#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <dirent.h>

#include <netinet/in.h>
#include <arpa/inet.h>
#include <rpc/rpc.h>
#include <sys/types.h>
#include <sys/socket.h>

#include "nfsclient.h"
#include "myrpc/mount.h"
#include "myrpc/nfs_prot.h"


#define MAX_REQUEST_SIZE 		1000
#define MAX_SERVERNAME_SIZE		50
#define MAX_DIRNAME_SIZE		150
#define QUEUE_LENGTH 			10
#define NF						256		//  Number of files

#define NFS_MOUNT	1
#define NFS_OPEN	2
#define NFS_READ	3
#define NFS_CLOSE	4

#define TMD		TheMountedDirectory		//  For convenience
#define fsize	diropres_u.diropres.attributes.size

#define PRINTOUT	0

//  Guess what?  Since I moved the NFS functions into this file, EVERYTHING
//  is done with global variables. Woo hoo for global variables!


static diropargs * TheMountedDirectory;	//  This represents the mounted directory in
                                        //    the field "dir". "name" useful?
static diropres * diropres_table[NF];	//  We'll need a diropres{ults} for each one --
										//    that's the "fhandle" and the "fattr"
// static int file_offset_table[NF];	//  No longer used... I think
static int being_used_by[NF];			//  Number of clients using file
static int entry_is_valid[NF];			//  Whether the entries are still valid
static int file_is_cached[NF];			//  Whether the file is locally cached
static char * known_file_names[NF];		//  Names of cached files
static int last_used[NF];				//  Time the file was last used 

static int first_empty_slot = 0;		//  The address of the first empty slot
static char * server;					//  The server we mounted from
static char * TMDname;					//  The name of the mounted directory
static CLIENT * client;					//  The NFS RPC client (not the mounting client)

static char * cache_dir_name;			//  The name of the directory in which we cache
static int cache_size;					//  The size of the cache
static int amount_in_cache;				//  How many bytes are already in the cache

static int current_timestamp;			//  The current timestamp (used for LRU)

static int rpccalls;					//  For tracking server load
static int socketsends, socketrecvs;
static long socketsendbytes, socketrecvbytes, rpcbytes;

int main(int argc, char * argv[])
{
	int listening_socket, new_socket;	//  int = socket descriptor

	int returncode, addrlen;
	int * boot;

	int bindsize, i;

	struct sockaddr listening_address;	//  Local socket 
	struct sockaddr new_address;		//  For child process 
	
	char * syscallstring;
	char * tempfilename;
	FILE * tempfile;
	
	rpccalls = 0;
	socketsends = 0;
	socketrecvs = 0;
	socketsendbytes = 0;
	socketrecvbytes = 0;
	rpcbytes = 0;

	boot = (int *) malloc (100 * sizeof(int));
	
	server  = (char *) malloc (MAX_SERVERNAME_SIZE * sizeof(char));
	TMDname = (char *) malloc (MAX_DIRNAME_SIZE    * sizeof(char));
	// cache_dir_name = (char *) malloc (MAX_DIRNAME_SIZE    * sizeof(char));
	
	current_timestamp = 1;
	for (i=0; i<NF; i++)
	{
		// file_offset_table[i] = 0;
		being_used_by[i] = 0;
		entry_is_valid[i] = 0;
		file_is_cached[i] = 0;
		last_used[i] = 0;
		known_file_names[i] = (char *) malloc (MAX_DIRNAME_SIZE * sizeof(char));
		diropres_table[i] = NULL;
	}

  //  Get the name of our cache directory. 
  
	if (PRINTOUT) printf("NFSClient: Creating cache directory.\n");
  	if (argc < 2)
  	{
		if (PRINTOUT) printf("NFSClient: No cache directory given, using /tmp/nfscache/\n");
		cache_dir_name = "/tmp/nfscache";
  	}
  	else
  	{
 		if (PRINTOUT) printf("NFSClient: Cache directory is %s\n", argv[1]);
		cache_dir_name = argv[1];
  	}

  	if (argc < 3)
  	{
		if (PRINTOUT) printf("NFSClient: No cache size given, using 10,000 bytes\n");
		cache_size = 10000;
  	}
  	else
  	{
		cache_size = atoi(argv[2]);
 		if (PRINTOUT) printf("NFSClient: Cache size is %d\n", cache_size);
  	}
  
  //  See whether we can open the cache dir. If we can't, try to create it.
  
  	if ((DIR *)opendir(cache_dir_name) != NULL)
  	{
  		if (PRINTOUT) printf("NFSClient: Found directory %s\n", cache_dir_name);
  	}
  	else
  	{
  		if (PRINTOUT) printf("NFSClient: Creating directory %s\n", cache_dir_name);
  		
  		syscallstring = (char *) malloc ((strlen(cache_dir_name) + 12) 
  		                                 * sizeof(char));
  		strcpy(syscallstring, "mkdir -p ");
  		strcat(syscallstring, cache_dir_name);
  		
  		returncode = system(syscallstring);
  		
	 	if (returncode < 0)
		{
			if (PRINTOUT) printf("NFSClient: error %d trying to create directory\n", errno);
			perror("         ");
			exit(1);
		}
  	}
  		
	//  Ok, it's open. See whether we can write to it. 

	tempfilename = (char *) malloc ((strlen(cache_dir_name) + 6) * sizeof(char));
	strcpy(tempfilename, cache_dir_name);
	strcat(tempfilename, "/1");

	tempfile = fopen(tempfilename, "w");

	if (tempfile == NULL)
	{
  		if (PRINTOUT) printf("NFSClient: Couldn't write to a file in there. You'll ");
		if (PRINTOUT) printf("have to pick a different directory.\n");
		exit(0);
	}
	else
	{
		fclose(tempfile);
	}
  	

  //  The mounted directory, allocate it.

	TheMountedDirectory = (diropargs *) malloc (sizeof(diropargs));
	
  //  The client, allocate it.
  
  	client = (CLIENT *) malloc (sizeof(CLIENT));

  //    Create the local listening socket. 
  //    First, grab a socket descriptor. 	 

	listening_socket = socket(AF_UNIX, SOCK_STREAM, 0);

	if (listening_socket < 0)
	{
		if (PRINTOUT) printf("NFSClient: error %d creating local listening socket\n", errno);
		perror("         ");
		exit(1);
	}
	
  //    Fill the socket info... 

	listening_address.sa_family = AF_UNIX;
	strcpy(listening_address.sa_data, "/tmp/smNFS");

	bindsize = strlen(listening_address.sa_data) + sizeof(listening_address.sa_family);

  //    ...and try and bind it with the name. 
	
	remove("/tmp/smNFS");
	returncode = bind(listening_socket, &listening_address, bindsize);

	if (returncode < 0)
	{
		if (PRINTOUT) printf("NFSClient: error %d binding local listening socket\n", errno);
		perror("         ");
		exit(1);
	}
	else
	{
		if (PRINTOUT) printf("NFSClient: Opened socket with file descriptor %d\n", listening_socket);
	}
	
  //    Now listen on it... 
		
	returncode = listen(listening_socket, QUEUE_LENGTH);
	if (returncode < 0)
	{
		if (PRINTOUT) printf("NFSClient: error %d listening\n", errno);
		perror("         ");
		exit(1);
	}
	else
	{
		if (PRINTOUT) printf("NFSClient: Listening on socket %d\n", listening_socket);
	}
	
  //    Go into the infinite loop waiting for connections. 
  
	while (1)
	{
		new_socket = accept(listening_socket, 
			(struct sockaddr *) &new_address, boot);

		if (new_socket < 0)
		{
			if (PRINTOUT) printf("NFSClient: error %d accepting\n", errno);
			perror("         ");
			exit(1);
		}
		else
		{
			// if (PRINTOUT) printf("NFSClient: Connection accepted...\n");
		}
	
		//  We don't fork(), so that we have only a single process.
		//  We don't select(), either, though, as the assignment suggests.
		//  The reason for this?  I designed it so that every individual
		//  call in my NFS API opens exactly one socket, sends exactly
		//  one message, and expects exactly one in return. Thus, since I 
		//  only have a single process in my NFS client, it is not wasting
		//  any time by accepting a connection, reading a message, sending
		//  one back, and closing the connection. Using select() would
		//  accomplish nothing, because there are no other sockets besides
		//  the listening socket to listen on. 
	
		// if (PRINTOUT) printf("NFSClient: Handling connection\n");

		returncode = handle_connection(new_socket);
		if (returncode < 0)
		{
			if (PRINTOUT) printf("NFSClient: error handling connection (from API)\n", errno);
			exit(1);
		}
		// if (PRINTOUT) printf("NFSClient: Done handling connection.\n\n");
		
		//  I may add code here to check whether anything has come in on
		//  standard input, and use that as a reason to quit. Or I may not.
		
		// exit(0);

	}
	
  //  Clean up.  

	close(listening_socket);
	remove("/tmp/smNFS");
	if (PRINTOUT) printf("NFSClient: Bye bye! :-)\n");
}

