2011-05-24 Jay Civelli <jcivelli@chromium.org>
[WebKit-https.git] / Source / WebCore / loader / archive / mhtml / MHTMLParser.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #if ENABLE(MHTML)
34 #include "MHTMLParser.h"
35
36 #include "Base64.h"
37 #include "MHTMLArchive.h"
38 #include "MIMEHeader.h"
39 #include "MIMETypeRegistry.h"
40 #include "QuotedPrintable.h"
41 #include <wtf/HashMap.h>
42 #include <wtf/NotFound.h>
43
44 namespace WebCore {
45
46 static bool skipLinesUntilBoundaryFound(SharedBufferCRLFLineReader& lineReader, const String& boundary)
47 {
48     String line;
49     while (!(line = lineReader.nextLine()).isNull()) {
50         if (line == boundary)
51             return true;
52     }
53     return false;
54 }
55
56 MHTMLParser::MHTMLParser(SharedBuffer* data)
57     : m_lineReader(data)
58 {
59 }
60
61 PassRefPtr<MHTMLArchive> MHTMLParser::parseArchive()
62 {
63     RefPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
64     return parseArchiveWithHeader(header.get());
65 }
66
67 PassRefPtr<MHTMLArchive> MHTMLParser::parseArchiveWithHeader(MIMEHeader* header)
68 {
69     if (!header) {
70         LOG_ERROR("Failed to parse MHTML part: no header.");
71         return 0;
72     }
73
74     RefPtr<MHTMLArchive> archive = MHTMLArchive::create();
75     if (!header->isMultipart()) {
76         // With IE a page with no resource is not multi-part.
77         bool endOfArchiveReached = false;
78         RefPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
79         if (!resource)
80             return 0;
81         archive->setMainResource(resource);
82         return archive;
83     }
84
85     // Skip the message content (it's a generic browser specific message).
86     skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
87
88     bool endOfArchive = false;
89     while (!endOfArchive) {
90         RefPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
91         if (!resourceHeader) {
92             LOG_ERROR("Failed to parse MHTML, invalid MIME header.");
93             return 0;
94         }
95         if (resourceHeader->contentType() == "multipart/alternative") {
96             // Ignore IE nesting which makes little sense (IE seems to nest only some of the frames).
97             RefPtr<MHTMLArchive> subframeArchive = parseArchiveWithHeader(resourceHeader.get());
98             if (!subframeArchive) {
99                 LOG_ERROR("Failed to parse MHTML subframe.");
100                 return 0;
101             }
102             bool endOfPartReached = skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
103             ASSERT_UNUSED(endOfPartReached, endOfPartReached);
104             // The top-frame is the first frame found, regardless of the nesting level.
105             if (subframeArchive->mainResource())
106                 addResourceToArchive(subframeArchive->mainResource(), archive.get());
107             archive->addSubframeArchive(subframeArchive);
108             continue;
109         }
110
111         RefPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
112         if (!resource) {
113             LOG_ERROR("Failed to parse MHTML part.");
114             return 0;
115         }
116         addResourceToArchive(resource.get(), archive.get());
117     }
118
119     return archive.release();
120 }
121
122 void MHTMLParser::addResourceToArchive(ArchiveResource* resource, MHTMLArchive* archive)
123 {
124     const String& mimeType = resource->mimeType();
125     if (!MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType) || MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType) || mimeType == "text/css") {
126         m_resources.append(resource);
127         return;
128     }
129
130     // The first document suitable resource is the main frame.
131     if (!archive->mainResource()) {
132         archive->setMainResource(resource);
133         m_frames.append(archive);
134         return;
135     }
136
137     RefPtr<MHTMLArchive> subframe = MHTMLArchive::create();
138     subframe->setMainResource(resource);
139     m_frames.append(subframe);
140 }
141
142 PassRefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader, const String& endOfPartBoundary, const String& endOfDocumentBoundary, bool& endOfArchiveReached)
143 {
144     ASSERT(endOfPartBoundary.isEmpty() == endOfDocumentBoundary.isEmpty());
145
146     RefPtr<SharedBuffer> content = SharedBuffer::create();
147     const bool checkBoundary = !endOfPartBoundary.isEmpty();
148     bool endOfPartReached = false;
149     String line;
150     while (!(line = m_lineReader.nextLine()).isNull()) {
151         if (checkBoundary && (line == endOfPartBoundary || line == endOfDocumentBoundary)) {
152             endOfArchiveReached = (line == endOfDocumentBoundary);
153             endOfPartReached = true;
154             break;
155         }
156         // Note that we use line.utf8() and not line.ascii() as ascii turns special characters (such as tab, line-feed...) into '?'.
157         content->append(line.utf8().data(), line.length());
158         if (mimeHeader.contentTransferEncoding() == MIMEHeader::QuotedPrintable) {
159             // The line reader removes the \r\n, but we need them for the content in this case as the QuotedPrintable decoder expects CR-LF terminated lines.
160             content->append("\r\n", 2);
161         }
162     }
163     if (!endOfPartReached && checkBoundary) {
164         LOG_ERROR("No bounday found for MHTML part.");
165         return 0;
166     }
167
168     Vector<char> data;
169     switch (mimeHeader.contentTransferEncoding()) {
170     case MIMEHeader::Base64:
171         if (!base64Decode(content->data(), content->size(), data)) {
172             LOG_ERROR("Invalid base64 content for MHTML part.");
173             return 0;
174         }
175         break;
176     case MIMEHeader::QuotedPrintable:
177         quotedPrintableDecode(content->data(), content->size(), data);
178         break;
179     case MIMEHeader::SevenBit:
180         data.append(content->data(), content->size());
181         break;
182     default:
183         LOG_ERROR("Invalid encoding for MHTML part.");
184         return 0;
185     }
186     RefPtr<SharedBuffer> contentBuffer = SharedBuffer::adoptVector(data);
187     // FIXME: the URL in the MIME header could be relative, we should resolve it if it is.
188     // The specs mentions 5 ways to resolve a URL: http://tools.ietf.org/html/rfc2557#section-5
189     // IE and Firefox (UNMht) seem to generate only absolute URLs.
190     KURL location = KURL(KURL(), mimeHeader.contentLocation());
191     return ArchiveResource::create(contentBuffer, location, mimeHeader.contentType(), mimeHeader.charset(), String());
192 }
193
194 size_t MHTMLParser::frameCount() const
195 {
196     return m_frames.size();
197 }
198
199 MHTMLArchive* MHTMLParser::frameAt(size_t index) const
200 {
201     return m_frames[index].get();
202 }
203
204 size_t MHTMLParser::subResourceCount() const
205 {
206     return m_resources.size();
207 }
208
209 ArchiveResource* MHTMLParser::subResourceAt(size_t index) const
210 {
211     return m_resources[index].get();
212 }
213
214 }
215 #endif