dlls/opcservices/factory.c

   1 /*
   2  * Copyright 2018 Nikolay Sivov 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 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24
  25 #include "initguid.h"
  26 #include "ole2.h"
  27 #include "rpcproxy.h"
  28 #include "msopc.h"
  29 #include "xmllite.h"
  30
  31 #include "wine/debug.h"
  32
  33 #include "opc_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(msopc);
  36
  37 struct opc_filestream
  38 {
  39     IStream IStream_iface;
  40     LONG refcount;
  41
  42     HANDLE hfile;
  43 };
  44
  45 static inline struct opc_filestream *impl_from_IStream(IStream *iface)
  46 {
  47     return CONTAINING_RECORD(iface, struct opc_filestream, IStream_iface);
  48 }
  49
  50 static HRESULT WINAPI opc_filestream_QueryInterface(IStream *iface, REFIID iid, void **out)
  51 {
  52     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  53
  54     if (IsEqualIID(iid, &IID_IStream) ||
  55             IsEqualIID(iid, &IID_ISequentialStream) ||
  56             IsEqualIID(iid, &IID_IUnknown))
  57     {
  58         *out = iface;
  59         IStream_AddRef(iface);
  60         return S_OK;
  61     }
  62
  63     *out = NULL;
  64     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
  65     return E_NOINTERFACE;
  66 }
  67
  68 static ULONG WINAPI opc_filestream_AddRef(IStream *iface)
  69 {
  70     struct opc_filestream *stream = impl_from_IStream(iface);
  71     ULONG refcount = InterlockedIncrement(&stream->refcount);
  72
  73     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  74
  75     return refcount;
  76 }
  77
  78 static ULONG WINAPI opc_filestream_Release(IStream *iface)
  79 {
  80     struct opc_filestream *stream = impl_from_IStream(iface);
  81     ULONG refcount = InterlockedDecrement(&stream->refcount);
  82
  83     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  84
  85     if (!refcount)
  86     {
  87         CloseHandle(stream->hfile);
  88         heap_free(stream);
  89     }
  90
  91     return refcount;
  92 }
  93
  94 static HRESULT WINAPI opc_filestream_Read(IStream *iface, void *buff, ULONG size, ULONG *num_read)
  95 {
  96     struct opc_filestream *stream = impl_from_IStream(iface);
  97     DWORD read = 0;
  98
  99     TRACE("iface %p, buff %p, size %u, num_read %p.\n", iface, buff, size, num_read);
 100
 101     if (!num_read)
 102         num_read = &read;
 103
 104     *num_read = 0;
 105     if (!ReadFile(stream->hfile, buff, size, num_read, NULL))
 106     {
 107         WARN("Failed to read file, error %d.\n", GetLastError());
 108         return HRESULT_FROM_WIN32(GetLastError());
 109     }
 110
 111     return *num_read == size ? S_OK : S_FALSE;
 112 }
 113
 114 static HRESULT WINAPI opc_filestream_Write(IStream *iface, const void *data, ULONG size, ULONG *num_written)
 115 {
 116     struct opc_filestream *stream = impl_from_IStream(iface);
 117     DWORD written = 0;
 118
 119     TRACE("iface %p, data %p, size %u, num_written %p.\n", iface, data, size, num_written);
 120
 121     if (!num_written)
 122         num_written = &written;
 123
 124     *num_written = 0;
 125     if (!WriteFile(stream->hfile, data, size, num_written, NULL))
 126     {
 127         WARN("Failed to write to file, error %d.\n", GetLastError());
 128         return HRESULT_FROM_WIN32(GetLastError());
 129     }
 130
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI opc_filestream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *newpos)
 135 {
 136     struct opc_filestream *stream = impl_from_IStream(iface);
 137
 138     TRACE("iface %p, move %s, origin %d, newpos %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, newpos);
 139
 140     if (!SetFilePointerEx(stream->hfile, move, (LARGE_INTEGER *)newpos, origin))
 141         return HRESULT_FROM_WIN32(GetLastError());
 142
 143     return S_OK;
 144 }
 145
 146 static HRESULT WINAPI opc_filestream_SetSize(IStream *iface, ULARGE_INTEGER size)
 147 {
 148     FIXME("iface %p, size %s stub!\n", iface, wine_dbgstr_longlong(size.QuadPart));
 149
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI opc_filestream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size,
 154         ULARGE_INTEGER *num_read, ULARGE_INTEGER *written)
 155 {
 156     FIXME("iface %p, dest %p, size %s, num_read %p, written %p stub!\n", iface, dest,
 157             wine_dbgstr_longlong(size.QuadPart), num_read, written);
 158
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI opc_filestream_Commit(IStream *iface, DWORD flags)
 163 {
 164     FIXME("iface %p, flags %#x stub!\n", iface, flags);
 165
 166     return E_NOTIMPL;
 167 }
 168
 169 static HRESULT WINAPI opc_filestream_Revert(IStream *iface)
 170 {
 171     FIXME("iface %p stub!\n", iface);
 172
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI opc_filestream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
 177         ULARGE_INTEGER size, DWORD lock_type)
 178 {
 179     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 180             wine_dbgstr_longlong(size.QuadPart), lock_type);
 181
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI opc_filestream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size,
 186         DWORD lock_type)
 187 {
 188     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 189             wine_dbgstr_longlong(size.QuadPart), lock_type);
 190
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI opc_filestream_Stat(IStream *iface, STATSTG *statstg, DWORD flag)
 195 {
 196     struct opc_filestream *stream = impl_from_IStream(iface);
 197     BY_HANDLE_FILE_INFORMATION fi;
 198
 199     TRACE("iface %p, statstg %p, flag %d.\n", iface, statstg, flag);
 200
 201     if (!statstg)
 202         return E_POINTER;
 203
 204     memset(&fi, 0, sizeof(fi));
 205     GetFileInformationByHandle(stream->hfile, &fi);
 206
 207     memset(statstg, 0, sizeof(*statstg));
 208     statstg->type = STGTY_STREAM;
 209     statstg->cbSize.u.LowPart = fi.nFileSizeLow;
 210     statstg->cbSize.u.HighPart = fi.nFileSizeHigh;
 211     statstg->mtime = fi.ftLastWriteTime;
 212     statstg->ctime = fi.ftCreationTime;
 213     statstg->atime = fi.ftLastAccessTime;
 214
 215     return S_OK;
 216 }
 217
 218 static HRESULT WINAPI opc_filestream_Clone(IStream *iface, IStream **result)
 219 {
 220     FIXME("iface %p, result %p stub!\n", iface, result);
 221
 222     return E_NOTIMPL;
 223 }
 224
 225 static const IStreamVtbl opc_filestream_vtbl =
 226 {
 227     opc_filestream_QueryInterface,
 228     opc_filestream_AddRef,
 229     opc_filestream_Release,
 230     opc_filestream_Read,
 231     opc_filestream_Write,
 232     opc_filestream_Seek,
 233     opc_filestream_SetSize,
 234     opc_filestream_CopyTo,
 235     opc_filestream_Commit,
 236     opc_filestream_Revert,
 237     opc_filestream_LockRegion,
 238     opc_filestream_UnlockRegion,
 239     opc_filestream_Stat,
 240     opc_filestream_Clone,
 241 };
 242
 243 static HRESULT opc_filestream_create(const WCHAR *filename, OPC_STREAM_IO_MODE io_mode, SECURITY_ATTRIBUTES *sa,
 244         DWORD flags, IStream **out)
 245 {
 246     struct opc_filestream *stream;
 247     DWORD access, creation;
 248
 249     if (!filename || !out)
 250         return E_POINTER;
 251
 252     switch (io_mode)
 253     {
 254     case OPC_STREAM_IO_READ:
 255         access = GENERIC_READ;
 256         creation = OPEN_EXISTING;
 257         break;
 258     case OPC_STREAM_IO_WRITE:
 259         access = GENERIC_WRITE;
 260         creation = CREATE_ALWAYS;
 261         break;
 262     default:
 263         return E_INVALIDARG;
 264     }
 265
 266     if (!(stream = heap_alloc_zero(sizeof(*stream))))
 267         return E_OUTOFMEMORY;
 268
 269     stream->hfile = CreateFileW(filename, access, 0, sa, creation, flags, NULL);
 270     if (stream->hfile == INVALID_HANDLE_VALUE)
 271     {
 272         HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
 273         heap_free(stream);
 274         return hr;
 275     }
 276
 277     stream->IStream_iface.lpVtbl = &opc_filestream_vtbl;
 278     stream->refcount = 1;
 279
 280     *out = &stream->IStream_iface;
 281     TRACE("Created file stream %p.\n", *out);
 282     return S_OK;
 283 }
 284
 285 static HRESULT WINAPI opc_factory_QueryInterface(IOpcFactory *iface, REFIID iid, void **out)
 286 {
 287     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 288
 289     if (IsEqualIID(iid, &IID_IOpcFactory) ||
 290             IsEqualIID(iid, &IID_IUnknown))
 291     {
 292         *out = iface;
 293         IOpcFactory_AddRef(iface);
 294         return S_OK;
 295     }
 296
 297     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 298     return E_NOINTERFACE;
 299 }
 300
 301 static ULONG WINAPI opc_factory_AddRef(IOpcFactory *iface)
 302 {
 303     return 2;
 304 }
 305
 306 static ULONG WINAPI opc_factory_Release(IOpcFactory *iface)
 307 {
 308     return 1;
 309 }
 310
 311 static HRESULT WINAPI opc_factory_CreatePackageRootUri(IOpcFactory *iface, IOpcUri **uri)
 312 {
 313     TRACE("iface %p, uri %p.\n", iface, uri);
 314
 315     if (!uri)
 316         return E_POINTER;
 317
 318     return opc_root_uri_create(uri);
 319 }
 320
 321 static HRESULT WINAPI opc_factory_CreatePartUri(IOpcFactory *iface, LPCWSTR uri, IOpcPartUri **out)
 322 {
 323     static const WCHAR rootW[] = {'/',0};
 324     IUri *part_uri, *root_uri, *combined;
 325     HRESULT hr;
 326
 327     TRACE("iface %p, uri %s, out %p.\n", iface, debugstr_w(uri), out);
 328
 329     if (!out)
 330         return E_POINTER;
 331
 332     *out = NULL;
 333
 334     if (FAILED(hr = CreateUri(uri, Uri_CREATE_ALLOW_RELATIVE, 0, &part_uri)))
 335     {
 336         WARN("Failed to create uri, hr %#x.\n", hr);
 337         return hr;
 338     }
 339
 340     if (FAILED(hr = CreateUri(rootW, Uri_CREATE_ALLOW_RELATIVE, 0, &root_uri)))
 341     {
 342         WARN("Failed to create root uri, hr %#x.\n", hr);
 343         IUri_Release(part_uri);
 344         return hr;
 345     }
 346
 347     hr = CoInternetCombineIUri(root_uri, part_uri, 0, &combined, 0);
 348     IUri_Release(root_uri);
 349     IUri_Release(part_uri);
 350     if (FAILED(hr))
 351     {
 352         WARN("Failed to combine URIs, hr %#x.\n", hr);
 353         return hr;
 354     }
 355
 356     hr = opc_part_uri_create(combined, NULL, out);
 357     IUri_Release(combined);
 358     return hr;
 359 }
 360
 361 static HRESULT WINAPI opc_factory_CreateStreamOnFile(IOpcFactory *iface, LPCWSTR filename,
 362         OPC_STREAM_IO_MODE io_mode, SECURITY_ATTRIBUTES *sa, DWORD flags, IStream **stream)
 363 {
 364     TRACE("iface %p, filename %s, io_mode %d, sa %p, flags %#x, stream %p.\n", iface, debugstr_w(filename),
 365             io_mode, sa, flags, stream);
 366
 367     return opc_filestream_create(filename, io_mode, sa, flags, stream);
 368 }
 369
 370 static HRESULT WINAPI opc_factory_CreatePackage(IOpcFactory *iface, IOpcPackage **package)
 371 {
 372     TRACE("iface %p, package %p.\n", iface, package);
 373
 374     return opc_package_create(iface, package);
 375 }
 376
 377 static HRESULT WINAPI opc_factory_ReadPackageFromStream(IOpcFactory *iface, IStream *stream,
 378         OPC_READ_FLAGS flags, IOpcPackage **package)
 379 {
 380     FIXME("iface %p, stream %p, flags %#x, package %p stub!\n", iface, stream, flags, package);
 381
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI opc_factory_WritePackageToStream(IOpcFactory *iface, IOpcPackage *package, OPC_WRITE_FLAGS flags,
 386         IStream *stream)
 387 {
 388     TRACE("iface %p, package %p, flags %#x, stream %p.\n", iface, package, flags, stream);
 389
 390     if (!package || !stream)
 391         return E_POINTER;
 392
 393     return opc_package_write(package, flags, stream);
 394 }
 395
 396 static HRESULT WINAPI opc_factory_CreateDigitalSignatureManager(IOpcFactory *iface, IOpcPackage *package,
 397         IOpcDigitalSignatureManager **signature_manager)
 398 {
 399     FIXME("iface %p, package %p, signature_manager %p stub!\n", iface, package, signature_manager);
 400
 401     return E_NOTIMPL;
 402 }
 403
 404 static const IOpcFactoryVtbl opc_factory_vtbl =
 405 {
 406     opc_factory_QueryInterface,
 407     opc_factory_AddRef,
 408     opc_factory_Release,
 409     opc_factory_CreatePackageRootUri,
 410     opc_factory_CreatePartUri,
 411     opc_factory_CreateStreamOnFile,
 412     opc_factory_CreatePackage,
 413     opc_factory_ReadPackageFromStream,
 414     opc_factory_WritePackageToStream,
 415     opc_factory_CreateDigitalSignatureManager,
 416 };
 417
 418 static IOpcFactory opc_factory = { &opc_factory_vtbl };
 419
 420 static HRESULT WINAPI opc_class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
 421 {
 422     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 423
 424     if (IsEqualGUID(iid, &IID_IClassFactory) ||
 425             IsEqualGUID(iid, &IID_IUnknown))
 426     {
 427         IClassFactory_AddRef(iface);
 428         *out = iface;
 429         return S_OK;
 430     }
 431
 432     *out = NULL;
 433     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 434     return E_NOINTERFACE;
 435 }
 436
 437 static ULONG WINAPI opc_class_factory_AddRef(IClassFactory *iface)
 438 {
 439     return 2;
 440 }
 441
 442 static ULONG WINAPI opc_class_factory_Release(IClassFactory *iface)
 443 {
 444     return 1;
 445 }
 446
 447 static HRESULT WINAPI opc_class_factory_CreateInstance(IClassFactory *iface,
 448         IUnknown *outer, REFIID iid, void **out)
 449 {
 450     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 451
 452     if (outer)
 453         return CLASS_E_NOAGGREGATION;
 454
 455     return IOpcFactory_QueryInterface(&opc_factory, iid, out);
 456 }
 457
 458 static HRESULT WINAPI opc_class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 459 {
 460     FIXME("iface %p, dolock %d stub!\n", iface, dolock);
 461     return S_OK;
 462 }
 463
 464 static const struct IClassFactoryVtbl opc_class_factory_vtbl =
 465 {
 466     opc_class_factory_QueryInterface,
 467     opc_class_factory_AddRef,
 468     opc_class_factory_Release,
 469     opc_class_factory_CreateInstance,
 470     opc_class_factory_LockServer
 471 };
 472
 473 static IClassFactory opc_class_factory = { &opc_class_factory_vtbl };
 474
 475 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 476 {
 477     TRACE("clsid %s, iid %s, out %p\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 478
 479     if (IsEqualCLSID(clsid, &CLSID_OpcFactory))
 480         return IClassFactory_QueryInterface(&opc_class_factory, iid, out);
 481
 482     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
 483     return E_NOTIMPL;
 484 }
 485
 486 HRESULT WINAPI DllCanUnloadNow(void)
 487 {
 488     return S_FALSE;
 489 }
 490
 491 static HINSTANCE OPC_hInstance;
 492
 493 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD reason, void *reserved)
 494 {
 495     OPC_hInstance = hInstDLL;
 496
 497     switch (reason)
 498     {
 499     case DLL_PROCESS_ATTACH:
 500         DisableThreadLibraryCalls(hInstDLL);
 501         break;
 502     }
 503     return TRUE;
 504 }
 505
 506 HRESULT WINAPI DllRegisterServer(void)
 507 {
 508     return __wine_register_resources( OPC_hInstance );
 509 }
 510
 511 HRESULT WINAPI DllUnregisterServer(void)
 512 {
 513     return __wine_unregister_resources( OPC_hInstance );
 514 }