dlls/wsdapi/xml.c

   1 /*
   2  * Web Services on Devices
   3  *
   4  * Copyright 2017 Owen Rudge for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "wsdapi_internal.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(wsdapi);
  29
  30 LPWSTR duplicate_string(void *parentMemoryBlock, LPCWSTR value)
  31 {
  32     int valueLen;
  33     LPWSTR dup;
  34
  35     valueLen = lstrlenW(value) + 1;
  36
  37     dup = WSDAllocateLinkedMemory(parentMemoryBlock, valueLen * sizeof(WCHAR));
  38
  39     if (dup) memcpy(dup, value, valueLen * sizeof(WCHAR));
  40     return dup;
  41 }
  42
  43 static WSDXML_NAMESPACE *duplicate_namespace(void *parentMemoryBlock, WSDXML_NAMESPACE *ns)
  44 {
  45     WSDXML_NAMESPACE *newNs;
  46
  47     newNs = WSDAllocateLinkedMemory(parentMemoryBlock, sizeof(WSDXML_NAMESPACE));
  48
  49     if (newNs == NULL)
  50     {
  51         return NULL;
  52     }
  53
  54     newNs->Encoding = ns->Encoding;
  55
  56     /* On Windows, both Names and NamesCount are set to null even if there are names present */
  57     newNs->NamesCount = 0;
  58     newNs->Names = NULL;
  59
  60     newNs->PreferredPrefix = duplicate_string(newNs, ns->PreferredPrefix);
  61     newNs->Uri = duplicate_string(newNs, ns->Uri);
  62
  63     return newNs;
  64 }
  65
  66 WSDXML_NAME *duplicate_name(void *parentMemoryBlock, WSDXML_NAME *name)
  67 {
  68     WSDXML_NAME *dup;
  69
  70     dup = WSDAllocateLinkedMemory(parentMemoryBlock, sizeof(WSDXML_NAME));
  71
  72     if (dup == NULL)
  73     {
  74         return NULL;
  75     }
  76
  77     dup->Space = duplicate_namespace(dup, name->Space);
  78     dup->LocalName = duplicate_string(dup, name->LocalName);
  79
  80     if (dup->LocalName == NULL)
  81     {
  82         WSDFreeLinkedMemory(dup);
  83         return NULL;
  84     }
  85
  86     return dup;
  87 }
  88
  89 HRESULT WINAPI WSDXMLAddChild(WSDXML_ELEMENT *pParent, WSDXML_ELEMENT *pChild)
  90 {
  91     WSDXML_NODE *currentNode;
  92
  93     TRACE("(%p, %p)\n", pParent, pChild);
  94
  95     if ((pParent == NULL) || (pChild == NULL) || (pChild->Node.Parent != NULL))
  96     {
  97         return E_INVALIDARG;
  98     }
  99
 100     /* See if the parent already has a child */
 101     currentNode = pParent->FirstChild;
 102
 103     if (currentNode == NULL)
 104     {
 105         pParent->FirstChild = (WSDXML_NODE *)pChild;
 106     }
 107     else
 108     {
 109         /* Find the last sibling node and make this child the next sibling */
 110         WSDXMLAddSibling((WSDXML_ELEMENT *)currentNode, pChild);
 111     }
 112
 113     pChild->Node.Parent = pParent;
 114
 115     /* Link the memory allocations */
 116     WSDAttachLinkedMemory(pParent, pChild);
 117
 118     return S_OK;
 119 }
 120
 121 HRESULT WINAPI WSDXMLAddSibling(WSDXML_ELEMENT *pFirst, WSDXML_ELEMENT *pSecond)
 122 {
 123     WSDXML_NODE *currentNode;
 124
 125     TRACE("(%p, %p)\n", pFirst, pSecond);
 126
 127     if ((pFirst == NULL) || (pSecond == NULL))
 128     {
 129         return E_INVALIDARG;
 130     }
 131
 132     /* See if the first node already has a sibling */
 133     currentNode = pFirst->Node.Next;
 134
 135     if (currentNode == NULL)
 136     {
 137         pFirst->Node.Next = (WSDXML_NODE *)pSecond;
 138     }
 139     else
 140     {
 141         /* Find the last sibling node and make the second element the next sibling */
 142         while (1)
 143         {
 144             if (currentNode->Next == NULL)
 145             {
 146                 currentNode->Next = (WSDXML_NODE *)pSecond;
 147                 break;
 148             }
 149
 150             currentNode = currentNode->Next;
 151         }
 152     }
 153
 154     /* Reparent the second node under the first */
 155     pSecond->Node.Parent = pFirst->Node.Parent;
 156
 157     /* Link the memory allocations */
 158     WSDAttachLinkedMemory(pFirst->Node.Parent, pSecond);
 159
 160     return S_OK;
 161 }
 162
 163 HRESULT WINAPI WSDXMLBuildAnyForSingleElement(WSDXML_NAME *pElementName, LPCWSTR pszText, WSDXML_ELEMENT **ppAny)
 164 {
 165     WSDXML_TEXT *child;
 166
 167     TRACE("(%p, %s, %p)\n", pElementName, debugstr_w(pszText), ppAny);
 168
 169     if ((pElementName == NULL) || ((pszText != NULL) && (lstrlenW(pszText) > WSD_MAX_TEXT_LENGTH)))
 170     {
 171         return E_INVALIDARG;
 172     }
 173
 174     if (ppAny == NULL)
 175     {
 176         return E_POINTER;
 177     }
 178
 179     *ppAny = WSDAllocateLinkedMemory(NULL, sizeof(WSDXML_ELEMENT));
 180
 181     if (*ppAny == NULL)
 182     {
 183         return E_OUTOFMEMORY;
 184     }
 185
 186     ZeroMemory(*ppAny, sizeof(WSDXML_ELEMENT));
 187
 188     (*ppAny)->Name = duplicate_name(*ppAny, pElementName);
 189
 190     if ((*ppAny)->Name == NULL)
 191     {
 192         WSDFreeLinkedMemory(*ppAny);
 193         return E_OUTOFMEMORY;
 194     }
 195
 196     if (pszText != NULL)
 197     {
 198         child = WSDAllocateLinkedMemory(*ppAny, sizeof(WSDXML_TEXT));
 199
 200         if (child == NULL)
 201         {
 202             WSDFreeLinkedMemory(*ppAny);
 203             return E_OUTOFMEMORY;
 204         }
 205
 206         child->Node.Parent = *ppAny;
 207         child->Node.Next = NULL;
 208         child->Node.Type = TextType;
 209         child->Text = duplicate_string(child, pszText);
 210
 211         if (child->Text == NULL)
 212         {
 213             WSDFreeLinkedMemory(*ppAny);
 214             return E_OUTOFMEMORY;
 215         }
 216
 217         (*ppAny)->FirstChild = (WSDXML_NODE *)child;
 218     }
 219
 220     return S_OK;
 221 }
 222
 223 HRESULT WINAPI WSDXMLCleanupElement(WSDXML_ELEMENT *pAny)
 224 {
 225     TRACE("(%p)\n", pAny);
 226
 227     if (pAny == NULL)
 228     {
 229         return E_INVALIDARG;
 230     }
 231
 232     WSDFreeLinkedMemory(pAny);
 233     return S_OK;
 234 }
 235
 236 HRESULT WINAPI WSDXMLGetValueFromAny(const WCHAR *pszNamespace, const WCHAR *pszName, WSDXML_ELEMENT *pAny, LPCWSTR *ppszValue)
 237 {
 238     WSDXML_ELEMENT *element;
 239     WSDXML_TEXT *text;
 240
 241     if (pAny == NULL)
 242         return E_INVALIDARG;
 243
 244     if (ppszValue == NULL)
 245         return E_POINTER;
 246
 247     if ((pszNamespace == NULL) || (pszName == NULL) || (lstrlenW(pszNamespace) > WSD_MAX_TEXT_LENGTH) || (lstrlenW(pszName) > WSD_MAX_TEXT_LENGTH))
 248         return E_INVALIDARG;
 249
 250     element = pAny;
 251
 252     while (element != NULL)
 253     {
 254         if (element->Node.Type == ElementType)
 255         {
 256             if ((lstrcmpW(element->Name->LocalName, pszName) == 0) && (lstrcmpW(element->Name->Space->Uri, pszNamespace) == 0))
 257             {
 258                 if ((element->FirstChild == NULL) || (element->FirstChild->Type != TextType))
 259                 {
 260                     return E_FAIL;
 261                 }
 262
 263                 text = (WSDXML_TEXT *) element->FirstChild;
 264                 *ppszValue = (LPCWSTR) text->Text;
 265
 266                 return S_OK;
 267             }
 268         }
 269
 270         element = (WSDXML_ELEMENT *) element->Node.Next;
 271     }
 272
 273     return E_FAIL;
 274 }
 275
 276 /* IWSDXMLContext implementation */
 277
 278 struct xmlNamespace
 279 {
 280     struct list entry;
 281     WSDXML_NAMESPACE *namespace;
 282 };
 283
 284 typedef struct IWSDXMLContextImpl
 285 {
 286     IWSDXMLContext IWSDXMLContext_iface;
 287     LONG ref;
 288
 289     struct list *namespaces;
 290     int nextUnknownPrefix;
 291 } IWSDXMLContextImpl;
 292
 293 static WSDXML_NAMESPACE *find_namespace(struct list *namespaces, LPCWSTR uri)
 294 {
 295     struct xmlNamespace *ns;
 296
 297     LIST_FOR_EACH_ENTRY(ns, namespaces, struct xmlNamespace, entry)
 298     {
 299         if (lstrcmpW(ns->namespace->Uri, uri) == 0)
 300         {
 301             return ns->namespace;
 302         }
 303     }
 304
 305     return NULL;
 306 }
 307
 308 static WSDXML_NAME *find_name(WSDXML_NAMESPACE *ns, LPCWSTR name)
 309 {
 310     int i;
 311
 312     for (i = 0; i < ns->NamesCount; i++)
 313     {
 314         if (lstrcmpW(ns->Names[i].LocalName, name) == 0)
 315         {
 316             return &ns->Names[i];
 317         }
 318     }
 319
 320     return NULL;
 321 }
 322
 323 static WSDXML_NAME *add_name(WSDXML_NAMESPACE *ns, LPCWSTR name)
 324 {
 325     WSDXML_NAME *names;
 326     WSDXML_NAME *newName;
 327     int i;
 328
 329     names = WSDAllocateLinkedMemory(ns, sizeof(WSDXML_NAME) * (ns->NamesCount + 1));
 330
 331     if (names == NULL)
 332     {
 333         return NULL;
 334     }
 335
 336     if (ns->NamesCount > 0)
 337     {
 338         /* Copy the existing names array over to the new allocation */
 339         memcpy(names, ns->Names, sizeof(WSDXML_NAME) * ns->NamesCount);
 340
 341         for (i = 0; i < ns->NamesCount; i++)
 342         {
 343             /* Attach the local name memory to the new names allocation */
 344             WSDAttachLinkedMemory(names, names[i].LocalName);
 345         }
 346
 347         WSDFreeLinkedMemory(ns->Names);
 348     }
 349
 350     ns->Names = names;
 351
 352     newName = &names[ns->NamesCount];
 353
 354     newName->LocalName = duplicate_string(names, name);
 355     newName->Space = ns;
 356
 357     if (newName->LocalName == NULL)
 358     {
 359         return NULL;
 360     }
 361
 362     ns->NamesCount++;
 363     return newName;
 364 }
 365
 366 static BOOL is_prefix_unique(struct list *namespaces, LPCWSTR prefix)
 367 {
 368     struct xmlNamespace *ns;
 369
 370     LIST_FOR_EACH_ENTRY(ns, namespaces, struct xmlNamespace, entry)
 371     {
 372         if (lstrcmpW(ns->namespace->PreferredPrefix, prefix) == 0)
 373         {
 374             return FALSE;
 375         }
 376     }
 377
 378     return TRUE;
 379 }
 380
 381 static LPWSTR generate_namespace_prefix(IWSDXMLContextImpl *impl, void *parentMemoryBlock, LPCWSTR uri)
 382 {
 383     WCHAR suggestedPrefix[7];
 384
 385     /* Find a unique prefix */
 386     while (impl->nextUnknownPrefix < 1000)
 387     {
 388         wsprintfW(suggestedPrefix, L"un%d", impl->nextUnknownPrefix++);
 389
 390         /* For the unlikely event where somebody has explicitly created a prefix called 'unX', check it is unique */
 391         if (is_prefix_unique(impl->namespaces, suggestedPrefix))
 392         {
 393             return duplicate_string(parentMemoryBlock, suggestedPrefix);
 394         }
 395     }
 396
 397     return NULL;
 398 }
 399
 400 static WSDXML_NAMESPACE *add_namespace(struct list *namespaces, LPCWSTR uri)
 401 {
 402     struct xmlNamespace *ns = WSDAllocateLinkedMemory(namespaces, sizeof(struct xmlNamespace));
 403
 404     if (ns == NULL)
 405     {
 406         return NULL;
 407     }
 408
 409     ns->namespace = WSDAllocateLinkedMemory(ns, sizeof(WSDXML_NAMESPACE));
 410
 411     if (ns->namespace == NULL)
 412     {
 413         WSDFreeLinkedMemory(ns);
 414         return NULL;
 415     }
 416
 417     ZeroMemory(ns->namespace, sizeof(WSDXML_NAMESPACE));
 418     ns->namespace->Uri = duplicate_string(ns->namespace, uri);
 419
 420     if (ns->namespace->Uri == NULL)
 421     {
 422         WSDFreeLinkedMemory(ns);
 423         return NULL;
 424     }
 425
 426     list_add_tail(namespaces, &ns->entry);
 427     return ns->namespace;
 428 }
 429
 430 static inline IWSDXMLContextImpl *impl_from_IWSDXMLContext(IWSDXMLContext *iface)
 431 {
 432     return CONTAINING_RECORD(iface, IWSDXMLContextImpl, IWSDXMLContext_iface);
 433 }
 434
 435 static HRESULT WINAPI IWSDXMLContextImpl_QueryInterface(IWSDXMLContext *iface, REFIID riid, void **ppv)
 436 {
 437     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 438
 439     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv);
 440
 441     if (!ppv)
 442     {
 443         WARN("Invalid parameter\n");
 444         return E_INVALIDARG;
 445     }
 446
 447     *ppv = NULL;
 448
 449     if (IsEqualIID(riid, &IID_IUnknown) ||
 450         IsEqualIID(riid, &IID_IWSDXMLContext))
 451     {
 452         *ppv = &This->IWSDXMLContext_iface;
 453     }
 454     else
 455     {
 456         WARN("Unknown IID %s\n", debugstr_guid(riid));
 457         return E_NOINTERFACE;
 458     }
 459
 460     IUnknown_AddRef((IUnknown*)*ppv);
 461     return S_OK;
 462 }
 463
 464 static ULONG WINAPI IWSDXMLContextImpl_AddRef(IWSDXMLContext *iface)
 465 {
 466     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 467     ULONG ref = InterlockedIncrement(&This->ref);
 468
 469     TRACE("(%p) ref=%d\n", This, ref);
 470     return ref;
 471 }
 472
 473 static ULONG WINAPI IWSDXMLContextImpl_Release(IWSDXMLContext *iface)
 474 {
 475     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 476     ULONG ref = InterlockedDecrement(&This->ref);
 477
 478     TRACE("(%p) ref=%d\n", This, ref);
 479
 480     if (ref == 0)
 481     {
 482         WSDFreeLinkedMemory(This);
 483     }
 484
 485     return ref;
 486 }
 487
 488 static HRESULT WINAPI IWSDXMLContextImpl_AddNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszSuggestedPrefix, WSDXML_NAMESPACE **ppNamespace)
 489 {
 490     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 491     WSDXML_NAMESPACE *ns;
 492     LPCWSTR newPrefix = NULL;
 493     BOOL setNewPrefix;
 494
 495     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszSuggestedPrefix), ppNamespace);
 496
 497     if ((pszUri == NULL) || (pszSuggestedPrefix == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) ||
 498         (lstrlenW(pszSuggestedPrefix) > WSD_MAX_TEXT_LENGTH))
 499     {
 500         return E_INVALIDARG;
 501     }
 502
 503     ns = find_namespace(This->namespaces, pszUri);
 504
 505     if (ns == NULL)
 506     {
 507         ns = add_namespace(This->namespaces, pszUri);
 508
 509         if (ns == NULL)
 510         {
 511             return E_OUTOFMEMORY;
 512         }
 513     }
 514
 515     setNewPrefix = (ns->PreferredPrefix == NULL);
 516
 517     if ((ns->PreferredPrefix == NULL) || (lstrcmpW(ns->PreferredPrefix, pszSuggestedPrefix) != 0))
 518     {
 519         newPrefix = pszSuggestedPrefix;
 520         setNewPrefix = TRUE;
 521     }
 522
 523     if (setNewPrefix)
 524     {
 525         WSDFreeLinkedMemory((void *)ns->PreferredPrefix);
 526         ns->PreferredPrefix = NULL;
 527
 528         if ((newPrefix != NULL) && (is_prefix_unique(This->namespaces, newPrefix)))
 529         {
 530             ns->PreferredPrefix = duplicate_string(ns, newPrefix);
 531         }
 532         else
 533         {
 534             ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 535             if (ns->PreferredPrefix == NULL)
 536             {
 537                 return E_FAIL;
 538             }
 539         }
 540     }
 541
 542     if (ppNamespace != NULL)
 543     {
 544         *ppNamespace = duplicate_namespace(NULL, ns);
 545
 546         if (*ppNamespace == NULL)
 547         {
 548             return E_OUTOFMEMORY;
 549         }
 550     }
 551
 552     return S_OK;
 553 }
 554
 555 static HRESULT WINAPI IWSDXMLContextImpl_AddNameToNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszName, WSDXML_NAME **ppName)
 556 {
 557     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 558     WSDXML_NAMESPACE *ns;
 559     WSDXML_NAME *name;
 560
 561     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszName), ppName);
 562
 563     if ((pszUri == NULL) || (pszName == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) || (lstrlenW(pszName) > WSD_MAX_TEXT_LENGTH))
 564     {
 565         return E_INVALIDARG;
 566     }
 567
 568     ns = find_namespace(This->namespaces, pszUri);
 569
 570     if (ns == NULL)
 571     {
 572         /* The namespace doesn't exist, add it */
 573         ns = add_namespace(This->namespaces, pszUri);
 574
 575         if (ns == NULL)
 576         {
 577             return E_OUTOFMEMORY;
 578         }
 579
 580         ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 581         if (ns->PreferredPrefix == NULL)
 582         {
 583             return E_FAIL;
 584         }
 585     }
 586
 587     name = find_name(ns, pszName);
 588
 589     if (name == NULL)
 590     {
 591         name = add_name(ns, pszName);
 592
 593         if (name == NULL)
 594         {
 595             return E_OUTOFMEMORY;
 596         }
 597     }
 598
 599     if (ppName != NULL)
 600     {
 601         *ppName = duplicate_name(NULL, name);
 602
 603         if (*ppName == NULL)
 604         {
 605             return E_OUTOFMEMORY;
 606         }
 607     }
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT WINAPI IWSDXMLContextImpl_SetNamespaces(IWSDXMLContext *iface, const PCWSDXML_NAMESPACE *pNamespaces, WORD wNamespacesCount, BYTE bLayerNumber)
 613 {
 614     FIXME("(%p, %p, %d, %d)\n", iface, pNamespaces, wNamespacesCount, bLayerNumber);
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI IWSDXMLContextImpl_SetTypes(IWSDXMLContext *iface, const PCWSDXML_TYPE *pTypes, DWORD dwTypesCount, BYTE bLayerNumber)
 619 {
 620     FIXME("(%p, %p, %d, %d)\n", iface, pTypes, dwTypesCount, bLayerNumber);
 621     return E_NOTIMPL;
 622 }
 623
 624 static const IWSDXMLContextVtbl xmlcontext_vtbl =
 625 {
 626     IWSDXMLContextImpl_QueryInterface,
 627     IWSDXMLContextImpl_AddRef,
 628     IWSDXMLContextImpl_Release,
 629     IWSDXMLContextImpl_AddNamespace,
 630     IWSDXMLContextImpl_AddNameToNamespace,
 631     IWSDXMLContextImpl_SetNamespaces,
 632     IWSDXMLContextImpl_SetTypes
 633 };
 634
 635 HRESULT WINAPI WSDXMLCreateContext(IWSDXMLContext **ppContext)
 636 {
 637     IWSDXMLContextImpl *obj;
 638
 639     TRACE("(%p)\n", ppContext);
 640
 641     if (ppContext == NULL)
 642     {
 643         WARN("Invalid parameter: ppContext == NULL\n");
 644         return E_POINTER;
 645     }
 646
 647     *ppContext = NULL;
 648
 649     obj = WSDAllocateLinkedMemory(NULL, sizeof(*obj));
 650
 651     if (!obj)
 652     {
 653         return E_OUTOFMEMORY;
 654     }
 655
 656     obj->IWSDXMLContext_iface.lpVtbl = &xmlcontext_vtbl;
 657     obj->ref = 1;
 658     obj->namespaces = WSDAllocateLinkedMemory(obj, sizeof(struct list));
 659     obj->nextUnknownPrefix = 0;
 660
 661     if (obj->namespaces == NULL)
 662     {
 663         WSDFreeLinkedMemory(obj);
 664         return E_OUTOFMEMORY;
 665     }
 666
 667     list_init(obj->namespaces);
 668
 669     *ppContext = &obj->IWSDXMLContext_iface;
 670     TRACE("Returning iface %p\n", *ppContext);
 671
 672     return S_OK;
 673 }
 674
 675 WSDXML_NAMESPACE *xml_context_find_namespace_by_prefix(IWSDXMLContext *context, LPCWSTR prefix)
 676 {
 677     IWSDXMLContextImpl *impl = impl_from_IWSDXMLContext(context);
 678     struct xmlNamespace *ns;
 679
 680     if (prefix == NULL) return NULL;
 681
 682     LIST_FOR_EACH_ENTRY(ns, impl->namespaces, struct xmlNamespace, entry)
 683     {
 684         if (lstrcmpW(ns->namespace->PreferredPrefix, prefix) == 0)
 685             return ns->namespace;
 686     }
 687
 688     return NULL;
 689 }