/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsDataChannel.h"
#include "nsDataHandler.h"
#include "nsNetCID.h"
#include "nsError.h"
#include "nsIOService.h"
#include "DataChannelChild.h"
#include "plstr.h"
#include "nsSimpleURI.h"
#include "mozilla/dom/MimeType.h"

////////////////////////////////////////////////////////////////////////////////

NS_IMPL_ISUPPORTS(nsDataHandler, nsIProtocolHandler, nsISupportsWeakReference)

nsresult
nsDataHandler::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult) {

    nsDataHandler* ph = new nsDataHandler();
    if (ph == nullptr)
        return NS_ERROR_OUT_OF_MEMORY;
    NS_ADDREF(ph);
    nsresult rv = ph->QueryInterface(aIID, aResult);
    NS_RELEASE(ph);
    return rv;
}

////////////////////////////////////////////////////////////////////////////////
// nsIProtocolHandler methods:

NS_IMETHODIMP
nsDataHandler::GetScheme(nsACString &result) {
    result.AssignLiteral("data");
    return NS_OK;
}

NS_IMETHODIMP
nsDataHandler::GetDefaultPort(int32_t *result) {
    // no ports for data protocol
    *result = -1;
    return NS_OK;
}

NS_IMETHODIMP
nsDataHandler::GetProtocolFlags(uint32_t *result) {
    *result = URI_NORELATIVE | URI_NOAUTH | URI_INHERITS_SECURITY_CONTEXT |
              URI_LOADABLE_BY_ANYONE | URI_NON_PERSISTABLE | URI_IS_LOCAL_RESOURCE |
              URI_SYNC_LOAD_IS_OK;
    return NS_OK;
}

NS_IMETHODIMP
nsDataHandler::NewURI(const nsACString &aSpec,
                      const char *aCharset, // ignore charset info
                      nsIURI *aBaseURI,
                      nsIURI **result) {
    nsresult rv;
    nsCOMPtr<nsIURI> uri;

    nsCString spec(aSpec);

    if (aBaseURI && !spec.IsEmpty() && spec[0] == '#') {
        // Looks like a reference instead of a fully-specified URI.
        // --> initialize |uri| as a clone of |aBaseURI|, with ref appended.
        rv = NS_MutateURI(aBaseURI)
               .SetRef(spec)
               .Finalize(uri);
    } else {
        // Otherwise, we'll assume |spec| is a fully-specified data URI
        nsAutoCString contentType;
        bool base64;
        rv = ParseURI(spec, contentType, /* contentCharset = */ nullptr,
                      base64, /* dataBuffer = */ nullptr);
        if (NS_FAILED(rv))
            return rv;

        // Strip whitespace unless this is text, where whitespace is important
        // Don't strip escaped whitespace though (bug 391951)
        if (base64 || (strncmp(contentType.get(),"text/",5) != 0 &&
                       contentType.Find("xml") == kNotFound)) {
            // it's ascii encoded binary, don't let any spaces in
            if (!spec.StripWhitespace(mozilla::fallible)) {
                return NS_ERROR_OUT_OF_MEMORY;
            }
        }

        rv = NS_MutateURI(new mozilla::net::nsSimpleURI::Mutator())
               .SetSpec(spec)
               .Finalize(uri);
    }

    if (NS_FAILED(rv))
        return rv;

    uri.forget(result);
    return rv;
}

NS_IMETHODIMP
nsDataHandler::NewChannel2(nsIURI* uri,
                           nsILoadInfo* aLoadInfo,
                           nsIChannel** result)
{
    NS_ENSURE_ARG_POINTER(uri);
    nsDataChannel* channel;
    if (XRE_IsParentProcess()) {
        channel = new nsDataChannel(uri);
    } else {
        channel = new mozilla::net::DataChannelChild(uri);
    }
    NS_ADDREF(channel);

    nsresult rv = channel->Init();
    if (NS_FAILED(rv)) {
        NS_RELEASE(channel);
        return rv;
    }

    // set the loadInfo on the new channel
    rv = channel->SetLoadInfo(aLoadInfo);
    if (NS_FAILED(rv)) {
        NS_RELEASE(channel);
        return rv;
    }

    *result = channel;
    return NS_OK;
}

NS_IMETHODIMP
nsDataHandler::NewChannel(nsIURI* uri, nsIChannel* *result)
{
    return NewChannel2(uri, nullptr, result);
}

NS_IMETHODIMP
nsDataHandler::AllowPort(int32_t port, const char *scheme, bool *_retval) {
    // don't override anything.
    *_retval = false;
    return NS_OK;
}

/**
 * Helper that performs a case insensitive match to find the offset of a given
 * pattern in a nsACString.
 * The search is performed starting from the end of the string; if the string
 * contains more than one match, the rightmost (last) match will be returned.
 */
