CheckAuthorityHelper()

unsafe int System.Uri.CheckAuthorityHelper ( char * pString, int idx, int length, ref ParsingError err, ref Flags flags, UriParser syntax, ref string newHost )

inlineprivate

Definition at line 2698 of file Uri.cs.

    {
        int i = length;
        int num = idx;
        int j = idx;
        newHost = null;
        bool justNormalized = false;
        bool flag = IriParsingStatic(syntax);
        bool flag2 = (flags & Flags.HasUnicode) != 0;
        bool flag3 = flag2 && (flags & Flags.HostUnicodeNormalized) == 0;
        UriSyntaxFlags flags2 = syntax.Flags;
        char c;
        if (idx == length || (c = pString[idx]) == '/' || (c == '\\' && StaticIsFile(syntax)) || c == '#' || c == '?')
        {
            if (syntax.InFact(UriSyntaxFlags.AllowEmptyHost))
            {
                flags &= ~Flags.UncPath;
                if (StaticInFact(flags, Flags.ImplicitFile))
                {
                    err = ParsingError.BadHostName;
                }
                else
                {
                    flags |= Flags.BasicHostType;
                }
            }
            else
            {
                err = ParsingError.BadHostName;
            }
            if (flag3)
            {
                flags |= Flags.HostUnicodeNormalized;
            }
            return idx;
        }
        if (flag3)
        {
            newHost = _originalUnicodeString.Substring(0, num);
        }
        string text = null;
        if ((flags2 & UriSyntaxFlags.MayHaveUserInfo) != 0)
        {
            for (; j < i; j++)
            {
                if (j == i - 1 || pString[j] == '?' || pString[j] == '#' || pString[j] == '\\' || pString[j] == '/')
                {
                    j = idx;
                    break;
                }
                if (pString[j] != '@')
                {
                    continue;
                }
                flags |= Flags.HasUserInfo;
                if (flag)
                {
                    if (flag3)
                    {
                        text = IriHelper.EscapeUnescapeIri(pString, num, j + 1, UriComponents.UserInfo);
                        newHost += text;
                        if (newHost.Length > 65535)
                        {
                            err = ParsingError.SizeLimit;
                            return idx;
                        }
                    }
                    else
                    {
                        text = new string(pString, num, j - num + 1);
                    }
                }
                j++;
                c = pString[j];
                break;
            }
        }
        bool notCanonical = (flags2 & UriSyntaxFlags.SimpleUserSyntax) == 0;
        if (c == '[' && syntax.InFact(UriSyntaxFlags.AllowIPv6Host) && IPv6AddressHelper.IsValid(pString, j + 1, ref i))
        {
            flags |= Flags.IPv6HostType;
            if (flag3)
            {
                newHost += new string(pString, j, i - j);
                flags |= Flags.HostUnicodeNormalized;
                justNormalized = true;
            }
        }
        else if (c <= '9' && c >= '0' && syntax.InFact(UriSyntaxFlags.AllowIPv4Host) && IPv4AddressHelper.IsValid(pString, j, ref i, allowIPv6: false, StaticNotAny(flags, Flags.ImplicitFile), syntax.InFact(UriSyntaxFlags.V1_UnknownUri)))
        {
            flags |= Flags.IPv4HostType;
            if (flag3)
            {
                newHost += new string(pString, j, i - j);
                flags |= Flags.HostUnicodeNormalized;
                justNormalized = true;
            }
        }
        else if ((flags2 & UriSyntaxFlags.AllowDnsHost) != 0 && !flag && DomainNameHelper.IsValid(pString, j, ref i, ref notCanonical, StaticNotAny(flags, Flags.ImplicitFile)))
        {
            flags |= Flags.DnsHostType;
            if (!notCanonical)
            {
                flags |= Flags.CanonicalDnsHost;
            }
        }
        else if ((flags2 & UriSyntaxFlags.AllowDnsHost) != 0 && (flag3 || syntax.InFact(UriSyntaxFlags.AllowIdn)) && DomainNameHelper.IsValidByIri(pString, j, ref i, ref notCanonical, StaticNotAny(flags, Flags.ImplicitFile)))
        {
            CheckAuthorityHelperHandleDnsIri(pString, j, i, flag2, ref flags, ref justNormalized, ref newHost, ref err);
        }
        else if ((flags2 & UriSyntaxFlags.AllowUncHost) != 0 && UncNameHelper.IsValid(pString, j, ref i, StaticNotAny(flags, Flags.ImplicitFile)) && i - j <= 256)
        {
            flags |= Flags.UncHostType;
            if (flag3)
            {
                newHost += new string(pString, j, i - j);
                flags |= Flags.HostUnicodeNormalized;
                justNormalized = true;
            }
        }
        if (i < length && pString[i] == '\\' && (flags & Flags.HostTypeMask) != Flags.Zero && !StaticIsFile(syntax))
        {
            if (syntax.InFact(UriSyntaxFlags.V1_UnknownUri))
            {
                err = ParsingError.BadHostName;
                flags |= Flags.HostTypeMask;
                return i;
            }
            flags &= ~Flags.HostTypeMask;
        }
        else if (i < length && pString[i] == ':')
        {
            if (syntax.InFact(UriSyntaxFlags.MayHavePort))
            {
                int num2 = 0;
                int num3 = i;
                for (idx = i + 1; idx < length; idx++)
                {
                    int num4 = pString[idx] - 48;
                    switch (num4)
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                        if ((num2 = num2 * 10 + num4) <= 65535)
                        {
                            continue;
                        }
                        break;
                    default:
                        if (syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost) && syntax.NotAny(UriSyntaxFlags.V1_UnknownUri))
                        {
                            flags &= ~Flags.HostTypeMask;
                            break;
                        }
                        err = ParsingError.BadPort;
                        return idx;
                    case -13:
                    case -1:
                    case 15:
                        break;
                    }
                    break;
                }
                if (num2 > 65535)
                {
                    if (!syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost))
                    {
                        err = ParsingError.BadPort;
                        return idx;
                    }
                    flags &= ~Flags.HostTypeMask;
                }
                if (flag2 && justNormalized)
                {
                    newHost += new string(pString, num3, idx - num3);
                }
            }
            else
            {
                flags &= ~Flags.HostTypeMask;
            }
        }
        if ((flags & Flags.HostTypeMask) == Flags.Zero)
        {
            flags &= ~Flags.HasUserInfo;
            if (syntax.InFact(UriSyntaxFlags.AllowAnyOtherHost))
            {
                flags |= Flags.BasicHostType;
                for (i = idx; i < length && pString[i] != '/' && pString[i] != '?' && pString[i] != '#'; i++)
                {
                }
                if (flag3)
                {
                    string text2 = new string(pString, num, i - num);
                    try
                    {
                        newHost += text2.Normalize(NormalizationForm.FormC);
                    }
                    catch (ArgumentException)
                    {
                        err = ParsingError.BadHostName;
                    }
                    flags |= Flags.HostUnicodeNormalized;
                }
            }
            else if (syntax.InFact(UriSyntaxFlags.V1_UnknownUri))
            {
                bool flag4 = false;
                int num5 = idx;
                for (i = idx; i < length && (!flag4 || (pString[i] != '/' && pString[i] != '?' && pString[i] != '#')); i++)
                {
                    if (i < idx + 2 && pString[i] == '.')
                    {
                        flag4 = true;
                        continue;
                    }
                    err = ParsingError.BadHostName;
                    flags |= Flags.HostTypeMask;
                    return idx;
                }
                flags |= Flags.BasicHostType;
                if (flag3)
                {
                    string text3 = new string(pString, num5, i - num5);
                    try
                    {
                        newHost += text3.Normalize(NormalizationForm.FormC);
                    }
                    catch (ArgumentException)
                    {
                        err = ParsingError.BadFormat;
                        return idx;
                    }
                    flags |= Flags.HostUnicodeNormalized;
                }
            }
            else if (syntax.InFact(UriSyntaxFlags.MustHaveAuthority) || syntax.InFact(UriSyntaxFlags.MailToLikeUri))
            {
                err = ParsingError.BadHostName;
                flags |= Flags.HostTypeMask;
                return idx;
            }
        }
        return i;
    }

References System.Uri._originalUnicodeString, System.Uri.CheckAuthorityHelperHandleDnsIri(), System.Runtime.Serialization.Dictionary, System.IriHelper.EscapeUnescapeIri(), System.Uri.IriParsingStatic(), System.DomainNameHelper.IsValid(), System.IPv6AddressHelper.IsValid(), System.IPv4AddressHelper.IsValid(), System.UncNameHelper.IsValid(), System.DomainNameHelper.IsValidByIri(), System.length, System.Uri.StaticInFact(), System.Uri.StaticIsFile(), System.Uri.StaticNotAny(), and System.text.

Referenced by System.Uri.GetHostViaCustomSyntax(), and System.Uri.PrivateParseMinimal().