/// <summary>
///Creates an authentication mechanism
/// </summary>
/// <param name="authIdentifier"></param>
/// <returns></returns>
private AuthenticationMechanism CreateAuthenticationMechanism(string authIdentifier)
{
IAuthenticationMethod authConfig = null;
foreach (IAuthenticationMethod authMethod in ConnectionsConfig.AuthenticationMethods)
{
//authMethod
//AuthenticationMechanismChecker checker = authMethod.AuthChecker;
//if (checker.IsCompatibleWith(EndpointContext.Connection))
// compatibleAuthenticationMethods.Add(authMethod.AuthIdentifier);
if (authMethod.AuthIdentifier.Equals(authIdentifier))
{
authConfig = authMethod;
}
}
AuthenticationMechanism auth;
if (authConfig == null)
{
auth = GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <AuthenticationMechanism>(authIdentifier);
}
else
{
auth = GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <AuthenticationMechanism>(authIdentifier, authConfig);
}
return(auth);
}
/// <summary>
/// Finds the type with the specified identifier in the specified assembly. This method also provides
/// a caching mechanism
/// </summary>
/// <param name="identifier"></param>
/// <param name="asm"></param>
/// <returns></returns>
public static Type FindTypedStreamSerializableType(string identifier, Assembly asm)
{
lock (_cachedTypes)
{
if (_cachedTypes.ContainsKey(asm) == false)
{
_cachedTypes.Add(asm, new Dictionary <string, Type> ());
}
if (_cachedTypes[asm].ContainsKey(identifier) == false)
{
Type t = GenericClassIdentifierFactory.FindTypeForIdentifier <ITypedStreamSerializable> (identifier, asm);
if (t == null)
{
return(null);
}
_cachedTypes[asm].Add(identifier, t);
}
return(_cachedTypes[asm][identifier]);
}
}
public static FrontEndConnection CreateFrontEndConnection(
string identifier,
ConnectionBuilderSettings settings,
params object[] parameters)
{
Type t = GenericClassIdentifierFactory.FindTypeForIdentifier <FrontEndConnection>(identifier);
if (t == null)
{
return(null);
}
FrontEndConnectionAttribute attr = (FrontEndConnectionAttribute)t.GetCustomAttributes(typeof(FrontEndConnectionAttribute), false)[0];
if (attr.ConnectionBuilder != null)
{
IConnectionBuilder connectionBuilder = (IConnectionBuilder)
GenericClassIdentifierFactory.CreateInstance(attr.ConnectionBuilder, parameters);
connectionBuilder.Settings = settings;
return(connectionBuilder.SetupConnection());
}
else
{
return(GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <FrontEndConnection>(identifier, parameters));
}
}
/// <summary>
/// Starts the configured connection listeners
/// </summary>
private void StartConnections()
{
IConnectionsConfiguration connectionConfig = (IConnectionsConfiguration)ConfigurationManager.GetSection("connections");
foreach (IListenerConfiguration listenerConfig in connectionConfig.Listeners)
{
_logger.DebugFormat("Listener configuration: {0}", listenerConfig.ListenerType);
_logger.DebugFormat("\tWith parameters:");
foreach (KeyValuePair <string, string> parameter in listenerConfig.Parameters)
{
_logger.DebugFormat("\tname={0}; value={1}", parameter.Key, parameter.Value);
}
IFrontEndServerListener listener = GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <IFrontEndServerListener>(
listenerConfig.ListenerType, listenerConfig);
if (listener == null)
{
_logger.FatalFormat("Cannot start listener '{0}', listener not found!", listenerConfig.ListenerType);
throw new ArgumentException(string.Format("Cannot start listener '{0}', listener not found!", listenerConfig.ListenerType));
}
_logger.InfoFormat("Listener '{0}' started succesfull (type={1})", listenerConfig.ListenerType, listener.GetType());
_listeners.Add(listener);
listener.ClientConnected += HandleListenerClientConnected;
listener.Listen();
}
}
public AuthenticationMechanismChecker(IAuthenticationMethod authConfig)
{
_authConfig = authConfig;
_authType = GenericClassIdentifierFactory.FindTypeForIdentifier <AuthenticationMechanism>(authConfig.AuthIdentifier);
if (_authType == null)
{
throw new ArgumentException(string.Format("No AuthenticationMechanism with identifier '{0}' was found", authConfig.AuthIdentifier));
}
object[] attributes = _authType.GetCustomAttributes(typeof(AuthenticationSettingsAttribute), false);
if (attributes == null || attributes.Length == 0)
{
throw new ArgumentException(string.Format("Authentication '{0}' does not provide authentication settings!", authConfig.AuthIdentifier));
}
_authSettings = (AuthenticationSettingsAttribute)attributes[0];
}
public override void Execute(string[] commandline)
{
if (commandline.Length < 2)
{
_console.Out.WriteLine("Error: [connection_name] not specified\n");
return;
}
Type t = GenericClassIdentifierFactory.FindTypeForIdentifier <FrontEndConnection>(commandline[1]);
if (t == null)
{
_console.Out.WriteLine("Error: Could not find connection with identifier '{0}'", commandline[1]);
return;
}
_console.Out.WriteLine("'{0}' supports the following constructions:", commandline[1]);
ConstructorInfo[] ctors = t.GetConstructors();
//Currently the tpm console only supports string parameters, so look if there is a ctor who only nneds string arguments
foreach (ConstructorInfo ctor in ctors)
{
bool validCtor = true;
string ctorArguments = "";
foreach (ParameterInfo param in ctor.GetParameters())
{
ctorArguments += "[" + param.Name + "] ";
if (param.ParameterType.Equals(typeof(string)) == false)
{
validCtor = false;
break;
}
}
if (validCtor)
{
_console.Out.WriteLine();
_console.Out.WriteLine(ctorArguments);
}
}
}
/// <summary>
/// Create a TPM keystore provider using its name.
/// </summary>
/// <param name="providerName"></param>
/// <param name="options"></param>
/// <returns></returns>
public static TPMKeystoreProvider Create(String providerName, IDictionary <String, String> options)
{
return(GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <TPMKeystoreProvider>(providerName, options));
}
/// <summary>
/// Creates an instance of the specified authentication mechanism
/// </summary>
/// <returns></returns>
public AuthenticationMechanism CreateInstance()
{
return(GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <AuthenticationMechanism>(_authSettings.Identifier));
}
