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