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: inp.c,v 1.36 2012/04/10 14:46:34 ajacoutot Exp $
27 * $FreeBSD$
28 */
29
30 #include <sys/types.h>
31 #include <sys/file.h>
32 #include <sys/stat.h>
33 #include <sys/mman.h>
34 #include <sys/wait.h>
35
36 #include <ctype.h>
37 #include <errno.h>
38 #include <libgen.h>
39 #include <paths.h>
40 #include <spawn.h>
41 #include <stddef.h>
42 #include <stdint.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47
48 #include "common.h"
49 #include "util.h"
50 #include "pch.h"
51 #include "inp.h"
52
53
54 /* Input-file-with-indexable-lines abstract type */
55
56 static size_t i_size; /* size of the input file */
57 static char *i_womp; /* plan a buffer for entire file */
58 static char **i_ptr; /* pointers to lines in i_womp */
59 static char empty_line[] = { '\0' };
60
61 static int tifd = -1; /* plan b virtual string array */
62 static char *tibuf[2]; /* plan b buffers */
63 static LINENUM tiline[2] = {-1, -1}; /* 1st line in each buffer */
64 static size_t lines_per_buf; /* how many lines per buffer */
65 static size_t tibuflen; /* plan b buffer length */
66 static size_t tireclen; /* length of records in tmp file */
67
68 static bool rev_in_string(const char *);
69 static bool reallocate_lines(size_t *);
70
71 /* returns false if insufficient memory */
72 static bool plan_a(const char *);
73
74 static void plan_b(const char *);
75
76 /* New patch--prepare to edit another file. */
77
78 void
re_input(void)79 re_input(void)
80 {
81 if (using_plan_a) {
82 free(i_ptr);
83 i_ptr = NULL;
84 if (i_womp != NULL) {
85 munmap(i_womp, i_size);
86 i_womp = NULL;
87 }
88 i_size = 0;
89 } else {
90 using_plan_a = true; /* maybe the next one is smaller */
91 close(tifd);
92 tifd = -1;
93 free(tibuf[0]);
94 free(tibuf[1]);
95 tibuf[0] = tibuf[1] = NULL;
96 tiline[0] = tiline[1] = -1;
97 tireclen = 0;
98 }
99 }
100
101 /* Construct the line index, somehow or other. */
102
103 void
scan_input(const char * filename)104 scan_input(const char *filename)
105 {
106 if (!plan_a(filename))
107 plan_b(filename);
108 if (verbose) {
109 say("Patching file %s using Plan %s...\n", filename,
110 (using_plan_a ? "A" : "B"));
111 }
112 }
113
114 static bool
reallocate_lines(size_t * lines_allocated)115 reallocate_lines(size_t *lines_allocated)
116 {
117 char **p;
118 size_t new_size;
119
120 new_size = *lines_allocated * 3 / 2;
121 p = realloc(i_ptr, (new_size + 2) * sizeof(char *));
122 if (p == NULL) { /* shucks, it was a near thing */
123 munmap(i_womp, i_size);
124 i_womp = NULL;
125 free(i_ptr);
126 i_ptr = NULL;
127 *lines_allocated = 0;
128 return false;
129 }
130 *lines_allocated = new_size;
131 i_ptr = p;
132 return true;
133 }
134
135 /* Try keeping everything in memory. */
136
137 static bool
plan_a(const char * filename)138 plan_a(const char *filename)
139 {
140 int ifd, statfailed;
141 char *p, *s;
142 struct stat filestat;
143 ptrdiff_t sz;
144 size_t i;
145 size_t iline, lines_allocated;
146
147 #ifdef DEBUGGING
148 if (debug & 8)
149 return false;
150 #endif
151
152 if (filename == NULL || *filename == '\0')
153 return false;
154
155 statfailed = stat(filename, &filestat);
156 if (statfailed && ok_to_create_file) {
157 if (verbose)
158 say("(Creating file %s...)\n", filename);
159
160 /*
161 * in check_patch case, we still display `Creating file' even
162 * though we're not. The rule is that -C should be as similar
163 * to normal patch behavior as possible
164 */
165 if (check_only)
166 return true;
167 makedirs(filename, true);
168 close(creat(filename, 0666));
169 statfailed = stat(filename, &filestat);
170 }
171 if (statfailed)
172 fatal("can't find %s\n", filename);
173 filemode = filestat.st_mode;
174 if (!S_ISREG(filemode))
175 fatal("%s is not a normal file--can't patch\n", filename);
176 if ((uint64_t)filestat.st_size > SIZE_MAX) {
177 say("block too large to mmap\n");
178 return false;
179 }
180 i_size = (size_t)filestat.st_size;
181 if (out_of_mem) {
182 set_hunkmax(); /* make sure dynamic arrays are allocated */
183 out_of_mem = false;
184 return false; /* force plan b because plan a bombed */
185 }
186 if ((ifd = open(filename, O_RDONLY)) < 0)
187 pfatal("can't open file %s", filename);
188
189 if (i_size) {
190 i_womp = mmap(NULL, i_size, PROT_READ, MAP_PRIVATE, ifd, 0);
191 if (i_womp == MAP_FAILED) {
192 perror("mmap failed");
193 i_womp = NULL;
194 close(ifd);
195 return false;
196 }
197 } else {
198 i_womp = NULL;
199 }
200
201 close(ifd);
202 if (i_size)
203 madvise(i_womp, i_size, MADV_SEQUENTIAL);
204
205 /* estimate the number of lines */
206 lines_allocated = i_size / 25;
207 if (lines_allocated < 100)
208 lines_allocated = 100;
209
210 if (!reallocate_lines(&lines_allocated))
211 return false;
212
213 /* now scan the buffer and build pointer array */
214 iline = 1;
215 i_ptr[iline] = i_womp;
216 /* test for NUL too, to maintain the behavior of the original code */
217 for (s = i_womp, i = 0; i < i_size && *s != '\0'; s++, i++) {
218 if (*s == '\n') {
219 if (iline == lines_allocated) {
220 if (!reallocate_lines(&lines_allocated))
221 return false;
222 }
223 /* these are NOT NUL terminated */
224 i_ptr[++iline] = s + 1;
225 }
226 }
227 /* if the last line contains no EOL, append one */
228 if (i_size > 0 && i_womp[i_size - 1] != '\n') {
229 last_line_missing_eol = true;
230 /* fix last line */
231 sz = s - i_ptr[iline];
232 p = malloc(sz + 1);
233 if (p == NULL) {
234 free(i_ptr);
235 i_ptr = NULL;
236 munmap(i_womp, i_size);
237 i_womp = NULL;
238 return false;
239 }
240
241 memcpy(p, i_ptr[iline], sz);
242 p[sz] = '\n';
243 i_ptr[iline] = p;
244 /* count the extra line and make it point to some valid mem */
245 i_ptr[++iline] = empty_line;
246 } else
247 last_line_missing_eol = false;
248
249 input_lines = iline - 1;
250
251 /* now check for revision, if any */
252
253 if (revision != NULL) {
254 if (i_womp == NULL || !rev_in_string(i_womp)) {
255 if (force) {
256 if (verbose)
257 say("Warning: this file doesn't appear "
258 "to be the %s version--patching anyway.\n",
259 revision);
260 } else if (batch) {
261 fatal("this file doesn't appear to be the "
262 "%s version--aborting.\n",
263 revision);
264 } else {
265 ask("This file doesn't appear to be the "
266 "%s version--patch anyway? [n] ",
267 revision);
268 if (*buf != 'y')
269 fatal("aborted\n");
270 }
271 } else if (verbose)
272 say("Good. This file appears to be the %s version.\n",
273 revision);
274 }
275 return true; /* plan a will work */
276 }
277
278 /* Keep (virtually) nothing in memory. */
279
280 static void
plan_b(const char * filename)281 plan_b(const char *filename)
282 {
283 FILE *ifp;
284 size_t i = 0, j, len, maxlen = 1;
285 char *lbuf = NULL, *p;
286 bool found_revision = (revision == NULL);
287
288 using_plan_a = false;
289 if ((ifp = fopen(filename, "r")) == NULL)
290 pfatal("can't open file %s", filename);
291 unlink(TMPINNAME);
292 if ((tifd = open(TMPINNAME, O_EXCL | O_CREAT | O_WRONLY, 0666)) < 0)
293 pfatal("can't open file %s", TMPINNAME);
294 while ((p = fgetln(ifp, &len)) != NULL) {
295 if (p[len - 1] == '\n')
296 p[len - 1] = '\0';
297 else {
298 /* EOF without EOL, copy and add the NUL */
299 if ((lbuf = malloc(len + 1)) == NULL)
300 fatal("out of memory\n");
301 memcpy(lbuf, p, len);
302 lbuf[len] = '\0';
303 p = lbuf;
304
305 last_line_missing_eol = true;
306 len++;
307 }
308 if (revision != NULL && !found_revision && rev_in_string(p))
309 found_revision = true;
310 if (len > maxlen)
311 maxlen = len; /* find longest line */
312 }
313 free(lbuf);
314 if (ferror(ifp))
315 pfatal("can't read file %s", filename);
316
317 if (revision != NULL) {
318 if (!found_revision) {
319 if (force) {
320 if (verbose)
321 say("Warning: this file doesn't appear "
322 "to be the %s version--patching anyway.\n",
323 revision);
324 } else if (batch) {
325 fatal("this file doesn't appear to be the "
326 "%s version--aborting.\n",
327 revision);
328 } else {
329 ask("This file doesn't appear to be the %s "
330 "version--patch anyway? [n] ",
331 revision);
332 if (*buf != 'y')
333 fatal("aborted\n");
334 }
335 } else if (verbose)
336 say("Good. This file appears to be the %s version.\n",
337 revision);
338 }
339 fseek(ifp, 0L, SEEK_SET); /* rewind file */
340 tireclen = maxlen;
341 tibuflen = maxlen > BUFFERSIZE ? maxlen : BUFFERSIZE;
342 lines_per_buf = tibuflen / maxlen;
343 tibuf[0] = malloc(tibuflen + 1);
344 if (tibuf[0] == NULL)
345 fatal("out of memory\n");
346 tibuf[1] = malloc(tibuflen + 1);
347 if (tibuf[1] == NULL)
348 fatal("out of memory\n");
349 for (i = 1;; i++) {
350 p = tibuf[0] + maxlen * (i % lines_per_buf);
351 if (i % lines_per_buf == 0) /* new block */
352 if (write(tifd, tibuf[0], tibuflen) !=
353 (ssize_t) tibuflen)
354 pfatal("can't write temp file");
355 if (fgets(p, maxlen + 1, ifp) == NULL) {
356 input_lines = i - 1;
357 if (i % lines_per_buf != 0)
358 if (write(tifd, tibuf[0], tibuflen) !=
359 (ssize_t) tibuflen)
360 pfatal("can't write temp file");
361 break;
362 }
363 j = strlen(p);
364 /* These are '\n' terminated strings, so no need to add a NUL */
365 if (j == 0 || p[j - 1] != '\n')
366 p[j] = '\n';
367 }
368 fclose(ifp);
369 close(tifd);
370 if ((tifd = open(TMPINNAME, O_RDONLY)) < 0)
371 pfatal("can't reopen file %s", TMPINNAME);
372 }
373
374 /*
375 * Fetch a line from the input file, \n terminated, not necessarily \0.
376 */
377 char *
ifetch(LINENUM line,int whichbuf)378 ifetch(LINENUM line, int whichbuf)
379 {
380 if (line < 1 || line > input_lines) {
381 if (warn_on_invalid_line) {
382 say("No such line %ld in input file, ignoring\n", line);
383 warn_on_invalid_line = false;
384 }
385 return NULL;
386 }
387 if (using_plan_a)
388 return i_ptr[line];
389 else {
390 LINENUM offline = line % lines_per_buf;
391 LINENUM baseline = line - offline;
392
393 if (tiline[0] == baseline)
394 whichbuf = 0;
395 else if (tiline[1] == baseline)
396 whichbuf = 1;
397 else {
398 tiline[whichbuf] = baseline;
399
400 if (lseek(tifd, (off_t) (baseline / lines_per_buf *
401 tibuflen), SEEK_SET) < 0)
402 pfatal("cannot seek in the temporary input file");
403
404 if (read(tifd, tibuf[whichbuf], tibuflen) !=
405 (ssize_t) tibuflen)
406 pfatal("error reading tmp file %s", TMPINNAME);
407 }
408 return tibuf[whichbuf] + (tireclen * offline);
409 }
410 }
411
412 /*
413 * True if the string argument contains the revision number we want.
414 */
415 static bool
rev_in_string(const char * string)416 rev_in_string(const char *string)
417 {
418 const char *s;
419 size_t patlen;
420
421 if (revision == NULL)
422 return true;
423 patlen = strlen(revision);
424 if (strnEQ(string, revision, patlen) && isspace((unsigned char)string[patlen]))
425 return true;
426 for (s = string; *s; s++) {
427 if (isspace((unsigned char)*s) && strnEQ(s + 1, revision, patlen) &&
428 isspace((unsigned char)s[patlen + 1])) {
429 return true;
430 }
431 }
432 return false;
433 }
434