Function findAuthChallengeEnd

Libraries/HttpClient/HttpClientSession.cpp:121–173

    }
    return offset;
}

static size_t readAuthToken(SC::Span<const char> bytes, size_t offset, size_t end)
{
    while (offset < end and isHttpTokenCharacter(bytes[offset]))
    {
        offset += 1;
    }
    return offset;
}

static bool asciiStartsWith(SC::StringSpan text, SC::StringSpan prefix)
{
    if (text.sizeInBytes() < prefix.sizeInBytes())
    {
        return false;
    }
    const SC::Span<const char> textBytes   = text.toCharSpan();
    const SC::Span<const char> prefixBytes = prefix.toCharSpan();
    return ::memcmp(textBytes.data(), prefixBytes.data(), prefixBytes.sizeInBytes()) == 0;
}

static bool sessionIsAsciiWhiteSpace(char c) { return c == ' ' or c == '\t' or c == '\r' or c == '\n'; }

static bool sessionHasHttpHeaderUnsafeBytes(SC::StringSpan value)
{
    const SC::Span<const char> bytes = value.toCharSpan();
    for (size_t idx = 0; idx < bytes.sizeInBytes(); ++idx)
    {
        if (bytes[idx] == '\r' or bytes[idx] == '\n' or bytes[idx] == '\0')
        {
            return true;
        }
    }
    return false;
}

static SC::StringSpan trimAsciiWhiteSpace(SC::StringSpan text)
{
    const SC::Span<const char> bytes = text.toCharSpan();
    size_t                     start = 0;
    size_t                     end   = bytes.sizeInBytes();
    while (start < end and sessionIsAsciiWhiteSpace(bytes[start]))
    {
        start += 1;
    }
    while (end > start and sessionIsAsciiWhiteSpace(bytes[end - 1]))
    {
        end -= 1;
    }
    return {{bytes.data() + start, end - start}, false, SC::StringEncoding::Ascii};
}

static SC::StringSpan sliceString(SC::StringSpan text, size_t start, size_t end)
{
    const SC::Span<const char> bytes = text.toCharSpan();