#define _BSD_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/queue.h>

#include "xtio.h"
#include "sysio.h"
#include "test_driver.h"

/*
 * ################################################
 * # Function stubs                               #
 * #  These allow all of the different commands   #
 * #  to be called with the same format           #
 * ################################################
 */

int test_do_setdebug(int argc, char **argv) 
{
  int level;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for setdebug\n",
		   argc));
    return INVALID_ARGS;
  }

  level = atoi(argv[0]);

  if (level < 0) {
    DBG(2, fprintf(outfp, "Invalid debug level %d\n", level));
    return INVALID_ARGS;
  }
  
  debug_level = level;
  return SUCCESS;
}

int test_do_printline(int argc, char **argv) 
{
  int on;

  
  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for printline\n",
		   argc));
    return INVALID_ARGS;
  }

  on = atoi(argv[0]);
  if (on)
    print_line = 1;
  else
    print_line = 0;

  return SUCCESS;
}

/*
int test_do_setoutput(int argc, char **argv)
{
  FILE *newfp;

  if (argc != 1) {
    fprintf(outfp, "Invalid number of args (%d) for setoutput\n",
	    argc);
    return -1;
  }

  newfp = fopen(argv[0], "w");
  if (!newfp) {
    fprintf(outfp, "Unable to open new output file %s\n", argv[0]);
    return -1;
  }

  outfp = newfp;

  return 0;
}

*/


int test_do_fillbuff(int argc, char **argv) 
{
  char *typestr, *buf;
  void *valptr;
  int size, type, index, offset;

  if (argc != 5) {
    DBG(2, 
	fprintf(outfp, 
		"fillbuff requires a value, a type, a size, an offset, and the target buffer\n"));
    fprintf(stderr, "fillbuff requires 5 args, you gave %d\n", argc);
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Do not understand offset %s\n", argv[3]));
    return INVALID_VAR;
  }

  index = get_obj(argv[4]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Can't find buffer at %s\n", argv[4]));
    return INVALID_VAR;
  }
  buf = (char *)(buflist[index]->buf)+offset;

  DBG(4, fprintf(outfp, "Buffer start is at %p\n", (void *)buflist[index]));

  typestr = argv[1];
  size = get_obj(argv[2]);
  if (size < 0) {
    DBG(2, fprintf(outfp, "Unable to understand size %s\n", argv[2]));
    return INVALID_VAR;
  }
  
  if ( (!strcmp(typestr, "UINT")) || (!strcmp(typestr, "SINT")) ){
    int val = get_obj(argv[0]);
    valptr = &val;
    type = UINT;
    if (val < 0) { /* FIX THIS */
      DBG(2, fprintf(outfp, "Can't understand value %s\n", argv[0]));
      return INVALID_VAR;
    }
    DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %x\n",
		   size, buf, *((int *)valptr)));
    memcpy(buf, valptr, size);
         
  } else if (!strcmp(typestr,"STR")) {
    type = STR;
    valptr = argv[0];
    DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %s\n",
		   size, buf, (char *)valptr));
    memcpy(buf, valptr, size);
  } else if (!strcmp(typestr, "PTR")) {
    unsigned long val;
    int index = get_obj(argv[0]);
    if (index < 0) {
      DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[0]));
      return INVALID_VAR;
    }
    
    val = (unsigned long)buflist[index]->buf;
    valptr = &val;
    DBG(4, fprintf(outfp, "Copying %d bytes from %p. Val is %p\n",
		   size, buf, valptr));
    memcpy(buf, valptr, size);
  } else {
    DBG(2, fprintf(outfp, "Unknown type %s.  Valid types are UINT, STR, and PTR\n", 
		   typestr));
    fprintf(stderr, "Unknown type %s.  Valid types are UINT, STR, and PTR\n", 
		   typestr);
    return INVALID_ARGS;
  }
 
  return SUCCESS;
}
    

#define STR_TYPE       1
#define INT_TYPE       2
#define SHORT_TYPE     3
#define CHAR_TYPE      4
#define LONG_TYPE      5

void print_partial(char *buf, int offset, int len, int type)
{
  int i;

  if (type == STR_TYPE) {
    sprintf(output, "%s%s", output, (char *)(buf+offset));
    DBG(4, fprintf(outfp, "Printing str %s\n", (char *)(buf+offset)));
  } else {
    if (type == SHORT_TYPE) {
      for (i = 0; i < len; i+= 2) {
	short *ibuf = (short *)(buf + offset + i);
	sprintf(output, "%s%#04x ", output, *ibuf);
	DBG(4, fprintf(outfp, "Printing short %#04x\n", *ibuf));
      }
    } else if (type == CHAR_TYPE) {
      for (i = 0; i < len; i++) {
	short *ibuf = (short *)(buf+offset+i);
	sprintf(output, "%s%#02x ", output, (*ibuf & 0x00ff));
	DBG(4, fprintf(outfp, "Printing char %c\n", (*ibuf & 0x00ff)));
      }
    } else if (type == INT_TYPE) {
      for (i = 0; i < len; i+= 4) {
	int *ibuf = (int *)(buf + offset + i);
	sprintf(output, "%s%#08x ", output, *ibuf);
	DBG(4, fprintf(outfp, "Printing int %#08x\n", *ibuf));
      }
    } else {
      for (i = 0; i < len; i += 8) {
	unsigned long *lbuf = (unsigned long *)(buf + offset +i);
	sprintf(output, "%s%#08lx ", output, *lbuf);
	DBG(4, fprintf(outfp, "Printing int %#016lx\n", *lbuf));
      }
    } 
  }
}
      
