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     return IUri_IsEqual(uri->uri, comparand, is_equal);
 316 }
 317
 318 static HRESULT WINAPI opc_uri_GetRelationshipsPartUri(IOpcPartUri *iface, IOpcPartUri **part_uri)
 319 {
 320     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 321
 322     TRACE("iface %p, part_uri %p.\n", iface, part_uri);
 323
 324     if (!part_uri)
 325         return E_POINTER;
 326
 327     if (!uri->rels_part_uri)
 328     {
 329         *part_uri = NULL;
 330         return OPC_E_NONCONFORMING_URI;
 331     }
 332
 333     return opc_part_uri_create(uri->rels_part_uri, uri, part_uri);
 334 }
 335
 336 static HRESULT WINAPI opc_uri_GetRelativeUri(IOpcPartUri *iface, IOpcPartUri *part_uri,
 337         IUri **relative_uri)
 338 {
 339     FIXME("iface %p, part_uri %p, relative_uri %p stub!\n", iface, part_uri, relative_uri);
 340
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI opc_uri_CombinePartUri(IOpcPartUri *iface, IUri *relative_uri, IOpcPartUri **combined)
 345 {
 346     FIXME("iface %p, relative_uri %p, combined %p stub!\n", iface, relative_uri, combined);
 347
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI opc_uri_ComparePartUri(IOpcPartUri *iface, IOpcPartUri *part_uri,
 352         INT32 *result)
 353 {
 354     FIXME("iface %p, part_uri %p, result %p stub!\n", iface, part_uri, result);
 355
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI opc_uri_GetSourceUri(IOpcPartUri *iface, IOpcUri **source_uri)
 360 {
 361     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 362
 363     TRACE("iface %p, source_uri %p.\n", iface, source_uri);
 364
 365     return opc_source_uri_create(uri, source_uri);
 366 }
 367
 368 static HRESULT WINAPI opc_uri_IsRelationshipsPartUri(IOpcPartUri *iface, BOOL *result)
 369 {
 370     struct opc_uri *uri = impl_from_IOpcPartUri(iface);
 371
 372     TRACE("iface %p, result %p.\n", iface, result);
 373
 374     if (!result)
 375         return E_POINTER;
 376
 377     *result = !uri->rels_part_uri;
 378
 379     return S_OK;
 380 }
 381
 382 static const IOpcPartUriVtbl opc_part_uri_vtbl =
 383 {
 384     opc_uri_QueryInterface,
 385     opc_uri_AddRef,
 386     opc_uri_Release,
 387     opc_uri_GetPropertyBSTR,
 388     opc_uri_GetPropertyLength,
 389     opc_uri_GetPropertyDWORD,
 390     opc_uri_HasProperty,
 391     opc_uri_GetAbsoluteUri,
 392     opc_uri_GetAuthority,
 393     opc_uri_GetDisplayUri,
 394     opc_uri_GetDomain,
 395     opc_uri_GetExtension,
 396     opc_uri_GetFragment,
 397     opc_uri_GetHost,
 398     opc_uri_GetPassword,
 399     opc_uri_GetPath,
 400     opc_uri_GetPathAndQuery,
 401     opc_uri_GetQuery,
 402     opc_uri_GetRawUri,
 403     opc_uri_GetSchemeName,
 404     opc_uri_GetUserInfo,
 405     opc_uri_GetUserName,
 406     opc_uri_GetHostType,
 407     opc_uri_GetPort,
 408     opc_uri_GetScheme,
 409     opc_uri_GetZone,
 410     opc_uri_GetProperties,
 411     opc_uri_IsEqual,
 412     opc_uri_GetRelationshipsPartUri,
 413     opc_uri_GetRelativeUri,
 414     opc_uri_CombinePartUri,
 415     opc_uri_ComparePartUri,
 416     opc_uri_GetSourceUri,
 417     opc_uri_IsRelationshipsPartUri,
 418 };
 419
 420 static IUri *opc_part_uri_get_rels_uri(IUri *uri)
 421 {
 422     static const WCHAR relsdirW[] = {'/','_','r','e','l','s',0};
 423     static const WCHAR relsextW[] = {'.','r','e','l','s',0};
 424     WCHAR *start = NULL, *end, *ret;
 425     IUri *rels_uri;
 426     HRESULT hr;
 427     DWORD len;
 428     BSTR path;
 429
 430     if (FAILED(IUri_GetPath(uri, &path)))
 431         return NULL;
 432
 433     if (FAILED(IUri_GetPropertyLength(uri, Uri_PROPERTY_PATH, &len, 0)))
 434     {
 435         SysFreeString(path);
 436         return NULL;
 437     }
 438
 439     end = strrchrW(path, '/');
 440     if (end && end >= path + ARRAY_SIZE(relsdirW) - 1)
 441         start = end - ARRAY_SIZE(relsdirW) + 1;
 442     if (!start)
 443         start = end;
 444
 445     /* Test if it's already relationships uri. */
 446     if (len > ARRAY_SIZE(relsextW))
 447     {
 448         if (!strcmpW(path + len - ARRAY_SIZE(relsextW) + 1, relsextW))
 449         {
 450             if (start && !memcmp(start, relsdirW, ARRAY_SIZE(relsdirW) - sizeof(WCHAR)))
 451             {
 452                 SysFreeString(path);
 453                 return NULL;
 454             }
 455         }
 456     }
 457
 458     ret = heap_alloc((len + ARRAY_SIZE(relsextW) + ARRAY_SIZE(relsdirW)) * sizeof(WCHAR));
 459     if (!ret)
 460     {
 461         SysFreeString(path);
 462         return NULL;
 463     }
 464     ret[0] = 0;
 465
 466     if (start != path)
 467     {
 468         memcpy(ret, path, (start - path) * sizeof(WCHAR));
 469         ret[start - path] = 0;
 470     }
 471
 472     strcatW(ret, relsdirW);
 473     strcatW(ret, end);
 474     strcatW(ret, relsextW);
 475
 476     if (FAILED(hr = CreateUri(ret, Uri_CREATE_ALLOW_RELATIVE, 0, &rels_uri)))
 477         WARN("Failed to create rels uri, hr %#x.\n", hr);
 478     heap_free(ret);
 479
 480     return rels_uri;
 481 }
 482
 483 static HRESULT opc_part_uri_init(struct opc_uri *object, struct opc_uri *source_uri, BOOL is_part_uri, IUri *uri)
 484 {
 485     object->IOpcPartUri_iface.lpVtbl = &opc_part_uri_vtbl;
 486     object->refcount = 1;
 487     object->is_part_uri = is_part_uri;
 488     object->uri = uri;
 489     IUri_AddRef(object->uri);
 490     object->rels_part_uri = opc_part_uri_get_rels_uri(object->uri);
 491     object->source_uri = source_uri;
 492     if (object->source_uri)
 493         IOpcPartUri_AddRef(&object->source_uri->IOpcPartUri_iface);
 494
 495     return S_OK;
 496 }
 497
 498 static HRESULT opc_source_uri_create(struct opc_uri *uri, IOpcUri **out)
 499 {
 500     struct opc_uri *obj;
 501     HRESULT hr;
 502
 503     if (!out)
 504         return E_POINTER;
 505
 506     *out = NULL;
 507
 508     if (!uri->source_uri)
 509         return OPC_E_RELATIONSHIP_URI_REQUIRED;
 510
 511     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 512         return E_OUTOFMEMORY;
 513
 514     if (FAILED(hr = opc_part_uri_init(obj, NULL, uri->source_uri->is_part_uri, uri->source_uri->uri)))
 515     {
 516         WARN("Failed to init part uri, hr %#x.\n", hr);
 517         heap_free(obj);
 518         return hr;
 519     }
 520
 521     *out = (IOpcUri *)&obj->IOpcPartUri_iface;
 522
 523     TRACE("Created source uri %p.\n", *out);
 524
 525     return S_OK;
 526 }
 527
 528 HRESULT opc_part_uri_create(IUri *uri, struct opc_uri *source_uri, IOpcPartUri **out)
 529 {
 530     struct opc_uri *obj;
 531     HRESULT hr;
 532
 533     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 534         return E_OUTOFMEMORY;
 535
 536     if (FAILED(hr = opc_part_uri_init(obj, source_uri, TRUE, uri)))
 537     {
 538         WARN("Failed to init part uri, hr %#x.\n", hr);
 539         heap_free(obj);
 540         return hr;
 541     }
 542
 543     *out = &obj->IOpcPartUri_iface;
 544     TRACE("Created part uri %p.\n", *out);
 545     return S_OK;
 546 }
 547
 548 HRESULT opc_root_uri_create(IOpcUri **out)
 549 {
 550     static const WCHAR rootW[] = {'/',0};
 551     struct opc_uri *obj;
 552     HRESULT hr;
 553     IUri *uri;
 554
 555     *out = NULL;
 556
 557     if (!(obj = heap_alloc_zero(sizeof(*obj))))
 558         return E_OUTOFMEMORY;
 559
 560     if (FAILED(hr = CreateUri(rootW, Uri_CREATE_ALLOW_RELATIVE, 0, &uri)))
 561     {
 562         WARN("Failed to create rels uri, hr %#x.\n", hr);
 563         heap_free(obj);
 564         return hr;
 565     }
 566
 567     hr = opc_part_uri_init(obj, NULL, FALSE, uri);
 568     IUri_Release(uri);
 569     if (FAILED(hr))
 570     {
 571         WARN("Failed to init uri, hr %#x.\n", hr);
 572         heap_free(uri);
 573         return hr;
 574     }
 575
 576     *out = (IOpcUri *)&obj->IOpcPartUri_iface;
 577     TRACE("Created part uri %p.\n", *out);
 578     return S_OK;
 579 }