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 */