source: rtems-libbsd/freebsd/contrib/pf/pfctl/parse.y @ 084d4db

4.11
Last change on this file since 084d4db was 084d4db, checked in by Christian Mauderer <Christian.Mauderer@…>, on Jul 5, 2016 at 2:07:37 PM

pfctl: Import sources from FreeBSD.

  • Property mode set to 100644
File size: 137.7 KB
Line 
1/*      $OpenBSD: parse.y,v 1.554 2008/10/17 12:59:53 henning Exp $     */
2
3/*
4 * Copyright (c) 2001 Markus Friedl.  All rights reserved.
5 * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
6 * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
7 * Copyright (c) 2002,2003 Henning Brauer. All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29%{
30#ifdef __rtems__
31#include <machine/rtems-bsd-user-space.h>
32#define pf_find_or_create_ruleset _bsd_pf_find_or_create_ruleset
33#define pf_anchor_setup _bsd_pf_anchor_setup
34#define pf_remove_if_empty_ruleset _bsd_pf_remove_if_empty_ruleset
35#endif /* __rtems__ */
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD$");
38
39#include <sys/types.h>
40#include <sys/socket.h>
41#include <sys/stat.h>
42#ifdef __FreeBSD__
43#include <sys/sysctl.h>
44#endif
45#include <net/if.h>
46#include <netinet/in.h>
47#include <netinet/in_systm.h>
48#include <netinet/ip.h>
49#include <netinet/ip_icmp.h>
50#include <netinet/icmp6.h>
51#include <net/pfvar.h>
52#include <arpa/inet.h>
53#include <altq/altq.h>
54#include <altq/altq_cbq.h>
55#include <altq/altq_priq.h>
56#include <altq/altq_hfsc.h>
57
58#include <stdio.h>
59#include <unistd.h>
60#include <stdlib.h>
61#include <netdb.h>
62#include <stdarg.h>
63#include <errno.h>
64#include <string.h>
65#include <ctype.h>
66#include <math.h>
67#include <err.h>
68#include <limits.h>
69#include <pwd.h>
70#include <grp.h>
71#include <md5.h>
72
73#include "pfctl_parser.h"
74#include "pfctl.h"
75
76static struct pfctl     *pf = NULL;
77static int               debug = 0;
78static int               rulestate = 0;
79static u_int16_t         returnicmpdefault =
80                            (ICMP_UNREACH << 8) | ICMP_UNREACH_PORT;
81static u_int16_t         returnicmp6default =
82                            (ICMP6_DST_UNREACH << 8) | ICMP6_DST_UNREACH_NOPORT;
83static int               blockpolicy = PFRULE_DROP;
84static int               require_order = 1;
85static int               default_statelock;
86
87TAILQ_HEAD(files, file)          files = TAILQ_HEAD_INITIALIZER(files);
88static struct file {
89        TAILQ_ENTRY(file)        entry;
90        FILE                    *stream;
91        char                    *name;
92        int                      lineno;
93        int                      errors;
94} *file;
95struct file     *pushfile(const char *, int);
96int              popfile(void);
97int              check_file_secrecy(int, const char *);
98int              yyparse(void);
99int              yylex(void);
100int              yyerror(const char *, ...);
101int              kw_cmp(const void *, const void *);
102int              lookup(char *);
103int              lgetc(int);
104int              lungetc(int);
105int              findeol(void);
106
107TAILQ_HEAD(symhead, sym)         symhead = TAILQ_HEAD_INITIALIZER(symhead);
108struct sym {
109        TAILQ_ENTRY(sym)         entry;
110        int                      used;
111        int                      persist;
112        char                    *nam;
113        char                    *val;
114};
115int              symset(const char *, const char *, int);
116char            *symget(const char *);
117
118int              atoul(char *, u_long *);
119
120enum {
121        PFCTL_STATE_NONE,
122        PFCTL_STATE_OPTION,
123        PFCTL_STATE_SCRUB,
124        PFCTL_STATE_QUEUE,
125        PFCTL_STATE_NAT,
126        PFCTL_STATE_FILTER
127};
128
129struct node_proto {
130        u_int8_t                 proto;
131        struct node_proto       *next;
132        struct node_proto       *tail;
133};
134
135struct node_port {
136        u_int16_t                port[2];
137        u_int8_t                 op;
138        struct node_port        *next;
139        struct node_port        *tail;
140};
141
142struct node_uid {
143        uid_t                    uid[2];
144        u_int8_t                 op;
145        struct node_uid         *next;
146        struct node_uid         *tail;
147};
148
149struct node_gid {
150        gid_t                    gid[2];
151        u_int8_t                 op;
152        struct node_gid         *next;
153        struct node_gid         *tail;
154};
155
156struct node_icmp {
157        u_int8_t                 code;
158        u_int8_t                 type;
159        u_int8_t                 proto;
160        struct node_icmp        *next;
161        struct node_icmp        *tail;
162};
163
164enum    { PF_STATE_OPT_MAX, PF_STATE_OPT_NOSYNC, PF_STATE_OPT_SRCTRACK,
165            PF_STATE_OPT_MAX_SRC_STATES, PF_STATE_OPT_MAX_SRC_CONN,
166            PF_STATE_OPT_MAX_SRC_CONN_RATE, PF_STATE_OPT_MAX_SRC_NODES,
167            PF_STATE_OPT_OVERLOAD, PF_STATE_OPT_STATELOCK,
168            PF_STATE_OPT_TIMEOUT, PF_STATE_OPT_SLOPPY,
169            PF_STATE_OPT_PFLOW };
170
171enum    { PF_SRCTRACK_NONE, PF_SRCTRACK, PF_SRCTRACK_GLOBAL, PF_SRCTRACK_RULE };
172
173struct node_state_opt {
174        int                      type;
175        union {
176                u_int32_t        max_states;
177                u_int32_t        max_src_states;
178                u_int32_t        max_src_conn;
179                struct {
180                        u_int32_t       limit;
181                        u_int32_t       seconds;
182                }                max_src_conn_rate;
183                struct {
184                        u_int8_t        flush;
185                        char            tblname[PF_TABLE_NAME_SIZE];
186                }                overload;
187                u_int32_t        max_src_nodes;
188                u_int8_t         src_track;
189                u_int32_t        statelock;
190                struct {
191                        int             number;
192                        u_int32_t       seconds;
193                }                timeout;
194        }                        data;
195        struct node_state_opt   *next;
196        struct node_state_opt   *tail;
197};
198
199struct peer {
200        struct node_host        *host;
201        struct node_port        *port;
202};
203
204struct node_queue {
205        char                     queue[PF_QNAME_SIZE];
206        char                     parent[PF_QNAME_SIZE];
207        char                     ifname[IFNAMSIZ];
208        int                      scheduler;
209        struct node_queue       *next;
210        struct node_queue       *tail;
211}       *queues = NULL;
212
213struct node_qassign {
214        char            *qname;
215        char            *pqname;
216};
217
218struct filter_opts {
219        int                      marker;
220#define FOM_FLAGS       0x01
221#define FOM_ICMP        0x02
222#define FOM_TOS         0x04
223#define FOM_KEEP        0x08
224#define FOM_SRCTRACK    0x10
225        struct node_uid         *uid;
226        struct node_gid         *gid;
227        struct {
228                u_int8_t         b1;
229                u_int8_t         b2;
230                u_int16_t        w;
231                u_int16_t        w2;
232        } flags;
233        struct node_icmp        *icmpspec;
234        u_int32_t                tos;
235        u_int32_t                prob;
236        struct {
237                int                      action;
238                struct node_state_opt   *options;
239        } keep;
240        int                      fragment;
241        int                      allowopts;
242        char                    *label;
243        struct node_qassign      queues;
244        char                    *tag;
245        char                    *match_tag;
246        u_int8_t                 match_tag_not;
247        u_int                    rtableid;
248        struct {
249                struct node_host        *addr;
250                u_int16_t               port;
251        }                        divert;
252} filter_opts;
253
254struct antispoof_opts {
255        char                    *label;
256        u_int                    rtableid;
257} antispoof_opts;
258
259struct scrub_opts {
260        int                      marker;
261#define SOM_MINTTL      0x01
262#define SOM_MAXMSS      0x02
263#define SOM_FRAGCACHE   0x04
264#define SOM_SETTOS      0x08
265        int                      nodf;
266        int                      minttl;
267        int                      maxmss;
268        int                      settos;
269        int                      fragcache;
270        int                      randomid;
271        int                      reassemble_tcp;
272        char                    *match_tag;
273        u_int8_t                 match_tag_not;
274        u_int                    rtableid;
275} scrub_opts;
276
277struct queue_opts {
278        int                     marker;
279#define QOM_BWSPEC      0x01
280#define QOM_SCHEDULER   0x02
281#define QOM_PRIORITY    0x04
282#define QOM_TBRSIZE     0x08
283#define QOM_QLIMIT      0x10
284        struct node_queue_bw    queue_bwspec;
285        struct node_queue_opt   scheduler;
286        int                     priority;
287        int                     tbrsize;
288        int                     qlimit;
289} queue_opts;
290
291struct table_opts {
292        int                     flags;
293        int                     init_addr;
294        struct node_tinithead   init_nodes;
295} table_opts;
296
297struct pool_opts {
298        int                      marker;
299#define POM_TYPE                0x01
300#define POM_STICKYADDRESS       0x02
301        u_int8_t                 opts;
302        int                      type;
303        int                      staticport;
304        struct pf_poolhashkey   *key;
305
306} pool_opts;
307
308
309struct node_hfsc_opts    hfsc_opts;
310struct node_state_opt   *keep_state_defaults = NULL;
311
312int              disallow_table(struct node_host *, const char *);
313int              disallow_urpf_failed(struct node_host *, const char *);
314int              disallow_alias(struct node_host *, const char *);
315int              rule_consistent(struct pf_rule *, int);
316int              filter_consistent(struct pf_rule *, int);
317int              nat_consistent(struct pf_rule *);
318int              rdr_consistent(struct pf_rule *);
319int              process_tabledef(char *, struct table_opts *);
320void             expand_label_str(char *, size_t, const char *, const char *);
321void             expand_label_if(const char *, char *, size_t, const char *);
322void             expand_label_addr(const char *, char *, size_t, u_int8_t,
323                    struct node_host *);
324void             expand_label_port(const char *, char *, size_t,
325                    struct node_port *);
326void             expand_label_proto(const char *, char *, size_t, u_int8_t);
327void             expand_label_nr(const char *, char *, size_t);
328void             expand_label(char *, size_t, const char *, u_int8_t,
329                    struct node_host *, struct node_port *, struct node_host *,
330                    struct node_port *, u_int8_t);
331void             expand_rule(struct pf_rule *, struct node_if *,
332                    struct node_host *, struct node_proto *, struct node_os *,
333                    struct node_host *, struct node_port *, struct node_host *,
334                    struct node_port *, struct node_uid *, struct node_gid *,
335                    struct node_icmp *, const char *);
336int              expand_altq(struct pf_altq *, struct node_if *,
337                    struct node_queue *, struct node_queue_bw bwspec,
338                    struct node_queue_opt *);
339int              expand_queue(struct pf_altq *, struct node_if *,
340                    struct node_queue *, struct node_queue_bw,
341                    struct node_queue_opt *);
342int              expand_skip_interface(struct node_if *);
343
344int      check_rulestate(int);
345int      getservice(char *);
346int      rule_label(struct pf_rule *, char *);
347int      rt_tableid_max(void);
348
349void     mv_rules(struct pf_ruleset *, struct pf_ruleset *);
350void     decide_address_family(struct node_host *, sa_family_t *);
351void     remove_invalid_hosts(struct node_host **, sa_family_t *);
352int      invalid_redirect(struct node_host *, sa_family_t);
353u_int16_t parseicmpspec(char *, sa_family_t);
354
355TAILQ_HEAD(loadanchorshead, loadanchors)
356    loadanchorshead = TAILQ_HEAD_INITIALIZER(loadanchorshead);
357
358struct loadanchors {
359        TAILQ_ENTRY(loadanchors)         entries;
360        char                            *anchorname;
361        char                            *filename;
362};
363
364typedef struct {
365        union {
366                int64_t                  number;
367                double                   probability;
368                int                      i;
369                char                    *string;
370                u_int                    rtableid;
371                struct {
372                        u_int8_t         b1;
373                        u_int8_t         b2;
374                        u_int16_t        w;
375                        u_int16_t        w2;
376                }                        b;
377                struct range {
378                        int              a;
379                        int              b;
380                        int              t;
381                }                        range;
382                struct node_if          *interface;
383                struct node_proto       *proto;
384                struct node_icmp        *icmp;
385                struct node_host        *host;
386                struct node_os          *os;
387                struct node_port        *port;
388                struct node_uid         *uid;
389                struct node_gid         *gid;
390                struct node_state_opt   *state_opt;
391                struct peer              peer;
392                struct {
393                        struct peer      src, dst;
394                        struct node_os  *src_os;
395                }                        fromto;
396                struct {
397                        struct node_host        *host;
398                        u_int8_t                 rt;
399                        u_int8_t                 pool_opts;
400                        sa_family_t              af;
401                        struct pf_poolhashkey   *key;
402                }                        route;
403                struct redirection {
404                        struct node_host        *host;
405                        struct range             rport;
406                }                       *redirection;
407                struct {
408                        int                      action;
409                        struct node_state_opt   *options;
410                }                        keep_state;
411                struct {
412                        u_int8_t         log;
413                        u_int8_t         logif;
414                        u_int8_t         quick;
415                }                        logquick;
416                struct {
417                        int              neg;
418                        char            *name;
419                }                        tagged;
420                struct pf_poolhashkey   *hashkey;
421                struct node_queue       *queue;
422                struct node_queue_opt    queue_options;
423                struct node_queue_bw     queue_bwspec;
424                struct node_qassign      qassign;
425                struct filter_opts       filter_opts;
426                struct antispoof_opts    antispoof_opts;
427                struct queue_opts        queue_opts;
428                struct scrub_opts        scrub_opts;
429                struct table_opts        table_opts;
430                struct pool_opts         pool_opts;
431                struct node_hfsc_opts    hfsc_opts;
432        } v;
433        int lineno;
434} YYSTYPE;
435
436#define PPORT_RANGE     1
437#define PPORT_STAR      2
438int     parseport(char *, struct range *r, int);
439
440#define DYNIF_MULTIADDR(addr) ((addr).type == PF_ADDR_DYNIFTL && \
441        (!((addr).iflags & PFI_AFLAG_NOALIAS) ||                 \
442        !isdigit((addr).v.ifname[strlen((addr).v.ifname)-1])))
443
444%}
445
446%token  PASS BLOCK SCRUB RETURN IN OS OUT LOG QUICK ON FROM TO FLAGS
447%token  RETURNRST RETURNICMP RETURNICMP6 PROTO INET INET6 ALL ANY ICMPTYPE
448%token  ICMP6TYPE CODE KEEP MODULATE STATE PORT RDR NAT BINAT ARROW NODF
449%token  MINTTL ERROR ALLOWOPTS FASTROUTE FILENAME ROUTETO DUPTO REPLYTO NO LABEL
450%token  NOROUTE URPFFAILED FRAGMENT USER GROUP MAXMSS MAXIMUM TTL TOS DROP TABLE
451%token  REASSEMBLE FRAGDROP FRAGCROP ANCHOR NATANCHOR RDRANCHOR BINATANCHOR
452%token  SET OPTIMIZATION TIMEOUT LIMIT LOGINTERFACE BLOCKPOLICY RANDOMID
453%token  REQUIREORDER SYNPROXY FINGERPRINTS NOSYNC DEBUG SKIP HOSTID
454%token  ANTISPOOF FOR INCLUDE
455%token  BITMASK RANDOM SOURCEHASH ROUNDROBIN STATICPORT PROBABILITY
456%token  ALTQ CBQ PRIQ HFSC BANDWIDTH TBRSIZE LINKSHARE REALTIME UPPERLIMIT
457%token  QUEUE PRIORITY QLIMIT RTABLE
458%token  LOAD RULESET_OPTIMIZATION
459%token  STICKYADDRESS MAXSRCSTATES MAXSRCNODES SOURCETRACK GLOBAL RULE
460%token  MAXSRCCONN MAXSRCCONNRATE OVERLOAD FLUSH SLOPPY PFLOW
461%token  TAGGED TAG IFBOUND FLOATING STATEPOLICY STATEDEFAULTS ROUTE SETTOS
462%token  DIVERTTO DIVERTREPLY
463%token  <v.string>              STRING
464%token  <v.number>              NUMBER
465%token  <v.i>                   PORTBINARY
466%type   <v.interface>           interface if_list if_item_not if_item
467%type   <v.number>              number icmptype icmp6type uid gid
468%type   <v.number>              tos not yesno
469%type   <v.probability>         probability
470%type   <v.i>                   no dir af fragcache optimizer
471%type   <v.i>                   sourcetrack flush unaryop statelock
472%type   <v.b>                   action nataction natpasslog scrubaction
473%type   <v.b>                   flags flag blockspec
474%type   <v.range>               portplain portstar portrange
475%type   <v.hashkey>             hashkey
476%type   <v.proto>               proto proto_list proto_item
477%type   <v.number>              protoval
478%type   <v.icmp>                icmpspec
479%type   <v.icmp>                icmp_list icmp_item
480%type   <v.icmp>                icmp6_list icmp6_item
481%type   <v.number>              reticmpspec reticmp6spec
482%type   <v.fromto>              fromto
483%type   <v.peer>                ipportspec from to
484%type   <v.host>                ipspec toipspec xhost host dynaddr host_list
485%type   <v.host>                redir_host_list redirspec
486%type   <v.host>                route_host route_host_list routespec
487%type   <v.os>                  os xos os_list
488%type   <v.port>                portspec port_list port_item
489%type   <v.uid>                 uids uid_list uid_item
490%type   <v.gid>                 gids gid_list gid_item
491%type   <v.route>               route
492%type   <v.redirection>         redirection redirpool
493%type   <v.string>              label stringall tag anchorname
494%type   <v.string>              string varstring numberstring
495%type   <v.keep_state>          keep
496%type   <v.state_opt>           state_opt_spec state_opt_list state_opt_item
497%type   <v.logquick>            logquick quick log logopts logopt
498%type   <v.interface>           antispoof_ifspc antispoof_iflst antispoof_if
499%type   <v.qassign>             qname
500%type   <v.queue>               qassign qassign_list qassign_item
501%type   <v.queue_options>       scheduler
502%type   <v.number>              cbqflags_list cbqflags_item
503%type   <v.number>              priqflags_list priqflags_item
504%type   <v.hfsc_opts>           hfscopts_list hfscopts_item hfsc_opts
505%type   <v.queue_bwspec>        bandwidth
506%type   <v.filter_opts>         filter_opts filter_opt filter_opts_l
507%type   <v.antispoof_opts>      antispoof_opts antispoof_opt antispoof_opts_l
508%type   <v.queue_opts>          queue_opts queue_opt queue_opts_l
509%type   <v.scrub_opts>          scrub_opts scrub_opt scrub_opts_l
510%type   <v.table_opts>          table_opts table_opt table_opts_l
511%type   <v.pool_opts>           pool_opts pool_opt pool_opts_l
512%type   <v.tagged>              tagged
513%type   <v.rtableid>            rtable
514%%
515
516ruleset         : /* empty */
517                | ruleset include '\n'
518                | ruleset '\n'
519                | ruleset option '\n'
520                | ruleset scrubrule '\n'
521                | ruleset natrule '\n'
522                | ruleset binatrule '\n'
523                | ruleset pfrule '\n'
524                | ruleset anchorrule '\n'
525                | ruleset loadrule '\n'
526                | ruleset altqif '\n'
527                | ruleset queuespec '\n'
528                | ruleset varset '\n'
529                | ruleset antispoof '\n'
530                | ruleset tabledef '\n'
531                | '{' fakeanchor '}' '\n';
532                | ruleset error '\n'            { file->errors++; }
533                ;
534
535include         : INCLUDE STRING                {
536                        struct file     *nfile;
537
538                        if ((nfile = pushfile($2, 0)) == NULL) {
539                                yyerror("failed to include file %s", $2);
540                                free($2);
541                                YYERROR;
542                        }
543                        free($2);
544
545                        file = nfile;
546                        lungetc('\n');
547                }
548                ;
549
550/*
551 * apply to previouslys specified rule: must be careful to note
552 * what that is: pf or nat or binat or rdr
553 */
554fakeanchor      : fakeanchor '\n'
555                | fakeanchor anchorrule '\n'
556                | fakeanchor binatrule '\n'
557                | fakeanchor natrule '\n'
558                | fakeanchor pfrule '\n'
559                | fakeanchor error '\n'
560                ;
561
562optimizer       : string        {
563                        if (!strcmp($1, "none"))
564                                $$ = 0;
565                        else if (!strcmp($1, "basic"))
566                                $$ = PF_OPTIMIZE_BASIC;
567                        else if (!strcmp($1, "profile"))
568                                $$ = PF_OPTIMIZE_BASIC | PF_OPTIMIZE_PROFILE;
569                        else {
570                                yyerror("unknown ruleset-optimization %s", $1);
571                                YYERROR;
572                        }
573                }
574                ;
575
576option          : SET OPTIMIZATION STRING               {
577                        if (check_rulestate(PFCTL_STATE_OPTION)) {
578                                free($3);
579                                YYERROR;
580                        }
581                        if (pfctl_set_optimization(pf, $3) != 0) {
582                                yyerror("unknown optimization %s", $3);
583                                free($3);
584                                YYERROR;
585                        }
586                        free($3);
587                }
588                | SET RULESET_OPTIMIZATION optimizer {
589                        if (!(pf->opts & PF_OPT_OPTIMIZE)) {
590                                pf->opts |= PF_OPT_OPTIMIZE;
591                                pf->optimize = $3;
592                        }
593                }
594                | SET TIMEOUT timeout_spec
595                | SET TIMEOUT '{' optnl timeout_list '}'
596                | SET LIMIT limit_spec
597                | SET LIMIT '{' optnl limit_list '}'
598                | SET LOGINTERFACE stringall            {
599                        if (check_rulestate(PFCTL_STATE_OPTION)) {
600                                free($3);
601                                YYERROR;
602                        }
603                        if (pfctl_set_logif(pf, $3) != 0) {
604                                yyerror("error setting loginterface %s", $3);
605                                free($3);
606                                YYERROR;
607                        }
608                        free($3);
609                }
610                | SET HOSTID number {
611                        if ($3 == 0 || $3 > UINT_MAX) {
612                                yyerror("hostid must be non-zero");
613                                YYERROR;
614                        }
615                        if (pfctl_set_hostid(pf, $3) != 0) {
616                                yyerror("error setting hostid %08x", $3);
617                                YYERROR;
618                        }
619                }
620                | SET BLOCKPOLICY DROP  {
621                        if (pf->opts & PF_OPT_VERBOSE)
622                                printf("set block-policy drop\n");
623                        if (check_rulestate(PFCTL_STATE_OPTION))
624                                YYERROR;
625                        blockpolicy = PFRULE_DROP;
626                }
627                | SET BLOCKPOLICY RETURN {
628                        if (pf->opts & PF_OPT_VERBOSE)
629                                printf("set block-policy return\n");
630                        if (check_rulestate(PFCTL_STATE_OPTION))
631                                YYERROR;
632                        blockpolicy = PFRULE_RETURN;
633                }
634                | SET REQUIREORDER yesno {
635                        if (pf->opts & PF_OPT_VERBOSE)
636                                printf("set require-order %s\n",
637                                    $3 == 1 ? "yes" : "no");
638                        require_order = $3;
639                }
640                | SET FINGERPRINTS STRING {
641                        if (pf->opts & PF_OPT_VERBOSE)
642                                printf("set fingerprints \"%s\"\n", $3);
643                        if (check_rulestate(PFCTL_STATE_OPTION)) {
644                                free($3);
645                                YYERROR;
646                        }
647                        if (!pf->anchor->name[0]) {
648                                if (pfctl_file_fingerprints(pf->dev,
649                                    pf->opts, $3)) {
650                                        yyerror("error loading "
651                                            "fingerprints %s", $3);
652                                        free($3);
653                                        YYERROR;
654                                }
655                        }
656                        free($3);
657                }
658                | SET STATEPOLICY statelock {
659                        if (pf->opts & PF_OPT_VERBOSE)
660                                switch ($3) {
661                                case 0:
662                                        printf("set state-policy floating\n");
663                                        break;
664                                case PFRULE_IFBOUND:
665                                        printf("set state-policy if-bound\n");
666                                        break;
667                                }
668                        default_statelock = $3;
669                }
670                | SET DEBUG STRING {
671                        if (check_rulestate(PFCTL_STATE_OPTION)) {
672                                free($3);
673                                YYERROR;
674                        }
675                        if (pfctl_set_debug(pf, $3) != 0) {
676                                yyerror("error setting debuglevel %s", $3);
677                                free($3);
678                                YYERROR;
679                        }
680                        free($3);
681                }
682                | SET SKIP interface {
683                        if (expand_skip_interface($3) != 0) {
684                                yyerror("error setting skip interface(s)");
685                                YYERROR;
686                        }
687                }
688                | SET STATEDEFAULTS state_opt_list {
689                        if (keep_state_defaults != NULL) {
690                                yyerror("cannot redefine state-defaults");
691                                YYERROR;
692                        }
693                        keep_state_defaults = $3;
694                }
695                ;
696
697stringall       : STRING        { $$ = $1; }
698                | ALL           {
699                        if (($$ = strdup("all")) == NULL) {
700                                err(1, "stringall: strdup");
701                        }
702                }
703                ;
704
705string          : STRING string                         {
706                        if (asprintf(&$$, "%s %s", $1, $2) == -1)
707                                err(1, "string: asprintf");
708                        free($1);
709                        free($2);
710                }
711                | STRING
712                ;
713
714varstring       : numberstring varstring                {
715                        if (asprintf(&$$, "%s %s", $1, $2) == -1)
716                                err(1, "string: asprintf");
717                        free($1);
718                        free($2);
719                }
720                | numberstring
721                ;
722
723numberstring    : NUMBER                                {
724                        char    *s;
725                        if (asprintf(&s, "%lld", (long long)$1) == -1) {
726                                yyerror("string: asprintf");
727                                YYERROR;
728                        }
729                        $$ = s;
730                }
731                | STRING
732                ;
733
734varset          : STRING '=' varstring  {
735                        if (pf->opts & PF_OPT_VERBOSE)
736                                printf("%s = \"%s\"\n", $1, $3);
737                        if (symset($1, $3, 0) == -1)
738                                err(1, "cannot store variable %s", $1);
739                        free($1);
740                        free($3);
741                }
742                ;
743
744anchorname      : STRING                        { $$ = $1; }
745                | /* empty */                   { $$ = NULL; }
746                ;
747
748pfa_anchorlist  : /* empty */
749                | pfa_anchorlist '\n'
750                | pfa_anchorlist pfrule '\n'
751                | pfa_anchorlist anchorrule '\n'
752                ;
753
754pfa_anchor      : '{'
755                {
756                        char ta[PF_ANCHOR_NAME_SIZE];
757                        struct pf_ruleset *rs;
758
759                        /* steping into a brace anchor */
760                        pf->asd++;
761                        pf->bn++;
762                        pf->brace = 1;
763
764                        /* create a holding ruleset in the root */
765                        snprintf(ta, PF_ANCHOR_NAME_SIZE, "_%d", pf->bn);
766                        rs = pf_find_or_create_ruleset(ta);
767                        if (rs == NULL)
768                                err(1, "pfa_anchor: pf_find_or_create_ruleset");
769                        pf->astack[pf->asd] = rs->anchor;
770                        pf->anchor = rs->anchor;
771                } '\n' pfa_anchorlist '}'
772                {
773                        pf->alast = pf->anchor;
774                        pf->asd--;
775                        pf->anchor = pf->astack[pf->asd];
776                }
777                | /* empty */
778                ;
779
780anchorrule      : ANCHOR anchorname dir quick interface af proto fromto
781                    filter_opts pfa_anchor
782                {
783                        struct pf_rule  r;
784                        struct node_proto       *proto;
785
786                        if (check_rulestate(PFCTL_STATE_FILTER)) {
787                                if ($2)
788                                        free($2);
789                                YYERROR;
790                        }
791
792                        if ($2 && ($2[0] == '_' || strstr($2, "/_") != NULL)) {
793                                free($2);
794                                yyerror("anchor names beginning with '_' "
795                                    "are reserved for internal use");
796                                YYERROR;
797                        }
798
799                        memset(&r, 0, sizeof(r));
800                        if (pf->astack[pf->asd + 1]) {
801                                /* move inline rules into relative location */
802                                pf_anchor_setup(&r,
803                                    &pf->astack[pf->asd]->ruleset,
804                                    $2 ? $2 : pf->alast->name);
805               
806                                if (r.anchor == NULL)
807                                        err(1, "anchorrule: unable to "
808                                            "create ruleset");
809
810                                if (pf->alast != r.anchor) {
811                                        if (r.anchor->match) {
812                                                yyerror("inline anchor '%s' "
813                                                    "already exists",
814                                                    r.anchor->name);
815                                                YYERROR;
816                                        }
817                                        mv_rules(&pf->alast->ruleset,
818                                            &r.anchor->ruleset);
819                                }
820                                pf_remove_if_empty_ruleset(&pf->alast->ruleset);
821                                pf->alast = r.anchor;
822                        } else {
823                                if (!$2) {
824                                        yyerror("anchors without explicit "
825                                            "rules must specify a name");
826                                        YYERROR;
827                                }
828                        }
829                        r.direction = $3;
830                        r.quick = $4.quick;
831                        r.af = $6;
832                        r.prob = $9.prob;
833                        r.rtableid = $9.rtableid;
834
835                        if ($9.tag)
836                                if (strlcpy(r.tagname, $9.tag,
837                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
838                                        yyerror("tag too long, max %u chars",
839                                            PF_TAG_NAME_SIZE - 1);
840                                        YYERROR;
841                                }
842                        if ($9.match_tag)
843                                if (strlcpy(r.match_tagname, $9.match_tag,
844                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
845                                        yyerror("tag too long, max %u chars",
846                                            PF_TAG_NAME_SIZE - 1);
847                                        YYERROR;
848                                }
849                        r.match_tag_not = $9.match_tag_not;
850                        if (rule_label(&r, $9.label))
851                                YYERROR;
852                        free($9.label);
853                        r.flags = $9.flags.b1;
854                        r.flagset = $9.flags.b2;
855                        if (($9.flags.b1 & $9.flags.b2) != $9.flags.b1) {
856                                yyerror("flags always false");
857                                YYERROR;
858                        }
859                        if ($9.flags.b1 || $9.flags.b2 || $8.src_os) {
860                                for (proto = $7; proto != NULL &&
861                                    proto->proto != IPPROTO_TCP;
862                                    proto = proto->next)
863                                        ;       /* nothing */
864                                if (proto == NULL && $7 != NULL) {
865                                        if ($9.flags.b1 || $9.flags.b2)
866                                                yyerror(
867                                                    "flags only apply to tcp");
868                                        if ($8.src_os)
869                                                yyerror(
870                                                    "OS fingerprinting only "
871                                                    "applies to tcp");
872                                        YYERROR;
873                                }
874                        }
875
876                        r.tos = $9.tos;
877
878                        if ($9.keep.action) {
879                                yyerror("cannot specify state handling "
880                                    "on anchors");
881                                YYERROR;
882                        }
883
884                        if ($9.match_tag)
885                                if (strlcpy(r.match_tagname, $9.match_tag,
886                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
887                                        yyerror("tag too long, max %u chars",
888                                            PF_TAG_NAME_SIZE - 1);
889                                        YYERROR;
890                                }
891                        r.match_tag_not = $9.match_tag_not;
892
893                        decide_address_family($8.src.host, &r.af);
894                        decide_address_family($8.dst.host, &r.af);
895
896                        expand_rule(&r, $5, NULL, $7, $8.src_os,
897                            $8.src.host, $8.src.port, $8.dst.host, $8.dst.port,
898                            $9.uid, $9.gid, $9.icmpspec,
899                            pf->astack[pf->asd + 1] ? pf->alast->name : $2);
900                        free($2);
901                        pf->astack[pf->asd + 1] = NULL;
902                }
903                | NATANCHOR string interface af proto fromto rtable {
904                        struct pf_rule  r;
905
906                        if (check_rulestate(PFCTL_STATE_NAT)) {
907                                free($2);
908                                YYERROR;
909                        }
910
911                        memset(&r, 0, sizeof(r));
912                        r.action = PF_NAT;
913                        r.af = $4;
914                        r.rtableid = $7;
915
916                        decide_address_family($6.src.host, &r.af);
917                        decide_address_family($6.dst.host, &r.af);
918
919                        expand_rule(&r, $3, NULL, $5, $6.src_os,
920                            $6.src.host, $6.src.port, $6.dst.host, $6.dst.port,
921                            0, 0, 0, $2);
922                        free($2);
923                }
924                | RDRANCHOR string interface af proto fromto rtable {
925                        struct pf_rule  r;
926
927                        if (check_rulestate(PFCTL_STATE_NAT)) {
928                                free($2);
929                                YYERROR;
930                        }
931
932                        memset(&r, 0, sizeof(r));
933                        r.action = PF_RDR;
934                        r.af = $4;
935                        r.rtableid = $7;
936
937                        decide_address_family($6.src.host, &r.af);
938                        decide_address_family($6.dst.host, &r.af);
939
940                        if ($6.src.port != NULL) {
941                                yyerror("source port parameter not supported"
942                                    " in rdr-anchor");
943                                YYERROR;
944                        }
945                        if ($6.dst.port != NULL) {
946                                if ($6.dst.port->next != NULL) {
947                                        yyerror("destination port list "
948                                            "expansion not supported in "
949                                            "rdr-anchor");
950                                        YYERROR;
951                                } else if ($6.dst.port->op != PF_OP_EQ) {
952                                        yyerror("destination port operators"
953                                            " not supported in rdr-anchor");
954                                        YYERROR;
955                                }
956                                r.dst.port[0] = $6.dst.port->port[0];
957                                r.dst.port[1] = $6.dst.port->port[1];
958                                r.dst.port_op = $6.dst.port->op;
959                        }
960
961                        expand_rule(&r, $3, NULL, $5, $6.src_os,
962                            $6.src.host, $6.src.port, $6.dst.host, $6.dst.port,
963                            0, 0, 0, $2);
964                        free($2);
965                }
966                | BINATANCHOR string interface af proto fromto rtable {
967                        struct pf_rule  r;
968
969                        if (check_rulestate(PFCTL_STATE_NAT)) {
970                                free($2);
971                                YYERROR;
972                        }
973
974                        memset(&r, 0, sizeof(r));
975                        r.action = PF_BINAT;
976                        r.af = $4;
977                        r.rtableid = $7;
978                        if ($5 != NULL) {
979                                if ($5->next != NULL) {
980                                        yyerror("proto list expansion"
981                                            " not supported in binat-anchor");
982                                        YYERROR;
983                                }
984                                r.proto = $5->proto;
985                                free($5);
986                        }
987
988                        if ($6.src.host != NULL || $6.src.port != NULL ||
989                            $6.dst.host != NULL || $6.dst.port != NULL) {
990                                yyerror("fromto parameter not supported"
991                                    " in binat-anchor");
992                                YYERROR;
993                        }
994
995                        decide_address_family($6.src.host, &r.af);
996                        decide_address_family($6.dst.host, &r.af);
997
998                        pfctl_add_rule(pf, &r, $2);
999                        free($2);
1000                }
1001                ;
1002
1003loadrule        : LOAD ANCHOR string FROM string        {
1004                        struct loadanchors      *loadanchor;
1005
1006                        if (strlen(pf->anchor->name) + 1 +
1007                            strlen($3) >= MAXPATHLEN) {
1008                                yyerror("anchorname %s too long, max %u\n",
1009                                    $3, MAXPATHLEN - 1);
1010                                free($3);
1011                                YYERROR;
1012                        }
1013                        loadanchor = calloc(1, sizeof(struct loadanchors));
1014                        if (loadanchor == NULL)
1015                                err(1, "loadrule: calloc");
1016                        if ((loadanchor->anchorname = malloc(MAXPATHLEN)) ==
1017                            NULL)
1018                                err(1, "loadrule: malloc");
1019                        if (pf->anchor->name[0])
1020                                snprintf(loadanchor->anchorname, MAXPATHLEN,
1021                                    "%s/%s", pf->anchor->name, $3);
1022                        else
1023                                strlcpy(loadanchor->anchorname, $3, MAXPATHLEN);
1024                        if ((loadanchor->filename = strdup($5)) == NULL)
1025                                err(1, "loadrule: strdup");
1026
1027                        TAILQ_INSERT_TAIL(&loadanchorshead, loadanchor,
1028                            entries);
1029
1030                        free($3);
1031                        free($5);
1032                };
1033
1034scrubaction     : no SCRUB {
1035                        $$.b2 = $$.w = 0;
1036                        if ($1)
1037                                $$.b1 = PF_NOSCRUB;
1038                        else
1039                                $$.b1 = PF_SCRUB;
1040                }
1041                ;
1042
1043scrubrule       : scrubaction dir logquick interface af proto fromto scrub_opts
1044                {
1045                        struct pf_rule  r;
1046
1047                        if (check_rulestate(PFCTL_STATE_SCRUB))
1048                                YYERROR;
1049
1050                        memset(&r, 0, sizeof(r));
1051
1052                        r.action = $1.b1;
1053                        r.direction = $2;
1054
1055                        r.log = $3.log;
1056                        r.logif = $3.logif;
1057                        if ($3.quick) {
1058                                yyerror("scrub rules do not support 'quick'");
1059                                YYERROR;
1060                        }
1061
1062                        r.af = $5;
1063                        if ($8.nodf)
1064                                r.rule_flag |= PFRULE_NODF;
1065                        if ($8.randomid)
1066                                r.rule_flag |= PFRULE_RANDOMID;
1067                        if ($8.reassemble_tcp) {
1068                                if (r.direction != PF_INOUT) {
1069                                        yyerror("reassemble tcp rules can not "
1070                                            "specify direction");
1071                                        YYERROR;
1072                                }
1073                                r.rule_flag |= PFRULE_REASSEMBLE_TCP;
1074                        }
1075                        if ($8.minttl)
1076                                r.min_ttl = $8.minttl;
1077                        if ($8.maxmss)
1078                                r.max_mss = $8.maxmss;
1079                        if ($8.marker & SOM_SETTOS) {
1080                                r.rule_flag |= PFRULE_SET_TOS;
1081                                r.set_tos = $8.settos;
1082                        }
1083                        if ($8.fragcache)
1084                                r.rule_flag |= $8.fragcache;
1085                        if ($8.match_tag)
1086                                if (strlcpy(r.match_tagname, $8.match_tag,
1087                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
1088                                        yyerror("tag too long, max %u chars",
1089                                            PF_TAG_NAME_SIZE - 1);
1090                                        YYERROR;
1091                                }
1092                        r.match_tag_not = $8.match_tag_not;
1093                        r.rtableid = $8.rtableid;
1094
1095                        expand_rule(&r, $4, NULL, $6, $7.src_os,
1096                            $7.src.host, $7.src.port, $7.dst.host, $7.dst.port,
1097                            NULL, NULL, NULL, "");
1098                }
1099                ;
1100
1101scrub_opts      :       {
1102                                bzero(&scrub_opts, sizeof scrub_opts);
1103                                scrub_opts.rtableid = -1;
1104                        }
1105                    scrub_opts_l
1106                        { $$ = scrub_opts; }
1107                | /* empty */ {
1108                        bzero(&scrub_opts, sizeof scrub_opts);
1109                        scrub_opts.rtableid = -1;
1110                        $$ = scrub_opts;
1111                }
1112                ;
1113
1114scrub_opts_l    : scrub_opts_l scrub_opt
1115                | scrub_opt
1116                ;
1117
1118scrub_opt       : NODF  {
1119                        if (scrub_opts.nodf) {
1120                                yyerror("no-df cannot be respecified");
1121                                YYERROR;
1122                        }
1123                        scrub_opts.nodf = 1;
1124                }
1125                | MINTTL NUMBER {
1126                        if (scrub_opts.marker & SOM_MINTTL) {
1127                                yyerror("min-ttl cannot be respecified");
1128                                YYERROR;
1129                        }
1130                        if ($2 < 0 || $2 > 255) {
1131                                yyerror("illegal min-ttl value %d", $2);
1132                                YYERROR;
1133                        }
1134                        scrub_opts.marker |= SOM_MINTTL;
1135                        scrub_opts.minttl = $2;
1136                }
1137                | MAXMSS NUMBER {
1138                        if (scrub_opts.marker & SOM_MAXMSS) {
1139                                yyerror("max-mss cannot be respecified");
1140                                YYERROR;
1141                        }
1142                        if ($2 < 0 || $2 > 65535) {
1143                                yyerror("illegal max-mss value %d", $2);
1144                                YYERROR;
1145                        }
1146                        scrub_opts.marker |= SOM_MAXMSS;
1147                        scrub_opts.maxmss = $2;
1148                }
1149                | SETTOS tos {
1150                        if (scrub_opts.marker & SOM_SETTOS) {
1151                                yyerror("set-tos cannot be respecified");
1152                                YYERROR;
1153                        }
1154                        scrub_opts.marker |= SOM_SETTOS;
1155                        scrub_opts.settos = $2;
1156                }
1157                | fragcache {
1158                        if (scrub_opts.marker & SOM_FRAGCACHE) {
1159                                yyerror("fragcache cannot be respecified");
1160                                YYERROR;
1161                        }
1162                        scrub_opts.marker |= SOM_FRAGCACHE;
1163                        scrub_opts.fragcache = $1;
1164                }
1165                | REASSEMBLE STRING {
1166                        if (strcasecmp($2, "tcp") != 0) {
1167                                yyerror("scrub reassemble supports only tcp, "
1168                                    "not '%s'", $2);
1169                                free($2);
1170                                YYERROR;
1171                        }
1172                        free($2);
1173                        if (scrub_opts.reassemble_tcp) {
1174                                yyerror("reassemble tcp cannot be respecified");
1175                                YYERROR;
1176                        }
1177                        scrub_opts.reassemble_tcp = 1;
1178                }
1179                | RANDOMID {
1180                        if (scrub_opts.randomid) {
1181                                yyerror("random-id cannot be respecified");
1182                                YYERROR;
1183                        }
1184                        scrub_opts.randomid = 1;
1185                }
1186                | RTABLE NUMBER                         {
1187                        if ($2 < 0 || $2 > rt_tableid_max()) {
1188                                yyerror("invalid rtable id");
1189                                YYERROR;
1190                        }
1191                        scrub_opts.rtableid = $2;
1192                }
1193                | not TAGGED string                     {
1194                        scrub_opts.match_tag = $3;
1195                        scrub_opts.match_tag_not = $1;
1196                }
1197                ;
1198
1199fragcache       : FRAGMENT REASSEMBLE   { $$ = 0; /* default */ }
1200                | FRAGMENT FRAGCROP     { $$ = PFRULE_FRAGCROP; }
1201                | FRAGMENT FRAGDROP     { $$ = PFRULE_FRAGDROP; }
1202                ;
1203
1204antispoof       : ANTISPOOF logquick antispoof_ifspc af antispoof_opts {
1205                        struct pf_rule           r;
1206                        struct node_host        *h = NULL, *hh;
1207                        struct node_if          *i, *j;
1208
1209                        if (check_rulestate(PFCTL_STATE_FILTER))
1210                                YYERROR;
1211
1212                        for (i = $3; i; i = i->next) {
1213                                bzero(&r, sizeof(r));
1214
1215                                r.action = PF_DROP;
1216                                r.direction = PF_IN;
1217                                r.log = $2.log;
1218                                r.logif = $2.logif;
1219                                r.quick = $2.quick;
1220                                r.af = $4;
1221                                if (rule_label(&r, $5.label))
1222                                        YYERROR;
1223                                r.rtableid = $5.rtableid;
1224                                j = calloc(1, sizeof(struct node_if));
1225                                if (j == NULL)
1226                                        err(1, "antispoof: calloc");
1227                                if (strlcpy(j->ifname, i->ifname,
1228                                    sizeof(j->ifname)) >= sizeof(j->ifname)) {
1229                                        free(j);
1230                                        yyerror("interface name too long");
1231                                        YYERROR;
1232                                }
1233                                j->not = 1;
1234                                if (i->dynamic) {
1235                                        h = calloc(1, sizeof(*h));
1236                                        if (h == NULL)
1237                                                err(1, "address: calloc");
1238                                        h->addr.type = PF_ADDR_DYNIFTL;
1239                                        set_ipmask(h, 128);
1240                                        if (strlcpy(h->addr.v.ifname, i->ifname,
1241                                            sizeof(h->addr.v.ifname)) >=
1242                                            sizeof(h->addr.v.ifname)) {
1243                                                free(h);
1244                                                yyerror(
1245                                                    "interface name too long");
1246                                                YYERROR;
1247                                        }
1248                                        hh = malloc(sizeof(*hh));
1249                                        if (hh == NULL)
1250                                                 err(1, "address: malloc");
1251                                        bcopy(h, hh, sizeof(*hh));
1252                                        h->addr.iflags = PFI_AFLAG_NETWORK;
1253                                } else {
1254                                        h = ifa_lookup(j->ifname,
1255                                            PFI_AFLAG_NETWORK);
1256                                        hh = NULL;
1257                                }
1258
1259                                if (h != NULL)
1260                                        expand_rule(&r, j, NULL, NULL, NULL, h,
1261                                            NULL, NULL, NULL, NULL, NULL,
1262                                            NULL, "");
1263
1264                                if ((i->ifa_flags & IFF_LOOPBACK) == 0) {
1265                                        bzero(&r, sizeof(r));
1266
1267                                        r.action = PF_DROP;
1268                                        r.direction = PF_IN;
1269                                        r.log = $2.log;
1270                                        r.logif = $2.logif;
1271                                        r.quick = $2.quick;
1272                                        r.af = $4;
1273                                        if (rule_label(&r, $5.label))
1274                                                YYERROR;
1275                                        r.rtableid = $5.rtableid;
1276                                        if (hh != NULL)
1277                                                h = hh;
1278                                        else
1279                                                h = ifa_lookup(i->ifname, 0);
1280                                        if (h != NULL)
1281                                                expand_rule(&r, NULL, NULL,
1282                                                    NULL, NULL, h, NULL, NULL,
1283                                                    NULL, NULL, NULL, NULL, "");
1284                                } else
1285                                        free(hh);
1286                        }
1287                        free($5.label);
1288                }
1289                ;
1290
1291antispoof_ifspc : FOR antispoof_if                      { $$ = $2; }
1292                | FOR '{' optnl antispoof_iflst '}'     { $$ = $4; }
1293                ;
1294
1295antispoof_iflst : antispoof_if optnl                    { $$ = $1; }
1296                | antispoof_iflst comma antispoof_if optnl {
1297                        $1->tail->next = $3;
1298                        $1->tail = $3;
1299                        $$ = $1;
1300                }
1301                ;
1302
1303antispoof_if    : if_item                               { $$ = $1; }
1304                | '(' if_item ')'                       {
1305                        $2->dynamic = 1;
1306                        $$ = $2;
1307                }
1308                ;
1309
1310antispoof_opts  :       {
1311                                bzero(&antispoof_opts, sizeof antispoof_opts);
1312                                antispoof_opts.rtableid = -1;
1313                        }
1314                    antispoof_opts_l
1315                        { $$ = antispoof_opts; }
1316                | /* empty */   {
1317                        bzero(&antispoof_opts, sizeof antispoof_opts);
1318                        antispoof_opts.rtableid = -1;
1319                        $$ = antispoof_opts;
1320                }
1321                ;
1322
1323antispoof_opts_l        : antispoof_opts_l antispoof_opt
1324                        | antispoof_opt
1325                        ;
1326
1327antispoof_opt   : label {
1328                        if (antispoof_opts.label) {
1329                                yyerror("label cannot be redefined");
1330                                YYERROR;
1331                        }
1332                        antispoof_opts.label = $1;
1333                }
1334                | RTABLE NUMBER                         {
1335                        if ($2 < 0 || $2 > rt_tableid_max()) {
1336                                yyerror("invalid rtable id");
1337                                YYERROR;
1338                        }
1339                        antispoof_opts.rtableid = $2;
1340                }
1341                ;
1342
1343not             : '!'           { $$ = 1; }
1344                | /* empty */   { $$ = 0; }
1345                ;
1346
1347tabledef        : TABLE '<' STRING '>' table_opts {
1348                        struct node_host         *h, *nh;
1349                        struct node_tinit        *ti, *nti;
1350
1351                        if (strlen($3) >= PF_TABLE_NAME_SIZE) {
1352                                yyerror("table name too long, max %d chars",
1353                                    PF_TABLE_NAME_SIZE - 1);
1354                                free($3);
1355                                YYERROR;
1356                        }
1357                        if (pf->loadopt & PFCTL_FLAG_TABLE)
1358                                if (process_tabledef($3, &$5)) {
1359                                        free($3);
1360                                        YYERROR;
1361                                }
1362                        free($3);
1363                        for (ti = SIMPLEQ_FIRST(&$5.init_nodes);
1364                            ti != SIMPLEQ_END(&$5.init_nodes); ti = nti) {
1365                                if (ti->file)
1366                                        free(ti->file);
1367                                for (h = ti->host; h != NULL; h = nh) {
1368                                        nh = h->next;
1369                                        free(h);
1370                                }
1371                                nti = SIMPLEQ_NEXT(ti, entries);
1372                                free(ti);
1373                        }
1374                }
1375                ;
1376
1377table_opts      :       {
1378                        bzero(&table_opts, sizeof table_opts);
1379                        SIMPLEQ_INIT(&table_opts.init_nodes);
1380                }
1381                    table_opts_l
1382                        { $$ = table_opts; }
1383                | /* empty */
1384                        {
1385                        bzero(&table_opts, sizeof table_opts);
1386                        SIMPLEQ_INIT(&table_opts.init_nodes);
1387                        $$ = table_opts;
1388                }
1389                ;
1390
1391table_opts_l    : table_opts_l table_opt
1392                | table_opt
1393                ;
1394
1395table_opt       : STRING                {
1396                        if (!strcmp($1, "const"))
1397                                table_opts.flags |= PFR_TFLAG_CONST;
1398                        else if (!strcmp($1, "persist"))
1399                                table_opts.flags |= PFR_TFLAG_PERSIST;
1400                        else if (!strcmp($1, "counters"))
1401                                table_opts.flags |= PFR_TFLAG_COUNTERS;
1402                        else {
1403                                yyerror("invalid table option '%s'", $1);
1404                                free($1);
1405                                YYERROR;
1406                        }
1407                        free($1);
1408                }
1409                | '{' optnl '}'         { table_opts.init_addr = 1; }
1410                | '{' optnl host_list '}'       {
1411                        struct node_host        *n;
1412                        struct node_tinit       *ti;
1413
1414                        for (n = $3; n != NULL; n = n->next) {
1415                                switch (n->addr.type) {
1416                                case PF_ADDR_ADDRMASK:
1417                                        continue; /* ok */
1418                                case PF_ADDR_RANGE:
1419                                        yyerror("address ranges are not "
1420                                            "permitted inside tables");
1421                                        break;
1422                                case PF_ADDR_DYNIFTL:
1423                                        yyerror("dynamic addresses are not "
1424                                            "permitted inside tables");
1425                                        break;
1426                                case PF_ADDR_TABLE:
1427                                        yyerror("tables cannot contain tables");
1428                                        break;
1429                                case PF_ADDR_NOROUTE:
1430                                        yyerror("\"no-route\" is not permitted "
1431                                            "inside tables");
1432                                        break;
1433                                case PF_ADDR_URPFFAILED:
1434                                        yyerror("\"urpf-failed\" is not "
1435                                            "permitted inside tables");
1436                                        break;
1437                                default:
1438                                        yyerror("unknown address type %d",
1439                                            n->addr.type);
1440                                }
1441                                YYERROR;
1442                        }
1443                        if (!(ti = calloc(1, sizeof(*ti))))
1444                                err(1, "table_opt: calloc");
1445                        ti->host = $3;
1446                        SIMPLEQ_INSERT_TAIL(&table_opts.init_nodes, ti,
1447                            entries);
1448                        table_opts.init_addr = 1;
1449                }
1450                | FILENAME STRING       {
1451                        struct node_tinit       *ti;
1452
1453                        if (!(ti = calloc(1, sizeof(*ti))))
1454                                err(1, "table_opt: calloc");
1455                        ti->file = $2;
1456                        SIMPLEQ_INSERT_TAIL(&table_opts.init_nodes, ti,
1457                            entries);
1458                        table_opts.init_addr = 1;
1459                }
1460                ;
1461
1462altqif          : ALTQ interface queue_opts QUEUE qassign {
1463                        struct pf_altq  a;
1464
1465                        if (check_rulestate(PFCTL_STATE_QUEUE))
1466                                YYERROR;
1467
1468                        memset(&a, 0, sizeof(a));
1469                        if ($3.scheduler.qtype == ALTQT_NONE) {
1470                                yyerror("no scheduler specified!");
1471                                YYERROR;
1472                        }
1473                        a.scheduler = $3.scheduler.qtype;
1474                        a.qlimit = $3.qlimit;
1475                        a.tbrsize = $3.tbrsize;
1476                        if ($5 == NULL) {
1477                                yyerror("no child queues specified");
1478                                YYERROR;
1479                        }
1480                        if (expand_altq(&a, $2, $5, $3.queue_bwspec,
1481                            &$3.scheduler))
1482                                YYERROR;
1483                }
1484                ;
1485
1486queuespec       : QUEUE STRING interface queue_opts qassign {
1487                        struct pf_altq  a;
1488
1489                        if (check_rulestate(PFCTL_STATE_QUEUE)) {
1490                                free($2);
1491                                YYERROR;
1492                        }
1493
1494                        memset(&a, 0, sizeof(a));
1495
1496                        if (strlcpy(a.qname, $2, sizeof(a.qname)) >=
1497                            sizeof(a.qname)) {
1498                                yyerror("queue name too long (max "
1499                                    "%d chars)", PF_QNAME_SIZE-1);
1500                                free($2);
1501                                YYERROR;
1502                        }
1503                        free($2);
1504                        if ($4.tbrsize) {
1505                                yyerror("cannot specify tbrsize for queue");
1506                                YYERROR;
1507                        }
1508                        if ($4.priority > 255) {
1509                                yyerror("priority out of range: max 255");
1510                                YYERROR;
1511                        }
1512                        a.priority = $4.priority;
1513                        a.qlimit = $4.qlimit;
1514                        a.scheduler = $4.scheduler.qtype;
1515                        if (expand_queue(&a, $3, $5, $4.queue_bwspec,
1516                            &$4.scheduler)) {
1517                                yyerror("errors in queue definition");
1518                                YYERROR;
1519                        }
1520                }
1521                ;
1522
1523queue_opts      :       {
1524                        bzero(&queue_opts, sizeof queue_opts);
1525                        queue_opts.priority = DEFAULT_PRIORITY;
1526                        queue_opts.qlimit = DEFAULT_QLIMIT;
1527                        queue_opts.scheduler.qtype = ALTQT_NONE;
1528                        queue_opts.queue_bwspec.bw_percent = 100;
1529                }
1530                    queue_opts_l
1531                        { $$ = queue_opts; }
1532                | /* empty */ {
1533                        bzero(&queue_opts, sizeof queue_opts);
1534                        queue_opts.priority = DEFAULT_PRIORITY;
1535                        queue_opts.qlimit = DEFAULT_QLIMIT;
1536                        queue_opts.scheduler.qtype = ALTQT_NONE;
1537                        queue_opts.queue_bwspec.bw_percent = 100;
1538                        $$ = queue_opts;
1539                }
1540                ;
1541
1542queue_opts_l    : queue_opts_l queue_opt
1543                | queue_opt
1544                ;
1545
1546queue_opt       : BANDWIDTH bandwidth   {
1547                        if (queue_opts.marker & QOM_BWSPEC) {
1548                                yyerror("bandwidth cannot be respecified");
1549                                YYERROR;
1550                        }
1551                        queue_opts.marker |= QOM_BWSPEC;
1552                        queue_opts.queue_bwspec = $2;
1553                }
1554                | PRIORITY NUMBER       {
1555                        if (queue_opts.marker & QOM_PRIORITY) {
1556                                yyerror("priority cannot be respecified");
1557                                YYERROR;
1558                        }
1559                        if ($2 < 0 || $2 > 255) {
1560                                yyerror("priority out of range: max 255");
1561                                YYERROR;
1562                        }
1563                        queue_opts.marker |= QOM_PRIORITY;
1564                        queue_opts.priority = $2;
1565                }
1566                | QLIMIT NUMBER {
1567                        if (queue_opts.marker & QOM_QLIMIT) {
1568                                yyerror("qlimit cannot be respecified");
1569                                YYERROR;
1570                        }
1571                        if ($2 < 0 || $2 > 65535) {
1572                                yyerror("qlimit out of range: max 65535");
1573                                YYERROR;
1574                        }
1575                        queue_opts.marker |= QOM_QLIMIT;
1576                        queue_opts.qlimit = $2;
1577                }
1578                | scheduler     {
1579                        if (queue_opts.marker & QOM_SCHEDULER) {
1580                                yyerror("scheduler cannot be respecified");
1581                                YYERROR;
1582                        }
1583                        queue_opts.marker |= QOM_SCHEDULER;
1584                        queue_opts.scheduler = $1;
1585                }
1586                | TBRSIZE NUMBER        {
1587                        if (queue_opts.marker & QOM_TBRSIZE) {
1588                                yyerror("tbrsize cannot be respecified");
1589                                YYERROR;
1590                        }
1591                        if ($2 < 0 || $2 > 65535) {
1592                                yyerror("tbrsize too big: max 65535");
1593                                YYERROR;
1594                        }
1595                        queue_opts.marker |= QOM_TBRSIZE;
1596                        queue_opts.tbrsize = $2;
1597                }
1598                ;
1599
1600bandwidth       : STRING {
1601                        double   bps;
1602                        char    *cp;
1603
1604                        $$.bw_percent = 0;
1605
1606                        bps = strtod($1, &cp);
1607                        if (cp != NULL) {
1608                                if (!strcmp(cp, "b"))
1609                                        ; /* nothing */
1610                                else if (!strcmp(cp, "Kb"))
1611                                        bps *= 1000;
1612                                else if (!strcmp(cp, "Mb"))
1613                                        bps *= 1000 * 1000;
1614                                else if (!strcmp(cp, "Gb"))
1615                                        bps *= 1000 * 1000 * 1000;
1616                                else if (!strcmp(cp, "%")) {
1617                                        if (bps < 0 || bps > 100) {
1618                                                yyerror("bandwidth spec "
1619                                                    "out of range");
1620                                                free($1);
1621                                                YYERROR;
1622                                        }
1623                                        $$.bw_percent = bps;
1624                                        bps = 0;
1625                                } else {
1626                                        yyerror("unknown unit %s", cp);
1627                                        free($1);
1628                                        YYERROR;
1629                                }
1630                        }
1631                        free($1);
1632                        $$.bw_absolute = (u_int32_t)bps;
1633                }
1634                | NUMBER {
1635                        if ($1 < 0 || $1 > UINT_MAX) {
1636                                yyerror("bandwidth number too big");
1637                                YYERROR;
1638                        }
1639                        $$.bw_percent = 0;
1640                        $$.bw_absolute = $1;
1641                }
1642                ;
1643
1644scheduler       : CBQ                           {
1645                        $$.qtype = ALTQT_CBQ;
1646                        $$.data.cbq_opts.flags = 0;
1647                }
1648                | CBQ '(' cbqflags_list ')'     {
1649                        $$.qtype = ALTQT_CBQ;
1650                        $$.data.cbq_opts.flags = $3;
1651                }
1652                | PRIQ                          {
1653                        $$.qtype = ALTQT_PRIQ;
1654                        $$.data.priq_opts.flags = 0;
1655                }
1656                | PRIQ '(' priqflags_list ')'   {
1657                        $$.qtype = ALTQT_PRIQ;
1658                        $$.data.priq_opts.flags = $3;
1659                }
1660                | HFSC                          {
1661                        $$.qtype = ALTQT_HFSC;
1662                        bzero(&$$.data.hfsc_opts,
1663                            sizeof(struct node_hfsc_opts));
1664                }
1665                | HFSC '(' hfsc_opts ')'        {
1666                        $$.qtype = ALTQT_HFSC;
1667                        $$.data.hfsc_opts = $3;
1668                }
1669                ;
1670
1671cbqflags_list   : cbqflags_item                         { $$ |= $1; }
1672                | cbqflags_list comma cbqflags_item     { $$ |= $3; }
1673                ;
1674
1675cbqflags_item   : STRING        {
1676                        if (!strcmp($1, "default"))
1677                                $$ = CBQCLF_DEFCLASS;
1678                        else if (!strcmp($1, "borrow"))
1679                                $$ = CBQCLF_BORROW;
1680                        else if (!strcmp($1, "red"))
1681                                $$ = CBQCLF_RED;
1682                        else if (!strcmp($1, "ecn"))
1683                                $$ = CBQCLF_RED|CBQCLF_ECN;
1684                        else if (!strcmp($1, "rio"))
1685                                $$ = CBQCLF_RIO;
1686                        else {
1687                                yyerror("unknown cbq flag \"%s\"", $1);
1688                                free($1);
1689                                YYERROR;
1690                        }
1691                        free($1);
1692                }
1693                ;
1694
1695priqflags_list  : priqflags_item                        { $$ |= $1; }
1696                | priqflags_list comma priqflags_item   { $$ |= $3; }
1697                ;
1698
1699priqflags_item  : STRING        {
1700                        if (!strcmp($1, "default"))
1701                                $$ = PRCF_DEFAULTCLASS;
1702                        else if (!strcmp($1, "red"))
1703                                $$ = PRCF_RED;
1704                        else if (!strcmp($1, "ecn"))
1705                                $$ = PRCF_RED|PRCF_ECN;
1706                        else if (!strcmp($1, "rio"))
1707                                $$ = PRCF_RIO;
1708                        else {
1709                                yyerror("unknown priq flag \"%s\"", $1);
1710                                free($1);
1711                                YYERROR;
1712                        }
1713                        free($1);
1714                }
1715                ;
1716
1717hfsc_opts       :       {
1718                                bzero(&hfsc_opts,
1719                                    sizeof(struct node_hfsc_opts));
1720                        }
1721                    hfscopts_list                               {
1722                        $$ = hfsc_opts;
1723                }
1724                ;
1725
1726hfscopts_list   : hfscopts_item
1727                | hfscopts_list comma hfscopts_item
1728                ;
1729
1730hfscopts_item   : LINKSHARE bandwidth                           {
1731                        if (hfsc_opts.linkshare.used) {
1732                                yyerror("linkshare already specified");
1733                                YYERROR;
1734                        }
1735                        hfsc_opts.linkshare.m2 = $2;
1736                        hfsc_opts.linkshare.used = 1;
1737                }
1738                | LINKSHARE '(' bandwidth comma NUMBER comma bandwidth ')'
1739                    {
1740                        if ($5 < 0 || $5 > INT_MAX) {
1741                                yyerror("timing in curve out of range");
1742                                YYERROR;
1743                        }
1744                        if (hfsc_opts.linkshare.used) {
1745                                yyerror("linkshare already specified");
1746                                YYERROR;
1747                        }
1748                        hfsc_opts.linkshare.m1 = $3;
1749                        hfsc_opts.linkshare.d = $5;
1750                        hfsc_opts.linkshare.m2 = $7;
1751                        hfsc_opts.linkshare.used = 1;
1752                }
1753                | REALTIME bandwidth                            {
1754                        if (hfsc_opts.realtime.used) {
1755                                yyerror("realtime already specified");
1756                                YYERROR;
1757                        }
1758                        hfsc_opts.realtime.m2 = $2;
1759                        hfsc_opts.realtime.used = 1;
1760                }
1761                | REALTIME '(' bandwidth comma NUMBER comma bandwidth ')'
1762                    {
1763                        if ($5 < 0 || $5 > INT_MAX) {
1764                                yyerror("timing in curve out of range");
1765                                YYERROR;
1766                        }
1767                        if (hfsc_opts.realtime.used) {
1768                                yyerror("realtime already specified");
1769                                YYERROR;
1770                        }
1771                        hfsc_opts.realtime.m1 = $3;
1772                        hfsc_opts.realtime.d = $5;
1773                        hfsc_opts.realtime.m2 = $7;
1774                        hfsc_opts.realtime.used = 1;
1775                }
1776                | UPPERLIMIT bandwidth                          {
1777                        if (hfsc_opts.upperlimit.used) {
1778                                yyerror("upperlimit already specified");
1779                                YYERROR;
1780                        }
1781                        hfsc_opts.upperlimit.m2 = $2;
1782                        hfsc_opts.upperlimit.used = 1;
1783                }
1784                | UPPERLIMIT '(' bandwidth comma NUMBER comma bandwidth ')'
1785                    {
1786                        if ($5 < 0 || $5 > INT_MAX) {
1787                                yyerror("timing in curve out of range");
1788                                YYERROR;
1789                        }
1790                        if (hfsc_opts.upperlimit.used) {
1791                                yyerror("upperlimit already specified");
1792                                YYERROR;
1793                        }
1794                        hfsc_opts.upperlimit.m1 = $3;
1795                        hfsc_opts.upperlimit.d = $5;
1796                        hfsc_opts.upperlimit.m2 = $7;
1797                        hfsc_opts.upperlimit.used = 1;
1798                }
1799                | STRING        {
1800                        if (!strcmp($1, "default"))
1801                                hfsc_opts.flags |= HFCF_DEFAULTCLASS;
1802                        else if (!strcmp($1, "red"))
1803                                hfsc_opts.flags |= HFCF_RED;
1804                        else if (!strcmp($1, "ecn"))
1805                                hfsc_opts.flags |= HFCF_RED|HFCF_ECN;
1806                        else if (!strcmp($1, "rio"))
1807                                hfsc_opts.flags |= HFCF_RIO;
1808                        else {
1809                                yyerror("unknown hfsc flag \"%s\"", $1);
1810                                free($1);
1811                                YYERROR;
1812                        }
1813                        free($1);
1814                }
1815                ;
1816
1817qassign         : /* empty */           { $$ = NULL; }
1818                | qassign_item          { $$ = $1; }
1819                | '{' optnl qassign_list '}'    { $$ = $3; }
1820                ;
1821
1822qassign_list    : qassign_item optnl            { $$ = $1; }
1823                | qassign_list comma qassign_item optnl {
1824                        $1->tail->next = $3;
1825                        $1->tail = $3;
1826                        $$ = $1;
1827                }
1828                ;
1829
1830qassign_item    : STRING                        {
1831                        $$ = calloc(1, sizeof(struct node_queue));
1832                        if ($$ == NULL)
1833                                err(1, "qassign_item: calloc");
1834                        if (strlcpy($$->queue, $1, sizeof($$->queue)) >=
1835                            sizeof($$->queue)) {
1836                                yyerror("queue name '%s' too long (max "
1837                                    "%d chars)", $1, sizeof($$->queue)-1);
1838                                free($1);
1839                                free($$);
1840                                YYERROR;
1841                        }
1842                        free($1);
1843                        $$->next = NULL;
1844                        $$->tail = $$;
1845                }
1846                ;
1847
1848pfrule          : action dir logquick interface route af proto fromto
1849                    filter_opts
1850                {
1851                        struct pf_rule           r;
1852                        struct node_state_opt   *o;
1853                        struct node_proto       *proto;
1854                        int                      srctrack = 0;
1855                        int                      statelock = 0;
1856                        int                      adaptive = 0;
1857                        int                      defaults = 0;
1858
1859                        if (check_rulestate(PFCTL_STATE_FILTER))
1860                                YYERROR;
1861
1862                        memset(&r, 0, sizeof(r));
1863
1864                        r.action = $1.b1;
1865                        switch ($1.b2) {
1866                        case PFRULE_RETURNRST:
1867                                r.rule_flag |= PFRULE_RETURNRST;
1868                                r.return_ttl = $1.w;
1869                                break;
1870                        case PFRULE_RETURNICMP:
1871                                r.rule_flag |= PFRULE_RETURNICMP;
1872                                r.return_icmp = $1.w;
1873                                r.return_icmp6 = $1.w2;
1874                                break;
1875                        case PFRULE_RETURN:
1876                                r.rule_flag |= PFRULE_RETURN;
1877                                r.return_icmp = $1.w;
1878                                r.return_icmp6 = $1.w2;
1879                                break;
1880                        }
1881                        r.direction = $2;
1882                        r.log = $3.log;
1883                        r.logif = $3.logif;
1884                        r.quick = $3.quick;
1885                        r.prob = $9.prob;
1886                        r.rtableid = $9.rtableid;
1887
1888                        r.af = $6;
1889                        if ($9.tag)
1890                                if (strlcpy(r.tagname, $9.tag,
1891                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
1892                                        yyerror("tag too long, max %u chars",
1893                                            PF_TAG_NAME_SIZE - 1);
1894                                        YYERROR;
1895                                }
1896                        if ($9.match_tag)
1897                                if (strlcpy(r.match_tagname, $9.match_tag,
1898                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
1899                                        yyerror("tag too long, max %u chars",
1900                                            PF_TAG_NAME_SIZE - 1);
1901                                        YYERROR;
1902                                }
1903                        r.match_tag_not = $9.match_tag_not;
1904                        if (rule_label(&r, $9.label))
1905                                YYERROR;
1906                        free($9.label);
1907                        r.flags = $9.flags.b1;
1908                        r.flagset = $9.flags.b2;
1909                        if (($9.flags.b1 & $9.flags.b2) != $9.flags.b1) {
1910                                yyerror("flags always false");
1911                                YYERROR;
1912                        }
1913                        if ($9.flags.b1 || $9.flags.b2 || $8.src_os) {
1914                                for (proto = $7; proto != NULL &&
1915                                    proto->proto != IPPROTO_TCP;
1916                                    proto = proto->next)
1917                                        ;       /* nothing */
1918                                if (proto == NULL && $7 != NULL) {
1919                                        if ($9.flags.b1 || $9.flags.b2)
1920                                                yyerror(
1921                                                    "flags only apply to tcp");
1922                                        if ($8.src_os)
1923                                                yyerror(
1924                                                    "OS fingerprinting only "
1925                                                    "apply to tcp");
1926                                        YYERROR;
1927                                }
1928#if 0
1929                                if (($9.flags.b1 & parse_flags("S")) == 0 &&
1930                                    $8.src_os) {
1931                                        yyerror("OS fingerprinting requires "
1932                                            "the SYN TCP flag (flags S/SA)");
1933                                        YYERROR;
1934                                }
1935#endif
1936                        }
1937
1938                        r.tos = $9.tos;
1939                        r.keep_state = $9.keep.action;
1940                        o = $9.keep.options;
1941
1942                        /* 'keep state' by default on pass rules. */
1943                        if (!r.keep_state && !r.action &&
1944                            !($9.marker & FOM_KEEP)) {
1945                                r.keep_state = PF_STATE_NORMAL;
1946                                o = keep_state_defaults;
1947                                defaults = 1;
1948                        }
1949
1950                        while (o) {
1951                                struct node_state_opt   *p = o;
1952
1953                                switch (o->type) {
1954                                case PF_STATE_OPT_MAX:
1955                                        if (r.max_states) {
1956                                                yyerror("state option 'max' "
1957                                                    "multiple definitions");
1958                                                YYERROR;
1959                                        }
1960                                        r.max_states = o->data.max_states;
1961                                        break;
1962                                case PF_STATE_OPT_NOSYNC:
1963                                        if (r.rule_flag & PFRULE_NOSYNC) {
1964                                                yyerror("state option 'sync' "
1965                                                    "multiple definitions");
1966                                                YYERROR;
1967                                        }
1968                                        r.rule_flag |= PFRULE_NOSYNC;
1969                                        break;
1970                                case PF_STATE_OPT_SRCTRACK:
1971                                        if (srctrack) {
1972                                                yyerror("state option "
1973                                                    "'source-track' "
1974                                                    "multiple definitions");
1975                                                YYERROR;
1976                                        }
1977                                        srctrack =  o->data.src_track;
1978                                        r.rule_flag |= PFRULE_SRCTRACK;
1979                                        break;
1980                                case PF_STATE_OPT_MAX_SRC_STATES:
1981                                        if (r.max_src_states) {
1982                                                yyerror("state option "
1983                                                    "'max-src-states' "
1984                                                    "multiple definitions");
1985                                                YYERROR;
1986                                        }
1987                                        if (o->data.max_src_states == 0) {
1988                                                yyerror("'max-src-states' must "
1989                                                    "be > 0");
1990                                                YYERROR;
1991                                        }
1992                                        r.max_src_states =
1993                                            o->data.max_src_states;
1994                                        r.rule_flag |= PFRULE_SRCTRACK;
1995                                        break;
1996                                case PF_STATE_OPT_OVERLOAD:
1997                                        if (r.overload_tblname[0]) {
1998                                                yyerror("multiple 'overload' "
1999                                                    "table definitions");
2000                                                YYERROR;
2001                                        }
2002                                        if (strlcpy(r.overload_tblname,
2003                                            o->data.overload.tblname,
2004                                            PF_TABLE_NAME_SIZE) >=
2005                                            PF_TABLE_NAME_SIZE) {
2006                                                yyerror("state option: "
2007                                                    "strlcpy");
2008                                                YYERROR;
2009                                        }
2010                                        r.flush = o->data.overload.flush;
2011                                        break;
2012                                case PF_STATE_OPT_MAX_SRC_CONN:
2013                                        if (r.max_src_conn) {
2014                                                yyerror("state option "
2015                                                    "'max-src-conn' "
2016                                                    "multiple definitions");
2017                                                YYERROR;
2018                                        }
2019                                        if (o->data.max_src_conn == 0) {
2020                                                yyerror("'max-src-conn' "
2021                                                    "must be > 0");
2022                                                YYERROR;
2023                                        }
2024                                        r.max_src_conn =
2025                                            o->data.max_src_conn;
2026                                        r.rule_flag |= PFRULE_SRCTRACK |
2027                                            PFRULE_RULESRCTRACK;
2028                                        break;
2029                                case PF_STATE_OPT_MAX_SRC_CONN_RATE:
2030                                        if (r.max_src_conn_rate.limit) {
2031                                                yyerror("state option "
2032                                                    "'max-src-conn-rate' "
2033                                                    "multiple definitions");
2034                                                YYERROR;
2035                                        }
2036                                        if (!o->data.max_src_conn_rate.limit ||
2037                                            !o->data.max_src_conn_rate.seconds) {
2038                                                yyerror("'max-src-conn-rate' "
2039                                                    "values must be > 0");
2040                                                YYERROR;
2041                                        }
2042                                        if (o->data.max_src_conn_rate.limit >
2043                                            PF_THRESHOLD_MAX) {
2044                                                yyerror("'max-src-conn-rate' "
2045                                                    "maximum rate must be < %u",
2046                                                    PF_THRESHOLD_MAX);
2047                                                YYERROR;
2048                                        }
2049                                        r.max_src_conn_rate.limit =
2050                                            o->data.max_src_conn_rate.limit;
2051                                        r.max_src_conn_rate.seconds =
2052                                            o->data.max_src_conn_rate.seconds;
2053                                        r.rule_flag |= PFRULE_SRCTRACK |
2054                                            PFRULE_RULESRCTRACK;
2055                                        break;
2056                                case PF_STATE_OPT_MAX_SRC_NODES:
2057                                        if (r.max_src_nodes) {
2058                                                yyerror("state option "
2059                                                    "'max-src-nodes' "
2060                                                    "multiple definitions");
2061                                                YYERROR;
2062                                        }
2063                                        if (o->data.max_src_nodes == 0) {
2064                                                yyerror("'max-src-nodes' must "
2065                                                    "be > 0");
2066                                                YYERROR;
2067                                        }
2068                                        r.max_src_nodes =
2069                                            o->data.max_src_nodes;
2070                                        r.rule_flag |= PFRULE_SRCTRACK |
2071                                            PFRULE_RULESRCTRACK;
2072                                        break;
2073                                case PF_STATE_OPT_STATELOCK:
2074                                        if (statelock) {
2075                                                yyerror("state locking option: "
2076                                                    "multiple definitions");
2077                                                YYERROR;
2078                                        }
2079                                        statelock = 1;
2080                                        r.rule_flag |= o->data.statelock;
2081                                        break;
2082                                case PF_STATE_OPT_SLOPPY:
2083                                        if (r.rule_flag & PFRULE_STATESLOPPY) {
2084                                                yyerror("state sloppy option: "
2085                                                    "multiple definitions");
2086                                                YYERROR;
2087                                        }
2088                                        r.rule_flag |= PFRULE_STATESLOPPY;
2089                                        break;
2090                                case PF_STATE_OPT_PFLOW:
2091                                        if (r.rule_flag & PFRULE_PFLOW) {
2092                                                yyerror("state pflow "
2093                                                    "option: multiple "
2094                                                    "definitions");
2095                                                YYERROR;
2096                                        }
2097                                        r.rule_flag |= PFRULE_PFLOW;
2098                                        break;
2099                                case PF_STATE_OPT_TIMEOUT:
2100                                        if (o->data.timeout.number ==
2101                                            PFTM_ADAPTIVE_START ||
2102                                            o->data.timeout.number ==
2103                                            PFTM_ADAPTIVE_END)
2104                                                adaptive = 1;
2105                                        if (r.timeout[o->data.timeout.number]) {
2106                                                yyerror("state timeout %s "
2107                                                    "multiple definitions",
2108                                                    pf_timeouts[o->data.
2109                                                    timeout.number].name);
2110                                                YYERROR;
2111                                        }
2112                                        r.timeout[o->data.timeout.number] =
2113                                            o->data.timeout.seconds;
2114                                }
2115                                o = o->next;
2116                                if (!defaults)
2117                                        free(p);
2118                        }
2119
2120                        /* 'flags S/SA' by default on stateful rules */
2121                        if (!r.action && !r.flags && !r.flagset &&
2122                            !$9.fragment && !($9.marker & FOM_FLAGS) &&
2123                            r.keep_state) {
2124                                r.flags = parse_flags("S");
2125                                r.flagset =  parse_flags("SA");
2126                        }
2127                        if (!adaptive && r.max_states) {
2128                                r.timeout[PFTM_ADAPTIVE_START] =
2129                                    (r.max_states / 10) * 6;
2130                                r.timeout[PFTM_ADAPTIVE_END] =
2131                                    (r.max_states / 10) * 12;
2132                        }
2133                        if (r.rule_flag & PFRULE_SRCTRACK) {
2134                                if (srctrack == PF_SRCTRACK_GLOBAL &&
2135                                    r.max_src_nodes) {
2136                                        yyerror("'max-src-nodes' is "
2137                                            "incompatible with "
2138                                            "'source-track global'");
2139                                        YYERROR;
2140                                }
2141                                if (srctrack == PF_SRCTRACK_GLOBAL &&
2142                                    r.max_src_conn) {
2143                                        yyerror("'max-src-conn' is "
2144                                            "incompatible with "
2145                                            "'source-track global'");
2146                                        YYERROR;
2147                                }
2148                                if (srctrack == PF_SRCTRACK_GLOBAL &&
2149                                    r.max_src_conn_rate.seconds) {
2150                                        yyerror("'max-src-conn-rate' is "
2151                                            "incompatible with "
2152                                            "'source-track global'");
2153                                        YYERROR;
2154                                }
2155                                if (r.timeout[PFTM_SRC_NODE] <
2156                                    r.max_src_conn_rate.seconds)
2157                                        r.timeout[PFTM_SRC_NODE] =
2158                                            r.max_src_conn_rate.seconds;
2159                                r.rule_flag |= PFRULE_SRCTRACK;
2160                                if (srctrack == PF_SRCTRACK_RULE)
2161                                        r.rule_flag |= PFRULE_RULESRCTRACK;
2162                        }
2163                        if (r.keep_state && !statelock)
2164                                r.rule_flag |= default_statelock;
2165
2166                        if ($9.fragment)
2167                                r.rule_flag |= PFRULE_FRAGMENT;
2168                        r.allow_opts = $9.allowopts;
2169
2170                        decide_address_family($8.src.host, &r.af);
2171                        decide_address_family($8.dst.host, &r.af);
2172
2173                        if ($5.rt) {
2174                                if (!r.direction) {
2175                                        yyerror("direction must be explicit "
2176                                            "with rules that specify routing");
2177                                        YYERROR;
2178                                }
2179                                r.rt = $5.rt;
2180                                r.rpool.opts = $5.pool_opts;
2181                                if ($5.key != NULL)
2182                                        memcpy(&r.rpool.key, $5.key,
2183                                            sizeof(struct pf_poolhashkey));
2184                        }
2185                        if (r.rt && r.rt != PF_FASTROUTE) {
2186                                decide_address_family($5.host, &r.af);
2187                                remove_invalid_hosts(&$5.host, &r.af);
2188                                if ($5.host == NULL) {
2189                                        yyerror("no routing address with "
2190                                            "matching address family found.");
2191                                        YYERROR;
2192                                }
2193                                if ((r.rpool.opts & PF_POOL_TYPEMASK) ==
2194                                    PF_POOL_NONE && ($5.host->next != NULL ||
2195                                    $5.host->addr.type == PF_ADDR_TABLE ||
2196                                    DYNIF_MULTIADDR($5.host->addr)))
2197                                        r.rpool.opts |= PF_POOL_ROUNDROBIN;
2198                                if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
2199                                    PF_POOL_ROUNDROBIN &&
2200                                    disallow_table($5.host, "tables are only "
2201                                    "supported in round-robin routing pools"))
2202                                        YYERROR;
2203                                if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
2204                                    PF_POOL_ROUNDROBIN &&
2205                                    disallow_alias($5.host, "interface (%s) "
2206                                    "is only supported in round-robin "
2207                                    "routing pools"))
2208                                        YYERROR;
2209                                if ($5.host->next != NULL) {
2210                                        if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
2211                                            PF_POOL_ROUNDROBIN) {
2212                                                yyerror("r.rpool.opts must "
2213                                                    "be PF_POOL_ROUNDROBIN");
2214                                                YYERROR;
2215                                        }
2216                                }
2217                        }
2218                        if ($9.queues.qname != NULL) {
2219                                if (strlcpy(r.qname, $9.queues.qname,
2220                                    sizeof(r.qname)) >= sizeof(r.qname)) {
2221                                        yyerror("rule qname too long (max "
2222                                            "%d chars)", sizeof(r.qname)-1);
2223                                        YYERROR;
2224                                }
2225                                free($9.queues.qname);
2226                        }
2227                        if ($9.queues.pqname != NULL) {
2228                                if (strlcpy(r.pqname, $9.queues.pqname,
2229                                    sizeof(r.pqname)) >= sizeof(r.pqname)) {
2230                                        yyerror("rule pqname too long (max "
2231                                            "%d chars)", sizeof(r.pqname)-1);
2232                                        YYERROR;
2233                                }
2234                                free($9.queues.pqname);
2235                        }
2236#ifdef __FreeBSD__
2237                        r.divert.port = $9.divert.port;
2238#else
2239                        if ((r.divert.port = $9.divert.port)) {
2240                                if (r.direction == PF_OUT) {
2241                                        if ($9.divert.addr) {
2242                                                yyerror("address specified "
2243                                                    "for outgoing divert");
2244                                                YYERROR;
2245                                        }
2246                                        bzero(&r.divert.addr,
2247                                            sizeof(r.divert.addr));
2248                                } else {
2249                                        if (!$9.divert.addr) {
2250                                                yyerror("no address specified "
2251                                                    "for incoming divert");
2252                                                YYERROR;
2253                                        }
2254                                        if ($9.divert.addr->af != r.af) {
2255                                                yyerror("address family "
2256                                                    "mismatch for divert");
2257                                                YYERROR;
2258                                        }
2259                                        r.divert.addr =
2260                                            $9.divert.addr->addr.v.a.addr;
2261                                }
2262                        }
2263#endif
2264
2265                        expand_rule(&r, $4, $5.host, $7, $8.src_os,
2266                            $8.src.host, $8.src.port, $8.dst.host, $8.dst.port,
2267                            $9.uid, $9.gid, $9.icmpspec, "");
2268                }
2269                ;
2270
2271filter_opts     :       {
2272                                bzero(&filter_opts, sizeof filter_opts);
2273                                filter_opts.rtableid = -1;
2274                        }
2275                    filter_opts_l
2276                        { $$ = filter_opts; }
2277                | /* empty */   {
2278                        bzero(&filter_opts, sizeof filter_opts);
2279                        filter_opts.rtableid = -1;
2280                        $$ = filter_opts;
2281                }
2282                ;
2283
2284filter_opts_l   : filter_opts_l filter_opt
2285                | filter_opt
2286                ;
2287
2288filter_opt      : USER uids {
2289                        if (filter_opts.uid)
2290                                $2->tail->next = filter_opts.uid;
2291                        filter_opts.uid = $2;
2292                }
2293                | GROUP gids {
2294                        if (filter_opts.gid)
2295                                $2->tail->next = filter_opts.gid;
2296                        filter_opts.gid = $2;
2297                }
2298                | flags {
2299                        if (filter_opts.marker & FOM_FLAGS) {
2300                                yyerror("flags cannot be redefined");
2301                                YYERROR;
2302                        }
2303                        filter_opts.marker |= FOM_FLAGS;
2304                        filter_opts.flags.b1 |= $1.b1;
2305                        filter_opts.flags.b2 |= $1.b2;
2306                        filter_opts.flags.w |= $1.w;
2307                        filter_opts.flags.w2 |= $1.w2;
2308                }
2309                | icmpspec {
2310                        if (filter_opts.marker & FOM_ICMP) {
2311                                yyerror("icmp-type cannot be redefined");
2312                                YYERROR;
2313                        }
2314                        filter_opts.marker |= FOM_ICMP;
2315                        filter_opts.icmpspec = $1;
2316                }
2317                | TOS tos {
2318                        if (filter_opts.marker & FOM_TOS) {
2319                                yyerror("tos cannot be redefined");
2320                                YYERROR;
2321                        }
2322                        filter_opts.marker |= FOM_TOS;
2323                        filter_opts.tos = $2;
2324                }
2325                | keep {
2326                        if (filter_opts.marker & FOM_KEEP) {
2327                                yyerror("modulate or keep cannot be redefined");
2328                                YYERROR;
2329                        }
2330                        filter_opts.marker |= FOM_KEEP;
2331                        filter_opts.keep.action = $1.action;
2332                        filter_opts.keep.options = $1.options;
2333                }
2334                | FRAGMENT {
2335                        filter_opts.fragment = 1;
2336                }
2337                | ALLOWOPTS {
2338                        filter_opts.allowopts = 1;
2339                }
2340                | label {
2341                        if (filter_opts.label) {
2342                                yyerror("label cannot be redefined");
2343                                YYERROR;
2344                        }
2345                        filter_opts.label = $1;
2346                }
2347                | qname {
2348                        if (filter_opts.queues.qname) {
2349                                yyerror("queue cannot be redefined");
2350                                YYERROR;
2351                        }
2352                        filter_opts.queues = $1;
2353                }
2354                | TAG string                            {
2355                        filter_opts.tag = $2;
2356                }
2357                | not TAGGED string                     {
2358                        filter_opts.match_tag = $3;
2359                        filter_opts.match_tag_not = $1;
2360                }
2361                | PROBABILITY probability               {
2362                        double  p;
2363
2364                        p = floor($2 * UINT_MAX + 0.5);
2365                        if (p < 0.0 || p > UINT_MAX) {
2366                                yyerror("invalid probability: %lf", p);
2367                                YYERROR;
2368                        }
2369                        filter_opts.prob = (u_int32_t)p;
2370                        if (filter_opts.prob == 0)
2371                                filter_opts.prob = 1;
2372                }
2373                | RTABLE NUMBER                         {
2374                        if ($2 < 0 || $2 > rt_tableid_max()) {
2375                                yyerror("invalid rtable id");
2376                                YYERROR;
2377                        }
2378                        filter_opts.rtableid = $2;
2379                }
2380                | DIVERTTO portplain {
2381#ifdef __FreeBSD__
2382                        filter_opts.divert.port = $2.a;
2383                        if (!filter_opts.divert.port) {
2384                                yyerror("invalid divert port: %u", ntohs($2.a));
2385                                YYERROR;
2386                        }
2387#endif
2388                }
2389                | DIVERTTO STRING PORT portplain {
2390#ifndef __FreeBSD__
2391                        if ((filter_opts.divert.addr = host($2)) == NULL) {
2392                                yyerror("could not parse divert address: %s",
2393                                    $2);
2394                                free($2);
2395                                YYERROR;
2396                        }
2397#else
2398                        if ($2)
2399#endif
2400                        free($2);
2401                        filter_opts.divert.port = $4.a;
2402                        if (!filter_opts.divert.port) {
2403                                yyerror("invalid divert port: %u", ntohs($4.a));
2404                                YYERROR;
2405                        }
2406                }
2407                | DIVERTREPLY {
2408#ifdef __FreeBSD__
2409                        yyerror("divert-reply has no meaning in FreeBSD pf(4)");
2410                        YYERROR;
2411#else
2412                        filter_opts.divert.port = 1;    /* some random value */
2413#endif
2414                }
2415                ;
2416
2417probability     : STRING                                {
2418                        char    *e;
2419                        double   p = strtod($1, &e);
2420
2421                        if (*e == '%') {
2422                                p *= 0.01;
2423                                e++;
2424                        }
2425                        if (*e) {
2426                                yyerror("invalid probability: %s", $1);
2427                                free($1);
2428                                YYERROR;
2429                        }
2430                        free($1);
2431                        $$ = p;
2432                }
2433                | NUMBER                                {
2434                        $$ = (double)$1;
2435                }
2436                ;
2437
2438
2439action          : PASS                  { $$.b1 = PF_PASS; $$.b2 = $$.w = 0; }
2440                | BLOCK blockspec       { $$ = $2; $$.b1 = PF_DROP; }
2441                ;
2442
2443blockspec       : /* empty */           {
2444                        $$.b2 = blockpolicy;
2445                        $$.w = returnicmpdefault;
2446                        $$.w2 = returnicmp6default;
2447                }
2448                | DROP                  {
2449                        $$.b2 = PFRULE_DROP;
2450                        $$.w = 0;
2451                        $$.w2 = 0;
2452                }
2453                | RETURNRST             {
2454                        $$.b2 = PFRULE_RETURNRST;
2455                        $$.w = 0;
2456                        $$.w2 = 0;
2457                }
2458                | RETURNRST '(' TTL NUMBER ')'  {
2459                        if ($4 < 0 || $4 > 255) {
2460                                yyerror("illegal ttl value %d", $4);
2461                                YYERROR;
2462                        }
2463                        $$.b2 = PFRULE_RETURNRST;
2464                        $$.w = $4;
2465                        $$.w2 = 0;
2466                }
2467                | RETURNICMP            {
2468                        $$.b2 = PFRULE_RETURNICMP;
2469                        $$.w = returnicmpdefault;
2470                        $$.w2 = returnicmp6default;
2471                }
2472                | RETURNICMP6           {
2473                        $$.b2 = PFRULE_RETURNICMP;
2474                        $$.w = returnicmpdefault;
2475                        $$.w2 = returnicmp6default;
2476                }
2477                | RETURNICMP '(' reticmpspec ')'        {
2478                        $$.b2 = PFRULE_RETURNICMP;
2479                        $$.w = $3;
2480                        $$.w2 = returnicmpdefault;
2481                }
2482                | RETURNICMP6 '(' reticmp6spec ')'      {
2483                        $$.b2 = PFRULE_RETURNICMP;
2484                        $$.w = returnicmpdefault;
2485                        $$.w2 = $3;
2486                }
2487                | RETURNICMP '(' reticmpspec comma reticmp6spec ')' {
2488                        $$.b2 = PFRULE_RETURNICMP;
2489                        $$.w = $3;
2490                        $$.w2 = $5;
2491                }
2492                | RETURN {
2493                        $$.b2 = PFRULE_RETURN;
2494                        $$.w = returnicmpdefault;
2495                        $$.w2 = returnicmp6default;
2496                }
2497                ;
2498
2499reticmpspec     : STRING                        {
2500                        if (!($$ = parseicmpspec($1, AF_INET))) {
2501                                free($1);
2502                                YYERROR;
2503                        }
2504                        free($1);
2505                }
2506                | NUMBER                        {
2507                        u_int8_t                icmptype;
2508
2509                        if ($1 < 0 || $1 > 255) {
2510                                yyerror("invalid icmp code %lu", $1);
2511                                YYERROR;
2512                        }
2513                        icmptype = returnicmpdefault >> 8;
2514                        $$ = (icmptype << 8 | $1);
2515                }
2516                ;
2517
2518reticmp6spec    : STRING                        {
2519                        if (!($$ = parseicmpspec($1, AF_INET6))) {
2520                                free($1);
2521                                YYERROR;
2522                        }
2523                        free($1);
2524                }
2525                | NUMBER                        {
2526                        u_int8_t                icmptype;
2527
2528                        if ($1 < 0 || $1 > 255) {
2529                                yyerror("invalid icmp code %lu", $1);
2530                                YYERROR;
2531                        }
2532                        icmptype = returnicmp6default >> 8;
2533                        $$ = (icmptype << 8 | $1);
2534                }
2535                ;
2536
2537dir             : /* empty */                   { $$ = PF_INOUT; }
2538                | IN                            { $$ = PF_IN; }
2539                | OUT                           { $$ = PF_OUT; }
2540                ;
2541
2542quick           : /* empty */                   { $$.quick = 0; }
2543                | QUICK                         { $$.quick = 1; }
2544                ;
2545
2546logquick        : /* empty */   { $$.log = 0; $$.quick = 0; $$.logif = 0; }
2547                | log           { $$ = $1; $$.quick = 0; }
2548                | QUICK         { $$.quick = 1; $$.log = 0; $$.logif = 0; }
2549                | log QUICK     { $$ = $1; $$.quick = 1; }
2550                | QUICK log     { $$ = $2; $$.quick = 1; }
2551                ;
2552
2553log             : LOG                   { $$.log = PF_LOG; $$.logif = 0; }
2554                | LOG '(' logopts ')'   {
2555                        $$.log = PF_LOG | $3.log;
2556                        $$.logif = $3.logif;
2557                }
2558                ;
2559
2560logopts         : logopt                        { $$ = $1; }
2561                | logopts comma logopt          {
2562                        $$.log = $1.log | $3.log;
2563                        $$.logif = $3.logif;
2564                        if ($$.logif == 0)
2565                                $$.logif = $1.logif;
2566                }
2567                ;
2568
2569logopt          : ALL           { $$.log = PF_LOG_ALL; $$.logif = 0; }
2570                | USER          { $$.log = PF_LOG_SOCKET_LOOKUP; $$.logif = 0; }
2571                | GROUP         { $$.log = PF_LOG_SOCKET_LOOKUP; $$.logif = 0; }
2572                | TO string     {
2573                        const char      *errstr;
2574                        u_int            i;
2575
2576                        $$.log = 0;
2577                        if (strncmp($2, "pflog", 5)) {
2578                                yyerror("%s: should be a pflog interface", $2);
2579                                free($2);
2580                                YYERROR;
2581                        }
2582                        i = strtonum($2 + 5, 0, 255, &errstr);
2583                        if (errstr) {
2584                                yyerror("%s: %s", $2, errstr);
2585                                free($2);
2586                                YYERROR;
2587                        }
2588                        free($2);
2589                        $$.logif = i;
2590                }
2591                ;
2592
2593interface       : /* empty */                   { $$ = NULL; }
2594                | ON if_item_not                { $$ = $2; }
2595                | ON '{' optnl if_list '}'      { $$ = $4; }
2596                ;
2597
2598if_list         : if_item_not optnl             { $$ = $1; }
2599                | if_list comma if_item_not optnl       {
2600                        $1->tail->next = $3;
2601                        $1->tail = $3;
2602                        $$ = $1;
2603                }
2604                ;
2605
2606if_item_not     : not if_item                   { $$ = $2; $$->not = $1; }
2607                ;
2608
2609if_item         : STRING                        {
2610                        struct node_host        *n;
2611
2612                        $$ = calloc(1, sizeof(struct node_if));
2613                        if ($$ == NULL)
2614                                err(1, "if_item: calloc");
2615                        if (strlcpy($$->ifname, $1, sizeof($$->ifname)) >=
2616                            sizeof($$->ifname)) {
2617                                free($1);
2618                                free($$);
2619                                yyerror("interface name too long");
2620                                YYERROR;
2621                        }
2622
2623                        if ((n = ifa_exists($1)) != NULL)
2624                                $$->ifa_flags = n->ifa_flags;
2625
2626                        free($1);
2627                        $$->not = 0;
2628                        $$->next = NULL;
2629                        $$->tail = $$;
2630                }
2631                ;
2632
2633af              : /* empty */                   { $$ = 0; }
2634                | INET                          { $$ = AF_INET; }
2635                | INET6                         { $$ = AF_INET6; }
2636                ;
2637
2638proto           : /* empty */                           { $$ = NULL; }
2639                | PROTO proto_item                      { $$ = $2; }
2640                | PROTO '{' optnl proto_list '}'        { $$ = $4; }
2641                ;
2642
2643proto_list      : proto_item optnl              { $$ = $1; }
2644                | proto_list comma proto_item optnl     {
2645                        $1->tail->next = $3;
2646                        $1->tail = $3;
2647                        $$ = $1;
2648                }
2649                ;
2650
2651proto_item      : protoval                      {
2652                        u_int8_t        pr;
2653
2654                        pr = (u_int8_t)$1;
2655                        if (pr == 0) {
2656                                yyerror("proto 0 cannot be used");
2657                                YYERROR;
2658                        }
2659                        $$ = calloc(1, sizeof(struct node_proto));
2660                        if ($$ == NULL)
2661                                err(1, "proto_item: calloc");
2662                        $$->proto = pr;
2663                        $$->next = NULL;
2664                        $$->tail = $$;
2665                }
2666                ;
2667
2668protoval        : STRING                        {
2669                        struct protoent *p;
2670
2671                        p = getprotobyname($1);
2672                        if (p == NULL) {
2673                                yyerror("unknown protocol %s", $1);
2674                                free($1);
2675                                YYERROR;
2676                        }
2677                        $$ = p->p_proto;
2678                        free($1);
2679                }
2680                | NUMBER                        {
2681                        if ($1 < 0 || $1 > 255) {
2682                                yyerror("protocol outside range");
2683                                YYERROR;
2684                        }
2685                }
2686                ;
2687
2688fromto          : ALL                           {
2689                        $$.src.host = NULL;
2690                        $$.src.port = NULL;
2691                        $$.dst.host = NULL;
2692                        $$.dst.port = NULL;
2693                        $$.src_os = NULL;
2694                }
2695                | from os to                    {
2696                        $$.src = $1;
2697                        $$.src_os = $2;
2698                        $$.dst = $3;
2699                }
2700                ;
2701
2702os              : /* empty */                   { $$ = NULL; }
2703                | OS xos                        { $$ = $2; }
2704                | OS '{' optnl os_list '}'      { $$ = $4; }
2705                ;
2706
2707xos             : STRING {
2708                        $$ = calloc(1, sizeof(struct node_os));
2709                        if ($$ == NULL)
2710                                err(1, "os: calloc");
2711                        $$->os = $1;
2712                        $$->tail = $$;
2713                }
2714                ;
2715
2716os_list         : xos optnl                     { $$ = $1; }
2717                | os_list comma xos optnl       {
2718                        $1->tail->next = $3;
2719                        $1->tail = $3;
2720                        $$ = $1;
2721                }
2722                ;
2723
2724from            : /* empty */                   {
2725                        $$.host = NULL;
2726                        $$.port = NULL;
2727                }
2728                | FROM ipportspec               {
2729                        $$ = $2;
2730                }
2731                ;
2732
2733to              : /* empty */                   {
2734                        $$.host = NULL;
2735                        $$.port = NULL;
2736                }
2737                | TO ipportspec         {
2738                        if (disallow_urpf_failed($2.host, "\"urpf-failed\" is "
2739                            "not permitted in a destination address"))
2740                                YYERROR;
2741                        $$ = $2;
2742                }
2743                ;
2744
2745ipportspec      : ipspec                        {
2746                        $$.host = $1;
2747                        $$.port = NULL;
2748                }
2749                | ipspec PORT portspec          {
2750                        $$.host = $1;
2751                        $$.port = $3;
2752                }
2753                | PORT portspec                 {
2754                        $$.host = NULL;
2755                        $$.port = $2;
2756                }
2757                ;
2758
2759optnl           : '\n' optnl
2760                |
2761                ;
2762
2763ipspec          : ANY                           { $$ = NULL; }
2764                | xhost                         { $$ = $1; }
2765                | '{' optnl host_list '}'       { $$ = $3; }
2766                ;
2767
2768toipspec        : TO ipspec                     { $$ = $2; }
2769                | /* empty */                   { $$ = NULL; }
2770                ;
2771
2772host_list       : ipspec optnl                  { $$ = $1; }
2773                | host_list comma ipspec optnl  {
2774                        if ($3 == NULL)
2775                                $$ = $1;
2776                        else if ($1 == NULL)
2777                                $$ = $3;
2778                        else {
2779                                $1->tail->next = $3;
2780                                $1->tail = $3->tail;
2781                                $$ = $1;
2782                        }
2783                }
2784                ;
2785
2786xhost           : not host                      {
2787                        struct node_host        *n;
2788
2789                        for (n = $2; n != NULL; n = n->next)
2790                                n->not = $1;
2791                        $$ = $2;
2792                }
2793                | not NOROUTE                   {
2794                        $$ = calloc(1, sizeof(struct node_host));
2795                        if ($$ == NULL)
2796                                err(1, "xhost: calloc");
2797                        $$->addr.type = PF_ADDR_NOROUTE;
2798                        $$->next = NULL;
2799                        $$->not = $1;
2800                        $$->tail = $$;
2801                }
2802                | not URPFFAILED                {
2803                        $$ = calloc(1, sizeof(struct node_host));
2804                        if ($$ == NULL)
2805                                err(1, "xhost: calloc");
2806                        $$->addr.type = PF_ADDR_URPFFAILED;
2807                        $$->next = NULL;
2808                        $$->not = $1;
2809                        $$->tail = $$;
2810                }
2811                ;
2812
2813host            : STRING                        {
2814                        if (($$ = host($1)) == NULL)    {
2815                                /* error. "any" is handled elsewhere */
2816                                free($1);
2817                                yyerror("could not parse host specification");
2818                                YYERROR;
2819                        }
2820                        free($1);
2821
2822                }
2823                | STRING '-' STRING             {
2824                        struct node_host *b, *e;
2825
2826                        if ((b = host($1)) == NULL || (e = host($3)) == NULL) {
2827                                free($1);
2828                                free($3);
2829                                yyerror("could not parse host specification");
2830                                YYERROR;
2831                        }
2832                        if (b->af != e->af ||
2833                            b->addr.type != PF_ADDR_ADDRMASK ||
2834                            e->addr.type != PF_ADDR_ADDRMASK ||
2835                            unmask(&b->addr.v.a.mask, b->af) !=
2836                            (b->af == AF_INET ? 32 : 128) ||
2837                            unmask(&e->addr.v.a.mask, e->af) !=
2838                            (e->af == AF_INET ? 32 : 128) ||
2839                            b->next != NULL || b->not ||
2840                            e->next != NULL || e->not) {
2841                                free(b);
2842                                free(e);
2843                                free($1);
2844                                free($3);
2845                                yyerror("invalid address range");
2846                                YYERROR;
2847                        }
2848                        memcpy(&b->addr.v.a.mask, &e->addr.v.a.addr,
2849                            sizeof(b->addr.v.a.mask));
2850                        b->addr.type = PF_ADDR_RANGE;
2851                        $$ = b;
2852                        free(e);
2853                        free($1);
2854                        free($3);
2855                }
2856                | STRING '/' NUMBER             {
2857                        char    *buf;
2858
2859                        if (asprintf(&buf, "%s/%lld", $1, (long long)$3) == -1)
2860                                err(1, "host: asprintf");
2861                        free($1);
2862                        if (($$ = host(buf)) == NULL)   {
2863                                /* error. "any" is handled elsewhere */
2864                                free(buf);
2865                                yyerror("could not parse host specification");
2866                                YYERROR;
2867                        }
2868                        free(buf);
2869                }
2870                | NUMBER '/' NUMBER             {
2871                        char    *buf;
2872
2873                        /* ie. for 10/8 parsing */
2874#ifdef __FreeBSD__
2875                        if (asprintf(&buf, "%lld/%lld", (long long)$1, (long long)$3) == -1)
2876#else
2877                        if (asprintf(&buf, "%lld/%lld", $1, $3) == -1)
2878#endif
2879                                err(1, "host: asprintf");
2880                        if (($$ = host(buf)) == NULL)   {
2881                                /* error. "any" is handled elsewhere */
2882                                free(buf);
2883                                yyerror("could not parse host specification");
2884                                YYERROR;
2885                        }
2886                        free(buf);
2887                }
2888                | dynaddr
2889                | dynaddr '/' NUMBER            {
2890                        struct node_host        *n;
2891
2892                        if ($3 < 0 || $3 > 128) {
2893                                yyerror("bit number too big");
2894                                YYERROR;
2895                        }
2896                        $$ = $1;
2897                        for (n = $1; n != NULL; n = n->next)
2898                                set_ipmask(n, $3);
2899                }
2900                | '<' STRING '>'        {
2901                        if (strlen($2) >= PF_TABLE_NAME_SIZE) {
2902                                yyerror("table name '%s' too long", $2);
2903                                free($2);
2904                                YYERROR;
2905                        }
2906                        $$ = calloc(1, sizeof(struct node_host));
2907                        if ($$ == NULL)
2908                                err(1, "host: calloc");
2909                        $$->addr.type = PF_ADDR_TABLE;
2910                        if (strlcpy($$->addr.v.tblname, $2,
2911                            sizeof($$->addr.v.tblname)) >=
2912                            sizeof($$->addr.v.tblname))
2913                                errx(1, "host: strlcpy");
2914                        free($2);
2915                        $$->next = NULL;
2916                        $$->tail = $$;
2917                }
2918                | ROUTE STRING          {
2919                        $$ = calloc(1, sizeof(struct node_host));
2920                        if ($$ == NULL) {
2921                                free($2);
2922                                err(1, "host: calloc");
2923                        }
2924                        $$->addr.type = PF_ADDR_RTLABEL;
2925                        if (strlcpy($$->addr.v.rtlabelname, $2,
2926                            sizeof($$->addr.v.rtlabelname)) >=
2927                            sizeof($$->addr.v.rtlabelname)) {
2928                                yyerror("route label too long, max %u chars",
2929                                    sizeof($$->addr.v.rtlabelname) - 1);
2930                                free($2);
2931                                free($$);
2932                                YYERROR;
2933                        }
2934                        $$->next = NULL;
2935                        $$->tail = $$;
2936                        free($2);
2937                }
2938                ;
2939
2940number          : NUMBER
2941                | STRING                {
2942                        u_long  ulval;
2943
2944                        if (atoul($1, &ulval) == -1) {
2945                                yyerror("%s is not a number", $1);
2946                                free($1);
2947                                YYERROR;
2948                        } else
2949                                $$ = ulval;
2950                        free($1);
2951                }
2952                ;
2953
2954dynaddr         : '(' STRING ')'                {
2955                        int      flags = 0;
2956                        char    *p, *op;
2957
2958                        op = $2;
2959                        if (!isalpha(op[0])) {
2960                                yyerror("invalid interface name '%s'", op);
2961                                free(op);
2962                                YYERROR;
2963                        }
2964                        while ((p = strrchr($2, ':')) != NULL) {
2965                                if (!strcmp(p+1, "network"))
2966                                        flags |= PFI_AFLAG_NETWORK;
2967                                else if (!strcmp(p+1, "broadcast"))
2968                                        flags |= PFI_AFLAG_BROADCAST;
2969                                else if (!strcmp(p+1, "peer"))
2970                                        flags |= PFI_AFLAG_PEER;
2971                                else if (!strcmp(p+1, "0"))
2972                                        flags |= PFI_AFLAG_NOALIAS;
2973                                else {
2974                                        yyerror("interface %s has bad modifier",
2975                                            $2);
2976                                        free(op);
2977                                        YYERROR;
2978                                }
2979                                *p = '\0';
2980                        }
2981                        if (flags & (flags - 1) & PFI_AFLAG_MODEMASK) {
2982                                free(op);
2983                                yyerror("illegal combination of "
2984                                    "interface modifiers");
2985                                YYERROR;
2986                        }
2987                        $$ = calloc(1, sizeof(struct node_host));
2988                        if ($$ == NULL)
2989                                err(1, "address: calloc");
2990                        $$->af = 0;
2991                        set_ipmask($$, 128);
2992                        $$->addr.type = PF_ADDR_DYNIFTL;
2993                        $$->addr.iflags = flags;
2994                        if (strlcpy($$->addr.v.ifname, $2,
2995                            sizeof($$->addr.v.ifname)) >=
2996                            sizeof($$->addr.v.ifname)) {
2997                                free(op);
2998                                free($$);
2999                                yyerror("interface name too long");
3000                                YYERROR;
3001                        }
3002                        free(op);
3003                        $$->next = NULL;
3004                        $$->tail = $$;
3005                }
3006                ;
3007
3008portspec        : port_item                     { $$ = $1; }
3009                | '{' optnl port_list '}'       { $$ = $3; }
3010                ;
3011
3012port_list       : port_item optnl               { $$ = $1; }
3013                | port_list comma port_item optnl       {
3014                        $1->tail->next = $3;
3015                        $1->tail = $3;
3016                        $$ = $1;
3017                }
3018                ;
3019
3020port_item       : portrange                     {
3021                        $$ = calloc(1, sizeof(struct node_port));
3022                        if ($$ == NULL)
3023                                err(1, "port_item: calloc");
3024                        $$->port[0] = $1.a;
3025                        $$->port[1] = $1.b;
3026                        if ($1.t)
3027                                $$->op = PF_OP_RRG;
3028                        else
3029                                $$->op = PF_OP_EQ;
3030                        $$->next = NULL;
3031                        $$->tail = $$;
3032                }
3033                | unaryop portrange     {
3034                        if ($2.t) {
3035                                yyerror("':' cannot be used with an other "
3036                                    "port operator");
3037                                YYERROR;
3038                        }
3039                        $$ = calloc(1, sizeof(struct node_port));
3040                        if ($$ == NULL)
3041                                err(1, "port_item: calloc");
3042                        $$->port[0] = $2.a;
3043                        $$->port[1] = $2.b;
3044                        $$->op = $1;
3045                        $$->next = NULL;
3046                        $$->tail = $$;
3047                }
3048                | portrange PORTBINARY portrange        {
3049                        if ($1.t || $3.t) {
3050                                yyerror("':' cannot be used with an other "
3051                                    "port operator");
3052                                YYERROR;
3053                        }
3054                        $$ = calloc(1, sizeof(struct node_port));
3055                        if ($$ == NULL)
3056                                err(1, "port_item: calloc");
3057                        $$->port[0] = $1.a;
3058                        $$->port[1] = $3.a;
3059                        $$->op = $2;
3060                        $$->next = NULL;
3061                        $$->tail = $$;
3062                }
3063                ;
3064
3065portplain       : numberstring                  {
3066                        if (parseport($1, &$$, 0) == -1) {
3067                                free($1);
3068                                YYERROR;
3069                        }
3070                        free($1);
3071                }
3072                ;
3073
3074portrange       : numberstring                  {
3075                        if (parseport($1, &$$, PPORT_RANGE) == -1) {
3076                                free($1);
3077                                YYERROR;
3078                        }
3079                        free($1);
3080                }
3081                ;
3082
3083uids            : uid_item                      { $$ = $1; }
3084                | '{' optnl uid_list '}'        { $$ = $3; }
3085                ;
3086
3087uid_list        : uid_item optnl                { $$ = $1; }
3088                | uid_list comma uid_item optnl {
3089                        $1->tail->next = $3;
3090                        $1->tail = $3;
3091                        $$ = $1;
3092                }
3093                ;
3094
3095uid_item        : uid                           {
3096                        $$ = calloc(1, sizeof(struct node_uid));
3097                        if ($$ == NULL)
3098                                err(1, "uid_item: calloc");
3099                        $$->uid[0] = $1;
3100                        $$->uid[1] = $1;
3101                        $$->op = PF_OP_EQ;
3102                        $$->next = NULL;
3103                        $$->tail = $$;
3104                }
3105                | unaryop uid                   {
3106                        if ($2 == UID_MAX && $1 != PF_OP_EQ && $1 != PF_OP_NE) {
3107                                yyerror("user unknown requires operator = or "
3108                                    "!=");
3109                                YYERROR;
3110                        }
3111                        $$ = calloc(1, sizeof(struct node_uid));
3112                        if ($$ == NULL)
3113                                err(1, "uid_item: calloc");
3114                        $$->uid[0] = $2;
3115                        $$->uid[1] = $2;
3116                        $$->op = $1;
3117                        $$->next = NULL;
3118                        $$->tail = $$;
3119                }
3120                | uid PORTBINARY uid            {
3121                        if ($1 == UID_MAX || $3 == UID_MAX) {
3122                                yyerror("user unknown requires operator = or "
3123                                    "!=");
3124                                YYERROR;
3125                        }
3126                        $$ = calloc(1, sizeof(struct node_uid));
3127                        if ($$ == NULL)
3128                                err(1, "uid_item: calloc");
3129                        $$->uid[0] = $1;
3130                        $$->uid[1] = $3;
3131                        $$->op = $2;
3132                        $$->next = NULL;
3133                        $$->tail = $$;
3134                }
3135                ;
3136
3137uid             : STRING                        {
3138                        if (!strcmp($1, "unknown"))
3139                                $$ = UID_MAX;
3140                        else {
3141                                struct passwd   *pw;
3142
3143                                if ((pw = getpwnam($1)) == NULL) {
3144                                        yyerror("unknown user %s", $1);
3145                                        free($1);
3146                                        YYERROR;
3147                                }
3148                                $$ = pw->pw_uid;
3149                        }
3150                        free($1);
3151                }
3152                | NUMBER                        {
3153                        if ($1 < 0 || $1 >= UID_MAX) {
3154                                yyerror("illegal uid value %lu", $1);
3155                                YYERROR;
3156                        }
3157                        $$ = $1;
3158                }
3159                ;
3160
3161gids            : gid_item                      { $$ = $1; }
3162                | '{' optnl gid_list '}'        { $$ = $3; }
3163                ;
3164
3165gid_list        : gid_item optnl                { $$ = $1; }
3166                | gid_list comma gid_item optnl {
3167                        $1->tail->next = $3;
3168                        $1->tail = $3;
3169                        $$ = $1;
3170                }
3171                ;
3172
3173gid_item        : gid                           {
3174                        $$ = calloc(1, sizeof(struct node_gid));
3175                        if ($$ == NULL)
3176                                err(1, "gid_item: calloc");
3177                        $$->gid[0] = $1;
3178                        $$->gid[1] = $1;
3179                        $$->op = PF_OP_EQ;
3180                        $$->next = NULL;
3181                        $$->tail = $$;
3182                }
3183                | unaryop gid                   {
3184                        if ($2 == GID_MAX && $1 != PF_OP_EQ && $1 != PF_OP_NE) {
3185                                yyerror("group unknown requires operator = or "
3186                                    "!=");
3187                                YYERROR;
3188                        }
3189                        $$ = calloc(1, sizeof(struct node_gid));
3190                        if ($$ == NULL)
3191                                err(1, "gid_item: calloc");
3192                        $$->gid[0] = $2;
3193                        $$->gid[1] = $2;
3194                        $$->op = $1;
3195                        $$->next = NULL;
3196                        $$->tail = $$;
3197                }
3198                | gid PORTBINARY gid            {
3199                        if ($1 == GID_MAX || $3 == GID_MAX) {
3200                                yyerror("group unknown requires operator = or "
3201                                    "!=");
3202                                YYERROR;
3203                        }
3204                        $$ = calloc(1, sizeof(struct node_gid));
3205                        if ($$ == NULL)
3206                                err(1, "gid_item: calloc");
3207                        $$->gid[0] = $1;
3208                        $$->gid[1] = $3;
3209                        $$->op = $2;
3210                        $$->next = NULL;
3211                        $$->tail = $$;
3212                }
3213                ;
3214
3215gid             : STRING                        {
3216                        if (!strcmp($1, "unknown"))
3217                                $$ = GID_MAX;
3218                        else {
3219                                struct group    *grp;
3220
3221                                if ((grp = getgrnam($1)) == NULL) {
3222                                        yyerror("unknown group %s", $1);
3223                                        free($1);
3224                                        YYERROR;
3225                                }
3226                                $$ = grp->gr_gid;
3227                        }
3228                        free($1);
3229                }
3230                | NUMBER                        {
3231                        if ($1 < 0 || $1 >= GID_MAX) {
3232                                yyerror("illegal gid value %lu", $1);
3233                                YYERROR;
3234                        }
3235                        $$ = $1;
3236                }
3237                ;
3238
3239flag            : STRING                        {
3240                        int     f;
3241
3242                        if ((f = parse_flags($1)) < 0) {
3243                                yyerror("bad flags %s", $1);
3244                                free($1);
3245                                YYERROR;
3246                        }
3247                        free($1);
3248                        $$.b1 = f;
3249                }
3250                ;
3251
3252flags           : FLAGS flag '/' flag   { $$.b1 = $2.b1; $$.b2 = $4.b1; }
3253                | FLAGS '/' flag        { $$.b1 = 0; $$.b2 = $3.b1; }
3254                | FLAGS ANY             { $$.b1 = 0; $$.b2 = 0; }
3255                ;
3256
3257icmpspec        : ICMPTYPE icmp_item                    { $$ = $2; }
3258                | ICMPTYPE '{' optnl icmp_list '}'      { $$ = $4; }
3259                | ICMP6TYPE icmp6_item                  { $$ = $2; }
3260                | ICMP6TYPE '{' optnl icmp6_list '}'    { $$ = $4; }
3261                ;
3262
3263icmp_list       : icmp_item optnl               { $$ = $1; }
3264                | icmp_list comma icmp_item optnl {
3265                        $1->tail->next = $3;
3266                        $1->tail = $3;
3267                        $$ = $1;
3268                }
3269                ;
3270
3271icmp6_list      : icmp6_item optnl              { $$ = $1; }
3272                | icmp6_list comma icmp6_item optnl {
3273                        $1->tail->next = $3;
3274                        $1->tail = $3;
3275                        $$ = $1;
3276                }
3277                ;
3278
3279icmp_item       : icmptype              {
3280                        $$ = calloc(1, sizeof(struct node_icmp));
3281                        if ($$ == NULL)
3282                                err(1, "icmp_item: calloc");
3283                        $$->type = $1;
3284                        $$->code = 0;
3285                        $$->proto = IPPROTO_ICMP;
3286                        $$->next = NULL;
3287                        $$->tail = $$;
3288                }
3289                | icmptype CODE STRING  {
3290                        const struct icmpcodeent        *p;
3291
3292                        if ((p = geticmpcodebyname($1-1, $3, AF_INET)) == NULL) {
3293                                yyerror("unknown icmp-code %s", $3);
3294                                free($3);
3295                                YYERROR;
3296                        }
3297
3298                        free($3);
3299                        $$ = calloc(1, sizeof(struct node_icmp));
3300                        if ($$ == NULL)
3301                                err(1, "icmp_item: calloc");
3302                        $$->type = $1;
3303                        $$->code = p->code + 1;
3304                        $$->proto = IPPROTO_ICMP;
3305                        $$->next = NULL;
3306                        $$->tail = $$;
3307                }
3308                | icmptype CODE NUMBER  {
3309                        if ($3 < 0 || $3 > 255) {
3310                                yyerror("illegal icmp-code %lu", $3);
3311                                YYERROR;
3312                        }
3313                        $$ = calloc(1, sizeof(struct node_icmp));
3314                        if ($$ == NULL)
3315                                err(1, "icmp_item: calloc");
3316                        $$->type = $1;
3317                        $$->code = $3 + 1;
3318                        $$->proto = IPPROTO_ICMP;
3319                        $$->next = NULL;
3320                        $$->tail = $$;
3321                }
3322                ;
3323
3324icmp6_item      : icmp6type             {
3325                        $$ = calloc(1, sizeof(struct node_icmp));
3326                        if ($$ == NULL)
3327                                err(1, "icmp_item: calloc");
3328                        $$->type = $1;
3329                        $$->code = 0;
3330                        $$->proto = IPPROTO_ICMPV6;
3331                        $$->next = NULL;
3332                        $$->tail = $$;
3333                }
3334                | icmp6type CODE STRING {
3335                        const struct icmpcodeent        *p;
3336
3337                        if ((p = geticmpcodebyname($1-1, $3, AF_INET6)) == NULL) {
3338                                yyerror("unknown icmp6-code %s", $3);
3339                                free($3);
3340                                YYERROR;
3341                        }
3342                        free($3);
3343
3344                        $$ = calloc(1, sizeof(struct node_icmp));
3345                        if ($$ == NULL)
3346                                err(1, "icmp_item: calloc");
3347                        $$->type = $1;
3348                        $$->code = p->code + 1;
3349                        $$->proto = IPPROTO_ICMPV6;
3350                        $$->next = NULL;
3351                        $$->tail = $$;
3352                }
3353                | icmp6type CODE NUMBER {
3354                        if ($3 < 0 || $3 > 255) {
3355                                yyerror("illegal icmp-code %lu", $3);
3356                                YYERROR;
3357                        }
3358                        $$ = calloc(1, sizeof(struct node_icmp));
3359                        if ($$ == NULL)
3360                                err(1, "icmp_item: calloc");
3361                        $$->type = $1;
3362                        $$->code = $3 + 1;
3363                        $$->proto = IPPROTO_ICMPV6;
3364                        $$->next = NULL;
3365                        $$->tail = $$;
3366                }
3367                ;
3368
3369icmptype        : STRING                        {
3370                        const struct icmptypeent        *p;
3371
3372                        if ((p = geticmptypebyname($1, AF_INET)) == NULL) {
3373                                yyerror("unknown icmp-type %s", $1);
3374                                free($1);
3375                                YYERROR;
3376                        }
3377                        $$ = p->type + 1;
3378                        free($1);
3379                }
3380                | NUMBER                        {
3381                        if ($1 < 0 || $1 > 255) {
3382                                yyerror("illegal icmp-type %lu", $1);
3383                                YYERROR;
3384                        }
3385                        $$ = $1 + 1;
3386                }
3387                ;
3388
3389icmp6type       : STRING                        {
3390                        const struct icmptypeent        *p;
3391
3392                        if ((p = geticmptypebyname($1, AF_INET6)) ==
3393                            NULL) {
3394                                yyerror("unknown icmp6-type %s", $1);
3395                                free($1);
3396                                YYERROR;
3397                        }
3398                        $$ = p->type + 1;
3399                        free($1);
3400                }
3401                | NUMBER                        {
3402                        if ($1 < 0 || $1 > 255) {
3403                                yyerror("illegal icmp6-type %lu", $1);
3404                                YYERROR;
3405                        }
3406                        $$ = $1 + 1;
3407                }
3408                ;
3409
3410tos     : STRING                        {
3411                        if (!strcmp($1, "lowdelay"))
3412                                $$ = IPTOS_LOWDELAY;
3413                        else if (!strcmp($1, "throughput"))
3414                                $$ = IPTOS_THROUGHPUT;
3415                        else if (!strcmp($1, "reliability"))
3416                                $$ = IPTOS_RELIABILITY;
3417                        else if ($1[0] == '0' && $1[1] == 'x')
3418                                $$ = strtoul($1, NULL, 16);
3419                        else
3420                                $$ = 0;         /* flag bad argument */
3421                        if (!$$ || $$ > 255) {
3422                                yyerror("illegal tos value %s", $1);
3423                                free($1);
3424                                YYERROR;
3425                        }
3426                        free($1);
3427                }
3428                | NUMBER                        {
3429                        $$ = $1;
3430                        if (!$$ || $$ > 255) {
3431                                yyerror("illegal tos value %s", $1);
3432                                YYERROR;
3433                        }
3434                }
3435                ;
3436
3437sourcetrack     : SOURCETRACK           { $$ = PF_SRCTRACK; }
3438                | SOURCETRACK GLOBAL    { $$ = PF_SRCTRACK_GLOBAL; }
3439                | SOURCETRACK RULE      { $$ = PF_SRCTRACK_RULE; }
3440                ;
3441
3442statelock       : IFBOUND {
3443                        $$ = PFRULE_IFBOUND;
3444                }
3445                | FLOATING {
3446                        $$ = 0;
3447                }
3448                ;
3449
3450keep            : NO STATE                      {
3451                        $$.action = 0;
3452                        $$.options = NULL;
3453                }
3454                | KEEP STATE state_opt_spec     {
3455                        $$.action = PF_STATE_NORMAL;
3456                        $$.options = $3;
3457                }
3458                | MODULATE STATE state_opt_spec {
3459                        $$.action = PF_STATE_MODULATE;
3460                        $$.options = $3;
3461                }
3462                | SYNPROXY STATE state_opt_spec {
3463                        $$.action = PF_STATE_SYNPROXY;
3464                        $$.options = $3;
3465                }
3466                ;
3467
3468flush           : /* empty */                   { $$ = 0; }
3469                | FLUSH                         { $$ = PF_FLUSH; }
3470                | FLUSH GLOBAL                  {
3471                        $$ = PF_FLUSH | PF_FLUSH_GLOBAL;
3472                }
3473                ;
3474
3475state_opt_spec  : '(' state_opt_list ')'        { $$ = $2; }
3476                | /* empty */                   { $$ = NULL; }
3477                ;
3478
3479state_opt_list  : state_opt_item                { $$ = $1; }
3480                | state_opt_list comma state_opt_item {
3481                        $1->tail->next = $3;
3482                        $1->tail = $3;
3483                        $$ = $1;
3484                }
3485                ;
3486
3487state_opt_item  : MAXIMUM NUMBER                {
3488                        if ($2 < 0 || $2 > UINT_MAX) {
3489                                yyerror("only positive values permitted");
3490                                YYERROR;
3491                        }
3492                        $$ = calloc(1, sizeof(struct node_state_opt));
3493                        if ($$ == NULL)
3494                                err(1, "state_opt_item: calloc");
3495                        $$->type = PF_STATE_OPT_MAX;
3496                        $$->data.max_states = $2;
3497                        $$->next = NULL;
3498                        $$->tail = $$;
3499                }
3500                | NOSYNC                                {
3501                        $$ = calloc(1, sizeof(struct node_state_opt));
3502                        if ($$ == NULL)
3503                                err(1, "state_opt_item: calloc");
3504                        $$->type = PF_STATE_OPT_NOSYNC;
3505                        $$->next = NULL;
3506                        $$->tail = $$;
3507                }
3508                | MAXSRCSTATES NUMBER                   {
3509                        if ($2 < 0 || $2 > UINT_MAX) {
3510                                yyerror("only positive values permitted");
3511                                YYERROR;
3512                        }
3513                        $$ = calloc(1, sizeof(struct node_state_opt));
3514                        if ($$ == NULL)
3515                                err(1, "state_opt_item: calloc");
3516                        $$->type = PF_STATE_OPT_MAX_SRC_STATES;
3517                        $$->data.max_src_states = $2;
3518                        $$->next = NULL;
3519                        $$->tail = $$;
3520                }
3521                | MAXSRCCONN NUMBER                     {
3522                        if ($2 < 0 || $2 > UINT_MAX) {
3523                                yyerror("only positive values permitted");
3524                                YYERROR;
3525                        }
3526                        $$ = calloc(1, sizeof(struct node_state_opt));
3527                        if ($$ == NULL)
3528                                err(1, "state_opt_item: calloc");
3529                        $$->type = PF_STATE_OPT_MAX_SRC_CONN;
3530                        $$->data.max_src_conn = $2;
3531                        $$->next = NULL;
3532                        $$->tail = $$;
3533                }
3534                | MAXSRCCONNRATE NUMBER '/' NUMBER      {
3535                        if ($2 < 0 || $2 > UINT_MAX ||
3536                            $4 < 0 || $4 > UINT_MAX) {
3537                                yyerror("only positive values permitted");
3538                                YYERROR;
3539                        }
3540                        $$ = calloc(1, sizeof(struct node_state_opt));
3541                        if ($$ == NULL)
3542                                err(1, "state_opt_item: calloc");
3543                        $$->type = PF_STATE_OPT_MAX_SRC_CONN_RATE;
3544                        $$->data.max_src_conn_rate.limit = $2;
3545                        $$->data.max_src_conn_rate.seconds = $4;
3546                        $$->next = NULL;
3547                        $$->tail = $$;
3548                }
3549                | OVERLOAD '<' STRING '>' flush         {
3550                        if (strlen($3) >= PF_TABLE_NAME_SIZE) {
3551                                yyerror("table name '%s' too long", $3);
3552                                free($3);
3553                                YYERROR;
3554                        }
3555                        $$ = calloc(1, sizeof(struct node_state_opt));
3556                        if ($$ == NULL)
3557                                err(1, "state_opt_item: calloc");
3558                        if (strlcpy($$->data.overload.tblname, $3,
3559                            PF_TABLE_NAME_SIZE) >= PF_TABLE_NAME_SIZE)
3560                                errx(1, "state_opt_item: strlcpy");
3561                        free($3);
3562                        $$->type = PF_STATE_OPT_OVERLOAD;
3563                        $$->data.overload.flush = $5;
3564                        $$->next = NULL;
3565                        $$->tail = $$;
3566                }
3567                | MAXSRCNODES NUMBER                    {
3568                        if ($2 < 0 || $2 > UINT_MAX) {
3569                                yyerror("only positive values permitted");
3570                                YYERROR;
3571                        }
3572                        $$ = calloc(1, sizeof(struct node_state_opt));
3573                        if ($$ == NULL)
3574                                err(1, "state_opt_item: calloc");
3575                        $$->type = PF_STATE_OPT_MAX_SRC_NODES;
3576                        $$->data.max_src_nodes = $2;
3577                        $$->next = NULL;
3578                        $$->tail = $$;
3579                }
3580                | sourcetrack {
3581                        $$ = calloc(1, sizeof(struct node_state_opt));
3582                        if ($$ == NULL)
3583                                err(1, "state_opt_item: calloc");
3584                        $$->type = PF_STATE_OPT_SRCTRACK;
3585                        $$->data.src_track = $1;
3586                        $$->next = NULL;
3587                        $$->tail = $$;
3588                }
3589                | statelock {
3590                        $$ = calloc(1, sizeof(struct node_state_opt));
3591                        if ($$ == NULL)
3592                                err(1, "state_opt_item: calloc");
3593                        $$->type = PF_STATE_OPT_STATELOCK;
3594                        $$->data.statelock = $1;
3595                        $$->next = NULL;
3596                        $$->tail = $$;
3597                }
3598                | SLOPPY {
3599                        $$ = calloc(1, sizeof(struct node_state_opt));
3600                        if ($$ == NULL)
3601                                err(1, "state_opt_item: calloc");
3602                        $$->type = PF_STATE_OPT_SLOPPY;
3603                        $$->next = NULL;
3604                        $$->tail = $$;
3605                }
3606                | PFLOW {
3607                        $$ = calloc(1, sizeof(struct node_state_opt));
3608                        if ($$ == NULL)
3609                                err(1, "state_opt_item: calloc");
3610                        $$->type = PF_STATE_OPT_PFLOW;
3611                        $$->next = NULL;
3612                        $$->tail = $$;
3613                }
3614                | STRING NUMBER                 {
3615                        int     i;
3616
3617                        if ($2 < 0 || $2 > UINT_MAX) {
3618                                yyerror("only positive values permitted");
3619                                YYERROR;
3620                        }
3621                        for (i = 0; pf_timeouts[i].name &&
3622                            strcmp(pf_timeouts[i].name, $1); ++i)
3623                                ;       /* nothing */
3624                        if (!pf_timeouts[i].name) {
3625                                yyerror("illegal timeout name %s", $1);
3626                                free($1);
3627                                YYERROR;
3628                        }
3629                        if (strchr(pf_timeouts[i].name, '.') == NULL) {
3630                                yyerror("illegal state timeout %s", $1);
3631                                free($1);
3632                                YYERROR;
3633                        }
3634                        free($1);
3635                        $$ = calloc(1, sizeof(struct node_state_opt));
3636                        if ($$ == NULL)
3637                                err(1, "state_opt_item: calloc");
3638                        $$->type = PF_STATE_OPT_TIMEOUT;
3639                        $$->data.timeout.number = pf_timeouts[i].timeout;
3640                        $$->data.timeout.seconds = $2;
3641                        $$->next = NULL;
3642                        $$->tail = $$;
3643                }
3644                ;
3645
3646label           : LABEL STRING                  {
3647                        $$ = $2;
3648                }
3649                ;
3650
3651qname           : QUEUE STRING                          {
3652                        $$.qname = $2;
3653                        $$.pqname = NULL;
3654                }
3655                | QUEUE '(' STRING ')'                  {
3656                        $$.qname = $3;
3657                        $$.pqname = NULL;
3658                }
3659                | QUEUE '(' STRING comma STRING ')'     {
3660                        $$.qname = $3;
3661                        $$.pqname = $5;
3662                }
3663                ;
3664
3665no              : /* empty */                   { $$ = 0; }
3666                | NO                            { $$ = 1; }
3667                ;
3668
3669portstar        : numberstring                  {
3670                        if (parseport($1, &$$, PPORT_RANGE|PPORT_STAR) == -1) {
3671                                free($1);
3672                                YYERROR;
3673                        }
3674                        free($1);
3675                }
3676                ;
3677
3678redirspec       : host                          { $$ = $1; }
3679                | '{' optnl redir_host_list '}' { $$ = $3; }
3680                ;
3681
3682redir_host_list : host optnl                    { $$ = $1; }
3683                | redir_host_list comma host optnl {
3684                        $1->tail->next = $3;
3685                        $1->tail = $3->tail;
3686                        $$ = $1;
3687                }
3688                ;
3689
3690redirpool       : /* empty */                   { $$ = NULL; }
3691                | ARROW redirspec               {
3692                        $$ = calloc(1, sizeof(struct redirection));
3693                        if ($$ == NULL)
3694                                err(1, "redirection: calloc");
3695                        $$->host = $2;
3696                        $$->rport.a = $$->rport.b = $$->rport.t = 0;
3697                }
3698                | ARROW redirspec PORT portstar {
3699                        $$ = calloc(1, sizeof(struct redirection));
3700                        if ($$ == NULL)
3701                                err(1, "redirection: calloc");
3702                        $$->host = $2;
3703                        $$->rport = $4;
3704                }
3705                ;
3706
3707hashkey         : /* empty */
3708                {
3709                        $$ = calloc(1, sizeof(struct pf_poolhashkey));
3710                        if ($$ == NULL)
3711                                err(1, "hashkey: calloc");
3712                        $$->key32[0] = arc4random();
3713                        $$->key32[1] = arc4random();
3714                        $$->key32[2] = arc4random();
3715                        $$->key32[3] = arc4random();
3716                }
3717                | string
3718                {
3719                        if (!strncmp($1, "0x", 2)) {
3720                                if (strlen($1) != 34) {
3721                                        free($1);
3722                                        yyerror("hex key must be 128 bits "
3723                                                "(32 hex digits) long");
3724                                        YYERROR;
3725                                }
3726                                $$ = calloc(1, sizeof(struct pf_poolhashkey));
3727                                if ($$ == NULL)
3728                                        err(1, "hashkey: calloc");
3729
3730                                if (sscanf($1, "0x%8x%8x%8x%8x",
3731                                    &$$->key32[0], &$$->key32[1],
3732                                    &$$->key32[2], &$$->key32[3]) != 4) {
3733                                        free($$);
3734                                        free($1);
3735                                        yyerror("invalid hex key");
3736                                        YYERROR;
3737                                }
3738                        } else {
3739                                MD5_CTX context;
3740
3741                                $$ = calloc(1, sizeof(struct pf_poolhashkey));
3742                                if ($$ == NULL)
3743                                        err(1, "hashkey: calloc");
3744                                MD5Init(&context);
3745                                MD5Update(&context, (unsigned char *)$1,
3746                                    strlen($1));
3747                                MD5Final((unsigned char *)$$, &context);
3748                                HTONL($$->key32[0]);
3749                                HTONL($$->key32[1]);
3750                                HTONL($$->key32[2]);
3751                                HTONL($$->key32[3]);
3752                        }
3753                        free($1);
3754                }
3755                ;
3756
3757pool_opts       :       { bzero(&pool_opts, sizeof pool_opts); }
3758                    pool_opts_l
3759                        { $$ = pool_opts; }
3760                | /* empty */   {
3761                        bzero(&pool_opts, sizeof pool_opts);
3762                        $$ = pool_opts;
3763                }
3764                ;
3765
3766pool_opts_l     : pool_opts_l pool_opt
3767                | pool_opt
3768                ;
3769
3770pool_opt        : BITMASK       {
3771                        if (pool_opts.type) {
3772                                yyerror("pool type cannot be redefined");
3773                                YYERROR;
3774                        }
3775                        pool_opts.type =  PF_POOL_BITMASK;
3776                }
3777                | RANDOM        {
3778                        if (pool_opts.type) {
3779                                yyerror("pool type cannot be redefined");
3780                                YYERROR;
3781                        }
3782                        pool_opts.type = PF_POOL_RANDOM;
3783                }
3784                | SOURCEHASH hashkey {
3785                        if (pool_opts.type) {
3786                                yyerror("pool type cannot be redefined");
3787                                YYERROR;
3788                        }
3789                        pool_opts.type = PF_POOL_SRCHASH;
3790                        pool_opts.key = $2;
3791                }
3792                | ROUNDROBIN    {
3793                        if (pool_opts.type) {
3794                                yyerror("pool type cannot be redefined");
3795                                YYERROR;
3796                        }
3797                        pool_opts.type = PF_POOL_ROUNDROBIN;
3798                }
3799                | STATICPORT    {
3800                        if (pool_opts.staticport) {
3801                                yyerror("static-port cannot be redefined");
3802                                YYERROR;
3803                        }
3804                        pool_opts.staticport = 1;
3805                }
3806                | STICKYADDRESS {
3807                        if (filter_opts.marker & POM_STICKYADDRESS) {
3808                                yyerror("sticky-address cannot be redefined");
3809                                YYERROR;
3810                        }
3811                        pool_opts.marker |= POM_STICKYADDRESS;
3812                        pool_opts.opts |= PF_POOL_STICKYADDR;
3813                }
3814                ;
3815
3816redirection     : /* empty */                   { $$ = NULL; }
3817                | ARROW host                    {
3818                        $$ = calloc(1, sizeof(struct redirection));
3819                        if ($$ == NULL)
3820                                err(1, "redirection: calloc");
3821                        $$->host = $2;
3822                        $$->rport.a = $$->rport.b = $$->rport.t = 0;
3823                }
3824                | ARROW host PORT portstar      {
3825                        $$ = calloc(1, sizeof(struct redirection));
3826                        if ($$ == NULL)
3827                                err(1, "redirection: calloc");
3828                        $$->host = $2;
3829                        $$->rport = $4;
3830                }
3831                ;
3832
3833natpasslog      : /* empty */   { $$.b1 = $$.b2 = 0; $$.w2 = 0; }
3834                | PASS          { $$.b1 = 1; $$.b2 = 0; $$.w2 = 0; }
3835                | PASS log      { $$.b1 = 1; $$.b2 = $2.log; $$.w2 = $2.logif; }
3836                | log           { $$.b1 = 0; $$.b2 = $1.log; $$.w2 = $1.logif; }
3837                ;
3838
3839nataction       : no NAT natpasslog {
3840                        if ($1 && $3.b1) {
3841                                yyerror("\"pass\" not valid with \"no\"");
3842                                YYERROR;
3843                        }
3844                        if ($1)
3845                                $$.b1 = PF_NONAT;
3846                        else
3847                                $$.b1 = PF_NAT;
3848                        $$.b2 = $3.b1;
3849                        $$.w = $3.b2;
3850                        $$.w2 = $3.w2;
3851                }
3852                | no RDR natpasslog {
3853                        if ($1 && $3.b1) {
3854                                yyerror("\"pass\" not valid with \"no\"");
3855                                YYERROR;
3856                        }
3857                        if ($1)
3858                                $$.b1 = PF_NORDR;
3859                        else
3860                                $$.b1 = PF_RDR;
3861                        $$.b2 = $3.b1;
3862                        $$.w = $3.b2;
3863                        $$.w2 = $3.w2;
3864                }
3865                ;
3866
3867natrule         : nataction interface af proto fromto tag tagged rtable
3868                    redirpool pool_opts
3869                {
3870                        struct pf_rule  r;
3871
3872                        if (check_rulestate(PFCTL_STATE_NAT))
3873                                YYERROR;
3874
3875                        memset(&r, 0, sizeof(r));
3876
3877                        r.action = $1.b1;
3878                        r.natpass = $1.b2;
3879                        r.log = $1.w;
3880                        r.logif = $1.w2;
3881                        r.af = $3;
3882
3883                        if (!r.af) {
3884                                if ($5.src.host && $5.src.host->af &&
3885                                    !$5.src.host->ifindex)
3886                                        r.af = $5.src.host->af;
3887                                else if ($5.dst.host && $5.dst.host->af &&
3888                                    !$5.dst.host->ifindex)
3889                                        r.af = $5.dst.host->af;
3890                        }
3891
3892                        if ($6 != NULL)
3893                                if (strlcpy(r.tagname, $6, PF_TAG_NAME_SIZE) >=
3894                                    PF_TAG_NAME_SIZE) {
3895                                        yyerror("tag too long, max %u chars",
3896                                            PF_TAG_NAME_SIZE - 1);
3897                                        YYERROR;
3898                                }
3899
3900                        if ($7.name)
3901                                if (strlcpy(r.match_tagname, $7.name,
3902                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
3903                                        yyerror("tag too long, max %u chars",
3904                                            PF_TAG_NAME_SIZE - 1);
3905                                        YYERROR;
3906                                }
3907                        r.match_tag_not = $7.neg;
3908                        r.rtableid = $8;
3909
3910                        if (r.action == PF_NONAT || r.action == PF_NORDR) {
3911                                if ($9 != NULL) {
3912                                        yyerror("translation rule with 'no' "
3913                                            "does not need '->'");
3914                                        YYERROR;
3915                                }
3916                        } else {
3917                                if ($9 == NULL || $9->host == NULL) {
3918                                        yyerror("translation rule requires '-> "
3919                                            "address'");
3920                                        YYERROR;
3921                                }
3922                                if (!r.af && ! $9->host->ifindex)
3923                                        r.af = $9->host->af;
3924
3925                                remove_invalid_hosts(&$9->host, &r.af);
3926                                if (invalid_redirect($9->host, r.af))
3927                                        YYERROR;
3928                                if (check_netmask($9->host, r.af))
3929                                        YYERROR;
3930
3931                                r.rpool.proxy_port[0] = ntohs($9->rport.a);
3932
3933                                switch (r.action) {
3934                                case PF_RDR:
3935                                        if (!$9->rport.b && $9->rport.t &&
3936                                            $5.dst.port != NULL) {
3937                                                r.rpool.proxy_port[1] =
3938                                                    ntohs($9->rport.a) +
3939                                                    (ntohs(
3940                                                    $5.dst.port->port[1]) -
3941                                                    ntohs(
3942                                                    $5.dst.port->port[0]));
3943                                        } else
3944                                                r.rpool.proxy_port[1] =
3945                                                    ntohs($9->rport.b);
3946                                        break;
3947                                case PF_NAT:
3948                                        r.rpool.proxy_port[1] =
3949                                            ntohs($9->rport.b);
3950                                        if (!r.rpool.proxy_port[0] &&
3951                                            !r.rpool.proxy_port[1]) {
3952                                                r.rpool.proxy_port[0] =
3953                                                    PF_NAT_PROXY_PORT_LOW;
3954                                                r.rpool.proxy_port[1] =
3955                                                    PF_NAT_PROXY_PORT_HIGH;
3956                                        } else if (!r.rpool.proxy_port[1])
3957                                                r.rpool.proxy_port[1] =
3958                                                    r.rpool.proxy_port[0];
3959                                        break;
3960                                default:
3961                                        break;
3962                                }
3963
3964                                r.rpool.opts = $10.type;
3965                                if ((r.rpool.opts & PF_POOL_TYPEMASK) ==
3966                                    PF_POOL_NONE && ($9->host->next != NULL ||
3967                                    $9->host->addr.type == PF_ADDR_TABLE ||
3968                                    DYNIF_MULTIADDR($9->host->addr)))
3969                                        r.rpool.opts = PF_POOL_ROUNDROBIN;
3970                                if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
3971                                    PF_POOL_ROUNDROBIN &&
3972                                    disallow_table($9->host, "tables are only "
3973                                    "supported in round-robin redirection "
3974                                    "pools"))
3975                                        YYERROR;
3976                                if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
3977                                    PF_POOL_ROUNDROBIN &&
3978                                    disallow_alias($9->host, "interface (%s) "
3979                                    "is only supported in round-robin "
3980                                    "redirection pools"))
3981                                        YYERROR;
3982                                if ($9->host->next != NULL) {
3983                                        if ((r.rpool.opts & PF_POOL_TYPEMASK) !=
3984                                            PF_POOL_ROUNDROBIN) {
3985                                                yyerror("only round-robin "
3986                                                    "valid for multiple "
3987                                                    "redirection addresses");
3988                                                YYERROR;
3989                                        }
3990                                }
3991                        }
3992
3993                        if ($10.key != NULL)
3994                                memcpy(&r.rpool.key, $10.key,
3995                                    sizeof(struct pf_poolhashkey));
3996
3997                         if ($10.opts)
3998                                r.rpool.opts |= $10.opts;
3999
4000                        if ($10.staticport) {
4001                                if (r.action != PF_NAT) {
4002                                        yyerror("the 'static-port' option is "
4003                                            "only valid with nat rules");
4004                                        YYERROR;
4005                                }
4006                                if (r.rpool.proxy_port[0] !=
4007                                    PF_NAT_PROXY_PORT_LOW &&
4008                                    r.rpool.proxy_port[1] !=
4009                                    PF_NAT_PROXY_PORT_HIGH) {
4010                                        yyerror("the 'static-port' option can't"
4011                                            " be used when specifying a port"
4012                                            " range");
4013                                        YYERROR;
4014                                }
4015                                r.rpool.proxy_port[0] = 0;
4016                                r.rpool.proxy_port[1] = 0;
4017                        }
4018
4019                        expand_rule(&r, $2, $9 == NULL ? NULL : $9->host, $4,
4020                            $5.src_os, $5.src.host, $5.src.port, $5.dst.host,
4021                            $5.dst.port, 0, 0, 0, "");
4022                        free($9);
4023                }
4024                ;
4025
4026binatrule       : no BINAT natpasslog interface af proto FROM host toipspec tag
4027                    tagged rtable redirection
4028                {
4029                        struct pf_rule          binat;
4030                        struct pf_pooladdr      *pa;
4031
4032                        if (check_rulestate(PFCTL_STATE_NAT))
4033                                YYERROR;
4034                        if (disallow_urpf_failed($9, "\"urpf-failed\" is not "
4035                            "permitted as a binat destination"))
4036                                YYERROR;
4037
4038                        memset(&binat, 0, sizeof(binat));
4039
4040                        if ($1 && $3.b1) {
4041                                yyerror("\"pass\" not valid with \"no\"");
4042                                YYERROR;
4043                        }
4044                        if ($1)
4045                                binat.action = PF_NOBINAT;
4046                        else
4047                                binat.action = PF_BINAT;
4048                        binat.natpass = $3.b1;
4049                        binat.log = $3.b2;
4050                        binat.logif = $3.w2;
4051                        binat.af = $5;
4052                        if (!binat.af && $8 != NULL && $8->af)
4053                                binat.af = $8->af;
4054                        if (!binat.af && $9 != NULL && $9->af)
4055                                binat.af = $9->af;
4056
4057                        if (!binat.af && $13 != NULL && $13->host)
4058                                binat.af = $13->host->af;
4059                        if (!binat.af) {
4060                                yyerror("address family (inet/inet6) "
4061                                    "undefined");
4062                                YYERROR;
4063                        }
4064
4065                        if ($4 != NULL) {
4066                                memcpy(binat.ifname, $4->ifname,
4067                                    sizeof(binat.ifname));
4068                                binat.ifnot = $4->not;
4069                                free($4);
4070                        }
4071
4072                        if ($10 != NULL)
4073                                if (strlcpy(binat.tagname, $10,
4074                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
4075                                        yyerror("tag too long, max %u chars",
4076                                            PF_TAG_NAME_SIZE - 1);
4077                                        YYERROR;
4078                                }
4079                        if ($11.name)
4080                                if (strlcpy(binat.match_tagname, $11.name,
4081                                    PF_TAG_NAME_SIZE) >= PF_TAG_NAME_SIZE) {
4082                                        yyerror("tag too long, max %u chars",
4083                                            PF_TAG_NAME_SIZE - 1);
4084                                        YYERROR;
4085                                }
4086                        binat.match_tag_not = $11.neg;
4087                        binat.rtableid = $12;
4088
4089                        if ($6 != NULL) {
4090                                binat.proto = $6->proto;
4091                                free($6);
4092                        }
4093
4094                        if ($8 != NULL && disallow_table($8, "invalid use of "
4095                            "table <%s> as the source address of a binat rule"))
4096                                YYERROR;
4097                        if ($8 != NULL && disallow_alias($8, "invalid use of "
4098                            "interface (%s) as the source address of a binat "
4099                            "rule"))
4100                                YYERROR;
4101                        if ($13 != NULL && $13->host != NULL && disallow_table(
4102                            $13->host, "invalid use of table <%s> as the "
4103                            "redirect address of a binat rule"))
4104                                YYERROR;
4105                        if ($13 != NULL && $13->host != NULL && disallow_alias(
4106                            $13->host, "invalid use of interface (%s) as the "
4107                            "redirect address of a binat rule"))
4108                                YYERROR;
4109
4110                        if ($8 != NULL) {
4111                                if ($8->next) {
4112                                        yyerror("multiple binat ip addresses");
4113                                        YYERROR;
4114                                }
4115                                if ($8->addr.type == PF_ADDR_DYNIFTL)
4116                                        $8->af = binat.af;
4117                                if ($8->af != binat.af) {
4118                                        yyerror("binat ip versions must match");
4119                                        YYERROR;
4120                                }
4121                                if (check_netmask($8, binat.af))
4122                                        YYERROR;
4123                                memcpy(&binat.src.addr, &$8->addr,
4124                                    sizeof(binat.src.addr));
4125                                free($8);
4126                        }
4127                        if ($9 != NULL) {
4128                                if ($9->next) {
4129                                        yyerror("multiple binat ip addresses");
4130                                        YYERROR;
4131                                }
4132                                if ($9->af != binat.af && $9->af) {
4133                                        yyerror("binat ip versions must match");
4134                                        YYERROR;
4135                                }
4136                                if (check_netmask($9, binat.af))
4137                                        YYERROR;
4138                                memcpy(&binat.dst.addr, &$9->addr,
4139                                    sizeof(binat.dst.addr));
4140                                binat.dst.neg = $9->not;
4141                                free($9);
4142                        }
4143
4144                        if (binat.action == PF_NOBINAT) {
4145                                if ($13 != NULL) {
4146                                        yyerror("'no binat' rule does not need"
4147                                            " '->'");
4148                                        YYERROR;
4149                                }
4150                        } else {
4151                                if ($13 == NULL || $13->host == NULL) {
4152                                        yyerror("'binat' rule requires"
4153                                            " '-> address'");
4154                                        YYERROR;
4155                                }
4156
4157                                remove_invalid_hosts(&$13->host, &binat.af);
4158                                if (invalid_redirect($13->host, binat.af))
4159                                        YYERROR;
4160                                if ($13->host->next != NULL) {
4161                                        yyerror("binat rule must redirect to "
4162                                            "a single address");
4163                                        YYERROR;
4164                                }
4165                                if (check_netmask($13->host, binat.af))
4166                                        YYERROR;
4167
4168                                if (!PF_AZERO(&binat.src.addr.v.a.mask,
4169                                    binat.af) &&
4170                                    !PF_AEQ(&binat.src.addr.v.a.mask,
4171                                    &$13->host->addr.v.a.mask, binat.af)) {
4172                                        yyerror("'binat' source mask and "
4173                                            "redirect mask must be the same");
4174                                        YYERROR;
4175                                }
4176
4177                                TAILQ_INIT(&binat.rpool.list);
4178                                pa = calloc(1, sizeof(struct pf_pooladdr));
4179                                if (pa == NULL)
4180                                        err(1, "binat: calloc");
4181                                pa->addr = $13->host->addr;
4182                                pa->ifname[0] = 0;
4183                                TAILQ_INSERT_TAIL(&binat.rpool.list,
4184                                    pa, entries);
4185
4186                                free($13);
4187                        }
4188
4189                        pfctl_add_rule(pf, &binat, "");
4190                }
4191                ;
4192
4193tag             : /* empty */           { $$ = NULL; }
4194                | TAG STRING            { $$ = $2; }
4195                ;
4196
4197tagged          : /* empty */           { $$.neg = 0; $$.name = NULL; }
4198                | not TAGGED string     { $$.neg = $1; $$.name = $3; }
4199                ;
4200
4201rtable          : /* empty */           { $$ = -1; }
4202                | RTABLE NUMBER         {
4203                        if ($2 < 0 || $2 > rt_tableid_max()) {
4204                                yyerror("invalid rtable id");
4205                                YYERROR;
4206                        }
4207                        $$ = $2;
4208                }
4209                ;
4210
4211route_host      : STRING                        {
4212                        $$ = calloc(1, sizeof(struct node_host));
4213                        if ($$ == NULL)
4214                                err(1, "route_host: calloc");
4215                        $$->ifname = $1;
4216                        set_ipmask($$, 128);
4217                        $$->next = NULL;
4218                        $$->tail = $$;
4219                }
4220                | '(' STRING host ')'           {
4221                        $$ = $3;
4222                        $$->ifname = $2;
4223                }
4224                ;
4225
4226route_host_list : route_host optnl                      { $$ = $1; }
4227                | route_host_list comma route_host optnl {
4228                        if ($1->af == 0)
4229                                $1->af = $3->af;
4230                        if ($1->af != $3->af) {
4231                                yyerror("all pool addresses must be in the "
4232                                    "same address family");
4233                                YYERROR;
4234                        }
4235                        $1->tail->next = $3;
4236                        $1->tail = $3->tail;
4237                        $$ = $1;
4238                }
4239                ;
4240
4241routespec       : route_host                    { $$ = $1; }
4242                | '{' optnl route_host_list '}' { $$ = $3; }
4243                ;
4244
4245route           : /* empty */                   {
4246                        $$.host = NULL;
4247                        $$.rt = 0;
4248                        $$.pool_opts = 0;
4249                }
4250                | FASTROUTE {
4251                        $$.host = NULL;
4252                        $$.rt = PF_FASTROUTE;
4253                        $$.pool_opts = 0;
4254                }
4255                | ROUTETO routespec pool_opts {
4256                        $$.host = $2;
4257                        $$.rt = PF_ROUTETO;
4258                        $$.pool_opts = $3.type | $3.opts;
4259                        if ($3.key != NULL)
4260                                $$.key = $3.key;
4261                }
4262                | REPLYTO routespec pool_opts {
4263                        $$.host = $2;
4264                        $$.rt = PF_REPLYTO;
4265                        $$.pool_opts = $3.type | $3.opts;
4266                        if ($3.key != NULL)
4267                                $$.key = $3.key;
4268                }
4269                | DUPTO routespec pool_opts {
4270                        $$.host = $2;
4271                        $$.rt = PF_DUPTO;
4272                        $$.pool_opts = $3.type | $3.opts;
4273                        if ($3.key != NULL)
4274                                $$.key = $3.key;
4275                }
4276                ;
4277
4278timeout_spec    : STRING NUMBER
4279                {
4280                        if (check_rulestate(PFCTL_STATE_OPTION)) {
4281                                free($1);
4282                                YYERROR;
4283                        }
4284                        if ($2 < 0 || $2 > UINT_MAX) {
4285                                yyerror("only positive values permitted");
4286                                YYERROR;
4287                        }
4288                        if (pfctl_set_timeout(pf, $1, $2, 0) != 0) {
4289                                yyerror("unknown timeout %s", $1);
4290                                free($1);
4291                                YYERROR;
4292                        }
4293                        free($1);
4294                }
4295                ;
4296
4297timeout_list    : timeout_list comma timeout_spec optnl
4298                | timeout_spec optnl
4299                ;
4300
4301limit_spec      : STRING NUMBER
4302                {
4303                        if (check_rulestate(PFCTL_STATE_OPTION)) {
4304                                free($1);
4305                                YYERROR;
4306                        }
4307                        if ($2 < 0 || $2 > UINT_MAX) {
4308                                yyerror("only positive values permitted");
4309                                YYERROR;
4310                        }
4311                        if (pfctl_set_limit(pf, $1, $2) != 0) {
4312                                yyerror("unable to set limit %s %u", $1, $2);
4313                                free($1);
4314                                YYERROR;
4315                        }
4316                        free($1);
4317                }
4318                ;
4319
4320limit_list      : limit_list comma limit_spec optnl
4321                | limit_spec optnl
4322                ;
4323
4324comma           : ','
4325                | /* empty */
4326                ;
4327
4328yesno           : NO                    { $$ = 0; }
4329                | STRING                {
4330                        if (!strcmp($1, "yes"))
4331                                $$ = 1;
4332                        else {
4333                                yyerror("invalid value '%s', expected 'yes' "
4334                                    "or 'no'", $1);
4335                                free($1);
4336                                YYERROR;
4337                        }
4338                        free($1);
4339                }
4340                ;
4341
4342unaryop         : '='           { $$ = PF_OP_EQ; }
4343                | '!' '='       { $$ = PF_OP_NE; }
4344                | '<' '='       { $$ = PF_OP_LE; }
4345                | '<'           { $$ = PF_OP_LT; }
4346                | '>' '='       { $$ = PF_OP_GE; }
4347                | '>'           { $$ = PF_OP_GT; }
4348                ;
4349
4350%%
4351
4352int
4353yyerror(const char *fmt, ...)
4354{
4355        va_list          ap;
4356
4357        file->errors++;
4358        va_start(ap, fmt);
4359        fprintf(stderr, "%s:%d: ", file->name, yylval.lineno);
4360        vfprintf(stderr, fmt, ap);
4361        fprintf(stderr, "\n");
4362        va_end(ap);
4363        return (0);
4364}
4365
4366int
4367disallow_table(struct node_host *h, const char *fmt)
4368{
4369        for (; h != NULL; h = h->next)
4370                if (h->addr.type == PF_ADDR_TABLE) {
4371                        yyerror(fmt, h->addr.v.tblname);
4372                        return (1);
4373                }
4374        return (0);
4375}
4376
4377int
4378disallow_urpf_failed(struct node_host *h, const char *fmt)
4379{
4380        for (; h != NULL; h = h->next)
4381                if (h->addr.type == PF_ADDR_URPFFAILED) {
4382                        yyerror(fmt);
4383                        return (1);
4384                }
4385        return (0);
4386}
4387
4388int
4389disallow_alias(struct node_host *h, const char *fmt)
4390{
4391        for (; h != NULL; h = h->next)
4392                if (DYNIF_MULTIADDR(h->addr)) {
4393                        yyerror(fmt, h->addr.v.tblname);
4394                        return (1);
4395                }
4396        return (0);
4397}
4398
4399int
4400rule_consistent(struct pf_rule *r, int anchor_call)
4401{
4402        int     problems = 0;
4403
4404        switch (r->action) {
4405        case PF_PASS:
4406        case PF_DROP:
4407        case PF_SCRUB:
4408        case PF_NOSCRUB:
4409                problems = filter_consistent(r, anchor_call);
4410                break;
4411        case PF_NAT:
4412        case PF_NONAT:
4413                problems = nat_consistent(r);
4414                break;
4415        case PF_RDR:
4416        case PF_NORDR:
4417                problems = rdr_consistent(r);
4418                break;
4419        case PF_BINAT:
4420        case PF_NOBINAT:
4421        default:
4422                break;
4423        }
4424        return (problems);
4425}
4426
4427int
4428filter_consistent(struct pf_rule *r, int anchor_call)
4429{
4430        int     problems = 0;
4431
4432        if (r->proto != IPPROTO_TCP && r->proto != IPPROTO_UDP &&
4433            (r->src.port_op || r->dst.port_op)) {
4434                yyerror("port only applies to tcp/udp");
4435                problems++;
4436        }
4437        if (r->proto != IPPROTO_ICMP && r->proto != IPPROTO_ICMPV6 &&
4438            (r->type || r->code)) {
4439                yyerror("icmp-type/code only applies to icmp");
4440                problems++;
4441        }
4442        if (!r->af && (r->type || r->code)) {
4443                yyerror("must indicate address family with icmp-type/code");
4444                problems++;
4445        }
4446        if (r->overload_tblname[0] &&
4447            r->max_src_conn == 0 && r->max_src_conn_rate.seconds == 0) {
4448                yyerror("'overload' requires 'max-src-conn' "
4449                    "or 'max-src-conn-rate'");
4450                problems++;
4451        }
4452        if ((r->proto == IPPROTO_ICMP && r->af == AF_INET6) ||
4453            (r->proto == IPPROTO_ICMPV6 && r->af == AF_INET)) {
4454                yyerror("proto %s doesn't match address family %s",
4455                    r->proto == IPPROTO_ICMP ? "icmp" : "icmp6",
4456                    r->af == AF_INET ? "inet" : "inet6");
4457                problems++;
4458        }
4459        if (r->allow_opts && r->action != PF_PASS) {
4460                yyerror("allow-opts can only be specified for pass rules");
4461                problems++;
4462        }
4463        if (r->rule_flag & PFRULE_FRAGMENT && (r->src.port_op ||
4464            r->dst.port_op || r->flagset || r->type || r->code)) {
4465                yyerror("fragments can be filtered only on IP header fields");
4466                problems++;
4467        }
4468        if (r->rule_flag & PFRULE_RETURNRST && r->proto != IPPROTO_TCP) {
4469                yyerror("return-rst can only be applied to TCP rules");
4470                problems++;
4471        }
4472        if (r->max_src_nodes && !(r->rule_flag & PFRULE_RULESRCTRACK)) {
4473                yyerror("max-src-nodes requires 'source-track rule'");
4474                problems++;
4475        }
4476        if (r->action == PF_DROP && r->keep_state) {
4477                yyerror("keep state on block rules doesn't make sense");
4478                problems++;
4479        }
4480        if (r->rule_flag & PFRULE_STATESLOPPY &&
4481            (r->keep_state == PF_STATE_MODULATE ||
4482            r->keep_state == PF_STATE_SYNPROXY)) {
4483                yyerror("sloppy state matching cannot be used with "
4484                    "synproxy state or modulate state");
4485                problems++;
4486        }
4487        return (-problems);
4488}
4489
4490int
4491nat_consistent(struct pf_rule *r)
4492{
4493        return (0);     /* yeah! */
4494}
4495
4496int
4497rdr_consistent(struct pf_rule *r)
4498{
4499        int                      problems = 0;
4500
4501        if (r->proto != IPPROTO_TCP && r->proto != IPPROTO_UDP) {
4502                if (r->src.port_op) {
4503                        yyerror("src port only applies to tcp/udp");
4504                        problems++;
4505                }
4506                if (r->dst.port_op) {
4507                        yyerror("dst port only applies to tcp/udp");
4508                        problems++;
4509                }
4510                if (r->rpool.proxy_port[0]) {
4511                        yyerror("rpool port only applies to tcp/udp");
4512                        problems++;
4513                }
4514        }
4515        if (r->dst.port_op &&
4516            r->dst.port_op != PF_OP_EQ && r->dst.port_op != PF_OP_RRG) {
4517                yyerror("invalid port operator for rdr destination port");
4518                problems++;
4519        }
4520        return (-problems);
4521}
4522
4523int
4524process_tabledef(char *name, struct table_opts *opts)
4525{
4526        struct pfr_buffer        ab;
4527        struct node_tinit       *ti;
4528
4529        bzero(&ab, sizeof(ab));
4530        ab.pfrb_type = PFRB_ADDRS;
4531        SIMPLEQ_FOREACH(ti, &opts->init_nodes, entries) {
4532                if (ti->file)
4533                        if (pfr_buf_load(&ab, ti->file, 0, append_addr)) {
4534                                if (errno)
4535                                        yyerror("cannot load \"%s\": %s",
4536                                            ti->file, strerror(errno));
4537                                else
4538                                        yyerror("file \"%s\" contains bad data",
4539                                            ti->file);
4540                                goto _error;
4541                        }
4542                if (ti->host)
4543                        if (append_addr_host(&ab, ti->host, 0, 0)) {
4544                                yyerror("cannot create address buffer: %s",
4545                                    strerror(errno));
4546                                goto _error;
4547                        }
4548        }
4549        if (pf->opts & PF_OPT_VERBOSE)
4550                print_tabledef(name, opts->flags, opts->init_addr,
4551                    &opts->init_nodes);
4552        if (!(pf->opts & PF_OPT_NOACTION) &&
4553            pfctl_define_table(name, opts->flags, opts->init_addr,
4554            pf->anchor->name, &ab, pf->anchor->ruleset.tticket)) {
4555                yyerror("cannot define table %s: %s", name,
4556                    pfr_strerror(errno));
4557                goto _error;
4558        }
4559        pf->tdirty = 1;
4560        pfr_buf_clear(&ab);
4561        return (0);
4562_error:
4563        pfr_buf_clear(&ab);
4564        return (-1);
4565}
4566
4567struct keywords {
4568        const char      *k_name;
4569        int              k_val;
4570};
4571
4572/* macro gore, but you should've seen the prior indentation nightmare... */
4573
4574#define FREE_LIST(T,r) \
4575        do { \
4576                T *p, *node = r; \
4577                while (node != NULL) { \
4578                        p = node; \
4579                        node = node->next; \
4580                        free(p); \
4581                } \
4582        } while (0)
4583
4584#define LOOP_THROUGH(T,n,r,C) \
4585        do { \
4586                T *n; \
4587                if (r == NULL) { \
4588                        r = calloc(1, sizeof(T)); \
4589                        if (r == NULL) \
4590                                err(1, "LOOP: calloc"); \
4591                        r->next = NULL; \
4592                } \
4593                n = r; \
4594                while (n != NULL) { \
4595                        do { \
4596                                C; \
4597                        } while (0); \
4598                        n = n->next; \
4599                } \
4600        } while (0)
4601
4602void
4603expand_label_str(char *label, size_t len, const char *srch, const char *repl)
4604{
4605        char *tmp;
4606        char *p, *q;
4607
4608        if ((tmp = calloc(1, len)) == NULL)
4609                err(1, "expand_label_str: calloc");
4610        p = q = label;
4611        while ((q = strstr(p, srch)) != NULL) {
4612                *q = '\0';
4613                if ((strlcat(tmp, p, len) >= len) ||
4614                    (strlcat(tmp, repl, len) >= len))
4615                        errx(1, "expand_label: label too long");
4616                q += strlen(srch);
4617                p = q;
4618        }
4619        if (strlcat(tmp, p, len) >= len)
4620                errx(1, "expand_label: label too long");
4621        strlcpy(label, tmp, len);       /* always fits */
4622        free(tmp);
4623}
4624
4625void
4626expand_label_if(const char *name, char *label, size_t len, const char *ifname)
4627{
4628        if (strstr(label, name) != NULL) {
4629                if (!*ifname)
4630                        expand_label_str(label, len, name, "any");
4631                else
4632                        expand_label_str(label, len, name, ifname);
4633        }
4634}
4635
4636void
4637expand_label_addr(const char *name, char *label, size_t len, sa_family_t af,
4638    struct node_host *h)
4639{
4640        char tmp[64], tmp_not[66];
4641
4642        if (strstr(label, name) != NULL) {
4643                switch (h->addr.type) {
4644                case PF_ADDR_DYNIFTL:
4645                        snprintf(tmp, sizeof(tmp), "(%s)", h->addr.v.ifname);
4646                        break;
4647                case PF_ADDR_TABLE:
4648                        snprintf(tmp, sizeof(tmp), "<%s>", h->addr.v.tblname);
4649                        break;
4650                case PF_ADDR_NOROUTE:
4651                        snprintf(tmp, sizeof(tmp), "no-route");
4652                        break;
4653                case PF_ADDR_URPFFAILED:
4654                        snprintf(tmp, sizeof(tmp), "urpf-failed");
4655                        break;
4656                case PF_ADDR_ADDRMASK:
4657                        if (!af || (PF_AZERO(&h->addr.v.a.addr, af) &&
4658                            PF_AZERO(&h->addr.v.a.mask, af)))
4659                                snprintf(tmp, sizeof(tmp), "any");
4660                        else {
4661                                char    a[48];
4662                                int     bits;
4663
4664                                if (inet_ntop(af, &h->addr.v.a.addr, a,
4665                                    sizeof(a)) == NULL)
4666                                        snprintf(tmp, sizeof(tmp), "?");
4667                                else {
4668                                        bits = unmask(&h->addr.v.a.mask, af);
4669                                        if ((af == AF_INET && bits < 32) ||
4670                                            (af == AF_INET6 && bits < 128))
4671                                                snprintf(tmp, sizeof(tmp),
4672                                                    "%s/%d", a, bits);
4673                                        else
4674                                                snprintf(tmp, sizeof(tmp),
4675                                                    "%s", a);
4676                                }
4677                        }
4678                        break;
4679                default:
4680                        snprintf(tmp, sizeof(tmp), "?");
4681                        break;
4682                }
4683
4684                if (h->not) {
4685                        snprintf(tmp_not, sizeof(tmp_not), "! %s", tmp);
4686                        expand_label_str(label, len, name, tmp_not);
4687                } else
4688                        expand_label_str(label, len, name, tmp);
4689        }
4690}
4691
4692void
4693expand_label_port(const char *name, char *label, size_t len,
4694    struct node_port *port)
4695{
4696        char     a1[6], a2[6], op[13] = "";
4697
4698        if (strstr(label, name) != NULL) {
4699                snprintf(a1, sizeof(a1), "%u", ntohs(port->port[0]));
4700                snprintf(a2, sizeof(a2), "%u", ntohs(port->port[1]));
4701                if (!port->op)
4702                        ;
4703                else if (port->op == PF_OP_IRG)
4704                        snprintf(op, sizeof(op), "%s><%s", a1, a2);
4705                else if (port->op == PF_OP_XRG)
4706                        snprintf(op, sizeof(op), "%s<>%s", a1, a2);
4707                else if (port->op == PF_OP_EQ)
4708                        snprintf(op, sizeof(op), "%s", a1);
4709                else if (port->op == PF_OP_NE)
4710                        snprintf(op, sizeof(op), "!=%s", a1);
4711                else if (port->op == PF_OP_LT)
4712                        snprintf(op, sizeof(op), "<%s", a1);
4713                else if (port->op == PF_OP_LE)
4714                        snprintf(op, sizeof(op), "<=%s", a1);
4715                else if (port->op == PF_OP_GT)
4716                        snprintf(op, sizeof(op), ">%s", a1);
4717                else if (port->op == PF_OP_GE)
4718                        snprintf(op, sizeof(op), ">=%s", a1);
4719                expand_label_str(label, len, name, op);
4720        }
4721}
4722
4723void
4724expand_label_proto(const char *name, char *label, size_t len, u_int8_t proto)
4725{
4726        struct protoent *pe;
4727        char n[4];
4728
4729        if (strstr(label, name) != NULL) {
4730                pe = getprotobynumber(proto);
4731                if (pe != NULL)
4732                        expand_label_str(label, len, name, pe->p_name);
4733                else {
4734                        snprintf(n, sizeof(n), "%u", proto);
4735                        expand_label_str(label, len, name, n);
4736                }
4737        }
4738}
4739
4740void
4741expand_label_nr(const char *name, char *label, size_t len)
4742{
4743        char n[11];
4744
4745        if (strstr(label, name) != NULL) {
4746                snprintf(n, sizeof(n), "%u", pf->anchor->match);
4747                expand_label_str(label, len, name, n);
4748        }
4749}
4750
4751void
4752expand_label(char *label, size_t len, const char *ifname, sa_family_t af,
4753    struct node_host *src_host, struct node_port *src_port,
4754    struct node_host *dst_host, struct node_port *dst_port,
4755    u_int8_t proto)
4756{
4757        expand_label_if("$if", label, len, ifname);
4758        expand_label_addr("$srcaddr", label, len, af, src_host);
4759        expand_label_addr("$dstaddr", label, len, af, dst_host);
4760        expand_label_port("$srcport", label, len, src_port);
4761        expand_label_port("$dstport", label, len, dst_port);
4762        expand_label_proto("$proto", label, len, proto);
4763        expand_label_nr("$nr", label, len);
4764}
4765
4766int
4767expand_altq(struct pf_altq *a, struct node_if *interfaces,
4768    struct node_queue *nqueues, struct node_queue_bw bwspec,
4769    struct node_queue_opt *opts)
4770{
4771        struct pf_altq           pa, pb;
4772        char                     qname[PF_QNAME_SIZE];
4773        struct node_queue       *n;
4774        struct node_queue_bw     bw;
4775        int                      errs = 0;
4776
4777        if ((pf->loadopt & PFCTL_FLAG_ALTQ) == 0) {
4778                FREE_LIST(struct node_if, interfaces);
4779                FREE_LIST(struct node_queue, nqueues);
4780                return (0);
4781        }
4782
4783        LOOP_THROUGH(struct node_if, interface, interfaces,
4784                memcpy(&pa, a, sizeof(struct pf_altq));
4785                if (strlcpy(pa.ifname, interface->ifname,
4786                    sizeof(pa.ifname)) >= sizeof(pa.ifname))
4787                        errx(1, "expand_altq: strlcpy");
4788
4789                if (interface->not) {
4790                        yyerror("altq on ! <interface> is not supported");
4791                        errs++;
4792                } else {
4793                        if (eval_pfaltq(pf, &pa, &bwspec, opts))
4794                                errs++;
4795                        else
4796                                if (pfctl_add_altq(pf, &pa))
4797                                        errs++;
4798
4799                        if (pf->opts & PF_OPT_VERBOSE) {
4800                                print_altq(&pf->paltq->altq, 0,
4801                                    &bwspec, opts);
4802                                if (nqueues && nqueues->tail) {
4803                                        printf("queue { ");
4804                                        LOOP_THROUGH(struct node_queue, queue,
4805                                            nqueues,
4806                                                printf("%s ",
4807                                                    queue->queue);
4808                                        );
4809                                        printf("}");
4810                                }
4811                                printf("\n");
4812                        }
4813
4814                        if (pa.scheduler == ALTQT_CBQ ||
4815                            pa.scheduler == ALTQT_HFSC) {
4816                                /* now create a root queue */
4817                                memset(&pb, 0, sizeof(struct pf_altq));
4818                                if (strlcpy(qname, "root_", sizeof(qname)) >=
4819                                    sizeof(qname))
4820                                        errx(1, "expand_altq: strlcpy");
4821                                if (strlcat(qname, interface->ifname,
4822                                    sizeof(qname)) >= sizeof(qname))
4823                                        errx(1, "expand_altq: strlcat");
4824                                if (strlcpy(pb.qname, qname,
4825                                    sizeof(pb.qname)) >= sizeof(pb.qname))
4826                                        errx(1, "expand_altq: strlcpy");
4827                                if (strlcpy(pb.ifname, interface->ifname,
4828                                    sizeof(pb.ifname)) >= sizeof(pb.ifname))
4829                                        errx(1, "expand_altq: strlcpy");
4830                                pb.qlimit = pa.qlimit;
4831                                pb.scheduler = pa.scheduler;
4832                                bw.bw_absolute = pa.ifbandwidth;
4833                                bw.bw_percent = 0;
4834                                if (eval_pfqueue(pf, &pb, &bw, opts))
4835                                        errs++;
4836                                else
4837                                        if (pfctl_add_altq(pf, &pb))
4838                                                errs++;
4839                        }
4840
4841                        LOOP_THROUGH(struct node_queue, queue, nqueues,
4842                                n = calloc(1, sizeof(struct node_queue));
4843                                if (n == NULL)
4844                                        err(1, "expand_altq: calloc");
4845                                if (pa.scheduler == ALTQT_CBQ ||
4846                                    pa.scheduler == ALTQT_HFSC)
4847                                        if (strlcpy(n->parent, qname,
4848                                            sizeof(n->parent)) >=
4849                                            sizeof(n->parent))
4850                                                errx(1, "expand_altq: strlcpy");
4851                                if (strlcpy(n->queue, queue->queue,
4852                                    sizeof(n->queue)) >= sizeof(n->queue))
4853                                        errx(1, "expand_altq: strlcpy");
4854                                if (strlcpy(n->ifname, interface->ifname,
4855                                    sizeof(n->ifname)) >= sizeof(n->ifname))
4856                                        errx(1, "expand_altq: strlcpy");
4857                                n->scheduler = pa.scheduler;
4858                                n->next = NULL;
4859                                n->tail = n;
4860                                if (queues == NULL)
4861                                        queues = n;
4862                                else {
4863                                        queues->tail->next = n;
4864                                        queues->tail = n;
4865                                }
4866                        );
4867                }
4868        );
4869        FREE_LIST(struct node_if, interfaces);
4870        FREE_LIST(struct node_queue, nqueues);
4871
4872        return (errs);
4873}
4874
4875int
4876expand_queue(struct pf_altq *a, struct node_if *interfaces,
4877    struct node_queue *nqueues, struct node_queue_bw bwspec,
4878    struct node_queue_opt *opts)
4879{
4880        struct node_queue       *n, *nq;
4881        struct pf_altq           pa;
4882        u_int8_t                 found = 0;
4883        u_int8_t                 errs = 0;
4884
4885        if ((pf->loadopt & PFCTL_FLAG_ALTQ) == 0) {
4886                FREE_LIST(struct node_queue, nqueues);
4887                return (0);
4888        }
4889
4890        if (queues == NULL) {
4891                yyerror("queue %s has no parent", a->qname);
4892                FREE_LIST(struct node_queue, nqueues);
4893                return (1);
4894        }
4895
4896        LOOP_THROUGH(struct node_if, interface, interfaces,
4897                LOOP_THROUGH(struct node_queue, tqueue, queues,
4898                        if (!strncmp(a->qname, tqueue->queue, PF_QNAME_SIZE) &&
4899                            (interface->ifname[0] == 0 ||
4900                            (!interface->not && !strncmp(interface->ifname,
4901                            tqueue->ifname, IFNAMSIZ)) ||
4902                            (interface->not && strncmp(interface->ifname,
4903                            tqueue->ifname, IFNAMSIZ)))) {
4904                                /* found ourself in queues */
4905                                found++;
4906
4907                                memcpy(&pa, a, sizeof(struct pf_altq));
4908
4909                                if (pa.scheduler != ALTQT_NONE &&
4910                                    pa.scheduler != tqueue->scheduler) {
4911                                        yyerror("exactly one scheduler type "
4912                                            "per interface allowed");
4913                                        return (1);
4914                                }
4915                                pa.scheduler = tqueue->scheduler;
4916
4917                                /* scheduler dependent error checking */
4918                                switch (pa.scheduler) {
4919                                case ALTQT_PRIQ:
4920                                        if (nqueues != NULL) {
4921                                                yyerror("priq queues cannot "
4922                                                    "have child queues");
4923                                                return (1);
4924                                        }
4925                                        if (bwspec.bw_absolute > 0 ||
4926                                            bwspec.bw_percent < 100) {
4927                                                yyerror("priq doesn't take "
4928                                                    "bandwidth");
4929                                                return (1);
4930                                        }
4931                                        break;
4932                                default:
4933                                        break;
4934                                }
4935
4936                                if (strlcpy(pa.ifname, tqueue->ifname,
4937                                    sizeof(pa.ifname)) >= sizeof(pa.ifname))
4938                                        errx(1, "expand_queue: strlcpy");
4939                                if (strlcpy(pa.parent, tqueue->parent,
4940                                    sizeof(pa.parent)) >= sizeof(pa.parent))
4941                                        errx(1, "expand_queue: strlcpy");
4942
4943                                if (eval_pfqueue(pf, &pa, &bwspec, opts))
4944                                        errs++;
4945                                else
4946                                        if (pfctl_add_altq(pf, &pa))
4947                                                errs++;
4948
4949                                for (nq = nqueues; nq != NULL; nq = nq->next) {
4950                                        if (!strcmp(a->qname, nq->queue)) {
4951                                                yyerror("queue cannot have "
4952                                                    "itself as child");
4953                                                errs++;
4954                                                continue;
4955                                        }
4956                                        n = calloc(1,
4957                                            sizeof(struct node_queue));
4958                                        if (n == NULL)
4959                                                err(1, "expand_queue: calloc");
4960                                        if (strlcpy(n->parent, a->qname,
4961                                            sizeof(n->parent)) >=
4962                                            sizeof(n->parent))
4963                                                errx(1, "expand_queue strlcpy");
4964                                        if (strlcpy(n->queue, nq->queue,
4965                                            sizeof(n->queue)) >=
4966                                            sizeof(n->queue))
4967                                                errx(1, "expand_queue strlcpy");
4968                                        if (strlcpy(n->ifname, tqueue->ifname,
4969                                            sizeof(n->ifname)) >=
4970                                            sizeof(n->ifname))
4971                                                errx(1, "expand_queue strlcpy");
4972                                        n->scheduler = tqueue->scheduler;
4973                                        n->next = NULL;
4974                                        n->tail = n;
4975                                        if (queues == NULL)
4976                                                queues = n;
4977                                        else {
4978                                                queues->tail->next = n;
4979                                                queues->tail = n;
4980                                        }
4981                                }
4982                                if ((pf->opts & PF_OPT_VERBOSE) && (
4983                                    (found == 1 && interface->ifname[0] == 0) ||
4984                                    (found > 0 && interface->ifname[0] != 0))) {
4985                                        print_queue(&pf->paltq->altq, 0,
4986                                            &bwspec, interface->ifname[0] != 0,
4987                                            opts);
4988                                        if (nqueues && nqueues->tail) {
4989                                                printf("{ ");
4990                                                LOOP_THROUGH(struct node_queue,
4991                                                    queue, nqueues,
4992                                                        printf("%s ",
4993                                                            queue->queue);
4994                                                );
4995                                                printf("}");
4996                                        }
4997                                        printf("\n");
4998                                }
4999                        }
5000                );
5001        );
5002
5003        FREE_LIST(struct node_queue, nqueues);
5004        FREE_LIST(struct node_if, interfaces);
5005
5006        if (!found) {
5007                yyerror("queue %s has no parent", a->qname);
5008                errs++;
5009        }
5010
5011        if (errs)
5012                return (1);
5013        else
5014                return (0);
5015}
5016
5017void
5018expand_rule(struct pf_rule *r,
5019    struct node_if *interfaces, struct node_host *rpool_hosts,
5020    struct node_proto *protos, struct node_os *src_oses,
5021    struct node_host *src_hosts, struct node_port *src_ports,
5022    struct node_host *dst_hosts, struct node_port *dst_ports,
5023    struct node_uid *uids, struct node_gid *gids, struct node_icmp *icmp_types,
5024    const char *anchor_call)
5025{
5026        sa_family_t              af = r->af;
5027        int                      added = 0, error = 0;
5028        char                     ifname[IF_NAMESIZE];
5029        char                     label[PF_RULE_LABEL_SIZE];
5030        char                     tagname[PF_TAG_NAME_SIZE];
5031        char                     match_tagname[PF_TAG_NAME_SIZE];
5032        struct pf_pooladdr      *pa;
5033        struct node_host        *h;
5034        u_int8_t                 flags, flagset, keep_state;
5035
5036        if (strlcpy(label, r->label, sizeof(label)) >= sizeof(label))
5037                errx(1, "expand_rule: strlcpy");
5038        if (strlcpy(tagname, r->tagname, sizeof(tagname)) >= sizeof(tagname))
5039                errx(1, "expand_rule: strlcpy");
5040        if (strlcpy(match_tagname, r->match_tagname, sizeof(match_tagname)) >=
5041            sizeof(match_tagname))
5042                errx(1, "expand_rule: strlcpy");
5043        flags = r->flags;
5044        flagset = r->flagset;
5045        keep_state = r->keep_state;
5046
5047        LOOP_THROUGH(struct node_if, interface, interfaces,
5048        LOOP_THROUGH(struct node_proto, proto, protos,
5049        LOOP_THROUGH(struct node_icmp, icmp_type, icmp_types,
5050        LOOP_THROUGH(struct node_host, src_host, src_hosts,
5051        LOOP_THROUGH(struct node_port, src_port, src_ports,
5052        LOOP_THROUGH(struct node_os, src_os, src_oses,
5053        LOOP_THROUGH(struct node_host, dst_host, dst_hosts,
5054        LOOP_THROUGH(struct node_port, dst_port, dst_ports,
5055        LOOP_THROUGH(struct node_uid, uid, uids,
5056        LOOP_THROUGH(struct node_gid, gid, gids,
5057
5058                r->af = af;
5059                /* for link-local IPv6 address, interface must match up */
5060                if ((r->af && src_host->af && r->af != src_host->af) ||
5061                    (r->af && dst_host->af && r->af != dst_host->af) ||
5062                    (src_host->af && dst_host->af &&
5063                    src_host->af != dst_host->af) ||
5064                    (src_host->ifindex && dst_host->ifindex &&
5065                    src_host->ifindex != dst_host->ifindex) ||
5066                    (src_host->ifindex && *interface->ifname &&
5067                    src_host->ifindex != if_nametoindex(interface->ifname)) ||
5068                    (dst_host->ifindex && *interface->ifname &&
5069                    dst_host->ifindex != if_nametoindex(interface->ifname)))
5070                        continue;
5071                if (!r->af && src_host->af)
5072                        r->af = src_host->af;
5073                else if (!r->af && dst_host->af)
5074                        r->af = dst_host->af;
5075
5076                if (*interface->ifname)
5077                        strlcpy(r->ifname, interface->ifname,
5078                            sizeof(r->ifname));
5079                else if (if_indextoname(src_host->ifindex, ifname))
5080                        strlcpy(r->ifname, ifname, sizeof(r->ifname));
5081                else if (if_indextoname(dst_host->ifindex, ifname))
5082                        strlcpy(r->ifname, ifname, sizeof(r->ifname));
5083                else
5084                        memset(r->ifname, '\0', sizeof(r->ifname));
5085
5086                if (strlcpy(r->label, label, sizeof(r->label)) >=
5087                    sizeof(r->label))
5088                        errx(1, "expand_rule: strlcpy");
5089                if (strlcpy(r->tagname, tagname, sizeof(r->tagname)) >=
5090                    sizeof(r->tagname))
5091                        errx(1, "expand_rule: strlcpy");
5092                if (strlcpy(r->match_tagname, match_tagname,
5093                    sizeof(r->match_tagname)) >= sizeof(r->match_tagname))
5094                        errx(1, "expand_rule: strlcpy");
5095                expand_label(r->label, PF_RULE_LABEL_SIZE, r->ifname, r->af,
5096                    src_host, src_port, dst_host, dst_port, proto->proto);
5097                expand_label(r->tagname, PF_TAG_NAME_SIZE, r->ifname, r->af,
5098                    src_host, src_port, dst_host, dst_port, proto->proto);
5099                expand_label(r->match_tagname, PF_TAG_NAME_SIZE, r->ifname,
5100                    r->af, src_host, src_port, dst_host, dst_port,
5101                    proto->proto);
5102
5103                error += check_netmask(src_host, r->af);
5104                error += check_netmask(dst_host, r->af);
5105
5106                r->ifnot = interface->not;
5107                r->proto = proto->proto;
5108                r->src.addr = src_host->addr;
5109                r->src.neg = src_host->not;
5110                r->src.port[0] = src_port->port[0];
5111                r->src.port[1] = src_port->port[1];
5112                r->src.port_op = src_port->op;
5113                r->dst.addr = dst_host->addr;
5114                r->dst.neg = dst_host->not;
5115                r->dst.port[0] = dst_port->port[0];
5116                r->dst.port[1] = dst_port->port[1];
5117                r->dst.port_op = dst_port->op;
5118                r->uid.op = uid->op;
5119                r->uid.uid[0] = uid->uid[0];
5120                r->uid.uid[1] = uid->uid[1];
5121                r->gid.op = gid->op;
5122                r->gid.gid[0] = gid->gid[0];
5123                r->gid.gid[1] = gid->gid[1];
5124                r->type = icmp_type->type;
5125                r->code = icmp_type->code;
5126
5127                if ((keep_state == PF_STATE_MODULATE ||
5128                    keep_state == PF_STATE_SYNPROXY) &&
5129                    r->proto && r->proto != IPPROTO_TCP)
5130                        r->keep_state = PF_STATE_NORMAL;
5131                else
5132                        r->keep_state = keep_state;
5133
5134                if (r->proto && r->proto != IPPROTO_TCP) {
5135                        r->flags = 0;
5136                        r->flagset = 0;
5137                } else {
5138                        r->flags = flags;
5139                        r->flagset = flagset;
5140                }
5141                if (icmp_type->proto && r->proto != icmp_type->proto) {
5142                        yyerror("icmp-type mismatch");
5143                        error++;
5144                }
5145
5146                if (src_os && src_os->os) {
5147                        r->os_fingerprint = pfctl_get_fingerprint(src_os->os);
5148                        if ((pf->opts & PF_OPT_VERBOSE2) &&
5149                            r->os_fingerprint == PF_OSFP_NOMATCH)
5150                                fprintf(stderr,
5151                                    "warning: unknown '%s' OS fingerprint\n",
5152                                    src_os->os);
5153                } else {
5154                        r->os_fingerprint = PF_OSFP_ANY;
5155                }
5156
5157                TAILQ_INIT(&r->rpool.list);
5158                for (h = rpool_hosts; h != NULL; h = h->next) {
5159                        pa = calloc(1, sizeof(struct pf_pooladdr));
5160                        if (pa == NULL)
5161                                err(1, "expand_rule: calloc");
5162                        pa->addr = h->addr;
5163                        if (h->ifname != NULL) {
5164                                if (strlcpy(pa->ifname, h->ifname,
5165                                    sizeof(pa->ifname)) >=
5166                                    sizeof(pa->ifname))
5167                                        errx(1, "expand_rule: strlcpy");
5168                        } else
5169                                pa->ifname[0] = 0;
5170                        TAILQ_INSERT_TAIL(&r->rpool.list, pa, entries);
5171                }
5172
5173                if (rule_consistent(r, anchor_call[0]) < 0 || error)
5174                        yyerror("skipping rule due to errors");
5175                else {
5176                        r->nr = pf->astack[pf->asd]->match++;
5177                        pfctl_add_rule(pf, r, anchor_call);
5178                        added++;
5179                }
5180
5181        ))))))))));
5182
5183        FREE_LIST(struct node_if, interfaces);
5184        FREE_LIST(struct node_proto, protos);
5185        FREE_LIST(struct node_host, src_hosts);
5186        FREE_LIST(struct node_port, src_ports);
5187        FREE_LIST(struct node_os, src_oses);
5188        FREE_LIST(struct node_host, dst_hosts);
5189        FREE_LIST(struct node_port, dst_ports);
5190        FREE_LIST(struct node_uid, uids);
5191        FREE_LIST(struct node_gid, gids);
5192        FREE_LIST(struct node_icmp, icmp_types);
5193        FREE_LIST(struct node_host, rpool_hosts);
5194
5195        if (!added)
5196                yyerror("rule expands to no valid combination");
5197}
5198
5199int
5200expand_skip_interface(struct node_if *interfaces)
5201{
5202        int     errs = 0;
5203
5204        if (!interfaces || (!interfaces->next && !interfaces->not &&
5205            !strcmp(interfaces->ifname, "none"))) {
5206                if (pf->opts & PF_OPT_VERBOSE)
5207                        printf("set skip on none\n");
5208                errs = pfctl_set_interface_flags(pf, "", PFI_IFLAG_SKIP, 0);
5209                return (errs);
5210        }
5211
5212        if (pf->opts & PF_OPT_VERBOSE)
5213                printf("set skip on {");
5214        LOOP_THROUGH(struct node_if, interface, interfaces,
5215                if (pf->opts & PF_OPT_VERBOSE)
5216                        printf(" %s", interface->ifname);
5217                if (interface->not) {
5218                        yyerror("skip on ! <interface> is not supported");
5219                        errs++;
5220                } else
5221                        errs += pfctl_set_interface_flags(pf,
5222                            interface->ifname, PFI_IFLAG_SKIP, 1);
5223        );
5224        if (pf->opts & PF_OPT_VERBOSE)
5225                printf(" }\n");
5226
5227        FREE_LIST(struct node_if, interfaces);
5228
5229        if (errs)
5230                return (1);
5231        else
5232                return (0);
5233}
5234
5235#undef FREE_LIST
5236#undef LOOP_THROUGH
5237
5238int
5239check_rulestate(int desired_state)
5240{
5241        if (require_order && (rulestate > desired_state)) {
5242                yyerror("Rules must be in order: options, normalization, "
5243                    "queueing, translation, filtering");
5244                return (1);
5245        }
5246        rulestate = desired_state;
5247        return (0);
5248}
5249
5250int
5251kw_cmp(const void *k, const void *e)
5252{
5253        return (strcmp(k, ((const struct keywords *)e)->k_name));
5254}
5255
5256int
5257lookup(char *s)
5258{
5259        /* this has to be sorted always */
5260        static const struct keywords keywords[] = {
5261                { "all",                ALL},
5262                { "allow-opts",         ALLOWOPTS},
5263                { "altq",               ALTQ},
5264                { "anchor",             ANCHOR},
5265                { "antispoof",          ANTISPOOF},
5266                { "any",                ANY},
5267                { "bandwidth",          BANDWIDTH},
5268                { "binat",              BINAT},
5269                { "binat-anchor",       BINATANCHOR},
5270                { "bitmask",            BITMASK},
5271                { "block",              BLOCK},
5272                { "block-policy",       BLOCKPOLICY},
5273                { "cbq",                CBQ},
5274                { "code",               CODE},
5275                { "crop",               FRAGCROP},
5276                { "debug",              DEBUG},
5277                { "divert-reply",       DIVERTREPLY},
5278                { "divert-to",          DIVERTTO},
5279                { "drop",               DROP},
5280                { "drop-ovl",           FRAGDROP},
5281                { "dup-to",             DUPTO},
5282                { "fastroute",          FASTROUTE},
5283                { "file",               FILENAME},
5284                { "fingerprints",       FINGERPRINTS},
5285                { "flags",              FLAGS},
5286                { "floating",           FLOATING},
5287                { "flush",              FLUSH},
5288                { "for",                FOR},
5289                { "fragment",           FRAGMENT},
5290                { "from",               FROM},
5291                { "global",             GLOBAL},
5292                { "group",              GROUP},
5293                { "hfsc",               HFSC},
5294                { "hostid",             HOSTID},
5295                { "icmp-type",          ICMPTYPE},
5296                { "icmp6-type",         ICMP6TYPE},
5297                { "if-bound",           IFBOUND},
5298                { "in",                 IN},
5299                { "include",            INCLUDE},
5300                { "inet",               INET},
5301                { "inet6",              INET6},
5302                { "keep",               KEEP},
5303                { "label",              LABEL},
5304                { "limit",              LIMIT},
5305                { "linkshare",          LINKSHARE},
5306                { "load",               LOAD},
5307                { "log",                LOG},
5308                { "loginterface",       LOGINTERFACE},
5309                { "max",                MAXIMUM},
5310                { "max-mss",            MAXMSS},
5311                { "max-src-conn",       MAXSRCCONN},
5312                { "max-src-conn-rate",  MAXSRCCONNRATE},
5313                { "max-src-nodes",      MAXSRCNODES},
5314                { "max-src-states",     MAXSRCSTATES},
5315                { "min-ttl",            MINTTL},
5316                { "modulate",           MODULATE},
5317                { "nat",                NAT},
5318                { "nat-anchor",         NATANCHOR},
5319                { "no",                 NO},
5320                { "no-df",              NODF},
5321                { "no-route",           NOROUTE},
5322                { "no-sync",            NOSYNC},
5323                { "on",                 ON},
5324                { "optimization",       OPTIMIZATION},
5325                { "os",                 OS},
5326                { "out",                OUT},
5327                { "overload",           OVERLOAD},
5328                { "pass",               PASS},
5329                { "pflow",              PFLOW},
5330                { "port",               PORT},
5331                { "priority",           PRIORITY},
5332                { "priq",               PRIQ},
5333                { "probability",        PROBABILITY},
5334                { "proto",              PROTO},
5335                { "qlimit",             QLIMIT},
5336                { "queue",              QUEUE},
5337                { "quick",              QUICK},
5338                { "random",             RANDOM},
5339                { "random-id",          RANDOMID},
5340                { "rdr",                RDR},
5341                { "rdr-anchor",         RDRANCHOR},
5342                { "realtime",           REALTIME},
5343                { "reassemble",         REASSEMBLE},
5344                { "reply-to",           REPLYTO},
5345                { "require-order",      REQUIREORDER},
5346                { "return",             RETURN},
5347                { "return-icmp",        RETURNICMP},
5348                { "return-icmp6",       RETURNICMP6},
5349                { "return-rst",         RETURNRST},
5350                { "round-robin",        ROUNDROBIN},
5351                { "route",              ROUTE},
5352                { "route-to",           ROUTETO},
5353                { "rtable",             RTABLE},
5354                { "rule",               RULE},
5355                { "ruleset-optimization",       RULESET_OPTIMIZATION},
5356                { "scrub",              SCRUB},
5357                { "set",                SET},
5358                { "set-tos",            SETTOS},
5359                { "skip",               SKIP},
5360                { "sloppy",             SLOPPY},
5361                { "source-hash",        SOURCEHASH},
5362                { "source-track",       SOURCETRACK},
5363                { "state",              STATE},
5364                { "state-defaults",     STATEDEFAULTS},
5365                { "state-policy",       STATEPOLICY},
5366                { "static-port",        STATICPORT},
5367                { "sticky-address",     STICKYADDRESS},
5368                { "synproxy",           SYNPROXY},
5369                { "table",              TABLE},
5370                { "tag",                TAG},
5371                { "tagged",             TAGGED},
5372                { "tbrsize",            TBRSIZE},
5373                { "timeout",            TIMEOUT},
5374                { "to",                 TO},
5375                { "tos",                TOS},
5376                { "ttl",                TTL},
5377                { "upperlimit",         UPPERLIMIT},
5378                { "urpf-failed",        URPFFAILED},
5379                { "user",               USER},
5380        };
5381        const struct keywords   *p;
5382
5383        p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
5384            sizeof(keywords[0]), kw_cmp);
5385
5386        if (p) {
5387                if (debug > 1)
5388                        fprintf(stderr, "%s: %d\n", s, p->k_val);
5389                return (p->k_val);
5390        } else {
5391                if (debug > 1)
5392                        fprintf(stderr, "string: %s\n", s);
5393                return (STRING);
5394        }
5395}
5396
5397#define MAXPUSHBACK     128
5398
5399char    *parsebuf;
5400int      parseindex;
5401char     pushback_buffer[MAXPUSHBACK];
5402int      pushback_index = 0;
5403
5404int
5405lgetc(int quotec)
5406{
5407        int             c, next;
5408
5409        if (parsebuf) {
5410                /* Read character from the parsebuffer instead of input. */
5411                if (parseindex >= 0) {
5412                        c = parsebuf[parseindex++];
5413                        if (c != '\0')
5414                                return (c);
5415                        parsebuf = NULL;
5416                } else
5417                        parseindex++;
5418        }
5419
5420        if (pushback_index)
5421                return (pushback_buffer[--pushback_index]);
5422
5423        if (quotec) {
5424                if ((c = getc(file->stream)) == EOF) {
5425                        yyerror("reached end of file while parsing quoted string");
5426                        if (popfile() == EOF)
5427                                return (EOF);
5428                        return (quotec);
5429                }
5430                return (c);
5431        }
5432
5433        while ((c = getc(file->stream)) == '\\') {
5434                next = getc(file->stream);
5435                if (next != '\n') {
5436                        c = next;
5437                        break;
5438                }
5439                yylval.lineno = file->lineno;
5440                file->lineno++;
5441        }
5442
5443        while (c == EOF) {
5444                if (popfile() == EOF)
5445                        return (EOF);
5446                c = getc(file->stream);
5447        }
5448        return (c);
5449}
5450
5451int
5452lungetc(int c)
5453{
5454        if (c == EOF)
5455                return (EOF);
5456        if (parsebuf) {
5457                parseindex--;
5458                if (parseindex >= 0)
5459                        return (c);
5460        }
5461        if (pushback_index < MAXPUSHBACK-1)
5462                return (pushback_buffer[pushback_index++] = c);
5463        else
5464                return (EOF);
5465}
5466
5467int
5468findeol(void)
5469{
5470        int     c;
5471
5472        parsebuf = NULL;
5473
5474        /* skip to either EOF or the first real EOL */
5475        while (1) {
5476                if (pushback_index)
5477                        c = pushback_buffer[--pushback_index];
5478                else
5479                        c = lgetc(0);
5480                if (c == '\n') {
5481                        file->lineno++;
5482                        break;
5483                }
5484                if (c == EOF)
5485                        break;
5486        }
5487        return (ERROR);
5488}
5489
5490int
5491yylex(void)
5492{
5493        char     buf[8096];
5494        char    *p, *val;
5495        int      quotec, next, c;
5496        int      token;
5497
5498top:
5499        p = buf;
5500        while ((c = lgetc(0)) == ' ' || c == '\t')
5501                ; /* nothing */
5502
5503        yylval.lineno = file->lineno;
5504        if (c == '#')
5505                while ((c = lgetc(0)) != '\n' && c != EOF)
5506                        ; /* nothing */
5507        if (c == '$' && parsebuf == NULL) {
5508                while (1) {
5509                        if ((c = lgetc(0)) == EOF)
5510                                return (0);
5511
5512                        if (p + 1 >= buf + sizeof(buf) - 1) {
5513                                yyerror("string too long");
5514                                return (findeol());
5515                        }
5516                        if (isalnum(c) || c == '_') {
5517                                *p++ = (char)c;
5518                                continue;
5519                        }
5520                        *p = '\0';
5521                        lungetc(c);
5522                        break;
5523                }
5524                val = symget(buf);
5525                if (val == NULL) {
5526                        yyerror("macro '%s' not defined", buf);
5527                        return (findeol());
5528                }
5529                parsebuf = val;
5530                parseindex = 0;
5531                goto top;
5532        }
5533
5534        switch (c) {
5535        case '\'':
5536        case '"':
5537                quotec = c;
5538                while (1) {
5539                        if ((c = lgetc(quotec)) == EOF)
5540                                return (0);
5541                        if (c == '\n') {
5542                                file->lineno++;
5543                                continue;
5544                        } else if (c == '\\') {
5545                                if ((next = lgetc(quotec)) == EOF)
5546                                        return (0);
5547                                if (next == quotec || c == ' ' || c == '\t')
5548                                        c = next;
5549                                else if (next == '\n')
5550                                        continue;
5551                                else
5552                                        lungetc(next);
5553                        } else if (c == quotec) {
5554                                *p = '\0';
5555                                break;
5556                        }
5557                        if (p + 1 >= buf + sizeof(buf) - 1) {
5558                                yyerror("string too long");
5559                                return (findeol());
5560                        }
5561                        *p++ = (char)c;
5562                }
5563                yylval.v.string = strdup(buf);
5564                if (yylval.v.string == NULL)
5565                        err(1, "yylex: strdup");
5566                return (STRING);
5567        case '<':
5568                next = lgetc(0);
5569                if (next == '>') {
5570                        yylval.v.i = PF_OP_XRG;
5571                        return (PORTBINARY);
5572                }
5573                lungetc(next);
5574                break;
5575        case '>':
5576                next = lgetc(0);
5577                if (next == '<') {
5578                        yylval.v.i = PF_OP_IRG;
5579                        return (PORTBINARY);
5580                }
5581                lungetc(next);
5582                break;
5583        case '-':
5584                next = lgetc(0);
5585                if (next == '>')
5586                        return (ARROW);
5587                lungetc(next);
5588                break;
5589        }
5590
5591#define allowed_to_end_number(x) \
5592        (isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
5593
5594        if (c == '-' || isdigit(c)) {
5595                do {
5596                        *p++ = c;
5597                        if ((unsigned)(p-buf) >= sizeof(buf)) {
5598                                yyerror("string too long");
5599                                return (findeol());
5600                        }
5601                } while ((c = lgetc(0)) != EOF && isdigit(c));
5602                lungetc(c);
5603                if (p == buf + 1 && buf[0] == '-')
5604                        goto nodigits;
5605                if (c == EOF || allowed_to_end_number(c)) {
5606                        const char *errstr = NULL;
5607
5608                        *p = '\0';
5609                        yylval.v.number = strtonum(buf, LLONG_MIN,
5610                            LLONG_MAX, &errstr);
5611                        if (errstr) {
5612                                yyerror("\"%s\" invalid number: %s",
5613                                    buf, errstr);
5614                                return (findeol());
5615                        }
5616                        return (NUMBER);
5617                } else {
5618nodigits:
5619                        while (p > buf + 1)
5620                                lungetc(*--p);
5621                        c = *--p;
5622                        if (c == '-')
5623                                return (c);
5624                }
5625        }
5626
5627#define allowed_in_string(x) \
5628        (isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
5629        x != '{' && x != '}' && x != '<' && x != '>' && \
5630        x != '!' && x != '=' && x != '/' && x != '#' && \
5631        x != ','))
5632
5633        if (isalnum(c) || c == ':' || c == '_') {
5634                do {
5635                        *p++ = c;
5636                        if ((unsigned)(p-buf) >= sizeof(buf)) {
5637                                yyerror("string too long");
5638                                return (findeol());
5639                        }
5640                } while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
5641                lungetc(c);
5642                *p = '\0';
5643                if ((token = lookup(buf)) == STRING)
5644                        if ((yylval.v.string = strdup(buf)) == NULL)
5645                                err(1, "yylex: strdup");
5646                return (token);
5647        }
5648        if (c == '\n') {
5649                yylval.lineno = file->lineno;
5650                file->lineno++;
5651        }
5652        if (c == EOF)
5653                return (0);
5654        return (c);
5655}
5656
5657int
5658check_file_secrecy(int fd, const char *fname)
5659{
5660        struct stat     st;
5661
5662        if (fstat(fd, &st)) {
5663                warn("cannot stat %s", fname);
5664                return (-1);
5665        }
5666        if (st.st_uid != 0 && st.st_uid != getuid()) {
5667                warnx("%s: owner not root or current user", fname);
5668                return (-1);
5669        }
5670        if (st.st_mode & (S_IRWXG | S_IRWXO)) {
5671                warnx("%s: group/world readable/writeable", fname);
5672                return (-1);
5673        }
5674        return (0);
5675}
5676
5677struct file *
5678pushfile(const char *name, int secret)
5679{
5680        struct file     *nfile;
5681
5682        if ((nfile = calloc(1, sizeof(struct file))) == NULL ||
5683            (nfile->name = strdup(name)) == NULL) {
5684                warn("malloc");
5685                return (NULL);
5686        }
5687        if (TAILQ_FIRST(&files) == NULL && strcmp(nfile->name, "-") == 0) {
5688                nfile->stream = stdin;
5689                free(nfile->name);
5690                if ((nfile->name = strdup("stdin")) == NULL) {
5691                        warn("strdup");
5692                        free(nfile);
5693                        return (NULL);
5694                }
5695        } else if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
5696                warn("%s", nfile->name);
5697                free(nfile->name);
5698                free(nfile);
5699                return (NULL);
5700        } else if (secret &&
5701            check_file_secrecy(fileno(nfile->stream), nfile->name)) {
5702                fclose(nfile->stream);
5703                free(nfile->name);
5704                free(nfile);
5705                return (NULL);
5706        }
5707        nfile->lineno = 1;
5708        TAILQ_INSERT_TAIL(&files, nfile, entry);
5709        return (nfile);
5710}
5711
5712int
5713popfile(void)
5714{
5715        struct file     *prev;
5716
5717        if ((prev = TAILQ_PREV(file, files, entry)) != NULL) {
5718                prev->errors += file->errors;
5719                TAILQ_REMOVE(&files, file, entry);
5720                fclose(file->stream);
5721                free(file->name);
5722                free(file);
5723                file = prev;
5724                return (0);
5725        }
5726        return (EOF);
5727}
5728
5729int
5730parse_config(char *filename, struct pfctl *xpf)
5731{
5732        int              errors = 0;
5733        struct sym      *sym;
5734
5735        pf = xpf;
5736        errors = 0;
5737        rulestate = PFCTL_STATE_NONE;
5738        returnicmpdefault = (ICMP_UNREACH << 8) | ICMP_UNREACH_PORT;
5739        returnicmp6default =
5740            (ICMP6_DST_UNREACH << 8) | ICMP6_DST_UNREACH_NOPORT;
5741        blockpolicy = PFRULE_DROP;
5742        require_order = 1;
5743
5744        if ((file = pushfile(filename, 0)) == NULL) {
5745                warn("cannot open the main config file!");
5746                return (-1);
5747        }
5748
5749        yyparse();
5750        errors = file->errors;
5751        popfile();
5752
5753        /* Free macros and check which have not been used. */
5754        while ((sym = TAILQ_FIRST(&symhead))) {
5755                if ((pf->opts & PF_OPT_VERBOSE2) && !sym->used)
5756                        fprintf(stderr, "warning: macro '%s' not "
5757                            "used\n", sym->nam);
5758                free(sym->nam);
5759                free(sym->val);
5760                TAILQ_REMOVE(&symhead, sym, entry);
5761                free(sym);
5762        }
5763
5764        return (errors ? -1 : 0);
5765}
5766
5767int
5768symset(const char *nam, const char *val, int persist)
5769{
5770        struct sym      *sym;
5771
5772        for (sym = TAILQ_FIRST(&symhead); sym && strcmp(nam, sym->nam);
5773            sym = TAILQ_NEXT(sym, entry))
5774                ;       /* nothing */
5775
5776        if (sym != NULL) {
5777                if (sym->persist == 1)
5778                        return (0);
5779                else {
5780                        free(sym->nam);
5781                        free(sym->val);
5782                        TAILQ_REMOVE(&symhead, sym, entry);
5783                        free(sym);
5784                }
5785        }
5786        if ((sym = calloc(1, sizeof(*sym))) == NULL)
5787                return (-1);
5788
5789        sym->nam = strdup(nam);
5790        if (sym->nam == NULL) {
5791                free(sym);
5792                return (-1);
5793        }
5794        sym->val = strdup(val);
5795        if (sym->val == NULL) {
5796                free(sym->nam);
5797                free(sym);
5798                return (-1);
5799        }
5800        sym->used = 0;
5801        sym->persist = persist;
5802        TAILQ_INSERT_TAIL(&symhead, sym, entry);
5803        return (0);
5804}
5805
5806int
5807pfctl_cmdline_symset(char *s)
5808{
5809        char    *sym, *val;
5810        int      ret;
5811
5812        if ((val = strrchr(s, '=')) == NULL)
5813                return (-1);
5814
5815        if ((sym = malloc(strlen(s) - strlen(val) + 1)) == NULL)
5816                err(1, "pfctl_cmdline_symset: malloc");
5817
5818        strlcpy(sym, s, strlen(s) - strlen(val) + 1);
5819
5820        ret = symset(sym, val + 1, 1);
5821        free(sym);
5822
5823        return (ret);
5824}
5825
5826char *
5827symget(const char *nam)
5828{
5829        struct sym      *sym;
5830
5831        TAILQ_FOREACH(sym, &symhead, entry)
5832                if (strcmp(nam, sym->nam) == 0) {
5833                        sym->used = 1;
5834                        return (sym->val);
5835                }
5836        return (NULL);
5837}
5838
5839void
5840mv_rules(struct pf_ruleset *src, struct pf_ruleset *dst)
5841{
5842        int i;
5843        struct pf_rule *r;
5844
5845        for (i = 0; i < PF_RULESET_MAX; ++i) {
5846                while ((r = TAILQ_FIRST(src->rules[i].active.ptr))
5847                    != NULL) {
5848                        TAILQ_REMOVE(src->rules[i].active.ptr, r, entries);
5849                        TAILQ_INSERT_TAIL(dst->rules[i].active.ptr, r, entries);
5850                        dst->anchor->match++;
5851                }
5852                src->anchor->match = 0;
5853                while ((r = TAILQ_FIRST(src->rules[i].inactive.ptr))
5854                    != NULL) {
5855                        TAILQ_REMOVE(src->rules[i].inactive.ptr, r, entries);
5856                        TAILQ_INSERT_TAIL(dst->rules[i].inactive.ptr,
5857                                r, entries);
5858                }
5859        }
5860}
5861
5862void
5863decide_address_family(struct node_host *n, sa_family_t *af)
5864{
5865        if (*af != 0 || n == NULL)
5866                return;
5867        *af = n->af;
5868        while ((n = n->next) != NULL) {
5869                if (n->af != *af) {
5870                        *af = 0;
5871                        return;
5872                }
5873        }
5874}
5875
5876void
5877remove_invalid_hosts(struct node_host **nh, sa_family_t *af)
5878{
5879        struct node_host        *n = *nh, *prev = NULL;
5880
5881        while (n != NULL) {
5882                if (*af && n->af && n->af != *af) {
5883                        /* unlink and free n */
5884                        struct node_host *next = n->next;
5885
5886                        /* adjust tail pointer */
5887                        if (n == (*nh)->tail)
5888                                (*nh)->tail = prev;
5889                        /* adjust previous node's next pointer */
5890                        if (prev == NULL)
5891                                *nh = next;
5892                        else
5893                                prev->next = next;
5894                        /* free node */
5895                        if (n->ifname != NULL)
5896                                free(n->ifname);
5897                        free(n);
5898                        n = next;
5899                } else {
5900                        if (n->af && !*af)
5901                                *af = n->af;
5902                        prev = n;
5903                        n = n->next;
5904                }
5905        }
5906}
5907
5908int
5909invalid_redirect(struct node_host *nh, sa_family_t af)
5910{
5911        if (!af) {
5912                struct node_host *n;
5913
5914                /* tables and dyniftl are ok without an address family */
5915                for (n = nh; n != NULL; n = n->next) {
5916                        if (n->addr.type != PF_ADDR_TABLE &&
5917                            n->addr.type != PF_ADDR_DYNIFTL) {
5918                                yyerror("address family not given and "
5919                                    "translation address expands to multiple "
5920                                    "address families");
5921                                return (1);
5922                        }
5923                }
5924        }
5925        if (nh == NULL) {
5926                yyerror("no translation address with matching address family "
5927                    "found.");
5928                return (1);
5929        }
5930        return (0);
5931}
5932
5933int
5934atoul(char *s, u_long *ulvalp)
5935{
5936        u_long   ulval;
5937        char    *ep;
5938
5939        errno = 0;
5940        ulval = strtoul(s, &ep, 0);
5941        if (s[0] == '\0' || *ep != '\0')
5942                return (-1);
5943        if (errno == ERANGE && ulval == ULONG_MAX)
5944                return (-1);
5945        *ulvalp = ulval;
5946        return (0);
5947}
5948
5949int
5950getservice(char *n)
5951{
5952        struct servent  *s;
5953        u_long           ulval;
5954
5955        if (atoul(n, &ulval) == 0) {
5956                if (ulval > 65535) {
5957                        yyerror("illegal port value %lu", ulval);
5958                        return (-1);
5959                }
5960                return (htons(ulval));
5961        } else {
5962                s = getservbyname(n, "tcp");
5963                if (s == NULL)
5964                        s = getservbyname(n, "udp");
5965                if (s == NULL) {
5966                        yyerror("unknown port %s", n);
5967                        return (-1);
5968                }
5969                return (s->s_port);
5970        }
5971}
5972
5973int
5974rule_label(struct pf_rule *r, char *s)
5975{
5976        if (s) {
5977                if (strlcpy(r->label, s, sizeof(r->label)) >=
5978                    sizeof(r->label)) {
5979                        yyerror("rule label too long (max %d chars)",
5980                            sizeof(r->label)-1);
5981                        return (-1);
5982                }
5983        }
5984        return (0);
5985}
5986
5987u_int16_t
5988parseicmpspec(char *w, sa_family_t af)
5989{
5990        const struct icmpcodeent        *p;
5991        u_long                           ulval;
5992        u_int8_t                         icmptype;
5993
5994        if (af == AF_INET)
5995                icmptype = returnicmpdefault >> 8;
5996        else
5997                icmptype = returnicmp6default >> 8;
5998
5999        if (atoul(w, &ulval) == -1) {
6000                if ((p = geticmpcodebyname(icmptype, w, af)) == NULL) {
6001                        yyerror("unknown icmp code %s", w);
6002                        return (0);
6003                }
6004                ulval = p->code;
6005        }
6006        if (ulval > 255) {
6007                yyerror("invalid icmp code %lu", ulval);
6008                return (0);
6009        }
6010        return (icmptype << 8 | ulval);
6011}
6012
6013int
6014parseport(char *port, struct range *r, int extensions)
6015{
6016        char    *p = strchr(port, ':');
6017
6018        if (p == NULL) {
6019                if ((r->a = getservice(port)) == -1)
6020                        return (-1);
6021                r->b = 0;
6022                r->t = PF_OP_NONE;
6023                return (0);
6024        }
6025        if ((extensions & PPORT_STAR) && !strcmp(p+1, "*")) {
6026                *p = 0;
6027                if ((r->a = getservice(port)) == -1)
6028                        return (-1);
6029                r->b = 0;
6030                r->t = PF_OP_IRG;
6031                return (0);
6032        }
6033        if ((extensions & PPORT_RANGE)) {
6034                *p++ = 0;
6035                if ((r->a = getservice(port)) == -1 ||
6036                    (r->b = getservice(p)) == -1)
6037                        return (-1);
6038                if (r->a == r->b) {
6039                        r->b = 0;
6040                        r->t = PF_OP_NONE;
6041                } else
6042                        r->t = PF_OP_RRG;
6043                return (0);
6044        }
6045        return (-1);
6046}
6047
6048int
6049pfctl_load_anchors(int dev, struct pfctl *pf, struct pfr_buffer *trans)
6050{
6051        struct loadanchors      *la;
6052
6053        TAILQ_FOREACH(la, &loadanchorshead, entries) {
6054                if (pf->opts & PF_OPT_VERBOSE)
6055                        fprintf(stderr, "\nLoading anchor %s from %s\n",
6056                            la->anchorname, la->filename);
6057                if (pfctl_rules(dev, la->filename, pf->opts, pf->optimize,
6058                    la->anchorname, trans) == -1)
6059                        return (-1);
6060        }
6061
6062        return (0);
6063}
6064
6065int
6066rt_tableid_max(void)
6067{
6068#ifdef __FreeBSD__
6069        int fibs;
6070        size_t l = sizeof(fibs);
6071
6072        if (sysctlbyname("net.fibs", &fibs, &l, NULL, 0) == -1)
6073                fibs = 16;      /* XXX RT_MAXFIBS, at least limit it some. */
6074        /*
6075         * As the OpenBSD code only compares > and not >= we need to adjust
6076         * here given we only accept values of 0..n and want to avoid #ifdefs
6077         * in the grammer.
6078         */
6079        return (fibs - 1);
6080#else
6081        return (RT_TABLEID_MAX);
6082#endif
6083}
Note: See TracBrowser for help on using the repository browser.