//    
//     #    #    ##    #    #  #####   #       ######   ####    ####   #    #  #    #
//     #    #   #  #   ##   #  #    #  #       #       #    #  #    #  ##   #  ##   #
//     ######  #    #  # #  #  #    #  #       #####   #       #    #  # #  #  # #  #
//     #    #  ######  #  # #  #    #  #       #       #       #    #  #  # #  #  # #
//     #    #  #    #  #   ##  #    #  #       #       #    #  #    #  #   ##  #   ##
//     #    #  #    #  #    #  #####   ######  ######   ####    ####   #    #  #    #
//    

int handle_connection(int the_socket)
{
	int returncode;
	char *buffer;
	char ** lastposition = &buffer;
	char * command;
	char * temp;
	int commandcode;
	int i;
	
	// if (PRINTOUT) printf("NFSClient (handle_connection): Entered.\n");
	
	buffer = (char *) malloc((MAX_REQUEST_SIZE + 2) * sizeof(char));
	
	// if (PRINTOUT) printf("NFSClient (handle_connection): Waiting for connection...\n");
		
	returncode = recv(the_socket, buffer, MAX_REQUEST_SIZE, 0);
	if (returncode < 0)
	{
		if (PRINTOUT) printf("NFSClient (handle_connection): error %d receiving local message\n", errno);
		perror("      ");
		return(-1);
	}
	else if (returncode == 0)
	{
		if (PRINTOUT) printf("NFSClient (handle_connection): Local socket closed by other side...\n");
		return(0);
	}
	socketrecvs++; socketrecvbytes += returncode;

	// if (PRINTOUT) printf("NFSClient (handle_connection): Message received from socket was:\n");

	buffer[returncode] = '\0';
	// if (PRINTOUT) printf("%s[end]\n", buffer);
	
  //	We have to add a newline at the end if there isn't one, dumb eh?
  
	i = strlen(buffer);
	if (buffer[i-1] != '\n')
	{
		// if (PRINTOUT) printf("NFSClient (handle_connection): adding a newline to end of args (psht).\n");
		buffer[i] = '\n';
		buffer[i+1] = '\0';
		// if (PRINTOUT) printf("NFSClient (handle_connection): args now %s[end]\n", buffer);
	}
	
  //    Now parse the first argument to see what the heck they want. 
	
  //    Get the first token  
	
	temp = (char *) strtok_r(buffer, "\n", lastposition);
	// if (PRINTOUT) printf("NFSClient (handle_connection): first arg is %s\n", temp);
	
  //    Parse it as an int representing which function call to make 

	commandcode = atoi(temp);
	
  //    Get the rest of the message into temp	 
	
	temp = (char *) strtok_r(buffer, "", lastposition);
	
	if (temp == NULL)
	{
		if (PRINTOUT) printf("NFSClient (handle_connection): That's all that's in the message.\n");
	}
	else
	{
		// if (PRINTOUT) printf("NFSClient (handle_connection): And the rest is %s[end]\n", temp);
	}
	
  //    Now pass the rest of the message and the socket to the  
  //    functions that do the work. They will craft the responses 
  //    to the application and send them over the socket. Control 
  //    then comes back here to close the socket. 

	// if (PRINTOUT) printf("NFSClient (handle_connection): temp is %s\n", temp);

	switch(commandcode)
	{
		//  Okay, let's talk about what we're doing in do_NFSmount.
		//  We pass it the rest of the arguments string, for starters.
		//  We also pass it the socket, since it is its job to report
		//  back to the application using the API. We also pass it
		//  TheMountedDirectory, which is a pointer to a "diropargs";
		//  it will fill this with an fhandle which we will need to
		//  call Open and so forth. We also pass it the address of the
		//  server string; it will fill this with the name of the server.
	
		case NFS_MOUNT:	
		
				if (PRINTOUT) printf("NFSClient (handle_connection): NFSmount called\n");
		
				// returncode = do_NFSmount(temp, the_socket, 
				// 	TheMountedDirectory, TMDname, server, &client);
				returncode = do_NFSmount(temp, the_socket);
				
				if (returncode == 0)
				{
					if (PRINTOUT) printf("NFSClient (handle_connection): Server name is %s\n", server);
					if (PRINTOUT) printf("NFSClient (handle_connection): Directory name is %s\n", TMDname);
						
					if (TheMountedDirectory -> name != NULL)
					{
						if (PRINTOUT) printf("NFSClient (handle_connection): NFSClient result diropargs.name is: ");
						if (PRINTOUT) printf("%s\n", (char *)(TheMountedDirectory->name));
					}
					else
					{
						// if (PRINTOUT) printf("NFSClient (handle_connection): NFSClient result has no diropargs.name.\n");
					}
				}
				else
				{
					if (PRINTOUT) printf("NFSClient (handle_connection): Dog! Couldn't mount that.\n");
				}
				
				break;
						
		//  Okay, mounting works fine. Now say we want to open a file. 
		//  The luser will give us a filename, which we will assume is
		//  in the directory that luser wanted to mount. (It may include
		//  subdirectory paths.)  We have to return a FILE *. Fortunately
		//  luser cannot luse it as a regular FILE, he can only luse it in
		//  calls to my very own NFSread and NFSclose. So, I can use the 
		//  internal structure of FILE as anything I want. 
		//
		//  We'll get the API part to fake up the FILE * on the fly. All
		//  it needs for that is the file descriptor. We don't even bother
		//  to pass that in, since it's just an index that is determined
		//  out here. 
		//
		//  We pretty much need to send this function every variable we
		//  have, since we're not doing this in an object-oriented language.
		//  
		//  The result is 0 for a new file opened, 1 for found the filename
		//  in the cache. The only difference is whether we set new values
		//  in file_is_cached and being_used_by. (known_file_names is set
		//  inside the function, and are we violating information hiding 
		//  enough?)
								
		case NFS_OPEN:	
		
			if (PRINTOUT) printf("NFSClient (handle_connection): NFSopen called\n");

			//  And make the function call. We pass the args,
			//  the socket, the mounted directory, a pointer
			//  to a FILE * and a diropres * for our results,
			//  and the server name, which we need to make 
			//  the RPC call. 

			if (PRINTOUT) printf("NFSClient (handle_connection): server name is %s\n", server);
			if (PRINTOUT) printf("NFSClient (handle_connection): TMD name is %s\n", TMDname);
				
			// returncode = do_NFSopen (temp, the_socket, 
			//	TheMountedDirectory, first_empty_slot,
			//	being_used_by, file_is_cached,
			//	known_file_names, cache_dir_name,
			//	diropres_table[first_empty_slot], 
			//	server, TMDname, client);
			
			returncode = do_NFSopen (temp, the_socket);
	
			if (PRINTOUT) printf("NFSClient (handle_connection): Ok, NFSopen return code is %d.\n", 
				returncode);
					
			if (returncode == 0 || returncode == 1)
			{
				if (PRINTOUT) printf("NFSClient (handle_connection): That indicates success.\n");
			}
			else
			{
				if (PRINTOUT) printf("NFSClient (handle_connection): I'm afraid that is an error.\n");
			}
							
			break;
			

		//  Okay, well, it would seem we have open working. After a file is opened, it
		//  is stored in our big tables as a diropres (containing its actual file handle)
		//  and as an int representing its logical position.
		//
		//  Thus, if we want to read from a file, all we need is its file descriptor,
		//  which our API will pass us as an int, which do_NFSread will parse. So
		//  what do we pass in?  The pointer to the table of "diropres"es, and the
		//  pointer to the table of offsets. Oh, and of course the server name. We 
		//  actually shouldn't need the currently mounted directory, as the fhandle
		//  ought to be all we need to access the file.
						
		case NFS_READ:	
		
				// if (PRINTOUT) printf("NFSClient (handle_connection): NFSread called\n");
		
				returncode = do_NFSread (temp, the_socket);

				// if (PRINTOUT) printf("NFSClient (handle_connection): Ok, NFSread return code is %d.\n", 
				// 		returncode);
					
				if (returncode == 0)
				{
					// if (PRINTOUT) printf("NFSClient (handle_connection): That indicates success.\n");
				}
				else
				{
					// if (PRINTOUT) printf("NFSClient (handle_connection): I'm afraid that is an error.\n");
				}
				
				break;
						
		//  As for closing the file, that is going to be a very simple NFS call.
		//  Note that this is the only function that returns anything besides 0/non0. 
		//  It returns -1 on error and the number of the file to close otherwise.
						
		case NFS_CLOSE:	
				
				if (PRINTOUT) printf("NFSClient (handle_connection): NFSclose called\n");
		
				returncode = do_NFSclose(temp, the_socket);

				if (PRINTOUT) printf("NFSClient (handle_connection): Ok, NFSclose return code is %d.\n", 
						returncode);
					
				if (returncode == -1)
				{
					if (PRINTOUT) printf("NFSClient (handle_connection): I'm afraid that is an error.\n");
				}
				else
				{
					being_used_by[returncode] -= 1;
					if (being_used_by[returncode] < 0)
						being_used_by[returncode] = 0;
					 
					if (PRINTOUT) printf("NFSClient (handle_connection): File %d ", returncode);
					if (PRINTOUT) printf("is now being used by %d clients.\n", being_used_by[returncode]);
					// file_offset_table[returncode] = 0;
				}
				
				break;
		
		default:
				socketrecvs--; socketrecvbytes -= returncode;
				// printf("NFSClient: REPORTING VALUES SIR!\n");
				printf(": rpccalls == %d\n", rpccalls);
				printf(": rpcbytes == %ld\n", rpcbytes);
				//printf(": socketsends == %d\n", socketsends);
				//printf(": socketrecvs == %d\n", socketrecvs);
				//printf(": socketsendbytes == %ld\n", socketsendbytes);
				//printf(": socketrecvbytes == %ld\n", socketrecvbytes);
				printf(": rpccalls/cachesize == %.8f\n", (float)rpccalls/(float)cache_size);
				printf(": rpcbytes/cachesize == %.4f\n", (float)rpcbytes/(float)cache_size);
				break;
	}
	
	if (returncode < 0)
	{
		// if (PRINTOUT) printf("NFSClient (handle_connection): Couldn't fulfill request! D'oh.\n");
	}
	else
	{
		// if (PRINTOUT) printf("NFSClient (handle_connection): Request fulfilled.\n");
	}
	
	// if (PRINTOUT) printf("NFSClient (handle_connection): Freeing buffer.\n");

	if (TRY_FREEING_MEMORY) free(buffer);
	
	// if (PRINTOUT) printf("NFSClient (handle_connection): Closing.\n");

	//shutdown(the_socket, 2);
	close(the_socket);

	return(0);
}

