repositories / deb_libnfs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rpc_nfs_create_async, args is now a pointer, not a structur
[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
345int rpc_nfs_mkdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data)
346{
347 struct rpc_pdu *pdu;
348 MKDIR3args args;
349
350 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKDIR, cb, private_data, (xdrproc_t)xdr_MKDIR3res, sizeof(MKDIR3res));
351 if (pdu == NULL) {
352 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/setattr call");
353 return -1;
354 }
355
ea98629a 356 memset(&args, 0, sizeof(MKDIR3args));
84004dbf
RS		 357 args.where.dir.data.data_len = fh->data.data_len;
358 args.where.dir.data.data_val = fh->data.data_val;
359 args.where.name = dir;
360 args.attributes.mode.set_it = 1;
361 args.attributes.mode.set_mode3_u.mode = 0755;
362
363 if (xdr_MKDIR3args(&pdu->xdr, &args) == 0) {
364 rpc_set_error(rpc, "XDR error: Failed to encode MKDIR3args");
365 rpc_free_pdu(rpc, pdu);
366 return -2;
367 }
368
369 if (rpc_queue_pdu(rpc, pdu) != 0) {
370 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/mkdir call");
371 rpc_free_pdu(rpc, pdu);
372 return -3;
373 }
374
375 return 0;
376}
377
378
379
380
381int rpc_nfs_rmdir_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *dir, void *private_data)
382{
383 struct rpc_pdu *pdu;
384 RMDIR3args args;
385
386 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RMDIR, cb, private_data, (xdrproc_t)xdr_RMDIR3res, sizeof(RMDIR3res));
387 if (pdu == NULL) {
388 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rmdir call");
389 return -1;
390 }
391
ea98629a 392 memset(&args, 0, sizeof(RMDIR3args));
84004dbf
RS		 393 args.object.dir.data.data_len = fh->data.data_len;
394 args.object.dir.data.data_val = fh->data.data_val;
395 args.object.name = dir;
396
397 if (xdr_RMDIR3args(&pdu->xdr, &args) == 0) {
398 rpc_set_error(rpc, "XDR error: Failed to encode RMDIR3args");
399 rpc_free_pdu(rpc, pdu);
400 return -2;
401 }
402
403 if (rpc_queue_pdu(rpc, pdu) != 0) {
404 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rmdir call");
405 rpc_free_pdu(rpc, pdu);
406 return -3;
407 }
408
409 return 0;
410}
411
412
413
c985c015 414int rpc_nfs_create_async(struct rpc_context *rpc, rpc_cb cb, CREATE3args *args, void *private_data)
84004dbf
RS		 415{
416 struct rpc_pdu *pdu;
84004dbf
RS		 417
418 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_CREATE, cb, private_data, (xdrproc_t)xdr_CREATE3res, sizeof(CREATE3res));
419 if (pdu == NULL) {
420 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/create call");
421 return -1;
422 }
423
bac0bc54 424 if (xdr_CREATE3args(&pdu->xdr, args) == 0) {
84004dbf
RS		 425 rpc_set_error(rpc, "XDR error: Failed to encode CREATE3args");
426 rpc_free_pdu(rpc, pdu);
427 return -2;
428 }
429
430 if (rpc_queue_pdu(rpc, pdu) != 0) {
431 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/create call");
432 rpc_free_pdu(rpc, pdu);
433 return -3;
434 }
435
436 return 0;
437}
438
439
440
1ec6b50a
RS		 441int 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)
442{
443 struct rpc_pdu *pdu;
444 MKNOD3args args;
445
446 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_MKNOD, cb, private_data, (xdrproc_t)xdr_MKNOD3res, sizeof(MKNOD3res));
447 if (pdu == NULL) {
448 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/mknod call");
449 return -1;
450 }
451
452 memset(&args, 0, sizeof(MKNOD3args));
453 args.where.dir.data.data_len = fh->data.data_len;
454 args.where.dir.data.data_val = fh->data.data_val;
455 args.where.name = file;
456 switch (mode & S_IFMT) {
457 case S_IFCHR:
458 args.what.type = NF3CHR;
459 args.what.mknoddata3_u.chr_device.dev_attributes.mode.set_it = 1;
460 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);
461 args.what.mknoddata3_u.chr_device.spec.specdata1 = major;
462 args.what.mknoddata3_u.chr_device.spec.specdata2 = minor;
463 break;
464 case S_IFBLK:
465 args.what.type = NF3BLK;
466 args.what.mknoddata3_u.blk_device.dev_attributes.mode.set_it = 1;
467 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);
468 args.what.mknoddata3_u.blk_device.spec.specdata1 = major;
469 args.what.mknoddata3_u.blk_device.spec.specdata2 = minor;
470 case S_IFSOCK:
471 args.what.type = NF3SOCK;
472 args.what.mknoddata3_u.sock_attributes.mode.set_it = 1;
473 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);
474 break;
475 case S_IFIFO:
476 args.what.type = NF3FIFO;
477 args.what.mknoddata3_u.pipe_attributes.mode.set_it = 1;
478 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);
479 break;
480 default:
481 rpc_set_error(rpc, "Invalid file type for nfs/mknod call");
482 rpc_free_pdu(rpc, pdu);
483 return -1;
484 }
485
486 if (xdr_MKNOD3args(&pdu->xdr, &args) == 0) {
487 rpc_set_error(rpc, "XDR error: Failed to encode MKNOD3args");
488 rpc_free_pdu(rpc, pdu);
489 return -2;
490 }
491
492 if (rpc_queue_pdu(rpc, pdu) != 0) {
493 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/mknod call");
494 rpc_free_pdu(rpc, pdu);
495 return -3;
496 }
497
498 return 0;
499}
500
84004dbf
RS		 501
502int rpc_nfs_remove_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *file, void *private_data)
503{
504 struct rpc_pdu *pdu;
505 REMOVE3args args;
506
507 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_REMOVE, cb, private_data, (xdrproc_t)xdr_REMOVE3res, sizeof(REMOVE3res));
508 if (pdu == NULL) {
509 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/remove call");
510 return -1;
511 }
512
ea98629a 513 memset(&args, 0, sizeof(REMOVE3args));
84004dbf
RS		 514 args.object.dir.data.data_len = fh->data.data_len;
515 args.object.dir.data.data_val = fh->data.data_val;
516 args.object.name = file;
517
518 if (xdr_REMOVE3args(&pdu->xdr, &args) == 0) {
519 rpc_set_error(rpc, "XDR error: Failed to encode REMOVE3args");
520 rpc_free_pdu(rpc, pdu);
521 return -2;
522 }
523
524 if (rpc_queue_pdu(rpc, pdu) != 0) {
525 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/remove call");
526 rpc_free_pdu(rpc, pdu);
527 return -3;
528 }
529
530 return 0;
531}
532
84004dbf
RS		 533int 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)
534{
535 struct rpc_pdu *pdu;
536 READDIR3args args;
537
538 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIR, cb, private_data, (xdrproc_t)xdr_READDIR3res, sizeof(READDIR3res));
539 if (pdu == NULL) {
540 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdir call");
541 return -1;
542 }
543
ea98629a 544 memset(&args, 0, sizeof(READDIR3args));
84004dbf
RS		 545 args.dir.data.data_len = fh->data.data_len;
546 args.dir.data.data_val = fh->data.data_val;
547 args.cookie = cookie;
548 memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
549 args.count = count;
550
551 if (xdr_READDIR3args(&pdu->xdr, &args) == 0) {
552 rpc_set_error(rpc, "XDR error: Failed to encode READDIR3args");
553 rpc_free_pdu(rpc, pdu);
554 return -2;
555 }
556
557 if (rpc_queue_pdu(rpc, pdu) != 0) {
558 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdir call");
559 rpc_free_pdu(rpc, pdu);
560 return -3;
561 }
562
563 return 0;
564}
565
f390f181
RS		 566int 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)
567{
568 struct rpc_pdu *pdu;
569 READDIRPLUS3args args;
570
571 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READDIRPLUS, cb, private_data, (xdrproc_t)xdr_READDIRPLUS3res, sizeof(READDIRPLUS3res));
572 if (pdu == NULL) {
573 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readdirplus call");
574 return -1;
575 }
576
ea98629a 577 memset(&args, 0, sizeof(READDIRPLUS3args));
f390f181
RS		 578 args.dir.data.data_len = fh->data.data_len;
579 args.dir.data.data_val = fh->data.data_val;
580 args.cookie = cookie;
581 memcpy(&args.cookieverf, cookieverf, sizeof(cookieverf3));
582 args.dircount = count;
583 args.maxcount = count;
584
585 if (xdr_READDIRPLUS3args(&pdu->xdr, &args) == 0) {
586 rpc_set_error(rpc, "XDR error: Failed to encode READDIRPLUS3args");
587 rpc_free_pdu(rpc, pdu);
588 return -2;
589 }
590
591 if (rpc_queue_pdu(rpc, pdu) != 0) {
592 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readdirplus call");
593 rpc_free_pdu(rpc, pdu);
594 return -3;
595 }
596
597 return 0;
598}
599
84004dbf
RS		 600int rpc_nfs_fsstat_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
601{
602 struct rpc_pdu *pdu;
603 FSSTAT3args args;
604
605 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSSTAT, cb, private_data, (xdrproc_t)xdr_FSSTAT3res, sizeof(FSSTAT3res));
606 if (pdu == NULL) {
607 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsstat call");
608 return -1;
609 }
610
611 args.fsroot.data.data_len = fh->data.data_len;
612 args.fsroot.data.data_val = fh->data.data_val;
613
614 if (xdr_FSSTAT3args(&pdu->xdr, &args) == 0) {
615 rpc_set_error(rpc, "XDR error: Failed to encode FSSTAT3args");
616 rpc_free_pdu(rpc, pdu);
617 return -2;
618 }
619
620 if (rpc_queue_pdu(rpc, pdu) != 0) {
621 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsstat call");
622 rpc_free_pdu(rpc, pdu);
623 return -3;
624 }
625
626 return 0;
627}
628
1058201e
RS		 629int rpc_nfs_fsinfo_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
630{
631 struct rpc_pdu *pdu;
632 FSINFO3args args;
633
634 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_FSINFO, cb, private_data, (xdrproc_t)xdr_FSINFO3res, sizeof(FSINFO3res));
635 if (pdu == NULL) {
636 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/fsinfo call");
637 return -1;
638 }
639
640 args.fsroot.data.data_len = fh->data.data_len;
641 args.fsroot.data.data_val = fh->data.data_val;
642
643 if (xdr_FSINFO3args(&pdu->xdr, &args) == 0) {
644 rpc_set_error(rpc, "XDR error: Failed to encode FSINFO3args");
645 rpc_free_pdu(rpc, pdu);
646 return -2;
647 }
648
649 if (rpc_queue_pdu(rpc, pdu) != 0) {
650 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/fsinfo call");
651 rpc_free_pdu(rpc, pdu);
652 return -3;
653 }
654
655 return 0;
656}
84004dbf
RS		 657
658int rpc_nfs_readlink_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, void *private_data)
659{
660 struct rpc_pdu *pdu;
661 READLINK3args args;
662
663 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_READLINK, cb, private_data, (xdrproc_t)xdr_READLINK3res, sizeof(READLINK3res));
664 if (pdu == NULL) {
665 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/readlink call");
666 return -1;
667 }
668
669 args.symlink.data.data_len = fh->data.data_len;
670 args.symlink.data.data_val = fh->data.data_val;
671
672 if (xdr_READLINK3args(&pdu->xdr, &args) == 0) {
673 rpc_set_error(rpc, "XDR error: Failed to encode READLINK3args");
674 rpc_free_pdu(rpc, pdu);
675 return -2;
676 }
677
678 if (rpc_queue_pdu(rpc, pdu) != 0) {
679 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/readlink call");
680 rpc_free_pdu(rpc, pdu);
681 return -3;
682 }
683
684 return 0;
685}
686
687
688int rpc_nfs_symlink_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *fh, char *newname, char *oldpath, void *private_data)
689{
690 struct rpc_pdu *pdu;
691 SYMLINK3args args;
692
693 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_SYMLINK, cb, private_data, (xdrproc_t)xdr_SYMLINK3res, sizeof(SYMLINK3res));
694 if (pdu == NULL) {
695 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/symlink call");
696 return -1;
697 }
698
ea98629a 699 memset(&args, 0, sizeof(SYMLINK3args));
84004dbf
RS		 700 args.where.dir.data.data_len = fh->data.data_len;
701 args.where.dir.data.data_val = fh->data.data_val;
702 args.where.name = newname;
703 args.symlink.symlink_attributes.mode.set_it = 1;
704 args.symlink.symlink_attributes.mode.set_mode3_u.mode = S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH;
705 args.symlink.symlink_data = oldpath;
706
707 if (xdr_SYMLINK3args(&pdu->xdr, &args) == 0) {
708 rpc_set_error(rpc, "XDR error: Failed to encode SYMLINK3args");
709 rpc_free_pdu(rpc, pdu);
710 return -2;
711 }
712
713 if (rpc_queue_pdu(rpc, pdu) != 0) {
714 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/symlink call");
715 rpc_free_pdu(rpc, pdu);
716 return -3;
717 }
718
719 return 0;
720}
721
722
723
724
725int 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)
726{
727 struct rpc_pdu *pdu;
728 RENAME3args args;
729
730 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_RENAME, cb, private_data, (xdrproc_t)xdr_RENAME3res, sizeof(RENAME3res));
731 if (pdu == NULL) {
732 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/rename call");
733 return -1;
734 }
735
ea98629a 736 memset(&args, 0, sizeof(RENAME3args));
84004dbf
RS		 737 args.from.dir.data.data_len = olddir->data.data_len;
738 args.from.dir.data.data_val = olddir->data.data_val;
739 args.from.name = oldname;
740 args.to.dir.data.data_len = newdir->data.data_len;
741 args.to.dir.data.data_val = newdir->data.data_val;
742 args.to.name = newname;
743
744 if (xdr_RENAME3args(&pdu->xdr, &args) == 0) {
745 rpc_set_error(rpc, "XDR error: Failed to encode RENAME3args");
746 rpc_free_pdu(rpc, pdu);
747 return -2;
748 }
749
750 if (rpc_queue_pdu(rpc, pdu) != 0) {
751 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/rename call");
752 rpc_free_pdu(rpc, pdu);
753 return -3;
754 }
755
756 return 0;
757}
758
759
760
761
762int rpc_nfs_link_async(struct rpc_context *rpc, rpc_cb cb, struct nfs_fh3 *file, struct nfs_fh3 *newdir, char *newname, void *private_data)
763{
764 struct rpc_pdu *pdu;
765 LINK3args args;
766
767 pdu = rpc_allocate_pdu(rpc, NFS_PROGRAM, NFS_V3, NFS3_LINK, cb, private_data, (xdrproc_t)xdr_LINK3res, sizeof(LINK3res));
768 if (pdu == NULL) {
769 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for nfs/link call");
770 return -1;
771 }
772
ea98629a 773 memset(&args, 0, sizeof(LINK3args));
84004dbf
RS		 774 args.file.data.data_len = file->data.data_len;
775 args.file.data.data_val = file->data.data_val;
776 args.link.dir.data.data_len = newdir->data.data_len;
777 args.link.dir.data.data_val = newdir->data.data_val;
778 args.link.name = newname;
779
780 if (xdr_LINK3args(&pdu->xdr, &args) == 0) {
781 rpc_set_error(rpc, "XDR error: Failed to encode LINK3args");
782 rpc_free_pdu(rpc, pdu);
783 return -2;
784 }
785
786 if (rpc_queue_pdu(rpc, pdu) != 0) {
787 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for nfs/link call");
788 rpc_free_pdu(rpc, pdu);
789 return -3;
790 }
791
792 return 0;
793}
794
795
796
797
libnfs Piment Noir Debian package repository