prex.c File Reference

Manage precompiled / predefined regular expressions. More...

#include "config.h"
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include "prex.h"
#include "logging.h"
#include "memory.h"

Include dependency graph for prex.c:

Go to the source code of this file.

Data Structures
struct	PrexStorage
	A predefined / precompiled regex. More...

Macros
#define	PREX_MONTH   "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"
#define	PREX_DOW   "(Mon|Tue|Wed|Thu|Fri|Sat|Sun)"
#define	PREX_DOW_NOCASE
#define	PREX_TIME   "([[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2})"
#define	PREX_YEAR   "([[:digit:]]{4})"
#define	UNR_PCTENC_SUBDEL   "][[:alnum:]._~%!$&'()*+,;="
#define	PATH   ":@/ "
#define	QUERY_PART   "^&="
#define	FWS   " *"
#define	C   "(\\(.*\\))?"
#define	CFWS   FWS C FWS

Functions
static struct PrexStorage *	prex (enum Prex which)
	Compile on demand and get data for a predefined regex. More...
regmatch_t *	mutt_prex_capture (enum Prex which, const char *str)
	match a precompiled regex against a string More...
void	mutt_prex_free (void)
	Cleanup heap memory allocated by compiled regexes. More...

Detailed Description

Manage precompiled / predefined regular expressions.

Authors

• Pietro Cerutti

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program 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. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file prex.c.

Macro Definition Documentation

PREX_MONTH

#define PREX_MONTH   "(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"

Definition at line 81 of file prex.c.

PREX_DOW

#define PREX_DOW   "(Mon|Tue|Wed|Thu|Fri|Sat|Sun)"

Definition at line 82 of file prex.c.

PREX_DOW_NOCASE

#define PREX_DOW_NOCASE

Value:

"([Mm][Oo][Nn]|[Tt][Uu][Ee]|[Ww][Ee][Dd]|[Tt][Hh][Uu]|[Ff][Rr][Ii]|"         \
  "[Ss][Aa][Tt]|[Ss][Uu][Nn])"

Definition at line 83 of file prex.c.

PREX_TIME

#define PREX_TIME   "([[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2})"

Definition at line 86 of file prex.c.

PREX_YEAR

#define PREX_YEAR   "([[:digit:]]{4})"

Definition at line 87 of file prex.c.

UNR_PCTENC_SUBDEL

#define UNR_PCTENC_SUBDEL   "][[:alnum:]._~%!$&'()*+,;="

PATH

#define PATH   ":@/ "

QUERY_PART

#define QUERY_PART   "^&="

FWS

#define FWS   " *"

C

#define C   "(\\(.*\\))?"

CFWS

#define CFWS   FWS C FWS

Function Documentation

prex()

static struct PrexStorage* prex ( enum Prex  which )

static

Compile on demand and get data for a predefined regex.

Parameters

which

Which regex to get

Return values

ptr	Pointer to a PrexStorage struct

Note

Returned pointer is guaranteed not to be NULL. The function asserts on error.

Definition at line 97 of file prex.c.

