/* $NetBSD: virtdir.c,v 1.3 2017/11/26 03:51:45 christos Exp $ */ /* * Copyright © 2007 Alistair Crooks. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include <sys/types.h> #include <sys/param.h> #include <sys/stat.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <util.h> #include "virtdir.h" /* utility comparison routine for sorting and searching */ static int compare(const void *vp1, const void *vp2) { const virt_dirent_t *tp1 = vp1; const virt_dirent_t *tp2 = vp2; return strcmp(tp1->name, tp2->name); } /* ensure intermediate directories exist */ static void mkdirs(virtdir_t *tp, const char *path, size_t size) { virt_dirent_t *ep; char name[MAXPATHLEN]; char *slash; (void) strlcpy(name, path, sizeof(name)); for (slash = name + 1 ; (slash = strchr(slash + 1, '/')) != NULL ; ) { *slash = '\0'; if ((ep = virtdir_find(tp, name, strlen(name))) == NULL) { virtdir_add(tp, name, strlen(name), 'd', NULL, 0, 0); } *slash = '/'; } } /* get rid of multiple slashes in input */ static size_t normalise(const char *name, size_t namelen, char *path, size_t pathsize) { const char *np; char *pp; int done; for (pp = path, np = name, done = 0 ; !done && (size_t)(pp - path) < pathsize - 1 && (size_t)(np - name) <= namelen; ) { switch (*np) { case '/': if (pp == path || *(pp - 1) != '/') { *pp++ = *np; } np += 1; break; case '\0': done = 1; break; default: *pp++ = *np++; break; } } /* XXX - trailing slash? */ *pp = '\0'; return (size_t)(pp - path); } /* initialise the tree */ int virtdir_init(virtdir_t *tp, const char *rootdir, const struct stat *d, const struct stat *f, const struct stat *l) { tp->dir = *d; tp->dir.st_mode = S_IFDIR | 0755; tp->dir.st_nlink = 2; tp->file = *f; tp->file.st_mode = S_IFREG | 0644; tp->file.st_nlink = 1; tp->lnk = *l; tp->lnk.st_mode = S_IFLNK | 0644; tp->lnk.st_nlink = 1; if (rootdir != NULL) { tp->rootdir = estrdup(rootdir); } return 1; } /* add an entry to the tree */ int virtdir_add(virtdir_t *tp, const char *name, size_t size, uint8_t type, const char *tgt, size_t tgtlen, uint16_t select) { char path[MAXPATHLEN]; size_t pathlen; pathlen = normalise(name, size, path, sizeof(path)); if (virtdir_find(tp, path, pathlen) != NULL) { /* attempt to add a duplicate directory entry */ return 0; } if (tp->c == tp->size || tp->size == 0) { tp->size += 10; tp->v = erealloc(tp->v, tp->size * sizeof(*tp->v)); } tp->v[tp->c].namelen = pathlen; tp->v[tp->c].name = estrndup(path, pathlen); tp->v[tp->c].d_name = strrchr(tp->v[tp->c].name, '/') + 1; tp->v[tp->c].type = type; tp->v[tp->c].ino = (ino_t) random() & 0xfffff; tp->v[tp->c].tgtlen = tgtlen; if (tgt != NULL) { tp->v[tp->c].tgt = estrndup(tgt, tgtlen); } tp->v[tp->c].select = select; tp->c += 1; qsort(tp->v, tp->c, sizeof(tp->v[0]), compare); mkdirs(tp, path, pathlen); return 1; } /* find an entry in the tree */ virt_dirent_t * virtdir_find(virtdir_t *tp, const char *name, size_t namelen) { virt_dirent_t e; char path[MAXPATHLEN]; (void) memset(&e, 0, sizeof(e)); e.namelen = normalise(name, namelen, path, sizeof(path)); e.name = path; return bsearch(&e, tp->v, tp->c, sizeof(tp->v[0]), compare); } /* return the virtual offset in the tree */ off_t virtdir_offset(const virtdir_t *tp, const virt_dirent_t *dp) { return dp - tp->v; } /* analogous to opendir(3) - open a directory, save information, and * return a pointer to the dynamically allocated structure */ VIRTDIR * openvirtdir(virtdir_t *tp, const char *d) { VIRTDIR *dirp; dirp = emalloc(sizeof(*dirp)); dirp->dirname = estrdup(d); dirp->dirnamelen = strlen(d); dirp->tp = tp; dirp->i = 0; return dirp; } /* analogous to readdir(3) - read the next entry in the directory that * was opened, and return a pointer to it */ virt_dirent_t * readvirtdir(VIRTDIR *dirp) { char *from; for ( ; dirp->i < dirp->tp->c; dirp->i++) { from = (strcmp(dirp->dirname, "/") == 0) ? &dirp->tp->v[dirp->i].name[1] : &dirp->tp->v[dirp->i].name[dirp->dirnamelen + 1]; if (strncmp(dirp->tp->v[dirp->i].name, dirp->dirname, dirp->dirnamelen) == 0 && *from != '\0' && strchr(from, '/') == NULL) { return &dirp->tp->v[dirp->i++]; } } return NULL; } /* free the storage associated with the virtual directory structure */ void closevirtdir(VIRTDIR *dirp) { free(dirp->dirname); free(dirp); }