public bool ImportPrivateKey(string label, PrivateKeyNotWallet key) { var aliased = AliasManager.SetAlias(label, key); var address = key.Address.Encoded; if (wallets.ContainsKey(label)) { return(false); } wallets.Add(address, aliased); AddressListener.Listen(key.Address); return(true); }
/// <summary> /// Looks at the incoming fields and figures out what the aliases and name spaces for auth level types are. /// </summary> /// <param name="fields">The incoming message data in which to discover TypeURIs and aliases.</param> /// <returns>The <see cref="AliasManager"/> initialized with the given data.</returns> internal static AliasManager FindIncomingAliases(IDictionary<string, string> fields) { AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith(Constants.AuthLevelNamespaceDeclarationPrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(Constants.AuthLevelNamespaceDeclarationPrefix.Length); aliasManager.SetAlias(alias, pair.Value); } aliasManager.SetPreferredAliasesWhereNotSet(Constants.AssuranceLevels.PreferredTypeUriToAliasMap); return aliasManager; }
static AliasManager parseAliases(IDictionary <string, string> fields) { Debug.Assert(fields != null); AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith("type.", StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(5); if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0) { Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return(aliasManager); }
/// <summary> /// Reads through the attributes included in the response to discover /// the alias-TypeURI relationships. /// </summary> /// <param name="fields">The data included in the extension message.</param> /// <returns>The alias manager that provides lookup between aliases and type URIs.</returns> private static AliasManager ParseAliases(IDictionary <string, string> fields) { Contract.Requires <ArgumentNullException>(fields != null); AliasManager aliasManager = new AliasManager(); const string TypePrefix = "type."; foreach (var pair in fields) { if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(TypePrefix.Length); if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0) { Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return(aliasManager); }
public bool ImportDeclaration(string alias, TxDeclaration declaration) { AliasManager.SetAlias(alias, declaration); if (declarations.ContainsKey(alias)) { return(false); } declarations.Add(alias, declaration); if (declaration is TxAddressDeclaration) { var address = ((TxAddressDeclaration)declaration).Address; AliasManager.SetAlias(address.Encoded, declaration); if (declarations.ContainsKey(address.Encoded)) { return(false); } declarations.Add(address.Encoded, declaration); AddressListener.Listen(address); } return(true); }
/// <summary> /// Reads through the attributes included in the response to discover /// the alias-TypeURI relationships. /// </summary> /// <param name="fields">The data included in the extension message.</param> /// <returns>The alias manager that provides lookup between aliases and type URIs.</returns> private static AliasManager ParseAliases(IDictionary<string, string> fields) { Contract.Requires<ArgumentNullException>(fields != null); AliasManager aliasManager = new AliasManager(); const string TypePrefix = "type."; foreach (var pair in fields) { if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(TypePrefix.Length); if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0) { Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return aliasManager; }
bool IExtensionRequest.Deserialize(IDictionary <string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri) { if (fields == null) { return(false); } string mode; fields.TryGetValue("mode", out mode); if (mode != Mode) { return(false); } string updateUrl; fields.TryGetValue("update_url", out updateUrl); Uri updateUri; if (Uri.TryCreate(updateUrl, UriKind.Absolute, out updateUri)) { UpdateUrl = updateUri; } string requiredAliasString, optionalAliasString; fields.TryGetValue("if_available", out optionalAliasString); fields.TryGetValue("required", out requiredAliasString); var requiredAliases = parseAliasList(requiredAliasString); var optionalAliases = parseAliasList(optionalAliasString); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List <string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return(false); } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (fields.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (fields.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") { att.Count = int.MaxValue; } else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } AddAttribute(att); } else { Logger.Error("Type URI definition of alias " + alias + " is missing."); } } return(true); }
/// <summary> /// Called when the message has been received, /// after it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnReceiving() { var extraData = ((IMessage)this).ExtraData; var requiredAliases = ParseAliasList(this.RequiredAliases); var optionalAliases = ParseAliasList(this.OptionalAliases); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.OpenId.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return; } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (extraData.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (extraData.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") { att.Count = int.MaxValue; } else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.OpenId.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } this.Attributes.Add(att); } else { Logger.OpenId.Error("Type URI definition of alias " + alias + " is missing."); } } }
bool IExtensionRequest.Deserialize(IDictionary<string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri) { if (fields == null) return false; string mode; fields.TryGetValue("mode", out mode); if (mode != Mode) return false; string updateUrl; fields.TryGetValue("update_url", out updateUrl); Uri updateUri; if (Uri.TryCreate(updateUrl, UriKind.Absolute, out updateUri)) UpdateUrl = updateUri; string requiredAliasString, optionalAliasString; fields.TryGetValue("if_available", out optionalAliasString); fields.TryGetValue("required", out requiredAliasString); var requiredAliases = parseAliasList(requiredAliasString); var optionalAliases = parseAliasList(optionalAliasString); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return false; } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (fields.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (fields.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") att.Count = int.MaxValue; else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } AddAttribute(att); } else { Logger.Error("Type URI definition of alias " + alias + " is missing."); } } return true; }
/// <summary> /// Called when the message has been received, /// after it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnReceiving() { var extraData = ((IMessage)this).ExtraData; var requiredAliases = ParseAliasList(this.RequiredAliases); var optionalAliases = ParseAliasList(this.OptionalAliases); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List <string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.OpenId.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return; } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (extraData.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (extraData.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") { att.Count = int.MaxValue; } else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.OpenId.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } this.Attributes.Add(att); } else { Logger.OpenId.Error("Type URI definition of alias " + alias + " is missing."); } } }
static AliasManager parseAliases(IDictionary<string, string> fields) { Debug.Assert(fields != null); AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith("type.", StringComparison.Ordinal)) continue; string alias = pair.Key.Substring(5); if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0) { Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return aliasManager; }