int test_do_printbuf(int argc, char **argv)
{
  int index, i, type, offset, len;
  struct buf_t *buf_st;
  void *buf;
  char *typestr;
  struct var_mapping *mobj;

  if (argv[0][0] == '$') {
    if (argv[0][1] == '$') {
      sprintf(output, "\n%#010x", (unsigned int)last_ret_val);
      return SUCCESS;
    } else if (!strcmp("errno", &argv[0][1])) {
      sprintf(output, "\n%#010x", my_errno);
      return SUCCESS;
    }
  }

  mobj = get_map(argv[0]);
  if (mobj == NULL) {
    DBG(2, fprintf(outfp, "Can't get var at %s\n", argv[0]));
    return INVALID_VAR;
  }

  if (mobj->type == UINT)
    sprintf(output, "\n%#010x", mobj->obj);
  else if (mobj->type == SINT)
    sprintf(output, "%d", mobj->obj);
  else if ((mobj->type == STR) || (mobj->type == PTR)) {
    index = mobj->obj;

    buf_st = buflist[index];
    DBG(2, fprintf(outfp, "buf_st is %p:\n", (void *)buf_st));
    buf = buf_st->buf;
    DBG(2, fprintf(outfp, "buf %s:\n", argv[0]));
    if (mobj->type == STR) {
      sprintf(output, "\n%s", (char *)buf);
     } else {
       sprintf(output,"%s\n", output);
       DBG(2, fprintf(outfp, "buf_st->len is %d, buf is %p\n", buf_st->len, buf));
       if (argc == 1) {
	 for (i = 0; i < buf_st->len/4; i++) 
	   DBG(2, fprintf(outfp, "%#x ", ((int *)buf)[i]));
	   sprintf(output, "%s%#x ", output, ((int *)buf)[i]);
	 
       }

       for (i = 1; i < argc; i++) {
	 offset = get_obj(argv[i++]);
	 len = get_obj(argv[i++]);
	 if ((offset < 0) || (len < 0)) {
	   DBG(2, fprintf(outfp, "Invalid offset (%s) or len (%s)\n",
			  argv[i-2], argv[i-1]));
	   return INVALID_VAR;
	 }
	 typestr = argv[i];
	 if (!strcmp("STR", typestr))
	   type = STR_TYPE;
	 else if (!strcmp("INT", typestr))
	   type = INT_TYPE;
	 else if (!strcmp("SHORT", typestr))
	   type = SHORT_TYPE;
	 else if (!strcmp("CHAR", typestr))
	   type = CHAR_TYPE;
	 else if (!strcmp("LONG", typestr))
	   type = LONG_TYPE;
	 else {
	   DBG(2, fprintf(outfp, "Unable to understand type %s\n",
			  typestr));
	   return INVALID_ARGS;
	 }
	 print_partial(buf, offset, len, type);
       }
     }
  }
  DBG(3, fprintf(outfp, "output: %s \n", output));
  return SUCCESS;
}

int test_do_mount(int argc, char **argv) 
{
  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for test_do_mount\n",
		   argc));
    return INVALID_ARGS;
  }

  DBG(4, fprintf(outfp, "Calling mount with from %s and to %s\n",
		 argv[0], argv[1]));
  last_ret_val = sysio_mount(argv[0], argv[1]);
  my_errno = errno;
  last_type = SINT;
  return SUCCESS;
}

int test_do_clear(int argc, char **argv) 
{
  int index;
  struct buf_t *buf;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for clear\n",
		   argc));
    return INVALID_ARGS;
  }
  index = get_obj(argv[0]);
  if (index < 0) {
    fprintf(outfp, "Unable to locate buffer %s\n",
	   argv[0]);
    return -1;
  }
  buf = buflist[index];
  bzero(buf->buf, buf->len);

  return SUCCESS;
}

int test_do_list(int argc, char **argv) 
{
  char *buf;

  if ((argc) && (argc != 1)) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for list\n",
		   argc));
    return INVALID_ARGS;
  }

  DBG(5,fprintf(outfp, "In test_do_list with args %p\n", (void *)argv));
  if (!argv) {
    buf = getcwd(NULL, 0);
    DBG(4, fprintf(outfp, "Calling list with dir of %s\n", buf));
    last_ret_val =  sysio_list(buf);
    my_errno = errno;
    free(buf);
    return SUCCESS;
  } 
    
  last_type = SINT;
  return sysio_list(*argv);
}

/*
 * Initlizes sysio library.  Will use default initlization
 * unless arguments are given
 */
int test_do_init(int argc, char **argv) 
{
  if (argc > 0) {
    char *rdriver;
    char *mpath;
    int mflags, rsize, msize;
    if (argc != 3) {
      DBG(2, fprintf(outfp, "Invalid number of args (%d) for init\n",
		     argc));
      return INVALID_ARGS;
    } 

    rdriver = get_str(argv[0]);
    rsize = strlen(rdriver)+1;
    if (rsize > 75) {
      DBG(2, fprintf(outfp, "%s too long for root driver\n", rdriver));
      return INVALID_ARGS;
    }
    bzero(root_driver, 75);
    memcpy(root_driver, rdriver, rsize);
    
    mpath = get_str(argv[1]);
    msize = strlen(mpath)+1;
    if (msize > 250) {
      DBG(2, fprintf(outfp, "%s too long for mount path\n", mpath));
      return INVALID_ARGS;
    }
    bzero(mntpath, 250);
    memcpy(mntpath, mpath, msize);
    
    mflags = get_obj(argv[2]);
    if (mflags == -1) {
      DBG(2, fprintf(outfp, "Invalid flags argument %s\n", argv[2]));
      return INVALID_ARGS;
    } 
  }
  
  DBG(5, fprintf(outfp, "In test_do_init\n"));
  last_type = SINT;
  DBG(3, fprintf(outfp, "initializing\n"));
  return initilize_sysio();
}


/*
 * Returns 1 if the machine is big-endian, 0
 * otherwise
 */
int get_endian(int argc, char **argv) 
{
  int x = 1;
  
  if ((argc) || (argv)) {
    DBG(2, fprintf(outfp, "Expected no args for test_do_endian\n"));
    return INVALID_ARGS;
  }

  if(*(char *)&x == 1) {
    /* little-endian, return 0 */
    last_ret_val= 0;
  } else {
    /* big endian, return 1 */
    last_ret_val= 1;
  }
  last_type = UINT;
  return SUCCESS;
}

