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_REPLY:
  90                 // Flag reply and take a copy of this message
  91                 if( !gSyncReplyActive )
  92                 {
  93                         _SysDebug("Unexpected reply message %i", message.ReadU8());
  94                 }
  95                 else if( gSyncReplyValid )
  96                 {
  97                         // Oh... that was unexpected
  98                         _SysDebug("Unexpected second reply message %i", message.ReadU8());
  99                 }
 100                 else
 101                 {
 102                         gSyncReplyValid = true;
 103                         gSyncReplyBuf = message;
 104                 }
 105                 break;
 106         default:
 107                 _SysDebug("TODO: RecvMessage(%i)", id);
 108                 break;
 109         }
 110 }
 111
 112 CDeserialiser GetSyncReply(CSerialiser& request, unsigned int Message)
 113 {
 114         ::std::lock_guard<std::mutex>   lock(glSyncReply);
 115         gSyncReplyActive = true;
 116         gSyncReplyValid = false;
 117         // Send once lock is acquired
 118         SendMessage(request);
 119
 120         while( !gSyncReplyValid )
 121         {
 122                 // Tick along
 123                 if( !AxWin4_WaitEventQueue(0) )
 124                         throw ::std::runtime_error("Connection dropped while waiting for reply");
 125         }
 126         gSyncReplyActive = false;
 127
 128         uint8_t id = gSyncReplyBuf.ReadU8();
 129         if( id != Message )
 130         {
 131                 _SysDebug("Unexpected reply message id=%i, expected %i",
 132                         id, Message);
 133                 throw ::std::runtime_error("Sequencing error, unexpected reply");
 134         }
 135
 136         // Use move to avoid copying
 137         return ::std::move(gSyncReplyBuf);
 138 }
 139
 140 extern "C" void AxWin4_GetScreenDimensions(unsigned int ScreenIndex, unsigned int *Width, unsigned int *Height)
 141 {
 142         CSerialiser     req;
 143         req.WriteU8(IPCMSG_GETGLOBAL);
 144         req.WriteU16(IPC_GLOBATTR_SCREENDIMS);
 145         req.WriteU8(ScreenIndex);
 146
 147         CDeserialiser   response = GetSyncReply(req, IPCMSG_GETGLOBAL);
 148         if( response.ReadU16() != IPC_GLOBATTR_SCREENDIMS ) {
 149
 150         }
 151
 152         *Width = response.ReadU16();
 153         *Height = response.ReadU16();
 154
 155         _SysDebug("AxWin4_GetScreenDimensions: %i = %ix%i", ScreenIndex, *Width, *Height);
 156 }
 157
 158 IIPCChannel::~IIPCChannel()
 159 {
 160 }
 161
 162 };      // namespace AxWin
 163