TAO/orbsvcs/ImplRepo_Service/Activator_Options.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    Activator_Options.cpp
   4  *
   5  *  @author Darrell Brunsch <brunsch@cs.wustl.edu>
   6  */
   7 //=============================================================================
   8 #include "Activator_Options.h"
   9
  10 #include "ace/Arg_Shifter.h"
  11 #include "ace/OS_NS_strings.h"
  12 #include "orbsvcs/Log_Macros.h"
  13
  14 #if defined (ACE_WIN32)
  15 static const HKEY SERVICE_REG_ROOT = HKEY_LOCAL_MACHINE;
  16 // This string must agree with the one used in Activator_NT_Service.h
  17 static const ACE_TCHAR *SERVICE_REG_PATH =
  18   ACE_TEXT ("SYSTEM\\CurrentControlSet\\Services\\TAOImRActivator\\Parameters");
  19 #endif /* ACE_WIN32 */
  20
  21 Activator_Options::Activator_Options ()
  22 : debug_ (0)
  23 , service_ (false)
  24 , notify_imr_ (false)
  25 , induce_delay_ (0)
  26 , service_command_(SC_NONE)
  27 , env_buf_len_ (Activator_Options::ENVIRONMENT_BUFFER)
  28 , max_env_vars_ (Activator_Options::ENVIRONMENT_MAX_VARS)
  29 , detach_child_ (
  30 #if defined IMR_DETACH_CHILD_DEF
  31                  true
  32 #else
  33                  false
  34 #endif
  35                  )
  36 {
  37 }
  38
  39 int
  40 Activator_Options::parse_args (int &argc, ACE_TCHAR *argv[])
  41 {
  42   ACE_Arg_Shifter shifter (argc, argv);
  43
  44   while (shifter.is_anything_left ())
  45     {
  46       if (ACE_OS::strcasecmp (shifter.get_current (),
  47                               ACE_TEXT ("-c")) == 0)
  48         {
  49           shifter.consume_arg ();
  50
  51           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
  52             {
  53               ORBSVCS_ERROR ((LM_ERROR, "Error: -c option needs a command\n"));
  54               this->print_usage ();
  55               return -1;
  56             }
  57
  58           if (ACE_OS::strcasecmp (shifter.get_current (),
  59                                    ACE_TEXT ("install")) == 0)
  60             {
  61               this->service_command_ = SC_INSTALL;
  62             }
  63           else if (ACE_OS::strcasecmp (shifter.get_current (),
  64                                    ACE_TEXT ("remove")) == 0)
  65             {
  66               this->service_command_ = SC_REMOVE;
  67             }
  68           else if (ACE_OS::strcasecmp (shifter.get_current (),
  69                                    ACE_TEXT ("install_no_imr")) == 0)
  70             {
  71               this->service_command_ = SC_INSTALL_NO_LOCATOR;
  72             }
  73           else
  74             {
  75               ORBSVCS_ERROR((LM_ERROR, "Error: Unknown service command : %s\n", shifter.get_current()));
  76               this->print_usage ();
  77               return -1;
  78             }
  79         }
  80       else if (ACE_OS::strcasecmp (shifter.get_current (),
  81                                    ACE_TEXT ("-d")) == 0)
  82         {
  83           shifter.consume_arg ();
  84
  85           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
  86             {
  87               ORBSVCS_ERROR ((LM_ERROR, "Error: -d option needs a debuglevel\n"));
  88               this->print_usage ();
  89               return -1;
  90             }
  91
  92           this->debug_ = ACE_OS::atoi (shifter.get_current ());
  93         }
  94       else if (ACE_OS::strcasecmp (shifter.get_current (),
  95                                    ACE_TEXT ("-e")) == 0)
  96         {
  97           shifter.consume_arg ();
  98
  99           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 100             {
 101               ORBSVCS_ERROR ((LM_ERROR, "Error: -e option needs "
 102                                     "an environment buffer length\n"));
 103               this->print_usage ();
 104               return -1;
 105             }
 106
 107           this->env_buf_len_ = ACE_OS::atoi (shifter.get_current ());
 108         }
 109       else if (ACE_OS::strcasecmp (shifter.get_current (),
 110                                    ACE_TEXT ("-m")) == 0)
 111         {
 112           shifter.consume_arg ();
 113
 114           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 115             {
 116               ORBSVCS_ERROR ((LM_ERROR, "Error: -m option needs "
 117                                     "a maximum number of environment vars\n"));
 118               this->print_usage ();
 119               return -1;
 120             }
 121
 122           this->max_env_vars_ = ACE_OS::atoi (shifter.get_current ());
 123         }
 124       else if (ACE_OS::strcasecmp (shifter.get_current (),
 125                                    ACE_TEXT ("-o")) == 0)
 126         {
 127           shifter.consume_arg ();
 128
 129           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 130             {
 131               ORBSVCS_ERROR ((LM_ERROR, "Error: -o option needs a filename\n"));
 132               this->print_usage ();
 133               return -1;
 134             }
 135           this->ior_output_file_ = shifter.get_current ();
 136         }
 137       else if (ACE_OS::strcasecmp (shifter.get_current (),
 138                                    ACE_TEXT ("-s")) == 0)
 139         {
 140           this->service_ = true;
 141         }
 142       else if ((ACE_OS::strcasecmp (shifter.get_current (),
 143                                     ACE_TEXT ("-?")) == 0)
 144                || (ACE_OS::strcasecmp (shifter.get_current (),
 145                                        ACE_TEXT ("-h")) == 0))
 146         {
 147           this->print_usage ();
 148           return 1;
 149         }
 150       else if (ACE_OS::strcasecmp (shifter.get_current (),
 151                                    ACE_TEXT ("-n")) == 0)
 152         {
 153           shifter.consume_arg ();
 154
 155           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 156             {
 157               ORBSVCS_ERROR ((LM_ERROR, "Error: -n option needs a name\n"));
 158               this->print_usage ();
 159               return -1;
 160             }
 161           this->name_ = ACE_TEXT_ALWAYS_CHAR(shifter.get_current ());
 162         }
 163       else if (ACE_OS::strcasecmp (shifter.get_current (),
 164                                    ACE_TEXT ("-l")) == 0)
 165         {
 166           this->notify_imr_ = true;
 167         }
 168       else if (ACE_OS::strcasecmp (shifter.get_current (),
 169                                    ACE_TEXT ("-delay")) == 0)
 170         {
 171           shifter.consume_arg ();
 172
 173           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 174             {
 175               ORBSVCS_ERROR ((LM_ERROR, "Error: -delay option needs a value\n"));
 176               this->print_usage ();
 177               return -1;
 178             }
 179           this->induce_delay_ = ACE_OS::atoi (shifter.get_current ());
 180         }
 181       else if (ACE_OS::strcasecmp (shifter.get_current (),
 182                                    ACE_TEXT ("-detach")) == 0)
 183         {
 184           shifter.consume_arg ();
 185
 186           if (!shifter.is_anything_left () || shifter.get_current ()[0] == '-')
 187             {
 188               ORBSVCS_ERROR ((LM_ERROR, "Error: -detach option needs a value\n"));
 189               this->print_usage ();
 190               return -1;
 191             }
 192           this->detach_child_ = ACE_OS::atoi (shifter.get_current ()) != 0;
 193         }
 194
 195       else
 196         {
 197           shifter.ignore_arg ();
 198           continue;
 199         }
 200
 201       shifter.consume_arg ();
 202     }
 203   return 0;
 204 }
 205
 206 int
 207 Activator_Options::init (int argc, ACE_TCHAR *argv[])
 208 {
 209   // Make an initial pass through and grab the arguments that we recognize.
 210   // This may also run the commands to install or remove the nt service.
 211   int result = this->parse_args (argc, argv);
 212   if (result != 0)
 213     {
 214       return result;
 215     }
 216
 217   for (int i = 0; i < argc; ++i)
 218     {
 219       this->cmdline_ += ACE_CString (ACE_TEXT_ALWAYS_CHAR(argv[i])) + ACE_CString (" ");
 220     }
 221
 222   return 0;
 223 }
 224
 225 int
 226 Activator_Options::init_from_registry ()
 227 {
 228   this->load_registry_options();
 229   return 0;
 230 }
 231
 232 void
 233 Activator_Options::print_usage () const
 234 {
 235   ORBSVCS_ERROR ((LM_ERROR,
 236               "Usage:\n"
 237               "\n"
 238               "ImR_Activator [-c cmd] [-d 0|1|2] [-e buflen] [-o file] [-l] [-n name] [-m maxenv]\n"
 239               "\n"
 240               "  -c command  Runs service commands\n"
 241               "              ('install' or 'remove' or 'install_no_imr')\n"
 242               "  -d level    Sets the debug level\n"
 243               "  -e buflen   Set the environment buffer length in bytes for activated servants\n"
 244               "  -o file     Outputs the ImR's IOR to a file\n"
 245               "  -l          Notify the ImR when a process exits\n"
 246               "  -n name     Specify a name for the Activator\n"
 247               "  -delay ms   When using -l to notify, induce a delay of ms before notifying\n")
 248              );
 249 }
 250
 251 int
 252 Activator_Options::save_registry_options()
 253 {
 254 #if defined (ACE_WIN32)
 255   HKEY key = 0;
 256   // Create or open the parameters key
 257   LONG err = ACE_TEXT_RegCreateKeyEx (SERVICE_REG_ROOT,
 258                              SERVICE_REG_PATH,
 259                              0,
 260                              const_cast<ACE_TCHAR *> (ACE_TEXT("")), // class
 261                              REG_OPTION_NON_VOLATILE,
 262                              KEY_ALL_ACCESS,
 263                              0,
 264                              &key,
 265                              0
 266                              );
 267   if (err != ERROR_SUCCESS)
 268     {
 269       return -1;
 270     }
 271   err = ACE_TEXT_RegSetValueEx (key, ACE_TEXT("ORBInitOptions"), 0, REG_SZ,
 272     (LPBYTE) this->cmdline_.c_str (), (DWORD) this->cmdline_.length () + 1);
 273   ACE_ASSERT (err == ERROR_SUCCESS);
 274
 275   err = ACE_TEXT_RegSetValueEx (key, ACE_TEXT("IORFile"), 0, REG_SZ,
 276     (LPBYTE) this->ior_output_file_.c_str (), (DWORD) this->ior_output_file_.length () + 1);
 277   ACE_ASSERT (err == ERROR_SUCCESS);
 278
 279   err = ACE_TEXT_RegSetValueEx (key, ACE_TEXT("DebugLevel"), 0, REG_DWORD,
 280     (LPBYTE) &this->debug_ , sizeof (this->debug_));
 281   ACE_ASSERT (err == ERROR_SUCCESS);
 282
 283   err = ACE_TEXT_RegSetValueEx( key, ACE_TEXT("Name"), 0, REG_SZ,
 284     (LPBYTE) this->name_.c_str (), (DWORD) this->name_.length () + 1);
 285   ACE_ASSERT (err == ERROR_SUCCESS);
 286
 287   DWORD tmpint = this->notify_imr_;
 288   err = ACE_TEXT_RegSetValueEx (key, ACE_TEXT("NotifyImR"), 0, REG_DWORD,
 289     (LPBYTE) &tmpint , sizeof (tmpint));
 290   ACE_ASSERT (err == ERROR_SUCCESS);
 291
 292   tmpint = this->env_buf_len_;
 293   err = ACE_TEXT_RegSetValueEx(key, ACE_TEXT("EnvBufLen"), 0, REG_DWORD,
 294     (LPBYTE) &tmpint , sizeof(tmpint));
 295   ACE_ASSERT(err == ERROR_SUCCESS);
 296
 297   tmpint = this->max_env_vars_;
 298   err = ACE_TEXT_RegSetValueEx(key, ACE_TEXT("MaxEnvVars"), 0, REG_DWORD,
 299     (LPBYTE) &tmpint , sizeof(tmpint));
 300    ACE_ASSERT(err == ERROR_SUCCESS);
 301
 302   err = ::RegCloseKey (key);
 303   ACE_ASSERT (err == ERROR_SUCCESS);
 304 #endif
 305   return 0;
 306 }
 307
 308 int
 309 Activator_Options::load_registry_options ()
 310 {
 311 #if defined (ACE_WIN32)
 312   HKEY key = 0;
 313   // Create or open the parameters key
 314   LONG err = ACE_TEXT_RegOpenKeyEx (SERVICE_REG_ROOT,
 315                              SERVICE_REG_PATH,
 316                              0,
 317                              KEY_READ,
 318                              &key
 319                              );
 320   if (err != ERROR_SUCCESS)
 321     {
 322       // If there aren't any saved parameters, then that's ok.
 323       return 0;
 324     }
 325   ACE_TCHAR tmpstr[4096];
 326   DWORD sz = sizeof (tmpstr);
 327   DWORD type = 0;
 328   err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("ORBInitOptions"), 0, &type,
 329     (LPBYTE) tmpstr, &sz);
 330   if (err == ERROR_SUCCESS)
 331     {
 332       ACE_ASSERT (type == REG_SZ);
 333       tmpstr[sz - 1] = '\0';
 334       this->cmdline_ = ACE_TEXT_ALWAYS_CHAR(tmpstr);
 335     }
 336
 337   sz = sizeof(tmpstr);
 338   err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("IORFile"), 0, &type,
 339     (LPBYTE) tmpstr, &sz);
 340   if (err == ERROR_SUCCESS)
 341     {
 342       ACE_ASSERT (type == REG_SZ);
 343       tmpstr[sz - 1] = '\0';
 344       this->ior_output_file_ = tmpstr;
 345     }
 346
 347   sz = sizeof(debug_);
 348   err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("DebugLevel"), 0, &type,
 349     (LPBYTE) &this->debug_ , &sz);
 350   if (err == ERROR_SUCCESS)
 351     {
 352       ACE_ASSERT (type == REG_DWORD);
 353     }
 354
 355   sz = sizeof(tmpstr);
 356   err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("Name"), 0, &type,
 357     (LPBYTE) tmpstr, &sz);
 358   if (err == ERROR_SUCCESS)
 359     {
 360       ACE_ASSERT (type == REG_SZ);
 361       tmpstr[sz - 1] = '\0';
 362       this->name_ = ACE_TEXT_ALWAYS_CHAR(tmpstr);
 363     }
 364
 365   DWORD tmpint = 0;
 366   sz = sizeof(tmpint);
 367   err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("NotifyImR"), 0, &type,
 368     (LPBYTE) &tmpint , &sz);
 369   if (err == ERROR_SUCCESS)
 370     {
 371       ACE_ASSERT (type == REG_DWORD);
 372     }
 373   this->notify_imr_ = tmpint != 0;
 374
 375   err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("EnvBufLen"), 0, &type,
 376     (LPBYTE) &tmpint , &sz);
 377   if (err == ERROR_SUCCESS) {
 378     ACE_ASSERT(type == REG_DWORD);
 379   }
 380   this->env_buf_len_ = tmpint;
 381
 382   err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("MaxEnvArgs"), 0, &type,
 383     (LPBYTE) &tmpint , &sz);
 384   if (err == ERROR_SUCCESS) {
 385     ACE_ASSERT(type == REG_DWORD);
 386   }
 387   this->max_env_vars_ = tmpint;
 388
 389   err = ::RegCloseKey (key);
 390   ACE_ASSERT(err == ERROR_SUCCESS);
 391 #endif /* ACE_WIN32 */
 392   return 0;
 393 }
 394
 395 bool
 396 Activator_Options::service () const
 397 {
 398   return this->service_;
 399 }
 400
 401 bool
 402 Activator_Options::notify_imr () const
 403 {
 404   return this->notify_imr_;
 405 }
 406
 407 unsigned int
 408 Activator_Options::induce_delay () const
 409 {
 410   return this->induce_delay_;
 411 }
 412
 413 unsigned int
 414 Activator_Options::debug () const
 415 {
 416   return this->debug_;
 417 }
 418
 419 const ACE_TString&
 420 Activator_Options::ior_filename () const
 421 {
 422   return this->ior_output_file_;
 423 }
 424
 425 Activator_Options::SERVICE_COMMAND
 426 Activator_Options::service_command () const
 427 {
 428   return this->service_command_;
 429 }
 430
 431 const char*
 432 Activator_Options::cmdline () const
 433 {
 434   return this->cmdline_.c_str ();
 435 }
 436
 437 const ACE_CString&
 438 Activator_Options::name () const
 439 {
 440   return this->name_;
 441 }
 442
 443 int
 444 Activator_Options::env_buf_len () const
 445 {
 446   return this->env_buf_len_;
 447 }
 448
 449 int
 450 Activator_Options::max_env_vars () const
 451 {
 452   return this->max_env_vars_;
 453 }
 454
 455 bool
 456 Activator_Options::detach_child () const
 457 {
 458   return this->detach_child_;
 459 }