c3cebc47517090f07328ce06f106096c7541c132
2 Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
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.
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.
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/>.
19 #include "win32_compat.h"
27 #include "libnfs-zdr.h"
29 #include "libnfs-raw.h"
30 #include "libnfs-private.h"
31 #include "libnfs-raw-nfs.h"
33 char *nfsstat3_to_str(int error
)
36 case NFS3_OK
: return "NFS3_OK"; break;
37 case NFS3ERR_PERM
: return "NFS3ERR_PERM"; break;
38 case NFS3ERR_NOENT
: return "NFS3ERR_NOENT"; break;
39 case NFS3ERR_IO
: return "NFS3ERR_IO"; break;
40 case NFS3ERR_NXIO
: return "NFS3ERR_NXIO"; break;
41 case NFS3ERR_ACCES
: return "NFS3ERR_ACCES"; break;
42 case NFS3ERR_EXIST
: return "NFS3ERR_EXIST"; break;
43 case NFS3ERR_XDEV
: return "NFS3ERR_XDEV"; break;
44 case NFS3ERR_NODEV
: return "NFS3ERR_NODEV"; break;
45 case NFS3ERR_NOTDIR
: return "NFS3ERR_NOTDIR"; break;
46 case NFS3ERR_ISDIR
: return "NFS3ERR_ISDIR"; break;
47 case NFS3ERR_INVAL
: return "NFS3ERR_INVAL"; break;
48 case NFS3ERR_FBIG
: return "NFS3ERR_FBIG"; break;
49 case NFS3ERR_NOSPC
: return "NFS3ERR_NOSPC"; break;
50 case NFS3ERR_ROFS
: return "NFS3ERR_ROFS"; break;
51 case NFS3ERR_MLINK
: return "NFS3ERR_MLINK"; break;
52 case NFS3ERR_NAMETOOLONG
: return "NFS3ERR_NAMETOOLONG"; break;
53 case NFS3ERR_NOTEMPTY
: return "NFS3ERR_NOTEMPTY"; break;
54 case NFS3ERR_DQUOT
: return "NFS3ERR_DQUOT"; break;
55 case NFS3ERR_STALE
: return "NFS3ERR_STALE"; break;
56 case NFS3ERR_REMOTE
: return "NFS3ERR_REMOTE"; break;
57 case NFS3ERR_BADHANDLE
: return "NFS3ERR_BADHANDLE"; break;
58 case NFS3ERR_NOT_SYNC
: return "NFS3ERR_NOT_SYNC"; break;
59 case NFS3ERR_BAD_COOKIE
: return "NFS3ERR_BAD_COOKIE"; break;
60 case NFS3ERR_NOTSUPP
: return "NFS3ERR_NOTSUPP"; break;
61 case NFS3ERR_TOOSMALL
: return "NFS3ERR_TOOSMALL"; break;
62 case NFS3ERR_SERVERFAULT
: return "NFS3ERR_SERVERFAULT"; break;
63 case NFS3ERR_BADTYPE
: return "NFS3ERR_BADTYPE"; break;
64 case NFS3ERR_JUKEBOX
: return "NFS3ERR_JUKEBOX"; break;
66 return "unknown nfs error";
69 int nfsstat3_to_errno(int error
)
72 case NFS3_OK
: return 0; break;
73 case NFS3ERR_PERM
: return -EPERM
; break;
74 case NFS3ERR_NOENT
: return -ENOENT
; break;
75 case NFS3ERR_IO
: return -EIO
; break;
76 case NFS3ERR_NXIO
: return -ENXIO
; break;
77 case NFS3ERR_ACCES
: return -EACCES
; break;
78 case NFS3ERR_EXIST
: return -EEXIST
; break;
79 case NFS3ERR_XDEV
: return -EXDEV
; break;
80 case NFS3ERR_NODEV
: return -ENODEV
; break;
81 case NFS3ERR_NOTDIR
: return -ENOTDIR
; break;
82 case NFS3ERR_ISDIR
: return -EISDIR
; break;
83 case NFS3ERR_INVAL
: return -EINVAL
; break;
84 case NFS3ERR_FBIG
: return -EFBIG
; break;
85 case NFS3ERR_NOSPC
: return -ENOSPC
; break;
86 case NFS3ERR_ROFS
: return -EROFS
; break;
87 case NFS3ERR_MLINK
: return -EMLINK
; break;
88 case NFS3ERR_NAMETOOLONG
: return -ENAMETOOLONG
; break;
89 case NFS3ERR_NOTEMPTY
: return -EEXIST
; break;
90 case NFS3ERR_DQUOT
: return -ERANGE
; break;
91 case NFS3ERR_STALE
: return -EIO
; break;
92 case NFS3ERR_REMOTE
: return -EIO
; break;
93 case NFS3ERR_BADHANDLE
: return -EIO
; break;
94 case NFS3ERR_NOT_SYNC
: return -EIO
; break;
95 case NFS3ERR_BAD_COOKIE
: return -EIO
; break;
96 case NFS3ERR_NOTSUPP
: return -EINVAL
; break;
97 case NFS3ERR_TOOSMALL
: return -EIO
; break;
98 case NFS3ERR_SERVERFAULT
: return -EIO
; break;
99 case NFS3ERR_BADTYPE
: return -EINVAL
; break;
100 case NFS3ERR_JUKEBOX
: return -EAGAIN
; break;
106 int rpc_nfs_null_async(struct rpc_context
*rpc
, rpc_cb cb
, void *private_data
)
110 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_NULL
, cb
, private_data
, (zdrproc_t
)zdr_void
, 0);
112 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/null call");
116 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
117 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/null call");
118 rpc_free_pdu(rpc
, pdu
);
125 int rpc_nfs_getattr_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, void *private_data
)
130 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_GETATTR
, cb
, private_data
, (zdrproc_t
)zdr_GETATTR3res
, sizeof(GETATTR3res
));
132 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/null call");
136 args
.object
.data
.data_len
= fh
->data
.data_len
;
137 args
.object
.data
.data_val
= fh
->data
.data_val
;
139 if (zdr_GETATTR3args(&pdu
->zdr
, &args
) == 0) {
140 rpc_set_error(rpc
, "ZDR error: Failed to encode GETATTR3args");
141 rpc_free_pdu(rpc
, pdu
);
145 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
146 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/getattr call");
147 rpc_free_pdu(rpc
, pdu
);
154 int rpc_nfs_pathconf_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, void *private_data
)
159 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_PATHCONF
, cb
, private_data
, (zdrproc_t
)zdr_PATHCONF3res
, sizeof(PATHCONF3res
));
161 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/pathconf call");
165 args
.object
.data
.data_len
= fh
->data
.data_len
;
166 args
.object
.data
.data_val
= fh
->data
.data_val
;
168 if (zdr_PATHCONF3args(&pdu
->zdr
, &args
) == 0) {
169 rpc_set_error(rpc
, "ZDR error: Failed to encode PATHCONF3args");
170 rpc_free_pdu(rpc
, pdu
);
174 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
175 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/pathconf call");
176 rpc_free_pdu(rpc
, pdu
);
183 int rpc_nfs_lookup_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, char *name
, void *private_data
)
188 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_LOOKUP
, cb
, private_data
, (zdrproc_t
)zdr_LOOKUP3res
, sizeof(LOOKUP3res
));
190 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/lookup call");
194 args
.what
.dir
.data
.data_len
= fh
->data
.data_len
;
195 args
.what
.dir
.data
.data_val
= fh
->data
.data_val
;
196 args
.what
.name
= name
;
198 if (zdr_LOOKUP3args(&pdu
->zdr
, &args
) == 0) {
199 rpc_set_error(rpc
, "ZDR error: Failed to encode LOOKUP3args");
200 rpc_free_pdu(rpc
, pdu
);
204 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
205 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/lookup call");
206 rpc_free_pdu(rpc
, pdu
);
214 int rpc_nfs_access_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, int access
, void *private_data
)
219 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_ACCESS
, cb
, private_data
, (zdrproc_t
)zdr_ACCESS3res
, sizeof(ACCESS3res
));
221 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/access call");
225 args
.object
.data
.data_len
= fh
->data
.data_len
;
226 args
.object
.data
.data_val
= fh
->data
.data_val
;
227 args
.access
= access
;
229 if (zdr_ACCESS3args(&pdu
->zdr
, &args
) == 0) {
230 rpc_set_error(rpc
, "ZDR error: Failed to encode ACCESS3args");
231 rpc_free_pdu(rpc
, pdu
);
235 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
236 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/access call");
237 rpc_free_pdu(rpc
, pdu
);
246 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
)
251 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_READ
, cb
, private_data
, (zdrproc_t
)zdr_READ3res
, sizeof(READ3res
));
253 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/read call");
257 args
.file
.data
.data_len
= fh
->data
.data_len
;
258 args
.file
.data
.data_val
= fh
->data
.data_val
;
259 args
.offset
= offset
;
262 if (zdr_READ3args(&pdu
->zdr
, &args
) == 0) {
263 rpc_set_error(rpc
, "ZDR error: Failed to encode READ3args");
264 rpc_free_pdu(rpc
, pdu
);
268 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
269 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/read call");
270 rpc_free_pdu(rpc
, pdu
);
278 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
)
283 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_WRITE
, cb
, private_data
, (zdrproc_t
)zdr_WRITE3res
, sizeof(WRITE3res
));
285 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/write call");
289 args
.file
.data
.data_len
= fh
->data
.data_len
;
290 args
.file
.data
.data_val
= fh
->data
.data_val
;
291 args
.offset
= offset
;
293 args
.stable
= stable_how
;
294 args
.data
.data_len
= count
;
295 args
.data
.data_val
= buf
;
297 if (zdr_WRITE3args(&pdu
->zdr
, &args
) == 0) {
298 rpc_set_error(rpc
, "ZDR error: Failed to encode WRITE3args");
299 rpc_free_pdu(rpc
, pdu
);
303 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
304 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/write call");
305 rpc_free_pdu(rpc
, pdu
);
314 int rpc_nfs_commit_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, void *private_data
)
319 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_COMMIT
, cb
, private_data
, (zdrproc_t
)zdr_COMMIT3res
, sizeof(COMMIT3res
));
321 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/commit call");
325 args
.file
.data
.data_len
= fh
->data
.data_len
;
326 args
.file
.data
.data_val
= fh
->data
.data_val
;
330 if (zdr_COMMIT3args(&pdu
->zdr
, &args
) == 0) {
331 rpc_set_error(rpc
, "ZDR error: Failed to encode WRITE3args");
332 rpc_free_pdu(rpc
, pdu
);
336 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
337 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/commit call");
338 rpc_free_pdu(rpc
, pdu
);
346 int rpc_nfs_setattr_async(struct rpc_context
*rpc
, rpc_cb cb
, SETATTR3args
*args
, void *private_data
)
350 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_SETATTR
, cb
, private_data
, (zdrproc_t
)zdr_SETATTR3res
, sizeof(SETATTR3res
));
352 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/setattr call");
356 if (zdr_SETATTR3args(&pdu
->zdr
, args
) == 0) {
357 rpc_set_error(rpc
, "ZDR error: Failed to encode SETATTR3args");
358 rpc_free_pdu(rpc
, pdu
);
362 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
363 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/setattr call");
364 rpc_free_pdu(rpc
, pdu
);
373 int rpc_nfs_mkdir_async(struct rpc_context
*rpc
, rpc_cb cb
, MKDIR3args
*args
, void *private_data
)
377 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_MKDIR
, cb
, private_data
, (zdrproc_t
)zdr_MKDIR3res
, sizeof(MKDIR3res
));
379 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/setattr call");
383 if (zdr_MKDIR3args(&pdu
->zdr
, args
) == 0) {
384 rpc_set_error(rpc
, "ZDR error: Failed to encode MKDIR3args");
385 rpc_free_pdu(rpc
, pdu
);
389 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
390 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/mkdir call");
391 rpc_free_pdu(rpc
, pdu
);
401 int rpc_nfs_rmdir_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, char *dir
, void *private_data
)
406 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_RMDIR
, cb
, private_data
, (zdrproc_t
)zdr_RMDIR3res
, sizeof(RMDIR3res
));
408 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/rmdir call");
412 memset(&args
, 0, sizeof(RMDIR3args
));
413 args
.object
.dir
.data
.data_len
= fh
->data
.data_len
;
414 args
.object
.dir
.data
.data_val
= fh
->data
.data_val
;
415 args
.object
.name
= dir
;
417 if (zdr_RMDIR3args(&pdu
->zdr
, &args
) == 0) {
418 rpc_set_error(rpc
, "ZDR error: Failed to encode RMDIR3args");
419 rpc_free_pdu(rpc
, pdu
);
423 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
424 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/rmdir call");
425 rpc_free_pdu(rpc
, pdu
);
434 int rpc_nfs_create_async(struct rpc_context
*rpc
, rpc_cb cb
, CREATE3args
*args
, void *private_data
)
438 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_CREATE
, cb
, private_data
, (zdrproc_t
)zdr_CREATE3res
, sizeof(CREATE3res
));
440 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/create call");
444 if (zdr_CREATE3args(&pdu
->zdr
, args
) == 0) {
445 rpc_set_error(rpc
, "ZDR error: Failed to encode CREATE3args");
446 rpc_free_pdu(rpc
, pdu
);
450 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
451 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/create call");
452 rpc_free_pdu(rpc
, pdu
);
461 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
)
466 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_MKNOD
, cb
, private_data
, (zdrproc_t
)zdr_MKNOD3res
, sizeof(MKNOD3res
));
468 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/mknod call");
472 memset(&args
, 0, sizeof(MKNOD3args
));
473 args
.where
.dir
.data
.data_len
= fh
->data
.data_len
;
474 args
.where
.dir
.data
.data_val
= fh
->data
.data_val
;
475 args
.where
.name
= file
;
476 switch (mode
& S_IFMT
) {
478 args
.what
.type
= NF3CHR
;
479 args
.what
.mknoddata3_u
.chr_device
.dev_attributes
.mode
.set_it
= 1;
480 args
.what
.mknoddata3_u
.chr_device
.dev_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
);
481 args
.what
.mknoddata3_u
.chr_device
.spec
.specdata1
= major
;
482 args
.what
.mknoddata3_u
.chr_device
.spec
.specdata2
= minor
;
485 args
.what
.type
= NF3BLK
;
486 args
.what
.mknoddata3_u
.blk_device
.dev_attributes
.mode
.set_it
= 1;
487 args
.what
.mknoddata3_u
.blk_device
.dev_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
);
488 args
.what
.mknoddata3_u
.blk_device
.spec
.specdata1
= major
;
489 args
.what
.mknoddata3_u
.blk_device
.spec
.specdata2
= minor
;
491 args
.what
.type
= NF3SOCK
;
492 args
.what
.mknoddata3_u
.sock_attributes
.mode
.set_it
= 1;
493 args
.what
.mknoddata3_u
.sock_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
);
496 args
.what
.type
= NF3FIFO
;
497 args
.what
.mknoddata3_u
.pipe_attributes
.mode
.set_it
= 1;
498 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
);
501 rpc_set_error(rpc
, "Invalid file type for nfs/mknod call");
502 rpc_free_pdu(rpc
, pdu
);
506 if (zdr_MKNOD3args(&pdu
->zdr
, &args
) == 0) {
507 rpc_set_error(rpc
, "ZDR error: Failed to encode MKNOD3args");
508 rpc_free_pdu(rpc
, pdu
);
512 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
513 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/mknod call");
514 rpc_free_pdu(rpc
, pdu
);
522 int rpc_nfs_remove_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, char *file
, void *private_data
)
527 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_REMOVE
, cb
, private_data
, (zdrproc_t
)zdr_REMOVE3res
, sizeof(REMOVE3res
));
529 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/remove call");
533 memset(&args
, 0, sizeof(REMOVE3args
));
534 args
.object
.dir
.data
.data_len
= fh
->data
.data_len
;
535 args
.object
.dir
.data
.data_val
= fh
->data
.data_val
;
536 args
.object
.name
= file
;
538 if (zdr_REMOVE3args(&pdu
->zdr
, &args
) == 0) {
539 rpc_set_error(rpc
, "ZDR error: Failed to encode REMOVE3args");
540 rpc_free_pdu(rpc
, pdu
);
544 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
545 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/remove call");
546 rpc_free_pdu(rpc
, pdu
);
553 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
)
558 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_READDIR
, cb
, private_data
, (zdrproc_t
)zdr_READDIR3res
, sizeof(READDIR3res
));
560 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/readdir call");
564 memset(&args
, 0, sizeof(READDIR3args
));
565 args
.dir
.data
.data_len
= fh
->data
.data_len
;
566 args
.dir
.data
.data_val
= fh
->data
.data_val
;
567 args
.cookie
= cookie
;
568 memcpy(&args
.cookieverf
, cookieverf
, sizeof(cookieverf3
));
571 if (zdr_READDIR3args(&pdu
->zdr
, &args
) == 0) {
572 rpc_set_error(rpc
, "ZDR error: Failed to encode READDIR3args");
573 rpc_free_pdu(rpc
, pdu
);
577 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
578 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/readdir call");
579 rpc_free_pdu(rpc
, pdu
);
586 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
)
589 READDIRPLUS3args args
;
591 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_READDIRPLUS
, cb
, private_data
, (zdrproc_t
)zdr_READDIRPLUS3res
, sizeof(READDIRPLUS3res
));
593 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/readdirplus call");
597 memset(&args
, 0, sizeof(READDIRPLUS3args
));
598 args
.dir
.data
.data_len
= fh
->data
.data_len
;
599 args
.dir
.data
.data_val
= fh
->data
.data_val
;
600 args
.cookie
= cookie
;
601 memcpy(&args
.cookieverf
, cookieverf
, sizeof(cookieverf3
));
602 args
.dircount
= count
;
603 args
.maxcount
= count
;
605 if (zdr_READDIRPLUS3args(&pdu
->zdr
, &args
) == 0) {
606 rpc_set_error(rpc
, "ZDR error: Failed to encode READDIRPLUS3args");
607 rpc_free_pdu(rpc
, pdu
);
611 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
612 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/readdirplus call");
613 rpc_free_pdu(rpc
, pdu
);
620 int rpc_nfs_fsstat_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, void *private_data
)
625 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_FSSTAT
, cb
, private_data
, (zdrproc_t
)zdr_FSSTAT3res
, sizeof(FSSTAT3res
));
627 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/fsstat call");
631 args
.fsroot
.data
.data_len
= fh
->data
.data_len
;
632 args
.fsroot
.data
.data_val
= fh
->data
.data_val
;
634 if (zdr_FSSTAT3args(&pdu
->zdr
, &args
) == 0) {
635 rpc_set_error(rpc
, "ZDR error: Failed to encode FSSTAT3args");
636 rpc_free_pdu(rpc
, pdu
);
640 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
641 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/fsstat call");
642 rpc_free_pdu(rpc
, pdu
);
649 int rpc_nfs_fsinfo_async(struct rpc_context
*rpc
, rpc_cb cb
, struct nfs_fh3
*fh
, void *private_data
)
654 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_FSINFO
, cb
, private_data
, (zdrproc_t
)zdr_FSINFO3res
, sizeof(FSINFO3res
));
656 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/fsinfo call");
660 args
.fsroot
.data
.data_len
= fh
->data
.data_len
;
661 args
.fsroot
.data
.data_val
= fh
->data
.data_val
;
663 if (zdr_FSINFO3args(&pdu
->zdr
, &args
) == 0) {
664 rpc_set_error(rpc
, "ZDR error: Failed to encode FSINFO3args");
665 rpc_free_pdu(rpc
, pdu
);
669 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
670 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/fsinfo call");
671 rpc_free_pdu(rpc
, pdu
);
678 int rpc_nfs_readlink_async(struct rpc_context
*rpc
, rpc_cb cb
, READLINK3args
*args
, void *private_data
)
682 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_READLINK
, cb
, private_data
, (zdrproc_t
)zdr_READLINK3res
, sizeof(READLINK3res
));
684 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/readlink call");
688 if (zdr_READLINK3args(&pdu
->zdr
, args
) == 0) {
689 rpc_set_error(rpc
, "ZDR error: Failed to encode READLINK3args");
690 rpc_free_pdu(rpc
, pdu
);
694 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
695 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/readlink call");
696 rpc_free_pdu(rpc
, pdu
);
704 int rpc_nfs_symlink_async(struct rpc_context
*rpc
, rpc_cb cb
, SYMLINK3args
*args
, void *private_data
)
708 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_SYMLINK
, cb
, private_data
, (zdrproc_t
)zdr_SYMLINK3res
, sizeof(SYMLINK3res
));
710 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/symlink call");
714 if (zdr_SYMLINK3args(&pdu
->zdr
, args
) == 0) {
715 rpc_set_error(rpc
, "ZDR error: Failed to encode SYMLINK3args");
716 rpc_free_pdu(rpc
, pdu
);
720 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
721 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/symlink call");
722 rpc_free_pdu(rpc
, pdu
);
732 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
)
737 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_RENAME
, cb
, private_data
, (zdrproc_t
)zdr_RENAME3res
, sizeof(RENAME3res
));
739 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/rename call");
743 memset(&args
, 0, sizeof(RENAME3args
));
744 args
.from
.dir
.data
.data_len
= olddir
->data
.data_len
;
745 args
.from
.dir
.data
.data_val
= olddir
->data
.data_val
;
746 args
.from
.name
= oldname
;
747 args
.to
.dir
.data
.data_len
= newdir
->data
.data_len
;
748 args
.to
.dir
.data
.data_val
= newdir
->data
.data_val
;
749 args
.to
.name
= newname
;
751 if (zdr_RENAME3args(&pdu
->zdr
, &args
) == 0) {
752 rpc_set_error(rpc
, "ZDR error: Failed to encode RENAME3args");
753 rpc_free_pdu(rpc
, pdu
);
757 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
758 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/rename call");
759 rpc_free_pdu(rpc
, pdu
);
769 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
)
774 pdu
= rpc_allocate_pdu(rpc
, NFS_PROGRAM
, NFS_V3
, NFS3_LINK
, cb
, private_data
, (zdrproc_t
)zdr_LINK3res
, sizeof(LINK3res
));
776 rpc_set_error(rpc
, "Out of memory. Failed to allocate pdu for nfs/link call");
780 memset(&args
, 0, sizeof(LINK3args
));
781 args
.file
.data
.data_len
= file
->data
.data_len
;
782 args
.file
.data
.data_val
= file
->data
.data_val
;
783 args
.link
.dir
.data
.data_len
= newdir
->data
.data_len
;
784 args
.link
.dir
.data
.data_val
= newdir
->data
.data_val
;
785 args
.link
.name
= newname
;
787 if (zdr_LINK3args(&pdu
->zdr
, &args
) == 0) {
788 rpc_set_error(rpc
, "ZDR error: Failed to encode LINK3args");
789 rpc_free_pdu(rpc
, pdu
);
793 if (rpc_queue_pdu(rpc
, pdu
) != 0) {
794 rpc_set_error(rpc
, "Out of memory. Failed to queue pdu for nfs/link call");
795 rpc_free_pdu(rpc
, pdu
);