1 #include "ipc.h"

     2 #include "ipcconn.h"

     3 #include "logging.h"

     4 

     5 #include <stdbool.h>

     6 #include <stdlib.h>

     7 

     8 typedef struct _flib_ipc {

     9 	flib_ipcconn connection;

    10 	IpcConnState oldConnState;

    11 

    12 	void (*onConnectCb)(void*);

    13 	void *onConnectCtx;

    14 

    15 	void (*onDisconnectCb)(void*);

    16 	void *onDisconnectCtx;

    17 

    18 	void (*onConfigQueryCb)(void*);

    19 	void *onConfigQueryCtx;

    20 

    21 	void (*onEngineErrorCb)(void*, const uint8_t*);

    22 	void *onEngineErrorCtx;

    23 

    24 	void (*onGameEndCb)(void*, int);

    25 	void *onGameEndCtx;

    26 

    27 	void (*onChatCb)(void*, const uint8_t*, int);

    28 	void *onChatCtx;

    29 

    30 	void (*onEngineMessageCb)(void*, const uint8_t*, int);

    31 	void *onEngineMessageCtx;

    32 

    33 	bool running;

    34 	bool destroyRequested;

    35 } _flib_ipc;

    36 

    37 static void emptyCallback(void* ptr) {}

    38 static void emptyCallback_int(void* ptr, int i) {}

    39 static void emptyCallback_str(void* ptr, const uint8_t* str) {}

    40 static void emptyCallback_str_int(void* ptr, const uint8_t* str, int i) {}

    41 

    42 static void clearCallbacks(flib_ipc ipc) {

    43 	ipc->onConnectCb = &emptyCallback;

    44 	ipc->onDisconnectCb = &emptyCallback;

    45 	ipc->onConfigQueryCb = &emptyCallback;

    46 	ipc->onEngineErrorCb = &emptyCallback_str;

    47 	ipc->onGameEndCb = &emptyCallback_int;

    48 	ipc->onChatCb = &emptyCallback_str_int;

    49 	ipc->onEngineMessageCb = &emptyCallback_str_int;

    50 }

    51 

    52 flib_ipc flib_ipc_create(bool recordDemo, const char *localPlayerName) {

    53 	flib_ipc result = malloc(sizeof(_flib_ipc));

    54 	flib_ipcconn connection = flib_ipcconn_create(recordDemo, localPlayerName);

    55 

    56 	if(!result || !connection) {

    57 		free(result);

    58 		flib_ipcconn_destroy(&connection);

    59 		return NULL;

    60 	}

    61 

    62 	result->connection = connection;

    63 	result->oldConnState = IPC_LISTENING;

    64 	result->running = false;

    65 	result->destroyRequested = false;

    66 

    67 	clearCallbacks(result);

    68 	return result;

    69 }

    70 

    71 void flib_ipc_destroy(flib_ipc *ipcptr) {

    72 	if(!ipcptr || !*ipcptr) {

    73 		return;

    74 	}

    75 	flib_ipc ipc = *ipcptr;

    76 	if(ipc->running) {

    77 		// The function was called from a callback of this ipc connection,

    78 		// so the tick function is still running and we delay the actual

    79 		// destruction. We ensure no further callbacks will be sent to prevent

    80 		// surprises.

    81 		clearCallbacks(ipc);

    82 		ipc->destroyRequested = true;

    83 	} else {

    84 		flib_ipcconn_destroy(&ipc->connection);

    85 		free(ipc);

    86 	}

    87 	*ipcptr = NULL;

    88 }

    89 

    90 void flib_ipc_onConnect(flib_ipc ipc, void (*callback)(void* context), void* context) {

    91 	if(!ipc) {

    92 		flib_log_w("Call to flib_ipc_onConnect with ipc==null");

    93 		return;

    94 	}

    95 	ipc->onConnectCb = callback ? callback : &emptyCallback;

    96 	ipc->onConnectCtx = context;

    97 }

    98 

    99 void flib_ipc_onDisconnect(flib_ipc ipc, void (*callback)(void* context), void* context) {

   100 	if(!ipc) {

   101 		flib_log_w("Call to flib_ipc_onDisconnect with ipc==null");

   102 		return;

   103 	}

   104 	ipc->onDisconnectCb = callback ? callback : &emptyCallback;

   105 	ipc->onDisconnectCtx = context;

   106 }

   107 

   108 void flib_ipc_onConfigQuery(flib_ipc ipc, void (*callback)(void* context), void* context) {

   109 	if(!ipc) {

   110 		flib_log_w("Call to flib_ipc_onConfigQuery with ipc==null");

   111 		return;

   112 	}

   113 	ipc->onConfigQueryCb = callback ? callback : &emptyCallback;

   114 	ipc->onConfigQueryCtx = context;

   115 }

   116 

   117 void flib_ipc_onEngineError(flib_ipc ipc, void (*callback)(void* context, const uint8_t *error), void* context) {

   118 	if(!ipc) {

   119 		flib_log_w("Call to flib_ipc_onEngineError with ipc==null");

   120 		return;

   121 	}

   122 	ipc->onEngineErrorCb = callback ? callback : &emptyCallback_str;

   123 	ipc->onEngineErrorCtx = context;

   124 }

   125 

   126 void flib_ipc_onGameEnd(flib_ipc ipc, void (*callback)(void* context, int gameEndType), void* context) {

   127 	if(!ipc) {

   128 		flib_log_w("Call to flib_ipc_onGameEnd with ipc==null");

   129 		return;

   130 	}

   131 	ipc->onGameEndCb = callback ? callback : &emptyCallback_int;

   132 	ipc->onGameEndCtx = context;

   133 }

   134 

   135 void flib_ipc_onChat(flib_ipc ipc, void (*callback)(void* context, const uint8_t *messagestr, int teamchat), void* context) {

   136 	if(!ipc) {

   137 		flib_log_w("Call to flib_ipc_onChat with ipc==null");

   138 		return;

   139 	}

   140 	ipc->onChatCb = callback ? callback : &emptyCallback_str_int;

   141 	ipc->onChatCtx = context;

   142 }

   143 

   144 void flib_ipc_onEngineMessage(flib_ipc ipc, void (*callback)(void* context, const uint8_t *message, int len), void* context) {

   145 	if(!ipc) {

   146 		flib_log_w("Call to flib_ipc_onEngineMessage with ipc==null");

   147 		return;

   148 	}

   149 	ipc->onEngineMessageCb = callback ? callback : &emptyCallback_str_int;

   150 	ipc->onEngineMessageCtx = context;

   151 }

   152 

   153 static void flib_ipc_wrappedtick(flib_ipc ipc) {

   154 	if(ipc->oldConnState == IPC_NOT_CONNECTED) {

   155 		return;

   156 	}

   157 

   158 	flib_ipcconn_tick(ipc->connection);

   159 	IpcConnState newstate = flib_ipcconn_state(ipc->connection);

   160 	if(ipc->oldConnState == IPC_LISTENING && newstate == IPC_CONNECTED) {

   161 		ipc->oldConnState = newstate;

   162 		ipc->onConnectCb(ipc->onConnectCtx);

   163 	}

   164 

   165 	if(ipc->oldConnState == IPC_CONNECTED) {

   166 		uint8_t msgbuffer[257];

   167 		int len;

   168 		while(!ipc->destroyRequested && (len = flib_ipcconn_recv_message(ipc->connection, msgbuffer))>=0) {

   169 			if(len<2) {

   170 				flib_log_w("Received short message from IPC (<2 bytes)");

   171 				continue;

   172 			}

   173 			msgbuffer[len] = 0;

   174 			flib_log_i("[IPC in] %s", msgbuffer+1);

   175 			switch(msgbuffer[1]) {

   176 			case '?':

   177 				flib_ipcconn_send_messagestr(ipc->connection, "!");

   178 				break;

   179 			case 'C':

   180 				ipc->onConfigQueryCb(ipc->onConfigQueryCtx);

   181 				break;

   182 			case 'E':

   183 				if(len>=3) {

   184 					msgbuffer[len-2] = 0;

   185 					ipc->onEngineErrorCb(ipc->onEngineErrorCtx, msgbuffer+2);

   186 				}

   187 				break;

   188 			case 'i':

   189 				// TODO

   190 				break;

   191 			case 'Q':

   192 				ipc->onGameEndCb(ipc->onGameEndCtx, GAME_END_INTERRUPTED);

   193 				break;

   194 			case 'q':

   195 				ipc->onGameEndCb(ipc->onGameEndCtx, GAME_END_FINISHED);

   196 				break;

   197 			case 'H':

   198 				ipc->onGameEndCb(ipc->onGameEndCtx, GAME_END_HALTED);

   199 				break;

   200 			case 's':

   201 				if(len>=3) {

   202 					msgbuffer[len-2] = 0;

   203 					ipc->onChatCb(ipc->onChatCtx, msgbuffer+2, 0);

   204 				}

   205 				break;

   206 			case 'b':

   207 				if(len>=3) {

   208 					msgbuffer[len-2] = 0;

   209 					ipc->onChatCb(ipc->onChatCtx, msgbuffer+2, 1);

   210 				}

   211 				break;

   212 			default:

   213 				ipc->onEngineMessageCb(ipc->onEngineMessageCtx, msgbuffer, len);

   214 				break;

   215 			}

   216 		}

   217 	}

   218 

   219 	newstate = flib_ipcconn_state(ipc->connection);

   220 	if(newstate == IPC_NOT_CONNECTED) {

   221 		ipc->oldConnState = newstate;

   222 		ipc->onDisconnectCb(ipc->onDisconnectCtx);

   223 	}

   224 }

   225 

   226 int flib_ipc_send_raw(flib_ipc ipc, void *data, size_t len) {

   227 	if(!ipc) {

   228 		flib_log_w("Call to flib_ipc_send_raw with ipc==null");

   229 		return -1;

   230 	}

   231 	return flib_ipcconn_send_raw(ipc->connection, data, len);

   232 }

   233 

   234 int flib_ipc_send_message(flib_ipc ipc, void *data, size_t len) {

   235 	if(!ipc) {

   236 		flib_log_w("Call to flib_ipc_send_message with ipc==null");

   237 		return -1;

   238 	}

   239 	return flib_ipcconn_send_message(ipc->connection, data, len);

   240 }

   241 

   242 int flib_ipc_send_messagestr(flib_ipc ipc, char *data) {

   243 	if(!ipc) {

   244 		flib_log_w("Call to flib_ipc_send_messagestr with ipc==null");

   245 		return -1;

   246 	}

   247 	return flib_ipcconn_send_messagestr(ipc->connection, data);

   248 }

   249 

   250 uint16_t flib_ipc_port(flib_ipc ipc) {

   251 	if(!ipc) {

   252 		flib_log_w("Call to flib_ipc_send_messagestr with ipc==null");

   253 		return 0;

   254 	}

   255 	return flib_ipcconn_port(ipc->connection);

   256 }

   257 

   258 flib_constbuffer flib_ipc_getdemo(flib_ipc ipc) {

   259 	if(!ipc) {

   260 		flib_log_w("Call to flib_ipc_send_messagestr with ipc==null");

   261 		flib_constbuffer result = {NULL, 0};

   262 		return result;

   263 	}

   264 	return flib_ipcconn_getdemo(ipc->connection);

   265 }

   266 

   267 void flib_ipc_tick(flib_ipc ipc) {

   268 	if(!ipc) {

   269 		flib_log_w("Call to flib_ipc_tick with ipc==null");

   270 		return;

   271 	}

   272 	if(ipc->running) {

   273 		flib_log_w("Call to flib_ipc_tick from a callback");

   274 		return;

   275 	}

   276 

   277 	ipc->running = true;

   278 	flib_ipc_wrappedtick(ipc);

   279 	ipc->running = false;

   280 

   281 	if(ipc->destroyRequested) {

   282 		flib_ipc_destroy(&ipc);

   283 	}

   284 }