int do_setbuf(int argc, char **argv)
{
	int val, size, index, offset;
	void *buf;

	if (argc != 4) {
		DBG(2, fprintf(outfp, "Need val, size, buffer, and offset for setbuf\n"));
		return INVALID_ARGS;
	}
	val = get_obj(argv[0]);
	if (val < 0) {
		DBG(2, fprintf(outfp, "Unable to understand val of %s\n",
									 argv[0]));
		return INVALID_VAR;
	}

	size = get_obj(argv[1]);
	if( size <=0 ) {
		DBG(2, fprintf(outfp, "Size of %s is invalid\n", argv[1]));
		return INVALID_VAR;
	}

  index = get_obj(argv[2]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[2]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

	offset = get_obj(argv[3]);
	
	if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[3]));
    return INVALID_ARGS;
  }
	
	buf = (void *)((char *)buf +offset);

	memset(buf, val, size);

	return SUCCESS;
}

				
int get_sizeof(int argc, char **argv) 
{
  char *type;
  int size;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for sizeof\n",
		   argc));
    return INVALID_ARGS;
  }

  type = argv[0];

  if (!strcmp(type, "char")) 
    size =  sizeof(char);
  else if (!strcmp(type, "int"))
    size =  sizeof(int);
  else if (!strcmp(type, "long"))
    size =  sizeof(long);
  else if (!strcmp(type, "flock"))
    size =  sizeof(struct flock);
  else if (!strcmp(type, "stat"))
    size =  sizeof(struct stat);
  else if (!strcmp(type, "statvfs"))
    size =  sizeof(struct statvfs);
  else if (!strcmp(type, "iovec"))
    size =  sizeof(struct iovec);
 else if (!strcmp(type, "xtvec"))
    size =  sizeof(struct xtvec);
  else
    return INVALID_ARGS;

  DBG(2, fprintf(outfp, "Size is %d\n", size));

  last_type = UINT;
  last_ret_val = size;
  return SUCCESS;
}

int test_do_exit(int argc, char **argv) 
{
  int val = 0;

  if (argc) {
    /* 
     * If argc is given, need to return the value of
     * the passed in variable 
     */
    val = get_obj(argv[0]);
  }
    
  /*
   * Clean up.
   */
  _sysio_shutdown();

  if (argc)
    DBG(3, printf("Exiting with %d from %s\n", val, argv[0]));

  exit(val);

  return 0;
}

int get_buffer(int argc, char **argv) 
{
  int size, align;
  struct buf_t *buf;

  if (argc == 1) /* Just put size, not alignment */
    align = 16;
  else if (argc == 2)
    align = get_obj(argv[1]);
  else {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for alloc\n",
		   argc));
    return INVALID_ARGS;
  }
    
  size = get_obj(argv[0]);
  if (size < 0) {
    DBG(2, fprintf(outfp, "Invalid size %s\n", argv[0]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "Getting buffer of size %d and aligned at %d\n",
		 size, align));
  buf = (struct buf_t *)malloc(sizeof(struct buf_t));
  buf->buf = alloc_buff32(size, align);
  buf->len = size;
  buflist[next] = buf;
  DBG(3, fprintf(outfp, "Your buffer (%p) (%p) is at index %d\n",
		 (void *)buf, buf->buf, next));
  next++;

  last_type = PTR;
  last_ret_val = next-1;
  return SUCCESS;
}

int free_buffer(int argc, char **argv) 
{
  int index;
  char *name = argv[0];
  
  if (argc != 1) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for free\n",
		   argc));
    return INVALID_ARGS;
  }

  /* 
   * Assume that there is one arg and it 
   * is a variable name which maps to an
   * index into the buffer array 
   */  
   index = get_obj(name);
   if (index < 0) {
     DBG(2, fprintf(outfp, "Can't find buffer %s\n",
		    name));
     return INVALID_VAR;
   }
   DBG(4, fprintf(outfp, "Freeing buffer at index %d\n", index));
   free(buflist[index]);

   free_obj(name);
   return SUCCESS;
}

int cmp_bufs(int argc, char **argv) 
{
  int res, index1, index2;
  char *buf1, *buf2;

  if (argc != 2) {
    fprintf(outfp, "Need two buffers to compare\n");
    return INVALID_ARGS;
  } 

  index1 = get_obj(argv[0]);
  if (index1 < 0) {
    fprintf(outfp, "Unable to locate buffer %s\n",
	   argv[0]);
    return INVALID_VAR;
  }
  buf1 = buflist[index1]->buf;

  index2 = get_obj(argv[1]);
  if (index2 < 0) {
    fprintf(outfp, "Unable to locate buffer %s\n",
	   argv[1]);
    return INVALID_VAR;
  }

  buf2 = buflist[index2]->buf;
  last_ret_val = strcmp(buf1, buf2);

  DBG(3, fprintf(outfp, "strcmp returned %d\n", res));
  return SUCCESS;
}

int test_do_chdir(int argc, char **argv) 
{
  if (argc != 1) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for chdir\n",
		   argc));
    return INVALID_ARGS;
  }
  last_type = SINT;
  return sysio_chdir(argv[0]);
}


int test_do_chmod(int argc, char **argv) 
{
  if (argc != 2) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for chmod\n",
		   argc));
    return INVALID_ARGS;
  }
  last_type = SINT;
  return sysio_chmod(argv[0], argv[1]);
}

int test_do_chown(int argc, char **argv) 
{
  if (argc != 2) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for chown\n",
		   argc));
    return INVALID_ARGS;
  }
  last_type = SINT;
  return sysio_chown(argv[0], argv[1]);
}

int test_do_open(int argc, char **argv) 
{ 
  char *name = argv[0];
  int flags = O_RDWR;

  if (argc > 1) 
    flags = get_obj(argv[1]);

  if (name[0] == '$') {
    int index = get_obj(name);

    if (index < 0) {
      DBG(2, fprintf(outfp, "Unable to find buffer at %s\n",
		     name));
      return INVALID_VAR;
    }

    name = buflist[index]->buf;
  }

  DBG(4,  fprintf(outfp, "Opening file %s with flags %d\n", name, flags));
  if (argc == 2)
    return sysio_open(name, flags);
  else if (argc == 3)
    return sysio_open3(name, flags, argv[2]);
  else {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d)\n", argc));
    return INVALID_ARGS;
  }
  last_type = UINT;
  return SUCCESS;
}

