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 * Copyright (c) 1996, by Sun Microsystems, Inc. 24 * All Rights Reserved. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <locale.h> 30 #include <sys/types.h> 31 #include <stdio.h> 32 #include <sys/param.h> 33 #include <string.h> 34 #include <unistd.h> 35 #include <errno.h> 36 #include <fcntl.h> 37 #include <sys/stat.h> 38 #include <stdlib.h> 39 40 #include "rules.h" 41 42 char * lex(FILE *); 43 44 extern char *mstrdup(const char *); 45 extern void *mmalloc(size_t size); 46 47 void 48 read_rules(FILE *file, int (*rulefunc)()) 49 { 50 char *s; 51 int base_active = 0; 52 int list_ent_cnt = 0; 53 int gign_ent_cnt = 0; 54 int lign_ent_cnt = 0; 55 struct item *add_item(); 56 struct item *fitem, *sitem; 57 char version[20]; 58 59 last_gign = &gign_hd; 60 gign_hd.i_next = (struct item *)0; 61 gign_hd.i_str = (char *)0; 62 list_hd.i_next = (struct item *)0; 63 list_hd.i_str = (char *)0; 64 while (s = lex(file)) { 65 if (s == (char *)0) 66 break; 67 if (*s == '#') 68 continue; 69 if (*s == '*') 70 continue; 71 if (strcmp(s, BASE) == 0) { 72 #ifdef DEBUG 73 printf("BASE base_active = %d\n", base_active); 74 #endif /* DEBUG */ 75 if (base_active) { 76 /* 77 * Tack local IGNORE strings to end of globals 78 */ 79 if (lign_hd.i_next != (struct item *)0) { 80 last_gign->i_next = &lign_hd; 81 } 82 /* 83 * Process directives for previous BASE command 84 * if there was one. Also free up LIST items 85 * and local IGNORE items. 86 */ 87 do_base_dir(basedir, &list_hd, &gign_hd, 88 rulefunc); 89 /* 90 * Free up space from LIST item list 91 */ 92 fitem = list_hd.i_next; 93 if (fitem != (struct item *)0) { 94 while (fitem != (struct item *)0) { 95 free(fitem->i_str); 96 sitem = fitem->i_next; 97 free(fitem); 98 fitem = sitem; 99 } 100 } 101 /* 102 * Free up space from local IGNORE item list 103 */ 104 fitem = lign_hd.i_next; 105 if (fitem != (struct item *)0) { 106 while (fitem != (struct item *)0) { 107 free(fitem->i_str); 108 sitem = fitem->i_next; 109 free(fitem); 110 fitem = sitem; 111 } 112 } 113 last_gign->i_next = (struct item *)0; 114 } 115 base_active = 1; 116 /* 117 * Reset LIST item list and local IGNORE item 118 * list to be empty. 119 */ 120 last_list = &list_hd; 121 list_hd.i_next = (struct item *)0; 122 list_hd.i_str = (char *)0; 123 last_lign = &lign_hd; 124 lign_hd.i_next = (struct item *)0; 125 lign_hd.i_str = (char *)0; 126 /* 127 * Get BASE directory specified 128 */ 129 s = lex(0); 130 if (s == (char *)0) { 131 fprintf(stderr, gettext("cachefspack: ")); 132 fprintf(stderr, gettext( 133 "illegal BASE command\n")); 134 return; 135 } 136 137 if (*s == '$') { 138 /* 139 * String starts with a '$', it must be an 140 * environment variable 141 */ 142 s = getenv(&s[1]); 143 if (s == (char *)NULL) { 144 fprintf(stderr, 145 gettext("cachefspack: ")); 146 fprintf(stderr, 147 gettext("Can't find " 148 "environment variable\n")); 149 exit(1); 150 } 151 } 152 basedir = mstrdup(s); 153 #ifdef DEBUG 154 printf("basedir = %s\n", basedir); 155 #endif /* DEBUG */ 156 continue; 157 } 158 if (strcmp(s, IGNORE) == 0) { 159 #ifdef DEBUG 160 printf("IGNORE - base_active = %d\n", base_active); 161 #endif /* DEBUG */ 162 if (base_active) { 163 /* 164 * Local IGNORE rule 165 */ 166 while ((s = lex(0)) 167 != 0) { 168 last_lign = add_item(last_lign, s, 169 def_lign_flags); 170 } 171 } else { 172 /* 173 * Global IGNORE rule 174 */ 175 while ((s = lex(0)) != 0) { 176 last_gign = add_item(last_gign, s, 177 def_gign_flags); 178 } 179 } 180 continue; 181 } 182 if (strcmp(s, LIST) == 0) { 183 #ifdef DEBUG 184 printf("LIST\n"); 185 #endif /* DEBUG */ 186 if (!base_active) { 187 fprintf(stderr, 188 gettext( 189 "cachefspack: skipping LIST command - ")); 190 fprintf(stderr, 191 gettext(" no active base\n")); 192 continue; 193 } 194 while ((s = lex(0)) != 0) { 195 last_list = add_item(last_list, s, 196 def_list_flags); 197 } 198 continue; 199 } 200 if (strcmp(s, VERSION) == 0) { 201 sprintf(version, "%d.%d", VERMAJOR, VERMINOR); 202 s = lex(0); 203 if (s == (char *)0) { 204 fprintf(stderr, gettext("cachefspack: ")); 205 fprintf(stderr, gettext("missing version\n")); 206 fprintf(stderr, gettext("cachefspack: ")); 207 fprintf(stderr, gettext( 208 "version = %d.%d\n"), VERMAJOR, VERMINOR); 209 exit(1); 210 } 211 if (strcmp(version, s) != 0) { 212 fprintf(stderr, gettext( 213 "cachefspack: ")); 214 fprintf(stderr, gettext( 215 "WARNING - version of packing rules ")); 216 fprintf(stderr, gettext( 217 "does not match cachefspack version\n")); 218 fprintf(stderr, gettext( 219 "version = %d.%d\n"), VERMAJOR, VERMINOR); 220 } 221 } 222 } 223 /* 224 * Tack local IGNORE strings to end of globals 225 */ 226 if (lign_hd.i_next != (struct item *)0) { 227 last_gign->i_next = &lign_hd; 228 } 229 do_base_dir(basedir, &list_hd, &gign_hd, rulefunc); 230 } 231 232 struct item * 233 add_item(struct item *last_item, char *str, int flags) 234 { 235 struct item * add_cmd_items(); 236 237 if (*str == CMDCHAR) { 238 last_item = add_cmd_items(last_item, &str[1], bang_list_flags); 239 } else { 240 last_item->i_next = (struct item *)mmalloc( 241 sizeof (struct item)); 242 last_item = last_item->i_next; 243 last_item->i_str = mstrdup(str); 244 last_item->i_flag = flags; 245 last_item->i_next = (struct item *)0; 246 } 247 return (last_item); 248 } 249 250 struct item * 251 add_cmd_items(struct item *last_item, char *str, int flags) 252 { 253 FILE *fd; 254 char inbuf[MAX_RULE_SZ]; 255 char *olddir = NULL; 256 char *s; 257 void getcmd(char *, char *); 258 259 if ((basedir != NULL) && (basedir[0] != '\0')) { 260 olddir = getcwd(NULL, MAXPATHLEN + 1); 261 if (olddir == NULL) { 262 fprintf(stderr, gettext("cannot malloc buffer\n")); 263 exit(1); 264 } 265 266 if (chdir(basedir) != 0) { 267 fprintf(stderr, gettext("cannot chdir to %s: %s\n"), 268 basedir, strerror(errno)); 269 exit(1); 270 } 271 } 272 273 getcmd(str, inbuf); 274 fd = popen(inbuf, "r"); 275 if (fd == NULL) { 276 fprintf(stderr, gettext("cachefspack: LIST can't execute - ")); 277 fprintf(stderr, "%s\n", inbuf); 278 exit(1); 279 } 280 281 while (s = lex(fd)) { 282 last_item = add_item(last_item, s, flags); 283 while (s = lex(0)) { 284 last_item = add_item(last_item, s, flags); 285 } 286 } 287 if (pclose(fd) < 0) { 288 fprintf(stderr, gettext("cachefspack: can't close pipe\n")); 289 } 290 291 if (olddir != NULL) { 292 if (chdir(olddir) != 0) { 293 fprintf(stderr, gettext("cannot return to %s: %s\n"), 294 olddir, strerror(errno)); 295 exit(1); 296 } 297 free(olddir); 298 } 299 300 return (last_item); 301 } 302 303 void 304 getcmd(char *str, char *buf) 305 { 306 char *s; 307 308 strcpy(buf, str); 309 strcat(buf, " "); 310 while (s = lex(0)) { 311 strcat(buf, s); 312 strcat(buf, " "); 313 } 314 #ifdef DEBUG 315 printf("getcmd: cmd = %s\n", buf); 316 #endif /* DEBUG */ 317 } 318 319 /* 320 * routine: 321 * lex 322 * 323 * purpose: 324 * my own version of strtok that handles quoting and escaping 325 * 326 * parameters: 327 * string to be lexed (or 0 for same string) 328 * 329 * returns: 330 * pointer to next token 331 * 332 * notes: 333 * this routine makes no changes to the string it is passed, 334 * copying tokens into a static buffer. 335 */ 336 char * 337 lex(FILE *fd) 338 { char c, delim; 339 char *p; 340 const char *s; 341 static const char *savep = 0; 342 static char namebuf[MAX_RULE_SZ]; 343 static char inbuf[MAX_RULE_SZ]; 344 int len, space_left; 345 char *err; 346 347 /* 348 * if the file descriptor is non-zero read a new command. Otherwise 349 * get fields from current line. 350 */ 351 if (fd != 0) { 352 len = 0; 353 space_left = sizeof (inbuf); 354 while ((err = fgets(&inbuf[len], space_left, fd)) != NULL) { 355 len = strlen(inbuf); 356 if (len == 1) { 357 /* 358 * must be a blank line starting command. 359 * If a blank line occurs after the start of 360 * a command, blanks will be included in the 361 * command. 362 */ 363 len = 0; 364 continue; 365 } 366 len -= 2; 367 space_left -= len; 368 s = (char *)((int)inbuf + len); 369 /* 370 * Continuation character 371 */ 372 if (strcmp(s, "\\\n") == 0) { 373 continue; 374 } 375 break; 376 } 377 if (err == NULL) { 378 return (err); 379 } 380 s = inbuf; 381 } else { 382 if (savep == 0) 383 return (0); 384 s = savep; 385 } 386 savep = 0; 387 388 /* skip over leading white space */ 389 while (isspace(*s)) 390 s++; 391 if (*s == 0) { 392 return (0); 393 } 394 395 /* see if this is a quoted string */ 396 c = *s; 397 if (c == '\'' || c == '"') { 398 delim = c; 399 s++; 400 } else 401 delim = 0; 402 403 /* copy the token into the buffer */ 404 for (p = namebuf; (c = *s) != 0; s++) { 405 if ((p - namebuf) >= sizeof (namebuf)) { 406 savep = 0; 407 return (0); 408 } 409 /* literal escape */ 410 if (c == '\\') { 411 s++; 412 *p++ = *s; 413 continue; 414 } 415 416 /* closing delimiter */ 417 if (c == delim) { 418 s++; 419 break; 420 } 421 422 /* delimiting white space */ 423 if (delim == 0 && isspace(c)) 424 break; 425 426 /* ordinary characters */ 427 *p++ = *s; 428 } 429 430 431 /* remember where we left off */ 432 savep = *s ? s : 0; 433 434 /* null terminate and return the buffer */ 435 *p = 0; 436 return (namebuf); 437 } 438 439 char * 440 mk_base_dir(char *path, char *linkpath) 441 { 442 static char pathb[MAXPATHLEN]; 443 char *dnam; 444 char *get_dirname(char *); 445 int len; 446 447 /* 448 * absolute path name 449 */ 450 if (*linkpath == '/') { 451 strcpy(pathb, linkpath); 452 } else { 453 /* 454 * relative path 455 */ 456 dnam = get_dirname(path); 457 if (dnam == (char *)0) { 458 return ((char *) 0); 459 } 460 strcpy(pathb, dnam); 461 len = strlen(pathb); 462 if (len == 0) 463 return (pathb); 464 if (pathb[len-1] != '/') 465 strcat(pathb, "/"); 466 if (strncmp(linkpath, "../", 3) == 0) { 467 /* 468 * path is relative to directory containing sym link 469 * remove "../" from beginning of linkpath 470 */ 471 strcat(pathb, &linkpath[3]); 472 } else { 473 /* 474 * path is relative to directory containing sym link 475 */ 476 strcat(pathb, linkpath); 477 } 478 } 479 return (pathb); 480 } 481