granicus.if.org Git - apache/blob - server/util_pcre.c

   1 /*************************************************
   2  *      Perl-Compatible Regular Expressions      *
   3  *************************************************/
   4
   5 /*
   6 This is a library of functions to support regular expressions whose syntax
   7 and semantics are as close as possible to those of the Perl 5 language. See
   8 the file Tech.Notes for some information on the internals.
   9
  10 This module is a wrapper that provides a POSIX API to the underlying PCRE
  11 functions.
  12
  13 Written by: Philip Hazel <ph10@cam.ac.uk>
  14
  15            Copyright (c) 1997-2004 University of Cambridge
  16
  17 -----------------------------------------------------------------------------
  18 Redistribution and use in source and binary forms, with or without
  19 modification, are permitted provided that the following conditions are met:
  20
  21     * Redistributions of source code must retain the above copyright notice,
  22       this list of conditions and the following disclaimer.
  23
  24     * Redistributions in binary form must reproduce the above copyright
  25       notice, this list of conditions and the following disclaimer in the
  26       documentation and/or other materials provided with the distribution.
  27
  28     * Neither the name of the University of Cambridge nor the names of its
  29       contributors may be used to endorse or promote products derived from
  30       this software without specific prior written permission.
  31
  32 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  33 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  34 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  35 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  36 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  37 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  38 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  39 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  40 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  41 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42 POSSIBILITY OF SUCH DAMAGE.
  43 -----------------------------------------------------------------------------
  44 */
  45
  46 #include "httpd.h"
  47 #include "apr_strings.h"
  48 #include "apr_tables.h"
  49 #include "pcre.h"
  50
  51 #define APR_WANT_STRFUNC
  52 #include "apr_want.h"
  53
  54 #ifndef POSIX_MALLOC_THRESHOLD
  55 #define POSIX_MALLOC_THRESHOLD (10)
  56 #endif
  57
  58 /* Table of error strings corresponding to POSIX error codes; must be
  59  * kept in synch with include/ap_regex.h's AP_REG_E* definitions.
  60  */
  61
  62 static const char *const pstring[] = {
  63     "",                         /* Dummy for value 0 */
  64     "internal error",           /* AP_REG_ASSERT */
  65     "failed to get memory",     /* AP_REG_ESPACE */
  66     "bad argument",             /* AP_REG_INVARG */
  67     "match failed"              /* AP_REG_NOMATCH */
  68 };
  69
  70 AP_DECLARE(apr_size_t) ap_regerror(int errcode, const ap_regex_t *preg,
  71                                    char *errbuf, apr_size_t errbuf_size)
  72 {
  73     const char *message, *addmessage;
  74     apr_size_t length, addlength;
  75
  76     message = (errcode >= (int)(sizeof(pstring) / sizeof(char *))) ?
  77               "unknown error code" : pstring[errcode];
  78     length = strlen(message) + 1;
  79
  80     addmessage = " at offset ";
  81     addlength = (preg != NULL && (int)preg->re_erroffset != -1) ?
  82                 strlen(addmessage) + 6 : 0;
  83
  84     if (errbuf_size > 0) {
  85         if (addlength > 0 && errbuf_size >= length + addlength)
  86             apr_snprintf(errbuf, errbuf_size, "%s%s%-6d", message, addmessage,
  87                          (int)preg->re_erroffset);
  88         else
  89             apr_cpystrn(errbuf, message, errbuf_size);
  90     }
  91
  92     return length + addlength;
  93 }
  94
  95
  96
  97
  98 /*************************************************
  99  *           Free store held by a regex          *
 100  *************************************************/
 101
 102 AP_DECLARE(void) ap_regfree(ap_regex_t *preg)
 103 {
 104     (pcre_free)(preg->re_pcre);
 105 }
 106
 107
 108
 109
 110 /*************************************************
 111  *            Compile a regular expression       *
 112  *************************************************/
 113
 114 /*
 115  * Arguments:
 116  *  preg        points to a structure for recording the compiled expression
 117  *  pattern     the pattern to compile
 118  *  cflags      compilation flags
 119  *
 120  * Returns:      0 on success
 121  *               various non-zero codes on failure
 122 */
 123 AP_DECLARE(int) ap_regcomp(ap_regex_t * preg, const char *pattern, int cflags)
 124 {
 125     const char *errorptr;
 126     int erroffset;
 127     int errcode = 0;
 128     /* PCRE_DUPNAMES is only present in more recent versions of PCRE */
 129 #ifdef PCRE_DUPNAMES
 130     int options = PCRE_DUPNAMES;
 131 #else
 132 #error PCRE_DUPNAMES does not exist in this PCRE implementation; too old.
 133 #endif
 134
 135     if ((cflags & AP_REG_ICASE) != 0)
 136         options |= PCRE_CASELESS;
 137     if ((cflags & AP_REG_NEWLINE) != 0)
 138         options |= PCRE_MULTILINE;
 139     if ((cflags & AP_REG_DOTALL) != 0)
 140         options |= PCRE_DOTALL;
 141
 142     preg->re_pcre =
 143         pcre_compile2(pattern, options, &errcode, &errorptr, &erroffset, NULL);
 144     preg->re_erroffset = erroffset;
 145
 146     if (preg->re_pcre == NULL) {
 147         /*
 148          * There doesn't seem to be constants defined for compile time error
 149          * codes. 21 is "failed to get memory" according to pcreapi(3).
 150          */
 151         if (errcode == 21)
 152             return AP_REG_ESPACE;
 153         return AP_REG_INVARG;
 154     }
 155
 156     pcre_fullinfo((const pcre *)preg->re_pcre, NULL,
 157                    PCRE_INFO_CAPTURECOUNT, &(preg->re_nsub));
 158     return 0;
 159 }
 160
 161
 162
 163
 164 /*************************************************
 165  *              Match a regular expression       *
 166  *************************************************/
 167
 168 /* Unfortunately, PCRE requires 3 ints of working space for each captured
 169  * substring, so we have to get and release working store instead of just using
 170  * the POSIX structures as was done in earlier releases when PCRE needed only 2
 171  * ints. However, if the number of possible capturing brackets is small, use a
 172  * block of store on the stack, to reduce the use of malloc/free. The threshold
 173  * is in a macro that can be changed at configure time.
 174  */
 175 AP_DECLARE(int) ap_regexec(const ap_regex_t *preg, const char *string,
 176                            apr_size_t nmatch, ap_regmatch_t *pmatch,
 177                            int eflags)
 178 {
 179     return ap_regexec_len(preg, string, strlen(string), nmatch, pmatch,
 180                           eflags);
 181 }
 182
 183 AP_DECLARE(int) ap_regexec_len(const ap_regex_t *preg, const char *buff,
 184                                apr_size_t len, apr_size_t nmatch,
 185                                ap_regmatch_t *pmatch, int eflags)
 186 {
 187     int rc;
 188     int options = 0;
 189     int *ovector = NULL;
 190     int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
 191     int allocated_ovector = 0;
 192
 193     if ((eflags & AP_REG_NOTBOL) != 0)
 194         options |= PCRE_NOTBOL;
 195     if ((eflags & AP_REG_NOTEOL) != 0)
 196         options |= PCRE_NOTEOL;
 197
 198     ((ap_regex_t *)preg)->re_erroffset = (apr_size_t)(-1);    /* Only has meaning after compile */
 199
 200     if (nmatch > 0) {
 201         if (nmatch <= POSIX_MALLOC_THRESHOLD) {
 202             ovector = &(small_ovector[0]);
 203         }
 204         else {
 205             ovector = (int *)malloc(sizeof(int) * nmatch * 3);
 206             if (ovector == NULL)
 207                 return AP_REG_ESPACE;
 208             allocated_ovector = 1;
 209         }
 210     }
 211
 212     rc = pcre_exec((const pcre *)preg->re_pcre, NULL, buff, (int)len,
 213                    0, options, ovector, nmatch * 3);
 214
 215     if (rc == 0)
 216         rc = nmatch;            /* All captured slots were filled in */
 217
 218     if (rc >= 0) {
 219         apr_size_t i;
 220         for (i = 0; i < (apr_size_t)rc; i++) {
 221             pmatch[i].rm_so = ovector[i * 2];
 222             pmatch[i].rm_eo = ovector[i * 2 + 1];
 223         }
 224         if (allocated_ovector)
 225             free(ovector);
 226         for (; i < nmatch; i++)
 227             pmatch[i].rm_so = pmatch[i].rm_eo = -1;
 228         return 0;
 229     }
 230
 231     else {
 232         if (allocated_ovector)
 233             free(ovector);
 234         switch (rc) {
 235         case PCRE_ERROR_NOMATCH:
 236             return AP_REG_NOMATCH;
 237         case PCRE_ERROR_NULL:
 238             return AP_REG_INVARG;
 239         case PCRE_ERROR_BADOPTION:
 240             return AP_REG_INVARG;
 241         case PCRE_ERROR_BADMAGIC:
 242             return AP_REG_INVARG;
 243         case PCRE_ERROR_UNKNOWN_NODE:
 244             return AP_REG_ASSERT;
 245         case PCRE_ERROR_NOMEMORY:
 246             return AP_REG_ESPACE;
 247 #ifdef PCRE_ERROR_MATCHLIMIT
 248         case PCRE_ERROR_MATCHLIMIT:
 249             return AP_REG_ESPACE;
 250 #endif
 251 #ifdef PCRE_ERROR_BADUTF8
 252         case PCRE_ERROR_BADUTF8:
 253             return AP_REG_INVARG;
 254 #endif
 255 #ifdef PCRE_ERROR_BADUTF8_OFFSET
 256         case PCRE_ERROR_BADUTF8_OFFSET:
 257             return AP_REG_INVARG;
 258 #endif
 259         default:
 260             return AP_REG_ASSERT;
 261         }
 262     }
 263 }
 264
 265 AP_DECLARE(int) ap_regname(const ap_regex_t *preg,
 266                            apr_array_header_t *names, const char *prefix,
 267                            int upper)
 268 {
 269     int namecount;
 270     int nameentrysize;
 271     int i;
 272     char *nametable;
 273
 274     pcre_fullinfo((const pcre *)preg->re_pcre, NULL,
 275                        PCRE_INFO_NAMECOUNT, &namecount);
 276     pcre_fullinfo((const pcre *)preg->re_pcre, NULL,
 277                        PCRE_INFO_NAMEENTRYSIZE, &nameentrysize);
 278     pcre_fullinfo((const pcre *)preg->re_pcre, NULL,
 279                        PCRE_INFO_NAMETABLE, &nametable);
 280
 281     for (i = 0; i < namecount; i++) {
 282         const char *offset = nametable + i * nameentrysize;
 283         int capture = ((offset[0] << 8) + offset[1]);
 284         while (names->nelts <= capture) {
 285             apr_array_push(names);
 286         }
 287         if (upper || prefix) {
 288             char *name = ((char **) names->elts)[capture] =
 289                     prefix ? apr_pstrcat(names->pool, prefix, offset + 2,
 290                             NULL) :
 291                             apr_pstrdup(names->pool, offset + 2);
 292             if (upper) {
 293                 ap_str_toupper(name);
 294             }
 295         }
 296         else {
 297             ((const char **)names->elts)[capture] = offset + 2;
 298         }
 299     }
 300
 301     return namecount;
 302 }
 303
 304 /* End of pcreposix.c */