int test_do_close(int argc, char **argv) 
{
  int fd;
  char *name = argv[0];

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for close\n",
		   argc));
    return INVALID_ARGS;
  }

  /* 
   * Assume that there is one arg and it 
   * is a variable name which maps to a file
   * descriptor 
   */
  fd = get_obj(name);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to map var %s to anything\n", name));
    return INVALID_VAR;
  }
  sysio_close(fd);
  free_obj(name);
  return SUCCESS;
}

int test_do_dup(int argc, char **argv) 
{
  int fd;
  char *var_name = argv[0];

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for dup\n",
		   argc));
    return INVALID_ARGS;
  }


  fd = get_obj(var_name);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name));
    return INVALID_VAR;
  }

  last_ret_val = dup(fd);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_dup2(int argc, char **argv) 
{
  int fd1, fd2;
  char *var_name1 = argv[0];
  char *var_name2 = argv[1];

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Number of args (%d) invalid for dup2\n",
		   argc));
    return INVALID_ARGS;
  }

  fd1 = get_obj(var_name1);
  if (fd1 < 0) {
    DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name1));
    return INVALID_VAR;
  }

  fd2 = get_obj(var_name2);
  if (fd2 < 0) {
    DBG(2, fprintf(outfp, "Unable to map var %s to any file\n", var_name2));
    return INVALID_VAR;
  }

  last_ret_val = dup2(fd1, fd2);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

struct cmd_map fcntl_cmds[] = {
  { "F_DUPFD", F_DUPFD, 3 },
  { "F_GETFD", F_GETFD, 2 },
  { "F_SETFD", F_SETFD, 3 },
  { "F_GETFL", F_GETFL, 2 },
  { "F_SETFL", F_SETFL, 3 },
  { "F_SETLK", F_SETLK, 3 },
  { "F_SETLKW", F_SETLKW, 3 },
  { "F_GETLK", F_GETLK, 3 },
#if defined __USE_BSD || defined __USE_XOPEN2K
  { "F_GETOWN", F_GETOWN, 2 },
  { "F_SETOWN", F_SETOWN, 3 },
#endif
#ifdef __USE_GNU
  { "F_GETSIG", F_GETSIG, 2 },
  { "F_SETSIG", F_SETSIG, 3 },
  { "F_SETLEASE", F_SETLEASE, 3},
  { "F_GETLEASE", F_GETLEASE, 2},
  { "F_NOTIFY", F_NOTIFY, 3} ,
#endif
  { NULL, -1, 0 }
};

struct cmd_map* get_cmd(char *cmd_name, int argc)
{
  int i =0;

  while (fcntl_cmds[i].cmd_name) {
    if (!strcmp(fcntl_cmds[i].cmd_name, cmd_name)) {
      if (fcntl_cmds[i].num_args == argc)
	return &fcntl_cmds[i];
      else
	return NULL;
    }
    i++;
  }
  return NULL;
}

int test_do_fcntl(int argc, char **argv)
{
  
  struct cmd_map *cmd;
  int fd;

  /* 
   * get_cmd translates a symbolic command into
   * into its numerical equivalent. It also
   * verifies that the number of args is the
   * correct number for the command. It returns
   * NULL on failure
   */
  cmd = get_cmd(argv[1], argc);
  if (!cmd) {
    DBG(2, fprintf(outfp, "Unable to get command %s\n", argv[1]));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to map %s to file descriptor \n", argv[0]));
    return INVALID_VAR;
  }

  if (argc > 2)
    last_ret_val =  sysio_fcntl(fd, cmd, argv[2]);
  else
    last_ret_val = sysio_fcntl(fd, cmd, NULL);
  DBG(4, fprintf(outfp, "Got return value of %d\n", (int)last_ret_val));
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_fstat(int argc, char **argv)
{
  int fd, index;
  void *buf;

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) for fstat\n",
		   argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }
  
  buf = buflist[index]->buf;
  
  last_ret_val = sysio_fstat(fd, buf);
  my_errno = errno;
  last_type = SINT;
  
  return SUCCESS;
}

int test_do_lstat(int argc, char **argv)
{
  char *name = argv[0];
  int index;
  void *buf;

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) for lstat\n",
		   argc));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }
  
  buf = buflist[index]->buf;
  last_type = SINT;  

  return sysio_lstat(name, buf);
}

int test_do_fsync(int argc, char **argv)
{
  int fd;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to fsync\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  last_ret_val = fsync(fd);
  my_errno = errno;
  last_type = SINT;  

  return SUCCESS;
}


