80d7c256a553a2a426e196219d4f260b9c8691f3
[tpg/acess2.git] / AcessNative / acesskernel_src / server.c
1 /*
2  * Acess2 Native Kernel
3  * - Acess kernel emulation on another OS using SDL and UDP
4  *
5  * Syscall Server
6  */
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <SDL/SDL.h>
11 #ifdef __WIN32__
12 # include <windows.h>
13 # include <winsock.h>
14 #else
15 # include <unistd.h>
16 # include <sys/socket.h>
17 # include <netinet/in.h>
18 #endif
19 #include "../syscalls.h"
20 //#include <debug.h>
21
22 #define USE_TCP 0
23 #define MAX_CLIENTS     16
24
25 // === TYPES ===
26 typedef struct {
27          int    ClientID;
28         SDL_Thread      *WorkerThread;
29         #if USE_TCP
30         #else
31         tRequestHeader  *CurrentRequest;
32         struct sockaddr_in      ClientAddr;
33         SDL_cond        *WaitFlag;
34         SDL_mutex       *Mutex;
35         #endif
36 }       tClient;
37
38 // === IMPORTS ===
39 extern tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength);
40 extern int      Threads_CreateRootProcess(void);
41 extern void     Threads_SetThread(int TID);
42 // HACK: Should have these in a header
43 extern void     Log_Debug(const char *Subsys, const char *Message, ...);
44 extern void     Log_Notice(const char *Subsys, const char *Message, ...);
45
46 // === PROTOTYPES ===
47 tClient *Server_GetClient(int ClientID);
48  int    Server_WorkerThread(void *ClientPtr);
49  int    SyscallServer(void);
50  int    Server_ListenThread(void *Unused);
51
52 // === GLOBALS ===
53 #ifdef __WIN32__
54 WSADATA gWinsock;
55 SOCKET  gSocket = INVALID_SOCKET;
56 #else
57 # define INVALID_SOCKET -1
58  int    gSocket = INVALID_SOCKET;
59 #endif
60 tClient gaServer_Clients[MAX_CLIENTS];
61 SDL_Thread      *gpServer_ListenThread;
62
63 // === CODE ===
64 int Server_GetClientID(void)
65 {
66          int    i;
67         Uint32  thisId = SDL_ThreadID();
68         
69         for( i = 0; i < MAX_CLIENTS; i ++ )
70         {
71                 if( SDL_GetThreadID(gaServer_Clients[i].WorkerThread) == thisId )
72                         return gaServer_Clients[i].ClientID;
73         }
74         
75         fprintf(stderr, "ERROR: Server_GetClientID - Thread is not allocated\n");
76         
77         return 0;
78 }
79
80 tClient *Server_GetClient(int ClientID)
81 {
82         tClient *ret = NULL;
83          int    i;
84         
85         // Allocate an ID if needed
86         if(ClientID == 0)
87                 ClientID = Threads_CreateRootProcess();
88         
89         for( i = 0; i < MAX_CLIENTS; i ++ )
90         {
91                 if( gaServer_Clients[i].ClientID == ClientID ) {
92                         return &gaServer_Clients[i];
93                 }
94                 if(!ret && gaServer_Clients[i].ClientID == 0)
95                         ret = &gaServer_Clients[i];
96         }
97         
98         // Uh oh, no free slots
99         // TODO: Dynamic allocation
100         if( !ret )
101                 return NULL;
102         
103         // Allocate a thread for the process
104         ret->ClientID = ClientID;
105         ret->CurrentRequest = NULL;
106                 
107         if( !ret->WorkerThread ) {
108                 ret->WaitFlag = SDL_CreateCond();
109                 ret->Mutex = SDL_CreateMutex();
110                 SDL_mutexP( ret->Mutex );
111                 ret->WorkerThread = SDL_CreateThread( Server_WorkerThread, ret );
112         }
113         
114         return ret;
115 }
116
117 int Server_WorkerThread(void *ClientPtr)
118 {
119         tClient *Client = ClientPtr;
120         tRequestHeader  *retHeader;
121         tRequestHeader  errorHeader;
122          int    retSize = 0;
123          int    sentSize;
124          int    cur_client_id = 0;
125         
126         #if USE_TCP
127         #else
128         for( ;; )
129         {
130                 // Wait for something to do
131                 while( Client->CurrentRequest == NULL )
132                         SDL_CondWait(Client->WaitFlag, Client->Mutex);
133                 
134                 if(Client->ClientID != cur_client_id) {
135                         Threads_SetThread( Client->ClientID );
136                         cur_client_id = Client->ClientID;
137                 }
138                 
139                 Log_Debug("AcessSrv", "Worker %i takes %p",
140                         Client->ClientID, Client->CurrentRequest);
141                 
142                 // Get the response
143                 retHeader = SyscallRecieve(Client->CurrentRequest, &retSize);
144                 
145                 if( !retHeader ) {
146                         // Return an error to the client
147                         printf("ERROR: SyscallRecieve failed\n");
148                         errorHeader.CallID = Client->CurrentRequest->CallID;
149                         errorHeader.NParams = 0;
150                         retHeader = &errorHeader;
151                         retSize = sizeof(errorHeader);
152                 }
153                 
154                 // Set ID
155                 retHeader->ClientID = Client->ClientID;
156                 
157                 // Mark the thread as ready for another job
158                 Client->CurrentRequest = 0;
159                 
160                 Log_Debug("AcessSrv", "Sending %i to %x:%i (Client %i)",
161                         retSize, ntohl(Client->ClientAddr.sin_addr.s_addr),
162                         ntohs(Client->ClientAddr.sin_port),
163                         Client->ClientID
164                         );
165                 
166                 // Return the data
167                 sentSize = sendto(gSocket, retHeader, retSize, 0,
168                         (struct sockaddr*)&Client->ClientAddr, sizeof(Client->ClientAddr)
169                         );
170                 if( sentSize != retSize ) {
171                         perror("Server_WorkerThread - send");
172                 }
173                 
174                 // Free allocated header
175                 if( retHeader != &errorHeader )
176                         free( retHeader );
177         }
178         #endif
179 }
180
181 int SyscallServer(void)
182 {
183         struct sockaddr_in      server;
184         
185         #ifdef __WIN32__
186         /* Open windows connection */
187         if (WSAStartup(0x0101, &gWinsock) != 0)
188         {
189                 fprintf(stderr, "Could not open Windows connection.\n");
190                 exit(0);
191         }
192         #endif
193         
194         #if USE_TCP
195         // Open TCP Connection
196         gSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
197         #else
198         // Open UDP Connection
199         gSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
200         #endif
201         if (gSocket == INVALID_SOCKET)
202         {
203                 fprintf(stderr, "Could not create socket.\n");
204                 #if __WIN32__
205                 WSACleanup();
206                 #endif
207                 exit(0);
208         }
209         
210         // Set server address
211         memset(&server, 0, sizeof(struct sockaddr_in));
212         server.sin_family = AF_INET;
213         server.sin_port = htons(SERVER_PORT);
214         server.sin_addr.s_addr = htonl(INADDR_ANY);
215         
216         // Bind
217         if( bind(gSocket, (struct sockaddr *)&server, sizeof(struct sockaddr_in)) == -1 )
218         {
219                 fprintf(stderr, "Cannot bind address to socket.\n");
220                 perror("SyscallServer - bind");
221                 #if __WIN32__
222                 closesocket(gSocket);
223                 WSACleanup();
224                 #else
225                 close(gSocket);
226                 #endif
227                 exit(0);
228         }
229         
230         #if USE_TCP
231         listen(gSocket, 5);
232         #endif
233         
234         Log_Notice("AcessSrv", "Listening on 0.0.0.0:%i", SERVER_PORT);
235         gpServer_ListenThread = SDL_CreateThread( Server_ListenThread, NULL );
236         return 0;
237 }
238
239 int Server_ListenThread(void *Unused)
240 {       
241         // Wait for something to do :)
242         for( ;; )
243         {
244                 #if USE_TCP
245                 struct sockaddr_in      client;
246                 uint    clientSize = sizeof(client);
247                  int    clientSock = accept(gSocket, (struct sockaddr*)&client, &clientSize);
248                 if( clientSock < 0 ) {
249                         perror("SyscallServer - accept");
250                         break ;
251                 }
252                 
253                 Log("Client connection %x:%i\n",
254                         ntohl(client.sin_addr), ntohs(client.sin_port)
255                         );
256                 
257                 #else
258                 char    data[BUFSIZ];
259                 tRequestHeader  *req = (void*)data;
260                 struct sockaddr_in      addr;
261                 uint    clientSize = sizeof(addr);
262                  int    length;
263                 tClient *client;
264                 
265                 length = recvfrom(gSocket, data, BUFSIZ, 0, (struct sockaddr*)&addr, &clientSize);
266                 
267                 if( length == -1 ) {
268                         perror("SyscallServer - recv");
269                         break;
270                 }
271                 
272                 // Hand off to a worker thread
273                 // - TODO: Actually have worker threads
274                 printf("%i bytes from %x:%i\n", length,
275                         ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port));
276                 
277                 client = Server_GetClient(req->ClientID);
278                 // NOTE: Hack - Should check if all zero
279                 if( req->ClientID == 0 || client->ClientAddr.sin_port == 0 )
280                 {
281                         memcpy(&client->ClientAddr, &addr, sizeof(addr));
282                 }
283                 else if( memcmp(&client->ClientAddr, &addr, sizeof(addr)) != 0 )
284                 {
285                         printf("ClientID %i used by %x:%i\n",
286                                 client->ClientID, ntohl(addr.sin_addr.s_addr), ntohs(addr.sin_port));
287                         printf(" actually owned by %x:%i\n",
288                                 ntohl(client->ClientAddr.sin_addr.s_addr), ntohs(client->ClientAddr.sin_port));
289                         continue;
290                 }
291                 
292                 if( client->CurrentRequest ) {
293                         printf("Worker thread for %x:%i is busy\n",
294                                 ntohl(client->ClientAddr.sin_addr.s_addr), ntohs(client->ClientAddr.sin_port));
295                         continue;
296                 }
297                 
298                 Log_Debug("AcessSrv", "Message from Client %i (%p)",
299                         client->ClientID, client);
300                 
301                 client->CurrentRequest = req;
302                 SDL_CondSignal(client->WaitFlag);
303                 #endif
304         }
305         return -1;
306 }

UCC git Repository :: git.ucc.asn.au