linux-largefile-defns-20030724
[openafs.git] / src / pinstall / install.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 /*
11                       All Rights Reserved
12
13 Permission to use, copy, modify, and distribute this software and its 
14 documentation for any purpose and without fee is hereby granted, 
15 provided that the above copyright notice appear in all copies and that
16 both that copyright notice and this permission notice appear in 
17 supporting documentation, and that the name of IBM not be
18 used in advertising or publicity pertaining to distribution of the
19 software without specific, written prior permission.  
20
21 IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
22 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
23 IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
24 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
25 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
26 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
27 SOFTWARE.
28 ******************************************************************/
29 /* $ACIS: $ */
30
31 /* ALSO utimes and strip the file
32
33 Generic install command.  Options are:
34         -s              strip the file  (default for executable files with no extension)
35         -ns             do not strip the file   (default for other files)
36         -c              ignored for compatability
37         -m <mode>       chmod to this value
38         -o <user>       chown to this user
39         -g <group>      chgrp to this group
40         -f              target path is a file
41         -q              be very, very quick and quiet
42         -l <envcwd>     attempt symbolic link back from destination to source
43                         with the current directory in the specified environment
44                         variable
45 */
46
47 #define MAXFILES 200
48 #define BUFSIZE 32768
49 #include <afsconfig.h>
50 #include <afs/param.h>
51
52 RCSID
53     ("$Header$");
54
55 #include <stdio.h>
56 #include <pwd.h>
57 #include <grp.h>
58 #include <errno.h>
59 #ifdef  AFS_AIX32_ENV
60 #include <signal.h>
61 #endif
62 #include <sys/types.h>
63 #include <sys/stat.h>
64 #include <sys/file.h>
65 #include <sys/time.h>
66 #ifdef  AFS_SUN5_ENV
67 #include <fcntl.h>
68 #include <string.h>
69 #include <elf.h>
70 #else
71 #ifdef AFS_DARWIN_ENV
72 #include <fcntl.h>
73 #include <string.h>
74 #else
75 #include <strings.h>
76 #include <a.out.h>
77 #endif
78 #endif
79 #ifdef  AFS_HPUX_ENV
80 #include <utime.h>
81 #endif
82 #include <unistd.h>
83 #include <string.h>
84 #include <sys/wait.h>
85 #include <stdlib.h>
86 #ifdef HAVE_PWD_H
87 #include <pwd.h>
88 #endif
89 #include <stdio.h>
90
91 static struct stat istat, ostat;
92 static int stripcalled = 0;
93
94 #if !defined(AFS_DARWIN60_ENV) && !defined(AFS_FBSD50_ENV)
95 extern int sys_nerr;
96 #endif
97 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
98 extern char *sys_errlist[];
99 #endif
100
101 /* static prototypes */
102 char *ErrorString(int aerrno);
103 int stripName(char *aname);
104 int atoo(register char *astr);
105
106
107 #if defined(AFS_HPUX_ENV) && !defined(AFS_HPUX102_ENV)
108 int
109 utimes(char *file, struct timeval tvp[2])
110 {
111     struct utimbuf times;
112
113     times.actime = tvp[0].tv_sec;
114     times.modtime = tvp[1].tv_sec;
115     return (utime(file, &times));
116 }
117 #endif
118
119 static char *
120 strrpbrk(char *s, char *set)
121 {
122     char sets[256];
123     int i;
124
125     memset(sets, 0, sizeof(sets));
126     while (*set)
127         sets[(int)*set++] = 1;
128     i = strlen(s);
129     while (i > 0)
130         if (sets[(int)s[--i]])
131             return &s[i];
132     return 0;
133 }
134
135 char *
136 ErrorString(int aerrno)
137 {
138     static char tbuffer[100];
139     if (aerrno < 0 || aerrno >= sys_nerr) {
140         sprintf(tbuffer, "undefined error code %d", aerrno);
141     } else {
142         strcpy(tbuffer, sys_errlist[aerrno]);
143     }
144     return tbuffer;
145 }
146
147 int
148 stripName(char *aname)
149 {
150     if (strrchr(aname, '.') == 0)
151         return 1;
152     else
153         return 0;
154 }
155
156 int
157 atoo(register char *astr)
158 {
159     register afs_int32 value;
160     register char tc;
161     value = 0;
162     while ((tc = *astr++)) {
163         value <<= 3;
164         value += tc - '0';
165     }
166     return value;
167 }
168
169 #if     defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DECOSF_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_OBSD_ENV) || defined(AFS_NBSD_ENV)
170 /*
171  * Implementation lifted from that for AIX 3.1, since there didn't seem to be any
172  * reason why it wouldn't work.
173  */
174 static int
175 quickStrip(char *iname, char *oname, int ignored, int copy_only)
176 {
177     int pid;
178     pid_t status;
179     static char *strip[] = {
180         "strip", 0, 0,
181     };
182     static char *copy[] = {
183         "cp", 0, 0, 0,
184     };
185
186     /*
187      * first, copy the `iname' to the `oname'
188      */
189     switch (pid = fork()) {
190     case -1:                    /* error        */
191         perror("fork");
192         return -1;
193
194     case 0:                     /* child        */
195         copy[1] = iname;
196         copy[2] = oname;
197         execve("/bin/cp", copy, NULL);
198         perror("/bin/cp");
199         exit(1);
200
201     default:                    /* parent       */
202         if (waitpid(pid, &status, 0) != pid && errno != ECHILD) {
203             perror("waitpid");
204             return -1;
205         }
206     }
207
208     if (status != 0) {
209         fprintf(stderr, "Bad exit code from /bin/cp: %d\n", status);
210         return -1;
211     }
212
213     /*
214      * need to do a chmod to guarantee that the perms will permit
215      * the strip.  Perms are fixed up later.
216      */
217     if (chmod(oname, 0700)) {
218         perror("chmod");
219         return -1;
220     }
221 #if !defined(AFS_OBSD_ENV) && !defined(AFS_NBSD_ENV)
222     /*
223      * done the copy, now strip if desired.
224      */
225     if (copy_only)
226         return 0;
227
228     switch (pid = fork()) {
229     case -1:                    /* error        */
230         perror("fork");
231         return -1;
232
233     case 0:                     /* child        */
234         strip[1] = oname;
235 #ifdef  AFS_SUN5_ENV
236 #define STRIP_BIN       "/usr/ccs/bin/strip"
237 #elif defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
238 #define STRIP_BIN       "/usr/bin/strip"
239 #else
240 #define STRIP_BIN       "/bin/strip"
241 #endif
242         execve(STRIP_BIN, strip, NULL);
243         perror(STRIP_BIN);
244         exit(1);
245
246     default:                    /* parent       */
247         if (waitpid(pid, &status, 0) != pid && errno != ECHILD) {
248             perror("waitpid");
249             return -1;
250         }
251     }
252 #endif
253
254     return status;
255 }
256
257 #else
258 #ifdef AFS_AIX_ENV
259 #ifdef AFS_AIX32_ENV
260 /*
261  * whoa! back up and be a little more rational (every little bit helps in
262  * aix_31).
263  */
264 static int
265 quickStrip(char *iname, char *oname, int ignored, int copy_only)
266 {
267     int pid, status;
268     static char *strip[] = {
269         "strip", 0, 0,
270     };
271     static char *copy[] = {
272         "cp", 0, 0, 0,
273     };
274
275     /*
276      * first, copy the `iname' to the `oname'
277      */
278     switch (pid = fork()) {
279     case -1:                    /* error        */
280         perror("fork");
281         return -1;
282
283     case 0:                     /* child        */
284         copy[1] = iname;
285         copy[2] = oname;
286         execve("/bin/cp", copy, 0);
287         perror("/bin/cp");
288         exit(1);
289
290     default:                    /* parent       */
291         if (waitpid(pid, &status, 0) != pid && errno != ECHILD) {
292             perror("waitpid");
293             return -1;
294         }
295     }
296
297     if (status != 0) {
298         fprintf(stderr, "Bad exit code from /bin/cp: %d\n", status);
299         return -1;
300     }
301
302     /*
303      * need to do a chmod to guarantee that the perms will permit
304      * the strip.  Perms are fixed up later.
305      */
306     if (chmod(oname, 0700)) {
307         perror("chmod");
308         return -1;
309     }
310
311     /*
312      * done the copy, now strip if desired.
313      */
314     if (copy_only)
315         return 0;
316
317     switch (pid = fork()) {
318     case -1:                    /* error        */
319         perror("fork");
320         return -1;
321
322     case 0:                     /* child        */
323         strip[1] = oname;
324         execve("/bin/strip", strip, 0);
325         perror("/bin/strip");
326         exit(1);
327
328     default:                    /* parent       */
329         if (waitpid(pid, &status, 0) != pid && errno != ECHILD) {
330             perror("waitpid");
331             return -1;
332         }
333     }
334
335     return status;
336 }
337
338 #endif /* AFS_AIX32_ENV        */
339 #else /* !AFS_AIX_ENV         */
340
341 #ifdef  mips
342 #include "sex.h"
343 int
344 quickStrip(int fd, afs_int32 asize)
345 {
346     FILHDR fheader;
347     int dum, newlen;
348     int mysex, swapheader;
349
350     /* Read the file header, if it is one. */
351     if (lseek(fd, 0, L_SET) == -1) {
352         printf("Initial lseek failed while stripping file: %s\n",
353                ErrorString(errno));
354         return -1;
355     }
356     dum = read(fd, (char *)&fheader, sizeof(fheader));
357     /* Fail on I/O error */
358     if (dum < 0) {
359         printf("Initial read failed while stripping: %s\n",
360                ErrorString(errno));
361         return -1;
362     }
363     /* If the file is smaller than a file header, forget it. */
364     if (dum != sizeof(fheader))
365         return 0;
366 #ifdef AFS_DECOSF_ENV
367     mysex = LITTLEENDIAN;
368 #else
369     mysex = gethostsex();
370     if (mysex != BIGENDIAN && mysex != LITTLEENDIAN)
371         return 0;
372 #endif /* DEC OSF */
373     swapheader = 0;
374     if (fheader.f_magic == MIPSELMAGIC) {
375         if (mysex == BIGENDIAN)
376             swapheader = 1;
377     } else if (fheader.f_magic == MIPSEBMAGIC) {
378         if (mysex == LITTLEENDIAN)
379             swapheader = 1;
380     } else
381         return 0;               /* not executable */
382 #ifdef AFS_DECOSF_ENV
383     if (swapheader)
384         return 0;
385 #else
386     if (swapheader)
387         swap_filehdr(&fheader, gethostsex());
388 #endif /* DEC OSF */
389     /* Already stripped? */
390     if (fheader.f_symptr == 0 || fheader.f_nsyms == 0)
391         return 0;
392     /* Strip it.  Zero out the symbol pointers. */
393     newlen = fheader.f_symptr;
394     fheader.f_symptr = 0;
395     fheader.f_nsyms = 0;
396 #ifndef AFS_DECOSF_ENV
397     if (swapheader)
398         swap_filehdr(&fheader, gethostsex());
399 #endif /* DEC OSF */
400     if (lseek(fd, 0, L_SET) == -1)
401         return -1;
402     if (write(fd, (char *)&fheader, sizeof(fheader)) != sizeof(fheader))
403         return -1;
404 /* Now truncate the file itself. */
405     if (ftruncate(fd, newlen) != 0)
406         return -1;
407     return 0;
408 }
409 #else /* !mips */
410 static int
411 quickStrip(int afd, afs_int32 asize)
412 {
413     int n, bytesLeft;
414     struct exec buf;
415     struct exec *head;
416     n = lseek(afd, 0, 0);
417     if (n < 0) {
418         printf("Initial lseek failed while stripping file: %s\n",
419                ErrorString(errno));
420         return -1;
421     }
422     n = read(afd, &buf, sizeof(buf));
423     if (n < 0) {
424         printf("Initial read failed while stripping: %s\n",
425                ErrorString(errno));
426         return -1;
427     }
428     head = &buf;
429     if (n >= sizeof(*head) && !N_BADMAG(*head)) {       /* This code lifted from strip.c. */
430         bytesLeft = (afs_int32) head->a_text + head->a_data;
431         head->a_syms = head->a_trsize = head->a_drsize = 0;
432         if (head->a_magic == ZMAGIC)
433             bytesLeft += N_TXTOFF(*head) - sizeof(*head);
434         /* also include size of header */
435         bytesLeft += sizeof(*head);
436         n = lseek(afd, 0, 0);
437         if (n < 0) {
438             printf("lseek failed while stripping file: %s\n",
439                    ErrorString(errno));
440             return -1;
441         }
442         n = write(afd, &buf, sizeof(buf));
443         if (n < 0) {
444             printf("write failed while stripping file: %s\n",
445                    ErrorString(errno));
446             return -1;
447         }
448     } else
449         bytesLeft = 0;
450
451     /* check if size of stripped file is same as existing file */
452     if (bytesLeft != 0 && bytesLeft != asize) {
453         if (ftruncate(afd, bytesLeft) < 0) {
454             printf("ftruncate failed after stripping file: %s\n",
455                    ErrorString(errno));
456             return -1;
457         }
458     }
459     return 0;
460 }
461 #endif /* mips */
462 #endif
463 #endif /* AFS_HPUX_ENV */
464
465 #include "AFS_component_version_number.c"
466
467 int
468 main(int argc, char *argv[])
469 {
470     int setOwner, setMode, setGroup, ifd, ofd;
471     afs_int32 mode = 0, owner, group;
472     struct passwd *tpw;
473     struct group *tgp;
474     char *fnames[MAXFILES], *newNames[MAXFILES];
475     afs_int32 rcode, code;
476     char *dname;
477     char pname[1024];
478 #if defined (AFS_HPUX_ENV)
479     char pnameBusy[1024];
480 #endif /* AFS_HPUX_ENV */
481     char pnametmp[1024];
482     int pnamelen;
483     afs_int32 newcode;
484     static char diskBuffer[BUFSIZE];    /* must be static to avoid compiler bugs for large stuff */
485     char myHostName[100];
486     struct timeval tvp[2];
487     int isDir;
488     int strip;
489     int fptr;
490     register char *tp;
491     register afs_int32 i;
492
493 #ifdef  AFS_AIX32_ENV
494     /*
495      * The following signal action for AIX is necessary so that in case of a 
496      * crash (i.e. core is generated) we can include the user's data section 
497      * in the core dump. Unfortunately, by default, only a partial core is
498      * generated which, in many cases, isn't too useful.
499      */
500     struct sigaction nsa;
501
502     sigemptyset(&nsa.sa_mask);
503     nsa.sa_handler = SIG_DFL;
504     nsa.sa_flags = SA_FULLDUMP;
505     sigaction(SIGSEGV, &nsa, NULL);
506 #endif
507     fptr = 0;
508     rcode = 0;
509     strip = -1;                 /* don't know yet */
510     owner = 0;
511     setOwner = 0;
512     setMode = 0;
513     group = 0;
514     setGroup = 0;
515     isDir = -1;                 /* don't know yet */
516
517     for (i = 1; i < argc; i++) {
518         tp = argv[i];
519         if (tp[0] == '-') {     /* a switch */
520             if (!strcmp(tp, "-m"))
521                 mode = atoo(argv[++i]), setMode = 1;
522             else if (!strcmp(tp, "-s"))
523                 strip = 1;
524             else if (!strcmp(tp, "-ns"))
525                 strip = 0;
526             else if (!strcmp(tp, "-c")) /* nothing */
527                 ;
528             else if (!strcmp(tp, "-f"))
529                 isDir = 0;      /* => dest is file */
530             else if (!strcmp(tp, "-o")) {       /* look up the dude */
531                 tpw = getpwnam(argv[++i]);
532                 if (!tpw) {
533                     printf("User %s not found in passwd database, ignored\n",
534                            argv[i]);
535                 } else {
536                     owner = tpw->pw_uid;
537                     setOwner = 1;
538                 }
539             } else if (!strcmp(tp, "-g")) {     /* look up the dude */
540                 tgp = getgrnam(argv[++i]);
541                 if (!tgp) {
542                     printf("Group %s not found in passwd database; ignored\n",
543                            argv[i]);
544                 } else {
545                     group = tgp->gr_gid;
546                     setGroup = 1;
547                 }
548             } else {
549                 printf("Bad switch %s\n", argv[i]);
550                 exit(1);
551             }
552         } else {                /* a file name */
553             if (fptr >= MAXFILES) {
554                 printf("Too many files on command line, max is %d\n",
555                        MAXFILES);
556                 exit(1);
557             }
558             fnames[fptr++] = argv[i];
559         }
560     }
561
562     /* we've parse the commands, now *do* them */
563
564     /* otherwise we are doing a local install, so we do the work for each file
565      * here the last name in the fname array is the dir in which to put all
566      * this stuff */
567
568     if (fptr < 2) {
569         printf("Not enough file names\n");
570         exit(1);
571     }
572
573     /* N file usage requires last argument to be a directory.  If -f was
574      * specified it is an error.  In the 2 file usage when -f is not specified
575      * use a heuristic.  If the ends of the two pathnames are equal then assume
576      * the target is a file, otherwise assume it is a directory. */
577
578     if ((fptr > 2) && (isDir == 0)) {
579         printf
580             ("target must be a directory, don't use multiple source files with -f switch\n");
581         exit(1);
582     } else if (fptr > 2)
583         isDir = 1;
584     else if (isDir != 0) {
585         char *targetSuffix;
586         char *sourceSuffix;
587
588         targetSuffix = strrpbrk(fnames[1], "./");
589         sourceSuffix = strrpbrk(fnames[0], "./");
590         if (sourceSuffix == 0) {
591             sourceSuffix = fnames[0];
592             if (targetSuffix == 0)
593                 targetSuffix = fnames[1];
594             else
595                 targetSuffix++;
596         } else if (targetSuffix == 0)
597             targetSuffix = fnames[1];
598         if (strcmp(targetSuffix, sourceSuffix) == 0)
599             isDir = 0;
600     }
601
602     dname = fnames[--fptr];
603     if (stat(dname, &istat) < 0) {
604         if ((errno == ENOENT) || (errno == ENOTDIR)) {
605             /* create path */
606             char protopath[BUFSIZ];
607             int i = 0;
608             char c;
609             while (dname[i]) {
610                 do {
611                     protopath[i] = dname[i];
612                     c = dname[++i];     /* next char */
613                 } while (!((c == 0) || (c == '/')));
614                 protopath[i] = 0;
615
616                 /* don't mkdir last component if target is a file */
617                 if ((c == 0) && (isDir == 0))
618                     break;
619
620                 /* else create dir component if it doesn't exist */
621                 code = stat(protopath, &istat);
622                 if (code && (errno == ENOENT)) {
623                     code = mkdir(protopath, 0755);
624                     if (code) {
625                         printf("Can't create destination path at %s\n",
626                                protopath);
627                         exit(1);
628                     }
629                 }
630             }                   /* while dname not exhausted */
631             if (isDir == -1)
632                 isDir = 1;
633         } else {
634             printf("Can't stat destination ``%s'': %s\n", dname,
635                    ErrorString(errno));
636             exit(1);
637         }
638     } else {
639         if ((istat.st_mode & S_IFMT) == S_IFDIR)
640             isDir = 1;
641         else
642             isDir = 0;
643     }
644
645     /* either can be n files and one dir, or one file and one target */
646     if (!isDir && fptr != 1) {
647         printf("target for multiple files must be a dir\n");
648         exit(1);
649     }
650
651     for (i = 0; i < fptr; i++) {        /* figure out name to put as entry name for file */
652         tp = strrchr(fnames[i], '/');
653         if (tp)
654             newNames[i] = tp + 1;
655         else
656             newNames[i] = fnames[i];
657     }
658     for (i = 0; i < fptr; i++) {        /* copy newName[i] into directory dname */
659
660         /* pname is target file in either case */
661         if (isDir) {
662             strcpy(pname, dname);
663             strcat(pname, "/");
664             strcat(pname, newNames[i]);
665         } else
666             strcpy(pname, dname);
667         strcpy(pnametmp, pname);
668         /* Make up a temporary name for a destination */
669         pnamelen = strlen(pnametmp);
670         gethostname(myHostName, sizeof(myHostName) - 1);        /* lv room for null */
671         if (pnamelen > 1020 - strlen(myHostName))
672             pnamelen = 1020 - strlen(myHostName);
673         pnametmp[pnamelen] = '.';
674         strcpy(&pnametmp[pnamelen + 1], myHostName);
675         if (strcmp(fnames[i], pnametmp) == 0)
676             strcpy(&pnametmp[pnamelen], ".NeW");
677
678         ifd = open(fnames[i], O_RDONLY, 0);
679         if (ifd < 0) {
680             printf("Can't open source file ``%s'': %s\n", fnames[i],
681                    ErrorString(errno));
682             rcode = 1;
683             continue;
684         }
685         if (fstat(ifd, &istat) < 0) {
686             printf("Cound not fstat input file ``%s'': %s; skipping it\n",
687                    fnames[i], ErrorString(errno));
688             close(ifd);
689             rcode = 1;
690             continue;
691         }
692         if (lstat(pname, &ostat) == 0) {
693             if ((ostat.st_size == istat.st_size)
694                 && (ostat.st_mtime == istat.st_mtime) && ((!setMode)
695                                                           ||
696                                                           ((ostat.
697                                                             st_mode & S_IFMT)
698                                                            == mode))
699                 && ((!setOwner) || (ostat.st_uid == owner)) && ((!setGroup)
700                                                                 || (ostat.
701                                                                     st_gid ==
702                                                                     group))) {
703                 close(ifd);
704                 printf("No changes to %s since %s installed\n", fnames[i],
705                        pname);
706                 continue;
707             }
708         }
709 #if     defined(AFS_AIX_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_DECOSF_ENV) || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_OBSD_ENV) || defined(AFS_NBSD_ENV)
710         stripcalled = 0;
711         if (strip == 1 || ((strip == -1 && ((istat.st_mode & 0111) == 0111)
712                             && stripName(newNames[i]))))
713             stripcalled = 1;
714         if (!stripcalled) {
715             /* Simply copy target to dest */
716             quickStrip(fnames[i], pnametmp, istat.st_size, 1);
717         } else {
718             if (quickStrip(fnames[i], pnametmp, istat.st_size, 0) < 0) {
719                 printf
720                     ("...strip failed for output temp file ``%s''; skipping it\n",
721                      pnametmp);
722                 close(ifd);
723                 unlink(pnametmp);
724                 rcode = 1;
725                 continue;
726             }
727         }
728         close(ifd);
729
730         ofd = open(pnametmp, O_RDWR, 0);
731         if (ofd < 0) {
732             printf("Could not open output temp file ``%s'': %s\n", pnametmp,
733                    ErrorString(errno));
734             close(ifd);
735             rcode = 1;
736             continue;
737         }
738         if (!setMode)
739             mode = istat.st_mode;       /* Was 0755:> this is the default for our rcs to work */
740 #else /* AFS_AIX_ENV */
741         /* check to see if this file is hard to duplicate */
742         ofd = open(pnametmp, O_RDWR | O_TRUNC | O_CREAT, 0666);
743         if (ofd < 0) {
744             printf("Could not create output temp file ``%s'': %s\n", pnametmp,
745                    ErrorString(errno));
746             close(ifd);
747             rcode = 1;
748             continue;
749         }
750         if (!setMode)
751             mode = istat.st_mode;       /* Was 0755:> this is the default for our rcs to work */
752         /* here both files are open and ready to go */
753         while (1) {
754             code = read(ifd, diskBuffer, BUFSIZE);
755             if (code == 0)
756                 break;
757             if (code < 0) {
758                 printf("READ ERROR %d: %s\n", errno, ErrorString(errno));
759                 break;
760             }
761             errno = 0;
762             newcode = write(ofd, diskBuffer, code);
763             if (newcode != code) {
764                 printf("WRITE ERROR %d: %s\n", errno, ErrorString(errno));
765                 break;
766             }
767         }
768         if (code != 0) {
769             rcode = 1;          /* an error occurred copying the file */
770             printf
771                 ("Warning: Error occurred writing output temp file %s; skipping it\n",
772                  pnametmp);
773             close(ifd);
774             unlink(pnametmp);
775             close(ofd);
776             continue;           /* to the next file */
777         }
778         /* strip the file? */
779         if (strip == 1 || (strip == -1 && ((istat.st_mode & 0111) == 0111)
780                            && stripName(newNames[i])))
781             if (quickStrip(ofd, istat.st_size) < 0) {
782                 printf
783                     ("...strip failed for output temp file ``%s''; skipping it\n",
784                      pnametmp);
785                 close(ifd);
786                 unlink(pnametmp);
787                 rcode = 1;
788                 continue;
789             }
790
791         /* do the chmod, etc calls before closing the file for max parallelism on store behind */
792         close(ifd);
793
794 #endif /* AFS_AIX_ENV */
795         if (fchmod(ofd, mode) < 0) {
796             printf("Couldn't chmod output temp file ``%s'': %s\n", pnametmp,
797                    ErrorString(errno));
798             unlink(pnametmp);
799             close(ofd);
800             rcode = 1;
801             continue;
802         }
803
804         tvp[0].tv_sec = istat.st_atime;
805         tvp[0].tv_usec = 0;
806         tvp[1].tv_sec = istat.st_mtime;
807         tvp[1].tv_usec = 0;
808         if (utimes(pnametmp, tvp) < 0) {
809             printf("Couldn't utimes output temp file ``%s'': %s\n", pnametmp,
810                    ErrorString(errno));
811             unlink(pnametmp);
812             close(ofd);
813             rcode = 1;
814             continue;
815         }
816         code = close(ofd);
817         if (code != 0) {
818             printf("Warning: Could not close output temp file %s (%s)\n",
819                    pnametmp, ErrorString(errno));
820             unlink(pnametmp);
821             rcode = 1;          /* an error occurred closing the output file */
822             continue;           /* to the next file */
823         }
824
825         /* do this later so vice doesn't see chown of unstored file */
826         if (setOwner || setGroup)
827             if (chown
828                 (pnametmp, (setOwner ? owner : -1),
829                  (setGroup ? group : -1)) < 0) {
830                 printf("Couldn't set %s for output temp file %s: %s\n",
831                        (setOwner ? (setGroup ? "owner and group" : "owner") :
832                         "group"), pnametmp, ErrorString(errno));
833                 unlink(pnametmp);
834                 rcode = 1;
835                 continue;
836             }
837
838         if (rename(pnametmp, pname) < 0) {
839 #if defined(AFS_HPUX_ENV)
840             if (errno == ETXTBSY) {
841                 (void)strcpy(pnameBusy, pname);
842                 (void)strcat(pnameBusy, ".BUSY");
843                 if (rename(pname, pnameBusy) == 0) {
844                     fprintf(stdout, "Had to leave old file: %s.\n",
845                             pnameBusy);
846                     fprintf(stdout,
847                             "Please delete this file when the program using it is finished.\n");
848                     if (rename(pnametmp, pname) < 0) {
849 #endif /* AFS_HPUX_ENV */
850
851                         printf
852                             ("Couldn't rename temp file %s to be output file %s: %s\n",
853                              pnametmp, pname, ErrorString(errno));
854                         unlink(pnametmp);
855                         rcode = 1;
856                         continue;
857
858 #if defined(AFS_HPUX_ENV)
859                     }
860                 } else {
861                     fprintf(stderr,
862                             "Couldn't move busy target file %s to make room for new version %s: %s\n",
863                             pname, pnametmp, ErrorString(errno));
864                     if (errno == ETXTBSY) {
865                         fprintf(stderr,
866                                 "Try terminating any programs using the file %s and then re-run %s.\n",
867                                 pnameBusy, argv[0]);
868                     }
869                     unlink(pnametmp);
870                     rcode = 1;
871                     continue;
872                 }
873             }
874 #endif /* AFS_HPUX_ENV */
875         }
876     }
877     /* all done now */
878     exit(rcode);
879 }