int test_do_fdatasync(int argc, char **argv)
{
  int fd;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to fdatasync\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  last_ret_val = fdatasync(fd);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_ftruncate(int argc, char **argv)
{
  int fd;
  off_t length;

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ftruncate\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  length = (off_t)get_obj(argv[1]);

  DBG(3, fprintf(outfp, "Setting file %d to %d\n", fd, (int) length));

  last_ret_val = ftruncate(fd, length);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_getcwd(int argc, char **argv)
{
  char *buf;
  int size, index;

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to getcwd\n", argc));
    return INVALID_ARGS;
  }

  index = get_obj(argv[0]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  size = get_obj(argv[1]);

  DBG(4, fprintf(outfp, "Getting cwd with buffer size of %d\n", size));

  last_ret_val = 0;
  if (!getcwd(buf, size)) {
      last_ret_val = -1;
      if (errno == ERANGE) {
	  DBG(2, fprintf(outfp, "Need a bigger buffer!\n"));
      }
  }
 
  my_errno = errno;

  
  DBG(3, fprintf(outfp, "cwd: %s\n", buf));
  last_type = SINT;

  return SUCCESS;
}

int test_do_lseek(int argc, char **argv)
{
  int fd, whence;
  off_t offset;

  
  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to lseek\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  offset = (off_t)get_obj(argv[1]);
  whence = get_obj(argv[2]);

  if (whence < 0 ) {
    DBG(2, fprintf(outfp, "Not familiar with whence of %s\n",
		   argv[2]));
    return INVALID_ARGS;
  }

  last_ret_val = lseek(fd, offset, whence);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_getdirentries(int argc, char **argv) 
{
  int fd, nbytes;
  int bufindex;
  off_t basep;
  char *buf;
  struct var_mapping *base_map;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to getdirentries\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }

  bufindex = get_obj(argv[1]);
   
  if (bufindex < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[bufindex]->buf;

  nbytes = get_obj(argv[2]);

  if (nbytes < 0) {
    DBG(2, fprintf(outfp, "I don't understand %s\n",
		   argv[2]));
    return INVALID_ARGS;
  }

  base_map = get_map(argv[3]);
  if (!base_map) {
    DBG(3, fprintf(outfp, "Resetting basep\n"));
    /* 
     * Assume that this is the first getdirentries call
     * and we need to setup the base pointer
     */
    basep = 0;
  } else 
    basep = base_map->obj;
      
  DBG(3, fprintf(outfp, "basep is (starting) %d\n", (int) basep));
  last_ret_val = sysio_getdirentries(fd, buf, nbytes, &basep);
  if (base_map)
    base_map->obj = basep;
  else
    store_result(argv[3]+1, basep);
  DBG(3, fprintf(outfp, "basep is (ending) %d\n", (int) basep));
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_mkdir(int argc, char **argv)
{
  if (argc !=2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to mkdir\n", argc));
    return INVALID_ARGS;
  }

  last_type = SINT;
  return sysio_mkdir(argv[0], argv[1]);
}

int test_do_creat(int argc, char **argv)
{
  if (argc !=2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to creat\n", argc));
    return INVALID_ARGS;
  }

  last_type = UINT;
  return sysio_creat(argv[0], argv[1]);
}

int test_do_stat(int argc, char **argv)
{
  int index;
  void *buf;
  char *str;

  if (argc != 2) {
    fprintf(outfp, "Invalid number of arguments (%d) for stat\n",
	   argc);
    return -1;
  }


  index = get_obj(argv[1]);
  if (index < 0) {
    fprintf(outfp, "Unable to find buffer assocated with %s\n",
	   argv[1]);
  }
  
  buf = buflist[index]->buf;
  last_type = SINT;
  
  str = get_str(argv[0]);
  return sysio_stat(str, buf);
}

int test_do_statvfs(int argc, char **argv)
{
  int index;
  void *buf;

  if (argc != 2) {
    fprintf(outfp, "Invalid number of arguments (%d) for statvfs\n",
	   argc);
    return -1;
  }


  index = get_obj(argv[1]);
  if (index < 0) {
    fprintf(outfp, "Unable to find buffer assocated with %s\n",
	   argv[1]);
  }
  
  buf = buflist[index]->buf;
  last_type = SINT;
  
  return sysio_statvfs(argv[0], buf);
}

int test_do_fstatvfs(int argc, char **argv)
{
  int index, fd;
  void *buf;

  if (argc != 2) {
    fprintf(outfp, "Invalid number of arguments (%d) for fstatvfs\n",
	   argc);
    return -1;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    fprintf(outfp, "Unable to find file assocated with %s\n",
	   argv[0]);
  }


  index = get_obj(argv[1]);
  if (index < 0) {
    fprintf(outfp, "Unable to find buffer assocated with %s\n",
	   argv[1]);
  }
  
  buf = buflist[index]->buf;
  last_type = SINT;
  
  return sysio_fstatvfs(fd, buf);
}

int test_do_truncate(int argc, char **argv)
{
  off_t length;

  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to truncate\n", argc));
    return INVALID_ARGS;
  }
  
  length = (off_t)get_obj(argv[1]);

  DBG(3, fprintf(outfp, "Setting file %s to %d\n", argv[0], (int) length));

  last_ret_val = truncate(argv[0], length);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_rmdir(int argc, char **argv)
{

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to rmdir\n", argc));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "Removing dir %s\n", argv[0]));

  last_ret_val = rmdir(argv[0]);
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_symlink(int argc, char **argv)
{
  if (argc != 2) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to symlink\n", argc));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "Linking %s to %s\n", argv[0], argv[1]));

  last_ret_val = symlink(argv[0], argv[1]);
  if (last_ret_val) {
    if (errno < 0) 
      errno = errno*-1;
    my_perror("symlink");
  } 
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


struct cmd_map ioctl_cmds[] = {
#if 0
  { "BLKROSET", BLKROSET, 3 },
  { "BLKROGET", BLKROGET, 3 },
  { "BLKRRPART", BLKRRPART, 3 },
  { "BLKGETSIZE", BLKGETSIZE, 3 },
  { "BLKRASET", BLKRASET, 3 },
  { "BLKRAGET", BLKRAGET, 3 },
  { "BLKSECTSET", BLKSECTSET, 3 },
  { "BLKSECTGET", BLKSECTGET, 3 },
  { "BLKSSZGET", BLKSSZGET, 3 },
  { "BLKGETLASTSECT", BLKGETLASTSECT, 3 },
  { "BLKSETLASTSECT", BLKSETLASTSECT, 3 },
  { "BLKBSZGET", BLKBSZGET, 3 },
  { "BLKBSZSET", BLKBSZSET, 3 },
  { "FIBMAP", FIBMAP, 3 },
  { "FIGETBSZ", FIGETBSZ, 3},
#endif
  { NULL, -1, 0 }
};

int get_ioctl_cmd(char *cmd) 
{
  int i = 0;

  while (ioctl_cmds[i].cmd_name != NULL) {
    if (strcmp(ioctl_cmds[i].cmd_name, cmd))
      i++;
    else
      return ioctl_cmds[i].cmd;
  }

  return -1;
}

int test_do_ioctl(int argc, char **argv)
{
  int fd, cmd;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ioctl\n", argc));
    return INVALID_ARGS;
  }


  fd = get_obj(argv[0]);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file %s\n", argv[0]));
    return INVALID_VAR;
  }

  cmd = get_ioctl_cmd(argv[1]);
  if (cmd == -1) {
    DBG(2, fprintf(outfp, "Do not understand command %s\n", argv[1]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "Executing command %s\n", argv[1]));

  last_ret_val = ioctl(fd, cmd, argv[2]);
  my_errno = errno;
  if (last_ret_val) 
    my_perror("ioctl");
  last_type = SINT;

  return SUCCESS;
}

int test_do_unlink(int argc, char **argv)
{
  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to unlink\n", argc));
    return INVALID_ARGS;
  }

  DBG(4, fprintf(outfp, "Unlinking %s\n", argv[0]));

  last_ret_val = unlink(argv[0]);
  my_errno = errno;
  if (last_ret_val) 
    my_perror("unlink");
  last_type = SINT;

  return SUCCESS;
}

int test_do_umask(int argc, char **argv)
{
  mode_t old_mask;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Incorrect number of args (%d) for umask\n", argc));
    return INVALID_ARGS;
  }

  last_ret_val = old_mask = sysio_umask(argv[0]);
  my_errno = errno;
  DBG(3, fprintf(outfp, "Previous umask was %o\n", old_mask));
  last_type = UINT;
  
  return SUCCESS;
}

int test_do_iowait(int argc, char **argv)
{
  long err;
  ioid_t ioid;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Incorrect amount of args (%d) for iowait\n", argc));
    return INVALID_ARGS;
  }

  err = get_obj(argv[0]);
  if (err < 0) {
    DBG(2, fprintf(outfp, "Cannot find ioid at %s\n", argv[0]));
    return INVALID_VAR;
  }
  
  ioid = (ioid_t)err;

  last_ret_val =  iowait(ioid);
  my_errno = errno;
  if (last_ret_val < 0) {
    my_perror("iowait");
  }
  last_type = SINT;

  return SUCCESS;
}

int test_do_iodone(int argc, char **argv)
{
  long err;
  ioid_t ioid;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Incorrect amount of args (%d) for iodone\n", argc));
    return INVALID_ARGS;
  }

  err = get_obj(argv[0]);
  if (err < 0) {
    DBG(2, fprintf(outfp, "Cannot find ioid at %s\n", argv[0]));
    return INVALID_VAR;
  }
  ioid = (ioid_t)err;

  last_ret_val =  iowait(ioid);
  if (last_ret_val < 0) {
    my_perror("iodone");
  }
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;

}

int test_do_ipread(int argc, char **argv) 
{
  int fd, index, count, offset;
  char *buf;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipread\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file at %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Do not understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset of %s\n", argv[3]));
    return INVALID_ARGS;
  }

  last_ret_val = (long)ipread(fd, buf, count, offset);
  if (last_ret_val < 0) {
    my_perror("ipread");
  }
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_iread(int argc, char **argv) 
{
  int fd, index, count;
  char *buf;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iread\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);
  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file at %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer at %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Do not understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  last_ret_val = (long) iread(fd, buf, count);
  if (last_ret_val < 0) {
    my_perror("iread");
  }
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_ipreadv(int argc, char **argv)
{
  int fd, count, index;
  off_t offset;
  char *buf;
  struct iovec *iov;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipreadv\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  count = get_obj(argv[2]);

  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset value %s\n", argv[3]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "ipreadv(fd: %d vector:{iov_base: %p iov_len %d} count: %d offset: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count, (int) offset)); 

  last_ret_val = (long) ipreadv(fd, iov, count, offset);
  if (last_ret_val < 0)
    my_perror("ipreadv");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_preadv(int argc, char **argv)
{
  int fd, count, index;
  off_t offset;
  char *buf;
  struct iovec *iov;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to preadv\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  count = get_obj(argv[2]);

  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset value %s\n", argv[3]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "preadv(fd: %d vector:{iov_base: %p iov_len %d} count: %d offset: %d\n",
		 fd, iov->iov_base, (int) iov->iov_len, count, (int) offset)); 

  last_ret_val = preadv(fd, iov, count, offset);
  my_errno = errno;
  if (last_ret_val < 0)
    my_perror("preadv");
  last_type = SINT;

  return SUCCESS;
}


