/*

* ModSecurity for Apache 2.x, http://www.modsecurity.org/

* Copyright (c) 2004-2013 Trustwave Holdings, Inc. (http://www.trustwave.com/)

*

* You may not use this file except in compliance with

* the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* If any of the files related to licensing are missing or if you have any

* other questions related to licensing please contact Trustwave Holdings, Inc.

* directly using the email address security@modsecurity.org.

*/

#include "modsecurity.h"

#include <ctype.h>

#include <fcntl.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "msc_release.h"

#include "msc_util.h"

#include <apr_lib.h>

#include <apr_sha1.h>

#include "modsecurity_config.h"

#include "msc_remote_rules.h"

#ifdef WITH_CURL

#include "curl/curl.h"

#endif

/**

 * NOTE: Be careful as these can ONLY be used on static values for X.

 * (i.e. VALID_HEX(c++) will NOT work)

 */

#define VALID_HEX(X) (((X >= '0')&&(X <= '9')) || ((X >= 'a')&&(X <= 'f')) || ((X >= 'A')&&(X <= 'F')))

#define ISODIGIT(X) ((X >= '0')&&(X <= '7'))

#if (defined(WIN32) || defined(NETWARE))

/** Windows does not define all the octal modes */

#define S_IXOTH 00001

#define S_IWOTH 00002

#define S_IROTH 00004

#define S_IXGRP 00010

#define S_IWGRP 00020

#define S_IRGRP 00040

#define S_IXUSR 00100

#define S_IWUSR 00200

#define S_IRUSR 00400

#define S_ISVTX 01000

#define S_ISGID 02000

#define S_ISUID 04000

#endif /* defined(WIN32 || NETWARE) */

/* Base64 tables used in decodeBase64Ext */

static const char b64_pad = '=';

static const short b64_reverse_t[256] = {

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -2, -2, -1, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, -2, -2, 63,

  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -2, -2, -2,

  -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, -2,

  -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,

  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

  -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2

};

static unsigned char *c2x(unsigned what, unsigned char *where);

static unsigned char x2c(unsigned char *what);

static unsigned char xsingle2c(unsigned char *what);

#ifdef LINUX_S390

int swap_int32(int x) {

    int swap = ((x>>24)&0xff) | ((x<<8)&0xff0000) |

                ((x>>8)&0xff00) | ((x<<24)&0xff000000);

    return swap;

}

#endif

/** \brief Decode utf-8 to unicode format.

 *

 * \param mp Pointer to memory pool

 * \param input Pointer to input data

 * \param input_len Input data length

 * \param changed Set if data is changed

 *

 * \retval rval On Success

 */

