dlls/msxml3/schema.c

   1 /*
   2  * Schema cache implementation
   3  *
   4  * Copyright 2007 Huw Davies
   5  * Copyright 2010 Adam Martinson for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include "config.h"
  25
  26 #include <assert.h>
  27 #include <stdarg.h>
  28 #ifdef HAVE_LIBXML2
  29 # include <libxml/xmlerror.h>
  30 # include <libxml/tree.h>
  31 # include <libxml/xmlschemas.h>
  32 # include <libxml/schemasInternals.h>
  33 # include <libxml/hash.h>
  34 # include <libxml/parser.h>
  35 # include <libxml/parserInternals.h>
  36 # include <libxml/xmlIO.h>
  37 # include <libxml/xmlversion.h>
  38 # include <libxml/xpath.h>
  39 #endif
  40
  41 #include "windef.h"
  42 #include "winbase.h"
  43 #include "winuser.h"
  44 #include "ole2.h"
  45 #include "msxml6.h"
  46
  47 #include "wine/debug.h"
  48
  49 #include "msxml_private.h"
  50
  51 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  52
  53 /* We use a chained hashtable, which can hold any number of schemas
  54  * TODO: grow/shrink hashtable depending on load factor
  55  * TODO: implement read-only where appropriate
  56  */
  57
  58 /* This is just the number of buckets, should be prime */
  59 #define DEFAULT_HASHTABLE_SIZE 17
  60
  61 #ifdef HAVE_LIBXML2
  62
  63 xmlDocPtr XDR_to_XSD_doc(xmlDocPtr xdr_doc, xmlChar const* nsURI);
  64
  65 static const xmlChar XSD_schema[] = "schema";
  66 static const xmlChar XSD_nsURI[] = "http://www.w3.org/2001/XMLSchema";
  67 static const xmlChar XDR_schema[] = "Schema";
  68 static const xmlChar XDR_nsURI[] = "urn:schemas-microsoft-com:xml-data";
  69 static const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes";
  70
  71 static xmlChar *        datatypes_src;
  72 static int              datatypes_len;
  73 static HGLOBAL          datatypes_handle;
  74 static HRSRC            datatypes_rsrc;
  75 static xmlSchemaPtr     datatypes_schema;
  76
  77 static const WCHAR      emptyW[] = {0};
  78
  79 /* Supported types:
  80  * msxml3 - XDR only
  81  * msxml4 - XDR & XSD
  82  * msxml5 - XDR & XSD
  83  * mxsml6 - XSD only
  84  *
  85  * CacheType_NS is a special type used for read-only collection build with
  86  * IXMLDOMDocument2::namespaces()
  87  */
  88 typedef enum  {
  89     CacheEntryType_Invalid,
  90     CacheEntryType_XDR,
  91     CacheEntryType_XSD,
  92     CacheEntryType_NS
  93 } CacheEntryType;
  94
  95 typedef struct
  96 {
  97     DispatchEx dispex;
  98     IXMLDOMSchemaCollection2 IXMLDOMSchemaCollection2_iface;
  99     LONG ref;
 100
 101     MSXML_VERSION version;
 102     xmlHashTablePtr cache;
 103     xmlChar **uris;
 104     int allocated;
 105     int count;
 106
 107     VARIANT_BOOL validateOnLoad;
 108     int read_only;
 109 } schema_cache;
 110
 111 typedef struct
 112 {
 113     CacheEntryType type;
 114     xmlSchemaPtr schema;
 115     xmlDocPtr doc;
 116     LONG ref;
 117 } cache_entry;
 118
 119 static const tid_t schema_cache_se_tids[] = {
 120     IXMLDOMSchemaCollection_tid,
 121     IXMLDOMSchemaCollection2_tid,
 122     NULL_tid
 123 };
 124
 125 /* datatypes lookup stuff
 126  * generated with help from gperf */
 127 #define DT_MIN_STR_LEN 2
 128 #define DT_MAX_STR_LEN 11
 129 #define DT_MIN_HASH_VALUE 2
 130 #define DT_MAX_HASH_VALUE 115
 131
 132 static const xmlChar DT_bin_base64[] = "bin.base64";
 133 static const xmlChar DT_bin_hex[] = "bin.hex";
 134 static const xmlChar DT_boolean[] = "boolean";
 135 static const xmlChar DT_char[] = "char";
 136 static const xmlChar DT_date[] = "date";
 137 static const xmlChar DT_date_tz[] = "date.tz";
 138 static const xmlChar DT_dateTime[] = "dateTime";
 139 static const xmlChar DT_dateTime_tz[] = "dateTime.tz";
 140 static const xmlChar DT_entity[] = "entity";
 141 static const xmlChar DT_entities[] = "entities";
 142 static const xmlChar DT_enumeration[] = "enumeration";
 143 static const xmlChar DT_fixed_14_4[] = "fixed.14.4";
 144 static const xmlChar DT_float[] = "float";
 145 static const xmlChar DT_i1[] = "i1";
 146 static const xmlChar DT_i2[] = "i2";
 147 static const xmlChar DT_i4[] = "i4";
 148 static const xmlChar DT_i8[] = "i8";
 149 static const xmlChar DT_id[] = "id";
 150 static const xmlChar DT_idref[] = "idref";
 151 static const xmlChar DT_idrefs[] = "idrefs";
 152 static const xmlChar DT_int[] = "int";
 153 static const xmlChar DT_nmtoken[] = "nmtoken";
 154 static const xmlChar DT_nmtokens[] = "nmtokens";
 155 static const xmlChar DT_notation[] = "notation";
 156 static const xmlChar DT_number[] = "number";
 157 static const xmlChar DT_r4[] = "r4";
 158 static const xmlChar DT_r8[] = "r8";
 159 static const xmlChar DT_string[] = "string";
 160 static const xmlChar DT_time[] = "time";
 161 static const xmlChar DT_time_tz[] = "time.tz";
 162 static const xmlChar DT_ui1[] = "ui1";
 163 static const xmlChar DT_ui2[] = "ui2";
 164 static const xmlChar DT_ui4[] = "ui4";
 165 static const xmlChar DT_ui8[] = "ui8";
 166 static const xmlChar DT_uri[] = "uri";
 167 static const xmlChar DT_uuid[] = "uuid";
 168
 169 static const OLECHAR wDT_bin_base64[] = {'b','i','n','.','b','a','s','e','6','4',0};
 170 static const OLECHAR wDT_bin_hex[] = {'b','i','n','.','h','e','x',0};
 171 static const OLECHAR wDT_boolean[] = {'b','o','o','l','e','a','n',0};
 172 static const OLECHAR wDT_char[] = {'c','h','a','r',0};
 173 static const OLECHAR wDT_date[] = {'d','a','t','e',0};
 174 static const OLECHAR wDT_date_tz[] = {'d','a','t','e','.','t','z',0};
 175 static const OLECHAR wDT_dateTime[] = {'d','a','t','e','T','i','m','e',0};
 176 static const OLECHAR wDT_dateTime_tz[] = {'d','a','t','e','T','i','m','e','.','t','z',0};
 177 static const OLECHAR wDT_entity[] = {'e','n','t','i','t','y',0};
 178 static const OLECHAR wDT_entities[] = {'e','n','t','i','t','i','e','s',0};
 179 static const OLECHAR wDT_enumeration[] = {'e','n','u','m','e','r','a','t','i','o','n',0};
 180 static const OLECHAR wDT_fixed_14_4[] = {'f','i','x','e','d','.','1','4','.','4',0};
 181 static const OLECHAR wDT_float[] = {'f','l','o','a','t',0};
 182 static const OLECHAR wDT_i1[] = {'i','1',0};
 183 static const OLECHAR wDT_i2[] = {'i','2',0};
 184 static const OLECHAR wDT_i4[] = {'i','4',0};
 185 static const OLECHAR wDT_i8[] = {'i','8',0};
 186 static const OLECHAR wDT_id[] = {'i','d',0};
 187 static const OLECHAR wDT_idref[] = {'i','d','r','e','f',0};
 188 static const OLECHAR wDT_idrefs[] = {'i','d','r','e','f','s',0};
 189 static const OLECHAR wDT_int[] = {'i','n','t',0};
 190 static const OLECHAR wDT_nmtoken[] = {'n','m','t','o','k','e','n',0};
 191 static const OLECHAR wDT_nmtokens[] = {'n','m','t','o','k','e','n','s',0};
 192 static const OLECHAR wDT_notation[] = {'n','o','t','a','t','i','o','n',0};
 193 static const OLECHAR wDT_number[] = {'n','u','m','b','e','r',0};
 194 static const OLECHAR wDT_r4[] = {'r','4',0};
 195 static const OLECHAR wDT_r8[] = {'r','8',0};
 196 static const OLECHAR wDT_string[] = {'s','t','r','i','n','g',0};
 197 static const OLECHAR wDT_time[] = {'t','i','m','e',0};
 198 static const OLECHAR wDT_time_tz[] = {'t','i','m','e','.','t','z',0};
 199 static const OLECHAR wDT_ui1[] = {'u','i','1',0};
 200 static const OLECHAR wDT_ui2[] = {'u','i','2',0};
 201 static const OLECHAR wDT_ui4[] = {'u','i','4',0};
 202 static const OLECHAR wDT_ui8[] = {'u','i','8',0};
 203 static const OLECHAR wDT_uri[] = {'u','r','i',0};
 204 static const OLECHAR wDT_uuid[] = {'u','u','i','d',0};
 205
 206 static const BYTE hash_assoc_values[] =
 207 {
 208     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 209     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 210     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 211     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 212     116, 116, 116, 116, 116, 116,  10, 116, 116,  55,
 213      45, 116,   5, 116,   0, 116,   0, 116, 116, 116,
 214     116, 116, 116, 116, 116,   5,   0,   0,  20,   0,
 215       0,  10,   0,   0, 116,   0,   0,   0,  15,   5,
 216     116, 116,  10,   0,   0,   0, 116, 116,   0,   0,
 217      10, 116, 116, 116, 116, 116, 116,   5,   0,   0,
 218      20,   0,   0,  10,   0,   0, 116,   0,   0,   0,
 219      15,   5, 116, 116,  10,   0,   0,   0, 116, 116,
 220       0,   0,  10, 116, 116, 116, 116, 116, 116, 116,
 221     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 222     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 223     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 224     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 225     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 226     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 227     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 228     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 229     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 230     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 231     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 232     116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
 233     116, 116, 116, 116, 116, 116
 234 };
 235
 236 static void LIBXML2_LOG_CALLBACK parser_error(void* ctx, char const* msg, ...)
 237 {
 238     va_list ap;
 239     va_start(ap, msg);
 240     LIBXML2_CALLBACK_ERR(Schema_parse, msg, ap);
 241     va_end(ap);
 242 }
 243
 244 static void LIBXML2_LOG_CALLBACK parser_warning(void* ctx, char const* msg, ...)
 245 {
 246     va_list ap;
 247     va_start(ap, msg);
 248     LIBXML2_CALLBACK_WARN(Schema_parse, msg, ap);
 249     va_end(ap);
 250 }
 251
 252 #ifdef HAVE_XMLSCHEMASSETPARSERSTRUCTUREDERRORS
 253 static void parser_serror(void* ctx, xmlErrorPtr err)
 254 {
 255     LIBXML2_CALLBACK_SERROR(Schema_parse, err);
 256 }
 257 #endif
 258
 259 static inline xmlSchemaPtr Schema_parse(xmlSchemaParserCtxtPtr spctx)
 260 {
 261     TRACE("(%p)\n", spctx);
 262
 263     xmlSchemaSetParserErrors(spctx, parser_error, parser_warning, NULL);
 264 #ifdef HAVE_XMLSCHEMASSETPARSERSTRUCTUREDERRORS
 265     xmlSchemaSetParserStructuredErrors(spctx, parser_serror, NULL);
 266 #endif
 267
 268     return xmlSchemaParse(spctx);
 269 }
 270
 271 static void LIBXML2_LOG_CALLBACK validate_error(void* ctx, char const* msg, ...)
 272 {
 273     va_list ap;
 274     va_start(ap, msg);
 275     LIBXML2_CALLBACK_ERR(Schema_validate_tree, msg, ap);
 276     va_end(ap);
 277 }
 278
 279 static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ...)
 280 {
 281     va_list ap;
 282     va_start(ap, msg);
 283     LIBXML2_CALLBACK_WARN(Schema_validate_tree, msg, ap);
 284     va_end(ap);
 285 }
 286
 287 #ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS
 288 static void validate_serror(void* ctx, xmlErrorPtr err)
 289 {
 290     LIBXML2_CALLBACK_SERROR(Schema_validate_tree, err);
 291 }
 292 #endif
 293
 294 static HRESULT schema_cache_get_item(IUnknown *iface, LONG index, VARIANT *item)
 295 {
 296     V_VT(item) = VT_BSTR;
 297     return IXMLDOMSchemaCollection2_get_namespaceURI((IXMLDOMSchemaCollection2*)iface, index, &V_BSTR(item));
 298 }
 299
 300 static const struct enumvariant_funcs schemacache_enumvariant = {
 301     schema_cache_get_item,
 302     NULL
 303 };
 304
 305 static inline HRESULT Schema_validate_tree(xmlSchemaPtr schema, xmlNodePtr tree)
 306 {
 307     xmlSchemaValidCtxtPtr svctx;
 308     int err;
 309
 310     TRACE("(%p, %p)\n", schema, tree);
 311     /* TODO: if validateOnLoad property is false,
 312      *       we probably need to validate the schema here. */
 313     svctx = xmlSchemaNewValidCtxt(schema);
 314     xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL);
 315 #ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS
 316     xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL);
 317 #endif
 318
 319     if (tree->type == XML_DOCUMENT_NODE)
 320         err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree);
 321     else
 322         err = xmlSchemaValidateOneElement(svctx, tree);
 323
 324     xmlSchemaFreeValidCtxt(svctx);
 325     return err? S_FALSE : S_OK;
 326 }
 327
 328 static DWORD dt_hash(xmlChar const* str, int len /* calculated if -1 */)
 329 {
 330     DWORD hval = (len == -1)? xmlStrlen(str) : len;
 331
 332     switch (hval)
 333     {
 334         default:
 335             hval += hash_assoc_values[str[10]];
 336             /*FALLTHROUGH*/
 337         case 10:
 338             hval += hash_assoc_values[str[9]];
 339             /*FALLTHROUGH*/
 340         case 9:
 341             hval += hash_assoc_values[str[8]];
 342             /*FALLTHROUGH*/
 343         case 8:
 344             hval += hash_assoc_values[str[7]];
 345             /*FALLTHROUGH*/
 346         case 7:
 347             hval += hash_assoc_values[str[6]];
 348             /*FALLTHROUGH*/
 349         case 6:
 350             hval += hash_assoc_values[str[5]];
 351             /*FALLTHROUGH*/
 352         case 5:
 353             hval += hash_assoc_values[str[4]];
 354             /*FALLTHROUGH*/
 355         case 4:
 356             hval += hash_assoc_values[str[3]];
 357             /*FALLTHROUGH*/
 358         case 3:
 359             hval += hash_assoc_values[str[2]];
 360             /*FALLTHROUGH*/
 361         case 2:
 362             hval += hash_assoc_values[str[1]];
 363             /*FALLTHROUGH*/
 364         case 1:
 365             hval += hash_assoc_values[str[0]];
 366             break;
 367     }
 368     return hval;
 369 }
 370
 371 static DWORD dt_hash_bstr(OLECHAR const* bstr, int len /* calculated if -1 */)
 372 {
 373     DWORD hval = (len == -1)? lstrlenW(bstr) : len;
 374
 375     switch (hval)
 376     {
 377         default:
 378             hval += (bstr[10] & 0xFF00)? 116 : hash_assoc_values[bstr[10]];
 379             /*FALLTHROUGH*/
 380         case 10:
 381             hval += (bstr[9] & 0xFF00)? 116 : hash_assoc_values[bstr[9]];
 382             /*FALLTHROUGH*/
 383         case 9:
 384             hval += (bstr[8] & 0xFF00)? 116 : hash_assoc_values[bstr[8]];
 385             /*FALLTHROUGH*/
 386         case 8:
 387             hval += (bstr[7] & 0xFF00)? 116 : hash_assoc_values[bstr[7]];
 388             /*FALLTHROUGH*/
 389         case 7:
 390             hval += (bstr[6] & 0xFF00)? 116 : hash_assoc_values[bstr[6]];
 391             /*FALLTHROUGH*/
 392         case 6:
 393             hval += (bstr[5] & 0xFF00)? 116 : hash_assoc_values[bstr[5]];
 394             /*FALLTHROUGH*/
 395         case 5:
 396             hval += (bstr[4] & 0xFF00)? 116 : hash_assoc_values[bstr[4]];
 397             /*FALLTHROUGH*/
 398         case 4:
 399             hval += (bstr[3] & 0xFF00)? 116 : hash_assoc_values[bstr[3]];
 400             /*FALLTHROUGH*/
 401         case 3:
 402             hval += (bstr[2] & 0xFF00)? 116 : hash_assoc_values[bstr[2]];
 403             /*FALLTHROUGH*/
 404         case 2:
 405             hval += (bstr[1] & 0xFF00)? 116 : hash_assoc_values[bstr[1]];
 406             /*FALLTHROUGH*/
 407         case 1:
 408             hval += (bstr[0] & 0xFF00)? 116 : hash_assoc_values[bstr[0]];
 409             break;
 410     }
 411     return hval;
 412 }
 413
 414 static const xmlChar *const DT_string_table[LAST_DT] =
 415 {
 416     DT_bin_base64,
 417     DT_bin_hex,
 418     DT_boolean,
 419     DT_char,
 420     DT_date,
 421     DT_date_tz,
 422     DT_dateTime,
 423     DT_dateTime_tz,
 424     DT_entity,
 425     DT_entities,
 426     DT_enumeration,
 427     DT_fixed_14_4,
 428     DT_float,
 429     DT_i1,
 430     DT_i2,
 431     DT_i4,
 432     DT_i8,
 433     DT_id,
 434     DT_idref,
 435     DT_idrefs,
 436     DT_int,
 437     DT_nmtoken,
 438     DT_nmtokens,
 439     DT_notation,
 440     DT_number,
 441     DT_r4,
 442     DT_r8,
 443     DT_string,
 444     DT_time,
 445     DT_time_tz,
 446     DT_ui1,
 447     DT_ui2,
 448     DT_ui4,
 449     DT_ui8,
 450     DT_uri,
 451     DT_uuid
 452 };
 453
 454 static const WCHAR *const DT_wstring_table[LAST_DT] =
 455 {
 456     wDT_bin_base64,
 457     wDT_bin_hex,
 458     wDT_boolean,
 459     wDT_char,
 460     wDT_date,
 461     wDT_date_tz,
 462     wDT_dateTime,
 463     wDT_dateTime_tz,
 464     wDT_entity,
 465     wDT_entities,
 466     wDT_enumeration,
 467     wDT_fixed_14_4,
 468     wDT_float,
 469     wDT_i1,
 470     wDT_i2,
 471     wDT_i4,
 472     wDT_i8,
 473     wDT_id,
 474     wDT_idref,
 475     wDT_idrefs,
 476     wDT_int,
 477     wDT_nmtoken,
 478     wDT_nmtokens,
 479     wDT_notation,
 480     wDT_number,
 481     wDT_r4,
 482     wDT_r8,
 483     wDT_string,
 484     wDT_time,
 485     wDT_time_tz,
 486     wDT_ui1,
 487     wDT_ui2,
 488     wDT_ui4,
 489     wDT_ui8,
 490     wDT_uri,
 491     wDT_uuid
 492 };
 493
 494 static const XDR_DT DT_lookup_table[] =
 495 {
 496     -1, -1,
 497     DT_I8,
 498     DT_UI8,
 499     DT_TIME,
 500     -1, -1,
 501     DT_I4,
 502     DT_UI4,
 503     -1, -1, -1,
 504     DT_R8,
 505     DT_URI,
 506     -1,
 507     DT_FLOAT,
 508     -1,
 509     DT_R4,
 510     DT_INT,
 511     DT_CHAR,
 512     -1,
 513     DT_ENTITY,
 514     DT_ID,
 515     DT_ENTITIES,
 516     DT_UUID,
 517     -1, -1,
 518     DT_TIME_TZ,
 519     -1,
 520     DT_DATE,
 521     -1,
 522     DT_NUMBER,
 523     DT_BIN_HEX,
 524     DT_DATETIME,
 525     -1,
 526     DT_IDREF,
 527     DT_IDREFS,
 528     DT_BOOLEAN,
 529     -1, -1, -1,
 530     DT_STRING,
 531     DT_NMTOKEN,
 532     DT_NMTOKENS,
 533     -1,
 534     DT_BIN_BASE64,
 535     -1,
 536     DT_I2,
 537     DT_UI2,
 538     -1, -1, -1,
 539     DT_DATE_TZ,
 540     DT_NOTATION,
 541     -1, -1,
 542     DT_DATETIME_TZ,
 543     DT_I1,
 544     DT_UI1,
 545     -1, -1,
 546     DT_ENUMERATION,
 547     -1, -1, -1, -1, -1, -1, -1, -1, -1,
 548     -1, -1, -1, -1, -1, -1, -1, -1, -1,
 549     -1, -1, -1, -1, -1, -1, -1, -1, -1,
 550     -1, -1, -1, -1, -1, -1, -1, -1, -1,
 551     -1, -1, -1, -1, -1, -1, -1, -1, -1,
 552     -1, -1, -1, -1, -1, -1, -1, -1,
 553     DT_FIXED_14_4
 554 };
 555
 556 XDR_DT str_to_dt(xmlChar const* str, int len /* calculated if -1 */)
 557 {
 558     DWORD hash = dt_hash(str, len);
 559     XDR_DT dt = DT_INVALID;
 560
 561     if (hash <= DT_MAX_HASH_VALUE)
 562         dt = DT_lookup_table[hash];
 563
 564     if (dt != DT_INVALID && xmlStrcasecmp(str, DT_string_table[dt]) == 0)
 565         return dt;
 566
 567     return DT_INVALID;
 568 }
 569
 570 XDR_DT bstr_to_dt(OLECHAR const* bstr, int len /* calculated if -1 */)
 571 {
 572     DWORD hash = dt_hash_bstr(bstr, len);
 573     XDR_DT dt = DT_INVALID;
 574
 575     if (hash <= DT_MAX_HASH_VALUE)
 576         dt = DT_lookup_table[hash];
 577
 578     if (dt != DT_INVALID && lstrcmpiW(bstr, DT_wstring_table[dt]) == 0)
 579         return dt;
 580
 581     return DT_INVALID;
 582 }
 583
 584 xmlChar const* dt_to_str(XDR_DT dt)
 585 {
 586     if (dt == DT_INVALID)
 587         return NULL;
 588
 589     return DT_string_table[dt];
 590 }
 591
 592 OLECHAR const* dt_to_bstr(XDR_DT dt)
 593 {
 594     if (dt == DT_INVALID)
 595         return NULL;
 596
 597     return DT_wstring_table[dt];
 598 }
 599
 600 const char* debugstr_dt(XDR_DT dt)
 601 {
 602     return debugstr_a(dt != DT_INVALID ? (const char*)DT_string_table[dt] : NULL);
 603 }
 604
 605 HRESULT dt_validate(XDR_DT dt, xmlChar const* content)
 606 {
 607     xmlDocPtr tmp_doc;
 608     xmlNodePtr node;
 609     xmlNsPtr ns;
 610     HRESULT hr;
 611
 612     TRACE("(dt:%s, %s)\n", debugstr_dt(dt), debugstr_a((char const*)content));
 613
 614     if (!datatypes_schema)
 615     {
 616         xmlSchemaParserCtxtPtr spctx;
 617         assert(datatypes_src != NULL);
 618         spctx = xmlSchemaNewMemParserCtxt((char const*)datatypes_src, datatypes_len);
 619         datatypes_schema = Schema_parse(spctx);
 620         xmlSchemaFreeParserCtxt(spctx);
 621     }
 622
 623     switch (dt)
 624     {
 625         case DT_INVALID:
 626             return E_FAIL;
 627         case DT_BIN_BASE64:
 628         case DT_BIN_HEX:
 629         case DT_BOOLEAN:
 630         case DT_CHAR:
 631         case DT_DATE:
 632         case DT_DATE_TZ:
 633         case DT_DATETIME:
 634         case DT_DATETIME_TZ:
 635         case DT_FIXED_14_4:
 636         case DT_FLOAT:
 637         case DT_I1:
 638         case DT_I2:
 639         case DT_I4:
 640         case DT_I8:
 641         case DT_INT:
 642         case DT_NMTOKEN:
 643         case DT_NMTOKENS:
 644         case DT_NUMBER:
 645         case DT_R4:
 646         case DT_R8:
 647         case DT_STRING:
 648         case DT_TIME:
 649         case DT_TIME_TZ:
 650         case DT_UI1:
 651         case DT_UI2:
 652         case DT_UI4:
 653         case DT_UI8:
 654         case DT_URI:
 655         case DT_UUID:
 656             if (!datatypes_schema)
 657             {
 658                 ERR("failed to load schema for urn:schemas-microsoft-com:datatypes, "
 659                     "you're probably using an old version of libxml2: " LIBXML_DOTTED_VERSION "\n");
 660
 661                 /* Hopefully they don't need much in the way of XDR datatypes support... */
 662                 return S_OK;
 663             }
 664
 665             if (content && xmlStrlen(content))
 666             {
 667                 tmp_doc = xmlNewDoc(NULL);
 668                 node = xmlNewChild((xmlNodePtr)tmp_doc, NULL, dt_to_str(dt), content);
 669                 ns = xmlNewNs(node, DT_nsURI, BAD_CAST "dt");
 670                 xmlSetNs(node, ns);
 671                 xmlDocSetRootElement(tmp_doc, node);
 672
 673                 hr = Schema_validate_tree(datatypes_schema, (xmlNodePtr)tmp_doc);
 674                 xmlFreeDoc(tmp_doc);
 675             }
 676             else
 677             {   /* probably the node is being created manually and has no content yet */
 678                 hr = S_OK;
 679             }
 680             return hr;
 681         default:
 682             FIXME("need to handle dt:%s\n", debugstr_dt(dt));
 683             return S_OK;
 684     }
 685 }
 686
 687 static inline xmlChar const* get_node_nsURI(xmlNodePtr node)
 688 {
 689     return (node->ns != NULL)? node->ns->href : NULL;
 690 }
 691
 692 static inline cache_entry* get_entry(schema_cache* This, xmlChar const* nsURI)
 693 {
 694     return (!nsURI)? xmlHashLookup(This->cache, BAD_CAST "") :
 695                      xmlHashLookup(This->cache, nsURI);
 696 }
 697
 698 static inline xmlSchemaPtr get_node_schema(schema_cache* This, xmlNodePtr node)
 699 {
 700     cache_entry* entry = get_entry(This, get_node_nsURI(node));
 701     return (!entry)? NULL : entry->schema;
 702 }
 703
 704 static xmlExternalEntityLoader _external_entity_loader;
 705
 706 static xmlParserInputPtr external_entity_loader(const char *URL, const char *ID,
 707                                                 xmlParserCtxtPtr ctxt)
 708 {
 709     xmlParserInputPtr input;
 710
 711     TRACE("(%s %s %p)\n", debugstr_a(URL), debugstr_a(ID), ctxt);
 712
 713     assert(MSXML_hInstance != NULL);
 714     assert(datatypes_rsrc != NULL);
 715     assert(datatypes_handle != NULL);
 716     assert(datatypes_src != NULL);
 717
 718     /* TODO: if the desired schema is in the cache, load it from there */
 719     if (lstrcmpA(URL, "urn:schemas-microsoft-com:datatypes") == 0)
 720     {
 721         TRACE("loading built-in schema for %s\n", URL);
 722         input = xmlNewStringInputStream(ctxt, datatypes_src);
 723     }
 724     else
 725     {
 726         input = _external_entity_loader(URL, ID, ctxt);
 727     }
 728
 729     return input;
 730 }
 731
 732 void schemasInit(void)
 733 {
 734     xmlChar* buf;
 735     if (!(datatypes_rsrc = FindResourceA(MSXML_hInstance, "DATATYPES", "XML")))
 736     {
 737         FIXME("failed to find resource for %s\n", DT_nsURI);
 738         return;
 739     }
 740
 741     if (!(datatypes_handle = LoadResource(MSXML_hInstance, datatypes_rsrc)))
 742     {
 743         FIXME("failed to load resource for %s\n", DT_nsURI);
 744         return;
 745     }
 746     buf = LockResource(datatypes_handle);
 747     datatypes_len = SizeofResource(MSXML_hInstance, datatypes_rsrc);
 748
 749     /* Resource is loaded as raw data,
 750      * need a null-terminated string */
 751     while (buf[datatypes_len - 1] != '>') datatypes_len--;
 752     datatypes_src = HeapAlloc(GetProcessHeap(), 0, datatypes_len + 1);
 753     memcpy(datatypes_src, buf, datatypes_len);
 754     datatypes_src[datatypes_len] = 0;
 755
 756     if (xmlGetExternalEntityLoader() != external_entity_loader)
 757     {
 758         _external_entity_loader = xmlGetExternalEntityLoader();
 759         xmlSetExternalEntityLoader(external_entity_loader);
 760     }
 761 }
 762
 763 void schemasCleanup(void)
 764 {
 765     xmlSchemaFree(datatypes_schema);
 766     HeapFree(GetProcessHeap(), 0, datatypes_src);
 767     xmlSetExternalEntityLoader(_external_entity_loader);
 768 }
 769
 770 static LONG cache_entry_add_ref(cache_entry* entry)
 771 {
 772     LONG ref = InterlockedIncrement(&entry->ref);
 773     TRACE("(%p)->(%d)\n", entry, ref);
 774     return ref;
 775 }
 776
 777 static LONG cache_entry_release(cache_entry* entry)
 778 {
 779     LONG ref = InterlockedDecrement(&entry->ref);
 780     TRACE("(%p)->(%d)\n", entry, ref);
 781
 782     if (ref == 0)
 783     {
 784         if (entry->type == CacheEntryType_XSD)
 785         {
 786             xmldoc_release(entry->doc);
 787             entry->schema->doc = NULL;
 788             xmlSchemaFree(entry->schema);
 789         }
 790         else if (entry->type == CacheEntryType_XDR)
 791         {
 792             xmldoc_release(entry->doc);
 793             xmldoc_release(entry->schema->doc);
 794             entry->schema->doc = NULL;
 795             xmlSchemaFree(entry->schema);
 796         }
 797
 798         heap_free(entry);
 799     }
 800     return ref;
 801 }
 802
 803 static const struct IXMLDOMSchemaCollection2Vtbl XMLDOMSchemaCollection2Vtbl;
 804
 805 static inline schema_cache* impl_from_IXMLDOMSchemaCollection2(IXMLDOMSchemaCollection2* iface)
 806 {
 807     return CONTAINING_RECORD(iface, schema_cache, IXMLDOMSchemaCollection2_iface);
 808 }
 809
 810 static inline schema_cache* impl_from_IXMLDOMSchemaCollection(IXMLDOMSchemaCollection* iface)
 811 {
 812     return CONTAINING_RECORD(iface, schema_cache, IXMLDOMSchemaCollection2_iface);
 813 }
 814
 815 static inline schema_cache* unsafe_impl_from_IXMLDOMSchemaCollection(IXMLDOMSchemaCollection *iface)
 816 {
 817     return iface->lpVtbl == (void*)&XMLDOMSchemaCollection2Vtbl ? impl_from_IXMLDOMSchemaCollection(iface) : NULL;
 818 }
 819
 820 static inline CacheEntryType cache_type_from_xmlDocPtr(xmlDocPtr schema)
 821 {
 822     xmlNodePtr root = NULL;
 823     if (schema)
 824         root = xmlDocGetRootElement(schema);
 825     if (root && root->ns)
 826     {
 827
 828         if (xmlStrEqual(root->name, XDR_schema) &&
 829             xmlStrEqual(root->ns->href, XDR_nsURI))
 830         {
 831             return CacheEntryType_XDR;
 832         }
 833         else if (xmlStrEqual(root->name, XSD_schema) &&
 834                  xmlStrEqual(root->ns->href, XSD_nsURI))
 835         {
 836             return CacheEntryType_XSD;
 837         }
 838     }
 839     return CacheEntryType_Invalid;
 840 }
 841
 842 static BOOL link_datatypes(xmlDocPtr schema)
 843 {
 844     xmlNodePtr root, next, child;
 845     xmlNsPtr ns;
 846
 847     assert(xmlGetExternalEntityLoader() == external_entity_loader);
 848     root = xmlDocGetRootElement(schema);
 849     if (!root)
 850         return FALSE;
 851
 852     for (ns = root->nsDef; ns != NULL; ns = ns->next)
 853     {
 854         if (xmlStrEqual(ns->href, DT_nsURI))
 855             break;
 856     }
 857
 858     if (!ns)
 859         return FALSE;
 860
 861     next = xmlFirstElementChild(root);
 862     child = xmlNewChild(root, NULL, BAD_CAST "import", NULL);
 863     if (next) child = xmlAddPrevSibling(next, child);
 864     xmlSetProp(child, BAD_CAST "namespace", DT_nsURI);
 865     xmlSetProp(child, BAD_CAST "schemaLocation", DT_nsURI);
 866
 867     return TRUE;
 868 }
 869
 870 static cache_entry* cache_entry_from_xsd_doc(xmlDocPtr doc, xmlChar const* nsURI, MSXML_VERSION v)
 871 {
 872     cache_entry* entry = heap_alloc(sizeof(cache_entry));
 873     xmlSchemaParserCtxtPtr spctx;
 874     xmlDocPtr new_doc = xmlCopyDoc(doc, 1);
 875
 876     link_datatypes(new_doc);
 877
 878     /* TODO: if the nsURI is different from the default xmlns or targetNamespace,
 879      *       do we need to do something special here? */
 880     entry->type = CacheEntryType_XSD;
 881     entry->ref = 0;
 882     spctx = xmlSchemaNewDocParserCtxt(new_doc);
 883
 884     if ((entry->schema = Schema_parse(spctx)))
 885     {
 886         xmldoc_init(entry->schema->doc, v);
 887         entry->doc = entry->schema->doc;
 888         xmldoc_add_ref(entry->doc);
 889     }
 890     else
 891     {
 892         FIXME("failed to parse doc\n");
 893         xmlFreeDoc(new_doc);
 894         heap_free(entry);
 895         entry = NULL;
 896     }
 897     xmlSchemaFreeParserCtxt(spctx);
 898     return entry;
 899 }
 900
 901 static cache_entry* cache_entry_from_xdr_doc(xmlDocPtr doc, xmlChar const* nsURI, MSXML_VERSION version)
 902 {
 903     cache_entry* entry = heap_alloc(sizeof(cache_entry));
 904     xmlSchemaParserCtxtPtr spctx;
 905     xmlDocPtr new_doc = xmlCopyDoc(doc, 1), xsd_doc = XDR_to_XSD_doc(doc, nsURI);
 906
 907     link_datatypes(xsd_doc);
 908
 909     entry->type = CacheEntryType_XDR;
 910     entry->ref = 0;
 911     spctx = xmlSchemaNewDocParserCtxt(xsd_doc);
 912
 913     if ((entry->schema = Schema_parse(spctx)))
 914     {
 915         entry->doc = new_doc;
 916         xmldoc_init(entry->schema->doc, version);
 917         xmldoc_init(entry->doc, version);
 918         xmldoc_add_ref(entry->doc);
 919         xmldoc_add_ref(entry->schema->doc);
 920     }
 921     else
 922     {
 923         FIXME("failed to parse doc\n");
 924         xmlFreeDoc(new_doc);
 925         xmlFreeDoc(xsd_doc);
 926         heap_free(entry);
 927         entry = NULL;
 928     }
 929     xmlSchemaFreeParserCtxt(spctx);
 930
 931     return entry;
 932 }
 933
 934 static cache_entry* cache_entry_from_url(VARIANT url, xmlChar const* nsURI, MSXML_VERSION version)
 935 {
 936     cache_entry* entry;
 937     IXMLDOMDocument3* domdoc = NULL;
 938     xmlDocPtr doc = NULL;
 939     HRESULT hr = DOMDocument_create(version, NULL, (void**)&domdoc);
 940     VARIANT_BOOL b = VARIANT_FALSE;
 941     CacheEntryType type = CacheEntryType_Invalid;
 942
 943     if (hr != S_OK)
 944     {
 945         FIXME("failed to create domdoc\n");
 946         return NULL;
 947     }
 948     assert(domdoc != NULL);
 949     assert(V_VT(&url) == VT_BSTR);
 950
 951     hr = IXMLDOMDocument3_load(domdoc, url, &b);
 952     if (hr != S_OK)
 953     {
 954         ERR("IXMLDOMDocument3_load() returned 0x%08x\n", hr);
 955         if (b != VARIANT_TRUE)
 956         {
 957             FIXME("Failed to load doc at %s\n", debugstr_w(V_BSTR(&url)));
 958             IXMLDOMDocument3_Release(domdoc);
 959             return NULL;
 960         }
 961     }
 962     doc = xmlNodePtr_from_domnode((IXMLDOMNode*)domdoc, XML_DOCUMENT_NODE)->doc;
 963     type = cache_type_from_xmlDocPtr(doc);
 964
 965     switch (type)
 966     {
 967         case CacheEntryType_XSD:
 968             entry = cache_entry_from_xsd_doc(doc, nsURI, version);
 969             break;
 970         case CacheEntryType_XDR:
 971             entry = cache_entry_from_xdr_doc(doc, nsURI, version);
 972             break;
 973         default:
 974             entry = NULL;
 975             FIXME("invalid schema\n");
 976             break;
 977     }
 978     IXMLDOMDocument3_Release(domdoc);
 979
 980     return entry;
 981 }
 982
 983 static void cache_free(void* data, xmlChar* name /* ignored */)
 984 {
 985     cache_entry_release((cache_entry*)data);
 986 }
 987
 988 /* returns index or -1 if not found */
 989 static int cache_free_uri(schema_cache *cache, const xmlChar *uri)
 990 {
 991     int i;
 992
 993     for (i = 0; i < cache->count; i++)
 994         if (xmlStrEqual(cache->uris[i], uri))
 995         {
 996             heap_free(cache->uris[i]);
 997             return i;
 998         }
 999
1000     return -1;
1001 }
1002
1003 static void cache_add_entry(schema_cache *cache, const xmlChar *uri, cache_entry *entry)
1004 {
1005     int i;
1006
1007     /* meaning no entry found with this name */
1008     if (xmlHashRemoveEntry(cache->cache, uri, cache_free))
1009     {
1010         if (cache->count == cache->allocated)
1011         {
1012             cache->allocated *= 2;
1013             cache->uris = heap_realloc(cache->uris, cache->allocated*sizeof(xmlChar*));
1014         }
1015         i = cache->count++;
1016     }
1017     else
1018         i = cache_free_uri(cache, uri);
1019
1020     cache->uris[i] = heap_strdupxmlChar(uri);
1021     xmlHashAddEntry(cache->cache, uri, entry);
1022 }
1023
1024 static void cache_remove_entry(schema_cache *cache, const xmlChar *uri)
1025 {
1026     /* adjust index if entry was really removed */
1027     if (xmlHashRemoveEntry(cache->cache, uri, cache_free) == 0)
1028     {
1029         int i = cache_free_uri(cache, uri);
1030         if (i == -1) return;
1031         /* shift array */
1032         if (i != --cache->count)
1033             memmove(&cache->uris[i], &cache->uris[i+1], (cache->count-i)*sizeof(xmlChar*));
1034     }
1035 }
1036
1037 /* This one adds all namespaces defined in document to a cache, without anything
1038    associated with uri obviously.
1039    Unfortunately namespace:: axis implementation in libxml2 differs from what we need,
1040    it uses additional node type to describe namespace definition attribute while
1041    in msxml it's expected to be a normal attribute - as a workaround document is
1042    queried at libxml2 level here. */
1043 HRESULT cache_from_doc_ns(IXMLDOMSchemaCollection2 *iface, xmlnode *node)
1044 {
1045     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1046     static const xmlChar query[] = "//*/namespace::*";
1047     xmlXPathObjectPtr nodeset;
1048     xmlXPathContextPtr ctxt;
1049
1050     This->read_only = 1;
1051
1052     ctxt = xmlXPathNewContext(node->node->doc);
1053
1054     nodeset = xmlXPathEvalExpression(query, ctxt);
1055     xmlXPathFreeContext(ctxt);
1056
1057     if (nodeset)
1058     {
1059         int pos = 0, len = xmlXPathNodeSetGetLength(nodeset->nodesetval);
1060
1061         if (len == 0) return S_OK;
1062
1063         while (pos < len)
1064         {
1065             xmlNodePtr node = xmlXPathNodeSetItem(nodeset->nodesetval, pos);
1066             if (node->type == XML_NAMESPACE_DECL)
1067             {
1068                 static const xmlChar defns[] = "http://www.w3.org/XML/1998/namespace";
1069                 xmlNsPtr ns = (xmlNsPtr)node;
1070                 cache_entry *entry;
1071
1072                 /* filter out default uri */
1073                 if (xmlStrEqual(ns->href, defns))
1074                 {
1075                     pos++;
1076                     continue;
1077                 }
1078
1079                 entry = heap_alloc(sizeof(cache_entry));
1080                 entry->type = CacheEntryType_NS;
1081                 entry->ref = 1;
1082                 entry->schema = NULL;
1083                 entry->doc = NULL;
1084
1085                 cache_add_entry(This, ns->href, entry);
1086             }
1087             pos++;
1088         }
1089
1090         xmlXPathFreeObject(nodeset);
1091     }
1092
1093     return S_OK;
1094 }
1095
1096 static HRESULT WINAPI schema_cache_QueryInterface(IXMLDOMSchemaCollection2* iface,
1097                                                   REFIID riid, void** ppvObject)
1098 {
1099     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1100
1101     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1102
1103     if ( IsEqualIID(riid, &IID_IUnknown) ||
1104          IsEqualIID(riid, &IID_IDispatch) ||
1105          IsEqualIID(riid, &IID_IXMLDOMSchemaCollection) ||
1106          IsEqualIID(riid, &IID_IXMLDOMSchemaCollection2) )
1107     {
1108         *ppvObject = iface;
1109     }
1110     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
1111     {
1112         return *ppvObject ? S_OK : E_NOINTERFACE;
1113     }
1114     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
1115     {
1116         return node_create_supporterrorinfo(schema_cache_se_tids, ppvObject);
1117     }
1118     else
1119     {
1120         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1121         *ppvObject = NULL;
1122         return E_NOINTERFACE;
1123     }
1124
1125     IXMLDOMSchemaCollection2_AddRef(iface);
1126
1127     return S_OK;
1128 }
1129
1130 static ULONG WINAPI schema_cache_AddRef(IXMLDOMSchemaCollection2* iface)
1131 {
1132     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1133     LONG ref = InterlockedIncrement(&This->ref);
1134     TRACE("(%p)->(%d)\n", This, ref);
1135     return ref;
1136 }
1137
1138 static ULONG WINAPI schema_cache_Release(IXMLDOMSchemaCollection2* iface)
1139 {
1140     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1141     LONG ref = InterlockedDecrement(&This->ref);
1142     TRACE("(%p)->(%d)\n", This, ref);
1143
1144     if (ref == 0)
1145     {
1146         int i;
1147
1148         for (i = 0; i < This->count; i++)
1149             heap_free(This->uris[i]);
1150         heap_free(This->uris);
1151         xmlHashFree(This->cache, cache_free);
1152         release_dispex(&This->dispex);
1153         heap_free(This);
1154     }
1155
1156     return ref;
1157 }
1158
1159 static HRESULT WINAPI schema_cache_GetTypeInfoCount(IXMLDOMSchemaCollection2* iface,
1160                                                     UINT* pctinfo)
1161 {
1162     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1163     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1164 }
1165
1166 static HRESULT WINAPI schema_cache_GetTypeInfo(IXMLDOMSchemaCollection2* iface,
1167                                                UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1168 {
1169     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1170     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
1171         iTInfo, lcid, ppTInfo);
1172 }
1173
1174 static HRESULT WINAPI schema_cache_GetIDsOfNames(IXMLDOMSchemaCollection2* iface,
1175                                                  REFIID riid, LPOLESTR* rgszNames,
1176                                                  UINT cNames, LCID lcid, DISPID* rgDispId)
1177 {
1178     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1179     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
1180         riid, rgszNames, cNames, lcid, rgDispId);
1181 }
1182
1183 static HRESULT WINAPI schema_cache_Invoke(IXMLDOMSchemaCollection2* iface,
1184                                           DISPID dispIdMember, REFIID riid, LCID lcid,
1185                                           WORD wFlags, DISPPARAMS* pDispParams,
1186                                           VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
1187                                           UINT* puArgErr)
1188 {
1189     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1190     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
1191         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1192 }
1193
1194 static HRESULT WINAPI schema_cache_add(IXMLDOMSchemaCollection2* iface, BSTR uri, VARIANT var)
1195 {
1196     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1197     xmlChar* name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1198     TRACE("(%p)->(%s %s)\n", This, debugstr_w(uri), debugstr_variant(&var));
1199
1200     if (This->read_only) return E_FAIL;
1201
1202     switch (V_VT(&var))
1203     {
1204         case VT_NULL:
1205             {
1206                 cache_remove_entry(This, name);
1207             }
1208             break;
1209
1210         case VT_BSTR:
1211             {
1212                 cache_entry* entry = cache_entry_from_url(var, name, This->version);
1213
1214                 if (entry)
1215                 {
1216                     cache_entry_add_ref(entry);
1217                 }
1218                 else
1219                 {
1220                     heap_free(name);
1221                     return E_FAIL;
1222                 }
1223
1224                 cache_add_entry(This, name, entry);
1225             }
1226             break;
1227
1228         case VT_DISPATCH:
1229             {
1230                 xmlDocPtr doc = NULL;
1231                 cache_entry* entry;
1232                 CacheEntryType type;
1233                 IXMLDOMNode* domnode = NULL;
1234                 IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IXMLDOMNode, (void**)&domnode);
1235
1236                 if (domnode)
1237                     doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
1238
1239                 if (!doc)
1240                 {
1241                     IXMLDOMNode_Release(domnode);
1242                     heap_free(name);
1243                     return E_INVALIDARG;
1244                 }
1245                 type = cache_type_from_xmlDocPtr(doc);
1246
1247                 if (type == CacheEntryType_XSD)
1248                 {
1249                     entry = cache_entry_from_xsd_doc(doc, name, This->version);
1250                 }
1251                 else if (type == CacheEntryType_XDR)
1252                 {
1253                     entry = cache_entry_from_xdr_doc(doc, name, This->version);
1254                 }
1255                 else
1256                 {
1257                     WARN("invalid schema!\n");
1258                     entry = NULL;
1259                 }
1260
1261                 IXMLDOMNode_Release(domnode);
1262
1263                 if (entry)
1264                 {
1265                     cache_entry_add_ref(entry);
1266                 }
1267                 else
1268                 {
1269                     heap_free(name);
1270                     return E_FAIL;
1271                 }
1272
1273                 cache_add_entry(This, name, entry);
1274             }
1275             break;
1276
1277         default:
1278             {
1279                 heap_free(name);
1280                 return E_INVALIDARG;
1281             }
1282     }
1283     heap_free(name);
1284     return S_OK;
1285 }
1286
1287 static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri,
1288                                        IXMLDOMNode** node)
1289 {
1290     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1291     cache_entry* entry;
1292     xmlChar* name;
1293
1294     TRACE("(%p)->(%s %p)\n", This, debugstr_w(uri), node);
1295
1296     if (This->version == MSXML6) return E_NOTIMPL;
1297
1298     if (!node)
1299         return E_POINTER;
1300
1301     name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1302     entry = (cache_entry*) xmlHashLookup(This->cache, name);
1303     heap_free(name);
1304
1305     /* TODO: this should be read-only */
1306     if (entry && entry->doc)
1307         return get_domdoc_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node);
1308
1309     *node = NULL;
1310     return S_OK;
1311 }
1312
1313 static HRESULT WINAPI schema_cache_remove(IXMLDOMSchemaCollection2* iface, BSTR uri)
1314 {
1315     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1316     xmlChar* name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1317     TRACE("(%p)->(%s)\n", This, debugstr_w(uri));
1318
1319     if (This->version == MSXML6) return E_NOTIMPL;
1320
1321     cache_remove_entry(This, name);
1322     heap_free(name);
1323     return S_OK;
1324 }
1325
1326 static HRESULT WINAPI schema_cache_get_length(IXMLDOMSchemaCollection2* iface, LONG* length)
1327 {
1328     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1329     TRACE("(%p)->(%p)\n", This, length);
1330
1331     if (!length)
1332         return E_POINTER;
1333
1334     *length = This->count;
1335     return S_OK;
1336 }
1337
1338 static HRESULT WINAPI schema_cache_get_namespaceURI(IXMLDOMSchemaCollection2* iface,
1339                                                     LONG index, BSTR* uri)
1340 {
1341     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1342
1343     TRACE("(%p)->(%i %p)\n", This, index, uri);
1344
1345     if (!uri)
1346         return E_POINTER;
1347
1348     if (index >= This->count)
1349         return E_FAIL;
1350
1351     *uri = bstr_from_xmlChar(This->uris[index]);
1352     return S_OK;
1353 }
1354
1355 static void cache_copy(void* data, void* dest, xmlChar* name)
1356 {
1357     schema_cache* This = (schema_cache*) dest;
1358     cache_entry* entry = (cache_entry*) data;
1359
1360     if (xmlHashLookup(This->cache, name) == NULL)
1361     {
1362         cache_entry_add_ref(entry);
1363         cache_add_entry(This, name, entry);
1364     }
1365 }
1366
1367 static HRESULT WINAPI schema_cache_addCollection(IXMLDOMSchemaCollection2* iface,
1368                                                  IXMLDOMSchemaCollection* collection)
1369 {
1370     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1371     schema_cache* That;
1372
1373     TRACE("(%p)->(%p)\n", This, collection);
1374
1375     if (!collection)
1376         return E_POINTER;
1377
1378     That = unsafe_impl_from_IXMLDOMSchemaCollection(collection);
1379     if (!That)
1380     {
1381         ERR("external collection implementation\n");
1382         return E_FAIL;
1383     }
1384
1385     /* TODO: detect errors while copying & return E_FAIL */
1386     xmlHashScan(That->cache, cache_copy, This);
1387
1388     return S_OK;
1389 }
1390
1391 static HRESULT WINAPI schema_cache_get__newEnum(IXMLDOMSchemaCollection2* iface, IUnknown** enumv)
1392 {
1393     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1394     TRACE("(%p)->(%p)\n", This, enumv);
1395     return create_enumvariant((IUnknown*)iface, TRUE, &schemacache_enumvariant, (IEnumVARIANT**)enumv);
1396 }
1397
1398 static HRESULT WINAPI schema_cache_validate(IXMLDOMSchemaCollection2* iface)
1399 {
1400     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1401     FIXME("(%p): stub\n", This);
1402     return E_NOTIMPL;
1403 }
1404
1405 static HRESULT WINAPI schema_cache_put_validateOnLoad(IXMLDOMSchemaCollection2* iface,
1406                                                       VARIANT_BOOL value)
1407 {
1408     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1409     FIXME("(%p)->(%d): stub\n", This, value);
1410
1411     This->validateOnLoad = value;
1412     /* it's ok to disable it, cause we don't validate on load anyway */
1413     if (value == VARIANT_FALSE) return S_OK;
1414
1415     return E_NOTIMPL;
1416 }
1417
1418 static HRESULT WINAPI schema_cache_get_validateOnLoad(IXMLDOMSchemaCollection2* iface,
1419                                                       VARIANT_BOOL* value)
1420 {
1421     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1422     TRACE("(%p)->(%p)\n", This, value);
1423
1424     if (!value) return E_POINTER;
1425     *value = This->validateOnLoad;
1426
1427     return S_OK;
1428 }
1429
1430 static HRESULT WINAPI schema_cache_getSchema(IXMLDOMSchemaCollection2* iface,
1431                                              BSTR namespaceURI, ISchema** schema)
1432 {
1433     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1434     FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(namespaceURI), schema);
1435     if (schema)
1436         *schema = NULL;
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI schema_cache_getDeclaration(IXMLDOMSchemaCollection2* iface,
1441                                                   IXMLDOMNode* node, ISchemaItem** item)
1442 {
1443     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1444     FIXME("(%p)->(%p %p): stub\n", This, node, item);
1445     if (item)
1446         *item = NULL;
1447     return E_NOTIMPL;
1448 }
1449
1450 static const struct IXMLDOMSchemaCollection2Vtbl XMLDOMSchemaCollection2Vtbl =
1451 {
1452     schema_cache_QueryInterface,
1453     schema_cache_AddRef,
1454     schema_cache_Release,
1455     schema_cache_GetTypeInfoCount,
1456     schema_cache_GetTypeInfo,
1457     schema_cache_GetIDsOfNames,
1458     schema_cache_Invoke,
1459     schema_cache_add,
1460     schema_cache_get,
1461     schema_cache_remove,
1462     schema_cache_get_length,
1463     schema_cache_get_namespaceURI,
1464     schema_cache_addCollection,
1465     schema_cache_get__newEnum,
1466     schema_cache_validate,
1467     schema_cache_put_validateOnLoad,
1468     schema_cache_get_validateOnLoad,
1469     schema_cache_getSchema,
1470     schema_cache_getDeclaration
1471 };
1472
1473 static xmlSchemaElementPtr lookup_schema_elemDecl(xmlSchemaPtr schema, xmlNodePtr node)
1474 {
1475     xmlSchemaElementPtr decl = NULL;
1476     xmlChar const* nsURI = get_node_nsURI(node);
1477
1478     TRACE("(%p, %p)\n", schema, node);
1479
1480     if (xmlStrEqual(nsURI, schema->targetNamespace))
1481         decl = xmlHashLookup(schema->elemDecl, node->name);
1482
1483     if (!decl && xmlHashSize(schema->schemasImports) > 1)
1484     {
1485         FIXME("declaration not found in main schema - need to check schema imports!\n");
1486         /*xmlSchemaImportPtr import;
1487         if (nsURI == NULL)
1488             import = xmlHashLookup(schema->schemasImports, XML_SCHEMAS_NO_NAMESPACE);
1489         else
1490             import = xmlHashLookup(schema->schemasImports, node->ns->href);
1491
1492         if (import != NULL)
1493             decl = xmlHashLookup(import->schema->elemDecl, node->name);*/
1494     }
1495
1496     return decl;
1497 }
1498
1499 static inline xmlNodePtr lookup_schema_element(xmlSchemaPtr schema, xmlNodePtr node)
1500 {
1501     xmlSchemaElementPtr decl = lookup_schema_elemDecl(schema, node);
1502     while (decl != NULL && decl->refDecl != NULL)
1503         decl = decl->refDecl;
1504     return (decl != NULL)? decl->node : NULL;
1505 }
1506
1507 HRESULT SchemaCache_validate_tree(IXMLDOMSchemaCollection2* iface, xmlNodePtr tree)
1508 {
1509     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1510     xmlSchemaPtr schema;
1511
1512     TRACE("(%p, %p)\n", This, tree);
1513
1514     if (!tree)
1515         return E_POINTER;
1516
1517     if (tree->type == XML_DOCUMENT_NODE)
1518         tree = xmlDocGetRootElement(tree->doc);
1519
1520     schema = get_node_schema(This, tree);
1521     /* TODO: if the ns is not in the cache, and it's a URL,
1522      *       do we try to load from that? */
1523     if (schema)
1524         return Schema_validate_tree(schema, tree);
1525     else
1526         WARN("no schema found for xmlns=%s\n", get_node_nsURI(tree));
1527
1528     return E_FAIL;
1529 }
1530
1531 XDR_DT SchemaCache_get_node_dt(IXMLDOMSchemaCollection2* iface, xmlNodePtr node)
1532 {
1533     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1534     xmlSchemaPtr schema = get_node_schema(This, node);
1535     XDR_DT dt = DT_INVALID;
1536
1537     TRACE("(%p, %p)\n", This, node);
1538
1539     if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
1540     {
1541         dt = str_to_dt(node->name, -1);
1542     }
1543     else if (schema)
1544     {
1545         xmlChar* str;
1546         xmlNodePtr schema_node = lookup_schema_element(schema, node);
1547
1548         str = xmlGetNsProp(schema_node, BAD_CAST "dt", DT_nsURI);
1549         if (str)
1550         {
1551             dt = str_to_dt(str, -1);
1552             xmlFree(str);
1553         }
1554     }
1555
1556     return dt;
1557 }
1558
1559 static const tid_t schemacache_iface_tids[] = {
1560     IXMLDOMSchemaCollection2_tid,
1561     0
1562 };
1563
1564 static dispex_static_data_t schemacache_dispex = {
1565     NULL,
1566     IXMLDOMSchemaCollection2_tid,
1567     NULL,
1568     schemacache_iface_tids
1569 };
1570
1571 HRESULT SchemaCache_create(MSXML_VERSION version, IUnknown* outer, void** obj)
1572 {
1573     schema_cache* This = heap_alloc(sizeof(schema_cache));
1574     if (!This)
1575         return E_OUTOFMEMORY;
1576
1577     TRACE("(%d %p %p)\n", version, outer, obj);
1578
1579     This->IXMLDOMSchemaCollection2_iface.lpVtbl = &XMLDOMSchemaCollection2Vtbl;
1580     This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE);
1581     This->allocated = 10;
1582     This->count = 0;
1583     This->uris = heap_alloc(This->allocated*sizeof(xmlChar*));
1584     This->ref = 1;
1585     This->version = version;
1586     This->validateOnLoad = VARIANT_TRUE;
1587     This->read_only = 0;
1588     init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSchemaCollection2_iface, &schemacache_dispex);
1589
1590     *obj = &This->IXMLDOMSchemaCollection2_iface;
1591     return S_OK;
1592 }
1593
1594 #else
1595
1596 HRESULT SchemaCache_create(MSXML_VERSION version, IUnknown* outer, void** obj)
1597 {
1598     MESSAGE("This program tried to use a SchemaCache object, but\n"
1599             "libxml2 support was not present at compile time.\n");
1600     return E_NOTIMPL;
1601 }
1602
1603 #endif