Don't allow a configure file which is writeable by the Exim user or group
[exim.git] / test / src / cf.c
1 /* $Cambridge: exim/test/src/cf.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */
2
3 /************************************************
4 *                  PH-Compare                   *
5 ************************************************/
6
7 /* A program to compare two files line by line.
8
9 History:
10
11 It was originally written in C, but the C under
12 Panos is still a shambles (1986). Translated therefore
13 to BCPL -- this explains some of the odd style.
14
15 Modified to run on Archimedes, August 1987.
16 Modified to run under MSDOS, March 1989.
17 Modified to run under CINTERP interpreter, July 1989.
18 Modified to run under Unix, October 1989.
19
20 Translated back into C, March 1990! */
21
22 /* Copyright (c) 1986, 1987, 1989, 1990, 1994, 2001 by Philip Hazel */
23
24 /* Previously modified: October 1994*/
25 /* Last modified: September 2001 - a long-lived bug fixed! */
26
27
28 #include <stdio.h>
29 #include <errno.h>
30
31 #ifdef __STDC__
32 #include <string.h>
33 #include <stdlib.h>
34 #endif
35
36 /* ----- parameters ----- */
37
38 #define version            8
39 #define defaultstore  100000     /* default recovery buffer size */
40 #define minstore         500     /* minimum recovery buffer size */
41
42 /* ----- misc defines ----- */
43
44 #define FALSE 0
45 #define TRUE  1
46
47 #ifdef __STDC__
48 #define pvoid     void
49 #else
50 #define pvoid
51 #endif
52
53 #define EqString(s, t)   (strcmp(s, t) == 0)
54
55 /* ----- line structure ----- */
56
57 typedef struct line {
58   struct line *next;
59   int  number;
60   char text[999999];
61 } line;
62
63
64 /* ----- global variables ----- */
65
66 FILE *f_one;           /* files */
67 FILE *f_two;
68 FILE *f_out;
69
70 int lines_one = 0;            /* line counts */
71 int lines_two = 0;
72 int return_code = 0;
73 int eof_one = FALSE;          /* eof flags */
74 int eof_two = FALSE;
75 int exact = FALSE;            /* TRUE => no strip spaces */
76 int echo = TRUE;              /* TRUE => show mismatched lines */
77 int sync_count = 3;           /* resync count */
78 int storesize = defaultstore; /* size of each buffer */
79
80 char *name_one = NULL;        /* file names */
81 char *name_two = NULL;
82 char *to_name = NULL;
83
84 char *bufbase_one;            /* start buffer */
85 char *bufbase_two;
86 char *bufnext_one;            /* next free byte */
87 char *bufnext_two;
88 char *buftop_one;             /* end buffer */
89 char *buftop_two;
90
91 line *rootline_one;           /* mis-match point */
92 line *rootline_two;
93 line *lastline_one;           /* last in store */
94 line *lastline_two;
95 line *pline_one;              /* working line */
96 line *pline_two;
97
98
99 /*************************************************
100 *             Help Information                   *
101 *************************************************/
102
103 void givehelp(pvoid)
104 {
105 printf("PH's CMP v%d\n", version);
106 printf("Keywords:\n");
107 printf("       <file>    ) files to compare\n");
108 printf("       <file>    ) no keywords used\n");
109 printf("-to    <file>      output destination\n");
110 printf("-exact             include trailing spaces & match tabs\n");
111 printf("-noecho            don't echo differences (just give line numbers)\n");
112 printf("-s, -sync  <n>     set re-sync count, default 3\n");
113 printf("-buffer <n>        buffer size (for each file) default 100000\n");
114 printf("-id                give program version id\n");
115 printf("-h, -help          give this help\n");
116 printf("\nExamples:\n");
117 printf("cmp old.f77 new.f77\n");
118 printf("cmp first second -noecho -sync 1\n");
119 printf("cmp large1 large2 -buffer 200000 -noecho -to diffs\n");
120 }
121
122
123
124 /************************************************
125 *               Errors -- all serious           *
126 ************************************************/
127
128 void moan(code, text)
129 int code;
130 char *text;
131 {
132 fprintf(stderr, "\n** ");
133 switch (code)
134   {
135   case 1:
136   fprintf(stderr, "Unable to open file \"%s\"", text);
137   if (errno)
138     {
139     fprintf(stderr, " - ");
140     perror(NULL);
141     }
142   else fprintf(stderr, "\n");
143   break;
144
145   case 2:
146   fprintf(stderr, "Buffer overflow for file \"%s\"\n", text);
147   break;
148
149   case 3:
150   fprintf(stderr, "Two file names must be given\n");
151   break;
152
153   default:
154   fprintf(stderr, "Unknown error %d\n", code);
155   break;
156   }
157
158 fprintf(stderr, "** CMP abandoned\n");
159 exit(99);
160 }
161
162
163
164 /*************************************************
165 *         Write line identification              *
166 *************************************************/
167
168 void write_id(n1, n2, c, name, p1, p2)
169 int n1, n2, c;
170 char *name, *p1, *p2;
171 {
172 if (n2 < 0) n2 = -n2;
173 n2 -= 1;
174 fprintf(f_out, "%cine", c);
175 if (n1 == n2) fprintf(f_out, " %d of \"%s\"%s", n1, name, p1);
176   else fprintf(f_out, "s %d-%d of \"%s\"%s", n1, n2, name, p2);
177 }
178
179
180 /*************************************************
181 *           Write sequence of lines              *
182 *************************************************/
183
184 void write_lines(s, t)
185 line *s, *t;
186 {
187 while (s != t)
188   {
189   char *p = s->text;
190   while (*p != '\n') fputc(*p++, f_out);
191   fputc('\n', f_out);
192   s = s->next;
193   }
194 }
195
196
197
198 /*************************************************
199 *           Write separator rule                 *
200 *************************************************/
201
202 void rule(s, l)
203 int s, l;
204 {
205 while (l-- > 0) fprintf(f_out, "%c", s);
206 fprintf(f_out, "\n");
207 }
208
209
210
211 /*************************************************
212 *          Write message on re-sync or eof       *
213 *************************************************/
214
215 void write_message(tline_one, tline_two)
216 line *tline_one, *tline_two;
217 {
218 int s1 = rootline_one->number;
219 int t1 = tline_one->number;
220 int s2 = rootline_two->number;
221 int t2 = tline_two->number;
222 if (echo) rule('=', 15);
223
224 if (s1 == t1)
225   {
226   write_id(s2, t2, 'L', name_two, " occurs ", " occur ");
227   if (s1 < 0) fprintf(f_out, "at the end");
228     else fprintf(f_out, "before line %d", s1);
229   fprintf(f_out, " of \"%s\".\n", name_one);
230   if (echo)
231     {
232     rule('-', 10);
233     write_lines(rootline_two, tline_two);
234     }
235   }
236
237 else if (s2 == t2)
238   {
239   write_id(s1, t1, 'L', name_one, " occurs ", " occur ");
240   if (s2 < 0) fprintf(f_out, "at the end");
241     else fprintf(f_out, "before line %d", s2);
242   fprintf(f_out, " of \"%s\".\n", name_two);
243   if (echo)
244     {
245     rule('-', 10);
246     write_lines(rootline_one, tline_one);
247     }
248   }
249
250 else if (t1 < 0 && t2 < 0)
251   {
252   fprintf(f_out, "From line %d of \"%s\" and line %d of \"%s\" ",
253     rootline_one->number, name_one, rootline_two->number, name_two);
254   fprintf(f_out, "the files are different.\n");
255   if (echo)
256     {
257     rule('-', 10);
258     if (-t1-s1 < 21) write_lines(rootline_one, tline_one);
259       else fprintf(f_out, "... <more than 20 lines> ...\n");
260     rule('-', 10);
261     if (-t2-s2 < 21) write_lines(rootline_two, tline_two);
262       else fprintf(f_out, "... <more than 20 lines> ...\n");
263     }
264   }
265
266 else
267   {
268   write_id(s1, t1, 'L', name_one, " does ", " do ");
269   fprintf(f_out, "not match ");
270   write_id(s2, t2, 'l', name_two, ".\n", ".\n");
271   if (echo)
272     {
273     rule('-', 10);
274     write_lines(rootline_one, tline_one);
275     rule('-', 10);
276     write_lines(rootline_two, tline_two);
277     }
278   }
279 }
280
281
282
283
284 /*************************************************
285 *           Advance to next line in store        *
286 *************************************************/
287
288 /* A separate procedure exists for each file, for
289 simplicity and efficiency. */
290
291 int nextline_one(pvoid)
292 {
293 if (pline_one == NULL || pline_one->next == NULL) return FALSE;
294 pline_one = pline_one->next;
295 return TRUE;
296 }
297
298 int nextline_two(pvoid)
299 {
300 if (pline_two == NULL || pline_two->next == NULL) return FALSE;
301 pline_two = pline_two->next;
302 return TRUE;
303 }
304
305
306 /*************************************************
307 *             Read a line into store             *
308 *************************************************/
309
310 /* A separate procedure exists for each file, for
311 simplicity and efficiency. */
312
313 void readline_one(pvoid)
314 {
315 int count = 0;
316 int c = fgetc(f_one);
317 line *nextline = (line *)bufnext_one;
318
319 bufnext_one = nextline->text;
320 if (bufnext_one >= buftop_one) moan(2, name_one);
321
322 nextline->next = NULL;
323
324 lines_one ++;
325 if (c == EOF)
326   {
327   eof_one = TRUE;
328   nextline->number = -lines_one;
329   }
330 else
331   {
332   nextline->number = lines_one;
333   for (;;)
334     {
335     if (c == EOF) c = '\n';
336     if (c == '\n')
337       {
338       if (!exact)
339         while (bufnext_one > nextline->text)
340           { if (bufnext_one[-1] == ' ') bufnext_one--; else break; }
341       *(bufnext_one++) = '\n';
342       if (bufnext_one >= buftop_one) moan(2, name_one);
343       break;
344       }
345     if (c == '\t' && !exact)
346       do { *(bufnext_one++) = ' '; count++; } while ((count & 7) != 0);
347     else { *(bufnext_one++) = c; count++; }
348     if (bufnext_one >= buftop_one) moan(2, name_one);
349     c = fgetc(f_one);
350     }
351   }
352
353 if (lastline_one != NULL) lastline_one->next = nextline;
354 lastline_one = nextline;
355 pline_one = nextline;
356
357 bufnext_one = (char *) (((int)bufnext_one+3) & (-4));
358 }
359
360
361
362 void readline_two(pvoid)
363 {
364 int count = 0;
365 int c = fgetc(f_two);
366 line *nextline = (line *)bufnext_two;
367
368 bufnext_two = nextline->text;
369 if (bufnext_two >= buftop_two) moan(2, name_two);
370
371 nextline->next = NULL;
372
373 lines_two ++;
374 if (c == EOF)
375   {
376   eof_two = TRUE;
377   nextline->number = -lines_two;
378   }
379 else
380   {
381   nextline->number = lines_two;
382   for (;;)
383     {
384     if (c == EOF) c = '\n';
385     if (c == '\n')
386       {
387       if (!exact)
388         while (bufnext_two > nextline->text)
389           { if (bufnext_two[-1] == ' ') bufnext_two--; else break; }
390       *(bufnext_two++) = '\n';
391       if (bufnext_two >= buftop_two) moan(2, name_two);
392       break;
393       }
394     if (c == '\t' && !exact)
395       do { *(bufnext_two++) = ' '; count++; } while ((count & 7) != 0);
396     else { *(bufnext_two++) = c; count++; }
397     if (bufnext_two >= buftop_two) moan(2, name_two);
398     c = fgetc(f_two);
399     }
400   }
401
402 if (lastline_two != NULL) lastline_two->next = nextline;
403 lastline_two = nextline;
404 pline_two = nextline;
405
406 bufnext_two = (char *) (((int)bufnext_two+3) & (-4));
407 }
408
409
410
411 /**************************************************
412 *              Compare two lines                  *
413 **************************************************/
414
415 int compare_lines(a, b)
416 line *a, *b;
417 {
418 int n1 = a->number;
419 int n2 = b->number;
420 char *s = a->text;
421 char *t = b->text;
422
423 if (n1 < 0  &&  n2 < 0) return TRUE;
424 if (n1 < 0  ||  n2 < 0) return FALSE;
425
426 while (*s == *t)
427   {
428   if (*s == '\n') return TRUE;
429   s++; t++;
430   }
431
432 return FALSE;
433 }
434
435
436 /*************************************************
437 *             Re-synchronizing code              *
438 *************************************************/
439
440 int resync(pvoid)
441 {
442 int i;
443 int matched = TRUE;
444 line *tline_one = pline_one;
445 line *tline_two = pline_two;
446
447 if (eof_one || eof_two) matched = FALSE; else
448   {
449   for (i = 1; i < sync_count; i++)
450     {
451     if (!nextline_one()) readline_one();
452     if (!nextline_two()) readline_two();
453     if (!compare_lines(pline_one, pline_two)) { matched = FALSE; break; }
454     if (eof_one || eof_two) { matched = FALSE; break; }
455     }
456   }
457
458 if (matched) write_message(tline_one, tline_two); else
459   {
460   pline_one = tline_one;
461   pline_two = tline_two;
462   }
463
464 return matched;
465 }
466
467
468
469 /*************************************************
470 *                 Main compare code              *
471 *************************************************/
472
473 void compare(pvoid)
474 {
475 int matched = TRUE;
476
477 /* Big main loop - exit by return or unmatched at eof */
478
479 while (matched)
480   {
481   /* First minor loop, while in step */
482
483   while (matched && !eof_one && !eof_two)
484     {
485     /* Advance or read next lines */
486
487     if (!nextline_one())
488       {
489       bufnext_one = bufbase_one;
490       lastline_one = NULL;
491       readline_one();
492       }
493
494     if (!nextline_two())
495       {
496       bufnext_two = bufbase_two;
497       lastline_two = NULL;
498       readline_two();
499       }
500
501     /* Compare and check for end of file */
502
503     matched = compare_lines(pline_one, pline_two);
504
505     } /* End first minor loop */
506
507   if (matched) return;    /* successful end of file */
508
509   /* There has been a mis-match */
510
511   return_code++;
512   rootline_one = pline_one;   /* Fail point */
513   rootline_two = pline_two;
514
515   /* Second minor loop, trying to regain sync */
516
517   while (!eof_one || !eof_two)
518     {
519     /* Advance one and scan all of two */
520
521     if (!eof_one)
522       {
523       line *zline = pline_two;
524       if (!nextline_one()) readline_one();
525       pline_two = rootline_two;
526       for (;;)
527         {
528         if (compare_lines(pline_one, pline_two))
529           {
530           matched = resync();
531           if (matched) break;
532           }
533         if (pline_two == zline) break;
534         pline_two = pline_two->next;
535         }
536       if (matched) break;
537       }
538
539     /* Advance two and scan all of one */
540
541     if (!eof_two)
542       {
543       line *zline = pline_one;
544       if (!nextline_two()) readline_two();
545       pline_one = rootline_one;
546       for (;;)
547         {
548         if (compare_lines(pline_one, pline_two))
549           {
550           matched = resync();
551           if (matched) break;
552           }
553         if (pline_one == zline) break;
554         pline_one = pline_one->next;
555         }
556       if (matched) break;
557       }
558
559     } /* End second minor loop */
560
561   } /* End of major loop */
562
563 write_message(lastline_one, lastline_two);
564 }
565
566
567
568
569 /*************************************************
570 *                   Entry Point                  *
571 *************************************************/
572
573 int main(argc, argv)
574 int argc;
575 char **argv;
576 {
577 int argp = 1;
578 int arg_id = FALSE;
579 int arg_help = FALSE;
580
581 f_out = stdout;
582
583 /* Scan argument strings */
584
585 while (argp < argc)
586   {
587   char  *arg = argv[argp];
588   char **lv_name = (name_one == NULL)? &name_one:&name_two;  /* default for positional */
589   int   *lv_value = NULL;
590   int    value = TRUE;
591
592   if (arg[0] == '-')
593     {                            /* keyed argument */
594     if (EqString(arg,"-help") || EqString(arg, "-h"))
595       { arg_help = TRUE; value = FALSE; }
596     else if (EqString(arg, "-id"))
597       { arg_id = TRUE; value = FALSE; }
598     else if (EqString(arg, "-exact"))
599       { exact = TRUE; value = FALSE; }
600     else if (EqString(arg, "-noecho"))
601       { echo = FALSE; value = FALSE; }
602     else if (EqString(arg, "-to")) lv_name = &to_name;
603     else if (EqString(arg, "-sync") || EqString(arg, "-s"))
604        lv_value = &sync_count;
605     else if (EqString(arg, "-buffer")) lv_value = &storesize;
606     else { printf("Unknown keyword %s\n", arg); exit(99); }
607
608     if (++argp >= argc && value)
609       { printf("Value for keyword %s missing\n", arg); exit(99); }
610     }
611
612   /* Deal with keys that take values */
613
614   if (value)
615     {
616     if (lv_value == &sync_count || lv_value == &storesize)
617       {
618       int ch;
619       int i = 0;
620       char *argval = argv[argp++];
621       *lv_value = 0;
622       while ((ch = argval[i++]) != 0)
623         {
624         if ('0' <= ch && ch <= '9') *lv_value = 10*(*lv_value) + ch - '0'; else
625           {
626           printf("Number expected after \"%s\" but \"%s\" read\n",
627             arg, argval);
628           exit(99);
629           }
630         }
631       }
632
633     else if (*lv_name != NULL)
634       {
635       printf("Keyword expected but \"%s\" read", arg);
636       printf(" - use \"cmp -h\" for help\n");
637       exit(99);
638       }
639     else *lv_name = argv[argp++];
640     }
641   }
642
643 /* Deal with help and id */
644
645 if (arg_id && !arg_help)
646   {
647   printf("PH's CMP v%d\n", version);
648   exit(0);
649   }
650
651 if (arg_help)
652   {
653   givehelp();
654   exit(0);
655   }
656
657 /* Deal with file names */
658
659 if (name_one == NULL || name_two == NULL) moan(3, "");
660
661 if (to_name != NULL)
662   {
663   f_out = fopen(to_name, "w");
664   if (f_out == NULL) moan(1, to_name);
665   }
666
667 /* Further general initialization */
668
669 if (storesize < minstore) storesize = defaultstore;
670 f_one = fopen(name_one, "r");
671 if (f_one == NULL) moan(1, name_one);
672 f_two = fopen(name_two, "r");
673 if (f_two == NULL) moan(1, name_two);
674
675 bufbase_one = (char *)malloc(storesize);
676 buftop_one = bufbase_one + storesize;
677 bufbase_two = (char *)malloc(storesize);
678 buftop_two = bufbase_two + storesize;
679
680 /* Do the job */
681
682 compare();
683
684 /* Final messages */
685
686 if (return_code == 0)
687   fprintf(f_out, "\"%s\" and \"%s\" are identical.\n", name_one, name_two);
688 else
689   {
690   if (echo) rule('=', 15);
691   fprintf(f_out, "%d difference", return_code);
692   if (return_code != 1) fprintf(f_out, "s");
693   fprintf(f_out, " found.\n");
694
695   lines_one -= 1;
696   fprintf(f_out, "\"%s\" contains %d line", name_one, lines_one);
697   if (lines_one != 1) fprintf(f_out, "s");
698
699   lines_two -= 1;
700   fprintf(f_out, "; \"%s\" contains %d line", name_two, lines_two);
701   if (lines_two != 1) fprintf(f_out, "s");
702   fprintf(f_out, ".\n");
703   }
704
705 free(bufbase_one);
706 free(bufbase_two);
707
708 fclose(f_one);
709 fclose(f_two);
710 if (f_out != stdout) fclose(f_out);
711
712 return return_code;
713 }
714
715 /* End of PH-Compare. */