/*
 * 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 1995-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * module:
 *      debug.c
 *
 * purpose:
 *      utility routines for debugging filesync (tracing, diagnostics,
 *      and error simulation)
 *
 * contents:
 *      showflags       display a word of flags symbolicly
 *      dbg_usage       printout usage info for -D switch
 *      err_usage       printout usage info for -E switch
 *      dbg_set_error   enable an error simulation
 *      dbg_check_error check for error simulation
 *
 *
 * note:
 *      there are numerous flag words and bit fields in this
 *      program, and it would be horrendous to just print them
 *      out in hex (in debugging output).  These routines use
 *      a "flaglist" data structure to map between bits and
 *      character string names or descriptions.
 *
 *      a flaglist is merely a list of paired bits and name strings.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#include "filesync.h"
#include "database.h"
#include "debug.h"


/* bits in opt_debug for usage message                                  */
static struct flaglist dbgflags[] =
{       DBG_BASE,       "BASE: base include building",
        DBG_RULE,       "RULE: rule tree building",
        DBG_STAT,       "STAT: file stats",
        DBG_ANAL,       "ANAL: difference analysis",
        DBG_RECON,      "RECO: reconciliation list processing",
        DBG_VARS,       "VARS: qualification and expansion",
        DBG_FILES,      "FILE: rule and baseline files",
        DBG_LIST,       "LIST: tree building",
        DBG_EVAL,       "EVAL: tree walking",
        DBG_IGNORE,     "IGNO: ignore list",
        DBG_MISC,       "MISC: everything else",
        0,              0
};

/* bits in opt_debug for dsiplay                                        */
struct flaglist dbgmap[] =
{       DBG_BASE,       "BASE",
        DBG_RULE,       "RULE",
        DBG_STAT,       "STAT",
        DBG_ANAL,       "ANAL",
        DBG_RECON,      "RECO",
        DBG_VARS,       "VARS",
        DBG_FILES,      "FILE",
        DBG_LIST,       "LIST",
        DBG_EVAL,       "EVAL",
        DBG_IGNORE,     "IGNO",
        DBG_MISC,       "MISC",
        0,              0
};

/* bits in the rules flag field                                 */
struct flaglist rflags[] =
{       R_IGNORE,       "IGNORE",
        R_PROGRAM,      "PROGRAM",
        R_WILD,         "WILD",
        R_NEW,          "NEW",
        R_BOGUS,        "BOGUS",
        R_RESTRICT,     "RESTRICT",
        0,              0
};

/* bits in the files flag field                                 */
struct flaglist fileflags[] =
{       F_NEW,          "new",
        F_IN_BASELINE,  "base",
        F_IN_SOURCE,    "srce",
        F_IN_DEST,      "dest",
        F_EVALUATE,     "eval",
        F_SPARSE,       "sparse",
        F_REMOVE,       "remove",
        F_CONFLICT,     "conflict",
        F_LISTED,       "listed",
        F_STAT_ERROR,   "statfail",
        0,              0
};

/* bits in the file src/dst difference mask                     */
struct flaglist diffmap[] = {
        D_CREATE,       "create",
        D_DELETE,       "delete",
        D_MTIME,        "modtime",
        D_SIZE,         "size",
        D_UID,          "uid",
        D_GID,          "gid",
        D_PROT,         "modes",
        D_LINKS,        "links",
        D_TYPE,         "type",
        D_FACLS,        "facls",
        D_RENAME_TO,    "rename2",
        D_RENAME_FROM,  "renamed",
        0,              0
};

/* bits in the exit error code mask                             */
struct flaglist errmap[] = {
        ERR_RESOLVABLE, "resolvable",
        ERR_UNRESOLVED, "unresolvable",
        ERR_MISSING,    "missing files",
        ERR_PERM,       "permissions",
        ERR_FILES,      "rule/base errors",
        ERR_INVAL,      "invalid arguments",
        ERR_NOBASE,     "bad base dir",
        ERR_OTHER,      "other",
        0,              0
};

/*
 * routine:
 *      showflags
 *
 * purpose:
 *      format flags for printing
 *
 * parameters:
 *      pointer to map
 *      mask to be interpreted \
 *
 * returns:
 *      pointer to a static buffer
 */
char *
showflags(struct flaglist *map, long mask)
{       int i;
        static char outbuf[MAX_NAME];

        outbuf[0] = 0;
        for (i = 0; map[i].fl_mask; i++)
                if (mask & map[i].fl_mask) {
                        if (outbuf[0])
                                strcat(outbuf, "|");
                        strcat(outbuf, map[i].fl_name);
                }

        return (outbuf);
}

/*
 * routines:
 *      dbg_usage, err_usage
 *
 * purpose:
 *      to print out usage messages for the secret debugging flags
 *
 * returns:
 *      void
 */
