dnl APACHE_CHECK_PCRE

dnl Apache includes it's own version of PCRE; however, if PCRE exists

dnl on the build system, we link against that instead of building

dnl Apache's own PCRE.

dnl

AC_DEFUN(APACHE_CHECK_PCRE, [

  AC_MSG_CHECKING(for external PCRE library)

  ap_pcre_base=""

  ap_test_pcre=1

  AP_EXTERN_PCRE=0

  AC_ARG_WITH([pcre], AS_HELP_STRING([--with-external-pcre],

      [use external libpcre (versus apache-supplied pcre)]), [

    if test "x$withval" = "xno"; then

      ap_test_pcre=0;

    elif test "x$withval" != "xyes" -a "x$withval" != "x"; then

      ap_pcre_base="$withval"

    fi

  ])

  if test "$ap_test_pcre" != "0"; then

    ap_pcre_conf="pcre-config"

    if test -f "$ap_pcre_base"; then

      ap_pcre_conf="$ap_pcre_base";

    elif test -f "$ap_pcre_base/pcre-config"; then

      ap_pcre_conf="$ap_pcre_base/pcre-config";

    elif test -f "$ap_pcre_base/bin/pcre-config"; then

      ap_pcre_conf="$ap_pcre_base/bin/pcre-config";

    fi

    ap_save_CFLAGS="$CFLAGS"

    ap_save_LIBS="$LIBS"

    CFLAGS="$CFLAGS `$ap_pcre_conf --cflags 2>/dev/null`"

    LIBS="$LIBS `$ap_pcre_conf --libs 2>/dev/null`"

    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <pcre.h>]],

        [[char *foo = pcre_version();]])], [

      AP_EXTERN_PCRE=1

    ], [

      CFLAGS="$ap_save_CFLAGS"

      LIBS="$ap_save_LIBS"

    ])

  fi

  if test "$AP_EXTERN_PCRE" = "1"; then

    AC_MSG_RESULT(yes)

  else

    AC_MSG_RESULT(no)

  fi

  AC_SUBST(AP_EXTERN_PCRE)

])

dnl

/*************************************************

*      Perl-Compatible Regular Expressions       *

*************************************************/

/*

This is a library of functions to support regular expressions whose syntax

and semantics are as close as possible to those of the Perl 5 language. See

the file Tech.Notes for some information on the internals.

This module is a wrapper that provides a POSIX API to the underlying PCRE

functions.

Written by: Philip Hazel <ph10@cam.ac.uk>

           Copyright (c) 1997-2003 University of Cambridge

	   Copyright (C) 2004  Andres Salomon <dilinger@voxel.net>

-----------------------------------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any

computer system, and to redistribute it freely, subject to the following

restrictions:

1. This software is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by

   explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be

   misrepresented as being the original software.

4. If PCRE is embedded in any software that is released under the GNU

   General Purpose Licence (GPL), then the terms of that licence shall

   supersede any condition above with which it is incompatible.

-----------------------------------------------------------------------------

*/

#include "apr.h"

#include "apr_strings.h"

#include "apr_lib.h"

#define APR_WANT_STDIO

#define APR_WANT_STRFUNC

#include "apr_want.h"

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#if APR_HAVE_NETDB_H

#include <netdb.h>              /* for gethostbyname() */

#endif

#define CORE_PRIVATE

#include "ap_config.h"

#include "apr_base64.h"

#include "httpd.h"

#include "http_main.h"

#include "http_log.h"

#include "http_protocol.h"

#include "http_config.h"

#include "util_ebcdic.h"

#include <pcre.h>

#ifndef PCRE_CONFIG_POSIX_MALLOC_THRESHOLD

#define PCRE_CONFIG_POSIX_MALLOC_THRESHOLD 3

#endif

/* Table of texts corresponding to POSIX error codes */

static const char *pstring[] = {

  "",                                /* Dummy for value 0 */

  "internal error",                  /* REG_ASSERT */

  "invalid repeat counts in {}",     /* BADBR      */

  "pattern error",                   /* BADPAT     */

  "? * + invalid",                   /* BADRPT     */

  "unbalanced {}",                   /* EBRACE     */

  "unbalanced []",                   /* EBRACK     */

  "collation error - not relevant",  /* ECOLLATE   */

  "bad class",                       /* ECTYPE     */

  "bad escape sequence",             /* EESCAPE    */

  "empty expression",                /* EMPTY      */

  "unbalanced ()",                   /* EPAREN     */

  "bad range inside []",             /* ERANGE     */

  "expression too big",              /* ESIZE      */

  "failed to get memory",            /* ESPACE     */

  "bad back reference",              /* ESUBREG    */

  "bad argument",                    /* INVARG     */

  "match failed"                     /* NOMATCH    */

};

