1 #include "frontlib.h"

     2 #include "logging.h"

     3 

     4 #include <SDL.h>

     5 #include <SDL_net.h>

     6 #include <stdio.h>

     7 #include <stdint.h>

     8 #include <stdlib.h>

     9 #include <time.h>

    10 

    11 static int flib_initflags;

    12 static TCPsocket ipcListenSocket;

    13 static int ipcPort;

    14 static uint8_t ipcReadBuffer[256];

    15 static int ipcReadBufferSize;

    16 

    17 static TCPsocket ipcConnSocket;

    18 static SDLNet_SocketSet ipcConnSocketSet;

    19 

    20 static TCPsocket serverConnSocket;

    21 static SDLNet_SocketSet serverConnSocketSet;

    22 

    23 

    24 #include <time.h>

    25 void flib_logtime() {

    26     time_t timer;

    27     char buffer[25];

    28     struct tm* tm_info;

    29 

    30     time(&timer);

    31     tm_info = localtime(&timer);

    32 

    33     strftime(buffer, 25, "%H:%M:%S", tm_info);

    34     printf("%s", buffer);

    35 }

    36 

    37 int flib_init(int flags) {

    38 	flib_initflags = flags;

    39 	ipcListenSocket = NULL;

    40 	ipcConnSocket = NULL;

    41 	serverConnSocket = NULL;

    42 	ipcReadBufferSize = 0;

    43 

    44 	if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

    45 		if(SDL_Init(0)==-1) {

    46 		    flib_log_e("Error in SDL_Init: %s\n", SDL_GetError());

    47 		    return -1;

    48 		}

    49 	}

    50 

    51 	if(SDLNet_Init()==-1) {

    52 		flib_log_e("Error in SDLNet_Init: %s\n", SDLNet_GetError());

    53 		if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

    54 			SDL_Quit();

    55 		}

    56 		return -1;

    57 	}

    58 

    59 	ipcConnSocketSet = SDLNet_AllocSocketSet(1);

    60 	serverConnSocketSet = SDLNet_AllocSocketSet(1);

    61 	return 0;

    62 }

    63 

    64 /**

    65  * Free resources associated with the library. Call this function once

    66  * the library is no longer needed. You can re-initialize the library by calling

    67  * flib_init again.

    68  */

    69 void flib_quit() {

    70 	// TODO: Send a "quit" message first?

    71 	SDLNet_FreeSocketSet(ipcConnSocketSet);

    72 	SDLNet_FreeSocketSet(serverConnSocketSet);

    73 

    74 	if(ipcListenSocket) {

    75 		SDLNet_TCP_Close(ipcListenSocket);

    76 		ipcListenSocket = NULL;

    77 	}

    78 	if(ipcConnSocket) {

    79 		SDLNet_TCP_Close(ipcConnSocket);

    80 		ipcConnSocket = NULL;

    81 	}

    82 	if(serverConnSocket) {

    83 		SDLNet_TCP_Close(serverConnSocket);

    84 		serverConnSocket = NULL;

    85 	}

    86 

    87 	SDLNet_Quit();

    88 	if(!(flib_initflags | FRONTLIB_SDL_ALREADY_INITIALIZED)) {

    89 		SDL_Quit();

    90 	}

    91 }

    92 

    93 /**

    94  * Start listening for a connection from the engine, if we are not listening already.

    95  * Returns the port we are listening on, which needs to be passed to the engine,

    96  * or -1 if there is an error.

    97  *

    98  * We stop listening once a connection has been established, so if you want to start

    99  * the engine again and talk to it you need to call this function again after the old

   100  * connection is closed.

   101  */

   102 int flib_ipc_listen() {

   103 	if(ipcListenSocket) {

   104 		return ipcPort;

   105 	}

   106 	IPaddress addr;

   107 	addr.host = INADDR_ANY;

   108 

   109 	/* SDL_net does not seem to have a way to listen on a random unused port

   110 	   and find out which port that is, so let's try to find one ourselves. */

   111 	// TODO: Is socket binding fail-fast on all platforms?

   112 	srand(time(NULL));

   113 	rand();

   114 	for(int i=0; i<1000; i++) {

   115 		// IANA suggests using ports in the range 49152-65535 for things like this

   116 		ipcPort = 49152+(rand()%(65535-49152));

   117 		SDLNet_Write16(ipcPort, &addr.port);

   118 		flib_log_i("Attempting to listen on port %i...\n", ipcPort);

   119 		ipcListenSocket = SDLNet_TCP_Open(&addr);

   120 		if(!ipcListenSocket) {

   121 			flib_log_w("Unable to listen on port %i: %s\n", ipcPort, SDLNet_GetError());

   122 		} else {

   123 			flib_log_i("ok.\n");

   124 			return ipcPort;

   125 		}

   126 	}

   127 	flib_log_e("Unable to find a usable IPC port.");

   128 	return -1;

   129 }

   130 

   131 void flib_accept_ipc() {

   132 	if(!ipcListenSocket) {

   133 		flib_log_e("Attempt to accept IPC connection while not listening.");

   134 		return;

   135 	}

   136 	do {

   137 		TCPsocket sock = SDLNet_TCP_Accept(ipcListenSocket);

   138 		if(!sock) {

   139 			// No incoming connections

   140 			return;

   141 		}

   142 		// Check if it is a local connection

   143 		IPaddress *addr = SDLNet_TCP_GetPeerAddress(sock);

   144 		uint32_t numip = SDLNet_Read32(&addr->host);

   145 		if(numip != (uint32_t)((127UL<<24)+1)) { // 127.0.0.1

   146 			flib_log_w("Rejected IPC connection attempt from %s\n", flib_format_ip(numip));

   147 		} else {

   148 			ipcConnSocket = sock;

   149 			SDLNet_AddSocket(ipcConnSocketSet, (SDLNet_GenericSocket)ipcConnSocket);

   150 			SDLNet_TCP_Close(ipcListenSocket);

   151 			ipcListenSocket = NULL;

   152 		}

   153 	} while(!ipcConnSocket);

   154 	return;

   155 }

   156 

   157 /**

   158  * Receive a single message and copy it into the data buffer.

   159  * Returns the length of the received message, -1 when nothing is received.

   160  */

   161 int flib_engine_read_message(void *data) {

   162 	if(!ipcConnSocket && ipcListenSocket) {

   163 		flib_accept_ipc();

   164 	}

   165 

   166 	if(ipcConnSocket && SDLNet_CheckSockets(ipcConnSocketSet, 0)>0) {

   167 		int size = SDLNet_TCP_Recv(ipcConnSocket, ipcReadBuffer+ipcReadBufferSize, sizeof(ipcReadBuffer)-ipcReadBufferSize);

   168 		if(size>0) {

   169 			ipcReadBufferSize += size;

   170 		} else {

   171 			SDLNet_DelSocket(ipcConnSocketSet, (SDLNet_GenericSocket)ipcConnSocket);

   172 			SDLNet_TCP_Close(ipcConnSocket);

   173 			ipcConnSocket = NULL;

   174 			// TODO trigger "IPC disconnect" event, possibly delayed until after the messages are processed

   175 		}

   176 	}

   177 

   178 	int msgsize = ipcReadBuffer[0];

   179 	if(ipcReadBufferSize > msgsize) {

   180 		memcpy(data, ipcReadBuffer+1, msgsize);

   181 		memmove(ipcReadBuffer, ipcReadBuffer+msgsize+1, ipcReadBufferSize-(msgsize+1));

   182 		ipcReadBufferSize -= (msgsize+1);

   183 		return msgsize;

   184 	} else if(!ipcConnSocket && ipcReadBufferSize>0) {

   185 		flib_log_w("Last message from engine data stream is incomplete (received %u of %u bytes)", ipcReadBufferSize-1, msgsize);

   186 		ipcReadBufferSize = 0;

   187 		return -1;

   188 	} else {

   189 		return -1;

   190 	}

   191 }

   192 

   193 void flib_engine_write_message(void *data, size_t len) {

   194 	uint8_t sendbuf[256];

   195 	if(len>255) {

   196 		flib_log_e("Attempt to send too much data to the engine in a single message.");

   197 		return;

   198 	}

   199 	sendbuf[0] = len;

   200 	memcpy(sendbuf+1, data, len);

   201 	SDLNet_TCP_Send(ipcConnSocket, sendbuf, len+1);

   202 }

   203 

   204 int main(int argc, char *argv[]) {

   205 	flib_init(0);

   206 	int port = flib_ipc_listen();

   207 	printf("%i", port);

   208 	fflush(stdout);

   209 	char data[256];

   210 	while(ipcListenSocket||ipcConnSocket) {

   211 		int size = flib_engine_read_message(data);

   212 		if(size>0) {

   213 			if(data[0]=='?') {

   214 				flib_engine_write_message("!", 1);

   215 			}

   216 		}

   217 	}

   218 	return 0;

   219 }