dlls/wshom.ocx/wshom_main.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 "wshom_private.h"
  20
  21 #include "initguid.h"
  22 #include "wshom.h"
  23 #include "rpcproxy.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(wshom);
  28
  29 static inline struct provideclassinfo *impl_from_IProvideClassInfo(IProvideClassInfo *iface)
  30 {
  31     return CONTAINING_RECORD(iface, struct provideclassinfo, IProvideClassInfo_iface);
  32 }
  33
  34 static ITypeLib *typelib;
  35 static ITypeInfo *typeinfos[LAST_tid];
  36
  37 static REFIID tid_ids[] = {
  38     &IID_NULL,
  39     &IID_IWshCollection,
  40     &IID_IWshEnvironment,
  41     &IID_IWshExec,
  42     &IID_IWshShell3,
  43     &IID_IWshShortcut
  44 };
  45
  46 static HRESULT load_typelib(void)
  47 {
  48     HRESULT hres;
  49     ITypeLib *tl;
  50
  51     if(typelib)
  52         return S_OK;
  53
  54     hres = LoadRegTypeLib(&LIBID_IWshRuntimeLibrary, 1, 0, LOCALE_SYSTEM_DEFAULT, &tl);
  55     if(FAILED(hres)) {
  56         ERR("LoadRegTypeLib failed: %08x\n", hres);
  57         return hres;
  58     }
  59
  60     if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
  61         ITypeLib_Release(tl);
  62     return hres;
  63 }
  64
  65 static HRESULT get_typeinfo_of_guid(const GUID *guid, ITypeInfo **tinfo)
  66 {
  67     HRESULT hres;
  68
  69     if(FAILED(hres = load_typelib()))
  70         return hres;
  71
  72     return ITypeLib_GetTypeInfoOfGuid(typelib, guid, tinfo);
  73 }
  74
  75 HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
  76 {
  77     HRESULT hres;
  78
  79     if (FAILED(hres = load_typelib()))
  80         return hres;
  81
  82     if(!typeinfos[tid]) {
  83         ITypeInfo *ti;
  84
  85         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
  86         if(FAILED(hres)) {
  87             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
  88             return hres;
  89         }
  90
  91         if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
  92             ITypeInfo_Release(ti);
  93     }
  94
  95     *typeinfo = typeinfos[tid];
  96     ITypeInfo_AddRef(*typeinfo);
  97     return S_OK;
  98 }
  99
 100 static
 101 void release_typelib(void)
 102 {
 103     unsigned i;
 104
 105     if(!typelib)
 106         return;
 107
 108     for(i = 0; i < ARRAY_SIZE(typeinfos); i++)
 109         if(typeinfos[i])
 110             ITypeInfo_Release(typeinfos[i]);
 111
 112     ITypeLib_Release(typelib);
 113 }
 114
 115 static HRESULT WINAPI provideclassinfo_QueryInterface(IProvideClassInfo *iface, REFIID riid, void **obj)
 116 {
 117     struct provideclassinfo *This = impl_from_IProvideClassInfo(iface);
 118
 119     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 120
 121     if (IsEqualIID(riid, &IID_IProvideClassInfo)) {
 122         *obj = iface;
 123         IProvideClassInfo_AddRef(iface);
 124         return S_OK;
 125     }
 126     else
 127         return IUnknown_QueryInterface(This->outer, riid, obj);
 128 }
 129
 130 static ULONG WINAPI provideclassinfo_AddRef(IProvideClassInfo *iface)
 131 {
 132     struct provideclassinfo *This = impl_from_IProvideClassInfo(iface);
 133     return IUnknown_AddRef(This->outer);
 134 }
 135
 136 static ULONG WINAPI provideclassinfo_Release(IProvideClassInfo *iface)
 137 {
 138     struct provideclassinfo *This = impl_from_IProvideClassInfo(iface);
 139     return IUnknown_Release(This->outer);
 140 }
 141
 142 static HRESULT WINAPI provideclassinfo_GetClassInfo(IProvideClassInfo *iface, ITypeInfo **ti)
 143 {
 144     struct provideclassinfo *This = impl_from_IProvideClassInfo(iface);
 145
 146     TRACE("(%p)->(%p)\n", This, ti);
 147
 148     return get_typeinfo_of_guid(This->guid, ti);
 149 }
 150
 151 static const IProvideClassInfoVtbl provideclassinfovtbl = {
 152     provideclassinfo_QueryInterface,
 153     provideclassinfo_AddRef,
 154     provideclassinfo_Release,
 155     provideclassinfo_GetClassInfo
 156 };
 157
 158 void init_classinfo(const GUID *guid, IUnknown *outer, struct provideclassinfo *classinfo)
 159 {
 160     classinfo->IProvideClassInfo_iface.lpVtbl = &provideclassinfovtbl;
 161     classinfo->outer = outer;
 162     classinfo->guid = guid;
 163 }
 164
 165 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 166 {
 167     *ppv = NULL;
 168
 169     if(IsEqualGUID(&IID_IUnknown, riid)) {
 170         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 171         *ppv = iface;
 172     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
 173         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 174         *ppv = iface;
 175     }
 176
 177     if(*ppv) {
 178         IUnknown_AddRef((IUnknown*)*ppv);
 179         return S_OK;
 180     }
 181
 182     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 183     return E_NOINTERFACE;
 184 }
 185
 186 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 187 {
 188     TRACE("(%p)\n", iface);
 189     return 2;
 190 }
 191
 192 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 193 {
 194     TRACE("(%p)\n", iface);
 195     return 1;
 196 }
 197
 198 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 199 {
 200     TRACE("(%p)->(%x)\n", iface, fLock);
 201     return S_OK;
 202 }
 203
 204 static const IClassFactoryVtbl WshShellFactoryVtbl = {
 205     ClassFactory_QueryInterface,
 206     ClassFactory_AddRef,
 207     ClassFactory_Release,
 208     WshShellFactory_CreateInstance,
 209     ClassFactory_LockServer
 210 };
 211
 212 static IClassFactory WshShellFactory = { &WshShellFactoryVtbl };
 213
 214 /******************************************************************
 215  *              DllMain (wshom.ocx.@)
 216  */
 217 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 218 {
 219     TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv);
 220
 221     switch(fdwReason)
 222     {
 223     case DLL_PROCESS_ATTACH:
 224         DisableThreadLibraryCalls(hInstDLL);
 225         break;
 226     case DLL_PROCESS_DETACH:
 227         if (lpv) break;
 228         release_typelib();
 229         break;
 230     }
 231
 232     return TRUE;
 233 }
 234
 235 /***********************************************************************
 236  *              DllGetClassObject       (wshom.ocx.@)
 237  */
 238 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 239 {
 240     if(IsEqualGUID(&CLSID_WshShell, rclsid)) {
 241         TRACE("(CLSID_WshShell %s %p)\n", debugstr_guid(riid), ppv);
 242         return IClassFactory_QueryInterface(&WshShellFactory, riid, ppv);
 243     }
 244
 245     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 246     return CLASS_E_CLASSNOTAVAILABLE;
 247 }