1 /*
2 * valid.c : part of the code use to do the DTD handling and the validity
3 * checking
4 *
5 * See Copyright for the status of this software.
6 *
7 * daniel@veillard.com
8 */
9
10 #define IN_LIBXML
11 #include "libxml.h"
12
13 #include <string.h>
14
15 #ifdef HAVE_STDLIB_H
16 #include <stdlib.h>
17 #endif
18
19 #include <libxml/xmlmemory.h>
20 #include <libxml/hash.h>
21 #include <libxml/uri.h>
22 #include <libxml/valid.h>
23 #include <libxml/parser.h>
24 #include <libxml/parserInternals.h>
25 #include <libxml/xmlerror.h>
26 #include <libxml/list.h>
27 #include <libxml/globals.h>
28
29 static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name,
30 int create);
31 /* #define DEBUG_VALID_ALGO */
32 /* #define DEBUG_REGEXP_ALGO */
33
34 #define TODO \
35 xmlGenericError(xmlGenericErrorContext, \
36 "Unimplemented block at %s:%d\n", \
37 __FILE__, __LINE__);
38
39 #ifdef LIBXML_VALID_ENABLED
40 static int
41 xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
42 const xmlChar *value);
43 #endif
44 /************************************************************************
45 * *
46 * Error handling routines *
47 * *
48 ************************************************************************/
49
50 /**
51 * xmlVErrMemory:
52 * @ctxt: an XML validation parser context
53 * @extra: extra informations
54 *
55 * Handle an out of memory error
56 */
57 static void
xmlVErrMemory(xmlValidCtxtPtr ctxt,const char * extra)58 xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
59 {
60 xmlGenericErrorFunc channel = NULL;
61 xmlParserCtxtPtr pctxt = NULL;
62 void *data = NULL;
63
64 if (ctxt != NULL) {
65 channel = ctxt->error;
66 data = ctxt->userData;
67 /* Use the special values to detect if it is part of a parsing
68 context */
69 if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
70 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
71 long delta = (char *) ctxt - (char *) ctxt->userData;
72 if ((delta > 0) && (delta < 250))
73 pctxt = ctxt->userData;
74 }
75 }
76 if (extra)
77 __xmlRaiseError(NULL, channel, data,
78 pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
79 XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
80 "Memory allocation failed : %s\n", extra);
81 else
82 __xmlRaiseError(NULL, channel, data,
83 pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
84 XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
85 "Memory allocation failed\n");
86 }
87
88 /**
89 * xmlErrValid:
90 * @ctxt: an XML validation parser context
91 * @error: the error number
92 * @extra: extra informations
93 *
94 * Handle a validation error
95 */
96 static void
xmlErrValid(xmlValidCtxtPtr ctxt,xmlParserErrors error,const char * msg,const char * extra)97 xmlErrValid(xmlValidCtxtPtr ctxt, xmlParserErrors error,
98 const char *msg, const char *extra)
99 {
100 xmlGenericErrorFunc channel = NULL;
101 xmlParserCtxtPtr pctxt = NULL;
102 void *data = NULL;
103
104 if (ctxt != NULL) {
105 channel = ctxt->error;
106 data = ctxt->userData;
107 /* Use the special values to detect if it is part of a parsing
108 context */
109 if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
110 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
111 long delta = (char *) ctxt - (char *) ctxt->userData;
112 if ((delta > 0) && (delta < 250))
113 pctxt = ctxt->userData;
114 }
115 }
116 if (extra)
117 __xmlRaiseError(NULL, channel, data,
118 pctxt, NULL, XML_FROM_VALID, error,
119 XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
120 msg, extra);
121 else
122 __xmlRaiseError(NULL, channel, data,
123 pctxt, NULL, XML_FROM_VALID, error,
124 XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
125 msg);
126 }
127
128 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
129 /**
130 * xmlErrValidNode:
131 * @ctxt: an XML validation parser context
132 * @node: the node raising the error
133 * @error: the error number
134 * @str1: extra informations
135 * @str2: extra informations
136 * @str3: extra informations
137 *
138 * Handle a validation error, provide contextual informations
139 */
140 static void
xmlErrValidNode(xmlValidCtxtPtr ctxt,xmlNodePtr node,xmlParserErrors error,const char * msg,const xmlChar * str1,const xmlChar * str2,const xmlChar * str3)141 xmlErrValidNode(xmlValidCtxtPtr ctxt,
142 xmlNodePtr node, xmlParserErrors error,
143 const char *msg, const xmlChar * str1,
144 const xmlChar * str2, const xmlChar * str3)
145 {
146 xmlStructuredErrorFunc schannel = NULL;
147 xmlGenericErrorFunc channel = NULL;
148 xmlParserCtxtPtr pctxt = NULL;
149 void *data = NULL;
150
151 if (ctxt != NULL) {
152 channel = ctxt->error;
153 data = ctxt->userData;
154 /* Use the special values to detect if it is part of a parsing
155 context */
156 if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
157 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
158 long delta = (char *) ctxt - (char *) ctxt->userData;
159 if ((delta > 0) && (delta < 250))
160 pctxt = ctxt->userData;
161 }
162 }
163 __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
164 XML_ERR_ERROR, NULL, 0,
165 (const char *) str1,
166 (const char *) str1,
167 (const char *) str3, 0, 0, msg, str1, str2, str3);
168 }
169 #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
170
171 #ifdef LIBXML_VALID_ENABLED
172 /**
173 * xmlErrValidNodeNr:
174 * @ctxt: an XML validation parser context
175 * @node: the node raising the error
176 * @error: the error number
177 * @str1: extra informations
178 * @int2: extra informations
179 * @str3: extra informations
180 *
181 * Handle a validation error, provide contextual informations
182 */
183 static void
xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,xmlNodePtr node,xmlParserErrors error,const char * msg,const xmlChar * str1,int int2,const xmlChar * str3)184 xmlErrValidNodeNr(xmlValidCtxtPtr ctxt,
185 xmlNodePtr node, xmlParserErrors error,
186 const char *msg, const xmlChar * str1,
187 int int2, const xmlChar * str3)
188 {
189 xmlStructuredErrorFunc schannel = NULL;
190 xmlGenericErrorFunc channel = NULL;
191 xmlParserCtxtPtr pctxt = NULL;
192 void *data = NULL;
193
194 if (ctxt != NULL) {
195 channel = ctxt->error;
196 data = ctxt->userData;
197 /* Use the special values to detect if it is part of a parsing
198 context */
199 if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
200 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
201 long delta = (char *) ctxt - (char *) ctxt->userData;
202 if ((delta > 0) && (delta < 250))
203 pctxt = ctxt->userData;
204 }
205 }
206 __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
207 XML_ERR_ERROR, NULL, 0,
208 (const char *) str1,
209 (const char *) str3,
210 NULL, int2, 0, msg, str1, int2, str3);
211 }
212
213 /**
214 * xmlErrValidWarning:
215 * @ctxt: an XML validation parser context
216 * @node: the node raising the error
217 * @error: the error number
218 * @str1: extra information
219 * @str2: extra information
220 * @str3: extra information
221 *
222 * Handle a validation error, provide contextual information
223 */
224 static void
xmlErrValidWarning(xmlValidCtxtPtr ctxt,xmlNodePtr node,xmlParserErrors error,const char * msg,const xmlChar * str1,const xmlChar * str2,const xmlChar * str3)225 xmlErrValidWarning(xmlValidCtxtPtr ctxt,
226 xmlNodePtr node, xmlParserErrors error,
227 const char *msg, const xmlChar * str1,
228 const xmlChar * str2, const xmlChar * str3)
229 {
230 xmlStructuredErrorFunc schannel = NULL;
231 xmlGenericErrorFunc channel = NULL;
232 xmlParserCtxtPtr pctxt = NULL;
233 void *data = NULL;
234
235 if (ctxt != NULL) {
236 channel = ctxt->warning;
237 data = ctxt->userData;
238 /* Use the special values to detect if it is part of a parsing
239 context */
240 if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
241 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
242 long delta = (char *) ctxt - (char *) ctxt->userData;
243 if ((delta > 0) && (delta < 250))
244 pctxt = ctxt->userData;
245 }
246 }
247 __xmlRaiseError(schannel, channel, data, pctxt, node, XML_FROM_VALID, error,
248 XML_ERR_WARNING, NULL, 0,
249 (const char *) str1,
250 (const char *) str1,
251 (const char *) str3, 0, 0, msg, str1, str2, str3);
252 }
253
254
255
256 #ifdef LIBXML_REGEXP_ENABLED
257 /*
258 * If regexp are enabled we can do continuous validation without the
259 * need of a tree to validate the content model. this is done in each
260 * callbacks.
261 * Each xmlValidState represent the validation state associated to the
262 * set of nodes currently open from the document root to the current element.
263 */
264
265
266 typedef struct _xmlValidState {
267 xmlElementPtr elemDecl; /* pointer to the content model */
268 xmlNodePtr node; /* pointer to the current node */
269 xmlRegExecCtxtPtr exec; /* regexp runtime */
270 } _xmlValidState;
271
272
273 static int
vstateVPush(xmlValidCtxtPtr ctxt,xmlElementPtr elemDecl,xmlNodePtr node)274 vstateVPush(xmlValidCtxtPtr ctxt, xmlElementPtr elemDecl, xmlNodePtr node) {
275 if ((ctxt->vstateMax == 0) || (ctxt->vstateTab == NULL)) {
276 ctxt->vstateMax = 10;
277 ctxt->vstateTab = (xmlValidState *) xmlMalloc(ctxt->vstateMax *
278 sizeof(ctxt->vstateTab[0]));
279 if (ctxt->vstateTab == NULL) {
280 xmlVErrMemory(ctxt, "malloc failed");
281 return(-1);
282 }
283 }
284
285 if (ctxt->vstateNr >= ctxt->vstateMax) {
286 xmlValidState *tmp;
287
288 tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
289 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
290 if (tmp == NULL) {
291 xmlVErrMemory(ctxt, "realloc failed");
292 return(-1);
293 }
294 ctxt->vstateMax *= 2;
295 ctxt->vstateTab = tmp;
296 }
297 ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr];
298 ctxt->vstateTab[ctxt->vstateNr].elemDecl = elemDecl;
299 ctxt->vstateTab[ctxt->vstateNr].node = node;
300 if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
301 if (elemDecl->contModel == NULL)
302 xmlValidBuildContentModel(ctxt, elemDecl);
303 if (elemDecl->contModel != NULL) {
304 ctxt->vstateTab[ctxt->vstateNr].exec =
305 xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
306 } else {
307 ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
308 xmlErrValidNode(ctxt, (xmlNodePtr) elemDecl,
309 XML_ERR_INTERNAL_ERROR,
310 "Failed to build content model regexp for %s\n",
311 node->name, NULL, NULL);
312 }
313 }
314 return(ctxt->vstateNr++);
315 }
316
317 static int
vstateVPop(xmlValidCtxtPtr ctxt)318 vstateVPop(xmlValidCtxtPtr ctxt) {
319 xmlElementPtr elemDecl;
320
321 if (ctxt->vstateNr < 1) return(-1);
322 ctxt->vstateNr--;
323 elemDecl = ctxt->vstateTab[ctxt->vstateNr].elemDecl;
324 ctxt->vstateTab[ctxt->vstateNr].elemDecl = NULL;
325 ctxt->vstateTab[ctxt->vstateNr].node = NULL;
326 if ((elemDecl != NULL) && (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT)) {
327 xmlRegFreeExecCtxt(ctxt->vstateTab[ctxt->vstateNr].exec);
328 }
329 ctxt->vstateTab[ctxt->vstateNr].exec = NULL;
330 if (ctxt->vstateNr >= 1)
331 ctxt->vstate = &ctxt->vstateTab[ctxt->vstateNr - 1];
332 else
333 ctxt->vstate = NULL;
334 return(ctxt->vstateNr);
335 }
336
337 #else /* not LIBXML_REGEXP_ENABLED */
338 /*
339 * If regexp are not enabled, it uses a home made algorithm less
340 * complex and easier to
341 * debug/maintain than a generic NFA -> DFA state based algo. The
342 * only restriction is on the deepness of the tree limited by the
343 * size of the occurs bitfield
344 *
345 * this is the content of a saved state for rollbacks
346 */
347
348 #define ROLLBACK_OR 0
349 #define ROLLBACK_PARENT 1
350
351 typedef struct _xmlValidState {
352 xmlElementContentPtr cont; /* pointer to the content model subtree */
353 xmlNodePtr node; /* pointer to the current node in the list */
354 long occurs;/* bitfield for multiple occurrences */
355 unsigned char depth; /* current depth in the overall tree */
356 unsigned char state; /* ROLLBACK_XXX */
357 } _xmlValidState;
358
359 #define MAX_RECURSE 25000
360 #define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
361 #define CONT ctxt->vstate->cont
362 #define NODE ctxt->vstate->node
363 #define DEPTH ctxt->vstate->depth
364 #define OCCURS ctxt->vstate->occurs
365 #define STATE ctxt->vstate->state
366
367 #define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
368 #define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
369
370 #define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
371 #define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
372
373 static int
vstateVPush(xmlValidCtxtPtr ctxt,xmlElementContentPtr cont,xmlNodePtr node,unsigned char depth,long occurs,unsigned char state)374 vstateVPush(xmlValidCtxtPtr ctxt, xmlElementContentPtr cont,
375 xmlNodePtr node, unsigned char depth, long occurs,
376 unsigned char state) {
377 int i = ctxt->vstateNr - 1;
378
379 if (ctxt->vstateNr > MAX_RECURSE) {
380 return(-1);
381 }
382 if (ctxt->vstateTab == NULL) {
383 ctxt->vstateMax = 8;
384 ctxt->vstateTab = (xmlValidState *) xmlMalloc(
385 ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
386 if (ctxt->vstateTab == NULL) {
387 xmlVErrMemory(ctxt, "malloc failed");
388 return(-1);
389 }
390 }
391 if (ctxt->vstateNr >= ctxt->vstateMax) {
392 xmlValidState *tmp;
393
394 tmp = (xmlValidState *) xmlRealloc(ctxt->vstateTab,
395 2 * ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
396 if (tmp == NULL) {
397 xmlVErrMemory(ctxt, "malloc failed");
398 return(-1);
399 }
400 ctxt->vstateMax *= 2;
401 ctxt->vstateTab = tmp;
402 ctxt->vstate = &ctxt->vstateTab[0];
403 }
404 /*
405 * Don't push on the stack a state already here
406 */
407 if ((i >= 0) && (ctxt->vstateTab[i].cont == cont) &&
408 (ctxt->vstateTab[i].node == node) &&
409 (ctxt->vstateTab[i].depth == depth) &&
410 (ctxt->vstateTab[i].occurs == occurs) &&
411 (ctxt->vstateTab[i].state == state))
412 return(ctxt->vstateNr);
413 ctxt->vstateTab[ctxt->vstateNr].cont = cont;
414 ctxt->vstateTab[ctxt->vstateNr].node = node;
415 ctxt->vstateTab[ctxt->vstateNr].depth = depth;
416 ctxt->vstateTab[ctxt->vstateNr].occurs = occurs;
417 ctxt->vstateTab[ctxt->vstateNr].state = state;
418 return(ctxt->vstateNr++);
419 }
420
421 static int
vstateVPop(xmlValidCtxtPtr ctxt)422 vstateVPop(xmlValidCtxtPtr ctxt) {
423 if (ctxt->vstateNr <= 1) return(-1);
424 ctxt->vstateNr--;
425 ctxt->vstate = &ctxt->vstateTab[0];
426 ctxt->vstate->cont = ctxt->vstateTab[ctxt->vstateNr].cont;
427 ctxt->vstate->node = ctxt->vstateTab[ctxt->vstateNr].node;
428 ctxt->vstate->depth = ctxt->vstateTab[ctxt->vstateNr].depth;
429 ctxt->vstate->occurs = ctxt->vstateTab[ctxt->vstateNr].occurs;
430 ctxt->vstate->state = ctxt->vstateTab[ctxt->vstateNr].state;
431 return(ctxt->vstateNr);
432 }
433
434 #endif /* LIBXML_REGEXP_ENABLED */
435
436 static int
nodeVPush(xmlValidCtxtPtr ctxt,xmlNodePtr value)437 nodeVPush(xmlValidCtxtPtr ctxt, xmlNodePtr value)
438 {
439 if (ctxt->nodeMax <= 0) {
440 ctxt->nodeMax = 4;
441 ctxt->nodeTab =
442 (xmlNodePtr *) xmlMalloc(ctxt->nodeMax *
443 sizeof(ctxt->nodeTab[0]));
444 if (ctxt->nodeTab == NULL) {
445 xmlVErrMemory(ctxt, "malloc failed");
446 ctxt->nodeMax = 0;
447 return (0);
448 }
449 }
450 if (ctxt->nodeNr >= ctxt->nodeMax) {
451 xmlNodePtr *tmp;
452 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
453 ctxt->nodeMax * 2 * sizeof(ctxt->nodeTab[0]));
454 if (tmp == NULL) {
455 xmlVErrMemory(ctxt, "realloc failed");
456 return (0);
457 }
458 ctxt->nodeMax *= 2;
459 ctxt->nodeTab = tmp;
460 }
461 ctxt->nodeTab[ctxt->nodeNr] = value;
462 ctxt->node = value;
463 return (ctxt->nodeNr++);
464 }
465 static xmlNodePtr
nodeVPop(xmlValidCtxtPtr ctxt)466 nodeVPop(xmlValidCtxtPtr ctxt)
467 {
468 xmlNodePtr ret;
469
470 if (ctxt->nodeNr <= 0)
471 return (NULL);
472 ctxt->nodeNr--;
473 if (ctxt->nodeNr > 0)
474 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
475 else
476 ctxt->node = NULL;
477 ret = ctxt->nodeTab[ctxt->nodeNr];
478 ctxt->nodeTab[ctxt->nodeNr] = NULL;
479 return (ret);
480 }
481
482 #ifdef DEBUG_VALID_ALGO
483 static void
xmlValidPrintNode(xmlNodePtr cur)484 xmlValidPrintNode(xmlNodePtr cur) {
485 if (cur == NULL) {
486 xmlGenericError(xmlGenericErrorContext, "null");
487 return;
488 }
489 switch (cur->type) {
490 case XML_ELEMENT_NODE:
491 xmlGenericError(xmlGenericErrorContext, "%s ", cur->name);
492 break;
493 case XML_TEXT_NODE:
494 xmlGenericError(xmlGenericErrorContext, "text ");
495 break;
496 case XML_CDATA_SECTION_NODE:
497 xmlGenericError(xmlGenericErrorContext, "cdata ");
498 break;
499 case XML_ENTITY_REF_NODE:
500 xmlGenericError(xmlGenericErrorContext, "&%s; ", cur->name);
501 break;
502 case XML_PI_NODE:
503 xmlGenericError(xmlGenericErrorContext, "pi(%s) ", cur->name);
504 break;
505 case XML_COMMENT_NODE:
506 xmlGenericError(xmlGenericErrorContext, "comment ");
507 break;
508 case XML_ATTRIBUTE_NODE:
509 xmlGenericError(xmlGenericErrorContext, "?attr? ");
510 break;
511 case XML_ENTITY_NODE:
512 xmlGenericError(xmlGenericErrorContext, "?ent? ");
513 break;
514 case XML_DOCUMENT_NODE:
515 xmlGenericError(xmlGenericErrorContext, "?doc? ");
516 break;
517 case XML_DOCUMENT_TYPE_NODE:
518 xmlGenericError(xmlGenericErrorContext, "?doctype? ");
519 break;
520 case XML_DOCUMENT_FRAG_NODE:
521 xmlGenericError(xmlGenericErrorContext, "?frag? ");
522 break;
523 case XML_NOTATION_NODE:
524 xmlGenericError(xmlGenericErrorContext, "?nota? ");
525 break;
526 case XML_HTML_DOCUMENT_NODE:
527 xmlGenericError(xmlGenericErrorContext, "?html? ");
528 break;
529 #ifdef LIBXML_DOCB_ENABLED
530 case XML_DOCB_DOCUMENT_NODE:
531 xmlGenericError(xmlGenericErrorContext, "?docb? ");
532 break;
533 #endif
534 case XML_DTD_NODE:
535 xmlGenericError(xmlGenericErrorContext, "?dtd? ");
536 break;
537 case XML_ELEMENT_DECL:
538 xmlGenericError(xmlGenericErrorContext, "?edecl? ");
539 break;
540 case XML_ATTRIBUTE_DECL:
541 xmlGenericError(xmlGenericErrorContext, "?adecl? ");
542 break;
543 case XML_ENTITY_DECL:
544 xmlGenericError(xmlGenericErrorContext, "?entdecl? ");
545 break;
546 case XML_NAMESPACE_DECL:
547 xmlGenericError(xmlGenericErrorContext, "?nsdecl? ");
548 break;
549 case XML_XINCLUDE_START:
550 xmlGenericError(xmlGenericErrorContext, "incstart ");
551 break;
552 case XML_XINCLUDE_END:
553 xmlGenericError(xmlGenericErrorContext, "incend ");
554 break;
555 }
556 }
557
558 static void
xmlValidPrintNodeList(xmlNodePtr cur)559 xmlValidPrintNodeList(xmlNodePtr cur) {
560 if (cur == NULL)
561 xmlGenericError(xmlGenericErrorContext, "null ");
562 while (cur != NULL) {
563 xmlValidPrintNode(cur);
564 cur = cur->next;
565 }
566 }
567
568 static void
xmlValidDebug(xmlNodePtr cur,xmlElementContentPtr cont)569 xmlValidDebug(xmlNodePtr cur, xmlElementContentPtr cont) {
570 char expr[5000];
571
572 expr[0] = 0;
573 xmlGenericError(xmlGenericErrorContext, "valid: ");
574 xmlValidPrintNodeList(cur);
575 xmlGenericError(xmlGenericErrorContext, "against ");
576 xmlSnprintfElementContent(expr, 5000, cont, 1);
577 xmlGenericError(xmlGenericErrorContext, "%s\n", expr);
578 }
579
580 static void
xmlValidDebugState(xmlValidStatePtr state)581 xmlValidDebugState(xmlValidStatePtr state) {
582 xmlGenericError(xmlGenericErrorContext, "(");
583 if (state->cont == NULL)
584 xmlGenericError(xmlGenericErrorContext, "null,");
585 else
586 switch (state->cont->type) {
587 case XML_ELEMENT_CONTENT_PCDATA:
588 xmlGenericError(xmlGenericErrorContext, "pcdata,");
589 break;
590 case XML_ELEMENT_CONTENT_ELEMENT:
591 xmlGenericError(xmlGenericErrorContext, "%s,",
592 state->cont->name);
593 break;
594 case XML_ELEMENT_CONTENT_SEQ:
595 xmlGenericError(xmlGenericErrorContext, "seq,");
596 break;
597 case XML_ELEMENT_CONTENT_OR:
598 xmlGenericError(xmlGenericErrorContext, "or,");
599 break;
600 }
601 xmlValidPrintNode(state->node);
602 xmlGenericError(xmlGenericErrorContext, ",%d,%X,%d)",
603 state->depth, state->occurs, state->state);
604 }
605
606 static void
xmlValidStateDebug(xmlValidCtxtPtr ctxt)607 xmlValidStateDebug(xmlValidCtxtPtr ctxt) {
608 int i, j;
609
610 xmlGenericError(xmlGenericErrorContext, "state: ");
611 xmlValidDebugState(ctxt->vstate);
612 xmlGenericError(xmlGenericErrorContext, " stack: %d ",
613 ctxt->vstateNr - 1);
614 for (i = 0, j = ctxt->vstateNr - 1;(i < 3) && (j > 0);i++,j--)
615 xmlValidDebugState(&ctxt->vstateTab[j]);
616 xmlGenericError(xmlGenericErrorContext, "\n");
617 }
618
619 /*****
620 #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
621 *****/
622
623 #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
624 #define DEBUG_VALID_MSG(m) \
625 xmlGenericError(xmlGenericErrorContext, "%s\n", m);
626
627 #else
628 #define DEBUG_VALID_STATE(n,c)
629 #define DEBUG_VALID_MSG(m)
630 #endif
631
632 /* TODO: use hash table for accesses to elem and attribute definitions */
633
634
635 #define CHECK_DTD \
636 if (doc == NULL) return(0); \
637 else if ((doc->intSubset == NULL) && \
638 (doc->extSubset == NULL)) return(0)
639
640 xmlAttributePtr xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem);
641
642 #ifdef LIBXML_REGEXP_ENABLED
643
644 /************************************************************************
645 * *
646 * Content model validation based on the regexps *
647 * *
648 ************************************************************************/
649
650 /**
651 * xmlValidBuildAContentModel:
652 * @content: the content model
653 * @ctxt: the schema parser context
654 * @name: the element name whose content is being built
655 *
656 * Generate the automata sequence needed for that type
657 *
658 * Returns 1 if successful or 0 in case of error.
659 */
660 static int
xmlValidBuildAContentModel(xmlElementContentPtr content,xmlValidCtxtPtr ctxt,const xmlChar * name)661 xmlValidBuildAContentModel(xmlElementContentPtr content,
662 xmlValidCtxtPtr ctxt,
663 const xmlChar *name) {
664 if (content == NULL) {
665 xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
666 "Found NULL content in content model of %s\n",
667 name, NULL, NULL);
668 return(0);
669 }
670 switch (content->type) {
671 case XML_ELEMENT_CONTENT_PCDATA:
672 xmlErrValidNode(ctxt, NULL, XML_ERR_INTERNAL_ERROR,
673 "Found PCDATA in content model of %s\n",
674 name, NULL, NULL);
675 return(0);
676 break;
677 case XML_ELEMENT_CONTENT_ELEMENT: {
678 xmlAutomataStatePtr oldstate = ctxt->state;
679 xmlChar fn[50];
680 xmlChar *fullname;
681
682 fullname = xmlBuildQName(content->name, content->prefix, fn, 50);
683 if (fullname == NULL) {
684 xmlVErrMemory(ctxt, "Building content model");
685 return(0);
686 }
687
688 switch (content->ocur) {
689 case XML_ELEMENT_CONTENT_ONCE:
690 ctxt->state = xmlAutomataNewTransition(ctxt->am,
691 ctxt->state, NULL, fullname, NULL);
692 break;
693 case XML_ELEMENT_CONTENT_OPT:
694 ctxt->state = xmlAutomataNewTransition(ctxt->am,
695 ctxt->state, NULL, fullname, NULL);
696 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
697 break;
698 case XML_ELEMENT_CONTENT_PLUS:
699 ctxt->state = xmlAutomataNewTransition(ctxt->am,
700 ctxt->state, NULL, fullname, NULL);
701 xmlAutomataNewTransition(ctxt->am, ctxt->state,
702 ctxt->state, fullname, NULL);
703 break;
704 case XML_ELEMENT_CONTENT_MULT:
705 ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
706 ctxt->state, NULL);
707 xmlAutomataNewTransition(ctxt->am,
708 ctxt->state, ctxt->state, fullname, NULL);
709 break;
710 }
711 if ((fullname != fn) && (fullname != content->name))
712 xmlFree(fullname);
713 break;
714 }
715 case XML_ELEMENT_CONTENT_SEQ: {
716 xmlAutomataStatePtr oldstate, oldend;
717 xmlElementContentOccur ocur;
718
719 /*
720 * Simply iterate over the content
721 */
722 oldstate = ctxt->state;
723 ocur = content->ocur;
724 if (ocur != XML_ELEMENT_CONTENT_ONCE) {
725 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL);
726 oldstate = ctxt->state;
727 }
728 do {
729 xmlValidBuildAContentModel(content->c1, ctxt, name);
730 content = content->c2;
731 } while ((content->type == XML_ELEMENT_CONTENT_SEQ) &&
732 (content->ocur == XML_ELEMENT_CONTENT_ONCE));
733 xmlValidBuildAContentModel(content, ctxt, name);
734 oldend = ctxt->state;
735 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
736 switch (ocur) {
737 case XML_ELEMENT_CONTENT_ONCE:
738 break;
739 case XML_ELEMENT_CONTENT_OPT:
740 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
741 break;
742 case XML_ELEMENT_CONTENT_MULT:
743 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
744 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
745 break;
746 case XML_ELEMENT_CONTENT_PLUS:
747 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
748 break;
749 }
750 break;
751 }
752 case XML_ELEMENT_CONTENT_OR: {
753 xmlAutomataStatePtr oldstate, oldend;
754 xmlElementContentOccur ocur;
755
756 ocur = content->ocur;
757 if ((ocur == XML_ELEMENT_CONTENT_PLUS) ||
758 (ocur == XML_ELEMENT_CONTENT_MULT)) {
759 ctxt->state = xmlAutomataNewEpsilon(ctxt->am,
760 ctxt->state, NULL);
761 }
762 oldstate = ctxt->state;
763 oldend = xmlAutomataNewState(ctxt->am);
764
765 /*
766 * iterate over the subtypes and remerge the end with an
767 * epsilon transition
768 */
769 do {
770 ctxt->state = oldstate;
771 xmlValidBuildAContentModel(content->c1, ctxt, name);
772 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
773 content = content->c2;
774 } while ((content->type == XML_ELEMENT_CONTENT_OR) &&
775 (content->ocur == XML_ELEMENT_CONTENT_ONCE));
776 ctxt->state = oldstate;
777 xmlValidBuildAContentModel(content, ctxt, name);
778 xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldend);
779 ctxt->state = xmlAutomataNewEpsilon(ctxt->am, oldend, NULL);
780 switch (ocur) {
781 case XML_ELEMENT_CONTENT_ONCE:
782 break;
783 case XML_ELEMENT_CONTENT_OPT:
784 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
785 break;
786 case XML_ELEMENT_CONTENT_MULT:
787 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
788 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
789 break;
790 case XML_ELEMENT_CONTENT_PLUS:
791 xmlAutomataNewEpsilon(ctxt->am, oldend, oldstate);
792 break;
793 }
794 break;
795 }
796 default:
797 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
798 "ContentModel broken for element %s\n",
799 (const char *) name);
800 return(0);
801 }
802 return(1);
803 }
804 /**
805 * xmlValidBuildContentModel:
806 * @ctxt: a validation context
807 * @elem: an element declaration node
808 *
809 * (Re)Build the automata associated to the content model of this
810 * element
811 *
812 * Returns 1 in case of success, 0 in case of error
813 */
814 int
xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,xmlElementPtr elem)815 xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, xmlElementPtr elem) {
816
817 if ((ctxt == NULL) || (elem == NULL))
818 return(0);
819 if (elem->type != XML_ELEMENT_DECL)
820 return(0);
821 if (elem->etype != XML_ELEMENT_TYPE_ELEMENT)
822 return(1);
823 /* TODO: should we rebuild in this case ? */
824 if (elem->contModel != NULL) {
825 if (!xmlRegexpIsDeterminist(elem->contModel)) {
826 ctxt->valid = 0;
827 return(0);
828 }
829 return(1);
830 }
831
832 ctxt->am = xmlNewAutomata();
833 if (ctxt->am == NULL) {
834 xmlErrValidNode(ctxt, (xmlNodePtr) elem,
835 XML_ERR_INTERNAL_ERROR,
836 "Cannot create automata for element %s\n",
837 elem->name, NULL, NULL);
838 return(0);
839 }
840 ctxt->state = xmlAutomataGetInitState(ctxt->am);
841 xmlValidBuildAContentModel(elem->content, ctxt, elem->name);
842 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
843 elem->contModel = xmlAutomataCompile(ctxt->am);
844 if (xmlRegexpIsDeterminist(elem->contModel) != 1) {
845 char expr[5000];
846 expr[0] = 0;
847 xmlSnprintfElementContent(expr, 5000, elem->content, 1);
848 xmlErrValidNode(ctxt, (xmlNodePtr) elem,
849 XML_DTD_CONTENT_NOT_DETERMINIST,
850 "Content model of %s is not determinist: %s\n",
851 elem->name, BAD_CAST expr, NULL);
852 #ifdef DEBUG_REGEXP_ALGO
853 xmlRegexpPrint(stderr, elem->contModel);
854 #endif
855 ctxt->valid = 0;
856 ctxt->state = NULL;
857 xmlFreeAutomata(ctxt->am);
858 ctxt->am = NULL;
859 return(0);
860 }
861 ctxt->state = NULL;
862 xmlFreeAutomata(ctxt->am);
863 ctxt->am = NULL;
864 return(1);
865 }
866
867 #endif /* LIBXML_REGEXP_ENABLED */
868
869 /****************************************************************
870 * *
871 * Util functions for data allocation/deallocation *
872 * *
873 ****************************************************************/
874
875 /**
876 * xmlNewValidCtxt:
877 *
878 * Allocate a validation context structure.
879 *
880 * Returns NULL if not, otherwise the new validation context structure
881 */
xmlNewValidCtxt(void)882 xmlValidCtxtPtr xmlNewValidCtxt(void) {
883 xmlValidCtxtPtr ret;
884
885 if ((ret = xmlMalloc(sizeof (xmlValidCtxt))) == NULL) {
886 xmlVErrMemory(NULL, "malloc failed");
887 return (NULL);
888 }
889
890 (void) memset(ret, 0, sizeof (xmlValidCtxt));
891
892 return (ret);
893 }
894
895 /**
896 * xmlFreeValidCtxt:
897 * @cur: the validation context to free
898 *
899 * Free a validation context structure.
900 */
901 void
xmlFreeValidCtxt(xmlValidCtxtPtr cur)902 xmlFreeValidCtxt(xmlValidCtxtPtr cur) {
903 if (cur->vstateTab != NULL)
904 xmlFree(cur->vstateTab);
905 if (cur->nodeTab != NULL)
906 xmlFree(cur->nodeTab);
907 xmlFree(cur);
908 }
909
910 #endif /* LIBXML_VALID_ENABLED */
911
912 /**
913 * xmlNewDocElementContent:
914 * @doc: the document
915 * @name: the subelement name or NULL
916 * @type: the type of element content decl
917 *
918 * Allocate an element content structure for the document.
919 *
920 * Returns NULL if not, otherwise the new element content structure
921 */
922 xmlElementContentPtr
xmlNewDocElementContent(xmlDocPtr doc,const xmlChar * name,xmlElementContentType type)923 xmlNewDocElementContent(xmlDocPtr doc, const xmlChar *name,
924 xmlElementContentType type) {
925 xmlElementContentPtr ret;
926 xmlDictPtr dict = NULL;
927
928 if (doc != NULL)
929 dict = doc->dict;
930
931 switch(type) {
932 case XML_ELEMENT_CONTENT_ELEMENT:
933 if (name == NULL) {
934 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
935 "xmlNewElementContent : name == NULL !\n",
936 NULL);
937 }
938 break;
939 case XML_ELEMENT_CONTENT_PCDATA:
940 case XML_ELEMENT_CONTENT_SEQ:
941 case XML_ELEMENT_CONTENT_OR:
942 if (name != NULL) {
943 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
944 "xmlNewElementContent : name != NULL !\n",
945 NULL);
946 }
947 break;
948 default:
949 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
950 "Internal: ELEMENT content corrupted invalid type\n",
951 NULL);
952 return(NULL);
953 }
954 ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
955 if (ret == NULL) {
956 xmlVErrMemory(NULL, "malloc failed");
957 return(NULL);
958 }
959 memset(ret, 0, sizeof(xmlElementContent));
960 ret->type = type;
961 ret->ocur = XML_ELEMENT_CONTENT_ONCE;
962 if (name != NULL) {
963 int l;
964 const xmlChar *tmp;
965
966 tmp = xmlSplitQName3(name, &l);
967 if (tmp == NULL) {
968 if (dict == NULL)
969 ret->name = xmlStrdup(name);
970 else
971 ret->name = xmlDictLookup(dict, name, -1);
972 } else {
973 if (dict == NULL) {
974 ret->prefix = xmlStrndup(name, l);
975 ret->name = xmlStrdup(tmp);
976 } else {
977 ret->prefix = xmlDictLookup(dict, name, l);
978 ret->name = xmlDictLookup(dict, tmp, -1);
979 }
980 }
981 }
982 return(ret);
983 }
984
985 /**
986 * xmlNewElementContent:
987 * @name: the subelement name or NULL
988 * @type: the type of element content decl
989 *
990 * Allocate an element content structure.
991 * Deprecated in favor of xmlNewDocElementContent
992 *
993 * Returns NULL if not, otherwise the new element content structure
994 */
995 xmlElementContentPtr
xmlNewElementContent(const xmlChar * name,xmlElementContentType type)996 xmlNewElementContent(const xmlChar *name, xmlElementContentType type) {
997 return(xmlNewDocElementContent(NULL, name, type));
998 }
999
1000 /**
1001 * xmlCopyDocElementContent:
1002 * @doc: the document owning the element declaration
1003 * @cur: An element content pointer.
1004 *
1005 * Build a copy of an element content description.
1006 *
1007 * Returns the new xmlElementContentPtr or NULL in case of error.
1008 */
1009 xmlElementContentPtr
xmlCopyDocElementContent(xmlDocPtr doc,xmlElementContentPtr cur)1010 xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1011 xmlElementContentPtr ret = NULL, prev = NULL, tmp;
1012 xmlDictPtr dict = NULL;
1013
1014 if (cur == NULL) return(NULL);
1015
1016 if (doc != NULL)
1017 dict = doc->dict;
1018
1019 ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1020 if (ret == NULL) {
1021 xmlVErrMemory(NULL, "malloc failed");
1022 return(NULL);
1023 }
1024 memset(ret, 0, sizeof(xmlElementContent));
1025 ret->type = cur->type;
1026 ret->ocur = cur->ocur;
1027 if (cur->name != NULL) {
1028 if (dict)
1029 ret->name = xmlDictLookup(dict, cur->name, -1);
1030 else
1031 ret->name = xmlStrdup(cur->name);
1032 }
1033
1034 if (cur->prefix != NULL) {
1035 if (dict)
1036 ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
1037 else
1038 ret->prefix = xmlStrdup(cur->prefix);
1039 }
1040 if (cur->c1 != NULL)
1041 ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
1042 if (ret->c1 != NULL)
1043 ret->c1->parent = ret;
1044 if (cur->c2 != NULL) {
1045 prev = ret;
1046 cur = cur->c2;
1047 while (cur != NULL) {
1048 tmp = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
1049 if (tmp == NULL) {
1050 xmlVErrMemory(NULL, "malloc failed");
1051 return(ret);
1052 }
1053 memset(tmp, 0, sizeof(xmlElementContent));
1054 tmp->type = cur->type;
1055 tmp->ocur = cur->ocur;
1056 prev->c2 = tmp;
1057 if (cur->name != NULL) {
1058 if (dict)
1059 tmp->name = xmlDictLookup(dict, cur->name, -1);
1060 else
1061 tmp->name = xmlStrdup(cur->name);
1062 }
1063
1064 if (cur->prefix != NULL) {
1065 if (dict)
1066 tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
1067 else
1068 tmp->prefix = xmlStrdup(cur->prefix);
1069 }
1070 if (cur->c1 != NULL)
1071 tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
1072 if (tmp->c1 != NULL)
1073 tmp->c1->parent = ret;
1074 prev = tmp;
1075 cur = cur->c2;
1076 }
1077 }
1078 return(ret);
1079 }
1080
1081 /**
1082 * xmlCopyElementContent:
1083 * @cur: An element content pointer.
1084 *
1085 * Build a copy of an element content description.
1086 * Deprecated, use xmlCopyDocElementContent instead
1087 *
1088 * Returns the new xmlElementContentPtr or NULL in case of error.
1089 */
1090 xmlElementContentPtr
xmlCopyElementContent(xmlElementContentPtr cur)1091 xmlCopyElementContent(xmlElementContentPtr cur) {
1092 return(xmlCopyDocElementContent(NULL, cur));
1093 }
1094
1095 /**
1096 * xmlFreeDocElementContent:
1097 * @doc: the document owning the element declaration
1098 * @cur: the element content tree to free
1099 *
1100 * Free an element content structure. The whole subtree is removed.
1101 */
1102 void
xmlFreeDocElementContent(xmlDocPtr doc,xmlElementContentPtr cur)1103 xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur) {
1104 xmlElementContentPtr next;
1105 xmlDictPtr dict = NULL;
1106
1107 if (doc != NULL)
1108 dict = doc->dict;
1109
1110 while (cur != NULL) {
1111 next = cur->c2;
1112 switch (cur->type) {
1113 case XML_ELEMENT_CONTENT_PCDATA:
1114 case XML_ELEMENT_CONTENT_ELEMENT:
1115 case XML_ELEMENT_CONTENT_SEQ:
1116 case XML_ELEMENT_CONTENT_OR:
1117 break;
1118 default:
1119 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1120 "Internal: ELEMENT content corrupted invalid type\n",
1121 NULL);
1122 return;
1123 }
1124 if (cur->c1 != NULL) xmlFreeDocElementContent(doc, cur->c1);
1125 if (dict) {
1126 if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
1127 xmlFree((xmlChar *) cur->name);
1128 if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
1129 xmlFree((xmlChar *) cur->prefix);
1130 } else {
1131 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1132 if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
1133 }
1134 xmlFree(cur);
1135 cur = next;
1136 }
1137 }
1138
1139 /**
1140 * xmlFreeElementContent:
1141 * @cur: the element content tree to free
1142 *
1143 * Free an element content structure. The whole subtree is removed.
1144 * Deprecated, use xmlFreeDocElementContent instead
1145 */
1146 void
xmlFreeElementContent(xmlElementContentPtr cur)1147 xmlFreeElementContent(xmlElementContentPtr cur) {
1148 xmlFreeDocElementContent(NULL, cur);
1149 }
1150
1151 #ifdef LIBXML_OUTPUT_ENABLED
1152 /**
1153 * xmlDumpElementContent:
1154 * @buf: An XML buffer
1155 * @content: An element table
1156 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
1157 *
1158 * This will dump the content of the element table as an XML DTD definition
1159 */
1160 static void
xmlDumpElementContent(xmlBufferPtr buf,xmlElementContentPtr content,int glob)1161 xmlDumpElementContent(xmlBufferPtr buf, xmlElementContentPtr content, int glob) {
1162 if (content == NULL) return;
1163
1164 if (glob) xmlBufferWriteChar(buf, "(");
1165 switch (content->type) {
1166 case XML_ELEMENT_CONTENT_PCDATA:
1167 xmlBufferWriteChar(buf, "#PCDATA");
1168 break;
1169 case XML_ELEMENT_CONTENT_ELEMENT:
1170 if (content->prefix != NULL) {
1171 xmlBufferWriteCHAR(buf, content->prefix);
1172 xmlBufferWriteChar(buf, ":");
1173 }
1174 xmlBufferWriteCHAR(buf, content->name);
1175 break;
1176 case XML_ELEMENT_CONTENT_SEQ:
1177 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1178 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1179 xmlDumpElementContent(buf, content->c1, 1);
1180 else
1181 xmlDumpElementContent(buf, content->c1, 0);
1182 xmlBufferWriteChar(buf, " , ");
1183 if ((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1184 ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) &&
1185 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1186 xmlDumpElementContent(buf, content->c2, 1);
1187 else
1188 xmlDumpElementContent(buf, content->c2, 0);
1189 break;
1190 case XML_ELEMENT_CONTENT_OR:
1191 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1192 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1193 xmlDumpElementContent(buf, content->c1, 1);
1194 else
1195 xmlDumpElementContent(buf, content->c1, 0);
1196 xmlBufferWriteChar(buf, " | ");
1197 if ((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1198 ((content->c2->type == XML_ELEMENT_CONTENT_OR) &&
1199 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)))
1200 xmlDumpElementContent(buf, content->c2, 1);
1201 else
1202 xmlDumpElementContent(buf, content->c2, 0);
1203 break;
1204 default:
1205 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1206 "Internal: ELEMENT content corrupted invalid type\n",
1207 NULL);
1208 }
1209 if (glob)
1210 xmlBufferWriteChar(buf, ")");
1211 switch (content->ocur) {
1212 case XML_ELEMENT_CONTENT_ONCE:
1213 break;
1214 case XML_ELEMENT_CONTENT_OPT:
1215 xmlBufferWriteChar(buf, "?");
1216 break;
1217 case XML_ELEMENT_CONTENT_MULT:
1218 xmlBufferWriteChar(buf, "*");
1219 break;
1220 case XML_ELEMENT_CONTENT_PLUS:
1221 xmlBufferWriteChar(buf, "+");
1222 break;
1223 }
1224 }
1225
1226 /**
1227 * xmlSprintfElementContent:
1228 * @buf: an output buffer
1229 * @content: An element table
1230 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1231 *
1232 * Deprecated, unsafe, use xmlSnprintfElementContent
1233 */
1234 void
xmlSprintfElementContent(char * buf ATTRIBUTE_UNUSED,xmlElementContentPtr content ATTRIBUTE_UNUSED,int englob ATTRIBUTE_UNUSED)1235 xmlSprintfElementContent(char *buf ATTRIBUTE_UNUSED,
1236 xmlElementContentPtr content ATTRIBUTE_UNUSED,
1237 int englob ATTRIBUTE_UNUSED) {
1238 }
1239 #endif /* LIBXML_OUTPUT_ENABLED */
1240
1241 /**
1242 * xmlSnprintfElementContent:
1243 * @buf: an output buffer
1244 * @size: the buffer size
1245 * @content: An element table
1246 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1247 *
1248 * This will dump the content of the element content definition
1249 * Intended just for the debug routine
1250 */
1251 void
xmlSnprintfElementContent(char * buf,int size,xmlElementContentPtr content,int englob)1252 xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
1253 int len;
1254
1255 if (content == NULL) return;
1256 len = strlen(buf);
1257 if (size - len < 50) {
1258 if ((size - len > 4) && (buf[len - 1] != '.'))
1259 strcat(buf, " ...");
1260 return;
1261 }
1262 if (englob) strcat(buf, "(");
1263 switch (content->type) {
1264 case XML_ELEMENT_CONTENT_PCDATA:
1265 strcat(buf, "#PCDATA");
1266 break;
1267 case XML_ELEMENT_CONTENT_ELEMENT:
1268 if (content->prefix != NULL) {
1269 if (size - len < xmlStrlen(content->prefix) + 10) {
1270 strcat(buf, " ...");
1271 return;
1272 }
1273 strcat(buf, (char *) content->prefix);
1274 strcat(buf, ":");
1275 }
1276 if (size - len < xmlStrlen(content->name) + 10) {
1277 strcat(buf, " ...");
1278 return;
1279 }
1280 if (content->name != NULL)
1281 strcat(buf, (char *) content->name);
1282 break;
1283 case XML_ELEMENT_CONTENT_SEQ:
1284 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1285 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1286 xmlSnprintfElementContent(buf, size, content->c1, 1);
1287 else
1288 xmlSnprintfElementContent(buf, size, content->c1, 0);
1289 len = strlen(buf);
1290 if (size - len < 50) {
1291 if ((size - len > 4) && (buf[len - 1] != '.'))
1292 strcat(buf, " ...");
1293 return;
1294 }
1295 strcat(buf, " , ");
1296 if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1297 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1298 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1299 xmlSnprintfElementContent(buf, size, content->c2, 1);
1300 else
1301 xmlSnprintfElementContent(buf, size, content->c2, 0);
1302 break;
1303 case XML_ELEMENT_CONTENT_OR:
1304 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1305 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1306 xmlSnprintfElementContent(buf, size, content->c1, 1);
1307 else
1308 xmlSnprintfElementContent(buf, size, content->c1, 0);
1309 len = strlen(buf);
1310 if (size - len < 50) {
1311 if ((size - len > 4) && (buf[len - 1] != '.'))
1312 strcat(buf, " ...");
1313 return;
1314 }
1315 strcat(buf, " | ");
1316 if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1317 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1318 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1319 xmlSnprintfElementContent(buf, size, content->c2, 1);
1320 else
1321 xmlSnprintfElementContent(buf, size, content->c2, 0);
1322 break;
1323 }
1324 if (englob)
1325 strcat(buf, ")");
1326 switch (content->ocur) {
1327 case XML_ELEMENT_CONTENT_ONCE:
1328 break;
1329 case XML_ELEMENT_CONTENT_OPT:
1330 strcat(buf, "?");
1331 break;
1332 case XML_ELEMENT_CONTENT_MULT:
1333 strcat(buf, "*");
1334 break;
1335 case XML_ELEMENT_CONTENT_PLUS:
1336 strcat(buf, "+");
1337 break;
1338 }
1339 }
1340
1341 /****************************************************************
1342 * *
1343 * Registration of DTD declarations *
1344 * *
1345 ****************************************************************/
1346
1347 /**
1348 * xmlFreeElement:
1349 * @elem: An element
1350 *
1351 * Deallocate the memory used by an element definition
1352 */
1353 static void
xmlFreeElement(xmlElementPtr elem)1354 xmlFreeElement(xmlElementPtr elem) {
1355 if (elem == NULL) return;
1356 xmlUnlinkNode((xmlNodePtr) elem);
1357 xmlFreeDocElementContent(elem->doc, elem->content);
1358 if (elem->name != NULL)
1359 xmlFree((xmlChar *) elem->name);
1360 if (elem->prefix != NULL)
1361 xmlFree((xmlChar *) elem->prefix);
1362 #ifdef LIBXML_REGEXP_ENABLED
1363 if (elem->contModel != NULL)
1364 xmlRegFreeRegexp(elem->contModel);
1365 #endif
1366 xmlFree(elem);
1367 }
1368
1369
1370 /**
1371 * xmlAddElementDecl:
1372 * @ctxt: the validation context
1373 * @dtd: pointer to the DTD
1374 * @name: the entity name
1375 * @type: the element type
1376 * @content: the element content tree or NULL
1377 *
1378 * Register a new element declaration
1379 *
1380 * Returns NULL if not, otherwise the entity
1381 */
1382 xmlElementPtr
xmlAddElementDecl(xmlValidCtxtPtr ctxt,xmlDtdPtr dtd,const xmlChar * name,xmlElementTypeVal type,xmlElementContentPtr content)1383 xmlAddElementDecl(xmlValidCtxtPtr ctxt,
1384 xmlDtdPtr dtd, const xmlChar *name,
1385 xmlElementTypeVal type,
1386 xmlElementContentPtr content) {
1387 xmlElementPtr ret;
1388 xmlElementTablePtr table;
1389 xmlAttributePtr oldAttributes = NULL;
1390 xmlChar *ns, *uqname;
1391
1392 if (dtd == NULL) {
1393 return(NULL);
1394 }
1395 if (name == NULL) {
1396 return(NULL);
1397 }
1398
1399 switch (type) {
1400 case XML_ELEMENT_TYPE_EMPTY:
1401 if (content != NULL) {
1402 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1403 "xmlAddElementDecl: content != NULL for EMPTY\n",
1404 NULL);
1405 return(NULL);
1406 }
1407 break;
1408 case XML_ELEMENT_TYPE_ANY:
1409 if (content != NULL) {
1410 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1411 "xmlAddElementDecl: content != NULL for ANY\n",
1412 NULL);
1413 return(NULL);
1414 }
1415 break;
1416 case XML_ELEMENT_TYPE_MIXED:
1417 if (content == NULL) {
1418 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1419 "xmlAddElementDecl: content == NULL for MIXED\n",
1420 NULL);
1421 return(NULL);
1422 }
1423 break;
1424 case XML_ELEMENT_TYPE_ELEMENT:
1425 if (content == NULL) {
1426 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1427 "xmlAddElementDecl: content == NULL for ELEMENT\n",
1428 NULL);
1429 return(NULL);
1430 }
1431 break;
1432 default:
1433 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1434 "Internal: ELEMENT decl corrupted invalid type\n",
1435 NULL);
1436 return(NULL);
1437 }
1438
1439 /*
1440 * check if name is a QName
1441 */
1442 uqname = xmlSplitQName2(name, &ns);
1443 if (uqname != NULL)
1444 name = uqname;
1445
1446 /*
1447 * Create the Element table if needed.
1448 */
1449 table = (xmlElementTablePtr) dtd->elements;
1450 if (table == NULL) {
1451 xmlDictPtr dict = NULL;
1452
1453 if (dtd->doc != NULL)
1454 dict = dtd->doc->dict;
1455 table = xmlHashCreateDict(0, dict);
1456 dtd->elements = (void *) table;
1457 }
1458 if (table == NULL) {
1459 xmlVErrMemory(ctxt,
1460 "xmlAddElementDecl: Table creation failed!\n");
1461 if (uqname != NULL)
1462 xmlFree(uqname);
1463 if (ns != NULL)
1464 xmlFree(ns);
1465 return(NULL);
1466 }
1467
1468 /*
1469 * lookup old attributes inserted on an undefined element in the
1470 * internal subset.
1471 */
1472 if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
1473 ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
1474 if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
1475 oldAttributes = ret->attributes;
1476 ret->attributes = NULL;
1477 xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
1478 xmlFreeElement(ret);
1479 }
1480 }
1481
1482 /*
1483 * The element may already be present if one of its attribute
1484 * was registered first
1485 */
1486 ret = xmlHashLookup2(table, name, ns);
1487 if (ret != NULL) {
1488 if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
1489 #ifdef LIBXML_VALID_ENABLED
1490 /*
1491 * The element is already defined in this DTD.
1492 */
1493 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1494 "Redefinition of element %s\n",
1495 name, NULL, NULL);
1496 #endif /* LIBXML_VALID_ENABLED */
1497 if (uqname != NULL)
1498 xmlFree(uqname);
1499 if (ns != NULL)
1500 xmlFree(ns);
1501 return(NULL);
1502 }
1503 if (ns != NULL) {
1504 xmlFree(ns);
1505 ns = NULL;
1506 }
1507 } else {
1508 ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1509 if (ret == NULL) {
1510 xmlVErrMemory(ctxt, "malloc failed");
1511 if (uqname != NULL)
1512 xmlFree(uqname);
1513 if (ns != NULL)
1514 xmlFree(ns);
1515 return(NULL);
1516 }
1517 memset(ret, 0, sizeof(xmlElement));
1518 ret->type = XML_ELEMENT_DECL;
1519
1520 /*
1521 * fill the structure.
1522 */
1523 ret->name = xmlStrdup(name);
1524 if (ret->name == NULL) {
1525 xmlVErrMemory(ctxt, "malloc failed");
1526 if (uqname != NULL)
1527 xmlFree(uqname);
1528 if (ns != NULL)
1529 xmlFree(ns);
1530 xmlFree(ret);
1531 return(NULL);
1532 }
1533 ret->prefix = ns;
1534
1535 /*
1536 * Validity Check:
1537 * Insertion must not fail
1538 */
1539 if (xmlHashAddEntry2(table, name, ns, ret)) {
1540 #ifdef LIBXML_VALID_ENABLED
1541 /*
1542 * The element is already defined in this DTD.
1543 */
1544 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1545 "Redefinition of element %s\n",
1546 name, NULL, NULL);
1547 #endif /* LIBXML_VALID_ENABLED */
1548 xmlFreeElement(ret);
1549 if (uqname != NULL)
1550 xmlFree(uqname);
1551 return(NULL);
1552 }
1553 /*
1554 * For new element, may have attributes from earlier
1555 * definition in internal subset
1556 */
1557 ret->attributes = oldAttributes;
1558 }
1559
1560 /*
1561 * Finish to fill the structure.
1562 */
1563 ret->etype = type;
1564 /*
1565 * Avoid a stupid copy when called by the parser
1566 * and flag it by setting a special parent value
1567 * so the parser doesn't unallocate it.
1568 */
1569 if ((ctxt != NULL) &&
1570 ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
1571 (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
1572 ret->content = content;
1573 if (content != NULL)
1574 content->parent = (xmlElementContentPtr) 1;
1575 } else {
1576 ret->content = xmlCopyDocElementContent(dtd->doc, content);
1577 }
1578
1579 /*
1580 * Link it to the DTD
1581 */
1582 ret->parent = dtd;
1583 ret->doc = dtd->doc;
1584 if (dtd->last == NULL) {
1585 dtd->children = dtd->last = (xmlNodePtr) ret;
1586 } else {
1587 dtd->last->next = (xmlNodePtr) ret;
1588 ret->prev = dtd->last;
1589 dtd->last = (xmlNodePtr) ret;
1590 }
1591 if (uqname != NULL)
1592 xmlFree(uqname);
1593 return(ret);
1594 }
1595
1596 /**
1597 * xmlFreeElementTable:
1598 * @table: An element table
1599 *
1600 * Deallocate the memory used by an element hash table.
1601 */
1602 void
xmlFreeElementTable(xmlElementTablePtr table)1603 xmlFreeElementTable(xmlElementTablePtr table) {
1604 xmlHashFree(table, (xmlHashDeallocator) xmlFreeElement);
1605 }
1606
1607 #ifdef LIBXML_TREE_ENABLED
1608 /**
1609 * xmlCopyElement:
1610 * @elem: An element
1611 *
1612 * Build a copy of an element.
1613 *
1614 * Returns the new xmlElementPtr or NULL in case of error.
1615 */
1616 static xmlElementPtr
xmlCopyElement(xmlElementPtr elem)1617 xmlCopyElement(xmlElementPtr elem) {
1618 xmlElementPtr cur;
1619
1620 cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
1621 if (cur == NULL) {
1622 xmlVErrMemory(NULL, "malloc failed");
1623 return(NULL);
1624 }
1625 memset(cur, 0, sizeof(xmlElement));
1626 cur->type = XML_ELEMENT_DECL;
1627 cur->etype = elem->etype;
1628 if (elem->name != NULL)
1629 cur->name = xmlStrdup(elem->name);
1630 else
1631 cur->name = NULL;
1632 if (elem->prefix != NULL)
1633 cur->prefix = xmlStrdup(elem->prefix);
1634 else
1635 cur->prefix = NULL;
1636 cur->content = xmlCopyElementContent(elem->content);
1637 /* TODO : rebuild the attribute list on the copy */
1638 cur->attributes = NULL;
1639 return(cur);
1640 }
1641
1642 /**
1643 * xmlCopyElementTable:
1644 * @table: An element table
1645 *
1646 * Build a copy of an element table.
1647 *
1648 * Returns the new xmlElementTablePtr or NULL in case of error.
1649 */
1650 xmlElementTablePtr
xmlCopyElementTable(xmlElementTablePtr table)1651 xmlCopyElementTable(xmlElementTablePtr table) {
1652 return((xmlElementTablePtr) xmlHashCopy(table,
1653 (xmlHashCopier) xmlCopyElement));
1654 }
1655 #endif /* LIBXML_TREE_ENABLED */
1656
1657 #ifdef LIBXML_OUTPUT_ENABLED
1658 /**
1659 * xmlDumpElementDecl:
1660 * @buf: the XML buffer output
1661 * @elem: An element table
1662 *
1663 * This will dump the content of the element declaration as an XML
1664 * DTD definition
1665 */
1666 void
xmlDumpElementDecl(xmlBufferPtr buf,xmlElementPtr elem)1667 xmlDumpElementDecl(xmlBufferPtr buf, xmlElementPtr elem) {
1668 if ((buf == NULL) || (elem == NULL))
1669 return;
1670 switch (elem->etype) {
1671 case XML_ELEMENT_TYPE_EMPTY:
1672 xmlBufferWriteChar(buf, "<!ELEMENT ");
1673 if (elem->prefix != NULL) {
1674 xmlBufferWriteCHAR(buf, elem->prefix);
1675 xmlBufferWriteChar(buf, ":");
1676 }
1677 xmlBufferWriteCHAR(buf, elem->name);
1678 xmlBufferWriteChar(buf, " EMPTY>\n");
1679 break;
1680 case XML_ELEMENT_TYPE_ANY:
1681 xmlBufferWriteChar(buf, "<!ELEMENT ");
1682 if (elem->prefix != NULL) {
1683 xmlBufferWriteCHAR(buf, elem->prefix);
1684 xmlBufferWriteChar(buf, ":");
1685 }
1686 xmlBufferWriteCHAR(buf, elem->name);
1687 xmlBufferWriteChar(buf, " ANY>\n");
1688 break;
1689 case XML_ELEMENT_TYPE_MIXED:
1690 xmlBufferWriteChar(buf, "<!ELEMENT ");
1691 if (elem->prefix != NULL) {
1692 xmlBufferWriteCHAR(buf, elem->prefix);
1693 xmlBufferWriteChar(buf, ":");
1694 }
1695 xmlBufferWriteCHAR(buf, elem->name);
1696 xmlBufferWriteChar(buf, " ");
1697 xmlDumpElementContent(buf, elem->content, 1);
1698 xmlBufferWriteChar(buf, ">\n");
1699 break;
1700 case XML_ELEMENT_TYPE_ELEMENT:
1701 xmlBufferWriteChar(buf, "<!ELEMENT ");
1702 if (elem->prefix != NULL) {
1703 xmlBufferWriteCHAR(buf, elem->prefix);
1704 xmlBufferWriteChar(buf, ":");
1705 }
1706 xmlBufferWriteCHAR(buf, elem->name);
1707 xmlBufferWriteChar(buf, " ");
1708 xmlDumpElementContent(buf, elem->content, 1);
1709 xmlBufferWriteChar(buf, ">\n");
1710 break;
1711 default:
1712 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1713 "Internal: ELEMENT struct corrupted invalid type\n",
1714 NULL);
1715 }
1716 }
1717
1718 /**
1719 * xmlDumpElementDeclScan:
1720 * @elem: An element table
1721 * @buf: the XML buffer output
1722 *
1723 * This routine is used by the hash scan function. It just reverses
1724 * the arguments.
1725 */
1726 static void
xmlDumpElementDeclScan(xmlElementPtr elem,xmlBufferPtr buf)1727 xmlDumpElementDeclScan(xmlElementPtr elem, xmlBufferPtr buf) {
1728 xmlDumpElementDecl(buf, elem);
1729 }
1730
1731 /**
1732 * xmlDumpElementTable:
1733 * @buf: the XML buffer output
1734 * @table: An element table
1735 *
1736 * This will dump the content of the element table as an XML DTD definition
1737 */
1738 void
xmlDumpElementTable(xmlBufferPtr buf,xmlElementTablePtr table)1739 xmlDumpElementTable(xmlBufferPtr buf, xmlElementTablePtr table) {
1740 if ((buf == NULL) || (table == NULL))
1741 return;
1742 xmlHashScan(table, (xmlHashScanner) xmlDumpElementDeclScan, buf);
1743 }
1744 #endif /* LIBXML_OUTPUT_ENABLED */
1745
1746 /**
1747 * xmlCreateEnumeration:
1748 * @name: the enumeration name or NULL
1749 *
1750 * create and initialize an enumeration attribute node.
1751 *
1752 * Returns the xmlEnumerationPtr just created or NULL in case
1753 * of error.
1754 */
1755 xmlEnumerationPtr
xmlCreateEnumeration(const xmlChar * name)1756 xmlCreateEnumeration(const xmlChar *name) {
1757 xmlEnumerationPtr ret;
1758
1759 ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
1760 if (ret == NULL) {
1761 xmlVErrMemory(NULL, "malloc failed");
1762 return(NULL);
1763 }
1764 memset(ret, 0, sizeof(xmlEnumeration));
1765
1766 if (name != NULL)
1767 ret->name = xmlStrdup(name);
1768 return(ret);
1769 }
1770
1771 /**
1772 * xmlFreeEnumeration:
1773 * @cur: the tree to free.
1774 *
1775 * free an enumeration attribute node (recursive).
1776 */
1777 void
xmlFreeEnumeration(xmlEnumerationPtr cur)1778 xmlFreeEnumeration(xmlEnumerationPtr cur) {
1779 if (cur == NULL) return;
1780
1781 if (cur->next != NULL) xmlFreeEnumeration(cur->next);
1782
1783 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1784 xmlFree(cur);
1785 }
1786
1787 #ifdef LIBXML_TREE_ENABLED
1788 /**
1789 * xmlCopyEnumeration:
1790 * @cur: the tree to copy.
1791 *
1792 * Copy an enumeration attribute node (recursive).
1793 *
1794 * Returns the xmlEnumerationPtr just created or NULL in case
1795 * of error.
1796 */
1797 xmlEnumerationPtr
xmlCopyEnumeration(xmlEnumerationPtr cur)1798 xmlCopyEnumeration(xmlEnumerationPtr cur) {
1799 xmlEnumerationPtr ret;
1800
1801 if (cur == NULL) return(NULL);
1802 ret = xmlCreateEnumeration((xmlChar *) cur->name);
1803
1804 if (cur->next != NULL) ret->next = xmlCopyEnumeration(cur->next);
1805 else ret->next = NULL;
1806
1807 return(ret);
1808 }
1809 #endif /* LIBXML_TREE_ENABLED */
1810
1811 #ifdef LIBXML_OUTPUT_ENABLED
1812 /**
1813 * xmlDumpEnumeration:
1814 * @buf: the XML buffer output
1815 * @enum: An enumeration
1816 *
1817 * This will dump the content of the enumeration
1818 */
1819 static void
xmlDumpEnumeration(xmlBufferPtr buf,xmlEnumerationPtr cur)1820 xmlDumpEnumeration(xmlBufferPtr buf, xmlEnumerationPtr cur) {
1821 if ((buf == NULL) || (cur == NULL))
1822 return;
1823
1824 xmlBufferWriteCHAR(buf, cur->name);
1825 if (cur->next == NULL)
1826 xmlBufferWriteChar(buf, ")");
1827 else {
1828 xmlBufferWriteChar(buf, " | ");
1829 xmlDumpEnumeration(buf, cur->next);
1830 }
1831 }
1832 #endif /* LIBXML_OUTPUT_ENABLED */
1833
1834 #ifdef LIBXML_VALID_ENABLED
1835 /**
1836 * xmlScanAttributeDeclCallback:
1837 * @attr: the attribute decl
1838 * @list: the list to update
1839 *
1840 * Callback called by xmlScanAttributeDecl when a new attribute
1841 * has to be entered in the list.
1842 */
1843 static void
xmlScanAttributeDeclCallback(xmlAttributePtr attr,xmlAttributePtr * list,const xmlChar * name ATTRIBUTE_UNUSED)1844 xmlScanAttributeDeclCallback(xmlAttributePtr attr, xmlAttributePtr *list,
1845 const xmlChar* name ATTRIBUTE_UNUSED) {
1846 attr->nexth = *list;
1847 *list = attr;
1848 }
1849
1850 /**
1851 * xmlScanAttributeDecl:
1852 * @dtd: pointer to the DTD
1853 * @elem: the element name
1854 *
1855 * When inserting a new element scan the DtD for existing attributes
1856 * for that element and initialize the Attribute chain
1857 *
1858 * Returns the pointer to the first attribute decl in the chain,
1859 * possibly NULL.
1860 */
1861 xmlAttributePtr
xmlScanAttributeDecl(xmlDtdPtr dtd,const xmlChar * elem)1862 xmlScanAttributeDecl(xmlDtdPtr dtd, const xmlChar *elem) {
1863 xmlAttributePtr ret = NULL;
1864 xmlAttributeTablePtr table;
1865
1866 if (dtd == NULL) {
1867 return(NULL);
1868 }
1869 if (elem == NULL) {
1870 return(NULL);
1871 }
1872 table = (xmlAttributeTablePtr) dtd->attributes;
1873 if (table == NULL)
1874 return(NULL);
1875
1876 /* WRONG !!! */
1877 xmlHashScan3(table, NULL, NULL, elem,
1878 (xmlHashScanner) xmlScanAttributeDeclCallback, &ret);
1879 return(ret);
1880 }
1881
1882 /**
1883 * xmlScanIDAttributeDecl:
1884 * @ctxt: the validation context
1885 * @elem: the element name
1886 * @err: whether to raise errors here
1887 *
1888 * Verify that the element don't have too many ID attributes
1889 * declared.
1890 *
1891 * Returns the number of ID attributes found.
1892 */
1893 static int
xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt,xmlElementPtr elem,int err)1894 xmlScanIDAttributeDecl(xmlValidCtxtPtr ctxt, xmlElementPtr elem, int err) {
1895 xmlAttributePtr cur;
1896 int ret = 0;
1897
1898 if (elem == NULL) return(0);
1899 cur = elem->attributes;
1900 while (cur != NULL) {
1901 if (cur->atype == XML_ATTRIBUTE_ID) {
1902 ret ++;
1903 if ((ret > 1) && (err))
1904 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_MULTIPLE_ID,
1905 "Element %s has too many ID attributes defined : %s\n",
1906 elem->name, cur->name, NULL);
1907 }
1908 cur = cur->nexth;
1909 }
1910 return(ret);
1911 }
1912 #endif /* LIBXML_VALID_ENABLED */
1913
1914 /**
1915 * xmlFreeAttribute:
1916 * @elem: An attribute
1917 *
1918 * Deallocate the memory used by an attribute definition
1919 */
1920 static void
xmlFreeAttribute(xmlAttributePtr attr)1921 xmlFreeAttribute(xmlAttributePtr attr) {
1922 xmlDictPtr dict;
1923
1924 if (attr == NULL) return;
1925 if (attr->doc != NULL)
1926 dict = attr->doc->dict;
1927 else
1928 dict = NULL;
1929 xmlUnlinkNode((xmlNodePtr) attr);
1930 if (attr->tree != NULL)
1931 xmlFreeEnumeration(attr->tree);
1932 if (dict) {
1933 if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
1934 xmlFree((xmlChar *) attr->elem);
1935 if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
1936 xmlFree((xmlChar *) attr->name);
1937 if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
1938 xmlFree((xmlChar *) attr->prefix);
1939 if ((attr->defaultValue != NULL) &&
1940 (!xmlDictOwns(dict, attr->defaultValue)))
1941 xmlFree((xmlChar *) attr->defaultValue);
1942 } else {
1943 if (attr->elem != NULL)
1944 xmlFree((xmlChar *) attr->elem);
1945 if (attr->name != NULL)
1946 xmlFree((xmlChar *) attr->name);
1947 if (attr->defaultValue != NULL)
1948 xmlFree((xmlChar *) attr->defaultValue);
1949 if (attr->prefix != NULL)
1950 xmlFree((xmlChar *) attr->prefix);
1951 }
1952 xmlFree(attr);
1953 }
1954
1955
1956 /**
1957 * xmlAddAttributeDecl:
1958 * @ctxt: the validation context
1959 * @dtd: pointer to the DTD
1960 * @elem: the element name
1961 * @name: the attribute name
1962 * @ns: the attribute namespace prefix
1963 * @type: the attribute type
1964 * @def: the attribute default type
1965 * @defaultValue: the attribute default value
1966 * @tree: if it's an enumeration, the associated list
1967 *
1968 * Register a new attribute declaration
1969 * Note that @tree becomes the ownership of the DTD
1970 *
1971 * Returns NULL if not new, otherwise the attribute decl
1972 */
1973 xmlAttributePtr
xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,xmlDtdPtr dtd,const xmlChar * elem,const xmlChar * name,const xmlChar * ns,xmlAttributeType type,xmlAttributeDefault def,const xmlChar * defaultValue,xmlEnumerationPtr tree)1974 xmlAddAttributeDecl(xmlValidCtxtPtr ctxt,
1975 xmlDtdPtr dtd, const xmlChar *elem,
1976 const xmlChar *name, const xmlChar *ns,
1977 xmlAttributeType type, xmlAttributeDefault def,
1978 const xmlChar *defaultValue, xmlEnumerationPtr tree) {
1979 xmlAttributePtr ret;
1980 xmlAttributeTablePtr table;
1981 xmlElementPtr elemDef;
1982 xmlDictPtr dict = NULL;
1983
1984 if (dtd == NULL) {
1985 xmlFreeEnumeration(tree);
1986 return(NULL);
1987 }
1988 if (name == NULL) {
1989 xmlFreeEnumeration(tree);
1990 return(NULL);
1991 }
1992 if (elem == NULL) {
1993 xmlFreeEnumeration(tree);
1994 return(NULL);
1995 }
1996 if (dtd->doc != NULL)
1997 dict = dtd->doc->dict;
1998
1999 #ifdef LIBXML_VALID_ENABLED
2000 /*
2001 * Check the type and possibly the default value.
2002 */
2003 switch (type) {
2004 case XML_ATTRIBUTE_CDATA:
2005 break;
2006 case XML_ATTRIBUTE_ID:
2007 break;
2008 case XML_ATTRIBUTE_IDREF:
2009 break;
2010 case XML_ATTRIBUTE_IDREFS:
2011 break;
2012 case XML_ATTRIBUTE_ENTITY:
2013 break;
2014 case XML_ATTRIBUTE_ENTITIES:
2015 break;
2016 case XML_ATTRIBUTE_NMTOKEN:
2017 break;
2018 case XML_ATTRIBUTE_NMTOKENS:
2019 break;
2020 case XML_ATTRIBUTE_ENUMERATION:
2021 break;
2022 case XML_ATTRIBUTE_NOTATION:
2023 break;
2024 default:
2025 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
2026 "Internal: ATTRIBUTE struct corrupted invalid type\n",
2027 NULL);
2028 xmlFreeEnumeration(tree);
2029 return(NULL);
2030 }
2031 if ((defaultValue != NULL) &&
2032 (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
2033 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
2034 "Attribute %s of %s: invalid default value\n",
2035 elem, name, defaultValue);
2036 defaultValue = NULL;
2037 if (ctxt != NULL)
2038 ctxt->valid = 0;
2039 }
2040 #endif /* LIBXML_VALID_ENABLED */
2041
2042 /*
2043 * Check first that an attribute defined in the external subset wasn't
2044 * already defined in the internal subset
2045 */
2046 if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
2047 (dtd->doc->intSubset != NULL) &&
2048 (dtd->doc->intSubset->attributes != NULL)) {
2049 ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
2050 if (ret != NULL) {
2051 xmlFreeEnumeration(tree);
2052 return(NULL);
2053 }
2054 }
2055
2056 /*
2057 * Create the Attribute table if needed.
2058 */
2059 table = (xmlAttributeTablePtr) dtd->attributes;
2060 if (table == NULL) {
2061 table = xmlHashCreateDict(0, dict);
2062 dtd->attributes = (void *) table;
2063 }
2064 if (table == NULL) {
2065 xmlVErrMemory(ctxt,
2066 "xmlAddAttributeDecl: Table creation failed!\n");
2067 xmlFreeEnumeration(tree);
2068 return(NULL);
2069 }
2070
2071
2072 ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2073 if (ret == NULL) {
2074 xmlVErrMemory(ctxt, "malloc failed");
2075 xmlFreeEnumeration(tree);
2076 return(NULL);
2077 }
2078 memset(ret, 0, sizeof(xmlAttribute));
2079 ret->type = XML_ATTRIBUTE_DECL;
2080
2081 /*
2082 * fill the structure.
2083 */
2084 ret->atype = type;
2085 /*
2086 * doc must be set before possible error causes call
2087 * to xmlFreeAttribute (because it's used to check on
2088 * dict use)
2089 */
2090 ret->doc = dtd->doc;
2091 if (dict) {
2092 ret->name = xmlDictLookup(dict, name, -1);
2093 ret->prefix = xmlDictLookup(dict, ns, -1);
2094 ret->elem = xmlDictLookup(dict, elem, -1);
2095 } else {
2096 ret->name = xmlStrdup(name);
2097 ret->prefix = xmlStrdup(ns);
2098 ret->elem = xmlStrdup(elem);
2099 }
2100 ret->def = def;
2101 ret->tree = tree;
2102 if (defaultValue != NULL) {
2103 if (dict)
2104 ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2105 else
2106 ret->defaultValue = xmlStrdup(defaultValue);
2107 }
2108
2109 /*
2110 * Validity Check:
2111 * Search the DTD for previous declarations of the ATTLIST
2112 */
2113 if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
2114 #ifdef LIBXML_VALID_ENABLED
2115 /*
2116 * The attribute is already defined in this DTD.
2117 */
2118 xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
2119 "Attribute %s of element %s: already defined\n",
2120 name, elem, NULL);
2121 #endif /* LIBXML_VALID_ENABLED */
2122 xmlFreeAttribute(ret);
2123 return(NULL);
2124 }
2125
2126 /*
2127 * Validity Check:
2128 * Multiple ID per element
2129 */
2130 elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
2131 if (elemDef != NULL) {
2132
2133 #ifdef LIBXML_VALID_ENABLED
2134 if ((type == XML_ATTRIBUTE_ID) &&
2135 (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
2136 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
2137 "Element %s has too may ID attributes defined : %s\n",
2138 elem, name, NULL);
2139 if (ctxt != NULL)
2140 ctxt->valid = 0;
2141 }
2142 #endif /* LIBXML_VALID_ENABLED */
2143
2144 /*
2145 * Insert namespace default def first they need to be
2146 * processed first.
2147 */
2148 if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
2149 ((ret->prefix != NULL &&
2150 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
2151 ret->nexth = elemDef->attributes;
2152 elemDef->attributes = ret;
2153 } else {
2154 xmlAttributePtr tmp = elemDef->attributes;
2155
2156 while ((tmp != NULL) &&
2157 ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
2158 ((ret->prefix != NULL &&
2159 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
2160 if (tmp->nexth == NULL)
2161 break;
2162 tmp = tmp->nexth;
2163 }
2164 if (tmp != NULL) {
2165 ret->nexth = tmp->nexth;
2166 tmp->nexth = ret;
2167 } else {
2168 ret->nexth = elemDef->attributes;
2169 elemDef->attributes = ret;
2170 }
2171 }
2172 }
2173
2174 /*
2175 * Link it to the DTD
2176 */
2177 ret->parent = dtd;
2178 if (dtd->last == NULL) {
2179 dtd->children = dtd->last = (xmlNodePtr) ret;
2180 } else {
2181 dtd->last->next = (xmlNodePtr) ret;
2182 ret->prev = dtd->last;
2183 dtd->last = (xmlNodePtr) ret;
2184 }
2185 return(ret);
2186 }
2187
2188 /**
2189 * xmlFreeAttributeTable:
2190 * @table: An attribute table
2191 *
2192 * Deallocate the memory used by an entities hash table.
2193 */
2194 void
xmlFreeAttributeTable(xmlAttributeTablePtr table)2195 xmlFreeAttributeTable(xmlAttributeTablePtr table) {
2196 xmlHashFree(table, (xmlHashDeallocator) xmlFreeAttribute);
2197 }
2198
2199 #ifdef LIBXML_TREE_ENABLED
2200 /**
2201 * xmlCopyAttribute:
2202 * @attr: An attribute
2203 *
2204 * Build a copy of an attribute.
2205 *
2206 * Returns the new xmlAttributePtr or NULL in case of error.
2207 */
2208 static xmlAttributePtr
xmlCopyAttribute(xmlAttributePtr attr)2209 xmlCopyAttribute(xmlAttributePtr attr) {
2210 xmlAttributePtr cur;
2211
2212 cur = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
2213 if (cur == NULL) {
2214 xmlVErrMemory(NULL, "malloc failed");
2215 return(NULL);
2216 }
2217 memset(cur, 0, sizeof(xmlAttribute));
2218 cur->type = XML_ATTRIBUTE_DECL;
2219 cur->atype = attr->atype;
2220 cur->def = attr->def;
2221 cur->tree = xmlCopyEnumeration(attr->tree);
2222 if (attr->elem != NULL)
2223 cur->elem = xmlStrdup(attr->elem);
2224 if (attr->name != NULL)
2225 cur->name = xmlStrdup(attr->name);
2226 if (attr->prefix != NULL)
2227 cur->prefix = xmlStrdup(attr->prefix);
2228 if (attr->defaultValue != NULL)
2229 cur->defaultValue = xmlStrdup(attr->defaultValue);
2230 return(cur);
2231 }
2232
2233 /**
2234 * xmlCopyAttributeTable:
2235 * @table: An attribute table
2236 *
2237 * Build a copy of an attribute table.
2238 *
2239 * Returns the new xmlAttributeTablePtr or NULL in case of error.
2240 */
2241 xmlAttributeTablePtr
xmlCopyAttributeTable(xmlAttributeTablePtr table)2242 xmlCopyAttributeTable(xmlAttributeTablePtr table) {
2243 return((xmlAttributeTablePtr) xmlHashCopy(table,
2244 (xmlHashCopier) xmlCopyAttribute));
2245 }
2246 #endif /* LIBXML_TREE_ENABLED */
2247
2248 #ifdef LIBXML_OUTPUT_ENABLED
2249 /**
2250 * xmlDumpAttributeDecl:
2251 * @buf: the XML buffer output
2252 * @attr: An attribute declaration
2253 *
2254 * This will dump the content of the attribute declaration as an XML
2255 * DTD definition
2256 */
2257 void
xmlDumpAttributeDecl(xmlBufferPtr buf,xmlAttributePtr attr)2258 xmlDumpAttributeDecl(xmlBufferPtr buf, xmlAttributePtr attr) {
2259 if ((buf == NULL) || (attr == NULL))
2260 return;
2261 xmlBufferWriteChar(buf, "<!ATTLIST ");
2262 xmlBufferWriteCHAR(buf, attr->elem);
2263 xmlBufferWriteChar(buf, " ");
2264 if (attr->prefix != NULL) {
2265 xmlBufferWriteCHAR(buf, attr->prefix);
2266 xmlBufferWriteChar(buf, ":");
2267 }
2268 xmlBufferWriteCHAR(buf, attr->name);
2269 switch (attr->atype) {
2270 case XML_ATTRIBUTE_CDATA:
2271 xmlBufferWriteChar(buf, " CDATA");
2272 break;
2273 case XML_ATTRIBUTE_ID:
2274 xmlBufferWriteChar(buf, " ID");
2275 break;
2276 case XML_ATTRIBUTE_IDREF:
2277 xmlBufferWriteChar(buf, " IDREF");
2278 break;
2279 case XML_ATTRIBUTE_IDREFS:
2280 xmlBufferWriteChar(buf, " IDREFS");
2281 break;
2282 case XML_ATTRIBUTE_ENTITY:
2283 xmlBufferWriteChar(buf, " ENTITY");
2284 break;
2285 case XML_ATTRIBUTE_ENTITIES:
2286 xmlBufferWriteChar(buf, " ENTITIES");
2287 break;
2288 case XML_ATTRIBUTE_NMTOKEN:
2289 xmlBufferWriteChar(buf, " NMTOKEN");
2290 break;
2291 case XML_ATTRIBUTE_NMTOKENS:
2292 xmlBufferWriteChar(buf, " NMTOKENS");
2293 break;
2294 case XML_ATTRIBUTE_ENUMERATION:
2295 xmlBufferWriteChar(buf, " (");
2296 xmlDumpEnumeration(buf, attr->tree);
2297 break;
2298 case XML_ATTRIBUTE_NOTATION:
2299 xmlBufferWriteChar(buf, " NOTATION (");
2300 xmlDumpEnumeration(buf, attr->tree);
2301 break;
2302 default:
2303 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2304 "Internal: ATTRIBUTE struct corrupted invalid type\n",
2305 NULL);
2306 }
2307 switch (attr->def) {
2308 case XML_ATTRIBUTE_NONE:
2309 break;
2310 case XML_ATTRIBUTE_REQUIRED:
2311 xmlBufferWriteChar(buf, " #REQUIRED");
2312 break;
2313 case XML_ATTRIBUTE_IMPLIED:
2314 xmlBufferWriteChar(buf, " #IMPLIED");
2315 break;
2316 case XML_ATTRIBUTE_FIXED:
2317 xmlBufferWriteChar(buf, " #FIXED");
2318 break;
2319 default:
2320 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
2321 "Internal: ATTRIBUTE struct corrupted invalid def\n",
2322 NULL);
2323 }
2324 if (attr->defaultValue != NULL) {
2325 xmlBufferWriteChar(buf, " ");
2326 xmlBufferWriteQuotedString(buf, attr->defaultValue);
2327 }
2328 xmlBufferWriteChar(buf, ">\n");
2329 }
2330
2331 /**
2332 * xmlDumpAttributeDeclScan:
2333 * @attr: An attribute declaration
2334 * @buf: the XML buffer output
2335 *
2336 * This is used with the hash scan function - just reverses arguments
2337 */
2338 static void
xmlDumpAttributeDeclScan(xmlAttributePtr attr,xmlBufferPtr buf)2339 xmlDumpAttributeDeclScan(xmlAttributePtr attr, xmlBufferPtr buf) {
2340 xmlDumpAttributeDecl(buf, attr);
2341 }
2342
2343 /**
2344 * xmlDumpAttributeTable:
2345 * @buf: the XML buffer output
2346 * @table: An attribute table
2347 *
2348 * This will dump the content of the attribute table as an XML DTD definition
2349 */
2350 void
xmlDumpAttributeTable(xmlBufferPtr buf,xmlAttributeTablePtr table)2351 xmlDumpAttributeTable(xmlBufferPtr buf, xmlAttributeTablePtr table) {
2352 if ((buf == NULL) || (table == NULL))
2353 return;
2354 xmlHashScan(table, (xmlHashScanner) xmlDumpAttributeDeclScan, buf);
2355 }
2356 #endif /* LIBXML_OUTPUT_ENABLED */
2357
2358 /************************************************************************
2359 * *
2360 * NOTATIONs *
2361 * *
2362 ************************************************************************/
2363 /**
2364 * xmlFreeNotation:
2365 * @not: A notation
2366 *
2367 * Deallocate the memory used by an notation definition
2368 */
2369 static void
xmlFreeNotation(xmlNotationPtr nota)2370 xmlFreeNotation(xmlNotationPtr nota) {
2371 if (nota == NULL) return;
2372 if (nota->name != NULL)
2373 xmlFree((xmlChar *) nota->name);
2374 if (nota->PublicID != NULL)
2375 xmlFree((xmlChar *) nota->PublicID);
2376 if (nota->SystemID != NULL)
2377 xmlFree((xmlChar *) nota->SystemID);
2378 xmlFree(nota);
2379 }
2380
2381
2382 /**
2383 * xmlAddNotationDecl:
2384 * @dtd: pointer to the DTD
2385 * @ctxt: the validation context
2386 * @name: the entity name
2387 * @PublicID: the public identifier or NULL
2388 * @SystemID: the system identifier or NULL
2389 *
2390 * Register a new notation declaration
2391 *
2392 * Returns NULL if not, otherwise the entity
2393 */
2394 xmlNotationPtr
xmlAddNotationDecl(xmlValidCtxtPtr ctxt,xmlDtdPtr dtd,const xmlChar * name,const xmlChar * PublicID,const xmlChar * SystemID)2395 xmlAddNotationDecl(xmlValidCtxtPtr ctxt, xmlDtdPtr dtd,
2396 const xmlChar *name,
2397 const xmlChar *PublicID, const xmlChar *SystemID) {
2398 xmlNotationPtr ret;
2399 xmlNotationTablePtr table;
2400
2401 if (dtd == NULL) {
2402 return(NULL);
2403 }
2404 if (name == NULL) {
2405 return(NULL);
2406 }
2407 if ((PublicID == NULL) && (SystemID == NULL)) {
2408 return(NULL);
2409 }
2410
2411 /*
2412 * Create the Notation table if needed.
2413 */
2414 table = (xmlNotationTablePtr) dtd->notations;
2415 if (table == NULL) {
2416 xmlDictPtr dict = NULL;
2417 if (dtd->doc != NULL)
2418 dict = dtd->doc->dict;
2419
2420 dtd->notations = table = xmlHashCreateDict(0, dict);
2421 }
2422 if (table == NULL) {
2423 xmlVErrMemory(ctxt,
2424 "xmlAddNotationDecl: Table creation failed!\n");
2425 return(NULL);
2426 }
2427
2428 ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2429 if (ret == NULL) {
2430 xmlVErrMemory(ctxt, "malloc failed");
2431 return(NULL);
2432 }
2433 memset(ret, 0, sizeof(xmlNotation));
2434
2435 /*
2436 * fill the structure.
2437 */
2438 ret->name = xmlStrdup(name);
2439 if (SystemID != NULL)
2440 ret->SystemID = xmlStrdup(SystemID);
2441 if (PublicID != NULL)
2442 ret->PublicID = xmlStrdup(PublicID);
2443
2444 /*
2445 * Validity Check:
2446 * Check the DTD for previous declarations of the ATTLIST
2447 */
2448 if (xmlHashAddEntry(table, name, ret)) {
2449 #ifdef LIBXML_VALID_ENABLED
2450 xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
2451 "xmlAddNotationDecl: %s already defined\n",
2452 (const char *) name);
2453 #endif /* LIBXML_VALID_ENABLED */
2454 xmlFreeNotation(ret);
2455 return(NULL);
2456 }
2457 return(ret);
2458 }
2459
2460 /**
2461 * xmlFreeNotationTable:
2462 * @table: An notation table
2463 *
2464 * Deallocate the memory used by an entities hash table.
2465 */
2466 void
xmlFreeNotationTable(xmlNotationTablePtr table)2467 xmlFreeNotationTable(xmlNotationTablePtr table) {
2468 xmlHashFree(table, (xmlHashDeallocator) xmlFreeNotation);
2469 }
2470
2471 #ifdef LIBXML_TREE_ENABLED
2472 /**
2473 * xmlCopyNotation:
2474 * @nota: A notation
2475 *
2476 * Build a copy of a notation.
2477 *
2478 * Returns the new xmlNotationPtr or NULL in case of error.
2479 */
2480 static xmlNotationPtr
xmlCopyNotation(xmlNotationPtr nota)2481 xmlCopyNotation(xmlNotationPtr nota) {
2482 xmlNotationPtr cur;
2483
2484 cur = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
2485 if (cur == NULL) {
2486 xmlVErrMemory(NULL, "malloc failed");
2487 return(NULL);
2488 }
2489 if (nota->name != NULL)
2490 cur->name = xmlStrdup(nota->name);
2491 else
2492 cur->name = NULL;
2493 if (nota->PublicID != NULL)
2494 cur->PublicID = xmlStrdup(nota->PublicID);
2495 else
2496 cur->PublicID = NULL;
2497 if (nota->SystemID != NULL)
2498 cur->SystemID = xmlStrdup(nota->SystemID);
2499 else
2500 cur->SystemID = NULL;
2501 return(cur);
2502 }
2503
2504 /**
2505 * xmlCopyNotationTable:
2506 * @table: A notation table
2507 *
2508 * Build a copy of a notation table.
2509 *
2510 * Returns the new xmlNotationTablePtr or NULL in case of error.
2511 */
2512 xmlNotationTablePtr
xmlCopyNotationTable(xmlNotationTablePtr table)2513 xmlCopyNotationTable(xmlNotationTablePtr table) {
2514 return((xmlNotationTablePtr) xmlHashCopy(table,
2515 (xmlHashCopier) xmlCopyNotation));
2516 }
2517 #endif /* LIBXML_TREE_ENABLED */
2518
2519 #ifdef LIBXML_OUTPUT_ENABLED
2520 /**
2521 * xmlDumpNotationDecl:
2522 * @buf: the XML buffer output
2523 * @nota: A notation declaration
2524 *
2525 * This will dump the content the notation declaration as an XML DTD definition
2526 */
2527 void
xmlDumpNotationDecl(xmlBufferPtr buf,xmlNotationPtr nota)2528 xmlDumpNotationDecl(xmlBufferPtr buf, xmlNotationPtr nota) {
2529 if ((buf == NULL) || (nota == NULL))
2530 return;
2531 xmlBufferWriteChar(buf, "<!NOTATION ");
2532 xmlBufferWriteCHAR(buf, nota->name);
2533 if (nota->PublicID != NULL) {
2534 xmlBufferWriteChar(buf, " PUBLIC ");
2535 xmlBufferWriteQuotedString(buf, nota->PublicID);
2536 if (nota->SystemID != NULL) {
2537 xmlBufferWriteChar(buf, " ");
2538 xmlBufferWriteQuotedString(buf, nota->SystemID);
2539 }
2540 } else {
2541 xmlBufferWriteChar(buf, " SYSTEM ");
2542 xmlBufferWriteQuotedString(buf, nota->SystemID);
2543 }
2544 xmlBufferWriteChar(buf, " >\n");
2545 }
2546
2547 /**
2548 * xmlDumpNotationDeclScan:
2549 * @nota: A notation declaration
2550 * @buf: the XML buffer output
2551 *
2552 * This is called with the hash scan function, and just reverses args
2553 */
2554 static void
xmlDumpNotationDeclScan(xmlNotationPtr nota,xmlBufferPtr buf)2555 xmlDumpNotationDeclScan(xmlNotationPtr nota, xmlBufferPtr buf) {
2556 xmlDumpNotationDecl(buf, nota);
2557 }
2558
2559 /**
2560 * xmlDumpNotationTable:
2561 * @buf: the XML buffer output
2562 * @table: A notation table
2563 *
2564 * This will dump the content of the notation table as an XML DTD definition
2565 */
2566 void
xmlDumpNotationTable(xmlBufferPtr buf,xmlNotationTablePtr table)2567 xmlDumpNotationTable(xmlBufferPtr buf, xmlNotationTablePtr table) {
2568 if ((buf == NULL) || (table == NULL))
2569 return;
2570 xmlHashScan(table, (xmlHashScanner) xmlDumpNotationDeclScan, buf);
2571 }
2572 #endif /* LIBXML_OUTPUT_ENABLED */
2573
2574 /************************************************************************
2575 * *
2576 * IDs *
2577 * *
2578 ************************************************************************/
2579 /**
2580 * DICT_FREE:
2581 * @str: a string
2582 *
2583 * Free a string if it is not owned by the "dict" dictionnary in the
2584 * current scope
2585 */
2586 #define DICT_FREE(str) \
2587 if ((str) && ((!dict) || \
2588 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2589 xmlFree((char *)(str));
2590
2591 /**
2592 * xmlFreeID:
2593 * @not: A id
2594 *
2595 * Deallocate the memory used by an id definition
2596 */
2597 static void
xmlFreeID(xmlIDPtr id)2598 xmlFreeID(xmlIDPtr id) {
2599 xmlDictPtr dict = NULL;
2600
2601 if (id == NULL) return;
2602
2603 if (id->doc != NULL)
2604 dict = id->doc->dict;
2605
2606 if (id->value != NULL)
2607 DICT_FREE(id->value)
2608 if (id->name != NULL)
2609 DICT_FREE(id->name)
2610 xmlFree(id);
2611 }
2612
2613
2614 /**
2615 * xmlAddID:
2616 * @ctxt: the validation context
2617 * @doc: pointer to the document
2618 * @value: the value name
2619 * @attr: the attribute holding the ID
2620 *
2621 * Register a new id declaration
2622 *
2623 * Returns NULL if not, otherwise the new xmlIDPtr
2624 */
2625 xmlIDPtr
xmlAddID(xmlValidCtxtPtr ctxt,xmlDocPtr doc,const xmlChar * value,xmlAttrPtr attr)2626 xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2627 xmlAttrPtr attr) {
2628 xmlIDPtr ret;
2629 xmlIDTablePtr table;
2630
2631 if (doc == NULL) {
2632 return(NULL);
2633 }
2634 if (value == NULL) {
2635 return(NULL);
2636 }
2637 if (attr == NULL) {
2638 return(NULL);
2639 }
2640
2641 /*
2642 * Create the ID table if needed.
2643 */
2644 table = (xmlIDTablePtr) doc->ids;
2645 if (table == NULL) {
2646 doc->ids = table = xmlHashCreateDict(0, doc->dict);
2647 }
2648 if (table == NULL) {
2649 xmlVErrMemory(ctxt,
2650 "xmlAddID: Table creation failed!\n");
2651 return(NULL);
2652 }
2653
2654 ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2655 if (ret == NULL) {
2656 xmlVErrMemory(ctxt, "malloc failed");
2657 return(NULL);
2658 }
2659
2660 /*
2661 * fill the structure.
2662 */
2663 ret->value = xmlStrdup(value);
2664 ret->doc = doc;
2665 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2666 /*
2667 * Operating in streaming mode, attr is gonna disapear
2668 */
2669 if (doc->dict != NULL)
2670 ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2671 else
2672 ret->name = xmlStrdup(attr->name);
2673 ret->attr = NULL;
2674 } else {
2675 ret->attr = attr;
2676 ret->name = NULL;
2677 }
2678 ret->lineno = xmlGetLineNo(attr->parent);
2679
2680 if (xmlHashAddEntry(table, value, ret) < 0) {
2681 #ifdef LIBXML_VALID_ENABLED
2682 /*
2683 * The id is already defined in this DTD.
2684 */
2685 if ((ctxt != NULL) && (ctxt->error != NULL)) {
2686 xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2687 "ID %s already defined\n",
2688 value, NULL, NULL);
2689 }
2690 #endif /* LIBXML_VALID_ENABLED */
2691 xmlFreeID(ret);
2692 return(NULL);
2693 }
2694 if (attr != NULL)
2695 attr->atype = XML_ATTRIBUTE_ID;
2696 return(ret);
2697 }
2698
2699 /**
2700 * xmlFreeIDTable:
2701 * @table: An id table
2702 *
2703 * Deallocate the memory used by an ID hash table.
2704 */
2705 void
xmlFreeIDTable(xmlIDTablePtr table)2706 xmlFreeIDTable(xmlIDTablePtr table) {
2707 xmlHashFree(table, (xmlHashDeallocator) xmlFreeID);
2708 }
2709
2710 /**
2711 * xmlIsID:
2712 * @doc: the document
2713 * @elem: the element carrying the attribute
2714 * @attr: the attribute
2715 *
2716 * Determine whether an attribute is of type ID. In case we have DTD(s)
2717 * then this is done if DTD loading has been requested. In the case
2718 * of HTML documents parsed with the HTML parser, then ID detection is
2719 * done systematically.
2720 *
2721 * Returns 0 or 1 depending on the lookup result
2722 */
2723 int
xmlIsID(xmlDocPtr doc,xmlNodePtr elem,xmlAttrPtr attr)2724 xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
2725 if ((attr == NULL) || (attr->name == NULL)) return(0);
2726 if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2727 (!strcmp((char *) attr->name, "id")) &&
2728 (!strcmp((char *) attr->ns->prefix, "xml")))
2729 return(1);
2730 if (doc == NULL) return(0);
2731 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
2732 return(0);
2733 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2734 if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2735 ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2736 ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
2737 return(1);
2738 return(0);
2739 } else if (elem == NULL) {
2740 return(0);
2741 } else {
2742 xmlAttributePtr attrDecl = NULL;
2743
2744 xmlChar felem[50], fattr[50];
2745 xmlChar *fullelemname, *fullattrname;
2746
2747 fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2748 xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2749 (xmlChar *)elem->name;
2750
2751 fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2752 xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2753 (xmlChar *)attr->name;
2754
2755 if (fullelemname != NULL && fullattrname != NULL) {
2756 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2757 fullattrname);
2758 if ((attrDecl == NULL) && (doc->extSubset != NULL))
2759 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2760 fullattrname);
2761 }
2762
2763 if ((fullattrname != fattr) && (fullattrname != attr->name))
2764 xmlFree(fullattrname);
2765 if ((fullelemname != felem) && (fullelemname != elem->name))
2766 xmlFree(fullelemname);
2767
2768 if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2769 return(1);
2770 }
2771 return(0);
2772 }
2773
2774 /**
2775 * xmlRemoveID:
2776 * @doc: the document
2777 * @attr: the attribute
2778 *
2779 * Remove the given attribute from the ID table maintained internally.
2780 *
2781 * Returns -1 if the lookup failed and 0 otherwise
2782 */
2783 int
xmlRemoveID(xmlDocPtr doc,xmlAttrPtr attr)2784 xmlRemoveID(xmlDocPtr doc, xmlAttrPtr attr) {
2785 xmlIDTablePtr table;
2786 xmlIDPtr id;
2787 xmlChar *ID;
2788
2789 if (doc == NULL) return(-1);
2790 if (attr == NULL) return(-1);
2791 table = (xmlIDTablePtr) doc->ids;
2792 if (table == NULL)
2793 return(-1);
2794
2795 if (attr == NULL)
2796 return(-1);
2797 ID = xmlNodeListGetString(doc, attr->children, 1);
2798 if (ID == NULL)
2799 return(-1);
2800 id = xmlHashLookup(table, ID);
2801 if (id == NULL || id->attr != attr) {
2802 xmlFree(ID);
2803 return(-1);
2804 }
2805 xmlHashRemoveEntry(table, ID, (xmlHashDeallocator) xmlFreeID);
2806 xmlFree(ID);
2807 attr->atype = 0;
2808 return(0);
2809 }
2810
2811 /**
2812 * xmlGetID:
2813 * @doc: pointer to the document
2814 * @ID: the ID value
2815 *
2816 * Search the attribute declaring the given ID
2817 *
2818 * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2819 */
2820 xmlAttrPtr
xmlGetID(xmlDocPtr doc,const xmlChar * ID)2821 xmlGetID(xmlDocPtr doc, const xmlChar *ID) {
2822 xmlIDTablePtr table;
2823 xmlIDPtr id;
2824
2825 if (doc == NULL) {
2826 return(NULL);
2827 }
2828
2829 if (ID == NULL) {
2830 return(NULL);
2831 }
2832
2833 table = (xmlIDTablePtr) doc->ids;
2834 if (table == NULL)
2835 return(NULL);
2836
2837 id = xmlHashLookup(table, ID);
2838 if (id == NULL)
2839 return(NULL);
2840 if (id->attr == NULL) {
2841 /*
2842 * We are operating on a stream, return a well known reference
2843 * since the attribute node doesn't exist anymore
2844 */
2845 return((xmlAttrPtr) doc);
2846 }
2847 return(id->attr);
2848 }
2849
2850 /************************************************************************
2851 * *
2852 * Refs *
2853 * *
2854 ************************************************************************/
2855 typedef struct xmlRemoveMemo_t
2856 {
2857 xmlListPtr l;
2858 xmlAttrPtr ap;
2859 } xmlRemoveMemo;
2860
2861 typedef xmlRemoveMemo *xmlRemoveMemoPtr;
2862
2863 typedef struct xmlValidateMemo_t
2864 {
2865 xmlValidCtxtPtr ctxt;
2866 const xmlChar *name;
2867 } xmlValidateMemo;
2868
2869 typedef xmlValidateMemo *xmlValidateMemoPtr;
2870
2871 /**
2872 * xmlFreeRef:
2873 * @lk: A list link
2874 *
2875 * Deallocate the memory used by a ref definition
2876 */
2877 static void
xmlFreeRef(xmlLinkPtr lk)2878 xmlFreeRef(xmlLinkPtr lk) {
2879 xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
2880 if (ref == NULL) return;
2881 if (ref->value != NULL)
2882 xmlFree((xmlChar *)ref->value);
2883 if (ref->name != NULL)
2884 xmlFree((xmlChar *)ref->name);
2885 xmlFree(ref);
2886 }
2887
2888 /**
2889 * xmlFreeRefList:
2890 * @list_ref: A list of references.
2891 *
2892 * Deallocate the memory used by a list of references
2893 */
2894 static void
xmlFreeRefList(xmlListPtr list_ref)2895 xmlFreeRefList(xmlListPtr list_ref) {
2896 if (list_ref == NULL) return;
2897 xmlListDelete(list_ref);
2898 }
2899
2900 /**
2901 * xmlWalkRemoveRef:
2902 * @data: Contents of current link
2903 * @user: Value supplied by the user
2904 *
2905 * Returns 0 to abort the walk or 1 to continue
2906 */
2907 static int
xmlWalkRemoveRef(const void * data,const void * user)2908 xmlWalkRemoveRef(const void *data, const void *user)
2909 {
2910 xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2911 xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2912 xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2913
2914 if (attr0 == attr1) { /* Matched: remove and terminate walk */
2915 xmlListRemoveFirst(ref_list, (void *)data);
2916 return 0;
2917 }
2918 return 1;
2919 }
2920
2921 /**
2922 * xmlDummyCompare
2923 * @data0: Value supplied by the user
2924 * @data1: Value supplied by the user
2925 *
2926 * Do nothing, return 0. Used to create unordered lists.
2927 */
2928 static int
xmlDummyCompare(const void * data0 ATTRIBUTE_UNUSED,const void * data1 ATTRIBUTE_UNUSED)2929 xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED,
2930 const void *data1 ATTRIBUTE_UNUSED)
2931 {
2932 return (0);
2933 }
2934
2935 /**
2936 * xmlAddRef:
2937 * @ctxt: the validation context
2938 * @doc: pointer to the document
2939 * @value: the value name
2940 * @attr: the attribute holding the Ref
2941 *
2942 * Register a new ref declaration
2943 *
2944 * Returns NULL if not, otherwise the new xmlRefPtr
2945 */
2946 xmlRefPtr
xmlAddRef(xmlValidCtxtPtr ctxt,xmlDocPtr doc,const xmlChar * value,xmlAttrPtr attr)2947 xmlAddRef(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value,
2948 xmlAttrPtr attr) {
2949 xmlRefPtr ret;
2950 xmlRefTablePtr table;
2951 xmlListPtr ref_list;
2952
2953 if (doc == NULL) {
2954 return(NULL);
2955 }
2956 if (value == NULL) {
2957 return(NULL);
2958 }
2959 if (attr == NULL) {
2960 return(NULL);
2961 }
2962
2963 /*
2964 * Create the Ref table if needed.
2965 */
2966 table = (xmlRefTablePtr) doc->refs;
2967 if (table == NULL) {
2968 doc->refs = table = xmlHashCreateDict(0, doc->dict);
2969 }
2970 if (table == NULL) {
2971 xmlVErrMemory(ctxt,
2972 "xmlAddRef: Table creation failed!\n");
2973 return(NULL);
2974 }
2975
2976 ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
2977 if (ret == NULL) {
2978 xmlVErrMemory(ctxt, "malloc failed");
2979 return(NULL);
2980 }
2981
2982 /*
2983 * fill the structure.
2984 */
2985 ret->value = xmlStrdup(value);
2986 if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
2987 /*
2988 * Operating in streaming mode, attr is gonna disapear
2989 */
2990 ret->name = xmlStrdup(attr->name);
2991 ret->attr = NULL;
2992 } else {
2993 ret->name = NULL;
2994 ret->attr = attr;
2995 }
2996 ret->lineno = xmlGetLineNo(attr->parent);
2997
2998 /* To add a reference :-
2999 * References are maintained as a list of references,
3000 * Lookup the entry, if no entry create new nodelist
3001 * Add the owning node to the NodeList
3002 * Return the ref
3003 */
3004
3005 if (NULL == (ref_list = xmlHashLookup(table, value))) {
3006 if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
3007 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3008 "xmlAddRef: Reference list creation failed!\n",
3009 NULL);
3010 goto failed;
3011 }
3012 if (xmlHashAddEntry(table, value, ref_list) < 0) {
3013 xmlListDelete(ref_list);
3014 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3015 "xmlAddRef: Reference list insertion failed!\n",
3016 NULL);
3017 goto failed;
3018 }
3019 }
3020 if (xmlListAppend(ref_list, ret) != 0) {
3021 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3022 "xmlAddRef: Reference list insertion failed!\n",
3023 NULL);
3024 goto failed;
3025 }
3026 return(ret);
3027 failed:
3028 if (ret != NULL) {
3029 if (ret->value != NULL)
3030 xmlFree((char *)ret->value);
3031 if (ret->name != NULL)
3032 xmlFree((char *)ret->name);
3033 xmlFree(ret);
3034 }
3035 return(NULL);
3036 }
3037
3038 /**
3039 * xmlFreeRefTable:
3040 * @table: An ref table
3041 *
3042 * Deallocate the memory used by an Ref hash table.
3043 */
3044 void
xmlFreeRefTable(xmlRefTablePtr table)3045 xmlFreeRefTable(xmlRefTablePtr table) {
3046 xmlHashFree(table, (xmlHashDeallocator) xmlFreeRefList);
3047 }
3048
3049 /**
3050 * xmlIsRef:
3051 * @doc: the document
3052 * @elem: the element carrying the attribute
3053 * @attr: the attribute
3054 *
3055 * Determine whether an attribute is of type Ref. In case we have DTD(s)
3056 * then this is simple, otherwise we use an heuristic: name Ref (upper
3057 * or lowercase).
3058 *
3059 * Returns 0 or 1 depending on the lookup result
3060 */
3061 int
xmlIsRef(xmlDocPtr doc,xmlNodePtr elem,xmlAttrPtr attr)3062 xmlIsRef(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr) {
3063 if (attr == NULL)
3064 return(0);
3065 if (doc == NULL) {
3066 doc = attr->doc;
3067 if (doc == NULL) return(0);
3068 }
3069
3070 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3071 return(0);
3072 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3073 /* TODO @@@ */
3074 return(0);
3075 } else {
3076 xmlAttributePtr attrDecl;
3077
3078 if (elem == NULL) return(0);
3079 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3080 if ((attrDecl == NULL) && (doc->extSubset != NULL))
3081 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3082 elem->name, attr->name);
3083
3084 if ((attrDecl != NULL) &&
3085 (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3086 attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3087 return(1);
3088 }
3089 return(0);
3090 }
3091
3092 /**
3093 * xmlRemoveRef:
3094 * @doc: the document
3095 * @attr: the attribute
3096 *
3097 * Remove the given attribute from the Ref table maintained internally.
3098 *
3099 * Returns -1 if the lookup failed and 0 otherwise
3100 */
3101 int
xmlRemoveRef(xmlDocPtr doc,xmlAttrPtr attr)3102 xmlRemoveRef(xmlDocPtr doc, xmlAttrPtr attr) {
3103 xmlListPtr ref_list;
3104 xmlRefTablePtr table;
3105 xmlChar *ID;
3106 xmlRemoveMemo target;
3107
3108 if (doc == NULL) return(-1);
3109 if (attr == NULL) return(-1);
3110 table = (xmlRefTablePtr) doc->refs;
3111 if (table == NULL)
3112 return(-1);
3113
3114 if (attr == NULL)
3115 return(-1);
3116 ID = xmlNodeListGetString(doc, attr->children, 1);
3117 if (ID == NULL)
3118 return(-1);
3119 ref_list = xmlHashLookup(table, ID);
3120
3121 if(ref_list == NULL) {
3122 xmlFree(ID);
3123 return (-1);
3124 }
3125 /* At this point, ref_list refers to a list of references which
3126 * have the same key as the supplied attr. Our list of references
3127 * is ordered by reference address and we don't have that information
3128 * here to use when removing. We'll have to walk the list and
3129 * check for a matching attribute, when we find one stop the walk
3130 * and remove the entry.
3131 * The list is ordered by reference, so that means we don't have the
3132 * key. Passing the list and the reference to the walker means we
3133 * will have enough data to be able to remove the entry.
3134 */
3135 target.l = ref_list;
3136 target.ap = attr;
3137
3138 /* Remove the supplied attr from our list */
3139 xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3140
3141 /*If the list is empty then remove the list entry in the hash */
3142 if (xmlListEmpty(ref_list))
3143 xmlHashUpdateEntry(table, ID, NULL, (xmlHashDeallocator)
3144 xmlFreeRefList);
3145 xmlFree(ID);
3146 return(0);
3147 }
3148
3149 /**
3150 * xmlGetRefs:
3151 * @doc: pointer to the document
3152 * @ID: the ID value
3153 *
3154 * Find the set of references for the supplied ID.
3155 *
3156 * Returns NULL if not found, otherwise node set for the ID.
3157 */
3158 xmlListPtr
xmlGetRefs(xmlDocPtr doc,const xmlChar * ID)3159 xmlGetRefs(xmlDocPtr doc, const xmlChar *ID) {
3160 xmlRefTablePtr table;
3161
3162 if (doc == NULL) {
3163 return(NULL);
3164 }
3165
3166 if (ID == NULL) {
3167 return(NULL);
3168 }
3169
3170 table = (xmlRefTablePtr) doc->refs;
3171 if (table == NULL)
3172 return(NULL);
3173
3174 return (xmlHashLookup(table, ID));
3175 }
3176
3177 /************************************************************************
3178 * *
3179 * Routines for validity checking *
3180 * *
3181 ************************************************************************/
3182
3183 /**
3184 * xmlGetDtdElementDesc:
3185 * @dtd: a pointer to the DtD to search
3186 * @name: the element name
3187 *
3188 * Search the DTD for the description of this element
3189 *
3190 * returns the xmlElementPtr if found or NULL
3191 */
3192
3193 xmlElementPtr
xmlGetDtdElementDesc(xmlDtdPtr dtd,const xmlChar * name)3194 xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name) {
3195 xmlElementTablePtr table;
3196 xmlElementPtr cur;
3197 xmlChar *uqname = NULL, *prefix = NULL;
3198
3199 if ((dtd == NULL) || (name == NULL)) return(NULL);
3200 if (dtd->elements == NULL)
3201 return(NULL);
3202 table = (xmlElementTablePtr) dtd->elements;
3203
3204 uqname = xmlSplitQName2(name, &prefix);
3205 if (uqname != NULL)
3206 name = uqname;
3207 cur = xmlHashLookup2(table, name, prefix);
3208 if (prefix != NULL) xmlFree(prefix);
3209 if (uqname != NULL) xmlFree(uqname);
3210 return(cur);
3211 }
3212 /**
3213 * xmlGetDtdElementDesc2:
3214 * @dtd: a pointer to the DtD to search
3215 * @name: the element name
3216 * @create: create an empty description if not found
3217 *
3218 * Search the DTD for the description of this element
3219 *
3220 * returns the xmlElementPtr if found or NULL
3221 */
3222
3223 static xmlElementPtr
xmlGetDtdElementDesc2(xmlDtdPtr dtd,const xmlChar * name,int create)3224 xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create) {
3225 xmlElementTablePtr table;
3226 xmlElementPtr cur;
3227 xmlChar *uqname = NULL, *prefix = NULL;
3228
3229 if (dtd == NULL) return(NULL);
3230 if (dtd->elements == NULL) {
3231 xmlDictPtr dict = NULL;
3232
3233 if (dtd->doc != NULL)
3234 dict = dtd->doc->dict;
3235
3236 if (!create)
3237 return(NULL);
3238 /*
3239 * Create the Element table if needed.
3240 */
3241 table = (xmlElementTablePtr) dtd->elements;
3242 if (table == NULL) {
3243 table = xmlHashCreateDict(0, dict);
3244 dtd->elements = (void *) table;
3245 }
3246 if (table == NULL) {
3247 xmlVErrMemory(NULL, "element table allocation failed");
3248 return(NULL);
3249 }
3250 }
3251 table = (xmlElementTablePtr) dtd->elements;
3252
3253 uqname = xmlSplitQName2(name, &prefix);
3254 if (uqname != NULL)
3255 name = uqname;
3256 cur = xmlHashLookup2(table, name, prefix);
3257 if ((cur == NULL) && (create)) {
3258 cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
3259 if (cur == NULL) {
3260 xmlVErrMemory(NULL, "malloc failed");
3261 return(NULL);
3262 }
3263 memset(cur, 0, sizeof(xmlElement));
3264 cur->type = XML_ELEMENT_DECL;
3265
3266 /*
3267 * fill the structure.
3268 */
3269 cur->name = xmlStrdup(name);
3270 cur->prefix = xmlStrdup(prefix);
3271 cur->etype = XML_ELEMENT_TYPE_UNDEFINED;
3272
3273 xmlHashAddEntry2(table, name, prefix, cur);
3274 }
3275 if (prefix != NULL) xmlFree(prefix);
3276 if (uqname != NULL) xmlFree(uqname);
3277 return(cur);
3278 }
3279
3280 /**
3281 * xmlGetDtdQElementDesc:
3282 * @dtd: a pointer to the DtD to search
3283 * @name: the element name
3284 * @prefix: the element namespace prefix
3285 *
3286 * Search the DTD for the description of this element
3287 *
3288 * returns the xmlElementPtr if found or NULL
3289 */
3290
3291 xmlElementPtr
xmlGetDtdQElementDesc(xmlDtdPtr dtd,const xmlChar * name,const xmlChar * prefix)3292 xmlGetDtdQElementDesc(xmlDtdPtr dtd, const xmlChar *name,
3293 const xmlChar *prefix) {
3294 xmlElementTablePtr table;
3295
3296 if (dtd == NULL) return(NULL);
3297 if (dtd->elements == NULL) return(NULL);
3298 table = (xmlElementTablePtr) dtd->elements;
3299
3300 return(xmlHashLookup2(table, name, prefix));
3301 }
3302
3303 /**
3304 * xmlGetDtdAttrDesc:
3305 * @dtd: a pointer to the DtD to search
3306 * @elem: the element name
3307 * @name: the attribute name
3308 *
3309 * Search the DTD for the description of this attribute on
3310 * this element.
3311 *
3312 * returns the xmlAttributePtr if found or NULL
3313 */
3314
3315 xmlAttributePtr
xmlGetDtdAttrDesc(xmlDtdPtr dtd,const xmlChar * elem,const xmlChar * name)3316 xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name) {
3317 xmlAttributeTablePtr table;
3318 xmlAttributePtr cur;
3319 xmlChar *uqname = NULL, *prefix = NULL;
3320
3321 if (dtd == NULL) return(NULL);
3322 if (dtd->attributes == NULL) return(NULL);
3323
3324 table = (xmlAttributeTablePtr) dtd->attributes;
3325 if (table == NULL)
3326 return(NULL);
3327
3328 uqname = xmlSplitQName2(name, &prefix);
3329
3330 if (uqname != NULL) {
3331 cur = xmlHashLookup3(table, uqname, prefix, elem);
3332 if (prefix != NULL) xmlFree(prefix);
3333 if (uqname != NULL) xmlFree(uqname);
3334 } else
3335 cur = xmlHashLookup3(table, name, NULL, elem);
3336 return(cur);
3337 }
3338
3339 /**
3340 * xmlGetDtdQAttrDesc:
3341 * @dtd: a pointer to the DtD to search
3342 * @elem: the element name
3343 * @name: the attribute name
3344 * @prefix: the attribute namespace prefix
3345 *
3346 * Search the DTD for the description of this qualified attribute on
3347 * this element.
3348 *
3349 * returns the xmlAttributePtr if found or NULL
3350 */
3351
3352 xmlAttributePtr
xmlGetDtdQAttrDesc(xmlDtdPtr dtd,const xmlChar * elem,const xmlChar * name,const xmlChar * prefix)3353 xmlGetDtdQAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name,
3354 const xmlChar *prefix) {
3355 xmlAttributeTablePtr table;
3356
3357 if (dtd == NULL) return(NULL);
3358 if (dtd->attributes == NULL) return(NULL);
3359 table = (xmlAttributeTablePtr) dtd->attributes;
3360
3361 return(xmlHashLookup3(table, name, prefix, elem));
3362 }
3363
3364 /**
3365 * xmlGetDtdNotationDesc:
3366 * @dtd: a pointer to the DtD to search
3367 * @name: the notation name
3368 *
3369 * Search the DTD for the description of this notation
3370 *
3371 * returns the xmlNotationPtr if found or NULL
3372 */
3373
3374 xmlNotationPtr
xmlGetDtdNotationDesc(xmlDtdPtr dtd,const xmlChar * name)3375 xmlGetDtdNotationDesc(xmlDtdPtr dtd, const xmlChar *name) {
3376 xmlNotationTablePtr table;
3377
3378 if (dtd == NULL) return(NULL);
3379 if (dtd->notations == NULL) return(NULL);
3380 table = (xmlNotationTablePtr) dtd->notations;
3381
3382 return(xmlHashLookup(table, name));
3383 }
3384
3385 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3386 /**
3387 * xmlValidateNotationUse:
3388 * @ctxt: the validation context
3389 * @doc: the document
3390 * @notationName: the notation name to check
3391 *
3392 * Validate that the given name match a notation declaration.
3393 * - [ VC: Notation Declared ]
3394 *
3395 * returns 1 if valid or 0 otherwise
3396 */
3397
3398 int
xmlValidateNotationUse(xmlValidCtxtPtr ctxt,xmlDocPtr doc,const xmlChar * notationName)3399 xmlValidateNotationUse(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3400 const xmlChar *notationName) {
3401 xmlNotationPtr notaDecl;
3402 if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
3403
3404 notaDecl = xmlGetDtdNotationDesc(doc->intSubset, notationName);
3405 if ((notaDecl == NULL) && (doc->extSubset != NULL))
3406 notaDecl = xmlGetDtdNotationDesc(doc->extSubset, notationName);
3407
3408 if ((notaDecl == NULL) && (ctxt != NULL)) {
3409 xmlErrValidNode(ctxt, (xmlNodePtr) doc, XML_DTD_UNKNOWN_NOTATION,
3410 "NOTATION %s is not declared\n",
3411 notationName, NULL, NULL);
3412 return(0);
3413 }
3414 return(1);
3415 }
3416 #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
3417
3418 /**
3419 * xmlIsMixedElement:
3420 * @doc: the document
3421 * @name: the element name
3422 *
3423 * Search in the DtDs whether an element accept Mixed content (or ANY)
3424 * basically if it is supposed to accept text childs
3425 *
3426 * returns 0 if no, 1 if yes, and -1 if no element description is available
3427 */
3428
3429 int
xmlIsMixedElement(xmlDocPtr doc,const xmlChar * name)3430 xmlIsMixedElement(xmlDocPtr doc, const xmlChar *name) {
3431 xmlElementPtr elemDecl;
3432
3433 if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
3434
3435 elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
3436 if ((elemDecl == NULL) && (doc->extSubset != NULL))
3437 elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
3438 if (elemDecl == NULL) return(-1);
3439 switch (elemDecl->etype) {
3440 case XML_ELEMENT_TYPE_UNDEFINED:
3441 return(-1);
3442 case XML_ELEMENT_TYPE_ELEMENT:
3443 return(0);
3444 case XML_ELEMENT_TYPE_EMPTY:
3445 /*
3446 * return 1 for EMPTY since we want VC error to pop up
3447 * on <empty> </empty> for example
3448 */
3449 case XML_ELEMENT_TYPE_ANY:
3450 case XML_ELEMENT_TYPE_MIXED:
3451 return(1);
3452 }
3453 return(1);
3454 }
3455
3456 #ifdef LIBXML_VALID_ENABLED
3457
3458 static int
xmlIsDocNameStartChar(xmlDocPtr doc,int c)3459 xmlIsDocNameStartChar(xmlDocPtr doc, int c) {
3460 if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3461 /*
3462 * Use the new checks of production [4] [4a] amd [5] of the
3463 * Update 5 of XML-1.0
3464 */
3465 if (((c >= 'a') && (c <= 'z')) ||
3466 ((c >= 'A') && (c <= 'Z')) ||
3467 (c == '_') || (c == ':') ||
3468 ((c >= 0xC0) && (c <= 0xD6)) ||
3469 ((c >= 0xD8) && (c <= 0xF6)) ||
3470 ((c >= 0xF8) && (c <= 0x2FF)) ||
3471 ((c >= 0x370) && (c <= 0x37D)) ||
3472 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3473 ((c >= 0x200C) && (c <= 0x200D)) ||
3474 ((c >= 0x2070) && (c <= 0x218F)) ||
3475 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3476 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3477 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3478 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3479 ((c >= 0x10000) && (c <= 0xEFFFF)))
3480 return(1);
3481 } else {
3482 if (IS_LETTER(c) || (c == '_') || (c == ':'))
3483 return(1);
3484 }
3485 return(0);
3486 }
3487
3488 static int
xmlIsDocNameChar(xmlDocPtr doc,int c)3489 xmlIsDocNameChar(xmlDocPtr doc, int c) {
3490 if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) {
3491 /*
3492 * Use the new checks of production [4] [4a] amd [5] of the
3493 * Update 5 of XML-1.0
3494 */
3495 if (((c >= 'a') && (c <= 'z')) ||
3496 ((c >= 'A') && (c <= 'Z')) ||
3497 ((c >= '0') && (c <= '9')) || /* !start */
3498 (c == '_') || (c == ':') ||
3499 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3500 ((c >= 0xC0) && (c <= 0xD6)) ||
3501 ((c >= 0xD8) && (c <= 0xF6)) ||
3502 ((c >= 0xF8) && (c <= 0x2FF)) ||
3503 ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3504 ((c >= 0x370) && (c <= 0x37D)) ||
3505 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3506 ((c >= 0x200C) && (c <= 0x200D)) ||
3507 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3508 ((c >= 0x2070) && (c <= 0x218F)) ||
3509 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3510 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3511 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3512 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3513 ((c >= 0x10000) && (c <= 0xEFFFF)))
3514 return(1);
3515 } else {
3516 if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3517 (c == '.') || (c == '-') ||
3518 (c == '_') || (c == ':') ||
3519 (IS_COMBINING(c)) ||
3520 (IS_EXTENDER(c)))
3521 return(1);
3522 }
3523 return(0);
3524 }
3525
3526 /**
3527 * xmlValidateNameValue:
3528 * @doc: pointer to the document or NULL
3529 * @value: an Name value
3530 *
3531 * Validate that the given value match Name production
3532 *
3533 * returns 1 if valid or 0 otherwise
3534 */
3535
3536 static int
xmlValidateNameValueInternal(xmlDocPtr doc,const xmlChar * value)3537 xmlValidateNameValueInternal(xmlDocPtr doc, const xmlChar *value) {
3538 const xmlChar *cur;
3539 int val, len;
3540
3541 if (value == NULL) return(0);
3542 cur = value;
3543 val = xmlStringCurrentChar(NULL, cur, &len);
3544 cur += len;
3545 if (!xmlIsDocNameStartChar(doc, val))
3546 return(0);
3547
3548 val = xmlStringCurrentChar(NULL, cur, &len);
3549 cur += len;
3550 while (xmlIsDocNameChar(doc, val)) {
3551 val = xmlStringCurrentChar(NULL, cur, &len);
3552 cur += len;
3553 }
3554
3555 if (val != 0) return(0);
3556
3557 return(1);
3558 }
3559
3560 /**
3561 * xmlValidateNameValue:
3562 * @value: an Name value
3563 *
3564 * Validate that the given value match Name production
3565 *
3566 * returns 1 if valid or 0 otherwise
3567 */
3568
3569 int
xmlValidateNameValue(const xmlChar * value)3570 xmlValidateNameValue(const xmlChar *value) {
3571 return(xmlValidateNameValueInternal(NULL, value));
3572 }
3573
3574 /**
3575 * xmlValidateNamesValueInternal:
3576 * @doc: pointer to the document or NULL
3577 * @value: an Names value
3578 *
3579 * Validate that the given value match Names production
3580 *
3581 * returns 1 if valid or 0 otherwise
3582 */
3583
3584 static int
xmlValidateNamesValueInternal(xmlDocPtr doc,const xmlChar * value)3585 xmlValidateNamesValueInternal(xmlDocPtr doc, const xmlChar *value) {
3586 const xmlChar *cur;
3587 int val, len;
3588
3589 if (value == NULL) return(0);
3590 cur = value;
3591 val = xmlStringCurrentChar(NULL, cur, &len);
3592 cur += len;
3593
3594 if (!xmlIsDocNameStartChar(doc, val))
3595 return(0);
3596
3597 val = xmlStringCurrentChar(NULL, cur, &len);
3598 cur += len;
3599 while (xmlIsDocNameChar(doc, val)) {
3600 val = xmlStringCurrentChar(NULL, cur, &len);
3601 cur += len;
3602 }
3603
3604 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3605 while (val == 0x20) {
3606 while (val == 0x20) {
3607 val = xmlStringCurrentChar(NULL, cur, &len);
3608 cur += len;
3609 }
3610
3611 if (!xmlIsDocNameStartChar(doc, val))
3612 return(0);
3613
3614 val = xmlStringCurrentChar(NULL, cur, &len);
3615 cur += len;
3616
3617 while (xmlIsDocNameChar(doc, val)) {
3618 val = xmlStringCurrentChar(NULL, cur, &len);
3619 cur += len;
3620 }
3621 }
3622
3623 if (val != 0) return(0);
3624
3625 return(1);
3626 }
3627
3628 /**
3629 * xmlValidateNamesValue:
3630 * @value: an Names value
3631 *
3632 * Validate that the given value match Names production
3633 *
3634 * returns 1 if valid or 0 otherwise
3635 */
3636
3637 int
xmlValidateNamesValue(const xmlChar * value)3638 xmlValidateNamesValue(const xmlChar *value) {
3639 return(xmlValidateNamesValueInternal(NULL, value));
3640 }
3641
3642 /**
3643 * xmlValidateNmtokenValueInternal:
3644 * @doc: pointer to the document or NULL
3645 * @value: an Nmtoken value
3646 *
3647 * Validate that the given value match Nmtoken production
3648 *
3649 * [ VC: Name Token ]
3650 *
3651 * returns 1 if valid or 0 otherwise
3652 */
3653
3654 static int
xmlValidateNmtokenValueInternal(xmlDocPtr doc,const xmlChar * value)3655 xmlValidateNmtokenValueInternal(xmlDocPtr doc, const xmlChar *value) {
3656 const xmlChar *cur;
3657 int val, len;
3658
3659 if (value == NULL) return(0);
3660 cur = value;
3661 val = xmlStringCurrentChar(NULL, cur, &len);
3662 cur += len;
3663
3664 if (!xmlIsDocNameChar(doc, val))
3665 return(0);
3666
3667 val = xmlStringCurrentChar(NULL, cur, &len);
3668 cur += len;
3669 while (xmlIsDocNameChar(doc, val)) {
3670 val = xmlStringCurrentChar(NULL, cur, &len);
3671 cur += len;
3672 }
3673
3674 if (val != 0) return(0);
3675
3676 return(1);
3677 }
3678
3679 /**
3680 * xmlValidateNmtokenValue:
3681 * @value: an Nmtoken value
3682 *
3683 * Validate that the given value match Nmtoken production
3684 *
3685 * [ VC: Name Token ]
3686 *
3687 * returns 1 if valid or 0 otherwise
3688 */
3689
3690 int
xmlValidateNmtokenValue(const xmlChar * value)3691 xmlValidateNmtokenValue(const xmlChar *value) {
3692 return(xmlValidateNmtokenValueInternal(NULL, value));
3693 }
3694
3695 /**
3696 * xmlValidateNmtokensValueInternal:
3697 * @doc: pointer to the document or NULL
3698 * @value: an Nmtokens value
3699 *
3700 * Validate that the given value match Nmtokens production
3701 *
3702 * [ VC: Name Token ]
3703 *
3704 * returns 1 if valid or 0 otherwise
3705 */
3706
3707 static int
xmlValidateNmtokensValueInternal(xmlDocPtr doc,const xmlChar * value)3708 xmlValidateNmtokensValueInternal(xmlDocPtr doc, const xmlChar *value) {
3709 const xmlChar *cur;
3710 int val, len;
3711
3712 if (value == NULL) return(0);
3713 cur = value;
3714 val = xmlStringCurrentChar(NULL, cur, &len);
3715 cur += len;
3716
3717 while (IS_BLANK(val)) {
3718 val = xmlStringCurrentChar(NULL, cur, &len);
3719 cur += len;
3720 }
3721
3722 if (!xmlIsDocNameChar(doc, val))
3723 return(0);
3724
3725 while (xmlIsDocNameChar(doc, val)) {
3726 val = xmlStringCurrentChar(NULL, cur, &len);
3727 cur += len;
3728 }
3729
3730 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3731 while (val == 0x20) {
3732 while (val == 0x20) {
3733 val = xmlStringCurrentChar(NULL, cur, &len);
3734 cur += len;
3735 }
3736 if (val == 0) return(1);
3737
3738 if (!xmlIsDocNameChar(doc, val))
3739 return(0);
3740
3741 val = xmlStringCurrentChar(NULL, cur, &len);
3742 cur += len;
3743
3744 while (xmlIsDocNameChar(doc, val)) {
3745 val = xmlStringCurrentChar(NULL, cur, &len);
3746 cur += len;
3747 }
3748 }
3749
3750 if (val != 0) return(0);
3751
3752 return(1);
3753 }
3754
3755 /**
3756 * xmlValidateNmtokensValue:
3757 * @value: an Nmtokens value
3758 *
3759 * Validate that the given value match Nmtokens production
3760 *
3761 * [ VC: Name Token ]
3762 *
3763 * returns 1 if valid or 0 otherwise
3764 */
3765
3766 int
xmlValidateNmtokensValue(const xmlChar * value)3767 xmlValidateNmtokensValue(const xmlChar *value) {
3768 return(xmlValidateNmtokensValueInternal(NULL, value));
3769 }
3770
3771 /**
3772 * xmlValidateNotationDecl:
3773 * @ctxt: the validation context
3774 * @doc: a document instance
3775 * @nota: a notation definition
3776 *
3777 * Try to validate a single notation definition
3778 * basically it does the following checks as described by the
3779 * XML-1.0 recommendation:
3780 * - it seems that no validity constraint exists on notation declarations
3781 * But this function get called anyway ...
3782 *
3783 * returns 1 if valid or 0 otherwise
3784 */
3785
3786 int
xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED,xmlDocPtr doc ATTRIBUTE_UNUSED,xmlNotationPtr nota ATTRIBUTE_UNUSED)3787 xmlValidateNotationDecl(xmlValidCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlDocPtr doc ATTRIBUTE_UNUSED,
3788 xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3789 int ret = 1;
3790
3791 return(ret);
3792 }
3793
3794 /**
3795 * xmlValidateAttributeValueInternal:
3796 * @doc: the document
3797 * @type: an attribute type
3798 * @value: an attribute value
3799 *
3800 * Validate that the given attribute value match the proper production
3801 *
3802 * returns 1 if valid or 0 otherwise
3803 */
3804
3805 static int
xmlValidateAttributeValueInternal(xmlDocPtr doc,xmlAttributeType type,const xmlChar * value)3806 xmlValidateAttributeValueInternal(xmlDocPtr doc, xmlAttributeType type,
3807 const xmlChar *value) {
3808 switch (type) {
3809 case XML_ATTRIBUTE_ENTITIES:
3810 case XML_ATTRIBUTE_IDREFS:
3811 return(xmlValidateNamesValueInternal(doc, value));
3812 case XML_ATTRIBUTE_ENTITY:
3813 case XML_ATTRIBUTE_IDREF:
3814 case XML_ATTRIBUTE_ID:
3815 case XML_ATTRIBUTE_NOTATION:
3816 return(xmlValidateNameValueInternal(doc, value));
3817 case XML_ATTRIBUTE_NMTOKENS:
3818 case XML_ATTRIBUTE_ENUMERATION:
3819 return(xmlValidateNmtokensValueInternal(doc, value));
3820 case XML_ATTRIBUTE_NMTOKEN:
3821 return(xmlValidateNmtokenValueInternal(doc, value));
3822 case XML_ATTRIBUTE_CDATA:
3823 break;
3824 }
3825 return(1);
3826 }
3827
3828 /**
3829 * xmlValidateAttributeValue:
3830 * @type: an attribute type
3831 * @value: an attribute value
3832 *
3833 * Validate that the given attribute value match the proper production
3834 *
3835 * [ VC: ID ]
3836 * Values of type ID must match the Name production....
3837 *
3838 * [ VC: IDREF ]
3839 * Values of type IDREF must match the Name production, and values
3840 * of type IDREFS must match Names ...
3841 *
3842 * [ VC: Entity Name ]
3843 * Values of type ENTITY must match the Name production, values
3844 * of type ENTITIES must match Names ...
3845 *
3846 * [ VC: Name Token ]
3847 * Values of type NMTOKEN must match the Nmtoken production; values
3848 * of type NMTOKENS must match Nmtokens.
3849 *
3850 * returns 1 if valid or 0 otherwise
3851 */
3852 int
xmlValidateAttributeValue(xmlAttributeType type,const xmlChar * value)3853 xmlValidateAttributeValue(xmlAttributeType type, const xmlChar *value) {
3854 return(xmlValidateAttributeValueInternal(NULL, type, value));
3855 }
3856
3857 /**
3858 * xmlValidateAttributeValue2:
3859 * @ctxt: the validation context
3860 * @doc: the document
3861 * @name: the attribute name (used for error reporting only)
3862 * @type: the attribute type
3863 * @value: the attribute value
3864 *
3865 * Validate that the given attribute value match a given type.
3866 * This typically cannot be done before having finished parsing
3867 * the subsets.
3868 *
3869 * [ VC: IDREF ]
3870 * Values of type IDREF must match one of the declared IDs
3871 * Values of type IDREFS must match a sequence of the declared IDs
3872 * each Name must match the value of an ID attribute on some element
3873 * in the XML document; i.e. IDREF values must match the value of
3874 * some ID attribute
3875 *
3876 * [ VC: Entity Name ]
3877 * Values of type ENTITY must match one declared entity
3878 * Values of type ENTITIES must match a sequence of declared entities
3879 *
3880 * [ VC: Notation Attributes ]
3881 * all notation names in the declaration must be declared.
3882 *
3883 * returns 1 if valid or 0 otherwise
3884 */
3885
3886 static int
xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt,xmlDocPtr doc,const xmlChar * name,xmlAttributeType type,const xmlChar * value)3887 xmlValidateAttributeValue2(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
3888 const xmlChar *name, xmlAttributeType type, const xmlChar *value) {
3889 int ret = 1;
3890 switch (type) {
3891 case XML_ATTRIBUTE_IDREFS:
3892 case XML_ATTRIBUTE_IDREF:
3893 case XML_ATTRIBUTE_ID:
3894 case XML_ATTRIBUTE_NMTOKENS:
3895 case XML_ATTRIBUTE_ENUMERATION:
3896 case XML_ATTRIBUTE_NMTOKEN:
3897 case XML_ATTRIBUTE_CDATA:
3898 break;
3899 case XML_ATTRIBUTE_ENTITY: {
3900 xmlEntityPtr ent;
3901
3902 ent = xmlGetDocEntity(doc, value);
3903 /* yeah it's a bit messy... */
3904 if ((ent == NULL) && (doc->standalone == 1)) {
3905 doc->standalone = 0;
3906 ent = xmlGetDocEntity(doc, value);
3907 }
3908 if (ent == NULL) {
3909 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3910 XML_DTD_UNKNOWN_ENTITY,
3911 "ENTITY attribute %s reference an unknown entity \"%s\"\n",
3912 name, value, NULL);
3913 ret = 0;
3914 } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3915 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3916 XML_DTD_ENTITY_TYPE,
3917 "ENTITY attribute %s reference an entity \"%s\" of wrong type\n",
3918 name, value, NULL);
3919 ret = 0;
3920 }
3921 break;
3922 }
3923 case XML_ATTRIBUTE_ENTITIES: {
3924 xmlChar *dup, *nam = NULL, *cur, save;
3925 xmlEntityPtr ent;
3926
3927 dup = xmlStrdup(value);
3928 if (dup == NULL)
3929 return(0);
3930 cur = dup;
3931 while (*cur != 0) {
3932 nam = cur;
3933 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
3934 save = *cur;
3935 *cur = 0;
3936 ent = xmlGetDocEntity(doc, nam);
3937 if (ent == NULL) {
3938 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3939 XML_DTD_UNKNOWN_ENTITY,
3940 "ENTITIES attribute %s reference an unknown entity \"%s\"\n",
3941 name, nam, NULL);
3942 ret = 0;
3943 } else if (ent->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
3944 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3945 XML_DTD_ENTITY_TYPE,
3946 "ENTITIES attribute %s reference an entity \"%s\" of wrong type\n",
3947 name, nam, NULL);
3948 ret = 0;
3949 }
3950 if (save == 0)
3951 break;
3952 *cur = save;
3953 while (IS_BLANK_CH(*cur)) cur++;
3954 }
3955 xmlFree(dup);
3956 break;
3957 }
3958 case XML_ATTRIBUTE_NOTATION: {
3959 xmlNotationPtr nota;
3960
3961 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
3962 if ((nota == NULL) && (doc->extSubset != NULL))
3963 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
3964
3965 if (nota == NULL) {
3966 xmlErrValidNode(ctxt, (xmlNodePtr) doc,
3967 XML_DTD_UNKNOWN_NOTATION,
3968 "NOTATION attribute %s reference an unknown notation \"%s\"\n",
3969 name, value, NULL);
3970 ret = 0;
3971 }
3972 break;
3973 }
3974 }
3975 return(ret);
3976 }
3977
3978 /**
3979 * xmlValidCtxtNormalizeAttributeValue:
3980 * @ctxt: the validation context
3981 * @doc: the document
3982 * @elem: the parent
3983 * @name: the attribute name
3984 * @value: the attribute value
3985 * @ctxt: the validation context or NULL
3986 *
3987 * Does the validation related extra step of the normalization of attribute
3988 * values:
3989 *
3990 * If the declared value is not CDATA, then the XML processor must further
3991 * process the normalized attribute value by discarding any leading and
3992 * trailing space (#x20) characters, and by replacing sequences of space
3993 * (#x20) characters by single space (#x20) character.
3994 *
3995 * Also check VC: Standalone Document Declaration in P32, and update
3996 * ctxt->valid accordingly
3997 *
3998 * returns a new normalized string if normalization is needed, NULL otherwise
3999 * the caller must free the returned value.
4000 */
4001
4002 xmlChar *
xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem,const xmlChar * name,const xmlChar * value)4003 xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4004 xmlNodePtr elem, const xmlChar *name, const xmlChar *value) {
4005 xmlChar *ret, *dst;
4006 const xmlChar *src;
4007 xmlAttributePtr attrDecl = NULL;
4008 int extsubset = 0;
4009
4010 if (doc == NULL) return(NULL);
4011 if (elem == NULL) return(NULL);
4012 if (name == NULL) return(NULL);
4013 if (value == NULL) return(NULL);
4014
4015 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4016 xmlChar fn[50];
4017 xmlChar *fullname;
4018
4019 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4020 if (fullname == NULL)
4021 return(NULL);
4022 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
4023 if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
4024 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
4025 if (attrDecl != NULL)
4026 extsubset = 1;
4027 }
4028 if ((fullname != fn) && (fullname != elem->name))
4029 xmlFree(fullname);
4030 }
4031 if ((attrDecl == NULL) && (doc->intSubset != NULL))
4032 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
4033 if ((attrDecl == NULL) && (doc->extSubset != NULL)) {
4034 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
4035 if (attrDecl != NULL)
4036 extsubset = 1;
4037 }
4038
4039 if (attrDecl == NULL)
4040 return(NULL);
4041 if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
4042 return(NULL);
4043
4044 ret = xmlStrdup(value);
4045 if (ret == NULL)
4046 return(NULL);
4047 src = value;
4048 dst = ret;
4049 while (*src == 0x20) src++;
4050 while (*src != 0) {
4051 if (*src == 0x20) {
4052 while (*src == 0x20) src++;
4053 if (*src != 0)
4054 *dst++ = 0x20;
4055 } else {
4056 *dst++ = *src++;
4057 }
4058 }
4059 *dst = 0;
4060 if ((doc->standalone) && (extsubset == 1) && (!xmlStrEqual(value, ret))) {
4061 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_STANDALONE,
4062 "standalone: %s on %s value had to be normalized based on external subset declaration\n",
4063 name, elem->name, NULL);
4064 ctxt->valid = 0;
4065 }
4066 return(ret);
4067 }
4068
4069 /**
4070 * xmlValidNormalizeAttributeValue:
4071 * @doc: the document
4072 * @elem: the parent
4073 * @name: the attribute name
4074 * @value: the attribute value
4075 *
4076 * Does the validation related extra step of the normalization of attribute
4077 * values:
4078 *
4079 * If the declared value is not CDATA, then the XML processor must further
4080 * process the normalized attribute value by discarding any leading and
4081 * trailing space (#x20) characters, and by replacing sequences of space
4082 * (#x20) characters by single space (#x20) character.
4083 *
4084 * Returns a new normalized string if normalization is needed, NULL otherwise
4085 * the caller must free the returned value.
4086 */
4087
4088 xmlChar *
xmlValidNormalizeAttributeValue(xmlDocPtr doc,xmlNodePtr elem,const xmlChar * name,const xmlChar * value)4089 xmlValidNormalizeAttributeValue(xmlDocPtr doc, xmlNodePtr elem,
4090 const xmlChar *name, const xmlChar *value) {
4091 xmlChar *ret, *dst;
4092 const xmlChar *src;
4093 xmlAttributePtr attrDecl = NULL;
4094
4095 if (doc == NULL) return(NULL);
4096 if (elem == NULL) return(NULL);
4097 if (name == NULL) return(NULL);
4098 if (value == NULL) return(NULL);
4099
4100 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4101 xmlChar fn[50];
4102 xmlChar *fullname;
4103
4104 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4105 if (fullname == NULL)
4106 return(NULL);
4107 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, name);
4108 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4109 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname, name);
4110 if ((fullname != fn) && (fullname != elem->name))
4111 xmlFree(fullname);
4112 }
4113 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, name);
4114 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4115 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, elem->name, name);
4116
4117 if (attrDecl == NULL)
4118 return(NULL);
4119 if (attrDecl->atype == XML_ATTRIBUTE_CDATA)
4120 return(NULL);
4121
4122 ret = xmlStrdup(value);
4123 if (ret == NULL)
4124 return(NULL);
4125 src = value;
4126 dst = ret;
4127 while (*src == 0x20) src++;
4128 while (*src != 0) {
4129 if (*src == 0x20) {
4130 while (*src == 0x20) src++;
4131 if (*src != 0)
4132 *dst++ = 0x20;
4133 } else {
4134 *dst++ = *src++;
4135 }
4136 }
4137 *dst = 0;
4138 return(ret);
4139 }
4140
4141 static void
xmlValidateAttributeIdCallback(xmlAttributePtr attr,int * count,const xmlChar * name ATTRIBUTE_UNUSED)4142 xmlValidateAttributeIdCallback(xmlAttributePtr attr, int *count,
4143 const xmlChar* name ATTRIBUTE_UNUSED) {
4144 if (attr->atype == XML_ATTRIBUTE_ID) (*count)++;
4145 }
4146
4147 /**
4148 * xmlValidateAttributeDecl:
4149 * @ctxt: the validation context
4150 * @doc: a document instance
4151 * @attr: an attribute definition
4152 *
4153 * Try to validate a single attribute definition
4154 * basically it does the following checks as described by the
4155 * XML-1.0 recommendation:
4156 * - [ VC: Attribute Default Legal ]
4157 * - [ VC: Enumeration ]
4158 * - [ VC: ID Attribute Default ]
4159 *
4160 * The ID/IDREF uniqueness and matching are done separately
4161 *
4162 * returns 1 if valid or 0 otherwise
4163 */
4164
4165 int
xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlAttributePtr attr)4166 xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4167 xmlAttributePtr attr) {
4168 int ret = 1;
4169 int val;
4170 CHECK_DTD;
4171 if(attr == NULL) return(1);
4172
4173 /* Attribute Default Legal */
4174 /* Enumeration */
4175 if (attr->defaultValue != NULL) {
4176 val = xmlValidateAttributeValueInternal(doc, attr->atype,
4177 attr->defaultValue);
4178 if (val == 0) {
4179 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_DEFAULT,
4180 "Syntax of default value for attribute %s of %s is not valid\n",
4181 attr->name, attr->elem, NULL);
4182 }
4183 ret &= val;
4184 }
4185
4186 /* ID Attribute Default */
4187 if ((attr->atype == XML_ATTRIBUTE_ID)&&
4188 (attr->def != XML_ATTRIBUTE_IMPLIED) &&
4189 (attr->def != XML_ATTRIBUTE_REQUIRED)) {
4190 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_FIXED,
4191 "ID attribute %s of %s is not valid must be #IMPLIED or #REQUIRED\n",
4192 attr->name, attr->elem, NULL);
4193 ret = 0;
4194 }
4195
4196 /* One ID per Element Type */
4197 if (attr->atype == XML_ATTRIBUTE_ID) {
4198 int nbId;
4199
4200 /* the trick is that we parse DtD as their own internal subset */
4201 xmlElementPtr elem = xmlGetDtdElementDesc(doc->intSubset,
4202 attr->elem);
4203 if (elem != NULL) {
4204 nbId = xmlScanIDAttributeDecl(NULL, elem, 0);
4205 } else {
4206 xmlAttributeTablePtr table;
4207
4208 /*
4209 * The attribute may be declared in the internal subset and the
4210 * element in the external subset.
4211 */
4212 nbId = 0;
4213 if (doc->intSubset != NULL) {
4214 table = (xmlAttributeTablePtr) doc->intSubset->attributes;
4215 xmlHashScan3(table, NULL, NULL, attr->elem, (xmlHashScanner)
4216 xmlValidateAttributeIdCallback, &nbId);
4217 }
4218 }
4219 if (nbId > 1) {
4220
4221 xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4222 "Element %s has %d ID attribute defined in the internal subset : %s\n",
4223 attr->elem, nbId, attr->name);
4224 } else if (doc->extSubset != NULL) {
4225 int extId = 0;
4226 elem = xmlGetDtdElementDesc(doc->extSubset, attr->elem);
4227 if (elem != NULL) {
4228 extId = xmlScanIDAttributeDecl(NULL, elem, 0);
4229 }
4230 if (extId > 1) {
4231 xmlErrValidNodeNr(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4232 "Element %s has %d ID attribute defined in the external subset : %s\n",
4233 attr->elem, extId, attr->name);
4234 } else if (extId + nbId > 1) {
4235 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ID_SUBSET,
4236 "Element %s has ID attributes defined in the internal and external subset : %s\n",
4237 attr->elem, attr->name, NULL);
4238 }
4239 }
4240 }
4241
4242 /* Validity Constraint: Enumeration */
4243 if ((attr->defaultValue != NULL) && (attr->tree != NULL)) {
4244 xmlEnumerationPtr tree = attr->tree;
4245 while (tree != NULL) {
4246 if (xmlStrEqual(tree->name, attr->defaultValue)) break;
4247 tree = tree->next;
4248 }
4249 if (tree == NULL) {
4250 xmlErrValidNode(ctxt, (xmlNodePtr) attr, XML_DTD_ATTRIBUTE_VALUE,
4251 "Default value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4252 attr->defaultValue, attr->name, attr->elem);
4253 ret = 0;
4254 }
4255 }
4256
4257 return(ret);
4258 }
4259
4260 /**
4261 * xmlValidateElementDecl:
4262 * @ctxt: the validation context
4263 * @doc: a document instance
4264 * @elem: an element definition
4265 *
4266 * Try to validate a single element definition
4267 * basically it does the following checks as described by the
4268 * XML-1.0 recommendation:
4269 * - [ VC: One ID per Element Type ]
4270 * - [ VC: No Duplicate Types ]
4271 * - [ VC: Unique Element Type Declaration ]
4272 *
4273 * returns 1 if valid or 0 otherwise
4274 */
4275
4276 int
xmlValidateElementDecl(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlElementPtr elem)4277 xmlValidateElementDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4278 xmlElementPtr elem) {
4279 int ret = 1;
4280 xmlElementPtr tst;
4281
4282 CHECK_DTD;
4283
4284 if (elem == NULL) return(1);
4285
4286 #if 0
4287 #ifdef LIBXML_REGEXP_ENABLED
4288 /* Build the regexp associated to the content model */
4289 ret = xmlValidBuildContentModel(ctxt, elem);
4290 #endif
4291 #endif
4292
4293 /* No Duplicate Types */
4294 if (elem->etype == XML_ELEMENT_TYPE_MIXED) {
4295 xmlElementContentPtr cur, next;
4296 const xmlChar *name;
4297
4298 cur = elem->content;
4299 while (cur != NULL) {
4300 if (cur->type != XML_ELEMENT_CONTENT_OR) break;
4301 if (cur->c1 == NULL) break;
4302 if (cur->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4303 name = cur->c1->name;
4304 next = cur->c2;
4305 while (next != NULL) {
4306 if (next->type == XML_ELEMENT_CONTENT_ELEMENT) {
4307 if ((xmlStrEqual(next->name, name)) &&
4308 (xmlStrEqual(next->prefix, cur->prefix))) {
4309 if (cur->prefix == NULL) {
4310 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4311 "Definition of %s has duplicate references of %s\n",
4312 elem->name, name, NULL);
4313 } else {
4314 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4315 "Definition of %s has duplicate references of %s:%s\n",
4316 elem->name, cur->prefix, name);
4317 }
4318 ret = 0;
4319 }
4320 break;
4321 }
4322 if (next->c1 == NULL) break;
4323 if (next->c1->type != XML_ELEMENT_CONTENT_ELEMENT) break;
4324 if ((xmlStrEqual(next->c1->name, name)) &&
4325 (xmlStrEqual(next->c1->prefix, cur->prefix))) {
4326 if (cur->prefix == NULL) {
4327 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4328 "Definition of %s has duplicate references to %s\n",
4329 elem->name, name, NULL);
4330 } else {
4331 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_CONTENT_ERROR,
4332 "Definition of %s has duplicate references to %s:%s\n",
4333 elem->name, cur->prefix, name);
4334 }
4335 ret = 0;
4336 }
4337 next = next->c2;
4338 }
4339 }
4340 cur = cur->c2;
4341 }
4342 }
4343
4344 /* VC: Unique Element Type Declaration */
4345 tst = xmlGetDtdElementDesc(doc->intSubset, elem->name);
4346 if ((tst != NULL ) && (tst != elem) &&
4347 ((tst->prefix == elem->prefix) ||
4348 (xmlStrEqual(tst->prefix, elem->prefix))) &&
4349 (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4350 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4351 "Redefinition of element %s\n",
4352 elem->name, NULL, NULL);
4353 ret = 0;
4354 }
4355 tst = xmlGetDtdElementDesc(doc->extSubset, elem->name);
4356 if ((tst != NULL ) && (tst != elem) &&
4357 ((tst->prefix == elem->prefix) ||
4358 (xmlStrEqual(tst->prefix, elem->prefix))) &&
4359 (tst->etype != XML_ELEMENT_TYPE_UNDEFINED)) {
4360 xmlErrValidNode(ctxt, (xmlNodePtr) elem, XML_DTD_ELEM_REDEFINED,
4361 "Redefinition of element %s\n",
4362 elem->name, NULL, NULL);
4363 ret = 0;
4364 }
4365 /* One ID per Element Type
4366 * already done when registering the attribute
4367 if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4368 ret = 0;
4369 } */
4370 return(ret);
4371 }
4372
4373 /**
4374 * xmlValidateOneAttribute:
4375 * @ctxt: the validation context
4376 * @doc: a document instance
4377 * @elem: an element instance
4378 * @attr: an attribute instance
4379 * @value: the attribute value (without entities processing)
4380 *
4381 * Try to validate a single attribute for an element
4382 * basically it does the following checks as described by the
4383 * XML-1.0 recommendation:
4384 * - [ VC: Attribute Value Type ]
4385 * - [ VC: Fixed Attribute Default ]
4386 * - [ VC: Entity Name ]
4387 * - [ VC: Name Token ]
4388 * - [ VC: ID ]
4389 * - [ VC: IDREF ]
4390 * - [ VC: Entity Name ]
4391 * - [ VC: Notation Attributes ]
4392 *
4393 * The ID/IDREF uniqueness and matching are done separately
4394 *
4395 * returns 1 if valid or 0 otherwise
4396 */
4397
4398 int
xmlValidateOneAttribute(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem,xmlAttrPtr attr,const xmlChar * value)4399 xmlValidateOneAttribute(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4400 xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value)
4401 {
4402 xmlAttributePtr attrDecl = NULL;
4403 int val;
4404 int ret = 1;
4405
4406 CHECK_DTD;
4407 if ((elem == NULL) || (elem->name == NULL)) return(0);
4408 if ((attr == NULL) || (attr->name == NULL)) return(0);
4409
4410 if ((elem->ns != NULL) && (elem->ns->prefix != NULL)) {
4411 xmlChar fn[50];
4412 xmlChar *fullname;
4413
4414 fullname = xmlBuildQName(elem->name, elem->ns->prefix, fn, 50);
4415 if (fullname == NULL)
4416 return(0);
4417 if (attr->ns != NULL) {
4418 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4419 attr->name, attr->ns->prefix);
4420 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4421 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4422 attr->name, attr->ns->prefix);
4423 } else {
4424 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname, attr->name);
4425 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4426 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4427 fullname, attr->name);
4428 }
4429 if ((fullname != fn) && (fullname != elem->name))
4430 xmlFree(fullname);
4431 }
4432 if (attrDecl == NULL) {
4433 if (attr->ns != NULL) {
4434 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4435 attr->name, attr->ns->prefix);
4436 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4437 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4438 attr->name, attr->ns->prefix);
4439 } else {
4440 attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4441 elem->name, attr->name);
4442 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4443 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4444 elem->name, attr->name);
4445 }
4446 }
4447
4448
4449 /* Validity Constraint: Attribute Value Type */
4450 if (attrDecl == NULL) {
4451 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4452 "No declaration for attribute %s of element %s\n",
4453 attr->name, elem->name, NULL);
4454 return(0);
4455 }
4456 attr->atype = attrDecl->atype;
4457
4458 val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4459 if (val == 0) {
4460 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4461 "Syntax of value for attribute %s of %s is not valid\n",
4462 attr->name, elem->name, NULL);
4463 ret = 0;
4464 }
4465
4466 /* Validity constraint: Fixed Attribute Default */
4467 if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4468 if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4469 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4470 "Value for attribute %s of %s is different from default \"%s\"\n",
4471 attr->name, elem->name, attrDecl->defaultValue);
4472 ret = 0;
4473 }
4474 }
4475
4476 /* Validity Constraint: ID uniqueness */
4477 if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4478 if (xmlAddID(ctxt, doc, value, attr) == NULL)
4479 ret = 0;
4480 }
4481
4482 if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4483 (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4484 if (xmlAddRef(ctxt, doc, value, attr) == NULL)
4485 ret = 0;
4486 }
4487
4488 /* Validity Constraint: Notation Attributes */
4489 if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4490 xmlEnumerationPtr tree = attrDecl->tree;
4491 xmlNotationPtr nota;
4492
4493 /* First check that the given NOTATION was declared */
4494 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4495 if (nota == NULL)
4496 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4497
4498 if (nota == NULL) {
4499 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4500 "Value \"%s\" for attribute %s of %s is not a declared Notation\n",
4501 value, attr->name, elem->name);
4502 ret = 0;
4503 }
4504
4505 /* Second, verify that it's among the list */
4506 while (tree != NULL) {
4507 if (xmlStrEqual(tree->name, value)) break;
4508 tree = tree->next;
4509 }
4510 if (tree == NULL) {
4511 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4512 "Value \"%s\" for attribute %s of %s is not among the enumerated notations\n",
4513 value, attr->name, elem->name);
4514 ret = 0;
4515 }
4516 }
4517
4518 /* Validity Constraint: Enumeration */
4519 if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4520 xmlEnumerationPtr tree = attrDecl->tree;
4521 while (tree != NULL) {
4522 if (xmlStrEqual(tree->name, value)) break;
4523 tree = tree->next;
4524 }
4525 if (tree == NULL) {
4526 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4527 "Value \"%s\" for attribute %s of %s is not among the enumerated set\n",
4528 value, attr->name, elem->name);
4529 ret = 0;
4530 }
4531 }
4532
4533 /* Fixed Attribute Default */
4534 if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4535 (!xmlStrEqual(attrDecl->defaultValue, value))) {
4536 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4537 "Value for attribute %s of %s must be \"%s\"\n",
4538 attr->name, elem->name, attrDecl->defaultValue);
4539 ret = 0;
4540 }
4541
4542 /* Extra check for the attribute value */
4543 ret &= xmlValidateAttributeValue2(ctxt, doc, attr->name,
4544 attrDecl->atype, value);
4545
4546 return(ret);
4547 }
4548
4549 /**
4550 * xmlValidateOneNamespace:
4551 * @ctxt: the validation context
4552 * @doc: a document instance
4553 * @elem: an element instance
4554 * @prefix: the namespace prefix
4555 * @ns: an namespace declaration instance
4556 * @value: the attribute value (without entities processing)
4557 *
4558 * Try to validate a single namespace declaration for an element
4559 * basically it does the following checks as described by the
4560 * XML-1.0 recommendation:
4561 * - [ VC: Attribute Value Type ]
4562 * - [ VC: Fixed Attribute Default ]
4563 * - [ VC: Entity Name ]
4564 * - [ VC: Name Token ]
4565 * - [ VC: ID ]
4566 * - [ VC: IDREF ]
4567 * - [ VC: Entity Name ]
4568 * - [ VC: Notation Attributes ]
4569 *
4570 * The ID/IDREF uniqueness and matching are done separately
4571 *
4572 * returns 1 if valid or 0 otherwise
4573 */
4574
4575 int
xmlValidateOneNamespace(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem,const xmlChar * prefix,xmlNsPtr ns,const xmlChar * value)4576 xmlValidateOneNamespace(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
4577 xmlNodePtr elem, const xmlChar *prefix, xmlNsPtr ns, const xmlChar *value) {
4578 /* xmlElementPtr elemDecl; */
4579 xmlAttributePtr attrDecl = NULL;
4580 int val;
4581 int ret = 1;
4582
4583 CHECK_DTD;
4584 if ((elem == NULL) || (elem->name == NULL)) return(0);
4585 if ((ns == NULL) || (ns->href == NULL)) return(0);
4586
4587 if (prefix != NULL) {
4588 xmlChar fn[50];
4589 xmlChar *fullname;
4590
4591 fullname = xmlBuildQName(elem->name, prefix, fn, 50);
4592 if (fullname == NULL) {
4593 xmlVErrMemory(ctxt, "Validating namespace");
4594 return(0);
4595 }
4596 if (ns->prefix != NULL) {
4597 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, fullname,
4598 ns->prefix, BAD_CAST "xmlns");
4599 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4600 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, fullname,
4601 ns->prefix, BAD_CAST "xmlns");
4602 } else {
4603 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullname,
4604 BAD_CAST "xmlns");
4605 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4606 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullname,
4607 BAD_CAST "xmlns");
4608 }
4609 if ((fullname != fn) && (fullname != elem->name))
4610 xmlFree(fullname);
4611 }
4612 if (attrDecl == NULL) {
4613 if (ns->prefix != NULL) {
4614 attrDecl = xmlGetDtdQAttrDesc(doc->intSubset, elem->name,
4615 ns->prefix, BAD_CAST "xmlns");
4616 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4617 attrDecl = xmlGetDtdQAttrDesc(doc->extSubset, elem->name,
4618 ns->prefix, BAD_CAST "xmlns");
4619 } else {
4620 attrDecl = xmlGetDtdAttrDesc(doc->intSubset,
4621 elem->name, BAD_CAST "xmlns");
4622 if ((attrDecl == NULL) && (doc->extSubset != NULL))
4623 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
4624 elem->name, BAD_CAST "xmlns");
4625 }
4626 }
4627
4628
4629 /* Validity Constraint: Attribute Value Type */
4630 if (attrDecl == NULL) {
4631 if (ns->prefix != NULL) {
4632 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4633 "No declaration for attribute xmlns:%s of element %s\n",
4634 ns->prefix, elem->name, NULL);
4635 } else {
4636 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ATTRIBUTE,
4637 "No declaration for attribute xmlns of element %s\n",
4638 elem->name, NULL, NULL);
4639 }
4640 return(0);
4641 }
4642
4643 val = xmlValidateAttributeValueInternal(doc, attrDecl->atype, value);
4644 if (val == 0) {
4645 if (ns->prefix != NULL) {
4646 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4647 "Syntax of value for attribute xmlns:%s of %s is not valid\n",
4648 ns->prefix, elem->name, NULL);
4649 } else {
4650 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_DEFAULT,
4651 "Syntax of value for attribute xmlns of %s is not valid\n",
4652 elem->name, NULL, NULL);
4653 }
4654 ret = 0;
4655 }
4656
4657 /* Validity constraint: Fixed Attribute Default */
4658 if (attrDecl->def == XML_ATTRIBUTE_FIXED) {
4659 if (!xmlStrEqual(value, attrDecl->defaultValue)) {
4660 if (ns->prefix != NULL) {
4661 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4662 "Value for attribute xmlns:%s of %s is different from default \"%s\"\n",
4663 ns->prefix, elem->name, attrDecl->defaultValue);
4664 } else {
4665 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_DEFAULT,
4666 "Value for attribute xmlns of %s is different from default \"%s\"\n",
4667 elem->name, attrDecl->defaultValue, NULL);
4668 }
4669 ret = 0;
4670 }
4671 }
4672
4673 /* Validity Constraint: ID uniqueness */
4674 if (attrDecl->atype == XML_ATTRIBUTE_ID) {
4675 if (xmlAddID(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4676 ret = 0;
4677 }
4678
4679 if ((attrDecl->atype == XML_ATTRIBUTE_IDREF) ||
4680 (attrDecl->atype == XML_ATTRIBUTE_IDREFS)) {
4681 if (xmlAddRef(ctxt, doc, value, (xmlAttrPtr) ns) == NULL)
4682 ret = 0;
4683 }
4684
4685 /* Validity Constraint: Notation Attributes */
4686 if (attrDecl->atype == XML_ATTRIBUTE_NOTATION) {
4687 xmlEnumerationPtr tree = attrDecl->tree;
4688 xmlNotationPtr nota;
4689
4690 /* First check that the given NOTATION was declared */
4691 nota = xmlGetDtdNotationDesc(doc->intSubset, value);
4692 if (nota == NULL)
4693 nota = xmlGetDtdNotationDesc(doc->extSubset, value);
4694
4695 if (nota == NULL) {
4696 if (ns->prefix != NULL) {
4697 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4698 "Value \"%s\" for attribute xmlns:%s of %s is not a declared Notation\n",
4699 value, ns->prefix, elem->name);
4700 } else {
4701 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_NOTATION,
4702 "Value \"%s\" for attribute xmlns of %s is not a declared Notation\n",
4703 value, elem->name, NULL);
4704 }
4705 ret = 0;
4706 }
4707
4708 /* Second, verify that it's among the list */
4709 while (tree != NULL) {
4710 if (xmlStrEqual(tree->name, value)) break;
4711 tree = tree->next;
4712 }
4713 if (tree == NULL) {
4714 if (ns->prefix != NULL) {
4715 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4716 "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated notations\n",
4717 value, ns->prefix, elem->name);
4718 } else {
4719 xmlErrValidNode(ctxt, elem, XML_DTD_NOTATION_VALUE,
4720 "Value \"%s\" for attribute xmlns of %s is not among the enumerated notations\n",
4721 value, elem->name, NULL);
4722 }
4723 ret = 0;
4724 }
4725 }
4726
4727 /* Validity Constraint: Enumeration */
4728 if (attrDecl->atype == XML_ATTRIBUTE_ENUMERATION) {
4729 xmlEnumerationPtr tree = attrDecl->tree;
4730 while (tree != NULL) {
4731 if (xmlStrEqual(tree->name, value)) break;
4732 tree = tree->next;
4733 }
4734 if (tree == NULL) {
4735 if (ns->prefix != NULL) {
4736 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4737 "Value \"%s\" for attribute xmlns:%s of %s is not among the enumerated set\n",
4738 value, ns->prefix, elem->name);
4739 } else {
4740 xmlErrValidNode(ctxt, elem, XML_DTD_ATTRIBUTE_VALUE,
4741 "Value \"%s\" for attribute xmlns of %s is not among the enumerated set\n",
4742 value, elem->name, NULL);
4743 }
4744 ret = 0;
4745 }
4746 }
4747
4748 /* Fixed Attribute Default */
4749 if ((attrDecl->def == XML_ATTRIBUTE_FIXED) &&
4750 (!xmlStrEqual(attrDecl->defaultValue, value))) {
4751 if (ns->prefix != NULL) {
4752 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4753 "Value for attribute xmlns:%s of %s must be \"%s\"\n",
4754 ns->prefix, elem->name, attrDecl->defaultValue);
4755 } else {
4756 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
4757 "Value for attribute xmlns of %s must be \"%s\"\n",
4758 elem->name, attrDecl->defaultValue, NULL);
4759 }
4760 ret = 0;
4761 }
4762
4763 /* Extra check for the attribute value */
4764 if (ns->prefix != NULL) {
4765 ret &= xmlValidateAttributeValue2(ctxt, doc, ns->prefix,
4766 attrDecl->atype, value);
4767 } else {
4768 ret &= xmlValidateAttributeValue2(ctxt, doc, BAD_CAST "xmlns",
4769 attrDecl->atype, value);
4770 }
4771
4772 return(ret);
4773 }
4774
4775 #ifndef LIBXML_REGEXP_ENABLED
4776 /**
4777 * xmlValidateSkipIgnorable:
4778 * @ctxt: the validation context
4779 * @child: the child list
4780 *
4781 * Skip ignorable elements w.r.t. the validation process
4782 *
4783 * returns the first element to consider for validation of the content model
4784 */
4785
4786 static xmlNodePtr
xmlValidateSkipIgnorable(xmlNodePtr child)4787 xmlValidateSkipIgnorable(xmlNodePtr child) {
4788 while (child != NULL) {
4789 switch (child->type) {
4790 /* These things are ignored (skipped) during validation. */
4791 case XML_PI_NODE:
4792 case XML_COMMENT_NODE:
4793 case XML_XINCLUDE_START:
4794 case XML_XINCLUDE_END:
4795 child = child->next;
4796 break;
4797 case XML_TEXT_NODE:
4798 if (xmlIsBlankNode(child))
4799 child = child->next;
4800 else
4801 return(child);
4802 break;
4803 /* keep current node */
4804 default:
4805 return(child);
4806 }
4807 }
4808 return(child);
4809 }
4810
4811 /**
4812 * xmlValidateElementType:
4813 * @ctxt: the validation context
4814 *
4815 * Try to validate the content model of an element internal function
4816 *
4817 * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4818 * reference is found and -3 if the validation succeeded but
4819 * the content model is not determinist.
4820 */
4821
4822 static int
xmlValidateElementType(xmlValidCtxtPtr ctxt)4823 xmlValidateElementType(xmlValidCtxtPtr ctxt) {
4824 int ret = -1;
4825 int determinist = 1;
4826
4827 NODE = xmlValidateSkipIgnorable(NODE);
4828 if ((NODE == NULL) && (CONT == NULL))
4829 return(1);
4830 if ((NODE == NULL) &&
4831 ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4832 (CONT->ocur == XML_ELEMENT_CONTENT_OPT))) {
4833 return(1);
4834 }
4835 if (CONT == NULL) return(-1);
4836 if ((NODE != NULL) && (NODE->type == XML_ENTITY_REF_NODE))
4837 return(-2);
4838
4839 /*
4840 * We arrive here when more states need to be examined
4841 */
4842 cont:
4843
4844 /*
4845 * We just recovered from a rollback generated by a possible
4846 * epsilon transition, go directly to the analysis phase
4847 */
4848 if (STATE == ROLLBACK_PARENT) {
4849 DEBUG_VALID_MSG("restored parent branch");
4850 DEBUG_VALID_STATE(NODE, CONT)
4851 ret = 1;
4852 goto analyze;
4853 }
4854
4855 DEBUG_VALID_STATE(NODE, CONT)
4856 /*
4857 * we may have to save a backup state here. This is the equivalent
4858 * of handling epsilon transition in NFAs.
4859 */
4860 if ((CONT != NULL) &&
4861 ((CONT->parent == NULL) ||
4862 (CONT->parent->type != XML_ELEMENT_CONTENT_OR)) &&
4863 ((CONT->ocur == XML_ELEMENT_CONTENT_MULT) ||
4864 (CONT->ocur == XML_ELEMENT_CONTENT_OPT) ||
4865 ((CONT->ocur == XML_ELEMENT_CONTENT_PLUS) && (OCCURRENCE)))) {
4866 DEBUG_VALID_MSG("saving parent branch");
4867 if (vstateVPush(ctxt, CONT, NODE, DEPTH, OCCURS, ROLLBACK_PARENT) < 0)
4868 return(0);
4869 }
4870
4871
4872 /*
4873 * Check first if the content matches
4874 */
4875 switch (CONT->type) {
4876 case XML_ELEMENT_CONTENT_PCDATA:
4877 if (NODE == NULL) {
4878 DEBUG_VALID_MSG("pcdata failed no node");
4879 ret = 0;
4880 break;
4881 }
4882 if (NODE->type == XML_TEXT_NODE) {
4883 DEBUG_VALID_MSG("pcdata found, skip to next");
4884 /*
4885 * go to next element in the content model
4886 * skipping ignorable elems
4887 */
4888 do {
4889 NODE = NODE->next;
4890 NODE = xmlValidateSkipIgnorable(NODE);
4891 if ((NODE != NULL) &&
4892 (NODE->type == XML_ENTITY_REF_NODE))
4893 return(-2);
4894 } while ((NODE != NULL) &&
4895 ((NODE->type != XML_ELEMENT_NODE) &&
4896 (NODE->type != XML_TEXT_NODE) &&
4897 (NODE->type != XML_CDATA_SECTION_NODE)));
4898 ret = 1;
4899 break;
4900 } else {
4901 DEBUG_VALID_MSG("pcdata failed");
4902 ret = 0;
4903 break;
4904 }
4905 break;
4906 case XML_ELEMENT_CONTENT_ELEMENT:
4907 if (NODE == NULL) {
4908 DEBUG_VALID_MSG("element failed no node");
4909 ret = 0;
4910 break;
4911 }
4912 ret = ((NODE->type == XML_ELEMENT_NODE) &&
4913 (xmlStrEqual(NODE->name, CONT->name)));
4914 if (ret == 1) {
4915 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4916 ret = (CONT->prefix == NULL);
4917 } else if (CONT->prefix == NULL) {
4918 ret = 0;
4919 } else {
4920 ret = xmlStrEqual(NODE->ns->prefix, CONT->prefix);
4921 }
4922 }
4923 if (ret == 1) {
4924 DEBUG_VALID_MSG("element found, skip to next");
4925 /*
4926 * go to next element in the content model
4927 * skipping ignorable elems
4928 */
4929 do {
4930 NODE = NODE->next;
4931 NODE = xmlValidateSkipIgnorable(NODE);
4932 if ((NODE != NULL) &&
4933 (NODE->type == XML_ENTITY_REF_NODE))
4934 return(-2);
4935 } while ((NODE != NULL) &&
4936 ((NODE->type != XML_ELEMENT_NODE) &&
4937 (NODE->type != XML_TEXT_NODE) &&
4938 (NODE->type != XML_CDATA_SECTION_NODE)));
4939 } else {
4940 DEBUG_VALID_MSG("element failed");
4941 ret = 0;
4942 break;
4943 }
4944 break;
4945 case XML_ELEMENT_CONTENT_OR:
4946 /*
4947 * Small optimization.
4948 */
4949 if (CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) {
4950 if ((NODE == NULL) ||
4951 (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4952 DEPTH++;
4953 CONT = CONT->c2;
4954 goto cont;
4955 }
4956 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4957 ret = (CONT->c1->prefix == NULL);
4958 } else if (CONT->c1->prefix == NULL) {
4959 ret = 0;
4960 } else {
4961 ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4962 }
4963 if (ret == 0) {
4964 DEPTH++;
4965 CONT = CONT->c2;
4966 goto cont;
4967 }
4968 }
4969
4970 /*
4971 * save the second branch 'or' branch
4972 */
4973 DEBUG_VALID_MSG("saving 'or' branch");
4974 if (vstateVPush(ctxt, CONT->c2, NODE, (unsigned char)(DEPTH + 1),
4975 OCCURS, ROLLBACK_OR) < 0)
4976 return(-1);
4977 DEPTH++;
4978 CONT = CONT->c1;
4979 goto cont;
4980 case XML_ELEMENT_CONTENT_SEQ:
4981 /*
4982 * Small optimization.
4983 */
4984 if ((CONT->c1->type == XML_ELEMENT_CONTENT_ELEMENT) &&
4985 ((CONT->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
4986 (CONT->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
4987 if ((NODE == NULL) ||
4988 (!xmlStrEqual(NODE->name, CONT->c1->name))) {
4989 DEPTH++;
4990 CONT = CONT->c2;
4991 goto cont;
4992 }
4993 if ((NODE->ns == NULL) || (NODE->ns->prefix == NULL)) {
4994 ret = (CONT->c1->prefix == NULL);
4995 } else if (CONT->c1->prefix == NULL) {
4996 ret = 0;
4997 } else {
4998 ret = xmlStrEqual(NODE->ns->prefix, CONT->c1->prefix);
4999 }
5000 if (ret == 0) {
5001 DEPTH++;
5002 CONT = CONT->c2;
5003 goto cont;
5004 }
5005 }
5006 DEPTH++;
5007 CONT = CONT->c1;
5008 goto cont;
5009 }
5010
5011 /*
5012 * At this point handle going up in the tree
5013 */
5014 if (ret == -1) {
5015 DEBUG_VALID_MSG("error found returning");
5016 return(ret);
5017 }
5018 analyze:
5019 while (CONT != NULL) {
5020 /*
5021 * First do the analysis depending on the occurrence model at
5022 * this level.
5023 */
5024 if (ret == 0) {
5025 switch (CONT->ocur) {
5026 xmlNodePtr cur;
5027
5028 case XML_ELEMENT_CONTENT_ONCE:
5029 cur = ctxt->vstate->node;
5030 DEBUG_VALID_MSG("Once branch failed, rollback");
5031 if (vstateVPop(ctxt) < 0 ) {
5032 DEBUG_VALID_MSG("exhaustion, failed");
5033 return(0);
5034 }
5035 if (cur != ctxt->vstate->node)
5036 determinist = -3;
5037 goto cont;
5038 case XML_ELEMENT_CONTENT_PLUS:
5039 if (OCCURRENCE == 0) {
5040 cur = ctxt->vstate->node;
5041 DEBUG_VALID_MSG("Plus branch failed, rollback");
5042 if (vstateVPop(ctxt) < 0 ) {
5043 DEBUG_VALID_MSG("exhaustion, failed");
5044 return(0);
5045 }
5046 if (cur != ctxt->vstate->node)
5047 determinist = -3;
5048 goto cont;
5049 }
5050 DEBUG_VALID_MSG("Plus branch found");
5051 ret = 1;
5052 break;
5053 case XML_ELEMENT_CONTENT_MULT:
5054 #ifdef DEBUG_VALID_ALGO
5055 if (OCCURRENCE == 0) {
5056 DEBUG_VALID_MSG("Mult branch failed");
5057 } else {
5058 DEBUG_VALID_MSG("Mult branch found");
5059 }
5060 #endif
5061 ret = 1;
5062 break;
5063 case XML_ELEMENT_CONTENT_OPT:
5064 DEBUG_VALID_MSG("Option branch failed");
5065 ret = 1;
5066 break;
5067 }
5068 } else {
5069 switch (CONT->ocur) {
5070 case XML_ELEMENT_CONTENT_OPT:
5071 DEBUG_VALID_MSG("Option branch succeeded");
5072 ret = 1;
5073 break;
5074 case XML_ELEMENT_CONTENT_ONCE:
5075 DEBUG_VALID_MSG("Once branch succeeded");
5076 ret = 1;
5077 break;
5078 case XML_ELEMENT_CONTENT_PLUS:
5079 if (STATE == ROLLBACK_PARENT) {
5080 DEBUG_VALID_MSG("Plus branch rollback");
5081 ret = 1;
5082 break;
5083 }
5084 if (NODE == NULL) {
5085 DEBUG_VALID_MSG("Plus branch exhausted");
5086 ret = 1;
5087 break;
5088 }
5089 DEBUG_VALID_MSG("Plus branch succeeded, continuing");
5090 SET_OCCURRENCE;
5091 goto cont;
5092 case XML_ELEMENT_CONTENT_MULT:
5093 if (STATE == ROLLBACK_PARENT) {
5094 DEBUG_VALID_MSG("Mult branch rollback");
5095 ret = 1;
5096 break;
5097 }
5098 if (NODE == NULL) {
5099 DEBUG_VALID_MSG("Mult branch exhausted");
5100 ret = 1;
5101 break;
5102 }
5103 DEBUG_VALID_MSG("Mult branch succeeded, continuing");
5104 /* SET_OCCURRENCE; */
5105 goto cont;
5106 }
5107 }
5108 STATE = 0;
5109
5110 /*
5111 * Then act accordingly at the parent level
5112 */
5113 RESET_OCCURRENCE;
5114 if (CONT->parent == NULL)
5115 break;
5116
5117 switch (CONT->parent->type) {
5118 case XML_ELEMENT_CONTENT_PCDATA:
5119 DEBUG_VALID_MSG("Error: parent pcdata");
5120 return(-1);
5121 case XML_ELEMENT_CONTENT_ELEMENT:
5122 DEBUG_VALID_MSG("Error: parent element");
5123 return(-1);
5124 case XML_ELEMENT_CONTENT_OR:
5125 if (ret == 1) {
5126 DEBUG_VALID_MSG("Or succeeded");
5127 CONT = CONT->parent;
5128 DEPTH--;
5129 } else {
5130 DEBUG_VALID_MSG("Or failed");
5131 CONT = CONT->parent;
5132 DEPTH--;
5133 }
5134 break;
5135 case XML_ELEMENT_CONTENT_SEQ:
5136 if (ret == 0) {
5137 DEBUG_VALID_MSG("Sequence failed");
5138 CONT = CONT->parent;
5139 DEPTH--;
5140 } else if (CONT == CONT->parent->c1) {
5141 DEBUG_VALID_MSG("Sequence testing 2nd branch");
5142 CONT = CONT->parent->c2;
5143 goto cont;
5144 } else {
5145 DEBUG_VALID_MSG("Sequence succeeded");
5146 CONT = CONT->parent;
5147 DEPTH--;
5148 }
5149 }
5150 }
5151 if (NODE != NULL) {
5152 xmlNodePtr cur;
5153
5154 cur = ctxt->vstate->node;
5155 DEBUG_VALID_MSG("Failed, remaining input, rollback");
5156 if (vstateVPop(ctxt) < 0 ) {
5157 DEBUG_VALID_MSG("exhaustion, failed");
5158 return(0);
5159 }
5160 if (cur != ctxt->vstate->node)
5161 determinist = -3;
5162 goto cont;
5163 }
5164 if (ret == 0) {
5165 xmlNodePtr cur;
5166
5167 cur = ctxt->vstate->node;
5168 DEBUG_VALID_MSG("Failure, rollback");
5169 if (vstateVPop(ctxt) < 0 ) {
5170 DEBUG_VALID_MSG("exhaustion, failed");
5171 return(0);
5172 }
5173 if (cur != ctxt->vstate->node)
5174 determinist = -3;
5175 goto cont;
5176 }
5177 return(determinist);
5178 }
5179 #endif
5180
5181 /**
5182 * xmlSnprintfElements:
5183 * @buf: an output buffer
5184 * @size: the size of the buffer
5185 * @content: An element
5186 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5187 *
5188 * This will dump the list of elements to the buffer
5189 * Intended just for the debug routine
5190 */
5191 static void
xmlSnprintfElements(char * buf,int size,xmlNodePtr node,int glob)5192 xmlSnprintfElements(char *buf, int size, xmlNodePtr node, int glob) {
5193 xmlNodePtr cur;
5194 int len;
5195
5196 if (node == NULL) return;
5197 if (glob) strcat(buf, "(");
5198 cur = node;
5199 while (cur != NULL) {
5200 len = strlen(buf);
5201 if (size - len < 50) {
5202 if ((size - len > 4) && (buf[len - 1] != '.'))
5203 strcat(buf, " ...");
5204 return;
5205 }
5206 switch (cur->type) {
5207 case XML_ELEMENT_NODE:
5208 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5209 if (size - len < xmlStrlen(cur->ns->prefix) + 10) {
5210 if ((size - len > 4) && (buf[len - 1] != '.'))
5211 strcat(buf, " ...");
5212 return;
5213 }
5214 strcat(buf, (char *) cur->ns->prefix);
5215 strcat(buf, ":");
5216 }
5217 if (size - len < xmlStrlen(cur->name) + 10) {
5218 if ((size - len > 4) && (buf[len - 1] != '.'))
5219 strcat(buf, " ...");
5220 return;
5221 }
5222 strcat(buf, (char *) cur->name);
5223 if (cur->next != NULL)
5224 strcat(buf, " ");
5225 break;
5226 case XML_TEXT_NODE:
5227 if (xmlIsBlankNode(cur))
5228 break;
5229 case XML_CDATA_SECTION_NODE:
5230 case XML_ENTITY_REF_NODE:
5231 strcat(buf, "CDATA");
5232 if (cur->next != NULL)
5233 strcat(buf, " ");
5234 break;
5235 case XML_ATTRIBUTE_NODE:
5236 case XML_DOCUMENT_NODE:
5237 #ifdef LIBXML_DOCB_ENABLED
5238 case XML_DOCB_DOCUMENT_NODE:
5239 #endif
5240 case XML_HTML_DOCUMENT_NODE:
5241 case XML_DOCUMENT_TYPE_NODE:
5242 case XML_DOCUMENT_FRAG_NODE:
5243 case XML_NOTATION_NODE:
5244 case XML_NAMESPACE_DECL:
5245 strcat(buf, "???");
5246 if (cur->next != NULL)
5247 strcat(buf, " ");
5248 break;
5249 case XML_ENTITY_NODE:
5250 case XML_PI_NODE:
5251 case XML_DTD_NODE:
5252 case XML_COMMENT_NODE:
5253 case XML_ELEMENT_DECL:
5254 case XML_ATTRIBUTE_DECL:
5255 case XML_ENTITY_DECL:
5256 case XML_XINCLUDE_START:
5257 case XML_XINCLUDE_END:
5258 break;
5259 }
5260 cur = cur->next;
5261 }
5262 if (glob) strcat(buf, ")");
5263 }
5264
5265 /**
5266 * xmlValidateElementContent:
5267 * @ctxt: the validation context
5268 * @child: the child list
5269 * @elemDecl: pointer to the element declaration
5270 * @warn: emit the error message
5271 * @parent: the parent element (for error reporting)
5272 *
5273 * Try to validate the content model of an element
5274 *
5275 * returns 1 if valid or 0 if not and -1 in case of error
5276 */
5277
5278 static int
xmlValidateElementContent(xmlValidCtxtPtr ctxt,xmlNodePtr child,xmlElementPtr elemDecl,int warn,xmlNodePtr parent)5279 xmlValidateElementContent(xmlValidCtxtPtr ctxt, xmlNodePtr child,
5280 xmlElementPtr elemDecl, int warn, xmlNodePtr parent) {
5281 int ret = 1;
5282 #ifndef LIBXML_REGEXP_ENABLED
5283 xmlNodePtr repl = NULL, last = NULL, tmp;
5284 #endif
5285 xmlNodePtr cur;
5286 xmlElementContentPtr cont;
5287 const xmlChar *name;
5288
5289 if (elemDecl == NULL)
5290 return(-1);
5291 cont = elemDecl->content;
5292 name = elemDecl->name;
5293
5294 #ifdef LIBXML_REGEXP_ENABLED
5295 /* Build the regexp associated to the content model */
5296 if (elemDecl->contModel == NULL)
5297 ret = xmlValidBuildContentModel(ctxt, elemDecl);
5298 if (elemDecl->contModel == NULL) {
5299 return(-1);
5300 } else {
5301 xmlRegExecCtxtPtr exec;
5302
5303 if (!xmlRegexpIsDeterminist(elemDecl->contModel)) {
5304 return(-1);
5305 }
5306 ctxt->nodeMax = 0;
5307 ctxt->nodeNr = 0;
5308 ctxt->nodeTab = NULL;
5309 exec = xmlRegNewExecCtxt(elemDecl->contModel, NULL, NULL);
5310 if (exec != NULL) {
5311 cur = child;
5312 while (cur != NULL) {
5313 switch (cur->type) {
5314 case XML_ENTITY_REF_NODE:
5315 /*
5316 * Push the current node to be able to roll back
5317 * and process within the entity
5318 */
5319 if ((cur->children != NULL) &&
5320 (cur->children->children != NULL)) {
5321 nodeVPush(ctxt, cur);
5322 cur = cur->children->children;
5323 continue;
5324 }
5325 break;
5326 case XML_TEXT_NODE:
5327 if (xmlIsBlankNode(cur))
5328 break;
5329 ret = 0;
5330 goto fail;
5331 case XML_CDATA_SECTION_NODE:
5332 /* TODO */
5333 ret = 0;
5334 goto fail;
5335 case XML_ELEMENT_NODE:
5336 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
5337 xmlChar fn[50];
5338 xmlChar *fullname;
5339
5340 fullname = xmlBuildQName(cur->name,
5341 cur->ns->prefix, fn, 50);
5342 if (fullname == NULL) {
5343 ret = -1;
5344 goto fail;
5345 }
5346 ret = xmlRegExecPushString(exec, fullname, NULL);
5347 if ((fullname != fn) && (fullname != cur->name))
5348 xmlFree(fullname);
5349 } else {
5350 ret = xmlRegExecPushString(exec, cur->name, NULL);
5351 }
5352 break;
5353 default:
5354 break;
5355 }
5356 /*
5357 * Switch to next element
5358 */
5359 cur = cur->next;
5360 while (cur == NULL) {
5361 cur = nodeVPop(ctxt);
5362 if (cur == NULL)
5363 break;
5364 cur = cur->next;
5365 }
5366 }
5367 ret = xmlRegExecPushString(exec, NULL, NULL);
5368 fail:
5369 xmlRegFreeExecCtxt(exec);
5370 }
5371 }
5372 #else /* LIBXML_REGEXP_ENABLED */
5373 /*
5374 * Allocate the stack
5375 */
5376 ctxt->vstateMax = 8;
5377 ctxt->vstateTab = (xmlValidState *) xmlMalloc(
5378 ctxt->vstateMax * sizeof(ctxt->vstateTab[0]));
5379 if (ctxt->vstateTab == NULL) {
5380 xmlVErrMemory(ctxt, "malloc failed");
5381 return(-1);
5382 }
5383 /*
5384 * The first entry in the stack is reserved to the current state
5385 */
5386 ctxt->nodeMax = 0;
5387 ctxt->nodeNr = 0;
5388 ctxt->nodeTab = NULL;
5389 ctxt->vstate = &ctxt->vstateTab[0];
5390 ctxt->vstateNr = 1;
5391 CONT = cont;
5392 NODE = child;
5393 DEPTH = 0;
5394 OCCURS = 0;
5395 STATE = 0;
5396 ret = xmlValidateElementType(ctxt);
5397 if ((ret == -3) && (warn)) {
5398 xmlErrValidWarning(ctxt, child, XML_DTD_CONTENT_NOT_DETERMINIST,
5399 "Content model for Element %s is ambiguous\n",
5400 name, NULL, NULL);
5401 } else if (ret == -2) {
5402 /*
5403 * An entities reference appeared at this level.
5404 * Buid a minimal representation of this node content
5405 * sufficient to run the validation process on it
5406 */
5407 DEBUG_VALID_MSG("Found an entity reference, linearizing");
5408 cur = child;
5409 while (cur != NULL) {
5410 switch (cur->type) {
5411 case XML_ENTITY_REF_NODE:
5412 /*
5413 * Push the current node to be able to roll back
5414 * and process within the entity
5415 */
5416 if ((cur->children != NULL) &&
5417 (cur->children->children != NULL)) {
5418 nodeVPush(ctxt, cur);
5419 cur = cur->children->children;
5420 continue;
5421 }
5422 break;
5423 case XML_TEXT_NODE:
5424 if (xmlIsBlankNode(cur))
5425 break;
5426 /* no break on purpose */
5427 case XML_CDATA_SECTION_NODE:
5428 /* no break on purpose */
5429 case XML_ELEMENT_NODE:
5430 /*
5431 * Allocate a new node and minimally fills in
5432 * what's required
5433 */
5434 tmp = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
5435 if (tmp == NULL) {
5436 xmlVErrMemory(ctxt, "malloc failed");
5437 xmlFreeNodeList(repl);
5438 ret = -1;
5439 goto done;
5440 }
5441 tmp->type = cur->type;
5442 tmp->name = cur->name;
5443 tmp->ns = cur->ns;
5444 tmp->next = NULL;
5445 tmp->content = NULL;
5446 if (repl == NULL)
5447 repl = last = tmp;
5448 else {
5449 last->next = tmp;
5450 last = tmp;
5451 }
5452 if (cur->type == XML_CDATA_SECTION_NODE) {
5453 /*
5454 * E59 spaces in CDATA does not match the
5455 * nonterminal S
5456 */
5457 tmp->content = xmlStrdup(BAD_CAST "CDATA");
5458 }
5459 break;
5460 default:
5461 break;
5462 }
5463 /*
5464 * Switch to next element
5465 */
5466 cur = cur->next;
5467 while (cur == NULL) {
5468 cur = nodeVPop(ctxt);
5469 if (cur == NULL)
5470 break;
5471 cur = cur->next;
5472 }
5473 }
5474
5475 /*
5476 * Relaunch the validation
5477 */
5478 ctxt->vstate = &ctxt->vstateTab[0];
5479 ctxt->vstateNr = 1;
5480 CONT = cont;
5481 NODE = repl;
5482 DEPTH = 0;
5483 OCCURS = 0;
5484 STATE = 0;
5485 ret = xmlValidateElementType(ctxt);
5486 }
5487 #endif /* LIBXML_REGEXP_ENABLED */
5488 if ((warn) && ((ret != 1) && (ret != -3))) {
5489 if (ctxt != NULL) {
5490 char expr[5000];
5491 char list[5000];
5492
5493 expr[0] = 0;
5494 xmlSnprintfElementContent(&expr[0], 5000, cont, 1);
5495 list[0] = 0;
5496 #ifndef LIBXML_REGEXP_ENABLED
5497 if (repl != NULL)
5498 xmlSnprintfElements(&list[0], 5000, repl, 1);
5499 else
5500 #endif /* LIBXML_REGEXP_ENABLED */
5501 xmlSnprintfElements(&list[0], 5000, child, 1);
5502
5503 if (name != NULL) {
5504 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5505 "Element %s content does not follow the DTD, expecting %s, got %s\n",
5506 name, BAD_CAST expr, BAD_CAST list);
5507 } else {
5508 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5509 "Element content does not follow the DTD, expecting %s, got %s\n",
5510 BAD_CAST expr, BAD_CAST list, NULL);
5511 }
5512 } else {
5513 if (name != NULL) {
5514 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5515 "Element %s content does not follow the DTD\n",
5516 name, NULL, NULL);
5517 } else {
5518 xmlErrValidNode(ctxt, parent, XML_DTD_CONTENT_MODEL,
5519 "Element content does not follow the DTD\n",
5520 NULL, NULL, NULL);
5521 }
5522 }
5523 ret = 0;
5524 }
5525 if (ret == -3)
5526 ret = 1;
5527
5528 #ifndef LIBXML_REGEXP_ENABLED
5529 done:
5530 /*
5531 * Deallocate the copy if done, and free up the validation stack
5532 */
5533 while (repl != NULL) {
5534 tmp = repl->next;
5535 xmlFree(repl);
5536 repl = tmp;
5537 }
5538 ctxt->vstateMax = 0;
5539 if (ctxt->vstateTab != NULL) {
5540 xmlFree(ctxt->vstateTab);
5541 ctxt->vstateTab = NULL;
5542 }
5543 #endif
5544 ctxt->nodeMax = 0;
5545 ctxt->nodeNr = 0;
5546 if (ctxt->nodeTab != NULL) {
5547 xmlFree(ctxt->nodeTab);
5548 ctxt->nodeTab = NULL;
5549 }
5550 return(ret);
5551
5552 }
5553
5554 /**
5555 * xmlValidateCdataElement:
5556 * @ctxt: the validation context
5557 * @doc: a document instance
5558 * @elem: an element instance
5559 *
5560 * Check that an element follows #CDATA
5561 *
5562 * returns 1 if valid or 0 otherwise
5563 */
5564 static int
xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem)5565 xmlValidateOneCdataElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5566 xmlNodePtr elem) {
5567 int ret = 1;
5568 xmlNodePtr cur, child;
5569
5570 if ((ctxt == NULL) || (doc == NULL) || (elem == NULL))
5571 return(0);
5572
5573 child = elem->children;
5574
5575 cur = child;
5576 while (cur != NULL) {
5577 switch (cur->type) {
5578 case XML_ENTITY_REF_NODE:
5579 /*
5580 * Push the current node to be able to roll back
5581 * and process within the entity
5582 */
5583 if ((cur->children != NULL) &&
5584 (cur->children->children != NULL)) {
5585 nodeVPush(ctxt, cur);
5586 cur = cur->children->children;
5587 continue;
5588 }
5589 break;
5590 case XML_COMMENT_NODE:
5591 case XML_PI_NODE:
5592 case XML_TEXT_NODE:
5593 case XML_CDATA_SECTION_NODE:
5594 break;
5595 default:
5596 ret = 0;
5597 goto done;
5598 }
5599 /*
5600 * Switch to next element
5601 */
5602 cur = cur->next;
5603 while (cur == NULL) {
5604 cur = nodeVPop(ctxt);
5605 if (cur == NULL)
5606 break;
5607 cur = cur->next;
5608 }
5609 }
5610 done:
5611 ctxt->nodeMax = 0;
5612 ctxt->nodeNr = 0;
5613 if (ctxt->nodeTab != NULL) {
5614 xmlFree(ctxt->nodeTab);
5615 ctxt->nodeTab = NULL;
5616 }
5617 return(ret);
5618 }
5619
5620 /**
5621 * xmlValidateCheckMixed:
5622 * @ctxt: the validation context
5623 * @cont: the mixed content model
5624 * @qname: the qualified name as appearing in the serialization
5625 *
5626 * Check if the given node is part of the content model.
5627 *
5628 * Returns 1 if yes, 0 if no, -1 in case of error
5629 */
5630 static int
xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,xmlElementContentPtr cont,const xmlChar * qname)5631 xmlValidateCheckMixed(xmlValidCtxtPtr ctxt,
5632 xmlElementContentPtr cont, const xmlChar *qname) {
5633 const xmlChar *name;
5634 int plen;
5635 name = xmlSplitQName3(qname, &plen);
5636
5637 if (name == NULL) {
5638 while (cont != NULL) {
5639 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5640 if ((cont->prefix == NULL) && (xmlStrEqual(cont->name, qname)))
5641 return(1);
5642 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5643 (cont->c1 != NULL) &&
5644 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5645 if ((cont->c1->prefix == NULL) &&
5646 (xmlStrEqual(cont->c1->name, qname)))
5647 return(1);
5648 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5649 (cont->c1 == NULL) ||
5650 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5651 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
5652 "Internal: MIXED struct corrupted\n",
5653 NULL);
5654 break;
5655 }
5656 cont = cont->c2;
5657 }
5658 } else {
5659 while (cont != NULL) {
5660 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
5661 if ((cont->prefix != NULL) &&
5662 (xmlStrncmp(cont->prefix, qname, plen) == 0) &&
5663 (xmlStrEqual(cont->name, name)))
5664 return(1);
5665 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
5666 (cont->c1 != NULL) &&
5667 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
5668 if ((cont->c1->prefix != NULL) &&
5669 (xmlStrncmp(cont->c1->prefix, qname, plen) == 0) &&
5670 (xmlStrEqual(cont->c1->name, name)))
5671 return(1);
5672 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
5673 (cont->c1 == NULL) ||
5674 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
5675 xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
5676 "Internal: MIXED struct corrupted\n",
5677 NULL);
5678 break;
5679 }
5680 cont = cont->c2;
5681 }
5682 }
5683 return(0);
5684 }
5685
5686 /**
5687 * xmlValidGetElemDecl:
5688 * @ctxt: the validation context
5689 * @doc: a document instance
5690 * @elem: an element instance
5691 * @extsubset: pointer, (out) indicate if the declaration was found
5692 * in the external subset.
5693 *
5694 * Finds a declaration associated to an element in the document.
5695 *
5696 * returns the pointer to the declaration or NULL if not found.
5697 */
5698 static xmlElementPtr
xmlValidGetElemDecl(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem,int * extsubset)5699 xmlValidGetElemDecl(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5700 xmlNodePtr elem, int *extsubset) {
5701 xmlElementPtr elemDecl = NULL;
5702 const xmlChar *prefix = NULL;
5703
5704 if ((ctxt == NULL) || (doc == NULL) ||
5705 (elem == NULL) || (elem->name == NULL))
5706 return(NULL);
5707 if (extsubset != NULL)
5708 *extsubset = 0;
5709
5710 /*
5711 * Fetch the declaration for the qualified name
5712 */
5713 if ((elem->ns != NULL) && (elem->ns->prefix != NULL))
5714 prefix = elem->ns->prefix;
5715
5716 if (prefix != NULL) {
5717 elemDecl = xmlGetDtdQElementDesc(doc->intSubset,
5718 elem->name, prefix);
5719 if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5720 elemDecl = xmlGetDtdQElementDesc(doc->extSubset,
5721 elem->name, prefix);
5722 if ((elemDecl != NULL) && (extsubset != NULL))
5723 *extsubset = 1;
5724 }
5725 }
5726
5727 /*
5728 * Fetch the declaration for the non qualified name
5729 * This is "non-strict" validation should be done on the
5730 * full QName but in that case being flexible makes sense.
5731 */
5732 if (elemDecl == NULL) {
5733 elemDecl = xmlGetDtdElementDesc(doc->intSubset, elem->name);
5734 if ((elemDecl == NULL) && (doc->extSubset != NULL)) {
5735 elemDecl = xmlGetDtdElementDesc(doc->extSubset, elem->name);
5736 if ((elemDecl != NULL) && (extsubset != NULL))
5737 *extsubset = 1;
5738 }
5739 }
5740 if (elemDecl == NULL) {
5741 xmlErrValidNode(ctxt, elem,
5742 XML_DTD_UNKNOWN_ELEM,
5743 "No declaration for element %s\n",
5744 elem->name, NULL, NULL);
5745 }
5746 return(elemDecl);
5747 }
5748
5749 #ifdef LIBXML_REGEXP_ENABLED
5750 /**
5751 * xmlValidatePushElement:
5752 * @ctxt: the validation context
5753 * @doc: a document instance
5754 * @elem: an element instance
5755 * @qname: the qualified name as appearing in the serialization
5756 *
5757 * Push a new element start on the validation stack.
5758 *
5759 * returns 1 if no validation problem was found or 0 otherwise
5760 */
5761 int
xmlValidatePushElement(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem,const xmlChar * qname)5762 xmlValidatePushElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5763 xmlNodePtr elem, const xmlChar *qname) {
5764 int ret = 1;
5765 xmlElementPtr eDecl;
5766 int extsubset = 0;
5767
5768 if (ctxt == NULL)
5769 return(0);
5770 /* printf("PushElem %s\n", qname); */
5771 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5772 xmlValidStatePtr state = ctxt->vstate;
5773 xmlElementPtr elemDecl;
5774
5775 /*
5776 * Check the new element agaisnt the content model of the new elem.
5777 */
5778 if (state->elemDecl != NULL) {
5779 elemDecl = state->elemDecl;
5780
5781 switch(elemDecl->etype) {
5782 case XML_ELEMENT_TYPE_UNDEFINED:
5783 ret = 0;
5784 break;
5785 case XML_ELEMENT_TYPE_EMPTY:
5786 xmlErrValidNode(ctxt, state->node,
5787 XML_DTD_NOT_EMPTY,
5788 "Element %s was declared EMPTY this one has content\n",
5789 state->node->name, NULL, NULL);
5790 ret = 0;
5791 break;
5792 case XML_ELEMENT_TYPE_ANY:
5793 /* I don't think anything is required then */
5794 break;
5795 case XML_ELEMENT_TYPE_MIXED:
5796 /* simple case of declared as #PCDATA */
5797 if ((elemDecl->content != NULL) &&
5798 (elemDecl->content->type ==
5799 XML_ELEMENT_CONTENT_PCDATA)) {
5800 xmlErrValidNode(ctxt, state->node,
5801 XML_DTD_NOT_PCDATA,
5802 "Element %s was declared #PCDATA but contains non text nodes\n",
5803 state->node->name, NULL, NULL);
5804 ret = 0;
5805 } else {
5806 ret = xmlValidateCheckMixed(ctxt, elemDecl->content,
5807 qname);
5808 if (ret != 1) {
5809 xmlErrValidNode(ctxt, state->node,
5810 XML_DTD_INVALID_CHILD,
5811 "Element %s is not declared in %s list of possible children\n",
5812 qname, state->node->name, NULL);
5813 }
5814 }
5815 break;
5816 case XML_ELEMENT_TYPE_ELEMENT:
5817 /*
5818 * TODO:
5819 * VC: Standalone Document Declaration
5820 * - element types with element content, if white space
5821 * occurs directly within any instance of those types.
5822 */
5823 if (state->exec != NULL) {
5824 ret = xmlRegExecPushString(state->exec, qname, NULL);
5825 if (ret < 0) {
5826 xmlErrValidNode(ctxt, state->node,
5827 XML_DTD_CONTENT_MODEL,
5828 "Element %s content does not follow the DTD, Misplaced %s\n",
5829 state->node->name, qname, NULL);
5830 ret = 0;
5831 } else {
5832 ret = 1;
5833 }
5834 }
5835 break;
5836 }
5837 }
5838 }
5839 eDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
5840 vstateVPush(ctxt, eDecl, elem);
5841 return(ret);
5842 }
5843
5844 /**
5845 * xmlValidatePushCData:
5846 * @ctxt: the validation context
5847 * @data: some character data read
5848 * @len: the lenght of the data
5849 *
5850 * check the CData parsed for validation in the current stack
5851 *
5852 * returns 1 if no validation problem was found or 0 otherwise
5853 */
5854 int
xmlValidatePushCData(xmlValidCtxtPtr ctxt,const xmlChar * data,int len)5855 xmlValidatePushCData(xmlValidCtxtPtr ctxt, const xmlChar *data, int len) {
5856 int ret = 1;
5857
5858 /* printf("CDATA %s %d\n", data, len); */
5859 if (ctxt == NULL)
5860 return(0);
5861 if (len <= 0)
5862 return(ret);
5863 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5864 xmlValidStatePtr state = ctxt->vstate;
5865 xmlElementPtr elemDecl;
5866
5867 /*
5868 * Check the new element agaisnt the content model of the new elem.
5869 */
5870 if (state->elemDecl != NULL) {
5871 elemDecl = state->elemDecl;
5872
5873 switch(elemDecl->etype) {
5874 case XML_ELEMENT_TYPE_UNDEFINED:
5875 ret = 0;
5876 break;
5877 case XML_ELEMENT_TYPE_EMPTY:
5878 xmlErrValidNode(ctxt, state->node,
5879 XML_DTD_NOT_EMPTY,
5880 "Element %s was declared EMPTY this one has content\n",
5881 state->node->name, NULL, NULL);
5882 ret = 0;
5883 break;
5884 case XML_ELEMENT_TYPE_ANY:
5885 break;
5886 case XML_ELEMENT_TYPE_MIXED:
5887 break;
5888 case XML_ELEMENT_TYPE_ELEMENT:
5889 if (len > 0) {
5890 int i;
5891
5892 for (i = 0;i < len;i++) {
5893 if (!IS_BLANK_CH(data[i])) {
5894 xmlErrValidNode(ctxt, state->node,
5895 XML_DTD_CONTENT_MODEL,
5896 "Element %s content does not follow the DTD, Text not allowed\n",
5897 state->node->name, NULL, NULL);
5898 ret = 0;
5899 goto done;
5900 }
5901 }
5902 /*
5903 * TODO:
5904 * VC: Standalone Document Declaration
5905 * element types with element content, if white space
5906 * occurs directly within any instance of those types.
5907 */
5908 }
5909 break;
5910 }
5911 }
5912 }
5913 done:
5914 return(ret);
5915 }
5916
5917 /**
5918 * xmlValidatePopElement:
5919 * @ctxt: the validation context
5920 * @doc: a document instance
5921 * @elem: an element instance
5922 * @qname: the qualified name as appearing in the serialization
5923 *
5924 * Pop the element end from the validation stack.
5925 *
5926 * returns 1 if no validation problem was found or 0 otherwise
5927 */
5928 int
xmlValidatePopElement(xmlValidCtxtPtr ctxt,xmlDocPtr doc ATTRIBUTE_UNUSED,xmlNodePtr elem ATTRIBUTE_UNUSED,const xmlChar * qname ATTRIBUTE_UNUSED)5929 xmlValidatePopElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc ATTRIBUTE_UNUSED,
5930 xmlNodePtr elem ATTRIBUTE_UNUSED,
5931 const xmlChar *qname ATTRIBUTE_UNUSED) {
5932 int ret = 1;
5933
5934 if (ctxt == NULL)
5935 return(0);
5936 /* printf("PopElem %s\n", qname); */
5937 if ((ctxt->vstateNr > 0) && (ctxt->vstate != NULL)) {
5938 xmlValidStatePtr state = ctxt->vstate;
5939 xmlElementPtr elemDecl;
5940
5941 /*
5942 * Check the new element agaisnt the content model of the new elem.
5943 */
5944 if (state->elemDecl != NULL) {
5945 elemDecl = state->elemDecl;
5946
5947 if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) {
5948 if (state->exec != NULL) {
5949 ret = xmlRegExecPushString(state->exec, NULL, NULL);
5950 if (ret == 0) {
5951 xmlErrValidNode(ctxt, state->node,
5952 XML_DTD_CONTENT_MODEL,
5953 "Element %s content does not follow the DTD, Expecting more child\n",
5954 state->node->name, NULL,NULL);
5955 } else {
5956 /*
5957 * previous validation errors should not generate
5958 * a new one here
5959 */
5960 ret = 1;
5961 }
5962 }
5963 }
5964 }
5965 vstateVPop(ctxt);
5966 }
5967 return(ret);
5968 }
5969 #endif /* LIBXML_REGEXP_ENABLED */
5970
5971 /**
5972 * xmlValidateOneElement:
5973 * @ctxt: the validation context
5974 * @doc: a document instance
5975 * @elem: an element instance
5976 *
5977 * Try to validate a single element and it's attributes,
5978 * basically it does the following checks as described by the
5979 * XML-1.0 recommendation:
5980 * - [ VC: Element Valid ]
5981 * - [ VC: Required Attribute ]
5982 * Then call xmlValidateOneAttribute() for each attribute present.
5983 *
5984 * The ID/IDREF checkings are done separately
5985 *
5986 * returns 1 if valid or 0 otherwise
5987 */
5988
5989 int
xmlValidateOneElement(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem)5990 xmlValidateOneElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc,
5991 xmlNodePtr elem) {
5992 xmlElementPtr elemDecl = NULL;
5993 xmlElementContentPtr cont;
5994 xmlAttributePtr attr;
5995 xmlNodePtr child;
5996 int ret = 1, tmp;
5997 const xmlChar *name;
5998 int extsubset = 0;
5999
6000 CHECK_DTD;
6001
6002 if (elem == NULL) return(0);
6003 switch (elem->type) {
6004 case XML_ATTRIBUTE_NODE:
6005 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6006 "Attribute element not expected\n", NULL, NULL ,NULL);
6007 return(0);
6008 case XML_TEXT_NODE:
6009 if (elem->children != NULL) {
6010 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6011 "Text element has children !\n",
6012 NULL,NULL,NULL);
6013 return(0);
6014 }
6015 if (elem->ns != NULL) {
6016 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6017 "Text element has namespace !\n",
6018 NULL,NULL,NULL);
6019 return(0);
6020 }
6021 if (elem->content == NULL) {
6022 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6023 "Text element has no content !\n",
6024 NULL,NULL,NULL);
6025 return(0);
6026 }
6027 return(1);
6028 case XML_XINCLUDE_START:
6029 case XML_XINCLUDE_END:
6030 return(1);
6031 case XML_CDATA_SECTION_NODE:
6032 case XML_ENTITY_REF_NODE:
6033 case XML_PI_NODE:
6034 case XML_COMMENT_NODE:
6035 return(1);
6036 case XML_ENTITY_NODE:
6037 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6038 "Entity element not expected\n", NULL, NULL ,NULL);
6039 return(0);
6040 case XML_NOTATION_NODE:
6041 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6042 "Notation element not expected\n", NULL, NULL ,NULL);
6043 return(0);
6044 case XML_DOCUMENT_NODE:
6045 case XML_DOCUMENT_TYPE_NODE:
6046 case XML_DOCUMENT_FRAG_NODE:
6047 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6048 "Document element not expected\n", NULL, NULL ,NULL);
6049 return(0);
6050 case XML_HTML_DOCUMENT_NODE:
6051 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6052 "HTML Document not expected\n", NULL, NULL ,NULL);
6053 return(0);
6054 case XML_ELEMENT_NODE:
6055 break;
6056 default:
6057 xmlErrValidNode(ctxt, elem, XML_ERR_INTERNAL_ERROR,
6058 "unknown element type\n", NULL, NULL ,NULL);
6059 return(0);
6060 }
6061
6062 /*
6063 * Fetch the declaration
6064 */
6065 elemDecl = xmlValidGetElemDecl(ctxt, doc, elem, &extsubset);
6066 if (elemDecl == NULL)
6067 return(0);
6068
6069 /*
6070 * If vstateNr is not zero that means continuous validation is
6071 * activated, do not try to check the content model at that level.
6072 */
6073 if (ctxt->vstateNr == 0) {
6074 /* Check that the element content matches the definition */
6075 switch (elemDecl->etype) {
6076 case XML_ELEMENT_TYPE_UNDEFINED:
6077 xmlErrValidNode(ctxt, elem, XML_DTD_UNKNOWN_ELEM,
6078 "No declaration for element %s\n",
6079 elem->name, NULL, NULL);
6080 return(0);
6081 case XML_ELEMENT_TYPE_EMPTY:
6082 if (elem->children != NULL) {
6083 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_EMPTY,
6084 "Element %s was declared EMPTY this one has content\n",
6085 elem->name, NULL, NULL);
6086 ret = 0;
6087 }
6088 break;
6089 case XML_ELEMENT_TYPE_ANY:
6090 /* I don't think anything is required then */
6091 break;
6092 case XML_ELEMENT_TYPE_MIXED:
6093
6094 /* simple case of declared as #PCDATA */
6095 if ((elemDecl->content != NULL) &&
6096 (elemDecl->content->type == XML_ELEMENT_CONTENT_PCDATA)) {
6097 ret = xmlValidateOneCdataElement(ctxt, doc, elem);
6098 if (!ret) {
6099 xmlErrValidNode(ctxt, elem, XML_DTD_NOT_PCDATA,
6100 "Element %s was declared #PCDATA but contains non text nodes\n",
6101 elem->name, NULL, NULL);
6102 }
6103 break;
6104 }
6105 child = elem->children;
6106 /* Hum, this start to get messy */
6107 while (child != NULL) {
6108 if (child->type == XML_ELEMENT_NODE) {
6109 name = child->name;
6110 if ((child->ns != NULL) && (child->ns->prefix != NULL)) {
6111 xmlChar fn[50];
6112 xmlChar *fullname;
6113
6114 fullname = xmlBuildQName(child->name, child->ns->prefix,
6115 fn, 50);
6116 if (fullname == NULL)
6117 return(0);
6118 cont = elemDecl->content;
6119 while (cont != NULL) {
6120 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6121 if (xmlStrEqual(cont->name, fullname))
6122 break;
6123 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6124 (cont->c1 != NULL) &&
6125 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)){
6126 if (xmlStrEqual(cont->c1->name, fullname))
6127 break;
6128 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6129 (cont->c1 == NULL) ||
6130 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)){
6131 xmlErrValid(NULL, XML_DTD_MIXED_CORRUPT,
6132 "Internal: MIXED struct corrupted\n",
6133 NULL);
6134 break;
6135 }
6136 cont = cont->c2;
6137 }
6138 if ((fullname != fn) && (fullname != child->name))
6139 xmlFree(fullname);
6140 if (cont != NULL)
6141 goto child_ok;
6142 }
6143 cont = elemDecl->content;
6144 while (cont != NULL) {
6145 if (cont->type == XML_ELEMENT_CONTENT_ELEMENT) {
6146 if (xmlStrEqual(cont->name, name)) break;
6147 } else if ((cont->type == XML_ELEMENT_CONTENT_OR) &&
6148 (cont->c1 != NULL) &&
6149 (cont->c1->type == XML_ELEMENT_CONTENT_ELEMENT)) {
6150 if (xmlStrEqual(cont->c1->name, name)) break;
6151 } else if ((cont->type != XML_ELEMENT_CONTENT_OR) ||
6152 (cont->c1 == NULL) ||
6153 (cont->c1->type != XML_ELEMENT_CONTENT_PCDATA)) {
6154 xmlErrValid(ctxt, XML_DTD_MIXED_CORRUPT,
6155 "Internal: MIXED struct corrupted\n",
6156 NULL);
6157 break;
6158 }
6159 cont = cont->c2;
6160 }
6161 if (cont == NULL) {
6162 xmlErrValidNode(ctxt, elem, XML_DTD_INVALID_CHILD,
6163 "Element %s is not declared in %s list of possible children\n",
6164 name, elem->name, NULL);
6165 ret = 0;
6166 }
6167 }
6168 child_ok:
6169 child = child->next;
6170 }
6171 break;
6172 case XML_ELEMENT_TYPE_ELEMENT:
6173 if ((doc->standalone == 1) && (extsubset == 1)) {
6174 /*
6175 * VC: Standalone Document Declaration
6176 * - element types with element content, if white space
6177 * occurs directly within any instance of those types.
6178 */
6179 child = elem->children;
6180 while (child != NULL) {
6181 if (child->type == XML_TEXT_NODE) {
6182 const xmlChar *content = child->content;
6183
6184 while (IS_BLANK_CH(*content))
6185 content++;
6186 if (*content == 0) {
6187 xmlErrValidNode(ctxt, elem,
6188 XML_DTD_STANDALONE_WHITE_SPACE,
6189 "standalone: %s declared in the external subset contains white spaces nodes\n",
6190 elem->name, NULL, NULL);
6191 ret = 0;
6192 break;
6193 }
6194 }
6195 child =child->next;
6196 }
6197 }
6198 child = elem->children;
6199 cont = elemDecl->content;
6200 tmp = xmlValidateElementContent(ctxt, child, elemDecl, 1, elem);
6201 if (tmp <= 0)
6202 ret = tmp;
6203 break;
6204 }
6205 } /* not continuous */
6206
6207 /* [ VC: Required Attribute ] */
6208 attr = elemDecl->attributes;
6209 while (attr != NULL) {
6210 if (attr->def == XML_ATTRIBUTE_REQUIRED) {
6211 int qualified = -1;
6212
6213 if ((attr->prefix == NULL) &&
6214 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6215 xmlNsPtr ns;
6216
6217 ns = elem->nsDef;
6218 while (ns != NULL) {
6219 if (ns->prefix == NULL)
6220 goto found;
6221 ns = ns->next;
6222 }
6223 } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6224 xmlNsPtr ns;
6225
6226 ns = elem->nsDef;
6227 while (ns != NULL) {
6228 if (xmlStrEqual(attr->name, ns->prefix))
6229 goto found;
6230 ns = ns->next;
6231 }
6232 } else {
6233 xmlAttrPtr attrib;
6234
6235 attrib = elem->properties;
6236 while (attrib != NULL) {
6237 if (xmlStrEqual(attrib->name, attr->name)) {
6238 if (attr->prefix != NULL) {
6239 xmlNsPtr nameSpace = attrib->ns;
6240
6241 if (nameSpace == NULL)
6242 nameSpace = elem->ns;
6243 /*
6244 * qualified names handling is problematic, having a
6245 * different prefix should be possible but DTDs don't
6246 * allow to define the URI instead of the prefix :-(
6247 */
6248 if (nameSpace == NULL) {
6249 if (qualified < 0)
6250 qualified = 0;
6251 } else if (!xmlStrEqual(nameSpace->prefix,
6252 attr->prefix)) {
6253 if (qualified < 1)
6254 qualified = 1;
6255 } else
6256 goto found;
6257 } else {
6258 /*
6259 * We should allow applications to define namespaces
6260 * for their application even if the DTD doesn't
6261 * carry one, otherwise, basically we would always
6262 * break.
6263 */
6264 goto found;
6265 }
6266 }
6267 attrib = attrib->next;
6268 }
6269 }
6270 if (qualified == -1) {
6271 if (attr->prefix == NULL) {
6272 xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6273 "Element %s does not carry attribute %s\n",
6274 elem->name, attr->name, NULL);
6275 ret = 0;
6276 } else {
6277 xmlErrValidNode(ctxt, elem, XML_DTD_MISSING_ATTRIBUTE,
6278 "Element %s does not carry attribute %s:%s\n",
6279 elem->name, attr->prefix,attr->name);
6280 ret = 0;
6281 }
6282 } else if (qualified == 0) {
6283 xmlErrValidWarning(ctxt, elem, XML_DTD_NO_PREFIX,
6284 "Element %s required attribute %s:%s has no prefix\n",
6285 elem->name, attr->prefix, attr->name);
6286 } else if (qualified == 1) {
6287 xmlErrValidWarning(ctxt, elem, XML_DTD_DIFFERENT_PREFIX,
6288 "Element %s required attribute %s:%s has different prefix\n",
6289 elem->name, attr->prefix, attr->name);
6290 }
6291 } else if (attr->def == XML_ATTRIBUTE_FIXED) {
6292 /*
6293 * Special tests checking #FIXED namespace declarations
6294 * have the right value since this is not done as an
6295 * attribute checking
6296 */
6297 if ((attr->prefix == NULL) &&
6298 (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) {
6299 xmlNsPtr ns;
6300
6301 ns = elem->nsDef;
6302 while (ns != NULL) {
6303 if (ns->prefix == NULL) {
6304 if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6305 xmlErrValidNode(ctxt, elem,
6306 XML_DTD_ELEM_DEFAULT_NAMESPACE,
6307 "Element %s namespace name for default namespace does not match the DTD\n",
6308 elem->name, NULL, NULL);
6309 ret = 0;
6310 }
6311 goto found;
6312 }
6313 ns = ns->next;
6314 }
6315 } else if (xmlStrEqual(attr->prefix, BAD_CAST "xmlns")) {
6316 xmlNsPtr ns;
6317
6318 ns = elem->nsDef;
6319 while (ns != NULL) {
6320 if (xmlStrEqual(attr->name, ns->prefix)) {
6321 if (!xmlStrEqual(attr->defaultValue, ns->href)) {
6322 xmlErrValidNode(ctxt, elem, XML_DTD_ELEM_NAMESPACE,
6323 "Element %s namespace name for %s does not match the DTD\n",
6324 elem->name, ns->prefix, NULL);
6325 ret = 0;
6326 }
6327 goto found;
6328 }
6329 ns = ns->next;
6330 }
6331 }
6332 }
6333 found:
6334 attr = attr->nexth;
6335 }
6336 return(ret);
6337 }
6338
6339 /**
6340 * xmlValidateRoot:
6341 * @ctxt: the validation context
6342 * @doc: a document instance
6343 *
6344 * Try to validate a the root element
6345 * basically it does the following check as described by the
6346 * XML-1.0 recommendation:
6347 * - [ VC: Root Element Type ]
6348 * it doesn't try to recurse or apply other check to the element
6349 *
6350 * returns 1 if valid or 0 otherwise
6351 */
6352
6353 int
xmlValidateRoot(xmlValidCtxtPtr ctxt,xmlDocPtr doc)6354 xmlValidateRoot(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6355 xmlNodePtr root;
6356 int ret;
6357
6358 if (doc == NULL) return(0);
6359
6360 root = xmlDocGetRootElement(doc);
6361 if ((root == NULL) || (root->name == NULL)) {
6362 xmlErrValid(ctxt, XML_DTD_NO_ROOT,
6363 "no root element\n", NULL);
6364 return(0);
6365 }
6366
6367 /*
6368 * When doing post validation against a separate DTD, those may
6369 * no internal subset has been generated
6370 */
6371 if ((doc->intSubset != NULL) &&
6372 (doc->intSubset->name != NULL)) {
6373 /*
6374 * Check first the document root against the NQName
6375 */
6376 if (!xmlStrEqual(doc->intSubset->name, root->name)) {
6377 if ((root->ns != NULL) && (root->ns->prefix != NULL)) {
6378 xmlChar fn[50];
6379 xmlChar *fullname;
6380
6381 fullname = xmlBuildQName(root->name, root->ns->prefix, fn, 50);
6382 if (fullname == NULL) {
6383 xmlVErrMemory(ctxt, NULL);
6384 return(0);
6385 }
6386 ret = xmlStrEqual(doc->intSubset->name, fullname);
6387 if ((fullname != fn) && (fullname != root->name))
6388 xmlFree(fullname);
6389 if (ret == 1)
6390 goto name_ok;
6391 }
6392 if ((xmlStrEqual(doc->intSubset->name, BAD_CAST "HTML")) &&
6393 (xmlStrEqual(root->name, BAD_CAST "html")))
6394 goto name_ok;
6395 xmlErrValidNode(ctxt, root, XML_DTD_ROOT_NAME,
6396 "root and DTD name do not match '%s' and '%s'\n",
6397 root->name, doc->intSubset->name, NULL);
6398 return(0);
6399 }
6400 }
6401 name_ok:
6402 return(1);
6403 }
6404
6405
6406 /**
6407 * xmlValidateElement:
6408 * @ctxt: the validation context
6409 * @doc: a document instance
6410 * @elem: an element instance
6411 *
6412 * Try to validate the subtree under an element
6413 *
6414 * returns 1 if valid or 0 otherwise
6415 */
6416
6417 int
xmlValidateElement(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlNodePtr elem)6418 xmlValidateElement(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem) {
6419 xmlNodePtr child;
6420 xmlAttrPtr attr;
6421 xmlNsPtr ns;
6422 const xmlChar *value;
6423 int ret = 1;
6424
6425 if (elem == NULL) return(0);
6426
6427 /*
6428 * XInclude elements were added after parsing in the infoset,
6429 * they don't really mean anything validation wise.
6430 */
6431 if ((elem->type == XML_XINCLUDE_START) ||
6432 (elem->type == XML_XINCLUDE_END))
6433 return(1);
6434
6435 CHECK_DTD;
6436
6437 /*
6438 * Entities references have to be handled separately
6439 */
6440 if (elem->type == XML_ENTITY_REF_NODE) {
6441 return(1);
6442 }
6443
6444 ret &= xmlValidateOneElement(ctxt, doc, elem);
6445 if (elem->type == XML_ELEMENT_NODE) {
6446 attr = elem->properties;
6447 while (attr != NULL) {
6448 value = xmlNodeListGetString(doc, attr->children, 0);
6449 ret &= xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
6450 if (value != NULL)
6451 xmlFree((char *)value);
6452 attr= attr->next;
6453 }
6454 ns = elem->nsDef;
6455 while (ns != NULL) {
6456 if (elem->ns == NULL)
6457 ret &= xmlValidateOneNamespace(ctxt, doc, elem, NULL,
6458 ns, ns->href);
6459 else
6460 ret &= xmlValidateOneNamespace(ctxt, doc, elem,
6461 elem->ns->prefix, ns, ns->href);
6462 ns = ns->next;
6463 }
6464 }
6465 child = elem->children;
6466 while (child != NULL) {
6467 ret &= xmlValidateElement(ctxt, doc, child);
6468 child = child->next;
6469 }
6470
6471 return(ret);
6472 }
6473
6474 /**
6475 * xmlValidateRef:
6476 * @ref: A reference to be validated
6477 * @ctxt: Validation context
6478 * @name: Name of ID we are searching for
6479 *
6480 */
6481 static void
xmlValidateRef(xmlRefPtr ref,xmlValidCtxtPtr ctxt,const xmlChar * name)6482 xmlValidateRef(xmlRefPtr ref, xmlValidCtxtPtr ctxt,
6483 const xmlChar *name) {
6484 xmlAttrPtr id;
6485 xmlAttrPtr attr;
6486
6487 if (ref == NULL)
6488 return;
6489 if ((ref->attr == NULL) && (ref->name == NULL))
6490 return;
6491 attr = ref->attr;
6492 if (attr == NULL) {
6493 xmlChar *dup, *str = NULL, *cur, save;
6494
6495 dup = xmlStrdup(name);
6496 if (dup == NULL) {
6497 ctxt->valid = 0;
6498 return;
6499 }
6500 cur = dup;
6501 while (*cur != 0) {
6502 str = cur;
6503 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6504 save = *cur;
6505 *cur = 0;
6506 id = xmlGetID(ctxt->doc, str);
6507 if (id == NULL) {
6508 xmlErrValidNodeNr(ctxt, NULL, XML_DTD_UNKNOWN_ID,
6509 "attribute %s line %d references an unknown ID \"%s\"\n",
6510 ref->name, ref->lineno, str);
6511 ctxt->valid = 0;
6512 }
6513 if (save == 0)
6514 break;
6515 *cur = save;
6516 while (IS_BLANK_CH(*cur)) cur++;
6517 }
6518 xmlFree(dup);
6519 } else if (attr->atype == XML_ATTRIBUTE_IDREF) {
6520 id = xmlGetID(ctxt->doc, name);
6521 if (id == NULL) {
6522 xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6523 "IDREF attribute %s references an unknown ID \"%s\"\n",
6524 attr->name, name, NULL);
6525 ctxt->valid = 0;
6526 }
6527 } else if (attr->atype == XML_ATTRIBUTE_IDREFS) {
6528 xmlChar *dup, *str = NULL, *cur, save;
6529
6530 dup = xmlStrdup(name);
6531 if (dup == NULL) {
6532 xmlVErrMemory(ctxt, "IDREFS split");
6533 ctxt->valid = 0;
6534 return;
6535 }
6536 cur = dup;
6537 while (*cur != 0) {
6538 str = cur;
6539 while ((*cur != 0) && (!IS_BLANK_CH(*cur))) cur++;
6540 save = *cur;
6541 *cur = 0;
6542 id = xmlGetID(ctxt->doc, str);
6543 if (id == NULL) {
6544 xmlErrValidNode(ctxt, attr->parent, XML_DTD_UNKNOWN_ID,
6545 "IDREFS attribute %s references an unknown ID \"%s\"\n",
6546 attr->name, str, NULL);
6547 ctxt->valid = 0;
6548 }
6549 if (save == 0)
6550 break;
6551 *cur = save;
6552 while (IS_BLANK_CH(*cur)) cur++;
6553 }
6554 xmlFree(dup);
6555 }
6556 }
6557
6558 /**
6559 * xmlWalkValidateList:
6560 * @data: Contents of current link
6561 * @user: Value supplied by the user
6562 *
6563 * Returns 0 to abort the walk or 1 to continue
6564 */
6565 static int
xmlWalkValidateList(const void * data,const void * user)6566 xmlWalkValidateList(const void *data, const void *user)
6567 {
6568 xmlValidateMemoPtr memo = (xmlValidateMemoPtr)user;
6569 xmlValidateRef((xmlRefPtr)data, memo->ctxt, memo->name);
6570 return 1;
6571 }
6572
6573 /**
6574 * xmlValidateCheckRefCallback:
6575 * @ref_list: List of references
6576 * @ctxt: Validation context
6577 * @name: Name of ID we are searching for
6578 *
6579 */
6580 static void
xmlValidateCheckRefCallback(xmlListPtr ref_list,xmlValidCtxtPtr ctxt,const xmlChar * name)6581 xmlValidateCheckRefCallback(xmlListPtr ref_list, xmlValidCtxtPtr ctxt,
6582 const xmlChar *name) {
6583 xmlValidateMemo memo;
6584
6585 if (ref_list == NULL)
6586 return;
6587 memo.ctxt = ctxt;
6588 memo.name = name;
6589
6590 xmlListWalk(ref_list, xmlWalkValidateList, &memo);
6591
6592 }
6593
6594 /**
6595 * xmlValidateDocumentFinal:
6596 * @ctxt: the validation context
6597 * @doc: a document instance
6598 *
6599 * Does the final step for the document validation once all the
6600 * incremental validation steps have been completed
6601 *
6602 * basically it does the following checks described by the XML Rec
6603 *
6604 * Check all the IDREF/IDREFS attributes definition for validity
6605 *
6606 * returns 1 if valid or 0 otherwise
6607 */
6608
6609 int
xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,xmlDocPtr doc)6610 xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6611 xmlRefTablePtr table;
6612
6613 if (ctxt == NULL)
6614 return(0);
6615 if (doc == NULL) {
6616 xmlErrValid(ctxt, XML_DTD_NO_DOC,
6617 "xmlValidateDocumentFinal: doc == NULL\n", NULL);
6618 return(0);
6619 }
6620
6621 /*
6622 * Check all the NOTATION/NOTATIONS attributes
6623 */
6624 /*
6625 * Check all the ENTITY/ENTITIES attributes definition for validity
6626 */
6627 /*
6628 * Check all the IDREF/IDREFS attributes definition for validity
6629 */
6630 table = (xmlRefTablePtr) doc->refs;
6631 ctxt->doc = doc;
6632 ctxt->valid = 1;
6633 xmlHashScan(table, (xmlHashScanner) xmlValidateCheckRefCallback, ctxt);
6634 return(ctxt->valid);
6635 }
6636
6637 /**
6638 * xmlValidateDtd:
6639 * @ctxt: the validation context
6640 * @doc: a document instance
6641 * @dtd: a dtd instance
6642 *
6643 * Try to validate the document against the dtd instance
6644 *
6645 * Basically it does check all the definitions in the DtD.
6646 * Note the the internal subset (if present) is de-coupled
6647 * (i.e. not used), which could give problems if ID or IDREF
6648 * is present.
6649 *
6650 * returns 1 if valid or 0 otherwise
6651 */
6652
6653 int
xmlValidateDtd(xmlValidCtxtPtr ctxt,xmlDocPtr doc,xmlDtdPtr dtd)6654 xmlValidateDtd(xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd) {
6655 int ret;
6656 xmlDtdPtr oldExt, oldInt;
6657 xmlNodePtr root;
6658
6659 if (dtd == NULL) return(0);
6660 if (doc == NULL) return(0);
6661 oldExt = doc->extSubset;
6662 oldInt = doc->intSubset;
6663 doc->extSubset = dtd;
6664 doc->intSubset = NULL;
6665 ret = xmlValidateRoot(ctxt, doc);
6666 if (ret == 0) {
6667 doc->extSubset = oldExt;
6668 doc->intSubset = oldInt;
6669 return(ret);
6670 }
6671 if (doc->ids != NULL) {
6672 xmlFreeIDTable(doc->ids);
6673 doc->ids = NULL;
6674 }
6675 if (doc->refs != NULL) {
6676 xmlFreeRefTable(doc->refs);
6677 doc->refs = NULL;
6678 }
6679 root = xmlDocGetRootElement(doc);
6680 ret = xmlValidateElement(ctxt, doc, root);
6681 ret &= xmlValidateDocumentFinal(ctxt, doc);
6682 doc->extSubset = oldExt;
6683 doc->intSubset = oldInt;
6684 return(ret);
6685 }
6686
6687 static void
xmlValidateNotationCallback(xmlEntityPtr cur,xmlValidCtxtPtr ctxt,const xmlChar * name ATTRIBUTE_UNUSED)6688 xmlValidateNotationCallback(xmlEntityPtr cur, xmlValidCtxtPtr ctxt,
6689 const xmlChar *name ATTRIBUTE_UNUSED) {
6690 if (cur == NULL)
6691 return;
6692 if (cur->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
6693 xmlChar *notation = cur->content;
6694
6695 if (notation != NULL) {
6696 int ret;
6697
6698 ret = xmlValidateNotationUse(ctxt, cur->doc, notation);
6699 if (ret != 1) {
6700 ctxt->valid = 0;
6701 }
6702 }
6703 }
6704 }
6705
6706 static void
xmlValidateAttributeCallback(xmlAttributePtr cur,xmlValidCtxtPtr ctxt,const xmlChar * name ATTRIBUTE_UNUSED)6707 xmlValidateAttributeCallback(xmlAttributePtr cur, xmlValidCtxtPtr ctxt,
6708 const xmlChar *name ATTRIBUTE_UNUSED) {
6709 int ret;
6710 xmlDocPtr doc;
6711 xmlElementPtr elem = NULL;
6712
6713 if (cur == NULL)
6714 return;
6715 switch (cur->atype) {
6716 case XML_ATTRIBUTE_CDATA:
6717 case XML_ATTRIBUTE_ID:
6718 case XML_ATTRIBUTE_IDREF :
6719 case XML_ATTRIBUTE_IDREFS:
6720 case XML_ATTRIBUTE_NMTOKEN:
6721 case XML_ATTRIBUTE_NMTOKENS:
6722 case XML_ATTRIBUTE_ENUMERATION:
6723 break;
6724 case XML_ATTRIBUTE_ENTITY:
6725 case XML_ATTRIBUTE_ENTITIES:
6726 case XML_ATTRIBUTE_NOTATION:
6727 if (cur->defaultValue != NULL) {
6728
6729 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc, cur->name,
6730 cur->atype, cur->defaultValue);
6731 if ((ret == 0) && (ctxt->valid == 1))
6732 ctxt->valid = 0;
6733 }
6734 if (cur->tree != NULL) {
6735 xmlEnumerationPtr tree = cur->tree;
6736 while (tree != NULL) {
6737 ret = xmlValidateAttributeValue2(ctxt, ctxt->doc,
6738 cur->name, cur->atype, tree->name);
6739 if ((ret == 0) && (ctxt->valid == 1))
6740 ctxt->valid = 0;
6741 tree = tree->next;
6742 }
6743 }
6744 }
6745 if (cur->atype == XML_ATTRIBUTE_NOTATION) {
6746 doc = cur->doc;
6747 if (cur->elem == NULL) {
6748 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
6749 "xmlValidateAttributeCallback(%s): internal error\n",
6750 (const char *) cur->name);
6751 return;
6752 }
6753
6754 if (doc != NULL)
6755 elem = xmlGetDtdElementDesc(doc->intSubset, cur->elem);
6756 if ((elem == NULL) && (doc != NULL))
6757 elem = xmlGetDtdElementDesc(doc->extSubset, cur->elem);
6758 if ((elem == NULL) && (cur->parent != NULL) &&
6759 (cur->parent->type == XML_DTD_NODE))
6760 elem = xmlGetDtdElementDesc((xmlDtdPtr) cur->parent, cur->elem);
6761 if (elem == NULL) {
6762 xmlErrValidNode(ctxt, NULL, XML_DTD_UNKNOWN_ELEM,
6763 "attribute %s: could not find decl for element %s\n",
6764 cur->name, cur->elem, NULL);
6765 return;
6766 }
6767 if (elem->etype == XML_ELEMENT_TYPE_EMPTY) {
6768 xmlErrValidNode(ctxt, NULL, XML_DTD_EMPTY_NOTATION,
6769 "NOTATION attribute %s declared for EMPTY element %s\n",
6770 cur->name, cur->elem, NULL);
6771 ctxt->valid = 0;
6772 }
6773 }
6774 }
6775
6776 /**
6777 * xmlValidateDtdFinal:
6778 * @ctxt: the validation context
6779 * @doc: a document instance
6780 *
6781 * Does the final step for the dtds validation once all the
6782 * subsets have been parsed
6783 *
6784 * basically it does the following checks described by the XML Rec
6785 * - check that ENTITY and ENTITIES type attributes default or
6786 * possible values matches one of the defined entities.
6787 * - check that NOTATION type attributes default or
6788 * possible values matches one of the defined notations.
6789 *
6790 * returns 1 if valid or 0 if invalid and -1 if not well-formed
6791 */
6792
6793 int
xmlValidateDtdFinal(xmlValidCtxtPtr ctxt,xmlDocPtr doc)6794 xmlValidateDtdFinal(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6795 xmlDtdPtr dtd;
6796 xmlAttributeTablePtr table;
6797 xmlEntitiesTablePtr entities;
6798
6799 if ((doc == NULL) || (ctxt == NULL)) return(0);
6800 if ((doc->intSubset == NULL) && (doc->extSubset == NULL))
6801 return(0);
6802 ctxt->doc = doc;
6803 ctxt->valid = 1;
6804 dtd = doc->intSubset;
6805 if ((dtd != NULL) && (dtd->attributes != NULL)) {
6806 table = (xmlAttributeTablePtr) dtd->attributes;
6807 xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6808 }
6809 if ((dtd != NULL) && (dtd->entities != NULL)) {
6810 entities = (xmlEntitiesTablePtr) dtd->entities;
6811 xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6812 ctxt);
6813 }
6814 dtd = doc->extSubset;
6815 if ((dtd != NULL) && (dtd->attributes != NULL)) {
6816 table = (xmlAttributeTablePtr) dtd->attributes;
6817 xmlHashScan(table, (xmlHashScanner) xmlValidateAttributeCallback, ctxt);
6818 }
6819 if ((dtd != NULL) && (dtd->entities != NULL)) {
6820 entities = (xmlEntitiesTablePtr) dtd->entities;
6821 xmlHashScan(entities, (xmlHashScanner) xmlValidateNotationCallback,
6822 ctxt);
6823 }
6824 return(ctxt->valid);
6825 }
6826
6827 /**
6828 * xmlValidateDocument:
6829 * @ctxt: the validation context
6830 * @doc: a document instance
6831 *
6832 * Try to validate the document instance
6833 *
6834 * basically it does the all the checks described by the XML Rec
6835 * i.e. validates the internal and external subset (if present)
6836 * and validate the document tree.
6837 *
6838 * returns 1 if valid or 0 otherwise
6839 */
6840
6841 int
xmlValidateDocument(xmlValidCtxtPtr ctxt,xmlDocPtr doc)6842 xmlValidateDocument(xmlValidCtxtPtr ctxt, xmlDocPtr doc) {
6843 int ret;
6844 xmlNodePtr root;
6845
6846 if (doc == NULL)
6847 return(0);
6848 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
6849 xmlErrValid(ctxt, XML_DTD_NO_DTD,
6850 "no DTD found!\n", NULL);
6851 return(0);
6852 }
6853 if ((doc->intSubset != NULL) && ((doc->intSubset->SystemID != NULL) ||
6854 (doc->intSubset->ExternalID != NULL)) && (doc->extSubset == NULL)) {
6855 xmlChar *sysID;
6856 if (doc->intSubset->SystemID != NULL) {
6857 sysID = xmlBuildURI(doc->intSubset->SystemID,
6858 doc->URL);
6859 if (sysID == NULL) {
6860 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6861 "Could not build URI for external subset \"%s\"\n",
6862 (const char *) doc->intSubset->SystemID);
6863 return 0;
6864 }
6865 } else
6866 sysID = NULL;
6867 doc->extSubset = xmlParseDTD(doc->intSubset->ExternalID,
6868 (const xmlChar *)sysID);
6869 if (sysID != NULL)
6870 xmlFree(sysID);
6871 if (doc->extSubset == NULL) {
6872 if (doc->intSubset->SystemID != NULL) {
6873 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6874 "Could not load the external subset \"%s\"\n",
6875 (const char *) doc->intSubset->SystemID);
6876 } else {
6877 xmlErrValid(ctxt, XML_DTD_LOAD_ERROR,
6878 "Could not load the external subset \"%s\"\n",
6879 (const char *) doc->intSubset->ExternalID);
6880 }
6881 return(0);
6882 }
6883 }
6884
6885 if (doc->ids != NULL) {
6886 xmlFreeIDTable(doc->ids);
6887 doc->ids = NULL;
6888 }
6889 if (doc->refs != NULL) {
6890 xmlFreeRefTable(doc->refs);
6891 doc->refs = NULL;
6892 }
6893 ret = xmlValidateDtdFinal(ctxt, doc);
6894 if (!xmlValidateRoot(ctxt, doc)) return(0);
6895
6896 root = xmlDocGetRootElement(doc);
6897 ret &= xmlValidateElement(ctxt, doc, root);
6898 ret &= xmlValidateDocumentFinal(ctxt, doc);
6899 return(ret);
6900 }
6901
6902 /************************************************************************
6903 * *
6904 * Routines for dynamic validation editing *
6905 * *
6906 ************************************************************************/
6907
6908 /**
6909 * xmlValidGetPotentialChildren:
6910 * @ctree: an element content tree
6911 * @names: an array to store the list of child names
6912 * @len: a pointer to the number of element in the list
6913 * @max: the size of the array
6914 *
6915 * Build/extend a list of potential children allowed by the content tree
6916 *
6917 * returns the number of element in the list, or -1 in case of error.
6918 */
6919
6920 int
xmlValidGetPotentialChildren(xmlElementContent * ctree,const xmlChar ** names,int * len,int max)6921 xmlValidGetPotentialChildren(xmlElementContent *ctree,
6922 const xmlChar **names,
6923 int *len, int max) {
6924 int i;
6925
6926 if ((ctree == NULL) || (names == NULL) || (len == NULL))
6927 return(-1);
6928 if (*len >= max) return(*len);
6929
6930 switch (ctree->type) {
6931 case XML_ELEMENT_CONTENT_PCDATA:
6932 for (i = 0; i < *len;i++)
6933 if (xmlStrEqual(BAD_CAST "#PCDATA", names[i])) return(*len);
6934 names[(*len)++] = BAD_CAST "#PCDATA";
6935 break;
6936 case XML_ELEMENT_CONTENT_ELEMENT:
6937 for (i = 0; i < *len;i++)
6938 if (xmlStrEqual(ctree->name, names[i])) return(*len);
6939 names[(*len)++] = ctree->name;
6940 break;
6941 case XML_ELEMENT_CONTENT_SEQ:
6942 xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6943 xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6944 break;
6945 case XML_ELEMENT_CONTENT_OR:
6946 xmlValidGetPotentialChildren(ctree->c1, names, len, max);
6947 xmlValidGetPotentialChildren(ctree->c2, names, len, max);
6948 break;
6949 }
6950
6951 return(*len);
6952 }
6953
6954 /*
6955 * Dummy function to suppress messages while we try out valid elements
6956 */
xmlNoValidityErr(void * ctx ATTRIBUTE_UNUSED,const char * msg ATTRIBUTE_UNUSED,...)6957 static void XMLCDECL xmlNoValidityErr(void *ctx ATTRIBUTE_UNUSED,
6958 const char *msg ATTRIBUTE_UNUSED, ...) {
6959 return;
6960 }
6961
6962 /**
6963 * xmlValidGetValidElements:
6964 * @prev: an element to insert after
6965 * @next: an element to insert next
6966 * @names: an array to store the list of child names
6967 * @max: the size of the array
6968 *
6969 * This function returns the list of authorized children to insert
6970 * within an existing tree while respecting the validity constraints
6971 * forced by the Dtd. The insertion point is defined using @prev and
6972 * @next in the following ways:
6973 * to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
6974 * to insert next 'node': xmlValidGetValidElements(node, node->next, ...
6975 * to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
6976 * to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
6977 * to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
6978 *
6979 * pointers to the element names are inserted at the beginning of the array
6980 * and do not need to be freed.
6981 *
6982 * returns the number of element in the list, or -1 in case of error. If
6983 * the function returns the value @max the caller is invited to grow the
6984 * receiving array and retry.
6985 */
6986
6987 int
xmlValidGetValidElements(xmlNode * prev,xmlNode * next,const xmlChar ** names,int max)6988 xmlValidGetValidElements(xmlNode *prev, xmlNode *next, const xmlChar **names,
6989 int max) {
6990 xmlValidCtxt vctxt;
6991 int nb_valid_elements = 0;
6992 const xmlChar *elements[256];
6993 int nb_elements = 0, i;
6994 const xmlChar *name;
6995
6996 xmlNode *ref_node;
6997 xmlNode *parent;
6998 xmlNode *test_node;
6999
7000 xmlNode *prev_next;
7001 xmlNode *next_prev;
7002 xmlNode *parent_childs;
7003 xmlNode *parent_last;
7004
7005 xmlElement *element_desc;
7006
7007 if (prev == NULL && next == NULL)
7008 return(-1);
7009
7010 if (names == NULL) return(-1);
7011 if (max <= 0) return(-1);
7012
7013 memset(&vctxt, 0, sizeof (xmlValidCtxt));
7014 vctxt.error = xmlNoValidityErr; /* this suppresses err/warn output */
7015
7016 nb_valid_elements = 0;
7017 ref_node = prev ? prev : next;
7018 parent = ref_node->parent;
7019
7020 /*
7021 * Retrieves the parent element declaration
7022 */
7023 element_desc = xmlGetDtdElementDesc(parent->doc->intSubset,
7024 parent->name);
7025 if ((element_desc == NULL) && (parent->doc->extSubset != NULL))
7026 element_desc = xmlGetDtdElementDesc(parent->doc->extSubset,
7027 parent->name);
7028 if (element_desc == NULL) return(-1);
7029
7030 /*
7031 * Do a backup of the current tree structure
7032 */
7033 prev_next = prev ? prev->next : NULL;
7034 next_prev = next ? next->prev : NULL;
7035 parent_childs = parent->children;
7036 parent_last = parent->last;
7037
7038 /*
7039 * Creates a dummy node and insert it into the tree
7040 */
7041 test_node = xmlNewDocNode (ref_node->doc, NULL, BAD_CAST "<!dummy?>", NULL);
7042 test_node->parent = parent;
7043 test_node->prev = prev;
7044 test_node->next = next;
7045 name = test_node->name;
7046
7047 if (prev) prev->next = test_node;
7048 else parent->children = test_node;
7049
7050 if (next) next->prev = test_node;
7051 else parent->last = test_node;
7052
7053 /*
7054 * Insert each potential child node and check if the parent is
7055 * still valid
7056 */
7057 nb_elements = xmlValidGetPotentialChildren(element_desc->content,
7058 elements, &nb_elements, 256);
7059
7060 for (i = 0;i < nb_elements;i++) {
7061 test_node->name = elements[i];
7062 if (xmlValidateOneElement(&vctxt, parent->doc, parent)) {
7063 int j;
7064
7065 for (j = 0; j < nb_valid_elements;j++)
7066 if (xmlStrEqual(elements[i], names[j])) break;
7067 names[nb_valid_elements++] = elements[i];
7068 if (nb_valid_elements >= max) break;
7069 }
7070 }
7071
7072 /*
7073 * Restore the tree structure
7074 */
7075 if (prev) prev->next = prev_next;
7076 if (next) next->prev = next_prev;
7077 parent->children = parent_childs;
7078 parent->last = parent_last;
7079
7080 /*
7081 * Free up the dummy node
7082 */
7083 test_node->name = name;
7084 xmlFreeNode(test_node);
7085
7086 return(nb_valid_elements);
7087 }
7088 #endif /* LIBXML_VALID_ENABLED */
7089
7090 #define bottom_valid
7091 #include "elfgcchack.h"
7092