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 Copyright (c) 1997-2008 University of Cambridge 10 11 ----------------------------------------------------------------------------- 12 Redistribution and use in source and binary forms, with or without 13 modification, are permitted provided that the following conditions are met: 14 15 * Redistributions of source code must retain the above copyright notice, 16 this list of conditions and the following disclaimer. 17 18 * Redistributions in binary form must reproduce the above copyright 19 notice, this list of conditions and the following disclaimer in the 20 documentation and/or other materials provided with the distribution. 21 22 * Neither the name of the University of Cambridge nor the names of its 23 contributors may be used to endorse or promote products derived from 24 this software without specific prior written permission. 25 26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 POSSIBILITY OF SUCH DAMAGE. 37 ----------------------------------------------------------------------------- 38 */ 39 40 41 /* This module contains some convenience functions for extracting substrings 42 from the subject string after a regex match has succeeded. The original idea 43 for these functions came from Scott Wimer. */ 44 45 46 #ifdef HAVE_CONFIG_H 47 #include "config.h" 48 #endif 49 50 #include "pcre_internal.h" 51 52 53 /************************************************* 54 * Find number for named string * 55 *************************************************/ 56 57 /* This function is used by the get_first_set() function below, as well 58 as being generally available. It assumes that names are unique. 59 60 Arguments: 61 code the compiled regex 62 stringname the name whose number is required 63 64 Returns: the number of the named parentheses, or a negative number 65 (PCRE_ERROR_NOSUBSTRING) if not found 66 */ 67 68 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 69 pcre_get_stringnumber(const pcre *code, const char *stringname) 70 { 71 int rc; 72 int entrysize; 73 int top, bot; 74 uschar *nametable; 75 76 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0) 77 return rc; 78 if (top <= 0) return PCRE_ERROR_NOSUBSTRING; 79 80 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0) 81 return rc; 82 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0) 83 return rc; 84 85 bot = 0; 86 while (top > bot) 87 { 88 int mid = (top + bot) / 2; 89 uschar *entry = nametable + entrysize*mid; 90 int c = strcmp(stringname, (char *)(entry + 2)); 91 if (c == 0) return (entry[0] << 8) + entry[1]; 92 if (c > 0) bot = mid + 1; else top = mid; 93 } 94 95 return PCRE_ERROR_NOSUBSTRING; 96 } 97 98 99 100 /************************************************* 101 * Find (multiple) entries for named string * 102 *************************************************/ 103 104 /* This is used by the get_first_set() function below, as well as being 105 generally available. It is used when duplicated names are permitted. 106 107 Arguments: 108 code the compiled regex 109 stringname the name whose entries required 110 firstptr where to put the pointer to the first entry 111 lastptr where to put the pointer to the last entry 112 113 Returns: the length of each entry, or a negative number 114 (PCRE_ERROR_NOSUBSTRING) if not found 115 */ 116 117 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 118 pcre_get_stringtable_entries(const pcre *code, const char *stringname, 119 char **firstptr, char **lastptr) 120 { 121 int rc; 122 int entrysize; 123 int top, bot; 124 uschar *nametable, *lastentry; 125 126 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0) 127 return rc; 128 if (top <= 0) return PCRE_ERROR_NOSUBSTRING; 129 130 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0) 131 return rc; 132 if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0) 133 return rc; 134 135 lastentry = nametable + entrysize * (top - 1); 136 bot = 0; 137 while (top > bot) 138 { 139 int mid = (top + bot) / 2; 140 uschar *entry = nametable + entrysize*mid; 141 int c = strcmp(stringname, (char *)(entry + 2)); 142 if (c == 0) 143 { 144 uschar *first = entry; 145 uschar *last = entry; 146 while (first > nametable) 147 { 148 if (strcmp(stringname, (char *)(first - entrysize + 2)) != 0) break; 149 first -= entrysize; 150 } 151 while (last < lastentry) 152 { 153 if (strcmp(stringname, (char *)(last + entrysize + 2)) != 0) break; 154 last += entrysize; 155 } 156 *firstptr = (char *)first; 157 *lastptr = (char *)last; 158 return entrysize; 159 } 160 if (c > 0) bot = mid + 1; else top = mid; 161 } 162 163 return PCRE_ERROR_NOSUBSTRING; 164 } 165 166 167 168 /************************************************* 169 * Find first set of multiple named strings * 170 *************************************************/ 171 172 /* This function allows for duplicate names in the table of named substrings. 173 It returns the number of the first one that was set in a pattern match. 174 175 Arguments: 176 code the compiled regex 177 stringname the name of the capturing substring 178 ovector the vector of matched substrings 179 180 Returns: the number of the first that is set, 181 or the number of the last one if none are set, 182 or a negative number on error 183 */ 184 185 static int 186 get_first_set(const pcre *code, const char *stringname, int *ovector) 187 { 188 const real_pcre *re = (const real_pcre *)code; 189 int entrysize; 190 char *first, *last; 191 uschar *entry; 192 if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0) 193 return pcre_get_stringnumber(code, stringname); 194 entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last); 195 if (entrysize <= 0) return entrysize; 196 for (entry = (uschar *)first; entry <= (uschar *)last; entry += entrysize) 197 { 198 int n = (entry[0] << 8) + entry[1]; 199 if (ovector[n*2] >= 0) return n; 200 } 201 return (first[0] << 8) + first[1]; 202 } 203 204 205 206 207 /************************************************* 208 * Copy captured string to given buffer * 209 *************************************************/ 210 211 /* This function copies a single captured substring into a given buffer. 212 Note that we use memcpy() rather than strncpy() in case there are binary zeros 213 in the string. 214 215 Arguments: 216 subject the subject string that was matched 217 ovector pointer to the offsets table 218 stringcount the number of substrings that were captured 219 (i.e. the yield of the pcre_exec call, unless 220 that was zero, in which case it should be 1/3 221 of the offset table size) 222 stringnumber the number of the required substring 223 buffer where to put the substring 224 size the size of the buffer 225 226 Returns: if successful: 227 the length of the copied string, not including the zero 228 that is put on the end; can be zero 229 if not successful: 230 PCRE_ERROR_NOMEMORY (-6) buffer too small 231 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring 232 */ 233 234 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 235 pcre_copy_substring(const char *subject, int *ovector, int stringcount, 236 int stringnumber, char *buffer, int size) 237 { 238 int yield; 239 if (stringnumber < 0 || stringnumber >= stringcount) 240 return PCRE_ERROR_NOSUBSTRING; 241 stringnumber *= 2; 242 yield = ovector[stringnumber+1] - ovector[stringnumber]; 243 if (size < yield + 1) return PCRE_ERROR_NOMEMORY; 244 memcpy(buffer, subject + ovector[stringnumber], yield); 245 buffer[yield] = 0; 246 return yield; 247 } 248 249 250 251 /************************************************* 252 * Copy named captured string to given buffer * 253 *************************************************/ 254 255 /* This function copies a single captured substring into a given buffer, 256 identifying it by name. If the regex permits duplicate names, the first 257 substring that is set is chosen. 258 259 Arguments: 260 code the compiled regex 261 subject the subject string that was matched 262 ovector pointer to the offsets table 263 stringcount the number of substrings that were captured 264 (i.e. the yield of the pcre_exec call, unless 265 that was zero, in which case it should be 1/3 266 of the offset table size) 267 stringname the name of the required substring 268 buffer where to put the substring 269 size the size of the buffer 270 271 Returns: if successful: 272 the length of the copied string, not including the zero 273 that is put on the end; can be zero 274 if not successful: 275 PCRE_ERROR_NOMEMORY (-6) buffer too small 276 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring 277 */ 278 279 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 280 pcre_copy_named_substring(const pcre *code, const char *subject, int *ovector, 281 int stringcount, const char *stringname, char *buffer, int size) 282 { 283 int n = get_first_set(code, stringname, ovector); 284 if (n <= 0) return n; 285 return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size); 286 } 287 288 289 290 /************************************************* 291 * Copy all captured strings to new store * 292 *************************************************/ 293 294 /* This function gets one chunk of store and builds a list of pointers and all 295 of the captured substrings in it. A NULL pointer is put on the end of the list. 296 297 Arguments: 298 subject the subject string that was matched 299 ovector pointer to the offsets table 300 stringcount the number of substrings that were captured 301 (i.e. the yield of the pcre_exec call, unless 302 that was zero, in which case it should be 1/3 303 of the offset table size) 304 listptr set to point to the list of pointers 305 306 Returns: if successful: 0 307 if not successful: 308 PCRE_ERROR_NOMEMORY (-6) failed to get store 309 */ 310 311 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 312 pcre_get_substring_list(const char *subject, int *ovector, int stringcount, 313 const char ***listptr) 314 { 315 int i; 316 int size = sizeof(char *); 317 int double_count = stringcount * 2; 318 char **stringlist; 319 char *p; 320 321 for (i = 0; i < double_count; i += 2) 322 size += sizeof(char *) + ovector[i+1] - ovector[i] + 1; 323 324 stringlist = (char **)(pcre_malloc)(size); 325 if (stringlist == NULL) return PCRE_ERROR_NOMEMORY; 326 327 *listptr = (const char **)stringlist; 328 p = (char *)(stringlist + stringcount + 1); 329 330 for (i = 0; i < double_count; i += 2) 331 { 332 int len = ovector[i+1] - ovector[i]; 333 memcpy(p, subject + ovector[i], len); 334 *stringlist++ = p; 335 p += len; 336 *p++ = 0; 337 } 338 339 *stringlist = NULL; 340 return 0; 341 } 342 343 344 345 /************************************************* 346 * Free store obtained by get_substring_list * 347 *************************************************/ 348 349 /* This function exists for the benefit of people calling PCRE from non-C 350 programs that can call its functions, but not free() or (pcre_free)() directly. 351 352 Argument: the result of a previous pcre_get_substring_list() 353 Returns: nothing 354 */ 355 356 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION 357 pcre_free_substring_list(const char **pointer) 358 { 359 (pcre_free)((void *)pointer); 360 } 361 362 363 364 /************************************************* 365 * Copy captured string to new store * 366 *************************************************/ 367 368 /* This function copies a single captured substring into a piece of new 369 store 370 371 Arguments: 372 subject the subject string that was matched 373 ovector pointer to the offsets table 374 stringcount the number of substrings that were captured 375 (i.e. the yield of the pcre_exec call, unless 376 that was zero, in which case it should be 1/3 377 of the offset table size) 378 stringnumber the number of the required substring 379 stringptr where to put a pointer to the substring 380 381 Returns: if successful: 382 the length of the string, not including the zero that 383 is put on the end; can be zero 384 if not successful: 385 PCRE_ERROR_NOMEMORY (-6) failed to get store 386 PCRE_ERROR_NOSUBSTRING (-7) substring not present 387 */ 388 389 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 390 pcre_get_substring(const char *subject, int *ovector, int stringcount, 391 int stringnumber, const char **stringptr) 392 { 393 int yield; 394 char *substring; 395 if (stringnumber < 0 || stringnumber >= stringcount) 396 return PCRE_ERROR_NOSUBSTRING; 397 stringnumber *= 2; 398 yield = ovector[stringnumber+1] - ovector[stringnumber]; 399 substring = (char *)(pcre_malloc)(yield + 1); 400 if (substring == NULL) return PCRE_ERROR_NOMEMORY; 401 memcpy(substring, subject + ovector[stringnumber], yield); 402 substring[yield] = 0; 403 *stringptr = substring; 404 return yield; 405 } 406 407 408 409 /************************************************* 410 * Copy named captured string to new store * 411 *************************************************/ 412 413 /* This function copies a single captured substring, identified by name, into 414 new store. If the regex permits duplicate names, the first substring that is 415 set is chosen. 416 417 Arguments: 418 code the compiled regex 419 subject the subject string that was matched 420 ovector pointer to the offsets table 421 stringcount the number of substrings that were captured 422 (i.e. the yield of the pcre_exec call, unless 423 that was zero, in which case it should be 1/3 424 of the offset table size) 425 stringname the name of the required substring 426 stringptr where to put the pointer 427 428 Returns: if successful: 429 the length of the copied string, not including the zero 430 that is put on the end; can be zero 431 if not successful: 432 PCRE_ERROR_NOMEMORY (-6) couldn't get memory 433 PCRE_ERROR_NOSUBSTRING (-7) no such captured substring 434 */ 435 436 PCRE_EXP_DEFN int PCRE_CALL_CONVENTION 437 pcre_get_named_substring(const pcre *code, const char *subject, int *ovector, 438 int stringcount, const char *stringname, const char **stringptr) 439 { 440 int n = get_first_set(code, stringname, ovector); 441 if (n <= 0) return n; 442 return pcre_get_substring(subject, ovector, stringcount, n, stringptr); 443 } 444 445 446 447 448 /************************************************* 449 * Free store obtained by get_substring * 450 *************************************************/ 451 452 /* This function exists for the benefit of people calling PCRE from non-C 453 programs that can call its functions, but not free() or (pcre_free)() directly. 454 455 Argument: the result of a previous pcre_get_substring() 456 Returns: nothing 457 */ 458 459 PCRE_EXP_DEFN void PCRE_CALL_CONVENTION 460 pcre_free_substring(const char *pointer) 461 { 462 (pcre_free)((void *)pointer); 463 } 464 465 /* End of pcre_get.c */ 466
