/*****************************************************
 **
 **  Remote Memory Library - CLIENT
 **
 **  File: MemoryClient.cpp
 **  Author: Marcio S. Pinho e Rafael S. Garcia.
 **  Mail: pinho@inf.pucrs.br,
 **        rafael_sgarcia@terra.com.br
 **  Version: 2.0.
 **
 **  Last Update: 27.January.2003
 **
 *****************************************************/
#include <stdio.h>
#include <conio.h>
#include <winsock.h>

#include "RemoteMemory.h"

// Struct with Server address.
SOCKADDR_IN serverSockAddr;

// Client sockets.
SOCKET MemorySocketIP;
SOCKET MemorySocketUDP;




/************************************************
 ** IsThereAMsg ( SOCKET )
 ************************************************/
BOOL IsThereAMsg ( SOCKET sock ) {
	fd_set socketSet;
	const struct timeval FAR timeout = { 0, 0 };
	int result;

	FD_ZERO ( &socketSet );
	FD_SET ( sock, &socketSet );

	result = select ( 1, &socketSet, NULL, NULL, &timeout );
	if ( FD_ISSET ( sock, &socketSet ) )
		return true;

	return false;
}



/************************************************
 ** CloseConnectionToRemoteMemory ( void )
 ************************************************/
void CloseConnectionToRemoteMemory ( void ) {
	closesocket ( MemorySocketIP );
	closesocket ( MemorySocketUDP );
}



/************************************************
 ** ConnectToRemoteMemory ( *char, unsigned short )
 ************************************************/
int ConnectToRemoteMemory ( char *serverIP, unsigned short port ) {
	if ( !ConnectToRemoteMemoryIP  ( serverIP, port ) ) {
		printf ( "Unable to connect to the Memory Server '%s' on port '%d'!\n", serverIP, port );
		return 0;
	}

	if ( !ConnectToRemoteMemoryUDP ( serverIP, port + 1 ) ) {
		printf ( "Unable to connect to the Memory Server '%s' on port '%d'!\n", serverIP, port );
		return 0;
	}

	printf ( "Successfully connected to the server!\n" );
	return 1;
}





/************************************************
 ** Remote Memory IP Client Functions
 ************************************************/


/************************************************
 ** ConnectToTheServerIP ( *char, unsigned short )
 ************************************************/
SOCKET ConnectToTheServerIP ( char *serverName, unsigned short portNum ) { 	
	char myName[265];
	HOSTENT *hostent;
	WSAData info;

	SOCKET clientSocket;
	SOCKADDR_IN socketAddr;

	WORD socketVersion = MAKEWORD ( 1, 1 );

	// Setup the socket library version.
	if ( WSAStartup ( socketVersion, &info ) == SOCKET_ERROR ) {
		printf ( "Couldn't initialize the socket library.\n" );
		exit (1);
	}

	// Check the library version.
	if ( info.wVersion != socketVersion ) {
		fprintf ( stderr, "Couldn't initialize the socket library.\n" );
		exit (1);
	}

	// clear the address struct.
	memset ( &socketAddr, 0, sizeof ( struct sockaddr_in ) );

	int result = gethostname ( myName, sizeof ( myName ) );
	if ( result == WSANOTINITIALISED )
		printf ( "Socket library wasn't correctly initialized.\n" );

	// Check our own address.
	hostent = gethostbyname ( serverName );
	if ( hostent == NULL )
		return INVALID_SOCKET;

	memset ( &socketAddr, 0, sizeof ( socketAddr ) );
	memcpy ( (char *)&socketAddr.sin_addr, hostent->h_addr, hostent->h_length );
	socketAddr.sin_family = AF_INET;
	socketAddr.sin_addr = *((LPIN_ADDR)*hostent ->h_addr_list);
	socketAddr.sin_port = htons ( portNum );

	// Create the client socket.
	clientSocket = socket ( AF_INET, SOCK_STREAM, 0 );
	if ( clientSocket == INVALID_SOCKET )
		return INVALID_SOCKET;

	// Connect to the server.
	if ( connect ( clientSocket, ( struct sockaddr * )&socketAddr, sizeof ( socketAddr ) ) == SOCKET_ERROR ) {
		closesocket ( clientSocket );
		return INVALID_SOCKET;
	}

	return clientSocket;
}



