2008-05-14 Julien Chaffraix <jchaffraix@webkit.org>
[WebKit-https.git] / WebCore / plugins / PluginView.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "PluginView.h"
29
30 #include "Document.h"
31 #include "DocumentLoader.h"
32 #include "Element.h"
33 #include "EventNames.h"
34 #include "FrameLoader.h"
35 #include "FrameTree.h"
36 #include "Frame.h"
37 #include "FrameView.h"
38 #include "GraphicsContext.h"
39 #include "Image.h"
40 #include "HTMLNames.h"
41 #include "HTMLPlugInElement.h"
42 #include "JSDOMWindow.h"
43 #include "KeyboardEvent.h"
44 #include "MIMETypeRegistry.h"
45 #include "MouseEvent.h"
46 #include "NotImplemented.h"
47 #include "Page.h"
48 #include "FocusController.h"
49 #include "PlatformMouseEvent.h"
50 #if PLATFORM(WIN)
51 #include "PluginMessageThrottlerWin.h"
52 #endif
53 #include "PluginPackage.h"
54 #include "kjs_binding.h"
55 #include "kjs_proxy.h"
56 #include "PluginDatabase.h"
57 #include "PluginDebug.h"
58 #include "PluginPackage.h"
59 #include "c_instance.h"
60 #include "npruntime_impl.h"
61 #include "runtime_root.h"
62 #include "Settings.h"
63 #include "runtime.h"
64 #include <kjs/JSLock.h>
65 #include <kjs/value.h>
66 #include <wtf/ASCIICType.h>
67
68 using KJS::ExecState;
69 using KJS::JSLock;
70 using KJS::JSObject;
71 using KJS::JSValue;
72 using KJS::UString;
73
74 using std::min;
75
76 using namespace WTF;
77
78 namespace WebCore {
79
80 using namespace EventNames;
81 using namespace HTMLNames;
82
83 static int s_callingPlugin;
84
85 static String scriptStringIfJavaScriptURL(const KURL& url)
86 {
87     if (!url.protocolIs("javascript"))
88         return String();
89
90     // This returns an unescaped string
91     return decodeURLEscapeSequences(url.string().substring(11));
92 }
93
94 PluginView* PluginView::s_currentPluginView = 0;
95
96 void PluginView::popPopupsStateTimerFired(Timer<PluginView>*)
97 {
98     popPopupsEnabledState();
99 }
100
101 IntRect PluginView::windowClipRect() const
102 {
103     // Start by clipping to our bounds.
104     IntRect clipRect(m_windowRect);
105     
106     // Take our element and get the clip rect from the enclosing layer and frame view.
107     RenderLayer* layer = m_element->renderer()->enclosingLayer();
108     FrameView* parentView = m_element->document()->view();
109     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
110
111     return clipRect;
112 }
113
114 void PluginView::setFrameGeometry(const IntRect& rect)
115 {
116     if (m_element->document()->printing())
117         return;
118
119     if (rect != frameGeometry())
120         Widget::setFrameGeometry(rect);
121
122     updateWindow();
123
124 #if PLATFORM(WIN)
125     setNPWindowRect(rect);
126 #endif
127 }
128
129 void PluginView::geometryChanged() const
130 {
131     updateWindow();
132 }
133
134 void PluginView::handleEvent(Event* event)
135 {
136     if (!m_plugin || m_isWindowed)
137         return;
138
139     if (event->isMouseEvent())
140         handleMouseEvent(static_cast<MouseEvent*>(event));
141     else if (event->isKeyboardEvent())
142         handleKeyboardEvent(static_cast<KeyboardEvent*>(event));
143 }
144
145 bool PluginView::start()
146 {
147     if (m_isStarted)
148         return false;
149
150     ASSERT(m_plugin);
151     ASSERT(m_plugin->pluginFuncs()->newp);
152
153     NPError npErr;
154     PluginView::setCurrentPluginView(this);
155     {
156         KJS::JSLock::DropAllLocks dropAllLocks;
157         setCallingPlugin(true);
158         npErr = m_plugin->pluginFuncs()->newp((NPMIMEType)m_mimeType.data(), m_instance, m_mode, m_paramCount, m_paramNames, m_paramValues, NULL);
159         setCallingPlugin(false);
160         LOG_NPERROR(npErr);
161     }
162     PluginView::setCurrentPluginView(0);
163
164     if (npErr != NPERR_NO_ERROR)
165         return false;
166
167     m_isStarted = true;
168
169     if (!m_url.isEmpty() && !m_loadManually) {
170         FrameLoadRequest frameLoadRequest;
171         frameLoadRequest.resourceRequest().setHTTPMethod("GET");
172         frameLoadRequest.resourceRequest().setURL(m_url);
173         load(frameLoadRequest, false, 0);
174     }
175
176     return true;
177 }
178
179 void PluginView::setCurrentPluginView(PluginView* pluginView)
180 {
181     s_currentPluginView = pluginView;
182 }
183
184 PluginView* PluginView::currentPluginView()
185 {
186     return s_currentPluginView;
187 }
188
189 static char* createUTF8String(const String& str)
190 {
191     CString cstr = str.utf8();
192     char* result = reinterpret_cast<char*>(fastMalloc(cstr.length() + 1));
193
194     strncpy(result, cstr.data(), cstr.length() + 1);
195
196     return result;
197 }
198
199 static bool getString(KJSProxy* proxy, JSValue* result, String& string)
200 {
201     if (!proxy || !result || result->isUndefined())
202         return false;
203     JSLock lock;
204
205     ExecState* exec = proxy->globalObject()->globalExec();
206     UString ustring = result->toString(exec);
207     exec->clearException();
208
209     string = ustring;
210     return true;
211 }
212
213 void PluginView::performRequest(PluginRequest* request)
214 {
215     // don't let a plugin start any loads if it is no longer part of a document that is being 
216     // displayed unless the loads are in the same frame as the plugin.
217     const String& targetFrameName = request->frameLoadRequest().frameName();
218     if (m_parentFrame->loader()->documentLoader() != m_parentFrame->loader()->activeDocumentLoader() &&
219         (targetFrameName.isNull() || m_parentFrame->tree()->find(targetFrameName) != m_parentFrame))
220         return;
221
222     KURL requestURL = request->frameLoadRequest().resourceRequest().url();
223     String jsString = scriptStringIfJavaScriptURL(requestURL);
224
225     if (jsString.isNull()) {
226         // if this is not a targeted request, create a stream for it. otherwise,
227         // just pass it off to the loader
228         if (targetFrameName.isEmpty()) {
229             PluginStream* stream = new PluginStream(this, m_parentFrame, request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData(), plugin()->pluginFuncs(), instance(), m_plugin->quirks());
230             m_streams.add(stream);
231             stream->start();
232         } else {
233             m_parentFrame->loader()->load(request->frameLoadRequest().resourceRequest(), targetFrameName);
234       
235             // FIXME: <rdar://problem/4807469> This should be sent when the document has finished loading
236             if (request->sendNotification()) {
237                 KJS::JSLock::DropAllLocks dropAllLocks;
238                 setCallingPlugin(true);
239                 m_plugin->pluginFuncs()->urlnotify(m_instance, requestURL.string().utf8().data(), NPRES_DONE, request->notifyData());
240                 setCallingPlugin(false);
241             }
242         }
243         return;
244     }
245
246     // Targeted JavaScript requests are only allowed on the frame that contains the JavaScript plugin
247     // and this has been made sure in ::load.
248     ASSERT(targetFrameName.isEmpty() || m_parentFrame->tree()->find(targetFrameName) == m_parentFrame);
249     
250     // Executing a script can cause the plugin view to be destroyed, so we keep a reference to the parent frame.
251     RefPtr<Frame> parentFrame = m_parentFrame;
252     JSValue* result = m_parentFrame->loader()->executeScript(jsString, request->shouldAllowPopups());
253
254     if (targetFrameName.isNull()) {
255         String resultString;
256
257         CString cstr;
258         if (getString(parentFrame->scriptProxy(), result, resultString))
259             cstr = resultString.utf8();
260
261         RefPtr<PluginStream> stream = new PluginStream(this, m_parentFrame, request->frameLoadRequest().resourceRequest(), request->sendNotification(), request->notifyData(), plugin()->pluginFuncs(), instance(), m_plugin->quirks());
262         m_streams.add(stream);
263         stream->sendJavaScriptStream(requestURL, cstr);
264     }
265 }
266
267 void PluginView::requestTimerFired(Timer<PluginView>* timer)
268 {
269     ASSERT(timer == &m_requestTimer);
270     ASSERT(m_requests.size() > 0);
271     ASSERT(!m_isJavaScriptPaused);
272
273     PluginRequest* request = m_requests[0];
274     m_requests.remove(0);
275     
276     // Schedule a new request before calling performRequest since the call to
277     // performRequest can cause the plugin view to be deleted.
278     if (m_requests.size() > 0)
279         m_requestTimer.startOneShot(0);
280
281     performRequest(request);
282     delete request;
283 }
284
285 void PluginView::scheduleRequest(PluginRequest* request)
286 {
287     m_requests.append(request);
288
289     if (!m_isJavaScriptPaused)
290         m_requestTimer.startOneShot(0);
291 }
292
293 NPError PluginView::load(const FrameLoadRequest& frameLoadRequest, bool sendNotification, void* notifyData)
294 {
295     ASSERT(frameLoadRequest.resourceRequest().httpMethod() == "GET" || frameLoadRequest.resourceRequest().httpMethod() == "POST");
296
297     KURL url = frameLoadRequest.resourceRequest().url();
298     
299     if (url.isEmpty())
300         return NPERR_INVALID_URL;
301
302     const String& targetFrameName = frameLoadRequest.frameName();
303     String jsString = scriptStringIfJavaScriptURL(url);
304
305     if (!jsString.isNull()) {
306         Settings* settings = m_parentFrame->settings();
307         if (!settings || !settings->isJavaScriptEnabled()) {
308             // Return NPERR_GENERIC_ERROR if JS is disabled. This is what Mozilla does.
309             return NPERR_GENERIC_ERROR;
310         } 
311         
312         if (!targetFrameName.isNull() && m_parentFrame->tree()->find(targetFrameName) != m_parentFrame) {
313             // For security reasons, only allow JS requests to be made on the frame that contains the plug-in.
314             return NPERR_INVALID_PARAM;
315         }
316     }
317
318     PluginRequest* request = new PluginRequest(frameLoadRequest, sendNotification, notifyData, arePopupsAllowed());
319     scheduleRequest(request);
320
321     return NPERR_NO_ERROR;
322 }
323
324 static KURL makeURL(const KURL& baseURL, const char* relativeURLString)
325 {
326     String urlString = relativeURLString;
327
328     // Strip return characters.
329     urlString.replace('\n', "");
330     urlString.replace('\r', "");
331
332     return KURL(baseURL, urlString);
333 }
334
335 NPError PluginView::getURLNotify(const char* url, const char* target, void* notifyData)
336 {
337     FrameLoadRequest frameLoadRequest;
338
339     frameLoadRequest.setFrameName(target);
340     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
341     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
342
343     return load(frameLoadRequest, true, notifyData);
344 }
345
346 NPError PluginView::getURL(const char* url, const char* target)
347 {
348     FrameLoadRequest frameLoadRequest;
349
350     frameLoadRequest.setFrameName(target);
351     frameLoadRequest.resourceRequest().setHTTPMethod("GET");
352     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
353
354     return load(frameLoadRequest, false, 0);
355 }
356
357 NPError PluginView::postURLNotify(const char* url, const char* target, uint32 len, const char* buf, NPBool file, void* notifyData)
358 {
359     return handlePost(url, target, len, buf, file, notifyData, true, true);
360 }
361
362 NPError PluginView::postURL(const char* url, const char* target, uint32 len, const char* buf, NPBool file)
363 {
364     // As documented, only allow headers to be specified via NPP_PostURL when using a file.
365     return handlePost(url, target, len, buf, file, 0, false, file);
366 }
367
368 NPError PluginView::newStream(NPMIMEType type, const char* target, NPStream** stream)
369 {
370     notImplemented();
371     // Unsupported
372     return NPERR_GENERIC_ERROR;
373 }
374
375 int32 PluginView::write(NPStream* stream, int32 len, void* buffer)
376 {
377     notImplemented();
378     // Unsupported
379     return -1;
380 }
381
382 NPError PluginView::destroyStream(NPStream* stream, NPReason reason)
383 {
384     PluginStream* browserStream = static_cast<PluginStream*>(stream->ndata);
385
386     if (!stream || PluginStream::ownerForStream(stream) != m_instance)
387         return NPERR_INVALID_INSTANCE_ERROR;
388
389     browserStream->cancelAndDestroyStream(reason);
390     return NPERR_NO_ERROR;
391 }
392
393 void PluginView::status(const char* message)
394 {
395     if (Page* page = m_parentFrame->page())
396         page->chrome()->setStatusbarText(m_parentFrame, String(message));
397 }
398
399 NPError PluginView::setValue(NPPVariable variable, void* value)
400 {
401     switch (variable) {
402         case NPPVpluginWindowBool:
403             m_isWindowed = value;
404             return NPERR_NO_ERROR;
405         case NPPVpluginTransparentBool:
406             m_isTransparent = value;
407             return NPERR_NO_ERROR;
408         default:
409             notImplemented();
410             return NPERR_GENERIC_ERROR;
411     }
412 }
413
414 void PluginView::invalidateTimerFired(Timer<PluginView>* timer)
415 {
416     ASSERT(timer == &m_invalidateTimer);
417
418     for (unsigned i = 0; i < m_invalidRects.size(); i++)
419         Widget::invalidateRect(m_invalidRects[i]);
420     m_invalidRects.clear();
421 }
422
423
424 void PluginView::pushPopupsEnabledState(bool state)
425 {
426     m_popupStateStack.append(state);
427 }
428  
429 void PluginView::popPopupsEnabledState()
430 {
431     m_popupStateStack.removeLast();
432 }
433
434 bool PluginView::arePopupsAllowed() const
435 {
436     if (!m_popupStateStack.isEmpty())
437         return m_popupStateStack.last();
438
439     return false;
440 }
441
442 void PluginView::setJavaScriptPaused(bool paused)
443 {
444     if (m_isJavaScriptPaused == paused)
445         return;
446     m_isJavaScriptPaused = paused;
447
448     if (m_isJavaScriptPaused)
449         m_requestTimer.stop();
450     else if (!m_requests.isEmpty())
451         m_requestTimer.startOneShot(0);
452 }
453
454 PassRefPtr<KJS::Bindings::Instance> PluginView::bindingInstance()
455 {
456 #if ENABLE(NETSCAPE_PLUGIN_API)
457     NPObject* object = 0;
458
459     if (!m_plugin || !m_plugin->pluginFuncs()->getvalue)
460         return 0;
461
462     NPError npErr;
463     {
464         KJS::JSLock::DropAllLocks dropAllLocks;
465         setCallingPlugin(true);
466         npErr = m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginScriptableNPObject, &object);
467         setCallingPlugin(false);
468     }
469
470     if (npErr != NPERR_NO_ERROR || !object)
471         return 0;
472
473     RefPtr<KJS::Bindings::RootObject> root = m_parentFrame->createRootObject(this, m_parentFrame->scriptProxy()->globalObject());
474     RefPtr<KJS::Bindings::Instance> instance = KJS::Bindings::CInstance::create(object, root.release());
475
476     _NPN_ReleaseObject(object);
477
478     return instance.release();
479 #else
480     return 0;
481 #endif
482 }
483
484 void PluginView::disconnectStream(PluginStream* stream)
485 {
486     ASSERT(m_streams.contains(stream));
487
488     m_streams.remove(stream);
489 }
490
491 void PluginView::setParameters(const Vector<String>& paramNames, const Vector<String>& paramValues)
492 {
493     ASSERT(paramNames.size() == paramValues.size());
494
495     unsigned size = paramNames.size();
496     unsigned paramCount = 0;
497
498     m_paramNames = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
499     m_paramValues = reinterpret_cast<char**>(fastMalloc(sizeof(char*) * size));
500
501     for (unsigned i = 0; i < size; i++) {
502         if (m_plugin->quirks().contains(PluginQuirkRemoveWindowlessVideoParam) && equalIgnoringCase(paramNames[i], "windowlessvideo"))
503             continue;
504
505         m_paramNames[paramCount] = createUTF8String(paramNames[i]);
506         m_paramValues[paramCount] = createUTF8String(paramValues[i]);
507
508         paramCount++;
509     }
510
511     m_paramCount = paramCount;
512 }
513
514 PluginView::PluginView(Frame* parentFrame, const IntSize& size, PluginPackage* plugin, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
515     : m_parentFrame(parentFrame)
516     , m_plugin(plugin)
517     , m_element(element)
518     , m_isStarted(false)
519     , m_url(url)
520     , m_baseURL(m_parentFrame->loader()->completeURL(m_parentFrame->document()->baseURL().string()))
521     , m_status(PluginStatusLoadedSuccessfully)
522     , m_requestTimer(this, &PluginView::requestTimerFired)
523     , m_invalidateTimer(this, &PluginView::invalidateTimerFired)
524     , m_popPopupsStateTimer(this, &PluginView::popPopupsStateTimerFired)
525     , m_paramNames(0)
526     , m_paramValues(0)
527     , m_isWindowed(true)
528     , m_isTransparent(false)
529     , m_isVisible(false)
530     , m_attachedToWindow(false)
531     , m_haveInitialized(false)
532 #if PLATFORM(GTK) || defined(Q_WS_X11)
533     , m_needsXEmbed(false)
534 #endif
535 #if PLATFORM(WIN)
536     , m_pluginWndProc(0)
537     , m_lastMessage(0)
538     , m_isCallingPluginWndProc(false)
539 #endif
540     , m_window(0)
541     , m_loadManually(loadManually)
542     , m_manualStream(0)
543     , m_isJavaScriptPaused(false)
544 {
545     if (!m_plugin) {
546         m_status = PluginStatusCanNotFindPlugin;
547         return;
548     }
549
550     m_instance = &m_instanceStruct;
551     m_instance->ndata = this;
552
553     m_mimeType = mimeType.utf8();
554
555     setParameters(paramNames, paramValues);
556
557 #ifdef XP_UNIX
558     m_npWindow.ws_info = 0;
559 #endif
560
561     m_mode = m_loadManually ? NP_FULL : NP_EMBED;
562
563     resize(size);
564 }
565
566 void PluginView::didReceiveResponse(const ResourceResponse& response)
567 {
568     ASSERT(m_loadManually);
569     ASSERT(!m_manualStream);
570
571     m_manualStream = new PluginStream(this, m_parentFrame, m_parentFrame->loader()->activeDocumentLoader()->request(), false, 0, plugin()->pluginFuncs(), instance(), m_plugin->quirks());
572     m_manualStream->setLoadManually(true);
573
574     m_manualStream->didReceiveResponse(0, response);
575 }
576
577 void PluginView::didReceiveData(const char* data, int length)
578 {
579     ASSERT(m_loadManually);
580     ASSERT(m_manualStream);
581     
582     m_manualStream->didReceiveData(0, data, length);
583 }
584
585 void PluginView::didFinishLoading()
586 {
587     ASSERT(m_loadManually);
588     ASSERT(m_manualStream);
589
590     m_manualStream->didFinishLoading(0);
591 }
592
593 void PluginView::didFail(const ResourceError& error)
594 {
595     ASSERT(m_loadManually);
596     ASSERT(m_manualStream);
597
598     m_manualStream->didFail(0, error);
599 }
600
601 void PluginView::setCallingPlugin(bool b) const
602 {
603     if (!m_plugin->quirks().contains(PluginQuirkHasModalMessageLoop))
604         return;
605
606     if (b)
607         ++s_callingPlugin;
608     else
609         --s_callingPlugin;
610
611     ASSERT(s_callingPlugin >= 0);
612 }
613
614 bool PluginView::isCallingPlugin()
615 {
616     return s_callingPlugin > 0;
617 }
618
619 PluginView* PluginView::create(Frame* parentFrame, const IntSize& size, Element* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
620 {
621     // if we fail to find a plugin for this MIME type, findPlugin will search for
622     // a plugin by the file extension and update the MIME type, so pass a mutable String
623     String mimeTypeCopy = mimeType;
624     PluginPackage* plugin = PluginDatabase::installedPlugins()->findPlugin(url, mimeTypeCopy);
625
626     // No plugin was found, try refreshing the database and searching again
627     if (!plugin && PluginDatabase::installedPlugins()->refresh()) {
628         mimeTypeCopy = mimeType;
629         plugin = PluginDatabase::installedPlugins()->findPlugin(url, mimeTypeCopy);
630     }
631
632     return new PluginView(parentFrame, size, plugin, element, url, paramNames, paramValues, mimeTypeCopy, loadManually);
633 }
634
635 void PluginView::freeStringArray(char** stringArray, int length)
636 {
637     if (!stringArray)
638         return;
639
640     for (int i = 0; i < length; i++)
641         fastFree(stringArray[i]);
642
643     fastFree(stringArray);
644 }
645
646 static inline bool startsWithBlankLine(const Vector<char>& buffer)
647 {
648     return buffer.size() > 0 && buffer[0] == '\n';
649 }
650
651 static inline int locationAfterFirstBlankLine(const Vector<char>& buffer)
652 {
653     const char* bytes = buffer.data();
654     unsigned length = buffer.size();
655
656     for (unsigned i = 0; i < length - 4; i++) {
657         // Support for Acrobat. It sends "\n\n".
658         if (bytes[i] == '\n' && bytes[i + 1] == '\n')
659             return i + 2;
660         
661         // Returns the position after 2 CRLF's or 1 CRLF if it is the first line.
662         if (bytes[i] == '\r' && bytes[i + 1] == '\n') {
663             i += 2;
664             if (i == 2)
665                 return i;
666             else if (bytes[i] == '\n')
667                 // Support for Director. It sends "\r\n\n" (3880387).
668                 return i + 1;
669             else if (bytes[i] == '\r' && bytes[i + 1] == '\n')
670                 // Support for Flash. It sends "\r\n\r\n" (3758113).
671                 return i + 2;
672         }
673     }
674
675     return -1;
676 }
677
678 static inline const char* findEOL(const char* bytes, unsigned length)
679 {
680     // According to the HTTP specification EOL is defined as
681     // a CRLF pair. Unfortunately, some servers will use LF
682     // instead. Worse yet, some servers will use a combination
683     // of both (e.g. <header>CRLFLF<body>), so findEOL needs
684     // to be more forgiving. It will now accept CRLF, LF or
685     // CR.
686     //
687     // It returns NULL if EOLF is not found or it will return
688     // a pointer to the first terminating character.
689     for (unsigned i = 0; i < length; i++) {
690         if (bytes[i] == '\n')
691             return bytes + i;
692         if (bytes[i] == '\r') {
693             // Check to see if spanning buffer bounds
694             // (CRLF is across reads). If so, wait for
695             // next read.
696             if (i + 1 == length)
697                 break;
698
699             return bytes + i;
700         }
701     }
702
703     return 0;
704 }
705
706 static inline String capitalizeRFC822HeaderFieldName(const String& name)
707 {
708     bool capitalizeCharacter = true;
709     String result;
710
711     for (unsigned i = 0; i < name.length(); i++) {
712         UChar c;
713
714         if (capitalizeCharacter && name[i] >= 'a' && name[i] <= 'z')
715             c = toASCIIUpper(name[i]);
716         else if (!capitalizeCharacter && name[i] >= 'A' && name[i] <= 'Z')
717             c = toASCIILower(name[i]);
718         else
719             c = name[i];
720
721         if (name[i] == '-')
722             capitalizeCharacter = true;
723         else
724             capitalizeCharacter = false;
725
726         result.append(c);
727     }
728
729     return result;
730 }
731
732 static inline HTTPHeaderMap parseRFC822HeaderFields(const Vector<char>& buffer, unsigned length)
733 {
734     const char* bytes = buffer.data();
735     const char* eol;
736     String lastKey;
737     HTTPHeaderMap headerFields;
738
739     // Loop ove rlines until we're past the header, or we can't find any more end-of-lines
740     while ((eol = findEOL(bytes, length))) {
741         const char* line = bytes;
742         int lineLength = eol - bytes;
743         
744         // Move bytes to the character after the terminator as returned by findEOL.
745         bytes = eol + 1;
746         if ((*eol == '\r') && (*bytes == '\n'))
747             bytes++; // Safe since findEOL won't return a spanning CRLF.
748
749         length -= (bytes - line);
750         if (lineLength == 0)
751             // Blank line; we're at the end of the header
752             break;
753         else if (*line == ' ' || *line == '\t') {
754             // Continuation of the previous header
755             if (lastKey.isNull()) {
756                 // malformed header; ignore it and continue
757                 continue;
758             } else {
759                 // Merge the continuation of the previous header
760                 String currentValue = headerFields.get(lastKey);
761                 String newValue(line, lineLength);
762
763                 headerFields.set(lastKey, currentValue + newValue);
764             }
765         } else {
766             // Brand new header
767             const char* colon;
768             for (colon = line; *colon != ':' && colon != eol; colon++) {
769                 // empty loop
770             }
771             if (colon == eol) 
772                 // malformed header; ignore it and continue
773                 continue;
774             else {
775                 lastKey = capitalizeRFC822HeaderFieldName(String(line, colon - line));
776                 String value;
777
778                 for (colon++; colon != eol; colon++) {
779                     if (*colon != ' ' && *colon != '\t')
780                         break;
781                 }
782                 if (colon == eol)
783                     value = "";
784                 else
785                     value = String(colon, eol - colon);
786
787                 String oldValue = headerFields.get(lastKey);
788                 if (!oldValue.isNull()) {
789                     String tmp = oldValue;
790                     tmp += ", ";
791                     tmp += value;
792                     value = tmp;
793                 }
794
795                 headerFields.set(lastKey, value);
796             }
797         }
798     }
799
800     return headerFields;
801 }
802
803 NPError PluginView::handlePost(const char* url, const char* target, uint32 len, const char* buf, bool file, void* notifyData, bool sendNotification, bool allowHeaders)
804 {
805     if (!url || !len || !buf)
806         return NPERR_INVALID_PARAM;
807
808     FrameLoadRequest frameLoadRequest;
809
810     HTTPHeaderMap headerFields;
811     Vector<char> buffer;
812     
813     if (file) {
814         NPError readResult = handlePostReadFile(buffer, len, buf);
815         if(readResult != NPERR_NO_ERROR)
816             return readResult;
817     } else {
818         buffer.resize(len);
819         memcpy(buffer.data(), buf, len);
820     }
821
822     const char* postData = buffer.data();
823     int postDataLength = buffer.size();
824
825     if (allowHeaders) {
826         if (startsWithBlankLine(buffer)) {
827             postData++;
828             postDataLength--;
829         } else {
830             int location = locationAfterFirstBlankLine(buffer);
831             if (location != -1) {
832                 // If the blank line is somewhere in the middle of the buffer, everything before is the header
833                 headerFields = parseRFC822HeaderFields(buffer, location);
834                 unsigned dataLength = buffer.size() - location;
835
836                 // Sometimes plugins like to set Content-Length themselves when they post,
837                 // but WebFoundation does not like that. So we will remove the header
838                 // and instead truncate the data to the requested length.
839                 String contentLength = headerFields.get("Content-Length");
840
841                 if (!contentLength.isNull())
842                     dataLength = min(contentLength.toInt(), (int)dataLength);
843                 headerFields.remove("Content-Length");
844
845                 postData += location;
846                 postDataLength = dataLength;
847             }
848         }
849     }
850
851     frameLoadRequest.resourceRequest().setHTTPMethod("POST");
852     frameLoadRequest.resourceRequest().setURL(makeURL(m_baseURL, url));
853     frameLoadRequest.resourceRequest().addHTTPHeaderFields(headerFields);
854     frameLoadRequest.resourceRequest().setHTTPBody(FormData::create(postData, postDataLength));
855     frameLoadRequest.setFrameName(target);
856
857     return load(frameLoadRequest, sendNotification, notifyData);
858 }
859
860 } // namespace WebCore