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