char *utf8_unicode_inplace_ex(apr_pool_t *mp, unsigned char *input, long int input_len, int *changed) {

    int unicode_len = 0, length = 0;

    unsigned int d = 0, count = 0;

    unsigned char c, *utf;

    char *rval, *data;

    unsigned int i, len, j;

    unsigned int bytes_left = input_len;

    unsigned char *unicode = NULL;

    *changed = 0;

    len = input_len * 7 + 1;

    data = rval = apr_palloc(mp, len);

    if (rval == NULL) return NULL;

    if (input == NULL) return NULL;

    for(i = 0; i < bytes_left;)  {

        unicode_len = 0; d = 0;

        utf = (unsigned char *)&input[i];

        c = *utf;

        /* If first byte begins with binary 0 it is single byte encoding */

        if ((c & 0x80) == 0) {

            /* single byte unicode (7 bit ASCII equivilent) has no validation */

            count++;

            if(count <= len)    {

                if(c == 0)

                    *data = x2c(&c);

                else

                    *data++ = c;

            }

        }

        /* If first byte begins with binary 110 it is two byte encoding*/

        else if ((c & 0xE0) == 0xC0) {

            /* check we have at least two bytes */

            if (bytes_left < 2) unicode_len = UNICODE_ERROR_CHARACTERS_MISSING;

            /* check second byte starts with binary 10 */

            else if (((*(utf + 1)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            else {

                unicode_len = 2;

                count+=6;

                if(count <= len) {

                    /* compute character number */

                    d = ((c & 0x1F) << 6) | (*(utf + 1) & 0x3F);

                    *data++ = '%';

                    *data++ = 'u';

                    unicode = apr_psprintf(mp, "%x", d);

                    length = strlen(unicode);

                    switch(length)  {

                        case 1:

                            *data++ = '0';

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 2:

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 3:

                            *data++ = '0';

                            break;

                        case 4:

                        case 5:

                            break;

                    }

                    for(j=0; j

                        *data++ = unicode[j];

                    }

                    *changed = 1;

                }

            }

        }

        /* If first byte begins with binary 1110 it is three byte encoding */

        else if ((c & 0xF0) == 0xE0) {

            /* check we have at least three bytes */

            if (bytes_left < 3) unicode_len = UNICODE_ERROR_CHARACTERS_MISSING;

            /* check second byte starts with binary 10 */

            else if (((*(utf + 1)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            /* check third byte starts with binary 10 */

            else if (((*(utf + 2)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            else {

                unicode_len = 3;

                count+=6;

                if(count <= len) {

                    /* compute character number */

                    d = ((c & 0x0F) << 12) | ((*(utf + 1) & 0x3F) << 6) | (*(utf + 2) & 0x3F);

                    *data++ = '%';

                    *data++ = 'u';

                    unicode = apr_psprintf(mp, "%x", d);

                    length = strlen(unicode);

                    switch(length)  {

                        case 1:

                            *data++ = '0';

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 2:

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 3:

                            *data++ = '0';

                            break;

                        case 4:

                        case 5:

                            break;

                    }

                    for(j=0; j

                        *data++ = unicode[j];

                    }

                    *changed = 1;

                }

            }

        }

        /* If first byte begins with binary 11110 it is four byte encoding */

        else if ((c & 0xF8) == 0xF0) {

            /* restrict characters to UTF-8 range (U+0000 - U+10FFFF)*/

            if (c >= 0xF5) {

                *data++ = c;

            }

            /* check we have at least four bytes */

            if (bytes_left < 4) unicode_len = UNICODE_ERROR_CHARACTERS_MISSING;

            /* check second byte starts with binary 10 */

            else if (((*(utf + 1)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            /* check third byte starts with binary 10 */

            else if (((*(utf + 2)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            /* check forth byte starts with binary 10 */

            else if (((*(utf + 3)) & 0xC0) != 0x80) unicode_len = UNICODE_ERROR_INVALID_ENCODING;

            else {

                unicode_len = 4;

                count+=7;

                if(count <= len) {

                    /* compute character number */

                    d = ((c & 0x07) << 18) | ((*(utf + 1) & 0x3F) << 12) | ((*(utf + 2) & 0x3F) << 6) | (*(utf + 3) & 0x3F);

                    *data++ = '%';

                    *data++ = 'u';

                    unicode = apr_psprintf(mp, "%x", d);

                    length = strlen(unicode);

                    switch(length)  {

                        case 1:

                            *data++ = '0';

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 2:

                            *data++ = '0';

                            *data++ = '0';

                            break;

                        case 3:

                            *data++ = '0';

                            break;

                        case 4:

                        case 5:

                            break;

                    }

                    for(j=0; j

                        *data++ = unicode[j];

                    }

                    *changed = 1;

                }

            }

        }

        /* any other first byte is invalid (RFC 3629) */

        else {

            count++;

            if(count <= len)

                *data++ = c;

        }

        /* invalid UTF-8 character number range (RFC 3629) */

        if ((d >= 0xD800) && (d <= 0xDFFF)) {

            count++;

            if(count <= len)

                *data++ = c;

        }

        /* check for overlong */

        if ((unicode_len == 4) && (d < 0x010000)) {

            /* four byte could be represented with less bytes */

            count++;

            if(count <= len)

                *data++ = c;

        }

        else if ((unicode_len == 3) && (d < 0x0800)) {

            /* three byte could be represented with less bytes */

            count++;

            if(count <= len)

                *data++ = c;

        }

        else if ((unicode_len == 2) && (d < 0x80)) {

            /* two byte could be represented with less bytes */

            count++;

            if(count <= len)

                *data++ = c;

        }

        if(unicode_len > 0) {

            i += unicode_len;

        } else {

            i++;

        }

    }

    *data ='\0';

    return rval;

}

/** \brief Validate IPv4 Netmask

 *

 * \param ip_strv6 Pointer to ipv6 address

 *

 * \retval netmask_v4 On Success

 */

unsigned char is_netmask_v4(char *ip_strv4) {

    unsigned char netmask_v4 = 32;

    char *mask_str = NULL;

    int cidr;

    if(ip_strv4 == NULL)

        return netmask_v4;

    if ((mask_str = strchr(ip_strv4, '/'))) {

        *(mask_str++) = '\0';

        if (strchr(mask_str, '.') != NULL) {

            return 0;

        }

        cidr = atoi(mask_str);

        if ((cidr < 0) || (cidr > 32)) {

            return 0;

        }

        netmask_v4 = (unsigned char)cidr;

    }

    return netmask_v4;

}

/** \brief Validate IPv6 Netmask

 *

 * \param ip_strv6 Pointer to ipv6 address

 *

 * \retval netmask_v6 On Success

 */

unsigned char is_netmask_v6(char *ip_strv6) {

    unsigned char netmask_v6 = 128;

    char *mask_str = NULL;

    int cidr;

    if(ip_strv6 == NULL)

        return netmask_v6;

    if ((mask_str = strchr(ip_strv6, '/'))) {

        *(mask_str++) = '\0';

        if (strchr(mask_str, ':') != NULL) {

            return 0;

        }

        cidr = atoi(mask_str);

        if ((cidr < 0) || (cidr > 128)) {

            return 0;

        }

        netmask_v6 = (unsigned char)cidr;

    }

    return netmask_v6;

}

/** \brief Interpret |HEX| syntax

 *

 * \param op_parm Pointer to operator input

 * \param op_len Operator input lenght

 * \param rule Pointer to rule struct

 * \param error_msg Pointer to error message

 *

 * \retval string On Success

 */

char *parse_pm_content(const char *op_parm, unsigned short int op_len, msre_rule *rule, char **error_msg)  {

    char *parm = NULL;

    char *content = NULL;

    unsigned short int offset = 0;

    char converted = 0;

    int i, x;

    unsigned char bin = 0, esc = 0, bin_offset = 0;

    unsigned char bin_parm[3], c = 0;

    char *processed = NULL;

    content = apr_pstrdup(rule->ruleset->mp, op_parm);

    if (content == NULL) {

        *error_msg = apr_psprintf(rule->ruleset->mp, "Error allocating memory for pattern matching content.");

        return NULL;

    }

    while (offset < op_len && apr_isspace(content[offset])) {

        offset++;

    };

    op_len = strlen(content);

    if (content[offset] == '\"' && content[op_len-1] == '\"') {

        parm = apr_pstrdup(rule->ruleset->mp, content + offset + 1);

        if (parm  == NULL) {

            *error_msg = apr_psprintf(rule->ruleset->mp, "Error allocating memory for pattern matching content.");

            return NULL;

        }

        parm[op_len - offset - 2] = '\0';

    } else {

        parm = apr_pstrdup(rule->ruleset->mp, content + offset);

        if (parm == NULL) {

            *error_msg = apr_psprintf(rule->ruleset->mp, "Error allocating memory for pattern matching content.");

            return NULL;

        }

    }

    op_len = strlen(parm);

    if (op_len == 0)   {

        *error_msg = apr_psprintf(rule->ruleset->mp, "Content length is 0.");

        return NULL;

    }

    for (i = 0, x = 0; i < op_len; i++) {

        if (parm[i] == '|') {

            if (bin) {

                bin = 0;

            } else {

                bin = 1;

            }

        } else if(!esc && parm[i] == '\\') {

            esc = 1;

        } else {

            if (bin) {

                if (apr_isdigit(parm[i]) ||

                        parm[i] == 'A' || parm[i] == 'a' ||

                        parm[i] == 'B' || parm[i] == 'b' ||

                        parm[i] == 'C' || parm[i] == 'c' ||

                        parm[i] == 'D' || parm[i] == 'd' ||

                        parm[i] == 'E' || parm[i] == 'e' ||

                        parm[i] == 'F' || parm[i] == 'f')

                {

                    bin_parm[bin_offset] = (char)parm[i];

                    bin_offset++;

                    if (bin_offset == 2) {

                        c = strtol((char *)bin_parm, (char **) NULL, 16) & 0xFF;

                        bin_offset = 0;

                        parm[x] = c;

                        x++;

                        converted = 1;

                    }

                } else if (parm[i] == ' ') {

                }

            } else if (esc) {

                if (parm[i] == ':' ||

                        parm[i] == ';' ||

                        parm[i] == '\\' ||

                        parm[i] == '\"')

                {

                    parm[x] = parm[i];

                    x++;

                } else {

                    *error_msg = apr_psprintf(rule->ruleset->mp, "Unsupported escape sequence.");

                    return NULL;

                }

                esc = 0;

                converted = 1;

            } else {

                parm[x] = parm[i];

                x++;

            }

        }

    }

    if (converted) {

        op_len = x;

    }

    processed = apr_pstrmemdup(rule->ruleset->mp, parm, op_len);

    if (processed == NULL) {

        *error_msg = apr_psprintf(rule->ruleset->mp, "Error allocating memory for pattern matching content.");

        return NULL;

    }

    return processed;

}

/** \brief Remove quotes

 *

 * \param mptmp Pointer to the pool

 * \param input Pointer to input string

 * \param input_len Input data length

 *

 * \retval string On Success

 */

char *remove_quotes(apr_pool_t *mptmp, const char *input, int input_len)  {

    char *parm = apr_palloc(mptmp, input_len);

    char *ret = parm;

    int len = input_len;

    for(; *input !='\0' && len >=0; input++, len--)    {

        if(*input != '\'' && *input != '\"')    {

            *parm++ = *input;

        }

    }

    *parm = '\0';

    return ret;

}

/** \brief Remove escape char

 *

 * \param mptmp Pointer to the pool

 * \param input Pointer to input string

 * \param input_len Input data length

 *

 * \retval string On Success

 */

char *remove_escape(apr_pool_t *mptmp, const char *input, int input_len)  {

    char *parm = apr_palloc(mptmp, input_len);

    char *ret = parm;

    int len = input_len;

    for(; *input !='\0' && len >=0; input++, len--)    {

        if(*input != '\\')    {

            *parm++ = *input;

        }

    }

    *parm = '\0';

    return ret;

}

/**

 *

 */

int parse_boolean(const char *input) {

    if (input == NULL) return -1;

    if (strcasecmp(input, "on") == 0) return 1;

    if (strcasecmp(input, "true") == 0) return 1;

    if (strcasecmp(input, "1") == 0) return 1;

    if (strcasecmp(input, "off") == 0) return 0;

    if (strcasecmp(input, "false") == 0) return 0;

    if (strcasecmp(input, "0") == 0) return 0;

    return -1;

}

/** \brief Decode Base64 data with special chars

 *

 * \param plain_text Pointer to plain text data

 * \param input Pointer to input data

 * \param input_len Input data length

 *

 * \retval 0 On failure

 * \retval string length On Success

 */

int decode_base64_ext(char *plain_text, const unsigned char *input, int input_len)   {

    const unsigned char *encoded = input;

    int i = 0, j = 0, k = 0;

    int ch = 0;

    while ((ch = *encoded++) != '\0' && input_len-- > 0) {

        if (ch == b64_pad) {

            if (*encoded != '=' && (i % 4) == 1) {

                return 0;

            }

            continue;

        }

        ch = b64_reverse_t[ch];

        if (ch < 0 || ch == -1) {

            continue;

        } else if (ch == -2) {

            return 0;

        }

        switch(i % 4) {

            case 0:

                plain_text[j] = ch << 2;

                break;

            case 1:

                plain_text[j++] |= ch >> 4;

                plain_text[j] = (ch & 0x0f) << 4;

                break;

            case 2:

                plain_text[j++] |= ch >>2;

                plain_text[j] = (ch & 0x03) << 6;

                break;

            case 3:

                plain_text[j++] |= ch;

                break;

        }

        i++;

    }

    k = j;

    if (ch == b64_pad) {

        switch(i % 4) {

            case 1:

                return 0;

            case 2:

                k++;

            case 3:

                plain_text[k] = 0;

        }

    }

    plain_text[j] = '\0';

    return j;

}

/** \brief Convert const char to int

 *

 * \param c number string

 *

 * \retval n The converted number

 */

int convert_to_int(const char c)

{

    int n;

    if ((c>='0') && (c<='9'))

        n = c - '0';

    else if ((c>='A') && (c<='F'))

        n = c - 'A' + 10;

    else if ((c>='a') && (c<='f'))

        n = c - 'a' + 10;

    else

        n = 0;

    return n;

}

/** \brief Set a match to tx.N

 *

 * \param msr Pointer to modsec resource

 * \param capture If ON match will be saved

 * \param match Pointer to captured string

 *\parm tx_n The tx number to save the data

 *

 * \retval 0 On Sucess|Fail

 */

int set_match_to_tx(modsec_rec *msr, int capture, const char *match, int tx_n)  {

    if (capture) {

        msc_string *s = (msc_string *)apr_pcalloc(msr->mp, sizeof(msc_string));

        if (s == NULL) return -1;

        s->name = apr_psprintf(msr->mp,"%d", tx_n);

        s->name_len = strlen(s->name);

        s->value = apr_pstrdup(msr->mp, match);

        if (s->value == NULL) return -1;

        s->value_len = strlen(s->value);

        apr_table_setn(msr->tx_vars, s->name, (void *)s);

        if (msr->txcfg->debuglog_level >= 9) {

            msr_log(msr, 9, "Added phrase match to TX.%d: %s",

                    tx_n, log_escape_nq_ex(msr->mp, s->value, s->value_len));

        }

    }

    return 0;

}

/**

 * Parses a string that contains a name-value pair in the form "name=value".

 * IMP1 It does not check for whitespace between tokens.

 */

int parse_name_eq_value(apr_pool_t *mp, const char *input, char **name, char **value) {

    char *p = NULL;

    if ((name == NULL)||(value == NULL)) return -1;

    if (input == NULL) return 0;

    *name = NULL;

    *value = NULL;

    p = (char *)input;

    while((*p != '=')&&(*p != '\0')) p++;

    if (*p == '\0') {

        *name = (char *)input;

        return 1;

    }

    *name = apr_pstrmemdup(mp, input, p - input);

    if (*name == NULL) return -1;

    p++;

    *value = apr_pstrdup(mp, p);

    if (*value == NULL) return -1;

    return 1;

}

/**

 *

 * IMP1 Assumes NUL-terminated

 */

char *url_encode(apr_pool_t *mp, char *input, unsigned int input_len, int *changed) {

    char *rval, *d;

    unsigned int i, len;

    *changed = 0;

    len = input_len * 3 + 1;

    d = rval = apr_palloc(mp, len);

    if (rval == NULL) return NULL;

    /* ENH Only encode the characters that really need to be encoded. */

    for(i = 0; i < input_len; i++) {

        unsigned char c = input[i];

        if (c == ' ') {

            *d++ = '+';

            *changed = 1;

        } else

            if ( (c == 42) || ((c >= 48)&&(c <= 57)) || ((c >= 65)&&(c <= 90))

                    || ((c >= 97)&&(c <= 122))

               ) {

                *d++ = c;

            } else {

                *d++ = '%';

                c2x(c, (unsigned char *)d);

                d += 2;

                *changed = 1;

            }

    }

    *d = '\0';

    return rval;

}

/**

 * Appends an URL-encoded version of the source string to the

 * destination string, but makes sure that no more than "maxlen"

 * bytes are added.

 */

char *strnurlencat(char *destination, char *source, unsigned int maxlen) {

    char *s = source;

    char *d = destination;

    /* ENH Only encode the characters that really need to be encoded. */

    /* Advance to the end of destination string. */

    while(*d != '\0') d++;

    /* Loop while there's bytes in the source string or

     * until we reach the output limit.

     */

    while((*s != '\0')&&(maxlen > 0)) {

        unsigned char c = *s;

        if (c == ' ') {

            *d++ = '+';

            maxlen--;

        } else

            if ( (c == 42) || ((c >= 48)&&(c <= 57)) || ((c >= 65)&&(c <= 90))

                    || ((c >= 97)&&(c <= 122))

               ) {

                *d++ = c;

                maxlen--;

            } else {

                if (maxlen >= 3) {

                    *d++ = '%';

                    c2x(c, (unsigned char *)d);

                    d += 2;

                    maxlen -= 3;

                } else {

                    /* If there's not enough room for the encoded

                     * byte we ignore it.

                     */

                    maxlen = 0;

                }

            }

        s++;

    }

    *d++ = '\0';

    return destination;

}

/**

 *

 */

char *file_basename(apr_pool_t *mp, const char *filename) {

    char *d, *p;

    if (filename == NULL) return NULL;

    d = apr_pstrdup(mp, filename);

    if (d == NULL) return NULL;

    p = strrchr(d, '/');

    if (p != NULL) d = p + 1;

    p = strrchr(d, '\\');

    if (p != NULL) d = p + 1;

    return d;

}

char *m_strcasestr(const char *haystack, const char *needle) {

    char aux, lower_aux;

    int length;

    if ((aux = *needle++) != 0) {

        aux = (char)tolower((unsigned char)aux);

        length = strlen(needle);

        do {

            do {

                if ((lower_aux = *haystack++) == 0)

                    return NULL;

            } while ((char)tolower((unsigned char)lower_aux) != aux);

        } while (strncasecmp(haystack, needle, length) != 0);

        haystack--;

    }

    return ((char *)haystack);

}

#ifdef WIN32

#if !(NTDDI_VERSION >= NTDDI_VISTA)

int inet_pton(int family, const char *src, void *dst)   {

    struct addrinfo addr;

    struct sockaddr_in *in = NULL;

#if APR_HAVE_IPV6

    struct sockaddr_in6 *in6 = NULL;

#endif

    struct addrinfo *addr_info = NULL;

    memset(&addr, 0, sizeof(struct addrinfo));

    addr.ai_family = family;

    if (getaddrinfo(src, NULL, &addr, &addr_info) != 0)

        return -1;

    if (addr_info) {

        if (addr_info->ai_family == AF_INET) {

            in = (struct sockaddr_in*)addr_info->ai_addr;

            if(in != NULL)

                memcpy(dst, &in->sin_addr, 4);

        }

#if APR_HAVE_IPV6

        else if (addr_info->ai_family == AF_INET6) {

            in6 = (struct sockaddr_in6*)addr_info->ai_addr;

            if(in6 != NULL)

                memcpy(dst, &in6->sin6_addr, 16);

        }

#endif

        else {

            freeaddrinfo(addr_info);

            return -1;

        }

        freeaddrinfo(addr_info);

        return 1;