dlls/opcservices/uri.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 "wine/debug.h"
  26 #include "wine/unicode.h"
  27
  28 #include "opc_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msopc);
  31
  32 static inline struct opc_uri *impl_from_IOpcPartUri(IOpcPartUri *iface)
  33 {
  34     return CONTAINING_RECORD(iface, struct opc_uri, IOpcPartUri_iface);
  35 }
  36
  37 static HRESULT opc_source_uri_create(struct opc_uri *uri, IOpcUri **out);
  38
  39 static HRESULT WINAPI opc_uri_QueryInterface(IOpcPartUri *iface, REFIID iid, void **out)
  40 {
  41     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
  42
  43     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  44
  45     if ((uri->is_part_uri && IsEqualIID(iid, &IID_IOpcPartUri)) ||
  46             IsEqualIID(iid, &IID_IOpcUri) ||
  47             IsEqualIID(iid, &IID_IUri) ||
  48             IsEqualIID(iid, &IID_IUnknown))
  49     {
  50         *out = iface;
  51         IOpcPartUri_AddRef(iface);
  52         return S_OK;
  53     }
  54
  55     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
  56     return E_NOINTERFACE;
  57 }
  58
  59 static ULONG WINAPI opc_uri_AddRef(IOpcPartUri *iface)
  60 {
  61     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
  62     ULONG refcount = InterlockedIncrement(&uri->refcount);
  63
  64     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  65
  66     return refcount;
  67 }
  68
  69 static ULONG WINAPI opc_uri_Release(IOpcPartUri *iface)
  70 {
  71     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
  72     ULONG refcount = InterlockedDecrement(&uri->refcount);
  73
  74     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  75
  76     if (!refcount)
  77     {
  78         if (uri->rels_part_uri)
  79             IUri_Release(uri->rels_part_uri);
  80         if (uri->source_uri)
  81             IOpcPartUri_Release(&uri->source_uri->IOpcPartUri_iface);
  82         IUri_Release(uri->uri);
  83         heap_free(uri);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 static HRESULT WINAPI opc_uri_GetPropertyBSTR(IOpcPartUri *iface, Uri_PROPERTY property,
  90         BSTR *value, DWORD flags)
  91 {
  92     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
  93
  94     TRACE("iface %p, property %d, value %p, flags %#x.\n", iface, property, value, flags);
  95
  96     return IUri_GetPropertyBSTR(uri->uri, property, value, flags);
  97 }
  98
  99 static HRESULT WINAPI opc_uri_GetPropertyLength(IOpcPartUri *iface, Uri_PROPERTY property,
 100         DWORD *length, DWORD flags)
 101 {
 102     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 103
 104     TRACE("iface %p, property %d, length %p, flags %#x.\n", iface, property, length, flags);
 105
 106     return IUri_GetPropertyLength(uri->uri, property, length, flags);
 107 }
 108
 109 static HRESULT WINAPI opc_uri_GetPropertyDWORD(IOpcPartUri *iface, Uri_PROPERTY property,
 110         DWORD *value, DWORD flags)
 111 {
 112     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 113
 114     TRACE("iface %p, property %d, value %p, flags %#x.\n", iface, property, value, flags);
 115
 116     return IUri_GetPropertyDWORD(uri->uri, property, value, flags);
 117 }
 118
 119 static HRESULT WINAPI opc_uri_HasProperty(IOpcPartUri *iface, Uri_PROPERTY property,
 120         BOOL *has_property)
 121 {
 122     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 123
 124     TRACE("iface %p, property %d, has_property %p.\n", iface, property, has_property);
 125
 126     return IUri_HasProperty(uri->uri, property, has_property);
 127 }
 128
 129 static HRESULT WINAPI opc_uri_GetAbsoluteUri(IOpcPartUri *iface, BSTR *value)
 130 {
 131     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 132
 133     TRACE("iface %p, value %p.\n", iface, value);
 134
 135     return IUri_GetAbsoluteUri(uri->uri, value);
 136 }
 137
 138 static HRESULT WINAPI opc_uri_GetAuthority(IOpcPartUri *iface, BSTR *value)
 139 {
 140     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 141
 142     TRACE("iface %p, value %p.\n", iface, value);
 143
 144     return IUri_GetAuthority(uri->uri, value);
 145 }
 146
 147 static HRESULT WINAPI opc_uri_GetDisplayUri(IOpcPartUri *iface, BSTR *value)
 148 {
 149     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 150
 151     TRACE("iface %p, value %p.\n", iface, value);
 152
 153     return IUri_GetDisplayUri(uri->uri, value);
 154 }
 155
 156 static HRESULT WINAPI opc_uri_GetDomain(IOpcPartUri *iface, BSTR *value)
 157 {
 158     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 159
 160     TRACE("iface %p, value %p.\n", iface, value);
 161
 162     return IUri_GetDomain(uri->uri, value);
 163 }
 164
 165 static HRESULT WINAPI opc_uri_GetExtension(IOpcPartUri *iface, BSTR *value)
 166 {
 167     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 168
 169     TRACE("iface %p, value %p.\n", iface, value);
 170
 171     return IUri_GetExtension(uri->uri, value);
 172 }
 173
 174 static HRESULT WINAPI opc_uri_GetFragment(IOpcPartUri *iface, BSTR *value)
 175 {
 176     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 177
 178     TRACE("iface %p, value %p.\n", iface, value);
 179
 180     return IUri_GetFragment(uri->uri, value);
 181 }
 182
 183 static HRESULT WINAPI opc_uri_GetHost(IOpcPartUri *iface, BSTR *value)
 184 {
 185     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 186
 187     TRACE("iface %p, value %p.\n", iface, value);
 188
 189     return IUri_GetHost(uri->uri, value);
 190 }
 191
 192 static HRESULT WINAPI opc_uri_GetPassword(IOpcPartUri *iface, BSTR *value)
 193 {
 194     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 195
 196     TRACE("iface %p, value %p.\n", iface, value);
 197
 198     return IUri_GetPassword(uri->uri, value);
 199 }
 200
 201 static HRESULT WINAPI opc_uri_GetPath(IOpcPartUri *iface, BSTR *value)
 202 {
 203     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 204
 205     TRACE("iface %p, value %p.\n", iface, value);
 206
 207     return IUri_GetPath(uri->uri, value);
 208 }
 209
 210 static HRESULT WINAPI opc_uri_GetPathAndQuery(IOpcPartUri *iface, BSTR *value)
 211 {
 212     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 213
 214     TRACE("iface %p, value %p.\n", iface, value);
 215
 216     return IUri_GetPathAndQuery(uri->uri, value);
 217 }
 218
 219 static HRESULT WINAPI opc_uri_GetQuery(IOpcPartUri *iface, BSTR *value)
 220 {
 221     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 222
 223     TRACE("iface %p, value %p.\n", iface, value);
 224
 225     return IUri_GetQuery(uri->uri, value);
 226 }
 227
 228 static HRESULT WINAPI opc_uri_GetRawUri(IOpcPartUri *iface, BSTR *value)
 229 {
 230     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 231
 232     TRACE("iface %p, value %p.\n", iface, value);
 233
 234     return IUri_GetRawUri(uri->uri, value);
 235 }
 236
 237 static HRESULT WINAPI opc_uri_GetSchemeName(IOpcPartUri *iface, BSTR *value)
 238 {
 239     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 240
 241     TRACE("iface %p, value %p.\n", iface, value);
 242
 243     return IUri_GetSchemeName(uri->uri, value);
 244 }
 245
 246 static HRESULT WINAPI opc_uri_GetUserInfo(IOpcPartUri *iface, BSTR *value)
 247 {
 248     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 249
 250     TRACE("iface %p, value %p.\n", iface, value);
 251
 252     return IUri_GetUserInfo(uri->uri, value);
 253 }
 254
 255 static HRESULT WINAPI opc_uri_GetUserName(IOpcPartUri *iface, BSTR *value)
 256 {
 257     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 258
 259     TRACE("iface %p, value %p.\n", iface, value);
 260
 261     return IUri_GetUserName(uri->uri, value);
 262 }
 263
 264 static HRESULT WINAPI opc_uri_GetHostType(IOpcPartUri *iface, DWORD *value)
 265 {
 266     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 267
 268     TRACE("iface %p, value %p.\n", iface, value);
 269
 270     return IUri_GetHostType(uri->uri, value);
 271 }
 272
 273 static HRESULT WINAPI opc_uri_GetPort(IOpcPartUri *iface, DWORD *value)
 274 {
 275     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 276
 277     TRACE("iface %p, value %p.\n", iface, value);
 278
 279     return IUri_GetPort(uri->uri, value);
 280 }
 281
 282 static HRESULT WINAPI opc_uri_GetScheme(IOpcPartUri *iface, DWORD *value)
 283 {
 284     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 285
 286     TRACE("iface %p, value %p.\n", iface, value);
 287
 288     return IUri_GetScheme(uri->uri, value);
 289 }
 290
 291 static HRESULT WINAPI opc_uri_GetZone(IOpcPartUri *iface, DWORD *value)
 292 {
 293     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 294
 295     TRACE("iface %p, value %p.\n", iface, value);
 296
 297     return IUri_GetZone(uri->uri, value);
 298 }
 299
 300 static HRESULT WINAPI opc_uri_GetProperties(IOpcPartUri *iface, DWORD *flags)
 301 {
 302     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 303
 304     TRACE("iface %p, flags %p.\n", iface, flags);
 305
 306     return IUri_GetProperties(uri->uri, flags);
 307 }
 308
 309 static HRESULT WINAPI opc_uri_IsEqual(IOpcPartUri *iface, IUri *comparand, BOOL *is_equal)
 310 {
 311     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 312
 313     TRACE("iface %p, comparand %p, is_equal %p.\n", iface, comparand, is_equal);
 314
 315     if (!is_equal)
 316         return E_POINTER;
 317
 318     if (!comparand)
 319     {
 320         if (uri->is_part_uri)
 321         {
 322             *is_equal = FALSE;
 323             return S_OK;
 324         }
 325
 326         return E_POINTER;
 327     }
 328
 329     return IUri_IsEqual(comparand, uri->uri, is_equal);
 330 }
 331
 332 static HRESULT WINAPI opc_uri_GetRelationshipsPartUri(IOpcPartUri *iface, IOpcPartUri **part_uri)
 333 {
 334     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 335
 336     TRACE("iface %p, part_uri %p.\n", iface, part_uri);
 337
 338     if (!part_uri)
 339         return E_POINTER;
 340
 341     if (!uri->rels_part_uri)
 342     {
 343         *part_uri = NULL;
 344         return OPC_E_NONCONFORMING_URI;
 345     }
 346
 347     return opc_part_uri_create(uri->rels_part_uri, uri, part_uri);
 348 }
 349
 350 static HRESULT WINAPI opc_uri_GetRelativeUri(IOpcPartUri *iface, IOpcPartUri *part_uri,
 351         IUri **relative_uri)
 352 {
 353     FIXME("iface %p, part_uri %p, relative_uri %p stub!\n", iface, part_uri, relative_uri);
 354
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI opc_uri_CombinePartUri(IOpcPartUri *iface, IUri *relative_uri, IOpcPartUri **combined)
 359 {
 360     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 361     IUri *combined_uri;
 362     HRESULT hr;
 363
 364     TRACE("iface %p, relative_uri %p, combined %p.\n", iface, relative_uri, combined);
 365
 366     if (!combined)
 367         return E_POINTER;
 368
 369     *combined = NULL;
 370
 371     if (!relative_uri)
 372         return E_POINTER;
 373
 374     if (FAILED(hr = CoInternetCombineIUri(uri->uri, relative_uri, 0, &combined_uri, 0)))
 375         return hr;
 376
 377     hr = opc_part_uri_create(combined_uri, NULL, combined);
 378     IUri_Release(combined_uri);
 379     return hr;
 380 }
 381
 382 static HRESULT WINAPI opc_uri_ComparePartUri(IOpcPartUri *iface, IOpcPartUri *part_uri,
 383         INT32 *result)
 384 {
 385     FIXME("iface %p, part_uri %p, result %p stub!\n", iface, part_uri, result);
 386
 387     return E_NOTIMPL;
 388 }
 389
 390 static HRESULT WINAPI opc_uri_GetSourceUri(IOpcPartUri *iface, IOpcUri **source_uri)
 391 {
 392     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 393
 394     TRACE("iface %p, source_uri %p.\n", iface, source_uri);
 395
 396     return opc_source_uri_create(uri, source_uri);
 397 }
 398
 399 static HRESULT WINAPI opc_uri_IsRelationshipsPartUri(IOpcPartUri *iface, BOOL *result)
 400 {
 401     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 402
 403     TRACE("iface %p, result %p.\n", iface, result);
 404
 405     if (!result)
 406         return E_POINTER;
 407
 408     *result = !uri->rels_part_uri;
 409
 410     return S_OK;
 411 }
 412
 413 static const IOpcPartUriVtbl opc_part_uri_vtbl =
 414 {
 415     opc_uri_QueryInterface,
 416     opc_uri_AddRef,
 417     opc_uri_Release,
 418     opc_uri_GetPropertyBSTR,
 419     opc_uri_GetPropertyLength,
 420     opc_uri_GetPropertyDWORD,
 421     opc_uri_HasProperty,
 422     opc_uri_GetAbsoluteUri,
 423     opc_uri_GetAuthority,
 424     opc_uri_GetDisplayUri,
 425     opc_uri_GetDomain,
 426     opc_uri_GetExtension,
 427     opc_uri_GetFragment,
 428     opc_uri_GetHost,
 429     opc_uri_GetPassword,
 430     opc_uri_GetPath,
 431     opc_uri_GetPathAndQuery,
 432     opc_uri_GetQuery,
 433     opc_uri_GetRawUri,
 434     opc_uri_GetSchemeName,
 435     opc_uri_GetUserInfo,
 436     opc_uri_GetUserName,
 437     opc_uri_GetHostType,
 438     opc_uri_GetPort,
 439     opc_uri_GetScheme,
 440     opc_uri_GetZone,
 441     opc_uri_GetProperties,
 442     opc_uri_IsEqual,
 443     opc_uri_GetRelationshipsPartUri,
 444     opc_uri_GetRelativeUri,
 445     opc_uri_CombinePartUri,
 446     opc_uri_ComparePartUri,
 447     opc_uri_GetSourceUri,
 448     opc_uri_IsRelationshipsPartUri,
 449 };
 450
 451 static IUri *opc_part_uri_get_rels_uri(IUri *uri)
 452 {
 453     static const WCHAR relsdirW[] = {'/','_','r','e','l','s',0};
 454     static const WCHAR relsextW[] = {'.','r','e','l','s',0};
 455     WCHAR *start = NULL, *end, *ret;
 456     IUri *rels_uri;
 457     HRESULT hr;
 458     DWORD len;
 459     BSTR path;
 460
 461     if (FAILED(IUri_GetPath(uri, &path)))
 462         return NULL;
 463
 464     if (FAILED(IUri_GetPropertyLength(uri, Uri_PROPERTY_PATH, &len, 0)))
 465     {
 466         SysFreeString(path);
 467         return NULL;
 468     }
 469
 470     end = strrchrW(path, '/');
 471     if (end && end >= path + ARRAY_SIZE(relsdirW) - 1)
 472         start = end - ARRAY_SIZE(relsdirW) + 1;
 473     if (!start)
 474         start = end;
 475
 476     /* Test if it's already relationships uri. */
 477     if (len > ARRAY_SIZE(relsextW))
 478     {
 479         if (!strcmpW(path + len - ARRAY_SIZE(relsextW) + 1, relsextW))
 480         {
 481             if (start && !memcmp(start, relsdirW, ARRAY_SIZE(relsdirW) - sizeof(WCHAR)))
 482             {
 483                 SysFreeString(path);
 484                 return NULL;
 485             }
 486         }
 487     }
 488
 489     ret = heap_alloc((len + ARRAY_SIZE(relsextW) + ARRAY_SIZE(relsdirW)) * sizeof(WCHAR));
 490     if (!ret)
 491     {
 492         SysFreeString(path);
 493         return NULL;
 494     }
 495     ret[0] = 0;
 496
 497     if (start != path)
 498     {
 499         memcpy(ret, path, (start - path) * sizeof(WCHAR));
 500         ret[start - path] = 0;
 501     }
 502
 503     strcatW(ret, relsdirW);
 504     strcatW(ret, end);
 505     strcatW(ret, relsextW);
 506
 507     if (FAILED(hr = CreateUri(ret, Uri_CREATE_ALLOW_RELATIVE, 0, &rels_uri)))
 508         WARN("Failed to create rels uri, hr %#x.\n", hr);
 509     heap_free(ret);
 510     SysFreeString(path);
 511
 512     return rels_uri;
 513 }
 514
 515 static HRESULT opc_part_uri_init(struct opc_uri *object, struct opc_uri *source_uri, BOOL is_part_uri, IUri *uri)
 516 {
 517     object->IOpcPartUri_iface.lpVtbl = &opc_part_uri_vtbl;
 518     object->refcount = 1;
 519     object->is_part_uri = is_part_uri;
 520     object->uri = uri;
 521     IUri_AddRef(object->uri);
 522     object->rels_part_uri = opc_part_uri_get_rels_uri(object->uri);
 523     object->source_uri = source_uri;
 524     if (object->source_uri)
 525         IOpcPartUri_AddRef(&object->source_uri->IOpcPartUri_iface);
 526
 527     return S_OK;
 528 }
 529
 530 static HRESULT opc_source_uri_create(struct opc_uri *uri, IOpcUri **out)
 531 {
 532     struct opc_uri *obj;
 533     HRESULT hr;
 534
 535     if (!out)
 536         return E_POINTER;
 537
 538     *out = NULL;
 539
 540     if (!uri->source_uri)
 541         return OPC_E_RELATIONSHIP_URI_REQUIRED;
 542
 543     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 544         return E_OUTOFMEMORY;
 545
 546     if (FAILED(hr = opc_part_uri_init(obj, NULL, uri->source_uri->is_part_uri, uri->source_uri->uri)))
 547     {
 548         WARN("Failed to init part uri, hr %#x.\n", hr);
 549         heap_free(obj);
 550         return hr;
 551     }
 552
 553     *out = (IOpcUri *)&obj->IOpcPartUri_iface;
 554
 555     TRACE("Created source uri %p.\n", *out);
 556
 557     return S_OK;
 558 }
 559
 560 HRESULT opc_part_uri_create(IUri *uri, struct opc_uri *source_uri, IOpcPartUri **out)
 561 {
 562     struct opc_uri *obj;
 563     HRESULT hr;
 564
 565     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 566         return E_OUTOFMEMORY;
 567
 568     if (FAILED(hr = opc_part_uri_init(obj, source_uri, TRUE, uri)))
 569     {
 570         WARN("Failed to init part uri, hr %#x.\n", hr);
 571         heap_free(obj);
 572         return hr;
 573     }
 574
 575     *out = &obj->IOpcPartUri_iface;
 576     TRACE("Created part uri %p.\n", *out);
 577     return S_OK;
 578 }
 579
 580 HRESULT opc_root_uri_create(IOpcUri **out)
 581 {
 582     static const WCHAR rootW[] = {'/',0};
 583     struct opc_uri *obj;
 584     HRESULT hr;
 585     IUri *uri;
 586
 587     *out = NULL;
 588
 589     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 590         return E_OUTOFMEMORY;
 591
 592     if (FAILED(hr = CreateUri(rootW, Uri_CREATE_ALLOW_RELATIVE, 0, &uri)))
 593     {
 594         WARN("Failed to create rels uri, hr %#x.\n", hr);
 595         heap_free(obj);
 596         return hr;
 597     }
 598
 599     hr = opc_part_uri_init(obj, NULL, FALSE, uri);
 600     IUri_Release(uri);
 601     if (FAILED(hr))
 602     {
 603         WARN("Failed to init uri, hr %#x.\n", hr);
 604         heap_free(uri);
 605         return hr;
 606     }
 607
 608     *out = (IOpcUri *)&obj->IOpcPartUri_iface;
 609     TRACE("Created part uri %p.\n", *out);
 610     return S_OK;
 611 }