//     #    #   ####   #    #  #    #   #####
//     ##  ##  #    #  #    #  ##   #     #
//     # ## #  #    #  #    #  # #  #     #
//     #    #  #    #  #    #  #  # #     #
//     #    #  #    #  #    #  #   ##     #
//     #    #   ####    ####   #    #     #
//    

int do_NFSmount(char *arguments, int the_socket)
{
	char ** lastposition = &arguments;
	char * temp;
	char * temp2;
	char * message;
	int bytes_sent;

	CLIENT * mountclient;
	fhstatus * result;
	dirpath * mountpath;
	int intresult;
	int i;
	
  //  Get the host and pathnames
	
	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (PRINTOUT) printf("do_NFSmount: temp is %s\n", temp);
	
	strcpy(server, temp);
	
	temp2 = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (PRINTOUT) printf("do_NFSmount: temp2 is %s\n", temp2);

	mountpath = &temp2;
	strcpy(TMDname, *mountpath);
	
	if (PRINTOUT) printf("do_NFSmount: server is %s\n", server);
	if (PRINTOUT) printf("do_NFSmount: *mountpath is %s\n", *mountpath);

  //  Do the mounting
  
	mountclient = clnt_create(server, MOUNTPROG, MOUNTVERS, "udp");
	
	if (mountclient == NULL)
	{
		if (PRINTOUT) printf("do_NFSmount: Couldn't create the MOUNTING client\n");
		clnt_pcreateerror(server);
		intresult = -1;
	}
	else
	{
		if (PRINTOUT) printf("do_NFSmount: Created the MOUNTING client\n");

		mountclient->cl_auth = authunix_create_default();

		result = mountproc_mnt_1(mountpath, mountclient);
		rpccalls++; rpcbytes += (sizeof(fhstatus) + sizeof(dirpath) + sizeof(CLIENT));
		
		intresult = result->fhs_status;
		if (PRINTOUT) printf("do_NFSmount: Result status is %d\n", intresult);
	
	  //  Okay, so what have we actually accomplished here?  We have
	  //  made the RPC call that mounts the directory. That gets us
	  //  the first file handle (the handle of the directory we mounted).
	  //  The return value (result) of the call is something called an
	  //  "fhstatus", which contains, although I don't get unions really:
	  //  
	  //    An integer which is the status of the call. Zero means success.
	  //    An "fhandle" which is the directory we've mounted.
	  //
	  //  Apparently we can use the fhandle of the directory to open up
	  //  files now. So we'll copy that fhandle into our "diropargs" TMD,
	  //  which is TheMountedDirectory, which is state kept by the NFS
	  //  client thingie (and wouldn't it be nice to do this in an object-
	  //  oriented language?)  We also need to pass out the name of the 
	  //  server.
	
		if (intresult != 0)
		{
			if (PRINTOUT) printf("do_NFSmount: That indicates some kind of error... sorry.\n");
		}
		else
		{
			memcpy(TMD->dir.data, result->fhs_fh, NFS_FHSIZE);
		}
	
	  //  Okay, we are also going to create an NFS client and pass it back
	  //  up, so we don't have to create a new NFS client every time.
	  //
	  //  NB: No longer passing up, just using global variable.
		
		client  = clnt_create(server, NFS_PROGRAM, NFS_VERSION, "udp");
		if (client == NULL)
		{
			if (PRINTOUT) printf("do_NFSmount: Couldn't create the NFS client");
			clnt_pcreateerror(server);
			exit(1);
		}
		else
		{
			client ->cl_auth = authunix_create_default();
		}
		
	}
	
  //  We do one more thing, which is send a message containg the
  //  return code (0 or -1) to the application that asked us to
  //  make the call.
  
	message = (char *) malloc (100 * sizeof(char));

	if (intresult == 0)
	{
		strcat(message, "0");
	}
	else
	{
		strcat(message, "-1");
	}	

	bytes_sent = send(the_socket, message, strlen(message), 0);
	socketsends++; socketsendbytes += bytes_sent;
	
	if (bytes_sent < 0)   
	{
		if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
		perror("           ");  
		exit(1);
	}
	
	if (TRY_FREEING_MEMORY) free(message);
	
	if (PRINTOUT) printf("do_NFSmount: Done.\n");

	return(intresult);
}


