gdb/xml-support.c

   1 /* Helper routines for parsing XML using Expat.
   2
   3    Copyright (C) 2006-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcmd.h"
  22 #include "xml-builtin.h"
  23 #include "xml-support.h"
  24 #include "gdbsupport/filestuff.h"
  25 #include "safe-ctype.h"
  26 #include <vector>
  27 #include <string>
  28
  29 /* Debugging flag.  */
  30 static bool debug_xml;
  31
  32 /* The contents of this file are only useful if XML support is
  33    available.  */
  34 #ifdef HAVE_LIBEXPAT
  35
  36 #include "gdb_expat.h"
  37
  38 /* The maximum depth of <xi:include> nesting.  No need to be miserly,
  39    we just want to avoid running out of stack on loops.  */
  40 #define MAX_XINCLUDE_DEPTH 30
  41
  42 /* Simplified XML parser infrastructure.  */
  43
  44 /* A parsing level -- used to keep track of the current element
  45    nesting.  */
  46 struct scope_level
  47 {
  48   explicit scope_level (const gdb_xml_element *elements_ = NULL)
  49     : elements (elements_),
  50       element (NULL),
  51       seen (0)
  52   {}
  53
  54   /* Elements we allow at this level.  */
  55   const struct gdb_xml_element *elements;
  56
  57   /* The element which we are within.  */
  58   const struct gdb_xml_element *element;
  59
  60   /* Mask of which elements we've seen at this level (used for
  61      optional and repeatable checking).  */
  62   unsigned int seen;
  63
  64   /* Body text accumulation.  */
  65   std::string body;
  66 };
  67
  68 /* The parser itself, and our additional state.  */
  69 struct gdb_xml_parser
  70 {
  71   gdb_xml_parser (const char *name,
  72                   const gdb_xml_element *elements,
  73                   void *user_data);
  74   ~gdb_xml_parser();
  75
  76   /* Associate DTD_NAME, which must be the name of a compiled-in DTD,
  77      with the parser.  */
  78   void use_dtd (const char *dtd_name);
  79
  80   /* Return the name of the expected / default DTD, if specified.  */
  81   const char *dtd_name ()
  82   { return m_dtd_name; }
  83
  84   /* Invoke the parser on BUFFER.  BUFFER is the data to parse, which
  85      should be NUL-terminated.
  86
  87      The return value is 0 for success or -1 for error.  It may throw,
  88      but only if something unexpected goes wrong during parsing; parse
  89      errors will be caught, warned about, and reported as failure.  */
  90   int parse (const char *buffer);
  91
  92   /* Issue a debugging message.  */
  93   void vdebug (const char *format, va_list ap)
  94     ATTRIBUTE_PRINTF (2, 0);
  95
  96   /* Issue an error message, and stop parsing.  */
  97   void verror (const char *format, va_list ap)
  98     ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 0);
  99
 100   void body_text (const XML_Char *text, int length);
 101   void start_element (const XML_Char *name, const XML_Char **attrs);
 102   void end_element (const XML_Char *name);
 103
 104   /* Return the name of this parser.  */
 105   const char *name ()
 106   { return m_name; }
 107
 108   /* Return the user's callback data, for handlers.  */
 109   void *user_data ()
 110   { return m_user_data; };
 111
 112   /* Are we the special <xi:include> parser?  */
 113   void set_is_xinclude (bool is_xinclude)
 114   { m_is_xinclude = is_xinclude; }
 115
 116   /* A thrown error, if any.  */
 117   void set_error (gdb_exception &&error)
 118   {
 119     m_error = std::move (error);
 120 #ifdef HAVE_XML_STOPPARSER
 121     XML_StopParser (m_expat_parser, XML_FALSE);
 122 #endif
 123   }
 124
 125   /* Return the underlying expat parser.  */
 126   XML_Parser expat_parser ()
 127   { return m_expat_parser; }
 128
 129 private:
 130   /* The underlying expat parser.  */
 131   XML_Parser m_expat_parser;
 132
 133   /* Name of this parser.  */
 134   const char *m_name;
 135
 136   /* The user's callback data, for handlers.  */
 137   void *m_user_data;
 138
 139   /* Scoping stack.  */
 140   std::vector<scope_level> m_scopes;
 141
 142 /* A thrown error, if any.  */
 143   struct gdb_exception m_error;
 144
 145   /* The line of the thrown error, or 0.  */
 146   int m_last_line;
 147
 148   /* The name of the expected / default DTD, if specified.  */
 149   const char *m_dtd_name;
 150
 151   /* Are we the special <xi:include> parser?  */
 152   bool m_is_xinclude;
 153 };
 154
 155 /* Process some body text.  We accumulate the text for later use; it's
 156    wrong to do anything with it immediately, because a single block of
 157    text might be broken up into multiple calls to this function.  */
 158
 159 void
 160 gdb_xml_parser::body_text (const XML_Char *text, int length)
 161 {
 162   if (m_error.reason < 0)
 163     return;
 164
 165   scope_level &scope = m_scopes.back ();
 166   scope.body.append (text, length);
 167 }
 168
 169 static void
 170 gdb_xml_body_text (void *data, const XML_Char *text, int length)
 171 {
 172   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
 173
 174   parser->body_text (text, length);
 175 }
 176
 177 /* Issue a debugging message from one of PARSER's handlers.  */
 178
 179 void
 180 gdb_xml_parser::vdebug (const char *format, va_list ap)
 181 {
 182   int line = XML_GetCurrentLineNumber (m_expat_parser);
 183
 184   std::string message = string_vprintf (format, ap);
 185   if (line)
 186     gdb_printf (gdb_stderr, "%s (line %d): %s\n",
 187                 m_name, line, message.c_str ());
 188   else
 189     gdb_printf (gdb_stderr, "%s: %s\n",
 190                 m_name, message.c_str ());
 191 }
 192
 193 void
 194 gdb_xml_debug (struct gdb_xml_parser *parser, const char *format, ...)
 195 {
 196   if (!debug_xml)
 197     return;
 198
 199   va_list ap;
 200   va_start (ap, format);
 201   parser->vdebug (format, ap);
 202   va_end (ap);
 203 }
 204
 205 /* Issue an error message from one of PARSER's handlers, and stop
 206    parsing.  */
 207
 208 void
 209 gdb_xml_parser::verror (const char *format, va_list ap)
 210 {
 211   int line = XML_GetCurrentLineNumber (m_expat_parser);
 212
 213   m_last_line = line;
 214   throw_verror (XML_PARSE_ERROR, format, ap);
 215 }
 216
 217 void
 218 gdb_xml_error (struct gdb_xml_parser *parser, const char *format, ...)
 219 {
 220   va_list ap;
 221   va_start (ap, format);
 222   parser->verror (format, ap);
 223   va_end (ap);
 224 }
 225
 226 /* Find the attribute named NAME in the set of parsed attributes
 227    ATTRIBUTES.  Returns NULL if not found.  */
 228
 229 struct gdb_xml_value *
 230 xml_find_attribute (std::vector<gdb_xml_value> &attributes,
 231                     const char *name)
 232 {
 233   for (gdb_xml_value &value : attributes)
 234     if (strcmp (value.name, name) == 0)
 235       return &value;
 236
 237   return NULL;
 238 }
 239
 240 /* Handle the start of an element.  NAME is the element, and ATTRS are
 241    the names and values of this element's attributes.  */
 242
 243 void
 244 gdb_xml_parser::start_element (const XML_Char *name,
 245                                const XML_Char **attrs)
 246 {
 247   if (m_error.reason < 0)
 248     return;
 249
 250   const struct gdb_xml_element *element;
 251   const struct gdb_xml_attribute *attribute;
 252   unsigned int seen;
 253
 254   /* Push an error scope.  If we return or throw an exception before
 255      filling this in, it will tell us to ignore children of this
 256      element.  Note we don't take a reference to the element yet
 257      because further below we'll process the element which may recurse
 258      back here and push more elements to the vector.  When the
 259      recursion unrolls all such elements will have been popped back
 260      already, but if one of those pushes reallocates the vector,
 261      previous element references will be invalidated.  */
 262   m_scopes.emplace_back ();
 263
 264   /* Get a reference to the current scope.  */
 265   scope_level &scope = m_scopes[m_scopes.size () - 2];
 266
 267   gdb_xml_debug (this, _("Entering element <%s>"), name);
 268
 269   /* Find this element in the list of the current scope's allowed
 270      children.  Record that we've seen it.  */
 271
 272   seen = 1;
 273   for (element = scope.elements; element && element->name;
 274        element++, seen <<= 1)
 275     if (strcmp (element->name, name) == 0)
 276       break;
 277
 278   if (element == NULL || element->name == NULL)
 279     {
 280       /* If we're working on XInclude, <xi:include> can be the child
 281          of absolutely anything.  Copy the previous scope's element
 282          list into the new scope even if there was no match.  */
 283       if (m_is_xinclude)
 284         {
 285           XML_DefaultCurrent (m_expat_parser);
 286
 287           scope_level &unknown_scope = m_scopes.back ();
 288           unknown_scope.elements = scope.elements;
 289           return;
 290         }
 291
 292       gdb_xml_debug (this, _("Element <%s> unknown"), name);
 293       return;
 294     }
 295
 296   if (!(element->flags & GDB_XML_EF_REPEATABLE) && (seen & scope.seen))
 297     gdb_xml_error (this, _("Element <%s> only expected once"), name);
 298
 299   scope.seen |= seen;
 300
 301   std::vector<gdb_xml_value> attributes;
 302
 303   for (attribute = element->attributes;
 304        attribute != NULL && attribute->name != NULL;
 305        attribute++)
 306     {
 307       const char *val = NULL;
 308       const XML_Char **p;
 309       void *parsed_value;
 310
 311       for (p = attrs; *p != NULL; p += 2)
 312         if (!strcmp (attribute->name, p[0]))
 313           {
 314             val = p[1];
 315             break;
 316           }
 317
 318       if (*p != NULL && val == NULL)
 319         {
 320           gdb_xml_debug (this, _("Attribute \"%s\" missing a value"),
 321                          attribute->name);
 322           continue;
 323         }
 324
 325       if (*p == NULL && !(attribute->flags & GDB_XML_AF_OPTIONAL))
 326         {
 327           gdb_xml_error (this, _("Required attribute \"%s\" of "
 328                                    "<%s> not specified"),
 329                          attribute->name, element->name);
 330           continue;
 331         }
 332
 333       if (*p == NULL)
 334         continue;
 335
 336       gdb_xml_debug (this, _("Parsing attribute %s=\"%s\""),
 337                      attribute->name, val);
 338
 339       if (attribute->handler)
 340         parsed_value = attribute->handler (this, attribute, val);
 341       else
 342         parsed_value = xstrdup (val);
 343
 344       attributes.emplace_back (attribute->name, parsed_value);
 345     }
 346
 347   /* Check for unrecognized attributes.  */
 348   if (debug_xml)
 349     {
 350       const XML_Char **p;
 351
 352       for (p = attrs; *p != NULL; p += 2)
 353         {
 354           for (attribute = element->attributes;
 355                attribute != NULL && attribute->name != NULL;
 356                attribute++)
 357             if (strcmp (attribute->name, *p) == 0)
 358               break;
 359
 360           if (attribute == NULL || attribute->name == NULL)
 361             gdb_xml_debug (this, _("Ignoring unknown attribute %s"), *p);
 362         }
 363     }
 364
 365   /* Call the element handler if there is one.  */
 366   if (element->start_handler)
 367     element->start_handler (this, element, m_user_data, attributes);
 368
 369   /* Fill in a new scope level.  Note that we must delay getting a
 370      back reference till here because above we might have recursed,
 371      which may have reallocated the vector which invalidates
 372      iterators/pointers/references.  */
 373   scope_level &new_scope = m_scopes.back ();
 374   new_scope.element = element;
 375   new_scope.elements = element->children;
 376 }
 377
 378 /* Wrapper for gdb_xml_start_element, to prevent throwing exceptions
 379    through expat.  */
 380
 381 static void
 382 gdb_xml_start_element_wrapper (void *data, const XML_Char *name,
 383                                const XML_Char **attrs)
 384 {
 385   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
 386
 387   try
 388     {
 389       parser->start_element (name, attrs);
 390     }
 391   catch (gdb_exception &ex)
 392     {
 393       parser->set_error (std::move (ex));
 394     }
 395 }
 396
 397 /* Handle the end of an element.  NAME is the current element.  */
 398
 399 void
 400 gdb_xml_parser::end_element (const XML_Char *name)
 401 {
 402   if (m_error.reason < 0)
 403     return;
 404
 405   struct scope_level *scope = &m_scopes.back ();
 406   const struct gdb_xml_element *element;
 407   unsigned int seen;
 408
 409   gdb_xml_debug (this, _("Leaving element <%s>"), name);
 410
 411   for (element = scope->elements, seen = 1;
 412        element != NULL && element->name != NULL;
 413        element++, seen <<= 1)
 414     if ((scope->seen & seen) == 0
 415         && (element->flags & GDB_XML_EF_OPTIONAL) == 0)
 416       gdb_xml_error (this, _("Required element <%s> is missing"),
 417                      element->name);
 418
 419   /* Call the element processor.  */
 420   if (scope->element != NULL && scope->element->end_handler)
 421     {
 422       const char *body;
 423
 424       if (scope->body.empty ())
 425         body = "";
 426       else
 427         {
 428           int length;
 429
 430           length = scope->body.size ();
 431           body = scope->body.c_str ();
 432
 433           /* Strip leading and trailing whitespace.  */
 434           while (length > 0 && ISSPACE (body[length - 1]))
 435             length--;
 436           scope->body.erase (length);
 437           while (*body && ISSPACE (*body))
 438             body++;
 439         }
 440
 441       scope->element->end_handler (this, scope->element,
 442                                    m_user_data, body);
 443     }
 444   else if (scope->element == NULL)
 445     XML_DefaultCurrent (m_expat_parser);
 446
 447   /* Pop the scope level.  */
 448   m_scopes.pop_back ();
 449 }
 450
 451 /* Wrapper for gdb_xml_end_element, to prevent throwing exceptions
 452    through expat.  */
 453
 454 static void
 455 gdb_xml_end_element_wrapper (void *data, const XML_Char *name)
 456 {
 457   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data;
 458
 459   try
 460     {
 461       parser->end_element (name);
 462     }
 463   catch (gdb_exception &ex)
 464     {
 465       parser->set_error (std::move (ex));
 466     }
 467 }
 468
 469 /* Free a parser and all its associated state.  */
 470
 471 gdb_xml_parser::~gdb_xml_parser ()
 472 {
 473   XML_ParserFree (m_expat_parser);
 474 }
 475
 476 /* Initialize a parser.  */
 477
 478 gdb_xml_parser::gdb_xml_parser (const char *name,
 479                                 const gdb_xml_element *elements,
 480                                 void *user_data)
 481   : m_name (name),
 482     m_user_data (user_data),
 483     m_last_line (0),
 484     m_dtd_name (NULL),
 485     m_is_xinclude (false)
 486 {
 487   m_expat_parser = XML_ParserCreateNS (NULL, '!');
 488   if (m_expat_parser == NULL)
 489     malloc_failure (0);
 490
 491   XML_SetUserData (m_expat_parser, this);
 492
 493   /* Set the callbacks.  */
 494   XML_SetElementHandler (m_expat_parser, gdb_xml_start_element_wrapper,
 495                          gdb_xml_end_element_wrapper);
 496   XML_SetCharacterDataHandler (m_expat_parser, gdb_xml_body_text);
 497
 498   /* Initialize the outer scope.  */
 499   m_scopes.emplace_back (elements);
 500 }
 501
 502 /* External entity handler.  The only external entities we support
 503    are those compiled into GDB (we do not fetch entities from the
 504    target).  */
 505
 506 static int XMLCALL
 507 gdb_xml_fetch_external_entity (XML_Parser expat_parser,
 508                                const XML_Char *context,
 509                                const XML_Char *base,
 510                                const XML_Char *systemId,
 511                                const XML_Char *publicId)
 512 {
 513   XML_Parser entity_parser;
 514   const char *text;
 515   enum XML_Status status;
 516
 517   if (systemId == NULL)
 518     {
 519       gdb_xml_parser *parser
 520         = (gdb_xml_parser *) XML_GetUserData (expat_parser);
 521
 522       text = fetch_xml_builtin (parser->dtd_name ());
 523       if (text == NULL)
 524         internal_error (_("could not locate built-in DTD %s"),
 525                         parser->dtd_name ());
 526     }
 527   else
 528     {
 529       text = fetch_xml_builtin (systemId);
 530       if (text == NULL)
 531         return XML_STATUS_ERROR;
 532     }
 533
 534   entity_parser = XML_ExternalEntityParserCreate (expat_parser,
 535                                                   context, NULL);
 536
 537   /* Don't use our handlers for the contents of the DTD.  Just let expat
 538      process it.  */
 539   XML_SetElementHandler (entity_parser, NULL, NULL);
 540   XML_SetDoctypeDeclHandler (entity_parser, NULL, NULL);
 541   XML_SetXmlDeclHandler (entity_parser, NULL);
 542   XML_SetDefaultHandler (entity_parser, NULL);
 543   XML_SetUserData (entity_parser, NULL);
 544
 545   status = XML_Parse (entity_parser, text, strlen (text), 1);
 546
 547   XML_ParserFree (entity_parser);
 548   return status;
 549 }
 550
 551 void
 552 gdb_xml_parser::use_dtd (const char *dtd_name)
 553 {
 554   enum XML_Error err;
 555
 556   m_dtd_name = dtd_name;
 557
 558   XML_SetParamEntityParsing (m_expat_parser,
 559                              XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
 560   XML_SetExternalEntityRefHandler (m_expat_parser,
 561                                    gdb_xml_fetch_external_entity);
 562
 563   /* Even if no DTD is provided, use the built-in DTD anyway.  */
 564   err = XML_UseForeignDTD (m_expat_parser, XML_TRUE);
 565   if (err != XML_ERROR_NONE)
 566     internal_error (_("XML_UseForeignDTD failed: %s"),
 567                     XML_ErrorString (err));
 568 }
 569
 570 /* Invoke PARSER on BUFFER.  BUFFER is the data to parse, which
 571    should be NUL-terminated.
 572
 573    The return value is 0 for success or -1 for error.  It may throw,
 574    but only if something unexpected goes wrong during parsing; parse
 575    errors will be caught, warned about, and reported as failure.  */
 576
 577 int
 578 gdb_xml_parser::parse (const char *buffer)
 579 {
 580   enum XML_Status status;
 581   const char *error_string;
 582
 583   gdb_xml_debug (this, _("Starting:\n%s"), buffer);
 584
 585   status = XML_Parse (m_expat_parser, buffer, strlen (buffer), 1);
 586
 587   if (status == XML_STATUS_OK && m_error.reason == 0)
 588     return 0;
 589
 590   if (m_error.reason == RETURN_ERROR
 591       && m_error.error == XML_PARSE_ERROR)
 592     {
 593       gdb_assert (m_error.message != NULL);
 594       error_string = m_error.what ();
 595     }
 596   else if (status == XML_STATUS_ERROR)
 597     {
 598       enum XML_Error err = XML_GetErrorCode (m_expat_parser);
 599
 600       error_string = XML_ErrorString (err);
 601     }
 602   else
 603     {
 604       gdb_assert (m_error.reason < 0);
 605       throw_exception (std::move (m_error));
 606     }
 607
 608   if (m_last_line != 0)
 609     warning (_("while parsing %s (at line %d): %s"), m_name,
 610              m_last_line, error_string);
 611   else
 612     warning (_("while parsing %s: %s"), m_name, error_string);
 613
 614   return -1;
 615 }
 616
 617 int
 618 gdb_xml_parse_quick (const char *name, const char *dtd_name,
 619                      const struct gdb_xml_element *elements,
 620                      const char *document, void *user_data)
 621 {
 622   gdb_xml_parser parser (name, elements, user_data);
 623   if (dtd_name != NULL)
 624     parser.use_dtd (dtd_name);
 625   return parser.parse (document);
 626 }
 627
 628 /* Parse a field VALSTR that we expect to contain an integer value.
 629    The integer is returned in *VALP.  The string is parsed with an
 630    equivalent to strtoul.
 631
 632    Returns 0 for success, -1 for error.  */
 633
 634 static int
 635 xml_parse_unsigned_integer (const char *valstr, ULONGEST *valp)
 636 {
 637   const char *endptr;
 638   ULONGEST result;
 639
 640   if (*valstr == '\0')
 641     return -1;
 642
 643   result = strtoulst (valstr, &endptr, 0);
 644   if (*endptr != '\0')
 645     return -1;
 646
 647   *valp = result;
 648   return 0;
 649 }
 650
 651 /* Parse an integer string into a ULONGEST and return it, or call
 652    gdb_xml_error if it could not be parsed.  */
 653
 654 ULONGEST
 655 gdb_xml_parse_ulongest (struct gdb_xml_parser *parser, const char *value)
 656 {
 657   ULONGEST result;
 658
 659   if (xml_parse_unsigned_integer (value, &result) != 0)
 660     gdb_xml_error (parser, _("Can't convert \"%s\" to an integer"), value);
 661
 662   return result;
 663 }
 664
 665 /* Parse an integer attribute into a ULONGEST.  */
 666
 667 void *
 668 gdb_xml_parse_attr_ulongest (struct gdb_xml_parser *parser,
 669                              const struct gdb_xml_attribute *attribute,
 670                              const char *value)
 671 {
 672   ULONGEST result;
 673   void *ret;
 674
 675   if (xml_parse_unsigned_integer (value, &result) != 0)
 676     gdb_xml_error (parser, _("Can't convert %s=\"%s\" to an integer"),
 677                    attribute->name, value);
 678
 679   ret = XNEW (ULONGEST);
 680   memcpy (ret, &result, sizeof (result));
 681   return ret;
 682 }
 683
 684 /* A handler_data for yes/no boolean values.  */
 685
 686 const struct gdb_xml_enum gdb_xml_enums_boolean[] = {
 687   { "yes", 1 },
 688   { "no", 0 },
 689   { NULL, 0 }
 690 };
 691
 692 /* Map NAME to VALUE.  A struct gdb_xml_enum * should be saved as the
 693    value of handler_data when using gdb_xml_parse_attr_enum to parse a
 694    fixed list of possible strings.  The list is terminated by an entry
 695    with NAME == NULL.  */
 696
 697 void *
 698 gdb_xml_parse_attr_enum (struct gdb_xml_parser *parser,
 699                          const struct gdb_xml_attribute *attribute,
 700                          const char *value)
 701 {
 702   const struct gdb_xml_enum *enums
 703     = (const struct gdb_xml_enum *) attribute->handler_data;
 704   void *ret;
 705
 706   for (enums = (const struct gdb_xml_enum *) attribute->handler_data;
 707        enums->name != NULL; enums++)
 708     if (strcasecmp (enums->name, value) == 0)
 709       break;
 710
 711   if (enums->name == NULL)
 712     gdb_xml_error (parser, _("Unknown attribute value %s=\"%s\""),
 713                  attribute->name, value);
 714
 715   ret = xmalloc (sizeof (enums->value));
 716   memcpy (ret, &enums->value, sizeof (enums->value));
 717   return ret;
 718 }
 719 \f
 720
 721 /* XInclude processing.  This is done as a separate step from actually
 722    parsing the document, so that we can produce a single combined XML
 723    document - e.g. to hand to a front end or to simplify comparing two
 724    documents.  We make extensive use of XML_DefaultCurrent, to pass
 725    input text directly into the output without reformatting or
 726    requoting it.
 727
 728    We output the DOCTYPE declaration for the first document unchanged,
 729    if present, and discard DOCTYPEs from included documents.  Only the
 730    one we pass through here is used when we feed the result back to
 731    expat.  The XInclude standard explicitly does not discuss
 732    validation of the result; we choose to apply the same DTD applied
 733    to the outermost document.
 734
 735    We can not simply include the external DTD subset in the document
 736    as an internal subset, because <!IGNORE> and <!INCLUDE> are valid
 737    only in external subsets.  But if we do not pass the DTD into the
 738    output at all, default values will not be filled in.
 739
 740    We don't pass through any <?xml> declaration because we generate
 741    UTF-8, not whatever the input encoding was.  */
 742
 743 struct xinclude_parsing_data
 744 {
 745   xinclude_parsing_data (std::string &output_,
 746                          xml_fetch_another fetcher_,
 747                          int include_depth_)
 748     : output (output_),
 749       skip_depth (0),
 750       include_depth (include_depth_),
 751       fetcher (fetcher_)
 752   {}
 753
 754   /* Where the output goes.  */
 755   std::string &output;
 756
 757   /* A count indicating whether we are in an element whose
 758      children should not be copied to the output, and if so,
 759      how deep we are nested.  This is used for anything inside
 760      an xi:include, and for the DTD.  */
 761   int skip_depth;
 762
 763   /* The number of <xi:include> elements currently being processed,
 764      to detect loops.  */
 765   int include_depth;
 766
 767   /* A function to call to obtain additional features, and its
 768      baton.  */
 769   xml_fetch_another fetcher;
 770 };
 771
 772 static void
 773 xinclude_start_include (struct gdb_xml_parser *parser,
 774                         const struct gdb_xml_element *element,
 775                         void *user_data,
 776                         std::vector<gdb_xml_value> &attributes)
 777 {
 778   struct xinclude_parsing_data *data
 779     = (struct xinclude_parsing_data *) user_data;
 780   char *href = (char *) xml_find_attribute (attributes, "href")->value.get ();
 781
 782   gdb_xml_debug (parser, _("Processing XInclude of \"%s\""), href);
 783
 784   if (data->include_depth > MAX_XINCLUDE_DEPTH)
 785     gdb_xml_error (parser, _("Maximum XInclude depth (%d) exceeded"),
 786                    MAX_XINCLUDE_DEPTH);
 787
 788   gdb::optional<gdb::char_vector> text = data->fetcher (href);
 789   if (!text)
 790     gdb_xml_error (parser, _("Could not load XML document \"%s\""), href);
 791
 792   if (!xml_process_xincludes (data->output, parser->name (),
 793                               text->data (), data->fetcher,
 794                               data->include_depth + 1))
 795     gdb_xml_error (parser, _("Parsing \"%s\" failed"), href);
 796
 797   data->skip_depth++;
 798 }
 799
 800 static void
 801 xinclude_end_include (struct gdb_xml_parser *parser,
 802                       const struct gdb_xml_element *element,
 803                       void *user_data, const char *body_text)
 804 {
 805   struct xinclude_parsing_data *data
 806     = (struct xinclude_parsing_data *) user_data;
 807
 808   data->skip_depth--;
 809 }
 810
 811 static void XMLCALL
 812 xml_xinclude_default (void *data_, const XML_Char *s, int len)
 813 {
 814   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
 815   xinclude_parsing_data *data = (xinclude_parsing_data *) parser->user_data ();
 816
 817   /* If we are inside of e.g. xi:include or the DTD, don't save this
 818      string.  */
 819   if (data->skip_depth)
 820     return;
 821
 822   /* Otherwise just add it to the end of the document we're building
 823      up.  */
 824   data->output.append (s, len);
 825 }
 826
 827 static void XMLCALL
 828 xml_xinclude_start_doctype (void *data_, const XML_Char *doctypeName,
 829                             const XML_Char *sysid, const XML_Char *pubid,
 830                             int has_internal_subset)
 831 {
 832   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
 833   xinclude_parsing_data *data = (xinclude_parsing_data *) parser->user_data ();
 834
 835   /* Don't print out the doctype, or the contents of the DTD internal
 836      subset, if any.  */
 837   data->skip_depth++;
 838 }
 839
 840 static void XMLCALL
 841 xml_xinclude_end_doctype (void *data_)
 842 {
 843   struct gdb_xml_parser *parser = (struct gdb_xml_parser *) data_;
 844   xinclude_parsing_data *data = (xinclude_parsing_data *) parser->user_data ();
 845
 846   data->skip_depth--;
 847 }
 848
 849 static void XMLCALL
 850 xml_xinclude_xml_decl (void *data_, const XML_Char *version,
 851                        const XML_Char *encoding, int standalone)
 852 {
 853   /* Do nothing - this function prevents the default handler from
 854      being called, thus suppressing the XML declaration from the
 855      output.  */
 856 }
 857
 858 const struct gdb_xml_attribute xinclude_attributes[] = {
 859   { "href", GDB_XML_AF_NONE, NULL, NULL },
 860   { NULL, GDB_XML_AF_NONE, NULL, NULL }
 861 };
 862
 863 const struct gdb_xml_element xinclude_elements[] = {
 864   { "http://www.w3.org/2001/XInclude!include", xinclude_attributes, NULL,
 865     GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE,
 866     xinclude_start_include, xinclude_end_include },
 867   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
 868 };
 869
 870 /* The main entry point for <xi:include> processing.  */
 871
 872 bool
 873 xml_process_xincludes (std::string &result,
 874                        const char *name, const char *text,
 875                        xml_fetch_another fetcher, int depth)
 876 {
 877   xinclude_parsing_data data (result, fetcher, depth);
 878
 879   gdb_xml_parser parser (name, xinclude_elements, &data);
 880   parser.set_is_xinclude (true);
 881
 882   XML_SetCharacterDataHandler (parser.expat_parser (), NULL);
 883   XML_SetDefaultHandler (parser.expat_parser (), xml_xinclude_default);
 884
 885   /* Always discard the XML version declarations; the only important
 886      thing this provides is encoding, and our result will have been
 887      converted to UTF-8.  */
 888   XML_SetXmlDeclHandler (parser.expat_parser (), xml_xinclude_xml_decl);
 889
 890   if (depth > 0)
 891     /* Discard the doctype for included documents.  */
 892     XML_SetDoctypeDeclHandler (parser.expat_parser (),
 893                                xml_xinclude_start_doctype,
 894                                xml_xinclude_end_doctype);
 895
 896   parser.use_dtd ("xinclude.dtd");
 897
 898   if (parser.parse (text) == 0)
 899     {
 900       if (depth == 0)
 901         gdb_xml_debug (&parser, _("XInclude processing succeeded."));
 902       return true;
 903     }
 904
 905   return false;
 906 }
 907 #endif /* HAVE_LIBEXPAT */
 908 \f
 909
 910 /* Return an XML document which was compiled into GDB, from
 911    the given FILENAME, or NULL if the file was not compiled in.  */
 912
 913 const char *
 914 fetch_xml_builtin (const char *filename)
 915 {
 916   const char *const (*p)[2];
 917
 918   for (p = xml_builtin; (*p)[0]; p++)
 919     if (strcmp ((*p)[0], filename) == 0)
 920       return (*p)[1];
 921
 922   return NULL;
 923 }
 924
 925 /* A to_xfer_partial helper function which reads XML files which were
 926    compiled into GDB.  The target may call this function from its own
 927    to_xfer_partial handler, after converting object and annex to the
 928    appropriate filename.  */
 929
 930 LONGEST
 931 xml_builtin_xfer_partial (const char *filename,
 932                           gdb_byte *readbuf, const gdb_byte *writebuf,
 933                           ULONGEST offset, LONGEST len)
 934 {
 935   const char *buf;
 936   LONGEST len_avail;
 937
 938   gdb_assert (readbuf != NULL && writebuf == NULL);
 939   gdb_assert (filename != NULL);
 940
 941   buf = fetch_xml_builtin (filename);
 942   if (buf == NULL)
 943     return -1;
 944
 945   len_avail = strlen (buf);
 946   if (offset >= len_avail)
 947     return 0;
 948
 949   if (len > len_avail - offset)
 950     len = len_avail - offset;
 951   memcpy (readbuf, buf + offset, len);
 952   return len;
 953 }
 954 \f
 955
 956 static void
 957 show_debug_xml (struct ui_file *file, int from_tty,
 958                 struct cmd_list_element *c, const char *value)
 959 {
 960   gdb_printf (file, _("XML debugging is %s.\n"), value);
 961 }
 962
 963 gdb::optional<gdb::char_vector>
 964 xml_fetch_content_from_file (const char *filename, const char *dirname)
 965 {
 966   gdb_file_up file;
 967
 968   if (dirname != nullptr && *dirname != '\0')
 969     {
 970       gdb::unique_xmalloc_ptr<char> fullname
 971         (concat (dirname, "/", filename, (char *) NULL));
 972
 973       file = gdb_fopen_cloexec (fullname.get (), FOPEN_RB);
 974     }
 975   else
 976     file = gdb_fopen_cloexec (filename, FOPEN_RB);
 977
 978   if (file == NULL)
 979     return {};
 980
 981   /* Read in the whole file.  */
 982
 983   size_t len;
 984
 985   if (fseek (file.get (), 0, SEEK_END) == -1)
 986     perror_with_name (_("seek to end of file"));
 987   len = ftell (file.get ());
 988   rewind (file.get ());
 989
 990   gdb::char_vector text (len + 1);
 991
 992   if (fread (text.data (), 1, len, file.get ()) != len
 993       || ferror (file.get ()))
 994     {
 995       warning (_("Read error from \"%s\""), filename);
 996       return {};
 997     }
 998
 999   text.back () = '\0';
1000   return text;
1001 }
1002
1003 void _initialize_xml_support ();
1004 void _initialize_xml_support ();
1005 void
1006 _initialize_xml_support ()
1007 {
1008   add_setshow_boolean_cmd ("xml", class_maintenance, &debug_xml,
1009                            _("Set XML parser debugging."),
1010                            _("Show XML parser debugging."),
1011                            _("When set, debugging messages for XML parsers "
1012                              "are displayed."),
1013                            NULL, show_debug_xml,
1014                            &setdebuglist, &showdebuglist);
1015 }