1
2
3#include <errno.h>
4#include <inttypes.h>
5#include <stdio.h>
6#include <libmnl/libmnl.h>
7#include <linux/dcbnl.h>
8
9#include "dcb.h"
10#include "utils.h"
11#include "rt_names.h"
12
13static void dcb_app_help_add(void)
14{
15 fprintf(stderr,
16 "Usage: dcb app { add | del | replace } dev STRING\n"
17 " [ default-prio PRIO ]\n"
18 " [ ethtype-prio ET:PRIO ]\n"
19 " [ stream-port-prio PORT:PRIO ]\n"
20 " [ dgram-port-prio PORT:PRIO ]\n"
21 " [ port-prio PORT:PRIO ]\n"
22 " [ dscp-prio INTEGER:PRIO ]\n"
23 "\n"
24 " where PRIO := { 0 .. 7 }\n"
25 " ET := { 0x600 .. 0xffff }\n"
26 " PORT := { 1 .. 65535 }\n"
27 " DSCP := { 0 .. 63 }\n"
28 "\n"
29 );
30}
31
32static void dcb_app_help_show_flush(void)
33{
34 fprintf(stderr,
35 "Usage: dcb app { show | flush } dev STRING\n"
36 " [ default-prio ]\n"
37 " [ ethtype-prio ]\n"
38 " [ stream-port-prio ]\n"
39 " [ dgram-port-prio ]\n"
40 " [ port-prio ]\n"
41 " [ dscp-prio ]\n"
42 "\n"
43 );
44}
45
46static void dcb_app_help(void)
47{
48 fprintf(stderr,
49 "Usage: dcb app help\n"
50 "\n"
51 );
52 dcb_app_help_show_flush();
53 dcb_app_help_add();
54}
55
56struct dcb_app_table {
57 struct dcb_app *apps;
58 size_t n_apps;
59};
60
61static void dcb_app_table_fini(struct dcb_app_table *tab)
62{
63 free(tab->apps);
64}
65
66static int dcb_app_table_push(struct dcb_app_table *tab, struct dcb_app *app)
67{
68 struct dcb_app *apps = realloc(tab->apps, (tab->n_apps + 1) * sizeof(*tab->apps));
69
70 if (apps == NULL) {
71 perror("Cannot allocate APP table");
72 return -ENOMEM;
73 }
74
75 tab->apps = apps;
76 tab->apps[tab->n_apps++] = *app;
77 return 0;
78}
79
80static void dcb_app_table_remove_existing(struct dcb_app_table *a,
81 const struct dcb_app_table *b)
82{
83 size_t ia, ja;
84 size_t ib;
85
86 for (ia = 0, ja = 0; ia < a->n_apps; ia++) {
87 struct dcb_app *aa = &a->apps[ia];
88 bool found = false;
89
90 for (ib = 0; ib < b->n_apps; ib++) {
91 const struct dcb_app *ab = &b->apps[ib];
92
93 if (aa->selector == ab->selector &&
94 aa->protocol == ab->protocol &&
95 aa->priority == ab->priority) {
96 found = true;
97 break;
98 }
99 }
100
101 if (!found)
102 a->apps[ja++] = *aa;
103 }
104
105 a->n_apps = ja;
106}
107
108static void dcb_app_table_remove_replaced(struct dcb_app_table *a,
109 const struct dcb_app_table *b)
110{
111 size_t ia, ja;
112 size_t ib;
113
114 for (ia = 0, ja = 0; ia < a->n_apps; ia++) {
115 struct dcb_app *aa = &a->apps[ia];
116 bool present = false;
117 bool found = false;
118
119 for (ib = 0; ib < b->n_apps; ib++) {
120 const struct dcb_app *ab = &b->apps[ib];
121
122 if (aa->selector == ab->selector &&
123 aa->protocol == ab->protocol)
124 present = true;
125 else
126 continue;
127
128 if (aa->priority == ab->priority) {
129 found = true;
130 break;
131 }
132 }
133
134
135
136
137
138 if (present && !found)
139 a->apps[ja++] = *aa;
140 }
141
142 a->n_apps = ja;
143}
144
145static int dcb_app_table_copy(struct dcb_app_table *a,
146 const struct dcb_app_table *b)
147{
148 size_t i;
149 int ret;
150
151 for (i = 0; i < b->n_apps; i++) {
152 ret = dcb_app_table_push(a, &b->apps[i]);
153 if (ret != 0)
154 return ret;
155 }
156 return 0;
157}
158
159static int dcb_app_cmp(const struct dcb_app *a, const struct dcb_app *b)
160{
161 if (a->protocol < b->protocol)
162 return -1;
163 if (a->protocol > b->protocol)
164 return 1;
165 return a->priority - b->priority;
166}
167
168static int dcb_app_cmp_cb(const void *a, const void *b)
169{
170 return dcb_app_cmp(a, b);
171}
172
173static void dcb_app_table_sort(struct dcb_app_table *tab)
174{
175 qsort(tab->apps, tab->n_apps, sizeof(*tab->apps), dcb_app_cmp_cb);
176}
177
178struct dcb_app_parse_mapping {
179 __u8 selector;
180 struct dcb_app_table *tab;
181 int err;
182};
183
184static void dcb_app_parse_mapping_cb(__u32 key, __u64 value, void *data)
185{
186 struct dcb_app_parse_mapping *pm = data;
187 struct dcb_app app = {
188 .selector = pm->selector,
189 .priority = value,
190 .protocol = key,
191 };
192
193 if (pm->err)
194 return;
195
196 pm->err = dcb_app_table_push(pm->tab, &app);
197}
198
199static int dcb_app_parse_mapping_ethtype_prio(__u32 key, char *value, void *data)
200{
201 __u8 prio;
202
203 if (key < 0x600) {
204 fprintf(stderr, "Protocol IDs < 0x600 are reserved for EtherType\n");
205 return -EINVAL;
206 }
207
208 if (get_u8(&prio, value, 0))
209 return -EINVAL;
210
211 return dcb_parse_mapping("ETHTYPE", key, 0xffff,
212 "PRIO", prio, IEEE_8021QAZ_MAX_TCS - 1,
213 dcb_app_parse_mapping_cb, data);
214}
215
216static int dcb_app_parse_dscp(__u32 *key, const char *arg)
217{
218 if (parse_mapping_num_all(key, arg) == 0)
219 return 0;
220
221 if (rtnl_dsfield_a2n(key, arg) != 0)
222 return -1;
223
224 if (*key & 0x03) {
225 fprintf(stderr, "The values `%s' uses non-DSCP bits.\n", arg);
226 return -1;
227 }
228
229
230 *key >>= 2;
231 return 0;
232}
233
234static int dcb_app_parse_mapping_dscp_prio(__u32 key, char *value, void *data)
235{
236 __u8 prio;
237
238 if (get_u8(&prio, value, 0))
239 return -EINVAL;
240
241 return dcb_parse_mapping("DSCP", key, 63,
242 "PRIO", prio, IEEE_8021QAZ_MAX_TCS - 1,
243 dcb_app_parse_mapping_cb, data);
244}
245
246static int dcb_app_parse_mapping_port_prio(__u32 key, char *value, void *data)
247{
248 __u8 prio;
249
250 if (key == 0) {
251 fprintf(stderr, "Port ID of 0 is invalid\n");
252 return -EINVAL;
253 }
254
255 if (get_u8(&prio, value, 0))
256 return -EINVAL;
257
258 return dcb_parse_mapping("PORT", key, 0xffff,
259 "PRIO", prio, IEEE_8021QAZ_MAX_TCS - 1,
260 dcb_app_parse_mapping_cb, data);
261}
262
263static int dcb_app_parse_default_prio(int *argcp, char ***argvp, struct dcb_app_table *tab)
264{
265 int argc = *argcp;
266 char **argv = *argvp;
267 int ret = 0;
268
269 while (argc > 0) {
270 struct dcb_app app;
271 __u8 prio;
272
273 if (get_u8(&prio, *argv, 0)) {
274 ret = 1;
275 break;
276 }
277
278 app = (struct dcb_app){
279 .selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE,
280 .protocol = 0,
281 .priority = prio,
282 };
283 ret = dcb_app_table_push(tab, &app);
284 if (ret != 0)
285 break;
286
287 argc--, argv++;
288 }
289
290 *argcp = argc;
291 *argvp = argv;
292 return ret;
293}
294
295static bool dcb_app_is_ethtype(const struct dcb_app *app)
296{
297 return app->selector == IEEE_8021QAZ_APP_SEL_ETHERTYPE &&
298 app->protocol != 0;
299}
300
301static bool dcb_app_is_default(const struct dcb_app *app)
302{
303 return app->selector == IEEE_8021QAZ_APP_SEL_ETHERTYPE &&
304 app->protocol == 0;
305}
306
307static bool dcb_app_is_dscp(const struct dcb_app *app)
308{
309 return app->selector == IEEE_8021QAZ_APP_SEL_DSCP;
310}
311
312static bool dcb_app_is_stream_port(const struct dcb_app *app)
313{
314 return app->selector == IEEE_8021QAZ_APP_SEL_STREAM;
315}
316
317static bool dcb_app_is_dgram_port(const struct dcb_app *app)
318{
319 return app->selector == IEEE_8021QAZ_APP_SEL_DGRAM;
320}
321
322static bool dcb_app_is_port(const struct dcb_app *app)
323{
324 return app->selector == IEEE_8021QAZ_APP_SEL_ANY;
325}
326
327static int dcb_app_print_key_dec(__u16 protocol)
328{
329 return print_uint(PRINT_ANY, NULL, "%d:", protocol);
330}
331
332static int dcb_app_print_key_hex(__u16 protocol)
333{
334 return print_uint(PRINT_ANY, NULL, "%x:", protocol);
335}
336
337static int dcb_app_print_key_dscp(__u16 protocol)
338{
339 const char *name = rtnl_dsfield_get_name(protocol << 2);
340
341
342 if (!is_json_context() && name != NULL)
343 return print_string(PRINT_FP, NULL, "%s:", name);
344 return print_uint(PRINT_ANY, NULL, "%d:", protocol);
345}
346
347static void dcb_app_print_filtered(const struct dcb_app_table *tab,
348 bool (*filter)(const struct dcb_app *),
349 int (*print_key)(__u16 protocol),
350 const char *json_name,
351 const char *fp_name)
352{
353 bool first = true;
354 size_t i;
355
356 for (i = 0; i < tab->n_apps; i++) {
357 struct dcb_app *app = &tab->apps[i];
358
359 if (!filter(app))
360 continue;
361 if (first) {
362 open_json_array(PRINT_JSON, json_name);
363 print_string(PRINT_FP, NULL, "%s ", fp_name);
364 first = false;
365 }
366
367 open_json_array(PRINT_JSON, NULL);
368 print_key(app->protocol);
369 print_uint(PRINT_ANY, NULL, "%d ", app->priority);
370 close_json_array(PRINT_JSON, NULL);
371 }
372
373 if (!first) {
374 close_json_array(PRINT_JSON, json_name);
375 print_nl();
376 }
377}
378
379static void dcb_app_print_ethtype_prio(const struct dcb_app_table *tab)
380{
381 dcb_app_print_filtered(tab, dcb_app_is_ethtype, dcb_app_print_key_hex,
382 "ethtype_prio", "ethtype-prio");
383}
384
385static void dcb_app_print_dscp_prio(const struct dcb *dcb,
386 const struct dcb_app_table *tab)
387{
388 dcb_app_print_filtered(tab, dcb_app_is_dscp,
389 dcb->numeric ? dcb_app_print_key_dec
390 : dcb_app_print_key_dscp,
391 "dscp_prio", "dscp-prio");
392}
393
394static void dcb_app_print_stream_port_prio(const struct dcb_app_table *tab)
395{
396 dcb_app_print_filtered(tab, dcb_app_is_stream_port, dcb_app_print_key_dec,
397 "stream_port_prio", "stream-port-prio");
398}
399
400static void dcb_app_print_dgram_port_prio(const struct dcb_app_table *tab)
401{
402 dcb_app_print_filtered(tab, dcb_app_is_dgram_port, dcb_app_print_key_dec,
403 "dgram_port_prio", "dgram-port-prio");
404}
405
406static void dcb_app_print_port_prio(const struct dcb_app_table *tab)
407{
408 dcb_app_print_filtered(tab, dcb_app_is_port, dcb_app_print_key_dec,
409 "port_prio", "port-prio");
410}
411
412static void dcb_app_print_default_prio(const struct dcb_app_table *tab)
413{
414 bool first = true;
415 size_t i;
416
417 for (i = 0; i < tab->n_apps; i++) {
418 if (!dcb_app_is_default(&tab->apps[i]))
419 continue;
420 if (first) {
421 open_json_array(PRINT_JSON, "default_prio");
422 print_string(PRINT_FP, NULL, "default-prio ", NULL);
423 first = false;
424 }
425 print_uint(PRINT_ANY, NULL, "%d ", tab->apps[i].priority);
426 }
427
428 if (!first) {
429 close_json_array(PRINT_JSON, "default_prio");
430 print_nl();
431 }
432}
433
434static void dcb_app_print(const struct dcb *dcb, const struct dcb_app_table *tab)
435{
436 dcb_app_print_ethtype_prio(tab);
437 dcb_app_print_default_prio(tab);
438 dcb_app_print_dscp_prio(dcb, tab);
439 dcb_app_print_stream_port_prio(tab);
440 dcb_app_print_dgram_port_prio(tab);
441 dcb_app_print_port_prio(tab);
442}
443
444static int dcb_app_get_table_attr_cb(const struct nlattr *attr, void *data)
445{
446 struct dcb_app_table *tab = data;
447 struct dcb_app *app;
448 int ret;
449
450 if (mnl_attr_get_type(attr) != DCB_ATTR_IEEE_APP) {
451 fprintf(stderr, "Unknown attribute in DCB_ATTR_IEEE_APP_TABLE: %d\n",
452 mnl_attr_get_type(attr));
453 return MNL_CB_OK;
454 }
455 if (mnl_attr_get_payload_len(attr) < sizeof(struct dcb_app)) {
456 fprintf(stderr, "DCB_ATTR_IEEE_APP payload expected to have size %zd, not %d\n",
457 sizeof(struct dcb_app), mnl_attr_get_payload_len(attr));
458 return MNL_CB_OK;
459 }
460
461 app = mnl_attr_get_payload(attr);
462 ret = dcb_app_table_push(tab, app);
463 if (ret != 0)
464 return MNL_CB_ERROR;
465
466 return MNL_CB_OK;
467}
468
469static int dcb_app_get(struct dcb *dcb, const char *dev, struct dcb_app_table *tab)
470{
471 uint16_t payload_len;
472 void *payload;
473 int ret;
474
475 ret = dcb_get_attribute_va(dcb, dev, DCB_ATTR_IEEE_APP_TABLE, &payload, &payload_len);
476 if (ret != 0)
477 return ret;
478
479 ret = mnl_attr_parse_payload(payload, payload_len, dcb_app_get_table_attr_cb, tab);
480 if (ret != MNL_CB_OK)
481 return -EINVAL;
482
483 return 0;
484}
485
486struct dcb_app_add_del {
487 const struct dcb_app_table *tab;
488 bool (*filter)(const struct dcb_app *app);
489};
490
491static int dcb_app_add_del_cb(struct dcb *dcb, struct nlmsghdr *nlh, void *data)
492{
493 struct dcb_app_add_del *add_del = data;
494 struct nlattr *nest;
495 size_t i;
496
497 nest = mnl_attr_nest_start(nlh, DCB_ATTR_IEEE_APP_TABLE);
498
499 for (i = 0; i < add_del->tab->n_apps; i++) {
500 const struct dcb_app *app = &add_del->tab->apps[i];
501
502 if (add_del->filter == NULL || add_del->filter(app))
503 mnl_attr_put(nlh, DCB_ATTR_IEEE_APP, sizeof(*app), app);
504 }
505
506 mnl_attr_nest_end(nlh, nest);
507 return 0;
508}
509
510static int dcb_app_add_del(struct dcb *dcb, const char *dev, int command,
511 const struct dcb_app_table *tab,
512 bool (*filter)(const struct dcb_app *))
513{
514 struct dcb_app_add_del add_del = {
515 .tab = tab,
516 .filter = filter,
517 };
518
519 if (tab->n_apps == 0)
520 return 0;
521
522 return dcb_set_attribute_va(dcb, command, dev, dcb_app_add_del_cb, &add_del);
523}
524
525static int dcb_cmd_app_parse_add_del(struct dcb *dcb, const char *dev,
526 int argc, char **argv, struct dcb_app_table *tab)
527{
528 struct dcb_app_parse_mapping pm = {
529 .tab = tab,
530 };
531 int ret;
532
533 if (!argc) {
534 dcb_app_help_add();
535 return 0;
536 }
537
538 do {
539 if (matches(*argv, "help") == 0) {
540 dcb_app_help_add();
541 return 0;
542 } else if (matches(*argv, "ethtype-prio") == 0) {
543 NEXT_ARG();
544 pm.selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE;
545 ret = parse_mapping(&argc, &argv, false,
546 &dcb_app_parse_mapping_ethtype_prio,
547 &pm);
548 } else if (matches(*argv, "default-prio") == 0) {
549 NEXT_ARG();
550 ret = dcb_app_parse_default_prio(&argc, &argv, pm.tab);
551 if (ret != 0) {
552 fprintf(stderr, "Invalid default priority %s\n", *argv);
553 return ret;
554 }
555 } else if (matches(*argv, "dscp-prio") == 0) {
556 NEXT_ARG();
557 pm.selector = IEEE_8021QAZ_APP_SEL_DSCP;
558 ret = parse_mapping_gen(&argc, &argv,
559 &dcb_app_parse_dscp,
560 &dcb_app_parse_mapping_dscp_prio,
561 &pm);
562 } else if (matches(*argv, "stream-port-prio") == 0) {
563 NEXT_ARG();
564 pm.selector = IEEE_8021QAZ_APP_SEL_STREAM;
565 ret = parse_mapping(&argc, &argv, false,
566 &dcb_app_parse_mapping_port_prio,
567 &pm);
568 } else if (matches(*argv, "dgram-port-prio") == 0) {
569 NEXT_ARG();
570 pm.selector = IEEE_8021QAZ_APP_SEL_DGRAM;
571 ret = parse_mapping(&argc, &argv, false,
572 &dcb_app_parse_mapping_port_prio,
573 &pm);
574 } else if (matches(*argv, "port-prio") == 0) {
575 NEXT_ARG();
576 pm.selector = IEEE_8021QAZ_APP_SEL_ANY;
577 ret = parse_mapping(&argc, &argv, false,
578 &dcb_app_parse_mapping_port_prio,
579 &pm);
580 } else {
581 fprintf(stderr, "What is \"%s\"?\n", *argv);
582 dcb_app_help_add();
583 return -EINVAL;
584 }
585
586 if (ret != 0) {
587 fprintf(stderr, "Invalid mapping %s\n", *argv);
588 return ret;
589 }
590 if (pm.err)
591 return pm.err;
592 } while (argc > 0);
593
594 return 0;
595}
596
597static int dcb_cmd_app_add(struct dcb *dcb, const char *dev, int argc, char **argv)
598{
599 struct dcb_app_table tab = {};
600 int ret;
601
602 ret = dcb_cmd_app_parse_add_del(dcb, dev, argc, argv, &tab);
603 if (ret != 0)
604 return ret;
605
606 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_SET, &tab, NULL);
607 dcb_app_table_fini(&tab);
608 return ret;
609}
610
611static int dcb_cmd_app_del(struct dcb *dcb, const char *dev, int argc, char **argv)
612{
613 struct dcb_app_table tab = {};
614 int ret;
615
616 ret = dcb_cmd_app_parse_add_del(dcb, dev, argc, argv, &tab);
617 if (ret != 0)
618 return ret;
619
620 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &tab, NULL);
621 dcb_app_table_fini(&tab);
622 return ret;
623}
624
625static int dcb_cmd_app_show(struct dcb *dcb, const char *dev, int argc, char **argv)
626{
627 struct dcb_app_table tab = {};
628 int ret;
629
630 ret = dcb_app_get(dcb, dev, &tab);
631 if (ret != 0)
632 return ret;
633
634 dcb_app_table_sort(&tab);
635
636 open_json_object(NULL);
637
638 if (!argc) {
639 dcb_app_print(dcb, &tab);
640 goto out;
641 }
642
643 do {
644 if (matches(*argv, "help") == 0) {
645 dcb_app_help_show_flush();
646 goto out;
647 } else if (matches(*argv, "ethtype-prio") == 0) {
648 dcb_app_print_ethtype_prio(&tab);
649 } else if (matches(*argv, "dscp-prio") == 0) {
650 dcb_app_print_dscp_prio(dcb, &tab);
651 } else if (matches(*argv, "stream-port-prio") == 0) {
652 dcb_app_print_stream_port_prio(&tab);
653 } else if (matches(*argv, "dgram-port-prio") == 0) {
654 dcb_app_print_dgram_port_prio(&tab);
655 } else if (matches(*argv, "port-prio") == 0) {
656 dcb_app_print_port_prio(&tab);
657 } else {
658 fprintf(stderr, "What is \"%s\"?\n", *argv);
659 dcb_app_help_show_flush();
660 ret = -EINVAL;
661 goto out;
662 }
663
664 NEXT_ARG_FWD();
665 } while (argc > 0);
666
667out:
668 close_json_object();
669 dcb_app_table_fini(&tab);
670 return ret;
671}
672
673static int dcb_cmd_app_flush(struct dcb *dcb, const char *dev, int argc, char **argv)
674{
675 struct dcb_app_table tab = {};
676 int ret;
677
678 ret = dcb_app_get(dcb, dev, &tab);
679 if (ret != 0)
680 return ret;
681
682 if (!argc) {
683 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &tab, NULL);
684 goto out;
685 }
686
687 do {
688 if (matches(*argv, "help") == 0) {
689 dcb_app_help_show_flush();
690 goto out;
691 } else if (matches(*argv, "ethtype-prio") == 0) {
692 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &tab,
693 &dcb_app_is_ethtype);
694 if (ret != 0)
695 goto out;
696 } else if (matches(*argv, "default-prio") == 0) {
697 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &tab,
698 &dcb_app_is_default);
699 if (ret != 0)
700 goto out;
701 } else if (matches(*argv, "dscp-prio") == 0) {
702 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &tab,
703 &dcb_app_is_dscp);
704 if (ret != 0)
705 goto out;
706 } else {
707 fprintf(stderr, "What is \"%s\"?\n", *argv);
708 dcb_app_help_show_flush();
709 ret = -EINVAL;
710 goto out;
711 }
712
713 NEXT_ARG_FWD();
714 } while (argc > 0);
715
716out:
717 dcb_app_table_fini(&tab);
718 return ret;
719}
720
721static int dcb_cmd_app_replace(struct dcb *dcb, const char *dev, int argc, char **argv)
722{
723 struct dcb_app_table orig = {};
724 struct dcb_app_table tab = {};
725 struct dcb_app_table new = {};
726 int ret;
727
728 ret = dcb_app_get(dcb, dev, &orig);
729 if (ret != 0)
730 return ret;
731
732 ret = dcb_cmd_app_parse_add_del(dcb, dev, argc, argv, &tab);
733 if (ret != 0)
734 goto out;
735
736
737
738
739 ret = dcb_app_table_copy(&new, &tab);
740 if (ret != 0)
741 goto out;
742 dcb_app_table_remove_existing(&new, &orig);
743
744 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_SET, &new, NULL);
745 if (ret != 0) {
746 fprintf(stderr, "Could not add new APP entries\n");
747 goto out;
748 }
749
750
751 dcb_app_table_remove_replaced(&orig, &tab);
752 ret = dcb_app_add_del(dcb, dev, DCB_CMD_IEEE_DEL, &orig, NULL);
753 if (ret != 0) {
754 fprintf(stderr, "Could not remove replaced APP entries\n");
755 goto out;
756 }
757
758out:
759 dcb_app_table_fini(&new);
760 dcb_app_table_fini(&tab);
761 dcb_app_table_fini(&orig);
762 return 0;
763}
764
765int dcb_cmd_app(struct dcb *dcb, int argc, char **argv)
766{
767 if (!argc || matches(*argv, "help") == 0) {
768 dcb_app_help();
769 return 0;
770 } else if (matches(*argv, "show") == 0) {
771 NEXT_ARG_FWD();
772 return dcb_cmd_parse_dev(dcb, argc, argv,
773 dcb_cmd_app_show, dcb_app_help_show_flush);
774 } else if (matches(*argv, "flush") == 0) {
775 NEXT_ARG_FWD();
776 return dcb_cmd_parse_dev(dcb, argc, argv,
777 dcb_cmd_app_flush, dcb_app_help_show_flush);
778 } else if (matches(*argv, "add") == 0) {
779 NEXT_ARG_FWD();
780 return dcb_cmd_parse_dev(dcb, argc, argv,
781 dcb_cmd_app_add, dcb_app_help_add);
782 } else if (matches(*argv, "del") == 0) {
783 NEXT_ARG_FWD();
784 return dcb_cmd_parse_dev(dcb, argc, argv,
785 dcb_cmd_app_del, dcb_app_help_add);
786 } else if (matches(*argv, "replace") == 0) {
787 NEXT_ARG_FWD();
788 return dcb_cmd_parse_dev(dcb, argc, argv,
789 dcb_cmd_app_replace, dcb_app_help_add);
790 } else {
791 fprintf(stderr, "What is \"%s\"?\n", *argv);
792 dcb_app_help();
793 return -EINVAL;
794 }
795}
796
