diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/miscellany/patch-2.0.12u8/util.c

   1 #include "EXTERN.h"
   2 #include "common.h"
   3 #include "INTERN.h"
   4 #include "util.h"
   5 #include "backupfile.h"
   6
   7 void my_exit();
   8
   9 static char *
  10 private_strerror (errnum)
  11      int errnum;
  12 {
  13   extern char *sys_errlist[];
  14   extern int sys_nerr;
  15
  16   if (errnum > 0 && errnum <= sys_nerr)
  17     return sys_errlist[errnum];
  18   return "Unknown system error";
  19 }
  20 #define strerror private_strerror
  21
  22 /* Rename a file, copying it if necessary. */
  23
  24 int
  25 move_file(from,to)
  26 char *from, *to;
  27 {
  28     char bakname[512];
  29     Reg1 char *s;
  30     Reg2 int i;
  31     Reg3 int fromfd;
  32
  33     /* to stdout? */
  34
  35     if (strEQ(to, "-")) {
  36 #ifdef DEBUGGING
  37         if (debug & 4)
  38             say2("Moving %s to stdout.\n", from);
  39 #endif
  40         fromfd = open(from, 0);
  41         if (fromfd < 0)
  42             pfatal2("internal error, can't reopen %s", from);
  43         while ((i=read(fromfd, buf, sizeof buf)) > 0)
  44             if (write(1, buf, i) != 1)
  45                 pfatal1("write failed");
  46         Close(fromfd);
  47         return 0;
  48     }
  49
  50     if (origprae) {
  51         Strcpy(bakname, origprae);
  52         Strcat(bakname, to);
  53     } else {
  54 #ifndef NODIR
  55         char *backupname = find_backup_file_name(to);
  56         if (backupname == (char *) 0)
  57             fatal1("out of memory\n");
  58         Strcpy(bakname, backupname);
  59         free(backupname);
  60 #else /* NODIR */
  61         Strcpy(bakname, to);
  62         Strcat(bakname, simple_backup_suffix);
  63 #endif /* NODIR */
  64     }
  65
  66     if (stat(to, &filestat) == 0) {     /* output file exists */
  67         dev_t to_device = filestat.st_dev;
  68         ino_t to_inode  = filestat.st_ino;
  69         char *simplename = bakname;
  70
  71         for (s=bakname; *s; s++) {
  72             if (*s == '/')
  73                 simplename = s+1;
  74         }
  75         /* Find a backup name that is not the same file.
  76            Change the first lowercase char into uppercase;
  77            if that isn't sufficient, chop off the first char and try again.  */
  78         while (stat(bakname, &filestat) == 0 &&
  79                 to_device == filestat.st_dev && to_inode == filestat.st_ino) {
  80             /* Skip initial non-lowercase chars.  */
  81             for (s=simplename; *s && !islower(*s); s++) ;
  82             if (*s)
  83                 *s = toupper(*s);
  84             else
  85                 Strcpy(simplename, simplename+1);
  86         }
  87         while (unlink(bakname) >= 0) ;  /* while() is for benefit of Eunice */
  88 #ifdef DEBUGGING
  89         if (debug & 4)
  90             say3("Moving %s to %s.\n", to, bakname);
  91 #endif
  92         if (link(to, bakname) < 0) {
  93             /* Maybe `to' is a symlink into a different file system.
  94                Copying replaces the symlink with a file; using rename
  95                would be better.  */
  96             Reg4 int tofd;
  97             Reg5 int bakfd;
  98
  99             bakfd = creat(bakname, 0666);
 100             if (bakfd < 0) {
 101                 say4("Can't backup %s, output is in %s: %s\n", to, from,
 102                      strerror(errno));
 103                 return -1;
 104             }
 105             tofd = open(to, 0);
 106             if (tofd < 0)
 107                 pfatal2("internal error, can't open %s", to);
 108             while ((i=read(tofd, buf, sizeof buf)) > 0)
 109                 if (write(bakfd, buf, i) != i)
 110                     pfatal1("write failed");
 111             Close(tofd);
 112             Close(bakfd);
 113         }
 114         while (unlink(to) >= 0) ;
 115     }
 116 #ifdef DEBUGGING
 117     if (debug & 4)
 118         say3("Moving %s to %s.\n", from, to);
 119 #endif
 120     if (link(from, to) < 0) {           /* different file system? */
 121         Reg4 int tofd;
 122
 123         tofd = creat(to, 0666);
 124         if (tofd < 0) {
 125             say4("Can't create %s, output is in %s: %s\n",
 126               to, from, strerror(errno));
 127             return -1;
 128         }
 129         fromfd = open(from, 0);
 130         if (fromfd < 0)
 131             pfatal2("internal error, can't reopen %s", from);
 132         while ((i=read(fromfd, buf, sizeof buf)) > 0)
 133             if (write(tofd, buf, i) != i)
 134                 pfatal1("write failed");
 135         Close(fromfd);
 136         Close(tofd);
 137     }
 138     Unlink(from);
 139     return 0;
 140 }
 141
 142 /* Copy a file. */
 143
 144 void
 145 copy_file(from,to)
 146 char *from, *to;
 147 {
 148     Reg3 int tofd;
 149     Reg2 int fromfd;
 150     Reg1 int i;
 151
 152     tofd = creat(to, 0666);
 153     if (tofd < 0)
 154         pfatal2("can't create %s", to);
 155     fromfd = open(from, 0);
 156     if (fromfd < 0)
 157         pfatal2("internal error, can't reopen %s", from);
 158     while ((i=read(fromfd, buf, sizeof buf)) > 0)
 159         if (write(tofd, buf, i) != i)
 160             pfatal2("write to %s failed", to);
 161     Close(fromfd);
 162     Close(tofd);
 163 }
 164
 165 /* Allocate a unique area for a string. */
 166
 167 char *
 168 savestr(s)
 169 Reg1 char *s;
 170 {
 171     Reg3 char *rv;
 172     Reg2 char *t;
 173
 174     if (!s)
 175         s = "Oops";
 176     t = s;
 177     while (*t++);
 178     rv = malloc((MEM) (t - s));
 179     if (rv == Nullch) {
 180         if (using_plan_a)
 181             out_of_mem = TRUE;
 182         else
 183             fatal1("out of memory\n");
 184     }
 185     else {
 186         t = rv;
 187         while (*t++ = *s++);
 188     }
 189     return rv;
 190 }
 191
 192 #if defined(lint) && defined(CANVARARG)
 193
 194 /*VARARGS ARGSUSED*/
 195 say(pat) char *pat; { ; }
 196 /*VARARGS ARGSUSED*/
 197 fatal(pat) char *pat; { ; }
 198 /*VARARGS ARGSUSED*/
 199 pfatal(pat) char *pat; { ; }
 200 /*VARARGS ARGSUSED*/
 201 ask(pat) char *pat; { ; }
 202
 203 #else
 204
 205 /* Vanilla terminal output (buffered). */
 206
 207 void
 208 say(pat,arg1,arg2,arg3)
 209 char *pat;
 210 long arg1,arg2,arg3;
 211 {
 212     fprintf(stderr, pat, arg1, arg2, arg3);
 213     Fflush(stderr);
 214 }
 215
 216 /* Terminal output, pun intended. */
 217
 218 void                            /* very void */
 219 fatal(pat,arg1,arg2,arg3)
 220 char *pat;
 221 long arg1,arg2,arg3;
 222 {
 223     fprintf(stderr, "patch: **** ");
 224     fprintf(stderr, pat, arg1, arg2, arg3);
 225     my_exit(1);
 226 }
 227
 228 /* Say something from patch, something from the system, then silence . . . */
 229
 230 void                            /* very void */
 231 pfatal(pat,arg1,arg2,arg3)
 232 char *pat;
 233 long arg1,arg2,arg3;
 234 {
 235     int errnum = errno;
 236
 237     fprintf(stderr, "patch: **** ");
 238     fprintf(stderr, pat, arg1, arg2, arg3);
 239     fprintf(stderr, ": %s\n", strerror(errnum));
 240     my_exit(1);
 241 }
 242
 243 /* Get a response from the user, somehow or other. */
 244
 245 void
 246 ask(pat,arg1,arg2,arg3)
 247 char *pat;
 248 long arg1,arg2,arg3;
 249 {
 250     int ttyfd;
 251     int r;
 252     bool tty2 = isatty(2);
 253
 254     Sprintf(buf, pat, arg1, arg2, arg3);
 255     Fflush(stderr);
 256     write(2, buf, strlen(buf));
 257     if (tty2) {                         /* might be redirected to a file */
 258         r = read(2, buf, sizeof buf);
 259     }
 260     else if (isatty(1)) {               /* this may be new file output */
 261         Fflush(stdout);
 262         write(1, buf, strlen(buf));
 263         r = read(1, buf, sizeof buf);
 264     }
 265     else if ((ttyfd = open("/dev/tty", 2)) >= 0 && isatty(ttyfd)) {
 266                                         /* might be deleted or unwriteable */
 267         write(ttyfd, buf, strlen(buf));
 268         r = read(ttyfd, buf, sizeof buf);
 269         Close(ttyfd);
 270     }
 271     else if (isatty(0)) {               /* this is probably patch input */
 272         Fflush(stdin);
 273         write(0, buf, strlen(buf));
 274         r = read(0, buf, sizeof buf);
 275     }
 276     else {                              /* no terminal at all--default it */
 277         buf[0] = '\n';
 278         r = 1;
 279     }
 280     if (r <= 0)
 281         buf[0] = 0;
 282     else
 283         buf[r] = '\0';
 284     if (!tty2)
 285         say1(buf);
 286 }
 287 #endif /* lint */
 288
 289 /* How to handle certain events when not in a critical region. */
 290
 291 void
 292 set_signals(reset)
 293 int reset;
 294 {
 295 #ifndef lint
 296 #ifdef VOIDSIG
 297     static void (*hupval)(),(*intval)();
 298 #else
 299     static int (*hupval)(),(*intval)();
 300 #endif
 301
 302     if (!reset) {
 303         hupval = signal(SIGHUP, SIG_IGN);
 304         if (hupval != SIG_IGN)
 305 #ifdef VOIDSIG
 306             hupval = my_exit;
 307 #else
 308             hupval = (int(*)())my_exit;
 309 #endif
 310         intval = signal(SIGINT, SIG_IGN);
 311         if (intval != SIG_IGN)
 312 #ifdef VOIDSIG
 313             intval = my_exit;
 314 #else
 315             intval = (int(*)())my_exit;
 316 #endif
 317     }
 318     Signal(SIGHUP, hupval);
 319     Signal(SIGINT, intval);
 320 #endif
 321 }
 322
 323 /* How to handle certain events when in a critical region. */
 324
 325 void
 326 ignore_signals()
 327 {
 328 #ifndef lint
 329     Signal(SIGHUP, SIG_IGN);
 330     Signal(SIGINT, SIG_IGN);
 331 #endif
 332 }
 333
 334 /* Make sure we'll have the directories to create a file.
 335    If `striplast' is TRUE, ignore the last element of `filename'.  */
 336
 337 void
 338 makedirs(filename,striplast)
 339 Reg1 char *filename;
 340 bool striplast;
 341 {
 342     char tmpbuf[256];
 343     Reg2 char *s = tmpbuf;
 344     char *dirv[20];             /* Point to the NULs between elements.  */
 345     Reg3 int i;
 346     Reg4 int dirvp = 0;         /* Number of finished entries in dirv. */
 347
 348     /* Copy `filename' into `tmpbuf' with a NUL instead of a slash
 349        between the directories.  */
 350     while (*filename) {
 351         if (*filename == '/') {
 352             filename++;
 353             dirv[dirvp++] = s;
 354             *s++ = '\0';
 355         }
 356         else {
 357             *s++ = *filename++;
 358         }
 359     }
 360     *s = '\0';
 361     dirv[dirvp] = s;
 362     if (striplast)
 363         dirvp--;
 364     if (dirvp < 0)
 365         return;
 366
 367     strcpy(buf, "mkdir");
 368     s = buf;
 369     for (i=0; i<=dirvp; i++) {
 370         struct stat sbuf;
 371
 372         if (stat(tmpbuf, &sbuf) && errno == ENOENT) {
 373             while (*s) s++;
 374             *s++ = ' ';
 375             strcpy(s, tmpbuf);
 376         }
 377         *dirv[i] = '/';
 378     }
 379     if (s != buf)
 380         system(buf);
 381 }
 382
 383 /* Make filenames more reasonable. */
 384
 385 char *
 386 fetchname(at,strip_leading,assume_exists)
 387 char *at;
 388 int strip_leading;
 389 int assume_exists;
 390 {
 391     char *fullname;
 392     char *name;
 393     Reg1 char *t;
 394     char tmpbuf[200];
 395     int sleading = strip_leading;
 396
 397     if (!at)
 398         return Nullch;
 399     while (isspace(*at))
 400         at++;
 401 #ifdef DEBUGGING
 402     if (debug & 128)
 403         say4("fetchname %s %d %d\n",at,strip_leading,assume_exists);
 404 #endif
 405     if (strnEQ(at, "/dev/null", 9))     /* so files can be created by diffing */
 406         return Nullch;                  /*   against /dev/null. */
 407     name = fullname = t = savestr(at);
 408
 409     /* Strip off up to `sleading' leading slashes and null terminate.  */
 410     for (; *t && !isspace(*t); t++)
 411         if (*t == '/')
 412             if (--sleading >= 0)
 413                 name = t+1;
 414     *t = '\0';
 415
 416     /* If no -p option was given (957 is the default value!),
 417        we were given a relative pathname,
 418        and the leading directories that we just stripped off all exist,
 419        put them back on.  */
 420     if (strip_leading == 957 && name != fullname && *fullname != '/') {
 421         name[-1] = '\0';
 422         if (stat(fullname, &filestat) == 0 && S_ISDIR (filestat.st_mode)) {
 423             name[-1] = '/';
 424             name=fullname;
 425         }
 426     }
 427
 428     name = savestr(name);
 429     free(fullname);
 430
 431     if (stat(name, &filestat) && !assume_exists) {
 432         char *filebase = basename(name);
 433         int pathlen = filebase - name;
 434
 435         /* Put any leading path into `tmpbuf'.  */
 436         strncpy(tmpbuf, name, pathlen);
 437
 438 #define try(f, a1, a2) (Sprintf(tmpbuf + pathlen, f, a1, a2), stat(tmpbuf, &filestat) == 0)
 439         if (   try("RCS/%s%s", filebase, RCSSUFFIX)
 440             || try("RCS/%s"  , filebase,         0)
 441             || try(    "%s%s", filebase, RCSSUFFIX)
 442             || try("SCCS/%s%s", SCCSPREFIX, filebase)
 443             || try(     "%s%s", SCCSPREFIX, filebase))
 444           return name;
 445         free(name);
 446         name = Nullch;
 447     }
 448
 449     return name;
 450 }