nfs/nfs.c

   1 /*
   2    Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as published by
   6    the Free Software Foundation; either version 2.1 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program; if not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #if defined(WIN32)
  19 #include <winsock2.h>
  20 #define S_IRUSR 0000400
  21 #define S_IWUSR 0000200
  22 #define S_IXUSR 0000100
  23 #define S_IRGRP 0000040
  24 #define S_IWGRP 0000020
  25 #define S_IXGRP 0000010
  26 #define S_IROTH 0000004
  27 #define S_IWOTH 0000002
  28 #define S_IXOTH 0000001
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <errno.h>
  33 #include <sys/stat.h>
  34 #include <string.h>
  35 #include <rpc/rpc.h>
  36 #include <rpc/xdr.h>
  37 #include "libnfs.h"
  38 #include "libnfs-raw.h"
  39 #include "libnfs-private.h"
  40 #include "libnfs-raw-nfs.h"
  41
  42
  43
  44 char *nfsstat3_to_str(int error)
  45 {
  46         switch (error) {
  47         case NFS3_OK: return "NFS3_OK"; break;
  48         case NFS3ERR_PERM: return "NFS3ERR_PERM"; break;
  49         case NFS3ERR_NOENT: return "NFS3ERR_NOENT"; break;
  50         case NFS3ERR_IO: return "NFS3ERR_IO"; break;
  51         case NFS3ERR_NXIO: return "NFS3ERR_NXIO"; break;
  52         case NFS3ERR_ACCES: return "NFS3ERR_ACCES"; break;
  53         case NFS3ERR_EXIST: return "NFS3ERR_EXIST"; break;
  54         case NFS3ERR_XDEV: return "NFS3ERR_XDEV"; break;
  55         case NFS3ERR_NODEV: return "NFS3ERR_NODEV"; break;
  56         case NFS3ERR_NOTDIR: return "NFS3ERR_NOTDIR"; break;
  57         case NFS3ERR_ISDIR: return "NFS3ERR_ISDIR"; break;
  58         case NFS3ERR_INVAL: return "NFS3ERR_INVAL"; break;
  59         case NFS3ERR_FBIG: return "NFS3ERR_FBIG"; break;
  60         case NFS3ERR_NOSPC: return "NFS3ERR_NOSPC"; break;
  61         case NFS3ERR_ROFS: return "NFS3ERR_ROFS"; break;
  62         case NFS3ERR_MLINK: return "NFS3ERR_MLINK"; break;
  63         case NFS3ERR_NAMETOOLONG: return "NFS3ERR_NAMETOOLONG"; break;
  64         case NFS3ERR_NOTEMPTY: return "NFS3ERR_NOTEMPTY"; break;
  65         case NFS3ERR_DQUOT: return "NFS3ERR_DQUOT"; break;
  66         case NFS3ERR_STALE: return "NFS3ERR_STALE"; break;
  67         case NFS3ERR_REMOTE: return "NFS3ERR_REMOTE"; break;
  68         case NFS3ERR_BADHANDLE: return "NFS3ERR_BADHANDLE"; break;
  69         case NFS3ERR_NOT_SYNC: return "NFS3ERR_NOT_SYNC"; break;
  70         case NFS3ERR_BAD_COOKIE: return "NFS3ERR_BAD_COOKIE"; break;
  71         case NFS3ERR_NOTSUPP: return "NFS3ERR_NOTSUPP"; break;
  72         case NFS3ERR_TOOSMALL: return "NFS3ERR_TOOSMALL"; break;
  73         case NFS3ERR_SERVERFAULT: return "NFS3ERR_SERVERFAULT"; break;
  74         case NFS3ERR_BADTYPE: return "NFS3ERR_BADTYPE"; break;
  75         case NFS3ERR_JUKEBOX: return "NFS3ERR_JUKEBOX"; break;
  76         };
  77         return "unknown nfs error";
  78 }
  79
  80 int nfsstat3_to_errno(int error)
  81 {
  82         switch (error) {
  83         case NFS3_OK:             return 0; break;
  84         case NFS3ERR_PERM:        return -EPERM; break;
  85         case NFS3ERR_NOENT:       return -ENOENT; break;
  86         case NFS3ERR_IO:          return -EIO; break;
  87         case NFS3ERR_NXIO:        return -ENXIO; break;
  88         case NFS3ERR_ACCES:       return -EACCES; break;
  89         case NFS3ERR_EXIST:       return -EEXIST; break;
  90         case NFS3ERR_XDEV:        return -EXDEV; break;
  91         case NFS3ERR_NODEV:       return -ENODEV; break;
  92         case NFS3ERR_NOTDIR:      return -ENOTDIR; break;
  93         case NFS3ERR_ISDIR:       return -EISDIR; break;
  94         case NFS3ERR_INVAL:       return -EINVAL; break;
  95         case NFS3ERR_FBIG:        return -EFBIG; break;
  96         case NFS3ERR_NOSPC:       return -ENOSPC; break;
  97         case NFS3ERR_ROFS:        return -EROFS; break;
  98         case NFS3ERR_MLINK:       return -EMLINK; break;
  99         case NFS3ERR_NAMETOOLONG: return -ENAMETOOLONG; break;
 100         case NFS3ERR_NOTEMPTY:    return -EEXIST; break;
 101         case NFS3ERR_DQUOT:       return -ERANGE; break;
 102         case NFS3ERR_STALE:       return -EIO; break;
 103         case NFS3ERR_REMOTE:      return -EIO; break;
 104         case NFS3ERR_BADHANDLE:   return -EIO; break;
 105         case NFS3ERR_NOT_SYNC:    return -EIO; break;
 106         case NFS3ERR_BAD_COOKIE:  return -EIO; break;
 107         case NFS3ERR_NOTSUPP:     return -EINVAL; break;
 108         case NFS3ERR_TOOSMALL:    return -EIO; break;
 109         case NFS3ERR_SERVERFAULT: return -EIO; break;
 110         case NFS3ERR_BADTYPE:     return -EINVAL; break;
 111         case NFS3ERR_JUKEBOX:     return -EAGAIN; break;
 112         };
 113         return -ERANGE;
 114 }
 115
 116
 117 int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
 118 {
 119         struct rpc_pdu *pdu;
 120
 121         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_NULL, cb, private_data, (xdrproc_t)xdr_void, 0);
 122         if (pdu == NULL) {
 123                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/null call");
 124                 return -1;
 125         }
 126
 127         if (rpc_queue_pdu(rpc, pdu) != 0) {
 128                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/null call");
 129                 rpc_free_pdu(rpc, pdu);
 130                 return -2;
 131         }
 132
 133         return 0;
 134 }
 135
 136 int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
 137 {
 138         struct rpc_pdu *pdu;
 139         GETATTR3args args;
 140
 141         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_GETATTR, cb, private_data, (xdrproc_t)xdr_GETATTR3res, sizeof(GETATTR3res));
 142         if (pdu == NULL) {
 143                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/null call");
 144                 return -1;
 145         }
 146
 147         args.object.data.data_len = fh->data.data_len;
 148         args.object.data.data_val = fh->data.data_val;
 149
 150         if (xdr_GETATTR3args(&pdu->xdr, &args) == 0) {
 151                 rpc_set_error(rpc, "XDR error: Failed to encode GETATTR3args");
 152                 rpc_free_pdu(rpc, pdu);
 153                 return -2;
 154         }
 155
 156         if (rpc_queue_pdu(rpc, pdu) != 0) {
 157                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/null call");
 158                 rpc_free_pdu(rpc, pdu);
 159                 return -3;
 160         }
 161
 162         return 0;
 163 }
 164
 165 int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *name, void *private_data)
 166 {
 167         struct rpc_pdu *pdu;
 168         LOOKUP3args args;
 169
 170         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LOOKUP, cb, private_data, (xdrproc_t)xdr_LOOKUP3res, sizeof(LOOKUP3res));
 171         if (pdu == NULL) {
 172                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/lookup call");
 173                 return -1;
 174         }
 175
 176         args.what.dir.data.data_len = fh->data.data_len;
 177         args.what.dir.data.data_val = fh->data.data_val;
 178         args.what.name              = name;
 179
 180         if (xdr_LOOKUP3args(&pdu->xdr, &args) == 0) {
 181                 rpc_set_error(rpc, "XDR error: Failed to encode LOOKUP3args");
 182                 rpc_free_pdu(rpc, pdu);
 183                 return -2;
 184         }
 185
 186         if (rpc_queue_pdu(rpc, pdu) != 0) {
 187                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/lookup call");
 188                 rpc_free_pdu(rpc, pdu);
 189                 return -3;
 190         }
 191
 192         return 0;
 193 }
 194
 195
 196 int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, int access, void *private_data)
 197 {
 198         struct rpc_pdu *pdu;
 199         ACCESS3args args;
 200
 201         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_ACCESS, cb, private_data, (xdrproc_t)xdr_ACCESS3res, sizeof(ACCESS3res));
 202         if (pdu == NULL) {
 203                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/access call");
 204                 return -1;
 205         }
 206
 207         args.object.data.data_len = fh->data.data_len;
 208         args.object.data.data_val = fh->data.data_val;
 209         args.access = access;
 210
 211         if (xdr_ACCESS3args(&pdu->xdr, &args) == 0) {
 212                 rpc_set_error(rpc, "XDR error: Failed to encode ACCESS3args");
 213                 rpc_free_pdu(rpc, pdu);
 214                 return -2;
 215         }
 216
 217         if (rpc_queue_pdu(rpc, pdu) != 0) {
 218                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/access call");
 219                 rpc_free_pdu(rpc, pdu);
 220                 return -3;
 221         }
 222
 223         return 0;
 224 }
 225
 226
 227
 228 int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, off_t offset, size_t count, void *private_data)
 229 {
 230         struct rpc_pdu *pdu;
 231         READ3args args;
 232
 233         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READ, cb, private_data, (xdrproc_t)xdr_READ3res, sizeof(READ3res));
 234         if (pdu == NULL) {
 235                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/read call");
 236                 return -1;
 237         }
 238
 239         args.file.data.data_len = fh->data.data_len;
 240         args.file.data.data_val = fh->data.data_val;
 241         args.offset = offset;
 242         args.count = count;
 243
 244         if (xdr_READ3args(&pdu->xdr, &args) == 0) {
 245                 rpc_set_error(rpc, "XDR error: Failed to encode READ3args");
 246                 rpc_free_pdu(rpc, pdu);
 247                 return -2;
 248         }
 249
 250         if (rpc_queue_pdu(rpc, pdu) != 0) {
 251                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/read call");
 252                 rpc_free_pdu(rpc, pdu);
 253                 return -3;
 254         }
 255
 256         return 0;
 257 }
 258
 259
 260 int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *buf, off_t offset, size_t count, int stable_how, void *private_data)
 261 {
 262         struct rpc_pdu *pdu;
 263         WRITE3args args;
 264
 265         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_WRITE, cb, private_data, (xdrproc_t)xdr_WRITE3res, sizeof(WRITE3res));
 266         if (pdu == NULL) {
 267                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/write call");
 268                 return -1;
 269         }
 270
 271         args.file.data.data_len = fh->data.data_len;
 272         args.file.data.data_val = fh->data.data_val;
 273         args.offset = offset;
 274         args.count  = count;
 275         args.stable = stable_how;;
 276         args.data.data_len = count;
 277         args.data.data_val = buf;
 278
 279         if (xdr_WRITE3args(&pdu->xdr, &args) == 0) {
 280                 rpc_set_error(rpc, "XDR error: Failed to encode WRITE3args");
 281                 rpc_free_pdu(rpc, pdu);
 282                 return -2;
 283         }
 284
 285         if (rpc_queue_pdu(rpc, pdu) != 0) {
 286                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/write call");
 287                 rpc_free_pdu(rpc, pdu);
 288                 return -3;
 289         }
 290
 291         return 0;
 292 }
 293
 294
 295
 296 int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
 297 {
 298         struct rpc_pdu *pdu;
 299         COMMIT3args args;
 300
 301         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_COMMIT, cb, private_data, (xdrproc_t)xdr_COMMIT3res, sizeof(COMMIT3res));
 302         if (pdu == NULL) {
 303                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/commit call");
 304                 return -1;
 305         }
 306
 307         args.file.data.data_len = fh->data.data_len;
 308         args.file.data.data_val = fh->data.data_val;
 309         args.offset = 0;
 310         args.count  = 0;
 311
 312         if (xdr_COMMIT3args(&pdu->xdr, &args) == 0) {
 313                 rpc_set_error(rpc, "XDR error: Failed to encode WRITE3args");
 314                 rpc_free_pdu(rpc, pdu);
 315                 return -2;
 316         }
 317
 318         if (rpc_queue_pdu(rpc, pdu) != 0) {
 319                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/commit call");
 320                 rpc_free_pdu(rpc, pdu);
 321                 return -3;
 322         }
 323
 324         return 0;
 325 }
 326
 327
 328 int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data)
 329 {
 330         struct rpc_pdu *pdu;
 331
 332         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SETATTR, cb, private_data, (xdrproc_t)xdr_SETATTR3res, sizeof(SETATTR3res));
 333         if (pdu == NULL) {
 334                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/setattr call");
 335                 return -1;
 336         }
 337
 338         if (xdr_SETATTR3args(&pdu->xdr, args) == 0) {
 339                 rpc_set_error(rpc, "XDR error: Failed to encode SETATTR3args");
 340                 rpc_free_pdu(rpc, pdu);
 341                 return -2;
 342         }
 343
 344         if (rpc_queue_pdu(rpc, pdu) != 0) {
 345                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/setattr call");
 346                 rpc_free_pdu(rpc, pdu);
 347                 return -3;
 348         }
 349
 350         return 0;
 351 }
 352
 353
 354
 355 int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data)
 356 {
 357         struct rpc_pdu *pdu;
 358         MKDIR3args args;
 359
 360         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKDIR, cb, private_data, (xdrproc_t)xdr_MKDIR3res, sizeof(MKDIR3res));
 361         if (pdu == NULL) {
 362                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/setattr call");
 363                 return -1;
 364         }
 365
 366         bzero(&args, sizeof(MKDIR3args));
 367         args.where.dir.data.data_len = fh->data.data_len;
 368         args.where.dir.data.data_val = fh->data.data_val;
 369         args.where.name = dir;
 370         args.attributes.mode.set_it = 1;
 371         args.attributes.mode.set_mode3_u.mode = 0755;
 372
 373         if (xdr_MKDIR3args(&pdu->xdr, &args) == 0) {
 374                 rpc_set_error(rpc, "XDR error: Failed to encode MKDIR3args");
 375                 rpc_free_pdu(rpc, pdu);
 376                 return -2;
 377         }
 378
 379         if (rpc_queue_pdu(rpc, pdu) != 0) {
 380                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/mkdir call");
 381                 rpc_free_pdu(rpc, pdu);
 382                 return -3;
 383         }
 384
 385         return 0;
 386 }
 387
 388
 389
 390
 391 int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data)
 392 {
 393         struct rpc_pdu *pdu;
 394         RMDIR3args args;
 395
 396         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RMDIR, cb, private_data, (xdrproc_t)xdr_RMDIR3res, sizeof(RMDIR3res));
 397         if (pdu == NULL) {
 398                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rmdir call");
 399                 return -1;
 400         }
 401
 402         bzero(&args, sizeof(RMDIR3args));
 403         args.object.dir.data.data_len = fh->data.data_len;
 404         args.object.dir.data.data_val = fh->data.data_val;
 405         args.object.name = dir;
 406
 407         if (xdr_RMDIR3args(&pdu->xdr, &args) == 0) {
 408                 rpc_set_error(rpc, "XDR error: Failed to encode RMDIR3args");
 409                 rpc_free_pdu(rpc, pdu);
 410                 return -2;
 411         }
 412
 413         if (rpc_queue_pdu(rpc, pdu) != 0) {
 414                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rmdir call");
 415                 rpc_free_pdu(rpc, pdu);
 416                 return -3;
 417         }
 418
 419         return 0;
 420 }
 421
 422
 423
 424 int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, int mode, void *private_data)
 425 {
 426         struct rpc_pdu *pdu;
 427         CREATE3args args;
 428
 429         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_CREATE, cb, private_data, (xdrproc_t)xdr_CREATE3res, sizeof(CREATE3res));
 430         if (pdu == NULL) {
 431                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/create call");
 432                 return -1;
 433         }
 434
 435         bzero(&args, sizeof(CREATE3args));
 436         args.where.dir.data.data_len = fh->data.data_len;
 437         args.where.dir.data.data_val = fh->data.data_val;
 438         args.where.name = file;
 439         args.how.mode = UNCHECKED;
 440         args.how.createhow3_u.obj_attributes.mode.set_it = 1;
 441         args.how.createhow3_u.obj_attributes.mode.set_mode3_u.mode = mode;
 442
 443         if (xdr_CREATE3args(&pdu->xdr, &args) == 0) {
 444                 rpc_set_error(rpc, "XDR error: Failed to encode CREATE3args");
 445                 rpc_free_pdu(rpc, pdu);
 446                 return -2;
 447         }
 448
 449         if (rpc_queue_pdu(rpc, pdu) != 0) {
 450                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/create call");
 451                 rpc_free_pdu(rpc, pdu);
 452                 return -3;
 453         }
 454
 455         return 0;
 456 }
 457
 458
 459
 460
 461 int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, void *private_data)
 462 {
 463         struct rpc_pdu *pdu;
 464         REMOVE3args args;
 465
 466         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (xdrproc_t)xdr_REMOVE3res, sizeof(REMOVE3res));
 467         if (pdu == NULL) {
 468                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/remove call");
 469                 return -1;
 470         }
 471
 472         bzero(&args, sizeof(REMOVE3args));
 473         args.object.dir.data.data_len = fh->data.data_len;
 474         args.object.dir.data.data_val = fh->data.data_val;
 475         args.object.name = file;
 476
 477         if (xdr_REMOVE3args(&pdu->xdr, &args) == 0) {
 478                 rpc_set_error(rpc, "XDR error: Failed to encode REMOVE3args");
 479                 rpc_free_pdu(rpc, pdu);
 480                 return -2;
 481         }
 482
 483         if (rpc_queue_pdu(rpc, pdu) != 0) {
 484                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/remove call");
 485                 rpc_free_pdu(rpc, pdu);
 486                 return -3;
 487         }
 488
 489         return 0;
 490 }
 491
 492 int rpc_nfs_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t cookie, char *cookieverf, int count, void *private_data)
 493 {
 494         struct rpc_pdu *pdu;
 495         READDIR3args args;
 496
 497         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (xdrproc_t)xdr_READDIR3res, sizeof(READDIR3res));
 498         if (pdu == NULL) {
 499                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdir call");
 500                 return -1;
 501         }
 502
 503         bzero(&args, sizeof(READDIR3args));
 504         args.dir.data.data_len = fh->data.data_len;
 505         args.dir.data.data_val = fh->data.data_val;
 506         args.cookie = cookie;
 507         memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
 508         args.count = count;
 509
 510         if (xdr_READDIR3args(&pdu->xdr, &args) == 0) {
 511                 rpc_set_error(rpc, "XDR error: Failed to encode READDIR3args");
 512                 rpc_free_pdu(rpc, pdu);
 513                 return -2;
 514         }
 515
 516         if (rpc_queue_pdu(rpc, pdu) != 0) {
 517                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdir call");
 518                 rpc_free_pdu(rpc, pdu);
 519                 return -3;
 520         }
 521
 522         return 0;
 523 }
 524
 525 int rpc_nfs_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t cookie, char *cookieverf, int count, void *private_data)
 526 {
 527         struct rpc_pdu *pdu;
 528         READDIRPLUS3args args;
 529
 530         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (xdrproc_t)xdr_READDIRPLUS3res, sizeof(READDIRPLUS3res));
 531         if (pdu == NULL) {
 532                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdirplus call");
 533                 return -1;
 534         }
 535
 536         bzero(&args, sizeof(READDIRPLUS3args));
 537         args.dir.data.data_len = fh->data.data_len;
 538         args.dir.data.data_val = fh->data.data_val;
 539         args.cookie = cookie;
 540         memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
 541         args.dircount = count;
 542         args.maxcount = count;
 543
 544         if (xdr_READDIRPLUS3args(&pdu->xdr, &args) == 0) {
 545                 rpc_set_error(rpc, "XDR error: Failed to encode READDIRPLUS3args");
 546                 rpc_free_pdu(rpc, pdu);
 547                 return -2;
 548         }
 549
 550         if (rpc_queue_pdu(rpc, pdu) != 0) {
 551                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdirplus call");
 552                 rpc_free_pdu(rpc, pdu);
 553                 return -3;
 554         }
 555
 556         return 0;
 557 }
 558
 559 int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
 560 {
 561         struct rpc_pdu *pdu;
 562         FSSTAT3args args;
 563
 564         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSSTAT, cb, private_data, (xdrproc_t)xdr_FSSTAT3res, sizeof(FSSTAT3res));
 565         if (pdu == NULL) {
 566                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsstat call");
 567                 return -1;
 568         }
 569
 570         args.fsroot.data.data_len = fh->data.data_len;
 571         args.fsroot.data.data_val = fh->data.data_val;
 572
 573         if (xdr_FSSTAT3args(&pdu->xdr, &args) == 0) {
 574                 rpc_set_error(rpc, "XDR error: Failed to encode FSSTAT3args");
 575                 rpc_free_pdu(rpc, pdu);
 576                 return -2;
 577         }
 578
 579         if (rpc_queue_pdu(rpc, pdu) != 0) {
 580                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsstat call");
 581                 rpc_free_pdu(rpc, pdu);
 582                 return -3;
 583         }
 584
 585         return 0;
 586 }
 587
 588 int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
 589 {
 590         struct rpc_pdu *pdu;
 591         FSINFO3args args;
 592
 593         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSINFO, cb, private_data, (xdrproc_t)xdr_FSINFO3res, sizeof(FSINFO3res));
 594         if (pdu == NULL) {
 595                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsinfo call");
 596                 return -1;
 597         }
 598
 599         args.fsroot.data.data_len = fh->data.data_len;
 600         args.fsroot.data.data_val = fh->data.data_val;
 601
 602         if (xdr_FSINFO3args(&pdu->xdr, &args) == 0) {
 603                 rpc_set_error(rpc, "XDR error: Failed to encode FSINFO3args");
 604                 rpc_free_pdu(rpc, pdu);
 605                 return -2;
 606         }
 607
 608         if (rpc_queue_pdu(rpc, pdu) != 0) {
 609                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsinfo call");
 610                 rpc_free_pdu(rpc, pdu);
 611                 return -3;
 612         }
 613
 614         return 0;
 615 }
 616
 617 int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
 618 {
 619         struct rpc_pdu *pdu;
 620         READLINK3args args;
 621
 622         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READLINK, cb, private_data, (xdrproc_t)xdr_READLINK3res, sizeof(READLINK3res));
 623         if (pdu == NULL) {
 624                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readlink call");
 625                 return -1;
 626         }
 627
 628         args.symlink.data.data_len = fh->data.data_len;
 629         args.symlink.data.data_val = fh->data.data_val;
 630
 631         if (xdr_READLINK3args(&pdu->xdr, &args) == 0) {
 632                 rpc_set_error(rpc, "XDR error: Failed to encode READLINK3args");
 633                 rpc_free_pdu(rpc, pdu);
 634                 return -2;
 635         }
 636
 637         if (rpc_queue_pdu(rpc, pdu) != 0) {
 638                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readlink call");
 639                 rpc_free_pdu(rpc, pdu);
 640                 return -3;
 641         }
 642
 643         return 0;
 644 }
 645
 646
 647 int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *newname, char *oldpath, void *private_data)
 648 {
 649         struct rpc_pdu *pdu;
 650         SYMLINK3args args;
 651
 652         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SYMLINK, cb, private_data, (xdrproc_t)xdr_SYMLINK3res, sizeof(SYMLINK3res));
 653         if (pdu == NULL) {
 654                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/symlink call");
 655                 return -1;
 656         }
 657
 658         bzero(&args, sizeof(SYMLINK3args));
 659         args.where.dir.data.data_len = fh->data.data_len;
 660         args.where.dir.data.data_val = fh->data.data_val;
 661         args.where.name = newname;
 662         args.symlink.symlink_attributes.mode.set_it = 1;
 663         args.symlink.symlink_attributes.mode.set_mode3_u.mode = S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH;
 664         args.symlink.symlink_data = oldpath;
 665
 666         if (xdr_SYMLINK3args(&pdu->xdr, &args) == 0) {
 667                 rpc_set_error(rpc, "XDR error: Failed to encode SYMLINK3args");
 668                 rpc_free_pdu(rpc, pdu);
 669                 return -2;
 670         }
 671
 672         if (rpc_queue_pdu(rpc, pdu) != 0) {
 673                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/symlink call");
 674                 rpc_free_pdu(rpc, pdu);
 675                 return -3;
 676         }
 677
 678         return 0;
 679 }
 680
 681
 682
 683
 684 int rpc_nfs_rename_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *olddir, char *oldname, struct nfs_fh3 *newdir, char *newname, void *private_data)
 685 {
 686         struct rpc_pdu *pdu;
 687         RENAME3args args;
 688
 689         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RENAME, cb, private_data, (xdrproc_t)xdr_RENAME3res, sizeof(RENAME3res));
 690         if (pdu == NULL) {
 691                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rename call");
 692                 return -1;
 693         }
 694
 695         bzero(&args, sizeof(RENAME3args));
 696         args.from.dir.data.data_len = olddir->data.data_len;
 697         args.from.dir.data.data_val = olddir->data.data_val;
 698         args.from.name = oldname;
 699         args.to.dir.data.data_len = newdir->data.data_len;
 700         args.to.dir.data.data_val = newdir->data.data_val;
 701         args.to.name = newname;
 702
 703         if (xdr_RENAME3args(&pdu->xdr, &args) == 0) {
 704                 rpc_set_error(rpc, "XDR error: Failed to encode RENAME3args");
 705                 rpc_free_pdu(rpc, pdu);
 706                 return -2;
 707         }
 708
 709         if (rpc_queue_pdu(rpc, pdu) != 0) {
 710                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rename call");
 711                 rpc_free_pdu(rpc, pdu);
 712                 return -3;
 713         }
 714
 715         return 0;
 716 }
 717
 718
 719
 720
 721 int rpc_nfs_link_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *file, struct nfs_fh3 *newdir, char *newname, void *private_data)
 722 {
 723         struct rpc_pdu *pdu;
 724         LINK3args args;
 725
 726         pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LINK, cb, private_data, (xdrproc_t)xdr_LINK3res, sizeof(LINK3res));
 727         if (pdu == NULL) {
 728                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/link call");
 729                 return -1;
 730         }
 731
 732         bzero(&args, sizeof(LINK3args));
 733         args.file.data.data_len = file->data.data_len;
 734         args.file.data.data_val = file->data.data_val;
 735         args.link.dir.data.data_len = newdir->data.data_len;
 736         args.link.dir.data.data_val = newdir->data.data_val;
 737         args.link.name = newname;
 738
 739         if (xdr_LINK3args(&pdu->xdr, &args) == 0) {
 740                 rpc_set_error(rpc, "XDR error: Failed to encode LINK3args");
 741                 rpc_free_pdu(rpc, pdu);
 742                 return -2;
 743         }
 744
 745         if (rpc_queue_pdu(rpc, pdu) != 0) {
 746                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/link call");
 747                 rpc_free_pdu(rpc, pdu);
 748                 return -3;
 749         }
 750
 751         return 0;
 752 }
 753
 754
 755
 756