1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include <vroot/vroot.h>
31 #include <vroot/args.h>
32
33 #include <string.h>
34 #include <sys/param.h>
35 #include <sys/file.h>
36
37 typedef struct {
38 short init;
39 pathpt vector;
40 const char *env_var;
41 } vroot_patht;
42
43 typedef struct {
44 vroot_patht vroot;
45 vroot_patht path;
46 char full_path[MAXPATHLEN+1];
47 char *vroot_start;
48 char *path_start;
49 char *filename_start;
50 int scan_vroot_first;
51 int cpp_style_path;
52 } vroot_datat, *vroot_datapt;
53
54 static vroot_datat vroot_data= {
55 { 0, NULL, "VIRTUAL_ROOT"},
56 { 0, NULL, "PATH"},
57 "", NULL, NULL, NULL, 0, 1};
58
59 void
60 add_dir_to_path(const char *path, register pathpt *pointer, register int position)
61 {
62 register int size= 0;
63 register int length;
64 register char *name;
65 register pathcellpt p;
66 pathpt new_path;
67
68 if (*pointer != NULL) {
69 for (p= &((*pointer)[0]); p->path != NULL; p++, size++);
70 if (position < 0)
71 position= size;}
72 else
73 if (position < 0)
74 position= 0;
75 if (position >= size) {
76 new_path= (pathpt)calloc((unsigned)(position+2), sizeof(pathcellt));
77 if (*pointer != NULL) {
78 memcpy((char *)new_path,(char *)(*pointer), size*sizeof(pathcellt));
79 free((char *)(*pointer));};
80 *pointer= new_path;};
81 length= strlen(path);
82 name= (char *)malloc((unsigned)(length+1));
83 (void)strcpy(name, path);
84 if ((*pointer)[position].path != NULL)
85 free((*pointer)[position].path);
86 (*pointer)[position].path= name;
87 (*pointer)[position].length= length;
88 }
89
90 pathpt
91 parse_path_string(register char *string, register int remove_slash)
92 {
93 register char *p;
94 pathpt result= NULL;
95
96 if (string != NULL)
97 for (; 1; string= p+1) {
98 if (p= strchr(string, ':')) *p= 0;
99 if ((remove_slash == 1) && !strcmp(string, "/"))
100 add_dir_to_path("", &result, -1);
101 else
102 add_dir_to_path(string, &result, -1);
103 if (p) *p= ':';
104 else return(result);};
105 return((pathpt)NULL);
106 }
107
108 const char *
109 get_vroot_name(void)
110 {
111 return(vroot_data.vroot.env_var);
112 }
113
114 const char *
115 get_path_name(void)
116 {
117 return(vroot_data.path.env_var);
118 }
119
120 void
121 flush_path_cache(void)
122 {
123 vroot_data.path.init= 0;
124 }
125
126 void
127 flush_vroot_cache(void)
128 {
129 vroot_data.vroot.init= 0;
130 }
131
132 void
133 scan_path_first(void)
134 {
135 vroot_data.scan_vroot_first= 0;
136 }
137
138 void
139 scan_vroot_first(void)
140 {
141 vroot_data.scan_vroot_first= 1;
142 }
143
144 void
145 set_path_style(int style)
146 {
147 vroot_data.cpp_style_path= style;
148 }
149
150 char *
151 get_vroot_path(register char **vroot, register char **path, register char **filename)
152 {
153 if (vroot != NULL) {
154 if ((*vroot= vroot_data.vroot_start) == NULL)
155 if ((*vroot= vroot_data.path_start) == NULL)
156 *vroot= vroot_data.filename_start;};
157 if (path != NULL) {
158 if ((*path= vroot_data.path_start) == NULL)
159 *path= vroot_data.filename_start;};
160 if (filename != NULL)
161 *filename= vroot_data.filename_start;
162 return(vroot_data.full_path);
163 }
164
165 void
166 translate_with_thunk(register char *filename, int (*thunk) (char *), pathpt path_vector, pathpt vroot_vector, rwt rw)
167 {
168 register pathcellt *vp;
169 pathcellt *pp;
170 register pathcellt *pp1;
171 register char *p;
172 int flags[256];
173
174 /* Setup path to use */
175 if (rw == rw_write)
176 pp1= NULL; /* Do not use path when writing */
177 else {
178 if (path_vector == VROOT_DEFAULT) {
179 if (!vroot_data.path.init) {
180 vroot_data.path.init= 1;
181 vroot_data.path.vector= parse_path_string(getenv(vroot_data.path.env_var), 0);};
182 path_vector= vroot_data.path.vector;};
183 pp1= path_vector == NULL ? NULL : &(path_vector)[0];};
184
185 /* Setup vroot to use */
186 if (vroot_vector == VROOT_DEFAULT) {
187 if (!vroot_data.vroot.init) {
188 vroot_data.vroot.init= 1;
189 vroot_data.vroot.vector= parse_path_string(getenv(vroot_data.vroot.env_var), 1);};
190 vroot_vector= vroot_data.vroot.vector;};
191 vp= vroot_vector == NULL ? NULL : &(vroot_vector)[0];
192
193 /* Setup to remember pieces */
194 vroot_data.vroot_start= NULL;
195 vroot_data.path_start= NULL;
196 vroot_data.filename_start= NULL;
197
198 int flen = strlen(filename);
199 if(flen >= MAXPATHLEN) {
200 errno = ENAMETOOLONG;
201 return;
202 }
203
204 switch ((vp ?1:0) + (pp1 ? 2:0)) {
205 case 0: /* No path. No vroot. */
206 use_name:
207 (void)strcpy(vroot_data.full_path, filename);
208 vroot_data.filename_start= vroot_data.full_path;
209 (void)(*thunk)(vroot_data.full_path);
210 return;
211 case 1: /* No path. Vroot */
212 if (filename[0] != '/') goto use_name;
213 for (; vp->path != NULL; vp++) {
214 if((1 + flen + vp->length) >= MAXPATHLEN) {
215 errno = ENAMETOOLONG;
216 continue;
217 }
218 p= vroot_data.full_path;
219 (void)strcpy(vroot_data.vroot_start= p, vp->path);
220 p+= vp->length;
221 (void)strcpy(vroot_data.filename_start= p, filename);
222 if ((*thunk)(vroot_data.full_path)) return;};
223 (void)strcpy(vroot_data.full_path, filename);
224 return;
225 case 2: /* Path. No vroot. */
226 if (vroot_data.cpp_style_path) {
227 if (filename[0] == '/') goto use_name;
228 } else {
229 if (strchr(filename, '/') != NULL) goto use_name;
230 };
231 for (; pp1->path != NULL; pp1++) {
232 p= vroot_data.full_path;
233 if((1 + flen + pp1->length) >= MAXPATHLEN) {
234 errno = ENAMETOOLONG;
235 continue;
236 }
237 if (vroot_data.cpp_style_path) {
238 (void)strcpy(vroot_data.path_start= p, pp1->path);
239 p+= pp1->length;
240 *p++= '/';
241 } else {
242 if (pp1->length != 0) {
243 (void)strcpy(vroot_data.path_start= p,
244 pp1->path);
245 p+= pp1->length;
246 *p++= '/';
247 };
248 };
249 (void)strcpy(vroot_data.filename_start= p, filename);
250 if ((*thunk)(vroot_data.full_path)) return;};
251 (void)strcpy(vroot_data.full_path, filename);
252 return;
253 case 3: { /* Path. Vroot. */
254 int *rel_path, path_len= 1;
255 if (vroot_data.scan_vroot_first == 0) {
256 for (pp= pp1; pp->path != NULL; pp++) path_len++;
257 rel_path= flags;
258 for (path_len-= 2; path_len >= 0; path_len--) rel_path[path_len]= 0;
259 for (; vp->path != NULL; vp++)
260 for (pp= pp1, path_len= 0; pp->path != NULL; pp++, path_len++) {
261 int len = 0;
262 if (rel_path[path_len] == 1) continue;
263 if (pp->path[0] != '/') rel_path[path_len]= 1;
264 p= vroot_data.full_path;
265 if ((filename[0] == '/') || (pp->path[0] == '/')) {
266 if(vp->length >= MAXPATHLEN) {
267 errno = ENAMETOOLONG;
268 continue;
269 }
270 (void)strcpy(vroot_data.vroot_start= p, vp->path); p+= vp->length;
271 len += vp->length;
272 };
273 if (vroot_data.cpp_style_path) {
274 if (filename[0] != '/') {
275 if(1 + len + pp->length >= MAXPATHLEN) {
276 errno = ENAMETOOLONG;
277 continue;
278 }
279 (void)strcpy(vroot_data.path_start= p, pp->path); p+= pp->length;
280 *p++= '/';
281 len += 1 + pp->length;
282 };
283 } else {
284 if (strchr(filename, '/') == NULL) {
285 if (pp->length != 0) {
286 if(1 + len + pp->length >= MAXPATHLEN) {
287 errno = ENAMETOOLONG;
288 continue;
289 }
290 (void)strcpy(vroot_data.path_start= p,
291 pp->path);
292 p+= pp->length;
293 *p++= '/';
294 len += 1 + pp->length;
295 }
296 }
297 };
298 (void)strcpy(vroot_data.filename_start= p, filename);
299 if ((*thunk)(vroot_data.full_path)) return;};}
300 else { pathcellt *vp1= vp;
301 for (pp= pp1, path_len= 0; pp->path != NULL; pp++, path_len++)
302 for (vp= vp1; vp->path != NULL; vp++) {
303 int len = 0;
304 p= vroot_data.full_path;
305 if ((filename[0] == '/') || (pp->path[0] == '/')) {
306 if(vp->length >= MAXPATHLEN) {
307 errno = ENAMETOOLONG;
308 continue;
309 }
310 (void)strcpy(vroot_data.vroot_start= p, vp->path); p+= vp->length;
311 len += vp->length;
312 }
313 if (vroot_data.cpp_style_path) {
314 if (filename[0] != '/') {
315 if(1 + len + pp->length >= MAXPATHLEN) {
316 errno = ENAMETOOLONG;
317 continue;
318 }
319 (void)strcpy(vroot_data.path_start= p, pp->path); p+= pp->length;
320 *p++= '/';
321 len += 1 + pp->length;
322 }
323 } else {
324 if (strchr(filename, '/') == NULL) {
325 if(1 + len + pp->length >= MAXPATHLEN) {
326 errno = ENAMETOOLONG;
327 continue;
328 }
329 (void)strcpy(vroot_data.path_start= p, pp->path); p+= pp->length;
330 *p++= '/';
331 len += 1 + pp->length;
332 }
333 }
334 (void)strcpy(vroot_data.filename_start= p, filename);
335 if ((*thunk)(vroot_data.full_path)) return;};};
336 (void)strcpy(vroot_data.full_path, filename);
337 return;};};
338 }