dlls/packager/packager_main.c

   1 /*
   2  * Copyright 2014 Andrew Eikum 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 <stdarg.h>
  20
  21 #define COBJMACROS
  22 #include "initguid.h"
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "ole2.h"
  26 #include "rpcproxy.h"
  27 #include "shellapi.h"
  28 #include "shlwapi.h"
  29
  30 #include "wine/debug.h"
  31
  32 #include "packager_classes.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(packager);
  35
  36 struct Package {
  37     IOleObject IOleObject_iface;
  38     IPersistStorage IPersistStorage_iface;
  39
  40     LONG ref;
  41
  42     WCHAR filename[MAX_PATH];
  43
  44     IOleClientSite *clientsite;
  45 };
  46
  47 static inline struct Package *impl_from_IOleObject(IOleObject *iface)
  48 {
  49     return CONTAINING_RECORD(iface, struct Package, IOleObject_iface);
  50 }
  51
  52 static inline struct Package *impl_from_IPersistStorage(IPersistStorage *iface)
  53 {
  54     return CONTAINING_RECORD(iface, struct Package, IPersistStorage_iface);
  55 }
  56
  57 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **obj)
  58 {
  59     struct Package *This = impl_from_IOleObject(iface);
  60
  61     if(IsEqualGUID(riid, &IID_IUnknown) ||
  62             IsEqualGUID(riid, &IID_IOleObject)) {
  63         TRACE("(%p)->(IID_IOleObject, %p)\n", This, obj);
  64         *obj = &This->IOleObject_iface;
  65     }else if(IsEqualGUID(riid, &IID_IPersistStorage)){
  66         TRACE("(%p)->(IID_IPersistStorage, %p)\n", This, obj);
  67         *obj = &This->IPersistStorage_iface;
  68     }else {
  69         FIXME("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  70         *obj = NULL;
  71         return E_NOINTERFACE;
  72     }
  73
  74     IUnknown_AddRef((IUnknown*)*obj);
  75     return S_OK;
  76 }
  77
  78 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
  79 {
  80     struct Package *This = impl_from_IOleObject(iface);
  81     LONG ref = InterlockedIncrement(&This->ref);
  82
  83     TRACE("(%p) ref=%d\n", This, ref);
  84
  85     return ref;
  86 }
  87
  88 static ULONG WINAPI OleObject_Release(IOleObject *iface)
  89 {
  90     struct Package *This = impl_from_IOleObject(iface);
  91     LONG ref = InterlockedDecrement(&This->ref);
  92
  93     TRACE("(%p) ref=%d\n", This, ref);
  94
  95     if(!ref){
  96         if(This->clientsite)
  97             IOleClientSite_Release(This->clientsite);
  98
  99         if(*This->filename)
 100             DeleteFileW(This->filename);
 101
 102         HeapFree(GetProcessHeap(), 0, This);
 103     }
 104
 105     return ref;
 106 }
 107
 108 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 109 {
 110     struct Package *This = impl_from_IOleObject(iface);
 111
 112     TRACE("(%p)->(%p)\n", This, pClientSite);
 113
 114     if(This->clientsite)
 115         IOleClientSite_Release(This->clientsite);
 116
 117     This->clientsite = pClientSite;
 118     if(pClientSite)
 119         IOleClientSite_AddRef(pClientSite);
 120
 121     return S_OK;
 122 }
 123
 124 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 125 {
 126     struct Package *This = impl_from_IOleObject(iface);
 127     FIXME("(%p)->(%p)\n", This, ppClientSite);
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 132 {
 133     struct Package *This = impl_from_IOleObject(iface);
 134     FIXME("(%p)->(%s, %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 139 {
 140     struct Package *This = impl_from_IOleObject(iface);
 141
 142     TRACE("(%p)->(0x%x)\n", This, dwSaveOption);
 143
 144     if(dwSaveOption == OLECLOSE_SAVEIFDIRTY ||
 145             dwSaveOption == OLECLOSE_PROMPTSAVE)
 146         WARN("Saving unsupported\n");
 147
 148     return S_OK;
 149 }
 150
 151 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 152 {
 153     struct Package *This = impl_from_IOleObject(iface);
 154     FIXME("(%p)->(%d, %p)\n", This, dwWhichMoniker, pmk);
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 159 {
 160     struct Package *This = impl_from_IOleObject(iface);
 161     FIXME("(%p)->(%d, %d, %p)\n", This, dwAssign, dwWhichMoniker, ppmk);
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 166                                         DWORD dwReserved)
 167 {
 168     struct Package *This = impl_from_IOleObject(iface);
 169     FIXME("(%p)->(%p, 0x%x, %d)\n", This, pDataObject, fCreation, dwReserved);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 174 {
 175     struct Package *This = impl_from_IOleObject(iface);
 176     FIXME("(%p)->(%d, %p)\n", This, dwReserved, ppDataObject);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT do_activate_object(struct Package *This, HWND parent)
 181 {
 182     ShellExecuteW(parent, L"open", This->filename, NULL, NULL, SW_SHOW);
 183     return S_OK;
 184 }
 185
 186 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 187                                         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 188 {
 189     struct Package *This = impl_from_IOleObject(iface);
 190
 191     TRACE("(%p)->(%d)\n", This, iVerb);
 192
 193     switch(iVerb){
 194     case 0:
 195         return do_activate_object(This, hwndParent);
 196     }
 197
 198     return E_INVALIDARG;
 199 }
 200
 201 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 202 {
 203     struct Package *This = impl_from_IOleObject(iface);
 204     FIXME("(%p)->(%p)\n", This, ppEnumOleVerb);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 209 {
 210     struct Package *This = impl_from_IOleObject(iface);
 211     FIXME("(%p)\n", This);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 216 {
 217     struct Package *This = impl_from_IOleObject(iface);
 218     FIXME("(%p)\n", This);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 223 {
 224     struct Package *This = impl_from_IOleObject(iface);
 225     FIXME("(%p)->(%p)\n", This, pClsid);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 230 {
 231     struct Package *This = impl_from_IOleObject(iface);
 232     FIXME("(%p)->(%d, %p)\n", This, dwFormOfType, pszUserType);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 237 {
 238     struct Package *This = impl_from_IOleObject(iface);
 239     FIXME("(%p)->(%d, %p)\n", This, dwDrawAspect, psizel);
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 244 {
 245     struct Package *This = impl_from_IOleObject(iface);
 246     FIXME("(%p)->(%d, %p)\n", This, dwDrawAspect, psizel);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 251 {
 252     struct Package *This = impl_from_IOleObject(iface);
 253     FIXME("(%p)->(%p, %p)\n", This, pAdvSink, pdwConnection);
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 258 {
 259     struct Package *This = impl_from_IOleObject(iface);
 260     FIXME("(%p)->(%d)\n", This, dwConnection);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 265 {
 266     struct Package *This = impl_from_IOleObject(iface);
 267     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 272 {
 273     struct Package *This = impl_from_IOleObject(iface);
 274
 275     TRACE("(%p)->(%d, %p)\n", This, dwAspect, pdwStatus);
 276
 277     if(!pdwStatus)
 278         return E_INVALIDARG;
 279
 280     *pdwStatus = OLEMISC_ONLYICONIC;
 281
 282     return S_OK;
 283 }
 284
 285 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 286 {
 287     struct Package *This = impl_from_IOleObject(iface);
 288     FIXME("(%p)->(%p)\n", This, pLogpal);
 289     return E_NOTIMPL;
 290 }
 291
 292 static const IOleObjectVtbl OleObject_Vtbl = {
 293     OleObject_QueryInterface,
 294     OleObject_AddRef,
 295     OleObject_Release,
 296     OleObject_SetClientSite,
 297     OleObject_GetClientSite,
 298     OleObject_SetHostNames,
 299     OleObject_Close,
 300     OleObject_SetMoniker,
 301     OleObject_GetMoniker,
 302     OleObject_InitFromData,
 303     OleObject_GetClipboardData,
 304     OleObject_DoVerb,
 305     OleObject_EnumVerbs,
 306     OleObject_Update,
 307     OleObject_IsUpToDate,
 308     OleObject_GetUserClassID,
 309     OleObject_GetUserType,
 310     OleObject_SetExtent,
 311     OleObject_GetExtent,
 312     OleObject_Advise,
 313     OleObject_Unadvise,
 314     OleObject_EnumAdvise,
 315     OleObject_GetMiscStatus,
 316     OleObject_SetColorScheme
 317 };
 318
 319 static HRESULT WINAPI PersistStorage_QueryInterface(IPersistStorage* iface,
 320         REFIID riid, void **ppvObject)
 321 {
 322     struct Package *This = impl_from_IPersistStorage(iface);
 323
 324     return OleObject_QueryInterface(&This->IOleObject_iface, riid, ppvObject);
 325 }
 326
 327 static ULONG WINAPI PersistStorage_AddRef(IPersistStorage* iface)
 328 {
 329     struct Package *This = impl_from_IPersistStorage(iface);
 330
 331     return OleObject_AddRef(&This->IOleObject_iface);
 332 }
 333
 334 static ULONG WINAPI PersistStorage_Release(IPersistStorage* iface)
 335 {
 336     struct Package *This = impl_from_IPersistStorage(iface);
 337
 338     return OleObject_Release(&This->IOleObject_iface);
 339 }
 340
 341 static HRESULT WINAPI PersistStorage_GetClassID(IPersistStorage* iface,
 342         CLSID *pClassID)
 343 {
 344     struct Package *This = impl_from_IPersistStorage(iface);
 345     FIXME("(%p)->(%p)\n", This, pClassID);
 346     return E_NOTIMPL;
 347 }
 348
 349 static HRESULT WINAPI PersistStorage_IsDirty(IPersistStorage* iface)
 350 {
 351     struct Package *This = impl_from_IPersistStorage(iface);
 352     FIXME("(%p)\n", This);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI PersistStorage_InitNew(IPersistStorage* iface,
 357         IStorage *pStg)
 358 {
 359     struct Package *This = impl_from_IPersistStorage(iface);
 360     FIXME("(%p)->(%p)\n", This, pStg);
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT discard_string(struct Package *This, IStream *stream)
 365 {
 366     ULONG nbytes;
 367     HRESULT hr;
 368     char chr = 0;
 369
 370     do{
 371         hr = IStream_Read(stream, &chr, 1, &nbytes);
 372         if(FAILED(hr) || !nbytes){
 373             TRACE("Unexpected end of stream or Read failed with %08x\n", hr);
 374             return (hr == S_OK || hr == S_FALSE) ? E_FAIL : hr;
 375         }
 376     }while(chr);
 377
 378     return S_OK;
 379 }
 380
 381 static HRESULT WINAPI PersistStorage_Load(IPersistStorage* iface,
 382         IStorage *pStg)
 383 {
 384     struct Package *This = impl_from_IPersistStorage(iface);
 385     IStream *stream;
 386     DWORD payload_size, len, stream_filename_len, filenameA_len, i, bytes_read;
 387     ULARGE_INTEGER payload_pos;
 388     LARGE_INTEGER seek;
 389     HRESULT hr;
 390     HANDLE file = INVALID_HANDLE_VALUE;
 391     WCHAR filenameW[MAX_PATH];
 392     char filenameA[MAX_PATH];
 393     WCHAR *stream_filename;
 394     WCHAR *base_end, extension[MAX_PATH];
 395
 396     TRACE("(%p)->(%p)\n", This, pStg);
 397
 398     hr = IStorage_OpenStream(pStg, L"\1Ole10Native", NULL,
 399             STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream);
 400     if(FAILED(hr)){
 401         TRACE("OpenStream gave: %08x\n", hr);
 402         return hr;
 403     }
 404
 405     /* skip stream size & two unknown bytes */
 406     seek.QuadPart = 6;
 407     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
 408     if(FAILED(hr))
 409         goto exit;
 410
 411     /* read and discard label */
 412     hr = discard_string(This, stream);
 413     if(FAILED(hr))
 414         goto exit;
 415
 416     /* read and discard filename */
 417     hr = discard_string(This, stream);
 418     if(FAILED(hr))
 419         goto exit;
 420
 421     /* skip more unknown data */
 422     seek.QuadPart = 4;
 423     hr = IStream_Seek(stream, seek, STREAM_SEEK_CUR, NULL);
 424     if(FAILED(hr))
 425         goto exit;
 426
 427     /* ASCIIZ filename */
 428     hr = IStream_Read(stream, &filenameA_len, 4, NULL);
 429     if(FAILED(hr))
 430         goto exit;
 431
 432     hr = IStream_Read(stream, filenameA, filenameA_len, NULL);
 433     if(FAILED(hr))
 434         goto exit;
 435
 436     /* skip payload for now */
 437     hr = IStream_Read(stream, &payload_size, 4, NULL);
 438     if(FAILED(hr))
 439         goto exit;
 440
 441     seek.QuadPart = 0;
 442     hr = IStream_Seek(stream, seek, STREAM_SEEK_CUR, &payload_pos);
 443     if(FAILED(hr))
 444         goto exit;
 445
 446     seek.QuadPart = payload_size;
 447     hr = IStream_Seek(stream, seek, STREAM_SEEK_CUR, NULL);
 448     if(FAILED(hr))
 449         goto exit;
 450
 451     /* read WCHAR filename, if present */
 452     hr = IStream_Read(stream, &len, 4, &bytes_read);
 453     if(SUCCEEDED(hr) && bytes_read == 4 && len > 0){
 454         hr = IStream_Read(stream, filenameW, len * sizeof(WCHAR), NULL);
 455         if(FAILED(hr))
 456             goto exit;
 457     }else{
 458         len = MultiByteToWideChar(CP_ACP, 0, filenameA, filenameA_len,
 459                 filenameW, ARRAY_SIZE(filenameW));
 460     }
 461
 462     stream_filename = filenameW + len - 1;
 463     while(stream_filename != filenameW &&
 464             *stream_filename != '\\')
 465         --stream_filename;
 466     if(*stream_filename == '\\')
 467         ++stream_filename;
 468     stream_filename_len = len - (stream_filename - filenameW);
 469
 470     len = GetTempPathW(ARRAY_SIZE(This->filename), This->filename);
 471     memcpy(This->filename + len, stream_filename, stream_filename_len * sizeof(WCHAR));
 472     This->filename[len + stream_filename_len] = 0;
 473
 474     /* read & write payload */
 475     memcpy(&seek, &payload_pos, sizeof(seek)); /* STREAM_SEEK_SET treats as ULARGE_INTEGER */
 476     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
 477     if(FAILED(hr))
 478         goto exit;
 479
 480     base_end = PathFindExtensionW(This->filename);
 481     lstrcpyW(extension, base_end);
 482     i = 1;
 483
 484     file = CreateFileW(This->filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 485             CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
 486     while(file == INVALID_HANDLE_VALUE){
 487         if(GetLastError() != ERROR_FILE_EXISTS){
 488             WARN("CreateFile failed: %u\n", GetLastError());
 489             hr = E_FAIL;
 490             goto exit;
 491         }
 492
 493         /* file exists, so increment file name and try again */
 494         ++i;
 495         wsprintfW(base_end, L" (%u)", i);
 496         lstrcatW(base_end, extension);
 497
 498         file = CreateFileW(This->filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
 499                 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
 500     }
 501     TRACE("Final filename: %s\n", wine_dbgstr_w(This->filename));
 502
 503     while(payload_size){
 504         ULONG nbytes;
 505         BYTE data[4096];
 506         DWORD written;
 507
 508         hr = IStream_Read(stream, data, min(sizeof(data), payload_size), &nbytes);
 509         if(FAILED(hr) || nbytes == 0){
 510             TRACE("Unexpected end of file, or Read failed with %08x\n", hr);
 511             if(hr == S_OK || hr == S_FALSE)
 512                 hr = E_FAIL;
 513             goto exit;
 514         }
 515
 516         payload_size -= nbytes;
 517
 518         WriteFile(file, data, nbytes, &written, NULL);
 519     }
 520
 521     hr = S_OK;
 522
 523 exit:
 524     if(file != INVALID_HANDLE_VALUE){
 525         CloseHandle(file);
 526         if(FAILED(hr))
 527             DeleteFileW(This->filename);
 528     }
 529     IStream_Release(stream);
 530
 531     TRACE("Returning: %08x\n", hr);
 532     return hr;
 533 }
 534
 535 static HRESULT WINAPI PersistStorage_Save(IPersistStorage* iface,
 536         IStorage *pStgSave, BOOL fSameAsLoad)
 537 {
 538     struct Package *This = impl_from_IPersistStorage(iface);
 539     FIXME("(%p)->(%p, %u)\n", This, pStgSave, fSameAsLoad);
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI PersistStorage_SaveCompleted(IPersistStorage* iface,
 544         IStorage *pStgNew)
 545 {
 546     struct Package *This = impl_from_IPersistStorage(iface);
 547     FIXME("(%p)->(%p)\n", This, pStgNew);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI PersistStorage_HandsOffStorage(IPersistStorage* iface)
 552 {
 553     struct Package *This = impl_from_IPersistStorage(iface);
 554     FIXME("(%p)\n", This);
 555     return E_NOTIMPL;
 556 }
 557
 558 static IPersistStorageVtbl PersistStorage_Vtbl = {
 559     PersistStorage_QueryInterface,
 560     PersistStorage_AddRef,
 561     PersistStorage_Release,
 562     PersistStorage_GetClassID,
 563     PersistStorage_IsDirty,
 564     PersistStorage_InitNew,
 565     PersistStorage_Load,
 566     PersistStorage_Save,
 567     PersistStorage_SaveCompleted,
 568     PersistStorage_HandsOffStorage
 569 };
 570
 571 static HRESULT WINAPI PackageCF_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
 572 {
 573     TRACE("(static)->(%s, %p)\n", debugstr_guid(riid), obj);
 574
 575     if(IsEqualGUID(&IID_IUnknown, riid) ||
 576             IsEqualGUID(&IID_IClassFactory, riid))
 577         *obj = iface;
 578     else
 579         *obj = NULL;
 580
 581     if(*obj){
 582         IUnknown_AddRef((IUnknown*)*obj);
 583         return S_OK;
 584     }
 585
 586     FIXME("Unknown interface: %s\n", debugstr_guid(riid));
 587     return E_NOINTERFACE;
 588 }
 589
 590 static ULONG WINAPI PackageCF_AddRef(IClassFactory *iface)
 591 {
 592     TRACE("(static)\n");
 593     return 2;
 594 }
 595
 596 static ULONG WINAPI PackageCF_Release(IClassFactory *iface)
 597 {
 598     TRACE("(static)\n");
 599     return 1;
 600 }
 601
 602 static HRESULT WINAPI PackageCF_CreateInstance(IClassFactory *iface, IUnknown *outer,
 603         REFIID iid, void **obj)
 604 {
 605     struct Package *package;
 606
 607     TRACE("(static)->(%p, %s, %p)\n", outer, wine_dbgstr_guid(iid), obj);
 608
 609     package = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*package));
 610     if(!package)
 611         return E_OUTOFMEMORY;
 612
 613     package->IOleObject_iface.lpVtbl = &OleObject_Vtbl;
 614     package->IPersistStorage_iface.lpVtbl = &PersistStorage_Vtbl;
 615
 616     return IOleObject_QueryInterface(&package->IOleObject_iface, iid, obj);
 617 }
 618
 619 static HRESULT WINAPI PackageCF_LockServer(IClassFactory *iface, BOOL fLock)
 620 {
 621     TRACE("(%p)->(%x)\n", iface, fLock);
 622     return S_OK;
 623 }
 624
 625 static const IClassFactoryVtbl PackageCF_Vtbl = {
 626     PackageCF_QueryInterface,
 627     PackageCF_AddRef,
 628     PackageCF_Release,
 629     PackageCF_CreateInstance,
 630     PackageCF_LockServer
 631 };
 632
 633 static IClassFactory PackageCF = {
 634     &PackageCF_Vtbl
 635 };
 636
 637 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **obj)
 638 {
 639     TRACE("(%s, %s, %p)\n", wine_dbgstr_guid(clsid), wine_dbgstr_guid(iid), obj);
 640
 641     if(IsEqualGUID(clsid, &CLSID_Package))
 642         return IClassFactory_QueryInterface(&PackageCF, iid, obj);
 643
 644     FIXME("Unknown CLSID: %s\n", wine_dbgstr_guid(clsid));
 645
 646     return CLASS_E_CLASSNOTAVAILABLE;
 647 }