instw_getstatus(&instw,&status);

	if(status&INSTW_TRANSLATED) 
		result=true_openat(instw.translpath,flags,mode);
	else
		result=true_openat(instw.path,flags,mode);
	
	if(flags & (O_WRONLY | O_RDWR)) 
		logg("%d\topenat\t%s\t#%s\n", result,instw.path, error(result));

	instw_delete(&instw);

snprintf(proc_path, PROC_PATH_LEN, "/proc/self/fd/%d", dirfd);
	if(true_stat(proc_path, &s) == -1)
		goto out;
	if(!(newpath = malloc(s.st_size+strlen(relpath)+2)))
		goto out;
	if((l = true_readlink(proc_path, newpath, s.st_size)) == -1)
		goto free_out;
	newpath[l] = '/';

int openat (int dirfd, const char *path, int flags, ...) {
	mode_t mode = 0;
	va_list arg;
	if(flags & O_CREAT) {
		va_start(arg, flags);
		mode = va_arg(arg, mode_t);
		va_end (arg);
	}
	int result, status;
	instw_t instw;

	/* If all we are doing is normal open, forgo refcounting, etc. */
        if(dirfd == AT_FDCWD || *path == '/') {
                printf("hello1\n");
		return open(path, flags, mode);
		logg("%d\topenat\t%s\t#%s\n", result,path, error(result));
	}

	REFCOUNT;

	if (!libc_handle)
		initialize();

#if DEBUG
	debug(2, "openat(%d, %s, 0x%x, 0%o)\n", dirfd, path, flags, mode);
#endif
	

	instw_new(&instw);
	instw_setpathrel(&instw,dirfd,path);
	
	  /* We were asked to work in "real" mode */
	if(!(__instw.gstatus & INSTW_INITIALIZED) ||
	   !(__instw.gstatus & INSTW_OKWRAP))
		return open(path,flags,mode);
	
#if DEBUG
	instw_print(&instw);
#endif

	/* if(flags & (O_WRONLY | O_RDWR)) {
		backup(instw.truepath);
		instw_apply(&instw);
	} */
	
	backup(instw.truepath);
	instw_apply(&instw);

	instw_getstatus(&instw,&status);

	if(status&INSTW_TRANSLATED) {
		printf("hello2\n");
		result=open(instw.translpath,flags,mode);
		logg("%d\topenat\t%s\t#%s\n", result,instw.translpath, error(result));
	} else {
		printf("hello3\n");
		result=open(instw.path,flags,mode);
		logg("%d\topenat\t%s\t#%s\n", result,instw.path, error(result));	
		}
	
	/* if(flags & (O_WRONLY | O_RDWR))
		logg("%d\topenat\t%s\t#%s\n", result,
		    instw.reslvpath, error(result)); */

	instw_delete(&instw);

	return result;
}

#endif /* GLIBC_MINOR >= 4 */

int openat (int dirfd, const char *path, int flags, ...) {
	mode_t mode = 0;
	va_list arg;
	if(flags & O_CREAT) {
		va_start(arg, flags);
		mode = va_arg(arg, mode_t);
		va_end (arg);
	}
	int result, status;
	instw_t instw;

	/* If all we are doing is normal open, forgo refcounting, etc. */
        if(dirfd == AT_FDCWD || *path == '/')
                return open(path, flags, mode);

	REFCOUNT;

	if (!libc_handle)
		initialize();

	debug(2, "openat(%d, %s, 0x%x, 0%o)\n", dirfd, path, flags, mode);

	  /* We were asked to work in "real" mode */
	if(!(__instw.gstatus & INSTW_INITIALIZED) ||
	   !(__instw.gstatus & INSTW_OKWRAP))
		return true_openat(dirfd,path,flags,mode);

	instw_new(&instw);
	instw_setpathrel(&instw,dirfd,path);
	
#if DEBUG
	instw_print(&instw);
#endif

	if(flags & (O_WRONLY | O_RDWR)) {
		backup(instw.truepath);
		instw_apply(&instw);
	}

	instw_getstatus(&instw,&status);

	if(status&INSTW_TRANSLATED) 
		result=open(instw.translpath,flags,mode);
	else
		result=open(instw.path,flags,mode);
	
	/* if(flags & (O_WRONLY | O_RDWR)) 
		logg("%d\topenat\t%s\t#%s\n", result,instw.path, error(result)); */

	instw_delete(&instw);

	return result;
}

