af2e18f383733f14ba6e75a2b99a3904f696bab5
[openafs.git] / src / venus / up.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 /* missing type from C language */
17
18 #include <errno.h>
19 #ifdef  AFS_AIX32_ENV
20 #include <signal.h>
21 #undef  _NONSTD_TYPES
22 #endif
23 #include <stdio.h>
24 #include <afs/afs_args.h>
25 #include <sys/param.h>
26 #ifdef  AFS_SUN5_ENV
27 #include <fcntl.h>
28 #endif
29 #include <sys/file.h>
30 #include <sys/stat.h>
31 #include <dirent.h>
32 #include <sys/time.h>
33 #define VIRTUE
34 #define VICE
35 #include <sys/ioctl.h>
36 #include <afs/vice.h>
37 #undef VIRTUE
38 #undef VICE
39 #include <sys/ioctl.h>
40 #include <netdb.h>
41 #ifdef HAVE_NETINET_IN_H
42 #include <netinet/in.h>
43 #endif
44
45 #ifdef HAVE_STRING_H
46 #include <string.h>
47 #else
48 #ifdef HAVE_STRINGS_H
49 #include <strings.h>
50 #endif
51 #endif
52
53 #include <afs/venus.h>
54
55 /* ************************************************************* */
56
57 #define MAXACL 400
58
59 short verbose = 0;
60 short renameTargets = 0;
61 short oneLevel = 0;
62 short preserveDate = 1;
63 short preserveMountPoints = 0;
64 short forceOverwrite = 0;
65
66 int pageSize;
67 short setacl = 1;
68 short oldAcl = 0;
69 char file1[MAXPATHLEN], file2[MAXPATHLEN];
70
71 #define MAXSIZE 2048
72 static char space[MAXSIZE];
73
74 struct OldAcl {
75     int nplus;
76     int nminus;
77     int offset;
78     char data[1];
79 };
80
81 static void ScanArgs(int argc, char *argv[]);
82 static short MakeParent(char *file, afs_int32 owner);
83 static int Copy(char *file1, char *file2, short recursive, int level);
84 static int isMountPoint(char *name, struct ViceIoctl *blob);
85
86
87 /* ************************************************************ */
88 /*                                                               */
89 /* main program                                                  */
90 /*                                                               */
91 /* ************************************************************ */
92
93 #include "AFS_component_version_number.c"
94
95 int
96 main(int argc, char *argv[])
97 {
98 #ifdef  AFS_AIX32_ENV
99     /*
100      * The following signal action for AIX is necessary so that in case of a 
101      * crash (i.e. core is generated) we can include the user's data section 
102      * in the core dump. Unfortunately, by default, only a partial core is
103      * generated which, in many cases, isn't too useful.
104      */
105     struct sigaction nsa;
106
107     sigemptyset(&nsa.sa_mask);
108     nsa.sa_handler = SIG_DFL;
109     nsa.sa_flags = SA_FULLDUMP;
110     sigaction(SIGSEGV, &nsa, NULL);
111 #endif
112 #if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV)
113     pageSize = getpagesize();
114 #endif
115     ScanArgs(argc, argv);
116
117     /* now read each line of the CopyList */
118     if (Copy(file1, file2, !oneLevel, 0))
119         return(1);              /* some type of failure */
120
121     return(0);
122 }
123
124
125 #define USAGE "usage: up [-v1frxm] from to\n"
126 static void
127 ScanArgs(int argc, char *argv[])
128 {
129     /* skip program name */
130     argc--, argv++;
131
132     /* check for -flag options */
133     while (argc > 0 && *argv[0] == '-') {
134         char *cp = *argv;
135
136         switch (*++cp) {
137         case 'v':
138             verbose = 1;
139             break;
140
141         case '1':
142             oneLevel = 1;
143             break;
144
145         case 'r':
146             renameTargets = 1;
147             break;
148
149         case 'f':
150             forceOverwrite = 1;
151             break;
152
153         case 'x':
154             preserveDate = 0;
155             break;
156
157         case 'm':
158             preserveMountPoints = 1;
159             break;
160
161         default:
162             fprintf(stderr, "Unknown option: '%c'\n", *cp);
163             fprintf(stderr, USAGE);
164             exit(1);
165         }
166         argc--, argv++;
167     }
168
169     if (argc != 2) {
170         fprintf(stderr, USAGE);
171         exit(1);
172     }
173
174     strncpy(file1, argv[0], MAXPATHLEN);
175     strncpy(file2, argv[1], MAXPATHLEN);
176
177 }                               /*ScanArgs */
178
179
180
181 /*
182  * MakeParent
183  *      Make sure the parent directory of this file exists.  Returns
184  *      1 if it exists, 0 otherwise.  Note: the owner argument
185  *      is a hack.  All directories made will have this owner.
186  */
187 static short
188 MakeParent(char *file, afs_int32 owner)
189 {
190     char parent[MAXPATHLEN];
191     char *p;
192     struct stat s;
193
194     strlcpy(parent, file, sizeof parent);
195
196     p = strrchr(parent, '/');
197     if (!p) {
198         strlcpy(parent, ".", sizeof parent);
199     } else if (p > parent) {
200         *p = '\0';
201     } else {
202         p[1] = '\0';
203     }
204
205     if (stat(parent, &s) < 0) {
206         if (!MakeParent(parent, owner))
207             return (0);
208
209         if (verbose) {
210             printf("Creating directory %s\n", parent);
211             fflush(stdout);
212         }
213
214         mkdir(parent, 0777);
215         chown(parent, owner, -1);
216     }
217     return (1);
218 }                               /*MakeParent */
219
220
221 /*
222  * Copy
223  *      This does the bulk of the work of the program.  Handle one file,
224  *      possibly copying subfiles if this is a directory
225  */
226 static int
227 Copy(char *file1, char *file2, short recursive, int level)
228 {
229     struct stat s1, s2;         /*Stat blocks */
230     struct ViceIoctl blob;
231     char aclspace[MAXACL];
232     afs_int32 rcode = 0, code;
233     int goods2 = 1;
234
235     code = lstat(file1, &s1);
236     if (code < 0) {
237         fprintf(stderr, "Can't find %s\n", file1);
238         return 1;
239     }
240
241     code = lstat(file2, &s2);
242     if (code < 0) {
243         if (!MakeParent(file2, s1.st_uid))
244             return 0;
245         goods2 = 0;
246     }
247
248     if ((s1.st_mode & S_IFMT) == S_IFREG) {
249         /*
250          * -------------------- Copy regular file --------------------
251          */
252         int f1, f2, n;
253         char buf[4096];         /* Must be bigger than sizeof (*head) */
254         struct timeval tv[2];
255         char tmpfile[MAXPATHLEN], newName[MAXPATHLEN];
256
257         if (verbose) {
258             printf("Level %d: File %s to %s\n", level, file1, file2);
259             fflush(stdout);
260         }
261
262         /* Wonder if there is a security hole */
263         if (((s1.st_mode & 04002) == 04002) || ((s1.st_mode & 04020) == 04020)
264             || ((s1.st_mode & 02002) == 02002)) {
265             fprintf(stderr,
266                     "WARNING: Mode-bits security hole in files %s and %s\n",
267                     file1, file2);
268         }
269
270         if (!goods2 || (s1.st_mtime != s2.st_mtime) || (s1.st_size != s2.st_size)) {    /*c */
271             /* Don't ovewrite a write protected file (unless force: -f) */
272             if (!forceOverwrite && goods2 && (s2.st_mode & 0200) == 0) {
273                 fprintf(stderr,
274                         "File %s is write protected against its owner; not changed\n",
275                         file2);
276                 return 1;
277             }
278
279             if (verbose) {
280                 printf("  Copy file %s to %s (%u Bytes)\n", file1, file2,
281                        s1.st_size);
282                 fflush(stdout);
283             }
284
285             strlcpy(tmpfile, file2, sizeof tmpfile);    /* Name of temporary file */
286             strlcat(tmpfile, ".UPD", sizeof tmpfile);
287
288             /* open file1 for input */
289             f1 = open(file1, O_RDONLY);
290             if (f1 < 0) {
291                 fprintf(stderr, "Unable to open input file %s: %s\n",
292                         file1, strerror(errno));
293                 return 1;
294             }
295
296             /* open temporary output file */
297             f2 = open(tmpfile, (O_WRONLY | O_CREAT | O_TRUNC), s1.st_mode);
298             if (f2 < 0) {
299                 fprintf(stderr, "Unable to open output file %s: %s\n",
300                         tmpfile, strerror(errno));
301                 fflush(stdout);
302                 close(f1);
303                 return 1;
304             }
305
306             /* Copy file1 to temporary file */
307             while ((n = read(f1, buf, sizeof(buf))) > 0) {
308                 if (write(f2, buf, n) != n) {
309                     fprintf(stderr,
310                             "Write failed, file %s must be copied again.\n",
311                             file2);
312                 }
313             }
314
315             /* preserve access and modification times: ("-x" disables) */
316             if (preserveDate) {
317                 tv[0].tv_sec = s1.st_atime;
318                 tv[0].tv_usec = 0;
319                 tv[1].tv_sec = s1.st_mtime;
320                 tv[1].tv_usec = 0;
321                 utimes(tmpfile, tv);
322             }
323
324             /* Close the files */
325             code = close(f1);
326             code = close(f2);
327             if (code < 0) {
328                 perror("close ");
329                 rcode = 1;
330             }
331
332             /* Rename file2 to file2.old. [-r] */
333             if (renameTargets && goods2) {
334                 strlcpy(newName, file2, sizeof newName);
335                 strlcat(newName, ".old", sizeof newName);
336                 if (verbose) {
337                     printf("  Renaming %s to %s\n", file2, newName);
338                     fflush(stdout);
339                 }
340                 if (rename(file2, newName) < 0) {
341                     fprintf(stderr, "Rename of %s to %s failed.\n", file2,
342                             newName);
343                 }
344             }
345
346             /* Rename temporary file to file2 */
347             code = rename(tmpfile, file2);
348             if (code < 0) {
349                 fprintf(stderr, "Rename of %s to %s failed.\n", tmpfile,
350                         file2);
351                 return 1;
352             }
353
354             /* Re-stat file2 and compare file sizes */
355             code = lstat(file2, &s2);
356             if (code < 0) {
357                 fprintf(stderr, "WARNING: Unable to stat new file %s\n",
358                         file2);
359                 return 1;
360             }
361             if (s1.st_size != s2.st_size) {
362                 fprintf(stderr,
363                         "WARNING: New file %s is %u bytes long; should be %u\n",
364                         file2, s2.st_size, s1.st_size);
365             }
366         }
367
368         /*c */
369         /* Set the user-id */
370         if (s2.st_uid != s1.st_uid) {
371             if (verbose) {
372                 printf("  Set owner-id for %s to %d\n", file2, s1.st_uid);
373                 fflush(stdout);
374             }
375             code = chown(file2, s1.st_uid, -1);
376             if (code) {
377                 fprintf(stderr, "Unable to set owner-id for %s to %d\n",
378                         file2, s1.st_uid);
379                 fflush(stdout);
380                 rcode = 1;
381                 s1.st_mode &= ~04000;   /* Don't set suid bit */
382             }
383         }
384
385         /* Set the group-id */
386         if (s2.st_gid != s1.st_gid) {
387             if (verbose) {
388                 printf("  Set group-id for %s to %d\n", file2, s1.st_gid);
389                 fflush(stdout);
390             }
391             code = chown(file2, -1, s1.st_gid);
392             if (code) {
393                 fprintf(stderr, "Unable to set group-id for %s to %d\n",
394                         file2, s1.st_gid);
395                 fflush(stdout);
396                 rcode = 1;
397                 s1.st_mode &= ~02000;   /* Don't set sgid bit */
398             }
399         }
400
401         /* Set the mode bits */
402         if (s1.st_mode != s2.st_mode) {
403             if (verbose) {
404                 printf("  Set mode-bit for %s to %o\n", file2,
405                        (s1.st_mode & 07777));
406                 fflush(stdout);
407             }
408             code = chmod(file2, s1.st_mode);
409             if (code) {
410                 fprintf(stderr, "Unable to set mode-bits for %s to %d\n",
411                         file2, s1.st_mode);
412                 rcode = 1;
413             }
414         }
415     }
416     /* regular file */
417     else if ((s1.st_mode & S_IFMT) == S_IFLNK) {
418         /*
419          * --------------------- Copy symlink  --------------------
420          */
421         char linkvalue[MAXPATHLEN + 1];
422         int n;
423
424         if (verbose) {
425             printf("Level %d: Symbolic link %s to %s\n", level, file1, file2);
426             fflush(stdout);
427         }
428
429         /* Don't ovewrite a write protected directory (unless force: -f) */
430         if (!forceOverwrite && goods2 && (s2.st_mode & 0200) == 0) {
431             fprintf(stderr,
432                     "Link %s is write protected against its owner; not changed\n",
433                     file2);
434             return 1;
435         }
436
437         if (verbose) {
438             printf("  Copy symbolic link %s->%s to %s\n", file1, linkvalue,
439                    file2);
440             fflush(stdout);
441         }
442
443         n = readlink(file1, linkvalue, sizeof(linkvalue));
444         if (n == -1) {
445             fprintf(stderr, "Could not read symbolic link %s\n", file1);
446             perror("read link ");
447             return 1;
448         }
449         linkvalue[n] = 0;
450
451         unlink(file2);          /* Always make the new link (it was easier) */
452
453         code = symlink(linkvalue, file2);
454         if (code == -1) {
455             fprintf(stderr, "Could not create symbolic link %s\n", file2);
456             perror("create link ");
457             return 1;
458         }
459     }
460     /*Dealing with symlink */
461     else if (preserveMountPoints && (code = isMountPoint(file1, &blob))) {
462         /*
463          * --------------------- Copy mount point  --------------------
464          */
465
466         if (code > 1) {
467             perror("checking for mount point ");
468             return 1;
469         }
470         if (verbose) {
471             printf("Level %d: Mount point %s to %s\n", level, file1, file2);
472             fflush(stdout);
473         }
474
475         /* Don't ovewrite a write protected directory (unless force: -f) */
476         if (!forceOverwrite && goods2 && (s2.st_mode & 0200) == 0) {
477             fprintf(stderr,
478                     "Target %s is write protected against its owner; not changed\n",
479                     file2);
480             return 1;
481         }
482
483         if (verbose) {
484             printf("  Copy mount point %s for vol %s to %s\n", file1,
485                    blob.out, file2);
486             fflush(stdout);
487         }
488
489         unlink(file2);          /* Always make the new link (it was easier) */
490
491         strcat(blob.out, ".");  /* stupid convention; these end with a period */
492         code = symlink(blob.out, file2);
493         if (code == -1) {
494             fprintf(stderr, "Could not create mount point %s for vol %s\n",
495                     file2, blob.out);
496             perror("create mount point ");
497             return 1;
498         }
499
500     }
501     /*Dealing with mount point */
502     else if (((s1.st_mode & S_IFMT) == S_IFDIR)
503              && (recursive || (level == 0))) {
504         /*
505          * ----------------------- Copy directory -----------------------
506          */
507         DIR *dir;
508         int tfd, code, i;
509         struct OldAcl *oacl;
510         char tacl[MAXACL];
511         char f1[MAXPATHLEN], f2[MAXPATHLEN];
512         char *p1, *p2;
513         struct dirent *d;
514
515         if (verbose) {
516             printf("Level %d: Directory %s to %s\n", level, file1, file2);
517             fflush(stdout);
518         }
519
520         /* Don't ovewrite a write protected directory (unless force: -f) */
521         if (!forceOverwrite && goods2 && (s2.st_mode & 0200) == 0) {
522             fprintf(stderr,
523                     "Directory %s is write protected against its owner; not changed\n",
524                     file2);
525             return 1;
526         }
527
528         strlcpy(f1, file1, sizeof f1);
529         strlcpy(f2, file2, sizeof f2);
530         p1 = f1 + strlen(f1);
531         p2 = f2 + strlen(f2);
532         if (p1 == f1 || p1[-1] != '/')
533             *p1++ = '/';
534         if (p2 == f2 || p2[-1] != '/')
535             *p2++ = '/';
536
537         dir = opendir(file1);
538         if (dir == NULL) {
539             fprintf(stderr, "Couldn't open %s\n", file1);
540             return 1;
541         }
542
543         while ((d = readdir(dir)) != NULL) {
544             if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0)
545                 continue;
546             strlcpy(p1, d->d_name, sizeof f1 - (p1 - f1));
547             strlcpy(p2, d->d_name, sizeof f2 - (p2 - f2));
548             code = Copy(f1, f2, recursive, level + 1);
549             if (code && !rcode)
550                 rcode = 1;      /* remember errors */
551         }
552
553         closedir(dir);
554
555         if (verbose) {
556             printf("Level %d: Copied directory %s to %s\n", level, file1,
557                    file2);
558             fflush(stdout);
559         }
560
561         mkdir(file2, 0777);     /* Handle case where MakeParent not invoked. */
562
563         if (verbose) {
564             printf("  Set owner-id for %s to %d\n", file2, s1.st_uid);
565             fflush(stdout);
566         }
567         code = chown(file2, s1.st_uid, -1);
568         if (code) {
569             fprintf(stderr, "Unable to set owner-id for %s to %d\n", file2,
570                     s1.st_uid);
571             fflush(stdout);
572             s1.st_mode &= ~04000;       /* Don't set suid bit */
573         }
574
575         if (verbose) {
576             printf("  Set group-id for %s to %d\n", file2, s1.st_gid);
577             fflush(stdout);
578         }
579         code = chown(file2, -1, s1.st_gid);
580         if (code) {
581             fprintf(stderr, "Unable to set group-id for %s to %d\n", file2,
582                     s1.st_gid);
583             fflush(stdout);
584             s1.st_mode &= ~02000;       /* Don't set sgid bit */
585         }
586
587         if (verbose) {
588             printf("  Set mode-bit for %s to %o\n", file2,
589                    (s1.st_mode & 07777));
590             fflush(stdout);
591         }
592         code = chmod(file2, s1.st_mode);
593         if (code) {
594             fprintf(stderr, "Unable to set mode-bits for %s to %d\n", file2,
595                     s1.st_mode);
596             fflush(stdout);
597             rcode = 1;
598         }
599
600         if (setacl == 1) {
601             if (verbose) {
602                 printf("  Set acls for %s\n", file2);
603                 fflush(stdout);
604             }
605
606             blob.in = aclspace;
607             blob.out = aclspace;
608             blob.in_size = 0;
609             blob.out_size = MAXACL;
610
611             if (oldAcl) {
612                 /* Get an old-style ACL and convert it */
613                 if (verbose) {
614                     printf("  Getting old style acl\n");
615                     fflush(stdout);
616                 }
617
618                 for (i = 1; i < strlen(file1); i++)
619                     if (file1[i] == '/')
620                         break;
621                 strlcpy(aclspace, &file1[i], sizeof aclspace);
622
623                 blob.in_size = 1 + strlen(aclspace);
624                 tfd = open(file1, O_RDONLY, 0);
625                 if (tfd < 0) {
626                     perror("old-acl open ");
627                     return 1;
628                 }
629                 code = ioctl(tfd, _VICEIOCTL(4), &blob);
630                 close(tfd);
631                 if (code < 0) {
632                     if (errno == EINVAL) {
633                         setacl = 0;
634                         if (verbose) {
635                             printf("  _VICEIOCTL(4) returns EINVAL\n");
636                             fflush(stdout);
637                         }
638                     } else {
639                         return 1;
640                     }
641                 }
642                 /* Now convert the thing. */
643                 oacl = (struct OldAcl *)(aclspace + 4);
644                 sprintf(tacl, "%d\n%d\n", oacl->nplus, oacl->nminus);
645                 strlcat(tacl, oacl->data, sizeof tacl);
646                 strlcpy(aclspace, tacl, sizeof aclspace);
647             } /*Grab and convert old-style ACL */
648             else {
649                 /* Get a new-style ACL */
650                 if (verbose) {
651                     printf("  Getting new style acl\n");
652                     fflush(stdout);
653                 }
654
655                 code = pioctl(file1, _VICEIOCTL(2), &blob, 1);
656                 if (code < 0) {
657                     if (errno == EINVAL) {
658                         setacl = 0;
659                         if (verbose) {
660                             printf("  _VICEIOCTL(2) returns EINVAL\n");
661                             fflush(stdout);
662                         }
663                     } else {
664                         perror("getacl ");
665                         return 1;
666                     }
667                 }
668             }                   /*Grab new-style ACL */
669
670             /*
671              * Now, set the new-style ACL.
672              */
673             if (setacl == 1) {
674                 if (verbose) {
675                     printf("  Setting new style acl\n");
676                     fflush(stdout);
677                 }
678                 blob.out = aclspace;
679                 blob.in = aclspace;
680                 blob.out_size = 0;
681                 blob.in_size = 1 + strlen(aclspace);
682                 code = pioctl(file2, _VICEIOCTL(1), &blob, 1);
683                 if (code) {
684                     if (errno == EINVAL) {
685                         setacl = 0;
686                         if (verbose) {
687                             printf("  _VICEIOCTL(1) returns EINVAL\n");
688                             fflush(stdout);
689                         }
690                     } else {
691                         fprintf(stderr, "Couldn't set acls for %s\n", file2);
692                         return 1;
693                     }
694                 }
695             }
696
697             if (setacl == 0) {
698                 printf("Not setting acls\n");
699             }
700         }
701     }
702
703     return rcode;
704 }                               /*Copy */
705
706
707 static int
708 isMountPoint(char *name, struct ViceIoctl *blob)
709 {
710     afs_int32 code;
711     char true_name[1024];       /*dirname */
712     char parent_dir[1024];      /*Parent directory of true name */
713     char *last_component;       /*Last component of true name */
714
715     sprintf(true_name, "%s%s", (name[0] == '/') ? "" : "./", name);
716
717     /*
718      * Find rightmost slash, if any.
719      */
720     last_component = (char *)strrchr(true_name, '/');
721     if (last_component) {
722         /*
723          * Found it.  Designate everything before it as the parent directory,
724          * everything after it as the final component.
725          */
726         strncpy(parent_dir, true_name, last_component - true_name);
727         parent_dir[last_component - true_name] = 0;
728         last_component++;       /*Skip the slash */
729     } else {
730         /*
731          * No slash appears in the given file name.  Set parent_dir to the current
732          * directory, and the last component as the given name.
733          */
734         strlcpy(parent_dir, ".", sizeof parent_dir);
735         last_component = true_name;
736     }
737
738     if (strcmp(last_component, ".") == 0 || strcmp(last_component, "..") == 0) {
739         fprintf(stderr,
740                 "up: you may not use '.' or '..' as the last component\n");
741         fprintf(stderr, "up: of a name in the 'up' command.\n");
742         return 3;
743     }
744
745     blob->in = last_component;
746     blob->in_size = strlen(last_component) + 1;
747     blob->out_size = MAXSIZE;
748     blob->out = space;
749     memset(space, 0, MAXSIZE);
750
751     code = pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, blob, 0);
752
753     if (code == 0) {
754         printf("'%s' is a mount point for volume '%s'\n", name, space);
755         fflush(stdout);
756         return 1;
757     } else {
758         if (errno == EINVAL) {
759             /* printf( "'%s' is not a mount point.\n", name);
760              * fflush(stdout);
761              */
762             return 0;
763         } else {
764             fprintf(stderr, "problem examining '%s' in '%s'.\n",
765                     last_component, parent_dir);
766             return 2;
767             /* Die(errno, (ti->data ? ti->data : parent_dir));
768              */
769         }
770     }
771     return 4;
772 }