Move /var/svc/log to /var/log/svc

[unleashed/lotheac.git] / usr / src / cmd / filesync / base.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:
 *      base.c
 *
 * purpose:
 *      routines to create, traverse, read and write the baseline database
 *
 * contents:
 *      manipulation:
 *              add_base, add_file_to_base, add_file_to_dir
 *              (static) add_file_to_list
 *      reading baseline:
 *              read_baseline
 *              (static) gettype
 *      writing baseline:
 *              write_baseline
 *              (static) bw_header, bw_base, bw_file, showtype
 */
#ident  "%W%    %E% SMI"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

#include "filesync.h"
#include "database.h"
#include "messages.h"

#define BASE_MAJOR      1               /* base file format major rev   */
#define BASE_MINOR      2               /* base file format minor rev   */
#define BASE_TAG        "filesync-BaseLine"

/*
 * globals
 */
struct base omnibase;                   /* dummy to hold global rules   */
struct base *bases;                     /* pointer to the base list     */

/*
 * locals
 */
static int num_bases;                   /* used to generate sequence #s */
static errmask_t bw_header(FILE *);     /* write out baseline header    */
static errmask_t bw_base(FILE *, struct base *); /* write out one base  */
static errmask_t bw_file(FILE *, struct file *, int);
static struct file *add_file_to_list(struct file **, const char *);
static char showtype(int);
static long gettype(int);

/*
 * routine:
 *      add_base
 *
 * purpose:
 *      to find a base pair in the chain, adding it if necessary
 *
 * parameters:
 *      spec for source directory
 *      spec for dest directory
 *
 * returns:
 *      pointer to the base pair
 *
 */
struct base *
add_base(const char *src, const char *dst)
{       struct base *bp, **bpp;

        /* first see if we already have it */
        for (bpp = &bases; (bp = *bpp) != 0; bpp = &bp->b_next) {
                /* base must match on both src and dst  */
                if (strcmp(src, bp->b_src_spec))
                        continue;
                if (strcmp(dst, bp->b_dst_spec))
                        continue;

                if (opt_debug & DBG_BASE)
                        fprintf(stderr, "BASE: FOUND base=%d, src=%s, dst=%s\n",
                                bp->b_ident, src, dst);
                return (bp);
        }

        /* no joy, so we have to allocate one           */
        bp = malloc(sizeof (struct base));
        if (bp == 0)
                nomem("base structure");

        /* initialize the new base                      */
        memset(bp, 0, sizeof (struct base));
        bp->b_ident = ++num_bases;
        bp->b_src_spec = strdup(src);
        bp->b_dst_spec = strdup(dst);

        /* names are expanded at run-time, and this is run-time */
        if ((bp->b_src_name = expand(bp->b_src_spec)) == 0) {
                fprintf(stderr, gettext(ERR_badbase), bp->b_src_spec);
                exit(ERR_FILES);
        }

        if ((bp->b_dst_name = expand(bp->b_dst_spec)) == 0) {
                fprintf(stderr, gettext(ERR_badbase), bp->b_dst_spec);
                exit(ERR_FILES);
        }

        /* chain it in                                  */
        *bpp = bp;

        if (opt_debug & DBG_BASE)
                fprintf(stderr, "BASE: ADDED base=%d, src=%s, dst=%s\n",
                        bp->b_ident, src, dst);

        return (bp);
}

/*
 * routine:
 *      add_file_to_list
 *
 * purpose:
 *      to find a file on a list, or if necessary add it to the list
 *
 *      this is an internal routine, used only by add_file_to_base
 *      and add_file_to_dir.
 *
 * parameters:
 *      pointer to the list head
 *
 * returns:
 *      pointer to a file structure
 *
 * notes:
 *
 *      list is sorted to provide some search optimization
 *
 *      most files are in the baseline, and so come in in alphabetical
 *      order.  If we keep a guess pointer to the last file we added/found,
 *      there is a better than even chance that this one should be
 *      added immediately onto the end of it ... and in so doing we
 *      can save ourselves the trouble of searching the lists most
 *      of the time.
 *
 *      this win would be even better if the FTW traversal was sorted,
 *      but building the baseline is enough of a win to justify the
 *      feature ... but even without this we run a 60%-70% hit rate.
 */
