static int vlan_delete(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__VLAN_DELETE_MAX];
u8 mode = 0;
int resCode = LR_SUCCESS;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
json_object *result = NULL;
result = json_object_new_object();
blobmsg_parse(vlan_delete_policy, ARRAY_SIZE(vlan_delete_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[VLAN_DELETE_MODE]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
mode = blobmsg_get_u8(tb[VLAN_DELETE_MODE]);
if(mode){
int vid;
if(!tb[VLAN_DELETE_ID]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
vid = blobmsg_get_u16(tb[VLAN_DELETE_ID]);
resCode = delete_vlan_in_vlanDatabase(vid);
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
goto returnMsg;
}
json_object_object_add(result, "vlanID", json_object_new_int(vid));
}else{
/* delete all vlan */
resCode = delete_all_vlan_in_vlanDatabase();
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
goto returnMsg;
}
json_object_object_add(result, "flush", json_object_new_int(1));
}
pmsg = json_object_to_json_string(result);
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
if(result != NULL)
json_object_put(result);
return UBUS_STATUS_OK;
}
static void blobmsg_format_element(struct blob_attr *data, int next_indent)
{
switch (blobmsg_type(data)) {
case BLOBMSG_TYPE_UNSPEC:
printf("null\n");
break;
case BLOBMSG_TYPE_STRING:
printf("%s\n", blobmsg_get_string(data));
break;
case BLOBMSG_TYPE_BOOL:
printf("%s\n", blobmsg_get_u8(data) ? "true" : "false");
break;
case BLOBMSG_TYPE_INT16:
printf("%d\n", blobmsg_get_u16(data));
break;
case BLOBMSG_TYPE_INT32:
printf("%d\n", blobmsg_get_u32(data));
break;
case BLOBMSG_TYPE_INT64:
printf("%"PRIu64"\n", blobmsg_get_u64(data));
break;
case BLOBMSG_TYPE_TABLE:
case BLOBMSG_TYPE_ARRAY:
blobmsg_format_std_indent(data, next_indent);
break;
}
}
static int sw_reg_write(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__SW_REG_WRITE_MAX];
u8 phyAddr;
u8 regAddr;
u16 data;
int resCode = LR_SUCCESS;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
blobmsg_parse(sw_reg_write_policy, ARRAY_SIZE(sw_reg_write_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[SW_REG_WRITE_REG_ADDR] || !tb[SW_REG_WRITE_ADDR] || !tb[SW_REG_WRITE_DATA]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
phyAddr = blobmsg_get_u8(tb[SW_REG_WRITE_ADDR]);
regAddr = blobmsg_get_u8(tb[SW_REG_WRITE_REG_ADDR]);
data = blobmsg_get_u16(tb[SW_REG_WRITE_DATA]);
resCode = sw_chip_register_write_reg(phyAddr, regAddr, (int)data);
char buff[100];
sprintf(buff, "{\"phyAddr\":0x%2x, \"regAddr\":0x%2x, \"value\":0x%4x}", phyAddr,regAddr, data);
pmsg = buff;
//pmsg= getJsonMsg(resCode);
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
return UBUS_STATUS_OK;
}
static int conf_rpa_set(struct ipc_user *u, char *data, size_t len, __unused struct blob_buf *reply)
{
conf conf = container_of(u, conf_s, ipc_users[CONF_IPC_RPA_SET]);
struct blob_attr *tb[CONF_RPA_MAX];
struct in6_addr rpa;
if(blobmsg_parse(conf_rpa_attrs, CONF_RPA_MAX, tb, data, len) ||
!tb[CONF_RPA_RPA] || !addr_pton(&rpa, blobmsg_get_string(tb[CONF_RPA_RPA])) ||
tb[CONF_RPA_GROUPS])
return -1;
if(tb[CONF_RPA_RPL_JP])
pim_rpa_set_rpl_jp(conf->pim, &rpa, blobmsg_get_u8(tb[CONF_RPA_RPL_JP]));
return 0;
}
static int vlan_new(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__VLAN_NEW_MAX];
int vid;
u8 mstid = 0;
int resCode = LR_ERR_NONE;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
json_object *result = NULL;
blobmsg_parse(vlan_new_policy, ARRAY_SIZE(vlan_new_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[VLAN_NEW_ID]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
if(tb[VLAN_NEW_MSTID]){
mstid = blobmsg_get_u8(tb[VLAN_NEW_MSTID]);
}
vid = blobmsg_get_u16(tb[VLAN_NEW_ID]);
//resCode = create_vlan_have_none_port(vid);
resCode = create_vlan_have_none_port_ex(vid, mstid);
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
}else{
result = json_object_new_object();
json_object_object_add(result, "vlanID", json_object_new_int(vid));
pmsg = json_object_to_json_string(result);
}
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
if(result != NULL)
json_object_put(result);
return UBUS_STATUS_OK;
}
static void uqmi_print_result(struct blob_attr *data)
{
struct blob_attr *cur;
int rem;
blob_for_each_attr(cur, data, rem) {
switch (blobmsg_type(cur)) {
case BLOBMSG_TYPE_STRING:
printf("%s=%s\n", blobmsg_name(cur), (char *) blobmsg_data(cur));
break;
case BLOBMSG_TYPE_INT32:
printf("%s=%d\n", blobmsg_name(cur), (int32_t) blobmsg_get_u32(cur));
break;
case BLOBMSG_TYPE_INT8:
printf("%s=%s\n", blobmsg_name(cur), blobmsg_get_u8(cur) ? "true" : "false");
break;
}
}
}
static int vlan_mstp(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__VLAN_MSTP_MAX];
int resCode = LR_SUCCESS;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
u8 mstid = 0;
u8 portid = 0;
u8 portState = 0;
bool newMSTI = false;
bool delMSTI = false;
bool setPortState = false;
bool flushFids = false;
blobmsg_parse(vlan_mstp_policy, ARRAY_SIZE(vlan_mstp_policy), tb, blob_data(msg), blob_len(msg));
if(tb[VLAN_MSTP_FLUSH_FIDS]){
flushFids = blobmsg_get_bool(tb[VLAN_MSTP_FLUSH_FIDS]);
if(flushFids){
/* flush all FIDs */
resCode = delete_all_vlan_in_vlanDatabase();
goto process3;
}
}
if(!tb[VLAN_MSTP_MSTID]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
mstid = blobmsg_get_u8(tb[VLAN_MSTP_MSTID]);
if(tb[VLAN_MSTP_NEW_MSTI]){
newMSTI = blobmsg_get_bool(tb[VLAN_MSTP_NEW_MSTI]);
if(newMSTI){
/* create new msti */
resCode = add_msti_to_hw(mstid);
goto process2;
}
}
if(tb[VLAN_MSTP_DELETE_MSTI]){
delMSTI = blobmsg_get_bool(tb[VLAN_MSTP_DELETE_MSTI]);
if(delMSTI){
/* delete msti */
resCode = delete_msti_to_hw(mstid);
}
}
process2:
if(tb[VLAN_MSTP_SET_PORT_STATE]){
setPortState = blobmsg_get_bool(tb[VLAN_MSTP_SET_PORT_STATE]);
if(setPortState){
/* set port state for msti */
if(!tb[VLAN_MSTP_PORTID] || !tb[VLAN_MSTP_PORT_STATE]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
portid = blobmsg_get_u8(tb[VLAN_MSTP_PORTID]);
portState = blobmsg_get_u8(tb[VLAN_MSTP_PORT_STATE]);
resCode = set_port_state_for_msti(mstid, portid, portState);
}
}
process3:
pmsg = getJsonMsg(resCode);
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
return UBUS_STATUS_OK;
}
static int vlan_port(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__VLAN_PORT_MAX];
int resCode = LR_SUCCESS;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
u16 vid = 0;
u8 portid = 0;
bool bind = false;
blobmsg_parse(vlan_port_policy, ARRAY_SIZE(vlan_port_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[VLAN_PORT_VLANID] || !tb[VLAN_PORT_PORTID]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
portid = blobmsg_get_u8(tb[VLAN_PORT_PORTID]);
vid = blobmsg_get_u16(tb[VLAN_PORT_VLANID]);
if(tb[VLAN_PORT_BIND]){
bind = blobmsg_get_bool(tb[VLAN_PORT_BIND]);
if(bind){
BASE_VLAN_PORT port;
PORT_LINK_TYPE linktype;
u16 pvid = 1;
if(!tb[VLAN_PORT_LINKTYPE]){
linktype = (gDevPorts+portid)->linktype;
}else{
linktype = blobmsg_get_u8(tb[VLAN_PORT_LINKTYPE]);
}
get_port_pvid(portid, &pvid);
port.portid = portid;
if(linktype == PORT_LINK_TYPE_ACCESS){
if(vid != pvid){
resCode = LR_ILLEGAL_OPR;
goto process2;
}
port.portAttr.egress = EGRESS_UNTAGGED;
}else if(linktype == PORT_LINK_TYPE_TRUNK){
if(vid == pvid)
port.portAttr.egress = EGRESS_UNTAGGED;
else
port.portAttr.egress = EGRESS_TAGGED;
}else if(linktype == PORT_LINK_TYPE_HYBRID){
//TODO: hybrid mode
}else if(linktype == PORT_LINK_TYPE_QINQ){
//TODO: QinQ mode
}else{
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
resCode = bind_vlan_to_port(vid, port);
goto process2;
}else{
resCode = unbind_vlan_from_port(vid, portid);
goto process2;
}
}
process2:
pmsg = getJsonMsg(resCode);
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
return UBUS_STATUS_OK;
}
static int vlan_find(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__VLAN_FIND_MAX];
u8 mode = 0;
int resCode = LR_SUCCESS;
const char *pmsg = getJsonMsg(LR_INVALID_PARAM);
json_object *result = NULL;
blobmsg_parse(vlan_find_policy, ARRAY_SIZE(vlan_find_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[VLAN_FIND_MODE]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
mode = blobmsg_get_u8(tb[VLAN_FIND_MODE]);
if(1 == mode){
/* find a special VLAN ID */
int vid;
bool found;
VLAN_ENTRY vlanEntry;
if(!tb[VLAN_FIND_ID]){
resCode = LR_INVALID_PARAM;
goto returnMsg;
}
vid = blobmsg_get_u16(tb[VLAN_FIND_ID]);
resCode = find_vlan_in_vlanDatabase(vid, &vlanEntry, &found);
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
goto returnMsg;
}
if(found){
resCode = LR_FOUND;
result = gen_json_object_vlan_entry(&vlanEntry);
pmsg = json_object_to_json_string(result);
}else{
resCode = LR_NOT_FOUND;
pmsg = getJsonMsg(LR_NOT_EXIST);
}
}else if( 3== mode){
/* find all VLAN ID in the hardware VLAN LIST , include port attribute*/
VLAN_ENTRY *vlanEntry = NULL;
int vlanEntryCnt;
resCode = find_all_vlan_in_vlanDatabase(&vlanEntry, &vlanEntryCnt);
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
goto returnMsg;
}
json_object *vidList = json_object_new_array();
result = json_object_new_object();
for(int i=0; i< vlanEntryCnt; i++){
json_object *vlnEntry = gen_json_object_vlan_entry(vlanEntry+i);
json_object_array_add(vidList, vlnEntry);
}
json_object_object_add(result, "vlanlist", vidList);
pmsg = json_object_to_json_string(result);
//free vlan entry
free_VLAN_ENTRY_pointer(vlanEntry, vlanEntryCnt);
}else{
/* find all VLAN ID in the hardware VLAN LIST */
u8 vids[4095] = {0};
int vidCnt;
int i;
memset(vids, 0, 4095);
resCode = find_all_vlan_in_vlanDatabase_summary((u8 *)&vids, &vidCnt);
if(resCode != LR_ERR_NONE){
pmsg = getJsonMsg(resCode);
goto returnMsg;
}
json_object *vidList = json_object_new_array();
result = json_object_new_object();
for(i=1; i< 4095; i++){
if(vids[i] == 1){
json_object_array_add(vidList, json_object_new_int(i));
}
}
json_object_object_add(result, "vlanlist", vidList);
pmsg = json_object_to_json_string(result);
}
returnMsg:
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "msg",pmsg);
blobmsg_add_u16(&b,"resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
if(result != NULL)
json_object_put(result);
return UBUS_STATUS_OK;
}
