1 /*************************************************
2 * Perl-Compatible Regular Expressions *
3 *************************************************/
4
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7
8 Written by Philip Hazel
9 Original API code Copyright (c) 1997-2012 University of Cambridge
10 New API code Copyright (c) 2016-2018 University of Cambridge
11
12 -----------------------------------------------------------------------------
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15
16 * Redistributions of source code must retain the above copyright notice,
17 this list of conditions and the following disclaimer.
18
19 * Redistributions in binary form must reproduce the above copyright
20 notice, this list of conditions and the following disclaimer in the
21 documentation and/or other materials provided with the distribution.
22
23 * Neither the name of the University of Cambridge nor the names of its
24 contributors may be used to endorse or promote products derived from
25 this software without specific prior written permission.
26
27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 POSSIBILITY OF SUCH DAMAGE.
38 -----------------------------------------------------------------------------
39 */
40
41
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
45
46 #include "pcre2_internal.h"
47
48
49
50 /*************************************************
51 * Copy named captured string to given buffer *
52 *************************************************/
53
54 /* This function copies a single captured substring into a given buffer,
55 identifying it by name. If the regex permits duplicate names, the first
56 substring that is set is chosen.
57
58 Arguments:
59 match_data points to the match data
60 stringname the name of the required substring
61 buffer where to put the substring
62 sizeptr the size of the buffer, updated to the size of the substring
63
64 Returns: if successful: zero
65 if not successful, a negative error code:
66 (1) an error from nametable_scan()
67 (2) an error from copy_bynumber()
68 (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
69 (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
70 */
71
72 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_copy_byname(pcre2_match_data * match_data,PCRE2_SPTR stringname,PCRE2_UCHAR * buffer,PCRE2_SIZE * sizeptr)73 pcre2_substring_copy_byname(pcre2_match_data *match_data, PCRE2_SPTR stringname,
74 PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
75 {
76 PCRE2_SPTR first, last, entry;
77 int failrc, entrysize;
78 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
79 return PCRE2_ERROR_DFA_UFUNC;
80 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
81 &first, &last);
82 if (entrysize < 0) return entrysize;
83 failrc = PCRE2_ERROR_UNAVAILABLE;
84 for (entry = first; entry <= last; entry += entrysize)
85 {
86 uint32_t n = GET2(entry, 0);
87 if (n < match_data->oveccount)
88 {
89 if (match_data->ovector[n*2] != PCRE2_UNSET)
90 return pcre2_substring_copy_bynumber(match_data, n, buffer, sizeptr);
91 failrc = PCRE2_ERROR_UNSET;
92 }
93 }
94 return failrc;
95 }
96
97
98
99 /*************************************************
100 * Copy numbered captured string to given buffer *
101 *************************************************/
102
103 /* This function copies a single captured substring into a given buffer,
104 identifying it by number.
105
106 Arguments:
107 match_data points to the match data
108 stringnumber the number of the required substring
109 buffer where to put the substring
110 sizeptr the size of the buffer, updated to the size of the substring
111
112 Returns: if successful: 0
113 if not successful, a negative error code:
114 PCRE2_ERROR_NOMEMORY: buffer too small
115 PCRE2_ERROR_NOSUBSTRING: no such substring
116 PCRE2_ERROR_UNAVAILABLE: ovector too small
117 PCRE2_ERROR_UNSET: substring is not set
118 */
119
120 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_copy_bynumber(pcre2_match_data * match_data,uint32_t stringnumber,PCRE2_UCHAR * buffer,PCRE2_SIZE * sizeptr)121 pcre2_substring_copy_bynumber(pcre2_match_data *match_data,
122 uint32_t stringnumber, PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
123 {
124 int rc;
125 PCRE2_SIZE size;
126 rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
127 if (rc < 0) return rc;
128 if (size + 1 > *sizeptr) return PCRE2_ERROR_NOMEMORY;
129 memcpy(buffer, match_data->subject + match_data->ovector[stringnumber*2],
130 CU2BYTES(size));
131 buffer[size] = 0;
132 *sizeptr = size;
133 return 0;
134 }
135
136
137
138 /*************************************************
139 * Extract named captured string *
140 *************************************************/
141
142 /* This function copies a single captured substring, identified by name, into
143 new memory. If the regex permits duplicate names, the first substring that is
144 set is chosen.
145
146 Arguments:
147 match_data pointer to match_data
148 stringname the name of the required substring
149 stringptr where to put the pointer to the new memory
150 sizeptr where to put the length of the substring
151
152 Returns: if successful: zero
153 if not successful, a negative value:
154 (1) an error from nametable_scan()
155 (2) an error from get_bynumber()
156 (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
157 (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
158 */
159
160 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_get_byname(pcre2_match_data * match_data,PCRE2_SPTR stringname,PCRE2_UCHAR ** stringptr,PCRE2_SIZE * sizeptr)161 pcre2_substring_get_byname(pcre2_match_data *match_data,
162 PCRE2_SPTR stringname, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
163 {
164 PCRE2_SPTR first, last, entry;
165 int failrc, entrysize;
166 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
167 return PCRE2_ERROR_DFA_UFUNC;
168 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
169 &first, &last);
170 if (entrysize < 0) return entrysize;
171 failrc = PCRE2_ERROR_UNAVAILABLE;
172 for (entry = first; entry <= last; entry += entrysize)
173 {
174 uint32_t n = GET2(entry, 0);
175 if (n < match_data->oveccount)
176 {
177 if (match_data->ovector[n*2] != PCRE2_UNSET)
178 return pcre2_substring_get_bynumber(match_data, n, stringptr, sizeptr);
179 failrc = PCRE2_ERROR_UNSET;
180 }
181 }
182 return failrc;
183 }
184
185
186
187 /*************************************************
188 * Extract captured string to new memory *
189 *************************************************/
190
191 /* This function copies a single captured substring into a piece of new
192 memory.
193
194 Arguments:
195 match_data points to match data
196 stringnumber the number of the required substring
197 stringptr where to put a pointer to the new memory
198 sizeptr where to put the size of the substring
199
200 Returns: if successful: 0
201 if not successful, a negative error code:
202 PCRE2_ERROR_NOMEMORY: failed to get memory
203 PCRE2_ERROR_NOSUBSTRING: no such substring
204 PCRE2_ERROR_UNAVAILABLE: ovector too small
205 PCRE2_ERROR_UNSET: substring is not set
206 */
207
208 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_get_bynumber(pcre2_match_data * match_data,uint32_t stringnumber,PCRE2_UCHAR ** stringptr,PCRE2_SIZE * sizeptr)209 pcre2_substring_get_bynumber(pcre2_match_data *match_data,
210 uint32_t stringnumber, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
211 {
212 int rc;
213 PCRE2_SIZE size;
214 PCRE2_UCHAR *yield;
215 rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
216 if (rc < 0) return rc;
217 yield = PRIV(memctl_malloc)(sizeof(pcre2_memctl) +
218 (size + 1)*PCRE2_CODE_UNIT_WIDTH, (pcre2_memctl *)match_data);
219 if (yield == NULL) return PCRE2_ERROR_NOMEMORY;
220 yield = (PCRE2_UCHAR *)(((char *)yield) + sizeof(pcre2_memctl));
221 memcpy(yield, match_data->subject + match_data->ovector[stringnumber*2],
222 CU2BYTES(size));
223 yield[size] = 0;
224 *stringptr = yield;
225 *sizeptr = size;
226 return 0;
227 }
228
229
230
231 /*************************************************
232 * Free memory obtained by get_substring *
233 *************************************************/
234
235 /*
236 Argument: the result of a previous pcre2_substring_get_byxxx()
237 Returns: nothing
238 */
239
240 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_substring_free(PCRE2_UCHAR * string)241 pcre2_substring_free(PCRE2_UCHAR *string)
242 {
243 if (string != NULL)
244 {
245 pcre2_memctl *memctl = (pcre2_memctl *)((char *)string - sizeof(pcre2_memctl));
246 memctl->free(memctl, memctl->memory_data);
247 }
248 }
249
250
251
252 /*************************************************
253 * Get length of a named substring *
254 *************************************************/
255
256 /* This function returns the length of a named captured substring. If the regex
257 permits duplicate names, the first substring that is set is chosen.
258
259 Arguments:
260 match_data pointer to match data
261 stringname the name of the required substring
262 sizeptr where to put the length
263
264 Returns: 0 if successful, else a negative error number
265 */
266
267 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_length_byname(pcre2_match_data * match_data,PCRE2_SPTR stringname,PCRE2_SIZE * sizeptr)268 pcre2_substring_length_byname(pcre2_match_data *match_data,
269 PCRE2_SPTR stringname, PCRE2_SIZE *sizeptr)
270 {
271 PCRE2_SPTR first, last, entry;
272 int failrc, entrysize;
273 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
274 return PCRE2_ERROR_DFA_UFUNC;
275 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
276 &first, &last);
277 if (entrysize < 0) return entrysize;
278 failrc = PCRE2_ERROR_UNAVAILABLE;
279 for (entry = first; entry <= last; entry += entrysize)
280 {
281 uint32_t n = GET2(entry, 0);
282 if (n < match_data->oveccount)
283 {
284 if (match_data->ovector[n*2] != PCRE2_UNSET)
285 return pcre2_substring_length_bynumber(match_data, n, sizeptr);
286 failrc = PCRE2_ERROR_UNSET;
287 }
288 }
289 return failrc;
290 }
291
292
293
294 /*************************************************
295 * Get length of a numbered substring *
296 *************************************************/
297
298 /* This function returns the length of a captured substring. If the start is
299 beyond the end (which can happen when \K is used in an assertion), it sets the
300 length to zero.
301
302 Arguments:
303 match_data pointer to match data
304 stringnumber the number of the required substring
305 sizeptr where to put the length, if not NULL
306
307 Returns: if successful: 0
308 if not successful, a negative error code:
309 PCRE2_ERROR_NOSUBSTRING: no such substring
310 PCRE2_ERROR_UNAVAILABLE: ovector is too small
311 PCRE2_ERROR_UNSET: substring is not set
312 */
313
314 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_length_bynumber(pcre2_match_data * match_data,uint32_t stringnumber,PCRE2_SIZE * sizeptr)315 pcre2_substring_length_bynumber(pcre2_match_data *match_data,
316 uint32_t stringnumber, PCRE2_SIZE *sizeptr)
317 {
318 PCRE2_SIZE left, right;
319 int count = match_data->rc;
320 if (count == PCRE2_ERROR_PARTIAL)
321 {
322 if (stringnumber > 0) return PCRE2_ERROR_PARTIAL;
323 count = 0;
324 }
325 else if (count < 0) return count; /* Match failed */
326
327 if (match_data->matchedby != PCRE2_MATCHEDBY_DFA_INTERPRETER)
328 {
329 if (stringnumber > match_data->code->top_bracket)
330 return PCRE2_ERROR_NOSUBSTRING;
331 if (stringnumber >= match_data->oveccount)
332 return PCRE2_ERROR_UNAVAILABLE;
333 if (match_data->ovector[stringnumber*2] == PCRE2_UNSET)
334 return PCRE2_ERROR_UNSET;
335 }
336 else /* Matched using pcre2_dfa_match() */
337 {
338 if (stringnumber >= match_data->oveccount) return PCRE2_ERROR_UNAVAILABLE;
339 if (count != 0 && stringnumber >= (uint32_t)count) return PCRE2_ERROR_UNSET;
340 }
341
342 left = match_data->ovector[stringnumber*2];
343 right = match_data->ovector[stringnumber*2+1];
344 if (sizeptr != NULL) *sizeptr = (left > right)? 0 : right - left;
345 return 0;
346 }
347
348
349
350 /*************************************************
351 * Extract all captured strings to new memory *
352 *************************************************/
353
354 /* This function gets one chunk of memory and builds a list of pointers and all
355 the captured substrings in it. A NULL pointer is put on the end of the list.
356 The substrings are zero-terminated, but also, if the final argument is
357 non-NULL, a list of lengths is also returned. This allows binary data to be
358 handled.
359
360 Arguments:
361 match_data points to the match data
362 listptr set to point to the list of pointers
363 lengthsptr set to point to the list of lengths (may be NULL)
364
365 Returns: if successful: 0
366 if not successful, a negative error code:
367 PCRE2_ERROR_NOMEMORY: failed to get memory,
368 or a match failure code
369 */
370
371 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_list_get(pcre2_match_data * match_data,PCRE2_UCHAR *** listptr,PCRE2_SIZE ** lengthsptr)372 pcre2_substring_list_get(pcre2_match_data *match_data, PCRE2_UCHAR ***listptr,
373 PCRE2_SIZE **lengthsptr)
374 {
375 int i, count, count2;
376 PCRE2_SIZE size;
377 PCRE2_SIZE *lensp;
378 pcre2_memctl *memp;
379 PCRE2_UCHAR **listp;
380 PCRE2_UCHAR *sp;
381 PCRE2_SIZE *ovector;
382
383 if ((count = match_data->rc) < 0) return count; /* Match failed */
384 if (count == 0) count = match_data->oveccount; /* Ovector too small */
385
386 count2 = 2*count;
387 ovector = match_data->ovector;
388 size = sizeof(pcre2_memctl) + sizeof(PCRE2_UCHAR *); /* For final NULL */
389 if (lengthsptr != NULL) size += sizeof(PCRE2_SIZE) * count; /* For lengths */
390
391 for (i = 0; i < count2; i += 2)
392 {
393 size += sizeof(PCRE2_UCHAR *) + CU2BYTES(1);
394 if (ovector[i+1] > ovector[i]) size += CU2BYTES(ovector[i+1] - ovector[i]);
395 }
396
397 memp = PRIV(memctl_malloc)(size, (pcre2_memctl *)match_data);
398 if (memp == NULL) return PCRE2_ERROR_NOMEMORY;
399
400 *listptr = listp = (PCRE2_UCHAR **)((char *)memp + sizeof(pcre2_memctl));
401 lensp = (PCRE2_SIZE *)((char *)listp + sizeof(PCRE2_UCHAR *) * (count + 1));
402
403 if (lengthsptr == NULL)
404 {
405 sp = (PCRE2_UCHAR *)lensp;
406 lensp = NULL;
407 }
408 else
409 {
410 *lengthsptr = lensp;
411 sp = (PCRE2_UCHAR *)((char *)lensp + sizeof(PCRE2_SIZE) * count);
412 }
413
414 for (i = 0; i < count2; i += 2)
415 {
416 size = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0;
417
418 /* Size == 0 includes the case when the capture is unset. Avoid adding
419 PCRE2_UNSET to match_data->subject because it overflows, even though with
420 zero size calling memcpy() is harmless. */
421
422 if (size != 0) memcpy(sp, match_data->subject + ovector[i], CU2BYTES(size));
423 *listp++ = sp;
424 if (lensp != NULL) *lensp++ = size;
425 sp += size;
426 *sp++ = 0;
427 }
428
429 *listp = NULL;
430 return 0;
431 }
432
433
434
435 /*************************************************
436 * Free memory obtained by substring_list_get *
437 *************************************************/
438
439 /*
440 Argument: the result of a previous pcre2_substring_list_get()
441 Returns: nothing
442 */
443
444 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_substring_list_free(PCRE2_SPTR * list)445 pcre2_substring_list_free(PCRE2_SPTR *list)
446 {
447 if (list != NULL)
448 {
449 pcre2_memctl *memctl = (pcre2_memctl *)((char *)list - sizeof(pcre2_memctl));
450 memctl->free(memctl, memctl->memory_data);
451 }
452 }
453
454
455
456 /*************************************************
457 * Find (multiple) entries for named string *
458 *************************************************/
459
460 /* This function scans the nametable for a given name, using binary chop. It
461 returns either two pointers to the entries in the table, or, if no pointers are
462 given, the number of a unique group with the given name. If duplicate names are
463 permitted, and the name is not unique, an error is generated.
464
465 Arguments:
466 code the compiled regex
467 stringname the name whose entries required
468 firstptr where to put the pointer to the first entry
469 lastptr where to put the pointer to the last entry
470
471 Returns: PCRE2_ERROR_NOSUBSTRING if the name is not found
472 otherwise, if firstptr and lastptr are NULL:
473 a group number for a unique substring
474 else PCRE2_ERROR_NOUNIQUESUBSTRING
475 otherwise:
476 the length of each entry, having set firstptr and lastptr
477 */
478
479 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_nametable_scan(const pcre2_code * code,PCRE2_SPTR stringname,PCRE2_SPTR * firstptr,PCRE2_SPTR * lastptr)480 pcre2_substring_nametable_scan(const pcre2_code *code, PCRE2_SPTR stringname,
481 PCRE2_SPTR *firstptr, PCRE2_SPTR *lastptr)
482 {
483 uint16_t bot = 0;
484 uint16_t top = code->name_count;
485 uint16_t entrysize = code->name_entry_size;
486 PCRE2_SPTR nametable = (PCRE2_SPTR)((char *)code + sizeof(pcre2_real_code));
487
488 while (top > bot)
489 {
490 uint16_t mid = (top + bot) / 2;
491 PCRE2_SPTR entry = nametable + entrysize*mid;
492 int c = PRIV(strcmp)(stringname, entry + IMM2_SIZE);
493 if (c == 0)
494 {
495 PCRE2_SPTR first;
496 PCRE2_SPTR last;
497 PCRE2_SPTR lastentry;
498 lastentry = nametable + entrysize * (code->name_count - 1);
499 first = last = entry;
500 while (first > nametable)
501 {
502 if (PRIV(strcmp)(stringname, (first - entrysize + IMM2_SIZE)) != 0) break;
503 first -= entrysize;
504 }
505 while (last < lastentry)
506 {
507 if (PRIV(strcmp)(stringname, (last + entrysize + IMM2_SIZE)) != 0) break;
508 last += entrysize;
509 }
510 if (firstptr == NULL) return (first == last)?
511 (int)GET2(entry, 0) : PCRE2_ERROR_NOUNIQUESUBSTRING;
512 *firstptr = first;
513 *lastptr = last;
514 return entrysize;
515 }
516 if (c > 0) bot = mid + 1; else top = mid;
517 }
518
519 return PCRE2_ERROR_NOSUBSTRING;
520 }
521
522
523 /*************************************************
524 * Find number for named string *
525 *************************************************/
526
527 /* This function is a convenience wrapper for pcre2_substring_nametable_scan()
528 when it is known that names are unique. If there are duplicate names, it is not
529 defined which number is returned.
530
531 Arguments:
532 code the compiled regex
533 stringname the name whose number is required
534
535 Returns: the number of the named parenthesis, or a negative number
536 PCRE2_ERROR_NOSUBSTRING if not found
537 PCRE2_ERROR_NOUNIQUESUBSTRING if not unique
538 */
539
540 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_substring_number_from_name(const pcre2_code * code,PCRE2_SPTR stringname)541 pcre2_substring_number_from_name(const pcre2_code *code,
542 PCRE2_SPTR stringname)
543 {
544 return pcre2_substring_nametable_scan(code, stringname, NULL, NULL);
545 }
546
547 /* End of pcre2_substring.c */
548
