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