conf.c

Go to the documentation of this file.

/*
 * $Id$
 *
 * Copyright (C) 2009 1&1 Internet AG
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio 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
 *
 * Kamailio 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, write to the Free Software 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "conf.h"
#include "../../mem/mem.h"
#include "../../mem/shm_mem.h"
#include "../../sr_module.h"
#include "../../proxy.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define BUFSIZE 1000

enum {
        sfidx_request = 0,
        sfidx_reply,
        sfilter_cnt
};

static int sfilter_mask[sfilter_cnt] = { 1, 2 };

static char *sfilter_str[sfilter_cnt] = {
        "REQUEST",
        "REPLY"
};


struct fwd_setting {
        int active;
        int sfilter;
        char *filter_methods;
        struct proxy_l* proxy;
};


static struct fwd_setting *fwd_settings = NULL;
static int fwd_max_id = 0;


static void remove_spaces(char *s)
{
        char *p, *dst;
        for (p = s, dst = s; *p != '\0'; ++p) {
                if (!isspace(*p)) *dst++ = *p;
        }
        *dst = '\0';

}


static int conf_str2int(char *s)
{
        if (s == NULL) return -1;

        errno = 0;
        char *end = NULL;
        long int i = strtol(s, &end, 10);
        if ((errno != 0) || (i == LONG_MIN) || (i == LONG_MAX) || (end == s)) {
                LM_ERR("invalid string '%s'.\n", s);
                return -1;
        }

        return i;
}


int conf_str2id(char *id_str)
{
        int id = conf_str2int(id_str);

        if ((id<0) || (id > fwd_max_id)) {
        LM_ERR("id %d is out of range.\n", id);
        return -1;
        }

        return id;
}


static int update_switch(int id, char* param_str)
{
        if (param_str == NULL) {
                LM_ERR("param_str is NULL.\n");
                return -1;
        }

        if (strcmp(param_str, "on") == 0) {
                fwd_settings[id].active = 1;
                return 0;
        } else if (strcmp(param_str, "off") == 0) {
                fwd_settings[id].active = 0;
                return 0;
        }

        LM_ERR("invalid switch '%s'.\n", param_str);
        return -1;
}


static int update_filter(int id, char *flist)
{
        if (flist == NULL) {
                LM_ERR("flist is NULL.\n");
                return -1;
        }

        /* reset special filter mask and filter methods*/
        fwd_settings[id].sfilter = 0;
        if (fwd_settings[id].filter_methods != NULL) {
                shm_free(fwd_settings[id].filter_methods);
                fwd_settings[id].filter_methods = NULL;
        }

        int i;
        for (i=0; i<sfilter_cnt; i++) {
                if (strstr(flist, sfilter_str[i]) != NULL) {
                        /* special filter name is found in flist -> add to special filter mask */
                        fwd_settings[id].sfilter |= sfilter_mask[i];
                }
        }

        char buf[BUFSIZE+1], tmp[BUFSIZE+1];
        buf[0] = '\0';
        char *set_p = flist;
        char *token = NULL;
        while ((token = strsep(&set_p, ":"))) {  /* iterate through list of filters */
                int found  = 0;
                /* is it a special filter? */
                for (i=0; i<sfilter_cnt; i++) {
                        if (strcmp(token, sfilter_str[i]) == 0) {
                                found = 1;
                                break;
                        }
                }

                if (found == 0) {
                /* no special filter! */
                        if (buf[0]) {
                                strcpy(tmp, buf);
                                snprintf(buf, BUFSIZE, "%s:%s", tmp, token);
                                buf[BUFSIZE]='\0';
                        } else {
                                snprintf(buf, BUFSIZE, "%s", token);
                                buf[BUFSIZE]='\0';
                        }
                }
        }

        int len = strlen(buf);
        if (len > 0) {
                char *flc = shm_malloc(len+1);
                if (flc == NULL) {
                        SHM_MEM_ERROR;
                        return -1;
                }
                memcpy(flc, buf, len+1);
                fwd_settings[id].filter_methods = flc;
        }
        return 0;
}


