![[BACK]](/icons/back.gif){kind=icon}
Return to pch.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / patch|
Return to pch.c CVS log | Up to [local] / src / usr.bin / patch |
1.39 ! ajacouto 1: /* $OpenBSD: pch.c,v 1.38 2009/10/27 23:59:41 deraadt Exp $ */
1.30 otto 2:
3: /*
4: * patch - a program to apply diffs to original files
5: *
6: * Copyright 1986, Larry Wall
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following condition is met:
10: * 1. Redistributions of source code must retain the above copyright notice,
11: * this condition and the following disclaimer.
12: *
13: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
14: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
17: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
20: * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23: * SUCH DAMAGE.
24: *
25: * -C option added in 1998, original code by Marc Espie, based on FreeBSD
26: * behaviour
27: */
1.1 deraadt 28:
1.21 otto 29: #include <sys/types.h>
30: #include <sys/stat.h>
31:
32: #include <ctype.h>
1.32 millert 33: #include <libgen.h>
34: #include <limits.h>
1.25 otto 35: #include <stdio.h>
1.21 otto 36: #include <stdlib.h>
37: #include <string.h>
38: #include <unistd.h>
39:
1.1 deraadt 40: #include "common.h"
41: #include "util.h"
42: #include "pch.h"
1.27 millert 43: #include "pathnames.h"
1.1 deraadt 44:
45: /* Patch (diff listing) abstract type. */
46:
1.17 deraadt 47: static long p_filesize; /* size of the patch file */
48: static LINENUM p_first; /* 1st line number */
49: static LINENUM p_newfirst; /* 1st line number of replacement */
50: static LINENUM p_ptrn_lines; /* # lines in pattern */
51: static LINENUM p_repl_lines; /* # lines in replacement text */
52: static LINENUM p_end = -1; /* last line in hunk */
53: static LINENUM p_max; /* max allowed value of p_end */
54: static LINENUM p_context = 3; /* # of context lines */
55: static LINENUM p_input_line = 0; /* current line # from patch file */
1.25 otto 56: static char **p_line = NULL;/* the text of the hunk */
1.21 otto 57: static short *p_len = NULL; /* length of each line */
1.25 otto 58: static char *p_char = NULL; /* +, -, and ! */
1.17 deraadt 59: static int hunkmax = INITHUNKMAX; /* size of above arrays to begin with */
60: static int p_indent; /* indent to patch */
61: static LINENUM p_base; /* where to intuit this time */
62: static LINENUM p_bline; /* line # of p_base */
63: static LINENUM p_start; /* where intuit found a patch */
64: static LINENUM p_sline; /* and the line number for it */
65: static LINENUM p_hunk_beg; /* line number of current hunk */
66: static LINENUM p_efake = -1; /* end of faked up lines--don't free */
67: static LINENUM p_bfake = -1; /* beg of faked up lines */
1.25 otto 68: static FILE *pfp = NULL; /* patch file pointer */
69: static char *bestguess = NULL; /* guess at correct filename */
1.1 deraadt 70:
1.21 otto 71: static void grow_hunkmax(void);
72: static int intuit_diff_type(void);
1.25 otto 73: static void next_intuit_at(LINENUM, LINENUM);
74: static void skip_to(LINENUM, LINENUM);
1.23 deraadt 75: static char *pgets(char *, int, FILE *);
1.32 millert 76: static char *best_name(const struct file_name *, bool);
77: static char *posix_name(const struct file_name *, bool);
78: static size_t num_components(const char *);
1.25 otto 79:
1.17 deraadt 80: /*
81: * Prepare to look for the next patch in the patch file.
82: */
1.1 deraadt 83: void
1.17 deraadt 84: re_patch(void)
1.1 deraadt 85: {
1.25 otto 86: p_first = 0;
87: p_newfirst = 0;
88: p_ptrn_lines = 0;
89: p_repl_lines = 0;
1.17 deraadt 90: p_end = (LINENUM) - 1;
1.25 otto 91: p_max = 0;
1.17 deraadt 92: p_indent = 0;
1.1 deraadt 93: }
94:
1.17 deraadt 95: /*
96: * Open the patch file at the beginning of time.
97: */
1.1 deraadt 98: void
1.25 otto 99: open_patch_file(const char *filename)
1.1 deraadt 100: {
1.25 otto 101: struct stat filestat;
102:
103: if (filename == NULL || *filename == '\0' || strEQ(filename, "-")) {
1.17 deraadt 104: pfp = fopen(TMPPATNAME, "w");
1.21 otto 105: if (pfp == NULL)
1.17 deraadt 106: pfatal("can't create %s", TMPPATNAME);
1.21 otto 107: while (fgets(buf, sizeof buf, stdin) != NULL)
1.17 deraadt 108: fputs(buf, pfp);
109: fclose(pfp);
110: filename = TMPPATNAME;
111: }
112: pfp = fopen(filename, "r");
1.21 otto 113: if (pfp == NULL)
1.17 deraadt 114: pfatal("patch file %s not found", filename);
115: fstat(fileno(pfp), &filestat);
116: p_filesize = filestat.st_size;
117: next_intuit_at(0L, 1L); /* start at the beginning */
118: set_hunkmax();
1.1 deraadt 119: }
120:
1.17 deraadt 121: /*
122: * Make sure our dynamically realloced tables are malloced to begin with.
123: */
1.1 deraadt 124: void
1.17 deraadt 125: set_hunkmax(void)
1.1 deraadt 126: {
1.21 otto 127: if (p_line == NULL)
1.37 deraadt 128: p_line = calloc((size_t) hunkmax, sizeof(char *));
1.21 otto 129: if (p_len == NULL)
1.37 deraadt 130: p_len = calloc((size_t) hunkmax, sizeof(short));
1.21 otto 131: if (p_char == NULL)
1.37 deraadt 132: p_char = calloc((size_t) hunkmax, sizeof(char));
1.1 deraadt 133: }
134:
1.17 deraadt 135: /*
136: * Enlarge the arrays containing the current hunk of patch.
137: */
1.21 otto 138: static void
1.17 deraadt 139: grow_hunkmax(void)
1.1 deraadt 140: {
1.31 otto 141: int new_hunkmax;
1.35 deraadt 142: char **new_p_line;
1.31 otto 143: short *new_p_len;
144: char *new_p_char;
145:
146: new_hunkmax = hunkmax * 2;
1.17 deraadt 147:
1.28 otto 148: if (p_line == NULL || p_len == NULL || p_char == NULL)
149: fatal("Internal memory allocation error\n");
1.21 otto 150:
1.31 otto 151: new_p_line = realloc(p_line, new_hunkmax * sizeof(char *));
152: if (new_p_line == NULL)
153: free(p_line);
154:
155: new_p_len = realloc(p_len, new_hunkmax * sizeof(short));
156: if (new_p_len == NULL)
157: free(p_len);
158:
159: new_p_char = realloc(p_char, new_hunkmax * sizeof(char));
160: if (new_p_char == NULL)
161: free(p_char);
162:
163: p_char = new_p_char;
164: p_len = new_p_len;
165: p_line = new_p_line;
1.21 otto 166:
1.31 otto 167: if (p_line != NULL && p_len != NULL && p_char != NULL) {
168: hunkmax = new_hunkmax;
1.17 deraadt 169: return;
1.31 otto 170: }
171:
1.17 deraadt 172: if (!using_plan_a)
173: fatal("out of memory\n");
1.28 otto 174: out_of_mem = true; /* whatever is null will be allocated again */
175: /* from within plan_a(), of all places */
1.1 deraadt 176: }
177:
178: /* True if the remainder of the patch file contains a diff of some sort. */
179:
180: bool
1.17 deraadt 181: there_is_another_patch(void)
1.1 deraadt 182: {
1.32 millert 183: bool exists = false;
184:
1.17 deraadt 185: if (p_base != 0L && p_base >= p_filesize) {
186: if (verbose)
187: say("done\n");
1.28 otto 188: return false;
1.17 deraadt 189: }
1.1 deraadt 190: if (verbose)
1.17 deraadt 191: say("Hmm...");
192: diff_type = intuit_diff_type();
193: if (!diff_type) {
194: if (p_base != 0L) {
195: if (verbose)
196: say(" Ignoring the trailing garbage.\ndone\n");
197: } else
198: say(" I can't seem to find a patch in there anywhere.\n");
1.28 otto 199: return false;
1.1 deraadt 200: }
1.17 deraadt 201: if (verbose)
202: say(" %sooks like %s to me...\n",
203: (p_base == 0L ? "L" : "The next patch l"),
204: diff_type == UNI_DIFF ? "a unified diff" :
205: diff_type == CONTEXT_DIFF ? "a context diff" :
206: diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
207: diff_type == NORMAL_DIFF ? "a normal diff" :
208: "an ed script");
209: if (p_indent && verbose)
210: say("(Patch is indented %d space%s.)\n", p_indent,
211: p_indent == 1 ? "" : "s");
212: skip_to(p_start, p_sline);
1.21 otto 213: while (filearg[0] == NULL) {
1.17 deraadt 214: if (force || batch) {
215: say("No file to patch. Skipping...\n");
216: filearg[0] = savestr(bestguess);
1.28 otto 217: skip_rest_of_patch = true;
218: return true;
1.17 deraadt 219: }
220: ask("File to patch: ");
221: if (*buf != '\n') {
1.25 otto 222: free(bestguess);
1.17 deraadt 223: bestguess = savestr(buf);
1.32 millert 224: filearg[0] = fetchname(buf, &exists, 0);
1.17 deraadt 225: }
1.32 millert 226: if (!exists) {
1.17 deraadt 227: ask("No file found--skip this patch? [n] ");
228: if (*buf != 'y')
229: continue;
230: if (verbose)
231: say("Skipping patch...\n");
1.33 otto 232: free(filearg[0]);
1.32 millert 233: filearg[0] = fetchname(bestguess, &exists, 0);
1.28 otto 234: skip_rest_of_patch = true;
235: return true;
1.17 deraadt 236: }
1.1 deraadt 237: }
1.28 otto 238: return true;
1.1 deraadt 239: }
240:
241: /* Determine what kind of diff is in the remaining part of the patch file. */
242:
1.21 otto 243: static int
1.17 deraadt 244: intuit_diff_type(void)
1.1 deraadt 245: {
1.17 deraadt 246: long this_line = 0, previous_line;
1.28 otto 247: long first_command_line = -1;
248: LINENUM fcl_line = -1;
249: bool last_line_was_command = false, this_is_a_command = false;
250: bool stars_last_line = false, stars_this_line = false;
1.17 deraadt 251: char *s, *t;
252: int indent, retval;
1.32 millert 253: struct file_name names[MAX_FILE];
1.17 deraadt 254:
1.32 millert 255: memset(names, 0, sizeof(names));
1.28 otto 256: ok_to_create_file = false;
1.21 otto 257: fseek(pfp, p_base, SEEK_SET);
1.17 deraadt 258: p_input_line = p_bline - 1;
259: for (;;) {
260: previous_line = this_line;
261: last_line_was_command = this_is_a_command;
262: stars_last_line = stars_this_line;
263: this_line = ftell(pfp);
264: indent = 0;
265: p_input_line++;
1.21 otto 266: if (fgets(buf, sizeof buf, pfp) == NULL) {
1.17 deraadt 267: if (first_command_line >= 0L) {
268: /* nothing but deletes!? */
269: p_start = first_command_line;
270: p_sline = fcl_line;
271: retval = ED_DIFF;
272: goto scan_exit;
273: } else {
274: p_start = this_line;
275: p_sline = p_input_line;
276: retval = 0;
277: goto scan_exit;
278: }
279: }
280: for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
281: if (*s == '\t')
282: indent += 8 - (indent % 8);
283: else
284: indent++;
285: }
286: for (t = s; isdigit(*t) || *t == ','; t++)
287: ;
288: this_is_a_command = (isdigit(*s) &&
289: (*t == 'd' || *t == 'c' || *t == 'a'));
290: if (first_command_line < 0L && this_is_a_command) {
291: first_command_line = this_line;
292: fcl_line = p_input_line;
293: p_indent = indent; /* assume this for now */
294: }
295: if (!stars_last_line && strnEQ(s, "*** ", 4))
1.32 millert 296: names[OLD_FILE].path = fetchname(s + 4,
297: &names[OLD_FILE].exists, strippath);
1.17 deraadt 298: else if (strnEQ(s, "--- ", 4))
1.32 millert 299: names[NEW_FILE].path = fetchname(s + 4,
300: &names[NEW_FILE].exists, strippath);
1.17 deraadt 301: else if (strnEQ(s, "+++ ", 4))
1.32 millert 302: /* pretend it is the old name */
303: names[OLD_FILE].path = fetchname(s + 4,
304: &names[OLD_FILE].exists, strippath);
1.17 deraadt 305: else if (strnEQ(s, "Index:", 6))
1.32 millert 306: names[INDEX_FILE].path = fetchname(s + 6,
307: &names[INDEX_FILE].exists, strippath);
1.17 deraadt 308: else if (strnEQ(s, "Prereq:", 7)) {
1.18 deraadt 309: for (t = s + 7; isspace(*t); t++)
310: ;
1.17 deraadt 311: revision = savestr(t);
1.18 deraadt 312: for (t = revision; *t && !isspace(*t); t++)
313: ;
1.17 deraadt 314: *t = '\0';
1.25 otto 315: if (*revision == '\0') {
1.17 deraadt 316: free(revision);
1.21 otto 317: revision = NULL;
1.17 deraadt 318: }
319: }
320: if ((!diff_type || diff_type == ED_DIFF) &&
321: first_command_line >= 0L &&
322: strEQ(s, ".\n")) {
323: p_indent = indent;
324: p_start = first_command_line;
325: p_sline = fcl_line;
326: retval = ED_DIFF;
327: goto scan_exit;
328: }
329: if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) {
1.32 millert 330: if (strnEQ(s + 4, "0,0", 3))
1.28 otto 331: ok_to_create_file = true;
1.17 deraadt 332: p_indent = indent;
333: p_start = this_line;
334: p_sline = p_input_line;
335: retval = UNI_DIFF;
336: goto scan_exit;
337: }
338: stars_this_line = strnEQ(s, "********", 8);
339: if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
340: strnEQ(s, "*** ", 4)) {
1.32 millert 341: if (atol(s + 4) == 0)
1.28 otto 342: ok_to_create_file = true;
1.17 deraadt 343: /*
1.32 millert 344: * If this is a new context diff the character just
345: * before the newline is a '*'.
1.17 deraadt 346: */
347: while (*s != '\n')
348: s++;
349: p_indent = indent;
350: p_start = previous_line;
351: p_sline = p_input_line - 1;
352: retval = (*(s - 1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
353: goto scan_exit;
354: }
355: if ((!diff_type || diff_type == NORMAL_DIFF) &&
356: last_line_was_command &&
357: (strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2))) {
358: p_start = previous_line;
359: p_sline = p_input_line - 1;
360: p_indent = indent;
361: retval = NORMAL_DIFF;
362: goto scan_exit;
363: }
364: }
365: scan_exit:
1.32 millert 366: if (retval == UNI_DIFF) {
367: /* unswap old and new */
368: struct file_name tmp = names[OLD_FILE];
369: names[OLD_FILE] = names[NEW_FILE];
370: names[NEW_FILE] = tmp;
371: }
372: if (filearg[0] == NULL) {
373: if (posix)
374: filearg[0] = posix_name(names, ok_to_create_file);
375: else {
376: /* Ignore the Index: name for context diffs, like GNU */
377: if (names[OLD_FILE].path != NULL ||
378: names[NEW_FILE].path != NULL) {
379: free(names[INDEX_FILE].path);
380: names[INDEX_FILE].path = NULL;
381: }
382: filearg[0] = best_name(names, ok_to_create_file);
383: }
1.17 deraadt 384: }
1.25 otto 385:
386: free(bestguess);
387: bestguess = NULL;
1.21 otto 388: if (filearg[0] != NULL)
1.17 deraadt 389: bestguess = savestr(filearg[0]);
1.32 millert 390: else if (!ok_to_create_file) {
391: /*
392: * We don't want to create a new file but we need a
393: * filename to set bestguess. Avoid setting filearg[0]
394: * so the file is not created automatically.
395: */
396: if (posix)
397: bestguess = posix_name(names, true);
398: else
399: bestguess = best_name(names, true);
400: }
401: free(names[OLD_FILE].path);
402: free(names[NEW_FILE].path);
403: free(names[INDEX_FILE].path);
1.17 deraadt 404: return retval;
1.1 deraadt 405: }
406:
1.17 deraadt 407: /*
408: * Remember where this patch ends so we know where to start up again.
409: */
1.21 otto 410: static void
1.25 otto 411: next_intuit_at(LINENUM file_pos, LINENUM file_line)
1.1 deraadt 412: {
1.17 deraadt 413: p_base = file_pos;
414: p_bline = file_line;
1.1 deraadt 415: }
416:
1.17 deraadt 417: /*
418: * Basically a verbose fseek() to the actual diff listing.
419: */
1.21 otto 420: static void
1.25 otto 421: skip_to(LINENUM file_pos, LINENUM file_line)
1.1 deraadt 422: {
1.17 deraadt 423: char *ret;
1.1 deraadt 424:
1.28 otto 425: if (p_base > file_pos)
426: fatal("Internal error: seek %ld>%ld\n", p_base, file_pos);
1.17 deraadt 427: if (verbose && p_base < file_pos) {
1.21 otto 428: fseek(pfp, p_base, SEEK_SET);
1.17 deraadt 429: say("The text leading up to this was:\n--------------------------\n");
430: while (ftell(pfp) < file_pos) {
431: ret = fgets(buf, sizeof buf, pfp);
1.28 otto 432: if (ret == NULL)
433: fatal("Unexpected end of file\n");
1.17 deraadt 434: say("|%s", buf);
435: }
436: say("--------------------------\n");
437: } else
1.21 otto 438: fseek(pfp, file_pos, SEEK_SET);
1.17 deraadt 439: p_input_line = file_line - 1;
1.1 deraadt 440: }
441:
442: /* Make this a function for better debugging. */
443: static void
1.16 deraadt 444: malformed(void)
1.1 deraadt 445: {
1.17 deraadt 446: fatal("malformed patch at line %ld: %s", p_input_line, buf);
447: /* about as informative as "Syntax error" in C */
1.1 deraadt 448: }
449:
1.14 otto 450: /*
451: * True if the line has been discarded (i.e. it is a line saying
452: * "\ No newline at end of file".)
453: */
454: static bool
455: remove_special_line(void)
456: {
1.17 deraadt 457: int c;
1.14 otto 458:
459: c = fgetc(pfp);
460: if (c == '\\') {
461: do {
462: c = fgetc(pfp);
463: } while (c != EOF && c != '\n');
464:
1.28 otto 465: return true;
1.14 otto 466: }
467: if (c != EOF)
468: fseek(pfp, -1L, SEEK_CUR);
469:
1.28 otto 470: return false;
1.14 otto 471: }
472:
1.17 deraadt 473: /*
474: * True if there is more of the current diff listing to process.
475: */
1.1 deraadt 476: bool
1.17 deraadt 477: another_hunk(void)
1.1 deraadt 478: {
1.17 deraadt 479: long line_beginning; /* file pos of the current line */
480: LINENUM repl_beginning; /* index of --- line */
481: LINENUM fillcnt; /* #lines of missing ptrn or repl */
482: LINENUM fillsrc; /* index of first line to copy */
483: LINENUM filldst; /* index of first missing line */
484: bool ptrn_spaces_eaten; /* ptrn was slightly misformed */
485: bool repl_could_be_missing; /* no + or ! lines in this hunk */
486: bool repl_missing; /* we are now backtracking */
487: long repl_backtrack_position; /* file pos of first repl line */
488: LINENUM repl_patch_line; /* input line number for same */
489: LINENUM ptrn_copiable; /* # of copiable lines in ptrn */
490: char *s, *ret;
491: int context = 0;
492:
493: while (p_end >= 0) {
494: if (p_end == p_efake)
495: p_end = p_bfake; /* don't free twice */
496: else
497: free(p_line[p_end]);
498: p_end--;
499: }
500: p_efake = -1;
501:
502: p_max = hunkmax; /* gets reduced when --- found */
503: if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
504: line_beginning = ftell(pfp);
505: repl_beginning = 0;
506: fillcnt = 0;
1.39 ! ajacouto 507: fillsrc = 0;
1.28 otto 508: ptrn_spaces_eaten = false;
509: repl_could_be_missing = true;
510: repl_missing = false;
1.17 deraadt 511: repl_backtrack_position = 0;
1.39 ! ajacouto 512: repl_patch_line = 0;
1.17 deraadt 513: ptrn_copiable = 0;
514:
515: ret = pgets(buf, sizeof buf, pfp);
516: p_input_line++;
1.21 otto 517: if (ret == NULL || strnNE(buf, "********", 8)) {
1.17 deraadt 518: next_intuit_at(line_beginning, p_input_line);
1.28 otto 519: return false;
1.17 deraadt 520: }
521: p_context = 100;
522: p_hunk_beg = p_input_line + 1;
523: while (p_end < p_max) {
524: line_beginning = ftell(pfp);
525: ret = pgets(buf, sizeof buf, pfp);
526: p_input_line++;
1.21 otto 527: if (ret == NULL) {
1.17 deraadt 528: if (p_max - p_end < 4) {
529: /* assume blank lines got chopped */
530: strlcpy(buf, " \n", sizeof buf);
531: } else {
532: if (repl_beginning && repl_could_be_missing) {
1.28 otto 533: repl_missing = true;
1.17 deraadt 534: goto hunk_done;
535: }
536: fatal("unexpected end of file in patch\n");
537: }
538: }
539: p_end++;
1.28 otto 540: if (p_end >= hunkmax)
541: fatal("Internal error: hunk larger than hunk "
1.29 deraadt 542: "buffer size");
1.17 deraadt 543: p_char[p_end] = *buf;
1.21 otto 544: p_line[p_end] = NULL;
1.17 deraadt 545: switch (*buf) {
546: case '*':
547: if (strnEQ(buf, "********", 8)) {
548: if (repl_beginning && repl_could_be_missing) {
1.28 otto 549: repl_missing = true;
1.17 deraadt 550: goto hunk_done;
551: } else
552: fatal("unexpected end of hunk "
553: "at line %ld\n",
554: p_input_line);
555: }
556: if (p_end != 0) {
557: if (repl_beginning && repl_could_be_missing) {
1.28 otto 558: repl_missing = true;
1.17 deraadt 559: goto hunk_done;
560: }
561: fatal("unexpected *** at line %ld: %s",
562: p_input_line, buf);
563: }
564: context = 0;
565: p_line[p_end] = savestr(buf);
566: if (out_of_mem) {
567: p_end--;
1.28 otto 568: return false;
1.17 deraadt 569: }
570: for (s = buf; *s && !isdigit(*s); s++)
571: ;
572: if (!*s)
573: malformed();
574: if (strnEQ(s, "0,0", 3))
575: memmove(s, s + 2, strlen(s + 2) + 1);
576: p_first = (LINENUM) atol(s);
577: while (isdigit(*s))
578: s++;
579: if (*s == ',') {
1.18 deraadt 580: for (; *s && !isdigit(*s); s++)
581: ;
1.17 deraadt 582: if (!*s)
583: malformed();
584: p_ptrn_lines = ((LINENUM) atol(s)) - p_first + 1;
585: } else if (p_first)
586: p_ptrn_lines = 1;
587: else {
588: p_ptrn_lines = 0;
589: p_first = 1;
590: }
1.26 deraadt 591:
592: /* we need this much at least */
593: p_max = p_ptrn_lines + 6;
1.17 deraadt 594: while (p_max >= hunkmax)
595: grow_hunkmax();
596: p_max = hunkmax;
597: break;
598: case '-':
599: if (buf[1] == '-') {
600: if (repl_beginning ||
601: (p_end != p_ptrn_lines + 1 +
602: (p_char[p_end - 1] == '\n'))) {
603: if (p_end == 1) {
604: /*
605: * `old' lines were omitted;
606: * set up to fill them in
607: * from 'new' context lines.
608: */
609: p_end = p_ptrn_lines + 1;
610: fillsrc = p_end + 1;
611: filldst = 1;
612: fillcnt = p_ptrn_lines;
613: } else {
614: if (repl_beginning) {
615: if (repl_could_be_missing) {
1.28 otto 616: repl_missing = true;
1.17 deraadt 617: goto hunk_done;
618: }
619: fatal("duplicate \"---\" at line %ld--check line numbers at line %ld\n",
620: p_input_line, p_hunk_beg + repl_beginning);
621: } else {
622: fatal("%s \"---\" at line %ld--check line numbers at line %ld\n",
623: (p_end <= p_ptrn_lines
624: ? "Premature"
625: : "Overdue"),
626: p_input_line, p_hunk_beg);
627: }
628: }
629: }
630: repl_beginning = p_end;
631: repl_backtrack_position = ftell(pfp);
632: repl_patch_line = p_input_line;
633: p_line[p_end] = savestr(buf);
634: if (out_of_mem) {
635: p_end--;
1.28 otto 636: return false;
1.17 deraadt 637: }
638: p_char[p_end] = '=';
639: for (s = buf; *s && !isdigit(*s); s++)
640: ;
641: if (!*s)
642: malformed();
643: p_newfirst = (LINENUM) atol(s);
644: while (isdigit(*s))
645: s++;
646: if (*s == ',') {
647: for (; *s && !isdigit(*s); s++)
648: ;
649: if (!*s)
650: malformed();
651: p_repl_lines = ((LINENUM) atol(s)) -
652: p_newfirst + 1;
653: } else if (p_newfirst)
654: p_repl_lines = 1;
655: else {
656: p_repl_lines = 0;
657: p_newfirst = 1;
658: }
659: p_max = p_repl_lines + p_end;
660: if (p_max > MAXHUNKSIZE)
661: fatal("hunk too large (%ld lines) at line %ld: %s",
662: p_max, p_input_line, buf);
663: while (p_max >= hunkmax)
664: grow_hunkmax();
665: if (p_repl_lines != ptrn_copiable &&
666: (p_context != 0 || p_repl_lines != 1))
1.28 otto 667: repl_could_be_missing = false;
1.17 deraadt 668: break;
669: }
670: goto change_line;
671: case '+':
672: case '!':
1.28 otto 673: repl_could_be_missing = false;
1.17 deraadt 674: change_line:
675: if (buf[1] == '\n' && canonicalize)
676: strlcpy(buf + 1, " \n", sizeof buf - 1);
677: if (!isspace(buf[1]) && buf[1] != '>' &&
678: buf[1] != '<' &&
679: repl_beginning && repl_could_be_missing) {
1.28 otto 680: repl_missing = true;
1.17 deraadt 681: goto hunk_done;
682: }
683: if (context >= 0) {
684: if (context < p_context)
685: p_context = context;
686: context = -1000;
687: }
688: p_line[p_end] = savestr(buf + 2);
689: if (out_of_mem) {
690: p_end--;
1.28 otto 691: return false;
1.17 deraadt 692: }
693: if (p_end == p_ptrn_lines) {
694: if (remove_special_line()) {
695: int len;
696:
697: len = strlen(p_line[p_end]) - 1;
698: (p_line[p_end])[len] = 0;
699: }
700: }
701: break;
702: case '\t':
703: case '\n': /* assume the 2 spaces got eaten */
704: if (repl_beginning && repl_could_be_missing &&
705: (!ptrn_spaces_eaten ||
706: diff_type == NEW_CONTEXT_DIFF)) {
1.28 otto 707: repl_missing = true;
1.17 deraadt 708: goto hunk_done;
709: }
710: p_line[p_end] = savestr(buf);
711: if (out_of_mem) {
712: p_end--;
1.28 otto 713: return false;
1.17 deraadt 714: }
715: if (p_end != p_ptrn_lines + 1) {
716: ptrn_spaces_eaten |= (repl_beginning != 0);
717: context++;
718: if (!repl_beginning)
719: ptrn_copiable++;
720: p_char[p_end] = ' ';
721: }
722: break;
723: case ' ':
724: if (!isspace(buf[1]) &&
1.23 deraadt 725: repl_beginning && repl_could_be_missing) {
1.28 otto 726: repl_missing = true;
1.17 deraadt 727: goto hunk_done;
728: }
729: context++;
730: if (!repl_beginning)
731: ptrn_copiable++;
732: p_line[p_end] = savestr(buf + 2);
733: if (out_of_mem) {
734: p_end--;
1.28 otto 735: return false;
1.17 deraadt 736: }
737: break;
738: default:
739: if (repl_beginning && repl_could_be_missing) {
1.28 otto 740: repl_missing = true;
1.17 deraadt 741: goto hunk_done;
742: }
743: malformed();
744: }
745: /* set up p_len for strncmp() so we don't have to */
746: /* assume null termination */
747: if (p_line[p_end])
748: p_len[p_end] = strlen(p_line[p_end]);
749: else
750: p_len[p_end] = 0;
751: }
752:
753: hunk_done:
754: if (p_end >= 0 && !repl_beginning)
755: fatal("no --- found in patch at line %ld\n", pch_hunk_beg());
756:
757: if (repl_missing) {
758:
759: /* reset state back to just after --- */
760: p_input_line = repl_patch_line;
761: for (p_end--; p_end > repl_beginning; p_end--)
762: free(p_line[p_end]);
1.21 otto 763: fseek(pfp, repl_backtrack_position, SEEK_SET);
1.17 deraadt 764:
765: /* redundant 'new' context lines were omitted - set */
766: /* up to fill them in from the old file context */
767: if (!p_context && p_repl_lines == 1) {
768: p_repl_lines = 0;
769: p_max--;
770: }
771: fillsrc = 1;
772: filldst = repl_beginning + 1;
773: fillcnt = p_repl_lines;
774: p_end = p_max;
775: } else if (!p_context && fillcnt == 1) {
776: /* the first hunk was a null hunk with no context */
777: /* and we were expecting one line -- fix it up. */
778: while (filldst < p_end) {
779: p_line[filldst] = p_line[filldst + 1];
780: p_char[filldst] = p_char[filldst + 1];
781: p_len[filldst] = p_len[filldst + 1];
782: filldst++;
783: }
784: #if 0
1.26 deraadt 785: repl_beginning--; /* this doesn't need to be fixed */
1.17 deraadt 786: #endif
787: p_end--;
788: p_first++; /* do append rather than insert */
789: fillcnt = 0;
790: p_ptrn_lines = 0;
791: }
792: if (diff_type == CONTEXT_DIFF &&
793: (fillcnt || (p_first > 1 && ptrn_copiable > 2 * p_context))) {
794: if (verbose)
795: say("%s\n%s\n%s\n",
796: "(Fascinating--this is really a new-style context diff but without",
797: "the telltale extra asterisks on the *** line that usually indicate",
798: "the new style...)");
799: diff_type = NEW_CONTEXT_DIFF;
800: }
801: /* if there were omitted context lines, fill them in now */
802: if (fillcnt) {
1.26 deraadt 803: p_bfake = filldst; /* remember where not to free() */
1.17 deraadt 804: p_efake = filldst + fillcnt - 1;
805: while (fillcnt-- > 0) {
806: while (fillsrc <= p_end && p_char[fillsrc] != ' ')
807: fillsrc++;
808: if (fillsrc > p_end)
809: fatal("replacement text or line numbers mangled in hunk at line %ld\n",
810: p_hunk_beg);
811: p_line[filldst] = p_line[fillsrc];
812: p_char[filldst] = p_char[fillsrc];
813: p_len[filldst] = p_len[fillsrc];
814: fillsrc++;
815: filldst++;
816: }
817: while (fillsrc <= p_end && fillsrc != repl_beginning &&
818: p_char[fillsrc] != ' ')
819: fillsrc++;
820: #ifdef DEBUGGING
821: if (debug & 64)
822: printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
823: fillsrc, filldst, repl_beginning, p_end + 1);
1.1 deraadt 824: #endif
1.28 otto 825: if (fillsrc != p_end + 1 && fillsrc != repl_beginning)
826: malformed();
827: if (filldst != p_end + 1 && filldst != repl_beginning)
828: malformed();
1.1 deraadt 829: }
1.17 deraadt 830: if (p_line[p_end] != NULL) {
831: if (remove_special_line()) {
832: p_len[p_end] -= 1;
833: (p_line[p_end])[p_len[p_end]] = 0;
834: }
835: }
836: } else if (diff_type == UNI_DIFF) {
837: long line_beginning = ftell(pfp); /* file pos of the current line */
838: LINENUM fillsrc; /* index of old lines */
839: LINENUM filldst; /* index of new lines */
840: char ch;
841:
842: ret = pgets(buf, sizeof buf, pfp);
843: p_input_line++;
1.21 otto 844: if (ret == NULL || strnNE(buf, "@@ -", 4)) {
1.17 deraadt 845: next_intuit_at(line_beginning, p_input_line);
1.28 otto 846: return false;
1.1 deraadt 847: }
1.17 deraadt 848: s = buf + 4;
1.1 deraadt 849: if (!*s)
1.17 deraadt 850: malformed();
1.1 deraadt 851: p_first = (LINENUM) atol(s);
1.17 deraadt 852: while (isdigit(*s))
853: s++;
854: if (*s == ',') {
855: p_ptrn_lines = (LINENUM) atol(++s);
856: while (isdigit(*s))
857: s++;
858: } else
859: p_ptrn_lines = 1;
860: if (*s == ' ')
861: s++;
862: if (*s != '+' || !*++s)
863: malformed();
864: p_newfirst = (LINENUM) atol(s);
865: while (isdigit(*s))
866: s++;
1.1 deraadt 867: if (*s == ',') {
1.17 deraadt 868: p_repl_lines = (LINENUM) atol(++s);
869: while (isdigit(*s))
870: s++;
871: } else
872: p_repl_lines = 1;
873: if (*s == ' ')
874: s++;
875: if (*s != '@')
876: malformed();
877: if (!p_ptrn_lines)
878: p_first++; /* do append rather than insert */
879: p_max = p_ptrn_lines + p_repl_lines + 1;
880: while (p_max >= hunkmax)
881: grow_hunkmax();
882: fillsrc = 1;
883: filldst = fillsrc + p_ptrn_lines;
884: p_end = filldst + p_repl_lines;
885: snprintf(buf, sizeof buf, "*** %ld,%ld ****\n", p_first,
1.26 deraadt 886: p_first + p_ptrn_lines - 1);
1.17 deraadt 887: p_line[0] = savestr(buf);
888: if (out_of_mem) {
889: p_end = -1;
1.28 otto 890: return false;
1.17 deraadt 891: }
892: p_char[0] = '*';
893: snprintf(buf, sizeof buf, "--- %ld,%ld ----\n", p_newfirst,
1.26 deraadt 894: p_newfirst + p_repl_lines - 1);
1.17 deraadt 895: p_line[filldst] = savestr(buf);
896: if (out_of_mem) {
897: p_end = 0;
1.28 otto 898: return false;
1.1 deraadt 899: }
1.17 deraadt 900: p_char[filldst++] = '=';
901: p_context = 100;
902: context = 0;
903: p_hunk_beg = p_input_line + 1;
904: while (fillsrc <= p_ptrn_lines || filldst <= p_end) {
905: line_beginning = ftell(pfp);
906: ret = pgets(buf, sizeof buf, pfp);
907: p_input_line++;
1.21 otto 908: if (ret == NULL) {
1.17 deraadt 909: if (p_max - filldst < 3) {
910: /* assume blank lines got chopped */
911: strlcpy(buf, " \n", sizeof buf);
912: } else {
913: fatal("unexpected end of file in patch\n");
914: }
915: }
916: if (*buf == '\t' || *buf == '\n') {
917: ch = ' '; /* assume the space got eaten */
918: s = savestr(buf);
919: } else {
920: ch = *buf;
921: s = savestr(buf + 1);
922: }
923: if (out_of_mem) {
924: while (--filldst > p_ptrn_lines)
925: free(p_line[filldst]);
926: p_end = fillsrc - 1;
1.28 otto 927: return false;
1.17 deraadt 928: }
929: switch (ch) {
930: case '-':
931: if (fillsrc > p_ptrn_lines) {
932: free(s);
933: p_end = filldst - 1;
934: malformed();
935: }
936: p_char[fillsrc] = ch;
937: p_line[fillsrc] = s;
938: p_len[fillsrc++] = strlen(s);
939: if (fillsrc > p_ptrn_lines) {
940: if (remove_special_line()) {
941: p_len[fillsrc - 1] -= 1;
942: s[p_len[fillsrc - 1]] = 0;
943: }
944: }
945: break;
946: case '=':
947: ch = ' ';
948: /* FALL THROUGH */
949: case ' ':
950: if (fillsrc > p_ptrn_lines) {
951: free(s);
952: while (--filldst > p_ptrn_lines)
953: free(p_line[filldst]);
954: p_end = fillsrc - 1;
955: malformed();
956: }
957: context++;
958: p_char[fillsrc] = ch;
959: p_line[fillsrc] = s;
960: p_len[fillsrc++] = strlen(s);
961: s = savestr(s);
962: if (out_of_mem) {
963: while (--filldst > p_ptrn_lines)
964: free(p_line[filldst]);
965: p_end = fillsrc - 1;
1.28 otto 966: return false;
1.34 otto 967: }
968: if (fillsrc > p_ptrn_lines) {
969: if (remove_special_line()) {
970: p_len[fillsrc - 1] -= 1;
971: s[p_len[fillsrc - 1]] = 0;
972: }
1.17 deraadt 973: }
974: /* FALL THROUGH */
975: case '+':
976: if (filldst > p_end) {
977: free(s);
978: while (--filldst > p_ptrn_lines)
979: free(p_line[filldst]);
980: p_end = fillsrc - 1;
981: malformed();
982: }
983: p_char[filldst] = ch;
984: p_line[filldst] = s;
985: p_len[filldst++] = strlen(s);
986: if (fillsrc > p_ptrn_lines) {
987: if (remove_special_line()) {
988: p_len[filldst - 1] -= 1;
989: s[p_len[filldst - 1]] = 0;
990: }
991: }
992: break;
993: default:
994: p_end = filldst;
995: malformed();
1.1 deraadt 996: }
1.17 deraadt 997: if (ch != ' ' && context > 0) {
998: if (context < p_context)
999: p_context = context;
1000: context = -1000;
1.1 deraadt 1001: }
1.17 deraadt 1002: } /* while */
1003: } else { /* normal diff--fake it up */
1004: char hunk_type;
1005: int i;
1006: LINENUM min, max;
1007: long line_beginning = ftell(pfp);
1008:
1009: p_context = 0;
1010: ret = pgets(buf, sizeof buf, pfp);
1011: p_input_line++;
1.21 otto 1012: if (ret == NULL || !isdigit(*buf)) {
1.17 deraadt 1013: next_intuit_at(line_beginning, p_input_line);
1.28 otto 1014: return false;
1.17 deraadt 1015: }
1016: p_first = (LINENUM) atol(buf);
1.18 deraadt 1017: for (s = buf; isdigit(*s); s++)
1018: ;
1.17 deraadt 1019: if (*s == ',') {
1020: p_ptrn_lines = (LINENUM) atol(++s) - p_first + 1;
1021: while (isdigit(*s))
1022: s++;
1023: } else
1024: p_ptrn_lines = (*s != 'a');
1025: hunk_type = *s;
1026: if (hunk_type == 'a')
1027: p_first++; /* do append rather than insert */
1028: min = (LINENUM) atol(++s);
1.18 deraadt 1029: for (; isdigit(*s); s++)
1030: ;
1.17 deraadt 1031: if (*s == ',')
1032: max = (LINENUM) atol(++s);
1033: else
1034: max = min;
1035: if (hunk_type == 'd')
1036: min++;
1037: p_end = p_ptrn_lines + 1 + max - min + 1;
1038: if (p_end > MAXHUNKSIZE)
1.16 deraadt 1039: fatal("hunk too large (%ld lines) at line %ld: %s",
1.17 deraadt 1040: p_end, p_input_line, buf);
1041: while (p_end >= hunkmax)
1.1 deraadt 1042: grow_hunkmax();
1.17 deraadt 1043: p_newfirst = min;
1044: p_repl_lines = max - min + 1;
1045: snprintf(buf, sizeof buf, "*** %ld,%ld\n", p_first,
1.26 deraadt 1046: p_first + p_ptrn_lines - 1);
1.17 deraadt 1047: p_line[0] = savestr(buf);
1.1 deraadt 1048: if (out_of_mem) {
1.17 deraadt 1049: p_end = -1;
1.28 otto 1050: return false;
1.1 deraadt 1051: }
1.17 deraadt 1052: p_char[0] = '*';
1053: for (i = 1; i <= p_ptrn_lines; i++) {
1054: ret = pgets(buf, sizeof buf, pfp);
1055: p_input_line++;
1.21 otto 1056: if (ret == NULL)
1.17 deraadt 1057: fatal("unexpected end of file in patch at line %ld\n",
1058: p_input_line);
1059: if (*buf != '<')
1060: fatal("< expected at line %ld of patch\n",
1061: p_input_line);
1062: p_line[i] = savestr(buf + 2);
1063: if (out_of_mem) {
1064: p_end = i - 1;
1.28 otto 1065: return false;
1.14 otto 1066: }
1.17 deraadt 1067: p_len[i] = strlen(p_line[i]);
1068: p_char[i] = '-';
1.14 otto 1069: }
1.17 deraadt 1070:
1071: if (remove_special_line()) {
1072: p_len[i - 1] -= 1;
1073: (p_line[i - 1])[p_len[i - 1]] = 0;
1.1 deraadt 1074: }
1.17 deraadt 1075: if (hunk_type == 'c') {
1076: ret = pgets(buf, sizeof buf, pfp);
1077: p_input_line++;
1.21 otto 1078: if (ret == NULL)
1.17 deraadt 1079: fatal("unexpected end of file in patch at line %ld\n",
1080: p_input_line);
1081: if (*buf != '-')
1082: fatal("--- expected at line %ld of patch\n",
1083: p_input_line);
1.1 deraadt 1084: }
1.17 deraadt 1085: snprintf(buf, sizeof(buf), "--- %ld,%ld\n", min, max);
1086: p_line[i] = savestr(buf);
1.1 deraadt 1087: if (out_of_mem) {
1.17 deraadt 1088: p_end = i - 1;
1.28 otto 1089: return false;
1.1 deraadt 1090: }
1.17 deraadt 1091: p_char[i] = '=';
1092: for (i++; i <= p_end; i++) {
1093: ret = pgets(buf, sizeof buf, pfp);
1094: p_input_line++;
1.21 otto 1095: if (ret == NULL)
1.17 deraadt 1096: fatal("unexpected end of file in patch at line %ld\n",
1097: p_input_line);
1098: if (*buf != '>')
1099: fatal("> expected at line %ld of patch\n",
1100: p_input_line);
1101: p_line[i] = savestr(buf + 2);
1102: if (out_of_mem) {
1103: p_end = i - 1;
1.28 otto 1104: return false;
1.14 otto 1105: }
1.17 deraadt 1106: p_len[i] = strlen(p_line[i]);
1107: p_char[i] = '+';
1.14 otto 1108: }
1.17 deraadt 1109:
1110: if (remove_special_line()) {
1111: p_len[i - 1] -= 1;
1112: (p_line[i - 1])[p_len[i - 1]] = 0;
1.14 otto 1113: }
1.1 deraadt 1114: }
1.17 deraadt 1115: if (reverse) /* backwards patch? */
1116: if (!pch_swap())
1117: say("Not enough memory to swap next hunk!\n");
1.1 deraadt 1118: #ifdef DEBUGGING
1.17 deraadt 1119: if (debug & 2) {
1120: int i;
1121: char special;
1122:
1123: for (i = 0; i <= p_end; i++) {
1124: if (i == p_ptrn_lines)
1125: special = '^';
1126: else
1127: special = ' ';
1128: fprintf(stderr, "%3d %c %c %s", i, p_char[i],
1129: special, p_line[i]);
1130: fflush(stderr);
1131: }
1.1 deraadt 1132: }
1133: #endif
1.17 deraadt 1134: if (p_end + 1 < hunkmax)/* paranoia reigns supreme... */
1135: p_char[p_end + 1] = '^'; /* add a stopper for apply_hunk */
1.28 otto 1136: return true;
1.1 deraadt 1137: }
1138:
1.17 deraadt 1139: /*
1140: * Input a line from the patch file, worrying about indentation.
1141: */
1.21 otto 1142: static char *
1.17 deraadt 1143: pgets(char *bf, int sz, FILE *fp)
1144: {
1145: char *s, *ret = fgets(bf, sz, fp);
1146: int indent = 0;
1.1 deraadt 1147:
1.21 otto 1148: if (p_indent && ret != NULL) {
1.17 deraadt 1149: for (s = buf;
1150: indent < p_indent && (*s == ' ' || *s == '\t' || *s == 'X');
1151: s++) {
1152: if (*s == '\t')
1153: indent += 8 - (indent % 7);
1154: else
1155: indent++;
1156: }
1157: if (buf != s && strlcpy(buf, s, sizeof(buf)) >= sizeof(buf))
1158: fatal("buffer too small in pgets()\n");
1159: }
1160: return ret;
1.1 deraadt 1161: }
1162:
1.17 deraadt 1163: /*
1164: * Reverse the old and new portions of the current hunk.
1165: */
1.1 deraadt 1166: bool
1.17 deraadt 1167: pch_swap(void)
1.1 deraadt 1168: {
1.17 deraadt 1169: char **tp_line; /* the text of the hunk */
1170: short *tp_len; /* length of each line */
1171: char *tp_char; /* +, -, and ! */
1172: LINENUM i;
1173: LINENUM n;
1.28 otto 1174: bool blankline = false;
1.17 deraadt 1175: char *s;
1176:
1177: i = p_first;
1178: p_first = p_newfirst;
1179: p_newfirst = i;
1180:
1181: /* make a scratch copy */
1182:
1183: tp_line = p_line;
1184: tp_len = p_len;
1185: tp_char = p_char;
1.21 otto 1186: p_line = NULL; /* force set_hunkmax to allocate again */
1187: p_len = NULL;
1188: p_char = NULL;
1.17 deraadt 1189: set_hunkmax();
1.28 otto 1190: if (p_line == NULL || p_len == NULL || p_char == NULL) {
1.21 otto 1191:
1.28 otto 1192: free(p_line);
1.17 deraadt 1193: p_line = tp_line;
1.28 otto 1194: free(p_len);
1.17 deraadt 1195: p_len = tp_len;
1.28 otto 1196: free(p_char);
1.17 deraadt 1197: p_char = tp_char;
1.28 otto 1198: return false; /* not enough memory to swap hunk! */
1.17 deraadt 1199: }
1200: /* now turn the new into the old */
1201:
1.1 deraadt 1202: i = p_ptrn_lines + 1;
1.17 deraadt 1203: if (tp_char[i] == '\n') { /* account for possible blank line */
1.28 otto 1204: blankline = true;
1.17 deraadt 1205: i++;
1206: }
1207: if (p_efake >= 0) { /* fix non-freeable ptr range */
1208: if (p_efake <= i)
1209: n = p_end - i + 1;
1210: else
1211: n = -i;
1212: p_efake += n;
1213: p_bfake += n;
1214: }
1215: for (n = 0; i <= p_end; i++, n++) {
1216: p_line[n] = tp_line[i];
1217: p_char[n] = tp_char[i];
1218: if (p_char[n] == '+')
1219: p_char[n] = '-';
1220: p_len[n] = tp_len[i];
1221: }
1222: if (blankline) {
1223: i = p_ptrn_lines + 1;
1224: p_line[n] = tp_line[i];
1225: p_char[n] = tp_char[i];
1226: p_len[n] = tp_len[i];
1227: n++;
1228: }
1.28 otto 1229: if (p_char[0] != '=')
1.29 deraadt 1230: fatal("Malformed patch at line %ld: expected '=' found '%c'\n",
1.28 otto 1231: p_input_line, p_char[0]);
1.17 deraadt 1232: p_char[0] = '*';
1233: for (s = p_line[0]; *s; s++)
1234: if (*s == '-')
1235: *s = '*';
1236:
1237: /* now turn the old into the new */
1238:
1.28 otto 1239: if (p_char[0] != '*')
1.29 deraadt 1240: fatal("Malformed patch at line %ld: expected '*' found '%c'\n",
1241: p_input_line, p_char[0]);
1.17 deraadt 1242: tp_char[0] = '=';
1243: for (s = tp_line[0]; *s; s++)
1244: if (*s == '*')
1245: *s = '-';
1246: for (i = 0; n <= p_end; i++, n++) {
1247: p_line[n] = tp_line[i];
1248: p_char[n] = tp_char[i];
1249: if (p_char[n] == '-')
1250: p_char[n] = '+';
1251: p_len[n] = tp_len[i];
1252: }
1.28 otto 1253:
1254: if (i != p_ptrn_lines + 1)
1255: fatal("Malformed patch at line %ld: expected %ld lines, "
1.29 deraadt 1256: "got %ld\n",
1257: p_input_line, p_ptrn_lines + 1, i);
1.28 otto 1258:
1.17 deraadt 1259: i = p_ptrn_lines;
1260: p_ptrn_lines = p_repl_lines;
1261: p_repl_lines = i;
1.21 otto 1262:
1.28 otto 1263: free(tp_line);
1264: free(tp_len);
1265: free(tp_char);
1266:
1267: return true;
1.1 deraadt 1268: }
1269:
1.17 deraadt 1270: /*
1271: * Return the specified line position in the old file of the old context.
1272: */
1.1 deraadt 1273: LINENUM
1.17 deraadt 1274: pch_first(void)
1.1 deraadt 1275: {
1.17 deraadt 1276: return p_first;
1.1 deraadt 1277: }
1278:
1.17 deraadt 1279: /*
1280: * Return the number of lines of old context.
1281: */
1.1 deraadt 1282: LINENUM
1.17 deraadt 1283: pch_ptrn_lines(void)
1.1 deraadt 1284: {
1.17 deraadt 1285: return p_ptrn_lines;
1.1 deraadt 1286: }
1287:
1.17 deraadt 1288: /*
1289: * Return the probable line position in the new file of the first line.
1290: */
1.1 deraadt 1291: LINENUM
1.17 deraadt 1292: pch_newfirst(void)
1.1 deraadt 1293: {
1.17 deraadt 1294: return p_newfirst;
1.1 deraadt 1295: }
1296:
1.17 deraadt 1297: /*
1298: * Return the number of lines in the replacement text including context.
1299: */
1.1 deraadt 1300: LINENUM
1.17 deraadt 1301: pch_repl_lines(void)
1.1 deraadt 1302: {
1.17 deraadt 1303: return p_repl_lines;
1.1 deraadt 1304: }
1305:
1.17 deraadt 1306: /*
1307: * Return the number of lines in the whole hunk.
1308: */
1.1 deraadt 1309: LINENUM
1.17 deraadt 1310: pch_end(void)
1.1 deraadt 1311: {
1.17 deraadt 1312: return p_end;
1.1 deraadt 1313: }
1314:
1.17 deraadt 1315: /*
1316: * Return the number of context lines before the first changed line.
1317: */
1.1 deraadt 1318: LINENUM
1.17 deraadt 1319: pch_context(void)
1.1 deraadt 1320: {
1.17 deraadt 1321: return p_context;
1.1 deraadt 1322: }
1323:
1.17 deraadt 1324: /*
1325: * Return the length of a particular patch line.
1326: */
1.1 deraadt 1327: short
1.17 deraadt 1328: pch_line_len(LINENUM line)
1.1 deraadt 1329: {
1.17 deraadt 1330: return p_len[line];
1.1 deraadt 1331: }
1332:
1.17 deraadt 1333: /*
1334: * Return the control character (+, -, *, !, etc) for a patch line.
1335: */
1.1 deraadt 1336: char
1.17 deraadt 1337: pch_char(LINENUM line)
1.1 deraadt 1338: {
1.17 deraadt 1339: return p_char[line];
1.1 deraadt 1340: }
1341:
1.17 deraadt 1342: /*
1343: * Return a pointer to a particular patch line.
1344: */
1.1 deraadt 1345: char *
1.17 deraadt 1346: pfetch(LINENUM line)
1.1 deraadt 1347: {
1.17 deraadt 1348: return p_line[line];
1.1 deraadt 1349: }
1350:
1.17 deraadt 1351: /*
1352: * Return where in the patch file this hunk began, for error messages.
1353: */
1.1 deraadt 1354: LINENUM
1.17 deraadt 1355: pch_hunk_beg(void)
1.1 deraadt 1356: {
1.17 deraadt 1357: return p_hunk_beg;
1.1 deraadt 1358: }
1359:
1.17 deraadt 1360: /*
1361: * Apply an ed script by feeding ed itself.
1362: */
1.1 deraadt 1363: void
1.17 deraadt 1364: do_ed_script(void)
1.1 deraadt 1365: {
1.17 deraadt 1366: char *t;
1367: long beginning_of_this_line;
1.36 otto 1368: FILE *pipefp = NULL;
1.17 deraadt 1369:
1370: if (!skip_rest_of_patch) {
1.24 millert 1371: if (copy_file(filearg[0], TMPOUTNAME) < 0) {
1372: unlink(TMPOUTNAME);
1373: fatal("can't create temp file %s", TMPOUTNAME);
1374: }
1.27 millert 1375: snprintf(buf, sizeof buf, "%s%s%s", _PATH_ED,
1376: verbose ? " " : " -s ", TMPOUTNAME);
1.17 deraadt 1377: pipefp = popen(buf, "w");
1378: }
1379: for (;;) {
1380: beginning_of_this_line = ftell(pfp);
1.21 otto 1381: if (pgets(buf, sizeof buf, pfp) == NULL) {
1.17 deraadt 1382: next_intuit_at(beginning_of_this_line, p_input_line);
1383: break;
1384: }
1385: p_input_line++;
1.18 deraadt 1386: for (t = buf; isdigit(*t) || *t == ','; t++)
1387: ;
1.22 millert 1388: /* POSIX defines allowed commands as {a,c,d,i,s} */
1389: if (isdigit(*buf) && (*t == 'a' || *t == 'c' || *t == 'd' ||
1390: *t == 'i' || *t == 's')) {
1.28 otto 1391: if (pipefp != NULL)
1.17 deraadt 1392: fputs(buf, pipefp);
1393: if (*t != 'd') {
1.21 otto 1394: while (pgets(buf, sizeof buf, pfp) != NULL) {
1.17 deraadt 1395: p_input_line++;
1.28 otto 1396: if (pipefp != NULL)
1.17 deraadt 1397: fputs(buf, pipefp);
1398: if (strEQ(buf, ".\n"))
1399: break;
1400: }
1401: }
1402: } else {
1403: next_intuit_at(beginning_of_this_line, p_input_line);
1.1 deraadt 1404: break;
1405: }
1406: }
1.28 otto 1407: if (pipefp == NULL)
1.17 deraadt 1408: return;
1409: fprintf(pipefp, "w\n");
1410: fprintf(pipefp, "q\n");
1411: fflush(pipefp);
1412: pclose(pipefp);
1413: ignore_signals();
1414: if (!check_only) {
1415: if (move_file(TMPOUTNAME, outname) < 0) {
1.28 otto 1416: toutkeep = true;
1.17 deraadt 1417: chmod(TMPOUTNAME, filemode);
1418: } else
1419: chmod(outname, filemode);
1.1 deraadt 1420: }
1.17 deraadt 1421: set_signals(1);
1.32 millert 1422: }
1423:
1424: /*
1425: * Choose the name of the file to be patched based on POSIX rules.
1426: * NOTE: the POSIX rules are amazingly stupid and we only follow them
1427: * if the user specified --posix or set POSIXLY_CORRECT.
1428: */
1429: static char *
1430: posix_name(const struct file_name *names, bool assume_exists)
1431: {
1432: char *path = NULL;
1433: int i;
1434:
1435: /*
1436: * POSIX states that the filename will be chosen from one
1437: * of the old, new and index names (in that order) if
1438: * the file exists relative to CWD after -p stripping.
1439: */
1440: for (i = 0; i < MAX_FILE; i++) {
1441: if (names[i].path != NULL && names[i].exists) {
1442: path = names[i].path;
1443: break;
1444: }
1445: }
1446: if (path == NULL && !assume_exists) {
1447: /*
1448: * No files found, look for something we can checkout from
1449: * RCS/SCCS dirs. Same order as above.
1450: */
1451: for (i = 0; i < MAX_FILE; i++) {
1452: if (names[i].path != NULL &&
1453: (path = checked_in(names[i].path)) != NULL)
1454: break;
1455: }
1456: /*
1457: * Still no match? Check to see if the diff could be creating
1458: * a new file.
1459: */
1460: if (path == NULL && ok_to_create_file &&
1461: names[NEW_FILE].path != NULL)
1462: path = names[NEW_FILE].path;
1463: }
1464:
1465: return path ? savestr(path) : NULL;
1466: }
1467:
1468: /*
1469: * Choose the name of the file to be patched based the "best" one
1470: * available.
1471: */
1472: static char *
1473: best_name(const struct file_name *names, bool assume_exists)
1474: {
1475: size_t min_components, min_baselen, min_len, tmp;
1476: char *best = NULL;
1477: int i;
1478:
1479: /*
1480: * The "best" name is the one with the fewest number of path
1481: * components, the shortest basename length, and the shortest
1482: * overall length (in that order). We only use the Index: file
1483: * if neither of the old or new files could be intuited from
1484: * the diff header.
1485: */
1486: min_components = min_baselen = min_len = SIZE_MAX;
1487: for (i = INDEX_FILE; i >= OLD_FILE; i--) {
1488: if (names[i].path == NULL ||
1489: (!names[i].exists && !assume_exists))
1490: continue;
1491: if ((tmp = num_components(names[i].path)) > min_components)
1492: continue;
1493: min_components = tmp;
1494: if ((tmp = strlen(basename(names[i].path))) > min_baselen)
1495: continue;
1496: min_baselen = tmp;
1497: if ((tmp = strlen(names[i].path)) > min_len)
1498: continue;
1499: min_len = tmp;
1500: best = names[i].path;
1501: }
1502: if (best == NULL) {
1503: /*
1504: * No files found, look for something we can checkout from
1505: * RCS/SCCS dirs. Logic is identical to that above...
1506: */
1507: min_components = min_baselen = min_len = SIZE_MAX;
1508: for (i = INDEX_FILE; i >= OLD_FILE; i--) {
1509: if (names[i].path == NULL ||
1510: checked_in(names[i].path) == NULL)
1511: continue;
1512: if ((tmp = num_components(names[i].path)) > min_components)
1513: continue;
1514: min_components = tmp;
1515: if ((tmp = strlen(basename(names[i].path))) > min_baselen)
1516: continue;
1517: min_baselen = tmp;
1518: if ((tmp = strlen(names[i].path)) > min_len)
1519: continue;
1520: min_len = tmp;
1521: best = names[i].path;
1522: }
1523: /*
1524: * Still no match? Check to see if the diff could be creating
1525: * a new file.
1526: */
1527: if (best == NULL && ok_to_create_file &&
1528: names[NEW_FILE].path != NULL)
1529: best = names[NEW_FILE].path;
1530: }
1531:
1532: return best ? savestr(best) : NULL;
1533: }
1534:
1535: static size_t
1536: num_components(const char *path)
1537: {
1538: size_t n;
1539: const char *cp;
1540:
1541: for (n = 0, cp = path; (cp = strchr(cp, '/')) != NULL; n++, cp++) {
1542: while (*cp == '/')
1543: cp++; /* skip consecutive slashes */
1544: }
1545: return n;
1.1 deraadt 1546: }