xref: /PHP-8.3/ext/pcre/pcre2lib/pcre2_context.c (revision c4e8f652)
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-2022 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,          /* JIT callback */
167   NULL,          /* JIT callback data */
168 #endif
169   NULL,          /* Callout function */
170   NULL,          /* Callout data */
171   NULL,          /* Substitute callout function */
172   NULL,          /* Substitute callout data */
173   PCRE2_UNSET,   /* Offset limit */
174   HEAP_LIMIT,
175   MATCH_LIMIT,
176   MATCH_LIMIT_DEPTH };
177 
178 /* The create function copies the default into the new memory, but must
179 override the default memory handling functions if a gcontext was provided. */
180 
181 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_create(pcre2_general_context * gcontext)182 pcre2_match_context_create(pcre2_general_context *gcontext)
183 {
184 pcre2_match_context *mcontext = PRIV(memctl_malloc)(
185   sizeof(pcre2_real_match_context), (pcre2_memctl *)gcontext);
186 if (mcontext == NULL) return NULL;
187 *mcontext = PRIV(default_match_context);
188 if (gcontext != NULL)
189   *((pcre2_memctl *)mcontext) = *((pcre2_memctl *)gcontext);
190 return mcontext;
191 }
192 
193 
194 /* A default convert context is set up to save having to initialize at run time
195 when no context is supplied to the convert function. */
196 
197 const pcre2_convert_context PRIV(default_convert_context) = {
198   { default_malloc, default_free, NULL },    /* Default memory handling */
199 #ifdef _WIN32
200   CHAR_BACKSLASH,                            /* Default path separator */
201   CHAR_GRAVE_ACCENT                          /* Default escape character */
202 #else  /* Not Windows */
203   CHAR_SLASH,                                /* Default path separator */
204   CHAR_BACKSLASH                             /* Default escape character */
205 #endif
206   };
207 
208 /* The create function copies the default into the new memory, but must
209 override the default memory handling functions if a gcontext was provided. */
210 
211 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_create(pcre2_general_context * gcontext)212 pcre2_convert_context_create(pcre2_general_context *gcontext)
213 {
214 pcre2_convert_context *ccontext = PRIV(memctl_malloc)(
215   sizeof(pcre2_real_convert_context), (pcre2_memctl *)gcontext);
216 if (ccontext == NULL) return NULL;
217 *ccontext = PRIV(default_convert_context);
218 if (gcontext != NULL)
219   *((pcre2_memctl *)ccontext) = *((pcre2_memctl *)gcontext);
220 return ccontext;
221 }
222 
223 
224 /*************************************************
225 *              Context copy functions            *
226 *************************************************/
227 
228 PCRE2_EXP_DEFN pcre2_general_context * PCRE2_CALL_CONVENTION
pcre2_general_context_copy(pcre2_general_context * gcontext)229 pcre2_general_context_copy(pcre2_general_context *gcontext)
230 {
231 pcre2_general_context *new =
232   gcontext->memctl.malloc(sizeof(pcre2_real_general_context),
233   gcontext->memctl.memory_data);
234 if (new == NULL) return NULL;
235 memcpy(new, gcontext, sizeof(pcre2_real_general_context));
236 return new;
237 }
238 
239 
240 PCRE2_EXP_DEFN pcre2_compile_context * PCRE2_CALL_CONVENTION
pcre2_compile_context_copy(pcre2_compile_context * ccontext)241 pcre2_compile_context_copy(pcre2_compile_context *ccontext)
242 {
243 pcre2_compile_context *new =
244   ccontext->memctl.malloc(sizeof(pcre2_real_compile_context),
245   ccontext->memctl.memory_data);
246 if (new == NULL) return NULL;
247 memcpy(new, ccontext, sizeof(pcre2_real_compile_context));
248 return new;
249 }
250 
251 
252 PCRE2_EXP_DEFN pcre2_match_context * PCRE2_CALL_CONVENTION
pcre2_match_context_copy(pcre2_match_context * mcontext)253 pcre2_match_context_copy(pcre2_match_context *mcontext)
254 {
255 pcre2_match_context *new =
256   mcontext->memctl.malloc(sizeof(pcre2_real_match_context),
257   mcontext->memctl.memory_data);
258 if (new == NULL) return NULL;
259 memcpy(new, mcontext, sizeof(pcre2_real_match_context));
260 return new;
261 }
262 
263 
264 
265 PCRE2_EXP_DEFN pcre2_convert_context * PCRE2_CALL_CONVENTION
pcre2_convert_context_copy(pcre2_convert_context * ccontext)266 pcre2_convert_context_copy(pcre2_convert_context *ccontext)
267 {
268 pcre2_convert_context *new =
269   ccontext->memctl.malloc(sizeof(pcre2_real_convert_context),
270   ccontext->memctl.memory_data);
271 if (new == NULL) return NULL;
272 memcpy(new, ccontext, sizeof(pcre2_real_convert_context));
273 return new;
274 }
275 
276 
277 /*************************************************
278 *              Context free functions            *
279 *************************************************/
280 
281 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_general_context_free(pcre2_general_context * gcontext)282 pcre2_general_context_free(pcre2_general_context *gcontext)
283 {
284 if (gcontext != NULL)
285   gcontext->memctl.free(gcontext, gcontext->memctl.memory_data);
286 }
287 
288 
289 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_compile_context_free(pcre2_compile_context * ccontext)290 pcre2_compile_context_free(pcre2_compile_context *ccontext)
291 {
292 if (ccontext != NULL)
293   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
294 }
295 
296 
297 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_match_context_free(pcre2_match_context * mcontext)298 pcre2_match_context_free(pcre2_match_context *mcontext)
299 {
300 if (mcontext != NULL)
301   mcontext->memctl.free(mcontext, mcontext->memctl.memory_data);
302 }
303 
304 
305 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_convert_context_free(pcre2_convert_context * ccontext)306 pcre2_convert_context_free(pcre2_convert_context *ccontext)
307 {
308 if (ccontext != NULL)
309   ccontext->memctl.free(ccontext, ccontext->memctl.memory_data);
310 }
311 
312 
313 /*************************************************
314 *             Set values in contexts             *
315 *************************************************/
316 
317 /* All these functions return 0 for success or PCRE2_ERROR_BADDATA if invalid
318 data is given. Only some of the functions are able to test the validity of the
319 data. */
320 
321 
322 /* ------------ Compile context ------------ */
323 
324 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_character_tables(pcre2_compile_context * ccontext,const uint8_t * tables)325 pcre2_set_character_tables(pcre2_compile_context *ccontext,
326   const uint8_t *tables)
327 {
328 ccontext->tables = tables;
329 return 0;
330 }
331 
332 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_bsr(pcre2_compile_context * ccontext,uint32_t value)333 pcre2_set_bsr(pcre2_compile_context *ccontext, uint32_t value)
334 {
335 switch(value)
336   {
337   case PCRE2_BSR_ANYCRLF:
338   case PCRE2_BSR_UNICODE:
339   ccontext->bsr_convention = value;
340   return 0;
341 
342   default:
343   return PCRE2_ERROR_BADDATA;
344   }
345 }
346 
347 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_max_pattern_length(pcre2_compile_context * ccontext,PCRE2_SIZE length)348 pcre2_set_max_pattern_length(pcre2_compile_context *ccontext, PCRE2_SIZE length)
349 {
350 ccontext->max_pattern_length = length;
351 return 0;
352 }
353 
354 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_newline(pcre2_compile_context * ccontext,uint32_t newline)355 pcre2_set_newline(pcre2_compile_context *ccontext, uint32_t newline)
356 {
357 switch(newline)
358   {
359   case PCRE2_NEWLINE_CR:
360   case PCRE2_NEWLINE_LF:
361   case PCRE2_NEWLINE_CRLF:
362   case PCRE2_NEWLINE_ANY:
363   case PCRE2_NEWLINE_ANYCRLF:
364   case PCRE2_NEWLINE_NUL:
365   ccontext->newline_convention = newline;
366   return 0;
367 
368   default:
369   return PCRE2_ERROR_BADDATA;
370   }
371 }
372 
373 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_parens_nest_limit(pcre2_compile_context * ccontext,uint32_t limit)374 pcre2_set_parens_nest_limit(pcre2_compile_context *ccontext, uint32_t limit)
375 {
376 ccontext->parens_nest_limit = limit;
377 return 0;
378 }
379 
380 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_extra_options(pcre2_compile_context * ccontext,uint32_t options)381 pcre2_set_compile_extra_options(pcre2_compile_context *ccontext, uint32_t options)
382 {
383 ccontext->extra_options = options;
384 return 0;
385 }
386 
387 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_compile_recursion_guard(pcre2_compile_context * ccontext,int (* guard)(uint32_t,void *),void * user_data)388 pcre2_set_compile_recursion_guard(pcre2_compile_context *ccontext,
389   int (*guard)(uint32_t, void *), void *user_data)
390 {
391 ccontext->stack_guard = guard;
392 ccontext->stack_guard_data = user_data;
393 return 0;
394 }
395 
396 
397 /* ------------ Match context ------------ */
398 
399 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_callout(pcre2_match_context * mcontext,int (* callout)(pcre2_callout_block *,void *),void * callout_data)400 pcre2_set_callout(pcre2_match_context *mcontext,
401   int (*callout)(pcre2_callout_block *, void *), void *callout_data)
402 {
403 mcontext->callout = callout;
404 mcontext->callout_data = callout_data;
405 return 0;
406 }
407 
408 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_substitute_callout(pcre2_match_context * mcontext,int (* substitute_callout)(pcre2_substitute_callout_block *,void *),void * substitute_callout_data)409 pcre2_set_substitute_callout(pcre2_match_context *mcontext,
410   int (*substitute_callout)(pcre2_substitute_callout_block *, void *),
411     void *substitute_callout_data)
412 {
413 mcontext->substitute_callout = substitute_callout;
414 mcontext->substitute_callout_data = substitute_callout_data;
415 return 0;
416 }
417 
418 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_heap_limit(pcre2_match_context * mcontext,uint32_t limit)419 pcre2_set_heap_limit(pcre2_match_context *mcontext, uint32_t limit)
420 {
421 mcontext->heap_limit = limit;
422 return 0;
423 }
424 
425 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_match_limit(pcre2_match_context * mcontext,uint32_t limit)426 pcre2_set_match_limit(pcre2_match_context *mcontext, uint32_t limit)
427 {
428 mcontext->match_limit = limit;
429 return 0;
430 }
431 
432 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_depth_limit(pcre2_match_context * mcontext,uint32_t limit)433 pcre2_set_depth_limit(pcre2_match_context *mcontext, uint32_t limit)
434 {
435 mcontext->depth_limit = limit;
436 return 0;
437 }
438 
439 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_offset_limit(pcre2_match_context * mcontext,PCRE2_SIZE limit)440 pcre2_set_offset_limit(pcre2_match_context *mcontext, PCRE2_SIZE limit)
441 {
442 mcontext->offset_limit = limit;
443 return 0;
444 }
445 
446 /* These functions became obsolete at release 10.30. The first is kept as a
447 synonym for backwards compatibility. The second now does nothing. Exclude both
448 from coverage reports. */
449 
450 /* LCOV_EXCL_START */
451 
452 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_recursion_limit(pcre2_match_context * mcontext,uint32_t limit)453 pcre2_set_recursion_limit(pcre2_match_context *mcontext, uint32_t limit)
454 {
455 return pcre2_set_depth_limit(mcontext, limit);
456 }
457 
458 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)459 pcre2_set_recursion_memory_management(pcre2_match_context *mcontext,
460   void *(*mymalloc)(size_t, void *), void (*myfree)(void *, void *),
461   void *mydata)
462 {
463 (void)mcontext;
464 (void)mymalloc;
465 (void)myfree;
466 (void)mydata;
467 return 0;
468 }
469 
470 /* LCOV_EXCL_STOP */
471 
472 
473 /* ------------ Convert context ------------ */
474 
475 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_separator(pcre2_convert_context * ccontext,uint32_t separator)476 pcre2_set_glob_separator(pcre2_convert_context *ccontext, uint32_t separator)
477 {
478 if (separator != CHAR_SLASH && separator != CHAR_BACKSLASH &&
479     separator != CHAR_DOT) return PCRE2_ERROR_BADDATA;
480 ccontext->glob_separator = separator;
481 return 0;
482 }
483 
484 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_set_glob_escape(pcre2_convert_context * ccontext,uint32_t escape)485 pcre2_set_glob_escape(pcre2_convert_context *ccontext, uint32_t escape)
486 {
487 if (escape > 255 || (escape != 0 && !ispunct(escape)))
488   return PCRE2_ERROR_BADDATA;
489 ccontext->glob_escape = escape;
490 return 0;
491 }
492 
493 /* End of pcre2_context.c */
494 
495