Usermode/Applications/axwin4_src/Server/ipc.cpp

   1 /*
   2  */
   3 #include <ipc.hpp>
   4 #include <list>
   5 #include <IIPCChannel.hpp>
   6 #include <algorithm>
   7 #include <CClient.hpp>
   8 #include <serialisation.hpp>
   9 #include <ipc_proto.hpp>
  10 #include <CCompositor.hpp>
  11 extern "C" {
  12 #include <assert.h>
  13 };
  14 #include <CIPCChannel_AcessIPCPipe.hpp>
  15
  16 namespace AxWin {
  17 namespace IPC {
  18
  19 CCompositor*    gpCompositor;
  20 ::std::list<IIPCChannel*>       glChannels;
  21 //::std::map<uint16_t,CClient*> glClients;
  22
  23 void Initialise(const CConfigIPC& config, CCompositor& compositor)
  24 {
  25         gpCompositor = &compositor;
  26
  27         ::std::string pipe_basepath = "axwin4";
  28         glChannels.push_back( new CIPCChannel_AcessIPCPipe( pipe_basepath ) );
  29
  30         //glChannels.push_back( new CIPCChannel_TCP("0.0.0.0:2100") );
  31
  32         //for( auto channel : config.m_channels )
  33         //{
  34         //      channels.push_back(  );
  35         //}
  36 }
  37
  38 int FillSelect(fd_set& rfds)
  39 {
  40         int ret = 0;
  41         for( auto channel : glChannels )
  42         {
  43                 ret = ::std::max(ret, channel->FillSelect(rfds));
  44         }
  45         return ret;
  46 }
  47
  48 void HandleSelect(fd_set& rfds)
  49 {
  50         for( auto channel : glChannels )
  51         {
  52                 channel->HandleSelect(rfds);
  53         }
  54 }
  55
  56 void RegisterClient(CClient& client)
  57 {
  58         // allocate a client ID, and save
  59         //client.m_id = 123;
  60         //glClients[client.m_id] = &client;
  61 }
  62
  63 void DeregisterClient(CClient& client)
  64 {
  65         //glClients.erase( client.m_id );
  66 }
  67
  68
  69
  70 typedef void    MessageHandler_op_t(CClient& client, CDeserialiser& message);
  71 MessageHandler_op_t     HandleMessage_Ping;
  72 MessageHandler_op_t     HandleMessage_GetWindowAttr;
  73 MessageHandler_op_t     HandleMessage_Reply;
  74 MessageHandler_op_t     HandleMessage_CreateWindow;
  75 MessageHandler_op_t     HandleMessage_CloseWindow;
  76 MessageHandler_op_t     HandleMessage_SetWindowAttr;
  77 MessageHandler_op_t     HandleMessage_AddRegion;
  78 MessageHandler_op_t     HandleMessage_DelRegion;
  79 MessageHandler_op_t     HandleMessage_SetRegionAttr;
  80 MessageHandler_op_t     HandleMessage_PushData;
  81 MessageHandler_op_t     HandleMessage_SendIPC;
  82
  83 MessageHandler_op_t     *message_handlers[] = {
  84         [IPCMSG_PING]       = &HandleMessage_Ping,
  85         [IPCMSG_REPLY]      = &HandleMessage_Reply,
  86
  87         [IPCMSG_CREATEWIN]  = &HandleMessage_CreateWindow,
  88         [IPCMSG_CLOSEWIN]   = &HandleMessage_CloseWindow,
  89         [IPCMSG_SETWINATTR] = &HandleMessage_SetWindowAttr,
  90         [IPCMSG_GETWINATTR] = &HandleMessage_GetWindowAttr,
  91
  92         [IPCMSG_RGNADD]     = &HandleMessage_AddRegion,
  93         [IPCMSG_RGNDEL]     = &HandleMessage_DelRegion,
  94         [IPCMSG_RGNSETATTR] = &HandleMessage_SetRegionAttr,
  95         [IPCMSG_RGNPUSHDATA]= &HandleMessage_PushData,  // to a region
  96         [IPCMSG_SENDIPC]    = &HandleMessage_SendIPC,   // Use the GUI server for low-bandwith inter-process messaging
  97 };
  98
  99 void HandleMessage(CClient& client, CDeserialiser& message)
 100 {
 101         unsigned int command = message.ReadU8();
 102         if( command >= sizeof(message_handlers)/sizeof(IPC::MessageHandler_op_t*) ) {
 103                 // Drop, invalid command
 104                 return ;
 105         }
 106
 107         (message_handlers[command])(client, message);
 108 }
 109
 110 void HandleMessage_Reply(CClient& client, CDeserialiser& message)
 111 {
 112         // Reply to a sent message
 113         // - Not many messages need server-bound replies
 114         int orig_command = message.ReadU8();
 115         switch(orig_command)
 116         {
 117         case IPCMSG_PING:
 118                 // Ping reply, mark client as still responding
 119                 break;
 120         default:
 121                 // Unexpected reply
 122                 break;
 123         }
 124 }
 125
 126 void HandleMessage_Ping(CClient& client, CDeserialiser& message)
 127 {
 128         // A client has asked for a ping, we pong them back
 129         CSerialiser     reply;
 130         reply.WriteU8(IPCMSG_REPLY);
 131         reply.WriteU8(IPCMSG_PING);
 132         client.SendMessage(reply);
 133 }
 134
 135 void HandleMessage_CreateWindow(CClient& client, CDeserialiser& message)
 136 {
 137         uint16_t        parent_id = message.ReadU16();
 138         uint16_t        new_id = message.ReadU16();
 139         CWindow* parent = client.GetWindow( parent_id );
 140
 141         client.SetWindow( new_id, gpCompositor->CreateWindow(client) );
 142 }
 143
 144 void HandleMessage_CloseWindow(CClient& client, CDeserialiser& message)
 145 {
 146         assert(!"TODO");
 147 }
 148
 149 void HandleMessage_SetWindowAttr(CClient& client, CDeserialiser& message)
 150 {
 151         assert(!"TODO");
 152 }
 153
 154 void HandleMessage_GetWindowAttr(CClient& client, CDeserialiser& message)
 155 {
 156         assert(!"TODO");
 157 }
 158
 159 void HandleMessage_AddRegion(CClient& client, CDeserialiser& message)
 160 {
 161         assert(!"TODO");
 162 }
 163
 164 void HandleMessage_DelRegion(CClient& client, CDeserialiser& message)
 165 {
 166         assert(!"TODO");
 167 }
 168
 169 void HandleMessage_SetRegionAttr(CClient& client, CDeserialiser& message)
 170 {
 171         assert(!"TODO");
 172 }
 173
 174 void HandleMessage_PushData(CClient& client, CDeserialiser& message)
 175 {
 176         assert(!"TODO");
 177 }
 178
 179 void HandleMessage_SendIPC(CClient& client, CDeserialiser& message)
 180 {
 181         assert(!"TODO");
 182 }
 183
 184 };      // namespace IPC
 185
 186 IIPCChannel::~IIPCChannel()
 187 {
 188 }
 189
 190 };      // namespace AxWin
 191