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 477
