Add NFSv2 RPC support
[deb_libnfs.git] / 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 #ifdef WIN32
19 #include "win32_compat.h"
20 #else
21 #include <sys/stat.h>
22 #endif/*WIN32*/
23
24 #include <stdio.h>
25 #include <errno.h>
26 #include <string.h>
27 #include "libnfs-zdr.h"
28 #include "libnfs.h"
29 #include "libnfs-raw.h"
30 #include "libnfs-private.h"
31 #include "libnfs-raw-nfs.h"
32
33 char *nfsstat3_to_str(int error)
34 {
35 switch (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;
65 };
66 return "unknown nfs error";
67 }
68
69 int nfsstat3_to_errno(int error)
70 {
71 switch (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;
101 };
102 return -ERANGE;
103 }
104
105
106 /*
107 * NFSv3
108 */
109 int rpc_nfs3_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
110 {
111 struct rpc_pdu *pdu;
112
113 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_NULL, cb, private_data, (zdrproc_t)zdr_void, 0);
114 if (pdu == NULL) {
115 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/NULL call");
116 return -1;
117 }
118
119 if (rpc_queue_pdu(rpc, pdu) != 0) {
120 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/NULL call");
121 rpc_free_pdu(rpc, pdu);
122 return -2;
123 }
124
125 return 0;
126 }
127
128 int rpc_nfs_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
129 {
130 return rpc_nfs3_null_async(rpc, cb, private_data);
131 }
132
133 int rpc_nfs3_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct GETATTR3args *args, void *private_data)
134 {
135 struct rpc_pdu *pdu;
136
137 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_GETATTR, cb, private_data, (zdrproc_t)zdr_GETATTR3res, sizeof(GETATTR3res));
138 if (pdu == NULL) {
139 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/GETATTR call");
140 return -1;
141 }
142
143 if (zdr_GETATTR3args(&pdu->zdr, args) == 0) {
144 rpc_set_error(rpc, "ZDR error: Failed to encode GETATTR3args");
145 rpc_free_pdu(rpc, pdu);
146 return -2;
147 }
148
149 if (rpc_queue_pdu(rpc, pdu) != 0) {
150 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/GETATTR call");
151 rpc_free_pdu(rpc, pdu);
152 return -3;
153 }
154
155 return 0;
156 }
157
158 int rpc_nfs_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
159 {
160 GETATTR3args args;
161
162 memset(&args, 0, sizeof(GETATTR3args));
163 args.object.data.data_len = fh->data.data_len;
164 args.object.data.data_val = fh->data.data_val;
165
166 return rpc_nfs3_getattr_async(rpc, cb, &args, private_data);
167 }
168
169 int rpc_nfs3_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct PATHCONF3args *args, void *private_data)
170 {
171 struct rpc_pdu *pdu;
172
173 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_PATHCONF, cb, private_data, (zdrproc_t)zdr_PATHCONF3res, sizeof(PATHCONF3res));
174 if (pdu == NULL) {
175 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/PATHCONF call");
176 return -1;
177 }
178
179 if (zdr_PATHCONF3args(&pdu->zdr, args) == 0) {
180 rpc_set_error(rpc, "ZDR error: Failed to encode PATHCONF3args");
181 rpc_free_pdu(rpc, pdu);
182 return -2;
183 }
184
185 if (rpc_queue_pdu(rpc, pdu) != 0) {
186 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/PATHCONF call");
187 rpc_free_pdu(rpc, pdu);
188 return -3;
189 }
190
191 return 0;
192 }
193
194 int rpc_nfs_pathconf_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
195 {
196 PATHCONF3args args;
197
198 memset(&args, 0, sizeof(PATHCONF3args));
199 args.object.data.data_len = fh->data.data_len;
200 args.object.data.data_val = fh->data.data_val;
201
202 return rpc_nfs3_pathconf_async(rpc, cb, &args, private_data);
203 }
204
205 int rpc_nfs3_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct LOOKUP3args *args, void *private_data)
206 {
207 struct rpc_pdu *pdu;
208
209 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LOOKUP, cb, private_data, (zdrproc_t)zdr_LOOKUP3res, sizeof(LOOKUP3res));
210 if (pdu == NULL) {
211 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LOOKUP call");
212 return -1;
213 }
214
215 if (zdr_LOOKUP3args(&pdu->zdr, args) == 0) {
216 rpc_set_error(rpc, "ZDR error: Failed to encode LOOKUP3args");
217 rpc_free_pdu(rpc, pdu);
218 return -2;
219 }
220
221 if (rpc_queue_pdu(rpc, pdu) != 0) {
222 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LOOKUP call");
223 rpc_free_pdu(rpc, pdu);
224 return -3;
225 }
226
227 return 0;
228 }
229
230 int rpc_nfs_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *name, void *private_data)
231 {
232 LOOKUP3args args;
233
234 memset(&args, 0, sizeof(LOOKUP3args));
235 args.what.dir.data.data_len = fh->data.data_len;
236 args.what.dir.data.data_val = fh->data.data_val;
237 args.what.name = name;
238
239 return rpc_nfs3_lookup_async(rpc, cb, &args, private_data);
240 }
241
242 int rpc_nfs3_access_async(struct rpc_context *rpc, rpc_cb cb, struct ACCESS3args *args, void *private_data)
243 {
244 struct rpc_pdu *pdu;
245
246 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_ACCESS, cb, private_data, (zdrproc_t)zdr_ACCESS3res, sizeof(ACCESS3res));
247 if (pdu == NULL) {
248 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/ACCESS call");
249 return -1;
250 }
251
252 if (zdr_ACCESS3args(&pdu->zdr, args) == 0) {
253 rpc_set_error(rpc, "ZDR error: Failed to encode ACCESS3args");
254 rpc_free_pdu(rpc, pdu);
255 return -2;
256 }
257
258 if (rpc_queue_pdu(rpc, pdu) != 0) {
259 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/ACCESS call");
260 rpc_free_pdu(rpc, pdu);
261 return -3;
262 }
263
264 return 0;
265 }
266
267 int rpc_nfs_access_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, int access, void *private_data)
268 {
269 ACCESS3args args;
270
271 memset(&args, 0, sizeof(ACCESS3args));
272 args.object.data.data_len = fh->data.data_len;
273 args.object.data.data_val = fh->data.data_val;
274 args.access = access;
275
276 return rpc_nfs3_access_async(rpc, cb, &args, private_data);
277 }
278
279 int rpc_nfs3_read_async(struct rpc_context *rpc, rpc_cb cb, struct READ3args *args, void *private_data)
280 {
281 struct rpc_pdu *pdu;
282
283 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READ, cb, private_data, (zdrproc_t)zdr_READ3res, sizeof(READ3res));
284 if (pdu == NULL) {
285 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READ call");
286 return -1;
287 }
288
289 if (zdr_READ3args(&pdu->zdr, args) == 0) {
290 rpc_set_error(rpc, "ZDR error: Failed to encode READ3args");
291 rpc_free_pdu(rpc, pdu);
292 return -2;
293 }
294
295 if (rpc_queue_pdu(rpc, pdu) != 0) {
296 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READ call");
297 rpc_free_pdu(rpc, pdu);
298 return -3;
299 }
300
301 return 0;
302 }
303
304 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)
305 {
306 READ3args args;
307
308 memset(&args, 0, sizeof(READ3args));
309 args.file.data.data_len = fh->data.data_len;
310 args.file.data.data_val = fh->data.data_val;
311 args.offset = offset;
312 args.count = count;
313
314 return rpc_nfs3_read_async(rpc, cb, &args, private_data);
315 }
316
317 int rpc_nfs3_write_async(struct rpc_context *rpc, rpc_cb cb, struct WRITE3args *args, void *private_data)
318 {
319 struct rpc_pdu *pdu;
320
321 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_WRITE, cb, private_data, (zdrproc_t)zdr_WRITE3res, sizeof(WRITE3res));
322 if (pdu == NULL) {
323 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/WRITE call");
324 return -1;
325 }
326
327 if (zdr_WRITE3args(&pdu->zdr, args) == 0) {
328 rpc_set_error(rpc, "ZDR error: Failed to encode WRITE3args");
329 rpc_free_pdu(rpc, pdu);
330 return -2;
331 }
332
333 if (rpc_queue_pdu(rpc, pdu) != 0) {
334 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/WRITE call");
335 rpc_free_pdu(rpc, pdu);
336 return -3;
337 }
338
339 return 0;
340 }
341
342 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)
343 {
344 WRITE3args args;
345
346 memset(&args, 0, sizeof(WRITE3args));
347 args.file.data.data_len = fh->data.data_len;
348 args.file.data.data_val = fh->data.data_val;
349 args.offset = offset;
350 args.count = count;
351 args.stable = stable_how;
352 args.data.data_len = count;
353 args.data.data_val = buf;
354
355 return rpc_nfs3_write_async(rpc, cb, &args, private_data);
356 }
357
358 int rpc_nfs3_commit_async(struct rpc_context *rpc, rpc_cb cb, struct COMMIT3args *args, void *private_data)
359 {
360 struct rpc_pdu *pdu;
361
362 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_COMMIT, cb, private_data, (zdrproc_t)zdr_COMMIT3res, sizeof(COMMIT3res));
363 if (pdu == NULL) {
364 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/COMMIT call");
365 return -1;
366 }
367
368 if (zdr_COMMIT3args(&pdu->zdr, args) == 0) {
369 rpc_set_error(rpc, "ZDR error: Failed to encode COMMIT3args");
370 rpc_free_pdu(rpc, pdu);
371 return -2;
372 }
373
374 if (rpc_queue_pdu(rpc, pdu) != 0) {
375 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/COMMIT call");
376 rpc_free_pdu(rpc, pdu);
377 return -3;
378 }
379
380 return 0;
381 }
382
383 int rpc_nfs_commit_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
384 {
385 COMMIT3args args;
386
387 memset(&args, 0, sizeof(COMMIT3args));
388 args.file.data.data_len = fh->data.data_len;
389 args.file.data.data_val = fh->data.data_val;
390 args.offset = 0;
391 args.count = 0;
392
393 return rpc_nfs3_commit_async(rpc, cb, &args, private_data);
394 }
395
396 int rpc_nfs3_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data)
397 {
398 struct rpc_pdu *pdu;
399
400 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SETATTR, cb, private_data, (zdrproc_t)zdr_SETATTR3res, sizeof(SETATTR3res));
401 if (pdu == NULL) {
402 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SETATTR call");
403 return -1;
404 }
405
406 if (zdr_SETATTR3args(&pdu->zdr, args) == 0) {
407 rpc_set_error(rpc, "ZDR error: Failed to encode SETATTR3args");
408 rpc_free_pdu(rpc, pdu);
409 return -2;
410 }
411
412 if (rpc_queue_pdu(rpc, pdu) != 0) {
413 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SETATTR call");
414 rpc_free_pdu(rpc, pdu);
415 return -3;
416 }
417
418 return 0;
419 }
420
421 int rpc_nfs_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR3args *args, void *private_data)
422 {
423 return rpc_nfs3_setattr_async(rpc, cb, args, private_data);
424 }
425
426 int rpc_nfs3_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data)
427 {
428 struct rpc_pdu *pdu;
429
430 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKDIR, cb, private_data, (zdrproc_t)zdr_MKDIR3res, sizeof(MKDIR3res));
431 if (pdu == NULL) {
432 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKDIR call");
433 return -1;
434 }
435
436 if (zdr_MKDIR3args(&pdu->zdr, args) == 0) {
437 rpc_set_error(rpc, "ZDR error: Failed to encode MKDIR3args");
438 rpc_free_pdu(rpc, pdu);
439 return -2;
440 }
441
442 if (rpc_queue_pdu(rpc, pdu) != 0) {
443 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKDIR call");
444 rpc_free_pdu(rpc, pdu);
445 return -3;
446 }
447
448 return 0;
449 }
450
451 int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR3args *args, void *private_data)
452 {
453 return rpc_nfs3_mkdir_async(rpc, cb, args, private_data);
454 }
455
456 int rpc_nfs3_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct RMDIR3args *args, void *private_data)
457 {
458 struct rpc_pdu *pdu;
459
460 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RMDIR, cb, private_data, (zdrproc_t)zdr_RMDIR3res, sizeof(RMDIR3res));
461 if (pdu == NULL) {
462 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RMDIR call");
463 return -1;
464 }
465
466 if (zdr_RMDIR3args(&pdu->zdr, args) == 0) {
467 rpc_set_error(rpc, "ZDR error: Failed to encode RMDIR3args");
468 rpc_free_pdu(rpc, pdu);
469 return -2;
470 }
471
472 if (rpc_queue_pdu(rpc, pdu) != 0) {
473 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RMDIR call");
474 rpc_free_pdu(rpc, pdu);
475 return -3;
476 }
477
478 return 0;
479 }
480
481 int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data)
482 {
483 RMDIR3args args;
484
485 memset(&args, 0, sizeof(RMDIR3args));
486 args.object.dir.data.data_len = fh->data.data_len;
487 args.object.dir.data.data_val = fh->data.data_val;
488 args.object.name = dir;
489
490 return rpc_nfs3_rmdir_async(rpc, cb, &args, private_data);
491 }
492
493 int rpc_nfs3_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data)
494 {
495 struct rpc_pdu *pdu;
496
497 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_CREATE, cb, private_data, (zdrproc_t)zdr_CREATE3res, sizeof(CREATE3res));
498 if (pdu == NULL) {
499 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/CREATE call");
500 return -1;
501 }
502
503 if (zdr_CREATE3args(&pdu->zdr, args) == 0) {
504 rpc_set_error(rpc, "ZDR error: Failed to encode CREATE3args");
505 rpc_free_pdu(rpc, pdu);
506 return -2;
507 }
508
509 if (rpc_queue_pdu(rpc, pdu) != 0) {
510 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/CREATE call");
511 rpc_free_pdu(rpc, pdu);
512 return -3;
513 }
514
515 return 0;
516 }
517
518 int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data)
519 {
520 return rpc_nfs3_create_async(rpc, cb, args, private_data);
521 }
522
523 int rpc_nfs3_mknod_async(struct rpc_context *rpc, rpc_cb cb, struct MKNOD3args *args, void *private_data)
524 {
525 struct rpc_pdu *pdu;
526
527 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKNOD, cb, private_data, (zdrproc_t)zdr_MKNOD3res, sizeof(MKNOD3res));
528 if (pdu == NULL) {
529 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/MKNOD call");
530 return -1;
531 }
532
533 if (zdr_MKNOD3args(&pdu->zdr, args) == 0) {
534 rpc_set_error(rpc, "ZDR error: Failed to encode MKNOD3args");
535 rpc_free_pdu(rpc, pdu);
536 return -2;
537 }
538
539 if (rpc_queue_pdu(rpc, pdu) != 0) {
540 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/MKNOD call");
541 rpc_free_pdu(rpc, pdu);
542 return -3;
543 }
544
545 return 0;
546 }
547
548 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)
549 {
550 MKNOD3args args;
551
552 memset(&args, 0, sizeof(MKNOD3args));
553 args.where.dir.data.data_len = fh->data.data_len;
554 args.where.dir.data.data_val = fh->data.data_val;
555 args.where.name = file;
556
557 switch (mode & S_IFMT) {
558 case S_IFCHR:
559 args.what.type = NF3CHR;
560 args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_it = 1;
561 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);
562 args.what.mknoddata3_u.chr_device.spec.specdata1 = major;
563 args.what.mknoddata3_u.chr_device.spec.specdata2 = minor;
564 break;
565 case S_IFBLK:
566 args.what.type = NF3BLK;
567 args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_it = 1;
568 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);
569 args.what.mknoddata3_u.blk_device.spec.specdata1 = major;
570 args.what.mknoddata3_u.blk_device.spec.specdata2 = minor;
571 case S_IFSOCK:
572 args.what.type = NF3SOCK;
573 args.what.mknoddata3_u.sock_attributes.mode.set_it = 1;
574 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);
575 break;
576 case S_IFIFO:
577 args.what.type = NF3FIFO;
578 args.what.mknoddata3_u.pipe_attributes.mode.set_it = 1;
579 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);
580 break;
581 default:
582 rpc_set_error(rpc, "Invalid file type for NFS3/MKNOD call");
583 return -1;
584 }
585
586 return rpc_nfs3_mknod_async(rpc, cb, &args, private_data);
587 }
588
589 int rpc_nfs3_remove_async(struct rpc_context *rpc, rpc_cb cb, struct REMOVE3args *args, void *private_data)
590 {
591 struct rpc_pdu *pdu;
592
593 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE3res, sizeof(REMOVE3res));
594 if (pdu == NULL) {
595 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/REMOVE call");
596 return -1;
597 }
598
599 if (zdr_REMOVE3args(&pdu->zdr, args) == 0) {
600 rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE3args");
601 rpc_free_pdu(rpc, pdu);
602 return -2;
603 }
604
605 if (rpc_queue_pdu(rpc, pdu) != 0) {
606 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/REMOVE call");
607 rpc_free_pdu(rpc, pdu);
608 return -3;
609 }
610
611 return 0;
612 }
613
614 int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, void *private_data)
615 {
616 REMOVE3args args;
617
618 memset(&args, 0, sizeof(REMOVE3args));
619 args.object.dir.data.data_len = fh->data.data_len;
620 args.object.dir.data.data_val = fh->data.data_val;
621 args.object.name = file;
622
623 return rpc_nfs3_remove_async(rpc, cb, &args, private_data);
624 }
625
626 int rpc_nfs3_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct READDIR3args *args, void *private_data)
627 {
628 struct rpc_pdu *pdu;
629
630 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR3res, sizeof(READDIR3res));
631 if (pdu == NULL) {
632 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIR call");
633 return -1;
634 }
635
636 if (zdr_READDIR3args(&pdu->zdr, args) == 0) {
637 rpc_set_error(rpc, "ZDR error: Failed to encode READDIR3args");
638 rpc_free_pdu(rpc, pdu);
639 return -2;
640 }
641
642 if (rpc_queue_pdu(rpc, pdu) != 0) {
643 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIR call");
644 rpc_free_pdu(rpc, pdu);
645 return -3;
646 }
647
648 return 0;
649 }
650
651 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)
652 {
653 READDIR3args args;
654
655 memset(&args, 0, sizeof(READDIR3args));
656 args.dir.data.data_len = fh->data.data_len;
657 args.dir.data.data_val = fh->data.data_val;
658 args.cookie = cookie;
659 memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
660 args.count = count;
661
662 return rpc_nfs3_readdir_async(rpc, cb, &args, private_data);
663 }
664
665 int rpc_nfs3_readdirplus_async(struct rpc_context *rpc, rpc_cb cb, struct READDIRPLUS3args *args, void *private_data)
666 {
667 struct rpc_pdu *pdu;
668
669 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (zdrproc_t)zdr_READDIRPLUS3res, sizeof(READDIRPLUS3res));
670 if (pdu == NULL) {
671 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READDIRPLUS call");
672 return -1;
673 }
674
675 if (zdr_READDIRPLUS3args(&pdu->zdr, args) == 0) {
676 rpc_set_error(rpc, "ZDR error: Failed to encode READDIRPLUS3args");
677 rpc_free_pdu(rpc, pdu);
678 return -2;
679 }
680
681 if (rpc_queue_pdu(rpc, pdu) != 0) {
682 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READDIRPLUS call");
683 rpc_free_pdu(rpc, pdu);
684 return -3;
685 }
686
687 return 0;
688 }
689
690 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)
691 {
692 READDIRPLUS3args args;
693
694 memset(&args, 0, sizeof(READDIRPLUS3args));
695 args.dir.data.data_len = fh->data.data_len;
696 args.dir.data.data_val = fh->data.data_val;
697 args.cookie = cookie;
698 memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
699 args.dircount = count;
700 args.maxcount = count;
701
702 return rpc_nfs3_readdirplus_async(rpc, cb, &args, private_data);
703 }
704
705 int rpc_nfs3_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct FSSTAT3args *args, void *private_data)
706 {
707 struct rpc_pdu *pdu;
708
709 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSSTAT, cb, private_data, (zdrproc_t)zdr_FSSTAT3res, sizeof(FSSTAT3res));
710 if (pdu == NULL) {
711 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSSTAT call");
712 return -1;
713 }
714
715 if (zdr_FSSTAT3args(&pdu->zdr, args) == 0) {
716 rpc_set_error(rpc, "ZDR error: Failed to encode FSSTAT3args");
717 rpc_free_pdu(rpc, pdu);
718 return -2;
719 }
720
721 if (rpc_queue_pdu(rpc, pdu) != 0) {
722 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSSTAT call");
723 rpc_free_pdu(rpc, pdu);
724 return -3;
725 }
726
727 return 0;
728 }
729
730 int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
731 {
732 FSSTAT3args args;
733
734 memset(&args, 0, sizeof(FSSTAT3args));
735 args.fsroot.data.data_len = fh->data.data_len;
736 args.fsroot.data.data_val = fh->data.data_val;
737
738 return rpc_nfs3_fsstat_async(rpc, cb, &args, private_data);
739 }
740
741 int rpc_nfs3_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct FSINFO3args *args, void *private_data)
742 {
743 struct rpc_pdu *pdu;
744
745 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSINFO, cb, private_data, (zdrproc_t)zdr_FSINFO3res, sizeof(FSINFO3res));
746 if (pdu == NULL) {
747 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/FSINFO call");
748 return -1;
749 }
750
751 if (zdr_FSINFO3args(&pdu->zdr, args) == 0) {
752 rpc_set_error(rpc, "ZDR error: Failed to encode FSINFO3args");
753 rpc_free_pdu(rpc, pdu);
754 return -2;
755 }
756
757 if (rpc_queue_pdu(rpc, pdu) != 0) {
758 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/FSINFO call");
759 rpc_free_pdu(rpc, pdu);
760 return -3;
761 }
762
763 return 0;
764 }
765
766 int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
767 {
768 FSINFO3args args;
769
770 memset(&args, 0, sizeof(FSINFO3args));
771 args.fsroot.data.data_len = fh->data.data_len;
772 args.fsroot.data.data_val = fh->data.data_val;
773
774 return rpc_nfs3_fsinfo_async(rpc, cb, fh, private_data);
775 }
776
777 int rpc_nfs3_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data)
778 {
779 struct rpc_pdu *pdu;
780
781 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READLINK, cb, private_data, (zdrproc_t)zdr_READLINK3res, sizeof(READLINK3res));
782 if (pdu == NULL) {
783 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/READLINK call");
784 return -1;
785 }
786
787 if (zdr_READLINK3args(&pdu->zdr, args) == 0) {
788 rpc_set_error(rpc, "ZDR error: Failed to encode READLINK3args");
789 rpc_free_pdu(rpc, pdu);
790 return -2;
791 }
792
793 if (rpc_queue_pdu(rpc, pdu) != 0) {
794 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/READLINK call");
795 rpc_free_pdu(rpc, pdu);
796 return -3;
797 }
798
799 return 0;
800 }
801
802 int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK3args *args, void *private_data)
803 {
804 return rpc_nfs3_readlink_async(rpc, cb, args, private_data);
805 }
806
807 int rpc_nfs3_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data)
808 {
809 struct rpc_pdu *pdu;
810
811 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SYMLINK, cb, private_data, (zdrproc_t)zdr_SYMLINK3res, sizeof(SYMLINK3res));
812 if (pdu == NULL) {
813 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/SYMLINK call");
814 return -1;
815 }
816
817 if (zdr_SYMLINK3args(&pdu->zdr, args) == 0) {
818 rpc_set_error(rpc, "ZDR error: Failed to encode SYMLINK3args");
819 rpc_free_pdu(rpc, pdu);
820 return -2;
821 }
822
823 if (rpc_queue_pdu(rpc, pdu) != 0) {
824 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/SYMLINK call");
825 rpc_free_pdu(rpc, pdu);
826 return -3;
827 }
828
829 return 0;
830 }
831
832 int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK3args *args, void *private_data)
833 {
834 return rpc_nfs3_symlink_async(rpc, cb, args, private_data);
835 }
836
837 int rpc_nfs3_rename_async(struct rpc_context *rpc, rpc_cb cb, struct RENAME3args *args, void *private_data)
838 {
839 struct rpc_pdu *pdu;
840
841 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RENAME, cb, private_data, (zdrproc_t)zdr_RENAME3res, sizeof(RENAME3res));
842 if (pdu == NULL) {
843 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/RENAME call");
844 return -1;
845 }
846
847 if (zdr_RENAME3args(&pdu->zdr, args) == 0) {
848 rpc_set_error(rpc, "ZDR error: Failed to encode RENAME3args");
849 rpc_free_pdu(rpc, pdu);
850 return -2;
851 }
852
853 if (rpc_queue_pdu(rpc, pdu) != 0) {
854 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/RENAME call");
855 rpc_free_pdu(rpc, pdu);
856 return -3;
857 }
858
859 return 0;
860 }
861
862 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)
863 {
864 RENAME3args args;
865
866 memset(&args, 0, sizeof(RENAME3args));
867 args.from.dir.data.data_len = olddir->data.data_len;
868 args.from.dir.data.data_val = olddir->data.data_val;
869 args.from.name = oldname;
870 args.to.dir.data.data_len = newdir->data.data_len;
871 args.to.dir.data.data_val = newdir->data.data_val;
872 args.to.name = newname;
873
874 return rpc_nfs3_rename_async(rpc, cb, &args, private_data);
875 }
876
877 int rpc_nfs3_link_async(struct rpc_context *rpc, rpc_cb cb, struct LINK3args *args, void *private_data)
878 {
879 struct rpc_pdu *pdu;
880
881 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LINK, cb, private_data, (zdrproc_t)zdr_LINK3res, sizeof(LINK3res));
882 if (pdu == NULL) {
883 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/LINK call");
884 return -1;
885 }
886
887 if (zdr_LINK3args(&pdu->zdr, args) == 0) {
888 rpc_set_error(rpc, "ZDR error: Failed to encode LINK3args");
889 rpc_free_pdu(rpc, pdu);
890 return -2;
891 }
892
893 if (rpc_queue_pdu(rpc, pdu) != 0) {
894 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS3/LINK call");
895 rpc_free_pdu(rpc, pdu);
896 return -3;
897 }
898
899 return 0;
900 }
901
902 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)
903 {
904 LINK3args args;
905
906 memset(&args, 0, sizeof(LINK3args));
907 args.file.data.data_len = file->data.data_len;
908 args.file.data.data_val = file->data.data_val;
909 args.link.dir.data.data_len = newdir->data.data_len;
910 args.link.dir.data.data_val = newdir->data.data_val;
911 args.link.name = newname;
912
913 return rpc_nfs3_link_async(rpc, cb, &args, private_data);
914 }
915
916 /*
917 * NFSv2
918 */
919 int rpc_nfs2_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
920 {
921 struct rpc_pdu *pdu;
922
923 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_NULL, cb, private_data, (zdrproc_t)zdr_void, 0);
924 if (pdu == NULL) {
925 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/NULL call");
926 return -1;
927 }
928
929 if (rpc_queue_pdu(rpc, pdu) != 0) {
930 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/NULL call");
931 rpc_free_pdu(rpc, pdu);
932 return -2;
933 }
934
935 return 0;
936 }
937
938 int rpc_nfs2_getattr_async(struct rpc_context *rpc, rpc_cb cb, struct GETATTR2args *args, void *private_data)
939 {
940 struct rpc_pdu *pdu;
941
942 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_GETATTR, cb, private_data, (zdrproc_t)zdr_GETATTR2res, sizeof(GETATTR2res));
943 if (pdu == NULL) {
944 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/GETATTR call");
945 return -1;
946 }
947
948 if (zdr_GETATTR2args(&pdu->zdr, args) == 0) {
949 rpc_set_error(rpc, "ZDR error: Failed to encode GETATTR2args");
950 rpc_free_pdu(rpc, pdu);
951 return -2;
952 }
953
954 if (rpc_queue_pdu(rpc, pdu) != 0) {
955 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/GETATTR call");
956 rpc_free_pdu(rpc, pdu);
957 return -3;
958 }
959
960 return 0;
961 }
962
963 int rpc_nfs2_setattr_async(struct rpc_context *rpc, rpc_cb cb, SETATTR2args *args, void *private_data)
964 {
965 struct rpc_pdu *pdu;
966
967 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_SETATTR, cb, private_data, (zdrproc_t)zdr_SETATTR2res, sizeof(SETATTR2res));
968 if (pdu == NULL) {
969 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/SETATTR call");
970 return -1;
971 }
972
973 if (zdr_SETATTR2args(&pdu->zdr, args) == 0) {
974 rpc_set_error(rpc, "ZDR error: Failed to encode SETATTR2args");
975 rpc_free_pdu(rpc, pdu);
976 return -2;
977 }
978
979 if (rpc_queue_pdu(rpc, pdu) != 0) {
980 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/SETATTR call");
981 rpc_free_pdu(rpc, pdu);
982 return -3;
983 }
984
985 return 0;
986 }
987
988 int rpc_nfs2_lookup_async(struct rpc_context *rpc, rpc_cb cb, struct LOOKUP2args *args, void *private_data)
989 {
990 struct rpc_pdu *pdu;
991
992 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_LOOKUP, cb, private_data, (zdrproc_t)zdr_LOOKUP2res, sizeof(LOOKUP2res));
993 if (pdu == NULL) {
994 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/LOOKUP call");
995 return -1;
996 }
997
998 if (zdr_LOOKUP2args(&pdu->zdr, args) == 0) {
999 rpc_set_error(rpc, "ZDR error: Failed to encode LOOKUP2args");
1000 rpc_free_pdu(rpc, pdu);
1001 return -2;
1002 }
1003
1004 if (rpc_queue_pdu(rpc, pdu) != 0) {
1005 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/LOOKUP call");
1006 rpc_free_pdu(rpc, pdu);
1007 return -3;
1008 }
1009
1010 return 0;
1011 }
1012
1013 int rpc_nfs2_readlink_async(struct rpc_context *rpc, rpc_cb cb, READLINK2args *args, void *private_data)
1014 {
1015 struct rpc_pdu *pdu;
1016
1017 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READLINK, cb, private_data, (zdrproc_t)zdr_READLINK2res, sizeof(READLINK2res));
1018 if (pdu == NULL) {
1019 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READLINK call");
1020 return -1;
1021 }
1022
1023 if (zdr_READLINK2args(&pdu->zdr, args) == 0) {
1024 rpc_set_error(rpc, "ZDR error: Failed to encode READLINK2args");
1025 rpc_free_pdu(rpc, pdu);
1026 return -2;
1027 }
1028
1029 if (rpc_queue_pdu(rpc, pdu) != 0) {
1030 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READLINK call");
1031 rpc_free_pdu(rpc, pdu);
1032 return -3;
1033 }
1034
1035 return 0;
1036 }
1037
1038 int rpc_nfs2_read_async(struct rpc_context *rpc, rpc_cb cb, struct READ2args *args, void *private_data)
1039 {
1040 struct rpc_pdu *pdu;
1041
1042 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READ, cb, private_data, (zdrproc_t)zdr_READ2res, sizeof(READ2res));
1043 if (pdu == NULL) {
1044 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READ call");
1045 return -1;
1046 }
1047
1048 if (zdr_READ2args(&pdu->zdr, args) == 0) {
1049 rpc_set_error(rpc, "ZDR error: Failed to encode READ2args");
1050 rpc_free_pdu(rpc, pdu);
1051 return -2;
1052 }
1053
1054 if (rpc_queue_pdu(rpc, pdu) != 0) {
1055 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READ call");
1056 rpc_free_pdu(rpc, pdu);
1057 return -3;
1058 }
1059
1060 return 0;
1061 }
1062
1063 int rpc_nfs2_write_async(struct rpc_context *rpc, rpc_cb cb, struct WRITE2args *args, void *private_data)
1064 {
1065 struct rpc_pdu *pdu;
1066
1067 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_WRITE, cb, private_data, (zdrproc_t)zdr_WRITE2res, sizeof(WRITE2res));
1068 if (pdu == NULL) {
1069 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/WRITE call");
1070 return -1;
1071 }
1072
1073 if (zdr_WRITE2args(&pdu->zdr, args) == 0) {
1074 rpc_set_error(rpc, "ZDR error: Failed to encode WRITE2args");
1075 rpc_free_pdu(rpc, pdu);
1076 return -2;
1077 }
1078
1079 if (rpc_queue_pdu(rpc, pdu) != 0) {
1080 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/WRITE call");
1081 rpc_free_pdu(rpc, pdu);
1082 return -3;
1083 }
1084
1085 return 0;
1086 }
1087
1088 int rpc_nfs2_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE2args *args, void *private_data)
1089 {
1090 struct rpc_pdu *pdu;
1091
1092 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_CREATE, cb, private_data, (zdrproc_t)zdr_CREATE2res, sizeof(CREATE2res));
1093 if (pdu == NULL) {
1094 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/CREATE call");
1095 return -1;
1096 }
1097
1098 if (zdr_CREATE2args(&pdu->zdr, args) == 0) {
1099 rpc_set_error(rpc, "ZDR error: Failed to encode CREATE2args");
1100 rpc_free_pdu(rpc, pdu);
1101 return -2;
1102 }
1103
1104 if (rpc_queue_pdu(rpc, pdu) != 0) {
1105 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/CREATE call");
1106 rpc_free_pdu(rpc, pdu);
1107 return -3;
1108 }
1109
1110 return 0;
1111 }
1112
1113 int rpc_nfs2_remove_async(struct rpc_context *rpc, rpc_cb cb, struct REMOVE2args *args, void *private_data)
1114 {
1115 struct rpc_pdu *pdu;
1116
1117 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_REMOVE, cb, private_data, (zdrproc_t)zdr_REMOVE2res, sizeof(REMOVE2res));
1118 if (pdu == NULL) {
1119 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS3/REMOVE call");
1120 return -1;
1121 }
1122
1123 if (zdr_REMOVE2args(&pdu->zdr, args) == 0) {
1124 rpc_set_error(rpc, "ZDR error: Failed to encode REMOVE2args");
1125 rpc_free_pdu(rpc, pdu);
1126 return -2;
1127 }
1128
1129 if (rpc_queue_pdu(rpc, pdu) != 0) {
1130 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/REMOVE call");
1131 rpc_free_pdu(rpc, pdu);
1132 return -3;
1133 }
1134
1135 return 0;
1136 }
1137
1138 int rpc_nfs2_rename_async(struct rpc_context *rpc, rpc_cb cb, struct RENAME2args *args, void *private_data)
1139 {
1140 struct rpc_pdu *pdu;
1141
1142 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_RENAME, cb, private_data, (zdrproc_t)zdr_RENAME2res, sizeof(RENAME2res));
1143 if (pdu == NULL) {
1144 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/RENAME call");
1145 return -1;
1146 }
1147
1148 if (zdr_RENAME2args(&pdu->zdr, args) == 0) {
1149 rpc_set_error(rpc, "ZDR error: Failed to encode RENAME2args");
1150 rpc_free_pdu(rpc, pdu);
1151 return -2;
1152 }
1153
1154 if (rpc_queue_pdu(rpc, pdu) != 0) {
1155 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/RENAME call");
1156 rpc_free_pdu(rpc, pdu);
1157 return -3;
1158 }
1159
1160 return 0;
1161 }
1162
1163 int rpc_nfs2_link_async(struct rpc_context *rpc, rpc_cb cb, LINK2args *args, void *private_data)
1164 {
1165 struct rpc_pdu *pdu;
1166
1167 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_LINK, cb, private_data, (zdrproc_t)zdr_LINK2res, sizeof(LINK2res));
1168 if (pdu == NULL) {
1169 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/LINK call");
1170 return -1;
1171 }
1172
1173 if (zdr_LINK2args(&pdu->zdr, args) == 0) {
1174 rpc_set_error(rpc, "ZDR error: Failed to encode LINK2args");
1175 rpc_free_pdu(rpc, pdu);
1176 return -2;
1177 }
1178
1179 if (rpc_queue_pdu(rpc, pdu) != 0) {
1180 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/LINK call");
1181 rpc_free_pdu(rpc, pdu);
1182 return -3;
1183 }
1184
1185 return 0;
1186 }
1187
1188 int rpc_nfs2_symlink_async(struct rpc_context *rpc, rpc_cb cb, SYMLINK2args *args, void *private_data)
1189 {
1190 struct rpc_pdu *pdu;
1191
1192 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_SYMLINK, cb, private_data, (zdrproc_t)zdr_SYMLINK2res, sizeof(SYMLINK2res));
1193 if (pdu == NULL) {
1194 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/SYMLINK call");
1195 return -1;
1196 }
1197
1198 if (zdr_SYMLINK2args(&pdu->zdr, args) == 0) {
1199 rpc_set_error(rpc, "ZDR error: Failed to encode SYMLINK2args");
1200 rpc_free_pdu(rpc, pdu);
1201 return -2;
1202 }
1203
1204 if (rpc_queue_pdu(rpc, pdu) != 0) {
1205 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/SYMLINK call");
1206 rpc_free_pdu(rpc, pdu);
1207 return -3;
1208 }
1209
1210 return 0;
1211 }
1212
1213 int rpc_nfs2_mkdir_async(struct rpc_context *rpc, rpc_cb cb, MKDIR2args *args, void *private_data)
1214 {
1215 struct rpc_pdu *pdu;
1216
1217 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_MKDIR, cb, private_data, (zdrproc_t)zdr_MKDIR2res, sizeof(MKDIR2res));
1218 if (pdu == NULL) {
1219 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/MKDIR call");
1220 return -1;
1221 }
1222
1223 if (zdr_MKDIR2args(&pdu->zdr, args) == 0) {
1224 rpc_set_error(rpc, "ZDR error: Failed to encode MKDIR2args");
1225 rpc_free_pdu(rpc, pdu);
1226 return -2;
1227 }
1228
1229 if (rpc_queue_pdu(rpc, pdu) != 0) {
1230 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/MKDIR call");
1231 rpc_free_pdu(rpc, pdu);
1232 return -3;
1233 }
1234
1235 return 0;
1236 }
1237
1238 int rpc_nfs2_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct RMDIR2args *args, void *private_data)
1239 {
1240 struct rpc_pdu *pdu;
1241
1242 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_RMDIR, cb, private_data, (zdrproc_t)zdr_RMDIR2res, sizeof(RMDIR2res));
1243 if (pdu == NULL) {
1244 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/RMDIR call");
1245 return -1;
1246 }
1247
1248 if (zdr_RMDIR2args(&pdu->zdr, args) == 0) {
1249 rpc_set_error(rpc, "ZDR error: Failed to encode RMDIR2args");
1250 rpc_free_pdu(rpc, pdu);
1251 return -2;
1252 }
1253
1254 if (rpc_queue_pdu(rpc, pdu) != 0) {
1255 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/RMDIR call");
1256 rpc_free_pdu(rpc, pdu);
1257 return -3;
1258 }
1259
1260 return 0;
1261 }
1262
1263 int rpc_nfs2_readdir_async(struct rpc_context *rpc, rpc_cb cb, struct READDIR2args *args, void *private_data)
1264 {
1265 struct rpc_pdu *pdu;
1266
1267 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_READDIR, cb, private_data, (zdrproc_t)zdr_READDIR2res, sizeof(READDIR2res));
1268 if (pdu == NULL) {
1269 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/READDIR call");
1270 return -1;
1271 }
1272
1273 if (zdr_READDIR2args(&pdu->zdr, args) == 0) {
1274 rpc_set_error(rpc, "ZDR error: Failed to encode READDIR2args");
1275 rpc_free_pdu(rpc, pdu);
1276 return -2;
1277 }
1278
1279 if (rpc_queue_pdu(rpc, pdu) != 0) {
1280 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/READDIR call");
1281 rpc_free_pdu(rpc, pdu);
1282 return -3;
1283 }
1284
1285 return 0;
1286 }
1287
1288 int rpc_nfs2_statfs_async(struct rpc_context *rpc, rpc_cb cb, struct STATFS2args *args, void *private_data)
1289 {
1290 struct rpc_pdu *pdu;
1291
1292 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V2, NFS2_STATFS, cb, private_data, (zdrproc_t)zdr_STATFS2res, sizeof(STATFS2res));
1293 if (pdu == NULL) {
1294 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS2/STATFS call");
1295 return -1;
1296 }
1297
1298 if (zdr_STATFS2args(&pdu->zdr, args) == 0) {
1299 rpc_set_error(rpc, "ZDR error: Failed to encode STATFS2args");
1300 rpc_free_pdu(rpc, pdu);
1301 return -2;
1302 }
1303
1304 if (rpc_queue_pdu(rpc, pdu) != 0) {
1305 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS2/STATFS call");
1306 rpc_free_pdu(rpc, pdu);
1307 return -3;
1308 }
1309
1310 return 0;
1311 }