repositories / deb_libnfs.git / blob
? search:


ba7b64893f4ede24fc3b6be4f4eab5774dac09fc
[deb_libnfs.git] / lib / libnfs.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 * High level api to nfs filesystems
19 */
20 #ifdef WIN32
21 #include "win32_compat.h"
22 #define DllExport
23 #else
24 #include <strings.h>
25 #include <sys/statvfs.h>
26 #include <utime.h>
27 #include <unistd.h>
28 #endif/*WIN32*/
29
30 #define _GNU_SOURCE
31
32 #include <stdio.h>
33 #include <stdarg.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <errno.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <fcntl.h>
40 #include "libnfs.h"
41 #include "libnfs-raw.h"
42 #include "libnfs-raw-mount.h"
43 #include "libnfs-raw-nfs.h"
44 #include "libnfs-private.h"
45
46 struct nfsdir {
47 struct nfsdirent *entries;
48 struct nfsdirent *current;
49 };
50
51 struct nfsfh {
52 struct nfs_fh3 fh;
53 int is_sync;
54 off_t offset;
55 };
56
57 struct nfs_context {
58 struct rpc_context *rpc;
59 char *server;
60 char *export;
61 struct nfs_fh3 rootfh;
62 size_t readmax;
63 size_t writemax;
64 };
65
66 void nfs_free_nfsdir(struct nfsdir *nfsdir)
67 {
68 while (nfsdir->entries) {
69 struct nfsdirent *dirent = nfsdir->entries->next;
70 if (nfsdir->entries->name != NULL) {
71 free(nfsdir->entries->name);
72 }
73 free(nfsdir->entries);
74 nfsdir->entries = dirent;
75 }
76 free(nfsdir);
77 }
78
79 struct nfs_cb_data;
80 typedef int (*continue_func)(struct nfs_context *nfs, struct nfs_cb_data *data);
81
82 struct nfs_cb_data {
83 struct nfs_context *nfs;
84 struct nfsfh *nfsfh;
85 char *saved_path, *path;
86
87 nfs_cb cb;
88 void *private_data;
89
90 continue_func continue_cb;
91 void *continue_data;
92 void (*free_continue_data)(void *);
93 int continue_int;
94
95 struct nfs_fh3 fh;
96
97 /* for multi-read/write calls. */
98 int error;
99 int cancel;
100 int num_calls;
101 off_t start_offset, max_offset;
102 char *buffer;
103 };
104
105 struct nfs_mcb_data {
106 struct nfs_cb_data *data;
107 off_t offset;
108 size_t count;
109 };
110
111 static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb_data *data, struct nfs_fh3 *fh);
112
113
114 void nfs_set_auth(struct nfs_context *nfs, struct AUTH *auth)
115 {
116 rpc_set_auth(nfs->rpc, auth);
117 }
118
119 int nfs_get_fd(struct nfs_context *nfs)
120 {
121 return rpc_get_fd(nfs->rpc);
122 }
123
124 int nfs_queue_length(struct nfs_context *nfs)
125 {
126 return rpc_queue_length(nfs->rpc);
127 }
128
129 int nfs_which_events(struct nfs_context *nfs)
130 {
131 return rpc_which_events(nfs->rpc);
132 }
133
134 int nfs_service(struct nfs_context *nfs, int revents)
135 {
136 return rpc_service(nfs->rpc, revents);
137 }
138
139 char *nfs_get_error(struct nfs_context *nfs)
140 {
141 return rpc_get_error(nfs->rpc);
142 };
143
144 struct nfs_context *nfs_init_context(void)
145 {
146 struct nfs_context *nfs;
147
148 nfs = malloc(sizeof(struct nfs_context));
149 if (nfs == NULL) {
150 return NULL;
151 }
152 nfs->rpc = rpc_init_context();
153 if (nfs->rpc == NULL) {
154 free(nfs);
155 return NULL;
156 }
157
158 nfs->server = NULL;
159 nfs->export = NULL;
160
161 nfs->rootfh.data.data_len = 0;
162 nfs->rootfh.data.data_val = NULL;
163
164 return nfs;
165 }
166
167 void nfs_destroy_context(struct nfs_context *nfs)
168 {
169 rpc_destroy_context(nfs->rpc);
170 nfs->rpc = NULL;
171
172 if (nfs->server) {
173 free(nfs->server);
174 nfs->server = NULL;
175 }
176
177 if (nfs->export) {
178 free(nfs->export);
179 nfs->export = NULL;
180 }
181
182 if (nfs->rootfh.data.data_val != NULL) {
183 free(nfs->rootfh.data.data_val);
184 nfs->rootfh.data.data_val = NULL;
185 }
186
187 free(nfs);
188 }
189
190 void free_nfs_cb_data(struct nfs_cb_data *data)
191 {
192 if (data->saved_path != NULL) {
193 free(data->saved_path);
194 data->saved_path = NULL;
195 }
196
197 if (data->continue_data != NULL) {
198 data->free_continue_data(data->continue_data);
199 data->continue_data = NULL;
200 }
201
202 if (data->fh.data.data_val != NULL) {
203 free(data->fh.data.data_val);
204 data->fh.data.data_val = NULL;
205 }
206
207 if (data->buffer != NULL) {
208 free(data->buffer);
209 data->buffer = NULL;
210 }
211
212 free(data);
213 }
214
215
216
217
218
219 static void nfs_mount_10_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
220 {
221 struct nfs_cb_data *data = private_data;
222 struct nfs_context *nfs = data->nfs;
223
224 if (status == RPC_STATUS_ERROR) {
225 data->cb(-EFAULT, nfs, command_data, data->private_data);
226 free_nfs_cb_data(data);
227 return;
228 }
229 if (status == RPC_STATUS_CANCEL) {
230 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
231 free_nfs_cb_data(data);
232 return;
233 }
234
235 data->cb(0, nfs, NULL, data->private_data);
236 free_nfs_cb_data(data);
237 }
238
239 static void nfs_mount_9_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
240 {
241 struct nfs_cb_data *data = private_data;
242 struct nfs_context *nfs = data->nfs;
243 FSINFO3res *res = command_data;
244
245 if (status == RPC_STATUS_ERROR) {
246 data->cb(-EFAULT, nfs, command_data, data->private_data);
247 free_nfs_cb_data(data);
248 return;
249 }
250 if (status == RPC_STATUS_CANCEL) {
251 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
252 free_nfs_cb_data(data);
253 return;
254 }
255
256 nfs->readmax = res->FSINFO3res_u.resok.rtmax;
257 nfs->writemax = res->FSINFO3res_u.resok.wtmax;
258
259 if (rpc_nfs_getattr_async(rpc, nfs_mount_10_cb, &nfs->rootfh, data) != 0) {
260 data->cb(-ENOMEM, nfs, command_data, data->private_data);
261 free_nfs_cb_data(data);
262 return;
263 }
264 }
265
266 static void nfs_mount_8_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
267 {
268 struct nfs_cb_data *data = private_data;
269 struct nfs_context *nfs = data->nfs;
270
271 if (status == RPC_STATUS_ERROR) {
272 data->cb(-EFAULT, nfs, command_data, data->private_data);
273 free_nfs_cb_data(data);
274 return;
275 }
276 if (status == RPC_STATUS_CANCEL) {
277 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
278 free_nfs_cb_data(data);
279 return;
280 }
281
282 if (rpc_nfs_fsinfo_async(rpc, nfs_mount_9_cb, &nfs->rootfh, data) != 0) {
283 data->cb(-ENOMEM, nfs, command_data, data->private_data);
284 free_nfs_cb_data(data);
285 return;
286 }
287 }
288
289
290 static void nfs_mount_7_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
291 {
292 struct nfs_cb_data *data = private_data;
293 struct nfs_context *nfs = data->nfs;
294
295 if (status == RPC_STATUS_ERROR) {
296 data->cb(-EFAULT, nfs, command_data, data->private_data);
297 free_nfs_cb_data(data);
298 return;
299 }
300 if (status == RPC_STATUS_CANCEL) {
301 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
302 free_nfs_cb_data(data);
303 return;
304 }
305
306 if (rpc_nfs_null_async(rpc, nfs_mount_8_cb, data) != 0) {
307 data->cb(-ENOMEM, nfs, command_data, data->private_data);
308 free_nfs_cb_data(data);
309 return;
310 }
311 }
312
313
314 static void nfs_mount_6_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
315 {
316 struct nfs_cb_data *data = private_data;
317 struct nfs_context *nfs = data->nfs;
318 mountres3 *res;
319
320 if (status == RPC_STATUS_ERROR) {
321 data->cb(-EFAULT, nfs, command_data, data->private_data);
322 free_nfs_cb_data(data);
323 return;
324 }
325 if (status == RPC_STATUS_CANCEL) {
326 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
327 free_nfs_cb_data(data);
328 return;
329 }
330
331 res = command_data;
332 if (res->fhs_status != MNT3_OK) {
333 rpc_set_error(rpc, "RPC error: Mount failed with error %s(%d) %s(%d)", mountstat3_to_str(res->fhs_status), res->fhs_status, strerror(-mountstat3_to_errno(res->fhs_status)), -mountstat3_to_errno(res->fhs_status));
334 data->cb(mountstat3_to_errno(res->fhs_status), nfs, rpc_get_error(rpc), data->private_data);
335 free_nfs_cb_data(data);
336 return;
337 }
338
339 nfs->rootfh.data.data_len = res->mountres3_u.mountinfo.fhandle.fhandle3_len;
340 nfs->rootfh.data.data_val = malloc(nfs->rootfh.data.data_len);
341 if (nfs->rootfh.data.data_val == NULL) {
342 rpc_set_error(rpc, "Out of memory. Could not allocate memory to store root filehandle");
343 data->cb(-ENOMEM, nfs, rpc_get_error(rpc), data->private_data);
344 free_nfs_cb_data(data);
345 return;
346 }
347 memcpy(nfs->rootfh.data.data_val, res->mountres3_u.mountinfo.fhandle.fhandle3_val, nfs->rootfh.data.data_len);
348
349 rpc_disconnect(rpc, "normal disconnect");
350 if (rpc_connect_async(rpc, nfs->server, 2049, nfs_mount_7_cb, data) != 0) {
351 data->cb(-ENOMEM, nfs, command_data, data->private_data);
352 free_nfs_cb_data(data);
353 return;
354 }
355 }
356
357
358 static void nfs_mount_5_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
359 {
360 struct nfs_cb_data *data = private_data;
361 struct nfs_context *nfs = data->nfs;
362
363 if (status == RPC_STATUS_ERROR) {
364 data->cb(-EFAULT, nfs, command_data, data->private_data);
365 free_nfs_cb_data(data);
366 return;
367 }
368 if (status == RPC_STATUS_CANCEL) {
369 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
370 free_nfs_cb_data(data);
371 return;
372 }
373
374 if (rpc_mount_mnt_async(rpc, nfs_mount_6_cb, nfs->export, data) != 0) {
375 data->cb(-ENOMEM, nfs, command_data, data->private_data);
376 free_nfs_cb_data(data);
377 return;
378 }
379 }
380
381 static void nfs_mount_4_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
382 {
383 struct nfs_cb_data *data = private_data;
384 struct nfs_context *nfs = data->nfs;
385
386 if (status == RPC_STATUS_ERROR) {
387 data->cb(-EFAULT, nfs, command_data, data->private_data);
388 free_nfs_cb_data(data);
389 return;
390 }
391 if (status == RPC_STATUS_CANCEL) {
392 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
393 free_nfs_cb_data(data);
394 return;
395 }
396
397 if (rpc_mount_null_async(rpc, nfs_mount_5_cb, data) != 0) {
398 data->cb(-ENOMEM, nfs, command_data, data->private_data);
399 free_nfs_cb_data(data);
400 return;
401 }
402 }
403
404 static void nfs_mount_3_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
405 {
406 struct nfs_cb_data *data = private_data;
407 struct nfs_context *nfs = data->nfs;
408 uint32_t mount_port;
409
410 if (status == RPC_STATUS_ERROR) {
411 data->cb(-EFAULT, nfs, command_data, data->private_data);
412 free_nfs_cb_data(data);
413 return;
414 }
415 if (status == RPC_STATUS_CANCEL) {
416 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
417 free_nfs_cb_data(data);
418 return;
419 }
420
421 mount_port = *(uint32_t *)command_data;
422 if (mount_port == 0) {
423 rpc_set_error(rpc, "RPC error. Mount program is not available on %s", nfs->server);
424 data->cb(-ENOENT, nfs, command_data, data->private_data);
425 free_nfs_cb_data(data);
426 return;
427 }
428
429 rpc_disconnect(rpc, "normal disconnect");
430 if (rpc_connect_async(rpc, nfs->server, mount_port, nfs_mount_4_cb, data) != 0) {
431 data->cb(-ENOMEM, nfs, command_data, data->private_data);
432 free_nfs_cb_data(data);
433 return;
434 }
435 }
436
437
438 static void nfs_mount_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
439 {
440 struct nfs_cb_data *data = private_data;
441 struct nfs_context *nfs = data->nfs;
442
443 if (status == RPC_STATUS_ERROR) {
444 data->cb(-EFAULT, nfs, command_data, data->private_data);
445 free_nfs_cb_data(data);
446 return;
447 }
448 if (status == RPC_STATUS_CANCEL) {
449 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
450 free_nfs_cb_data(data);
451 return;
452 }
453
454 if (rpc_pmap_getport_async(rpc, MOUNT_PROGRAM, MOUNT_V3, nfs_mount_3_cb, private_data) != 0) {
455 data->cb(-ENOMEM, nfs, command_data, data->private_data);
456 free_nfs_cb_data(data);
457 return;
458 }
459 }
460
461 static void nfs_mount_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
462 {
463 struct nfs_cb_data *data = private_data;
464 struct nfs_context *nfs = data->nfs;
465
466 if (status == RPC_STATUS_ERROR) {
467 data->cb(-EFAULT, nfs, command_data, data->private_data);
468 free_nfs_cb_data(data);
469 return;
470 }
471 if (status == RPC_STATUS_CANCEL) {
472 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
473 free_nfs_cb_data(data);
474 return;
475 }
476
477 if (rpc_pmap_null_async(rpc, nfs_mount_2_cb, data) != 0) {
478 data->cb(-ENOMEM, nfs, command_data, data->private_data);
479 free_nfs_cb_data(data);
480 return;
481 }
482 }
483
484 /*
485 * Async call for mounting an nfs share and geting the root filehandle
486 */
487 int nfs_mount_async(struct nfs_context *nfs, const char *server, const char *export, nfs_cb cb, void *private_data)
488 {
489 struct nfs_cb_data *data;
490 char *new_server, *new_export;
491
492 data = malloc(sizeof(struct nfs_cb_data));
493 if (data == NULL) {
494 rpc_set_error(nfs->rpc, "out of memory. failed to allocate memory for nfs mount data");
495 return -1;
496 }
497 memset(data, 0, sizeof(struct nfs_cb_data));
498 new_server = strdup(server);
499 new_export = strdup(export);
500 if (nfs->server != NULL) {
501 free(nfs->server);
502 nfs->server = NULL;
503 }
504 nfs->server = new_server;
505 if (nfs->export != NULL) {
506 free(nfs->export);
507 nfs->export = NULL;
508 }
509 nfs->export = new_export;
510 data->nfs = nfs;
511 data->cb = cb;
512 data->private_data = private_data;
513
514 if (rpc_connect_async(nfs->rpc, server, 111, nfs_mount_1_cb, data) != 0) {
515 rpc_set_error(nfs->rpc, "Failed to start connection");
516 free_nfs_cb_data(data);
517 return -1;
518 }
519
520 return 0;
521 }
522
523
524
525 /*
526 * Functions to first look up a path, component by component, and then finally call a specific function once
527 * the filehandle for the final component is found.
528 */
529 static void nfs_lookup_path_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
530 {
531 struct nfs_cb_data *data = private_data;
532 struct nfs_context *nfs = data->nfs;
533 LOOKUP3res *res;
534
535 if (status == RPC_STATUS_ERROR) {
536 data->cb(-EFAULT, nfs, command_data, data->private_data);
537 free_nfs_cb_data(data);
538 return;
539 }
540 if (status == RPC_STATUS_CANCEL) {
541 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
542 free_nfs_cb_data(data);
543 return;
544 }
545
546 res = command_data;
547 if (res->status != NFS3_OK) {
548 rpc_set_error(nfs->rpc, "NFS: Lookup of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
549 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
550 free_nfs_cb_data(data);
551 return;
552 }
553
554 if (nfs_lookup_path_async_internal(nfs, data, &res->LOOKUP3res_u.resok.object) != 0) {
555 rpc_set_error(nfs->rpc, "Failed to create lookup pdu");
556 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
557 free_nfs_cb_data(data);
558 return;
559 }
560 }
561
562 static int nfs_lookup_path_async_internal(struct nfs_context *nfs, struct nfs_cb_data *data, struct nfs_fh3 *fh)
563 {
564 char *path, *str;
565
566 while (*data->path == '/') {
567 data->path++;
568 }
569
570 path = data->path;
571 str = strchr(path, '/');
572 if (str != NULL) {
573 *str = 0;
574 data->path = str+1;
575 } else {
576 while (*data->path != 0) {
577 data->path++;
578 }
579 }
580
581 if (*path == 0) {
582 data->fh.data.data_len = fh->data.data_len;
583 data->fh.data.data_val = malloc(data->fh.data.data_len);
584 if (data->fh.data.data_val == NULL) {
585 rpc_set_error(nfs->rpc, "Out of memory: Failed to allocate fh for %s", data->path);
586 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
587 free_nfs_cb_data(data);
588 return -1;
589 }
590 memcpy(data->fh.data.data_val, fh->data.data_val, data->fh.data.data_len);
591 data->continue_cb(nfs, data);
592 return 0;
593 }
594
595 if (rpc_nfs_lookup_async(nfs->rpc, nfs_lookup_path_1_cb, fh, path, data) != 0) {
596 rpc_set_error(nfs->rpc, "RPC error: Failed to send lookup call for %s", data->path);
597 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
598 free_nfs_cb_data(data);
599 return -1;
600 }
601 return 0;
602 }
603
604 static int nfs_lookuppath_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data, continue_func continue_cb, void *continue_data, void (*free_continue_data)(void *), int continue_int)
605 {
606 struct nfs_cb_data *data;
607
608 if (path[0] != '/') {
609 rpc_set_error(nfs->rpc, "Pathname is not absulute %s", path);
610 return -1;
611 }
612
613 data = malloc(sizeof(struct nfs_cb_data));
614 if (data == NULL) {
615 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
616 return -1;
617 }
618 memset(data, 0, sizeof(struct nfs_cb_data));
619 data->nfs = nfs;
620 data->cb = cb;
621 data->continue_cb = continue_cb;
622 data->continue_data = continue_data;
623 data->free_continue_data = free_continue_data;
624 data->continue_int = continue_int;
625 data->private_data = private_data;
626 data->saved_path = strdup(path);
627 if (data->saved_path == NULL) {
628 rpc_set_error(nfs->rpc, "out of memory: failed to copy path string");
629 free_nfs_cb_data(data);
630 return -1;
631 }
632 data->path = data->saved_path;
633
634 if (nfs_lookup_path_async_internal(nfs, data, &nfs->rootfh) != 0) {
635 /* return 0 here since the callback will be invoked if there is a failure */
636 return 0;
637 }
638 return 0;
639 }
640
641
642
643
644
645 /*
646 * Async stat()
647 */
648 static void nfs_stat_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
649 {
650 GETATTR3res *res;
651 struct nfs_cb_data *data = private_data;
652 struct nfs_context *nfs = data->nfs;
653 struct stat st;
654
655 if (status == RPC_STATUS_ERROR) {
656 data->cb(-EFAULT, nfs, command_data, data->private_data);
657 free_nfs_cb_data(data);
658 return;
659 }
660 if (status == RPC_STATUS_CANCEL) {
661 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
662 free_nfs_cb_data(data);
663 return;
664 }
665
666 res = command_data;
667 if (res->status != NFS3_OK) {
668 rpc_set_error(nfs->rpc, "NFS: GETATTR of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
669 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
670 free_nfs_cb_data(data);
671 return;
672 }
673
674 st.st_dev = -1;
675 st.st_ino = res->GETATTR3res_u.resok.obj_attributes.fileid;
676 st.st_mode = res->GETATTR3res_u.resok.obj_attributes.mode;
677 if (res->GETATTR3res_u.resok.obj_attributes.type == NF3DIR) {
678 st.st_mode |= S_IFDIR ;
679 }
680 st.st_nlink = res->GETATTR3res_u.resok.obj_attributes.nlink;
681 st.st_uid = res->GETATTR3res_u.resok.obj_attributes.uid;
682 st.st_gid = res->GETATTR3res_u.resok.obj_attributes.gid;
683 st.st_rdev = 0;
684 st.st_size = res->GETATTR3res_u.resok.obj_attributes.size;
685 #ifndef WIN32
686 st.st_blksize = 4096;
687 st.st_blocks = res->GETATTR3res_u.resok.obj_attributes.size / 4096;
688 #endif//WIN32
689 st.st_atime = res->GETATTR3res_u.resok.obj_attributes.atime.seconds;
690 st.st_mtime = res->GETATTR3res_u.resok.obj_attributes.mtime.seconds;
691 st.st_ctime = res->GETATTR3res_u.resok.obj_attributes.ctime.seconds;
692
693 data->cb(0, nfs, &st, data->private_data);
694 free_nfs_cb_data(data);
695 }
696
697 static int nfs_stat_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
698 {
699 if (rpc_nfs_getattr_async(nfs->rpc, nfs_stat_1_cb, &data->fh, data) != 0) {
700 rpc_set_error(nfs->rpc, "RPC error: Failed to send STAT GETATTR call for %s", data->path);
701 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
702 free_nfs_cb_data(data);
703 return -1;
704 }
705 return 0;
706 }
707
708 int nfs_stat_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
709 {
710 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_stat_continue_internal, NULL, NULL, 0) != 0) {
711 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
712 return -1;
713 }
714
715 return 0;
716 }
717
718
719
720
721
722 /*
723 * Async open()
724 */
725 static void nfs_open_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
726 {
727 ACCESS3res *res;
728 struct nfs_cb_data *data = private_data;
729 struct nfs_context *nfs = data->nfs;
730 struct nfsfh *nfsfh;
731 unsigned int nfsmode = 0;
732
733 if (status == RPC_STATUS_ERROR) {
734 data->cb(-EFAULT, nfs, command_data, data->private_data);
735 free_nfs_cb_data(data);
736 return;
737 }
738 if (status == RPC_STATUS_CANCEL) {
739 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
740 free_nfs_cb_data(data);
741 return;
742 }
743
744 res = command_data;
745 if (res->status != NFS3_OK) {
746 rpc_set_error(nfs->rpc, "NFS: ACCESS of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
747 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
748 free_nfs_cb_data(data);
749 return;
750 }
751
752 if (data->continue_int & O_WRONLY) {
753 nfsmode |= ACCESS3_MODIFY;
754 }
755 if (data->continue_int & O_RDWR) {
756 nfsmode |= ACCESS3_READ|ACCESS3_MODIFY;
757 }
758 if (!(data->continue_int & (O_WRONLY|O_RDWR))) {
759 nfsmode |= ACCESS3_READ;
760 }
761
762
763 if (res->ACCESS3res_u.resok.access != nfsmode) {
764 rpc_set_error(nfs->rpc, "NFS: ACCESS denied. Required access %c%c%c. Allowed access %c%c%c",
765 nfsmode&ACCESS3_READ?'r':'-',
766 nfsmode&ACCESS3_MODIFY?'w':'-',
767 nfsmode&ACCESS3_EXECUTE?'x':'-',
768 res->ACCESS3res_u.resok.access&ACCESS3_READ?'r':'-',
769 res->ACCESS3res_u.resok.access&ACCESS3_MODIFY?'w':'-',
770 res->ACCESS3res_u.resok.access&ACCESS3_EXECUTE?'x':'-');
771 data->cb(-EACCES, nfs, rpc_get_error(nfs->rpc), data->private_data);
772 free_nfs_cb_data(data);
773 return;
774 }
775
776 nfsfh = malloc(sizeof(struct nfsfh));
777 if (nfsfh == NULL) {
778 rpc_set_error(nfs->rpc, "NFS: Failed to allocate nfsfh structure");
779 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
780 free_nfs_cb_data(data);
781 return;
782 }
783 memset(nfsfh, 0, sizeof(struct nfsfh));
784
785 if (data->continue_int & O_SYNC) {
786 nfsfh->is_sync = 1;
787 }
788
789 /* steal the filehandle */
790 nfsfh->fh.data.data_len = data->fh.data.data_len;
791 nfsfh->fh.data.data_val = data->fh.data.data_val;
792 data->fh.data.data_val = NULL;
793
794 data->cb(0, nfs, nfsfh, data->private_data);
795 free_nfs_cb_data(data);
796 }
797
798 static int nfs_open_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
799 {
800 int nfsmode = 0;
801
802 if (data->continue_int & O_WRONLY) {
803 nfsmode |= ACCESS3_MODIFY;
804 }
805 if (data->continue_int & O_RDWR) {
806 nfsmode |= ACCESS3_READ|ACCESS3_MODIFY;
807 }
808 if (!(data->continue_int & (O_WRONLY|O_RDWR))) {
809 nfsmode |= ACCESS3_READ;
810 }
811
812 if (rpc_nfs_access_async(nfs->rpc, nfs_open_cb, &data->fh, nfsmode, data) != 0) {
813 rpc_set_error(nfs->rpc, "RPC error: Failed to send OPEN ACCESS call for %s", data->path);
814 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
815 free_nfs_cb_data(data);
816 return -1;
817 }
818 return 0;
819 }
820
821 int nfs_open_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
822 {
823 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_open_continue_internal, NULL, NULL, mode) != 0) {
824 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
825 return -1;
826 }
827
828 return 0;
829 }
830
831
832
833
834
835 /*
836 * Async pread()
837 */
838 static void nfs_pread_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
839 {
840 struct nfs_cb_data *data = private_data;
841 struct nfs_context *nfs = data->nfs;
842 READ3res *res;
843
844 if (status == RPC_STATUS_ERROR) {
845 data->cb(-EFAULT, nfs, command_data, data->private_data);
846 free_nfs_cb_data(data);
847 return;
848 }
849 if (status == RPC_STATUS_CANCEL) {
850 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
851 free_nfs_cb_data(data);
852 return;
853 }
854
855 res = command_data;
856 if (res->status != NFS3_OK) {
857 rpc_set_error(nfs->rpc, "NFS: Read failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
858 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
859 free_nfs_cb_data(data);
860 return;
861 }
862
863 data->nfsfh->offset += res->READ3res_u.resok.count;
864 data->cb(res->READ3res_u.resok.count, nfs, res->READ3res_u.resok.data.data_val, data->private_data);
865 free_nfs_cb_data(data);
866 }
867
868 static void nfs_pread_mcb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
869 {
870 struct nfs_mcb_data *mdata = private_data;
871 struct nfs_cb_data *data = mdata->data;
872 struct nfs_context *nfs = data->nfs;
873 READ3res *res;
874
875 data->num_calls--;
876
877 if (status == RPC_STATUS_ERROR) {
878 /* flag the failure but do not invoke callback until we have received all responses */
879 data->error = 1;
880 }
881 if (status == RPC_STATUS_CANCEL) {
882 /* flag the cancellation but do not invoke callback until we have received all responses */
883 data->cancel = 1;
884 }
885
886 /* reassemble the data into the buffer */
887 if (status == RPC_STATUS_SUCCESS) {
888 res = command_data;
889 if (res->status != NFS3_OK) {
890 rpc_set_error(nfs->rpc, "NFS: Read failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
891 data->error = 1;
892 } else {
893 if (res->READ3res_u.resok.count > 0) {
894 memcpy(&data->buffer[mdata->offset - data->start_offset], res->READ3res_u.resok.data.data_val, res->READ3res_u.resok.count);
895 if ((unsigned)data->max_offset < mdata->offset + res->READ3res_u.resok.count) {
896 data->max_offset = mdata->offset + res->READ3res_u.resok.count;
897 }
898 }
899 }
900 }
901
902 if (data->num_calls > 0) {
903 /* still waiting for more replies */
904 free(mdata);
905 return;
906 }
907
908 if (data->error != 0) {
909 data->cb(-EFAULT, nfs, command_data, data->private_data);
910 free_nfs_cb_data(data);
911 free(mdata);
912 return;
913 }
914 if (data->cancel != 0) {
915 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
916 free_nfs_cb_data(data);
917 free(mdata);
918 return;
919 }
920
921 data->nfsfh->offset = data->max_offset;
922 data->cb(data->max_offset - data->start_offset, nfs, data->buffer, data->private_data);
923
924 free_nfs_cb_data(data);
925 free(mdata);
926 }
927
928 int nfs_pread_async(struct nfs_context *nfs, struct nfsfh *nfsfh, off_t offset, size_t count, nfs_cb cb, void *private_data)
929 {
930 struct nfs_cb_data *data;
931
932 data = malloc(sizeof(struct nfs_cb_data));
933 if (data == NULL) {
934 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
935 return -1;
936 }
937 memset(data, 0, sizeof(struct nfs_cb_data));
938 data->nfs = nfs;
939 data->cb = cb;
940 data->private_data = private_data;
941 data->nfsfh = nfsfh;
942
943 nfsfh->offset = offset;
944
945 if (count <= nfs_get_readmax(nfs)) {
946 if (rpc_nfs_read_async(nfs->rpc, nfs_pread_cb, &nfsfh->fh, offset, count, data) != 0) {
947 rpc_set_error(nfs->rpc, "RPC error: Failed to send READ call for %s", data->path);
948 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
949 free_nfs_cb_data(data);
950 return -1;
951 }
952 return 0;
953 }
954
955 /* trying to read more than maximum server read size, we has to chop it up into smaller
956 * reads and collect into a reassembly buffer.
957 * we send all reads in parallell so that performance is still good.
958 */
959 data->max_offset = offset;
960 data->start_offset = offset;
961
962 data->buffer = malloc(count);
963 if (data->buffer == NULL) {
964 rpc_set_error(nfs->rpc, "Out-Of-Memory: Failed to allocate reassembly buffer for %d bytes", (int)count);
965 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
966 free_nfs_cb_data(data);
967 return -1;
968 }
969
970 while (count > 0) {
971 size_t readcount = count;
972 struct nfs_mcb_data *mdata;
973
974 if (readcount > nfs_get_readmax(nfs)) {
975 readcount = nfs_get_readmax(nfs);
976 }
977
978 mdata = malloc(sizeof(struct nfs_mcb_data));
979 if (mdata == NULL) {
980 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_mcb_data structure");
981 return -1;
982 }
983 memset(mdata, 0, sizeof(struct nfs_mcb_data));
984 mdata->data = data;
985 mdata->offset = offset;
986 mdata->count = readcount;
987 if (rpc_nfs_read_async(nfs->rpc, nfs_pread_mcb, &nfsfh->fh, offset, readcount, mdata) != 0) {
988 rpc_set_error(nfs->rpc, "RPC error: Failed to send READ call for %s", data->path);
989 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
990 free(mdata);
991 return -1;
992 }
993
994 count -= readcount;
995 offset += readcount;
996 data->num_calls++;
997 }
998
999 return 0;
1000 }
1001
1002 /*
1003 * Async read()
1004 */
1005 int nfs_read_async(struct nfs_context *nfs, struct nfsfh *nfsfh, size_t count, nfs_cb cb, void *private_data)
1006 {
1007 return nfs_pread_async(nfs, nfsfh, nfsfh->offset, count, cb, private_data);
1008 }
1009
1010
1011
1012 /*
1013 * Async pwrite()
1014 */
1015 static void nfs_pwrite_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1016 {
1017 struct nfs_cb_data *data = private_data;
1018 struct nfs_context *nfs = data->nfs;
1019 WRITE3res *res;
1020
1021 if (status == RPC_STATUS_ERROR) {
1022 data->cb(-EFAULT, nfs, command_data, data->private_data);
1023 free_nfs_cb_data(data);
1024 return;
1025 }
1026 if (status == RPC_STATUS_CANCEL) {
1027 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1028 free_nfs_cb_data(data);
1029 return;
1030 }
1031
1032 res = command_data;
1033 if (res->status != NFS3_OK) {
1034 rpc_set_error(nfs->rpc, "NFS: Write failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1035 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1036 free_nfs_cb_data(data);
1037 return;
1038 }
1039
1040 data->nfsfh->offset += res->WRITE3res_u.resok.count;
1041 data->cb(res->WRITE3res_u.resok.count, nfs, NULL, data->private_data);
1042 free_nfs_cb_data(data);
1043 }
1044
1045 static void nfs_pwrite_mcb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1046 {
1047 struct nfs_mcb_data *mdata = private_data;
1048 struct nfs_cb_data *data = mdata->data;
1049 struct nfs_context *nfs = data->nfs;
1050 WRITE3res *res;
1051
1052 data->num_calls--;
1053
1054 if (status == RPC_STATUS_ERROR) {
1055 /* flag the failure but do not invoke callback until we have received all responses */
1056 data->error = 1;
1057 }
1058 if (status == RPC_STATUS_CANCEL) {
1059 /* flag the cancellation but do not invoke callback until we have received all responses */
1060 data->cancel = 1;
1061 }
1062
1063 if (status == RPC_STATUS_SUCCESS) {
1064 res = command_data;
1065 if (res->status != NFS3_OK) {
1066 rpc_set_error(nfs->rpc, "NFS: Write failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1067 data->error = 1;
1068 } else {
1069 if (res->WRITE3res_u.resok.count > 0) {
1070 if ((unsigned)data->max_offset < mdata->offset + res->WRITE3res_u.resok.count) {
1071 data->max_offset = mdata->offset + res->WRITE3res_u.resok.count;
1072 }
1073 }
1074 }
1075 }
1076
1077 if (data->num_calls > 0) {
1078 /* still waiting for more replies */
1079 free(mdata);
1080 return;
1081 }
1082
1083 if (data->error != 0) {
1084 data->cb(-EFAULT, nfs, command_data, data->private_data);
1085 free_nfs_cb_data(data);
1086 free(mdata);
1087 return;
1088 }
1089 if (data->cancel != 0) {
1090 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1091 free_nfs_cb_data(data);
1092 free(mdata);
1093 return;
1094 }
1095
1096 data->nfsfh->offset = data->max_offset;
1097 data->cb(data->max_offset - data->start_offset, nfs, NULL, data->private_data);
1098
1099 free_nfs_cb_data(data);
1100 free(mdata);
1101 }
1102
1103
1104 int nfs_pwrite_async(struct nfs_context *nfs, struct nfsfh *nfsfh, off_t offset, size_t count, char *buf, nfs_cb cb, void *private_data)
1105 {
1106 struct nfs_cb_data *data;
1107
1108 data = malloc(sizeof(struct nfs_cb_data));
1109 if (data == NULL) {
1110 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
1111 return -1;
1112 }
1113 memset(data, 0, sizeof(struct nfs_cb_data));
1114 data->nfs = nfs;
1115 data->cb = cb;
1116 data->private_data = private_data;
1117 data->nfsfh = nfsfh;
1118
1119 nfsfh->offset = offset;
1120
1121 if (count <= nfs_get_writemax(nfs)) {
1122 if (rpc_nfs_write_async(nfs->rpc, nfs_pwrite_cb, &nfsfh->fh, buf, offset, count, nfsfh->is_sync?FILE_SYNC:UNSTABLE, data) != 0) {
1123 rpc_set_error(nfs->rpc, "RPC error: Failed to send WRITE call for %s", data->path);
1124 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1125 free_nfs_cb_data(data);
1126 return -1;
1127 }
1128 return 0;
1129 }
1130
1131 /* trying to write more than maximum server write size, we has to chop it up into smaller
1132 * chunks.
1133 * we send all writes in parallell so that performance is still good.
1134 */
1135 data->max_offset = offset;
1136 data->start_offset = offset;
1137
1138 while (count > 0) {
1139 size_t writecount = count;
1140 struct nfs_mcb_data *mdata;
1141
1142 if (writecount > nfs_get_writemax(nfs)) {
1143 writecount = nfs_get_writemax(nfs);
1144 }
1145
1146 mdata = malloc(sizeof(struct nfs_mcb_data));
1147 if (mdata == NULL) {
1148 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_mcb_data structure");
1149 return -1;
1150 }
1151 memset(mdata, 0, sizeof(struct nfs_mcb_data));
1152 mdata->data = data;
1153 mdata->offset = offset;
1154 mdata->count = writecount;
1155
1156 if (rpc_nfs_write_async(nfs->rpc, nfs_pwrite_mcb, &nfsfh->fh, &buf[offset - data->start_offset], offset, writecount, nfsfh->is_sync?FILE_SYNC:UNSTABLE, mdata) != 0) {
1157 rpc_set_error(nfs->rpc, "RPC error: Failed to send WRITE call for %s", data->path);
1158 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1159 free(mdata);
1160 return -1;
1161 }
1162
1163 count -= writecount;
1164 offset += writecount;
1165 data->num_calls++;
1166 }
1167
1168 return 0;
1169 }
1170
1171 /*
1172 * Async write()
1173 */
1174 int nfs_write_async(struct nfs_context *nfs, struct nfsfh *nfsfh, size_t count, char *buf, nfs_cb cb, void *private_data)
1175 {
1176 return nfs_pwrite_async(nfs, nfsfh, nfsfh->offset, count, buf, cb, private_data);
1177 }
1178
1179
1180
1181
1182 /*
1183 * close
1184 */
1185
1186 int nfs_close_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
1187 {
1188 if (nfsfh->fh.data.data_val != NULL){
1189 free(nfsfh->fh.data.data_val);
1190 nfsfh->fh.data.data_val = NULL;
1191 }
1192 free(nfsfh);
1193
1194 cb(0, nfs, NULL, private_data);
1195 return 0;
1196 };
1197
1198
1199
1200
1201
1202 /*
1203 * Async fstat()
1204 */
1205 int nfs_fstat_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
1206 {
1207 struct nfs_cb_data *data;
1208
1209 data = malloc(sizeof(struct nfs_cb_data));
1210 if (data == NULL) {
1211 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
1212 return -1;
1213 }
1214 memset(data, 0, sizeof(struct nfs_cb_data));
1215 data->nfs = nfs;
1216 data->cb = cb;
1217 data->private_data = private_data;
1218
1219 if (rpc_nfs_getattr_async(nfs->rpc, nfs_stat_1_cb, &nfsfh->fh, data) != 0) {
1220 rpc_set_error(nfs->rpc, "RPC error: Failed to send STAT GETATTR call for %s", data->path);
1221 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1222 free_nfs_cb_data(data);
1223 return -1;
1224 }
1225 return 0;
1226 }
1227
1228
1229
1230 /*
1231 * Async fsync()
1232 */
1233 static void nfs_fsync_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1234 {
1235 struct nfs_cb_data *data = private_data;
1236 struct nfs_context *nfs = data->nfs;
1237 COMMIT3res *res;
1238
1239 if (status == RPC_STATUS_ERROR) {
1240 data->cb(-EFAULT, nfs, command_data, data->private_data);
1241 free_nfs_cb_data(data);
1242 return;
1243 }
1244 if (status == RPC_STATUS_CANCEL) {
1245 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1246 free_nfs_cb_data(data);
1247 return;
1248 }
1249
1250 res = command_data;
1251 if (res->status != NFS3_OK) {
1252 rpc_set_error(nfs->rpc, "NFS: Commit failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1253 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1254 free_nfs_cb_data(data);
1255 return;
1256 }
1257
1258 data->cb(0, nfs, NULL, data->private_data);
1259 free_nfs_cb_data(data);
1260 }
1261
1262 int nfs_fsync_async(struct nfs_context *nfs, struct nfsfh *nfsfh, nfs_cb cb, void *private_data)
1263 {
1264 struct nfs_cb_data *data;
1265
1266 data = malloc(sizeof(struct nfs_cb_data));
1267 if (data == NULL) {
1268 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
1269 return -1;
1270 }
1271 memset(data, 0, sizeof(struct nfs_cb_data));
1272 data->nfs = nfs;
1273 data->cb = cb;
1274 data->private_data = private_data;
1275
1276 if (rpc_nfs_commit_async(nfs->rpc, nfs_fsync_cb, &nfsfh->fh, data) != 0) {
1277 rpc_set_error(nfs->rpc, "RPC error: Failed to send COMMIT call for %s", data->path);
1278 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1279 free_nfs_cb_data(data);
1280 return -1;
1281 }
1282 return 0;
1283 }
1284
1285
1286
1287
1288 /*
1289 * Async ftruncate()
1290 */
1291 static void nfs_ftruncate_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1292 {
1293 struct nfs_cb_data *data = private_data;
1294 struct nfs_context *nfs = data->nfs;
1295 SETATTR3res *res;
1296
1297 if (status == RPC_STATUS_ERROR) {
1298 data->cb(-EFAULT, nfs, command_data, data->private_data);
1299 free_nfs_cb_data(data);
1300 return;
1301 }
1302 if (status == RPC_STATUS_CANCEL) {
1303 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1304 free_nfs_cb_data(data);
1305 return;
1306 }
1307
1308 res = command_data;
1309 if (res->status != NFS3_OK) {
1310 rpc_set_error(nfs->rpc, "NFS: Setattr failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1311 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1312 free_nfs_cb_data(data);
1313 return;
1314 }
1315
1316 data->cb(0, nfs, NULL, data->private_data);
1317 free_nfs_cb_data(data);
1318 }
1319
1320 int nfs_ftruncate_async(struct nfs_context *nfs, struct nfsfh *nfsfh, off_t length, nfs_cb cb, void *private_data)
1321 {
1322 struct nfs_cb_data *data;
1323 SETATTR3args args;
1324
1325 data = malloc(sizeof(struct nfs_cb_data));
1326 if (data == NULL) {
1327 rpc_set_error(nfs->rpc, "out of memory: failed to allocate nfs_cb_data structure");
1328 return -1;
1329 }
1330 memset(data, 0, sizeof(struct nfs_cb_data));
1331 data->nfs = nfs;
1332 data->cb = cb;
1333 data->private_data = private_data;
1334
1335 memset(&args, 0, sizeof(SETATTR3args));
1336 args.object.data.data_len = nfsfh->fh.data.data_len;
1337 args.object.data.data_val = nfsfh->fh.data.data_val;
1338 args.new_attributes.size.set_it = 1;
1339 args.new_attributes.size.set_size3_u.size = length;
1340
1341 if (rpc_nfs_setattr_async(nfs->rpc, nfs_ftruncate_cb, &args, data) != 0) {
1342 rpc_set_error(nfs->rpc, "RPC error: Failed to send SETATTR call for %s", data->path);
1343 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1344 free_nfs_cb_data(data);
1345 return -1;
1346 }
1347 return 0;
1348 }
1349
1350
1351 /*
1352 * Async truncate()
1353 */
1354 static int nfs_truncate_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1355 {
1356 off_t offset = data->continue_int;
1357 struct nfsfh nfsfh;
1358
1359 nfsfh.fh.data.data_val = data->fh.data.data_val;
1360 nfsfh.fh.data.data_len = data->fh.data.data_len;
1361
1362 if (nfs_ftruncate_async(nfs, &nfsfh, offset, data->cb, data->private_data) != 0) {
1363 rpc_set_error(nfs->rpc, "RPC error: Failed to send SETATTR call for %s", data->path);
1364 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1365 free_nfs_cb_data(data);
1366 return -1;
1367 }
1368 free_nfs_cb_data(data);
1369 return 0;
1370 }
1371
1372 int nfs_truncate_async(struct nfs_context *nfs, const char *path, off_t length, nfs_cb cb, void *private_data)
1373 {
1374 off_t offset;
1375
1376 offset = length;
1377
1378 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_truncate_continue_internal, NULL, NULL, offset) != 0) {
1379 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
1380 return -1;
1381 }
1382
1383 return 0;
1384 }
1385
1386
1387
1388
1389 /*
1390 * Async mkdir()
1391 */
1392 static void nfs_mkdir_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1393 {
1394 MKDIR3res *res;
1395 struct nfs_cb_data *data = private_data;
1396 struct nfs_context *nfs = data->nfs;
1397 char *str = data->continue_data;
1398
1399 str = &str[strlen(str) + 1];
1400
1401 if (status == RPC_STATUS_ERROR) {
1402 data->cb(-EFAULT, nfs, command_data, data->private_data);
1403 free_nfs_cb_data(data);
1404 return;
1405 }
1406 if (status == RPC_STATUS_CANCEL) {
1407 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1408 free_nfs_cb_data(data);
1409 return;
1410 }
1411
1412 res = command_data;
1413 if (res->status != NFS3_OK) {
1414 rpc_set_error(nfs->rpc, "NFS: MKDIR of %s/%s failed with %s(%d)", data->saved_path, str, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1415 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1416 free_nfs_cb_data(data);
1417 return;
1418 }
1419
1420 data->cb(0, nfs, NULL, data->private_data);
1421 free_nfs_cb_data(data);
1422 }
1423
1424 static int nfs_mkdir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1425 {
1426 char *str = data->continue_data;
1427
1428 str = &str[strlen(str) + 1];
1429
1430 if (rpc_nfs_mkdir_async(nfs->rpc, nfs_mkdir_cb, &data->fh, str, data) != 0) {
1431 rpc_set_error(nfs->rpc, "RPC error: Failed to send MKDIR call for %s", data->path);
1432 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1433 free_nfs_cb_data(data);
1434 return -1;
1435 }
1436 return 0;
1437 }
1438
1439 int nfs_mkdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
1440 {
1441 char *new_path;
1442 char *ptr;
1443
1444 new_path = strdup(path);
1445 if (new_path == NULL) {
1446 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
1447 return -1;
1448 }
1449
1450 ptr = strrchr(new_path, '/');
1451 if (ptr == NULL) {
1452 rpc_set_error(nfs->rpc, "Invalid path %s", path);
1453 return -1;
1454 }
1455 *ptr = 0;
1456
1457 /* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
1458 if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_mkdir_continue_internal, new_path, free, 0) != 0) {
1459 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path component");
1460 return -1;
1461 }
1462
1463 return 0;
1464 }
1465
1466
1467
1468
1469
1470 /*
1471 * Async rmdir()
1472 */
1473 static void nfs_rmdir_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1474 {
1475 RMDIR3res *res;
1476 struct nfs_cb_data *data = private_data;
1477 struct nfs_context *nfs = data->nfs;
1478 char *str = data->continue_data;
1479
1480 str = &str[strlen(str) + 1];
1481
1482 if (status == RPC_STATUS_ERROR) {
1483 data->cb(-EFAULT, nfs, command_data, data->private_data);
1484 free_nfs_cb_data(data);
1485 return;
1486 }
1487 if (status == RPC_STATUS_CANCEL) {
1488 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1489 free_nfs_cb_data(data);
1490 return;
1491 }
1492
1493 res = command_data;
1494 if (res->status != NFS3_OK) {
1495 rpc_set_error(nfs->rpc, "NFS: RMDIR of %s/%s failed with %s(%d)", data->saved_path, str, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1496 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1497 free_nfs_cb_data(data);
1498 return;
1499 }
1500
1501 data->cb(0, nfs, NULL, data->private_data);
1502 free_nfs_cb_data(data);
1503 }
1504
1505 static int nfs_rmdir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1506 {
1507 char *str = data->continue_data;
1508
1509 str = &str[strlen(str) + 1];
1510
1511 if (rpc_nfs_rmdir_async(nfs->rpc, nfs_rmdir_cb, &data->fh, str, data) != 0) {
1512 rpc_set_error(nfs->rpc, "RPC error: Failed to send RMDIR call for %s", data->path);
1513 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1514 free_nfs_cb_data(data);
1515 return -1;
1516 }
1517 return 0;
1518 }
1519
1520 int nfs_rmdir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
1521 {
1522 char *new_path;
1523 char *ptr;
1524
1525 new_path = strdup(path);
1526 if (new_path == NULL) {
1527 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
1528 return -1;
1529 }
1530
1531 ptr = strrchr(new_path, '/');
1532 if (ptr == NULL) {
1533 rpc_set_error(nfs->rpc, "Invalid path %s", path);
1534 return -1;
1535 }
1536 *ptr = 0;
1537
1538 /* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
1539 if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_rmdir_continue_internal, new_path, free, 0) != 0) {
1540 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
1541 return -1;
1542 }
1543
1544 return 0;
1545 }
1546
1547
1548
1549
1550 /*
1551 * Async creat()
1552 */
1553 static void nfs_create_2_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1554 {
1555 LOOKUP3res *res;
1556 struct nfs_cb_data *data = private_data;
1557 struct nfs_context *nfs = data->nfs;
1558 struct nfsfh *nfsfh;
1559 char *str = data->continue_data;
1560
1561 if (status == RPC_STATUS_ERROR) {
1562 data->cb(-EFAULT, nfs, command_data, data->private_data);
1563 free_nfs_cb_data(data);
1564 return;
1565 }
1566 if (status == RPC_STATUS_CANCEL) {
1567 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1568 free_nfs_cb_data(data);
1569 return;
1570 }
1571
1572 str = &str[strlen(str) + 1];
1573 res = command_data;
1574 if (res->status != NFS3_OK) {
1575 rpc_set_error(nfs->rpc, "NFS: CREATE of %s/%s failed with %s(%d)", data->saved_path, str, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1576 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1577
1578 return;
1579 }
1580
1581 nfsfh = malloc(sizeof(struct nfsfh));
1582 if (nfsfh == NULL) {
1583 rpc_set_error(nfs->rpc, "NFS: Failed to allocate nfsfh structure");
1584 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1585 free_nfs_cb_data(data);
1586 return;
1587 }
1588 memset(nfsfh, 0, sizeof(struct nfsfh));
1589
1590 /* steal the filehandle */
1591 nfsfh->fh.data.data_len = data->fh.data.data_len;
1592 nfsfh->fh.data.data_val = data->fh.data.data_val;
1593 data->fh.data.data_val = NULL;
1594
1595 data->cb(0, nfs, nfsfh, data->private_data);
1596 free_nfs_cb_data(data);
1597 }
1598
1599
1600
1601 static void nfs_creat_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1602 {
1603 CREATE3res *res;
1604 struct nfs_cb_data *data = private_data;
1605 struct nfs_context *nfs = data->nfs;
1606 char *str = data->continue_data;
1607
1608 if (status == RPC_STATUS_ERROR) {
1609 data->cb(-EFAULT, nfs, command_data, data->private_data);
1610 free_nfs_cb_data(data);
1611 return;
1612 }
1613 if (status == RPC_STATUS_CANCEL) {
1614 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1615 free_nfs_cb_data(data);
1616 return;
1617 }
1618
1619 str = &str[strlen(str) + 1];
1620 res = command_data;
1621 if (res->status != NFS3_OK) {
1622 rpc_set_error(nfs->rpc, "NFS: CREATE of %s/%s failed with %s(%d)", data->saved_path, str, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1623 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1624
1625 return;
1626 }
1627
1628 if (rpc_nfs_lookup_async(nfs->rpc, nfs_create_2_cb, &data->fh, str, data) != 0) {
1629 rpc_set_error(nfs->rpc, "RPC error: Failed to send lookup call for %s/%s", data->saved_path, str);
1630 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1631 free_nfs_cb_data(data);
1632 return;
1633 }
1634 return;
1635 }
1636
1637 static int nfs_creat_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1638 {
1639 char *str = data->continue_data;
1640
1641 str = &str[strlen(str) + 1];
1642
1643 if (rpc_nfs_create_async(nfs->rpc, nfs_creat_1_cb, &data->fh, str, data->continue_int, data) != 0) {
1644 rpc_set_error(nfs->rpc, "RPC error: Failed to send CREATE call for %s/%s", data->path, str);
1645 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1646 free_nfs_cb_data(data);
1647 return -1;
1648 }
1649 return 0;
1650 }
1651
1652 int nfs_creat_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
1653 {
1654 char *new_path;
1655 char *ptr;
1656
1657 new_path = strdup(path);
1658 if (new_path == NULL) {
1659 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
1660 return -1;
1661 }
1662
1663 ptr = strrchr(new_path, '/');
1664 if (ptr == NULL) {
1665 rpc_set_error(nfs->rpc, "Invalid path %s", path);
1666 return -1;
1667 }
1668 *ptr = 0;
1669
1670 /* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
1671 if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_creat_continue_internal, new_path, free, mode) != 0) {
1672 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
1673 return -1;
1674 }
1675
1676 return 0;
1677 }
1678
1679
1680
1681
1682 /*
1683 * Async unlink()
1684 */
1685 static void nfs_unlink_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1686 {
1687 REMOVE3res *res;
1688 struct nfs_cb_data *data = private_data;
1689 struct nfs_context *nfs = data->nfs;
1690 char *str = data->continue_data;
1691
1692 str = &str[strlen(str) + 1];
1693
1694 if (status == RPC_STATUS_ERROR) {
1695 data->cb(-EFAULT, nfs, command_data, data->private_data);
1696 free_nfs_cb_data(data);
1697 return;
1698 }
1699 if (status == RPC_STATUS_CANCEL) {
1700 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1701 free_nfs_cb_data(data);
1702 return;
1703 }
1704
1705 res = command_data;
1706 if (res->status != NFS3_OK) {
1707 rpc_set_error(nfs->rpc, "NFS: REMOVE of %s/%s failed with %s(%d)", data->saved_path, str, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1708 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1709 free_nfs_cb_data(data);
1710 return;
1711 }
1712
1713 data->cb(0, nfs, NULL, data->private_data);
1714 free_nfs_cb_data(data);
1715 }
1716
1717 static int nfs_unlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1718 {
1719 char *str = data->continue_data;
1720
1721 str = &str[strlen(str) + 1];
1722
1723 if (rpc_nfs_remove_async(nfs->rpc, nfs_unlink_cb, &data->fh, str, data) != 0) {
1724 rpc_set_error(nfs->rpc, "RPC error: Failed to send REMOVE call for %s", data->path);
1725 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1726 free_nfs_cb_data(data);
1727 return -1;
1728 }
1729 return 0;
1730 }
1731
1732 int nfs_unlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
1733 {
1734 char *new_path;
1735 char *ptr;
1736
1737 new_path = strdup(path);
1738 if (new_path == NULL) {
1739 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for path");
1740 return -1;
1741 }
1742
1743 ptr = strrchr(new_path, '/');
1744 if (ptr == NULL) {
1745 rpc_set_error(nfs->rpc, "Invalid path %s", path);
1746 return -1;
1747 }
1748 *ptr = 0;
1749
1750 /* new_path now points to the parent directory, and beyond the nul terminateor is the new directory to create */
1751 if (nfs_lookuppath_async(nfs, new_path, cb, private_data, nfs_unlink_continue_internal, new_path, free, 0) != 0) {
1752 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
1753 return -1;
1754 }
1755
1756 return 0;
1757 }
1758
1759
1760
1761
1762
1763 /*
1764 * Async opendir()
1765 */
1766 static void nfs_opendir_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1767 {
1768 READDIRPLUS3res *res;
1769 struct nfs_cb_data *data = private_data;
1770 struct nfs_context *nfs = data->nfs;
1771 struct nfsdir *nfsdir = data->continue_data;
1772 struct entryplus3 *entry;
1773 uint64_t cookie;
1774
1775 if (status == RPC_STATUS_ERROR) {
1776 data->cb(-EFAULT, nfs, command_data, data->private_data);
1777 nfs_free_nfsdir(nfsdir);
1778 data->continue_data = NULL;
1779 free_nfs_cb_data(data);
1780 return;
1781 }
1782 if (status == RPC_STATUS_CANCEL) {
1783 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1784 nfs_free_nfsdir(nfsdir);
1785 data->continue_data = NULL;
1786 free_nfs_cb_data(data);
1787 return;
1788 }
1789
1790 res = command_data;
1791 if (res->status != NFS3_OK) {
1792 rpc_set_error(nfs->rpc, "NFS: READDIR of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1793 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1794 nfs_free_nfsdir(nfsdir);
1795 data->continue_data = NULL;
1796 free_nfs_cb_data(data);
1797 return;
1798 }
1799
1800 entry =res->READDIRPLUS3res_u.resok.reply.entries;
1801 while (entry != NULL) {
1802 struct nfsdirent *nfsdirent;
1803
1804 nfsdirent = malloc(sizeof(struct nfsdirent));
1805 if (nfsdirent == NULL) {
1806 data->cb(-ENOMEM, nfs, "Failed to allocate dirent", data->private_data);
1807 nfs_free_nfsdir(nfsdir);
1808 data->continue_data = NULL;
1809 free_nfs_cb_data(data);
1810 return;
1811 }
1812 memset(nfsdirent, 0, sizeof(struct nfsdirent));
1813 nfsdirent->name = strdup(entry->name);
1814 if (nfsdirent->name == NULL) {
1815 data->cb(-ENOMEM, nfs, "Failed to allocate dirent->name", data->private_data);
1816 nfs_free_nfsdir(nfsdir);
1817 data->continue_data = NULL;
1818 free_nfs_cb_data(data);
1819 return;
1820 }
1821 nfsdirent->inode = entry->fileid;
1822 if (entry->name_attributes.attributes_follow) {
1823 nfsdirent->type = entry->name_attributes.post_op_attr_u.attributes.type;
1824 nfsdirent->mode = entry->name_attributes.post_op_attr_u.attributes.mode;
1825 nfsdirent->size = entry->name_attributes.post_op_attr_u.attributes.size;
1826
1827 nfsdirent->atime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.atime.seconds;
1828 nfsdirent->atime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.atime.nseconds/1000;
1829 nfsdirent->mtime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.mtime.seconds;
1830 nfsdirent->mtime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.mtime.nseconds/1000;
1831 nfsdirent->ctime.tv_sec = entry->name_attributes.post_op_attr_u.attributes.ctime.seconds;
1832 nfsdirent->ctime.tv_usec = entry->name_attributes.post_op_attr_u.attributes.ctime.nseconds/1000;
1833 }
1834
1835 nfsdirent->next = nfsdir->entries;
1836 nfsdir->entries = nfsdirent;
1837
1838 cookie = entry->cookie;
1839 entry = entry->nextentry;
1840 }
1841
1842 if (res->READDIRPLUS3res_u.resok.reply.eof == 0) {
1843 if (rpc_nfs_readdirplus_async(nfs->rpc, nfs_opendir_cb, &data->fh, cookie, res->READDIRPLUS3res_u.resok.cookieverf, 8192, data) != 0) {
1844 rpc_set_error(nfs->rpc, "RPC error: Failed to send READDIRPLUS call for %s", data->path);
1845 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1846 nfs_free_nfsdir(nfsdir);
1847 data->continue_data = NULL;
1848 free_nfs_cb_data(data);
1849 return;
1850 }
1851 return;
1852 }
1853
1854 /* steal the dirhandle */
1855 data->continue_data = NULL;
1856 nfsdir->current = nfsdir->entries;
1857
1858 data->cb(0, nfs, nfsdir, data->private_data);
1859 free_nfs_cb_data(data);
1860 }
1861
1862 static int nfs_opendir_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
1863 {
1864 cookieverf3 cv;
1865
1866 memset(cv, 0, sizeof(cookieverf3));
1867 if (rpc_nfs_readdirplus_async(nfs->rpc, nfs_opendir_cb, &data->fh, 0, (char *)&cv, 8192, data) != 0) {
1868 rpc_set_error(nfs->rpc, "RPC error: Failed to send READDIRPLUS call for %s", data->path);
1869 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
1870 free_nfs_cb_data(data);
1871 return -1;
1872 }
1873 return 0;
1874 }
1875
1876 int nfs_opendir_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
1877 {
1878 struct nfsdir *nfsdir;
1879
1880 nfsdir = malloc(sizeof(struct nfsdir));
1881 if (nfsdir == NULL) {
1882 rpc_set_error(nfs->rpc, "failed to allocate buffer for nfsdir");
1883 return -1;
1884 }
1885 memset(nfsdir, 0, sizeof(struct nfsdir));
1886
1887 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_opendir_continue_internal, nfsdir, free, 0) != 0) {
1888 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
1889 return -1;
1890 }
1891
1892 return 0;
1893 }
1894
1895
1896 struct nfsdirent *nfs_readdir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir)
1897 {
1898 struct nfsdirent *nfsdirent = nfsdir->current;
1899
1900 if (nfsdir->current != NULL) {
1901 nfsdir->current = nfsdir->current->next;
1902 }
1903 return nfsdirent;
1904 }
1905
1906
1907 void nfs_closedir(struct nfs_context *nfs _U_, struct nfsdir *nfsdir)
1908 {
1909 nfs_free_nfsdir(nfsdir);
1910 }
1911
1912
1913
1914
1915
1916
1917
1918 /*
1919 * Async lseek()
1920 */
1921 struct lseek_cb_data {
1922 struct nfs_context *nfs;
1923 struct nfsfh *nfsfh;
1924 off_t offset;
1925 nfs_cb cb;
1926 void *private_data;
1927 };
1928
1929 static void nfs_lseek_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
1930 {
1931 GETATTR3res *res;
1932 struct lseek_cb_data *data = private_data;
1933 struct nfs_context *nfs = data->nfs;
1934
1935 if (status == RPC_STATUS_ERROR) {
1936 data->cb(-EFAULT, nfs, command_data, data->private_data);
1937 free(data);
1938 return;
1939 }
1940 if (status == RPC_STATUS_CANCEL) {
1941 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
1942 free(data);
1943 return;
1944 }
1945
1946 res = command_data;
1947 if (res->status != NFS3_OK) {
1948 rpc_set_error(nfs->rpc, "NFS: GETATTR failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
1949 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
1950 free(data);
1951 return;
1952 }
1953
1954 data->nfsfh->offset = data->offset + res->GETATTR3res_u.resok.obj_attributes.size;
1955 data->cb(0, nfs, &data->nfsfh->offset, data->private_data);
1956 free(data);
1957 }
1958
1959 int nfs_lseek_async(struct nfs_context *nfs, struct nfsfh *nfsfh, off_t offset, int whence, nfs_cb cb, void *private_data)
1960 {
1961 struct lseek_cb_data *data;
1962
1963 if (whence == SEEK_SET) {
1964 nfsfh->offset = offset;
1965 cb(0, nfs, &nfsfh->offset, private_data);
1966 return 0;
1967 }
1968 if (whence == SEEK_CUR) {
1969 nfsfh->offset += offset;
1970 cb(0, nfs, &nfsfh->offset, private_data);
1971 return 0;
1972 }
1973
1974 data = malloc(sizeof(struct lseek_cb_data));
1975 if (data == NULL) {
1976 rpc_set_error(nfs->rpc, "Out Of Memory: Failed to malloc lseek cb data");
1977 return -1;
1978 }
1979
1980 data->nfs = nfs;
1981 data->nfsfh = nfsfh;
1982 data->offset = offset;
1983 data->cb = cb;
1984 data->private_data = private_data;
1985
1986 if (rpc_nfs_getattr_async(nfs->rpc, nfs_lseek_1_cb, &nfsfh->fh, data) != 0) {
1987 rpc_set_error(nfs->rpc, "RPC error: Failed to send LSEEK GETATTR call");
1988 free(data);
1989 return -1;
1990 }
1991 return 0;
1992 }
1993
1994
1995
1996
1997 /*
1998 * Async statvfs()
1999 */
2000 static void nfs_statvfs_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2001 {
2002 FSSTAT3res *res;
2003 struct nfs_cb_data *data = private_data;
2004 struct nfs_context *nfs = data->nfs;
2005 #ifndef WIN32
2006 struct statvfs svfs;
2007 #endif/*WIN32*/
2008
2009 if (status == RPC_STATUS_ERROR) {
2010 data->cb(-EFAULT, nfs, command_data, data->private_data);
2011 free_nfs_cb_data(data);
2012 return;
2013 }
2014 if (status == RPC_STATUS_CANCEL) {
2015 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2016 free_nfs_cb_data(data);
2017 return;
2018 }
2019
2020 res = command_data;
2021 if (res->status != NFS3_OK) {
2022 rpc_set_error(nfs->rpc, "NFS: FSSTAT of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2023 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2024 free_nfs_cb_data(data);
2025 return;
2026 }
2027
2028 #ifndef WIN32
2029 svfs.f_bsize = 4096;
2030 svfs.f_frsize = 4096;
2031 svfs.f_blocks = res->FSSTAT3res_u.resok.tbytes/4096;
2032 svfs.f_bfree = res->FSSTAT3res_u.resok.fbytes/4096;
2033 svfs.f_bavail = res->FSSTAT3res_u.resok.abytes/4096;
2034 svfs.f_files = res->FSSTAT3res_u.resok.tfiles;
2035 svfs.f_ffree = res->FSSTAT3res_u.resok.ffiles;
2036 svfs.f_favail = res->FSSTAT3res_u.resok.afiles;
2037 svfs.f_fsid = 0;
2038 svfs.f_flag = 0;
2039 svfs.f_namemax = 256;
2040
2041 data->cb(0, nfs, &svfs, data->private_data);
2042 #else
2043 data->cb(0, nfs,NULL, data->private_data);
2044 #endif/*WIN32*/
2045 free_nfs_cb_data(data);
2046 }
2047
2048 static int nfs_statvfs_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2049 {
2050 if (rpc_nfs_fsstat_async(nfs->rpc, nfs_statvfs_1_cb, &data->fh, data) != 0) {
2051 rpc_set_error(nfs->rpc, "RPC error: Failed to send FSSTAT call for %s", data->path);
2052 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2053 free_nfs_cb_data(data);
2054 return -1;
2055 }
2056 return 0;
2057 }
2058
2059 int nfs_statvfs_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
2060 {
2061 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_statvfs_continue_internal, NULL, NULL, 0) != 0) {
2062 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2063 return -1;
2064 }
2065
2066 return 0;
2067 }
2068
2069
2070
2071
2072 /*
2073 * Async readlink()
2074 */
2075 static void nfs_readlink_1_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2076 {
2077 READLINK3res *res;
2078 struct nfs_cb_data *data = private_data;
2079 struct nfs_context *nfs = data->nfs;
2080
2081 if (status == RPC_STATUS_ERROR) {
2082 data->cb(-EFAULT, nfs, command_data, data->private_data);
2083 free_nfs_cb_data(data);
2084 return;
2085 }
2086 if (status == RPC_STATUS_CANCEL) {
2087 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2088 free_nfs_cb_data(data);
2089 return;
2090 }
2091
2092 res = command_data;
2093 if (res->status != NFS3_OK) {
2094 rpc_set_error(nfs->rpc, "NFS: READLINK of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2095 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2096 free_nfs_cb_data(data);
2097 return;
2098 }
2099
2100
2101 data->cb(0, nfs, res->READLINK3res_u.resok.data, data->private_data);
2102 free_nfs_cb_data(data);
2103 }
2104
2105 static int nfs_readlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2106 {
2107 if (rpc_nfs_readlink_async(nfs->rpc, nfs_readlink_1_cb, &data->fh, data) != 0) {
2108 rpc_set_error(nfs->rpc, "RPC error: Failed to send READLINK call for %s", data->path);
2109 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2110 free_nfs_cb_data(data);
2111 return -1;
2112 }
2113 return 0;
2114 }
2115
2116 int nfs_readlink_async(struct nfs_context *nfs, const char *path, nfs_cb cb, void *private_data)
2117 {
2118 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_readlink_continue_internal, NULL, NULL, 0) != 0) {
2119 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2120 return -1;
2121 }
2122
2123 return 0;
2124 }
2125
2126
2127
2128
2129 /*
2130 * Async chmod()
2131 */
2132 static void nfs_chmod_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2133 {
2134 struct nfs_cb_data *data = private_data;
2135 struct nfs_context *nfs = data->nfs;
2136 SETATTR3res *res;
2137
2138 if (status == RPC_STATUS_ERROR) {
2139 data->cb(-EFAULT, nfs, command_data, data->private_data);
2140 free_nfs_cb_data(data);
2141 return;
2142 }
2143 if (status == RPC_STATUS_CANCEL) {
2144 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2145 free_nfs_cb_data(data);
2146 return;
2147 }
2148
2149 res = command_data;
2150 if (res->status != NFS3_OK) {
2151 rpc_set_error(nfs->rpc, "NFS: SETATTR failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2152 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2153 free_nfs_cb_data(data);
2154 return;
2155 }
2156
2157 data->cb(0, nfs, NULL, data->private_data);
2158 free_nfs_cb_data(data);
2159 }
2160
2161 static int nfs_chmod_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2162 {
2163 SETATTR3args args;
2164
2165 memset(&args, 0, sizeof(SETATTR3args));
2166 args.object.data.data_len = data->fh.data.data_len;
2167 args.object.data.data_val = data->fh.data.data_val;
2168 args.new_attributes.mode.set_it = 1;
2169 args.new_attributes.mode.set_mode3_u.mode = data->continue_int;
2170
2171 if (rpc_nfs_setattr_async(nfs->rpc, nfs_chmod_cb, &args, data) != 0) {
2172 rpc_set_error(nfs->rpc, "RPC error: Failed to send SETATTR call for %s", data->path);
2173 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2174 free_nfs_cb_data(data);
2175 return -1;
2176 }
2177 return 0;
2178 }
2179
2180
2181 int nfs_chmod_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
2182 {
2183 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_chmod_continue_internal, NULL, NULL, mode) != 0) {
2184 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2185 return -1;
2186 }
2187
2188 return 0;
2189 }
2190
2191 /*
2192 * Async fchmod()
2193 */
2194 int nfs_fchmod_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int mode, nfs_cb cb, void *private_data)
2195 {
2196 struct nfs_cb_data *data;
2197
2198 data = malloc(sizeof(struct nfs_cb_data));
2199 if (data == NULL) {
2200 rpc_set_error(nfs->rpc, "out of memory. failed to allocate memory for nfs mount data");
2201 return -1;
2202 }
2203 memset(data, 0, sizeof(struct nfs_cb_data));
2204 data->nfs = nfs;
2205 data->cb = cb;
2206 data->private_data = private_data;
2207 data->continue_int = mode;
2208 data->fh.data.data_len = nfsfh->fh.data.data_len;
2209 data->fh.data.data_val = malloc(data->fh.data.data_len);
2210 if (data->fh.data.data_val == NULL) {
2211 rpc_set_error(nfs->rpc, "Out of memory: Failed to allocate fh");
2212 free_nfs_cb_data(data);
2213 return -1;
2214 }
2215 memcpy(data->fh.data.data_val, nfsfh->fh.data.data_val, data->fh.data.data_len);
2216
2217 if (nfs_chmod_continue_internal(nfs, data) != 0) {
2218 free_nfs_cb_data(data);
2219 return -1;
2220 }
2221
2222 return 0;
2223 }
2224
2225
2226
2227 /*
2228 * Async chown()
2229 */
2230 static void nfs_chown_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2231 {
2232 struct nfs_cb_data *data = private_data;
2233 struct nfs_context *nfs = data->nfs;
2234 SETATTR3res *res;
2235
2236 if (status == RPC_STATUS_ERROR) {
2237 data->cb(-EFAULT, nfs, command_data, data->private_data);
2238 free_nfs_cb_data(data);
2239 return;
2240 }
2241 if (status == RPC_STATUS_CANCEL) {
2242 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2243 free_nfs_cb_data(data);
2244 return;
2245 }
2246
2247 res = command_data;
2248 if (res->status != NFS3_OK) {
2249 rpc_set_error(nfs->rpc, "NFS: SETATTR failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2250 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2251 free_nfs_cb_data(data);
2252 return;
2253 }
2254
2255 data->cb(0, nfs, NULL, data->private_data);
2256 free_nfs_cb_data(data);
2257 }
2258
2259 struct nfs_chown_data {
2260 uid_t uid;
2261 gid_t gid;
2262 };
2263
2264 static int nfs_chown_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2265 {
2266 SETATTR3args args;
2267 struct nfs_chown_data *chown_data = data->continue_data;
2268
2269 memset(&args, 0, sizeof(SETATTR3args));
2270 args.object.data.data_len = data->fh.data.data_len;
2271 args.object.data.data_val = data->fh.data.data_val;
2272 if (chown_data->uid != (uid_t)-1) {
2273 args.new_attributes.uid.set_it = 1;
2274 args.new_attributes.uid.set_uid3_u.uid = chown_data->uid;
2275 }
2276 if (chown_data->gid != (gid_t)-1) {
2277 args.new_attributes.gid.set_it = 1;
2278 args.new_attributes.gid.set_gid3_u.gid = chown_data->gid;
2279 }
2280
2281 if (rpc_nfs_setattr_async(nfs->rpc, nfs_chown_cb, &args, data) != 0) {
2282 rpc_set_error(nfs->rpc, "RPC error: Failed to send SETATTR call for %s", data->path);
2283 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2284 free_nfs_cb_data(data);
2285 return -1;
2286 }
2287 return 0;
2288 }
2289
2290
2291 int nfs_chown_async(struct nfs_context *nfs, const char *path, int uid, int gid, nfs_cb cb, void *private_data)
2292 {
2293 struct nfs_chown_data *chown_data;
2294
2295 chown_data = malloc(sizeof(struct nfs_chown_data));
2296 if (chown_data == NULL) {
2297 rpc_set_error(nfs->rpc, "Failed to allocate memory for chown data structure");
2298 return -1;
2299 }
2300
2301 chown_data->uid = uid;
2302 chown_data->gid = gid;
2303
2304 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_chown_continue_internal, chown_data, free, 0) != 0) {
2305 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2306 return -1;
2307 }
2308
2309 return 0;
2310 }
2311
2312
2313 /*
2314 * Async fchown()
2315 */
2316 int nfs_fchown_async(struct nfs_context *nfs, struct nfsfh *nfsfh, int uid, int gid, nfs_cb cb, void *private_data)
2317 {
2318 struct nfs_cb_data *data;
2319 struct nfs_chown_data *chown_data;
2320
2321 chown_data = malloc(sizeof(struct nfs_chown_data));
2322 if (chown_data == NULL) {
2323 rpc_set_error(nfs->rpc, "Failed to allocate memory for chown data structure");
2324 return -1;
2325 }
2326
2327 chown_data->uid = uid;
2328 chown_data->gid = gid;
2329
2330
2331 data = malloc(sizeof(struct nfs_cb_data));
2332 if (data == NULL) {
2333 rpc_set_error(nfs->rpc, "out of memory. failed to allocate memory for fchown data");
2334 return -1;
2335 }
2336 memset(data, 0, sizeof(struct nfs_cb_data));
2337 data->nfs = nfs;
2338 data->cb = cb;
2339 data->private_data = private_data;
2340 data->continue_data = chown_data;
2341 data->fh.data.data_len = nfsfh->fh.data.data_len;
2342 data->fh.data.data_val = malloc(data->fh.data.data_len);
2343 if (data->fh.data.data_val == NULL) {
2344 rpc_set_error(nfs->rpc, "Out of memory: Failed to allocate fh");
2345 free_nfs_cb_data(data);
2346 return -1;
2347 }
2348 memcpy(data->fh.data.data_val, nfsfh->fh.data.data_val, data->fh.data.data_len);
2349
2350
2351 if (nfs_chown_continue_internal(nfs, data) != 0) {
2352 free_nfs_cb_data(data);
2353 return -1;
2354 }
2355
2356 return 0;
2357 }
2358
2359
2360
2361
2362
2363 /*
2364 * Async utimes()
2365 */
2366 static void nfs_utimes_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2367 {
2368 struct nfs_cb_data *data = private_data;
2369 struct nfs_context *nfs = data->nfs;
2370 SETATTR3res *res;
2371
2372 if (status == RPC_STATUS_ERROR) {
2373 data->cb(-EFAULT, nfs, command_data, data->private_data);
2374 free_nfs_cb_data(data);
2375 return;
2376 }
2377 if (status == RPC_STATUS_CANCEL) {
2378 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2379 free_nfs_cb_data(data);
2380 return;
2381 }
2382
2383 res = command_data;
2384 if (res->status != NFS3_OK) {
2385 rpc_set_error(nfs->rpc, "NFS: SETATTR failed with %s(%d)", nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2386 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2387 free_nfs_cb_data(data);
2388 return;
2389 }
2390
2391 data->cb(0, nfs, NULL, data->private_data);
2392 free_nfs_cb_data(data);
2393 }
2394
2395 static int nfs_utimes_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2396 {
2397 SETATTR3args args;
2398 struct timeval *utimes_data = data->continue_data;
2399
2400 memset(&args, 0, sizeof(SETATTR3args));
2401 args.object.data.data_len = data->fh.data.data_len;
2402 args.object.data.data_val = data->fh.data.data_val;
2403 if (utimes_data != NULL) {
2404 args.new_attributes.atime.set_it = SET_TO_CLIENT_TIME;
2405 args.new_attributes.atime.set_atime_u.atime.seconds = utimes_data[0].tv_sec;
2406 args.new_attributes.atime.set_atime_u.atime.nseconds = utimes_data[0].tv_usec * 1000;
2407 args.new_attributes.mtime.set_it = SET_TO_CLIENT_TIME;
2408 args.new_attributes.mtime.set_mtime_u.mtime.seconds = utimes_data[1].tv_sec;
2409 args.new_attributes.mtime.set_mtime_u.mtime.nseconds = utimes_data[1].tv_usec * 1000;
2410 } else {
2411 args.new_attributes.atime.set_it = SET_TO_SERVER_TIME;
2412 args.new_attributes.mtime.set_it = SET_TO_SERVER_TIME;
2413 }
2414
2415 if (rpc_nfs_setattr_async(nfs->rpc, nfs_utimes_cb, &args, data) != 0) {
2416 rpc_set_error(nfs->rpc, "RPC error: Failed to send SETATTR call for %s", data->path);
2417 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2418 free_nfs_cb_data(data);
2419 return -1;
2420 }
2421 return 0;
2422 }
2423
2424
2425 int nfs_utimes_async(struct nfs_context *nfs, const char *path, struct timeval *times, nfs_cb cb, void *private_data)
2426 {
2427 struct timeval *new_times = NULL;
2428
2429 if (times != NULL) {
2430 new_times = malloc(sizeof(struct timeval)*2);
2431 if (new_times == NULL) {
2432 rpc_set_error(nfs->rpc, "Failed to allocate memory for timeval structure");
2433 return -1;
2434 }
2435
2436 memcpy(new_times, times, sizeof(struct timeval)*2);
2437 }
2438
2439 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
2440 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2441 return -1;
2442 }
2443
2444 return 0;
2445 }
2446
2447 /*
2448 * Async utime()
2449 */
2450 int nfs_utime_async(struct nfs_context *nfs, const char *path, struct utimbuf *times, nfs_cb cb, void *private_data)
2451 {
2452 struct timeval *new_times = NULL;
2453
2454 if (times != NULL) {
2455 new_times = malloc(sizeof(struct timeval)*2);
2456 if (new_times == NULL) {
2457 rpc_set_error(nfs->rpc, "Failed to allocate memory for timeval structure");
2458 return -1;
2459 }
2460
2461 new_times[0].tv_sec = times->actime;
2462 new_times[0].tv_usec = 0;
2463 new_times[1].tv_sec = times->modtime;
2464 new_times[1].tv_usec = 0;
2465 }
2466
2467 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_utimes_continue_internal, new_times, free, 0) != 0) {
2468 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2469 return -1;
2470 }
2471
2472 return 0;
2473 }
2474
2475
2476
2477
2478
2479 /*
2480 * Async access()
2481 */
2482 static void nfs_access_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2483 {
2484 ACCESS3res *res;
2485 struct nfs_cb_data *data = private_data;
2486 struct nfs_context *nfs = data->nfs;
2487 unsigned int nfsmode = 0;
2488
2489 if (status == RPC_STATUS_ERROR) {
2490 data->cb(-EFAULT, nfs, command_data, data->private_data);
2491 free_nfs_cb_data(data);
2492 return;
2493 }
2494 if (status == RPC_STATUS_CANCEL) {
2495 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2496 free_nfs_cb_data(data);
2497 return;
2498 }
2499
2500 res = command_data;
2501 if (res->status != NFS3_OK) {
2502 rpc_set_error(nfs->rpc, "NFS: ACCESS of %s failed with %s(%d)", data->saved_path, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2503 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2504 free_nfs_cb_data(data);
2505 return;
2506 }
2507
2508 if (data->continue_int & R_OK) {
2509 nfsmode |= ACCESS3_READ;
2510 }
2511 if (data->continue_int & W_OK) {
2512 nfsmode |= ACCESS3_MODIFY;
2513 }
2514 if (data->continue_int & X_OK) {
2515 nfsmode |= ACCESS3_EXECUTE;
2516 }
2517
2518 if (res->ACCESS3res_u.resok.access != nfsmode) {
2519 rpc_set_error(nfs->rpc, "NFS: ACCESS denied. Required access %c%c%c. Allowed access %c%c%c",
2520 nfsmode&ACCESS3_READ?'r':'-',
2521 nfsmode&ACCESS3_MODIFY?'w':'-',
2522 nfsmode&ACCESS3_EXECUTE?'x':'-',
2523 res->ACCESS3res_u.resok.access&ACCESS3_READ?'r':'-',
2524 res->ACCESS3res_u.resok.access&ACCESS3_MODIFY?'w':'-',
2525 res->ACCESS3res_u.resok.access&ACCESS3_EXECUTE?'x':'-');
2526 data->cb(-EACCES, nfs, rpc_get_error(nfs->rpc), data->private_data);
2527 free_nfs_cb_data(data);
2528 return;
2529 }
2530
2531 data->cb(0, nfs, NULL, data->private_data);
2532 free_nfs_cb_data(data);
2533 }
2534
2535 static int nfs_access_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2536 {
2537 int nfsmode = 0;
2538
2539 if (data->continue_int & R_OK) {
2540 nfsmode |= ACCESS3_READ;
2541 }
2542 if (data->continue_int & W_OK) {
2543 nfsmode |= ACCESS3_MODIFY;
2544 }
2545 if (data->continue_int & X_OK) {
2546 nfsmode |= ACCESS3_EXECUTE;
2547 }
2548
2549 if (rpc_nfs_access_async(nfs->rpc, nfs_access_cb, &data->fh, nfsmode, data) != 0) {
2550 rpc_set_error(nfs->rpc, "RPC error: Failed to send OPEN ACCESS call for %s", data->path);
2551 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2552 free_nfs_cb_data(data);
2553 return -1;
2554 }
2555 return 0;
2556 }
2557
2558 int nfs_access_async(struct nfs_context *nfs, const char *path, int mode, nfs_cb cb, void *private_data)
2559 {
2560 if (nfs_lookuppath_async(nfs, path, cb, private_data, nfs_access_continue_internal, NULL, NULL, mode) != 0) {
2561 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2562 return -1;
2563 }
2564
2565 return 0;
2566 }
2567
2568
2569
2570 /*
2571 * Async symlink()
2572 */
2573 struct nfs_symlink_data {
2574 char *oldpath;
2575 char *newpathparent;
2576 char *newpathobject;
2577 };
2578
2579 static void free_nfs_symlink_data(void *mem)
2580 {
2581 struct nfs_symlink_data *data = mem;
2582
2583 if (data->oldpath != NULL) {
2584 free(data->oldpath);
2585 }
2586 if (data->newpathparent != NULL) {
2587 free(data->newpathparent);
2588 }
2589 if (data->newpathobject != NULL) {
2590 free(data->newpathobject);
2591 }
2592 free(data);
2593 }
2594
2595 static void nfs_symlink_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2596 {
2597 SYMLINK3res *res;
2598 struct nfs_cb_data *data = private_data;
2599 struct nfs_context *nfs = data->nfs;
2600 struct nfs_symlink_data *symlink_data = data->continue_data;
2601
2602 if (status == RPC_STATUS_ERROR) {
2603 data->cb(-EFAULT, nfs, command_data, data->private_data);
2604 free_nfs_cb_data(data);
2605 return;
2606 }
2607 if (status == RPC_STATUS_CANCEL) {
2608 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2609 free_nfs_cb_data(data);
2610 return;
2611 }
2612
2613 res = command_data;
2614 if (res->status != NFS3_OK) {
2615 rpc_set_error(nfs->rpc, "NFS: SYMLINK %s/%s -> %s failed with %s(%d)", symlink_data->newpathparent, symlink_data->newpathobject, symlink_data->oldpath, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2616 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2617 free_nfs_cb_data(data);
2618 return;
2619 }
2620
2621 data->cb(0, nfs, NULL, data->private_data);
2622 free_nfs_cb_data(data);
2623 }
2624
2625 static int nfs_symlink_continue_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2626 {
2627 struct nfs_symlink_data *symlink_data = data->continue_data;
2628
2629 if (rpc_nfs_symlink_async(nfs->rpc, nfs_symlink_cb, &data->fh, symlink_data->newpathobject, symlink_data->oldpath, data) != 0) {
2630 rpc_set_error(nfs->rpc, "RPC error: Failed to send SYMLINK call for %s", data->path);
2631 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2632 free_nfs_cb_data(data);
2633 return -1;
2634 }
2635 return 0;
2636 }
2637
2638 int nfs_symlink_async(struct nfs_context *nfs, const char *oldpath, const char *newpath, nfs_cb cb, void *private_data)
2639 {
2640 char *ptr;
2641 struct nfs_symlink_data *symlink_data;
2642
2643 symlink_data = malloc(sizeof(struct nfs_symlink_data));
2644 if (symlink_data == NULL) {
2645 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for symlink data");
2646 return -1;
2647 }
2648 memset(symlink_data, 0, sizeof(struct nfs_symlink_data));
2649
2650 symlink_data->oldpath = strdup(oldpath);
2651 if (symlink_data->oldpath == NULL) {
2652 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for oldpath");
2653 free_nfs_symlink_data(symlink_data);
2654 return -1;
2655 }
2656
2657 symlink_data->newpathparent = strdup(newpath);
2658 if (symlink_data->newpathparent == NULL) {
2659 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for new path");
2660 free_nfs_symlink_data(symlink_data);
2661 return -1;
2662 }
2663
2664 ptr = strrchr(symlink_data->newpathparent, '/');
2665 if (ptr == NULL) {
2666 rpc_set_error(nfs->rpc, "Invalid path %s", oldpath);
2667 free_nfs_symlink_data(symlink_data);
2668 return -1;
2669 }
2670 *ptr = 0;
2671 ptr++;
2672
2673 symlink_data->newpathobject = strdup(ptr);
2674 if (symlink_data->newpathobject == NULL) {
2675 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate mode buffer for new path");
2676 free_nfs_symlink_data(symlink_data);
2677 return -1;
2678 }
2679
2680 if (nfs_lookuppath_async(nfs, symlink_data->newpathparent, cb, private_data, nfs_symlink_continue_internal, symlink_data, free_nfs_symlink_data, 0) != 0) {
2681 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2682 return -1;
2683 }
2684
2685 return 0;
2686 }
2687
2688
2689
2690 /*
2691 * Async rename()
2692 */
2693 struct nfs_rename_data {
2694 char *oldpath;
2695 char *oldobject;
2696 struct nfs_fh3 olddir;
2697 char *newpath;
2698 char *newobject;
2699 struct nfs_fh3 newdir;
2700 };
2701
2702 static void free_nfs_rename_data(void *mem)
2703 {
2704 struct nfs_rename_data *data = mem;
2705
2706 if (data->oldpath != NULL) {
2707 free(data->oldpath);
2708 }
2709 if (data->olddir.data.data_val != NULL) {
2710 free(data->olddir.data.data_val);
2711 }
2712 if (data->newpath != NULL) {
2713 free(data->newpath);
2714 }
2715 if (data->newdir.data.data_val != NULL) {
2716 free(data->newdir.data.data_val);
2717 }
2718 free(data);
2719 }
2720
2721 static void nfs_rename_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2722 {
2723 RENAME3res *res;
2724 struct nfs_cb_data *data = private_data;
2725 struct nfs_context *nfs = data->nfs;
2726 struct nfs_rename_data *rename_data = data->continue_data;
2727
2728 if (status == RPC_STATUS_ERROR) {
2729 data->cb(-EFAULT, nfs, command_data, data->private_data);
2730 free_nfs_cb_data(data);
2731 return;
2732 }
2733 if (status == RPC_STATUS_CANCEL) {
2734 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2735 free_nfs_cb_data(data);
2736 return;
2737 }
2738
2739 res = command_data;
2740 if (res->status != NFS3_OK) {
2741 rpc_set_error(nfs->rpc, "NFS: RENAME %s/%s -> %s/%s failed with %s(%d)", rename_data->oldpath, rename_data->oldobject, rename_data->newpath, rename_data->newobject, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2742 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2743 free_nfs_cb_data(data);
2744 return;
2745 }
2746
2747 data->cb(0, nfs, NULL, data->private_data);
2748 free_nfs_cb_data(data);
2749 }
2750
2751 static int nfs_rename_continue_2_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2752 {
2753 struct nfs_rename_data *rename_data = data->continue_data;
2754
2755 /* steal the filehandle */
2756 rename_data->newdir.data.data_len = data->fh.data.data_len;
2757 rename_data->newdir.data.data_val = data->fh.data.data_val;
2758 data->fh.data.data_val = NULL;
2759
2760 if (rpc_nfs_rename_async(nfs->rpc, nfs_rename_cb, &rename_data->olddir, rename_data->oldobject, &rename_data->newdir, rename_data->newobject, data) != 0) {
2761 rpc_set_error(nfs->rpc, "RPC error: Failed to send RENAME call for %s", data->path);
2762 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2763 free_nfs_cb_data(data);
2764 return -1;
2765 }
2766 return 0;
2767 }
2768
2769
2770 static int nfs_rename_continue_1_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2771 {
2772 struct nfs_rename_data *rename_data = data->continue_data;
2773
2774 /* steal the filehandle */
2775 rename_data->olddir.data.data_len = data->fh.data.data_len;
2776 rename_data->olddir.data.data_val = data->fh.data.data_val;
2777 data->fh.data.data_val = NULL;
2778
2779 if (nfs_lookuppath_async(nfs, rename_data->newpath, data->cb, data->private_data, nfs_rename_continue_2_internal, rename_data, free_nfs_rename_data, 0) != 0) {
2780 rpc_set_error(nfs->rpc, "RPC error: Failed to send LOOKUP call for %s", rename_data->newpath);
2781 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2782 free_nfs_cb_data(data);
2783 return -1;
2784 }
2785 data->continue_data = NULL;
2786 free_nfs_cb_data(data);
2787
2788 return 0;
2789 }
2790
2791
2792 int nfs_rename_async(struct nfs_context *nfs, const char *oldpath, const char *newpath, nfs_cb cb, void *private_data)
2793 {
2794 char *ptr;
2795 struct nfs_rename_data *rename_data;
2796
2797 rename_data = malloc(sizeof(struct nfs_rename_data));
2798 if (rename_data == NULL) {
2799 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for rename data");
2800 return -1;
2801 }
2802 memset(rename_data, 0, sizeof(struct nfs_rename_data));
2803
2804 rename_data->oldpath = strdup(oldpath);
2805 if (rename_data->oldpath == NULL) {
2806 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for oldpath");
2807 free_nfs_rename_data(rename_data);
2808 return -1;
2809 }
2810 ptr = strrchr(rename_data->oldpath, '/');
2811 if (ptr == NULL) {
2812 rpc_set_error(nfs->rpc, "Invalid path %s", oldpath);
2813 free_nfs_rename_data(rename_data);
2814 return -1;
2815 }
2816 *ptr = 0;
2817 ptr++;
2818 rename_data->oldobject = ptr;
2819
2820
2821 rename_data->newpath = strdup(newpath);
2822 if (rename_data->newpath == NULL) {
2823 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for newpath");
2824 free_nfs_rename_data(rename_data);
2825 return -1;
2826 }
2827 ptr = strrchr(rename_data->newpath, '/');
2828 if (ptr == NULL) {
2829 rpc_set_error(nfs->rpc, "Invalid path %s", newpath);
2830 free_nfs_rename_data(rename_data);
2831 return -1;
2832 }
2833 *ptr = 0;
2834 ptr++;
2835 rename_data->newobject = ptr;
2836
2837
2838 if (nfs_lookuppath_async(nfs, rename_data->oldpath, cb, private_data, nfs_rename_continue_1_internal, rename_data, free_nfs_rename_data, 0) != 0) {
2839 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2840 return -1;
2841 }
2842
2843 return 0;
2844 }
2845
2846
2847 /*
2848 * Async link()
2849 */
2850 struct nfs_link_data {
2851 char *oldpath;
2852 struct nfs_fh3 oldfh;
2853 char *newpath;
2854 char *newobject;
2855 struct nfs_fh3 newdir;
2856 };
2857
2858 static void free_nfs_link_data(void *mem)
2859 {
2860 struct nfs_link_data *data = mem;
2861
2862 if (data->oldpath != NULL) {
2863 free(data->oldpath);
2864 }
2865 if (data->oldfh.data.data_val != NULL) {
2866 free(data->oldfh.data.data_val);
2867 }
2868 if (data->newpath != NULL) {
2869 free(data->newpath);
2870 }
2871 if (data->newdir.data.data_val != NULL) {
2872 free(data->newdir.data.data_val);
2873 }
2874 free(data);
2875 }
2876
2877 static void nfs_link_cb(struct rpc_context *rpc _U_, int status, void *command_data, void *private_data)
2878 {
2879 LINK3res *res;
2880 struct nfs_cb_data *data = private_data;
2881 struct nfs_context *nfs = data->nfs;
2882 struct nfs_link_data *link_data = data->continue_data;
2883
2884 if (status == RPC_STATUS_ERROR) {
2885 data->cb(-EFAULT, nfs, command_data, data->private_data);
2886 free_nfs_cb_data(data);
2887 return;
2888 }
2889 if (status == RPC_STATUS_CANCEL) {
2890 data->cb(-EINTR, nfs, "Command was cancelled", data->private_data);
2891 free_nfs_cb_data(data);
2892 return;
2893 }
2894
2895 res = command_data;
2896 if (res->status != NFS3_OK) {
2897 rpc_set_error(nfs->rpc, "NFS: LINK %s -> %s/%s failed with %s(%d)", link_data->oldpath, link_data->newpath, link_data->newobject, nfsstat3_to_str(res->status), nfsstat3_to_errno(res->status));
2898 data->cb(nfsstat3_to_errno(res->status), nfs, rpc_get_error(nfs->rpc), data->private_data);
2899 free_nfs_cb_data(data);
2900 return;
2901 }
2902
2903 data->cb(0, nfs, NULL, data->private_data);
2904 free_nfs_cb_data(data);
2905 }
2906
2907 static int nfs_link_continue_2_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2908 {
2909 struct nfs_link_data *link_data = data->continue_data;
2910
2911 /* steal the filehandle */
2912 link_data->newdir.data.data_len = data->fh.data.data_len;
2913 link_data->newdir.data.data_val = data->fh.data.data_val;
2914 data->fh.data.data_val = NULL;
2915
2916 if (rpc_nfs_link_async(nfs->rpc, nfs_link_cb, &link_data->oldfh, &link_data->newdir, link_data->newobject, data) != 0) {
2917 rpc_set_error(nfs->rpc, "RPC error: Failed to send LINK call for %s", data->path);
2918 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2919 free_nfs_cb_data(data);
2920 return -1;
2921 }
2922 return 0;
2923 }
2924
2925
2926 static int nfs_link_continue_1_internal(struct nfs_context *nfs, struct nfs_cb_data *data)
2927 {
2928 struct nfs_link_data *link_data = data->continue_data;
2929
2930 /* steal the filehandle */
2931 link_data->oldfh.data.data_len = data->fh.data.data_len;
2932 link_data->oldfh.data.data_val = data->fh.data.data_val;
2933 data->fh.data.data_val = NULL;
2934
2935 if (nfs_lookuppath_async(nfs, link_data->newpath, data->cb, data->private_data, nfs_link_continue_2_internal, link_data, free_nfs_link_data, 0) != 0) {
2936 rpc_set_error(nfs->rpc, "RPC error: Failed to send LOOKUP call for %s", link_data->newpath);
2937 data->cb(-ENOMEM, nfs, rpc_get_error(nfs->rpc), data->private_data);
2938 free_nfs_cb_data(data);
2939 return -1;
2940 }
2941 data->continue_data = NULL;
2942 free_nfs_cb_data(data);
2943
2944 return 0;
2945 }
2946
2947
2948 int nfs_link_async(struct nfs_context *nfs, const char *oldpath, const char *newpath, nfs_cb cb, void *private_data)
2949 {
2950 char *ptr;
2951 struct nfs_link_data *link_data;
2952
2953 link_data = malloc(sizeof(struct nfs_link_data));
2954 if (link_data == NULL) {
2955 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for link data");
2956 return -1;
2957 }
2958 memset(link_data, 0, sizeof(struct nfs_link_data));
2959
2960 link_data->oldpath = strdup(oldpath);
2961 if (link_data->oldpath == NULL) {
2962 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for oldpath");
2963 free_nfs_link_data(link_data);
2964 return -1;
2965 }
2966
2967 link_data->newpath = strdup(newpath);
2968 if (link_data->newpath == NULL) {
2969 rpc_set_error(nfs->rpc, "Out of memory, failed to allocate buffer for newpath");
2970 free_nfs_link_data(link_data);
2971 return -1;
2972 }
2973 ptr = strrchr(link_data->newpath, '/');
2974 if (ptr == NULL) {
2975 rpc_set_error(nfs->rpc, "Invalid path %s", newpath);
2976 free_nfs_link_data(link_data);
2977 return -1;
2978 }
2979 *ptr = 0;
2980 ptr++;
2981 link_data->newobject = ptr;
2982
2983
2984 if (nfs_lookuppath_async(nfs, link_data->oldpath, cb, private_data, nfs_link_continue_1_internal, link_data, free_nfs_link_data, 0) != 0) {
2985 rpc_set_error(nfs->rpc, "Out of memory: failed to start parsing the path components");
2986 return -1;
2987 }
2988
2989 return 0;
2990 }
2991
2992
2993 //qqq replace later with lseek()
2994 off_t nfs_get_current_offset(struct nfsfh *nfsfh)
2995 {
2996 return nfsfh->offset;
2997 }
2998
2999
3000
3001 /*
3002 * Get the maximum supported READ3 size by the server
3003 */
3004 size_t nfs_get_readmax(struct nfs_context *nfs)
3005 {
3006 return nfs->readmax;
3007 }
3008
3009 /*
3010 * Get the maximum supported WRITE3 size by the server
3011 */
3012 size_t nfs_get_writemax(struct nfs_context *nfs)
3013 {
3014 /* Some XDR libraries can not marshall PDUs bigger than this */
3015 if (nfs->writemax < 32768) {
3016 return nfs->writemax;
3017 }
3018 return 32768;
3019 }
3020
3021 void nfs_set_error(struct nfs_context *nfs, char *error_string, ...)
3022 {
3023 va_list ap;
3024 char *str = NULL;
3025
3026 va_start(ap, error_string);
3027 str = malloc(1024);
3028 vsnprintf(str, 1024, error_string, ap);
3029 if (nfs->rpc->error_string != NULL) {
3030 free(nfs->rpc->error_string);
3031 }
3032 nfs->rpc->error_string = str;
3033 va_end(ap);
3034 }
3035
3036
3037
3038 struct mount_cb_data {
3039 rpc_cb cb;
3040 void *private_data;
3041 char *server;
3042 };
3043
3044 static void free_mount_cb_data(struct mount_cb_data *data)
3045 {
3046 if (data->server != NULL) {
3047 free(data->server);
3048 data->server = NULL;
3049 }
3050
3051 free(data);
3052 }
3053
3054 static void mount_export_5_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
3055 {
3056 struct mount_cb_data *data = private_data;
3057
3058 if (status == RPC_STATUS_ERROR) {
3059 data->cb(rpc, -EFAULT, command_data, data->private_data);
3060 free_mount_cb_data(data);
3061 return;
3062 }
3063 if (status == RPC_STATUS_CANCEL) {
3064 data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
3065 free_mount_cb_data(data);
3066 return;
3067 }
3068
3069 data->cb(rpc, 0, command_data, data->private_data);
3070 if (rpc_disconnect(rpc, "normal disconnect") != 0) {
3071 rpc_set_error(rpc, "Failed to disconnect\n");
3072 }
3073 free_mount_cb_data(data);
3074 }
3075
3076 static void mount_export_4_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
3077 {
3078 struct mount_cb_data *data = private_data;
3079
3080 if (status == RPC_STATUS_ERROR) {
3081 data->cb(rpc, -EFAULT, command_data, data->private_data);
3082 free_mount_cb_data(data);
3083 return;
3084 }
3085 if (status == RPC_STATUS_CANCEL) {
3086 data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
3087 free_mount_cb_data(data);
3088 return;
3089 }
3090
3091 if (rpc_mount_export_async(rpc, mount_export_5_cb, data) != 0) {
3092 data->cb(rpc, -ENOMEM, command_data, data->private_data);
3093 free_mount_cb_data(data);
3094 return;
3095 }
3096 }
3097
3098 static void mount_export_3_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
3099 {
3100 struct mount_cb_data *data = private_data;
3101 uint32_t mount_port;
3102
3103 if (status == RPC_STATUS_ERROR) {
3104 data->cb(rpc, -EFAULT, command_data, data->private_data);
3105 free_mount_cb_data(data);
3106 return;
3107 }
3108 if (status == RPC_STATUS_CANCEL) {
3109 data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
3110 free_mount_cb_data(data);
3111 return;
3112 }
3113
3114 mount_port = *(uint32_t *)command_data;
3115 if (mount_port == 0) {
3116 rpc_set_error(rpc, "RPC error. Mount program is not available");
3117 data->cb(rpc, -ENOENT, command_data, data->private_data);
3118 free_mount_cb_data(data);
3119 return;
3120 }
3121
3122 rpc_disconnect(rpc, "normal disconnect");
3123 if (rpc_connect_async(rpc, data->server, mount_port, mount_export_4_cb, data) != 0) {
3124 data->cb(rpc, -ENOMEM, command_data, data->private_data);
3125 free_mount_cb_data(data);
3126 return;
3127 }
3128 }
3129
3130 static void mount_export_2_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
3131 {
3132 struct mount_cb_data *data = private_data;
3133
3134 if (status == RPC_STATUS_ERROR) {
3135 data->cb(rpc, -EFAULT, command_data, data->private_data);
3136 free_mount_cb_data(data);
3137 return;
3138 }
3139 if (status == RPC_STATUS_CANCEL) {
3140 data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
3141 free_mount_cb_data(data);
3142 return;
3143 }
3144
3145 if (rpc_pmap_getport_async(rpc, MOUNT_PROGRAM, MOUNT_V3, mount_export_3_cb, private_data) != 0) {
3146 data->cb(rpc, -ENOMEM, command_data, data->private_data);
3147 free_mount_cb_data(data);
3148 return;
3149 }
3150 }
3151
3152 static void mount_export_1_cb(struct rpc_context *rpc, int status, void *command_data, void *private_data)
3153 {
3154 struct mount_cb_data *data = private_data;
3155
3156 if (status == RPC_STATUS_ERROR) {
3157 data->cb(rpc, -EFAULT, command_data, data->private_data);
3158 free_mount_cb_data(data);
3159 return;
3160 }
3161 if (status == RPC_STATUS_CANCEL) {
3162 data->cb(rpc, -EINTR, "Command was cancelled", data->private_data);
3163 free_mount_cb_data(data);
3164 return;
3165 }
3166
3167 if (rpc_pmap_null_async(rpc, mount_export_2_cb, data) != 0) {
3168 data->cb(rpc, -ENOMEM, command_data, data->private_data);
3169 free_mount_cb_data(data);
3170 return;
3171 }
3172 }
3173
3174 int mount_getexports_async(struct rpc_context *rpc, const char *server, rpc_cb cb, void *private_data)
3175 {
3176 struct mount_cb_data *data;
3177
3178 data = malloc(sizeof(struct mount_cb_data));
3179 if (data == NULL) {
3180 return -1;
3181 }
3182 memset(data, 0, sizeof(struct mount_cb_data));
3183 data->cb = cb;
3184 data->private_data = private_data;
3185 data->server = strdup(server);
3186 if (data->server == NULL) {
3187 free_mount_cb_data(data);
3188 return -1;
3189 }
3190 if (rpc_connect_async(rpc, data->server, 111, mount_export_1_cb, data) != 0) {
3191 free_mount_cb_data(data);
3192 return -1;
3193 }
3194
3195 return 0;
3196 }
3197
3198 struct rpc_context *nfs_get_rpc_context(struct nfs_context *nfs)
3199 {
3200 return nfs->rpc;
3201 }
3202
3203 const char *nfs_get_server(struct nfs_context *nfs) {
3204 return nfs->server;
3205 }
3206
3207 const char *nfs_get_export(struct nfs_context *nfs) {
3208 return nfs->export;
3209 }
3210
3211
3212 #if defined(WIN32)
3213 int poll(struct pollfd *fds, int nfsd, int timeout)
3214 {
3215 fd_set rfds, wfds, efds;
3216 int ret;
3217
3218 FD_ZERO(&rfds);
3219 FD_ZERO(&wfds);
3220 FD_ZERO(&efds);
3221 if (fds->events & POLLIN) {
3222 FD_SET(fds->fd, &rfds);
3223 }
3224 if (fds->events & POLLOUT) {
3225 FD_SET(fds->fd, &wfds);
3226 }
3227 FD_SET(fds->fd, &efds);
3228 select(fds->fd + 1, &rfds, &wfds, &efds, NULL);
3229 fds->revents = 0;
3230 if (FD_ISSET(fds->fd, &rfds)) {
3231 fds->revents |= POLLIN;
3232 }
3233 if (FD_ISSET(fds->fd, &wfds)) {
3234 fds->revents |= POLLOUT;
3235 }
3236 if (FD_ISSET(fds->fd, &efds)) {
3237 fds->revents |= POLLHUP;
3238 }
3239 return 1;
3240 }
3241 #endif
3242
libnfs Piment Noir Debian package repository