Usermode/Libraries/libaxwin4.so_src/ipc.cpp

   1 /*
   2  * AxWin4 Interface Library
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * ipc.c
   6  * - IPC Abstraction
   7  */
   8 #include <axwin4/axwin.h>
   9 #include "include/common.hpp"
  10 #include "include/IIPCChannel.hpp"
  11 #include "include/CIPCChannel_AcessIPCPipe.hpp"
  12 #include <ipc_proto.hpp>
  13 #include <algorithm>
  14 #include <mutex>
  15 #include <stdexcept>
  16
  17 #include <cstring>
  18 #include <cstdio>
  19
  20 namespace AxWin {
  21
  22 IIPCChannel*    gIPCChannel;
  23 ::std::mutex    glSyncReply;
  24 bool    gSyncReplyActive;
  25 bool    gSyncReplyValid;
  26 CDeserialiser   gSyncReplyBuf;
  27
  28 extern "C" bool AxWin4_Connect(const char *URI)
  29 {
  30         _SysDebug("AxWin4_Connect('%s')", URI);
  31         if( gIPCChannel ) {
  32                 return false;
  33         }
  34         try {
  35                 if( strncmp(URI, "ipcpipe://", 3+4+3) == 0 )
  36                 {
  37                         gIPCChannel = new CIPCChannel_AcessIPCPipe(URI+3+4+3);
  38                 }
  39                 else
  40                 {
  41                         _SysDebug("Unknown protocol");
  42                         return false;
  43                 }
  44         }
  45         catch( const ::std::exception& e )
  46         {
  47                 fprintf(stderr, "AxWin4_Connect: %s\n", e.what());
  48                 return false;
  49         }
  50         return true;
  51 }
  52
  53 extern "C" bool AxWin4_PeekEventQueue(void)
  54 {
  55         return false;
  56 }
  57
  58 extern "C" bool AxWin4_WaitEventQueue(uint64_t Timeout)
  59 {
  60         return AxWin4_WaitEventQueueSelect(0, NULL, NULL, NULL, Timeout);
  61 }
  62
  63 extern "C" bool AxWin4_WaitEventQueueSelect(int nFDs, fd_set *rfds, fd_set *wfds, fd_set *efds, uint64_t Timeout)
  64 {
  65         fd_set  local_rfds;
  66         if( !rfds ) {
  67                 FD_ZERO(&local_rfds);
  68                 rfds = &local_rfds;
  69         }
  70
  71         int64_t select_timeout = Timeout;
  72         int64_t *select_timeout_p = (Timeout ? &select_timeout : 0);
  73
  74         nFDs = ::std::max(nFDs, gIPCChannel->FillSelect(*rfds));
  75         _SysSelect(nFDs, rfds, wfds, efds, select_timeout_p, 0);
  76         return gIPCChannel->HandleSelect(*rfds);
  77 }
  78
  79 void SendMessage(CSerialiser& message)
  80 {
  81         gIPCChannel->Send(message);
  82 }
  83 void RecvMessage(CDeserialiser& message)
  84 {
  85         uint8_t id = message.ReadU8();
  86         _SysDebug("RecvMessage: id=%i", id);
  87         switch(id)
  88         {
  89         case IPCMSG_PING:
  90                 // If we hear ping, we must pong
  91                 {
  92                 CSerialiser     pong;
  93                 pong.WriteU8(IPCMSG_REPLY);
  94                 pong.WriteU8(IPCMSG_PING);
  95                 SendMessage(pong);
  96                 }
  97                 break;
  98         case IPCMSG_REPLY:
  99                 // Flag reply and take a copy of this message
 100                 if( !gSyncReplyActive )
 101                 {
 102                         _SysDebug("Unexpected reply message %i", message.ReadU8());
 103                 }
 104                 else if( gSyncReplyValid )
 105                 {
 106                         // Oh... that was unexpected
 107                         _SysDebug("Unexpected second reply message %i", message.ReadU8());
 108                 }
 109                 else
 110                 {
 111                         gSyncReplyValid = true;
 112                         gSyncReplyBuf = message;
 113                 }
 114                 break;
 115         // TODO: Handle messages from server (input events, IPC)
 116         // TODO: If an event is currently being processed, save the message in a queue to be handled when processing is complete
 117         // - This will prevent deep recursion (and make server errors aparent)
 118         default:
 119                 _SysDebug("TODO: RecvMessage(%i)", id);
 120                 break;
 121         }
 122 }
 123
 124 CDeserialiser GetSyncReply(CSerialiser& request, unsigned int Message)
 125 {
 126         ::std::lock_guard<std::mutex>   lock(glSyncReply);
 127         gSyncReplyActive = true;
 128         gSyncReplyValid = false;
 129         // Send once lock is acquired
 130         SendMessage(request);
 131
 132         while( !gSyncReplyValid )
 133         {
 134                 // Tick along
 135                 if( !AxWin4_WaitEventQueue(0) )
 136                         throw ::std::runtime_error("Connection dropped while waiting for reply");
 137         }
 138         gSyncReplyActive = false;
 139
 140         uint8_t id = gSyncReplyBuf.ReadU8();
 141         if( id != Message )
 142         {
 143                 _SysDebug("Unexpected reply message id=%i, expected %i",
 144                         id, Message);
 145                 throw ::std::runtime_error("Sequencing error, unexpected reply");
 146         }
 147
 148         // Use move to avoid copying
 149         return ::std::move(gSyncReplyBuf);
 150 }
 151
 152 extern "C" void AxWin4_GetScreenDimensions(unsigned int ScreenIndex, unsigned int *Width, unsigned int *Height)
 153 {
 154         CSerialiser     req;
 155         req.WriteU8(IPCMSG_GETGLOBAL);
 156         req.WriteU16(IPC_GLOBATTR_SCREENDIMS);
 157         req.WriteU8(ScreenIndex);
 158
 159         CDeserialiser   response = GetSyncReply(req, IPCMSG_GETGLOBAL);
 160         if( response.ReadU16() != IPC_GLOBATTR_SCREENDIMS ) {
 161
 162         }
 163
 164         *Width = response.ReadU16();
 165         *Height = response.ReadU16();
 166
 167         _SysDebug("AxWin4_GetScreenDimensions: %i = %ix%i", ScreenIndex, *Width, *Height);
 168 }
 169
 170 IIPCChannel::~IIPCChannel()
 171 {
 172 }
 173
 174 };      // namespace AxWin
 175