xmlChar *xml_convert_input(const char *in, const char *encoding) { xmlChar *out; int ret; int size; int out_size; int temp; xmlCharEncodingHandlerPtr handler; handler = xmlFindCharEncodingHandler(encoding); assert(handler != NULL); size = (int)strlen(in) + 1; out_size = size * 2 - 1; out = (unsigned char *)xmlMalloc((size_t) out_size); if (out != NULL) { temp = size - 1; ret = handler->input(out, &out_size, (const xmlChar *)in, &temp); if ((ret < 0) || (temp - size + 1)) { xmlFree(out); out = 0; } else { out = (unsigned char *)xmlRealloc(out, out_size + 1); out[out_size] = 0; /*null terminating out */ } } return out; }
/* wrapper for stats_event, this takes a charset to convert from */ void stats_event_conv(const char *mount, const char *name, const char *value, const char *charset) { const char *metadata = value; xmlBufferPtr conv = xmlBufferCreate (); if (charset && value) { xmlCharEncodingHandlerPtr handle = xmlFindCharEncodingHandler (charset); if (handle) { xmlBufferPtr raw = xmlBufferCreate (); xmlBufferAdd (raw, (const xmlChar *)value, strlen (value)); if (xmlCharEncInFunc (handle, conv, raw) > 0) metadata = (char *)xmlBufferContent (conv); xmlBufferFree (raw); xmlCharEncCloseFunc (handle); } else WARN1 ("No charset found for \"%s\"", charset); } stats_event (mount, name, metadata); xmlBufferFree (conv); }
/** * ConvertInput: * @in: string in a given encoding * @encoding: the encoding used * * Converts @in into UTF-8 for processing with libxml2 APIs * * Returns the converted UTF-8 string, or NULL in case of error. */ xmlChar* cpXmlCmdOutput::ConvertInput( const xmlChar* in, const xmlChar* encoding ) { xmlChar *out; int ret; int size; int out_size; int temp; xmlCharEncodingHandlerPtr handler; if ( in == 0 ) return 0; handler = xmlFindCharEncodingHandler( (const char *)encoding ); if ( !handler ) { printf( "ConvertInput: no encoding handler found for '%s'\n", encoding != 0 ? (const char *)encoding : "" ); return 0; } size = (int) strlen( (const char*) in ) + 1; out_size = size * 2 - 1; out = (xmlChar *) xmlMalloc( (size_t) out_size ); if ( out != 0 ) { temp = size - 1; ret = handler->input( out, &out_size, in, &temp ); if ( ( ret < 0 ) || ( temp - size + 1 ) ) { if ( ret < 0 ) { printf( "ConvertInput: conversion wasn't successful.\n" ); } else { printf ( "ConvertInput: conversion wasn't successful. converted: %i octets.\n", temp ); } xmlFree( out ); out = 0; } else { out = (xmlChar *) xmlRealloc( out, out_size + 1 ); out[out_size] = 0; //null termination } } else { printf( "ConvertInput: no mem\n" ); } return out; }
XMLWrapper::XMLWrapper() { mDocument = NULL; mCharEncodingHandler = xmlFindCharEncodingHandler ("UTF8"); if (!mCharEncodingHandler) { /* no encoding handler found */ std::cerr << "XMLWrapper::XMLWrapper - no encoding handler found" << std::endl; } }
xsltStylesheetPtr parse_xsl( char* xsl, int iXslType ) { xsltStylesheetPtr tParsedXslt = NULL; xmlDocPtr tXSLDocument = NULL; /** Rem: For encoding */ xmlCharEncodingHandlerPtr encoder = NULL; const xmlChar *encoding = NULL; /** Act: Encoding support */ xmlInitCharEncodingHandlers( ); /** Act: Parse XSL */ if( iXslType == RUBY_XSLT_XSLSRC_TYPE_STR ) { tXSLDocument = xmlParseMemory( xsl, strlen( xsl ) ); if( tXSLDocument == NULL ) { rb_raise( eXSLTParsingError, "XSL parsing error" ); return( NULL ); } tParsedXslt = xsltParseStylesheetDoc( tXSLDocument ); } else if( iXslType == RUBY_XSLT_XSLSRC_TYPE_FILE ) { tParsedXslt = xsltParseStylesheetFile( BAD_CAST xsl ); } if( tParsedXslt == NULL ) { rb_raise( eXSLTParsingError, "XSL Stylesheet parsing error" ); return( NULL ); } /** Act: Get encoding */ XSLT_GET_IMPORT_PTR( encoding, tParsedXslt, encoding ) encoder = xmlFindCharEncodingHandler((char *)encoding); if( encoding != NULL ) { encoder = xmlFindCharEncodingHandler((char *)encoding); if( (encoder != NULL) && (xmlStrEqual((const xmlChar *)encoder->name, (const xmlChar *) "UTF-8")) ) { encoder = NULL; } } return( tParsedXslt ); }
static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self) { VALUE result = Qnil; VALUE options = Qnil; xmlNodePtr xnode; xmlCharEncodingHandlerPtr encodingHandler; xmlOutputBufferPtr output; int level = 0; int indent = 1; const char *xencoding = "UTF-8"; rb_scan_args(argc, argv, "01", &options); if (!NIL_P(options)) { VALUE rencoding, rindent, rlevel; Check_Type(options, T_HASH); rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding"))); rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent"))); rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level"))); if (rindent == Qfalse) indent = 0; if (rlevel != Qnil) level = NUM2INT(rlevel); if (rencoding != Qnil) { xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding)); if (!xencoding) rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding)); } } encodingHandler = xmlFindCharEncodingHandler(xencoding); output = xmlAllocOutputBuffer(encodingHandler); xnode = rxml_get_xnode(self); xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, xencoding); xmlOutputBufferFlush(output); if (output->conv) result = rxml_new_cstr((const char*) output->conv->content, xencoding); else result = rxml_new_cstr((const char*) output->buffer->content, xencoding); xmlOutputBufferClose(output); return result; }
/** * htmlNodeDumpFileFormat: * @out: the FILE pointer * @doc: the document * @cur: the current node * @encoding: the document encoding * @format: should formatting spaces been added * * Dump an HTML node, recursive behaviour,children are printed too. * * TODO: if encoding == NULL try to save in the doc encoding * * returns: the number of byte written or -1 in case of failure. */ int htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc, xmlNodePtr cur, const char *encoding, int format) { xmlOutputBufferPtr buf; xmlCharEncodingHandlerPtr handler = NULL; int ret; xmlInitParser(); if (encoding != NULL) { xmlCharEncoding enc; enc = xmlParseCharEncoding(encoding); if (enc != XML_CHAR_ENCODING_UTF8) { handler = xmlFindCharEncodingHandler(encoding); if (handler == NULL) return(-1); } } /* * Fallback to HTML or ASCII when the encoding is unspecified */ if (handler == NULL) handler = xmlFindCharEncodingHandler("HTML"); if (handler == NULL) handler = xmlFindCharEncodingHandler("ascii"); /* * save the content to a temp buffer. */ buf = xmlOutputBufferCreateFile(out, handler); if (buf == NULL) return(0); htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format); ret = xmlOutputBufferClose(buf); return(ret); }
/* * Read xmlDocument from server */ static xmlDoc * js_document_read (xmlParserCtxtPtr ctxt, js_session_t *jsp, const char *url, const char *encoding, int options) { xmlParserInputBufferPtr input; xmlParserInputPtr stream; xmlDoc *docp; if (jsp == NULL || ctxt == NULL || jsp->js_state == JSS_DEAD) return NULL; xmlCtxtReset(ctxt); input = js_buffer_create(jsp, XML_CHAR_ENCODING_NONE); if (input == NULL) return NULL; input->closecallback = NULL; stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); if (stream == NULL) { xmlFreeParserInputBuffer(input); return NULL; } inputPush(ctxt, stream); xmlCtxtUseOptions(ctxt, options); xmlCharEncodingHandlerPtr hdlr; if (encoding && ((hdlr = xmlFindCharEncodingHandler(encoding)) != NULL)) xmlSwitchToEncoding(ctxt, hdlr); if (url != NULL && ctxt->input != NULL && ctxt->input->filename == NULL) ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) url); /* * All right. The stage is set, time to open the curtain and let * the show begin. */ xmlParseDocument(ctxt); docp = ctxt->myDoc; ctxt->myDoc = NULL; if (docp && !ctxt->wellFormed) { xmlFreeDoc(docp); docp = NULL; } return docp; }
void XMLStream::toStream( xmlDocPtr doc, std::ostream &os ) { void *IOContexte = &os; const char *encoding="UTF-8"; int formatWithSpace=1; xmlCharEncodingHandlerPtr handler = xmlFindCharEncodingHandler(encoding); //xmlCharEncodingHandlerPtr handler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF8); doesnt work :/ SLM_ASSERT("handler not instanced", handler); //xmlThrDefIndentTreeOutput(4); xmlOutputBufferPtr outBuff = xmlOutputBufferCreateIO( streamIOWrite , streamIOClose, IOContexte, handler); xmlSaveFormatFileTo( outBuff, doc, encoding, formatWithSpace ); }
OutputBuffer::OutputBuffer(const std::string & encoding) { xmlCharEncodingHandlerPtr encoder = nullptr; if ( !encoding.empty() ) { xmlCharEncoding enc = xmlParseCharEncoding(encoding.c_str()); if ( enc != XML_CHAR_ENCODING_UTF8 ) { encoder = xmlFindCharEncodingHandler(encoding.c_str()); if ( encoder == nullptr ) throw InternalError("Unsupported output encoding: " + encoding); } } _buf = xmlOutputBufferCreateIO(OutputBuffer::write_cb, OutputBuffer::close_cb, this, encoder); if ( _buf == nullptr ) throw InternalError("Failed to create xml output buffer"); }
xmlChar* PmmFastEncodeString( int charset, const xmlChar *string, const xmlChar *encoding ) { xmlCharEncodingHandlerPtr coder = NULL; xmlChar *retval = NULL; xmlBufferPtr in = NULL, out = NULL; if ( charset == XML_CHAR_ENCODING_UTF8 ) { /* warn("use UTF8 for encoding ... %s ", string); */ return xmlStrdup( string ); } else if ( charset == XML_CHAR_ENCODING_ERROR ) { /* warn("no standard encoding %s\n", encoding); */ coder =xmlFindCharEncodingHandler( (const char *)encoding ); } else if ( charset == XML_CHAR_ENCODING_NONE ) { xs_warn("PmmFastEncodeString: no encoding found\n"); } else { /* warn( "use document encoding %s (%d)", encoding, charset ); */ coder= xmlGetCharEncodingHandler( charset ); } if ( coder != NULL ) { xs_warn("PmmFastEncodeString: coding machine found \n"); in = xmlBufferCreate(); out = xmlBufferCreate(); xmlBufferCCat( in, (const char *) string ); if ( xmlCharEncInFunc( coder, out, in ) >= 0 ) { retval = xmlStrdup( out->content ); /* warn( "encoded string is %s" , retval); */ } else { /* warn( "b0rked encoiding!\n"); */ } xmlBufferFree( in ); xmlBufferFree( out ); xmlCharEncCloseFunc( coder ); } return retval; }
static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self) { VALUE options = Qnil; xmlNodePtr xnode; xmlCharEncodingHandlerPtr encodingHandler; xmlOutputBufferPtr output; int level = 0; int indent = 1; const char *encoding = "UTF-8"; rb_scan_args(argc, argv, "01", &options); if (!NIL_P(options)) { VALUE rencoding, rindent, rlevel; Check_Type(options, T_HASH); rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding"))); rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent"))); rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level"))); if (rindent == Qfalse) indent = 0; if (rlevel != Qnil) level = NUM2INT(rlevel); if (rencoding != Qnil) encoding = RSTRING_PTR(rxml_input_encoding_to_s(cXMLInput, rencoding)); } encodingHandler = xmlFindCharEncodingHandler(encoding); output = xmlAllocOutputBuffer(encodingHandler); Data_Get_Struct(self, xmlNode, xnode); xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, encoding); xmlOutputBufferFlush(output); if (output->conv) return rb_str_new2((const char*) output->conv->content); else return rb_str_new2((const char*) output->buffer->content); }
xmlChar* PmmFastDecodeString( int charset, const xmlChar *string, const xmlChar *encoding) { xmlCharEncodingHandlerPtr coder = NULL; xmlChar *retval = NULL; xmlBufferPtr in = NULL, out = NULL; if ( charset == XML_CHAR_ENCODING_UTF8 ) { return xmlStrdup( string ); } else if ( charset == XML_CHAR_ENCODING_ERROR ) { coder = xmlFindCharEncodingHandler( (const char *) encoding ); } else if ( charset == XML_CHAR_ENCODING_NONE ) { xs_warn("PmmFastDecodeString: no encoding found\n"); } else { coder= xmlGetCharEncodingHandler( charset ); } if ( coder != NULL ) { /* warn( "do encoding %s", string ); */ in = xmlBufferCreate(); out = xmlBufferCreate(); xmlBufferCat( in, string ); if ( xmlCharEncOutFunc( coder, out, in ) >= 0 ) { retval = xmlCharStrndup((const char *)xmlBufferContent(out), xmlBufferLength(out)); } else { xs_warn("PmmFastEncodeString: decoding error\n"); } xmlBufferFree( in ); xmlBufferFree( out ); xmlCharEncCloseFunc( coder ); } return retval; }
/* * call-seq: * context.encoding = XML::Encoding::UTF_8 * * Sets the character encoding for this context. */ static VALUE rxml_parser_context_encoding_set(VALUE self, VALUE encoding) { xmlParserCtxtPtr ctxt; int result; const char* xencoding = xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(encoding)); xmlCharEncodingHandlerPtr hdlr = xmlFindCharEncodingHandler(xencoding); if (!hdlr) rb_raise(rb_eRuntimeError, "Unknown encoding: %s", encoding); Data_Get_Struct(self, xmlParserCtxt, ctxt); result = xmlSwitchToEncoding(ctxt, hdlr); if (result != 0) rxml_raise(&xmlLastError); if (ctxt->encoding != NULL) xmlFree((xmlChar *) ctxt->encoding); ctxt->encoding = xmlStrdup((const xmlChar *) xencoding); return self; }
char * rss_utf8_enc (const unsigned char *in, const char *encoding) { static xmlChar out[RSSMAXBUFSIZE * 2]; int temp = 0; int size = 0; xmlCharEncodingHandlerPtr handler; if (!in) return NULL; handler = xmlFindCharEncodingHandler (encoding); if (!handler) return NULL; temp = strlen ((const char *) in); size = sizeof (out); handler->input (out, &size, in, &temp); return (char *) out; }
void XMLNode::GetXML(std::string& out_xml_str, const std::string& encoding, bool user_friendly) const { out_xml_str.resize(0); if (!node_) return; if (node_->type != XML_ELEMENT_NODE) return; xmlDocPtr doc = node_->doc; if (doc == NULL) return; xmlCharEncodingHandlerPtr handler = NULL; handler = xmlFindCharEncodingHandler(encoding.c_str()); if (handler == NULL) return; std::map<xmlNsPtr,xmlNsPtr> extns; CollectExternalNamespaces(node_, extns); std::string ns_str; NamespacesToString(extns, ns_str); out_xml_str.append(ns_str.length(),' '); //xmlOutputBufferPtr buf = xmlAllocOutputBuffer(handler); xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(&write_to_string,&close_string,&out_xml_str,NULL); if(buf == NULL) return; xmlNodeDumpOutput(buf, doc, node_, 0, user_friendly ? 1 : 0, encoding.c_str()); xmlOutputBufferFlush(buf); //out_xml_str = (char*)(buf->conv ? buf->conv->content : buf->buffer->content); xmlOutputBufferClose(buf); InsertExternalNamespaces(out_xml_str, ns_str); }
void stats_set_conv (long handle, const char *name, const char *value, const char *charset) { if (charset) { xmlCharEncodingHandlerPtr encoding = xmlFindCharEncodingHandler (charset); if (encoding) { xmlBufferPtr in = xmlBufferCreate (); xmlBufferPtr conv = xmlBufferCreate (); xmlBufferCCat (in, value); if (xmlCharEncInFunc (encoding, conv, in) > 0) stats_set_entity_decode (handle, name, (void*)xmlBufferContent (conv)); xmlBufferFree (in); xmlBufferFree (conv); xmlCharEncCloseFunc (encoding); return; } WARN1 ("No charset found for \"%s\"", charset); return; } stats_set_entity_decode (handle, name, value); }
void Server::sendResponse(Context *ctx, XmlDocSharedHelper doc) { sendHeaders(ctx); if (ctx->response()->suppressBody(ctx->request())) { return; } xmlCharEncodingHandlerPtr encoder = NULL; const std::string &encoding = ctx->documentWriter()->outputEncoding(); if (!encoding.empty() && 0 != strncasecmp(encoding.c_str(), "utf-8", sizeof("utf-8"))) { encoder = xmlFindCharEncodingHandler(encoding.c_str()); } xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(writeFunc, closeFunc, ctx, encoder); XmlUtils::throwUnless(NULL != buf); try { ctx->documentWriter()->write(ctx->response(), doc.get(), buf); } catch(const std::exception &e) { xmlOutputBufferClose(buf); throw e; } }
String::C xdoc2buf(Request& r, VXdoc& vdoc, XDocOutputOptions& oo, const String* file_spec, bool use_source_charset_to_render_and_client_charset_to_write_to_header=false) { Charset* render=0; Charset* header=0; if(use_source_charset_to_render_and_client_charset_to_write_to_header) { render=&r.charsets.source(); header=&r.charsets.client(); } else { header=render=&charsets.get(oo.encoding->change_case(r.charsets.source(), String::CC_UPPER)); } const char* render_encoding=render->NAME_CSTR(); const char* header_encoding=header->NAME_CSTR(); xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding); // UTF-8 renderer contains empty input/output converters, // which is wrong for xmlOutputBufferCreateIO // while zero renderer goes perfectly if(render->isUTF8()) renderer=0; xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer)); xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet()); if(!stylesheet.get()) throw Exception(0, 0, "xsltNewStylesheet failed"); #define OOSTRING2STYLE(name) \ stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0 #define OOBOOL2STYLE(name) \ if(oo.name>=0) stylesheet->name=oo.name OOSTRING2STYLE(method); OOSTRING2STYLE(encoding); OOSTRING2STYLE(mediaType); // OOSTRING2STYLE(doctypeSystem); // OOSTRING2STYLE(doctypePublic); OOBOOL2STYLE(indent); OOSTRING2STYLE(version); OOBOOL2STYLE(standalone); OOBOOL2STYLE(omitXmlDeclaration); xmlDoc& xmldoc=vdoc.get_xmldoc(); xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding); if(header_encoding) stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding); if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0 || xmlHaveGenericErrors()) throw XmlException(0, r); // write out result char *gnome_str; size_t gnome_length; #ifdef LIBXML2_NEW_BUFFER if(outputBuffer->conv) { gnome_length=xmlBufUse(outputBuffer->conv); gnome_str=(char *)xmlBufContent(outputBuffer->conv); } else { gnome_length=xmlOutputBufferGetSize(&(*outputBuffer)); gnome_str=(char *)xmlOutputBufferGetContent(&(*outputBuffer)); } #else if(outputBuffer->conv) { gnome_length=outputBuffer->conv->use; gnome_str=(char *)outputBuffer->conv->content; } else { gnome_length=outputBuffer->buffer->use; gnome_str=(char *)outputBuffer->buffer->content; } #endif if(file_spec){ file_write(r.charsets, *file_spec, gnome_str, gnome_length, true/*as_text*/); return String::C(); // actually, we don't need this output at all } else return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length); }
/** * 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 ((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) { *mem = NULL; *size = 0; return; } } 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 = 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); }