ACE/apps/JAWS3/jaws3/Synch_IO.cpp

   1 #include "ace/ACE.h"
   2
   3 #ifndef JAWS_BUILD_DLL
   4 #define JAWS_BUILD_DLL
   5 #endif
   6
   7 #include "jaws3/Jaws_IO.h"
   8 #include "jaws3/Synch_IO.h"
   9 #include "jaws3/Event_Completer.h"
  10
  11 static JAWS_Event_Result
  12 JAWS_synch_send ( ACE_HANDLE handle
  13                 , ACE_Message_Block *mb
  14                 , const ACE_Time_Value *tv = 0
  15                 )
  16 {
  17   JAWS_Event_Result io_result;
  18
  19   ssize_t result = ACE::send_n (handle, mb->rd_ptr (), mb->length (), tv);
  20   if (result < 0)
  21     {
  22       if (errno == ETIME)
  23         {
  24           JAWS_Event_Result tmp_io_result ( 0
  25                                           , JAWS_Event_Result::JE_ERROR
  26                                           , JAWS_Event_Result::JE_SEND_TIMEOUT
  27                                           );
  28           io_result = tmp_io_result;
  29         }
  30       else
  31         {
  32           JAWS_Event_Result tmp_io_result ( 0
  33                                           , JAWS_Event_Result::JE_ERROR
  34                                           , JAWS_Event_Result::JE_SEND_FAIL
  35                                           );
  36           io_result = tmp_io_result;
  37         }
  38     }
  39   else if ((size_t) result < mb->length ())
  40     {
  41       if (result > 0)
  42         mb->rd_ptr (result);
  43
  44       JAWS_Event_Result tmp_io_result ( result
  45                                       , JAWS_Event_Result::JE_ERROR
  46                                       , JAWS_Event_Result::JE_SEND_SHORT
  47                                       );
  48       io_result = tmp_io_result;
  49     }
  50   else
  51     {
  52       if (result > 0)
  53         mb->rd_ptr (result);
  54
  55       JAWS_Event_Result tmp_io_result ( result
  56                                       , JAWS_Event_Result::JE_OK
  57                                       , JAWS_Event_Result::JE_SEND_OK
  58                                       );
  59       io_result = tmp_io_result;
  60     }
  61
  62   return io_result;
  63 }
  64
  65 void
  66 JAWS_Synch_IO::send ( ACE_HANDLE handle
  67                     , ACE_Message_Block *mb
  68                     , JAWS_Event_Completer *completer
  69                     , const ACE_Time_Value &tv
  70                     , void *act
  71                     )
  72 {
  73   JAWS_Event_Result io_result;
  74   const ACE_Time_Value *tvp = 0;
  75
  76   if (ACE_Time_Value::zero < tv)
  77     tvp = &tv;
  78
  79   io_result = JAWS_synch_send (handle, mb, tvp);
  80
  81   if (completer)
  82     completer->output_complete (io_result, act);
  83 }
  84
  85
  86 void
  87 JAWS_Synch_IO::send ( ACE_HANDLE handle
  88                     , ACE_Message_Block *mb
  89                     , JAWS_Event_Completer *completer
  90                     , void *act
  91                     )
  92 {
  93   this->send (handle, mb, completer, ACE_Time_Value::zero, act);
  94 }
  95
  96
  97 void
  98 JAWS_Synch_IO::recv ( ACE_HANDLE handle
  99                     , ACE_Message_Block *mb
 100                     , JAWS_Event_Completer *completer
 101                     , const ACE_Time_Value &tv
 102                     , void *act
 103                     )
 104 {
 105   JAWS_Event_Result io_result;
 106   const ACE_Time_Value *tvp = 0;
 107
 108   if (ACE_Time_Value::zero < tv)
 109     tvp = &tv;
 110
 111   ssize_t result = ACE::recv (handle, mb->wr_ptr (), mb->space (), tvp);
 112   if (result < 0)
 113     {
 114       JAWS_Event_Result tmp_io_result ( 0
 115                                       , JAWS_Event_Result::JE_ERROR
 116                                       , JAWS_Event_Result::JE_RECV_FAIL
 117                                       );
 118       io_result = tmp_io_result;
 119     }
 120   else
 121     {
 122       if (result > 0)
 123         mb->wr_ptr (result);
 124
 125       JAWS_Event_Result tmp_io_result ( result
 126                                       , JAWS_Event_Result::JE_OK
 127                                       , JAWS_Event_Result::JE_RECV_OK
 128                                       );
 129       io_result = tmp_io_result;
 130     }
 131
 132   if (completer)
 133     completer->input_complete (io_result, act);
 134 }
 135
 136
 137 void
 138 JAWS_Synch_IO::recv ( ACE_HANDLE handle
 139                     , ACE_Message_Block *mb
 140                     , JAWS_Event_Completer *completer
 141                     , void *act
 142                     )
 143 {
 144   this->recv (handle, mb, completer, ACE_Time_Value::zero, act);
 145 }
 146
 147
 148 void
 149 JAWS_Synch_IO::transmit ( ACE_HANDLE handle
 150                         , ACE_HANDLE source
 151                         , JAWS_Event_Completer *completer
 152                         , const ACE_Time_Value &tv
 153                         , void *act
 154                         , ACE_Message_Block *header
 155                         , ACE_Message_Block *trailer
 156                         )
 157 {
 158   JAWS_Event_Result io_result;
 159   const ACE_Time_Value *tvp = 0;
 160
 161   if (ACE_Time_Value::zero < tv)
 162     tvp = &tv;
 163
 164   size_t bytes = 0;
 165
 166   if (header)
 167     {
 168       io_result = JAWS_synch_send (handle, header, tvp);
 169       bytes += io_result.bytes ();
 170       if (io_result.status () != JAWS_Event_Result::JE_OK)
 171         {
 172           if (completer)
 173             completer->input_complete (io_result, act);
 174
 175           return;
 176         }
 177     }
 178
 179   ACE_Message_Block buf (8 * 1024);
 180   ssize_t len = 0;
 181   while ((len = ACE::recv (source, buf.wr_ptr (), buf.space (), tvp)) >= 0)
 182     {
 183       if (len == 0)
 184         break;
 185
 186       buf.wr_ptr (len);
 187       io_result = JAWS_synch_send (handle, & buf);
 188       bytes += io_result.bytes ();
 189       if (io_result.status () != JAWS_Event_Result::JE_OK)
 190         {
 191           JAWS_Event_Result tmp_io_result ( bytes
 192                                           , JAWS_Event_Result::JE_ERROR
 193                                           , JAWS_Event_Result::JE_SEND_SHORT
 194                                           );
 195
 196           if (completer)
 197             completer->input_complete (tmp_io_result, act);
 198
 199           return;
 200         }
 201
 202       buf.crunch ();
 203     }
 204
 205   if (trailer)
 206     {
 207       io_result = JAWS_synch_send (handle, trailer, tvp);
 208       bytes += io_result.bytes ();
 209       if (io_result.status () != JAWS_Event_Result::JE_OK)
 210         {
 211           JAWS_Event_Result tmp_io_result ( bytes
 212                                           , JAWS_Event_Result::JE_ERROR
 213                                           , JAWS_Event_Result::JE_SEND_SHORT
 214                                           );
 215
 216           if (completer)
 217             completer->input_complete (tmp_io_result, act);
 218
 219           return;
 220         }
 221     }
 222
 223   if (len == 0)
 224     {
 225       JAWS_Event_Result tmp_io_result ( bytes
 226                                       , JAWS_Event_Result::JE_OK
 227                                       , JAWS_Event_Result::JE_SEND_OK
 228                                       );
 229       io_result = tmp_io_result;
 230     }
 231   else
 232     {
 233       JAWS_Event_Result tmp_io_result ( bytes
 234                                       , JAWS_Event_Result::JE_ERROR
 235                                       , JAWS_Event_Result::JE_SEND_SHORT
 236                                       );
 237       io_result = tmp_io_result;
 238     }
 239
 240   if (completer)
 241     completer->input_complete (io_result, act);
 242 }
 243
 244
 245 void
 246 JAWS_Synch_IO::transmit ( ACE_HANDLE handle
 247                         , ACE_HANDLE source
 248                         , JAWS_Event_Completer *completer
 249                         , void *act
 250                         , ACE_Message_Block *header
 251                         , ACE_Message_Block *trailer
 252                         )
 253 {
 254   this->transmit ( handle
 255                  , source
 256                  , completer
 257                  , ACE_Time_Value::zero
 258                  , act
 259                  , header
 260                  , trailer
 261                  );
 262 }
 263