void
dbg_usage(void)
{       int i;

        fprintf(stderr, "Usage:\tfilesync -Dmask ...\n");
        for (i = 0; dbgflags[i].fl_mask; i++)
                fprintf(stderr, "\t0x%04lx .... %s\n",
                        dbgflags[i].fl_mask, dbgflags[i].fl_name);
        fprintf(stderr, "\n");
}

#ifdef  DBG_ERRORS
/*
 * The -E flag is a debugging feature that enables the user to request
 * the simulation of difficult to trigger error conditions in order
 * to test out the error handling code in filesync.  We maintain a
 * registry that specifies a file name and an operation, and an errno
 * to be returned if the specified operation is attempted on the
 * specified file.
 */
void
err_usage(void)
{
        fprintf(stderr, "Usage:\tfilesync -E<errno>,<code>,<filename>\n");
        fprintf(stderr, "\ts ... eval stat source\n");
        fprintf(stderr, "\tS ... eval stat destination\n");
        fprintf(stderr, "\tn ... eval nftw source\n");
        fprintf(stderr, "\tN ... eval nftw destination\n");
        fprintf(stderr, "\tc ... reconcile copy create\n");
        fprintf(stderr, "\to ... reconcile copy open\n");
        fprintf(stderr, "\tr ... reconcile copy read/readlink\n");
        fprintf(stderr, "\tw ... reconcile copy write\n");
        fprintf(stderr, "\tl ... reconcile link/symlink\n");
        fprintf(stderr, "\tu ... reconcile unlink\n");
        fprintf(stderr, "\td ... reconcile mkdir/mknod\n");
        fprintf(stderr, "\tD ... reconcile rmdir\n");
        fprintf(stderr, "\tm ... reconcile rename\n");
        fprintf(stderr, "\tR ... reconcile restat\n");
        fprintf(stderr, "\tp ... reconcile protection (chmod)");
        fprintf(stderr, "\ta ... reconcile access control (setfacl)");
        fprintf(stderr, "\tO ... reconcile ownership (chown)");
        fprintf(stderr, "\tZ ... out of space on target\n");
        fprintf(stderr, "\n");
}

/*
 * this data structure us used to keep track of the error simulations
 * that have been requested.
 */
static struct errsim {
        int Errno;              /* error number to return       */
        char code;              /* event triggering the error   */
        char *file;             /* file name triggering error   */
} errsim[ DBG_MAX_ERR ];

static int num_errs;            /* number of simulated errors   */


/*
 * routine:
 *      dbg_set_error
 *
 * purpose:
 *      note that we have been requested to simulate file access errors
 *
 * parameters:
 *      argument string <errno>,<errcode>,<filename>
 *
 * returns:
 *      error mask
 */
int
dbg_set_error(char *arg)
{       char *s;
        char error_type;
        int error_no;

        if (num_errs >= DBG_MAX_ERR) {
                fprintf(stderr, "ERROR: only %d -E specifications allowed\n",
                                DBG_MAX_ERR);
                return (ERR_INVAL);
        }

        /* get the error number         */
        if (!isdigit(arg[0]))
                return (ERR_INVAL);
        error_no = strtol(arg, &s, 0);

        /* get the error condition      */
        if (*s++ != ',' || !isalpha(*s))
                return (ERR_INVAL);
        error_type = *s;

        /* get the file name            */
        while (*s && *s != ',') s++;
        if (*s++ != ',' || *s == 0)
                return (ERR_INVAL);

        /* register the error simulation        */
        errsim[num_errs].Errno = error_no;
        errsim[num_errs].code  = error_type;
        errsim[num_errs].file  = s;

        if (opt_debug & DBG_MISC)
                fprintf(stderr, "MISC: errsim[%d] %c(%s) -> %d\n",
                        num_errs, error_type, s, error_no);

        num_errs++;

        return (0);
}

/*
 * routine:
 *      dbg_chk_error
 *
 * purpose:
 *      determine whether or not we have been asked to simulate an
 *      error for a specified file.
 *
 * parameters:
 *      file name
 *
 * returns:
 *      errno (or zero if no error)
 */
int
dbg_chk_error(const char *name, char code)
{       int i;

        for (i = 0; i < num_errs; i++) {
                /* see if this code matches any registered condition    */
                if (code != errsim[i].code)
                        continue;

                /* see if this also matches the file name       */
                if (!suffix(name, errsim[i].file))
                        continue;

                /* we have a winner                             */
                if (opt_debug & DBG_MISC)
                        fprintf(stderr, "MISC: trigger %d for file %c(%s)\n",
                                errsim[i].Errno, code, name);
                return (errsim[i].Errno);
        }
        return (0);
}

#else   /* ! DBG_ERRORS */
void
err_usage(void)
{
        fprintf(stderr, "ERROR: this filesync does not support -E\n");
}

int
dbg_set_error(char *arg)
{
        return (ERR_INVAL);
}

int
dbg_chk_error(const char *name, char code)
{
        return (0);
}
#endif