//**********************************************
// Packet.cpp: implements several useful functions for
// communicating between clients and servers for version 2
// Does not support GetLastError between client and server

#include "packet.h"
#include <iostream.h>

//** sendControl - sends a network control word
// PRE: socket2server is ready for communications
// POST: sends "request" to socket2server
// on network failure - closes socket and cleans up TCP connection
bool sendControl(SOCKET socket2server, NET_CONTROL request)
{
	char* Ptr = (char*) &request;
	int numsnt = send(socket2server, Ptr, sizeof(request), 0);
	if (numsnt != sizeof(request)) {
		//		TRACE("Could not send request:%d", (int) WSAGetLastError());
		closesocket(socket2server);
		WSACleanup();
		return false;
	}
	return true;
}

//*************************************
//** getControl: receives a network control word

NET_CONTROL getControl(SOCKET socket2server)	
{
	NET_CONTROL reply;
	int numrcv = recv(socket2server, (char*) &reply, sizeof(reply),0);
	if(numrcv != sizeof(reply))
		return FAILURE;
	return reply;
}

//******************************************
//** sendPacket: sends packet to socket2server
bool sendPacket(SOCKET socket2server, LPBYTE packet, int size)
{
	int numsnt = send(socket2server, (char*) packet, size, 0);
	if (numsnt != size) {
		//TRACE("Could not send fileHandle:%d", (int) WSAGetLastError());
		closesocket(socket2server);
		WSACleanup();
		return false;
	}
	return true;
}


bool getPacket(SOCKET socket2server, LPBYTE packet, int size)
{
	int numrcv = recv(socket2server, (char*) packet, size,0);
	if(numrcv != size)
		return false;
	return true;
}

//*****************************
//** client_CreateDirectory: simulates client side RPC for CreateDirectory
// does not support security parameter
// PRE: socket2server connection is open

bool client_CreateDirectory(LPCTSTR name, LPSECURITY_ATTRIBUTES dummy)
{
	PCKT_CREATE_DIRECTORY_IN pcktCD;
	PCKT_CREATE_DIRECTORY_OUT pcktCDout;
		
	if (!sendControl(socket2server, CREATE_DIRECTORY))
		return  false;
	memcpy(pcktCD.name, name, SIZE_NAME);
	if(!sendPacket(socket2server, LPBYTE(&pcktCD), sizeof(pcktCD)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktCDout), sizeof(pcktCDout)))
		return false;
	if(pcktCDout.status != SUCCESS)
		return false;
	return pcktCDout.returnValue;
	
}

//*****************************
//** client_SetCurrentDirectory: simulates client side RPC for SetCurrentDirectory
// PRE: socket2server connection is open

bool client_SetCurrentDirectory(LPCTSTR name)
{
	PCKT_CREATE_DIRECTORY_IN pcktSD;
	PCKT_CREATE_DIRECTORY_OUT pcktSDout;
		
	if (!sendControl(socket2server, SET_CURRENT_DIRECTORY))
		return  false;
	memcpy(pcktSD.name, name, SIZE_NAME);
	if(!sendPacket(socket2server, LPBYTE(&pcktSD), sizeof(pcktSD)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktSDout), sizeof(pcktSDout)))
		return false;
	if(pcktSDout.status != SUCCESS)
		return false;
	return pcktSDout.returnValue;
	
}

//*****************************
//** client_CreatFile: simulates client side RPC for CreateFile
// does not supprt share, security, attributes, and template file parameters
// PRE: socket2server connection is open

HANDLE client_CreateFile(LPCTSTR fileName, DWORD access, DWORD share, LPSECURITY_ATTRIBUTES dummy1, 
				  DWORD create, DWORD attributes, HANDLE templateFile)
{
	PCKT_CREATE_FILE_IN pcktCF;
	PCKT_CREATE_FILE_OUT pcktCFout;
		
	if (!sendControl(socket2server, CREATE_FILE))
		return  INVALID_HANDLE_VALUE;
	memcpy(pcktCF.fileName, fileName, SIZE_NAME);
	pcktCF.accessMode = access;
	pcktCF.createMode = create;
	if(!sendPacket(socket2server, LPBYTE(&pcktCF), sizeof(pcktCF)))
		return INVALID_HANDLE_VALUE;
	if(!getPacket(socket2server, LPBYTE(&pcktCFout), sizeof(pcktCFout)))
		return INVALID_HANDLE_VALUE;
	if(pcktCFout.status != SUCCESS)
		return INVALID_HANDLE_VALUE;
	return pcktCFout.fileHandle;
	
}
//***********************************
//** client_WriteFile: simulates client side RPC for WriteFile
// does not support overlapped parameter
// PRE: socket2server connection is open

bool client_WriteFile(HANDLE fileHandle, LPCVOID buffer, DWORD nBytes, LPDWORD nBytesOut, LPOVERLAPPED dummy)
{
	PCKT_WRITE_FILE_IN pcktWF;
	PCKT_WRITE_FILE_OUT pcktWFout;

	if (!sendControl(socket2server, WRITE_FILE))
		return false;
	pcktWF.fileHandle = fileHandle;
	memcpy(pcktWF.buffer, buffer, nBytes);
	pcktWF.nBytesIn = nBytes;
	if(!sendPacket(socket2server, LPBYTE(&pcktWF), sizeof(pcktWF)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktWFout), sizeof(pcktWFout)))
		return false;
	if(pcktWFout.status != SUCCESS)
		return false;
	*nBytesOut = pcktWFout.nBytesOut;
	return true;
}

//***********************************
//** client_ReadFile: simulates client side RPC for ReadFile
// does not support overlapped parameter
// PRE: socket2server connection is open

