![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to path.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / bsd-user|
Return to path.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / bsd-user |
1.1 root 1: /* Code to mangle pathnames into those matching a given prefix.
2: eg. open("/lib/foo.so") => open("/usr/gnemul/i386-linux/lib/foo.so");
3:
4: The assumption is that this area does not change.
5: */
6: #include <sys/types.h>
7: #include <sys/param.h>
8: #include <dirent.h>
9: #include <unistd.h>
10: #include <stdlib.h>
11: #include <string.h>
12: #include <errno.h>
13: #include <stdio.h>
14: #include "qemu.h"
15: #include "qemu-common.h"
16:
17: struct pathelem
18: {
19: /* Name of this, eg. lib */
20: char *name;
21: /* Full path name, eg. /usr/gnemul/x86-linux/lib. */
22: char *pathname;
23: struct pathelem *parent;
24: /* Children */
25: unsigned int num_entries;
26: struct pathelem *entries[0];
27: };
28:
29: static struct pathelem *base;
30:
31: /* First N chars of S1 match S2, and S2 is N chars long. */
32: static int strneq(const char *s1, unsigned int n, const char *s2)
33: {
34: unsigned int i;
35:
36: for (i = 0; i < n; i++)
37: if (s1[i] != s2[i])
38: return 0;
39: return s2[i] == 0;
40: }
41:
42: static struct pathelem *add_entry(struct pathelem *root, const char *name);
43:
44: static struct pathelem *new_entry(const char *root,
45: struct pathelem *parent,
46: const char *name)
47: {
48: struct pathelem *new = malloc(sizeof(*new));
49: new->name = strdup(name);
50: asprintf(&new->pathname, "%s/%s", root, name);
51: new->num_entries = 0;
52: return new;
53: }
54:
55: #define streq(a,b) (strcmp((a), (b)) == 0)
56:
57: static struct pathelem *add_dir_maybe(struct pathelem *path)
58: {
59: DIR *dir;
60:
61: if ((dir = opendir(path->pathname)) != NULL) {
62: struct dirent *dirent;
63:
64: while ((dirent = readdir(dir)) != NULL) {
65: if (!streq(dirent->d_name,".") && !streq(dirent->d_name,"..")){
66: path = add_entry(path, dirent->d_name);
67: }
68: }
69: closedir(dir);
70: }
71: return path;
72: }
73:
74: static struct pathelem *add_entry(struct pathelem *root, const char *name)
75: {
76: root->num_entries++;
77:
78: root = realloc(root, sizeof(*root)
79: + sizeof(root->entries[0])*root->num_entries);
80:
81: root->entries[root->num_entries-1] = new_entry(root->pathname, root, name);
82: root->entries[root->num_entries-1]
83: = add_dir_maybe(root->entries[root->num_entries-1]);
84: return root;
85: }
86:
87: /* This needs to be done after tree is stabilized (ie. no more reallocs!). */
88: static void set_parents(struct pathelem *child, struct pathelem *parent)
89: {
90: unsigned int i;
91:
92: child->parent = parent;
93: for (i = 0; i < child->num_entries; i++)
94: set_parents(child->entries[i], child);
95: }
96:
97: /* FIXME: Doesn't handle DIR/.. where DIR is not in emulated dir. */
98: static const char *
99: follow_path(const struct pathelem *cursor, const char *name)
100: {
101: unsigned int i, namelen;
102:
103: name += strspn(name, "/");
104: namelen = strcspn(name, "/");
105:
106: if (namelen == 0)
107: return cursor->pathname;
108:
109: if (strneq(name, namelen, ".."))
110: return follow_path(cursor->parent, name + namelen);
111:
112: if (strneq(name, namelen, "."))
113: return follow_path(cursor, name + namelen);
114:
115: for (i = 0; i < cursor->num_entries; i++)
116: if (strneq(name, namelen, cursor->entries[i]->name))
117: return follow_path(cursor->entries[i], name + namelen);
118:
119: /* Not found */
120: return NULL;
121: }
122:
123: void init_paths(const char *prefix)
124: {
125: char pref_buf[PATH_MAX];
126:
127: if (prefix[0] == '\0' ||
128: !strcmp(prefix, "/"))
129: return;
130:
131: if (prefix[0] != '/') {
132: char *cwd = getcwd(NULL, 0);
133: size_t pref_buf_len = sizeof(pref_buf);
134:
135: if (!cwd)
136: abort();
137: pstrcpy(pref_buf, sizeof(pref_buf), cwd);
138: pstrcat(pref_buf, pref_buf_len, "/");
139: pstrcat(pref_buf, pref_buf_len, prefix);
140: free(cwd);
141: } else
142: pstrcpy(pref_buf, sizeof(pref_buf), prefix + 1);
143:
144: base = new_entry("", NULL, pref_buf);
145: base = add_dir_maybe(base);
146: if (base->num_entries == 0) {
147: free (base);
148: base = NULL;
149: } else {
150: set_parents(base, base);
151: }
152: }
153:
154: /* Look for path in emulation dir, otherwise return name. */
155: const char *path(const char *name)
156: {
157: /* Only do absolute paths: quick and dirty, but should mostly be OK.
158: Could do relative by tracking cwd. */
159: if (!base || name[0] != '/')
160: return name;
161:
162: return follow_path(base, name) ?: name;
163: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.