int test_do_pread(int argc, char **argv)
{
  int fd, count, index, numbytes, offset;
  char *buf;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pread\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }
  
  index = get_obj(argv[1]);
    
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count of %s\n", argv[1]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset of %s\n", argv[2]));
    return INVALID_ARGS;
  }


  last_ret_val = numbytes = (int) pread(fd, buf, count, offset);
  my_errno = errno;
  DBG(4, fprintf(outfp, "Read %d bytes out of %d starting at offset %x\n", 
		 numbytes, count, offset));
  DBG(3, fprintf(outfp, "Got %s\n", buf));
  last_type = SINT;

  return SUCCESS;
}


int test_do_ireadv(int argc, char **argv)
{
  int fd, count, index;
  char *buf;
  struct iovec *iov;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ireadv\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  count = get_obj(argv[2]);

  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "ireadv (fd: %d, vector:{ iov_base: %p iov_len %d }, count: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count)); 

  last_ret_val = (long) ireadv(fd, iov, count);
  if (last_ret_val < 0)
    my_perror("ireadv");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_readv(int argc, char **argv)
{
  int fd, count, index;
  char *buf;
  struct iovec *iov;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to readv\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  count = get_obj(argv[2]);

  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "ireadv (fd: %d, vector:{ iov_base: %p iov_len %d }, count: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count)); 

  last_ret_val = readv(fd, iov, count);
  if (last_ret_val < 0)
    my_perror("readv");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_read(int argc, char **argv)
{
  int fd, count, index, numbytes=0;
  char *buf;

  if (argc < 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to read\n", argc));
    return INVALID_ARGS;
  }

  
  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file assocated with %s\n",
		   argv[0]));
    return INVALID_VAR;
  }
  
  index = get_obj(argv[1]);
  
  
  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer assocated with %s\n",
		   argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);

  if ( (argc == 4) && (!strcmp(argv[3], "delay")) ){
    int i;
    /* Wait a little while for input */
    for (i=0; i < count; i++) {
      sleep(0.005);
      numbytes += (int) read(fd, buf, 1);
      last_ret_val = numbytes;
      
    }
  } else {
    last_ret_val = numbytes = (int) read(fd, buf, count);
  }
  my_errno = errno;

  DBG(3, fprintf(outfp, "Read %d bytes out of %d\n", numbytes, count));
  DBG(3, fprintf(outfp, "Got %s\n", buf));
  last_type = SINT;

  return SUCCESS;
}

