hbase

heirloom base
git clone git://git.2f30.org/hbase
Log | Files | Refs | README

util.c (9701B)


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