usr.bin/patch/util.c

   1 /*-
   2  * Copyright 1986, Larry Wall
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following condition is met:
   6  * 1. Redistributions of source code must retain the above copyright notice,
   7  * this condition and the following disclaimer.
   8  *
   9  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  10  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  12  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  13  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  14  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  15  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  16  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  17  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  18  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  19  * SUCH DAMAGE.
  20  *
  21  * patch - a program to apply diffs to original files
  22  *
  23  * -C option added in 1998, original code by Marc Espie, based on FreeBSD
  24  * behaviour
  25  *
  26  * $OpenBSD: util.c,v 1.35 2010/07/24 01:10:12 ray Exp $
  27  */
  28
  29 #include <sys/stat.h>
  30
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <libgen.h>
  35 #include <limits.h>
  36 #include <paths.h>
  37 #include <signal.h>
  38 #include <stdarg.h>
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43
  44 #include "common.h"
  45 #include "util.h"
  46 #include "backupfile.h"
  47 #include "pathnames.h"
  48
  49 /* Rename a file, copying it if necessary. */
  50
  51 int
  52 move_file(const char *from, const char *to)
  53 {
  54         int     fromfd;
  55         ssize_t i;
  56
  57         /* to stdout? */
  58
  59         if (strEQ(to, "-")) {
  60 #ifdef DEBUGGING
  61                 if (debug & 4)
  62                         say("Moving %s to stdout.\n", from);
  63 #endif
  64                 fromfd = open(from, O_RDONLY);
  65                 if (fromfd < 0)
  66                         pfatal("internal error, can't reopen %s", from);
  67                 while ((i = read(fromfd, buf, buf_size)) > 0)
  68                         if (write(STDOUT_FILENO, buf, i) != i)
  69                                 pfatal("write failed");
  70                 close(fromfd);
  71                 return 0;
  72         }
  73         if (backup_file(to) < 0) {
  74                 say("Can't backup %s, output is in %s: %s\n", to, from,
  75                     strerror(errno));
  76                 return -1;
  77         }
  78 #ifdef DEBUGGING
  79         if (debug & 4)
  80                 say("Moving %s to %s.\n", from, to);
  81 #endif
  82         if (rename(from, to) < 0) {
  83                 if (errno != EXDEV || copy_file(from, to) < 0) {
  84                         say("Can't create %s, output is in %s: %s\n",
  85                             to, from, strerror(errno));
  86                         return -1;
  87                 }
  88         }
  89         return 0;
  90 }
  91
  92 /* Backup the original file.  */
  93
  94 int
  95 backup_file(const char *orig)
  96 {
  97         struct stat     filestat;
  98         char            bakname[PATH_MAX], *s, *simplename;
  99         dev_t           orig_device;
 100         ino_t           orig_inode;
 101
 102         if (backup_type == none || stat(orig, &filestat) != 0)
 103                 return 0;                       /* nothing to do */
 104         /*
 105          * If the user used zero prefixes or suffixes, then
 106          * he doesn't want backups.  Yet we have to remove
 107          * orig to break possible hardlinks.
 108          */
 109         if ((origprae && *origprae == 0) || *simple_backup_suffix == 0) {
 110                 unlink(orig);
 111                 return 0;
 112         }
 113         orig_device = filestat.st_dev;
 114         orig_inode = filestat.st_ino;
 115
 116         if (origprae) {
 117                 if (strlcpy(bakname, origprae, sizeof(bakname)) >= sizeof(bakname) ||
 118                     strlcat(bakname, orig, sizeof(bakname)) >= sizeof(bakname))
 119                         fatal("filename %s too long for buffer\n", origprae);
 120         } else {
 121                 if ((s = find_backup_file_name(orig)) == NULL)
 122                         fatal("out of memory\n");
 123                 if (strlcpy(bakname, s, sizeof(bakname)) >= sizeof(bakname))
 124                         fatal("filename %s too long for buffer\n", s);
 125                 free(s);
 126         }
 127
 128         if ((simplename = strrchr(bakname, '/')) != NULL)
 129                 simplename = simplename + 1;
 130         else
 131                 simplename = bakname;
 132
 133         /*
 134          * Find a backup name that is not the same file. Change the
 135          * first lowercase char into uppercase; if that isn't
 136          * sufficient, chop off the first char and try again.
 137          */
 138         while (stat(bakname, &filestat) == 0 &&
 139             orig_device == filestat.st_dev && orig_inode == filestat.st_ino) {
 140                 /* Skip initial non-lowercase chars.  */
 141                 for (s = simplename; *s && !islower((unsigned char)*s); s++)
 142                         ;
 143                 if (*s)
 144                         *s = toupper((unsigned char)*s);
 145                 else
 146                         memmove(simplename, simplename + 1,
 147                             strlen(simplename + 1) + 1);
 148         }
 149 #ifdef DEBUGGING
 150         if (debug & 4)
 151                 say("Moving %s to %s.\n", orig, bakname);
 152 #endif
 153         if (rename(orig, bakname) < 0) {
 154                 if (errno != EXDEV || copy_file(orig, bakname) < 0)
 155                         return -1;
 156         }
 157         return 0;
 158 }
 159
 160 /*
 161  * Copy a file.
 162  */
 163 int
 164 copy_file(const char *from, const char *to)
 165 {
 166         int     tofd, fromfd;
 167         ssize_t i;
 168
 169         tofd = open(to, O_CREAT|O_TRUNC|O_WRONLY, 0666);
 170         if (tofd < 0)
 171                 return -1;
 172         fromfd = open(from, O_RDONLY, 0);
 173         if (fromfd < 0)
 174                 pfatal("internal error, can't reopen %s", from);
 175         while ((i = read(fromfd, buf, buf_size)) > 0)
 176                 if (write(tofd, buf, i) != i)
 177                         pfatal("write to %s failed", to);
 178         close(fromfd);
 179         close(tofd);
 180         return 0;
 181 }
 182
 183 /*
 184  * Allocate a unique area for a string.
 185  */
 186 char *
 187 savestr(const char *s)
 188 {
 189         char    *rv;
 190
 191         if (!s)
 192                 s = "Oops";
 193         rv = strdup(s);
 194         if (rv == NULL) {
 195                 if (using_plan_a)
 196                         out_of_mem = true;
 197                 else
 198                         fatal("out of memory\n");
 199         }
 200         return rv;
 201 }
 202
 203 /*
 204  * Allocate a unique area for a string.  Call fatal if out of memory.
 205  */
 206 char *
 207 xstrdup(const char *s)
 208 {
 209         char    *rv;
 210
 211         if (!s)
 212                 s = "Oops";
 213         rv = strdup(s);
 214         if (rv == NULL)
 215                 fatal("out of memory\n");
 216         return rv;
 217 }
 218
 219 /*
 220  * Vanilla terminal output (buffered).
 221  */
 222 void
 223 say(const char *fmt, ...)
 224 {
 225         va_list ap;
 226
 227         va_start(ap, fmt);
 228         vfprintf(stdout, fmt, ap);
 229         va_end(ap);
 230         fflush(stdout);
 231 }
 232
 233 /*
 234  * Terminal output, pun intended.
 235  */
 236 void
 237 fatal(const char *fmt, ...)
 238 {
 239         va_list ap;
 240
 241         va_start(ap, fmt);
 242         fprintf(stderr, "patch: **** ");
 243         vfprintf(stderr, fmt, ap);
 244         va_end(ap);
 245         my_exit(2);
 246 }
 247
 248 /*
 249  * Say something from patch, something from the system, then silence . . .
 250  */
 251 void
 252 pfatal(const char *fmt, ...)
 253 {
 254         va_list ap;
 255         int     errnum = errno;
 256
 257         fprintf(stderr, "patch: **** ");
 258         va_start(ap, fmt);
 259         vfprintf(stderr, fmt, ap);
 260         va_end(ap);
 261         fprintf(stderr, ": %s\n", strerror(errnum));
 262         my_exit(2);
 263 }
 264
 265 /*
 266  * Get a response from the user via /dev/tty
 267  */
 268 void
 269 ask(const char *fmt, ...)
 270 {
 271         va_list ap;
 272         ssize_t nr = 0;
 273         static  int ttyfd = -1;
 274
 275         va_start(ap, fmt);
 276         vfprintf(stdout, fmt, ap);
 277         va_end(ap);
 278         fflush(stdout);
 279         if (ttyfd < 0)
 280                 ttyfd = open(_PATH_TTY, O_RDONLY);
 281         if (ttyfd >= 0) {
 282                 if ((nr = read(ttyfd, buf, buf_size)) > 0 &&
 283                     buf[nr - 1] == '\n')
 284                         buf[nr - 1] = '\0';
 285         }
 286         if (ttyfd < 0 || nr <= 0) {
 287                 /* no tty or error reading, pretend user entered 'return' */
 288                 putchar('\n');
 289                 buf[0] = '\0';
 290         }
 291 }
 292
 293 /*
 294  * How to handle certain events when not in a critical region.
 295  */
 296 void
 297 set_signals(int reset)
 298 {
 299         static sig_t    hupval, intval;
 300
 301         if (!reset) {
 302                 hupval = signal(SIGHUP, SIG_IGN);
 303                 if (hupval != SIG_IGN)
 304                         hupval = my_exit;
 305                 intval = signal(SIGINT, SIG_IGN);
 306                 if (intval != SIG_IGN)
 307                         intval = my_exit;
 308         }
 309         signal(SIGHUP, hupval);
 310         signal(SIGINT, intval);
 311 }
 312
 313 /*
 314  * How to handle certain events when in a critical region.
 315  */
 316 void
 317 ignore_signals(void)
 318 {
 319         signal(SIGHUP, SIG_IGN);
 320         signal(SIGINT, SIG_IGN);
 321 }
 322
 323 /*
 324  * Make sure we'll have the directories to create a file. If `striplast' is
 325  * true, ignore the last element of `filename'.
 326  */
 327
 328 void
 329 makedirs(const char *filename, bool striplast)
 330 {
 331         char    *tmpbuf;
 332
 333         if ((tmpbuf = strdup(filename)) == NULL)
 334                 fatal("out of memory\n");
 335
 336         if (striplast) {
 337                 char    *s = strrchr(tmpbuf, '/');
 338                 if (s == NULL) {
 339                         free(tmpbuf);
 340                         return; /* nothing to be done */
 341                 }
 342                 *s = '\0';
 343         }
 344         if (mkpath(tmpbuf) != 0)
 345                 pfatal("creation of %s failed", tmpbuf);
 346         free(tmpbuf);
 347 }
 348
 349 /*
 350  * Make filenames more reasonable.
 351  */
 352 char *
 353 fetchname(const char *at, bool *exists, int strip_leading)
 354 {
 355         char            *fullname, *name, *t;
 356         int             sleading, tab;
 357         struct stat     filestat;
 358
 359         if (at == NULL || *at == '\0')
 360                 return NULL;
 361         while (isspace((unsigned char)*at))
 362                 at++;
 363 #ifdef DEBUGGING
 364         if (debug & 128)
 365                 say("fetchname %s %d\n", at, strip_leading);
 366 #endif
 367         /* So files can be created by diffing against /dev/null.  */
 368         if (strnEQ(at, _PATH_DEVNULL, sizeof(_PATH_DEVNULL) - 1)) {
 369                 *exists = true;
 370                 return NULL;
 371         }
 372         name = fullname = t = savestr(at);
 373
 374         tab = strchr(t, '\t') != NULL;
 375         /* Strip off up to `strip_leading' path components and NUL terminate. */
 376         for (sleading = strip_leading; *t != '\0' && ((tab && *t != '\t') ||
 377             !isspace((unsigned char)*t)); t++) {
 378                 if (t[0] == '/' && t[1] != '/' && t[1] != '\0')
 379                         if (--sleading >= 0)
 380                                 name = t + 1;
 381         }
 382         *t = '\0';
 383
 384         /*
 385          * If no -p option was given (957 is the default value!), we were
 386          * given a relative pathname, and the leading directories that we
 387          * just stripped off all exist, put them back on.
 388          */
 389         if (strip_leading == 957 && name != fullname && *fullname != '/') {
 390                 name[-1] = '\0';
 391                 if (stat(fullname, &filestat) == 0 && S_ISDIR(filestat.st_mode)) {
 392                         name[-1] = '/';
 393                         name = fullname;
 394                 }
 395         }
 396         name = savestr(name);
 397         free(fullname);
 398
 399         *exists = stat(name, &filestat) == 0;
 400         return name;
 401 }
 402
 403 void
 404 version(void)
 405 {
 406         printf("patch 2.0-12u11 FreeBSD\n");
 407         my_exit(EXIT_SUCCESS);
 408 }
 409
 410 /*
 411  * Exit with cleanup.
 412  */
 413 void
 414 my_exit(int status)
 415 {
 416         unlink(TMPINNAME);
 417         if (!toutkeep)
 418                 unlink(TMPOUTNAME);
 419         if (!trejkeep)
 420                 unlink(TMPREJNAME);
 421         unlink(TMPPATNAME);
 422         exit(status);
 423 }