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