internal bool addOrUpdateMap(Ice.Properties properties, string mapName, IMetricsMapFactory factory,
Ice.Logger logger)
{
//
// Add maps to views configured with the given map.
//
string viewPrefix = "IceMX.Metrics." + _name + ".";
string mapsPrefix = viewPrefix + "Map.";
Dictionary <string, string> mapsProps = properties.getPropertiesForPrefix(mapsPrefix);
string mapPrefix;
Dictionary <string, string> mapProps = new Dictionary <string, string>();
if (mapsProps.Count > 0)
{
mapPrefix = mapsPrefix + mapName + ".";
mapProps = properties.getPropertiesForPrefix(mapPrefix);
if (mapProps.Count == 0)
{
// This map isn't configured for this view.
return(_maps.Remove(mapName));
}
}
else
{
mapPrefix = viewPrefix;
mapProps = properties.getPropertiesForPrefix(mapPrefix);
}
if (properties.getPropertyAsInt(mapPrefix + "Disabled") > 0)
{
// This map is disabled for this view.
return(_maps.Remove(mapName));
}
IMetricsMap m;
if (_maps.TryGetValue(mapName, out m) && Ice.Collections.Equals(m.getProperties(), mapProps))
{
return(false); // The map configuration didn't change, no need to re-create.
}
try
{
_maps[mapName] = factory.create(mapPrefix, properties);
}
catch (Exception ex)
{
logger.warning("unexpected exception while creating metrics map:\n" + ex);
_maps.Remove(mapName);
}
return(true);
}
private static void copyProperties(string prefix, Ice.Properties from, Ice.Properties to)
{
foreach (var p in from.getPropertiesForPrefix(prefix))
{
to.setProperty(p.Key, p.Value);
}
}
private Dictionary <string, Regex> parseRule(Ice.Properties properties, string name)
{
Dictionary <string, Regex> pats = new Dictionary <string, Regex>();
Dictionary <string, string> rules = properties.getPropertiesForPrefix(name + '.');
foreach (KeyValuePair <string, string> e in rules)
{
pats.Add(e.Key.Substring(name.Length + 1), new Regex(e.Value));
}
return(pats);
}
public override int run(string[] args)
{
List <string> argSeq = new List <string>(args);
const string prefix = "IceBox.Service.";
Ice.Properties properties = communicator().getProperties();
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
foreach (KeyValuePair <string, string> pair in services)
{
string name = pair.Key.Substring(prefix.Length);
for (int i = 0; i < argSeq.Count; ++i)
{
if (argSeq[i].StartsWith("--" + name, StringComparison.CurrentCulture))
{
argSeq.RemoveAt(i);
i--;
}
}
}
foreach (string s in argSeq)
{
if (s.Equals("-h") || s.Equals("--help"))
{
usage();
return(0);
}
else if (s.Equals("-v") || s.Equals("--version"))
{
Console.Out.WriteLine(Ice.Util.stringVersion());
return(0);
}
else
{
Console.Error.WriteLine("Server: unknown option `" + s + "'");
usage();
return(1);
}
}
ServiceManagerI serviceManagerImpl = new ServiceManagerI(communicator(), args);
return(serviceManagerImpl.run());
}
internal TrustManager(Ice.Communicator communicator)
{
Debug.Assert(communicator != null);
communicator_ = communicator;
Ice.Properties properties = communicator.getProperties();
traceLevel_ = properties.getPropertyAsInt("IceSSL.Trace.Security");
string key = null;
try
{
key = "IceSSL.TrustOnly";
parse(properties.getProperty(key), rejectAll_, acceptAll_);
key = "IceSSL.TrustOnly.Client";
parse(properties.getProperty(key), rejectClient_, acceptClient_);
key = "IceSSL.TrustOnly.Server";
parse(properties.getProperty(key), rejectAllServer_, acceptAllServer_);
Dictionary <string, string> dict = properties.getPropertiesForPrefix("IceSSL.TrustOnly.Server.");
foreach (KeyValuePair <string, string> entry in dict)
{
key = entry.Key;
string name = key.Substring("IceSSL.TrustOnly.Server.".Length);
List <List <RFC2253.RDNPair> > reject = new List <List <RFC2253.RDNPair> >();
List <List <RFC2253.RDNPair> > accept = new List <List <RFC2253.RDNPair> >();
parse(entry.Value, reject, accept);
if (reject.Count > 0)
{
rejectServer_[name] = reject;
}
if (accept.Count > 0)
{
acceptServer_[name] = accept;
}
}
}
catch (RFC2253.ParseException e)
{
Ice.PluginInitializationException ex = new Ice.PluginInitializationException();
ex.reason = "IceSSL: invalid property " + key + ":\n" + e.reason;
throw ex;
}
}
private static int run(Ice.Communicator communicator, string[] args)
{
const string prefix = "IceBox.Service.";
Ice.Properties properties = communicator.getProperties();
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
var argSeq = new List <string>(args);
foreach (KeyValuePair <string, string> pair in services)
{
string name = pair.Key.Substring(prefix.Length);
argSeq.RemoveAll(v => v.StartsWith("--" + name));
}
foreach (string arg in args)
{
if (arg.Equals("-h") || arg.Equals("--help"))
{
usage();
return(0);
}
else if (arg.Equals("-v") || arg.Equals("--version"))
{
Console.Out.WriteLine(Ice.Util.stringVersion());
return(0);
}
else
{
Console.Error.WriteLine("IceBox.Server: unknown option `" + arg + "'");
usage();
return(1);
}
}
ServiceManagerI serviceManagerImpl = new ServiceManagerI(communicator, args);
return(serviceManagerImpl.run());
}
public static void validateProperties(string prefix, Ice.Properties properties)
{
Dictionary <string, string> props = properties.getPropertiesForPrefix(prefix);
List <string> unknownProps = new List <string>();
foreach (string prop in props.Keys)
{
bool valid = false;
foreach (string suffix in suffixes)
{
if (IceUtilInternal.StringUtil.match(prop, prefix + suffix, false))
{
valid = true;
break;
}
}
if (!valid)
{
unknownProps.Add(prop);
}
}
if (unknownProps.Count != 0 && properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
StringBuilder message = new StringBuilder("found unknown IceMX properties for `");
message.Append(prefix.Substring(0, prefix.Length - 1));
message.Append("':");
foreach (string p in unknownProps)
{
message.Append("\n ");
message.Append(p);
}
Ice.Util.getProcessLogger().warning(message.ToString());
}
}
internal void initialize()
{
if (_initialized)
{
return;
}
const string prefix = "IceSSL.";
Ice.Properties properties = communicator().getProperties();
//
// Check for a default directory. We look in this directory for
// files mentioned in the configuration.
//
_defaultDir = properties.getProperty(prefix + "DefaultDir");
string certStoreLocation = properties.getPropertyWithDefault(prefix + "CertStoreLocation", "CurrentUser");
StoreLocation storeLocation;
if (certStoreLocation == "CurrentUser")
{
storeLocation = StoreLocation.CurrentUser;
}
else if (certStoreLocation == "LocalMachine")
{
storeLocation = StoreLocation.LocalMachine;
}
else
{
_logger.warning("Invalid IceSSL.CertStoreLocation value `" + certStoreLocation +
"' adjusted to `CurrentUser'");
storeLocation = StoreLocation.CurrentUser;
}
_useMachineContext = certStoreLocation == "LocalMachine";
//
// Protocols selects which protocols to enable, by default we only enable TLS1.0
// TLS1.1 and TLS1.2 to avoid security issues with SSLv3
//
_protocols = parseProtocols(
properties.getPropertyAsListWithDefault(prefix + "Protocols", new string[] { "TLS1_0", "TLS1_1", "TLS1_2" }));
//
// CheckCertName determines whether we compare the name in a peer's
// certificate against its hostname.
//
_checkCertName = properties.getPropertyAsIntWithDefault(prefix + "CheckCertName", 0) > 0;
//
// VerifyDepthMax establishes the maximum length of a peer's certificate
// chain, including the peer's certificate. A value of 0 means there is
// no maximum.
//
_verifyDepthMax = properties.getPropertyAsIntWithDefault(prefix + "VerifyDepthMax", 3);
//
// CheckCRL determines whether the certificate revocation list is checked, and how strictly.
//
_checkCRL = properties.getPropertyAsIntWithDefault(prefix + "CheckCRL", 0);
//
// Check for a certificate verifier.
//
string certVerifierClass = properties.getProperty(prefix + "CertVerifier");
if (certVerifierClass.Length > 0)
{
if (_verifier != null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: certificate verifier already installed";
throw e;
}
Type cls = _facade.findType(certVerifierClass);
if (cls == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load certificate verifier class " + certVerifierClass;
throw e;
}
try
{
_verifier = (CertificateVerifier)IceInternal.AssemblyUtil.createInstance(cls);
}
catch (Exception ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: unable to instantiate certificate verifier class " + certVerifierClass;
throw e;
}
if (_verifier == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to instantiate certificate verifier class " + certVerifierClass;
throw e;
}
}
//
// Check for a password callback.
//
string passwordCallbackClass = properties.getProperty(prefix + "PasswordCallback");
if (passwordCallbackClass.Length > 0)
{
if (_passwordCallback != null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: password callback already installed";
throw e;
}
Type cls = _facade.findType(passwordCallbackClass);
if (cls == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
try
{
_passwordCallback = (PasswordCallback)IceInternal.AssemblyUtil.createInstance(cls);
}
catch (Exception ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
if (_passwordCallback == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
}
//
// If the user hasn't supplied a certificate collection, we need to examine
// the property settings.
//
if (_certs == null)
{
//
// If IceSSL.CertFile is defined, load a certificate from a file and
// add it to the collection.
//
// TODO: tracing?
_certs = new X509Certificate2Collection();
string certFile = properties.getProperty(prefix + "CertFile");
string passwordStr = properties.getProperty(prefix + "Password");
string findCert = properties.getProperty(prefix + "FindCert");
const string findPrefix = prefix + "FindCert.";
Dictionary <string, string> findCertProps = properties.getPropertiesForPrefix(findPrefix);
if (certFile.Length > 0)
{
if (!checkPath(ref certFile))
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: certificate file not found: " + certFile;
throw e;
}
SecureString password = null;
if (passwordStr.Length > 0)
{
password = createSecureString(passwordStr);
}
else if (_passwordCallback != null)
{
password = _passwordCallback.getPassword(certFile);
}
try
{
X509Certificate2 cert;
X509KeyStorageFlags importFlags;
if (_useMachineContext)
{
importFlags = X509KeyStorageFlags.MachineKeySet;
}
else
{
importFlags = X509KeyStorageFlags.UserKeySet;
}
if (password != null)
{
cert = new X509Certificate2(certFile, password, importFlags);
}
else
{
cert = new X509Certificate2(certFile, "", importFlags);
}
_certs.Add(cert);
}
catch (CryptographicException ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: error while attempting to load certificate from " + certFile;
throw e;
}
}
else if (findCert.Length > 0)
{
string certStore = properties.getPropertyWithDefault("IceSSL.CertStore", "My");
_certs.AddRange(findCertificates("IceSSL.FindCert", storeLocation, certStore, findCert));
if (_certs.Count == 0)
{
throw new Ice.PluginInitializationException("IceSSL: no certificates found");
}
}
else if (findCertProps.Count > 0)
{
//
// If IceSSL.FindCert.* properties are defined, add the selected certificates
// to the collection.
//
foreach (KeyValuePair <string, string> entry in findCertProps)
{
string name = entry.Key;
string val = entry.Value;
if (val.Length > 0)
{
string storeSpec = name.Substring(findPrefix.Length);
StoreLocation storeLoc = 0;
StoreName storeName = 0;
string sname = null;
parseStore(name, storeSpec, ref storeLoc, ref storeName, ref sname);
if (sname == null)
{
sname = storeName.ToString();
}
X509Certificate2Collection coll = findCertificates(name, storeLoc, sname, val);
_certs.AddRange(coll);
}
}
if (_certs.Count == 0)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: no certificates found";
throw e;
}
}
}
if (_caCerts == null)
{
string certAuthFile = properties.getProperty(prefix + "CAs");
if (certAuthFile.Length == 0)
{
certAuthFile = properties.getProperty(prefix + "CertAuthFile");
}
if (certAuthFile.Length > 0 || properties.getPropertyAsInt(prefix + "UsePlatformCAs") <= 0)
{
_caCerts = new X509Certificate2Collection();
}
if (certAuthFile.Length > 0)
{
if (!checkPath(ref certAuthFile))
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: CA certificate file not found: " + certAuthFile;
throw e;
}
try
{
using (System.IO.FileStream fs = System.IO.File.OpenRead(certAuthFile))
{
byte[] data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
string strbuf = "";
try
{
strbuf = System.Text.Encoding.UTF8.GetString(data);
}
catch (Exception)
{
// Ignore
}
if (strbuf.Length == data.Length)
{
int size, startpos, endpos = 0;
bool first = true;
while (true)
{
startpos = strbuf.IndexOf("-----BEGIN CERTIFICATE-----", endpos);
if (startpos != -1)
{
endpos = strbuf.IndexOf("-----END CERTIFICATE-----", startpos);
size = endpos - startpos + "-----END CERTIFICATE-----".Length;
}
else if (first)
{
startpos = 0;
endpos = strbuf.Length;
size = strbuf.Length;
}
else
{
break;
}
byte[] cert = new byte[size];
System.Buffer.BlockCopy(data, startpos, cert, 0, size);
_caCerts.Import(cert);
first = false;
}
}
else
{
_caCerts.Import(data);
}
}
}
catch (Exception ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: error while attempting to load CA certificate from " + certAuthFile;
throw e;
}
}
}
_initialized = true;
}
internal MetricsMap(string mapPrefix, Ice.Properties props, Dictionary <string, ISubMapFactory> subMaps)
{
MetricsAdminI.validateProperties(mapPrefix, props);
_properties = props.getPropertiesForPrefix(mapPrefix);
_retain = props.getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10);
_accept = parseRule(props, mapPrefix + "Accept");
_reject = parseRule(props, mapPrefix + "Reject");
_groupByAttributes = new List <string>();
_groupBySeparators = new List <string>();
string groupBy = props.getPropertyWithDefault(mapPrefix + "GroupBy", "id");
if (groupBy.Length > 0)
{
string v = "";
bool attribute = char.IsLetter(groupBy[0]) || char.IsDigit(groupBy[0]);
if (!attribute)
{
_groupByAttributes.Add("");
}
foreach (char p in groupBy)
{
bool isAlphaNum = char.IsLetter(p) || char.IsDigit(p) || p == '.';
if (attribute && !isAlphaNum)
{
_groupByAttributes.Add(v);
v = "" + p;
attribute = false;
}
else if (!attribute && isAlphaNum)
{
_groupBySeparators.Add(v);
v = "" + p;
attribute = true;
}
else
{
v += p;
}
}
if (attribute)
{
_groupByAttributes.Add(v);
}
else
{
_groupBySeparators.Add(v);
}
}
if (subMaps != null && subMaps.Count > 0)
{
_subMaps = new Dictionary <string, ISubMapCloneFactory>();
List <string> subMapNames = new List <string>();
foreach (KeyValuePair <string, ISubMapFactory> e in subMaps)
{
subMapNames.Add(e.Key);
string subMapsPrefix = mapPrefix + "Map.";
string subMapPrefix = subMapsPrefix + e.Key + '.';
if (props.getPropertiesForPrefix(subMapPrefix).Count == 0)
{
if (props.getPropertiesForPrefix(subMapsPrefix).Count == 0)
{
subMapPrefix = mapPrefix;
}
else
{
continue; // This sub-map isn't configured.
}
}
_subMaps.Add(e.Key, e.Value.createCloneFactory(subMapPrefix, props));
}
}
else
{
_subMaps = null;
}
}
public int run()
{
try
{
Ice.Properties properties = _communicator.getProperties();
//
// Create an object adapter. Services probably should NOT share
// this object adapter, as the endpoint(s) for this object adapter
// will most likely need to be firewalled for security reasons.
//
Ice.ObjectAdapter adapter = null;
if (properties.getProperty("IceBox.ServiceManager.Endpoints").Length != 0)
{
adapter = _communicator.createObjectAdapter("IceBox.ServiceManager");
Ice.Identity identity = new Ice.Identity();
identity.category = properties.getPropertyWithDefault("IceBox.InstanceName", "IceBox");
identity.name = "ServiceManager";
adapter.add(this, identity);
}
//
// Parse the property set with the prefix "IceBox.Service.". These
// properties should have the following format:
//
// IceBox.Service.Foo=<assembly>:Package.Foo [args]
//
// We parse the service properties specified in IceBox.LoadOrder
// first, then the ones from remaining services.
//
string prefix = "IceBox.Service.";
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
string[] loadOrder = properties.getPropertyAsList("IceBox.LoadOrder");
List <StartServiceInfo> servicesInfo = new List <StartServiceInfo>();
for (int i = 0; i < loadOrder.Length; ++i)
{
if (loadOrder[i].Length > 0)
{
string key = prefix + loadOrder[i];
string value = services[key];
if (value == null)
{
FailureException ex = new FailureException();
ex.reason = "ServiceManager: no service definition for `" + loadOrder[i] + "'";
throw ex;
}
servicesInfo.Add(new StartServiceInfo(loadOrder[i], value, _argv));
services.Remove(key);
}
}
foreach (KeyValuePair <string, string> entry in services)
{
string name = entry.Key.Substring(prefix.Length);
string value = entry.Value;
servicesInfo.Add(new StartServiceInfo(name, value, _argv));
}
//
// Check if some services are using the shared communicator in which
// case we create the shared communicator now with a property set that
// is the union of all the service properties (from services that use
// the shared communicator).
//
if (properties.getPropertiesForPrefix("IceBox.UseSharedCommunicator.").Count > 0)
{
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = createServiceProperties("SharedCommunicator");
foreach (StartServiceInfo service in servicesInfo)
{
if (properties.getPropertyAsInt("IceBox.UseSharedCommunicator." + service.name) <= 0)
{
continue;
}
//
// Load the service properties using the shared communicator properties as
// the default properties.
//
Ice.Properties svcProperties = Ice.Util.createProperties(ref service.args, initData.properties);
//
// Remove properties from the shared property set that a service explicitly clears.
//
Dictionary <string, string> allProps = initData.properties.getPropertiesForPrefix("");
foreach (string key in allProps.Keys)
{
if (svcProperties.getProperty(key).Length == 0)
{
initData.properties.setProperty(key, "");
}
}
//
// Add the service properties to the shared communicator properties.
//
foreach (KeyValuePair <string, string> entry in svcProperties.getPropertiesForPrefix(""))
{
initData.properties.setProperty(entry.Key, entry.Value);
}
//
// Parse <service>.* command line options (the Ice command line options
// were parsed by the call to createProperties above).
//
service.args = initData.properties.parseCommandLineOptions(service.name, service.args);
}
string facetNamePrefix = "IceBox.SharedCommunicator.";
bool addFacets = configureAdmin(initData.properties, facetNamePrefix);
_sharedCommunicator = Ice.Util.initialize(initData);
if (addFacets)
{
// Add all facets created on shared communicator to the IceBox communicator
// but renamed <prefix>.<facet-name>, except for the Process facet which is
// never added.
foreach (KeyValuePair <string, Ice.Object> p in _sharedCommunicator.findAllAdminFacets())
{
if (!p.Key.Equals("Process"))
{
_communicator.addAdminFacet(p.Value, facetNamePrefix + p.Key);
}
}
}
}
foreach (StartServiceInfo s in servicesInfo)
{
startService(s.name, s.entryPoint, s.args);
}
//
// We may want to notify external scripts that the services
// have started. This is done by defining the property:
//
// PrintServicesReady=bundleName
//
// Where bundleName is whatever you choose to call this set of
// services. It will be echoed back as "bundleName ready".
//
// This must be done after start() has been invoked on the
// services.
//
string bundleName = properties.getProperty("IceBox.PrintServicesReady");
if (bundleName.Length > 0)
{
Console.Out.WriteLine(bundleName + " ready");
}
//
// Don't move after the adapter activation. This allows
// applications to wait for the service manager to be
// reachable before sending a signal to shutdown the
//
//
Ice.Application.shutdownOnInterrupt();
//
// Register "this" as a facet to the Admin object and create Admin object
//
try
{
_communicator.addAdminFacet(this, "IceBox.ServiceManager");
_communicator.getAdmin();
}
catch (Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
//
// Start request dispatching after we've started the services.
//
if (adapter != null)
{
try
{
adapter.activate();
}
catch (Ice.ObjectAdapterDeactivatedException)
{
//
// Expected if the communicator has been shutdown.
//
}
}
_communicator.waitForShutdown();
}
catch (FailureException ex)
{
_logger.error(ex.ToString());
return(1);
}
catch (Exception ex)
{
_logger.error("ServiceManager: caught exception:\n" + ex.ToString());
return(1);
}
finally
{
//
// Invoke stop() on the services.
//
stopAll();
}
return(0);
}
private Reference create(Ice.Identity ident,
string facet,
Reference.Mode mode,
bool secure,
Ice.ProtocolVersion protocol,
Ice.EncodingVersion encoding,
EndpointI[] endpoints,
string adapterId,
string propertyPrefix)
{
DefaultsAndOverrides defaultsAndOverrides = instance_.defaultsAndOverrides();
//
// Default local proxy options.
//
LocatorInfo locatorInfo = null;
if (_defaultLocator != null)
{
if (!((Ice.ObjectPrxHelperBase)_defaultLocator).reference__().getEncoding().Equals(encoding))
{
locatorInfo = instance_.locatorManager().get(
(Ice.LocatorPrx)_defaultLocator.ice_encodingVersion(encoding));
}
else
{
locatorInfo = instance_.locatorManager().get(_defaultLocator);
}
}
RouterInfo routerInfo = instance_.routerManager().get(_defaultRouter);
bool collocOptimized = defaultsAndOverrides.defaultCollocationOptimization;
bool cacheConnection = true;
bool preferSecure = defaultsAndOverrides.defaultPreferSecure;
Ice.EndpointSelectionType endpointSelection = defaultsAndOverrides.defaultEndpointSelection;
int locatorCacheTimeout = defaultsAndOverrides.defaultLocatorCacheTimeout;
int invocationTimeout = defaultsAndOverrides.defaultInvocationTimeout;
Dictionary <string, string> context = null;
//
// Override the defaults with the proxy properties if a property prefix is defined.
//
if (propertyPrefix != null && propertyPrefix.Length > 0)
{
Ice.Properties properties = instance_.initializationData().properties;
//
// Warn about unknown properties.
//
if (properties.getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0)
{
checkForUnknownProperties(propertyPrefix);
}
string property;
property = propertyPrefix + ".Locator";
Ice.LocatorPrx locator = Ice.LocatorPrxHelper.uncheckedCast(_communicator.propertyToProxy(property));
if (locator != null)
{
if (!((Ice.ObjectPrxHelperBase)locator).reference__().getEncoding().Equals(encoding))
{
locatorInfo = instance_.locatorManager().get(
(Ice.LocatorPrx)locator.ice_encodingVersion(encoding));
}
else
{
locatorInfo = instance_.locatorManager().get(locator);
}
}
property = propertyPrefix + ".Router";
Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(_communicator.propertyToProxy(property));
if (router != null)
{
if (propertyPrefix.EndsWith(".Router", StringComparison.Ordinal))
{
string s = "`" + property + "=" + properties.getProperty(property) +
"': cannot set a router on a router; setting ignored";
instance_.initializationData().logger.warning(s);
}
else
{
routerInfo = instance_.routerManager().get(router);
}
}
property = propertyPrefix + ".CollocationOptimized";
collocOptimized = properties.getPropertyAsIntWithDefault(property, collocOptimized ? 1 : 0) > 0;
property = propertyPrefix + ".ConnectionCached";
cacheConnection = properties.getPropertyAsIntWithDefault(property, cacheConnection ? 1 : 0) > 0;
property = propertyPrefix + ".PreferSecure";
preferSecure = properties.getPropertyAsIntWithDefault(property, preferSecure ? 1 : 0) > 0;
property = propertyPrefix + ".EndpointSelection";
if (properties.getProperty(property).Length > 0)
{
string type = properties.getProperty(property);
if (type.Equals("Random"))
{
endpointSelection = Ice.EndpointSelectionType.Random;
}
else if (type.Equals("Ordered"))
{
endpointSelection = Ice.EndpointSelectionType.Ordered;
}
else
{
throw new Ice.EndpointSelectionTypeParseException("illegal value `" + type +
"'; expected `Random' or `Ordered'");
}
}
property = propertyPrefix + ".LocatorCacheTimeout";
string val = properties.getProperty(property);
if (val.Length > 0)
{
locatorCacheTimeout = properties.getPropertyAsIntWithDefault(property, locatorCacheTimeout);
if (locatorCacheTimeout < -1)
{
locatorCacheTimeout = -1;
StringBuilder msg = new StringBuilder("invalid value for ");
msg.Append(property);
msg.Append(" `");
msg.Append(properties.getProperty(property));
msg.Append("': defaulting to -1");
instance_.initializationData().logger.warning(msg.ToString());
}
}
property = propertyPrefix + ".InvocationTimeout";
val = properties.getProperty(property);
if (val.Length > 0)
{
invocationTimeout = properties.getPropertyAsIntWithDefault(property, invocationTimeout);
if (invocationTimeout < 1 && invocationTimeout != -1)
{
invocationTimeout = -1;
StringBuilder msg = new StringBuilder("invalid value for ");
msg.Append(property);
msg.Append(" `");
msg.Append(properties.getProperty(property));
msg.Append("': defaulting to -1");
instance_.initializationData().logger.warning(msg.ToString());
}
}
property = propertyPrefix + ".Context.";
Dictionary <string, string> contexts = properties.getPropertiesForPrefix(property);
if (contexts.Count != 0)
{
context = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> e in contexts)
{
context.Add(e.Key.Substring(property.Length), e.Value);
}
}
}
//
// Create new reference
//
return(new RoutableReference(instance_,
_communicator,
ident,
facet,
mode,
secure,
protocol,
encoding,
endpoints,
adapterId,
locatorInfo,
routerInfo,
collocOptimized,
cacheConnection,
preferSecure,
endpointSelection,
locatorCacheTimeout,
invocationTimeout,
context));
}
public static int Main(string[] args)
{
int status = 0;
List <string> argSeq = new List <string>();
const string prefix = "IceBox.Service.";
Ice.InitializationData initData = new Ice.InitializationData();
initData.properties = Ice.Util.createProperties();
initData.properties.setProperty("Ice.Admin.DelayCreation", "1");
try
{
using (var communicator = Ice.Util.initialize(ref args, initData))
{
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
communicator.shutdown();
};
Ice.Properties properties = communicator.getProperties();
Dictionary <string, string> services = properties.getPropertiesForPrefix(prefix);
foreach (string arg in argSeq)
{
bool valid = false;
foreach (KeyValuePair <string, string> pair in services)
{
string name = pair.Key.Substring(prefix.Length);
if (arg.StartsWith("--" + name, StringComparison.CurrentCulture))
{
valid = true;
break;
}
}
if (!valid)
{
if (arg.Equals("-h") || arg.Equals("--help"))
{
usage();
status = 1;
break;
}
else if (arg.Equals("-v") || arg.Equals("--version"))
{
Console.Out.WriteLine(Ice.Util.stringVersion());
status = 1;
break;
}
else
{
Console.Error.WriteLine("IceBox.Server: unknown option `" + arg + "'");
usage();
status = 1;
break;
}
}
}
ServiceManagerI serviceManagerImpl = new ServiceManagerI(communicator, argSeq.ToArray());
status = serviceManagerImpl.run();
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
status = 1;
}
return(status);
}
internal void initialize()
{
if (_initialized)
{
return;
}
const string prefix = "IceSSL.";
Ice.Properties properties = communicator().getProperties();
//
// Check for a default directory. We look in this directory for
// files mentioned in the configuration.
//
_defaultDir = properties.getProperty(prefix + "DefaultDir");
string keySet = properties.getPropertyWithDefault(prefix + "KeySet", "DefaultKeySet");
if (!keySet.Equals("DefaultKeySet") && !keySet.Equals("UserKeySet") && !keySet.Equals("MachineKeySet"))
{
_logger.warning("Invalid IceSSL.KeySet value `" + keySet + "' adjusted to `DefaultKeySet'");
keySet = "DefaultKeySet";
}
X509KeyStorageFlags keyStorageFlags = X509KeyStorageFlags.DefaultKeySet;
if (keySet.Equals("UserKeySet"))
{
keyStorageFlags = X509KeyStorageFlags.UserKeySet;
}
else if (keySet.Equals("MachineKeySet"))
{
keyStorageFlags = X509KeyStorageFlags.MachineKeySet;
}
if (properties.getPropertyAsIntWithDefault(prefix + "PersistKeySet", 0) > 0)
{
keyStorageFlags |= X509KeyStorageFlags.PersistKeySet;
}
//
// Process IceSSL.ImportCert.* properties.
//
Dictionary <string, string> certs = properties.getPropertiesForPrefix(prefix + "ImportCert.");
foreach (KeyValuePair <string, string> entry in certs)
{
string name = entry.Key;
string val = entry.Value;
if (val.Length > 0)
{
importCertificate(name, val, keyStorageFlags);
}
}
//
// Select protocols.
//
_protocols = parseProtocols(prefix + "Protocols");
//
// CheckCertName determines whether we compare the name in a peer's
// certificate against its hostname.
//
_checkCertName = properties.getPropertyAsIntWithDefault(prefix + "CheckCertName", 0) > 0;
//
// VerifyDepthMax establishes the maximum length of a peer's certificate
// chain, including the peer's certificate. A value of 0 means there is
// no maximum.
//
_verifyDepthMax = properties.getPropertyAsIntWithDefault(prefix + "VerifyDepthMax", 2);
//
// CheckCRL determines whether the certificate revocation list is checked, and how strictly.
//
_checkCRL = properties.getPropertyAsIntWithDefault(prefix + "CheckCRL", 0);
//
// Check for a certificate verifier.
//
string certVerifierClass = properties.getProperty(prefix + "CertVerifier");
if (certVerifierClass.Length > 0)
{
if (_verifier != null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: certificate verifier already installed";
throw e;
}
Type cls = _facade.findType(certVerifierClass);
if (cls == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load certificate verifier class " + certVerifierClass;
throw e;
}
try
{
_verifier = (CertificateVerifier)IceInternal.AssemblyUtil.createInstance(cls);
}
catch (Exception ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: unable to instantiate certificate verifier class " + certVerifierClass;
throw e;
}
if (_verifier == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to instantiate certificate verifier class " + certVerifierClass;
throw e;
}
}
//
// Check for a password callback.
//
string passwordCallbackClass = properties.getProperty(prefix + "PasswordCallback");
if (passwordCallbackClass.Length > 0)
{
if (_passwordCallback != null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: password callback already installed";
throw e;
}
Type cls = _facade.findType(passwordCallbackClass);
if (cls == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
try
{
_passwordCallback = (PasswordCallback)IceInternal.AssemblyUtil.createInstance(cls);
}
catch (Exception ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
if (_passwordCallback == null)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: unable to load password callback class " + passwordCallbackClass;
throw e;
}
}
//
// If the user hasn't supplied a certificate collection, we need to examine
// the property settings.
//
if (_certs == null)
{
//
// If IceSSL.CertFile is defined, load a certificate from a file and
// add it to the collection.
//
// TODO: tracing?
_certs = new X509Certificate2Collection();
string certFile = properties.getProperty(prefix + "CertFile");
string passwordStr = properties.getProperty(prefix + "Password");
if (certFile.Length > 0)
{
if (!checkPath(ref certFile))
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: certificate file not found: " + certFile;
throw e;
}
SecureString password = null;
if (passwordStr.Length > 0)
{
password = createSecureString(passwordStr);
}
else if (_passwordCallback != null)
{
password = _passwordCallback.getPassword(certFile);
}
try
{
X509Certificate2 cert;
if (password != null)
{
cert = new X509Certificate2(certFile, password, keyStorageFlags);
}
else
{
cert = new X509Certificate2(certFile, "", keyStorageFlags);
}
_certs.Add(cert);
}
catch (CryptographicException ex)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException(ex);
e.reason = "IceSSL: error while attempting to load certificate from " + certFile;
throw e;
}
}
//
// If IceSSL.FindCert.* properties are defined, add the selected certificates
// to the collection.
//
// TODO: tracing?
const string findPrefix = prefix + "FindCert.";
Dictionary <string, string> certProps = properties.getPropertiesForPrefix(findPrefix);
if (certProps.Count > 0)
{
foreach (KeyValuePair <string, string> entry in certProps)
{
string name = entry.Key;
string val = entry.Value;
if (val.Length > 0)
{
string storeSpec = name.Substring(findPrefix.Length);
X509Certificate2Collection coll = findCertificates(name, storeSpec, val);
_certs.AddRange(coll);
}
}
if (_certs.Count == 0)
{
Ice.PluginInitializationException e = new Ice.PluginInitializationException();
e.reason = "IceSSL: no certificates found";
throw e;
}
}
}
_initialized = true;
}