static int update_proxy(int id, char *host_str, char *port_str)
{
        if (host_str == NULL) {
                LM_ERR("host_str is NULL.\n");
                return -1;
        }
        if (port_str == NULL) {
                LM_ERR("port_str is NULL.\n");
                return -1;
        }

        int port = conf_str2int(port_str);
        if (port < 0) {
                LM_ERR("invalid port '%s'.\n", port_str);
                return -1;
        }

        /* make copy of host string since mk_proxy does not */
        str host;
        host.len = strlen(host_str);
        host.s = shm_malloc(host.len+1);
        if (host.s == NULL) {
                SHM_MEM_ERROR;
                return -1;
        }
        strcpy(host.s, host_str);

        /* make proxy in shared memory */
        struct proxy_l* proxy;
        proxy = mk_shm_proxy(&host, port, PROTO_UDP);
        if (proxy == NULL) {
                LM_ERR("cannot make proxy (host='%s', port=%d).\n", host_str, port);
                shm_free(host.s);
                return -1;
        }

        if (fwd_settings[id].proxy) {
                /* cleaning up old proxy */
                if (fwd_settings[id].proxy->name.s) {
                        shm_free(fwd_settings[id].proxy->name.s);
                }
                free_shm_proxy(fwd_settings[id].proxy);
                shm_free(fwd_settings[id].proxy);
        }
        fwd_settings[id].proxy = proxy;  /* new proxy is now acitvated */

        return 0;
}


int conf_parse_switch(char *settings)
{
        /* make a copy since we are modifying it */
        int len = strlen(settings);
        if (len==0) return 1;
        char *strc = (char *)pkg_malloc(len+1);
        if (strc == NULL) {
                PKG_MEM_ERROR;
                return -1;
        }
        memcpy(strc, settings, len+1);
        remove_spaces(strc);

        char *set_p = strc;
        char *token = NULL;
        while ((token = strsep(&set_p, ","))) {  /* iterate through list of settings */
                char *id_str = strsep(&token, "=");
                int id = conf_str2id(id_str);
                if (id < 0) {
                        LM_ERR("cannot parse id '%s'.\n", id_str);
                        pkg_free(strc);
                        return -1;
                }

                /* got all data for one setting -> update configuration now */
                if (update_switch(id, token) < 0) {
                        LM_ERR("cannot update switch.\n");
                        pkg_free(strc);
                        return -1;
                }
        }

        pkg_free(strc);
        return 1;
}


int conf_show(struct mi_root* rpl_tree)
{
        int id, sfilter;
        struct mi_node * node = NULL;

        node = addf_mi_node_child( &rpl_tree->node, 0, 0, 0, "id switch %30s proxy\n", "filter");
        if(node == NULL)
                goto error;

        for (id=0; id<=fwd_max_id; id++) {
                char buf[BUFSIZE+1];
                char tmp[BUFSIZE+1];
                buf[0]='\0';
                for (sfilter=0; sfilter<sfilter_cnt; sfilter++) {
                        if (fwd_settings[id].sfilter&sfilter_mask[sfilter]) {
                                if (buf[0]) {
                                        strcpy(tmp, buf);
                                        snprintf(buf, BUFSIZE, "%s:%s", tmp, sfilter_str[sfilter]);
                                        buf[BUFSIZE]='\0';
                                } else {
                                        snprintf(buf, BUFSIZE, "%s", sfilter_str[sfilter]);
                                        buf[BUFSIZE]='\0';
                                }
                        }
                }
                if (fwd_settings[id].filter_methods) {
                        if (buf[0]) {
                                strcpy(tmp, buf);
                                snprintf(buf, BUFSIZE, "%s:%s", tmp, fwd_settings[id].filter_methods);
                                buf[BUFSIZE]='\0';
                        } else {
                                snprintf(buf, BUFSIZE, "%s", fwd_settings[id].filter_methods);
                                buf[BUFSIZE]='\0';
                        }
                }
                node = addf_mi_node_child( &rpl_tree->node, 0, 0, 0, "%2d %s %33s %s:%d\n", id,
                        fwd_settings[id].active ? "on " : "off", buf,
                        fwd_settings[id].proxy ? fwd_settings[id].proxy->name.s : "",
                        fwd_settings[id].proxy ? fwd_settings[id].proxy->port : 0);
                if(node == NULL)
                        goto error;

        }
        return 0;

error:
        return -1;
}


