cr_domain.c

Go to the documentation of this file.

/*
 * $Id$
 *
 * Copyright (C) 2007-2008 1&1 Internet AG
 *
 * This file is part of SIP-router, a free SIP server.
 *
 * SIP-router 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
 *
 * SIP-router 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 <stdlib.h>
#include "../../mem/shm_mem.h"
#include "../../ut.h"
#include "cr_domain.h"
#include "cr_rule.h"
#include "carrierroute.h"


static void destroy_route_flags_list(void *data) {
        struct route_flags *rf, *rf_tmp;

        rf=(struct route_flags *)(data);
        while (rf!=NULL) {
                rf_tmp = rf->next;
                destroy_route_flags(rf);
                rf = rf_tmp;
        }
}


static void destroy_failure_route_rule_list(void *data) {
        struct failure_route_rule *rs, *rs_tmp;
        
        rs = (struct failure_route_rule *)(data);
        while (rs != NULL) {
                rs_tmp = rs->next;
                destroy_failure_route_rule(rs);
                rs = rs_tmp;
        }
}


struct domain_data_t * create_domain_data(int domain_id, str * domain_name) {
        struct domain_data_t * tmp;
        if ((tmp = shm_malloc(sizeof(struct domain_data_t))) == NULL) {
                SHM_MEM_ERROR;
                return NULL;
        }
        memset(tmp, 0, sizeof(struct domain_data_t));
        tmp->id = domain_id;
        tmp->name = domain_name;
        if ((tmp->tree = dtrie_init(cr_match_mode)) == NULL) {
                shm_free(tmp);
                return NULL;
        }
        if ((tmp->failure_tree = dtrie_init(cr_match_mode)) == NULL) {
                dtrie_destroy(&tmp->tree, NULL, cr_match_mode);
                shm_free(tmp);
                return NULL;
        }
        return tmp;
}


void destroy_domain_data(struct domain_data_t *domain_data) {
        if (domain_data) {
                dtrie_destroy(&domain_data->tree, destroy_route_flags_list, cr_match_mode);
                dtrie_destroy(&domain_data->failure_tree, destroy_failure_route_rule_list,
                                cr_match_mode);
                shm_free(domain_data);
        }
}


int add_route_to_tree(struct dtrie_node_t *node, const str * scan_prefix,
                flag_t flags, flag_t mask, const str * full_prefix, int max_targets, double prob,
                const str * rewrite_hostpart, int strip, const str * rewrite_local_prefix,
                const str * rewrite_local_suffix, int status, int hash_index, 
                int backup, int * backed_up, const str * comment) {
        void **ret;
        struct route_flags *rf;

        ret = dtrie_contains(node, scan_prefix->s, scan_prefix->len, cr_match_mode);

        rf = add_route_flags((struct route_flags **)ret, flags, mask);
        if (rf == NULL) {
                LM_ERR("cannot insert route flags into list\n");
                return -1;
        }

        if (ret == NULL) {
                /* node does not exist */
                if (dtrie_insert(node, scan_prefix->s, scan_prefix->len, rf, cr_match_mode) != 0) {
                        LM_ERR("cannot insert route flags into d-trie\n");
                        return -1;
                }
        }

        /* Now add rule to flags */
        return add_route_rule(rf, full_prefix, max_targets, prob, rewrite_hostpart, strip,
                                                                                                rewrite_local_prefix, rewrite_local_suffix, status, hash_index,
                                                                                                backup, backed_up, comment);
}


int add_failure_route_to_tree(struct dtrie_node_t * failure_node, const str * scan_prefix,
                const str * full_prefix, const str * host, const str * reply_code,
                const flag_t flags, const flag_t mask, const int next_domain, const str * comment) {
        void **ret;
        struct failure_route_rule *frr;

        ret = dtrie_contains(failure_node, scan_prefix->s, scan_prefix->len, cr_match_mode);

        frr = add_failure_route_rule((struct failure_route_rule **)ret, full_prefix, host, reply_code, flags, mask, next_domain, comment);
        if (frr == NULL) {
                LM_ERR("cannot insert failure route rule into list\n");
                return -1;
                }

        if (ret == NULL) {
                /* node does not exist */
                if (dtrie_insert(failure_node, scan_prefix->s, scan_prefix->len, frr, cr_match_mode) != 0) {
                        LM_ERR("cannot insert failure route rule into d-trie\n");
                        return -1;
                }
        }

        return 0;
}


int compare_domain_data(const void *v1, const void *v2) {
  struct domain_data_t *d1 = *(struct domain_data_t * const *)v1;
        struct domain_data_t *d2 = *(struct domain_data_t * const *)v2;
        if (d1 == NULL) {
                if (d2 == NULL) return 0;
                else return 1;
        }
        else {
                if (d2 == NULL) return -1;
                else {
                        if (d1->id < d2->id) return -1;
                        else if (d1->id > d2->id) return 1;
                        else return 0;
                }
        }
}