aboutsummaryrefslogtreecommitdiff
blob: a7f106c973082ac69e06f0ddd8ec424f5e107a8d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
/* These functions find the absolute path to the current working directory.  */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>
#include <string.h>

#include "config.h"
#include <sys/param.h>
#include "localdecls.h"

/* Modified: 08 June 2005; Martin Schlemmer <azarah@gentoo.org>
 * 
 *  Cleaned up unneeded stuff.	Add a wrapper to try and detect when
 *  we have a kernel whose getcwd system call do not handle directory
 *  names longer than PATH_MAX, and if so, use our generic version.
 */

#ifndef __set_errno
# define __set_errno(val) errno = (val)
#endif

/* If the syscall is not present, we have to walk up the
 * directory tree till we hit the root.  Now we _could_
 * use /proc/self/cwd if /proc is mounted... That approach
 * is left an an exercise for the reader... */


/* Seems a few broken filesystems (like coda) don't like this */
/*#undef FAST_DIR_SEARCH_POSSIBLE on Linux */


/* Routine to find the step back down */
SB_STATIC char *search_dir(dev_t this_dev, ino_t this_ino, char *path_buf, size_t path_size)
{
	DIR *dp;
	struct dirent *d;
	char *ptr;
	size_t slen;
	struct stat st;

#ifdef FAST_DIR_SEARCH_POSSIBLE
	/* The test is for ELKS lib 0.0.9, this should be fixed in the real kernel */
	size_t slow_search = (sizeof(ino_t) != sizeof(d->d_ino));
#endif

//	if (stat(path_buf, &st) < 0) {
//		goto oops;
//	}
#ifdef FAST_DIR_SEARCH_POSSIBLE
	if (this_dev != st.st_dev)
		slow_search = 1;
#endif

	slen = strlen(path_buf);
	ptr = path_buf + slen - 1;
	if (*ptr != '/') {
		if (slen + 2 > path_size) {
			goto oops;
		}
		snprintf(++ptr, 2, "/");
		slen++;
	}
	slen++;

#ifdef OUTSIDE_LIBSANDBOX
	dp = opendir(path_buf);
#else
	check_dlsym(__opendir);
	dp = true___opendir(path_buf);
#endif
	if (dp == 0) {
	    goto oops;
	}

	while ((d = readdir(dp)) != 0) {
#ifdef FAST_DIR_SEARCH_POSSIBLE
		if (slow_search || this_ino == d->d_ino) {
#endif
			if (slen + strlen(d->d_name) > path_size) {
			    goto oops;
			}
			snprintf(ptr + 1, sizeof(d->d_name) + 1, "%s", d->d_name);
			if (lstat(path_buf, &st) < 0)
				continue;
			if (st.st_ino == this_ino && st.st_dev == this_dev) {
				closedir(dp);
				return path_buf;
			}
#ifdef FAST_DIR_SEARCH_POSSIBLE
		}
#endif
	}

	closedir(dp);
	return 0;

oops:
	__set_errno(ERANGE);
	return 0;
}

/* Routine to go up tree */
SB_STATIC char *recurser(char *path_buf, size_t path_size, dev_t root_dev, ino_t root_ino)
{
	struct stat st;
	dev_t this_dev;
	ino_t this_ino;

	if (lstat(path_buf, &st) < 0) {
	    if (errno != EFAULT)
		goto oops;
	    return 0;
	}
	this_dev = st.st_dev;
	this_ino = st.st_ino;
	if (this_dev == root_dev && this_ino == root_ino) {
		if (path_size < 2) {
		    goto oops;
		}
		snprintf(path_buf, 2, "/");
		return path_buf;
	}
	if (strlen(path_buf) + 4 > path_size) {
	    goto oops;
	}
	snprintf(path_buf + strlen(path_buf), 4, "/..");
	if (recurser(path_buf, path_size, root_dev, root_ino) == 0)
		return 0;

	return search_dir(this_dev, this_ino, path_buf, path_size);
oops:
	__set_errno(ERANGE);
	return 0;
}

SB_STATIC inline
size_t __syscall_egetcwd(char * buf, unsigned long size)
{
    size_t len;
    char *cwd;
    struct stat st;
    size_t olderrno;

    if (lstat("/", &st) < 0)
	return -1;
    olderrno = errno;
    len = -1;
    cwd = recurser(buf, size, st.st_dev, st.st_ino);
    if (cwd) {
	len = strlen(buf);
	__set_errno(olderrno);
    }
    return len;
}

SB_STATIC char *__egetcwd(char *buf, size_t size)
{
    size_t ret;
    char *path;
    size_t alloc_size = size;

    if (size == 0) {
	if (buf != NULL) {
	    __set_errno(EINVAL);
	    return NULL;
	}
	alloc_size = SB_PATH_MAX;
    }
    path=buf;
    if (buf == NULL) {
	path = malloc(alloc_size);
	if (path == NULL)
	    return NULL;
    }
    snprintf(buf, 2, ".");
    ret = __syscall_egetcwd(path, alloc_size);
    if (ret >= 0)
    {
	if (buf == NULL && size == 0)
	    buf = realloc(path, ret);
	if (buf == NULL)
	    buf = path;
	return buf;
    }
    if (buf == NULL)
	free (path);
    return NULL;
}

SB_STATIC char *egetcwd(char *buf, size_t size)
{
	struct stat st;
	char *tmpbuf;

	__set_errno(0);
	tmpbuf = getcwd(buf, size);
	if (tmpbuf)
		lstat(buf, &st);
	else
		return NULL;

	if (errno) {
		/* If lstat() failed with eerror = ENOENT, then its
		 * possible that we are running on an older kernel,
		 * so use our generic version which *should* not fail.
		 */
		if (errno == ENOENT) {
			free(tmpbuf);
			
			tmpbuf = __egetcwd(buf, size);
			if (tmpbuf)
				lstat(buf, &st);
			else
				return NULL;

			if (!errno)
				return __egetcwd(buf, size);
			else if (tmpbuf)
				free(tmpbuf);

			return NULL;
		} else {
			return tmpbuf;
		}
	}

	return tmpbuf;
}