static void init_phy_port_obj(npu_id_t npu, port_t port, cps_api_object_t obj) { cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_IF_PHY_PHYSICAL_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_NPU_ID,npu); cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_PORT_ID,port); }
TEST(std_nas_route_test, nas_neighbor_set) { cps_api_object_t obj = cps_api_object_create(); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_NBR_AF,AF_INET); uint32_t ip; struct in_addr a; inet_aton("6.6.6.6",&a); ip=a.s_addr; cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_NBR_ADDRESS,&ip,sizeof(ip)); int port_index = if_nametoindex("e101-001-0"); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_NBR_IFINDEX, port_index); hal_mac_addr_t mac_addr = {0x00, 0x00, 0x00, 0xaa, 0xbb, 0xcc}; cps_api_object_attr_add(obj, BASE_ROUTE_OBJ_NBR_MAC_ADDR, &mac_addr, HAL_MAC_ADDR_LEN); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_set(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); }
static cps_api_return_code_t get_interface( const char * name, cps_api_get_params_t *param, size_t *ix) { cps_api_object_t obj = cps_api_object_create(); uint_t ifix = cps_api_interface_name_to_if_index(name); cps_api_int_if_key_create(cps_api_object_key(obj),true,0,ifix); if (!cps_api_object_list_append(param->list,obj)) { cps_api_object_delete(obj); return cps_api_ret_code_ERR; } cps_api_object_attr_add(obj,cps_api_if_STRUCT_A_NAME,name,strlen(name)+1); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_IFINDEX,ifix); unsigned int mtu; if (nas_os_util_int_mtu_get(name,&mtu)!=STD_ERR_OK) return cps_api_ret_code_ERR; cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_MTU,mtu); db_interface_state_t astate; db_interface_operational_state_t ostate; if (nas_os_util_int_admin_state_get(name,&astate,&ostate)!=STD_ERR_OK) return cps_api_ret_code_ERR; cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_ADMIN_STATE,astate); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_OPER_STATE,ostate); hal_mac_addr_t mac; if (nas_os_util_int_mac_addr_get(name,&mac)!=STD_ERR_OK) return cps_api_ret_code_ERR; cps_api_object_attr_add(obj,cps_api_if_STRUCT_A_IF_MACADDR,&mac,sizeof(mac)); return cps_api_ret_code_OK; }
t_std_error nas_mac_publish_entry(nas_mac_entry_t *entry,bool is_static,bool flush_all, cps_api_operation_types_t op){ if(entry == nullptr){ NAS_MAC_LOG(ERR,0,"Null MAC entry pointer passed to convert it to cps object"); return STD_ERR(MAC,PARAM,0); } cps_api_object_t obj = cps_api_object_create(); if(obj == nullptr){ NAS_MAC_LOG(ERR,0,"Failed to allocate memory to cps object"); return STD_ERR(MAC,NOMEM,0); } cps_api_key_t key; cps_api_key_from_attr_with_qual(&key, BASE_MAC_TABLE_OBJ, cps_api_qualifier_OBSERVED); cps_api_object_set_type_operation(&key,op); cps_api_object_set_key(obj,&key); if(!flush_all){ cps_api_object_attr_add_u32(obj,BASE_MAC_TABLE_IFINDEX,entry->ifindex); cps_api_object_attr_add_u32(obj,BASE_MAC_TABLE_ACTIONS,entry->pkt_action); cps_api_object_attr_add_u16(obj,BASE_MAC_TABLE_VLAN,entry->entry_key.vlan_id); cps_api_object_attr_add(obj,BASE_MAC_TABLE_MAC_ADDRESS,(void*)entry->entry_key.mac_addr, sizeof(entry->entry_key.mac_addr)); cps_api_object_attr_add_u32(obj,BASE_MAC_TABLE_STATIC,is_static); } NAS_MAC_LOG(INFO,3,"Publishing an event with operation %d",op); return nas_mac_event_publish(obj); }
TEST(std_nas_route_test, nas_route_mp_delete) { cps_api_object_t obj = cps_api_object_create(); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_AF,AF_INET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_VRF_ID,0); uint32_t ip; struct in_addr a; inet_aton("6.6.6.6",&a); ip=a.s_addr; cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX,&ip,sizeof(ip)); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_delete(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); printf("___________________________________________\n"); system("ip route show 6.6.6.6"); printf("___________________________________________\n"); }
TEST(std_nas_route_test, nas_neighbor_delete_static) { cps_api_object_t obj = cps_api_object_create(); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_NBR_AF,AF_INET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_NBR_TYPE,BASE_ROUTE_RT_TYPE_STATIC); uint32_t ip; struct in_addr a; inet_aton("6.6.6.7",&a); ip=a.s_addr; cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_NBR_ADDRESS,&ip,sizeof(ip)); int port_index = if_nametoindex("e101-001-0"); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_NBR_IFINDEX, port_index); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_delete(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); }
TEST(cps_api_db,db_node_list) { cps_api_object_t obj = cps_api_object_create(); cps_api_object_guard og(obj); ASSERT_TRUE(og.get()!=nullptr); cps_api_node_ident ids[2] = { {"NODE1", "10.11.56.37:6379"}, {"NODE2","127.0.0.1:6379"} }; cps_api_node_group_t _g; _g.id = "A"; _g.addrs = ids; _g.addr_len = 2; _g.data_type = cps_api_node_data_1_PLUS_1_REDUNDENCY; ASSERT_EQ(cps_api_set_node_group(&_g),cps_api_ret_code_OK); ASSERT_EQ(cps_api_set_master_node("A","NODE1"),cps_api_ret_code_OK); cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_IP_IPV6,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_IP_IPV6_VRF_ID,0); cps_api_object_attr_add_u32(obj,BASE_IP_IPV6_IFINDEX,1); cps_api_object_attr_add(obj,BASE_IP_IPV6_NAME,"Clifford",9); cps_api_key_set_group(obj,"A"); ASSERT_TRUE(cps_api_commit_one(cps_api_oper_CREATE, obj, 0, 200)==cps_api_ret_code_OK); ASSERT_EQ(cps_api_delete_node_group("A"),cps_api_ret_code_OK); }
TEST(std_nas_route_test, nas_route_add) { cps_api_object_t obj = cps_api_object_create(); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); /* * Check mandatory route attributes * BASE_ROUTE_OBJ_ENTRY_AF, BASE_ROUTE_OBJ_ENTRY_VRF_ID); * BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX, BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN; */ cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_AF,AF_INET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_VRF_ID,0); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); uint32_t ip; struct in_addr a; inet_aton("6.6.6.6",&a); ip=a.s_addr; cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX,&ip,sizeof(ip)); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); cps_api_attr_id_t ids[3]; const int ids_len = sizeof(ids)/sizeof(*ids); ids[0] = BASE_ROUTE_OBJ_ENTRY_NH_LIST; ids[1] = 0; ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_NH_ADDR; /* * Set Loopback0 NH */ inet_aton("127.0.0.1",&a); ip=a.s_addr; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_BIN, &ip,sizeof(ip)); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_NH_COUNT,1); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_create(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); }
static void nas_sflow_fill_object(cps_api_object_t obj,nas_sflow_map_it it){ cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_SFLOW_ENTRY_OBJ, cps_api_qualifier_TARGET); cps_api_set_key_data(obj,BASE_SFLOW_ENTRY_ID,cps_api_object_ATTR_T_U32, &it->second.nas_sflow_id,sizeof(it->second.nas_sflow_id)); cps_api_object_attr_add_u32(obj,BASE_SFLOW_ENTRY_ID,it->second.nas_sflow_id); cps_api_object_attr_add_u32(obj,BASE_SFLOW_ENTRY_IFINDEX,it->second.ifindex); cps_api_object_attr_add_u32(obj,BASE_SFLOW_ENTRY_DIRECTION, it->second.ndi_sflow_entry.sflow_direction); cps_api_object_attr_add_u32(obj,BASE_SFLOW_ENTRY_SAMPLING_RATE, it->second.ndi_sflow_entry.sampling_rate); }
static t_std_error dn_nas_get_phy_media_default_setting(PLATFORM_MEDIA_TYPE_t media_type, cps_api_object_t obj) { cps_api_get_params_t gp; cps_api_get_request_init(&gp); cps_api_get_request_guard rg(&gp); cps_api_object_t media_obj = cps_api_object_list_create_obj_and_append(gp.filters); t_std_error rc = STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_FAIL, 0); do { if (!cps_api_key_from_attr_with_qual(cps_api_object_key(media_obj), BASE_MEDIA_MEDIA_INFO_OBJ, cps_api_qualifier_OBSERVED)) { break; } cps_api_set_key_data_uint(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, &media_type, sizeof(media_type)); cps_api_object_attr_add_u32(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, media_type); if (cps_api_get(&gp) != cps_api_ret_code_OK) break; if (0 == cps_api_object_list_size(gp.list)) break; media_obj = cps_api_object_list_get(gp.list,0); if (!cps_api_object_clone(obj, media_obj)) { break; } rc = STD_ERR_OK; } while(0); return rc; }
bool INTERFACE::os_interface_lag_attrs_handler(if_details *details, cps_api_object_t obj) { if_bond *bond_hdlr = os_get_bond_db_hdlr(); hal_ifindex_t master_idx = (details->_attrs[IFLA_MASTER]!=NULL)? *(int *)nla_data(details->_attrs[IFLA_MASTER]):0; if (details->_info_kind!=nullptr && !strncmp(details->_info_kind, "tun", 3)) { if(details->_attrs[IFLA_MASTER]!=NULL && ((details->_flags & IFF_SLAVE)!=0)) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Received tun %d and state 0x%x", details->_ifindex,details->_flags); if(bond_hdlr && bond_hdlr->bond_mbr_present(master_idx, details->_ifindex)){ EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Bond mbr present in master %d, slave %d", master_idx, details->_ifindex); return true; } if(bond_hdlr) bond_hdlr->bond_mbr_add(master_idx, details->_ifindex); // Unmask the event publish for this interface after lag addition os_interface_mask_event(details->_ifindex, OS_IF_CHANGE_NONE); if(!os_interface_lag_add_member_name(details->_ifindex, obj)) return false; details->_type = BASE_CMN_INTERFACE_TYPE_LAG; } else if ((details->_flags & IFF_SLAVE)!=0) { if(bond_hdlr && (master_idx = bond_hdlr->bond_master_get(details->_ifindex))) bond_hdlr->bond_mbr_del(master_idx, details->_ifindex); if(!master_idx) { EV_LOGGING(NAS_OS, DEBUG, "NET-MAIN", "No master found, this could be an if update for %d", details->_ifindex); return true; } EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Lag member delete: tun %d and state 0x%x", details->_ifindex,details->_flags); if(!os_interface_lag_add_member_name(details->_ifindex, obj)) return false; cps_api_object_attr_delete(obj, DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX); cps_api_object_attr_delete(obj, IF_INTERFACES_INTERFACE_NAME); cps_api_object_attr_add_u32(obj, DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX,master_idx); details->_type = BASE_CMN_INTERFACE_TYPE_LAG; details->_op = cps_api_oper_DELETE; } } if(details->_info_kind!=nullptr && !strncmp(details->_info_kind, "bond", 4)) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Bond interface index is %d ", details->_ifindex); if (details->_attrs[IFLA_MASTER]==nullptr) { details->_type = BASE_CMN_INTERFACE_TYPE_LAG; } } // bond interface return true; }
TEST(std_nas_route_test, nas_route_delete_scale) { char ip_addr[256]; int i=1, j=1; uint32_t ip; struct in_addr a; for(i=1; i<65; i++) { for (j=1; j<251; j++) { cps_api_object_t obj = cps_api_object_create(); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_AF,AF_INET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_VRF_ID,0); snprintf(ip_addr,256, "11.10.%d.%d",i,j); //printf ("Delete Route:%s \n", ip_addr); inet_aton(ip_addr,&a); //inet_aton("6.6.6.6",&a); ip=a.s_addr; cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX,&ip,sizeof(ip)); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_delete(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); } } }
static void _if_fill_in_supported_speeds_attrs(npu_id_t npu, port_t port, cps_api_object_t obj) { size_t speed_count = NDI_PORT_SUPPORTED_SPEED_MAX; BASE_IF_SPEED_t speed_list[NDI_PORT_SUPPORTED_SPEED_MAX]; if (ndi_port_supported_speed_get(npu,port,&speed_count, speed_list) == STD_ERR_OK) { size_t mx = speed_count; for (size_t ix =0;ix < mx; ix++) { cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_SUPPORTED_SPEED, speed_list[ix]); } } }
t_std_error nas_os_util_int_get_if_details(const char *name, cps_api_object_t obj) { struct ifreq ifr; strncpy(ifr.ifr_ifrn.ifrn_name,name,sizeof(ifr.ifr_ifrn.ifrn_name)-1); const int NAS_LINK_MTU_HDR_SIZE = 32; int sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock==-1) return STD_ERR(INTERFACE,FAIL,errno); t_std_error err = STD_ERR(INTERFACE,FAIL,errno); cps_api_object_attr_add(obj, IF_INTERFACES_INTERFACE_NAME, name, (strlen(name)+1)); do { if (ioctl(sock, SIOCGIFFLAGS, &ifr) >= 0) { cps_api_object_attr_add_u32(obj,BASE_IF_LINUX_IF_INTERFACES_INTERFACE_IF_FLAGS, ifr.ifr_flags); cps_api_object_attr_add_u32(obj,IF_INTERFACES_INTERFACE_ENABLED, (ifr.ifr_flags & IFF_UP) ? true :false); } else break; ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER; if (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0) { char buff[40]; const char *_p = std_mac_to_string((const hal_mac_addr_t *)(ifr.ifr_hwaddr.sa_data), buff, sizeof(buff)); cps_api_object_attr_add(obj,DELL_IF_IF_INTERFACES_INTERFACE_PHYS_ADDRESS,_p,strlen(_p)+1); } else break; if (ioctl(sock, SIOCGIFMTU, &ifr) >= 0) { cps_api_object_attr_add_u32(obj, DELL_IF_IF_INTERFACES_INTERFACE_MTU, (ifr.ifr_mtu + NAS_LINK_MTU_HDR_SIZE)); } else break; err = STD_ERR_OK; } while(0); close(sock); return err; }
static void _ndi_port_event_update_ (ndi_port_t *ndi_port, ndi_port_event_t event, uint32_t hwport) { cps_api_object_guard og(cps_api_object_create()); init_phy_port_obj(ndi_port->npu_id,ndi_port->npu_port,og.get()); cps_api_object_attr_add_u32(og.get(),BASE_IF_PHY_PHYSICAL_HARDWARE_PORT_ID,hwport); if (!(event == ndi_port_ADD || event==ndi_port_DELETE)) return ; cps_api_object_set_type_operation(cps_api_object_key(og.get()),event == ndi_port_ADD ? cps_api_oper_CREATE : cps_api_oper_DELETE ); hal_interface_send_event(og.get()); }
static void nas_mirror_fill_object(cps_api_object_t obj, nas_mirror_table_it it){ nas_mirror_entry & entry = it->second; cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_MIRROR_ENTRY_OBJ, cps_api_qualifier_TARGET); nas_mirror_id_t id = entry.get_id(); cps_api_set_key_data(obj,BASE_MIRROR_ENTRY_ID,cps_api_object_ATTR_T_U32, &id,sizeof(id)); cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_ID,id); nas::ndi_obj_id_table_t mirror_opaque_data_table; mirror_opaque_data_table[entry.get_npu_id()] = entry.get_ndi_id(); cps_api_attr_id_t attr_id_list[] = {BASE_MIRROR_ENTRY_OPAQUE_DATA}; nas::ndi_obj_id_table_cps_serialize (mirror_opaque_data_table, obj, attr_id_list, sizeof(attr_id_list)/sizeof(attr_id_list[0])); cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_DST_INTF,entry.get_dst_intf()); cps_api_attr_id_t ids[3] = {BASE_MIRROR_ENTRY_INTF,0,BASE_MIRROR_ENTRY_INTF_SRC }; const int ids_len = sizeof(ids)/sizeof(ids[0]); for(auto src_it = entry.get_src_intf_map()->begin() ; src_it != entry.get_src_intf_map()->end() ; ++src_it){ cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32,&(src_it->first),sizeof(src_it->first)); ids[2]=BASE_MIRROR_ENTRY_INTF_DIRECTION; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32,&(src_it->second),sizeof(src_it->second)); ids[2]=BASE_MIRROR_ENTRY_INTF_SRC; ++ids[1]; } cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_FLOW_ENABLED,entry.get_flow()); cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_TYPE,entry.get_mode()); if(entry.get_mode() == BASE_MIRROR_MODE_RSPAN){ cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_VLAN,entry.get_vlan_id()); } if(entry.get_mode() == BASE_MIRROR_MODE_ERSPAN){ cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_SOURCE_IP,entry.get_dst_ip()->u.v4_addr); cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_DESTINATION_IP,entry.get_src_ip()->u.v4_addr); cps_api_object_attr_add(obj,BASE_MIRROR_ENTRY_SOURCE_MAC,(void *)entry.get_src_mac(),sizeof(hal_mac_addr_t)); cps_api_object_attr_add(obj,BASE_MIRROR_ENTRY_DEST_MAC,(void *)entry.get_dst_mac(),sizeof(hal_mac_addr_t)); cps_api_object_attr_add_u32(obj,BASE_MIRROR_ENTRY_ERSPAN_VLAN_ID,entry.get_vlan_id()); } }
extern "C" t_std_error dn_hal_get_interface_mac(hal_ifindex_t if_index, hal_mac_addr_t mac_addr) { if(mac_addr == NULL) { EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C","mac_addr_ptr NULL"); return(STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_PARAM, 0)); } cps_api_get_params_t gp; cps_api_get_request_init(&gp); cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters); t_std_error rc = STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_FAIL, 0); do { if (!cps_api_key_from_attr_with_qual(cps_api_object_key(obj), DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ, cps_api_qualifier_TARGET)) { break; } cps_api_object_attr_add_u32(obj,DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX, if_index); if (cps_api_get(&gp) != cps_api_ret_code_OK) break; if (0 == cps_api_object_list_size(gp.list)) break; obj = cps_api_object_list_get(gp.list,0); cps_api_object_attr_t attr = cps_api_object_attr_get(obj,DELL_IF_IF_INTERFACES_INTERFACE_PHYS_ADDRESS); if (attr != NULL) { void *_mac_str = cps_api_object_attr_data_bin(attr); size_t addr_len = strlen(static_cast<char *>(_mac_str)); EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C","mac_addr %s, len %d", _mac_str, addr_len); if (std_string_to_mac((hal_mac_addr_t *)mac_addr, static_cast<const char *>(_mac_str), addr_len)) { rc = STD_ERR_OK; } } } while (0); cps_api_get_request_close(&gp); return rc; }
t_std_error dn_nas_lag_get_ndi_ids (hal_ifindex_t if_index, nas_ndi_obj_id_table_handle_t ndi_id_data) { if(ndi_id_data == NULL) { EV_LOG_ERR(ev_log_t_INTERFACE, 2, "INTF-C","Input ndi_data is NULL"); return(STD_ERR(INTERFACE, PARAM, 0)); } cps_api_get_params_t gp; cps_api_get_request_init(&gp); cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters); t_std_error rc = STD_ERR(INTERFACE, FAIL, 0); do { if (!cps_api_key_from_attr_with_qual(cps_api_object_key(obj), DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ, cps_api_qualifier_TARGET)) { break; } cps_api_object_attr_add_u32(obj,DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX, if_index); cps_api_object_attr_add(obj,IF_INTERFACES_INTERFACE_TYPE, (const char *)IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG, sizeof(IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG)); if (cps_api_get(&gp) != cps_api_ret_code_OK) break; if (0 == cps_api_object_list_size(gp.list)) break; obj = cps_api_object_list_get(gp.list,0); cps_api_attr_id_t attr_list[] = {BASE_IF_LAG_IF_INTERFACES_INTERFACE_LAG_OPAQUE_DATA}; if (!nas_ndi_obj_id_table_cps_unserialize (ndi_id_data, obj, attr_list, sizeof (attr_list)/sizeof (cps_api_attr_id_t))) { EV_LOG_ERR(ev_log_t_INTERFACE, 2, "INTF-C","Failed to get LAG opaque data"); break; } rc = STD_ERR_OK; } while (0); cps_api_get_request_close(&gp); return rc; }
static cps_api_return_code_t nas_qos_store_prev_attr(cps_api_object_t obj, const nas::attr_set_t attr_set, const nas_qos_scheduler_group &scheduler_group) { // filling in the keys uint32_t switch_id = scheduler_group.switch_id(); nas_obj_id_t sg_id = scheduler_group.get_scheduler_group_id(); cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_QOS_SCHEDULER_GROUP_OBJ, cps_api_qualifier_TARGET); cps_api_set_key_data(obj, BASE_QOS_SCHEDULER_GROUP_SWITCH_ID, cps_api_object_ATTR_T_U32, &switch_id, sizeof(uint32_t)); cps_api_set_key_data(obj, BASE_QOS_SCHEDULER_GROUP_ID, cps_api_object_ATTR_T_U64, &sg_id, sizeof(uint64_t)); for (auto attr_id: attr_set) { switch (attr_id) { case BASE_QOS_SCHEDULER_GROUP_ID: /* key */ break; case BASE_QOS_SCHEDULER_GROUP_CHILD_COUNT: case BASE_QOS_SCHEDULER_GROUP_CHILD_LIST: /* Read only attributes, no need to save */ break; case BASE_QOS_SCHEDULER_GROUP_PORT_ID: cps_api_object_attr_add_u32(obj, attr_id, scheduler_group.get_level()); break; case BASE_QOS_SCHEDULER_GROUP_SCHEDULER_PROFILE_ID: cps_api_object_attr_add_u64(obj, attr_id, scheduler_group.get_scheduler_profile_id()); break; default: break; } } return cps_api_ret_code_OK; }
TEST(std_nas_route_test, nas_peer_routing_config_set) { cps_api_object_t obj = cps_api_object_create(); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_PEER_ROUTING_CONFIG_OBJ,cps_api_qualifier_TARGET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_PEER_ROUTING_CONFIG_VRF_ID,0); hal_mac_addr_t mac_addr = {0x01, 0x22, 0x23, 0x24, 0x25, 0x26}; cps_api_object_attr_add(obj, BASE_ROUTE_PEER_ROUTING_CONFIG_PEER_MAC_ADDR, &mac_addr, HAL_MAC_ADDR_LEN); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_set(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); }
static void make_phy_port_details(npu_id_t npu, port_t port, cps_api_object_t obj) { init_phy_port_obj(npu,port,obj); if (_is_cpu_port(npu, port)) { return; } uint32_t hwport; if (get_hw_port(npu,port,hwport)) { cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_HARDWARE_PORT_ID,hwport); } //should be size_t int mode_count = BASE_IF_PHY_BREAKOUT_MODE_BREAKOUT_1X1+1; BASE_IF_PHY_BREAKOUT_MODE_t mode_list[BASE_IF_PHY_BREAKOUT_MODE_BREAKOUT_1X1+1]; if (ndi_port_supported_breakout_mode_get(npu,port, &mode_count,mode_list)==STD_ERR_OK) { size_t ix = 0; size_t mx = mode_count; for ( ; ix < mx ; ++ix ) { cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_BREAKOUT_CAPABILITIES,mode_list[ix]); } } BASE_IF_PHY_BREAKOUT_MODE_t cur_mode; if (ndi_port_breakout_mode_get(npu,port,&cur_mode)==STD_ERR_OK) { cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_FANOUT_MODE,cur_mode); } _if_fill_in_supported_speeds_attrs(npu,port,obj); auto it = _phy_port.find(hwport); if (it!=_phy_port.end()) { cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_FRONT_PANEL_NUMBER, it->second.front_panel_port); cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_PHY_MEDIA, it->second.media_type); cps_api_object_attr_add_u32(obj,BASE_IF_PHY_PHYSICAL_LOOPBACK, it->second.loopback); } }
bool cps_delete_mac(){ // Create and initialize the transaction object cps_api_transaction_params_t tran; if (cps_api_transaction_init(&tran) != cps_api_ret_code_OK ){ return false; } // Create and initialize the key cps_api_key_t key; cps_api_key_from_attr_with_qual(&key, BASE_MAC_TABLE_OBJ, cps_api_qualifier_TARGET); // Create the object cps_api_object_t obj = cps_api_object_create(); if(obj == NULL ){ cps_api_transaction_close(&tran); return false; } // Set the key for the object cps_api_object_set_key(obj,&key); // Add attributes mandatory to create MAC address entry uint8_t mac_addr[6] = {0x0,0xa,0xb,0xc,0xd,0xe}; uint16_t vlan_id = 131; cps_api_object_attr_add(obj,BASE_MAC_TABLE_MAC_ADDRESS, mac_addr, sizeof(hal_mac_addr_t)); cps_api_object_attr_add_u32(obj,BASE_MAC_TABLE_IFINDEX,if_nametoindex("e101-001-0") ); cps_api_object_attr_add_u16(obj,BASE_MAC_TABLE_VLAN,vlan_id); // Add the object along with the operation to transaction if(cps_api_delete(&tran,obj) != cps_api_ret_code_OK ){ cps_api_delete_object(obj); return false; }
static t_std_error nas_os_publish_route(int rt_msg_type, cps_api_object_t obj) { static char buff[MAX_CPS_MSG_SIZE]; cps_api_object_t new_obj = cps_api_object_init(buff,sizeof(buff)); cps_api_key_init(cps_api_object_key(new_obj),cps_api_qualifier_TARGET, cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0 ); cps_api_object_attr_t prefix = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX); cps_api_object_attr_t af = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_AF); cps_api_object_attr_t pref_len = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN); cps_api_object_attr_t nh_count = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_NH_COUNT); if(rt_msg_type == RTM_NEWROUTE) { cps_api_object_attr_add_u32(new_obj, cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_ADD); } else if(rt_msg_type == RTM_DELROUTE) { cps_api_object_attr_add_u32(new_obj, cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_DEL); } else { return false; } cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_FAMILY, cps_api_object_attr_data_u32(af)); uint32_t addr_len; hal_ip_addr_t ip; if(cps_api_object_attr_data_u32(af) == AF_INET) { struct in_addr *inp = (struct in_addr *) cps_api_object_attr_data_bin(prefix); std_ip_from_inet(&ip,inp); addr_len = HAL_INET4_LEN; } else { struct in6_addr *inp6 = (struct in6_addr *) cps_api_object_attr_data_bin(prefix); std_ip_from_inet6(&ip,inp6); addr_len = HAL_INET6_LEN; } cps_api_attr_id_t attr = cps_api_if_ROUTE_A_PREFIX; cps_api_object_e_add(new_obj, &attr, 1, cps_api_object_ATTR_T_BIN, &ip, sizeof(ip)); cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_PREFIX_LEN, cps_api_object_attr_data_u32(pref_len)); uint32_t nhc = 0; if (nh_count != CPS_API_ATTR_NULL) nhc = cps_api_object_attr_data_u32(nh_count); if (nhc == 1) { cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_HOP_COUNT,nhc); cps_api_attr_id_t ids[3] = { BASE_ROUTE_OBJ_ENTRY_NH_LIST, 0, BASE_ROUTE_OBJ_ENTRY_NH_LIST_NH_ADDR}; const int ids_len = sizeof(ids)/sizeof(*ids); cps_api_object_attr_t gw = cps_api_object_e_get(obj,ids,ids_len); ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_IFINDEX; cps_api_object_attr_t gwix = cps_api_object_e_get(obj,ids,ids_len); cps_api_attr_id_t new_ids[3]; new_ids[0] = cps_api_if_ROUTE_A_NH; new_ids[1] = 0; if (gw != CPS_API_ATTR_NULL) { new_ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; hal_ip_addr_t ip; if(addr_len == HAL_INET4_LEN) { ip.af_index = AF_INET; memcpy(&(ip.u.v4_addr), cps_api_object_attr_data_bin(gw),addr_len); } else { ip.af_index = AF_INET6; memcpy(&(ip.u.v6_addr), cps_api_object_attr_data_bin(gw),addr_len); } cps_api_object_e_add(new_obj, new_ids, ids_len, cps_api_object_ATTR_T_BIN, &ip,sizeof(ip)); } if (gwix != CPS_API_ATTR_NULL) { new_ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; uint32_t gw_idx = cps_api_object_attr_data_u32(gwix); cps_api_object_e_add(new_obj,new_ids,ids_len,cps_api_object_ATTR_T_U32, (void *)&gw_idx, sizeof(uint32_t)); } } EV_LOG(INFO, NAS_OS, 2,"ROUTE-UPD","Publishing object"); net_publish_event(new_obj); return STD_ERR_OK; }
//db_route_t bool nl_to_route_info(int rt_msg_type, struct nlmsghdr *hdr, cps_api_object_t obj) { struct rtmsg *rtmsg = (struct rtmsg *)NLMSG_DATA(hdr); char addr_str[INET6_ADDRSTRLEN]; if(hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*rtmsg))) return false; if(rt_msg_type == RTM_NEWROUTE) { cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_ADD); } else if(rt_msg_type == RTM_DELROUTE) { cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_DEL); } else { return false; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_PROTOCOL,rtmsg->rtm_protocol); cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_FAMILY,rtmsg->rtm_family); int attr_len = nlmsg_attrlen(hdr,sizeof(*rtmsg)); struct nlattr *head = nlmsg_attrdata(hdr, sizeof(struct rtmsg)); struct nlattr *attrs[__IFLA_MAX]; memset(attrs,0,sizeof(attrs)); if (nla_parse(attrs,__IFLA_MAX,head,attr_len)!=0) { EV_LOG(ERR,ROUTE,0,"NL-ROUTE-PARSE","Failed to parse attributes"); return false; } cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0 ); if(attrs[RTA_DST]!=NULL) { rta_add_ip((struct nlattr*)attrs[RTA_DST],rtmsg->rtm_family, obj,cps_api_if_ROUTE_A_PREFIX); } if((rtmsg->rtm_flags & RTM_F_CLONED) && (rtmsg->rtm_family == AF_INET6)) { // Skip cloned route updates char addr_str[INET6_ADDRSTRLEN]; EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","Cache entry %s", (attrs[RTA_DST]!=NULL)?(inet_ntop(rtmsg->rtm_family, ((struct in6_addr *) nla_data((struct nlattr*)attrs[RTA_DST])), addr_str, INET6_ADDRSTRLEN)):""); return false; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_PREFIX_LEN,rtmsg->rtm_dst_len); size_t hop_count = 0; cps_api_attr_id_t ids[3]; const int ids_len = sizeof(ids)/sizeof(*ids); ids[0] = cps_api_if_ROUTE_A_NH; ids[1] = hop_count; if (attrs[RTA_GATEWAY]!=NULL) { ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; rta_add_e_ip((struct nlattr*)attrs[RTA_GATEWAY], rtmsg->rtm_family,obj, ids,ids_len); rta_add_ip((struct nlattr*)attrs[RTA_GATEWAY],rtmsg->rtm_family,obj, cps_api_if_ROUTE_A_NEXT_HOP_ADDR); } if (attrs[RTA_OIF]!=NULL) { ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; unsigned int *x = (unsigned int *) nla_data(attrs[RTA_OIF]); cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, nla_data(attrs[RTA_OIF]),sizeof(uint32_t)); cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_NH_IFINDEX,*x); } nas_os_log_route_info(rt_msg_type, rtmsg, attrs); if (attrs[RTA_MULTIPATH]) { //array of next hops struct rtnexthop * rtnh = (struct rtnexthop * )nla_data(attrs[RTA_MULTIPATH]); int remaining = nla_len(attrs[RTA_MULTIPATH]); while (RTNH_OK(rtnh, remaining)) { ids[1] = hop_count; ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; uint32_t _int = rtnh->rtnh_ifindex; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &rtnh->rtnh_ifindex,sizeof(uint32_t)); _int = rtnh->rtnh_flags; ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_FLAGS; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &_int,sizeof(uint32_t)); ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_WEIGHT; _int = rtnh->rtnh_hops; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &_int,sizeof(uint32_t)); struct nlattr *nhattr[__RTA_MAX]; memset(nhattr,0,sizeof(nhattr)); nhrt_parse(nhattr,__IFLA_MAX,rtnh); if (nhattr[RTA_GATEWAY]) { ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; rta_add_e_ip((struct nlattr*)nhattr[RTA_GATEWAY], rtmsg->rtm_family,obj, ids,ids_len); EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","MultiPath nh-cnt:%d gateway:%s ifIndex:%d nh-flags:0x%x weight:%d", hop_count, ((rtmsg->rtm_family == AF_INET) ? (inet_ntop(rtmsg->rtm_family, ((struct in_addr *) nla_data((struct nlattr*)nhattr[RTA_GATEWAY])), addr_str, INET_ADDRSTRLEN)) : (inet_ntop(rtmsg->rtm_family, ((struct in6_addr *) nla_data((struct nlattr*)nhattr[RTA_GATEWAY])), addr_str, INET6_ADDRSTRLEN))), rtnh->rtnh_ifindex, rtnh->rtnh_flags, rtnh->rtnh_hops); } else { EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","MultiPath nh-cnt:%d ifIndex:%d nh-flags:0x%x weight:%d", hop_count, rtnh->rtnh_ifindex, rtnh->rtnh_flags, rtnh->rtnh_hops); } rtnh = rtnh_next(rtnh,&remaining); ++hop_count; } } else { ++hop_count; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_HOP_COUNT,hop_count); return true; }
/** * This function provides NAS-QoS SCHEDULER_GROUP CPS API read function * @Param Standard CPS API params * @Return Standard Error Code */ cps_api_return_code_t nas_qos_cps_api_scheduler_group_read (void * context, cps_api_get_params_t * param, size_t ix) { cps_api_object_t obj = cps_api_object_list_get(param->filters, ix); cps_api_object_attr_t sg_attr = cps_api_get_key_data(obj, BASE_QOS_SCHEDULER_GROUP_ID); uint32_t port_id = 0, level; bool have_port = false, have_level = false; if (!sg_attr) { cps_api_object_it_t it; cps_api_object_it_begin(obj, &it); for ( ; cps_api_object_it_valid(&it); cps_api_object_it_next(&it)) { cps_api_attr_id_t id = cps_api_object_attr_id(it.attr); if (id == BASE_QOS_SCHEDULER_GROUP_PORT_ID) { port_id = cps_api_object_attr_data_u32(it.attr); have_port = true; } else if (id == BASE_QOS_SCHEDULER_GROUP_LEVEL) { level = cps_api_object_attr_data_u32(it.attr); have_level = true; } } } if (!sg_attr && !have_port) { EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS", "Invalid input attributes for reading"); return NAS_QOS_E_MISSING_KEY; } uint_t switch_id = 0; nas_obj_id_t scheduler_group_id = (sg_attr? cps_api_object_attr_data_u64(sg_attr): 0); EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Read switch id %u, scheduler_group id 0x%016lX\n", switch_id, scheduler_group_id); std_mutex_simple_lock_guard p_m(&scheduler_group_mutex); if (have_port) { nas_qos_port_scheduler_group_init(port_id); } nas_qos_switch * p_switch = nas_qos_get_switch(switch_id); if (p_switch == NULL) return NAS_QOS_E_FAIL; std::vector<nas_qos_scheduler_group *> sg_list; if (sg_attr) { nas_qos_scheduler_group *scheduler_group = p_switch->get_scheduler_group(scheduler_group_id); if (scheduler_group == NULL) { EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS", "Could not find scheduler group with ID %llu", scheduler_group_id); return NAS_QOS_E_FAIL; } sg_list.push_back(scheduler_group); } else { int match_level = have_level ? (int)level : -1; p_switch->get_port_scheduler_groups(port_id, match_level, sg_list); } /* fill in data */ cps_api_object_t ret_obj; for (auto scheduler_group: sg_list) { ret_obj = cps_api_object_list_create_obj_and_append (param->list); if (ret_obj == NULL) { EV_LOG_TRACE(ev_log_t_QOS, ev_log_s_MINOR, "NAS-QOS", "Failed to create cps object"); return cps_api_ret_code_ERR; } cps_api_key_from_attr_with_qual(cps_api_object_key(ret_obj),BASE_QOS_SCHEDULER_GROUP_OBJ, cps_api_qualifier_TARGET); cps_api_set_key_data(ret_obj, BASE_QOS_SCHEDULER_GROUP_SWITCH_ID, cps_api_object_ATTR_T_U32, &switch_id, sizeof(uint32_t)); scheduler_group_id = scheduler_group->get_scheduler_group_id(); cps_api_set_key_data(ret_obj, BASE_QOS_SCHEDULER_GROUP_ID, cps_api_object_ATTR_T_U64, &scheduler_group_id, sizeof(uint64_t)); cps_api_object_attr_add_u32(ret_obj, BASE_QOS_SCHEDULER_GROUP_CHILD_COUNT, scheduler_group->get_child_count()); for (uint32_t idx = 0; idx < scheduler_group->get_child_count(); idx++) { cps_api_object_attr_add_u64(ret_obj, BASE_QOS_SCHEDULER_GROUP_CHILD_LIST, scheduler_group->get_child_id(idx)); } cps_api_object_attr_add_u32(ret_obj, BASE_QOS_SCHEDULER_GROUP_PORT_ID, scheduler_group->get_port_id()); cps_api_object_attr_add_u32(ret_obj, BASE_QOS_SCHEDULER_GROUP_LEVEL, scheduler_group->get_level()); cps_api_object_attr_add_u64(ret_obj, BASE_QOS_SCHEDULER_GROUP_SCHEDULER_PROFILE_ID, scheduler_group->get_scheduler_profile_id()); } return cps_api_ret_code_OK; }
//Scale tests for route add/delete TEST(std_nas_route_test, nas_route_add_scale) { char ip_addr[256]; int i=1, j=1 ,count=0; uint32_t ip; struct in_addr a; for(i=1; i<101; i++) { for (j=1; j<251; j++) { cps_api_object_t obj = cps_api_object_create(); cps_api_key_from_attr_with_qual(cps_api_object_key(obj), BASE_ROUTE_OBJ_OBJ,cps_api_qualifier_TARGET); //cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, // cps_api_obj_CAT_BASE_ROUTE, BASE_ROUTE_OBJ_OBJ,0 ); /* * Check mandatory route attributes * BASE_ROUTE_OBJ_ENTRY_AF, BASE_ROUTE_OBJ_ENTRY_VRF_ID); * BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX, BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN; */ cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_AF,AF_INET); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_VRF_ID,0); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); snprintf(ip_addr,256, "11.10.%d.%d",i,j); // printf ("Add Route:%s, NH:1.1.1.4\n", ip_addr); inet_aton(ip_addr,&a); //inet_aton("6.6.6.6",&a); ip=a.s_addr; //printf ("Route:%d\n", ip); cps_api_object_attr_add(obj,BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX,&ip,sizeof(ip)); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN,32); cps_api_attr_id_t ids[3]; const int ids_len = sizeof(ids)/sizeof(*ids); ids[0] = BASE_ROUTE_OBJ_ENTRY_NH_LIST; ids[1] = 0; ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_NH_ADDR; /* * Set NH */ inet_aton("1.1.1.4",&a); ip=a.s_addr; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_BIN, &ip,sizeof(ip)); cps_api_object_attr_add_u32(obj,BASE_ROUTE_OBJ_ENTRY_NH_COUNT,1); /* * CPS transaction */ cps_api_transaction_params_t tr; ASSERT_TRUE(cps_api_transaction_init(&tr)==cps_api_ret_code_OK); cps_api_create(&tr,obj); ASSERT_TRUE(cps_api_commit(&tr)==cps_api_ret_code_OK); cps_api_transaction_close(&tr); count++; } } printf("Sent %d Routes\n", count); }
extern "C" bool nl_get_ip_info (int rt_msg_type, struct nlmsghdr *hdr, cps_api_object_t obj) { struct ifaddrmsg *ifmsg = (struct ifaddrmsg *)NLMSG_DATA(hdr); if(hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*ifmsg))) return false; typedef enum { IP_KEY, IFINDEX, PREFIX, ADDRESS, IFNAME } attr_t ; static const std::map<uint32_t, std::map<int,cps_api_attr_id_t>> _ipmap = { {AF_INET, { {IP_KEY, BASE_IP_IPV4_OBJ}, {IFINDEX, BASE_IP_IPV4_IFINDEX}, {PREFIX, BASE_IP_IPV4_ADDRESS_PREFIX_LENGTH}, {ADDRESS, BASE_IP_IPV4_ADDRESS_IP}, {IFNAME, BASE_IP_IPV4_NAME} }}, {AF_INET6, { {IP_KEY, BASE_IP_IPV6_OBJ}, {IFINDEX, BASE_IP_IPV6_IFINDEX}, {PREFIX, BASE_IP_IPV6_ADDRESS_PREFIX_LENGTH}, {ADDRESS, BASE_IP_IPV6_ADDRESS_IP}, {IFNAME, BASE_IP_IPV6_NAME} }} }; cps_api_key_from_attr_with_qual(cps_api_object_key(obj),_ipmap.at(ifmsg->ifa_family).at(IP_KEY), cps_api_qualifier_TARGET); cps_api_set_key_data(obj,_ipmap.at(ifmsg->ifa_family).at(IFINDEX), cps_api_object_ATTR_T_U32, &ifmsg->ifa_index,sizeof(ifmsg->ifa_index)); cps_api_object_attr_add_u32(obj, _ipmap.at(ifmsg->ifa_family).at(IFINDEX), ifmsg->ifa_index); cps_api_object_attr_add_u32(obj, _ipmap.at(ifmsg->ifa_family).at(PREFIX), ifmsg->ifa_prefixlen); int nla_len = nlmsg_attrlen(hdr,sizeof(*ifmsg)); struct nlattr *head = nlmsg_attrdata(hdr, sizeof(struct ifaddrmsg)); struct nlattr *attrs[__IFLA_MAX]; memset(attrs,0,sizeof(attrs)); if (nla_parse(attrs,__IFLA_MAX,head,nla_len)!=0) { EV_LOG_TRACE(ev_log_t_NAS_OS,ev_log_s_WARNING,"IP-NL-PARSE","Failed to parse attributes"); cps_api_object_delete(obj); return false; } if(attrs[IFA_ADDRESS]!=NULL) { rta_add_ip((struct nlattr*)ifmsg, ifmsg->ifa_family, obj, _ipmap.at(ifmsg->ifa_family).at(ADDRESS)); } if(attrs[IFA_LABEL]!=NULL) { rta_add_name(attrs[IFA_LABEL], obj, _ipmap.at(ifmsg->ifa_family).at(IFNAME)); } if (rt_msg_type == RTM_NEWADDR) { cps_api_object_set_type_operation(cps_api_object_key(obj),cps_api_oper_CREATE); } else if (rt_msg_type == RTM_DELADDR) { cps_api_object_set_type_operation(cps_api_object_key(obj),cps_api_oper_DELETE); } else { cps_api_object_set_type_operation(cps_api_object_key(obj),cps_api_oper_SET); } return true; }
//db_if_event_t bool nl_get_if_info (int rt_msg_type, struct nlmsghdr *hdr, cps_api_object_t obj) { struct ifinfomsg *ifmsg = (struct ifinfomsg *)NLMSG_DATA(hdr); if(hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*ifmsg))) return false; db_if_type_t _type = DB_IF_TYPE_PHYS_INTER; uint_t ifindex = ifmsg->ifi_index; uint32_t op = 0; EV_LOG(INFO, NAS_OS, 3, "NET-MAIN", "nl_get_if_info msgType %d, ifindex %d change %x\n", rt_msg_type, ifindex, ifmsg->ifi_change); if (rt_msg_type ==RTM_NEWLINK) { op = DB_INTERFACE_OP_CREATE; } else if (rt_msg_type ==RTM_DELLINK) { op = DB_INTERFACE_OP_DELETE; } else { op = DB_INTERFACE_OP_SET; } cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_OPERATION,op); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_FLAGS, ifmsg->ifi_flags); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_IFINDEX,ifindex); if(ifmsg->ifi_flags & IFF_UP) { cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_ADMIN_STATE,DB_ADMIN_STATE_UP); } else { cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_ADMIN_STATE,DB_ADMIN_STATE_DN); } int nla_len = nlmsg_attrlen(hdr,sizeof(*ifmsg)); struct nlattr *head = nlmsg_attrdata(hdr, sizeof(struct ifinfomsg)); struct nlattr *attrs[__IFLA_MAX]; memset(attrs,0,sizeof(attrs)); if (nla_parse(attrs,__IFLA_MAX,head,nla_len)!=0) { EV_LOG(ERR,NAS_OS,0,"NL-PARSE","Failed to parse attributes"); cps_api_object_delete(obj); return false; } if (attrs[IFLA_ADDRESS]!=NULL) { rta_add_mac(attrs[IFLA_ADDRESS],obj,cps_api_if_STRUCT_A_IF_MACADDR); } if(attrs[IFLA_IFNAME]!=NULL) { rta_add_name(attrs[IFLA_IFNAME],obj,cps_api_if_STRUCT_A_NAME); } if(attrs[IFLA_MTU]!=NULL) { int *mtu = (int *) nla_data(attrs[IFLA_MTU]); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_MTU,(*mtu + NAS_LINK_MTU_HDR_SIZE)); } if(attrs[IFLA_MASTER]!=NULL) { /* This gives us the bridge index, which should be sent to * NAS for correlation */ EV_LOG(INFO, NAS_OS, 3, "NET-MAIN", "Rcvd master index %d", *(int *)nla_data(attrs[IFLA_MASTER])); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_MASTER, *(int *)nla_data(attrs[IFLA_MASTER])); if(op == DB_INTERFACE_OP_DELETE) { /* With Dell offering VLAN data structures use port index instead of * vlan interface */ int phy_ifindex = 0; nas_os_physical_to_vlan_ifindex(ifindex, 0, false, &phy_ifindex); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_IFINDEX, phy_ifindex); cps_api_object_attr_add_u32(obj, cps_api_if_STRUCT_A_VLAN_PORT_INDEX, ifindex); _type = DB_IF_TYPE_VLAN_INTER; } } struct nlattr *linkinfo[IFLA_INFO_MAX]; struct nlattr *vlan[IFLA_VLAN_MAX]; char *info_kind; if (attrs[IFLA_LINKINFO]) { memset(linkinfo,0,sizeof(linkinfo)); nla_parse_nested(linkinfo,IFLA_INFO_MAX,attrs[IFLA_LINKINFO]); if(linkinfo[IFLA_INFO_KIND]) { info_kind = (char *)nla_data(linkinfo[IFLA_INFO_KIND]); EV_LOG(INFO, NAS_OS, 3, "NET-MAIN", "In IFLA_INFO_KIND for %s index %d", info_kind, ifindex); if(!strncmp(info_kind, "vlan", 4)) { if(attrs[IFLA_MASTER]!=NULL) { if (linkinfo[IFLA_INFO_DATA]) { memset(vlan,0,sizeof(vlan)); nla_parse_nested(vlan,IFLA_VLAN_MAX,linkinfo[IFLA_INFO_DATA]); if (vlan[IFLA_VLAN_ID]) { EV_LOG(INFO, NAS_OS, 3, "NET-MAIN", "Received VLAN %d", ifindex); cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_VLAN_ID, *(uint16_t*)nla_data(vlan[IFLA_VLAN_ID])); _type = DB_IF_TYPE_VLAN_INTER; if (attrs[IFLA_LINK]) { //port that is added to vlan uint32_t portIndex = *(uint32_t*)nla_data(attrs[IFLA_LINK]); if (op == DB_INTERFACE_OP_DELETE) { cps_api_object_attr_add_u32(obj, cps_api_if_STRUCT_A_VLAN_PORT_INDEX, ifindex); } else { cps_api_object_attr_add_u32(obj, cps_api_if_STRUCT_A_VLAN_PORT_INDEX, portIndex); } } //IFLA_LINK } //IFLA_VLAN_ID }//IFLA_INFO_DATA }// IFLA_MASTER } // vlan interface else if(!strncmp(info_kind, "tun", 3)) { /* TODO : Revisit this and introduce a logical interface type */ if(attrs[IFLA_MASTER]!=NULL) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Received tun %d", ifindex); _type = DB_IF_TYPE_VLAN_INTER; cps_api_object_attr_add_u32(obj, cps_api_if_STRUCT_A_VLAN_PORT_INDEX, ifindex); } if(ifmsg->ifi_flags & IFF_SLAVE) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Received tun %d and state IFF_UP", ifindex,ifmsg->ifi_flags); _type = DB_IF_TYPE_LAG_INTER; } } else if(!strncmp(info_kind, "bridge", 6)) { EV_LOG(INFO,NAS_OS,3, "NET-MAIN", "Bridge intf index is %d ", ifindex); _type = DB_IF_TYPE_BRIDGE_INTER; } /* bridge interface */ else if(!strncmp(info_kind, "bond", 4)) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Bond interface index is %d ", ifindex); _type = DB_IF_TYPE_LAG_INTER; if(attrs[IFLA_MASTER]!=NULL) { EV_LOG(INFO, NAS_OS,3, "NET-MAIN", "Received bond %d with master set %d", ifindex, *(int *)nla_data(attrs[IFLA_MASTER])); /* Bond with master set, means configured in a bridge * Pass the master index as the ifindex for vlan processing to continue */ _type = DB_IF_TYPE_VLAN_INTER; cps_api_object_attr_add_u32(obj, cps_api_if_STRUCT_A_VLAN_PORT_INDEX, ifindex); if (op == DB_INTERFACE_OP_DELETE ) { cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_IFINDEX, *(int *)nla_data(attrs[IFLA_MASTER])); } } } // bond interface } } if(attrs[IFLA_OPERSTATE]!=NULL) { int *link = (int *) nla_data(attrs[IFLA_OPERSTATE]); if (*link==IF_OPER_UP) { cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_OPER_STATE,DB_OPER_STATE_UP); } else if (*link==IF_OPER_DOWN) { cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_OPER_STATE,DB_OPER_STATE_DN); } } cps_api_object_attr_add_u32(obj,cps_api_if_STRUCT_A_IF_TYPE,_type); cps_api_int_if_key_create(cps_api_object_key(obj),true,0,ifindex); return true; }