1 #include "ipc.h"

     2 #include "ipc/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 	if(ipc->oldConnState == IPC_LISTENING) {

   159 		flib_ipcconn_accept(ipc->connection);

   160 		if(flib_ipcconn_state(ipc->connection) == IPC_CONNECTED) {

   161 			ipc->oldConnState = IPC_CONNECTED;

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

   163 		}

   164 	}

   165 

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

   167 		uint8_t msgbuffer[257];

   168 		int len;

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

   170 			if(len<2) {

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

   172 				continue;

   173 			}

   174 			msgbuffer[len] = 0;

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

   176 			switch(msgbuffer[1]) {

   177 			case '?':

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

   179 				break;

   180 			case 'C':

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

   182 				break;

   183 			case 'E':

   184 				if(len>=3) {

   185 					msgbuffer[len-2] = 0;

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

   187 				}

   188 				break;

   189 			case 'i':

   190 				// TODO

   191 				break;

   192 			case 'Q':

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

   194 				break;

   195 			case 'q':

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

   197 				break;

   198 			case 'H':

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

   200 				break;

   201 			case 's':

   202 				if(len>=3) {

   203 					msgbuffer[len-2] = 0;

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

   205 				}

   206 				break;

   207 			case 'b':

   208 				if(len>=3) {

   209 					msgbuffer[len-2] = 0;

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

   211 				}

   212 				break;

   213 			default:

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

   215 				break;

   216 			}

   217 		}

   218 	}

   219 

   220 	if(flib_ipcconn_state(ipc->connection) == IPC_NOT_CONNECTED) {

   221 		ipc->oldConnState = IPC_NOT_CONNECTED;

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

   223 	}

   224 }

   225 

   226 void flib_ipc_tick(flib_ipc ipc) {

   227 	if(!ipc) {

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

   229 		return;

   230 	}

   231 	if(ipc->running) {

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

   233 		return;

   234 	}

   235 

   236 	ipc->running = true;

   237 	flib_ipc_wrappedtick(ipc);

   238 	ipc->running = false;

   239 

   240 	if(ipc->destroyRequested) {

   241 		flib_ipc_destroy(&ipc);

   242 	}

   243 }

   244 

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

   246 	if(!ipc) {

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

   248 		return -1;

   249 	}

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

   251 }

   252 

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

   254 	if(!ipc) {

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

   256 		return -1;

   257 	}

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

   259 }

   260 

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

   262 	if(!ipc) {

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

   264 		return -1;

   265 	}

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

   267 }

   268 

   269 uint16_t flib_ipc_port(flib_ipc ipc) {

   270 	if(!ipc) {

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

   272 		return 0;

   273 	}

   274 	return flib_ipcconn_port(ipc->connection);

   275 }

   276 

   277 flib_constbuffer flib_ipc_getdemo(flib_ipc ipc) {

   278 	if(!ipc) {

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

   280 		flib_constbuffer result = {NULL, 0};

   281 		return result;

   282 	}

   283 	return flib_ipcconn_getrecord(ipc->connection, false);

   284 }