Home | History | Annotate | Line # | Download | only in mtree
misc.c revision 1.30.14.1 
      1 /*	$NetBSD: misc.c,v 1.30.14.1 2012/11/20 03:03:02 tls Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1991, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)misc.c	8.1 (Berkeley) 6/6/93
     32  */
     33 
     34 #if HAVE_NBTOOL_CONFIG_H
     35 #include "nbtool_config.h"
     36 #endif
     37 
     38 #include <sys/cdefs.h>
     39 #if defined(__RCSID) && !defined(lint)
     40 __RCSID("$NetBSD: misc.c,v 1.30.14.1 2012/11/20 03:03:02 tls Exp $");
     41 #endif /* not lint */
     42 
     43 #include <sys/types.h>
     44 #include <sys/stat.h>
     45 
     46 #include <stdarg.h>
     47 #include <stdio.h>
     48 #include <stdlib.h>
     49 #include <string.h>
     50 
     51 #include "extern.h"
     52 
     53 typedef struct _key {
     54 	const char	*name;		/* key name */
     55 	u_int		val;		/* value */
     56 
     57 #define	NEEDVALUE	0x01
     58 	u_int		flags;
     59 } KEY;
     60 
     61 /* NB: the following tables must be sorted lexically. */
     62 static KEY keylist[] = {
     63 	{"cksum",	F_CKSUM,	NEEDVALUE},
     64 	{"device",	F_DEV,		NEEDVALUE},
     65 	{"flags",	F_FLAGS,	NEEDVALUE},
     66 	{"gid",		F_GID,		NEEDVALUE},
     67 	{"gname",	F_GNAME,	NEEDVALUE},
     68 	{"ignore",	F_IGN,		0},
     69 	{"link",	F_SLINK,	NEEDVALUE},
     70 	{"md5",		F_MD5,		NEEDVALUE},
     71 	{"md5digest",	F_MD5,		NEEDVALUE},
     72 	{"mode",	F_MODE,		NEEDVALUE},
     73 	{"nlink",	F_NLINK,	NEEDVALUE},
     74 	{"nochange",	F_NOCHANGE,	0},
     75 	{"optional",	F_OPT,		0},
     76 	{"ripemd160digest", F_RMD160,	NEEDVALUE},
     77 	{"rmd160digest",F_RMD160,	NEEDVALUE},
     78 	{"rmd160",	F_RMD160,	NEEDVALUE},
     79 	{"rmd160digest",F_RMD160,	NEEDVALUE},
     80 	{"sha1",	F_SHA1,		NEEDVALUE},
     81 	{"sha1digest",	F_SHA1,		NEEDVALUE},
     82 	{"sha256",	F_SHA256,	NEEDVALUE},
     83 	{"sha256digest",F_SHA256,	NEEDVALUE},
     84 	{"sha384",	F_SHA384,	NEEDVALUE},
     85 	{"sha384digest",F_SHA384,	NEEDVALUE},
     86 	{"sha512",	F_SHA512,	NEEDVALUE},
     87 	{"sha512digest",F_SHA512,	NEEDVALUE},
     88 	{"size",	F_SIZE,		NEEDVALUE},
     89 	{"tags",	F_TAGS,		NEEDVALUE},
     90 	{"time",	F_TIME,		NEEDVALUE},
     91 	{"type",	F_TYPE,		NEEDVALUE},
     92 	{"uid",		F_UID,		NEEDVALUE},
     93 	{"uname",	F_UNAME,	NEEDVALUE}
     94 };
     95 
     96 static KEY typelist[] = {
     97 	{"block",	F_BLOCK,	0},
     98 	{"char",	F_CHAR,		0},
     99 	{"dir",		F_DIR,		0},
    100 #ifdef S_IFDOOR
    101 	{"door",	F_DOOR,		0},
    102 #endif
    103 	{"fifo",	F_FIFO,		0},
    104 	{"file",	F_FILE,		0},
    105 	{"link",	F_LINK,		0},
    106 	{"socket",	F_SOCK,		0},
    107 };
    108 
    109 slist_t	excludetags, includetags;
    110 int	keys = KEYDEFAULT;
    111 
    112 
    113 int keycompare(const void *, const void *);
    114 
    115 u_int
    116 parsekey(const char *name, int *needvaluep)
    117 {
    118 	static int allbits;
    119 	KEY *k, tmp;
    120 
    121 	if (allbits == 0) {
    122 		size_t i;
    123 
    124 		for (i = 0; i < sizeof(keylist) / sizeof(KEY); i++)
    125 			allbits |= keylist[i].val;
    126 	}
    127 	tmp.name = name;
    128 	if (strcmp(name, "all") == 0)
    129 		return (allbits);
    130 	k = (KEY *)bsearch(&tmp, keylist, sizeof(keylist) / sizeof(KEY),
    131 	    sizeof(KEY), keycompare);
    132 	if (k == NULL)
    133 		mtree_err("unknown keyword `%s'", name);
    134 
    135 	if (needvaluep)
    136 		*needvaluep = k->flags & NEEDVALUE ? 1 : 0;
    137 
    138 	return (k->val);
    139 }
    140 
    141 u_int
    142 parsetype(const char *name)
    143 {
    144 	KEY *k, tmp;
    145 
    146 	tmp.name = name;
    147 	k = (KEY *)bsearch(&tmp, typelist, sizeof(typelist) / sizeof(KEY),
    148 	    sizeof(KEY), keycompare);
    149 	if (k == NULL)
    150 		mtree_err("unknown file type `%s'", name);
    151 
    152 	return (k->val);
    153 }
    154 
    155 int
    156 keycompare(const void *a, const void *b)
    157 {
    158 
    159 	return (strcmp(((const KEY *)a)->name, ((const KEY *)b)->name));
    160 }
    161 
    162 void
    163 mtree_err(const char *fmt, ...)
    164 {
    165 	va_list ap;
    166 
    167 	va_start(ap, fmt);
    168 	vwarnx(fmt, ap);
    169 	va_end(ap);
    170 	if (mtree_lineno)
    171 		warnx("failed at line %lu of the specification",
    172 		    (u_long) mtree_lineno);
    173 	exit(1);
    174 	/* NOTREACHED */
    175 }
    176 
    177 void
    178 addtag(slist_t *list, char *elem)
    179 {
    180 
    181 #define	TAG_CHUNK 20
    182 
    183 	if ((list->count % TAG_CHUNK) == 0) {
    184 		char **new;
    185 
    186 		new = (char **)realloc(list->list, (list->count + TAG_CHUNK)
    187 		    * sizeof(char *));
    188 		if (new == NULL)
    189 			mtree_err("memory allocation error");
    190 		list->list = new;
    191 	}
    192 	list->list[list->count] = elem;
    193 	list->count++;
    194 }
    195 
    196 void
    197 parsetags(slist_t *list, char *args)
    198 {
    199 	char	*p, *e;
    200 	int	len;
    201 
    202 	if (args == NULL) {
    203 		addtag(list, NULL);
    204 		return;
    205 	}
    206 	while ((p = strsep(&args, ",")) != NULL) {
    207 		if (*p == '\0')
    208 			continue;
    209 		len = strlen(p) + 3;	/* "," + p + ",\0" */
    210 		if ((e = malloc(len)) == NULL)
    211 			mtree_err("memory allocation error");
    212 		snprintf(e, len, ",%s,", p);
    213 		addtag(list, e);
    214 	}
    215 }
    216 
    217 /*
    218  * matchtags
    219  *	returns 0 if there's a match from the exclude list in the node's tags,
    220  *	or there's an include list and no match.
    221  *	return 1 otherwise.
    222  */
    223 int
    224 matchtags(NODE *node)
    225 {
    226 	int	i;
    227 
    228 	if (node->tags) {
    229 		for (i = 0; i < excludetags.count; i++)
    230 			if (strstr(node->tags, excludetags.list[i]))
    231 				break;
    232 		if (i < excludetags.count)
    233 			return (0);
    234 
    235 		for (i = 0; i < includetags.count; i++)
    236 			if (strstr(node->tags, includetags.list[i]))
    237 				break;
    238 		if (i > 0 && i == includetags.count)
    239 			return (0);
    240 	} else if (includetags.count > 0) {
    241 		return (0);
    242 	}
    243 	return (1);
    244 }
    245 
    246 u_int
    247 nodetoino(u_int type)
    248 {
    249 
    250 	switch (type) {
    251 	case F_BLOCK:
    252 		return S_IFBLK;
    253 	case F_CHAR:
    254 		return S_IFCHR;
    255 	case F_DIR:
    256 		return S_IFDIR;
    257 	case F_FIFO:
    258 		return S_IFIFO;
    259 	case F_FILE:
    260 		return S_IFREG;
    261 	case F_LINK:
    262 		return S_IFLNK;
    263 #ifdef S_IFSOCK
    264 	case F_SOCK:
    265 		return S_IFSOCK;
    266 #endif
    267 	default:
    268 		printf("unknown type %d", type);
    269 		abort();
    270 	}
    271 	/* NOTREACHED */
    272 }
    273 
    274 const char *
    275 nodetype(u_int type)
    276 {
    277 
    278 	return (inotype(nodetoino(type)));
    279 }
    280 
    281 
    282 const char *
    283 inotype(u_int type)
    284 {
    285 
    286 	switch (type & S_IFMT) {
    287 	case S_IFBLK:
    288 		return ("block");
    289 	case S_IFCHR:
    290 		return ("char");
    291 	case S_IFDIR:
    292 		return ("dir");
    293 	case S_IFIFO:
    294 		return ("fifo");
    295 	case S_IFREG:
    296 		return ("file");
    297 	case S_IFLNK:
    298 		return ("link");
    299 #ifdef S_IFSOCK
    300 	case S_IFSOCK:
    301 		return ("socket");
    302 #endif
    303 #ifdef S_IFDOOR
    304 	case S_IFDOOR:
    305 		return ("door");
    306 #endif
    307 	default:
    308 		return ("unknown");
    309 	}
    310 	/* NOTREACHED */
    311 }
    312