X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FApplications%2Faxwin3_src%2FWM%2Fipc.c;h=46aff215dd9287e7995fd75dff7bbe16cef66d94;hb=b1488ae9beae34068d38d00e191b90ef0bf812f3;hp=01f16be0aeb952c04bc309243b317b7a550ba0b4;hpb=9b2597c18780e7b9946336aa76c81c8c6106813a;p=tpg%2Facess2.git diff --git a/Usermode/Applications/axwin3_src/WM/ipc.c b/Usermode/Applications/axwin3_src/WM/ipc.c index 01f16be0..46aff215 100644 --- a/Usermode/Applications/axwin3_src/WM/ipc.c +++ b/Usermode/Applications/axwin3_src/WM/ipc.c @@ -10,46 +10,64 @@ #include #include #include +#include +#include +#include #define AXWIN_PORT 4101 #define STATICBUF_SIZE 64 +#define MAX_WINDOWS_PER_APP 128 // === TYPES === typedef struct sIPC_Type tIPC_Type; + struct sIPC_Type { - int (*GetIdentSize)(void *Ident); - int (*CompareIdent)(void *Ident1, void *Ident2); - void (*SendMessage)(void *Ident, size_t, void *Data); + int (*GetIdentSize)(const void *Ident); + int (*CompareIdent)(const void *Ident1, const void *Ident2); + void (*SendMessage)(const void *Ident, size_t Length, const void *Data); +}; + +struct sIPC_Client +{ + const tIPC_Type *IPCType; + const void *Ident; // Stored after structure + + int nWindows; + tWindow **Windows; }; +// === IMPORTS === +extern tWindow *gpWM_FocusedWindow; // Needed for _FocusWindow + // === PROTOTYPES === void IPC_Init(void); void IPC_FillSelect(int *nfds, fd_set *set); void IPC_HandleSelect(fd_set *set); -void IPC_Handle(tIPC_Type *IPCType, void *Ident, size_t MsgLen, tAxWin_Message *Msg); -void IPC_ReturnValue(tIPC_Type *IPCType, void *Ident, int MessageID, uint32_t Value); - int IPC_Type_Datagram_GetSize(void *Ident); - int IPC_Type_Datagram_Compare(void *Ident1, void *Ident2); -void IPC_Type_Datagram_Send(void *Ident, size_t Length, void *Data); - int IPC_Type_Sys_GetSize(void *Ident); - int IPC_Type_Sys_Compare(void *Ident1, void *Ident2); -void IPC_Type_Sys_Send(void *Ident, size_t Length, void *Data); + int IPC_Type_Datagram_GetSize(const void *Ident); + int IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2); +void IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data); + int IPC_Type_Sys_GetSize(const void *Ident); + int IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2); +void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data); +void IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg); // === GLOBALS === - int giNetworkFileHandle = -1; - int giMessagesFileHandle = -1; -tIPC_Type gIPC_Type_Datagram = { +const tIPC_Type gIPC_Type_Datagram = { IPC_Type_Datagram_GetSize, IPC_Type_Datagram_Compare, IPC_Type_Datagram_Send }; -tIPC_Type gIPC_Type_SysMessage = { +const tIPC_Type gIPC_Type_SysMessage = { IPC_Type_Sys_GetSize, IPC_Type_Sys_Compare, IPC_Type_Sys_Send }; + int giNetworkFileHandle = -1; + int giMessagesFileHandle = -1; + int giIPC_ClientCount; +tIPC_Client **gIPC_Clients; // === CODE === void IPC_Init(void) @@ -80,7 +98,7 @@ void IPC_HandleSelect(fd_set *set) msg = staticBuf + identlen; IPC_Handle(&gIPC_Type_Datagram, staticBuf, readlen - identlen, (void*)msg); - _SysDebug("IPC_HandleSelect: UDP handled"); +// _SysDebug("IPC_HandleSelect: UDP handled"); } while(SysGetMessage(NULL, NULL)) @@ -91,100 +109,458 @@ void IPC_HandleSelect(fd_set *set) SysGetMessage(NULL, data); IPC_Handle(&gIPC_Type_SysMessage, &tid, len, (void*)data); - _SysDebug("IPC_HandleSelect: Message handled"); +// _SysDebug("IPC_HandleSelect: Message handled"); } } -void IPC_Handle(tIPC_Type *IPCType, void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg) +int IPC_Type_Datagram_GetSize(const void *Ident) { - tApplication *app; - tElement *ele; - - _SysDebug("IPC_Handle: (IPCType=%p, Ident=%p, MsgLen=%i, Msg=%p)", - IPCType, Ident, MsgLen, Msg); + return 4 + Net_GetAddressSize( ((const uint16_t*)Ident)[1] ); +} + +int IPC_Type_Datagram_Compare(const void *Ident1, const void *Ident2) +{ + // Pass the buck :) + // - No need to worry about mis-matching sizes, as the size is computed + // from the 3rd/4th bytes, hence it will differ before the size is hit. + return memcmp(Ident1, Ident2, IPC_Type_Datagram_GetSize(Ident1)); +} + +void IPC_Type_Datagram_Send(const void *Ident, size_t Length, const void *Data) +{ + int identlen = IPC_Type_Datagram_GetSize(Ident); + char tmpbuf[ identlen + Length ]; + memcpy(tmpbuf, Ident, identlen); // Header + memcpy(tmpbuf + identlen, Data, Length); // Data + // TODO: Handle fragmented packets + write(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf)); +} + +int IPC_Type_Sys_GetSize(const void *Ident) +{ + return sizeof(pid_t); +} + +int IPC_Type_Sys_Compare(const void *Ident1, const void *Ident2) +{ + return *(const tid_t*)Ident1 - *(const tid_t*)Ident2; +} + +void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data) +{ + SysSendMessage( *(const tid_t*)Ident, Length, Data ); +} + +// --- Client -> Window Mappings +int _CompareClientPtrs(const void *_a, const void *_b) +{ + tIPC_Client *a = *(tIPC_Client**)_a; + tIPC_Client *b = *(tIPC_Client**)_b; - if( MsgLen < sizeof(tAxWin_Message) ) - return ; - if( MsgLen < sizeof(tAxWin_Message) + Msg->Size ) - return ; + if(a->IPCType < b->IPCType) return -1; + if(a->IPCType > b->IPCType) return 1; - app = AxWin_GetClient(IPCType, Ident); + return a->IPCType->CompareIdent(a->Ident, b->Ident); +} - switch((enum eAxWin_IPCMessageTypes) Msg->ID) +tIPC_Client *IPC_int_GetClient(const tIPC_Type *IPCType, const void *Ident) +{ + int pos = 0; // Position where the new client will be inserted + int ident_size; + tIPC_Client *ret; + + // - Search list of registered clients + if(giIPC_ClientCount > 0) { - // --- Ping message (reset timeout and get server version) - case IPCMSG_PING: - _SysDebug(" IPC_Handle: IPCMSG_PING"); - if( MsgLen < sizeof(tAxWin_Message) + 4 ) return; - if( Msg->Flags & IPCMSG_FLAG_RETURN ) + tIPC_Client target; + int div; + int cmp = -1; + + target.IPCType = IPCType; + target.Ident = Ident; + ret = ⌖ // Abuse ret to get a pointer + + div = giIPC_ClientCount; + pos = div/2; + while(div > 0) { - Msg->ID = IPCMSG_PING; - Msg->Size = sizeof(tIPCMsg_Return); - ((tIPCMsg_Return*)Msg->Data)->Value = AXWIN_VERSION; - IPCType->SendMessage(Ident, sizeof(tIPCMsg_Return), Msg); + div /= 2; + cmp = _CompareClientPtrs(&ret, &gIPC_Clients[pos]); +// _SysDebug("Checking against %i gives %i", pos, cmp); + if(cmp == 0) break; + if(cmp < 0) + pos -= div; + else + pos += div; } - break; + + // - Return if found + if(cmp == 0) + return gIPC_Clients[pos]; + + // Adjust pos to be the index where the new client will be placed + if(cmp > 0) pos ++; + } - // --- - // --- Unknown message - default: - fprintf(stderr, "WARNING: Unknown message %i (%p)\n", Msg->ID, IPCType); - _SysDebug("WARNING: Unknown message %i (%p)\n", Msg->ID, IPCType); - break; + // - Create a new client entry + ident_size = IPCType->GetIdentSize(Ident); +// _SysDebug("ident_size = %i", ident_size); + ret = malloc( sizeof(tIPC_Client) + ident_size ); + if(!ret) return NULL; + ret->IPCType = IPCType; + ret->Ident = ret + 1; // Get the end of the structure + memcpy( (void*)ret->Ident, Ident, ident_size ); + ret->nWindows = 0; + ret->Windows = NULL; + + // TODO: Register some way of detecting the client disconnecting + // > Wait on the thread / register with kernel somehow + // > Sockets are easier, but UDP is harder. Might get rid of it + + // - Insert + giIPC_ClientCount ++; + gIPC_Clients = realloc(gIPC_Clients, giIPC_ClientCount*sizeof(tIPC_Client*)); + memmove(&gIPC_Clients[pos+1], &gIPC_Clients[pos], (giIPC_ClientCount-pos-1) * sizeof(tIPC_Client*)); + gIPC_Clients[pos] = ret; + + return ret; +} + +tWindow *IPC_int_GetWindow(tIPC_Client *Client, uint32_t WindowID) +{ + if( WindowID == -1 ) + return NULL; + + if( WindowID >= Client->nWindows ) { +// _SysDebug("Window %i out of range for %p (%i)", WindowID, Client, Client->nWindows); + return NULL; } + + return Client->Windows[WindowID]; } -void IPC_ReturnValue(tIPC_Type *IPCType, void *Ident, int MessageID, uint32_t Value) +void IPC_int_SetWindow(tIPC_Client *Client, uint32_t WindowID, tWindow *WindowPtr) { - char data[sizeof(tAxWin_Message) + sizeof(tAxWin_RetMsg)]; - tAxWin_Message *msg = (void *)data; - tAxWin_RetMsg *ret_msg = (void *)msg->Data; + if( WindowID >= MAX_WINDOWS_PER_APP ) + return ; + + if( WindowID >= Client->nWindows ) + { + int oldCount = Client->nWindows; + Client->nWindows = WindowID + 1; + Client->Windows = realloc(Client->Windows, Client->nWindows*sizeof(tWindow*)); + memset( &Client->Windows[oldCount], 0, (Client->nWindows-oldCount)*sizeof(tWindow*) ); + _SysDebug("Expanded %p's window list from %i to %i", Client, oldCount, Client->nWindows); + } + + _SysDebug("Assigned %p to window %i for %p", WindowPtr, WindowID, Client); + Client->Windows[WindowID] = WindowPtr; +} + +// --- IPC Message Handlers --- +int IPC_Msg_SendMsg(tIPC_Client *Client, tAxWin_IPCMessage *Msg) +{ + tIPCMsg_SendMsg *info = (void*)Msg->Data; + tWindow *src, *dest; - msg->Source = 0; // 0 = Server - msg->ID = MSG_SRSP_RETURN; - msg->Size = sizeof(tAxWin_RetMsg); - ret_msg->ReqID = MessageID; - ret_msg->Rsvd = 0; - ret_msg->Value = Value; + // - Sanity checks + if( Msg->Size < sizeof(tIPCMsg_SendMsg) ) + return -1; + if( Msg->Size < sizeof(tIPCMsg_SendMsg) + info->Length ) + return -1; - IPCType->SendMessage(Ident, sizeof(data), data); + src = IPC_int_GetWindow(Client, Msg->Window); + if(!src) return 1; + dest = IPC_int_GetWindow(Client, info->Remote); + if(!dest) return 1; + + WM_SendMessage(src, dest, info->ID, info->Length, info->Data); + + return 0; } -int IPC_Type_Datagram_GetSize(void *Ident) +int IPC_Msg_FocusWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - return 4 + Net_GetAddressSize( ((uint16_t*)Ident)[1] ); + tWindow *win; + + // Don't allow the focus to be changed unless the client has the focus + if(!gpWM_FocusedWindow) return 1; + if(gpWM_FocusedWindow->Client != Client) return 1; + + win = IPC_int_GetWindow(Client, Msg->Window); + if(!win) return 1; + + WM_FocusWindow(win); + + return 0; } -int IPC_Type_Datagram_Compare(void *Ident1, void *Ident2) +int IPC_Msg_CreateWin(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - // Pass the buck :) - // - No need to worry about mis-matching sizes, as the size is computed - // from the 3rd/4th bytes, hence it will differ before the size is hit. - return memcmp(Ident1, Ident2, IPC_Type_Datagram_GetSize(Ident1)); + tIPCMsg_CreateWin *info = (void*)Msg->Data; + tWindow *newwin, *parent; + + // - Sanity checks + // > +1 is for NULL byte on string + if( Msg->Size < sizeof(*info) + 1 ) { + _SysDebug("IPC_Msg_CreateWin: Size check 1 failed"); + return -1; + } + if( info->Renderer[Msg->Size - sizeof(*info) - 1] != '\0' ) { + _SysDebug("IPC_Msg_CreateWin: Size check 2 failed"); + _SysDebug("info = {"); + _SysDebug(" .NewWinID = %i", info->NewWinID); + _SysDebug(" .RendererArg = %i", info->RendererArg); + _SysDebug(" .Renderer = '%.*s'", Msg->Size - sizeof(*info), info->Renderer); + _SysDebug("}"); + return -1; + } + + // - Get the parent window ID + parent = IPC_int_GetWindow(Client, Msg->Window); + + // Catch creating a window with an existing ID + if( IPC_int_GetWindow(Client, info->NewWinID) ) + return 1; + + // - Create the new window, and save its pointer + newwin = WM_CreateWindow(parent, Client, info->NewWinID, info->RendererArg, info->Renderer); + IPC_int_SetWindow(Client, info->NewWinID, newwin); + + return 0; } -void IPC_Type_Datagram_Send(void *Ident, size_t Length, void *Data) +int IPC_Msg_SetWindowTitle(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - int identlen = IPC_Type_Datagram_GetSize(Ident); - char tmpbuf[ identlen + Length ]; - memcpy(tmpbuf, Ident, identlen); // Header - memcpy(tmpbuf + identlen, Data, Length); // Data - // TODO: Handle fragmented packets - write(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf)); + tWindow *win; + + if( Msg->Size < 1 ) return -1; + if( Msg->Data[ Msg->Size-1 ] != '\0' ) return -1; + + win = IPC_int_GetWindow(Client, Msg->Window); + if(!win) return 1; + + WM_SetWindowTitle(win, Msg->Data); + + return 0; } -int IPC_Type_Sys_GetSize(void *Ident) +int IPC_Msg_ShowWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - return sizeof(pid_t); + tIPCMsg_Boolean *info = (void*)Msg->Data; + tWindow *win; + + if( Msg->Size < sizeof(*info) ) return -1; + + win = IPC_int_GetWindow(Client, Msg->Window); + if(!win) return 1; + + WM_ShowWindow(win, !!info->Value); + + return 0; } -int IPC_Type_Sys_Compare(void *Ident1, void *Ident2) +int IPC_Msg_DecorateWindow(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - return *(int*)Ident1 - *(int*)Ident2; + tIPCMsg_Boolean *info = (void*)Msg->Data; + tWindow *win; + + if( Msg->Size < sizeof(*info) ) return -1; + + win = IPC_int_GetWindow(Client, Msg->Window); + if(!win) return 1; + + WM_DecorateWindow(win, !!info->Value); + return 0; } -void IPC_Type_Sys_Send(void *Ident, size_t Length, void *Data) +int IPC_Msg_SetWinPos(tIPC_Client *Client, tAxWin_IPCMessage *Msg) { - SysSendMessage( *(tid_t*)Ident, Length, Data ); + tIPCMsg_SetWindowPos *info = (void*)Msg->Data; + tWindow *win; + + if(Msg->Size < sizeof(*info)) return -1; + + win = IPC_int_GetWindow(Client, Msg->Window); + if(!win) return 1; + + _SysDebug("info = {..., bSetPos=%i,bSetDims=%i}", info->bSetPos, info->bSetDims); + + if(info->bSetPos) + WM_MoveWindow(win, info->X, info->Y); + if(info->bSetDims) + WM_ResizeWindow(win, info->W, info->H); + + return 0; +} + +int IPC_Msg_GetDisplayCount(tIPC_Client *Client, tAxWin_IPCMessage *Msg) +{ + tAxWin_IPCMessage *ret_hdr; + tIPCMsg_ReturnInt *ret; + char buf[sizeof(*ret_hdr)+sizeof(*ret)]; + + if( !(Msg->Flags & IPCMSG_FLAG_RETURN) ) return 0; + + ret_hdr = (void*)buf; + ret_hdr->ID = IPCMSG_GETDISPLAYCOUNT; + ret_hdr->Flags = 0; + ret_hdr->Window = -1; + ret_hdr->Size = sizeof(*ret); + ret = (void*)ret_hdr->Data; + ret->Value = 1; // HARD CODE - Current version only supports one display + + Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf); + return 0; } + +int IPC_Msg_GetDisplayDims(tIPC_Client *Client, tAxWin_IPCMessage *Msg) +{ + tIPCMsg_GetDisplayDims *info; + tAxWin_IPCMessage *ret_hdr; + tIPCMsg_RetDisplayDims *ret; + char buf[sizeof(*ret_hdr)+sizeof(*ret)]; + + if( !(Msg->Flags & IPCMSG_FLAG_RETURN) ) return 0; + + info = (void*)Msg->Data; + + ret_hdr = (void*)buf; + ret_hdr->ID = IPCMSG_GETDISPLAYDIMS; + ret_hdr->Flags = 0; + ret_hdr->Window = -1; + ret_hdr->Size = sizeof(*ret); + ret = (void*)ret_hdr->Data; + + // HARD CODE! Only one display supported + if( info->DisplayID == 0 ) + { + ret->X = 0; + ret->Y = 0; + ret->W = giScreenWidth; + ret->H = giScreenHeight; + } + else + { + ret->X = 0; ret->Y = 0; + ret->W = 0; ret->H = 0; + } + + Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf); + return 0; +} + +void IPC_Handle(const tIPC_Type *IPCType, const void *Ident, size_t MsgLen, tAxWin_IPCMessage *Msg) +{ + tIPC_Client *client; + int rv = 0; + + _SysDebug("IPC_Handle: (IPCType=%p, Ident=%p, MsgLen=%i, Msg=%p)", + IPCType, Ident, MsgLen, Msg); + + if( MsgLen < sizeof(tAxWin_IPCMessage) ) + return ; + if( MsgLen < sizeof(tAxWin_IPCMessage) + Msg->Size ) + return ; + + client = IPC_int_GetClient(IPCType, Ident); + + switch((enum eAxWin_IPCMessageTypes) Msg->ID) + { + // --- Ping message (reset timeout and get server version) + case IPCMSG_PING: + _SysDebug(" IPC_Handle: IPCMSG_PING"); + if( Msg->Size < 4 ) return; + if( Msg->Flags & IPCMSG_FLAG_RETURN ) + { + tIPCMsg_ReturnInt *ret = (void*)Msg->Data; + Msg->ID = IPCMSG_PING; + Msg->Size = sizeof(*ret); + ret->Value = AXWIN_VERSION; + IPCType->SendMessage(Ident, sizeof(*Msg)+sizeof(*ret), Msg); + } + break; + + // -- Get display count + case IPCMSG_GETDISPLAYCOUNT: + rv = IPC_Msg_GetDisplayCount(client, Msg); + break; + + // --- Get display dimensions + case IPCMSG_GETDISPLAYDIMS: + rv = IPC_Msg_GetDisplayDims(client, Msg); + break; + + // --- Send a message + case IPCMSG_SENDMSG: + _SysDebug(" IPC_Handle: IPCMSG_SENDMSG %i", ((tIPCMsg_SendMsg*)Msg->Data)->ID); + rv = IPC_Msg_SendMsg(client, Msg); + break; + + // --- Create window + case IPCMSG_CREATEWIN: + _SysDebug(" IPC_Handle: IPCMSG_CREATEWIN"); + rv = IPC_Msg_CreateWin(client, Msg); + break; + // TODO: Destroy window + + // --- Set window title + case IPCMSG_SETWINTITLE: + _SysDebug(" IPC_Handle: IPCMSG_SETWINTITLE"); + rv = IPC_Msg_SetWindowTitle(client, Msg); + break; + + // --- Give a window focus + case IPCMSG_FOCUSWINDOW: + _SysDebug(" IPC_Handle: IPCMSG_FOCUSWINDOW"); + rv = IPC_Msg_FocusWindow(client, Msg); + break; + // --- Show/Hide a window + case IPCMSG_SHOWWINDOW: + _SysDebug(" IPC_Handle: IPCMSG_SHOWWINDOW"); + rv = IPC_Msg_ShowWindow(client, Msg); + break; + case IPCMSG_DECORATEWINDOW: + _SysDebug(" IPC_Handle: IPCMSG_DECORATEWINDOW"); + rv = IPC_Msg_DecorateWindow(client, Msg); + break; + // --- Move/Resize a window + case IPCMSG_SETWINPOS: + _SysDebug(" IPC_Handle: IPCMSG_SETWINPOS"); + rv = IPC_Msg_SetWinPos(client, Msg); + break; + + // --- Unknown message + default: + fprintf(stderr, "WARNING: Unknown message %i (%p)\n", Msg->ID, IPCType); + _SysDebug("WARNING: Unknown message %i (%p)", Msg->ID, IPCType); + break; + } + if(rv) + _SysDebug("IPC_Handle: rv = %i", rv); +} + +// --- Server->Client replies +void IPC_SendWMMessage(tIPC_Client *Client, uint32_t Src, uint32_t Dst, int MsgID, int Len, void *Data) +{ + tAxWin_IPCMessage *hdr; + tIPCMsg_SendMsg *msg; + char buf[sizeof(*hdr)+sizeof(*msg)+Len]; + + hdr = (void*)buf; + msg = (void*)hdr->Data; + + hdr->ID = IPCMSG_SENDMSG; + hdr->Flags = 0; + hdr->Size = sizeof(*msg) + Len; + hdr->Window = Dst; + + msg->Remote = Src; + msg->ID = MsgID; + msg->Length = Len; + memcpy(msg->Data, Data, Len); + + Client->IPCType->SendMessage(Client->Ident, sizeof(buf), buf); +} +