static int aggregation_enable(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__AGGREGATION_MAX];
bool en;
int fds[2];
blobmsg_parse(aggregation_enable_policy, ARRAY_SIZE(aggregation_enable_policy), tb, blob_data(msg), blob_len(msg));
if(!tb[AGGREGATION_MODULE_ENABLE])
return UBUS_STATUS_INVALID_ARGUMENT;
en = blobmsg_get_bool(tb[AGGREGATION_MODULE_ENABLE]);
// TODO:check aggregation module is found, set enable status to require.
DEBUG("%s received enable message:%s\n", obj->name, en?"true":"false");
{
int resCode = LR_SUCCESS;
char msg[100];
char *pmsg = msg;
// TODO: add other attr
sprintf(msg,"set aggregation module to %s", en ? "true":"false");
blob_buf_init(&b, 0);
//blobmsg_add_u8(&b, "module_en",en);
blobmsg_add_string(&b, "msg", pmsg);
blobmsg_add_u16(&b, "resCode", resCode);
req->deferred = false;
ubus_send_reply(ctx, req, b.head);
}
#if 0
if(pipe(fds) == -1) {
fprintf(stderr, "Failed to create pipe\n");
return -1;
}
ubus_request_set_fd(ctx, req, fds[0]);
ubus_complete_deferred_request(ctx, req, 0);
{
char data[100]={0};
sprintf(data, "module %s\n", en ? "enable" : "disable" );
if(write(fds[1], data, strlen(data) ) < 0) {
close(fds[1]);
free(req);
return 0;
}
}
#endif
return 0;
}
static struct device_addr *
parse_address_item(struct blob_attr *attr, bool v6, bool ext)
{
struct device_addr *addr;
struct blob_attr *tb[__ADDR_MAX];
struct blob_attr *cur;
if (blobmsg_type(attr) != BLOBMSG_TYPE_TABLE)
return NULL;
addr = alloc_device_addr(v6, ext);
if (!addr)
return NULL;
blobmsg_parse(proto_ip_addr, __ADDR_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
addr->mask = v6 ? 128 : 32;
if ((cur = tb[ADDR_MASK])) {
unsigned int new_mask;
new_mask = parse_netmask_string(blobmsg_data(cur), v6);
if (new_mask > addr->mask)
goto error;
addr->mask = new_mask;
}
cur = tb[ADDR_IPADDR];
if (!cur)
goto error;
if (!inet_pton(v6 ? AF_INET6 : AF_INET, blobmsg_data(cur), &addr->addr))
goto error;
if ((cur = tb[ADDR_OFFLINK]) && blobmsg_get_bool(cur))
addr->flags |= DEVADDR_OFFLINK;
if (!v6) {
if ((cur = tb[ADDR_BROADCAST]) &&
!inet_pton(AF_INET, blobmsg_data(cur), &addr->broadcast))
goto error;
if ((cur = tb[ADDR_PTP]) &&
!inet_pton(AF_INET, blobmsg_data(cur), &addr->point_to_point))
goto error;
} else {
time_t now = system_get_rtime();
if ((cur = tb[ADDR_PREFERRED])) {
int64_t preferred = blobmsg_get_u32(cur);
int64_t preferred_until = preferred + (int64_t)now;
if (preferred_until <= LONG_MAX && preferred != 0xffffffffLL)
addr->preferred_until = preferred_until;
}
if ((cur = tb[ADDR_VALID])) {
int64_t valid = blobmsg_get_u32(cur);
int64_t valid_until = valid + (int64_t)now;
if (valid_until <= LONG_MAX && valid != 0xffffffffLL)
addr->valid_until = valid_until;
}
if (addr->valid_until) {
if (!addr->preferred_until)
addr->preferred_until = addr->valid_until;
else if (addr->preferred_until > addr->valid_until)
goto error;
}
if ((cur = tb[ADDR_CLASS]))
addr->pclass = strdup(blobmsg_get_string(cur));
}
return addr;
error:
free(addr);
return NULL;
}
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;
}
void
iprule_add(struct blob_attr *attr, bool v6)
{
struct interface *iif = NULL, *oif = NULL;
struct blob_attr *tb[__RULE_MAX], *cur;
struct interface *iface;
struct iprule *rule;
int af = v6 ? AF_INET6 : AF_INET;
blobmsg_parse(rule_attr, __RULE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr));
rule = calloc(1, sizeof(*rule));
if (!rule)
return;
rule->flags = v6 ? IPRULE_INET6 : IPRULE_INET4;
rule->order = iprules_counter[rule->flags]++;
if ((cur = tb[RULE_INVERT]) != NULL)
rule->invert = blobmsg_get_bool(cur);
if ((cur = tb[RULE_INTERFACE_IN]) != NULL) {
iif = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
if (!iif || !iif->l3_dev.dev) {
DPRINTF("Failed to resolve device of network: %s\n", (char *) blobmsg_data(cur));
goto error;
}
memcpy(rule->in_dev, iif->l3_dev.dev->ifname, sizeof(rule->in_dev));
rule->flags |= IPRULE_IN;
}
if ((cur = tb[RULE_INTERFACE_OUT]) != NULL) {
oif = vlist_find(&interfaces, blobmsg_data(cur), iface, node);
if (!oif || !oif->l3_dev.dev) {
DPRINTF("Failed to resolve device of network: %s\n", (char *) blobmsg_data(cur));
goto error;
}
memcpy(rule->out_dev, oif->l3_dev.dev->ifname, sizeof(rule->out_dev));
rule->flags |= IPRULE_OUT;
}
if ((cur = tb[RULE_SRC]) != NULL) {
if (!parse_ip_and_netmask(af, blobmsg_data(cur), &rule->src_addr, &rule->src_mask)) {
DPRINTF("Failed to parse rule source: %s\n", (char *) blobmsg_data(cur));
goto error;
}
rule->flags |= IPRULE_SRC;
}
if ((cur = tb[RULE_DEST]) != NULL) {
if (!parse_ip_and_netmask(af, blobmsg_data(cur), &rule->dest_addr, &rule->dest_mask)) {
DPRINTF("Failed to parse rule destination: %s\n", (char *) blobmsg_data(cur));
goto error;
}
rule->flags |= IPRULE_DEST;
}
if ((cur = tb[RULE_PRIORITY]) != NULL) {
rule->priority = blobmsg_get_u32(cur);
rule->flags |= IPRULE_PRIORITY;
}
if ((cur = tb[RULE_TOS]) != NULL) {
if ((rule->tos = blobmsg_get_u32(cur)) > 255) {
DPRINTF("Invalid TOS value: %u\n", blobmsg_get_u32(cur));
goto error;
}
rule->flags |= IPRULE_TOS;
}
if ((cur = tb[RULE_FWMARK]) != NULL) {
if (!iprule_parse_mark(blobmsg_data(cur), rule)) {
DPRINTF("Failed to parse rule fwmark: %s\n", (char *) blobmsg_data(cur));
goto error;
}
/* flags set by iprule_parse_mark() */
}
if ((cur = tb[RULE_LOOKUP]) != NULL) {
if (!system_resolve_rt_table(blobmsg_data(cur), &rule->lookup)) {
DPRINTF("Failed to parse rule lookup table: %s\n", (char *) blobmsg_data(cur));
goto error;
}
rule->flags |= IPRULE_LOOKUP;
}
if ((cur = tb[RULE_ACTION]) != NULL) {
if (!system_resolve_iprule_action(blobmsg_data(cur), &rule->action)) {
DPRINTF("Failed to parse rule action: %s\n", (char *) blobmsg_data(cur));
goto error;
}
rule->flags |= IPRULE_ACTION;
}
if ((cur = tb[RULE_GOTO]) != NULL) {
rule->gotoid = blobmsg_get_u32(cur);
rule->flags |= IPRULE_GOTO;
}
vlist_add(&iprules, &rule->node, &rule->flags);
return;
error:
free(rule);
}
static int watchdog_set(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
struct blob_attr *tb[__WDT_MAX];
const char *status;
if (!msg)
return UBUS_STATUS_INVALID_ARGUMENT;
blobmsg_parse(watchdog_policy, __WDT_MAX, tb, blob_data(msg), blob_len(msg));
if (tb[WDT_FREQUENCY]) {
unsigned int timeout = watchdog_timeout(0);
unsigned int freq = blobmsg_get_u32(tb[WDT_FREQUENCY]);
if (freq) {
if (freq > timeout / 2)
freq = timeout / 2;
watchdog_frequency(freq);
}
}
if (tb[WDT_TIMEOUT]) {
unsigned int timeout = blobmsg_get_u32(tb[WDT_TIMEOUT]);
unsigned int frequency = watchdog_frequency(0);
if (timeout <= frequency)
timeout = frequency * 2;
watchdog_timeout(timeout);
}
if (tb[WDT_STOP])
watchdog_set_stopped(blobmsg_get_bool(tb[WDT_STOP]));
if (watchdog_fd() == NULL)
status = "offline";
else if (watchdog_get_stopped())
status = "stopped";
else
status = "running";
blob_buf_init(&b, 0);
blobmsg_add_string(&b, "status", status);
blobmsg_add_u32(&b, "timeout", watchdog_timeout(0));
blobmsg_add_u32(&b, "frequency", watchdog_frequency(0));
ubus_send_reply(ctx, req, b.head);
return 0;
}