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         if (len == 0) return S_OK;
1042
1043         while (pos < len)
1044         {
1045             xmlNodePtr node = xmlXPathNodeSetItem(nodeset->nodesetval, pos);
1046             if (node->type == XML_NAMESPACE_DECL)
1047             {
1048                 static const xmlChar defns[] = "http://www.w3.org/XML/1998/namespace";
1049                 xmlNsPtr ns = (xmlNsPtr)node;
1050                 cache_entry *entry;
1051
1052                 /* filter out default uri */
1053                 if (xmlStrEqual(ns->href, defns))
1054                 {
1055                     pos++;
1056                     continue;
1057                 }
1058
1059                 entry = heap_alloc(sizeof(cache_entry));
1060                 entry->type = CacheEntryType_NS;
1061                 entry->ref = 1;
1062                 entry->schema = NULL;
1063                 entry->doc = NULL;
1064
1065                 cache_add_entry(This, ns->href, entry);
1066             }
1067             pos++;
1068         }
1069
1070         xmlXPathFreeObject(nodeset);
1071     }
1072
1073     return S_OK;
1074 }
1075
1076 static HRESULT WINAPI schema_cache_QueryInterface(IXMLDOMSchemaCollection2* iface,
1077                                                   REFIID riid, void** ppvObject)
1078 {
1079     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1080
1081     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1082
1083     if ( IsEqualIID(riid, &IID_IUnknown) ||
1084          IsEqualIID(riid, &IID_IDispatch) ||
1085          IsEqualIID(riid, &IID_IXMLDOMSchemaCollection) ||
1086          IsEqualIID(riid, &IID_IXMLDOMSchemaCollection2) )
1087     {
1088         *ppvObject = iface;
1089     }
1090     else if (dispex_query_interface(&This->dispex, riid, ppvObject))
1091     {
1092         return *ppvObject ? S_OK : E_NOINTERFACE;
1093     }
1094     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
1095     {
1096         return node_create_supporterrorinfo(schema_cache_se_tids, ppvObject);
1097     }
1098     else
1099     {
1100         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1101         *ppvObject = NULL;
1102         return E_NOINTERFACE;
1103     }
1104
1105     IXMLDOMSchemaCollection2_AddRef(iface);
1106
1107     return S_OK;
1108 }
1109
1110 static ULONG WINAPI schema_cache_AddRef(IXMLDOMSchemaCollection2* iface)
1111 {
1112     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1113     LONG ref = InterlockedIncrement(&This->ref);
1114     TRACE("(%p)->(%d)\n", This, ref);
1115     return ref;
1116 }
1117
1118 static ULONG WINAPI schema_cache_Release(IXMLDOMSchemaCollection2* iface)
1119 {
1120     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1121     LONG ref = InterlockedDecrement(&This->ref);
1122     TRACE("(%p)->(%d)\n", This, ref);
1123
1124     if (ref == 0)
1125     {
1126         int i;
1127
1128         for (i = 0; i < This->count; i++)
1129             heap_free(This->uris[i]);
1130         heap_free(This->uris);
1131         xmlHashFree(This->cache, cache_free);
1132         heap_free(This);
1133     }
1134
1135     return ref;
1136 }
1137
1138 static HRESULT WINAPI schema_cache_GetTypeInfoCount(IXMLDOMSchemaCollection2* iface,
1139                                                     UINT* pctinfo)
1140 {
1141     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1142     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1143 }
1144
1145 static HRESULT WINAPI schema_cache_GetTypeInfo(IXMLDOMSchemaCollection2* iface,
1146                                                UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
1147 {
1148     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1149     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
1150         iTInfo, lcid, ppTInfo);
1151 }
1152
1153 static HRESULT WINAPI schema_cache_GetIDsOfNames(IXMLDOMSchemaCollection2* iface,
1154                                                  REFIID riid, LPOLESTR* rgszNames,
1155                                                  UINT cNames, LCID lcid, DISPID* rgDispId)
1156 {
1157     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1158     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
1159         riid, rgszNames, cNames, lcid, rgDispId);
1160 }
1161
1162 static HRESULT WINAPI schema_cache_Invoke(IXMLDOMSchemaCollection2* iface,
1163                                           DISPID dispIdMember, REFIID riid, LCID lcid,
1164                                           WORD wFlags, DISPPARAMS* pDispParams,
1165                                           VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
1166                                           UINT* puArgErr)
1167 {
1168     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1169     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
1170         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1171 }
1172
1173 static HRESULT WINAPI schema_cache_add(IXMLDOMSchemaCollection2* iface, BSTR uri, VARIANT var)
1174 {
1175     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1176     xmlChar* name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1177     TRACE("(%p)->(%s %s)\n", This, debugstr_w(uri), debugstr_variant(&var));
1178
1179     if (This->read_only) return E_FAIL;
1180
1181     switch (V_VT(&var))
1182     {
1183         case VT_NULL:
1184             {
1185                 cache_remove_entry(This, name);
1186             }
1187             break;
1188
1189         case VT_BSTR:
1190             {
1191                 cache_entry* entry = cache_entry_from_url(var, name, This->version);
1192
1193                 if (entry)
1194                 {
1195                     cache_entry_add_ref(entry);
1196                 }
1197                 else
1198                 {
1199                     heap_free(name);
1200                     return E_FAIL;
1201                 }
1202
1203                 cache_add_entry(This, name, entry);
1204             }
1205             break;
1206
1207         case VT_DISPATCH:
1208             {
1209                 xmlDocPtr doc = NULL;
1210                 cache_entry* entry;
1211                 CacheEntryType type;
1212                 IXMLDOMNode* domnode = NULL;
1213                 IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IXMLDOMNode, (void**)&domnode);
1214
1215                 if (domnode)
1216                     doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
1217
1218                 if (!doc)
1219                 {
1220                     IXMLDOMNode_Release(domnode);
1221                     heap_free(name);
1222                     return E_INVALIDARG;
1223                 }
1224                 type = cache_type_from_xmlDocPtr(doc);
1225
1226                 if (type == CacheEntryType_XSD)
1227                 {
1228                     entry = cache_entry_from_xsd_doc(doc, name, This->version);
1229                 }
1230                 else if (type == CacheEntryType_XDR)
1231                 {
1232                     entry = cache_entry_from_xdr_doc(doc, name, This->version);
1233                 }
1234                 else
1235                 {
1236                     WARN("invalid schema!\n");
1237                     entry = NULL;
1238                 }
1239
1240                 IXMLDOMNode_Release(domnode);
1241
1242                 if (entry)
1243                 {
1244                     cache_entry_add_ref(entry);
1245                 }
1246                 else
1247                 {
1248                     heap_free(name);
1249                     return E_FAIL;
1250                 }
1251
1252                 cache_add_entry(This, name, entry);
1253             }
1254             break;
1255
1256         default:
1257             {
1258                 heap_free(name);
1259                 return E_INVALIDARG;
1260             }
1261     }
1262     heap_free(name);
1263     return S_OK;
1264 }
1265
1266 static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri,
1267                                        IXMLDOMNode** node)
1268 {
1269     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1270     cache_entry* entry;
1271     xmlChar* name;
1272
1273     TRACE("(%p)->(%s %p)\n", This, debugstr_w(uri), node);
1274
1275     if (This->version == MSXML6)
1276     {
1277         if (node) *node = NULL;
1278         return E_NOTIMPL;
1279     }
1280
1281     if (!node)
1282         return E_POINTER;
1283
1284     *node = NULL;
1285
1286     name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1287     entry = (cache_entry*) xmlHashLookup(This->cache, name);
1288     heap_free(name);
1289
1290     /* TODO: this should be read-only */
1291     if (entry && entry->doc)
1292         return get_domdoc_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node);
1293
1294     return S_OK;
1295 }
1296
1297 static HRESULT WINAPI schema_cache_remove(IXMLDOMSchemaCollection2* iface, BSTR uri)
1298 {
1299     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1300     xmlChar* name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);
1301     TRACE("(%p)->(%s)\n", This, debugstr_w(uri));
1302
1303     if (This->version == MSXML6) return E_NOTIMPL;
1304
1305     cache_remove_entry(This, name);
1306     heap_free(name);
1307     return S_OK;
1308 }
1309
1310 static HRESULT WINAPI schema_cache_get_length(IXMLDOMSchemaCollection2* iface, LONG* length)
1311 {
1312     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1313     TRACE("(%p)->(%p)\n", This, length);
1314
1315     if (!length)
1316         return E_POINTER;
1317
1318     *length = This->count;
1319     return S_OK;
1320 }
1321
1322 static HRESULT WINAPI schema_cache_get_namespaceURI(IXMLDOMSchemaCollection2* iface,
1323                                                     LONG index, BSTR* uri)
1324 {
1325     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1326
1327     TRACE("(%p)->(%i %p)\n", This, index, uri);
1328
1329     if (!uri)
1330         return E_POINTER;
1331
1332     if (This->version == MSXML6)
1333         *uri = NULL;
1334
1335     if (index >= This->count)
1336         return E_FAIL;
1337
1338     *uri = bstr_from_xmlChar(This->uris[index]);
1339     return S_OK;
1340 }
1341
1342 static void cache_copy(void* data, void* dest, xmlChar* name)
1343 {
1344     schema_cache* This = (schema_cache*) dest;
1345     cache_entry* entry = (cache_entry*) data;
1346
1347     if (xmlHashLookup(This->cache, name) == NULL)
1348     {
1349         cache_entry_add_ref(entry);
1350         cache_add_entry(This, name, entry);
1351     }
1352 }
1353
1354 static HRESULT WINAPI schema_cache_addCollection(IXMLDOMSchemaCollection2* iface,
1355                                                  IXMLDOMSchemaCollection* collection)
1356 {
1357     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1358     schema_cache* That;
1359
1360     TRACE("(%p)->(%p)\n", This, collection);
1361
1362     if (!collection)
1363         return E_POINTER;
1364
1365     That = unsafe_impl_from_IXMLDOMSchemaCollection(collection);
1366     if (!That)
1367     {
1368         ERR("external collection implementation\n");
1369         return E_FAIL;
1370     }
1371
1372     /* TODO: detect errors while copying & return E_FAIL */
1373     xmlHashScan(That->cache, cache_copy, This);
1374
1375     return S_OK;
1376 }
1377
1378 static HRESULT WINAPI schema_cache_get__newEnum(IXMLDOMSchemaCollection2* iface, IUnknown** enumv)
1379 {
1380     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1381     TRACE("(%p)->(%p)\n", This, enumv);
1382     return create_enumvariant((IUnknown*)iface, TRUE, &schemacache_enumvariant, (IEnumVARIANT**)enumv);
1383 }
1384
1385 static HRESULT WINAPI schema_cache_validate(IXMLDOMSchemaCollection2* iface)
1386 {
1387     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1388     FIXME("(%p): stub\n", This);
1389     return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI schema_cache_put_validateOnLoad(IXMLDOMSchemaCollection2* iface,
1393                                                       VARIANT_BOOL value)
1394 {
1395     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1396     FIXME("(%p)->(%d): stub\n", This, value);
1397
1398     This->validateOnLoad = value;
1399     /* it's ok to disable it, cause we don't validate on load anyway */
1400     if (value == VARIANT_FALSE) return S_OK;
1401
1402     return E_NOTIMPL;
1403 }
1404
1405 static HRESULT WINAPI schema_cache_get_validateOnLoad(IXMLDOMSchemaCollection2* iface,
1406                                                       VARIANT_BOOL* value)
1407 {
1408     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1409     TRACE("(%p)->(%p)\n", This, value);
1410
1411     if (!value) return E_POINTER;
1412     *value = This->validateOnLoad;
1413
1414     return S_OK;
1415 }
1416
1417 static HRESULT WINAPI schema_cache_getSchema(IXMLDOMSchemaCollection2* iface,
1418                                              BSTR namespaceURI, ISchema** schema)
1419 {
1420     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1421     FIXME("(%p)->(%s %p): stub\n", This, debugstr_w(namespaceURI), schema);
1422     if (schema)
1423         *schema = NULL;
1424     return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI schema_cache_getDeclaration(IXMLDOMSchemaCollection2* iface,
1428                                                   IXMLDOMNode* node, ISchemaItem** item)
1429 {
1430     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1431     FIXME("(%p)->(%p %p): stub\n", This, node, item);
1432     if (item)
1433         *item = NULL;
1434     return E_NOTIMPL;
1435 }
1436
1437 static const struct IXMLDOMSchemaCollection2Vtbl XMLDOMSchemaCollection2Vtbl =
1438 {
1439     schema_cache_QueryInterface,
1440     schema_cache_AddRef,
1441     schema_cache_Release,
1442     schema_cache_GetTypeInfoCount,
1443     schema_cache_GetTypeInfo,
1444     schema_cache_GetIDsOfNames,
1445     schema_cache_Invoke,
1446     schema_cache_add,
1447     schema_cache_get,
1448     schema_cache_remove,
1449     schema_cache_get_length,
1450     schema_cache_get_namespaceURI,
1451     schema_cache_addCollection,
1452     schema_cache_get__newEnum,
1453     schema_cache_validate,
1454     schema_cache_put_validateOnLoad,
1455     schema_cache_get_validateOnLoad,
1456     schema_cache_getSchema,
1457     schema_cache_getDeclaration
1458 };
1459
1460 static xmlSchemaElementPtr lookup_schema_elemDecl(xmlSchemaPtr schema, xmlNodePtr node)
1461 {
1462     xmlSchemaElementPtr decl = NULL;
1463     xmlChar const* nsURI = get_node_nsURI(node);
1464
1465     TRACE("(%p, %p)\n", schema, node);
1466
1467     if (xmlStrEqual(nsURI, schema->targetNamespace))
1468         decl = xmlHashLookup(schema->elemDecl, node->name);
1469
1470     if (!decl && xmlHashSize(schema->schemasImports) > 1)
1471     {
1472         FIXME("declaration not found in main schema - need to check schema imports!\n");
1473         /*xmlSchemaImportPtr import;
1474         if (nsURI == NULL)
1475             import = xmlHashLookup(schema->schemasImports, XML_SCHEMAS_NO_NAMESPACE);
1476         else
1477             import = xmlHashLookup(schema->schemasImports, node->ns->href);
1478
1479         if (import != NULL)
1480             decl = xmlHashLookup(import->schema->elemDecl, node->name);*/
1481     }
1482
1483     return decl;
1484 }
1485
1486 static inline xmlNodePtr lookup_schema_element(xmlSchemaPtr schema, xmlNodePtr node)
1487 {
1488     xmlSchemaElementPtr decl = lookup_schema_elemDecl(schema, node);
1489     while (decl != NULL && decl->refDecl != NULL)
1490         decl = decl->refDecl;
1491     return (decl != NULL)? decl->node : NULL;
1492 }
1493
1494 HRESULT SchemaCache_validate_tree(IXMLDOMSchemaCollection2* iface, xmlNodePtr tree)
1495 {
1496     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1497     xmlSchemaPtr schema;
1498
1499     TRACE("(%p, %p)\n", This, tree);
1500
1501     if (!tree)
1502         return E_POINTER;
1503
1504     if (tree->type == XML_DOCUMENT_NODE)
1505         tree = xmlDocGetRootElement(tree->doc);
1506
1507     schema = get_node_schema(This, tree);
1508     /* TODO: if the ns is not in the cache, and it's a URL,
1509      *       do we try to load from that? */
1510     if (schema)
1511         return Schema_validate_tree(schema, tree);
1512     else
1513         WARN("no schema found for xmlns=%s\n", get_node_nsURI(tree));
1514
1515     return E_FAIL;
1516 }
1517
1518 XDR_DT SchemaCache_get_node_dt(IXMLDOMSchemaCollection2* iface, xmlNodePtr node)
1519 {
1520     schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
1521     xmlSchemaPtr schema = get_node_schema(This, node);
1522     XDR_DT dt = DT_INVALID;
1523
1524     TRACE("(%p, %p)\n", This, node);
1525
1526     if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
1527     {
1528         dt = str_to_dt(node->name, -1);
1529     }
1530     else if (schema)
1531     {
1532         xmlChar* str;
1533         xmlNodePtr schema_node = lookup_schema_element(schema, node);
1534
1535         str = xmlGetNsProp(schema_node, BAD_CAST "dt", DT_nsURI);
1536         if (str)
1537         {
1538             dt = str_to_dt(str, -1);
1539             xmlFree(str);
1540         }
1541     }
1542
1543     return dt;
1544 }
1545
1546 static const tid_t schemacache_iface_tids[] = {
1547     IXMLDOMSchemaCollection2_tid,
1548     0
1549 };
1550
1551 static dispex_static_data_t schemacache_dispex = {
1552     NULL,
1553     IXMLDOMSchemaCollection2_tid,
1554     NULL,
1555     schemacache_iface_tids
1556 };
1557
1558 HRESULT SchemaCache_create(MSXML_VERSION version, void** obj)
1559 {
1560     schema_cache* This = heap_alloc(sizeof(schema_cache));
1561     if (!This)
1562         return E_OUTOFMEMORY;
1563
1564     TRACE("(%d %p)\n", version, obj);
1565
1566     This->IXMLDOMSchemaCollection2_iface.lpVtbl = &XMLDOMSchemaCollection2Vtbl;
1567     This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE);
1568     This->allocated = 10;
1569     This->count = 0;
1570     This->uris = heap_alloc(This->allocated*sizeof(xmlChar*));
1571     This->ref = 1;
1572     This->version = version;
1573     This->validateOnLoad = VARIANT_TRUE;
1574     This->read_only = 0;
1575     init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSchemaCollection2_iface, &schemacache_dispex);
1576
1577     *obj = &This->IXMLDOMSchemaCollection2_iface;
1578     return S_OK;
1579 }
1580
1581 #else
1582
1583 HRESULT SchemaCache_create(MSXML_VERSION version, void** obj)
1584 {
1585     MESSAGE("This program tried to use a SchemaCache object, but\n"
1586             "libxml2 support was not present at compile time.\n");
1587     return E_NOTIMPL;
1588 }
1589
1590 #endif