klee/tools/klee-replay/file-creator.c - third_party/llvm-project - Git at Google

 //===-- file-creator.c ----------------------------------------------------===//
 //
 //                     The KLEE Symbolic Virtual Machine
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "klee-replay.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <termios.h>
 #include <pty.h>
 #include <time.h>
 #include <sys/wait.h>
 #include <sys/time.h>
 #include <assert.h>

 static void create_file(int target_fd,
                        const char *target_name,
                        exe_disk_file_t *dfile,
                        const char *tmpdir);
 static void check_file(int index, exe_disk_file_t *file);
 static void delete_file(const char *path, int recurse);


 #define __STDIN -1
 #define __STDOUT -2

 static int create_link(const char *fname,
                        exe_disk_file_t *dfile,
                        const char *tmpdir) {
   char buf[64];
   struct stat64 *s = dfile->stat;

   // XXX Broken, we want this path to be somewhere else most likely.
   sprintf(buf, "%s.lnk", fname);
   s->st_mode = (s->st_mode & ~S_IFMT) | S_IFREG;
   create_file(-1, buf, dfile, tmpdir);

   int res = symlink(buf, fname);
   if (res < 0) {
     perror("symlink");
   }

   return open(fname, O_RDWR);
 }


 static int create_dir(const char *fname, exe_disk_file_t *dfile,
                       const char *tmpdir) {
   int res = mkdir(fname, dfile->stat->st_mode);
   if (res < 0) {
     perror("mkdir");
     return -1;
   }
   return open(fname, O_RDWR);
 }

 double getTime() {
   struct timeval t;
   gettimeofday(&t, NULL);

   return (double) t.tv_sec + ((double) t.tv_usec / 1000000.0);
 }

 /// Return true if program exited, false if timed out.
 int wait_for_timeout_or_exit(pid_t pid, const char *name, int *statusp) {
   char *t = getenv("KLEE_REPLAY_TIMEOUT");
   int timeout = t ? atoi(t) : 5;
   double wait = timeout * .5;
   double start = getTime();
   fprintf(stderr, "note: %s: waiting %.2fs\n", name, wait);
   while (getTime() - start < wait) {
     struct timespec r = {0, 1000000};
     nanosleep(&r, 0);
     int res = waitpid(pid, statusp, WNOHANG);
     if (res==pid)
       return 1;
   }

   return 0;
 }

 static int create_char_dev(const char *fname, exe_disk_file_t *dfile,
                            const char *tmpdir) {
   struct stat64 *s = dfile->stat;
   unsigned flen = dfile->size;
   char* contents = dfile->contents;

   // Assume tty, kinda broken, need an actual device id or something
   struct termios term, *ts=&term;
   struct winsize win = { 24, 80, 0, 0 };
   /* Just copied from my system, munged to match what fields
      uclibc thinks are there. */
   ts->c_iflag = 27906;
   ts->c_oflag = 5;
   ts->c_cflag = 1215;
   ts->c_lflag = 35287;
   ts->c_line = 0;
   ts->c_cc[0] = '\x03';
   ts->c_cc[1] = '\x1c';
   ts->c_cc[2] = '\x7f';
   ts->c_cc[3] = '\x15';
   ts->c_cc[4] = '\x04';
   ts->c_cc[5] = '\x00';
   ts->c_cc[6] = '\x01';
   ts->c_cc[7] = '\xff';
   ts->c_cc[8] = '\x11';
   ts->c_cc[9] = '\x13';
   ts->c_cc[10] = '\x1a';
   ts->c_cc[11] = '\xff';
   ts->c_cc[12] = '\x12';
   ts->c_cc[13] = '\x0f';
   ts->c_cc[14] = '\x17';
   ts->c_cc[15] = '\x16';
   ts->c_cc[16] = '\xff';
   ts->c_cc[17] = '\x0';
   ts->c_cc[18] = '\x0';

   {
     char name[1024];
     int amaster, aslave;
     int res = openpty(&amaster, &aslave, name, &term, &win);
     if (res < 0) {
       perror("openpty");
       exit(1);
     }

     if (symlink(name, fname) == -1) {
       fprintf(stderr, "unable to create sym link to tty\n");
       perror("symlink");
     }

     // pty will not be world writeable
     s->st_mode &= ~02;

     pid_t pid = fork();
     if (pid < 0) {
       perror("fork failed\n");
       exit(1);
     } else if (pid == 0) {
       close(amaster);

       fprintf(stderr, "note: pty slave: setting raw mode\n");
       {
         struct termio mode;

         int res = ioctl(aslave, TCGETA, &mode);
         assert(!res);
         mode.c_iflag = IGNBRK;
         mode.c_oflag &= ~(OLCUC | ONLCR | OCRNL | ONLRET);
         mode.c_lflag = 0;
         mode.c_cc[VMIN] = 1;
         mode.c_cc[VTIME] = 0;
         res = ioctl(aslave, TCSETA, &mode);
         assert(res == 0);
       }

       return aslave;
     } else {
       unsigned pos = 0;
       int status;
       fprintf(stderr, "note: pty master: starting\n");
       close(aslave);

       while (pos < flen) {
 	int res = write(amaster, &contents[pos], flen - pos);
 	if (res<0) {
 	  if (errno != EINTR) {
 	    fprintf(stderr, "note: pty master: write error\n");
 	    perror("errno");
 	    break;
 	  }
 	} else if (res) {
 	  fprintf(stderr, "note: pty master: wrote: %d (of %d)\n", res, flen);
 	  pos += res;
 	}
       }

       if (wait_for_timeout_or_exit(pid, "pty master", &status))
         goto pty_exit;

       fprintf(stderr, "note: pty master: closing & waiting\n");
       close(amaster);
       while (1) {
 	int res = waitpid(pid, &status, 0);
 	if (res < 0) {
 	  if (errno != EINTR)
 	    break;
 	} else {
 	  break;
 	}
       }

     pty_exit:
       close(amaster);
       fprintf(stderr, "note: pty master: done\n");
       process_status(status, 0, "PTY MASTER");
     }
   }
 }

 static int create_pipe(const char *fname, exe_disk_file_t *dfile,
                        const char *tmpdir) {
   //struct stat64 *s = dfile->stat;
   unsigned flen = dfile->size;
   char* contents = dfile->contents;

   // XXX what is direction ? need more data
   pid_t pid;
   int fds[2];
   int res = pipe(fds);
   if (res < 0) {
     perror("pipe");
     exit(1);
   }

   pid  = fork();
   if (pid < 0) {
     perror("fork");
     exit(1);
   } else if (pid == 0) {
     close(fds[1]);
     return fds[0];
   } else {
     unsigned pos = 0;
     int status;
     fprintf(stderr, "note: pipe master: starting\n");
     close(fds[0]);

     while (pos < flen) {
       int res = write(fds[1], &contents[pos], flen - pos);
       if (res<0) {
 	if (errno != EINTR)
 	  break;
       } else if (res) {
 	pos += res;
       }
     }

     if (wait_for_timeout_or_exit(pid, "pipe master", &status))
       goto pipe_exit;

     fprintf(stderr, "note: pipe master: closing & waiting\n");
     close(fds[1]);
     while (1) {
       int res = waitpid(pid, &status, 0);
       if (res < 0) {
 	if (errno != EINTR)
 	  break;
       } else {
 	break;
       }
     }

   pipe_exit:
     close(fds[1]);
     fprintf(stderr, "note: pipe master: done\n");
     process_status(status, 0, "PTY MASTER");
   }
 }


 static int create_reg_file(const char *fname, exe_disk_file_t *dfile,
                            const char *tmpdir) {
   struct stat64 *s = dfile->stat;
   char* contents = dfile->contents;
   unsigned flen = dfile->size;
   unsigned mode = s->st_mode & 0777;

   //fprintf(stderr, "Creating regular file\n");

   // Open in RDWR just in case we have to end up using this fd.

   if (__exe_env.version == 0 && mode == 0)
     mode = 0644;


   int fd = open(fname, O_CREAT | O_RDWR, mode);
   //    int fd = open(fname, O_CREAT | O_WRONLY, s->st_mode&0777);
   if (fd < 0) {
     fprintf(stderr, "Cannot create file %s\n", fname);
     exit(1);
   }

   int r = write(fd, contents, flen);
   if (r < 0 || (unsigned) r != flen) {
     fprintf(stderr, "Cannot write file %s\n", fname);
     exit(1);
   }

   struct timeval tv[2];
   tv[0].tv_sec = s->st_atime;
   tv[0].tv_usec = 0;
   tv[1].tv_sec = s->st_mtime;
   tv[1].tv_usec = 0;
   futimes(fd, tv);

   // XXX: Now what we should do is reopen a new fd with the correct modes
   // as they were given to the process.
   lseek(fd, 0, SEEK_SET);

   return fd;
 }

 static int delete_dir(const char *path, int recurse) {
   if (recurse) {
     DIR *d = opendir(path);
     struct dirent *de;

     if (d) {
       while ((de = readdir(d))) {
         if (strcmp(de->d_name, ".")!=0 && strcmp(de->d_name, "..")!=0) {
           char tmp[PATH_MAX];
           sprintf(tmp, "%s/%s", path, de->d_name);
           delete_file(tmp, 0);
         }
       }

       closedir(d);
     }
   }

   if (rmdir(path) == -1) {
     fprintf(stderr, "Cannot create file %s (exists, is dir, can't remove)\n", path);
     perror("rmdir");
     return -1;
   }

   return 0;
 }

 static void delete_file(const char *path, int recurse) {
   if (unlink(path) < 0 && errno != ENOENT) {
     if (errno == EISDIR) {
       delete_dir(path, 1);
     } else {
       fprintf(stderr, "Cannot create file %s (already exists)\n", path);
       perror("unlink");
     }
   }
 }

 static void create_file(int target_fd,
                         const char *target_name,
                         exe_disk_file_t *dfile,
                         const char *tmpdir) {
   struct stat64 *s = dfile->stat;
   char tmpname[PATH_MAX];
   const char *target;
   int fd;

   assert((target_fd == -1) ^ (target_name == NULL));

   if (target_name) {
     target = target_name;
   } else {
     sprintf(tmpname, "%s/fd%d", tmpdir, target_fd);
     target = tmpname;
   }

   delete_file(target, 1);

   // XXX get rid of me once a reasonable solution is found
   s->st_uid = geteuid();
   s->st_gid = getegid();

   if (S_ISLNK(s->st_mode)) {
     fd = create_link(target, dfile, tmpdir);
   }
   else if (S_ISDIR(s->st_mode)) {
     fd = create_dir(target, dfile, tmpdir);
   }
   else if (S_ISCHR(s->st_mode)) {
     fd = create_char_dev(target, dfile, tmpdir);
   }
   else if (S_ISFIFO(s->st_mode) ||
            (target_fd==0 && (s->st_mode & S_IFMT) == 0)) { // XXX hack
     fd = create_pipe(target, dfile, tmpdir);
   }
   else {
     fd = create_reg_file(target, dfile, tmpdir);
   }

   if (fd >= 0) {
     if (target_fd != -1) {
       close(target_fd);
       if (dup2(fd, target_fd) < 0) {
         fprintf(stderr, "note: dup2 failed for target: %d\n", target_fd);
         perror("dup2");
       }
       close(fd);
     } else {
       // Only worry about 1 vs !1
       if (s->st_nlink > 1) {
         char tmp2[PATH_MAX];
         sprintf(tmp2, "%s/%s.link2", tmpdir, target_name);
         if (link(target_name, tmp2) < 0) {
           perror("link");
           exit(1);
         }
       }

       close(fd);
     }
   }
 }

 void replay_create_files(exe_file_system_t *exe_fs) {
   char tmpdir[PATH_MAX];
   unsigned k;

   if (!getcwd(tmpdir, PATH_MAX)) {
     perror("getcwd");
     exit(1);
   }

   strcat(tmpdir, ".temps");
   delete_file(tmpdir, 1);
   mkdir(tmpdir, 0755);

   umask(0);
   for (k=0; k < exe_fs->n_sym_files; k++) {
     char name[2];
     sprintf(name, "%c", 'A' + k);
     create_file(-1, name, &exe_fs->sym_files[k], tmpdir);
   }

   if (exe_fs->sym_stdin)
     create_file(0, NULL, exe_fs->sym_stdin, tmpdir);

   if (exe_fs->sym_stdout)
     create_file(1, NULL, exe_fs->sym_stdout, tmpdir);

   if (exe_fs->sym_stdin)
     check_file(__STDIN, exe_fs->sym_stdin);

   if (exe_fs->sym_stdout)
     check_file(__STDOUT, exe_fs->sym_stdout);

   for (k=0; k<exe_fs->n_sym_files; ++k)
     check_file(k, &exe_fs->sym_files[k]);
 }

 static void check_file(int index, exe_disk_file_t *dfile) {
   struct stat s;
   int res;
   char name[32];

   switch (index) {
   case __STDIN:
     strcpy(name, "stdin");
     res = fstat(0, &s);
     break;
   case __STDOUT:
     strcpy(name, "stdout");
     res = fstat(1, &s);
     break;
   default:
     name[0] = 'A' + index;
     name[1] = '\0';
     res = stat(name, &s);
     break;
   }

   if (res < 0) {
     fprintf(stderr, "warning: check_file %d: stat failure\n", index);
     return;
   }

   if (s.st_dev != dfile->stat->st_dev) {
     fprintf(stderr, "warning: check_file %s: dev mismatch: %d vs %d\n",
             name, (int) s.st_dev, (int) dfile->stat->st_dev);
   }
 /*   if (s.st_ino != dfile->stat->st_ino) { */
 /*     fprintf(stderr, "warning: check_file %s: ino mismatch: %d vs %d\n",  */
 /*             name, (int) s.st_ino, (int) dfile->stat->st_ino);     */
 /*   } */
   if (s.st_mode != dfile->stat->st_mode) {
     fprintf(stderr, "warning: check_file %s: mode mismatch: %#o vs %#o\n",
             name, s.st_mode, dfile->stat->st_mode);
   }
   if (s.st_nlink != dfile->stat->st_nlink) {
     fprintf(stderr, "warning: check_file %s: nlink mismatch: %d vs %d\n",
             name, (int) s.st_nlink, (int) dfile->stat->st_nlink);
   }
   if (s.st_uid != dfile->stat->st_uid) {
     fprintf(stderr, "warning: check_file %s: uid mismatch: %d vs %d\n",
             name, s.st_uid, dfile->stat->st_uid);
   }
   if (s.st_gid != dfile->stat->st_gid) {
     fprintf(stderr, "warning: check_file %s: gid mismatch: %d vs %d\n",
             name, s.st_gid, dfile->stat->st_gid);
   }
   if (s.st_rdev != dfile->stat->st_rdev) {
     fprintf(stderr, "warning: check_file %s: rdev mismatch: %d vs %d\n",
             name, (int) s.st_rdev, (int) dfile->stat->st_rdev);
   }
   if (s.st_size != dfile->stat->st_size) {
     fprintf(stderr, "warning: check_file %s: size mismatch: %d vs %d\n",
             name, (int) s.st_size, (int) dfile->stat->st_size);
   }
   if (s.st_blksize != dfile->stat->st_blksize) {
     fprintf(stderr, "warning: check_file %s: blksize mismatch: %d vs %d\n",
             name, (int) s.st_blksize, (int) dfile->stat->st_blksize);
   }
   if (s.st_blocks != dfile->stat->st_blocks) {
     fprintf(stderr, "warning: check_file %s: blocks mismatch: %d vs %d\n",
             name, (int) s.st_blocks, (int) dfile->stat->st_blocks);
   }
 /*   if (s.st_atime != dfile->stat->st_atime) { */
 /*     fprintf(stderr, "warning: check_file %s: atime mismatch: %d vs %d\n",  */
 /*             name, (int) s.st_atime, (int) dfile->stat->st_atime); */
 /*   } */
 /*   if (s.st_mtime != dfile->stat->st_mtime) { */
 /*     fprintf(stderr, "warning: check_file %s: mtime mismatch: %d vs %d\n",  */
 /*             name, (int) s.st_mtime, (int) dfile->stat->st_mtime);     */
 /*   } */
 /*   if (s.st_ctime != dfile->stat->st_ctime) { */
 /*     fprintf(stderr, "warning: check_file %s: ctime mismatch: %d vs %d\n",  */
 /*             name, (int) s.st_ctime, (int) dfile->stat->st_ctime);     */
 /*   } */
 }
	//===-- file-creator.c ----------------------------------------------------===//
	//
	// The KLEE Symbolic Virtual Machine
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "klee-replay.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <errno.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <termios.h>
	#include <pty.h>
	#include <time.h>
	#include <sys/wait.h>
	#include <sys/time.h>
	#include <assert.h>

	static void create_file(int target_fd,
	const char *target_name,
	exe_disk_file_t *dfile,
	const char *tmpdir);
	static void check_file(int index, exe_disk_file_t *file);
	static void delete_file(const char *path, int recurse);


	#define __STDIN -1
	#define __STDOUT -2

	static int create_link(const char *fname,
	exe_disk_file_t *dfile,
	const char *tmpdir) {
	char buf[64];
	struct stat64 *s = dfile->stat;

	// XXX Broken, we want this path to be somewhere else most likely.
	sprintf(buf, "%s.lnk", fname);
	s->st_mode = (s->st_mode & ~S_IFMT) \| S_IFREG;
	create_file(-1, buf, dfile, tmpdir);

	int res = symlink(buf, fname);
	if (res < 0) {
	perror("symlink");
	}

	return open(fname, O_RDWR);
	}


	static int create_dir(const char fname, exe_disk_file_t dfile,
	const char *tmpdir) {
	int res = mkdir(fname, dfile->stat->st_mode);
	if (res < 0) {
	perror("mkdir");
	return -1;
	}
	return open(fname, O_RDWR);
	}

	double getTime() {
	struct timeval t;
	gettimeofday(&t, NULL);

	return (double) t.tv_sec + ((double) t.tv_usec / 1000000.0);
	}

	/// Return true if program exited, false if timed out.
	int wait_for_timeout_or_exit(pid_t pid, const char name, int statusp) {
	char *t = getenv("KLEE_REPLAY_TIMEOUT");
	int timeout = t ? atoi(t) : 5;
	double wait = timeout * .5;
	double start = getTime();
	fprintf(stderr, "note: %s: waiting %.2fs\n", name, wait);
	while (getTime() - start < wait) {
	struct timespec r = {0, 1000000};
	nanosleep(&r, 0);
	int res = waitpid(pid, statusp, WNOHANG);
	if (res==pid)
	return 1;
	}

	return 0;
	}

	static int create_char_dev(const char fname, exe_disk_file_t dfile,
	const char *tmpdir) {
	struct stat64 *s = dfile->stat;
	unsigned flen = dfile->size;
	char* contents = dfile->contents;

	// Assume tty, kinda broken, need an actual device id or something
	struct termios term, *ts=&term;
	struct winsize win = { 24, 80, 0, 0 };
	/* Just copied from my system, munged to match what fields
	uclibc thinks are there. */
	ts->c_iflag = 27906;
	ts->c_oflag = 5;
	ts->c_cflag = 1215;
	ts->c_lflag = 35287;
	ts->c_line = 0;
	ts->c_cc[0] = '\x03';
	ts->c_cc[1] = '\x1c';
	ts->c_cc[2] = '\x7f';
	ts->c_cc[3] = '\x15';
	ts->c_cc[4] = '\x04';
	ts->c_cc[5] = '\x00';
	ts->c_cc[6] = '\x01';
	ts->c_cc[7] = '\xff';
	ts->c_cc[8] = '\x11';
	ts->c_cc[9] = '\x13';
	ts->c_cc[10] = '\x1a';
	ts->c_cc[11] = '\xff';
	ts->c_cc[12] = '\x12';
	ts->c_cc[13] = '\x0f';
	ts->c_cc[14] = '\x17';
	ts->c_cc[15] = '\x16';
	ts->c_cc[16] = '\xff';
	ts->c_cc[17] = '\x0';
	ts->c_cc[18] = '\x0';

	{
	char name[1024];
	int amaster, aslave;
	int res = openpty(&amaster, &aslave, name, &term, &win);
	if (res < 0) {
	perror("openpty");
	exit(1);
	}

	if (symlink(name, fname) == -1) {
	fprintf(stderr, "unable to create sym link to tty\n");
	perror("symlink");
	}

	// pty will not be world writeable
	s->st_mode &= ~02;

	pid_t pid = fork();
	if (pid < 0) {
	perror("fork failed\n");
	exit(1);
	} else if (pid == 0) {
	close(amaster);

	fprintf(stderr, "note: pty slave: setting raw mode\n");
	{
	struct termio mode;

	int res = ioctl(aslave, TCGETA, &mode);
	assert(!res);
	mode.c_iflag = IGNBRK;
	mode.c_oflag &= ~(OLCUC \| ONLCR \| OCRNL \| ONLRET);
	mode.c_lflag = 0;
	mode.c_cc[VMIN] = 1;
	mode.c_cc[VTIME] = 0;
	res = ioctl(aslave, TCSETA, &mode);
	assert(res == 0);
	}

	return aslave;
	} else {
	unsigned pos = 0;
	int status;
	fprintf(stderr, "note: pty master: starting\n");
	close(aslave);

	while (pos < flen) {
	int res = write(amaster, &contents[pos], flen - pos);
	if (res<0) {
	if (errno != EINTR) {
	fprintf(stderr, "note: pty master: write error\n");
	perror("errno");
	break;
	}
	} else if (res) {
	fprintf(stderr, "note: pty master: wrote: %d (of %d)\n", res, flen);
	pos += res;
	}
	}

	if (wait_for_timeout_or_exit(pid, "pty master", &status))
	goto pty_exit;

	fprintf(stderr, "note: pty master: closing & waiting\n");
	close(amaster);
	while (1) {
	int res = waitpid(pid, &status, 0);
	if (res < 0) {
	if (errno != EINTR)
	break;
	} else {
	break;
	}
	}

	pty_exit:
	close(amaster);
	fprintf(stderr, "note: pty master: done\n");
	process_status(status, 0, "PTY MASTER");
	}
	}
	}

	static int create_pipe(const char fname, exe_disk_file_t dfile,
	const char *tmpdir) {
	//struct stat64 *s = dfile->stat;
	unsigned flen = dfile->size;
	char* contents = dfile->contents;

	// XXX what is direction ? need more data
	pid_t pid;
	int fds[2];
	int res = pipe(fds);
	if (res < 0) {
	perror("pipe");
	exit(1);
	}

	pid = fork();
	if (pid < 0) {
	perror("fork");
	exit(1);
	} else if (pid == 0) {
	close(fds[1]);
	return fds[0];
	} else {
	unsigned pos = 0;
	int status;
	fprintf(stderr, "note: pipe master: starting\n");
	close(fds[0]);

	while (pos < flen) {
	int res = write(fds[1], &contents[pos], flen - pos);
	if (res<0) {
	if (errno != EINTR)
	break;
	} else if (res) {
	pos += res;
	}
	}

	if (wait_for_timeout_or_exit(pid, "pipe master", &status))
	goto pipe_exit;

	fprintf(stderr, "note: pipe master: closing & waiting\n");
	close(fds[1]);
	while (1) {
	int res = waitpid(pid, &status, 0);
	if (res < 0) {
	if (errno != EINTR)
	break;
	} else {
	break;
	}
	}

	pipe_exit:
	close(fds[1]);
	fprintf(stderr, "note: pipe master: done\n");
	process_status(status, 0, "PTY MASTER");
	}
	}


	static int create_reg_file(const char fname, exe_disk_file_t dfile,
	const char *tmpdir) {
	struct stat64 *s = dfile->stat;
	char* contents = dfile->contents;
	unsigned flen = dfile->size;
	unsigned mode = s->st_mode & 0777;

	//fprintf(stderr, "Creating regular file\n");

	// Open in RDWR just in case we have to end up using this fd.

	if (__exe_env.version == 0 && mode == 0)
	mode = 0644;


	int fd = open(fname, O_CREAT \| O_RDWR, mode);
	// int fd = open(fname, O_CREAT \| O_WRONLY, s->st_mode&0777);
	if (fd < 0) {
	fprintf(stderr, "Cannot create file %s\n", fname);
	exit(1);
	}

	int r = write(fd, contents, flen);
	if (r < 0 \|\| (unsigned) r != flen) {
	fprintf(stderr, "Cannot write file %s\n", fname);
	exit(1);
	}

	struct timeval tv[2];
	tv[0].tv_sec = s->st_atime;
	tv[0].tv_usec = 0;
	tv[1].tv_sec = s->st_mtime;
	tv[1].tv_usec = 0;
	futimes(fd, tv);

	// XXX: Now what we should do is reopen a new fd with the correct modes
	// as they were given to the process.
	lseek(fd, 0, SEEK_SET);

	return fd;
	}

	static int delete_dir(const char *path, int recurse) {
	if (recurse) {
	DIR *d = opendir(path);
	struct dirent *de;

	if (d) {
	while ((de = readdir(d))) {
	if (strcmp(de->d_name, ".")!=0 && strcmp(de->d_name, "..")!=0) {
	char tmp[PATH_MAX];
	sprintf(tmp, "%s/%s", path, de->d_name);
	delete_file(tmp, 0);
	}
	}

	closedir(d);
	}
	}

	if (rmdir(path) == -1) {
	fprintf(stderr, "Cannot create file %s (exists, is dir, can't remove)\n", path);
	perror("rmdir");
	return -1;
	}

	return 0;
	}

	static void delete_file(const char *path, int recurse) {
	if (unlink(path) < 0 && errno != ENOENT) {
	if (errno == EISDIR) {
	delete_dir(path, 1);
	} else {
	fprintf(stderr, "Cannot create file %s (already exists)\n", path);
	perror("unlink");
	}
	}
	}

	static void create_file(int target_fd,
	const char *target_name,
	exe_disk_file_t *dfile,
	const char *tmpdir) {
	struct stat64 *s = dfile->stat;
	char tmpname[PATH_MAX];
	const char *target;
	int fd;

	assert((target_fd == -1) ^ (target_name == NULL));

	if (target_name) {
	target = target_name;
	} else {
	sprintf(tmpname, "%s/fd%d", tmpdir, target_fd);
	target = tmpname;
	}

	delete_file(target, 1);

	// XXX get rid of me once a reasonable solution is found
	s->st_uid = geteuid();
	s->st_gid = getegid();

	if (S_ISLNK(s->st_mode)) {
	fd = create_link(target, dfile, tmpdir);
	}
	else if (S_ISDIR(s->st_mode)) {
	fd = create_dir(target, dfile, tmpdir);
	}
	else if (S_ISCHR(s->st_mode)) {
	fd = create_char_dev(target, dfile, tmpdir);
	}
	else if (S_ISFIFO(s->st_mode) \|\|
	(target_fd==0 && (s->st_mode & S_IFMT) == 0)) { // XXX hack
	fd = create_pipe(target, dfile, tmpdir);
	}
	else {
	fd = create_reg_file(target, dfile, tmpdir);
	}

	if (fd >= 0) {
	if (target_fd != -1) {
	close(target_fd);
	if (dup2(fd, target_fd) < 0) {
	fprintf(stderr, "note: dup2 failed for target: %d\n", target_fd);
	perror("dup2");
	}
	close(fd);
	} else {
	// Only worry about 1 vs !1
	if (s->st_nlink > 1) {
	char tmp2[PATH_MAX];
	sprintf(tmp2, "%s/%s.link2", tmpdir, target_name);
	if (link(target_name, tmp2) < 0) {
	perror("link");
	exit(1);
	}
	}

	close(fd);
	}
	}
	}

	void replay_create_files(exe_file_system_t *exe_fs) {
	char tmpdir[PATH_MAX];
	unsigned k;

	if (!getcwd(tmpdir, PATH_MAX)) {
	perror("getcwd");
	exit(1);
	}

	strcat(tmpdir, ".temps");
	delete_file(tmpdir, 1);
	mkdir(tmpdir, 0755);

	umask(0);
	for (k=0; k < exe_fs->n_sym_files; k++) {
	char name[2];
	sprintf(name, "%c", 'A' + k);
	create_file(-1, name, &exe_fs->sym_files[k], tmpdir);
	}

	if (exe_fs->sym_stdin)
	create_file(0, NULL, exe_fs->sym_stdin, tmpdir);

	if (exe_fs->sym_stdout)
	create_file(1, NULL, exe_fs->sym_stdout, tmpdir);

	if (exe_fs->sym_stdin)
	check_file(__STDIN, exe_fs->sym_stdin);

	if (exe_fs->sym_stdout)
	check_file(__STDOUT, exe_fs->sym_stdout);

	for (k=0; k<exe_fs->n_sym_files; ++k)
	check_file(k, &exe_fs->sym_files[k]);
	}

	static void check_file(int index, exe_disk_file_t *dfile) {
	struct stat s;
	int res;
	char name[32];

	switch (index) {
	case __STDIN:
	strcpy(name, "stdin");
	res = fstat(0, &s);
	break;
	case __STDOUT:
	strcpy(name, "stdout");
	res = fstat(1, &s);
	break;
	default:
	name[0] = 'A' + index;
	name[1] = '\0';
	res = stat(name, &s);
	break;
	}

	if (res < 0) {
	fprintf(stderr, "warning: check_file %d: stat failure\n", index);
	return;
	}

	if (s.st_dev != dfile->stat->st_dev) {
	fprintf(stderr, "warning: check_file %s: dev mismatch: %d vs %d\n",
	name, (int) s.st_dev, (int) dfile->stat->st_dev);
	}
	/* if (s.st_ino != dfile->stat->st_ino) { */
	/* fprintf(stderr, "warning: check_file %s: ino mismatch: %d vs %d\n", */
	/* name, (int) s.st_ino, (int) dfile->stat->st_ino); */
	/* } */
	if (s.st_mode != dfile->stat->st_mode) {
	fprintf(stderr, "warning: check_file %s: mode mismatch: %#o vs %#o\n",
	name, s.st_mode, dfile->stat->st_mode);
	}
	if (s.st_nlink != dfile->stat->st_nlink) {
	fprintf(stderr, "warning: check_file %s: nlink mismatch: %d vs %d\n",
	name, (int) s.st_nlink, (int) dfile->stat->st_nlink);
	}
	if (s.st_uid != dfile->stat->st_uid) {
	fprintf(stderr, "warning: check_file %s: uid mismatch: %d vs %d\n",
	name, s.st_uid, dfile->stat->st_uid);
	}
	if (s.st_gid != dfile->stat->st_gid) {
	fprintf(stderr, "warning: check_file %s: gid mismatch: %d vs %d\n",
	name, s.st_gid, dfile->stat->st_gid);
	}
	if (s.st_rdev != dfile->stat->st_rdev) {
	fprintf(stderr, "warning: check_file %s: rdev mismatch: %d vs %d\n",
	name, (int) s.st_rdev, (int) dfile->stat->st_rdev);
	}
	if (s.st_size != dfile->stat->st_size) {
	fprintf(stderr, "warning: check_file %s: size mismatch: %d vs %d\n",
	name, (int) s.st_size, (int) dfile->stat->st_size);
	}
	if (s.st_blksize != dfile->stat->st_blksize) {
	fprintf(stderr, "warning: check_file %s: blksize mismatch: %d vs %d\n",
	name, (int) s.st_blksize, (int) dfile->stat->st_blksize);
	}
	if (s.st_blocks != dfile->stat->st_blocks) {
	fprintf(stderr, "warning: check_file %s: blocks mismatch: %d vs %d\n",
	name, (int) s.st_blocks, (int) dfile->stat->st_blocks);
	}
	/* if (s.st_atime != dfile->stat->st_atime) { */
	/* fprintf(stderr, "warning: check_file %s: atime mismatch: %d vs %d\n", */
	/* name, (int) s.st_atime, (int) dfile->stat->st_atime); */
	/* } */
	/* if (s.st_mtime != dfile->stat->st_mtime) { */
	/* fprintf(stderr, "warning: check_file %s: mtime mismatch: %d vs %d\n", */
	/* name, (int) s.st_mtime, (int) dfile->stat->st_mtime); */
	/* } */
	/* if (s.st_ctime != dfile->stat->st_ctime) { */
	/* fprintf(stderr, "warning: check_file %s: ctime mismatch: %d vs %d\n", */
	/* name, (int) s.st_ctime, (int) dfile->stat->st_ctime); */
	/* } */
	}