a29f5eff673bed667eaaf5255f6de7554383294c
[ossec-hids.git] / pcre2_pattern_info.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 *        Return info about compiled pattern      *
51 *************************************************/
52
53 /*
54 Arguments:
55   code          points to compiled code
56   what          what information is required
57   where         where to put the information; if NULL, return length
58
59 Returns:        0 when data returned
60                 > 0 when length requested
61                 < 0 on error or unset value
62 */
63
64 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
65 pcre2_pattern_info(const pcre2_code *code, uint32_t what, void *where)
66 {
67 const pcre2_real_code *re = (pcre2_real_code *)code;
68
69 if (where == NULL)   /* Requests field length */
70   {
71   switch(what)
72     {
73     case PCRE2_INFO_ALLOPTIONS:
74     case PCRE2_INFO_ARGOPTIONS:
75     case PCRE2_INFO_BACKREFMAX:
76     case PCRE2_INFO_BSR:
77     case PCRE2_INFO_CAPTURECOUNT:
78     case PCRE2_INFO_DEPTHLIMIT:
79     case PCRE2_INFO_EXTRAOPTIONS:
80     case PCRE2_INFO_FIRSTCODETYPE:
81     case PCRE2_INFO_FIRSTCODEUNIT:
82     case PCRE2_INFO_HASBACKSLASHC:
83     case PCRE2_INFO_HASCRORLF:
84     case PCRE2_INFO_HEAPLIMIT:
85     case PCRE2_INFO_JCHANGED:
86     case PCRE2_INFO_LASTCODETYPE:
87     case PCRE2_INFO_LASTCODEUNIT:
88     case PCRE2_INFO_MATCHEMPTY:
89     case PCRE2_INFO_MATCHLIMIT:
90     case PCRE2_INFO_MAXLOOKBEHIND:
91     case PCRE2_INFO_MINLENGTH:
92     case PCRE2_INFO_NAMEENTRYSIZE:
93     case PCRE2_INFO_NAMECOUNT:
94     case PCRE2_INFO_NEWLINE:
95     return sizeof(uint32_t);
96
97     case PCRE2_INFO_FIRSTBITMAP:
98     return sizeof(const uint8_t *);
99
100     case PCRE2_INFO_JITSIZE:
101     case PCRE2_INFO_SIZE:
102     case PCRE2_INFO_FRAMESIZE:
103     return sizeof(size_t);
104
105     case PCRE2_INFO_NAMETABLE:
106     return sizeof(PCRE2_SPTR);
107     }
108   }
109
110 if (re == NULL) return PCRE2_ERROR_NULL;
111
112 /* Check that the first field in the block is the magic number. If it is not,
113 return with PCRE2_ERROR_BADMAGIC. */
114
115 if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;
116
117 /* Check that this pattern was compiled in the correct bit mode */
118
119 if ((re->flags & (PCRE2_CODE_UNIT_WIDTH/8)) == 0) return PCRE2_ERROR_BADMODE;
120
121 switch(what)
122   {
123   case PCRE2_INFO_ALLOPTIONS:
124   *((uint32_t *)where) = re->overall_options;
125   break;
126
127   case PCRE2_INFO_ARGOPTIONS:
128   *((uint32_t *)where) = re->compile_options;
129   break;
130
131   case PCRE2_INFO_BACKREFMAX:
132   *((uint32_t *)where) = re->top_backref;
133   break;
134
135   case PCRE2_INFO_BSR:
136   *((uint32_t *)where) = re->bsr_convention;
137   break;
138
139   case PCRE2_INFO_CAPTURECOUNT:
140   *((uint32_t *)where) = re->top_bracket;
141   break;
142
143   case PCRE2_INFO_DEPTHLIMIT:
144   *((uint32_t *)where) = re->limit_depth;
145   if (re->limit_depth == UINT32_MAX) return PCRE2_ERROR_UNSET;
146   break;
147
148   case PCRE2_INFO_EXTRAOPTIONS:
149   *((uint32_t *)where) = re->extra_options;
150   break;
151
152   case PCRE2_INFO_FIRSTCODETYPE:
153   *((uint32_t *)where) = ((re->flags & PCRE2_FIRSTSET) != 0)? 1 :
154                          ((re->flags & PCRE2_STARTLINE) != 0)? 2 : 0;
155   break;
156
157   case PCRE2_INFO_FIRSTCODEUNIT:
158   *((uint32_t *)where) = ((re->flags & PCRE2_FIRSTSET) != 0)?
159     re->first_codeunit : 0;
160   break;
161
162   case PCRE2_INFO_FIRSTBITMAP:
163   *((const uint8_t **)where) = ((re->flags & PCRE2_FIRSTMAPSET) != 0)?
164     &(re->start_bitmap[0]) : NULL;
165   break;
166
167   case PCRE2_INFO_FRAMESIZE:
168   *((size_t *)where) = offsetof(heapframe, ovector) +
169     re->top_bracket * 2 * sizeof(PCRE2_SIZE);
170   break;
171
172   case PCRE2_INFO_HASBACKSLASHC:
173   *((uint32_t *)where) = (re->flags & PCRE2_HASBKC) != 0;
174   break;
175
176   case PCRE2_INFO_HASCRORLF:
177   *((uint32_t *)where) = (re->flags & PCRE2_HASCRORLF) != 0;
178   break;
179
180   case PCRE2_INFO_HEAPLIMIT:
181   *((uint32_t *)where) = re->limit_heap;
182   if (re->limit_heap == UINT32_MAX) return PCRE2_ERROR_UNSET;
183   break;
184
185   case PCRE2_INFO_JCHANGED:
186   *((uint32_t *)where) = (re->flags & PCRE2_JCHANGED) != 0;
187   break;
188
189   case PCRE2_INFO_JITSIZE:
190 #ifdef SUPPORT_JIT
191   *((size_t *)where) = (re->executable_jit != NULL)?
192     PRIV(jit_get_size)(re->executable_jit) : 0;
193 #else
194   *((size_t *)where) = 0;
195 #endif
196   break;
197
198   case PCRE2_INFO_LASTCODETYPE:
199   *((uint32_t *)where) = ((re->flags & PCRE2_LASTSET) != 0)? 1 : 0;
200   break;
201
202   case PCRE2_INFO_LASTCODEUNIT:
203   *((uint32_t *)where) = ((re->flags & PCRE2_LASTSET) != 0)?
204     re->last_codeunit : 0;
205   break;
206
207   case PCRE2_INFO_MATCHEMPTY:
208   *((uint32_t *)where) = (re->flags & PCRE2_MATCH_EMPTY) != 0;
209   break;
210
211   case PCRE2_INFO_MATCHLIMIT:
212   *((uint32_t *)where) = re->limit_match;
213   if (re->limit_match == UINT32_MAX) return PCRE2_ERROR_UNSET;
214   break;
215
216   case PCRE2_INFO_MAXLOOKBEHIND:
217   *((uint32_t *)where) = re->max_lookbehind;
218   break;
219
220   case PCRE2_INFO_MINLENGTH:
221   *((uint32_t *)where) = re->minlength;
222   break;
223
224   case PCRE2_INFO_NAMEENTRYSIZE:
225   *((uint32_t *)where) = re->name_entry_size;
226   break;
227
228   case PCRE2_INFO_NAMECOUNT:
229   *((uint32_t *)where) = re->name_count;
230   break;
231
232   case PCRE2_INFO_NAMETABLE:
233   *((PCRE2_SPTR *)where) = (PCRE2_SPTR)((char *)re + sizeof(pcre2_real_code));
234   break;
235
236   case PCRE2_INFO_NEWLINE:
237   *((uint32_t *)where) = re->newline_convention;
238   break;
239
240   case PCRE2_INFO_SIZE:
241   *((size_t *)where) = re->blocksize;
242   break;
243
244   default: return PCRE2_ERROR_BADOPTION;
245   }
246
247 return 0;
248 }
249
250
251
252 /*************************************************
253 *              Callout enumerator                *
254 *************************************************/
255
256 /*
257 Arguments:
258   code          points to compiled code
259   callback      function called for each callout block
260   callout_data  user data passed to the callback
261
262 Returns:        0 when successfully completed
263                 < 0 on local error
264                != 0 for callback error
265 */
266
267 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
268 pcre2_callout_enumerate(const pcre2_code *code,
269   int (*callback)(pcre2_callout_enumerate_block *, void *), void *callout_data)
270 {
271 pcre2_real_code *re = (pcre2_real_code *)code;
272 pcre2_callout_enumerate_block cb;
273 PCRE2_SPTR cc;
274 #ifdef SUPPORT_UNICODE
275 BOOL utf;
276 #endif
277
278 if (re == NULL) return PCRE2_ERROR_NULL;
279
280 #ifdef SUPPORT_UNICODE
281 utf = (re->overall_options & PCRE2_UTF) != 0;
282 #endif
283
284 /* Check that the first field in the block is the magic number. If it is not,
285 return with PCRE2_ERROR_BADMAGIC. */
286
287 if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC;
288
289 /* Check that this pattern was compiled in the correct bit mode */
290
291 if ((re->flags & (PCRE2_CODE_UNIT_WIDTH/8)) == 0) return PCRE2_ERROR_BADMODE;
292
293 cb.version = 0;
294 cc = (PCRE2_SPTR)((uint8_t *)re + sizeof(pcre2_real_code))
295      + re->name_count * re->name_entry_size;
296
297 while (TRUE)
298   {
299   int rc;
300   switch (*cc)
301     {
302     case OP_END:
303     return 0;
304
305     case OP_CHAR:
306     case OP_CHARI:
307     case OP_NOT:
308     case OP_NOTI:
309     case OP_STAR:
310     case OP_MINSTAR:
311     case OP_PLUS:
312     case OP_MINPLUS:
313     case OP_QUERY:
314     case OP_MINQUERY:
315     case OP_UPTO:
316     case OP_MINUPTO:
317     case OP_EXACT:
318     case OP_POSSTAR:
319     case OP_POSPLUS:
320     case OP_POSQUERY:
321     case OP_POSUPTO:
322     case OP_STARI:
323     case OP_MINSTARI:
324     case OP_PLUSI:
325     case OP_MINPLUSI:
326     case OP_QUERYI:
327     case OP_MINQUERYI:
328     case OP_UPTOI:
329     case OP_MINUPTOI:
330     case OP_EXACTI:
331     case OP_POSSTARI:
332     case OP_POSPLUSI:
333     case OP_POSQUERYI:
334     case OP_POSUPTOI:
335     case OP_NOTSTAR:
336     case OP_NOTMINSTAR:
337     case OP_NOTPLUS:
338     case OP_NOTMINPLUS:
339     case OP_NOTQUERY:
340     case OP_NOTMINQUERY:
341     case OP_NOTUPTO:
342     case OP_NOTMINUPTO:
343     case OP_NOTEXACT:
344     case OP_NOTPOSSTAR:
345     case OP_NOTPOSPLUS:
346     case OP_NOTPOSQUERY:
347     case OP_NOTPOSUPTO:
348     case OP_NOTSTARI:
349     case OP_NOTMINSTARI:
350     case OP_NOTPLUSI:
351     case OP_NOTMINPLUSI:
352     case OP_NOTQUERYI:
353     case OP_NOTMINQUERYI:
354     case OP_NOTUPTOI:
355     case OP_NOTMINUPTOI:
356     case OP_NOTEXACTI:
357     case OP_NOTPOSSTARI:
358     case OP_NOTPOSPLUSI:
359     case OP_NOTPOSQUERYI:
360     case OP_NOTPOSUPTOI:
361     cc += PRIV(OP_lengths)[*cc];
362 #ifdef SUPPORT_UNICODE
363     if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
364 #endif
365     break;
366
367     case OP_TYPESTAR:
368     case OP_TYPEMINSTAR:
369     case OP_TYPEPLUS:
370     case OP_TYPEMINPLUS:
371     case OP_TYPEQUERY:
372     case OP_TYPEMINQUERY:
373     case OP_TYPEUPTO:
374     case OP_TYPEMINUPTO:
375     case OP_TYPEEXACT:
376     case OP_TYPEPOSSTAR:
377     case OP_TYPEPOSPLUS:
378     case OP_TYPEPOSQUERY:
379     case OP_TYPEPOSUPTO:
380     cc += PRIV(OP_lengths)[*cc];
381 #ifdef SUPPORT_UNICODE
382     if (cc[-1] == OP_PROP || cc[-1] == OP_NOTPROP) cc += 2;
383 #endif
384     break;
385
386 #if defined SUPPORT_UNICODE || PCRE2_CODE_UNIT_WIDTH != 8
387     case OP_XCLASS:
388     cc += GET(cc, 1);
389     break;
390 #endif
391
392     case OP_MARK:
393     case OP_COMMIT_ARG:
394     case OP_PRUNE_ARG:
395     case OP_SKIP_ARG:
396     case OP_THEN_ARG:
397     cc += PRIV(OP_lengths)[*cc] + cc[1];
398     break;
399
400     case OP_CALLOUT:
401     cb.pattern_position = GET(cc, 1);
402     cb.next_item_length = GET(cc, 1 + LINK_SIZE);
403     cb.callout_number = cc[1 + 2*LINK_SIZE];
404     cb.callout_string_offset = 0;
405     cb.callout_string_length = 0;
406     cb.callout_string = NULL;
407     rc = callback(&cb, callout_data);
408     if (rc != 0) return rc;
409     cc += PRIV(OP_lengths)[*cc];
410     break;
411
412     case OP_CALLOUT_STR:
413     cb.pattern_position = GET(cc, 1);
414     cb.next_item_length = GET(cc, 1 + LINK_SIZE);
415     cb.callout_number = 0;
416     cb.callout_string_offset = GET(cc, 1 + 3*LINK_SIZE);
417     cb.callout_string_length =
418       GET(cc, 1 + 2*LINK_SIZE) - (1 + 4*LINK_SIZE) - 2;
419     cb.callout_string = cc + (1 + 4*LINK_SIZE) + 1;
420     rc = callback(&cb, callout_data);
421     if (rc != 0) return rc;
422     cc += GET(cc, 1 + 2*LINK_SIZE);
423     break;
424
425     default:
426     cc += PRIV(OP_lengths)[*cc];
427     break;
428     }
429   }
430 }
431
432 /* End of pcre2_pattern_info.c */