usr.bin/pathchk/pathchk.c

   1 /*      $NetBSD: pathchk.c,v 1.2 2011/09/16 15:39:28 joerg Exp $        */
   2
   3 /*-
   4  * Copyright (c) 2002 Tim J. Robbins.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * from FreeBSD: pathchk.c,v 1.4 2002/12/15 00:40:47 tjr Exp
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #ifndef lint
  33 __RCSID("$NetBSD: pathchk.c,v 1.2 2011/09/16 15:39:28 joerg Exp $");
  34 #endif /* !lint */
  35
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38
  39 #include <err.h>
  40 #include <errno.h>
  41 #include <limits.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <unistd.h>
  46
  47 static int check(const char *);
  48 static int portable(const char *);
  49 __dead static void usage(void);
  50
  51 static int pflag;                       /* Perform portability checks */
  52
  53 int
  54 main(int argc, char *argv[])
  55 {
  56         int ch, rval;
  57         const char *arg;
  58
  59         while ((ch = getopt(argc, argv, "p")) > 0) {
  60                 switch (ch) {
  61                 case 'p':
  62                         pflag = 1;
  63                         break;
  64                 default:
  65                         usage();
  66                         /*NOTREACHED*/
  67                 }
  68         }
  69         argc -= optind;
  70         argv += optind;
  71
  72         if (argc == 0)
  73                 usage();
  74
  75         rval = 0;
  76         while ((arg = *argv++) != NULL)
  77                 rval |= check(arg);
  78
  79         exit(rval);
  80 }
  81
  82 static void
  83 usage(void)
  84 {
  85
  86         fprintf(stderr, "usage: pathchk [-p] pathname...\n");
  87         exit(1);
  88 }
  89
  90 static int
  91 check(const char *path)
  92 {
  93         struct stat sb;
  94         long complen, namemax, pathmax, svnamemax;
  95         int badch, last;
  96         char *end, *p, *pathd;
  97
  98         if ((pathd = strdup(path)) == NULL)
  99                 err(1, "strdup");
 100
 101         p = pathd;
 102
 103         if (!pflag) {
 104                 errno = 0;
 105                 namemax = pathconf(*p == '/' ? "/" : ".", _PC_NAME_MAX);
 106                 if (namemax == -1 && errno != 0)
 107                         namemax = NAME_MAX;
 108         } else
 109                 namemax = _POSIX_NAME_MAX;
 110
 111         for (;;) {
 112                 p += strspn(p, "/");
 113                 complen = (long)strcspn(p, "/");
 114                 end = p + complen;
 115                 last = *end == '\0';
 116                 *end = '\0';
 117
 118                 if (namemax != -1 && complen > namemax) {
 119                         warnx("%s: %s: component too long (limit %ld)", path,
 120                             p, namemax);
 121                         goto bad;
 122                 }
 123
 124                 if (!pflag && stat(pathd, &sb) == -1 && errno != ENOENT) {
 125                         warn("%s: %.*s", path, (int)(strlen(pathd) -
 126                             complen - 1), pathd);
 127                         goto bad;
 128                 }
 129
 130                 if (pflag && (badch = portable(p)) >= 0) {
 131                         warnx("%s: %s: component contains non-portable "
 132                             "character `%c'", path, p, badch);
 133                         goto bad;
 134                 }
 135
 136                 if (last)
 137                         break;
 138
 139                 if (!pflag) {
 140                         errno = 0;
 141                         svnamemax = namemax;
 142                         namemax = pathconf(pathd, _PC_NAME_MAX);
 143                         if (namemax == -1 && errno != 0)
 144                                 namemax = svnamemax;
 145                 }
 146
 147                 *end = '/';
 148                 p = end + 1;
 149         }
 150
 151         if (!pflag) {
 152                 errno = 0;
 153                 pathmax = pathconf(path, _PC_PATH_MAX);
 154                 if (pathmax == -1 && errno != 0)
 155                         pathmax = PATH_MAX;
 156         } else
 157                 pathmax = _POSIX_PATH_MAX;
 158         if (pathmax != -1 && strlen(path) >= (size_t)pathmax) {
 159                 warnx("%s: path too long (limit %ld)", path, pathmax - 1);
 160                 goto bad;
 161         }
 162
 163         free(pathd);
 164         return (0);
 165
 166 bad:    free(pathd);
 167         return (1);
 168 }
 169
 170 /*
 171  * Check whether a path component contains only portable characters. Return
 172  * the first non-portable character found.
 173  */
 174 static int
 175 portable(const char *path)
 176 {
 177         static const char charset[] =
 178             "abcdefghijklmnopqrstuvwxyz"
 179             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 180             "0123456789._-";
 181         long s;
 182
 183         if (*path == '-')
 184                 return (*path);
 185
 186         s = strspn(path, charset);
 187         if (path[s] != '\0')
 188                 return (path[s]);
 189
 190         return (-1);
 191 }