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