#include <glob.h>
#include <libubox/uloop.h>
+#include <libubox/avl-cmp.h>
#include "qosify.h"
static int qosify_map_fds[__CL_MAP_MAX];
static AVL_TREE(map_data, qosify_map_entry_cmp, false, NULL);
static LIST_HEAD(map_files);
+static AVL_TREE(map_aliases, avl_strcmp, false, NULL);
static uint32_t next_timeout;
-static uint8_t qosify_dscp_default[2] = { 0xff, 0xff };
+static struct qosify_dscp_val qosify_dscp_default[2] = {
+ { 0xff, 0xff },
+ { 0xff, 0xff }
+};
int qosify_map_timeout;
int qosify_active_timeout;
struct qosify_config config;
char filename[];
};
+struct qosify_map_alias {
+ struct avl_node avl;
+ struct qosify_dscp_val value;
+};
+
static const struct {
const char *name;
const char *type_name;
bpf_map_delete_elem(fd, &key);
}
-static void __qosify_map_set_dscp_default(enum qosify_map_id id, uint8_t val)
+static void __qosify_map_set_dscp_default(enum qosify_map_id id, struct qosify_dscp_val *val)
{
struct qosify_map_data data = {
.id = id,
int fd = qosify_map_fds[id];
int i;
- val |= QOSIFY_DSCP_DEFAULT_FLAG;
+ val->ingress |= QOSIFY_DSCP_DEFAULT_FLAG;
+ val->egress |= QOSIFY_DSCP_DEFAULT_FLAG;
for (i = 0; i < (1 << 16); i++) {
data.addr.port = htons(i);
if (avl_find(&map_data, &data))
continue;
- bpf_map_update_elem(fd, &data.addr, &val, BPF_ANY);
+ bpf_map_update_elem(fd, &data.addr, val, BPF_ANY);
}
}
-void qosify_map_set_dscp_default(enum qosify_map_id id, uint8_t val)
+void qosify_map_set_dscp_default(enum qosify_map_id id, struct qosify_dscp_val val)
{
bool udp;
else
return;
- if (qosify_dscp_default[udp] == val)
+ if (!memcmp(&qosify_dscp_default[udp], &val, sizeof(val)))
return;
qosify_dscp_default[udp] = val;
- __qosify_map_set_dscp_default(id, val);
+ __qosify_map_set_dscp_default(id, &qosify_dscp_default[udp]);
}
int qosify_map_init(void)
static void __qosify_map_set_entry(struct qosify_map_data *data)
{
int fd = qosify_map_fds[data->id];
+ struct qosify_dscp_val prev_dscp = { 0xff, 0xff };
struct qosify_map_entry *e;
bool file = data->file;
int32_t delta = 0;
- bool add = data->dscp != 0xff;
- uint8_t prev_dscp = 0xff;
+ bool add = data->dscp.ingress != 0xff;
e = avl_find_element(&map_data, data, e, avl);
if (!e) {
e->data.dscp = e->data.file_dscp;
}
- if (e->data.dscp != prev_dscp && data->id < CL_MAP_DNS) {
+ if (memcmp(&e->data.dscp, &prev_dscp, sizeof(prev_dscp)) != 0 &&
+ data->id < CL_MAP_DNS) {
struct qosify_ip_map_val val = {
.dscp = e->data.dscp,
.seen = 1,
return 0;
}
-int qosify_map_set_entry(enum qosify_map_id id, bool file, const char *str, uint8_t dscp)
+int qosify_map_set_entry(enum qosify_map_id id, bool file, const char *str,
+ struct qosify_dscp_val dscp)
{
struct qosify_map_data data = {
.id = id,
return 0;
}
-int qosify_map_dscp_value(const char *val)
+static int
+__qosify_map_dscp_value(const char *val, uint8_t *dscp_val)
{
unsigned long dscp;
- char *err;
bool fallback = false;
+ char *err;
if (*val == '+') {
fallback = true;
if (dscp >= 64)
return -1;
- return dscp + (fallback << 6);
+ *dscp_val = dscp | (fallback << 6);
+
+ return 0;
+}
+
+int qosify_map_dscp_value(const char *val, struct qosify_dscp_val *dscp_val)
+{
+ struct qosify_map_alias *alias;
+ bool fallback = false;
+
+ if (*val == '+') {
+ fallback = true;
+ val++;
+ }
+
+ alias = avl_find_element(&map_aliases, val, alias, avl);
+ if (alias) {
+ *dscp_val = alias->value;
+ } else {
+ if (__qosify_map_dscp_value(val, &dscp_val->egress))
+ return -1;
+
+ dscp_val->ingress = dscp_val->egress;
+ }
+
+ if (fallback) {
+ dscp_val->ingress |= (1 << 6);
+ dscp_val->egress |= (1 << 6);
+ }
+
+ return 0;
}
static void
qosify_map_parse_line(char *str)
{
const char *key, *value;
- int dscp;
+ struct qosify_dscp_val dscp;
str = str_skip(str, true);
key = str;
str = str_skip(str, true);
value = str;
- dscp = qosify_map_dscp_value(value);
- if (dscp < 0)
+ if (qosify_map_dscp_value(value, &dscp))
return;
if (!strncmp(key, "dns:", 4))
void qosify_map_reset_config(void)
{
+ struct qosify_dscp_val val = {};
+
qosify_map_clear_files();
- qosify_map_set_dscp_default(CL_MAP_TCP_PORTS, 0);
- qosify_map_set_dscp_default(CL_MAP_UDP_PORTS, 0);
+ qosify_map_set_dscp_default(CL_MAP_TCP_PORTS, val);
+ qosify_map_set_dscp_default(CL_MAP_UDP_PORTS, val);
qosify_map_timeout = 3600;
qosify_active_timeout = 300;
memset(&config, 0, sizeof(config));
- config.dscp_prio = 0xff;
- config.dscp_bulk = 0xff;
- config.dscp_icmp = 0xff;
+ config.dscp_prio.ingress = 0xff;
+ config.dscp_prio.egress = 0xff;
+ config.dscp_bulk.ingress = 0xff;
+ config.dscp_bulk.egress = 0xff;
+ config.dscp_icmp.ingress = 0xff;
+ config.dscp_icmp.egress = 0xff;
}
void qosify_map_reload(void)
return 0;
}
+static void
+blobmsg_add_dscp(struct blob_buf *b, const char *name, uint8_t dscp)
+{
+ int buf_len = 8;
+ char *buf;
+
+ buf = blobmsg_alloc_string_buffer(b, name, buf_len);
+ qosify_map_dscp_codepoint_str(buf, buf_len, dscp);
+ blobmsg_add_string_buffer(b);
+}
+
void qosify_map_dump(struct blob_buf *b)
{
blobmsg_add_u8(b, "file", e->data.file);
blobmsg_add_u8(b, "user", e->data.user);
- buf = blobmsg_alloc_string_buffer(b, "dscp", buf_len);
- qosify_map_dscp_codepoint_str(buf, buf_len, e->data.dscp);
- blobmsg_add_string_buffer(b);
+ blobmsg_add_dscp(b, "dscp_ingress", e->data.dscp.ingress);
+ blobmsg_add_dscp(b, "dscp_egress", e->data.dscp.egress);
blobmsg_add_string(b, "type", qosify_map_info[e->data.id].type_name);
blobmsg_add_string(b, "addr", e->data.addr.dns.pattern);
break;
default:
- *buf = 0;
break;
}
blobmsg_close_table(b, c);
blobmsg_close_array(b, a);
}
+static int
+qosify_map_create_alias(struct blob_attr *attr)
+{
+ struct qosify_map_alias *alias;
+ enum {
+ MAP_ALIAS_INGRESS,
+ MAP_ALIAS_EGRESS,
+ __MAP_ALIAS_MAX
+ };
+ static const struct blobmsg_policy policy[__MAP_ALIAS_MAX] = {
+ [MAP_ALIAS_INGRESS] = { .type = BLOBMSG_TYPE_STRING },
+ [MAP_ALIAS_EGRESS] = { .type = BLOBMSG_TYPE_STRING },
+ };
+ struct blob_attr *tb[__MAP_ALIAS_MAX];
+ const char *name;
+ char *name_buf;
+
+ if (blobmsg_check_array(attr, BLOBMSG_TYPE_STRING) != 2)
+ return -1;
+
+ blobmsg_parse_array(policy, __MAP_ALIAS_MAX, tb,
+ blobmsg_data(attr), blobmsg_len(attr));
+
+ if (!tb[MAP_ALIAS_INGRESS] || !tb[MAP_ALIAS_EGRESS])
+ return -1;
+
+ name = blobmsg_name(attr);
+ alias = calloc_a(sizeof(*alias), &name_buf, strlen(name) + 1);
+ alias->avl.key = strcpy(name_buf, name);
+ if (__qosify_map_dscp_value(blobmsg_get_string(tb[MAP_ALIAS_INGRESS]),
+ &alias->value.ingress) ||
+ __qosify_map_dscp_value(blobmsg_get_string(tb[MAP_ALIAS_EGRESS]),
+ &alias->value.egress) ||
+ avl_insert(&map_aliases, &alias->avl)) {
+ free(alias);
+ return -1;
+ }
+
+ return 0;
+}
+
+void qosify_map_set_aliases(struct blob_attr *val)
+{
+ struct qosify_map_alias *alias, *tmp;
+ struct blob_attr *cur;
+ int rem;
+
+ avl_remove_all_elements(&map_aliases, alias, avl, tmp)
+ free(alias);
+
+ blobmsg_for_each_attr(cur, val, rem)
+ qosify_map_create_alias(cur);
+}
+
void qosify_map_update_config(void)
{
int fd = qosify_map_fds[CL_MAP_CONFIG];
projects / project / qosify.git / blobdiff