int test_do_ipwritev(int argc, char **argv)
{
  int fd, count, index, offset;
  char *buf;
  struct iovec *iov;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipwritev\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, 
		 "ipwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d, offset: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count, offset)); 

  last_ret_val = (long) ipwritev(fd, iov, count, offset);
  my_errno = errno;
  if (last_ret_val < 0)
    my_perror("ipwritev");
  last_type = SINT;

  return SUCCESS;
}

int test_do_ipwrite(int argc, char **argv)
{
  int fd, count, index, offset;
  char *buf;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ipwrite\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
    return INVALID_ARGS;
  }

  last_ret_val = (long) ipwrite(fd, buf, count, offset);
  if (last_ret_val < 0)
    my_perror("ipwrite");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_pwritev(int argc, char **argv)
{
  int fd, count, index, offset;
  char *buf;
  struct iovec *iov;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pwritev\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
    return INVALID_ARGS;
  }


  DBG(3, fprintf(outfp, 
		 "pwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d, offset: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count, offset)); 

  last_ret_val = (long) pwritev(fd, iov, count, offset);
  if (last_ret_val < 0)
    my_perror("ipwritev");
  my_errno = errno;
  last_type = SINT;
  
  return SUCCESS;
}

int test_do_pwrite(int argc, char **argv)
{
  int fd, count, index, offset;
  char *buf;

  if (argc != 4) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to pwrite\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  offset = get_obj(argv[3]);
  if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand offset %s\n", argv[3]));
    return INVALID_ARGS;
  }

  last_ret_val = pwrite(fd, buf, count, offset);
  my_errno = errno;
  if (last_ret_val < 0)
    my_perror("pwrite");
  last_type = SINT;

  return SUCCESS;
}


int test_do_iwritev(int argc, char **argv)
{
  int fd, count, index;
  char *buf;
  struct iovec *iov;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwritev\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "iwritev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count)); 

  last_ret_val = (long) iwritev(fd, iov, count);
  my_errno = errno;
  if (last_ret_val < 0)
    my_perror("iwritev");
  last_type = SINT;

  return SUCCESS;
}

int test_do_iwrite(int argc, char **argv)
{
  int fd, count, index;
  char *buf;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwrite\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  last_ret_val = (long) iwrite(fd, buf, count);
  my_errno = errno;
  if (last_ret_val < 0)
    my_perror("iwrite");
  last_type = SINT;

  return SUCCESS;
}


int test_do_write(int argc, char **argv)
{
  int fd, count, index, err;
  char *buf;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to write\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  count = get_obj(argv[2]);
  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand count %s\n", argv[2]));
    return INVALID_ARGS;
  }

  DBG(4, fprintf(outfp, "Writing out %d bytes (%s) using fd of %x\n",
		 count, buf, fd));
  err = write(fd, buf, count);
  if (err < 0)
    my_perror("write");

  last_ret_val = err;
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_writev(int argc, char **argv)
{
  int fd, count, index;
  char *buf;
  struct iovec *iov;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to writev\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  count = get_obj(argv[2]);

  if (count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "writev(fd: %d, vector: { iov_base: %p iov_len %d }, count: %d\n",
		 fd, iov->iov_base, (int)iov->iov_len, count)); 

  last_ret_val = writev(fd, iov, count);
  if (last_ret_val < 0)
    my_perror("writev");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}

int test_do_mknod(int argc, char **argv) 
{
  int dev;

  if (argc != 3) {
    DBG(2, fprintf(outfp, "Invalid number of args (%d) for mknod\n", argc));
    return INVALID_ARGS;
  }

  dev = get_obj(argv[2]);
  if (dev < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }
  last_type = SINT;

  
  return sysio_mknod(argv[0], argv[1], (dev_t) dev);
}

int test_do_umount(int argc, char **argv) 
{
  int err;

  if (argc != 1) {
    DBG(2, fprintf(outfp, "Invalid number (%d) of args for umount\n", argc));
    return INVALID_ARGS;
  }

  err = umount(argv[0]);
  if (err)
    my_perror("umount");

  my_errno = errno;
  last_ret_val = err;
  last_type = SINT;

  return SUCCESS;
}
 
int test_do_init_iovec(int argc, char **argv)
{
	int iov_index, buf_index;
	int offset, len, pos;
	struct iovec *iov_ptr;
	char *base_ptr;

	if (argc != 5) {
		DBG(2, fprintf(outfp, "Need buffer, offset, len, array pos, and iov pointer\n"));
		return INVALID_ARGS;
	}

	if ((buf_index = get_obj(argv[0])) < 0) {
		DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[0]));
		return INVALID_VAR;
	}
	base_ptr = buflist[buf_index]->buf;

	if ((offset = get_obj(argv[1])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand offset of %s\n", argv[1]));
		return INVALID_VAR;
	}
	
	if ((len = get_obj(argv[2])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand len of %s\n", argv[2]));
		return INVALID_VAR;
	}
	
	if ((pos = get_obj(argv[3])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand array pos of %s\n", argv[3]));
		return INVALID_VAR;
	}

	if ((iov_index = get_obj(argv[4])) < 0) {
		DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[4]));
		return INVALID_VAR;
	}
	iov_ptr = (struct iovec *)(buflist[iov_index]->buf);	

	iov_ptr[pos].iov_len = len;
	iov_ptr[pos].iov_base = (void *)(base_ptr + offset);
	
	DBG(3, fprintf(outfp, "iov_ptr.len is %d and base is %p\n", 
		       (int)iov_ptr[pos].iov_len, iov_ptr[pos].iov_base));
   my_errno = errno;
  last_type = PTR;

	return SUCCESS;
}


