?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix typo in MLINK name.
[dragonfly.git] / bin / cpdup / hcproto.c
blob6424074ad6681b6af1537326f2e673b0d2baf652
1 /*
2 * HCPROTO.C
3 *
4 * This module implements a simple remote control protocol
5 *
6 * $DragonFly: src/bin/cpdup/hcproto.c,v 1.8 2008/11/11 04:36:00 dillon Exp $
7 */
8
9 #include "cpdup.h"
10 #include "hclink.h"
11 #include "hcproto.h"
12
13 static int hc_decode_stat(hctransaction_t trans, struct stat *, struct HCHead *);
14 static int hc_decode_stat_item(struct stat *st, struct HCLeaf *item);
15 static int rc_encode_stat(hctransaction_t trans, struct stat *);
16
17 static int rc_hello(hctransaction_t trans, struct HCHead *);
18 static int rc_stat(hctransaction_t trans, struct HCHead *);
19 static int rc_lstat(hctransaction_t trans, struct HCHead *);
20 static int rc_opendir(hctransaction_t trans, struct HCHead *);
21 static int rc_readdir(hctransaction_t trans, struct HCHead *);
22 static int rc_closedir(hctransaction_t trans, struct HCHead *);
23 static int rc_scandir(hctransaction_t trans, struct HCHead *);
24 static int rc_open(hctransaction_t trans, struct HCHead *);
25 static int rc_close(hctransaction_t trans, struct HCHead *);
26 static int rc_read(hctransaction_t trans, struct HCHead *);
27 static int rc_readfile(hctransaction_t trans, struct HCHead *);
28 static int rc_write(hctransaction_t trans, struct HCHead *);
29 static int rc_remove(hctransaction_t trans, struct HCHead *);
30 static int rc_mkdir(hctransaction_t trans, struct HCHead *);
31 static int rc_rmdir(hctransaction_t trans, struct HCHead *);
32 static int rc_chown(hctransaction_t trans, struct HCHead *);
33 static int rc_lchown(hctransaction_t trans, struct HCHead *);
34 static int rc_chmod(hctransaction_t trans, struct HCHead *);
35 static int rc_mknod(hctransaction_t trans, struct HCHead *);
36 static int rc_link(hctransaction_t trans, struct HCHead *);
37 #ifdef _ST_FLAGS_PRESENT_
38 static int rc_chflags(hctransaction_t trans, struct HCHead *);
39 #endif
40 static int rc_readlink(hctransaction_t trans, struct HCHead *);
41 static int rc_umask(hctransaction_t trans, struct HCHead *);
42 static int rc_symlink(hctransaction_t trans, struct HCHead *);
43 static int rc_rename(hctransaction_t trans, struct HCHead *);
44 static int rc_utimes(hctransaction_t trans, struct HCHead *);
45 static int rc_geteuid(hctransaction_t trans, struct HCHead *);
46 static int rc_getgroups(hctransaction_t trans, struct HCHead *);
47
48 static int getmygroups(gid_t **gidlist);
49
50 static int silentwarning(int *, const char *, ...) __printflike(2, 3);
51
52 static struct HCDesc HCDispatchTable[] = {
53 { HC_HELLO, rc_hello },
54 { HC_STAT, rc_stat },
55 { HC_LSTAT, rc_lstat },
56 { HC_OPENDIR, rc_opendir },
57 { HC_READDIR, rc_readdir },
58 { HC_CLOSEDIR, rc_closedir },
59 { HC_OPEN, rc_open },
60 { HC_CLOSE, rc_close },
61 { HC_READ, rc_read },
62 { HC_WRITE, rc_write },
63 { HC_REMOVE, rc_remove },
64 { HC_MKDIR, rc_mkdir },
65 { HC_RMDIR, rc_rmdir },
66 { HC_CHOWN, rc_chown },
67 { HC_LCHOWN, rc_lchown },
68 { HC_CHMOD, rc_chmod },
69 { HC_MKNOD, rc_mknod },
70 { HC_LINK, rc_link },
71 #ifdef _ST_FLAGS_PRESENT_
72 { HC_CHFLAGS, rc_chflags },
73 #endif
74 { HC_READLINK, rc_readlink },
75 { HC_UMASK, rc_umask },
76 { HC_SYMLINK, rc_symlink },
77 { HC_RENAME, rc_rename },
78 { HC_UTIMES, rc_utimes },
79 { HC_GETEUID, rc_geteuid },
80 { HC_GETGROUPS, rc_getgroups },
81 { HC_SCANDIR, rc_scandir },
82 { HC_READFILE, rc_readfile },
83 };
84
85 static int chown_warning;
86 static int chflags_warning;
87
88 /*
89 * If not running as root generate a silent warning and return no error.
90 *
91 * If running as root return an error.
92 */
93 static int
94 silentwarning(int *didwarn, const char *ctl, ...)
95 {
96 va_list va;
97
98 if (DstRootPrivs)
99 return(-1);
100 if (*didwarn == 0 && QuietOpt == 0) {
101 *didwarn = 1;
102 fprintf(stderr, "WARNING: Not running as root, ");
103 va_start(va, ctl);
104 vfprintf(stderr, ctl, va);
105 va_end(va);
106 }
107 return(0);
108 }
109
110 int
111 hc_connect(struct HostConf *hc, int readonly)
112 {
113 if (hcc_connect(hc, readonly) < 0) {
114 fprintf(stderr, "Unable to connect to %s\n", hc->host);
115 return(-1);
116 }
117 return(hc_hello(hc));
118 }
119
120 void
121 hc_slave(int fdin, int fdout)
122 {
123 hcc_slave(fdin, fdout, HCDispatchTable,
124 sizeof(HCDispatchTable) / sizeof(HCDispatchTable[0]));
125 }
126
127 /*
128 * A HELLO RPC is sent on the initial connect.
129 */
130 int
131 hc_hello(struct HostConf *hc)
132 {
133 struct HCHead *head;
134 struct HCLeaf *item;
135 hctransaction_t trans;
136 char hostbuf[256];
137 int error;
138
139 bzero(hostbuf, sizeof(hostbuf));
140 if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
141 return(-1);
142 if (hostbuf[0] == 0)
143 hostbuf[0] = '?';
144
145 trans = hcc_start_command(hc, HC_HELLO);
146 hcc_leaf_string(trans, LC_HELLOSTR, hostbuf);
147 hcc_leaf_int32(trans, LC_VERSION, HCPROTO_VERSION);
148 if (UseCpFile)
149 hcc_leaf_string(trans, LC_PATH1, UseCpFile);
150 if ((head = hcc_finish_command(trans)) == NULL) {
151 fprintf(stderr, "Connected to %s but remote failed to complete hello\n",
152 hc->host);
153 return(-1);
154 }
155
156 if (head->error) {
157 fprintf(stderr, "Connected to %s but remote returned error %d\n",
158 hc->host, head->error);
159 return(-1);
160 }
161
162 error = -1;
163 FOR_EACH_ITEM(item, trans, head) {
164 switch(item->leafid) {
165 case LC_HELLOSTR:
166 if (QuietOpt == 0)
167 fprintf(stderr, "Handshaked with %s\n", HCC_STRING(item));
168 error = 0;
169 break;
170 case LC_VERSION:
171 hc->version = HCC_INT32(item);
172 break;
173 }
174 }
175 if (hc->version < HCPROTO_VERSION_COMPAT) {
176 fprintf(stderr, "Remote cpdup at %s has an incompatible version\n",
177 hc->host);
178 error = -1;
179 } else if (hc->version < HCPROTO_VERSION && QuietOpt == 0) {
180 fprintf(stderr, "WARNING: Remote cpdup at %s has a lower version, "
181 "expect reduced speed\n", hc->host);
182 }
183 if (error < 0)
184 fprintf(stderr, "Handshake failed with %s\n", hc->host);
185 return (error);
186 }
187
188 static int
189 rc_hello(hctransaction_t trans, struct HCHead *head)
190 {
191 struct HCLeaf *item;
192 char hostbuf[256];
193
194 FOR_EACH_ITEM(item, trans, head) {
195 if (item->leafid == LC_PATH1)
196 UseCpFile = strdup(HCC_STRING(item));
197 }
198
199 bzero(hostbuf, sizeof(hostbuf));
200 if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
201 return(-1);
202 if (hostbuf[0] == 0)
203 hostbuf[0] = '?';
204
205 hcc_leaf_string(trans, LC_HELLOSTR, hostbuf);
206 hcc_leaf_int32(trans, LC_VERSION, HCPROTO_VERSION);
207 return(0);
208 }
209
210 /*
211 * STAT, LSTAT
212 */
213 int
214 hc_stat(struct HostConf *hc, const char *path, struct stat *st)
215 {
216 struct HCHead *head;
217 hctransaction_t trans;
218
219 if (hc == NULL || hc->host == NULL)
220 return(stat(path, st));
221
222 trans = hcc_start_command(hc, HC_STAT);
223 hcc_leaf_string(trans, LC_PATH1, path);
224 if ((head = hcc_finish_command(trans)) == NULL)
225 return(-1);
226 if (head->error)
227 return(-1);
228 return(hc_decode_stat(trans, st, head));
229 }
230
231 int
232 hc_lstat(struct HostConf *hc, const char *path, struct stat *st)
233 {
234 struct HCHead *head;
235 hctransaction_t trans;
236
237 if (hc == NULL || hc->host == NULL)
238 return(lstat(path, st));
239
240 trans = hcc_start_command(hc, HC_LSTAT);
241 hcc_leaf_string(trans, LC_PATH1, path);
242 if ((head = hcc_finish_command(trans)) == NULL)
243 return(-1);
244 if (head->error)
245 return(-1);
246 return(hc_decode_stat(trans, st, head));
247 }
248
249 static int
250 hc_decode_stat(hctransaction_t trans, struct stat *st, struct HCHead *head)
251 {
252 struct HCLeaf *item;
253
254 bzero(st, sizeof(*st));
255 FOR_EACH_ITEM(item, trans, head)
256 hc_decode_stat_item(st, item);
257 return(0);
258 }
259
260 static int
261 hc_decode_stat_item(struct stat *st, struct HCLeaf *item)
262 {
263 switch(item->leafid) {
264 case LC_DEV:
265 st->st_dev = HCC_INT32(item);
266 break;
267 case LC_INO:
268 st->st_ino = HCC_INT64(item);
269 break;
270 case LC_MODE:
271 st->st_mode = HCC_INT32(item);
272 break;
273 case LC_NLINK:
274 st->st_nlink = HCC_INT32(item);
275 break;
276 case LC_UID:
277 st->st_uid = HCC_INT32(item);
278 break;
279 case LC_GID:
280 st->st_gid = HCC_INT32(item);
281 break;
282 case LC_RDEV:
283 st->st_rdev = HCC_INT32(item);
284 break;
285 case LC_ATIME:
286 st->st_atime = (time_t)HCC_INT64(item);
287 break;
288 case LC_MTIME:
289 st->st_mtime = (time_t)HCC_INT64(item);
290 break;
291 case LC_CTIME:
292 st->st_ctime = (time_t)HCC_INT64(item);
293 break;
294 case LC_FILESIZE:
295 st->st_size = HCC_INT64(item);
296 break;
297 case LC_FILEBLKS:
298 st->st_blocks = HCC_INT64(item);
299 break;
300 case LC_BLKSIZE:
301 st->st_blksize = HCC_INT32(item);
302 break;
303 #ifdef _ST_FSMID_PRESENT_
304 case LC_FSMID:
305 st->st_fsmid = HCC_INT64(item);
306 break;
307 #endif
308 #ifdef _ST_FLAGS_PRESENT_
309 case LC_FILEFLAGS:
310 st->st_flags = (uint32_t)HCC_INT64(item);
311 break;
312 #endif
313 }
314 return(0);
315 }
316
317 static int
318 rc_stat(hctransaction_t trans, struct HCHead *head)
319 {
320 struct HCLeaf *item;
321 struct stat st;
322 const char *path = NULL;
323
324 FOR_EACH_ITEM(item, trans, head) {
325 if (item->leafid == LC_PATH1)
326 path = HCC_STRING(item);
327 }
328 if (path == NULL)
329 return(-2);
330 if (stat(path, &st) < 0)
331 return(-1);
332 return (rc_encode_stat(trans, &st));
333 }
334
335 static int
336 rc_lstat(hctransaction_t trans, struct HCHead *head)
337 {
338 struct HCLeaf *item;
339 struct stat st;
340 const char *path = NULL;
341
342 FOR_EACH_ITEM(item, trans, head) {
343 if (item->leafid == LC_PATH1)
344 path = HCC_STRING(item);
345 }
346 if (path == NULL)
347 return(-2);
348 if (lstat(path, &st) < 0)
349 return(-1);
350 return (rc_encode_stat(trans, &st));
351 }
352
353 /*
354 * Encode all entries of a stat structure.
355 *
356 * CAUTION: If you add any more entries here, be sure to
357 * increase the STAT_MAX_NUM_ENTRIES value!
358 */
359 #define STAT_MAX_NUM_ENTRIES 18
360 static int
361 rc_encode_stat(hctransaction_t trans, struct stat *st)
362 {
363 hcc_leaf_int32(trans, LC_DEV, st->st_dev);
364 hcc_leaf_int64(trans, LC_INO, st->st_ino);
365 hcc_leaf_int32(trans, LC_MODE, st->st_mode);
366 hcc_leaf_int32(trans, LC_NLINK, st->st_nlink);
367 hcc_leaf_int32(trans, LC_UID, st->st_uid);
368 hcc_leaf_int32(trans, LC_GID, st->st_gid);
369 hcc_leaf_int32(trans, LC_RDEV, st->st_rdev);
370 hcc_leaf_int64(trans, LC_ATIME, st->st_atime);
371 hcc_leaf_int64(trans, LC_MTIME, st->st_mtime);
372 hcc_leaf_int64(trans, LC_CTIME, st->st_ctime);
373 hcc_leaf_int64(trans, LC_FILESIZE, st->st_size);
374 hcc_leaf_int64(trans, LC_FILEBLKS, st->st_blocks);
375 hcc_leaf_int32(trans, LC_BLKSIZE, st->st_blksize);
376 #ifdef _ST_FSMID_PRESENT_
377 hcc_leaf_int64(trans, LC_FSMID, st->st_fsmid);
378 #endif
379 #ifdef _ST_FLAGS_PRESENT_
380 hcc_leaf_int64(trans, LC_FILEFLAGS, st->st_flags);
381 #endif
382 return(0);
383 }
384
385 /*
386 * OPENDIR
387 */
388 DIR *
389 hc_opendir(struct HostConf *hc, const char *path)
390 {
391 hctransaction_t trans;
392 struct HCHead *head;
393
394 if (hc == NULL || hc->host == NULL)
395 return(opendir(path));
396
397 if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
398 struct HCLeaf *item;
399 struct HCDirEntry *den;
400 intptr_t desc = 0;
401
402 trans = hcc_start_command(hc, HC_OPENDIR);
403 hcc_leaf_string(trans, LC_PATH1, path);
404 if ((head = hcc_finish_command(trans)) == NULL)
405 return (NULL);
406 if (head->error)
407 return (NULL);
408 FOR_EACH_ITEM(item, trans, head) {
409 if (item->leafid == LC_DESCRIPTOR)
410 desc = HCC_INT32(item);
411 }
412 if (hcc_get_descriptor(hc, desc, HC_DESC_DIR)) {
413 fprintf(stderr, "hc_opendir: remote reused active descriptor %jd\n",
414 (intmax_t)desc);
415 return (NULL);
416 }
417 den = malloc(sizeof(*den));
418 hcc_set_descriptor(hc, desc, den, HC_DESC_DIR);
419 return ((void *)desc);
420 }
421
422 /* hc->version >= 4: use HC_SCANDIR */
423 trans = hcc_start_command(hc, HC_SCANDIR);
424 hcc_leaf_string(trans, LC_PATH1, path);
425 if ((head = hcc_finish_command(trans)) == NULL || head->error)
426 return (NULL);
427 return ((void *)head);
428 }
429
430 static int
431 rc_opendir(hctransaction_t trans, struct HCHead *head)
432 {
433 struct HCLeaf *item;
434 const char *path = NULL;
435 DIR *dir;
436 int desc;
437
438 FOR_EACH_ITEM(item, trans, head) {
439 if (item->leafid == LC_PATH1)
440 path = HCC_STRING(item);
441 }
442 if (path == NULL)
443 return(-2);
444 if ((dir = opendir(path)) == NULL) {
445 head->error = errno;
446 } else {
447 desc = hcc_alloc_descriptor(trans->hc, dir, HC_DESC_DIR);
448 hcc_leaf_int32(trans, LC_DESCRIPTOR, desc);
449 }
450 return(0);
451 }
452
453 /*
454 * READDIR
455 */
456 struct HCDirEntry *
457 hc_readdir(struct HostConf *hc, DIR *dir, struct stat **statpp)
458 {
459 int stat_ok = 0;
460 struct HCHead *head;
461 struct HCLeaf *item;
462 static struct HCDirEntry denbuf;
463
464 *statpp = NULL;
465 if (hc == NULL || hc->host == NULL) {
466 struct dirent *sysden;
467
468 if ((sysden = readdir(dir)) == NULL)
469 return (NULL);
470 strlcpy(denbuf.d_name, sysden->d_name, MAXNAMLEN + 1);
471 return (&denbuf);
472 }
473
474 if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
475 hctransaction_t trans;
476 struct HCDirEntry *den;
477
478 trans = hcc_start_command(hc, HC_READDIR);
479 hcc_leaf_int32(trans, LC_DESCRIPTOR, (intptr_t)dir);
480 if ((head = hcc_finish_command(trans)) == NULL)
481 return (NULL);
482 if (head->error)
483 return (NULL); /* XXX errno */
484 den = hcc_get_descriptor(hc, (intptr_t)dir, HC_DESC_DIR);
485 if (den == NULL)
486 return (NULL); /* XXX errno */
487 den->d_name[0] = 0;
488 FOR_EACH_ITEM(item, trans, head) {
489 if (item->leafid == LC_PATH1)
490 strlcpy(den->d_name, HCC_STRING(item), MAXNAMLEN + 1);
491 }
492 return (den->d_name[0] ? den : NULL);
493 }
494
495 /* hc->version >= 4: using HC_SCANDIR */
496 denbuf.d_name[0] = 0;
497 head = (void *)dir;
498 *statpp = malloc(sizeof(struct stat));
499 bzero(*statpp, sizeof(struct stat));
500 while ((item = hcc_nextchaineditem(hc, head)) != NULL) {
501 if (item->leafid == LC_PATH1) { /* this must be the last item */
502 strlcpy(denbuf.d_name, HCC_STRING(item), MAXNAMLEN + 1);
503 break;
504 } else {
505 stat_ok = 1;
506 hc_decode_stat_item(*statpp, item);
507 }
508 }
509 if (!stat_ok) {
510 free(*statpp);
511 *statpp = NULL;
512 }
513 return (denbuf.d_name[0] ? &denbuf : NULL);
514 }
515
516 static int
517 rc_readdir(hctransaction_t trans, struct HCHead *head)
518 {
519 struct HCLeaf *item;
520 struct dirent *den;
521 DIR *dir = NULL;
522
523 FOR_EACH_ITEM(item, trans, head) {
524 if (item->leafid == LC_DESCRIPTOR)
525 dir = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_DIR);
526 }
527 if (dir == NULL)
528 return(-2);
529 if ((den = readdir(dir)) != NULL)
530 hcc_leaf_string(trans, LC_PATH1, den->d_name);
531 return(0);
532 }
533
534 /*
535 * CLOSEDIR
536 *
537 * XXX cpdup needs to check error code to avoid truncated dirs?
538 */
539 int
540 hc_closedir(struct HostConf *hc, DIR *dir)
541 {
542 struct HCHead *head;
543
544 if (hc == NULL || hc->host == NULL)
545 return(closedir(dir));
546
547 if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
548 hctransaction_t trans;
549 struct dirent *den;
550
551 if ((den = hcc_get_descriptor(hc, (intptr_t)dir, HC_DESC_DIR)) != NULL) {
552 free(den);
553 hcc_set_descriptor(hc, (intptr_t)dir, NULL, HC_DESC_DIR);
554 trans = hcc_start_command(hc, HC_CLOSEDIR);
555 hcc_leaf_int32(trans, LC_DESCRIPTOR, (intptr_t)dir);
556 if ((head = hcc_finish_command(trans)) == NULL)
557 return (-1);
558 if (head->error)
559 return (-1); /* XXX errno */
560 return (0);
561 } else {
562 /* errno */
563 return(-1);
564 }
565 }
566
567 /* hc->version >= 4: using HC_SCANDIR */
568 head = (void *)dir;
569 /* skip any remaining items if the directory is closed prematurely */
570 while (hcc_nextchaineditem(hc, head) != NULL)
571 /*nothing*/ ;
572 if (head->error)
573 return (-1);
574 return (0);
575 }
576
577 static int
578 rc_closedir(hctransaction_t trans, struct HCHead *head)
579 {
580 struct HCLeaf *item;
581 DIR *dir = NULL;
582
583 FOR_EACH_ITEM(item, trans, head) {
584 if (item->leafid == LC_DESCRIPTOR) {
585 dir = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_DIR);
586 if (dir != NULL) {
587 hcc_set_descriptor(trans->hc, HCC_INT32(item),
588 NULL, HC_DESC_DIR);
589 }
590 }
591 }
592 if (dir == NULL)
593 return(-2);
594 return(closedir(dir));
595 }
596
597 /*
598 * SCANDIR
599 */
600 static int
601 rc_scandir(hctransaction_t trans, struct HCHead *head)
602 {
603 struct HCLeaf *item;
604 const char *path = NULL;
605 struct dirent *den;
606 DIR *dir;
607 char *fpath;
608 struct stat st;
609
610 FOR_EACH_ITEM(item, trans, head) {
611 if (item->leafid == LC_PATH1)
612 path = HCC_STRING(item);
613 }
614 if (path == NULL)
615 return (-2);
616 if ((dir = opendir(path)) == NULL)
617 return (-1);
618 while ((den = readdir(dir)) != NULL) {
619 if (den->d_name[0] == '.' && (den->d_name[1] == '\0' ||
620 (den->d_name[1] == '.' && den->d_name[2] == '\0')))
621 continue; /* skip "." and ".." */
622 /*
623 * Check if there's enough space left in the current packet.
624 * We have at most STAT_MAX_NUM_ENTRIES pieces of data, of which
625 * one is a string, so we use strlen() + 1 (terminating zero).
626 * The remaining ones are numbers; we assume sizeof(int64_t) so
627 * we're on the safe side.
628 */
629 if (!hcc_check_space(trans, head, STAT_MAX_NUM_ENTRIES,
630 (STAT_MAX_NUM_ENTRIES - 1) * sizeof(int64_t) +
631 strlen(den->d_name) + 1)) {
632 closedir(dir);
633 return (-1);
634 }
635 fpath = mprintf("%s/%s", path, den->d_name);
636 if (lstat(fpath, &st) == 0)
637 rc_encode_stat(trans, &st);
638 /* The name must be the last item! */
639 hcc_leaf_string(trans, LC_PATH1, den->d_name);
640 free(fpath);
641 }
642 return (closedir(dir));
643 }
644
645 /*
646 * OPEN
647 */
648 int
649 hc_open(struct HostConf *hc, const char *path, int flags, mode_t mode)
650 {
651 hctransaction_t trans;
652 struct HCHead *head;
653 struct HCLeaf *item;
654 int *fdp;
655 int desc = 0;
656 int nflags;
657
658 if (NotForRealOpt && (flags & O_CREAT))
659 return(0x7FFFFFFF);
660
661 if (hc == NULL || hc->host == NULL) {
662 #ifdef O_LARGEFILE
663 flags |= O_LARGEFILE;
664 #endif
665 return(open(path, flags, mode));
666 }
667
668 if ((flags & (O_WRONLY | O_RDWR)) == 0 && hc->version >= 4) {
669 trans = hcc_start_command(hc, HC_READFILE);
670 hcc_leaf_string(trans, LC_PATH1, path);
671 if ((head = hcc_finish_command(trans)) == NULL || head->error)
672 return (-1);
673 head->magic = 0; /* used to indicate offset within buffer */
674 return (1); /* dummy */
675 }
676
677 nflags = flags & XO_NATIVEMASK;
678 if (flags & O_CREAT)
679 nflags |= XO_CREAT;
680 if (flags & O_EXCL)
681 nflags |= XO_EXCL;
682 if (flags & O_TRUNC)
683 nflags |= XO_TRUNC;
684
685 trans = hcc_start_command(hc, HC_OPEN);
686 hcc_leaf_string(trans, LC_PATH1, path);
687 hcc_leaf_int32(trans, LC_OFLAGS, nflags);
688 hcc_leaf_int32(trans, LC_MODE, mode);
689
690 if ((head = hcc_finish_command(trans)) == NULL)
691 return(-1);
692 if (head->error)
693 return(-1);
694 FOR_EACH_ITEM(item, trans, head) {
695 if (item->leafid == LC_DESCRIPTOR)
696 desc = HCC_INT32(item);
697 }
698 if (hcc_get_descriptor(hc, desc, HC_DESC_FD)) {
699 fprintf(stderr, "hc_open: remote reused active descriptor %d\n",
700 desc);
701 return(-1);
702 }
703 fdp = malloc(sizeof(int));
704 *fdp = desc; /* really just a dummy */
705 hcc_set_descriptor(hc, desc, fdp, HC_DESC_FD);
706 return(desc);
707 }
708
709 static int
710 rc_open(hctransaction_t trans, struct HCHead *head)
711 {
712 struct HCLeaf *item;
713 const char *path = NULL;
714 int nflags = 0;
715 int flags;
716 mode_t mode = 0666;
717 int desc;
718 int *fdp;
719 int fd;
720
721 FOR_EACH_ITEM(item, trans, head) {
722 switch(item->leafid) {
723 case LC_PATH1:
724 path = HCC_STRING(item);
725 break;
726 case LC_OFLAGS:
727 nflags = HCC_INT32(item);
728 break;
729 case LC_MODE:
730 mode = HCC_INT32(item);
731 break;
732 }
733 }
734 if (path == NULL)
735 return(-2);
736
737 flags = nflags & XO_NATIVEMASK;
738 if (nflags & XO_CREAT)
739 flags |= O_CREAT;
740 if (nflags & XO_EXCL)
741 flags |= O_EXCL;
742 if (nflags & XO_TRUNC)
743 flags |= O_TRUNC;
744
745 if (ReadOnlyOpt) {
746 if (flags & (O_WRONLY | O_RDWR | O_CREAT | O_TRUNC)) {
747 head->error = EACCES;
748 return (0);
749 }
750 flags |= O_RDONLY;
751 }
752
753 #ifdef O_LARGEFILE
754 flags |= O_LARGEFILE;
755 #endif
756 if ((fd = open(path, flags, mode)) < 0)
757 return(-1);
758 fdp = malloc(sizeof(int));
759 *fdp = fd;
760 desc = hcc_alloc_descriptor(trans->hc, fdp, HC_DESC_FD);
761 hcc_leaf_int32(trans, LC_DESCRIPTOR, desc);
762 return(0);
763 }
764
765 /*
766 * CLOSE
767 */
768 int
769 hc_close(struct HostConf *hc, int fd)
770 {
771 hctransaction_t trans;
772 struct HCHead *head;
773 int *fdp;
774
775 if (NotForRealOpt && fd == 0x7FFFFFFF)
776 return(0);
777 if (hc == NULL || hc->host == NULL)
778 return(close(fd));
779
780 if (fd == 1 && hc->version >= 4) { /* using HC_READFILE */
781 head = (void *)hc->trans.rbuf;
782 /* skip any remaining items if the file is closed prematurely */
783 while (hcc_nextchaineditem(hc, head) != NULL)
784 /*nothing*/ ;
785 if (head->error)
786 return (-1);
787 return (0);
788 }
789
790 fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
791 if (fdp) {
792 free(fdp);
793 hcc_set_descriptor(hc, fd, NULL, HC_DESC_FD);
794
795 trans = hcc_start_command(hc, HC_CLOSE);
796 hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
797 if ((head = hcc_finish_command(trans)) == NULL)
798 return(-1);
799 if (head->error)
800 return(-1);
801 return(0);
802 } else {
803 return(-1);
804 }
805 }
806
807 static int
808 rc_close(hctransaction_t trans, struct HCHead *head)
809 {
810 struct HCLeaf *item;
811 int *fdp = NULL;
812 int fd;
813 int desc = -1;
814
815 FOR_EACH_ITEM(item, trans, head) {
816 if (item->leafid == LC_DESCRIPTOR)
817 desc = HCC_INT32(item);
818 }
819 if (desc < 0)
820 return(-2);
821 if ((fdp = hcc_get_descriptor(trans->hc, desc, HC_DESC_FD)) == NULL)
822 return(-2);
823 fd = *fdp;
824 free(fdp);
825 hcc_set_descriptor(trans->hc, desc, NULL, HC_DESC_FD);
826 return(close(fd));
827 }
828
829 static int
830 getiolimit(void)
831 {
832 return(32768);
833 }
834
835 /*
836 * READ
837 */
838 ssize_t
839 hc_read(struct HostConf *hc, int fd, void *buf, size_t bytes)
840 {
841 hctransaction_t trans;
842 struct HCHead *head;
843 struct HCLeaf *item;
844 int *fdp;
845 int offset;
846 int r = 0;
847 int x = 0;
848
849 if (hc == NULL || hc->host == NULL)
850 return(read(fd, buf, bytes));
851
852 if (fd == 1 && hc->version >= 4) { /* using HC_READFILE */
853 head = (void *)hc->trans.rbuf;
854 while (bytes) {
855 if ((offset = head->magic) != 0)
856 item = hcc_currentchaineditem(hc, head);
857 else
858 item = hcc_nextchaineditem(hc, head);
859 if (item == NULL)
860 return (r);
861 if (item->leafid != LC_DATA)
862 return (-1);
863 x = item->bytes - sizeof(*item) - offset;
864 if (x > (int)bytes) {
865 x = (int)bytes;
866 head->magic += x; /* leave bytes in the buffer */
867 }
868 else
869 head->magic = 0; /* all bytes used up */
870 bcopy((char *)HCC_BINARYDATA(item) + offset, buf, x);
871 buf = (char *)buf + x;
872 bytes -= (size_t)x;
873 r += x;
874 }
875 return (r);
876 }
877
878 fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
879 if (fdp) {
880 while (bytes) {
881 size_t limit = getiolimit();
882 int n = (bytes > limit) ? limit : bytes;
883
884 trans = hcc_start_command(hc, HC_READ);
885 hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
886 hcc_leaf_int32(trans, LC_BYTES, n);
887 if ((head = hcc_finish_command(trans)) == NULL)
888 return(-1);
889 if (head->error)
890 return(-1);
891 FOR_EACH_ITEM(item, trans, head) {
892 if (item->leafid == LC_DATA) {
893 x = item->bytes - sizeof(*item);
894 if (x > (int)bytes)
895 x = (int)bytes;
896 bcopy(HCC_BINARYDATA(item), buf, x);
897 buf = (char *)buf + x;
898 bytes -= (size_t)x;
899 r += x;
900 }
901 }
902 if (x < n)
903 break;
904 }
905 return(r);
906 } else {
907 return(-1);
908 }
909 }
910
911 static int
912 rc_read(hctransaction_t trans, struct HCHead *head)
913 {
914 struct HCLeaf *item;
915 int *fdp = NULL;
916 char buf[32768];
917 int bytes = -1;
918 int n;
919
920 FOR_EACH_ITEM(item, trans, head) {
921 switch(item->leafid) {
922 case LC_DESCRIPTOR:
923 fdp = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_FD);
924 break;
925 case LC_BYTES:
926 bytes = HCC_INT32(item);
927 break;
928 }
929 }
930 if (fdp == NULL)
931 return(-2);
932 if (bytes < 0 || bytes > 32768)
933 return(-2);
934 n = read(*fdp, buf, bytes);
935 if (n < 0)
936 return(-1);
937 hcc_leaf_data(trans, LC_DATA, buf, n);
938 return(0);
939 }
940
941 /*
942 * READFILE
943 */
944 static int
945 rc_readfile(hctransaction_t trans, struct HCHead *head)
946 {
947 struct HCLeaf *item;
948 const char *path = NULL;
949 char buf[32768];
950 int n;
951 int fd;
952
953 FOR_EACH_ITEM(item, trans, head) {
954 if (item->leafid == LC_PATH1)
955 path = HCC_STRING(item);
956 }
957 if (path == NULL)
958 return (-2);
959 if ((fd = open(path, O_RDONLY)) < 0)
960 return(-1);
961 while ((n = read(fd, buf, 32768)) >= 0) {
962 if (!hcc_check_space(trans, head, 1, n)) {
963 close(fd);
964 return (-1);
965 }
966 hcc_leaf_data(trans, LC_DATA, buf, n);
967 if (n == 0)
968 break;
969 }
970 if (n < 0) {
971 close(fd);
972 return (-1);
973 }
974 return (close(fd));
975 }
976
977 /*
978 * WRITE
979 */
980 ssize_t
981 hc_write(struct HostConf *hc, int fd, const void *buf, size_t bytes)
982 {
983 hctransaction_t trans;
984 struct HCHead *head;
985 struct HCLeaf *item;
986 int *fdp;
987 int r;
988
989 if (NotForRealOpt)
990 return(bytes);
991
992 if (hc == NULL || hc->host == NULL)
993 return(write(fd, buf, bytes));
994
995 fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
996 if (fdp) {
997 r = 0;
998 while (bytes) {
999 size_t limit = getiolimit();
1000 int n = (bytes > limit) ? limit : bytes;
1001 int x = 0;
1002
1003 trans = hcc_start_command(hc, HC_WRITE);
1004 hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
1005 hcc_leaf_data(trans, LC_DATA, buf, n);
1006 if ((head = hcc_finish_command(trans)) == NULL)
1007 return(-1);
1008 if (head->error)
1009 return(-1);
1010 FOR_EACH_ITEM(item, trans, head) {
1011 if (item->leafid == LC_BYTES)
1012 x = HCC_INT32(item);
1013 }
1014 if (x < 0 || x > n)
1015 return(-1);
1016 r += x;
1017 buf = (const char *)buf + x;
1018 bytes -= x;
1019 if (x < n)
1020 break;
1021 }
1022 return(r);
1023 } else {
1024 return(-1);
1025 }
1026 }
1027
1028 static int
1029 rc_write(hctransaction_t trans, struct HCHead *head)
1030 {
1031 struct HCLeaf *item;
1032 int *fdp = NULL;
1033 void *buf = NULL;
1034 int n = -1;
1035
1036 FOR_EACH_ITEM(item, trans, head) {
1037 switch(item->leafid) {
1038 case LC_DESCRIPTOR:
1039 fdp = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_FD);
1040 break;
1041 case LC_DATA:
1042 buf = HCC_BINARYDATA(item);
1043 n = item->bytes - sizeof(*item);
1044 break;
1045 }
1046 }
1047 if (ReadOnlyOpt) {
1048 head->error = EACCES;
1049 return (0);
1050 }
1051 if (fdp == NULL)
1052 return(-2);
1053 if (n < 0 || n > 32768)
1054 return(-2);
1055 n = write(*fdp, buf, n);
1056 if (n < 0)
1057 return (-1);
1058 hcc_leaf_int32(trans, LC_BYTES, n);
1059 return(0);
1060 }
1061
1062 /*
1063 * REMOVE
1064 *
1065 * NOTE: This function returns -errno if an error occured.
1066 */
1067 int
1068 hc_remove(struct HostConf *hc, const char *path)
1069 {
1070 hctransaction_t trans;
1071 struct HCHead *head;
1072 int res;
1073
1074 if (NotForRealOpt)
1075 return(0);
1076 if (hc == NULL || hc->host == NULL) {
1077 res = remove(path);
1078 if (res < 0)
1079 res = -errno;
1080 return(res);
1081 }
1082
1083 trans = hcc_start_command(hc, HC_REMOVE);
1084 hcc_leaf_string(trans, LC_PATH1, path);
1085 if ((head = hcc_finish_command(trans)) == NULL)
1086 return(-EIO);
1087 if (head->error)
1088 return(-(int)head->error);
1089 return(0);
1090 }
1091
1092 static int
1093 rc_remove(hctransaction_t trans, struct HCHead *head)
1094 {
1095 struct HCLeaf *item;
1096 const char *path = NULL;
1097
1098 FOR_EACH_ITEM(item, trans, head) {
1099 if (item->leafid == LC_PATH1)
1100 path = HCC_STRING(item);
1101 }
1102 if (path == NULL)
1103 return(-2);
1104 if (ReadOnlyOpt) {
1105 head->error = EACCES;
1106 return (0);
1107 }
1108 return(remove(path));
1109 }
1110
1111 /*
1112 * MKDIR
1113 */
1114 int
1115 hc_mkdir(struct HostConf *hc, const char *path, mode_t mode)
1116 {
1117 hctransaction_t trans;
1118 struct HCHead *head;
1119
1120 if (NotForRealOpt)
1121 return(0);
1122 if (hc == NULL || hc->host == NULL)
1123 return(mkdir(path, mode));
1124
1125 trans = hcc_start_command(hc, HC_MKDIR);
1126 hcc_leaf_string(trans, LC_PATH1, path);
1127 hcc_leaf_int32(trans, LC_MODE, mode);
1128 if ((head = hcc_finish_command(trans)) == NULL)
1129 return(-1);
1130 if (head->error)
1131 return(-1);
1132 return(0);
1133 }
1134
1135 static int
1136 rc_mkdir(hctransaction_t trans, struct HCHead *head)
1137 {
1138 struct HCLeaf *item;
1139 const char *path = NULL;
1140 mode_t mode = 0777;
1141
1142 FOR_EACH_ITEM(item, trans, head) {
1143 switch(item->leafid) {
1144 case LC_PATH1:
1145 path = HCC_STRING(item);
1146 break;
1147 case LC_MODE:
1148 mode = HCC_INT32(item);
1149 break;
1150 }
1151 }
1152 if (ReadOnlyOpt) {
1153 head->error = EACCES;
1154 return (0);
1155 }
1156 if (path == NULL)
1157 return(-2);
1158 return(mkdir(path, mode));
1159 }
1160
1161 /*
1162 * RMDIR
1163 */
1164 int
1165 hc_rmdir(struct HostConf *hc, const char *path)
1166 {
1167 hctransaction_t trans;
1168 struct HCHead *head;
1169
1170 if (NotForRealOpt)
1171 return(0);
1172 if (hc == NULL || hc->host == NULL)
1173 return(rmdir(path));
1174
1175 trans = hcc_start_command(hc, HC_RMDIR);
1176 hcc_leaf_string(trans, LC_PATH1, path);
1177 if ((head = hcc_finish_command(trans)) == NULL)
1178 return(-1);
1179 if (head->error)
1180 return(-1);
1181 return(0);
1182 }
1183
1184 static int
1185 rc_rmdir(hctransaction_t trans, struct HCHead *head)
1186 {
1187 struct HCLeaf *item;
1188 const char *path = NULL;
1189
1190 FOR_EACH_ITEM(item, trans, head) {
1191 if (item->leafid == LC_PATH1)
1192 path = HCC_STRING(item);
1193 }
1194 if (ReadOnlyOpt) {
1195 head->error = EACCES;
1196 return (0);
1197 }
1198 if (path == NULL)
1199 return(-2);
1200 return(rmdir(path));
1201 }
1202
1203 /*
1204 * CHOWN
1205 *
1206 * Almost silently ignore chowns that fail if we are not root.
1207 */
1208 int
1209 hc_chown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
1210 {
1211 hctransaction_t trans;
1212 struct HCHead *head;
1213 int rc;
1214
1215 if (NotForRealOpt)
1216 return(0);
1217 if (!DstRootPrivs)
1218 owner = -1;
1219
1220 if (hc == NULL || hc->host == NULL) {
1221 rc = chown(path, owner, group);
1222 if (rc < 0)
1223 rc = silentwarning(&chown_warning, "file ownership may differ\n");
1224 return(rc);
1225 }
1226
1227 trans = hcc_start_command(hc, HC_CHOWN);
1228 hcc_leaf_string(trans, LC_PATH1, path);
1229 hcc_leaf_int32(trans, LC_UID, owner);
1230 hcc_leaf_int32(trans, LC_GID, group);
1231 if ((head = hcc_finish_command(trans)) == NULL)
1232 return(-1);
1233 if (head->error)
1234 return(-1);
1235 return(0);
1236 }
1237
1238 static int
1239 rc_chown(hctransaction_t trans, struct HCHead *head)
1240 {
1241 struct HCLeaf *item;
1242 const char *path = NULL;
1243 uid_t uid = (uid_t)-1;
1244 gid_t gid = (gid_t)-1;
1245 int rc;
1246
1247 FOR_EACH_ITEM(item, trans, head) {
1248 switch(item->leafid) {
1249 case LC_PATH1:
1250 path = HCC_STRING(item);
1251 break;
1252 case LC_UID:
1253 uid = HCC_INT32(item);
1254 break;
1255 case LC_GID:
1256 gid = HCC_INT32(item);
1257 break;
1258 }
1259 }
1260 if (ReadOnlyOpt) {
1261 head->error = EACCES;
1262 return (0);
1263 }
1264 if (path == NULL)
1265 return(-2);
1266 rc = chown(path, uid, gid);
1267 if (rc < 0)
1268 rc = silentwarning(&chown_warning, "file ownership may differ\n");
1269 return(rc);
1270 }
1271
1272 /*
1273 * LCHOWN
1274 */
1275 int
1276 hc_lchown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
1277 {
1278 hctransaction_t trans;
1279 struct HCHead *head;
1280 int rc;
1281
1282 if (NotForRealOpt)
1283 return(0);
1284 if (!DstRootPrivs)
1285 owner = -1;
1286
1287 if (hc == NULL || hc->host == NULL) {
1288 rc = lchown(path, owner, group);
1289 if (rc < 0)
1290 rc = silentwarning(&chown_warning, "file ownership may differ\n");
1291 return(rc);
1292 }
1293
1294 trans = hcc_start_command(hc, HC_LCHOWN);
1295 hcc_leaf_string(trans, LC_PATH1, path);
1296 hcc_leaf_int32(trans, LC_UID, owner);
1297 hcc_leaf_int32(trans, LC_GID, group);
1298 if ((head = hcc_finish_command(trans)) == NULL)
1299 return(-1);
1300 if (head->error)
1301 return(-1);
1302 return(0);
1303 }
1304
1305 static int
1306 rc_lchown(hctransaction_t trans, struct HCHead *head)
1307 {
1308 struct HCLeaf *item;
1309 const char *path = NULL;
1310 uid_t uid = (uid_t)-1;
1311 gid_t gid = (gid_t)-1;
1312 int rc;
1313
1314 FOR_EACH_ITEM(item, trans, head) {
1315 switch(item->leafid) {
1316 case LC_PATH1:
1317 path = HCC_STRING(item);
1318 break;
1319 case LC_UID:
1320 uid = HCC_INT32(item);
1321 break;
1322 case LC_GID:
1323 gid = HCC_INT32(item);
1324 break;
1325 }
1326 }
1327 if (ReadOnlyOpt) {
1328 head->error = EACCES;
1329 return (0);
1330 }
1331 if (path == NULL)
1332 return(-2);
1333 rc = lchown(path, uid, gid);
1334 if (rc < 0)
1335 rc = silentwarning(&chown_warning, "file ownership may differ\n");
1336 return(rc);
1337 }
1338
1339 /*
1340 * CHMOD
1341 */
1342 int
1343 hc_chmod(struct HostConf *hc, const char *path, mode_t mode)
1344 {
1345 hctransaction_t trans;
1346 struct HCHead *head;
1347
1348 if (NotForRealOpt)
1349 return(0);
1350 if (hc == NULL || hc->host == NULL)
1351 return(chmod(path, mode));
1352
1353 trans = hcc_start_command(hc, HC_CHMOD);
1354 hcc_leaf_string(trans, LC_PATH1, path);
1355 hcc_leaf_int32(trans, LC_MODE, mode);
1356 if ((head = hcc_finish_command(trans)) == NULL)
1357 return(-1);
1358 if (head->error)
1359 return(-1);
1360 return(0);
1361 }
1362
1363 static int
1364 rc_chmod(hctransaction_t trans, struct HCHead *head)
1365 {
1366 struct HCLeaf *item;
1367 const char *path = NULL;
1368 mode_t mode = 0666;
1369
1370 FOR_EACH_ITEM(item, trans, head) {
1371 switch(item->leafid) {
1372 case LC_PATH1:
1373 path = HCC_STRING(item);
1374 break;
1375 case LC_MODE:
1376 mode = HCC_INT32(item);
1377 break;
1378 }
1379 }
1380 if (ReadOnlyOpt) {
1381 head->error = EACCES;
1382 return (0);
1383 }
1384 if (path == NULL)
1385 return(-2);
1386 return(chmod(path, mode));
1387 }
1388
1389 /*
1390 * MKNOD
1391 */
1392 int
1393 hc_mknod(struct HostConf *hc, const char *path, mode_t mode, dev_t rdev)
1394 {
1395 hctransaction_t trans;
1396 struct HCHead *head;
1397
1398 if (NotForRealOpt)
1399 return(0);
1400 if (!DstRootPrivs) {
1401 /* mknod() requires root privs, so don't bother. */
1402 errno = EPERM;
1403 return (-1);
1404 }
1405
1406 if (hc == NULL || hc->host == NULL)
1407 return(mknod(path, mode, rdev));
1408
1409 trans = hcc_start_command(hc, HC_MKNOD);
1410 hcc_leaf_string(trans, LC_PATH1, path);
1411 hcc_leaf_int32(trans, LC_MODE, mode);
1412 hcc_leaf_int32(trans, LC_RDEV, rdev);
1413 if ((head = hcc_finish_command(trans)) == NULL)
1414 return(-1);
1415 if (head->error)
1416 return(-1);
1417 return(0);
1418 }
1419
1420 static int
1421 rc_mknod(hctransaction_t trans, struct HCHead *head)
1422 {
1423 struct HCLeaf *item;
1424 const char *path = NULL;
1425 mode_t mode = 0666;
1426 dev_t rdev = 0;
1427
1428 FOR_EACH_ITEM(item, trans, head) {
1429 switch(item->leafid) {
1430 case LC_PATH1:
1431 path = HCC_STRING(item);
1432 break;
1433 case LC_MODE:
1434 mode = HCC_INT32(item);
1435 break;
1436 case LC_RDEV:
1437 rdev = HCC_INT32(item);
1438 break;
1439 }
1440 }
1441 if (ReadOnlyOpt) {
1442 head->error = EACCES;
1443 return (0);
1444 }
1445 if (path == NULL)
1446 return(-2);
1447 return(mknod(path, mode, rdev));
1448 }
1449
1450 /*
1451 * LINK
1452 */
1453 int
1454 hc_link(struct HostConf *hc, const char *name1, const char *name2)
1455 {
1456 hctransaction_t trans;
1457 struct HCHead *head;
1458
1459 if (NotForRealOpt)
1460 return(0);
1461 if (hc == NULL || hc->host == NULL)
1462 return(link(name1, name2));
1463
1464 trans = hcc_start_command(hc, HC_LINK);
1465 hcc_leaf_string(trans, LC_PATH1, name1);
1466 hcc_leaf_string(trans, LC_PATH2, name2);
1467 if ((head = hcc_finish_command(trans)) == NULL)
1468 return(-1);
1469 if (head->error)
1470 return(-1);
1471 return(0);
1472 }
1473
1474 static int
1475 rc_link(hctransaction_t trans, struct HCHead *head)
1476 {
1477 struct HCLeaf *item;
1478 const char *name1 = NULL;
1479 const char *name2 = NULL;
1480
1481 FOR_EACH_ITEM(item, trans, head) {
1482 switch(item->leafid) {
1483 case LC_PATH1:
1484 name1 = HCC_STRING(item);
1485 break;
1486 case LC_PATH2:
1487 name2 = HCC_STRING(item);
1488 break;
1489 }
1490 }
1491 if (ReadOnlyOpt) {
1492 head->error = EACCES;
1493 return (-0);
1494 }
1495 if (name1 == NULL || name2 == NULL)
1496 return(-2);
1497 return(link(name1, name2));
1498 }
1499
1500 #ifdef _ST_FLAGS_PRESENT_
1501 /*
1502 * CHFLAGS
1503 */
1504 int
1505 hc_chflags(struct HostConf *hc, const char *path, u_long flags)
1506 {
1507 hctransaction_t trans;
1508 struct HCHead *head;
1509 int rc;
1510
1511 if (NotForRealOpt)
1512 return(0);
1513 if (!DstRootPrivs)
1514 flags &= UF_SETTABLE;
1515
1516 if (hc == NULL || hc->host == NULL) {
1517 if ((rc = chflags(path, flags)) < 0)
1518 rc = silentwarning(&chflags_warning, "file flags may differ\n");
1519 return (rc);
1520 }
1521
1522 trans = hcc_start_command(hc, HC_CHFLAGS);
1523 hcc_leaf_string(trans, LC_PATH1, path);
1524 hcc_leaf_int64(trans, LC_FILEFLAGS, flags);
1525 if ((head = hcc_finish_command(trans)) == NULL)
1526 return(-1);
1527 if (head->error)
1528 return(-1);
1529 return(0);
1530 }
1531
1532 static int
1533 rc_chflags(hctransaction_t trans, struct HCHead *head)
1534 {
1535 struct HCLeaf *item;
1536 const char *path = NULL;
1537 u_long flags = 0;
1538 int rc;
1539
1540 FOR_EACH_ITEM(item, trans, head) {
1541 switch(item->leafid) {
1542 case LC_PATH1:
1543 path = HCC_STRING(item);
1544 break;
1545 case LC_FILEFLAGS:
1546 flags = (u_long)HCC_INT64(item);
1547 break;
1548 }
1549 }
1550 if (ReadOnlyOpt) {
1551 head->error = EACCES;
1552 return (0);
1553 }
1554 if (path == NULL)
1555 return(-2);
1556 if ((rc = chflags(path, flags)) < 0)
1557 rc = silentwarning(&chflags_warning, "file flags may differ\n");
1558 return(rc);
1559 }
1560
1561 #endif
1562
1563 /*
1564 * READLINK
1565 */
1566 int
1567 hc_readlink(struct HostConf *hc, const char *path, char *buf, int bufsiz)
1568 {
1569 hctransaction_t trans;
1570 struct HCHead *head;
1571 struct HCLeaf *item;
1572 int r;
1573
1574 if (hc == NULL || hc->host == NULL)
1575 return(readlink(path, buf, bufsiz));
1576
1577 trans = hcc_start_command(hc, HC_READLINK);
1578 hcc_leaf_string(trans, LC_PATH1, path);
1579 if ((head = hcc_finish_command(trans)) == NULL)
1580 return(-1);
1581 if (head->error)
1582 return(-1);
1583
1584 r = 0;
1585 FOR_EACH_ITEM(item, trans, head) {
1586 if (item->leafid == LC_DATA) {
1587 r = item->bytes - sizeof(*item);
1588 if (r < 0)
1589 r = 0;
1590 if (r > bufsiz)
1591 r = bufsiz;
1592 bcopy(HCC_BINARYDATA(item), buf, r);
1593 }
1594 }
1595 return(r);
1596 }
1597
1598 static int
1599 rc_readlink(hctransaction_t trans, struct HCHead *head)
1600 {
1601 struct HCLeaf *item;
1602 const char *path = NULL;
1603 char buf[1024];
1604 int r;
1605
1606 FOR_EACH_ITEM(item, trans, head) {
1607 if (item->leafid == LC_PATH1)
1608 path = HCC_STRING(item);
1609 }
1610 if (path == NULL)
1611 return(-2);
1612 r = readlink(path, buf, sizeof(buf));
1613 if (r < 0)
1614 return(-1);
1615 hcc_leaf_data(trans, LC_DATA, buf, r);
1616 return(0);
1617 }
1618
1619 /*
1620 * UMASK
1621 */
1622 mode_t
1623 hc_umask(struct HostConf *hc, mode_t numask)
1624 {
1625 hctransaction_t trans;
1626 struct HCHead *head;
1627 struct HCLeaf *item;
1628
1629 if (NotForRealOpt)
1630 return(umask(numask));
1631 if (hc == NULL || hc->host == NULL)
1632 return(umask(numask));
1633
1634 trans = hcc_start_command(hc, HC_UMASK);
1635 hcc_leaf_int32(trans, LC_MODE, numask);
1636 if ((head = hcc_finish_command(trans)) == NULL)
1637 return((mode_t)-1);
1638 if (head->error)
1639 return((mode_t)-1);
1640
1641 numask = (mode_t) ~0666U;
1642 FOR_EACH_ITEM(item, trans, head) {
1643 if (item->leafid == LC_MODE)
1644 numask = HCC_INT32(item);
1645 }
1646 return(numask);
1647 }
1648
1649 static int
1650 rc_umask(hctransaction_t trans, struct HCHead *head)
1651 {
1652 struct HCLeaf *item;
1653 mode_t numask = (mode_t) ~0666U;
1654
1655 FOR_EACH_ITEM(item, trans, head) {
1656 if (item->leafid == LC_MODE)
1657 numask = HCC_INT32(item);
1658 }
1659 numask = umask(numask);
1660 hcc_leaf_int32(trans, LC_MODE, numask);
1661 return(0);
1662 }
1663
1664 /*
1665 * SYMLINK
1666 */
1667 int
1668 hc_symlink(struct HostConf *hc, const char *name1, const char *name2)
1669 {
1670 hctransaction_t trans;
1671 struct HCHead *head;
1672
1673 if (NotForRealOpt)
1674 return(0);
1675 if (hc == NULL || hc->host == NULL)
1676 return(symlink(name1, name2));
1677
1678 trans = hcc_start_command(hc, HC_SYMLINK);
1679 hcc_leaf_string(trans, LC_PATH1, name1);
1680 hcc_leaf_string(trans, LC_PATH2, name2);
1681 if ((head = hcc_finish_command(trans)) == NULL)
1682 return(-1);
1683 if (head->error)
1684 return(-1);
1685 return(0);
1686 }
1687
1688 static int
1689 rc_symlink(hctransaction_t trans, struct HCHead *head)
1690 {
1691 struct HCLeaf *item;
1692 const char *name1 = NULL;
1693 const char *name2 = NULL;
1694
1695 FOR_EACH_ITEM(item, trans, head) {
1696 switch(item->leafid) {
1697 case LC_PATH1:
1698 name1 = HCC_STRING(item);
1699 break;
1700 case LC_PATH2:
1701 name2 = HCC_STRING(item);
1702 break;
1703 }
1704 }
1705 if (ReadOnlyOpt) {
1706 head->error = EACCES;
1707 return (0);
1708 }
1709 if (name1 == NULL || name2 == NULL)
1710 return(-2);
1711 return(symlink(name1, name2));
1712 }
1713
1714 /*
1715 * RENAME
1716 */
1717 int
1718 hc_rename(struct HostConf *hc, const char *name1, const char *name2)
1719 {
1720 hctransaction_t trans;
1721 struct HCHead *head;
1722
1723 if (NotForRealOpt)
1724 return(0);
1725 if (hc == NULL || hc->host == NULL)
1726 return(rename(name1, name2));
1727
1728 trans = hcc_start_command(hc, HC_RENAME);
1729 hcc_leaf_string(trans, LC_PATH1, name1);
1730 hcc_leaf_string(trans, LC_PATH2, name2);
1731 if ((head = hcc_finish_command(trans)) == NULL)
1732 return(-1);
1733 if (head->error)
1734 return(-1);
1735 return(0);
1736 }
1737
1738 static int
1739 rc_rename(hctransaction_t trans, struct HCHead *head)
1740 {
1741 struct HCLeaf *item;
1742 const char *name1 = NULL;
1743 const char *name2 = NULL;
1744
1745 FOR_EACH_ITEM(item, trans, head) {
1746 switch(item->leafid) {
1747 case LC_PATH1:
1748 name1 = HCC_STRING(item);
1749 break;
1750 case LC_PATH2:
1751 name2 = HCC_STRING(item);
1752 break;
1753 }
1754 }
1755 if (ReadOnlyOpt) {
1756 head->error = EACCES;
1757 return (0);
1758 }
1759 if (name1 == NULL || name2 == NULL)
1760 return(-2);
1761 return(rename(name1, name2));
1762 }
1763
1764 /*
1765 * UTIMES
1766 */
1767 int
1768 hc_utimes(struct HostConf *hc, const char *path, const struct timeval *times)
1769 {
1770 hctransaction_t trans;
1771 struct HCHead *head;
1772
1773 if (NotForRealOpt)
1774 return(0);
1775 if (hc == NULL || hc->host == NULL)
1776 return(utimes(path, times));
1777
1778 trans = hcc_start_command(hc, HC_UTIMES);
1779 hcc_leaf_string(trans, LC_PATH1, path);
1780 hcc_leaf_int64(trans, LC_ATIME, times[0].tv_sec);
1781 hcc_leaf_int64(trans, LC_MTIME, times[1].tv_sec);
1782 if ((head = hcc_finish_command(trans)) == NULL)
1783 return(-1);
1784 if (head->error)
1785 return(-1);
1786 return(0);
1787 }
1788
1789 static int
1790 rc_utimes(hctransaction_t trans, struct HCHead *head)
1791 {
1792 struct HCLeaf *item;
1793 struct timeval times[2];
1794 const char *path;
1795
1796 bzero(times, sizeof(times));
1797 path = NULL;
1798
1799 FOR_EACH_ITEM(item, trans, head) {
1800 switch(item->leafid) {
1801 case LC_PATH1:
1802 path = HCC_STRING(item);
1803 break;
1804 case LC_ATIME:
1805 times[0].tv_sec = HCC_INT64(item);
1806 break;
1807 case LC_MTIME:
1808 times[1].tv_sec = HCC_INT64(item);
1809 break;
1810 }
1811 }
1812 if (ReadOnlyOpt) {
1813 head->error = EACCES;
1814 return (0);
1815 }
1816 if (path == NULL)
1817 return(-2);
1818 return(utimes(path, times));
1819 }
1820
1821 uid_t
1822 hc_geteuid(struct HostConf *hc)
1823 {
1824 hctransaction_t trans;
1825 struct HCHead *head;
1826 struct HCLeaf *item;
1827
1828 if (hc == NULL || hc->host == NULL)
1829 return (geteuid());
1830
1831 if (hc->version < 3) {
1832 fprintf(stderr, "WARNING: Remote client uses old protocol version\n");
1833 /* Return 0 on error, so the caller assumes root privileges. */
1834 return (0);
1835 }
1836
1837 trans = hcc_start_command(hc, HC_GETEUID);
1838 if ((head = hcc_finish_command(trans)) == NULL || head->error)
1839 return(0);
1840 FOR_EACH_ITEM(item, trans, head) {
1841 if (item->leafid == LC_UID)
1842 return (HCC_INT32(item));
1843 }
1844 return(0); /* shouldn't happen */
1845 }
1846
1847 static int
1848 rc_geteuid(hctransaction_t trans, struct HCHead *head __unused)
1849 {
1850 hcc_leaf_int32(trans, LC_UID, geteuid());
1851 return (0);
1852 }
1853
1854 static int
1855 getmygroups(gid_t **gidlist)
1856 {
1857 int count;
1858
1859 if ((count = getgroups(0, *gidlist)) > 0) {
1860 if ((*gidlist = malloc(count * sizeof(gid_t))) != NULL) {
1861 if ((count = getgroups(count, *gidlist)) <= 0)
1862 free(*gidlist);
1863 }
1864 else
1865 count = -1;
1866 }
1867 else
1868 *gidlist = NULL;
1869 return (count);
1870 }
1871
1872 int
1873 hc_getgroups(struct HostConf *hc, gid_t **gidlist)
1874 {
1875 int count, i;
1876 hctransaction_t trans;
1877 struct HCHead *head;
1878 struct HCLeaf *item;
1879
1880 if (hc == NULL || hc->host == NULL)
1881 return (getmygroups(gidlist));
1882
1883 i = 0;
1884 count = 0;
1885 *gidlist = NULL;
1886
1887 if (hc->version < 3) {
1888 fprintf(stderr, "WARNING: Remote client uses old protocol version\n");
1889 return (-1);
1890 }
1891
1892 trans = hcc_start_command(hc, HC_GETGROUPS);
1893 if ((head = hcc_finish_command(trans)) == NULL || head->error)
1894 return(-1);
1895 FOR_EACH_ITEM(item, trans, head) {
1896 switch(item->leafid) {
1897 case LC_COUNT:
1898 count = HCC_INT32(item);
1899 if (*gidlist != NULL) { /* protocol error */
1900 free(*gidlist);
1901 *gidlist = NULL;
1902 return (-1);
1903 }
1904 if ((*gidlist = malloc(count * sizeof(gid_t))) == NULL)
1905 return (-1);
1906 break;
1907 case LC_GID:
1908 if (*gidlist == NULL || i >= count) { /* protocol error */
1909 if (*gidlist != NULL)
1910 free(*gidlist);
1911 *gidlist = NULL;
1912 return (-1);
1913 }
1914 (*gidlist)[i++] = HCC_INT32(item);
1915 break;
1916 }
1917 }
1918 return (count);
1919 }
1920
1921 static int
1922 rc_getgroups(hctransaction_t trans, struct HCHead *head __unused)
1923 {
1924 int count, i;
1925 gid_t *gidlist;
1926
1927 if ((count = getmygroups(&gidlist)) < 0)
1928 return (-1);
1929 hcc_leaf_int32(trans, LC_COUNT, count);
1930 for (i = 0; i < count; i++)
1931 hcc_leaf_int32(trans, LC_GID, gidlist[i]);
1932 if (gidlist != NULL)
1933 free(gidlist);
1934 return (0);
1935 }
DragonFly BSD