/** * exsltStrAlignFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * Aligns a string within another string. */ static void exsltStrAlignFunction (xmlXPathParserContextPtr ctxt, int nargs) { xmlChar *str, *padding, *alignment, *ret; int str_l, padding_l; if ((nargs < 2) || (nargs > 3)) { xmlXPathSetArityError(ctxt); return; } if (nargs == 3) alignment = xmlXPathPopString(ctxt); else alignment = NULL; padding = xmlXPathPopString(ctxt); str = xmlXPathPopString(ctxt); str_l = xmlUTF8Strlen (str); padding_l = xmlUTF8Strlen (padding); if (str_l == padding_l) { xmlXPathReturnString (ctxt, str); xmlFree(padding); xmlFree(alignment); return; } if (str_l > padding_l) { ret = xmlUTF8Strndup (str, padding_l); } else { if (xmlStrEqual(alignment, (const xmlChar *) "right")) { ret = xmlUTF8Strndup (padding, padding_l - str_l); ret = xmlStrcat (ret, str); } else if (xmlStrEqual(alignment, (const xmlChar *) "center")) { int left = (padding_l - str_l) / 2; int right_start; ret = xmlUTF8Strndup (padding, left); ret = xmlStrcat (ret, str); right_start = xmlUTF8Strsize (padding, left + str_l); ret = xmlStrcat (ret, padding + right_start); } else { int str_s; str_s = xmlUTF8Strsize(padding, str_l); ret = xmlStrdup (str); ret = xmlStrcat (ret, padding + str_s); } } xmlXPathReturnString (ctxt, ret); xmlFree(str); xmlFree(padding); xmlFree(alignment); }
/** * exsltCryptoRc4DecryptFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * computes the sha1 hash of a string and returns as hex */ static void exsltCryptoRc4DecryptFunction (xmlXPathParserContextPtr ctxt, int nargs) { int key_len = 0, key_size = 0; int str_len = 0, bin_len = 0, ret_len = 0; xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin = NULL, *ret = NULL; if ((nargs < 1) || (nargs > 3)) { xmlXPathSetArityError (ctxt); return; } str = xmlXPathPopString (ctxt); str_len = xmlUTF8Strlen (str); if (str_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (str); return; } key = xmlXPathPopString (ctxt); key_len = xmlUTF8Strlen (str); if (key_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (key); xmlFree (str); return; } padkey = xmlMallocAtomic (RC4_KEY_LENGTH); key_size = xmlUTF8Strsize (key, key_len); memcpy (padkey, key, key_size); memset (padkey + key_size, '\0', sizeof (padkey)); /* decode hex to binary */ bin_len = str_len; bin = xmlMallocAtomic (bin_len); ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len); /* decrypt the binary blob */ ret = xmlMallocAtomic (ret_len); PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len); xmlXPathReturnString (ctxt, ret); if (key != NULL) xmlFree (key); if (str != NULL) xmlFree (str); if (padkey != NULL) xmlFree (padkey); if (bin != NULL) xmlFree (bin); }
/** * exsltStrDecodeUriFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * reverses URI-Escaping of a string */ static void exsltStrDecodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) { int str_len = 0; xmlChar *str = NULL, *ret = NULL, *tmp; if ((nargs < 1) || (nargs > 2)) { xmlXPathSetArityError(ctxt); return; } if (nargs >= 2) { /* check for UTF-8 if encoding was explicitly given; we don't support anything else yet */ tmp = xmlXPathPopString(ctxt); if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) { xmlXPathReturnEmptyString(ctxt); xmlFree(tmp); return; } xmlFree(tmp); } str = xmlXPathPopString(ctxt); str_len = xmlUTF8Strlen(str); if (str_len == 0) { xmlXPathReturnEmptyString(ctxt); xmlFree(str); return; } ret = (xmlChar *) xmlURIUnescapeString((const char *)str,0,NULL); if (!xmlCheckUTF8(ret)) { /* FIXME: instead of throwing away the whole URI, we should only discard the invalid sequence(s). How to do that? */ xmlXPathReturnEmptyString(ctxt); xmlFree(str); xmlFree(ret); return; } xmlXPathReturnString(ctxt, ret); if (str != NULL) xmlFree(str); }
/** * exsltStrEncodeUriFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * URI-Escapes a string */ static void exsltStrEncodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) { int escape_all = 1, str_len = 0; xmlChar *str = NULL, *ret = NULL, *tmp; if ((nargs < 2) || (nargs > 3)) { xmlXPathSetArityError(ctxt); return; } if (nargs >= 3) { /* check for UTF-8 if encoding was explicitly given; we don't support anything else yet */ tmp = xmlXPathPopString(ctxt); if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) { xmlXPathReturnEmptyString(ctxt); xmlFree(tmp); return; } xmlFree(tmp); } escape_all = xmlXPathPopBoolean(ctxt); str = xmlXPathPopString(ctxt); str_len = xmlUTF8Strlen(str); if (str_len == 0) { xmlXPathReturnEmptyString(ctxt); xmlFree(str); return; } ret = xmlURIEscapeStr(str,(const xmlChar *)(escape_all?"-_.!~*'()":"-_.!~*'();/?:@&=+$,[]")); xmlXPathReturnString(ctxt, ret); if (str != NULL) xmlFree(str); }
void NormalizeString (DPL::Optional<DPL::String>& txt) { if (!!txt) { std::string tmp = DPL::ToUTF8String(*txt); const xmlChar* str = reinterpret_cast<const xmlChar*>(tmp.c_str()); if (!xmlCheckUTF8(str)) { LogError("Not valid UTF8"); return; } int i = 0; xmlChar* c; while ((c = const_cast<xmlChar*>(xmlUTF8Strpos(str, i))) != NULL) { if (!IsSpace(c)) { break; } ++i; } xmlChar* tmpnew = xmlUTF8Strndup(c, xmlUTF8Strlen(c) + 1); bool first = false; xmlChar* s = tmpnew; while ((c = const_cast<xmlChar*>(xmlUTF8Strpos(str, i))) != NULL) { if (IsSpace(c)) { first = true; ++i; } else { if (c[0] == 0x0) { break; } if (first) { xmlChar space[6] = { 0x20 }; CopyChar(s, space); s += xmlUTF8Size(s); first = false; } CopyChar(s, c); s += xmlUTF8Size(s); ++i; } } s[0] = 0x0; txt = DPL::FromUTF8String(reinterpret_cast<char*>(tmpnew)); xmlFree(tmpnew); } }
/** * exsltStrPaddingFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * Creates a padding string of a certain length. */ static void exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) { int number, str_len = 0, str_size = 0; xmlChar *str = NULL, *ret = NULL; if ((nargs < 1) || (nargs > 2)) { xmlXPathSetArityError(ctxt); return; } if (nargs == 2) { str = xmlXPathPopString(ctxt); str_len = xmlUTF8Strlen(str); str_size = xmlStrlen(str); } if (str_len == 0) { if (str != NULL) xmlFree(str); str = xmlStrdup((const xmlChar *) " "); str_len = 1; str_size = 1; } number = (int) xmlXPathPopNumber(ctxt); if (number <= 0) { xmlXPathReturnEmptyString(ctxt); xmlFree(str); return; } while (number >= str_len) { ret = xmlStrncat(ret, str, str_size); number -= str_len; } if (number > 0) { str_size = xmlUTF8Strsize(str, number); ret = xmlStrncat(ret, str, str_size); } xmlXPathReturnString(ctxt, ret); if (str != NULL) xmlFree(str); }
static int exsltRegexpExecute(xmlXPathParserContextPtr ctxt, const xmlChar* haystack, const xmlChar* regexp, int flags, int ovector[], int ovector_len) { int haystack_len = 0; pcre *compiled_regexp = NULL; int rc = 0, erroffset = 0; const char *error = 0; compiled_regexp = pcre_compile(regexp, /* the pattern */ flags, /* default options */ &error, /* for error message */ &erroffset, /* for error offset */ NULL); /* use default character tables */ if (compiled_regexp == NULL) { xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL, "exslt:regexp failed to compile %s (char: %d). %s", regexp, erroffset, error); return -1; } haystack_len = xmlUTF8Strlen (haystack); rc = pcre_exec(compiled_regexp, /* result of pcre_compile() */ NULL, /* we didn't study the pattern */ haystack, /* the subject string */ haystack_len, /* the length of the subject string */ 0, /* start at offset 0 in the subject */ 0, /* default options */ (int*)ovector, /* vector of integers for substring information */ ovector_len); /* number of elements in the vector (NOT size in bytes) */ if (rc < -1) { xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL, "exslt:regexp failed to execute %s for %s", regexp, haystack); rc = 0; } if (compiled_regexp != NULL) pcre_free(compiled_regexp); return rc; }
/** * xmlUTF8Strpos: * @param utf the input UTF8 * * @param pos the position of the desired UTF8 char (in chars) * * a function to provide the equivalent of fetching a * character from a string array * * Returns a pointer to the UTF8 character or NULL */ XMLPUBFUNEXPORT xmlChar * xmlUTF8Strpos(const xmlChar *utf, int pos) { xmlChar ch; if (utf == NULL) return(NULL); if ( (pos < 0) || (pos >= xmlUTF8Strlen(utf)) ) return(NULL); while (pos--) { if ((ch=*utf++) == 0) return(NULL); if ( ch & 0x80 ) { /* if not simple ascii, verify proper format */ if ( (ch & 0xc0) != 0xc0 ) return(NULL); /* then skip over remaining bytes for this char */ while ( (ch <<= 1) & 0x80 ) if ( (*utf++ & 0xc0) != 0x80 ) return(NULL); } } return((xmlChar *)utf); }
/* {{{ length long readonly=yes URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-7D61178C Since: */ int dom_characterdata_length_read(dom_object *obj, zval *retval) { xmlNodePtr nodep = dom_object_get_node(obj); xmlChar *content; long length = 0; if (nodep == NULL) { php_dom_throw_error(INVALID_STATE_ERR, 0); return FAILURE; } content = xmlNodeGetContent(nodep); if (content) { length = xmlUTF8Strlen(content); xmlFree(content); } ZVAL_LONG(retval, length); return SUCCESS; }
/** * exsltCryptoPopString: * @ctxt: an XPath parser context * @nargs: the number of arguments * * Helper function which checks for and returns first string argument and its length */ static int exsltCryptoPopString (xmlXPathParserContextPtr ctxt, int nargs, xmlChar ** str) { int str_len = 0; if ((nargs < 1) || (nargs > 2)) { xmlXPathSetArityError (ctxt); return 0; } *str = xmlXPathPopString (ctxt); str_len = xmlUTF8Strlen (*str); if (str_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (*str); return 0; } return str_len; }
/** * exsltCryptoRc4DecryptFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * computes the sha1 hash of a string and returns as hex */ static void exsltCryptoRc4DecryptFunction (xmlXPathParserContextPtr ctxt, int nargs) { int key_len = 0, key_size = 0; int str_len = 0, bin_len = 0, ret_len = 0; xmlChar *key = NULL, *str = NULL, *padkey = NULL, *bin = NULL, *ret = NULL; xsltTransformContextPtr tctxt = NULL; if (nargs != 2) { xmlXPathSetArityError (ctxt); return; } tctxt = xsltXPathGetTransformContext(ctxt); str = xmlXPathPopString (ctxt); str_len = xmlUTF8Strlen (str); if (str_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (str); return; } key = xmlXPathPopString (ctxt); key_len = xmlUTF8Strlen (key); if (key_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (key); xmlFree (str); return; } padkey = xmlMallocAtomic (RC4_KEY_LENGTH + 1); if (padkey == NULL) { xsltTransformError(tctxt, NULL, tctxt->inst, "exsltCryptoRc4EncryptFunction: Failed to allocate padkey\n"); tctxt->state = XSLT_STATE_STOPPED; xmlXPathReturnEmptyString (ctxt); goto done; } memset(padkey, 0, RC4_KEY_LENGTH + 1); key_size = xmlUTF8Strsize (key, key_len); if ((key_size > RC4_KEY_LENGTH) || (key_size < 0)) { xsltTransformError(tctxt, NULL, tctxt->inst, "exsltCryptoRc4EncryptFunction: key size too long or key broken\n"); tctxt->state = XSLT_STATE_STOPPED; xmlXPathReturnEmptyString (ctxt); goto done; } memcpy (padkey, key, key_size); /* decode hex to binary */ bin_len = str_len; bin = xmlMallocAtomic (bin_len); if (bin == NULL) { xsltTransformError(tctxt, NULL, tctxt->inst, "exsltCryptoRc4EncryptFunction: Failed to allocate string\n"); tctxt->state = XSLT_STATE_STOPPED; xmlXPathReturnEmptyString (ctxt); goto done; } ret_len = exsltCryptoHex2Bin (str, str_len, bin, bin_len); /* decrypt the binary blob */ ret = xmlMallocAtomic (ret_len); if (ret == NULL) { xsltTransformError(tctxt, NULL, tctxt->inst, "exsltCryptoRc4EncryptFunction: Failed to allocate result\n"); tctxt->state = XSLT_STATE_STOPPED; xmlXPathReturnEmptyString (ctxt); goto done; } PLATFORM_RC4_DECRYPT (ctxt, padkey, bin, ret_len, ret, ret_len); xmlXPathReturnString (ctxt, ret); done: if (key != NULL) xmlFree (key); if (str != NULL) xmlFree (str); if (padkey != NULL) xmlFree (padkey); if (bin != NULL) xmlFree (bin); }
static void exsltRegexpReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) { xmlChar *haystack, *regexp, *flagstr, *replace, *tmp; xmlChar *result = NULL, *working, *end; int rc, x, flags, global, ovector[3]; if ((nargs < 1) || (nargs > 4)) { xmlXPathSetArityError(ctxt); return; } replace = xmlXPathPopString(ctxt); if (xmlXPathCheckError(ctxt) || (replace == NULL)) { return; } flagstr = xmlXPathPopString(ctxt); if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) { xmlFree(replace); return; } regexp = xmlXPathPopString(ctxt); if (xmlXPathCheckError(ctxt) || (regexp == NULL)) { xmlFree(flagstr); xmlFree(replace); return; } haystack = xmlXPathPopString(ctxt); if (xmlXPathCheckError(ctxt) || (haystack == NULL)) { xmlFree(regexp); xmlFree(flagstr); xmlFree(replace); return; } exsltRegexpFlagsFromString(flagstr, &global, &flags); working = haystack; rc = exsltRegexpExecute(ctxt, working, regexp, flags, ovector, sizeof(ovector)/sizeof(int)); while (rc > 0 ) { if (0==ovector[0]) { if (NULL==result) result = xmlStrdup(replace); else result = xmlStrcat(result, replace); } else { tmp = xmlStrsub(working, 0, ovector[0]); if (NULL==result) result = tmp; else { result = xmlStrcat(result, tmp); xmlFree(tmp); } result = xmlStrcat(result, replace); } working = working + ovector[1]; if (!global) break; rc = exsltRegexpExecute(ctxt, working, regexp, flags, ovector, sizeof(ovector)/sizeof(int)); } end = haystack + xmlUTF8Strlen(haystack); if (working < end ) { if (NULL==result) result = xmlStrdup(working); else { result = xmlStrcat(result, working); } } fail: if (replace != NULL) xmlFree(replace); if (flagstr != NULL) xmlFree(flagstr); if (regexp != NULL) xmlFree(regexp); if (haystack != NULL) xmlFree(haystack); xmlXPathReturnString(ctxt, result); }
int xml_parser_utf8_strlen(char *buf) { return xmlUTF8Strlen(BAD_CAST buf); }
int my_xmlStrncopy(char ** out, const char * in, int len) { if(in) { size_t lin=0; size_t lout=0; int l1=0; int l2=0; int retval=1; char *inbuf; char *inbuf2; char *outbuf; char *outbuf2; lin=strlen(in); l2=xmlUTF8Strlen((xmlChar*)in); if(l2<0) lout=l1; else if (len>0 && len<l2) lout=len; else lout=l2; inbuf=inbuf2=(char *)malloc((lin+1)*sizeof(char)); outbuf=outbuf2=(char *)malloc((lout+1)*sizeof(char)); memcpy(inbuf,in,lin); l1=lin; l2=lout; #ifndef LINUX if(my_UTF8Toisolat1(&outbuf2,&lout,(const char **)&inbuf2,&lin)<0) { #else if(my_UTF8Toisolat1(&outbuf2,&lout,&inbuf2,&lin)<0) { #endif retval=-1; } free(inbuf); outbuf[l2]=0; if(*out) { memcpy(*out,outbuf,l2+1); free(outbuf); } else { *out=outbuf; } return retval<0?-1:l2; } else return -1; } #ifndef LINUX int my_UTF8Toisolat1(char **dest, size_t * lu, const char **src, size_t * l) #else int my_UTF8Toisolat1(char **dest, size_t * lu, char **src, size_t * l) #endif { iconv_t t=iconv_open("ISO_8859-1","UTF-8"); iconv(t, src, l, dest, lu); iconv_close(t); return 1; }
/** * exsltCryptoRc4EncryptFunction: * @ctxt: an XPath parser context * @nargs: the number of arguments * * computes the sha1 hash of a string and returns as hex */ static void exsltCryptoRc4EncryptFunction (xmlXPathParserContextPtr ctxt, int nargs) { int key_len = 0, key_size = 0; int str_len = 0, bin_len = 0, hex_len = 0; xmlChar *key = NULL, *str = NULL, *padkey = NULL; xmlChar *bin = NULL, *hex = NULL; if ((nargs < 1) || (nargs > 3)) { xmlXPathSetArityError (ctxt); return; } str = xmlXPathPopString (ctxt); str_len = xmlUTF8Strlen (str); if (str_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (str); return; } key = xmlXPathPopString (ctxt); key_len = xmlUTF8Strlen (str); if (key_len == 0) { xmlXPathReturnEmptyString (ctxt); xmlFree (key); xmlFree (str); return; } padkey = xmlMallocAtomic (RC4_KEY_LENGTH); key_size = xmlUTF8Strsize (key, key_len); memcpy (padkey, key, key_size); memset (padkey + key_size, '\0', sizeof (padkey)); /* encrypt it */ bin_len = str_len; bin = xmlStrdup (str); if (bin == NULL) { xmlXPathReturnEmptyString (ctxt); goto done; } PLATFORM_RC4_ENCRYPT (ctxt, padkey, str, str_len, bin, bin_len); /* encode it */ hex_len = str_len * 2 + 1; hex = xmlMallocAtomic (hex_len); if (hex == NULL) { xmlXPathReturnEmptyString (ctxt); goto done; } exsltCryptoBin2Hex (bin, str_len, hex, hex_len); xmlXPathReturnString (ctxt, hex); done: if (key != NULL) xmlFree (key); if (str != NULL) xmlFree (str); if (padkey != NULL) xmlFree (padkey); if (bin != NULL) xmlFree (bin); }