static bool _mPerfRunServer(const char* listen, const struct mArguments* args, const struct PerfOpts* perfOpts) {
SocketSubsystemInit();
Socket server = SocketOpenTCP(7216, NULL);
if (SOCKET_FAILED(server)) {
SocketSubsystemDeinit();
return false;
}
if (SOCKET_FAILED(SocketListen(server, 0))) {
SocketClose(server);
SocketSubsystemDeinit();
return false;
}
_socket = SocketAccept(server, NULL);
if (perfOpts->csv) {
const char* header = "game_code,frames,duration,renderer\n";
SocketSend(_socket, header, strlen(header));
}
char path[PATH_MAX];
while (SocketRecv(_socket, path, sizeof(path)) > 0) {
char* nl = strchr(path, '\n');
if (nl == path) {
break;
}
if (nl) {
nl[0] = '\0';
}
if (!_mPerfRunCore(path, args, perfOpts)) {
break;
}
}
SocketClose(_socket);
SocketClose(server);
SocketSubsystemDeinit();
return true;
}
void GDBStubUpdate(struct GDBStub* stub) {
if (stub->socket == INVALID_SOCKET) {
if (stub->d.state == DEBUGGER_PAUSED) {
stub->d.state = DEBUGGER_RUNNING;
}
return;
}
if (stub->connection == INVALID_SOCKET) {
if (stub->shouldBlock) {
Socket reads = stub->socket;
SocketPoll(1, &reads, 0, 0, SOCKET_TIMEOUT);
}
stub->connection = SocketAccept(stub->socket, 0);
if (!SOCKET_FAILED(stub->connection)) {
if (!SocketSetBlocking(stub->connection, false)) {
goto connectionLost;
}
mDebuggerEnter(&stub->d, DEBUGGER_ENTER_ATTACHED, 0);
} else if (SocketWouldBlock()) {
return;
} else {
goto connectionLost;
}
}
while (true) {
if (stub->shouldBlock) {
Socket reads = stub->connection;
SocketPoll(1, &reads, 0, 0, SOCKET_TIMEOUT);
}
ssize_t messageLen = SocketRecv(stub->connection, stub->line, GDB_STUB_MAX_LINE - 1);
if (messageLen == 0) {
goto connectionLost;
}
if (messageLen == -1) {
if (SocketWouldBlock()) {
return;
}
goto connectionLost;
}
stub->line[messageLen] = '\0';
mLOG(DEBUGGER, DEBUG, "< %s", stub->line);
ssize_t position = 0;
while (position < messageLen) {
position += _parseGDBMessage(stub, &stub->line[position]);
}
}
connectionLost:
mLOG(DEBUGGER, WARN, "Connection lost");
GDBStubHangup(stub);
}
int main( int argc,char * argv[] )
{
crypt_buffer_ctx ctx ;
crypt_buffer_result r ;
ssize_t n ;
char * encryption_key ;
size_t encryption_key_length ;
int network_port = PORT_NUMBER ;
const char * network_address = NETWORK_ADDRESS ;
socket_t c ;
char * e ;
#define buffer_size sizeof( zuluKey_t ) * 2
char buffer[ buffer_size ] ;
socket_t s ;
struct sigaction sa ;
if( argc < 2 ){
puts( "error: invalid number of arguments" ) ;
return 1 ;
}else if( argc >= 4 ){
network_address = *( argv + 2 ) ;
network_port = atoi( *( argv + 3 ) ) ;
}
memset( &sa,'\0',sizeof( struct sigaction ) ) ;
sa.sa_handler = _closeServer ;
sigaction( SIGTERM,&sa,NULL ) ;
e = *( argv + 1 ) ;
encryption_key_length = strlen( e ) ;
encryption_key = malloc( sizeof( char ) * encryption_key_length ) ;
memcpy( encryption_key,e,encryption_key_length ) ;
memset( e,'\0',encryption_key_length ) ;
s = SocketNet( network_address,network_port ) ;
_clean_on_exit.s = s ;
_clean_on_exit.buffer = encryption_key ;
_clean_on_exit.buffer_length = encryption_key_length ;
_debug( "server started" ) ;
if( !SocketBind( s ) ){
return _exitServer( "socket bind failed" ) ;
}
if( !SocketListen( s ) ){
return _exitServer( "socket listen failed" ) ;
}
if( crypt_buffer_init( &ctx,encryption_key,encryption_key_length ) ){
_clean_on_exit.ctx = ctx ;
while( 1 ){
c = SocketAccept( s ) ;
n = SocketGetData_3( c,buffer,buffer_size,4 ) ;
if( n != -1 ){
if( crypt_buffer_decrypt( ctx,buffer,n,&r ) ){
_process_request( c,ctx,&r ) ;
}else{
_debug( "failed to decrypt data" ) ;
}
}else{
_debug( "network timed out" ) ;
}
SocketClose( &c ) ;
}
}else{
_debug( "failed to initialize encryption routine" ) ;
}
return 0 ;
}
