pcre2_substring.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-2018 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 *   Copy named captured string to given buffer   *
  52 *************************************************/
  53
  54 /* This function copies a single captured substring into a given buffer,
  55 identifying it by name. If the regex permits duplicate names, the first
  56 substring that is set is chosen.
  57
  58 Arguments:
  59   match_data     points to the match data
  60   stringname     the name of the required substring
  61   buffer         where to put the substring
  62   sizeptr        the size of the buffer, updated to the size of the substring
  63
  64 Returns:         if successful: zero
  65                  if not successful, a negative error code:
  66                    (1) an error from nametable_scan()
  67                    (2) an error from copy_bynumber()
  68                    (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
  69                    (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
  70 */
  71
  72 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
  73 pcre2_substring_copy_byname(pcre2_match_data *match_data, PCRE2_SPTR stringname,
  74   PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
  75 {
  76 PCRE2_SPTR first, last, entry;
  77 int failrc, entrysize;
  78 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
  79   return PCRE2_ERROR_DFA_UFUNC;
  80 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
  81   &first, &last);
  82 if (entrysize < 0) return entrysize;
  83 failrc = PCRE2_ERROR_UNAVAILABLE;
  84 for (entry = first; entry <= last; entry += entrysize)
  85   {
  86   uint32_t n = GET2(entry, 0);
  87   if (n < match_data->oveccount)
  88     {
  89     if (match_data->ovector[n*2] != PCRE2_UNSET)
  90       return pcre2_substring_copy_bynumber(match_data, n, buffer, sizeptr);
  91     failrc = PCRE2_ERROR_UNSET;
  92     }
  93   }
  94 return failrc;
  95 }
  96
  97
  98
  99 /*************************************************
 100 *  Copy numbered captured string to given buffer *
 101 *************************************************/
 102
 103 /* This function copies a single captured substring into a given buffer,
 104 identifying it by number.
 105
 106 Arguments:
 107   match_data     points to the match data
 108   stringnumber   the number of the required substring
 109   buffer         where to put the substring
 110   sizeptr        the size of the buffer, updated to the size of the substring
 111
 112 Returns:         if successful: 0
 113                  if not successful, a negative error code:
 114                    PCRE2_ERROR_NOMEMORY: buffer too small
 115                    PCRE2_ERROR_NOSUBSTRING: no such substring
 116                    PCRE2_ERROR_UNAVAILABLE: ovector too small
 117                    PCRE2_ERROR_UNSET: substring is not set
 118 */
 119
 120 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 121 pcre2_substring_copy_bynumber(pcre2_match_data *match_data,
 122   uint32_t stringnumber, PCRE2_UCHAR *buffer, PCRE2_SIZE *sizeptr)
 123 {
 124 int rc;
 125 PCRE2_SIZE size;
 126 rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
 127 if (rc < 0) return rc;
 128 if (size + 1 > *sizeptr) return PCRE2_ERROR_NOMEMORY;
 129 memcpy(buffer, match_data->subject + match_data->ovector[stringnumber*2],
 130   CU2BYTES(size));
 131 buffer[size] = 0;
 132 *sizeptr = size;
 133 return 0;
 134 }
 135
 136
 137
 138 /*************************************************
 139 *          Extract named captured string         *
 140 *************************************************/
 141
 142 /* This function copies a single captured substring, identified by name, into
 143 new memory. If the regex permits duplicate names, the first substring that is
 144 set is chosen.
 145
 146 Arguments:
 147   match_data     pointer to match_data
 148   stringname     the name of the required substring
 149   stringptr      where to put the pointer to the new memory
 150   sizeptr        where to put the length of the substring
 151
 152 Returns:         if successful: zero
 153                  if not successful, a negative value:
 154                    (1) an error from nametable_scan()
 155                    (2) an error from get_bynumber()
 156                    (3) PCRE2_ERROR_UNAVAILABLE: no group is in ovector
 157                    (4) PCRE2_ERROR_UNSET: all named groups in ovector are unset
 158 */
 159
 160 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 161 pcre2_substring_get_byname(pcre2_match_data *match_data,
 162   PCRE2_SPTR stringname, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
 163 {
 164 PCRE2_SPTR first, last, entry;
 165 int failrc, entrysize;
 166 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
 167   return PCRE2_ERROR_DFA_UFUNC;
 168 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
 169   &first, &last);
 170 if (entrysize < 0) return entrysize;
 171 failrc = PCRE2_ERROR_UNAVAILABLE;
 172 for (entry = first; entry <= last; entry += entrysize)
 173   {
 174   uint32_t n = GET2(entry, 0);
 175   if (n < match_data->oveccount)
 176     {
 177     if (match_data->ovector[n*2] != PCRE2_UNSET)
 178       return pcre2_substring_get_bynumber(match_data, n, stringptr, sizeptr);
 179     failrc = PCRE2_ERROR_UNSET;
 180     }
 181   }
 182 return failrc;
 183 }
 184
 185
 186
 187 /*************************************************
 188 *      Extract captured string to new memory     *
 189 *************************************************/
 190
 191 /* This function copies a single captured substring into a piece of new
 192 memory.
 193
 194 Arguments:
 195   match_data     points to match data
 196   stringnumber   the number of the required substring
 197   stringptr      where to put a pointer to the new memory
 198   sizeptr        where to put the size of the substring
 199
 200 Returns:         if successful: 0
 201                  if not successful, a negative error code:
 202                    PCRE2_ERROR_NOMEMORY: failed to get memory
 203                    PCRE2_ERROR_NOSUBSTRING: no such substring
 204                    PCRE2_ERROR_UNAVAILABLE: ovector too small
 205                    PCRE2_ERROR_UNSET: substring is not set
 206 */
 207
 208 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 209 pcre2_substring_get_bynumber(pcre2_match_data *match_data,
 210   uint32_t stringnumber, PCRE2_UCHAR **stringptr, PCRE2_SIZE *sizeptr)
 211 {
 212 int rc;
 213 PCRE2_SIZE size;
 214 PCRE2_UCHAR *yield;
 215 rc = pcre2_substring_length_bynumber(match_data, stringnumber, &size);
 216 if (rc < 0) return rc;
 217 yield = PRIV(memctl_malloc)(sizeof(pcre2_memctl) +
 218   (size + 1)*PCRE2_CODE_UNIT_WIDTH, (pcre2_memctl *)match_data);
 219 if (yield == NULL) return PCRE2_ERROR_NOMEMORY;
 220 yield = (PCRE2_UCHAR *)(((char *)yield) + sizeof(pcre2_memctl));
 221 memcpy(yield, match_data->subject + match_data->ovector[stringnumber*2],
 222   CU2BYTES(size));
 223 yield[size] = 0;
 224 *stringptr = yield;
 225 *sizeptr = size;
 226 return 0;
 227 }
 228
 229
 230
 231 /*************************************************
 232 *       Free memory obtained by get_substring    *
 233 *************************************************/
 234
 235 /*
 236 Argument:     the result of a previous pcre2_substring_get_byxxx()
 237 Returns:      nothing
 238 */
 239
 240 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 241 pcre2_substring_free(PCRE2_UCHAR *string)
 242 {
 243 if (string != NULL)
 244   {
 245   pcre2_memctl *memctl = (pcre2_memctl *)((char *)string - sizeof(pcre2_memctl));
 246   memctl->free(memctl, memctl->memory_data);
 247   }
 248 }
 249
 250
 251
 252 /*************************************************
 253 *         Get length of a named substring        *
 254 *************************************************/
 255
 256 /* This function returns the length of a named captured substring. If the regex
 257 permits duplicate names, the first substring that is set is chosen.
 258
 259 Arguments:
 260   match_data      pointer to match data
 261   stringname      the name of the required substring
 262   sizeptr         where to put the length
 263
 264 Returns:          0 if successful, else a negative error number
 265 */
 266
 267 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 268 pcre2_substring_length_byname(pcre2_match_data *match_data,
 269   PCRE2_SPTR stringname, PCRE2_SIZE *sizeptr)
 270 {
 271 PCRE2_SPTR first, last, entry;
 272 int failrc, entrysize;
 273 if (match_data->matchedby == PCRE2_MATCHEDBY_DFA_INTERPRETER)
 274   return PCRE2_ERROR_DFA_UFUNC;
 275 entrysize = pcre2_substring_nametable_scan(match_data->code, stringname,
 276   &first, &last);
 277 if (entrysize < 0) return entrysize;
 278 failrc = PCRE2_ERROR_UNAVAILABLE;
 279 for (entry = first; entry <= last; entry += entrysize)
 280   {
 281   uint32_t n = GET2(entry, 0);
 282   if (n < match_data->oveccount)
 283     {
 284     if (match_data->ovector[n*2] != PCRE2_UNSET)
 285       return pcre2_substring_length_bynumber(match_data, n, sizeptr);
 286     failrc = PCRE2_ERROR_UNSET;
 287     }
 288   }
 289 return failrc;
 290 }
 291
 292
 293
 294 /*************************************************
 295 *        Get length of a numbered substring      *
 296 *************************************************/
 297
 298 /* This function returns the length of a captured substring. If the start is
 299 beyond the end (which can happen when \K is used in an assertion), it sets the
 300 length to zero.
 301
 302 Arguments:
 303   match_data      pointer to match data
 304   stringnumber    the number of the required substring
 305   sizeptr         where to put the length, if not NULL
 306
 307 Returns:         if successful: 0
 308                  if not successful, a negative error code:
 309                    PCRE2_ERROR_NOSUBSTRING: no such substring
 310                    PCRE2_ERROR_UNAVAILABLE: ovector is too small
 311                    PCRE2_ERROR_UNSET: substring is not set
 312 */
 313
 314 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 315 pcre2_substring_length_bynumber(pcre2_match_data *match_data,
 316   uint32_t stringnumber, PCRE2_SIZE *sizeptr)
 317 {
 318 PCRE2_SIZE left, right;
 319 int count = match_data->rc;
 320 if (count == PCRE2_ERROR_PARTIAL)
 321   {
 322   if (stringnumber > 0) return PCRE2_ERROR_PARTIAL;
 323   count = 0;
 324   }
 325 else if (count < 0) return count;            /* Match failed */
 326
 327 if (match_data->matchedby != PCRE2_MATCHEDBY_DFA_INTERPRETER)
 328   {
 329   if (stringnumber > match_data->code->top_bracket)
 330     return PCRE2_ERROR_NOSUBSTRING;
 331   if (stringnumber >= match_data->oveccount)
 332     return PCRE2_ERROR_UNAVAILABLE;
 333   if (match_data->ovector[stringnumber*2] == PCRE2_UNSET)
 334     return PCRE2_ERROR_UNSET;
 335   }
 336 else  /* Matched using pcre2_dfa_match() */
 337   {
 338   if (stringnumber >= match_data->oveccount) return PCRE2_ERROR_UNAVAILABLE;
 339   if (count != 0 && stringnumber >= (uint32_t)count) return PCRE2_ERROR_UNSET;
 340   }
 341
 342 left = match_data->ovector[stringnumber*2];
 343 right = match_data->ovector[stringnumber*2+1];
 344 if (sizeptr != NULL) *sizeptr = (left > right)? 0 : right - left;
 345 return 0;
 346 }
 347
 348
 349
 350 /*************************************************
 351 *    Extract all captured strings to new memory  *
 352 *************************************************/
 353
 354 /* This function gets one chunk of memory and builds a list of pointers and all
 355 the captured substrings in it. A NULL pointer is put on the end of the list.
 356 The substrings are zero-terminated, but also, if the final argument is
 357 non-NULL, a list of lengths is also returned. This allows binary data to be
 358 handled.
 359
 360 Arguments:
 361   match_data     points to the match data
 362   listptr        set to point to the list of pointers
 363   lengthsptr     set to point to the list of lengths (may be NULL)
 364
 365 Returns:         if successful: 0
 366                  if not successful, a negative error code:
 367                    PCRE2_ERROR_NOMEMORY: failed to get memory,
 368                    or a match failure code
 369 */
 370
 371 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 372 pcre2_substring_list_get(pcre2_match_data *match_data, PCRE2_UCHAR ***listptr,
 373   PCRE2_SIZE **lengthsptr)
 374 {
 375 int i, count, count2;
 376 PCRE2_SIZE size;
 377 PCRE2_SIZE *lensp;
 378 pcre2_memctl *memp;
 379 PCRE2_UCHAR **listp;
 380 PCRE2_UCHAR *sp;
 381 PCRE2_SIZE *ovector;
 382
 383 if ((count = match_data->rc) < 0) return count;   /* Match failed */
 384 if (count == 0) count = match_data->oveccount;    /* Ovector too small */
 385
 386 count2 = 2*count;
 387 ovector = match_data->ovector;
 388 size = sizeof(pcre2_memctl) + sizeof(PCRE2_UCHAR *);      /* For final NULL */
 389 if (lengthsptr != NULL) size += sizeof(PCRE2_SIZE) * count;  /* For lengths */
 390
 391 for (i = 0; i < count2; i += 2)
 392   {
 393   size += sizeof(PCRE2_UCHAR *) + CU2BYTES(1);
 394   if (ovector[i+1] > ovector[i]) size += CU2BYTES(ovector[i+1] - ovector[i]);
 395   }
 396
 397 memp = PRIV(memctl_malloc)(size, (pcre2_memctl *)match_data);
 398 if (memp == NULL) return PCRE2_ERROR_NOMEMORY;
 399
 400 *listptr = listp = (PCRE2_UCHAR **)((char *)memp + sizeof(pcre2_memctl));
 401 lensp = (PCRE2_SIZE *)((char *)listp + sizeof(PCRE2_UCHAR *) * (count + 1));
 402
 403 if (lengthsptr == NULL)
 404   {
 405   sp = (PCRE2_UCHAR *)lensp;
 406   lensp = NULL;
 407   }
 408 else
 409   {
 410   *lengthsptr = lensp;
 411   sp = (PCRE2_UCHAR *)((char *)lensp + sizeof(PCRE2_SIZE) * count);
 412   }
 413
 414 for (i = 0; i < count2; i += 2)
 415   {
 416   size = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0;
 417
 418   /* Size == 0 includes the case when the capture is unset. Avoid adding
 419   PCRE2_UNSET to match_data->subject because it overflows, even though with
 420   zero size calling memcpy() is harmless. */
 421
 422   if (size != 0) memcpy(sp, match_data->subject + ovector[i], CU2BYTES(size));
 423   *listp++ = sp;
 424   if (lensp != NULL) *lensp++ = size;
 425   sp += size;
 426   *sp++ = 0;
 427   }
 428
 429 *listp = NULL;
 430 return 0;
 431 }
 432
 433
 434
 435 /*************************************************
 436 *   Free memory obtained by substring_list_get   *
 437 *************************************************/
 438
 439 /*
 440 Argument:     the result of a previous pcre2_substring_list_get()
 441 Returns:      nothing
 442 */
 443
 444 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
 445 pcre2_substring_list_free(PCRE2_SPTR *list)
 446 {
 447 if (list != NULL)
 448   {
 449   pcre2_memctl *memctl = (pcre2_memctl *)((char *)list - sizeof(pcre2_memctl));
 450   memctl->free(memctl, memctl->memory_data);
 451   }
 452 }
 453
 454
 455
 456 /*************************************************
 457 *     Find (multiple) entries for named string   *
 458 *************************************************/
 459
 460 /* This function scans the nametable for a given name, using binary chop. It
 461 returns either two pointers to the entries in the table, or, if no pointers are
 462 given, the number of a unique group with the given name. If duplicate names are
 463 permitted, and the name is not unique, an error is generated.
 464
 465 Arguments:
 466   code        the compiled regex
 467   stringname  the name whose entries required
 468   firstptr    where to put the pointer to the first entry
 469   lastptr     where to put the pointer to the last entry
 470
 471 Returns:      PCRE2_ERROR_NOSUBSTRING if the name is not found
 472               otherwise, if firstptr and lastptr are NULL:
 473                 a group number for a unique substring
 474                 else PCRE2_ERROR_NOUNIQUESUBSTRING
 475               otherwise:
 476                 the length of each entry, having set firstptr and lastptr
 477 */
 478
 479 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 480 pcre2_substring_nametable_scan(const pcre2_code *code, PCRE2_SPTR stringname,
 481   PCRE2_SPTR *firstptr, PCRE2_SPTR *lastptr)
 482 {
 483 uint16_t bot = 0;
 484 uint16_t top = code->name_count;
 485 uint16_t entrysize = code->name_entry_size;
 486 PCRE2_SPTR nametable = (PCRE2_SPTR)((char *)code + sizeof(pcre2_real_code));
 487
 488 while (top > bot)
 489   {
 490   uint16_t mid = (top + bot) / 2;
 491   PCRE2_SPTR entry = nametable + entrysize*mid;
 492   int c = PRIV(strcmp)(stringname, entry + IMM2_SIZE);
 493   if (c == 0)
 494     {
 495     PCRE2_SPTR first;
 496     PCRE2_SPTR last;
 497     PCRE2_SPTR lastentry;
 498     lastentry = nametable + entrysize * (code->name_count - 1);
 499     first = last = entry;
 500     while (first > nametable)
 501       {
 502       if (PRIV(strcmp)(stringname, (first - entrysize + IMM2_SIZE)) != 0) break;
 503       first -= entrysize;
 504       }
 505     while (last < lastentry)
 506       {
 507       if (PRIV(strcmp)(stringname, (last + entrysize + IMM2_SIZE)) != 0) break;
 508       last += entrysize;
 509       }
 510     if (firstptr == NULL) return (first == last)?
 511       (int)GET2(entry, 0) : PCRE2_ERROR_NOUNIQUESUBSTRING;
 512     *firstptr = first;
 513     *lastptr = last;
 514     return entrysize;
 515     }
 516   if (c > 0) bot = mid + 1; else top = mid;
 517   }
 518
 519 return PCRE2_ERROR_NOSUBSTRING;
 520 }
 521
 522
 523 /*************************************************
 524 *           Find number for named string         *
 525 *************************************************/
 526
 527 /* This function is a convenience wrapper for pcre2_substring_nametable_scan()
 528 when it is known that names are unique. If there are duplicate names, it is not
 529 defined which number is returned.
 530
 531 Arguments:
 532   code        the compiled regex
 533   stringname  the name whose number is required
 534
 535 Returns:      the number of the named parenthesis, or a negative number
 536                 PCRE2_ERROR_NOSUBSTRING if not found
 537                 PCRE2_ERROR_NOUNIQUESUBSTRING if not unique
 538 */
 539
 540 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
 541 pcre2_substring_number_from_name(const pcre2_code *code,
 542   PCRE2_SPTR stringname)
 543 {
 544 return pcre2_substring_nametable_scan(code, stringname, NULL, NULL);
 545 }
 546
 547 /* End of pcre2_substring.c */