X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=AcessNative%2Facesskernel_src%2Fserver.c;h=2e3f3a953ea5644900a541c0d9ed8564292b0d04;hb=d047958aaade97d65ed5d5ca6c3835c2699e1010;hp=af33bfd47b47fb60dce560b172eec9c68844a4fa;hpb=9ed2477f5f7e5b01501368719e93259aa336932f;p=tpg%2Facess2.git diff --git a/AcessNative/acesskernel_src/server.c b/AcessNative/acesskernel_src/server.c index af33bfd4..2e3f3a95 100644 --- a/AcessNative/acesskernel_src/server.c +++ b/AcessNative/acesskernel_src/server.c @@ -15,10 +15,12 @@ # include # include # include +# include // inet_ntop #endif #include "../syscalls.h" +//#include -#define USE_TCP 0 +#define USE_TCP 1 #define MAX_CLIENTS 16 // === TYPES === @@ -26,6 +28,7 @@ typedef struct { int ClientID; SDL_Thread *WorkerThread; #if USE_TCP + int Socket; #else tRequestHeader *CurrentRequest; struct sockaddr_in ClientAddr; @@ -36,11 +39,18 @@ typedef struct { // === IMPORTS === extern tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength); +extern int Threads_CreateRootProcess(void); +extern void Threads_SetThread(int TID); +// HACK: Should have these in a header +extern void Log_Debug(const char *Subsys, const char *Message, ...); +extern void Log_Notice(const char *Subsys, const char *Message, ...); +extern void Log_Warning(const char *Subsys, const char *Message, ...); // === PROTOTYPES === tClient *Server_GetClient(int ClientID); int Server_WorkerThread(void *ClientPtr); int SyscallServer(void); + int Server_ListenThread(void *Unused); // === GLOBALS === #ifdef __WIN32__ @@ -50,8 +60,8 @@ SOCKET gSocket = INVALID_SOCKET; # define INVALID_SOCKET -1 int gSocket = INVALID_SOCKET; #endif - int giServer_NextClientID = 1; tClient gaServer_Clients[MAX_CLIENTS]; +SDL_Thread *gpServer_ListenThread; // === CODE === int Server_GetClientID(void) @@ -75,12 +85,17 @@ tClient *Server_GetClient(int ClientID) tClient *ret = NULL; int i; + // Allocate an ID if needed + if(ClientID == 0) + ClientID = Threads_CreateRootProcess(); + for( i = 0; i < MAX_CLIENTS; i ++ ) { if( gaServer_Clients[i].ClientID == ClientID ) { - ret = &gaServer_Clients[i]; - break; + return &gaServer_Clients[i]; } + if(!ret && gaServer_Clients[i].ClientID == 0) + ret = &gaServer_Clients[i]; } // Uh oh, no free slots @@ -88,46 +103,130 @@ tClient *Server_GetClient(int ClientID) if( !ret ) return NULL; - if( ClientID == 0 ) - { - ret->ClientID = giServer_NextClientID ++; - ret->CurrentRequest = NULL; + // Allocate a thread for the process + ret->ClientID = ClientID; + #if USE_TCP + ret->Socket = 0; + #else + ret->CurrentRequest = NULL; + #endif - if( !ret->WorkerThread ) { - ret->WorkerThread = SDL_CreateThread( Server_WorkerThread, ret ); - ret->WaitFlag = SDL_CreateCond(); - ret->Mutex = SDL_CreateMutex(); - SDL_mutexP( ret->Mutex ); - } + if( !ret->WorkerThread ) { + #if USE_TCP + #else + ret->WaitFlag = SDL_CreateCond(); + ret->Mutex = SDL_CreateMutex(); + SDL_mutexP( ret->Mutex ); + #endif + ret->WorkerThread = SDL_CreateThread( Server_WorkerThread, ret ); } - return &gaServer_Clients[i]; + return ret; } int Server_WorkerThread(void *ClientPtr) { tClient *Client = ClientPtr; + + #if USE_TCP + for( ;; ) + { + fd_set fds; + int nfd = Client->Socket; + FD_ZERO(&fds); + FD_SET(Client->Socket, &fds); + + select(nfd, &fds, NULL, NULL, NULL); // TODO: Timeouts? + + if( FD_ISSET(Client->Socket, &fds) ) + { + const int ciMaxParamCount = 6; + char lbuf[sizeof(tRequestHeader) + ciMaxParamCount*sizeof(tRequestValue)]; + tRequestHeader *hdr = (void*)lbuf; + size_t len = recv(Client->Socket, hdr, sizeof(*hdr), 0); + if( len != sizeof(hdr) ) { + // Oops? + } + + if( hdr->NParams > ciMaxParamCount ) { + // Oops. + } + + len = recv(Client->Socket, hdr->Params, hdr->NParams*sizeof(tRequestValue), 0); + if( len != hdr->NParams*sizeof(tRequestValue) ) { + // Oops. + } + + // Get buffer size + size_t hdrsize = sizeof(tRequestHeader) + hdr->NParams*sizeof(tRequestValue); + size_t bufsize = hdrsize; + int i; + for( i = 0; i < hdr->NParams; i ++ ) + { + if( hdr->Params[i].Flags & ARG_FLAG_ZEROED ) + ; + else { + bufsize += hdr->Params[i].Length; + } + } + + // Allocate full buffer + hdr = malloc(bufsize); + memcpy(hdr, lbuf, hdrsize); + len = recv(Client->Socket, hdr->Params + hdr->NParams, bufsize - hdrsize, 0); + if( len != bufsize - hdrsize ) { + // Oops? + } + + int retlen; + tRequestHeader *retHeader; + retHeader = SyscallRecieve(hdr, &retlen); + if( !retHeader ) { + // Some sort of error + } + + send(Client->Socket, retHeader, retlen, 0); + + // Clean up + free(hdr); + } + } + #else tRequestHeader *retHeader; tRequestHeader errorHeader; int retSize = 0; int sentSize; - - #if USE_TCP - #else + int cur_client_id = 0; for( ;; ) { // Wait for something to do while( Client->CurrentRequest == NULL ) SDL_CondWait(Client->WaitFlag, Client->Mutex); - printf("Worker for %i, Job: %p\n", Client->ClientID, Client->CurrentRequest); +// Log_Debug("AcessSrv", "Worker got message %p", Client->CurrentRequest); + + if(Client->ClientID != cur_client_id) { +// Log_Debug("AcessSrv", "Client thread ID changed from %i to %i", +// cur_client_id, Client->ClientID); + Threads_SetThread( Client->ClientID ); + cur_client_id = Client->ClientID; + } + + // Debug + { + int callid = Client->CurrentRequest->CallID; + Log_Debug("AcessSrv", "Client %i request %i %s", + Client->ClientID, callid, + callid < N_SYSCALLS ? casSYSCALL_NAMES[callid] : "UNK" + ); + } // Get the response retHeader = SyscallRecieve(Client->CurrentRequest, &retSize); - + if( !retHeader ) { // Return an error to the client - printf("Error returned by SyscallRecieve\n"); + printf("ERROR: SyscallRecieve failed\n"); errorHeader.CallID = Client->CurrentRequest->CallID; errorHeader.NParams = 0; retHeader = &errorHeader; @@ -138,12 +237,14 @@ int Server_WorkerThread(void *ClientPtr) retHeader->ClientID = Client->ClientID; // Mark the thread as ready for another job + free(Client->CurrentRequest); Client->CurrentRequest = 0; - printf("Sending %i to %x:%i\n", - retSize, ntohl(Client->ClientAddr.sin_addr.s_addr), - ntohs(Client->ClientAddr.sin_port) - ); +// Log_Debug("AcessSrv", "Sending %i to %x:%i (Client %i)", +// retSize, ntohl(Client->ClientAddr.sin_addr.s_addr), +// ntohs(Client->ClientAddr.sin_port), +// Client->ClientID +// ); // Return the data sentSize = sendto(gSocket, retHeader, retSize, 0, @@ -213,32 +314,76 @@ int SyscallServer(void) listen(gSocket, 5); #endif - Log_Notice("Syscall", "Listening on 0.0.0.0:%i\n", SERVER_PORT); - + Log_Notice("AcessSrv", "Listening on 0.0.0.0:%i", SERVER_PORT); + gpServer_ListenThread = SDL_CreateThread( Server_ListenThread, NULL ); + return 0; +} + +int Server_ListenThread(void *Unused) +{ // Wait for something to do :) for( ;; ) { #if USE_TCP - struct sockaddr_in client; - uint clientSize = sizeof(client); - int clientSock = accept(gSocket, (struct sockaddr*)&client, &clientSize); + struct sockaddr_in clientaddr; + socklen_t clientSize = sizeof(clientaddr); + int clientSock = accept(gSocket, (struct sockaddr*)&clientaddr, &clientSize); if( clientSock < 0 ) { perror("SyscallServer - accept"); break ; } + + char addrstr[4*8+8+1]; + inet_ntop(clientaddr.sin_family, &clientaddr.sin_addr, addrstr, sizeof(addrstr)); + Log_Debug("Server", "Client connection %s:%i\n", addrstr, ntohs(clientaddr.sin_port)); - printf("Client connection %x:%i", - ntohl(client.sin_addr), ntohs(client.sin_port) - ); + // Perform auth + size_t len; + tRequestAuthHdr authhdr; + len = recv(clientSock, &authhdr, sizeof(authhdr), 0); + if( len != sizeof(authhdr) ) { + // Some form of error? + } + + tClient *client; + if( authhdr.pid == 0 ) { + // Allocate PID and client structure/thread + client = Server_GetClient(0); + client->Socket = clientSock; + authhdr.pid = client->ClientID; + } + else { + // Get client structure and make sure it's unused + // - Auth token / verifcation? + client = Server_GetClient(authhdr.pid); + if( client->Socket != 0 ) { + Log_Warning("Server", "Client (%i)%p owned by FD%i but %s:%i tried to use it", + authhdr.pid, client, addrstr, clientaddr.sin_port); + authhdr.pid = 0; + } + else { + client->Socket = clientSock; + } + } + len = send(clientSock, &authhdr, sizeof(authhdr), 0); + if( len != sizeof(authhdr) ) { + // Ok, this is an error + perror("Sending auth reply"); + } + + // All done, client thread should be watching now + #else char data[BUFSIZ]; tRequestHeader *req = (void*)data; struct sockaddr_in addr; uint clientSize = sizeof(addr); - int length = recvfrom(gSocket, data, BUFSIZ, 0, (struct sockaddr*)&addr, &clientSize); + int length; tClient *client; + length = recvfrom(gSocket, data, BUFSIZ, 0, (struct sockaddr*)&addr, &clientSize); + if( length == -1 ) { perror("SyscallServer - recv"); break; @@ -246,11 +391,12 @@ int SyscallServer(void) // Hand off to a worker thread // - TODO: Actually have worker threads - printf("%i bytes from %x:%i\n", length, - ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port)); +// Log_Debug("Server", "%i bytes from %x:%i", length, +// ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port)); client = Server_GetClient(req->ClientID); - if( req->ClientID == 0 ) + // NOTE: Hack - Should check if all zero + if( req->ClientID == 0 || client->ClientAddr.sin_port == 0 ) { memcpy(&client->ClientAddr, &addr, sizeof(addr)); } @@ -269,12 +415,15 @@ int SyscallServer(void) continue; } - printf("client = %p, ClientID = %i\n", client, client->ClientID); - +// Log_Debug("AcessSrv", "Message from Client %i (%p)", +// client->ClientID, client); + + // Make a copy of the request data + req = malloc(length); + memcpy(req, data, length); client->CurrentRequest = req; SDL_CondSignal(client->WaitFlag); #endif } - return -1; }