void tommy_list_concat(tommy_list* first, tommy_list* second) { tommy_node* first_head; tommy_node* first_tail; tommy_node* second_head; if (tommy_list_empty(second)) return; if (tommy_list_empty(first)) { *first = *second; return; } first_head = tommy_list_head(first); second_head = tommy_list_head(second); first_tail = tommy_list_tail(first); /* set the "circular" prev list */ first_head->prev = second_head->prev; second_head->prev = first_tail; /* set the "0 terminated" next list */ first_tail->next = second_head; }
void *get_first_elem_list(void *ll) { if (tommy_list_head(ll)) return tommy_list_head(ll)->data; else return NULL; }
uint16_t switch_smac_rewrite_index_from_rmac(switch_handle_t rmac_handle) { switch_rmac_info_t *rmac_info = NULL; switch_rmac_entry_t *rmac_entry = NULL; tommy_node *node = NULL; switch_mac_addr_t *mac = NULL; uint16_t smac_index = 0; switch_smac_entry_t *smac_entry = NULL; rmac_info = switch_api_rmac_info_get_internal(rmac_handle); if (!rmac_info) { return smac_index; } node = tommy_list_head(&(rmac_info->rmac_list)); while (node) { rmac_entry = node->data; mac = &rmac_entry->mac; smac_entry = switch_smac_rewrite_search_entry(mac); if (smac_entry) { smac_index = smac_entry->smac_index; break; } node = node->next; } return smac_index; }
switch_status_t switch_api_l3_v6_routes_print_by_vrf( switch_handle_t vrf_handle) { switch_l3_hash_t *hash_entry = NULL; tommy_node *node = NULL; switch_vrf_route_list_t *vrf_route_list = NULL; void *temp = NULL; switch_ip_addr_t ip_addr; char v6_addr[INET6_ADDRSTRLEN]; JLG(temp, switch_vrf_v6_routes, vrf_handle); if (!temp) { return SWITCH_STATUS_ITEM_NOT_FOUND; } vrf_route_list = (switch_vrf_route_list_t *)(*(unsigned long *)temp); node = tommy_list_head(&(vrf_route_list->routes)); while (node) { hash_entry = node->data; switch_l3_hash_key_decode(hash_entry, &vrf_handle, &ip_addr); inet_ntop(AF_INET6, ip_addr.ip.v6addr, v6_addr, INET6_ADDRSTRLEN); printf("\nvrf_handle %x ip %s -> nhop %x", (unsigned int)vrf_handle, v6_addr, (unsigned int)hash_entry->nhop_handle); node = node->next; } return SWITCH_STATUS_SUCCESS; }
void switchlink_db_mroute_mdb_walk(switchlink_db_mdb_info_t *mdb_info, switchlink_db_mroute_walk_fn notify) { if (!mdb_info || !notify) { return; } switchlink_handle_t mdb_vrf_h; switchlink_db_bridge_info_t bridge_info; if (switchlink_db_bridge_handle_get_info( mdb_info->bridge_h, &bridge_info) != SWITCHLINK_DB_STATUS_SUCCESS) { return; } mdb_vrf_h = bridge_info.vrf_h; tommy_node * node = tommy_list_head(&switchlink_db_mroute_obj_list); while (node) { switchlink_db_mroute_obj_t * obj = node->data; node = node->next; if ((obj->mroute_info.vrf_h == mdb_vrf_h) && (memcmp(&(obj->mroute_info.dst_ip), &(mdb_info->grp_ip), sizeof(switchlink_ip_addr_t)) == 0)) { switchlink_db_mroute_info_t mroute_info; memcpy(&mroute_info, &(obj->mroute_info), sizeof(switchlink_db_mroute_info_t)); (*notify)(&mroute_info); } } }
void pcore_hash_done(phash_pool *ptr) { phash_pool pool = (*ptr); if (!pool) { plog_error("%s(): Нет phash_pool!", __PRETTY_FUNCTION__); return; } plog_dbg("%s(): Очистка пула 0x%08X", __PRETTY_FUNCTION__, pool); tommy_node* i = tommy_list_head(pool->list); while (i) { tommy_node* i_next = i->next; if (!pcore_hash_deleteObject((phash_object*)&i->data)) { break; } i = i_next; } switch (pool->type) { case PHASH_FAST_SEARCH: tommy_hashdyn_done((tommy_hashdyn *)pool->hash_struct); break; case PHASH_FAST_INSERT: default: tommy_hashtable_done((tommy_hashtable *)pool->hash_struct); break; } pfree(&pool->hash_struct); pfree(&pool->list); pfree(&pool); }
switchlink_db_status_t switchlink_db_ecmp_get_info(switchlink_db_ecmp_info_t *ecmp_info) { tommy_node * node = tommy_list_head(&switchlink_db_ecmp_obj_list); while (node) { switchlink_db_ecmp_obj_t * obj = node->data; node = node->next; if (obj->ecmp_info.num_nhops == ecmp_info->num_nhops) { int i, j; for (i = 0; i < ecmp_info->num_nhops; i++) { bool match_found = false; for (j = 0; j < ecmp_info->num_nhops; j++) { if (obj->ecmp_info.nhops[i] == ecmp_info->nhops[j]) { match_found = true; break; } } if (!match_found) { return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; } } memcpy(ecmp_info, &(obj->ecmp_info), sizeof(switchlink_db_ecmp_info_t)); return SWITCHLINK_DB_STATUS_SUCCESS; } } return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; }
switch_status_t switch_api_nhop_print_entry(switch_handle_t nhop_handle) { switch_nhop_info_t *nhop_info = NULL; switch_spath_info_t *spath_info = NULL; switch_ecmp_info_t *ecmp_info = NULL; switch_ecmp_member_t *ecmp_member = NULL; tommy_node *node = NULL; nhop_info = switch_nhop_get(nhop_handle); if (!nhop_info) { return SWITCH_STATUS_INVALID_NHOP; } printf("\n\nnhop_handle %x", (unsigned int) nhop_handle); if (nhop_info->type == SWITCH_NHOP_INDEX_TYPE_ONE_PATH) { spath_info = &(SWITCH_NHOP_SPATH_INFO(nhop_info)); printf("\ntype : single path"); printf("\nintf_handle %x", (unsigned int) spath_info->nhop_key.intf_handle); } else { ecmp_info = &(SWITCH_NHOP_ECMP_INFO(nhop_info)); printf("\ntype : ecmp path"); printf("\nnumber of ecmp path %d", ecmp_info->count); node = tommy_list_head(&(ecmp_info->members)); while (node) { ecmp_member = node->data; printf("\n\tecmp_member_nhop %x", (unsigned int) ecmp_member->nhop_handle); node = node->next; } } return SWITCH_STATUS_SUCCESS; }
void cheap_tcam_insert(cheap_tcam_t *tcam, uint8_t *mask, uint8_t *key, cheap_tcam_node *node, void *data) { tommy_list *hashmaps = &tcam->hashmaps; tcam_hashmap_t *tcam_hashmap; uint32_t hash = hashlittle(key, tcam->key_size, 0); tommy_node* elem = tommy_list_head(hashmaps); while(elem) { tcam_hashmap = (tcam_hashmap_t *) elem->data; if(!memcmp(mask, tcam_hashmap->mask, tcam->key_size)) { tommy_hashlin_insert(&tcam_hashmap->hashmap, node, data, hash); return; } elem = elem->next; } tcam_hashmap = malloc(sizeof(tcam_hashmap_t)); tommy_hashlin_init(&tcam_hashmap->hashmap); tcam_hashmap->mask = malloc(tcam->key_size); memcpy(tcam_hashmap->mask, mask, tcam->key_size); tommy_list_insert_head(hashmaps, &tcam_hashmap->node, tcam_hashmap); tommy_hashlin_insert(&tcam_hashmap->hashmap, node, data, hash); }
switch_status_t switch_api_router_mac_group_print_entry(switch_handle_t rmac_handle) { switch_rmac_info_t *rmac_info = NULL; switch_rmac_entry_t *rmac_entry = NULL; tommy_node *node = NULL; switch_mac_addr_t *mac = NULL; rmac_info = switch_api_rmac_info_get_internal(rmac_handle); if (!rmac_info) { return SWITCH_STATUS_INVALID_HANDLE; } printf("\n\nrmac_handle %x", (unsigned int) rmac_handle); node = tommy_list_head(&(rmac_info->rmac_list)); while (node) { rmac_entry = node->data; mac = &rmac_entry->mac; printf("\n\t mac %02x:%02x:%02x:%02x:%02x:%02x", mac->mac_addr[0], mac->mac_addr[1], mac->mac_addr[2], mac->mac_addr[3], mac->mac_addr[4], mac->mac_addr[5]); node = node->next; } printf("\n"); return SWITCH_STATUS_SUCCESS; }
//:: for name, vs_info in value_sets.items(): //:: byte_width = vs_info["byte_width"] void *value_set_${name}_lookup(uint8_t *value, uint8_t *mask) { tommy_node* node = tommy_list_head(&value_set_${name}); while (node) { value_set_${name}_entry_t * data = node->data; if((!memcmp(data->value, value, sizeof(data->value))) && (!memcmp(data->mask, mask, sizeof(data->mask)))) return &data->node; node = node->next; } return NULL; }
/* * @function: switch_api_router_mac_add * Add Router mac to rmac group * @param device - Device to be programmed * @param rmac_handle - ID of the RMAC group * @param mac - Router mac address to be added to the group * @return: Returns success if mac is added successfully */ switch_status_t switch_api_router_mac_add(switch_device_t device, switch_handle_t rmac_handle, switch_mac_addr_t *mac) { switch_rmac_info_t *rmac_info = NULL; switch_rmac_entry_t *rmac_entry = NULL; tommy_node *node = NULL; switch_status_t status = SWITCH_STATUS_SUCCESS; if (!SWITCH_RMAC_HANDLE_VALID(rmac_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } rmac_info = switch_api_rmac_info_get_internal(rmac_handle); if (!rmac_info) { return SWITCH_STATUS_INVALID_HANDLE; } node = tommy_list_head(&(rmac_info->rmac_list)); while (node) { rmac_entry = node->data; if (memcmp(&(rmac_entry->mac), mac, sizeof(switch_mac_addr_t)) == 0) { return SWITCH_STATUS_SUCCESS; } node = node->next; } rmac_entry = switch_malloc(sizeof(switch_rmac_entry_t), 1); if (!rmac_entry) { return SWITCH_STATUS_NO_MEMORY; } memcpy(&rmac_entry->mac, mac, sizeof(switch_mac_addr_t)); tommy_list_insert_head(&(rmac_info->rmac_list), &(rmac_entry->node), rmac_entry); status = switch_smac_rewrite_add_entry(mac); if (status != SWITCH_STATUS_SUCCESS) { printf("MAC rewrite table add failed with error code %d\n", status); return status; } #ifdef SWITCH_PD status = switch_pd_inner_rmac_table_add_entry(device, handle_to_id(rmac_handle), mac, &rmac_entry->inner_rmac_entry); if(status != SWITCH_STATUS_SUCCESS) { printf("Inner RMAC table add failed with error code %d\n", status); return status; } status = switch_pd_outer_rmac_table_add_entry(device, handle_to_id(rmac_handle), mac, &rmac_entry->outer_rmac_entry); if(status != SWITCH_STATUS_SUCCESS) { printf("Outer RMAC table add failed with error code %d\n", status); } #endif return status; }
//:: for name, vs_info in value_sets.items(): //:: byte_width = vs_info["byte_width"] int value_set_${name}_contains(uint8_t *key) { tommy_node* node = tommy_list_head(&value_set_${name}); while (node) { value_set_${name}_entry_t * data = node->data; int result = cmp_values(key, data->value, ${byte_width}, data->mask); if(result) return 1; node = node->next; } return 0; }
switch_status_t switch_api_stp_group_print_entry(switch_handle_t stg_handle) { switch_stp_info_t *stp_info = NULL; switch_stp_vlan_entry_t *vlan_entry = NULL; switch_stp_port_entry_t *port_entry = NULL; tommy_node *node = NULL; switch_handle_t bd_handle = 0; switch_handle_t intf_handle = 0; if (!SWITCH_STP_HANDLE_VALID(stg_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } stp_info = switch_api_stp_get_internal(stg_handle); if (!stp_info) { return SWITCH_STATUS_INVALID_HANDLE; } printf("\n\nstp_group_handle: %x", (unsigned int) stg_handle); node = tommy_list_head(&(stp_info->vlan_list)); printf("\nlist of vlan handles:"); while (node) { vlan_entry = node->data; bd_handle = vlan_entry->bd_handle; printf("\n\tvlan_handle: %x", (unsigned int) bd_handle); node = node->next; } printf("\nlist of interface handles:"); node = tommy_list_head(&(stp_info->port_list)); while (node) { port_entry = node->data; intf_handle = port_entry->intf_handle; printf("\n\tintf_handle: %x stp_state %x", (unsigned int) intf_handle, port_entry->intf_state); node = node->next; } printf("\n"); return SWITCH_STATUS_SUCCESS; }
switch_status_t switch_api_stp_group_vlans_remove(switch_device_t device, switch_handle_t stg_handle, uint16_t vlan_count, switch_handle_t *vlan_handle) { switch_stp_info_t *stp_info = NULL; switch_bd_info_t *bd_info = NULL; switch_stp_vlan_entry_t *vlan_entry = NULL; tommy_node *node = NULL; switch_handle_t bd_handle; int count = 0; if (!SWITCH_STP_HANDLE_VALID(stg_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } stp_info = switch_api_stp_get_internal(stg_handle); if (!stp_info) { return SWITCH_STATUS_INVALID_HANDLE; } for (count = 0; count < vlan_count; count++) { bd_handle = vlan_handle[count]; bd_info = switch_bd_get(bd_handle); if (!bd_info) { return SWITCH_STATUS_INVALID_VLAN_ID; } node = tommy_list_head(&(stp_info->vlan_list)); while (node) { vlan_entry = node->data; if (vlan_entry->bd_handle == bd_handle) { break; } node = node->next; } if (!node) { return SWITCH_STATUS_ITEM_NOT_FOUND; } bd_info->stp_handle = 0; switch_pd_bd_table_update_entry(device, handle_to_id(bd_handle), bd_info); vlan_entry = tommy_list_remove_existing(&(stp_info->vlan_list), node); switch_free(vlan_entry); } return SWITCH_STATUS_SUCCESS; }
switch_status_t switch_stp_update_flood_list(switch_device_t device, switch_handle_t stg_handle, switch_handle_t intf_handle, switch_stp_state_t state) { switch_stp_info_t *stp_info = NULL; switch_bd_info_t *bd_info = NULL; switch_stp_vlan_entry_t *vlan_entry = NULL; tommy_node *node = NULL; switch_handle_t bd_handle = 0; switch_status_t status = SWITCH_STATUS_SUCCESS; switch_vlan_interface_t vlan_intf; if (!SWITCH_STP_HANDLE_VALID(stg_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } stp_info = switch_api_stp_get_internal(stg_handle); if (!stp_info) { return SWITCH_STATUS_INVALID_HANDLE; } node = tommy_list_head(&(stp_info->vlan_list)); while (node) { vlan_entry = node->data; bd_handle = vlan_entry->bd_handle; bd_info = switch_bd_get(bd_handle); if (!bd_info) { return SWITCH_STATUS_INVALID_VLAN_ID; } memset(&vlan_intf, 0, sizeof(vlan_intf)); vlan_intf.vlan_handle = bd_handle; vlan_intf.intf_handle = intf_handle; switch (state) { case SWITCH_PORT_STP_STATE_FORWARDING: status = switch_api_multicast_member_add( device, bd_info->uuc_mc_index, 1, &vlan_intf); break; case SWITCH_PORT_STP_STATE_BLOCKING: case SWITCH_PORT_STP_STATE_NONE: status = switch_api_multicast_member_delete( device, bd_info->uuc_mc_index, 1, &vlan_intf); break; default: break; } node = node->next; } return status; }
switch_status_t switch_api_packet_net_filter_tx_delete( switch_device_t device, switch_packet_tx_key_t *tx_key) { switch_packet_tx_entry_t *tmp_tx_entry = NULL; switch_packet_tx_info_t *tmp_tx_info = NULL; switch_packet_tx_entry_t tx_entry; tommy_node *node = NULL; switch_hostif_info_t *hostif_info = NULL; bool node_found = FALSE; switch_status_t status = SWITCH_STATUS_SUCCESS; if (!tx_key) { SWITCH_API_ERROR("filter tx delete failed. invalid params"); return SWITCH_STATUS_INVALID_PARAMETER; } memset(&tx_entry, 0x0, sizeof(tx_entry)); if (tx_key->handle_valid) { hostif_info = switch_hostif_get(tx_key->hostif_handle); if (!hostif_info) { SWITCH_API_ERROR("invalid hostif handle"); return SWITCH_STATUS_INVALID_HANDLE; } tx_entry.intf_fd = hostif_info->intf_fd; } if (tx_key->vlan_valid) { tx_entry.vlan_id = tx_key->vlan_id; } node = tommy_list_head(&packet_tx_filter_list); while (node) { tmp_tx_info = (switch_packet_tx_info_t *)node->data; tmp_tx_entry = &tmp_tx_info->tx_entry; if (switch_packet_tx_filter_match(tmp_tx_entry, &tx_entry)) { node_found = TRUE; break; } node = node->next; } if (!node_found) { SWITCH_API_ERROR("tx filter delete failed. node find failed"); return SWITCH_STATUS_ITEM_NOT_FOUND; } tommy_list_remove_existing(&packet_tx_filter_list, node); switch_free(tmp_tx_info); return status; }
switchlink_db_status_t switchlink_db_mac_intf_delete( switchlink_handle_t intf_h) { tommy_node *node = tommy_list_head(&switchlink_db_mac_obj_list); while (node) { switchlink_db_mac_obj_t *obj = node->data; node = node->next; if (obj->intf_h == intf_h) { tommy_hashlin_remove_existing(&switchlink_db_mac_obj_hash, &obj->hash_node); tommy_list_remove_existing(&switchlink_db_mac_obj_list, &obj->list_node); switchlink_free(obj); } } return SWITCHLINK_DB_STATUS_SUCCESS; }
switch_status_t switch_api_stp_group_delete(switch_device_t device, switch_handle_t stg_handle) { switch_stp_info_t *stp_info = NULL; tommy_node *node = NULL; switch_stp_port_entry_t *port_entry = NULL; switch_stp_vlan_entry_t *vlan_entry = NULL; if (!SWITCH_STP_HANDLE_VALID(stg_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } stp_info = switch_api_stp_get_internal(stg_handle); if (!stp_info) { return SWITCH_STATUS_INVALID_HANDLE; } node = tommy_list_head(&(stp_info->port_list)); while (node) { port_entry = node->data; node = node->next; switch_api_stp_port_state_set(device, stg_handle, port_entry->intf_handle, SWITCH_PORT_STP_STATE_NONE); } node = tommy_list_head(&(stp_info->vlan_list)); while (node) { vlan_entry = node->data; node = node->next; switch_api_stp_group_vlans_remove(device, stg_handle, 1, &vlan_entry->bd_handle); } switch_stg_handle_delete(stg_handle); return SWITCH_STATUS_SUCCESS; }
static int filter_element(tommy_list* filterlist, struct snapraid_filter** reason, const char* disk, const char* sub, int is_dir) { tommy_node* i; int direction = 1; /* by default include all */ /* for each filter */ for (i = tommy_list_head(filterlist); i != 0; i = i->next) { int ret; struct snapraid_filter* filter = i->data; if (filter->is_disk) { if (fnmatch(filter->pattern, disk, FNM_CASEINSENSITIVE_FOR_WIN) == 0) ret = filter->direction; else ret = 0; if (reason != 0 && ret < 0) *reason = filter; } else { ret = filter_recurse(filter, reason, sub, is_dir); } if (ret > 0) { /* include the file */ return 0; } else if (ret < 0) { /* exclude the file */ return -1; } else { /* default is opposite of the last filter */ direction = -filter->direction; if (reason != 0 && direction < 0) *reason = filter; /* continue with the next one */ } } /* directories are always included by default, otherwise we cannot apply rules */ /* to the contained files */ if (is_dir) return 0; /* files are excluded/included depending of the last rule processed */ if (direction < 0) return -1; return 0; }
void cheap_tcam_destroy(cheap_tcam_t *tcam) { tommy_node* elem = tommy_list_head(&tcam->hashmaps); tommy_node* next; tcam_hashmap_t *tcam_hashmap; while(elem) { tcam_hashmap = (tcam_hashmap_t *) elem->data; tommy_hashlin_done(&tcam_hashmap->hashmap); free(tcam_hashmap->mask); next = elem->next; free(tcam_hashmap); elem = next; } free(tcam->masked_key); free(tcam); }
switch_status_t switch_sflow_match_entry_remove(switch_sflow_info_t *sflow_info, switch_handle_t entry_hdl) { tommy_node *node = tommy_list_head(&sflow_info->match_list); while (node) { switch_sflow_match_entry_t *obj = (switch_sflow_match_entry_t *)node->data; if (obj->sflow_ace_hdl == entry_hdl) { break; } node = node->next; } if (node) { tommy_list_remove_existing(&sflow_info->match_list, node); return SWITCH_STATUS_SUCCESS; } return SWITCH_STATUS_ITEM_NOT_FOUND; }
switchlink_db_status_t switchlink_db_route_get_info(switchlink_db_route_info_t *route_info) { tommy_node * node = tommy_list_head(&switchlink_db_route_obj_list); while (node) { switchlink_db_route_obj_t * obj = node->data; node = node->next; if ((obj->route_info.vrf_h == route_info->vrf_h) && (memcmp(&(obj->route_info.ip_addr), &(route_info->ip_addr), sizeof(switchlink_ip_addr_t)) == 0)) { memcpy(route_info, &(obj->route_info), sizeof(switchlink_db_route_info_t)); return SWITCHLINK_DB_STATUS_SUCCESS; } } return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; }
switchlink_db_status_t switchlink_db_mdb_update(switchlink_db_mdb_info_t *mdb_info) { tommy_node * node = tommy_list_head(&switchlink_db_mdb_obj_list); while (node) { switchlink_db_mdb_obj_t * obj = node->data; node = node->next; if ((obj->mdb_info.bridge_h == mdb_info->bridge_h) && (memcmp(&(obj->mdb_info.grp_ip), &(mdb_info->grp_ip), sizeof(switchlink_ip_addr_t)) == 0)) { memcpy(&(obj->mdb_info), mdb_info, sizeof(switchlink_db_mdb_info_t)); return SWITCHLINK_DB_STATUS_SUCCESS; } } return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; }
void cheap_tcam_delete(cheap_tcam_t *tcam, uint8_t *mask, uint8_t *key, cheap_tcam_node *node) { tommy_list *hashmaps = &tcam->hashmaps; tcam_hashmap_t *tcam_hashmap; tommy_node* elem = tommy_list_head(hashmaps); while(elem) { tcam_hashmap = (tcam_hashmap_t *) elem->data; if(!memcmp(mask, tcam_hashmap->mask, tcam->key_size)) { tommy_hashlin_remove_existing(&tcam_hashmap->hashmap, node); return; } elem = elem->next; } }
switchlink_db_status_t switchlink_db_neighbor_delete(switchlink_db_neigh_info_t *neigh_info) { tommy_node * node = tommy_list_head(&switchlink_db_neigh_obj_list); while (node) { switchlink_db_neigh_obj_t * obj = node->data; node = node->next; if ((memcmp(&(neigh_info->ip_addr), &(obj->neigh_info.ip_addr), sizeof(switchlink_ip_addr_t)) == 0) && (neigh_info->intf_h == obj->neigh_info.intf_h)) { tommy_list_remove_existing(&switchlink_db_neigh_obj_list, &obj->list_node); switchlink_free(obj); return SWITCHLINK_DB_STATUS_SUCCESS; } } return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; }
/* * @function: switch_api_router_mac_delete * Add Router mac to rmac group * @param device - Device to be programmed * @param rmac_handle - ID of the RMAC group * @param mac - Router mac address to be removed from the group * @return: Returns success if mac is deleted successfully */ switch_status_t switch_api_router_mac_delete(switch_device_t device, switch_handle_t rmac_handle, switch_mac_addr_t *mac) { switch_rmac_info_t *rmac_info = NULL; switch_rmac_entry_t *rmac_entry = NULL; tommy_node *node = NULL; switch_status_t status = SWITCH_STATUS_SUCCESS; if (!SWITCH_RMAC_HANDLE_VALID(rmac_handle)) { return SWITCH_STATUS_INVALID_HANDLE; } rmac_info = switch_api_rmac_info_get_internal(rmac_handle); if (!rmac_info) { return SWITCH_STATUS_ITEM_NOT_FOUND; } node = tommy_list_head(&(rmac_info->rmac_list)); while (node) { rmac_entry = node->data; if (memcmp(&(rmac_entry->mac), mac, sizeof(switch_mac_addr_t)) == 0) { break; } node = node->next; } if (!node) { return SWITCH_STATUS_ITEM_NOT_FOUND; } switch_smac_rewrite_delete_entry(mac); rmac_entry = tommy_list_remove_existing(&(rmac_info->rmac_list), node); #ifdef SWITCH_PD status = switch_pd_outer_rmac_table_delete_entry(device, rmac_entry->outer_rmac_entry); if (status != SWITCH_STATUS_SUCCESS) { return status; } status = switch_pd_inner_rmac_table_delete_entry(device, rmac_entry->inner_rmac_entry); if (status != SWITCH_STATUS_SUCCESS) { return status; } #endif free(rmac_entry); return status; }
void tommy_list_sort(tommy_list* list, tommy_compare_func* cmp) { tommy_chain chain; tommy_node* head; if (tommy_list_empty(list)) return; head = tommy_list_head(list); /* create a chain from the list */ chain.head = head; chain.tail = head->prev; tommy_chain_mergesort(&chain, cmp); /* restore the list */ tommy_list_set(list, chain.head, chain.tail); }
switchlink_db_status_t switchlink_db_mroute_delete(switchlink_db_mroute_info_t *mroute_info) { tommy_node * node = tommy_list_head(&switchlink_db_mroute_obj_list); while (node) { switchlink_db_mroute_obj_t * obj = node->data; node = node->next; if ((obj->mroute_info.vrf_h == mroute_info->vrf_h) && (memcmp(&(obj->mroute_info.src_ip), &(mroute_info->src_ip), sizeof(switchlink_ip_addr_t)) == 0) && (memcmp(&(obj->mroute_info.dst_ip), &(mroute_info->dst_ip), sizeof(switchlink_ip_addr_t)) == 0)) { tommy_list_remove_existing(&switchlink_db_mroute_obj_list, &obj->list_node); switchlink_free(obj); return SWITCHLINK_DB_STATUS_SUCCESS; } } return SWITCHLINK_DB_STATUS_ITEM_NOT_FOUND; }
switch_status_t switch_api_sflow_session_delete(switch_device_t device, switch_handle_t sflow_hdl, bool all_cleanup) { #ifdef P4_SFLOW_ENABLE switch_sflow_info_t *sflow_info; sflow_info = switch_sflow_info_get(sflow_hdl); if (!sflow_info) { return SWITCH_STATUS_INVALID_HANDLE; } if (!tommy_list_empty(&sflow_info->match_list) && !all_cleanup) { return SWITCH_STATUS_RESOURCE_IN_USE; } if (all_cleanup) { switch_sflow_match_entry_t *entry; tommy_node *node = NULL; while ((node = tommy_list_head(&sflow_info->match_list)) && node) { entry = (switch_sflow_match_entry_t *)node->data; // could be ingress or egress match entry switch_pd_sflow_match_table_delete(device, entry); tommy_list_remove_existing(&sflow_info->match_list, node); switch_sflow_ace_handle_delete(entry->sflow_ace_hdl); } } switch_pd_sflow_session_delete(device, sflow_info); if (sflow_info->mirror_hdl != SWITCH_API_INVALID_HANDLE) { switch_api_mirror_session_delete(device, sflow_info->mirror_hdl); } switch_sflow_handle_delete(sflow_hdl); return SWITCH_STATUS_SUCCESS; #else (void)device; (void)sflow_hdl; (void)all_cleanup; return SWITCH_STATUS_FAILURE; #endif // P4_SFLOW_ENABLE }