dep/ACE_wrappers/ace/Remote_Name_Space.cpp

   1 #include "ace/Remote_Name_Space.h"
   2 #include "ace/Auto_Ptr.h"
   3 #include "ace/Log_Msg.h"
   4 #include "ace/SString.h"
   5 #include "ace/OS_NS_string.h"
   6
   7 ACE_RCSID (ace,
   8            Remote_Name_Space,
   9            "$Id: Remote_Name_Space.cpp 80826 2008-03-04 14:51:23Z wotte $")
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 int
  14 ACE_Remote_Name_Space::open (const ACE_TCHAR *servername, u_short port)
  15 {
  16   ACE_TRACE ("ACE_Remote_Name_Space::open");
  17   ACE_INET_Addr servaddr;
  18
  19   // Initialize Addr
  20   if (servaddr.set (port, servername) == -1)
  21     return -1;
  22
  23   // Connect to Name Server process.
  24   if (this->ns_proxy_.open (servaddr) == -1)
  25     return -1;
  26
  27   return 0;
  28 }
  29
  30 ACE_Remote_Name_Space::ACE_Remote_Name_Space (void)
  31 {
  32   ACE_TRACE ("ACE_Remote_Name_Space::ACE_Remote_Name_Space");
  33 }
  34
  35 ACE_Remote_Name_Space::ACE_Remote_Name_Space (const ACE_TCHAR *hostname,
  36                                               u_short port)
  37 {
  38   ACE_TRACE ("ACE_Remote_Name_Space::ACE_Remote_Name_Space");
  39   if (this->open (hostname, port) == -1)
  40     ACE_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Remote_Name_Space::ACE_Remote_Name_Space")));
  41 }
  42
  43 int
  44 ACE_Remote_Name_Space::bind (const ACE_NS_WString &name,
  45                              const ACE_NS_WString &value,
  46                              const char *type)
  47 {
  48   ACE_TRACE ("ACE_Remote_Name_Space::bind");
  49   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
  50   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> value_urep (value.rep ());
  51   ACE_UINT32 name_len =
  52     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
  53   ACE_UINT32 value_len =
  54     static_cast<ACE_UINT32> (value.length () * sizeof (ACE_WCHAR_T));
  55   ACE_UINT32 type_len =
  56     static_cast<ACE_UINT32> (ACE_OS::strlen (type));
  57   ACE_Name_Request request (ACE_Name_Request::BIND,
  58                             name_urep.get (),
  59                             name_len,
  60                             value_urep.get (),
  61                             value_len,
  62                             type,
  63                             type_len);
  64   return this->ns_proxy_.request_reply (request);
  65 }
  66
  67 int
  68 ACE_Remote_Name_Space::rebind (const ACE_NS_WString &name,
  69                                const ACE_NS_WString &value,
  70                                const char *type)
  71 {
  72   ACE_TRACE ("ACE_Remote_Name_Space::rebind");
  73   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
  74   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> value_urep (value.rep ());
  75   ACE_UINT32 name_len =
  76     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
  77   ACE_UINT32 value_len =
  78     static_cast<ACE_UINT32> (value.length () * sizeof (ACE_WCHAR_T));
  79   ACE_UINT32 type_len =
  80     static_cast<ACE_UINT32> (ACE_OS::strlen (type));
  81   ACE_Name_Request request (ACE_Name_Request::REBIND,
  82                             name_urep.get (),
  83                             name_len,
  84                             value_urep.get (),
  85                             value_len,
  86                             type,
  87                             type_len);
  88   return this->ns_proxy_.request_reply (request);
  89 }
  90
  91 int
  92 ACE_Remote_Name_Space::resolve (const ACE_NS_WString &name,
  93                                 ACE_NS_WString &value,
  94                                 char *&type)
  95 {
  96   ACE_TRACE ("ACE_Remote_Name_Space::resolve");
  97   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
  98   ACE_UINT32 name_len =
  99     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
 100   ACE_Name_Request request (ACE_Name_Request::RESOLVE,
 101                             name_urep.get (),
 102                             name_len,
 103                             0, 0, 0, 0);
 104
 105   if (this->ns_proxy_.send_request (request) == -1)
 106     return -1;
 107
 108   ACE_Name_Request reply;
 109
 110   if (this->ns_proxy_.recv_reply (reply) == -1)
 111     return -1;
 112
 113   ACE_NS_WString temp (reply.value (), reply.value_len () / sizeof (ACE_WCHAR_T));
 114   value = temp;
 115   ACE_NEW_RETURN (type,
 116                   char[reply.type_len () + 1],
 117                   -1);
 118   ACE_OS::strcpy (type, reply.type ());
 119   return 0;
 120 }
 121
 122 int
 123 ACE_Remote_Name_Space::unbind (const ACE_NS_WString &name)
 124 {
 125   ACE_TRACE ("ACE_Remote_Name_Space::unbind");
 126   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
 127   ACE_UINT32 name_len =
 128     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
 129   ACE_Name_Request request (ACE_Name_Request::UNBIND,
 130                             name_urep.get (),
 131                             name_len,
 132                             0, 0, 0, 0);
 133   return this->ns_proxy_.request_reply (request);
 134 }
 135
 136 int
 137 ACE_Remote_Name_Space::list_names (ACE_WSTRING_SET &set,
 138                                    const ACE_NS_WString &pattern)
 139 {
 140   ACE_TRACE ("ACE_Remote_Name_Space::list_names");
 141   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 142   ACE_UINT32 pattern_len =
 143     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 144   ACE_Name_Request request (ACE_Name_Request::LIST_NAMES,
 145                             pattern_urep.get (),
 146                             pattern_len,
 147                             0, 0, 0, 0);
 148   if (this->ns_proxy_.send_request (request) == -1)
 149     return -1;
 150
 151   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 152
 153   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 154     {
 155       if (this->ns_proxy_.recv_reply (reply) == -1)
 156         ACE_ERROR_RETURN ((LM_ERROR,
 157                            ACE_TEXT ("%p\n"),
 158                            ACE_TEXT ("ACE_Remote_Name_Space::list_names")),
 159                            -1);
 160       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 161         {
 162           ACE_NS_WString name (reply.name (),
 163                                reply.name_len () / sizeof (ACE_WCHAR_T));
 164           set.insert (name);
 165         }
 166     }
 167   return 0;
 168 }
 169
 170 int
 171 ACE_Remote_Name_Space::list_values (ACE_WSTRING_SET &set,
 172                                     const ACE_NS_WString &pattern)
 173 {
 174   ACE_TRACE ("ACE_Remote_Name_Space::list_values");
 175   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 176   ACE_UINT32 pattern_len =
 177     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 178   ACE_Name_Request request (ACE_Name_Request::LIST_VALUES,
 179                             pattern_urep.get (),
 180                             pattern_len,
 181                             0, 0, 0, 0);
 182   if (this->ns_proxy_.send_request (request) == -1)
 183     return -1;
 184
 185   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 186
 187   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 188     {
 189       if (this->ns_proxy_.recv_reply (reply) == -1)
 190         ACE_ERROR_RETURN ((LM_ERROR,
 191                            ACE_TEXT ("%p\n"),
 192                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
 193                            -1);
 194       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 195         {
 196           ACE_NS_WString value (reply.value (),
 197                                 reply.value_len () / sizeof (ACE_WCHAR_T));
 198           set.insert (value);
 199         }
 200     }
 201
 202   return 0;
 203 }
 204
 205 int
 206 ACE_Remote_Name_Space::list_types (ACE_WSTRING_SET &set,
 207                                    const ACE_NS_WString &pattern)
 208 {
 209   ACE_TRACE ("ACE_Remote_Name_Space::list_types");
 210   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 211   ACE_UINT32 pattern_len =
 212     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 213   ACE_Name_Request request (ACE_Name_Request::LIST_TYPES,
 214                             pattern_urep.get (),
 215                             pattern_len,
 216                             0, 0, 0, 0);
 217
 218   if (this->ns_proxy_.send_request (request) == -1)
 219     return -1;
 220
 221   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 222
 223   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 224     {
 225       if (this->ns_proxy_.recv_reply (reply) == -1)
 226         ACE_ERROR_RETURN ((LM_ERROR,
 227                            ACE_TEXT ("%p\n"),
 228                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
 229                            -1);
 230       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 231         {
 232           ACE_NS_WString type (reply.type ());
 233           set.insert (type);
 234         }
 235     }
 236
 237   return 0;
 238 }
 239
 240 int
 241 ACE_Remote_Name_Space::list_name_entries (ACE_BINDING_SET &set,
 242                                           const ACE_NS_WString &pattern)
 243 {
 244   ACE_TRACE ("ACE_Remote_Name_Space::list_name_entries");
 245   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 246   ACE_UINT32 pattern_len =
 247     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 248   ACE_Name_Request request (ACE_Name_Request::LIST_NAME_ENTRIES,
 249                             pattern_urep.get (),
 250                             pattern_len,
 251                             0, 0, 0, 0);
 252
 253   if (this->ns_proxy_.send_request (request) == -1)
 254     return -1;
 255
 256   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 257
 258   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 259     {
 260       if (this->ns_proxy_.recv_reply (reply) == -1)
 261         ACE_ERROR_RETURN ((LM_ERROR,
 262                            ACE_TEXT ("%p\n"),
 263                            ACE_TEXT ("ACE_Remote_Name_Space::list_names")),
 264                            -1);
 265       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 266         {
 267           ACE_NS_WString name (reply.name (),
 268                                reply.name_len () / sizeof (ACE_WCHAR_T));
 269           ACE_NS_WString value (reply.value (),
 270                                 reply.value_len () / sizeof (ACE_WCHAR_T));
 271           ACE_Name_Binding entry (name,
 272                                   value,
 273                                   reply.type ());
 274           if (set.insert (entry) == -1)
 275             return -1;
 276         }
 277     }
 278   return 0;
 279 }
 280
 281 int
 282 ACE_Remote_Name_Space::list_value_entries (ACE_BINDING_SET &set,
 283                                            const ACE_NS_WString &pattern)
 284 {
 285   ACE_TRACE ("ACE_Remote_Name_Space::list_value_entries");
 286   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 287   ACE_UINT32 pattern_len =
 288     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 289   ACE_Name_Request request (ACE_Name_Request::LIST_VALUE_ENTRIES,
 290                             pattern_urep.get (),
 291                             pattern_len,
 292                             0, 0, 0, 0);
 293
 294   if (this->ns_proxy_.send_request (request) == -1)
 295     return -1;
 296
 297   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 298
 299   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 300     {
 301       if (this->ns_proxy_.recv_reply (reply) == -1)
 302         ACE_ERROR_RETURN ((LM_ERROR,
 303                            ACE_TEXT ("%p\n"),
 304                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
 305                            -1);
 306       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 307         {
 308           ACE_NS_WString name (reply.name (),
 309                                reply.name_len () / sizeof (ACE_WCHAR_T));
 310           ACE_NS_WString value (reply.value (),
 311                                 reply.value_len () / sizeof (ACE_WCHAR_T));
 312           ACE_Name_Binding entry (name,
 313                                   value,
 314                                   reply.type());
 315           if (set.insert (entry) == -1)
 316             return -1;
 317         }
 318     }
 319   return 0;
 320 }
 321
 322 int
 323 ACE_Remote_Name_Space::list_type_entries (ACE_BINDING_SET &set,
 324                                           const ACE_NS_WString &pattern)
 325 {
 326   ACE_TRACE ("ACE_Remote_Name_Space::list_type_entries");
 327   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
 328   ACE_UINT32 pattern_len =
 329     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
 330   ACE_Name_Request request (ACE_Name_Request::LIST_TYPE_ENTRIES,
 331                             pattern_urep.get (),
 332                             pattern_len,
 333                             0, 0, 0, 0);
 334
 335   if (this->ns_proxy_.send_request (request) == -1)
 336     return -1;
 337
 338   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
 339
 340   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 341     {
 342       if (this->ns_proxy_.recv_reply (reply) == -1)
 343         ACE_ERROR_RETURN ((LM_ERROR,
 344                            ACE_TEXT ("%p\n"),
 345                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
 346                           -1);
 347       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
 348         {
 349           ACE_NS_WString name (reply.name (),
 350                                reply.name_len () / sizeof (ACE_WCHAR_T));
 351           ACE_NS_WString value (reply.value (),
 352                                 reply.value_len () / sizeof (ACE_WCHAR_T));
 353           ACE_Name_Binding entry (name,
 354                                   value,
 355                                   reply.type ());
 356           if (set.insert (entry) == -1)
 357               return -1;
 358         }
 359     }
 360   return 0;
 361 }
 362
 363 ACE_Remote_Name_Space::~ACE_Remote_Name_Space (void)
 364 {
 365   ACE_TRACE ("ACE_Remote_Name_Space::~ACE_Remote_Name_Space");
 366 }
 367
 368 void
 369 ACE_Remote_Name_Space::dump (void) const
 370 {
 371 #if defined (ACE_HAS_DUMP)
 372   ACE_TRACE ("ACE_Remote_Name_Space::dump");
 373
 374   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 375   this->ns_proxy_.dump ();
 376   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 377 #endif /* ACE_HAS_DUMP */
 378 }
 379
 380 ACE_END_VERSIONED_NAMESPACE_DECL