Coverage Report

Created: 2023-09-28 22:19

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