2c14df00805bf044c2b9593a82e3bc87c755dc92
[ossec-hids.git] / pcre2_context.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-2017 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 *          Default malloc/free functions         *
52 *************************************************/
53
54 /* Ignore the "user data" argument in each case. */
55
56 static void *default_malloc(size_t size, void *data)
57 {
58 (void)data;
59 return malloc(size);
60 }
61
62
63 static void default_free(void *block, void *data)
64 {
65 (void)data;
66 free(block);
67 }
68
69
70
71 /*************************************************
72 *        Get a block and save memory control     *
73 *************************************************/
74
75 /* This internal function is called to get a block of memory in which the
76 memory control data is to be stored at the start for future use.
77
78 Arguments:
79   size        amount of memory required
80   memctl      pointer to a memctl block or NULL
81
82 Returns:      pointer to memory or NULL on failure
83 */
84
85 extern void *
86 PRIV(memctl_malloc)(size_t size, pcre2_memctl *memctl)
87 {
88 pcre2_memctl *newmemctl;
89 void *yield = (memctl == NULL)? malloc(size) :
90   memctl->malloc(size, memctl->memory_data);
91 if (yield == NULL) return NULL;
92 newmemctl = (pcre2_memctl *)yield;
93 if (memctl == NULL)
94   {
95   newmemctl->malloc = default_malloc;
96   newmemctl->free = default_free;
97   newmemctl->memory_data = NULL;
98   }
99 else *newmemctl = *memctl;
100 return yield;
101 }
102
103
104
105 /*************************************************
106 *          Create and initialize contexts        *
107 *************************************************/
108
109 /* Initializing for compile and match contexts is done in separate, private
110 functions so that these can be called from functions such as pcre2_compile()
111 when an external context is not supplied. The initializing functions have an
112 option to set up default memory management. */
113
114 PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
115 pcre2_general_context_create(void *(*private_malloc)(size_t, void *),
116   void (*private_free)(void *, void *), void *memory_data)
117 {
118 pcre2_general_context *gcontext;
119 if (private_malloc == NULL) private_malloc = default_malloc;
120 if (private_free == NULL) private_free = default_free;
121 gcontext = private_malloc(sizeof(pcre2_real_general_context), memory_data);
122 if (gcontext == NULL) return NULL;
123 gcontext->memctl.malloc = private_malloc;
124 gcontext->memctl.free = private_free;
125 gcontext->memctl.memory_data = memory_data;
126 return gcontext;
127 }
128
129
130 /* A default compile context is set up to save having to initialize at run time
131 when no context is supplied to the compile function. */
132
133 const pcre2_compile_context PRIV(default_compile_context) = {
134   { default_malloc, default_free, NULL },    /* Default memory handling */
135   NULL,                                      /* Stack guard */
136   NULL,                                      /* Stack guard data */
137   PRIV(default_tables),                      /* Character tables */
138   PCRE2_UNSET,                               /* Max pattern length */
139   BSR_DEFAULT,                               /* Backslash R default */
140   NEWLINE_DEFAULT,                           /* Newline convention */
141   PARENS_NEST_LIMIT,                         /* As it says */
142   0 };                                       /* Extra options */
143
144 /* The create function copies the default into the new memory, but must
145 override the default memory handling functions if a gcontext was provided. */
146
147 PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
148 pcre2_compile_context_create(pcre2_general_context *gcontext)
149 {
150 pcre2_compile_context *ccontext = PRIV(memctl_malloc)(
151   sizeof(pcre2_real_compile_context), (pcre2_memctl *)gcontext);
152 if (ccontext == NULL) return NULL;
153 *ccontext = PRIV(default_compile_context);
154 if (gcontext != NULL)
155   *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
156 return ccontext;
157 }
158
159
160 /* A default match context is set up to save having to initialize at run time
161 when no context is supplied to a match function. */
162
163 const pcre2_match_context PRIV(default_match_context) = {
164   { default_malloc, default_free, NULL },
165 #ifdef SUPPORT_JIT
166   NULL,
167   NULL,
168 #endif
169   NULL,
170   NULL,
171   PCRE2_UNSET,   /* Offset limit */
172   HEAP_LIMIT,
173   MATCH_LIMIT,
174   MATCH_LIMIT_DEPTH };
175
176 /* The create function copies the default into the new memory, but must
177 override the default memory handling functions if a gcontext was provided. */
178
179 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
180 pcre2_match_context_create(pcre2_general_context *gcontext)
181 {
182 pcre2_match_context *mcontext = PRIV(memctl_malloc)(
183   sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
184 if (mcontext == NULL) return NULL;
185 *mcontext = PRIV(default_match_context);
186 if (gcontext != NULL)
187   *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext);
188 return mcontext;
189 }
190
191
192 /* A default convert context is set up to save having to initialize at run time
193 when no context is supplied to the convert function. */
194
195 const pcre2_convert_context PRIV(default_convert_context) = {
196   { default_malloc, default_free, NULL },    /* Default memory handling */
197 #ifdef _WIN32
198   CHAR_BACKSLASH,                            /* Default path separator */
199   CHAR_GRAVE_ACCENT                          /* Default escape character */
200 #else  /* Not Windows */
201   CHAR_SLASH,                                /* Default path separator */
202   CHAR_BACKSLASH                             /* Default escape character */
203 #endif
204   };
205
206 /* The create function copies the default into the new memory, but must
207 override the default memory handling functions if a gcontext was provided. */
208
209 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
210 pcre2_convert_context_create(pcre2_general_context *gcontext)
211 {
212 pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
213   sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
214 if (ccontext == NULL) return NULL;
215 *ccontext = PRIV(default_convert_context);
216 if (gcontext != NULL)
217   *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
218 return ccontext;
219 }
220
221
222 /*************************************************
223 *              Context copy functions            *
224 *************************************************/
225
226 PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
227 pcre2_general_context_copy(pcre2_general_context *gcontext)
228 {
229 pcre2_general_context *new =
230   gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
231   gcontext->memctl.memory_data);
232 if (new == NULL) return NULL;
233 memcpy(new, gcontext, sizeof(pcre2_real_general_context));
234 return new;
235 }
236
237
238 PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
239 pcre2_compile_context_copy(pcre2_compile_context *ccontext)
240 {
241 pcre2_compile_context *new =
242   ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
243   ccontext->memctl.memory_data);
244 if (new == NULL) return NULL;
245 memcpy(new, ccontext, sizeof(pcre2_real_compile_context));
246 return new;
247 }
248
249
250 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
251 pcre2_match_context_copy(pcre2_match_context *mcontext)
252 {
253 pcre2_match_context *new =
254   mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
255   mcontext->memctl.memory_data);
256 if (new == NULL) return NULL;
257 memcpy(new, mcontext, sizeof(pcre2_real_match_context));
258 return new;
259 }
260
261
262
263 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
264 pcre2_convert_context_copy(pcre2_convert_context *ccontext)
265 {
266 pcre2_convert_context *new =
267   ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
268   ccontext->memctl.memory_data);
269 if (new == NULL) return NULL;
270 memcpy(new, ccontext, sizeof(pcre2_real_convert_context));
271 return new;
272 }
273
274
275 /*************************************************
276 *              Context free functions            *
277 *************************************************/
278
279 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
280 pcre2_general_context_free(pcre2_general_context *gcontext)
281 {
282 if (gcontext != NULL)
283   gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
284 }
285
286
287 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
288 pcre2_compile_context_free(pcre2_compile_context *ccontext)
289 {
290 if (ccontext != NULL)
291   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
292 }
293
294
295 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
296 pcre2_match_context_free(pcre2_match_context *mcontext)
297 {
298 if (mcontext != NULL)
299   mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
300 }
301
302
303 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
304 pcre2_convert_context_free(pcre2_convert_context *ccontext)
305 {
306 if (ccontext != NULL)
307   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
308 }
309
310
311 /*************************************************
312 *             Set values in contexts             *
313 *************************************************/
314
315 /* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
316 data is given. Only some of the functions are able to test the validity of the
317 data. */
318
319
320 /* ------------ Compile context ------------ */
321
322 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
323 pcre2_set_character_tables(pcre2_compile_context *ccontext,
324   const unsigned char *tables)
325 {
326 ccontext->tables = tables;
327 return 0;
328 }
329
330 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
331 pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
332 {
333 switch(value)
334   {
335   case PCRE2_BSR_ANYCRLF:
336   case PCRE2_BSR_UNICODE:
337   ccontext->bsr_convention = value;
338   return 0;
339
340   default:
341   return PCRE2_ERROR_BADDATA;
342   }
343 }
344
345 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
346 pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
347 {
348 ccontext->max_pattern_length = length;
349 return 0;
350 }
351
352 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
353 pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
354 {
355 switch(newline)
356   {
357   case PCRE2_NEWLINE_CR:
358   case PCRE2_NEWLINE_LF:
359   case PCRE2_NEWLINE_CRLF:
360   case PCRE2_NEWLINE_ANY:
361   case PCRE2_NEWLINE_ANYCRLF:
362   case PCRE2_NEWLINE_NUL:
363   ccontext->newline_convention = newline;
364   return 0;
365
366   default:
367   return PCRE2_ERROR_BADDATA;
368   }
369 }
370
371 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
372 pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
373 {
374 ccontext->parens_nest_limit = limit;
375 return 0;
376 }
377
378 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
379 pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
380 {
381 ccontext->extra_options = options;
382 return 0;
383 }
384
385 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
386 pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
387   int (*guard)(uint32_t, void *), void *user_data)
388 {
389 ccontext->stack_guard = guard;
390 ccontext->stack_guard_data = user_data;
391 return 0;
392 }
393
394
395 /* ------------ Match context ------------ */
396
397 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
398 pcre2_set_callout(pcre2_match_context *mcontext,
399   int (*callout)(pcre2_callout_block *, void *), void *callout_data)
400 {
401 mcontext->callout = callout;
402 mcontext->callout_data = callout_data;
403 return 0;
404 }
405
406 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
407 pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
408 {
409 mcontext->heap_limit = limit;
410 return 0;
411 }
412
413 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
414 pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
415 {
416 mcontext->match_limit = limit;
417 return 0;
418 }
419
420 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
421 pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
422 {
423 mcontext->depth_limit = limit;
424 return 0;
425 }
426
427 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
428 pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
429 {
430 mcontext->offset_limit = limit;
431 return 0;
432 }
433
434 /* This function became obsolete at release 10.30. It is kept as a synonym for
435 backwards compatibility. */
436
437 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
438 pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
439 {
440 return pcre2_set_depth_limit(mcontext, limit);
441 }
442
443 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
444 pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
445   void *(*mymalloc)(size_t, void *), void (*myfree)(void *, void *),
446   void *mydata)
447 {
448 (void)mcontext;
449 (void)mymalloc;
450 (void)myfree;
451 (void)mydata;
452 return 0;
453 }
454
455 /* ------------ Convert context ------------ */
456
457 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
458 pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
459 {
460 if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
461     separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
462 ccontext->glob_separator = separator;
463 return 0;
464 }
465
466 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
467 pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
468 {
469 if (escape > 255 || (escape != 0 && !ispunct(escape)))
470   return PCRE2_ERROR_BADDATA;
471 ccontext->glob_escape = escape;
472 return 0;
473 }
474
475 /* End of pcre2_context.c */
476