regexp.c File Reference

Implementation of regular expression routines. More...

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include "util.h"
#include "regexp.h"

Go to the source code of this file.

Functions
const char *	regexp_error_string (int error)
	Convert a pcre regular expression error code into a string.
int	regexp_compile (struct regexp_t *regexp)
	Compile a PCRE regular expression into an optimized format for subsequent execution.
int	regexp_search (struct regexp_t *regexp, const char *subject)
	Execute a PCRE regular search against the subject string.
int	regexp_substring (struct regexp_t *regexp, const int match_number, char *buffer, int buffer_size)
	Get the substring matched by a specific match group.
int	regexp_free (struct regexp_t *regexp)
	Release the resources associated with a regular expression object.

---

Detailed Description

Implementation of regular expression routines.

Definition in file regexp.c.

---

Function Documentation

int regexp_compile

(

struct regexp_t *

regexp

)

Compile a PCRE regular expression into an optimized format for subsequent execution.

Parameters:

[out]

regexp

Pointer to variable to receive compiled regular expression

Returns:

SUCCESS (0) or non-zero error code otherwise

Definition at line 102 of file regexp.c.

Referenced by regexp_init().

{
    const char *error_str;
    int error_code, error_offset;

    if ((regexp->re = pcre_compile2(regexp->pattern, 0, &error_code,
                                    &error_str, &error_offset, NULL)) == NULL) {
        int i;
        char *ruler = malloc(error_offset + 2);

        if (ruler) {            /* point to where error is in pattern */
            for (i = 0; i < error_offset; i++) ruler[i] = ' ';
            ruler[error_offset] = '^';
            ruler[error_offset + 1] = 0;
        }

        log_msg(LOG_ERROR, _("regexp compilation failed at offset %d\n%s\n%s %s\n"),
                error_offset, regexp->pattern, ruler, error_str);
        free(ruler);
        return error_code;
    }
    return SUCCESS;
}

const char* regexp_error_string

(

int

error

)

Convert a pcre regular expression error code into a string.

Parameters:

[in]

error

The error code whose string representation is desired

Returns:

Pointer to static string

Definition at line 66 of file regexp.c.

Referenced by regexp_search(), and regexp_substring().

{
    switch(error) {
    case PCRE_ERROR_NOMATCH:        return "PCRE_ERROR_NOMATCH";
    case PCRE_ERROR_NULL:           return "PCRE_ERROR_NULL";
    case PCRE_ERROR_BADOPTION:      return "PCRE_ERROR_BADOPTION";
    case PCRE_ERROR_BADMAGIC:       return "PCRE_ERROR_BADMAGIC";
    case PCRE_ERROR_UNKNOWN_OPCODE: return "PCRE_ERROR_UNKNOWN_OPCODE";
    case PCRE_ERROR_NOMEMORY:       return "PCRE_ERROR_NOMEMORY";
    case PCRE_ERROR_NOSUBSTRING:    return "PCRE_ERROR_NOSUBSTRING";
    case PCRE_ERROR_MATCHLIMIT:     return "PCRE_ERROR_MATCHLIMIT";
    case PCRE_ERROR_CALLOUT:        return "PCRE_ERROR_CALLOUT";
    case PCRE_ERROR_BADUTF8:        return "PCRE_ERROR_BADUTF8";
    case PCRE_ERROR_BADUTF8_OFFSET: return "PCRE_ERROR_BADUTF8_OFFSET";
    case PCRE_ERROR_PARTIAL:        return "PCRE_ERROR_PARTIAL";
    case PCRE_ERROR_BADPARTIAL:     return "PCRE_ERROR_BADPARTIAL";
    case PCRE_ERROR_INTERNAL:       return "PCRE_ERROR_INTERNAL";
    case PCRE_ERROR_BADCOUNT:       return "PCRE_ERROR_BADCOUNT";
    case PCRE_ERROR_DFA_UITEM:      return "PCRE_ERROR_DFA_UITEM";
    case PCRE_ERROR_DFA_UCOND:      return "PCRE_ERROR_DFA_UCOND";
    case PCRE_ERROR_DFA_UMLIMIT:    return "PCRE_ERROR_DFA_UMLIMIT";
    case PCRE_ERROR_DFA_WSSIZE:     return "PCRE_ERROR_DFA_WSSIZE";
    case PCRE_ERROR_DFA_RECURSE:    return "PCRE_ERROR_DFA_RECURSE";
    case PCRE_ERROR_RECURSIONLIMIT: return "PCRE_ERROR_RECURSIONLIMIT";
    case PCRE_ERROR_NULLWSLIMIT:    return "PCRE_ERROR_NULLWSLIMIT";
    case PCRE_ERROR_BADNEWLINE:     return "PCRE_ERROR_BADNEWLINE";
    default:                        return "unknown";
    }
}

int regexp_free

(

struct regexp_t *

regexp

)

Release the resources associated with a regular expression object.

Parameters:

[in]

regexp

Pointer to a pointer to a regular expression object

Returns:

SUCCESS (0) or non-zero error code otherwise

Definition at line 194 of file regexp.c.

Referenced by regexp_fini().

{
    if (regexp->re) pcre_free(regexp->re);
    return SUCCESS;
}

int regexp_search	(	struct regexp_t *	regexp,
		const char *	subject
	)

Execute a PCRE regular search against the subject string.

Parameters:

[in]	regexp	Previously compiled regular expression object
[in]	subject	The string which is being searched for the regular expression match

Returns:

The number of matches found

Definition at line 135 of file regexp.c.

Referenced by is_log_backup().

{
    int result;

    regexp->subject = subject;
    result = pcre_exec(regexp->re, NULL,
                       subject, strlen(subject), 0, 0,
                       regexp->matches, sizeof(regexp->matches)/sizeof(int));

    if (result < 0) {
        regexp->num_matches = 0;
        regexp->error = result;
        if (result != PCRE_ERROR_NOMATCH) {
            log_msg(LOG_ERROR, _("regexp_search failed, error=%s(%d) pattern=\"%s\" subject=\"%s\"\n"),
                    regexp_error_string(regexp->error), regexp->error, regexp->pattern, subject);
        }

    } else {
        regexp->num_matches = result;
        regexp->error = 0;
    }
    return regexp->num_matches;
}

int regexp_substring	(	struct regexp_t *	regexp,
		const int	match_number,
		char *	buffer,
		int	buffer_size
	)

Get the substring matched by a specific match group.

Parameters:

[in]	regexp	The regular expression object
[in]	match_number	The index of the match group
[out]	buffer	The substring is written into this location
[in]	buffer_size	The size of the buffer to receive the substring

Returns:

SUCCESS (0) or non-zero error code otherwise

Definition at line 168 of file regexp.c.

Referenced by is_log_backup().

{
    if (buffer && buffer_size > 0) buffer[0] = 0; /* always NULL terminate buffer */

    if (match_number >= regexp->num_matches) {
        return PCRE_ERROR_NOSUBSTRING;
    }

    if ((regexp->error = pcre_copy_substring(regexp->subject, regexp->matches, regexp->num_matches,
                                     match_number, buffer, buffer_size)) < 0) {
        log_msg(LOG_ERROR, _("regexp_substring failed, match_number=%d num_matches=%d error=%s(%d) pattern=\"%s\" subject=\"%s\"\n"),
                match_number, regexp->num_matches,
                regexp_error_string(regexp->error), regexp->error, regexp->pattern, regexp->subject);
        return regexp->error;
    }
    return SUCCESS;
}