• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/qosify/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 (val != 0xff) {
200                 if (qosify_dscp_default[udp] == val)
201                         return;
202 
203                 qosify_dscp_default[udp] = val;
204         }
205 
206         __qosify_map_set_dscp_default(id, qosify_dscp_default[udp]);
207 }
208 
209 int qosify_map_init(void)
210 {
211         int i;
212 
213         for (i = 0; i < CL_MAP_DNS; i++) {
214                 qosify_map_fds[i] = qosify_map_get_fd(i);
215                 if (qosify_map_fds[i] < 0)
216                         return -1;
217         }
218 
219         qosify_map_clear_list(CL_MAP_IPV4_ADDR);
220         qosify_map_clear_list(CL_MAP_IPV6_ADDR);
221         qosify_map_reset_config();
222 
223         return 0;
224 }
225 
226 static char *str_skip(char *str, bool space)
227 {
228         while (*str && isspace(*str) == space)
229                 str++;
230 
231         return str;
232 }
233 
234 static int
235 qosify_map_codepoint(const char *val)
236 {
237         int i;
238 
239         for (i = 0; i < ARRAY_SIZE(codepoints); i++)
240                 if (!strcmp(codepoints[i].name, val))
241                         return codepoints[i].val;
242 
243         return 0xff;
244 }
245 
246 static int qosify_map_entry_cmp(const void *k1, const void *k2, void *ptr)
247 {
248         const struct qosify_map_data *d1 = k1;
249         const struct qosify_map_data *d2 = k2;
250 
251         if (d1->id != d2->id)
252                 return d2->id - d1->id;
253 
254         if (d1->id == CL_MAP_DNS)
255                 return strcmp(d1->addr.dns.pattern, d2->addr.dns.pattern);
256 
257         return memcmp(&d1->addr, &d2->addr, sizeof(d1->addr));
258 }
259 
260 static struct qosify_map_entry *
261 __qosify_map_alloc_entry(struct qosify_map_data *data)
262 {
263         struct qosify_map_entry *e;
264         char *pattern;
265         char *c;
266 
267         if (data->id < CL_MAP_DNS) {
268                 e = calloc(1, sizeof(*e));
269                 memcpy(&e->data.addr, &data->addr, sizeof(e->data.addr));
270 
271                 return e;
272         }
273 
274         e = calloc_a(sizeof(*e), &pattern, strlen(data->addr.dns.pattern) + 1);
275         strcpy(pattern, data->addr.dns.pattern);
276         e->data.addr.dns.pattern = pattern;
277 
278         for (c = pattern; *c; c++)
279                 *c = tolower(*c);
280 
281         if (pattern[0] == '/' &&
282             regcomp(&e->data.addr.dns.regex, pattern + 1,
283                     REG_EXTENDED | REG_NOSUB)) {
284                 free(e);
285                 return NULL;
286         }
287 
288         return e;
289 }
290 
291 void __qosify_map_set_entry(struct qosify_map_data *data)
292 {
293         int fd = qosify_map_fds[data->id];
294         struct qosify_map_entry *e;
295         bool file = data->file;
296         uint8_t prev_dscp = 0xff;
297         int32_t delta = 0;
298         bool add = data->dscp != 0xff;
299 
300         e = avl_find_element(&map_data, data, e, avl);
301         if (!e) {
302                 if (!add)
303                         return;
304 
305                 e = __qosify_map_alloc_entry(data);
306                 if (!e)
307                         return;
308 
309                 e->avl.key = &e->data;
310                 e->data.id = data->id;
311                 avl_insert(&map_data, &e->avl);
312         } else {
313                 prev_dscp = e->data.dscp;
314         }
315 
316         if (file)
317                 e->data.file = add;
318         else
319                 e->data.user = add;
320 
321         if (add) {
322                 if (file)
323                         e->data.file_dscp = data->dscp;
324                 if (!e->data.user || !file)
325                         e->data.dscp = data->dscp;
326         } else if (e->data.file && !file) {
327                 e->data.dscp = e->data.file_dscp;
328         }
329 
330         if (e->data.dscp != prev_dscp && data->id < CL_MAP_DNS) {
331                 struct qosify_ip_map_val val = {
332                         .dscp = e->data.dscp,
333                         .seen = 1,
334                 };
335 
336                 bpf_map_update_elem(fd, &data->addr, &val, BPF_ANY);
337         }
338 
339         if (data->id == CL_MAP_DNS)
340                 e->data.addr.dns.seq = ++map_dns_seq;
341 
342         if (add) {
343                 if (qosify_map_timeout == ~0 || file) {
344                         e->timeout = ~0;
345                         return;
346                 }
347 
348                 e->timeout = qosify_gettime() + qosify_map_timeout;
349                 delta = e->timeout - next_timeout;
350                 if (next_timeout && delta >= 0)
351                         return;
352         }
353 
354         uloop_timeout_set(&qosify_map_timer, 1);
355 }
356 
357 static int
358 qosify_map_set_port(struct qosify_map_data *data, const char *str)
359 {
360         unsigned long start_port, end_port;
361         char *err;
362         int i;
363 
364         start_port = end_port = strtoul(str, &err, 0);
365         if (err && *err) {
366                 if (*err == '-')
367                         end_port = strtoul(err + 1, &err, 0);
368                 if (*err)
369                         return -1;
370         }
371 
372         if (!start_port || end_port < start_port ||
373             end_port >= 65535)
374                 return -1;
375 
376         for (i = start_port; i <= end_port; i++) {
377                 data->addr.port = htons(i);
378                 __qosify_map_set_entry(data);
379         }
380 
381         return 0;
382 }
383 
384 static int
385 qosify_map_fill_ip(struct qosify_map_data *data, const char *str)
386 {
387         int af;
388 
389         if (data->id == CL_MAP_IPV6_ADDR)
390                 af = AF_INET6;
391         else
392                 af = AF_INET;
393 
394         if (inet_pton(af, str, &data->addr) != 1)
395                 return -1;
396 
397         return 0;
398 }
399 
400 int qosify_map_set_entry(enum qosify_map_id id, bool file, const char *str,
401                          uint8_t dscp)
402 {
403         struct qosify_map_data data = {
404                 .id = id,
405                 .file = file,
406                 .dscp = dscp,
407         };
408 
409         switch (id) {
410         case CL_MAP_DNS:
411                 data.addr.dns.pattern = str;
412                 if (str[-2] == 'c')
413                         data.addr.dns.only_cname = 1;
414                 break;
415         case CL_MAP_TCP_PORTS:
416         case CL_MAP_UDP_PORTS:
417                 return qosify_map_set_port(&data, str);
418         case CL_MAP_IPV4_ADDR:
419         case CL_MAP_IPV6_ADDR:
420                 if (qosify_map_fill_ip(&data, str))
421                         return -1;
422                 break;
423         default:
424                 return -1;
425         }
426 
427         __qosify_map_set_entry(&data);
428 
429         return 0;
430 }
431 
432 static int
433 __qosify_map_dscp_value(const char *val, uint8_t *dscp_val)
434 {
435         unsigned long dscp;
436         bool fallback = false;
437         char *err;
438 
439         if (*val == '+') {
440                 fallback = true;
441                 val++;
442         }
443 
444         dscp = strtoul(val, &err, 0);
445         if (err && *err)
446                 dscp = qosify_map_codepoint(val);
447 
448         if (dscp >= 64)
449                 return -1;
450 
451         *dscp_val = dscp | (fallback << 6);
452 
453         return 0;
454 }
455 
456 static int
457 qosify_map_check_class(const char *val, uint8_t *dscp_val)
458 {
459         int i;
460 
461         for (i = 0; i < ARRAY_SIZE(map_class); i++) {
462                 if (map_class[i] && !strcmp(val, map_class[i]->name)) {
463                         *dscp_val = i | QOSIFY_DSCP_CLASS_FLAG;
464                         return 0;
465                 }
466         }
467 
468         return -1;
469 }
470 
471 int qosify_map_dscp_value(const char *val, uint8_t *dscp_val)
472 {
473         uint8_t fallback = 0;
474 
475         if (*val == '+') {
476                 fallback = QOSIFY_DSCP_FALLBACK_FLAG;
477                 val++;
478         }
479 
480         if (qosify_map_check_class(val, dscp_val) &&
481             __qosify_map_dscp_value(val, dscp_val))
482                         return -1;
483 
484         *dscp_val |= fallback;
485 
486         return 0;
487 }
488 
489 static void
490 qosify_map_dscp_codepoint_str(char *dest, int len, uint8_t dscp)
491 {
492         int i;
493 
494         if (dscp & QOSIFY_DSCP_FALLBACK_FLAG) {
495                 *(dest++) = '+';
496                 len--;
497                 dscp &= ~QOSIFY_DSCP_FALLBACK_FLAG;
498         }
499 
500         for (i = 0; i < ARRAY_SIZE(codepoints); i++) {
501                 if (codepoints[i].val != dscp)
502                         continue;
503 
504                 snprintf(dest, len, "%s", codepoints[i].name);
505                 return;
506         }
507 
508         snprintf(dest, len, "0x%x", dscp);
509 }
510 
511 static void
512 qosify_map_parse_line(char *str)
513 {
514         const char *key, *value;
515         uint8_t dscp;
516 
517         str = str_skip(str, true);
518         key = str;
519 
520         str = str_skip(str, false);
521         if (!*str)
522                 return;
523 
524         *(str++) = 0;
525         str = str_skip(str, true);
526         value = str;
527 
528         if (qosify_map_dscp_value(value, &dscp))
529                 return;
530 
531         if (!strncmp(key, "dns:", 4))
532                 qosify_map_set_entry(CL_MAP_DNS, true, key + 4, dscp);
533         if (!strncmp(key, "dns_q:", 6) || !strncmp(key, "dns_c:", 6))
534                 qosify_map_set_entry(CL_MAP_DNS, true, key + 6, dscp);
535         if (!strncmp(key, "tcp:", 4))
536                 qosify_map_set_entry(CL_MAP_TCP_PORTS, true, key + 4, dscp);
537         else if (!strncmp(key, "udp:", 4))
538                 qosify_map_set_entry(CL_MAP_UDP_PORTS, true, key + 4, dscp);
539         else if (strchr(key, ':'))
540                 qosify_map_set_entry(CL_MAP_IPV6_ADDR, true, key, dscp);
541         else if (strchr(key, '.'))
542                 qosify_map_set_entry(CL_MAP_IPV4_ADDR, true, key, dscp);
543 }
544 
545 static void
546 __qosify_map_load_file_data(FILE *f)
547 {
548         char line[1024];
549         char *cur;
550 
551         while (fgets(line, sizeof(line), f)) {
552                 cur = strchr(line, '#');
553                 if (cur)
554                         *cur = 0;
555 
556                 cur = line + strlen(line);
557                 if (cur == line)
558                         continue;
559 
560                 while (cur > line && isspace(cur[-1]))
561                         cur--;
562 
563                 *cur = 0;
564                 qosify_map_parse_line(line);
565         }
566 
567 }
568 
569 static int
570 __qosify_map_load_file(const char *file)
571 {
572         glob_t gl;
573         FILE *f;
574         int i;
575 
576         if (!file)
577                 return 0;
578 
579         glob(file, 0, NULL, &gl);
580 
581         for (i = 0; i < gl.gl_pathc; i++) {
582                 f = fopen(file, "r");
583                 if (!f)
584                         continue;
585 
586                 __qosify_map_load_file_data(f);
587                 fclose(f);
588         }
589 
590         globfree(&gl);
591 
592         return 0;
593 }
594 
595 int qosify_map_load_file(const char *file)
596 {
597         struct qosify_map_file *f;
598 
599         if (!file)
600                 return 0;
601 
602         f = calloc(1, sizeof(*f) + strlen(file) + 1);
603         strcpy(f->filename, file);
604         list_add_tail(&f->list, &map_files);
605 
606         return __qosify_map_load_file(file);
607 }
608 
609 static void qosify_map_reset_file_entries(void)
610 {
611         struct qosify_map_entry *e;
612 
613         map_dns_seq = 0;
614         avl_for_each_element(&map_data, e, avl)
615                 e->data.file = false;
616 }
617 
618 void qosify_map_clear_files(void)
619 {
620         struct qosify_map_file *f, *tmp;
621 
622         qosify_map_reset_file_entries();
623 
624         list_for_each_entry_safe(f, tmp, &map_files, list) {
625                 list_del(&f->list);
626                 free(f);
627         }
628 }
629 
630 void qosify_map_reset_config(void)
631 {
632         qosify_map_clear_files();
633         qosify_map_set_dscp_default(CL_MAP_TCP_PORTS, 0);
634         qosify_map_set_dscp_default(CL_MAP_UDP_PORTS, 0);
635         qosify_map_timeout = 3600;
636         qosify_active_timeout = 300;
637 
638         memset(&config, 0, sizeof(config));
639         flow_config.dscp_prio = 0xff;
640         flow_config.dscp_bulk = 0xff;
641         config.dscp_icmp = 0xff;
642 }
643 
644 void qosify_map_reload(void)
645 {
646         struct qosify_map_file *f;
647 
648         qosify_map_reset_file_entries();
649 
650         list_for_each_entry(f, &map_files, list)
651                 __qosify_map_load_file(f->filename);
652 
653         qosify_map_gc();
654 
655         qosify_map_set_dscp_default(CL_MAP_TCP_PORTS, 0xff);
656         qosify_map_set_dscp_default(CL_MAP_UDP_PORTS, 0xff);
657 }
658 
659 static void qosify_map_free_entry(struct qosify_map_entry *e)
660 {
661         int fd = qosify_map_fds[e->data.id];
662 
663         avl_delete(&map_data, &e->avl);
664         if (e->data.id < CL_MAP_DNS)
665                 bpf_map_delete_elem(fd, &e->data.addr);
666         free(e);
667 }
668 
669 static bool
670 qosify_map_entry_refresh_timeout(struct qosify_map_entry *e)
671 {
672         struct qosify_ip_map_val val;
673         int fd = qosify_map_fds[e->data.id];
674 
675         if (e->data.id != CL_MAP_IPV4_ADDR &&
676             e->data.id != CL_MAP_IPV6_ADDR)
677                 return false;
678 
679         if (bpf_map_lookup_elem(fd, &e->data.addr, &val))
680                 return false;
681 
682         if (!val.seen)
683                 return false;
684 
685         e->timeout = qosify_gettime() + qosify_active_timeout;
686         val.seen = 0;
687         bpf_map_update_elem(fd, &e->data.addr, &val, BPF_ANY);
688 
689         return true;
690 }
691 
692 void qosify_map_gc(void)
693 {
694         struct qosify_map_entry *e, *tmp;
695         int32_t timeout = 0;
696         uint32_t cur_time = qosify_gettime();
697 
698         next_timeout = 0;
699         avl_for_each_element_safe(&map_data, e, avl, tmp) {
700                 int32_t cur_timeout;
701 
702                 if (e->data.user && e->timeout != ~0) {
703                         cur_timeout = e->timeout - cur_time;
704                         if (cur_timeout <= 0 &&
705                             qosify_map_entry_refresh_timeout(e))
706                                 cur_timeout = e->timeout - cur_time;
707                         if (cur_timeout <= 0) {
708                                 e->data.user = false;
709                                 e->data.dscp = e->data.file_dscp;
710                         } else if (!timeout || cur_timeout < timeout) {
711                                 timeout = cur_timeout;
712                                 next_timeout = e->timeout;
713                         }
714                 }
715 
716                 if (e->data.file || e->data.user)
717                         continue;
718 
719                 qosify_map_free_entry(e);
720         }
721 
722         if (!timeout)
723                 return;
724 
725         uloop_timeout_set(&qosify_map_timer, timeout * 1000);
726 }
727 
728 int qosify_map_lookup_dns_entry(char *host, bool cname, uint8_t *dscp, uint32_t *seq)
729 {
730         struct qosify_map_data data = {
731                 .id = CL_MAP_DNS,
732                 .addr.dns.pattern = "",
733         };
734         struct qosify_map_entry *e;
735         bool ret = -1;
736         char *c;
737 
738         e = avl_find_ge_element(&map_data, &data, e, avl);
739         if (!e)
740                 return -1;
741 
742         for (c = host; *c; c++)
743                 *c = tolower(*c);
744 
745         avl_for_element_to_last(&map_data, e, e, avl) {
746                 regex_t *regex = &e->data.addr.dns.regex;
747 
748                 if (e->data.id != CL_MAP_DNS)
749                         break;
750 
751                 if (!cname && e->data.addr.dns.only_cname)
752                         continue;
753 
754                 if (e->data.addr.dns.pattern[0] == '/') {
755                         if (regexec(regex, host, 0, NULL, 0) != 0)
756                                 continue;
757                 } else {
758                         if (fnmatch(e->data.addr.dns.pattern, host, 0))
759                                 continue;
760                 }
761 
762                 if (*dscp == 0xff || e->data.addr.dns.seq < *seq) {
763                         *dscp = e->data.dscp;
764                         *seq = e->data.addr.dns.seq;
765                 }
766                 ret = 0;
767         }
768 
769         return ret;
770 }
771 
772 
773 int qosify_map_add_dns_host(char *host, const char *addr, const char *type, int ttl)
774 {
775         struct qosify_map_data data = {
776                 .dscp = 0xff
777         };
778         int prev_timeout = qosify_map_timeout;
779         uint32_t lookup_seq = 0;
780 
781         if (qosify_map_lookup_dns_entry(host, false, &data.dscp, &lookup_seq))
782                 return 0;
783 
784         data.user = true;
785         if (!strcmp(type, "A"))
786                 data.id = CL_MAP_IPV4_ADDR;
787         else if (!strcmp(type, "AAAA"))
788                 data.id = CL_MAP_IPV6_ADDR;
789         else
790                 return 0;
791 
792         if (qosify_map_fill_ip(&data, addr))
793                 return -1;
794 
795         if (ttl)
796                 qosify_map_timeout = ttl;
797         __qosify_map_set_entry(&data);
798         qosify_map_timeout = prev_timeout;
799 
800         return 0;
801 }
802 
803 static void
804 blobmsg_add_dscp(struct blob_buf *b, const char *name, uint8_t dscp)
805 {
806         int buf_len = 8;
807         char *buf;
808 
809         if (dscp & QOSIFY_DSCP_CLASS_FLAG) {
810                 const char *val;
811                 int idx;
812 
813                 idx = dscp & QOSIFY_DSCP_VALUE_MASK;
814                 if (map_class[idx])
815                         val = map_class[idx]->name;
816                 else
817                         val = "<invalid>";
818 
819                 blobmsg_printf(b, name, "%s%s",
820                                (dscp & QOSIFY_DSCP_FALLBACK_FLAG) ? "+" : "", val);
821                 return;
822         }
823 
824         buf = blobmsg_alloc_string_buffer(b, name, buf_len);
825         qosify_map_dscp_codepoint_str(buf, buf_len, dscp);
826         blobmsg_add_string_buffer(b);
827 }
828 
829 
830 void qosify_map_dump(struct blob_buf *b)
831 {
832         struct qosify_map_entry *e;
833         uint32_t cur_time = qosify_gettime();
834         int buf_len = INET6_ADDRSTRLEN + 1;
835         char *buf;
836         void *a;
837         int af;
838 
839         a = blobmsg_open_array(b, "entries");
840         avl_for_each_element(&map_data, e, avl) {
841                 void *c;
842 
843                 if (!e->data.file && !e->data.user)
844                         continue;
845 
846                 c = blobmsg_open_table(b, NULL);
847                 if (e->data.user && e->timeout != ~0) {
848                         int32_t cur_timeout = e->timeout - cur_time;
849 
850                         if (cur_timeout < 0)
851                                 cur_timeout = 0;
852 
853                         blobmsg_add_u32(b, "timeout", cur_timeout);
854                 }
855 
856                 blobmsg_add_u8(b, "file", e->data.file);
857                 blobmsg_add_u8(b, "user", e->data.user);
858 
859                 blobmsg_add_dscp(b, "dscp", e->data.dscp);
860 
861                 blobmsg_add_string(b, "type", qosify_map_info[e->data.id].type_name);
862 
863                 switch (e->data.id) {
864                 case CL_MAP_TCP_PORTS:
865                 case CL_MAP_UDP_PORTS:
866                         blobmsg_printf(b, "addr", "%d", ntohs(e->data.addr.port));
867                         break;
868                 case CL_MAP_IPV4_ADDR:
869                 case CL_MAP_IPV6_ADDR:
870                         buf = blobmsg_alloc_string_buffer(b, "addr", buf_len);
871                         af = e->data.id == CL_MAP_IPV6_ADDR ? AF_INET6 : AF_INET;
872                         inet_ntop(af, &e->data.addr, buf, buf_len);
873                         blobmsg_add_string_buffer(b);
874                         break;
875                 case CL_MAP_DNS:
876                         blobmsg_add_string(b, "addr", e->data.addr.dns.pattern);
877                         break;
878                 default:
879                         break;
880                 }
881                 blobmsg_close_table(b, c);
882         }
883         blobmsg_close_array(b, a);
884 }
885 
886 static int32_t
887 qosify_map_get_class_id(const char *name)
888 {
889         int i;
890 
891         for (i = 0; i < ARRAY_SIZE(map_class); i++)
892                 if (map_class[i] && !strcmp(map_class[i]->name, name))
893                         return i;
894 
895         for (i = 0; i < ARRAY_SIZE(map_class); i++)
896                 if (!map_class[i])
897                         return i;
898 
899         for (i = 0; i < ARRAY_SIZE(map_class); i++) {
900                 if (!(map_class[i]->data.flags & QOSIFY_CLASS_FLAG_PRESENT)) {
901                         free(map_class[i]);
902                         map_class[i] = NULL;
903                         return i;
904                 }
905         }
906 
907         return -1;
908 }
909 
910 int map_fill_dscp_value(uint8_t *dest, struct blob_attr *attr, bool reset)
911 {
912         if (reset)
913                  *dest = 0xff;
914 
915         if (!attr)
916                 return 0;
917 
918         if (qosify_map_dscp_value(blobmsg_get_string(attr), dest))
919                 return -1;
920 
921         return 0;
922 }
923 
924 int map_parse_flow_config(struct qosify_flow_config *cfg, struct blob_attr *attr,
925                           bool reset)
926 {
927         enum {
928                 CL_CONFIG_DSCP_PRIO,
929                 CL_CONFIG_DSCP_BULK,
930                 CL_CONFIG_BULK_TIMEOUT,
931                 CL_CONFIG_BULK_PPS,
932                 CL_CONFIG_PRIO_PKT_LEN,
933                 __CL_CONFIG_MAX
934         };
935         static const struct blobmsg_policy policy[__CL_CONFIG_MAX] = {
936                 [CL_CONFIG_DSCP_PRIO] = { "dscp_prio", BLOBMSG_TYPE_STRING },
937                 [CL_CONFIG_DSCP_BULK] = { "dscp_bulk", BLOBMSG_TYPE_STRING },
938                 [CL_CONFIG_BULK_TIMEOUT] = { "bulk_trigger_timeout", BLOBMSG_TYPE_INT32 },
939                 [CL_CONFIG_BULK_PPS] = { "bulk_trigger_pps", BLOBMSG_TYPE_INT32 },
940                 [CL_CONFIG_PRIO_PKT_LEN] = { "prio_max_avg_pkt_len", BLOBMSG_TYPE_INT32 },
941         };
942         struct blob_attr *tb[__CL_CONFIG_MAX];
943         struct blob_attr *cur;
944 
945         if (reset)
946             memset(cfg, 0, sizeof(*cfg));
947 
948         blobmsg_parse(policy, __CL_CONFIG_MAX, tb, blobmsg_data(attr), blobmsg_len(attr));
949 
950         if (map_fill_dscp_value(&cfg->dscp_prio, tb[CL_CONFIG_DSCP_PRIO], reset) ||
951             map_fill_dscp_value(&cfg->dscp_bulk, tb[CL_CONFIG_DSCP_BULK], reset))
952                 return -1;
953 
954         if ((cur = tb[CL_CONFIG_BULK_TIMEOUT]) != NULL)
955                 cfg->bulk_trigger_timeout = blobmsg_get_u32(cur);
956 
957         if ((cur = tb[CL_CONFIG_BULK_PPS]) != NULL)
958                 cfg->bulk_trigger_pps = blobmsg_get_u32(cur);
959 
960         if ((cur = tb[CL_CONFIG_PRIO_PKT_LEN]) != NULL)
961                 cfg->prio_max_avg_pkt_len = blobmsg_get_u32(cur);
962 
963         return 0;
964 }
965 
966 static int
967 qosify_map_create_class(struct blob_attr *attr)
968 {
969         struct qosify_map_class *class;
970         enum {
971                 MAP_CLASS_INGRESS,
972                 MAP_CLASS_EGRESS,
973                 __MAP_CLASS_MAX
974         };
975         static const struct blobmsg_policy policy[__MAP_CLASS_MAX] = {
976                 [MAP_CLASS_INGRESS] = { "ingress", BLOBMSG_TYPE_STRING },
977                 [MAP_CLASS_EGRESS] = { "egress", BLOBMSG_TYPE_STRING },
978         };
979         struct blob_attr *tb[__MAP_CLASS_MAX];
980         const char *name;
981         char *name_buf;
982         int32_t slot;
983 
984         blobmsg_parse(policy, __MAP_CLASS_MAX, tb,
985                       blobmsg_data(attr), blobmsg_len(attr));
986 
987         if (!tb[MAP_CLASS_INGRESS] || !tb[MAP_CLASS_EGRESS])
988                 return -1;
989 
990         name = blobmsg_name(attr);
991         slot = qosify_map_get_class_id(name);
992         if (slot < 0)
993                 return -1;
994 
995         class = map_class[slot];
996         if (!class) {
997                 class = calloc_a(sizeof(*class), &name_buf, strlen(name) + 1);
998                 class->name = strcpy(name_buf, name);
999                 map_class[slot] = class;
1000         }
1001 
1002         class->data.flags |= QOSIFY_CLASS_FLAG_PRESENT;
1003         if (__qosify_map_dscp_value(blobmsg_get_string(tb[MAP_CLASS_INGRESS]),
1004                                     &class->data.val.ingress) ||
1005             __qosify_map_dscp_value(blobmsg_get_string(tb[MAP_CLASS_EGRESS]),
1006                                     &class->data.val.egress)) {
1007                 map_class[slot] = NULL;
1008                 free(class);
1009                 return -1;
1010         }
1011 
1012         return 0;
1013 }
1014 
1015 void qosify_map_set_classes(struct blob_attr *val)
1016 {
1017         int fd = qosify_map_fds[CL_MAP_CLASS];
1018         struct qosify_class empty_data = {};
1019         struct blob_attr *cur;
1020         int32_t i;
1021         int rem;
1022 
1023         for (i = 0; i < ARRAY_SIZE(map_class); i++)
1024                 if (map_class[i])
1025                         map_class[i]->data.flags &= ~QOSIFY_CLASS_FLAG_PRESENT;
1026 
1027         blobmsg_for_each_attr(cur, val, rem)
1028                 qosify_map_create_class(cur);
1029 
1030         for (i = 0; i < ARRAY_SIZE(map_class); i++) {
1031                 if (map_class[i] &&
1032                     (map_class[i]->data.flags & QOSIFY_CLASS_FLAG_PRESENT))
1033                         continue;
1034 
1035                 free(map_class[i]);
1036                 map_class[i] = NULL;
1037         }
1038 
1039         blobmsg_for_each_attr(cur, val, rem) {
1040                 i = qosify_map_get_class_id(blobmsg_name(cur));
1041                 if (i < 0 || !map_class[i])
1042                         continue;
1043 
1044                 map_parse_flow_config(&map_class[i]->data.config, cur, true);
1045         }
1046 
1047         for (i = 0; i < ARRAY_SIZE(map_class); i++) {
1048                 struct qosify_class *data;
1049 
1050                 data = map_class[i] ? &map_class[i]->data : &empty_data;
1051                 bpf_map_update_elem(fd, &i, data, BPF_ANY);
1052         }
1053 }
1054 
1055 void qosify_map_update_config(void)
1056 {
1057         int fd = qosify_map_fds[CL_MAP_CONFIG];
1058         uint32_t key = 0;
1059 
1060         bpf_map_update_elem(fd, &key, &config, BPF_ANY);
1061 }
1062 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt