/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1995 Sun Microsystems, Inc. All Rights Reserved * * module: * files.c * * purpose: * routines to examine and manipulate file names * * contents: * qualify ... ensure that a name is fully qualified * expand ... expand env variables within a string or file name * noblanks .. ensure that a name contains no embdded unescaped blanks * lex ....... a lexer that can handle escaped/embedded blanks * wildcards . see whether or not a name contains wild cards * prefix .... does one string begin with another * suffix .... does one string end with another * contains .. does one string contain another * * cannonize (static) ... compress redundant "." and ".." out of name * * notes: * we are interested in embedded blanks because international * character sets and non-unix file systems can both contain * the byte 0x20. Thus, whenever we record a filename in * file, we must be careful to escape any embedded blanks that * cause trouble when we re-lex that file later. */ #ident "%W% %E% SMI" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <unistd.h> #include "filesync.h" #include "messages.h" static void cannonize(char *name); /* * routine: * qualify * * purpose: * to fully qualify a name * * parameters: * name to be qualified * * returns: * either original pointer or copy to a new (malloced) buffer * * notes: * someday I may conclude that I should always make a copy * so that the caller can know that it is safe to free the parm * * I thought about this and concluded that there is never a need * to fully qualify a string containing variables. If the string * came from the command line, the variables were already expanded * and if it came from the rules data base it is required to already * be fully qualified. */ char * qualify(char *name) { char namebuf[ MAX_PATH ]; /* in the simple case, the parameter is already there */ if (*name == '/') { cannonize(name); return (name); } /* things that begin with variables get the benefit of the doubt */ if (*name == '$') { cannonize(name); return (name); } /* start with the current working directory */ if (getcwd(namebuf, sizeof (namebuf)) == 0) { fprintf(stderr, gettext(ERR_nocwd), name); exit(ERR_OTHER); } /* make sure we have room for our file name */ if ((strlen(namebuf) + strlen(name) + 2) >= sizeof (namebuf)) { fprintf(stderr, gettext(ERR_longname), name); exit(ERR_OTHER); } /* append the specified file name to it */ strcat(namebuf, "/"); strcat(namebuf, name); /* filter out redundant dots */ cannonize(namebuf); if (opt_debug & DBG_VARS) fprintf(stderr, "VARS: QUALIFY %s to %s\n", name, namebuf); /* and return a newly malloc'd copy */ return (strdup(namebuf)); } /* * routine: * expand * * purpose: * to expand variable names within a string * * parameters: * string to be expanded. Variable references always begin * with a $ and are delimited by parens or curleys. * * returns: * either original pointer or a copy to a new (malloced) buffer * * notes: * someday I may conclude that I should always make a copy * so that the caller can know that it is safe to free the parm * * someday I may decide to support escape conventions for embedding * $(){} in file names, but I suspec that day will never come. * * I thought about this and concluded there was no reason to * fully qualify these names, because the only names that should * need qualification are src/dst lines from the command line, * and the shell should have handled those for me. Once something * makes it into the database, it is expected to be fully qualified * already. * * We are limited to producing strings of length MAX_PATH or less * and variable names of length MAX_NAME or less. In practice, * these limitations should not be a problem. */ char * expand(char *name) { const char *s; char *p, *v; char delim; char namebuf[ MAX_PATH ]; char varbuf[ MAX_NAME ]; /* first see if there are no variables to be bound */ for (s = name; *s && *s != '$'; s++); if (*s == 0) return (name); /* move through the string, copying and expanding */ for (s = name, p = namebuf; *s; s++) { /* check for overflow */ if (p >= &namebuf[ MAX_PATH ]) { fprintf(stderr, gettext(ERR_longname), name); exit(ERR_OTHER); } /* normal characters, we just copy */ if (*s != '$') { *p++ = *s; continue; } /* figure out how the variable name is delimited */ delim = *++s; if (delim == '(') { delim = ')'; s++; } else if (delim == '{') { delim = '}'; s++; } else delim = 0; /* copy the variable name up to the closing delimiter */ for (v = varbuf; *s; s++) { if (isalnum(*s) || (*s == '_') || (delim && *s != delim)) *v++ = *s; else break; /* make sure we don't overflow var name buffer */ if (v >= &varbuf[MAX_NAME - 1]) { *v = 0; fprintf(stderr, gettext(ERR_longname), varbuf); exit(ERR_OTHER); } } *v = 0; /* FIX THIS ... there must be a more elegant way */ /* we may have to back up because s will be bumped */ if (delim == 0 || *s != delim) s--; /* look up the variable */ v = getenv(varbuf); if (v == 0 || *v == 0) { fprintf(stderr, gettext(ERR_undef), varbuf); return (0); } /* copy the variable into the buffer */ while (*v) *p++ = *v++; } /* null terminate the copy */ *p = 0; /* compress out any redundant dots and dot-dots */ cannonize(namebuf); if (opt_debug & DBG_VARS) fprintf(stderr, "VARS: EXPAND %s to %s\n", name, namebuf); /* and return a newly malloc'd copy */ return (strdup(namebuf)); } /* * routine: * noblanks * * purpose: * to ensure that a name contains no unescaped embedded blanks * * parameters: * pointer to name * * returns: * pointer to name or pointer to buffer containing escaped version of name * * notes: * this routine can be called on full file names, and so can * conceivably require an arbitrarily large buffer. */ const char * noblanks(const char *name) { const char *s; char *p; static char *namebuf = 0; static int buflen = 0; int l; /* first see if there are no embedded blanks */ for (s = name; *s && *s != ' '; s++); if (*s == 0) return (name); /* make sure we have a buffer large enough for the worst case */ l = 4 + (2*strlen(name)); for (buflen = MAX_PATH; buflen < l; buflen += MAX_NAME); namebuf = (char *) realloc(namebuf, buflen); /* quote the name, and copy it, escaping quotes */ p = namebuf; *p++ = '"'; for (s = name; *s; s++) { if (*s == '"' || *s == '\\') *p++ = '\\'; *p++ = *s; } *p++ = '"'; *p = 0; return (namebuf); } /* * routine: * lex * * purpose: * my own version of strtok that handles quoting and escaping * * parameters: * FILE structure for file to read (0 for same string, same file) * * returns: * pointer to next token * * notes: * this routine makes no changes to the string it is passed, * copying tokens into a static buffer. * * this routine handles continuation lines after reading and * before the lexing even starts. This limits continued lines * to a length of MAX_LINE, but keeps everything else very simple. * We also, therefore, limit tokens to a maximum length of MAX_LINE. */ int lex_linenum; /* line number in current input file */ char * lex(FILE *file) { char c, delim; char *p; char *s; static char *savep; static char namebuf[ MAX_LINE ]; static char inbuf[ MAX_LINE ]; if (file) { /* read a new line */ p = inbuf + sizeof (inbuf); /* read the next input line, with all continuations */ for (s = inbuf; savep = fgets(s, p - s, file); ) { lex_linenum++; /* go find the last character of the input line */ while (*s && s[1]) s++; if (*s == '\n') s--; /* see whether or not we need a continuation */ if (s < inbuf || *s != '\\') break; continue; } if (savep == 0) return (0); s = inbuf; } else { /* continue with old line */ if (savep == 0) return (0); s = savep; } savep = 0; /* skip over leading white space */ while (isspace(*s)) s++; if (*s == 0) return (0); /* see if this is a quoted string */ c = *s; if (c == '\'' || c == '"') { delim = c; s++; } else delim = 0; /* copy the token into the buffer */ for (p = namebuf; (c = *s) != 0; s++) { /* literal escape */ if (c == '\\') { s++; *p++ = *s; continue; } /* closing delimiter */ if (c == delim) { s++; break; } /* delimiting white space */ if (delim == 0 && isspace(c)) break; /* ordinary characters */ *p++ = *s; } /* remember where we left off */ savep = *s ? s : 0; /* null terminate and return the buffer */ *p = 0; return (namebuf); } /* * routine: * wildcards * * purpose: * determine whether or not there are any wild cards in a name * * parameters: * name to be checked * * returns: * true/false * * notes: * we use this to take shortcuts */ bool_t wildcards(const char *name) { const char *s; int literal = 0; for (s = name; *s; s++) if (literal) switch (*s) { case '\'': /* end of literal string */ literal = 0; continue; case '\\': /* escape next character */ s++; continue; } else switch (*s) { case '\'': /* literal string */ literal = 1; continue; case '\\': /* escape next character */ s++; continue; case '*': case '[': case '{': case '?': /* any of these is a wild card */ return (TRUE); } return (FALSE); } /* * routine: * cannonize * * purpose: * to compress redundant dots out of a path * * parameters: * file name in an editable buffer * * returns: * void * * notes: * because we compress the string in place, there is no danger * of our overflowing any fixed sized buffer. */ static void cannonize(char *name) { char *s, *p; /* leading dot-slashes */ for (s = name; *s == '.' && s[1] == '/'; strcpy(s, &s[2])); for (s = name; *s; s++) { /* interesting things happen after slashes */ if (*s != '/') continue; /* embedded dot-slashes */ while (s[1] == '.' && s[2] == '/') strcpy(&s[1], &s[3]); /* embedded slash-dot-dot-slash */ if (strncmp(s, "/../", 4) == 0) { /* scan backwards to eliminate last directory */ for (p = s-1; p > name && *p != '/'; p--); if (p < name) p = name; strcpy(p, &s[3]); } continue; } } /* * routine: * prefix * * purpose: * determine whether or not one string begins with another * * parameters: * string to be tested * suspected prefix * * returns: * no 0 * yes pointer character after prefix */ const char * prefix(const char *s, const char *p) { while (*p) if (*p++ != *s++) return (0); return (s); } /* * routine: * suffix * * purpose: * determine whether or not one string ends with another * * parameters: * string to be tested * suspected suffix * * returns: * true/false */ bool_t suffix(const char *str, const char *suf) { const char *s; /* go to where the alleged suffix would start */ for (s = str; *s; s++); s -= strlen(suf); if (s < str) return (FALSE); /* see if the string ends with the suffix */ while (*suf) if (*suf++ != *s++) return (FALSE); return (TRUE); } /* * routine: * contains * * purpose: * determine whether or not one string contains another * * parameters: * string to be checked * pattern we are seeking * * returns: * true/false */ bool_t contains(const char *str, const char *pat) { const char *s, *p; while (*str) { if (*str++ == *pat) { for (s = str, p = &pat[1]; *s == *p; s++, p++) if (p[1] == 0) return (TRUE); } } return (FALSE); }
