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 formatString[] = { 'u','n','%','d', 0 };
 384     WCHAR suggestedPrefix[7];
 385
 386     /* Find a unique prefix */
 387     while (impl->nextUnknownPrefix < 1000)
 388     {
 389         wsprintfW(suggestedPrefix, formatString, impl->nextUnknownPrefix++);
 390
 391         /* For the unlikely event where somebody has explicitly created a prefix called 'unX', check it is unique */
 392         if (is_prefix_unique(impl->namespaces, suggestedPrefix))
 393         {
 394             return duplicate_string(parentMemoryBlock, suggestedPrefix);
 395         }
 396     }
 397
 398     return NULL;
 399 }
 400
 401 static WSDXML_NAMESPACE *add_namespace(struct list *namespaces, LPCWSTR uri)
 402 {
 403     struct xmlNamespace *ns = WSDAllocateLinkedMemory(namespaces, sizeof(struct xmlNamespace));
 404
 405     if (ns == NULL)
 406     {
 407         return NULL;
 408     }
 409
 410     ns->namespace = WSDAllocateLinkedMemory(ns, sizeof(WSDXML_NAMESPACE));
 411
 412     if (ns->namespace == NULL)
 413     {
 414         WSDFreeLinkedMemory(ns);
 415         return NULL;
 416     }
 417
 418     ZeroMemory(ns->namespace, sizeof(WSDXML_NAMESPACE));
 419     ns->namespace->Uri = duplicate_string(ns->namespace, uri);
 420
 421     if (ns->namespace->Uri == NULL)
 422     {
 423         WSDFreeLinkedMemory(ns);
 424         return NULL;
 425     }
 426
 427     list_add_tail(namespaces, &ns->entry);
 428     return ns->namespace;
 429 }
 430
 431 static inline IWSDXMLContextImpl *impl_from_IWSDXMLContext(IWSDXMLContext *iface)
 432 {
 433     return CONTAINING_RECORD(iface, IWSDXMLContextImpl, IWSDXMLContext_iface);
 434 }
 435
 436 static HRESULT WINAPI IWSDXMLContextImpl_QueryInterface(IWSDXMLContext *iface, REFIID riid, void **ppv)
 437 {
 438     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 439
 440     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv);
 441
 442     if (!ppv)
 443     {
 444         WARN("Invalid parameter\n");
 445         return E_INVALIDARG;
 446     }
 447
 448     *ppv = NULL;
 449
 450     if (IsEqualIID(riid, &IID_IUnknown) ||
 451         IsEqualIID(riid, &IID_IWSDXMLContext))
 452     {
 453         *ppv = &This->IWSDXMLContext_iface;
 454     }
 455     else
 456     {
 457         WARN("Unknown IID %s\n", debugstr_guid(riid));
 458         return E_NOINTERFACE;
 459     }
 460
 461     IUnknown_AddRef((IUnknown*)*ppv);
 462     return S_OK;
 463 }
 464
 465 static ULONG WINAPI IWSDXMLContextImpl_AddRef(IWSDXMLContext *iface)
 466 {
 467     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 468     ULONG ref = InterlockedIncrement(&This->ref);
 469
 470     TRACE("(%p) ref=%d\n", This, ref);
 471     return ref;
 472 }
 473
 474 static ULONG WINAPI IWSDXMLContextImpl_Release(IWSDXMLContext *iface)
 475 {
 476     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 477     ULONG ref = InterlockedDecrement(&This->ref);
 478
 479     TRACE("(%p) ref=%d\n", This, ref);
 480
 481     if (ref == 0)
 482     {
 483         WSDFreeLinkedMemory(This);
 484     }
 485
 486     return ref;
 487 }
 488
 489 static HRESULT WINAPI IWSDXMLContextImpl_AddNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszSuggestedPrefix, WSDXML_NAMESPACE **ppNamespace)
 490 {
 491     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 492     WSDXML_NAMESPACE *ns;
 493     LPCWSTR newPrefix = NULL;
 494     BOOL setNewPrefix;
 495
 496     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszSuggestedPrefix), ppNamespace);
 497
 498     if ((pszUri == NULL) || (pszSuggestedPrefix == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) ||
 499         (lstrlenW(pszSuggestedPrefix) > WSD_MAX_TEXT_LENGTH))
 500     {
 501         return E_INVALIDARG;
 502     }
 503
 504     ns = find_namespace(This->namespaces, pszUri);
 505
 506     if (ns == NULL)
 507     {
 508         ns = add_namespace(This->namespaces, pszUri);
 509
 510         if (ns == NULL)
 511         {
 512             return E_OUTOFMEMORY;
 513         }
 514     }
 515
 516     setNewPrefix = (ns->PreferredPrefix == NULL);
 517
 518     if ((ns->PreferredPrefix == NULL) || (lstrcmpW(ns->PreferredPrefix, pszSuggestedPrefix) != 0))
 519     {
 520         newPrefix = pszSuggestedPrefix;
 521         setNewPrefix = TRUE;
 522     }
 523
 524     if (setNewPrefix)
 525     {
 526         WSDFreeLinkedMemory((void *)ns->PreferredPrefix);
 527         ns->PreferredPrefix = NULL;
 528
 529         if ((newPrefix != NULL) && (is_prefix_unique(This->namespaces, newPrefix)))
 530         {
 531             ns->PreferredPrefix = duplicate_string(ns, newPrefix);
 532         }
 533         else
 534         {
 535             ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 536             if (ns->PreferredPrefix == NULL)
 537             {
 538                 return E_FAIL;
 539             }
 540         }
 541     }
 542
 543     if (ppNamespace != NULL)
 544     {
 545         *ppNamespace = duplicate_namespace(NULL, ns);
 546
 547         if (*ppNamespace == NULL)
 548         {
 549             return E_OUTOFMEMORY;
 550         }
 551     }
 552
 553     return S_OK;
 554 }
 555
 556 static HRESULT WINAPI IWSDXMLContextImpl_AddNameToNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszName, WSDXML_NAME **ppName)
 557 {
 558     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 559     WSDXML_NAMESPACE *ns;
 560     WSDXML_NAME *name;
 561
 562     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszName), ppName);
 563
 564     if ((pszUri == NULL) || (pszName == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) || (lstrlenW(pszName) > WSD_MAX_TEXT_LENGTH))
 565     {
 566         return E_INVALIDARG;
 567     }
 568
 569     ns = find_namespace(This->namespaces, pszUri);
 570
 571     if (ns == NULL)
 572     {
 573         /* The namespace doesn't exist, add it */
 574         ns = add_namespace(This->namespaces, pszUri);
 575
 576         if (ns == NULL)
 577         {
 578             return E_OUTOFMEMORY;
 579         }
 580
 581         ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 582         if (ns->PreferredPrefix == NULL)
 583         {
 584             return E_FAIL;
 585         }
 586     }
 587
 588     name = find_name(ns, pszName);
 589
 590     if (name == NULL)
 591     {
 592         name = add_name(ns, pszName);
 593
 594         if (name == NULL)
 595         {
 596             return E_OUTOFMEMORY;
 597         }
 598     }
 599
 600     if (ppName != NULL)
 601     {
 602         *ppName = duplicate_name(NULL, name);
 603
 604         if (*ppName == NULL)
 605         {
 606             return E_OUTOFMEMORY;
 607         }
 608     }
 609
 610     return S_OK;
 611 }
 612
 613 static HRESULT WINAPI IWSDXMLContextImpl_SetNamespaces(IWSDXMLContext *iface, const PCWSDXML_NAMESPACE *pNamespaces, WORD wNamespacesCount, BYTE bLayerNumber)
 614 {
 615     FIXME("(%p, %p, %d, %d)\n", iface, pNamespaces, wNamespacesCount, bLayerNumber);
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT WINAPI IWSDXMLContextImpl_SetTypes(IWSDXMLContext *iface, const PCWSDXML_TYPE *pTypes, DWORD dwTypesCount, BYTE bLayerNumber)
 620 {
 621     FIXME("(%p, %p, %d, %d)\n", iface, pTypes, dwTypesCount, bLayerNumber);
 622     return E_NOTIMPL;
 623 }
 624
 625 static const IWSDXMLContextVtbl xmlcontext_vtbl =
 626 {
 627     IWSDXMLContextImpl_QueryInterface,
 628     IWSDXMLContextImpl_AddRef,
 629     IWSDXMLContextImpl_Release,
 630     IWSDXMLContextImpl_AddNamespace,
 631     IWSDXMLContextImpl_AddNameToNamespace,
 632     IWSDXMLContextImpl_SetNamespaces,
 633     IWSDXMLContextImpl_SetTypes
 634 };
 635
 636 HRESULT WINAPI WSDXMLCreateContext(IWSDXMLContext **ppContext)
 637 {
 638     IWSDXMLContextImpl *obj;
 639
 640     TRACE("(%p)\n", ppContext);
 641
 642     if (ppContext == NULL)
 643     {
 644         WARN("Invalid parameter: ppContext == NULL\n");
 645         return E_POINTER;
 646     }
 647
 648     *ppContext = NULL;
 649
 650     obj = WSDAllocateLinkedMemory(NULL, sizeof(*obj));
 651
 652     if (!obj)
 653     {
 654         return E_OUTOFMEMORY;
 655     }
 656
 657     obj->IWSDXMLContext_iface.lpVtbl = &xmlcontext_vtbl;
 658     obj->ref = 1;
 659     obj->namespaces = WSDAllocateLinkedMemory(obj, sizeof(struct list));
 660     obj->nextUnknownPrefix = 0;
 661
 662     if (obj->namespaces == NULL)
 663     {
 664         WSDFreeLinkedMemory(obj);
 665         return E_OUTOFMEMORY;
 666     }
 667
 668     list_init(obj->namespaces);
 669
 670     *ppContext = &obj->IWSDXMLContext_iface;
 671     TRACE("Returning iface %p\n", *ppContext);
 672
 673     return S_OK;
 674 }
 675
 676 WSDXML_NAMESPACE *xml_context_find_namespace_by_prefix(IWSDXMLContext *context, LPCWSTR prefix)
 677 {
 678     IWSDXMLContextImpl *impl = impl_from_IWSDXMLContext(context);
 679     struct xmlNamespace *ns;
 680
 681     if (prefix == NULL) return NULL;
 682
 683     LIST_FOR_EACH_ENTRY(ns, impl->namespaces, struct xmlNamespace, entry)
 684     {
 685         if (lstrcmpW(ns->namespace->PreferredPrefix, prefix) == 0)
 686             return ns->namespace;
 687     }
 688
 689     return NULL;
 690 }