kernel - Reduce lwp_signotify() latency
[dragonfly.git] / usr.sbin / ckdist / ckdist.c
1 /*
2  * Copyright (c) 1997 Robert Nordier
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in
12  *    the documentation and/or other materials provided with the
13  *    distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY
19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
21  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
23  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
25  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  *
27  * $FreeBSD: src/usr.sbin/ckdist/ckdist.c,v 1.3.2.1 2000/07/01 10:37:21 ps Exp $
28  * $DragonFly: src/usr.sbin/ckdist/ckdist.c,v 1.3 2004/12/18 22:48:02 swildner Exp $
29  */
30
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <err.h>
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <fts.h>
37 #include <md5.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <unistd.h>
42
43 extern int crc(int fd, u_long * cval, u_long * clen);
44
45 #define DISTMD5     1           /* MD5 format */
46 #define DISTINF     2           /* .inf format */
47 #define DISTTYPES   2           /* types supported */
48
49 #define E_UNKNOWN   1           /* Unknown format */
50 #define E_BADMD5    2           /* Invalid MD5 format */
51 #define E_BADINF    3           /* Invalid .inf format */
52 #define E_NAME      4           /* Can't derive component name */
53 #define E_LENGTH    5           /* Length mismatch */
54 #define E_CHKSUM    6           /* Checksum mismatch */
55 #define E_ERRNO     7           /* sys_errlist[errno] */
56
57 #define isfatal(err)   ((err) && (err) <= E_NAME)
58
59 #define NAMESIZE  256           /* filename buffer size */
60 #define MDSUMLEN   32           /* length of MD5 message digest */
61
62 #define isstdin(path)  ((path)[0] == '-' && !(path)[1])
63
64 static const char *opt_dir;     /* where to look for components */
65 static const char *opt_name;    /* name for accessing components */
66 static int opt_all;             /* report on all components */
67 static int opt_ignore;          /* ignore missing components */
68 static int opt_recurse;         /* search directories recursively */
69 static int opt_silent;          /* silent about inaccessible files */
70 static int opt_type;            /* dist type: md5 or inf */
71 static int opt_exist;           /* just verify existence */
72
73 static int ckdist(const char *path, int type);
74 static int chkmd5(FILE * fp, const char *path);
75 static int chkinf(FILE * fp, const char *path);
76 static int report(const char *path, const char *name, int error);
77 static const char *distname(const char *path, const char *name,
78                             const char *ext);
79 static char *stripath(const char *path);
80 static int distfile(const char *path);
81 static int disttype(const char *name);
82 static int fail(const char *path, const char *msg);
83 static void usage(void);
84
85 int
86 main(int argc, char *argv[])
87 {
88     static char *arg[2];
89     struct stat sb;
90     FTS *ftsp;
91     FTSENT *f;
92     int rval, c, type;
93
94     while ((c = getopt(argc, argv, "ad:in:rst:x")) != -1)
95         switch (c) {
96         case 'a':
97             opt_all = 1;
98             break;
99         case 'd':
100             opt_dir = optarg;
101             break;
102         case 'i':
103             opt_ignore = 1;
104             break;
105         case 'n':
106             opt_name = optarg;
107             break;
108         case 'r':
109             opt_recurse = 1;
110             break;
111         case 's':
112             opt_silent = 1;
113             break;
114         case 't':
115             if ((opt_type = disttype(optarg)) == 0) {
116                 warnx("illegal argument to -t option");
117                 usage();
118             }
119             break;
120         case 'x':
121             opt_exist = 1;
122             break;
123         default:
124             usage();
125         }
126     argc -= optind;
127     argv += optind;
128     if (argc < 1)
129         usage();
130     if (opt_dir) {
131         if (stat(opt_dir, &sb))
132             err(2, "%s", opt_dir);
133         if (!S_ISDIR(sb.st_mode))
134             errx(2, "%s: not a directory", opt_dir);
135     }
136     rval = 0;
137     do {
138         if (isstdin(*argv))
139             rval |= ckdist(*argv, opt_type);
140         else if (stat(*argv, &sb))
141             rval |= fail(*argv, NULL);
142         else if (S_ISREG(sb.st_mode))
143             rval |= ckdist(*argv, opt_type);
144         else {
145             arg[0] = *argv;
146             if ((ftsp = fts_open(arg, FTS_LOGICAL, NULL)) == NULL)
147                 err(2, "fts_open");
148             while ((f = fts_read(ftsp)) != NULL)
149                 switch (f->fts_info) {
150                 case FTS_DC:
151                     rval = fail(f->fts_path, "Directory causes a cycle");
152                     break;
153                 case FTS_DNR:
154                 case FTS_ERR:
155                 case FTS_NS:
156                     rval = fail(f->fts_path, sys_errlist[f->fts_errno]);
157                     break;
158                 case FTS_D:
159                     if (!opt_recurse && f->fts_level > FTS_ROOTLEVEL &&
160                         fts_set(ftsp, f, FTS_SKIP))
161                         err(2, "fts_set");
162                     break;
163                 case FTS_F:
164                     if ((type = distfile(f->fts_name)) != 0 &&
165                         (!opt_type || type == opt_type))
166                         rval |= ckdist(f->fts_path, type);
167                     break;
168                 default: ;
169                 }
170             if (errno)
171                 err(2, "fts_read");
172             if (fts_close(ftsp))
173                 err(2, "fts_close");
174         }
175     } while (*++argv);
176     return rval;
177 }
178
179 static int
180 ckdist(const char *path, int type)
181 {
182     FILE *fp;
183     int rval, c;
184
185     if (isstdin(path)) {
186         path = "(stdin)";
187         fp = stdin;
188     } else if ((fp = fopen(path, "r")) == NULL)
189         return fail(path, NULL);
190     if (!type) {
191         if (fp != stdin)
192             type = distfile(path);
193         if (!type)
194             if ((c = fgetc(fp)) != EOF) {
195                 type = c == 'M' ? DISTMD5 : c == 'P' ? DISTINF : 0;
196                 ungetc(c, fp);
197             }
198     }
199     switch (type) {
200     case DISTMD5:
201         rval = chkmd5(fp, path);
202         break;
203     case DISTINF:
204         rval = chkinf(fp, path);
205         break;
206     default:
207         rval = report(path, NULL, E_UNKNOWN);
208     }
209     if (ferror(fp))
210         warn("%s", path);
211     if (fp != stdin && fclose(fp))
212         err(2, "%s", path);
213     return rval;
214 }
215
216 static int
217 chkmd5(FILE * fp, const char *path)
218 {
219     char buf[298];              /* "MD5 (NAMESIZE = MDSUMLEN" */
220     char name[NAMESIZE + 1];
221     char sum[MDSUMLEN + 1], chk[MDSUMLEN + 1];
222     const char *dname;
223     char *s;
224     int rval, error, c, fd;
225     char ch;
226
227     rval = 0;
228     while (fgets(buf, sizeof(buf), fp)) {
229         dname = NULL;
230         error = 0;
231         if (((c = sscanf(buf, "MD5 (%256s = %32s%c", name, sum,
232                          &ch)) != 3 && (!feof(fp) || c != 2)) ||
233             (c == 3 && ch != '\n') ||
234             (s = strrchr(name, ')')) == NULL ||
235             strlen(sum) != MDSUMLEN)
236             error = E_BADMD5;
237         else {
238             *s = 0;
239             if ((dname = distname(path, name, NULL)) == NULL)
240                 error = E_NAME;
241             else if (opt_exist) {
242                 if ((fd = open(dname, O_RDONLY)) == -1)
243                     error = E_ERRNO;
244                 else if (close(fd))
245                     err(2, "%s", dname);
246             } else if (!MD5File((char *)dname, chk))
247                 error = E_ERRNO;
248             else if (strcmp(chk, sum))
249                 error = E_CHKSUM;
250         }
251         if (opt_ignore && error == E_ERRNO && errno == ENOENT)
252             continue;
253         if (error || opt_all)
254             rval |= report(path, dname, error);
255         if (isfatal(error))
256             break;
257     }
258     return rval;
259 }
260
261 static int
262 chkinf(FILE * fp, const char *path)
263 {
264     char buf[30];               /* "cksum.2 = 10 6" */
265     char ext[3];
266     struct stat sb;
267     const char *dname;
268     u_long sum, len, chk;
269     int rval, error, c, pieces, cnt, fd;
270     char ch;
271
272     rval = 0;
273     for (cnt = -1; fgets(buf, sizeof(buf), fp); cnt++) {
274         fd = -1;
275         dname = NULL;
276         error = 0;
277         if (cnt == -1) {
278             if ((c = sscanf(buf, "Pieces =  %d%c", &pieces, &ch)) != 2 ||
279                 ch != '\n' || pieces < 1)
280                 error = E_BADINF;
281         } else if (((c = sscanf(buf, "cksum.%2s = %lu %lu%c", ext, &sum,
282                                 &len, &ch)) != 4 &&
283                     (!feof(fp) || c != 3)) || (c == 4 && ch != '\n') ||
284                    ext[0] != 'a' + cnt / 26 || ext[1] != 'a' + cnt % 26)
285             error = E_BADINF;
286         else if ((dname = distname(fp == stdin ? NULL : path, NULL,
287                                     ext)) == NULL)
288             error = E_NAME;
289         else if ((fd = open(dname, O_RDONLY)) == -1)
290             error = E_ERRNO;
291         else if (fstat(fd, &sb))
292             error = E_ERRNO;
293         else if (sb.st_size != (off_t)len)
294             error = E_LENGTH;
295         else if (!opt_exist) {
296             if (crc(fd, &chk, &len))
297                 error = E_ERRNO;
298             else if (chk != sum)
299                 error = E_CHKSUM;
300         }
301         if (fd != -1 && close(fd))
302             err(2, "%s", dname);
303         if (opt_ignore && error == E_ERRNO && errno == ENOENT)
304             continue;
305         if (error || (opt_all && cnt >= 0))
306             rval |= report(path, dname, error);
307         if (isfatal(error))
308             break;
309     }
310     return rval;
311 }
312
313 static int
314 report(const char *path, const char *name, int error)
315 {
316     if (name)
317         name = stripath(name);
318     switch (error) {
319     case E_UNKNOWN:
320         printf("%s: Unknown format\n", path);
321         break;
322     case E_BADMD5:
323         printf("%s: Invalid MD5 format\n", path);
324         break;
325     case E_BADINF:
326         printf("%s: Invalid .inf format\n", path);
327         break;
328     case E_NAME:
329         printf("%s: Can't derive component name\n", path);
330         break;
331     case E_LENGTH:
332         printf("%s: %s: Size mismatch\n", path, name);
333         break;
334     case E_CHKSUM:
335         printf("%s: %s: Checksum mismatch\n", path, name);
336         break;
337     case E_ERRNO:
338         printf("%s: %s: %s\n", path, name, sys_errlist[errno]);
339         break;
340     default:
341         printf("%s: %s: OK\n", path, name);
342     }
343     return error != 0;
344 }
345
346 static const char *
347 distname(const char *path, const char *name, const char *ext)
348 {
349     static char buf[NAMESIZE];
350     size_t plen, nlen;
351     char *s;
352
353     if (opt_name)
354         name = opt_name;
355     else if (!name) {
356         if (!path)
357             return NULL;
358         name = stripath(path);
359     }
360     nlen = strlen(name);
361     if (ext && nlen > 4 && name[nlen - 4] == '.' &&
362         disttype(name + nlen - 3) == DISTINF)
363         nlen -= 4;
364     if (opt_dir) {
365         path = opt_dir;
366         plen = strlen(path);
367     } else
368         plen = path && (s = strrchr(path, '/')) != NULL ? 
369             (size_t)(s - path) : 0;
370     if (plen + (plen > 0) + nlen + (ext ? 3 : 0) >= sizeof(buf))
371         return NULL;
372     s = buf;
373     if (plen) {
374         memcpy(s, path, plen);
375         s += plen;
376         *s++ = '/';
377     }
378     memcpy(s, name, nlen);
379     s += nlen;
380     if (ext) {
381         *s++ = '.';
382         memcpy(s, ext, 2);
383         s += 2;
384     }
385     *s = 0;
386     return buf;
387 }
388
389 static char *
390 stripath(const char *path)
391 {
392     const char *s;
393
394     return (char *)((s = strrchr(path, '/')) != NULL && s[1] ? 
395                     s + 1 : path);
396 }
397
398 static int
399 distfile(const char *path)
400 {
401     const char *s;
402     int type;
403
404     if ((type = disttype(path)) == DISTMD5 ||
405         ((s = strrchr(path, '.')) != NULL && s > path &&
406          (type = disttype(s + 1)) != 0))
407         return type;
408     return 0;
409 }
410
411 static int
412 disttype(const char *name)
413 {
414     static const char dname[DISTTYPES][4] = {"md5", "inf"};
415     int i;
416
417     for (i = 0; i < DISTTYPES; i++)
418         if (!strcmp(dname[i], name))
419             return 1 + i;
420     return 0;
421 }
422
423 static int
424 fail(const char *path, const char *msg)
425 {
426     if (opt_silent)
427         return 0;
428     warnx("%s: %s", path, msg ? msg : sys_errlist[errno]);
429     return 2;
430 }
431
432 static void
433 usage(void)
434 {
435     fprintf(stderr,
436             "usage: ckdist [-airsx] [-d dir] [-n name] [-t type] file ...\n");
437     exit(2);
438 }