• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
default_malloc(size_t size,void * data)56 static void *default_malloc(size_t size, void *data)
57 {
58 (void)data;
59 return malloc(size);
60 }
61 
62 
default_free(void * block,void * data)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 *
PRIV(memctl_malloc)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
pcre2_general_context_create(void * (* private_malloc)(size_t,void *),void (* private_free)(void *,void *),void * memory_data)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
pcre2_compile_context_create(pcre2_general_context * gcontext)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
pcre2_match_context_create(pcre2_general_context * gcontext)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
pcre2_convert_context_create(pcre2_general_context * gcontext)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
pcre2_general_context_copy(pcre2_general_context * gcontext)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
pcre2_compile_context_copy(pcre2_compile_context * ccontext)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
pcre2_match_context_copy(pcre2_match_context * mcontext)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
pcre2_convert_context_copy(pcre2_convert_context * ccontext)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
pcre2_general_context_free(pcre2_general_context * gcontext)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
pcre2_compile_context_free(pcre2_compile_context * ccontext)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
pcre2_match_context_free(pcre2_match_context * mcontext)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
pcre2_convert_context_free(pcre2_convert_context * ccontext)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
pcre2_set_character_tables(pcre2_compile_context * ccontext,const unsigned char * tables)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
pcre2_set_bsr(pcre2_compile_context * ccontext,uint32_t value)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
pcre2_set_max_pattern_length(pcre2_compile_context * ccontext,PCRE2_SIZE length)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
pcre2_set_newline(pcre2_compile_context * ccontext,uint32_t newline)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
pcre2_set_parens_nest_limit(pcre2_compile_context * ccontext,uint32_t limit)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
pcre2_set_compile_extra_options(pcre2_compile_context * ccontext,uint32_t options)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
pcre2_set_compile_recursion_guard(pcre2_compile_context * ccontext,int (* guard)(uint32_t,void *),void * user_data)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
pcre2_set_callout(pcre2_match_context * mcontext,int (* callout)(pcre2_callout_block *,void *),void * callout_data)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
pcre2_set_heap_limit(pcre2_match_context * mcontext,uint32_t limit)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
pcre2_set_match_limit(pcre2_match_context * mcontext,uint32_t limit)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
pcre2_set_depth_limit(pcre2_match_context * mcontext,uint32_t limit)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
pcre2_set_offset_limit(pcre2_match_context * mcontext,PCRE2_SIZE limit)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
pcre2_set_recursion_limit(pcre2_match_context * mcontext,uint32_t limit)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
pcre2_set_recursion_memory_management(pcre2_match_context * mcontext,void * (* mymalloc)(size_t,void *),void (* myfree)(void *,void *),void * mydata)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
pcre2_set_glob_separator(pcre2_convert_context * ccontext,uint32_t separator)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
pcre2_set_glob_escape(pcre2_convert_context * ccontext,uint32_t escape)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 
477