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