/*************************************************

*          Translate error code to string        *

*************************************************/

AP_DECLARE(size_t)

ap_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)

{

const char *message, *addmessage;

size_t length, addlength;

message = (errcode >= (int)(sizeof(pstring)/sizeof(char *)))?

  "unknown error code" : pstring[errcode];

length = strlen(message) + 1;

addmessage = " at offset ";

addlength = (preg != NULL && (int)preg->re_erroffset != -1)?

  strlen(addmessage) + 6 : 0;

if (errbuf_size > 0)

  {

  if (addlength > 0 && errbuf_size >= length + addlength)

    sprintf(errbuf, "%s%s%-6d", message, addmessage, (int)preg->re_erroffset);

  else

    {

    strncpy(errbuf, message, errbuf_size - 1);

    errbuf[errbuf_size-1] = 0;

    }

  }

return length + addlength;

}

/*************************************************

*           Free store held by a regex           *

*************************************************/

void

ap_regfree(regex_t *preg)

{

(pcre_free)(preg->re_pcre);

}

/*************************************************

*            Compile a regular expression        *

*************************************************/

/*

Arguments:

  preg        points to a structure for recording the compiled expression

  pattern     the pattern to compile

  cflags      compilation flags

Returns:      0 on success

              various non-zero codes on failure

*/

int

ap_regcomp(regex_t *preg, const char *pattern, int cflags)

{

const char *errorptr;

int erroffset;

int options = 0;

if ((cflags & REG_ICASE) != 0) options |= PCRE_CASELESS;

if ((cflags & REG_NEWLINE) != 0) options |= PCRE_MULTILINE;

preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset, NULL);

preg->re_erroffset = erroffset;

if (preg->re_pcre == NULL) return 1;

preg->re_nsub = pcre_info(preg->re_pcre, NULL, NULL);

return 0;

}

/*************************************************

*              Match a regular expression        *

*************************************************/

/* Unfortunately, PCRE requires 3 ints of working space for each captured

substring, so we have to get and release working store instead of just using

the POSIX structures as was done in earlier releases when PCRE needed only 2

ints. However, if the number of possible capturing brackets is small, use a

block of store on the stack, to reduce the use of malloc/free. The threshold is

in a macro that can be changed at configure time. */

AP_DECLARE(int)

ap_regexec(regex_t *preg, const char *string, size_t nmatch,

  regmatch_t pmatch[], int eflags)

{

int rc;

int options = 0;

int *ovector = NULL;

int small_ovector[PCRE_CONFIG_POSIX_MALLOC_THRESHOLD * 3];

int allocated_ovector = 0;

if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;

if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;

((regex_t *)preg)->re_erroffset = (size_t)(-1);  /* Only has meaning after compile */

if (nmatch > 0)

  {

  if (nmatch <= PCRE_CONFIG_POSIX_MALLOC_THRESHOLD)

    {

    ovector = &(small_ovector[0]);

    }

  else

    {

    ovector = (int *)malloc(sizeof(int) * nmatch * 3);

    if (ovector == NULL) return REG_ESPACE;

    allocated_ovector = 1;

    }

  }

rc = pcre_exec(preg->re_pcre, NULL, string, (int)strlen(string), 0, options,

  ovector, nmatch * 3);

if (rc == 0) rc = nmatch;    /* All captured slots were filled in */

if (rc >= 0)

  {

  size_t i;

  for (i = 0; i < (size_t)rc; i++)

    {

    pmatch[i].rm_so = ovector[i*2];

    pmatch[i].rm_eo = ovector[i*2+1];

    }

  if (allocated_ovector) free(ovector);

  for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;

  return 0;

  }

else

  {

  if (allocated_ovector) free(ovector);

  switch(rc)

    {

    case PCRE_ERROR_NOMATCH: return REG_NOMATCH;

    case PCRE_ERROR_NULL: return REG_INVARG;

    case PCRE_ERROR_BADOPTION: return REG_INVARG;

    case PCRE_ERROR_BADMAGIC: return REG_INVARG;

    case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;

    case PCRE_ERROR_NOMEMORY: return REG_ESPACE;

    default: return REG_ASSERT;

    }

  }

}