#endif /* GLIBC_MINOR >= 4 */

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>

#define NEW_DIR "/usr/foo"
#define REL_READ_FILE "../lib/libssl.so"

int new_dir_rel_read_file(void)
{
	printf("Checking if you can read a relative file in an new dir...\n");

	int fd, retval = 0;
	static char buf[5];
	if((fd = open(NEW_DIR "/" REL_READ_FILE, O_RDONLY)) == -1)
		goto out;
	if(read(fd, buf, sizeof(buf) - 1) != sizeof(buf) - 1)
		goto close_out;
	retval = 1;
	printf("\tthe next three letters should be ELF: %s.\n", buf+1);

close_out:
	close(fd);
out:
	if(!retval)
		perror(__func__);
	return retval;
}

int main(int argc, char *argv[])
{
	printf("Attempting to create " NEW_DIR "...\n");
	if(mkdir(NEW_DIR, 0755) == -1) {
		perror(NEW_DIR " could not be created");
		return -1;
	}
	else
		printf("\t" NEW_DIR " successfully created.\n");

	new_dir_rel_read_file();

	return 0;
}

    Since stat and readlink are used internally there should be no reason to print
    the extra noise in the debugfile, at least once it is working correctly.

--- a/installwatch.c
+++ b/installwatch.c
@@ -1548,11 +1548,11 @@ static int instw_setpathrel(instw_t *instw, int dirfd, const char *relpath) {
 	struct stat s;
 
 	snprintf(proc_path, PROC_PATH_LEN, "/proc/self/fd/%d", dirfd);
-	if(stat(proc_path, &s) == -1)
+	if(true_stat(proc_path, &s) == -1)
 		goto out;
 	if(!(newpath = malloc(s.st_size+strlen(relpath)+2)))
 		goto out;
-	if((l = readlink(proc_path, newpath, s.st_size)) == -1)
+	if((l = true_readlink(proc_path, newpath, s.st_size)) == -1)
 		goto free_out;
 	newpath[l] = '/';
 	strcpy(newpath + l + 1, relpath);

    Let the wrapper for open handle all logging and backing up (even though it’s)
    less efficient.

--- a/installwatch.c
+++ b/installwatch.c
@@ -3724,7 +3724,7 @@ int openat (int dirfd, const char *path, int flags, ...) {
 		mode = va_arg(arg, mode_t);
 		va_end (arg);
 	}
-	int result, status;
+	int result;
 	instw_t instw;
 
 	/* If all we are doing is normal open, forgo refcounting, etc. */
@@ -3750,21 +3750,7 @@ int openat (int dirfd, const char *path, int flags, ...) {
 	instw_print(&instw);
 #endif
 
-	if(flags & (O_WRONLY | O_RDWR)) {
-		backup(instw.truepath);
-		instw_apply(&instw);
-	}
-
-	instw_getstatus(&instw,&status);
-
-	if(status&INSTW_TRANSLATED) 
-		result=true_open(instw.translpath,flags,mode);
-	else
-		result=true_open(instw.path,flags,mode);
-	
-	if(flags & (O_WRONLY | O_RDWR)) 
-		logg("%d\topenat\t%d\t%s\t0x%x\t0%o\t#%s\n", result, dirfd,
-		    path, flags, mode, error(result));
+	result = open(instw.path, flags, mode);
 
 	instw_delete(&instw);

    Introduce a recursive function called “reduce()” which does in-place path
    reduction (i.e., gets rid of "//", "..", and ".") of absolute paths. This
    is like realpath() except it doesn’t process links and doesn’t need an
    extra buffer. This new function will be called from setpath.

--- a/installwatch.c
+++ b/installwatch.c
@@ -213,6 +213,7 @@ typedef struct instw_t {
 static instw_t __instw;
 
 static int canonicalize(const char *,char *);
+static int reduce(char *);
 static int make_path(const char *);
 static int copy_path(const char *,const char *);
 static inline int path_excluded(const char *);
@@ -525,6 +526,61 @@ static int canonicalize(const char *path, char *resolved_path) {
 	return 0;
 } 
 
+/*
+ * procedure = / rc:=reduce(path) /
+ *
+ * task      = /   reduces all occurences of "..", ".", and extra "/" in path.
+ *
+ * inputs    = / path               The modifiable string containing the path
+ * outputs   = / path               The reduced path.
+ *
+ * returns   = /  0 ok. path reduced
+ *               -1 failed. cf errno /
+ * note      = /
+ *      --Very similar to canonicalize()/realpath() except we don’t do link-
+ *      expansion
+ *      --This is purely a string manipulation function (i.e., no verification
+ *      of a path’s validity occurs).
+ *      --Additionally, we try to do reduction “in-place” since the ending
+ *      path is shorter than the beginning path.
+ *      --Also, we want only absolute paths (other paths will throw an error)
+ * /
+ */
+static int reduce(char *path) {
+	int len;
+	char *off;
+
+	if(path == NULL || *path != '/') {
+		errno = EINVAL;
+		return -1;
+	}
+
+	len = strlen(path);
+
+	/* First, get rid of double / */
+	if(off = strstr(path, "//")) {
+		memmove(off, off+1, len - (off-path));
+		return reduce(path);
+	}
+
+	/* Then, worry about /../ */
+	if(off = strstr(path, "/../")) {
+		char *off2 = off;
+		if(off2++ != path)
+			while((--off2)[-1] != '/');
+		memmove(off2, off+4, len - 3 - (off-path));
+		return reduce(path);
+	}
+
+	/* Finally, do /./ */
+	if(off = strstr(path, "/./")) {
+		memmove(off, off+2, len - 1 - (off-path));
+		return reduce(path);
+	}
+
+	return 0;
+}
+
 static int make_path (const char *path) {
 	char checkdir[BUFSIZ];
 	struct stat inode;
@@ -1448,6 +1504,7 @@ static int instw_setpath(instw_t *instw,const char *path) {
 		}
 		strcat(instw->truepath,instw->path);
 	} else {
+		reduce(instw->path);
 		strcpy(instw->truepath,instw->path);
 	}
 	relen=strlen(instw->truepath);

    Switch the order of processing /./ and /../ in reduce().

--- a/installwatch.c
+++ b/installwatch.c
@@ -563,7 +563,13 @@ static int reduce(char *path) {
 		return reduce(path);
 	}
 
-	/* Then, worry about /../ */
+	/* Then, worry about /./ */
+	if(off = strstr(path, "/./")) {
+		memmove(off, off+2, len - 1 - (off-path));
+		return reduce(path);
+	}
+
+	/* Finally, do /../ */
 	if(off = strstr(path, "/../")) {
 		char *off2 = off;
 		if(off2++ != path)
@@ -572,12 +578,6 @@ static int reduce(char *path) {
 		return reduce(path);
 	}
 
-	/* Finally, do /./ */
-	if(off = strstr(path, "/./")) {
-		memmove(off, off+2, len - 1 - (off-path));
-		return reduce(path);
-	}
-
 	return 0;
 }

    This improves reduce() for those pesky cases where the culprit is at the end of
    the path (e.g., “/foo/bar/”, “/foo/bar/.”, or “/foo/bar/..”). We can’t just
    scan for a substring because for all we know that is the desired filename (e.g.,
    both “/foo/bar/..baz” and “/foo/bar../baz” would be clobbered). So we treat the
    case of the ending separately.
    
    Additionally, it seems we might have a candidate for IOCCC :)

--- a/installwatch.c
+++ b/installwatch.c
@@ -577,8 +577,31 @@ static int reduce(char *path) {
 		memmove(off2, off+4, len - 3 - (off-path));
 		return reduce(path);
 	}
-
-	return 0;
+	/* Beautify ending */
+	switch(path[len - 1]) {
+		case '.':
+			switch(path[len - 2]) {
+				default:
+					return 0;
+				case '.':
+					if(len != 3) {
+						off = path+len-3;
+						if(*off-- != '/')
+							return 0;
+						while(*--off != '/');
+						off[1] = 0;
+						return reduce(path);
+					}
+				case '/': ;
+			}
+		case '/':
+			if(len != 1) {
+				path[len-1] = 0;
+				return reduce(path);
+			}
+		default:
+			return 0;
+	}
 }
 
 static int make_path (const char *path) {