Coverage Report

Created: 2024-01-20 12:32

/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
108M
xmlStrndup(const xmlChar *cur, int len) {
46
108M
    xmlChar *ret;
47
48
108M
    if ((cur == NULL) || (len < 0)) return(NULL);
49
108M
    ret = (xmlChar *) xmlMallocAtomic((size_t) len + 1);
50
108M
    if (ret == NULL) {
51
0
        return(NULL);
52
0
    }
53
108M
    memcpy(ret, cur, len);
54
108M
    ret[len] = 0;
55
108M
    return(ret);
56
108M
}
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
91.9M
xmlStrdup(const xmlChar *cur) {
70
91.9M
    const xmlChar *p = cur;
71
72
91.9M
    if (cur == NULL) return(NULL);
73
12.6G
    while (*p != 0) p++; /* non input consuming */
74
88.6M
    return(xmlStrndup(cur, p - cur));
75
91.9M
}
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
119k
xmlCharStrndup(const char *cur, int len) {
89
119k
    int i;
90
119k
    xmlChar *ret;
91
92
119k
    if ((cur == NULL) || (len < 0)) return(NULL);
93
119k
    ret = (xmlChar *) xmlMallocAtomic((size_t) len + 1);
94
119k
    if (ret == NULL) {
95
0
        return(NULL);
96
0
    }
97
25.2M
    for (i = 0;i < len;i++) {
98
        /* Explicit sign change */
99
25.1M
        ret[i] = (xmlChar) cur[i];
100
25.1M
        if (ret[i] == 0) return(ret);
101
25.1M
    }
102
119k
    ret[len] = 0;
103
119k
    return(ret);
104
119k
}
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
119k
xmlCharStrdup(const char *cur) {
117
119k
    const char *p = cur;
118
119
119k
    if (cur == NULL) return(NULL);
120
25.2M
    while (*p != '\0') p++; /* non input consuming */
121
119k
    return(xmlCharStrndup(cur, p - cur));
122
119k
}
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
87
xmlStrcmp(const xmlChar *str1, const xmlChar *str2) {
136
87
    if (str1 == str2) return(0);
137
87
    if (str1 == NULL) return(-1);
138
87
    if (str2 == NULL) return(1);
139
87
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
140
87
    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
87
}
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
168M
xmlStrEqual(const xmlChar *str1, const xmlChar *str2) {
163
168M
    if (str1 == str2) return(1);
164
164M
    if (str1 == NULL) return(0);
165
164M
    if (str2 == NULL) return(0);
166
164M
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
167
164M
    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
164M
}
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
0
xmlStrQEqual(const xmlChar *pref, const xmlChar *name, const xmlChar *str) {
189
0
    if (pref == NULL) return(xmlStrEqual(name, str));
190
0
    if (name == NULL) return(0);
191
0
    if (str == NULL) return(0);
192
193
0
    do {
194
0
        if (*pref++ != *str) return(0);
195
0
    } while ((*str++) && (*pref));
196
0
    if (*str++ != ':') return(0);
197
0
    do {
198
0
        if (*name++ != *str) return(0);
199
0
    } while (*str++);
200
0
    return(1);
201
0
}
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
135M
xmlStrncmp(const xmlChar *str1, const xmlChar *str2, int len) {
216
135M
    if (len <= 0) return(0);
217
134M
    if (str1 == str2) return(0);
218
134M
    if (str1 == NULL) return(-1);
219
134M
    if (str2 == NULL) return(1);
220
134M
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
221
134M
    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
134M
}
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
0
xmlStrcasecmp(const xmlChar *str1, const xmlChar *str2) {
278
0
    register int tmp;
279
280
0
    if (str1 == str2) return(0);
281
0
    if (str1 == NULL) return(-1);
282
0
    if (str2 == NULL) return(1);
283
0
    do {
284
0
        tmp = casemap[*str1++] - casemap[*str2];
285
0
        if (tmp != 0) return(tmp);
286
0
    } while (*str2++ != 0);
287
0
    return 0;
288
0
}
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
43.4M
xmlStrncasecmp(const xmlChar *str1, const xmlChar *str2, int len) {
303
43.4M
    register int tmp;
304
305
43.4M
    if (len <= 0) return(0);
306
43.4M
    if (str1 == str2) return(0);
307
43.4M
    if (str1 == NULL) return(-1);
308
43.4M
    if (str2 == NULL) return(1);
309
3.66G
    do {
310
3.66G
        tmp = casemap[*str1++] - casemap[*str2];
311
3.66G
        if (tmp != 0 || --len == 0) return(tmp);
312
3.66G
    } while (*str2++ != 0);
313
0
    return 0;
314
43.4M
}
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
7.82M
xmlStrchr(const xmlChar *str, xmlChar val) {
328
7.82M
    if (str == NULL) return(NULL);
329
952M
    while (*str != 0) { /* non input consuming */
330
946M
        if (*str == val) return((xmlChar *) str);
331
945M
        str++;
332
945M
    }
333
6.63M
    return(NULL);
334
7.82M
}
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
3.07M
xmlStrstr(const xmlChar *str, const xmlChar *val) {
348
3.07M
    int n;
349
350
3.07M
    if (str == NULL) return(NULL);
351
3.07M
    if (val == NULL) return(NULL);
352
3.07M
    n = xmlStrlen(val);
353
354
3.07M
    if (n == 0) return(str);
355
63.1M
    while (*str != 0) { /* non input consuming */
356
60.1M
        if (*str == *val) {
357
530k
            if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);
358
530k
        }
359
60.0M
        str++;
360
60.0M
    }