//      ####   #####   ######  #    #
//     #    #  #    #  #       ##   #
//     #    #  #    #  #####   # #  #
//     #    #  #####   #       #  # #
//     #    #  #       #       #   ##
//      ####   #       ######  #    #


//  Ok, so what's the simplest, stupidest possible way I could do this?
//  I'd say -- fetch the entire file upon opening. Then every time it is
//  opened or read from, just access the local copy instead of going to 
//  the NFS server.  Since there is no writing to the file, this will 
//  maintain consistency.
//
//  This will be a little slower than keeping it in memory, but the 
//  process will obviously use up less memory.

int do_NFSopen (char *arguments, int the_socket)
{
	char ** lastposition = &arguments;
	char * temp;
	char * message;
	char * dirname;
	char * lastslash;
	int bytes_sent;
	diropres * dirresult;
	int intresult = -1;
	int slashfound = FALSE;
	diropargs * subdir;
	int mdreturncode;
	int i, j;
	FILE * cachefile;
	char * cachefilename;
	readargs * thearguments;
	readres * readresult;
	int amount_received;
	int file_size;
	int first_empty_slot = -1;
	int slot_to_use = -1;
	
	message = (char *) malloc (100 * sizeof(char));

  //  Get the filename

	if (PRINTOUT) printf("do_NFSopen: server name is %s\n", server);
	if (PRINTOUT) printf("do_NFSopen: TMDname is %s\n", TMDname);

	// if (PRINTOUT) printf("do_NFSopen: arguments is %s\n", arguments);

	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition); 

	// if (PRINTOUT) printf("do_NFSopen: first token in args is %s\n", temp);
	
  //  First, make sure there is an argument there. 
  
	if (temp != NULL)
	{
		//  First, see if it the name is exactly the same as a previously 
		//  fetched file. If it is, we will just return that file descriptor.
		//  The file descriptor is the same as the index into the filename
		//  array.
		//  
		//  This is a fairly naive search, as it just checks every entry.
		//  But there should never be so many entries that it's a problem.
		//  Also, strcmp will return as soon as the first different character
		//  is reached.
		
		for (i=0; i<NF; i++)
		{
			if (entry_is_valid[i])
			{
				if (PRINTOUT) printf("%-3d: file name is %s\n", i, known_file_names[i]);
				if (0 == strcmp(known_file_names[i], temp))
				{
					if (PRINTOUT) printf("do_NFSopen: found a match at filedesc %d\n", i);
					break;
				}
			}
			else 
			{
				if (first_empty_slot == -1)
					first_empty_slot = i;
			}
		}
		if (PRINTOUT) printf("final i is %d\n", i);

		if (i == NF)
		{
			//  In this case, it wasn't already in there, so we do the
			//  work of finding a place to put it. 

			//  If we found an empty slot above, that's easy.
			
			if (first_empty_slot != -1)
			{
				if (PRINTOUT) printf("do_NFSopen: Found an empty slot at %d\n", first_empty_slot);
				
				slot_to_use = first_empty_slot;
				
				//  Allocate it if necessary
				
				if (diropres_table[slot_to_use] == NULL)
				{
					if (PRINTOUT) printf("do_NFSopen: allocating diropres_table[%d]\n", slot_to_use);
					diropres_table[slot_to_use] = (diropres *)
						malloc(sizeof(diropres));
				}	
			}
			else
			{
				//  Otherwise, we will have to delete an entry. This will delete the
				//  LRU entry that is not open by any clients. If all entries are open,
				//  we cannot do this open and send an error. 
			
				slot_to_use = delete_least_recently_used_entry();
			}
			
			if (slot_to_use == -1)
			{
				if (PRINTOUT) printf("do_NFSopen: Sorry, I'm out of file slots!  Close some!\n");
				sprintf(message, "-1\n");
			
				bytes_sent = send(the_socket, message, strlen(message), 0);
				socketsends++; socketsendbytes += bytes_sent;
				
				if (bytes_sent < 0)   
				{
					if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
					perror("           ");  
					exit(1);
				}
				
				return -1;
			}
			
			// slot_to_use should now be defined, one way or another...
		
			strcpy(known_file_names[slot_to_use], temp);
			
			if (PRINTOUT) printf("do_NFSopen: using slot number %d\n", slot_to_use);

			being_used_by[slot_to_use] += 1;
			entry_is_valid[slot_to_use] = 1;
			
			if (PRINTOUT) printf("do_NFSopen: File %d ", slot_to_use);
			if (PRINTOUT) printf("is now being used by %d clients.\n", being_used_by[slot_to_use]);

		}
		else if (i >= 0 && i < NF)	//  It was already in there
		{
			//  If we are in here, it means we have found a matching
			//  file name, and should send the API that file desc, 
			//  instead of making all the connections and etc. 
			//  Besides sending over the socket, we also need to 
			//  inform the NFS client via the return code.
			
			being_used_by[i] += 1;
			last_used[i] = current_timestamp;
			current_timestamp++;

			if (PRINTOUT) printf("do_NFSopen: File %d ", i);
			if (PRINTOUT) printf("is now being used by %d clients.\n", being_used_by[i]);

			sprintf(message, "%d", i);
			if (PRINTOUT) printf("do_NFSopen: found file name %s at file number %d\n", 
				    known_file_names[i], i);
		
			bytes_sent = send(the_socket, message, strlen(message), 0);
			socketsends++; socketsendbytes += bytes_sent;
			
			if (bytes_sent < 0)   
			{
				if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
				perror("           ");  
				exit(1);
			}
			
			return(1);				//  This means we found it in cache
		}
		else						//  This should never happen
		{
			if (PRINTOUT) printf("do_NFSopen: Problem looking through cache!\n");
			if (PRINTOUT) printf("do_NFSopen: Dying horribly.\n");
			exit(1);
		}
	
		//  If we get down here it means we still have to go get the file. 
		
		//  First, check for /s in the filename. If there are any, we need 
		//  to mount another directory.
	
		lastslash = strrchr(temp, '/');
		
		if (lastslash != NULL)
		{
			slashfound = TRUE;
			lastslash[0] = '\0';
			
			if (PRINTOUT) printf("do_NFSopen: directory name is %s, filename is %s\n", 
					temp, lastslash + 1);
			
			dirname = (char *) malloc ((strlen(TMDname)+strlen(temp)+4) * sizeof(char));
			strcat(dirname, TMDname);
			strcat(dirname, "/");
			strcat(dirname, temp);
			
			if (PRINTOUT) printf("do_NFSopen: dirname is %s\n", dirname);
			
			subdir = (diropargs *) malloc (sizeof(diropargs));
			mdreturncode = mountDirectory(dirname, subdir, server);
			
			if (PRINTOUT) printf("do_NFSopen: mountdir return code is %d\n", mdreturncode);

			subdir -> name = lastslash + 1;
		}
		else
		{
			if (PRINTOUT) printf("do_NFSopen: filename is %s\n", temp);
	
		  //  Put the file name into the diropargs for lookup.
  
  			if (TMD)
	  			TMD -> name = temp;
			else
				client = NULL;
		}
	}
	
	if (temp == NULL)
	{
		if (PRINTOUT) printf("do_NFSopen: No arguments found.\n");
	}	
	else if (client == NULL)
	{
		if (PRINTOUT) printf("do_NFSopen: Couldn't use the client.\n");
		if (PRINTOUT) printf("do_NFSopen: Did you remember to mount first?\n");
		clnt_pcreateerror(server);
	}
	else
	{
	  //  Make the call. This now handles files in sub directories.
	  //  Anyway, the call returns a pointer to a "diropres", which holds a
	  //  status code and an fhandle, the fhandle being what we actually need.

		if (slashfound)
		{
			dirresult = nfsproc_lookup_2(subdir, client);
			rpccalls++; rpcbytes += (sizeof(diropres) + sizeof(diropargs) + sizeof(CLIENT));
		}
		else
		{	 
			dirresult = nfsproc_lookup_2(TMD, client);
			rpccalls++; rpcbytes += (sizeof(diropres) + sizeof(diropargs) + sizeof(CLIENT));
		}
		
		intresult = dirresult -> status;
		if (PRINTOUT) printf("do_NFSopen: Lookup status is %d\n", intresult);


		//  We save the filehandle, in case the file is purged from the
		//  cache, or never put there. 

		memcpy(diropres_table[slot_to_use], dirresult, sizeof(diropres));


		//  Okay, so how big is the file?

		file_size = dirresult -> fsize;
		if (PRINTOUT) printf("do_NFSopen: size is %d\n", file_size);

		if (file_size > cache_size)
		{
			//  If the file is bigger than the whole cache, we make
			//  no attempt to cache it.
			
			file_is_cached[slot_to_use] = 0;
			if (PRINTOUT) printf("do_NFSopen: Not caching this file.\n");
		}
		else
		{
			//  We do want to cache the file. But is there room?
			//  While there isn't, we'll remove files. 
		
			while (amount_in_cache + file_size > cache_size)
			{
				purge_LRU_file_from_cache();
			}
		
		
			//  Okay, now we actually cache the file. First, we open it for writing.
			//  The file will be cache_dir_name/# where # is the file descriptor.
			
			cachefilename = (char *) malloc ((strlen(cache_dir_name) + 8) *
			                                  sizeof(char));
			sprintf(cachefilename, "%s/%d", cache_dir_name, slot_to_use);
			if (PRINTOUT) printf("do_NFSopen: caching file in %s\n", cachefilename);
			cachefile = fopen(cachefilename, "w");
			
			//  Now we make the NFS call to read from the file.....
	
			thearguments = (readargs *) malloc (sizeof(readargs));
	
			thearguments -> offset = 0;
			thearguments -> count = NFS_MAXDATA;
			thearguments -> totalcount = 0;
			
			//  We do it as many times as necessary to get the whole file,
			//  since we can only get 8 K at a time.
	
		    while (thearguments -> offset < file_size)
		    {
				// if (PRINTOUT) printf("do_NFSopen: Copying the file handle for the call...\n");
				
				memcpy(thearguments -> file.data, 
				       dirresult -> diropres_u.diropres.file.data, NFS_FHSIZE);
				
				// if (PRINTOUT) printf("do_NFSopen: Trying to read over NFS...\n");
		
				readresult = nfsproc_read_2(thearguments, client);
				rpccalls++; rpcbytes += (sizeof(readres) + sizeof(readargs) + sizeof(CLIENT));
		
				intresult = readresult -> status;
				// if (PRINTOUT) printf("do_NFSread: int result is %d\n", intresult);
		
				// if (PRINTOUT) printf("do_NFSread: address of data is %d\n",
				// 	readresult -> readres_u.reply.data.data_val);
				
				if (intresult == 0)
				{		
					amount_received = readresult -> readres_u.reply.data.data_len;
					rpcbytes += amount_received;
			
					// if (PRINTOUT) printf("do_NFSopen: got %d bytes\n", amount_received);
				}
				else
					break;
		
				// if (PRINTOUT) printf("do_NFSread: Here's what we got:\n");
				for (i=0; i<amount_received; i++)
				{
					//  if (PRINTOUT) printf("%c", (char) (readresult -> readres_u.reply.data.data_val)[i]);
					fprintf(cachefile, "%c", 
					       (char) (readresult -> readres_u.reply.data.data_val)[i]);
				}
				//  if (PRINTOUT) printf("[end]\n");
		
				thearguments -> offset += amount_received;
		    }
	
			fclose(cachefile);
			
			if (intresult == 0)
			{
				file_is_cached[slot_to_use] = 1;
				amount_in_cache += file_size;
				
				if (intresult == 0)
				if (PRINTOUT) printf("do_NFSopen: cached file name %s for file number %d\n", 
				        known_file_names[slot_to_use], slot_to_use);
				        
				if (PRINTOUT) printf("do_NFSopen: amount in cache is now %d\n", amount_in_cache);
			}
		}
	}
	
	//  Last, we send the file descriptor to the API. It will do
	//  the work of faking up a FILE *. We do check whether the file
	//  was actually found.

	if (client == NULL || intresult != 0)
	{
		strcat(message, "-1");
	}
	else
	{
		sprintf(message, "%d", slot_to_use);
	}

	bytes_sent = send(the_socket, message, strlen(message), 0);
	socketsends++; socketsendbytes += bytes_sent;
	
	if (bytes_sent < 0)   
	{
		if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
		perror("           ");  
		exit(1);
	}
	
	if (TRY_FREEING_MEMORY) free(dirname);
	if (TRY_FREEING_MEMORY) free(subdir);
	if (TRY_FREEING_MEMORY) free(message);
	
	return(intresult);
}

