dlog: 40| 634|void dlog(int level, int flevel, char const *fmt, ...) {} flog: 41| 45|void flog(int level, char const *fmt, ...) {} LLVMFuzzerTestOneInput: 48| 634|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 49| 634| char filename[] = "/tmp/fuzz-config-XXXXXX"; 50| 634| int fd = mkstemp(filename); 51| 634| if (fd < 0) { ------------------ | Branch (51:9): [True: 0, False: 634] ------------------ 52| 0| return 0; 53| 0| } 54| 634| write(fd, data, size); 55| 634| close(fd); 56| | 57| 634| struct Interface *ifaces = readin_config(filename); 58| | 59| 634| if (ifaces) { ------------------ | Branch (59:9): [True: 0, False: 634] ------------------ 60| 0| free_ifaces(ifaces); 61| 0| } 62| | 63| 634| unlink(filename); 64| 634| return 0; 65| 634|} yyparse: 1505| 634|{ 1506| 634| yy_state_fast_t yystate = 0; 1507| | /* Number of tokens to shift before error messages enabled. */ 1508| 634| int yyerrstatus = 0; 1509| | 1510| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1511| | to reallocate them elsewhere. */ 1512| | 1513| | /* Their size. */ 1514| 634| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 614| 634|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1450| 634|# define YYINITDEPTH 200 ------------------ 1515| | 1516| | /* The state stack: array, bottom, top. */ 1517| 634| yy_state_t yyssa[YYINITDEPTH]; 1518| 634| yy_state_t *yyss = yyssa; 1519| 634| yy_state_t *yyssp = yyss; 1520| | 1521| | /* The semantic value stack: array, bottom, top. */ 1522| 634| YYSTYPE yyvsa[YYINITDEPTH]; 1523| 634| YYSTYPE *yyvs = yyvsa; 1524| 634| YYSTYPE *yyvsp = yyvs; 1525| | 1526| 634| int yyn; 1527| | /* The return value of yyparse. */ 1528| 634| int yyresult; 1529| | /* Lookahead symbol kind. */ 1530| 634| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1531| | /* The variables used to return semantic value and location from the 1532| | action routines. */ 1533| 634| YYSTYPE yyval; 1534| | 1535| | 1536| | 1537| 634|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1538| | 1539| | /* The number of symbols on the RHS of the reduced rule. 1540| | Keep to zero when no symbol should be popped. */ 1541| 634| int yylen = 0; 1542| | 1543| 634| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1441| 634|# define YYDPRINTF(Args) ((void) 0) ------------------ 1544| | 1545| 634| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 235| 634|#define YYEMPTY -2 ------------------ 1546| | 1547| 634| goto yysetstate; 1548| | 1549| | 1550| |/*------------------------------------------------------------. 1551| || yynewstate -- push a new state, which is found in yystate. | 1552| |`------------------------------------------------------------*/ 1553| 0|yynewstate: 1554| | /* In all cases, when you get here, the value and location stacks 1555| | have just been pushed. So pushing a state here evens the stacks. */ 1556| 0| yyssp++; 1557| | 1558| | 1559| |/*--------------------------------------------------------------------. 1560| || yysetstate -- set current state (the top of the stack) to yystate. | 1561| |`--------------------------------------------------------------------*/ 1562| 634|yysetstate: 1563| 634| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1441| 634|# define YYDPRINTF(Args) ((void) 0) ------------------ 1564| 634| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 730| 634|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (730:31): [Folded, False: 634] | | | Branch (730:37): [True: 0, False: 0] | | | Branch (730:37): [True: 0, False: 0] | | ------------------ ------------------ 1565| 634| YY_IGNORE_USELESS_CAST_BEGIN 1566| 634| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 112| 634|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1567| 634| YY_IGNORE_USELESS_CAST_END 1568| 634| YY_STACK_PRINT (yyss, yyssp); 1569| | 1570| 634| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1570:7): [True: 0, False: 634] ------------------ 1571| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1572| | YYNOMEM; 1573| |#else 1574| 0| { 1575| | /* Get the current used size of the three stacks, in elements. */ 1576| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 614| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1577| | 1578| |# if defined yyoverflow 1579| | { 1580| | /* Give user a chance to reallocate the stack. Use copies of 1581| | these so that the &'s don't force the real ones into 1582| | memory. */ 1583| | yy_state_t *yyss1 = yyss; 1584| | YYSTYPE *yyvs1 = yyvs; 1585| | 1586| | /* Each stack pointer address is followed by the size of the 1587| | data in use in that stack, in bytes. This used to be a 1588| | conditional around just the two extra args, but that might 1589| | be undefined if yyoverflow is a macro. */ 1590| | yyoverflow (YY_("memory exhausted"), 1591| | &yyss1, yysize * YYSIZEOF (*yyssp), 1592| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1593| | &yystacksize); 1594| | yyss = yyss1; 1595| | yyvs = yyvs1; 1596| | } 1597| |# else /* defined YYSTACK_RELOCATE */ 1598| | /* Extend the stack our own way. */ 1599| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1461| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1599:11): [True: 0, False: 0] ------------------ 1600| 0| YYNOMEM; ------------------ | | 1294| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1601| 0| yystacksize *= 2; 1602| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1461| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1602:11): [True: 0, False: 0] ------------------ 1603| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1461| 0|# define YYMAXDEPTH 10000 ------------------ 1604| | 1605| 0| { 1606| 0| yy_state_t *yyss1 = yyss; 1607| 0| union yyalloc *yyptr = 1608| 0| YY_CAST (union yyalloc *, ------------------ | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1609| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1610| 0| if (! yyptr) ------------------ | Branch (1610:13): [True: 0, False: 0] ------------------ 1611| 0| YYNOMEM; ------------------ | | 1294| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1612| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 827| 0| do \ | | 828| 0| { \ | | 829| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 614| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 830| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 845| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 831| 0| Stack = &yyptr->Stack_alloc; \ | | 832| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 811| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 833| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 834| 0| } \ | | 835| 0| while (0) | | ------------------ | | | Branch (835:12): [Folded, False: 0] | | ------------------ ------------------ 1613| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 827| 0| do \ | | 828| 0| { \ | | 829| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 614| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 830| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 845| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 831| 0| Stack = &yyptr->Stack_alloc; \ | | 832| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 811| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 833| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 647| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 834| 0| } \ | | 835| 0| while (0) | | ------------------ | | | Branch (835:12): [Folded, False: 0] | | ------------------ ------------------ 1614| 0|# undef YYSTACK_RELOCATE 1615| 0| if (yyss1 != yyssa) ------------------ | Branch (1615:13): [True: 0, False: 0] ------------------ 1616| 0| YYSTACK_FREE (yyss1); ------------------ | | 772| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 791| 0|# define YYFREE free | | ------------------ ------------------ 1617| 0| } 1618| 0|# endif 1619| | 1620| 0| yyssp = yyss + yysize - 1; 1621| 0| yyvsp = yyvs + yysize - 1; 1622| | 1623| 0| YY_IGNORE_USELESS_CAST_BEGIN 1624| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1441| 0|# define YYDPRINTF(Args) ((void) 0) ------------------ 1625| 0| YY_CAST (long, yystacksize))); 1626| 0| YY_IGNORE_USELESS_CAST_END 1627| | 1628| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1628:11): [True: 0, False: 0] ------------------ 1629| 0| YYABORT; ------------------ | | 1292| 0|#define YYABORT goto yyabortlab ------------------ 1630| 0| } 1631| 634|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1632| | 1633| | 1634| 634| if (yystate == YYFINAL) ------------------ | | 860| 634|#define YYFINAL 7 ------------------ | Branch (1634:7): [True: 0, False: 634] ------------------ 1635| 0| YYACCEPT; ------------------ | | 1291| 0|#define YYACCEPT goto yyacceptlab ------------------ 1636| | 1637| 634| goto yybackup; 1638| | 1639| | 1640| |/*-----------. 1641| || yybackup. | 1642| |`-----------*/ 1643| 634|yybackup: 1644| | /* Do appropriate processing given the current state. Read a 1645| | lookahead token if we need one and don't already have one. */ 1646| | 1647| | /* First try to decide what to do without reference to lookahead token. */ 1648| 634| yyn = yypact[yystate]; 1649| 634| if (yypact_value_is_default (yyn)) ------------------ | | 1011| 634| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1008| 634|#define YYPACT_NINF (-87) | | ------------------ | | | Branch (1011:3): [True: 0, False: 634] | | ------------------ ------------------ 1650| 0| goto yydefault; 1651| | 1652| | /* Not known => get a lookahead token if don't already have one. */ 1653| | 1654| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1655| 634| if (yychar == YYEMPTY) ------------------ | | 235| 634|#define YYEMPTY -2 ------------------ | Branch (1655:7): [True: 634, False: 0] ------------------ 1656| 634| { 1657| 634| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1441| 634|# define YYDPRINTF(Args) ((void) 0) ------------------ 1658| 634| yychar = yylex (); 1659| 634| } 1660| | 1661| 634| if (yychar <= YYEOF) ------------------ | | 236| 634|#define YYEOF 0 ------------------ | Branch (1661:7): [True: 48, False: 586] ------------------ 1662| 48| { 1663| 48| yychar = YYEOF; ------------------ | | 236| 48|#define YYEOF 0 ------------------ 1664| 48| yytoken = YYSYMBOL_YYEOF; 1665| 48| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1441| 48|# define YYDPRINTF(Args) ((void) 0) ------------------ 1666| 48| } 1667| 586| else if (yychar == YYerror) ------------------ | | 237| 586|#define YYerror 256 ------------------ | Branch (1667:12): [True: 0, False: 586] ------------------ 1668| 0| { 1669| | /* The scanner already issued an error message, process directly 1670| | to error recovery. But do not keep the error token as 1671| | lookahead, it is too special and may lead us to an endless 1672| | loop in error recovery. */ 1673| 0| yychar = YYUNDEF; ------------------ | | 238| 0|#define YYUNDEF 257 ------------------ 1674| 0| yytoken = YYSYMBOL_YYerror; 1675| 0| goto yyerrlab1; 1676| 0| } 1677| 586| else 1678| 586| { 1679| 586| yytoken = YYTRANSLATE (yychar); ------------------ | | 880| 586| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 874| 586|#define YYMAXUTOK 339 | | ------------------ | | | Branch (880:4): [True: 586, False: 0] | | | Branch (880:18): [True: 586, False: 0] | | ------------------ | | 881| 586| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 586|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 882| 586| : YYSYMBOL_YYUNDEF) ------------------ 1680| 586| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1681| 586| } 1682| | 1683| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1684| | detect an error, take that action. */ 1685| 634| yyn += yytoken; 1686| 634| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 862| 634|#define YYLAST 324 ------------------ | Branch (1686:7): [True: 0, False: 634] | Branch (1686:18): [True: 0, False: 634] | Branch (1686:34): [True: 634, False: 0] ------------------ 1687| 634| goto yydefault; 1688| 0| yyn = yytable[yyn]; 1689| 0| if (yyn <= 0) ------------------ | Branch (1689:7): [True: 0, False: 0] ------------------ 1690| 0| { 1691| 0| if (yytable_value_is_error (yyn)) ------------------ | | 1016| 0| 0 | | ------------------ | | | Branch (1016:3): [Folded, False: 0] | | ------------------ ------------------ 1692| 0| goto yyerrlab; 1693| 0| yyn = -yyn; 1694| 0| goto yyreduce; 1695| 0| } 1696| | 1697| | /* Count tokens shifted since error; after three, turn off error 1698| | status. */ 1699| 0| if (yyerrstatus) ------------------ | Branch (1699:7): [True: 0, False: 0] ------------------ 1700| 0| yyerrstatus--; 1701| | 1702| | /* Shift the lookahead token. */ 1703| 0| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1704| 0| yystate = yyn; 1705| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1706| 0| *++yyvsp = yylval; 1707| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 1708| | 1709| | /* Discard the shifted token. */ 1710| 0| yychar = YYEMPTY; ------------------ | | 235| 0|#define YYEMPTY -2 ------------------ 1711| 0| goto yynewstate; 1712| | 1713| | 1714| |/*-----------------------------------------------------------. 1715| || yydefault -- do the default action for the current state. | 1716| |`-----------------------------------------------------------*/ 1717| 634|yydefault: 1718| 634| yyn = yydefact[yystate]; 1719| 634| if (yyn == 0) ------------------ | Branch (1719:7): [True: 634, False: 0] ------------------ 1720| 634| goto yyerrlab; 1721| 0| goto yyreduce; 1722| | 1723| | 1724| |/*-----------------------------. 1725| || yyreduce -- do a reduction. | 1726| |`-----------------------------*/ 1727| 0|yyreduce: 1728| | /* yyn is the number of a rule to reduce with. */ 1729| 0| yylen = yyr2[yyn]; 1730| | 1731| | /* If YYLEN is nonzero, implement the default value of the action: 1732| | '$$ = $1'. 1733| | 1734| | Otherwise, the following line sets YYVAL to garbage. 1735| | This behavior is undocumented and Bison 1736| | users should not rely upon it. Assigning to YYVAL 1737| | unconditionally makes the parser a bit smaller, and it avoids a 1738| | GCC warning that YYVAL may be used uninitialized. */ 1739| 0| yyval = yyvsp[1-yylen]; 1740| | 1741| | 1742| 0| YY_REDUCE_PRINT (yyn); 1743| 0| switch (yyn) 1744| 0| { 1745| 0| case 4: /* ifacedef: ifacehead '{' ifaceparams '}' ';' */ ------------------ | Branch (1745:3): [True: 0, False: 0] ------------------ 1746| 0|#line 206 "gram.y" 1747| 0| { 1748| 0| dlog(LOG_DEBUG, 4, "%s interface definition ok", iface->props.name); 1749| | 1750| 0| iface->next = IfaceList; 1751| 0| IfaceList = iface; 1752| | 1753| 0| iface = NULL; 1754| 0| } 1755| 0|#line 1756 "gram.c" 1756| 0| break; 1757| | 1758| 0| case 5: /* ifacehead: T_INTERFACE name */ ------------------ | Branch (1758:3): [True: 0, False: 0] ------------------ 1759| 0|#line 216 "gram.y" 1760| 0| { 1761| 0| iface = IfaceList; 1762| | 1763| 0| while (iface) ------------------ | Branch (1763:11): [True: 0, False: 0] ------------------ 1764| 0| { 1765| 0| if (!strcmp((yyvsp[0].str), iface->props.name)) ------------------ | Branch (1765:9): [True: 0, False: 0] ------------------ 1766| 0| { 1767| 0| flog(LOG_ERR, "duplicate interface " 1768| 0| "definition for %s", (yyvsp[0].str)); 1769| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 1770| 0| } 1771| 0| iface = iface->next; 1772| 0| } 1773| | 1774| 0| iface = malloc(sizeof(struct Interface)); 1775| | 1776| 0| if (iface == NULL) { ------------------ | Branch (1776:8): [True: 0, False: 0] ------------------ 1777| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 1778| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 1779| 0| } 1780| | 1781| 0| iface_init_defaults(iface); 1782| 0| memset(&iface->props.name, 0, sizeof(iface->props.name)); 1783| 0| strlcpy(iface->props.name, (yyvsp[0].str), sizeof(iface->props.name)); 1784| 0| iface->lineno = num_lines; 1785| 0| } 1786| 0|#line 1787 "gram.c" 1787| 0| break; 1788| | 1789| 0| case 6: /* name: STRING */ ------------------ | Branch (1789:3): [True: 0, False: 0] ------------------ 1790| 0|#line 245 "gram.y" 1791| 0| { 1792| | /* check vality */ 1793| 0| (yyval.str) = (yyvsp[0].str); 1794| 0| } 1795| 0|#line 1796 "gram.c" 1796| 0| break; 1797| | 1798| 0| case 10: /* ifaceparam: prefixdef */ ------------------ | Branch (1798:3): [True: 0, False: 0] ------------------ 1799| 0|#line 256 "gram.y" 1800| 0| { ADD_TO_LL(struct AdvPrefix, AdvPrefixList, (yyvsp[0].pinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1801| 0|#line 1802 "gram.c" 1802| 0| break; 1803| | 1804| 0| case 11: /* ifaceparam: clientslist */ ------------------ | Branch (1804:3): [True: 0, False: 0] ------------------ 1805| 0|#line 257 "gram.y" 1806| 0| { ADD_TO_LL(struct Clients, ClientList, (yyvsp[0].ainfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1807| 0|#line 1808 "gram.c" 1808| 0| break; 1809| | 1810| 0| case 12: /* ifaceparam: routedef */ ------------------ | Branch (1810:3): [True: 0, False: 0] ------------------ 1811| 0|#line 258 "gram.y" 1812| 0| { ADD_TO_LL(struct AdvRoute, AdvRouteList, (yyvsp[0].rinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1813| 0|#line 1814 "gram.c" 1814| 0| break; 1815| | 1816| 0| case 13: /* ifaceparam: rdnssdef */ ------------------ | Branch (1816:3): [True: 0, False: 0] ------------------ 1817| 0|#line 259 "gram.y" 1818| 0| { ADD_TO_LL(struct AdvRDNSS, AdvRDNSSList, (yyvsp[0].rdnssinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1819| 0|#line 1820 "gram.c" 1820| 0| break; 1821| | 1822| 0| case 14: /* ifaceparam: dnssldef */ ------------------ | Branch (1822:3): [True: 0, False: 0] ------------------ 1823| 0|#line 260 "gram.y" 1824| 0| { ADD_TO_LL(struct AdvDNSSL, AdvDNSSLList, (yyvsp[0].dnsslinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1825| 0|#line 1826 "gram.c" 1826| 0| break; 1827| | 1828| 0| case 15: /* ifaceparam: dnrdef */ ------------------ | Branch (1828:3): [True: 0, False: 0] ------------------ 1829| 0|#line 261 "gram.y" 1830| 0| { ADD_TO_LL(struct AdvDNR, AdvDNRList, (yyvsp[0].dnrinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1831| 0|#line 1832 "gram.c" 1832| 0| break; 1833| | 1834| 0| case 16: /* ifaceparam: lowpancodef */ ------------------ | Branch (1834:3): [True: 0, False: 0] ------------------ 1835| 0|#line 262 "gram.y" 1836| 0| { ADD_TO_LL(struct AdvLowpanCo, AdvLowpanCoList, (yyvsp[0].lowpancoinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1837| 0|#line 1838 "gram.c" 1838| 0| break; 1839| | 1840| 0| case 17: /* ifaceparam: abrodef */ ------------------ | Branch (1840:3): [True: 0, False: 0] ------------------ 1841| 0|#line 263 "gram.y" 1842| 0| { ADD_TO_LL(struct AdvAbro, AdvAbroList, (yyvsp[0].abroinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1843| 0|#line 1844 "gram.c" 1844| 0| break; 1845| | 1846| 0| case 18: /* ifaceparam: rasrcaddresslist */ ------------------ | Branch (1846:3): [True: 0, False: 0] ------------------ 1847| 0|#line 264 "gram.y" 1848| 0| { ADD_TO_LL(struct AdvRASrcAddress, AdvRASrcAddressList, (yyvsp[0].rasrcaddressinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1849| 0|#line 1850 "gram.c" 1850| 0| break; 1851| | 1852| 0| case 19: /* ifaceparam: nat64prefixdef */ ------------------ | Branch (1852:3): [True: 0, False: 0] ------------------ 1853| 0|#line 265 "gram.y" 1854| 0| { ADD_TO_LL(struct NAT64Prefix, NAT64PrefixList, (yyvsp[0].nat64pinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1855| 0|#line 1856 "gram.c" 1856| 0| break; 1857| | 1858| 0| case 20: /* ifaceparam: ignoreprefixlist */ ------------------ | Branch (1858:3): [True: 0, False: 0] ------------------ 1859| 0|#line 266 "gram.y" 1860| 0| { ADD_TO_LL(struct AutogenIgnorePrefix, IgnorePrefixList, (yyvsp[0].igpinfo)); } ------------------ | | 93| 0| do { \ | | 94| 0| if (iface->list == NULL) \ | | ------------------ | | | Branch (94:7): [True: 0, False: 0] | | ------------------ | | 95| 0| iface->list = value; \ | | 96| 0| else { \ | | 97| 0| type *current = iface->list; \ | | 98| 0| while (current->next != NULL) \ | | ------------------ | | | Branch (98:11): [True: 0, False: 0] | | ------------------ | | 99| 0| current = current->next; \ | | 100| 0| current->next = value; \ | | 101| 0| } \ | | 102| 0| } while (0) | | ------------------ | | | Branch (102:11): [Folded, False: 0] | | ------------------ ------------------ 1861| 0|#line 1862 "gram.c" 1862| 0| break; 1863| | 1864| 0| case 21: /* ifaceval: T_MinRtrAdvInterval NUMBER ';' */ ------------------ | Branch (1864:3): [True: 0, False: 0] ------------------ 1865| 0|#line 270 "gram.y" 1866| 0| { 1867| 0| iface->MinRtrAdvInterval = (yyvsp[-1].num); 1868| 0| } 1869| 0|#line 1870 "gram.c" 1870| 0| break; 1871| | 1872| 0| case 22: /* ifaceval: T_MaxRtrAdvInterval NUMBER ';' */ ------------------ | Branch (1872:3): [True: 0, False: 0] ------------------ 1873| 0|#line 274 "gram.y" 1874| 0| { 1875| 0| iface->MaxRtrAdvInterval = (yyvsp[-1].num); 1876| 0| } 1877| 0|#line 1878 "gram.c" 1878| 0| break; 1879| | 1880| 0| case 23: /* ifaceval: T_MinDelayBetweenRAs NUMBER ';' */ ------------------ | Branch (1880:3): [True: 0, False: 0] ------------------ 1881| 0|#line 278 "gram.y" 1882| 0| { 1883| 0| iface->MinDelayBetweenRAs = (yyvsp[-1].num); 1884| 0| } 1885| 0|#line 1886 "gram.c" 1886| 0| break; 1887| | 1888| 0| case 24: /* ifaceval: T_MinRtrAdvInterval DECIMAL ';' */ ------------------ | Branch (1888:3): [True: 0, False: 0] ------------------ 1889| 0|#line 282 "gram.y" 1890| 0| { 1891| 0| iface->MinRtrAdvInterval = (yyvsp[-1].dec); 1892| 0| } 1893| 0|#line 1894 "gram.c" 1894| 0| break; 1895| | 1896| 0| case 25: /* ifaceval: T_MaxRtrAdvInterval DECIMAL ';' */ ------------------ | Branch (1896:3): [True: 0, False: 0] ------------------ 1897| 0|#line 286 "gram.y" 1898| 0| { 1899| 0| iface->MaxRtrAdvInterval = (yyvsp[-1].dec); 1900| 0| } 1901| 0|#line 1902 "gram.c" 1902| 0| break; 1903| | 1904| 0| case 26: /* ifaceval: T_MinDelayBetweenRAs DECIMAL ';' */ ------------------ | Branch (1904:3): [True: 0, False: 0] ------------------ 1905| 0|#line 290 "gram.y" 1906| 0| { 1907| 0| iface->MinDelayBetweenRAs = (yyvsp[-1].dec); 1908| 0| } 1909| 0|#line 1910 "gram.c" 1910| 0| break; 1911| | 1912| 0| case 27: /* ifaceval: T_IgnoreIfMissing SWITCH ';' */ ------------------ | Branch (1912:3): [True: 0, False: 0] ------------------ 1913| 0|#line 294 "gram.y" 1914| 0| { 1915| 0| iface->IgnoreIfMissing = (yyvsp[-1].num); 1916| 0| } 1917| 0|#line 1918 "gram.c" 1918| 0| break; 1919| | 1920| 0| case 28: /* ifaceval: T_AdvSendAdvert SWITCH ';' */ ------------------ | Branch (1920:3): [True: 0, False: 0] ------------------ 1921| 0|#line 298 "gram.y" 1922| 0| { 1923| 0| iface->AdvSendAdvert = (yyvsp[-1].num); 1924| 0| } 1925| 0|#line 1926 "gram.c" 1926| 0| break; 1927| | 1928| 0| case 29: /* ifaceval: T_AdvManagedFlag SWITCH ';' */ ------------------ | Branch (1928:3): [True: 0, False: 0] ------------------ 1929| 0|#line 302 "gram.y" 1930| 0| { 1931| 0| iface->ra_header_info.AdvManagedFlag = (yyvsp[-1].num); 1932| 0| } 1933| 0|#line 1934 "gram.c" 1934| 0| break; 1935| | 1936| 0| case 30: /* ifaceval: T_AdvOtherConfigFlag SWITCH ';' */ ------------------ | Branch (1936:3): [True: 0, False: 0] ------------------ 1937| 0|#line 306 "gram.y" 1938| 0| { 1939| 0| iface->ra_header_info.AdvOtherConfigFlag = (yyvsp[-1].num); 1940| 0| } 1941| 0|#line 1942 "gram.c" 1942| 0| break; 1943| | 1944| 0| case 31: /* ifaceval: T_AdvLinkMTU NUMBER ';' */ ------------------ | Branch (1944:3): [True: 0, False: 0] ------------------ 1945| 0|#line 310 "gram.y" 1946| 0| { 1947| 0| iface->AdvLinkMTU = (yyvsp[-1].num); 1948| 0| } 1949| 0|#line 1950 "gram.c" 1950| 0| break; 1951| | 1952| 0| case 32: /* ifaceval: T_AdvRAMTU NUMBER ';' */ ------------------ | Branch (1952:3): [True: 0, False: 0] ------------------ 1953| 0|#line 314 "gram.y" 1954| 0| { 1955| 0| iface->AdvRAMTU = (yyvsp[-1].num); 1956| 0| iface->AdvRAMTU = MAX(MIN_AdvLinkMTU, iface->AdvRAMTU); ------------------ | Branch (1956:22): [True: 0, False: 0] ------------------ 1957| 0| iface->AdvRAMTU = MIN(MAX_AdvLinkMTU, iface->AdvRAMTU); ------------------ | Branch (1957:22): [True: 0, False: 0] ------------------ 1958| 0| } 1959| 0|#line 1960 "gram.c" 1960| 0| break; 1961| | 1962| 0| case 33: /* ifaceval: T_AdvReachableTime NUMBER ';' */ ------------------ | Branch (1962:3): [True: 0, False: 0] ------------------ 1963| 0|#line 320 "gram.y" 1964| 0| { 1965| 0| iface->ra_header_info.AdvReachableTime = (yyvsp[-1].num); 1966| 0| } 1967| 0|#line 1968 "gram.c" 1968| 0| break; 1969| | 1970| 0| case 34: /* ifaceval: T_AdvRetransTimer NUMBER ';' */ ------------------ | Branch (1970:3): [True: 0, False: 0] ------------------ 1971| 0|#line 324 "gram.y" 1972| 0| { 1973| 0| iface->ra_header_info.AdvRetransTimer = (yyvsp[-1].num); 1974| 0| } 1975| 0|#line 1976 "gram.c" 1976| 0| break; 1977| | 1978| 0| case 35: /* ifaceval: T_AdvDefaultLifetime NUMBER ';' */ ------------------ | Branch (1978:3): [True: 0, False: 0] ------------------ 1979| 0|#line 328 "gram.y" 1980| 0| { 1981| 0| iface->ra_header_info.AdvDefaultLifetime = (yyvsp[-1].num); 1982| 0| } 1983| 0|#line 1984 "gram.c" 1984| 0| break; 1985| | 1986| 0| case 36: /* ifaceval: T_AdvDefaultPreference SIGNEDNUMBER ';' */ ------------------ | Branch (1986:3): [True: 0, False: 0] ------------------ 1987| 0|#line 332 "gram.y" 1988| 0| { 1989| 0| iface->ra_header_info.AdvDefaultPreference = (yyvsp[-1].snum); 1990| 0| } 1991| 0|#line 1992 "gram.c" 1992| 0| break; 1993| | 1994| 0| case 37: /* ifaceval: T_AdvCurHopLimit NUMBER ';' */ ------------------ | Branch (1994:3): [True: 0, False: 0] ------------------ 1995| 0|#line 336 "gram.y" 1996| 0| { 1997| 0| iface->ra_header_info.AdvCurHopLimit = (yyvsp[-1].num); 1998| 0| } 1999| 0|#line 2000 "gram.c" 2000| 0| break; 2001| | 2002| 0| case 38: /* ifaceval: T_RemoveAdvOnExit SWITCH ';' */ ------------------ | Branch (2002:3): [True: 0, False: 0] ------------------ 2003| 0|#line 340 "gram.y" 2004| 0| { 2005| 0| iface->RemoveAdvOnExit = (yyvsp[-1].num); 2006| 0| } 2007| 0|#line 2008 "gram.c" 2008| 0| break; 2009| | 2010| 0| case 39: /* ifaceval: T_AdvSourceLLAddress SWITCH ';' */ ------------------ | Branch (2010:3): [True: 0, False: 0] ------------------ 2011| 0|#line 344 "gram.y" 2012| 0| { 2013| 0| iface->AdvSourceLLAddress = (yyvsp[-1].num); 2014| 0| } 2015| 0|#line 2016 "gram.c" 2016| 0| break; 2017| | 2018| 0| case 40: /* ifaceval: T_AdvIntervalOpt SWITCH ';' */ ------------------ | Branch (2018:3): [True: 0, False: 0] ------------------ 2019| 0|#line 348 "gram.y" 2020| 0| { 2021| 0| iface->mipv6.AdvIntervalOpt = (yyvsp[-1].num); 2022| 0| } 2023| 0|#line 2024 "gram.c" 2024| 0| break; 2025| | 2026| 0| case 41: /* ifaceval: T_AdvHomeAgentInfo SWITCH ';' */ ------------------ | Branch (2026:3): [True: 0, False: 0] ------------------ 2027| 0|#line 352 "gram.y" 2028| 0| { 2029| 0| iface->mipv6.AdvHomeAgentInfo = (yyvsp[-1].num); 2030| 0| } 2031| 0|#line 2032 "gram.c" 2032| 0| break; 2033| | 2034| 0| case 42: /* ifaceval: T_AdvHomeAgentFlag SWITCH ';' */ ------------------ | Branch (2034:3): [True: 0, False: 0] ------------------ 2035| 0|#line 356 "gram.y" 2036| 0| { 2037| 0| iface->ra_header_info.AdvHomeAgentFlag = (yyvsp[-1].num); 2038| 0| } 2039| 0|#line 2040 "gram.c" 2040| 0| break; 2041| | 2042| 0| case 43: /* ifaceval: T_HomeAgentPreference NUMBER ';' */ ------------------ | Branch (2042:3): [True: 0, False: 0] ------------------ 2043| 0|#line 360 "gram.y" 2044| 0| { 2045| 0| iface->mipv6.HomeAgentPreference = (yyvsp[-1].num); 2046| 0| } 2047| 0|#line 2048 "gram.c" 2048| 0| break; 2049| | 2050| 0| case 44: /* ifaceval: T_HomeAgentLifetime NUMBER ';' */ ------------------ | Branch (2050:3): [True: 0, False: 0] ------------------ 2051| 0|#line 364 "gram.y" 2052| 0| { 2053| 0| iface->mipv6.HomeAgentLifetime = (yyvsp[-1].num); 2054| 0| } 2055| 0|#line 2056 "gram.c" 2056| 0| break; 2057| | 2058| 0| case 45: /* ifaceval: T_AdvSNACRouterFlag SWITCH ';' */ ------------------ | Branch (2058:3): [True: 0, False: 0] ------------------ 2059| 0|#line 368 "gram.y" 2060| 0| { 2061| 0| iface->ra_header_info.AdvSNACRouterFlag = (yyvsp[-1].num); 2062| 0| } 2063| 0|#line 2064 "gram.c" 2064| 0| break; 2065| | 2066| 0| case 46: /* ifaceval: T_UnicastOnly SWITCH ';' */ ------------------ | Branch (2066:3): [True: 0, False: 0] ------------------ 2067| 0|#line 372 "gram.y" 2068| 0| { 2069| 0| iface->UnicastOnly = (yyvsp[-1].num); 2070| 0| } 2071| 0|#line 2072 "gram.c" 2072| 0| break; 2073| | 2074| 0| case 47: /* ifaceval: T_UnrestrictedUnicast SWITCH ';' */ ------------------ | Branch (2074:3): [True: 0, False: 0] ------------------ 2075| 0|#line 376 "gram.y" 2076| 0| { 2077| 0| iface->UnrestrictedUnicast = (yyvsp[-1].num); 2078| 0| } 2079| 0|#line 2080 "gram.c" 2080| 0| break; 2081| | 2082| 0| case 48: /* ifaceval: T_AdvRASolicitedUnicast SWITCH ';' */ ------------------ | Branch (2082:3): [True: 0, False: 0] ------------------ 2083| 0|#line 380 "gram.y" 2084| 0| { 2085| 0| iface->AdvRASolicitedUnicast = (yyvsp[-1].num); 2086| 0| } 2087| 0|#line 2088 "gram.c" 2088| 0| break; 2089| | 2090| 0| case 49: /* ifaceval: T_AdvCaptivePortalAPI STRING ';' */ ------------------ | Branch (2090:3): [True: 0, False: 0] ------------------ 2091| 0|#line 384 "gram.y" 2092| 0| { 2093| 0| const char *source = (yyvsp[-1].str); 2094| 0| size_t len = strlen(source); 2095| | 2096| 0| if (iface->AdvCaptivePortalAPI) { ------------------ | Branch (2096:8): [True: 0, False: 0] ------------------ 2097| 0| flog(LOG_WARNING, "warning: AdvCaptivePortalAPI specified twice for interface " 2098| 0| "%s in %s, line %d", iface->props.name, filename, num_lines); 2099| | 2100| 0| free(iface->AdvCaptivePortalAPI); 2101| 0| iface->AdvCaptivePortalAPI = NULL; 2102| 0| } 2103| | 2104| | /* trim double-quotes from start and end of string */ 2105| 0| if ((len > 0) && (source[0] == '"')) { ------------------ | Branch (2105:8): [True: 0, False: 0] | Branch (2105:21): [True: 0, False: 0] ------------------ 2106| 0| source++; 2107| 0| len--; 2108| 0| } 2109| 0| if ((len > 0) && (source[len-1] == '"')) { ------------------ | Branch (2109:8): [True: 0, False: 0] | Branch (2109:21): [True: 0, False: 0] ------------------ 2110| 0| len--; 2111| 0| } 2112| | 2113| 0| if (len <= 0) { ------------------ | Branch (2113:8): [True: 0, False: 0] ------------------ 2114| 0| flog(LOG_ERR, "AdvCaptivePortalAPI empty URL specified for interface %s.", iface->props.name); 2115| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2116| 0| } 2117| | 2118| 0| iface->AdvCaptivePortalAPI = strndup(source, len); 2119| | 2120| 0| if (!iface->AdvCaptivePortalAPI) { ------------------ | Branch (2120:8): [True: 0, False: 0] ------------------ 2121| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2122| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2123| 0| } 2124| 0| } 2125| 0|#line 2126 "gram.c" 2126| 0| break; 2127| | 2128| 0| case 50: /* ifaceval: T_AdvMobRtrSupportFlag SWITCH ';' */ ------------------ | Branch (2128:3): [True: 0, False: 0] ------------------ 2129| 0|#line 418 "gram.y" 2130| 0| { 2131| 0| iface->mipv6.AdvMobRtrSupportFlag = (yyvsp[-1].num); 2132| 0| } 2133| 0|#line 2134 "gram.c" 2134| 0| break; 2135| | 2136| 0| case 51: /* clientslist: T_CLIENTS '{' v6addrlist_clients '}' ';' */ ------------------ | Branch (2136:3): [True: 0, False: 0] ------------------ 2137| 0|#line 424 "gram.y" 2138| 0| { 2139| 0| (yyval.ainfo) = (yyvsp[-2].ainfo); 2140| 0| } 2141| 0|#line 2142 "gram.c" 2142| 0| break; 2143| | 2144| 0| case 52: /* v6addrlist_clients: IPV6ADDR ';' */ ------------------ | Branch (2144:3): [True: 0, False: 0] ------------------ 2145| 0|#line 430 "gram.y" 2146| 0| { 2147| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2148| 0| if (new == NULL) { ------------------ | Branch (2148:8): [True: 0, False: 0] ------------------ 2149| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2150| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2151| 0| } 2152| | 2153| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2154| 0| new->ignored = 0; 2155| 0| (yyval.ainfo) = new; 2156| 0| } 2157| 0|#line 2158 "gram.c" 2158| 0| break; 2159| | 2160| 0| case 53: /* v6addrlist_clients: NOT_IPV6ADDR ';' */ ------------------ | Branch (2160:3): [True: 0, False: 0] ------------------ 2161| 0|#line 442 "gram.y" 2162| 0| { 2163| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2164| 0| if (new == NULL) { ------------------ | Branch (2164:8): [True: 0, False: 0] ------------------ 2165| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2166| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2167| 0| } 2168| | 2169| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2170| 0| new->ignored = 1; 2171| 0| (yyval.ainfo) = new; 2172| 0| } 2173| 0|#line 2174 "gram.c" 2174| 0| break; 2175| | 2176| 0| case 54: /* v6addrlist_clients: v6addrlist_clients IPV6ADDR ';' */ ------------------ | Branch (2176:3): [True: 0, False: 0] ------------------ 2177| 0|#line 454 "gram.y" 2178| 0| { 2179| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2180| 0| if (new == NULL) { ------------------ | Branch (2180:8): [True: 0, False: 0] ------------------ 2181| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2182| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2183| 0| } 2184| | 2185| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2186| 0| new->ignored = 0; 2187| 0| new->next = (yyvsp[-2].ainfo); 2188| 0| (yyval.ainfo) = new; 2189| 0| } 2190| 0|#line 2191 "gram.c" 2191| 0| break; 2192| | 2193| 0| case 55: /* v6addrlist_clients: v6addrlist_clients NOT_IPV6ADDR ';' */ ------------------ | Branch (2193:3): [True: 0, False: 0] ------------------ 2194| 0|#line 467 "gram.y" 2195| 0| { 2196| 0| struct Clients *new = calloc(1, sizeof(struct Clients)); 2197| 0| if (new == NULL) { ------------------ | Branch (2197:8): [True: 0, False: 0] ------------------ 2198| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2199| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2200| 0| } 2201| | 2202| 0| memcpy(&(new->Address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2203| 0| new->ignored = 1; 2204| 0| new->next = (yyvsp[-2].ainfo); 2205| 0| (yyval.ainfo) = new; 2206| 0| } 2207| 0|#line 2208 "gram.c" 2208| 0| break; 2209| | 2210| 0| case 56: /* rasrcaddresslist: T_RASRCADDRESS '{' v6addrlist_rasrcaddress '}' ';' */ ------------------ | Branch (2210:3): [True: 0, False: 0] ------------------ 2211| 0|#line 482 "gram.y" 2212| 0| { 2213| 0| (yyval.rasrcaddressinfo) = (yyvsp[-2].rasrcaddressinfo); 2214| 0| } 2215| 0|#line 2216 "gram.c" 2216| 0| break; 2217| | 2218| 0| case 57: /* v6addrlist_rasrcaddress: IPV6ADDR ';' */ ------------------ | Branch (2218:3): [True: 0, False: 0] ------------------ 2219| 0|#line 488 "gram.y" 2220| 0| { 2221| 0| struct AdvRASrcAddress *new = calloc(1, sizeof(struct AdvRASrcAddress)); 2222| 0| if (new == NULL) { ------------------ | Branch (2222:8): [True: 0, False: 0] ------------------ 2223| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2224| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2225| 0| } 2226| | 2227| 0| memcpy(&(new->address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2228| 0| (yyval.rasrcaddressinfo) = new; 2229| 0| } 2230| 0|#line 2231 "gram.c" 2231| 0| break; 2232| | 2233| 0| case 58: /* v6addrlist_rasrcaddress: v6addrlist_rasrcaddress IPV6ADDR ';' */ ------------------ | Branch (2233:3): [True: 0, False: 0] ------------------ 2234| 0|#line 499 "gram.y" 2235| 0| { 2236| 0| struct AdvRASrcAddress *new = calloc(1, sizeof(struct AdvRASrcAddress)); 2237| 0| if (new == NULL) { ------------------ | Branch (2237:8): [True: 0, False: 0] ------------------ 2238| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2239| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2240| 0| } 2241| | 2242| 0| memcpy(&(new->address), (yyvsp[-1].addr), sizeof(struct in6_addr)); 2243| 0| new->next = (yyvsp[-2].rasrcaddressinfo); 2244| 0| (yyval.rasrcaddressinfo) = new; 2245| 0| } 2246| 0|#line 2247 "gram.c" 2247| 0| break; 2248| | 2249| 0| case 59: /* nat64prefixdef: nat64prefixhead optional_nat64prefixplist ';' */ ------------------ | Branch (2249:3): [True: 0, False: 0] ------------------ 2250| 0|#line 513 "gram.y" 2251| 0| { 2252| 0| if (nat64prefix) { ------------------ | Branch (2252:8): [True: 0, False: 0] ------------------ 2253| | 2254| 0| if (nat64prefix->AdvValidLifetime > DFLT_NAT64MaxValidLifetime) ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ | Branch (2254:9): [True: 0, False: 0] ------------------ 2255| 0| { 2256| 0| flog(LOG_ERR, "AdvValidLifetime must be " 2257| 0| "smaller or equal to %d in %s, line %d", 2258| 0| DFLT_NAT64MaxValidLifetime, filename, num_lines); ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ 2259| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2260| 0| } 2261| 0| nat64prefix->curr_validlft = nat64prefix->AdvValidLifetime; 2262| 0| } 2263| 0| (yyval.nat64pinfo) = nat64prefix; 2264| 0| nat64prefix = NULL; 2265| 0| } 2266| 0|#line 2267 "gram.c" 2267| 0| break; 2268| | 2269| 0| case 60: /* nat64prefixhead: T_NAT64PREFIX IPV6ADDR '/' NUMBER */ ------------------ | Branch (2269:3): [True: 0, False: 0] ------------------ 2270| 0|#line 531 "gram.y" 2271| 0| { 2272| 0| struct in6_addr zeroaddr; 2273| 0| memset(&zeroaddr, 0, sizeof(zeroaddr)); 2274| | 2275| 0| if (!memcmp((yyvsp[-2].addr), &zeroaddr, sizeof(struct in6_addr))) { ------------------ | Branch (2275:8): [True: 0, False: 0] ------------------ 2276| 0| flog(LOG_ERR, "invalid all-zeros nat64prefix in %s, line %d", filename, num_lines); 2277| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2278| 0| } 2279| | 2280| 0| nat64prefix = malloc(sizeof(struct NAT64Prefix)); 2281| | 2282| 0| if (nat64prefix == NULL) { ------------------ | Branch (2282:8): [True: 0, False: 0] ------------------ 2283| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2284| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2285| 0| } 2286| | 2287| 0| nat64prefix_init_defaults(nat64prefix, iface); 2288| | 2289| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 165| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2289:8): [True: 0, False: 0] ------------------ 2290| 0| { 2291| 0| flog(LOG_ERR, "invalid prefix length in %s, line %d", filename, num_lines); 2292| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2293| 0| } 2294| | 2295| | /* RFC8781, section 4: only prefix lengths of 96, 64, 56, 48, 40, and 32 bits are valid */ 2296| 0| switch ((yyvsp[0].num)) { 2297| 0| case 32: ------------------ | Branch (2297:4): [True: 0, False: 0] ------------------ 2298| 0| case 40: ------------------ | Branch (2298:4): [True: 0, False: 0] ------------------ 2299| 0| case 48: ------------------ | Branch (2299:4): [True: 0, False: 0] ------------------ 2300| 0| case 56: ------------------ | Branch (2300:4): [True: 0, False: 0] ------------------ 2301| 0| case 64: ------------------ | Branch (2301:4): [True: 0, False: 0] ------------------ 2302| 0| case 96: ------------------ | Branch (2302:4): [True: 0, False: 0] ------------------ 2303| 0| break; 2304| 0| default: ------------------ | Branch (2304:4): [True: 0, False: 0] ------------------ 2305| 0| flog(LOG_ERR, "only /96, /64, /56, /48, /40 and /32 are allowed for " 2306| 0| "nat64prefix in %s:%d", filename, num_lines); 2307| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2308| 0| } 2309| 0| nat64prefix->PrefixLen = (yyvsp[0].num); 2310| | 2311| 0| memcpy(&nat64prefix->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2312| 0| } 2313| 0|#line 2314 "gram.c" 2314| 0| break; 2315| | 2316| 0| case 66: /* nat64prefixparms: T_AdvValidLifetime NUMBER ';' */ ------------------ | Branch (2316:3): [True: 0, False: 0] ------------------ 2317| 0|#line 585 "gram.y" 2318| 0| { 2319| 0| if ((yyvsp[-1].num) > DFLT_NAT64MaxValidLifetime) ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ | Branch (2319:8): [True: 0, False: 0] ------------------ 2320| 0| { 2321| 0| flog(LOG_ERR, "maximum for NAT64 AdvValidLifetime is %d (in %s, line %d)", 2322| 0| DFLT_NAT64MaxValidLifetime, filename, num_lines); ------------------ | | 68| 0|#define DFLT_NAT64MaxValidLifetime 65528 /* seconds */ ------------------ 2323| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2324| 0| } 2325| 0| if (nat64prefix) { ------------------ | Branch (2325:8): [True: 0, False: 0] ------------------ 2326| 0| nat64prefix->AdvValidLifetime = (yyvsp[-1].num); 2327| 0| } 2328| 0| } 2329| 0|#line 2330 "gram.c" 2330| 0| break; 2331| | 2332| 0| case 67: /* ignoreprefixlist: T_AUTOIGNOREPREFIX '{' ignoreprefixes '}' ';' */ ------------------ | Branch (2332:3): [True: 0, False: 0] ------------------ 2333| 0|#line 599 "gram.y" 2334| 0| { 2335| 0| (yyval.igpinfo) = (yyvsp[-2].igpinfo); 2336| 0| } 2337| 0|#line 2338 "gram.c" 2338| 0| break; 2339| | 2340| 0| case 68: /* ignoreprefixes: IPV6ADDR '/' NUMBER ';' */ ------------------ | Branch (2340:3): [True: 0, False: 0] ------------------ 2341| 0|#line 605 "gram.y" 2342| 0| { 2343| 0| struct AutogenIgnorePrefix *new = calloc(1, sizeof(struct AutogenIgnorePrefix)); 2344| 0| if (new == NULL) { ------------------ | Branch (2344:8): [True: 0, False: 0] ------------------ 2345| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2346| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2347| 0| } 2348| | 2349| 0| memcpy(&(new->Prefix), (yyvsp[-3].addr), sizeof(struct in6_addr)); 2350| | 2351| | // Create subnet mask from CIDR notation 2352| 0| int fullOctets = (yyvsp[-1].num) / 8; 2353| 0| for (int i = 0; i < fullOctets; ++i) { ------------------ | Branch (2353:20): [True: 0, False: 0] ------------------ 2354| 0| new->Mask.s6_addr[i] = 0xff; 2355| 0| } 2356| | 2357| 0| if (fullOctets != 16) { ------------------ | Branch (2357:8): [True: 0, False: 0] ------------------ 2358| 0| new->Mask.s6_addr[fullOctets] = ~(1 << (8 - (yyvsp[-1].num) % 8)) + 1; 2359| 0| } 2360| | 2361| 0| (yyval.igpinfo) = new; 2362| 0| } 2363| 0|#line 2364 "gram.c" 2364| 0| break; 2365| | 2366| 0| case 69: /* ignoreprefixes: ignoreprefixes IPV6ADDR '/' NUMBER ';' */ ------------------ | Branch (2366:3): [True: 0, False: 0] ------------------ 2367| 0|#line 627 "gram.y" 2368| 0| { 2369| 0| struct AutogenIgnorePrefix *new = calloc(1, sizeof(struct AutogenIgnorePrefix)); 2370| 0| if (new == NULL) { ------------------ | Branch (2370:8): [True: 0, False: 0] ------------------ 2371| 0| flog(LOG_CRIT, "calloc failed: %s", strerror(errno)); 2372| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2373| 0| } 2374| | 2375| 0| memcpy(&(new->Prefix), (yyvsp[-3].addr), sizeof(struct in6_addr)); 2376| | 2377| | // Create subnet mask from CIDR notation 2378| 0| int fullOctets = (yyvsp[-1].num) / 8; 2379| 0| for (int i = 0; i < fullOctets; ++i) { ------------------ | Branch (2379:20): [True: 0, False: 0] ------------------ 2380| 0| new->Mask.s6_addr[i] = 0xff; 2381| 0| } 2382| | 2383| 0| if (fullOctets != 16) { ------------------ | Branch (2383:8): [True: 0, False: 0] ------------------ 2384| 0| new->Mask.s6_addr[fullOctets] = ~(1 << (8 - (yyvsp[-1].num) % 8)) + 1; 2385| 0| } 2386| | 2387| 0| new->next = (yyvsp[-4].igpinfo); 2388| 0| (yyval.igpinfo) = new; 2389| 0| } 2390| 0|#line 2391 "gram.c" 2391| 0| break; 2392| | 2393| 0| case 70: /* prefixdef: prefixhead optional_prefixplist ';' */ ------------------ | Branch (2393:3): [True: 0, False: 0] ------------------ 2394| 0|#line 652 "gram.y" 2395| 0| { 2396| 0| if (prefix) { ------------------ | Branch (2396:8): [True: 0, False: 0] ------------------ 2397| | 2398| 0| if (prefix->AdvPreferredLifetime > prefix->AdvValidLifetime) ------------------ | Branch (2398:9): [True: 0, False: 0] ------------------ 2399| 0| { 2400| 0| flog(LOG_ERR, "AdvValidLifetime must be " 2401| 0| "greater than or equal to AdvPreferredLifetime in %s, line %d", 2402| 0| filename, num_lines); 2403| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2404| 0| } 2405| | 2406| 0| if ( prefix->if6[0] ) ------------------ | Branch (2406:10): [True: 0, False: 0] ------------------ 2407| 0| { 2408| 0| if (prefix->PrefixLen != 64) { ------------------ | Branch (2408:10): [True: 0, False: 0] ------------------ 2409| 0| flog(LOG_ERR, "only /64 is allowed with Base6Interface. %s:%d", filename, num_lines); 2410| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2411| 0| } 2412| 0| } 2413| 0| } 2414| 0| (yyval.pinfo) = prefix; 2415| 0| prefix = NULL; 2416| 0| } 2417| 0|#line 2418 "gram.c" 2418| 0| break; 2419| | 2420| 0| case 71: /* prefixhead: T_PREFIX IPV6ADDR '/' NUMBER */ ------------------ | Branch (2420:3): [True: 0, False: 0] ------------------ 2421| 0|#line 677 "gram.y" 2422| 0| { 2423| 0| struct in6_addr zeroaddr; 2424| 0| memset(&zeroaddr, 0, sizeof(zeroaddr)); 2425| | 2426| |#ifndef HAVE_IFADDRS_H // all-zeros prefix is a way to tell us to get the prefix from the interface config 2427| | if (!memcmp((yyvsp[-2].addr), &zeroaddr, sizeof(struct in6_addr))) { 2428| | flog(LOG_WARNING, "invalid all-zeros prefix in %s, line %d", filename, num_lines); 2429| | } 2430| |#endif 2431| 0| prefix = malloc(sizeof(struct AdvPrefix)); 2432| | 2433| 0| if (prefix == NULL) { ------------------ | Branch (2433:8): [True: 0, False: 0] ------------------ 2434| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2435| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2436| 0| } 2437| | 2438| 0| prefix_init_defaults(prefix); 2439| | 2440| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 165| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2440:8): [True: 0, False: 0] ------------------ 2441| 0| { 2442| 0| flog(LOG_ERR, "invalid prefix length in %s, line %d", filename, num_lines); 2443| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2444| 0| } 2445| | 2446| 0| prefix->PrefixLen = (yyvsp[0].num); 2447| | 2448| 0| memcpy(&prefix->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2449| 0| } 2450| 0|#line 2451 "gram.c" 2451| 0| break; 2452| | 2453| 0| case 77: /* prefixparms: T_AdvOnLink SWITCH ';' */ ------------------ | Branch (2453:3): [True: 0, False: 0] ------------------ 2454| 0|#line 717 "gram.y" 2455| 0| { 2456| 0| if (prefix) { ------------------ | Branch (2456:8): [True: 0, False: 0] ------------------ 2457| 0| prefix->AdvOnLinkFlag = (yyvsp[-1].num); 2458| 0| } 2459| 0| } 2460| 0|#line 2461 "gram.c" 2461| 0| break; 2462| | 2463| 0| case 78: /* prefixparms: T_AdvAutonomous SWITCH ';' */ ------------------ | Branch (2463:3): [True: 0, False: 0] ------------------ 2464| 0|#line 723 "gram.y" 2465| 0| { 2466| 0| if (prefix) { ------------------ | Branch (2466:8): [True: 0, False: 0] ------------------ 2467| 0| prefix->AdvAutonomousFlag = (yyvsp[-1].num); 2468| 0| } 2469| 0| } 2470| 0|#line 2471 "gram.c" 2471| 0| break; 2472| | 2473| 0| case 79: /* prefixparms: T_AdvRouterAddr SWITCH ';' */ ------------------ | Branch (2473:3): [True: 0, False: 0] ------------------ 2474| 0|#line 729 "gram.y" 2475| 0| { 2476| 0| if (prefix) { ------------------ | Branch (2476:8): [True: 0, False: 0] ------------------ 2477| 0| prefix->AdvRouterAddr = (yyvsp[-1].num); 2478| 0| } 2479| 0| } 2480| 0|#line 2481 "gram.c" 2481| 0| break; 2482| | 2483| 0| case 80: /* prefixparms: T_AdvDHCPv6PDPreferred SWITCH ';' */ ------------------ | Branch (2483:3): [True: 0, False: 0] ------------------ 2484| 0|#line 735 "gram.y" 2485| 0| { 2486| 0| if (prefix) { ------------------ | Branch (2486:8): [True: 0, False: 0] ------------------ 2487| 0| prefix->AdvDHCPv6PDPreferredFlag = (yyvsp[-1].num); 2488| 0| } 2489| 0| } 2490| 0|#line 2491 "gram.c" 2491| 0| break; 2492| | 2493| 0| case 81: /* prefixparms: T_AdvValidLifetime number_or_infinity ';' */ ------------------ | Branch (2493:3): [True: 0, False: 0] ------------------ 2494| 0|#line 741 "gram.y" 2495| 0| { 2496| 0| if (prefix) { ------------------ | Branch (2496:8): [True: 0, False: 0] ------------------ 2497| 0| prefix->AdvValidLifetime = (yyvsp[-1].num); 2498| 0| prefix->curr_validlft = (yyvsp[-1].num); 2499| 0| } 2500| 0| } 2501| 0|#line 2502 "gram.c" 2502| 0| break; 2503| | 2504| 0| case 82: /* prefixparms: T_AdvPreferredLifetime number_or_infinity ';' */ ------------------ | Branch (2504:3): [True: 0, False: 0] ------------------ 2505| 0|#line 748 "gram.y" 2506| 0| { 2507| 0| if (prefix) { ------------------ | Branch (2507:8): [True: 0, False: 0] ------------------ 2508| 0| prefix->AdvPreferredLifetime = (yyvsp[-1].num); 2509| 0| prefix->curr_preferredlft = (yyvsp[-1].num); 2510| 0| } 2511| 0| } 2512| 0|#line 2513 "gram.c" 2513| 0| break; 2514| | 2515| 0| case 83: /* prefixparms: T_DeprecatePrefix SWITCH ';' */ ------------------ | Branch (2515:3): [True: 0, False: 0] ------------------ 2516| 0|#line 755 "gram.y" 2517| 0| { 2518| 0| if (prefix) { ------------------ | Branch (2518:8): [True: 0, False: 0] ------------------ 2519| 0| prefix->DeprecatePrefixFlag = (yyvsp[-1].num); 2520| 0| } 2521| 0| } 2522| 0|#line 2523 "gram.c" 2523| 0| break; 2524| | 2525| 0| case 84: /* prefixparms: T_DecrementLifetimes SWITCH ';' */ ------------------ | Branch (2525:3): [True: 0, False: 0] ------------------ 2526| 0|#line 761 "gram.y" 2527| 0| { 2528| 0| if (prefix) { ------------------ | Branch (2528:8): [True: 0, False: 0] ------------------ 2529| 0| prefix->DecrementLifetimesFlag = (yyvsp[-1].num); 2530| 0| } 2531| 0| } 2532| 0|#line 2533 "gram.c" 2533| 0| break; 2534| | 2535| 0| case 85: /* prefixparms: T_Base6Interface name ';' */ ------------------ | Branch (2535:3): [True: 0, False: 0] ------------------ 2536| 0|#line 767 "gram.y" 2537| 0| { 2538| |#ifndef HAVE_IFADDRS_H 2539| | flog(LOG_ERR, "Base6Interface not supported in %s, line %d", filename, num_lines); 2540| | ABORT; 2541| |#else 2542| 0| if (prefix) { ------------------ | Branch (2542:8): [True: 0, False: 0] ------------------ 2543| 0| dlog(LOG_DEBUG, 4, "using prefixes on interface %s for prefixes on interface %s", (yyvsp[-1].str), iface->props.name); 2544| 0| memset(&prefix->if6, 0, sizeof(prefix->if6)); 2545| 0| strlcpy(prefix->if6, (yyvsp[-1].str), sizeof(prefix->if6)); 2546| 0| } 2547| 0|#endif 2548| 0| } 2549| 0|#line 2550 "gram.c" 2550| 0| break; 2551| | 2552| 0| case 86: /* prefixparms: T_Base6to4Interface name ';' */ ------------------ | Branch (2552:3): [True: 0, False: 0] ------------------ 2553| 0|#line 781 "gram.y" 2554| 0| { 2555| |#ifndef HAVE_IFADDRS_H 2556| | flog(LOG_ERR, "Base6to4Interface not supported in %s, line %d", filename, num_lines); 2557| | ABORT; 2558| |#else 2559| 0| if (prefix) { ------------------ | Branch (2559:8): [True: 0, False: 0] ------------------ 2560| 0| dlog(LOG_DEBUG, 4, "using interface %s for 6to4 prefixes on interface %s", (yyvsp[-1].str), iface->props.name); 2561| 0| memset(&prefix->if6to4, 0, sizeof(prefix->if6to4)); 2562| 0| strlcpy(prefix->if6to4, (yyvsp[-1].str), sizeof(prefix->if6to4)); 2563| 0| } 2564| 0|#endif 2565| 0| } 2566| 0|#line 2567 "gram.c" 2567| 0| break; 2568| | 2569| 0| case 87: /* routedef: routehead '{' optional_routeplist '}' ';' */ ------------------ | Branch (2569:3): [True: 0, False: 0] ------------------ 2570| 0|#line 796 "gram.y" 2571| 0| { 2572| 0| (yyval.rinfo) = route; 2573| 0| route = NULL; 2574| 0| } 2575| 0|#line 2576 "gram.c" 2576| 0| break; 2577| | 2578| 0| case 88: /* routehead: T_ROUTE IPV6ADDR '/' NUMBER */ ------------------ | Branch (2578:3): [True: 0, False: 0] ------------------ 2579| 0|#line 804 "gram.y" 2580| 0| { 2581| 0| route = malloc(sizeof(struct AdvRoute)); 2582| | 2583| 0| if (route == NULL) { ------------------ | Branch (2583:8): [True: 0, False: 0] ------------------ 2584| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2585| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2586| 0| } 2587| | 2588| 0| route_init_defaults(route, iface); 2589| | 2590| 0| if ((yyvsp[0].num) > MAX_PrefixLen) ------------------ | | 165| 0|#define MAX_PrefixLen 128 ------------------ | Branch (2590:8): [True: 0, False: 0] ------------------ 2591| 0| { 2592| 0| flog(LOG_ERR, "invalid route prefix length in %s, line %d", filename, num_lines); 2593| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2594| 0| } 2595| | 2596| 0| route->PrefixLen = (yyvsp[0].num); 2597| | 2598| 0| memcpy(&route->Prefix, (yyvsp[-2].addr), sizeof(struct in6_addr)); 2599| 0| } 2600| 0|#line 2601 "gram.c" 2601| 0| break; 2602| | 2603| 0| case 93: /* routeparms: T_AdvRoutePreference SIGNEDNUMBER ';' */ ------------------ | Branch (2603:3): [True: 0, False: 0] ------------------ 2604| 0|#line 837 "gram.y" 2605| 0| { 2606| 0| route->AdvRoutePreference = (yyvsp[-1].snum); 2607| 0| } 2608| 0|#line 2609 "gram.c" 2609| 0| break; 2610| | 2611| 0| case 94: /* routeparms: T_AdvRouteLifetime number_or_infinity ';' */ ------------------ | Branch (2611:3): [True: 0, False: 0] ------------------ 2612| 0|#line 841 "gram.y" 2613| 0| { 2614| 0| route->AdvRouteLifetime = (yyvsp[-1].num); 2615| 0| } 2616| 0|#line 2617 "gram.c" 2617| 0| break; 2618| | 2619| 0| case 95: /* routeparms: T_RemoveRoute SWITCH ';' */ ------------------ | Branch (2619:3): [True: 0, False: 0] ------------------ 2620| 0|#line 845 "gram.y" 2621| 0| { 2622| 0| route->RemoveRouteFlag = (yyvsp[-1].num); 2623| 0| } 2624| 0|#line 2625 "gram.c" 2625| 0| break; 2626| | 2627| 0| case 96: /* rdnssdef: rdnsshead '{' optional_rdnssplist '}' ';' */ ------------------ | Branch (2627:3): [True: 0, False: 0] ------------------ 2628| 0|#line 851 "gram.y" 2629| 0| { 2630| 0| (yyval.rdnssinfo) = rdnss; 2631| 0| rdnss = NULL; 2632| 0| } 2633| 0|#line 2634 "gram.c" 2634| 0| break; 2635| | 2636| 0| case 99: /* rdnssaddr: IPV6ADDR */ ------------------ | Branch (2636:3): [True: 0, False: 0] ------------------ 2637| 0|#line 862 "gram.y" 2638| 0| { 2639| 0| if (!rdnss) { ------------------ | Branch (2639:8): [True: 0, False: 0] ------------------ 2640| | /* first IP found */ 2641| 0| rdnss = malloc(sizeof(struct AdvRDNSS)); 2642| | 2643| 0| if (rdnss == NULL) { ------------------ | Branch (2643:9): [True: 0, False: 0] ------------------ 2644| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2645| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2646| 0| } 2647| | 2648| 0| rdnss_init_defaults(rdnss, iface); 2649| 0| } 2650| | 2651| 0| rdnss->AdvRDNSSNumber++; 2652| 0| if (rdnss->AdvRDNSSNumber > 127) { ------------------ | Branch (2652:8): [True: 0, False: 0] ------------------ 2653| 0| flog(LOG_CRIT, "Too many RDNSS servers specified - upper limit is 127 based on RDNSSI length field being uint8, RFC8106, section 5.1"); 2654| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2655| 0| } 2656| 0| rdnss->AdvRDNSSAddr = 2657| 0| realloc(rdnss->AdvRDNSSAddr, 2658| 0| rdnss->AdvRDNSSNumber * sizeof(struct in6_addr)); 2659| 0| if (rdnss->AdvRDNSSAddr == NULL) { ------------------ | Branch (2659:8): [True: 0, False: 0] ------------------ 2660| 0| flog(LOG_CRIT, "realloc failed: %s", strerror(errno)); 2661| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2662| 0| } 2663| 0| memcpy(&rdnss->AdvRDNSSAddr[rdnss->AdvRDNSSNumber - 1], (yyvsp[0].addr), sizeof(struct in6_addr)); 2664| 0| } 2665| 0|#line 2666 "gram.c" 2666| 0| break; 2667| | 2668| 0| case 100: /* rdnsshead: T_RDNSS rdnssaddrs */ ------------------ | Branch (2668:3): [True: 0, False: 0] ------------------ 2669| 0|#line 892 "gram.y" 2670| 0| { 2671| 0| if (!rdnss) { ------------------ | Branch (2671:8): [True: 0, False: 0] ------------------ 2672| 0| flog(LOG_CRIT, "no address specified in RDNSS section"); 2673| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2674| 0| } 2675| 0| } 2676| 0|#line 2677 "gram.c" 2677| 0| break; 2678| | 2679| 0| case 105: /* rdnssparms: T_AdvRDNSSPreference NUMBER ';' */ ------------------ | Branch (2679:3): [True: 0, False: 0] ------------------ 2680| 0|#line 910 "gram.y" 2681| 0| { 2682| 0| flog(LOG_WARNING, "ignoring deprecated RDNSS preference"); 2683| 0| } 2684| 0|#line 2685 "gram.c" 2685| 0| break; 2686| | 2687| 0| case 106: /* rdnssparms: T_AdvRDNSSOpenFlag SWITCH ';' */ ------------------ | Branch (2687:3): [True: 0, False: 0] ------------------ 2688| 0|#line 914 "gram.y" 2689| 0| { 2690| 0| flog(LOG_WARNING, "ignoring deprecated RDNSS open flag"); 2691| 0| } 2692| 0|#line 2693 "gram.c" 2693| 0| break; 2694| | 2695| 0| case 107: /* rdnssparms: T_AdvRDNSSLifetime number_or_infinity ';' */ ------------------ | Branch (2695:3): [True: 0, False: 0] ------------------ 2696| 0|#line 918 "gram.y" 2697| 0| { 2698| 0| rdnss->AdvRDNSSLifetime = (yyvsp[-1].num); 2699| 0| } 2700| 0|#line 2701 "gram.c" 2701| 0| break; 2702| | 2703| 0| case 108: /* rdnssparms: T_FlushRDNSS SWITCH ';' */ ------------------ | Branch (2703:3): [True: 0, False: 0] ------------------ 2704| 0|#line 922 "gram.y" 2705| 0| { 2706| 0| rdnss->FlushRDNSSFlag = (yyvsp[-1].num); 2707| 0| } 2708| 0|#line 2709 "gram.c" 2709| 0| break; 2710| | 2711| 0| case 109: /* dnssldef: dnsslhead '{' optional_dnsslplist '}' ';' */ ------------------ | Branch (2711:3): [True: 0, False: 0] ------------------ 2712| 0|#line 928 "gram.y" 2713| 0| { 2714| 0| (yyval.dnsslinfo) = dnssl; 2715| 0| dnssl = NULL; 2716| 0| } 2717| 0|#line 2718 "gram.c" 2718| 0| break; 2719| | 2720| 0| case 112: /* dnsslsuffix: STRING */ ------------------ | Branch (2720:3): [True: 0, False: 0] ------------------ 2721| 0|#line 939 "gram.y" 2722| 0| { 2723| 0| char *ch; 2724| 0| for (ch = (yyvsp[0].str);*ch != '\0';ch++) { ------------------ | Branch (2724:29): [True: 0, False: 0] ------------------ 2725| 0| if (*ch >= 'A' && *ch <= 'Z') ------------------ | Branch (2725:9): [True: 0, False: 0] | Branch (2725:23): [True: 0, False: 0] ------------------ 2726| 0| continue; 2727| 0| if (*ch >= 'a' && *ch <= 'z') ------------------ | Branch (2727:9): [True: 0, False: 0] | Branch (2727:23): [True: 0, False: 0] ------------------ 2728| 0| continue; 2729| 0| if (*ch >= '0' && *ch <= '9') ------------------ | Branch (2729:9): [True: 0, False: 0] | Branch (2729:23): [True: 0, False: 0] ------------------ 2730| 0| continue; 2731| 0| if (*ch == '-' || *ch == '.') ------------------ | Branch (2731:9): [True: 0, False: 0] | Branch (2731:23): [True: 0, False: 0] ------------------ 2732| 0| continue; 2733| | 2734| 0| flog(LOG_CRIT, "invalid domain suffix specified"); 2735| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2736| 0| } 2737| | 2738| 0| if (!dnssl) { ------------------ | Branch (2738:8): [True: 0, False: 0] ------------------ 2739| | /* first domain found */ 2740| 0| dnssl = malloc(sizeof(struct AdvDNSSL)); 2741| | 2742| 0| if (dnssl == NULL) { ------------------ | Branch (2742:9): [True: 0, False: 0] ------------------ 2743| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2744| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2745| 0| } 2746| | 2747| 0| dnssl_init_defaults(dnssl, iface); 2748| 0| } 2749| | 2750| 0| dnssl->AdvDNSSLNumber++; 2751| 0| dnssl->AdvDNSSLSuffixes = 2752| 0| realloc(dnssl->AdvDNSSLSuffixes, 2753| 0| dnssl->AdvDNSSLNumber * sizeof(char*)); 2754| 0| if (dnssl->AdvDNSSLSuffixes == NULL) { ------------------ | Branch (2754:8): [True: 0, False: 0] ------------------ 2755| 0| flog(LOG_CRIT, "realloc failed: %s", strerror(errno)); 2756| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2757| 0| } 2758| | 2759| 0| dnssl->AdvDNSSLSuffixes[dnssl->AdvDNSSLNumber - 1] = strdup((yyvsp[0].str)); 2760| 0| } 2761| 0|#line 2762 "gram.c" 2762| 0| break; 2763| | 2764| 0| case 113: /* dnsslhead: T_DNSSL dnsslsuffixes */ ------------------ | Branch (2764:3): [True: 0, False: 0] ------------------ 2765| 0|#line 981 "gram.y" 2766| 0| { 2767| 0| if (!dnssl) { ------------------ | Branch (2767:8): [True: 0, False: 0] ------------------ 2768| 0| flog(LOG_CRIT, "no domain specified in DNSSL section"); 2769| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2770| 0| } 2771| 0| } 2772| 0|#line 2773 "gram.c" 2773| 0| break; 2774| | 2775| 0| case 118: /* dnsslparms: T_AdvDNSSLLifetime number_or_infinity ';' */ ------------------ | Branch (2775:3): [True: 0, False: 0] ------------------ 2776| 0|#line 999 "gram.y" 2777| 0| { 2778| 0| dnssl->AdvDNSSLLifetime = (yyvsp[-1].num); 2779| | 2780| 0| } 2781| 0|#line 2782 "gram.c" 2782| 0| break; 2783| | 2784| 0| case 119: /* dnsslparms: T_FlushDNSSL SWITCH ';' */ ------------------ | Branch (2784:3): [True: 0, False: 0] ------------------ 2785| 0|#line 1004 "gram.y" 2786| 0| { 2787| 0| dnssl->FlushDNSSLFlag = (yyvsp[-1].num); 2788| 0| } 2789| 0|#line 2790 "gram.c" 2790| 0| break; 2791| | 2792| 0| case 120: /* dnrdef: dnrhead '{' optional_dnrplist '}' ';' */ ------------------ | Branch (2792:3): [True: 0, False: 0] ------------------ 2793| 0|#line 1010 "gram.y" 2794| 0| { 2795| | /* RFC 9463 §6.1: Addr Length, ipv6-address(es), and SvcParams 2796| | * fields are not present in ADN-only mode. */ 2797| 0| if (dnr->AdvDNRNumber == 0 && ------------------ | Branch (2797:8): [True: 0, False: 0] ------------------ 2798| 0| (dnr->AdvDNRSvcAlpn || dnr->AdvDNRSvcPort || dnr->AdvDNRSvcDohpath)) { ------------------ | Branch (2798:9): [True: 0, False: 0] | Branch (2798:31): [True: 0, False: 0] | Branch (2798:53): [True: 0, False: 0] ------------------ 2799| 0| flog(LOG_ERR, "DNR entry for '%s' at %s, line %d has Svc options " 2800| 0| "but no AdvDNRAddr; Svc options are disallowed in ADN-only mode", 2801| 0| dnr->AdvDNRADN, filename, num_lines); 2802| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2803| 0| } 2804| | 2805| 0| (yyval.dnrinfo) = dnr; 2806| 0| dnr = NULL; 2807| 0| } 2808| 0|#line 2809 "gram.c" 2809| 0| break; 2810| | 2811| 0| case 121: /* dnrhead: T_DNR STRING */ ------------------ | Branch (2811:3): [True: 0, False: 0] ------------------ 2812| 0|#line 1027 "gram.y" 2813| 0| { 2814| 0| const char *source = (yyvsp[0].str); 2815| 0| size_t len = strlen(source); 2816| 0| int label_len = 0; 2817| | 2818| 0| dnr = malloc(sizeof(struct AdvDNR)); 2819| | 2820| 0| if (dnr == NULL) { ------------------ | Branch (2820:8): [True: 0, False: 0] ------------------ 2821| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2822| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2823| 0| } 2824| | 2825| 0| dnr_init_defaults(dnr, iface); 2826| | 2827| | /* Strip surrounding quotes if the ADN was given as a quoted string */ 2828| 0| if ((len > 0) && (source[0] == '"')) { ------------------ | Branch (2828:8): [True: 0, False: 0] | Branch (2828:21): [True: 0, False: 0] ------------------ 2829| 0| source++; 2830| 0| len--; 2831| 0| } 2832| 0| if ((len > 0) && (source[len-1] == '"')) { ------------------ | Branch (2832:8): [True: 0, False: 0] | Branch (2832:21): [True: 0, False: 0] ------------------ 2833| 0| len--; 2834| 0| } 2835| | 2836| 0| if (len <= 0) { ------------------ | Branch (2836:8): [True: 0, False: 0] ------------------ 2837| 0| flog(LOG_ERR, "DNR ADN is empty " 2838| 0| "at %s, line %d", filename, num_lines); 2839| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2840| 0| } 2841| 0| if (source[len-1] == '.') { ------------------ | Branch (2841:8): [True: 0, False: 0] ------------------ 2842| 0| flog(LOG_ERR, "DNR ADN has a trailing dot " 2843| 0| "at %s, line %d", filename, num_lines); 2844| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2845| 0| } 2846| | 2847| | /* Domain name validation from RFC 1035, Section 3.1 */ 2848| 0| if (len > 255) { ------------------ | Branch (2848:8): [True: 0, False: 0] ------------------ 2849| 0| flog(LOG_ERR, "DNR ADN total length is greater than 255 bytes " 2850| 0| "at %s, line %d", filename, num_lines); 2851| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2852| 0| } 2853| | 2854| 0| for (int i = 0; i < (int)len; i++) { ------------------ | Branch (2854:20): [True: 0, False: 0] ------------------ 2855| 0| if (source[i] == '.') { ------------------ | Branch (2855:9): [True: 0, False: 0] ------------------ 2856| 0| if (label_len == 0) { ------------------ | Branch (2856:10): [True: 0, False: 0] ------------------ 2857| 0| flog(LOG_ERR, "DNR ADN has an empty label " 2858| 0| "at %s, line %d", filename, num_lines); 2859| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2860| 0| } 2861| 0| label_len = 0; 2862| 0| } else { 2863| 0| if (label_len == 63) { ------------------ | Branch (2863:10): [True: 0, False: 0] ------------------ 2864| 0| flog(LOG_ERR, "DNR ADN has a label with > 63 bytes " 2865| 0| "at %s, line %d", filename, num_lines); 2866| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2867| 0| } 2868| 0| label_len++; 2869| 0| } 2870| 0| } 2871| | 2872| 0| dnr->AdvDNRADN = strndup(source, len); 2873| | 2874| 0| if (dnr->AdvDNRADN == NULL) { ------------------ | Branch (2874:8): [True: 0, False: 0] ------------------ 2875| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 2876| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2877| 0| } 2878| 0| } 2879| 0|#line 2880 "gram.c" 2880| 0| break; 2881| | 2882| 0| case 126: /* dnrparms: T_AdvDNRPriority NUMBER ';' */ ------------------ | Branch (2882:3): [True: 0, False: 0] ------------------ 2883| 0|#line 1104 "gram.y" 2884| 0| { 2885| 0| if ((yyvsp[-1].num) > UINT16_MAX) { ------------------ | Branch (2885:8): [True: 0, False: 0] ------------------ 2886| 0| flog(LOG_ERR, "AdvDNRPriority must be a 16-bit number, " 2887| 0| "got %u at %s, line %d", (yyvsp[-1].num), filename, num_lines); 2888| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2889| 0| } 2890| 0| dnr->AdvDNRPriority = (yyvsp[-1].num); 2891| 0| } 2892| 0|#line 2893 "gram.c" 2893| 0| break; 2894| | 2895| 0| case 127: /* dnrparms: T_AdvDNRLifetime number_or_infinity ';' */ ------------------ | Branch (2895:3): [True: 0, False: 0] ------------------ 2896| 0|#line 1113 "gram.y" 2897| 0| { 2898| 0| dnr->AdvDNRLifetime = (yyvsp[-1].num); 2899| 0| } 2900| 0|#line 2901 "gram.c" 2901| 0| break; 2902| | 2903| 0| case 128: /* dnrparms: T_FlushDNR SWITCH ';' */ ------------------ | Branch (2903:3): [True: 0, False: 0] ------------------ 2904| 0|#line 1117 "gram.y" 2905| 0| { 2906| 0| dnr->FlushDNRFlag = (yyvsp[-1].num); 2907| 0| } 2908| 0|#line 2909 "gram.c" 2909| 0| break; 2910| | 2911| 0| case 129: /* dnrparms: T_AdvDNRAddr IPV6ADDR ';' */ ------------------ | Branch (2911:3): [True: 0, False: 0] ------------------ 2912| 0|#line 1121 "gram.y" 2913| 0| { 2914| 0| dnr->AdvDNRNumber++; 2915| 0| if (dnr->AdvDNRNumber > (int)(UINT16_MAX / sizeof(struct in6_addr))) { ------------------ | Branch (2915:8): [True: 0, False: 0] ------------------ 2916| 0| flog(LOG_CRIT, "Too many DNR addresses specified - " 2917| 0| "upper limit is %"PRIu16" based on Addr Length field being uint16, " 2918| 0| "RFC9463, section 6.1", (uint16_t)(UINT16_MAX / sizeof(struct in6_addr))); 2919| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2920| 0| } 2921| 0| dnr->AdvDNRAddrs = 2922| 0| realloc(dnr->AdvDNRAddrs, 2923| 0| dnr->AdvDNRNumber * sizeof(struct in6_addr)); 2924| 0| if (dnr->AdvDNRAddrs == NULL) { ------------------ | Branch (2924:8): [True: 0, False: 0] ------------------ 2925| 0| flog(LOG_CRIT, "realloc failed: %s", strerror(errno)); 2926| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2927| 0| } 2928| | /* RFC 9463 §6.2: hosts MUST silently discard multicast and loopback addresses */ 2929| 0| if (IN6_IS_ADDR_MULTICAST((yyvsp[-1].addr)) || IN6_IS_ADDR_LOOPBACK((yyvsp[-1].addr))) { ------------------ | Branch (2929:8): [True: 0, False: 0] | Branch (2929:51): [True: 0, False: 0] ------------------ 2930| 0| flog(LOG_WARNING, "DNR address at %s, line %d is multicast or loopback; " 2931| 0| "hosts will discard it per RFC 9463 §6.2", 2932| 0| filename, num_lines); 2933| 0| } 2934| 0| memcpy(&dnr->AdvDNRAddrs[dnr->AdvDNRNumber - 1], (yyvsp[-1].addr), sizeof(struct in6_addr)); 2935| 0| } 2936| 0|#line 2937 "gram.c" 2937| 0| break; 2938| | 2939| 0| case 130: /* dnrparms: T_AdvDNRSvcPort NUMBER ';' */ ------------------ | Branch (2939:3): [True: 0, False: 0] ------------------ 2940| 0|#line 1145 "gram.y" 2941| 0| { 2942| 0| if ((yyvsp[-1].num) > UINT16_MAX) { ------------------ | Branch (2942:8): [True: 0, False: 0] ------------------ 2943| 0| flog(LOG_ERR, "AdvDNRSvcPort must be a 16-bit number, " 2944| 0| "got %u at %s, line %d", (yyvsp[-1].num), filename, num_lines); 2945| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2946| 0| } 2947| 0| dnr->AdvDNRSvcPort = (yyvsp[-1].num); 2948| 0| } 2949| 0|#line 2950 "gram.c" 2950| 0| break; 2951| | 2952| 0| case 131: /* dnrparms: T_AdvDNRSvcAlpn STRING ';' */ ------------------ | Branch (2952:3): [True: 0, False: 0] ------------------ 2953| 0|#line 1154 "gram.y" 2954| 0| { 2955| 0| const char *source = (yyvsp[-1].str); 2956| 0| size_t len = strlen(source); 2957| 0| int comma = 0; 2958| | 2959| 0| if (dnr->AdvDNRSvcAlpn != NULL) { ------------------ | Branch (2959:8): [True: 0, False: 0] ------------------ 2960| 0| flog(LOG_WARNING, "warning: AdvDNRSvcAlpn specified twice for DNR " 2961| 0| "at %s, line %d", filename, num_lines); 2962| 0| free(dnr->AdvDNRSvcAlpn); 2963| 0| dnr->AdvDNRSvcAlpn = NULL; 2964| 0| } 2965| | 2966| 0| if ((len > 0) && (source[0] == '"')) { ------------------ | Branch (2966:8): [True: 0, False: 0] | Branch (2966:21): [True: 0, False: 0] ------------------ 2967| 0| source++; 2968| 0| len--; 2969| 0| } 2970| 0| if ((len > 0) && (source[len-1] == '"')) { ------------------ | Branch (2970:8): [True: 0, False: 0] | Branch (2970:21): [True: 0, False: 0] ------------------ 2971| 0| len--; 2972| 0| } 2973| | 2974| 0| if (len <= 0) { ------------------ | Branch (2974:8): [True: 0, False: 0] ------------------ 2975| 0| flog(LOG_ERR, "AdvDNRSvcAlpn empty ALPN specified for DNR " 2976| 0| "at %s, line %d", filename, num_lines); 2977| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2978| 0| } 2979| 0| if (source[0] == ',') { ------------------ | Branch (2979:8): [True: 0, False: 0] ------------------ 2980| 0| flog(LOG_ERR, "AdvDNRSvcAlpn has a leading comma " 2981| 0| "at %s, line %d", filename, num_lines); 2982| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2983| 0| } 2984| 0| if (source[len-1] == ',') { ------------------ | Branch (2984:8): [True: 0, False: 0] ------------------ 2985| 0| flog(LOG_ERR, "AdvDNRSvcAlpn has a trailing comma " 2986| 0| "at %s, line %d", filename, num_lines); 2987| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2988| 0| } 2989| 0| int token_len = 0; 2990| 0| for (int i = 0; i < (int)len; i++) { ------------------ | Branch (2990:20): [True: 0, False: 0] ------------------ 2991| 0| if (source[i] == '\\') { ------------------ | Branch (2991:9): [True: 0, False: 0] ------------------ 2992| 0| flog(LOG_ERR, "AdvDNRSvcAlpn contains '\\' " 2993| 0| "at %s, line %d", filename, num_lines); 2994| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 2995| 0| } 2996| 0| if (source[i] == ',') { ------------------ | Branch (2996:9): [True: 0, False: 0] ------------------ 2997| 0| if (comma) { ------------------ | Branch (2997:10): [True: 0, False: 0] ------------------ 2998| 0| flog(LOG_ERR, "AdvDNRSvcAlpn has an empty item (contains \",,\") " 2999| 0| "at %s, line %d", filename, num_lines); 3000| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3001| 0| } 3002| 0| comma = 1; 3003| 0| token_len = 0; 3004| 0| } else { 3005| 0| comma = 0; 3006| | /* RFC 9460 §7.1: each ALPN identifier is wire-encoded 3007| | * with a 1-byte length prefix, so it must be <= 255 bytes */ 3008| 0| if (++token_len > 255) { ------------------ | Branch (3008:10): [True: 0, False: 0] ------------------ 3009| 0| flog(LOG_ERR, "AdvDNRSvcAlpn item exceeds 255 bytes " 3010| 0| "at %s, line %d", filename, num_lines); 3011| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3012| 0| } 3013| 0| } 3014| 0| } 3015| | 3016| 0| dnr->AdvDNRSvcAlpn = strndup(source, len); 3017| | 3018| 0| if (dnr->AdvDNRSvcAlpn == NULL) { ------------------ | Branch (3018:8): [True: 0, False: 0] ------------------ 3019| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 3020| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3021| 0| } 3022| 0| } 3023| 0|#line 3024 "gram.c" 3024| 0| break; 3025| | 3026| 0| case 132: /* dnrparms: T_AdvDNRSvcDohpath STRING ';' */ ------------------ | Branch (3026:3): [True: 0, False: 0] ------------------ 3027| 0|#line 1224 "gram.y" 3028| 0| { 3029| 0| const char *source = (yyvsp[-1].str); 3030| 0| size_t len = strlen(source); 3031| | 3032| 0| if (dnr->AdvDNRSvcDohpath) { ------------------ | Branch (3032:8): [True: 0, False: 0] ------------------ 3033| 0| flog(LOG_WARNING, "warning: AdvDNRSvcDohpath specified twice for DNR " 3034| 0| "at %s, line %d", filename, num_lines); 3035| 0| free(dnr->AdvDNRSvcDohpath); 3036| 0| dnr->AdvDNRSvcDohpath = NULL; 3037| 0| } 3038| | 3039| 0| if ((len > 0) && (source[0] == '"')) { ------------------ | Branch (3039:8): [True: 0, False: 0] | Branch (3039:21): [True: 0, False: 0] ------------------ 3040| 0| source++; 3041| 0| len--; 3042| 0| } 3043| 0| if ((len > 0) && (source[len-1] == '"')) { ------------------ | Branch (3043:8): [True: 0, False: 0] | Branch (3043:21): [True: 0, False: 0] ------------------ 3044| 0| len--; 3045| 0| } 3046| 0| if (len <= 0) { ------------------ | Branch (3046:8): [True: 0, False: 0] ------------------ 3047| 0| flog(LOG_ERR, "AdvDNRSvcDohpath empty URL specified for DNR " 3048| 0| "at %s, line %d", filename, num_lines); 3049| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3050| 0| } 3051| | 3052| 0| if (strstr(source, "dns}") == NULL) { ------------------ | Branch (3052:8): [True: 0, False: 0] ------------------ 3053| 0| flog(LOG_WARNING, 3054| 0| "warning: AdvDNRSvcDohpath specified without 'dns' " 3055| 0| "template variable as required by RFC 9461, Section 5"); 3056| 0| } 3057| | 3058| 0| if (source[0] != '/') { ------------------ | Branch (3058:8): [True: 0, False: 0] ------------------ 3059| 0| flog(LOG_WARNING, "warning: AdvDNRSvcDohpath is not a URI Template " 3060| 0| "in relative form as required by RFC 9461, Section 5"); 3061| 0| } 3062| | 3063| 0| dnr->AdvDNRSvcDohpath = strndup(source, len); 3064| | 3065| 0| if (dnr->AdvDNRSvcDohpath == NULL) { ------------------ | Branch (3065:8): [True: 0, False: 0] ------------------ 3066| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 3067| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3068| 0| } 3069| 0| } 3070| 0|#line 3071 "gram.c" 3071| 0| break; 3072| | 3073| 0| case 133: /* lowpancodef: lowpancohead '{' optional_lowpancoplist '}' ';' */ ------------------ | Branch (3073:3): [True: 0, False: 0] ------------------ 3074| 0|#line 1269 "gram.y" 3075| 0| { 3076| 0| (yyval.lowpancoinfo) = lowpanco; 3077| 0| lowpanco = NULL; 3078| 0| } 3079| 0|#line 3080 "gram.c" 3080| 0| break; 3081| | 3082| 0| case 134: /* lowpancohead: T_LOWPANCO */ ------------------ | Branch (3082:3): [True: 0, False: 0] ------------------ 3083| 0|#line 1276 "gram.y" 3084| 0| { 3085| 0| lowpanco = malloc(sizeof(struct AdvLowpanCo)); 3086| | 3087| 0| if (lowpanco == NULL) { ------------------ | Branch (3087:8): [True: 0, False: 0] ------------------ 3088| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 3089| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3090| 0| } 3091| | 3092| 0| memset(lowpanco, 0, sizeof(struct AdvLowpanCo)); 3093| 0| } 3094| 0|#line 3095 "gram.c" 3095| 0| break; 3096| | 3097| 0| case 139: /* lowpancoparms: T_AdvContextLength NUMBER ';' */ ------------------ | Branch (3097:3): [True: 0, False: 0] ------------------ 3098| 0|#line 1297 "gram.y" 3099| 0| { 3100| 0| lowpanco->ContextLength = (yyvsp[-1].num); 3101| 0| } 3102| 0|#line 3103 "gram.c" 3103| 0| break; 3104| | 3105| 0| case 140: /* lowpancoparms: T_AdvContextCompressionFlag SWITCH ';' */ ------------------ | Branch (3105:3): [True: 0, False: 0] ------------------ 3106| 0|#line 1301 "gram.y" 3107| 0| { 3108| 0| lowpanco->ContextCompressionFlag = (yyvsp[-1].num); 3109| 0| } 3110| 0|#line 3111 "gram.c" 3111| 0| break; 3112| | 3113| 0| case 141: /* lowpancoparms: T_AdvContextID NUMBER ';' */ ------------------ | Branch (3113:3): [True: 0, False: 0] ------------------ 3114| 0|#line 1305 "gram.y" 3115| 0| { 3116| 0| lowpanco->AdvContextID = (yyvsp[-1].num); 3117| 0| } 3118| 0|#line 3119 "gram.c" 3119| 0| break; 3120| | 3121| 0| case 142: /* lowpancoparms: T_AdvLifeTime NUMBER ';' */ ------------------ | Branch (3121:3): [True: 0, False: 0] ------------------ 3122| 0|#line 1309 "gram.y" 3123| 0| { 3124| 0| lowpanco->AdvLifeTime = (yyvsp[-1].num); 3125| 0| } 3126| 0|#line 3127 "gram.c" 3127| 0| break; 3128| | 3129| 0| case 143: /* abrodef: abrohead '{' optional_abroplist '}' ';' */ ------------------ | Branch (3129:3): [True: 0, False: 0] ------------------ 3130| 0|#line 1315 "gram.y" 3131| 0| { 3132| 0| (yyval.abroinfo) = abro; 3133| 0| abro = NULL; 3134| 0| } 3135| 0|#line 3136 "gram.c" 3136| 0| break; 3137| | 3138| 0| case 146: /* abrohead_new: T_ABRO IPV6ADDR */ ------------------ | Branch (3138:3): [True: 0, False: 0] ------------------ 3139| 0|#line 1324 "gram.y" 3140| 0| { 3141| 0| abro = malloc(sizeof(struct AdvAbro)); 3142| | 3143| 0| if (abro == NULL) { ------------------ | Branch (3143:8): [True: 0, False: 0] ------------------ 3144| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 3145| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3146| 0| } 3147| | 3148| 0| memset(abro, 0, sizeof(struct AdvAbro)); 3149| 0| memcpy(&abro->LBRaddress, (yyvsp[0].addr), sizeof(struct in6_addr)); 3150| 0| } 3151| 0|#line 3152 "gram.c" 3152| 0| break; 3153| | 3154| 0| case 147: /* abrohead_dep: T_ABRO IPV6ADDR '/' NUMBER */ ------------------ | Branch (3154:3): [True: 0, False: 0] ------------------ 3155| 0|#line 1338 "gram.y" 3156| 0| { 3157| 0| flog(LOG_WARNING 3158| 0| , "%s:%d abro prefix length deprecated, remove trailing '/%d'" 3159| 0| , filename 3160| 0| , num_lines 3161| 0| , (yyvsp[0].num) 3162| 0| ); 3163| 0| abro = malloc(sizeof(struct AdvAbro)); 3164| | 3165| 0| if (abro == NULL) { ------------------ | Branch (3165:8): [True: 0, False: 0] ------------------ 3166| 0| flog(LOG_CRIT, "malloc failed: %s", strerror(errno)); 3167| 0| ABORT; ------------------ | | 535| 0|#define ABORT do { cleanup(); YYABORT; } while (0); | | ------------------ | | | | 1292| 0|#define YYABORT goto yyabortlab | | ------------------ | | | Branch (535:49): [Folded, False: 0] | | ------------------ ------------------ 3168| 0| } 3169| | 3170| 0| memset(abro, 0, sizeof(struct AdvAbro)); 3171| 0| memcpy(&abro->LBRaddress, (yyvsp[-2].addr), sizeof(struct in6_addr)); 3172| 0| } 3173| 0|#line 3174 "gram.c" 3174| 0| break; 3175| | 3176| 0| case 152: /* abroparms: T_AdvVersionLow NUMBER ';' */ ------------------ | Branch (3176:3): [True: 0, False: 0] ------------------ 3177| 0|#line 1366 "gram.y" 3178| 0| { 3179| 0| abro->Version[1] = (yyvsp[-1].num); 3180| 0| } 3181| 0|#line 3182 "gram.c" 3182| 0| break; 3183| | 3184| 0| case 153: /* abroparms: T_AdvVersionHigh NUMBER ';' */ ------------------ | Branch (3184:3): [True: 0, False: 0] ------------------ 3185| 0|#line 1370 "gram.y" 3186| 0| { 3187| 0| abro->Version[0] = (yyvsp[-1].num); 3188| 0| } 3189| 0|#line 3190 "gram.c" 3190| 0| break; 3191| | 3192| 0| case 154: /* abroparms: T_AdvValidLifetime NUMBER ';' */ ------------------ | Branch (3192:3): [True: 0, False: 0] ------------------ 3193| 0|#line 1374 "gram.y" 3194| 0| { 3195| 0| abro->ValidLifeTime = (yyvsp[-1].num); 3196| 0| } 3197| 0|#line 3198 "gram.c" 3198| 0| break; 3199| | 3200| 0| case 155: /* number_or_infinity: NUMBER */ ------------------ | Branch (3200:3): [True: 0, False: 0] ------------------ 3201| 0|#line 1380 "gram.y" 3202| 0| { 3203| 0| (yyval.num) = (yyvsp[0].num); 3204| 0| } 3205| 0|#line 3206 "gram.c" 3206| 0| break; 3207| | 3208| 0| case 156: /* number_or_infinity: INFINITY */ ------------------ | Branch (3208:3): [True: 0, False: 0] ------------------ 3209| 0|#line 1384 "gram.y" 3210| 0| { 3211| 0| (yyval.num) = (uint32_t)~0; 3212| 0| } 3213| 0|#line 3214 "gram.c" 3214| 0| break; 3215| | 3216| | 3217| 0|#line 3218 "gram.c" 3218| | 3219| 0| default: break; ------------------ | Branch (3219:7): [True: 0, False: 0] ------------------ 3220| 0| } 3221| | /* User semantic actions sometimes alter yychar, and that requires 3222| | that yytoken be updated with the new translation. We take the 3223| | approach of translating immediately before every use of yytoken. 3224| | One alternative is translating here after every semantic action, 3225| | but that translation would be missed if the semantic action invokes 3226| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 3227| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 3228| | incorrect destructor might then be invoked immediately. In the 3229| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 3230| | to an incorrect destructor call or verbose syntax error message 3231| | before the lookahead is translated. */ 3232| 0| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 3233| | 3234| 0| YYPOPSTACK (yylen); ------------------ | | 1537| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3235| 0| yylen = 0; 3236| | 3237| 0| *++yyvsp = yyval; 3238| | 3239| | /* Now 'shift' the result of the reduction. Determine what state 3240| | that goes to, based on the state we popped back to and the rule 3241| | number reduced by. */ 3242| 0| { 3243| 0| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 865| 0|#define YYNTOKENS 89 ------------------ 3244| 0| const int yyi = yypgoto[yylhs] + *yyssp; 3245| 0| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 862| 0|#define YYLAST 324 ------------------ | Branch (3245:16): [True: 0, False: 0] | Branch (3245:28): [True: 0, False: 0] | Branch (3245:45): [True: 0, False: 0] ------------------ 3246| 0| ? yytable[yyi] 3247| 0| : yydefgoto[yylhs]); 3248| 0| } 3249| | 3250| 0| goto yynewstate; 3251| | 3252| | 3253| |/*--------------------------------------. 3254| || yyerrlab -- here on detecting error. | 3255| |`--------------------------------------*/ 3256| 634|yyerrlab: 3257| | /* Make sure we have latest lookahead translation. See comments at 3258| | user semantic actions for why this is necessary. */ 3259| 634| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 235| 634|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 880| 1.26k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 874| 634|#define YYMAXUTOK 339 | | ------------------ | | | Branch (880:4): [True: 634, False: 0] | | | Branch (880:18): [True: 634, False: 0] | | ------------------ | | 881| 1.26k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 634|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 882| 1.26k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (3259:13): [True: 0, False: 634] ------------------ 3260| | /* If not already recovering from an error, report this error. */ 3261| 634| if (!yyerrstatus) ------------------ | Branch (3261:7): [True: 634, False: 0] ------------------ 3262| 634| { 3263| 634| ++yynerrs; 3264| 634| yyerror (YY_("syntax error")); ------------------ | | 664| 634|# define YY_(Msgid) Msgid ------------------ 3265| 634| } 3266| | 3267| 634| if (yyerrstatus == 3) ------------------ | Branch (3267:7): [True: 0, False: 634] ------------------ 3268| 0| { 3269| | /* If just tried and failed to reuse lookahead token after an 3270| | error, discard it. */ 3271| | 3272| 0| if (yychar <= YYEOF) ------------------ | | 236| 0|#define YYEOF 0 ------------------ | Branch (3272:11): [True: 0, False: 0] ------------------ 3273| 0| { 3274| | /* Return failure if at end of input. */ 3275| 0| if (yychar == YYEOF) ------------------ | | 236| 0|#define YYEOF 0 ------------------ | Branch (3275:15): [True: 0, False: 0] ------------------ 3276| 0| YYABORT; ------------------ | | 1292| 0|#define YYABORT goto yyabortlab ------------------ 3277| 0| } 3278| 0| else 3279| 0| { 3280| 0| yydestruct ("Error: discarding", 3281| 0| yytoken, &yylval); 3282| 0| yychar = YYEMPTY; ------------------ | | 235| 0|#define YYEMPTY -2 ------------------ 3283| 0| } 3284| 0| } 3285| | 3286| | /* Else will try to reuse lookahead token after shifting the error 3287| | token. */ 3288| 634| goto yyerrlab1; 3289| | 3290| | 3291| |/*---------------------------------------------------. 3292| || yyerrorlab -- error raised explicitly by YYERROR. | 3293| |`---------------------------------------------------*/ 3294| 634|yyerrorlab: 3295| | /* Pacify compilers when the user code never invokes YYERROR and the 3296| | label yyerrorlab therefore never appears in user code. */ 3297| 0| if (0) ------------------ | Branch (3297:7): [Folded, False: 0] ------------------ 3298| 0| YYERROR; ------------------ | | 1293| 0|#define YYERROR goto yyerrorlab ------------------ 3299| 0| ++yynerrs; 3300| | 3301| | /* Do not reclaim the symbols of the rule whose action triggered 3302| | this YYERROR. */ 3303| 0| YYPOPSTACK (yylen); ------------------ | | 1537| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3304| 0| yylen = 0; 3305| 0| YY_STACK_PRINT (yyss, yyssp); 3306| 0| yystate = *yyssp; 3307| 0| goto yyerrlab1; 3308| | 3309| | 3310| |/*-------------------------------------------------------------. 3311| || yyerrlab1 -- common code for both syntax error and YYERROR. | 3312| |`-------------------------------------------------------------*/ 3313| 634|yyerrlab1: 3314| 634| yyerrstatus = 3; /* Each real token shifted decrements this. */ 3315| | 3316| | /* Pop stack until we find a state that shifts the error token. */ 3317| 634| for (;;) 3318| 634| { 3319| 634| yyn = yypact[yystate]; 3320| 634| if (!yypact_value_is_default (yyn)) ------------------ | | 1011| 634| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1008| 634|#define YYPACT_NINF (-87) | | ------------------ ------------------ | Branch (3320:11): [True: 634, False: 0] ------------------ 3321| 634| { 3322| 634| yyn += YYSYMBOL_YYerror; 3323| 634| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 862| 1.26k|#define YYLAST 324 ------------------ | Branch (3323:15): [True: 634, False: 0] | Branch (3323:27): [True: 634, False: 0] | Branch (3323:44): [True: 0, False: 634] ------------------ 3324| 0| { 3325| 0| yyn = yytable[yyn]; 3326| 0| if (0 < yyn) ------------------ | Branch (3326:19): [True: 0, False: 0] ------------------ 3327| 0| break; 3328| 0| } 3329| 634| } 3330| | 3331| | /* Pop the current state because it cannot handle the error token. */ 3332| 634| if (yyssp == yyss) ------------------ | Branch (3332:11): [True: 634, False: 0] ------------------ 3333| 634| YYABORT; ------------------ | | 1292| 634|#define YYABORT goto yyabortlab ------------------ 3334| | 3335| | 3336| 0| yydestruct ("Error: popping", 3337| 0| YY_ACCESSING_SYMBOL (yystate), yyvsp); ------------------ | | 948| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 3338| 0| YYPOPSTACK (1); ------------------ | | 1537| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3339| 0| yystate = *yyssp; 3340| 0| YY_STACK_PRINT (yyss, yyssp); 3341| 0| } 3342| | 3343| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3344| 0| *++yyvsp = yylval; 3345| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 3346| | 3347| | 3348| | /* Shift the error token. */ 3349| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 3350| | 3351| 0| yystate = yyn; 3352| 0| goto yynewstate; 3353| | 3354| | 3355| |/*-------------------------------------. 3356| || yyacceptlab -- YYACCEPT comes here. | 3357| |`-------------------------------------*/ 3358| 0|yyacceptlab: 3359| 0| yyresult = 0; 3360| 0| goto yyreturnlab; 3361| | 3362| | 3363| |/*-----------------------------------. 3364| || yyabortlab -- YYABORT comes here. | 3365| |`-----------------------------------*/ 3366| 634|yyabortlab: 3367| 634| yyresult = 1; 3368| 634| goto yyreturnlab; 3369| | 3370| | 3371| |/*-----------------------------------------------------------. 3372| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 3373| |`-----------------------------------------------------------*/ 3374| 0|yyexhaustedlab: 3375| 0| yyerror (YY_("memory exhausted")); ------------------ | | 664| 0|# define YY_(Msgid) Msgid ------------------ 3376| 0| yyresult = 2; 3377| 0| goto yyreturnlab; 3378| | 3379| | 3380| |/*----------------------------------------------------------. 3381| || yyreturnlab -- parsing is finished, clean up and return. | 3382| |`----------------------------------------------------------*/ 3383| 634|yyreturnlab: 3384| 634| if (yychar != YYEMPTY) ------------------ | | 235| 634|#define YYEMPTY -2 ------------------ | Branch (3384:7): [True: 634, False: 0] ------------------ 3385| 634| { 3386| | /* Make sure we have latest lookahead translation. See comments at 3387| | user semantic actions for why this is necessary. */ 3388| 634| yytoken = YYTRANSLATE (yychar); ------------------ | | 880| 634| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 874| 634|#define YYMAXUTOK 339 | | ------------------ | | | Branch (880:4): [True: 634, False: 0] | | | Branch (880:18): [True: 634, False: 0] | | ------------------ | | 881| 634| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 112| 634|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 882| 634| : YYSYMBOL_YYUNDEF) ------------------ 3389| 634| yydestruct ("Cleanup: discarding lookahead", 3390| 634| yytoken, &yylval); 3391| 634| } 3392| | /* Do not reclaim the symbols of the rule whose action triggered 3393| | this YYABORT or YYACCEPT. */ 3394| 634| YYPOPSTACK (yylen); ------------------ | | 1537| 634|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3395| 634| YY_STACK_PRINT (yyss, yyssp); 3396| 634| while (yyssp != yyss) ------------------ | Branch (3396:10): [True: 0, False: 634] ------------------ 3397| 0| { 3398| 0| yydestruct ("Cleanup: popping", 3399| 0| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); ------------------ | | 948| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 112| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 3400| 0| YYPOPSTACK (1); ------------------ | | 1537| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 3401| 0| } 3402| 634|#ifndef yyoverflow 3403| 634| if (yyss != yyssa) ------------------ | Branch (3403:7): [True: 0, False: 634] ------------------ 3404| 0| YYSTACK_FREE (yyss); ------------------ | | 772| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 791| 0|# define YYFREE free | | ------------------ ------------------ 3405| 634|#endif 3406| | 3407| 634| return yyresult; 3408| 634|} readin_config: 3466| 634|{ 3467| 634| IfaceList = 0; 3468| 634| FILE * in = fopen(path, "r"); 3469| 634| if (in) { ------------------ | Branch (3469:6): [True: 634, False: 0] ------------------ 3470| 634| filename = path; 3471| 634| num_lines = 1; 3472| 634| iface = 0; 3473| | 3474| 634| yyset_in(in); 3475| 634| if (yyparse() != 0) { ------------------ | Branch (3475:7): [True: 634, False: 0] ------------------ 3476| 634| free_ifaces(iface); 3477| 634| iface = 0; 3478| 634| IfaceList = 0; 3479| 634| } else { 3480| 0| dlog(LOG_DEBUG, 1, "config file, %s, syntax ok", path); 3481| 0| } 3482| 634| yylex_destroy(); 3483| 634| fclose(in); 3484| 634| } 3485| | 3486| 634| return IfaceList; 3487| 634|} gram.c:yydestruct: 1476| 634|{ 1477| 634| YY_USE (yyvaluep); ------------------ | | 687| 634|# define YY_USE(E) ((void) (E)) ------------------ 1478| 634| if (!yymsg) ------------------ | Branch (1478:7): [True: 0, False: 634] ------------------ 1479| 0| yymsg = "Deleting"; 1480| 634| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1481| | 1482| 634| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1483| 634| YY_USE (yykind); ------------------ | | 687| 634|# define YY_USE(E) ((void) (E)) ------------------ 1484| 634| YY_IGNORE_MAYBE_UNINITIALIZED_END 1485| 634|} gram.c:yyerror: 3490| 634|{ 3491| | fprintf(stderr, "%s:%d error: %s\n", 3492| 634| filename, 3493| 634| num_lines, 3494| 634| msg); 3495| 634|} free_ifaces: 490| 634|{ 491| 634| dlog(LOG_DEBUG, 3, "Freeing Interfaces"); 492| | 493| 634| free_iface_list(ifaces); 494| 634|} interface.c:free_iface_list: 408| 634|{ 409| 634| while (iface) { ------------------ | Branch (409:9): [True: 0, False: 634] ------------------ 410| 0| struct Interface *next_iface = iface->next; 411| | 412| 0| dlog(LOG_DEBUG, 4, "freeing interface %s", iface->props.name); 413| | 414| 0| struct AdvPrefix *prefix = iface->AdvPrefixList; 415| 0| while (prefix) { ------------------ | Branch (415:10): [True: 0, False: 0] ------------------ 416| 0| struct AdvPrefix *next_prefix = prefix->next; 417| | 418| 0| free(prefix); 419| 0| prefix = next_prefix; 420| 0| } 421| | 422| 0| struct AdvRoute *route = iface->AdvRouteList; 423| 0| while (route) { ------------------ | Branch (423:10): [True: 0, False: 0] ------------------ 424| 0| struct AdvRoute *next_route = route->next; 425| | 426| 0| free(route); 427| 0| route = next_route; 428| 0| } 429| | 430| 0| struct AdvRDNSS *rdnss = iface->AdvRDNSSList; 431| 0| while (rdnss) { ------------------ | Branch (431:10): [True: 0, False: 0] ------------------ 432| 0| struct AdvRDNSS *next_rdnss = rdnss->next; 433| | 434| 0| free(rdnss->AdvRDNSSAddr); 435| 0| free(rdnss); 436| 0| rdnss = next_rdnss; 437| 0| } 438| | 439| 0| struct AdvDNSSL *dnssl = iface->AdvDNSSLList; 440| 0| while (dnssl) { ------------------ | Branch (440:10): [True: 0, False: 0] ------------------ 441| 0| struct AdvDNSSL *next_dnssl = dnssl->next; 442| | 443| 0| for (int i = 0; i < dnssl->AdvDNSSLNumber; i++) ------------------ | Branch (443:20): [True: 0, False: 0] ------------------ 444| 0| free(dnssl->AdvDNSSLSuffixes[i]); 445| 0| free(dnssl->AdvDNSSLSuffixes); 446| 0| free(dnssl); 447| | 448| 0| dnssl = next_dnssl; 449| 0| } 450| | 451| 0| struct AdvDNR *dnr = iface->AdvDNRList; 452| 0| while (dnr) { ------------------ | Branch (452:10): [True: 0, False: 0] ------------------ 453| 0| struct AdvDNR *next_dnr = dnr->next; 454| | 455| 0| free(dnr->AdvDNRAddrs); 456| 0| free(dnr->AdvDNRADN); 457| 0| free(dnr->AdvDNRSvcAlpn); 458| 0| free(dnr->AdvDNRSvcDohpath); 459| 0| free(dnr); 460| | 461| 0| dnr = next_dnr; 462| 0| } 463| | 464| 0| struct AutogenIgnorePrefix *ignore_prefixes = iface->IgnorePrefixList; 465| 0| while (ignore_prefixes) { ------------------ | Branch (465:10): [True: 0, False: 0] ------------------ 466| 0| struct AutogenIgnorePrefix *next_ignore_prefix = ignore_prefixes->next; 467| | 468| 0| free(ignore_prefixes); 469| 0| ignore_prefixes = next_ignore_prefix; 470| 0| } 471| | 472| 0| struct Clients *clients = iface->ClientList; 473| 0| while (clients) { ------------------ | Branch (473:10): [True: 0, False: 0] ------------------ 474| 0| struct Clients *next_client = clients->next; 475| | 476| 0| free(clients); 477| 0| clients = next_client; 478| 0| } 479| | 480| 0| free(iface->props.if_addrs); 481| | 482| 0| free(iface->AdvCaptivePortalAPI); 483| | 484| 0| free(iface); 485| 0| iface = next_iface; 486| 0| } 487| 634|} yylex: 1753| 634|{ 1754| 634| yy_state_type yy_current_state; 1755| 634| char *yy_cp, *yy_bp; 1756| 634| int yy_act; 1757| | 1758| 634| if ( !(yy_init) ) ------------------ | Branch (1758:7): [True: 634, False: 0] ------------------ 1759| 634| { 1760| 634| (yy_init) = 1; 1761| | 1762| |#ifdef YY_USER_INIT 1763| | YY_USER_INIT; 1764| |#endif 1765| | 1766| 634| if ( ! (yy_start) ) ------------------ | Branch (1766:8): [True: 634, False: 0] ------------------ 1767| 634| (yy_start) = 1; /* first start state */ 1768| | 1769| 634| if ( ! yyin ) ------------------ | Branch (1769:8): [True: 0, False: 634] ------------------ 1770| 0| yyin = stdin; 1771| | 1772| 634| if ( ! yyout ) ------------------ | Branch (1772:8): [True: 634, False: 0] ------------------ 1773| 634| yyout = stdout; 1774| | 1775| 634| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 278| 634|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 0, False: 634] | | ------------------ | | 279| 634| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 634| : NULL) ------------------ | Branch (1775:8): [True: 634, False: 0] ------------------ 1776| 634| yyensure_buffer_stack (); 1777| 634| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 1778| 634| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 139| 634|#define YY_BUF_SIZE 16384 ------------------ 1779| 634| } 1780| | 1781| 634| yy_load_buffer_state( ); 1782| 634| } 1783| | 1784| 634| { 1785| 634|#line 40 "scanner.l" 1786| | 1787| | 1788| 634|#line 1789 "scanner.c" 1789| | 1790| 917k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1790:23): [True: 917k, Folded] ------------------ 1791| 917k| { 1792| 917k| yy_cp = (yy_c_buf_p); 1793| | 1794| | /* Support of yytext. */ 1795| 917k| *yy_cp = (yy_hold_char); 1796| | 1797| | /* yy_bp points to the position in yy_ch_buf of the start of 1798| | * the current run. 1799| | */ 1800| 917k| yy_bp = yy_cp; 1801| | 1802| 917k| yy_current_state = (yy_start); 1803| 1.00M|yy_match: 1804| 1.00M| do 1805| 14.6M| { 1806| 14.6M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 111| 14.6M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1807| 14.6M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1807:9): [True: 2.83M, False: 11.7M] ------------------ 1808| 2.83M| { 1809| 2.83M| (yy_last_accepting_state) = yy_current_state; 1810| 2.83M| (yy_last_accepting_cpos) = yy_cp; 1811| 2.83M| } 1812| 27.8M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1812:12): [True: 13.2M, False: 14.6M] ------------------ 1813| 13.2M| { 1814| 13.2M| yy_current_state = (int) yy_def[yy_current_state]; 1815| 13.2M| if ( yy_current_state >= 966 ) ------------------ | Branch (1815:10): [True: 13.0M, False: 129k] ------------------ 1816| 13.0M| yy_c = yy_meta[yy_c]; 1817| 13.2M| } 1818| 14.6M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1819| 14.6M| ++yy_cp; 1820| 14.6M| } 1821| 14.6M| while ( yy_base[yy_current_state] != 3373 ); ------------------ | Branch (1821:11): [True: 13.6M, False: 1.00M] ------------------ 1822| | 1823| 1.01M|yy_find_action: 1824| 1.01M| yy_act = yy_accept[yy_current_state]; 1825| 1.01M| if ( yy_act == 0 ) ------------------ | Branch (1825:8): [True: 95.6k, False: 914k] ------------------ 1826| 95.6k| { /* have to back up */ 1827| 95.6k| yy_cp = (yy_last_accepting_cpos); 1828| 95.6k| yy_current_state = (yy_last_accepting_state); 1829| 95.6k| yy_act = yy_accept[yy_current_state]; 1830| 95.6k| } 1831| | 1832| 1.01M| YY_DO_BEFORE_ACTION; ------------------ | | 371| 1.01M| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 360| 1.01M|#define yytext_ptr yytext | | ------------------ | | 372| 1.01M| yyleng = (int) (yy_cp - yy_bp); \ | | 373| 1.01M| (yy_hold_char) = *yy_cp; \ | | 374| 1.01M| *yy_cp = '\0'; \ | | 375| 1.01M| (yy_c_buf_p) = yy_cp; ------------------ 1833| | 1834| 1.01M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 377| 2.02M|#define YY_END_OF_BUFFER 92 ------------------ | Branch (1834:8): [True: 917k, False: 93.1k] | Branch (1834:38): [True: 897k, False: 19.4k] ------------------ 1835| 897k| { 1836| 897k| int yyl; 1837| 4.98M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | Branch (1837:19): [True: 4.08M, False: 897k] ------------------ 1838| 4.08M| if ( yytext[yyl] == '\n' ) ------------------ | Branch (1838:10): [True: 1.05M, False: 3.02M] ------------------ 1839| | 1840| 1.05M| yylineno++; 1841| 897k|; 1842| 897k| } 1843| | 1844| 1.01M|do_action: /* This label is used only to access EOF actions. */ 1845| | 1846| 1.01M| switch ( yy_act ) 1847| 1.01M| { /* beginning of action switch */ 1848| 0| case 0: /* must back up */ ------------------ | Branch (1848:4): [True: 0, False: 1.01M] ------------------ 1849| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1850| 0| *yy_cp = (yy_hold_char); 1851| 0| yy_cp = (yy_last_accepting_cpos); 1852| 0| yy_current_state = (yy_last_accepting_state); 1853| 0| goto yy_find_action; 1854| | 1855| 16.8k|case 1: ------------------ | Branch (1855:1): [True: 16.8k, False: 993k] ------------------ 1856| 16.8k|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 1857| 16.8k|(yy_c_buf_p) = yy_cp -= 1; 1858| 16.8k|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 371| 16.8k| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 360| 16.8k|#define yytext_ptr yytext | | ------------------ | | 372| 16.8k| yyleng = (int) (yy_cp - yy_bp); \ | | 373| 16.8k| (yy_hold_char) = *yy_cp; \ | | 374| 16.8k| *yy_cp = '\0'; \ | | 375| 16.8k| (yy_c_buf_p) = yy_cp; ------------------ 1859| 16.8k|YY_RULE_SETUP 1860| 16.8k|#line 42 "scanner.l" 1861| 16.8k|{/* ignore comments */} 1862| 16.8k| YY_BREAK ------------------ | | 1744| 16.8k|#define YY_BREAK /*LINTED*/break; ------------------ 1863| 897k|case 2: ------------------ | Branch (1863:1): [True: 897k, False: 112k] ------------------ 1864| |/* rule 2 can match eol */ 1865| 897k|YY_RULE_SETUP 1866| 897k|#line 43 "scanner.l" 1867| 897k|{num_lines++;} 1868| 897k| YY_BREAK ------------------ | | 1744| 897k|#define YY_BREAK /*LINTED*/break; ------------------ 1869| 2.40k|case 3: ------------------ | Branch (1869:1): [True: 2.40k, False: 1.00M] ------------------ 1870| 2.40k|YY_RULE_SETUP 1871| 2.40k|#line 44 "scanner.l" 1872| 2.40k|{} 1873| 2.40k| YY_BREAK ------------------ | | 1744| 2.40k|#define YY_BREAK /*LINTED*/break; ------------------ 1874| 0|case 4: ------------------ | Branch (1874:1): [True: 0, False: 1.01M] ------------------ 1875| 0|YY_RULE_SETUP 1876| 0|#line 46 "scanner.l" 1877| 0|{ return T_INTERFACE; } ------------------ | | 147| 0|#define T_INTERFACE 258 ------------------ 1878| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1879| 2|case 5: ------------------ | Branch (1879:1): [True: 2, False: 1.01M] ------------------ 1880| 2|YY_RULE_SETUP 1881| 2|#line 47 "scanner.l" 1882| 2|{ return T_PREFIX; } ------------------ | | 148| 2|#define T_PREFIX 259 ------------------ 1883| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1884| 1|case 6: ------------------ | Branch (1884:1): [True: 1, False: 1.01M] ------------------ 1885| 1|YY_RULE_SETUP 1886| 1|#line 48 "scanner.l" 1887| 1|{ return T_ROUTE; } ------------------ | | 149| 1|#define T_ROUTE 260 ------------------ 1888| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1889| 1|case 7: ------------------ | Branch (1889:1): [True: 1, False: 1.01M] ------------------ 1890| 1|YY_RULE_SETUP 1891| 1|#line 49 "scanner.l" 1892| 1|{ return T_RDNSS; } ------------------ | | 150| 1|#define T_RDNSS 261 ------------------ 1893| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1894| 2|case 8: ------------------ | Branch (1894:1): [True: 2, False: 1.01M] ------------------ 1895| 2|YY_RULE_SETUP 1896| 2|#line 50 "scanner.l" 1897| 2|{ return T_DNSSL; } ------------------ | | 151| 2|#define T_DNSSL 262 ------------------ 1898| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1899| 1|case 9: ------------------ | Branch (1899:1): [True: 1, False: 1.01M] ------------------ 1900| 1|YY_RULE_SETUP 1901| 1|#line 51 "scanner.l" 1902| 1|{ return T_DNR; } ------------------ | | 152| 1|#define T_DNR 263 ------------------ 1903| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1904| 0|case 10: ------------------ | Branch (1904:1): [True: 0, False: 1.01M] ------------------ 1905| 0|YY_RULE_SETUP 1906| 0|#line 52 "scanner.l" 1907| 0|{ return T_CLIENTS; } ------------------ | | 153| 0|#define T_CLIENTS 264 ------------------ 1908| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1909| 0|case 11: ------------------ | Branch (1909:1): [True: 0, False: 1.01M] ------------------ 1910| 0|YY_RULE_SETUP 1911| 0|#line 53 "scanner.l" 1912| 0|{ return T_LOWPANCO; } ------------------ | | 154| 0|#define T_LOWPANCO 265 ------------------ 1913| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1914| 1|case 12: ------------------ | Branch (1914:1): [True: 1, False: 1.01M] ------------------ 1915| 1|YY_RULE_SETUP 1916| 1|#line 54 "scanner.l" 1917| 1|{ return T_ABRO; } ------------------ | | 155| 1|#define T_ABRO 266 ------------------ 1918| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1919| 0|case 13: ------------------ | Branch (1919:1): [True: 0, False: 1.01M] ------------------ 1920| 0|YY_RULE_SETUP 1921| 0|#line 55 "scanner.l" 1922| 0|{ return T_NAT64PREFIX; } ------------------ | | 157| 0|#define T_NAT64PREFIX 268 ------------------ 1923| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1924| 0|case 14: ------------------ | Branch (1924:1): [True: 0, False: 1.01M] ------------------ 1925| 0|YY_RULE_SETUP 1926| 0|#line 56 "scanner.l" 1927| 0|{ return T_AUTOIGNOREPREFIX; } ------------------ | | 158| 0|#define T_AUTOIGNOREPREFIX 269 ------------------ 1928| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1929| 0|case 15: ------------------ | Branch (1929:1): [True: 0, False: 1.01M] ------------------ 1930| 0|YY_RULE_SETUP 1931| 0|#line 58 "scanner.l" 1932| 0|{ return T_RASRCADDRESS; } ------------------ | | 156| 0|#define T_RASRCADDRESS 267 ------------------ 1933| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1934| 0|case 16: ------------------ | Branch (1934:1): [True: 0, False: 1.01M] ------------------ 1935| 0|YY_RULE_SETUP 1936| 0|#line 60 "scanner.l" 1937| 0|{ return T_IgnoreIfMissing; } ------------------ | | 167| 0|#define T_IgnoreIfMissing 278 ------------------ 1938| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1939| 0|case 17: ------------------ | Branch (1939:1): [True: 0, False: 1.01M] ------------------ 1940| 0|YY_RULE_SETUP 1941| 0|#line 61 "scanner.l" 1942| 0|{ return T_AdvSendAdvert; } ------------------ | | 168| 0|#define T_AdvSendAdvert 279 ------------------ 1943| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1944| 0|case 18: ------------------ | Branch (1944:1): [True: 0, False: 1.01M] ------------------ 1945| 0|YY_RULE_SETUP 1946| 0|#line 62 "scanner.l" 1947| 0|{ return T_MaxRtrAdvInterval; } ------------------ | | 169| 0|#define T_MaxRtrAdvInterval 280 ------------------ 1948| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1949| 0|case 19: ------------------ | Branch (1949:1): [True: 0, False: 1.01M] ------------------ 1950| 0|YY_RULE_SETUP 1951| 0|#line 63 "scanner.l" 1952| 0|{ return T_MinRtrAdvInterval; } ------------------ | | 170| 0|#define T_MinRtrAdvInterval 281 ------------------ 1953| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1954| 0|case 20: ------------------ | Branch (1954:1): [True: 0, False: 1.01M] ------------------ 1955| 0|YY_RULE_SETUP 1956| 0|#line 64 "scanner.l" 1957| 0|{ return T_AdvManagedFlag; } ------------------ | | 172| 0|#define T_AdvManagedFlag 283 ------------------ 1958| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1959| 0|case 21: ------------------ | Branch (1959:1): [True: 0, False: 1.01M] ------------------ 1960| 0|YY_RULE_SETUP 1961| 0|#line 65 "scanner.l" 1962| 0|{ return T_AdvOtherConfigFlag; } ------------------ | | 173| 0|#define T_AdvOtherConfigFlag 284 ------------------ 1963| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1964| 0|case 22: ------------------ | Branch (1964:1): [True: 0, False: 1.01M] ------------------ 1965| 0|YY_RULE_SETUP 1966| 0|#line 66 "scanner.l" 1967| 0|{ return T_AdvLinkMTU; } ------------------ | | 174| 0|#define T_AdvLinkMTU 285 ------------------ 1968| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1969| 0|case 23: ------------------ | Branch (1969:1): [True: 0, False: 1.01M] ------------------ 1970| 0|YY_RULE_SETUP 1971| 0|#line 67 "scanner.l" 1972| 0|{ return T_AdvRAMTU; } ------------------ | | 175| 0|#define T_AdvRAMTU 286 ------------------ 1973| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1974| 0|case 24: ------------------ | Branch (1974:1): [True: 0, False: 1.01M] ------------------ 1975| 0|YY_RULE_SETUP 1976| 0|#line 68 "scanner.l" 1977| 0|{ return T_AdvReachableTime; } ------------------ | | 176| 0|#define T_AdvReachableTime 287 ------------------ 1978| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1979| 0|case 25: ------------------ | Branch (1979:1): [True: 0, False: 1.01M] ------------------ 1980| 0|YY_RULE_SETUP 1981| 0|#line 69 "scanner.l" 1982| 0|{ return T_AdvRetransTimer; } ------------------ | | 177| 0|#define T_AdvRetransTimer 288 ------------------ 1983| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1984| 0|case 26: ------------------ | Branch (1984:1): [True: 0, False: 1.01M] ------------------ 1985| 0|YY_RULE_SETUP 1986| 0|#line 70 "scanner.l" 1987| 0|{ return T_AdvCurHopLimit; } ------------------ | | 178| 0|#define T_AdvCurHopLimit 289 ------------------ 1988| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1989| 0|case 27: ------------------ | Branch (1989:1): [True: 0, False: 1.01M] ------------------ 1990| 0|YY_RULE_SETUP 1991| 0|#line 71 "scanner.l" 1992| 0|{ return T_AdvDefaultLifetime; } ------------------ | | 179| 0|#define T_AdvDefaultLifetime 290 ------------------ 1993| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1994| 0|case 28: ------------------ | Branch (1994:1): [True: 0, False: 1.01M] ------------------ 1995| 0|YY_RULE_SETUP 1996| 0|#line 72 "scanner.l" 1997| 0|{ return T_AdvDefaultPreference; } ------------------ | | 180| 0|#define T_AdvDefaultPreference 291 ------------------ 1998| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1999| 0|case 29: ------------------ | Branch (1999:1): [True: 0, False: 1.01M] ------------------ 2000| 0|YY_RULE_SETUP 2001| 0|#line 73 "scanner.l" 2002| 0|{ return T_AdvSourceLLAddress; } ------------------ | | 181| 0|#define T_AdvSourceLLAddress 292 ------------------ 2003| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2004| 0|case 30: ------------------ | Branch (2004:1): [True: 0, False: 1.01M] ------------------ 2005| 0|YY_RULE_SETUP 2006| 0|#line 74 "scanner.l" 2007| 0|{ return T_RemoveAdvOnExit; } ------------------ | | 182| 0|#define T_RemoveAdvOnExit 293 ------------------ 2008| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2009| 0|case 31: ------------------ | Branch (2009:1): [True: 0, False: 1.01M] ------------------ 2010| 0|YY_RULE_SETUP 2011| 0|#line 76 "scanner.l" 2012| 0|{ return T_AdvOnLink; } ------------------ | | 183| 0|#define T_AdvOnLink 294 ------------------ 2013| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2014| 0|case 32: ------------------ | Branch (2014:1): [True: 0, False: 1.01M] ------------------ 2015| 0|YY_RULE_SETUP 2016| 0|#line 77 "scanner.l" 2017| 0|{ return T_AdvAutonomous; } ------------------ | | 184| 0|#define T_AdvAutonomous 295 ------------------ 2018| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2019| 0|case 33: ------------------ | Branch (2019:1): [True: 0, False: 1.01M] ------------------ 2020| 0|YY_RULE_SETUP 2021| 0|#line 78 "scanner.l" 2022| 0|{ return T_AdvDHCPv6PDPreferred; } ------------------ | | 185| 0|#define T_AdvDHCPv6PDPreferred 296 ------------------ 2023| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2024| 0|case 34: ------------------ | Branch (2024:1): [True: 0, False: 1.01M] ------------------ 2025| 0|YY_RULE_SETUP 2026| 0|#line 79 "scanner.l" 2027| 0|{ return T_AdvValidLifetime; } ------------------ | | 186| 0|#define T_AdvValidLifetime 297 ------------------ 2028| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2029| 0|case 35: ------------------ | Branch (2029:1): [True: 0, False: 1.01M] ------------------ 2030| 0|YY_RULE_SETUP 2031| 0|#line 80 "scanner.l" 2032| 0|{ return T_AdvPreferredLifetime; } ------------------ | | 187| 0|#define T_AdvPreferredLifetime 298 ------------------ 2033| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2034| 0|case 36: ------------------ | Branch (2034:1): [True: 0, False: 1.01M] ------------------ 2035| 0|YY_RULE_SETUP 2036| 0|#line 81 "scanner.l" 2037| 0|{ return T_DeprecatePrefix; } ------------------ | | 188| 0|#define T_DeprecatePrefix 299 ------------------ 2038| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2039| 0|case 37: ------------------ | Branch (2039:1): [True: 0, False: 1.01M] ------------------ 2040| 0|YY_RULE_SETUP 2041| 0|#line 82 "scanner.l" 2042| 0|{ return T_DecrementLifetimes; } ------------------ | | 189| 0|#define T_DecrementLifetimes 300 ------------------ 2043| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2044| 0|case 38: ------------------ | Branch (2044:1): [True: 0, False: 1.01M] ------------------ 2045| 0|YY_RULE_SETUP 2046| 0|#line 84 "scanner.l" 2047| 0|{ return T_AdvRouterAddr; } ------------------ | | 190| 0|#define T_AdvRouterAddr 301 ------------------ 2048| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2049| 0|case 39: ------------------ | Branch (2049:1): [True: 0, False: 1.01M] ------------------ 2050| 0|YY_RULE_SETUP 2051| 0|#line 85 "scanner.l" 2052| 0|{ return T_AdvHomeAgentFlag; } ------------------ | | 191| 0|#define T_AdvHomeAgentFlag 302 ------------------ 2053| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2054| 0|case 40: ------------------ | Branch (2054:1): [True: 0, False: 1.01M] ------------------ 2055| 0|YY_RULE_SETUP 2056| 0|#line 86 "scanner.l" 2057| 0|{ return T_AdvIntervalOpt; } ------------------ | | 192| 0|#define T_AdvIntervalOpt 303 ------------------ 2058| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2059| 0|case 41: ------------------ | Branch (2059:1): [True: 0, False: 1.01M] ------------------ 2060| 0|YY_RULE_SETUP 2061| 0|#line 87 "scanner.l" 2062| 0|{ return T_AdvHomeAgentInfo; } ------------------ | | 193| 0|#define T_AdvHomeAgentInfo 304 ------------------ 2063| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2064| 0|case 42: ------------------ | Branch (2064:1): [True: 0, False: 1.01M] ------------------ 2065| 0|YY_RULE_SETUP 2066| 0|#line 88 "scanner.l" 2067| 0|{ return T_UnicastOnly; } ------------------ | | 197| 0|#define T_UnicastOnly 308 ------------------ 2068| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2069| 0|case 43: ------------------ | Branch (2069:1): [True: 0, False: 1.01M] ------------------ 2070| 0|YY_RULE_SETUP 2071| 0|#line 89 "scanner.l" 2072| 0|{ return T_UnrestrictedUnicast; } ------------------ | | 198| 0|#define T_UnrestrictedUnicast 309 ------------------ 2073| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2074| 0|case 44: ------------------ | Branch (2074:1): [True: 0, False: 1.01M] ------------------ 2075| 0|YY_RULE_SETUP 2076| 0|#line 90 "scanner.l" 2077| 0|{ return T_AdvRASolicitedUnicast; } ------------------ | | 199| 0|#define T_AdvRASolicitedUnicast 310 ------------------ 2078| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2079| 0|case 45: ------------------ | Branch (2079:1): [True: 0, False: 1.01M] ------------------ 2080| 0|YY_RULE_SETUP 2081| 0|#line 91 "scanner.l" 2082| 0|{ return T_AdvCaptivePortalAPI; } ------------------ | | 200| 0|#define T_AdvCaptivePortalAPI 311 ------------------ 2083| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2084| 0|case 46: ------------------ | Branch (2084:1): [True: 0, False: 1.01M] ------------------ 2085| 0|YY_RULE_SETUP 2086| 0|#line 92 "scanner.l" 2087| 0|{ return T_AdvSNACRouterFlag; } ------------------ | | 194| 0|#define T_AdvSNACRouterFlag 305 ------------------ 2088| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2089| 0|case 47: ------------------ | Branch (2089:1): [True: 0, False: 1.01M] ------------------ 2090| 0|YY_RULE_SETUP 2091| 0|#line 94 "scanner.l" 2092| 0|{ return T_Base6Interface; } ------------------ | | 195| 0|#define T_Base6Interface 306 ------------------ 2093| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2094| 0|case 48: ------------------ | Branch (2094:1): [True: 0, False: 1.01M] ------------------ 2095| 0|YY_RULE_SETUP 2096| 0|#line 95 "scanner.l" 2097| 0|{ return T_Base6to4Interface; } ------------------ | | 196| 0|#define T_Base6to4Interface 307 ------------------ 2098| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2099| 0|case 49: ------------------ | Branch (2099:1): [True: 0, False: 1.01M] ------------------ 2100| 0|YY_RULE_SETUP 2101| 0|#line 97 "scanner.l" 2102| 0|{ return T_HomeAgentPreference; } ------------------ | | 201| 0|#define T_HomeAgentPreference 312 ------------------ 2103| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2104| 0|case 50: ------------------ | Branch (2104:1): [True: 0, False: 1.01M] ------------------ 2105| 0|YY_RULE_SETUP 2106| 0|#line 98 "scanner.l" 2107| 0|{ return T_HomeAgentLifetime; } ------------------ | | 202| 0|#define T_HomeAgentLifetime 313 ------------------ 2108| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2109| 0|case 51: ------------------ | Branch (2109:1): [True: 0, False: 1.01M] ------------------ 2110| 0|YY_RULE_SETUP 2111| 0|#line 100 "scanner.l" 2112| 0|{ return T_AdvRoutePreference; } ------------------ | | 203| 0|#define T_AdvRoutePreference 314 ------------------ 2113| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2114| 0|case 52: ------------------ | Branch (2114:1): [True: 0, False: 1.01M] ------------------ 2115| 0|YY_RULE_SETUP 2116| 0|#line 101 "scanner.l" 2117| 0|{ return T_AdvRouteLifetime; } ------------------ | | 204| 0|#define T_AdvRouteLifetime 315 ------------------ 2118| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2119| 0|case 53: ------------------ | Branch (2119:1): [True: 0, False: 1.01M] ------------------ 2120| 0|YY_RULE_SETUP 2121| 0|#line 102 "scanner.l" 2122| 0|{ return T_RemoveRoute; } ------------------ | | 205| 0|#define T_RemoveRoute 316 ------------------ 2123| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2124| 0|case 54: ------------------ | Branch (2124:1): [True: 0, False: 1.01M] ------------------ 2125| 0|YY_RULE_SETUP 2126| 0|#line 104 "scanner.l" 2127| 0|{ return T_AdvRDNSSPreference; } ------------------ | | 206| 0|#define T_AdvRDNSSPreference 317 ------------------ 2128| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2129| 0|case 55: ------------------ | Branch (2129:1): [True: 0, False: 1.01M] ------------------ 2130| 0|YY_RULE_SETUP 2131| 0|#line 105 "scanner.l" 2132| 0|{ return T_AdvRDNSSOpenFlag; } ------------------ | | 207| 0|#define T_AdvRDNSSOpenFlag 318 ------------------ 2133| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2134| 0|case 56: ------------------ | Branch (2134:1): [True: 0, False: 1.01M] ------------------ 2135| 0|YY_RULE_SETUP 2136| 0|#line 106 "scanner.l" 2137| 0|{ return T_AdvRDNSSLifetime; } ------------------ | | 208| 0|#define T_AdvRDNSSLifetime 319 ------------------ 2138| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2139| 0|case 57: ------------------ | Branch (2139:1): [True: 0, False: 1.01M] ------------------ 2140| 0|YY_RULE_SETUP 2141| 0|#line 107 "scanner.l" 2142| 0|{ return T_FlushRDNSS; } ------------------ | | 209| 0|#define T_FlushRDNSS 320 ------------------ 2143| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2144| 0|case 58: ------------------ | Branch (2144:1): [True: 0, False: 1.01M] ------------------ 2145| 0|YY_RULE_SETUP 2146| 0|#line 109 "scanner.l" 2147| 0|{ return T_AdvDNSSLLifetime; } ------------------ | | 210| 0|#define T_AdvDNSSLLifetime 321 ------------------ 2148| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2149| 0|case 59: ------------------ | Branch (2149:1): [True: 0, False: 1.01M] ------------------ 2150| 0|YY_RULE_SETUP 2151| 0|#line 110 "scanner.l" 2152| 0|{ return T_FlushDNSSL; } ------------------ | | 211| 0|#define T_FlushDNSSL 322 ------------------ 2153| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2154| 0|case 60: ------------------ | Branch (2154:1): [True: 0, False: 1.01M] ------------------ 2155| 0|YY_RULE_SETUP 2156| 0|#line 112 "scanner.l" 2157| 0|{ return T_AdvDNRPriority; } ------------------ | | 212| 0|#define T_AdvDNRPriority 323 ------------------ 2158| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2159| 0|case 61: ------------------ | Branch (2159:1): [True: 0, False: 1.01M] ------------------ 2160| 0|YY_RULE_SETUP 2161| 0|#line 113 "scanner.l" 2162| 0|{ return T_AdvDNRLifetime; } ------------------ | | 213| 0|#define T_AdvDNRLifetime 324 ------------------ 2163| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2164| 0|case 62: ------------------ | Branch (2164:1): [True: 0, False: 1.01M] ------------------ 2165| 0|YY_RULE_SETUP 2166| 0|#line 114 "scanner.l" 2167| 0|{ return T_AdvDNRAddr; } ------------------ | | 214| 0|#define T_AdvDNRAddr 325 ------------------ 2168| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2169| 0|case 63: ------------------ | Branch (2169:1): [True: 0, False: 1.01M] ------------------ 2170| 0|YY_RULE_SETUP 2171| 0|#line 115 "scanner.l" 2172| 0|{ return T_AdvDNRSvcAlpn; } ------------------ | | 215| 0|#define T_AdvDNRSvcAlpn 326 ------------------ 2173| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2174| 0|case 64: ------------------ | Branch (2174:1): [True: 0, False: 1.01M] ------------------ 2175| 0|YY_RULE_SETUP 2176| 0|#line 116 "scanner.l" 2177| 0|{ return T_AdvDNRSvcPort; } ------------------ | | 216| 0|#define T_AdvDNRSvcPort 327 ------------------ 2178| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2179| 0|case 65: ------------------ | Branch (2179:1): [True: 0, False: 1.01M] ------------------ 2180| 0|YY_RULE_SETUP 2181| 0|#line 117 "scanner.l" 2182| 0|{ return T_AdvDNRSvcDohpath; } ------------------ | | 217| 0|#define T_AdvDNRSvcDohpath 328 ------------------ 2183| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2184| 0|case 66: ------------------ | Branch (2184:1): [True: 0, False: 1.01M] ------------------ 2185| 0|YY_RULE_SETUP 2186| 0|#line 118 "scanner.l" 2187| 0|{ return T_FlushDNR; } ------------------ | | 218| 0|#define T_FlushDNR 329 ------------------ 2188| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2189| 0|case 67: ------------------ | Branch (2189:1): [True: 0, False: 1.01M] ------------------ 2190| 0|YY_RULE_SETUP 2191| 0|#line 120 "scanner.l" 2192| 0|{ return T_MinDelayBetweenRAs; } ------------------ | | 171| 0|#define T_MinDelayBetweenRAs 282 ------------------ 2193| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2194| 0|case 68: ------------------ | Branch (2194:1): [True: 0, False: 1.01M] ------------------ 2195| 0|YY_RULE_SETUP 2196| 0|#line 122 "scanner.l" 2197| 0|{ return T_AdvMobRtrSupportFlag; } ------------------ | | 219| 0|#define T_AdvMobRtrSupportFlag 330 ------------------ 2198| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2199| 0|case 69: ------------------ | Branch (2199:1): [True: 0, False: 1.01M] ------------------ 2200| 0|YY_RULE_SETUP 2201| 0|#line 124 "scanner.l" 2202| 0|{ return T_AdvContextLength; } ------------------ | | 220| 0|#define T_AdvContextLength 331 ------------------ 2203| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2204| 0|case 70: ------------------ | Branch (2204:1): [True: 0, False: 1.01M] ------------------ 2205| 0|YY_RULE_SETUP 2206| 0|#line 125 "scanner.l" 2207| 0|{ return T_AdvContextCompressionFlag; } ------------------ | | 221| 0|#define T_AdvContextCompressionFlag 332 ------------------ 2208| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2209| 0|case 71: ------------------ | Branch (2209:1): [True: 0, False: 1.01M] ------------------ 2210| 0|YY_RULE_SETUP 2211| 0|#line 126 "scanner.l" 2212| 0|{ return T_AdvContextID; } ------------------ | | 222| 0|#define T_AdvContextID 333 ------------------ 2213| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2214| 0|case 72: ------------------ | Branch (2214:1): [True: 0, False: 1.01M] ------------------ 2215| 0|YY_RULE_SETUP 2216| 0|#line 127 "scanner.l" 2217| 0|{ return T_AdvLifeTime; } ------------------ | | 223| 0|#define T_AdvLifeTime 334 ------------------ 2218| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2219| 0|case 73: ------------------ | Branch (2219:1): [True: 0, False: 1.01M] ------------------ 2220| 0|YY_RULE_SETUP 2221| 0|#line 128 "scanner.l" 2222| 0|{ return T_AdvContextPrefix; } ------------------ | | 224| 0|#define T_AdvContextPrefix 335 ------------------ 2223| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2224| 0|case 74: ------------------ | Branch (2224:1): [True: 0, False: 1.01M] ------------------ 2225| 0|YY_RULE_SETUP 2226| 0|#line 130 "scanner.l" 2227| 0|{ return T_AdvVersionLow; } ------------------ | | 225| 0|#define T_AdvVersionLow 336 ------------------ 2228| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2229| 0|case 75: ------------------ | Branch (2229:1): [True: 0, False: 1.01M] ------------------ 2230| 0|YY_RULE_SETUP 2231| 0|#line 131 "scanner.l" 2232| 0|{ return T_AdvVersionHigh; } ------------------ | | 226| 0|#define T_AdvVersionHigh 337 ------------------ 2233| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2234| 0|case 76: ------------------ | Branch (2234:1): [True: 0, False: 1.01M] ------------------ 2235| 0|YY_RULE_SETUP 2236| 0|#line 132 "scanner.l" 2237| 0|{ return T_Adv6LBRaddress; } ------------------ | | 227| 0|#define T_Adv6LBRaddress 338 ------------------ 2238| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2239| 7|case 77: ------------------ | Branch (2239:1): [True: 7, False: 1.01M] ------------------ 2240| 7|YY_RULE_SETUP 2241| 7|#line 134 "scanner.l" 2242| 7|{ 2243| 7| static struct in6_addr addr; 2244| 7| if (inet_pton(AF_INET6, yytext, &addr) < 1) { ------------------ | Branch (2244:8): [True: 1, False: 6] ------------------ 2245| 1| return T_BAD_TOKEN; ------------------ | | 228| 1|#define T_BAD_TOKEN 339 ------------------ 2246| 1| } 2247| | 2248| 6| yylval.addr = &addr; 2249| 6| return IPV6ADDR; ------------------ | | 164| 6|#define IPV6ADDR 275 ------------------ 2250| 7| } 2251| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2252| 5|case 78: ------------------ | Branch (2252:1): [True: 5, False: 1.01M] ------------------ 2253| 5|YY_RULE_SETUP 2254| 5|#line 144 "scanner.l" 2255| 5|{ 2256| 5| static struct in6_addr addr; 2257| 5| if (inet_pton(AF_INET6, &yytext[1], &addr) < 1) { ------------------ | Branch (2257:8): [True: 2, False: 3] ------------------ 2258| 2| return T_BAD_TOKEN; ------------------ | | 228| 2|#define T_BAD_TOKEN 339 ------------------ 2259| 2| } 2260| | 2261| 3| yylval.addr = &addr; 2262| 3| return NOT_IPV6ADDR; ------------------ | | 165| 3|#define NOT_IPV6ADDR 276 ------------------ 2263| 5| } 2264| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2265| 134|case 79: ------------------ | Branch (2265:1): [True: 134, False: 1.01M] ------------------ 2266| 134|YY_RULE_SETUP 2267| 134|#line 154 "scanner.l" 2268| 134|{ 2269| 134| unsigned long lnum; 2270| 134| char *endp; 2271| 134| lnum = strtoul(yytext, &endp, 10); 2272| 134| if (*yytext == '\0' || *endp != '\0') ------------------ | Branch (2272:8): [True: 0, False: 134] | Branch (2272:27): [True: 0, False: 134] ------------------ 2273| 0| return T_BAD_TOKEN; ------------------ | | 228| 0|#define T_BAD_TOKEN 339 ------------------ 2274| 134| if (lnum > 0xFFFFFFFFUL) ------------------ | Branch (2274:8): [True: 67, False: 67] ------------------ 2275| 67| return T_BAD_TOKEN; /* XXX */ ------------------ | | 228| 67|#define T_BAD_TOKEN 339 ------------------ 2276| 67| yylval.num = lnum; 2277| 67| return NUMBER; ------------------ | | 160| 67|#define NUMBER 271 ------------------ 2278| 134| } 2279| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2280| 2|case 80: ------------------ | Branch (2280:1): [True: 2, False: 1.01M] ------------------ 2281| 2|YY_RULE_SETUP 2282| 2|#line 166 "scanner.l" 2283| 2|{ yylval.snum = atoi(yytext); return SIGNEDNUMBER; } ------------------ | | 161| 2|#define SIGNEDNUMBER 272 ------------------ 2284| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2285| 1|case 81: ------------------ | Branch (2285:1): [True: 1, False: 1.01M] ------------------ 2286| 1|YY_RULE_SETUP 2287| 1|#line 168 "scanner.l" 2288| 1|{ yylval.dec = atof(yytext); return DECIMAL; } ------------------ | | 162| 1|#define DECIMAL 273 ------------------ 2289| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2290| 1|case 82: ------------------ | Branch (2290:1): [True: 1, False: 1.01M] ------------------ 2291| 1|YY_RULE_SETUP 2292| 1|#line 170 "scanner.l" 2293| 1|{ return INFINITY; } ------------------ | | 166| 1|#define INFINITY 277 ------------------ 2294| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2295| 2|case 83: ------------------ | Branch (2295:1): [True: 2, False: 1.01M] ------------------ 2296| 2|YY_RULE_SETUP 2297| 2|#line 172 "scanner.l" 2298| 2|{ yylval.num = 1; return SWITCH; } ------------------ | | 163| 2|#define SWITCH 274 ------------------ 2299| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2300| 1|case 84: ------------------ | Branch (2300:1): [True: 1, False: 1.01M] ------------------ 2301| 1|YY_RULE_SETUP 2302| 1|#line 174 "scanner.l" 2303| 1|{ yylval.num = 0; return SWITCH; } ------------------ | | 163| 1|#define SWITCH 274 ------------------ 2304| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2305| 1|case 85: ------------------ | Branch (2305:1): [True: 1, False: 1.01M] ------------------ 2306| 1|YY_RULE_SETUP 2307| 1|#line 176 "scanner.l" 2308| 1|{ yylval.snum = -1; return SIGNEDNUMBER; } ------------------ | | 161| 1|#define SIGNEDNUMBER 272 ------------------ 2309| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2310| 0|case 86: ------------------ | Branch (2310:1): [True: 0, False: 1.01M] ------------------ 2311| 0|YY_RULE_SETUP 2312| 0|#line 178 "scanner.l" 2313| 0|{ yylval.snum = 0; return SIGNEDNUMBER; } ------------------ | | 161| 0|#define SIGNEDNUMBER 272 ------------------ 2314| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2315| 2|case 87: ------------------ | Branch (2315:1): [True: 2, False: 1.01M] ------------------ 2316| 2|YY_RULE_SETUP 2317| 2|#line 180 "scanner.l" 2318| 2|{ yylval.snum = 1; return SIGNEDNUMBER; } ------------------ | | 161| 2|#define SIGNEDNUMBER 272 ------------------ 2319| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2320| 316|case 88: ------------------ | Branch (2320:1): [True: 316, False: 1.00M] ------------------ 2321| |/* rule 88 can match eol */ 2322| 316|YY_RULE_SETUP 2323| 316|#line 182 "scanner.l" 2324| 316|{ 2325| 316| static char string[256]; 2326| | 2327| 316| if (yyleng >= (int)sizeof(string)) { ------------------ | Branch (2327:8): [True: 45, False: 271] ------------------ 2328| 45| flog(LOG_ERR, "string constant exceeds %zu bytes at line %d", 2329| 45| sizeof(string) - 1, num_lines); 2330| 45| return T_BAD_TOKEN; ------------------ | | 228| 45|#define T_BAD_TOKEN 339 ------------------ 2331| 45| } 2332| | 2333| 271| strncpy(string, yytext, sizeof(string)); 2334| 271| string[sizeof(string)-1] = '\0'; 2335| 271| yylval.str = string; 2336| 271| return STRING; ------------------ | | 159| 271|#define STRING 270 ------------------ 2337| 316| } 2338| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2339| 4|case 89: ------------------ | Branch (2339:1): [True: 4, False: 1.01M] ------------------ 2340| 4|YY_RULE_SETUP 2341| 4|#line 197 "scanner.l" 2342| 4|{ return *yytext; } 2343| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2344| 102|case 90: ------------------ | Branch (2344:1): [True: 102, False: 1.01M] ------------------ 2345| 102|YY_RULE_SETUP 2346| 102|#line 199 "scanner.l" 2347| 102|{ return T_BAD_TOKEN; } ------------------ | | 228| 102|#define T_BAD_TOKEN 339 ------------------ 2348| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2349| 0|case 91: ------------------ | Branch (2349:1): [True: 0, False: 1.01M] ------------------ 2350| 0|YY_RULE_SETUP 2351| 0|#line 200 "scanner.l" 2352| 0|ECHO; ------------------ | | 1665| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (1665:23): [True: 0, False: 0] | | | Branch (1665:80): [Folded, False: 0] | | ------------------ ------------------ 2353| 0| YY_BREAK ------------------ | | 1744| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2354| 0|#line 2355 "scanner.c" 2355| 48|case YY_STATE_EOF(INITIAL): ------------------ | | 125| 48|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 377| 48|#define YY_END_OF_BUFFER 92 | | ------------------ ------------------ | Branch (2355:1): [True: 48, False: 1.01M] ------------------ 2356| 48| yyterminate(); ------------------ | | 1709| 48|#define yyterminate() return YY_NULL | | ------------------ | | | | 106| 48|#define YY_NULL 0 | | ------------------ ------------------ 2357| | 2358| 93.1k| case YY_END_OF_BUFFER: ------------------ | | 377| 93.1k|#define YY_END_OF_BUFFER 92 ------------------ | Branch (2358:2): [True: 93.1k, False: 917k] ------------------ 2359| 93.1k| { 2360| | /* Amount of text matched not including the EOB char. */ 2361| 93.1k| int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ------------------ | | 360| 93.1k|#define yytext_ptr yytext ------------------ 2362| | 2363| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2364| 93.1k| *yy_cp = (yy_hold_char); 2365| 93.1k| YY_RESTORE_YY_MORE_OFFSET 2366| | 2367| 93.1k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 284| 93.1k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 250| 93.1k|#define YY_BUFFER_NEW 0 ------------------ | Branch (2367:8): [True: 634, False: 92.4k] ------------------ 2368| 634| { 2369| | /* We're scanning a new file or input source. It's 2370| | * possible that this happened because the user 2371| | * just pointed yyin at a new source and called 2372| | * yylex(). If so, then we have to assure 2373| | * consistency between YY_CURRENT_BUFFER and our 2374| | * globals. Here is the right place to do so, because 2375| | * this is the first action (other than possibly a 2376| | * back-up) that will match for the new input source. 2377| | */ 2378| 634| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2379| 634| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2380| 634| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 251| 634|#define YY_BUFFER_NORMAL 1 ------------------ 2381| 634| } 2382| | 2383| | /* Note that here we test for yy_c_buf_p "<=" to the position 2384| | * of the first EOB in the buffer, since yy_c_buf_p will 2385| | * already have been incremented past the NUL character 2386| | * (since all states make transitions on EOB to the 2387| | * end-of-buffer state). Contrast this with the test 2388| | * in input(). 2389| | */ 2390| 93.1k| if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ------------------ | | 284| 93.1k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2390:8): [True: 89.9k, False: 3.11k] ------------------ 2391| 89.9k| { /* This was really a NUL. */ 2392| 89.9k| yy_state_type yy_next_state; 2393| | 2394| 89.9k| (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 360| 89.9k|#define yytext_ptr yytext ------------------ 2395| | 2396| 89.9k| yy_current_state = yy_get_previous_state( ); 2397| | 2398| | /* Okay, we're now positioned to make the NUL 2399| | * transition. We couldn't have 2400| | * yy_get_previous_state() go ahead and do it 2401| | * for us because it doesn't know how to deal 2402| | * with the possibility of jamming (and we don't 2403| | * want to build jamming into it because then it 2404| | * will run more slowly). 2405| | */ 2406| | 2407| 89.9k| yy_next_state = yy_try_NUL_trans( yy_current_state ); 2408| | 2409| 89.9k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 89.9k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1542| 89.9k|#define YY_MORE_ADJ 0 ------------------ 2410| | 2411| 89.9k| if ( yy_next_state ) ------------------ | Branch (2411:9): [True: 89.9k, False: 85] ------------------ 2412| 89.9k| { 2413| | /* Consume the NUL. */ 2414| 89.9k| yy_cp = ++(yy_c_buf_p); 2415| 89.9k| yy_current_state = yy_next_state; 2416| 89.9k| goto yy_match; 2417| 89.9k| } 2418| | 2419| 85| else 2420| 85| { 2421| 85| yy_cp = (yy_c_buf_p); 2422| 85| goto yy_find_action; 2423| 85| } 2424| 89.9k| } 2425| | 2426| 3.11k| else switch ( yy_get_next_buffer( ) ) ------------------ | Branch (2426:17): [True: 3.11k, False: 0] ------------------ 2427| 3.11k| { 2428| 48| case EOB_ACT_END_OF_FILE: ------------------ | | 162| 48|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (2428:4): [True: 48, False: 3.07k] ------------------ 2429| 48| { 2430| 48| (yy_did_buffer_switch_on_eof) = 0; 2431| | 2432| 48| if ( yywrap( ) ) ------------------ | | 345| 48|#define yywrap() (/*CONSTCOND*/1) | | ------------------ | | | Branch (345:18): [True: 48, Folded] | | ------------------ ------------------ 2433| 48| { 2434| | /* Note: because we've taken care in 2435| | * yy_get_next_buffer() to have set up 2436| | * yytext, we can now set up 2437| | * yy_c_buf_p so that if some total 2438| | * hoser (like flex itself) wants to 2439| | * call the scanner after we return the 2440| | * YY_NULL, it'll still work - another 2441| | * YY_NULL will get returned. 2442| | */ 2443| 48| (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 48|#define yytext_ptr yytext ------------------ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1542| 48|#define YY_MORE_ADJ 0 ------------------ 2444| | 2445| 48| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 125| 48|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 377| 48|#define YY_END_OF_BUFFER 92 | | ------------------ ------------------ 2446| 48| goto do_action; 2447| 48| } 2448| | 2449| 0| else 2450| 0| { 2451| 0| if ( ! (yy_did_buffer_switch_on_eof) ) ------------------ | Branch (2451:11): [True: 0, False: 0] ------------------ 2452| 0| YY_NEW_FILE; ------------------ | | 127| 0|#define YY_NEW_FILE yyrestart( yyin ) ------------------ 2453| 0| } 2454| 0| break; 2455| 48| } 2456| | 2457| 2.58k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 161| 2.58k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (2457:4): [True: 2.58k, False: 535] ------------------ 2458| 2.58k| (yy_c_buf_p) = 2459| 2.58k| (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 360| 2.58k|#define yytext_ptr yytext ------------------ 2460| | 2461| 2.58k| yy_current_state = yy_get_previous_state( ); 2462| | 2463| 2.58k| yy_cp = (yy_c_buf_p); 2464| 2.58k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 2.58k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1542| 2.58k|#define YY_MORE_ADJ 0 ------------------ 2465| 2.58k| goto yy_match; 2466| | 2467| 487| case EOB_ACT_LAST_MATCH: ------------------ | | 163| 487|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (2467:4): [True: 487, False: 2.63k] ------------------ 2468| 487| (yy_c_buf_p) = 2469| 487| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ------------------ | | 284| 487|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2470| | 2471| 487| yy_current_state = yy_get_previous_state( ); 2472| | 2473| 487| yy_cp = (yy_c_buf_p); 2474| 487| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 360| 487|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 1542| 487|#define YY_MORE_ADJ 0 ------------------ 2475| 487| goto yy_find_action; 2476| 3.11k| } 2477| 0| break; 2478| 93.1k| } 2479| | 2480| 0| default: ------------------ | Branch (2480:2): [True: 0, False: 1.01M] ------------------ 2481| 0| YY_FATAL_ERROR( ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2482| 1.01M| "fatal flex scanner internal error--no action found" ); 2483| 1.01M| } /* end of action switch */ 2484| 1.01M| } /* end of scanning one token */ 2485| 634| } /* end of user's declarations */ 2486| 634|} /* end of yylex */ yyrestart: 2777| 48|{ 2778| | 2779| 48| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 278| 48|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 48, False: 0] | | ------------------ | | 279| 48| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 48| : NULL) ------------------ | Branch (2779:7): [True: 0, False: 48] ------------------ 2780| 0| yyensure_buffer_stack (); 2781| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2782| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 139| 0|#define YY_BUF_SIZE 16384 ------------------ 2783| 0| } 2784| | 2785| | yy_init_buffer( YY_CURRENT_BUFFER, input_file ); ------------------ | | 278| 48|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 48, False: 0] | | ------------------ | | 279| 48| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 48| : NULL) ------------------ 2786| 48| yy_load_buffer_state( ); 2787| 48|} yy_create_buffer: 2839| 634|{ 2840| 634| YY_BUFFER_STATE b; 2841| | 2842| 634| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 2843| 634| if ( ! b ) ------------------ | Branch (2843:7): [True: 0, False: 634] ------------------ 2844| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2845| | 2846| 634| b->yy_buf_size = size; 2847| | 2848| | /* yy_ch_buf has to be 2 characters longer than the size given because 2849| | * we need to put in 2 end-of-buffer characters. 2850| | */ 2851| 634| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 2852| 634| if ( ! b->yy_ch_buf ) ------------------ | Branch (2852:7): [True: 0, False: 634] ------------------ 2853| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2854| | 2855| 634| b->yy_is_our_buffer = 1; 2856| | 2857| 634| yy_init_buffer( b, file ); 2858| | 2859| 634| return b; 2860| 634|} yy_delete_buffer: 2867| 634|{ 2868| | 2869| 634| if ( ! b ) ------------------ | Branch (2869:7): [True: 0, False: 634] ------------------ 2870| 0| return; 2871| | 2872| 634| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 278| 634|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 634, False: 0] | | ------------------ | | 279| 634| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 634| : NULL) ------------------ | Branch (2872:7): [True: 634, False: 0] ------------------ 2873| 634| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2874| | 2875| 634| if ( b->yy_is_our_buffer ) ------------------ | Branch (2875:7): [True: 634, False: 0] ------------------ 2876| 634| yyfree( (void *) b->yy_ch_buf ); 2877| | 2878| 634| yyfree( (void *) b ); 2879| 634|} yy_flush_buffer: 2914| 682|{ 2915| 682| if ( ! b ) ------------------ | Branch (2915:11): [True: 0, False: 682] ------------------ 2916| 0| return; 2917| | 2918| 682| b->yy_n_chars = 0; 2919| | 2920| | /* We always need two end-of-buffer characters. The first causes 2921| | * a transition to the end-of-buffer state. The second causes 2922| | * a jam in that state. 2923| | */ 2924| 682| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 682|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2925| 682| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 682|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2926| | 2927| 682| b->yy_buf_pos = &b->yy_ch_buf[0]; 2928| | 2929| 682| b->yy_at_bol = 1; 2930| 682| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 250| 682|#define YY_BUFFER_NEW 0 ------------------ 2931| | 2932| 682| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 278| 682|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 682, False: 0] | | ------------------ | | 279| 682| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 682| : NULL) ------------------ | Branch (2932:7): [True: 48, False: 634] ------------------ 2933| 48| yy_load_buffer_state( ); 2934| 682|} yypop_buffer_state: 2973| 634|{ 2974| 634| if (!YY_CURRENT_BUFFER) ------------------ | | 278| 634|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 634, False: 0] | | ------------------ | | 279| 634| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 634| : NULL) ------------------ | Branch (2974:10): [True: 634, False: 0] ------------------ 2975| 634| return; 2976| | 2977| 0| yy_delete_buffer(YY_CURRENT_BUFFER ); ------------------ | | 278| 0|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 0, False: 0] | | ------------------ | | 279| 0| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 0| : NULL) ------------------ 2978| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2979| 0| if ((yy_buffer_stack_top) > 0) ------------------ | Branch (2979:6): [True: 0, False: 0] ------------------ 2980| 0| --(yy_buffer_stack_top); 2981| | 2982| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 278| 0|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:27): [True: 0, False: 0] | | | Branch (278:29): [True: 0, False: 0] | | ------------------ | | 279| 0| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 0| : NULL) ------------------ 2983| 0| yy_load_buffer_state( ); 2984| 0| (yy_did_buffer_switch_on_eof) = 1; 2985| 0| } 2986| 0|} yyset_in: 3208| 634|{ 3209| 634| yyin = _in_str ; 3210| 634|} yylex_destroy: 3260| 634|{ 3261| | 3262| | /* Pop the buffer stack, destroying each element. */ 3263| 1.26k| while(YY_CURRENT_BUFFER){ ------------------ | | 278| 1.26k|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:27): [True: 634, False: 634] | | | Branch (278:29): [True: 1.26k, False: 0] | | ------------------ | | 279| 1.26k| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 1.26k| : NULL) ------------------ 3264| 634| yy_delete_buffer( YY_CURRENT_BUFFER ); ------------------ | | 278| 634|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 634, False: 0] | | ------------------ | | 279| 634| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 634| : NULL) ------------------ 3265| 634| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 284| 634|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 3266| 634| yypop_buffer_state(); 3267| 634| } 3268| | 3269| | /* Destroy the stack itself. */ 3270| 634| yyfree((yy_buffer_stack) ); 3271| 634| (yy_buffer_stack) = NULL; 3272| | 3273| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 3274| | * yylex() is called, initialization will occur. */ 3275| 634| yy_init_globals( ); 3276| | 3277| 634| return 0; 3278| 634|} yyalloc: 3306| 1.90k|{ 3307| 1.90k| return malloc(size); 3308| 1.90k|} yyrealloc: 3311| 139|{ 3312| | 3313| | /* The cast to (char *) in the following accommodates both 3314| | * implementations that use char* generic pointers, and those 3315| | * that use void* generic pointers. It works with the latter 3316| | * because both ANSI C and C++ allow castless assignment from 3317| | * any pointer type to void*, and deal with argument conversions 3318| | * as though doing an assignment. 3319| | */ 3320| 139| return realloc(ptr, size); 3321| 139|} yyfree: 3324| 1.90k|{ 3325| 1.90k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3326| 1.90k|} scanner.c:yy_get_next_buffer: 2496| 3.11k|{ 2497| 3.11k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2498| 3.11k| char *source = (yytext_ptr); ------------------ | | 360| 3.11k|#define yytext_ptr yytext ------------------ 2499| 3.11k| int number_to_move, i; 2500| 3.11k| int ret_val; 2501| | 2502| 3.11k| if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2502:7): [True: 0, False: 3.11k] ------------------ 2503| 0| YY_FATAL_ERROR( ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2504| 3.11k| "fatal flex scanner internal error--end of buffer missed" ); 2505| | 2506| 3.11k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2506:7): [True: 0, False: 3.11k] ------------------ 2507| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 2508| 0| if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 360| 0|#define yytext_ptr yytext ------------------ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 1542| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (2508:8): [True: 0, False: 0] ------------------ 2509| 0| { 2510| | /* We matched a single character, the EOB, so 2511| | * treat this as a final EOF. 2512| | */ 2513| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 162| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 2514| 0| } 2515| | 2516| 0| else 2517| 0| { 2518| | /* We matched some text prior to the EOB, first 2519| | * process it. 2520| | */ 2521| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 163| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 2522| 0| } 2523| 0| } 2524| | 2525| | /* Try to read more data. */ 2526| | 2527| | /* First move last chars to start of buffer. */ 2528| 3.11k| number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); ------------------ | | 360| 3.11k|#define yytext_ptr yytext ------------------ 2529| | 2530| 202M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (2530:15): [True: 202M, False: 3.11k] ------------------ 2531| 202M| *(dest++) = *(source++); 2532| | 2533| 3.11k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 262| 3.11k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (2533:7): [True: 20, False: 3.09k] ------------------ 2534| | /* don't do the read, it's not guaranteed to return an EOF, 2535| | * just force an EOF 2536| | */ 2537| 20| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ------------------ | | 284| 20|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2538| | 2539| 3.09k| else 2540| 3.09k| { 2541| 3.09k| int num_to_read = 2542| 3.09k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 284| 3.09k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2543| | 2544| 3.23k| while ( num_to_read <= 0 ) ------------------ | Branch (2544:11): [True: 139, False: 3.09k] ------------------ 2545| 139| { /* Not enough room in the buffer - grow it. */ 2546| | 2547| | /* just a shorter name for the current buffer */ 2548| 139| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 284| 139|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2549| | 2550| 139| int yy_c_buf_p_offset = 2551| 139| (int) ((yy_c_buf_p) - b->yy_ch_buf); 2552| | 2553| 139| if ( b->yy_is_our_buffer ) ------------------ | Branch (2553:9): [True: 139, False: 0] ------------------ 2554| 139| { 2555| 139| int new_size = b->yy_buf_size * 2; 2556| | 2557| 139| if ( new_size <= 0 ) ------------------ | Branch (2557:10): [True: 0, False: 139] ------------------ 2558| 0| b->yy_buf_size += b->yy_buf_size / 8; 2559| 139| else 2560| 139| b->yy_buf_size *= 2; 2561| | 2562| 139| b->yy_ch_buf = (char *) 2563| | /* Include room in for 2 EOB chars. */ 2564| 139| yyrealloc( (void *) b->yy_ch_buf, 2565| 139| (yy_size_t) (b->yy_buf_size + 2) ); 2566| 139| } 2567| 0| else 2568| | /* Can't grow it, we don't own it. */ 2569| 0| b->yy_ch_buf = NULL; 2570| | 2571| 139| if ( ! b->yy_ch_buf ) ------------------ | Branch (2571:9): [True: 0, False: 139] ------------------ 2572| 0| YY_FATAL_ERROR( ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2573| 139| "fatal error - scanner input buffer overflow" ); 2574| | 2575| 139| (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 2576| | 2577| 139| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 284| 139|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2578| 139| number_to_move - 1; 2579| | 2580| 139| } 2581| | 2582| 3.09k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1656| 3.09k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (2582:8): [True: 2.65k, False: 447] ------------------ 2583| 2.65k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1656| 2.65k|#define YY_READ_BUF_SIZE 8192 ------------------ 2584| | 2585| | /* Read in more data. */ 2586| 3.09k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1673| 3.09k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 284| 3.09k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | | Branch (1673:7): [True: 0, False: 3.09k] | | ------------------ | | 1674| 3.09k| { \ | | 1675| 0| int c = '*'; \ | | 1676| 0| int n; \ | | 1677| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1677:16): [True: 0, False: 0] | | ------------------ | | 1678| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | Branch (1678:9): [True: 0, False: 0] | | | Branch (1678:38): [True: 0, False: 0] | | ------------------ | | 1679| 0| buf[n] = (char) c; \ | | 1680| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1680:8): [True: 0, False: 0] | | ------------------ | | 1681| 0| buf[n++] = (char) c; \ | | 1682| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | Branch (1682:8): [True: 0, False: 0] | | | Branch (1682:20): [True: 0, False: 0] | | ------------------ | | 1683| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 1684| 0| result = n; \ | | 1685| 0| } \ | | 1686| 3.09k| else \ | | 1687| 3.09k| { \ | | 1688| 3.09k| errno=0; \ | | 1689| 3.09k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | Branch (1689:11): [True: 515, False: 2.58k] | | | Branch (1689:78): [True: 0, False: 515] | | ------------------ | | 1690| 3.09k| { \ | | 1691| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1691:8): [True: 0, False: 0] | | ------------------ | | 1692| 0| { \ | | 1693| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 1694| 0| break; \ | | 1695| 0| } \ | | 1696| 0| errno=0; \ | | 1697| 0| clearerr(yyin); \ | | 1698| 0| } \ | | 1699| 3.09k| }\ ------------------ 2587| 3.09k| (yy_n_chars), num_to_read ); 2588| | 2589| 3.09k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ------------------ | | 284| 3.09k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2590| 3.09k| } 2591| | 2592| 3.11k| if ( (yy_n_chars) == 0 ) ------------------ | Branch (2592:7): [True: 535, False: 2.58k] ------------------ 2593| 535| { 2594| 535| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 1542| 535|#define YY_MORE_ADJ 0 ------------------ | Branch (2594:8): [True: 48, False: 487] ------------------ 2595| 48| { 2596| 48| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 162| 48|#define EOB_ACT_END_OF_FILE 1 ------------------ 2597| 48| yyrestart( yyin ); 2598| 48| } 2599| | 2600| 487| else 2601| 487| { 2602| 487| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 163| 487|#define EOB_ACT_LAST_MATCH 2 ------------------ 2603| 487| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 284| 487|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2604| 487| YY_BUFFER_EOF_PENDING; ------------------ | | 262| 487|#define YY_BUFFER_EOF_PENDING 2 ------------------ 2605| 487| } 2606| 535| } 2607| | 2608| 2.58k| else 2609| 2.58k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 161| 2.58k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 2610| | 2611| 3.11k| if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2611:6): [True: 0, False: 3.11k] ------------------ 2612| | /* Extend the array by 50%, plus the number we really need. */ 2613| 0| int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 2614| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2615| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2616| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2616:8): [True: 0, False: 0] ------------------ 2617| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 2618| | /* "- 2" to take care of EOB's */ 2619| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 284| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2620| 0| } 2621| | 2622| 3.11k| (yy_n_chars) += number_to_move; 2623| 3.11k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 3.11k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2624| 3.11k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 128| 3.11k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2625| | 2626| 3.11k| (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 360| 3.11k|#define yytext_ptr yytext ------------------ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 284| 3.11k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2627| | 2628| 3.11k| return ret_val; 2629| 3.11k|} scanner.c:yy_get_previous_state: 2634| 93.0k|{ 2635| 93.0k| yy_state_type yy_current_state; 2636| 93.0k| char *yy_cp; 2637| | 2638| 93.0k| yy_current_state = (yy_start); 2639| | 2640| 988M| for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 360| 93.0k|#define yytext_ptr yytext ------------------ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 1542| 93.0k|#define YY_MORE_ADJ 0 ------------------ | Branch (2640:44): [True: 987M, False: 93.0k] ------------------ 2641| 987M| { 2642| 987M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 111| 975M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (2642:19): [True: 975M, False: 12.4M] ------------------ 2643| 987M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2643:8): [True: 111M, False: 876M] ------------------ 2644| 111M| { 2645| 111M| (yy_last_accepting_state) = yy_current_state; 2646| 111M| (yy_last_accepting_cpos) = yy_cp; 2647| 111M| } 2648| 1.95G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2648:11): [True: 965M, False: 987M] ------------------ 2649| 965M| { 2650| 965M| yy_current_state = (int) yy_def[yy_current_state]; 2651| 965M| if ( yy_current_state >= 966 ) ------------------ | Branch (2651:9): [True: 965M, False: 4.71k] ------------------ 2652| 965M| yy_c = yy_meta[yy_c]; 2653| 965M| } 2654| 987M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2655| 987M| } 2656| | 2657| 93.0k| return yy_current_state; 2658| 93.0k|} scanner.c:yy_try_NUL_trans: 2666| 89.9k|{ 2667| 89.9k| int yy_is_jam; 2668| 89.9k| char *yy_cp = (yy_c_buf_p); 2669| | 2670| 89.9k| YY_CHAR yy_c = 1; 2671| 89.9k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2671:7): [True: 13.4k, False: 76.5k] ------------------ 2672| 13.4k| { 2673| 13.4k| (yy_last_accepting_state) = yy_current_state; 2674| 13.4k| (yy_last_accepting_cpos) = yy_cp; 2675| 13.4k| } 2676| 166k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2676:10): [True: 76.7k, False: 89.9k] ------------------ 2677| 76.7k| { 2678| 76.7k| yy_current_state = (int) yy_def[yy_current_state]; 2679| 76.7k| if ( yy_current_state >= 966 ) ------------------ | Branch (2679:8): [True: 76.6k, False: 163] ------------------ 2680| 76.6k| yy_c = yy_meta[yy_c]; 2681| 76.7k| } 2682| 89.9k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2683| 89.9k| yy_is_jam = (yy_current_state == 965); 2684| | 2685| 89.9k| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (2685:10): [True: 85, False: 89.9k] ------------------ 2686| 89.9k|} scanner.c:yy_load_buffer_state: 2825| 730|{ 2826| 730| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 284| 730|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2827| 730| (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 360| 730|#define yytext_ptr yytext ------------------ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 284| 730|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2828| 730| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 284| 730|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2829| 730| (yy_hold_char) = *(yy_c_buf_p); 2830| 730|} scanner.c:yy_init_buffer: 2887| 682|{ 2888| 682| int oerrno = errno; 2889| | 2890| 682| yy_flush_buffer( b ); 2891| | 2892| 682| b->yy_input_file = file; 2893| 682| b->yy_fill_buffer = 1; 2894| | 2895| | /* If b is the current buffer, then yy_init_buffer was _probably_ 2896| | * called from yyrestart() or through yy_get_next_buffer. 2897| | * In that case, we don't want to reset the lineno or column. 2898| | */ 2899| 682| if (b != YY_CURRENT_BUFFER){ ------------------ | | 278| 682|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (278:29): [True: 682, False: 0] | | ------------------ | | 279| 682| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 280| 682| : NULL) ------------------ | Branch (2899:9): [True: 634, False: 48] ------------------ 2900| 634| b->yy_bs_lineno = 1; 2901| 634| b->yy_bs_column = 0; 2902| 634| } 2903| | 2904| 682| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (2904:32): [True: 682, False: 0] ------------------ 2905| | 2906| | errno = oerrno; 2907| 682|} scanner.c:yyensure_buffer_stack: 2992| 634|{ 2993| 634| yy_size_t num_to_alloc; 2994| | 2995| 634| if (!(yy_buffer_stack)) { ------------------ | Branch (2995:6): [True: 634, False: 0] ------------------ 2996| | 2997| | /* First allocation is just for 2 elements, since we don't know if this 2998| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2999| | * immediate realloc on the next call. 3000| | */ 3001| 634| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 3002| 634| (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 3003| 634| (num_to_alloc * sizeof(struct yy_buffer_state*) 3004| 634| ); 3005| 634| if ( ! (yy_buffer_stack) ) ------------------ | Branch (3005:8): [True: 0, False: 634] ------------------ 3006| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 3007| | 3008| 634| memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 3009| | 3010| 634| (yy_buffer_stack_max) = num_to_alloc; 3011| 634| (yy_buffer_stack_top) = 0; 3012| 634| return; 3013| 634| } 3014| | 3015| 0| if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ------------------ | Branch (3015:6): [True: 0, False: 0] ------------------ 3016| | 3017| | /* Increase the buffer to prepare for a possible push. */ 3018| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 3019| | 3020| 0| num_to_alloc = (yy_buffer_stack_max) + grow_size; 3021| 0| (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 3022| 0| ((yy_buffer_stack), 3023| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 3024| 0| ); 3025| 0| if ( ! (yy_buffer_stack) ) ------------------ | Branch (3025:8): [True: 0, False: 0] ------------------ 3026| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 1719| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 3027| | 3028| | /* zero only the new slots.*/ 3029| 0| memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 3030| 0| (yy_buffer_stack_max) = num_to_alloc; 3031| 0| } 3032| 0|} scanner.c:yy_init_globals: 3228| 634|{ 3229| | /* Initialization is the same as for the non-reentrant scanner. 3230| | * This function is called from yylex_destroy(), so don't allocate here. 3231| | */ 3232| | 3233| | /* We do not touch yylineno unless the option is enabled. */ 3234| 634| yylineno = 1; 3235| | 3236| 634| (yy_buffer_stack) = NULL; 3237| 634| (yy_buffer_stack_top) = 0; 3238| 634| (yy_buffer_stack_max) = 0; 3239| 634| (yy_c_buf_p) = NULL; 3240| 634| (yy_init) = 0; 3241| 634| (yy_start) = 0; 3242| | 3243| |/* Defined in main.c */ 3244| |#ifdef YY_STDINIT 3245| | yyin = stdin; 3246| | yyout = stdout; 3247| |#else 3248| 634| yyin = NULL; 3249| 634| yyout = NULL; 3250| 634|#endif 3251| | 3252| | /* For future reference: Set errno on error, since we are called by 3253| | * yylex_init() 3254| | */ 3255| 634| return 0; 3256| 634|}