git.oblomov.eu Git - wine/blob - dlls/shell32/shellole.c

   1 /*
   2  *      handling of SHELL32.DLL OLE-Objects
   3  *
   4  *      Copyright 1997  Marcus Meissner
   5  *      Copyright 1998  Juergen Schmied  <juergen.schmied@metronet.de>
   6  *
   7  */
   8
   9 #include <ctype.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include "ole.h"
  13 #include "ole2.h"
  14 #include "debug.h"
  15 #include "compobj.h"
  16 #include "interfaces.h"
  17 #include "shlobj.h"
  18 #include "shell.h"
  19 #include "winerror.h"
  20 #include "winnls.h"
  21 #include "winproc.h"
  22 #include "winversion.h"
  23 #include "commctrl.h"
  24
  25 #include "shell32_main.h"
  26
  27 /*************************************************************************
  28  *
  29  */
  30 typedef DWORD (* WINAPI GetClassPtr)(REFCLSID,REFIID,LPVOID);
  31
  32 static GetClassPtr SH_find_moduleproc(LPSTR dllname,HMODULE32 *xhmod,LPSTR name)
  33 {       HMODULE32 hmod;
  34         FARPROC32 dllunload,nameproc;
  35
  36         TRACE(shell,"dll=%s, hmodule=%p, name=%s\n",dllname, xhmod, name);
  37         if (xhmod)
  38         { *xhmod = 0;
  39         }
  40         if (!strcasecmp(PathFindFilename32A(dllname),"shell32.dll"))
  41         { return (GetClassPtr)SHELL32_DllGetClassObject;
  42         }
  43
  44         hmod = LoadLibraryEx32A(dllname,0,LOAD_WITH_ALTERED_SEARCH_PATH);
  45         if (!hmod)
  46         { return NULL;
  47         }
  48         dllunload = GetProcAddress32(hmod,"DllCanUnloadNow");
  49         if (!dllunload)
  50         { if (xhmod)
  51           { *xhmod = hmod;
  52           }
  53         }
  54         nameproc = GetProcAddress32(hmod,name);
  55         if (!nameproc)
  56         { FreeLibrary32(hmod);
  57           return NULL;
  58         }
  59         /* register unloadable dll with unloadproc ... */
  60         return (GetClassPtr)nameproc;
  61 }
  62 /*************************************************************************
  63  *
  64  */
  65 static DWORD SH_get_instance(REFCLSID clsid,LPSTR dllname,LPVOID unknownouter,REFIID refiid,LPVOID inst)
  66 {       GetClassPtr     dllgetclassob;
  67         DWORD           hres;
  68         LPCLASSFACTORY  classfac;
  69
  70         char    xclsid[50],xrefiid[50];
  71         WINE_StringFromCLSID((LPCLSID)clsid,xclsid);
  72         WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
  73         TRACE(shell,"\n\tCLSID:%s,%s,%p,\n\tIID:%s,%p\n",xclsid, dllname,unknownouter,xrefiid,inst);
  74
  75         dllgetclassob = SH_find_moduleproc(dllname,NULL,"DllGetClassObject");
  76         if (!dllgetclassob)
  77         { return 0x80070000|GetLastError();
  78         }
  79
  80         hres = (*dllgetclassob)(clsid,(REFIID)&IID_IClassFactory,&classfac);
  81         if ((hres<0) || (hres>=0x80000000))
  82             return hres;
  83         if (!classfac)
  84         { FIXME(shell,"no classfactory, but hres is 0x%ld!\n",hres);
  85           return E_FAIL;
  86         }
  87         classfac->lpvtbl->fnCreateInstance(classfac,unknownouter,refiid,inst);
  88         classfac->lpvtbl->fnRelease(classfac);
  89         return 0;
  90 }
  91
  92 /*************************************************************************
  93  * SHCoCreateInstance [SHELL32.102]
  94  *
  95  * NOTES
  96  *     exported by ordinal
  97  */
  98 LRESULT WINAPI SHCoCreateInstance(LPSTR aclsid,CLSID *clsid,LPUNKNOWN unknownouter,REFIID refiid,LPVOID inst)
  99 {       char    buffer[256],xclsid[48],xiid[48],path[260],tmodel[100];
 100         HKEY    inprockey;
 101         DWORD   pathlen,type,tmodellen;
 102         DWORD   hres;
 103
 104         WINE_StringFromCLSID(refiid,xiid);
 105
 106         if (clsid)
 107         { WINE_StringFromCLSID(clsid,xclsid);
 108         }
 109         else
 110         { if (!aclsid)
 111           {     return 0x80040154;
 112           }
 113           strcpy(xclsid,aclsid);
 114         }
 115         TRACE(shell,"(%p,\n\tSID:\t%s,%p,\n\tIID:\t%s,%p)\n",aclsid,xclsid,unknownouter,xiid,inst);
 116
 117         sprintf(buffer,"CLSID\\%s\\InProcServer32",xclsid);
 118
 119         if (RegOpenKeyEx32A(HKEY_CLASSES_ROOT,buffer,0,0x02000000,&inprockey))
 120         { return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 121         }
 122         pathlen=sizeof(path);
 123
 124         if (RegQueryValue32A(inprockey,NULL,path,&pathlen))
 125         { RegCloseKey(inprockey);
 126           return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 127         }
 128
 129         TRACE(shell, "Server dll is %s\n",path);
 130         tmodellen=sizeof(tmodel);
 131         type=REG_SZ;
 132         if (RegQueryValueEx32A(inprockey,"ThreadingModel",NULL,&type,tmodel,&tmodellen))
 133         { RegCloseKey(inprockey);
 134           return SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 135         }
 136
 137         TRACE(shell, "Threading model is %s\n",tmodel);
 138
 139         hres=SH_get_instance(clsid,path,unknownouter,refiid,inst);
 140         if (hres<0 || (hres>0x80000000))
 141         { hres=SH_get_instance(clsid,"shell32.dll",unknownouter,refiid,inst);
 142         }
 143         RegCloseKey(inprockey);
 144         return hres;
 145 }
 146
 147
 148 /*************************************************************************
 149  * SHELL32_DllGetClassObject   [SHELL32.128]
 150  *
 151  * [Standart OLE/COM Interface Method]
 152  * This Function retrives the pointer to a specified interface (iid) of
 153  * a given class (rclsid).
 154  * With this pointer it's possible to call the IClassFactory_CreateInstance
 155  * method to get a instance of the requested Class.
 156  * This function does NOT instantiate the Class!!!
 157  *
 158  * RETURNS
 159  *   HRESULT
 160  *
 161  */
 162 DWORD WINAPI SHELL32_DllGetClassObject(REFCLSID rclsid,REFIID iid,LPVOID *ppv)
 163 {       HRESULT hres = E_OUTOFMEMORY;
 164         LPCLASSFACTORY lpclf;
 165
 166         char xclsid[50],xiid[50];
 167         WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
 168         WINE_StringFromCLSID((LPCLSID)iid,xiid);
 169         TRACE(shell,"\n\tCLSID:\t%s,\n\tIID:\t%s\n",xclsid,xiid);
 170
 171         *ppv = NULL;
 172         if(IsEqualCLSID(rclsid, &CLSID_ShellDesktop)||
 173            IsEqualCLSID(rclsid, &CLSID_ShellLink))
 174         { if(IsEqualCLSID(rclsid, &CLSID_ShellDesktop))      /*debug*/
 175           { TRACE(shell,"-- requested CLSID_ShellDesktop\n");
 176           }
 177
 178           if (IsEqualCLSID(rclsid, &CLSID_ShellLink))
 179           { if (VERSION_OsIsUnicode ())
 180               lpclf = IShellLinkW_CF_Constructor();
 181             lpclf = IShellLink_CF_Constructor();
 182           }
 183           else
 184           { lpclf = IClassFactory_Constructor();
 185           }
 186
 187           if(lpclf)
 188           { hres = lpclf->lpvtbl->fnQueryInterface(lpclf,iid, ppv);
 189                 lpclf->lpvtbl->fnRelease(lpclf);
 190           }
 191         }
 192         else
 193         { WARN(shell, "-- CLSID not found\n");
 194           hres = CLASS_E_CLASSNOTAVAILABLE;
 195         }
 196         TRACE(shell,"-- pointer to class factory: %p\n",*ppv);
 197         return hres;
 198 }
 199
 200 /*************************************************************************
 201  *                       SHGetMalloc                    [SHELL32.220]
 202  * returns the interface to shell malloc.
 203  *
 204  * [SDK header win95/shlobj.h:
 205  * equivalent to:  #define SHGetMalloc(ppmem)   CoGetMalloc(MEMCTX_TASK, ppmem)
 206  * ]
 207  * What we are currently doing is not very wrong, since we always use the same
 208  * heap (ProcessHeap).
 209  */
 210 DWORD WINAPI SHGetMalloc(LPMALLOC32 *lpmal)
 211 {       TRACE(shell,"(%p)\n", lpmal);
 212         return CoGetMalloc32(0,lpmal);
 213 }
 214
 215 /**************************************************************************
 216 *  IClassFactory Implementation
 217 */
 218 static HRESULT WINAPI IClassFactory_QueryInterface(LPCLASSFACTORY,REFIID,LPVOID*);
 219 static ULONG WINAPI IClassFactory_AddRef(LPCLASSFACTORY);
 220 static ULONG WINAPI IClassFactory_Release(LPCLASSFACTORY);
 221 static HRESULT WINAPI IClassFactory_CreateInstance(LPCLASSFACTORY, LPUNKNOWN, REFIID, LPVOID *);
 222 static HRESULT WINAPI IClassFactory_LockServer(LPCLASSFACTORY, BOOL32);
 223 /**************************************************************************
 224  *  IClassFactory_VTable
 225  */
 226 static IClassFactory_VTable clfvt =
 227 {       IClassFactory_QueryInterface,
 228         IClassFactory_AddRef,
 229         IClassFactory_Release,
 230         IClassFactory_CreateInstance,
 231         IClassFactory_LockServer
 232 };
 233
 234 /**************************************************************************
 235  *  IClassFactory_Constructor
 236  */
 237
 238 LPCLASSFACTORY IClassFactory_Constructor(void)
 239 {       LPCLASSFACTORY  lpclf;
 240
 241         lpclf= (LPCLASSFACTORY)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactory));
 242         lpclf->ref = 1;
 243         lpclf->lpvtbl = &clfvt;
 244   TRACE(shell,"(%p)->()\n",lpclf);
 245         return lpclf;
 246 }
 247 /**************************************************************************
 248  *  IClassFactory_QueryInterface
 249  */
 250 static HRESULT WINAPI IClassFactory_QueryInterface(
 251   LPCLASSFACTORY this, REFIID riid, LPVOID *ppvObj)
 252 {       char    xriid[50];
 253         WINE_StringFromCLSID((LPCLSID)riid,xriid);
 254         TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",this,xriid);
 255
 256         *ppvObj = NULL;
 257
 258         if(IsEqualIID(riid, &IID_IUnknown))          /*IUnknown*/
 259         { *ppvObj = this;
 260         }
 261         else if(IsEqualIID(riid, &IID_IClassFactory))  /*IClassFactory*/
 262         { *ppvObj = (IClassFactory*)this;
 263         }
 264
 265         if(*ppvObj)
 266         { (*(LPCLASSFACTORY*)ppvObj)->lpvtbl->fnAddRef(this);
 267           TRACE(shell,"-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
 268           return S_OK;
 269         }
 270         TRACE(shell,"-- Interface: E_NOINTERFACE\n");
 271         return E_NOINTERFACE;
 272 }
 273 /******************************************************************************
 274  * IClassFactory_AddRef
 275  */
 276 static ULONG WINAPI IClassFactory_AddRef(LPCLASSFACTORY this)
 277 { TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
 278         return ++(this->ref);
 279 }
 280 /******************************************************************************
 281  * IClassFactory_Release
 282  */
 283 static ULONG WINAPI IClassFactory_Release(LPCLASSFACTORY this)
 284 {       TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
 285         if (!--(this->ref))
 286         { TRACE(shell,"-- destroying IClassFactory(%p)\n",this);
 287                 HeapFree(GetProcessHeap(),0,this);
 288                 return 0;
 289         }
 290         return this->ref;
 291 }
 292 /******************************************************************************
 293  * IClassFactory_CreateInstance
 294  */
 295 static HRESULT WINAPI IClassFactory_CreateInstance(
 296   LPCLASSFACTORY this, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
 297 {       IUnknown *pObj = NULL;
 298         HRESULT hres;
 299         char    xriid[50];
 300
 301         WINE_StringFromCLSID((LPCLSID)riid,xriid);
 302         TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",this,pUnknown,xriid,ppObject);
 303
 304         *ppObject = NULL;
 305
 306         if(pUnknown)
 307         {       return(CLASS_E_NOAGGREGATION);
 308         }
 309
 310         if (IsEqualIID(riid, &IID_IShellFolder))
 311         { pObj = (IUnknown *)IShellFolder_Constructor(NULL,NULL);
 312         }
 313         else if (IsEqualIID(riid, &IID_IShellView))
 314         { pObj = (IUnknown *)IShellView_Constructor(NULL,NULL);
 315         }
 316         else if (IsEqualIID(riid, &IID_IExtractIcon))
 317         { pObj = (IUnknown *)IExtractIcon_Constructor(NULL);
 318         }
 319         else if (IsEqualIID(riid, &IID_IContextMenu))
 320         { pObj = (IUnknown *)IContextMenu_Constructor(NULL, NULL, 0);
 321         }
 322         else if (IsEqualIID(riid, &IID_IDataObject))
 323         { pObj = (IUnknown *)IDataObject_Constructor(0,NULL,NULL,0);
 324         }
 325         else
 326         { ERR(shell,"unknown IID requested\n\tIID:\t%s\n",xriid);
 327           return(E_NOINTERFACE);
 328         }
 329
 330         if (!pObj)
 331         { return(E_OUTOFMEMORY);
 332         }
 333
 334         hres = pObj->lpvtbl->fnQueryInterface(pObj,riid, ppObject);
 335         pObj->lpvtbl->fnRelease(pObj);
 336         TRACE(shell,"-- Object created: (%p)->%p\n",this,*ppObject);
 337
 338         return hres;
 339 }
 340 /******************************************************************************
 341  * IClassFactory_LockServer
 342  */
 343 static HRESULT WINAPI IClassFactory_LockServer(LPCLASSFACTORY this, BOOL32 fLock)
 344 {       TRACE(shell,"%p->(0x%x), not implemented\n",this, fLock);
 345         return E_NOTIMPL;
 346 }