1 /* $ANTLR 2.7.7 (20090306): "iptables.g" -> "IPTCfgParser.cpp"$ */
2 #line 55 "iptables.g"
3
4 // gets inserted before the antlr generated includes in the cpp
5 // file
6
7 #line 8 "IPTCfgParser.cpp"
8 #include "IPTCfgParser.hpp"
9 #include <antlr/NoViableAltException.hpp>
10 #include <antlr/SemanticException.hpp>
11 #include <antlr/ASTFactory.hpp>
12 #line 61 "iptables.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 #include "fwbuilder/TCPService.h"
20 #include "fwbuilder/Logger.h"
21
22 #include <algorithm>
23
24 #line 25 "IPTCfgParser.cpp"
25 #line 1 "iptables.g"
26 #line 27 "IPTCfgParser.cpp"
IPTCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenBuffer & tokenBuf,int k)27 IPTCfgParser::IPTCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
28 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
29 {
30 }
31
IPTCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenBuffer & tokenBuf)32 IPTCfgParser::IPTCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
33 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
34 {
35 }
36
IPTCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenStream & lexer,int k)37 IPTCfgParser::IPTCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
38 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
39 {
40 }
41
IPTCfgParser(ANTLR_USE_NAMESPACE (antlr)TokenStream & lexer)42 IPTCfgParser::IPTCfgParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
43 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
44 {
45 }
46
IPTCfgParser(const ANTLR_USE_NAMESPACE (antlr)ParserSharedInputState & state)47 IPTCfgParser::IPTCfgParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
48 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
49 {
50 }
51
cfgfile()52 void IPTCfgParser::cfgfile() {
53
54 try { // for error handling
55 { // ( ... )+
56 int _cnt3=0;
57 for (;;) {
58 switch ( LA(1)) {
59 case NUMBER_SIGN:
60 {
61 comment();
62 break;
63 }
64 case STAR:
65 {
66 start_table();
67 break;
68 }
69 case COLON:
70 {
71 create_chain();
72 break;
73 }
74 case ADD_RULE:
75 {
76 add_rule();
77 break;
78 }
79 case COMMIT:
80 {
81 commit();
82 break;
83 }
84 case NEWLINE:
85 {
86 match(NEWLINE);
87 break;
88 }
89 default:
90 {
91 if ( _cnt3>=1 ) { goto _loop3; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
92 }
93 }
94 _cnt3++;
95 }
96 _loop3:;
97 } // ( ... )+
98 }
99 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
100 if( inputState->guessing == 0 ) {
101 reportError(ex);
102 recover(ex,_tokenSet_0);
103 } else {
104 throw;
105 }
106 }
107 }
108
comment()109 void IPTCfgParser::comment() {
110
111 try { // for error handling
112 match(NUMBER_SIGN);
113 { // ( ... )*
114 for (;;) {
115 if ((LA(1) == IPTABLES_SAVE_HEADER)) {
116 match(IPTABLES_SAVE_HEADER);
117 {
118 switch ( LA(1)) {
119 case THREE_COMPONENT_VERSION:
120 {
121 match(THREE_COMPONENT_VERSION);
122 break;
123 }
124 case IPV4:
125 {
126 match(IPV4);
127 break;
128 }
129 default:
130 {
131 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
132 }
133 }
134 }
135 if ( inputState->guessing==0 ) {
136 #line 151 "iptables.g"
137
138 importer->setCurrentLineNumber(LT(0)->getLine());
139 std::string version = LT(0)->getText();
140 importer->setDiscoveredVersion(version);
141 *dbg << "VERSION " << version << std::endl;
142 consumeUntil(NEWLINE);
143
144 #line 145 "IPTCfgParser.cpp"
145 }
146 }
147 else {
148 goto _loop7;
149 }
150
151 }
152 _loop7:;
153 } // ( ... )*
154 if ( inputState->guessing==0 ) {
155 #line 159 "iptables.g"
156
157 consumeUntil(NEWLINE);
158
159 #line 160 "IPTCfgParser.cpp"
160 }
161 }
162 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
163 if( inputState->guessing == 0 ) {
164 reportError(ex);
165 recover(ex,_tokenSet_1);
166 } else {
167 throw;
168 }
169 }
170 }
171
start_table()172 void IPTCfgParser::start_table() {
173
174 try { // for error handling
175 match(STAR);
176 match(WORD);
177 if ( inputState->guessing==0 ) {
178 #line 181 "iptables.g"
179
180 if (!importer->current_table.empty())
181 {
182 // we did not see COMMIT
183 *(importer->logger) << "********************************\n";
184 *(importer->logger) << "Missing COMMIT for the table " << importer->current_table << "\n";
185 *(importer->logger) << "Perhaps the file is broken ?" << "\n";
186 *(importer->logger) << "********************************\n";
187
188 *dbg << "Missing COMMIT for the table " << importer->current_table;
189 *dbg << "Perhaps the file is broken ?";
190
191 // push last rule
192 importer->pushRule();
193 // clear current table
194 importer->current_table = "";
195 }
196 importer->registerTable(LT(0)->getText());
197 *dbg << "TABLE " << LT(0)->getText() << std::endl;
198
199 #line 200 "IPTCfgParser.cpp"
200 }
201 }
202 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
203 if( inputState->guessing == 0 ) {
204 reportError(ex);
205 recover(ex,_tokenSet_1);
206 } else {
207 throw;
208 }
209 }
210 }
211
create_chain()212 void IPTCfgParser::create_chain() {
213
214 try { // for error handling
215 match(COLON);
216 chain_def();
217 if ( inputState->guessing==0 ) {
218 #line 216 "iptables.g"
219
220 importer->setCurrentLineNumber(LT(0)->getLine());
221 if (importer->current_table=="nat")
222 importer->newUnidirRuleSet(LT(0)->getText(),
223 libfwbuilder::NAT::TYPENAME);
224 else
225 importer->newUnidirRuleSet(LT(0)->getText(),
226 libfwbuilder::Policy::TYPENAME);
227 *dbg << "NEW CHAIN " << LT(0)->getText() << std::endl;
228
229 #line 230 "IPTCfgParser.cpp"
230 }
231 {
232 switch ( LA(1)) {
233 case WORD:
234 {
235 match(WORD);
236 break;
237 }
238 case MINUS:
239 {
240 match(MINUS);
241 break;
242 }
243 default:
244 {
245 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
246 }
247 }
248 }
249 if ( inputState->guessing==0 ) {
250 #line 227 "iptables.g"
251
252 importer->setDefaultAction(LT(0)->getText());
253 *dbg << "DEFAULT ACTION " << LT(0)->getText() << std::endl;
254
255 #line 256 "IPTCfgParser.cpp"
256 }
257 {
258 switch ( LA(1)) {
259 case OPENING_SQUARE:
260 {
261 match(OPENING_SQUARE);
262 match(INT_CONST);
263 match(COLON);
264 match(INT_CONST);
265 match(CLOSING_SQUARE);
266 break;
267 }
268 case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
269 case NEWLINE:
270 case NUMBER_SIGN:
271 case COMMIT:
272 case STAR:
273 case COLON:
274 case ADD_RULE:
275 {
276 break;
277 }
278 default:
279 {
280 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
281 }
282 }
283 }
284 }
285 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
286 if( inputState->guessing == 0 ) {
287 reportError(ex);
288 recover(ex,_tokenSet_1);
289 } else {
290 throw;
291 }
292 }
293 }
294
add_rule()295 void IPTCfgParser::add_rule() {
296
297 try { // for error handling
298 match(ADD_RULE);
299 chain_def();
300 if ( inputState->guessing==0 ) {
301 #line 237 "iptables.g"
302
303 // push previous rule
304 *dbg << std::endl;
305 importer->pushRule();
306 // start new one
307 importer->setCurrentLineNumber(LT(0)->getLine());
308 if (importer->current_table=="nat")
309 importer->newNATRule();
310 else
311 importer->newPolicyRule();
312 importer->current_chain = LT(0)->getText();
313 *dbg << "add_rule: line=" << LT(0)->getLine()
314 << " chain=" << LT(0)->getText();
315
316 #line 317 "IPTCfgParser.cpp"
317 }
318 { // ( ... )+
319 int _cnt17=0;
320 for (;;) {
321 if ((_tokenSet_2.member(LA(1)))) {
322 ipt_option();
323 }
324 else {
325 if ( _cnt17>=1 ) { goto _loop17; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
326 }
327
328 _cnt17++;
329 }
330 _loop17:;
331 } // ( ... )+
332 match(NEWLINE);
333 }
334 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
335 if( inputState->guessing == 0 ) {
336 reportError(ex);
337 recover(ex,_tokenSet_1);
338 } else {
339 throw;
340 }
341 }
342 }
343
commit()344 void IPTCfgParser::commit() {
345
346 try { // for error handling
347 match(COMMIT);
348 if ( inputState->guessing==0 ) {
349 #line 169 "iptables.g"
350
351 // push last rule
352 importer->pushRule();
353 *dbg << " COMMIT" << std::endl;
354 // clear current table
355 importer->current_table = "";
356
357 #line 358 "IPTCfgParser.cpp"
358 }
359 }
360 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
361 if( inputState->guessing == 0 ) {
362 reportError(ex);
363 recover(ex,_tokenSet_1);
364 } else {
365 throw;
366 }
367 }
368 }
369
chain_def()370 void IPTCfgParser::chain_def() {
371
372 try { // for error handling
373 {
374 switch ( LA(1)) {
375 case INPUT:
376 {
377 match(INPUT);
378 break;
379 }
380 case FORWARD:
381 {
382 match(FORWARD);
383 break;
384 }
385 case OUTPUT:
386 {
387 match(OUTPUT);
388 break;
389 }
390 case PREROUTING:
391 {
392 match(PREROUTING);
393 break;
394 }
395 case POSTROUTING:
396 {
397 match(POSTROUTING);
398 break;
399 }
400 case WORD:
401 {
402 match(WORD);
403 break;
404 }
405 default:
406 {
407 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
408 }
409 }
410 }
411 }
412 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
413 if( inputState->guessing == 0 ) {
414 reportError(ex);
415 recover(ex,_tokenSet_3);
416 } else {
417 throw;
418 }
419 }
420 }
421
ipt_option()422 void IPTCfgParser::ipt_option() {
423
424 try { // for error handling
425 {
426 switch ( LA(1)) {
427 case EXCLAMATION:
428 {
429 negation();
430 break;
431 }
432 case OPT_SRC:
433 {
434 src();
435 break;
436 }
437 case OPT_DST:
438 {
439 dst();
440 break;
441 }
442 case OPT_IN_INTF:
443 {
444 i_intf();
445 break;
446 }
447 case OPT_OUT_INTF:
448 {
449 o_intf();
450 break;
451 }
452 case OPT_PROTO:
453 {
454 proto();
455 break;
456 }
457 case OPT_TARGET:
458 {
459 target();
460 break;
461 }
462 case OPT_FRAGM:
463 {
464 fragm();
465 break;
466 }
467 case MATCH_ICMP_TYPE:
468 {
469 icmp_type_spec();
470 break;
471 }
472 case MATCH_SRC_PORT:
473 case MATCH_SRC_PORT_SHORT:
474 case MATCH_DST_PORT:
475 case MATCH_DST_PORT_SHORT:
476 {
477 basic_tcp_udp_port_spec();
478 break;
479 }
480 case MATCH_SRC_MULTIPORT:
481 case MATCH_DST_MULTIPORT:
482 case MATCH_BOTH_MULTIPORT:
483 {
484 multiport_tcp_udp_port_spec();
485 break;
486 }
487 case MATCH_SYN:
488 case MATCH_TCP_FLAGS:
489 case MATCH_TCP_OPTION:
490 {
491 tcp_options();
492 break;
493 }
494 case MATCH_LIMIT:
495 {
496 match_limit();
497 break;
498 }
499 case MATCH_LIMIT_BURST:
500 {
501 match_limit_burst();
502 break;
503 }
504 case MATCH_LENGTH:
505 {
506 match_length();
507 break;
508 }
509 case MATCH_IPRANGE_SRC:
510 {
511 match_iprange_src();
512 break;
513 }
514 case MATCH_IPRANGE_DST:
515 {
516 match_iprange_dst();
517 break;
518 }
519 case MINUS:
520 case UNSUPPORTED_OPTION:
521 {
522 unknown_option();
523 break;
524 }
525 default:
526 if ((LA(1) == OPT_MODULE) && (_tokenSet_4.member(LA(2)))) {
527 module();
528 }
529 else if ((LA(1) == OPT_MODULE) && (LA(2) == M_MARK)) {
530 match_mark();
531 }
532 else if ((LA(1) == OPT_MODULE) && (LA(2) == M_RECENT)) {
533 match_recent();
534 }
535 else {
536 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
537 }
538 }
539 }
540 }
541 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
542 if( inputState->guessing == 0 ) {
543 reportError(ex);
544 recover(ex,_tokenSet_5);
545 } else {
546 throw;
547 }
548 }
549 }
550
negation()551 void IPTCfgParser::negation() {
552
553 try { // for error handling
554 match(EXCLAMATION);
555 if ( inputState->guessing==0 ) {
556 #line 303 "iptables.g"
557
558 importer->tmp_neg = true;
559
560 #line 561 "IPTCfgParser.cpp"
561 }
562 }
563 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
564 if( inputState->guessing == 0 ) {
565 reportError(ex);
566 recover(ex,_tokenSet_5);
567 } else {
568 throw;
569 }
570 }
571 }
572
module()573 void IPTCfgParser::module() {
574
575 try { // for error handling
576 match(OPT_MODULE);
577 {
578 switch ( LA(1)) {
579 case M_STATE:
580 {
581 m_state();
582 break;
583 }
584 case M_MPORT:
585 {
586 m_mport();
587 break;
588 }
589 case ICMP:
590 {
591 m_icmp();
592 break;
593 }
594 case TCP:
595 {
596 m_tcp();
597 break;
598 }
599 case UDP:
600 {
601 m_udp();
602 break;
603 }
604 case M_LIMIT:
605 {
606 m_limit();
607 break;
608 }
609 case M_LENGTH:
610 {
611 m_length();
612 break;
613 }
614 case M_IPRANGE:
615 {
616 m_iprange();
617 break;
618 }
619 case M_COMMENT:
620 {
621 m_comment();
622 break;
623 }
624 case M_PKTTYPE:
625 {
626 m_pkttype();
627 break;
628 }
629 case WORD:
630 {
631 m_unknown_module();
632 break;
633 }
634 default:
635 {
636 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
637 }
638 }
639 }
640 }
641 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
642 if( inputState->guessing == 0 ) {
643 reportError(ex);
644 recover(ex,_tokenSet_5);
645 } else {
646 throw;
647 }
648 }
649 }
650
match_mark()651 void IPTCfgParser::match_mark() {
652
653 try { // for error handling
654 match(OPT_MODULE);
655 m_mark();
656 {
657 switch ( LA(1)) {
658 case EXCLAMATION:
659 {
660 match(EXCLAMATION);
661 if ( inputState->guessing==0 ) {
662 #line 731 "iptables.g"
663 importer->neg_match_mark = true;
664 #line 665 "IPTCfgParser.cpp"
665 }
666 break;
667 }
668 case MATCH_MARK:
669 {
670 break;
671 }
672 default:
673 {
674 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
675 }
676 }
677 }
678 match(MATCH_MARK);
679 {
680 switch ( LA(1)) {
681 case INT_CONST:
682 {
683 match(INT_CONST);
684 break;
685 }
686 case HEX_CONST:
687 {
688 match(HEX_CONST);
689 break;
690 }
691 default:
692 {
693 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
694 }
695 }
696 }
697 if ( inputState->guessing==0 ) {
698 #line 733 "iptables.g"
699
700 importer->tmp_neg = false;
701 importer->match_mark = LT(0)->getText();
702 *dbg << " MATCH MARK " << LT(0)->getText();
703
704 #line 705 "IPTCfgParser.cpp"
705 }
706 }
707 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
708 if( inputState->guessing == 0 ) {
709 reportError(ex);
710 recover(ex,_tokenSet_5);
711 } else {
712 throw;
713 }
714 }
715 }
716
match_recent()717 void IPTCfgParser::match_recent() {
718
719 try { // for error handling
720 match(OPT_MODULE);
721 m_recent();
722 { // ( ... )+
723 int _cnt95=0;
724 for (;;) {
725 if (((LA(1) >= MATCH_RECENT_SET && LA(1) <= MATCH_RECENT_HITCOUNT))) {
726 recent_opts();
727 }
728 else {
729 if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
730 }
731
732 _cnt95++;
733 }
734 _loop95:;
735 } // ( ... )+
736 }
737 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
738 if( inputState->guessing == 0 ) {
739 reportError(ex);
740 recover(ex,_tokenSet_5);
741 } else {
742 throw;
743 }
744 }
745 }
746
src()747 void IPTCfgParser::src() {
748
749 try { // for error handling
750 match(OPT_SRC);
751 if ( inputState->guessing==0 ) {
752 #line 381 "iptables.g"
753
754 *dbg << " SRC=";
755 importer->src_neg = importer->tmp_neg;
756 importer->tmp_neg = false;
757
758 #line 759 "IPTCfgParser.cpp"
759 }
760 {
761 {
762 switch ( LA(1)) {
763 case WORD:
764 {
765 match(WORD);
766 break;
767 }
768 case IPV4:
769 {
770 match(IPV4);
771 break;
772 }
773 default:
774 {
775 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
776 }
777 }
778 }
779 if ( inputState->guessing==0 ) {
780 #line 387 "iptables.g"
781
782 importer->src_a = LT(0)->getText();
783 *dbg << LT(0)->getText();
784
785 #line 786 "IPTCfgParser.cpp"
786 }
787 {
788 switch ( LA(1)) {
789 case SLASH:
790 {
791 match(SLASH);
792 {
793 switch ( LA(1)) {
794 case IPV4:
795 {
796 match(IPV4);
797 break;
798 }
799 case INT_CONST:
800 {
801 match(INT_CONST);
802 break;
803 }
804 default:
805 {
806 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
807 }
808 }
809 }
810 if ( inputState->guessing==0 ) {
811 #line 392 "iptables.g"
812
813 importer->src_nm = LT(0)->getText();
814 *dbg << "/" << LT(0)->getText();
815
816 #line 817 "IPTCfgParser.cpp"
817 }
818 break;
819 }
820 case NEWLINE:
821 case MINUS:
822 case EXCLAMATION:
823 case UNSUPPORTED_OPTION:
824 case OPT_MODULE:
825 case OPT_SRC:
826 case OPT_DST:
827 case OPT_IN_INTF:
828 case OPT_OUT_INTF:
829 case OPT_PROTO:
830 case OPT_TARGET:
831 case OPT_FRAGM:
832 case MATCH_LIMIT:
833 case MATCH_LIMIT_BURST:
834 case MATCH_IPRANGE_SRC:
835 case MATCH_IPRANGE_DST:
836 case MATCH_LENGTH:
837 case MATCH_SRC_MULTIPORT:
838 case MATCH_DST_MULTIPORT:
839 case MATCH_BOTH_MULTIPORT:
840 case MATCH_ICMP_TYPE:
841 case MATCH_SRC_PORT:
842 case MATCH_SRC_PORT_SHORT:
843 case MATCH_DST_PORT:
844 case MATCH_DST_PORT_SHORT:
845 case MATCH_SYN:
846 case MATCH_TCP_FLAGS:
847 case MATCH_TCP_OPTION:
848 {
849 break;
850 }
851 default:
852 {
853 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
854 }
855 }
856 }
857 }
858 }
859 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
860 if( inputState->guessing == 0 ) {
861 reportError(ex);
862 recover(ex,_tokenSet_5);
863 } else {
864 throw;
865 }
866 }
867 }
868
dst()869 void IPTCfgParser::dst() {
870
871 try { // for error handling
872 match(OPT_DST);
873 if ( inputState->guessing==0 ) {
874 #line 401 "iptables.g"
875
876 *dbg << " DST=";
877 importer->dst_neg = importer->tmp_neg;
878 importer->tmp_neg = false;
879
880 #line 881 "IPTCfgParser.cpp"
881 }
882 {
883 {
884 switch ( LA(1)) {
885 case WORD:
886 {
887 match(WORD);
888 break;
889 }
890 case IPV4:
891 {
892 match(IPV4);
893 break;
894 }
895 default:
896 {
897 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
898 }
899 }
900 }
901 if ( inputState->guessing==0 ) {
902 #line 407 "iptables.g"
903
904 importer->dst_a = LT(0)->getText();
905 *dbg << LT(0)->getText();
906
907 #line 908 "IPTCfgParser.cpp"
908 }
909 {
910 switch ( LA(1)) {
911 case SLASH:
912 {
913 match(SLASH);
914 {
915 switch ( LA(1)) {
916 case IPV4:
917 {
918 match(IPV4);
919 break;
920 }
921 case INT_CONST:
922 {
923 match(INT_CONST);
924 break;
925 }
926 default:
927 {
928 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
929 }
930 }
931 }
932 if ( inputState->guessing==0 ) {
933 #line 412 "iptables.g"
934
935 importer->dst_nm = LT(0)->getText();
936 *dbg << "/" << LT(0)->getText();
937
938 #line 939 "IPTCfgParser.cpp"
939 }
940 break;
941 }
942 case NEWLINE:
943 case MINUS:
944 case EXCLAMATION:
945 case UNSUPPORTED_OPTION:
946 case OPT_MODULE:
947 case OPT_SRC:
948 case OPT_DST:
949 case OPT_IN_INTF:
950 case OPT_OUT_INTF:
951 case OPT_PROTO:
952 case OPT_TARGET:
953 case OPT_FRAGM:
954 case MATCH_LIMIT:
955 case MATCH_LIMIT_BURST:
956 case MATCH_IPRANGE_SRC:
957 case MATCH_IPRANGE_DST:
958 case MATCH_LENGTH:
959 case MATCH_SRC_MULTIPORT:
960 case MATCH_DST_MULTIPORT:
961 case MATCH_BOTH_MULTIPORT:
962 case MATCH_ICMP_TYPE:
963 case MATCH_SRC_PORT:
964 case MATCH_SRC_PORT_SHORT:
965 case MATCH_DST_PORT:
966 case MATCH_DST_PORT_SHORT:
967 case MATCH_SYN:
968 case MATCH_TCP_FLAGS:
969 case MATCH_TCP_OPTION:
970 {
971 break;
972 }
973 default:
974 {
975 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
976 }
977 }
978 }
979 }
980 }
981 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
982 if( inputState->guessing == 0 ) {
983 reportError(ex);
984 recover(ex,_tokenSet_5);
985 } else {
986 throw;
987 }
988 }
989 }
990
i_intf()991 void IPTCfgParser::i_intf() {
992
993 try { // for error handling
994 match(OPT_IN_INTF);
995 if ( inputState->guessing==0 ) {
996 #line 421 "iptables.g"
997
998 importer->intf_neg = importer->tmp_neg;
999 importer->tmp_neg = false;
1000
1001 #line 1002 "IPTCfgParser.cpp"
1002 }
1003 match(WORD);
1004 if ( inputState->guessing==0 ) {
1005 #line 426 "iptables.g"
1006
1007 importer->i_intf = LT(0)->getText();
1008 *dbg << " I_INTF=" << LT(0)->getText();
1009
1010 #line 1011 "IPTCfgParser.cpp"
1011 }
1012 }
1013 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1014 if( inputState->guessing == 0 ) {
1015 reportError(ex);
1016 recover(ex,_tokenSet_5);
1017 } else {
1018 throw;
1019 }
1020 }
1021 }
1022
o_intf()1023 void IPTCfgParser::o_intf() {
1024
1025 try { // for error handling
1026 match(OPT_OUT_INTF);
1027 if ( inputState->guessing==0 ) {
1028 #line 434 "iptables.g"
1029
1030 importer->intf_neg = importer->tmp_neg;
1031 importer->tmp_neg = false;
1032
1033 #line 1034 "IPTCfgParser.cpp"
1034 }
1035 match(WORD);
1036 if ( inputState->guessing==0 ) {
1037 #line 439 "iptables.g"
1038
1039 importer->o_intf = LT(0)->getText();
1040 *dbg << " O_INTF=" << LT(0)->getText();
1041
1042 #line 1043 "IPTCfgParser.cpp"
1043 }
1044 }
1045 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1046 if( inputState->guessing == 0 ) {
1047 reportError(ex);
1048 recover(ex,_tokenSet_5);
1049 } else {
1050 throw;
1051 }
1052 }
1053 }
1054
proto()1055 void IPTCfgParser::proto() {
1056
1057 try { // for error handling
1058 match(OPT_PROTO);
1059 if ( inputState->guessing==0 ) {
1060 #line 450 "iptables.g"
1061
1062 importer->srv_neg = importer->tmp_neg;
1063 importer->tmp_neg = false;
1064
1065 #line 1066 "IPTCfgParser.cpp"
1066 }
1067 protocol_word();
1068 if ( inputState->guessing==0 ) {
1069 #line 455 "iptables.g"
1070
1071 std::string tmp_s = LT(0)->getText();
1072 importer->protocol.resize(tmp_s.size());
1073 std::transform(tmp_s.begin(),
1074 tmp_s.end(),
1075 importer->protocol.begin(),
1076 ::tolower);
1077 *dbg << " PROTO=" << importer->protocol;
1078
1079 #line 1080 "IPTCfgParser.cpp"
1080 }
1081 }
1082 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1083 if( inputState->guessing == 0 ) {
1084 reportError(ex);
1085 recover(ex,_tokenSet_5);
1086 } else {
1087 throw;
1088 }
1089 }
1090 }
1091
target()1092 void IPTCfgParser::target() {
1093 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1094
1095 try { // for error handling
1096 match(OPT_TARGET);
1097 t = LT(1);
1098 match(WORD);
1099 if ( inputState->guessing==0 ) {
1100 #line 468 "iptables.g"
1101
1102 importer->target = LT(0)->getText();
1103 *dbg << " TARGET=" << t->getText();
1104
1105 #line 1106 "IPTCfgParser.cpp"
1106 }
1107 { // ( ... )*
1108 for (;;) {
1109 if ((_tokenSet_6.member(LA(1)))) {
1110 target_options();
1111 }
1112 else {
1113 goto _loop54;
1114 }
1115
1116 }
1117 _loop54:;
1118 } // ( ... )*
1119 }
1120 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1121 if( inputState->guessing == 0 ) {
1122 reportError(ex);
1123 recover(ex,_tokenSet_5);
1124 } else {
1125 throw;
1126 }
1127 }
1128 }
1129
fragm()1130 void IPTCfgParser::fragm() {
1131
1132 try { // for error handling
1133 match(OPT_FRAGM);
1134 if ( inputState->guessing==0 ) {
1135 #line 680 "iptables.g"
1136
1137 importer->fragments = true;
1138 *dbg << " FRAGM";
1139
1140 #line 1141 "IPTCfgParser.cpp"
1141 }
1142 }
1143 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1144 if( inputState->guessing == 0 ) {
1145 reportError(ex);
1146 recover(ex,_tokenSet_5);
1147 } else {
1148 throw;
1149 }
1150 }
1151 }
1152
icmp_type_spec()1153 void IPTCfgParser::icmp_type_spec() {
1154
1155 try { // for error handling
1156 match(MATCH_ICMP_TYPE);
1157 {
1158 switch ( LA(1)) {
1159 case WORD:
1160 {
1161 match(WORD);
1162 if ( inputState->guessing==0 ) {
1163 #line 970 "iptables.g"
1164
1165 importer->icmp_spec = LT(0)->getText();
1166 *dbg << " ICMP_SPEC=" << LT(0)->getText();
1167
1168 #line 1169 "IPTCfgParser.cpp"
1169 }
1170 break;
1171 }
1172 case INT_CONST:
1173 {
1174 {
1175 match(INT_CONST);
1176 if ( inputState->guessing==0 ) {
1177 #line 977 "iptables.g"
1178
1179 importer->icmp_type = LT(0)->getText();
1180 importer->icmp_code = "-1";
1181 *dbg << " ICMP_TYPE=" << LT(0)->getText();
1182
1183 #line 1184 "IPTCfgParser.cpp"
1184 }
1185 {
1186 switch ( LA(1)) {
1187 case SLASH:
1188 {
1189 match(SLASH);
1190 match(INT_CONST);
1191 if ( inputState->guessing==0 ) {
1192 #line 984 "iptables.g"
1193
1194 importer->icmp_code = LT(0)->getText();
1195 *dbg << " ICMP_CODE=" << LT(0)->getText();
1196
1197 #line 1198 "IPTCfgParser.cpp"
1198 }
1199 break;
1200 }
1201 case NEWLINE:
1202 case MINUS:
1203 case EXCLAMATION:
1204 case UNSUPPORTED_OPTION:
1205 case OPT_MODULE:
1206 case OPT_SRC:
1207 case OPT_DST:
1208 case OPT_IN_INTF:
1209 case OPT_OUT_INTF:
1210 case OPT_PROTO:
1211 case OPT_TARGET:
1212 case OPT_FRAGM:
1213 case MATCH_LIMIT:
1214 case MATCH_LIMIT_BURST:
1215 case MATCH_IPRANGE_SRC:
1216 case MATCH_IPRANGE_DST:
1217 case MATCH_LENGTH:
1218 case MATCH_SRC_MULTIPORT:
1219 case MATCH_DST_MULTIPORT:
1220 case MATCH_BOTH_MULTIPORT:
1221 case MATCH_ICMP_TYPE:
1222 case MATCH_SRC_PORT:
1223 case MATCH_SRC_PORT_SHORT:
1224 case MATCH_DST_PORT:
1225 case MATCH_DST_PORT_SHORT:
1226 case MATCH_SYN:
1227 case MATCH_TCP_FLAGS:
1228 case MATCH_TCP_OPTION:
1229 {
1230 break;
1231 }
1232 default:
1233 {
1234 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1235 }
1236 }
1237 }
1238 }
1239 break;
1240 }
1241 default:
1242 {
1243 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1244 }
1245 }
1246 }
1247 }
1248 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1249 if( inputState->guessing == 0 ) {
1250 reportError(ex);
1251 recover(ex,_tokenSet_5);
1252 } else {
1253 throw;
1254 }
1255 }
1256 }
1257
basic_tcp_udp_port_spec()1258 void IPTCfgParser::basic_tcp_udp_port_spec() {
1259
1260 try { // for error handling
1261 switch ( LA(1)) {
1262 case MATCH_SRC_PORT:
1263 case MATCH_SRC_PORT_SHORT:
1264 {
1265 {
1266 switch ( LA(1)) {
1267 case MATCH_SRC_PORT:
1268 {
1269 match(MATCH_SRC_PORT);
1270 break;
1271 }
1272 case MATCH_SRC_PORT_SHORT:
1273 {
1274 match(MATCH_SRC_PORT_SHORT);
1275 break;
1276 }
1277 default:
1278 {
1279 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1280 }
1281 }
1282 }
1283 if ( inputState->guessing==0 ) {
1284 #line 1066 "iptables.g"
1285
1286 importer->srv_neg = importer->tmp_neg;
1287 importer->tmp_neg = false;
1288
1289 #line 1290 "IPTCfgParser.cpp"
1290 }
1291 {
1292 switch ( LA(1)) {
1293 case WORD:
1294 case INT_CONST:
1295 {
1296 port_def_with_range();
1297 break;
1298 }
1299 case COLON:
1300 {
1301 port_def_with_incomplete_range();
1302 break;
1303 }
1304 default:
1305 {
1306 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1307 }
1308 }
1309 }
1310 if ( inputState->guessing==0 ) {
1311 #line 1071 "iptables.g"
1312
1313 importer->pushTmpPortSpecToSrcPortList();
1314
1315 #line 1316 "IPTCfgParser.cpp"
1316 }
1317 break;
1318 }
1319 case MATCH_DST_PORT:
1320 case MATCH_DST_PORT_SHORT:
1321 {
1322 {
1323 switch ( LA(1)) {
1324 case MATCH_DST_PORT:
1325 {
1326 match(MATCH_DST_PORT);
1327 break;
1328 }
1329 case MATCH_DST_PORT_SHORT:
1330 {
1331 match(MATCH_DST_PORT_SHORT);
1332 break;
1333 }
1334 default:
1335 {
1336 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1337 }
1338 }
1339 }
1340 if ( inputState->guessing==0 ) {
1341 #line 1076 "iptables.g"
1342
1343 importer->srv_neg = importer->tmp_neg;
1344 importer->tmp_neg = false;
1345
1346 #line 1347 "IPTCfgParser.cpp"
1347 }
1348 {
1349 switch ( LA(1)) {
1350 case WORD:
1351 case INT_CONST:
1352 {
1353 port_def_with_range();
1354 break;
1355 }
1356 case COLON:
1357 {
1358 port_def_with_incomplete_range();
1359 break;
1360 }
1361 default:
1362 {
1363 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1364 }
1365 }
1366 }
1367 if ( inputState->guessing==0 ) {
1368 #line 1081 "iptables.g"
1369
1370 importer->pushTmpPortSpecToDstPortList();
1371
1372 #line 1373 "IPTCfgParser.cpp"
1373 }
1374 break;
1375 }
1376 default:
1377 {
1378 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1379 }
1380 }
1381 }
1382 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1383 if( inputState->guessing == 0 ) {
1384 reportError(ex);
1385 recover(ex,_tokenSet_5);
1386 } else {
1387 throw;
1388 }
1389 }
1390 }
1391
multiport_tcp_udp_port_spec()1392 void IPTCfgParser::multiport_tcp_udp_port_spec() {
1393
1394 try { // for error handling
1395 {
1396 switch ( LA(1)) {
1397 case MATCH_SRC_MULTIPORT:
1398 {
1399 {
1400 match(MATCH_SRC_MULTIPORT);
1401 if ( inputState->guessing==0 ) {
1402 #line 901 "iptables.g"
1403
1404 importer->srv_neg = importer->tmp_neg;
1405 importer->tmp_neg = false;
1406 importer->startSrcMultiPort();
1407 *dbg << " SRC MULTIPORT=";
1408
1409 #line 1410 "IPTCfgParser.cpp"
1410 }
1411 port_def_with_range();
1412 if ( inputState->guessing==0 ) {
1413 #line 908 "iptables.g"
1414
1415 importer->pushTmpPortSpecToSrcPortList();
1416
1417 #line 1418 "IPTCfgParser.cpp"
1418 }
1419 { // ( ... )*
1420 for (;;) {
1421 if ((LA(1) == COMMA)) {
1422 match(COMMA);
1423 port_def_with_range();
1424 if ( inputState->guessing==0 ) {
1425 #line 912 "iptables.g"
1426
1427 importer->pushTmpPortSpecToSrcPortList();
1428
1429 #line 1430 "IPTCfgParser.cpp"
1430 }
1431 }
1432 else {
1433 goto _loop114;
1434 }
1435
1436 }
1437 _loop114:;
1438 } // ( ... )*
1439 }
1440 break;
1441 }
1442 case MATCH_DST_MULTIPORT:
1443 {
1444 {
1445 match(MATCH_DST_MULTIPORT);
1446 if ( inputState->guessing==0 ) {
1447 #line 919 "iptables.g"
1448
1449 importer->srv_neg = importer->tmp_neg;
1450 importer->tmp_neg = false;
1451 importer->startDstMultiPort();
1452 *dbg << " DST MULTIPORT=";
1453
1454 #line 1455 "IPTCfgParser.cpp"
1455 }
1456 port_def_with_range();
1457 if ( inputState->guessing==0 ) {
1458 #line 926 "iptables.g"
1459
1460 importer->pushTmpPortSpecToDstPortList();
1461
1462 #line 1463 "IPTCfgParser.cpp"
1463 }
1464 { // ( ... )*
1465 for (;;) {
1466 if ((LA(1) == COMMA)) {
1467 match(COMMA);
1468 port_def_with_range();
1469 if ( inputState->guessing==0 ) {
1470 #line 930 "iptables.g"
1471
1472 importer->pushTmpPortSpecToDstPortList();
1473
1474 #line 1475 "IPTCfgParser.cpp"
1475 }
1476 }
1477 else {
1478 goto _loop117;
1479 }
1480
1481 }
1482 _loop117:;
1483 } // ( ... )*
1484 }
1485 break;
1486 }
1487 case MATCH_BOTH_MULTIPORT:
1488 {
1489 {
1490 match(MATCH_BOTH_MULTIPORT);
1491 if ( inputState->guessing==0 ) {
1492 #line 937 "iptables.g"
1493
1494 importer->srv_neg = importer->tmp_neg;
1495 importer->tmp_neg = false;
1496 importer->startBothMultiPort();
1497 *dbg << " MULTIPORT PORTS=";
1498
1499 #line 1500 "IPTCfgParser.cpp"
1500 }
1501 port_def_with_range();
1502 if ( inputState->guessing==0 ) {
1503 #line 944 "iptables.g"
1504
1505 importer->pushTmpPortSpecToBothPortList();
1506
1507 #line 1508 "IPTCfgParser.cpp"
1508 }
1509 { // ( ... )*
1510 for (;;) {
1511 if ((LA(1) == COMMA)) {
1512 match(COMMA);
1513 port_def_with_range();
1514 if ( inputState->guessing==0 ) {
1515 #line 948 "iptables.g"
1516
1517 importer->pushTmpPortSpecToBothPortList();
1518
1519 #line 1520 "IPTCfgParser.cpp"
1520 }
1521 }
1522 else {
1523 goto _loop120;
1524 }
1525
1526 }
1527 _loop120:;
1528 } // ( ... )*
1529 }
1530 break;
1531 }
1532 default:
1533 {
1534 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1535 }
1536 }
1537 }
1538 }
1539 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1540 if( inputState->guessing == 0 ) {
1541 reportError(ex);
1542 recover(ex,_tokenSet_5);
1543 } else {
1544 throw;
1545 }
1546 }
1547 }
1548
tcp_options()1549 void IPTCfgParser::tcp_options() {
1550
1551 try { // for error handling
1552 {
1553 switch ( LA(1)) {
1554 case MATCH_SYN:
1555 {
1556 syn();
1557 break;
1558 }
1559 case MATCH_TCP_FLAGS:
1560 {
1561 tcp_flags();
1562 break;
1563 }
1564 case MATCH_TCP_OPTION:
1565 {
1566 tcp_option();
1567 break;
1568 }
1569 default:
1570 {
1571 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1572 }
1573 }
1574 }
1575 if ( inputState->guessing==0 ) {
1576 #line 1111 "iptables.g"
1577
1578 importer->srv_neg = importer->tmp_neg;
1579 importer->tmp_neg = false;
1580
1581 #line 1582 "IPTCfgParser.cpp"
1582 }
1583 }
1584 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1585 if( inputState->guessing == 0 ) {
1586 reportError(ex);
1587 recover(ex,_tokenSet_5);
1588 } else {
1589 throw;
1590 }
1591 }
1592 }
1593
match_limit()1594 void IPTCfgParser::match_limit() {
1595
1596 try { // for error handling
1597 match(MATCH_LIMIT);
1598 limit_rate();
1599 }
1600 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1601 if( inputState->guessing == 0 ) {
1602 reportError(ex);
1603 recover(ex,_tokenSet_5);
1604 } else {
1605 throw;
1606 }
1607 }
1608 }
1609
match_limit_burst()1610 void IPTCfgParser::match_limit_burst() {
1611
1612 try { // for error handling
1613 match(MATCH_LIMIT_BURST);
1614 match(INT_CONST);
1615 if ( inputState->guessing==0 ) {
1616 #line 765 "iptables.g"
1617
1618 importer->limit_burst = LT(0)->getText();
1619 *dbg << " LIMIT BURST " << LT(0)->getText();
1620
1621 #line 1622 "IPTCfgParser.cpp"
1622 }
1623 }
1624 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1625 if( inputState->guessing == 0 ) {
1626 reportError(ex);
1627 recover(ex,_tokenSet_5);
1628 } else {
1629 throw;
1630 }
1631 }
1632 }
1633
match_length()1634 void IPTCfgParser::match_length() {
1635
1636 try { // for error handling
1637 match(MATCH_LENGTH);
1638 length_spec();
1639 }
1640 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1641 if( inputState->guessing == 0 ) {
1642 reportError(ex);
1643 recover(ex,_tokenSet_5);
1644 } else {
1645 throw;
1646 }
1647 }
1648 }
1649
match_iprange_src()1650 void IPTCfgParser::match_iprange_src() {
1651
1652 try { // for error handling
1653 match(MATCH_IPRANGE_SRC);
1654 {
1655 switch ( LA(1)) {
1656 case WORD:
1657 {
1658 match(WORD);
1659 break;
1660 }
1661 case IPV4:
1662 {
1663 match(IPV4);
1664 break;
1665 }
1666 default:
1667 {
1668 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1669 }
1670 }
1671 }
1672 if ( inputState->guessing==0 ) {
1673 #line 788 "iptables.g"
1674
1675 importer->iprange_src_from = LT(0)->getText();
1676 importer->using_iprange_src = true;
1677
1678 #line 1679 "IPTCfgParser.cpp"
1679 }
1680 match(MINUS);
1681 {
1682 switch ( LA(1)) {
1683 case WORD:
1684 {
1685 match(WORD);
1686 break;
1687 }
1688 case IPV4:
1689 {
1690 match(IPV4);
1691 break;
1692 }
1693 default:
1694 {
1695 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1696 }
1697 }
1698 }
1699 if ( inputState->guessing==0 ) {
1700 #line 793 "iptables.g"
1701
1702 importer->iprange_src_to = LT(0)->getText();
1703
1704 #line 1705 "IPTCfgParser.cpp"
1705 }
1706 }
1707 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1708 if( inputState->guessing == 0 ) {
1709 reportError(ex);
1710 recover(ex,_tokenSet_5);
1711 } else {
1712 throw;
1713 }
1714 }
1715 }
1716
match_iprange_dst()1717 void IPTCfgParser::match_iprange_dst() {
1718
1719 try { // for error handling
1720 match(MATCH_IPRANGE_DST);
1721 {
1722 switch ( LA(1)) {
1723 case WORD:
1724 {
1725 match(WORD);
1726 break;
1727 }
1728 case IPV4:
1729 {
1730 match(IPV4);
1731 break;
1732 }
1733 default:
1734 {
1735 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1736 }
1737 }
1738 }
1739 if ( inputState->guessing==0 ) {
1740 #line 799 "iptables.g"
1741
1742 importer->iprange_dst_from = LT(0)->getText();
1743 importer->using_iprange_dst = true;
1744
1745 #line 1746 "IPTCfgParser.cpp"
1746 }
1747 match(MINUS);
1748 {
1749 switch ( LA(1)) {
1750 case WORD:
1751 {
1752 match(WORD);
1753 break;
1754 }
1755 case IPV4:
1756 {
1757 match(IPV4);
1758 break;
1759 }
1760 default:
1761 {
1762 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1763 }
1764 }
1765 }
1766 if ( inputState->guessing==0 ) {
1767 #line 804 "iptables.g"
1768
1769 importer->iprange_dst_to = LT(0)->getText();
1770
1771 #line 1772 "IPTCfgParser.cpp"
1772 }
1773 }
1774 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1775 if( inputState->guessing == 0 ) {
1776 reportError(ex);
1777 recover(ex,_tokenSet_5);
1778 } else {
1779 throw;
1780 }
1781 }
1782 }
1783
unknown_option()1784 void IPTCfgParser::unknown_option() {
1785
1786 try { // for error handling
1787 if ((LA(1) == MINUS) && (LA(2) == WORD)) {
1788 {
1789 match(MINUS);
1790 match(WORD);
1791 if ( inputState->guessing==0 ) {
1792 #line 312 "iptables.g"
1793
1794 importer->reportError(
1795 std::string("Unknown option: -")+LT(0)->getText());
1796 *dbg << " UNKNOWN OPTION=-" << LT(0)->getText();
1797
1798 #line 1799 "IPTCfgParser.cpp"
1799 }
1800 {
1801 switch ( LA(1)) {
1802 case WORD:
1803 case INT_CONST:
1804 case DIGIT:
1805 {
1806 unknown_parameter();
1807 break;
1808 }
1809 case NEWLINE:
1810 case MINUS:
1811 case EXCLAMATION:
1812 case UNSUPPORTED_OPTION:
1813 case OPT_MODULE:
1814 case OPT_SRC:
1815 case OPT_DST:
1816 case OPT_IN_INTF:
1817 case OPT_OUT_INTF:
1818 case OPT_PROTO:
1819 case OPT_TARGET:
1820 case OPT_FRAGM:
1821 case MATCH_LIMIT:
1822 case MATCH_LIMIT_BURST:
1823 case MATCH_IPRANGE_SRC:
1824 case MATCH_IPRANGE_DST:
1825 case MATCH_LENGTH:
1826 case MATCH_SRC_MULTIPORT:
1827 case MATCH_DST_MULTIPORT:
1828 case MATCH_BOTH_MULTIPORT:
1829 case MATCH_ICMP_TYPE:
1830 case MATCH_SRC_PORT:
1831 case MATCH_SRC_PORT_SHORT:
1832 case MATCH_DST_PORT:
1833 case MATCH_DST_PORT_SHORT:
1834 case MATCH_SYN:
1835 case MATCH_TCP_FLAGS:
1836 case MATCH_TCP_OPTION:
1837 {
1838 break;
1839 }
1840 default:
1841 {
1842 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1843 }
1844 }
1845 }
1846 }
1847 }
1848 else if ((LA(1) == MINUS) && (LA(2) == MINUS)) {
1849 {
1850 {
1851 match(MINUS);
1852 match(MINUS);
1853 match(WORD);
1854 }
1855 if ( inputState->guessing==0 ) {
1856 #line 322 "iptables.g"
1857
1858 importer->reportError(
1859 std::string("Unknown option: --")+LT(0)->getText());
1860 *dbg << " UNKNOWN OPTION=--" << LT(0)->getText();
1861
1862 #line 1863 "IPTCfgParser.cpp"
1863 }
1864 {
1865 switch ( LA(1)) {
1866 case WORD:
1867 case INT_CONST:
1868 case DIGIT:
1869 {
1870 unknown_parameter();
1871 break;
1872 }
1873 case NEWLINE:
1874 case MINUS:
1875 case EXCLAMATION:
1876 case UNSUPPORTED_OPTION:
1877 case OPT_MODULE:
1878 case OPT_SRC:
1879 case OPT_DST:
1880 case OPT_IN_INTF:
1881 case OPT_OUT_INTF:
1882 case OPT_PROTO:
1883 case OPT_TARGET:
1884 case OPT_FRAGM:
1885 case MATCH_LIMIT:
1886 case MATCH_LIMIT_BURST:
1887 case MATCH_IPRANGE_SRC:
1888 case MATCH_IPRANGE_DST:
1889 case MATCH_LENGTH:
1890 case MATCH_SRC_MULTIPORT:
1891 case MATCH_DST_MULTIPORT:
1892 case MATCH_BOTH_MULTIPORT:
1893 case MATCH_ICMP_TYPE:
1894 case MATCH_SRC_PORT:
1895 case MATCH_SRC_PORT_SHORT:
1896 case MATCH_DST_PORT:
1897 case MATCH_DST_PORT_SHORT:
1898 case MATCH_SYN:
1899 case MATCH_TCP_FLAGS:
1900 case MATCH_TCP_OPTION:
1901 {
1902 break;
1903 }
1904 default:
1905 {
1906 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1907 }
1908 }
1909 }
1910 }
1911 }
1912 else if ((LA(1) == UNSUPPORTED_OPTION)) {
1913 {
1914 match(UNSUPPORTED_OPTION);
1915 if ( inputState->guessing==0 ) {
1916 #line 332 "iptables.g"
1917
1918 importer->reportError(
1919 std::string("Unknown option: ")+LT(0)->getText());
1920 *dbg << " UNKNOWN OPTION=" << LT(0)->getText();
1921
1922 #line 1923 "IPTCfgParser.cpp"
1923 }
1924 {
1925 switch ( LA(1)) {
1926 case WORD:
1927 case INT_CONST:
1928 case DIGIT:
1929 {
1930 unknown_parameter();
1931 break;
1932 }
1933 case NEWLINE:
1934 case MINUS:
1935 case EXCLAMATION:
1936 case UNSUPPORTED_OPTION:
1937 case OPT_MODULE:
1938 case OPT_SRC:
1939 case OPT_DST:
1940 case OPT_IN_INTF:
1941 case OPT_OUT_INTF:
1942 case OPT_PROTO:
1943 case OPT_TARGET:
1944 case OPT_FRAGM:
1945 case MATCH_LIMIT:
1946 case MATCH_LIMIT_BURST:
1947 case MATCH_IPRANGE_SRC:
1948 case MATCH_IPRANGE_DST:
1949 case MATCH_LENGTH:
1950 case MATCH_SRC_MULTIPORT:
1951 case MATCH_DST_MULTIPORT:
1952 case MATCH_BOTH_MULTIPORT:
1953 case MATCH_ICMP_TYPE:
1954 case MATCH_SRC_PORT:
1955 case MATCH_SRC_PORT_SHORT:
1956 case MATCH_DST_PORT:
1957 case MATCH_DST_PORT_SHORT:
1958 case MATCH_SYN:
1959 case MATCH_TCP_FLAGS:
1960 case MATCH_TCP_OPTION:
1961 {
1962 break;
1963 }
1964 default:
1965 {
1966 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1967 }
1968 }
1969 }
1970 }
1971 }
1972 else {
1973 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1974 }
1975
1976 }
1977 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1978 if( inputState->guessing == 0 ) {
1979 reportError(ex);
1980 recover(ex,_tokenSet_5);
1981 } else {
1982 throw;
1983 }
1984 }
1985 }
1986
unknown_parameter()1987 void IPTCfgParser::unknown_parameter() {
1988 #line 341 "iptables.g"
1989 std::string s;
1990 #line 1991 "IPTCfgParser.cpp"
1991
1992 try { // for error handling
1993 if ((LA(1) == INT_CONST || LA(1) == DIGIT) && (LA(2) == SLASH)) {
1994 {
1995 {
1996 {
1997 switch ( LA(1)) {
1998 case DIGIT:
1999 {
2000 match(DIGIT);
2001 if ( inputState->guessing==0 ) {
2002 #line 347 "iptables.g"
2003 s+=LT(0)->getText();
2004 #line 2005 "IPTCfgParser.cpp"
2005 }
2006 break;
2007 }
2008 case INT_CONST:
2009 {
2010 match(INT_CONST);
2011 if ( inputState->guessing==0 ) {
2012 #line 349 "iptables.g"
2013 s+=LT(0)->getText();
2014 #line 2015 "IPTCfgParser.cpp"
2015 }
2016 break;
2017 }
2018 default:
2019 {
2020 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2021 }
2022 }
2023 }
2024 match(SLASH);
2025 if ( inputState->guessing==0 ) {
2026 #line 351 "iptables.g"
2027 s+=LT(0)->getText();
2028 #line 2029 "IPTCfgParser.cpp"
2029 }
2030 match(WORD);
2031 if ( inputState->guessing==0 ) {
2032 #line 352 "iptables.g"
2033 s+=LT(0)->getText();
2034 #line 2035 "IPTCfgParser.cpp"
2035 }
2036 }
2037 if ( inputState->guessing==0 ) {
2038 #line 354 "iptables.g"
2039
2040 importer->reportError(
2041 std::string("Unknown parameter: ")+s);
2042 *dbg << " UNKNOWN PARMETER=" << s;
2043
2044 #line 2045 "IPTCfgParser.cpp"
2045 }
2046 }
2047 }
2048 else if ((LA(1) == WORD || LA(1) == INT_CONST || LA(1) == DIGIT) && (_tokenSet_5.member(LA(2)))) {
2049 {
2050 {
2051 switch ( LA(1)) {
2052 case DIGIT:
2053 {
2054 match(DIGIT);
2055 break;
2056 }
2057 case INT_CONST:
2058 {
2059 match(INT_CONST);
2060 break;
2061 }
2062 case WORD:
2063 {
2064 match(WORD);
2065 break;
2066 }
2067 default:
2068 {
2069 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2070 }
2071 }
2072 }
2073 if ( inputState->guessing==0 ) {
2074 #line 363 "iptables.g"
2075
2076 importer->reportError(
2077 std::string("Unknown parameter: ")+LT(0)->getText());
2078 *dbg << " UNKNOWN PARMETER=" << LT(0)->getText();
2079
2080 #line 2081 "IPTCfgParser.cpp"
2081 }
2082 }
2083 }
2084 else {
2085 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2086 }
2087
2088 }
2089 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2090 if( inputState->guessing == 0 ) {
2091 reportError(ex);
2092 recover(ex,_tokenSet_5);
2093 } else {
2094 throw;
2095 }
2096 }
2097 }
2098
m_state()2099 void IPTCfgParser::m_state() {
2100
2101 try { // for error handling
2102 match(M_STATE);
2103 match(MATCH_STATE);
2104 if ( inputState->guessing==0 ) {
2105 #line 701 "iptables.g"
2106
2107 importer->current_state = "";
2108
2109 #line 2110 "IPTCfgParser.cpp"
2110 }
2111 state_word();
2112 if ( inputState->guessing==0 ) {
2113 #line 705 "iptables.g"
2114
2115 importer->current_state += LT(0)->getText();
2116
2117 #line 2118 "IPTCfgParser.cpp"
2118 }
2119 { // ( ... )*
2120 for (;;) {
2121 if ((LA(1) == COMMA)) {
2122 match(COMMA);
2123 state_word();
2124 if ( inputState->guessing==0 ) {
2125 #line 710 "iptables.g"
2126
2127 importer->current_state += std::string(",") + LT(0)->getText();
2128
2129 #line 2130 "IPTCfgParser.cpp"
2130 }
2131 }
2132 else {
2133 goto _loop76;
2134 }
2135
2136 }
2137 _loop76:;
2138 } // ( ... )*
2139 if ( inputState->guessing==0 ) {
2140 #line 714 "iptables.g"
2141
2142 *dbg << " STATE MATCH=" << importer->current_state;
2143
2144 #line 2145 "IPTCfgParser.cpp"
2145 }
2146 }
2147 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2148 if( inputState->guessing == 0 ) {
2149 reportError(ex);
2150 recover(ex,_tokenSet_5);
2151 } else {
2152 throw;
2153 }
2154 }
2155 }
2156
m_mport()2157 void IPTCfgParser::m_mport() {
2158
2159 try { // for error handling
2160 match(M_MPORT);
2161 if ( inputState->guessing==0 ) {
2162 #line 873 "iptables.g"
2163
2164 *dbg << " MULTIPORT";
2165
2166 #line 2167 "IPTCfgParser.cpp"
2167 }
2168 }
2169 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2170 if( inputState->guessing == 0 ) {
2171 reportError(ex);
2172 recover(ex,_tokenSet_5);
2173 } else {
2174 throw;
2175 }
2176 }
2177 }
2178
m_icmp()2179 void IPTCfgParser::m_icmp() {
2180
2181 try { // for error handling
2182 match(ICMP);
2183 if ( inputState->guessing==0 ) {
2184 #line 960 "iptables.g"
2185
2186 importer->protocol = "icmp";
2187 *dbg << " ICMP";
2188
2189 #line 2190 "IPTCfgParser.cpp"
2190 }
2191 }
2192 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2193 if( inputState->guessing == 0 ) {
2194 reportError(ex);
2195 recover(ex,_tokenSet_5);
2196 } else {
2197 throw;
2198 }
2199 }
2200 }
2201
m_tcp()2202 void IPTCfgParser::m_tcp() {
2203
2204 try { // for error handling
2205 match(TCP);
2206 if ( inputState->guessing==0 ) {
2207 #line 1099 "iptables.g"
2208
2209 importer->protocol = "tcp";
2210 *dbg << " TCP";
2211
2212 #line 2213 "IPTCfgParser.cpp"
2213 }
2214 }
2215 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2216 if( inputState->guessing == 0 ) {
2217 reportError(ex);
2218 recover(ex,_tokenSet_5);
2219 } else {
2220 throw;
2221 }
2222 }
2223 }
2224
m_udp()2225 void IPTCfgParser::m_udp() {
2226
2227 try { // for error handling
2228 match(UDP);
2229 if ( inputState->guessing==0 ) {
2230 #line 1090 "iptables.g"
2231
2232 importer->protocol = "udp";
2233 *dbg << " UDP";
2234
2235 #line 2236 "IPTCfgParser.cpp"
2236 }
2237 }
2238 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2239 if( inputState->guessing == 0 ) {
2240 reportError(ex);
2241 recover(ex,_tokenSet_5);
2242 } else {
2243 throw;
2244 }
2245 }
2246 }
2247
m_limit()2248 void IPTCfgParser::m_limit() {
2249
2250 try { // for error handling
2251 match(M_LIMIT);
2252 if ( inputState->guessing==0 ) {
2253 #line 743 "iptables.g"
2254
2255 *dbg << " LIMIT";
2256
2257 #line 2258 "IPTCfgParser.cpp"
2258 }
2259 }
2260 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2261 if( inputState->guessing == 0 ) {
2262 reportError(ex);
2263 recover(ex,_tokenSet_5);
2264 } else {
2265 throw;
2266 }
2267 }
2268 }
2269
m_length()2270 void IPTCfgParser::m_length() {
2271
2272 try { // for error handling
2273 match(M_LENGTH);
2274 if ( inputState->guessing==0 ) {
2275 #line 838 "iptables.g"
2276
2277 *dbg << " LENGTH";
2278
2279 #line 2280 "IPTCfgParser.cpp"
2280 }
2281 }
2282 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2283 if( inputState->guessing == 0 ) {
2284 reportError(ex);
2285 recover(ex,_tokenSet_5);
2286 } else {
2287 throw;
2288 }
2289 }
2290 }
2291
m_iprange()2292 void IPTCfgParser::m_iprange() {
2293
2294 try { // for error handling
2295 match(M_IPRANGE);
2296 if ( inputState->guessing==0 ) {
2297 #line 782 "iptables.g"
2298
2299 *dbg << " IPRANGE";
2300
2301 #line 2302 "IPTCfgParser.cpp"
2302 }
2303 }
2304 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2305 if( inputState->guessing == 0 ) {
2306 reportError(ex);
2307 recover(ex,_tokenSet_5);
2308 } else {
2309 throw;
2310 }
2311 }
2312 }
2313
m_comment()2314 void IPTCfgParser::m_comment() {
2315
2316 try { // for error handling
2317 match(M_COMMENT);
2318 match(MATCH_COMMENT);
2319 match(STRING);
2320 if ( inputState->guessing==0 ) {
2321 #line 881 "iptables.g"
2322
2323 *dbg << " COMMENT=" << LT(0)->getText();
2324
2325 #line 2326 "IPTCfgParser.cpp"
2326 }
2327 }
2328 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2329 if( inputState->guessing == 0 ) {
2330 reportError(ex);
2331 recover(ex,_tokenSet_5);
2332 } else {
2333 throw;
2334 }
2335 }
2336 }
2337
m_pkttype()2338 void IPTCfgParser::m_pkttype() {
2339
2340 try { // for error handling
2341 match(M_PKTTYPE);
2342 match(MATCH_PKT_TYPE);
2343 pkt_type_spec();
2344 }
2345 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2346 if( inputState->guessing == 0 ) {
2347 reportError(ex);
2348 recover(ex,_tokenSet_5);
2349 } else {
2350 throw;
2351 }
2352 }
2353 }
2354
m_unknown_module()2355 void IPTCfgParser::m_unknown_module() {
2356
2357 try { // for error handling
2358 match(WORD);
2359 if ( inputState->guessing==0 ) {
2360 #line 688 "iptables.g"
2361
2362 *dbg << " UNKNOWN MODULE=" << LT(0)->getText();
2363 importer->reportError(
2364 std::string("Unknown module: ")+LT(0)->getText());
2365
2366 #line 2367 "IPTCfgParser.cpp"
2367 }
2368 }
2369 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2370 if( inputState->guessing == 0 ) {
2371 reportError(ex);
2372 recover(ex,_tokenSet_5);
2373 } else {
2374 throw;
2375 }
2376 }
2377 }
2378
protocol_word()2379 void IPTCfgParser::protocol_word() {
2380
2381 try { // for error handling
2382 {
2383 switch ( LA(1)) {
2384 case TCP:
2385 {
2386 match(TCP);
2387 break;
2388 }
2389 case UDP:
2390 {
2391 match(UDP);
2392 break;
2393 }
2394 case ICMP:
2395 {
2396 match(ICMP);
2397 break;
2398 }
2399 case WORD:
2400 {
2401 match(WORD);
2402 break;
2403 }
2404 case INT_CONST:
2405 {
2406 match(INT_CONST);
2407 break;
2408 }
2409 default:
2410 {
2411 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2412 }
2413 }
2414 }
2415 }
2416 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2417 if( inputState->guessing == 0 ) {
2418 reportError(ex);
2419 recover(ex,_tokenSet_5);
2420 } else {
2421 throw;
2422 }
2423 }
2424 }
2425
target_options()2426 void IPTCfgParser::target_options() {
2427 ANTLR_USE_NAMESPACE(antlr)RefToken major = ANTLR_USE_NAMESPACE(antlr)nullToken;
2428 ANTLR_USE_NAMESPACE(antlr)RefToken minor = ANTLR_USE_NAMESPACE(antlr)nullToken;
2429
2430 try { // for error handling
2431 {
2432 switch ( LA(1)) {
2433 case REJECT_WITH:
2434 {
2435 match(REJECT_WITH);
2436 match(WORD);
2437 if ( inputState->guessing==0 ) {
2438 #line 479 "iptables.g"
2439
2440 importer->action_params["reject_with"] = LT(0)->getText();
2441 *dbg << " REJECT WITH=" << LT(0)->getText();
2442
2443 #line 2444 "IPTCfgParser.cpp"
2444 }
2445 break;
2446 }
2447 case LOG_PREFIX:
2448 {
2449 match(LOG_PREFIX);
2450 {
2451 switch ( LA(1)) {
2452 case WORD:
2453 {
2454 match(WORD);
2455 break;
2456 }
2457 case STRING:
2458 {
2459 match(STRING);
2460 break;
2461 }
2462 default:
2463 {
2464 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2465 }
2466 }
2467 }
2468 if ( inputState->guessing==0 ) {
2469 #line 485 "iptables.g"
2470
2471 importer->action_params["log_prefix"] = LT(0)->getText();
2472 *dbg << " LOG PREFIX=" << LT(0)->getText();
2473
2474 #line 2475 "IPTCfgParser.cpp"
2475 }
2476 break;
2477 }
2478 case LOG_TCP_SEQ:
2479 {
2480 match(LOG_TCP_SEQ);
2481 if ( inputState->guessing==0 ) {
2482 #line 491 "iptables.g"
2483
2484 importer->action_params["log_tcp_seq"] = LT(0)->getText();
2485 *dbg << " LOG TCP SEQUENCE=";
2486
2487 #line 2488 "IPTCfgParser.cpp"
2488 }
2489 break;
2490 }
2491 case LOG_TCP_OPT:
2492 {
2493 match(LOG_TCP_OPT);
2494 if ( inputState->guessing==0 ) {
2495 #line 497 "iptables.g"
2496
2497 importer->action_params["log_tcp_options"] = LT(0)->getText();
2498 *dbg << " LOG TCP OPTIONS=";
2499
2500 #line 2501 "IPTCfgParser.cpp"
2501 }
2502 break;
2503 }
2504 case LOG_IP_OPT:
2505 {
2506 match(LOG_IP_OPT);
2507 if ( inputState->guessing==0 ) {
2508 #line 503 "iptables.g"
2509
2510 importer->action_params["log_ip_options"] = LT(0)->getText();
2511 *dbg << " LOG IP OPTIONS=";
2512
2513 #line 2514 "IPTCfgParser.cpp"
2514 }
2515 break;
2516 }
2517 case ULOG_PREFIX:
2518 {
2519 match(ULOG_PREFIX);
2520 {
2521 switch ( LA(1)) {
2522 case WORD:
2523 {
2524 match(WORD);
2525 break;
2526 }
2527 case STRING:
2528 {
2529 match(STRING);
2530 break;
2531 }
2532 default:
2533 {
2534 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2535 }
2536 }
2537 }
2538 if ( inputState->guessing==0 ) {
2539 #line 509 "iptables.g"
2540
2541 importer->action_params["log_prefix"] = LT(0)->getText();
2542 *dbg << " ULOG PREFIX=" << LT(0)->getText();
2543
2544 #line 2545 "IPTCfgParser.cpp"
2545 }
2546 break;
2547 }
2548 case LOG_LEVEL:
2549 {
2550 match(LOG_LEVEL);
2551 {
2552 switch ( LA(1)) {
2553 case INT_CONST:
2554 {
2555 match(INT_CONST);
2556 break;
2557 }
2558 case WORD:
2559 {
2560 match(WORD);
2561 break;
2562 }
2563 default:
2564 {
2565 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2566 }
2567 }
2568 }
2569 if ( inputState->guessing==0 ) {
2570 #line 515 "iptables.g"
2571
2572 importer->action_params["log_level"] = LT(0)->getText();
2573 *dbg << " LOG LEVEL=" << LT(0)->getText();
2574
2575 #line 2576 "IPTCfgParser.cpp"
2576 }
2577 break;
2578 }
2579 case SET_CLASS:
2580 {
2581 match(SET_CLASS);
2582 major = LT(1);
2583 match(INT_CONST);
2584 match(COLON);
2585 minor = LT(1);
2586 match(INT_CONST);
2587 if ( inputState->guessing==0 ) {
2588 #line 521 "iptables.g"
2589
2590 importer->action_params["set_class"] =
2591 major->getText() + ":" + minor->getText();
2592 *dbg << " SET CLASS=" << major->getText() + ":" + minor->getText();
2593
2594 #line 2595 "IPTCfgParser.cpp"
2595 }
2596 break;
2597 }
2598 case SET_MARK:
2599 {
2600 match(SET_MARK);
2601 {
2602 switch ( LA(1)) {
2603 case INT_CONST:
2604 {
2605 match(INT_CONST);
2606 break;
2607 }
2608 case HEX_CONST:
2609 {
2610 match(HEX_CONST);
2611 break;
2612 }
2613 default:
2614 {
2615 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2616 }
2617 }
2618 }
2619 if ( inputState->guessing==0 ) {
2620 #line 528 "iptables.g"
2621
2622 importer->action_params["set_mark"] = LT(0)->getText();
2623 *dbg << " SET MARK=" << LT(0)->getText();
2624
2625 #line 2626 "IPTCfgParser.cpp"
2626 }
2627 break;
2628 }
2629 case SAVE_MARK:
2630 {
2631 match(SAVE_MARK);
2632 if ( inputState->guessing==0 ) {
2633 #line 546 "iptables.g"
2634
2635 importer->action_params["connmark_save_mark"] = "--save-mark";
2636 *dbg << " SAVE MARK";
2637
2638 #line 2639 "IPTCfgParser.cpp"
2639 }
2640 break;
2641 }
2642 case RESTORE_MARK:
2643 {
2644 match(RESTORE_MARK);
2645 if ( inputState->guessing==0 ) {
2646 #line 552 "iptables.g"
2647
2648 importer->action_params["connmark_restore_mark"] = "--restore-mark";
2649 *dbg << " RESTORE MARK";
2650
2651 #line 2652 "IPTCfgParser.cpp"
2652 }
2653 break;
2654 }
2655 case CONTINUE:
2656 {
2657 match(CONTINUE);
2658 if ( inputState->guessing==0 ) {
2659 #line 558 "iptables.g"
2660
2661 importer->action_params["route_continue"] = "--continue";
2662 *dbg << " CONTINUE";
2663
2664 #line 2665 "IPTCfgParser.cpp"
2665 }
2666 break;
2667 }
2668 case ROUTE_IIF:
2669 {
2670 match(ROUTE_IIF);
2671 match(WORD);
2672 if ( inputState->guessing==0 ) {
2673 #line 564 "iptables.g"
2674
2675 importer->action_params["route_iif"] = LT(0)->getText();
2676 *dbg << " ROUTE_IIF=" << LT(0)->getText();
2677
2678 #line 2679 "IPTCfgParser.cpp"
2679 }
2680 break;
2681 }
2682 case ROUTE_OIF:
2683 {
2684 match(ROUTE_OIF);
2685 match(WORD);
2686 if ( inputState->guessing==0 ) {
2687 #line 570 "iptables.g"
2688
2689 importer->action_params["route_oif"] = LT(0)->getText();
2690 *dbg << " ROUTE_OIF=" << LT(0)->getText();
2691
2692 #line 2693 "IPTCfgParser.cpp"
2693 }
2694 break;
2695 }
2696 case ROUTE_GW:
2697 {
2698 match(ROUTE_GW);
2699 match(IPV4);
2700 if ( inputState->guessing==0 ) {
2701 #line 576 "iptables.g"
2702
2703 importer->action_params["route_gw"] = LT(0)->getText();
2704 *dbg << " ROUTE_GW=" << LT(0)->getText();
2705
2706 #line 2707 "IPTCfgParser.cpp"
2707 }
2708 break;
2709 }
2710 case ROUTE_TEE:
2711 {
2712 match(ROUTE_TEE);
2713 if ( inputState->guessing==0 ) {
2714 #line 582 "iptables.g"
2715
2716 importer->action_params["route_tee"] = "--tee";
2717 *dbg << " ROUTE_TEE";
2718
2719 #line 2720 "IPTCfgParser.cpp"
2720 }
2721 break;
2722 }
2723 case TO_SOURCE:
2724 {
2725 match(TO_SOURCE);
2726 if ( inputState->guessing==0 ) {
2727 #line 588 "iptables.g"
2728
2729 *dbg << " TO-SOURCE";
2730
2731 #line 2732 "IPTCfgParser.cpp"
2732 }
2733 nat_spec();
2734 break;
2735 }
2736 case TO_DESTINATION:
2737 {
2738 match(TO_DESTINATION);
2739 if ( inputState->guessing==0 ) {
2740 #line 594 "iptables.g"
2741
2742 *dbg << " TO-DESTINATION";
2743
2744 #line 2745 "IPTCfgParser.cpp"
2745 }
2746 nat_spec();
2747 break;
2748 }
2749 case TO_PORTS:
2750 {
2751 match(TO_PORTS);
2752 redirect_spec();
2753 break;
2754 }
2755 case TO_NETMAP:
2756 {
2757 match(TO_NETMAP);
2758 if ( inputState->guessing==0 ) {
2759 #line 602 "iptables.g"
2760
2761 *dbg << " TO-NETMAP";
2762
2763 #line 2764 "IPTCfgParser.cpp"
2764 }
2765 {
2766 match(IPV4);
2767 if ( inputState->guessing==0 ) {
2768 #line 607 "iptables.g"
2769
2770 importer->nat_addr1 = LT(0)->getText();
2771 importer->nat_addr2 = LT(0)->getText();
2772 *dbg << LT(0)->getText();
2773
2774 #line 2775 "IPTCfgParser.cpp"
2775 }
2776 match(SLASH);
2777 {
2778 switch ( LA(1)) {
2779 case IPV4:
2780 {
2781 match(IPV4);
2782 break;
2783 }
2784 case INT_CONST:
2785 {
2786 match(INT_CONST);
2787 break;
2788 }
2789 default:
2790 {
2791 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2792 }
2793 }
2794 }
2795 if ( inputState->guessing==0 ) {
2796 #line 613 "iptables.g"
2797
2798 importer->nat_nm = LT(0)->getText();
2799 *dbg << "/" << LT(0)->getText();
2800
2801 #line 2802 "IPTCfgParser.cpp"
2802 }
2803 }
2804 break;
2805 }
2806 case CLAMP_MSS:
2807 {
2808 match(CLAMP_MSS);
2809 if ( inputState->guessing==0 ) {
2810 #line 620 "iptables.g"
2811
2812 importer->action_params["clamp-mss-to-pmtu"] = "--clamp-mss-to-pmtu";
2813 *dbg << " TO-NETMAP";
2814
2815 #line 2816 "IPTCfgParser.cpp"
2816 }
2817 break;
2818 }
2819 default:
2820 if ((LA(1) == SET_TOS) && (LA(2) == HEX_CONST)) {
2821 match(SET_TOS);
2822 match(HEX_CONST);
2823 if ( inputState->guessing==0 ) {
2824 #line 534 "iptables.g"
2825
2826 importer->action_params["set_tos"] = LT(0)->getText();
2827 *dbg << " SET TOS=" << LT(0)->getText();
2828
2829 #line 2830 "IPTCfgParser.cpp"
2830 }
2831 }
2832 else if ((LA(1) == SET_TOS) && (LA(2) == WORD)) {
2833 match(SET_TOS);
2834 match(WORD);
2835 if ( inputState->guessing==0 ) {
2836 #line 540 "iptables.g"
2837
2838 importer->action_params["set_tos"] = LT(0)->getText();
2839 *dbg << " SET TOS=" << LT(0)->getText();
2840
2841 #line 2842 "IPTCfgParser.cpp"
2842 }
2843 }
2844 else {
2845 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2846 }
2847 }
2848 }
2849 }
2850 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2851 if( inputState->guessing == 0 ) {
2852 reportError(ex);
2853 recover(ex,_tokenSet_7);
2854 } else {
2855 throw;
2856 }
2857 }
2858 }
2859
nat_spec()2860 void IPTCfgParser::nat_spec() {
2861
2862 try { // for error handling
2863 nat_addr_range();
2864 {
2865 switch ( LA(1)) {
2866 case COLON:
2867 {
2868 match(COLON);
2869 nat_port_def_with_range();
2870 break;
2871 }
2872 case NEWLINE:
2873 case MINUS:
2874 case EXCLAMATION:
2875 case UNSUPPORTED_OPTION:
2876 case OPT_MODULE:
2877 case OPT_SRC:
2878 case OPT_DST:
2879 case OPT_IN_INTF:
2880 case OPT_OUT_INTF:
2881 case OPT_PROTO:
2882 case OPT_TARGET:
2883 case REJECT_WITH:
2884 case LOG_PREFIX:
2885 case LOG_TCP_SEQ:
2886 case LOG_TCP_OPT:
2887 case LOG_IP_OPT:
2888 case ULOG_PREFIX:
2889 case LOG_LEVEL:
2890 case SET_CLASS:
2891 case SET_MARK:
2892 case SET_TOS:
2893 case SAVE_MARK:
2894 case RESTORE_MARK:
2895 case CONTINUE:
2896 case ROUTE_IIF:
2897 case ROUTE_OIF:
2898 case ROUTE_GW:
2899 case ROUTE_TEE:
2900 case TO_SOURCE:
2901 case TO_DESTINATION:
2902 case TO_PORTS:
2903 case TO_NETMAP:
2904 case CLAMP_MSS:
2905 case OPT_FRAGM:
2906 case MATCH_LIMIT:
2907 case MATCH_LIMIT_BURST:
2908 case MATCH_IPRANGE_SRC:
2909 case MATCH_IPRANGE_DST:
2910 case MATCH_LENGTH:
2911 case MATCH_SRC_MULTIPORT:
2912 case MATCH_DST_MULTIPORT:
2913 case MATCH_BOTH_MULTIPORT:
2914 case MATCH_ICMP_TYPE:
2915 case MATCH_SRC_PORT:
2916 case MATCH_SRC_PORT_SHORT:
2917 case MATCH_DST_PORT:
2918 case MATCH_DST_PORT_SHORT:
2919 case MATCH_SYN:
2920 case MATCH_TCP_FLAGS:
2921 case MATCH_TCP_OPTION:
2922 {
2923 break;
2924 }
2925 default:
2926 {
2927 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2928 }
2929 }
2930 }
2931 if ( inputState->guessing==0 ) {
2932 #line 631 "iptables.g"
2933
2934 *dbg << " "
2935 << importer->nat_addr1
2936 << "-"
2937 << importer->nat_addr2
2938 << ":"
2939 << importer->nat_port_range_start
2940 << "-"
2941 << importer->nat_port_range_end;
2942
2943 #line 2944 "IPTCfgParser.cpp"
2944 }
2945 }
2946 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2947 if( inputState->guessing == 0 ) {
2948 reportError(ex);
2949 recover(ex,_tokenSet_7);
2950 } else {
2951 throw;
2952 }
2953 }
2954 }
2955
redirect_spec()2956 void IPTCfgParser::redirect_spec() {
2957
2958 try { // for error handling
2959 nat_port_def_with_range();
2960 if ( inputState->guessing==0 ) {
2961 #line 666 "iptables.g"
2962
2963 *dbg << " TO-PORTS "
2964 << importer->nat_addr1
2965 << "-"
2966 << importer->nat_addr2
2967 << ":"
2968 << importer->nat_port_range_start
2969 << "-"
2970 << importer->nat_port_range_end;
2971
2972 #line 2973 "IPTCfgParser.cpp"
2973 }
2974 }
2975 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2976 if( inputState->guessing == 0 ) {
2977 reportError(ex);
2978 recover(ex,_tokenSet_7);
2979 } else {
2980 throw;
2981 }
2982 }
2983 }
2984
nat_addr_range()2985 void IPTCfgParser::nat_addr_range() {
2986 ANTLR_USE_NAMESPACE(antlr)RefToken a1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
2987 ANTLR_USE_NAMESPACE(antlr)RefToken a2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
2988
2989 try { // for error handling
2990 bool synPredMatched67 = false;
2991 if (((LA(1) == IPV4) && (LA(2) == MINUS))) {
2992 int _m67 = mark();
2993 synPredMatched67 = true;
2994 inputState->guessing++;
2995 try {
2996 {
2997 match(IPV4);
2998 match(MINUS);
2999 }
3000 }
3001 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
3002 synPredMatched67 = false;
3003 }
3004 rewind(_m67);
3005 inputState->guessing--;
3006 }
3007 if ( synPredMatched67 ) {
3008 {
3009 a1 = LT(1);
3010 match(IPV4);
3011 match(MINUS);
3012 a2 = LT(1);
3013 match(IPV4);
3014 if ( inputState->guessing==0 ) {
3015 #line 647 "iptables.g"
3016
3017 importer->nat_port_range_start = "";
3018 importer->nat_port_range_end = "";
3019 importer->nat_addr1 = a1->getText();
3020 importer->nat_addr2 = a2->getText();
3021
3022 #line 3023 "IPTCfgParser.cpp"
3023 }
3024 }
3025 }
3026 else if ((LA(1) == IPV4) && (_tokenSet_8.member(LA(2)))) {
3027 match(IPV4);
3028 if ( inputState->guessing==0 ) {
3029 #line 656 "iptables.g"
3030
3031 importer->nat_port_range_start = "";
3032 importer->nat_port_range_end = "";
3033 importer->nat_addr1 = LT(0)->getText();
3034 importer->nat_addr2 = LT(0)->getText();
3035
3036 #line 3037 "IPTCfgParser.cpp"
3037 }
3038 }
3039 else {
3040 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3041 }
3042
3043 }
3044 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3045 if( inputState->guessing == 0 ) {
3046 reportError(ex);
3047 recover(ex,_tokenSet_8);
3048 } else {
3049 throw;
3050 }
3051 }
3052 }
3053
nat_port_def_with_range()3054 void IPTCfgParser::nat_port_def_with_range() {
3055
3056 try { // for error handling
3057 bool synPredMatched137 = false;
3058 if (((LA(1) == WORD || LA(1) == INT_CONST) && (LA(2) == MINUS))) {
3059 int _m137 = mark();
3060 synPredMatched137 = true;
3061 inputState->guessing++;
3062 try {
3063 {
3064 {
3065 switch ( LA(1)) {
3066 case WORD:
3067 {
3068 match(WORD);
3069 break;
3070 }
3071 case INT_CONST:
3072 {
3073 match(INT_CONST);
3074 break;
3075 }
3076 default:
3077 {
3078 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3079 }
3080 }
3081 }
3082 match(MINUS);
3083 }
3084 }
3085 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
3086 synPredMatched137 = false;
3087 }
3088 rewind(_m137);
3089 inputState->guessing--;
3090 }
3091 if ( synPredMatched137 ) {
3092 {
3093 {
3094 switch ( LA(1)) {
3095 case WORD:
3096 {
3097 match(WORD);
3098 break;
3099 }
3100 case INT_CONST:
3101 {
3102 match(INT_CONST);
3103 break;
3104 }
3105 default:
3106 {
3107 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3108 }
3109 }
3110 }
3111 if ( inputState->guessing==0 ) {
3112 #line 1043 "iptables.g"
3113
3114 importer->nat_port_range_start = LT(0)->getText();
3115 importer->nat_port_range_end = LT(0)->getText();
3116 *dbg << " PORT=" << LT(0)->getText();
3117
3118 #line 3119 "IPTCfgParser.cpp"
3119 }
3120 match(MINUS);
3121 {
3122 switch ( LA(1)) {
3123 case WORD:
3124 {
3125 match(WORD);
3126 break;
3127 }
3128 case INT_CONST:
3129 {
3130 match(INT_CONST);
3131 break;
3132 }
3133 default:
3134 {
3135 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3136 }
3137 }
3138 }
3139 if ( inputState->guessing==0 ) {
3140 #line 1049 "iptables.g"
3141
3142 importer->nat_port_range_end = LT(0)->getText();
3143 *dbg << ":" << LT(0)->getText();
3144
3145 #line 3146 "IPTCfgParser.cpp"
3146 }
3147 }
3148 }
3149 else if ((LA(1) == WORD || LA(1) == INT_CONST) && (_tokenSet_7.member(LA(2)))) {
3150 {
3151 switch ( LA(1)) {
3152 case WORD:
3153 {
3154 match(WORD);
3155 break;
3156 }
3157 case INT_CONST:
3158 {
3159 match(INT_CONST);
3160 break;
3161 }
3162 default:
3163 {
3164 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3165 }
3166 }
3167 }
3168 if ( inputState->guessing==0 ) {
3169 #line 1056 "iptables.g"
3170
3171 importer->nat_port_range_start = LT(0)->getText();
3172 importer->nat_port_range_end = LT(0)->getText();
3173 *dbg << " PORT=" << LT(0)->getText();
3174
3175 #line 3176 "IPTCfgParser.cpp"
3176 }
3177 }
3178 else {
3179 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3180 }
3181
3182 }
3183 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3184 if( inputState->guessing == 0 ) {
3185 reportError(ex);
3186 recover(ex,_tokenSet_7);
3187 } else {
3188 throw;
3189 }
3190 }
3191 }
3192
state_word()3193 void IPTCfgParser::state_word() {
3194
3195 try { // for error handling
3196 {
3197 switch ( LA(1)) {
3198 case INVALID:
3199 {
3200 match(INVALID);
3201 break;
3202 }
3203 case NEW:
3204 {
3205 match(NEW);
3206 break;
3207 }
3208 case ESTABLISHED:
3209 {
3210 match(ESTABLISHED);
3211 break;
3212 }
3213 case RELATED:
3214 {
3215 match(RELATED);
3216 break;
3217 }
3218 default:
3219 {
3220 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3221 }
3222 }
3223 }
3224 }
3225 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3226 if( inputState->guessing == 0 ) {
3227 reportError(ex);
3228 recover(ex,_tokenSet_9);
3229 } else {
3230 throw;
3231 }
3232 }
3233 }
3234
m_mark()3235 void IPTCfgParser::m_mark() {
3236
3237 try { // for error handling
3238 match(M_MARK);
3239 if ( inputState->guessing==0 ) {
3240 #line 723 "iptables.g"
3241
3242 *dbg << " MARK";
3243
3244 #line 3245 "IPTCfgParser.cpp"
3245 }
3246 }
3247 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3248 if( inputState->guessing == 0 ) {
3249 reportError(ex);
3250 recover(ex,_tokenSet_10);
3251 } else {
3252 throw;
3253 }
3254 }
3255 }
3256
limit_rate()3257 void IPTCfgParser::limit_rate() {
3258
3259 try { // for error handling
3260 match(INT_CONST);
3261 if ( inputState->guessing==0 ) {
3262 #line 754 "iptables.g"
3263 importer->limit_val = LT(0)->getText();
3264 #line 3265 "IPTCfgParser.cpp"
3265 }
3266 match(SLASH);
3267 match(WORD);
3268 if ( inputState->guessing==0 ) {
3269 #line 756 "iptables.g"
3270 importer->limit_suffix = LT(0)->getText();
3271 #line 3272 "IPTCfgParser.cpp"
3272 }
3273 if ( inputState->guessing==0 ) {
3274 #line 757 "iptables.g"
3275
3276 *dbg << " MATCH LIMIT "
3277 << importer->limit_val << "/"
3278 << importer->limit_suffix;
3279
3280 #line 3281 "IPTCfgParser.cpp"
3281 }
3282 }
3283 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3284 if( inputState->guessing == 0 ) {
3285 reportError(ex);
3286 recover(ex,_tokenSet_5);
3287 } else {
3288 throw;
3289 }
3290 }
3291 }
3292
m_recent()3293 void IPTCfgParser::m_recent() {
3294
3295 try { // for error handling
3296 match(M_RECENT);
3297 if ( inputState->guessing==0 ) {
3298 #line 774 "iptables.g"
3299
3300 *dbg << " RECENT";
3301
3302 #line 3303 "IPTCfgParser.cpp"
3303 }
3304 }
3305 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3306 if( inputState->guessing == 0 ) {
3307 reportError(ex);
3308 recover(ex,_tokenSet_11);
3309 } else {
3310 throw;
3311 }
3312 }
3313 }
3314
recent_opts()3315 void IPTCfgParser::recent_opts() {
3316
3317 try { // for error handling
3318 switch ( LA(1)) {
3319 case MATCH_RECENT_SET:
3320 case MATCH_RECENT_RCHECK:
3321 case MATCH_RECENT_UPDATE:
3322 case MATCH_RECENT_REMOVE:
3323 case MATCH_RECENT_RTTL:
3324 case RSOURCE:
3325 case MATCH_RECENT_RDEST:
3326 {
3327 recent_args_no_param();
3328 break;
3329 }
3330 case MATCH_RECENT_NAME:
3331 case MATCH_RECENT_SECONDS:
3332 case MATCH_RECENT_HITCOUNT:
3333 {
3334 recent_args_param();
3335 break;
3336 }
3337 default:
3338 {
3339 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3340 }
3341 }
3342 }
3343 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3344 if( inputState->guessing == 0 ) {
3345 reportError(ex);
3346 recover(ex,_tokenSet_12);
3347 } else {
3348 throw;
3349 }
3350 }
3351 }
3352
recent_args_no_param()3353 void IPTCfgParser::recent_args_no_param() {
3354
3355 try { // for error handling
3356 {
3357 switch ( LA(1)) {
3358 case MATCH_RECENT_SET:
3359 {
3360 match(MATCH_RECENT_SET);
3361 break;
3362 }
3363 case MATCH_RECENT_RCHECK:
3364 {
3365 match(MATCH_RECENT_RCHECK);
3366 break;
3367 }
3368 case MATCH_RECENT_UPDATE:
3369 {
3370 match(MATCH_RECENT_UPDATE);
3371 break;
3372 }
3373 case MATCH_RECENT_REMOVE:
3374 {
3375 match(MATCH_RECENT_REMOVE);
3376 break;
3377 }
3378 case MATCH_RECENT_RTTL:
3379 {
3380 match(MATCH_RECENT_RTTL);
3381 break;
3382 }
3383 case RSOURCE:
3384 {
3385 match(RSOURCE);
3386 break;
3387 }
3388 case MATCH_RECENT_RDEST:
3389 {
3390 match(MATCH_RECENT_RDEST);
3391 break;
3392 }
3393 default:
3394 {
3395 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3396 }
3397 }
3398 }
3399 if ( inputState->guessing==0 ) {
3400 #line 826 "iptables.g"
3401 importer->recent_match += LT(0)->getText() + " ";
3402 #line 3403 "IPTCfgParser.cpp"
3403 }
3404 }
3405 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3406 if( inputState->guessing == 0 ) {
3407 reportError(ex);
3408 recover(ex,_tokenSet_12);
3409 } else {
3410 throw;
3411 }
3412 }
3413 }
3414
recent_args_param()3415 void IPTCfgParser::recent_args_param() {
3416
3417 try { // for error handling
3418 {
3419 switch ( LA(1)) {
3420 case MATCH_RECENT_NAME:
3421 {
3422 match(MATCH_RECENT_NAME);
3423 break;
3424 }
3425 case MATCH_RECENT_SECONDS:
3426 {
3427 match(MATCH_RECENT_SECONDS);
3428 break;
3429 }
3430 case MATCH_RECENT_HITCOUNT:
3431 {
3432 match(MATCH_RECENT_HITCOUNT);
3433 break;
3434 }
3435 default:
3436 {
3437 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3438 }
3439 }
3440 }
3441 if ( inputState->guessing==0 ) {
3442 #line 830 "iptables.g"
3443 importer->recent_match += LT(0)->getText() + " ";
3444 #line 3445 "IPTCfgParser.cpp"
3445 }
3446 {
3447 switch ( LA(1)) {
3448 case INT_CONST:
3449 {
3450 match(INT_CONST);
3451 break;
3452 }
3453 case WORD:
3454 {
3455 match(WORD);
3456 break;
3457 }
3458 default:
3459 {
3460 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3461 }
3462 }
3463 }
3464 if ( inputState->guessing==0 ) {
3465 #line 832 "iptables.g"
3466 importer->recent_match += LT(0)->getText() + " ";
3467 #line 3468 "IPTCfgParser.cpp"
3468 }
3469 }
3470 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3471 if( inputState->guessing == 0 ) {
3472 reportError(ex);
3473 recover(ex,_tokenSet_12);
3474 } else {
3475 throw;
3476 }
3477 }
3478 }
3479
length_spec()3480 void IPTCfgParser::length_spec() {
3481
3482 try { // for error handling
3483 match(INT_CONST);
3484 if ( inputState->guessing==0 ) {
3485 #line 849 "iptables.g"
3486 importer->length_spec = LT(0)->getText();
3487 #line 3488 "IPTCfgParser.cpp"
3488 }
3489 match(COLON);
3490 match(INT_CONST);
3491 if ( inputState->guessing==0 ) {
3492 #line 851 "iptables.g"
3493 importer->length_spec += ":";
3494 importer->length_spec += LT(0)->getText();
3495 #line 3496 "IPTCfgParser.cpp"
3496 }
3497 if ( inputState->guessing==0 ) {
3498 #line 853 "iptables.g"
3499
3500 *dbg << " MATCH LENGTH " << importer->length_spec;
3501
3502 #line 3503 "IPTCfgParser.cpp"
3503 }
3504 }
3505 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3506 if( inputState->guessing == 0 ) {
3507 reportError(ex);
3508 recover(ex,_tokenSet_5);
3509 } else {
3510 throw;
3511 }
3512 }
3513 }
3514
pkt_type_spec()3515 void IPTCfgParser::pkt_type_spec() {
3516
3517 try { // for error handling
3518 {
3519 switch ( LA(1)) {
3520 case WORD_BROADCAST:
3521 {
3522 match(WORD_BROADCAST);
3523 break;
3524 }
3525 case WORD_MULTICAST:
3526 {
3527 match(WORD_MULTICAST);
3528 break;
3529 }
3530 case WORD_UNICAST:
3531 {
3532 match(WORD_UNICAST);
3533 break;
3534 }
3535 default:
3536 {
3537 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3538 }
3539 }
3540 }
3541 if ( inputState->guessing==0 ) {
3542 #line 864 "iptables.g"
3543
3544 importer->pkt_type_spec = LT(0)->getText();
3545 *dbg << " PKT_TYPE " << importer->pkt_type_spec;
3546
3547 #line 3548 "IPTCfgParser.cpp"
3548 }
3549 }
3550 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3551 if( inputState->guessing == 0 ) {
3552 reportError(ex);
3553 recover(ex,_tokenSet_5);
3554 } else {
3555 throw;
3556 }
3557 }
3558 }
3559
3560 /****************************************************************
3561 * port definition that allows for port range. That parser should
3562 * recognize constructs
3563 *
3564 * port1 ---> range_start = range_end = port1
3565 * port1:port2 ---> range_start = port1 range_end = port2
3566 * port1: ---> range_start = port1 range_end = 65535
3567 * :port2 ---> range_start = 0 range_end = port2
3568 */
port_def_with_range()3569 void IPTCfgParser::port_def_with_range() {
3570
3571 try { // for error handling
3572 {
3573 switch ( LA(1)) {
3574 case WORD:
3575 {
3576 match(WORD);
3577 break;
3578 }
3579 case INT_CONST:
3580 {
3581 match(INT_CONST);
3582 break;
3583 }
3584 default:
3585 {
3586 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3587 }
3588 }
3589 }
3590 if ( inputState->guessing==0 ) {
3591 #line 1014 "iptables.g"
3592
3593 importer->tmp_port_range_start = LT(0)->getText();
3594 importer->tmp_port_range_end = LT(0)->getText();
3595 *dbg << " PORT=" << LT(0)->getText();
3596
3597 #line 3598 "IPTCfgParser.cpp"
3598 }
3599 {
3600 switch ( LA(1)) {
3601 case COLON:
3602 {
3603 match(COLON);
3604 {
3605 switch ( LA(1)) {
3606 case WORD:
3607 {
3608 match(WORD);
3609 break;
3610 }
3611 case INT_CONST:
3612 {
3613 match(INT_CONST);
3614 break;
3615 }
3616 case NEWLINE:
3617 case MINUS:
3618 case EXCLAMATION:
3619 case UNSUPPORTED_OPTION:
3620 case OPT_MODULE:
3621 case OPT_SRC:
3622 case OPT_DST:
3623 case OPT_IN_INTF:
3624 case OPT_OUT_INTF:
3625 case OPT_PROTO:
3626 case OPT_TARGET:
3627 case OPT_FRAGM:
3628 case COMMA:
3629 case MATCH_LIMIT:
3630 case MATCH_LIMIT_BURST:
3631 case MATCH_IPRANGE_SRC:
3632 case MATCH_IPRANGE_DST:
3633 case MATCH_LENGTH:
3634 case MATCH_SRC_MULTIPORT:
3635 case MATCH_DST_MULTIPORT:
3636 case MATCH_BOTH_MULTIPORT:
3637 case MATCH_ICMP_TYPE:
3638 case MATCH_SRC_PORT:
3639 case MATCH_SRC_PORT_SHORT:
3640 case MATCH_DST_PORT:
3641 case MATCH_DST_PORT_SHORT:
3642 case MATCH_SYN:
3643 case MATCH_TCP_FLAGS:
3644 case MATCH_TCP_OPTION:
3645 {
3646 break;
3647 }
3648 default:
3649 {
3650 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3651 }
3652 }
3653 }
3654 if ( inputState->guessing==0 ) {
3655 #line 1021 "iptables.g"
3656
3657 importer->tmp_port_range_end = LT(0)->getText();
3658 *dbg << ":" << LT(0)->getText();
3659
3660 #line 3661 "IPTCfgParser.cpp"
3661 }
3662 break;
3663 }
3664 case NEWLINE:
3665 case MINUS:
3666 case EXCLAMATION:
3667 case UNSUPPORTED_OPTION:
3668 case OPT_MODULE:
3669 case OPT_SRC:
3670 case OPT_DST:
3671 case OPT_IN_INTF:
3672 case OPT_OUT_INTF:
3673 case OPT_PROTO:
3674 case OPT_TARGET:
3675 case OPT_FRAGM:
3676 case COMMA:
3677 case MATCH_LIMIT:
3678 case MATCH_LIMIT_BURST:
3679 case MATCH_IPRANGE_SRC:
3680 case MATCH_IPRANGE_DST:
3681 case MATCH_LENGTH:
3682 case MATCH_SRC_MULTIPORT:
3683 case MATCH_DST_MULTIPORT:
3684 case MATCH_BOTH_MULTIPORT:
3685 case MATCH_ICMP_TYPE:
3686 case MATCH_SRC_PORT:
3687 case MATCH_SRC_PORT_SHORT:
3688 case MATCH_DST_PORT:
3689 case MATCH_DST_PORT_SHORT:
3690 case MATCH_SYN:
3691 case MATCH_TCP_FLAGS:
3692 case MATCH_TCP_OPTION:
3693 {
3694 break;
3695 }
3696 default:
3697 {
3698 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3699 }
3700 }
3701 }
3702 }
3703 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3704 if( inputState->guessing == 0 ) {
3705 reportError(ex);
3706 recover(ex,_tokenSet_9);
3707 } else {
3708 throw;
3709 }
3710 }
3711 }
3712
port_def_no_range()3713 void IPTCfgParser::port_def_no_range() {
3714
3715 try { // for error handling
3716 {
3717 switch ( LA(1)) {
3718 case WORD:
3719 {
3720 match(WORD);
3721 break;
3722 }
3723 case INT_CONST:
3724 {
3725 match(INT_CONST);
3726 break;
3727 }
3728 default:
3729 {
3730 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3731 }
3732 }
3733 }
3734 if ( inputState->guessing==0 ) {
3735 #line 996 "iptables.g"
3736
3737 importer->tmp_port_range_start = LT(0)->getText();
3738 importer->tmp_port_range_end = LT(0)->getText();
3739 *dbg << " PORT=" << LT(0)->getText();
3740
3741 #line 3742 "IPTCfgParser.cpp"
3742 }
3743 }
3744 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3745 if( inputState->guessing == 0 ) {
3746 reportError(ex);
3747 recover(ex,_tokenSet_0);
3748 } else {
3749 throw;
3750 }
3751 }
3752 }
3753
port_def_with_incomplete_range()3754 void IPTCfgParser::port_def_with_incomplete_range() {
3755
3756 try { // for error handling
3757 match(COLON);
3758 {
3759 switch ( LA(1)) {
3760 case WORD:
3761 {
3762 match(WORD);
3763 break;
3764 }
3765 case INT_CONST:
3766 {
3767 match(INT_CONST);
3768 break;
3769 }
3770 default:
3771 {
3772 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3773 }
3774 }
3775 }
3776 if ( inputState->guessing==0 ) {
3777 #line 1030 "iptables.g"
3778
3779 importer->tmp_port_range_start = "0";
3780 importer->tmp_port_range_end = LT(0)->getText();
3781 *dbg << "PORT 0:" << LT(0)->getText();
3782
3783 #line 3784 "IPTCfgParser.cpp"
3784 }
3785 }
3786 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3787 if( inputState->guessing == 0 ) {
3788 reportError(ex);
3789 recover(ex,_tokenSet_5);
3790 } else {
3791 throw;
3792 }
3793 }
3794 }
3795
syn()3796 void IPTCfgParser::syn() {
3797
3798 try { // for error handling
3799 match(MATCH_SYN);
3800 if ( inputState->guessing==0 ) {
3801 #line 1118 "iptables.g"
3802
3803 importer->tcp_flags_mask.clear();
3804 importer->tcp_flags_mask.push_back(libfwbuilder::TCPService::SYN);
3805 importer->tcp_flags_mask.push_back(libfwbuilder::TCPService::RST);
3806 importer->tcp_flags_mask.push_back(libfwbuilder::TCPService::ACK);
3807
3808 importer->tcp_flags_comp.clear();
3809 importer->tcp_flags_comp.push_back(libfwbuilder::TCPService::SYN);
3810
3811 #line 3812 "IPTCfgParser.cpp"
3812 }
3813 }
3814 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3815 if( inputState->guessing == 0 ) {
3816 reportError(ex);
3817 recover(ex,_tokenSet_5);
3818 } else {
3819 throw;
3820 }
3821 }
3822 }
3823
tcp_flags()3824 void IPTCfgParser::tcp_flags() {
3825
3826 try { // for error handling
3827 match(MATCH_TCP_FLAGS);
3828 tcp_flags_list();
3829 if ( inputState->guessing==0 ) {
3830 #line 1169 "iptables.g"
3831
3832 importer->tcp_flags_mask = importer->tmp_tcp_flags_list;
3833 importer->tmp_tcp_flags_list.clear();
3834
3835 #line 3836 "IPTCfgParser.cpp"
3836 }
3837 tcp_flags_list();
3838 if ( inputState->guessing==0 ) {
3839 #line 1174 "iptables.g"
3840
3841 importer->tcp_flags_comp = importer->tmp_tcp_flags_list;
3842 importer->tmp_tcp_flags_list.clear();
3843 *dbg << " TCP FLAGS=";
3844 foreach(int x, importer->tcp_flags_mask)
3845 *dbg << x << "|";
3846 *dbg << " ";
3847 foreach(int x, importer->tcp_flags_comp)
3848 *dbg << x << "|";
3849
3850 #line 3851 "IPTCfgParser.cpp"
3851 }
3852 }
3853 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3854 if( inputState->guessing == 0 ) {
3855 reportError(ex);
3856 recover(ex,_tokenSet_5);
3857 } else {
3858 throw;
3859 }
3860 }
3861 }
3862
tcp_option()3863 void IPTCfgParser::tcp_option() {
3864
3865 try { // for error handling
3866 match(MATCH_TCP_OPTION);
3867 match(INT_CONST);
3868 }
3869 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3870 if( inputState->guessing == 0 ) {
3871 reportError(ex);
3872 recover(ex,_tokenSet_5);
3873 } else {
3874 throw;
3875 }
3876 }
3877 }
3878
tcp_flag_word()3879 void IPTCfgParser::tcp_flag_word() {
3880
3881 try { // for error handling
3882 {
3883 switch ( LA(1)) {
3884 case SYN:
3885 {
3886 match(SYN);
3887 if ( inputState->guessing==0 ) {
3888 #line 1131 "iptables.g"
3889 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::SYN;
3890 #line 3891 "IPTCfgParser.cpp"
3891 }
3892 break;
3893 }
3894 case ACK:
3895 {
3896 match(ACK);
3897 if ( inputState->guessing==0 ) {
3898 #line 1133 "iptables.g"
3899 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::ACK;
3900 #line 3901 "IPTCfgParser.cpp"
3901 }
3902 break;
3903 }
3904 case FIN:
3905 {
3906 match(FIN);
3907 if ( inputState->guessing==0 ) {
3908 #line 1135 "iptables.g"
3909 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::FIN;
3910 #line 3911 "IPTCfgParser.cpp"
3911 }
3912 break;
3913 }
3914 case RST:
3915 {
3916 match(RST);
3917 if ( inputState->guessing==0 ) {
3918 #line 1137 "iptables.g"
3919 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::RST;
3920 #line 3921 "IPTCfgParser.cpp"
3921 }
3922 break;
3923 }
3924 case URG:
3925 {
3926 match(URG);
3927 if ( inputState->guessing==0 ) {
3928 #line 1139 "iptables.g"
3929 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::URG;
3930 #line 3931 "IPTCfgParser.cpp"
3931 }
3932 break;
3933 }
3934 case PSH:
3935 {
3936 match(PSH);
3937 if ( inputState->guessing==0 ) {
3938 #line 1141 "iptables.g"
3939 importer->tmp_tcp_flag_code = libfwbuilder::TCPService::PSH;
3940 #line 3941 "IPTCfgParser.cpp"
3941 }
3942 break;
3943 }
3944 case ALL:
3945 {
3946 match(ALL);
3947 if ( inputState->guessing==0 ) {
3948 #line 1143 "iptables.g"
3949 importer->tmp_tcp_flag_code = 99;
3950 #line 3951 "IPTCfgParser.cpp"
3951 }
3952 break;
3953 }
3954 case NONE:
3955 {
3956 match(NONE);
3957 if ( inputState->guessing==0 ) {
3958 #line 1145 "iptables.g"
3959 importer->tmp_tcp_flag_code = 98;
3960 #line 3961 "IPTCfgParser.cpp"
3961 }
3962 break;
3963 }
3964 default:
3965 {
3966 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
3967 }
3968 }
3969 }
3970 }
3971 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
3972 if( inputState->guessing == 0 ) {
3973 reportError(ex);
3974 recover(ex,_tokenSet_13);
3975 } else {
3976 throw;
3977 }
3978 }
3979 }
3980
tcp_flags_list()3981 void IPTCfgParser::tcp_flags_list() {
3982
3983 try { // for error handling
3984 if ( inputState->guessing==0 ) {
3985 #line 1150 "iptables.g"
3986
3987 importer->tmp_tcp_flags_list.clear();
3988 importer->tmp_tcp_flag_code = 0;
3989
3990 #line 3991 "IPTCfgParser.cpp"
3991 }
3992 tcp_flag_word();
3993 if ( inputState->guessing==0 ) {
3994 #line 1155 "iptables.g"
3995
3996 importer->tmp_tcp_flags_list.push_back(importer->tmp_tcp_flag_code);
3997
3998 #line 3999 "IPTCfgParser.cpp"
3999 }
4000 { // ( ... )*
4001 for (;;) {
4002 if ((LA(1) == COMMA)) {
4003 match(COMMA);
4004 tcp_flag_word();
4005 if ( inputState->guessing==0 ) {
4006 #line 1160 "iptables.g"
4007
4008 importer->tmp_tcp_flags_list.push_back(
4009 importer->tmp_tcp_flag_code);
4010
4011 #line 4012 "IPTCfgParser.cpp"
4012 }
4013 }
4014 else {
4015 goto _loop156;
4016 }
4017
4018 }
4019 _loop156:;
4020 } // ( ... )*
4021 }
4022 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
4023 if( inputState->guessing == 0 ) {
4024 reportError(ex);
4025 recover(ex,_tokenSet_14);
4026 } else {
4027 throw;
4028 }
4029 }
4030 }
4031
initializeASTFactory(ANTLR_USE_NAMESPACE (antlr)ASTFactory &)4032 void IPTCfgParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
4033 {
4034 }
4035 const char* IPTCfgParser::tokenNames[] = {
4036 "<0>",
4037 "EOF",
4038 "<2>",
4039 "NULL_TREE_LOOKAHEAD",
4040 "NEWLINE",
4041 "NUMBER_SIGN",
4042 "IPTABLES_SAVE_HEADER",
4043 "THREE_COMPONENT_VERSION",
4044 "IPV4",
4045 "\"COMMIT\"",
4046 "STAR",
4047 "WORD",
4048 "\"INPUT\"",
4049 "\"FORWARD\"",
4050 "\"OUTPUT\"",
4051 "\"PREROUTING\"",
4052 "\"POSTROUTING\"",
4053 "COLON",
4054 "MINUS",
4055 "OPENING_SQUARE",
4056 "INT_CONST",
4057 "CLOSING_SQUARE",
4058 "ADD_RULE",
4059 "EXCLAMATION",
4060 "UNSUPPORTED_OPTION",
4061 "DIGIT",
4062 "SLASH",
4063 "OPT_MODULE",
4064 "OPT_SRC",
4065 "OPT_DST",
4066 "OPT_IN_INTF",
4067 "OPT_OUT_INTF",
4068 "\"tcp\"",
4069 "\"udp\"",
4070 "\"icmp\"",
4071 "OPT_PROTO",
4072 "OPT_TARGET",
4073 "REJECT_WITH",
4074 "LOG_PREFIX",
4075 "STRING",
4076 "LOG_TCP_SEQ",
4077 "LOG_TCP_OPT",
4078 "LOG_IP_OPT",
4079 "ULOG_PREFIX",
4080 "LOG_LEVEL",
4081 "SET_CLASS",
4082 "SET_MARK",
4083 "HEX_CONST",
4084 "SET_TOS",
4085 "SAVE_MARK",
4086 "RESTORE_MARK",
4087 "CONTINUE",
4088 "ROUTE_IIF",
4089 "ROUTE_OIF",
4090 "ROUTE_GW",
4091 "ROUTE_TEE",
4092 "TO_SOURCE",
4093 "TO_DESTINATION",
4094 "TO_PORTS",
4095 "TO_NETMAP",
4096 "CLAMP_MSS",
4097 "OPT_FRAGM",
4098 "\"INVALID\"",
4099 "\"NEW\"",
4100 "\"ESTABLISHED\"",
4101 "\"RELATED\"",
4102 "\"state\"",
4103 "MATCH_STATE",
4104 "COMMA",
4105 "\"mark\"",
4106 "MATCH_MARK",
4107 "\"limit\"",
4108 "MATCH_LIMIT",
4109 "MATCH_LIMIT_BURST",
4110 "\"recent\"",
4111 "\"iprange\"",
4112 "MATCH_IPRANGE_SRC",
4113 "MATCH_IPRANGE_DST",
4114 "MATCH_RECENT_SET",
4115 "MATCH_RECENT_RCHECK",
4116 "MATCH_RECENT_UPDATE",
4117 "MATCH_RECENT_REMOVE",
4118 "MATCH_RECENT_RTTL",
4119 "RSOURCE",
4120 "MATCH_RECENT_RDEST",
4121 "MATCH_RECENT_NAME",
4122 "MATCH_RECENT_SECONDS",
4123 "MATCH_RECENT_HITCOUNT",
4124 "\"length\"",
4125 "MATCH_LENGTH",
4126 "\"pkttype\"",
4127 "MATCH_PKT_TYPE",
4128 "\"broadcast\"",
4129 "\"multicast\"",
4130 "\"unicast\"",
4131 "\"multiport\"",
4132 "\"comment\"",
4133 "MATCH_COMMENT",
4134 "MATCH_SRC_MULTIPORT",
4135 "MATCH_DST_MULTIPORT",
4136 "MATCH_BOTH_MULTIPORT",
4137 "MATCH_ICMP_TYPE",
4138 "MATCH_SRC_PORT",
4139 "MATCH_SRC_PORT_SHORT",
4140 "MATCH_DST_PORT",
4141 "MATCH_DST_PORT_SHORT",
4142 "MATCH_SYN",
4143 "\"SYN\"",
4144 "\"ACK\"",
4145 "\"FIN\"",
4146 "\"RST\"",
4147 "\"URG\"",
4148 "\"PSH\"",
4149 "\"ALL\"",
4150 "\"NONE\"",
4151 "MATCH_TCP_FLAGS",
4152 "MATCH_TCP_OPTION",
4153 "Whitespace",
4154 "IPV6",
4155 "MAC_ADDRESS",
4156 "NEG_INT_CONST",
4157 "HEXDIGIT",
4158 "NUM_3DIGIT",
4159 "NUM_HEX_4DIGIT",
4160 "NUMBER",
4161 "ULOG_QTHR",
4162 "ULOG_NLG",
4163 "ULOG_CPR",
4164 "PERCENT",
4165 "AMPERSAND",
4166 "APOSTROPHE",
4167 "OPENING_PAREN",
4168 "CLOSING_PAREN",
4169 "PLUS",
4170 "DOT",
4171 "SEMICOLON",
4172 "LESS_THAN",
4173 "EQUALS",
4174 "GREATER_THAN",
4175 "QUESTION",
4176 "COMMERCIAL_AT",
4177 "CARET",
4178 "UNDERLINE",
4179 "OPENING_BRACE",
4180 "CLOSING_BRACE",
4181 "TILDE",
4182 0
4183 };
4184
4185 const unsigned long IPTCfgParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL };
4186 // EOF
4187 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_0(_tokenSet_0_data_,6);
4188 const unsigned long IPTCfgParser::_tokenSet_1_data_[] = { 4326962UL, 0UL, 0UL, 0UL, 0UL, 0UL };
4189 // EOF NEWLINE NUMBER_SIGN "COMMIT" STAR COLON ADD_RULE
4190 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_1(_tokenSet_1_data_,6);
4191 const unsigned long IPTCfgParser::_tokenSet_2_data_[] = { 4186177536UL, 536870936UL, 33567488UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4192 // MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST OPT_IN_INTF
4193 // OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM MATCH_LIMIT MATCH_LIMIT_BURST
4194 // MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4195 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4196 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN MATCH_TCP_FLAGS
4197 // MATCH_TCP_OPTION
4198 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_2(_tokenSet_2_data_,8);
4199 const unsigned long IPTCfgParser::_tokenSet_3_data_[] = { 4186179584UL, 536870936UL, 33567488UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4200 // WORD MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4201 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM MATCH_LIMIT
4202 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4203 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4204 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN MATCH_TCP_FLAGS
4205 // MATCH_TCP_OPTION
4206 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_3(_tokenSet_3_data_,8);
4207 const unsigned long IPTCfgParser::_tokenSet_4_data_[] = { 2048UL, 7UL, 2231371908UL, 1UL, 0UL, 0UL, 0UL, 0UL };
4208 // WORD "tcp" "udp" "icmp" "state" "limit" "iprange" "length" "pkttype"
4209 // "multiport" "comment"
4210 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_4(_tokenSet_4_data_,8);
4211 const unsigned long IPTCfgParser::_tokenSet_5_data_[] = { 4186177552UL, 536870936UL, 33567488UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4212 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4213 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM MATCH_LIMIT
4214 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4215 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4216 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN MATCH_TCP_FLAGS
4217 // MATCH_TCP_OPTION
4218 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_5(_tokenSet_5_data_,8);
4219 const unsigned long IPTCfgParser::_tokenSet_6_data_[] = { 0UL, 536837984UL, 0UL, 0UL, 0UL, 0UL };
4220 // REJECT_WITH LOG_PREFIX LOG_TCP_SEQ LOG_TCP_OPT LOG_IP_OPT ULOG_PREFIX
4221 // LOG_LEVEL SET_CLASS SET_MARK SET_TOS SAVE_MARK RESTORE_MARK CONTINUE
4222 // ROUTE_IIF ROUTE_OIF ROUTE_GW ROUTE_TEE TO_SOURCE TO_DESTINATION TO_PORTS
4223 // TO_NETMAP CLAMP_MSS
4224 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_6(_tokenSet_6_data_,6);
4225 const unsigned long IPTCfgParser::_tokenSet_7_data_[] = { 4186177552UL, 1073708920UL, 33567488UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4226 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4227 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET REJECT_WITH LOG_PREFIX
4228 // LOG_TCP_SEQ LOG_TCP_OPT LOG_IP_OPT ULOG_PREFIX LOG_LEVEL SET_CLASS SET_MARK
4229 // SET_TOS SAVE_MARK RESTORE_MARK CONTINUE ROUTE_IIF ROUTE_OIF ROUTE_GW
4230 // ROUTE_TEE TO_SOURCE TO_DESTINATION TO_PORTS TO_NETMAP CLAMP_MSS OPT_FRAGM
4231 // MATCH_LIMIT MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH
4232 // MATCH_SRC_MULTIPORT MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE
4233 // MATCH_SRC_PORT MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT
4234 // MATCH_SYN MATCH_TCP_FLAGS MATCH_TCP_OPTION
4235 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_7(_tokenSet_7_data_,8);
4236 const unsigned long IPTCfgParser::_tokenSet_8_data_[] = { 4186308624UL, 1073708920UL, 33567488UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4237 // NEWLINE COLON MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC
4238 // OPT_DST OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET REJECT_WITH LOG_PREFIX
4239 // LOG_TCP_SEQ LOG_TCP_OPT LOG_IP_OPT ULOG_PREFIX LOG_LEVEL SET_CLASS SET_MARK
4240 // SET_TOS SAVE_MARK RESTORE_MARK CONTINUE ROUTE_IIF ROUTE_OIF ROUTE_GW
4241 // ROUTE_TEE TO_SOURCE TO_DESTINATION TO_PORTS TO_NETMAP CLAMP_MSS OPT_FRAGM
4242 // MATCH_LIMIT MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH
4243 // MATCH_SRC_MULTIPORT MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE
4244 // MATCH_SRC_PORT MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT
4245 // MATCH_SYN MATCH_TCP_FLAGS MATCH_TCP_OPTION
4246 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_8(_tokenSet_8_data_,8);
4247 const unsigned long IPTCfgParser::_tokenSet_9_data_[] = { 4186177552UL, 536870936UL, 33567504UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4248 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4249 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM COMMA MATCH_LIMIT
4250 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4251 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4252 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN MATCH_TCP_FLAGS
4253 // MATCH_TCP_OPTION
4254 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_9(_tokenSet_9_data_,8);
4255 const unsigned long IPTCfgParser::_tokenSet_10_data_[] = { 8388608UL, 0UL, 64UL, 0UL, 0UL, 0UL, 0UL, 0UL };
4256 // EXCLAMATION MATCH_MARK
4257 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_10(_tokenSet_10_data_,8);
4258 const unsigned long IPTCfgParser::_tokenSet_11_data_[] = { 0UL, 0UL, 16760832UL, 0UL, 0UL, 0UL, 0UL, 0UL };
4259 // MATCH_RECENT_SET MATCH_RECENT_RCHECK MATCH_RECENT_UPDATE MATCH_RECENT_REMOVE
4260 // MATCH_RECENT_RTTL RSOURCE MATCH_RECENT_RDEST MATCH_RECENT_NAME MATCH_RECENT_SECONDS
4261 // MATCH_RECENT_HITCOUNT
4262 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_11(_tokenSet_11_data_,8);
4263 const unsigned long IPTCfgParser::_tokenSet_12_data_[] = { 4186177552UL, 536870936UL, 50328320UL, 1574908UL, 0UL, 0UL, 0UL, 0UL };
4264 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4265 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM MATCH_LIMIT
4266 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_RECENT_SET
4267 // MATCH_RECENT_RCHECK MATCH_RECENT_UPDATE MATCH_RECENT_REMOVE MATCH_RECENT_RTTL
4268 // RSOURCE MATCH_RECENT_RDEST MATCH_RECENT_NAME MATCH_RECENT_SECONDS MATCH_RECENT_HITCOUNT
4269 // MATCH_LENGTH MATCH_SRC_MULTIPORT MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT
4270 // MATCH_ICMP_TYPE MATCH_SRC_PORT MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT
4271 // MATCH_SYN MATCH_TCP_FLAGS MATCH_TCP_OPTION
4272 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_12(_tokenSet_12_data_,8);
4273 const unsigned long IPTCfgParser::_tokenSet_13_data_[] = { 4186177552UL, 536870936UL, 33567504UL, 2097148UL, 0UL, 0UL, 0UL, 0UL };
4274 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4275 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM COMMA MATCH_LIMIT
4276 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4277 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4278 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN "SYN"
4279 // "ACK" "FIN" "RST" "URG" "PSH" "ALL" "NONE" MATCH_TCP_FLAGS MATCH_TCP_OPTION
4280 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_13(_tokenSet_13_data_,8);
4281 const unsigned long IPTCfgParser::_tokenSet_14_data_[] = { 4186177552UL, 536870936UL, 33567488UL, 2097148UL, 0UL, 0UL, 0UL, 0UL };
4282 // NEWLINE MINUS EXCLAMATION UNSUPPORTED_OPTION OPT_MODULE OPT_SRC OPT_DST
4283 // OPT_IN_INTF OPT_OUT_INTF OPT_PROTO OPT_TARGET OPT_FRAGM MATCH_LIMIT
4284 // MATCH_LIMIT_BURST MATCH_IPRANGE_SRC MATCH_IPRANGE_DST MATCH_LENGTH MATCH_SRC_MULTIPORT
4285 // MATCH_DST_MULTIPORT MATCH_BOTH_MULTIPORT MATCH_ICMP_TYPE MATCH_SRC_PORT
4286 // MATCH_SRC_PORT_SHORT MATCH_DST_PORT MATCH_DST_PORT_SHORT MATCH_SYN "SYN"
4287 // "ACK" "FIN" "RST" "URG" "PSH" "ALL" "NONE" MATCH_TCP_FLAGS MATCH_TCP_OPTION
4288 const ANTLR_USE_NAMESPACE(antlr)BitSet IPTCfgParser::_tokenSet_14(_tokenSet_14_data_,8);
4289
4290
4291