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     IUri *part_uri, *root_uri, *combined;
 324     HRESULT hr;
 325
 326     TRACE("iface %p, uri %s, out %p.\n", iface, debugstr_w(uri), out);
 327
 328     if (!out)
 329         return E_POINTER;
 330
 331     *out = NULL;
 332
 333     if (FAILED(hr = CreateUri(uri, Uri_CREATE_ALLOW_RELATIVE, 0, &part_uri)))
 334     {
 335         WARN("Failed to create uri, hr %#x.\n", hr);
 336         return hr;
 337     }
 338
 339     if (FAILED(hr = CreateUri(L"/", Uri_CREATE_ALLOW_RELATIVE, 0, &root_uri)))
 340     {
 341         WARN("Failed to create root uri, hr %#x.\n", hr);
 342         IUri_Release(part_uri);
 343         return hr;
 344     }
 345
 346     hr = CoInternetCombineIUri(root_uri, part_uri, 0, &combined, 0);
 347     IUri_Release(root_uri);
 348     IUri_Release(part_uri);
 349     if (FAILED(hr))
 350     {
 351         WARN("Failed to combine URIs, hr %#x.\n", hr);
 352         return hr;
 353     }
 354
 355     hr = opc_part_uri_create(combined, NULL, out);
 356     IUri_Release(combined);
 357     return hr;
 358 }
 359
 360 static HRESULT WINAPI opc_factory_CreateStreamOnFile(IOpcFactory *iface, LPCWSTR filename,
 361         OPC_STREAM_IO_MODE io_mode, SECURITY_ATTRIBUTES *sa, DWORD flags, IStream **stream)
 362 {
 363     TRACE("iface %p, filename %s, io_mode %d, sa %p, flags %#x, stream %p.\n", iface, debugstr_w(filename),
 364             io_mode, sa, flags, stream);
 365
 366     return opc_filestream_create(filename, io_mode, sa, flags, stream);
 367 }
 368
 369 static HRESULT WINAPI opc_factory_CreatePackage(IOpcFactory *iface, IOpcPackage **package)
 370 {
 371     TRACE("iface %p, package %p.\n", iface, package);
 372
 373     return opc_package_create(iface, package);
 374 }
 375
 376 static HRESULT WINAPI opc_factory_ReadPackageFromStream(IOpcFactory *iface, IStream *stream,
 377         OPC_READ_FLAGS flags, IOpcPackage **package)
 378 {
 379     FIXME("iface %p, stream %p, flags %#x, package %p stub!\n", iface, stream, flags, package);
 380
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI opc_factory_WritePackageToStream(IOpcFactory *iface, IOpcPackage *package, OPC_WRITE_FLAGS flags,
 385         IStream *stream)
 386 {
 387     TRACE("iface %p, package %p, flags %#x, stream %p.\n", iface, package, flags, stream);
 388
 389     if (!package || !stream)
 390         return E_POINTER;
 391
 392     return opc_package_write(package, flags, stream);
 393 }
 394
 395 static HRESULT WINAPI opc_factory_CreateDigitalSignatureManager(IOpcFactory *iface, IOpcPackage *package,
 396         IOpcDigitalSignatureManager **signature_manager)
 397 {
 398     FIXME("iface %p, package %p, signature_manager %p stub!\n", iface, package, signature_manager);
 399
 400     return E_NOTIMPL;
 401 }
 402
 403 static const IOpcFactoryVtbl opc_factory_vtbl =
 404 {
 405     opc_factory_QueryInterface,
 406     opc_factory_AddRef,
 407     opc_factory_Release,
 408     opc_factory_CreatePackageRootUri,
 409     opc_factory_CreatePartUri,
 410     opc_factory_CreateStreamOnFile,
 411     opc_factory_CreatePackage,
 412     opc_factory_ReadPackageFromStream,
 413     opc_factory_WritePackageToStream,
 414     opc_factory_CreateDigitalSignatureManager,
 415 };
 416
 417 static IOpcFactory opc_factory = { &opc_factory_vtbl };
 418
 419 static HRESULT WINAPI opc_class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
 420 {
 421     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 422
 423     if (IsEqualGUID(iid, &IID_IClassFactory) ||
 424             IsEqualGUID(iid, &IID_IUnknown))
 425     {
 426         IClassFactory_AddRef(iface);
 427         *out = iface;
 428         return S_OK;
 429     }
 430
 431     *out = NULL;
 432     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 433     return E_NOINTERFACE;
 434 }
 435
 436 static ULONG WINAPI opc_class_factory_AddRef(IClassFactory *iface)
 437 {
 438     return 2;
 439 }
 440
 441 static ULONG WINAPI opc_class_factory_Release(IClassFactory *iface)
 442 {
 443     return 1;
 444 }
 445
 446 static HRESULT WINAPI opc_class_factory_CreateInstance(IClassFactory *iface,
 447         IUnknown *outer, REFIID iid, void **out)
 448 {
 449     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 450
 451     if (outer)
 452         return CLASS_E_NOAGGREGATION;
 453
 454     return IOpcFactory_QueryInterface(&opc_factory, iid, out);
 455 }
 456
 457 static HRESULT WINAPI opc_class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 458 {
 459     FIXME("iface %p, dolock %d stub!\n", iface, dolock);
 460     return S_OK;
 461 }
 462
 463 static const struct IClassFactoryVtbl opc_class_factory_vtbl =
 464 {
 465     opc_class_factory_QueryInterface,
 466     opc_class_factory_AddRef,
 467     opc_class_factory_Release,
 468     opc_class_factory_CreateInstance,
 469     opc_class_factory_LockServer
 470 };
 471
 472 static IClassFactory opc_class_factory = { &opc_class_factory_vtbl };
 473
 474 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 475 {
 476     TRACE("clsid %s, iid %s, out %p\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 477
 478     if (IsEqualCLSID(clsid, &CLSID_OpcFactory))
 479         return IClassFactory_QueryInterface(&opc_class_factory, iid, out);
 480
 481     WARN("Unsupported class %s.\n", debugstr_guid(clsid));
 482     return E_NOTIMPL;
 483 }