//     #####   ######    ##    #####
//     #    #  #        #  #   #    #
//     #    #  #####   #    #  #    #
//     #####   #       ######  #    #
//     #   #   #       #    #  #    #
//     #    #  ######  #    #  #####


int do_NFSread (char *arguments, int the_socket)
{
	char ** lastposition = &arguments;
	char * temp;
	char * message;
	int bytes_sent;
	int filedesc, offset, amount;
	int argsgood = 1;

  //  Protocol for read is
  //  3	(meaning read)
  //  filedesc
  //  offset
  //  amount

  //  Get the file descriptor -- should be the first argument.

	// if (PRINTOUT) printf("do_NFSread: server name is %s\n", server);
	
	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (temp == NULL)
	{
		if (PRINTOUT) printf("do_NFSread: No arguments found.\n");
		argsgood = 0;
	}
	else
	{
		filedesc = atoi(temp);
		// if (PRINTOUT) printf("do_NFSread: filedesc is %d\n", filedesc);
	}

  //  Get the offset -- should be the second argument.
 	
	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (temp == NULL)
	{
		if (PRINTOUT) printf("do_NFSread: Not enough arguments.\n");
		argsgood = 0;
	}
	else
	{
		offset = atoi(temp);
		if (PRINTOUT) printf("do_NFSread: offset is %d\n", offset);

		if (offset < 0)
		{
			if (PRINTOUT) printf("do_NFSread: which I guess means you didn't want any data.\n");
			argsgood = 0;
		}
	}

  //  Get the amount -- should be the third argument. 	

	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (temp == NULL)
	{
		if (PRINTOUT) printf("do_NFSread: Not enough arguments.\n");
		argsgood = 0;
	}
	else
	{
		amount = atoi(temp);
		if (PRINTOUT) printf("do_NFSread: amount is %d\n", amount);

		if (amount > 8000)
		{
			if (PRINTOUT) printf("do_NFSread: but I'm afraid I can only give you 8000 bytes.\n");
			amount = 8000;
		}
		else if (amount < 1)
		{
			if (PRINTOUT) printf("do_NFSread: which I guess means you didn't want any data.\n");
			argsgood = 0;
		}
	}

	if (!argsgood)
	{
		message = "-1\n";
		bytes_sent = send(the_socket, message, strlen(message), 0);
		socketsends++; socketsendbytes += bytes_sent;

		if (bytes_sent < 0)   
		{
			if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
			perror("           ");  
			exit(1);
		}
	}
	
	last_used[filedesc] = current_timestamp;
	current_timestamp++;
	
	if (file_is_cached[filedesc])
	{
		return(do_cache_read(filedesc, offset, amount, the_socket));
	}
	else
	{
		return(do_network_read(filedesc, offset, amount, the_socket));
	}
}

