/*
* 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.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#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