ACE/ace/Name_Proxy.cpp

   1 #include "ace/Name_Proxy.h"
   2 #include "ace/Log_Category.h"
   3 #include "ace/os_include/arpa/os_inet.h"
   4
   5
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 void
  10 ACE_Name_Proxy::dump (void) const
  11 {
  12 #if defined (ACE_HAS_DUMP)
  13   ACE_TRACE ("ACE_Name_Proxy::dump");
  14
  15   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  16   this->connector_.dump ();
  17   this->peer_.dump ();
  18   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("reactor_ = %x"), this->reactor_));
  19   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  20 #endif /* ACE_HAS_DUMP */
  21 }
  22
  23 // Default constructor.
  24
  25 ACE_Name_Proxy::ACE_Name_Proxy (void)
  26   : reactor_ (0)
  27 {
  28   ACE_TRACE ("ACE_Name_Proxy::ACE_Name_Proxy");
  29 }
  30
  31 // Establish binding with the ACE_Name Server at remote_addr.
  32
  33 int
  34 ACE_Name_Proxy::open (const ACE_INET_Addr &remote_addr,
  35                       ACE_Synch_Options& options)
  36 {
  37   ACE_TRACE ("ACE_Name_Proxy::open");
  38   ACE_Time_Value *timeout = 0;
  39
  40   if (options[ACE_Synch_Options::USE_TIMEOUT])
  41     timeout = const_cast<ACE_Time_Value *> (options.time_value ());
  42
  43   // Initiate the connection.
  44   return this->connector_.connect (this->peer_,
  45                                    remote_addr,
  46                                    timeout);
  47 }
  48
  49 // Establish binding with the ACE_Name Server at remote_addr.
  50
  51 ACE_Name_Proxy::ACE_Name_Proxy (
  52   const ACE_INET_Addr &remote_addr,
  53   ACE_Synch_Options& options)
  54    : reactor_ (0)
  55 {
  56   ACE_TRACE ("ACE_Name_Proxy::ACE_Name_Proxy");
  57   if (this->open (remote_addr, options) == -1
  58       && options[ACE_Synch_Options::USE_TIMEOUT] && errno != EWOULDBLOCK)
  59     ACELIB_ERROR ((LM_ERROR,
  60                 ACE_TEXT ("%p\n"),
  61                 ACE_TEXT ("ACE_Name_Proxy::ACE_Name_Proxy")));
  62 }
  63
  64 // Obtain underlying handle.
  65
  66 /* VIRTUAL */ ACE_HANDLE
  67 ACE_Name_Proxy::get_handle (void) const
  68 {
  69   ACE_TRACE ("ACE_Name_Proxy::get_handle");
  70   return this->peer_.get_handle ();
  71 }
  72
  73 int
  74 ACE_Name_Proxy::request_reply (ACE_Name_Request &request)
  75 {
  76   ACE_TRACE ("ACE_Name_Proxy::request_reply");
  77   void *buffer;
  78   ssize_t length = request.encode (buffer);
  79
  80   if (length == -1)
  81     ACELIB_ERROR_RETURN ((LM_ERROR,
  82                        ACE_TEXT ("%p\n"),
  83                        ACE_TEXT ("encode failed")),
  84                       -1);
  85
  86   // Transmit request via a blocking send.
  87
  88   if (this->peer_.send_n (buffer, length) != length)
  89     ACELIB_ERROR_RETURN ((LM_ERROR,
  90                        ACE_TEXT ("%p\n"),
  91                        ACE_TEXT ("send_n failed")),
  92                       -1);
  93   else
  94     {
  95       ACE_Name_Reply reply;
  96
  97       // Receive reply via blocking read.
  98
  99       if (this->peer_.recv_n (&reply,
 100                               sizeof reply) == -1)
 101         ACELIB_ERROR_RETURN ((LM_ERROR,
 102                            ACE_TEXT ("%p\n"),
 103                            ACE_TEXT ("recv failed")),
 104                           -1);
 105       else if (reply.decode () == -1)
 106         ACELIB_ERROR_RETURN ((LM_ERROR,
 107                            ACE_TEXT ("%p\n"),
 108                            ACE_TEXT ("decode failed")),
 109                           -1);
 110       errno = int (reply.errnum ());
 111       return reply.status ();
 112     }
 113 }
 114
 115 int
 116 ACE_Name_Proxy::send_request (ACE_Name_Request &request)
 117 {
 118   ACE_TRACE ("ACE_Name_Proxy::send_request");
 119   void *buffer;
 120   ssize_t length = request.encode (buffer);
 121
 122   if (length == -1)
 123     ACELIB_ERROR_RETURN ((LM_ERROR,
 124                        ACE_TEXT ("%p\n"),
 125                        ACE_TEXT ("encode failed")),
 126                       -1);
 127
 128   // Transmit request via a blocking send.
 129
 130   else if (this->peer_.send_n (buffer, length) != length)
 131     ACELIB_ERROR_RETURN ((LM_ERROR,
 132                        ACE_TEXT ("%p\n"),
 133                        ACE_TEXT ("send_n failed")),
 134                       -1);
 135   return 0;
 136 }
 137
 138 int
 139 ACE_Name_Proxy::recv_reply (ACE_Name_Request &reply)
 140 {
 141   ACE_TRACE ("ACE_Name_Proxy::recv_reply");
 142   // Read the first 4 bytes to get the length of the message This
 143   // implementation assumes that the first 4 bytes are the length of
 144   // the message.
 145   ssize_t n = this->peer_.recv ((void *) &reply, sizeof (ACE_UINT32));
 146
 147   switch (n)
 148     {
 149     case -1:
 150       ACELIB_DEBUG ((LM_DEBUG,
 151                   ACE_TEXT ("****************** recv_reply returned -1\n")));
 152       // FALLTHROUGH
 153     default:
 154       ACELIB_ERROR ((LM_ERROR,
 155                   ACE_TEXT ("%p got %d bytes, expected %d bytes\n"),
 156                   ACE_TEXT ("recv failed"),
 157                   n,
 158                   sizeof (ACE_UINT32)));
 159       // FALLTHROUGH
 160     case 0:
 161       // We've shutdown unexpectedly
 162       return -1;
 163       // NOTREACHED
 164     case sizeof (ACE_UINT32):
 165       {
 166         // Transform the length into host byte order.
 167         ssize_t length = ACE_NTOHL (reply.length ());
 168
 169         // Receive the rest of the request message.
 170         // @@ beware of blocking read!!!.
 171         n = this->peer_.recv ((void *) (((char *) &reply)
 172                                         + sizeof (ACE_UINT32)),
 173                               length - sizeof (ACE_UINT32));
 174
 175         // Subtract off the size of the part we skipped over...
 176         if (n != ssize_t (length - sizeof (ACE_UINT32)))
 177           {
 178             ACELIB_ERROR ((LM_ERROR,
 179                         ACE_TEXT ("%p expected %d, got %d\n"),
 180                         ACE_TEXT ("invalid length"),
 181                         length,
 182                         n));
 183             return -1;
 184           }
 185
 186         // Decode the request into host byte order.
 187         if (reply.decode () == -1)
 188           {
 189             ACELIB_ERROR ((LM_ERROR,
 190                         ACE_TEXT ("%p\n"),
 191                         ACE_TEXT ("decode failed")));
 192             return -1;
 193           }
 194       }
 195     }
 196   return 0;
 197 }
 198
 199 // Close down the connection to the server.
 200
 201 ACE_Name_Proxy::~ACE_Name_Proxy (void)
 202 {
 203   ACE_TRACE ("ACE_Name_Proxy::~ACE_Name_Proxy");
 204   this->peer_.close ();
 205 }
 206
 207 ACE_END_VERSIONED_NAMESPACE_DECL