361
3.00M
    return(NULL);
362
3.07M
}
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
0
xmlStrcasestr(const xmlChar *str, const xmlChar *val) {
376
0
    int n;
377
378
0
    if (str == NULL) return(NULL);
379
0
    if (val == NULL) return(NULL);
380
0
    n = xmlStrlen(val);
381
382
0
    if (n == 0) return(str);
383
0
    while (*str != 0) { /* non input consuming */
384
0
        if (casemap[*str] == casemap[*val])
385
0
            if (!xmlStrncasecmp(str, val, n)) return(str);
386
0
        str++;
387
0
    }
388
0
    return(NULL);
389
0
}
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
103
xmlStrsub(const xmlChar *str, int start, int len) {
404
103
    int i;
405
406
103
    if (str == NULL) return(NULL);
407
103
    if (start < 0) return(NULL);
408
103
    if (len < 0) return(NULL);
409
410
103
    for (i = 0;i < start;i++) {
411
0
        if (*str == 0) return(NULL);
412
0
        str++;
413
0
    }
414
103
    if (*str == 0) return(NULL);
415
103
    return(xmlStrndup(str, len));
416
103
}
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
94.5M
xmlStrlen(const xmlChar *str) {
429
94.5M
    size_t len = str ? strlen((const char *)str) : 0;
430
94.5M
    return(len > INT_MAX ? 0 : len);
431
94.5M
}
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
119k
xmlStrncat(xmlChar *cur, const xmlChar *add, int len) {
449
119k
    int size;
450
119k
    xmlChar *ret;
451
452
119k
    if ((add == NULL) || (len == 0))
453
8.09k
        return(cur);
454
111k
    if (len < 0)
455
0
  return(NULL);
456
111k
    if (cur == NULL)
457
0
        return(xmlStrndup(add, len));
458
459
111k
    size = xmlStrlen(cur);
460
111k
    if ((size < 0) || (size > INT_MAX - len))
461
0
        return(NULL);
462
111k
    ret = (xmlChar *) xmlRealloc(cur, (size_t) size + len + 1);
463
111k
    if (ret == NULL) {
464
0
        return(cur);
465
0
    }
466
111k
    memcpy(&ret[size], add, len);
467
111k
    ret[size + len] = 0;
468
111k
    return(ret);
469
111k
}
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
0
xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) {
485
0
    int size;
486
0
    xmlChar *ret;
487
488
0
    if (len < 0) {
489
0
        len = xmlStrlen(str2);
490
0
        if (len < 0)
491
0
            return(NULL);
492
0
    }
493
0
    if ((str2 == NULL) || (len == 0))
494
0
        return(xmlStrdup(str1));
495
0
    if (str1 == NULL)
496
0
        return(xmlStrndup(str2, len));
497
498
0
    size = xmlStrlen(str1);
499
0
    if ((size < 0) || (size > INT_MAX - len))
500
0
        return(NULL);
501
0
    ret = (xmlChar *) xmlMalloc((size_t) size + len + 1);
502
0
    if (ret == NULL) {
503
0
        return(xmlStrndup(str1, size));
504
0
    }
505
0
    memcpy(ret, str1, size);
506
0
    memcpy(&ret[size], str2, len);
507
0
    ret[size + len] = 0;
508
0
    return(ret);
509
0
}
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
120k
xmlStrcat(xmlChar *cur, const xmlChar *add) {
525
120k
    const xmlChar *p = add;
526
527
120k
    if (add == NULL) return(cur);
528
120k
    if (cur == NULL)
529
546
        return(xmlStrdup(add));
530
531
302M
    while (*p != 0) p++; /* non input consuming */
532
119k
    return(xmlStrncat(cur, add, p - add));
533
120k
}
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
60.6M
xmlUTF8Size(const xmlChar *utf) {
614
60.6M
    xmlChar mask;
615
60.6M
    int len;
616
617
60.6M
    if (utf == NULL)
618
0
        return -1;
619
60.6M
    if (*utf < 0x80)
620
58.7M
        return 1;
621
    /* check valid UTF8 character */
622
1.86M
    if (!(*utf & 0x40))
623
1.23M
        return -1;
624
    /* determine number of bytes in char */
625
630k
    len = 2;
626
1.83M
    for (mask=0x20; mask != 0; mask>>=1) {
627
1.79M
        if (!(*utf & mask))
628
592k
            return len;
629
1.20M
        len++;
630
1.20M
    }
631
38.1k
    return -1;
632
630k
}
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
60.6M
xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
645
646
60.6M
    if (utf1 == NULL ) {
647
0
        if (utf2 == NULL)
648
0
            return 0;
649
0
        return -1;
650
0
    }
