static int
get_reg_subkeys (const ACE_TCHAR *key,
ACE_TCHAR *buffer,
DWORD &buf_len)
{
HKEY hk;
LONG rc = ACE_TEXT_RegOpenKeyEx (HKEY_LOCAL_MACHINE,
key,
0,
KEY_READ,
&hk);
if (rc != ERROR_SUCCESS)
return -1;
ACE_TCHAR subkeyname[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 1];
DWORD subkeyname_len = ACE_MAX_FULLY_QUALIFIED_NAME_LEN;
FILETIME update_dummy;
DWORD total = 0;
for (int i = 0;
(rc = ACE_TEXT_RegEnumKeyEx (hk, i,
subkeyname,
&subkeyname_len,
0, 0, 0,
&update_dummy)) != ERROR_NO_MORE_ITEMS;
++i)
{
if (subkeyname_len < buf_len - total)
{
ACE_OS::strcpy(buffer + total, subkeyname);
total += subkeyname_len + 1;
// Reset: was changed by RegEnumKeyEx call.
subkeyname_len = ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 1;
}
else
return -1;
}
buf_len = total;
::RegCloseKey (hk);
return 0;
}
// Find <naming_context> with <name> in <this> context
// (String version)
int
ACE_Registry::Naming_Context::resolve_context (const ACE_TString &name,
Naming_Context &naming_context,
u_long security_access)
{
long result = ACE_TEXT_RegOpenKeyEx (this->key_,
name.c_str (),
0,
security_access,
&naming_context.key_);
if (result == ERROR_SUCCESS)
{
// set the correct parent
naming_context.parent (this->key_);
// set the correct name
naming_context.name (name);
}
ACE_REGISTRY_CALL_RETURN (result);
}
static int
get_reg_value (const ACE_TCHAR *key,
const ACE_TCHAR *name,
ACE_TCHAR *buffer,
DWORD &buf_len,
int all_subkeys = 0)
{
HKEY hk;
DWORD buf_type;
LONG rc = ACE_TEXT_RegOpenKeyEx (HKEY_LOCAL_MACHINE,
key,
0,
KEY_READ,
&hk);
if (rc != ERROR_SUCCESS)
// print_error_string(ACE_LIB_TEXT ("RegOpenKeyEx"), rc);
return -1;
if (all_subkeys)
{
ACE_TCHAR ifname[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 1];
DWORD ifname_len = ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 1;
FILETIME update_dummy;
DWORD total = 0;
DWORD size = buf_len;
for (int i = 0;
(rc = ACE_TEXT_RegEnumKeyEx (hk, i, ifname, &ifname_len,
0, 0, 0,
&update_dummy)) != ERROR_NO_MORE_ITEMS;
++i)
{
HKEY ifkey;
if (rc != ERROR_SUCCESS
|| ACE_TEXT_RegOpenKeyEx (hk, ifname, 0,
KEY_READ, &ifkey) != ERROR_SUCCESS)
continue;
if (ACE_TEXT_RegQueryValueEx (ifkey, name, 0, 0,
(u_char*) (buffer + total),
&size) != ERROR_SUCCESS)
{
RegCloseKey(ifkey);
continue;
}
else
{
total += size;
size = buf_len - total;
}
// Needs to be reset.
ifname_len = ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 1;
}
if (total == 0)
{
::RegCloseKey (hk);
return -2;
}
else
{
buf_len = total;
}
}
else
{
rc = ACE_TEXT_RegQueryValueEx (hk,
name,
0,
&buf_type,
(u_char *) buffer,
&buf_len);
if (rc != ERROR_SUCCESS)
{
// print_error_string(ACE_LIB_TEXT ("RegEnumKeyEx"), rc);
RegCloseKey (hk);
return -2;
}
}
::RegCloseKey (hk);
return 0;
}
void
TAO_NT_Notify_Service::arg_manip (char *args, DWORD arglen, bool query)
{
HKEY hkey = 0;
// It looks in the NT Registry under
// \\HKEY_LOCAL_MACHINE\SOFTWARE\ACE\TAO for the value of
// "TaoNotifyServiceOptions" for any Notify Service options such as
// "-ORBListenEndpoints".
// Get/Set Notify Service options from the NT Registry.
LONG result = ACE_TEXT_RegOpenKeyEx (REGISTRY_KEY_ROOT,
TAO_REGISTRY_SUBKEY,
0,
query ? KEY_READ : KEY_WRITE,
&hkey);
DWORD type = REG_EXPAND_SZ;
if (query)
{
*args = '\0';
if (result == ERROR_SUCCESS)
{
result = ACE_TEXT_RegQueryValueEx (hkey,
TAO_NOTIFY_SERVICE_OPTS_NAME,
0,
&type,
(BYTE *)args,
&arglen);
if (result != ERROR_SUCCESS)
{
this->report_error (ACE_TEXT ("Could not query %s, %s\n"),
TAO_NOTIFY_SERVICE_OPTS_NAME, result);
}
}
else
{
this->report_error (ACE_TEXT ("No key for %s, %s\n"),
TAO_REGISTRY_SUBKEY, result);
}
}
else
{
if (result != ERROR_SUCCESS)
{
result = ACE_TEXT_RegCreateKeyEx (REGISTRY_KEY_ROOT,
TAO_REGISTRY_SUBKEY,
0,
0,
0,
KEY_WRITE,
0,
&hkey,
0);
}
DWORD bufSize = static_cast<DWORD>(ACE_OS::strlen (args) + 1);
if (result == ERROR_SUCCESS)
{
result = ACE_TEXT_RegSetValueEx (hkey,
TAO_NOTIFY_SERVICE_OPTS_NAME,
0,
type,
(BYTE *)args,
bufSize);
if (result != ERROR_SUCCESS)
{
this->report_error (ACE_TEXT ("Could not set %s, %s\n"),
TAO_NOTIFY_SERVICE_OPTS_NAME, result);
}
}
else
{
this->report_error (ACE_TEXT ("Could not create key %s, %s\n"),
TAO_REGISTRY_SUBKEY, result);
}
}
RegCloseKey (hkey);
}
int
TAO_NT_Notify_Service::init (int argc,
ACE_TCHAR *argv[])
{
HKEY hkey = 0;
BYTE buf[ACE_DEFAULT_ARGV_BUFSIZ];
*buf = '\0';
// This solution is very kludgy. It looks in the NT Registry under
// \\HKEY_LOCAL_MACHINE\SOFTWARE\ACE\TAO for the value of
// "TaoNotifyServiceOptions" for any Notify Service options such as
// "-ORBEndpoint".
// Get Notify Service options from the NT Registry.
ACE_TEXT_RegOpenKeyEx (REGISTRY_KEY_ROOT,
TAO_REGISTRY_SUBKEY,
0,
KEY_READ,
&hkey);
DWORD type;
DWORD bufSize = sizeof (buf);
ACE_TEXT_RegQueryValueEx (hkey,
TAO_NOTIFY_SERVICE_OPTS_NAME,
0,
&type,
buf,
&bufSize);
RegCloseKey (hkey);
// Add options to the args list (if any).
if (ACE_OS::strlen ((char *) buf) > 0)
{
ACE_ARGV args ((const char*) buf);
// Allocate the internal args list to be one bigger than the
// args list passed into the function. We use a 'save' list in
// case we use a 'destructive' args list processor - this way we
// maintain the correct argv and argc for memory freeing
// operations in the destructor.
argv_save_ = (ACE_TCHAR **) ACE_OS::malloc (sizeof (ACE_TCHAR *) * (argc + args.argc ()));
// Copy the values into the internal args buffer.
int i;
for (i = 0; i < argc; i++)
argv_save_[i] = ACE_OS::strdup (argv[i]);
int j = 0;
for (i = argc; i < static_cast<int> ((args.argc () + argc)); i++)
argv_save_[i] = ACE_OS::strdup (args.argv ()[j++]);
// Set the arg counter.
argc_save_ = argc + args.argc ();
argc_ = argc_save_;
argv_ = argv_save_;
}
else
{
argc_ = argc;
argv_ = argv;
}
return 0;
}
int
Activator_Options::load_registry_options ()
{
#if defined (ACE_WIN32)
HKEY key = 0;
// Create or open the parameters key
LONG err = ACE_TEXT_RegOpenKeyEx (SERVICE_REG_ROOT,
SERVICE_REG_PATH,
0,
KEY_READ,
&key
);
if (err != ERROR_SUCCESS)
{
// If there aren't any saved parameters, then that's ok.
return 0;
}
char tmpstr[4096];
DWORD sz = sizeof (tmpstr);
DWORD type = 0;
err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("ORBInitOptions"), 0, &type,
(LPBYTE) tmpstr, &sz);
if (err == ERROR_SUCCESS)
{
ACE_ASSERT (type == REG_SZ);
tmpstr[sz - 1] = '\0';
this->cmdline_ = tmpstr;
}
sz = sizeof(tmpstr);
err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("IORFile"), 0, &type,
(LPBYTE) tmpstr, &sz);
if (err == ERROR_SUCCESS)
{
ACE_ASSERT (type == REG_SZ);
tmpstr[sz - 1] = '\0';
this->ior_output_file_ = ACE_TEXT_CHAR_TO_TCHAR(tmpstr);
}
sz = sizeof(debug_);
err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("DebugLevel"), 0, &type,
(LPBYTE) &this->debug_ , &sz);
if (err == ERROR_SUCCESS)
{
ACE_ASSERT (type == REG_DWORD);
}
sz = sizeof(tmpstr);
err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("Name"), 0, &type,
(LPBYTE) tmpstr, &sz);
if (err == ERROR_SUCCESS)
{
ACE_ASSERT (type == REG_SZ);
tmpstr[sz - 1] = '\0';
this->name_ = tmpstr;
}
DWORD tmpint = 0;
sz = sizeof(tmpint);
err = ACE_TEXT_RegQueryValueEx (key, ACE_TEXT("NotifyImR"), 0, &type,
(LPBYTE) &tmpint , &sz);
if (err == ERROR_SUCCESS)
{
ACE_ASSERT (type == REG_DWORD);
}
this->notify_imr_ = tmpint != 0;
err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("EnvBufLen"), 0, &type,
(LPBYTE) &tmpint , &sz);
if (err == ERROR_SUCCESS) {
ACE_ASSERT(type == REG_DWORD);
}
this->env_buf_len_ = tmpint;
err = ACE_TEXT_RegQueryValueEx(key, ACE_TEXT("MaxEnvArgs"), 0, &type,
(LPBYTE) &tmpint , &sz);
if (err == ERROR_SUCCESS) {
ACE_ASSERT(type == REG_DWORD);
}
this->max_env_vars_ = tmpint;
err = ::RegCloseKey (key);
ACE_ASSERT(err == ERROR_SUCCESS);
#endif /* ACE_WIN32 */
return 0;
}