public static DiscoveryResult DiscoverDevice(int port) { IEnumerable<string> ips = getInterfaceAddresses(); var ret = new DiscoveryResult(); _localEndPoint = new IPEndPoint(IPAddress.Any, 0); _client = new UdpClient(port); var p = new ISCPPacket("!xECNQSTN"); byte[] sendbuf = p.GetBytes(); foreach (string networkaddress in ips) { _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); } while (_client.Available > 0) { byte[] recv = _client.Receive(ref _localEndPoint); Thread.Sleep(100); var sb = new StringBuilder(); foreach (byte t in recv) sb.Append(char.ConvertFromUtf32(Convert.ToInt32(string.Format("{0:x2}", t), 16))); string stringData = sb.ToString(); if (stringData.Contains("!1ECN")) { int idx = stringData.IndexOf("!1ECN") + 5; string[] parts = stringData.Substring(idx).Split('/'); string mac = parts[3].Substring(0,12); string ip = ARP.GetIPInfo(mac).IPAddress; ret.IP = ip; ret.Port = Convert.ToInt32(parts[1]); ret.Region = stringData.Substring(idx + 14, 2); ret.MAC = mac; ret.Model = stringData.Substring(idx, 7); } } _client.Close(); return ret; }
/// <summary> /// Performs discovery on the specified identifier. /// </summary> /// <param name="identifier">The identifier to perform discovery on.</param> /// <param name="requestHandler">The means to place outgoing HTTP requests.</param> /// <param name="abortDiscoveryChain">if set to <c>true</c>, no further discovery services will be called for this identifier.</param> /// <returns> /// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty. /// </returns> public IEnumerable <IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) { abortDiscoveryChain = false; var uriIdentifier = identifier as UriIdentifier; if (uriIdentifier == null) { return(Enumerable.Empty <IdentifierDiscoveryResult>()); } var endpoints = new List <IdentifierDiscoveryResult>(); // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Discover(requestHandler, uriIdentifier, identifier.IsDiscoverySecureEndToEnd); if (yadisResult != null) { if (yadisResult.IsXrds) { try { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); var xrdsEndpoints = xrds.XrdElements.CreateServiceEndpoints(yadisResult.NormalizedUri, uriIdentifier); // Filter out insecure endpoints if high security is required. if (uriIdentifier.IsDiscoverySecureEndToEnd) { xrdsEndpoints = xrdsEndpoints.Where(se => se.ProviderEndpoint.IsTransportSecure()); } endpoints.AddRange(xrdsEndpoints); } catch (XmlException ex) { Logger.Yadis.Error("Error while parsing the XRDS document. Falling back to HTML discovery.", ex); } } // Failing YADIS discovery of an XRDS document, we try HTML discovery. if (endpoints.Count == 0) { var htmlEndpoints = new List <IdentifierDiscoveryResult>(DiscoverFromHtml(yadisResult.NormalizedUri, uriIdentifier, yadisResult.ResponseText)); if (htmlEndpoints.Any()) { Logger.Yadis.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count); Logger.Yadis.Debug(htmlEndpoints.ToStringDeferred(true)); endpoints.AddRange(htmlEndpoints.Where(ep => !uriIdentifier.IsDiscoverySecureEndToEnd || ep.ProviderEndpoint.IsTransportSecure())); if (endpoints.Count == 0) { Logger.Yadis.Info("No HTML discovered endpoints met the security requirements."); } } else { Logger.Yadis.Debug("HTML discovery failed to find any endpoints."); } } else { Logger.Yadis.Debug("Skipping HTML discovery because XRDS contained service endpoints."); } } return(endpoints); }
/// <summary> /// Searches for an XRDS document at the realm URL, and if found, searches /// for a description of a relying party endpoints (OpenId login pages). /// </summary> /// <param name="allowRedirects"> /// Whether redirects may be followed when discovering the Realm. /// This may be true when creating an unsolicited assertion, but must be /// false when performing return URL verification per 2.0 spec section 9.2.1. /// </param> /// <returns>The details of the endpoints if found, otherwise null.</returns> internal IEnumerable <DotNetOpenId.Provider.RelyingPartyReceivingEndpoint> Discover(bool allowRedirects) { // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Yadis.Discover(UriWithWildcardChangedToWww, false); if (yadisResult != null) { if (!allowRedirects && yadisResult.NormalizedUri != yadisResult.RequestUri) { // Redirect occurred when it was not allowed. throw new OpenIdException(string.Format(CultureInfo.CurrentCulture, Strings.RealmCausedRedirectUponDiscovery, yadisResult.RequestUri)); } if (yadisResult.IsXrds) { try { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); return(xrds.FindRelyingPartyReceivingEndpoints()); } catch (XmlException ex) { throw new OpenIdException(Strings.InvalidXRDSDocument, ex); } } } return(new RelyingPartyReceivingEndpoint[0]); }
internal DiscoveryResult DiscoverInternal(Assembly testAssembly, string testAssemblyPath, string configFilePath) { var bindingRegistry = GetBindingRegistry(testAssembly, configFilePath); var result = new DiscoveryResult(); var warningCollector = new WarningCollector(); _sourceFiles.Clear(); GetOrCreateSymbolReader(testAssembly, warningCollector, testAssemblyPath); result.StepDefinitions = GetStepDefinitions(bindingRegistry).Select(sdb => new StepDefinition { Type = sdb.StepDefinitionType.ToString(), Regex = sdb.Regex.ToString(), Method = sdb.Method.ToString(), ParamTypes = GetParamTypes(sdb.Method), Scope = GetScope(sdb), SourceLocation = GetSourceLocation(sdb.Method, warningCollector) }) .Distinct() //TODO: SpecFlow discoverers bindings from external assemblies twice -- needs fix .ToArray(); result.SourceFiles = _sourceFiles.ToDictionary(sf => sf.Value.ToString(), sf => sf.Key); result.TypeNames = _typeNames.ToDictionary(sf => sf.Value.ToString(), sf => sf.Key); result.Warnings = warningCollector.Warnings; result.SpecFlowVersion = typeof(IStepDefinitionBinding).Assembly.Location; return(result); }
static void OnDoWork(object sender, DoWorkEventArgs args) { var discovery = args.Argument as Discovery; var result = new DiscoveryResult(); args.Result = result; if (discovery != null) { try { result.Reference = new DiscoveryCompiler(discovery, CodeProvider.Default) .GenerateReference("temp"); } catch (InvalidOperationException ioe) { Debug.WriteLine(ioe.Message); result.FailureReason = ioe.Message; if (ioe.InnerException != null) { result.FailureReason += "\n" + ioe.InnerException.Message; } } } }
public void AddElement(DiscoveryResult discoveryResult) { ServerListElement serverListElement = GameObject.Instantiate(serverListElementPrefab, transform).GetComponent <ServerListElement>(); serverListElements.Add(serverListElement); serverListElement.Init(discoveryResult); UpdateColumnWidths(); }
public async Task <DiscoveryResult> DiscoverDevice(int port) { IEnumerable <string> ips = getInterfaceAddresses(); var ret = new DiscoveryResult(); _localEndPoint = new IPEndPoint(IPAddress.Any, 22222); _client = new UdpClient(port); _client.EnableBroadcast = true; _packetService.SetCommand("!xECNQSTN"); byte[] sendbuf = _packetService.GetBytes(); foreach (string networkaddress in ips) { try { _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); Console.WriteLine("Dobry socket"); } catch (Exception e) { Console.WriteLine("Zly socket"); Console.WriteLine(e); } } //while (_client.Available > 0) while (_client.Available > 0) { // var recv = new byte[256]; // _sock.Receive(recv, recv.Length, SocketFlags.None); byte[] recv = _client.Receive(ref _localEndPoint); Thread.Sleep(300); var sb = new StringBuilder(); foreach (byte t in recv) { sb.Append(char.ConvertFromUtf32(Convert.ToInt32(string.Format("{0:x2}", t), 16))); } string stringData = sb.ToString(); if (stringData.Contains("!1ECN")) { int idx = stringData.IndexOf("!1ECN") + 5; string[] parts = stringData.Substring(idx).Split('/'); string mac = parts[3].Substring(0, 12); var ip = _addressResolutionProtocolService.GetIPInfo(mac); ret.IP = ip.IpAddress; ret.Port = Convert.ToInt32(parts[1]); ret.Region = stringData.Substring(idx + 14, 2); ret.MAC = mac; ret.Model = stringData.Substring(idx, 7); } } // _sock.Close(); _client.Close(); return(ret); }
internal override IEnumerable <ServiceEndpoint> Discover() { List <ServiceEndpoint> endpoints = new List <ServiceEndpoint>(); // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Yadis.Discover(this, IsDiscoverySecureEndToEnd); if (yadisResult != null) { if (yadisResult.IsXrds) { try { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); var xrdsEndpoints = xrds.CreateServiceEndpoints(yadisResult.NormalizedUri); // Filter out insecure endpoints if high security is required. if (IsDiscoverySecureEndToEnd) { xrdsEndpoints = Util.Where(xrdsEndpoints, se => se.IsSecure); } endpoints.AddRange(xrdsEndpoints); } catch (XmlException ex) { //Logger.Error("Error while parsing the XRDS document. Falling back to HTML discovery.", ex); } } // Failing YADIS discovery of an XRDS document, we try HTML discovery. if (endpoints.Count == 0) { var htmlEndpoints = new List <ServiceEndpoint>(DiscoverFromHtml(yadisResult.NormalizedUri, yadisResult.ResponseText)); if (htmlEndpoints.Count > 0) { //Logger.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count); //Logger.Debug(Util.ToString(htmlEndpoints, true)); endpoints.AddRange(Util.Where(htmlEndpoints, ep => !IsDiscoverySecureEndToEnd || ep.IsSecure)); if (endpoints.Count == 0) { //Logger.Info("No HTML discovered endpoints met the security requirements."); } } else { //Logger.Debug("HTML discovery failed to find any endpoints."); } } else { //Logger.Debug("Skipping HTML discovery because XRDS contained service endpoints."); } } return(endpoints); }
/// <summary> /// Performs discovery on the Identifier. /// </summary> /// <param name="requestHandler">The web request handler to use for discovery.</param> /// <returns> /// An initialized structure containing the discovered provider endpoint information. /// </returns> internal override IEnumerable <ServiceEndpoint> Discover(IDirectWebRequestHandler requestHandler) { List <ServiceEndpoint> endpoints = new List <ServiceEndpoint>(); // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Discover(requestHandler, this, IsDiscoverySecureEndToEnd); if (yadisResult != null) { if (yadisResult.IsXrds) { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); var xrdsEndpoints = xrds.CreateServiceEndpoints(yadisResult.NormalizedUri, this); // Filter out insecure endpoints if high security is required. if (IsDiscoverySecureEndToEnd) { xrdsEndpoints = xrdsEndpoints.Where(se => se.IsSecure); } endpoints.AddRange(xrdsEndpoints); } // Failing YADIS discovery of an XRDS document, we try HTML discovery. if (endpoints.Count == 0) { var htmlEndpoints = new List <ServiceEndpoint>(DiscoverFromHtml(yadisResult.NormalizedUri, this, yadisResult.ResponseText)); if (htmlEndpoints.Any()) { Logger.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count); Logger.Debug(htmlEndpoints.ToStringDeferred(true)); endpoints.AddRange(htmlEndpoints.Where(ep => !IsDiscoverySecureEndToEnd || ep.IsSecure)); if (endpoints.Count == 0) { Logger.Info("No HTML discovered endpoints met the security requirements."); } } else { Logger.Debug("HTML discovery failed to find any endpoints."); } } else { Logger.Debug("Skipping HTML discovery because XRDS contained service endpoints."); } } return(endpoints); }
internal override IEnumerable <ServiceEndpoint> Discover() { List <ServiceEndpoint> endpoints = new List <ServiceEndpoint>(); // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Yadis.Discover(this, IsDiscoverySecureEndToEnd); if (yadisResult != null) { if (yadisResult.IsXrds) { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); var xrdsEndpoints = xrds.CreateServiceEndpoints(yadisResult.NormalizedUri); // Filter out insecure endpoints if high security is required. if (IsDiscoverySecureEndToEnd) { xrdsEndpoints = Util.Where(xrdsEndpoints, se => se.IsSecure); } endpoints.AddRange(xrdsEndpoints); } // Failing YADIS discovery of an XRDS document, we try HTML discovery. if (endpoints.Count == 0) { ServiceEndpoint ep = DiscoverFromHtml(yadisResult.NormalizedUri, yadisResult.ResponseText); if (ep != null) { Logger.Debug("HTML discovery found a service endpoint."); Logger.Debug(ep); if (!IsDiscoverySecureEndToEnd || ep.IsSecure) { endpoints.Add(ep); } else { Logger.Info("Skipping HTML discovered endpoint because it is not secure."); } } else { Logger.Debug("HTML discovery failed to find any endpoints."); } } else { Logger.Debug("Skipping HTML discovery because XRDS contained service endpoints."); } } return(endpoints); }
/// <summary> /// Gets the information that will be sent in the authentication /// request to the OpenID Provider. /// </summary> /// <param name="discResult">The DiscoveryResult object to use.</param> public NameValueCollection BuildAuthorizationData(DiscoveryResult discResult) { NameValueCollection pms = new NameValueCollection(); pms["openid.identity"] = discResult.LocalId; if (discResult.AuthVersion == ProtocolVersion.V2Dot0) { pms["openid.claimed_id"] = discResult.ClaimedId; } else { pms["esoid.ReturnUrl"] = "esoid.claimed_id=" + HttpUtility.UrlEncode(discResult.ClaimedId); } return pms; }
/// <summary> /// Searches for an XRDS document at the realm URL. /// </summary> /// <param name="requestHandler">The mechanism to use for sending HTTP requests.</param> /// <param name="allowRedirects">Whether redirects may be followed when discovering the Realm. /// This may be true when creating an unsolicited assertion, but must be /// false when performing return URL verification per 2.0 spec section 9.2.1.</param> /// <returns> /// The XRDS document if found; or <c>null</c> if no service document was discovered. /// </returns> internal virtual XrdsDocument Discover(IDirectWebRequestHandler requestHandler, bool allowRedirects) { // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Discover(requestHandler, this.UriWithWildcardChangedToWww, false); if (yadisResult != null) { // Detect disallowed redirects, since realm discovery never allows them for security. ErrorUtilities.VerifyProtocol(allowRedirects || yadisResult.NormalizedUri == yadisResult.RequestUri, OpenIdStrings.RealmCausedRedirectUponDiscovery, yadisResult.RequestUri); if (yadisResult.IsXrds) { try { return new XrdsDocument(yadisResult.ResponseText); } catch (XmlException ex) { throw ErrorUtilities.Wrap(ex, XrdsStrings.InvalidXRDSDocument); } } } return null; }
internal static async Task <Office365ServiceInfo> CreateAsync() { // Attempt to build an Office365ServiceInfo object based on cached API endpoint & resource ID information: SharePointOneDriveServiceInfo info = new SharePointOneDriveServiceInfo { ResourceId = (string)Office365CommonController.GetFromCache("SharePointOneDriveResourceId"), ApiEndpoint = (string)Office365CommonController.GetFromCache("SharePointOneDriveApiEndpoint") }; // If the Resource ID and API Endpoint are not empty, then the cached information is sufficient: if (info.ResourceId != null && info.ApiEndpoint != null) { info.AccessToken = Office365CommonController.GetAccessToken(info.ResourceId); return(info); } // If did not return above, invoke the Discovery Service to obtain the resource ID and API endpoint: info._discoveryServiceInfo = new DiscoveryServiceInfo(); // If no auth header is available for Discovery, return the info as is, with the missing // access token (and possibly a missing ResourceId and ApiEndpoint as well). The caller will need // to do an OAuth redirect anyway. if (!info._discoveryServiceInfo.HasValidAccessToken) { return(info); } // If still here, discovery has enough information to obtain the SharePoint OneDrive endpoints: DiscoveryResult[] results = await info._discoveryServiceInfo.DiscoverServicesAsync(); DiscoveryResult myFilesEndpoint = results.First(result => result.Capability == "MyFiles"); // Update and cache the resource ID and API endpoint: info.ResourceId = myFilesEndpoint.ServiceResourceId; // NOTE: In the initial Preview release of Service Discovery, the "MyFiles" endpoint URL will always // start with something like "https://contoso-my.sharepoint.com/personal/<username>_contoso_com/_api", // but the path following "/_api" may change over time. For consistency, it is safer to manually // extract the root path, and then append a call for the location of the Documents folder: info.ApiEndpoint = myFilesEndpoint.ServiceEndpointUri.Substring( 0, myFilesEndpoint.ServiceEndpointUri.IndexOf("/_api", StringComparison.Ordinal)) + "/_api/web/getfolderbyserverrelativeurl('Documents')"; Office365CommonController.SaveInCache("SharePointOneDriveResourceId", info.ResourceId); Office365CommonController.SaveInCache("SharePointOneDriveApiEndpoint", info.ApiEndpoint); info.AccessToken = Office365CommonController.GetAccessToken(info.ResourceId); return(info); }
internal async static Task <Office365ServiceInfo> CreateAsync() { // Attempt to build an Office365ServiceInfo object based on cached API endpoint & resource ID information: Office365ServiceInfo info = new SharePointOneDriveServiceInfo() { ResourceId = (string)Office365Helper.GetFromCache("SharePointOneDriveResourceId"), ApiEndpoint = (string)Office365Helper.GetFromCache("SharePointOneDriveApiEndpoint") }; // If the cached Resource ID and API Endpoint are not empty, then use them: if ((info.ResourceId != null) && (info.ApiEndpoint != null)) { info.AccessToken = await Office365Helper.GetAccessToken(info.ResourceId); return(info); } // If did not return above, invoke the Discovery Service to obtain the resource ID and API endpoint: DiscoveryServiceInfo discoveryServiceInfo = await DiscoveryServiceInfo.CreateAsync(); if (!discoveryServiceInfo.HasValidAccessToken) { // Cannot communicated with Service Discovery, so return the empty SharePointOneDriveServiceInfo as is. // The missing access token will let the caller know that the service is not ready to be used. return(info); } DiscoveryResult[] results = await discoveryServiceInfo.DiscoverServicesAsync(); DiscoveryResult myFilesEndpoint = results.First(result => result.Capability == "MyFiles"); // Update and cache the resource ID and API endpoint: info.ResourceId = myFilesEndpoint.ServiceResourceId; // NOTE: In the initial Preview release of Service Discovery, the "MyFiles" endpoint URL will always // start with something like "https://contoso-my.sharepoint.com/personal/<username>_contoso_com/_api", // but the path following "/_api" may change over time. For consistency, it is safer to manually // extract the root path, and then append a call for the location of the Documents folder: info.ApiEndpoint = myFilesEndpoint.ServiceEndpointUri.Substring( 0, myFilesEndpoint.ServiceEndpointUri.IndexOf("/_api", StringComparison.Ordinal)) + "/_api/web/getfolderbyserverrelativeurl('Documents')"; Office365Helper.SaveInCache("SharePointOneDriveResourceId", info.ResourceId); Office365Helper.SaveInCache("SharePointOneDriveApiEndpoint", info.ApiEndpoint); info.AccessToken = await Office365Helper.GetAccessToken(info.ResourceId); return(info); }
public void Init(DiscoveryResult discoveryResult) { hostedByColumnText.text = discoveryResult.HostName; playersColumnText.text = discoveryResult.ConnectedPlayers + " / " + discoveryResult.NumberOfPlayers; lapsColumnText.text = discoveryResult.Laps.ToString(); connectButton.onClick.AddListener(() => { GameSession.serverSession = null; GameSession.clientSession = new ClientSession { remoteServerIpAddress = discoveryResult.RemoteServerIpAddress, remoteServerPort = discoveryResult.RemoteServerPort }; SceneManager.LoadScene("SampleScene", LoadSceneMode.Single); }); }
private static void OnDoWork(object sender, DoWorkEventArgs args) { var discovery = args.Argument as Discovery; var result = new DiscoveryResult(); args.Result = result; if (discovery != null) { try { result.Reference = new DiscoveryCompiler(discovery, CodeProvider.Default) .GenerateReference("temp"); } catch (InvalidOperationException ioe) { result.FailureReason = ioe.Message; } } }
public static DiscoveryResult DiscoverDevice(int port) { IEnumerable <string> ips = getInterfaceAddresses(); var ret = new DiscoveryResult(); _localEndPoint = new IPEndPoint(IPAddress.Any, 0); _client = new UdpClient(port); var p = new ISCPPacket("!xECNQSTN"); byte[] sendbuf = p.GetBytes(); foreach (string networkaddress in ips) { _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); _client.Send(sendbuf, sendbuf.Length, IPAddress.Parse(networkaddress).ToString(), port); } while (_client.Available > 0) { byte[] recv = _client.Receive(ref _localEndPoint); Thread.Sleep(100); var sb = new StringBuilder(); foreach (byte t in recv) { sb.Append(char.ConvertFromUtf32(Convert.ToInt32(string.Format("{0:x2}", t), 16))); } string stringData = sb.ToString(); if (stringData.Contains("!1ECN")) { int idx = stringData.IndexOf("!1ECN") + 5; string[] parts = stringData.Substring(idx).Split('/'); string mac = parts[3].Substring(0, 12); string ip = ARP.GetIPInfo(mac).IPAddress; ret.IP = ip; ret.Port = Convert.ToInt32(parts[1]); ret.Region = stringData.Substring(idx + 14, 2); ret.MAC = mac; ret.Model = stringData.Substring(idx, 7); } } _client.Close(); return(ret); }
/// <summary> /// Add a forwarding rule to the router using UPnP /// </summary> public bool ForwardPort(int port, string description) { if (!CheckAvailability()) { return(false); } var client = NetUtility.GetSelfAddresses(); if (client == null) { return(false); } bool success = false; lock (m_discoveryResults) { for (int i = 0; i < m_discoveryResults.Count; i++) { ref DiscoveryResult result = ref m_discoveryResults.Data[i]; try { SOAPRequest(result.ServiceUrl, "<u:AddPortMapping xmlns:u=\"urn:schemas-upnp-org:service:" + result.ServiceName + ":1\">" + "<NewRemoteHost></NewRemoteHost>" + "<NewExternalPort>" + port.ToString() + "</NewExternalPort>" + "<NewProtocol>" + ProtocolType.Udp.ToString().ToUpper(System.Globalization.CultureInfo.InvariantCulture) + "</NewProtocol>" + "<NewInternalPort>" + port.ToString() + "</NewInternalPort>" + "<NewInternalClient>" + client.ToString() + "</NewInternalClient>" + "<NewEnabled>1</NewEnabled>" + "<NewPortMappingDescription>" + description + "</NewPortMappingDescription>" + "<NewLeaseDuration>0</NewLeaseDuration>" + "</u:AddPortMapping>", "AddPortMapping", result.ServiceName); success = true; m_peer.LogDebug("Sent UPnP port forward request"); } catch (Exception ex) { m_peer.LogVerbose("UPnP port forward failed: " + ex.Message); } } }
/// <summary> /// Searches for an XRDS document at the realm URL, and if found, searches /// for a description of a relying party endpoints (OpenId login pages). /// </summary> /// <param name="requestHandler">The mechanism to use for sending HTTP requests.</param> /// <param name="allowRedirects">Whether redirects may be followed when discovering the Realm. /// This may be true when creating an unsolicited assertion, but must be /// false when performing return URL verification per 2.0 spec section 9.2.1.</param> /// <returns> /// The details of the endpoints if found, otherwise null. /// </returns> internal IEnumerable <RelyingPartyEndpointDescription> Discover(IDirectWebRequestHandler requestHandler, bool allowRedirects) { // Attempt YADIS discovery DiscoveryResult yadisResult = Yadis.Discover(requestHandler, this.UriWithWildcardChangedToWww, false); if (yadisResult != null) { // Detect disallowed redirects, since realm discovery never allows them for security. ErrorUtilities.VerifyProtocol(allowRedirects || yadisResult.NormalizedUri == yadisResult.RequestUri, OpenIdStrings.RealmCausedRedirectUponDiscovery, yadisResult.RequestUri); if (yadisResult.IsXrds) { try { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); return(xrds.FindRelyingPartyReceivingEndpoints()); } catch (XmlException ex) { throw ErrorUtilities.Wrap(ex, XrdsStrings.InvalidXRDSDocument); } } } return(Enumerable.Empty <RelyingPartyEndpointDescription>()); }
/// <summary> /// Searches for an XRDS document at the realm URL. /// </summary> /// <param name="hostFactories">The host factories.</param> /// <param name="allowRedirects">Whether redirects may be followed when discovering the Realm. /// This may be true when creating an unsolicited assertion, but must be /// false when performing return URL verification per 2.0 spec section 9.2.1.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// The XRDS document if found; or <c>null</c> if no service document was discovered. /// </returns> internal virtual async Task <XrdsDocument> DiscoverAsync(IHostFactories hostFactories, bool allowRedirects, CancellationToken cancellationToken) { // Attempt YADIS discovery DiscoveryResult yadisResult = await Yadis.DiscoverAsync(hostFactories, this.UriWithWildcardChangedToWww, false, cancellationToken); if (yadisResult != null) { // Detect disallowed redirects, since realm discovery never allows them for security. ErrorUtilities.VerifyProtocol(allowRedirects || yadisResult.NormalizedUri == yadisResult.RequestUri, OpenIdStrings.RealmCausedRedirectUponDiscovery, yadisResult.RequestUri); if (yadisResult.IsXrds) { try { return(new XrdsDocument(yadisResult.ResponseText)); } catch (XmlException ex) { throw ErrorUtilities.Wrap(ex, XrdsStrings.InvalidXRDSDocument); } } } return(null); }
internal async static Task <Office365ServiceInfo> CreateAsync() { // Attempt to build an Office365ServiceInfo object based on cached API endpoint & resource ID information: Office365ServiceInfo info = new OneDriveServiceInfo() { ResourceId = (string)Office365Helper.GetFromCache("OneDriveResourceId"), ApiEndpoint = (string)Office365Helper.GetFromCache("OneDriveApiEndpoint") }; // If the cached Resource ID and API Endpoint are not empty, then use them: if ((info.ResourceId != null) && (info.ApiEndpoint != null)) { info.AccessToken = await Office365Helper.GetAccessToken(info.ResourceId); return(info); } // If did not return above, invoke the Discovery Service to obtain the resource ID and API endpoint: DiscoveryServiceInfo discoveryServiceInfo = await DiscoveryServiceInfo.CreateAsync(); if (!discoveryServiceInfo.HasValidAccessToken) { // Cannot communicated with Service Discovery, so return the empty SharePointOneDriveServiceInfo as is. // The missing access token will let the caller know that the service is not ready to be used. return(info); } DiscoveryResult[] results = await discoveryServiceInfo.DiscoverServicesAsync(); DiscoveryResult myFilesEndpoint = results.First(result => result.Capability == "MyFiles"); // Update and cache the resource ID and API endpoint: info.ResourceId = myFilesEndpoint.ServiceResourceId; info.ApiEndpoint = myFilesEndpoint.ServiceEndpointUri; Office365Helper.SaveInCache("OneDriveResourceId", info.ResourceId); Office365Helper.SaveInCache("OneDriveApiEndpoint", info.ApiEndpoint); info.AccessToken = await Office365Helper.GetAccessToken(info.ResourceId); return(info); }
internal DiscoveryResult DiscoverInternal(Assembly testAssembly, string testAssemblyPath, string configFilePath) { try { var bindingRegistry = GetBindingRegistry(testAssembly, configFilePath); var result = new DiscoveryResult(); var warningCollector = new WarningCollector(); _sourceFiles.Clear(); GetOrCreateSymbolReader(testAssembly, warningCollector, testAssemblyPath); result.StepDefinitions = GetStepDefinitions(bindingRegistry) .Select(sdb => CreateStepDefinition(sdb, warningCollector)) .Distinct() //TODO: SpecFlow discoverers bindings from external assemblies twice -- needs fix .ToArray(); result.SourceFiles = _sourceFiles.ToDictionary(sf => sf.Value.ToString(), sf => sf.Key); result.TypeNames = _typeNames.ToDictionary(sf => sf.Value.ToString(), sf => sf.Key); result.Warnings = warningCollector.Warnings; result.SpecFlowVersion = typeof(IStepDefinitionBinding).Assembly.Location; return(result); } catch (Exception ex) when(GetRegexError(ex) != null) { var regexError = GetRegexError(ex); return(new DiscoveryResult() { SpecFlowVersion = typeof(IStepDefinitionBinding).Assembly.Location, StepDefinitions = new[] { new StepDefinition { Method = "Unknown method", Error = $"Step definition regular expression error: {regexError.Message}" } } }); } }
private static void OnDoWork(object sender, DoWorkEventArgs args) { var discovery = args.Argument as Discovery; var result = new DiscoveryResult(); args.Result = result; if (discovery == null) { return; } try { result.Reference = new DiscoveryCompiler(discovery, CodeProvider.Default) .GenerateReference("temp"); } catch (InvalidOperationException ioe) { result.FailureReason = ioe.Message; } }
public async Task <DiscoveryResult> Discover(TerminalDTO terminal, bool isUserInitiated) { TerminalDO existentTerminal = null; if (!string.IsNullOrWhiteSpace(terminal.Name) && !string.IsNullOrWhiteSpace(terminal.Version)) { // TODO: @alexavrutin: This comparison is not going to work in the long term. // Terminal names are not guaranateed to be unique. Consider changing to Endpoint. existentTerminal = _terminal.GetAll().FirstOrDefault(x => !string.Equals(x.Name, terminal.Name, StringComparison.OrdinalIgnoreCase) && x.Version == terminal.Version); if (existentTerminal != null) { Logger.Info($"Discovering of terminal Name: {terminal.Name}, Version: {terminal.Version} was requested..."); } } if (existentTerminal == null) { if (string.IsNullOrWhiteSpace(terminal.Endpoint)) { var message = "No endpoint was specified for discovery request"; Logger.Warn(message); return(DiscoveryResult.Error(message)); } Logger.Info($"Discovering of terminal at '{terminal.Endpoint}' was requested..."); existentTerminal = _terminal.GetAll().FirstOrDefault(x => string.Equals(NormalizeUrl(x.Endpoint), NormalizeUrl(terminal.Endpoint), StringComparison.OrdinalIgnoreCase)); } if (existentTerminal == null) { var message = $"Discovery for terminal '{terminal.Endpoint}' failed: the provided Endpoint is not found in the Endpoint field of any of the existing Terminal entries."; Logger.Info(message); return(DiscoveryResult.Error(message)); } return(await DiscoverInternal(existentTerminal, isUserInitiated)); }
/// <summary> /// Returns the URL to which the User Agent should be redirected for the initial authentication request. /// </summary> /// <param name="props">RequestProperties object holding the current state.</param> /// <param name="discResult">The DiscoveryResult object created from the previous discovery process.</param> /// <param name="immediate">Whether or not an Immediate Mode request is being generated.</param> /// <returns>The complete URL to which the User Agent should be redirected.</returns> internal static Uri GetRedirectURL(StateContainer props, DiscoveryResult discResult, bool immediate) { if (props == null) { throw new ArgumentNullException("props"); } if (discResult == null) { throw new ArgumentNullException("discResult"); } NameValueCollection pms = new NameValueCollection(); if (immediate) { pms["openid.mode"] = "checkid_immediate"; } else { pms["openid.mode"] = "checkid_setup"; } string returl = props.ReturnToUrl.AbsoluteUri; switch (props.AuthMode) { case AuthenticationMode.Stateful: Association assoc = props.AssociationManager.FindByServer(discResult.ServerUrl.AbsoluteUri); Random r = new Random(); props.Nonce = r.Next(); switch (discResult.AuthVersion) { case ProtocolVersion.V1Dot1: pms["openid.assoc_handle"] = assoc.Handle; pms["openid.trust_root"] = props.TrustRoot; break; case ProtocolVersion.V2Dot0: pms["openid.ns"] = ProtocolUri.OpenId2Dot0.AbsoluteUri; pms["openid.assoc_handle"] = assoc.Handle; pms["openid.realm"] = props.TrustRoot; break; } break; case AuthenticationMode.Stateless: switch (discResult.AuthVersion) { case ProtocolVersion.V1Dot1: pms["openid.trust_root"] = props.TrustRoot; break; case ProtocolVersion.V2Dot0: pms["openid.ns"] = ProtocolUri.OpenId2Dot0.AbsoluteUri; pms["openid.realm"] = props.TrustRoot; break; } break; } foreach (IExtension e in props.ExtensionPlugIns) { NameValueCollection authdata = e.BuildAuthorizationData(discResult); foreach (string key in authdata.Keys) { if (key == "esoid.ReturnUrl") { if (returl.Contains("?")) { returl += "&" + authdata[key]; } else { returl += "?" + authdata[key]; } } else { pms[key] = authdata[key]; } } } pms["openid.return_to"] = Utility.AddExtraVariables(returl, props); return Utility.MakeGetURL(discResult.ServerUrl, pms); }
//private async Task<StandardFr8TerminalCM> SendDiscoveryRequest(string terminalUrl, Dictionary<string, string> headers = null) //{ // // Use a custom HttpClient to query the terminal with a low timeout (10 sec) // var innerClient = new HttpClient(); // innerClient.Timeout = new TimeSpan(0, 0, 10); // try // { // var response = await innerClient.GetAsync(new Uri(terminalUrl + "/discover", UriKind.Absolute)); // response.EnsureSuccessStatusCode(); // var responseContent = await response.Content.ReadAsStringAsync(); // return JsonConvert.DeserializeObject<StandardFr8TerminalCM>(responseContent); // } // catch (Exception) // Expect an exception if the request failed // { // throw; // } //} private async Task <DiscoveryResult> DiscoverInternal(TerminalDO terminalDo, bool isUserInitiated) { var terminalUrl = terminalDo.Endpoint; Logger.Info($"Starting discovering terminal at '{terminalUrl}'. Reporting about self as the Hub at '{_serverUrl}'."); string secret = null; if (terminalDo.ParticipationState == ParticipationState.Blocked) { var message = $"Discovery for terminal '{terminalUrl}' will not happen because the terminal is blocked."; Logger.Info(message); return(DiscoveryResult.Error(message)); } if (terminalDo.ParticipationState == ParticipationState.Deleted) { var message = $"Discovery for terminal '{terminalUrl}' will not happen because the terminal is deleted."; Logger.Info(message); return(DiscoveryResult.Error(message)); } if (!string.IsNullOrWhiteSpace(terminalDo?.Secret)) { secret = terminalDo.Secret; } if (secret == null) { Logger.Info($"Generating new secret for terminal at '{terminalUrl}'"); secret = Guid.NewGuid().ToString("N"); } var headers = new Dictionary <string, string> { { "Fr8HubCallbackSecret", secret }, { "Fr8HubCallBackUrl", _serverUrl } }; StandardFr8TerminalCM terminalRegistrationInfo = null; try { terminalRegistrationInfo = await SendDiscoveryRequest(terminalUrl, headers); } catch (Exception ex) { Logger.Warn("Failed to call terminal discovery endpoint", ex); _eventReporter.ActivityTemplateTerminalRegistrationError($"Failed terminal service: {terminalUrl}. Error Message: {ex.Message} ", ex.GetType().Name); terminalRegistrationInfo = null; } if (terminalRegistrationInfo == null || terminalRegistrationInfo.Definition == null || terminalRegistrationInfo.Activities == null) { // Discovery failed var message = $"Terminal at '{terminalUrl}' didn't return a valid response to the discovery request."; Logger.Warn(message); // Set terminal status inactive terminalDo.OperationalState = OperationalState.Inactive; try { _terminal.RegisterOrUpdate(terminalDo, isUserInitiated); } catch (Exception ex) { Logger.Error("Failed to update information about the terminal.", ex); } return(DiscoveryResult.Error(message)); } terminalDo.Secret = secret; terminalDo.OperationalState = OperationalState.Active; terminalDo.AuthenticationType = terminalRegistrationInfo.Definition.AuthenticationType; terminalDo.Description = terminalRegistrationInfo.Definition.Description; terminalDo.Label = terminalRegistrationInfo.Definition.Label; terminalDo.Name = terminalRegistrationInfo.Definition.Name; terminalDo.Version = terminalRegistrationInfo.Definition.Version; terminalDo.TerminalStatus = terminalRegistrationInfo.Definition.TerminalStatus; if (string.IsNullOrWhiteSpace(terminalDo.Label)) { terminalDo.Label = terminalDo.Name; } try { terminalDo = _terminal.RegisterOrUpdate(terminalDo, isUserInitiated); } catch (Exception ex) { Logger.Error("Failed to update information about the terminal.", ex); return(DiscoveryResult.Error($"Internal error updating the information about the terminal at '{terminalUrl}'")); } var activityTemplates = terminalRegistrationInfo.Activities.Select(Mapper.Map <ActivityTemplateDO>).ToList(); var result = new DiscoveryResult(true, null); foreach (var curItem in activityTemplates) { Logger.Info($"Registering activity '{curItem.Name}' from terminal at '{terminalUrl}'"); try { curItem.Terminal = terminalDo; curItem.TerminalId = terminalDo.Id; _activityTemplateService.RegisterOrUpdate(curItem); result.SucceededTemplates.Add(curItem); } catch (Exception ex) { _eventReporter.ActivityTemplateTerminalRegistrationError($"Failed to register activity {curItem.Name} of version {curItem.Version} for terminal {terminalDo.Name}. Error Message: {ex.Message}", ex.GetType().Name); Logger.Warn($"Failed to register activity {curItem.Name} of version {curItem.Version} for terminal {terminalDo.Name}", ex); result.FailedTemplates.Add(curItem); } } _activityTemplateService.RemoveInactiveActivities(terminalDo, activityTemplates); Logger.Info($"Successfully discovered terminal at '{terminalUrl}'."); return(result); }
private DiscoveryResult DiscoverTestsFromSingleDiscoverer( LazyExtension <ITestDiscoverer, ITestDiscovererCapabilities> discoverer, IEnumerable <string> sources, DiscoveryContext context, TestCaseDiscoverySink discoverySink, IMessageLogger logger, CancellationToken cancellationToken) { var result = new DiscoveryResult(); if (DiscovererEnumerator.TryToLoadDiscoverer(discoverer, logger, out var discovererType) == false) { // Fail to instantiate the discoverer type. return(result); } // on instantiated successfully, get tests try { EqtTrace.Verbose( "DiscovererEnumerator.DiscoverTestsFromSingleDiscoverer: Loading tests for {0}", discoverer.Value.GetType().FullName); var currentTotalTests = this.discoveryResultCache.TotalDiscoveredTests; var newTimeStart = DateTime.UtcNow; this.testPlatformEventSource.AdapterDiscoveryStart(discoverer.Metadata.DefaultExecutorUri.AbsoluteUri); foreach (var testSource in sources) { if (cancellationToken.IsCancellationRequested) { EqtTrace.Info("DiscovererEnumerator.DiscoverTestsFromSingleDiscoverer: Cancellation Requested. Aborting the discovery"); break; } discoverer.Value.DiscoverTests(new[] { testSource }, context, logger, discoverySink); } var totalAdapterRunTime = DateTime.UtcNow - newTimeStart; this.testPlatformEventSource.AdapterDiscoveryStop(this.discoveryResultCache.TotalDiscoveredTests - currentTotalTests); // Record Total Tests Discovered By each Discoverer. var totalTestsDiscoveredByCurrentDiscoverer = this.discoveryResultCache.TotalDiscoveredTests - currentTotalTests; this.requestData.MetricsCollection.Add( string.Format("{0}.{1}", TelemetryDataConstants.TotalTestsByAdapter, discoverer.Metadata.DefaultExecutorUri), totalTestsDiscoveredByCurrentDiscoverer); result.TotalAdaptersUsed++; EqtTrace.Verbose("DiscovererEnumerator.DiscoverTestsFromSingleDiscoverer: Done loading tests for {0}", discoverer.Value.GetType().FullName); var discovererFromDeprecatedLocations = DiscovererEnumerator.IsDiscovererFromDeprecatedLocations(discoverer); if (discovererFromDeprecatedLocations) { logger.SendMessage(TestMessageLevel.Warning, string.Format(CultureInfo.CurrentCulture, CrossPlatEngineResources.DeprecatedAdapterPath)); } // Collecting Data Point for Time Taken to Discover Tests by each Adapter this.requestData.MetricsCollection.Add($"{TelemetryDataConstants.TimeTakenToDiscoverTestsByAnAdapter}.{discoverer.Metadata.DefaultExecutorUri}", totalAdapterRunTime.TotalSeconds); result.TotalTimeSpentInAdapaters += totalAdapterRunTime.TotalSeconds; } catch (Exception e) { var message = string.Format(CultureInfo.CurrentUICulture, CrossPlatEngineResources.ExceptionFromLoadTests, discovererType.Name, e.Message); logger.SendMessage(TestMessageLevel.Error, message); EqtTrace.Error("DiscovererEnumerator.DiscoverTestsFromSingleDiscoverer: {0} ", e); } return(result); }
public async Task <DiscoveryResult> Discover(TargetType targetType = TargetType.All, short ttl = 2) { List <IPAddress> addressList = new List <IPAddress>(); addressList.AddRange(NetworkInterface.GetAllNetworkInterfaces() .Where(a => a.NetworkInterfaceType != NetworkInterfaceType.Loopback && a.OperationalStatus == OperationalStatus.Up) .SelectMany(a => a.GetIPProperties().UnicastAddresses) .Where(a => a.Address.AddressFamily == AddressFamily.InterNetwork || a.Address.AddressFamily == AddressFamily.InterNetworkV6) .Select(a => a.Address)); DiscoveryResult result = new DiscoveryResult(); List <Task> tasks = new List <Task>(); foreach (var a in addressList) { var task = Task.Run(async() => { var dstAddress = a.AddressFamily == AddressFamily.InterNetwork ? Core.Ssdp.EndPoint.SiteLocal : a.AddressFamily == AddressFamily.InterNetworkV6 ? Core.Ssdp.EndPoint.SiteLocalV6 : null; var message = new Message(dstAddress, MessageType.Search) .Mx(TimeSpan.FromSeconds(3)) .St(targetType); var messageBin = message.ToByteArray(); using (var client = new Socket(a.AddressFamily, SocketType.Dgram, ProtocolType.Udp)) { client.Ttl = ttl; client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true); client.Bind(new IPEndPoint(a, 0)); var bufferIn = new ArraySegment <byte>(new byte[2048]); var remoteEp = a.AddressFamily == AddressFamily.InterNetwork ? new IPEndPoint(IPAddress.Any, 0) : a.AddressFamily == AddressFamily.InterNetworkV6 ? new IPEndPoint(IPAddress.IPv6Any, 0) : null; var receiveTask = client.ReceiveFromAsync(bufferIn, SocketFlags.None, remoteEp); var bufferOut = new ArraySegment <byte>(messageBin); client.SendTo(bufferOut.Array, dstAddress); client.SendTo(bufferOut.Array, dstAddress); while (true) { if (!receiveTask.Wait((int)(message.Mx().TotalMilliseconds *ttl))) { return; } var taskResult = await receiveTask; try { result.Add(a, bufferIn.Take(taskResult.ReceivedBytes).ToArray(), taskResult.RemoteEndPoint); } catch (Exception x) { } receiveTask = client.ReceiveFromAsync(bufferIn, SocketFlags.None, remoteEp); } } }); tasks.Add(task); } await Task.WhenAll(tasks); m_discoveryResult = result; return(result); }
/// <summary> /// Name-Value data to be sent to Identity Provider during /// initial authentication request. /// </summary> /// <param name="discResult">The DiscoveryResult object to use.</param> public NameValueCollection BuildAuthorizationData(DiscoveryResult discResult) { NameValueCollection pms = new NameValueCollection(); pms["openid.ns.pape"] = NamespaceUri.AbsoluteUri; pms["openid.pape.max_auth_age"] = MaxAge.ToString(CultureInfo.InvariantCulture); List<string> list = new List<string>(); foreach (Uri u in _PreferredPolicies) { list.Add(u.AbsoluteUri); } pms["openid.pape.preferred_auth_policies"] = String.Join(" ", list.ToArray()); return pms; }
/// <summary> /// Performs discovery on the specified identifier. /// </summary> /// <param name="identifier">The identifier to perform discovery on.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty. /// </returns> public async Task <IdentifierDiscoveryServiceResult> DiscoverAsync(Identifier identifier, CancellationToken cancellationToken) { Requires.NotNull(identifier, "identifier"); Verify.Operation(this.HostFactories != null, Strings.HostFactoriesRequired); cancellationToken.ThrowIfCancellationRequested(); var uriIdentifier = identifier as UriIdentifier; if (uriIdentifier == null) { return(new IdentifierDiscoveryServiceResult(Enumerable.Empty <IdentifierDiscoveryResult>())); } var endpoints = new List <IdentifierDiscoveryResult>(); // Attempt YADIS discovery DiscoveryResult yadisResult = await Yadis.DiscoverAsync(this.HostFactories, uriIdentifier, identifier.IsDiscoverySecureEndToEnd, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); if (yadisResult != null) { if (yadisResult.IsXrds) { try { XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText); var xrdsEndpoints = xrds.XrdElements.CreateServiceEndpoints(yadisResult.NormalizedUri, uriIdentifier); // Filter out insecure endpoints if high security is required. if (uriIdentifier.IsDiscoverySecureEndToEnd) { xrdsEndpoints = xrdsEndpoints.Where(se => se.ProviderEndpoint.IsTransportSecure()); } endpoints.AddRange(xrdsEndpoints); } catch (XmlException ex) { Logger.Yadis.ErrorException("Error while parsing the XRDS document. Falling back to HTML discovery.", ex); } } // Failing YADIS discovery of an XRDS document, we try HTML discovery. if (endpoints.Count == 0) { await yadisResult.TryRevertToHtmlResponseAsync(); var htmlEndpoints = new List <IdentifierDiscoveryResult>(DiscoverFromHtml(yadisResult.NormalizedUri, uriIdentifier, yadisResult.ResponseText)); if (htmlEndpoints.Any()) { Logger.Yadis.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count); Logger.Yadis.Debug(htmlEndpoints.ToStringDeferred(true).ToString()); endpoints.AddRange(htmlEndpoints.Where(ep => !uriIdentifier.IsDiscoverySecureEndToEnd || ep.ProviderEndpoint.IsTransportSecure())); if (endpoints.Count == 0) { Logger.Yadis.Info("No HTML discovered endpoints met the security requirements."); } } else { Logger.Yadis.Debug("HTML discovery failed to find any endpoints."); } } else { Logger.Yadis.Debug("Skipping HTML discovery because XRDS contained service endpoints."); } } return(new IdentifierDiscoveryServiceResult(endpoints)); }
/// <summary> /// Creates the redirect URL for the OpenID authentication request. /// </summary> /// <param name="immediate">Create an immediate-mode request URL.</param> /// <param name="autoRedirect">Automatically redirect the current HTTP session to the OpenID Provider.</param> /// <returns>The redirect URL string that should be launched by the user's web browser.</returns> /// <remarks> /// <para> /// Use Immediate mode to get an immediate response back from the OpenID Provider. /// This means the OpenID Provider will not prompt the user in any way, but will /// redirect the user's browser back with an authentication response. If the user /// is not currently logged in to the Provider, a "SetupNeeded" response will be /// received here at the client. /// </para> /// <para> /// Set autoRedirect to true to automatically perform an HTTP redirect on the user's /// browser. This option is only valid in an ASP.NET environment. For all other /// environments, setting this value will have no effect. /// </para> /// </remarks> public virtual Uri CreateRequest(bool immediate, bool autoRedirect) { Tracer.Write("Beginning standard authentication check"); // If the OpenID Provider was not found, return an error. if (ProviderUrl == null) { StateContainer.ErrorState = ErrorCondition.NoServersFound; Tracer.Write("No OpenID Provider found."); return null; } // Set to defaults if LastDiscoveryResult is not set by // an inheriting class. if (LastDiscoveryResult == null) { LastDiscoveryResult = new DiscoveryResult(); LastDiscoveryResult.AuthVersion = ProtocolVersion.V2Dot0; LastDiscoveryResult.ServerUrl = ProviderUrl; } // Adjust the AuthenticationMode setting based on // the discovered Provider URL StateContainer.AuthMode = Quirks.CheckOpenIDMode(ProviderUrl.AbsoluteUri, StateContainer.AuthMode); // Perform Stateful (smart) authentication if (StateContainer.AuthMode == AuthenticationMode.Stateful) { if (ProviderUrl != null) { if (Utility.BuildAssociation(ProviderUrl, StateContainer.AssociationManager, LastDiscoveryResult.AuthVersion) == true) { Uri redirectUrl = Utility.GetRedirectURL(StateContainer, LastDiscoveryResult, immediate); Tracer.Write("Returning Stateful URL - " + redirectUrl.AbsoluteUri); if (autoRedirect) { Redirect(redirectUrl); } return redirectUrl; } else { StateContainer.AuthMode = AuthenticationMode.Stateless; Tracer.Write("Stateful key exchange failed, forcing Dumb mode and re-running authentication"); } } } // Perform Stateless (dumb) authentication if (StateContainer.AuthMode == AuthenticationMode.Stateless) { if (ProviderUrl != null) { Uri redirectUrl = Utility.GetRedirectURL(StateContainer, LastDiscoveryResult, immediate); Tracer.Write("Returning stateless URL - " + redirectUrl.AbsoluteUri); if (autoRedirect) { Redirect(redirectUrl); } return redirectUrl; } } return null; }
/// <summary> /// Retrieve the URL of the OpenID Provider using configured discovery plugins /// </summary> /// <returns>The URL of the OpenID Provider</returns> internal static DiscoveryResult GetProviderUrl(string identity, IList<IDiscovery> discoveryPlugIns) { if (String.IsNullOrEmpty(identity)) { throw new ArgumentNullException("identity"); } if (discoveryPlugIns == null) { throw new ArgumentNullException("discoveryPlugIns"); } DiscoveryResult dr = new DiscoveryResult(); Tracer.Warn("Creating HTTP Request."); DiscoveryResult[] systems = null; string actualLocation = null; NormalizationEntry ne = Utility.Normalize(identity, discoveryPlugIns); if (ne == null) { return null; } string response = Utility.MakeRequest(ne.DiscoveryUrl, out actualLocation); if (String.IsNullOrEmpty(response)) { return null; } dr.ClaimedId = Utility.Normalize(actualLocation, discoveryPlugIns).NormalizedId; Tracer.Write("HTTP Request successful. Passing to discovery plugins."); for (int i = 0; i < discoveryPlugIns.Count; i++) { IDiscovery disc = (IDiscovery)discoveryPlugIns[i]; Tracer.Write("Trying plugin " + disc.Name); systems = disc.Discover(response); if (systems != null) { Tracer.Write("Plugin discovered endpoint."); dr.AuthVersion = disc.Version; break; } } if (systems == null) { Tracer.Write("Plugins did not discover endpoint."); return null; } if (systems.Length == 0) { Tracer.Write("No servers found."); return null; } DiscoveryResult entry = systems[0]; if (entry.LocalId != null) { Tracer.Write("Delegated OpenID."); dr.LocalId = entry.LocalId; } dr.ServerUrl = entry.ServerUrl; Tracer.Write("Discovery successful - " + dr.ServerUrl.AbsoluteUri); if (dr.LocalId == null) { dr.LocalId = actualLocation; } return dr; }
/// <summary> /// Dictionary<string, string> containing key-value pairs that will be passed /// during initial authentication request to Identity Provider. /// </summary> /// <param name="discResult">The DiscoveryResult object to use.</param> public NameValueCollection BuildAuthorizationData(DiscoveryResult discResult) { NameValueCollection pms = new NameValueCollection(); int fieldcount = _OptionalFields.Count + _RequiredFields.Count; if (PolicyUrl != null) { fieldcount++; } if (fieldcount > 0) { if (discResult.AuthVersion == ProtocolVersion.V2Dot0) { pms["openid.ns.sreg"] = _Namespace.AbsoluteUri; } if (RequiredFields != null) { pms[_Prefix + "required"] = RequiredFields; } if (OptionalFields != null) { pms[_Prefix + "optional"] = OptionalFields; } if (PolicyUrl != null) { pms[_Prefix + "policy_url"] = PolicyUrl.AbsoluteUri; } } return pms; }
/// <summary> /// Parse HTTP response for OpenID Identity Providers. /// </summary> /// <param name="content">HTTP response content to parse.</param> /// <returns>An array of DiscoveryResult objects.</returns> public DiscoveryResult[] Discover(string content) { if (!content.Contains("<?xml")) { return null; } int xmlbegin = content.IndexOf("<?xml", StringComparison.Ordinal); string fixedcontent = content.Substring(xmlbegin); XmlDocument xd = new XmlDocument(); try { xd.LoadXml(fixedcontent); } catch (XmlException xe) { Tracer.Write("XML decode failed: " + xe.Message); return null; } foreach (IExtension ext in Parent.ExtensionPlugIns) { IXrdsConsumer ixc = ext as IXrdsConsumer; if (ixc != null) { ixc.ProcessXrds(xd); } } XmlNamespaceManager nsmanager = new XmlNamespaceManager(xd.NameTable); nsmanager.AddNamespace("openid", "http://openid.net/xmlns/1.0"); nsmanager.AddNamespace("xrds", "xri://$xrds"); nsmanager.AddNamespace("xrd", "xri://$xrd*($v*2.0)"); XmlNode rootnode = xd.DocumentElement; List<DiscoveryResult> entries = new List<DiscoveryResult>(); XmlNodeList xmlServices = rootnode.SelectNodes("/xrds:XRDS/xrd:XRD/xrd:Service", nsmanager); foreach (XmlNode node in xmlServices) { DiscoveryResult entry = new DiscoveryResult(); entry.AuthVersion = ProtocolVersion.Invalid; foreach (XmlAttribute attr in node.Attributes) { switch (attr.Name.ToUpperInvariant()) { case "PRIORITY": entry.Priority = Convert.ToInt32(attr.Value, CultureInfo.InvariantCulture); break; default: break; } } foreach (XmlNode servicenode in node.ChildNodes) { string val = null; if (servicenode.HasChildNodes) { val = servicenode.ChildNodes[0].Value; } if (val != null) { switch (servicenode.Name) { case "Type": if (val.Contains("http://specs.openid.net/auth/2.")) { entry.AuthVersion = ProtocolVersion.V2Dot0; } else if (val.Contains("http://openid.net/signon/1.")) { if (entry.AuthVersion != ProtocolVersion.V2Dot0) { entry.AuthVersion = ProtocolVersion.V1Dot1; } } break; case "URI": entry.ServerUrl = new Uri(val); break; case "openid:Delegate": entry.LocalId = val; break; case "LocalID": entry.LocalId = val; break; default: break; } } } if (entry.ServerUrl != null && entry.AuthVersion != ProtocolVersion.Invalid) { entries.Add(entry); } } if (entries.Count > 0) { DiscoveryResultComparer comp = new DiscoveryResultComparer(); entries.Sort(comp); _PV = entries[0].AuthVersion; return entries.ToArray(); } return null; }
/// <summary> /// Build the authentication arguments that will be sent with the OpenID /// request. /// </summary> /// <param name="discResult">Discovery result data.</param> /// <returns>A populated dictionary containing the request arguments.</returns> public NameValueCollection BuildAuthorizationData(DiscoveryResult discResult) { NameValueCollection dict = new NameValueCollection(); dict.Add("openid.ns.oauth", NamespaceUri.AbsoluteUri); dict.Add(prefix + "consumer", OAuthClient.ConsumerKey); dict.Add(prefix + "scope", Scope); return dict; }
/// <summary> /// When Directed Identity is enabled, populate the LastDiscoveryResult /// variable with fake discovery data. /// </summary> /// <remarks> /// This is needed, as discovery does not occur in Directed Identity /// mode. /// </remarks> private void SetupDirectedIdentity() { identity = ProtocolUri.IdentifierSelect.AbsoluteUri; LastDiscoveryResult = new DiscoveryResult(); LastDiscoveryResult.AuthVersion = ProtocolVersion.V2Dot0; LastDiscoveryResult.ClaimedId = ProtocolUri.IdentifierSelect.AbsoluteUri; LastDiscoveryResult.LocalId = ProtocolUri.IdentifierSelect.AbsoluteUri; LastDiscoveryResult.ServerUrl = ProviderUrl; }
/// <summary> /// Parse HTTP response for OpenID Identity Providers. /// </summary> /// <param name="content">HTTP response content to parse.</param> /// <returns>An array of DiscoveryResult objects.</returns> public DiscoveryResult[] Discover(string content) { List<string> supportedVersions = new List<string>(); string newcontent = Utility.RemoveHtmlComments(content); Regex rx_linktag1 = new Regex("<link[^>]*rel=[\"']([^\"']+)[\"'][^>]*href=[\"']([^\"']+)[\"'][^>]*"); Regex rx_linktag2 = new Regex("<link[^>]*href=[\"']([^\"']+)[\"'][^>]*rel=[\"']([^\"']+)[\"'][^>]*"); MatchCollection m1 = rx_linktag1.Matches(newcontent); MatchCollection m2 = rx_linktag2.Matches(newcontent); List<string[]> links = new List<string[]>(); foreach (Match m in m1) { string[] l = { m.Groups[1].Value, m.Groups[2].Value }; links.Add(l); } foreach (Match m in m2) { string[] l = { m.Groups[2].Value, m.Groups[1].Value }; links.Add(l); } DiscoveryResult de1 = new DiscoveryResult(); de1.AuthVersion = ProtocolVersion.V1Dot1; DiscoveryResult de2 = new DiscoveryResult(); de2.AuthVersion = ProtocolVersion.V2Dot0; foreach (string[] link in links) { string relattr = link[0]; string hrefattr = link[1]; Uri u = null; if (relattr.Contains("openid2.provider")) { Uri.TryCreate(hrefattr, UriKind.Absolute, out u); if (u != null) { de2.ServerUrl = u; supportedVersions.Add("2.0"); } } else if (relattr.Contains("openid.server")) { Uri.TryCreate(hrefattr, UriKind.Absolute, out u); if (u != null) { de1.ServerUrl = u; supportedVersions.Add("1.x"); } } else if (relattr.Contains("openid2.local_id")) { de2.LocalId = hrefattr; supportedVersions.Add("2.0"); } else if (relattr.Contains("openid.delegate")) { de1.LocalId = hrefattr; supportedVersions.Add("1.x"); } } if (supportedVersions.Contains("2.0")) { _PV = ProtocolVersion.V2Dot0; } else if (supportedVersions.Contains("1.x")) { _PV = ProtocolVersion.V1Dot1; } List<DiscoveryResult> list = new List<DiscoveryResult>(); if (de2.ServerUrl != null) { list.Add(de2); } if (de1.ServerUrl != null) { list.Add(de1); } if (list.Count == 0) { return null; } return list.ToArray(); }
public DiscoveredChunk(Vector3 cPos, DiscoveryResult res) { this.res = res; chunkPos = cPos; }
/// <summary> /// Gets the key-value data to be sent to Identity Provider during /// authentication request. /// </summary> /// <param name="discResult">DiscoveryResult object to use.</param> public NameValueCollection BuildAuthorizationData(DiscoveryResult discResult) { NameValueCollection pms = new NameValueCollection(); pms["openid.ns.ax"] = NamespaceUri.AbsoluteUri; switch (Mode) { case AttributeExchangeMode.Fetch: pms[prefix + "mode"] = "fetch_request"; List<string> required = new List<string>(); List<string> if_available = new List<string>(); foreach (AttributeExchangeItem aei in _RequestData) { pms[prefix + "type." + aei.Alias] = aei.IdUri.AbsoluteUri; if (aei.Count > 1) { pms[prefix + "count." + aei.Alias] = aei.Count.ToString(CultureInfo.InvariantCulture); } if (aei.Required == true) { required.Add(aei.Alias); } else { if_available.Add(aei.Alias); } } if (required.Count > 0) { pms[prefix + "required"] = String.Join(",", required.ToArray()); } if (if_available.Count > 0) { pms[prefix + "if_available"] = String.Join(",", if_available.ToArray()); } if (UpdateUrl != null) { pms[prefix + "update_url"] = UpdateUrl.AbsoluteUri; } break; case AttributeExchangeMode.Store: pms[prefix + "mode"] = "store_request"; foreach (AttributeExchangeItem aei in _RequestData) { pms[prefix + "type." + aei.Alias] = aei.IdUri.AbsoluteUri; if (aei.Values != null) { if (aei.Count == 1) { pms[prefix + "value." + aei.Alias] = aei.Values[0]; } else if (aei.Count > 1) { pms[prefix + "count." + aei.Alias] = aei.Count.ToString(CultureInfo.InvariantCulture); for (int i = 0; i < aei.Count; i++) { pms[prefix + "value." + aei.Alias + "." + i.ToString(CultureInfo.InvariantCulture)] = aei.Values[i]; } } } } break; } return pms; }
/// <summary> /// Returns a new <see cref="OpenIdUser"/> object with a pre-set claimed identity. /// </summary> /// <param name="discResult">The DiscoveryResult object created from the previous discovery process.</param> public OpenIdUser(DiscoveryResult discResult) { _LastDiscoveryResult = discResult; }
protected virtual void Handle(DiscoveryResult <ITestService> discoveryResult) => AddServices(discoveryResult);
private static int GetCount(NetworkAdapterInfo info, DiscoveryResult[] discoveryResult, out DiscoveryResult result) { List <DiscoveryResult> devices = GetRoutingDevices(discoveryResult); int index = 0; result = null; foreach (DiscoveryResult device in devices) { if (device.NetworkAdapterInfo.Equals(info)) { index++; result = device; } } return(index); }