xmlstring.c
1 /* 2 * string.c : an XML string utilities module 3 * 4 * This module provides various utility functions for manipulating 5 * the xmlChar* type. All functions named xmlStr* have been moved here 6 * from the parser.c file (their original home). 7 * 8 * See Copyright for the status of this software. 9 * 10 * UTF8 string routines from: 11 * William Brack <wbrack@mmm.com.hk> 12 * 13 * daniel@veillard.com 14 */ 15 16 #define IN_LIBXML 17 #include "libxml.h" 18 19 #include <stdlib.h> 20 #include <string.h> 21 #include <libxml/xmlmemory.h> 22 #include <libxml/parserInternals.h> 23 #include <libxml/xmlstring.h> 24 25 /************************************************************************ 26 * * 27 * Commodity functions to handle xmlChars * 28 * * 29 ************************************************************************/ 30 31 /** 32 * xmlStrndup: 33 * @cur: the input xmlChar * 34 * @len: the len of @cur 35 * 36 * a strndup for array of xmlChar's 37 * 38 * Returns a new xmlChar * or NULL 39 */ 40 xmlChar * 41 xmlStrndup(const xmlChar *cur, int len) { 42 xmlChar *ret; 43 44 if ((cur == NULL) || (len < 0)) return(NULL); 45 ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar)); 46 if (ret == NULL) { 47 xmlErrMemory(NULL, NULL); 48 return(NULL); 49 } 50 memcpy(ret, cur, len * sizeof(xmlChar)); 51 ret[len] = 0; 52 return(ret); 53 } 54 55 /** 56 * xmlStrdup: 57 * @cur: the input xmlChar * 58 * 59 * a strdup for array of xmlChar's. Since they are supposed to be 60 * encoded in UTF-8 or an encoding with 8bit based chars, we assume 61 * a termination mark of '0'. 62 * 63 * Returns a new xmlChar * or NULL 64 */ 65 xmlChar * 66 xmlStrdup(const xmlChar *cur) { 67 const xmlChar *p = cur; 68 69 if (cur == NULL) return(NULL); 70 while (*p != 0) p++; /* non input consuming */ 71 return(xmlStrndup(cur, p - cur)); 72 } 73 74 /** 75 * xmlCharStrndup: 76 * @cur: the input char * 77 * @len: the len of @cur 78 * 79 * a strndup for char's to xmlChar's 80 * 81 * Returns a new xmlChar * or NULL 82 */ 83 84 xmlChar * 85 xmlCharStrndup(const char *cur, int len) { 86 int i; 87 xmlChar *ret; 88 89 if ((cur == NULL) || (len < 0)) return(NULL); 90 ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar)); 91 if (ret == NULL) { 92 xmlErrMemory(NULL, NULL); 93 return(NULL); 94 } 95 for (i = 0;i < len;i++) { 96 ret[i] = (xmlChar) cur[i]; 97 if (ret[i] == 0) return(ret); 98 } 99 ret[len] = 0; 100 return(ret); 101 } 102 103 /** 104 * xmlCharStrdup: 105 * @cur: the input char * 106 * 107 * a strdup for char's to xmlChar's 108 * 109 * Returns a new xmlChar * or NULL 110 */ 111 112 xmlChar * 113 xmlCharStrdup(const char *cur) { 114 const char *p = cur; 115 116 if (cur == NULL) return(NULL); 117 while (*p != '\0') p++; /* non input consuming */ 118 return(xmlCharStrndup(cur, p - cur)); 119 } 120 121 /** 122 * xmlStrcmp: 123 * @str1: the first xmlChar * 124 * @str2: the second xmlChar * 125 * 126 * a strcmp for xmlChar's 127 * 128 * Returns the integer result of the comparison 129 */ 130 131 int 132 xmlStrcmp(const xmlChar *str1, const xmlChar *str2) { 133 register int tmp; 134 135 if (str1 == str2) return(0); 136 if (str1 == NULL) return(-1); 137 if (str2 == NULL) return(1); 138 do { 139 tmp = *str1++ - *str2; 140 if (tmp != 0) return(tmp); 141 } while (*str2++ != 0); 142 return 0; 143 } 144 145 /** 146 * xmlStrEqual: 147 * @str1: the first xmlChar * 148 * @str2: the second xmlChar * 149 * 150 * Check if both strings are equal of have same content. 151 * Should be a bit more readable and faster than xmlStrcmp() 152 * 153 * Returns 1 if they are equal, 0 if they are different 154 */ 155 156 int 157 xmlStrEqual(const xmlChar *str1, const xmlChar *str2) { 158 if (str1 == str2) return(1); 159 if (str1 == NULL) return(0); 160 if (str2 == NULL) return(0); 161 do { 162 if (*str1++ != *str2) return(0); 163 } while (*str2++); 164 return(1); 165 } 166 167 /** 168 * xmlStrQEqual: 169 * @pref: the prefix of the QName 170 * @name: the localname of the QName 171 * @str: the second xmlChar * 172 * 173 * Check if a QName is Equal to a given string 174 * 175 * Returns 1 if they are equal, 0 if they are different 176 */ 177 178 int 179 xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) { 180 if (pref == NULL) return(xmlStrEqual(name, str)); 181 if (name == NULL) return(0); 182 if (str == NULL) return(0); 183 184 do { 185 if (*pref++ != *str) return(0); 186 } while ((*str++) && (*pref)); 187 if (*str++ != ':') return(0); 188 do { 189 if (*name++ != *str) return(0); 190 } while (*str++); 191 return(1); 192 } 193 194 /** 195 * xmlStrncmp: 196 * @str1: the first xmlChar * 197 * @str2: the second xmlChar * 198 * @len: the max comparison length 199 * 200 * a strncmp for xmlChar's 201 * 202 * Returns the integer result of the comparison 203 */ 204 205 int 206 xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) { 207 register int tmp; 208 209 if (len <= 0) return(0); 210 if (str1 == str2) return(0); 211 if (str1 == NULL) return(-1); 212 if (str2 == NULL) return(1); 213 #ifdef __GNUC__ 214 tmp = strncmp((const char *)str1, (const char *)str2, len); 215 return tmp; 216 #else 217 do { 218 tmp = *str1++ - *str2; 219 if (tmp != 0 || --len == 0) return(tmp); 220 } while (*str2++ != 0); 221 return 0; 222 #endif 223 } 224 225 static const xmlChar casemap[256] = { 226 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, 227 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F, 228 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17, 229 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, 230 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27, 231 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, 232 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37, 233 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, 234 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67, 235 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, 236 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, 237 0x78,0x79,0x7A,0x7B,0x5C,0x5D,0x5E,0x5F, 238 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67, 239 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, 240 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, 241 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, 242 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, 243 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, 244 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97, 245 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, 246 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7, 247 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, 248 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7, 249 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, 250 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7, 251 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, 252 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7, 253 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, 254 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7, 255 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, 256 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7, 257 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF 258 }; 259 260 /** 261 * xmlStrcasecmp: 262 * @str1: the first xmlChar * 263 * @str2: the second xmlChar * 264 * 265 * a strcasecmp for xmlChar's 266 * 267 * Returns the integer result of the comparison 268 */ 269 270 int 271 xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) { 272 register int tmp; 273 274 if (str1 == str2) return(0); 275 if (str1 == NULL) return(-1); 276 if (str2 == NULL) return(1); 277 do { 278 tmp = casemap[*str1++] - casemap[*str2]; 279 if (tmp != 0) return(tmp); 280 } while (*str2++ != 0); 281 return 0; 282 } 283 284 /** 285 * xmlStrncasecmp: 286 * @str1: the first xmlChar * 287 * @str2: the second xmlChar * 288 * @len: the max comparison length 289 * 290 * a strncasecmp for xmlChar's 291 * 292 * Returns the integer result of the comparison 293 */ 294 295 int 296 xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len) { 297 register int tmp; 298 299 if (len <= 0) return(0); 300 if (str1 == str2) return(0); 301 if (str1 == NULL) return(-1); 302 if (str2 == NULL) return(1); 303 do { 304 tmp = casemap[*str1++] - casemap[*str2]; 305 if (tmp != 0 || --len == 0) return(tmp); 306 } while (*str2++ != 0); 307 return 0; 308 } 309 310 /** 311 * xmlStrchr: 312 * @str: the xmlChar * array 313 * @val: the xmlChar to search 314 * 315 * a strchr for xmlChar's 316 * 317 * Returns the xmlChar * for the first occurrence or NULL. 318 */ 319 320 const xmlChar * 321 xmlStrchr(const xmlChar *str, xmlChar val) { 322 if (str == NULL) return(NULL); 323 while (*str != 0) { /* non input consuming */ 324 if (*str == val) return((xmlChar *) str); 325 str++; 326 } 327 return(NULL); 328 } 329 330 /** 331 * xmlStrstr: 332 * @str: the xmlChar * array (haystack) 333 * @val: the xmlChar to search (needle) 334 * 335 * a strstr for xmlChar's 336 * 337 * Returns the xmlChar * for the first occurrence or NULL. 338 */ 339 340 const xmlChar * 341 xmlStrstr(const xmlChar *str, const xmlChar *val) { 342 int n; 343 344 if (str == NULL) return(NULL); 345 if (val == NULL) return(NULL); 346 n = xmlStrlen(val); 347 348 if (n == 0) return(str); 349 while (*str != 0) { /* non input consuming */ 350 if (*str == *val) { 351 if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str); 352 } 353 str++; 354 } 355 return(NULL); 356 } 357 358 /** 359 * xmlStrcasestr: 360 * @str: the xmlChar * array (haystack) 361 * @val: the xmlChar to search (needle) 362 * 363 * a case-ignoring strstr for xmlChar's 364 * 365 * Returns the xmlChar * for the first occurrence or NULL. 366 */ 367 368 const xmlChar * 369 xmlStrcasestr(const xmlChar *str, const xmlChar *val) { 370 int n; 371 372 if (str == NULL) return(NULL); 373 if (val == NULL) return(NULL); 374 n = xmlStrlen(val); 375 376 if (n == 0) return(str); 377 while (*str != 0) { /* non input consuming */ 378 if (casemap[*str] == casemap[*val]) 379 if (!xmlStrncasecmp(str, val, n)) return(str); 380 str++; 381 } 382 return(NULL); 383 } 384 385 /** 386 * xmlStrsub: 387 * @str: the xmlChar * array (haystack) 388 * @start: the index of the first char (zero based) 389 * @len: the length of the substring 390 * 391 * Extract a substring of a given string 392 * 393 * Returns the xmlChar * for the first occurrence or NULL. 394 */ 395 396 xmlChar * 397 xmlStrsub(const xmlChar *str, int start, int len) { 398 int i; 399 400 if (str == NULL) return(NULL); 401 if (start < 0) return(NULL); 402 if (len < 0) return(NULL); 403 404 for (i = 0;i < start;i++) { 405 if (*str == 0) return(NULL); 406 str++; 407 } 408 if (*str == 0) return(NULL); 409 return(xmlStrndup(str, len)); 410 } 411 412 /** 413 * xmlStrlen: 414 * @str: the xmlChar * array 415 * 416 * length of a xmlChar's string 417 * 418 * Returns the number of xmlChar contained in the ARRAY. 419 */ 420 421 int 422 xmlStrlen(const xmlChar *str) { 423 int len = 0; 424 425 if (str == NULL) return(0); 426 while (*str != 0) { /* non input consuming */ 427 str++; 428 len++; 429 } 430 return(len); 431 } 432 433 /** 434 * xmlStrncat: 435 * @cur: the original xmlChar * array 436 * @add: the xmlChar * array added 437 * @len: the length of @add 438 * 439 * a strncat for array of xmlChar's, it will extend @cur with the len 440 * first bytes of @add. Note that if @len < 0 then this is an API error 441 * and NULL will be returned. 442 * 443 * Returns a new xmlChar *, the original @cur is reallocated if needed 444 * and should not be freed 445 */ 446 447 xmlChar * 448 xmlStrncat(xmlChar *cur, const xmlChar *add, int len) { 449 int size; 450 xmlChar *ret; 451 452 if ((add == NULL) || (len == 0)) 453 return(cur); 454 if (len < 0) 455 return(NULL); 456 if (cur == NULL) 457 return(xmlStrndup(add, len)); 458 459 size = xmlStrlen(cur); 460 if (size < 0) 461 return(NULL); 462 ret = (xmlChar *) xmlRealloc(cur, (size + len + 1) * sizeof(xmlChar)); 463 if (ret == NULL) { 464 xmlErrMemory(NULL, NULL); 465 return(cur); 466 } 467 memcpy(&ret[size], add, len * sizeof(xmlChar)); 468 ret[size + len] = 0; 469 return(ret); 470 } 471 472 /** 473 * xmlStrncatNew: 474 * @str1: first xmlChar string 475 * @str2: second xmlChar string 476 * @len: the len of @str2 or < 0 477 * 478 * same as xmlStrncat, but creates a new string. The original 479 * two strings are not freed. If @len is < 0 then the length 480 * will be calculated automatically. 481 * 482 * Returns a new xmlChar * or NULL 483 */ 484 xmlChar * 485 xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) { 486 int size; 487 xmlChar *ret; 488 489 if (len < 0) { 490 len = xmlStrlen(str2); 491 if (len < 0) 492 return(NULL); 493 } 494 if ((str2 == NULL) || (len == 0)) 495 return(xmlStrdup(str1)); 496 if (str1 == NULL) 497 return(xmlStrndup(str2, len)); 498 499 size = xmlStrlen(str1); 500 if (size < 0) 501 return(NULL); 502 ret = (xmlChar *) xmlMalloc((size + len + 1) * sizeof(xmlChar)); 503 if (ret == NULL) { 504 xmlErrMemory(NULL, NULL); 505 return(xmlStrndup(str1, size)); 506 } 507 memcpy(ret, str1, size * sizeof(xmlChar)); 508 memcpy(&ret[size], str2, len * sizeof(xmlChar)); 509 ret[size + len] = 0; 510 return(ret); 511 } 512 513 /** 514 * xmlStrcat: 515 * @cur: the original xmlChar * array 516 * @add: the xmlChar * array added 517 * 518 * a strcat for array of xmlChar's. Since they are supposed to be 519 * encoded in UTF-8 or an encoding with 8bit based chars, we assume 520 * a termination mark of '0'. 521 * 522 * Returns a new xmlChar * containing the concatenated string. 523 */ 524 xmlChar * 525 xmlStrcat(xmlChar *cur, const xmlChar *add) { 526 const xmlChar *p = add; 527 528 if (add == NULL) return(cur); 529 if (cur == NULL) 530 return(xmlStrdup(add)); 531 532 while (*p != 0) p++; /* non input consuming */ 533 return(xmlStrncat(cur, add, p - add)); 534 } 535 536 /** 537 * xmlStrPrintf: 538 * @buf: the result buffer. 539 * @len: the result buffer length. 540 * @msg: the message with printf formatting. 541 * @...: extra parameters for the message. 542 * 543 * Formats @msg and places result into @buf. 544 * 545 * Returns the number of characters written to @buf or -1 if an error occurs. 546 */ 547 int XMLCDECL 548 xmlStrPrintf(xmlChar *buf, int len, const char *msg, ...) { 549 va_list args; 550 int ret; 551 552 if((buf == NULL) || (msg == NULL)) { 553 return(-1); 554 } 555 556 va_start(args, msg); 557 ret = vsnprintf((char *) buf, len, (const char *) msg, args); 558 va_end(args); 559 buf[len - 1] = 0; /* be safe ! */ 560 561 return(ret); 562 } 563 564 /** 565 * xmlStrVPrintf: 566 * @buf: the result buffer. 567 * @len: the result buffer length. 568 * @msg: the message with printf formatting. 569 * @ap: extra parameters for the message. 570 * 571 * Formats @msg and places result into @buf. 572 * 573 * Returns the number of characters written to @buf or -1 if an error occurs. 574 */ 575 int 576 xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap) { 577 int ret; 578 579 if((buf == NULL) || (msg == NULL)) { 580 return(-1); 581 } 582 583 ret = vsnprintf((char *) buf, len, (const char *) msg, ap); 584 buf[len - 1] = 0; /* be safe ! */ 585 586 return(ret); 587 } 588 589 /************************************************************************ 590 * * 591 * Generic UTF8 handling routines * 592 * * 593 * From rfc2044: encoding of the Unicode values on UTF-8: * 594 * * 595 * UCS-4 range (hex.) UTF-8 octet sequence (binary) * 596 * 0000 0000-0000 007F 0xxxxxxx * 597 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx * 598 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx * 599 * * 600 * I hope we won't use values > 0xFFFF anytime soon ! * 601 * * 602 ************************************************************************/ 603 604 605 /** 606 * xmlUTF8Size: 607 * @utf: pointer to the UTF8 character 608 * 609 * calculates the internal size of a UTF8 character 610 * 611 * returns the numbers of bytes in the character, -1 on format error 612 */ 613 int 614 xmlUTF8Size(const xmlChar *utf) { 615 xmlChar mask; 616 int len; 617 618 if (utf == NULL) 619 return -1; 620 if (*utf < 0x80) 621 return 1; 622 /* check valid UTF8 character */ 623 if (!(*utf & 0x40)) 624 return -1; 625 /* determine number of bytes in char */ 626 len = 2; 627 for (mask=0x20; mask != 0; mask>>=1) { 628 if (!(*utf & mask)) 629 return len; 630 len++; 631 } 632 return -1; 633 } 634 635 /** 636 * xmlUTF8Charcmp: 637 * @utf1: pointer to first UTF8 char 638 * @utf2: pointer to second UTF8 char 639 * 640 * compares the two UCS4 values 641 * 642 * returns result of the compare as with xmlStrncmp 643 */ 644 int 645 xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) { 646 647 if (utf1 == NULL ) { 648 if (utf2 == NULL) 649 return 0; 650 return -1; 651 } 652 return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1)); 653 } 654 655 /** 656 * xmlUTF8Strlen: 657 * @utf: a sequence of UTF-8 encoded bytes 658 * 659 * compute the length of an UTF8 string, it doesn't do a full UTF8 660 * checking of the content of the string. 661 * 662 * Returns the number of characters in the string or -1 in case of error 663 */ 664 int 665 xmlUTF8Strlen(const xmlChar *utf) { 666 int ret = 0; 667 668 if (utf == NULL) 669 return(-1); 670 671 while (*utf != 0) { 672 if (utf[0] & 0x80) { 673 if ((utf[1] & 0xc0) != 0x80) 674 return(-1); 675 if ((utf[0] & 0xe0) == 0xe0) { 676 if ((utf[2] & 0xc0) != 0x80) 677 return(-1); 678 if ((utf[0] & 0xf0) == 0xf0) { 679 if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80) 680 return(-1); 681 utf += 4; 682 } else { 683 utf += 3; 684 } 685 } else { 686 utf += 2; 687 } 688 } else { 689 utf++; 690 } 691 ret++; 692 } 693 return(ret); 694 } 695 696 /** 697 * xmlGetUTF8Char: 698 * @utf: a sequence of UTF-8 encoded bytes 699 * @len: a pointer to the minimum number of bytes present in 700 * the sequence. This is used to assure the next character 701 * is completely contained within the sequence. 702 * 703 * Read the first UTF8 character from @utf 704 * 705 * Returns the char value or -1 in case of error, and sets *len to 706 * the actual number of bytes consumed (0 in case of error) 707 */ 708 int 709 xmlGetUTF8Char(const unsigned char *utf, int *len) { 710 unsigned int c; 711 712 if (utf == NULL) 713 goto error; 714 if (len == NULL) 715 goto error; 716 if (*len < 1) 717 goto error; 718 719 c = utf[0]; 720 if (c & 0x80) { 721 if (*len < 2) 722 goto error; 723 if ((utf[1] & 0xc0) != 0x80) 724 goto error; 725 if ((c & 0xe0) == 0xe0) { 726 if (*len < 3) 727 goto error; 728 if ((utf[2] & 0xc0) != 0x80) 729 goto error; 730 if ((c & 0xf0) == 0xf0) { 731 if (*len < 4) 732 goto error; 733 if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80) 734 goto error; 735 *len = 4; 736 /* 4-byte code */ 737 c = (utf[0] & 0x7) << 18; 738 c |= (utf[1] & 0x3f) << 12; 739 c |= (utf[2] & 0x3f) << 6; 740 c |= utf[3] & 0x3f; 741 } else { 742 /* 3-byte code */ 743 *len = 3; 744 c = (utf[0] & 0xf) << 12; 745 c |= (utf[1] & 0x3f) << 6; 746 c |= utf[2] & 0x3f; 747 } 748 } else { 749 /* 2-byte code */ 750 *len = 2; 751 c = (utf[0] & 0x1f) << 6; 752 c |= utf[1] & 0x3f; 753 } 754 } else { 755 /* 1-byte code */ 756 *len = 1; 757 } 758 return(c); 759 760 error: 761 if (len != NULL) 762 *len = 0; 763 return(-1); 764 } 765 766 /** 767 * xmlCheckUTF8: 768 * @utf: Pointer to putative UTF-8 encoded string. 769 * 770 * Checks @utf for being valid UTF-8. @utf is assumed to be 771 * null-terminated. This function is not super-strict, as it will 772 * allow longer UTF-8 sequences than necessary. Note that Java is 773 * capable of producing these sequences if provoked. Also note, this 774 * routine checks for the 4-byte maximum size, but does not check for 775 * 0x10ffff maximum value. 776 * 777 * Return value: true if @utf is valid. 778 **/ 779 int 780 xmlCheckUTF8(const unsigned char *utf) 781 { 782 int ix; 783 unsigned char c; 784 785 if (utf == NULL) 786 return(0); 787 /* 788 * utf is a string of 1, 2, 3 or 4 bytes. The valid strings 789 * are as follows (in "bit format"): 790 * 0xxxxxxx valid 1-byte 791 * 110xxxxx 10xxxxxx valid 2-byte 792 * 1110xxxx 10xxxxxx 10xxxxxx valid 3-byte 793 * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx valid 4-byte 794 */ 795 for (ix = 0; (c = utf[ix]);) { /* string is 0-terminated */ 796 if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */ 797 ix++; 798 } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */ 799 if ((utf[ix+1] & 0xc0 ) != 0x80) 800 return 0; 801 ix += 2; 802 } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */ 803 if (((utf[ix+1] & 0xc0) != 0x80) || 804 ((utf[ix+2] & 0xc0) != 0x80)) 805 return 0; 806 ix += 3; 807 } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */ 808 if (((utf[ix+1] & 0xc0) != 0x80) || 809 ((utf[ix+2] & 0xc0) != 0x80) || 810 ((utf[ix+3] & 0xc0) != 0x80)) 811 return 0; 812 ix += 4; 813 } else /* unknown encoding */ 814 return 0; 815 } 816 return(1); 817 } 818 819 /** 820 * xmlUTF8Strsize: 821 * @utf: a sequence of UTF-8 encoded bytes 822 * @len: the number of characters in the array 823 * 824 * storage size of an UTF8 string 825 * the behaviour is not guaranteed if the input string is not UTF-8 826 * 827 * Returns the storage size of 828 * the first 'len' characters of ARRAY 829 */ 830 831 int 832 xmlUTF8Strsize(const xmlChar *utf, int len) { 833 const xmlChar *ptr=utf; 834 xmlChar ch; 835 836 if (utf == NULL) 837 return(0); 838 839 if (len <= 0) 840 return(0); 841 842 while ( len-- > 0) { 843 if ( !*ptr ) 844 break; 845 if ( (ch = *ptr++) & 0x80) 846 while ((ch<<=1) & 0x80 ) { 847 if (*ptr == 0) break; 848 ptr++; 849 } 850 } 851 return (ptr - utf); 852 } 853 854 855 /** 856 * xmlUTF8Strndup: 857 * @utf: the input UTF8 * 858 * @len: the len of @utf (in chars) 859 * 860 * a strndup for array of UTF8's 861 * 862 * Returns a new UTF8 * or NULL 863 */ 864 xmlChar * 865 xmlUTF8Strndup(const xmlChar *utf, int len) { 866 xmlChar *ret; 867 int i; 868 869 if ((utf == NULL) || (len < 0)) return(NULL); 870 i = xmlUTF8Strsize(utf, len); 871 ret = (xmlChar *) xmlMallocAtomic((i + 1) * sizeof(xmlChar)); 872 if (ret == NULL) { 873 xmlGenericError(xmlGenericErrorContext, 874 "malloc of %ld byte failed\n", 875 (len + 1) * (long)sizeof(xmlChar)); 876 return(NULL); 877 } 878 memcpy(ret, utf, i * sizeof(xmlChar)); 879 ret[i] = 0; 880 return(ret); 881 } 882 883 /** 884 * xmlUTF8Strpos: 885 * @utf: the input UTF8 * 886 * @pos: the position of the desired UTF8 char (in chars) 887 * 888 * a function to provide the equivalent of fetching a 889 * character from a string array 890 * 891 * Returns a pointer to the UTF8 character or NULL 892 */ 893 const xmlChar * 894 xmlUTF8Strpos(const xmlChar *utf, int pos) { 895 xmlChar ch; 896 897 if (utf == NULL) return(NULL); 898 if (pos < 0) 899 return(NULL); 900 while (pos--) { 901 if ((ch=*utf++) == 0) return(NULL); 902 if ( ch & 0x80 ) { 903 /* if not simple ascii, verify proper format */ 904 if ( (ch & 0xc0) != 0xc0 ) 905 return(NULL); 906 /* then skip over remaining bytes for this char */ 907 while ( (ch <<= 1) & 0x80 ) 908 if ( (*utf++ & 0xc0) != 0x80 ) 909 return(NULL); 910 } 911 } 912 return((xmlChar *)utf); 913 } 914 915 /** 916 * xmlUTF8Strloc: 917 * @utf: the input UTF8 * 918 * @utfchar: the UTF8 character to be found 919 * 920 * a function to provide the relative location of a UTF8 char 921 * 922 * Returns the relative character position of the desired char 923 * or -1 if not found 924 */ 925 int 926 xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) { 927 int i, size; 928 xmlChar ch; 929 930 if (utf==NULL || utfchar==NULL) return -1; 931 size = xmlUTF8Strsize(utfchar, 1); 932 for(i=0; (ch=*utf) != 0; i++) { 933 if (xmlStrncmp(utf, utfchar, size)==0) 934 return(i); 935 utf++; 936 if ( ch & 0x80 ) { 937 /* if not simple ascii, verify proper format */ 938 if ( (ch & 0xc0) != 0xc0 ) 939 return(-1); 940 /* then skip over remaining bytes for this char */ 941 while ( (ch <<= 1) & 0x80 ) 942 if ( (*utf++ & 0xc0) != 0x80 ) 943 return(-1); 944 } 945 } 946 947 return(-1); 948 } 949 /** 950 * xmlUTF8Strsub: 951 * @utf: a sequence of UTF-8 encoded bytes 952 * @start: relative pos of first char 953 * @len: total number to copy 954 * 955 * Create a substring from a given UTF-8 string 956 * Note: positions are given in units of UTF-8 chars 957 * 958 * Returns a pointer to a newly created string 959 * or NULL if any problem 960 */ 961 962 xmlChar * 963 xmlUTF8Strsub(const xmlChar *utf, int start, int len) { 964 int i; 965 xmlChar ch; 966 967 if (utf == NULL) return(NULL); 968 if (start < 0) return(NULL); 969 if (len < 0) return(NULL); 970 971 /* 972 * Skip over any leading chars 973 */ 974 for (i = 0;i < start;i++) { 975 if ((ch=*utf++) == 0) return(NULL); 976 if ( ch & 0x80 ) { 977 /* if not simple ascii, verify proper format */ 978 if ( (ch & 0xc0) != 0xc0 ) 979 return(NULL); 980 /* then skip over remaining bytes for this char */ 981 while ( (ch <<= 1) & 0x80 ) 982 if ( (*utf++ & 0xc0) != 0x80 ) 983 return(NULL); 984 } 985 } 986 987 return(xmlUTF8Strndup(utf, len)); 988 } 989 990 /** 991 * xmlEscapeFormatString: 992 * @msg: a pointer to the string in which to escape '%' characters. 993 * Must be a heap-allocated buffer created by libxml2 that may be 994 * returned, or that may be freed and replaced. 995 * 996 * Replaces the string pointed to by 'msg' with an escaped string. 997 * Returns the same string with all '%' characters escaped. 998 */ 999 xmlChar * 1000 xmlEscapeFormatString(xmlChar **msg) 1001 { 1002 xmlChar *msgPtr = NULL; 1003 xmlChar *result = NULL; 1004 xmlChar *resultPtr = NULL; 1005 size_t count = 0; 1006 size_t msgLen = 0; 1007 size_t resultLen = 0; 1008 1009 if (!msg || !*msg) 1010 return(NULL); 1011 1012 for (msgPtr = *msg; *msgPtr != '\0'; ++msgPtr) { 1013 ++msgLen; 1014 if (*msgPtr == '%') 1015 ++count; 1016 } 1017 1018 if (count == 0) 1019 return(*msg); 1020 1021 resultLen = msgLen + count + 1; 1022 result = (xmlChar *) xmlMallocAtomic(resultLen * sizeof(xmlChar)); 1023 if (result == NULL) { 1024 /* Clear *msg to prevent format string vulnerabilities in 1025 out-of-memory situations. */ 1026 xmlFree(*msg); 1027 *msg = NULL; 1028 xmlErrMemory(NULL, NULL); 1029 return(NULL); 1030 } 1031 1032 for (msgPtr = *msg, resultPtr = result; *msgPtr != '\0'; ++msgPtr, ++resultPtr) { 1033 *resultPtr = *msgPtr; 1034 if (*msgPtr == '%') 1035 *(++resultPtr) = '%'; 1036 } 1037 result[resultLen - 1] = '\0'; 1038 1039 xmlFree(*msg); 1040 *msg = result; 1041 1042 return *msg; 1043 } 1044 1045 #define bottom_xmlstring 1046 #include "elfgcchack.h"