msvcp: Prevent overflows while operating on string sizes.
[wine] / dlls / mshtml / nsevents.c
1 /*
2  * Copyright 2007-2008 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "ole2.h"
29 #include "mshtmcid.h"
30 #include "shlguid.h"
31
32 #include "wine/debug.h"
33
34 #include "mshtml_private.h"
35 #include "htmlevent.h"
36 #include "resource.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
39
40 static const PRUnichar blurW[]      = {'b','l','u','r',0};
41 static const PRUnichar focusW[]     = {'f','o','c','u','s',0};
42 static const PRUnichar keypressW[]  = {'k','e','y','p','r','e','s','s',0};
43 static const PRUnichar loadW[]      = {'l','o','a','d',0};
44
45 typedef struct {
46     nsIDOMEventListener nsIDOMEventListener_iface;
47     nsDocumentEventListener *This;
48 } nsEventListener;
49
50 struct nsDocumentEventListener {
51     nsEventListener blur_listener;
52     nsEventListener focus_listener;
53     nsEventListener keypress_listener;
54     nsEventListener load_listener;
55     nsEventListener htmlevent_listener;
56
57     LONG ref;
58
59     HTMLDocumentNode *doc;
60 };
61
62 static LONG release_listener(nsDocumentEventListener *This)
63 {
64     LONG ref = InterlockedDecrement(&This->ref);
65
66     TRACE("(%p) ref=%d\n", This, ref);
67
68     if(!ref)
69         heap_free(This);
70
71     return ref;
72 }
73
74 static inline nsEventListener *impl_from_nsIDOMEventListener(nsIDOMEventListener *iface)
75 {
76     return CONTAINING_RECORD(iface, nsEventListener, nsIDOMEventListener_iface);
77 }
78
79 static nsresult NSAPI nsDOMEventListener_QueryInterface(nsIDOMEventListener *iface,
80         nsIIDRef riid, void **result)
81 {
82     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
83
84     *result = NULL;
85
86     if(IsEqualGUID(&IID_nsISupports, riid)) {
87         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
88         *result = &This->nsIDOMEventListener_iface;
89     }else if(IsEqualGUID(&IID_nsIDOMEventListener, riid)) {
90         TRACE("(%p)->(IID_nsIDOMEventListener %p)\n", This, result);
91         *result = &This->nsIDOMEventListener_iface;
92     }
93
94     if(*result) {
95         nsIDOMEventListener_AddRef(&This->nsIDOMEventListener_iface);
96         return NS_OK;
97     }
98
99     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
100     return NS_NOINTERFACE;
101 }
102
103 static nsrefcnt NSAPI nsDOMEventListener_AddRef(nsIDOMEventListener *iface)
104 {
105     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
106     LONG ref = InterlockedIncrement(&This->This->ref);
107
108     TRACE("(%p) ref=%d\n", This->This, ref);
109
110     return ref;
111 }
112
113 static nsrefcnt NSAPI nsDOMEventListener_Release(nsIDOMEventListener *iface)
114 {
115     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
116
117     return release_listener(This->This);
118 }
119
120 static BOOL is_doc_child_focus(NSContainer *nscontainer)
121 {
122     HWND hwnd;
123
124     for(hwnd = GetFocus(); hwnd && hwnd != nscontainer->hwnd; hwnd = GetParent(hwnd));
125
126     return hwnd != NULL;
127 }
128
129 static nsresult NSAPI handle_blur(nsIDOMEventListener *iface, nsIDOMEvent *event)
130 {
131     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
132     HTMLDocumentNode *doc = This->This->doc;
133     HTMLDocumentObj *doc_obj;
134
135     TRACE("(%p)\n", doc);
136
137     if(!doc || !doc->basedoc.doc_obj)
138         return NS_ERROR_FAILURE;
139     doc_obj = doc->basedoc.doc_obj;
140
141     if(doc_obj->focus && !is_doc_child_focus(doc_obj->nscontainer)) {
142         doc_obj->focus = FALSE;
143         notif_focus(doc_obj);
144     }
145
146     return NS_OK;
147 }
148
149 static nsresult NSAPI handle_focus(nsIDOMEventListener *iface, nsIDOMEvent *event)
150 {
151     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
152     HTMLDocumentNode *doc = This->This->doc;
153     HTMLDocumentObj *doc_obj;
154
155     TRACE("(%p)\n", doc);
156
157     if(!doc)
158         return NS_ERROR_FAILURE;
159     doc_obj = doc->basedoc.doc_obj;
160
161     if(!doc_obj->focus) {
162         doc_obj->focus = TRUE;
163         notif_focus(doc_obj);
164     }
165
166     return NS_OK;
167 }
168
169 static nsresult NSAPI handle_keypress(nsIDOMEventListener *iface,
170         nsIDOMEvent *event)
171 {
172     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
173     HTMLDocumentNode *doc = This->This->doc;
174     HTMLDocumentObj *doc_obj;
175
176     if(!doc)
177         return NS_ERROR_FAILURE;
178     doc_obj = doc->basedoc.doc_obj;
179
180     TRACE("(%p)->(%p)\n", doc, event);
181
182     update_doc(&doc_obj->basedoc, UPDATE_UI);
183     if(doc_obj->usermode == EDITMODE)
184         handle_edit_event(&doc_obj->basedoc, event);
185
186     return NS_OK;
187 }
188
189 static void handle_docobj_load(HTMLDocumentObj *doc)
190 {
191     IOleCommandTarget *olecmd = NULL;
192     HRESULT hres;
193
194     if(doc->nscontainer->editor_controller) {
195         nsIController_Release(doc->nscontainer->editor_controller);
196         doc->nscontainer->editor_controller = NULL;
197     }
198
199     if(doc->usermode == EDITMODE)
200         handle_edit_load(&doc->basedoc);
201
202     if(doc->client) {
203         hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
204         if(FAILED(hres))
205             olecmd = NULL;
206     }
207
208     if(doc->download_state) {
209         if(olecmd) {
210             VARIANT progress;
211
212             V_VT(&progress) = VT_I4;
213             V_I4(&progress) = 0;
214             IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS,
215                     OLECMDEXECOPT_DONTPROMPTUSER, &progress, NULL);
216         }
217
218         set_download_state(doc, 0);
219     }
220
221     if(olecmd) {
222         IOleCommandTarget_Exec(olecmd, &CGID_ShellDocView, 103, 0, NULL, NULL);
223         IOleCommandTarget_Exec(olecmd, &CGID_MSHTML, IDM_PARSECOMPLETE, 0, NULL, NULL);
224         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_HTTPEQUIV_DONE, 0, NULL, NULL);
225
226         IOleCommandTarget_Release(olecmd);
227     }
228 }
229
230 static nsresult NSAPI handle_load(nsIDOMEventListener *iface, nsIDOMEvent *event)
231 {
232     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
233     HTMLDocumentNode *doc = This->This->doc;
234     nsIDOMHTMLElement *nsbody = NULL;
235     HTMLDocumentObj *doc_obj = NULL;
236
237     TRACE("(%p)\n", doc);
238
239     if(!doc || !doc->basedoc.window)
240         return NS_ERROR_FAILURE;
241     if(doc->basedoc.doc_obj && doc->basedoc.doc_obj->basedoc.doc_node == doc)
242         doc_obj = doc->basedoc.doc_obj;
243
244     connect_scripts(doc->window);
245
246     if(doc_obj)
247         handle_docobj_load(doc_obj);
248
249     set_ready_state(doc->basedoc.window, READYSTATE_COMPLETE);
250
251     if(doc_obj) {
252         if(doc_obj->view_sink)
253             IAdviseSink_OnViewChange(doc_obj->view_sink, DVASPECT_CONTENT, -1);
254
255         set_statustext(doc_obj, IDS_STATUS_DONE, NULL);
256
257         update_title(doc_obj);
258     }
259
260     if(doc_obj && doc_obj->usermode!=EDITMODE && doc_obj->doc_object_service)
261         IDocObjectService_FireDocumentComplete(doc_obj->doc_object_service,
262                 &doc->basedoc.window->base.IHTMLWindow2_iface, 0);
263
264     if(!doc->nsdoc) {
265         ERR("NULL nsdoc\n");
266         return NS_ERROR_FAILURE;
267     }
268
269     nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
270     if(nsbody) {
271         fire_event(doc, EVENTID_LOAD, TRUE, (nsIDOMNode*)nsbody, event);
272         nsIDOMHTMLElement_Release(nsbody);
273     }
274
275     return NS_OK;
276 }
277
278 static nsresult NSAPI handle_htmlevent(nsIDOMEventListener *iface, nsIDOMEvent *event)
279 {
280     nsEventListener *This = impl_from_nsIDOMEventListener(iface);
281     HTMLDocumentNode *doc = This->This->doc;
282     const PRUnichar *type;
283     nsIDOMEventTarget *event_target;
284     nsIDOMNode *nsnode;
285     nsAString type_str;
286     eventid_t eid;
287     nsresult nsres;
288
289     TRACE("%p\n", This->This);
290
291     nsAString_Init(&type_str, NULL);
292     nsIDOMEvent_GetType(event, &type_str);
293     nsAString_GetData(&type_str, &type);
294     eid = str_to_eid(type);
295     nsAString_Finish(&type_str);
296
297     nsres = nsIDOMEvent_GetTarget(event, &event_target);
298     if(NS_FAILED(nsres) || !event_target) {
299         ERR("GetEventTarget failed: %08x\n", nsres);
300         return NS_OK;
301     }
302
303     nsres = nsIDOMEventTarget_QueryInterface(event_target, &IID_nsIDOMNode, (void**)&nsnode);
304     nsIDOMEventTarget_Release(event_target);
305     if(NS_FAILED(nsres)) {
306         ERR("Could not get nsIDOMNode: %08x\n", nsres);
307         return NS_OK;
308     }
309
310     fire_event(doc, eid, TRUE, nsnode, event);
311
312     nsIDOMNode_Release(nsnode);
313
314     return NS_OK;
315 }
316
317 #define EVENTLISTENER_VTBL(handler) \
318     { \
319         nsDOMEventListener_QueryInterface, \
320         nsDOMEventListener_AddRef, \
321         nsDOMEventListener_Release, \
322         handler, \
323     }
324
325 static const nsIDOMEventListenerVtbl blur_vtbl =      EVENTLISTENER_VTBL(handle_blur);
326 static const nsIDOMEventListenerVtbl focus_vtbl =     EVENTLISTENER_VTBL(handle_focus);
327 static const nsIDOMEventListenerVtbl keypress_vtbl =  EVENTLISTENER_VTBL(handle_keypress);
328 static const nsIDOMEventListenerVtbl load_vtbl =      EVENTLISTENER_VTBL(handle_load);
329 static const nsIDOMEventListenerVtbl htmlevent_vtbl = EVENTLISTENER_VTBL(handle_htmlevent);
330
331 static void init_event(nsIDOMEventTarget *target, const PRUnichar *type,
332         nsIDOMEventListener *listener, BOOL capture)
333 {
334     nsAString type_str;
335     nsresult nsres;
336
337     nsAString_InitDepend(&type_str, type);
338     nsres = nsIDOMEventTarget_AddEventListener(target, &type_str, listener, capture, FALSE, 1);
339     nsAString_Finish(&type_str);
340     if(NS_FAILED(nsres))
341         ERR("AddEventTarget failed: %08x\n", nsres);
342
343 }
344
345 static void init_listener(nsEventListener *This, nsDocumentEventListener *listener,
346         const nsIDOMEventListenerVtbl *vtbl)
347 {
348     This->nsIDOMEventListener_iface.lpVtbl = vtbl;
349     This->This = listener;
350 }
351
352 void add_nsevent_listener(HTMLDocumentNode *doc, nsIDOMNode *nsnode, LPCWSTR type)
353 {
354     nsIDOMEventTarget *target;
355     nsresult nsres;
356
357     if(nsnode)
358         nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMEventTarget, (void**)&target);
359     else
360         nsres = nsIDOMWindow_QueryInterface(doc->basedoc.window->nswindow, &IID_nsIDOMEventTarget, (void**)&target);
361     if(NS_FAILED(nsres)) {
362         ERR("Could not get nsIDOMEventTarget interface: %08x\n", nsres);
363         return;
364     }
365
366     init_event(target, type, &doc->nsevent_listener->htmlevent_listener.nsIDOMEventListener_iface,
367             TRUE);
368     nsIDOMEventTarget_Release(target);
369 }
370
371 static void detach_nslistener(HTMLDocumentNode *doc, const WCHAR *type, nsEventListener *listener, cpp_bool is_capture)
372 {
373     nsIDOMEventTarget *target;
374     nsAString type_str;
375     nsresult nsres;
376
377     if(!doc->basedoc.window)
378         return;
379
380     nsres = nsIDOMWindow_QueryInterface(doc->basedoc.window->nswindow, &IID_nsIDOMEventTarget, (void**)&target);
381     if(NS_FAILED(nsres)) {
382         ERR("Could not get nsIDOMEventTarget interface: %08x\n", nsres);
383         return;
384     }
385
386     nsAString_InitDepend(&type_str, type);
387     nsres = nsIDOMEventTarget_RemoveEventListener(target, &type_str,
388             &listener->nsIDOMEventListener_iface, is_capture);
389     nsAString_Finish(&type_str);
390     nsIDOMEventTarget_Release(target);
391     if(NS_FAILED(nsres))
392         ERR("RemoveEventTarget failed: %08x\n", nsres);
393 }
394
395 void detach_nsevent(HTMLDocumentNode *doc, const WCHAR *type)
396 {
397     detach_nslistener(doc, type, &doc->nsevent_listener->htmlevent_listener, TRUE);
398 }
399
400 void release_nsevents(HTMLDocumentNode *doc)
401 {
402     nsDocumentEventListener *listener = doc->nsevent_listener;
403
404     TRACE("%p %p\n", doc, doc->nsevent_listener);
405
406     if(!listener)
407         return;
408
409     detach_nslistener(doc, blurW,     &listener->blur_listener,     TRUE);
410     detach_nslistener(doc, focusW,    &listener->focus_listener,    TRUE);
411     detach_nslistener(doc, keypressW, &listener->keypress_listener, FALSE);
412     detach_nslistener(doc, loadW,     &listener->load_listener,     TRUE);
413
414     listener->doc = NULL;
415     release_listener(listener);
416     doc->nsevent_listener = NULL;
417 }
418
419 void init_nsevents(HTMLDocumentNode *doc)
420 {
421     nsDocumentEventListener *listener;
422     nsIDOMEventTarget *target;
423     nsresult nsres;
424
425     listener = heap_alloc(sizeof(nsDocumentEventListener));
426     if(!listener)
427         return;
428
429     TRACE("%p %p\n", doc, listener);
430
431     listener->ref = 1;
432     listener->doc = doc;
433
434     init_listener(&listener->blur_listener,        listener, &blur_vtbl);
435     init_listener(&listener->focus_listener,       listener, &focus_vtbl);
436     init_listener(&listener->keypress_listener,    listener, &keypress_vtbl);
437     init_listener(&listener->load_listener,        listener, &load_vtbl);
438     init_listener(&listener->htmlevent_listener,   listener, &htmlevent_vtbl);
439
440     doc->nsevent_listener = listener;
441
442     nsres = nsIDOMWindow_QueryInterface(doc->basedoc.window->nswindow, &IID_nsIDOMEventTarget, (void**)&target);
443     if(NS_FAILED(nsres)) {
444         ERR("Could not get nsIDOMEventTarget interface: %08x\n", nsres);
445         return;
446     }
447
448     init_event(target, blurW,     &listener->blur_listener.nsIDOMEventListener_iface,     TRUE);
449     init_event(target, focusW,    &listener->focus_listener.nsIDOMEventListener_iface,    TRUE);
450     init_event(target, keypressW, &listener->keypress_listener.nsIDOMEventListener_iface, FALSE);
451     init_event(target, loadW,     &listener->load_listener.nsIDOMEventListener_iface,     TRUE);
452
453     nsIDOMEventTarget_Release(target);
454 }