//     #    #  ######  #####  #    #   ####   #####   #    #
//     ##   #  #         #    #    #  #    #  #    #  #   #
//     # #  #  #####     #    #    #  #    #  #    #  ####
//     #  # #  #         #    # ## #  #    #  #####   #  #
//     #   ##  #         #    ##  ##  #    #  #   #   #   #
//     #    #  ######    #    #    #   ####   #    #  #    #

//  When we're reading out of a file, how do we know where in the file 
//  we are?  We'll actually use the offset in the FILE *. Since each 
//  calling app has its own faked-up FILE *, we just set the offset
//  after each read, and then when the FILE * is passed back in for
//  another read, we'll use it to determine where to read from. 

//  We keep passing in the diropres and all that, in case we don't have
//  the file in cache. 


int do_network_read (int filedesc, int offset, int amount, int the_socket)
{	
	char * message;
	int messagelength;
	int bytes_sent;

	readres * readresult;
	readargs * thearguments;

	int intresult = -1;
	int i, amount_received;

	char * filename;
	char numberstring[8] = "\0\0\0\0\0\0\0\0";
	int numberstringlength;
	
  //  What arguments do we expect this function to need?  A file descriptor
  //  (int) saying which file to read from. And an int saying how many bytes
  //  to read. 

	// if (PRINTOUT) printf("do_NFSread/network: server name is %s\n", server);

  //  Check the client
  
	if (client == NULL)
	{
		if (PRINTOUT) printf("do_NFSread/network: Couldn't use the client.\n");
		if (PRINTOUT) printf("do_NFSread/network: Did you remember to mount first?\n");
		clnt_pcreateerror(server);
	}
	else
	{
		// if (PRINTOUT) printf("do_NFSread/network: Allocating readargs structures.\n");
	
		thearguments = (readargs *) malloc (sizeof(readargs));

		// logicalposition = file_offset_table[filedesc];
		// thearguments -> offset = logicalposition;

		thearguments -> offset = offset;
		thearguments -> count = amount;
		thearguments -> totalcount = 0;
		memcpy(thearguments -> file.data, 
		      (diropres_table[filedesc]) -> diropres_u.diropres.file.data,
		       NFS_FHSIZE);
		
		if (PRINTOUT) printf("do_NFSread/network: Trying to read from file number %d\n", filedesc);

		readresult = nfsproc_read_2(thearguments, client);
		rpccalls++; rpcbytes += (sizeof(readres) + sizeof(readargs) + sizeof(CLIENT));

		intresult = readresult -> status;
		if (PRINTOUT) printf("do_NFSread/network: int result is %d\n", intresult);
	
		//  The number of bytes we got is stored in the secret
		//  location readres->readres_u.reply.data.data_len, 
		//  right next to the data itself. (Annoying!)

		if (intresult == 0)
		{		
			amount_received = readresult -> readres_u.reply.data.data_len;
			rpcbytes += amount_received;

			if (PRINTOUT) printf("do_NFSread/network: got %d bytes \n", amount_received);

			//  Craft the response to be sent over the socket

			sprintf(numberstring, "%d\n", amount_received);
			numberstringlength = strlen(numberstring);

			// if (PRINTOUT) printf("do_NFSread/network: numberstring is %d chars long ",
			// 	numberstringlength);
			// if (PRINTOUT) printf("and is \n%s[end]\n", numberstring);

			message = (char *) malloc (
				(10 + amount_received) * sizeof (char));
			bzero(message, (10+amount_received));

			strcat(message, numberstring);

			memcpy((message+numberstringlength), 
				readresult -> readres_u.reply.data.data_val,
				amount_received);
				
			messagelength = numberstringlength + amount_received;
			
			// if (PRINTOUT) printf("--------------\n");
			// if (PRINTOUT) printf("%s\n", message);
			// if (PRINTOUT) printf("--------------\n");

		}
	}
	
	if (client == NULL || intresult != 0)
	{
		// message = (char *) malloc (8 * sizeof(char));
		// strcat(message, "-1\n");
		message = "-1\n";
		messagelength = strlen(message);
	}
	else
	{
		// message = (char *) malloc ((10 + amount_received) * sizeof (char));

		// sprintf(message, "%d", amount_received);
	}

	bytes_sent = send(the_socket, message, messagelength, 0);
	socketsends++; socketsendbytes += bytes_sent;

	if (bytes_sent < 0)   
	{
		if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
		perror("           ");  
		exit(1);
	}
	
	if (TRY_FREEING_MEMORY) free(thearguments);
	if (TRY_FREEING_MEMORY) free(message);
	
	if (intresult != 0)
	{
		return (intresult);
	}

	return 0;
}

