Snippets for bird 3.3.3 from FreeBSD 151amd64

Sourced from https://pkg-status.freebsd.org/beefy23/data/latest-per-pkg/bird3/3.3.3/151amd64-default.log.

• ./lib/tlists.h:112:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    112 |   if (node->TLIST_ITEM.prev = list->last)
        |       ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
  

• ./lib/tlists.h:97:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     97 |   if (node->TLIST_ITEM.next = list->first)
        |       ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~
  

• ./lib/tlists.h:151:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    151 |   if (node->TLIST_ITEM.next = after->TLIST_ITEM.next)
        |       ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
  

• obj/conf/cf-lex.c:9870:13: warning: passing 'char *' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   9870 |                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
        |                 ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9871 |                         (yy_n_chars), num_to_read );
        |                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• filter/filter.c:372:14: warning: passing 'char[0]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    372 |         if ((osym = cf_find_symbol(old, sym->name)) &&
        |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• filter/filter.c:381:14: warning: passing 'char[0]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    381 |         if ((osym = cf_find_symbol(old, sym->name)) &&
        |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• filter/data.c:558:21: warning: passing 'const char *const' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    558 |     return patmatch(v2->val.s, v1->val.s);
        |                     ^~~~~~~~~
  

• filter/data.c:558:32: warning: passing 'const char *const' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    558 |     return patmatch(v2->val.s, v1->val.s);
        |                                ^~~~~~~~~
  

• filter/data.c:720:24: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    720 |   case T_EC:    ec_format(buf2, v->val.ec); buffer_print(buf, "%s", buf2); return;
        |                           ^~~~
  

• filter/data.c:721:24: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    721 |   case T_LC:    lc_format(buf2, v->val.lc); buffer_print(buf, "%s", buf2); return;
        |                           ^~~~
  

• filter/data.c:727:42: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    727 |   case T_PATH:  as_path_format(v->val.ad, buf2, 1000); buffer_print(buf, "(path %s)", buf2); return;
        |                                           ^~~~
  

• filter/data.c:728:50: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    728 |   case T_CLIST: int_set_format(v->val.ad, 1, -1, buf2, 1000); buffer_print(buf, "(clist %s)", buf2); return;
        |                                                  ^~~~
  

• filter/data.c:729:47: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    729 |   case T_ECLIST: ec_set_format(v->val.ad, -1, buf2, 1000); buffer_print(buf, "(eclist %s)", buf2); return;
        |                                               ^~~~
  

• filter/data.c:730:47: warning: passing 'char[1024]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    730 |   case T_LCLIST: lc_set_format(v->val.ad, -1, buf2, 1000); buffer_print(buf, "(lclist %s)", buf2); return;
        |                                               ^~~~
  

• filter/data.c:743:24: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    743 |   return lp_strdup(lp, b.start);
        |                        ^~~~~~~
  

• filter/data.c:751:14: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[1024]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    751 |     .start = val_dump_buffer,
        |              ^~~~~~~~~~~~~~~
  

• filter/data.c:752:12: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    752 |     .end = val_dump_buffer + 1024,
        |            ^~~~~~~~~~~~~~~~~~~~~~
  

• filter/f-util.c:137:9: warning: initializing 'char *' with an expression of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    137 |   char *types = tbuf.start + 3;
        |         ^       ~~~~~~~~~~~~~~
  

• filter/f-util.c:148:52: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    148 |   struct symbol *sym = cf_find_symbol_scope(scope, name);
        |                                                    ^~~~
  

• filter/f-util.c:169:59: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    169 |   struct symbol *ms = scope ? cf_find_symbol_scope(scope, "!for_next") : NULL;
        |                                                           ^~~~~~~~~~~
  

• filter/f-util.c:200:59: warning: passing 'char[5]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    200 |   struct symbol *ms = scope ? cf_find_symbol_scope(scope, "last") : NULL;
        |                                                           ^~~~~~
  

• filter/f-inst.c:284:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    284 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:285:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    285 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:289:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    289 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:290:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    290 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:294:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    294 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:295:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    295 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:299:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    299 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:300:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    300 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:305:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    305 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:306:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    306 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:310:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    310 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:311:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    311 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:315:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    315 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:325:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    325 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:336:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    336 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:337:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    337 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:346:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    346 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:347:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    347 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:386:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    386 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:387:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    387 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:388:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    388 | } while (child3 = child3->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:443:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    443 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:444:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    444 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:450:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    450 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:451:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    451 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:457:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    457 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:458:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    458 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:468:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    468 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:469:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    469 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:479:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    479 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:484:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    484 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:485:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    485 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:493:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    493 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:494:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    494 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:502:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    502 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:506:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    506 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:507:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    507 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:512:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    512 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:536:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    536 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:563:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    563 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:564:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    564 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:565:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    565 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:566:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    566 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:593:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    593 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:602:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    602 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:611:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    611 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:620:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    620 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:629:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    629 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:641:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    641 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:650:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    650 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:691:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    691 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:742:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    742 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:898:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    898 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:936:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    936 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:983:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    983 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:984:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    984 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:996:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    996 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:997:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    997 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:998:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    998 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:999:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    999 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1000:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1000 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1003:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1003 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1039:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1039 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1075:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1075 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1085:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1085 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1112:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1112 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1122:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1122 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1130:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1130 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1142:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1142 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1151:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1151 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1160:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1160 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1172:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1172 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1202:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1202 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1224:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1224 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1227:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1227 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1230:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1230 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1233:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1233 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1236:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1236 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1239:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1239 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1242:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1242 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1245:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1245 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1248:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1248 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1251:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1251 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1254:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1254 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1257:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1257 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1260:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1260 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1263:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1263 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1268:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1268 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1353:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1353 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1357:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1357 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1401:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1401 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1402:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1402 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1410:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1410 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1411:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1411 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1418:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1418 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1419:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1419 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1426:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1426 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1427:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1427 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1434:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1434 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1435:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1435 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1441:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1441 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1442:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1442 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1455:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1455 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1456:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1456 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1462:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1462 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1463:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1463 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1469:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1469 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1470:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1470 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1476:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1476 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1477:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1477 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1483:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1483 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1484:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1484 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1490:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1490 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1491:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1491 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1497:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1497 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1498:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1498 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1504:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1504 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1505:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1505 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1511:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1511 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1512:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1512 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1523:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1523 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1524:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1524 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1530:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1530 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1531:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1531 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1537:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1537 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1538:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1538 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1551:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1551 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1552:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1552 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1558:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1558 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1559:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1559 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1565:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1565 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1566:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1566 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1576:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1576 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1577:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1577 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1583:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1583 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1584:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1584 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1590:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1590 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1591:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1591 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1601:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1601 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1602:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1602 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1608:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1608 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1609:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1609 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1615:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1615 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1616:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1616 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1626:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1626 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1627:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1627 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1637:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1637 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1638:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1638 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1644:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1644 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1645:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1645 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1655:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1655 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1656:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1656 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1662:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1662 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1663:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1663 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1673:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1673 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1674:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1674 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1680:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1680 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1681:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1681 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1692:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1692 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1693:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1693 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1714:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1714 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1715:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1715 | } while (child2 = child2->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1729:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1729 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1744:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1744 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:1750:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1750 | } while (child1 = child1->next);
        |          ~~~~~~~^~~~~~~~~~~~~~
  

• filter/f-inst.c:507:28: warning: passing 'char[5]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    507 |   f_register_method(T_NET, "type", method);
        |                            ^~~~~~
  

• filter/f-inst.c:510:27: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    510 |   f_register_method(T_IP, "is_v4", method);
        |                           ^~~~~~~
  

• filter/f-inst.c:564:29: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    564 |   f_register_method(T_PATH, "empty", method);
        |                             ^~~~~~~
  

• filter/f-inst.c:565:30: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    565 |   f_register_method(T_CLIST, "empty", method);
        |                              ^~~~~~~
  

• filter/f-inst.c:566:31: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    566 |   f_register_method(T_ECLIST, "empty", method);
        |                               ^~~~~~~
  

• filter/f-inst.c:569:31: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    569 |   f_register_method(T_LCLIST, "empty", method);
        |                               ^~~~~~~
  

• filter/f-inst.c:600:29: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    600 |   f_register_method(T_PATH, "!for_next", method);
        |                             ^~~~~~~~~~~
  

• filter/f-inst.c:609:30: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    609 |   f_register_method(T_CLIST, "!for_next", method);
        |                              ^~~~~~~~~~~
  

• filter/f-inst.c:618:31: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    618 |   f_register_method(T_ECLIST, "!for_next", method);
        |                               ^~~~~~~~~~~
  

• filter/f-inst.c:627:31: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    627 |   f_register_method(T_LCLIST, "!for_next", method);
        |                               ^~~~~~~~~~~
  

• filter/f-inst.c:640:37: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    640 |   f_register_method(T_ROUTES_BLOCK, "!for_next", method);
        |                                     ^~~~~~~~~~~
  

• filter/f-inst.c:997:28: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    997 |   f_register_method(T_NET, "len", method);
        |                            ^~~~~
  