/************************************************
 ** SendMessageIP ( SOCKET, *char, int )
 ************************************************/
void SendMessageIP ( SOCKET sock, char *buf, int numBytes ) {
	int result = send ( sock, buf, numBytes, 0 );
}



/************************************************
 ** ReceiveMessageIP ( SOCKET, *char, int )
 ************************************************/
void ReceiveMessageIP ( SOCKET sock, char *buf, int numBytes ) {
	memset ( buf, 0, numBytes );
	int result = recv ( sock, buf, numBytes, 0 );
	if ( result == SOCKET_ERROR ) {
		printf ( "Error reading socket number %d\n", sock );
		exit (1);
	}
}



/************************************************
 ** WriteOnRemoteMemoryIP ( *void, WORD, int )
 ************************************************/
void WriteOnRemoteMemoryIP ( void *message, WORD address, int size ) {
	TMSG Package;

	if ( size > MAX_BUFF_SIZE) {
		printf ( "Error in 'WriteOnRemoteMemory': The maximum message size is %d.\n", MAX_BUFF_SIZE );
		exit (1);
	}

	Package.operation = REMOTE_MEMORY_WRITE;
	Package.address = address;
	Package.nbytes = size;
	memcpy ( Package.data, message, size );
	
	SendMessageIP ( MemorySocketIP, ( char * )&Package, sizeof ( TMSG ) );
}



/************************************************
 ** ReadFromRemoteMemoryIP ( *void, WORD, int )
 ************************************************/
void ReadFromRemoteMemoryIP ( void *message, WORD address, int size ) {
	TMSG Package;

	// Message size error.
	if ( size > MAX_BUFF_SIZE ) {
		printf ( "Error in 'ReadFromRemoteMemory': The maximum message size is %d.\n", MAX_BUFF_SIZE );
		exit (1);
	}

	// Set the package components.
	Package.operation = REMOTE_MEMORY_READ;
	Package.address = address;
	Package.nbytes = size;
	memcpy ( Package.data, message, size );
	
	// Send Message.
	SendMessageIP ( MemorySocketIP, ( char * )&Package, sizeof ( TMSG ) );

	// Wait for reply.
	do {
		if ( IsThereAMsg ( MemorySocketIP ) ) {
			ReceiveMessageIP ( MemorySocketIP, ( char * )&Package, sizeof ( TMSG ) );
			break;
		}
	} while ( true );
	

	// Check operation error.
	if ( Package.operation != REMOTE_MEMORY_REPLY ) {
		printf ( "Error Message reply.\n" );
		exit (1);
	}

	// Set the received data.
	memcpy ( message, Package.data, size );
}



/************************************************
 ** ConnectToRemoteMemoryIP ( *char, unsigned short )
 ************************************************/
BOOL ConnectToRemoteMemoryIP ( char *serverIP, unsigned short port ) {
	MemorySocketIP = ConnectToTheServerIP ( serverIP, port );
	if ( MemorySocketIP == INVALID_SOCKET )
		return false;
	return true;
}





/************************************************
 ** Remote Memory UDP Client Functions
 ************************************************/


/************************************************
 ** ConnectToTheServerUDP ( *char, unsigned short )
 ************************************************/
SOCKET ConnectToTheServerUDP ( char *serverName, unsigned short portNum ) {
	char myName[265];
	HOSTENT *hostent;
	WSAData info;

	SOCKET clientSocket;
	SOCKADDR_IN socketAddr;

	WORD socketVersion = MAKEWORD ( 1, 1 );

	// Setup the socket library version.
	if ( WSAStartup ( socketVersion, &info ) == SOCKET_ERROR ) {
		printf ( "Couldn't initialize the socket library.\n" );
		exit (1);
	}

	// Check the library version.
	if ( info.wVersion != socketVersion ) {
		fprintf ( stderr, "Couldn't initialize the socket library.\n" );
		exit (1);
	}

	// clear the address struct.
	memset ( &socketAddr, 0, sizeof ( struct sockaddr_in ) );

	int result = gethostname ( myName, sizeof ( myName ) );
	if ( result == WSANOTINITIALISED )
		printf ( "Socket library wasn't correctly initialized.\n" );

	// Check our own address.
	hostent = gethostbyname ( serverName );
	if ( hostent == NULL )
		return INVALID_SOCKET;

	// Set the server address.
	serverSockAddr.sin_family = hostent->h_addrtype;
	memcpy ( (char *) &serverSockAddr.sin_addr.s_addr, hostent->h_addr_list[0], hostent->h_length );
	serverSockAddr.sin_port = htons( portNum );

	// Create the client socket.
	clientSocket = socket ( AF_INET, SOCK_DGRAM, 0 );
	if ( clientSocket == INVALID_SOCKET )
		return INVALID_SOCKET;

	socketAddr.sin_family = AF_INET;
	socketAddr.sin_addr.s_addr = htonl (INADDR_ANY);
	socketAddr.sin_port = htons (0);
  
	// Bind the socket.
	result = bind ( clientSocket, (struct sockaddr *)&socketAddr, sizeof(socketAddr) );
	if ( result < 0 )
		return INVALID_SOCKET;

	return clientSocket;
}



