/*------------------------------------------------------------------------- * * xml.c * XML data type support. * * * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * $PostgreSQL: pgsql/src/backend/utils/adt/xml.c,v 1.8 2006/12/29 10:50:22 petere Exp $ * *------------------------------------------------------------------------- */ /* * Generally, XML type support is only available when libxml use was * configured during the build. But even if that is not done, the * type and all the functions are available, but most of them will * fail. For one thing, this avoids having to manage variant catalog * installations. But it also has nice effects such as that you can * dump a database containing XML type data even if the server is not * linked with libxml. Thus, make sure xml_out() works even if nothing * else does. */ #include "postgres.h" #ifdef USE_LIBXML #include #include #include #include #include #endif /* USE_LIBXML */ #include "fmgr.h" #include "libpq/pqformat.h" #include "mb/pg_wchar.h" #include "nodes/execnodes.h" #include "utils/builtins.h" #include "utils/memutils.h" #include "utils/xml.h" #ifdef USE_LIBXML #define PG_XML_DEFAULT_URI "dummy.xml" static StringInfo xml_err_buf = NULL; static void xml_init(void); static void *xml_palloc(size_t size); static void *xml_repalloc(void *ptr, size_t size); static void xml_pfree(void *ptr); static char *xml_pstrdup(const char *string); static void xml_ereport(int level, int sqlcode, const char *msg, void *ctxt); static void xml_errorHandler(void *ctxt, const char *msg, ...); static void xml_ereport_by_code(int level, int sqlcode, const char *msg, int errcode); static xmlChar *xml_text2xmlChar(text *in); static xmlDocPtr xml_parse(text *data, bool is_document, bool preserve_whitespace); #endif /* USE_LIBXML */ #define NO_XML_SUPPORT() \ ereport(ERROR, \ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), \ errmsg("no XML support in this installation"))) Datum xml_in(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML char *s = PG_GETARG_CSTRING(0); size_t len; xmltype *vardata; len = strlen(s); vardata = palloc(len + VARHDRSZ); VARATT_SIZEP(vardata) = len + VARHDRSZ; memcpy(VARDATA(vardata), s, len); /* * Parse the data to check if it is well-formed XML data. Assume * that ERROR occurred if parsing failed. */ xml_parse(vardata, false, true); PG_RETURN_XML_P(vardata); #else NO_XML_SUPPORT(); return 0; #endif } Datum xml_out(PG_FUNCTION_ARGS) { xmltype *s = PG_GETARG_XML_P(0); char *result; int32 len; len = VARSIZE(s) - VARHDRSZ; result = palloc(len + 1); memcpy(result, VARDATA(s), len); result[len] = '\0'; PG_RETURN_CSTRING(result); } Datum xml_recv(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML StringInfo buf = (StringInfo) PG_GETARG_POINTER(0); xmltype *result; char *str; int nbytes; str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes); result = (xmltype *) palloc(nbytes + VARHDRSZ); VARATT_SIZEP(result) = nbytes + VARHDRSZ; memcpy(VARDATA(result), str, nbytes); pfree(str); /* * Parse the data to check if it is well-formed XML data. Assume * that ERROR occurred if parsing failed. */ xml_parse(result, false, true); PG_RETURN_XML_P(result); #else NO_XML_SUPPORT(); return 0; #endif } Datum xml_send(PG_FUNCTION_ARGS) { xmltype *x = PG_GETARG_XML_P(0); StringInfoData buf; pq_begintypsend(&buf); pq_sendbytes(&buf, VARDATA(x), VARSIZE(x) - VARHDRSZ); PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); } #ifdef USE_LIBXML static void appendStringInfoText(StringInfo str, const text *t) { appendBinaryStringInfo(str, VARDATA(t), VARSIZE(t) - VARHDRSZ); } static xmltype * stringinfo_to_xmltype(StringInfo buf) { int32 len; xmltype *result; len = buf->len + VARHDRSZ; result = palloc(len); VARATT_SIZEP(result) = len; memcpy(VARDATA(result), buf->data, buf->len); return result; } #endif Datum xmlcomment(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML text *arg = PG_GETARG_TEXT_P(0); int len = VARATT_SIZEP(arg) - VARHDRSZ; StringInfoData buf; int i; /* check for "--" in string or "-" at the end */ for (i = 1; i < len; i++) if ((VARDATA(arg)[i] == '-' && VARDATA(arg)[i - 1] == '-') || (VARDATA(arg)[i] == '-' && i == len - 1)) ereport(ERROR, (errcode(ERRCODE_INVALID_XML_COMMENT), errmsg("invalid XML comment"))); initStringInfo(&buf); appendStringInfo(&buf, ""); PG_RETURN_XML_P(stringinfo_to_xmltype(&buf)); #else NO_XML_SUPPORT(); return 0; #endif } Datum texttoxml(PG_FUNCTION_ARGS) { text *data = PG_GETARG_TEXT_P(0); PG_RETURN_XML_P(xmlparse(data, false, true)); } xmltype * xmlparse(text *data, bool is_document, bool preserve_whitespace) { #ifdef USE_LIBXML xml_parse(data, is_document, preserve_whitespace); return (xmltype *) data; #else NO_XML_SUPPORT(); return NULL; #endif } xmltype * xmlpi(char *target, text *arg) { #ifdef USE_LIBXML xmltype *result; StringInfoData buf; if (pg_strncasecmp(target, "xml", 3) == 0) ereport(ERROR, (errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION), errmsg("invalid XML processing instruction"), errdetail("XML processing instruction target name cannot start with \"xml\"."))); initStringInfo(&buf); appendStringInfo(&buf, "") != NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION), errmsg("invalid XML processing instruction"), errdetail("XML processing instruction cannot contain \"?>\"."))); appendStringInfoChar(&buf, ' '); appendStringInfoString(&buf, string); pfree(string); } appendStringInfoString(&buf, "?>"); result = stringinfo_to_xmltype(&buf); pfree(buf.data); return result; #else NO_XML_SUPPORT(); return NULL; #endif } xmltype * xmlroot(xmltype *data, text *version, int standalone) { #ifdef USE_LIBXML xmltype *result; StringInfoData buf; initStringInfo(&buf); /* * FIXME: This is probably supposed to be cleverer if there * already is an XML preamble. */ appendStringInfo(&buf,""); appendStringInfoText(&buf, (text *) data); result = stringinfo_to_xmltype(&buf); pfree(buf.data); return result; #else NO_XML_SUPPORT(); return NULL; #endif } /* * Validate document (given as string) against DTD (given as external link) * TODO !!! use text instead of cstring for second arg * TODO allow passing DTD as a string value (not only as an URI) * TODO redesign (see comment with '!!!' below) */ Datum xmlvalidate(PG_FUNCTION_ARGS) { #ifdef USE_LIBXML text *data = PG_GETARG_TEXT_P(0); text *dtdOrUri = PG_GETARG_TEXT_P(1); bool result = false; xmlParserCtxtPtr ctxt = NULL; xmlDocPtr doc = NULL; xmlDtdPtr dtd = NULL; xml_init(); /* We use a PG_TRY block to ensure libxml is cleaned up on error */ PG_TRY(); { ctxt = xmlNewParserCtxt(); if (ctxt == NULL) xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR, "could not allocate parser context", ctxt); doc = xmlCtxtReadMemory(ctxt, (char *) VARDATA(data), VARSIZE(data) - VARHDRSZ, PG_XML_DEFAULT_URI, NULL, 0); if (doc == NULL) xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT, "could not parse XML data", ctxt); #if 0 uri = xmlCreateURI(); elog(NOTICE, "dtd - %s", dtdOrUri); dtd = palloc(sizeof(xmlDtdPtr)); uri = xmlParseURI(dtdOrUri); if (uri == NULL) xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR, "not implemented yet... (TODO)", ctxt); else #endif dtd = xmlParseDTD(NULL, xml_text2xmlChar(dtdOrUri)); if (dtd == NULL) xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT, "could not load DTD", ctxt); if (xmlValidateDtd(xmlNewValidCtxt(), doc, dtd) == 1) result = true; if (!result) xml_ereport(NOTICE, ERRCODE_INVALID_XML_DOCUMENT, "validation against DTD failed", ctxt); #if 0 if (uri) xmlFreeURI(uri); #endif if (dtd) xmlFreeDtd(dtd); if (doc) xmlFreeDoc(doc); if (ctxt) xmlFreeParserCtxt(ctxt); xmlCleanupParser(); } PG_CATCH(); { #if 0 if (uri) xmlFreeURI(uri); #endif if (dtd) xmlFreeDtd(dtd); if (doc) xmlFreeDoc(doc); if (ctxt) xmlFreeParserCtxt(ctxt); xmlCleanupParser(); PG_RE_THROW(); } PG_END_TRY(); PG_RETURN_BOOL(result); #else /* not USE_LIBXML */ NO_XML_SUPPORT(); return 0; #endif /* not USE_LIBXML */ } #ifdef USE_LIBXML /* * Container for some init stuff (not good design!) * TODO xmlChar is utf8-char, make proper tuning (initdb with enc!=utf8 and check) */ static void xml_init(void) { /* * Currently, we have no pure UTF-8 support for internals -- check * if we can work. */ if (sizeof (char) != sizeof (xmlChar)) ereport(ERROR, (errmsg("could not initialize XML library"), errdetail("libxml2 has incompatible char type: sizeof(char)=%u, sizeof(xmlChar)=%u.", (int) sizeof(char), (int) sizeof(xmlChar)))); if (xml_err_buf == NULL) { /* First time through: create error buffer in permanent context */ MemoryContext oldcontext; oldcontext = MemoryContextSwitchTo(TopMemoryContext); xml_err_buf = makeStringInfo(); MemoryContextSwitchTo(oldcontext); } else { /* Reset pre-existing buffer to empty */ xml_err_buf->data[0] = '\0'; xml_err_buf->len = 0; } /* Now that xml_err_buf exists, safe to call xml_errorHandler */ xmlSetGenericErrorFunc(NULL, xml_errorHandler); xmlMemSetup(xml_pfree, xml_palloc, xml_repalloc, xml_pstrdup); xmlInitParser(); LIBXML_TEST_VERSION; } /* * Convert a C string to XML internal representation * * TODO maybe, libxml2's xmlreader is better? (do not construct DOM, yet do not use SAX - see xml_reader.c) * TODO what about internal URI for docs? (see PG_XML_DEFAULT_URI below) */ static xmlDocPtr xml_parse(text *data, bool is_document, bool preserve_whitespace) { int res_code; int32 len; xmlChar *string; xmlParserCtxtPtr ctxt = NULL; xmlDocPtr doc = NULL; len = VARSIZE(data) - VARHDRSZ; /* will be useful later */ string = xml_text2xmlChar(data); xml_init(); /* We use a PG_TRY block to ensure libxml is cleaned up on error */ PG_TRY(); { ctxt = xmlNewParserCtxt(); if (ctxt == NULL) xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR, "could not allocate parser context", ctxt); if (is_document) { /* * Note, that here we try to apply DTD defaults * (XML_PARSE_DTDATTR) according to SQL/XML:10.16.7.d: * 'Default valies defined by internal DTD are applied'. * As for external DTDs, we try to support them too, (see * SQL/XML:10.16.7.e) */ doc = xmlCtxtReadMemory(ctxt, (char *) string, len, PG_XML_DEFAULT_URI, NULL, XML_PARSE_NOENT | XML_PARSE_DTDATTR | (preserve_whitespace ? 0 : XML_PARSE_NOBLANKS)); if (doc == NULL) xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT, "invalid XML document", ctxt); } else { doc = xmlNewDoc(NULL); /* * FIXME: An XMLDecl is supposed to be accepted before the * content, but libxml doesn't allow this. Parse that * ourselves? */ /* TODO resolve: xmlParseBalancedChunkMemory assumes that string is UTF8 encoded! */ res_code = xmlParseBalancedChunkMemory(doc, NULL, NULL, 0, string, NULL); if (res_code != 0) xml_ereport_by_code(ERROR, ERRCODE_INVALID_XML_CONTENT, "invalid XML content", res_code); } /* TODO encoding issues * (thoughts: * CASE: * - XML data has explicit encoding attribute in its prolog * - if not, assume that enc. of XML data is the same as client's one * * The common rule is to accept the XML data only if its encoding * is the same as encoding of the storage (server's). The other possible * option is to accept all the docs, but DO TRANSFORMATION and, if needed, * change the prolog. * * I think I'd stick the first way (for the 1st version), * it's much simplier (less errors...) * ) */ /* ... */ if (doc) xmlFreeDoc(doc); if (ctxt) xmlFreeParserCtxt(ctxt); xmlCleanupParser(); } PG_CATCH(); { if (doc) xmlFreeDoc(doc); if (ctxt) xmlFreeParserCtxt(ctxt); xmlCleanupParser(); PG_RE_THROW(); } PG_END_TRY(); return doc; } /* * xmlChar<->text convertions */ static xmlChar * xml_text2xmlChar(text *in) { int32 len = VARSIZE(in) - VARHDRSZ; xmlChar *res; res = palloc(len + 1); memcpy(res, VARDATA(in), len); res[len] = '\0'; return(res); } /* * Wrappers for memory management functions */ static void * xml_palloc(size_t size) { return palloc(size); } static void * xml_repalloc(void *ptr, size_t size) { return repalloc(ptr, size); } static void xml_pfree(void *ptr) { pfree(ptr); } static char * xml_pstrdup(const char *string) { return pstrdup(string); } /* * Wrapper for "ereport" function. * Adds detail - libxml's native error message, if any. */ static void xml_ereport(int level, int sqlcode, const char *msg, void *ctxt) { xmlErrorPtr libxmlErr = NULL; if (xml_err_buf->len > 0) { ereport(DEBUG1, (errmsg("%s", xml_err_buf->data))); xml_err_buf->data[0] = '\0'; xml_err_buf->len = 0; } if (ctxt != NULL) libxmlErr = xmlCtxtGetLastError(ctxt); if (libxmlErr == NULL) { ereport(level, (errcode(sqlcode), errmsg("%s", msg))); } else { /* as usual, libxml error message contains '\n'; get rid of it */ char *xmlErrDetail; int xmlErrLen, i; xmlErrDetail = pstrdup(libxmlErr->message); xmlErrLen = strlen(xmlErrDetail); for (i = 0; i < xmlErrLen; i++) { if (xmlErrDetail[i] == '\n') xmlErrDetail[i] = '.'; } ereport(level, (errcode(sqlcode), errmsg("%s", msg), errdetail("%s", xmlErrDetail))); } } /* * Error handler for libxml error messages */ static void xml_errorHandler(void *ctxt, const char *msg,...) { /* Append the formatted text to xml_err_buf */ for (;;) { va_list args; bool success; /* Try to format the data. */ va_start(args, msg); success = appendStringInfoVA(xml_err_buf, msg, args); va_end(args); if (success) break; /* Double the buffer size and try again. */ enlargeStringInfo(xml_err_buf, xml_err_buf->maxlen); } } /* * Return error message by libxml error code * TODO make them closer to recommendations from Postgres manual */ static void xml_ereport_by_code(int level, int sqlcode, const char *msg, int code) { const char *det; if (xml_err_buf->len > 0) { ereport(DEBUG1, (errmsg("%s", xml_err_buf->data))); xml_err_buf->data[0] = '\0'; xml_err_buf->len = 0; } switch (code) { case XML_ERR_INTERNAL_ERROR: det = "libxml internal error"; break; case XML_ERR_ENTITY_LOOP: det = "Detected an entity reference loop"; break; case XML_ERR_ENTITY_NOT_STARTED: det = "EntityValue: \" or ' expected"; break; case XML_ERR_ENTITY_NOT_FINISHED: det = "EntityValue: \" or ' expected"; break; case XML_ERR_ATTRIBUTE_NOT_STARTED: det = "AttValue: \" or ' expected"; break; case XML_ERR_LT_IN_ATTRIBUTE: det = "Unescaped '<' not allowed in attributes values"; break; case XML_ERR_LITERAL_NOT_STARTED: det = "SystemLiteral \" or ' expected"; break; case XML_ERR_LITERAL_NOT_FINISHED: det = "Unfinished System or Public ID \" or ' expected"; break; case XML_ERR_MISPLACED_CDATA_END: det = "Sequence ']]>' not allowed in content"; break; case XML_ERR_URI_REQUIRED: det = "SYSTEM or PUBLIC, the URI is missing"; break; case XML_ERR_PUBID_REQUIRED: det = "PUBLIC, the Public Identifier is missing"; break; case XML_ERR_HYPHEN_IN_COMMENT: det = "Comment must not contain '--' (double-hyphen)"; break; case XML_ERR_PI_NOT_STARTED: det = "xmlParsePI : no target name"; break; case XML_ERR_RESERVED_XML_NAME: det = "Invalid PI name"; break; case XML_ERR_NOTATION_NOT_STARTED: det = "NOTATION: Name expected here"; break; case XML_ERR_NOTATION_NOT_FINISHED: det = "'>' required to close NOTATION declaration"; break; case XML_ERR_VALUE_REQUIRED: det = "Entity value required"; break; case XML_ERR_URI_FRAGMENT: det = "Fragment not allowed"; break; case XML_ERR_ATTLIST_NOT_STARTED: det = "'(' required to start ATTLIST enumeration"; break; case XML_ERR_NMTOKEN_REQUIRED: det = "NmToken expected in ATTLIST enumeration"; break; case XML_ERR_ATTLIST_NOT_FINISHED: det = "')' required to finish ATTLIST enumeration"; break; case XML_ERR_MIXED_NOT_STARTED: det = "MixedContentDecl : '|' or ')*' expected"; break; case XML_ERR_PCDATA_REQUIRED: det = "MixedContentDecl : '#PCDATA' expected"; break; case XML_ERR_ELEMCONTENT_NOT_STARTED: det = "ContentDecl : Name or '(' expected"; break; case XML_ERR_ELEMCONTENT_NOT_FINISHED: det = "ContentDecl : ',' '|' or ')' expected"; break; case XML_ERR_PEREF_IN_INT_SUBSET: det = "PEReference: forbidden within markup decl in internal subset"; break; case XML_ERR_GT_REQUIRED: det = "Expected '>'"; break; case XML_ERR_CONDSEC_INVALID: det = "XML conditional section '[' expected"; break; case XML_ERR_EXT_SUBSET_NOT_FINISHED: det = "Content error in the external subset"; break; case XML_ERR_CONDSEC_INVALID_KEYWORD: det = "conditional section INCLUDE or IGNORE keyword expected"; break; case XML_ERR_CONDSEC_NOT_FINISHED: det = "XML conditional section not closed"; break; case XML_ERR_XMLDECL_NOT_STARTED: det = "Text declaration '' expected"; break; case XML_ERR_EXT_ENTITY_STANDALONE: det = "external parsed entities cannot be standalone"; break; case XML_ERR_ENTITYREF_SEMICOL_MISSING: det = "EntityRef: expecting ';'"; break; case XML_ERR_DOCTYPE_NOT_FINISHED: det = "DOCTYPE improperly terminated"; break; case XML_ERR_LTSLASH_REQUIRED: det = "EndTag: '> 6) & 0x1F); utf8string[1] = 0x80 | (c & 0x3F); } else if (c <= 0xFFFF) { utf8string[0] = 0xE0 | ((c >> 12) & 0x0F); utf8string[1] = 0x80 | ((c >> 6) & 0x3F); utf8string[2] = 0x80 | (c & 0x3F); } else { utf8string[0] = 0xF0 | ((c >> 18) & 0x07); utf8string[1] = 0x80 | ((c >> 12) & 0x3F); utf8string[2] = 0x80 | ((c >> 6) & 0x3F); utf8string[3] = 0x80 | (c & 0x3F); } return (char *) pg_do_encoding_conversion((unsigned char *) utf8string, pg_mblen(utf8string), PG_UTF8, GetDatabaseEncoding()); } static bool is_valid_xml_namefirst(pg_wchar c) { /* (Letter | '_' | ':') */ return (xmlIsBaseCharQ(c) || xmlIsIdeographicQ(c) || c == '_' || c == ':'); } static bool is_valid_xml_namechar(pg_wchar c) { /* Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender */ return (xmlIsBaseCharQ(c) || xmlIsIdeographicQ(c) || xmlIsDigitQ(c) || c == '.' || c == '-' || c == '_' || c == ':' || xmlIsCombiningQ(c) || xmlIsExtenderQ(c)); } #endif /* USE_LIBXML */ /* * Map SQL identifier to XML name; see SQL/XML:2003 section 9.1. */ char * map_sql_identifier_to_xml_name(char *ident, bool fully_escaped) { #ifdef USE_LIBXML StringInfoData buf; char *p; initStringInfo(&buf); for (p = ident; *p; p += pg_mblen(p)) { if (*p == ':' && (p == ident || fully_escaped)) appendStringInfo(&buf, "_x003A_"); else if (*p == '_' && *(p+1) == 'x') appendStringInfo(&buf, "_x005F_"); else if (fully_escaped && p == ident && pg_strncasecmp(p, "xml", 3) == 0) { if (*p == 'x') appendStringInfo(&buf, "_x0078_"); else appendStringInfo(&buf, "_x0058_"); } else { pg_wchar u = sqlchar_to_unicode(p); if ((p == ident) ? !is_valid_xml_namefirst(u) : !is_valid_xml_namechar(u)) appendStringInfo(&buf, "_x%04X_", (unsigned int) u); else appendBinaryStringInfo(&buf, p, pg_mblen(p)); } } return buf.data; #else /* not USE_LIBXML */ NO_XML_SUPPORT(); return NULL; #endif /* not USE_LIBXML */ } /* * The inverse; see SQL/XML:2003 section 9.17. */ char * map_xml_name_to_sql_identifier(char *name) { StringInfoData buf; char *p; initStringInfo(&buf); for (p = name; *p; p += pg_mblen(p)) { if (*p == '_' && *(p+1) == 'x' && isxdigit((unsigned char) *(p+2)) && isxdigit((unsigned char) *(p+3)) && isxdigit((unsigned char) *(p+4)) && isxdigit((unsigned char) *(p+5)) && *(p+6) == '_') { unsigned int u; sscanf(p + 2, "%X", &u); appendStringInfoString(&buf, unicode_to_sqlchar(u)); p += 6; } else appendBinaryStringInfo(&buf, p, pg_mblen(p)); } return buf.data; }