• filter/f-inst.c:998:29: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    998 |   f_register_method(T_PATH, "len", method);
        |                             ^~~~~
  

• filter/f-inst.c:999:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    999 |   f_register_method(T_CLIST, "len", method);
        |                              ^~~~~
  

• filter/f-inst.c:1000:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1000 |   f_register_method(T_ECLIST, "len", method);
        |                               ^~~~~
  

• filter/f-inst.c:1002:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1002 |   f_register_method(T_LCLIST, "len", method);
        |                               ^~~~~
  

• filter/f-inst.c:1038:28: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1038 |   f_register_method(T_NET, "src", method);
        |                            ^~~~~
  

• filter/f-inst.c:1075:28: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1075 |   f_register_method(T_NET, "dst", method);
        |                            ^~~~~
  

• filter/f-inst.c:1085:28: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1085 |   f_register_method(T_NET, "maxlen", method);
        |                            ^~~~~~~~
  

• filter/f-inst.c:1112:28: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1112 |   f_register_method(T_NET, "asn", method);
        |                            ^~~~~
  

• filter/f-inst.c:1122:28: warning: passing 'char[3]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1122 |   f_register_method(T_NET, "ip", method);
        |                            ^~~~
  

• filter/f-inst.c:1130:28: warning: passing 'char[3]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1130 |   f_register_method(T_NET, "rd", method);
        |                            ^~~~
  

• filter/f-inst.c:1142:28: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1142 |   f_register_method(T_NET, "mac", method);
        |                            ^~~~~
  

• filter/f-inst.c:1151:28: warning: passing 'char[8]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1151 |   f_register_method(T_NET, "vlan_id", method);
        |                            ^~~~~~~~~
  

• filter/f-inst.c:1160:28: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1160 |   f_register_method(T_NET, "evpn_type", method);
        |                            ^~~~~~~~~~~
  

• filter/f-inst.c:1172:28: warning: passing 'char[9]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1172 |   f_register_method(T_NET, "evpn_tag", method);
        |                            ^~~~~~~~~~
  

• filter/f-inst.c:1202:28: warning: passing 'char[9]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1202 |   f_register_method(T_NET, "evpn_esi", method);
        |                            ^~~~~~~~~~
  

• filter/f-inst.c:1224:28: warning: passing 'char[10]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1224 |   f_register_method(T_NET, "router_ip", method);
        |                            ^~~~~~~~~~~
  

• filter/f-inst.c:1227:29: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1227 |   f_register_method(T_PATH, "first", method);
        |                             ^~~~~~~
  

• filter/f-inst.c:1230:29: warning: passing 'char[5]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1230 |   f_register_method(T_PATH, "last", method);
        |                             ^~~~~~
  

• filter/f-inst.c:1233:29: warning: passing 'char[19]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1233 |   f_register_method(T_PATH, "last_nonaggregated", method);
        |                             ^~~~~~~~~~~~~~~~~~~~
  

• filter/f-inst.c:1236:29: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1236 |   f_register_method(T_PAIR, "asn", method);
        |                             ^~~~~
  

• filter/f-inst.c:1239:29: warning: passing 'char[5]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1239 |   f_register_method(T_PAIR, "data", method);
        |                             ^~~~~~
  

• filter/f-inst.c:1242:27: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1242 |   f_register_method(T_LC, "asn", method);
        |                           ^~~~~
  

• filter/f-inst.c:1245:27: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1245 |   f_register_method(T_LC, "data1", method);
        |                           ^~~~~~~
  

• filter/f-inst.c:1248:27: warning: passing 'char[6]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1248 |   f_register_method(T_LC, "data2", method);
        |                           ^~~~~~~
  

• filter/f-inst.c:1251:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1251 |   f_register_method(T_CLIST, "min", method);
        |                              ^~~~~
  

• filter/f-inst.c:1254:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1254 |   f_register_method(T_CLIST, "max", method);
        |                              ^~~~~
  

• filter/f-inst.c:1257:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1257 |   f_register_method(T_ECLIST, "min", method);
        |                               ^~~~~
  

• filter/f-inst.c:1260:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1260 |   f_register_method(T_ECLIST, "max", method);
        |                               ^~~~~
  

• filter/f-inst.c:1263:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1263 |   f_register_method(T_LCLIST, "min", method);
        |                               ^~~~~
  

• filter/f-inst.c:1265:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1265 |   f_register_method(T_LCLIST, "max", method);
        |                               ^~~~~
  

• filter/f-inst.c:1409:27: warning: passing 'char[5]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1409 |   f_register_method(T_IP, "mask", method);
        |                           ^~~~~~
  

• filter/f-inst.c:1417:29: warning: passing 'char[8]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1417 |   f_register_method(T_PATH, "prepend", method);
        |                             ^~~~~~~~~
  