static struct file *
add_file_to_list(struct file **pp, const char *name)
{       struct file *fp, *new;
        int rslt;

        static struct file **last_list;
        static struct file *last_file;

        /*
         * start with the guess pointer, we hope to find that
         * this request will be satisfied by the next file in
         * the list.  The two cases we are trying to optimize
         * are:
         *      appending to the list, with appends in alphabetical order
         *      searches of the list, with searches in alphabetical order
         */
        if (last_list == pp && (new = last_file) != 0) {
                /* we like to think we belong farther down-list */
                if (strcmp(name, new->f_name) > 0) {
                        fp = new->f_next;
                        /* if we're at the end, we just won     */
                        if (fp == 0) {
                                pp = &new->f_next;
                                goto makeit;
                        }

                        /* or if the next one is what we want   */
                        if (strcmp(name, fp->f_name) == 0) {
                                fp->f_flags &= ~F_NEW;
                                new = fp;
                                goto gotit;
                        }
                }
        }

        /*
         * our guess pointer failed, so it is exhaustive search time
         */
        last_list = pp;

        for (fp = *pp; fp; pp = &fp->f_next, fp = *pp) {
                rslt = strcmp(name, fp->f_name);

                /* see if we got a match        */
                if (rslt == 0) {
                        fp->f_flags &= ~F_NEW;
                        new = fp;
                        goto gotit;
                }

                /* see if we should go no farther       */
                if (rslt < 0)
                        break;
        }

makeit:
        /*
         * we didn't find it:
         *      pp points at where our pointer should go
         *      fp points at the node after ours
         */
        new = (struct file *) malloc(sizeof (*new));
        if (new == 0)
                nomem("file structure");

        /* initialize the new node      */
        memset(new, 0, sizeof (struct file));
        new->f_name = strdup(name);
        new->f_flags = F_NEW;

        /* chain it into the list       */
        new->f_next = fp;
        *pp = new;

gotit:  /* remember this as our next guess pointer      */
        last_file = new;
        return (new);
}

/*
 * routine:
 *      add_file_to_base
 *
 * purpose:
 *      to add a file-node to a baseline
 *
 * parameters:
 *      pointer to base
 *      name of file to be added
 *
 * returns:
 *      pointer to file structure
 */
struct file *
add_file_to_base(struct base *bp, const char *name)
{       struct file *fp;

        fp = add_file_to_list(&bp->b_files, name);
        fp->f_base = bp;
        fp->f_depth = 0;

        if (opt_debug & DBG_LIST)
                fprintf(stderr, "LIST: base=%d, %s file=%s\n",
                        bp->b_ident, (fp->f_flags&F_NEW) ? "NEW" : "FOUND",
                        name);

        return (fp);
}

/*
 * routine:
 *      add_file_to_dir
 *
 * purpose:
 *      to add a file-node to a directory
 *
 * parameters:
 *      pointer to file entry for directory
 *      name of file to be added
 *
 * returns:
 *      pointer to file structure
 */
struct file *
add_file_to_dir(struct file *dp, const char *name)
{       struct file *fp;

        fp = add_file_to_list(&dp->f_files, name);
        fp->f_base = dp->f_base;
        fp->f_depth = dp->f_depth + 1;

        if (opt_debug & DBG_LIST)
                fprintf(stderr, "LIST: dir=%s, %s file=%s\n",
                        dp->f_name, (fp->f_flags&F_NEW) ? "NEW" : "FOUND",
                        name);

        return (fp);
}

/*
 * routine:
 *      read_baseline
 *
 * purpose:
 *      to read in the baseline file
 *
 * parameters:
 *      name of baseline file
 *
 * returns:
 *      error mask
 */
