ddf5774e15010a2a452997a00e15ed103cc080e8
[ossec-hids.git] / pcre2_substring.c
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
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
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
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
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
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
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
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
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
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
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
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 */