-WARNS6 cleanup (229 warnings)
[dragonfly.git] / bin / cpdup / hcproto.c
1 /*
2  * HCPROTO.C
3  *
4  * This module implements a simple remote control protocol
5  *
6  * $DragonFly: src/bin/cpdup/hcproto.c,v 1.1 2006/08/13 20:51:40 dillon Exp $
7  */
8
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <fcntl.h>
16 #include <dirent.h>
17 #include <errno.h>
18
19 #include "hclink.h"
20 #include "hcproto.h"
21
22 static int hc_decode_stat(struct stat *, struct HCHead *);
23 static int rc_encode_stat(struct HostConf *, struct stat *);
24
25 static int rc_hello(struct HostConf *, struct HCHead *);
26 static int rc_stat(struct HostConf *, struct HCHead *);
27 static int rc_lstat(struct HostConf *, struct HCHead *);
28 static int rc_opendir(struct HostConf *, struct HCHead *);
29 static int rc_readdir(struct HostConf *, struct HCHead *);
30 static int rc_closedir(struct HostConf *, struct HCHead *);
31 static int rc_open(struct HostConf *, struct HCHead *);
32 static int rc_close(struct HostConf *, struct HCHead *);
33 static int rc_read(struct HostConf *, struct HCHead *);
34 static int rc_write(struct HostConf *, struct HCHead *);
35 static int rc_remove(struct HostConf *, struct HCHead *);
36 static int rc_mkdir(struct HostConf *, struct HCHead *);
37 static int rc_rmdir(struct HostConf *, struct HCHead *);
38 static int rc_chown(struct HostConf *, struct HCHead *);
39 static int rc_lchown(struct HostConf *, struct HCHead *);
40 static int rc_chmod(struct HostConf *, struct HCHead *);
41 static int rc_link(struct HostConf *, struct HCHead *);
42 #ifdef _ST_FLAGS_PRESENT_
43 static int rc_chflags(struct HostConf *, struct HCHead *);
44 #endif
45 static int rc_readlink(struct HostConf *, struct HCHead *);
46 static int rc_umask(struct HostConf *, struct HCHead *);
47 static int rc_symlink(struct HostConf *, struct HCHead *);
48 static int rc_rename(struct HostConf *, struct HCHead *);
49 static int rc_utimes(struct HostConf *, struct HCHead *);
50
51 struct HCDesc HCDispatchTable[] = {
52     { HC_HELLO,         rc_hello },
53     { HC_STAT,          rc_stat },
54     { HC_LSTAT,         rc_lstat },
55     { HC_OPENDIR,       rc_opendir },
56     { HC_READDIR,       rc_readdir },
57     { HC_CLOSEDIR,      rc_closedir },
58     { HC_OPEN,          rc_open },
59     { HC_CLOSE,         rc_close },
60     { HC_READ,          rc_read },
61     { HC_WRITE,         rc_write },
62     { HC_REMOVE,        rc_remove },
63     { HC_MKDIR,         rc_mkdir },
64     { HC_RMDIR,         rc_rmdir },
65     { HC_CHOWN,         rc_chown },
66     { HC_LCHOWN,        rc_lchown },
67     { HC_CHMOD,         rc_chmod },
68     { HC_LINK,          rc_link },
69 #ifdef _ST_FLAGS_PRESENT_
70     { HC_CHFLAGS,       rc_chflags },
71 #endif
72     { HC_READLINK,      rc_readlink },
73     { HC_UMASK,         rc_umask },
74     { HC_SYMLINK,       rc_symlink },
75     { HC_RENAME,        rc_rename },
76     { HC_UTIMES,        rc_utimes },
77 };
78
79 int
80 hc_connect(struct HostConf *hc)
81 {
82     if (hcc_connect(hc) < 0)
83         return(-1);
84     return(hc_hello(hc));
85 }
86
87 void
88 hc_slave(int fdin, int fdout)
89 {
90     hcc_slave(fdin, fdout, HCDispatchTable,
91               sizeof(HCDispatchTable) / sizeof(HCDispatchTable[0]));
92     
93 }
94
95 /*
96  * A HELLO RPC is sent on the initial connect.
97  */
98 int
99 hc_hello(struct HostConf *hc)
100 {
101     struct HCHead *head;
102     struct HCLeaf *item;
103     char hostbuf[256];
104     int error;
105
106     bzero(hostbuf, sizeof(hostbuf));
107     if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
108         return(-1);
109     if (hostbuf[0] == 0)
110         hostbuf[0] = '?';
111
112     hcc_start_command(hc, HC_HELLO);
113     hcc_leaf_string(hc, LC_HELLOSTR, hostbuf);
114     if ((head = hcc_finish_command(hc)) == NULL)
115         return(-1);
116
117     if (head->error) {
118         fprintf(stderr, "Connected to %s but remote returned error %d\n",
119                 hc->host, head->error);
120         return(-1);
121     }
122
123     error = -1;
124     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
125         switch(item->leafid) {
126         case LC_HELLOSTR:
127             fprintf(stderr, "Handshaked with %s\n", HCC_STRING(item));
128             error = 0;
129         }
130     }
131     if (error < 0)
132         fprintf(stderr, "Handshake failed with %s\n", hc->host);
133     return (error);
134 }
135
136 static int
137 rc_hello(struct HostConf *hc, struct HCHead *head __unused)
138 {
139     char hostbuf[256];
140
141     bzero(hostbuf, sizeof(hostbuf));
142     if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
143         return(-1);
144     if (hostbuf[0] == 0)
145         hostbuf[0] = '?';
146
147     hcc_leaf_string(hc, LC_HELLOSTR, hostbuf);
148     return(0);
149 }
150
151 /*
152  * STAT, LSTAT
153  */
154 int
155 hc_stat(struct HostConf *hc, const char *path, struct stat *st)
156 {
157     struct HCHead *head;
158
159     if (hc == NULL || hc->host == NULL)
160         return(stat(path, st));
161
162     hcc_start_command(hc, HC_STAT);
163     hcc_leaf_string(hc, LC_PATH1, path);
164     if ((head = hcc_finish_command(hc)) == NULL)
165         return(-1);
166     if (head->error)
167         return(-1);
168     return(hc_decode_stat(st, head));
169 }
170
171 int
172 hc_lstat(struct HostConf *hc, const char *path, struct stat *st)
173 {
174     struct HCHead *head;
175
176     if (hc == NULL || hc->host == NULL)
177         return(lstat(path, st));
178
179     hcc_start_command(hc, HC_LSTAT);
180     hcc_leaf_string(hc, LC_PATH1, path);
181     if ((head = hcc_finish_command(hc)) == NULL)
182         return(-1);
183     if (head->error)
184         return(-1);
185     return(hc_decode_stat(st, head));
186 }
187
188 static int
189 hc_decode_stat(struct stat *st, struct HCHead *head)
190 {
191     struct HCLeaf *item;
192
193     bzero(st, sizeof(*st));
194     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
195         switch(item->leafid) {
196         case LC_DEV:
197                 st->st_dev = HCC_INT32(item);
198                 break;
199         case LC_INO:
200                 st->st_ino = HCC_INT64(item);
201                 break;
202         case LC_MODE:
203                 st->st_mode = HCC_INT32(item);
204                 break;
205         case LC_NLINK:
206                 st->st_nlink = HCC_INT32(item);
207                 break;
208         case LC_UID:
209                 st->st_uid = HCC_INT32(item);
210                 break;
211         case LC_GID:
212                 st->st_gid = HCC_INT32(item);
213                 break;
214         case LC_RDEV:
215                 st->st_rdev = HCC_INT32(item);
216                 break;
217         case LC_ATIME:
218                 st->st_atime = (time_t)HCC_INT64(item);
219                 break;
220         case LC_MTIME:
221                 st->st_mtime = (time_t)HCC_INT64(item);
222                 break;
223         case LC_CTIME:
224                 st->st_ctime = (time_t)HCC_INT64(item);
225                 break;
226         case LC_FILESIZE:
227                 st->st_size = HCC_INT64(item);
228                 break;
229         case LC_FILEBLKS:
230                 st->st_blocks = HCC_INT64(item);
231                 break;
232         case LC_BLKSIZE:
233                 st->st_blksize = HCC_INT32(item);
234                 break;
235 #ifdef _ST_FSMID_PRESENT_
236         case LC_FSMID:
237                 st->st_fsmid = HCC_INT64(item);
238                 break;
239 #endif
240 #ifdef _ST_FLAGS_PRESENT_
241         case LC_FILEFLAGS:
242                 st->st_flags = (u_int32_t)HCC_INT64(item);
243                 break;
244 #endif
245         }
246     }
247     return(0);
248 }
249
250 static int
251 rc_stat(struct HostConf *hc, struct HCHead *head)
252 {
253     struct HCLeaf *item;
254     struct stat st;
255     const char *path = NULL;
256
257     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
258         switch(item->leafid) {
259         case LC_PATH1:
260             path = HCC_STRING(item);
261             break;
262         }
263     }
264     if (path == NULL)
265         return(-2);
266     if (stat(path, &st) < 0)
267         return(-1);
268     return (rc_encode_stat(hc, &st));
269 }
270
271 static int
272 rc_lstat(struct HostConf *hc, struct HCHead *head)
273 {
274     struct HCLeaf *item;
275     struct stat st;
276     const char *path = NULL;
277
278     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
279         switch(item->leafid) {
280         case LC_PATH1:
281             path = HCC_STRING(item);
282             break;
283         }
284     }
285     if (path == NULL)
286         return(-2);
287     if (lstat(path, &st) < 0)
288         return(-1);
289     return (rc_encode_stat(hc, &st));
290 }
291
292 static int
293 rc_encode_stat(struct HostConf *hc, struct stat *st)
294 {
295     hcc_leaf_int32(hc, LC_DEV, st->st_dev);
296     hcc_leaf_int64(hc, LC_INO, st->st_ino);
297     hcc_leaf_int32(hc, LC_MODE, st->st_mode);
298     hcc_leaf_int32(hc, LC_NLINK, st->st_nlink);
299     hcc_leaf_int32(hc, LC_UID, st->st_uid);
300     hcc_leaf_int32(hc, LC_GID, st->st_gid);
301     hcc_leaf_int32(hc, LC_RDEV, st->st_rdev);
302     hcc_leaf_int64(hc, LC_ATIME, st->st_atime);
303     hcc_leaf_int64(hc, LC_MTIME, st->st_mtime);
304     hcc_leaf_int64(hc, LC_CTIME, st->st_ctime);
305     hcc_leaf_int64(hc, LC_FILESIZE, st->st_size);
306     hcc_leaf_int64(hc, LC_FILEBLKS, st->st_blocks);
307     hcc_leaf_int32(hc, LC_BLKSIZE, st->st_blksize);
308 #ifdef _ST_FSMID_PRESENT_
309     hcc_leaf_int64(hc, LC_FSMID, st->st_fsmid);
310 #endif
311 #ifdef _ST_FLAGS_PRESENT_
312     hcc_leaf_int64(hc, LC_FILEFLAGS, st->st_flags);
313 #endif
314     return(0);
315 }
316
317 /*
318  * OPENDIR
319  */
320 DIR *
321 hc_opendir(struct HostConf *hc, const char *path)
322 {
323     struct HCHead *head;
324     struct HCLeaf *item;
325     struct dirent *den;
326     int desc = 0;
327
328     if (hc == NULL || hc->host == NULL)
329         return(opendir(path));
330
331     hcc_start_command(hc, HC_OPENDIR);
332     hcc_leaf_string(hc, LC_PATH1, path);
333     if ((head = hcc_finish_command(hc)) == NULL)
334         return(NULL);
335     if (head->error)
336         return(NULL);
337     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
338         switch(item->leafid) {
339         case LC_DESCRIPTOR:
340             desc = HCC_INT32(item);
341             break;
342         }
343     }
344     if (hcc_get_descriptor(hc, desc, HC_DESC_DIR)) {
345         fprintf(stderr, "hc_opendir: remote reused active descriptor %d\n",
346                 desc);
347         return(NULL);
348     }
349     den = malloc(sizeof(*den));
350     bzero(den, sizeof(*den));
351     hcc_set_descriptor(hc, desc, den, HC_DESC_DIR);
352     return((void *)desc);
353 }
354
355 static int
356 rc_opendir(struct HostConf *hc, struct HCHead *head)
357 {
358     struct HCLeaf *item;
359     const char *path = NULL;
360     DIR *dir;
361     int desc;
362
363     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
364         switch(item->leafid) {
365         case LC_PATH1:
366             path = HCC_STRING(item);
367             break;
368         }
369     }
370     if (path == NULL)
371         return(-2);
372     if ((dir = opendir(path)) == NULL) {
373         head->error = errno;
374     } else {
375         desc = hcc_alloc_descriptor(hc, dir, HC_DESC_DIR);
376         hcc_leaf_int32(hc, LC_DESCRIPTOR, desc);
377     }
378     return(0);
379 }
380
381 /*
382  * READDIR
383  */
384 struct dirent *
385 hc_readdir(struct HostConf *hc, DIR *dir)
386 {
387     struct HCHead *head;
388     struct HCLeaf *item;
389     struct dirent *den;
390
391     if (hc == NULL || hc->host == NULL)
392         return(readdir(dir));
393
394     hcc_start_command(hc, HC_READDIR);
395     hcc_leaf_int32(hc, LC_DESCRIPTOR, (int)dir);
396     if ((head = hcc_finish_command(hc)) == NULL)
397         return(NULL);
398     if (head->error)
399         return(NULL);   /* XXX errno */
400     den = hcc_get_descriptor(hc, (int)dir, HC_DESC_DIR);
401     if (den == NULL)
402         return(NULL);   /* XXX errno */
403     if (den->d_name)
404         den->d_name[0] = 0;
405     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
406         switch(item->leafid) {
407         case LC_PATH1:
408             snprintf(den->d_name, sizeof(den->d_name), "%s", HCC_STRING(item));
409             break;
410         case LC_INO:
411             den->d_fileno = HCC_INT64(item);
412             break;
413         case LC_TYPE:
414             den->d_type = HCC_INT32(item);
415             break;
416         }
417     }
418     if (den->d_name[0]) {
419 #ifdef _DIRENT_HAVE_D_NAMLEN
420         den->d_namlen = strlen(den->d_name);
421 #endif
422         return(den);
423     }
424     return(NULL);       /* XXX errno */
425 }
426
427 static int
428 rc_readdir(struct HostConf *hc, struct HCHead *head)
429 {
430     struct HCLeaf *item;
431     struct dirent *den;
432     DIR *dir = NULL;
433
434     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
435         switch(item->leafid) {
436         case LC_DESCRIPTOR:
437             dir = hcc_get_descriptor(hc, HCC_INT32(item), HC_DESC_DIR);
438             break;
439         }
440     }
441     if (dir == NULL)
442         return(-2);
443     if ((den = readdir(dir)) != NULL) {
444         hcc_leaf_string(hc, LC_PATH1, den->d_name);
445         hcc_leaf_int64(hc, LC_INO, den->d_fileno);
446         hcc_leaf_int32(hc, LC_TYPE, den->d_type);
447     }
448     return(0);
449 }
450
451 /*
452  * CLOSEDIR
453  *
454  * XXX cpdup needs to check error code to avoid truncated dirs?
455  */
456 int
457 hc_closedir(struct HostConf *hc, DIR *dir)
458 {
459     struct HCHead *head;
460     struct dirent *den;
461
462     if (hc == NULL || hc->host == NULL)
463         return(closedir(dir));
464     den = hcc_get_descriptor(hc, (int)dir, HC_DESC_DIR);
465     if (den) {
466         free(den);
467         hcc_set_descriptor(hc, (int)dir, NULL, HC_DESC_DIR);
468
469         hcc_start_command(hc, HC_CLOSEDIR);
470         hcc_leaf_int32(hc, LC_DESCRIPTOR, (int)dir);
471         if ((head = hcc_finish_command(hc)) == NULL)
472             return(-1);
473         if (head->error)
474             return(-1);         /* XXX errno */
475         return(0);
476     } else {
477         /* errno */
478         return(-1);
479     }
480 }
481
482 static int
483 rc_closedir(struct HostConf *hc, struct HCHead *head)
484 {
485     struct HCLeaf *item;
486     DIR *dir = NULL;
487
488     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
489         switch(item->leafid) {
490         case LC_DESCRIPTOR:
491             dir = hcc_get_descriptor(hc, HCC_INT32(item), HC_DESC_DIR);
492             break;
493         }
494     }
495     if (dir == NULL)
496         return(-2);
497     return(closedir(dir));
498 }
499
500 /*
501  * OPEN
502  */
503 int
504 hc_open(struct HostConf *hc, const char *path, int flags, mode_t mode)
505 {
506     struct HCHead *head;
507     struct HCLeaf *item;
508     int *fdp;
509     int desc = 0;
510     int nflags;
511
512     if (hc == NULL || hc->host == NULL) {
513 #ifdef O_LARGEFILE
514         flags |= O_LARGEFILE;
515 #endif
516         return(open(path, flags, mode));
517     }
518
519     nflags = flags & XO_NATIVEMASK;
520     if (flags & O_CREAT)
521         nflags |= XO_CREAT;
522     if (flags & O_EXCL)
523         nflags |= XO_EXCL;
524     if (flags & O_TRUNC)
525         nflags |= XO_TRUNC;
526
527     hcc_start_command(hc, HC_OPEN);
528     hcc_leaf_string(hc, LC_PATH1, path);
529     hcc_leaf_int32(hc, LC_OFLAGS, nflags);
530     hcc_leaf_int32(hc, LC_MODE, mode);
531
532     if ((head = hcc_finish_command(hc)) == NULL)
533         return(-1);
534     if (head->error)
535         return(-1);
536     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
537         switch(item->leafid) {
538         case LC_DESCRIPTOR:
539             desc = HCC_INT32(item);
540             break;
541         }
542     }
543     if (hcc_get_descriptor(hc, desc, HC_DESC_FD)) {
544         fprintf(stderr, "hc_opendir: remote reused active descriptor %d\n",
545                 desc);
546         return(-1);
547     }
548     fdp = malloc(sizeof(int));
549     *fdp = desc;        /* really just a dummy */
550     hcc_set_descriptor(hc, desc, fdp, HC_DESC_FD);
551     return(desc);
552 }
553
554 static int
555 rc_open(struct HostConf *hc, struct HCHead *head)
556 {
557     struct HCLeaf *item;
558     const char *path = NULL;
559     int nflags = 0;
560     int flags;
561     mode_t mode = 0666;
562     int desc;
563     int *fdp;
564     int fd;
565
566     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
567         switch(item->leafid) {
568         case LC_PATH1:
569             path = HCC_STRING(item);
570             break;
571         case LC_OFLAGS:
572             nflags = HCC_INT32(item);
573             break;
574         case LC_MODE:
575             mode = HCC_INT32(item);
576             break;
577         }
578     }
579     if (path == NULL)
580         return(-2);
581
582     flags = nflags & XO_NATIVEMASK;
583     if (nflags & XO_CREAT)
584         flags |= O_CREAT;
585     if (nflags & XO_EXCL)
586         flags |= O_EXCL;
587     if (nflags & XO_TRUNC)
588         flags |= O_TRUNC;
589
590 #ifdef O_LARGEFILE
591     flags |= O_LARGEFILE;
592 #endif
593     if ((fd = open(path, flags, mode)) < 0) {
594         head->error = errno;
595         return(0);
596     }
597     fdp = malloc(sizeof(int));
598     *fdp = fd;
599     desc = hcc_alloc_descriptor(hc, fdp, HC_DESC_FD);
600     hcc_leaf_int32(hc, LC_DESCRIPTOR, desc);
601     return(0);
602 }
603
604 /*
605  * CLOSE
606  */
607 int
608 hc_close(struct HostConf *hc, int fd)
609 {
610     struct HCHead *head;
611     int *fdp;
612
613     if (hc == NULL || hc->host == NULL)
614         return(close(fd));
615
616     fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
617     if (fdp) {
618         free(fdp);
619         hcc_set_descriptor(hc, fd, NULL, HC_DESC_FD);
620
621         hcc_start_command(hc, HC_CLOSE);
622         hcc_leaf_int32(hc, LC_DESCRIPTOR, fd);
623         if ((head = hcc_finish_command(hc)) == NULL)
624             return(-1);
625         if (head->error)
626             return(-1);
627         return(0);
628     } else {
629         return(-1);
630     }
631 }
632
633 static int
634 rc_close(struct HostConf *hc, struct HCHead *head)
635 {
636     struct HCLeaf *item;
637     int *fdp = NULL;
638     int fd;
639     int desc = -1;
640
641     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
642         switch(item->leafid) {
643         case LC_DESCRIPTOR:
644             desc = HCC_INT32(item);
645             break;
646         }
647     }
648     if (desc < 0)
649         return(-2);
650     if ((fdp = hcc_get_descriptor(hc, desc, HC_DESC_FD)) == NULL)
651         return(-2);
652     fd = *fdp;
653     free(fdp);
654     hcc_set_descriptor(hc, desc, NULL, HC_DESC_FD);
655     return(close(fd));
656 }
657
658 /*
659  * READ
660  */
661 ssize_t
662 hc_read(struct HostConf *hc, int fd, void *buf, size_t bytes)
663 {
664     struct HCHead *head;
665     struct HCLeaf *item;
666     int *fdp;
667     int r;
668
669     if (hc == NULL || hc->host == NULL)
670         return(read(fd, buf, bytes));
671
672     fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
673     if (fdp) {
674         r = 0;
675         while (bytes) {
676             int n = (bytes > 32768) ? 32768 : bytes;
677             int x = 0;
678
679             hcc_start_command(hc, HC_READ);
680             hcc_leaf_int32(hc, LC_DESCRIPTOR, fd);
681             hcc_leaf_int32(hc, LC_BYTES, n);
682             if ((head = hcc_finish_command(hc)) == NULL)
683                 return(-1);
684             if (head->error)
685                 return(-1);
686             for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
687                 switch(item->leafid) {
688                 case LC_DATA:
689                     x = item->bytes - sizeof(*item);
690                     if (x > (int)bytes)
691                         x = (int)bytes;
692                     bcopy(HCC_BINARYDATA(item), buf, x);
693                     buf = (char *)buf + x;
694                     bytes -= (size_t)x;
695                     r += x;
696                     break;
697                 }
698             }
699             if (x < n)
700                 break;
701         }
702         return(r);
703     } else {
704         return(-1);
705     }
706 }
707
708 static int
709 rc_read(struct HostConf *hc, struct HCHead *head)
710 {
711     struct HCLeaf *item;
712     int *fdp = NULL;
713     char buf[32768];
714     int bytes = -1;
715     int n;
716
717     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
718         switch(item->leafid) {
719         case LC_DESCRIPTOR:
720             fdp = hcc_get_descriptor(hc, HCC_INT32(item), HC_DESC_FD);
721             break;
722         case LC_BYTES:
723             bytes = HCC_INT32(item);
724             break;
725         }
726     }
727     if (fdp == NULL)
728         return(-2);
729     if (bytes < 0 || bytes > 32768)
730         return(-2);
731     n = read(*fdp, buf, bytes);
732     if (n < 0) {
733         head->error = errno;
734         return(0);
735     }
736     hcc_leaf_data(hc, LC_DATA, buf, n);
737     return(0);
738 }
739
740 /*
741  * WRITE
742  */
743 ssize_t
744 hc_write(struct HostConf *hc, int fd, const void *buf, size_t bytes)
745 {
746     struct HCHead *head;
747     struct HCLeaf *item;
748     int *fdp;
749     int r;
750
751     if (hc == NULL || hc->host == NULL)
752         return(write(fd, buf, bytes));
753
754     fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
755     if (fdp) {
756         r = 0;
757         while (bytes) {
758             int n = (bytes > 32768) ? 32768 : bytes;
759             int x = 0;
760
761             hcc_start_command(hc, HC_WRITE);
762             hcc_leaf_int32(hc, LC_DESCRIPTOR, fd);
763             hcc_leaf_data(hc, LC_DATA, buf, n);
764             if ((head = hcc_finish_command(hc)) == NULL)
765                 return(-1);
766             if (head->error)
767                 return(-1);
768             for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
769                 switch(item->leafid) {
770                 case LC_BYTES:
771                     x = HCC_INT32(item);
772                     break;
773                 }
774             }
775             if (x < 0 || x > n)
776                 return(-1);
777             r += x;
778             buf = (const char *)buf + x;
779             bytes -= x;
780             if (x < n)
781                 break;
782         }
783         return(r);
784     } else {
785         return(-1);
786     }
787 }
788
789 static int
790 rc_write(struct HostConf *hc, struct HCHead *head)
791 {
792     struct HCLeaf *item;
793     int *fdp = NULL;
794     void *buf = NULL;
795     int n = -1;
796
797     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
798         switch(item->leafid) {
799         case LC_DESCRIPTOR:
800             fdp = hcc_get_descriptor(hc, HCC_INT32(item), HC_DESC_FD);
801             break;
802         case LC_DATA:
803             buf = HCC_BINARYDATA(item);
804             n = item->bytes - sizeof(*item);
805             break;
806         }
807     }
808     if (fdp == NULL)
809         return(-2);
810     if (n < 0 || n > 32768)
811         return(-2);
812     n = write(*fdp, buf, n);
813     if (n < 0) {
814         head->error = errno;
815     } else {
816         hcc_leaf_int32(hc, LC_BYTES, n);
817     }
818     return(0);
819 }
820
821 /*
822  * REMOVE
823  */
824 int
825 hc_remove(struct HostConf *hc, const char *path)
826 {
827     struct HCHead *head;
828
829     if (hc == NULL || hc->host == NULL)
830         return(remove(path));
831
832     hcc_start_command(hc, HC_REMOVE);
833     hcc_leaf_string(hc, LC_PATH1, path);
834     if ((head = hcc_finish_command(hc)) == NULL)
835         return(-1);
836     if (head->error)
837         return(-1);
838     return(0);
839 }
840
841 static int
842 rc_remove(struct HostConf *hc __unused, struct HCHead *head)
843 {
844     struct HCLeaf *item;
845     const char *path = NULL;
846
847     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
848         switch(item->leafid) {
849         case LC_PATH1:
850             path = HCC_STRING(item);
851             break;
852         }
853     }
854     if (path == NULL)
855         return(-2);
856     return(remove(path));
857 }
858
859 /*
860  * MKDIR
861  */
862 int
863 hc_mkdir(struct HostConf *hc __unused, const char *path, mode_t mode)
864 {
865     struct HCHead *head;
866
867     if (hc == NULL || hc->host == NULL)
868         return(mkdir(path, mode));
869
870     hcc_start_command(hc, HC_MKDIR);
871     hcc_leaf_string(hc, LC_PATH1, path);
872     hcc_leaf_int32(hc, LC_MODE, mode);
873     if ((head = hcc_finish_command(hc)) == NULL)
874         return(-1);
875     if (head->error)
876         return(-1);
877     return(0);
878 }
879
880 static int
881 rc_mkdir(struct HostConf *hc __unused, struct HCHead *head)
882 {
883     struct HCLeaf *item;
884     const char *path = NULL;
885     mode_t mode = 0777;
886
887     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
888         switch(item->leafid) {
889         case LC_PATH1:
890             path = HCC_STRING(item);
891             break;
892         case LC_MODE:
893             mode = HCC_INT32(item);
894             break;
895         }
896     }
897     if (path == NULL)
898         return(-1);
899     return(mkdir(path, mode));
900 }
901
902 /*
903  * RMDIR
904  */
905 int
906 hc_rmdir(struct HostConf *hc, const char *path)
907 {
908     struct HCHead *head;
909
910     if (hc == NULL || hc->host == NULL)
911         return(rmdir(path));
912
913     hcc_start_command(hc, HC_RMDIR);
914     hcc_leaf_string(hc, LC_PATH1, path);
915     if ((head = hcc_finish_command(hc)) == NULL)
916         return(-1);
917     if (head->error)
918         return(-1);
919     return(0);
920 }
921
922 static int
923 rc_rmdir(struct HostConf *hc __unused, struct HCHead *head)
924 {
925     struct HCLeaf *item;
926     const char *path = NULL;
927
928     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
929         switch(item->leafid) {
930         case LC_PATH1:
931             path = HCC_STRING(item);
932             break;
933         }
934     }
935     if (path == NULL)
936         return(-1);
937     return(rmdir(path));
938 }
939
940 /*
941  * CHOWN
942  */
943 int
944 hc_chown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
945 {
946     struct HCHead *head;
947
948     if (hc == NULL || hc->host == NULL)
949         return(chown(path, owner, group));
950
951     hcc_start_command(hc, HC_CHOWN);
952     hcc_leaf_string(hc, LC_PATH1, path);
953     hcc_leaf_int32(hc, LC_UID, owner);
954     hcc_leaf_int32(hc, LC_GID, group);
955     if ((head = hcc_finish_command(hc)) == NULL)
956         return(-1);
957     if (head->error)
958         return(-1);
959     return(0);
960 }
961
962 static int
963 rc_chown(struct HostConf *hc __unused, struct HCHead *head)
964 {
965     struct HCLeaf *item;
966     const char *path = NULL;
967     uid_t uid = (uid_t)-1;
968     gid_t gid = (gid_t)-1;
969
970     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
971         switch(item->leafid) {
972         case LC_PATH1:
973             path = HCC_STRING(item);
974             break;
975         case LC_UID:
976             uid = HCC_INT32(item);
977             break;
978         case LC_GID:
979             gid = HCC_INT32(item);
980             break;
981         }
982     }
983     if (path == NULL)
984         return(-1);
985     return(chown(path, uid, gid));
986 }
987
988 /*
989  * LCHOWN
990  */
991 int
992 hc_lchown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
993 {
994     struct HCHead *head;
995
996     if (hc == NULL || hc->host == NULL)
997         return(lchown(path, owner, group));
998
999     hcc_start_command(hc, HC_LCHOWN);
1000     hcc_leaf_string(hc, LC_PATH1, path);
1001     hcc_leaf_int32(hc, LC_UID, owner);
1002     hcc_leaf_int32(hc, LC_GID, group);
1003     if ((head = hcc_finish_command(hc)) == NULL)
1004         return(-1);
1005     if (head->error)
1006         return(-1);
1007     return(0);
1008 }
1009
1010 static int
1011 rc_lchown(struct HostConf *hc __unused, struct HCHead *head)
1012 {
1013     struct HCLeaf *item;
1014     const char *path = NULL;
1015     uid_t uid = (uid_t)-1;
1016     gid_t gid = (gid_t)-1;
1017
1018     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1019         switch(item->leafid) {
1020         case LC_PATH1:
1021             path = HCC_STRING(item);
1022             break;
1023         case LC_UID:
1024             uid = HCC_INT32(item);
1025             break;
1026         case LC_GID:
1027             gid = HCC_INT32(item);
1028             break;
1029         }
1030     }
1031     if (path == NULL)
1032         return(-1);
1033     return(lchown(path, uid, gid));
1034 }
1035
1036 /*
1037  * CHMOD
1038  */
1039 int
1040 hc_chmod(struct HostConf *hc, const char *path, mode_t mode)
1041 {
1042     struct HCHead *head;
1043
1044     if (hc == NULL || hc->host == NULL)
1045         return(chmod(path, mode));
1046
1047     hcc_start_command(hc, HC_CHMOD);
1048     hcc_leaf_string(hc, LC_PATH1, path);
1049     hcc_leaf_int32(hc, LC_MODE, mode);
1050     if ((head = hcc_finish_command(hc)) == NULL)
1051         return(-1);
1052     if (head->error)
1053         return(-1);
1054     return(0);
1055 }
1056
1057 static int
1058 rc_chmod(struct HostConf *hc __unused, struct HCHead *head)
1059 {
1060     struct HCLeaf *item;
1061     const char *path = NULL;
1062     mode_t mode = 0666;
1063
1064     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1065         switch(item->leafid) {
1066         case LC_PATH1:
1067             path = HCC_STRING(item);
1068             break;
1069         case LC_MODE:
1070             mode = HCC_INT32(item);
1071             break;
1072         }
1073     }
1074     if (path == NULL)
1075         return(-1);
1076     return(chmod(path, mode));
1077 }
1078
1079 /*
1080  * LINK
1081  */
1082 int
1083 hc_link(struct HostConf *hc, const char *name1, const char *name2)
1084 {
1085     struct HCHead *head;
1086
1087     if (hc == NULL || hc->host == NULL)
1088         return(link(name1, name2));
1089
1090     hcc_start_command(hc, HC_LINK);
1091     hcc_leaf_string(hc, LC_PATH1, name1);
1092     hcc_leaf_string(hc, LC_PATH2, name2);
1093     if ((head = hcc_finish_command(hc)) == NULL)
1094         return(-1);
1095     if (head->error)
1096         return(-1);
1097     return(0);
1098 }
1099
1100 static int
1101 rc_link(struct HostConf *hc __unused, struct HCHead *head)
1102 {
1103     struct HCLeaf *item;
1104     const char *name1 = NULL;
1105     const char *name2 = NULL;
1106
1107     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1108         switch(item->leafid) {
1109         case LC_PATH1:
1110             name1 = HCC_STRING(item);
1111             break;
1112         case LC_PATH2:
1113             name2 = HCC_STRING(item);
1114             break;
1115         }
1116     }
1117     if (name1 == NULL || name2 == NULL)
1118         return(-2);
1119     return(link(name1, name2));
1120 }
1121
1122 #ifdef _ST_FLAGS_PRESENT_
1123 /*
1124  * CHFLAGS
1125  */
1126 int
1127 hc_chflags(struct HostConf *hc, const char *path, u_long flags)
1128 {
1129     struct HCHead *head;
1130
1131     if (hc == NULL || hc->host == NULL)
1132         return(chflags(path, flags));
1133
1134     hcc_start_command(hc, HC_CHFLAGS);
1135     hcc_leaf_string(hc, LC_PATH1, path);
1136     hcc_leaf_int64(hc, LC_FILEFLAGS, flags);
1137     if ((head = hcc_finish_command(hc)) == NULL)
1138         return(-1);
1139     if (head->error)
1140         return(-1);
1141     return(0);
1142 }
1143
1144 static int
1145 rc_chflags(struct HostConf *hc __unused, struct HCHead *head)
1146 {
1147     struct HCLeaf *item;
1148     const char *path = NULL;
1149     u_long flags = 0;
1150
1151     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1152         switch(item->leafid) {
1153         case LC_PATH1:
1154             path = HCC_STRING(item);
1155             break;
1156         case LC_FILEFLAGS:
1157             flags = (u_long)HCC_INT64(item);
1158             break;
1159         }
1160     }
1161     if (path == NULL)
1162         return(-2);
1163     return(chflags(path, flags));
1164 }
1165
1166 #endif
1167
1168 /*
1169  * READLINK
1170  */
1171 int
1172 hc_readlink(struct HostConf *hc, const char *path, char *buf, int bufsiz)
1173 {
1174     struct HCHead *head;
1175     struct HCLeaf *item;
1176     int r;
1177
1178     if (hc == NULL || hc->host == NULL)
1179         return(readlink(path, buf, bufsiz));
1180
1181     hcc_start_command(hc, HC_READLINK);
1182     hcc_leaf_string(hc, LC_PATH1, path);
1183     if ((head = hcc_finish_command(hc)) == NULL)
1184         return(-1);
1185     if (head->error)
1186         return(-1);
1187
1188     r = 0;
1189     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1190         switch(item->leafid) {
1191         case LC_DATA:
1192             r = item->bytes - sizeof(*item);
1193             if (r < 0)
1194                 r = 0;
1195             if (r > bufsiz)
1196                 r = bufsiz;
1197             bcopy(HCC_BINARYDATA(item), buf, r);
1198             break;
1199         }
1200     }
1201     return(r);
1202 }
1203
1204 static int
1205 rc_readlink(struct HostConf *hc, struct HCHead *head)
1206 {
1207     struct HCLeaf *item;
1208     const char *path = NULL;
1209     char buf[1024];
1210     int r;
1211
1212     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1213         switch(item->leafid) {
1214         case LC_PATH1:
1215             path = HCC_STRING(item);
1216             break;
1217         }
1218     }
1219     if (path == NULL)
1220         return(-2);
1221     r = readlink(path, buf, sizeof(buf));
1222     if (r < 0)
1223         return(-1);
1224     hcc_leaf_data(hc, LC_DATA, buf, r);
1225     return(0);
1226 }
1227
1228 /*
1229  * UMASK
1230  */
1231 mode_t
1232 hc_umask(struct HostConf *hc, mode_t numask)
1233 {
1234     struct HCHead *head;
1235     struct HCLeaf *item;
1236
1237     if (hc == NULL || hc->host == NULL)
1238         return(umask(numask));
1239
1240     hcc_start_command(hc, HC_UMASK);
1241     hcc_leaf_int32(hc, LC_MODE, numask);
1242     if ((head = hcc_finish_command(hc)) == NULL)
1243         return((mode_t)-1);
1244     if (head->error)
1245         return((mode_t)-1);
1246
1247     numask = ~0666;
1248     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1249         switch(item->leafid) {
1250         case LC_MODE:
1251             numask = HCC_INT32(item);
1252             break;
1253         }
1254     }
1255     return(numask);
1256 }
1257
1258 static int
1259 rc_umask(struct HostConf *hc, struct HCHead *head)
1260 {
1261     struct HCLeaf *item;
1262     mode_t numask = ~0666;
1263
1264     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1265         switch(item->leafid) {
1266         case LC_MODE:
1267             numask = HCC_INT32(item);
1268             break;
1269         }
1270     }
1271     numask = umask(numask);
1272     hcc_leaf_int32(hc, LC_MODE, numask);
1273     return(0);
1274 }
1275
1276 /*
1277  * SYMLINK
1278  */
1279 int
1280 hc_symlink(struct HostConf *hc, const char *name1, const char *name2)
1281 {
1282     struct HCHead *head;
1283
1284     if (hc == NULL || hc->host == NULL)
1285         return(symlink(name1, name2));
1286
1287     hcc_start_command(hc, HC_SYMLINK);
1288     hcc_leaf_string(hc, LC_PATH1, name1);
1289     hcc_leaf_string(hc, LC_PATH2, name2);
1290     if ((head = hcc_finish_command(hc)) == NULL)
1291         return(-1);
1292     if (head->error)
1293         return(-1);
1294     return(0);
1295 }
1296
1297 static int
1298 rc_symlink(struct HostConf *hc __unused, struct HCHead *head)
1299 {
1300     struct HCLeaf *item;
1301     const char *name1 = NULL;
1302     const char *name2 = NULL;
1303
1304     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1305         switch(item->leafid) {
1306         case LC_PATH1:
1307             name1 = HCC_STRING(item);
1308             break;
1309         case LC_PATH2:
1310             name2 = HCC_STRING(item);
1311             break;
1312         }
1313     }
1314     if (name1 == NULL || name2 == NULL)
1315         return(-2);
1316     return(symlink(name1, name2));
1317 }
1318
1319 /*
1320  * RENAME
1321  */
1322 int
1323 hc_rename(struct HostConf *hc, const char *name1, const char *name2)
1324 {
1325     struct HCHead *head;
1326   
1327     if (hc == NULL || hc->host == NULL)
1328         return(rename(name1, name2));
1329
1330     hcc_start_command(hc, HC_RENAME);
1331     hcc_leaf_string(hc, LC_PATH1, name1);
1332     hcc_leaf_string(hc, LC_PATH2, name2);
1333     if ((head = hcc_finish_command(hc)) == NULL)
1334         return(-1);
1335     if (head->error)
1336         return(-1);
1337     return(0);
1338 }
1339
1340 static int
1341 rc_rename(struct HostConf *hc __unused, struct HCHead *head)
1342 {
1343     struct HCLeaf *item;
1344     const char *name1 = NULL;
1345     const char *name2 = NULL;
1346
1347     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1348         switch(item->leafid) {
1349         case LC_PATH1:
1350             name1 = HCC_STRING(item);
1351             break;
1352         case LC_PATH2:
1353             name2 = HCC_STRING(item);
1354             break;
1355         }
1356     }
1357     if (name1 == NULL || name2 == NULL)
1358         return(-2);
1359     return(rename(name1, name2));
1360 }
1361
1362 /*
1363  * UTIMES
1364  */
1365 int
1366 hc_utimes(struct HostConf *hc, const char *path, const struct timeval *times)
1367 {
1368     struct HCHead *head;
1369
1370     if (hc == NULL || hc->host == NULL)
1371         return(utimes(path, times));
1372
1373     hcc_start_command(hc, HC_UTIMES);
1374     hcc_leaf_string(hc, LC_PATH1, path);
1375     hcc_leaf_int64(hc, LC_ATIME, times[0].tv_sec);
1376     hcc_leaf_int64(hc, LC_MTIME, times[1].tv_sec);
1377     if ((head = hcc_finish_command(hc)) == NULL)
1378         return(-1);
1379     if (head->error)
1380         return(-1);
1381     return(0);
1382 }
1383
1384 static int
1385 rc_utimes(struct HostConf *hc __unused, struct HCHead *head)
1386 {
1387     struct HCLeaf *item;
1388     struct timeval times[2];
1389     const char *path;
1390
1391     bzero(times, sizeof(times));
1392     path = NULL;
1393
1394     for (item = hcc_firstitem(head); item; item = hcc_nextitem(head, item)) {
1395         switch(item->leafid) {
1396         case LC_PATH1:
1397             path = HCC_STRING(item);
1398             break;
1399         case LC_ATIME:
1400             times[0].tv_sec = HCC_INT64(item);
1401             break;
1402         case LC_MTIME:
1403             times[1].tv_sec = HCC_INT64(item);
1404             break;
1405         }
1406     }
1407     if (path == NULL)
1408         return(-2);
1409     return(utimes(path, times));
1410 }