/*! \brief * MI function to reload address table */ struct mi_root* mi_address_reload(struct mi_root *cmd_tree, void *param) { if (reload_address_table () == 1) { return init_mi_tree( 200, MI_SSTR(MI_OK)); } else { return init_mi_tree( 400, MI_SSTR("Address table reload failed")); } }
/*! \brief * RPC function to reload address table */ void rpc_address_reload(rpc_t* rpc, void* c) { if (reload_address_table () != 1) { rpc->fault(c, 500, "Reload failed."); return; } rpc->printf(c, "Reload OK"); return; }
/* * MI function to reload address table */ struct mi_root* mi_address_reload(struct mi_root *cmd_tree, void *param) { struct mi_node *node = NULL; struct pm_part_struct *it, *ps; char errbuf[100] = "failed to reload partition "; int errlen = strlen(errbuf); if (cmd_tree) node = cmd_tree->node.kids; if (node == NULL) { /* reload all partitions */ for (it=get_part_structs(); it; it = it->next) { if (it->hash_table == NULL) continue; sprintf(errbuf + errlen, " %.*s!", it->name.len, it->name.s); LM_DBG("trying to reload address table for %.*s\n", it->name.len, it->name.s); if (reload_address_table(it) != 1) return init_mi_tree( 400, MI_SSTR(errbuf)); } return init_mi_tree( 200, MI_SSTR(MI_OK)); } else { /* reload requested partition */ ps = get_part_struct(&node->value); if (ps == NULL) goto err; if (ps->hash_table == NULL) return init_mi_tree( 200, MI_SSTR(MI_OK)); LM_INFO("trying to reload address table for %.*s\n", ps->name.len, ps->name.s); if (reload_address_table(ps) == 1) return init_mi_tree( 200, MI_SSTR(MI_OK)); } err: return init_mi_tree( 400, MI_SSTR("Trusted table reload failed")); }
/* * Wrapper to reload addr table from mi or rpc * we need to open the db_handle */ int reload_address_table_cmd(void) { if (!db_handle) { db_handle = perm_dbf.init(&db_url); if (!db_handle) { LM_ERR("unable to connect database\n"); return -1; } } if (reload_address_table () != 1) { perm_dbf.close(db_handle); db_handle = 0; return -1; } perm_dbf.close(db_handle); db_handle = 0; return 1; }
/* * Initialize data structures */ int init_addresses(void) { if (!db_url.s) { LM_INFO("db_url parameter of permissions module not set, " "disabling allow_address\n"); return 0; } else { if (db_bind_mod(&db_url, &perm_dbf) < 0) { LM_ERR("load a database support module\n"); return -1; } if (!DB_CAPABILITY(perm_dbf, DB_CAP_QUERY)) { LM_ERR("database module does not implement 'query' function\n"); return -1; } } addr_hash_table_1 = addr_hash_table_2 = 0; addr_hash_table = 0; db_handle = perm_dbf.init(&db_url); if (!db_handle) { LM_ERR("unable to connect database\n"); return -1; } if(db_check_table_version(&perm_dbf, db_handle, &address_table, TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); perm_dbf.close(db_handle); return -1; } addr_hash_table_1 = new_addr_hash_table(); if (!addr_hash_table_1) return -1; addr_hash_table_2 = new_addr_hash_table(); if (!addr_hash_table_2) goto error; addr_hash_table = (struct addr_list ***)shm_malloc (sizeof(struct addr_list **)); if (!addr_hash_table) { LM_ERR("no more shm memory for addr_hash_table\n"); goto error; } *addr_hash_table = addr_hash_table_1; subnet_table_1 = new_subnet_table(); if (!subnet_table_1) goto error; subnet_table_2 = new_subnet_table(); if (!subnet_table_2) goto error; subnet_table = (struct subnet **)shm_malloc(sizeof(struct subnet *)); if (!subnet_table) { LM_ERR("no more shm memory for subnet_table\n"); goto error; } *subnet_table = subnet_table_1; domain_list_table_1 = new_domain_name_table(); if (!domain_list_table_1) goto error; domain_list_table_2 = new_domain_name_table(); if (!domain_list_table_2) goto error; domain_list_table = (struct domain_name_list ***)shm_malloc(sizeof(struct domain_name_list **)); if (!domain_list_table) { LM_ERR("no more shm memory for domain name table\n"); goto error; } *domain_list_table = domain_list_table_1; if (reload_address_table() == -1) { LM_CRIT("reload of address table failed\n"); goto error; } perm_dbf.close(db_handle); db_handle = 0; return 0; error: if (addr_hash_table_1) { free_addr_hash_table(addr_hash_table_1); addr_hash_table_1 = 0; } if (addr_hash_table_2) { free_addr_hash_table(addr_hash_table_2); addr_hash_table_2 = 0; } if (addr_hash_table) { shm_free(addr_hash_table); addr_hash_table = 0; } if (subnet_table_1) { free_subnet_table(subnet_table_1); subnet_table_1 = 0; } if (subnet_table_2) { free_subnet_table(subnet_table_2); subnet_table_2 = 0; } if (subnet_table) { shm_free(subnet_table); subnet_table = 0; } if (domain_list_table_1) { free_domain_name_table(domain_list_table_1); domain_list_table_1 = 0; } if (domain_list_table_2) { free_domain_name_table(domain_list_table_2); domain_list_table_2 = 0; } if (domain_list_table) { shm_free(domain_list_table); domain_list_table = 0; } perm_dbf.close(db_handle); db_handle = 0; return -1; }
/* * Initialize data structures */ int init_address(struct pm_partition *partition) { struct pm_part_struct *part_struct; /* Check if hash table needs to be loaded from address table */ if (!partition->url.s) { LM_INFO("db_url parameter of permissions module not set, " "disabling allow_address\n"); return 0; } part_struct = pkg_malloc(sizeof (struct pm_part_struct)); if (part_struct == NULL) { LM_ERR("no more pkg mem\n"); return -1; } memset(part_struct, 0, sizeof(struct pm_part_struct)); part_struct->name = partition->name; part_struct->url = partition->url; part_struct->table = partition->table; if (db_bind_mod(&partition->url, &part_struct->perm_dbf) < 0) { LM_ERR("load a database support module\n"); return -1; } if (!DB_CAPABILITY(part_struct->perm_dbf, DB_CAP_QUERY)) { LM_ERR("database module does not implement 'query' function\n"); return -1; } part_struct->hash_table_1 = part_struct->hash_table_2 = 0; part_struct->hash_table = 0; part_struct->db_handle = part_struct->perm_dbf.init(&partition->url); if (!part_struct->db_handle) { LM_ERR("unable to connect database\n"); return -1; } if (db_check_table_version(&part_struct->perm_dbf, part_struct->db_handle, &partition->table, TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); part_struct->perm_dbf.close(part_struct->db_handle); return -1; } part_struct->hash_table_1 = hash_create(); if (!part_struct->hash_table_1) return -1; part_struct->hash_table_2 = hash_create(); if (!part_struct->hash_table_2) goto error; part_struct->hash_table = (struct address_list ***)shm_malloc (sizeof(struct address_list **)); if (!part_struct->hash_table) goto error; *part_struct->hash_table = part_struct->hash_table_1; part_struct->subnet_table_1 = new_subnet_table(); if (!part_struct->subnet_table_1) goto error; part_struct->subnet_table_2 = new_subnet_table(); if (!part_struct->subnet_table_2) goto error; part_struct->subnet_table = (struct subnet **)shm_malloc(sizeof(struct subnet *)); if (!part_struct->subnet_table) goto error; *part_struct->subnet_table = part_struct->subnet_table_1; if (reload_address_table(part_struct) == -1) { LM_CRIT("reload of address table failed\n"); goto error; } part_struct->perm_dbf.close(part_struct->db_handle); part_struct->db_handle = 0; add_part_struct(part_struct); return 0; error: if (part_struct->hash_table_1) { hash_destroy(part_struct->hash_table_1); part_struct->hash_table_1 = 0; } if (part_struct->hash_table_2) { hash_destroy(part_struct->hash_table_2); part_struct->hash_table_2 = 0; } if (part_struct->hash_table) { shm_free(part_struct->hash_table); part_struct->hash_table = 0; } if (part_struct->subnet_table_1) { free_subnet_table(part_struct->subnet_table_1); part_struct->subnet_table_1 = 0; } if (part_struct->subnet_table_2) { free_subnet_table(part_struct->subnet_table_2); part_struct->subnet_table_2 = 0; } if (part_struct->subnet_table) { shm_free(part_struct->subnet_table); part_struct->subnet_table = 0; } part_struct->perm_dbf.close(part_struct->db_handle); part_struct->db_handle = 0; pkg_free(part_struct); return -1; }