repositories / deb_libnfs.git / blob
? search:


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