ACE/ace/Naming_Context.cpp

   1 #include "ace/Get_Opt.h"
   2 #include "ace/Naming_Context.h"
   3 #include "ace/Remote_Name_Space.h"
   4 #include "ace/Local_Name_Space_T.h"
   5 #include "ace/Registry_Name_Space.h"
   6 #include "ace/MMAP_Memory_Pool.h"
   7 #include "ace/Lib_Find.h"
   8 #include "ace/RW_Process_Mutex.h"
   9 #include "ace/OS_NS_string.h"
  10 #include "ace/OS_NS_unistd.h"
  11 #if defined (ACE_HAS_TRACE)
  12 # include "ace/OS_NS_strings.h"
  13 # include "ace/Trace.h"
  14 #endif /* ACE_HAS_TRACE */
  15
  16 #if !defined (__ACE_INLINE__)
  17 #include "ace/Naming_Context.inl"
  18 #endif /* __ACE_INLINE__ */
  19
  20 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 // Make life easier later on...
  23
  24 using LOCAL_NAME_SPACE = ACE_Local_Name_Space<ACE_MMAP_Memory_Pool, ACE_RW_Process_Mutex>;
  25 using LITE_LOCAL_NAME_SPACE = ACE_Local_Name_Space<ACE_Lite_MMAP_Memory_Pool, ACE_RW_Process_Mutex>;
  26
  27 // The ACE_Naming_Context static service object is now defined
  28 // by the ACE_Object_Manager, in Object_Manager.cpp.
  29
  30 int
  31 ACE_Naming_Context::info (ACE_TCHAR **strp,
  32                           size_t length) const
  33 {
  34   ACE_TRACE ("ACE_Naming_Context::info");
  35
  36   ACE_TCHAR buf[BUFSIZ];
  37
  38   ACE_OS::snprintf (buf, BUFSIZ,
  39                     ACE_TEXT ("%s\t#%s\n"),
  40                     ACE_TEXT ("ACE_Naming_Context"),
  41                     ACE_TEXT ("Proxy for making calls to a Name Server"));
  42
  43   if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0)
  44     return -1;
  45   else
  46     ACE_OS::strsncpy (*strp, buf, length);
  47   return static_cast<int> (ACE_OS::strlen (buf));
  48 }
  49
  50 int
  51 ACE_Naming_Context::local ()
  52 {
  53   ACE_TRACE ("ACE_Naming_Context::local");
  54   return ACE_OS::strcmp (this->netnameserver_host_,
  55                          ACE_TEXT ("localhost")) == 0
  56     || ACE_OS::strcmp (this->netnameserver_host_,
  57                        this->hostname_) == 0;
  58 }
  59
  60 int
  61 ACE_Naming_Context::open (Context_Scope_Type scope_in, int lite)
  62 {
  63   ACE_TRACE ("ACE_Naming_Context::open");
  64   ACE_OS::hostname (this->hostname_,
  65                     (sizeof this->hostname_ / sizeof (ACE_TCHAR)));
  66
  67   this->netnameserver_host_ =
  68     this->name_options_->nameserver_host ();
  69   this->netnameserver_port_ =
  70     this->name_options_->nameserver_port ();
  71
  72   // Perform factory operation to select appropriate type of
  73   // Name_Space subclass.
  74
  75 #if (defined (ACE_WIN32) && defined (ACE_USES_WCHAR))
  76 // This only works on Win32 platforms when ACE_USES_WCHAR is turned on
  77
  78   if (this->name_options_->use_registry ())
  79     // Use ACE_Registry
  80     ACE_NEW_RETURN (this->name_space_,
  81                     ACE_Registry_Name_Space (this->name_options_),
  82                     -1);
  83 #endif /* ACE_WIN32 && ACE_USES_WCHAR */
  84   if (!this->name_options_->use_registry ())
  85     {
  86       if (scope_in == ACE_Naming_Context::NET_LOCAL && this->local () == 0)
  87         {
  88           // Use NET_LOCAL name space, set up connection with remote server.
  89           ACE_NEW_RETURN (this->name_space_,
  90                           ACE_Remote_Name_Space (this->netnameserver_host_,
  91                                                  (u_short) this->netnameserver_port_),
  92                           -1);
  93         }
  94       else   // Use NODE_LOCAL or PROC_LOCAL name space.
  95         {
  96           if (lite)
  97             ACE_NEW_RETURN (this->name_space_,
  98                             LITE_LOCAL_NAME_SPACE (scope_in,
  99                                                    this->name_options_),
 100                             -1);
 101           else
 102             ACE_NEW_RETURN (this->name_space_,
 103                             LOCAL_NAME_SPACE (scope_in,
 104                                               this->name_options_),
 105                             -1);
 106         }
 107     }
 108
 109   if (ACE_LOG_MSG->op_status () != 0 || this->name_space_ == 0)
 110     ACELIB_ERROR_RETURN ((LM_ERROR,
 111                        ACE_TEXT ("NAME_SPACE::NAME_SPACE\n")),
 112                       -1);
 113   return 0;
 114 }
 115
 116 int
 117 ACE_Naming_Context::close_down ()
 118 {
 119   ACE_TRACE ("ACE_Naming_Context::close_down");
 120
 121   delete this->name_options_;
 122   this->name_options_ = 0;
 123
 124   return this->close ();
 125 }
 126
 127 int
 128 ACE_Naming_Context::close ()
 129 {
 130   ACE_TRACE ("ACE_Naming_Context::close");
 131
 132   delete this->name_space_;
 133   this->name_space_ = 0;
 134
 135   return 0;
 136 }
 137
 138 ACE_Naming_Context::ACE_Naming_Context ()
 139   : name_options_ (0),
 140     name_space_ (0),
 141     netnameserver_host_ (0),
 142     netnameserver_port_ (0)
 143 {
 144   ACE_TRACE ("ACE_Naming_Context::ACE_Naming_Context");
 145
 146   ACE_NEW (this->name_options_,
 147            ACE_Name_Options);
 148 }
 149
 150 ACE_Naming_Context::ACE_Naming_Context (Context_Scope_Type scope_in,
 151                                         int lite)
 152   : name_options_ (0),
 153     name_space_ (0),
 154     netnameserver_host_ (0)
 155 {
 156   ACE_TRACE ("ACE_Naming_Context::ACE_Naming_Context");
 157
 158   ACE_NEW (this->name_options_,
 159            ACE_Name_Options);
 160
 161   // Initialize.
 162   if (this->open (scope_in, lite) == -1)
 163     ACELIB_ERROR ((LM_ERROR,
 164                 ACE_TEXT ("%p\n"),
 165                 ACE_TEXT ("ACE_Naming_Context::ACE_Naming_Context")));
 166 }
 167
 168 ACE_Name_Options *
 169 ACE_Naming_Context::name_options ()
 170 {
 171   return this->name_options_;
 172 }
 173
 174 int
 175 ACE_Naming_Context::bind (const ACE_NS_WString &name_in,
 176                           const ACE_NS_WString &value_in,
 177                           const char *type_in)
 178 {
 179   ACE_TRACE ("ACE_Naming_Context::bind");
 180   return this->name_space_->bind (name_in, value_in, type_in);
 181 }
 182
 183 int
 184 ACE_Naming_Context::bind (const char *name_in,
 185                           const char *value_in,
 186                           const char *type_in)
 187 {
 188   ACE_TRACE ("ACE_Naming_Context::bind");
 189   return this->bind (ACE_NS_WString (name_in),
 190                      ACE_NS_WString (value_in),
 191                      type_in);
 192 }
 193
 194 int
 195 ACE_Naming_Context::rebind (const ACE_NS_WString &name_in,
 196                             const ACE_NS_WString &value_in,
 197                             const char *type_in)
 198 {
 199   ACE_TRACE ("ACE_Naming_Context::rebind");
 200   return this->name_space_->rebind (name_in,
 201                                     value_in,
 202                                     type_in);
 203 }
 204
 205 int
 206 ACE_Naming_Context::rebind (const char *name_in,
 207                             const char *value_in,
 208                             const char *type_in)
 209 {
 210   ACE_TRACE ("ACE_Naming_Context::rebind");
 211   return rebind (ACE_NS_WString (name_in),
 212                  ACE_NS_WString (value_in),
 213                  type_in);
 214 }
 215
 216 int
 217 ACE_Naming_Context::resolve (const ACE_NS_WString &name_in,
 218                              ACE_NS_WString &value_out,
 219                              char *&type_out)
 220 {
 221   ACE_TRACE ("ACE_Naming_Context::resolve");
 222   return this->name_space_->resolve (name_in,
 223                                      value_out,
 224                                      type_out);
 225 }
 226
 227 int
 228 ACE_Naming_Context::resolve (const char *name_in,
 229                              ACE_NS_WString &value_out,
 230                              char *&type_out)
 231 {
 232   ACE_TRACE ("ACE_Naming_Context::resolve");
 233   return this->resolve (ACE_NS_WString (name_in),
 234                         value_out,
 235                         type_out);
 236 }
 237
 238 int
 239 ACE_Naming_Context::resolve (const char *name_in,
 240                              char *&value_out,
 241                              char *&type_out)
 242 {
 243   ACE_TRACE ("ACE_Naming_Context::resolve");
 244   ACE_NS_WString val_str;
 245
 246   if (this->resolve (ACE_NS_WString (name_in),
 247                      val_str,
 248                      type_out) == -1)
 249     return -1;
 250
 251   // Note that <char_rep> *allocates* the memory!  Thus, caller is
 252   // responsible for deleting it!
 253   value_out = val_str.char_rep ();
 254
 255   return value_out == 0 ? -1 : 0;
 256 }
 257
 258 int
 259 ACE_Naming_Context::unbind (const ACE_NS_WString &name_in)
 260 {
 261   ACE_TRACE ("ACE_Naming_Context::unbind");
 262   return this->name_space_->unbind (name_in);
 263 }
 264
 265 int
 266 ACE_Naming_Context::unbind (const char *name_in)
 267 {
 268   ACE_TRACE ("ACE_Naming_Context::unbind");
 269   return this->unbind (ACE_NS_WString (name_in));
 270 }
 271
 272 int
 273 ACE_Naming_Context::list_names (ACE_PWSTRING_SET &set_out,
 274                                 const ACE_NS_WString &pattern_in)
 275 {
 276   ACE_TRACE ("ACE_Naming_Context::list_names");
 277   return this->name_space_->list_names (set_out,
 278                                         pattern_in);
 279 }
 280
 281 int
 282 ACE_Naming_Context::list_names (ACE_PWSTRING_SET &set_out,
 283                                 const char *pattern_in)
 284 {
 285   ACE_TRACE ("ACE_Naming_Context::list_names");
 286   return this->list_names (set_out,
 287                            ACE_NS_WString (pattern_in));
 288 }
 289
 290 int
 291 ACE_Naming_Context::list_values (ACE_PWSTRING_SET &set_out,
 292                                  const ACE_NS_WString &pattern_in)
 293 {
 294   ACE_TRACE ("ACE_Naming_Context::list_values");
 295   return this->name_space_->list_values (set_out,
 296                                          pattern_in);
 297 }
 298
 299 int
 300 ACE_Naming_Context::list_values (ACE_PWSTRING_SET &set_out,
 301                                  const char *pattern_in)
 302 {
 303   ACE_TRACE ("ACE_Naming_Context::list_values");
 304   return this->list_values (set_out,
 305                             ACE_NS_WString (pattern_in));
 306 }
 307
 308 int
 309 ACE_Naming_Context::list_types (ACE_PWSTRING_SET &set_out,
 310                                  const ACE_NS_WString &pattern_in)
 311 {
 312   ACE_TRACE ("ACE_Naming_Context::list_types");
 313   return this->name_space_->list_types (set_out,
 314                                         pattern_in);
 315 }
 316
 317 int
 318 ACE_Naming_Context::list_types (ACE_PWSTRING_SET &set_out,
 319                                  const char *pattern_in)
 320 {
 321   ACE_TRACE ("ACE_Naming_Context::list_types");
 322   return this->list_types (set_out,
 323                            ACE_NS_WString (pattern_in));
 324 }
 325
 326 int
 327 ACE_Naming_Context::list_name_entries (ACE_BINDING_SET &set_out,
 328                                        const ACE_NS_WString &pattern_in)
 329 {
 330   ACE_TRACE ("ACE_Naming_Context::list_name_entries");
 331   return this->name_space_->list_name_entries (set_out,
 332                                                pattern_in);
 333 }
 334
 335 int
 336 ACE_Naming_Context::list_name_entries (ACE_BINDING_SET &set_out,
 337                                        const char *pattern_in)
 338 {
 339   ACE_TRACE ("ACE_Naming_Context::list_name_entries");
 340   return this->list_name_entries (set_out,
 341                                   ACE_NS_WString (pattern_in));
 342 }
 343
 344 int
 345 ACE_Naming_Context::list_value_entries (ACE_BINDING_SET &set_out,
 346                                         const ACE_NS_WString &pattern_in)
 347 {
 348   ACE_TRACE ("ACE_Naming_Context::list_value_entries");
 349   return this->name_space_->list_value_entries (set_out,
 350                                                 pattern_in);
 351 }
 352
 353 int
 354 ACE_Naming_Context::list_value_entries (ACE_BINDING_SET &set_out,
 355                                         const char *pattern_in)
 356 {
 357   ACE_TRACE ("ACE_Naming_Context::list_value_entries");
 358   return this->list_value_entries (set_out,
 359                                    ACE_NS_WString (pattern_in));
 360 }
 361
 362 int
 363 ACE_Naming_Context::list_type_entries (ACE_BINDING_SET &set_out,
 364                                        const ACE_NS_WString &pattern_in)
 365 {
 366   ACE_TRACE ("ACE_Naming_Context::list_type_entries");
 367   return this->name_space_->list_type_entries (set_out,
 368                                                pattern_in);
 369 }
 370
 371 int
 372 ACE_Naming_Context::list_type_entries (ACE_BINDING_SET &set_out,
 373                                        const char *pattern_in)
 374 {
 375   ACE_TRACE ("ACE_Naming_Context::list_type_entries");
 376   return this->list_type_entries (set_out,
 377                                   ACE_NS_WString (pattern_in));
 378 }
 379
 380 ACE_Naming_Context::~ACE_Naming_Context ()
 381 {
 382   ACE_TRACE ("ACE_Naming_Context::~ACE_Naming_Context");
 383
 384   this->close_down ();
 385 }
 386
 387 void
 388 ACE_Naming_Context::dump ()
 389 {
 390 #if defined (ACE_HAS_DUMP)
 391   ACE_TRACE ("ACE_Naming_Context::dump");
 392   this->name_space_->dump();
 393 #endif /* ACE_HAS_DUMP */
 394 }
 395
 396 int
 397 ACE_Naming_Context::init (int argc, ACE_TCHAR *argv[])
 398 {
 399   if (ACE::debug ())
 400     ACELIB_DEBUG ((LM_DEBUG,
 401                 ACE_TEXT ("ACE_Naming_Context::init\n")));
 402   this->name_options_->parse_args (argc, argv);
 403   return this->open (this->name_options_->context ());
 404 }
 405
 406 int
 407 ACE_Naming_Context::fini ()
 408 {
 409   if (ACE::debug ())
 410     ACELIB_DEBUG ((LM_DEBUG,
 411                 ACE_TEXT ("ACE_Naming_Context::fini\n")));
 412   this->close_down ();
 413   return 0;
 414 }
 415
 416 ACE_Name_Options::ACE_Name_Options ()
 417   : debugging_ (false),
 418     verbosity_ (false),
 419     use_registry_ (false),
 420     nameserver_port_ (ACE_DEFAULT_SERVER_PORT),
 421     nameserver_host_ (ACE_OS::strdup (ACE_DEFAULT_SERVER_HOST)),
 422     process_name_ (0),
 423     database_ (ACE_OS::strdup (ACE_DEFAULT_LOCALNAME)),
 424     base_address_ (ACE_DEFAULT_BASE_ADDR)
 425 {
 426   ACE_TRACE ("ACE_Name_Options::ACE_Name_Options");
 427
 428 #if defined (ACE_DEFAULT_NAMESPACE_DIR)
 429   this->namespace_dir_ = ACE_OS::strdup (ACE_DEFAULT_NAMESPACE_DIR);
 430 #else /* ACE_DEFAULT_NAMESPACE_DIR */
 431   size_t pathsize = (MAXPATHLEN + 1) * sizeof (ACE_TCHAR);
 432 #if defined (ACE_HAS_ALLOC_HOOKS)
 433   this->namespace_dir_ = static_cast <ACE_TCHAR *> (ACE_Allocator::instance()->malloc (pathsize));
 434 #else
 435   this->namespace_dir_ = static_cast <ACE_TCHAR *> (ACE_OS::malloc (pathsize));
 436 #endif /* ACE_HAS_ALLOC_HOOKS */
 437
 438   if (ACE::get_temp_dir (this->namespace_dir_, MAXPATHLEN) == -1)
 439     {
 440       ACELIB_ERROR ((LM_ERROR,
 441                   ACE_TEXT ("Temporary path too long, ")
 442                   ACE_TEXT ("defaulting to current directory\n")));
 443       ACE_OS::strcpy (this->namespace_dir_, ACE_TEXT ("."));
 444       ACE_OS::strcat (this->namespace_dir_, ACE_DIRECTORY_SEPARATOR_STR);
 445     }
 446 #endif /* ACE_DEFAULT_NAMESPACE_DIR */
 447 }
 448
 449 ACE_Name_Options::~ACE_Name_Options ()
 450 {
 451   ACE_TRACE ("ACE_Name_Options::~ACE_Name_Options");
 452
 453 #if defined (ACE_HAS_ALLOC_HOOKS)
 454   ACE_Allocator::instance()->free ((void *) this->nameserver_host_);
 455   ACE_Allocator::instance()->free ((void *) this->namespace_dir_ );
 456   ACE_Allocator::instance()->free ((void *) this->process_name_ );
 457   ACE_Allocator::instance()->free ((void *) this->database_ );
 458 #else
 459   ACE_OS::free ((void *) this->nameserver_host_);
 460   ACE_OS::free ((void *) this->namespace_dir_ );
 461   ACE_OS::free ((void *) this->process_name_ );
 462   ACE_OS::free ((void *) this->database_ );
 463 #endif /* ACE_HAS_ALLOC_HOOKS */
 464 }
 465
 466 ACE_ALLOC_HOOK_DEFINE(ACE_Name_Options)
 467
 468 void
 469 ACE_Name_Options::nameserver_port (int port)
 470 {
 471   ACE_TRACE ("ACE_Name_Options::nameserver_port");
 472   this->nameserver_port_ = port;
 473 }
 474
 475 int
 476 ACE_Name_Options::nameserver_port ()
 477 {
 478   ACE_TRACE ("ACE_Name_Options::nameserver_port");
 479   return this->nameserver_port_;
 480 }
 481
 482 void
 483 ACE_Name_Options::namespace_dir (const ACE_TCHAR *dir)
 484 {
 485   ACE_TRACE ("ACE_Name_Options::namespace_dir");
 486 #if defined (ACE_HAS_ALLOC_HOOKS)
 487   ACE_Allocator::instance()->free ((void *) this->namespace_dir_ );
 488 #else
 489   ACE_OS::free ((void *) this->namespace_dir_ );
 490 #endif /* ACE_HAS_ALLOC_HOOKS */
 491   this->namespace_dir_ = ACE_OS::strdup (dir);
 492 }
 493
 494 void
 495 ACE_Name_Options::process_name (const ACE_TCHAR *pname)
 496 {
 497   ACE_TRACE ("ACE_Name_Options::process_name");
 498   const ACE_TCHAR *t = ACE::basename (pname, ACE_DIRECTORY_SEPARATOR_CHAR);
 499 #if defined (ACE_HAS_ALLOC_HOOKS)
 500   ACE_Allocator::instance()->free ((void *) this->process_name_ );
 501 #else
 502   ACE_OS::free ((void *) this->process_name_ );
 503 #endif /* ACE_HAS_ALLOC_HOOKS */
 504   this->process_name_ = ACE_OS::strdup (t);
 505 }
 506
 507 void
 508 ACE_Name_Options::nameserver_host (const ACE_TCHAR *host)
 509 {
 510   ACE_TRACE ("ACE_Name_Options::nameserver_host");
 511 #if defined (ACE_HAS_ALLOC_HOOKS)
 512   ACE_Allocator::instance()->free ((void *) this->nameserver_host_ );
 513 #else
 514   ACE_OS::free ((void *) this->nameserver_host_ );
 515 #endif /* ACE_HAS_ALLOC_HOOKS */
 516   this->nameserver_host_ = ACE_OS::strdup (host);
 517 }
 518
 519 const ACE_TCHAR *
 520 ACE_Name_Options::nameserver_host ()
 521 {
 522   ACE_TRACE ("ACE_Name_Options::nameserver_host");
 523   return this->nameserver_host_;
 524 }
 525
 526 const ACE_TCHAR *
 527 ACE_Name_Options::database ()
 528 {
 529   ACE_TRACE ("ACE_Name_Options::database");
 530   return this->database_;
 531 }
 532
 533 void
 534 ACE_Name_Options::database (const ACE_TCHAR *db)
 535 {
 536   ACE_TRACE ("ACE_Name_Options::database");
 537 #if defined (ACE_HAS_ALLOC_HOOKS)
 538   ACE_Allocator::instance()->free ((void *) this->database_);
 539 #else
 540   ACE_OS::free ((void *) this->database_);
 541 #endif /* ACE_HAS_ALLOC_HOOKS */
 542   this->database_ = ACE_OS::strdup (db);
 543 }
 544
 545 char *
 546 ACE_Name_Options::base_address ()
 547 {
 548   ACE_TRACE ("ACE_Name_Options::base_address");
 549   return this->base_address_;
 550 }
 551
 552 void
 553 ACE_Name_Options::base_address (char *base_address)
 554 {
 555   ACE_TRACE ("ACE_Name_Options::base_address");
 556   this->base_address_ = base_address;
 557 }
 558
 559 ACE_Naming_Context::Context_Scope_Type
 560 ACE_Name_Options::context ()
 561 {
 562   ACE_TRACE ("ACE_Name_Options::context");
 563   return this->context_;
 564 }
 565
 566 void
 567 ACE_Name_Options::context (ACE_Naming_Context::Context_Scope_Type context)
 568 {
 569   ACE_TRACE ("ACE_Name_Options::context");
 570   this->context_ = context;
 571 }
 572
 573 void
 574 ACE_Name_Options::parse_args (int argc, ACE_TCHAR *argv[])
 575 {
 576   ACE_TRACE ("ACE_Name_Options::parse_args");
 577
 578   const ACE_TCHAR* program_name = 0;
 579
 580   // Argc can be 0 on some platforms like VxWorks.
 581   if (argc > 0)
 582     program_name = argv[0];
 583
 584   ACE_LOG_MSG->open (program_name);
 585   this->process_name (program_name);
 586
 587   // Default is to use the PROC_LOCAL context...
 588   this->context (ACE_Naming_Context::PROC_LOCAL);
 589
 590   // Make the database name the same as the process name by default
 591   // (note that this makes a copy of the process_name_ so that we can
 592   // clean it up in the destructor).
 593   this->database (this->process_name ());
 594
 595   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("b:c:dh:l:P:p:s:T:vr"));
 596
 597   for (int c; (c = get_opt ()) != -1; )
 598     switch (c)
 599       {
 600       case 'c':
 601         {
 602           if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("PROC_LOCAL")) == 0)
 603             this->context (ACE_Naming_Context::PROC_LOCAL);
 604           else if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("NODE_LOCAL")) == 0)
 605             this->context (ACE_Naming_Context::NODE_LOCAL);
 606           else if (ACE_OS::strcmp (get_opt.opt_arg (), ACE_TEXT ("NET_LOCAL")) == 0)
 607             this->context (ACE_Naming_Context::NET_LOCAL);
 608         }
 609         break;
 610       case 'd':
 611         this->debugging_ = true;
 612         break;
 613       case 'r':
 614         this->use_registry_ = true;
 615         break;
 616       case 'h':
 617         this->nameserver_host (get_opt.opt_arg ());
 618         break;
 619       case 'l':
 620         this->namespace_dir (get_opt.opt_arg ());
 621         break;
 622       case 'P':
 623         this->process_name (get_opt.opt_arg ());
 624         break;
 625       case 'p':
 626         this->nameserver_port (ACE_OS::atoi (get_opt.opt_arg ()));
 627         break;
 628       case 's':
 629         this->database (get_opt.opt_arg ());
 630         break;
 631       case 'b':
 632         this->base_address
 633           (static_cast<char *> (ACE_OS::atop (get_opt.opt_arg ())));
 634         break;
 635       case 'T':
 636 #if defined (ACE_HAS_TRACE)
 637         if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT ("ON")) == 0)
 638           ACE_Trace::start_tracing ();
 639         else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT ("OFF")) == 0)
 640           ACE_Trace::stop_tracing ();
 641 #endif /* ACE_HAS_TRACE */
 642         break;
 643       case 'v':
 644         this->verbosity_ = true;
 645         break;
 646       default:
 647 #ifndef ACE_LACKS_STDERR
 648         ACE_OS::fprintf (stderr, "%s\n"
 649                          "\t[-d] (enable debugging)\n"
 650                          "\t[-h nameserver host]\n"
 651                          "\t[-l namespace directory]\n"
 652                          "\t[-P processname]\n"
 653                          "\t[-p nameserver port]\n"
 654                          "\t[-s database name]\n"
 655                          "\t[-b base address]\n"
 656                          "\t[-v] (verbose)\n"
 657                          "\t[-r] (use Win32 Registry)\n",
 658                          ACE_TEXT_ALWAYS_CHAR (argv[0]));
 659 #endif
 660         /* NOTREACHED */
 661         break;
 662       }
 663 }
 664
 665 // The following Factory is used by the ACE_Service_Config and
 666 // svc.conf file to dynamically initialize the state of the Name
 667 // Server client.
 668
 669 ACE_FACTORY_DEFINE (ACE, ACE_Naming_Context)
 670 ACE_STATIC_SVC_DEFINE (ACE_Naming_Context,
 671                        ACE_TEXT ("ACE_Naming_Context"),
 672                        ACE_SVC_OBJ_T,
 673                        &ACE_SVC_NAME (ACE_Naming_Context),
 674                        ACE_Service_Type::DELETE_THIS |
 675                        ACE_Service_Type::DELETE_OBJ,
 676                        0)
 677 ACE_STATIC_SVC_REQUIRE (ACE_Naming_Context)
 678
 679 ACE_END_VERSIONED_NAMESPACE_DECL