Usermode/Build - Updates to build system for crtbegin/crtend
[tpg/acess2.git] / Usermode / Applications / axwin3_src / WM / ipc.c
1 /*
2  * Acess2 GUI (AxWin) Version 3
3  * - By John Hodge (thePowersGang)
4  * 
5  * ipc.c
6  * - Interprocess communication
7  */
8 #include <common.h>
9 #include <acess/sys.h>
10 #include <net.h>
11 #include <string.h>
12 #include <ipcmessages.h>
13 #include <stdio.h>
14 #include <wm.h>
15 #include <wm_internals.h>
16
17 #define AXWIN_PORT      4101
18
19 #define STATICBUF_SIZE  64
20 #define MAX_WINDOWS_PER_APP     128
21
22 // === TYPES ===
23 typedef struct sIPC_Type        tIPC_Type;
24
25 struct sIPC_Type
26 {
27          int    (*GetIdentSize)(const void *Ident);
28          int    (*CompareIdent)(const void *Ident1, const void *Ident2);
29         void    (*SendMessage)(const void *Ident, size_t Length, const void *Data);
30 };
31
32 struct sIPC_Client
33 {
34         const tIPC_Type *IPCType;
35         const void      *Ident; // Stored after structure
36
37          int    nWindows;
38         tWindow **Windows;
39 };
40
41 // === IMPORTS ===
42 extern tWindow  *gpWM_FocusedWindow;    // Needed for _FocusWindow
43
44 // === PROTOTYPES ===
45 void    IPC_Init(void);
46 void    IPC_FillSelect(int *nfds, fd_set *set);
47 void    IPC_HandleSelect(fd_set *set);
48  int    IPC_Type_Datagram_GetSize(const void *Ident);
49  int    IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2);
50 void    IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data);
51  int    IPC_Type_Sys_GetSize(const void *Ident);
52  int    IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2);
53 void    IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data);
54 void    IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg);
55
56 // === GLOBALS ===
57 const tIPC_Type gIPC_Type_Datagram = {
58         IPC_Type_Datagram_GetSize,
59         IPC_Type_Datagram_Compare, 
60         IPC_Type_Datagram_Send
61 };
62 const tIPC_Type gIPC_Type_SysMessage = {
63         IPC_Type_Sys_GetSize,
64         IPC_Type_Sys_Compare,
65         IPC_Type_Sys_Send
66 };
67  int    giNetworkFileHandle = -1;
68  int    giMessagesFileHandle = -1;
69  int    giIPC_ClientCount;
70 tIPC_Client     **gIPC_Clients;
71
72 // === CODE ===
73 void IPC_Init(void)
74 {
75          int    tmp;
76         // TODO: Check this
77         giNetworkFileHandle = open("/Devices/ip/loop/udp", OPENFLAG_READ);
78         tmp = AXWIN_PORT;       ioctl(giNetworkFileHandle, 4, &tmp);    // TODO: Don't hard-code IOCtl number
79 }
80
81 void IPC_FillSelect(int *nfds, fd_set *set)
82 {
83         if( giNetworkFileHandle > *nfds )       *nfds = giNetworkFileHandle;
84         FD_SET(giNetworkFileHandle, set);
85 }
86
87 void IPC_HandleSelect(fd_set *set)
88 {
89         if( FD_ISSET(giNetworkFileHandle, set) )
90         {
91                 char    staticBuf[STATICBUF_SIZE];
92                  int    readlen, identlen;
93                 char    *msg;
94
95                 readlen = read(giNetworkFileHandle, staticBuf, sizeof(staticBuf));
96                 
97                 identlen = 4 + Net_GetAddressSize( ((uint16_t*)staticBuf)[1] );
98                 msg = staticBuf + identlen;
99
100                 IPC_Handle(&gIPC_Type_Datagram, staticBuf, readlen - identlen, (void*)msg);
101 //              _SysDebug("IPC_HandleSelect: UDP handled");
102         }
103
104         while(SysGetMessage(NULL, NULL))
105         {
106                 pid_t   tid;
107                  int    len = SysGetMessage(&tid, NULL);
108                 char    data[len];
109                 SysGetMessage(NULL, data);
110
111                 IPC_Handle(&gIPC_Type_SysMessage, &tid, len, (void*)data);
112 //              _SysDebug("IPC_HandleSelect: Message handled");
113         }
114 }
115
116 int IPC_Type_Datagram_GetSize(const void *Ident)
117 {
118         return 4 + Net_GetAddressSize( ((const uint16_t*)Ident)[1] );
119 }
120
121 int IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2)
122 {
123         // Pass the buck :)
124         // - No need to worry about mis-matching sizes, as the size is computed
125         //   from the 3rd/4th bytes, hence it will differ before the size is hit.
126         return memcmp(Ident1, Ident2, IPC_Type_Datagram_GetSize(Ident1));
127 }
128
129 void IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data)
130 {
131          int    identlen = IPC_Type_Datagram_GetSize(Ident);
132         char    tmpbuf[ identlen + Length ];
133         memcpy(tmpbuf, Ident, identlen);        // Header
134         memcpy(tmpbuf + identlen, Data, Length);        // Data
135         // TODO: Handle fragmented packets
136         write(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf));
137 }
138
139 int IPC_Type_Sys_GetSize(const void *Ident)
140 {
141         return sizeof(pid_t);
142 }
143
144 int IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2)
145 {
146         return *(const tid_t*)Ident1 - *(const tid_t*)Ident2;
147 }
148
149 void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data)
150 {
151         SysSendMessage( *(const tid_t*)Ident, Length, Data );
152 }
153
154 // --- Client -> Window Mappings
155 int _CompareClientPtrs(const void *_a, const void *_b)
156 {
157         tIPC_Client     *a = *(tIPC_Client**)_a;
158         tIPC_Client     *b = *(tIPC_Client**)_b;
159         
160         if(a->IPCType < b->IPCType)     return -1;
161         if(a->IPCType > b->IPCType)     return 1;
162         
163         return a->IPCType->CompareIdent(a->Ident, b->Ident);
164 }
165
166 tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident)
167 {
168          int    pos = 0;        // Position where the new client will be inserted
169          int    ident_size;
170         tIPC_Client     *ret;
171
172         // - Search list of registered clients
173         if(giIPC_ClientCount > 0)
174         {
175                 tIPC_Client     target;
176                  int    div;
177                  int    cmp = -1;
178         
179                 target.IPCType = IPCType;
180                 target.Ident = Ident;
181                 ret = &target;  // Abuse ret to get a pointer
182                 
183                 div = giIPC_ClientCount;
184                 pos = div/2;
185                 while(div > 0)
186                 {
187                         div /= 2;
188                         cmp = _CompareClientPtrs(&ret, &gIPC_Clients[pos]);
189 //                      _SysDebug("Checking against %i gives %i", pos, cmp);
190                         if(cmp == 0)    break;
191                         if(cmp < 0)
192                                 pos -= div;
193                         else
194                                 pos += div;
195                 }
196                 
197                 // - Return if found    
198                 if(cmp == 0)
199                         return gIPC_Clients[pos];
200         
201                 // Adjust pos to be the index where the new client will be placed
202                 if(cmp > 0)     pos ++;
203         }
204
205
206         // - Create a new client entry
207         ident_size = IPCType->GetIdentSize(Ident);
208 //      _SysDebug("ident_size = %i", ident_size);
209         ret = malloc( sizeof(tIPC_Client) + ident_size );
210         if(!ret)        return NULL;
211         ret->IPCType = IPCType;
212         ret->Ident = ret + 1;   // Get the end of the structure
213         memcpy( (void*)ret->Ident, Ident, ident_size );
214         ret->nWindows = 0;
215         ret->Windows = NULL;
216         
217         // TODO: Register some way of detecting the client disconnecting
218         //       > Wait on the thread / register with kernel somehow
219         //       > Sockets are easier, but UDP is harder. Might get rid of it
220
221         // - Insert
222         giIPC_ClientCount ++;
223         gIPC_Clients = realloc(gIPC_Clients, giIPC_ClientCount*sizeof(tIPC_Client*));
224         memmove(&gIPC_Clients[pos+1], &gIPC_Clients[pos], (giIPC_ClientCount-pos-1) * sizeof(tIPC_Client*));
225         gIPC_Clients[pos] = ret;
226
227         return ret;
228 }
229
230 tWindow *IPC_int_GetWindow(tIPC_Client *Client, uint32_t WindowID)
231 {
232         if( WindowID == -1 )
233                 return NULL;
234
235         if( WindowID >= Client->nWindows ) {
236 //              _SysDebug("Window %i out of range for %p (%i)", WindowID, Client, Client->nWindows);
237                 return NULL;
238         }
239
240         return Client->Windows[WindowID];
241 }
242
243 void IPC_int_SetWindow(tIPC_Client *Client, uint32_t WindowID, tWindow *WindowPtr)
244 {
245         if( WindowID >= MAX_WINDOWS_PER_APP )
246                 return ;
247
248         if( WindowID >= Client->nWindows )
249         {
250                  int    oldCount = Client->nWindows;
251                 Client->nWindows = WindowID + 1;
252                 Client->Windows = realloc(Client->Windows, Client->nWindows*sizeof(tWindow*));
253                 memset( &Client->Windows[oldCount],  0, (Client->nWindows-oldCount)*sizeof(tWindow*) );
254                 _SysDebug("Expanded %p's window list from %i to %i", Client, oldCount, Client->nWindows);
255         }
256
257         _SysDebug("Assigned %p to window %i for %p", WindowPtr, WindowID, Client);      
258         Client->Windows[WindowID] = WindowPtr;
259 }
260
261 // --- IPC Message Handlers ---
262 int IPC_Msg_SendMsg(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
263 {
264         tIPCMsg_SendMsg *info = (void*)Msg->Data;
265         tWindow *src, *dest;
266         
267         // - Sanity checks
268         if( Msg->Size < sizeof(tIPCMsg_SendMsg) )
269                 return -1;
270         if( Msg->Size < sizeof(tIPCMsg_SendMsg) + info->Length )
271                 return -1;
272         
273         src = IPC_int_GetWindow(Client, Msg->Window);
274         if(!src)        return 1;
275         dest = IPC_int_GetWindow(Client, info->Remote);
276         if(!dest)       return 1;
277
278         WM_SendMessage(src, dest, info->ID, info->Length, info->Data);  
279
280         return 0;
281 }
282
283 int IPC_Msg_FocusWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
284 {
285         tWindow *win;
286
287         // Don't allow the focus to be changed unless the client has the focus
288         if(!gpWM_FocusedWindow) return 1;
289         if(gpWM_FocusedWindow->Client != Client)        return 1;
290
291         win = IPC_int_GetWindow(Client, Msg->Window);
292         if(!win)        return 1;
293
294         WM_FocusWindow(win);
295
296         return 0;
297 }
298
299 int IPC_Msg_CreateWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
300 {
301         tIPCMsg_CreateWin       *info = (void*)Msg->Data;
302         tWindow *newwin, *parent;
303
304         // - Sanity checks
305         //  > +1 is for NULL byte on string
306         if( Msg->Size < sizeof(*info) + 1 ) {
307                 _SysDebug("IPC_Msg_CreateWin: Size check 1 failed");
308                 return -1;
309         }
310         if( info->Renderer[Msg->Size - sizeof(*info) - 1] != '\0' ) {
311                 _SysDebug("IPC_Msg_CreateWin: Size check 2 failed");
312                 _SysDebug("info = {");
313                 _SysDebug("  .NewWinID = %i", info->NewWinID);
314                 _SysDebug("  .RendererArg = %i", info->RendererArg);
315                 _SysDebug("  .Renderer = '%.*s'", Msg->Size - sizeof(*info), info->Renderer);
316                 _SysDebug("}");
317                 return -1;
318         }
319         
320         // - Get the parent window ID
321         parent = IPC_int_GetWindow(Client, Msg->Window);
322
323         // Catch creating a window with an existing ID
324         if( IPC_int_GetWindow(Client, info->NewWinID) )
325                 return 1;
326
327         // - Create the new window, and save its pointer
328         newwin = WM_CreateWindow(parent, Client, info->NewWinID, info->RendererArg, info->Renderer);
329         IPC_int_SetWindow(Client, info->NewWinID, newwin);
330
331         return 0;
332 }
333
334 int IPC_Msg_SetWindowTitle(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
335 {
336         tWindow *win;
337
338         if( Msg->Size < 1 )     return -1;
339         if( Msg->Data[ Msg->Size-1 ] != '\0' )  return -1;      
340
341         win = IPC_int_GetWindow(Client, Msg->Window);
342         if(!win)        return 1;
343
344         WM_SetWindowTitle(win, Msg->Data);
345
346         return 0;
347 }
348
349 int IPC_Msg_ShowWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
350 {
351         tIPCMsg_Boolean *info = (void*)Msg->Data;
352         tWindow *win;
353         
354         if( Msg->Size < sizeof(*info) ) return -1;
355         
356         win = IPC_int_GetWindow(Client, Msg->Window);
357         if(!win)        return 1;
358
359         WM_ShowWindow(win, !!info->Value);
360         
361         return 0;
362 }
363
364 int IPC_Msg_DecorateWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
365 {
366         tIPCMsg_Boolean *info = (void*)Msg->Data;
367         tWindow *win;
368         
369         if( Msg->Size < sizeof(*info) ) return -1;
370         
371         win = IPC_int_GetWindow(Client, Msg->Window);
372         if(!win)        return 1;
373         
374         WM_DecorateWindow(win, !!info->Value);
375         return 0;
376 }
377
378 int IPC_Msg_SetWinPos(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
379 {
380         tIPCMsg_SetWindowPos    *info = (void*)Msg->Data;
381         tWindow *win;
382         
383         if(Msg->Size < sizeof(*info))   return -1;
384         
385         win = IPC_int_GetWindow(Client, Msg->Window);
386         if(!win)        return 1;
387         
388         _SysDebug("info = {..., bSetPos=%i,bSetDims=%i}", info->bSetPos, info->bSetDims);
389         
390         if(info->bSetPos)
391                 WM_MoveWindow(win, info->X, info->Y);
392         if(info->bSetDims)
393                 WM_ResizeWindow(win, info->W, info->H);
394         
395         return 0;
396 }
397
398 int IPC_Msg_GetDisplayCount(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
399 {
400         tAxWin_IPCMessage       *ret_hdr;
401         tIPCMsg_ReturnInt       *ret;
402         char    buf[sizeof(*ret_hdr)+sizeof(*ret)];
403         
404         if( !(Msg->Flags & IPCMSG_FLAG_RETURN) )        return 0;
405         
406         ret_hdr = (void*)buf;
407         ret_hdr->ID = IPCMSG_GETDISPLAYCOUNT;
408         ret_hdr->Flags = 0;
409         ret_hdr->Window = -1;
410         ret_hdr->Size = sizeof(*ret);
411         ret = (void*)ret_hdr->Data;
412         ret->Value = 1; // HARD CODE - Current version only supports one display
413         
414         Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
415         return 0;
416 }
417
418 int IPC_Msg_GetDisplayDims(tIPC_Client *Client, tAxWin_IPCMessage *Msg)
419 {
420         tIPCMsg_GetDisplayDims  *info;
421         tAxWin_IPCMessage       *ret_hdr;
422         tIPCMsg_RetDisplayDims  *ret;
423         char    buf[sizeof(*ret_hdr)+sizeof(*ret)];
424         
425         if( !(Msg->Flags & IPCMSG_FLAG_RETURN) )        return 0;
426
427         info = (void*)Msg->Data;        
428
429         ret_hdr = (void*)buf;
430         ret_hdr->ID = IPCMSG_GETDISPLAYDIMS;
431         ret_hdr->Flags = 0;
432         ret_hdr->Window = -1;
433         ret_hdr->Size = sizeof(*ret);
434         ret = (void*)ret_hdr->Data;
435         
436         // HARD CODE! Only one display supported
437         if( info->DisplayID == 0 )
438         {
439                 ret->X = 0;
440                 ret->Y = 0;
441                 ret->W = giScreenWidth;
442                 ret->H = giScreenHeight;
443         }
444         else
445         {
446                 ret->X = 0;     ret->Y = 0;
447                 ret->W = 0;     ret->H = 0;
448         }
449         
450         Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
451         return 0;
452 }
453
454 void IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg)
455 {
456         tIPC_Client     *client;
457          int    rv = 0;
458         
459         _SysDebug("IPC_Handle: (IPCType=%p, Ident=%p, MsgLen=%i, Msg=%p)",
460                 IPCType, Ident, MsgLen, Msg);
461         
462         if( MsgLen < sizeof(tAxWin_IPCMessage) )
463                 return ;
464         if( MsgLen < sizeof(tAxWin_IPCMessage) + Msg->Size )
465                 return ;
466         
467         client = IPC_int_GetClient(IPCType, Ident);
468
469         switch((enum eAxWin_IPCMessageTypes) Msg->ID)
470         {
471         // --- Ping message (reset timeout and get server version)
472         case IPCMSG_PING:
473                 _SysDebug(" IPC_Handle: IPCMSG_PING");
474                 if( Msg->Size < 4 )     return;
475                 if( Msg->Flags & IPCMSG_FLAG_RETURN )
476                 {
477                         tIPCMsg_ReturnInt       *ret = (void*)Msg->Data;
478                         Msg->ID = IPCMSG_PING;
479                         Msg->Size = sizeof(*ret);
480                         ret->Value = AXWIN_VERSION;
481                         IPCType->SendMessage(Ident, sizeof(*Msg)+sizeof(*ret), Msg);
482                 }
483                 break;
484
485         // -- Get display count
486         case IPCMSG_GETDISPLAYCOUNT:
487                 rv = IPC_Msg_GetDisplayCount(client, Msg);
488                 break;
489         
490         // --- Get display dimensions
491         case IPCMSG_GETDISPLAYDIMS:
492                 rv = IPC_Msg_GetDisplayDims(client, Msg);
493                 break;
494
495         // --- Send a message
496         case IPCMSG_SENDMSG:
497                 _SysDebug(" IPC_Handle: IPCMSG_SENDMSG %i", ((tIPCMsg_SendMsg*)Msg->Data)->ID);
498                 rv = IPC_Msg_SendMsg(client, Msg);
499                 break;
500
501         // --- Create window
502         case IPCMSG_CREATEWIN:
503                 _SysDebug(" IPC_Handle: IPCMSG_CREATEWIN");
504                 rv = IPC_Msg_CreateWin(client, Msg);
505                 break;
506         // TODO: Destroy window
507         
508         // --- Set window title
509         case IPCMSG_SETWINTITLE:
510                 _SysDebug(" IPC_Handle: IPCMSG_SETWINTITLE");
511                 rv = IPC_Msg_SetWindowTitle(client, Msg);
512                 break;
513
514         // --- Give a window focus
515         case IPCMSG_FOCUSWINDOW:
516                 _SysDebug(" IPC_Handle: IPCMSG_FOCUSWINDOW");
517                 rv = IPC_Msg_FocusWindow(client, Msg);
518                 break;
519         // --- Show/Hide a window
520         case IPCMSG_SHOWWINDOW:
521                 _SysDebug(" IPC_Handle: IPCMSG_SHOWWINDOW");
522                 rv = IPC_Msg_ShowWindow(client, Msg);
523                 break;
524         case IPCMSG_DECORATEWINDOW:
525                 _SysDebug(" IPC_Handle: IPCMSG_DECORATEWINDOW");
526                 rv = IPC_Msg_DecorateWindow(client, Msg);
527                 break;
528         // --- Move/Resize a window
529         case IPCMSG_SETWINPOS:
530                 _SysDebug(" IPC_Handle: IPCMSG_SETWINPOS");
531                 rv = IPC_Msg_SetWinPos(client, Msg);
532                 break;
533
534         // --- Unknown message
535         default:
536                 fprintf(stderr, "WARNING: Unknown message %i (%p)\n", Msg->ID, IPCType);
537                 _SysDebug("WARNING: Unknown message %i (%p)", Msg->ID, IPCType);
538                 break;
539         }
540         if(rv)
541                 _SysDebug("IPC_Handle: rv = %i", rv);
542 }
543
544 // --- Server->Client replies
545 void IPC_SendWMMessage(tIPC_Client *Client, uint32_t Src, uint32_t Dst, int MsgID, int Len, void *Data)
546 {
547         tAxWin_IPCMessage       *hdr;
548         tIPCMsg_SendMsg         *msg;
549         char    buf[sizeof(*hdr)+sizeof(*msg)+Len];
550         
551         hdr = (void*)buf;
552         msg = (void*)hdr->Data;
553         
554         hdr->ID = IPCMSG_SENDMSG;
555         hdr->Flags = 0;
556         hdr->Size = sizeof(*msg) + Len;
557         hdr->Window = Dst;
558         
559         msg->Remote = Src;
560         msg->ID = MsgID;
561         msg->Length = Len;
562         memcpy(msg->Data, Data, Len);
563         
564         Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf);
565 }
566

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