xref: /external/webkit/Source/WebCore/loader/archive/android/WebArchiveAndroid.cpp

/*
 * Copyright 2010, The Android Open Source Project
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#define LOG_TAG "webarchive"

#include "config.h"
#include "WebArchiveAndroid.h"

#if ENABLE(WEB_ARCHIVE)

#include "Base64.h"
#include <libxml/encoding.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xmlstring.h>
#include <libxml/xmlwriter.h>
#include <utils/Log.h>
#include <wtf/text/CString.h>

namespace WebCore {

static const xmlChar* const archiveTag = BAD_CAST "Archive";
static const xmlChar* const archiveResourceTag = BAD_CAST "ArchiveResource";
static const xmlChar* const mainResourceTag = BAD_CAST "mainResource";
static const xmlChar* const subresourcesTag = BAD_CAST "subresources";
static const xmlChar* const subframesTag = BAD_CAST "subframes";
static const xmlChar* const urlFieldTag = BAD_CAST "url";
static const xmlChar* const mimeFieldTag = BAD_CAST "mimeType";
static const xmlChar* const encodingFieldTag = BAD_CAST "textEncoding";
static const xmlChar* const frameFieldTag = BAD_CAST "frameName";
static const xmlChar* const dataFieldTag = BAD_CAST "data";

PassRefPtr<WebArchiveAndroid> WebArchiveAndroid::create(PassRefPtr<ArchiveResource> mainResource,
        Vector<PassRefPtr<ArchiveResource> >& subresources,
        Vector<PassRefPtr<Archive> >& subframeArchives)
{
    if (mainResource)
        return adoptRef(new WebArchiveAndroid(mainResource, subresources, subframeArchives));
    return 0;
}

PassRefPtr<WebArchiveAndroid> WebArchiveAndroid::create(Frame* frame)
{
    PassRefPtr<ArchiveResource> mainResource = frame->loader()->documentLoader()->mainResource();
    Vector<PassRefPtr<ArchiveResource> > subresources;
    Vector<PassRefPtr<Archive> > subframes;
    int children = frame->tree()->childCount();

    frame->loader()->documentLoader()->getSubresources(subresources);

    for (int child = 0; child < children; child++)
        subframes.append(create(frame->tree()->child(child)));

    return create(mainResource, subresources, subframes);
}

WebArchiveAndroid::WebArchiveAndroid(PassRefPtr<ArchiveResource> mainResource,
        Vector<PassRefPtr<ArchiveResource> >& subresources,
        Vector<PassRefPtr<Archive> >& subframeArchives)
{
    setMainResource(mainResource);

    for (Vector<PassRefPtr<ArchiveResource> >::iterator subresourcesIterator = subresources.begin();
         subresourcesIterator != subresources.end();
         subresourcesIterator++) {
        addSubresource(*subresourcesIterator);
    }

    for (Vector<PassRefPtr<Archive> >::iterator subframesIterator = subframeArchives.begin();
         subframesIterator != subframeArchives.end();
         subframesIterator++) {
        addSubframeArchive(*subframesIterator);
    }
}

static bool loadArchiveResourceField(xmlNodePtr resourceNode, const xmlChar* fieldName, Vector<char>* outputData)
{
    if (!outputData)
        return false;

    outputData->clear();

    const char* base64Data = 0;

    for (xmlNodePtr fieldNode = resourceNode->xmlChildrenNode;
         fieldNode;
         fieldNode = fieldNode->next) {
        if (xmlStrEqual(fieldNode->name, fieldName)) {
            base64Data = (const char*)xmlNodeGetContent(fieldNode->xmlChildrenNode);
            if (!base64Data) {
                /* Empty fields seem to break if they aren't null terminated. */
                outputData->append('\0');
                return true;
            }
            break;
        }
    }
    if (!base64Data) {
        ALOGD("loadArchiveResourceField: Failed to load field.");
        return false;
    }

    const int base64Size = xmlStrlen(BAD_CAST base64Data);

    const int result = base64Decode(base64Data, base64Size, *outputData);
    if (!result) {
        ALOGD("loadArchiveResourceField: Failed to decode field.");
        return false;
    }

    return true;
}

static PassRefPtr<SharedBuffer> loadArchiveResourceFieldBuffer(xmlNodePtr resourceNode, const xmlChar* fieldName)
{
    Vector<char> fieldData;

    if (loadArchiveResourceField(resourceNode, fieldName, &fieldData))
        return SharedBuffer::create(fieldData.data(), fieldData.size());

    return 0;
}

static String loadArchiveResourceFieldString(xmlNodePtr resourceNode, const xmlChar* fieldName)
{
    Vector<char> fieldData;

    if (loadArchiveResourceField(resourceNode, fieldName, &fieldData))
        return String::fromUTF8(fieldData.data(), fieldData.size());

    return String();
}

static KURL loadArchiveResourceFieldURL(xmlNodePtr resourceNode, const xmlChar* fieldName)
{
    Vector<char> fieldData;

    if (loadArchiveResourceField(resourceNode, fieldName, &fieldData))
        return KURL(ParsedURLString, String::fromUTF8(fieldData.data(), fieldData.size()));

    return KURL();
}

