X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=nfs%2Fnfs.c;fp=nfs%2Fnfs.c;h=576145bef0feef5a111b934ee73d0148ca90ad8b;hb=463d59bf8e5ff1a3ac27ab4fedf77b237394d1a6;hp=c3cebc47517090f07328ce06f106096c7541c132;hpb=21668dcef43e1416a93c1aa28304a19bf4a95389;p=deb_libnfs.git diff --git a/nfs/nfs.c b/nfs/nfs.c index c3cebc4..576145b 100644 --- a/nfs/nfs.c +++ b/nfs/nfs.c @@ -103,18 +103,21 @@ int nfsstat3_to_errno(int error) } -int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) +/* + * NFSv3 + */ +int rpc_nfs3_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/null call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/NULL call"); return -1; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/null call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/NULL call"); rpc_free_pdu(rpc, pdu); return -2; } @@ -122,28 +125,29 @@ int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) return 0; } -int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) +{ + return rpc_nfs3_null_async(rpc, cb, private_data); +} + +int rpc_nfs3_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct GETATTR3args *args, void *private_data) { struct rpc_pdu *pdu; - GETATTR3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_GETATTR, cb, private_data, (zdrproc_t)zdr_GETATTR3res, sizeof(GETATTR3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/null call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/GETATTR call"); return -1; } - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - - if (zdr_GETATTR3args(&pdu->zdr, &args) == 0) { + if (zdr_GETATTR3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode GETATTR3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/getattr call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/GETATTR call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -151,28 +155,35 @@ int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh return 0; } -int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +{ + GETATTR3args args; + + memset(&args, 0, sizeof(GETATTR3args)); + args.object.data.data_len = fh->data.data_len; + args.object.data.data_val = fh->data.data_val; + + return rpc_nfs3_getattr_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct PATHCONF3args *args, void *private_data) { struct rpc_pdu *pdu; - PATHCONF3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_PATHCONF, cb, private_data, (zdrproc_t)zdr_PATHCONF3res, sizeof(PATHCONF3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/pathconf call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/PATHCONF call"); return -1; } - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - - if (zdr_PATHCONF3args(&pdu->zdr, &args) == 0) { + if (zdr_PATHCONF3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode PATHCONF3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/pathconf call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/PATHCONF call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -180,29 +191,35 @@ int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *f return 0; } -int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *name, void *private_data) +int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +{ + PATHCONF3args args; + + memset(&args, 0, sizeof(PATHCONF3args)); + args.object.data.data_len = fh->data.data_len; + args.object.data.data_val = fh->data.data_val; + + return rpc_nfs3_pathconf_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct LOOKUP3args *args, void *private_data) { struct rpc_pdu *pdu; - LOOKUP3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LOOKUP, cb, private_data, (zdrproc_t)zdr_LOOKUP3res, sizeof(LOOKUP3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/lookup call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LOOKUP call"); return -1; } - args.what.dir.data.data_len = fh->data.data_len; - args.what.dir.data.data_val = fh->data.data_val; - args.what.name = name; - - if (zdr_LOOKUP3args(&pdu->zdr, &args) == 0) { + if (zdr_LOOKUP3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode LOOKUP3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/lookup call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LOOKUP call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -210,30 +227,36 @@ int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } +int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *name, void *private_data) +{ + LOOKUP3args args; -int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, int access, void *private_data) + memset(&args, 0, sizeof(LOOKUP3args)); + args.what.dir.data.data_len = fh->data.data_len; + args.what.dir.data.data_val = fh->data.data_val; + args.what.name = name; + + return rpc_nfs3_lookup_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_access_async(struct rpc_context *rpc, rpc_cb cb, struct ACCESS3args *args, void *private_data) { struct rpc_pdu *pdu; - ACCESS3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_ACCESS, cb, private_data, (zdrproc_t)zdr_ACCESS3res, sizeof(ACCESS3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/access call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/ACCESS call"); return -1; } - args.object.data.data_len = fh->data.data_len; - args.object.data.data_val = fh->data.data_val; - args.access = access; - - if (zdr_ACCESS3args(&pdu->zdr, &args) == 0) { + if (zdr_ACCESS3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode ACCESS3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/access call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/ACCESS call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -241,32 +264,36 @@ int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } +int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, int access, void *private_data) +{ + ACCESS3args args; + + memset(&args, 0, sizeof(ACCESS3args)); + args.object.data.data_len = fh->data.data_len; + args.object.data.data_val = fh->data.data_val; + args.access = access; + return rpc_nfs3_access_async(rpc, cb, &args, private_data); +} -int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t offset, uint64_t count, void *private_data) +int rpc_nfs3_read_async(struct rpc_context *rpc, rpc_cb cb, struct READ3args *args, void *private_data) { struct rpc_pdu *pdu; - READ3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READ, cb, private_data, (zdrproc_t)zdr_READ3res, sizeof(READ3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/read call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READ call"); return -1; } - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = offset; - args.count = count; - - if (zdr_READ3args(&pdu->zdr, &args) == 0) { + if (zdr_READ3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode READ3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/read call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READ call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -274,34 +301,37 @@ int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, u return 0; } +int rpc_nfs_read_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, uint64_t offset, uint64_t count, void *private_data) +{ + READ3args args; -int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *buf, uint64_t offset, uint64_t count, int stable_how, void *private_data) + memset(&args, 0, sizeof(READ3args)); + args.file.data.data_len = fh->data.data_len; + args.file.data.data_val = fh->data.data_val; + args.offset = offset; + args.count = count; + + return rpc_nfs3_read_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_write_async(struct rpc_context *rpc, rpc_cb cb, struct WRITE3args *args, void *private_data) { struct rpc_pdu *pdu; - WRITE3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_WRITE, cb, private_data, (zdrproc_t)zdr_WRITE3res, sizeof(WRITE3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/write call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/WRITE call"); return -1; } - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = offset; - args.count = count; - args.stable = stable_how; - args.data.data_len = count; - args.data.data_val = buf; - - if (zdr_WRITE3args(&pdu->zdr, &args) == 0) { + if (zdr_WRITE3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode WRITE3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/write call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/WRITE call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -309,32 +339,40 @@ int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } +int rpc_nfs_write_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *buf, uint64_t offset, uint64_t count, int stable_how, void *private_data) +{ + WRITE3args args; + + memset(&args, 0, sizeof(WRITE3args)); + args.file.data.data_len = fh->data.data_len; + args.file.data.data_val = fh->data.data_val; + args.offset = offset; + args.count = count; + args.stable = stable_how; + args.data.data_len = count; + args.data.data_val = buf; + return rpc_nfs3_write_async(rpc, cb, &args, private_data); +} -int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +int rpc_nfs3_commit_async(struct rpc_context *rpc, rpc_cb cb, struct COMMIT3args *args, void *private_data) { struct rpc_pdu *pdu; - COMMIT3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_COMMIT, cb, private_data, (zdrproc_t)zdr_COMMIT3res, sizeof(COMMIT3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/commit call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/COMMIT call"); return -1; } - args.file.data.data_len = fh->data.data_len; - args.file.data.data_val = fh->data.data_val; - args.offset = 0; - args.count = 0; - - if (zdr_COMMIT3args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode WRITE3args"); + if (zdr_COMMIT3args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode COMMIT3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/commit call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/COMMIT call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -342,14 +380,26 @@ int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } +int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +{ + COMMIT3args args; -int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data) + memset(&args, 0, sizeof(COMMIT3args)); + args.file.data.data_len = fh->data.data_len; + args.file.data.data_val = fh->data.data_val; + args.offset = 0; + args.count = 0; + + return rpc_nfs3_commit_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SETATTR, cb, private_data, (zdrproc_t)zdr_SETATTR3res, sizeof(SETATTR3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/setattr call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SETATTR call"); return -1; } @@ -360,7 +410,7 @@ int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/setattr call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SETATTR call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -368,15 +418,18 @@ int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args return 0; } +int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data) +{ + return rpc_nfs3_setattr_async(rpc, cb, args, private_data); +} - -int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data) +int rpc_nfs3_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKDIR, cb, private_data, (zdrproc_t)zdr_MKDIR3res, sizeof(MKDIR3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/setattr call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKDIR call"); return -1; } @@ -387,7 +440,7 @@ int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, vo } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/mkdir call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKDIR call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -395,33 +448,29 @@ int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, vo return 0; } +int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data) +{ + return rpc_nfs3_mkdir_async(rpc, cb, args, private_data); +} - - -int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data) +int rpc_nfs3_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct RMDIR3args *args, void *private_data) { struct rpc_pdu *pdu; - RMDIR3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RMDIR, cb, private_data, (zdrproc_t)zdr_RMDIR3res, sizeof(RMDIR3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rmdir call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RMDIR call"); return -1; } - memset(&args, 0, sizeof(RMDIR3args)); - args.object.dir.data.data_len = fh->data.data_len; - args.object.dir.data.data_val = fh->data.data_val; - args.object.name = dir; - - if (zdr_RMDIR3args(&pdu->zdr, &args) == 0) { + if (zdr_RMDIR3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode RMDIR3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rmdir call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RMDIR call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -429,15 +478,25 @@ int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } +int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data) +{ + RMDIR3args args; + + memset(&args, 0, sizeof(RMDIR3args)); + args.object.dir.data.data_len = fh->data.data_len; + args.object.dir.data.data_val = fh->data.data_val; + args.object.name = dir; + return rpc_nfs3_rmdir_async(rpc, cb, &args, private_data); +} -int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data) +int rpc_nfs3_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_CREATE, cb, private_data, (zdrproc_t)zdr_CREATE3res, sizeof(CREATE3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/create call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/CREATE call"); return -1; } @@ -448,7 +507,7 @@ int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/create call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/CREATE call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -456,23 +515,45 @@ int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, return 0; } +int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data) +{ + return rpc_nfs3_create_async(rpc, cb, args, private_data); +} - -int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, int mode, int major, int minor, void *private_data) +int rpc_nfs3_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct MKNOD3args *args, void *private_data) { struct rpc_pdu *pdu; - MKNOD3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKNOD, cb, private_data, (zdrproc_t)zdr_MKNOD3res, sizeof(MKNOD3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/mknod call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKNOD call"); return -1; } + if (zdr_MKNOD3args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode MKNOD3args"); + rpc_free_pdu(rpc, pdu); + return -2; + } + + if (rpc_queue_pdu(rpc, pdu) != 0) { + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKNOD call"); + rpc_free_pdu(rpc, pdu); + return -3; + } + + return 0; +} + +int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, int mode, int major, int minor, void *private_data) +{ + MKNOD3args args; + memset(&args, 0, sizeof(MKNOD3args)); args.where.dir.data.data_len = fh->data.data_len; args.where.dir.data.data_val = fh->data.data_val; args.where.name = file; + switch (mode & S_IFMT) { case S_IFCHR: args.what.type = NF3CHR; @@ -498,19 +579,31 @@ int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, args.what.mknoddata3_u.pipe_attributes.mode.set_mode3_u.mode = mode & (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); break; default: - rpc_set_error(rpc, "Invalid file type for nfs/mknod call"); - rpc_free_pdu(rpc, pdu); + rpc_set_error(rpc, "Invalid file type for NFS3/MKNOD call"); return -1; } - if (zdr_MKNOD3args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode MKNOD3args"); + return rpc_nfs3_mknod_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_remove_async(struct rpc_context *rpc, rpc_cb cb, struct REMOVE3args *args, void *private_data) +{ + struct rpc_pdu *pdu; + + pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE3res, sizeof(REMOVE3res)); + if (pdu == NULL) { + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/REMOVE call"); + return -1; + } + + if (zdr_REMOVE3args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/mknod call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/REMOVE call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -518,31 +611,36 @@ int rpc_nfs_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } - int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, void *private_data) { - struct rpc_pdu *pdu; REMOVE3args args; - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE3res, sizeof(REMOVE3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/remove call"); - return -1; - } - memset(&args, 0, sizeof(REMOVE3args)); args.object.dir.data.data_len = fh->data.data_len; args.object.dir.data.data_val = fh->data.data_val; args.object.name = file; - if (zdr_REMOVE3args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE3args"); + return rpc_nfs3_remove_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct READDIR3args *args, void *private_data) +{ + struct rpc_pdu *pdu; + + pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR3res, sizeof(READDIR3res)); + if (pdu == NULL) { + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIR call"); + return -1; + } + + if (zdr_READDIR3args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode READDIR3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/remove call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIR call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -552,15 +650,8 @@ int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, 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) { - struct rpc_pdu *pdu; READDIR3args args; - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR3res, sizeof(READDIR3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdir call"); - return -1; - } - memset(&args, 0, sizeof(READDIR3args)); args.dir.data.data_len = fh->data.data_len; args.dir.data.data_val = fh->data.data_val; @@ -568,14 +659,27 @@ int rpc_nfs_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3)); args.count = count; - if (zdr_READDIR3args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READDIR3args"); + return rpc_nfs3_readdir_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct READDIRPLUS3args *args, void *private_data) +{ + struct rpc_pdu *pdu; + + pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (zdrproc_t)zdr_READDIRPLUS3res, sizeof(READDIRPLUS3res)); + if (pdu == NULL) { + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIRPLUS call"); + return -1; + } + + if (zdr_READDIRPLUS3args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode READDIRPLUS3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdir call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIRPLUS call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -585,15 +689,8 @@ int rpc_nfs_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh 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) { - struct rpc_pdu *pdu; READDIRPLUS3args args; - pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (zdrproc_t)zdr_READDIRPLUS3res, sizeof(READDIRPLUS3res)); - if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdirplus call"); - return -1; - } - memset(&args, 0, sizeof(READDIRPLUS3args)); args.dir.data.data_len = fh->data.data_len; args.dir.data.data_val = fh->data.data_val; @@ -602,43 +699,27 @@ int rpc_nfs_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 args.dircount = count; args.maxcount = count; - if (zdr_READDIRPLUS3args(&pdu->zdr, &args) == 0) { - rpc_set_error(rpc, "ZDR error: Failed to encode READDIRPLUS3args"); - rpc_free_pdu(rpc, pdu); - return -2; - } - - if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdirplus call"); - rpc_free_pdu(rpc, pdu); - return -3; - } - - return 0; + return rpc_nfs3_readdirplus_async(rpc, cb, &args, private_data); } -int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +int rpc_nfs3_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct FSSTAT3args *args, void *private_data) { struct rpc_pdu *pdu; - FSSTAT3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSSTAT, cb, private_data, (zdrproc_t)zdr_FSSTAT3res, sizeof(FSSTAT3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsstat call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSSTAT call"); return -1; } - args.fsroot.data.data_len = fh->data.data_len; - args.fsroot.data.data_val = fh->data.data_val; - - if (zdr_FSSTAT3args(&pdu->zdr, &args) == 0) { + if (zdr_FSSTAT3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode FSSTAT3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsstat call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSSTAT call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -646,28 +727,35 @@ int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } -int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +{ + FSSTAT3args args; + + memset(&args, 0, sizeof(FSSTAT3args)); + args.fsroot.data.data_len = fh->data.data_len; + args.fsroot.data.data_val = fh->data.data_val; + + return rpc_nfs3_fsstat_async(rpc, cb, &args, private_data); +} + +int rpc_nfs3_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct FSINFO3args *args, void *private_data) { struct rpc_pdu *pdu; - FSINFO3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSINFO, cb, private_data, (zdrproc_t)zdr_FSINFO3res, sizeof(FSINFO3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsinfo call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSINFO call"); return -1; } - args.fsroot.data.data_len = fh->data.data_len; - args.fsroot.data.data_val = fh->data.data_val; - - if (zdr_FSINFO3args(&pdu->zdr, &args) == 0) { + if (zdr_FSINFO3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode FSINFO3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsinfo call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSINFO call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -675,13 +763,24 @@ int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, return 0; } -int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data) +int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data) +{ + FSINFO3args args; + + memset(&args, 0, sizeof(FSINFO3args)); + args.fsroot.data.data_len = fh->data.data_len; + args.fsroot.data.data_val = fh->data.data_val; + + return rpc_nfs3_fsinfo_async(rpc, cb, fh, private_data); +} + +int rpc_nfs3_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READLINK, cb, private_data, (zdrproc_t)zdr_READLINK3res, sizeof(READLINK3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readlink call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READLINK call"); return -1; } @@ -692,7 +791,7 @@ int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *ar } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readlink call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READLINK call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -700,14 +799,18 @@ int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *ar return 0; } +int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data) +{ + return rpc_nfs3_readlink_async(rpc, cb, args, private_data); +} -int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data) +int rpc_nfs3_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data) { struct rpc_pdu *pdu; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SYMLINK, cb, private_data, (zdrproc_t)zdr_SYMLINK3res, sizeof(SYMLINK3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/symlink call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SYMLINK call"); return -1; } @@ -718,7 +821,7 @@ int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/symlink call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SYMLINK call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -726,36 +829,29 @@ int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args return 0; } +int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data) +{ + return rpc_nfs3_symlink_async(rpc, cb, args, private_data); +} - - -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) +int rpc_nfs3_rename_async(struct rpc_context *rpc, rpc_cb cb, struct RENAME3args *args, void *private_data) { struct rpc_pdu *pdu; - RENAME3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RENAME, cb, private_data, (zdrproc_t)zdr_RENAME3res, sizeof(RENAME3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rename call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RENAME call"); return -1; } - memset(&args, 0, sizeof(RENAME3args)); - args.from.dir.data.data_len = olddir->data.data_len; - args.from.dir.data.data_val = olddir->data.data_val; - args.from.name = oldname; - args.to.dir.data.data_len = newdir->data.data_len; - args.to.dir.data.data_val = newdir->data.data_val; - args.to.name = newname; - - if (zdr_RENAME3args(&pdu->zdr, &args) == 0) { + if (zdr_RENAME3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode RENAME3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rename call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RENAME call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -763,35 +859,39 @@ int rpc_nfs_rename_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *old return 0; } +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) +{ + RENAME3args args; + memset(&args, 0, sizeof(RENAME3args)); + args.from.dir.data.data_len = olddir->data.data_len; + args.from.dir.data.data_val = olddir->data.data_val; + args.from.name = oldname; + args.to.dir.data.data_len = newdir->data.data_len; + args.to.dir.data.data_val = newdir->data.data_val; + args.to.name = newname; + return rpc_nfs3_rename_async(rpc, cb, &args, private_data); +} -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) +int rpc_nfs3_link_async(struct rpc_context *rpc, rpc_cb cb, struct LINK3args *args, void *private_data) { struct rpc_pdu *pdu; - LINK3args args; pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LINK, cb, private_data, (zdrproc_t)zdr_LINK3res, sizeof(LINK3res)); if (pdu == NULL) { - rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/link call"); + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LINK call"); return -1; } - memset(&args, 0, sizeof(LINK3args)); - args.file.data.data_len = file->data.data_len; - args.file.data.data_val = file->data.data_val; - args.link.dir.data.data_len = newdir->data.data_len; - args.link.dir.data.data_val = newdir->data.data_val; - args.link.name = newname; - - if (zdr_LINK3args(&pdu->zdr, &args) == 0) { + if (zdr_LINK3args(&pdu->zdr, args) == 0) { rpc_set_error(rpc, "ZDR error: Failed to encode LINK3args"); rpc_free_pdu(rpc, pdu); return -2; } if (rpc_queue_pdu(rpc, pdu) != 0) { - rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/link call"); + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LINK call"); rpc_free_pdu(rpc, pdu); return -3; } @@ -799,6 +899,19 @@ int rpc_nfs_link_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *file, return 0; } +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) +{ + LINK3args args; + + memset(&args, 0, sizeof(LINK3args)); + args.file.data.data_len = file->data.data_len; + args.file.data.data_val = file->data.data_val; + args.link.dir.data.data_len = newdir->data.data_len; + args.link.dir.data.data_val = newdir->data.data_val; + args.link.name = newname; + + return rpc_nfs3_link_async(rpc, cb, &args, private_data); +}