errmask_t
read_baseline(char *name)
{       FILE *file;
        errmask_t errs = 0;

        char *s;
        char *s1 = 0;
        char type;
        char *field = "???";

        unsigned long l;
        unsigned long long ll;  /* intermediate for 64 bit file support */
        int level;
        int major, minor;

        struct base *bp = 0;
        struct file *fp;
        struct fileinfo *ip;
        aclent_t *ap;

        struct file *dirstack[ MAX_DEPTH ];

        file = fopen(name, "r");
        if (file == NULL) {
                fprintf(stderr, gettext(ERR_open), gettext(TXT_base),
                        name);
                return (ERR_FILES);
        }
        lex_linenum = 0;

        if (opt_debug & DBG_FILES)
                fprintf(stderr, "FILE: READ BASELINE %s\n", name);

        while (!feof(file)) {
                /* find the first token on the line     */
                s = lex(file);

                /* skip blank lines and comments        */
                if (s == 0 || *s == 0 || *s == '#' || *s == '*')
                        continue;

                field = "keyword";

                /* see if the first token is a known keyword    */
                if (strcmp(s, "VERSION") == 0 || strcmp(s, BASE_TAG) == 0) {
                        s = lex(0);
                        field = gettext(TXT_noargs);
                        if (s == 0)
                                goto bad;

                        major = strtol(s, &s1, 10);
                        field = gettext(TXT_badver);
                        if (*s1 != '.')
                                goto bad;
                        minor = strtol(&s1[1], 0, 10);

                        if (major != BASE_MAJOR || minor > BASE_MINOR) {
                                fprintf(stderr, gettext(ERR_badver),
                                        major, minor, gettext(TXT_base), name);
                                errs |= ERR_FILES;
                        }
                        s1 = 0;
                        continue;
                }

                if (strcmp(s, "BASE_SRC") == 0) {
                        s = lex(0);
                        field = "source directory";
                        if (s == 0)
                                goto bad;
                        s1 = strdup(s);
                        bp = 0;
                        continue;
                }

                if (strcmp(s, "BASE_DST") == 0) {
                        s = lex(0);
                        field = "destination directory";
                        if (s == 0)
                                goto bad;

                        /* make sure we have a source too */
                        if (s1 == 0) {
                                field = "no source directory";
                                goto bad;
                        }

                        bp = add_base(s1, s);
                        free(s1);
                        s1 = 0;
                        continue;
                }

                if (strcmp(s, "FILE") == 0) {
                        /* make sure we have a base to add to */
                        if (bp == 0) {
                                field = "missing base";
                                goto bad;
                        }

                        s = lex(0);     /* level        */
                        field = "level";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        level = l;

                        s = lex(0);     /* type */
                        field = "file type";
                        if (s == 0 || *s == 0)
                                goto bad;
                        type = *s;
                        if (gettype(type) < 0)
                                goto bad;

                        s = lex(0);     /* name */
                        field = "file name";
                        if (s == 0 || *s == 0)
                                goto bad;

                        /* allocate a file structure for this entry     */
                        if (level == 0)
                                fp = add_file_to_base(bp, s);
                        else
                                fp = add_file_to_dir(dirstack[level-1], s);

                        fp->f_flags |= F_IN_BASELINE;

                        /* maintain the directory stack                 */
                        if (level >= MAX_DEPTH) {
                                fprintf(stderr, gettext(ERR_deep), s);
                                exit(ERR_OTHER);
                        }

                        dirstack[ level ] = fp;

                        /* get a pointer to the baseline file info structure */
                        ip = &fp->f_info[ OPT_BASE ];

                        ip->f_type = gettype(type);     /* note file type */

                        s = lex(0);     /* modes        */
                        field = "file modes";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ip->f_mode = l;

                        s = lex(0);     /* uid  */
                        field = "file UID";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ip->f_uid = l;

                        s = lex(0);     /* gid  */
                        field = "file GID";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ip->f_gid = l;

                        s = lex(0);     /* source inode */
                        field = "source i#";
                        if (s == 0 || *s == 0)
                                goto bad;
                        ll = strtoull(s, 0, 0);
                        fp->f_s_inum = (ino_t) ll;

                        s = lex(0);     /* source major */
                        field = "source major";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_s_maj = l;

                        s = lex(0);     /* source minor */
                        field = "source minor";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_s_min = l;

                        s = lex(0);     /* source nlink */
                        field = "source nlink";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_s_nlink = l;

                        s = lex(0);     /* source mod   */
                        field = "source modtime";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_s_modtime = l;

                        s = lex(0);     /* dest inode   */
                        field = "destination i#";
                        if (s == 0 || *s == 0)
                                goto bad;
                        ll = strtoull(s, 0, 0);
                        fp->f_d_inum = (ino_t) ll;

                        s = lex(0);     /* dest major   */
                        field = "destination major";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_d_maj = l;

                        s = lex(0);     /* dest minor   */
                        field = "destination minor";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_d_min = l;

                        s = lex(0);     /* dest nlink   */
                        field = "dest nlink";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_d_nlink = l;

                        s = lex(0);     /* dest mod     */
                        field = "dest modtime";
                        if (s == 0 || *s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        fp->f_d_modtime = l;

                        s = lex(0);     /* major or size */

                        if (type == 'C' || type == 'B') {
                                field = "rdev major";
                                if (s == 0 || *s == 0)
                                        goto bad;
                                l = strtoul(s, 0, 0);
                                ip->f_rd_maj = l;

                                s = lex(0);     /* minor */
                                field = "rdev minor";
                                if (s == 0 || *s == 0)
                                        goto bad;
                                l = strtoul(s, 0, 0);
                                ip->f_rd_min = l;
                        } else {
                                field = "file size";
                                if (s == 0 || *s == 0)
                                        goto bad;
                                ll = strtoul(s, 0, 0);
                                ip->f_size = (off_t) ll;        /* size */
                        }

                        /*
                         * all fields after this point were added to the
                         * 1.0 format and so should be considered optional
                         */
                        s = lex(0);             /* acl length ? */
                        field = "acl count";
                        if (s && *s) {
                                l = strtoul(s, 0, 0);
                                ip->f_numacls = l;
                                ip->f_acls = (aclent_t *) malloc(ip->f_numacls *
                                                sizeof (aclent_t));
                                if (ip->f_acls == 0)
                                        nomem("Access Control List");
                        }

                        continue;
                }

                if (strcmp(s, "ACL") == 0) {
                        /* make sure there is a place to put the ACL    */
                        if (ip == 0 || ip->f_acls == 0) {
                                field = "ACL w/o FILE/LIST";
                                goto bad;
                        }

                        /* acl entry number     */
                        s = lex(0);
                        field = "acl index";
                        if (s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        if (l >= ip->f_numacls)
                                goto bad;
                        else
                                ap = &ip->f_acls[l];

                        /* acl entry type       */
                        s = lex(0);
                        field = "acl type";
                        if (s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ap->a_type = l;

                        /* acl entry ID         */
                        s = lex(0);
                        field = "acl id";
                        if (s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ap->a_id = l;

                        /* acl entry perms      */
                        s = lex(0);
                        field = "acl perm";
                        if (s == 0)
                                goto bad;
                        l = strtoul(s, 0, 0);
                        ap->a_perm = l;

                        continue;
                }

        bad:    /* log the error and continue processing to find others */
                fprintf(stderr, gettext(ERR_badinput), lex_linenum,
                        field, name);
                errs |= ERR_FILES;
        }

        (void) fclose(file);
        return (errs);
}

/*
 * routine:
 *      write_baseline
 *
 * purpose:
 *      to rewrite the baseline file
 *
 * parameters:
 *      name of the new baseline file
 *
 * returns:
 *      error mask
 */
errmask_t
write_baseline(char *name)
{       FILE *newfile;
        errmask_t errs = 0;
        struct base *bp;
        char tmpname[ MAX_PATH ];

        if (opt_debug & DBG_FILES)
                fprintf(stderr, "FILE: WRITE BASELINE %s\n", name);

        /* if no-touch is specified, we don't update files      */
        if (opt_notouch)
                return (0);

        /* create a temporary output file                       */
        sprintf(tmpname, "%s-TMP", name);

        /* create our output file       */
        newfile = fopen(tmpname, "w+");
        if (newfile == NULL) {
                fprintf(stderr, gettext(ERR_creat), gettext(TXT_base),
                                tmpname);
                return (ERR_FILES);
        }

        errs |= bw_header(newfile);
        for (bp = bases; bp; bp = bp->b_next)
                errs |= bw_base(newfile, bp);

        if (ferror(newfile)) {
                fprintf(stderr, gettext(ERR_write), gettext(TXT_base),
                        tmpname);
                errs |= ERR_FILES;
        }

        if (fclose(newfile)) {
                fprintf(stderr, gettext(ERR_fclose), gettext(TXT_base),
                        tmpname);
                errs |= ERR_FILES;
        }

        /* now switch the new file for the old one      */
        if (errs == 0)
                if (rename(tmpname, name) != 0) {
                        fprintf(stderr, gettext(ERR_rename),
                                gettext(TXT_base), tmpname, name);
                        errs |= ERR_FILES;
                }

        return (errs);
}

/*
 * routine:
 *      bw_header
 *
 * purpose:
 *      to write out a baseline header
 *
 * parameters:
 *      FILE* for the output file
 *
 * returns:
 *      error mask
 *
 * notes:
 */
static errmask_t
bw_header(FILE *file)
{       time_t now;
        struct tm *local;

        /* figure out what time it is   */
        (void) time(&now);
        local = localtime(&now);

        fprintf(file, "%s %d.%d\n", BASE_TAG, BASE_MAJOR, BASE_MINOR);
        fprintf(file, "#\n");
        fprintf(file, "# filesync baseline, last written by %s, %s",
                cuserid((char *) 0), asctime(local));
        fprintf(file, "#\n");

        return (0);
}

/*
 * routine:
 *      bw_base
 *
 * purpose:
 *      to write out the summary for one base-pair
 *
 * parameters:
 *      FILE * for the output file
 *
 * returns:
 *      error mask
 *
 * notes:
 */
static errmask_t
bw_base(FILE *file, struct base *bp)
{       struct file *fp;
        errmask_t errs = 0;

        /* see if this base is to be dropped from baseline      */
        if (bp->b_flags & F_REMOVE)
                return (0);

        fprintf(file, "\n");
        fprintf(file, "BASE_SRC %s\n", noblanks(bp->b_src_spec));
        fprintf(file, "BASE_DST %s\n", noblanks(bp->b_dst_spec));

        for (fp = bp->b_files; fp; fp = fp->f_next)
                errs |= bw_file(file, fp, 0);

        return (errs);
}

/*
 * routine:
 *      bw_file
 *
 * purpose:
 *      to write a file description out to the baseline
 *
 * parameters:
 *      output FILE
 *      pointer to file description
 *      recursion depth
 *
 * returns:
 *      error mask
 *
 * notes:
 *      some of the information we write out is kept separately
 *      for source and destination files because the values should
 *      be expected to be different for different systems/copies.
 *
 *      if a file has an unresolved conflict, we want to leave
 *      the old values in place so that we continue to compare
 *      files against the last time they agreed.
 */
static errmask_t
bw_file(FILE *file, struct file *fp, int depth)
{       struct file *cp;
        int i;
        errmask_t errs = 0;
        long long ll;           /* intermediate for 64 bit file support */
        struct fileinfo *ip = &fp->f_info[OPT_BASE];

        /* if this file is to be removed from baseline, skip it */
        if (fp->f_flags & F_REMOVE)
                return (0);

        /*
         * if this node is in conflict, or if it has not been
         * evaluated this time around, we should just leave the
         * baseline file the way it was before.  If there is a
         * conflict, let the baseline reflect the last agreement.
         * If the node wasn't evaluated, let the baseline reflect
         * our last knowledge.
         */
        if (fp->f_flags & F_CONFLICT || (fp->f_flags&F_EVALUATE) == 0) {
                fp->f_info[OPT_SRC].f_ino       = fp->f_s_inum;
                fp->f_info[OPT_SRC].f_nlink     = fp->f_s_nlink;
                fp->f_info[OPT_SRC].f_d_maj     = fp->f_s_maj;
                fp->f_info[OPT_SRC].f_d_min     = fp->f_s_min;
                fp->f_info[OPT_SRC].f_modtime   = fp->f_s_modtime;
                fp->f_info[OPT_DST].f_ino       = fp->f_d_inum;
                fp->f_info[OPT_DST].f_nlink     = fp->f_d_nlink;
                fp->f_info[OPT_DST].f_d_maj     = fp->f_d_maj;
                fp->f_info[OPT_DST].f_d_min     = fp->f_d_min;
                fp->f_info[OPT_DST].f_modtime   = fp->f_d_modtime;
        }

        /* write out the entry for this file            */
        fprintf(file, "FILE %d %c %-20s 0%04o", depth, showtype(ip->f_type),
                noblanks(fp->f_name), ip->f_mode);
        fprintf(file, " %6ld %6ld", ip->f_uid, ip->f_gid);

        ll = fp->f_info[OPT_SRC].f_ino;
        fprintf(file, "\t%6lld %4ld %4ld %4d 0x%08lx",
                        ll,
                        fp->f_info[OPT_SRC].f_d_maj,
                        fp->f_info[OPT_SRC].f_d_min,
                        fp->f_info[OPT_SRC].f_nlink,
                        fp->f_info[OPT_SRC].f_modtime);

        ll = fp->f_info[OPT_DST].f_ino;
        fprintf(file, "\t%6lld %4ld %4ld %4d 0x%08lx",
                        ll,
                        fp->f_info[OPT_DST].f_d_maj,
                        fp->f_info[OPT_DST].f_d_min,
                        fp->f_info[OPT_DST].f_nlink,
                        fp->f_info[OPT_DST].f_modtime);

        /* last fields are file type specific   */
        if (S_ISBLK(ip->f_type) || S_ISCHR(ip->f_type))
                fprintf(file, "\t%4ld %4ld", ip->f_rd_maj, ip->f_rd_min);
        else {
                ll = ip->f_size;
                fprintf(file, "\t%lld", ll);
        }

        /* ACL count goes at the end because it was added       */
        fprintf(file, "\t%d", ip->f_numacls);

        fprintf(file, "\n");

        /* if this file has ACLs, we have to write them out too */
        for (i = 0; i < ip->f_numacls; i++)
                fprintf(file, "ACL %d %d %ld %o\n", i, ip->f_acls[i].a_type,
                        ip->f_acls[i].a_id, ip->f_acls[i].a_perm);

        /* then enumerate all of the children (if any)  */
        for (cp = fp->f_files; cp; cp = cp->f_next)
                errs |= bw_file(file, cp, depth + 1);

        return (errs);
}

/*
 * routines:
 *      gettype/showtype
 *
 * purpose:
 *      to convert between a file type (as found in a mode word)
 *      and a single character representation
 *
 * parameters/return
 *      mode word -> character
 *      character -> mode word
 */
static char types[16] = "-PC?DNB?F?S?s???";

static char showtype(int mode)
{
        return (types[ (mode & S_IFMT) >> 12 ]);
}

static long gettype(int code)
{       int i;

        for (i = 0; i < 16; i++)
                if (types[i] == code)
                        return (i << 12);

        return (-1);
}