651
60.6M
    return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
652
60.6M
}
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
118k
xmlUTF8Strlen(const xmlChar *utf) {
665
118k
    size_t ret = 0;
666
667
118k
    if (utf == NULL)
668
0
        return(-1);
669
670
12.1M
    while (*utf != 0) {
671
12.0M
        if (utf[0] & 0x80) {
672
201k
            if ((utf[1] & 0xc0) != 0x80)
673
46.9k
                return(-1);
674
154k
            if ((utf[0] & 0xe0) == 0xe0) {
675
14.7k
                if ((utf[2] & 0xc0) != 0x80)
676
2.03k
                    return(-1);
677
12.7k
                if ((utf[0] & 0xf0) == 0xf0) {
678
7.79k
                    if ((utf[0] & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
679
1.31k
                        return(-1);
680
6.48k
                    utf += 4;
681
6.48k
                } else {
682
4.93k
                    utf += 3;
683
4.93k
                }
684
140k
            } else {
685
140k
                utf += 2;
686
140k
            }
687
11.8M
        } else {
688
11.8M
            utf++;
689
11.8M
        }
690
12.0M
        ret++;
691
12.0M
    }
692
67.7k
    return(ret > INT_MAX ? 0 : ret);
693
118k
}
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
0
xmlGetUTF8Char(const unsigned char *utf, int *len) {
709
0
    unsigned int c;
710
711
0
    if (utf == NULL)
712
0
        goto error;
713
0
    if (len == NULL)
714
0
        goto error;
715
0
    if (*len < 1)
716
0
        goto error;
717
718
0
    c = utf[0];
719
0
    if (c & 0x80) {
720
0
        if (*len < 2)
721
0
            goto error;
722
0
        if ((utf[1] & 0xc0) != 0x80)
723
0
            goto error;
724
0
        if ((c & 0xe0) == 0xe0) {
725
0
            if (*len < 3)
726
0
                goto error;
727
0
            if ((utf[2] & 0xc0) != 0x80)
728
0
                goto error;
729
0
            if ((c & 0xf0) == 0xf0) {
730
0
                if (*len < 4)
731
0
                    goto error;
732
0
                if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
733
0
                    goto error;
734
0
                *len = 4;
735
                /* 4-byte code */
736
0
                c = (utf[0] & 0x7) << 18;
737
0
                c |= (utf[1] & 0x3f) << 12;
738
0
                c |= (utf[2] & 0x3f) << 6;
739
0
                c |= utf[3] & 0x3f;
740
0
            } else {
741
              /* 3-byte code */
742
0
                *len = 3;
743
0
                c = (utf[0] & 0xf) << 12;
744
0
                c |= (utf[1] & 0x3f) << 6;
745
0
                c |= utf[2] & 0x3f;
746
0
            }
747
0
        } else {
748
          /* 2-byte code */
749
0
            *len = 2;
750
0
            c = (utf[0] & 0x1f) << 6;
751
0
            c |= utf[1] & 0x3f;
752
0
        }
753
0
    } else {
754
        /* 1-byte code */
755
0
        *len = 1;
756
0
    }
757
0
    return(c);
758
759
0
error:
760
0
    if (len != NULL)
761
0
  *len = 0;
762
0
    return(-1);
763
0
}
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
45.1k
{
781
45.1k
    int ix;
782
45.1k
    unsigned char c;
783
784
45.1k
    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
325k
    while ((c = utf[0])) {      /* string is 0-terminated */
795
323k
        ix = 0;
796
323k
        if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
797
274k
            ix = 1;
798
274k
  } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
799
3.23k
      if ((utf[1] & 0xc0 ) != 0x80)
800
399
          return 0;
801
2.83k
      ix = 2;
802
45.9k
  } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
803
3.19k
      if (((utf[1] & 0xc0) != 0x80) ||
804
3.19k
          ((utf[2] & 0xc0) != 0x80))
805
1.30k
        return 0;
806
1.88k
      ix = 3;
807
42.7k
  } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
808
2.13k
      if (((utf[1] & 0xc0) != 0x80) ||
809
2.13k
          ((utf[2] & 0xc0) != 0x80) ||
810
2.13k
    ((utf[3] & 0xc0) != 0x80))
811
823
        return 0;
812
1.30k
      ix = 4;
813
1.30k
  } else       /* unknown encoding */