static bool
FindOffsetOf(const nsACString& aPattern, const nsACString& aSrc,
             nsACString::size_type& aOffset)
{
    static const nsCaseInsensitiveCStringComparator kComparator;

    nsACString::const_iterator begin, end;
    aSrc.BeginReading(begin);
    aSrc.EndReading(end);
    if (!RFindInReadable(aPattern, begin, end, kComparator)) {
        return false;
    }

    // FindInReadable updates |begin| and |end| to the match coordinates.
    aOffset = nsACString::size_type(begin.get() - aSrc.Data());
    return true;
}

nsresult
nsDataHandler::ParsePathWithoutRef(
    const nsACString& aPath,
    nsCString& aContentType,
    nsCString* aContentCharset,
    bool& aIsBase64,
    nsDependentCSubstring* aDataBuffer)
{
    static NS_NAMED_LITERAL_CSTRING(kBase64, "base64");
    static NS_NAMED_LITERAL_CSTRING(kCharset, "charset");

    aIsBase64 = false;

    // First, find the start of the data
    int32_t commaIdx = aPath.FindChar(',');
    if (commaIdx == kNotFound) {
        return NS_ERROR_MALFORMED_URI;
    }

    if (commaIdx == 0) {
        // Nothing but data.
        aContentType.AssignLiteral("text/plain");
        if (aContentCharset) {
            aContentCharset->AssignLiteral("US-ASCII");
        }
    } else {
        auto mediaType = Substring(aPath, 0, commaIdx);

        // Determine if the data is base64 encoded.
        nsACString::size_type base64;
        if (FindOffsetOf(kBase64, mediaType, base64) && base64 > 0) {
            nsACString::size_type offset = base64 + kBase64.Length();
            // Per the RFC 2397 grammar, "base64" MUST be at the end of the
            // non-data part.
            //
            // But we also allow it in between parameters so a subsequent ";"
            // is ok as well (this deals with *broken* data URIs, see bug
            // 781693 for an example). Anything after "base64" in the non-data
            // part will be discarded in this case, however.
            if (offset == mediaType.Length() || mediaType[offset] == ';' || mediaType[offset] == ' ') {
                MOZ_DIAGNOSTIC_ASSERT(base64 > 0, "Did someone remove the check?");
                // Index is on the first character of matched "base64" so we
                // move to the preceding character
                base64--;
                // Skip any preceding spaces, searching for a semicolon
                while (base64 > 0 && mediaType[base64] == ' ') {
                    base64--;
                }
                if (mediaType[base64] == ';') {
                    aIsBase64 = true;
                    // Trim the base64 part off.
                    mediaType.Rebind(aPath, 0, base64);
                }
            }
        }

        // Skip any leading spaces
        nsACString::size_type startIndex = 0;
        while (startIndex < mediaType.Length() && mediaType[startIndex] == ' ') {
            startIndex++;
        }

        nsAutoCString mediaTypeBuf;
        // If the mimetype starts with ';' we assume text/plain
        if (startIndex < mediaType.Length() && mediaType[startIndex] == ';') {
            mediaTypeBuf.AssignLiteral("text/plain");
            mediaTypeBuf.Append(mediaType);
            mediaType.Rebind(mediaTypeBuf, 0, mediaTypeBuf.Length());
        }

        // Everything else is content type.
        UniquePtr<CMimeType> parsed = CMimeType::Parse(mediaType);
        if (parsed) {
            parsed->GetFullType(aContentType);
            if (aContentCharset) {
                parsed->GetParameterValue(kCharset, *aContentCharset);
            }
        } else {
            // Mime Type parsing failed
            aContentType.AssignLiteral("text/plain");
            if (aContentCharset) {
                aContentCharset->AssignLiteral("US-ASCII");
            }
        }

    }

    if (aDataBuffer) {
        aDataBuffer->Rebind(aPath, commaIdx + 1);
    }

    return NS_OK;
}

nsresult
nsDataHandler::ParseURI(nsCString& spec,
                        nsCString& contentType,
                        nsCString* contentCharset,
                        bool&    isBase64,
                        nsCString* dataBuffer)
{
    static NS_NAMED_LITERAL_CSTRING(kDataScheme, "data:");

    // move past "data:"
    int32_t scheme = spec.Find(kDataScheme, /* aIgnoreCase = */ true);
    if (scheme == kNotFound) {
        // malformed uri
        return NS_ERROR_MALFORMED_URI;
    }

    scheme += kDataScheme.Length();

    // Find the start of the hash ref if present.
    int32_t hash = spec.FindChar('#', scheme);

    auto pathWithoutRef = Substring(spec, scheme,
                                    hash != kNotFound ? hash : -1);
    nsDependentCSubstring dataRange;
    nsresult rv = ParsePathWithoutRef(pathWithoutRef, contentType,
                                      contentCharset, isBase64, &dataRange);
    if (NS_SUCCEEDED(rv) && dataBuffer) {
        if (!dataBuffer->Assign(dataRange, mozilla::fallible)) {
            rv = NS_ERROR_OUT_OF_MEMORY;
        }
    }

    return rv;
}