TAO/orbsvcs/Notify_Service/NT_Notify_Service.cpp

   1 /* -*- C++ -*- */
   2 #include /**/ "NT_Notify_Service.h"
   3
   4 #if defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_SERVICES)
   5
   6 #include /**/ "Notify_Service.h"
   7 #include "tao/ORB_Core.h"
   8 #include "ace/ARGV.h"
   9 #include "ace/Reactor.h"
  10 #include "orbsvcs/Log_Macros.h"
  11
  12 #define REGISTRY_KEY_ROOT HKEY_LOCAL_MACHINE
  13 #define TAO_REGISTRY_SUBKEY ACE_TEXT ("SOFTWARE\\ACE\\TAO")
  14 #define TAO_NOTIFY_SERVICE_OPTS_NAME ACE_TEXT ("TaoNotifyServiceOptions")
  15 #define TAO_SERVICE_PARAM_COUNT ACE_TEXT ("TaoServiceParameterCount")
  16
  17 TAO_NT_Notify_Service::TAO_NT_Notify_Service (void)
  18   : argc_ (0),
  19     argc_save_ (0),
  20     argv_ (0),
  21     argv_save_ (0)
  22 {
  23 }
  24
  25 TAO_NT_Notify_Service::~TAO_NT_Notify_Service (void)
  26 {
  27   if (argv_save_)
  28     {
  29       for (int i = 0; i < argc_save_; i++)
  30         ACE_OS::free (argv_save_[i]);
  31
  32       ACE_OS::free (argv_save_);
  33     }
  34 }
  35
  36 void
  37 TAO_NT_Notify_Service::handle_control (DWORD control_code)
  38 {
  39   if (control_code == SERVICE_CONTROL_SHUTDOWN
  40       || control_code == SERVICE_CONTROL_STOP)
  41     {
  42       report_status (SERVICE_STOP_PENDING);
  43       TAO_ORB_Core_instance ()->reactor ()->end_reactor_event_loop ();
  44       TAO_ORB_Core_instance ()->orb ()->shutdown (1);
  45       report_status (SERVICE_STOPPED);
  46     }
  47   else
  48     ACE_NT_Service::handle_control (control_code);
  49 }
  50
  51 int
  52 TAO_NT_Notify_Service::handle_exception (ACE_HANDLE)
  53 {
  54   return 0;
  55 }
  56
  57 void
  58 TAO_NT_Notify_Service::report_error (const ACE_TCHAR *format,
  59                                      const ACE_TCHAR *val,
  60                                      LONG result)
  61 {
  62   ACE_TCHAR msg[100];
  63   ACE_TEXT_FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
  64                           0,
  65                           result,
  66                           LANG_SYSTEM_DEFAULT,
  67                           msg,
  68                           100,0);
  69   ORBSVCS_DEBUG ((LM_DEBUG, format, val, msg));
  70 }
  71
  72 void
  73 TAO_NT_Notify_Service::arg_manip (char *args, DWORD arglen, bool query)
  74 {
  75   HKEY hkey = 0;
  76
  77   // It looks in the NT Registry under
  78   // \\HKEY_LOCAL_MACHINE\SOFTWARE\ACE\TAO for the value of
  79   // "TaoNotifyServiceOptions" for any Notify Service options such as
  80   // "-ORBListenEndpoints".
  81
  82   // Get/Set Notify Service options from the NT Registry.
  83
  84   LONG result = ACE_TEXT_RegOpenKeyEx (REGISTRY_KEY_ROOT,
  85                                        TAO_REGISTRY_SUBKEY,
  86                                        0,
  87                                        query ? KEY_READ : KEY_WRITE,
  88                                        &hkey);
  89
  90   DWORD type = REG_EXPAND_SZ;
  91
  92   if (query)
  93     {
  94       *args = '\0';
  95       if (result == ERROR_SUCCESS)
  96         {
  97           result = ACE_TEXT_RegQueryValueEx (hkey,
  98                                              TAO_NOTIFY_SERVICE_OPTS_NAME,
  99                                              0,
 100                                              &type,
 101                                              (BYTE *)args,
 102                                              &arglen);
 103           if (result != ERROR_SUCCESS)
 104             {
 105               this->report_error (ACE_TEXT ("Could not query %s, %s\n"),
 106                                   TAO_NOTIFY_SERVICE_OPTS_NAME, result);
 107             }
 108         }
 109       else
 110         {
 111           this->report_error (ACE_TEXT ("No key for %s, %s\n"),
 112                               TAO_REGISTRY_SUBKEY, result);
 113         }
 114     }
 115   else
 116     {
 117       if (result != ERROR_SUCCESS)
 118         {
 119           result = ACE_TEXT_RegCreateKeyEx (REGISTRY_KEY_ROOT,
 120                                             TAO_REGISTRY_SUBKEY,
 121                                             0,
 122                                             0,
 123                                             0,
 124                                             KEY_WRITE,
 125                                             0,
 126                                             &hkey,
 127                                             0);
 128         }
 129       DWORD bufSize = static_cast<DWORD>(ACE_OS::strlen (args) + 1);
 130       if (result == ERROR_SUCCESS)
 131         {
 132           result = ACE_TEXT_RegSetValueEx (hkey,
 133                                            TAO_NOTIFY_SERVICE_OPTS_NAME,
 134                                            0,
 135                                            type,
 136                                            (BYTE *)args,
 137                                            bufSize);
 138           if (result != ERROR_SUCCESS)
 139             {
 140                this->report_error (ACE_TEXT ("Could not set %s, %s\n"),
 141                                    TAO_NOTIFY_SERVICE_OPTS_NAME, result);
 142             }
 143         }
 144       else
 145         {
 146           this->report_error (ACE_TEXT ("Could not create key %s, %s\n"),
 147                               TAO_REGISTRY_SUBKEY, result);
 148         }
 149     }
 150
 151   RegCloseKey (hkey);
 152
 153 }
 154
 155 int
 156 TAO_NT_Notify_Service::set_args (const ACE_TCHAR *args)
 157 {
 158   char argbuf[ACE_DEFAULT_ARGV_BUFSIZ];
 159   if (args == 0)
 160     {
 161       this->arg_manip (argbuf, ACE_DEFAULT_ARGV_BUFSIZ, true);
 162       ACE_OS::printf ("%s\n", argbuf);
 163     }
 164   else
 165     {
 166       ACE_OS::strcpy (argbuf, ACE_TEXT_ALWAYS_CHAR (args));
 167       this->arg_manip (argbuf, 0, false);
 168     }
 169   return 0;
 170 }
 171
 172 int
 173 TAO_NT_Notify_Service::init (int argc,
 174                              ACE_TCHAR *argv[])
 175 {
 176   HKEY hkey = 0;
 177   BYTE buf[ACE_DEFAULT_ARGV_BUFSIZ];
 178
 179   *buf = '\0';
 180
 181   // This solution is very kludgy.  It looks in the NT Registry under
 182   // \\HKEY_LOCAL_MACHINE\SOFTWARE\ACE\TAO for the value of
 183   // "TaoNotifyServiceOptions" for any Notify Service options such as
 184   // "-ORBEndpoint".
 185
 186   // Get Notify Service options from the NT Registry.
 187
 188   ACE_TEXT_RegOpenKeyEx (REGISTRY_KEY_ROOT,
 189                          TAO_REGISTRY_SUBKEY,
 190                          0,
 191                          KEY_READ,
 192                          &hkey);
 193
 194   DWORD type;
 195   DWORD bufSize = sizeof (buf);
 196
 197   ACE_TEXT_RegQueryValueEx (hkey,
 198                             TAO_NOTIFY_SERVICE_OPTS_NAME,
 199                             0,
 200                             &type,
 201                             buf,
 202                             &bufSize);
 203
 204   RegCloseKey (hkey);
 205
 206   // Add options to the args list (if any).
 207
 208   if (ACE_OS::strlen ((char *) buf) > 0)
 209     {
 210       ACE_ARGV args ((const char*) buf);
 211       // Allocate the internal args list to be one bigger than the
 212       // args list passed into the function. We use a 'save' list in
 213       // case we use a 'destructive' args list processor - this way we
 214       // maintain the correct argv and argc for memory freeing
 215       // operations in the destructor.
 216       argv_save_ = (ACE_TCHAR **) ACE_OS::malloc (sizeof (ACE_TCHAR *) * (argc + args.argc ()));
 217
 218       // Copy the values into the internal args buffer.
 219       int i;
 220       for (i = 0; i < argc; i++)
 221         argv_save_[i] = ACE_OS::strdup (argv[i]);
 222
 223       int j = 0;
 224       for (i = argc; i < static_cast<int> ((args.argc () + argc)); i++)
 225         argv_save_[i] = ACE_OS::strdup (args.argv ()[j++]);
 226
 227       // Set the arg counter.
 228       argc_save_ = argc + args.argc ();
 229       argc_ = argc_save_;
 230       argv_ = argv_save_;
 231     }
 232   else
 233     {
 234       argc_ = argc;
 235       argv_ = argv;
 236     }
 237
 238   return 0;
 239 }
 240
 241 int
 242 TAO_NT_Notify_Service::svc (void)
 243 {
 244   TAO_Notify_Service_Driver notify_service;
 245
 246   try
 247     {
 248       if (notify_service.init (argc_, argv_) == -1)
 249         return -1;
 250
 251       report_status (SERVICE_RUNNING);
 252       notify_service.run ();
 253     }
 254   catch (const CORBA::Exception& ex)
 255     {
 256       ex._tao_print_exception (ACE_TEXT ("TAO NT Notify Service"));
 257       return -1;
 258     }
 259
 260   return 0;
 261 }
 262
 263 #endif /* ACE_WIN32 && !ACE_LACKS_WIN32_SERVICES */