• filter/f-inst.c:1425:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1425 |   f_register_method(T_STRING, "append", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1433:35: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1433 |   f_register_method(T_BYTESTRING, "append", method);
        |                                   ^~~~~~~~
  

• filter/f-inst.c:1440:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1440 |   f_register_method(T_CLIST, "add", method);
        |                              ^~~~~
  

• filter/f-inst.c:1454:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1454 |   f_register_method(T_CLIST, "add", method);
        |                              ^~~~~
  

• filter/f-inst.c:1461:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1461 |   f_register_method(T_CLIST, "add", method);
        |                              ^~~~~
  

• filter/f-inst.c:1468:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1468 |   f_register_method(T_CLIST, "add", method);
        |                              ^~~~~
  

• filter/f-inst.c:1475:30: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1475 |   f_register_method(T_CLIST, "add", method);
        |                              ^~~~~
  

• filter/f-inst.c:1482:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1482 |   f_register_method(T_ECLIST, "add", method);
        |                               ^~~~~
  

• filter/f-inst.c:1489:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1489 |   f_register_method(T_ECLIST, "add", method);
        |                               ^~~~~
  

• filter/f-inst.c:1496:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1496 |   f_register_method(T_LCLIST, "add", method);
        |                               ^~~~~
  

• filter/f-inst.c:1503:31: warning: passing 'char[4]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1503 |   f_register_method(T_LCLIST, "add", method);
        |                               ^~~~~
  

• filter/f-inst.c:1510:29: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1510 |   f_register_method(T_PATH, "delete", method);
        |                             ^~~~~~~~
  

• filter/f-inst.c:1522:29: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1522 |   f_register_method(T_PATH, "delete", method);
        |                             ^~~~~~~~
  

• filter/f-inst.c:1529:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1529 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1536:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1536 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1550:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1550 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1557:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1557 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1564:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1564 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1575:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1575 |   f_register_method(T_CLIST, "delete", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1582:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1582 |   f_register_method(T_ECLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1589:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1589 |   f_register_method(T_ECLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1600:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1600 |   f_register_method(T_ECLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1607:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1607 |   f_register_method(T_LCLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1614:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1614 |   f_register_method(T_LCLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1625:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1625 |   f_register_method(T_LCLIST, "delete", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1636:29: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1636 |   f_register_method(T_PATH, "filter", method);
        |                             ^~~~~~~~
  

• filter/f-inst.c:1643:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1643 |   f_register_method(T_CLIST, "filter", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1654:30: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1654 |   f_register_method(T_CLIST, "filter", method);
        |                              ^~~~~~~~
  

• filter/f-inst.c:1661:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1661 |   f_register_method(T_ECLIST, "filter", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1672:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1672 |   f_register_method(T_ECLIST, "filter", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1679:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1679 |   f_register_method(T_LCLIST, "filter", method);
        |                               ^~~~~~~~
  

• filter/f-inst.c:1690:31: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1690 |   f_register_method(T_LCLIST, "filter", method);
        |                               ^~~~~~~~
  

• lib/a-path.c:418:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    418 |     strcpy(b->end - 12, "...");
        |            ^~~~~~~~~~~
  

• lib/a-path.c:777:18: warning: assigning to 'const char *' from 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    777 |       pp->val.sp = pos - 1;
        |                  ^ ~~~~~~~
  

• lib/a-path.c:811:13: warning: initializing 'const u8 *' (aka 'const unsigned char *') with an expression of type 'const char *const' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    811 |   const u8 *p = pos->val.sp;
        |             ^   ~~~~~~~~~~~
  

• lib/a-path.c:837:13: warning: initializing 'const u8 *' (aka 'const unsigned char *') with an expression of type 'const char *const' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    837 |   const u8 *p = pos->val.sp;
        |             ^   ~~~~~~~~~~~
  

• lib/a-set.c:50:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     50 |             strcpy(buf, " ...");
        |                    ^~~
  

• lib/a-set.c:62:20: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     62 |           buf += bsprintf(buf, "(%d,%d)", z[i] >> 16, z[i] & 0xffff);
        |                           ^~~
  

• lib/a-set.c:65:20: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     65 |           buf += bsprintf(buf, "%R", z[i]);
        |                           ^~~
  

• lib/a-set.c:68:20: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     68 |           buf += bsprintf(buf, "%u", z[i]);
        |                           ^~~
  

• lib/a-set.c:98:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     98 |       return bsprintf(buf, "(%s, %u, %u)", kind, key, val);
        |                       ^~~
  

• lib/a-set.c:105:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    105 |       return bsprintf(buf, "(%s, %R, %u)", kind, key, val);
        |                       ^~~
  

• lib/a-set.c:112:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    112 |       return bsprintf(buf, "(%s, %u, %u)", kind, key, val);
        |                       ^~~
  

• lib/a-set.c:118:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    118 |       return bsprintf(buf, "(generic, 0x%x, 0x%x)", key, val);
        |                       ^~~
  

• lib/a-set.c:137:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    137 |             strcpy(buf, " ...");
        |                    ^~~
  

• lib/a-set.c:155:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    155 |   return bsprintf(buf, "(%u, %u, %u)", lc.asn, lc.ldp1, lc.ldp2);
        |                   ^~~
  

• lib/a-set.c:172:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    172 |             strcpy(buf, "...");
        |                    ^~~
  

• lib/a-set.c:178:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    178 |       buf += bsprintf(buf, "(%u, %u, %u)", d[i], d[i+1], d[i+2]);
        |                       ^~~
  

• lib/event.c:247:5: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    247 |     else
        |     ^
  

• lib/event.c:316:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    316 |   while (e = atomic_load_explicit(ep, memory_order_acquire))
        |          ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• lib/flowspec.c:779:22: warning: address of array 'f->data' will always evaluate to 'true' [-Wpointer-bool-conversion]
    779 |   ASSERT_DIE(f && f->data);
        |                ~~ ~~~^~~~
  

• lib/flowspec.c:796:22: warning: address of array 'f->data' will always evaluate to 'true' [-Wpointer-bool-conversion]
    796 |   ASSERT_DIE(f && f->data);
        |                ~~ ~~~^~~~
  

• lib/flowspec.c:1494:14: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1494 |     .start = buf,
        |              ^~~
  

• lib/flowspec.c:1495:12: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1495 |     .pos = buf,
        |            ^~~
  

• lib/flowspec.c:1496:12: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1496 |     .end = buf + blen,
        |            ^~~~~~~~~~
  

• lib/flowspec.c:1541:44: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1541 |     b.pos = b.start + MIN(blen - 6, strlen(b.start));
        |                                            ^~~~~~~
  

• lib/mempool.c:257:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    257 |   while (c = m->current->next)
        |          ~~^~~~~~~~~~~~~~~~~~
  

• ./sysdep/unix/io-loop.h:90:35: warning: redefinition of typedef 'thread_group' is a C11 feature [-Wtypedef-redefinition]
     90 | typedef union thread_group_public thread_group;
        |                                   ^
  

• lib/mslab.c:563:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    563 |   if (h = atomic_load_explicit(&ti->head, memory_order_acquire))
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• ./lib/netindex_private.h:38:3: warning: redefinition of typedef 'netindex_hash' is a C11 feature [-Wtypedef-redefinition]
     38 | } netindex_hash;
        |   ^
  

• lib/netindex.c:31:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     31 |   if (step > 0) SPINHASH_REHASH_UP(v,NETINDEX,struct netindex,step);
        |                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• lib/netindex.c:32:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     32 |   if (step < 0) SPINHASH_REHASH_DOWN(v,NETINDEX,struct netindex,-step);
        |                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• lib/rcu.c:41:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     41 |       t = atomic_load_explicit(tp, memory_order_acquire);
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• lib/rcu.c:95:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     95 |       t = atomic_load_explicit(tp, memory_order_acquire);
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• lib/slab.c:203:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    203 |   if (h = s->empty_heads.first)
        |       ~~^~~~~~~~~~~~~~~~~~~~~~
  

• lib/slists.c:76:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
     76 |   if (f = n->readers)
        |       ~~^~~~~~~~~~~~
  

• lib/timer.c:170:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    170 |   while (t = timers_first(loop))
        |          ~~^~~~~~~~~~~~~~~~~~~~
  

• lib/timer.c:324:17: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    324 |   if (!strfusec(tbuf, tbuf_size, fmt, t2))
        |                 ^~~~
  

• lib/timer.c:327:27: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    327 |   return strftime(x, max, tbuf, &tm);
        |                           ^~~~
  

• nest/cli.c:132:18: warning: passing 'byte[512]' (aka 'unsigned char[512]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    132 |         size = bsprintf(buf, " ");
        |                         ^~~
  

• nest/cli.c:134:18: warning: passing 'byte[512]' (aka 'unsigned char[512]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    134 |         size = bsprintf(buf, "%04d-", cd);
        |                         ^~~
  

• nest/cli.c:144:23: warning: passing 'byte[512]' (aka 'unsigned char[512]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    144 |       size = bsprintf(buf, "%04d ", cd);
        |                       ^~~
  

• nest/cli.c:150:20: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    150 |   cnt = bvsnprintf(buf+size, sizeof(buf)-size-1, msg, args);
        |                    ^~~~~~~~
  

• nest/cli.c:263:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    263 |   cli_rh_len = strlen(c->rx_buf);
        |                       ^~~~~~~~~
  

• nest/cmds.c:31:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     31 |   tm_format_time(tim, tf, current_time());
        |                  ^~~
  

• nest/cmds.c:35:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     35 |   tm_format_time(tim, tf, boot_time);
        |                  ^~~
  

• nest/cmds.c:37:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     37 |   tm_format_time(tim, tf, gr->load_time);
        |                  ^~~
  

• nest/iface.c:563:4: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    563 |           WALK_LIST_DELSAFE(a, b, i->addrs)
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/iface.c:1068:19: warning: initializing 'const char *' with an expression of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1068 |       const char *t = p->pattern;
        |                   ^   ~~~~~~~~~~
  

• nest/iface.c:1079:18: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1079 |           if (!patmatch(t, i->name))
        |                         ^
  

• nest/iface.c:1079:21: warning: passing 'char[16]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1079 |           if (!patmatch(t, i->name))
        |                            ^~~~~~~
  

• nest/iface.c:1126:42: warning: passing 'const byte *' (aka 'const unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1126 |           ((x->pattern != y->pattern) && strcmp(x->pattern, y->pattern)) ||
        |                                                 ^~~~~~~~~~
  

• nest/iface.c:1126:54: warning: passing 'const byte *' (aka 'const unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1126 |           ((x->pattern != y->pattern) && strcmp(x->pattern, y->pattern)) ||
        |                                                             ^~~~~~~~~~
  

• nest/iface.c:1162:7: warning: assigning to 'byte *' (aka 'unsigned char *') from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1162 |   flg = (a->flags & IA_PRIMARY) ? "Preferred, " : (a->flags & IA_SECONDARY) ? "Secondary, " : "";
        |       ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/iface.c:1165:14: warning: passing 'byte[55]' (aka 'unsigned char[55]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1165 |     bsprintf(opp, "opposite %I, ", a->opposite);
        |              ^~~
  

• nest/iface.c:1229:11: warning: passing 'byte[56]' (aka 'unsigned char[56]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1229 |         bsprintf(a4, "%I/%d", i->addr4->ip, i->addr4->prefix.pxlen);
        |                  ^~
  

• nest/iface.c:1234:11: warning: passing 'byte[56]' (aka 'unsigned char[56]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1234 |         bsprintf(a6, "%I/%d", i->addr6->ip, i->addr6->prefix.pxlen);
        |                  ^~
  

• nest/mpls.c:290:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    290 |   WALK_LIST_DELSAFE(r, r2, old_ranges)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:326:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    326 |   WALK_LIST_DELSAFE(r, rnext, m->ranges)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:379:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    379 |   WALK_LIST_DELSAFE(m, m2, old_domains)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:485:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    485 |   WALK_LIST_BACKWARDS_DELSAFE(r, rnext, m->ranges)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:1153:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1153 |     HASH_REMOVE2(m->net_hash, NET, m->pool, fec);
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:1158:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1158 |     HASH_REMOVE2(m->attrs_hash, RTA, m->pool, fec);
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/mpls.c:1190:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1190 |   HASH_REMOVE2(m->label_hash, LABEL, m->pool, fec);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:591:35: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    591 |   for (struct lfjour_item *it; it = lfjour_get(&s->digest_recipient); )
        |                                ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:618:5: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    618 |     else
        |     ^
  

• nest/proto.c:638:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    638 |       it = lfjour_get(&s->digest_recipient);
        |       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:1029:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1029 |   RT_FEED_WALK(&c->reimporter, f)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:1285:5: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   1285 |     else
        |     ^
  

• nest/proto.c:1944:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1944 |       if (oc->parent && !cf_find_symbol(new, oc->name) && !new->shutdown)
        |                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:1946:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1946 |         struct symbol *parsym = cf_find_symbol(new, oc->parent->name);
        |                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:1953:44: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1953 |           struct symbol *sym = cf_get_symbol(new, oc->name);
        |                                                   ^~~~~~~~
  

• nest/proto.c:1993:13: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1993 |       sym = cf_find_symbol(new, oc->name);
        |             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/proto.c:3031:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3031 |   tm_format_time(tbuf, tf, p->last_state_change);
        |                  ^~~~
  

• nest/proto.c:3046:20: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3046 |     tm_format_time(tbuf, tf, p->last_reconfiguration);
        |                    ^~~~
  

• nest/proto.c:3050:22: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3050 |       tm_format_time(tbuf, tf, p->last_restart);
        |                      ^~~~
  

• nest/proto.c:3266:27: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3266 |     if (!patt || patmatch(patt, p->name))
        |                           ^~~~
  

• nest/proto.c:3266:33: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3266 |     if (!patt || patmatch(patt, p->name))
        |                                 ^~~~~~~
  

• nest/rt-attr.c:114:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    114 |     bsnprintf(buf, size, "unknown");
        |               ^~~
  

• nest/rt-attr.c:116:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    116 |     bsnprintf(buf, size, "%s", rta_src_names[a->u.data]);
        |               ^~~
  

• nest/rt-attr.c:372:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    372 |   HASH_WALK_FILTER(o->hash, next, src, sp)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-attr.c:1314:9: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1314 |         strcpy(buf, " ...");
        |                ^~~
  

• nest/rt-attr.c:1318:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1318 |       buf += bsprintf(buf, "%s ", names[i]);
        |                       ^~~
  

• nest/rt-attr.c:1323:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1323 |     bsprintf(buf, "%08x ", data);
        |              ^~~
  

• nest/rt-attr.c:1342:11: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1342 |           strcpy(buf, " ...");
        |                  ^~~
  

• nest/rt-attr.c:1348:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1348 |       buf += bsprintf(buf, "%02x", ad->data[i]);
        |                       ^~~
  

• nest/rt-attr.c:1437:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1437 |     s = bsnprintf(buf, size, "via %I %I table %s", had->he->addr, had->he->link, had->he->owner->name);
        |                   ^~~
  

• nest/rt-attr.c:1439:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1439 |     s = bsnprintf(buf, size, "via %I table %s", had->he->addr, had->he->owner->name);
        |                   ^~~
  

• nest/rt-attr.c:1445:17: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1445 |   s = bsnprintf((buf += s), (size -= s), " mpls");
        |                 ^~~~~~~~~~
  

• nest/rt-attr.c:1447:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1447 |     s = bsnprintf((buf += s), (size -= s), " %u", had->labels[i]);
        |                   ^~~~~~~~~~
  

• nest/rt-attr.c:1489:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1489 |             bsprintf(pos, "unknown");
        |                      ^~~
  

• nest/rt-attr.c:1491:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1491 |             bsprintf(pos, "%u", e->u.data);
        |                      ^~~
  

• nest/rt-attr.c:1497:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1497 |           bsprintf(pos, "%I", *(ip_addr *) ad->data);
        |                    ^~~
  

• nest/rt-attr.c:1500:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1500 |           bsprintf(pos, "%R", e->u.data);
        |                    ^~~
  

• nest/rt-attr.c:1515:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1515 |           bsnprintf(pos, end - pos, "%s", (const char *) ad->data);
        |                     ^~~
  

• nest/rt-attr.c:1524:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1524 |           bsprintf(pos, "<type %02x>", e->type);
        |                    ^~~
  

• nest/rt-attr.c:1614:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1614 |       if (e = e->next)
        |           ~~^~~~~~~~~
  

• nest/rt-attr.c:2027:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   2027 |       else
        |       ^
  

• nest/rt-export.c:103:21: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    103 |       else if (feed = rt_export_next_feed(&r->feeder, &r->seq_map))
        |                ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-fib.c:190:16: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    190 |       while (e = x)
        |              ~~^~~
  

• nest/rt-fib.c:471:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    471 |           if (it = e->readers)
        |               ~~~^~~~~~~~~~~~
  

• nest/rt-fib.c:521:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    521 |     if (n = f->hash_table[h])
        |         ~~^~~~~~~~~~~~~~~~~~
  

• nest/rt-fib.c:524:14: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    524 |         if (i->next = n->readers)
        |             ~~~~~~~~^~~~~~~~~~~~
  

• nest/rt-fib.c:556:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    556 |   if (k = i->next)
        |       ~~^~~~~~~~~
  

• nest/rt-fib.c:569:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    569 |   if (j = n->readers)
        |       ~~^~~~~~~~~~~~
  

• nest/rt-fib.c:579:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    579 |   if (n = n->next)
        |       ~~^~~~~~~~~
  

• nest/rt-fib.c:583:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    583 |     if (n = f->hash_table[hpos])
        |         ~~^~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-show.c:55:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     55 |   tm_format_time(tm, c->tf ?: &d->tf_route, e->lastmod);
        |                  ^~
  

• nest/rt-show.c:58:14: warning: passing 'byte[47]' (aka 'unsigned char[47]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     58 |     bsprintf(from, " from %I", a_from);
        |              ^~~~
  

• nest/rt-show.c:70:14: warning: passing 'byte[256]' (aka 'unsigned char[256]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
     70 |     bsprintf(info, " (%d)", rt_get_preference(e));
        |              ^~~~
  

• nest/rt-show.c:105:33: warning: passing 'char[256]' to parameter of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    105 |     ea_show_hostentry(&had->ad, hetext, sizeof hetext);
        |                                 ^~~~~~
  

• nest/rt-show.c:145:2: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    145 |         else
        |         ^
  

• nest/rt-show.c:213:33: warning: passing 'byte[273]' (aka 'unsigned char[273]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    213 |             net_format(feed->ni->addr, ia, sizeof(ia));
        |                                        ^~
  

• nest/rt-show.c:215:16: warning: passing 'byte[273]' (aka 'unsigned char[273]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    215 |             bsnprintf(ia, sizeof(ia), "%N mpls %d", feed->ni->addr, label);
        |                       ^~
  

• nest/rt-show.c:248:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    248 |   WALK_LIST_DELSAFE(tab, tabx, d->tables)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-show.c:302:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    302 |       RT_FEED_WALK(&d->tab->req, f)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-show.c:315:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    315 |     RT_FEED_WALK(&d->tab->req, f)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-show.c:439:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    439 |   WALK_LIST_DELSAFE(tab, tabx, d->tables)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:381:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    381 |       case NET_IP4:   TW(4, FVR_IP);
        |                       ~~~~~~^~~~~~~
  

• nest/rt-table.c:382:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    382 |       case NET_VPN4:  TW(4, FVR_VPN);
        |                       ~~~~~~^~~~~~~~
  

• nest/rt-table.c:383:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    383 |       case NET_IP6:   TW(6, FVR_IP);
        |                       ~~~~~~^~~~~~~
  

• nest/rt-table.c:384:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    384 |       case NET_VPN6:  TW(6, FVR_VPN);
        |                       ~~~~~~^~~~~~~~
  

• nest/rt-table.c:393:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    393 |       case NET_IP4:   FW(4, FVR_IP);
        |                       ~~~~~~^~~~~~~
  

• nest/rt-table.c:394:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    394 |       case NET_VPN4:  FW(4, FVR_VPN);
        |                       ~~~~~~^~~~~~~~
  

• nest/rt-table.c:395:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    395 |       case NET_IP6:   FW(6, FVR_IP);
        |                       ~~~~~~^~~~~~~
  

• nest/rt-table.c:396:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    396 |       case NET_VPN6:  FW(6, FVR_VPN);
        |                       ~~~~~~^~~~~~~~
  

• nest/rt-table.c:460:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    460 |     int x = bsnprintf(buf, size, "as %u max %u, ", rad->u[upos].asn, rad->u[upos].max_pxlen);
        |                       ^~~
  

• nest/rt-table.c:465:17: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    465 |       bsnprintf(buf, size, " ... ");
        |                 ^~~
  

• nest/rt-table.c:493:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    493 |   RT_EXPORT_WALK(&rag->src, u) TMP_SAVED
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:567:2: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    567 |         else if (rad->u[p].max_pxlen == max_pxlen)
        |         ^
  

• nest/rt-table.c:963:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    963 |     if (n) NET_READ_WALK_ROUTES(tr, n, ep, e)
        |            ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1147:14: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1147 |   if (better = new->src->owner->class->rte_better)
        |       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1166:16: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1166 |   if (mergable = pri->src->owner->class->rte_mergable)
        |       ~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1219:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1219 |   NET_READ_WALK_ROUTES(tr, n, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1247:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1247 |   NET_READ_WALK_ROUTES(tr, n, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1478:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1478 |   RT_EXPORT_WALK(req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1541:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1541 |               rpe = atomic_load_explicit(&rpe->next, memory_order_acquire) ;)
        |               ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1602:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1602 |   RT_EXPORT_WALK(req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1698:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1698 |               rpe = atomic_load_explicit(&rpe->next, memory_order_acquire) ;)
        |               ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1857:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1857 |   RT_EXPORT_WALK(&c->out_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:1998:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1998 |   RT_EXPORT_WALK(&c->out_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2029:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2029 |   RT_EXPORT_WALK(&tab->best_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2355:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2355 |   NET_WALK_ROUTES(table, net, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2361:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   2361 |       else
        |       ^
  

• nest/rt-table.c:2465:14: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2465 |           for (; kk = atomic_load_explicit(k, memory_order_relaxed); k = &kk->next)
        |                  ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2542:6: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2542 |                 kk = atomic_load_explicit(k, memory_order_relaxed);
        |                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2596:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2596 |     NET_WALK_ROUTES(table, net, ep, e)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:2661:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   2661 |       else
        |       ^
  

• nest/rt-table.c:3221:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3221 |       NET_WALK_ROUTES(tab, &routes[i], ep, e)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:3318:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3318 |     NET_READ_WALK_ROUTES(tp, &routes[i], ep, e)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:3503:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3503 |   RT_EXPORT_WALK(&ln->req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:3523:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3523 |               rpe = atomic_load_explicit(&rpe->next, memory_order_acquire) ;)
        |               ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:3722:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3722 |   RT_EXPORT_WALK(&d->req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:3919:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3919 |   RT_EXPORT_WALK(&t->best_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:4004:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   4004 |   NET_WALK_ROUTES(tab, n, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:4290:50: warning: passing 'char[8]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   4290 |   c->def_tables[NET_IP4] = cf_implicit_symbol(c, "master4", SYM_TABLE, table, NULL);
        |                                                  ^~~~~~~~~
  

• nest/rt-table.c:4291:50: warning: passing 'char[8]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   4291 |   c->def_tables[NET_IP6] = cf_implicit_symbol(c, "master6", SYM_TABLE, table, NULL);
        |                                                  ^~~~~~~~~
  

• nest/rt-table.c:4707:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   4707 |   NET_WALK_ROUTES(tab, n, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:4719:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   4719 |   NET_WALK_ROUTES(tab, n, ep, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5001:51: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   5001 |   struct symbol *saux = cf_get_symbol(new_config, auxname);
        |                                                   ^~~~~~~
  

• nest/rt-table.c:5268:24: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   5268 |   struct symbol *sym = cf_find_symbol(cf, name);
        |                        ^~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5460:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   5460 |   RT_EXPORT_WALK(&hc->req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5481:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   5481 |               rpe = atomic_load_explicit(&rpe->next, memory_order_acquire) ;)
        |               ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5630:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   5630 |       NET_WALK_ROUTES(tab, n, ep, ee)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5670:2: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   5670 |         else
        |         ^
  

• nest/rt-table.c:5678:5: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   5678 |     else
        |     ^
  

• nest/rt-table.c:5754:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   5754 |   WALK_LIST_DELSAFE(n, x, hc->hostentries)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• nest/rt-table.c:5803:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   5803 |       else
        |       ^
  

• proto/static/static.c:809:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    809 |     buf += bsprintf(buf, " (%d/%u)", pref, a->u.data);
        |                     ^~~
  

• proto/static/static.c:811:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    811 |     buf += bsprintf(buf, " (%d)", pref);
        |                     ^~~
  

• proto/babel/babel.c:140:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    140 |   WALK_LIST_DELSAFE(n, nx, e->sources)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:247:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    247 |     WALK_LIST_DELSAFE(r, rx, e->routes)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:416:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    416 |   WALK_LIST_DELSAFE(sr, srx, e->requests)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:538:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    538 |     WALK_LIST_DELSAFE(nbr, nbx, ifa->neigh_list)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:1011:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1011 |   FIB_WALK(rtable, struct babel_entry, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2188:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2188 |   FIB_WALK(&p->ip4_rtable, struct babel_entry, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2193:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2193 |   FIB_WALK(&p->ip6_rtable, struct babel_entry, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2208:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2208 |   buf += bsprintf(buf, " (%d/%d) [%lR]",
        |                   ^~~
  

• proto/babel/babel.c:2218:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2218 |   bsnprintf(buf, len, "%lR", rid);
        |             ^~~
  

• proto/babel/babel.c:2264:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2264 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                          ^~~
  

• proto/babel/babel.c:2264:31: warning: passing 'char[16]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2264 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                               ^~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2301:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2301 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                          ^~~
  

• proto/babel/babel.c:2301:31: warning: passing 'char[16]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   2301 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                               ^~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2325:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2325 |   FIB_WALK(rtable, struct babel_entry, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/babel.c:2340:16: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2340 |     else if (r = e->selected)
        |              ~~^~~~~~~~~~~~~
  

• proto/babel/babel.c:2375:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2375 |   FIB_WALK(rtable, struct babel_entry, e)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/babel/packets.c:1933:29: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1933 |   mac_init(&ctx, pass->alg, pass->password, pass->length);
        |                             ^~~~~~~~~~~~~~
  

• proto/bfd/bfd.c:571:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    571 |   HASH_REMOVE(p->session_hash_id, HASH_ID, s);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bfd/bfd.c:572:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    572 |   HASH_REMOVE(p->session_hash_ip, HASH_IP, s);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bfd/bfd.c:799:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    799 |       req = bfd_pick_request(p);
        |       ~~~~^~~~~~~~~~~~~~~~~~~~~
  

• proto/bfd/bfd.c:1249:18: warning: passing 'byte[32]' (aka 'unsigned char[32]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1249 |   tm_format_time(tbuf, this_cli->tf ?: &gr->tf_proto,
        |                  ^~~~
  

• proto/bfd/bfd.c:1267:80: warning: passing 'byte[16]' (aka 'unsigned char[16]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1267 |   cli_msg(-1020, "  %-21s %s", "Local diagnostic:", bfd_diag_name(sp.loc.diag, dbuf));
        |                                                                                ^~~~
  

• proto/bfd/bfd.c:1268:81: warning: passing 'byte[16]' (aka 'unsigned char[16]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1268 |   cli_msg(-1020, "  %-21s %s", "Remote diagnostic:", bfd_diag_name(sp.rem.diag, dbuf));
        |                                                                                 ^~~~
  

• proto/bgp/attrs.c:477:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    477 |   bsprintf(buf, (a->u.data <= 2) ? bgp_origin_names[a->u.data] : "?");
        |            ^~~
  

• proto/bgp/attrs.c:596:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    596 |     bsprintf(buf, "%I", nh[0]);
        |              ^~~
  

• proto/bgp/attrs.c:598:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    598 |     bsprintf(buf, "%I %I", nh[0], nh[1]);
        |              ^~~
  

• proto/bgp/attrs.c:682:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    682 |   bsprintf(buf, "%I4 AS%u", get_ip4(data+4), get_u32(data+0));
        |            ^~~
  

• proto/bgp/attrs.c:956:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    956 |     bsnprintf(buf, size, "no-info%s", mpls);
        |               ^~~
  

• proto/bgp/attrs.c:961:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    961 |     bsnprintf(buf, size, "ingress-replication %I%s", a, mpls);
        |               ^~~
  

• proto/bgp/attrs.c:965:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    965 |     int n = bsnprintf(buf, size, "type %u%s ", type, mpls);
        |                       ^~~
  

• proto/bgp/attrs.c:967:48: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    967 |     bstrbintohex(ad->data + 5, ad->length - 5, buf, size, ':');
        |                                                ^~~
  

• proto/bgp/attrs.c:1002:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1002 |     bsprintf(buf, "?");
        |              ^~~
  

• proto/bgp/attrs.c:1004:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1004 |     bsprintf(buf, "%lu", get_u64(b + 3));
        |              ^~~
  

• proto/bgp/attrs.c:1091:9: warning: initializing 'char *' with an expression of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1091 |   char *pos = buf;
        |         ^     ~~~
  

• proto/bgp/attrs.c:1132:15: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1132 |     bsnprintf(buf, size, "(transitive)");
        |               ^~~
  

• proto/bgp/attrs.c:2187:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2187 |   HASH_REMOVE2(c->bucket_hash, RBH, c->pool, b);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:2221:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2221 |   while (px = bgp_bucket_pop_prefix(c, b))
        |          ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:2369:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   2369 |       else
        |       ^
  

• proto/bgp/attrs.c:2393:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2393 |   HASH_REMOVE2(c->prefix_hash, PXH, c->pool, px);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:2646:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2646 |   while (px = bgp_bucket_pop_prefix(c, b))
        |          ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:2652:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2652 |     while (px = bgp_bucket_pop_prefix(c, b))
        |            ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:3350:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3350 |       s = atomic_load_explicit(ptr, memory_order_acquire);
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:3371:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3371 |       s = atomic_load_explicit(ptr, memory_order_acquire);
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:3418:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3418 |   RT_FEED_WALK(&c->stale_feed, f) TMP_SAVED
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:3517:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3517 |   buf += bsprintf(buf, " (%d", rt_get_preference(e));
        |                   ^~~
  

• proto/bgp/attrs.c:3522:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3522 |       buf += bsprintf(buf, "-");
        |                       ^~~
  

• proto/bgp/attrs.c:3525:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3525 |       buf += bsprintf(buf, "s");
        |                       ^~~
  

• proto/bgp/attrs.c:3531:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3531 |       buf += bsprintf(buf, "/%lu", metric);
        |                       ^~~
  

• proto/bgp/attrs.c:3533:17: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3533 |     else if (ic = ea_find(e->attrs, &ea_gen_local_metric))
        |              ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/attrs.c:3536:18: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3536 |         buf += bsprintf(buf, "/-");
        |                         ^~~
  

• proto/bgp/attrs.c:3538:18: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3538 |         buf += bsprintf(buf, "/?");
        |                         ^~~
  

• proto/bgp/attrs.c:3540:18: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3540 |         buf += bsprintf(buf, "/%d", ic->u.i);
        |                         ^~~
  

• proto/bgp/attrs.c:3543:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3543 |   buf += bsprintf(buf, ") [");
        |                   ^~~
  

• proto/bgp/attrs.c:3546:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3546 |     buf += bsprintf(buf, "AS%u", origas);
        |                     ^~~
  

• proto/bgp/attrs.c:3548:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3548 |     buf += bsprintf(buf, "%c", "ie?"[o->u.data]);
        |                     ^~~
  

• proto/bgp/attrs.c:3549:10: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3549 |   strcpy(buf, "]");
        |          ^~~
  

• proto/bgp/bgp.c:847:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    847 |     WALK_LIST_DELSAFE(key, key2, old_keys)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/bgp.c:3347:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3347 |   if (tab = rt_get_default_table(cf->c.global, type))
        |       ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/bgp.c:3550:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   3550 |       else
        |       ^
  

• proto/bgp/bgp.c:3557:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   3557 |       else
        |       ^
  

• proto/bgp/bgp.c:3738:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   3738 |   WALK_LIST_DELSAFE(C, C2, p->p.channels)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/bgp.c:3982:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3982 |     bsprintf(buf, "%s%s", err1, err2);
        |              ^~~
  

• proto/bgp/bgp.c:3984:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3984 |     bsprintf(buf, "%-14s%s%s", bgp_state_dsc(p), err1, err2);
        |              ^~~
  

• proto/bgp/bgp.c:4005:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   4005 |     strcpy(b.end - 32, " ... <too long>");
        |            ^~~~~~~~~~
  

• proto/bgp/bgp.c:4007:17: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   4007 |   cli_msg(code, b.start);
        |                 ^~~~~~~
  

• proto/bgp/packets.c:838:10: warning: returning 'char *' from a function with result type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    838 |   return buf;
        |          ^~~
  

• proto/bgp/packets.c:1331:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1331 |     if (nhloc = bgp_use_gateway(s))
        |         ~~~~~~^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3797:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[23]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3797 |   { 1, 0, "Invalid message header" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3798:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[28]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3798 |   { 1, 1, "Connection not synchronized" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3799:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[19]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3799 |   { 1, 2, "Bad message length" },
        |           ^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3800:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[17]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3800 |   { 1, 3, "Bad message type" },
        |           ^~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3801:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[21]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3801 |   { 2, 0, "Invalid OPEN message" },
        |           ^~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3802:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[27]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3802 |   { 2, 1, "Unsupported version number" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3803:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[12]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3803 |   { 2, 2, "Bad peer AS" },
        |           ^~~~~~~~~~~~~
  

• proto/bgp/packets.c:3804:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[19]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3804 |   { 2, 3, "Bad BGP identifier" },
        |           ^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3805:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[31]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3805 |   { 2, 4, "Unsupported optional parameter" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3806:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[23]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3806 |   { 2, 5, "Authentication failure" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3807:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[23]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3807 |   { 2, 6, "Unacceptable hold time" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3808:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[28]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3808 |   { 2, 7, "Required capability missing" }, /* [RFC5492] */
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3809:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[22]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3809 |   { 2, 8, "No supported AFI/SAFI" }, /* This error msg is nonstandard */
        |           ^~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3810:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[14]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3810 |   { 2,11, "Role mismatch" }, /* From Open Policy, RFC 9234 */
        |           ^~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3811:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[23]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3811 |   { 3, 0, "Invalid UPDATE message" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3812:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[25]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3812 |   { 3, 1, "Malformed attribute list" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3813:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[34]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3813 |   { 3, 2, "Unrecognized well-known attribute" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3814:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[28]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3814 |   { 3, 3, "Missing mandatory attribute" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3815:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[24]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3815 |   { 3, 4, "Invalid attribute flags" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3816:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[25]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3816 |   { 3, 5, "Invalid attribute length" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3817:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[25]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3817 |   { 3, 6, "Invalid ORIGIN attribute" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3818:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[16]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3818 |   { 3, 7, "AS routing loop" },          /* Deprecated */
        |           ^~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3819:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[27]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3819 |   { 3, 8, "Invalid NEXT_HOP attribute" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3820:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[25]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3820 |   { 3, 9, "Optional attribute error" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3821:12: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[22]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3821 |   { 3, 10, "Invalid network field" },
        |            ^~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3822:12: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[18]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3822 |   { 3, 11, "Malformed AS_PATH" },
        |            ^~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3823:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[19]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3823 |   { 4, 0, "Hold timer expired" },
        |           ^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3824:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[27]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3824 |   { 5, 0, "Finite state machine error" }, /* Subcodes are according to [RFC6608] */
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3825:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[37]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3825 |   { 5, 1, "Unexpected message in OpenSent state" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3826:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[40]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3826 |   { 5, 2, "Unexpected message in OpenConfirm state" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3827:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[40]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3827 |   { 5, 3, "Unexpected message in Established state" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3828:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[6]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3828 |   { 6, 0, "Cease" }, /* Subcodes are according to [RFC4486] */
        |           ^~~~~~~
  

• proto/bgp/packets.c:3829:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[35]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3829 |   { 6, 1, "Maximum number of prefixes reached" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3830:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[24]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3830 |   { 6, 2, "Administrative shutdown" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3831:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[19]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3831 |   { 6, 3, "Peer de-configured" },
        |           ^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3832:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[21]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3832 |   { 6, 4, "Administrative reset" },
        |           ^~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3833:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[20]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3833 |   { 6, 5, "Connection rejected" },
        |           ^~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3834:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[27]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3834 |   { 6, 6, "Other configuration change" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3835:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[32]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3835 |   { 6, 7, "Connection collision resolution" },
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3836:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[17]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3836 |   { 6, 8, "Out of Resources" },
        |           ^~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3837:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[30]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3837 |   { 7, 0, "Invalid ROUTE-REFRESH message" }, /* [RFC7313] */
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3838:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[37]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3838 |   { 7, 1, "Invalid ROUTE-REFRESH message length" }, /* [RFC7313] */
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3839:11: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char[24]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3839 |   { 8, 0, "Send hold timer expired" }, /* [RFC9687] */
        |           ^~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3858:14: warning: returning 'byte *' (aka 'unsigned char *') from a function with result type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3858 |       return bgp_msg_table[i].msg;
        |              ^~~~~~~~~~~~~~~~~~~~
  

• proto/bgp/packets.c:3885:28: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3885 |   proto_set_message(&p->p, msg, msg_len);
        |                            ^~~
  

• proto/bgp/packets.c:3886:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3886 |   *bp += bsprintf(*bp, ": \"%s\"", p->p.message);
        |                   ^~~
  

• proto/bgp/packets.c:3909:18: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3909 |           t += bsprintf(t, ": %u", (len == 2) ? get_u16(data) : get_u32(data));
        |                         ^
  

• proto/bgp/packets.c:3915:18: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3915 |           t += bsprintf(t, " (%s)", bgp_format_role_name(get_u8(data)));
        |                         ^
  

• proto/bgp/packets.c:3929:16: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3929 |         t += bsprintf(t, "%02x", data[i]);
        |                       ^
  

• proto/bgp/packets.c:3934:15: warning: initializing 'const byte *' (aka 'const unsigned char *') with an expression of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   3934 |   const byte *dsc = bgp_error_dsc(code, subcode);
        |               ^     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:369:39: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    369 |   for (struct bmp_tx_buffer *btb; btb = p->tx_pending; )
        |                                   ~~~~^~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:581:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    581 |   HASH_REMOVE(p->table_map, HASH_TABLE, bt);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:639:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    639 |   HASH_REMOVE(p->stream_map, HASH_STREAM, bs);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:715:22: warning: assigning to 'const char *' from 'const byte[0]' (aka 'const unsigned char[0]') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    715 |     bsi.channel_name = ea_get_adata(bsi.channel_state, &ea_name)->data;
        |                      ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:753:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    753 |   HASH_REMOVE(p->peer_map, HASH_PEER, bp);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:1073:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1073 |   RT_EXPORT_WALK(&bt->out_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:1210:21: warning: initializing 'const char *' with an expression of type 'const byte[0]' (aka 'const unsigned char[0]') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1210 |       .proto_name = ea_get_adata(pst[i], &ea_name)->data,
        |                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:1404:19: warning: initializing 'const char *' with an expression of type 'const byte[0]' (aka 'const unsigned char[0]') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1404 |     .proto_name = ea_get_adata(ppu->new, &ea_name)->data,
        |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:1439:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1439 |       last_up = lfjour_get(&p->proto_state_reader);
        |       ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/bmp/bmp.c:1552:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1552 |     bsprintf(buf, "Down");
        |              ^~~
  

• proto/bmp/bmp.c:1554:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1554 |     bsprintf(buf, "Flush");
        |              ^~~
  

• proto/bmp/bmp.c:1560:16: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1560 |       bsprintf(buf, "%s", state);
        |                ^~~
  

• proto/bmp/bmp.c:1562:16: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1562 |       bsprintf(buf, "%-14s%s %M", state, "Error:", p->sock_err);
        |                ^~~
  

• proto/mrt/mrt.c:207:25: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    207 |   for (last = src; next = strstr(last, key); last = next + klen)
        |                    ~~~~~^~~~~~~~~~~~~~~~~~~
  

• proto/mrt/mrt.c:557:11: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    557 |         patmatch(pattern, tab->name) &&
        |                  ^~~~~~~
  

• proto/mrt/mrt.c:557:20: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    557 |         patmatch(pattern, tab->name) &&
        |                           ^~~~~~~~~
  

• proto/mrt/mrt.c:566:11: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    566 |         patmatch(pattern, tab->name) &&
        |                  ^~~~~~~
  

• proto/mrt/mrt.c:566:20: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    566 |         patmatch(pattern, tab->name) &&
        |                           ^~~~~~~~~
  

• proto/mrt/mrt.c:655:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    655 |     RT_FEED_WALK(&s->feeder, route_feed)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:267:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    267 |   WALK_LIST_DELSAFE(n, nx, ifa->neigh_list)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:795:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    795 |     WALK_LIST_DELSAFE(n, nx, ifa->neigh_list)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:914:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    914 |   WALK_LIST_DELSAFE(nb, nbx, ifa->nbma_list)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:1169:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1169 |     WALK_LIST_DELSAFE(ifa, ifx, p->iface_list)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:1204:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1204 |       WALK_LIST_DELSAFE(ifa, ifx, p->iface_list)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/iface.c:1389:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1389 |   WALK_LIST_DELSAFE(ifa, ifx, p->iface_list)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/lsalib.c:173:16: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    173 |       if (code = LOOKUP(opaque_lsa_types, id >> 24))
        |           ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/lsupd.c:444:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    444 |   WALK_SLIST_DELSAFE(ret, nxt, n->lsrtl)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/neighbor.c:544:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    544 |       WALK_LIST_DELSAFE(n, nx, ifa->neigh_list)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:541:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    541 |   FIB_WALK(&p->rtf, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:568:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    568 |       strcpy(buf, "Alone");
        |              ^~~
  

• proto/ospf/ospf.c:570:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    570 |       strcpy(buf, "Running");
        |              ^~~
  

• proto/ospf/ospf.c:596:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    596 |   buf += bsprintf(buf, " %s", type);
        |                   ^~~
  

• proto/ospf/ospf.c:597:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    597 |   buf += bsprintf(buf, " (%d/%d", rt_get_preference(rte), ea_get_int(rte->attrs, &ea_ospf_metric1, LSINFINITY));
        |                   ^~~
  

• proto/ospf/ospf.c:599:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    599 |     buf += bsprintf(buf, "/%d", ea_get_int(rte->attrs, &ea_ospf_metric2, LSINFINITY));
        |                     ^~~
  

• proto/ospf/ospf.c:600:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    600 |   buf += bsprintf(buf, ")");
        |                   ^~~
  

• proto/ospf/ospf.c:605:23: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    605 |       buf += bsprintf(buf, " [%x]", ea->u.data);
        |                       ^~~
  

• proto/ospf/ospf.c:610:21: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    610 |     buf += bsprintf(buf, " [%R]", ea->u.data);
        |                     ^~~
  

• proto/ospf/ospf.c:616:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    616 |   bsnprintf(buf, buflen, "0x%08x", a->u.data);
        |             ^~~
  

• proto/ospf/ospf.c:634:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    634 |     WALK_LIST_DELSAFE(ifa, ifx, p->iface_list)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:751:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    751 |   WALK_LIST_DELSAFE(ifa, ifx, p->iface_list)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:758:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    758 |   WALK_LIST_DELSAFE(oa, oax, p->area_list)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:785:35: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    785 |     if ((iff == NULL) || patmatch(iff, ifa->ifname))
        |                                   ^~~
  

• proto/ospf/ospf.c:785:40: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    785 |     if ((iff == NULL) || patmatch(iff, ifa->ifname))
        |                                        ^~~~~~~~~~~
  

• proto/ospf/ospf.c:845:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    845 |     FIB_WALK(&oa->net_fib, struct area_net, anet)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:858:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    858 |     FIB_WALK(&oa->enet_fib, struct area_net, anet)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/ospf.c:887:35: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    887 |     if ((iff == NULL) || patmatch(iff, ifa->ifname))
        |                                   ^~~
  

• proto/ospf/ospf.c:887:40: warning: passing 'char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    887 |     if ((iff == NULL) || patmatch(iff, ifa->ifname))
        |                                        ^~~~~~~~~~~
  

• proto/ospf/packet.c:119:25: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    119 |     mac_fill(pass->alg, pass->password, pass->length, (byte *) pkt, *plen, auth_tail);
        |                         ^~~~~~~~~~~~~~
  

• proto/ospf/packet.c:204:32: warning: passing 'u8[8]' (aka 'unsigned char[8]') to parameter of type 'const char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    204 |     if (!password_verify(pass, auth->password, sizeof(auth->password)))
        |                                ^~~~~~~~~~~~~~
  

• proto/ospf/packet.c:243:32: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    243 |     if (!mac_verify(pass->alg, pass->password, pass->length,
        |                                ^~~~~~~~~~~~~~
  

• proto/ospf/packet.c:455:55: warning: passing 'uint *' (aka 'unsigned int *') to parameter of type 'int *' converts between pointers to integer types with different sign [-Wpointer-sign]
    455 |   struct ospf_packet *pkt = (void *) sk_rx_buffer(sk, &len);
        |                                                       ^~~~
  

• proto/ospf/rt.c:986:25: warning: equality comparison with extraneous parentheses [-Wparentheses-equality]
    986 |   if ((nf->n.oa->areaid == oa->areaid))
        |        ~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~
  

• proto/ospf/rt.c:1190:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1190 |   FIB_WALK(&p->backbone->rtr, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1198:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1198 |   FIB_WALK(&p->rtf, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1264:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1264 |       FIB_WALK(&oa->rtr, ort, nf)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1275:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1275 |   FIB_WALK(&p->backbone->rtr, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1315:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1315 |       FIB_WALK(&oa->rtr, ort, nf)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1360:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1360 |   FIB_WALK(&p->rtf, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1388:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1388 |   FIB_WALK(&p->rtf, ort, nf)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1605:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1605 |   FIB_WALK(&p->rtf, ort, ri)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1628:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1628 |     FIB_WALK(&oa->rtr, ort, ri)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1637:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1637 |       FIB_WALK(&oa->net_fib, struct area_net, anet)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/rt.c:1644:7: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1644 |       FIB_WALK(&oa->enet_fib, struct area_net, anet)
        |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/topology.c:525:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    525 |   WALK_SLIST_DELSAFE(en, nxt, p->lsal)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/ospf/topology.c:1731:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1731 |   if (en = ifa->link_lsa)
        |       ~~~^~~~~~~~~~~~~~~
  

• proto/pipe/pipe.c:209:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    209 |   bsprintf(buf, "%s <=> %s", p->pri->table->name, p->sec->table->name);
        |            ^~~
  

• proto/radv/packets.c:339:9: warning: initializing 'char *' with an expression of type 'byte *' (aka 'unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    339 |   char *buf = ifa->sk->tbuf;
        |         ^     ~~~~~~~~~~~~~
  

• proto/radv/packets.c:405:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    405 |     FIB_WALK(&p->routes, struct radv_route, rt)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/radv/radv.c:186:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    186 |   WALK_LIST_DELSAFE(pfx, next, ifa->prefixes)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/radv/radv.c:209:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    209 |   WALK_LIST_DELSAFE(px, pxn, ifa->prefixes)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/radv/radv.c:289:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    289 |   RT_EXPORT_WALK(&p->nbr_channel->out_req, u)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/radv/radv.c:871:12: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    871 |     strcpy(buf, "Suppressed");
        |            ^~~
  

• proto/radv/radv.c:893:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    893 |   bsnprintf(buf, buflen, "%s", radv_pref_str(a->u.data));
        |             ^~~
  

• proto/rip/packets.c:320:25: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    320 |     mac_fill(pass->alg, pass->password, pass->length,
        |                         ^~~~~~~~~~~~~~
  

• proto/rip/packets.c:409:32: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    409 |     if (!mac_verify(pass->alg, pass->password, pass->length,
        |                                ^~~~~~~~~~~~~~
  

• proto/rip/rip.c:272:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    272 |   for (rp = &en->routes; rt = *rp; rp = &rt->next)
        |                          ~~~^~~~~
  

• proto/rip/rip.c:319:29: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    319 |   for (rp = &en->routes; rt = *rp; rp = &rt->next)
        |                          ~~~^~~~~
  

• proto/rip/rip.c:432:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    432 |   FIB_WALK(&p->rtable, struct rip_entry, en)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/rip/rip.c:951:31: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    951 |     for (rp = &en->routes; rt = *rp; /* rp = &rt->next */)
        |                            ~~~^~~~~
  

• proto/rip/rip.c:1010:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1010 |     WALK_LIST_DELSAFE(n, nn, ifa->neigh_list)
        |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/rip/rip.c:1262:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1262 |   buf += bsprintf(buf, " (%d/%d)", rt_get_preference(rte), rt_metric);
        |                   ^~~
  

• proto/rip/rip.c:1265:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1265 |     bsprintf(buf, " [%04x]", rt_tag);
        |              ^~~
  

• proto/rip/rip.c:1271:13: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1271 |   bsnprintf(buf, buflen, "%04x", a->u.data);
        |             ^~~
  

• proto/rip/rip.c:1313:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1313 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                          ^~~
  

• proto/rip/rip.c:1313:31: warning: passing 'char[16]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1313 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                               ^~~~~~~~~~~~~~~~
  

• proto/rip/rip.c:1348:26: warning: passing 'const char *' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1348 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                          ^~~
  

• proto/rip/rip.c:1348:31: warning: passing 'char[16]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1348 |     if (iff && !patmatch(iff, ifa->iface->name))
        |                               ^~~~~~~~~~~~~~~~
  

• proto/rip/rip.c:1371:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1371 |   FIB_WALK(&p->rtable, struct rip_entry, en)
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• proto/rpki/rpki.c:918:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    918 |     bsprintf(buf, "%s", rpki_cache_state_to_str(p->cache->state));
        |              ^~~
  

• proto/rpki/rpki.c:920:14: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    920 |     bsprintf(buf, "No cache server configured");
        |              ^~~
  

• sysdep/unix/alloc.c:188:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    188 |   if (fp = PAGE_STACK_GET)
        |       ~~~^~~~~~~~~~~~~~~~
  

• sysdep/unix/alloc.c:247:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    247 |   if (fp = alloc_hot_page(fp))
        |       ~~~^~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/alloc.c:261:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    261 |   if (fp = alloc_hot_page(fp))
        |       ~~~^~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/alloc.c:386:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    386 |   while (next = atomic_load_explicit(&last->next, memory_order_relaxed))
        |          ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io.c:257:2: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    257 |         else
        |         ^
  

• sysdep/unix/io.c:827:58: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
    827 |   if (getsockopt(s->fd, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldsize_s) < 0)
        |                                                          ^~~~~~~~~~
  

• sysdep/unix/io.c:1428:35: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
   1428 |   if ((getsockname(s->fd, &sa.sa, &sa_len) < 0) ||
        |                                   ^~~~~~~
  

• sysdep/unix/io.c:1454:66: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
   1454 |   int fd = accept(s->fd, ((type == SK_TCP) ? &rem_sa.sa : NULL), &rem_sa_len);
        |                                                                  ^~~~~~~~~~~
  

• sysdep/unix/io.c:1480:38: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
   1480 |     if ((getsockname(fd, &loc_sa.sa, &loc_sa_len) < 0) ||
        |                                      ^~~~~~~~~~~
  

• sysdep/unix/io.c:1791:12: warning: assigning to 'byte *' (aka 'unsigned char *') from 'char[1]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1791 |     s->ttx = "";                        /* Force s->ttx != s->tpos */
        |            ^ ~~
  

• sysdep/unix/io.c:1802:12: warning: assigning to 'byte *' (aka 'unsigned char *') from 'char[1]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1802 |     s->ttx = "";                        /* Force s->ttx != s->tpos */
        |            ^ ~~
  

• sysdep/unix/io.c:2266:7: warning: 'ssh_channel_select' is deprecated [-Wdeprecated-declarations]
   2266 |   if (ssh_channel_select(rchans, NULL, NULL, &timev) == SSH_EINTR)
        |       ^
  

• sysdep/unix/io.c:2444:54: warning: passing 'int *' to parameter of type 'socklen_t *' (aka 'unsigned int *') converts between pointers to integer types with different sign [-Wpointer-sign]
   2444 |     if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &se, &sse) < 0)
        |                                                      ^~~~
  

• sysdep/unix/io.c:2653:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2653 |       if (t = timers_first(&main_birdloop.time))
        |           ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:412:16: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    412 |       .start = new_info,
        |                ^~~~~~~~
  

• sysdep/unix/io-loop.c:413:14: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    413 |       .pos = new_info,
        |              ^~~~~~~~
  

• sysdep/unix/io-loop.c:414:14: warning: initializing 'byte *' (aka 'unsigned char *') with an expression of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    414 |       .end = new_info + size,
        |              ^~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:645:3: warning: redefinition of typedef 'thread_group' is a C11 feature [-Wtypedef-redefinition]
    645 | } thread_group;
        |   ^
  

• sysdep/unix/io-loop.c:974:32: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    974 |   if (this_thread->busy_active = val)
        |       ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~
  

• sysdep/unix/io-loop.c:1249:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1249 |       if (e = pthread_attr_init(&thr->thread_attr))
        |           ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:1257:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1257 |       if (e = pthread_attr_setdetachstate(&thr->thread_attr, PTHREAD_CREATE_DETACHED))
        |           ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:1260:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1260 |       if (e = pthread_create(&thr->thread_id, &thr->thread_attr, bird_thread_main, thr))
        |           ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:1531:14: warning: passing 'char[7]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1531 |         new_config, "worker",
        |                     ^~~~~~~~
  

• sysdep/unix/io-loop.c:1540:14: warning: passing 'char[8]' to parameter of type 'const byte *' (aka 'const unsigned char *') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1540 |         new_config, "express",
        |                     ^~~~~~~~~
  

• sysdep/unix/io-loop.c:2027:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2027 |   while (t = timers_first(&loop->time))
        |          ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/io-loop.c:2077:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2077 |       ltt = atomic_load_explicit(&loop->thread_transition, memory_order_acquire);
        |       ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/krt.c:1003:5: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1003 |     RT_FEED_WALK(&req, f)
        |     ^~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/log.c:233:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    233 |       l = atomic_load_explicit(pprev, memory_order_acquire);
        |       ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/log.c:324:33: warning: assigning to 'byte *' (aka 'unsigned char *') from 'char[2560]' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    324 |   buf->buf.start = buf->buf.pos = buf->block;
        |                                 ^ ~~~~~~~~~~
  

• sysdep/unix/log.c:325:16: warning: assigning to 'byte *' (aka 'unsigned char *') from 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    325 |   buf->buf.end = buf->block + sizeof buf->block;
        |                ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/unix/log.c:334:33: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    334 |     int t = tm_format_real_time(buf->buf.pos, buf->buf.end - buf->buf.pos, fmt, current_real_time());
        |                                 ^~~~~~~~~~~~
  

• sysdep/unix/log.c:351:33: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    351 |     int t = tm_format_real_time(buf->buf.pos, buf->buf.end - buf->buf.pos, fmt, current_real_time());
        |                                 ^~~~~~~~~~~~
  

• sysdep/unix/log.c:620:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
    620 |       ol = atomic_load_explicit(pprev, memory_order_acquire);
        |       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1073:7: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   1073 |       else
        |       ^
  

• sysdep/bsd-netlink/netlink.c:1491:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1491 |   while (h = nl_get_scan())
        |          ~~^~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1518:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1518 |   while (h = nl_get_scan())
        |          ~~^~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1525:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1525 |   while (h = nl_get_scan())
        |          ~~^~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1679:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1679 |   else if (ea = ea_find(eattrs, &ea_krt_scope))
        |            ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1686:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1686 |   if (ea = ea_find(eattrs, &ea_krt_prefsrc))
        |       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1689:10: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1689 |   if (ea = ea_find(eattrs, &ea_krt_realm))
        |       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1698:13: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   1698 |   while (ea = ea_walk(&ews, ea_krt_metrics[0].id, KRT_METRICS_MAX))
        |          ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:1704:15: warning: assigning to 'const char *' from 'const byte[0]' (aka 'const unsigned char[0]') converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
   1704 |       cc_algo = ea->u.ptr->data;
        |               ^ ~~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:2105:4: warning: add explicit braces to avoid dangling else [-Wdangling-else]
   2105 |           else
        |           ^
  

• sysdep/bsd-netlink/netlink.c:2138:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2138 |   while (h = nl_get_scan())
        |          ~~^~~~~~~~~~~~~~~
  

• sysdep/bsd-netlink/netlink.c:2823:3: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
   2823 |   HASH_REMOVE2(nl_table_map, RTH, krt_pool, p);
        |   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  

• client/client.c:332:19: warning: passing 'byte *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    332 |         server_got_reply(start);
        |                          ^~~~~
  

• client/client.c:343:14: warning: passing 'byte[4096]' (aka 'unsigned char[4096]') to parameter of type 'char *' converts between pointers to integer types where one is of the unique plain 'char' type and the other is not [-Wpointer-sign]
    343 |       strcpy(server_read_buf, "?<too-long>");
        |              ^~~~~~~~~~~~~~~