int conf_parse_filter(char *settings)
{
        /* make a copy since we are modifying it */
        int len = strlen(settings);
        if (len==0) return 1;
        char *strc = (char *)pkg_malloc(len+1);
        if (strc == NULL) {
                PKG_MEM_ERROR;
                return -1;
        }
        memcpy(strc, settings, len+1);
        remove_spaces(strc);

        char *set_p = strc;
        char *token = NULL;
        while ((token = strsep(&set_p, ","))) {  /* iterate through list of settings */
                char *id_str = strsep(&token, "=");
                int id = conf_str2id(id_str);
                if (id<0) {
                        LM_ERR("cannot parse id '%s'.\n", id_str);
                        pkg_free(strc);
                        return -1;
                }
                if (update_filter(id, token) < 0) {
                        LM_ERR("cannot extract filters.\n");
                        pkg_free(strc);
                        return -1;
                }
        }

        pkg_free(strc);
        return 1;
}


int conf_parse_proxy(char *settings)
{
        /* make a copy since we are modifying it */
        int len = strlen(settings);
        if (len==0) return 1;
        char *strc = (char *)pkg_malloc(len+1);
        if (strc == NULL) {
                PKG_MEM_ERROR;
                return -1;
        }
        memcpy(strc, settings, len+1);
        remove_spaces(strc);

        char *set_p = strc;
        char *token = NULL;
        while ((token = strsep(&set_p, ","))) {  /* iterate through list of settings */
                char *id_str = strsep(&token, "=");
                int id = conf_str2id(id_str);
                if (id<0) {
                        LM_ERR("cannot parse id '%s'.\n", id_str);
                        pkg_free(strc);
                        return -1;
                }
                char *host = strsep(&token, ":");

                /* got all data for one setting -> update configuration now */
                if (update_proxy(id, host, token) < 0) {
                        LM_ERR("cannot update proxy.\n");
                        pkg_free(strc);
                        return -1;
                }
        }

        pkg_free(strc);
        return 1;
}


static int filter_methods_contains_request(int id, char *method, int method_len)
{
        char *p = fwd_settings[id].filter_methods;

        while (p != NULL) {
                if (strncmp(p, method, method_len) == 0) {
                        return 1;
                }
                p = strchr(p, ':');
                if (p != NULL) p++;
        }

        return 0;
}


struct proxy_l *conf_needs_forward(struct sip_msg *msg, int id)
{
        if ((msg == NULL) || (fwd_settings[id].active == 0)) {
                return NULL;
        }

        if (msg->first_line.type == SIP_REPLY) {
                if (fwd_settings[id].sfilter&sfilter_mask[sfidx_reply]) {
                        return fwd_settings[id].proxy;
                }
        }

        if (msg->first_line.type == SIP_REQUEST) {
                if (fwd_settings[id].sfilter&sfilter_mask[sfidx_request]) {
                        return fwd_settings[id].proxy;
                }

                if (filter_methods_contains_request(id, msg->first_line.u.request.method.s, msg->first_line.u.request.method.len) > 0) {
                        return fwd_settings[id].proxy;
                }
        }

        return NULL;
}


int conf_init(int max_id)
{
        /* allocate and initialize memory for configuration */
        fwd_settings = shm_malloc(sizeof(struct fwd_setting)*(max_id+1));
        if (fwd_settings == NULL) {
                SHM_MEM_ERROR;
                return -1;
        }
        memset(fwd_settings, 0, sizeof(struct fwd_setting)*(max_id+1));
        fwd_max_id = max_id;
        return 0;
}


void conf_destroy(void)
{
        int id;

        if (fwd_settings) {
                for (id=0; id<=fwd_max_id; id++) {
                        fwd_settings[id].active = 0;
                        if (fwd_settings[id].proxy) {
                                if (fwd_settings[id].proxy->name.s) {
                                        shm_free(fwd_settings[id].proxy->name.s);
                                }
                                free_shm_proxy(fwd_settings[id].proxy);
                                shm_free(fwd_settings[id].proxy);
                        }
                }
                shm_free(fwd_settings);
        }
}