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 * files.c 27 * 28 * purpose: 29 * routines to examine and manipulate file names 30 * 31 * contents: 32 * qualify ... ensure that a name is fully qualified 33 * expand ... expand env variables within a string or file name 34 * noblanks .. ensure that a name contains no embdded unescaped blanks 35 * lex ....... a lexer that can handle escaped/embedded blanks 36 * wildcards . see whether or not a name contains wild cards 37 * prefix .... does one string begin with another 38 * suffix .... does one string end with another 39 * contains .. does one string contain another 40 * 41 * cannonize (static) ... compress redundant "." and ".." out of name 42 * 43 * notes: 44 * we are interested in embedded blanks because international 45 * character sets and non-unix file systems can both contain 46 * the byte 0x20. Thus, whenever we record a filename in 47 * file, we must be careful to escape any embedded blanks that 48 * cause trouble when we re-lex that file later. 49 */ 50 #ident "%W% %E% SMI" 51 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <ctype.h> 56 #include <unistd.h> 57 58 #include "filesync.h" 59 #include "messages.h" 60 61 static void cannonize(char *name); 62 63 /* 64 * routine: 65 * qualify 66 * 67 * purpose: 68 * to fully qualify a name 69 * 70 * parameters: 71 * name to be qualified 72 * 73 * returns: 74 * either original pointer or copy to a new (malloced) buffer 75 * 76 * notes: 77 * someday I may conclude that I should always make a copy 78 * so that the caller can know that it is safe to free the parm 79 * 80 * I thought about this and concluded that there is never a need 81 * to fully qualify a string containing variables. If the string 82 * came from the command line, the variables were already expanded 83 * and if it came from the rules data base it is required to already 84 * be fully qualified. 85 */ 86 char * 87 qualify(char *name) 88 { 89 char namebuf[ MAX_PATH ]; 90 91 /* in the simple case, the parameter is already there */ 92 if (*name == '/') { 93 cannonize(name); 94 return (name); 95 } 96 97 /* things that begin with variables get the benefit of the doubt */ 98 if (*name == '$') { 99 cannonize(name); 100 return (name); 101 } 102 103 /* start with the current working directory */ 104 if (getcwd(namebuf, sizeof (namebuf)) == 0) { 105 fprintf(stderr, gettext(ERR_nocwd), name); 106 exit(ERR_OTHER); 107 } 108 109 /* make sure we have room for our file name */ 110 if ((strlen(namebuf) + strlen(name) + 2) >= sizeof (namebuf)) { 111 fprintf(stderr, gettext(ERR_longname), name); 112 exit(ERR_OTHER); 113 } 114 115 /* append the specified file name to it */ 116 strcat(namebuf, "/"); 117 strcat(namebuf, name); 118 119 /* filter out redundant dots */ 120 cannonize(namebuf); 121 122 if (opt_debug & DBG_VARS) 123 fprintf(stderr, "VARS: QUALIFY %s to %s\n", name, namebuf); 124 125 /* and return a newly malloc'd copy */ 126 return (strdup(namebuf)); 127 } 128 129 /* 130 * routine: 131 * expand 132 * 133 * purpose: 134 * to expand variable names within a string 135 * 136 * parameters: 137 * string to be expanded. Variable references always begin 138 * with a $ and are delimited by parens or curleys. 139 * 140 * returns: 141 * either original pointer or a copy to a new (malloced) buffer 142 * 143 * notes: 144 * someday I may conclude that I should always make a copy 145 * so that the caller can know that it is safe to free the parm 146 * 147 * someday I may decide to support escape conventions for embedding 148 * $(){} in file names, but I suspec that day will never come. 149 * 150 * I thought about this and concluded there was no reason to 151 * fully qualify these names, because the only names that should 152 * need qualification are src/dst lines from the command line, 153 * and the shell should have handled those for me. Once something 154 * makes it into the database, it is expected to be fully qualified 155 * already. 156 * 157 * We are limited to producing strings of length MAX_PATH or less 158 * and variable names of length MAX_NAME or less. In practice, 159 * these limitations should not be a problem. 160 */ 161 char * 162 expand(char *name) 163 { const char *s; 164 char *p, *v; 165 char delim; 166 char namebuf[ MAX_PATH ]; 167 char varbuf[ MAX_NAME ]; 168 169 /* first see if there are no variables to be bound */ 170 for (s = name; *s && *s != '$'; s++); 171 if (*s == 0) 172 return (name); 173 174 /* move through the string, copying and expanding */ 175 for (s = name, p = namebuf; *s; s++) { 176 177 /* check for overflow */ 178 if (p >= &namebuf[ MAX_PATH ]) { 179 fprintf(stderr, gettext(ERR_longname), name); 180 exit(ERR_OTHER); 181 } 182 183 /* normal characters, we just copy */ 184 if (*s != '$') { 185 *p++ = *s; 186 continue; 187 } 188 189 /* figure out how the variable name is delimited */ 190 delim = *++s; 191 if (delim == '(') { 192 delim = ')'; 193 s++; 194 } else if (delim == '{') { 195 delim = '}'; 196 s++; 197 } else 198 delim = 0; 199 200 /* copy the variable name up to the closing delimiter */ 201 for (v = varbuf; *s; s++) { 202 if (isalnum(*s) || (*s == '_') || 203 (delim && *s != delim)) 204 *v++ = *s; 205 else 206 break; 207 208 /* make sure we don't overflow var name buffer */ 209 if (v >= &varbuf[MAX_NAME - 1]) { 210 *v = 0; 211 fprintf(stderr, gettext(ERR_longname), varbuf); 212 exit(ERR_OTHER); 213 } 214 } 215 216 *v = 0; 217 218 /* FIX THIS ... there must be a more elegant way */ 219 /* we may have to back up because s will be bumped */ 220 if (delim == 0 || *s != delim) 221 s--; 222 223 /* look up the variable */ 224 v = getenv(varbuf); 225 if (v == 0 || *v == 0) { 226 fprintf(stderr, gettext(ERR_undef), varbuf); 227 return (0); 228 } 229 230 /* copy the variable into the buffer */ 231 while (*v) 232 *p++ = *v++; 233 } 234 235 /* null terminate the copy */ 236 *p = 0; 237 238 /* compress out any redundant dots and dot-dots */ 239 cannonize(namebuf); 240 241 if (opt_debug & DBG_VARS) 242 fprintf(stderr, "VARS: EXPAND %s to %s\n", name, namebuf); 243 244 /* and return a newly malloc'd copy */ 245 return (strdup(namebuf)); 246 } 247 248 /* 249 * routine: 250 * noblanks 251 * 252 * purpose: 253 * to ensure that a name contains no unescaped embedded blanks 254 * 255 * parameters: 256 * pointer to name 257 * 258 * returns: 259 * pointer to name or pointer to buffer containing escaped version of name 260 * 261 * notes: 262 * this routine can be called on full file names, and so can 263 * conceivably require an arbitrarily large buffer. 264 */ 265 const char * 266 noblanks(const char *name) 267 { 268 const char *s; 269 char *p; 270 static char *namebuf = 0; 271 static int buflen = 0; 272 int l; 273 274 /* first see if there are no embedded blanks */ 275 for (s = name; *s && *s != ' '; s++); 276 if (*s == 0) 277 return (name); 278 279 /* make sure we have a buffer large enough for the worst case */ 280 l = 4 + (2*strlen(name)); 281 for (buflen = MAX_PATH; buflen < l; buflen += MAX_NAME); 282 namebuf = (char *) realloc(namebuf, buflen); 283 284 /* quote the name, and copy it, escaping quotes */ 285 p = namebuf; 286 *p++ = '"'; 287 288 for (s = name; *s; s++) { 289 if (*s == '"' || *s == '\\') 290 *p++ = '\\'; 291 *p++ = *s; 292 } 293 294 *p++ = '"'; 295 *p = 0; 296 297 return (namebuf); 298 } 299 300 /* 301 * routine: 302 * lex 303 * 304 * purpose: 305 * my own version of strtok that handles quoting and escaping 306 * 307 * parameters: 308 * FILE structure for file to read (0 for same string, same file) 309 * 310 * returns: 311 * pointer to next token 312 * 313 * notes: 314 * this routine makes no changes to the string it is passed, 315 * copying tokens into a static buffer. 316 * 317 * this routine handles continuation lines after reading and 318 * before the lexing even starts. This limits continued lines 319 * to a length of MAX_LINE, but keeps everything else very simple. 320 * We also, therefore, limit tokens to a maximum length of MAX_LINE. 321 */ 322 int lex_linenum; /* line number in current input file */ 323 324 char * 325 lex(FILE *file) 326 { char c, delim; 327 char *p; 328 char *s; 329 static char *savep; 330 static char namebuf[ MAX_LINE ]; 331 static char inbuf[ MAX_LINE ]; 332 333 if (file) { /* read a new line */ 334 p = inbuf + sizeof (inbuf); 335 336 /* read the next input line, with all continuations */ 337 for (s = inbuf; savep = fgets(s, p - s, file); ) { 338 lex_linenum++; 339 340 /* go find the last character of the input line */ 341 while (*s && s[1]) 342 s++; 343 if (*s == '\n') 344 s--; 345 346 /* see whether or not we need a continuation */ 347 if (s < inbuf || *s != '\\') 348 break; 349 350 continue; 351 } 352 353 if (savep == 0) 354 return (0); 355 356 s = inbuf; 357 } else { /* continue with old line */ 358 if (savep == 0) 359 return (0); 360 s = savep; 361 } 362 savep = 0; 363 364 /* skip over leading white space */ 365 while (isspace(*s)) 366 s++; 367 if (*s == 0) 368 return (0); 369 370 /* see if this is a quoted string */ 371 c = *s; 372 if (c == '\'' || c == '"') { 373 delim = c; 374 s++; 375 } else 376 delim = 0; 377 378 /* copy the token into the buffer */ 379 for (p = namebuf; (c = *s) != 0; s++) { 380 /* literal escape */ 381 if (c == '\\') { 382 s++; 383 *p++ = *s; 384 continue; 385 } 386 387 /* closing delimiter */ 388 if (c == delim) { 389 s++; 390 break; 391 } 392 393 /* delimiting white space */ 394 if (delim == 0 && isspace(c)) 395 break; 396 397 /* ordinary characters */ 398 *p++ = *s; 399 } 400 401 402 /* remember where we left off */ 403 savep = *s ? s : 0; 404 405 /* null terminate and return the buffer */ 406 *p = 0; 407 return (namebuf); 408 } 409 410 /* 411 * routine: 412 * wildcards 413 * 414 * purpose: 415 * determine whether or not there are any wild cards in a name 416 * 417 * parameters: 418 * name to be checked 419 * 420 * returns: 421 * true/false 422 * 423 * notes: 424 * we use this to take shortcuts 425 */ 426 bool_t 427 wildcards(const char *name) 428 { const char *s; 429 int literal = 0; 430 431 for (s = name; *s; s++) 432 if (literal) 433 switch (*s) { 434 case '\'': /* end of literal string */ 435 literal = 0; 436 continue; 437 case '\\': /* escape next character */ 438 s++; 439 continue; 440 } 441 else 442 switch (*s) { 443 case '\'': /* literal string */ 444 literal = 1; 445 continue; 446 case '\\': /* escape next character */ 447 s++; 448 continue; 449 case '*': 450 case '[': 451 case '{': 452 case '?': 453 /* any of these is a wild card */ 454 return (TRUE); 455 } 456 457 return (FALSE); 458 } 459 460 /* 461 * routine: 462 * cannonize 463 * 464 * purpose: 465 * to compress redundant dots out of a path 466 * 467 * parameters: 468 * file name in an editable buffer 469 * 470 * returns: 471 * void 472 * 473 * notes: 474 * because we compress the string in place, there is no danger 475 * of our overflowing any fixed sized buffer. 476 */ 477 static void 478 cannonize(char *name) 479 { char *s, *p; 480 481 /* leading dot-slashes */ 482 for (s = name; *s == '.' && s[1] == '/'; strcpy(s, &s[2])); 483 484 for (s = name; *s; s++) { 485 /* interesting things happen after slashes */ 486 if (*s != '/') 487 continue; 488 489 /* embedded dot-slashes */ 490 while (s[1] == '.' && s[2] == '/') 491 strcpy(&s[1], &s[3]); 492 493 /* embedded slash-dot-dot-slash */ 494 if (strncmp(s, "/../", 4) == 0) { 495 /* scan backwards to eliminate last directory */ 496 for (p = s-1; p > name && *p != '/'; p--); 497 498 if (p < name) 499 p = name; 500 strcpy(p, &s[3]); 501 } 502 503 continue; 504 } 505 } 506 507 /* 508 * routine: 509 * prefix 510 * 511 * purpose: 512 * determine whether or not one string begins with another 513 * 514 * parameters: 515 * string to be tested 516 * suspected prefix 517 * 518 * returns: 519 * no 0 520 * yes pointer character after prefix 521 */ 522 const char * 523 prefix(const char *s, const char *p) 524 { 525 while (*p) 526 if (*p++ != *s++) 527 return (0); 528 529 return (s); 530 } 531 532 /* 533 * routine: 534 * suffix 535 * 536 * purpose: 537 * determine whether or not one string ends with another 538 * 539 * parameters: 540 * string to be tested 541 * suspected suffix 542 * 543 * returns: 544 * true/false 545 */ 546 bool_t 547 suffix(const char *str, const char *suf) 548 { const char *s; 549 550 /* go to where the alleged suffix would start */ 551 for (s = str; *s; s++); 552 s -= strlen(suf); 553 if (s < str) 554 return (FALSE); 555 556 /* see if the string ends with the suffix */ 557 while (*suf) 558 if (*suf++ != *s++) 559 return (FALSE); 560 561 return (TRUE); 562 } 563 564 /* 565 * routine: 566 * contains 567 * 568 * purpose: 569 * determine whether or not one string contains another 570 * 571 * parameters: 572 * string to be checked 573 * pattern we are seeking 574 * 575 * returns: 576 * true/false 577 */ 578 bool_t 579 contains(const char *str, const char *pat) 580 { const char *s, *p; 581 582 while (*str) { 583 if (*str++ == *pat) { 584 for (s = str, p = &pat[1]; *s == *p; s++, p++) 585 if (p[1] == 0) 586 return (TRUE); 587 } 588 } 589 590 return (FALSE); 591 } 592