{
  static struct PrexStorage storage[] = {
    /* clang-format off */
    {
      PREX_URL,
      PREX_URL_MATCH_MAX,
      /* Spec: https://tools.ietf.org/html/rfc3986#section-3 */
#ifdef HAVE_PCRE2
#define UNR_PCTENC_SUBDEL "][\\p{L}\\p{N}._~%!$&'()*+,;="
#else
#define UNR_PCTENC_SUBDEL "][[:alnum:]._~%!$&'()*+,;="
#endif
#define PATH ":@/ "
      "^([[:alpha:]][-+.[:alnum:]]+):"             // . scheme
      "("                                          // . rest
        "("                                        // . . authority + path
                                                   // . . or path only
          "(//"                                    // . . . authority + path
            "("                                    // . . . . user info
              "([" UNR_PCTENC_SUBDEL "@-]*)"       // . . . . . user name + '@'
              "(:([" UNR_PCTENC_SUBDEL "-]*))?"    // . . . . . password
            "@)?"
            "("                                    // . . . . host
              "([" UNR_PCTENC_SUBDEL "-]*)"        // . . . . . host name
              "|"
              "(\\[[[:xdigit:]:.]+\\])"            // . . . . . IPv4 or IPv6
            ")"
            "(:([[:digit:]]+))?"                   // . . . . port
            "(/([" UNR_PCTENC_SUBDEL PATH "-]*))?" // . . . . path
          ")"
          "|"
          "("                                      // . . . path only
            "[" UNR_PCTENC_SUBDEL PATH "-]*"       // . . . . path
          ")"
        ")"
        // Should be: "(\\?([" UNR_PCTENC_SUBDEL PATH "?-]*))?"
        "(\\?([^#]*))?"                            // . . query
      ")$"
#undef PATH
#undef UNR_PCTENC_SUBDEL
    },
    {
      PREX_URL_QUERY_KEY_VAL,
      PREX_URL_QUERY_KEY_VAL_MATCH_MAX,
#define QUERY_PART "^&=" // Should be: "-[:alnum:]._~%!$'()*+,;:@/"
      "([" QUERY_PART "]+)=([" QUERY_PART "]+)"   // query + ' '
#undef QUERY_PART
    },
    {
      PREX_RFC2047_ENCODED_WORD,
      PREX_RFC2047_ENCODED_WORD_MATCH_MAX,
      "=\\?"
      "([^][()<>@,;:\\\"/?. =]+)" // charset
      "\\?"
      "([qQbB])" // encoding
      "\\?"
      "([^?]+)" // encoded text - we accept whitespace, see #1189
      "\\?="
    },
    {
      PREX_GNUTLS_CERT_HOST_HASH,
      PREX_GNUTLS_CERT_HOST_HASH_MATCH_MAX,
      "^\\#H ([[:alnum:]_\\.-]+) ([[:alnum:]]{4}( [[:alnum:]]{4}){7})[ \t]*$"
    },
    {
      PREX_RFC5322_DATE,
      PREX_RFC5322_DATE_MATCH_MAX,
      /* Spec: https://tools.ietf.org/html/rfc5322#section-3.3 */
      "^"
        "(" PREX_DOW ", )?"       // Day of week
        " *"
        "([[:digit:]]{1,2}) "     // Day
        PREX_MONTH                // Month
        " ([[:digit:]]{2,4}) "    // Year
        "([[:digit:]]{2})"        // Hour
        ":([[:digit:]]{2})"       // Minute
        "(:([[:digit:]]{2}))?"    // Second
        " *"
        "("
        "([+-][[:digit:]]{4})|"   // TZ
        "([[:alpha:]]+)"          // Obsolete TZ
        ")"
    },
    {
      PREX_RFC5322_DATE_LAX,
      PREX_RFC5322_DATE_LAX_MATCH_MAX,
      /* Spec: https://tools.ietf.org/html/rfc5322#section-3.3 */
#define FWS " *"
#define C "(\\(.*\\))?"
#define CFWS FWS C FWS
      "^"
        CFWS
        "(([[:alpha:]]+)" CFWS ", *)?"   // Day of week (or whatever)
        CFWS "([[:digit:]]{1,2}) "       // Day
        CFWS PREX_MONTH                  // Month
        CFWS "([[:digit:]]{2,4}) "       // Year
        CFWS "([[:digit:]]{1,2})"        // Hour
        ":" CFWS "([[:digit:]]{1,2})"    // Minute
        CFWS
        "(:" CFWS "([[:digit:]]{1,2}))?" // Second
        CFWS
        "("
        "([+-][[:digit:]]{4})|"          // TZ
        "([[:alpha:]]+)"                 // Obsolete TZ
        ")?"
#undef CFWS
#undef C
#undef FWS
    },
    {
      PREX_IMAP_DATE,
      PREX_IMAP_DATE_MATCH_MAX,
      "( ([[:digit:]])|([[:digit:]]{2}))" // Day
      "-" PREX_MONTH                      // Month
      "-" PREX_YEAR                       // Year
      " " PREX_TIME                       // Time
      " ([+-][[:digit:]]{4})"             // TZ
    },
    {
      PREX_MBOX_FROM,
      PREX_MBOX_FROM_MATCH_MAX,
      /* Spec: http://qmail.omnis.ch/man/man5/mbox.html */
      "^From "                 // From
      "([^[:space:]]+) +"      // Sender
      PREX_DOW                 // Day of week
      " +"
      PREX_MONTH               // Month
      " ( ([[:digit:]])|([[:digit:]]{2}))" // Day
      " +"
      PREX_TIME                // Time
      " +"
      PREX_YEAR                // Year
    },
    {
      PREX_MBOX_FROM_LAX,
      PREX_MBOX_FROM_LAX_MATCH_MAX,
      /* Spec: http://qmail.omnis.ch/man/man5/mbox.html */
      "^From "                  // From
      "("
        "[^[:space:]]+"         // Sender
        "( at [^[:space:]]+)?" // Possibly obfuscated, pipermail-style
      ")?"
      " *"
      PREX_DOW_NOCASE           // Day of week
      " +"
      PREX_MONTH                // Month
      " +"
      "( "                      // Day
        "([[:digit:]])|"
        "([[:digit:]]{2})"
      ")"
      " +"
      "("
        PREX_TIME               // Time (HH:MM:SS)
        "|"
        "([[:digit:]]{2}"       // Time (HH:MM)
        ":[[:digit:]]{2})"
      ")"
      " +"
      "([[:alpha:] ]*)"         // Timezone (which we skip)
      "("
        PREX_YEAR               // Year (YYYY)
        "|"
        "([[:digit:]]{2})"      // Year (YY)
      ")"
    }
    /* clang-format on */
  };

  assert((which >= 0) && (which < PREX_MAX) && "Invalid 'which' argument");
  struct PrexStorage *h = &storage[which];
  assert((which == h->which) && "Fix 'storage' array");
  if (!h->re)
  {
#ifdef HAVE_PCRE2
    uint32_t opt = pcre2_has_unicode() ? PCRE2_UTF : 0;
    int eno;
    PCRE2_SIZE eoff;
    h->re = pcre2_compile((PCRE2_SPTR8) h->str, PCRE2_ZERO_TERMINATED, opt,
                          &eno, &eoff, NULL);
    assert(h->re && "Fix your RE");
    h->mdata = pcre2_match_data_create_from_pattern(h->re, NULL);
    uint32_t ccount;
    pcre2_pattern_info(h->re, PCRE2_INFO_CAPTURECOUNT, &ccount);
    assert(ccount + 1 == h->nmatches && "Number of matches do not match (...)");
    h->matches = mutt_mem_calloc(h->nmatches, sizeof(*h->matches));
#else
    h->re = mutt_mem_calloc(1, sizeof(*h->re));
    const int rc = regcomp(h->re, h->str, REG_EXTENDED);
    assert(rc == 0 && "Fix your RE");
    h->matches = mutt_mem_calloc(h->nmatches, sizeof(*h->matches));
#endif
  }
  return h;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_prex_capture()

regmatch_t* mutt_prex_capture	(	enum Prex	which,
		const char *	str
	)

match a precompiled regex against a string

Parameters

which	Which regex to return
str	String to apply regex on

Return values

ptr	Pointer to an array of matched captures
NULL	Regex didn't match

Definition at line 301 of file prex.c.

{
  if (!str)
    return NULL;

  struct PrexStorage *h = prex(which);
#ifdef HAVE_PCRE2
  size_t len = strlen(str);
  int rc = pcre2_match(h->re, (PCRE2_SPTR8) str, len, 0, 0, h->mdata, NULL);
  if (rc < 0)
  {
    PCRE2_UCHAR errmsg[1024];
    pcre2_get_error_message(rc, errmsg, sizeof(errmsg));
    mutt_debug(LL_DEBUG2, "pcre2_match - <%s> -> <%s> =  %s\n", h->str, str, errmsg);
    return NULL;
  }
  PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(h->mdata);
  int i = 0;
  for (; i < rc; i++)
  {
    h->matches[i].rm_so = ovector[i * 2];
    h->matches[i].rm_eo = ovector[i * 2 + 1];
  }
  for (; i < h->nmatches; i++)
  {
    h->matches[i].rm_so = -1;
    h->matches[i].rm_eo = -1;
  }
#else
  if (regexec(h->re, str, h->nmatches, h->matches, 0))
    return NULL;

  assert((h->re->re_nsub == (h->nmatches - 1)) &&
         "Regular expression and matches enum are out of sync");
#endif
  return h->matches;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_prex_free()

void mutt_prex_free

(

void

)

Cleanup heap memory allocated by compiled regexes.

Definition at line 342 of file prex.c.

{
  for (enum Prex which = 0; which < PREX_MAX; which++)
  {
    struct PrexStorage *h = prex(which);
#ifdef HAVE_PCRE2
    pcre2_match_data_free(h->mdata);
    pcre2_code_free(h->re);
#else
    regfree(h->re);
    FREE(&h->re);
#endif
    FREE(&h->matches);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: