1 /* $ANTLR 2.7.7 (20100319): "pf.g" -> "PFCfgParser.cpp"$ */
2 #line 43 "pf.g"
3
4 // gets inserted before the antlr generated includes in the cpp
5 // file
6
7 #line 8 "PFCfgParser.cpp"
8 #include "PFCfgParser.hpp"
9 #include <antlr/NoViableAltException.hpp>
10 #include <antlr/SemanticException.hpp>
11 #include <antlr/ASTFactory.hpp>
12 #line 49 "pf.g"
13
14 // gets inserted after the antlr generated includes in the cpp
15 // file
16 #include <antlr/Token.hpp>
17 #include <antlr/TokenBuffer.hpp>
18
19 #line 20 "PFCfgParser.cpp"
20 #line 1 "pf.g"
21 #line 22 "PFCfgParser.cpp"
PFCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenBuffer & tokenBuf,int k)22 PFCfgParser::PFCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
23 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
24 {
25 }
26
PFCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenBuffer & tokenBuf)27 PFCfgParser::PFCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
28 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
29 {
30 }
31
PFCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenStream & lexer,int k)32 PFCfgParser::PFCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
33 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
34 {
35 }
36
PFCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenStream & lexer)37 PFCfgParser::PFCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
38 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
39 {
40 }
41
PFCfgParser(const ANTLR_USE_NAMESPACE (antlr)ParserSharedInputState & state)42 PFCfgParser::PFCfgParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
43 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
44 {
45 }
46
cfgfile()47 void PFCfgParser::cfgfile() {
48
49 try { // for error handling
50 { // ( ... )*
51 for (;;) {
52 switch ( LA(1)) {
53 case COMMENT_START:
54 {
55 comment();
56 break;
57 }
58 case INCLUDE_COMMAND:
59 {
60 include_command();
61 break;
62 }
63 case WORD:
64 {
65 macro_definition();
66 break;
67 }
68 case ALTQ:
69 {
70 altq_rule();
71 break;
72 }
73 case ANTISPOOF:
74 {
75 antispoof_rule();
76 break;
77 }
78 case QUEUE:
79 {
80 queue_rule();
81 break;
82 }
83 case SET:
84 {
85 set_rule();
86 break;
87 }
88 case SCRUB:
89 {
90 scrub_rule();
91 break;
92 }
93 case MATCH:
94 {
95 match_rule();
96 break;
97 }
98 case TABLE:
99 {
100 table_rule();
101 break;
102 }
103 case NO:
104 {
105 no_nat_rule();
106 break;
107 }
108 case NAT:
109 {
110 nat_rule();
111 break;
112 }
113 case RDR:
114 {
115 rdr_rule();
116 break;
117 }
118 case BINAT:
119 {
120 binat_rule();
121 break;
122 }
123 case PASS:
124 {
125 pass_rule();
126 break;
127 }
128 case BLOCK:
129 {
130 block_rule();
131 break;
132 }
133 case NEWLINE:
134 {
135 match(NEWLINE);
136 break;
137 }
138 default:
139 {
140 goto _loop3;
141 }
142 }
143 }
144 _loop3:;
145 } // ( ... )*
146 }
147 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
148 reportError(ex);
149 recover(ex,_tokenSet_0);
150 }
151 }
152
comment()153 void PFCfgParser::comment() {
154
155 try { // for error handling
156 match(COMMENT_START);
157 #line 159 "pf.g"
158
159 QStringList str;
160 while (LA(1) != ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE &&
161 LA(1) != NEWLINE)
162 {
163 str << QString::fromUtf8(LT(1)->getText().c_str());
164 consume();
165 }
166 importer->last_comment << str.join(" ");
167
168 #line 169 "PFCfgParser.cpp"
169 }
170 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
171 reportError(ex);
172 recover(ex,_tokenSet_1);
173 }
174 }
175
include_command()176 void PFCfgParser::include_command() {
177
178 try { // for error handling
179 match(INCLUDE_COMMAND);
180 #line 173 "pf.g"
181
182 importer->clear();
183 importer->setCurrentLineNumber(LT(0)->getLine());
184 importer->addMessageToLog(
185 QString("Error: import of 'include' commands is not supported."));
186 consumeUntil(NEWLINE);
187
188 #line 189 "PFCfgParser.cpp"
189 }
190 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
191 reportError(ex);
192 recover(ex,_tokenSet_1);
193 }
194 }
195
macro_definition()196 void PFCfgParser::macro_definition() {
197
198 try { // for error handling
199 match(WORD);
200 match(EQUAL);
201 #line 184 "pf.g"
202
203 importer->clear();
204 importer->setCurrentLineNumber(LT(0)->getLine());
205 consumeUntil(NEWLINE);
206
207 #line 208 "PFCfgParser.cpp"
208 }
209 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
210 reportError(ex);
211 recover(ex,_tokenSet_1);
212 }
213 }
214
altq_rule()215 void PFCfgParser::altq_rule() {
216
217 try { // for error handling
218 match(ALTQ);
219 #line 204 "pf.g"
220
221 importer->clear();
222 importer->setCurrentLineNumber(LT(0)->getLine());
223 importer->error_tracker->registerError(
224 QString("import of 'altq' commands is not supported."));
225 consumeUntil(NEWLINE);
226
227 #line 228 "PFCfgParser.cpp"
228 }
229 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
230 reportError(ex);
231 recover(ex,_tokenSet_1);
232 }
233 }
234
antispoof_rule()235 void PFCfgParser::antispoof_rule() {
236
237 try { // for error handling
238 match(ANTISPOOF);
239 #line 193 "pf.g"
240
241 importer->clear();
242 importer->setCurrentLineNumber(LT(0)->getLine());
243 importer->addMessageToLog(
244 QString("Warning: import of 'antispoof' commands has not been implemented yet."));
245 consumeUntil(NEWLINE);
246
247 #line 248 "PFCfgParser.cpp"
248 }
249 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
250 reportError(ex);
251 recover(ex,_tokenSet_1);
252 }
253 }
254
queue_rule()255 void PFCfgParser::queue_rule() {
256
257 try { // for error handling
258 match(QUEUE);
259 #line 215 "pf.g"
260
261 importer->clear();
262 importer->setCurrentLineNumber(LT(0)->getLine());
263 importer->error_tracker->registerError(
264 QString("import of 'queue' commands is not supported."));
265 consumeUntil(NEWLINE);
266
267 #line 268 "PFCfgParser.cpp"
268 }
269 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
270 reportError(ex);
271 recover(ex,_tokenSet_1);
272 }
273 }
274
set_rule()275 void PFCfgParser::set_rule() {
276
277 try { // for error handling
278 match(SET);
279 #line 226 "pf.g"
280
281 importer->clear();
282 importer->setCurrentLineNumber(LT(0)->getLine());
283
284 #line 285 "PFCfgParser.cpp"
285 {
286 switch ( LA(1)) {
287 case TIMEOUT:
288 {
289 set_timeout();
290 break;
291 }
292 case 14:
293 {
294 set_ruleset_optimization();
295 break;
296 }
297 case LITERAL_optimization:
298 {
299 set_optimization();
300 break;
301 }
302 case LITERAL_limit:
303 {
304 set_limit();
305 break;
306 }
307 case LITERAL_loginterface:
308 {
309 set_loginterface();
310 break;
311 }
312 case 23:
313 {
314 set_block_policy();
315 break;
316 }
317 case 26:
318 {
319 set_state_policy();
320 break;
321 }
322 case 29:
323 {
324 set_state_defaults();
325 break;
326 }
327 case 30:
328 {
329 set_require_order();
330 break;
331 }
332 case LITERAL_fingerprints:
333 {
334 set_fingerprints();
335 break;
336 }
337 case LITERAL_skip:
338 {
339 set_skip();
340 break;
341 }
342 case LITERAL_debug:
343 {
344 set_debug();
345 break;
346 }
347 case LITERAL_reassemble:
348 {
349 set_reassemble();
350 break;
351 }
352 case LITERAL_hostid:
353 {
354 set_hostid();
355 break;
356 }
357 default:
358 {
359 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
360 }
361 }
362 }
363 }
364 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
365 reportError(ex);
366 recover(ex,_tokenSet_1);
367 }
368 }
369
scrub_rule()370 void PFCfgParser::scrub_rule() {
371
372 try { // for error handling
373 match(SCRUB);
374 #line 525 "pf.g"
375
376 importer->clear();
377 importer->setCurrentLineNumber(LT(0)->getLine());
378 importer->newPolicyRule();
379 importer->action = "scrub";
380 *dbg << LT(1)->getLine() << ":" << " scrub ";
381
382 #line 383 "PFCfgParser.cpp"
383 rule_extended();
384 match(NEWLINE);
385 }
386 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
387 reportError(ex);
388 recover(ex,_tokenSet_1);
389 }
390 }
391
match_rule()392 void PFCfgParser::match_rule() {
393
394 try { // for error handling
395 match(MATCH);
396 #line 540 "pf.g"
397
398 importer->clear();
399 importer->setCurrentLineNumber(LT(0)->getLine());
400 importer->newPolicyRule();
401 importer->action = "match";
402 *dbg << LT(1)->getLine() << ":" << " match ";
403
404 #line 405 "PFCfgParser.cpp"
405 rule_extended();
406 #line 548 "pf.g"
407
408 if ( ! importer->scrub_rule) importer->pushRule();
409
410 #line 411 "PFCfgParser.cpp"
411 match(NEWLINE);
412 }
413 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
414 reportError(ex);
415 recover(ex,_tokenSet_1);
416 }
417 }
418
table_rule()419 void PFCfgParser::table_rule() {
420 ANTLR_USE_NAMESPACE(antlr)RefToken name = ANTLR_USE_NAMESPACE(antlr)nullToken;
421 ANTLR_USE_NAMESPACE(antlr)RefToken file = ANTLR_USE_NAMESPACE(antlr)nullToken;
422
423 try { // for error handling
424 match(TABLE);
425 #line 557 "pf.g"
426
427 importer->clear();
428 importer->setCurrentLineNumber(LT(0)->getLine());
429
430 #line 431 "PFCfgParser.cpp"
431 match(LESS_THAN);
432 name = LT(1);
433 match(WORD);
434 match(GREATER_THAN);
435 {
436 switch ( LA(1)) {
437 case PERSIST:
438 {
439 match(PERSIST);
440 break;
441 }
442 case NEWLINE:
443 case OPENING_BRACE:
444 case CONST_WORD:
445 case COUNTERS:
446 case FILE:
447 {
448 break;
449 }
450 default:
451 {
452 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
453 }
454 }
455 }
456 {
457 switch ( LA(1)) {
458 case CONST_WORD:
459 {
460 match(CONST_WORD);
461 #line 569 "pf.g"
462
463 importer->addMessageToLog(
464 QString("Warning: attribute \"const\" will be dropped from table configuration since this attribute is not supported at this time"));
465
466 #line 467 "PFCfgParser.cpp"
467 break;
468 }
469 case NEWLINE:
470 case OPENING_BRACE:
471 case COUNTERS:
472 case FILE:
473 {
474 break;
475 }
476 default:
477 {
478 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
479 }
480 }
481 }
482 {
483 switch ( LA(1)) {
484 case COUNTERS:
485 {
486 match(COUNTERS);
487 #line 576 "pf.g"
488
489 importer->addMessageToLog(
490 QString("Warning: attribute \"counters\" will be dropped from table configuration since this attribute is not supported at this time"));
491
492 #line 493 "PFCfgParser.cpp"
493 break;
494 }
495 case NEWLINE:
496 case OPENING_BRACE:
497 case FILE:
498 {
499 break;
500 }
501 default:
502 {
503 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
504 }
505 }
506 }
507 {
508 switch ( LA(1)) {
509 case FILE:
510 {
511 match(FILE);
512 file = LT(1);
513 match(STRING);
514 #line 583 "pf.g"
515
516 importer->newAddressTableObject(
517 name->getText(), file->getText());
518
519 #line 520 "PFCfgParser.cpp"
520 break;
521 }
522 case OPENING_BRACE:
523 {
524 match(OPENING_BRACE);
525 tableaddr_spec();
526 { // ( ... )*
527 for (;;) {
528 if ((_tokenSet_2.member(LA(1)))) {
529 {
530 switch ( LA(1)) {
531 case COMMA:
532 {
533 match(COMMA);
534 break;
535 }
536 case WORD:
537 case INT_CONST:
538 case EXLAMATION:
539 case SELF:
540 case IPV4:
541 case NUMBER:
542 {
543 break;
544 }
545 default:
546 {
547 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
548 }
549 }
550 }
551 tableaddr_spec();
552 }
553 else {
554 goto _loop58;
555 }
556
557 }
558 _loop58:;
559 } // ( ... )*
560 match(CLOSING_BRACE);
561 #line 595 "pf.g"
562
563 importer->newAddressTableObject(
564 name->getText(), importer->tmp_group);
565
566 #line 567 "PFCfgParser.cpp"
567 break;
568 }
569 case NEWLINE:
570 {
571 match(NEWLINE);
572 #line 601 "pf.g"
573
574 // Special case: table definition without file name or list of addresses.
575 // Create run-time AddressTable object with name but no file spec.
576 importer->newAddressTableObject(name->getText(), "");
577
578 #line 579 "PFCfgParser.cpp"
579 break;
580 }
581 default:
582 {
583 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
584 }
585 }
586 }
587 }
588 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
589 reportError(ex);
590 recover(ex,_tokenSet_1);
591 }
592 }
593
no_nat_rule()594 void PFCfgParser::no_nat_rule() {
595
596 try { // for error handling
597 match(NO);
598 #line 676 "pf.g"
599
600 importer->clear();
601 importer->setCurrentLineNumber(LT(0)->getLine());
602 importer->newNATRule();
603 importer->action = "nonat";
604 *dbg << LT(1)->getLine() << ":" << " nonat ";
605
606 #line 607 "PFCfgParser.cpp"
607 {
608 switch ( LA(1)) {
609 case NAT:
610 {
611 nat_rule();
612 break;
613 }
614 case RDR:
615 {
616 rdr_rule();
617 break;
618 }
619 default:
620 {
621 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
622 }
623 }
624 }
625 }
626 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
627 reportError(ex);
628 recover(ex,_tokenSet_1);
629 }
630 }
631
nat_rule()632 void PFCfgParser::nat_rule() {
633
634 try { // for error handling
635 match(NAT);
636 #line 693 "pf.g"
637
638 if ( importer->action != "nonat" )
639 {
640 importer->clear();
641 importer->setCurrentLineNumber(LT(0)->getLine());
642 importer->newNATRule();
643 importer->action = "nat";
644 *dbg << LT(1)->getLine() << ":" << " nat ";
645 }
646
647 #line 648 "PFCfgParser.cpp"
648 {
649 switch ( LA(1)) {
650 case PASS:
651 {
652 match(PASS);
653 #line 705 "pf.g"
654
655 importer->error_tracker->registerError(
656 QString("import of 'nat pass' commands is not supported."));
657
658 #line 659 "PFCfgParser.cpp"
659 {
660 switch ( LA(1)) {
661 case LOG:
662 {
663 logging();
664 break;
665 }
666 case NEWLINE:
667 case ON:
668 case EXLAMATION:
669 case MINUS:
670 case ALL:
671 case TO:
672 case INET:
673 case INET6:
674 case PROTO:
675 case FROM:
676 case TAGGED:
677 case TAG:
678 {
679 break;
680 }
681 default:
682 {
683 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
684 }
685 }
686 }
687 break;
688 }
689 case NEWLINE:
690 case ON:
691 case EXLAMATION:
692 case MINUS:
693 case ALL:
694 case TO:
695 case INET:
696 case INET6:
697 case PROTO:
698 case FROM:
699 case TAGGED:
700 case TAG:
701 {
702 break;
703 }
704 default:
705 {
706 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
707 }
708 }
709 }
710 {
711 switch ( LA(1)) {
712 case ON:
713 {
714 intrface();
715 break;
716 }
717 case NEWLINE:
718 case EXLAMATION:
719 case MINUS:
720 case ALL:
721 case TO:
722 case INET:
723 case INET6:
724 case PROTO:
725 case FROM:
726 case TAGGED:
727 case TAG:
728 {
729 break;
730 }
731 default:
732 {
733 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
734 }
735 }
736 }
737 {
738 switch ( LA(1)) {
739 case INET:
740 case INET6:
741 {
742 address_family();
743 break;
744 }
745 case NEWLINE:
746 case EXLAMATION:
747 case MINUS:
748 case ALL:
749 case TO:
750 case PROTO:
751 case FROM:
752 case TAGGED:
753 case TAG:
754 {
755 break;
756 }
757 default:
758 {
759 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
760 }
761 }
762 }
763 {
764 switch ( LA(1)) {
765 case PROTO:
766 {
767 protospec();
768 break;
769 }
770 case NEWLINE:
771 case EXLAMATION:
772 case MINUS:
773 case ALL:
774 case TO:
775 case FROM:
776 case TAGGED:
777 case TAG:
778 {
779 break;
780 }
781 default:
782 {
783 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
784 }
785 }
786 }
787 hosts();
788 {
789 switch ( LA(1)) {
790 case EXLAMATION:
791 case TAGGED:
792 {
793 tagged();
794 break;
795 }
796 case NEWLINE:
797 case MINUS:
798 case TAG:
799 {
800 break;
801 }
802 default:
803 {
804 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
805 }
806 }
807 }
808 {
809 switch ( LA(1)) {
810 case TAG:
811 {
812 tag_clause();
813 #line 718 "pf.g"
814
815 importer->error_tracker->registerError(
816 QString("import of 'nat ... tag' commands is not supported."));
817
818 #line 819 "PFCfgParser.cpp"
819 break;
820 }
821 case NEWLINE:
822 case MINUS:
823 {
824 break;
825 }
826 default:
827 {
828 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
829 }
830 }
831 }
832 {
833 switch ( LA(1)) {
834 case MINUS:
835 {
836 match(MINUS);
837 match(GREATER_THAN);
838 {
839 switch ( LA(1)) {
840 case WORD:
841 case IPV4:
842 case OPENING_PAREN:
843 {
844 redirhost();
845 break;
846 }
847 case OPENING_BRACE:
848 {
849 redirhost_list();
850 break;
851 }
852 default:
853 {
854 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
855 }
856 }
857 }
858 #line 726 "pf.g"
859
860 importer->nat_group = importer->tmp_group;
861
862 #line 863 "PFCfgParser.cpp"
863 {
864 switch ( LA(1)) {
865 case PORT:
866 {
867 portspec();
868 #line 731 "pf.g"
869
870 importer->nat_port_group = importer->tmp_port_group;
871
872 #line 873 "PFCfgParser.cpp"
873 break;
874 }
875 case NEWLINE:
876 case STATIC_PORT:
877 case BITMASK:
878 case RANDOM:
879 case SOURCE_HASH:
880 case ROUND_ROBIN:
881 {
882 break;
883 }
884 default:
885 {
886 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
887 }
888 }
889 }
890 {
891 switch ( LA(1)) {
892 case BITMASK:
893 case RANDOM:
894 case SOURCE_HASH:
895 case ROUND_ROBIN:
896 {
897 pooltype();
898 break;
899 }
900 case NEWLINE:
901 case STATIC_PORT:
902 {
903 break;
904 }
905 default:
906 {
907 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
908 }
909 }
910 }
911 {
912 switch ( LA(1)) {
913 case STATIC_PORT:
914 {
915 match(STATIC_PORT);
916 #line 737 "pf.g"
917 importer->nat_rule_opt_2 = "static-port";
918 #line 919 "PFCfgParser.cpp"
919 break;
920 }
921 case NEWLINE:
922 {
923 break;
924 }
925 default:
926 {
927 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
928 }
929 }
930 }
931 break;
932 }
933 case NEWLINE:
934 {
935 break;
936 }
937 default:
938 {
939 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
940 }
941 }
942 }
943 #line 740 "pf.g"
944
945 importer->pushRule();
946
947 #line 948 "PFCfgParser.cpp"
948 match(NEWLINE);
949 }
950 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
951 reportError(ex);
952 recover(ex,_tokenSet_1);
953 }
954 }
955
rdr_rule()956 void PFCfgParser::rdr_rule() {
957
958 try { // for error handling
959 match(RDR);
960 #line 749 "pf.g"
961
962 if ( importer->action != "nonat" )
963 {
964 importer->clear();
965 importer->setCurrentLineNumber(LT(0)->getLine());
966 importer->newNATRule();
967 importer->action = "rdr";
968 *dbg << LT(1)->getLine() << ":" << " rdr ";
969 }
970
971 #line 972 "PFCfgParser.cpp"
972 {
973 switch ( LA(1)) {
974 case PASS:
975 {
976 match(PASS);
977 #line 761 "pf.g"
978
979 importer->error_tracker->registerError(
980 QString("import of 'nat pass' commands is not supported."));
981
982 #line 983 "PFCfgParser.cpp"
983 {
984 switch ( LA(1)) {
985 case LOG:
986 {
987 logging();
988 break;
989 }
990 case NEWLINE:
991 case ON:
992 case EXLAMATION:
993 case MINUS:
994 case ALL:
995 case TO:
996 case INET:
997 case INET6:
998 case PROTO:
999 case FROM:
1000 case TAGGED:
1001 case TAG:
1002 {
1003 break;
1004 }
1005 default:
1006 {
1007 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1008 }
1009 }
1010 }
1011 break;
1012 }
1013 case NEWLINE:
1014 case ON:
1015 case EXLAMATION:
1016 case MINUS:
1017 case ALL:
1018 case TO:
1019 case INET:
1020 case INET6:
1021 case PROTO:
1022 case FROM:
1023 case TAGGED:
1024 case TAG:
1025 {
1026 break;
1027 }
1028 default:
1029 {
1030 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1031 }
1032 }
1033 }
1034 {
1035 switch ( LA(1)) {
1036 case ON:
1037 {
1038 intrface();
1039 break;
1040 }
1041 case NEWLINE:
1042 case EXLAMATION:
1043 case MINUS:
1044 case ALL:
1045 case TO:
1046 case INET:
1047 case INET6:
1048 case PROTO:
1049 case FROM:
1050 case TAGGED:
1051 case TAG:
1052 {
1053 break;
1054 }
1055 default:
1056 {
1057 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1058 }
1059 }
1060 }
1061 {
1062 switch ( LA(1)) {
1063 case INET:
1064 case INET6:
1065 {
1066 address_family();
1067 break;
1068 }
1069 case NEWLINE:
1070 case EXLAMATION:
1071 case MINUS:
1072 case ALL:
1073 case TO:
1074 case PROTO:
1075 case FROM:
1076 case TAGGED:
1077 case TAG:
1078 {
1079 break;
1080 }
1081 default:
1082 {
1083 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1084 }
1085 }
1086 }
1087 {
1088 switch ( LA(1)) {
1089 case PROTO:
1090 {
1091 protospec();
1092 break;
1093 }
1094 case NEWLINE:
1095 case EXLAMATION:
1096 case MINUS:
1097 case ALL:
1098 case TO:
1099 case FROM:
1100 case TAGGED:
1101 case TAG:
1102 {
1103 break;
1104 }
1105 default:
1106 {
1107 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1108 }
1109 }
1110 }
1111 hosts();
1112 {
1113 switch ( LA(1)) {
1114 case EXLAMATION:
1115 case TAGGED:
1116 {
1117 tagged();
1118 break;
1119 }
1120 case NEWLINE:
1121 case MINUS:
1122 case TAG:
1123 {
1124 break;
1125 }
1126 default:
1127 {
1128 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1129 }
1130 }
1131 }
1132 {
1133 switch ( LA(1)) {
1134 case TAG:
1135 {
1136 tag_clause();
1137 #line 774 "pf.g"
1138
1139 importer->error_tracker->registerError(
1140 QString("import of 'nat ... tag' commands is not supported."));
1141
1142 #line 1143 "PFCfgParser.cpp"
1143 break;
1144 }
1145 case NEWLINE:
1146 case MINUS:
1147 {
1148 break;
1149 }
1150 default:
1151 {
1152 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1153 }
1154 }
1155 }
1156 {
1157 switch ( LA(1)) {
1158 case MINUS:
1159 {
1160 match(MINUS);
1161 match(GREATER_THAN);
1162 {
1163 switch ( LA(1)) {
1164 case WORD:
1165 case IPV4:
1166 case OPENING_PAREN:
1167 {
1168 redirhost();
1169 break;
1170 }
1171 case OPENING_BRACE:
1172 {
1173 redirhost_list();
1174 break;
1175 }
1176 default:
1177 {
1178 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1179 }
1180 }
1181 }
1182 #line 782 "pf.g"
1183
1184 importer->nat_group = importer->tmp_group;
1185
1186 #line 1187 "PFCfgParser.cpp"
1187 {
1188 switch ( LA(1)) {
1189 case PORT:
1190 {
1191 portspec();
1192 #line 787 "pf.g"
1193
1194 importer->nat_port_group = importer->tmp_port_group;
1195
1196 #line 1197 "PFCfgParser.cpp"
1197 break;
1198 }
1199 case NEWLINE:
1200 case BITMASK:
1201 case RANDOM:
1202 case SOURCE_HASH:
1203 case ROUND_ROBIN:
1204 {
1205 break;
1206 }
1207 default:
1208 {
1209 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1210 }
1211 }
1212 }
1213 {
1214 switch ( LA(1)) {
1215 case BITMASK:
1216 case RANDOM:
1217 case SOURCE_HASH:
1218 case ROUND_ROBIN:
1219 {
1220 pooltype();
1221 break;
1222 }
1223 case NEWLINE:
1224 {
1225 break;
1226 }
1227 default:
1228 {
1229 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1230 }
1231 }
1232 }
1233 break;
1234 }
1235 case NEWLINE:
1236 {
1237 break;
1238 }
1239 default:
1240 {
1241 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1242 }
1243 }
1244 }
1245 #line 793 "pf.g"
1246
1247 importer->pushRule();
1248
1249 #line 1250 "PFCfgParser.cpp"
1250 match(NEWLINE);
1251 }
1252 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1253 reportError(ex);
1254 recover(ex,_tokenSet_1);
1255 }
1256 }
1257
binat_rule()1258 void PFCfgParser::binat_rule() {
1259
1260 try { // for error handling
1261 match(BINAT);
1262 #line 925 "pf.g"
1263
1264 importer->clear();
1265 importer->setCurrentLineNumber(LT(0)->getLine());
1266 importer->error_tracker->registerError(
1267 QString("import of 'binat' commands is not supported."));
1268 consumeUntil(NEWLINE);
1269
1270 #line 1271 "PFCfgParser.cpp"
1271 }
1272 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1273 reportError(ex);
1274 recover(ex,_tokenSet_1);
1275 }
1276 }
1277
pass_rule()1278 void PFCfgParser::pass_rule() {
1279
1280 try { // for error handling
1281 match(PASS);
1282 #line 948 "pf.g"
1283
1284 importer->clear();
1285 importer->setCurrentLineNumber(LT(0)->getLine());
1286 importer->newPolicyRule();
1287 importer->action = "pass";
1288 *dbg << LT(1)->getLine() << ":" << " pass ";
1289
1290 #line 1291 "PFCfgParser.cpp"
1291 rule_extended();
1292 #line 956 "pf.g"
1293
1294 importer->pushRule();
1295
1296 #line 1297 "PFCfgParser.cpp"
1297 match(NEWLINE);
1298 }
1299 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1300 reportError(ex);
1301 recover(ex,_tokenSet_1);
1302 }
1303 }
1304
block_rule()1305 void PFCfgParser::block_rule() {
1306
1307 try { // for error handling
1308 match(BLOCK);
1309 #line 963 "pf.g"
1310
1311 importer->clear();
1312 importer->setCurrentLineNumber(LT(0)->getLine());
1313 importer->newPolicyRule();
1314 importer->action = "block";
1315 *dbg << LT(1)->getLine() << ":" << " block ";
1316
1317 #line 1318 "PFCfgParser.cpp"
1318 {
1319 switch ( LA(1)) {
1320 case DROP:
1321 case RETURN:
1322 case RETURN_RST:
1323 case RETURN_ICMP:
1324 case RETURN_ICMP6:
1325 {
1326 block_return();
1327 break;
1328 }
1329 case NEWLINE:
1330 case QUEUE:
1331 case ON:
1332 case LITERAL_reassemble:
1333 case SCRUB:
1334 case EXLAMATION:
1335 case NO:
1336 case OPENING_PAREN:
1337 case IN_WORD:
1338 case OUT_WORD:
1339 case LOG:
1340 case QUICK:
1341 case ALL:
1342 case USER:
1343 case TO:
1344 case INET:
1345 case INET6:
1346 case PROTO:
1347 case FROM:
1348 case ROUTE_TO:
1349 case REPLY_TO:
1350 case DUP_TO:
1351 case GROUP:
1352 case LITERAL_fragment:
1353 case 146:
1354 case 147:
1355 case 148:
1356 case 149:
1357 case FLAGS:
1358 case ICMP_TYPE:
1359 case ICMP6_TYPE:
1360 case TAGGED:
1361 case TAG:
1362 case KEEP:
1363 case MODULATE:
1364 case SYNPROXY:
1365 case LABEL:
1366 {
1367 break;
1368 }
1369 default:
1370 {
1371 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1372 }
1373 }
1374 }
1375 rule_extended();
1376 #line 972 "pf.g"
1377
1378 importer->pushRule();
1379
1380 #line 1381 "PFCfgParser.cpp"
1381 match(NEWLINE);
1382 }
1383 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1384 reportError(ex);
1385 recover(ex,_tokenSet_1);
1386 }
1387 }
1388
set_timeout()1389 void PFCfgParser::set_timeout() {
1390
1391 try { // for error handling
1392 match(TIMEOUT);
1393 {
1394 switch ( LA(1)) {
1395 case 40:
1396 case 41:
1397 case 42:
1398 case 43:
1399 case 44:
1400 case 45:
1401 case 46:
1402 case 47:
1403 case 48:
1404 case 49:
1405 case 50:
1406 case 51:
1407 case 52:
1408 case 53:
1409 case LITERAL_frag:
1410 case LITERAL_interval:
1411 case 56:
1412 case 57:
1413 case 58:
1414 {
1415 timeout_def();
1416 break;
1417 }
1418 case OPENING_BRACE:
1419 {
1420 timeout_def_list();
1421 break;
1422 }
1423 default:
1424 {
1425 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1426 }
1427 }
1428 }
1429 }
1430 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1431 reportError(ex);
1432 recover(ex,_tokenSet_1);
1433 }
1434 }
1435
set_ruleset_optimization()1436 void PFCfgParser::set_ruleset_optimization() {
1437
1438 try { // for error handling
1439 match(14);
1440 #line 269 "pf.g"
1441
1442 importer->clear();
1443 importer->setCurrentLineNumber(LT(0)->getLine());
1444 importer->addMessageToLog(
1445 QString("Error: import of 'set ruleset-optimization' commands is not supported."));
1446 consumeUntil(NEWLINE);
1447
1448 #line 1449 "PFCfgParser.cpp"
1449 }
1450 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1451 reportError(ex);
1452 recover(ex,_tokenSet_1);
1453 }
1454 }
1455
set_optimization()1456 void PFCfgParser::set_optimization() {
1457
1458 try { // for error handling
1459 match(LITERAL_optimization);
1460 {
1461 switch ( LA(1)) {
1462 case LITERAL_aggressive:
1463 {
1464 match(LITERAL_aggressive);
1465 break;
1466 }
1467 case LITERAL_conservative:
1468 {
1469 match(LITERAL_conservative);
1470 break;
1471 }
1472 case 18:
1473 {
1474 match(18);
1475 break;
1476 }
1477 case LITERAL_normal:
1478 {
1479 match(LITERAL_normal);
1480 break;
1481 }
1482 case LITERAL_satellite:
1483 {
1484 match(LITERAL_satellite);
1485 break;
1486 }
1487 default:
1488 {
1489 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1490 }
1491 }
1492 }
1493 #line 291 "pf.g"
1494 importer->set_optimization = LT(0)->getText();
1495 #line 1496 "PFCfgParser.cpp"
1496 }
1497 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1498 reportError(ex);
1499 recover(ex,_tokenSet_1);
1500 }
1501 }
1502
set_limit()1503 void PFCfgParser::set_limit() {
1504
1505 try { // for error handling
1506 match(LITERAL_limit);
1507 {
1508 switch ( LA(1)) {
1509 case LITERAL_frags:
1510 case LITERAL_states:
1511 case 62:
1512 case LITERAL_tables:
1513 case 64:
1514 {
1515 limit_def();
1516 break;
1517 }
1518 case OPENING_BRACE:
1519 {
1520 limit_def_list();
1521 break;
1522 }
1523 default:
1524 {
1525 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1526 }
1527 }
1528 }
1529 }
1530 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1531 reportError(ex);
1532 recover(ex,_tokenSet_1);
1533 }
1534 }
1535
set_loginterface()1536 void PFCfgParser::set_loginterface() {
1537
1538 try { // for error handling
1539 match(LITERAL_loginterface);
1540 #line 302 "pf.g"
1541
1542 importer->clear();
1543 importer->setCurrentLineNumber(LT(0)->getLine());
1544 importer->addMessageToLog(
1545 QString("Error: import of 'set loginterface' commands is not supported."));
1546 consumeUntil(NEWLINE);
1547
1548 #line 1549 "PFCfgParser.cpp"
1549 }
1550 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1551 reportError(ex);
1552 recover(ex,_tokenSet_1);
1553 }
1554 }
1555
set_block_policy()1556 void PFCfgParser::set_block_policy() {
1557
1558 try { // for error handling
1559 match(23);
1560 {
1561 switch ( LA(1)) {
1562 case DROP:
1563 {
1564 match(DROP);
1565 break;
1566 }
1567 case RETURN:
1568 {
1569 match(RETURN);
1570 break;
1571 }
1572 default:
1573 {
1574 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1575 }
1576 }
1577 }
1578 #line 314 "pf.g"
1579 importer->set_block_policy = LT(0)->getText();
1580 #line 1581 "PFCfgParser.cpp"
1581 }
1582 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1583 reportError(ex);
1584 recover(ex,_tokenSet_1);
1585 }
1586 }
1587
set_state_policy()1588 void PFCfgParser::set_state_policy() {
1589
1590 try { // for error handling
1591 match(26);
1592 {
1593 switch ( LA(1)) {
1594 case 27:
1595 {
1596 match(27);
1597 break;
1598 }
1599 case LITERAL_floating:
1600 {
1601 match(LITERAL_floating);
1602 break;
1603 }
1604 default:
1605 {
1606 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1607 }
1608 }
1609 }
1610 #line 320 "pf.g"
1611 importer->set_state_policy = LT(0)->getText();
1612 #line 1613 "PFCfgParser.cpp"
1613 }
1614 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1615 reportError(ex);
1616 recover(ex,_tokenSet_1);
1617 }
1618 }
1619
set_state_defaults()1620 void PFCfgParser::set_state_defaults() {
1621
1622 try { // for error handling
1623 match(29);
1624 #line 326 "pf.g"
1625
1626 importer->clear();
1627 importer->setCurrentLineNumber(LT(0)->getLine());
1628 importer->addMessageToLog(
1629 QString("Error: import of 'set state-defaults' commands is not supported."));
1630 consumeUntil(NEWLINE);
1631
1632 #line 1633 "PFCfgParser.cpp"
1633 }
1634 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1635 reportError(ex);
1636 recover(ex,_tokenSet_1);
1637 }
1638 }
1639
set_require_order()1640 void PFCfgParser::set_require_order() {
1641
1642 try { // for error handling
1643 match(30);
1644 #line 338 "pf.g"
1645
1646 importer->clear();
1647 importer->setCurrentLineNumber(LT(0)->getLine());
1648 importer->addMessageToLog(
1649 QString("Error: import of 'set require-order' commands is not supported."));
1650 consumeUntil(NEWLINE);
1651
1652 #line 1653 "PFCfgParser.cpp"
1653 }
1654 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1655 reportError(ex);
1656 recover(ex,_tokenSet_1);
1657 }
1658 }
1659
set_fingerprints()1660 void PFCfgParser::set_fingerprints() {
1661
1662 try { // for error handling
1663 match(LITERAL_fingerprints);
1664 #line 350 "pf.g"
1665
1666 importer->clear();
1667 importer->setCurrentLineNumber(LT(0)->getLine());
1668 importer->addMessageToLog(
1669 QString("Error: import of 'set fingerprints' commands is not supported."));
1670 consumeUntil(NEWLINE);
1671
1672 #line 1673 "PFCfgParser.cpp"
1673 }
1674 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1675 reportError(ex);
1676 recover(ex,_tokenSet_1);
1677 }
1678 }
1679
set_skip()1680 void PFCfgParser::set_skip() {
1681
1682 try { // for error handling
1683 match(LITERAL_skip);
1684 match(ON);
1685 skip_def();
1686 }
1687 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1688 reportError(ex);
1689 recover(ex,_tokenSet_1);
1690 }
1691 }
1692
set_debug()1693 void PFCfgParser::set_debug() {
1694
1695 try { // for error handling
1696 match(LITERAL_debug);
1697 match(WORD);
1698 #line 386 "pf.g"
1699
1700 importer->set_debug = LT(0)->getText();
1701
1702 #line 1703 "PFCfgParser.cpp"
1703 }
1704 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1705 reportError(ex);
1706 recover(ex,_tokenSet_1);
1707 }
1708 }
1709
set_reassemble()1710 void PFCfgParser::set_reassemble() {
1711
1712 try { // for error handling
1713 match(LITERAL_reassemble);
1714 #line 394 "pf.g"
1715
1716 importer->clear();
1717 importer->setCurrentLineNumber(LT(0)->getLine());
1718 importer->addMessageToLog(
1719 QString("Error: import of 'set reassemble' commands is not supported."));
1720 consumeUntil(NEWLINE);
1721
1722 #line 1723 "PFCfgParser.cpp"
1723 }
1724 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1725 reportError(ex);
1726 recover(ex,_tokenSet_1);
1727 }
1728 }
1729
set_hostid()1730 void PFCfgParser::set_hostid() {
1731
1732 try { // for error handling
1733 match(LITERAL_hostid);
1734 #line 406 "pf.g"
1735
1736 importer->clear();
1737 importer->setCurrentLineNumber(LT(0)->getLine());
1738 importer->addMessageToLog(
1739 QString("Error: import of 'set hostid' commands is not supported."));
1740 consumeUntil(NEWLINE);
1741
1742 #line 1743 "PFCfgParser.cpp"
1743 }
1744 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1745 reportError(ex);
1746 recover(ex,_tokenSet_1);
1747 }
1748 }
1749
timeout_def()1750 void PFCfgParser::timeout_def() {
1751 #line 424 "pf.g"
1752 std::string timeout_name, timeout_value;
1753 #line 1754 "PFCfgParser.cpp"
1754
1755 try { // for error handling
1756 {
1757 switch ( LA(1)) {
1758 case 40:
1759 {
1760 match(40);
1761 break;
1762 }
1763 case 41:
1764 {
1765 match(41);
1766 break;
1767 }
1768 case 42:
1769 {
1770 match(42);
1771 break;
1772 }
1773 case 43:
1774 {
1775 match(43);
1776 break;
1777 }
1778 case 44:
1779 {
1780 match(44);
1781 break;
1782 }
1783 case 45:
1784 {
1785 match(45);
1786 break;
1787 }
1788 case 46:
1789 {
1790 match(46);
1791 break;
1792 }
1793 case 47:
1794 {
1795 match(47);
1796 break;
1797 }
1798 case 48:
1799 {
1800 match(48);
1801 break;
1802 }
1803 case 49:
1804 {
1805 match(49);
1806 break;
1807 }
1808 case 50:
1809 {
1810 match(50);
1811 break;
1812 }
1813 case 51:
1814 {
1815 match(51);
1816 break;
1817 }
1818 case 52:
1819 {
1820 match(52);
1821 break;
1822 }
1823 case 53:
1824 {
1825 match(53);
1826 break;
1827 }
1828 case LITERAL_frag:
1829 {
1830 match(LITERAL_frag);
1831 break;
1832 }
1833 case LITERAL_interval:
1834 {
1835 match(LITERAL_interval);
1836 break;
1837 }
1838 case 56:
1839 {
1840 match(56);
1841 break;
1842 }
1843 case 57:
1844 {
1845 match(57);
1846 break;
1847 }
1848 case 58:
1849 {
1850 match(58);
1851 break;
1852 }
1853 default:
1854 {
1855 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1856 }
1857 }
1858 }
1859 #line 465 "pf.g"
1860
1861 timeout_name = LT(0)->getText();
1862
1863 #line 1864 "PFCfgParser.cpp"
1864 match(INT_CONST);
1865 #line 469 "pf.g"
1866
1867 timeout_value = LT(0)->getText();
1868 importer->timeouts.push_back(
1869 std::pair<std::string, std::string>(timeout_name, timeout_value));
1870
1871 #line 1872 "PFCfgParser.cpp"
1872 }
1873 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1874 reportError(ex);
1875 recover(ex,_tokenSet_3);
1876 }
1877 }
1878
timeout_def_list()1879 void PFCfgParser::timeout_def_list() {
1880
1881 try { // for error handling
1882 match(OPENING_BRACE);
1883 timeout_def();
1884 { // ( ... )*
1885 for (;;) {
1886 if ((_tokenSet_4.member(LA(1)))) {
1887 {
1888 switch ( LA(1)) {
1889 case COMMA:
1890 {
1891 match(COMMA);
1892 break;
1893 }
1894 case 40:
1895 case 41:
1896 case 42:
1897 case 43:
1898 case 44:
1899 case 45:
1900 case 46:
1901 case 47:
1902 case 48:
1903 case 49:
1904 case 50:
1905 case 51:
1906 case 52:
1907 case 53:
1908 case LITERAL_frag:
1909 case LITERAL_interval:
1910 case 56:
1911 case 57:
1912 case 58:
1913 {
1914 break;
1915 }
1916 default:
1917 {
1918 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1919 }
1920 }
1921 }
1922 timeout_def();
1923 }
1924 else {
1925 goto _loop42;
1926 }
1927
1928 }
1929 _loop42:;
1930 } // ( ... )*
1931 match(CLOSING_BRACE);
1932 }
1933 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1934 reportError(ex);
1935 recover(ex,_tokenSet_1);
1936 }
1937 }
1938
limit_def()1939 void PFCfgParser::limit_def() {
1940 #line 487 "pf.g"
1941 std::string limit_name, limit_value;
1942 #line 1943 "PFCfgParser.cpp"
1943
1944 try { // for error handling
1945 {
1946 switch ( LA(1)) {
1947 case LITERAL_frags:
1948 {
1949 match(LITERAL_frags);
1950 break;
1951 }
1952 case LITERAL_states:
1953 {
1954 match(LITERAL_states);
1955 break;
1956 }
1957 case 62:
1958 {
1959 match(62);
1960 break;
1961 }
1962 case LITERAL_tables:
1963 {
1964 match(LITERAL_tables);
1965 break;
1966 }
1967 case 64:
1968 {
1969 match(64);
1970 break;
1971 }
1972 default:
1973 {
1974 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1975 }
1976 }
1977 }
1978 #line 500 "pf.g"
1979
1980 limit_name = LT(0)->getText();
1981
1982 #line 1983 "PFCfgParser.cpp"
1983 match(INT_CONST);
1984 #line 504 "pf.g"
1985
1986 limit_value = LT(0)->getText();
1987 importer->limits.push_back(
1988 std::pair<std::string, std::string>(limit_name, limit_value));
1989
1990 #line 1991 "PFCfgParser.cpp"
1991 }
1992 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1993 reportError(ex);
1994 recover(ex,_tokenSet_5);
1995 }
1996 }
1997
limit_def_list()1998 void PFCfgParser::limit_def_list() {
1999
2000 try { // for error handling
2001 match(OPENING_BRACE);
2002 limit_def();
2003 { // ( ... )*
2004 for (;;) {
2005 if ((_tokenSet_6.member(LA(1)))) {
2006 {
2007 switch ( LA(1)) {
2008 case COMMA:
2009 {
2010 match(COMMA);
2011 break;
2012 }
2013 case LITERAL_frags:
2014 case LITERAL_states:
2015 case 62:
2016 case LITERAL_tables:
2017 case 64:
2018 {
2019 break;
2020 }
2021 default:
2022 {
2023 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2024 }
2025 }
2026 }
2027 limit_def();
2028 }
2029 else {
2030 goto _loop48;
2031 }
2032
2033 }
2034 _loop48:;
2035 } // ( ... )*
2036 match(CLOSING_BRACE);
2037 }
2038 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2039 reportError(ex);
2040 recover(ex,_tokenSet_1);
2041 }
2042 }
2043
skip_def()2044 void PFCfgParser::skip_def() {
2045
2046 try { // for error handling
2047 switch ( LA(1)) {
2048 case WORD:
2049 {
2050 match(WORD);
2051 #line 366 "pf.g"
2052 importer->set_skip_on.push_back(LT(0)->getText());
2053 #line 2054 "PFCfgParser.cpp"
2054 break;
2055 }
2056 case OPENING_BRACE:
2057 {
2058 skip_list();
2059 break;
2060 }
2061 default:
2062 {
2063 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2064 }
2065 }
2066 }
2067 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2068 reportError(ex);
2069 recover(ex,_tokenSet_1);
2070 }
2071 }
2072
skip_list()2073 void PFCfgParser::skip_list() {
2074
2075 try { // for error handling
2076 match(OPENING_BRACE);
2077 match(WORD);
2078 #line 375 "pf.g"
2079 importer->set_skip_on.push_back(LT(0)->getText());
2080 #line 2081 "PFCfgParser.cpp"
2081 { // ( ... )*
2082 for (;;) {
2083 if ((LA(1) == WORD || LA(1) == COMMA)) {
2084 { // ( ... )*
2085 for (;;) {
2086 if ((LA(1) == COMMA)) {
2087 match(COMMA);
2088 }
2089 else {
2090 goto _loop32;
2091 }
2092
2093 }
2094 _loop32:;
2095 } // ( ... )*
2096 match(WORD);
2097 #line 378 "pf.g"
2098 importer->set_skip_on.push_back(LT(0)->getText());
2099 #line 2100 "PFCfgParser.cpp"
2100 }
2101 else {
2102 goto _loop33;
2103 }
2104
2105 }
2106 _loop33:;
2107 } // ( ... )*
2108 match(CLOSING_BRACE);
2109 }
2110 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2111 reportError(ex);
2112 recover(ex,_tokenSet_1);
2113 }
2114 }
2115
rule_extended()2116 void PFCfgParser::rule_extended() {
2117
2118 try { // for error handling
2119 {
2120 switch ( LA(1)) {
2121 case IN_WORD:
2122 case OUT_WORD:
2123 {
2124 direction();
2125 break;
2126 }
2127 case NEWLINE:
2128 case QUEUE:
2129 case ON:
2130 case LITERAL_reassemble:
2131 case SCRUB:
2132 case EXLAMATION:
2133 case NO:
2134 case OPENING_PAREN:
2135 case LOG:
2136 case QUICK:
2137 case ALL:
2138 case USER:
2139 case TO:
2140 case INET:
2141 case INET6:
2142 case PROTO:
2143 case FROM:
2144 case ROUTE_TO:
2145 case REPLY_TO:
2146 case DUP_TO:
2147 case GROUP:
2148 case LITERAL_fragment:
2149 case 146:
2150 case 147:
2151 case 148:
2152 case 149:
2153 case FLAGS:
2154 case ICMP_TYPE:
2155 case ICMP6_TYPE:
2156 case TAGGED:
2157 case TAG:
2158 case KEEP:
2159 case MODULATE:
2160 case SYNPROXY:
2161 case LABEL:
2162 {
2163 break;
2164 }
2165 default:
2166 {
2167 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2168 }
2169 }
2170 }
2171 {
2172 switch ( LA(1)) {
2173 case LOG:
2174 case QUICK:
2175 {
2176 quick_or_log();
2177 break;
2178 }
2179 case NEWLINE:
2180 case QUEUE:
2181 case ON:
2182 case LITERAL_reassemble:
2183 case SCRUB:
2184 case EXLAMATION:
2185 case NO:
2186 case OPENING_PAREN:
2187 case ALL:
2188 case USER:
2189 case TO:
2190 case INET:
2191 case INET6:
2192 case PROTO:
2193 case FROM:
2194 case ROUTE_TO:
2195 case REPLY_TO:
2196 case DUP_TO:
2197 case GROUP:
2198 case LITERAL_fragment:
2199 case 146:
2200 case 147:
2201 case 148:
2202 case 149:
2203 case FLAGS:
2204 case ICMP_TYPE:
2205 case ICMP6_TYPE:
2206 case TAGGED:
2207 case TAG:
2208 case KEEP:
2209 case MODULATE:
2210 case SYNPROXY:
2211 case LABEL:
2212 {
2213 break;
2214 }
2215 default:
2216 {
2217 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2218 }
2219 }
2220 }
2221 {
2222 switch ( LA(1)) {
2223 case ON:
2224 {
2225 intrface();
2226 break;
2227 }
2228 case NEWLINE:
2229 case QUEUE:
2230 case LITERAL_reassemble:
2231 case SCRUB:
2232 case EXLAMATION:
2233 case NO:
2234 case OPENING_PAREN:
2235 case ALL:
2236 case USER:
2237 case TO:
2238 case INET:
2239 case INET6:
2240 case PROTO:
2241 case FROM:
2242 case ROUTE_TO:
2243 case REPLY_TO:
2244 case DUP_TO:
2245 case GROUP:
2246 case LITERAL_fragment:
2247 case 146:
2248 case 147:
2249 case 148:
2250 case 149:
2251 case FLAGS:
2252 case ICMP_TYPE:
2253 case ICMP6_TYPE:
2254 case TAGGED:
2255 case TAG:
2256 case KEEP:
2257 case MODULATE:
2258 case SYNPROXY:
2259 case LABEL:
2260 {
2261 break;
2262 }
2263 default:
2264 {
2265 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2266 }
2267 }
2268 }
2269 {
2270 if (((LA(1) >= ROUTE_TO && LA(1) <= DUP_TO)) && (LA(2) == OPENING_BRACE || LA(2) == OPENING_PAREN)) {
2271 route();
2272 }
2273 else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_8.member(LA(2)))) {
2274 }
2275 else {
2276 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2277 }
2278
2279 }
2280 {
2281 switch ( LA(1)) {
2282 case INET:
2283 case INET6:
2284 {
2285 address_family();
2286 break;
2287 }
2288 case NEWLINE:
2289 case QUEUE:
2290 case LITERAL_reassemble:
2291 case SCRUB:
2292 case EXLAMATION:
2293 case NO:
2294 case OPENING_PAREN:
2295 case ALL:
2296 case USER:
2297 case TO:
2298 case PROTO:
2299 case FROM:
2300 case ROUTE_TO:
2301 case REPLY_TO:
2302 case DUP_TO:
2303 case GROUP:
2304 case LITERAL_fragment:
2305 case 146:
2306 case 147:
2307 case 148:
2308 case 149:
2309 case FLAGS:
2310 case ICMP_TYPE:
2311 case ICMP6_TYPE:
2312 case TAGGED:
2313 case TAG:
2314 case KEEP:
2315 case MODULATE:
2316 case SYNPROXY:
2317 case LABEL:
2318 {
2319 break;
2320 }
2321 default:
2322 {
2323 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2324 }
2325 }
2326 }
2327 {
2328 switch ( LA(1)) {
2329 case PROTO:
2330 {
2331 protospec();
2332 break;
2333 }
2334 case NEWLINE:
2335 case QUEUE:
2336 case LITERAL_reassemble:
2337 case SCRUB:
2338 case EXLAMATION:
2339 case NO:
2340 case OPENING_PAREN:
2341 case ALL:
2342 case USER:
2343 case TO:
2344 case FROM:
2345 case ROUTE_TO:
2346 case REPLY_TO:
2347 case DUP_TO:
2348 case GROUP:
2349 case LITERAL_fragment:
2350 case 146:
2351 case 147:
2352 case 148:
2353 case 149:
2354 case FLAGS:
2355 case ICMP_TYPE:
2356 case ICMP6_TYPE:
2357 case TAGGED:
2358 case TAG:
2359 case KEEP:
2360 case MODULATE:
2361 case SYNPROXY:
2362 case LABEL:
2363 {
2364 break;
2365 }
2366 default:
2367 {
2368 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2369 }
2370 }
2371 }
2372 {
2373 if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
2374 hosts();
2375 }
2376 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
2377 }
2378 else {
2379 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2380 }
2381
2382 }
2383 {
2384 switch ( LA(1)) {
2385 case QUEUE:
2386 case LITERAL_reassemble:
2387 case SCRUB:
2388 case EXLAMATION:
2389 case NO:
2390 case OPENING_PAREN:
2391 case USER:
2392 case GROUP:
2393 case LITERAL_fragment:
2394 case 146:
2395 case 147:
2396 case 148:
2397 case 149:
2398 case FLAGS:
2399 case ICMP_TYPE:
2400 case ICMP6_TYPE:
2401 case TAGGED:
2402 case TAG:
2403 case KEEP:
2404 case MODULATE:
2405 case SYNPROXY:
2406 case LABEL:
2407 {
2408 filteropts();
2409 break;
2410 }
2411 case NEWLINE:
2412 case ROUTE_TO:
2413 case REPLY_TO:
2414 case DUP_TO:
2415 {
2416 break;
2417 }
2418 default:
2419 {
2420 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2421 }
2422 }
2423 }
2424 {
2425 switch ( LA(1)) {
2426 case ROUTE_TO:
2427 case REPLY_TO:
2428 case DUP_TO:
2429 {
2430 route();
2431 break;
2432 }
2433 case NEWLINE:
2434 {
2435 break;
2436 }
2437 default:
2438 {
2439 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2440 }
2441 }
2442 }
2443 }
2444 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2445 reportError(ex);
2446 recover(ex,_tokenSet_13);
2447 }
2448 }
2449
tableaddr_spec()2450 void PFCfgParser::tableaddr_spec() {
2451 #line 609 "pf.g"
2452 AddressSpec as;
2453 #line 2454 "PFCfgParser.cpp"
2454
2455 try { // for error handling
2456 {
2457 switch ( LA(1)) {
2458 case EXLAMATION:
2459 {
2460 match(EXLAMATION);
2461 #line 610 "pf.g"
2462 as.neg = true;
2463 #line 2464 "PFCfgParser.cpp"
2464 break;
2465 }
2466 case WORD:
2467 case INT_CONST:
2468 case SELF:
2469 case IPV4:
2470 case NUMBER:
2471 {
2472 break;
2473 }
2474 default:
2475 {
2476 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2477 }
2478 }
2479 }
2480 {
2481 switch ( LA(1)) {
2482 case WORD:
2483 {
2484 match(WORD);
2485 #line 613 "pf.g"
2486
2487 // interface name or domain/host name
2488 as.at = AddressSpec::INTERFACE_OR_HOST_NAME;
2489 as.address = LT(0)->getText();
2490
2491 #line 2492 "PFCfgParser.cpp"
2492 {
2493 switch ( LA(1)) {
2494 case COLON:
2495 {
2496 match(COLON);
2497 {
2498 switch ( LA(1)) {
2499 case NETWORK:
2500 {
2501 match(NETWORK);
2502 #line 622 "pf.g"
2503
2504 as.at = AddressSpec::INTERFACE_NETWORK;
2505
2506 #line 2507 "PFCfgParser.cpp"
2507 break;
2508 }
2509 case BROADCAST:
2510 {
2511 match(BROADCAST);
2512 #line 627 "pf.g"
2513
2514 as.at = AddressSpec::INTERFACE_BROADCAST;
2515
2516 #line 2517 "PFCfgParser.cpp"
2517 break;
2518 }
2519 case PEER:
2520 {
2521 match(PEER);
2522 #line 632 "pf.g"
2523
2524 importer->error_tracker->registerError(
2525 QString("import of 'interface:peer' is not supported."));
2526
2527 #line 2528 "PFCfgParser.cpp"
2528 break;
2529 }
2530 case INT_CONST:
2531 {
2532 match(INT_CONST);
2533 #line 638 "pf.g"
2534
2535 importer->error_tracker->registerError(
2536 QString("import of 'interface:0' is not supported."));
2537
2538 #line 2539 "PFCfgParser.cpp"
2539 break;
2540 }
2541 default:
2542 {
2543 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2544 }
2545 }
2546 }
2547 break;
2548 }
2549 case WORD:
2550 case COMMA:
2551 case CLOSING_BRACE:
2552 case INT_CONST:
2553 case EXLAMATION:
2554 case SELF:
2555 case IPV4:
2556 case NUMBER:
2557 {
2558 break;
2559 }
2560 default:
2561 {
2562 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2563 }
2564 }
2565 }
2566 break;
2567 }
2568 case SELF:
2569 {
2570 match(SELF);
2571 #line 646 "pf.g"
2572
2573 as.at = AddressSpec::SPECIAL_ADDRESS;
2574 as.address = "self";
2575
2576 #line 2577 "PFCfgParser.cpp"
2577 break;
2578 }
2579 case INT_CONST:
2580 case IPV4:
2581 case NUMBER:
2582 {
2583 {
2584 switch ( LA(1)) {
2585 case IPV4:
2586 {
2587 match(IPV4);
2588 break;
2589 }
2590 case NUMBER:
2591 {
2592 match(NUMBER);
2593 break;
2594 }
2595 case INT_CONST:
2596 {
2597 match(INT_CONST);
2598 break;
2599 }
2600 default:
2601 {
2602 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2603 }
2604 }
2605 }
2606 #line 653 "pf.g"
2607
2608 as.at = AddressSpec::HOST_ADDRESS;
2609 as.address = LT(0)->getText();
2610
2611 #line 2612 "PFCfgParser.cpp"
2612 {
2613 switch ( LA(1)) {
2614 case SLASH:
2615 {
2616 match(SLASH);
2617 #line 659 "pf.g"
2618
2619 as.at = AddressSpec::NETWORK_ADDRESS;
2620
2621 #line 2622 "PFCfgParser.cpp"
2622 {
2623 switch ( LA(1)) {
2624 case IPV4:
2625 {
2626 match(IPV4);
2627 break;
2628 }
2629 case INT_CONST:
2630 {
2631 match(INT_CONST);
2632 break;
2633 }
2634 default:
2635 {
2636 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2637 }
2638 }
2639 }
2640 #line 663 "pf.g"
2641
2642 as.netmask = LT(0)->getText();
2643
2644 #line 2645 "PFCfgParser.cpp"
2645 break;
2646 }
2647 case WORD:
2648 case COMMA:
2649 case CLOSING_BRACE:
2650 case INT_CONST:
2651 case EXLAMATION:
2652 case SELF:
2653 case IPV4:
2654 case NUMBER:
2655 {
2656 break;
2657 }
2658 default:
2659 {
2660 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2661 }
2662 }
2663 }
2664 break;
2665 }
2666 default:
2667 {
2668 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2669 }
2670 }
2671 }
2672 #line 668 "pf.g"
2673
2674 importer->tmp_group.push_back(as);
2675
2676 #line 2677 "PFCfgParser.cpp"
2677 }
2678 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2679 reportError(ex);
2680 recover(ex,_tokenSet_14);
2681 }
2682 }
2683
logging()2684 void PFCfgParser::logging() {
2685
2686 try { // for error handling
2687 match(LOG);
2688 {
2689 switch ( LA(1)) {
2690 case OPENING_PAREN:
2691 {
2692 logopts();
2693 break;
2694 }
2695 case NEWLINE:
2696 case ON:
2697 case EXLAMATION:
2698 case MINUS:
2699 case ALL:
2700 case TO:
2701 case INET:
2702 case INET6:
2703 case PROTO:
2704 case FROM:
2705 case TAGGED:
2706 case TAG:
2707 {
2708 break;
2709 }
2710 default:
2711 {
2712 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2713 }
2714 }
2715 }
2716 #line 1048 "pf.g"
2717 importer->logging = true;
2718 #line 2719 "PFCfgParser.cpp"
2719 }
2720 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2721 reportError(ex);
2722 recover(ex,_tokenSet_15);
2723 }
2724 }
2725
intrface()2726 void PFCfgParser::intrface() {
2727
2728 try { // for error handling
2729 match(ON);
2730 {
2731 switch ( LA(1)) {
2732 case WORD:
2733 case EXLAMATION:
2734 {
2735 ifspec();
2736 break;
2737 }
2738 case OPENING_BRACE:
2739 {
2740 interface_list();
2741 break;
2742 }
2743 default:
2744 {
2745 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2746 }
2747 }
2748 }
2749 }
2750 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2751 reportError(ex);
2752 recover(ex,_tokenSet_16);
2753 }
2754 }
2755
address_family()2756 void PFCfgParser::address_family() {
2757
2758 try { // for error handling
2759 switch ( LA(1)) {
2760 case INET:
2761 {
2762 match(INET);
2763 break;
2764 }
2765 case INET6:
2766 {
2767 match(INET6);
2768 #line 1092 "pf.g"
2769
2770 importer->address_family = LT(0)->getText();
2771
2772 #line 2773 "PFCfgParser.cpp"
2773 break;
2774 }
2775 default:
2776 {
2777 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2778 }
2779 }
2780 }
2781 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2782 reportError(ex);
2783 recover(ex,_tokenSet_17);
2784 }
2785 }
2786
protospec()2787 void PFCfgParser::protospec() {
2788
2789 try { // for error handling
2790 match(PROTO);
2791 proto_def();
2792 }
2793 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2794 reportError(ex);
2795 recover(ex,_tokenSet_18);
2796 }
2797 }
2798
hosts()2799 void PFCfgParser::hosts() {
2800
2801 try { // for error handling
2802 switch ( LA(1)) {
2803 case ALL:
2804 {
2805 match(ALL);
2806 #line 1135 "pf.g"
2807
2808 importer->src_group.push_back(
2809 AddressSpec(AddressSpec::ANY, false, "0.0.0.0", "0.0.0.0"));
2810 importer->dst_group.push_back(
2811 AddressSpec(AddressSpec::ANY, false, "0.0.0.0", "0.0.0.0"));
2812
2813 #line 2814 "PFCfgParser.cpp"
2814 break;
2815 }
2816 case NEWLINE:
2817 case QUEUE:
2818 case LITERAL_reassemble:
2819 case SCRUB:
2820 case EXLAMATION:
2821 case NO:
2822 case MINUS:
2823 case OPENING_PAREN:
2824 case USER:
2825 case TO:
2826 case FROM:
2827 case ROUTE_TO:
2828 case REPLY_TO:
2829 case DUP_TO:
2830 case GROUP:
2831 case LITERAL_fragment:
2832 case 146:
2833 case 147:
2834 case 148:
2835 case 149:
2836 case FLAGS:
2837 case ICMP_TYPE:
2838 case ICMP6_TYPE:
2839 case TAGGED:
2840 case TAG:
2841 case KEEP:
2842 case MODULATE:
2843 case SYNPROXY:
2844 case LABEL:
2845 {
2846 {
2847 switch ( LA(1)) {
2848 case FROM:
2849 {
2850 hosts_from();
2851 break;
2852 }
2853 case NEWLINE:
2854 case QUEUE:
2855 case LITERAL_reassemble:
2856 case SCRUB:
2857 case EXLAMATION:
2858 case NO:
2859 case MINUS:
2860 case OPENING_PAREN:
2861 case USER:
2862 case TO:
2863 case ROUTE_TO:
2864 case REPLY_TO:
2865 case DUP_TO:
2866 case GROUP:
2867 case LITERAL_fragment:
2868 case 146:
2869 case 147:
2870 case 148:
2871 case 149:
2872 case FLAGS:
2873 case ICMP_TYPE:
2874 case ICMP6_TYPE:
2875 case TAGGED:
2876 case TAG:
2877 case KEEP:
2878 case MODULATE:
2879 case SYNPROXY:
2880 case LABEL:
2881 {
2882 break;
2883 }
2884 default:
2885 {
2886 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2887 }
2888 }
2889 }
2890 {
2891 switch ( LA(1)) {
2892 case TO:
2893 {
2894 hosts_to();
2895 break;
2896 }
2897 case NEWLINE:
2898 case QUEUE:
2899 case LITERAL_reassemble:
2900 case SCRUB:
2901 case EXLAMATION:
2902 case NO:
2903 case MINUS:
2904 case OPENING_PAREN:
2905 case USER:
2906 case ROUTE_TO:
2907 case REPLY_TO:
2908 case DUP_TO:
2909 case GROUP:
2910 case LITERAL_fragment:
2911 case 146:
2912 case 147:
2913 case 148:
2914 case 149:
2915 case FLAGS:
2916 case ICMP_TYPE:
2917 case ICMP6_TYPE:
2918 case TAGGED:
2919 case TAG:
2920 case KEEP:
2921 case MODULATE:
2922 case SYNPROXY:
2923 case LABEL:
2924 {
2925 break;
2926 }
2927 default:
2928 {
2929 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2930 }
2931 }
2932 }
2933 break;
2934 }
2935 default:
2936 {
2937 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2938 }
2939 }
2940 }
2941 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2942 reportError(ex);
2943 recover(ex,_tokenSet_19);
2944 }
2945 }
2946
tagged()2947 void PFCfgParser::tagged() {
2948
2949 try { // for error handling
2950 {
2951 switch ( LA(1)) {
2952 case EXLAMATION:
2953 {
2954 match(EXLAMATION);
2955 #line 1694 "pf.g"
2956 importer->tagged_neg = true;
2957 #line 2958 "PFCfgParser.cpp"
2958 break;
2959 }
2960 case TAGGED:
2961 {
2962 break;
2963 }
2964 default:
2965 {
2966 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2967 }
2968 }
2969 }
2970 match(TAGGED);
2971 match(WORD);
2972 #line 1696 "pf.g"
2973
2974 importer->tagged = LT(0)->getText();
2975
2976 #line 2977 "PFCfgParser.cpp"
2977 }
2978 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2979 reportError(ex);
2980 recover(ex,_tokenSet_20);
2981 }
2982 }
2983
tag_clause()2984 void PFCfgParser::tag_clause() {
2985
2986 try { // for error handling
2987 match(TAG);
2988 match(WORD);
2989 #line 1703 "pf.g"
2990
2991 importer->tag = LT(0)->getText();
2992
2993 #line 2994 "PFCfgParser.cpp"
2994 }
2995 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2996 reportError(ex);
2997 recover(ex,_tokenSet_20);
2998 }
2999 }
3000
redirhost()3001 void PFCfgParser::redirhost() {
3002 #line 804 "pf.g"
3003 AddressSpec as;
3004 #line 3005 "PFCfgParser.cpp"
3005
3006 try { // for error handling
3007 {
3008 switch ( LA(1)) {
3009 case IPV4:
3010 {
3011 match(IPV4);
3012 #line 807 "pf.g"
3013
3014 as.at = AddressSpec::HOST_ADDRESS;
3015 as.address = LT(0)->getText();
3016
3017 #line 3018 "PFCfgParser.cpp"
3018 {
3019 switch ( LA(1)) {
3020 case SLASH:
3021 {
3022 match(SLASH);
3023 #line 813 "pf.g"
3024
3025 as.at = AddressSpec::NETWORK_ADDRESS;
3026
3027 #line 3028 "PFCfgParser.cpp"
3028 {
3029 switch ( LA(1)) {
3030 case IPV4:
3031 {
3032 match(IPV4);
3033 break;
3034 }
3035 case INT_CONST:
3036 {
3037 match(INT_CONST);
3038 break;
3039 }
3040 default:
3041 {
3042 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3043 }
3044 }
3045 }
3046 #line 817 "pf.g"
3047
3048 as.netmask = LT(0)->getText();
3049
3050 #line 3051 "PFCfgParser.cpp"
3051 break;
3052 }
3053 case NEWLINE:
3054 case WORD:
3055 case COMMA:
3056 case CLOSING_BRACE:
3057 case IPV4:
3058 case STATIC_PORT:
3059 case OPENING_PAREN:
3060 case PORT:
3061 case BITMASK:
3062 case RANDOM:
3063 case SOURCE_HASH:
3064 case ROUND_ROBIN:
3065 {
3066 break;
3067 }
3068 default:
3069 {
3070 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3071 }
3072 }
3073 }
3074 break;
3075 }
3076 case OPENING_PAREN:
3077 {
3078 match(OPENING_PAREN);
3079 match(WORD);
3080 #line 824 "pf.g"
3081
3082 // interface name or domain/host name
3083 as.at = AddressSpec::INTERFACE_OR_HOST_NAME;
3084 as.address = LT(0)->getText();
3085
3086 #line 3087 "PFCfgParser.cpp"
3087 match(CLOSING_PAREN);
3088 break;
3089 }
3090 case WORD:
3091 {
3092 match(WORD);
3093 #line 832 "pf.g"
3094
3095 // interface name or domain/host name
3096 as.at = AddressSpec::INTERFACE_OR_HOST_NAME;
3097 as.address = LT(0)->getText();
3098
3099 #line 3100 "PFCfgParser.cpp"
3100 break;
3101 }
3102 default:
3103 {
3104 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3105 }
3106 }
3107 }
3108 #line 838 "pf.g"
3109
3110 importer->tmp_group.push_back(as);
3111
3112 #line 3113 "PFCfgParser.cpp"
3113 }
3114 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3115 reportError(ex);
3116 recover(ex,_tokenSet_21);
3117 }
3118 }
3119
redirhost_list()3120 void PFCfgParser::redirhost_list() {
3121
3122 try { // for error handling
3123 match(OPENING_BRACE);
3124 redirhost();
3125 { // ( ... )*
3126 for (;;) {
3127 if ((_tokenSet_22.member(LA(1)))) {
3128 {
3129 switch ( LA(1)) {
3130 case COMMA:
3131 {
3132 match(COMMA);
3133 break;
3134 }
3135 case WORD:
3136 case IPV4:
3137 case OPENING_PAREN:
3138 {
3139 break;
3140 }
3141 default:
3142 {
3143 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3144 }
3145 }
3146 }
3147 redirhost();
3148 }
3149 else {
3150 goto _loop101;
3151 }
3152
3153 }
3154 _loop101:;
3155 } // ( ... )*
3156 match(CLOSING_BRACE);
3157 }
3158 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3159 reportError(ex);
3160 recover(ex,_tokenSet_23);
3161 }
3162 }
3163
portspec()3164 void PFCfgParser::portspec() {
3165 #line 863 "pf.g"
3166 PortSpec ps;
3167 #line 3168 "PFCfgParser.cpp"
3168
3169 try { // for error handling
3170 match(PORT);
3171 {
3172 switch ( LA(1)) {
3173 case WORD:
3174 case INT_CONST:
3175 {
3176 port_def();
3177 #line 867 "pf.g"
3178
3179 ps.port1 = importer->tmp_port_def;
3180 ps.port2 = ps.port1;
3181 ps.port_op = "=";
3182
3183 #line 3184 "PFCfgParser.cpp"
3184 break;
3185 }
3186 case IPV6:
3187 {
3188 match(IPV6);
3189 #line 876 "pf.g"
3190
3191 ps.setFromPortRange(LT(0)->getText());
3192
3193 #line 3194 "PFCfgParser.cpp"
3194 {
3195 switch ( LA(1)) {
3196 case STAR:
3197 {
3198 match(STAR);
3199 #line 880 "pf.g"
3200 ps.port2 = "65535";
3201 #line 3202 "PFCfgParser.cpp"
3202 break;
3203 }
3204 case NEWLINE:
3205 case STATIC_PORT:
3206 case BITMASK:
3207 case RANDOM:
3208 case SOURCE_HASH:
3209 case ROUND_ROBIN:
3210 {
3211 break;
3212 }
3213 default:
3214 {
3215 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3216 }
3217 }
3218 }
3219 break;
3220 }
3221 default:
3222 {
3223 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3224 }
3225 }
3226 }
3227 #line 883 "pf.g"
3228
3229 importer->tmp_port_group.push_back(ps);
3230
3231 #line 3232 "PFCfgParser.cpp"
3232 }
3233 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3234 reportError(ex);
3235 recover(ex,_tokenSet_24);
3236 }
3237 }
3238
pooltype()3239 void PFCfgParser::pooltype() {
3240
3241 try { // for error handling
3242 {
3243 switch ( LA(1)) {
3244 case BITMASK:
3245 {
3246 match(BITMASK);
3247 #line 897 "pf.g"
3248 importer->pooltype_opt = "bitmask";
3249 #line 3250 "PFCfgParser.cpp"
3250 break;
3251 }
3252 case RANDOM:
3253 {
3254 match(RANDOM);
3255 #line 899 "pf.g"
3256 importer->pooltype_opt = "random";
3257 #line 3258 "PFCfgParser.cpp"
3258 break;
3259 }
3260 case SOURCE_HASH:
3261 {
3262 match(SOURCE_HASH);
3263 #line 901 "pf.g"
3264 importer->pooltype_opt = "source-hash";
3265 #line 3266 "PFCfgParser.cpp"
3266 {
3267 switch ( LA(1)) {
3268 case HEX_KEY:
3269 {
3270 match(HEX_KEY);
3271 #line 904 "pf.g"
3272
3273 importer->error_tracker->registerError(
3274 QString("import of commands with pool type 'source-hash hex-key' "
3275 "option is not supported"));
3276
3277 #line 3278 "PFCfgParser.cpp"
3278 break;
3279 }
3280 case STRING_KEY:
3281 {
3282 match(STRING_KEY);
3283 #line 911 "pf.g"
3284
3285 importer->error_tracker->registerError(
3286 QString("import of commands with pool type 'source-hash string-key' "
3287 "option is not supported"));
3288
3289 #line 3290 "PFCfgParser.cpp"
3290 break;
3291 }
3292 case NEWLINE:
3293 case QUEUE:
3294 case LITERAL_reassemble:
3295 case SCRUB:
3296 case EXLAMATION:
3297 case NO:
3298 case STATIC_PORT:
3299 case OPENING_PAREN:
3300 case STICKY_ADDRESS:
3301 case ALL:
3302 case USER:
3303 case TO:
3304 case INET:
3305 case INET6:
3306 case PROTO:
3307 case FROM:
3308 case ROUTE_TO:
3309 case REPLY_TO:
3310 case DUP_TO:
3311 case GROUP:
3312 case LITERAL_fragment:
3313 case 146:
3314 case 147:
3315 case 148:
3316 case 149:
3317 case FLAGS:
3318 case ICMP_TYPE:
3319 case ICMP6_TYPE:
3320 case TAGGED:
3321 case TAG:
3322 case KEEP:
3323 case MODULATE:
3324 case SYNPROXY:
3325 case LABEL:
3326 {
3327 break;
3328 }
3329 default:
3330 {
3331 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3332 }
3333 }
3334 }
3335 break;
3336 }
3337 case ROUND_ROBIN:
3338 {
3339 match(ROUND_ROBIN);
3340 #line 918 "pf.g"
3341 importer->pooltype_opt = "round-robin";
3342 #line 3343 "PFCfgParser.cpp"
3343 break;
3344 }
3345 default:
3346 {
3347 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3348 }
3349 }
3350 }
3351 {
3352 switch ( LA(1)) {
3353 case STICKY_ADDRESS:
3354 {
3355 match(STICKY_ADDRESS);
3356 break;
3357 }
3358 case NEWLINE:
3359 case QUEUE:
3360 case LITERAL_reassemble:
3361 case SCRUB:
3362 case EXLAMATION:
3363 case NO:
3364 case STATIC_PORT:
3365 case OPENING_PAREN:
3366 case ALL:
3367 case USER:
3368 case TO:
3369 case INET:
3370 case INET6:
3371 case PROTO:
3372 case FROM:
3373 case ROUTE_TO:
3374 case REPLY_TO:
3375 case DUP_TO:
3376 case GROUP:
3377 case LITERAL_fragment:
3378 case 146:
3379 case 147:
3380 case 148:
3381 case 149:
3382 case FLAGS:
3383 case ICMP_TYPE:
3384 case ICMP6_TYPE:
3385 case TAGGED:
3386 case TAG:
3387 case KEEP:
3388 case MODULATE:
3389 case SYNPROXY:
3390 case LABEL:
3391 {
3392 break;
3393 }
3394 default:
3395 {
3396 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3397 }
3398 }
3399 }
3400 }
3401 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3402 reportError(ex);
3403 recover(ex,_tokenSet_25);
3404 }
3405 }
3406
port_def()3407 void PFCfgParser::port_def() {
3408
3409 try { // for error handling
3410 {
3411 switch ( LA(1)) {
3412 case WORD:
3413 {
3414 match(WORD);
3415 break;
3416 }
3417 case INT_CONST:
3418 {
3419 match(INT_CONST);
3420 break;
3421 }
3422 default:
3423 {
3424 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3425 }
3426 }
3427 }
3428 #line 1831 "pf.g"
3429
3430 importer->tmp_port_def = LT(0)->getText();
3431
3432 #line 3433 "PFCfgParser.cpp"
3433 }
3434 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3435 reportError(ex);
3436 recover(ex,_tokenSet_26);
3437 }
3438 }
3439
block_return()3440 void PFCfgParser::block_return() {
3441
3442 try { // for error handling
3443 {
3444 switch ( LA(1)) {
3445 case DROP:
3446 {
3447 match(DROP);
3448 #line 980 "pf.g"
3449 importer->block_action_params.push_back("drop");
3450 #line 3451 "PFCfgParser.cpp"
3451 break;
3452 }
3453 case RETURN:
3454 {
3455 match(RETURN);
3456 #line 982 "pf.g"
3457 importer->block_action_params.push_back("return");
3458 #line 3459 "PFCfgParser.cpp"
3459 break;
3460 }
3461 case RETURN_RST:
3462 {
3463 match(RETURN_RST);
3464 #line 984 "pf.g"
3465 importer->block_action_params.push_back("return-rst");
3466 #line 3467 "PFCfgParser.cpp"
3467 {
3468 switch ( LA(1)) {
3469 case TTL:
3470 {
3471 match(TTL);
3472 match(INT_CONST);
3473 #line 987 "pf.g"
3474
3475 importer->error_tracker->registerError(
3476 QString("Import of \"block return-rst ttl number\" is not supported. "));
3477
3478 #line 3479 "PFCfgParser.cpp"
3479 break;
3480 }
3481 case NEWLINE:
3482 case QUEUE:
3483 case ON:
3484 case LITERAL_reassemble:
3485 case SCRUB:
3486 case EXLAMATION:
3487 case NO:
3488 case OPENING_PAREN:
3489 case IN_WORD:
3490 case OUT_WORD:
3491 case LOG:
3492 case QUICK:
3493 case ALL:
3494 case USER:
3495 case TO:
3496 case INET:
3497 case INET6:
3498 case PROTO:
3499 case FROM:
3500 case ROUTE_TO:
3501 case REPLY_TO:
3502 case DUP_TO:
3503 case GROUP:
3504 case LITERAL_fragment:
3505 case 146:
3506 case 147:
3507 case 148:
3508 case 149:
3509 case FLAGS:
3510 case ICMP_TYPE:
3511 case ICMP6_TYPE:
3512 case TAGGED:
3513 case TAG:
3514 case KEEP:
3515 case MODULATE:
3516 case SYNPROXY:
3517 case LABEL:
3518 {
3519 break;
3520 }
3521 default:
3522 {
3523 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3524 }
3525 }
3526 }
3527 break;
3528 }
3529 case RETURN_ICMP:
3530 {
3531 match(RETURN_ICMP);
3532 #line 993 "pf.g"
3533 importer->block_action_params.push_back("return-icmp");
3534 #line 3535 "PFCfgParser.cpp"
3535 {
3536 if ((LA(1) == OPENING_PAREN) && (_tokenSet_27.member(LA(2)))) {
3537 match(OPENING_PAREN);
3538 {
3539 switch ( LA(1)) {
3540 case 177:
3541 case 178:
3542 case 179:
3543 case 180:
3544 case LITERAL_needfrag:
3545 case LITERAL_srcfail:
3546 case 183:
3547 case 184:
3548 case LITERAL_isolate:
3549 case 186:
3550 case 187:
3551 case 188:
3552 case 189:
3553 case 190:
3554 case 191:
3555 case 192:
3556 case 193:
3557 case 194:
3558 case 195:
3559 case 196:
3560 case 197:
3561 case 198:
3562 case LITERAL_transit:
3563 case LITERAL_reassemb:
3564 case LITERAL_badhead:
3565 case LITERAL_optmiss:
3566 case LITERAL_badlen:
3567 case 204:
3568 case 205:
3569 case 206:
3570 {
3571 icmp_code_by_name();
3572 break;
3573 }
3574 case INT_CONST:
3575 {
3576 match(INT_CONST);
3577 break;
3578 }
3579 default:
3580 {
3581 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3582 }
3583 }
3584 }
3585 #line 997 "pf.g"
3586 importer->block_action_params.push_back(LT(0)->getText());
3587 #line 3588 "PFCfgParser.cpp"
3588 {
3589 switch ( LA(1)) {
3590 case COMMA:
3591 {
3592 match(COMMA);
3593 {
3594 switch ( LA(1)) {
3595 case 177:
3596 case 178:
3597 case 179:
3598 case 180:
3599 case LITERAL_needfrag:
3600 case LITERAL_srcfail:
3601 case 183:
3602 case 184:
3603 case LITERAL_isolate:
3604 case 186:
3605 case 187:
3606 case 188:
3607 case 189:
3608 case 190:
3609 case 191:
3610 case 192:
3611 case 193:
3612 case 194:
3613 case 195:
3614 case 196:
3615 case 197:
3616 case 198:
3617 case LITERAL_transit:
3618 case LITERAL_reassemb:
3619 case LITERAL_badhead:
3620 case LITERAL_optmiss:
3621 case LITERAL_badlen:
3622 case 204:
3623 case 205:
3624 case 206:
3625 {
3626 icmp_code_by_name();
3627 break;
3628 }
3629 case INT_CONST:
3630 {
3631 match(INT_CONST);
3632 break;
3633 }
3634 default:
3635 {
3636 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3637 }
3638 }
3639 }
3640 #line 1001 "pf.g"
3641
3642 importer->error_tracker->registerError(
3643 QString("Import of \"block return-icmp (icmp_code, icmp6_code)\" is not supported"));
3644
3645 #line 3646 "PFCfgParser.cpp"
3646 break;
3647 }
3648 case CLOSING_PAREN:
3649 {
3650 break;
3651 }
3652 default:
3653 {
3654 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3655 }
3656 }
3657 }
3658 match(CLOSING_PAREN);
3659 }
3660 else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
3661 }
3662 else {
3663 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3664 }
3665
3666 }
3667 break;
3668 }
3669 case RETURN_ICMP6:
3670 {
3671 match(RETURN_ICMP6);
3672 #line 1010 "pf.g"
3673
3674 importer->error_tracker->registerError(
3675 QString("Import of \"block return-icmp6\" is not supported"));
3676 importer->block_action_params.push_back("return-icmp");
3677
3678 #line 3679 "PFCfgParser.cpp"
3679 break;
3680 }
3681 default:
3682 {
3683 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3684 }
3685 }
3686 }
3687 }
3688 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3689 reportError(ex);
3690 recover(ex,_tokenSet_28);
3691 }
3692 }
3693
icmp_code_by_name()3694 void PFCfgParser::icmp_code_by_name() {
3695
3696 try { // for error handling
3697 {
3698 switch ( LA(1)) {
3699 case 177:
3700 {
3701 match(177);
3702 break;
3703 }
3704 case 178:
3705 {
3706 match(178);
3707 break;
3708 }
3709 case 179:
3710 {
3711 match(179);
3712 break;
3713 }
3714 case 180:
3715 {
3716 match(180);
3717 break;
3718 }
3719 case LITERAL_needfrag:
3720 {
3721 match(LITERAL_needfrag);
3722 break;
3723 }
3724 case LITERAL_srcfail:
3725 {
3726 match(LITERAL_srcfail);
3727 break;
3728 }
3729 case 183:
3730 {
3731 match(183);
3732 break;
3733 }
3734 case 184:
3735 {
3736 match(184);
3737 break;
3738 }
3739 case LITERAL_isolate:
3740 {
3741 match(LITERAL_isolate);
3742 break;
3743 }
3744 case 186:
3745 {
3746 match(186);
3747 break;
3748 }
3749 case 187:
3750 {
3751 match(187);
3752 break;
3753 }
3754 case 188:
3755 {
3756 match(188);
3757 break;
3758 }
3759 case 189:
3760 {
3761 match(189);
3762 break;
3763 }
3764 case 190:
3765 {
3766 match(190);
3767 break;
3768 }
3769 case 191:
3770 {
3771 match(191);
3772 break;
3773 }
3774 case 192:
3775 {
3776 match(192);
3777 break;
3778 }
3779 case 193:
3780 {
3781 match(193);
3782 break;
3783 }
3784 case 194:
3785 {
3786 match(194);
3787 break;
3788 }
3789 case 195:
3790 {
3791 match(195);
3792 break;
3793 }
3794 case 196:
3795 {
3796 match(196);
3797 break;
3798 }
3799 case 197:
3800 {
3801 match(197);
3802 break;
3803 }
3804 case 198:
3805 {
3806 match(198);
3807 break;
3808 }
3809 case LITERAL_transit:
3810 {
3811 match(LITERAL_transit);
3812 break;
3813 }
3814 case LITERAL_reassemb:
3815 {
3816 match(LITERAL_reassemb);
3817 break;
3818 }
3819 case LITERAL_badhead:
3820 {
3821 match(LITERAL_badhead);
3822 break;
3823 }
3824 case LITERAL_optmiss:
3825 {
3826 match(LITERAL_optmiss);
3827 break;
3828 }
3829 case LITERAL_badlen:
3830 {
3831 match(LITERAL_badlen);
3832 break;
3833 }
3834 case 204:
3835 {
3836 match(204);
3837 break;
3838 }
3839 case 205:
3840 {
3841 match(205);
3842 break;
3843 }
3844 case 206:
3845 {
3846 match(206);
3847 break;
3848 }
3849 default:
3850 {
3851 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3852 }
3853 }
3854 }
3855 }
3856 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3857 reportError(ex);
3858 recover(ex,_tokenSet_30);
3859 }
3860 }
3861
direction()3862 void PFCfgParser::direction() {
3863
3864 try { // for error handling
3865 {
3866 switch ( LA(1)) {
3867 case IN_WORD:
3868 {
3869 match(IN_WORD);
3870 break;
3871 }
3872 case OUT_WORD:
3873 {
3874 match(OUT_WORD);
3875 break;
3876 }
3877 default:
3878 {
3879 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3880 }
3881 }
3882 }
3883 #line 1031 "pf.g"
3884
3885 importer->direction = LT(0)->getText();
3886
3887 #line 3888 "PFCfgParser.cpp"
3888 }
3889 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3890 reportError(ex);
3891 recover(ex,_tokenSet_31);
3892 }
3893 }
3894
quick_or_log()3895 void PFCfgParser::quick_or_log() {
3896
3897 try { // for error handling
3898 {
3899 switch ( LA(1)) {
3900 case LOG:
3901 {
3902 match(LOG);
3903 {
3904 if ((LA(1) == OPENING_PAREN) && ((LA(2) >= ALL && LA(2) <= TO))) {
3905 logopts();
3906 }
3907 else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3908 }
3909 else {
3910 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3911 }
3912
3913 }
3914 #line 1039 "pf.g"
3915 importer->logging = true;
3916 #line 3917 "PFCfgParser.cpp"
3917 {
3918 switch ( LA(1)) {
3919 case QUICK:
3920 {
3921 match(QUICK);
3922 #line 1040 "pf.g"
3923 importer->quick = true;
3924 #line 3925 "PFCfgParser.cpp"
3925 break;
3926 }
3927 case NEWLINE:
3928 case QUEUE:
3929 case ON:
3930 case LITERAL_reassemble:
3931 case SCRUB:
3932 case EXLAMATION:
3933 case NO:
3934 case OPENING_PAREN:
3935 case ALL:
3936 case USER:
3937 case TO:
3938 case INET:
3939 case INET6:
3940 case PROTO:
3941 case FROM:
3942 case ROUTE_TO:
3943 case REPLY_TO:
3944 case DUP_TO:
3945 case GROUP:
3946 case LITERAL_fragment:
3947 case 146:
3948 case 147:
3949 case 148:
3950 case 149:
3951 case FLAGS:
3952 case ICMP_TYPE:
3953 case ICMP6_TYPE:
3954 case TAGGED:
3955 case TAG:
3956 case KEEP:
3957 case MODULATE:
3958 case SYNPROXY:
3959 case LABEL:
3960 {
3961 break;
3962 }
3963 default:
3964 {
3965 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3966 }
3967 }
3968 }
3969 break;
3970 }
3971 case QUICK:
3972 {
3973 match(QUICK);
3974 #line 1042 "pf.g"
3975 importer->quick = true;
3976 #line 3977 "PFCfgParser.cpp"
3977 {
3978 switch ( LA(1)) {
3979 case LOG:
3980 {
3981 match(LOG);
3982 {
3983 if ((LA(1) == OPENING_PAREN) && ((LA(2) >= ALL && LA(2) <= TO))) {
3984 logopts();
3985 }
3986 else if ((_tokenSet_34.member(LA(1))) && (_tokenSet_8.member(LA(2)))) {
3987 }
3988 else {
3989 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3990 }
3991
3992 }
3993 #line 1043 "pf.g"
3994 importer->logging = true;
3995 #line 3996 "PFCfgParser.cpp"
3996 break;
3997 }
3998 case NEWLINE:
3999 case QUEUE:
4000 case ON:
4001 case LITERAL_reassemble:
4002 case SCRUB:
4003 case EXLAMATION:
4004 case NO:
4005 case OPENING_PAREN:
4006 case ALL:
4007 case USER:
4008 case TO:
4009 case INET:
4010 case INET6:
4011 case PROTO:
4012 case FROM:
4013 case ROUTE_TO:
4014 case REPLY_TO:
4015 case DUP_TO:
4016 case GROUP:
4017 case LITERAL_fragment:
4018 case 146:
4019 case 147:
4020 case 148:
4021 case 149:
4022 case FLAGS:
4023 case ICMP_TYPE:
4024 case ICMP6_TYPE:
4025 case TAGGED:
4026 case TAG:
4027 case KEEP:
4028 case MODULATE:
4029 case SYNPROXY:
4030 case LABEL:
4031 {
4032 break;
4033 }
4034 default:
4035 {
4036 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4037 }
4038 }
4039 }
4040 break;
4041 }
4042 default:
4043 {
4044 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4045 }
4046 }
4047 }
4048 }
4049 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4050 reportError(ex);
4051 recover(ex,_tokenSet_34);
4052 }
4053 }
4054
route()4055 void PFCfgParser::route() {
4056
4057 try { // for error handling
4058 switch ( LA(1)) {
4059 case ROUTE_TO:
4060 {
4061 route_to();
4062 break;
4063 }
4064 case REPLY_TO:
4065 {
4066 reply_to();
4067 break;
4068 }
4069 case DUP_TO:
4070 {
4071 dup_to();
4072 break;
4073 }
4074 default:
4075 {
4076 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4077 }
4078 }
4079 }
4080 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4081 reportError(ex);
4082 recover(ex,_tokenSet_7);
4083 }
4084 }
4085
filteropts()4086 void PFCfgParser::filteropts() {
4087
4088 try { // for error handling
4089 filteropt();
4090 { // ( ... )*
4091 for (;;) {
4092 if ((_tokenSet_35.member(LA(1)))) {
4093 {
4094 switch ( LA(1)) {
4095 case COMMA:
4096 {
4097 match(COMMA);
4098 break;
4099 }
4100 case QUEUE:
4101 case LITERAL_reassemble:
4102 case SCRUB:
4103 case EXLAMATION:
4104 case NO:
4105 case OPENING_PAREN:
4106 case USER:
4107 case GROUP:
4108 case LITERAL_fragment:
4109 case 146:
4110 case 147:
4111 case 148:
4112 case 149:
4113 case FLAGS:
4114 case ICMP_TYPE:
4115 case ICMP6_TYPE:
4116 case TAGGED:
4117 case TAG:
4118 case KEEP:
4119 case MODULATE:
4120 case SYNPROXY:
4121 case LABEL:
4122 {
4123 break;
4124 }
4125 default:
4126 {
4127 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4128 }
4129 }
4130 }
4131 filteropt();
4132 }
4133 else {
4134 goto _loop207;
4135 }
4136
4137 }
4138 _loop207:;
4139 } // ( ... )*
4140 }
4141 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4142 reportError(ex);
4143 recover(ex,_tokenSet_36);
4144 }
4145 }
4146
logopts()4147 void PFCfgParser::logopts() {
4148
4149 try { // for error handling
4150 match(OPENING_PAREN);
4151 logopt();
4152 { // ( ... )*
4153 for (;;) {
4154 if ((LA(1) == COMMA)) {
4155 match(COMMA);
4156 #line 1055 "pf.g"
4157 importer->logopts += ",";
4158 #line 4159 "PFCfgParser.cpp"
4159 logopt();
4160 }
4161 else {
4162 goto _loop142;
4163 }
4164
4165 }
4166 _loop142:;
4167 } // ( ... )*
4168 match(CLOSING_PAREN);
4169 }
4170 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4171 reportError(ex);
4172 recover(ex,_tokenSet_37);
4173 }
4174 }
4175
logopt()4176 void PFCfgParser::logopt() {
4177
4178 try { // for error handling
4179 switch ( LA(1)) {
4180 case ALL:
4181 {
4182 match(ALL);
4183 break;
4184 }
4185 case USER:
4186 {
4187 match(USER);
4188 break;
4189 }
4190 case TO:
4191 {
4192 match(TO);
4193 match(WORD);
4194 #line 1062 "pf.g"
4195
4196 importer->logopts += LT(0)->getText();
4197
4198 #line 4199 "PFCfgParser.cpp"
4199 break;
4200 }
4201 default:
4202 {
4203 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4204 }
4205 }
4206 }
4207 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4208 reportError(ex);
4209 recover(ex,_tokenSet_38);
4210 }
4211 }
4212
ifspec()4213 void PFCfgParser::ifspec() {
4214 #line 1070 "pf.g"
4215 InterfaceSpec is;
4216 #line 4217 "PFCfgParser.cpp"
4217
4218 try { // for error handling
4219 {
4220 switch ( LA(1)) {
4221 case EXLAMATION:
4222 {
4223 match(EXLAMATION);
4224 #line 1071 "pf.g"
4225 is.neg = true;
4226 #line 4227 "PFCfgParser.cpp"
4227 break;
4228 }
4229 case WORD:
4230 {
4231 break;
4232 }
4233 default:
4234 {
4235 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4236 }
4237 }
4238 }
4239 match(WORD);
4240 #line 1073 "pf.g"
4241
4242 is.name = LT(0)->getText();
4243 importer->iface_group.push_back(is);
4244 importer->newInterface(is.name);
4245
4246 #line 4247 "PFCfgParser.cpp"
4247 }
4248 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4249 reportError(ex);
4250 recover(ex,_tokenSet_39);
4251 }
4252 }
4253
interface_list()4254 void PFCfgParser::interface_list() {
4255
4256 try { // for error handling
4257 match(OPENING_BRACE);
4258 ifspec();
4259 { // ( ... )*
4260 for (;;) {
4261 if ((LA(1) == WORD || LA(1) == COMMA || LA(1) == EXLAMATION)) {
4262 {
4263 switch ( LA(1)) {
4264 case COMMA:
4265 {
4266 match(COMMA);
4267 break;
4268 }
4269 case WORD:
4270 case EXLAMATION:
4271 {
4272 break;
4273 }
4274 default:
4275 {
4276 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4277 }
4278 }
4279 }
4280 ifspec();
4281 }
4282 else {
4283 goto _loop151;
4284 }
4285
4286 }
4287 _loop151:;
4288 } // ( ... )*
4289 match(CLOSING_BRACE);
4290 }
4291 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4292 reportError(ex);
4293 recover(ex,_tokenSet_16);
4294 }
4295 }
4296
proto_def()4297 void PFCfgParser::proto_def() {
4298
4299 try { // for error handling
4300 {
4301 switch ( LA(1)) {
4302 case IP:
4303 case ICMP:
4304 case IGMP:
4305 case TCP:
4306 case UDP:
4307 case RDP:
4308 case RSVP:
4309 case GRE:
4310 case ESP_WORD:
4311 case AH:
4312 case EIGRP:
4313 case OSPF:
4314 case IPIP:
4315 case VRRP:
4316 case L2TP:
4317 case ISIS:
4318 {
4319 proto_name();
4320 break;
4321 }
4322 case INT_CONST:
4323 {
4324 proto_number();
4325 break;
4326 }
4327 case OPENING_BRACE:
4328 {
4329 proto_list();
4330 break;
4331 }
4332 default:
4333 {
4334 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4335 }
4336 }
4337 }
4338 }
4339 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4340 reportError(ex);
4341 recover(ex,_tokenSet_40);
4342 }
4343 }
4344
proto_name()4345 void PFCfgParser::proto_name() {
4346
4347 try { // for error handling
4348 {
4349 switch ( LA(1)) {
4350 case IP:
4351 {
4352 match(IP);
4353 break;
4354 }
4355 case ICMP:
4356 {
4357 match(ICMP);
4358 break;
4359 }
4360 case IGMP:
4361 {
4362 match(IGMP);
4363 break;
4364 }
4365 case TCP:
4366 {
4367 match(TCP);
4368 break;
4369 }
4370 case UDP:
4371 {
4372 match(UDP);
4373 break;
4374 }
4375 case RDP:
4376 {
4377 match(RDP);
4378 break;
4379 }
4380 case RSVP:
4381 {
4382 match(RSVP);
4383 break;
4384 }
4385 case GRE:
4386 {
4387 match(GRE);
4388 break;
4389 }
4390 case ESP_WORD:
4391 {
4392 match(ESP_WORD);
4393 break;
4394 }
4395 case AH:
4396 {
4397 match(AH);
4398 break;
4399 }
4400 case EIGRP:
4401 {
4402 match(EIGRP);
4403 break;
4404 }
4405 case OSPF:
4406 {
4407 match(OSPF);
4408 break;
4409 }
4410 case IPIP:
4411 {
4412 match(IPIP);
4413 break;
4414 }
4415 case VRRP:
4416 {
4417 match(VRRP);
4418 break;
4419 }
4420 case L2TP:
4421 {
4422 match(L2TP);
4423 break;
4424 }
4425 case ISIS:
4426 {
4427 match(ISIS);
4428 break;
4429 }
4430 default:
4431 {
4432 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4433 }
4434 }
4435 }
4436 #line 1112 "pf.g"
4437
4438 importer->proto_list.push_back(LT(0)->getText());
4439
4440 #line 4441 "PFCfgParser.cpp"
4441 }
4442 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4443 reportError(ex);
4444 recover(ex,_tokenSet_40);
4445 }
4446 }
4447
proto_number()4448 void PFCfgParser::proto_number() {
4449
4450 try { // for error handling
4451 match(INT_CONST);
4452 #line 1118 "pf.g"
4453
4454 importer->proto_list.push_back(LT(0)->getText());
4455
4456 #line 4457 "PFCfgParser.cpp"
4457 }
4458 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4459 reportError(ex);
4460 recover(ex,_tokenSet_40);
4461 }
4462 }
4463
proto_list()4464 void PFCfgParser::proto_list() {
4465
4466 try { // for error handling
4467 match(OPENING_BRACE);
4468 proto_def();
4469 { // ( ... )*
4470 for (;;) {
4471 if ((_tokenSet_41.member(LA(1)))) {
4472 {
4473 switch ( LA(1)) {
4474 case COMMA:
4475 {
4476 match(COMMA);
4477 break;
4478 }
4479 case OPENING_BRACE:
4480 case INT_CONST:
4481 case IP:
4482 case ICMP:
4483 case IGMP:
4484 case TCP:
4485 case UDP:
4486 case RDP:
4487 case RSVP:
4488 case GRE:
4489 case ESP_WORD:
4490 case AH:
4491 case EIGRP:
4492 case OSPF:
4493 case IPIP:
4494 case VRRP:
4495 case L2TP:
4496 case ISIS:
4497 {
4498 break;
4499 }
4500 default:
4501 {
4502 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4503 }
4504 }
4505 }
4506 proto_def();
4507 }
4508 else {
4509 goto _loop162;
4510 }
4511
4512 }
4513 _loop162:;
4514 } // ( ... )*
4515 match(CLOSING_BRACE);
4516 }
4517 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4518 reportError(ex);
4519 recover(ex,_tokenSet_40);
4520 }
4521 }
4522
hosts_from()4523 void PFCfgParser::hosts_from() {
4524
4525 try { // for error handling
4526 match(FROM);
4527 src_hosts_part();
4528 {
4529 switch ( LA(1)) {
4530 case PORT:
4531 {
4532 src_port_part();
4533 break;
4534 }
4535 case NEWLINE:
4536 case QUEUE:
4537 case LITERAL_reassemble:
4538 case SCRUB:
4539 case EXLAMATION:
4540 case NO:
4541 case MINUS:
4542 case OPENING_PAREN:
4543 case USER:
4544 case TO:
4545 case ROUTE_TO:
4546 case REPLY_TO:
4547 case DUP_TO:
4548 case GROUP:
4549 case LITERAL_fragment:
4550 case 146:
4551 case 147:
4552 case 148:
4553 case 149:
4554 case FLAGS:
4555 case ICMP_TYPE:
4556 case ICMP6_TYPE:
4557 case TAGGED:
4558 case TAG:
4559 case KEEP:
4560 case MODULATE:
4561 case SYNPROXY:
4562 case LABEL:
4563 {
4564 break;
4565 }
4566 default:
4567 {
4568 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4569 }
4570 }
4571 }
4572 }
4573 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4574 reportError(ex);
4575 recover(ex,_tokenSet_42);
4576 }
4577 }
4578
hosts_to()4579 void PFCfgParser::hosts_to() {
4580
4581 try { // for error handling
4582 match(TO);
4583 dst_hosts_part();
4584 {
4585 switch ( LA(1)) {
4586 case PORT:
4587 {
4588 dst_port_part();
4589 break;
4590 }
4591 case NEWLINE:
4592 case QUEUE:
4593 case LITERAL_reassemble:
4594 case SCRUB:
4595 case EXLAMATION:
4596 case NO:
4597 case MINUS:
4598 case OPENING_PAREN:
4599 case USER:
4600 case ROUTE_TO:
4601 case REPLY_TO:
4602 case DUP_TO:
4603 case GROUP:
4604 case LITERAL_fragment:
4605 case 146:
4606 case 147:
4607 case 148:
4608 case 149:
4609 case FLAGS:
4610 case ICMP_TYPE:
4611 case ICMP6_TYPE:
4612 case TAGGED:
4613 case TAG:
4614 case KEEP:
4615 case MODULATE:
4616 case SYNPROXY:
4617 case LABEL:
4618 {
4619 break;
4620 }
4621 default:
4622 {
4623 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4624 }
4625 }
4626 }
4627 }
4628 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4629 reportError(ex);
4630 recover(ex,_tokenSet_19);
4631 }
4632 }
4633
src_hosts_part()4634 void PFCfgParser::src_hosts_part() {
4635
4636 try { // for error handling
4637 {
4638 switch ( LA(1)) {
4639 case WORD:
4640 case OPENING_BRACE:
4641 case LESS_THAN:
4642 case EXLAMATION:
4643 case SELF:
4644 case IPV4:
4645 case OPENING_PAREN:
4646 case IPV6:
4647 case ANY:
4648 case NO_ROUTE:
4649 case MACRO:
4650 {
4651 common_hosts_part();
4652 break;
4653 }
4654 case URPF_FAILED:
4655 {
4656 match(URPF_FAILED);
4657 #line 1158 "pf.g"
4658
4659 importer->tmp_group.push_back(
4660 AddressSpec(AddressSpec::SPECIAL_ADDRESS, false,
4661 "urpf-failed", ""));
4662
4663 #line 4664 "PFCfgParser.cpp"
4664 break;
4665 }
4666 default:
4667 {
4668 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4669 }
4670 }
4671 }
4672 #line 1164 "pf.g"
4673
4674 importer->src_neg = importer->tmp_neg;
4675 importer->src_group.splice(importer->src_group.begin(),
4676 importer->tmp_group);
4677
4678 #line 4679 "PFCfgParser.cpp"
4679 }
4680 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4681 reportError(ex);
4682 recover(ex,_tokenSet_43);
4683 }
4684 }
4685
src_port_part()4686 void PFCfgParser::src_port_part() {
4687
4688 try { // for error handling
4689 match(PORT);
4690 {
4691 switch ( LA(1)) {
4692 case WORD:
4693 case EQUAL:
4694 case INT_CONST:
4695 case LESS_THAN:
4696 case GREATER_THAN:
4697 case EXLAMATION:
4698 case IPV6:
4699 {
4700 port_op();
4701 break;
4702 }
4703 case OPENING_BRACE:
4704 {
4705 port_op_list();
4706 break;
4707 }
4708 default:
4709 {
4710 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4711 }
4712 }
4713 }
4714 #line 1752 "pf.g"
4715
4716 importer->src_port_group.splice(importer->src_port_group.begin(),
4717 importer->tmp_port_group);
4718
4719 #line 4720 "PFCfgParser.cpp"
4720 }
4721 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4722 reportError(ex);
4723 recover(ex,_tokenSet_42);
4724 }
4725 }
4726
dst_hosts_part()4727 void PFCfgParser::dst_hosts_part() {
4728
4729 try { // for error handling
4730 common_hosts_part();
4731 #line 1173 "pf.g"
4732
4733 importer->dst_neg = importer->tmp_neg;
4734 importer->dst_group.splice(importer->dst_group.begin(),
4735 importer->tmp_group);
4736
4737 #line 4738 "PFCfgParser.cpp"
4738 }
4739 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4740 reportError(ex);
4741 recover(ex,_tokenSet_44);
4742 }
4743 }
4744
dst_port_part()4745 void PFCfgParser::dst_port_part() {
4746
4747 try { // for error handling
4748 match(PORT);
4749 {
4750 switch ( LA(1)) {
4751 case WORD:
4752 case EQUAL:
4753 case INT_CONST:
4754 case LESS_THAN:
4755 case GREATER_THAN:
4756 case EXLAMATION:
4757 case IPV6:
4758 {
4759 port_op();
4760 break;
4761 }
4762 case OPENING_BRACE:
4763 {
4764 port_op_list();
4765 break;
4766 }
4767 default:
4768 {
4769 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4770 }
4771 }
4772 }
4773 #line 1765 "pf.g"
4774
4775 importer->dst_port_group.splice(importer->dst_port_group.begin(),
4776 importer->tmp_port_group);
4777
4778 #line 4779 "PFCfgParser.cpp"
4779 }
4780 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4781 reportError(ex);
4782 recover(ex,_tokenSet_19);
4783 }
4784 }
4785
common_hosts_part()4786 void PFCfgParser::common_hosts_part() {
4787
4788 try { // for error handling
4789 switch ( LA(1)) {
4790 case ANY:
4791 {
4792 match(ANY);
4793 #line 1182 "pf.g"
4794
4795 importer->tmp_group.push_back(
4796 AddressSpec(AddressSpec::ANY, false, "0.0.0.0", "0.0.0.0"));
4797
4798 #line 4799 "PFCfgParser.cpp"
4799 break;
4800 }
4801 case NO_ROUTE:
4802 {
4803 match(NO_ROUTE);
4804 #line 1188 "pf.g"
4805
4806 importer->tmp_group.push_back(
4807 AddressSpec(AddressSpec::SPECIAL_ADDRESS, false, "no-route", ""));
4808
4809 #line 4810 "PFCfgParser.cpp"
4810 break;
4811 }
4812 case WORD:
4813 case LESS_THAN:
4814 case EXLAMATION:
4815 case SELF:
4816 case IPV4:
4817 case OPENING_PAREN:
4818 case IPV6:
4819 case MACRO:
4820 {
4821 host();
4822 break;
4823 }
4824 case OPENING_BRACE:
4825 {
4826 host_list();
4827 break;
4828 }
4829 default:
4830 {
4831 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4832 }
4833 }
4834 }
4835 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4836 reportError(ex);
4837 recover(ex,_tokenSet_43);
4838 }
4839 }
4840
host()4841 void PFCfgParser::host() {
4842 ANTLR_USE_NAMESPACE(antlr)RefToken tn = ANTLR_USE_NAMESPACE(antlr)nullToken;
4843 ANTLR_USE_NAMESPACE(antlr)RefToken in = ANTLR_USE_NAMESPACE(antlr)nullToken;
4844 #line 1198 "pf.g"
4845 AddressSpec as;
4846 #line 4847 "PFCfgParser.cpp"
4847
4848 try { // for error handling
4849 {
4850 switch ( LA(1)) {
4851 case EXLAMATION:
4852 {
4853 match(EXLAMATION);
4854 #line 1199 "pf.g"
4855 as.neg = true;
4856 #line 4857 "PFCfgParser.cpp"
4857 break;
4858 }
4859 case WORD:
4860 case LESS_THAN:
4861 case SELF:
4862 case IPV4:
4863 case OPENING_PAREN:
4864 case IPV6:
4865 case MACRO:
4866 {
4867 break;
4868 }
4869 default:
4870 {
4871 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4872 }
4873 }
4874 }
4875 {
4876 switch ( LA(1)) {
4877 case WORD:
4878 case MACRO:
4879 {
4880 {
4881 switch ( LA(1)) {
4882 case WORD:
4883 {
4884 match(WORD);
4885 break;
4886 }
4887 case MACRO:
4888 {
4889 match(MACRO);
4890 break;
4891 }
4892 default:
4893 {
4894 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4895 }
4896 }
4897 }
4898 #line 1202 "pf.g"
4899
4900 // interface name or domain/host name
4901 as.at = AddressSpec::INTERFACE_OR_HOST_NAME;
4902 as.address = LT(0)->getText();
4903
4904 #line 4905 "PFCfgParser.cpp"
4905 {
4906 switch ( LA(1)) {
4907 case COLON:
4908 {
4909 match(COLON);
4910 {
4911 switch ( LA(1)) {
4912 case NETWORK:
4913 {
4914 match(NETWORK);
4915 #line 1211 "pf.g"
4916
4917 as.at = AddressSpec::INTERFACE_NETWORK;
4918
4919 #line 4920 "PFCfgParser.cpp"
4920 break;
4921 }
4922 case BROADCAST:
4923 {
4924 match(BROADCAST);
4925 #line 1216 "pf.g"
4926
4927 as.at = AddressSpec::INTERFACE_BROADCAST;
4928
4929 #line 4930 "PFCfgParser.cpp"
4930 break;
4931 }
4932 case PEER:
4933 {
4934 match(PEER);
4935 #line 1221 "pf.g"
4936
4937 importer->error_tracker->registerError(
4938 QString("import of 'interface:peer' is not supported."));
4939
4940 #line 4941 "PFCfgParser.cpp"
4941 break;
4942 }
4943 case INT_CONST:
4944 {
4945 match(INT_CONST);
4946 #line 1227 "pf.g"
4947
4948 importer->error_tracker->registerError(
4949 QString("import of 'interface:0' is not supported."));
4950
4951 #line 4952 "PFCfgParser.cpp"
4952 break;
4953 }
4954 default:
4955 {
4956 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
4957 }
4958 }
4959 }
4960 break;
4961 }
4962 case NEWLINE:
4963 case WORD:
4964 case QUEUE:
4965 case COMMA:
4966 case CLOSING_BRACE:
4967 case LITERAL_reassemble:
4968 case SCRUB:
4969 case LESS_THAN:
4970 case EXLAMATION:
4971 case SELF:
4972 case IPV4:
4973 case NO:
4974 case MINUS:
4975 case OPENING_PAREN:
4976 case PORT:
4977 case IPV6:
4978 case USER:
4979 case TO:
4980 case MACRO:
4981 case ROUTE_TO:
4982 case REPLY_TO:
4983 case DUP_TO:
4984 case GROUP:
4985 case LITERAL_fragment:
4986 case 146:
4987 case 147:
4988 case 148:
4989 case 149:
4990 case FLAGS:
4991 case ICMP_TYPE:
4992 case ICMP6_TYPE:
4993 case TAGGED:
4994 case TAG:
4995 case KEEP:
4996 case MODULATE:
4997 case SYNPROXY:
4998 case LABEL:
4999 {
5000 break;
5001 }
5002 default:
5003 {
5004 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5005 }
5006 }
5007 }
5008 break;
5009 }
5010 case SELF:
5011 {
5012 match(SELF);
5013 #line 1235 "pf.g"
5014
5015 as.at = AddressSpec::SPECIAL_ADDRESS;
5016 as.address = "self";
5017
5018 #line 5019 "PFCfgParser.cpp"
5019 break;
5020 }
5021 case IPV6:
5022 {
5023 match(IPV6);
5024 #line 1241 "pf.g"
5025
5026 importer->error_tracker->registerError(
5027 QString("IPv6 import is not supported. "));
5028 consumeUntil(NEWLINE);
5029
5030 #line 5031 "PFCfgParser.cpp"
5031 break;
5032 }
5033 case IPV4:
5034 {
5035 match(IPV4);
5036 #line 1248 "pf.g"
5037
5038 as.at = AddressSpec::HOST_ADDRESS;
5039 as.address = LT(0)->getText();
5040
5041 #line 5042 "PFCfgParser.cpp"
5042 {
5043 switch ( LA(1)) {
5044 case SLASH:
5045 {
5046 match(SLASH);
5047 #line 1254 "pf.g"
5048
5049 as.at = AddressSpec::NETWORK_ADDRESS;
5050
5051 #line 5052 "PFCfgParser.cpp"
5052 {
5053 switch ( LA(1)) {
5054 case IPV4:
5055 {
5056 match(IPV4);
5057 break;
5058 }
5059 case INT_CONST:
5060 {
5061 match(INT_CONST);
5062 break;
5063 }
5064 default:
5065 {
5066 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5067 }
5068 }
5069 }
5070 #line 1258 "pf.g"
5071
5072 as.netmask = LT(0)->getText();
5073
5074 #line 5075 "PFCfgParser.cpp"
5075 break;
5076 }
5077 case NEWLINE:
5078 case WORD:
5079 case QUEUE:
5080 case COMMA:
5081 case CLOSING_BRACE:
5082 case LITERAL_reassemble:
5083 case SCRUB:
5084 case LESS_THAN:
5085 case EXLAMATION:
5086 case SELF:
5087 case IPV4:
5088 case NO:
5089 case MINUS:
5090 case OPENING_PAREN:
5091 case PORT:
5092 case IPV6:
5093 case USER:
5094 case TO:
5095 case MACRO:
5096 case ROUTE_TO:
5097 case REPLY_TO:
5098 case DUP_TO:
5099 case GROUP:
5100 case LITERAL_fragment:
5101 case 146:
5102 case 147:
5103 case 148:
5104 case 149:
5105 case FLAGS:
5106 case ICMP_TYPE:
5107 case ICMP6_TYPE:
5108 case TAGGED:
5109 case TAG:
5110 case KEEP:
5111 case MODULATE:
5112 case SYNPROXY:
5113 case LABEL:
5114 {
5115 break;
5116 }
5117 default:
5118 {
5119 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5120 }
5121 }
5122 }
5123 break;
5124 }
5125 case LESS_THAN:
5126 {
5127 match(LESS_THAN);
5128 tn = LT(1);
5129 match(WORD);
5130 match(GREATER_THAN);
5131 #line 1264 "pf.g"
5132
5133 as.at = AddressSpec::TABLE;
5134 as.address = tn->getText();
5135
5136 #line 5137 "PFCfgParser.cpp"
5137 break;
5138 }
5139 case OPENING_PAREN:
5140 {
5141 match(OPENING_PAREN);
5142 in = LT(1);
5143 match(WORD);
5144 match(CLOSING_PAREN);
5145 #line 1270 "pf.g"
5146
5147 // interface name or domain/host name
5148 as.at = AddressSpec::INTERFACE_OR_HOST_NAME;
5149 as.address = in->getText();
5150
5151 #line 5152 "PFCfgParser.cpp"
5152 break;
5153 }
5154 default:
5155 {
5156 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5157 }
5158 }
5159 }
5160 #line 1276 "pf.g"
5161
5162 importer->tmp_group.push_back(as);
5163
5164 #line 5165 "PFCfgParser.cpp"
5165 }
5166 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5167 reportError(ex);
5168 recover(ex,_tokenSet_45);
5169 }
5170 }
5171
host_list()5172 void PFCfgParser::host_list() {
5173
5174 try { // for error handling
5175 match(OPENING_BRACE);
5176 host();
5177 { // ( ... )*
5178 for (;;) {
5179 if ((_tokenSet_46.member(LA(1)))) {
5180 {
5181 switch ( LA(1)) {
5182 case COMMA:
5183 {
5184 match(COMMA);
5185 break;
5186 }
5187 case WORD:
5188 case LESS_THAN:
5189 case EXLAMATION:
5190 case SELF:
5191 case IPV4:
5192 case OPENING_PAREN:
5193 case IPV6:
5194 case MACRO:
5195 {
5196 break;
5197 }
5198 default:
5199 {
5200 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5201 }
5202 }
5203 }
5204 host();
5205 }
5206 else {
5207 goto _loop185;
5208 }
5209
5210 }
5211 _loop185:;
5212 } // ( ... )*
5213 match(CLOSING_BRACE);
5214 }
5215 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5216 reportError(ex);
5217 recover(ex,_tokenSet_43);
5218 }
5219 }
5220
route_to()5221 void PFCfgParser::route_to() {
5222
5223 try { // for error handling
5224 match(ROUTE_TO);
5225 {
5226 switch ( LA(1)) {
5227 case OPENING_PAREN:
5228 {
5229 routehost();
5230 break;
5231 }
5232 case OPENING_BRACE:
5233 {
5234 routehost_list();
5235 break;
5236 }
5237 default:
5238 {
5239 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5240 }
5241 }
5242 }
5243 {
5244 switch ( LA(1)) {
5245 case BITMASK:
5246 case RANDOM:
5247 case SOURCE_HASH:
5248 case ROUND_ROBIN:
5249 {
5250 pooltype();
5251 break;
5252 }
5253 case NEWLINE:
5254 case QUEUE:
5255 case LITERAL_reassemble:
5256 case SCRUB:
5257 case EXLAMATION:
5258 case NO:
5259 case OPENING_PAREN:
5260 case ALL:
5261 case USER:
5262 case TO:
5263 case INET:
5264 case INET6:
5265 case PROTO:
5266 case FROM:
5267 case ROUTE_TO:
5268 case REPLY_TO:
5269 case DUP_TO:
5270 case GROUP:
5271 case LITERAL_fragment:
5272 case 146:
5273 case 147:
5274 case 148:
5275 case 149:
5276 case FLAGS:
5277 case ICMP_TYPE:
5278 case ICMP6_TYPE:
5279 case TAGGED:
5280 case TAG:
5281 case KEEP:
5282 case MODULATE:
5283 case SYNPROXY:
5284 case LABEL:
5285 {
5286 break;
5287 }
5288 default:
5289 {
5290 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5291 }
5292 }
5293 }
5294 #line 1298 "pf.g"
5295
5296 importer->route_type = PFImporter::ROUTE_TO;
5297
5298 #line 5299 "PFCfgParser.cpp"
5299 }
5300 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5301 reportError(ex);
5302 recover(ex,_tokenSet_7);
5303 }
5304 }
5305
reply_to()5306 void PFCfgParser::reply_to() {
5307
5308 try { // for error handling
5309 match(REPLY_TO);
5310 {
5311 switch ( LA(1)) {
5312 case OPENING_PAREN:
5313 {
5314 routehost();
5315 break;
5316 }
5317 case OPENING_BRACE:
5318 {
5319 routehost_list();
5320 break;
5321 }
5322 default:
5323 {
5324 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5325 }
5326 }
5327 }
5328 {
5329 switch ( LA(1)) {
5330 case BITMASK:
5331 case RANDOM:
5332 case SOURCE_HASH:
5333 case ROUND_ROBIN:
5334 {
5335 pooltype();
5336 break;
5337 }
5338 case NEWLINE:
5339 case QUEUE:
5340 case LITERAL_reassemble:
5341 case SCRUB:
5342 case EXLAMATION:
5343 case NO:
5344 case OPENING_PAREN:
5345 case ALL:
5346 case USER:
5347 case TO:
5348 case INET:
5349 case INET6:
5350 case PROTO:
5351 case FROM:
5352 case ROUTE_TO:
5353 case REPLY_TO:
5354 case DUP_TO:
5355 case GROUP:
5356 case LITERAL_fragment:
5357 case 146:
5358 case 147:
5359 case 148:
5360 case 149:
5361 case FLAGS:
5362 case ICMP_TYPE:
5363 case ICMP6_TYPE:
5364 case TAGGED:
5365 case TAG:
5366 case KEEP:
5367 case MODULATE:
5368 case SYNPROXY:
5369 case LABEL:
5370 {
5371 break;
5372 }
5373 default:
5374 {
5375 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5376 }
5377 }
5378 }
5379 #line 1305 "pf.g"
5380
5381 importer->route_type = PFImporter::REPLY_TO;
5382
5383 #line 5384 "PFCfgParser.cpp"
5384 }
5385 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5386 reportError(ex);
5387 recover(ex,_tokenSet_7);
5388 }
5389 }
5390
dup_to()5391 void PFCfgParser::dup_to() {
5392
5393 try { // for error handling
5394 match(DUP_TO);
5395 {
5396 switch ( LA(1)) {
5397 case OPENING_PAREN:
5398 {
5399 routehost();
5400 break;
5401 }
5402 case OPENING_BRACE:
5403 {
5404 routehost_list();
5405 break;
5406 }
5407 default:
5408 {
5409 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5410 }
5411 }
5412 }
5413 {
5414 switch ( LA(1)) {
5415 case BITMASK:
5416 case RANDOM:
5417 case SOURCE_HASH:
5418 case ROUND_ROBIN:
5419 {
5420 pooltype();
5421 break;
5422 }
5423 case NEWLINE:
5424 case QUEUE:
5425 case LITERAL_reassemble:
5426 case SCRUB:
5427 case EXLAMATION:
5428 case NO:
5429 case OPENING_PAREN:
5430 case ALL:
5431 case USER:
5432 case TO:
5433 case INET:
5434 case INET6:
5435 case PROTO:
5436 case FROM:
5437 case ROUTE_TO:
5438 case REPLY_TO:
5439 case DUP_TO:
5440 case GROUP:
5441 case LITERAL_fragment:
5442 case 146:
5443 case 147:
5444 case 148:
5445 case 149:
5446 case FLAGS:
5447 case ICMP_TYPE:
5448 case ICMP6_TYPE:
5449 case TAGGED:
5450 case TAG:
5451 case KEEP:
5452 case MODULATE:
5453 case SYNPROXY:
5454 case LABEL:
5455 {
5456 break;
5457 }
5458 default:
5459 {
5460 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5461 }
5462 }
5463 }
5464 #line 1312 "pf.g"
5465
5466 importer->route_type = PFImporter::DUP_TO;
5467
5468 #line 5469 "PFCfgParser.cpp"
5469 }
5470 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5471 reportError(ex);
5472 recover(ex,_tokenSet_7);
5473 }
5474 }
5475
routehost()5476 void PFCfgParser::routehost() {
5477 ANTLR_USE_NAMESPACE(antlr)RefToken h = ANTLR_USE_NAMESPACE(antlr)nullToken;
5478 ANTLR_USE_NAMESPACE(antlr)RefToken v6 = ANTLR_USE_NAMESPACE(antlr)nullToken;
5479 ANTLR_USE_NAMESPACE(antlr)RefToken nm = ANTLR_USE_NAMESPACE(antlr)nullToken;
5480 ANTLR_USE_NAMESPACE(antlr)RefToken nm6 = ANTLR_USE_NAMESPACE(antlr)nullToken;
5481 #line 1317 "pf.g"
5482 RouteSpec rs;
5483 #line 5484 "PFCfgParser.cpp"
5484
5485 try { // for error handling
5486 match(OPENING_PAREN);
5487 match(WORD);
5488 #line 1319 "pf.g"
5489 rs.iface = LT(0)->getText();
5490 #line 5491 "PFCfgParser.cpp"
5491 {
5492 switch ( LA(1)) {
5493 case IPV4:
5494 {
5495 h = LT(1);
5496 match(IPV4);
5497 break;
5498 }
5499 case IPV6:
5500 {
5501 v6 = LT(1);
5502 match(IPV6);
5503 break;
5504 }
5505 default:
5506 {
5507 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5508 }
5509 }
5510 }
5511 {
5512 switch ( LA(1)) {
5513 case SLASH:
5514 {
5515 match(SLASH);
5516 {
5517 switch ( LA(1)) {
5518 case IPV4:
5519 {
5520 nm = LT(1);
5521 match(IPV4);
5522 break;
5523 }
5524 case INT_CONST:
5525 {
5526 nm6 = LT(1);
5527 match(INT_CONST);
5528 break;
5529 }
5530 default:
5531 {
5532 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5533 }
5534 }
5535 }
5536 break;
5537 }
5538 case CLOSING_PAREN:
5539 {
5540 break;
5541 }
5542 default:
5543 {
5544 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5545 }
5546 }
5547 }
5548 #line 1321 "pf.g"
5549
5550 if (v6)
5551 {
5552 importer->error_tracker->registerError(
5553 QString("IPv6 import is not supported. "));
5554 consumeUntil(NEWLINE);
5555 } else
5556 {
5557 if (h) rs.address = h->getText();
5558 if (nm) rs.netmask = nm->getText();
5559 importer->route_group.push_back(rs);
5560 }
5561
5562 #line 5563 "PFCfgParser.cpp"
5563 match(CLOSING_PAREN);
5564 }
5565 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5566 reportError(ex);
5567 recover(ex,_tokenSet_47);
5568 }
5569 }
5570
routehost_list()5571 void PFCfgParser::routehost_list() {
5572
5573 try { // for error handling
5574 match(OPENING_BRACE);
5575 routehost();
5576 { // ( ... )*
5577 for (;;) {
5578 if ((LA(1) == COMMA || LA(1) == OPENING_PAREN)) {
5579 {
5580 switch ( LA(1)) {
5581 case COMMA:
5582 {
5583 match(COMMA);
5584 break;
5585 }
5586 case OPENING_PAREN:
5587 {
5588 break;
5589 }
5590 default:
5591 {
5592 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5593 }
5594 }
5595 }
5596 routehost();
5597 }
5598 else {
5599 goto _loop203;
5600 }
5601
5602 }
5603 _loop203:;
5604 } // ( ... )*
5605 match(CLOSING_BRACE);
5606 }
5607 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5608 reportError(ex);
5609 recover(ex,_tokenSet_48);
5610 }
5611 }
5612
filteropt()5613 void PFCfgParser::filteropt() {
5614
5615 try { // for error handling
5616 switch ( LA(1)) {
5617 case USER:
5618 {
5619 user_match();
5620 break;
5621 }
5622 case GROUP:
5623 {
5624 group_match();
5625 break;
5626 }
5627 case FLAGS:
5628 {
5629 tcp_flags();
5630 break;
5631 }
5632 case ICMP_TYPE:
5633 {
5634 icmp_type();
5635 break;
5636 }
5637 case ICMP6_TYPE:
5638 {
5639 icmp6_type();
5640 break;
5641 }
5642 case EXLAMATION:
5643 case TAGGED:
5644 {
5645 tagged();
5646 break;
5647 }
5648 case TAG:
5649 {
5650 tag_clause();
5651 break;
5652 }
5653 case NO:
5654 case KEEP:
5655 case MODULATE:
5656 case SYNPROXY:
5657 {
5658 state();
5659 break;
5660 }
5661 case QUEUE:
5662 {
5663 queue();
5664 break;
5665 }
5666 case LABEL:
5667 {
5668 label();
5669 break;
5670 }
5671 case SCRUB:
5672 {
5673 match_rule_scrub_options();
5674 break;
5675 }
5676 case LITERAL_reassemble:
5677 case OPENING_PAREN:
5678 case LITERAL_fragment:
5679 case 146:
5680 case 147:
5681 case 148:
5682 case 149:
5683 {
5684 scrub_options();
5685 break;
5686 }
5687 default:
5688 {
5689 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5690 }
5691 }
5692 }
5693 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5694 reportError(ex);
5695 recover(ex,_tokenSet_49);
5696 }
5697 }
5698
user_match()5699 void PFCfgParser::user_match() {
5700
5701 try { // for error handling
5702 match(USER);
5703 {
5704 switch ( LA(1)) {
5705 case WORD:
5706 case EQUAL:
5707 case INT_CONST:
5708 case LESS_THAN:
5709 case GREATER_THAN:
5710 case EXLAMATION:
5711 {
5712 user_group_op();
5713 break;
5714 }
5715 case OPENING_BRACE:
5716 {
5717 user_group_op_list();
5718 break;
5719 }
5720 default:
5721 {
5722 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5723 }
5724 }
5725 }
5726 #line 1386 "pf.g"
5727
5728 importer->addMessageToLog(
5729 QString("Error: import of 'user' match is not supported."));
5730
5731 #line 5732 "PFCfgParser.cpp"
5732 }
5733 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5734 reportError(ex);
5735 recover(ex,_tokenSet_49);
5736 }
5737 }
5738
group_match()5739 void PFCfgParser::group_match() {
5740
5741 try { // for error handling
5742 match(GROUP);
5743 {
5744 switch ( LA(1)) {
5745 case WORD:
5746 case EQUAL:
5747 case INT_CONST:
5748 case LESS_THAN:
5749 case GREATER_THAN:
5750 case EXLAMATION:
5751 {
5752 user_group_op();
5753 break;
5754 }
5755 case OPENING_BRACE:
5756 {
5757 user_group_op_list();
5758 break;
5759 }
5760 default:
5761 {
5762 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5763 }
5764 }
5765 }
5766 #line 1395 "pf.g"
5767
5768 importer->addMessageToLog(
5769 QString("Error: import of 'group' match is not supported."));
5770
5771 #line 5772 "PFCfgParser.cpp"
5772 }
5773 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5774 reportError(ex);
5775 recover(ex,_tokenSet_49);
5776 }
5777 }
5778
tcp_flags()5779 void PFCfgParser::tcp_flags() {
5780 ANTLR_USE_NAMESPACE(antlr)RefToken check = ANTLR_USE_NAMESPACE(antlr)nullToken;
5781 ANTLR_USE_NAMESPACE(antlr)RefToken mask = ANTLR_USE_NAMESPACE(antlr)nullToken;
5782
5783 try { // for error handling
5784 match(FLAGS);
5785 {
5786 switch ( LA(1)) {
5787 case ANY:
5788 {
5789 match(ANY);
5790 #line 1505 "pf.g"
5791
5792 importer->flags_check = "none";
5793 importer->flags_mask = "none";
5794
5795 #line 5796 "PFCfgParser.cpp"
5796 break;
5797 }
5798 case WORD:
5799 case SLASH:
5800 {
5801 {
5802 switch ( LA(1)) {
5803 case WORD:
5804 {
5805 check = LT(1);
5806 match(WORD);
5807 break;
5808 }
5809 case SLASH:
5810 {
5811 break;
5812 }
5813 default:
5814 {
5815 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5816 }
5817 }
5818 }
5819 match(SLASH);
5820 {
5821 switch ( LA(1)) {
5822 case WORD:
5823 {
5824 mask = LT(1);
5825 match(WORD);
5826 break;
5827 }
5828 case NEWLINE:
5829 case QUEUE:
5830 case COMMA:
5831 case LITERAL_reassemble:
5832 case SCRUB:
5833 case EXLAMATION:
5834 case NO:
5835 case OPENING_PAREN:
5836 case USER:
5837 case ROUTE_TO:
5838 case REPLY_TO:
5839 case DUP_TO:
5840 case GROUP:
5841 case LITERAL_fragment:
5842 case 146:
5843 case 147:
5844 case 148:
5845 case 149:
5846 case FLAGS:
5847 case ICMP_TYPE:
5848 case ICMP6_TYPE:
5849 case TAGGED:
5850 case TAG:
5851 case KEEP:
5852 case MODULATE:
5853 case SYNPROXY:
5854 case LABEL:
5855 {
5856 break;
5857 }
5858 default:
5859 {
5860 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5861 }
5862 }
5863 }
5864 #line 1511 "pf.g"
5865
5866 if (check)
5867 importer->flags_check = check->getText();
5868 else
5869 importer->flags_check = "any";
5870 if (mask)
5871 importer->flags_mask = mask->getText();
5872 else
5873 importer->flags_mask = "all";
5874
5875 #line 5876 "PFCfgParser.cpp"
5876 break;
5877 }
5878 default:
5879 {
5880 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5881 }
5882 }
5883 }
5884 }
5885 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5886 reportError(ex);
5887 recover(ex,_tokenSet_49);
5888 }
5889 }
5890
icmp_type()5891 void PFCfgParser::icmp_type() {
5892
5893 try { // for error handling
5894 match(ICMP_TYPE);
5895 {
5896 switch ( LA(1)) {
5897 case LITERAL_skip:
5898 case INT_CONST:
5899 case LITERAL_echorep:
5900 case LITERAL_unreach:
5901 case LITERAL_squench:
5902 case LITERAL_redir:
5903 case LITERAL_althost:
5904 case LITERAL_echoreq:
5905 case LITERAL_routeradv:
5906 case LITERAL_routersol:
5907 case LITERAL_timex:
5908 case LITERAL_paramprob:
5909 case LITERAL_timereq:
5910 case LITERAL_timerep:
5911 case LITERAL_inforeq:
5912 case LITERAL_inforep:
5913 case LITERAL_maskreq:
5914 case LITERAL_maskrep:
5915 case LITERAL_trace:
5916 case LITERAL_dataconv:
5917 case LITERAL_mobredir:
5918 case 172:
5919 case 173:
5920 case LITERAL_mobregreq:
5921 case LITERAL_mobregrep:
5922 case LITERAL_photuris:
5923 {
5924 icmp_type_code();
5925 break;
5926 }
5927 case OPENING_BRACE:
5928 {
5929 icmp_list();
5930 break;
5931 }
5932 default:
5933 {
5934 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5935 }
5936 }
5937 }
5938 }
5939 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5940 reportError(ex);
5941 recover(ex,_tokenSet_49);
5942 }
5943 }
5944
icmp6_type()5945 void PFCfgParser::icmp6_type() {
5946
5947 try { // for error handling
5948 match(ICMP6_TYPE);
5949 #line 1686 "pf.g"
5950
5951 importer->error_tracker->registerError(
5952 QString("ICMP6 import is not supported. "));
5953 consumeUntil(NEWLINE);
5954
5955 #line 5956 "PFCfgParser.cpp"
5956 }
5957 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
5958 reportError(ex);
5959 recover(ex,_tokenSet_49);
5960 }
5961 }
5962
state()5963 void PFCfgParser::state() {
5964
5965 try { // for error handling
5966 {
5967 switch ( LA(1)) {
5968 case NO:
5969 {
5970 match(NO);
5971 break;
5972 }
5973 case KEEP:
5974 {
5975 match(KEEP);
5976 break;
5977 }
5978 case MODULATE:
5979 {
5980 match(MODULATE);
5981 break;
5982 }
5983 case SYNPROXY:
5984 {
5985 match(SYNPROXY);
5986 break;
5987 }
5988 default:
5989 {
5990 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
5991 }
5992 }
5993 }
5994 #line 1718 "pf.g"
5995
5996 importer->state_op = LT(0)->getText();
5997
5998 #line 5999 "PFCfgParser.cpp"
5999 match(STATE);
6000 }
6001 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6002 reportError(ex);
6003 recover(ex,_tokenSet_49);
6004 }
6005 }
6006
queue()6007 void PFCfgParser::queue() {
6008
6009 try { // for error handling
6010 match(QUEUE);
6011 {
6012 switch ( LA(1)) {
6013 case WORD:
6014 {
6015 match(WORD);
6016 #line 1727 "pf.g"
6017 importer->queue += LT(0)->getText();
6018 #line 6019 "PFCfgParser.cpp"
6019 break;
6020 }
6021 case OPENING_PAREN:
6022 {
6023 match(OPENING_PAREN);
6024 match(WORD);
6025 #line 1730 "pf.g"
6026 importer->queue += LT(0)->getText();
6027 #line 6028 "PFCfgParser.cpp"
6028 { // ( ... )*
6029 for (;;) {
6030 if ((LA(1) == COMMA)) {
6031 match(COMMA);
6032 #line 1732 "pf.g"
6033 importer->queue += ",";
6034 #line 6035 "PFCfgParser.cpp"
6035 match(WORD);
6036 #line 1733 "pf.g"
6037 importer->queue += LT(0)->getText();
6038 #line 6039 "PFCfgParser.cpp"
6039 }
6040 else {
6041 goto _loop260;
6042 }
6043
6044 }
6045 _loop260:;
6046 } // ( ... )*
6047 match(CLOSING_PAREN);
6048 break;
6049 }
6050 default:
6051 {
6052 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6053 }
6054 }
6055 }
6056 }
6057 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6058 reportError(ex);
6059 recover(ex,_tokenSet_49);
6060 }
6061 }
6062
label()6063 void PFCfgParser::label() {
6064
6065 try { // for error handling
6066 match(LABEL);
6067 match(STRING);
6068 }
6069 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6070 reportError(ex);
6071 recover(ex,_tokenSet_49);
6072 }
6073 }
6074
match_rule_scrub_options()6075 void PFCfgParser::match_rule_scrub_options() {
6076
6077 try { // for error handling
6078 match(SCRUB);
6079 scrub_options();
6080 }
6081 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6082 reportError(ex);
6083 recover(ex,_tokenSet_49);
6084 }
6085 }
6086
scrub_options()6087 void PFCfgParser::scrub_options() {
6088
6089 try { // for error handling
6090 {
6091 switch ( LA(1)) {
6092 case LITERAL_reassemble:
6093 case LITERAL_fragment:
6094 case 146:
6095 case 147:
6096 case 148:
6097 case 149:
6098 {
6099 scrub_option();
6100 break;
6101 }
6102 case OPENING_PAREN:
6103 {
6104 scrub_option_list();
6105 break;
6106 }
6107 default:
6108 {
6109 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6110 }
6111 }
6112 }
6113 }
6114 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6115 reportError(ex);
6116 recover(ex,_tokenSet_49);
6117 }
6118 }
6119
user_group_op()6120 void PFCfgParser::user_group_op() {
6121
6122 try { // for error handling
6123 {
6124 switch ( LA(1)) {
6125 case EQUAL:
6126 case LESS_THAN:
6127 case GREATER_THAN:
6128 case EXLAMATION:
6129 {
6130 unary_op();
6131 {
6132 switch ( LA(1)) {
6133 case WORD:
6134 {
6135 match(WORD);
6136 break;
6137 }
6138 case INT_CONST:
6139 {
6140 match(INT_CONST);
6141 break;
6142 }
6143 default:
6144 {
6145 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6146 }
6147 }
6148 }
6149 break;
6150 }
6151 case WORD:
6152 case INT_CONST:
6153 {
6154 {
6155 switch ( LA(1)) {
6156 case WORD:
6157 {
6158 match(WORD);
6159 break;
6160 }
6161 case INT_CONST:
6162 {
6163 match(INT_CONST);
6164 break;
6165 }
6166 default:
6167 {
6168 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6169 }
6170 }
6171 }
6172 {
6173 if ((LA(1) == LESS_THAN || LA(1) == GREATER_THAN || LA(1) == COLON) && (_tokenSet_50.member(LA(2)))) {
6174 binary_op();
6175 {
6176 switch ( LA(1)) {
6177 case WORD:
6178 {
6179 match(WORD);
6180 break;
6181 }
6182 case INT_CONST:
6183 {
6184 match(INT_CONST);
6185 break;
6186 }
6187 default:
6188 {
6189 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6190 }
6191 }
6192 }
6193 }
6194 else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
6195 }
6196 else {
6197 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6198 }
6199
6200 }
6201 break;
6202 }
6203 default:
6204 {
6205 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6206 }
6207 }
6208 }
6209 }
6210 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6211 reportError(ex);
6212 recover(ex,_tokenSet_51);
6213 }
6214 }
6215
user_group_op_list()6216 void PFCfgParser::user_group_op_list() {
6217
6218 try { // for error handling
6219 match(OPENING_BRACE);
6220 user_group_op();
6221 { // ( ... )*
6222 for (;;) {
6223 if ((_tokenSet_53.member(LA(1)))) {
6224 {
6225 switch ( LA(1)) {
6226 case COMMA:
6227 {
6228 match(COMMA);
6229 break;
6230 }
6231 case WORD:
6232 case EQUAL:
6233 case INT_CONST:
6234 case LESS_THAN:
6235 case GREATER_THAN:
6236 case EXLAMATION:
6237 {
6238 break;
6239 }
6240 default:
6241 {
6242 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6243 }
6244 }
6245 }
6246 user_group_op();
6247 }
6248 else {
6249 goto _loop222;
6250 }
6251
6252 }
6253 _loop222:;
6254 } // ( ... )*
6255 match(CLOSING_BRACE);
6256 }
6257 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6258 reportError(ex);
6259 recover(ex,_tokenSet_49);
6260 }
6261 }
6262
unary_op()6263 void PFCfgParser::unary_op() {
6264
6265 try { // for error handling
6266 {
6267 switch ( LA(1)) {
6268 case EQUAL:
6269 {
6270 match(EQUAL);
6271 #line 1773 "pf.g"
6272 importer->tmp_port_op = "=";
6273 #line 6274 "PFCfgParser.cpp"
6274 break;
6275 }
6276 case EXLAMATION:
6277 {
6278 match(EXLAMATION);
6279 match(EQUAL);
6280 #line 1775 "pf.g"
6281 importer->tmp_port_op = "!=";
6282 #line 6283 "PFCfgParser.cpp"
6283 break;
6284 }
6285 default:
6286 if ((LA(1) == LESS_THAN) && (LA(2) == WORD || LA(2) == INT_CONST)) {
6287 match(LESS_THAN);
6288 #line 1777 "pf.g"
6289 importer->tmp_port_op = "<";
6290 #line 6291 "PFCfgParser.cpp"
6291 }
6292 else if ((LA(1) == LESS_THAN) && (LA(2) == EQUAL)) {
6293 match(LESS_THAN);
6294 match(EQUAL);
6295 #line 1779 "pf.g"
6296 importer->tmp_port_op = "<=";
6297 #line 6298 "PFCfgParser.cpp"
6298 }
6299 else if ((LA(1) == GREATER_THAN) && (LA(2) == WORD || LA(2) == INT_CONST)) {
6300 match(GREATER_THAN);
6301 #line 1781 "pf.g"
6302 importer->tmp_port_op = ">";
6303 #line 6304 "PFCfgParser.cpp"
6304 }
6305 else if ((LA(1) == GREATER_THAN) && (LA(2) == EQUAL)) {
6306 match(GREATER_THAN);
6307 match(EQUAL);
6308 #line 1783 "pf.g"
6309 importer->tmp_port_op = ">=";
6310 #line 6311 "PFCfgParser.cpp"
6311 }
6312 else {
6313 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6314 }
6315 }
6316 }
6317 }
6318 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6319 reportError(ex);
6320 recover(ex,_tokenSet_54);
6321 }
6322 }
6323
binary_op()6324 void PFCfgParser::binary_op() {
6325
6326 try { // for error handling
6327 {
6328 switch ( LA(1)) {
6329 case LESS_THAN:
6330 {
6331 match(LESS_THAN);
6332 match(GREATER_THAN);
6333 #line 1789 "pf.g"
6334 importer->tmp_port_op = "<>";
6335 #line 6336 "PFCfgParser.cpp"
6336 break;
6337 }
6338 case GREATER_THAN:
6339 {
6340 match(GREATER_THAN);
6341 match(LESS_THAN);
6342 #line 1791 "pf.g"
6343 importer->tmp_port_op = "><";
6344 #line 6345 "PFCfgParser.cpp"
6345 break;
6346 }
6347 case COLON:
6348 {
6349 match(COLON);
6350 #line 1793 "pf.g"
6351 importer->tmp_port_op = ":";
6352 #line 6353 "PFCfgParser.cpp"
6353 break;
6354 }
6355 default:
6356 {
6357 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6358 }
6359 }
6360 }
6361 }
6362 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6363 reportError(ex);
6364 recover(ex,_tokenSet_54);
6365 }
6366 }
6367
scrub_option()6368 void PFCfgParser::scrub_option() {
6369
6370 try { // for error handling
6371 {
6372 switch ( LA(1)) {
6373 case LITERAL_fragment:
6374 {
6375 match(LITERAL_fragment);
6376 {
6377 switch ( LA(1)) {
6378 case LITERAL_reassemble:
6379 {
6380 match(LITERAL_reassemble);
6381 break;
6382 }
6383 case LITERAL_crop:
6384 {
6385 match(LITERAL_crop);
6386 break;
6387 }
6388 case 145:
6389 {
6390 match(145);
6391 break;
6392 }
6393 default:
6394 {
6395 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6396 }
6397 }
6398 }
6399 #line 1457 "pf.g"
6400
6401 importer->scrub_options.push_back(
6402 str_tuple("fragment", LT(0)->getText()));
6403 importer->scrub_rule = true;
6404
6405 #line 6406 "PFCfgParser.cpp"
6406 break;
6407 }
6408 case LITERAL_reassemble:
6409 {
6410 match(LITERAL_reassemble);
6411 match(TCP);
6412 #line 1464 "pf.g"
6413
6414 importer->scrub_options.push_back(
6415 str_tuple("reassemble", "tcp"));
6416 importer->scrub_rule = true;
6417
6418 #line 6419 "PFCfgParser.cpp"
6419 break;
6420 }
6421 case 146:
6422 {
6423 match(146);
6424 #line 1471 "pf.g"
6425
6426 importer->scrub_options.push_back(
6427 str_tuple(LT(0)->getText(), ""));
6428 importer->scrub_rule = true;
6429
6430 #line 6431 "PFCfgParser.cpp"
6431 break;
6432 }
6433 case 147:
6434 {
6435 match(147);
6436 match(INT_CONST);
6437 #line 1478 "pf.g"
6438
6439 importer->scrub_options.push_back(
6440 str_tuple("min-ttl", LT(0)->getText()));
6441 importer->scrub_rule = true;
6442
6443 #line 6444 "PFCfgParser.cpp"
6444 break;
6445 }
6446 case 148:
6447 {
6448 match(148);
6449 match(INT_CONST);
6450 #line 1485 "pf.g"
6451
6452 importer->scrub_options.push_back(
6453 str_tuple("max-mss", LT(0)->getText()));
6454 importer->scrub_rule = true;
6455
6456 #line 6457 "PFCfgParser.cpp"
6457 break;
6458 }
6459 case 149:
6460 {
6461 match(149);
6462 #line 1492 "pf.g"
6463
6464 importer->scrub_options.push_back(
6465 str_tuple(LT(0)->getText(), ""));
6466 importer->scrub_rule = true;
6467
6468 #line 6469 "PFCfgParser.cpp"
6469 break;
6470 }
6471 default:
6472 {
6473 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6474 }
6475 }
6476 }
6477 }
6478 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6479 reportError(ex);
6480 recover(ex,_tokenSet_55);
6481 }
6482 }
6483
scrub_option_list()6484 void PFCfgParser::scrub_option_list() {
6485
6486 try { // for error handling
6487 match(OPENING_PAREN);
6488 scrub_option();
6489 { // ( ... )*
6490 for (;;) {
6491 if ((_tokenSet_56.member(LA(1)))) {
6492 {
6493 switch ( LA(1)) {
6494 case COMMA:
6495 {
6496 match(COMMA);
6497 break;
6498 }
6499 case LITERAL_reassemble:
6500 case LITERAL_fragment:
6501 case 146:
6502 case 147:
6503 case 148:
6504 case 149:
6505 {
6506 break;
6507 }
6508 default:
6509 {
6510 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6511 }
6512 }
6513 }
6514 scrub_option();
6515 }
6516 else {
6517 goto _loop229;
6518 }
6519
6520 }
6521 _loop229:;
6522 } // ( ... )*
6523 match(CLOSING_PAREN);
6524 }
6525 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6526 reportError(ex);
6527 recover(ex,_tokenSet_49);
6528 }
6529 }
6530
icmp_type_code()6531 void PFCfgParser::icmp_type_code() {
6532 #line 1533 "pf.g"
6533 IcmpSpec is;
6534 #line 6535 "PFCfgParser.cpp"
6535
6536 try { // for error handling
6537 {
6538 switch ( LA(1)) {
6539 case LITERAL_skip:
6540 case LITERAL_echorep:
6541 case LITERAL_unreach:
6542 case LITERAL_squench:
6543 case LITERAL_redir:
6544 case LITERAL_althost:
6545 case LITERAL_echoreq:
6546 case LITERAL_routeradv:
6547 case LITERAL_routersol:
6548 case LITERAL_timex:
6549 case LITERAL_paramprob:
6550 case LITERAL_timereq:
6551 case LITERAL_timerep:
6552 case LITERAL_inforeq:
6553 case LITERAL_inforep:
6554 case LITERAL_maskreq:
6555 case LITERAL_maskrep:
6556 case LITERAL_trace:
6557 case LITERAL_dataconv:
6558 case LITERAL_mobredir:
6559 case 172:
6560 case 173:
6561 case LITERAL_mobregreq:
6562 case LITERAL_mobregrep:
6563 case LITERAL_photuris:
6564 {
6565 icmp_type_by_name();
6566 #line 1535 "pf.g"
6567 is.icmp_type_name = LT(0)->getText();
6568 #line 6569 "PFCfgParser.cpp"
6569 break;
6570 }
6571 case INT_CONST:
6572 {
6573 match(INT_CONST);
6574 #line 1537 "pf.g"
6575 is.icmp_type_int = LT(0)->getText();
6576 #line 6577 "PFCfgParser.cpp"
6577 break;
6578 }
6579 default:
6580 {
6581 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6582 }
6583 }
6584 }
6585 {
6586 switch ( LA(1)) {
6587 case ICMP_CODE:
6588 {
6589 match(ICMP_CODE);
6590 {
6591 switch ( LA(1)) {
6592 case 177:
6593 case 178:
6594 case 179:
6595 case 180:
6596 case LITERAL_needfrag:
6597 case LITERAL_srcfail:
6598 case 183:
6599 case 184:
6600 case LITERAL_isolate:
6601 case 186:
6602 case 187:
6603 case 188:
6604 case 189:
6605 case 190:
6606 case 191:
6607 case 192:
6608 case 193:
6609 case 194:
6610 case 195:
6611 case 196:
6612 case 197:
6613 case 198:
6614 case LITERAL_transit:
6615 case LITERAL_reassemb:
6616 case LITERAL_badhead:
6617 case LITERAL_optmiss:
6618 case LITERAL_badlen:
6619 case 204:
6620 case 205:
6621 case 206:
6622 {
6623 icmp_code_by_name();
6624 #line 1543 "pf.g"
6625 is.icmp_code_name = LT(0)->getText();
6626 #line 6627 "PFCfgParser.cpp"
6627 break;
6628 }
6629 case INT_CONST:
6630 {
6631 match(INT_CONST);
6632 #line 1545 "pf.g"
6633 is.icmp_code_int = LT(0)->getText();
6634 #line 6635 "PFCfgParser.cpp"
6635 break;
6636 }
6637 default:
6638 {
6639 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6640 }
6641 }
6642 }
6643 break;
6644 }
6645 case NEWLINE:
6646 case QUEUE:
6647 case LITERAL_skip:
6648 case COMMA:
6649 case CLOSING_BRACE:
6650 case LITERAL_reassemble:
6651 case INT_CONST:
6652 case SCRUB:
6653 case EXLAMATION:
6654 case NO:
6655 case OPENING_PAREN:
6656 case USER:
6657 case ROUTE_TO:
6658 case REPLY_TO:
6659 case DUP_TO:
6660 case GROUP:
6661 case LITERAL_fragment:
6662 case 146:
6663 case 147:
6664 case 148:
6665 case 149:
6666 case FLAGS:
6667 case ICMP_TYPE:
6668 case LITERAL_echorep:
6669 case LITERAL_unreach:
6670 case LITERAL_squench:
6671 case LITERAL_redir:
6672 case LITERAL_althost:
6673 case LITERAL_echoreq:
6674 case LITERAL_routeradv:
6675 case LITERAL_routersol:
6676 case LITERAL_timex:
6677 case LITERAL_paramprob:
6678 case LITERAL_timereq:
6679 case LITERAL_timerep:
6680 case LITERAL_inforeq:
6681 case LITERAL_inforep:
6682 case LITERAL_maskreq:
6683 case LITERAL_maskrep:
6684 case LITERAL_trace:
6685 case LITERAL_dataconv:
6686 case LITERAL_mobredir:
6687 case 172:
6688 case 173:
6689 case LITERAL_mobregreq:
6690 case LITERAL_mobregrep:
6691 case LITERAL_photuris:
6692 case ICMP6_TYPE:
6693 case TAGGED:
6694 case TAG:
6695 case KEEP:
6696 case MODULATE:
6697 case SYNPROXY:
6698 case LABEL:
6699 {
6700 break;
6701 }
6702 default:
6703 {
6704 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6705 }
6706 }
6707 }
6708 #line 1548 "pf.g"
6709
6710 importer->icmp_type_code_group.push_back(is);
6711
6712 #line 6713 "PFCfgParser.cpp"
6713 }
6714 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6715 reportError(ex);
6716 recover(ex,_tokenSet_57);
6717 }
6718 }
6719
icmp_list()6720 void PFCfgParser::icmp_list() {
6721
6722 try { // for error handling
6723 match(OPENING_BRACE);
6724 icmp_type_code();
6725 { // ( ... )*
6726 for (;;) {
6727 if ((_tokenSet_58.member(LA(1)))) {
6728 {
6729 switch ( LA(1)) {
6730 case COMMA:
6731 {
6732 match(COMMA);
6733 break;
6734 }
6735 case LITERAL_skip:
6736 case INT_CONST:
6737 case LITERAL_echorep:
6738 case LITERAL_unreach:
6739 case LITERAL_squench:
6740 case LITERAL_redir:
6741 case LITERAL_althost:
6742 case LITERAL_echoreq:
6743 case LITERAL_routeradv:
6744 case LITERAL_routersol:
6745 case LITERAL_timex:
6746 case LITERAL_paramprob:
6747 case LITERAL_timereq:
6748 case LITERAL_timerep:
6749 case LITERAL_inforeq:
6750 case LITERAL_inforep:
6751 case LITERAL_maskreq:
6752 case LITERAL_maskrep:
6753 case LITERAL_trace:
6754 case LITERAL_dataconv:
6755 case LITERAL_mobredir:
6756 case 172:
6757 case 173:
6758 case LITERAL_mobregreq:
6759 case LITERAL_mobregrep:
6760 case LITERAL_photuris:
6761 {
6762 break;
6763 }
6764 default:
6765 {
6766 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6767 }
6768 }
6769 }
6770 icmp_type_code();
6771 }
6772 else {
6773 goto _loop250;
6774 }
6775
6776 }
6777 _loop250:;
6778 } // ( ... )*
6779 match(CLOSING_BRACE);
6780 }
6781 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6782 reportError(ex);
6783 recover(ex,_tokenSet_49);
6784 }
6785 }
6786
icmp_type_by_name()6787 void PFCfgParser::icmp_type_by_name() {
6788
6789 try { // for error handling
6790 {
6791 switch ( LA(1)) {
6792 case LITERAL_echorep:
6793 {
6794 match(LITERAL_echorep);
6795 break;
6796 }
6797 case LITERAL_unreach:
6798 {
6799 match(LITERAL_unreach);
6800 break;
6801 }
6802 case LITERAL_squench:
6803 {
6804 match(LITERAL_squench);
6805 break;
6806 }
6807 case LITERAL_redir:
6808 {
6809 match(LITERAL_redir);
6810 break;
6811 }
6812 case LITERAL_althost:
6813 {
6814 match(LITERAL_althost);
6815 break;
6816 }
6817 case LITERAL_echoreq:
6818 {
6819 match(LITERAL_echoreq);
6820 break;
6821 }
6822 case LITERAL_routeradv:
6823 {
6824 match(LITERAL_routeradv);
6825 break;
6826 }
6827 case LITERAL_routersol:
6828 {
6829 match(LITERAL_routersol);
6830 break;
6831 }
6832 case LITERAL_timex:
6833 {
6834 match(LITERAL_timex);
6835 break;
6836 }
6837 case LITERAL_paramprob:
6838 {
6839 match(LITERAL_paramprob);
6840 break;
6841 }
6842 case LITERAL_timereq:
6843 {
6844 match(LITERAL_timereq);
6845 break;
6846 }
6847 case LITERAL_timerep:
6848 {
6849 match(LITERAL_timerep);
6850 break;
6851 }
6852 case LITERAL_inforeq:
6853 {
6854 match(LITERAL_inforeq);
6855 break;
6856 }
6857 case LITERAL_inforep:
6858 {
6859 match(LITERAL_inforep);
6860 break;
6861 }
6862 case LITERAL_maskreq:
6863 {
6864 match(LITERAL_maskreq);
6865 break;
6866 }
6867 case LITERAL_maskrep:
6868 {
6869 match(LITERAL_maskrep);
6870 break;
6871 }
6872 case LITERAL_trace:
6873 {
6874 match(LITERAL_trace);
6875 break;
6876 }
6877 case LITERAL_dataconv:
6878 {
6879 match(LITERAL_dataconv);
6880 break;
6881 }
6882 case LITERAL_mobredir:
6883 {
6884 match(LITERAL_mobredir);
6885 break;
6886 }
6887 case 172:
6888 {
6889 match(172);
6890 break;
6891 }
6892 case 173:
6893 {
6894 match(173);
6895 break;
6896 }
6897 case LITERAL_mobregreq:
6898 {
6899 match(LITERAL_mobregreq);
6900 break;
6901 }
6902 case LITERAL_mobregrep:
6903 {
6904 match(LITERAL_mobregrep);
6905 break;
6906 }
6907 case LITERAL_skip:
6908 {
6909 match(LITERAL_skip);
6910 break;
6911 }
6912 case LITERAL_photuris:
6913 {
6914 match(LITERAL_photuris);
6915 break;
6916 }
6917 default:
6918 {
6919 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6920 }
6921 }
6922 }
6923 }
6924 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
6925 reportError(ex);
6926 recover(ex,_tokenSet_59);
6927 }
6928 }
6929
port_op()6930 void PFCfgParser::port_op() {
6931 #line 1799 "pf.g"
6932 PortSpec ps;
6933 #line 6934 "PFCfgParser.cpp"
6934
6935 try { // for error handling
6936 {
6937 switch ( LA(1)) {
6938 case EQUAL:
6939 case LESS_THAN:
6940 case GREATER_THAN:
6941 case EXLAMATION:
6942 {
6943 unary_op();
6944 #line 1801 "pf.g"
6945 ps.port_op = importer->tmp_port_op;
6946 #line 6947 "PFCfgParser.cpp"
6947 port_def();
6948 #line 1803 "pf.g"
6949
6950 ps.port1 = importer->tmp_port_def;
6951 ps.port2 = importer->tmp_port_def;
6952
6953 #line 6954 "PFCfgParser.cpp"
6954 break;
6955 }
6956 case WORD:
6957 case INT_CONST:
6958 {
6959 port_def();
6960 #line 1809 "pf.g"
6961
6962 ps.port1 = importer->tmp_port_def;
6963 ps.port2 = ps.port1;
6964 ps.port_op = "=";
6965
6966 #line 6967 "PFCfgParser.cpp"
6967 {
6968 if ((LA(1) == LESS_THAN || LA(1) == GREATER_THAN || LA(1) == COLON) && (_tokenSet_50.member(LA(2)))) {
6969 binary_op();
6970 #line 1815 "pf.g"
6971 ps.port_op = importer->tmp_port_op;
6972 #line 6973 "PFCfgParser.cpp"
6973 port_def();
6974 #line 1816 "pf.g"
6975 ps.port2 = LT(0)->getText();
6976 #line 6977 "PFCfgParser.cpp"
6977 }
6978 else if ((_tokenSet_60.member(LA(1))) && (_tokenSet_61.member(LA(2)))) {
6979 }
6980 else {
6981 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
6982 }
6983
6984 }
6985 break;
6986 }
6987 case IPV6:
6988 {
6989 match(IPV6);
6990 #line 1820 "pf.g"
6991
6992 ps.setFromPortRange(LT(0)->getText());
6993
6994 #line 6995 "PFCfgParser.cpp"
6995 break;
6996 }
6997 default:
6998 {
6999 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
7000 }
7001 }
7002 }
7003 #line 1824 "pf.g"
7004
7005 importer->tmp_port_group.push_back(ps);
7006
7007 #line 7008 "PFCfgParser.cpp"
7008 }
7009 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
7010 reportError(ex);
7011 recover(ex,_tokenSet_60);
7012 }
7013 }
7014
port_op_list()7015 void PFCfgParser::port_op_list() {
7016
7017 try { // for error handling
7018 match(OPENING_BRACE);
7019 port_op();
7020 { // ( ... )*
7021 for (;;) {
7022 if ((_tokenSet_62.member(LA(1)))) {
7023 {
7024 switch ( LA(1)) {
7025 case COMMA:
7026 {
7027 match(COMMA);
7028 break;
7029 }
7030 case WORD:
7031 case EQUAL:
7032 case INT_CONST:
7033 case LESS_THAN:
7034 case GREATER_THAN:
7035 case EXLAMATION:
7036 case IPV6:
7037 {
7038 break;
7039 }
7040 default:
7041 {
7042 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
7043 }
7044 }
7045 }
7046 port_op();
7047 }
7048 else {
7049 goto _loop278;
7050 }
7051
7052 }
7053 _loop278:;
7054 } // ( ... )*
7055 match(CLOSING_BRACE);
7056 }
7057 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
7058 reportError(ex);
7059 recover(ex,_tokenSet_42);
7060 }
7061 }
7062
initializeASTFactory(ANTLR_USE_NAMESPACE (antlr)ASTFactory &)7063 void PFCfgParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
7064 {
7065 }
7066 const char* PFCfgParser::tokenNames[] = {
7067 "<0>",
7068 "EOF",
7069 "<2>",
7070 "NULL_TREE_LOOKAHEAD",
7071 "NEWLINE",
7072 "COMMENT_START",
7073 "\"include\"",
7074 "WORD",
7075 "EQUAL",
7076 "\"antispoof\"",
7077 "\"altq\"",
7078 "\"queue\"",
7079 "\"set\"",
7080 "\"timeout\"",
7081 "\"ruleset-optimization\"",
7082 "\"optimization\"",
7083 "\"aggressive\"",
7084 "\"conservative\"",
7085 "\"high-latency\"",
7086 "\"normal\"",
7087 "\"satellite\"",
7088 "\"limit\"",
7089 "\"loginterface\"",
7090 "\"block-policy\"",
7091 "\"drop\"",
7092 "\"return\"",
7093 "\"state-policy\"",
7094 "\"if-bound\"",
7095 "\"floating\"",
7096 "\"state-defaults\"",
7097 "\"require-order\"",
7098 "\"fingerprints\"",
7099 "\"skip\"",
7100 "\"on\"",
7101 "OPENING_BRACE",
7102 "COMMA",
7103 "CLOSING_BRACE",
7104 "\"debug\"",
7105 "\"reassemble\"",
7106 "\"hostid\"",
7107 "\"tcp.first\"",
7108 "\"tcp.opening\"",
7109 "\"tcp.established\"",
7110 "\"tcp.closing\"",
7111 "\"tcp.finwait\"",
7112 "\"tcp.closed\"",
7113 "\"udp.first\"",
7114 "\"udp.single\"",
7115 "\"udp.multiple\"",
7116 "\"icmp.first\"",
7117 "\"icmp.error\"",
7118 "\"other.first\"",
7119 "\"other.single\"",
7120 "\"other.multiple\"",
7121 "\"frag\"",
7122 "\"interval\"",
7123 "\"src.track\"",
7124 "\"adaptive.start\"",
7125 "\"adaptive.end\"",
7126 "INT_CONST",
7127 "\"frags\"",
7128 "\"states\"",
7129 "\"src-nodes\"",
7130 "\"tables\"",
7131 "\"tables-entries\"",
7132 "\"scrub\"",
7133 "\"match\"",
7134 "\"table\"",
7135 "LESS_THAN",
7136 "GREATER_THAN",
7137 "\"persist\"",
7138 "\"const\"",
7139 "\"counters\"",
7140 "\"file\"",
7141 "STRING",
7142 "EXLAMATION",
7143 "COLON",
7144 "\"network\"",
7145 "\"broadcast\"",
7146 "\"peer\"",
7147 "\"self\"",
7148 "IPV4",
7149 "NUMBER",
7150 "SLASH",
7151 "\"no\"",
7152 "\"nat\"",
7153 "\"pass\"",
7154 "MINUS",
7155 "\"static-port\"",
7156 "\"rdr\"",
7157 "OPENING_PAREN",
7158 "CLOSING_PAREN",
7159 "\"port\"",
7160 "IPV6",
7161 "STAR",
7162 "\"bitmask\"",
7163 "\"random\"",
7164 "\"source-hash\"",
7165 "\"hex-key\"",
7166 "\"string-key\"",
7167 "\"round-robin\"",
7168 "\"sticky-address\"",
7169 "\"binat\"",
7170 "\"block\"",
7171 "\"return-rst\"",
7172 "TTL",
7173 "\"return-icmp\"",
7174 "RETURN_ICMP6",
7175 "\"in\"",
7176 "\"out\"",
7177 "\"log\"",
7178 "\"quick\"",
7179 "\"all\"",
7180 "\"user\"",
7181 "\"to\"",
7182 "\"inet\"",
7183 "\"inet6\"",
7184 "\"proto\"",
7185 "\"ip\"",
7186 "\"icmp\"",
7187 "\"igmp\"",
7188 "\"tcp\"",
7189 "\"udp\"",
7190 "\"rdp\"",
7191 "\"rsvp\"",
7192 "\"gre\"",
7193 "\"esp\"",
7194 "\"ah\"",
7195 "\"eigrp\"",
7196 "\"ospf\"",
7197 "\"ipip\"",
7198 "\"vrrp\"",
7199 "\"l2tp\"",
7200 "\"isis\"",
7201 "\"from\"",
7202 "\"urpf-failed\"",
7203 "\"any\"",
7204 "\"no-route\"",
7205 "MACRO",
7206 "\"route-to\"",
7207 "\"reply-to\"",
7208 "\"dup-to\"",
7209 "\"group\"",
7210 "\"fragment\"",
7211 "\"crop\"",
7212 "\"drop-ovl\"",
7213 "\"no-df\"",
7214 "\"min-ttl\"",
7215 "\"max-mss\"",
7216 "\"random-id\"",
7217 "\"flags\"",
7218 "\"icmp-type\"",
7219 "\"code\"",
7220 "\"echorep\"",
7221 "\"unreach\"",
7222 "\"squench\"",
7223 "\"redir\"",
7224 "\"althost\"",
7225 "\"echoreq\"",
7226 "\"routeradv\"",
7227 "\"routersol\"",
7228 "\"timex\"",
7229 "\"paramprob\"",
7230 "\"timereq\"",
7231 "\"timerep\"",
7232 "\"inforeq\"",
7233 "\"inforep\"",
7234 "\"maskreq\"",
7235 "\"maskrep\"",
7236 "\"trace\"",
7237 "\"dataconv\"",
7238 "\"mobredir\"",
7239 "\"ipv6-where\"",
7240 "\"ipv6-here\"",
7241 "\"mobregreq\"",
7242 "\"mobregrep\"",
7243 "\"photuris\"",
7244 "\"net-unr\"",
7245 "\"host-unr\"",
7246 "\"proto-unr\"",
7247 "\"port-unr\"",
7248 "\"needfrag\"",
7249 "\"srcfail\"",
7250 "\"net-unk\"",
7251 "\"host-unk\"",
7252 "\"isolate\"",
7253 "\"net-prohib\"",
7254 "\"host-prohib\"",
7255 "\"net-tos\"",
7256 "\"host-tos\"",
7257 "\"filter-prohib\"",
7258 "\"host-preced\"",
7259 "\"cutoff-preced\"",
7260 "\"redir-net\"",
7261 "\"redir-host\"",
7262 "\"redir-tos-net\"",
7263 "\"redir-tos-host\"",
7264 "\"normal-adv\"",
7265 "\"common-adv\"",
7266 "\"transit\"",
7267 "\"reassemb\"",
7268 "\"badhead\"",
7269 "\"optmiss\"",
7270 "\"badlen\"",
7271 "\"unknown-ind\"",
7272 "\"auth-fail\"",
7273 "\"decrypt-fail\"",
7274 "\"icmp6-type\"",
7275 "\"tagged\"",
7276 "\"tag\"",
7277 "\"keep\"",
7278 "\"modulate\"",
7279 "\"synproxy\"",
7280 "\"state\"",
7281 "\"label\"",
7282 "\"exit\"",
7283 "\"quit\"",
7284 "\"interface\"",
7285 "\"icmp6\"",
7286 "\"igrp\"",
7287 "\"ipsec\"",
7288 "\"nos\"",
7289 "\"pcp\"",
7290 "\"pim\"",
7291 "\"pptp\"",
7292 "\"rip\"",
7293 "\"snp\"",
7294 "\"host\"",
7295 "\"range\"",
7296 "\"alerts\"",
7297 "\"critical\"",
7298 "\"debugging\"",
7299 "\"emergencies\"",
7300 "\"errors\"",
7301 "\"informational\"",
7302 "\"notifications\"",
7303 "\"warnings\"",
7304 "\"disable\"",
7305 "\"inactive\"",
7306 "Whitespace",
7307 "HEX_CONST",
7308 "NEG_INT_CONST",
7309 "HEX_DIGIT",
7310 "DIGIT",
7311 "NUM_3DIGIT",
7312 "NUM_HEX_4DIGIT",
7313 "NUMBER_ADDRESS_OR_WORD",
7314 "PIPE_CHAR",
7315 "PERCENT",
7316 "AMPERSAND",
7317 "APOSTROPHE",
7318 "PLUS",
7319 "DOT",
7320 "SEMICOLON",
7321 "QUESTION",
7322 "COMMERCIAL_AT",
7323 "OPENING_SQUARE",
7324 "CLOSING_SQUARE",
7325 "CARET",
7326 "UNDERLINE",
7327 "TILDE",
7328 "DOUBLE_QUOTE",
7329 0
7330 };
7331
7332 const unsigned long PFCfgParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7333 // EOF
7334 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_0(_tokenSet_0_data_,10);
7335 const unsigned long PFCfgParser::_tokenSet_1_data_[] = { 7922UL, 0UL, 40894478UL, 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7336 // EOF NEWLINE COMMENT_START "include" WORD "antispoof" "altq" "queue"
7337 // "set" "scrub" "match" "table" "no" "nat" "pass" "rdr" "binat" "block"
7338 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_1(_tokenSet_1_data_,10);
7339 const unsigned long PFCfgParser::_tokenSet_2_data_[] = { 128UL, 134217736UL, 460800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7340 // WORD COMMA INT_CONST EXLAMATION "self" IPV4 NUMBER
7341 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_2(_tokenSet_2_data_,10);
7342 const unsigned long PFCfgParser::_tokenSet_3_data_[] = { 7922UL, 134217496UL, 40894478UL, 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7343 // EOF NEWLINE COMMENT_START "include" WORD "antispoof" "altq" "queue"
7344 // "set" COMMA CLOSING_BRACE "tcp.first" "tcp.opening" "tcp.established"
7345 // "tcp.closing" "tcp.finwait" "tcp.closed" "udp.first" "udp.single" "udp.multiple"
7346 // "icmp.first" "icmp.error" "other.first" "other.single" "other.multiple"
7347 // "frag" "interval" "src.track" "adaptive.start" "adaptive.end" "scrub"
7348 // "match" "table" "no" "nat" "pass" "rdr" "binat" "block"
7349 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_3(_tokenSet_3_data_,10);
7350 const unsigned long PFCfgParser::_tokenSet_4_data_[] = { 0UL, 134217480UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7351 // COMMA "tcp.first" "tcp.opening" "tcp.established" "tcp.closing" "tcp.finwait"
7352 // "tcp.closed" "udp.first" "udp.single" "udp.multiple" "icmp.first" "icmp.error"
7353 // "other.first" "other.single" "other.multiple" "frag" "interval" "src.track"
7354 // "adaptive.start" "adaptive.end"
7355 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_4(_tokenSet_4_data_,10);
7356 const unsigned long PFCfgParser::_tokenSet_5_data_[] = { 7922UL, 4026531864UL, 40894479UL, 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7357 // EOF NEWLINE COMMENT_START "include" WORD "antispoof" "altq" "queue"
7358 // "set" COMMA CLOSING_BRACE "frags" "states" "src-nodes" "tables" "tables-entries"
7359 // "scrub" "match" "table" "no" "nat" "pass" "rdr" "binat" "block"
7360 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_5(_tokenSet_5_data_,10);
7361 const unsigned long PFCfgParser::_tokenSet_6_data_[] = { 0UL, 4026531848UL, 1UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7362 // COMMA "frags" "states" "src-nodes" "tables" "tables-entries"
7363 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_6(_tokenSet_6_data_,10);
7364 const unsigned long PFCfgParser::_tokenSet_7_data_[] = { 2064UL, 64UL, 68159490UL, 4128768UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7365 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN "all"
7366 // "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to" "dup-to"
7367 // "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7368 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "label"
7369 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_7(_tokenSet_7_data_,16);
7370 const unsigned long PFCfgParser::_tokenSet_8_data_[] = { 8178UL, 134217805UL, 645598270UL, 4293329088UL, 4278190079UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7371 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7372 // "set" "skip" OPENING_BRACE COMMA "reassemble" INT_CONST "scrub" "match"
7373 // "table" LESS_THAN GREATER_THAN STRING EXLAMATION "self" IPV4 SLASH "no"
7374 // "nat" "pass" "rdr" OPENING_PAREN IPV6 "binat" "block" "all" "user" "to"
7375 // "proto" "ip" "icmp" "igmp" "tcp" "udp" "rdp" "rsvp" "gre" "esp" "ah"
7376 // "eigrp" "ospf" "ipip" "vrrp" "l2tp" "isis" "from" "urpf-failed" "any"
7377 // "no-route" MACRO "route-to" "reply-to" "dup-to" "group" "fragment" "crop"
7378 // "drop-ovl" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7379 // "echorep" "unreach" "squench" "redir" "althost" "echoreq" "routeradv"
7380 // "routersol" "timex" "paramprob" "timereq" "timerep" "inforeq" "inforep"
7381 // "maskreq" "maskrep" "trace" "dataconv" "mobredir" "ipv6-where" "ipv6-here"
7382 // "mobregreq" "mobregrep" "photuris" "icmp6-type" "tagged" "tag" "keep"
7383 // "modulate" "synproxy" "state" "label"
7384 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_8(_tokenSet_8_data_,16);
7385 const unsigned long PFCfgParser::_tokenSet_9_data_[] = { 2064UL, 64UL, 68159490UL, 458752UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7386 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN "all"
7387 // "user" "to" "from" "route-to" "reply-to" "dup-to" "group" "fragment"
7388 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type"
7389 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7390 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_9(_tokenSet_9_data_,16);
7391 const unsigned long PFCfgParser::_tokenSet_10_data_[] = { 8178UL, 134217805UL, 645598270UL, 33685696UL, 4278189952UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7392 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7393 // "set" "skip" OPENING_BRACE COMMA "reassemble" INT_CONST "scrub" "match"
7394 // "table" LESS_THAN GREATER_THAN STRING EXLAMATION "self" IPV4 SLASH "no"
7395 // "nat" "pass" "rdr" OPENING_PAREN IPV6 "binat" "block" "user" "tcp" "urpf-failed"
7396 // "any" "no-route" MACRO "route-to" "reply-to" "dup-to" "group" "fragment"
7397 // "crop" "drop-ovl" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7398 // "echorep" "unreach" "squench" "redir" "althost" "echoreq" "routeradv"
7399 // "routersol" "timex" "paramprob" "timereq" "timerep" "inforeq" "inforep"
7400 // "maskreq" "maskrep" "trace" "dataconv" "mobredir" "ipv6-where" "ipv6-here"
7401 // "mobregreq" "mobregrep" "photuris" "icmp6-type" "tagged" "tag" "keep"
7402 // "modulate" "synproxy" "state" "label"
7403 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_10(_tokenSet_10_data_,16);
7404 const unsigned long PFCfgParser::_tokenSet_11_data_[] = { 2064UL, 64UL, 68159490UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7405 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN "user"
7406 // "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7407 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7408 // "keep" "modulate" "synproxy" "label"
7409 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_11(_tokenSet_11_data_,16);
7410 const unsigned long PFCfgParser::_tokenSet_12_data_[] = { 8178UL, 134217805UL, 108530750UL, 33685696UL, 4278188288UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7411 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7412 // "set" "skip" OPENING_BRACE COMMA "reassemble" INT_CONST "scrub" "match"
7413 // "table" LESS_THAN GREATER_THAN STRING EXLAMATION SLASH "no" "nat" "pass"
7414 // "rdr" OPENING_PAREN "binat" "block" "user" "tcp" "any" "route-to" "reply-to"
7415 // "dup-to" "group" "fragment" "crop" "drop-ovl" "no-df" "min-ttl" "max-mss"
7416 // "random-id" "flags" "icmp-type" "echorep" "unreach" "squench" "redir"
7417 // "althost" "echoreq" "routeradv" "routersol" "timex" "paramprob" "timereq"
7418 // "timerep" "inforeq" "inforep" "maskreq" "maskrep" "trace" "dataconv"
7419 // "mobredir" "ipv6-where" "ipv6-here" "mobregreq" "mobregrep" "photuris"
7420 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "state" "label"
7421 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_12(_tokenSet_12_data_,16);
7422 const unsigned long PFCfgParser::_tokenSet_13_data_[] = { 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7423 // NEWLINE
7424 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_13(_tokenSet_13_data_,10);
7425 const unsigned long PFCfgParser::_tokenSet_14_data_[] = { 128UL, 134217752UL, 460800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7426 // WORD COMMA CLOSING_BRACE INT_CONST EXLAMATION "self" IPV4 NUMBER
7427 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_14(_tokenSet_14_data_,10);
7428 const unsigned long PFCfgParser::_tokenSet_15_data_[] = { 16UL, 2UL, 8390656UL, 3997696UL, 64UL, 0UL, 196608UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7429 // NEWLINE "on" EXLAMATION MINUS "all" "to" "inet" "inet6" "proto" "from"
7430 // "tagged" "tag"
7431 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_15(_tokenSet_15_data_,16);
7432 const unsigned long PFCfgParser::_tokenSet_16_data_[] = { 2064UL, 64UL, 76548098UL, 4128768UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7433 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7434 // "all" "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to"
7435 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7436 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7437 // "label"
7438 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_16(_tokenSet_16_data_,16);
7439 const unsigned long PFCfgParser::_tokenSet_17_data_[] = { 2064UL, 64UL, 76548098UL, 2555904UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7440 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7441 // "all" "user" "to" "proto" "from" "route-to" "reply-to" "dup-to" "group"
7442 // "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7443 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "label"
7444 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_17(_tokenSet_17_data_,16);
7445 const unsigned long PFCfgParser::_tokenSet_18_data_[] = { 2064UL, 64UL, 76548098UL, 458752UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7446 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7447 // "all" "user" "to" "from" "route-to" "reply-to" "dup-to" "group" "fragment"
7448 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type"
7449 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7450 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_18(_tokenSet_18_data_,16);
7451 const unsigned long PFCfgParser::_tokenSet_19_data_[] = { 2064UL, 64UL, 76548098UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7452 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7453 // "user" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7454 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7455 // "keep" "modulate" "synproxy" "label"
7456 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_19(_tokenSet_19_data_,16);
7457 const unsigned long PFCfgParser::_tokenSet_20_data_[] = { 2064UL, 72UL, 76548098UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7458 // NEWLINE "queue" COMMA "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7459 // "user" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7460 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7461 // "keep" "modulate" "synproxy" "label"
7462 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_20(_tokenSet_20_data_,16);
7463 const unsigned long PFCfgParser::_tokenSet_21_data_[] = { 144UL, 24UL, 2499936256UL, 19UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7464 // NEWLINE WORD COMMA CLOSING_BRACE IPV4 "static-port" OPENING_PAREN "port"
7465 // "bitmask" "random" "source-hash" "round-robin"
7466 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_21(_tokenSet_21_data_,10);
7467 const unsigned long PFCfgParser::_tokenSet_22_data_[] = { 128UL, 8UL, 67239936UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7468 // WORD COMMA IPV4 OPENING_PAREN
7469 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_22(_tokenSet_22_data_,10);
7470 const unsigned long PFCfgParser::_tokenSet_23_data_[] = { 16UL, 0UL, 2432696320UL, 19UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7471 // NEWLINE "static-port" "port" "bitmask" "random" "source-hash" "round-robin"
7472 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_23(_tokenSet_23_data_,10);
7473 const unsigned long PFCfgParser::_tokenSet_24_data_[] = { 16UL, 0UL, 2164260864UL, 19UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7474 // NEWLINE "static-port" "bitmask" "random" "source-hash" "round-robin"
7475 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_24(_tokenSet_24_data_,10);
7476 const unsigned long PFCfgParser::_tokenSet_25_data_[] = { 2064UL, 64UL, 84936706UL, 4128768UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7477 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" "static-port" OPENING_PAREN
7478 // "all" "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to"
7479 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7480 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7481 // "label"
7482 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_25(_tokenSet_25_data_,16);
7483 const unsigned long PFCfgParser::_tokenSet_26_data_[] = { 2448UL, 134217816UL, 2777684018UL, 393235UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7484 // NEWLINE WORD EQUAL "queue" COMMA CLOSING_BRACE "reassemble" INT_CONST
7485 // "scrub" LESS_THAN GREATER_THAN EXLAMATION COLON "no" MINUS "static-port"
7486 // OPENING_PAREN IPV6 "bitmask" "random" "source-hash" "round-robin" "user"
7487 // "to" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7488 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7489 // "keep" "modulate" "synproxy" "label"
7490 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_26(_tokenSet_26_data_,16);
7491 const unsigned long PFCfgParser::_tokenSet_27_data_[] = { 0UL, 134217728UL, 0UL, 0UL, 0UL, 4294836224UL, 32767UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7492 // INT_CONST "net-unr" "host-unr" "proto-unr" "port-unr" "needfrag" "srcfail"
7493 // "net-unk" "host-unk" "isolate" "net-prohib" "host-prohib" "net-tos"
7494 // "host-tos" "filter-prohib" "host-preced" "cutoff-preced" "redir-net"
7495 // "redir-host" "redir-tos-net" "redir-tos-host" "normal-adv" "common-adv"
7496 // "transit" "reassemb" "badhead" "optmiss" "badlen" "unknown-ind" "auth-fail"
7497 // "decrypt-fail"
7498 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_27(_tokenSet_27_data_,16);
7499 const unsigned long PFCfgParser::_tokenSet_28_data_[] = { 2064UL, 66UL, 68159490UL, 4190208UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7500 // NEWLINE "queue" "on" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7501 // "in" "out" "log" "quick" "all" "user" "to" "inet" "inet6" "proto" "from"
7502 // "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7503 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7504 // "keep" "modulate" "synproxy" "label"
7505 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_28(_tokenSet_28_data_,16);
7506 const unsigned long PFCfgParser::_tokenSet_29_data_[] = { 8178UL, 134217807UL, 645598270UL, 4294951104UL, 4278190079UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7507 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7508 // "set" "skip" "on" OPENING_BRACE COMMA "reassemble" INT_CONST "scrub"
7509 // "match" "table" LESS_THAN GREATER_THAN STRING EXLAMATION "self" IPV4
7510 // SLASH "no" "nat" "pass" "rdr" OPENING_PAREN IPV6 "binat" "block" "log"
7511 // "quick" "all" "user" "to" "inet" "inet6" "proto" "ip" "icmp" "igmp"
7512 // "tcp" "udp" "rdp" "rsvp" "gre" "esp" "ah" "eigrp" "ospf" "ipip" "vrrp"
7513 // "l2tp" "isis" "from" "urpf-failed" "any" "no-route" MACRO "route-to"
7514 // "reply-to" "dup-to" "group" "fragment" "crop" "drop-ovl" "no-df" "min-ttl"
7515 // "max-mss" "random-id" "flags" "icmp-type" "echorep" "unreach" "squench"
7516 // "redir" "althost" "echoreq" "routeradv" "routersol" "timex" "paramprob"
7517 // "timereq" "timerep" "inforeq" "inforep" "maskreq" "maskrep" "trace"
7518 // "dataconv" "mobredir" "ipv6-where" "ipv6-here" "mobregreq" "mobregrep"
7519 // "photuris" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7520 // "state" "label"
7521 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_29(_tokenSet_29_data_,16);
7522 const unsigned long PFCfgParser::_tokenSet_30_data_[] = { 2064UL, 134217817UL, 202377218UL, 131072UL, 4277991424UL, 131071UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7523 // NEWLINE "queue" "skip" COMMA CLOSING_BRACE "reassemble" INT_CONST "scrub"
7524 // EXLAMATION "no" OPENING_PAREN CLOSING_PAREN "user" "route-to" "reply-to"
7525 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7526 // "flags" "icmp-type" "echorep" "unreach" "squench" "redir" "althost"
7527 // "echoreq" "routeradv" "routersol" "timex" "paramprob" "timereq" "timerep"
7528 // "inforeq" "inforep" "maskreq" "maskrep" "trace" "dataconv" "mobredir"
7529 // "ipv6-where" "ipv6-here" "mobregreq" "mobregrep" "photuris" "icmp6-type"
7530 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7531 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_30(_tokenSet_30_data_,16);
7532 const unsigned long PFCfgParser::_tokenSet_31_data_[] = { 2064UL, 66UL, 68159490UL, 4177920UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7533 // NEWLINE "queue" "on" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7534 // "log" "quick" "all" "user" "to" "inet" "inet6" "proto" "from" "route-to"
7535 // "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7536 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7537 // "label"
7538 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_31(_tokenSet_31_data_,16);
7539 const unsigned long PFCfgParser::_tokenSet_32_data_[] = { 2064UL, 66UL, 68159490UL, 4161536UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7540 // NEWLINE "queue" "on" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7541 // "quick" "all" "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to"
7542 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7543 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7544 // "label"
7545 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_32(_tokenSet_32_data_,16);
7546 const unsigned long PFCfgParser::_tokenSet_33_data_[] = { 8178UL, 134217807UL, 645598270UL, 4294901952UL, 4278190079UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7547 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7548 // "set" "skip" "on" OPENING_BRACE COMMA "reassemble" INT_CONST "scrub"
7549 // "match" "table" LESS_THAN GREATER_THAN STRING EXLAMATION "self" IPV4
7550 // SLASH "no" "nat" "pass" "rdr" OPENING_PAREN IPV6 "binat" "block" "all"
7551 // "user" "to" "inet" "inet6" "proto" "ip" "icmp" "igmp" "tcp" "udp" "rdp"
7552 // "rsvp" "gre" "esp" "ah" "eigrp" "ospf" "ipip" "vrrp" "l2tp" "isis" "from"
7553 // "urpf-failed" "any" "no-route" MACRO "route-to" "reply-to" "dup-to"
7554 // "group" "fragment" "crop" "drop-ovl" "no-df" "min-ttl" "max-mss" "random-id"
7555 // "flags" "icmp-type" "echorep" "unreach" "squench" "redir" "althost"
7556 // "echoreq" "routeradv" "routersol" "timex" "paramprob" "timereq" "timerep"
7557 // "inforeq" "inforep" "maskreq" "maskrep" "trace" "dataconv" "mobredir"
7558 // "ipv6-where" "ipv6-here" "mobregreq" "mobregrep" "photuris" "icmp6-type"
7559 // "tagged" "tag" "keep" "modulate" "synproxy" "state" "label"
7560 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_33(_tokenSet_33_data_,16);
7561 const unsigned long PFCfgParser::_tokenSet_34_data_[] = { 2064UL, 66UL, 68159490UL, 4128768UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7562 // NEWLINE "queue" "on" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7563 // "all" "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to"
7564 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7565 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7566 // "label"
7567 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_34(_tokenSet_34_data_,16);
7568 const unsigned long PFCfgParser::_tokenSet_35_data_[] = { 2048UL, 72UL, 68159490UL, 131072UL, 16564224UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7569 // "queue" COMMA "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN "user"
7570 // "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7571 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "label"
7572 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_35(_tokenSet_35_data_,16);
7573 const unsigned long PFCfgParser::_tokenSet_36_data_[] = { 16UL, 0UL, 0UL, 0UL, 14336UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7574 // NEWLINE "route-to" "reply-to" "dup-to"
7575 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_36(_tokenSet_36_data_,12);
7576 const unsigned long PFCfgParser::_tokenSet_37_data_[] = { 2064UL, 66UL, 76548098UL, 4161536UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7577 // NEWLINE "queue" "on" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7578 // "quick" "all" "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to"
7579 // "dup-to" "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7580 // "flags" "icmp-type" "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy"
7581 // "label"
7582 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_37(_tokenSet_37_data_,16);
7583 const unsigned long PFCfgParser::_tokenSet_38_data_[] = { 0UL, 8UL, 134217728UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7584 // COMMA CLOSING_PAREN
7585 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_38(_tokenSet_38_data_,10);
7586 const unsigned long PFCfgParser::_tokenSet_39_data_[] = { 2192UL, 88UL, 76548098UL, 4128768UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7587 // NEWLINE WORD "queue" COMMA CLOSING_BRACE "reassemble" "scrub" EXLAMATION
7588 // "no" MINUS OPENING_PAREN "all" "user" "to" "inet" "inet6" "proto" "from"
7589 // "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7590 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7591 // "keep" "modulate" "synproxy" "label"
7592 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_39(_tokenSet_39_data_,16);
7593 const unsigned long PFCfgParser::_tokenSet_40_data_[] = { 2064UL, 134217820UL, 76548098UL, 4291231744UL, 16578687UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7594 // NEWLINE "queue" OPENING_BRACE COMMA CLOSING_BRACE "reassemble" INT_CONST
7595 // "scrub" EXLAMATION "no" MINUS OPENING_PAREN "all" "user" "to" "ip" "icmp"
7596 // "igmp" "tcp" "udp" "rdp" "rsvp" "gre" "esp" "ah" "eigrp" "ospf" "ipip"
7597 // "vrrp" "l2tp" "isis" "from" "route-to" "reply-to" "dup-to" "group" "fragment"
7598 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type"
7599 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7600 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_40(_tokenSet_40_data_,16);
7601 const unsigned long PFCfgParser::_tokenSet_41_data_[] = { 0UL, 134217740UL, 0UL, 4290772992UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7602 // OPENING_BRACE COMMA INT_CONST "ip" "icmp" "igmp" "tcp" "udp" "rdp" "rsvp"
7603 // "gre" "esp" "ah" "eigrp" "ospf" "ipip" "vrrp" "l2tp" "isis"
7604 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_41(_tokenSet_41_data_,12);
7605 const unsigned long PFCfgParser::_tokenSet_42_data_[] = { 2064UL, 64UL, 76548098UL, 393216UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7606 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7607 // "user" "to" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df"
7608 // "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged"
7609 // "tag" "keep" "modulate" "synproxy" "label"
7610 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_42(_tokenSet_42_data_,16);
7611 const unsigned long PFCfgParser::_tokenSet_43_data_[] = { 2064UL, 64UL, 344983554UL, 393216UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7612 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7613 // "port" "user" "to" "route-to" "reply-to" "dup-to" "group" "fragment"
7614 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type"
7615 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7616 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_43(_tokenSet_43_data_,16);
7617 const unsigned long PFCfgParser::_tokenSet_44_data_[] = { 2064UL, 64UL, 344983554UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7618 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" MINUS OPENING_PAREN
7619 // "port" "user" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df"
7620 // "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged"
7621 // "tag" "keep" "modulate" "synproxy" "label"
7622 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_44(_tokenSet_44_data_,16);
7623 const unsigned long PFCfgParser::_tokenSet_45_data_[] = { 2192UL, 88UL, 882051090UL, 393216UL, 16579584UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7624 // NEWLINE WORD "queue" COMMA CLOSING_BRACE "reassemble" "scrub" LESS_THAN
7625 // EXLAMATION "self" IPV4 "no" MINUS OPENING_PAREN "port" IPV6 "user" "to"
7626 // MACRO "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7627 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7628 // "keep" "modulate" "synproxy" "label"
7629 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_45(_tokenSet_45_data_,16);
7630 const unsigned long PFCfgParser::_tokenSet_46_data_[] = { 128UL, 8UL, 604178448UL, 0UL, 1024UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7631 // WORD COMMA LESS_THAN EXLAMATION "self" IPV4 OPENING_PAREN IPV6 MACRO
7632 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_46(_tokenSet_46_data_,12);
7633 const unsigned long PFCfgParser::_tokenSet_47_data_[] = { 2064UL, 88UL, 2215643138UL, 4128787UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7634 // NEWLINE "queue" COMMA CLOSING_BRACE "reassemble" "scrub" EXLAMATION
7635 // "no" OPENING_PAREN "bitmask" "random" "source-hash" "round-robin" "all"
7636 // "user" "to" "inet" "inet6" "proto" "from" "route-to" "reply-to" "dup-to"
7637 // "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7638 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "label"
7639 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_47(_tokenSet_47_data_,16);
7640 const unsigned long PFCfgParser::_tokenSet_48_data_[] = { 2064UL, 64UL, 2215643138UL, 4128787UL, 16578624UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7641 // NEWLINE "queue" "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN "bitmask"
7642 // "random" "source-hash" "round-robin" "all" "user" "to" "inet" "inet6"
7643 // "proto" "from" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df"
7644 // "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged"
7645 // "tag" "keep" "modulate" "synproxy" "label"
7646 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_48(_tokenSet_48_data_,16);
7647 const unsigned long PFCfgParser::_tokenSet_49_data_[] = { 2064UL, 72UL, 68159490UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7648 // NEWLINE "queue" COMMA "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7649 // "user" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7650 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7651 // "keep" "modulate" "synproxy" "label"
7652 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_49(_tokenSet_49_data_,16);
7653 const unsigned long PFCfgParser::_tokenSet_50_data_[] = { 128UL, 134217728UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7654 // WORD INT_CONST LESS_THAN GREATER_THAN
7655 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_50(_tokenSet_50_data_,10);
7656 const unsigned long PFCfgParser::_tokenSet_51_data_[] = { 2448UL, 134217816UL, 68159538UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7657 // NEWLINE WORD EQUAL "queue" COMMA CLOSING_BRACE "reassemble" INT_CONST
7658 // "scrub" LESS_THAN GREATER_THAN EXLAMATION "no" OPENING_PAREN "user"
7659 // "route-to" "reply-to" "dup-to" "group" "fragment" "no-df" "min-ttl"
7660 // "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged" "tag"
7661 // "keep" "modulate" "synproxy" "label"
7662 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_51(_tokenSet_51_data_,16);
7663 const unsigned long PFCfgParser::_tokenSet_52_data_[] = { 8178UL, 134217821UL, 108534846UL, 33685696UL, 4278188288UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7664 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7665 // "set" "skip" OPENING_BRACE COMMA CLOSING_BRACE "reassemble" INT_CONST
7666 // "scrub" "match" "table" LESS_THAN GREATER_THAN STRING EXLAMATION COLON
7667 // SLASH "no" "nat" "pass" "rdr" OPENING_PAREN "binat" "block" "user" "tcp"
7668 // "any" "route-to" "reply-to" "dup-to" "group" "fragment" "crop" "drop-ovl"
7669 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "echorep"
7670 // "unreach" "squench" "redir" "althost" "echoreq" "routeradv" "routersol"
7671 // "timex" "paramprob" "timereq" "timerep" "inforeq" "inforep" "maskreq"
7672 // "maskrep" "trace" "dataconv" "mobredir" "ipv6-where" "ipv6-here" "mobregreq"
7673 // "mobregrep" "photuris" "icmp6-type" "tagged" "tag" "keep" "modulate"
7674 // "synproxy" "state" "label"
7675 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_52(_tokenSet_52_data_,16);
7676 const unsigned long PFCfgParser::_tokenSet_53_data_[] = { 384UL, 134217736UL, 2096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7677 // WORD EQUAL COMMA INT_CONST LESS_THAN GREATER_THAN EXLAMATION
7678 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_53(_tokenSet_53_data_,10);
7679 const unsigned long PFCfgParser::_tokenSet_54_data_[] = { 128UL, 134217728UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7680 // WORD INT_CONST
7681 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_54(_tokenSet_54_data_,10);
7682 const unsigned long PFCfgParser::_tokenSet_55_data_[] = { 2064UL, 72UL, 202377218UL, 131072UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7683 // NEWLINE "queue" COMMA "reassemble" "scrub" EXLAMATION "no" OPENING_PAREN
7684 // CLOSING_PAREN "user" "route-to" "reply-to" "dup-to" "group" "fragment"
7685 // "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type"
7686 // "tagged" "tag" "keep" "modulate" "synproxy" "label"
7687 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_55(_tokenSet_55_data_,16);
7688 const unsigned long PFCfgParser::_tokenSet_56_data_[] = { 0UL, 72UL, 0UL, 0UL, 3964928UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7689 // COMMA "reassemble" "fragment" "no-df" "min-ttl" "max-mss" "random-id"
7690 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_56(_tokenSet_56_data_,12);
7691 const unsigned long PFCfgParser::_tokenSet_57_data_[] = { 2064UL, 134217817UL, 68159490UL, 131072UL, 4277991424UL, 131071UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7692 // NEWLINE "queue" "skip" COMMA CLOSING_BRACE "reassemble" INT_CONST "scrub"
7693 // EXLAMATION "no" OPENING_PAREN "user" "route-to" "reply-to" "dup-to"
7694 // "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7695 // "echorep" "unreach" "squench" "redir" "althost" "echoreq" "routeradv"
7696 // "routersol" "timex" "paramprob" "timereq" "timerep" "inforeq" "inforep"
7697 // "maskreq" "maskrep" "trace" "dataconv" "mobredir" "ipv6-where" "ipv6-here"
7698 // "mobregreq" "mobregrep" "photuris" "icmp6-type" "tagged" "tag" "keep"
7699 // "modulate" "synproxy" "label"
7700 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_57(_tokenSet_57_data_,16);
7701 const unsigned long PFCfgParser::_tokenSet_58_data_[] = { 0UL, 134217737UL, 0UL, 0UL, 4261412864UL, 131071UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7702 // "skip" COMMA INT_CONST "echorep" "unreach" "squench" "redir" "althost"
7703 // "echoreq" "routeradv" "routersol" "timex" "paramprob" "timereq" "timerep"
7704 // "inforeq" "inforep" "maskreq" "maskrep" "trace" "dataconv" "mobredir"
7705 // "ipv6-where" "ipv6-here" "mobregreq" "mobregrep" "photuris"
7706 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_58(_tokenSet_58_data_,12);
7707 const unsigned long PFCfgParser::_tokenSet_59_data_[] = { 2064UL, 134217817UL, 68159490UL, 131072UL, 4294768640UL, 131071UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7708 // NEWLINE "queue" "skip" COMMA CLOSING_BRACE "reassemble" INT_CONST "scrub"
7709 // EXLAMATION "no" OPENING_PAREN "user" "route-to" "reply-to" "dup-to"
7710 // "group" "fragment" "no-df" "min-ttl" "max-mss" "random-id" "flags" "icmp-type"
7711 // "code" "echorep" "unreach" "squench" "redir" "althost" "echoreq" "routeradv"
7712 // "routersol" "timex" "paramprob" "timereq" "timerep" "inforeq" "inforep"
7713 // "maskreq" "maskrep" "trace" "dataconv" "mobredir" "ipv6-where" "ipv6-here"
7714 // "mobregreq" "mobregrep" "photuris" "icmp6-type" "tagged" "tag" "keep"
7715 // "modulate" "synproxy" "label"
7716 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_59(_tokenSet_59_data_,16);
7717 const unsigned long PFCfgParser::_tokenSet_60_data_[] = { 2448UL, 134217816UL, 613419058UL, 393216UL, 16578560UL, 0UL, 6258688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7718 // NEWLINE WORD EQUAL "queue" COMMA CLOSING_BRACE "reassemble" INT_CONST
7719 // "scrub" LESS_THAN GREATER_THAN EXLAMATION "no" MINUS OPENING_PAREN IPV6
7720 // "user" "to" "route-to" "reply-to" "dup-to" "group" "fragment" "no-df"
7721 // "min-ttl" "max-mss" "random-id" "flags" "icmp-type" "icmp6-type" "tagged"
7722 // "tag" "keep" "modulate" "synproxy" "label"
7723 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_60(_tokenSet_60_data_,16);
7724 const unsigned long PFCfgParser::_tokenSet_61_data_[] = { 8178UL, 134217821UL, 653990974UL, 33947840UL, 4278189824UL, 131071UL, 8355840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7725 // EOF NEWLINE COMMENT_START "include" WORD EQUAL "antispoof" "altq" "queue"
7726 // "set" "skip" OPENING_BRACE COMMA CLOSING_BRACE "reassemble" INT_CONST
7727 // "scrub" "match" "table" LESS_THAN GREATER_THAN STRING EXLAMATION COLON
7728 // "self" IPV4 SLASH "no" "nat" "pass" MINUS "rdr" OPENING_PAREN IPV6 "binat"
7729 // "block" "user" "to" "tcp" "any" "no-route" MACRO "route-to" "reply-to"
7730 // "dup-to" "group" "fragment" "crop" "drop-ovl" "no-df" "min-ttl" "max-mss"
7731 // "random-id" "flags" "icmp-type" "echorep" "unreach" "squench" "redir"
7732 // "althost" "echoreq" "routeradv" "routersol" "timex" "paramprob" "timereq"
7733 // "timerep" "inforeq" "inforep" "maskreq" "maskrep" "trace" "dataconv"
7734 // "mobredir" "ipv6-where" "ipv6-here" "mobregreq" "mobregrep" "photuris"
7735 // "icmp6-type" "tagged" "tag" "keep" "modulate" "synproxy" "state" "label"
7736 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_61(_tokenSet_61_data_,16);
7737 const unsigned long PFCfgParser::_tokenSet_62_data_[] = { 384UL, 134217736UL, 536873008UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
7738 // WORD EQUAL COMMA INT_CONST LESS_THAN GREATER_THAN EXLAMATION IPV6
7739 const ANTLR_USE_NAMESPACE(antlr)BitSet PFCfgParser::_tokenSet_62(_tokenSet_62_data_,10);
7740
7741
7742