projects / project / qosify.git / blob
? search:


e4130204b584d9bc260463aad53a0e71d1279aff
[project/qosify.git] / map.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2021 Felix Fietkau <nbd@nbd.name>
4 */
5 #include <arpa/inet.h>
6
7 #include <errno.h>
8 #include <stdio.h>
9 #include <ctype.h>
10 #include <stdlib.h>
11 #include <time.h>
12 #include <fnmatch.h>
13 #include <glob.h>
14
15 #include <libubox/uloop.h>
16 #include <libubox/avl-cmp.h>
17
18 #include "qosify.h"
19
20 struct qosify_map_class;
21
22 static int qosify_map_entry_cmp(const void *k1, const void *k2, void *ptr);
23
24 static int qosify_map_fds[__CL_MAP_MAX];
25 static AVL_TREE(map_data, qosify_map_entry_cmp, false, NULL);
26 static LIST_HEAD(map_files);
27 static struct qosify_map_class *map_class[QOSIFY_MAX_CLASS_ENTRIES];
28 static uint32_t next_timeout;
29 static uint8_t qosify_dscp_default[2] = { 0xff, 0xff };
30 int qosify_map_timeout;
31 int qosify_active_timeout;
32 struct qosify_config config;
33 struct qosify_flow_config flow_config;
34 static uint32_t map_dns_seq;
35
36 struct qosify_map_file {
37 struct list_head list;
38 char filename[];
39 };
40
41 struct qosify_map_class {
42 const char *name;
43 struct qosify_class data;
44 };
45
46 static const struct {
47 const char *name;
48 const char *type_name;
49 } qosify_map_info[] = {
50 [CL_MAP_TCP_PORTS] = { "tcp_ports", "tcp_port" },
51 [CL_MAP_UDP_PORTS] = { "udp_ports", "udp_port" },
52 [CL_MAP_IPV4_ADDR] = { "ipv4_map", "ipv4_addr" },
53 [CL_MAP_IPV6_ADDR] = { "ipv6_map", "ipv6_addr" },
54 [CL_MAP_CONFIG] = { "config", "config" },
55 [CL_MAP_CLASS] = { "class_map", "class" },
56 [CL_MAP_DNS] = { "dns", "dns" },
57 };
58
59 static const struct {
60 const char name[5];
61 uint8_t val;
62 } codepoints[] = {
63 { "CS0", 0 },
64 { "CS1", 8 },
65 { "CS2", 16 },
66 { "CS3", 24 },
67 { "CS4", 32 },
68 { "CS5", 40 },
69 { "CS6", 48 },
70 { "CS7", 56 },
71 { "AF11", 10 },
72 { "AF12", 12 },
73 { "AF13", 14 },
74 { "AF21", 18 },
75 { "AF22", 20 },
76 { "AF23", 22 },
77 { "AF31", 26 },
78 { "AF32", 28 },
79 { "AF33", 30 },
80 { "AF41", 34 },
81 { "AF42", 36 },
82 { "AF43", 38 },
83 { "EF", 46 },
84 { "VA", 44 },
85 { "LE", 1 },
86 { "DF", 0 },
87 };
88
89 static void qosify_map_timer_cb(struct uloop_timeout *t)
90 {
91 qosify_map_gc();
92 }
93
94 static struct uloop_timeout qosify_map_timer = {
95 .cb = qosify_map_timer_cb,
96 };
97
98 static uint32_t qosify_gettime(void)
99 {
100 struct timespec ts;
101
102 clock_gettime(CLOCK_MONOTONIC, &ts);
103
104 return ts.tv_sec;
105 }
106
107 static const char *
108 qosify_map_path(enum qosify_map_id id)
109 {
110 static char path[128];
111 const char *name;
112
113 if (id >= ARRAY_SIZE(qosify_map_info))
114 return NULL;
115
116 name = qosify_map_info[id].name;
117 if (!name)
118 return NULL;
119
120 snprintf(path, sizeof(path), "%s/%s", CLASSIFY_DATA_PATH, name);
121
122 return path;
123 }
124
125 static int qosify_map_get_fd(enum qosify_map_id id)
126 {
127 const char *path = qosify_map_path(id);
128 int fd;
129
130 if (!path)
131 return -1;
132
133 fd = bpf_obj_get(path);
134 if (fd < 0)
135 fprintf(stderr, "Failed to open map %s: %s\n", path, strerror(errno));
136
137 return fd;
138 }
139
140 static void qosify_map_clear_list(enum qosify_map_id id)
141 {
142 int fd = qosify_map_fds[id];
143 __u32 key[4] = {};
144
145 while (bpf_map_get_next_key(fd, &key, &key) != -1)
146 bpf_map_delete_elem(fd, &key);
147 }
148
149 static void __qosify_map_set_dscp_default(enum qosify_map_id id, uint8_t val)
150 {
151 struct qosify_map_data data = {
152 .id = id,
153 };
154 struct qosify_class class = {
155 .val.ingress = val,
156 .val.egress = val,
157 };
158 uint32_t key;
159 int fd;
160 int i;
161
162 if (!(val & QOSIFY_DSCP_CLASS_FLAG)) {
163 if (id == CL_MAP_TCP_PORTS)
164 key = QOSIFY_MAX_CLASS_ENTRIES;
165 else if (id == CL_MAP_UDP_PORTS)
166 key = QOSIFY_MAX_CLASS_ENTRIES + 1;
167 else
168 return;
169
170 fd = qosify_map_fds[CL_MAP_CLASS];
171
172 memcpy(&class.config, &flow_config, sizeof(class.config));
173 bpf_map_update_elem(fd, &key, &class, BPF_ANY);
174
175 val = key | QOSIFY_DSCP_CLASS_FLAG;
176 }
177
178 fd = qosify_map_fds[id];
179 for (i = 0; i < (1 << 16); i++) {
180 data.addr.port = htons(i);
181 if (avl_find(&map_data, &data))
182 continue;
183
184 bpf_map_update_elem(fd, &data.addr, &val, BPF_ANY);
185 }
186 }
187
188 void qosify_map_set_dscp_default(enum qosify_map_id id, uint8_t val)
189 {
190 bool udp;
191
192 if (id == CL_MAP_TCP_PORTS)
193 udp = false;
194 else if (id == CL_MAP_UDP_PORTS)
195 udp = true;
196 else
197 return;
198
199 if (!memcmp(&qosify_dscp_default[udp], &val, sizeof(val)))
200 return;
201
202 qosify_dscp_default[udp] = val;
203 __qosify_map_set_dscp_default(id, val);
204 }
205
206 int qosify_map_init(void)
207 {
208 int i;
209
210 for (i = 0; i < CL_MAP_DNS; i++) {
211 qosify_map_fds[i] = qosify_map_get_fd(i);
212 if (qosify_map_fds[i] < 0)
213 return -1;
214 }
215
216 qosify_map_clear_list(CL_MAP_IPV4_ADDR);
217 qosify_map_clear_list(CL_MAP_IPV6_ADDR);
218 qosify_map_reset_config();
219
220 return 0;
221 }
222
223 static char *str_skip(char *str, bool space)
224 {
225 while (*str && isspace(*str) == space)
226 str++;
227
228 return str;
229 }
230
231 static int
232 qosify_map_codepoint(const char *val)
233 {
234 int i;
235
236 for (i = 0; i < ARRAY_SIZE(codepoints); i++)
237 if (!strcmp(codepoints[i].name, val))
238 return codepoints[i].val;
239
240 return 0xff;
241 }
242
243 static int qosify_map_entry_cmp(const void *k1, const void *k2, void *ptr)
244 {
245 const struct qosify_map_data *d1 = k1;
246 const struct qosify_map_data *d2 = k2;
247
248 if (d1->id != d2->id)
249 return d2->id - d1->id;
250
251 if (d1->id == CL_MAP_DNS)
252 return strcmp(d1->addr.dns.pattern, d2->addr.dns.pattern);
253
254 return memcmp(&d1->addr, &d2->addr, sizeof(d1->addr));
255 }
256
257 static struct qosify_map_entry *
258 __qosify_map_alloc_entry(struct qosify_map_data *data)
259 {
260 struct qosify_map_entry *e;
261 char *pattern;
262 char *c;
263
264 if (data->id < CL_MAP_DNS) {
265 e = calloc(1, sizeof(*e));
266 memcpy(&e->data.addr, &data->addr, sizeof(e->data.addr));
267
268 return e;
269 }
270
271 e = calloc_a(sizeof(*e), &pattern, strlen(data->addr.dns.pattern) + 1);
272 strcpy(pattern, data->addr.dns.pattern);
273 e->data.addr.dns.pattern = pattern;
274
275 for (c = pattern; *c; c++)
276 *c = tolower(*c);
277
278 if (pattern[0] == '/' &&
279 regcomp(&e->data.addr.dns.regex, pattern + 1,
280 REG_EXTENDED | REG_NOSUB)) {
281 free(e);
282 return NULL;
283 }
284
285 return e;
286 }
287
288 void __qosify_map_set_entry(struct qosify_map_data *data)
289 {
290 int fd = qosify_map_fds[data->id];
291 struct qosify_map_entry *e;
292 bool file = data->file;
293 uint8_t prev_dscp = 0xff;
294 int32_t delta = 0;
295 bool add = data->dscp != 0xff;
296
297 e = avl_find_element(&map_data, data, e, avl);
298 if (!e) {
299 if (!add)
300 return;
301
302 e = __qosify_map_alloc_entry(data);
303 if (!e)
304 return;
305
306 e->avl.key = &e->data;
307 e->data.id = data->id;
308 avl_insert(&map_data, &e->avl);
309 } else {
310 prev_dscp = e->data.dscp;
311 }
312
313 if (file)
314 e->data.file = add;
315 else
316 e->data.user = add;
317
318 if (add) {
319 if (file)
320 e->data.file_dscp = data->dscp;
321 if (!e->data.user || !file)
322 e->data.dscp = data->dscp;
323 } else if (e->data.file && !file) {
324 e->data.dscp = e->data.file_dscp;
325 }
326
327 if (e->data.dscp != prev_dscp && data->id < CL_MAP_DNS) {
328 struct qosify_ip_map_val val = {
329 .dscp = e->data.dscp,
330 .seen = 1,
331 };
332
333 bpf_map_update_elem(fd, &data->addr, &val, BPF_ANY);
334 }
335
336 if (data->id == CL_MAP_DNS)
337 e->data.addr.dns.seq = ++map_dns_seq;
338
339 if (add) {
340 if (qosify_map_timeout == ~0 || file) {
341 e->timeout = ~0;
342 return;
343 }
344
345 e->timeout = qosify_gettime() + qosify_map_timeout;
346 delta = e->timeout - next_timeout;
347 if (next_timeout && delta >= 0)
348 return;
349 }
350
351 uloop_timeout_set(&qosify_map_timer, 1);
352 }
353
354 static int
355 qosify_map_set_port(struct qosify_map_data *data, const char *str)
356 {
357 unsigned long start_port, end_port;
358 char *err;
359 int i;
360
361 start_port = end_port = strtoul(str, &err, 0);
362 if (err && *err) {
363 if (*err == '-')
364 end_port = strtoul(err + 1, &err, 0);
365 if (*err)
366 return -1;
367 }
368
369 if (!start_port || end_port < start_port ||
370 end_port >= 65535)
371 return -1;
372
373 for (i = start_port; i <= end_port; i++) {
374 data->addr.port = htons(i);
375 __qosify_map_set_entry(data);
376 }
377
378 return 0;
379 }
380
381 static int
382 qosify_map_fill_ip(struct qosify_map_data *data, const char *str)
383 {
384 int af;
385
386 if (data->id == CL_MAP_IPV6_ADDR)
387 af = AF_INET6;
388 else
389 af = AF_INET;
390
391 if (inet_pton(af, str, &data->addr) != 1)
392 return -1;
393
394 return 0;
395 }
396
397 int qosify_map_set_entry(enum qosify_map_id id, bool file, const char *str,
398 uint8_t dscp)
399 {
400 struct qosify_map_data data = {
401 .id = id,
402 .file = file,
403 .dscp = dscp,
404 };
405
406 switch (id) {
407 case CL_MAP_DNS:
408 data.addr.dns.pattern = str;
409 break;
410 case CL_MAP_TCP_PORTS:
411 case CL_MAP_UDP_PORTS:
412 return qosify_map_set_port(&data, str);
413 case CL_MAP_IPV4_ADDR:
414 case CL_MAP_IPV6_ADDR:
415 if (qosify_map_fill_ip(&data, str))
416 return -1;
417 break;
418 default:
419 return -1;
420 }
421
422 __qosify_map_set_entry(&data);
423
424 return 0;
425 }
426
427 static int
428 __qosify_map_dscp_value(const char *val, uint8_t *dscp_val)
429 {
430 unsigned long dscp;
431 bool fallback = false;
432 char *err;
433
434 if (*val == '+') {
435 fallback = true;
436 val++;
437 }
438
439 dscp = strtoul(val, &err, 0);
440 if (err && *err)
441 dscp = qosify_map_codepoint(val);
442
443 if (dscp >= 64)
444 return -1;
445
446 *dscp_val = dscp | (fallback << 6);
447
448 return 0;
449 }
450
451 static int
452 qosify_map_check_class(const char *val, uint8_t *dscp_val)
453 {
454 int i;
455
456 for (i = 0; i < ARRAY_SIZE(map_class); i++) {
457 if (map_class[i] && !strcmp(val, map_class[i]->name)) {
458 *dscp_val = i | QOSIFY_DSCP_CLASS_FLAG;
459 return 0;
460 }
461 }
462
463 return -1;
464 }
465
466 int qosify_map_dscp_value(const char *val, uint8_t *dscp_val)
467 {
468 uint8_t fallback = 0;
469
470 if (*val == '+') {
471 fallback = QOSIFY_DSCP_FALLBACK_FLAG;
472 val++;
473 }
474
475 if (qosify_map_check_class(val, dscp_val) &&
476 __qosify_map_dscp_value(val, dscp_val))
477 return -1;
478
479 *dscp_val |= fallback;
480
481 return 0;
482 }
483
484 static void
485 qosify_map_dscp_codepoint_str(char *dest, int len, uint8_t dscp)
486 {
487 int i;
488
489 if (dscp & QOSIFY_DSCP_FALLBACK_FLAG) {
490 *(dest++) = '+';
491 len--;
492 dscp &= ~QOSIFY_DSCP_FALLBACK_FLAG;
493 }
494
495 for (i = 0; i < ARRAY_SIZE(codepoints); i++) {
496 if (codepoints[i].val != dscp)
497 continue;
498
499 snprintf(dest, len, "%s", codepoints[i].name);
500 return;
501 }
502
503 snprintf(dest, len, "0x%x", dscp);
504 }
505
506 static void
507 qosify_map_parse_line(char *str)
508 {
509 const char *key, *value;
510 uint8_t dscp;
511
512 str = str_skip(str, true);
513 key = str;
514
515 str = str_skip(str, false);
516 if (!*str)
517 return;
518
519 *(str++) = 0;
520 str = str_skip(str, true);
521 value = str;
522
523 if (qosify_map_dscp_value(value, &dscp))
524 return;
525
526 if (!strncmp(key, "dns:", 4))
527 qosify_map_set_entry(CL_MAP_DNS, true, key + 4, dscp);
528 if (!strncmp(key, "tcp:", 4))
529 qosify_map_set_entry(CL_MAP_TCP_PORTS, true, key + 4, dscp);
530 else if (!strncmp(key, "udp:", 4))
531 qosify_map_set_entry(CL_MAP_UDP_PORTS, true, key + 4, dscp);
532 else if (strchr(key, ':'))
533 qosify_map_set_entry(CL_MAP_IPV6_ADDR, true, key, dscp);
534 else if (strchr(key, '.'))
535 qosify_map_set_entry(CL_MAP_IPV4_ADDR, true, key, dscp);
536 }
537
538 static void
539 __qosify_map_load_file_data(FILE *f)
540 {
541 char line[1024];
542 char *cur;
543
544 while (fgets(line, sizeof(line), f)) {
545 cur = strchr(line, '#');
546 if (cur)
547 *cur = 0;
548
549 cur = line + strlen(line);
550 if (cur == line)
551 continue;
552
553 while (cur > line && isspace(cur[-1]))
554 cur--;
555
556 *cur = 0;
557 qosify_map_parse_line(line);
558 }
559
560 }
561
562 static int
563 __qosify_map_load_file(const char *file)
564 {
565 glob_t gl;
566 FILE *f;
567 int i;
568
569 if (!file)
570 return 0;
571
572 glob(file, 0, NULL, &gl);
573
574 for (i = 0; i < gl.gl_pathc; i++) {
575 f = fopen(file, "r");
576 if (!f)
577 continue;
578
579 __qosify_map_load_file_data(f);
580 fclose(f);
581 }
582
583 globfree(&gl);
584
585 return 0;
586 }
587
588 int qosify_map_load_file(const char *file)
589 {
590 struct qosify_map_file *f;
591
592 if (!file)
593 return 0;
594
595 f = calloc(1, sizeof(*f) + strlen(file) + 1);
596 strcpy(f->filename, file);
597 list_add_tail(&f->list, &map_files);
598
599 return __qosify_map_load_file(file);
600 }
601
602 static void qosify_map_reset_file_entries(void)
603 {
604 struct qosify_map_entry *e;
605
606 map_dns_seq = 0;
607 avl_for_each_element(&map_data, e, avl)
608 e->data.file = false;
609 }
610
611 void qosify_map_clear_files(void)
612 {
613 struct qosify_map_file *f, *tmp;
614
615 qosify_map_reset_file_entries();
616
617 list_for_each_entry_safe(f, tmp, &map_files, list) {
618 list_del(&f->list);
619 free(f);
620 }
621 }
622
623 void qosify_map_reset_config(void)
624 {
625 qosify_map_clear_files();
626 qosify_map_set_dscp_default(CL_MAP_TCP_PORTS, 0);
627 qosify_map_set_dscp_default(CL_MAP_UDP_PORTS, 0);
628 qosify_map_timeout = 3600;
629 qosify_active_timeout = 300;
630
631 memset(&config, 0, sizeof(config));
632 flow_config.dscp_prio = 0xff;
633 flow_config.dscp_bulk = 0xff;
634 config.dscp_icmp = 0xff;
635 }
636
637 void qosify_map_reload(void)
638 {
639 struct qosify_map_file *f;
640
641 qosify_map_reset_file_entries();
642
643 list_for_each_entry(f, &map_files, list)
644 __qosify_map_load_file(f->filename);
645
646 qosify_map_gc();
647 }
648
649 static void qosify_map_free_entry(struct qosify_map_entry *e)
650 {
651 int fd = qosify_map_fds[e->data.id];
652
653 avl_delete(&map_data, &e->avl);
654 if (e->data.id < CL_MAP_DNS)
655 bpf_map_delete_elem(fd, &e->data.addr);
656 free(e);
657 }
658
659 static bool
660 qosify_map_entry_refresh_timeout(struct qosify_map_entry *e)
661 {
662 struct qosify_ip_map_val val;
663 int fd = qosify_map_fds[e->data.id];
664
665 if (e->data.id != CL_MAP_IPV4_ADDR &&
666 e->data.id != CL_MAP_IPV6_ADDR)
667 return false;
668
669 if (bpf_map_lookup_elem(fd, &e->data.addr, &val))
670 return false;
671
672 if (!val.seen)
673 return false;
674
675 e->timeout = qosify_gettime() + qosify_active_timeout;
676 val.seen = 0;
677 bpf_map_update_elem(fd, &e->data.addr, &val, BPF_ANY);
678
679 return true;
680 }
681
682 void qosify_map_gc(void)
683 {
684 struct qosify_map_entry *e, *tmp;
685 int32_t timeout = 0;
686 uint32_t cur_time = qosify_gettime();
687
688 next_timeout = 0;
689 avl_for_each_element_safe(&map_data, e, avl, tmp) {
690 int32_t cur_timeout;
691
692 if (e->data.user && e->timeout != ~0) {
693 cur_timeout = e->timeout - cur_time;
694 if (cur_timeout <= 0 &&
695 qosify_map_entry_refresh_timeout(e))
696 cur_timeout = e->timeout - cur_time;
697 if (cur_timeout <= 0) {
698 e->data.user = false;
699 e->data.dscp = e->data.file_dscp;
700 } else if (!timeout || cur_timeout < timeout) {
701 timeout = cur_timeout;
702 next_timeout = e->timeout;
703 }
704 }
705
706 if (e->data.file || e->data.user)
707 continue;
708
709 qosify_map_free_entry(e);
710 }
711
712 if (!timeout)
713 return;
714
715 uloop_timeout_set(&qosify_map_timer, timeout * 1000);
716 }
717
718 int qosify_map_lookup_dns_entry(char *host, uint8_t *dscp, uint32_t *seq)
719 {
720 struct qosify_map_data data = {
721 .id = CL_MAP_DNS,
722 .addr.dns.pattern = "",
723 };
724 struct qosify_map_entry *e;
725 bool ret = -1;
726 char *c;
727
728 e = avl_find_ge_element(&map_data, &data, e, avl);
729 if (!e)
730 return -1;
731
732 for (c = host; *c; c++)
733 *c = tolower(*c);
734
735 avl_for_element_to_last(&map_data, e, e, avl) {
736 regex_t *regex = &e->data.addr.dns.regex;
737
738 if (e->data.id != CL_MAP_DNS)
739 break;
740
741 if (e->data.addr.dns.pattern[0] == '/') {
742 if (regexec(regex, host, 0, NULL, 0) != 0)
743 continue;
744 } else {
745 if (fnmatch(e->data.addr.dns.pattern, host, 0))
746 continue;
747 }
748
749 if (*dscp == 0xff || e->data.addr.dns.seq < *seq) {
750 *dscp = e->data.dscp;
751 *seq = e->data.addr.dns.seq;
752 }
753 ret = 0;
754 }
755
756 return ret;
757 }
758
759
760 int qosify_map_add_dns_host(char *host, const char *addr, const char *type, int ttl)
761 {
762 struct qosify_map_data data = {};
763 int prev_timeout = qosify_map_timeout;
764 uint32_t lookup_seq = 0;
765
766 if (qosify_map_lookup_dns_entry(host, &data.dscp, &lookup_seq))
767 return 0;
768
769 data.user = true;
770 if (!strcmp(type, "A"))
771 data.id = CL_MAP_IPV4_ADDR;
772 else if (!strcmp(type, "AAAA"))
773 data.id = CL_MAP_IPV6_ADDR;
774 else
775 return 0;
776
777 if (qosify_map_fill_ip(&data, addr))
778 return -1;
779
780 if (ttl)
781 qosify_map_timeout = ttl;
782 __qosify_map_set_entry(&data);
783 qosify_map_timeout = prev_timeout;
784
785 return 0;
786 }
787
788 static void
789 blobmsg_add_dscp(struct blob_buf *b, const char *name, uint8_t dscp)
790 {
791 int buf_len = 8;
792 char *buf;
793
794 if (dscp & QOSIFY_DSCP_CLASS_FLAG) {
795 const char *val;
796 int idx;
797
798 idx = dscp & QOSIFY_DSCP_VALUE_MASK;
799 if (map_class[idx])
800 val = map_class[idx]->name;
801 else
802 val = "<invalid>";
803
804 blobmsg_printf(b, name, "%s%s",
805 (dscp & QOSIFY_DSCP_FALLBACK_FLAG) ? "+" : "", val);
806 return;
807 }
808
809 buf = blobmsg_alloc_string_buffer(b, name, buf_len);
810 qosify_map_dscp_codepoint_str(buf, buf_len, dscp);
811 blobmsg_add_string_buffer(b);
812 }
813
814
815 void qosify_map_dump(struct blob_buf *b)
816 {
817 struct qosify_map_entry *e;
818 uint32_t cur_time = qosify_gettime();
819 int buf_len = INET6_ADDRSTRLEN + 1;
820 char *buf;
821 void *a;
822 int af;
823
824 a = blobmsg_open_array(b, "entries");
825 avl_for_each_element(&map_data, e, avl) {
826 void *c;
827
828 if (!e->data.file && !e->data.user)
829 continue;
830
831 c = blobmsg_open_table(b, NULL);
832 if (e->data.user && e->timeout != ~0) {
833 int32_t cur_timeout = e->timeout - cur_time;
834
835 if (cur_timeout < 0)
836 cur_timeout = 0;
837
838 blobmsg_add_u32(b, "timeout", cur_timeout);
839 }
840
841 blobmsg_add_u8(b, "file", e->data.file);
842 blobmsg_add_u8(b, "user", e->data.user);
843
844 blobmsg_add_dscp(b, "dscp", e->data.dscp);
845
846 blobmsg_add_string(b, "type", qosify_map_info[e->data.id].type_name);
847
848 switch (e->data.id) {
849 case CL_MAP_TCP_PORTS:
850 case CL_MAP_UDP_PORTS:
851 blobmsg_printf(b, "addr", "%d", ntohs(e->data.addr.port));
852 break;
853 case CL_MAP_IPV4_ADDR:
854 case CL_MAP_IPV6_ADDR:
855 buf = blobmsg_alloc_string_buffer(b, "addr", buf_len);
856 af = e->data.id == CL_MAP_IPV6_ADDR ? AF_INET6 : AF_INET;
857 inet_ntop(af, &e->data.addr, buf, buf_len);
858 blobmsg_add_string_buffer(b);
859 break;
860 case CL_MAP_DNS:
861 blobmsg_add_string(b, "addr", e->data.addr.dns.pattern);
862 break;
863 default:
864 break;
865 }
866 blobmsg_close_table(b, c);
867 }
868 blobmsg_close_array(b, a);
869 }
870
871 static int32_t
872 qosify_map_get_class_id(const char *name)
873 {
874 int i;
875
876 for (i = 0; i < ARRAY_SIZE(map_class); i++)
877 if (map_class[i] && !strcmp(map_class[i]->name, name))
878 return i;
879
880 for (i = 0; i < ARRAY_SIZE(map_class); i++)
881 if (!map_class[i])
882 return i;
883
884 for (i = 0; i < ARRAY_SIZE(map_class); i++) {
885 if (!(map_class[i]->data.flags & QOSIFY_CLASS_FLAG_PRESENT)) {
886 free(map_class[i]);
887 map_class[i] = NULL;
888 return i;
889 }
890 }
891
892 return -1;
893 }
894
895 int map_fill_dscp_value(uint8_t *dest, struct blob_attr *attr, bool reset)
896 {
897 if (reset)
898 *dest = 0xff;
899
900 if (!attr)
901 return 0;
902
903 if (qosify_map_dscp_value(blobmsg_get_string(attr), dest))
904 return -1;
905
906 return 0;
907 }
908
909 int map_parse_flow_config(struct qosify_flow_config *cfg, struct blob_attr *attr,
910 bool reset)
911 {
912 enum {
913 CL_CONFIG_DSCP_PRIO,
914 CL_CONFIG_DSCP_BULK,
915 CL_CONFIG_BULK_TIMEOUT,
916 CL_CONFIG_BULK_PPS,
917 CL_CONFIG_PRIO_PKT_LEN,
918 __CL_CONFIG_MAX
919 };
920 static const struct blobmsg_policy policy[__CL_CONFIG_MAX] = {
921 [CL_CONFIG_DSCP_PRIO] = { "dscp_prio", BLOBMSG_TYPE_STRING },
922 [CL_CONFIG_DSCP_BULK] = { "dscp_bulk", BLOBMSG_TYPE_STRING },
923 [CL_CONFIG_BULK_TIMEOUT] = { "bulk_trigger_timeout", BLOBMSG_TYPE_INT32 },
924 [CL_CONFIG_BULK_PPS] = { "bulk_trigger_pps", BLOBMSG_TYPE_INT32 },
925 [CL_CONFIG_PRIO_PKT_LEN] = { "prio_max_avg_pkt_len", BLOBMSG_TYPE_INT32 },
926 };
927 struct blob_attr *tb[__CL_CONFIG_MAX];
928 struct blob_attr *cur;
929
930 if (reset)
931 memset(cfg, 0, sizeof(*cfg));
932
933 blobmsg_parse(policy, __CL_CONFIG_MAX, tb, blobmsg_data(attr), blobmsg_len(attr));
934
935 if (map_fill_dscp_value(&cfg->dscp_prio, tb[CL_CONFIG_DSCP_PRIO], reset) ||
936 map_fill_dscp_value(&cfg->dscp_bulk, tb[CL_CONFIG_DSCP_BULK], reset))
937 return -1;
938
939 if ((cur = tb[CL_CONFIG_BULK_TIMEOUT]) != NULL)
940 cfg->bulk_trigger_timeout = blobmsg_get_u32(cur);
941
942 if ((cur = tb[CL_CONFIG_BULK_PPS]) != NULL)
943 cfg->bulk_trigger_pps = blobmsg_get_u32(cur);
944
945 if ((cur = tb[CL_CONFIG_PRIO_PKT_LEN]) != NULL)
946 cfg->prio_max_avg_pkt_len = blobmsg_get_u32(cur);
947
948 return 0;
949 }
950
951 static int
952 qosify_map_create_class(struct blob_attr *attr)
953 {
954 struct qosify_map_class *class;
955 enum {
956 MAP_CLASS_INGRESS,
957 MAP_CLASS_EGRESS,
958 __MAP_CLASS_MAX
959 };
960 static const struct blobmsg_policy policy[__MAP_CLASS_MAX] = {
961 [MAP_CLASS_INGRESS] = { "ingress", BLOBMSG_TYPE_STRING },
962 [MAP_CLASS_EGRESS] = { "egress", BLOBMSG_TYPE_STRING },
963 };
964 struct blob_attr *tb[__MAP_CLASS_MAX];
965 const char *name;
966 char *name_buf;
967 int32_t slot;
968
969 blobmsg_parse(policy, __MAP_CLASS_MAX, tb,
970 blobmsg_data(attr), blobmsg_len(attr));
971
972 if (!tb[MAP_CLASS_INGRESS] || !tb[MAP_CLASS_EGRESS])
973 return -1;
974
975 name = blobmsg_name(attr);
976 slot = qosify_map_get_class_id(name);
977 if (slot < 0)
978 return -1;
979
980 class = map_class[slot];
981 if (!class) {
982 class = calloc_a(sizeof(*class), &name_buf, strlen(name) + 1);
983 class->name = strcpy(name_buf, name);
984 map_class[slot] = class;
985 }
986
987 class->data.flags |= QOSIFY_CLASS_FLAG_PRESENT;
988 if (__qosify_map_dscp_value(blobmsg_get_string(tb[MAP_CLASS_INGRESS]),
989 &class->data.val.ingress) ||
990 __qosify_map_dscp_value(blobmsg_get_string(tb[MAP_CLASS_EGRESS]),
991 &class->data.val.egress)) {
992 map_class[slot] = NULL;
993 free(class);
994 return -1;
995 }
996
997 return 0;
998 }
999
1000 void qosify_map_set_classes(struct blob_attr *val)
1001 {
1002 int fd = qosify_map_fds[CL_MAP_CLASS];
1003 struct qosify_class empty_data = {};
1004 struct blob_attr *cur;
1005 int32_t i;
1006 int rem;
1007
1008 for (i = 0; i < ARRAY_SIZE(map_class); i++)
1009 if (map_class[i])
1010 map_class[i]->data.flags &= ~QOSIFY_CLASS_FLAG_PRESENT;
1011
1012 blobmsg_for_each_attr(cur, val, rem)
1013 qosify_map_create_class(cur);
1014
1015 for (i = 0; i < ARRAY_SIZE(map_class); i++) {
1016 if (map_class[i] &&
1017 (map_class[i]->data.flags & QOSIFY_CLASS_FLAG_PRESENT))
1018 continue;
1019
1020 free(map_class[i]);
1021 map_class[i] = NULL;
1022 }
1023
1024 blobmsg_for_each_attr(cur, val, rem) {
1025 i = qosify_map_get_class_id(blobmsg_name(cur));
1026 if (i < 0 || !map_class[i])
1027 continue;
1028
1029 map_parse_flow_config(&map_class[i]->data.config, cur, true);
1030 }
1031
1032 for (i = 0; i < ARRAY_SIZE(map_class); i++) {
1033 struct qosify_class *data;
1034
1035 data = map_class[i] ? &map_class[i]->data : &empty_data;
1036 bpf_map_update_elem(fd, &i, data, BPF_ANY);
1037 }
1038 }
1039
1040 void qosify_map_update_config(void)
1041 {
1042 int fd = qosify_map_fds[CL_MAP_CONFIG];
1043 uint32_t key = 0;
1044
1045 bpf_map_update_elem(fd, &key, &config, BPF_ANY);
1046 }
OpenWrt QoS implementation based one eBPF + CAKE