iphlpapi: Combine #ifdef HAVE_IFADDRS_H blocks.
[wine] / dlls / vbscript / vbdisp.c
1 /*
2  * Copyright 2011 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 "vbscript.h"
20
21 #include "wine/debug.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
24
25 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
26 {
27     return id < This->desc->func_cnt;
28 }
29
30 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
31 {
32     unsigned i;
33
34     for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) {
35         if(invoke_type == VBDISP_ANY) {
36             if(!search_private && !This->desc->funcs[i].is_public)
37                 continue;
38             if(!i && !This->desc->funcs[0].name) /* default value may not exist */
39                 continue;
40         }else {
41             if(!This->desc->funcs[i].entries[invoke_type]
42                 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
43                 continue;
44         }
45
46         if(!strcmpiW(This->desc->funcs[i].name, name)) {
47             *id = i;
48             return TRUE;
49         }
50     }
51
52     return FALSE;
53 }
54
55 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
56 {
57     unsigned i;
58
59     if(get_func_id(This, name, invoke_type, search_private, id))
60         return S_OK;
61
62     for(i=0; i < This->desc->prop_cnt; i++) {
63         if(!search_private && !This->desc->props[i].is_public)
64             continue;
65
66         if(!strcmpiW(This->desc->props[i].name, name)) {
67             *id = i + This->desc->func_cnt;
68             return S_OK;
69         }
70     }
71
72     if(This->desc->typeinfo) {
73         HRESULT hres;
74
75         hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id);
76         if(SUCCEEDED(hres))
77             return S_OK;
78     }
79
80     *id = -1;
81     return DISP_E_UNKNOWNNAME;
82 }
83
84 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
85 {
86     unsigned i;
87
88     for(i=0; i < dp->cNamedArgs; i++) {
89         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
90             return dp->rgvarg+i;
91     }
92
93     return NULL;
94 }
95
96 static HRESULT invoke_variant_prop(vbdisp_t *This, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
97 {
98     HRESULT hres;
99
100     switch(flags) {
101     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
102         if(dp->cArgs) {
103             WARN("called with arguments\n");
104             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
105         }
106
107         hres = VariantCopy(res, v);
108         break;
109
110     case DISPATCH_PROPERTYPUT: {
111         VARIANT *put_val;
112
113         put_val = get_propput_arg(dp);
114         if(!put_val) {
115             WARN("no value to set\n");
116             return DISP_E_PARAMNOTOPTIONAL;
117         }
118
119         if(res)
120             V_VT(res) = VT_EMPTY;
121
122         hres = VariantCopy(v, put_val);
123         break;
124     }
125
126     default:
127         FIXME("unimplemented flags %x\n", flags);
128         return E_NOTIMPL;
129     }
130
131     return hres;
132 }
133
134 static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
135 {
136     VARIANT *args;
137
138     switch(flags) {
139     case DISPATCH_PROPERTYGET:
140         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
141             FIXME("property does not support DISPATCH_PROPERTYGET\n");
142             return E_FAIL;
143         }
144         break;
145     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
146         break;
147     case DISPATCH_METHOD:
148         if(prop->flags & (BP_GET|BP_GETPUT)) {
149             FIXME("Call on property\n");
150             return E_FAIL;
151         }
152         break;
153     case DISPATCH_PROPERTYPUT:
154         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
155             FIXME("property does not support DISPATCH_PROPERTYPUT\n");
156             return E_FAIL;
157         }
158
159         FIXME("call put\n");
160         return E_NOTIMPL;
161     default:
162         FIXME("unsupported flags %x\n", flags);
163         return E_NOTIMPL;
164     }
165
166     if(arg_cnt(dp) < prop->min_args || arg_cnt(dp) > (prop->max_args ? prop->max_args : prop->min_args)) {
167         FIXME("invalid number of arguments\n");
168         return E_FAIL;
169     }
170
171     if(arg_cnt(dp) == 1 && V_VT(dp->rgvarg) == (VT_BYREF|VT_VARIANT))
172         args = V_VARIANTREF(dp->rgvarg);
173     else
174         args = dp->rgvarg;
175
176     return prop->proc(This, args, dp->cArgs, res);
177 }
178
179 static BOOL run_terminator(vbdisp_t *This)
180 {
181     DISPPARAMS dp = {0};
182
183     if(This->terminator_ran)
184         return TRUE;
185     This->terminator_ran = TRUE;
186
187     if(!This->desc->class_terminate_id)
188         return TRUE;
189
190     This->ref++;
191     exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
192             (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
193     return !--This->ref;
194 }
195
196 static void clean_props(vbdisp_t *This)
197 {
198     unsigned i;
199
200     if(!This->desc)
201         return;
202
203     for(i=0; i < This->desc->prop_cnt; i++)
204         VariantClear(This->props+i);
205 }
206
207 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
208 {
209     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
210 }
211
212 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
213 {
214     vbdisp_t *This = impl_from_IDispatchEx(iface);
215
216     if(IsEqualGUID(&IID_IUnknown, riid)) {
217         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
218         *ppv = &This->IDispatchEx_iface;
219     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
220         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
221         *ppv = &This->IDispatchEx_iface;
222     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
223         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
224         *ppv = &This->IDispatchEx_iface;
225     }else {
226         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
227         *ppv = NULL;
228         return E_NOINTERFACE;
229     }
230
231     IUnknown_AddRef((IUnknown*)*ppv);
232     return S_OK;
233 }
234
235 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
236 {
237     vbdisp_t *This = impl_from_IDispatchEx(iface);
238     LONG ref = InterlockedIncrement(&This->ref);
239
240     TRACE("(%p) ref=%d\n", This, ref);
241
242     return ref;
243 }
244
245 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
246 {
247     vbdisp_t *This = impl_from_IDispatchEx(iface);
248     LONG ref = InterlockedDecrement(&This->ref);
249
250     TRACE("(%p) ref=%d\n", This, ref);
251
252     if(!ref && run_terminator(This)) {
253         clean_props(This);
254         list_remove(&This->entry);
255         heap_free(This);
256     }
257
258     return ref;
259 }
260
261 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
262 {
263     vbdisp_t *This = impl_from_IDispatchEx(iface);
264
265     TRACE("(%p)->(%p)\n", This, pctinfo);
266
267     *pctinfo = 1;
268     return S_OK;
269 }
270
271 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
272                                               ITypeInfo **ppTInfo)
273 {
274     vbdisp_t *This = impl_from_IDispatchEx(iface);
275     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
276     return E_NOTIMPL;
277 }
278
279 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
280                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
281                                                 DISPID *rgDispId)
282 {
283     vbdisp_t *This = impl_from_IDispatchEx(iface);
284     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
285           lcid, rgDispId);
286     return E_NOTIMPL;
287 }
288
289 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
290                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
291                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
292 {
293     vbdisp_t *This = impl_from_IDispatchEx(iface);
294     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
295           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
296     return E_NOTIMPL;
297 }
298
299 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
300 {
301     vbdisp_t *This = impl_from_IDispatchEx(iface);
302
303     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
304
305     if(!This->desc)
306         return E_UNEXPECTED;
307
308     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive)) {
309         FIXME("unsupported flags %x\n", grfdex);
310         return E_NOTIMPL;
311     }
312
313     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
314 }
315
316 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
317         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
318 {
319     vbdisp_t *This = impl_from_IDispatchEx(iface);
320
321     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
322
323     if(!This->desc)
324         return E_UNEXPECTED;
325
326     if(pvarRes)
327         V_VT(pvarRes) = VT_EMPTY;
328
329     if(id < 0)
330         return DISP_E_MEMBERNOTFOUND;
331
332     if(is_func_id(This, id)) {
333         function_t *func;
334
335         switch(wFlags) {
336         case DISPATCH_METHOD:
337         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
338             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
339             if(!func) {
340                 FIXME("no invoke/getter\n");
341                 return DISP_E_MEMBERNOTFOUND;
342             }
343
344             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
345         case DISPATCH_PROPERTYPUT: {
346             VARIANT *put_val;
347             DISPPARAMS dp = {NULL, NULL, 1, 0};
348
349             if(arg_cnt(pdp)) {
350                 FIXME("arguments not implemented\n");
351                 return E_NOTIMPL;
352             }
353
354             put_val = get_propput_arg(pdp);
355             if(!put_val) {
356                 WARN("no value to set\n");
357                 return DISP_E_PARAMNOTOPTIONAL;
358             }
359
360             dp.rgvarg = put_val;
361             func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
362             if(!func) {
363                 FIXME("no letter/setter\n");
364                 return DISP_E_MEMBERNOTFOUND;
365             }
366
367             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
368         }
369         default:
370             FIXME("flags %x\n", wFlags);
371             return DISP_E_MEMBERNOTFOUND;
372         }
373     }
374
375     if(id < This->desc->prop_cnt + This->desc->func_cnt)
376         return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
377
378     if(This->desc->builtin_prop_cnt) {
379         unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
380
381         while(min <= max) {
382             i = (min+max)/2;
383             if(This->desc->builtin_props[i].id == id)
384                 return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
385             if(This->desc->builtin_props[i].id < id)
386                 min = i+1;
387             else
388                 max = i-1;
389         }
390     }
391
392     return DISP_E_MEMBERNOTFOUND;
393 }
394
395 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
396 {
397     vbdisp_t *This = impl_from_IDispatchEx(iface);
398     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
399     return E_NOTIMPL;
400 }
401
402 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
403 {
404     vbdisp_t *This = impl_from_IDispatchEx(iface);
405     FIXME("(%p)->(%x)\n", This, id);
406     return E_NOTIMPL;
407 }
408
409 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
410 {
411     vbdisp_t *This = impl_from_IDispatchEx(iface);
412     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
413     return E_NOTIMPL;
414 }
415
416 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
417 {
418     vbdisp_t *This = impl_from_IDispatchEx(iface);
419     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
420     return E_NOTIMPL;
421 }
422
423 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
424 {
425     vbdisp_t *This = impl_from_IDispatchEx(iface);
426     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
427     return E_NOTIMPL;
428 }
429
430 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
431 {
432     vbdisp_t *This = impl_from_IDispatchEx(iface);
433     FIXME("(%p)->(%p)\n", This, ppunk);
434     return E_NOTIMPL;
435 }
436
437 static IDispatchExVtbl DispatchExVtbl = {
438     DispatchEx_QueryInterface,
439     DispatchEx_AddRef,
440     DispatchEx_Release,
441     DispatchEx_GetTypeInfoCount,
442     DispatchEx_GetTypeInfo,
443     DispatchEx_GetIDsOfNames,
444     DispatchEx_Invoke,
445     DispatchEx_GetDispID,
446     DispatchEx_InvokeEx,
447     DispatchEx_DeleteMemberByName,
448     DispatchEx_DeleteMemberByDispID,
449     DispatchEx_GetMemberProperties,
450     DispatchEx_GetMemberName,
451     DispatchEx_GetNextDispID,
452     DispatchEx_GetNameSpaceParent
453 };
454
455 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
456 {
457     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
458         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
459         : NULL;
460 }
461
462 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
463 {
464     vbdisp_t *vbdisp;
465
466     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
467     if(!vbdisp)
468         return E_OUTOFMEMORY;
469
470     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
471     vbdisp->ref = 1;
472     vbdisp->desc = desc;
473
474     if(desc->class_initialize_id) {
475         DISPPARAMS dp = {0};
476         HRESULT hres;
477
478         hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
479                            (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
480         if(FAILED(hres)) {
481             IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
482             return hres;
483         }
484     }
485
486     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
487     *ret = vbdisp;
488     return S_OK;
489 }
490
491 void collect_objects(script_ctx_t *ctx)
492 {
493     vbdisp_t *iter, *iter2;
494
495     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
496         run_terminator(iter);
497
498     while(!list_empty(&ctx->objects)) {
499         iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
500
501         IDispatchEx_AddRef(&iter->IDispatchEx_iface);
502         clean_props(iter);
503         iter->desc = NULL;
504         list_remove(&iter->entry);
505         list_init(&iter->entry);
506         IDispatchEx_Release(&iter->IDispatchEx_iface);
507     }
508 }
509
510 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
511 {
512     IDispatchEx *dispex;
513     vbdisp_t *vbdisp;
514     HRESULT hres;
515
516     vbdisp = unsafe_impl_from_IDispatch(disp);
517     if(vbdisp)
518         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
519
520     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
521     if(FAILED(hres)) {
522         TRACE("unsing IDispatch\n");
523         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
524     }
525
526     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
527     IDispatchEx_Release(dispex);
528     return hres;
529 }
530
531 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
532 {
533     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
534     IDispatchEx *dispex;
535     EXCEPINFO ei;
536     HRESULT hres;
537
538     memset(&ei, 0, sizeof(ei));
539     if(retv)
540         V_VT(retv) = VT_EMPTY;
541
542     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
543     if(FAILED(hres)) {
544         UINT err = 0;
545
546         TRACE("using IDispatch\n");
547         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
548     }
549
550     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
551     IDispatchEx_Release(dispex);
552     return hres;
553 }
554
555 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val)
556 {
557     DISPID propput_dispid = DISPID_PROPERTYPUT;
558     DISPPARAMS dp  = {val, &propput_dispid, 1, 1};
559     IDispatchEx *dispex;
560     EXCEPINFO ei = {0};
561     HRESULT hres;
562
563     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
564     if(SUCCEEDED(hres)) {
565         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL /* FIXME! */);
566         IDispatchEx_Release(dispex);
567     }else {
568         ULONG err = 0;
569
570         TRACE("using IDispatch\n");
571         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, &err);
572     }
573
574     return hres;
575 }