Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / cmd / filesync / files.c

/*
 * 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);
}