/** * htmlDocDumpMemory: * @cur: the document * @mem: OUT: the memory pointer * @size: OUT: the memory length * * Dump an HTML document in memory and return the xmlChar * and it's size. * It's up to the caller to free the memory. */ void htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) { xmlOutputBufferPtr buf; xmlCharEncodingHandlerPtr handler = NULL; const char *encoding; xmlInitParser(); if (cur == NULL) { #ifdef DEBUG_TREE xmlGenericError(xmlGenericErrorContext, "htmlDocDumpMemory : document == NULL\n"); #endif *mem = NULL; *size = 0; return; } encoding = (const char *) htmlGetMetaEncoding(cur); if (encoding != NULL) { xmlCharEncoding enc; enc = xmlParseCharEncoding(encoding); if (enc != cur->charset) { if (cur->charset != XML_CHAR_ENCODING_UTF8) { /* * Not supported yet */ *mem = NULL; *size = 0; return; } handler = xmlFindCharEncodingHandler(encoding); if (handler == NULL) { *mem = NULL; *size = 0; return; } } } /* * Fallback to HTML or ASCII when the encoding is unspecified */ if (handler == NULL) handler = xmlFindCharEncodingHandler("HTML"); if (handler == NULL) handler = xmlFindCharEncodingHandler("ascii"); buf = xmlAllocOutputBuffer(handler); if (buf == NULL) { *mem = NULL; *size = 0; return; } htmlDocContentDumpOutput(buf, cur, NULL); xmlOutputBufferFlush(buf); if (buf->conv != NULL) { *size = buf->conv->use; *mem = xmlStrndup(buf->conv->content, *size); } else { *size = buf->buffer->use; *mem = xmlStrndup(buf->buffer->content, *size); } (void)xmlOutputBufferClose(buf); }
/** * Parse command line for XSLT parameters */ int trParseParams(const char** params, int* plen, int count, char **argv) { int i; *plen = 0; params[0] = 0; for (i=0; i<count; i++) { if (argv[i][0] == '-') { if (!strcmp(argv[i], "-p")) { int j; xmlChar *name, *value; i++; if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS); for(j=0; argv[i][j] && (argv[i][j] != '='); j++); if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS); name = xmlStrndup((const xmlChar *) argv[i], j); value = xmlStrdup((const xmlChar *) argv[i]+j+1); if (*plen >= MAX_PARAMETERS) { fprintf(stderr, "too many params increase MAX_PARAMETERS\n"); exit(EXIT_INTERNAL_ERROR); } params[*plen] = (char *)name; (*plen)++; params[*plen] = (char *)value; (*plen)++; params[*plen] = 0; } else if (!strcmp(argv[i], "-s")) { int j; const xmlChar *string; xmlChar *name, *value; i++; if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS); for(j=0; argv[i][j] && (argv[i][j] != '='); j++); if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS); name = xmlStrndup((const xmlChar *)argv[i], j); string = (const xmlChar *)(argv[i]+j+1); if (xmlStrchr(string, '"')) { if (xmlStrchr(string, '\'')) { fprintf(stderr, "string parameter contains both quote and double-quotes\n"); exit(EXIT_INTERNAL_ERROR); } value = xmlStrdup((const xmlChar *)"'"); value = xmlStrcat(value, string); value = xmlStrcat(value, (const xmlChar *)"'"); } else { value = xmlStrdup((const xmlChar *)"\""); value = xmlStrcat(value, string); value = xmlStrcat(value, (const xmlChar *)"\""); } if (*plen >= MAX_PARAMETERS) { fprintf(stderr, "too many params increase MAX_PARAMETERS\n"); exit(EXIT_INTERNAL_ERROR); } params[*plen] = (char *)name; (*plen)++; params[*plen] = (char *)value; (*plen)++; params[*plen] = 0; } } else break; } return i; }
/** * xsltAttrTemplateValueProcessNode: * @ctxt: the XSLT transformation context * @str: the attribute template node value * @inst: the instruction (or LRE) in the stylesheet holding the * attribute with an AVT * * Process the given string, allowing to pass a namespace mapping * context and return the new string value. * * Called by: * - xsltAttrTemplateValueProcess() (templates.c) * - xsltEvalAttrValueTemplate() (templates.c) * * QUESTION: Why is this function public? It is not used outside * of templates.c. * * Returns the computed string value or NULL, must be deallocated by the * caller. */ xmlChar * xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt, const xmlChar *str, xmlNodePtr inst) { xmlChar *ret = NULL; const xmlChar *cur; xmlChar *expr, *val; xmlNsPtr *nsList = NULL; int nsNr = 0; if (str == NULL) return(NULL); if (*str == 0) return(xmlStrndup((xmlChar *)"", 0)); cur = str; while (*cur != 0) { if (*cur == '{') { if (*(cur+1) == '{') { /* escaped '{' */ cur++; ret = xmlStrncat(ret, str, cur - str); cur++; str = cur; continue; } ret = xmlStrncat(ret, str, cur - str); str = cur; cur++; while ((*cur != 0) && (*cur != '}')) cur++; if (*cur == 0) { xsltTransformError(ctxt, NULL, inst, "xsltAttrTemplateValueProcessNode: unmatched '{'\n"); ret = xmlStrncat(ret, str, cur - str); return(ret); } str++; expr = xmlStrndup(str, cur - str); if (expr == NULL) return(ret); else if (*expr == '{') { ret = xmlStrcat(ret, expr); xmlFree(expr); } else { xmlXPathCompExprPtr comp; /* * TODO: keep precompiled form around */ if ((nsList == NULL) && (inst != NULL)) { int i = 0; nsList = xmlGetNsList(inst->doc, inst); if (nsList != NULL) { while (nsList[i] != NULL) i++; nsNr = i; } } comp = xmlXPathCompile(expr); val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList); xmlXPathFreeCompExpr(comp); xmlFree(expr); if (val != NULL) { ret = xmlStrcat(ret, val); xmlFree(val); } } cur++; str = cur; } else if (*cur == '}') { cur++; if (*cur == '}') { /* escaped '}' */ ret = xmlStrncat(ret, str, cur - str); cur++; str = cur; continue; } else { xsltTransformError(ctxt, NULL, inst, "xsltAttrTemplateValueProcessNode: unmatched '}'\n"); } } else cur++; } if (cur != str) { ret = xmlStrncat(ret, str, cur - str); } if (nsList != NULL) xmlFree(nsList); return(ret); }
static void _start_element_handler_ns(void *user, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI, int nb_namespaces, const xmlChar ** namespaces, int nb_attributes, int nb_defaulted, const xmlChar ** attributes) { XML_Parser parser = (XML_Parser) user; xmlChar *qualified_name = NULL; xmlChar **attrs = NULL; int i; int z = 0; int y = 0; if (nb_namespaces > 0 && parser->h_start_ns != NULL) { for (i = 0; i < nb_namespaces; i += 1) { parser->h_start_ns(parser->user, (const XML_Char *) namespaces[y], (const XML_Char *) namespaces[y+1]); y += 2; } y = 0; } if (parser->h_start_element == NULL) { if (parser->h_default) { if (prefix) { qualified_name = xmlStrncatNew((xmlChar *)"<", prefix, xmlStrlen(prefix)); qualified_name = xmlStrncat(qualified_name, (xmlChar *)":", 1); qualified_name = xmlStrncat(qualified_name, name, xmlStrlen(name)); } else { qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name)); } if (namespaces) { int i, j; for (i = 0,j = 0;j < nb_namespaces;j++) { int ns_len; char *ns_string, *ns_prefix, *ns_url; ns_prefix = (char *) namespaces[i++]; ns_url = (char *) namespaces[i++]; if (ns_prefix) { ns_len = spprintf(&ns_string, 0, " xmlns:%s=\"%s\"", ns_prefix, ns_url); } else { ns_len = spprintf(&ns_string, 0, " xmlns=\"%s\"", ns_url); } qualified_name = xmlStrncat(qualified_name, (xmlChar *)ns_string, ns_len); efree(ns_string); } } if (attributes) { for (i = 0; i < nb_attributes; i += 1) { int att_len; char *att_string, *att_name, *att_value, *att_prefix, *att_valueend; att_name = (char *) attributes[y++]; att_prefix = (char *)attributes[y++]; y++; att_value = (char *)attributes[y++]; att_valueend = (char *)attributes[y++]; if (att_prefix) { att_len = spprintf(&att_string, 0, " %s:%s=\"", att_prefix, att_name); } else { att_len = spprintf(&att_string, 0, " %s=\"", att_name); } qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len); qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_value, att_valueend - att_value); qualified_name = xmlStrncat(qualified_name, (xmlChar *)"\"", 1); efree(att_string); } } qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1); parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name)); xmlFree(qualified_name); } return; } _qualify_namespace(parser, name, URI, &qualified_name); if (attributes != NULL) { xmlChar *qualified_name_attr = NULL; attrs = safe_emalloc((nb_attributes * 2) + 1, sizeof(int *), 0); for (i = 0; i < nb_attributes; i += 1) { if (attributes[y+1] != NULL) { _qualify_namespace(parser, attributes[y] , attributes[y + 2], &qualified_name_attr); } else { qualified_name_attr = xmlStrdup(attributes[y]); } attrs[z] = qualified_name_attr; attrs[z + 1] = xmlStrndup(attributes[y + 3] , (int) (attributes[y + 4] - attributes[y + 3])); z += 2; y += 5; } attrs[z] = NULL; } parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attrs); if (attrs) { for (i = 0; i < z; i++) { xmlFree(attrs[i]); } efree(attrs); } xmlFree(qualified_name); }
/** * htmlDocDumpMemoryFormat: * @cur: the document * @mem: OUT: the memory pointer * @size: OUT: the memory length * @format: should formatting spaces been added * * Dump an HTML document in memory and return the xmlChar * and it's size. * It's up to the caller to free the memory. */ void htmlDocDumpMemoryFormat(xmlDocPtr cur, xmlChar**mem, int *size, int format) { xmlOutputBufferPtr buf; xmlCharEncodingHandlerPtr handler = NULL; const char *encoding; xmlInitParser(); if ((mem == NULL) || (size == NULL)) return; if (cur == NULL) { *mem = NULL; *size = 0; return; } encoding = (const char *) htmlGetMetaEncoding(cur); if (encoding != NULL) { xmlCharEncoding enc; enc = xmlParseCharEncoding(encoding); if (enc != cur->charset) { if (cur->charset != XML_CHAR_ENCODING_UTF8) { /* * Not supported yet */ *mem = NULL; *size = 0; return; } handler = xmlFindCharEncodingHandler(encoding); if (handler == NULL) htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding); } else { handler = xmlFindCharEncodingHandler(encoding); } } /* * Fallback to HTML or ASCII when the encoding is unspecified */ if (handler == NULL) handler = xmlFindCharEncodingHandler("HTML"); if (handler == NULL) handler = xmlFindCharEncodingHandler("ascii"); buf = xmlAllocOutputBufferInternal(handler); if (buf == NULL) { *mem = NULL; *size = 0; return; } htmlDocContentDumpFormatOutput(buf, cur, NULL, format); xmlOutputBufferFlush(buf); if (buf->conv != NULL) { *size = xmlBufUse(buf->conv); *mem = xmlStrndup(xmlBufContent(buf->conv), *size); } else { *size = xmlBufUse(buf->buffer); *mem = xmlStrndup(xmlBufContent(buf->buffer), *size); } (void)xmlOutputBufferClose(buf); }
/* * xmlAddEntity : register a new entity for an entities table. */ static xmlEntityPtr xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type, const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content) { xmlDictPtr dict = NULL; xmlEntitiesTablePtr table = NULL; xmlEntityPtr ret; if (name == NULL) return(NULL); if (dtd == NULL) return(NULL); if (dtd->doc != NULL) dict = dtd->doc->dict; switch (type) { case XML_INTERNAL_GENERAL_ENTITY: case XML_EXTERNAL_GENERAL_PARSED_ENTITY: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: if (dtd->entities == NULL) dtd->entities = xmlHashCreateDict(0, dict); table = dtd->entities; break; case XML_INTERNAL_PARAMETER_ENTITY: case XML_EXTERNAL_PARAMETER_ENTITY: if (dtd->pentities == NULL) dtd->pentities = xmlHashCreateDict(0, dict); table = dtd->pentities; break; case XML_INTERNAL_PREDEFINED_ENTITY: return(NULL); } if (table == NULL) return(NULL); ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); if (ret == NULL) { xmlEntitiesErrMemory("xmlAddEntity:: malloc failed"); return(NULL); } memset(ret, 0, sizeof(xmlEntity)); ret->type = XML_ENTITY_DECL; ret->checked = 0; /* * fill the structure. */ ret->etype = (xmlEntityType) type; if (dict == NULL) { ret->name = xmlStrdup(name); if (ExternalID != NULL) ret->ExternalID = xmlStrdup(ExternalID); if (SystemID != NULL) ret->SystemID = xmlStrdup(SystemID); } else { ret->name = xmlDictLookup(dict, name, -1); if (ExternalID != NULL) ret->ExternalID = xmlDictLookup(dict, ExternalID, -1); if (SystemID != NULL) ret->SystemID = xmlDictLookup(dict, SystemID, -1); } if (content != NULL) { ret->length = xmlStrlen(content); if ((dict != NULL) && (ret->length < 5)) ret->content = (xmlChar *) xmlDictLookup(dict, content, ret->length); else ret->content = xmlStrndup(content, ret->length); } else { ret->length = 0; ret->content = NULL; } ret->URI = NULL; /* to be computed by the layer knowing the defining entity */ ret->orig = NULL; ret->owner = 0; ret->doc = dtd->doc; if (xmlHashAddEntry(table, name, ret)) { /* * entity was already defined at another level. */ xmlFreeEntity(ret); return(NULL); } return(ret); }
static void xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) { const char *cur = line; if (line == NULL) return; if (!strncmp(line, "HTTP/", 5)) { int version = 0; int ret = 0; cur += 5; while ((*cur >= '0') && (*cur <= '9')) { version *= 10; version += *cur - '0'; cur++; } if (*cur == '.') { cur++; if ((*cur >= '0') && (*cur <= '9')) { version *= 10; version += *cur - '0'; cur++; } while ((*cur >= '0') && (*cur <= '9')) cur++; } else version *= 10; if ((*cur != ' ') && (*cur != '\t')) return; while ((*cur == ' ') || (*cur == '\t')) cur++; if ((*cur < '0') || (*cur > '9')) return; while ((*cur >= '0') && (*cur <= '9')) { ret *= 10; ret += *cur - '0'; cur++; } if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return; ctxt->returnValue = ret; } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) { const xmlChar *charset, *last, *mime; cur += 13; while ((*cur == ' ') || (*cur == '\t')) cur++; if (ctxt->contentType != NULL) xmlFree(ctxt->contentType); ctxt->contentType = xmlMemStrdup(cur); mime = (const xmlChar *) cur; last = mime; while ((*last != 0) && (*last != ' ') && (*last != '\t') && (*last != ';') && (*last != ',')) last++; if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType); ctxt->mimeType = (char *) xmlStrndup(mime, last - mime); charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset="); if (charset != NULL) { charset += 8; last = charset; while ((*last != 0) && (*last != ' ') && (*last != '\t') && (*last != ';') && (*last != ',')) last++; if (ctxt->encoding != NULL) xmlFree(ctxt->encoding); ctxt->encoding = (char *) xmlStrndup(charset, last - charset); } } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) { const xmlChar *charset, *last, *mime; cur += 12; if (ctxt->contentType != NULL) return; while ((*cur == ' ') || (*cur == '\t')) cur++; ctxt->contentType = xmlMemStrdup(cur); mime = (const xmlChar *) cur; last = mime; while ((*last != 0) && (*last != ' ') && (*last != '\t') && (*last != ';') && (*last != ',')) last++; if (ctxt->mimeType != NULL) xmlFree(ctxt->mimeType); ctxt->mimeType = (char *) xmlStrndup(mime, last - mime); charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset="); if (charset != NULL) { charset += 8; last = charset; while ((*last != 0) && (*last != ' ') && (*last != '\t') && (*last != ';') && (*last != ',')) last++; if (ctxt->encoding != NULL) xmlFree(ctxt->encoding); ctxt->encoding = (char *) xmlStrndup(charset, last - charset); } } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) { cur += 9; while ((*cur == ' ') || (*cur == '\t')) cur++; if (ctxt->location != NULL) xmlFree(ctxt->location); if (*cur == '/') { xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://"); xmlChar *tmp_loc = xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname); ctxt->location = (char *) xmlStrcat (tmp_loc, (const xmlChar *) cur); } else { ctxt->location = xmlMemStrdup(cur); } } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) { cur += 17; while ((*cur == ' ') || (*cur == '\t')) cur++; if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader); ctxt->authHeader = xmlMemStrdup(cur); } else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) { cur += 19; while ((*cur == ' ') || (*cur == '\t')) cur++; if (ctxt->authHeader != NULL) xmlFree(ctxt->authHeader); ctxt->authHeader = xmlMemStrdup(cur); #ifdef HAVE_ZLIB_H } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) { cur += 17; while ((*cur == ' ') || (*cur == '\t')) cur++; if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) { ctxt->usesGzip = 1; ctxt->strm = xmlMalloc(sizeof(z_stream)); if (ctxt->strm != NULL) { ctxt->strm->zalloc = Z_NULL; ctxt->strm->zfree = Z_NULL; ctxt->strm->opaque = Z_NULL; ctxt->strm->avail_in = 0; ctxt->strm->next_in = Z_NULL; inflateInit2( ctxt->strm, 31 ); } } #endif } else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) { cur += 15; ctxt->ContentLength = strtol( cur, NULL, 10 ); } }
/** * xsltCompileAttr: * @style: a XSLT process context * @attr: the attribute coming from the stylesheet. * * Precompile an attribute in a stylesheet, basically it checks if it is * an attrubute value template, and if yes establish some structures needed * to process it at transformation time. */ void xsltCompileAttr(xsltStylesheetPtr style, xmlAttrPtr attr) { const xmlChar *str; const xmlChar *cur; xmlChar *ret = NULL; xmlChar *expr = NULL; xsltAttrVTPtr avt; int i = 0, lastavt = 0; if ((style == NULL) || (attr == NULL) || (attr->children == NULL)) return; if ((attr->children->type != XML_TEXT_NODE) || (attr->children->next != NULL)) { xsltTransformError(NULL, style, attr->parent, "Attribute '%s': The content is expected to be a single text " "node when compiling an AVT.\n", attr->name); style->errors++; return; } str = attr->children->content; if ((xmlStrchr(str, '{') == NULL) && (xmlStrchr(str, '}') == NULL)) return; #ifdef WITH_XSLT_DEBUG_AVT xsltGenericDebug(xsltGenericDebugContext, "Found AVT %s: %s\n", attr->name, str); #endif if (attr->psvi != NULL) { #ifdef WITH_XSLT_DEBUG_AVT xsltGenericDebug(xsltGenericDebugContext, "AVT %s: already compiled\n", attr->name); #endif return; } /* * Create a new AVT object. */ avt = xsltNewAttrVT(style); if (avt == NULL) return; attr->psvi = avt; avt->nsList = xmlGetNsList(attr->doc, attr->parent); if (avt->nsList != NULL) { while (avt->nsList[i] != NULL) i++; } avt->nsNr = i; cur = str; while (*cur != 0) { if (*cur == '{') { if (*(cur+1) == '{') { /* escaped '{' */ cur++; ret = xmlStrncat(ret, str, cur - str); cur++; str = cur; continue; } if (*(cur+1) == '}') { /* skip empty AVT */ ret = xmlStrncat(ret, str, cur - str); cur += 2; str = cur; continue; } if ((ret != NULL) || (cur - str > 0)) { ret = xmlStrncat(ret, str, cur - str); str = cur; if (avt->nb_seg == 0) avt->strstart = 1; if ((avt = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL) goto error; ret = NULL; lastavt = 0; } cur++; while ((*cur != 0) && (*cur != '}')) { /* Need to check for literal (bug539741) */ if ((*cur == '\'') || (*cur == '"')) { char delim = *(cur++); while ((*cur != 0) && (*cur != delim)) cur++; if (*cur != 0) cur++; /* skip the ending delimiter */ } else cur++; } if (*cur == 0) { xsltTransformError(NULL, style, attr->parent, "Attribute '%s': The AVT has an unmatched '{'.\n", attr->name); style->errors++; goto error; } str++; expr = xmlStrndup(str, cur - str); if (expr == NULL) { /* * TODO: What needs to be done here? */ XSLT_TODO goto error; } else { xmlXPathCompExprPtr comp; comp = xsltXPathCompile(style, expr); if (comp == NULL) { xsltTransformError(NULL, style, attr->parent, "Attribute '%s': Failed to compile the expression " "'%s' in the AVT.\n", attr->name, expr); style->errors++; goto error; } if (avt->nb_seg == 0) avt->strstart = 0; if (lastavt == 1) { if ((avt = xsltSetAttrVTsegment(avt, NULL)) == NULL) goto error; } if ((avt = xsltSetAttrVTsegment(avt, (void *) comp)) == NULL) goto error; lastavt = 1; xmlFree(expr); expr = NULL; } cur++; str = cur; } else if (*cur == '}') {
ngx_inline static ngx_http_xrlt_ctx_t * ngx_http_xrlt_create_ctx(ngx_http_request_t *r, size_t id) { ngx_http_xrlt_ctx_t *ctx; ngx_http_xrlt_loc_conf_t *conf; ngx_uint_t i, j; ngx_http_xrlt_param_t *params; xmlChar **xrltparams; conf = ngx_http_get_module_loc_conf(r, ngx_http_xrlt_module); ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_xrlt_ctx_t)); if (ctx == NULL) { return NULL; } if (id == 0) { ngx_pool_cleanup_t *cln; cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { return NULL; } dd("XRLT context creation"); if (conf->params != NULL && conf->params->nelts > 0) { params = conf->params->elts; xrltparams = ngx_palloc( r->pool, sizeof(xmlChar *) * (conf->params->nelts * 2 + 1) ); j = 0; for (i = 0; i < conf->params->nelts; i++) { xrltparams[j++] = xmlStrndup(params[i].name.data, params[i].name.len); xrltparams[j++] = xmlStrndup(params[i].value.value.data, params[i].value.value.len); } xrltparams[j] = NULL; } else { xrltparams = NULL; } ctx->xctx = xrltContextCreate(conf->sheet, xrltparams); ctx->id = 0; ctx->main_ctx = ctx; if (ctx->xctx == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to create XRLT context"); } cln->handler = ngx_http_xrlt_cleanup_context; cln->data = ctx->xctx; } else { ngx_http_xrlt_ctx_t *main_ctx; main_ctx = ngx_http_get_module_ctx(r->main, ngx_http_xrlt_module); if (main_ctx == NULL || main_ctx->xctx == NULL) { return NULL; } ctx->xctx = main_ctx->xctx; ctx->id = id; ctx->main_ctx = main_ctx; } return ctx; }
/* * xmlAddEntity : register a new entity for an entities table. */ static xmlEntityPtr xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type, const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content) { xmlEntitiesTablePtr table = NULL; xmlEntityPtr ret; if (name == NULL) return(NULL); switch (type) { case XML_INTERNAL_GENERAL_ENTITY: case XML_EXTERNAL_GENERAL_PARSED_ENTITY: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: if (dtd->entities == NULL) dtd->entities = xmlHashCreate(0); table = (xmlEntitiesTablePtr)dtd->entities; break; case XML_INTERNAL_PARAMETER_ENTITY: case XML_EXTERNAL_PARAMETER_ENTITY: if (dtd->pentities == NULL) dtd->pentities = xmlHashCreate(0); table = (xmlEntitiesTablePtr)dtd->pentities; break; case XML_INTERNAL_PREDEFINED_ENTITY: return(NULL); } if (table == NULL) return(NULL); ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); if (ret == NULL) { xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlAddEntity: out of memory\n")); return(NULL); } memset(ret, 0, sizeof(xmlEntity)); ret->type = XML_ENTITY_DECL; /* * fill the structure. */ ret->name = xmlStrdup(name); ret->etype = (xmlEntityType) type; if (ExternalID != NULL) ret->ExternalID = xmlStrdup(ExternalID); if (SystemID != NULL) ret->SystemID = xmlStrdup(SystemID); if (content != NULL) { ret->length = xmlStrlen(content); ret->content = xmlStrndup(content, ret->length); } else { ret->length = 0; ret->content = NULL; } ret->URI = NULL; /* to be computed by the layer knowing the defining entity */ ret->orig = NULL; ret->owner = 0; if (xmlHashAddEntry(table, name, ret)) { /* * entity was already defined at another level. */ xmlFreeEntity(ret); return(NULL); } return(ret); }
/** * Return the next token from the string */ static xQStatusCode nextToken(xQToken* tokenContext) { const xmlChar* start = tokenContext->strPtr; xmlChar* strStr = 0; xmlChar* strOut = 0; tokenContext->type = XQ_TT_NONE; if (tokenContext->content) xmlFree(tokenContext->content); tokenContext->content = 0; tokenContext->length = 0; // consume any leading space while (*start && xqIsSpace(*start)) ++start; // advance the pointer to the end of the token tokenContext->strPtr = start; // STRING if (*start == '"' || *start == '\'') { ++(tokenContext->strPtr); strStr = malloc(xmlStrlen(tokenContext->strPtr)); if ((!strStr) && *(tokenContext->strPtr)) return tokenContext->lastStatus = XQ_OUT_OF_MEMORY; strOut = strStr; while (*(tokenContext->strPtr)) { while (xqIsNotQuote(*(tokenContext->strPtr))) *(strOut++) = *(tokenContext->strPtr++); // escape if (*(tokenContext->strPtr) == '\\') { if (xqIsNotQuote(*(tokenContext->strPtr+1))) { *(strOut++) = *(tokenContext->strPtr++); *(strOut++) = *(tokenContext->strPtr++); } else if (*(tokenContext->strPtr+1)) { ++(tokenContext->strPtr); *(strOut++) = *(tokenContext->strPtr++); } // opposite quote } else if (*(tokenContext->strPtr) && (*(tokenContext->strPtr) != *start)) { *(strOut++) = *(tokenContext->strPtr++); // end of string } else if (*(tokenContext->strPtr)) { ++(tokenContext->strPtr); // move past the end of string marker *strOut = 0; tokenContext->type = XQ_TT_STRING; tokenContext->content = strStr; tokenContext->length = strOut - strStr; return tokenContext->lastStatus = XQ_OK; } } // unterminated string if (strStr) free(strStr); return tokenContext->lastStatus = XQ_INVALID_SEL_UNTERMINATED_STR; // TOKEN } else if (xqIsToken(*start)) { tokenContext->type = XQ_TT_TOKEN; ++(tokenContext->strPtr); // IDENT } else if (*start) { tokenContext->type = XQ_TT_IDENT; while (xqIsNotSpace(*(tokenContext->strPtr))) ++(tokenContext->strPtr); } else { return tokenContext->lastStatus = XQ_NO_TOKEN; } tokenContext->content = xmlStrndup(start, tokenContext->strPtr - start); tokenContext->length = tokenContext->strPtr - start; return tokenContext->lastStatus = XQ_OK; }
static void xsltNumberFormatTokenize(const xmlChar *format, xsltFormatPtr tokens) { int ix = 0; int j; int val; int len; default_token.token = DEFAULT_TOKEN; default_token.width = 1; default_token.separator = BAD_CAST(DEFAULT_SEPARATOR); tokens->start = NULL; tokens->tokens[0].separator = NULL; tokens->end = NULL; /* * Insert initial non-alphanumeric token. * There is always such a token in the list, even if NULL */ while (! (IS_LETTER(val=xmlStringCurrentChar(NULL, format+ix, &len)) || IS_DIGIT(val)) ) { if (format[ix] == 0) /* if end of format string */ break; /* while */ ix += len; } if (ix > 0) tokens->start = xmlStrndup(format, ix); for (tokens->nTokens = 0; tokens->nTokens < MAX_TOKENS; tokens->nTokens++) { if (format[ix] == 0) break; /* for */ /* * separator has already been parsed (except for the first * number) in tokens->end, recover it. */ if (tokens->nTokens > 0) { tokens->tokens[tokens->nTokens].separator = tokens->end; tokens->end = NULL; } val = xmlStringCurrentChar(NULL, format+ix, &len); if (IS_DIGIT_ONE(val) || IS_DIGIT_ZERO(val)) { tokens->tokens[tokens->nTokens].width = 1; while (IS_DIGIT_ZERO(val)) { tokens->tokens[tokens->nTokens].width++; ix += len; val = xmlStringCurrentChar(NULL, format+ix, &len); } if (IS_DIGIT_ONE(val)) { tokens->tokens[tokens->nTokens].token = val - 1; ix += len; val = xmlStringCurrentChar(NULL, format+ix, &len); } } else if ( (val == (xmlChar)'A') || (val == (xmlChar)'a') || (val == (xmlChar)'I') || (val == (xmlChar)'i') ) { tokens->tokens[tokens->nTokens].token = val; ix += len; val = xmlStringCurrentChar(NULL, format+ix, &len); } else { /* XSLT section 7.7 * "Any other format token indicates a numbering sequence * that starts with that token. If an implementation does * not support a numbering sequence that starts with that * token, it must use a format token of 1." */ tokens->tokens[tokens->nTokens].token = (xmlChar)'0'; tokens->tokens[tokens->nTokens].width = 1; } /* * Skip over remaining alphanumeric characters from the Nd * (Number, decimal digit), Nl (Number, letter), No (Number, * other), Lu (Letter, uppercase), Ll (Letter, lowercase), Lt * (Letters, titlecase), Lm (Letters, modifiers), and Lo * (Letters, other (uncased)) Unicode categories. This happens * to correspond to the Letter and Digit classes from XML (and * one wonders why XSLT doesn't refer to these instead). */ while (IS_LETTER(val) || IS_DIGIT(val)) { ix += len; val = xmlStringCurrentChar(NULL, format+ix, &len); } /* * Insert temporary non-alphanumeric final tooken. */ j = ix; while (! (IS_LETTER(val) || IS_DIGIT(val))) { if (val == 0) break; /* while */ ix += len; val = xmlStringCurrentChar(NULL, format+ix, &len); } if (ix > j) tokens->end = xmlStrndup(&format[j], ix - j); } }