//    
//      ####     ##     ####   #    #  ######  #####
//     #    #   #  #   #    #  #    #  #       #    #
//     #       #    #  #       ######  #####   #    #
//     #       ######  #       #    #  #       #    #
//     #    #  #    #  #    #  #    #  #       #    #
//      ####   #    #   ####   #    #  ######  #####


int do_cache_read (int filedesc, int offset, int amount, int the_socket)
{
	char * cachefilename;
	FILE * cachefile;
	int amount_read = 0;
	int ch;
	char * message;
	char * numberstring;
	int numberstring_length;
	int bytes_sent;
	
	message = (char *) malloc((12 + amount) * sizeof(char));
	numberstring = (char *) malloc (8 * sizeof(char));
	
	cachefilename = (char *) malloc ((strlen(cache_dir_name) + 8) *
	                                  sizeof(char));
	sprintf(cachefilename, "%s/%d", cache_dir_name, filedesc);
	if (PRINTOUT) printf("do_NFSread/cache: reading from %s\n", cachefilename);
	cachefile = fopen(cachefilename, "r");
	
	fseek(cachefile, offset, SEEK_SET);
	ch = fgetc(cachefile);

	while (amount_read < amount && ch != EOF)
	{
		message[amount_read+10] = ch;
		ch = fgetc(cachefile);
		amount_read++;
	}
	message[amount_read+10] = '\0';
	
	sprintf(numberstring, "%d\n", amount_read);
	numberstring_length = strlen(numberstring);
	
	memcpy(message+10-numberstring_length, numberstring, numberstring_length);
	
	// if (PRINTOUT) printf("do_NFSread/cache: numberstring is %sand its length is %d",
	//		numberstring, numberstring_length);
	
	// if (PRINTOUT) printf("do_NFSread/cache: message+10-%d is\n%s\n", 
	//		numberstring_length, message+10-numberstring_length);

	// if (PRINTOUT) printf("do_NFSread/cache: numberstring_length+amount_read is %d\n",
	//	numberstring_length+amount_read);

	// if (PRINTOUT) printf("do_NFSread/cache: strlen(message+10-numberstring_length) is %d\n",
	//	strlen(message+10-numberstring_length));


	fclose(cachefile);
	
	// bytes_sent = send(the_socket, message+10-numberstring_length, 
	//                 strlen(message+10-numberstring_length), 0);
	
	bytes_sent = send(the_socket, message+10-numberstring_length, 
	                  numberstring_length+amount_read, 0);
	socketsends++; socketsendbytes += bytes_sent;
	
	if (bytes_sent < 0)   
	{
		if (PRINTOUT) printf("Oops -- got error %d trying to use sockets. Quitting\n", errno);
		perror("           ");  
		exit(1);
	}
	
	if (TRY_FREEING_MEMORY) free(message);
	
	return 0;
	
}


//    
//      ####   #        ####    ####   ######
//     #    #  #       #    #  #       #
//     #       #       #    #   ####   #####
//     #       #       #    #       #  #
//     #    #  #       #    #  #    #  #
//      ####   ######   ####    ####   ######
//    


//  NFSclose only figures out the file number to close and passes it
//  back up.

