Home | History | Annotate | Line # | Download | only in mount_qemufwcfg
virtdir.c revision 1.1
      1 /* $NetBSD: virtdir.c,v 1.1 2017/11/25 23:23:39 jmcneill Exp $ */
      2 
      3 /*
      4  * Copyright  2007 Alistair Crooks.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  * 3. The name of the author may not be used to endorse or promote
     15  *    products derived from this software without specific prior written
     16  *    permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     19  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
     22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
     24  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     26  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     27  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include <sys/types.h>
     32 #include <sys/stat.h>
     33 
     34 #include <stdio.h>
     35 #include <stdlib.h>
     36 #include <unistd.h>
     37 
     38 #include "virtdir.h"
     39 #include "defs.h"
     40 
     41  /* utility comparison routine for sorting and searching */
     42 static int
     43 compare(const void *vp1, const void *vp2)
     44 {
     45 	const virt_dirent_t	*tp1 = (const virt_dirent_t *) vp1;
     46 	const virt_dirent_t	*tp2 = (const virt_dirent_t *) vp2;
     47 
     48 	return strcmp(tp1->name, tp2->name);
     49 }
     50 
     51 /* save `n' chars of `s' in allocated storage */
     52 static char *
     53 strnsave(const char *s, int n)
     54 {
     55 	char	*cp;
     56 
     57 	if (n < 0) {
     58 		n = strlen(s);
     59 	}
     60 	NEWARRAY(char, cp, n + 1, "strnsave", return NULL);
     61 	(void) memcpy(cp, s, n);
     62 	cp[n] = 0x0;
     63 	return cp;
     64 }
     65 
     66 /* ensure intermediate directories exist */
     67 static void
     68 mkdirs(virtdir_t *tp, const char *path, size_t size)
     69 {
     70 	virt_dirent_t	*ep;
     71 	char		 name[MAXPATHLEN];
     72 	char		*slash;
     73 
     74 	(void) strlcpy(name, path, sizeof(name));
     75 	for (slash = name + 1 ; (slash = strchr(slash + 1, '/')) != NULL ; ) {
     76 		*slash = 0x0;
     77 		if ((ep = virtdir_find(tp, name, strlen(name))) == NULL) {
     78 			virtdir_add(tp, name, strlen(name), 'd', NULL, 0, 0);
     79 		}
     80 		*slash = '/';
     81 	}
     82 }
     83 
     84 /* get rid of multiple slashes in input */
     85 static int
     86 normalise(const char *name, size_t namelen, char *path, size_t pathsize)
     87 {
     88 	const char	*np;
     89 	char		*pp;
     90 	int		 done;
     91 
     92 	for (pp = path, np = name, done = 0 ; !done && (int)(pp - path) < pathsize - 1 && (int)(np - name) <= namelen ; ) {
     93 		switch(*np) {
     94 		case '/':
     95 			if (pp == path || *(pp - 1) != '/') {
     96 				*pp++ = *np;
     97 			}
     98 			np += 1;
     99 			break;
    100 		case 0x0:
    101 			done = 1;
    102 			break;
    103 		default:
    104 			*pp++ = *np++;
    105 			break;
    106 		}
    107 	}
    108 	/* XXX - trailing slash? */
    109 	*pp = 0x0;
    110 	return (int)(pp - path);
    111 }
    112 
    113 /* initialise the tree */
    114 int
    115 virtdir_init(virtdir_t *tp, const char *rootdir, struct stat *d, struct stat *f, struct stat *l)
    116 {
    117 	(void) memcpy(&tp->dir, d, sizeof(tp->dir));
    118 	tp->dir.st_mode = S_IFDIR | 0755;
    119 	tp->dir.st_nlink = 2;
    120 	(void) memcpy(&tp->file, f, sizeof(tp->file));
    121 	tp->file.st_mode = S_IFREG | 0644;
    122 	tp->file.st_nlink = 1;
    123 	(void) memcpy(&tp->lnk, l, sizeof(tp->lnk));
    124 	tp->lnk.st_mode = S_IFLNK | 0644;
    125 	tp->lnk.st_nlink = 1;
    126 	if (rootdir != NULL) {
    127 		tp->rootdir = strdup(rootdir);
    128 	}
    129 	return 1;
    130 }
    131 
    132 /* add an entry to the tree */
    133 int
    134 virtdir_add(virtdir_t *tp, const char *name, size_t size, uint8_t type, const char *tgt, size_t tgtlen, uint16_t select)
    135 {
    136 	char		path[MAXPATHLEN];
    137 	int		pathlen;
    138 
    139 	pathlen = normalise(name, size, path, sizeof(path));
    140 	if (virtdir_find(tp, path, pathlen) != NULL) {
    141 		/* attempt to add a duplicate directory entry */
    142 		return 0;
    143 	}
    144 	ALLOC(virt_dirent_t, tp->v, tp->size, tp->c, 10, 10, "virtdir_add",
    145 			return 0);
    146 	tp->v[tp->c].namelen = pathlen;
    147 	if ((tp->v[tp->c].name = strnsave(path, pathlen)) == NULL) {
    148 		return 0;
    149 	}
    150 	tp->v[tp->c].d_name = strrchr(tp->v[tp->c].name, '/') + 1;
    151 	tp->v[tp->c].type = type;
    152 	tp->v[tp->c].ino = (ino_t) random() & 0xfffff;
    153 	tp->v[tp->c].tgtlen = tgtlen;
    154 	if (tgt != NULL) {
    155 		tp->v[tp->c].tgt = strnsave(tgt, tgtlen);
    156 	}
    157 	tp->v[tp->c].select = select;
    158 	tp->c += 1;
    159 	qsort(tp->v, tp->c, sizeof(tp->v[0]), compare);
    160 	mkdirs(tp, path, pathlen);
    161 	return 1;
    162 }
    163 
    164 /* find an entry in the tree */
    165 virt_dirent_t *
    166 virtdir_find(virtdir_t *tp, const char *name, size_t namelen)
    167 {
    168 	virt_dirent_t	e;
    169 	char		path[MAXPATHLEN];
    170 
    171 	(void) memset(&e, 0x0, sizeof(e));
    172 	e.namelen = normalise(name, namelen, path, sizeof(path));
    173 	e.name = path;
    174 	return bsearch(&e, tp->v, tp->c, sizeof(tp->v[0]), compare);
    175 }
    176 
    177 /* return the virtual offset in the tree */
    178 int
    179 virtdir_offset(virtdir_t *tp, virt_dirent_t *dp)
    180 {
    181 	return (int)(dp - tp->v);
    182 }
    183 
    184 /* analogous to opendir(3) - open a directory, save information, and
    185 * return a pointer to the dynamically allocated structure */
    186 VIRTDIR *
    187 openvirtdir(virtdir_t *tp, const char *d)
    188 {
    189 	VIRTDIR	*dirp;
    190 
    191 	NEW(VIRTDIR, dirp, "openvirtdir", exit(EXIT_FAILURE));
    192 	dirp->dirname = strdup(d);
    193 	dirp->dirnamelen = strlen(d);
    194 	dirp->tp = tp;
    195 	dirp->i = 0;
    196 	return dirp;
    197 }
    198 
    199 /* analogous to readdir(3) - read the next entry in the directory that
    200 * was opened, and return a pointer to it */
    201 virt_dirent_t *
    202 readvirtdir(VIRTDIR *dirp)
    203 {
    204 	char	*from;
    205 
    206 	for ( ; dirp->i < dirp->tp->c ; dirp->i++) {
    207 		from = (strcmp(dirp->dirname, "/") == 0) ?
    208 			&dirp->tp->v[dirp->i].name[1] :
    209 			&dirp->tp->v[dirp->i].name[dirp->dirnamelen + 1];
    210 		if (strncmp(dirp->tp->v[dirp->i].name, dirp->dirname,
    211 				dirp->dirnamelen) == 0 &&
    212 		    *from != 0x0 &&
    213 		    strchr(from, '/') == NULL) {
    214 			return &dirp->tp->v[dirp->i++];
    215 		}
    216 	}
    217 	return NULL;
    218 }
    219 
    220 /* free the storage associated with the virtual directory structure */
    221 void
    222 closevirtdir(VIRTDIR *dirp)
    223 {
    224 	free(dirp->dirname);
    225 	FREE(dirp);
    226 }
    227