int test_do_init_xtvec(int argc, char **argv)
{
	int xtv_index;
	int offset, len, pos;
	struct xtvec *xtv_ptr;

	if (argc != 4) {
		DBG(2, fprintf(outfp, "Need offset, len, array pos, and xtv pointer\n"));
		return INVALID_ARGS;
	}

	if ((offset = get_obj(argv[0])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand offset of %s\n", argv[0]));
		return INVALID_VAR;
	}
	
	if ((len = get_obj(argv[1])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand len of %s\n", argv[1]));
		return INVALID_VAR;
	}
	
	if ((pos = get_obj(argv[2])) < 0) {
		DBG(2, fprintf(outfp, "Cannot understand array pos of %s\n", argv[2]));
		return INVALID_VAR;
	}

	if ((xtv_index = get_obj(argv[3])) < 0) {
		DBG(2, fprintf(outfp, "Unable to find object %s\n", argv[3]));
		return INVALID_VAR;
	}
	xtv_ptr = (struct xtvec *)(buflist[xtv_index]->buf);	

	xtv_ptr[pos].xtv_len = len;
	xtv_ptr[pos].xtv_off = offset;
	
	DBG(3, fprintf(outfp, "xtv_ptr.len is %d and offset is %d\n", 
		       (int)xtv_ptr[pos].xtv_len, (int)xtv_ptr[pos].xtv_off));

	my_errno = errno;
  last_type = PTR;

	return SUCCESS;
}

int test_do_writex(int argc, char **argv)
{
  int fd, iov_count, xtv_count,index;
  char *buf;
  struct iovec *iov;
	struct xtvec *xtv;

  if (argc != 5) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to writex\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  iov_count = get_obj(argv[2]);

  if (iov_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[3]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  xtv = (struct xtvec *)buf;
  xtv_count = get_obj(argv[4]);

  if (xtv_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "writex(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
		 fd, (void *)iov, iov_count, (void *)xtv, xtv_count)); 

  last_ret_val = writex(fd, iov, iov_count, xtv, xtv_count);
  if (last_ret_val < 0)
    my_perror("writex");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_iwritex(int argc, char **argv)
{
  int fd, iov_count, xtv_count,index;
  char *buf;
  struct iovec *iov;
	struct xtvec *xtv;

  if (argc != 5) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to iwritex\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  iov_count = get_obj(argv[2]);

  if (iov_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[3]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  xtv = (struct xtvec *)buf;
  xtv_count = get_obj(argv[4]);

  if (xtv_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "iwritex(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
		 fd, (void *)iov, iov_count, (void *)xtv, xtv_count)); 

  last_ret_val = (long) iwritex(fd, iov, iov_count, xtv, xtv_count);
  if (last_ret_val < 0)
    my_perror("iwritex");
  my_errno = errno;
  last_type = SINT;

	return SUCCESS;
}


int test_do_readx(int argc, char **argv)
{
  int fd, iov_count, xtv_count,index;
  char *buf;
  struct iovec *iov;
	struct xtvec *xtv;

  if (argc != 5) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to readx\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  iov_count = get_obj(argv[2]);

  if (iov_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[3]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  xtv = (struct xtvec *)buf;
  xtv_count = get_obj(argv[4]);

  if (xtv_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "readx(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
		 fd, (void *)iov, iov_count, (void *)xtv, xtv_count)); 

  last_ret_val = readx(fd, iov, iov_count, xtv, xtv_count);
  if (last_ret_val < 0)
    my_perror("readx");
  my_errno = errno;
  last_type = SINT;

  return SUCCESS;
}


int test_do_ireadx(int argc, char **argv)
{
  int fd, iov_count, xtv_count,index;
  char *buf;
  struct iovec *iov;
	struct xtvec *xtv;

  if (argc != 5) {
    DBG(2, fprintf(outfp, "Invalid number of arguments (%d) to ireadx\n", argc));
    return INVALID_ARGS;
  }

  fd = get_obj(argv[0]);

  if (fd < 0) {
    DBG(2, fprintf(outfp, "Unable to find file described by %s\n", argv[0]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[1]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buffer described by %s\n", argv[1]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  iov = (struct iovec *)buf;
  iov_count = get_obj(argv[2]);

  if (iov_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

  index = get_obj(argv[3]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find xtvs described by %s\n", argv[3]));
    return INVALID_VAR;
  }

  buf = buflist[index]->buf;

  xtv = (struct xtvec *)buf;
  xtv_count = get_obj(argv[4]);

  if (xtv_count < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[4]));
    return INVALID_ARGS;
  }

  DBG(3, fprintf(outfp, "ireadx(fd: %d, iov: %p iov_cnt: %d, xtv: %p, xtv_cnt: %d\n",
		 fd, (void *)iov, iov_count, (void *)xtv, xtv_count)); 

  last_ret_val = (long) ireadx(fd, iov, iov_count, xtv, xtv_count);
  if (last_ret_val < 0)
    my_perror("ireadx");
  my_errno = errno;
  last_type = SINT;

	return SUCCESS;
}


int do_checkbuf(int argc, char **argv)
{
	 int size, val, index, i, offset;
	 int *ref_buf, *buf;
	
	if (argc != 4) {
		DBG(2, fprintf(outfp, "Need buffer, val, and offset for checkbuf\n"));
		return INVALID_ARGS;
	}

	index = get_obj(argv[0]);

  if (index < 0) {
    DBG(2, fprintf(outfp, "Unable to find buf described by %s\n", argv[0]));
    return INVALID_VAR;
  }

  buf = (int *)buflist[index]->buf;	


	size = get_obj(argv[1]);

	if (size < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[1]));
    return INVALID_ARGS;
  }

	val = get_obj(argv[2]);
	
  if (val < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[2]));
    return INVALID_ARGS;
  }

	
	offset = get_obj(argv[3]);
	
	if (offset < 0) {
    DBG(2, fprintf(outfp, "Unable to understand %s\n", argv[3]));
    return INVALID_ARGS;
  }
	

	ref_buf = (int *)malloc(size);
	memset((void *)ref_buf, val, size);

	last_ret_val =0;
	buf = (int *)((char *)buf + offset);
	for (i=0; (unsigned)i < size/sizeof(int); i++) {
		if (buf[i] != ref_buf[i]) {
			DBG(2, fprintf(stderr, "At pos %d I found a 0x%08x instead of 0x%08x\n",
										 i, buf[i], ref_buf[i]));
			fprintf(stderr, "At pos %d I found a 0x%08x instead of 0x%08x (val was %d)\n",
										 i, buf[i], ref_buf[i], val);
			last_ret_val = 1;
			break;
		}
	}

  my_errno = errno;
  last_type = SINT;

	return SUCCESS;
}