int do_NFSclose (char *arguments, int the_socket)
{
	char ** lastposition = &arguments;
	char * temp;
	int filedesc;

	int bytes_sent;

	char * message = "0\n";
	
  //  Get the file descriptor -- should be the first argument.

	temp = (char *) strtok_r(arguments, "\n", (char **) lastposition);
	if (temp == NULL)
	{
		if (PRINTOUT) printf("do_NFSclose: No arguments found.\n");
		filedesc = -1;
	}
	else
	{
		filedesc = atoi(temp);
		if (PRINTOUT) printf("do_NFSclose: filedesc is %d\n", filedesc);
	}

	bytes_sent = send(the_socket, message, strlen(message), 0);
	socketsends++; socketsendbytes += bytes_sent;
	
	if (bytes_sent < 0)   
	{
		if (PRINTOUT) printf("Oops -- got error %d trying to use sockets.\n", errno);
		perror("           ");  
		exit(1);
	}
	return (filedesc);
}


//     #####   #####   ######   #####   #####   #   #
//     #    #  #    #  #          #       #      # #
//     #    #  #    #  #####      #       #       #
//     #####   #####   #          #       #       #
//     #       #   #   #          #       #       #
//     #       #    #  ######     #       #       #


void prettyprintFILE(FILE * fin, const char * prefix)
{
	if (PRINTOUT) printf("%sFile descriptor is %d, logical position is %d\n",
			prefix, fin->_file, fin->_cnt);
}

//                                            ######
//     #    #   ####   #    #  #    #   ##### #     #     #    #####
//     ##  ##  #    #  #    #  ##   #     #   #     #     #    #    #
//     # ## #  #    #  #    #  # #  #     #   #     #     #    #    #
//     #    #  #    #  #    #  #  # #     #   #     #     #    #####
//     #    #  #    #  #    #  #   ##     #   #     #     #    #   #
//     #    #   ####    ####   #    #     #   ######      #    #    #
//    


int mountDirectory(char *dirname, diropargs * doaout, char * server)
{
	CLIENT * client;
	fhstatus * result;
	dirpath * mountpath;
	int i, intresult;
	
  //  Get the host and pathnames
	
	mountpath = &dirname;
	
	if (PRINTOUT) printf("mountDirectory: server is %s\n", server);
	if (PRINTOUT) printf("mountDirectory: *mountpath is %s\n", *mountpath);

  //  Do the mounting
  
	client = clnt_create(server, MOUNTPROG, MOUNTVERS, "udp");
	if (client == NULL)
	{
		if (PRINTOUT) printf("mountDirectory: Couldn't create the MOUNTING client");
		clnt_pcreateerror(server);
		return -1;
	}
	else
	{
		client->cl_auth = authunix_create_default();

		result = mountproc_mnt_1(mountpath, client);
		rpccalls++; rpcbytes += (sizeof(fhstatus) + sizeof(dirpath) + sizeof(CLIENT));
		
		intresult = result->fhs_status;
		if (PRINTOUT) printf("mountDirectory: Result status is %d\n", intresult);
	
		if (intresult != 0)
		{
			if (PRINTOUT) printf("mountDirectory: That indicates some kind of error... sorry.\n");
		}
		else
		{
			memcpy(doaout->dir.data, result->fhs_fh, NFS_FHSIZE);
		}
		return 0;
	}
}


//     #####   ######  #       ######   #####  ######
//     #    #  #       #       #          #    #
//     #    #  #####   #       #####      #    #####
//     #    #  #       #       #          #    #
//     #    #  #       #       #          #    #
//     #####   ######  ######  ######     #    ######


int delete_least_recently_used_entry()
{
	int i;
	int entry_to_delete = -1;
	int returncode = 34;
	
	//  First make sure there's one that's not being used.
	//  If there isn't return -1.
	//  If we happen across one that isn't even valid, just
	//  return that.
	
	for (i = 0; i<NF; i++)
	{
		if (!entry_is_valid[i])
		{
			file_is_cached[i] = 0;
			being_used_by[i] = 0;
			if (PRINTOUT) printf("Delete: Found a nonvalid entry at %d, returning it.\n", i);
			return i;
		}

		if (being_used_by[i] == 0)
		{
			entry_to_delete = i;
			break;
		}
	}
	if (entry_to_delete == -1)
	{
		return -1;
	}
	
	//  Next go through them all and find the one with the oldest last_used
	
	for (i = 0; i<NF; i++)
	{
		if (being_used_by[i] == 0 &&
		    last_used[i] < last_used[entry_to_delete])
		{
			entry_to_delete = i;
		}
	}
	
	//  Ok, now we know which one to delete.
	
	if (PRINTOUT) printf("Delete: deleting entry %d\n", entry_to_delete);

	file_is_cached[entry_to_delete] = 0;
	being_used_by [entry_to_delete] = 0;
	entry_is_valid[entry_to_delete] = 0;
	
	returncode = remove_from_cache(entry_to_delete);
	
	if (returncode != 0)
	{
		if (PRINTOUT) printf("Delete: Got an error %d\n", errno);
		perror("      ");
		
		if (errno != 2)
			return -1;
	}

	if (PRINTOUT) printf("Delete: Entry deleted.\n");
	
	return entry_to_delete;
}

int remove_from_cache(int which)
{
	char * tempfilename;

	tempfilename = (char *) malloc ((strlen(cache_dir_name) + 8) *
		                                  sizeof(char));

	file_is_cached[which] = 0;

	sprintf(tempfilename, "%s/%d", cache_dir_name, which);
	
	if (PRINTOUT) printf("Remove: removing file %s\n", tempfilename);
	
	return remove(tempfilename);
}

int purge_LRU_file_from_cache()
{
	int i;
	int file_to_remove = -1;
	int removed_size;
	
	//  Pick any cached file
	
	for (i = 0; i<NF; i++)
	{
		if (file_is_cached[i] && entry_is_valid[i])
		{
			file_to_remove = i;
			break;
		}
	}
	if (file_to_remove == -1)
	{
		//  Problem.
		
		if (PRINTOUT) printf("Purge: there are no valid files in the cache.\n");
		if (PRINTOUT) printf("Purge: I'll try purging the whole thing.\n");

		for (i = 0; i<NF; i++)
		{
			remove_from_cache(i);
		}
		amount_in_cache = 0;
		return 0;	
	}
	
	//  Now pick the one with the oldest timestamp.
	
	for (i = 0; i<NF; i++)
	{
		if (file_is_cached[i] && entry_is_valid[i] 
			&& last_used[i] < last_used[file_to_remove])
		{
			file_to_remove = i;
		}
	}
	remove_from_cache(file_to_remove);

	removed_size = diropres_table[file_to_remove] -> fsize;
	amount_in_cache -= removed_size;
	
	if (PRINTOUT) printf("Purge: Okay, I purged file number %d, which had size %d\n", 
	        file_to_remove, removed_size);
	if (PRINTOUT) printf("Purge: The cache now holds %d bytes.\n", amount_in_cache);
	
	return 0;
}