bool client_ReadFile(HANDLE fileHandle, LPVOID buffer, DWORD nBytes, LPDWORD nBytesOut, LPOVERLAPPED dummy)
{
	PCKT_READ_FILE_IN pcktRF;
	PCKT_READ_FILE_OUT pcktRFout;

	if (!sendControl(socket2server, READ_FILE))
		return false;
	pcktRF.fileHandle = fileHandle;
	pcktRF.nBytesIn = nBytes;
	if(!sendPacket(socket2server, LPBYTE(&pcktRF), sizeof(pcktRF)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktRFout), sizeof(pcktRFout)))
		return false;
	if(pcktRFout.status != SUCCESS)
		return false;
	memcpy((char*)buffer, (char*)(pcktRFout.buffer), nBytes);
	*nBytesOut = pcktRFout.nBytesOut;
	return true;
}

//***********************************
//** client_SetFilePointer: simulates client side RPC for SetFilePointer
// does not support overlapped parameter
// PRE: socket2server connection is open

DWORD client_SetFilePointer(HANDLE fileHandle, LONG dist1, PLONG dist2, DWORD method)
{
	PCKT_SET_FILE_POINTER_IN pcktSP;
	PCKT_SET_FILE_POINTER_OUT pcktSPout;

	if (!sendControl(socket2server, SET_FILE_POINTER))
		return 0xFFFFFFFF;
	pcktSP.fileHandle = fileHandle;
	pcktSP.dist1 = dist1;
	pcktSP.dist2 = dist2;
	pcktSP.method = method;
	if(!sendPacket(socket2server, LPBYTE(&pcktSP), sizeof(pcktSP)))
		return 0xFFFFFFFF;
	if(!getPacket(socket2server, LPBYTE(&pcktSPout), sizeof(pcktSPout)))
		return 0xFFFFFFFF;
	if(pcktSPout.status != SUCCESS)
		return 0xFFFFFFFF;
	return pcktSPout.returnValue;
}
//*********************************
//** client_CloseHandle: simulates client side RPC for CloseHandle
// PRE: socket2server connection is open

bool client_CloseHandle(HANDLE handle)
{
	PCKT_CLOSE_HANDLE_IN pcktCH;
	PCKT_CLOSE_HANDLE_OUT pcktCHout;

	if (!sendControl(socket2server, CLOSE_HANDLE))
		return false;
	pcktCH.handle = handle;
	if(!sendPacket(socket2server, LPBYTE(&pcktCH), sizeof(pcktCH)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktCHout), sizeof(pcktCHout)))
		return false;
	if(pcktCHout.status != SUCCESS)
		return false;
	return true;
}

////
//*********************************
//** client_DeleteFile simulates client side RPC for DeleteFile
// PRE: socket2server connection is open
BOOL client_DeleteFile(LPCTSTR lpFileName)
{
	PCKT_DELETE_FILE_IN pcktDFin;
	PCKT_DELETE_FILE_OUT pcktDFout;

	if (!sendControl(socket2server, DELETE_FILE))
		return false;
	memcpy(pcktDFin.fileName, lpFileName, SIZE_NAME);
	if(!sendPacket(socket2server, LPBYTE(&pcktDFin), sizeof(pcktDFin)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktDFout), sizeof(pcktDFout)))
		return false;
	if(pcktDFout.status != SUCCESS)
		return false;
	return true;
}

//***** SetEndOfFile RPC section
//** client_SetEndOfFile simulates client side RPC for SetEndOfFile
// PRE: socket2server connection is open
BOOL client_SetEndOfFile(HANDLE hFile)
{
	PCKT_SET_END_OF_FILE_IN pcktSEin;
	PCKT_SET_END_OF_FILE_OUT pcktSEout;

	if (!sendControl(socket2server, SET_END_OF_FILE))
		return false;
	pcktSEin.hFile = hFile;
	if(!sendPacket(socket2server, LPBYTE(&pcktSEin), sizeof(pcktSEin)))
		return false;
	if(!getPacket(socket2server, LPBYTE(&pcktSEout), sizeof(pcktSEout)))
		return false;
	if(pcktSEout.status != SUCCESS)
		return false;
	return true;
}

SOCKET connect2server(const char* serverIP)
{
	SOCKADDR_IN serverSockAddr;
	SOCKET socket2server;
	WSADATA Data;
	int status;
	
	status=WSAStartup(MAKEWORD(1, 1), &Data);
	if (status != 0) {
		cerr << "ERROR: WSAStartup unsuccessful" << endl;
		return INVALID_SOCKET;
	}

	socket2server=socket(AF_INET, SOCK_STREAM, 0);
	if (socket2server == INVALID_SOCKET)
	{
		cerr << "ERROR: socket unsuccessful" << endl;
		status=WSACleanup();
		if (status == SOCKET_ERROR)
			cerr << "ERROR: WSACleanup unsuccessful" << endl;
		return INVALID_SOCKET;
	}

	serverSockAddr.sin_addr.s_addr=inet_addr(serverIP);
	serverSockAddr.sin_port=htons(PORT);
	serverSockAddr.sin_family=AF_INET;
	
		
	status=connect(socket2server,
		(LPSOCKADDR) &serverSockAddr,
		sizeof(serverSockAddr));
	if (status == SOCKET_ERROR)
	{
		cerr << "ERROR: connect unsuccessful" << endl;
		status=closesocket(socket2server);
		if (status == SOCKET_ERROR)
			cerr << "ERROR: closesocket unsuccessful"
			<< endl;
		status=WSACleanup();
		if (status == SOCKET_ERROR)
			cerr << "ERROR: WSACleanup unsuccessful"
			<< endl;
		return INVALID_SOCKET;
	}
	return socket2server;
	
}