dlls/scrobj/scrobj.c

   1 /*
   2  * Copyright 2017 Nikolay Sivov
   3  * Copyright 2019 Jacek Caban for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "ole2.h"
  26 #include "olectl.h"
  27 #include "rpcproxy.h"
  28 #include "activscp.h"
  29 #include "dispex.h"
  30 #include "mshtmhst.h"
  31
  32 #include "initguid.h"
  33 #include "scrobj.h"
  34 #include "xmllite.h"
  35
  36 #include "wine/debug.h"
  37 #include "wine/heap.h"
  38 #include "wine/list.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(scrobj);
  41
  42 #ifdef _WIN64
  43
  44 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  45 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  46 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  47
  48 #else
  49
  50 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  51 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  52 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  53
  54 #endif
  55
  56 static HINSTANCE scrobj_instance;
  57
  58 enum member_type
  59 {
  60     MEMBER_METHOD,
  61     MEMBER_PROPERTY
  62 };
  63
  64 #define PROP_GETTER   0x01
  65 #define PROP_SETTER   0x02
  66
  67 struct scriptlet_member
  68 {
  69     struct list entry;
  70     enum member_type type;
  71     WCHAR *name;
  72     union
  73     {
  74         struct list parameters;
  75         unsigned int flags;
  76     } u;
  77 };
  78
  79 struct method_parameter
  80 {
  81     struct list entry;
  82     WCHAR *name;
  83 };
  84
  85 struct scriptlet_script
  86 {
  87     struct list entry;
  88     WCHAR *language;
  89     WCHAR *body;
  90 };
  91
  92 struct scriptlet_global
  93 {
  94     IDispatchEx IDispatchEx_iface;
  95     LONG ref;
  96 };
  97
  98 struct scriptlet_factory
  99 {
 100     IClassFactory IClassFactory_iface;
 101
 102     LONG ref;
 103
 104     IXmlReader *xml_reader;
 105     IMoniker *moniker;
 106
 107     BOOL have_registration;
 108     BOOL have_public;
 109     WCHAR *description;
 110     WCHAR *progid;
 111     WCHAR *versioned_progid;
 112     WCHAR *version;
 113     WCHAR *classid_str;
 114     CLSID classid;
 115
 116     struct list hosts;
 117     struct list members;
 118     struct list scripts;
 119 };
 120
 121 struct script_reference
 122 {
 123     struct script_host *host;
 124     DISPID id;
 125 };
 126
 127 struct object_member
 128 {
 129     enum member_type type;
 130     BSTR name;
 131     union
 132     {
 133         struct script_reference method;
 134         struct
 135         {
 136             struct script_reference get;
 137             struct script_reference put;
 138         } property;
 139     } u;
 140 };
 141
 142 struct scriptlet_instance
 143 {
 144     IDispatchEx IDispatchEx_iface;
 145     LONG ref;
 146     struct list hosts;
 147     struct scriptlet_global *global;
 148     unsigned member_cnt;
 149     struct object_member *members;
 150 };
 151
 152 struct script_host
 153 {
 154     IActiveScriptSite IActiveScriptSite_iface;
 155     IActiveScriptSiteWindow IActiveScriptSiteWindow_iface;
 156     IServiceProvider IServiceProvider_iface;
 157
 158     LONG ref;
 159     struct list entry;
 160
 161     WCHAR *language;
 162
 163     IActiveScript *active_script;
 164     IActiveScriptParse *parser;
 165     IDispatchEx *script_dispatch;
 166     struct scriptlet_instance *object;
 167     SCRIPTSTATE state;
 168     BOOL cloned;
 169 };
 170
 171 typedef enum tid_t
 172 {
 173     NULL_tid,
 174     IGenScriptletTLib_tid,
 175     LAST_tid
 176 } tid_t;
 177
 178 static ITypeLib *typelib;
 179 static ITypeInfo *typeinfos[LAST_tid];
 180
 181 static REFIID tid_ids[] = {
 182     &IID_NULL,
 183     &IID_IGenScriptletTLib,
 184 };
 185
 186 static HRESULT load_typelib(void)
 187 {
 188     HRESULT hres;
 189     ITypeLib *tl;
 190
 191     if (typelib)
 192         return S_OK;
 193
 194     hres = LoadRegTypeLib(&LIBID_Scriptlet, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 195     if (FAILED(hres))
 196     {
 197         ERR("LoadRegTypeLib failed: %08x\n", hres);
 198         return hres;
 199     }
 200
 201     if (InterlockedCompareExchangePointer((void **)&typelib, tl, NULL))
 202         ITypeLib_Release(tl);
 203     return hres;
 204 }
 205
 206 static HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
 207 {
 208     HRESULT hres;
 209
 210     if (FAILED(hres = load_typelib()))
 211         return hres;
 212
 213     if (!typeinfos[tid])
 214     {
 215         ITypeInfo *ti;
 216
 217         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
 218         if (FAILED(hres)) {
 219             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
 220             return hres;
 221         }
 222
 223         if (InterlockedCompareExchangePointer((void **)(typeinfos+tid), ti, NULL))
 224             ITypeInfo_Release(ti);
 225     }
 226
 227     *typeinfo = typeinfos[tid];
 228     ITypeInfo_AddRef(typeinfos[tid]);
 229     return S_OK;
 230 }
 231
 232 static void release_typelib(void)
 233 {
 234     unsigned i;
 235
 236     if (!typelib)
 237         return;
 238
 239     for (i = 0; i < ARRAY_SIZE(typeinfos); i++)
 240         if (typeinfos[i])
 241             ITypeInfo_Release(typeinfos[i]);
 242
 243     ITypeLib_Release(typelib);
 244 }
 245
 246 static WCHAR *heap_strdupW(const WCHAR *str)
 247 {
 248     WCHAR *ret;
 249     size_t size = (wcslen(str) + 1) * sizeof(WCHAR);
 250     if (!(ret = heap_alloc(size))) return NULL;
 251     memcpy(ret, str, size);
 252     return ret;
 253 }
 254
 255 static inline struct scriptlet_global *global_from_IDispatchEx(IDispatchEx *iface)
 256 {
 257     return CONTAINING_RECORD(iface, struct scriptlet_global, IDispatchEx_iface);
 258 }
 259
 260 static HRESULT WINAPI global_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 261 {
 262     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 263
 264     if (IsEqualGUID(&IID_IUnknown, riid))
 265     {
 266         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 267         *ppv = &This->IDispatchEx_iface;
 268     }
 269     else if (IsEqualGUID(&IID_IDispatch, riid))
 270     {
 271         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 272         *ppv = &This->IDispatchEx_iface;
 273     }
 274     else if (IsEqualGUID(&IID_IDispatchEx, riid))
 275     {
 276         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 277         *ppv = &This->IDispatchEx_iface;
 278     }
 279     else
 280     {
 281         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 282         *ppv = NULL;
 283         return E_NOINTERFACE;
 284     }
 285
 286     IUnknown_AddRef((IUnknown*)*ppv);
 287     return S_OK;
 288 }
 289
 290 static ULONG WINAPI global_AddRef(IDispatchEx *iface)
 291 {
 292     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 293     ULONG ref = InterlockedIncrement(&This->ref);
 294
 295     TRACE("(%p) ref=%d\n", This, ref);
 296
 297     return ref;
 298 }
 299
 300 static ULONG WINAPI global_Release(IDispatchEx *iface)
 301 {
 302     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 303     ULONG ref = InterlockedDecrement(&This->ref);
 304
 305     TRACE("(%p) ref=%d\n", This, ref);
 306
 307     if (!ref) heap_free(This);
 308     return ref;
 309 }
 310
 311 static HRESULT WINAPI global_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 312 {
 313     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 314     FIXME("(%p)->(%p)\n", This, pctinfo);
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI global_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 319 {
 320     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 321     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 322     return E_NOTIMPL;
 323 }
 324
 325 static HRESULT WINAPI global_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 326         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 327 {
 328     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 329     UINT i;
 330     HRESULT hres;
 331
 332     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
 333
 334     for(i=0; i < cNames; i++)
 335     {
 336         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId + i);
 337         if(FAILED(hres))
 338             return hres;
 339     }
 340
 341     return S_OK;
 342 }
 343
 344 static HRESULT WINAPI global_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 345         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 346         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 347 {
 348     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 349     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 350           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 351     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 352             pDispParams, pVarResult, pExcepInfo, NULL);
 353 }
 354
 355 static HRESULT WINAPI global_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 356 {
 357     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 358     FIXME("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 359     return E_NOTIMPL;
 360 }
 361
 362 static HRESULT WINAPI global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 363         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 364 {
 365     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 366     FIXME("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI global_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 371 {
 372     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 373     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI global_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 378 {
 379     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 380     FIXME("(%p)->(%x)\n", This, id);
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI global_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 385 {
 386     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 387     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI global_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 392 {
 393     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 394     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI global_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 399 {
 400     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 401     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI global_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 406 {
 407     struct scriptlet_global *This = global_from_IDispatchEx(iface);
 408     FIXME("(%p)->(%p)\n", This, ppunk);
 409     return E_NOTIMPL;
 410 }
 411
 412 static IDispatchExVtbl global_vtbl = {
 413     global_QueryInterface,
 414     global_AddRef,
 415     global_Release,
 416     global_GetTypeInfoCount,
 417     global_GetTypeInfo,
 418     global_GetIDsOfNames,
 419     global_Invoke,
 420     global_GetDispID,
 421     global_InvokeEx,
 422     global_DeleteMemberByName,
 423     global_DeleteMemberByDispID,
 424     global_GetMemberProperties,
 425     global_GetMemberName,
 426     global_GetNextDispID,
 427     global_GetNameSpaceParent
 428 };
 429
 430 static HRESULT set_script_state(struct script_host *host, SCRIPTSTATE state)
 431 {
 432     HRESULT hres;
 433     if (state == host->state) return S_OK;
 434     hres = IActiveScript_SetScriptState(host->active_script, state);
 435     if (FAILED(hres)) return hres;
 436     host->state = state;
 437     return S_OK;
 438 }
 439
 440 static inline struct script_host *impl_from_IActiveScriptSite(IActiveScriptSite *iface)
 441 {
 442     return CONTAINING_RECORD(iface, struct script_host, IActiveScriptSite_iface);
 443 }
 444
 445 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 446 {
 447     struct script_host *This = impl_from_IActiveScriptSite(iface);
 448
 449     if (IsEqualGUID(&IID_IUnknown, riid))
 450     {
 451         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 452         *ppv = &This->IActiveScriptSite_iface;
 453     }
 454     else if (IsEqualGUID(&IID_IActiveScriptSite, riid))
 455     {
 456         TRACE("(%p)->(IID_IActiveScriptSite %p)\n", This, ppv);
 457         *ppv = &This->IActiveScriptSite_iface;
 458     }
 459     else if (IsEqualGUID(&IID_IActiveScriptSiteWindow, riid))
 460     {
 461         TRACE("(%p)->(IID_IActiveScriptSiteWindow %p)\n", This, ppv);
 462         *ppv = &This->IActiveScriptSiteWindow_iface;
 463     }
 464     else if(IsEqualGUID(&IID_IServiceProvider, riid))
 465     {
 466         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 467         *ppv = &This->IServiceProvider_iface;
 468     }
 469     else
 470     {
 471         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 472         *ppv = NULL;
 473         return E_NOINTERFACE;
 474     }
 475
 476     IUnknown_AddRef((IUnknown*)*ppv);
 477     return S_OK;
 478 }
 479
 480 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 481 {
 482     struct script_host *This = impl_from_IActiveScriptSite(iface);
 483     LONG ref = InterlockedIncrement(&This->ref);
 484
 485     TRACE("(%p) ref=%d\n", This, ref);
 486
 487     return ref;
 488 }
 489
 490 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 491 {
 492     struct script_host *This = impl_from_IActiveScriptSite(iface);
 493     LONG ref = InterlockedDecrement(&This->ref);
 494
 495     TRACE("(%p) ref=%d\n", This, ref);
 496
 497     if(!ref) {
 498         heap_free(This->language);
 499         heap_free(This);
 500     }
 501
 502     return ref;
 503 }
 504
 505 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *lcid)
 506 {
 507     struct script_host *This = impl_from_IActiveScriptSite(iface);
 508
 509     TRACE("(%p, %p)\n", This, lcid);
 510
 511     *lcid = GetUserDefaultLCID();
 512     return S_OK;
 513 }
 514
 515 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR name, DWORD mask,
 516     IUnknown **unk, ITypeInfo **ti)
 517 {
 518     struct script_host *This = impl_from_IActiveScriptSite(iface);
 519
 520     TRACE("(%p, %s, %#x, %p, %p)\n", This, debugstr_w(name), mask, unk, ti);
 521
 522     if (mask != SCRIPTINFO_IUNKNOWN)
 523     {
 524         FIXME("mask %x not supported\n", mask);
 525         return E_NOTIMPL;
 526     }
 527
 528     if (wcscmp(name, L"scriptlet") && wcscmp(name, L"globals"))
 529     {
 530         FIXME("%s not supported\n", debugstr_w(name));
 531         return E_FAIL;
 532     }
 533
 534     if (!This->object) return E_UNEXPECTED;
 535
 536     *unk = (IUnknown *)&This->object->global->IDispatchEx_iface;
 537     IUnknown_AddRef(*unk);
 538     return S_OK;
 539 }
 540
 541 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *version)
 542 {
 543     struct script_host *This = impl_from_IActiveScriptSite(iface);
 544     FIXME("(%p, %p)\n", This, version);
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface, const VARIANT *result,
 549     const EXCEPINFO *ei)
 550 {
 551     struct script_host *This = impl_from_IActiveScriptSite(iface);
 552     FIXME("(%p, %s, %p)\n", This, debugstr_variant(result), ei);
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE state)
 557 {
 558     struct script_host *This = impl_from_IActiveScriptSite(iface);
 559     TRACE("(%p, %d)\n", This, state);
 560     return E_NOTIMPL;
 561 }
 562
 563 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *script_error)
 564 {
 565     struct script_host *This = impl_from_IActiveScriptSite(iface);
 566     FIXME("(%p, %p)\n", This, script_error);
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 571 {
 572     struct script_host *This = impl_from_IActiveScriptSite(iface);
 573     TRACE("(%p)\n", This);
 574     return S_OK;
 575 }
 576
 577 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 578 {
 579     struct script_host *This = impl_from_IActiveScriptSite(iface);
 580     TRACE("(%p)\n", This);
 581     return S_OK;
 582 }
 583
 584 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 585     ActiveScriptSite_QueryInterface,
 586     ActiveScriptSite_AddRef,
 587     ActiveScriptSite_Release,
 588     ActiveScriptSite_GetLCID,
 589     ActiveScriptSite_GetItemInfo,
 590     ActiveScriptSite_GetDocVersionString,
 591     ActiveScriptSite_OnScriptTerminate,
 592     ActiveScriptSite_OnStateChange,
 593     ActiveScriptSite_OnScriptError,
 594     ActiveScriptSite_OnEnterScript,
 595     ActiveScriptSite_OnLeaveScript
 596 };
 597
 598 static inline struct script_host *impl_from_IActiveScriptSiteWindow(IActiveScriptSiteWindow *iface)
 599 {
 600     return CONTAINING_RECORD(iface, struct script_host, IActiveScriptSiteWindow_iface);
 601 }
 602
 603 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface, REFIID riid, void **obj)
 604 {
 605     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 606     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, obj);
 607 }
 608
 609 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 610 {
 611     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 612     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 613 }
 614
 615 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 616 {
 617     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 618     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 619 }
 620
 621 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *hwnd)
 622 {
 623     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 624     FIXME("(%p, %p)\n", This, hwnd);
 625     return E_NOTIMPL;
 626 }
 627
 628 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL enable)
 629 {
 630     struct script_host *This = impl_from_IActiveScriptSiteWindow(iface);
 631     FIXME("(%p, %d)\n", This, enable);
 632     return E_NOTIMPL;
 633 }
 634
 635 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 636     ActiveScriptSiteWindow_QueryInterface,
 637     ActiveScriptSiteWindow_AddRef,
 638     ActiveScriptSiteWindow_Release,
 639     ActiveScriptSiteWindow_GetWindow,
 640     ActiveScriptSiteWindow_EnableModeless
 641 };
 642
 643 static inline struct script_host *impl_from_IServiceProvider(IServiceProvider *iface)
 644 {
 645     return CONTAINING_RECORD(iface, struct script_host, IServiceProvider_iface);
 646 }
 647
 648 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **obj)
 649 {
 650     struct script_host *This = impl_from_IServiceProvider(iface);
 651     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, obj);
 652 }
 653
 654 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 655 {
 656     struct script_host *This = impl_from_IServiceProvider(iface);
 657     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 658 }
 659
 660 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 661 {
 662     struct script_host *This = impl_from_IServiceProvider(iface);
 663     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 664 }
 665
 666 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID service,
 667     REFIID riid, void **obj)
 668 {
 669     struct script_host *This = impl_from_IServiceProvider(iface);
 670     FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(service), debugstr_guid(riid), obj);
 671     return E_NOTIMPL;
 672 }
 673
 674 static const IServiceProviderVtbl ServiceProviderVtbl = {
 675     ServiceProvider_QueryInterface,
 676     ServiceProvider_AddRef,
 677     ServiceProvider_Release,
 678     ServiceProvider_QueryService
 679 };
 680
 681 static struct script_host *find_script_host(struct list *hosts, const WCHAR *language)
 682 {
 683     struct script_host *host;
 684     LIST_FOR_EACH_ENTRY(host, hosts, struct script_host, entry)
 685     {
 686         if (!wcscmp(host->language, language)) return host;
 687     }
 688     return NULL;
 689 }
 690
 691 static HRESULT parse_scripts(struct scriptlet_factory *factory, struct list *hosts, BOOL start)
 692 {
 693     DWORD parse_flags = SCRIPTTEXT_ISVISIBLE;
 694     struct scriptlet_script *script;
 695     struct script_host *host;
 696     HRESULT hres;
 697
 698     if (!start) parse_flags |= SCRIPTITEM_ISPERSISTENT;
 699
 700     LIST_FOR_EACH_ENTRY(script, &factory->scripts, struct scriptlet_script, entry)
 701     {
 702         host = find_script_host(hosts, script->language);
 703
 704         if (start && host->state != SCRIPTSTATE_STARTED)
 705         {
 706             hres = set_script_state(host, SCRIPTSTATE_STARTED);
 707             if (FAILED(hres)) return hres;
 708         }
 709
 710         if (host->cloned) continue;
 711
 712         hres = IActiveScriptParse_ParseScriptText(host->parser, script->body, NULL, NULL, NULL, 0, 0 /* FIXME */,
 713                                                   parse_flags, NULL, NULL);
 714         if (FAILED(hres))
 715         {
 716             WARN("ParseScriptText failed: %08x\n", hres);
 717             return hres;
 718         }
 719     }
 720     if (!start)
 721     {
 722         LIST_FOR_EACH_ENTRY(host, hosts, struct script_host, entry)
 723         {
 724             if (host->state != SCRIPTSTATE_UNINITIALIZED)
 725                 set_script_state(host, SCRIPTSTATE_UNINITIALIZED);
 726         }
 727     }
 728     return S_OK;
 729 }
 730
 731 static HRESULT lookup_script_properties(struct scriptlet_instance *object, BSTR name, struct script_reference *ret)
 732 {
 733     struct script_host *host;
 734     HRESULT hres;
 735
 736     LIST_FOR_EACH_ENTRY(host, &object->hosts, struct script_host, entry)
 737     {
 738         hres = IDispatchEx_GetDispID(host->script_dispatch, name, 0, &ret->id);
 739         if (FAILED(hres)) continue;
 740         ret->host = host;
 741         return S_OK;
 742     }
 743
 744     FIXME("Could not find %s in scripts\n", debugstr_w(name));
 745     return E_FAIL;
 746 }
 747
 748 static HRESULT lookup_object_properties(struct scriptlet_instance *object, struct scriptlet_factory *factory)
 749 {
 750     struct scriptlet_member *member;
 751     unsigned i = 0, member_cnt = 0;
 752     size_t len;
 753     BSTR name;
 754     HRESULT hres;
 755
 756     LIST_FOR_EACH_ENTRY(member, &factory->members, struct scriptlet_member, entry)
 757         member_cnt++;
 758
 759     if (!member_cnt) return S_OK;
 760
 761     if (!(object->members = heap_alloc_zero(member_cnt * sizeof(*object->members)))) return E_OUTOFMEMORY;
 762     object->member_cnt = member_cnt;
 763
 764     LIST_FOR_EACH_ENTRY(member, &factory->members, struct scriptlet_member, entry)
 765     {
 766         object->members[i].type = member->type;
 767         if (!(object->members[i].name = SysAllocString(member->name))) return E_OUTOFMEMORY;
 768         switch (member->type)
 769         {
 770         case MEMBER_METHOD:
 771             hres = lookup_script_properties(object, object->members[i].name, &object->members[i].u.method);
 772             if (FAILED(hres)) return hres;
 773             break;
 774         case MEMBER_PROPERTY:
 775             len = wcslen(member->name);
 776             if (!(name = SysAllocStringLen(NULL, len + 4))) return E_OUTOFMEMORY;
 777             wcscpy(name, L"get_");
 778             wcscat(name, member->name);
 779             hres = lookup_script_properties(object, name, &object->members[i].u.property.get);
 780             if (SUCCEEDED(hres))
 781             {
 782                 memcpy(name, L"put", 3 * sizeof(WCHAR));
 783                 hres = lookup_script_properties(object, name, &object->members[i].u.property.put);
 784             }
 785             SysFreeString(name);
 786             if (FAILED(hres)) return hres;
 787             break;
 788         }
 789         i++;
 790     }
 791
 792     return S_OK;
 793 }
 794
 795 static HRESULT init_script_host(struct script_host *host, IActiveScript *clone)
 796 {
 797     HRESULT hres;
 798
 799     if (!clone)
 800     {
 801         IClassFactoryEx *factory_ex;
 802         IClassFactory *factory;
 803         IUnknown *unk;
 804         CLSID clsid;
 805
 806         if (FAILED(hres = CLSIDFromProgID(host->language, &clsid)))
 807         {
 808             WARN("Could not find script engine for %s\n", debugstr_w(host->language));
 809             return hres;
 810         }
 811
 812         hres = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, NULL,
 813                                 &IID_IClassFactory, (void**)&factory);
 814         if (FAILED(hres)) return hres;
 815
 816         hres = IClassFactory_QueryInterface(factory, &IID_IClassFactoryEx, (void**)&factory_ex);
 817         if (SUCCEEDED(hres))
 818         {
 819             FIXME("Use IClassFactoryEx\n");
 820             IClassFactoryEx_Release(factory_ex);
 821         }
 822
 823         hres = IClassFactory_CreateInstance(factory, NULL, &IID_IUnknown, (void**)&unk);
 824         IClassFactory_Release(factory);
 825         if (FAILED(hres)) return hres;
 826
 827         hres = IUnknown_QueryInterface(unk, &IID_IActiveScript, (void**)&host->active_script);
 828         IUnknown_Release(unk);
 829         if (FAILED(hres)) return hres;
 830     }
 831     else
 832     {
 833         IActiveScript_AddRef(clone);
 834         host->active_script = clone;
 835         host->cloned = TRUE;
 836     }
 837
 838     hres = IActiveScript_QueryInterface(host->active_script, &IID_IActiveScriptParse, (void**)&host->parser);
 839     if (FAILED(hres)) return hres;
 840
 841     if (!clone)
 842     {
 843         hres = IActiveScriptParse_InitNew(host->parser);
 844         if (FAILED(hres))
 845         {
 846             IActiveScriptParse_Release(host->parser);
 847             host->parser = NULL;
 848             return hres;
 849         }
 850     }
 851
 852     return IActiveScript_SetScriptSite(host->active_script, &host->IActiveScriptSite_iface);
 853 }
 854
 855 static HRESULT create_script_host(const WCHAR *language, IActiveScript *origin_script, struct list *hosts, struct script_host **ret)
 856 {
 857     IActiveScript *clone = NULL;
 858     struct script_host *host;
 859     HRESULT hres;
 860
 861     if (!(host = heap_alloc_zero(sizeof(*host)))) return E_OUTOFMEMORY;
 862
 863     host->IActiveScriptSite_iface.lpVtbl = &ActiveScriptSiteVtbl;
 864     host->IActiveScriptSiteWindow_iface.lpVtbl = &ActiveScriptSiteWindowVtbl;
 865     host->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
 866     host->ref = 1;
 867     host->state = SCRIPTSTATE_CLOSED;
 868
 869     if (!(host->language = heap_strdupW(language)))
 870     {
 871         IActiveScriptSite_Release(&host->IActiveScriptSite_iface);
 872         return E_OUTOFMEMORY;
 873     }
 874
 875     if (origin_script)
 876     {
 877         hres = IActiveScript_Clone(origin_script, &clone);
 878         if (FAILED(hres)) clone = NULL;
 879     }
 880
 881     list_add_tail(hosts, &host->entry);
 882     hres = init_script_host(host, clone);
 883     if (clone) IActiveScript_Release(clone);
 884     if (FAILED(hres)) return hres;
 885     if (ret) *ret = host;
 886     return S_OK;
 887 }
 888
 889 static void detach_script_hosts(struct list *hosts)
 890 {
 891     while (!list_empty(hosts))
 892     {
 893         struct script_host *host = LIST_ENTRY(list_head(hosts), struct script_host, entry);
 894         if (host->state != SCRIPTSTATE_UNINITIALIZED) set_script_state(host, SCRIPTSTATE_UNINITIALIZED);
 895         list_remove(&host->entry);
 896         host->object = NULL;
 897         if (host->script_dispatch)
 898         {
 899             IDispatchEx_Release(host->script_dispatch);
 900             host->script_dispatch = NULL;
 901         }
 902         if (host->parser)
 903         {
 904             IActiveScript_Close(host->active_script);
 905             IActiveScriptParse_Release(host->parser);
 906             host->parser = NULL;
 907         }
 908         if (host->active_script)
 909         {
 910             IActiveScript_Release(host->active_script);
 911             host->active_script = NULL;
 912         }
 913         IActiveScriptSite_Release(&host->IActiveScriptSite_iface);
 914     }
 915 }
 916
 917 static HRESULT create_scriptlet_hosts(struct scriptlet_factory *factory, struct list *hosts)
 918 {
 919     struct scriptlet_script *script;
 920     HRESULT hres;
 921
 922     LIST_FOR_EACH_ENTRY(script, &factory->scripts, struct scriptlet_script, entry)
 923     {
 924         if (find_script_host(hosts, script->language)) continue;
 925         hres = create_script_host(script->language, NULL, hosts, NULL);
 926         if (FAILED(hres))
 927         {
 928             detach_script_hosts(hosts);
 929             return hres;
 930         }
 931     }
 932
 933     return S_OK;
 934 }
 935
 936 static inline struct scriptlet_instance *impl_from_IDispatchEx(IDispatchEx *iface)
 937 {
 938     return CONTAINING_RECORD(iface, struct scriptlet_instance, IDispatchEx_iface);
 939 }
 940
 941 static HRESULT WINAPI scriptlet_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 942 {
 943     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 944
 945     if (IsEqualGUID(&IID_IUnknown, riid))
 946     {
 947         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 948         *ppv = &This->IDispatchEx_iface;
 949     }
 950     else if (IsEqualGUID(&IID_IDispatch, riid))
 951     {
 952         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 953         *ppv = &This->IDispatchEx_iface;
 954     }
 955     else if (IsEqualGUID(&IID_IDispatchEx, riid))
 956     {
 957         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 958         *ppv = &This->IDispatchEx_iface;
 959     }
 960     else
 961     {
 962         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 963         *ppv = NULL;
 964         return E_NOINTERFACE;
 965     }
 966
 967     IUnknown_AddRef((IUnknown*)*ppv);
 968     return S_OK;
 969 }
 970
 971 static ULONG WINAPI scriptlet_AddRef(IDispatchEx *iface)
 972 {
 973     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 974     ULONG ref = InterlockedIncrement(&This->ref);
 975
 976     TRACE("(%p) ref=%d\n", This, ref);
 977
 978     return ref;
 979 }
 980
 981 static ULONG WINAPI scriptlet_Release(IDispatchEx *iface)
 982 {
 983     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
 984     ULONG ref = InterlockedDecrement(&This->ref);
 985
 986     TRACE("(%p) ref=%d\n", This, ref);
 987
 988     if (!ref)
 989     {
 990         unsigned i;
 991         for (i = 0; i < This->member_cnt; i++)
 992             SysFreeString(This->members[i].name);
 993         heap_free(This->members);
 994         detach_script_hosts(&This->hosts);
 995         if (This->global) IDispatchEx_Release(&This->global->IDispatchEx_iface);
 996         heap_free(This);
 997     }
 998     return ref;
 999 }