814
40.6k
      return 0;
815
280k
        utf += ix;
816
280k
      }
817
2.00k
      return(1);
818
45.1k
}
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
147M
xmlUTF8Strsize(const xmlChar *utf, int len) {
834
147M
    const xmlChar *ptr=utf;
835
147M
    int ch;
836
147M
    size_t ret;
837
838
147M
    if (utf == NULL)
839
0
        return(0);
840
841
147M
    if (len <= 0)
842
447
        return(0);
843
844
295M
    while ( len-- > 0) {
845
148M
        if ( !*ptr )
846
6.38k
            break;
847
148M
        if ( (ch = *ptr++) & 0x80)
848
20.3M
            while ((ch<<=1) & 0x80 ) {
849
6.25M
    if (*ptr == 0) break;
850
6.21M
                ptr++;
851
6.21M
      }
852
148M
    }
853
147M
    ret = ptr - utf;
854
147M
    return (ret > INT_MAX ? 0 : ret);
855
147M
}
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
8.36k
xmlUTF8Strndup(const xmlChar *utf, int len) {
869
8.36k
    xmlChar *ret;
870
8.36k
    int i;
871
872
8.36k
    if ((utf == NULL) || (len < 0)) return(NULL);
873
8.36k
    i = xmlUTF8Strsize(utf, len);
874
8.36k
    ret = (xmlChar *) xmlMallocAtomic((size_t) i + 1);
875
8.36k
    if (ret == NULL) {
876
0
        return(NULL);
877
0
    }
878
8.36k
    memcpy(ret, utf, i);
879
8.36k
    ret[i] = 0;
880
8.36k
    return(ret);
881
8.36k
}
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
19.1k
xmlUTF8Strpos(const xmlChar *utf, int pos) {
895
19.1k
    int ch;
896
897
19.1k
    if (utf == NULL) return(NULL);
898
19.1k
    if (pos < 0)
899
0
        return(NULL);
900
453k
    while (pos--) {
901
435k
        if ((ch=*utf++) == 0) return(NULL);
902
435k
        if ( ch & 0x80 ) {
903
            /* if not simple ascii, verify proper format */
904
5.25k
            if ( (ch & 0xc0) != 0xc0 )
905
1.45k
                return(NULL);
906
            /* then skip over remaining bytes for this char */
907
9.86k
            while ( (ch <<= 1) & 0x80 )
908
6.05k
                if ( (*utf++ & 0xc0) != 0x80 )
909
0
                    return(NULL);
910
3.80k
        }
911
435k
    }
912
17.6k
    return((xmlChar *)utf);
913
19.1k
}
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
359k
xmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar) {
927
359k
    size_t i;
928
359k
    int size;
929
359k
    int ch;
930
931
359k
    if (utf==NULL || utfchar==NULL) return -1;
932
359k
    size = xmlUTF8Strsize(utfchar, 1);
933
11.7M
        for(i=0; (ch=*utf) != 0; i++) {
934
11.4M
            if (xmlStrncmp(utf, utfchar, size)==0)
935
29.4k
                return(i > INT_MAX ? 0 : i);
936
11.4M
            utf++;
937
11.4M
            if ( ch & 0x80 ) {
938
                /* if not simple ascii, verify proper format */
939
150k
                if ( (ch & 0xc0) != 0xc0 )
940
7.92k
                    return(-1);
941
                /* then skip over remaining bytes for this char */
942
363k
                while ( (ch <<= 1) & 0x80 )
943
234k
                    if ( (*utf++ & 0xc0) != 0x80 )
944
14.1k
                        return(-1);
945
143k
            }
946
11.4M
        }
947
948
307k
    return(-1);
949
359k
}
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
12.8k
xmlUTF8Strsub(const xmlChar *utf, int start, int len) {
965
12.8k
    int i;
966
12.8k
    int ch;
967
968
12.8k
    if (utf == NULL) return(NULL);
969
12.8k
    if (start < 0) return(NULL);
970
12.8k
    if (len < 0) return(NULL);
971
972
    /*
973
     * Skip over any leading chars
974
     */
975
106k
    for (i = 0;i < start;i++) {
976
99.3k
        if ((ch=*utf++) == 0) return(NULL);
977
95.4k
        if ( ch & 0x80 ) {
978
            /* if not simple ascii, verify proper format */
979
4.70k
            if ( (ch & 0xc0) != 0xc0 )
980
327
                return(NULL);
981
            /* then skip over remaining bytes for this char */
982
8.26k
            while ( (ch <<= 1) & 0x80 )
983
5.84k
                if ( (*utf++ & 0xc0) != 0x80 )
984
1.95k
                    return(NULL);
985
4.37k
        }
986
95.4k
    }
987
988
6.69k
    return(xmlUTF8Strndup(utf, len));
989
12.8k
}
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