static PassRefPtr<ArchiveResource> loadArchiveResource(xmlNodePtr resourceNode)
{
    if (!xmlStrEqual(resourceNode->name, archiveResourceTag)) {
        ALOGD("loadArchiveResource: Malformed resource.");
        return 0;
    }

    KURL url = loadArchiveResourceFieldURL(resourceNode, urlFieldTag);
    if (url.isNull()) {
        ALOGD("loadArchiveResource: Failed to load resource.");
        return 0;
    }

    String mimeType = loadArchiveResourceFieldString(resourceNode, mimeFieldTag);
    if (mimeType.isNull()) {
        ALOGD("loadArchiveResource: Failed to load resource.");
        return 0;
    }

    String textEncoding = loadArchiveResourceFieldString(resourceNode, encodingFieldTag);
    if (textEncoding.isNull()) {
        ALOGD("loadArchiveResource: Failed to load resource.");
        return 0;
    }

    String frameName = loadArchiveResourceFieldString(resourceNode, frameFieldTag);
    if (frameName.isNull()) {
        ALOGD("loadArchiveResource: Failed to load resource.");
        return 0;
    }

    PassRefPtr<SharedBuffer> data = loadArchiveResourceFieldBuffer(resourceNode, dataFieldTag);
    if (!data) {
        ALOGD("loadArchiveResource: Failed to load resource.");
        return 0;
    }

    return ArchiveResource::create(data, url, mimeType, textEncoding, frameName);
}

static PassRefPtr<WebArchiveAndroid> loadArchive(xmlNodePtr archiveNode)
{
    xmlNodePtr resourceNode = 0;

    PassRefPtr<ArchiveResource> mainResource;
    Vector<PassRefPtr<ArchiveResource> > subresources;
    Vector<PassRefPtr<Archive> > subframes;

    if (!xmlStrEqual(archiveNode->name, archiveTag)) {
        ALOGD("loadArchive: Malformed archive.");
        return 0;
    }

    for (resourceNode = archiveNode->xmlChildrenNode;
         resourceNode;
         resourceNode = resourceNode->next) {
        if (xmlStrEqual(resourceNode->name, mainResourceTag)) {
            resourceNode = resourceNode->xmlChildrenNode;
            if (!resourceNode)
                break;
            mainResource = loadArchiveResource(resourceNode);
            break;
        }
    }
    if (!mainResource) {
        ALOGD("loadArchive: Failed to load main resource.");
        return 0;
    }

    for (resourceNode = archiveNode->xmlChildrenNode;
         resourceNode;
         resourceNode = resourceNode->next) {
        if (xmlStrEqual(resourceNode->name, subresourcesTag)) {
            for (resourceNode = resourceNode->xmlChildrenNode;
                 resourceNode;
                 resourceNode = resourceNode->next) {
                PassRefPtr<ArchiveResource> subresource = loadArchiveResource(resourceNode);
                if (!subresource) {
                    ALOGD("loadArchive: Failed to load subresource.");
                    break;
                }
                subresources.append(subresource);
            }
            break;
        }
    }

    for (resourceNode = archiveNode->xmlChildrenNode;
         resourceNode;
         resourceNode = resourceNode->next) {
        if (xmlStrEqual(resourceNode->name, subframesTag)) {
            for (resourceNode = resourceNode->xmlChildrenNode;
                 resourceNode;
                 resourceNode = resourceNode->next) {
                PassRefPtr<WebArchiveAndroid> subframe = loadArchive(resourceNode);
                if (!subframe) {
                    ALOGD("loadArchive: Failed to load subframe.");
                    break;
                }
                subframes.append(subframe);
            }
            break;
        }
    }

    return WebArchiveAndroid::create(mainResource, subresources, subframes);
}

static PassRefPtr<WebArchiveAndroid> createArchiveForError()
{
    /* When an archive cannot be loaded, we return an empty archive instead. */
    PassRefPtr<ArchiveResource> mainResource = ArchiveResource::create(
        SharedBuffer::create(), KURL(ParsedURLString, String::fromUTF8("file:///dummy")),
        String::fromUTF8("text/plain"), String(""), String(""));
    Vector<PassRefPtr<ArchiveResource> > subresources;
    Vector<PassRefPtr<Archive> > subframes;

    return WebArchiveAndroid::create(mainResource, subresources, subframes);
}

PassRefPtr<WebArchiveAndroid> WebArchiveAndroid::create(SharedBuffer* buffer)
{
    const char* const noBaseUrl = "";
    const char* const defaultEncoding = 0;
    const int noParserOptions = 0;

    xmlDocPtr doc = xmlReadMemory(buffer->data(), buffer->size(), noBaseUrl, defaultEncoding, noParserOptions);
    if (!doc) {
        ALOGD("create: Failed to parse document.");
        return createArchiveForError();
    }

    xmlNodePtr root = xmlDocGetRootElement(doc);
    if (!root) {
        ALOGD("create: Empty document.");
        xmlFreeDoc(doc);
        return createArchiveForError();
    }

    RefPtr<WebArchiveAndroid> archive = loadArchive(root);
    if (!archive) {
        ALOGD("create: Failed to load archive.");
        xmlFreeDoc(doc);
        return createArchiveForError();
    }

    xmlFreeDoc(doc);
    return archive.release();
}

