2 * swlib.c: Switch configuration API (user space part)
4 * Copyright (C) 2008 Felix Fietkau <nbd@nbd.name>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public License
8 * version 2.1 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <linux/switch.h>
28 #include <netlink/netlink.h>
29 #include <netlink/genl/genl.h>
30 #include <netlink/genl/family.h>
34 #define DPRINTF(fmt, ...) fprintf(stderr, "%s(%d): " fmt, __func__, __LINE__, ##__VA_ARGS__)
36 #define DPRINTF(fmt, ...) do {} while (0)
39 static struct nl_sock *handle;
40 static struct nl_cache *cache;
41 static struct genl_family *family;
42 static struct nlattr *tb[SWITCH_ATTR_MAX + 1];
43 static int refcount = 0;
45 static struct nla_policy port_policy[SWITCH_ATTR_MAX] = {
46 [SWITCH_PORT_ID] = { .type = NLA_U32 },
47 [SWITCH_PORT_FLAG_TAGGED] = { .type = NLA_FLAG },
50 static struct nla_policy portmap_policy[SWITCH_PORTMAP_MAX] = {
51 [SWITCH_PORTMAP_SEGMENT] = { .type = NLA_STRING },
52 [SWITCH_PORTMAP_VIRT] = { .type = NLA_U32 },
55 static struct nla_policy link_policy[SWITCH_LINK_ATTR_MAX] = {
56 [SWITCH_LINK_FLAG_LINK] = { .type = NLA_FLAG },
57 [SWITCH_LINK_FLAG_DUPLEX] = { .type = NLA_FLAG },
58 [SWITCH_LINK_FLAG_ANEG] = { .type = NLA_FLAG },
59 [SWITCH_LINK_SPEED] = { .type = NLA_U32 },
60 [SWITCH_LINK_FLAG_EEE_100BASET] = { .type = NLA_FLAG },
61 [SWITCH_LINK_FLAG_EEE_1000BASET] = { .type = NLA_FLAG },
65 swlib_alloc(size_t size)
79 wait_handler(struct nl_msg *msg, void *arg)
87 /* helper function for performing netlink requests */
89 swlib_call(int cmd, int (*call)(struct nl_msg *, void *),
90 int (*data)(struct nl_msg *, void *), void *arg)
93 struct nl_cb *cb = NULL;
100 fprintf(stderr, "Out of memory!\n");
107 genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, genl_family_get_id(family), 0, flags, cmd, 0);
109 err = data(msg, arg);
111 goto nla_put_failure;
114 cb = nl_cb_alloc(NL_CB_CUSTOM);
116 fprintf(stderr, "nl_cb_alloc failed.\n");
120 err = nl_send_auto_complete(handle, msg);
122 fprintf(stderr, "nl_send_auto_complete failed: %d\n", err);
129 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, call, arg);
132 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, wait_handler, &finished);
134 nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, wait_handler, &finished);
136 err = nl_recvmsgs(handle, cb);
142 err = nl_wait_for_ack(handle);
153 send_attr(struct nl_msg *msg, void *arg)
155 struct switch_val *val = arg;
156 struct switch_attr *attr = val->attr;
158 NLA_PUT_U32(msg, SWITCH_ATTR_ID, attr->dev->id);
159 NLA_PUT_U32(msg, SWITCH_ATTR_OP_ID, attr->id);
160 switch(attr->atype) {
161 case SWLIB_ATTR_GROUP_PORT:
162 NLA_PUT_U32(msg, SWITCH_ATTR_OP_PORT, val->port_vlan);
164 case SWLIB_ATTR_GROUP_VLAN:
165 NLA_PUT_U32(msg, SWITCH_ATTR_OP_VLAN, val->port_vlan);
178 store_port_val(struct nl_msg *msg, struct nlattr *nla, struct switch_val *val)
181 int ports = val->attr->dev->ports;
185 if (!val->value.ports)
186 val->value.ports = malloc(sizeof(struct switch_port) * ports);
188 nla_for_each_nested(p, nla, remaining) {
189 struct nlattr *tb[SWITCH_PORT_ATTR_MAX+1];
190 struct switch_port *port;
192 if (val->len >= ports)
195 err = nla_parse_nested(tb, SWITCH_PORT_ATTR_MAX, p, port_policy);
199 if (!tb[SWITCH_PORT_ID])
202 port = &val->value.ports[val->len];
203 port->id = nla_get_u32(tb[SWITCH_PORT_ID]);
205 if (tb[SWITCH_PORT_FLAG_TAGGED])
206 port->flags |= SWLIB_PORT_FLAG_TAGGED;
216 store_link_val(struct nl_msg *msg, struct nlattr *nla, struct switch_val *val)
218 struct nlattr *tb[SWITCH_LINK_ATTR_MAX + 1];
219 struct switch_port_link *link;
222 if (!val->value.link)
223 val->value.link = malloc(sizeof(struct switch_port_link));
225 err = nla_parse_nested(tb, SWITCH_LINK_ATTR_MAX, nla, link_policy);
229 link = val->value.link;
230 link->link = !!tb[SWITCH_LINK_FLAG_LINK];
231 link->duplex = !!tb[SWITCH_LINK_FLAG_DUPLEX];
232 link->aneg = !!tb[SWITCH_LINK_FLAG_ANEG];
233 link->tx_flow = !!tb[SWITCH_LINK_FLAG_TX_FLOW];
234 link->rx_flow = !!tb[SWITCH_LINK_FLAG_RX_FLOW];
235 link->speed = nla_get_u32(tb[SWITCH_LINK_SPEED]);
237 if (tb[SWITCH_LINK_FLAG_EEE_100BASET])
238 link->eee |= SWLIB_LINK_FLAG_EEE_100BASET;
239 if (tb[SWITCH_LINK_FLAG_EEE_1000BASET])
240 link->eee |= SWLIB_LINK_FLAG_EEE_1000BASET;
247 store_val(struct nl_msg *msg, void *arg)
249 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
250 struct switch_val *val = arg;
255 if (nla_parse(tb, SWITCH_ATTR_MAX - 1, genlmsg_attrdata(gnlh, 0),
256 genlmsg_attrlen(gnlh, 0), NULL) < 0) {
260 if (tb[SWITCH_ATTR_OP_VALUE_INT])
261 val->value.i = nla_get_u32(tb[SWITCH_ATTR_OP_VALUE_INT]);
262 else if (tb[SWITCH_ATTR_OP_VALUE_STR])
263 val->value.s = strdup(nla_get_string(tb[SWITCH_ATTR_OP_VALUE_STR]));
264 else if (tb[SWITCH_ATTR_OP_VALUE_PORTS])
265 val->err = store_port_val(msg, tb[SWITCH_ATTR_OP_VALUE_PORTS], val);
266 else if (tb[SWITCH_ATTR_OP_VALUE_LINK])
267 val->err = store_link_val(msg, tb[SWITCH_ATTR_OP_VALUE_LINK], val);
277 swlib_get_attr(struct switch_dev *dev, struct switch_attr *attr, struct switch_val *val)
282 switch(attr->atype) {
283 case SWLIB_ATTR_GROUP_GLOBAL:
284 cmd = SWITCH_CMD_GET_GLOBAL;
286 case SWLIB_ATTR_GROUP_PORT:
287 cmd = SWITCH_CMD_GET_PORT;
289 case SWLIB_ATTR_GROUP_VLAN:
290 cmd = SWITCH_CMD_GET_VLAN;
296 memset(&val->value, 0, sizeof(val->value));
300 err = swlib_call(cmd, store_val, send_attr, val);
308 send_attr_ports(struct nl_msg *msg, struct switch_val *val)
313 /* TODO implement multipart? */
316 n = nla_nest_start(msg, SWITCH_ATTR_OP_VALUE_PORTS);
318 goto nla_put_failure;
319 for (i = 0; i < val->len; i++) {
320 struct switch_port *port = &val->value.ports[i];
323 np = nla_nest_start(msg, SWITCH_ATTR_PORT);
325 goto nla_put_failure;
327 NLA_PUT_U32(msg, SWITCH_PORT_ID, port->id);
328 if (port->flags & SWLIB_PORT_FLAG_TAGGED)
329 NLA_PUT_FLAG(msg, SWITCH_PORT_FLAG_TAGGED);
331 nla_nest_end(msg, np);
333 nla_nest_end(msg, n);
342 send_attr_link(struct nl_msg *msg, struct switch_val *val)
344 struct switch_port_link *link = val->value.link;
347 n = nla_nest_start(msg, SWITCH_ATTR_OP_VALUE_LINK);
349 goto nla_put_failure;
352 NLA_PUT_FLAG(msg, SWITCH_LINK_FLAG_DUPLEX);
354 NLA_PUT_FLAG(msg, SWITCH_LINK_FLAG_ANEG);
355 NLA_PUT_U32(msg, SWITCH_LINK_SPEED, link->speed);
357 nla_nest_end(msg, n);
366 send_attr_val(struct nl_msg *msg, void *arg)
368 struct switch_val *val = arg;
369 struct switch_attr *attr = val->attr;
371 if (send_attr(msg, arg))
372 goto nla_put_failure;
375 case SWITCH_TYPE_NOVAL:
377 case SWITCH_TYPE_INT:
378 NLA_PUT_U32(msg, SWITCH_ATTR_OP_VALUE_INT, val->value.i);
380 case SWITCH_TYPE_STRING:
382 goto nla_put_failure;
383 NLA_PUT_STRING(msg, SWITCH_ATTR_OP_VALUE_STR, val->value.s);
385 case SWITCH_TYPE_PORTS:
386 if (send_attr_ports(msg, val) < 0)
387 goto nla_put_failure;
389 case SWITCH_TYPE_LINK:
390 if (send_attr_link(msg, val))
391 goto nla_put_failure;
394 goto nla_put_failure;
403 swlib_set_attr(struct switch_dev *dev, struct switch_attr *attr, struct switch_val *val)
407 switch(attr->atype) {
408 case SWLIB_ATTR_GROUP_GLOBAL:
409 cmd = SWITCH_CMD_SET_GLOBAL;
411 case SWLIB_ATTR_GROUP_PORT:
412 cmd = SWITCH_CMD_SET_PORT;
414 case SWLIB_ATTR_GROUP_VLAN:
415 cmd = SWITCH_CMD_SET_VLAN;
422 return swlib_call(cmd, NULL, send_attr_val, val);
432 int swlib_set_attr_string(struct switch_dev *dev, struct switch_attr *a, int port_vlan, const char *str)
434 struct switch_port *ports;
435 struct switch_port_link *link;
436 struct switch_val val;
440 memset(&val, 0, sizeof(val));
441 val.port_vlan = port_vlan;
443 case SWITCH_TYPE_INT:
444 val.value.i = atoi(str);
446 case SWITCH_TYPE_STRING:
447 val.value.s = (char *)str;
449 case SWITCH_TYPE_PORTS:
450 ports = alloca(sizeof(struct switch_port) * dev->ports);
451 memset(ports, 0, sizeof(struct switch_port) * dev->ports);
456 while(*ptr && isspace(*ptr))
465 if (val.len >= dev->ports)
468 ports[val.len].flags = 0;
469 ports[val.len].id = strtoul(ptr, &ptr, 10);
470 while(*ptr && !isspace(*ptr)) {
472 ports[val.len].flags |= SWLIB_PORT_FLAG_TAGGED;
482 val.value.ports = ports;
484 case SWITCH_TYPE_LINK:
485 link = malloc(sizeof(struct switch_port_link));
486 memset(link, 0, sizeof(struct switch_port_link));
488 for (ptr = strtok(ptr," "); ptr; ptr = strtok(NULL, " ")) {
491 if (!strcmp(ptr, "duplex"))
493 else if (!strcmp(ptr, "autoneg"))
495 else if (!strcmp(ptr, "speed"))
498 fprintf(stderr, "Unsupported option %s\n", ptr);
501 if (!strcmp(ptr, "half"))
503 else if (!strcmp(ptr, "full"))
506 fprintf(stderr, "Unsupported value %s\n", ptr);
510 if (!strcmp(ptr, "on"))
512 else if (!strcmp(ptr, "off"))
515 fprintf(stderr, "Unsupported value %s\n", ptr);
519 link->speed = atoi(ptr);
524 val.value.link = link;
526 case SWITCH_TYPE_NOVAL:
527 if (str && !strcmp(str, "0"))
534 return swlib_set_attr(dev, a, &val);
538 struct attrlist_arg {
541 struct switch_dev *dev;
542 struct switch_attr *prev;
543 struct switch_attr **head;
547 add_id(struct nl_msg *msg, void *arg)
549 struct attrlist_arg *l = arg;
551 NLA_PUT_U32(msg, SWITCH_ATTR_ID, l->id);
559 add_attr(struct nl_msg *msg, void *ptr)
561 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
562 struct attrlist_arg *arg = ptr;
563 struct switch_attr *new;
565 if (nla_parse(tb, SWITCH_ATTR_MAX - 1, genlmsg_attrdata(gnlh, 0),
566 genlmsg_attrlen(gnlh, 0), NULL) < 0)
569 new = swlib_alloc(sizeof(struct switch_attr));
574 new->atype = arg->atype;
576 arg->prev->next = new;
578 arg->prev = *arg->head;
581 arg->head = &new->next;
583 if (tb[SWITCH_ATTR_OP_ID])
584 new->id = nla_get_u32(tb[SWITCH_ATTR_OP_ID]);
585 if (tb[SWITCH_ATTR_OP_TYPE])
586 new->type = nla_get_u32(tb[SWITCH_ATTR_OP_TYPE]);
587 if (tb[SWITCH_ATTR_OP_NAME])
588 new->name = strdup(nla_get_string(tb[SWITCH_ATTR_OP_NAME]));
589 if (tb[SWITCH_ATTR_OP_DESCRIPTION])
590 new->description = strdup(nla_get_string(tb[SWITCH_ATTR_OP_DESCRIPTION]));
597 swlib_scan(struct switch_dev *dev)
599 struct attrlist_arg arg;
601 if (dev->ops || dev->port_ops || dev->vlan_ops)
604 arg.atype = SWLIB_ATTR_GROUP_GLOBAL;
608 arg.head = &dev->ops;
609 swlib_call(SWITCH_CMD_LIST_GLOBAL, add_attr, add_id, &arg);
611 arg.atype = SWLIB_ATTR_GROUP_PORT;
613 arg.head = &dev->port_ops;
614 swlib_call(SWITCH_CMD_LIST_PORT, add_attr, add_id, &arg);
616 arg.atype = SWLIB_ATTR_GROUP_VLAN;
618 arg.head = &dev->vlan_ops;
619 swlib_call(SWITCH_CMD_LIST_VLAN, add_attr, add_id, &arg);
624 struct switch_attr *swlib_lookup_attr(struct switch_dev *dev,
625 enum swlib_attr_group atype, const char *name)
627 struct switch_attr *head;
633 case SWLIB_ATTR_GROUP_GLOBAL:
636 case SWLIB_ATTR_GROUP_PORT:
637 head = dev->port_ops;
639 case SWLIB_ATTR_GROUP_VLAN:
640 head = dev->vlan_ops;
644 if (!strcmp(name, head->name))
653 swlib_priv_free(void)
656 nl_object_put((struct nl_object*)family);
658 nl_cache_free(cache);
660 nl_socket_free(handle);
667 swlib_priv_init(void)
671 handle = nl_socket_alloc();
673 DPRINTF("Failed to create handle\n");
677 if (genl_connect(handle)) {
678 DPRINTF("Failed to connect to generic netlink\n");
682 ret = genl_ctrl_alloc_cache(handle, &cache);
684 DPRINTF("Failed to allocate netlink cache\n");
688 family = genl_ctrl_search_by_name(cache, "switch");
690 DPRINTF("Switch API not present\n");
700 struct swlib_scan_arg {
702 struct switch_dev *head;
703 struct switch_dev *ptr;
707 add_port_map(struct switch_dev *dev, struct nlattr *nla)
710 int err = 0, idx = 0;
713 dev->maps = malloc(sizeof(struct switch_portmap) * dev->ports);
716 memset(dev->maps, 0, sizeof(struct switch_portmap) * dev->ports);
718 nla_for_each_nested(p, nla, remaining) {
719 struct nlattr *tb[SWITCH_PORTMAP_MAX+1];
721 if (idx >= dev->ports)
724 err = nla_parse_nested(tb, SWITCH_PORTMAP_MAX, p, portmap_policy);
729 if (tb[SWITCH_PORTMAP_SEGMENT] && tb[SWITCH_PORTMAP_VIRT]) {
730 dev->maps[idx].segment = strdup(nla_get_string(tb[SWITCH_PORTMAP_SEGMENT]));
731 dev->maps[idx].virt = nla_get_u32(tb[SWITCH_PORTMAP_VIRT]);
742 add_switch(struct nl_msg *msg, void *arg)
744 struct swlib_scan_arg *sa = arg;
745 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
746 struct switch_dev *dev;
750 if (nla_parse(tb, SWITCH_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL) < 0)
753 if (!tb[SWITCH_ATTR_DEV_NAME])
756 name = nla_get_string(tb[SWITCH_ATTR_DEV_NAME]);
757 alias = nla_get_string(tb[SWITCH_ATTR_ALIAS]);
759 if (sa->name && (strcmp(name, sa->name) != 0) && (strcmp(alias, sa->name) != 0))
762 dev = swlib_alloc(sizeof(struct switch_dev));
766 strncpy(dev->dev_name, name, IFNAMSIZ - 1);
767 dev->alias = strdup(alias);
768 if (tb[SWITCH_ATTR_ID])
769 dev->id = nla_get_u32(tb[SWITCH_ATTR_ID]);
770 if (tb[SWITCH_ATTR_NAME])
771 dev->name = strdup(nla_get_string(tb[SWITCH_ATTR_NAME]));
772 if (tb[SWITCH_ATTR_PORTS])
773 dev->ports = nla_get_u32(tb[SWITCH_ATTR_PORTS]);
774 if (tb[SWITCH_ATTR_VLANS])
775 dev->vlans = nla_get_u32(tb[SWITCH_ATTR_VLANS]);
776 if (tb[SWITCH_ATTR_CPU_PORT])
777 dev->cpu_port = nla_get_u32(tb[SWITCH_ATTR_CPU_PORT]);
778 if (tb[SWITCH_ATTR_PORTMAP])
779 add_port_map(dev, tb[SWITCH_ATTR_PORTMAP]);
795 list_switch(struct nl_msg *msg, void *arg)
797 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
799 if (nla_parse(tb, SWITCH_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL) < 0)
802 if (!tb[SWITCH_ATTR_DEV_NAME] || !tb[SWITCH_ATTR_NAME])
805 printf("Found: %s - %s\n", nla_get_string(tb[SWITCH_ATTR_DEV_NAME]),
806 nla_get_string(tb[SWITCH_ATTR_ALIAS]));
815 if (swlib_priv_init() < 0)
817 swlib_call(SWITCH_CMD_GET_SWITCH, list_switch, NULL, NULL);
822 swlib_print_portmap(struct switch_dev *dev, char *segment)
827 if (!strcmp(segment, "cpu")) {
828 printf("%d ", dev->cpu_port);
829 } else if (!strcmp(segment, "disabled")) {
830 for (i = 0; i < dev->ports; i++)
831 if (!dev->maps[i].segment)
833 } else for (i = 0; i < dev->ports; i++) {
834 if (dev->maps[i].segment && !strcmp(dev->maps[i].segment, segment))
838 printf("%s - %s\n", dev->dev_name, dev->name);
839 for (i = 0; i < dev->ports; i++)
840 if (i == dev->cpu_port)
841 printf("port%d:\tcpu\n", i);
842 else if (dev->maps[i].segment)
843 printf("port%d:\t%s.%d\n", i, dev->maps[i].segment, dev->maps[i].virt);
845 printf("port%d:\tdisabled\n", i);
850 swlib_connect(const char *name)
852 struct swlib_scan_arg arg;
855 if (swlib_priv_init() < 0)
862 swlib_call(SWITCH_CMD_GET_SWITCH, add_switch, NULL, &arg);
871 swlib_free_attributes(struct switch_attr **head)
873 struct switch_attr *a = *head;
874 struct switch_attr *next;
879 free(a->description);
887 swlib_free_port_map(struct switch_dev *dev)
891 if (!dev || !dev->maps)
894 for (i = 0; i < dev->ports; i++)
895 free(dev->maps[i].segment);
900 swlib_free(struct switch_dev *dev)
902 swlib_free_attributes(&dev->ops);
903 swlib_free_attributes(&dev->port_ops);
904 swlib_free_attributes(&dev->vlan_ops);
905 swlib_free_port_map(dev);
915 swlib_free_all(struct switch_dev *dev)
917 struct switch_dev *p;