deamon/drd64_marshald_dispatch.c

   1 /*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
   2
   3                          D r . D e a m o n  6 4
   4                         for INTEL64(R), AMD64(R)
   5
   6    Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
  30
  31 /* File Info -----------------------------------------------------------
  32 File: drd64_.c
  33 Function:
  34 Comment:
  35 ----------------------------------------------------------------------*/
  36
  37 #include"drd64_marshald.h"
  38
  39 static  fd_set  g_fds_orig;
  40
  41
  42 /* for EXTERNAL Function */
  43 void
  44         Drd64_Marshald_Dispatch_SetFD(
  45                 int     i_fds )
  46 {
  47         FD_SET( i_fds, &g_fds_orig );
  48         return;
  49 }
  50
  51
  52 /* for EXTERNAL Function */
  53 void
  54         Drd64_Marshald_Dispatch_CloseSocket(
  55                 int     i_fds )
  56 {
  57         close( i_fds );
  58         FD_CLR( i_fds, &g_fds_orig );
  59         Drd64_Server_RecvStatus_FreeRecvStatus( i_fds );
  60         DRD64_DEBUG_PRINT("CloseSocket",i_fds,"errono",errno,NULL,0);
  61         return;
  62 }
  63
  64
  65 int
  66         Drd64_Marshald_Dispatch_OpenSocket(
  67                 int     i_socket_server )
  68 {
  69         int             i_socket_new;
  70         Drd64_Server_RecvStatus         *p_recv;
  71
  72         i_socket_new    = accept( i_socket_server, NULL, NULL );
  73         DRD64_DEBUG_SYSCALL("accept(New Comm.)",i_socket_new,errno);
  74
  75         if( -1 == i_socket_new )        {
  76                 return -1;
  77         }
  78
  79         FD_SET( i_socket_new, &g_fds_orig );
  80
  81         p_recv = Drd64_Server_RecvStatus_AllocRecvStatus(
  82                                         i_socket_new, DRD64_MARSHALD_RECVSTATUS_UNITS );
  83
  84         if( NULL == p_recv )    {
  85                 return -2;
  86         }
  87
  88         Drd64_Server_RecvStatus_InitRecvStatus( p_recv );
  89
  90         return i_socket_new;
  91 }
  92
  93
  94 int
  95         Drd64_Marshald_Dispatch_ExecPacket(
  96                 int             i_recv_id,
  97                 Drd64_Server_RecvStatus *p_recv,
  98         Drd64_Marshald_MasterInformation *p_marshald )
  99 {
 100         int                                                     i_result;
 101         Drd64_PacketHeader                      *p_phead;
 102         Drd64_Server_RecvStatus         *p_recv_parent;
 103         void                                            *pv_data;
 104
 105         /* Phase 1 : Init. ================================*/
 106         pv_data                 = NULL;
 107         i_result        = DRD64_MARSHALD_DISPATCH_RESULT_CLOSE;         // XXX > error
 108
 109         p_phead = (Drd64_PacketHeader *)p_recv->pv_buf;
 110         assert( NULL != p_phead );
 111
 112         if( 0 < p_phead->i_datalen )
 113                 { pv_data       = DRD64_PacketData( p_recv->pv_buf ); }
 114
 115
 116         /* Phase 2 : Exec. Command ========================*/
 117         /* CMD: Connect -----------------------------------*/
 118         if( DRD64_COMMAND_CONNECT == p_phead->dw_command )      {
 119                 i_result = Drd64_Marshald_Cmd_Connect( i_recv_id, p_phead, pv_data );
 120         }
 121         /* CMD: DisConnect --------------------------------*/
 122         else if( DRD64_COMMAND_DISCONNECT == p_phead->dw_command )      {
 123                 i_result = Drd64_Marshald_Cmd_DisConnect( i_recv_id, p_phead, pv_data );
 124         }
 125         /* CMD: Attach Request  ---------------------------*/
 126         else if( DRD64_COMMAND_ATTACH_REQUEST == p_phead->dw_command )  {
 127                 i_result = Drd64_Marshald_Cmd_AttachRequest(
 128                                                         i_recv_id, p_phead, pv_data, p_marshald );
 129         }
 130         else if( DRD64_COMMAND_DEBUG_REQUEST == p_phead->dw_command )   {
 131         }
 132         else if( DRD64_COMMAND_DETACH == p_phead->dw_command )  {
 133         }
 134         else if( DRD64_COMMAND_EXIT == p_phead->dw_command )    {
 135         }
 136         else if( DRD64_COMMAND_DEBUGD_BOOTINFO == p_phead->dw_command ) {
 137                 i_result = Drd64_Marshald_Msg_DebugdBootInfo(
 138                                                         i_recv_id, p_phead, pv_data, p_marshald );
 139         }
 140
 141
 142         /* Phase 3 : Result Proc.  =======================*/
 143         if( DRD64_MARSHALD_DISPATCH_RESULT_RESTART == i_result )        {
 144                 if( -1 < p_phead->i_resume_recvstatus_id )      {
 145                         p_recv_parent = Drd64_Server_RecvStatus_GetRecvStatus(
 146                                                                         p_phead->i_resume_recvstatus_id );
 147                         assert( NULL != p_recv_parent );
 148
 149                         p_recv_parent->b_recv_status
 150                                         = DRD64_SERVER_RECVSTATUS_STATUS_RESUME;
 151                 }
 152         }
 153         else if( DRD64_MARSHALD_DISPATCH_RESULT_POLL == i_result )      {
 154                 p_recv->b_recv_status   = DRD64_SERVER_RECVSTATUS_STATUS_STOP;
 155         }
 156
 157         /* XXX > error */
 158         if(( DRD64_MARSHALD_DISPATCH_RESULT_COMPLETE == i_result )
 159                         || ( DRD64_MARSHALD_DISPATCH_RESULT_RESTART == i_result ))      {
 160                 Drd64_Server_RecvStatus_DeleteResumeChain( i_recv_id );
 161         }
 162
 163         return i_result;
 164 }
 165
 166
 167 int
 168         Drd64_Marshald_Dispatch_JudgePacket(
 169                 int             i_fds,
 170                 int             i_remainbytes,
 171                 Drd64_Server_RecvStatus *p_recv,
 172         Drd64_Marshald_MasterInformation *p_marshald )
 173 {
 174         int             i_result;
 175         int             i_recv_id;
 176         Drd64_PacketHeader                      *p_phead;
 177         Drd64_Server_RecvStatus         *p_recv_new;
 178
 179         i_result                = 0x00;
 180
 181         /* Judge 1: Receiving : Remain Bytes Receiving = 0x01 */
 182         if( 0 < i_remainbytes )
 183                 { return DRD64_MARSHALD_DISPATCH_RESULT_RECEVING; }
 184         /* Judge 2: Error: Connection Down or Close = 0x00 */
 185         else if( 0 > i_remainbytes )
 186                 { return DRD64_MARSHALD_DISPATCH_RESULT_CLOSE; }
 187
 188         p_phead = (Drd64_PacketHeader *)p_recv->pv_buf;
 189         assert( NULL != p_phead );
 190
 191         /* Check 1 : Header Check */
 192         if( DRD64_PACKET_HEADER != p_phead->w_header )
 193                 { return DRD64_MARSHALD_DISPATCH_RESULT_CLOSE; }
 194
 195         /* Judge 3: Remain Packet Data? = 0x01 */
 196         if(( DRD64_SERVER_RECVSTATUS_PHASE_HEADER == p_recv->i_read_phase ) &&
 197                         ( 0 < p_phead->i_datalen ))             {
 198                 p_recv->i_read_phase    = DRD64_SERVER_RECVSTATUS_PHASE_DATA;
 199
 200                 /* Check BOF Attack */
 201                 if( DRD64_MAX_PACKET_DATA < p_phead->i_datalen )
 202                         { return DRD64_MARSHALD_DISPATCH_RESULT_CLOSE; }
 203                 p_recv->i_remain_bytes  = p_phead->i_datalen;
 204
 205                 return DRD64_MARSHALD_DISPATCH_RESULT_RECEVING;
 206         }
 207
 208         /* Check 2: Standart Packet Header Check */
 209                 /* XXX : NO implement */
 210
 211         /* Check 4: Transport Packet? */
 212
 213         /* Push Readed Command Packet for Resume Pool */
 214         i_recv_id       = Drd64_Server_RecvStatus_PushResumeChain(
 215                                                 i_fds, DRD64_MARSHALD_RECVSTATUS_UNITS );
 216         if( 0 > i_recv_id )
 217                 { return DRD64_MARSHALD_DISPATCH_RESULT_CLOSE; }        // XXX > error
 218
 219         p_recv_new      = Drd64_Server_RecvStatus_GetRecvStatus( i_fds );
 220         assert( NULL != p_recv_new );
 221
 222         // Drd64_Marshald_Dispatch_InitRecvStatus( p_recv_new );
 223         Drd64_Server_RecvStatus_InitRecvStatus( p_recv_new );
 224
 225         /* Exec Packet by Command-Code */
 226         i_result = Drd64_Marshald_Dispatch_ExecPacket(
 227                                                 i_recv_id, p_recv, p_marshald );
 228
 229         return i_result;
 230 }
 231
 232
 233 int
 234         Drd64_Marshald_Dispatch_ExecResumeRecvStatus(
 235                 Drd64_Marshald_MasterInformation *p_marshald )
 236 {
 237         int                                                     i_result;
 238         Drd64_Server_RecvStatus         *p_recv;
 239
 240         p_recv  = Drd64_Server_RecvStatus_GetResumeStart();
 241         while( NULL != p_recv ) {
 242                 if( DRD64_SERVER_RECVSTATUS_STATUS_RESUME
 243                                                         == p_recv->b_recv_status )      {
 244
 245                         i_result = Drd64_Marshald_Dispatch_ExecPacket(
 246                                                         p_recv->i_recvstatus_id, p_recv, p_marshald );
 247
 248                         /* XXX : support for disconnect (CLOSE) */
 249                         /* 0x00 = Judge 1 : Disconnect ( Others Packet ) */
 250                         if( DRD64_MARSHALD_DISPATCH_RESULT_CLOSE == i_result )  {
 251                                 Drd64_Marshald_Dispatch_CloseSocket( p_recv->i_fds_id );
 252                         }
 253                         else if( DRD64_MARSHALD_DISPATCH_RESULT_RESTART == i_result )   {
 254                                 p_recv  = NULL;
 255                         }
 256                 }
 257
 258                 if( NULL != p_recv )    {
 259                         p_recv = (Drd64_Server_RecvStatus *)p_recv->pv_recv_next;
 260                 }
 261                 else    {
 262                         p_recv  = Drd64_Server_RecvStatus_GetResumeStart();
 263                 }
 264         }
 265
 266         return 0x00;
 267 }
 268
 269 int
 270     Drd64_Marshald_Dispatch_Polling(
 271         Drd64_Marshald_MasterInformation *p_marshald )
 272 {
 273         fd_set  fds_now;
 274         int     i_cnt;
 275         int             i_result;
 276         int             i_err;
 277         int             i_pid;
 278         int             i_selects;
 279         int             i_resume_flag;
 280         int     i_socket_new;
 281         int             i_selects_base;
 282         int     i_selects_max;
 283         int             i_selects_last;
 284         //int           i_socket_server;
 285         Drd64_Server_RecvStatus         *p_recv;
 286         Drd64_Server_RecvStatus         *p_recv_resume;
 287         struct  timeval                         tmval;
 288
 289         FD_ZERO( &g_fds_orig );
 290         FD_SET( p_marshald->i_socket_local, &g_fds_orig );
 291         FD_SET( p_marshald->i_socket_inet, &g_fds_orig );
 292
 293         if( p_marshald->i_socket_local > p_marshald->i_socket_inet )
 294                 { i_selects_base        = p_marshald->i_socket_local + 1; }
 295         else
 296                 { i_selects_base        = p_marshald->i_socket_inet + 1; }
 297         i_selects_max = i_selects_base;
 298
 299         tmval.tv_sec    = 0;
 300         tmval.tv_usec   = 5000;
 301
 302         while( 1 )  {
 303                 /* Phase 1: Packet & Signal Polling */
 304                 memcpy( &fds_now, &g_fds_orig, sizeof( struct fd_set ) );
 305                 i_selects = select( i_selects_max, &fds_now, NULL, NULL, &tmval );
 306
 307                 /* Phase 2: Receive Packet */
 308                 if( 0 < i_selects )             {
 309                         //i_socket_server       = -1;
 310                         /*if( FD_ISSET( p_marshald->i_socket_local, &fds_now ) )
 311                                 { i_socket_server       = p_marshald->i_socket_local; }
 312                         else if( FD_ISSET( p_marshald->i_socket_inet, &fds_now ) )
 313                                 { i_socket_server       = p_marshald->i_socket_inet; }
 314
 315                         if( -1 < i_socket_server )      {
 316                                 i_socket_new = Drd64_Marshald_Dispatch_OpenSocket( i_socket_server );
 317                         }
 318                         else    { */
 319
 320                         //VVVVVVVV
 321                         /* Server Socket from Local */
 322                         if( FD_ISSET( p_marshald->i_socket_local, &fds_now ))   {
 323                                 Drd64_Marshald_Dispatch_OpenSocket(
 324                                                                 p_marshald->i_socket_local );
 325                         }
 326
 327                         /* Server Socket from Local */
 328                         if( FD_ISSET( p_marshald->i_socket_inet, &fds_now ))    {
 329                                 Drd64_Marshald_Dispatch_OpenSocket(
 330                                                                 p_marshald->i_socket_inet );
 331                         }
 332
 333                         i_resume_flag   = 0x00;
 334                         for( i_cnt = 0; i_cnt < i_selects_max; i_cnt++ )    {
 335
 336                                 /* Drd64 Clinet & Marshald => No Judge */
 337                                 if(( i_cnt == p_marshald->i_socket_local ) ||
 338                                                 ( i_cnt == p_marshald->i_socket_inet ))
 339                                         { continue; }
 340
 341                                 p_recv  = Drd64_Server_RecvStatus_GetRecvStatus( i_cnt );
 342                                 if( NULL == p_recv )    { continue; }
 343
 344                                 if( FD_ISSET( i_cnt, &fds_now ) )       {
 345                                         /* Read */
 346                                         assert( DRD64_SERVER_RECVSTATUS_STATUS_READ
 347                                                                                 == p_recv->b_recv_status );
 348
 349                                         /*i_err = Drd64_Server_RecvSocket_SocketRead_Cert(
 350                                                                         i_cnt, &i_pid );*/
 351                                         i_err = Drd64_Server_RecvSocket_SocketRead( i_cnt );
 352                                         DRD64_DEBUG_PRINT("SocketRead",i_err,"FD",i_cnt,"DestPid",i_pid);
 353                                         /* Judge Packet */
 354                                         i_result = Drd64_Marshald_Dispatch_JudgePacket(
 355                                                                 i_cnt, i_err, p_recv, &drd64_marshald_info );
 356
 357                                         /* 0x00 = Judge 1 : Disconnect ( Others Packet ) */
 358                                         if( DRD64_MARSHALD_DISPATCH_RESULT_CLOSE == i_result )  {
 359                                                         Drd64_Marshald_Dispatch_CloseSocket( i_cnt );
 360                                         }
 361                                         else if( DRD64_MARSHALD_DISPATCH_RESULT_RESTART
 362                                                                                                                         == i_result )
 363                                                 { i_resume_flag = 0x01; }
 364                                         /* 0x01 = Judge 1 : Reading Next */
 365                                 }
 366                         }
 367
 368                         /* Check Restart Packet (RecvStatus) */
 369                         if( 0x00 != i_resume_flag )             {
 370                                 Drd64_Marshald_Dispatch_ExecResumeRecvStatus(
 371                                                                                 &drd64_marshald_info );
 372                         }
 373
 374                         /* Set Max fd */
 375                         i_selects_last  = Drd64_Server_RecvStatus_GetRecvStatMax();
 376                         if( i_selects_last > i_selects_base )
 377                                 { i_selects_max = i_selects_last; }
 378                         else
 379                                 { i_selects_max = i_selects_base; }
 380                         printf("%d\n", i_selects_max );
 381                 }
 382
 383                 /* Phase 3: Check TimeOut Resume Packet */
 384
 385                 /* Phase 4: Signal Check & Proc */
 386         }
 387
 388         return 0x00;
 389 }
 390
 391
 392 /* EOF of drd64_.c ----------------------------------- */