static bool saveArchiveResourceField(xmlTextWriterPtr writer, const xmlChar* tag, const char* data, int size)
{
    int result = xmlTextWriterStartElement(writer, tag);
    if (result < 0) {
        ALOGD("saveArchiveResourceField: Failed to start element.");
        return false;
    }

    if (size > 0) {
        Vector<char> base64Data;
        base64Encode(data, size, base64Data, false);
        if (base64Data.isEmpty()) {
            ALOGD("saveArchiveResourceField: Failed to base64 encode data.");
            return false;
        }

        result = xmlTextWriterWriteRawLen(writer, BAD_CAST base64Data.data(), base64Data.size());
        if (result < 0) {
            ALOGD("saveArchiveResourceField: Failed to write data.");
            return false;
        }
    }

    result = xmlTextWriterEndElement(writer);
    if (result < 0) {
        ALOGD("saveArchiveResourceField: Failed to end element.");
        return false;
    }

    return true;
}

static bool saveArchiveResourceField(xmlTextWriterPtr writer, const xmlChar* tag, SharedBuffer* buffer)
{
    return saveArchiveResourceField(writer, tag, buffer->data(), buffer->size());
}

static bool saveArchiveResourceField(xmlTextWriterPtr writer, const xmlChar* tag, const String& string)
{
    CString utf8String = string.utf8();

    return saveArchiveResourceField(writer, tag, utf8String.data(), utf8String.length());
}

static bool saveArchiveResource(xmlTextWriterPtr writer, PassRefPtr<ArchiveResource> resource)
{
    int result = xmlTextWriterStartElement(writer, archiveResourceTag);
    if (result < 0) {
        ALOGD("saveArchiveResource: Failed to start element.");
        return false;
    }

    if (!saveArchiveResourceField(writer, urlFieldTag, resource->url().string())
        || !saveArchiveResourceField(writer, mimeFieldTag, resource->mimeType())
        || !saveArchiveResourceField(writer, encodingFieldTag, resource->textEncoding())
        || !saveArchiveResourceField(writer, frameFieldTag, resource->frameName())
        || !saveArchiveResourceField(writer, dataFieldTag, resource->data()))
        return false;

    result = xmlTextWriterEndElement(writer);
    if (result < 0) {
        ALOGD("saveArchiveResource: Failed to end element.");
        return false;
    }

    return true;
}

static bool saveArchive(xmlTextWriterPtr writer, PassRefPtr<Archive> archive)
{
    int result = xmlTextWriterStartElement(writer, archiveTag);
    if (result < 0) {
        ALOGD("saveArchive: Failed to start element.");
        return false;
    }

    result = xmlTextWriterStartElement(writer, mainResourceTag);
    if (result < 0) {
        ALOGD("saveArchive: Failed to start element.");
        return false;
    }

    if (!saveArchiveResource(writer, archive->mainResource()))
        return false;

    result = xmlTextWriterEndElement(writer);
    if (result < 0) {
        ALOGD("saveArchive: Failed to end element.");
        return false;
    }

    result = xmlTextWriterStartElement(writer, subresourcesTag);
    if (result < 0) {
        ALOGD("saveArchive: Failed to start element.");
        return false;
    }

    for (Vector<const RefPtr<ArchiveResource> >::iterator subresource = archive->subresources().begin();
         subresource != archive->subresources().end();
         subresource++) {
        if (!saveArchiveResource(writer, *subresource))
            return false;
    }

    result = xmlTextWriterEndElement(writer);
    if (result < 0) {
        ALOGD("saveArchive: Failed to end element.");
        return false;
    }

    result = xmlTextWriterStartElement(writer, subframesTag);
    if (result < 0) {
        ALOGD("saveArchive: Failed to start element.");
        return false;
    }

    for (Vector<const RefPtr<Archive> >::iterator subframe = archive->subframeArchives().begin();
            subframe != archive->subframeArchives().end();
            subframe++) {
        if (!saveArchive(writer, *subframe))
            return false;
    }

    result = xmlTextWriterEndElement(writer);
    if (result < 0) {
        ALOGD("saveArchive: Failed to end element.");
        return true;
    }

    return true;
}

bool WebArchiveAndroid::saveWebArchive(xmlTextWriterPtr writer)
{
    const char* const defaultXmlVersion = 0;
    const char* const defaultEncoding = 0;
    const char* const defaultStandalone = 0;

    int result = xmlTextWriterStartDocument(writer, defaultXmlVersion, defaultEncoding, defaultStandalone);
    if (result < 0) {
        ALOGD("saveWebArchive: Failed to start document.");
        return false;
    }

    if (!saveArchive(writer, this))
        return false;

    result = xmlTextWriterEndDocument(writer);
    if (result< 0) {
        ALOGD("saveWebArchive: Failed to end document.");
        return false;
    }

    return true;
}

}

#endif // ENABLE(WEB_ARCHIVE)