/************************************************
 ** SendMessageUDP ( SOCKET, *char, numBytes )
 ************************************************/
void SendMessageUDP ( SOCKET sock, char *buf, int numBytes ) {
	int result = sendto ( 
		sock, buf, numBytes, 0, ( struct sockaddr * )&serverSockAddr, sizeof ( serverSockAddr ) 
	);
}



/************************************************
 ** ReceiveMessageUDP ( SOCKET, *char, numBytes )
 ************************************************/
void ReceiveMessageUDP ( SOCKET sock, char *buf, int numBytes ) {
	memset ( buf, 0, numBytes );
	
	SOCKADDR_IN sockAddr;
	int length = sizeof ( sockAddr ); 
	int result = recvfrom ( sock, buf, numBytes, 0, ( struct sockaddr * )&sockAddr, &length );

	if ( result == SOCKET_ERROR ) {
		printf ( "Error reading UDP socket number %d\n", sock );
		exit (1);
	}
}



/************************************************
 ** WriteOnRemoteMemoryUDP ( *void, WORD, int )
 ************************************************/
void WriteOnRemoteMemoryUDP ( void *message, WORD address, int size ) {
	TMSG Package;
	if ( size > MAX_BUFF_SIZE ) {
		printf ( "Error in 'WriteOnRemoteMemory': The maximum message size is %d.\n", MAX_BUFF_SIZE );
		exit (1);
	}

	Package.operation = REMOTE_MEMORY_WRITE;
	Package.address = address;
	Package.nbytes = size;
	memcpy ( Package.data, message, size );

	SendMessageUDP ( MemorySocketUDP, ( char * )&Package, sizeof ( TMSG ) );
}



/************************************************
 ** ReadFromRemoteMemoryUDP ( *void, WORD, int )
 ************************************************/
void ReadFromRemoteMemoryUDP ( void *message, WORD address, int size ) {
	TMSG Package;

	// Message size error.
	if ( size > MAX_BUFF_SIZE ) {
		printf ( "Error in 'ReadFromRemoteMemory': The maximum message size is %d.\n", MAX_BUFF_SIZE );
		exit (1);
	}

	// Set the package components.
	Package.operation = REMOTE_MEMORY_READ;
	Package.address = address;
	Package.nbytes = size;
	memcpy ( Package.data, message, size );

	// Send message.
	SendMessageUDP ( MemorySocketUDP, (char *)&Package, sizeof (TMSG) );

	// Wait for reply.
	do {
		if ( IsThereAMsg ( MemorySocketUDP ) ) {
			ReceiveMessageUDP ( MemorySocketUDP, (char *)&Package, sizeof ( TMSG ) );
			break;
		}
	} while ( true );

	// Check operation error.
	if ( Package.operation != REMOTE_MEMORY_REPLY ) {
		printf ( "Error Message reply\n" );
		exit (1);
	}

	// Set the received data.
	memcpy ( message, Package.data, size );
}



/************************************************
 ** ConnectToRemoteMemoryUDP ( *char, unsigned short )
 ************************************************/
BOOL ConnectToRemoteMemoryUDP ( char *serverIP, unsigned short port ) {
	MemorySocketUDP = ConnectToTheServerUDP ( serverIP, port );
	if ( MemorySocketUDP == INVALID_SOCKET ) 
		return false;
	return true;
}