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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * 25 * logadm/glob.c -- globbing routines 26 * 27 * these routines support two kinds of globs. first, the 28 * usual kind of filename globbing, like: 29 * 30 * *.c 31 * /var/log/syslog.? 32 * log[0-9]*file 33 * /var/apache/logs/x*{access,error}_log 34 * 35 * this is basically the same syntax that csh supports for globs and 36 * is provided by the routine glob_glob() which takes a filename and 37 * returns a list of filenames that match the glob. 38 * 39 * the second type is something called a "reglob" which is a pathname 40 * where the components are regular expressions as described in regex(3c). 41 * some examples: 42 * 43 * .*\.c 44 * /var/log/syslog\.. 45 * log[0-9].*file 46 * /var/log/syslog\.([0-9]+)$0 47 * 48 * the last example uses the ()$n form to assign a numeric extension 49 * on a filename to the "n" value kept by the fn routines with each 50 * filename (see fn_setn() in fn.c). logadm uses this mechanism to 51 * correctly sort lognames when templates containing $n are used. 52 * 53 * the routine glob_reglob() is used to expand reglobs. glob_glob() 54 * is implemented by expanding the curly braces, converting the globs 55 * to reglobs, and then passing the work to glob_reglob(). 56 * 57 * finally, since expanding globs and reglobs requires doing a stat(2) 58 * on the files, we store the resulting stat information in the filename 59 * struct (see fn_setstat() in fn.c). 60 * 61 * the glob(3c) routines are not used here since they don't support 62 * braces, and don't support the more powerful reglobs required by logadm. 63 */ 64 65 #pragma ident "%Z%%M% %I% %E% SMI" 66 67 #include <stdio.h> 68 #include <libintl.h> 69 #include <stdlib.h> 70 #include <libgen.h> 71 #include <strings.h> 72 #include <sys/types.h> 73 #include <sys/param.h> 74 #include <sys/stat.h> 75 #include <dirent.h> 76 #include "err.h" 77 #include "fn.h" 78 #include "glob.h" 79 80 /* forward declarations for functions used internally by this module */ 81 static struct fn_list *glob_debrace(struct fn *fnp); 82 static struct fn_list *glob_reglob_list(struct fn_list *fnlp); 83 static boolean_t glob_magic(struct fn *fnp); 84 85 /* expand curly braces (like file{one,two,three}name) */ 86 static struct fn_list * 87 glob_debrace(struct fn *fnp) 88 { 89 struct fn_list *ret = fn_list_new(NULL); 90 struct fn_list *newret; 91 char *sp = fn_s(fnp); 92 char *left; 93 char *right; 94 char *comma; 95 96 /* start with an empty string in the list */ 97 fn_list_adds(ret, ""); 98 99 /* while braces remain... */ 100 while (sp != NULL && (left = strchr(sp, '{')) != NULL) 101 if ((right = strchr(left, '}')) == NULL) { 102 err(EF_FILE|EF_JMP, "Missing }"); 103 fn_list_free(ret); 104 return (NULL); 105 } else { 106 /* stuff before "left" is finished */ 107 fn_list_appendrange(ret, sp, left); 108 109 /* stuff after "right" still need processing */ 110 sp = right + 1; 111 112 if (left + 1 == right) 113 continue; /* just an empty {} */ 114 115 /* stuff between "left" and "right" is comma-sep list */ 116 left++; 117 newret = fn_list_new(NULL); 118 while ((comma = strchr(left, ',')) != NULL) { 119 struct fn_list *dup = fn_list_dup(ret); 120 121 /* stuff from left to comma is one variant */ 122 fn_list_appendrange(dup, left, comma); 123 fn_list_addfn_list(newret, dup); 124 left = comma + 1; 125 } 126 /* what's left is the last item in the list */ 127 fn_list_appendrange(ret, left, right); 128 fn_list_addfn_list(newret, ret); 129 ret = newret; 130 } 131 132 /* anything remaining in "s" is finished */ 133 fn_list_appendrange(ret, sp, &sp[strlen(sp)]); 134 return (ret); 135 } 136 137 /* return true if filename contains any "magic" characters (*,?,[) */ 138 static boolean_t 139 glob_magic(struct fn *fnp) 140 { 141 char *s = fn_s(fnp); 142 143 for (; s != NULL && *s; s++) 144 if (*s == '*' || 145 *s == '?' || 146 *s == '[') 147 return (B_TRUE); 148 149 return (B_FALSE); 150 } 151 152 /* 153 * glob_glob -- given a filename glob, return the list of matching filenames 154 * 155 * fn_setn() and fn_setstat() are called to set the "n" and stat information 156 * for the resulting filenames. 157 */ 158 struct fn_list * 159 glob_glob(struct fn *fnp) 160 { 161 struct fn_list *tmplist = glob_debrace(fnp); 162 struct fn_list *ret; 163 struct fn *nextfnp; 164 struct fn *newfnp; 165 int magic = 0; 166 167 /* debracing produced NULL list? */ 168 if (tmplist == NULL) 169 return (NULL); 170 171 /* see if anything in list contains magic characters */ 172 fn_list_rewind(tmplist); 173 while ((nextfnp = fn_list_next(tmplist)) != NULL) 174 if (glob_magic(nextfnp)) { 175 magic = 1; 176 break; 177 } 178 179 if (!magic) 180 return (tmplist); /* no globs to expand */ 181 182 /* foreach name in the list, call glob_glob() to expand it */ 183 fn_list_rewind(tmplist); 184 ret = fn_list_new(NULL); 185 while ((nextfnp = fn_list_next(tmplist)) != NULL) { 186 newfnp = glob_to_reglob(nextfnp); 187 fn_list_addfn(ret, newfnp); 188 } 189 fn_list_free(tmplist); 190 tmplist = ret; 191 ret = glob_reglob_list(tmplist); 192 fn_list_free(tmplist); 193 194 return (ret); 195 } 196 197 /* 198 * glob_glob_list -- given a list of filename globs, return all matches 199 */ 200 struct fn_list * 201 glob_glob_list(struct fn_list *fnlp) 202 { 203 struct fn_list *ret = fn_list_new(NULL); 204 struct fn *fnp; 205 206 fn_list_rewind(fnlp); 207 while ((fnp = fn_list_next(fnlp)) != NULL) 208 fn_list_addfn_list(ret, glob_glob(fnp)); 209 return (ret); 210 } 211 212 /* 213 * glob_reglob -- given a filename reglob, return a list of matching filenames 214 * 215 * this routine does all the hard work in this module. 216 */ 217 struct fn_list * 218 glob_reglob(struct fn *fnp) 219 { 220 struct fn_list *ret = fn_list_new(NULL); 221 struct fn_list *newret; 222 struct fn *nextfnp; 223 char *mys = STRDUP(fn_s(fnp)); 224 char *sp = mys; 225 char *slash; 226 int skipdotfiles; 227 char *re; 228 char ret0[MAXPATHLEN]; 229 230 231 /* start with the initial directory in the list */ 232 if (*sp == '/') { 233 fn_list_adds(ret, "/"); 234 while (*sp == '/') 235 sp++; 236 } else 237 fn_list_adds(ret, "./"); 238 239 /* while components remain... */ 240 do { 241 if ((slash = strchr(sp, '/')) != NULL) { 242 *slash++ = '\0'; 243 /* skip superfluous slashes */ 244 while (*slash == '/') 245 slash++; 246 } 247 248 /* dot files are skipped unless a dot was specifically given */ 249 if (sp[0] == '\\' && sp[1] == '.') 250 skipdotfiles = 0; 251 else 252 skipdotfiles = 1; 253 254 /* compile the regex */ 255 if ((re = regcmp("^", sp, "$", (char *)0)) == NULL) 256 err(EF_FILE|EF_JMP, "regcmp failed on <%s>", sp); 257 258 /* apply regex to every filename we've matched so far */ 259 newret = fn_list_new(NULL); 260 fn_list_rewind(ret); 261 while ((nextfnp = fn_list_next(ret)) != NULL) { 262 DIR *dirp; 263 struct dirent *dp; 264 265 /* go through directory looking for matches */ 266 if ((dirp = opendir(fn_s(nextfnp))) == NULL) 267 continue; 268 269 while ((dp = readdir(dirp)) != NULL) { 270 if (skipdotfiles && dp->d_name[0] == '.') 271 continue; 272 *ret0 = '\0'; 273 if (regex(re, dp->d_name, ret0)) { 274 struct fn *matchfnp = fn_dup(nextfnp); 275 struct stat stbuf; 276 int n; 277 278 fn_puts(matchfnp, dp->d_name); 279 280 if (stat(fn_s(matchfnp), &stbuf) < 0) { 281 fn_free(matchfnp); 282 continue; 283 } 284 285 /* skip non-dirs if more components */ 286 if (slash && 287 (stbuf.st_mode & S_IFMT) != 288 S_IFDIR) { 289 fn_free(matchfnp); 290 continue; 291 } 292 293 /* 294 * component matched, fill in "n" 295 * value, stat information, and 296 * append component to directory 297 * name just searched. 298 */ 299 300 if (*ret0) 301 n = atoi(ret0); 302 else 303 n = -1; 304 fn_setn(matchfnp, n); 305 fn_setstat(matchfnp, &stbuf); 306 307 if (slash) 308 fn_putc(matchfnp, '/'); 309 310 fn_list_addfn(newret, matchfnp); 311 } 312 } 313 (void) closedir(dirp); 314 } 315 fn_list_free(ret); 316 ret = newret; 317 sp = slash; 318 } while (slash); 319 320 FREE(mys); 321 322 return (ret); 323 } 324 325 /* reglob a list of filenames */ 326 static struct fn_list * 327 glob_reglob_list(struct fn_list *fnlp) 328 { 329 struct fn_list *ret = fn_list_new(NULL); 330 struct fn *fnp; 331 332 fn_list_rewind(fnlp); 333 while ((fnp = fn_list_next(fnlp)) != NULL) 334 fn_list_addfn_list(ret, glob_reglob(fnp)); 335 return (ret); 336 } 337 338 /* 339 * glob_to_reglob -- convert a glob (*, ?, etc) to a reglob (.*, ., etc.) 340 */ 341 struct fn * 342 glob_to_reglob(struct fn *fnp) 343 { 344 int c; 345 struct fn *ret = fn_new(NULL); 346 347 fn_rewind(fnp); 348 while ((c = fn_getc(fnp)) != '\0') 349 switch (c) { 350 case '.': 351 case '(': 352 case ')': 353 case '^': 354 case '+': 355 case '{': 356 case '}': 357 case '$': 358 /* magic characters need backslash */ 359 fn_putc(ret, '\\'); 360 fn_putc(ret, c); 361 break; 362 case '?': 363 /* change '?' to a single dot */ 364 fn_putc(ret, '.'); 365 break; 366 case '*': 367 /* change '*' to ".*" */ 368 fn_putc(ret, '.'); 369 fn_putc(ret, '*'); 370 break; 371 default: 372 fn_putc(ret, c); 373 } 374 375 return (ret); 376 } 377 378 #ifdef TESTMODULE 379 380 /* 381 * test main for glob module, usage: a.out [-r] [pattern...] 382 * -r means the patterns are reglobs instead of globs 383 */ 384 int 385 main(int argc, char *argv[]) 386 { 387 int i; 388 int reglobs = 0; 389 struct fn *argfnp = fn_new(NULL); 390 struct fn *fnp; 391 struct fn_list *fnlp; 392 393 err_init(argv[0]); 394 setbuf(stdout, NULL); 395 396 for (i = 1; i < argc; i++) { 397 if (strcmp(argv[i], "-r") == 0) { 398 reglobs = 1; 399 continue; 400 } 401 402 if (SETJMP) { 403 printf(" skipped due to errors\n"); 404 continue; 405 } else { 406 printf("<%s>:\n", argv[i]); 407 fn_renew(argfnp, argv[i]); 408 if (reglobs) 409 fnlp = glob_reglob(argfnp); 410 else 411 fnlp = glob_glob(argfnp); 412 } 413 414 fn_list_rewind(fnlp); 415 while ((fnp = fn_list_next(fnlp)) != NULL) 416 printf(" <%s>\n", fn_s(fnp)); 417 418 printf("total size: %lld\n", fn_list_totalsize(fnlp)); 419 420 while ((fnp = fn_list_popoldest(fnlp)) != NULL) { 421 printf(" oldest <%s>\n", fn_s(fnp)); 422 fn_free(fnp); 423 } 424 425 fn_list_free(fnlp); 426 } 427 fn_free(argfnp); 428 429 err_done(0); 430 /* NOTREACHED */ 431 return (0); 432 } 433 434 #endif /* TESTMODULE */ 435