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) 1995 Sun Microsystems, Inc. All Rights Reserved 24 * 25 * module: 26 * rules.c 27 * 28 * purpose: 29 * to read and write the rules file and manage rules lists 30 * 31 * contents: 32 * reading rules file 33 * read_rules 34 * (static) read_command 35 * writing rules file 36 * write_rules 37 * (static) rw_header, rw_base 38 * adding rules 39 * add_ignore, add_include 40 * (static) add_rule 41 * adding/checking restrictions 42 * add_restr, check_restr 43 */ 44 #pragma ident "%Z%%M% %I% %E% SMI" 45 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <time.h> 50 #include <ctype.h> 51 52 #include "filesync.h" 53 #include "database.h" 54 #include "messages.h" 55 #include "debug.h" 56 57 /* 58 * routines: 59 */ 60 static errmask_t rw_base(FILE *file, struct base *bp); 61 static errmask_t rw_header(FILE *file); 62 static errmask_t add_rule(struct base *, int, const char *); 63 static char *read_cmd(char *); 64 65 /* 66 * globals 67 */ 68 static int rules_added; 69 static int restr_added; 70 71 /* 72 * locals 73 */ 74 #define RULE_MAJOR 1 /* rules file format major rev */ 75 #define RULE_MINOR 1 /* rules file format minor rev */ 76 #define RULE_TAG "PACKINGRULES" /* magic string for rules files */ 77 78 /* 79 * routine: 80 * read_rules 81 * 82 * purpose: 83 * to read in the rules file 84 * 85 * parameters: 86 * name of rules file 87 * 88 * returns: 89 * error mask 90 * 91 * notes: 92 * later when I implement a proper (comment preserving) update 93 * function I'm going to wish I had figured out how to build the 94 * input functions for this function in a way that would make 95 * the more usable for that too. 96 */ 97 errmask_t 98 read_rules(char *name) 99 { FILE *file; 100 errmask_t errs = 0; 101 int flags; 102 int major, minor; 103 char *s, *s1, *s2; 104 struct base *bp; 105 char *errstr = "???"; 106 107 file = fopen(name, "r"); 108 if (file == NULL) { 109 fprintf(stderr, gettext(ERR_open), gettext(TXT_rules), 110 name); 111 return (ERR_FILES); 112 } 113 114 lex_linenum = 0; 115 116 if (opt_debug & DBG_FILES) 117 fprintf(stderr, "FILE: READ RULES %s\n", name); 118 119 bp = &omnibase; /* default base before any others */ 120 121 while (!feof(file)) { 122 /* find the first token on the line */ 123 s = lex(file); 124 125 /* skip blank lines and comments */ 126 if (s == 0 || *s == 0 || *s == '#' || *s == '*') 127 continue; 128 129 /* see if the first token is a known keyword */ 130 if (strcmp(s, "BASE") == 0) { 131 132 /* get the source & destination tokens */ 133 errstr = gettext(TXT_srcdst); 134 s1 = lex(0); 135 if (s1 == 0) 136 goto bad; 137 s1 = strdup(s1); 138 139 s2 = lex(0); 140 if (s2 == 0) 141 goto bad; 142 s2 = strdup(s2); 143 144 /* creat the new base pair */ 145 bp = add_base(s1, s2); 146 bp->b_flags |= F_LISTED; 147 148 free(s1); 149 free(s2); 150 continue; 151 } 152 153 if (strcmp(s, "LIST") == 0) { 154 155 /* make sure we are associated with a real base */ 156 if (bp == &omnibase) { 157 errstr = gettext(TXT_nobase); 158 goto bad; 159 } 160 161 /* skip to the next token */ 162 s = lex(0); 163 errstr = gettext(TXT_noargs); 164 if (s == 0) 165 goto bad; 166 167 /* see if it is a program or a name */ 168 if (*s == '!') { 169 errs |= add_rule(bp, R_PROGRAM, 170 read_cmd(&s[1])); 171 } else { 172 do { 173 flags = wildcards(s) ? R_WILD : 0; 174 errs |= add_rule(bp, flags, s); 175 s = lex(0); 176 } while (s != 0); 177 } 178 continue; 179 } 180 181 if (strcmp(s, "IGNORE") == 0) { 182 183 /* skip to the next token */ 184 s = lex(0); 185 errstr = gettext(TXT_noargs); 186 if (s == 0) 187 goto bad; 188 189 flags = R_IGNORE; 190 191 /* see if it is a program or a name */ 192 if (*s == '!') { 193 errs |= add_rule(bp, R_PROGRAM|flags, 194 read_cmd(&s[1])); 195 } else { 196 do { 197 if (wildcards(s)) 198 flags |= R_WILD; 199 errs |= add_rule(bp, flags, s); 200 s = lex(0); 201 } while (s != 0); 202 } 203 continue; 204 } 205 206 if (strcmp(s, "VERSION") == 0 || strcmp(s, RULE_TAG) == 0) { 207 s = lex(0); 208 errstr = gettext(TXT_noargs); 209 if (s == 0) 210 goto bad; 211 212 major = strtol(s, &s1, 10); 213 errstr = gettext(TXT_badver); 214 if (*s1 != '.') 215 goto bad; 216 minor = strtol(&s1[1], 0, 10); 217 218 if (major != RULE_MAJOR || minor > RULE_MINOR) { 219 fprintf(stderr, gettext(ERR_badver), 220 major, minor, gettext(TXT_rules), name); 221 errs |= ERR_FILES; 222 } 223 continue; 224 } 225 226 bad: /* log the error and continue processing to find others */ 227 fprintf(stderr, gettext(ERR_badinput), 228 lex_linenum, errstr, name); 229 errs |= ERR_FILES; 230 } 231 232 233 (void) fclose(file); 234 return (errs); 235 } 236 237 /* 238 * routine: 239 * read_cmd 240 * 241 * purpose: 242 * to lex a runnable command (! lines) into a buffer 243 * 244 * parameters: 245 * first token 246 * 247 * returns: 248 * pointer to a command line in a static buffer 249 * (it is assumed the caller will copy it promptly) 250 * 251 * notes: 252 * this is necessary because lex has already choped off 253 * the first token for us 254 */ 255 static char *read_cmd(char * s) 256 { 257 static char cmdbuf[ MAX_LINE ]; 258 259 cmdbuf[0] = 0; 260 261 do { 262 if (*s) { 263 strcat(cmdbuf, s); 264 strcat(cmdbuf, " "); 265 } 266 } while ((s = lex(0)) != 0); 267 268 return (cmdbuf); 269 } 270 271 /* 272 * routine: 273 * write_rules 274 * 275 * purpose: 276 * to rewrite the rules file, appending the new rules 277 * 278 * parameters: 279 * name of output file 280 * 281 * returns: 282 * error mask 283 * 284 */ 285 errmask_t 286 write_rules(char *name) 287 { FILE *newfile; 288 errmask_t errs = 0; 289 struct base *bp; 290 char tmpname[ MAX_PATH ]; 291 292 /* if no-touch is specified, we don't update files */ 293 if (opt_notouch || rules_added == 0) 294 return (0); 295 296 /* create a temporary output file */ 297 sprintf(tmpname, "%s-TMP", name); 298 299 /* create our output file */ 300 newfile = fopen(tmpname, "w+"); 301 if (newfile == NULL) { 302 fprintf(stderr, gettext(ERR_creat), gettext(TXT_rules), 303 name); 304 return (ERR_FILES); 305 } 306 307 if (opt_debug & DBG_FILES) 308 fprintf(stderr, "FILE: UPDATE RULES %s\n", name); 309 310 errs |= rw_header(newfile); 311 errs |= rw_base(newfile, &omnibase); 312 for (bp = bases; bp; bp = bp->b_next) 313 errs |= rw_base(newfile, bp); 314 315 if (ferror(newfile)) { 316 fprintf(stderr, gettext(ERR_write), gettext(TXT_rules), 317 tmpname); 318 errs |= ERR_FILES; 319 } 320 321 if (fclose(newfile)) { 322 fprintf(stderr, gettext(ERR_fclose), gettext(TXT_rules), 323 tmpname); 324 errs |= ERR_FILES; 325 } 326 327 /* now switch the new file for the old one */ 328 if (errs == 0) 329 if (rename(tmpname, name) != 0) { 330 fprintf(stderr, gettext(ERR_rename), 331 gettext(TXT_rules), tmpname, name); 332 errs |= ERR_FILES; 333 } 334 335 return (errs); 336 } 337 338 /* 339 * routine: 340 * rw_header 341 * 342 * purpose: 343 * to write out a rules header 344 * 345 * parameters: 346 * FILE* for the output file 347 * 348 * returns: 349 * error mask 350 * 351 * notes: 352 */ 353 static errmask_t rw_header(FILE *file) 354 { 355 time_t now; 356 struct tm *local; 357 358 /* figure out what time it is */ 359 (void) time(&now); 360 local = localtime(&now); 361 362 fprintf(file, "%s %d.%d\n", RULE_TAG, RULE_MAJOR, RULE_MINOR); 363 fprintf(file, "#\n"); 364 fprintf(file, "# filesync rules, last written by %s, %s", 365 cuserid((char *) 0), asctime(local)); 366 fprintf(file, "#\n"); 367 368 return (0); 369 } 370 371 /* 372 * routine: 373 * rw_base 374 * 375 * purpose: 376 * to write out the summary for one base-pair 377 * 378 * parameters: 379 * FILE * for the output file 380 * 381 * returns: 382 * error mask 383 * 384 * notes: 385 */ 386 static errmask_t rw_base(FILE *file, struct base *bp) 387 { struct rule *rp; 388 389 fprintf(file, "\n"); 390 391 /* global rules don't appear within a base */ 392 if (bp->b_ident) 393 fprintf(file, "BASE %s %s\n", noblanks(bp->b_src_spec), 394 noblanks(bp->b_dst_spec)); 395 396 for (rp = bp->b_includes; rp; rp = rp->r_next) 397 if (rp->r_flags & R_PROGRAM) 398 fprintf(file, "LIST !%s\n", rp->r_file); 399 else 400 fprintf(file, "LIST %s\n", noblanks(rp->r_file)); 401 402 for (rp = bp->b_excludes; rp; rp = rp->r_next) 403 if (rp->r_flags & R_PROGRAM) 404 fprintf(file, "IGNORE !%s\n", rp->r_file); 405 else 406 fprintf(file, "IGNORE %s\n", noblanks(rp->r_file)); 407 408 return (0); 409 } 410 411 /* 412 * routine: 413 * add_rule 414 * 415 * purpose: 416 * to add a new rule 417 * 418 * parameters: 419 * pointer to list base 420 * rule flags 421 * associated name/arguments 422 * 423 * returns: 424 * error flags 425 * 426 * notes: 427 * we always copy the argument string because most of them 428 * were read from a file and are just in a transient buffer 429 */ 430 static errmask_t add_rule(struct base *bp, int flags, const char *args) 431 { struct rule *rp; 432 struct rule **list; 433 434 rp = malloc(sizeof (struct rule)); 435 if (rp == 0) 436 nomem("rule struture"); 437 438 /* initialize the new base */ 439 memset((void *) rp, 0, sizeof (struct rule)); 440 rp->r_flags = flags; 441 rp->r_file = strdup(args); 442 443 /* figure out which list to put it on */ 444 if (flags&R_IGNORE) 445 list = &bp->b_excludes; 446 else if (flags&R_RESTRICT) 447 list = &bp->b_restrictions; 448 else 449 list = &bp->b_includes; 450 451 while (*list) 452 list = &((*list)->r_next); 453 *list = rp; 454 455 if (flags & R_NEW) 456 rules_added++; 457 458 if (opt_debug & DBG_RULE) { 459 fprintf(stderr, "RULE: base=%d, ", bp->b_ident); 460 fprintf(stderr, "flags=%s, ", 461 showflags(rflags, rp->r_flags)); 462 fprintf(stderr, "arg=%s\n", rp->r_file); 463 } 464 465 return (0); 466 } 467 468 /* 469 * routine: 470 * add_ignore, add_include 471 * 472 * purpose: 473 * wrappers for add_rule that permit outsiders (like main.c) 474 * not to know what is inside of a base, file, or list entry 475 * 476 * parameters: 477 * base under which rules should be added 478 * argument associated with rule 479 * 480 * returns: 481 * error flags 482 * 483 * notes: 484 * basically these routines figure out what the right 485 * flags are for a rule, and what list to put it on, 486 * and then call a common handler. 487 */ 488 errmask_t 489 add_ignore(struct base *bp, char *name) 490 { int flags = R_IGNORE | R_NEW; 491 492 if (bp == 0) 493 bp = &omnibase; 494 495 if (wildcards(name)) 496 flags |= R_WILD; 497 498 return (add_rule(bp, flags, name)); 499 } 500 501 errmask_t 502 add_include(struct base *bp, char *name) 503 { int flags = R_NEW; 504 505 if (bp == 0) 506 bp = &omnibase; 507 508 if (wildcards(name)) 509 flags |= R_WILD; 510 511 bp->b_flags |= F_LISTED; 512 513 return (add_rule(bp, flags, name)); 514 } 515 516 /* 517 * routine: 518 * add_restr 519 * 520 * purpose: 521 * to add a restriction to a base 522 * 523 * parameters: 524 * address of base 525 * restriction string 526 * 527 * returns: 528 * error mask 529 * 530 * notes: 531 * a restriction is specified on the command line and 532 * tells us to limit our analysis/reconcilation to 533 * specified files and/or directories. We deal with 534 * these by adding a restriction rule to any base that 535 * looks like it might fit the restriction. We need to 536 * treat this as a rule because the restriction string 537 * may extend beyond the base directory and part-way into 538 * its tree ... meaning that individual file names under 539 * the base will have to be checked against the restriction. 540 */ 541 errmask_t 542 add_restr(char *restr) 543 { const char *s; 544 errmask_t errs = 0; 545 struct base *bp; 546 547 for (bp = bases; bp; bp = bp->b_next) { 548 /* 549 * see if this restriction could apply to this base. 550 * It could match either the source or destination 551 * directory name for this base. If it matches neither 552 * then the restriction does not apply to this base. 553 */ 554 s = prefix(restr, bp->b_src_name); 555 if (s == 0) 556 s = prefix(restr, bp->b_dst_name); 557 if (s == 0) 558 continue; 559 560 /* 561 * if there is more restriction string after the 562 * base, we will need to note the remainder of the 563 * string so that we can match individual files 564 * against it. 565 */ 566 if (*s == '/') 567 s++; 568 569 errs |= add_rule(bp, R_RESTRICT, s); 570 restr_added++; 571 } 572 573 return (errs); 574 } 575 576 /* 577 * routine: 578 * check_restr 579 * 580 * purpose: 581 * to see if an argument falls within restrictions 582 * 583 * parameters: 584 * pointer to relevant base 585 * file name 586 * 587 * returns: 588 * TRUE name is within restrictions 589 * FALSE name is outside of restrictions 590 * MAYBE name is on the path to a restriction 591 * 592 * notes: 593 * if no restrictions have been specified, we evaluate 594 * everything. If any restrictions have been specified, 595 * we process only files that match one of the restrictions. 596 * 597 * add_restr has ensured that if the restriction includes 598 * a portion that must be matched by individual files under 599 * the base, that the restriction rule will contain that 600 * portion of the restriction which must be matched against 601 * individual file names. 602 */ 603 bool_t 604 check_restr(struct base *bp, const char *name) 605 { struct rule *rp; 606 607 /* if there are no restrictions, everything is OK */ 608 if (restr_added == 0) 609 return (TRUE); 610 611 /* now we have to run through the list */ 612 for (rp = bp->b_restrictions; rp; rp = rp->r_next) { 613 /* see if current path is under the restriction */ 614 if (prefix(name, rp->r_file)) 615 return (TRUE); 616 617 /* see if current path is on the way to restr */ 618 if (prefix(rp->r_file, name)) 619 /* 620 * this is kinky, but walker really needs 621 * to know the difference between a directory 622 * that we are unreservedly scanning, and one 623 * that we are scanning only to find something 624 * beneath it. 625 */ 626 return (MAYBE); 627 } 628 629 /* 630 * there are restrictions in effect and this file doesn't seem 631 * to meet any of them 632 */ 633 if (opt_debug & DBG_RULE) 634 fprintf(stderr, "RULE: FAIL RESTRICTION base=%d, file=%s\n", 635 bp->b_ident, name); 636 637 return (FALSE); 638 } 639