1000
1001 static HRESULT WINAPI scriptlet_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
1002 {
1003     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1004     FIXME("(%p)->(%p)\n", This, pctinfo);
1005     return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI scriptlet_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1009 {
1010     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1011     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1012     return E_NOTIMPL;
1013 }
1014
1015 static HRESULT WINAPI scriptlet_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1016         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1017 {
1018     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1019     UINT i;
1020     HRESULT hres;
1021
1022     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1023           lcid, rgDispId);
1024
1025     for(i=0; i < cNames; i++)
1026     {
1027         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId + i);
1028         if(FAILED(hres))
1029             return hres;
1030     }
1031
1032     return S_OK;
1033 }
1034
1035 static HRESULT WINAPI scriptlet_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1036         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1037         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1038 {
1039     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1040     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1041           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1042     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
1043             pDispParams, pVarResult, pExcepInfo, NULL);
1044 }
1045
1046 static HRESULT WINAPI scriptlet_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
1047 {
1048     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1049     unsigned i;
1050
1051     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
1052
1053     if (grfdex & ~(fdexNameCaseInsensitive|fdexNameCaseSensitive))
1054         FIXME("Unsupported grfdex %x\n", grfdex);
1055
1056     for (i = 0; i < This->member_cnt; i++)
1057     {
1058         if (grfdex & fdexNameCaseInsensitive)
1059         {
1060             if (wcsicmp(This->members[i].name, bstrName)) continue;
1061         }
1062         else if (wcscmp(This->members[i].name, bstrName)) continue;
1063         *pid = i + 1;
1064         return S_OK;
1065     }
1066
1067     WARN("Unknown property %s\n", debugstr_w(bstrName));
1068     return DISP_E_UNKNOWNNAME;
1069 }
1070
1071 static HRESULT WINAPI scriptlet_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *pdp,
1072         VARIANT *res, EXCEPINFO *pei, IServiceProvider *caller)
1073 {
1074     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1075     FIXME("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, pdp, res, pei, caller);
1076     return DISP_E_MEMBERNOTFOUND;
1077 }
1078
1079 static HRESULT WINAPI scriptlet_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
1080 {
1081     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1082     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
1083     return E_NOTIMPL;
1084 }
1085
1086 static HRESULT WINAPI scriptlet_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
1087 {
1088     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1089     FIXME("(%p)->(%x)\n", This, id);
1090     return E_NOTIMPL;
1091 }
1092
1093 static HRESULT WINAPI scriptlet_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
1094 {
1095     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1096     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI scriptlet_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
1101 {
1102     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1103     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
1104     return E_NOTIMPL;
1105 }
1106
1107 static HRESULT WINAPI scriptlet_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
1108 {
1109     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1110     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
1111     return E_NOTIMPL;
1112 }
1113
1114 static HRESULT WINAPI scriptlet_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
1115 {
1116     struct scriptlet_instance *This = impl_from_IDispatchEx(iface);
1117     FIXME("(%p)->(%p)\n", This, ppunk);
1118     return E_NOTIMPL;
1119 }
1120
1121 static IDispatchExVtbl DispatchExVtbl = {
1122     scriptlet_QueryInterface,
1123     scriptlet_AddRef,
1124     scriptlet_Release,
1125     scriptlet_GetTypeInfoCount,
1126     scriptlet_GetTypeInfo,
1127     scriptlet_GetIDsOfNames,
1128     scriptlet_Invoke,
1129     scriptlet_GetDispID,
1130     scriptlet_InvokeEx,
1131     scriptlet_DeleteMemberByName,
1132     scriptlet_DeleteMemberByDispID,
1133     scriptlet_GetMemberProperties,
1134     scriptlet_GetMemberName,
1135     scriptlet_GetNextDispID,
1136     scriptlet_GetNameSpaceParent
1137 };
1138
1139 static HRESULT create_scriptlet_instance(struct scriptlet_factory *factory, IDispatchEx **disp)
1140 {
1141     struct script_host *factory_host, *host;
1142     struct scriptlet_instance *obj;
1143     IDispatch *script_dispatch;
1144     HRESULT hres;
1145
1146     if (!(obj = heap_alloc_zero(sizeof(*obj)))) return E_OUTOFMEMORY;
1147
1148     obj->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
1149     obj->ref = 1;
1150     list_init(&obj->hosts);
1151
1152     if (!(obj->global = heap_alloc(sizeof(*obj->global))))
1153     {
1154         IDispatchEx_Release(&obj->IDispatchEx_iface);
1155         return E_OUTOFMEMORY;
1156     }
1157     obj->global->IDispatchEx_iface.lpVtbl = &global_vtbl;
1158     obj->global->ref = 1;
1159
1160     LIST_FOR_EACH_ENTRY(factory_host, &factory->hosts, struct script_host, entry)
1161     {
1162         hres = create_script_host(factory_host->language, factory_host->active_script, &obj->hosts, &host);
1163         if (FAILED(hres)) break;
1164         host->object = obj;
1165
1166         hres = IActiveScript_AddNamedItem(host->active_script, L"scriptlet",
1167                                           SCRIPTITEM_ISVISIBLE | SCRIPTITEM_GLOBALMEMBERS);
1168         if (FAILED(hres)) break;
1169
1170         hres = IActiveScript_AddNamedItem(host->active_script, L"globals", SCRIPTITEM_ISVISIBLE);
1171         if (FAILED(hres)) break;
1172
1173         hres = IActiveScript_GetScriptDispatch(host->active_script, NULL, &script_dispatch);
1174         if (FAILED(hres)) return hres;
1175
1176         hres = IDispatch_QueryInterface(script_dispatch, &IID_IDispatchEx, (void**)&host->script_dispatch);
1177         IDispatch_Release(script_dispatch);
1178         if (FAILED(hres))
1179         {
1180             FIXME("IDispatchEx not supported by script engine\n");
1181             return hres;
1182         }
1183     }
1184
1185     if (SUCCEEDED(hres)) hres = parse_scripts(factory, &obj->hosts, TRUE);
1186     if (SUCCEEDED(hres)) hres = lookup_object_properties(obj, factory);
1187     if (FAILED(hres))
1188     {
1189         IDispatchEx_Release(&obj->IDispatchEx_iface);
1190         return hres;
1191     }
1192
1193     *disp = &obj->IDispatchEx_iface;
1194     return S_OK;
1195 }
1196
1197 static const char *debugstr_xml_name(struct scriptlet_factory *factory)
1198 {
1199     const WCHAR *str;
1200     UINT len;
1201     HRESULT hres;
1202     hres = IXmlReader_GetLocalName(factory->xml_reader, &str, &len);
1203     if (FAILED(hres)) return "#err";
1204     return debugstr_wn(str, len);
1205 }
1206
1207 static HRESULT next_xml_node(struct scriptlet_factory *factory, XmlNodeType *node_type)
1208 {
1209     HRESULT hres;
1210     do hres = IXmlReader_Read(factory->xml_reader, node_type);
1211     while (hres == S_OK && *node_type == XmlNodeType_Whitespace);
1212     return hres;
1213 }
1214
1215 static BOOL is_xml_name(struct scriptlet_factory *factory, const WCHAR *name)
1216 {
1217     const WCHAR *qname;
1218     UINT len;
1219     HRESULT hres;
1220     hres = IXmlReader_GetQualifiedName(factory->xml_reader, &qname, &len);
1221     return hres == S_OK && len == wcslen(name) && !memcmp(qname, name, len * sizeof(WCHAR));
1222 }
1223
1224 static HRESULT expect_end_element(struct scriptlet_factory *factory)
1225 {
1226     XmlNodeType node_type;
1227     HRESULT hres;
1228     hres = next_xml_node(factory, &node_type);
1229     if (hres != S_OK || node_type != XmlNodeType_EndElement)
1230     {
1231         FIXME("Unexpected node %u %s\n", node_type, debugstr_xml_name(factory));
1232         return E_FAIL;
1233     }
1234     return S_OK;
1235 }
1236
1237 static HRESULT expect_no_attributes(struct scriptlet_factory *factory)
1238 {
1239     UINT count;
1240     HRESULT hres;
1241     hres = IXmlReader_GetAttributeCount(factory->xml_reader, &count);
1242     if (FAILED(hres)) return hres;
1243     if (!count) return S_OK;
1244     FIXME("Unexpected attributes\n");
1245     return E_FAIL;
1246 }
1247
1248 static BOOL is_case_xml_name(struct scriptlet_factory *factory, const WCHAR *name)
1249 {
1250     const WCHAR *qname;
1251     UINT len;
1252     HRESULT hres;
1253     hres = IXmlReader_GetQualifiedName(factory->xml_reader, &qname, &len);
1254     return hres == S_OK && len == wcslen(name) && !memicmp(qname, name, len * sizeof(WCHAR));
1255 }
1256
1257 static HRESULT read_xml_value(struct scriptlet_factory *factory, WCHAR **ret)
1258 {
1259     const WCHAR *str;
1260     UINT len;
1261     HRESULT hres;
1262     hres = IXmlReader_GetValue(factory->xml_reader, &str, &len);
1263     if (FAILED(hres)) return hres;
1264     if (!(*ret = heap_alloc((len + 1) * sizeof(WCHAR)))) return E_OUTOFMEMORY;
1265     memcpy(*ret, str, len * sizeof(WCHAR));
1266     (*ret)[len] = 0;
1267     return S_OK;
1268 }
1269
1270 static HRESULT parse_scriptlet_registration(struct scriptlet_factory *factory)
1271 {
1272     HRESULT hres;
1273
1274     if (factory->have_registration)
1275     {
1276         FIXME("duplicated registration element\n");
1277         return E_FAIL;
1278     }
1279     factory->have_registration = TRUE;
1280
1281     for (;;)
1282     {
1283         hres = IXmlReader_MoveToNextAttribute(factory->xml_reader);
1284         if (hres != S_OK) break;
1285
1286         if (is_xml_name(factory, L"description"))
1287         {
1288             if (factory->description)
1289             {
1290                 FIXME("Duplicated description\n");
1291                 return E_FAIL;
1292             }
1293             hres = read_xml_value(factory, &factory->description);
1294             if (FAILED(hres)) return hres;
1295         }
1296         else if (is_case_xml_name(factory, L"progid"))
1297         {
1298             if (factory->progid)
1299             {
1300                 FIXME("Duplicated progid\n");
1301                 return E_FAIL;
1302             }
1303             hres = read_xml_value(factory, &factory->progid);
1304             if (FAILED(hres)) return hres;
1305         }
1306         else if (is_xml_name(factory, L"version"))
1307         {
1308             if (factory->version)
1309             {
1310                 FIXME("Duplicated version\n");
1311                 return E_FAIL;
1312             }
1313             hres = read_xml_value(factory, &factory->version);
1314             if (FAILED(hres)) return hres;
1315         }
1316         else if (is_xml_name(factory, L"classid"))
1317         {
1318             if (factory->classid_str)
1319             {
1320                 FIXME("Duplicated classid attribute\n");
1321                 return E_FAIL;
1322             }
1323             hres = read_xml_value(factory, &factory->classid_str);
1324             if (FAILED(hres)) return hres;
1325             hres = IIDFromString(factory->classid_str, &factory->classid);
1326             if (FAILED(hres))
1327             {
1328                 FIXME("Invalid classid %s\n", debugstr_w(factory->classid_str));
1329
1330                 return E_FAIL;
1331             }
1332         }
1333         else
1334         {
1335             FIXME("Unexpected attribute\n");
1336             return E_NOTIMPL;
1337         }
1338     }
1339
1340     if (!factory->progid && !factory->classid_str)
1341     {
1342         FIXME("Incomplet registration element\n");
1343         return E_FAIL;
1344     }
1345
1346     if (factory->progid)
1347     {
1348         size_t progid_len = wcslen(factory->progid);
1349         size_t version_len = wcslen(factory->version);
1350
1351         if (!(factory->versioned_progid = heap_alloc((progid_len + version_len + 2) * sizeof(WCHAR))))
1352             return E_OUTOFMEMORY;
1353
1354         memcpy(factory->versioned_progid, factory->progid, (progid_len + 1) * sizeof(WCHAR));
1355         if (version_len)
1356         {
1357             factory->versioned_progid[progid_len++] = '.';
1358             wcscpy(factory->versioned_progid + progid_len, factory->version);
1359         }
1360         else factory->versioned_progid[progid_len] = 0;
1361     }
1362
1363     return expect_end_element(factory);
1364 }
1365
1366 static HRESULT parse_scriptlet_public(struct scriptlet_factory *factory)
1367 {
1368     struct scriptlet_member *member, *member_iter;
1369     enum member_type member_type;
1370     XmlNodeType node_type;
1371     BOOL empty;
1372     HRESULT hres;
1373
1374     TRACE("\n");
1375
1376     if (factory->have_public)
1377     {
1378         FIXME("duplicated public element\n");
1379         return E_FAIL;
1380     }
1381     factory->have_public = TRUE;
1382
1383     for (;;)
1384     {
1385         hres = next_xml_node(factory, &node_type);
1386         if (FAILED(hres)) return hres;
1387         if (node_type == XmlNodeType_EndElement) break;
1388         if (node_type != XmlNodeType_Element)
1389         {
1390             FIXME("Unexpected node type %u\n", node_type);
1391             return E_FAIL;
1392         }
1393
1394         if (is_xml_name(factory, L"method"))
1395             member_type = MEMBER_METHOD;
1396         else if (is_xml_name(factory, L"property"))
1397             member_type = MEMBER_PROPERTY;
1398         else
1399         {
1400             FIXME("Unexpected element %s\n", debugstr_xml_name(factory));
1401             return E_NOTIMPL;
1402         }
1403
1404         empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1405
1406         hres = IXmlReader_MoveToAttributeByName(factory->xml_reader, L"name", NULL);
1407         if (hres != S_OK)
1408         {
1409             FIXME("Missing method name\n");
1410             return E_FAIL;
1411         }
1412
1413         if (!(member = heap_alloc(sizeof(*member)))) return E_OUTOFMEMORY;
1414         member->type = member_type;
1415
1416         hres = read_xml_value(factory, &member->name);
1417         if (FAILED(hres))
1418         {
1419             heap_free(member);
1420             return hres;
1421         }
1422
1423         LIST_FOR_EACH_ENTRY(member_iter, &factory->members, struct scriptlet_member, entry)
1424         {
1425             if (!wcsicmp(member_iter->name, member->name))
1426             {
1427                 FIXME("Duplicated member %s\n", debugstr_w(member->name));
1428                 return E_FAIL;
1429             }
1430         }
1431         list_add_tail(&factory->members, &member->entry);
1432
1433         switch (member_type)
1434         {
1435         case MEMBER_METHOD:
1436             list_init(&member->u.parameters);
1437
1438             if (empty) break;
1439             for (;;)
1440             {
1441                 struct method_parameter *parameter;
1442
1443                 hres = next_xml_node(factory, &node_type);
1444                 if (FAILED(hres)) return hres;
1445                 if (node_type == XmlNodeType_EndElement) break;
1446                 if (node_type != XmlNodeType_Element)
1447                 {
1448                     FIXME("Unexpected node type %u\n", node_type);
1449                     return E_FAIL;
1450                 }
1451                 if (!is_case_xml_name(factory, L"parameter"))
1452                 {
1453                     FIXME("Unexpected method element\n");
1454                     return E_FAIL;
1455                 }
1456
1457                 empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1458
1459                 hres = IXmlReader_MoveToAttributeByName(factory->xml_reader, L"name", NULL);
1460                 if (hres != S_OK)
1461                 {
1462                     FIXME("Missing parameter name\n");
1463                     return E_FAIL;
1464                 }
1465
1466                 if (!(parameter = heap_alloc(sizeof(*parameter)))) return E_OUTOFMEMORY;
1467
1468                 hres = read_xml_value(factory, &parameter->name);
1469                 if (FAILED(hres)) return hres;
1470                 list_add_tail(&member->u.parameters, &parameter->entry);
1471                 if (!empty && FAILED(hres = expect_end_element(factory))) return hres;
1472             }
1473             break;
1474
1475         case MEMBER_PROPERTY:
1476             member->u.flags = 0;
1477
1478             if (empty) break;
1479             for (;;)
1480             {
1481                 hres = next_xml_node(factory, &node_type);
1482                 if (FAILED(hres)) return hres;
1483                 if (node_type == XmlNodeType_EndElement) break;
1484                 if (node_type != XmlNodeType_Element)
1485                 {
1486                     FIXME("Unexpected node type %u\n", node_type);
1487                     return E_FAIL;
1488                 }
1489                 if (is_case_xml_name(factory, L"get"))
1490                 {
1491                     if (member->u.flags & PROP_GETTER)
1492                     {
1493                         FIXME("Duplicated getter\n");
1494                         return E_FAIL;
1495                     }
1496                     member->u.flags |= PROP_GETTER;
1497                 }
1498                 else if (is_case_xml_name(factory, L"put"))
1499                 {
1500                     if (member->u.flags & PROP_SETTER)
1501                     {
1502                         FIXME("Duplicated setter\n");
1503                         return E_FAIL;
1504                     }
1505                     member->u.flags |= PROP_SETTER;
1506                 }
1507                 else
1508                 {
1509                     FIXME("Unexpected property element %s\n", debugstr_xml_name(factory));
1510                     return E_FAIL;
1511                 }
1512
1513                 empty = IXmlReader_IsEmptyElement(factory->xml_reader);
1514                 if (!empty && FAILED(hres = expect_end_element(factory))) return hres;
1515             }
1516             if (!member->u.flags)
1517             {
1518                 FIXME("No getter or setter\n");
1519                 return E_NOTIMPL;
1520             }
1521             break;
1522         }
1523         if (FAILED(hres)) return hres;
1524     }
1525
1526     return S_OK;
1527 }
1528
1529 static HRESULT parse_scriptlet_script(struct scriptlet_factory *factory, struct scriptlet_script *script)
1530 {
1531     XmlNodeType node_type;
1532     HRESULT hres;
1533
1534     for (;;)
1535     {
1536         hres = IXmlReader_MoveToNextAttribute(factory->xml_reader);
1537         if (hres != S_OK) break;
1538
1539         if (is_xml_name(factory, L"language"))
1540         {
1541             if (script->language)
1542             {
1543                 FIXME("Duplicated language\n");
1544                 return E_FAIL;
1545             }
1546             hres = read_xml_value(factory, &script->language);
1547             if (FAILED(hres)) return hres;
1548         }
1549         else
1550         {
1551             FIXME("Unexpected attribute\n");
1552             return E_NOTIMPL;
1553         }
1554     }
1555
1556     if (!script->language)
1557     {
1558         FIXME("Language not specified\n");
1559         return E_FAIL;
1560     }
1561
1562     if (FAILED(hres = next_xml_node(factory, &node_type))) return hres;
1563
1564     if (node_type != XmlNodeType_Text && node_type != XmlNodeType_CDATA)
1565     {
1566         FIXME("Unexpected node type %u\n", node_type);
1567         return E_FAIL;
1568     }
1569
1570     hres = read_xml_value(factory, &script->body);
1571     if (FAILED(hres)) return hres;
1572
1573     return expect_end_element(factory);
1574 }
1575
1576 static HRESULT parse_scriptlet_file(struct scriptlet_factory *factory, const WCHAR *url)
1577 {
1578     XmlNodeType node_type;
1579     IBindCtx *bind_ctx;
1580     IStream *stream;
1581     HRESULT hres;
1582
1583     hres = CreateURLMoniker(NULL, url, &factory->moniker);
1584     if (FAILED(hres))
1585     {
1586         WARN("CreateURLMoniker failed: %08x\n", hres);
1587         return hres;
1588     }
1589
1590     hres = CreateBindCtx(0, &bind_ctx);
1591     if(FAILED(hres))
1592         return hres;
1593
1594     hres = IMoniker_BindToStorage(factory->moniker, bind_ctx, NULL, &IID_IStream, (void**)&stream);
1595     IBindCtx_Release(bind_ctx);
1596     if (FAILED(hres))
1597         return hres;
1598
1599     hres = CreateXmlReader(&IID_IXmlReader, (void**)&factory->xml_reader, NULL);
1600     if(SUCCEEDED(hres))
1601         hres = IXmlReader_SetInput(factory->xml_reader, (IUnknown*)stream);
1602     IStream_Release(stream);
1603     if (FAILED(hres))
1604         return hres;
1605
1606     hres = next_xml_node(factory, &node_type);
1607     if (hres == S_OK && node_type == XmlNodeType_XmlDeclaration)
1608         hres = next_xml_node(factory, &node_type);
1609
1610     if (node_type != XmlNodeType_Element || !is_xml_name(factory, L"component"))
1611     {
1612         FIXME("Unexpected %s element\n", debugstr_xml_name(factory));
1613         return E_FAIL;
1614     }
1615
1616     hres = expect_no_attributes(factory);
1617     if (FAILED(hres)) return hres;
1618
1619     for (;;)
1620     {
1621         hres = next_xml_node(factory, &node_type);
1622         if (FAILED(hres)) return hres;
1623         if (node_type == XmlNodeType_EndElement) break;
1624         if (node_type != XmlNodeType_Element)
1625         {
1626             FIXME("Unexpected node type %u\n", node_type);
1627             return E_FAIL;
1628         }
1629
1630         if (is_xml_name(factory, L"registration"))
1631             hres = parse_scriptlet_registration(factory);
1632         else if (is_xml_name(factory, L"public"))
1633             hres = parse_scriptlet_public(factory);
1634         else if (is_xml_name(factory, L"script"))
1635         {
1636             struct scriptlet_script *script;
1637             if (!(script = heap_alloc_zero(sizeof(*script)))) return E_OUTOFMEMORY;
1638             list_add_tail(&factory->scripts, &script->entry);
1639             hres = parse_scriptlet_script(factory, script);
1640             if (FAILED(hres)) return hres;
1641         }
1642         else
1643         {
1644             FIXME("Unexpected element %s\n", debugstr_xml_name(factory));
1645             return E_NOTIMPL;
1646         }
1647         if (FAILED(hres)) return hres;
1648     }
1649
1650     hres = next_xml_node(factory, &node_type);
1651     if (hres != S_FALSE)
1652     {
1653         FIXME("Unexpected node type %u\n", node_type);
1654         return E_FAIL;
1655     }
1656     return S_OK;
1657 }
1658
1659 static inline struct scriptlet_factory *impl_from_IClassFactory(IClassFactory *iface)
1660 {
1661     return CONTAINING_RECORD(iface, struct scriptlet_factory, IClassFactory_iface);
1662 }
1663
1664 static HRESULT WINAPI scriptlet_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1665 {
1666     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1667
1668     if (IsEqualGUID(&IID_IUnknown, riid))
1669     {
1670         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
1671         *ppv = &This->IClassFactory_iface;
1672     }
1673     else if (IsEqualGUID(&IID_IClassFactory, riid))
1674     {
1675         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
1676         *ppv = &This->IClassFactory_iface;
1677     }
1678     else
1679     {
1680         WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
1681         *ppv = NULL;
1682         return E_NOINTERFACE;
1683     }
1684
1685     IUnknown_AddRef((IUnknown *)*ppv);
1686     return S_OK;
1687 }
1688
1689 static ULONG WINAPI scriptlet_factory_AddRef(IClassFactory *iface)
1690 {
1691     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1692     ULONG ref = InterlockedIncrement(&This->ref);
1693
1694     TRACE("(%p) ref=%d\n", This, ref);
1695
1696     return ref;
1697 }
1698
1699 static ULONG WINAPI scriptlet_factory_Release(IClassFactory *iface)
1700 {
1701     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1702     ULONG ref = InterlockedDecrement(&This->ref);
1703
1704     TRACE("(%p) ref=%d\n", This, ref);
1705
1706     if (!ref)
1707     {
1708         if (This->moniker) IMoniker_Release(This->moniker);
1709         if (This->xml_reader) IXmlReader_Release(This->xml_reader);
1710         detach_script_hosts(&This->hosts);
1711         while (!list_empty(&This->members))
1712         {
1713             struct scriptlet_member *member = LIST_ENTRY(list_head(&This->members), struct scriptlet_member, entry);
1714             list_remove(&member->entry);
1715             heap_free(member->name);
1716             if (member->type == MEMBER_METHOD)
1717             {
1718                 while (!list_empty(&member->u.parameters))
1719                 {
1720                     struct method_parameter *parameter = LIST_ENTRY(list_head(&member->u.parameters), struct method_parameter, entry);
1721                     list_remove(&parameter->entry);
1722                     heap_free(parameter->name);
1723                     heap_free(parameter);
1724                 }
1725             }
1726             heap_free(member);
1727         }
1728         while (!list_empty(&This->scripts))
1729         {
1730             struct scriptlet_script *script = LIST_ENTRY(list_head(&This->scripts), struct scriptlet_script, entry);
1731             list_remove(&script->entry);
1732             heap_free(script->language);
1733             heap_free(script->body);
1734             heap_free(script);
1735         }
1736         heap_free(This->classid_str);
1737         heap_free(This->description);
1738         heap_free(This->versioned_progid);
1739         heap_free(This->progid);
1740         heap_free(This->version);
1741         heap_free(This);
1742     }
1743     return ref;
1744 }
1745
1746 static HRESULT WINAPI scriptlet_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1747 {
1748     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1749     IDispatchEx *disp;
1750     HRESULT hres;
1751
1752     TRACE("(%p)->(%p %s %p)\n", This, outer, debugstr_guid(riid), ppv);
1753
1754     if (outer) FIXME("outer not supported\n");
1755
1756     if (list_empty(&This->hosts))
1757     {
1758         hres = create_scriptlet_hosts(This, &This->hosts);
1759         if (FAILED(hres)) return hres;
1760
1761         hres = parse_scripts(This, &This->hosts, FALSE);
1762         if (FAILED(hres))
1763         {
1764             detach_script_hosts(&This->hosts);
1765             return hres;
1766         }
1767     }
1768
1769     hres = create_scriptlet_instance(This, &disp);
1770     if (FAILED(hres)) return hres;
1771
1772     hres = IDispatchEx_QueryInterface(disp, riid, ppv);
1773     IDispatchEx_Release(disp);
1774     return hres;
1775 }
1776
1777 static HRESULT WINAPI scriptlet_factory_LockServer(IClassFactory *iface, BOOL fLock)
1778 {
1779     struct scriptlet_factory *This = impl_from_IClassFactory(iface);
1780     TRACE("(%p)->(%x)\n", This, fLock);
1781     return S_OK;
1782 }
1783
1784 static const struct IClassFactoryVtbl scriptlet_factory_vtbl =
1785 {
1786     scriptlet_factory_QueryInterface,
1787     scriptlet_factory_AddRef,
1788     scriptlet_factory_Release,
1789     scriptlet_factory_CreateInstance,
1790     scriptlet_factory_LockServer
1791 };
1792
1793 static HRESULT create_scriptlet_factory(const WCHAR *url, struct scriptlet_factory **ret)
1794 {
1795     struct scriptlet_factory *factory;
1796     HRESULT hres;
1797
1798     TRACE("%s\n", debugstr_w(url));
1799
1800     if (!(factory = heap_alloc_zero(sizeof(*factory))))
1801     {
1802         IClassFactory_Release(&factory->IClassFactory_iface);
1803         return E_OUTOFMEMORY;
1804     }
1805
1806     factory->IClassFactory_iface.lpVtbl = &scriptlet_factory_vtbl;
1807     factory->ref = 1;
1808     list_init(&factory->hosts);
1809     list_init(&factory->members);
1810     list_init(&factory->scripts);
1811
1812     hres = parse_scriptlet_file(factory, url);
1813     if (FAILED(hres))
1814     {
1815         IClassFactory_Release(&factory->IClassFactory_iface);
1816         return hres;
1817     }
1818
1819     *ret = factory;
1820     return S_OK;
1821 }
1822
1823 static HRESULT register_scriptlet(struct scriptlet_factory *factory)
1824 {
1825     HKEY key, clsid_key, obj_key;
1826     LSTATUS status;
1827     HRESULT hres;
1828
1829     if (factory->classid_str)
1830     {
1831         WCHAR *url;
1832
1833         status = RegCreateKeyW(HKEY_CLASSES_ROOT, L"CLSID", &clsid_key);
1834         if (status) return E_ACCESSDENIED;
1835
1836         status = RegCreateKeyW(clsid_key, factory->classid_str, &obj_key);
1837         RegCloseKey(clsid_key);
1838         if (status) return E_ACCESSDENIED;
1839
1840         hres = IMoniker_GetDisplayName(factory->moniker, NULL, NULL, &url);
1841         if (FAILED(hres))
1842         {
1843             RegCloseKey(obj_key);
1844             return hres;
1845         }
1846         status = RegCreateKeyW(obj_key, L"ScriptletURL", &key);
1847         if (!status)
1848         {
1849             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)url,
1850                                     (wcslen(url) + 1) * sizeof(WCHAR));
1851             RegCloseKey(key);
1852         }
1853         CoTaskMemFree(url);
1854
1855         if (factory->description)
1856             status = RegSetValueExW(obj_key, NULL, 0, REG_SZ, (BYTE*)factory->description,
1857                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
1858
1859         if (!status)
1860         {
1861             status = RegCreateKeyW(obj_key, L"InprocServer32", &key);
1862             if (!status)
1863             {
1864                 WCHAR str[MAX_PATH];
1865                 GetModuleFileNameW(scrobj_instance, str, MAX_PATH);
1866                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)str, (wcslen(str) + 1) * sizeof(WCHAR));
1867                 RegCloseKey(key);
1868             }
1869         }
1870
1871         if (!status && factory->versioned_progid)
1872         {
1873             status = RegCreateKeyW(obj_key, L"ProgID", &key);
1874             if (!status)
1875             {
1876                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->versioned_progid,
1877                                         (wcslen(factory->versioned_progid) + 1) * sizeof(WCHAR));
1878                 RegCloseKey(key);
1879             }
1880         }
1881
1882         if (!status && factory->progid)
1883         {
1884             status = RegCreateKeyW(obj_key, L"VersionIndependentProgID", &key);
1885             if (!status)
1886             {
1887                 status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->progid,
1888                                         (wcslen(factory->progid) + 1) * sizeof(WCHAR));
1889                 RegCloseKey(key);
1890             }
1891         }
1892
1893         RegCloseKey(obj_key);
1894         if (status) return E_ACCESSDENIED;
1895     }
1896
1897     if (factory->progid)
1898     {
1899         status = RegCreateKeyW(HKEY_CLASSES_ROOT, factory->progid, &key);
1900         if (status) return E_ACCESSDENIED;
1901
1902         if (factory->description)
1903             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->description,
1904                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
1905
1906         if (!status && factory->classid_str)
1907         {
1908             status = RegCreateKeyW(key, L"CLSID", &clsid_key);
1909             if (!status)
1910             {
1911                 status = RegSetValueExW(clsid_key, NULL, 0, REG_SZ, (BYTE*)factory->classid_str,
1912                                         (wcslen(factory->classid_str) + 1) * sizeof(WCHAR));
1913                 RegCloseKey(clsid_key);
1914             }
1915         }
1916
1917         RegCloseKey(key);
1918         if (status) return E_ACCESSDENIED;
1919     }
1920
1921     if (factory->versioned_progid)
1922     {
1923         status = RegCreateKeyW(HKEY_CLASSES_ROOT, factory->versioned_progid, &key);
1924         if (status) return E_ACCESSDENIED;
1925
1926         if (factory->description)
1927             status = RegSetValueExW(key, NULL, 0, REG_SZ, (BYTE*)factory->description,
1928                                     (wcslen(factory->description) + 1) * sizeof(WCHAR));
1929
1930         if (!status && factory->classid_str)
1931         {
1932             status = RegCreateKeyW(key, L"CLSID", &clsid_key);
1933             if (!status)
1934             {
1935                 status = RegSetValueExW(clsid_key, NULL, 0, REG_SZ, (BYTE*)factory->classid_str,
1936                                         (wcslen(factory->classid_str) + 1) * sizeof(WCHAR));
1937                 RegCloseKey(clsid_key);
1938             }
1939         }
1940
1941         RegCloseKey(key);
1942         if (status) return E_ACCESSDENIED;
1943     }
1944
1945     return S_OK;
1946 }
1947
1948 static HRESULT unregister_scriptlet(struct scriptlet_factory *factory)
1949 {
1950     LSTATUS status;
1951
1952     if (factory->classid_str)
1953     {
1954         HKEY clsid_key;
1955         status = RegCreateKeyW(HKEY_CLASSES_ROOT, L"CLSID", &clsid_key);
1956         if (!status)
1957         {
1958             RegDeleteTreeW(clsid_key, factory->classid_str);
1959             RegCloseKey(clsid_key);
1960         }
1961     }
1962
1963     if (factory->progid) RegDeleteTreeW(HKEY_CLASSES_ROOT, factory->progid);
1964     if (factory->versioned_progid) RegDeleteTreeW(HKEY_CLASSES_ROOT, factory->versioned_progid);
1965     return S_OK;
1966 }
1967
1968 struct scriptlet_typelib
1969 {
1970     IGenScriptletTLib IGenScriptletTLib_iface;
1971     LONG ref;
1972
1973     BSTR guid;
1974 };
1975
1976 static inline struct scriptlet_typelib *impl_from_IGenScriptletTLib(IGenScriptletTLib *iface)
1977 {
1978     return CONTAINING_RECORD(iface, struct scriptlet_typelib, IGenScriptletTLib_iface);
1979 }
1980
1981 static HRESULT WINAPI scriptlet_typelib_QueryInterface(IGenScriptletTLib *iface, REFIID riid, void **obj)
1982 {
1983     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
1984
1985     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), obj);
1986
1987     if (IsEqualIID(riid, &IID_IGenScriptletTLib) ||
1988             IsEqualIID(riid, &IID_IDispatch) ||
1989             IsEqualIID(riid, &IID_IUnknown))
1990     {
1991         *obj = iface;
1992         IGenScriptletTLib_AddRef(iface);
1993         return S_OK;
1994     }
1995
1996     *obj = NULL;
1997     return E_NOINTERFACE;
1998 }
1999
2000 static ULONG WINAPI scriptlet_typelib_AddRef(IGenScriptletTLib *iface)
2001 {
2002     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2003     ULONG ref = InterlockedIncrement(&This->ref);
2004     TRACE("(%p)->(%u)\n", This, ref);
2005     return ref;
2006 }
2007
2008 static ULONG WINAPI scriptlet_typelib_Release(IGenScriptletTLib *iface)
2009 {
2010     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2011     LONG ref = InterlockedDecrement(&This->ref);
2012
2013     TRACE("(%p)->(%u)\n", This, ref);
2014
2015     if (!ref)
2016     {
2017         SysFreeString(This->guid);
2018         HeapFree(GetProcessHeap(), 0, This);
2019     }
2020
2021     return ref;
2022 }
2023
2024 static HRESULT WINAPI scriptlet_typelib_GetTypeInfoCount(IGenScriptletTLib *iface, UINT *count)
2025 {
2026     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2027
2028     TRACE("(%p, %p)\n", This, count);
2029
2030     *count = 1;
2031     return S_OK;
2032 }
2033
2034 static HRESULT WINAPI scriptlet_typelib_GetTypeInfo(IGenScriptletTLib *iface, UINT index, LCID lcid,
2035     ITypeInfo **tinfo)
2036 {
2037     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2038
2039     TRACE("(%p, %u, %x, %p)\n", This, index, lcid, tinfo);
2040
2041     return get_typeinfo(IGenScriptletTLib_tid, tinfo);
2042 }
2043
2044 static HRESULT WINAPI scriptlet_typelib_GetIDsOfNames(IGenScriptletTLib *iface, REFIID riid, LPOLESTR *names,
2045     UINT cNames, LCID lcid, DISPID *dispid)
2046 {
2047     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2048     ITypeInfo *typeinfo;
2049     HRESULT hr;
2050
2051     TRACE("(%p, %s, %p, %u, %x, %p)\n", This, debugstr_guid(riid), names, cNames, lcid, dispid);
2052
2053     hr = get_typeinfo(IGenScriptletTLib_tid, &typeinfo);
2054     if (SUCCEEDED(hr))
2055     {
2056         hr = ITypeInfo_GetIDsOfNames(typeinfo, names, cNames, dispid);
2057         ITypeInfo_Release(typeinfo);
2058     }
2059
2060     return hr;
2061 }
2062
2063 static HRESULT WINAPI scriptlet_typelib_Invoke(IGenScriptletTLib *iface, DISPID dispid, REFIID riid,
2064     LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *ei, UINT *argerr)
2065 {
2066     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2067     ITypeInfo *typeinfo;
2068     HRESULT hr;
2069
2070     TRACE("(%p, %d, %s, %x, %x, %p, %p, %p, %p)\n", This, dispid, debugstr_guid(riid), lcid, flags,
2071         params, result, ei, argerr);
2072
2073     hr = get_typeinfo(IGenScriptletTLib_tid, &typeinfo);
2074     if (SUCCEEDED(hr))
2075     {
2076         hr = ITypeInfo_Invoke(typeinfo, &This->IGenScriptletTLib_iface, dispid, flags,
2077                 params, result, ei, argerr);
2078         ITypeInfo_Release(typeinfo);
2079     }
2080
2081     return hr;
2082 }
2083
2084 static HRESULT WINAPI scriptlet_typelib_AddURL(IGenScriptletTLib *iface, BSTR url)
2085 {
2086     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2087
2088     FIXME("(%p, %s): stub\n", This, debugstr_w(url));
2089
2090     return E_NOTIMPL;
2091 }
2092
2093 static HRESULT WINAPI scriptlet_typelib_put_Path(IGenScriptletTLib *iface, BSTR path)
2094 {
2095     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2096
2097     FIXME("(%p, %s): stub\n", This, debugstr_w(path));
2098
2099     return E_NOTIMPL;
2100 }
2101
2102 static HRESULT WINAPI scriptlet_typelib_get_Path(IGenScriptletTLib *iface, BSTR *path)
2103 {
2104     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2105
2106     FIXME("(%p, %p): stub\n", This, path);
2107
2108     return E_NOTIMPL;
2109 }
2110
2111 static HRESULT WINAPI scriptlet_typelib_put_Doc(IGenScriptletTLib *iface, BSTR doc)
2112 {
2113     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2114
2115     FIXME("(%p, %s): stub\n", This, debugstr_w(doc));
2116
2117     return E_NOTIMPL;
2118 }
2119
2120 static HRESULT WINAPI scriptlet_typelib_get_Doc(IGenScriptletTLib *iface, BSTR *doc)
2121 {
2122     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2123
2124     FIXME("(%p, %p): stub\n", This, doc);
2125
2126     return E_NOTIMPL;
2127 }
2128
2129 static HRESULT WINAPI scriptlet_typelib_put_Name(IGenScriptletTLib *iface, BSTR name)
2130 {
2131     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2132
2133     FIXME("(%p, %s): stub\n", This, debugstr_w(name));
2134
2135     return E_NOTIMPL;
2136 }
2137
2138 static HRESULT WINAPI scriptlet_typelib_get_Name(IGenScriptletTLib *iface, BSTR *name)
2139 {
2140     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2141
2142     FIXME("(%p, %p): stub\n", This, name);
2143
2144     return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI scriptlet_typelib_put_MajorVersion(IGenScriptletTLib *iface, WORD version)
2148 {
2149     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2150
2151     FIXME("(%p, %x): stub\n", This, version);
2152
2153     return E_NOTIMPL;
2154 }
2155
2156 static HRESULT WINAPI scriptlet_typelib_get_MajorVersion(IGenScriptletTLib *iface, WORD *version)
2157 {
2158     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2159
2160     FIXME("(%p, %p): stub\n", This, version);
2161
2162     return E_NOTIMPL;
2163 }
2164
2165 static HRESULT WINAPI scriptlet_typelib_put_MinorVersion(IGenScriptletTLib *iface, WORD version)
2166 {
2167     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2168
2169     FIXME("(%p, %x): stub\n", This, version);
2170
2171     return E_NOTIMPL;
2172 }
2173
2174 static HRESULT WINAPI scriptlet_typelib_get_MinorVersion(IGenScriptletTLib *iface, WORD *version)
2175 {
2176     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2177
2178     FIXME("(%p, %p): stub\n", This, version);
2179
2180     return E_NOTIMPL;
2181 }
2182
2183 static HRESULT WINAPI scriptlet_typelib_Write(IGenScriptletTLib *iface)
2184 {
2185     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2186
2187     FIXME("(%p): stub\n", This);
2188
2189     return E_NOTIMPL;
2190 }
2191
2192 static HRESULT WINAPI scriptlet_typelib_Reset(IGenScriptletTLib *iface)
2193 {
2194     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2195
2196     FIXME("(%p): stub\n", This);
2197
2198     return E_NOTIMPL;
2199 }
2200
2201 static HRESULT WINAPI scriptlet_typelib_put_GUID(IGenScriptletTLib *iface, BSTR guid)
2202 {
2203     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2204
2205     FIXME("(%p, %s): stub\n", This, debugstr_w(guid));
2206
2207     return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI scriptlet_typelib_get_GUID(IGenScriptletTLib *iface, BSTR *ret)
2211 {
2212     struct scriptlet_typelib *This = impl_from_IGenScriptletTLib(iface);
2213
2214     TRACE("(%p, %p)\n", This, ret);
2215
2216     *ret = NULL;
2217
2218     if (!This->guid)
2219     {
2220         WCHAR guidW[39];
2221         GUID guid;
2222         HRESULT hr;
2223
2224         hr = CoCreateGuid(&guid);
2225         if (FAILED(hr))
2226             return hr;
2227
2228         hr = StringFromGUID2(&guid, guidW, ARRAY_SIZE(guidW));
2229         if (FAILED(hr))
2230             return hr;
2231
2232         if (!(This->guid = SysAllocString(guidW)))
2233             return E_OUTOFMEMORY;
2234     }
2235
2236     *ret = SysAllocString(This->guid);
2237     return *ret ? S_OK : E_OUTOFMEMORY;
2238 }
2239
2240 static const IGenScriptletTLibVtbl scriptlet_typelib_vtbl =
2241 {
2242     scriptlet_typelib_QueryInterface,
2243     scriptlet_typelib_AddRef,
2244     scriptlet_typelib_Release,
2245     scriptlet_typelib_GetTypeInfoCount,
2246     scriptlet_typelib_GetTypeInfo,
2247     scriptlet_typelib_GetIDsOfNames,
2248     scriptlet_typelib_Invoke,
2249     scriptlet_typelib_AddURL,
2250     scriptlet_typelib_put_Path,
2251     scriptlet_typelib_get_Path,
2252     scriptlet_typelib_put_Doc,
2253     scriptlet_typelib_get_Doc,
2254     scriptlet_typelib_put_Name,
2255     scriptlet_typelib_get_Name,
2256     scriptlet_typelib_put_MajorVersion,
2257     scriptlet_typelib_get_MajorVersion,
2258     scriptlet_typelib_put_MinorVersion,
2259     scriptlet_typelib_get_MinorVersion,
2260     scriptlet_typelib_Write,
2261     scriptlet_typelib_Reset,
2262     scriptlet_typelib_put_GUID,
2263     scriptlet_typelib_get_GUID
2264 };
2265
2266 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved)
2267 {
2268     TRACE("%p, %u, %p\n", hinst, reason, reserved);
2269
2270     switch (reason)
2271     {
2272         case DLL_WINE_PREATTACH:
2273             return FALSE;    /* prefer native version */
2274         case DLL_PROCESS_ATTACH:
2275             DisableThreadLibraryCalls(hinst);
2276             scrobj_instance = hinst;
2277             break;
2278         case DLL_PROCESS_DETACH:
2279             if (reserved) break;
2280             release_typelib();
2281             break;
2282     }
2283     return TRUE;
2284 }
2285
2286 /***********************************************************************
2287  *      DllRegisterServer (scrobj.@)
2288  */
2289 HRESULT WINAPI DllRegisterServer(void)
2290 {
2291     TRACE("()\n");
2292     return __wine_register_resources(scrobj_instance);
2293 }
2294
2295 /***********************************************************************
2296  *      DllUnregisterServer (scrobj.@)
2297  */
2298 HRESULT WINAPI DllUnregisterServer(void)
2299 {
2300     TRACE("()\n");
2301     return __wine_unregister_resources(scrobj_instance);
2302 }
2303
2304 /***********************************************************************
2305  *      DllInstall (scrobj.@)
2306  */
2307 HRESULT WINAPI DllInstall(BOOL install, const WCHAR *arg)
2308 {
2309     struct scriptlet_factory *factory;
2310     HRESULT hres;
2311
2312     if (install)
2313     {
2314         hres = DllRegisterServer();
2315         if (!arg || FAILED(hres)) return hres;
2316     }
2317     else if (!arg)
2318         return DllUnregisterServer();
2319
2320     hres = create_scriptlet_factory(arg, &factory);
2321     if (SUCCEEDED(hres))
2322     {
2323         if (factory->have_registration)
2324         {
2325             /* validate scripts */
2326             hres = create_scriptlet_hosts(factory, &factory->hosts);
2327             if (SUCCEEDED(hres)) hres = parse_scripts(factory, &factory->hosts, FALSE);
2328         }
2329         else
2330         {
2331             FIXME("No registration info\n");
2332             hres = E_FAIL;
2333         }
2334         if (SUCCEEDED(hres))
2335         {
2336             if (install)
2337                 hres = register_scriptlet(factory);
2338             else
2339                 hres = unregister_scriptlet(factory);
2340         }
2341         IClassFactory_Release(&factory->IClassFactory_iface);
2342     }
2343
2344     return hres;
2345 }
2346
2347 static HRESULT WINAPI scriptlet_typelib_CreateInstance(IClassFactory *factory, IUnknown *outer, REFIID riid, void **obj)
2348 {
2349     struct scriptlet_typelib *This;
2350     HRESULT hr;
2351
2352     TRACE("(%p, %p, %s, %p)\n", factory, outer, debugstr_guid(riid), obj);
2353
2354     *obj = NULL;
2355
2356     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2357     if (!This)
2358         return E_OUTOFMEMORY;
2359
2360     This->IGenScriptletTLib_iface.lpVtbl = &scriptlet_typelib_vtbl;
2361     This->ref = 1;
2362     This->guid = NULL;
2363
2364     hr = IGenScriptletTLib_QueryInterface(&This->IGenScriptletTLib_iface, riid, obj);
2365     IGenScriptletTLib_Release(&This->IGenScriptletTLib_iface);
2366     return hr;
2367 }
2368
2369 static HRESULT WINAPI scrruncf_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2370 {
2371     *ppv = NULL;
2372
2373     if (IsEqualGUID(&IID_IUnknown, riid))
2374     {
2375         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
2376         *ppv = iface;
2377     }
2378     else if (IsEqualGUID(&IID_IClassFactory, riid))
2379     {
2380         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
2381         *ppv = iface;
2382     }
2383
2384     if (*ppv)
2385     {
2386         IUnknown_AddRef((IUnknown *)*ppv);
2387         return S_OK;
2388     }
2389
2390     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
2391     return E_NOINTERFACE;
2392 }
2393
2394 static ULONG WINAPI scrruncf_AddRef(IClassFactory *iface)
2395 {
2396     TRACE("(%p)\n", iface);
2397     return 2;
2398 }
2399
2400 static ULONG WINAPI scrruncf_Release(IClassFactory *iface)
2401 {
2402     TRACE("(%p)\n", iface);
2403     return 1;
2404 }
2405
2406 static HRESULT WINAPI scrruncf_LockServer(IClassFactory *iface, BOOL fLock)
2407 {
2408     TRACE("(%p)->(%x)\n", iface, fLock);
2409     return S_OK;
2410 }
2411
2412 static const struct IClassFactoryVtbl scriptlet_typelib_factory_vtbl =
2413 {
2414     scrruncf_QueryInterface,
2415     scrruncf_AddRef,
2416     scrruncf_Release,
2417     scriptlet_typelib_CreateInstance,
2418     scrruncf_LockServer
2419 };
2420
2421 static IClassFactory scriptlet_typelib_factory = { &scriptlet_typelib_factory_vtbl };
2422
2423 /***********************************************************************
2424  *      DllGetClassObject (scrobj.@)
2425  */
2426 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
2427 {
2428     WCHAR key_name[128], *p;
2429     LONG size = 0;
2430     LSTATUS status;
2431
2432     if (IsEqualGUID(&CLSID_TypeLib, rclsid))
2433     {
2434         TRACE("(Scriptlet.TypeLib %s %p)\n", debugstr_guid(riid), ppv);
2435         return IClassFactory_QueryInterface(&scriptlet_typelib_factory, riid, ppv);
2436     }
2437
2438     wcscpy(key_name, L"CLSID\\");
2439     p = key_name + wcslen(key_name);
2440     p += StringFromGUID2(rclsid, p, ARRAY_SIZE(key_name) - (p - key_name)) - 1;
2441     wcscpy(p, L"\\ScriptletURL");
2442     status = RegQueryValueW(HKEY_CLASSES_ROOT, key_name, NULL, &size);
2443     if (!status)
2444     {
2445         struct scriptlet_factory *factory;
2446         WCHAR *url;
2447         HRESULT hres;
2448
2449         if (!(url = heap_alloc(size * sizeof(WCHAR)))) return E_OUTOFMEMORY;
2450         status = RegQueryValueW(HKEY_CLASSES_ROOT, key_name, url, &size);
2451
2452         hres = create_scriptlet_factory(url, &factory);
2453         heap_free(url);
2454         if (FAILED(hres)) return hres;
2455
2456         hres = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, ppv);
2457         IClassFactory_Release(&factory->IClassFactory_iface);
2458         return hres;
2459     }
2460
2461     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
2462     return CLASS_E_CLASSNOTAVAILABLE;
2463 }
2464
2465 /***********************************************************************
2466  *      DllCanUnloadNow (scrobj.@)
2467  */
2468 HRESULT WINAPI DllCanUnloadNow(void)
2469 {
2470     return S_FALSE;
2471 }