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