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

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