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