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 /* IWSDXMLContext implementation */
 242
 243 struct xmlNamespace
 244 {
 245     struct list entry;
 246     WSDXML_NAMESPACE *namespace;
 247 };
 248
 249 typedef struct IWSDXMLContextImpl
 250 {
 251     IWSDXMLContext IWSDXMLContext_iface;
 252     LONG ref;
 253
 254     struct list *namespaces;
 255     int nextUnknownPrefix;
 256 } IWSDXMLContextImpl;
 257
 258 static WSDXML_NAMESPACE *find_namespace(struct list *namespaces, LPCWSTR uri)
 259 {
 260     struct xmlNamespace *ns;
 261
 262     LIST_FOR_EACH_ENTRY(ns, namespaces, struct xmlNamespace, entry)
 263     {
 264         if (lstrcmpW(ns->namespace->Uri, uri) == 0)
 265         {
 266             return ns->namespace;
 267         }
 268     }
 269
 270     return NULL;
 271 }
 272
 273 static WSDXML_NAME *find_name(WSDXML_NAMESPACE *ns, LPCWSTR name)
 274 {
 275     int i;
 276
 277     for (i = 0; i < ns->NamesCount; i++)
 278     {
 279         if (lstrcmpW(ns->Names[i].LocalName, name) == 0)
 280         {
 281             return &ns->Names[i];
 282         }
 283     }
 284
 285     return NULL;
 286 }
 287
 288 static WSDXML_NAME *add_name(WSDXML_NAMESPACE *ns, LPCWSTR name)
 289 {
 290     WSDXML_NAME *names;
 291     WSDXML_NAME *newName;
 292     int i;
 293
 294     names = WSDAllocateLinkedMemory(ns, sizeof(WSDXML_NAME) * (ns->NamesCount + 1));
 295
 296     if (names == NULL)
 297     {
 298         return NULL;
 299     }
 300
 301     if (ns->NamesCount > 0)
 302     {
 303         /* Copy the existing names array over to the new allocation */
 304         memcpy(names, ns->Names, sizeof(WSDXML_NAME) * ns->NamesCount);
 305
 306         for (i = 0; i < ns->NamesCount; i++)
 307         {
 308             /* Attach the local name memory to the new names allocation */
 309             WSDAttachLinkedMemory(names, names[i].LocalName);
 310         }
 311
 312         WSDFreeLinkedMemory(ns->Names);
 313     }
 314
 315     ns->Names = names;
 316
 317     newName = &names[ns->NamesCount];
 318
 319     newName->LocalName = duplicate_string(names, name);
 320     newName->Space = ns;
 321
 322     if (newName->LocalName == NULL)
 323     {
 324         return NULL;
 325     }
 326
 327     ns->NamesCount++;
 328     return newName;
 329 }
 330
 331 static BOOL is_prefix_unique(struct list *namespaces, LPCWSTR prefix)
 332 {
 333     struct xmlNamespace *ns;
 334
 335     LIST_FOR_EACH_ENTRY(ns, namespaces, struct xmlNamespace, entry)
 336     {
 337         if (lstrcmpW(ns->namespace->PreferredPrefix, prefix) == 0)
 338         {
 339             return FALSE;
 340         }
 341     }
 342
 343     return TRUE;
 344 }
 345
 346 static LPWSTR generate_namespace_prefix(IWSDXMLContextImpl *impl, void *parentMemoryBlock, LPCWSTR uri)
 347 {
 348     WCHAR formatString[] = { 'u','n','%','d', 0 };
 349     WCHAR suggestedPrefix[7];
 350
 351     /* Find a unique prefix */
 352     while (impl->nextUnknownPrefix < 1000)
 353     {
 354         wsprintfW(suggestedPrefix, formatString, impl->nextUnknownPrefix++);
 355
 356         /* For the unlikely event where somebody has explicitly created a prefix called 'unX', check it is unique */
 357         if (is_prefix_unique(impl->namespaces, suggestedPrefix))
 358         {
 359             return duplicate_string(parentMemoryBlock, suggestedPrefix);
 360         }
 361     }
 362
 363     return NULL;
 364 }
 365
 366 static WSDXML_NAMESPACE *add_namespace(struct list *namespaces, LPCWSTR uri)
 367 {
 368     struct xmlNamespace *ns = WSDAllocateLinkedMemory(namespaces, sizeof(struct xmlNamespace));
 369
 370     if (ns == NULL)
 371     {
 372         return NULL;
 373     }
 374
 375     ns->namespace = WSDAllocateLinkedMemory(ns, sizeof(WSDXML_NAMESPACE));
 376
 377     if (ns->namespace == NULL)
 378     {
 379         WSDFreeLinkedMemory(ns);
 380         return NULL;
 381     }
 382
 383     ZeroMemory(ns->namespace, sizeof(WSDXML_NAMESPACE));
 384     ns->namespace->Uri = duplicate_string(ns->namespace, uri);
 385
 386     if (ns->namespace->Uri == NULL)
 387     {
 388         WSDFreeLinkedMemory(ns);
 389         return NULL;
 390     }
 391
 392     list_add_tail(namespaces, &ns->entry);
 393     return ns->namespace;
 394 }
 395
 396 static inline IWSDXMLContextImpl *impl_from_IWSDXMLContext(IWSDXMLContext *iface)
 397 {
 398     return CONTAINING_RECORD(iface, IWSDXMLContextImpl, IWSDXMLContext_iface);
 399 }
 400
 401 static HRESULT WINAPI IWSDXMLContextImpl_QueryInterface(IWSDXMLContext *iface, REFIID riid, void **ppv)
 402 {
 403     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 404
 405     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppv);
 406
 407     if (!ppv)
 408     {
 409         WARN("Invalid parameter\n");
 410         return E_INVALIDARG;
 411     }
 412
 413     *ppv = NULL;
 414
 415     if (IsEqualIID(riid, &IID_IUnknown) ||
 416         IsEqualIID(riid, &IID_IWSDXMLContext))
 417     {
 418         *ppv = &This->IWSDXMLContext_iface;
 419     }
 420     else
 421     {
 422         WARN("Unknown IID %s\n", debugstr_guid(riid));
 423         return E_NOINTERFACE;
 424     }
 425
 426     IUnknown_AddRef((IUnknown*)*ppv);
 427     return S_OK;
 428 }
 429
 430 static ULONG WINAPI IWSDXMLContextImpl_AddRef(IWSDXMLContext *iface)
 431 {
 432     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 433     ULONG ref = InterlockedIncrement(&This->ref);
 434
 435     TRACE("(%p) ref=%d\n", This, ref);
 436     return ref;
 437 }
 438
 439 static ULONG WINAPI IWSDXMLContextImpl_Release(IWSDXMLContext *iface)
 440 {
 441     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 442     ULONG ref = InterlockedDecrement(&This->ref);
 443
 444     TRACE("(%p) ref=%d\n", This, ref);
 445
 446     if (ref == 0)
 447     {
 448         WSDFreeLinkedMemory(This);
 449     }
 450
 451     return ref;
 452 }
 453
 454 static HRESULT WINAPI IWSDXMLContextImpl_AddNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszSuggestedPrefix, WSDXML_NAMESPACE **ppNamespace)
 455 {
 456     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 457     WSDXML_NAMESPACE *ns;
 458     LPCWSTR newPrefix = NULL;
 459     BOOL setNewPrefix;
 460
 461     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszSuggestedPrefix), ppNamespace);
 462
 463     if ((pszUri == NULL) || (pszSuggestedPrefix == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) ||
 464         (lstrlenW(pszSuggestedPrefix) > WSD_MAX_TEXT_LENGTH))
 465     {
 466         return E_INVALIDARG;
 467     }
 468
 469     ns = find_namespace(This->namespaces, pszUri);
 470
 471     if (ns == NULL)
 472     {
 473         ns = add_namespace(This->namespaces, pszUri);
 474
 475         if (ns == NULL)
 476         {
 477             return E_OUTOFMEMORY;
 478         }
 479     }
 480
 481     setNewPrefix = (ns->PreferredPrefix == NULL);
 482
 483     if ((ns->PreferredPrefix == NULL) || (lstrcmpW(ns->PreferredPrefix, pszSuggestedPrefix) != 0))
 484     {
 485         newPrefix = pszSuggestedPrefix;
 486         setNewPrefix = TRUE;
 487     }
 488
 489     if (setNewPrefix)
 490     {
 491         WSDFreeLinkedMemory((void *)ns->PreferredPrefix);
 492
 493         if ((newPrefix != NULL) && (is_prefix_unique(This->namespaces, newPrefix)))
 494         {
 495             ns->PreferredPrefix = duplicate_string(ns, newPrefix);
 496         }
 497         else
 498         {
 499             ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 500             if (ns->PreferredPrefix == NULL)
 501             {
 502                 return E_FAIL;
 503             }
 504         }
 505     }
 506
 507     if (ppNamespace != NULL)
 508     {
 509         *ppNamespace = duplicate_namespace(NULL, ns);
 510
 511         if (*ppNamespace == NULL)
 512         {
 513             return E_OUTOFMEMORY;
 514         }
 515     }
 516
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI IWSDXMLContextImpl_AddNameToNamespace(IWSDXMLContext *iface, LPCWSTR pszUri, LPCWSTR pszName, WSDXML_NAME **ppName)
 521 {
 522     IWSDXMLContextImpl *This = impl_from_IWSDXMLContext(iface);
 523     WSDXML_NAMESPACE *ns;
 524     WSDXML_NAME *name;
 525
 526     TRACE("(%p, %s, %s, %p)\n", This, debugstr_w(pszUri), debugstr_w(pszName), ppName);
 527
 528     if ((pszUri == NULL) || (pszName == NULL) || (lstrlenW(pszUri) > WSD_MAX_TEXT_LENGTH) || (lstrlenW(pszName) > WSD_MAX_TEXT_LENGTH))
 529     {
 530         return E_INVALIDARG;
 531     }
 532
 533     ns = find_namespace(This->namespaces, pszUri);
 534
 535     if (ns == NULL)
 536     {
 537         /* The namespace doesn't exist, add it */
 538         ns = add_namespace(This->namespaces, pszUri);
 539
 540         if (ns == NULL)
 541         {
 542             return E_OUTOFMEMORY;
 543         }
 544
 545         ns->PreferredPrefix = generate_namespace_prefix(This, ns, pszUri);
 546         if (ns->PreferredPrefix == NULL)
 547         {
 548             return E_FAIL;
 549         }
 550     }
 551
 552     name = find_name(ns, pszName);
 553
 554     if (name == NULL)
 555     {
 556         name = add_name(ns, pszName);
 557
 558         if (name == NULL)
 559         {
 560             return E_OUTOFMEMORY;
 561         }
 562     }
 563
 564     if (ppName != NULL)
 565     {
 566         *ppName = duplicate_name(NULL, name);
 567
 568         if (*ppName == NULL)
 569         {
 570             return E_OUTOFMEMORY;
 571         }
 572     }
 573
 574     return S_OK;
 575 }
 576
 577 static HRESULT WINAPI IWSDXMLContextImpl_SetNamespaces(IWSDXMLContext *iface, const PCWSDXML_NAMESPACE *pNamespaces, WORD wNamespacesCount, BYTE bLayerNumber)
 578 {
 579     FIXME("(%p, %p, %d, %d)\n", iface, pNamespaces, wNamespacesCount, bLayerNumber);
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI IWSDXMLContextImpl_SetTypes(IWSDXMLContext *iface, const PCWSDXML_TYPE *pTypes, DWORD dwTypesCount, BYTE bLayerNumber)
 584 {
 585     FIXME("(%p, %p, %d, %d)\n", iface, pTypes, dwTypesCount, bLayerNumber);
 586     return E_NOTIMPL;
 587 }
 588
 589 static const IWSDXMLContextVtbl xmlcontext_vtbl =
 590 {
 591     IWSDXMLContextImpl_QueryInterface,
 592     IWSDXMLContextImpl_AddRef,
 593     IWSDXMLContextImpl_Release,
 594     IWSDXMLContextImpl_AddNamespace,
 595     IWSDXMLContextImpl_AddNameToNamespace,
 596     IWSDXMLContextImpl_SetNamespaces,
 597     IWSDXMLContextImpl_SetTypes
 598 };
 599
 600 HRESULT WINAPI WSDXMLCreateContext(IWSDXMLContext **ppContext)
 601 {
 602     IWSDXMLContextImpl *obj;
 603
 604     TRACE("(%p)\n", ppContext);
 605
 606     if (ppContext == NULL)
 607     {
 608         WARN("Invalid parameter: ppContext == NULL\n");
 609         return E_POINTER;
 610     }
 611
 612     *ppContext = NULL;
 613
 614     obj = WSDAllocateLinkedMemory(NULL, sizeof(*obj));
 615
 616     if (!obj)
 617     {
 618         return E_OUTOFMEMORY;
 619     }
 620
 621     obj->IWSDXMLContext_iface.lpVtbl = &xmlcontext_vtbl;
 622     obj->ref = 1;
 623     obj->namespaces = WSDAllocateLinkedMemory(obj, sizeof(struct list));
 624     obj->nextUnknownPrefix = 0;
 625
 626     if (obj->namespaces == NULL)
 627     {
 628         WSDFreeLinkedMemory(obj);
 629         return E_OUTOFMEMORY;
 630     }
 631
 632     list_init(obj->namespaces);
 633
 634     *ppContext = &obj->IWSDXMLContext_iface;
 635     TRACE("Returning iface %p\n", *ppContext);
 636
 637     return S_OK;
 638 }