- static char *buf=NULL;
- static int bufsize = WRITE_BLOCK_SIZE;
- int total=0;
-
- if (!buf) {
- buf = (char *)malloc(bufsize);
- if (!buf) out_of_memory("read_write");
- }
-
- while (total < size) {
- int n = MIN(size-total,bufsize);
- read_buf(fd_in,buf,n);
- if (write(fd_out,buf,n) != n)
- return total;
- total += n;
- }
- return total;
-}
-
-
-/* this is taken from CVS */
-int piped_child(char **command,int *f_in,int *f_out)
-{
- int pid;
- int to_child_pipe[2];
- int from_child_pipe[2];
-
- if (pipe(to_child_pipe) < 0 ||
- pipe(from_child_pipe) < 0) {
- fprintf(stderr,"pipe: %s\n",strerror(errno));
- exit(1);
- }
-
-
- pid = fork();
- if (pid < 0) {
- fprintf(stderr,"fork: %s\n",strerror(errno));
- exit(1);
- }
-
- if (pid == 0)
- {
- if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
- close(to_child_pipe[1]) < 0 ||
- close(from_child_pipe[0]) < 0 ||
- dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
- fprintf(stderr,"Failed to dup/close : %s\n",strerror(errno));
- exit(1);
- }
- execvp(command[0], command);
- fprintf(stderr,"Failed to exec %s : %s\n",
- command[0],strerror(errno));
- exit(1);
- }
-
- if (close(from_child_pipe[1]) < 0 ||
- close(to_child_pipe[0]) < 0) {
- fprintf(stderr,"Failed to close : %s\n",strerror(errno));
- exit(1);
- }
-
- *f_in = from_child_pipe[0];
- *f_out = to_child_pipe[1];
-
- return pid;
+ char *p;
+ int l;
+ int modified = 1;
+
+ if (!name) return;
+
+ while (modified) {
+ modified = 0;
+
+ if ((p=strstr(name,"/./"))) {
+ modified = 1;
+ while (*p) {
+ p[0] = p[2];
+ p++;
+ }
+ }
+
+ if ((p=strstr(name,"//"))) {
+ modified = 1;
+ while (*p) {
+ p[0] = p[1];
+ p++;
+ }
+ }
+
+ if (strncmp(p=name,"./",2) == 0) {
+ modified = 1;
+ do {
+ p[0] = p[2];
+ } while (*p++);
+ }
+
+ l = strlen(p=name);
+ if (l > 1 && p[l-1] == '/') {
+ modified = 1;
+ p[l-1] = 0;
+ }
+ }
+}
+
+/**
+ * Make path appear as if a chroot had occurred:
+ *
+ * @li 1. remove leading "/" (or replace with "." if at end)
+ *
+ * @li 2. remove leading ".." components (except those allowed by @p reldir)
+ *
+ * @li 3. delete any other "<dir>/.." (recursively)
+ *
+ * Can only shrink paths, so sanitizes in place.
+ *
+ * While we're at it, remove double slashes and "." components like
+ * clean_fname() does, but DON'T remove a trailing slash because that
+ * is sometimes significant on command line arguments.
+ *
+ * If @p reldir is non-null, it is a sanitized directory that the path will be
+ * relative to, so allow as many ".." at the beginning of the path as
+ * there are components in reldir. This is used for symbolic link targets.
+ * If reldir is non-null and the path began with "/", to be completely like
+ * a chroot we should add in depth levels of ".." at the beginning of the
+ * path, but that would blow the assumption that the path doesn't grow and
+ * it is not likely to end up being a valid symlink anyway, so just do
+ * the normal removal of the leading "/" instead.
+ *
+ * Contributed by Dave Dykstra <dwd@bell-labs.com>
+ */
+void sanitize_path(char *p, char *reldir)
+{
+ char *start, *sanp;
+ int depth = 0;
+ int allowdotdot = 0;
+
+ if (reldir) {
+ depth++;
+ while (*reldir) {
+ if (*reldir++ == '/') {
+ depth++;
+ }
+ }
+ }
+ start = p;
+ sanp = p;
+ while (*p == '/') {
+ /* remove leading slashes */
+ p++;
+ }
+ while (*p != '\0') {
+ /* this loop iterates once per filename component in p.
+ * both p (and sanp if the original had a slash) should
+ * always be left pointing after a slash
+ */
+ if ((*p == '.') && ((*(p+1) == '/') || (*(p+1) == '\0'))) {
+ /* skip "." component */
+ while (*++p == '/') {
+ /* skip following slashes */
+ ;
+ }
+ continue;
+ }
+ allowdotdot = 0;
+ if ((*p == '.') && (*(p+1) == '.') &&
+ ((*(p+2) == '/') || (*(p+2) == '\0'))) {
+ /* ".." component followed by slash or end */
+ if ((depth > 0) && (sanp == start)) {
+ /* allow depth levels of .. at the beginning */
+ --depth;
+ allowdotdot = 1;
+ } else {
+ p += 2;
+ if (*p == '/')
+ p++;
+ if (sanp != start) {
+ /* back up sanp one level */
+ --sanp; /* now pointing at slash */
+ while ((sanp > start) && (*(sanp - 1) != '/')) {
+ /* skip back up to slash */
+ sanp--;
+ }
+ }
+ continue;
+ }
+ }
+ while (1) {
+ /* copy one component through next slash */
+ *sanp++ = *p++;
+ if ((*p == '\0') || (*(p-1) == '/')) {
+ while (*p == '/') {
+ /* skip multiple slashes */
+ p++;
+ }
+ break;
+ }
+ }
+ if (allowdotdot) {
+ /* move the virtual beginning to leave the .. alone */
+ start = sanp;
+ }
+ }
+ if ((sanp == start) && !allowdotdot) {
+ /* ended up with nothing, so put in "." component */
+ /*
+ * note that the !allowdotdot doesn't prevent this from
+ * happening in all allowed ".." situations, but I didn't
+ * think it was worth putting in an extra variable to ensure
+ * it since an extra "." won't hurt in those situations.
+ */
+ *sanp++ = '.';
+ }
+ *sanp = '\0';