1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * 24 * Copyright (c) 1994 by Sun Microsystems, Inc. 25 */ 26 27 /* 28 * Copyright 1991, 1992 by Mortice Kern Systems Inc. All rights reserved. 29 * 30 * Standards Conformance : 31 * P1003.2/D11.2 32 * 33 */ 34 #pragma ident "%Z%%M% %I% %E% SMI" 35 /* 36 * Original ident string for reference 37 * ident "$Id: pathchk.c,v 1.29 1994/05/24 15:51:19 mark Exp $" 38 */ 39 40 #include <locale.h> 41 #include <libintl.h> 42 #include <limits.h> 43 #include <sys/stat.h> 44 #include <fcntl.h> /* for creat() prototype */ 45 #include <string.h> 46 #include <errno.h> 47 #include <stdlib.h> 48 #include <stdio.h> 49 #include <ctype.h> 50 #include <unistd.h> 51 #include <stdlib.h> 52 53 /* 54 * These are the characters in the portable filename character set defined 55 * in POSIX P1003.2. 56 */ 57 static char portfsset[] = \ 58 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-"; 59 60 61 #ifndef M_FSDELIM 62 #define M_FSDELIM(c) ((c) == '/') 63 #endif 64 65 static char *nametoolong = "%s: component too long.\n"; 66 static char *pathtoolong = "%s: pathname too long.\n"; 67 static char *notsrch = "%s: Not searchable.\n"; 68 static char *badchar = "%s: Nonportable character '%c' (%#02X) found.\n"; 69 static char *badbyte = "%s: Nonportable byte %#02X found.\n"; 70 71 static char *pathconfprob = "pathchk: warning: \ 72 pathconf(\"%s\", %s) returns '%s'. Using %s = %d\n"; 73 74 75 static int printWarnings = 1; 76 77 static int checkpathname(char *, int); 78 static void usage(void); 79 80 /* 81 * mainline for pathchk 82 */ 83 int 84 main(int argc, char **argv) 85 { 86 int c; 87 int errors; 88 int pflag = 0; 89 90 (void) setlocale(LC_ALL, ""); 91 #if !defined(TEXT_DOMAIN) 92 #define TEXT_DOMAIN "SYS_TEST" 93 #endif 94 (void) textdomain(TEXT_DOMAIN); 95 96 97 while ((c = getopt(argc, argv, "pw")) != EOF) { 98 switch (c) { 99 case 'p': 100 pflag = 1; 101 break; 102 103 case 'w': 104 /* turn off warning messages */ 105 printWarnings = 0; 106 break; 107 108 default: 109 usage(); 110 } 111 } 112 113 argv += optind; 114 115 if (*argv == 0) { 116 usage(); 117 /* NOTREACHED */ 118 } 119 120 errors = 0; 121 while (*argv) { 122 errors += checkpathname(*argv, pflag); 123 argv += 1; 124 } 125 126 return (errors); 127 } 128 129 /* 130 * checkPathConf(const char *, int, long *) 131 * 132 * Calls pathconf(), and returns 1 if pathconf failed, zero 133 * otherwise. If pathconf() succeeded, then *valp contains the 134 * value returned 135 */ 136 static int 137 checkPathConf(const char *path, int type, long *valp) 138 { 139 errno = 0; 140 *valp = pathconf(path, type); 141 if ((*valp == -1) && (errno != 0) && (errno != EACCES)) { 142 /* 143 * pathconf() is not supported on some mounted filesystems 144 * (e.g NFS mounts) and pathconf() is known to fail. 145 * So, we print a warning and use the POSIX default values. 146 */ 147 if (type == _PC_PATH_MAX) 148 *valp = _POSIX_PATH_MAX; 149 else 150 *valp = _POSIX_NAME_MAX; 151 152 if (printWarnings) { 153 (void) fprintf(stderr, gettext(pathconfprob), path, 154 type == _PC_PATH_MAX?"_PC_PATH_MAX" : 155 "_PC_NAME_MAX", strerror(errno), 156 type == _PC_PATH_MAX ? "PATH_MAX" : "NAME_MAX", 157 *valp); 158 } 159 } 160 return ((*valp == -1) && (errno != 0)); 161 } 162 163 164 #define UPDATE_LIMITS(buf)\ 165 {\ 166 if (pflag) {\ 167 nameMax = _POSIX_NAME_MAX;\ 168 pathMax = _POSIX_PATH_MAX;\ 169 } else if (checkPathConf((buf), _PC_PATH_MAX, &pathMax) || \ 170 checkPathConf((buf), _PC_NAME_MAX, &nameMax)) {\ 171 (void) fprintf(stderr, gettext(notsrch), buf);\ 172 return (1);\ 173 }\ 174 } 175 176 /* 177 * checkpathname(char *pname) 178 * pathchk a single pathname. 179 */ 180 int 181 checkpathname(char *path, int pflag) 182 { 183 int checkStat; 184 long nameMax; 185 long pathMax; 186 char *scomp; 187 char *ecomp; 188 register char *p; 189 190 p = path; 191 checkStat = 1; 192 193 /* 194 * Get the initial NAME_MAX and PATH_MAX values 195 */ 196 if (M_FSDELIM(*p)) { 197 char buf[2]; 198 199 buf[0] = *p; 200 buf[1] = '\0'; 201 202 UPDATE_LIMITS(buf); 203 } else { 204 /* 205 * This is a relative pathname, initial values 206 * are relative to the current directory 207 */ 208 UPDATE_LIMITS("."); 209 } 210 211 /* 212 * Check to make sure that the pathname doesn't exceed the 213 * current PATH_MAX 214 */ 215 if (pathMax != -1 && strlen(p) > (size_t)pathMax) { 216 (void) fprintf(stderr, gettext(pathtoolong), path); 217 return (1); 218 } 219 220 221 /* 222 * Now spin around checking all the prefixes of 223 * the pathname, until we hit the end of the 224 * argument 225 */ 226 while (*p != '\0') { 227 /* 228 * Find the beginning of the next 229 * component. Assume that 230 * M_FSDELIM('\0') == 0 231 */ 232 while (M_FSDELIM(*p)) 233 p += 1; 234 235 if (*p == '\0') { 236 /* 237 * There were trailing fsdelim chars on 238 * the path provided, so we were 239 * finished, we just didn't know it. 240 */ 241 return (0); 242 } 243 244 scomp = p; 245 246 /* 247 * Find the end of the current component 248 * and check for valid characters in the component 249 */ 250 while (*p != '\0' && !M_FSDELIM(*p)) { 251 /* 252 * for pflag: check for PFCS characters 253 * otherwise assume all characters are valid 254 */ 255 if (pflag && (strchr(portfsset, *p) == 0)) { 256 if (isprint(*p)) { 257 (void) fprintf(stderr, 258 gettext(badchar), path, *p, *p); 259 } else { 260 (void) fprintf(stderr, 261 gettext(badbyte), path, *p); 262 } 263 return (1); 264 } 265 p += 1; 266 } 267 268 ecomp = p; 269 270 /* 271 * Make sure that this component does not exceed 272 * NAME_MAX in the current prefix directory 273 */ 274 if ((nameMax != -1) && (ecomp - scomp > nameMax)) { 275 (void) fprintf(stderr, gettext(nametoolong), scomp); 276 return (1); 277 } else if (!pflag && checkStat) { 278 /* 279 * Perform the extra checks that 280 * are required when not just 281 * checking for portability. 282 */ 283 struct stat sb; 284 char fsdelim; 285 286 fsdelim = *ecomp; 287 *ecomp = '\0'; 288 289 if (stat(path, &sb) == -1) { 290 /* 291 * We error out if an 292 * intermediate component 293 * is a file, when we 294 * were expecting a 295 * directory, or it is an 296 * unsearchable directory. 297 */ 298 if ((errno == ENOTDIR && fsdelim != '\0') || 299 (errno == EACCES)) { 300 (void) fprintf(stderr, gettext(notsrch), 301 path); 302 return (1); 303 } else if (errno == ENOENT) { 304 checkStat = 0; 305 } 306 } else if (S_ISDIR(sb.st_mode)) { 307 /* 308 * If the current prefix is a 309 * directory, then we need to 310 * update the limits for NAME_MAX 311 * for the next component and the suffix. 312 */ 313 if (checkPathConf(path, _PC_NAME_MAX, 314 &nameMax)) { 315 (void) fprintf(stderr, 316 gettext(notsrch), path); 317 return (1); 318 } 319 } 320 321 /* 322 * restore the fsdelim char that we 323 * stomped to produce a prefix. 324 */ 325 *ecomp = fsdelim; 326 } /* if (we need to stat the path) */ 327 } /* while (more of this path to check) */ 328 329 /* 330 * We successfully traversed the whole pathname 331 */ 332 return (0); 333 } 334 335 void 336 usage() 337 { 338 (void) fprintf(stderr, gettext("usage: pathchk [-p] pathname ...")); 339 (void) fprintf(stderr, "\n"); 340 exit(2); 341 } 342