├── compiler ├── netcl-compile ├── README.md ├── Makefile ├── netcl_rules ├── templates │ └── table_2_template.py ├── netcl.l ├── compiled_rules ├── netcl.tab.h ├── netcl.y ├── netcl.tab.c └── lex.yy.c ├── custom-recieve.py ├── custom-send.py ├── switch ├── netcl.py ├── controller.py └── p4control.p4 ├── host_agent ├── host_agent.py └── host_agent_ebpf.c └── README.md /compiler/netcl-compile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/peng-gao-lab/p4control/HEAD/compiler/netcl-compile -------------------------------------------------------------------------------- /compiler/README.md: -------------------------------------------------------------------------------- 1 | # Rebuild NetCL Compiler 2 | 3 | To rebuild the NetCL compiler after modifying its code, execute the following 4 | ``` 5 | make clean 6 | make netcl 7 | ``` 8 | -------------------------------------------------------------------------------- /compiler/Makefile: -------------------------------------------------------------------------------- 1 | netcl: 2 | bison -d netcl.y 3 | flex netcl.l 4 | g++ netcl.tab.c lex.yy.c -ll -o ./netcl-compile --std=c++0x 5 | 6 | clean: 7 | rm -rf netcl.tab.c netcl.tab.h lex.yy.c 8 | rm -rf netcl-compile netcl 9 | -------------------------------------------------------------------------------- /compiler/netcl_rules: -------------------------------------------------------------------------------- 1 | if match(pktlabel contains 0x01 && IP == "10.0.0.3") then drop 2 | 3 | if match(pktlabel contains 0x02 && IP == "10.0.0.3") then allow 4 | 5 | if match(pktlabel contains 0x01 && IP == "10.0.0.2") then allow 6 | 7 | if match(pktlabel contains 0x02 && IP == "10.0.0.1") then allow -------------------------------------------------------------------------------- /compiler/templates/table_2_template.py: -------------------------------------------------------------------------------- 1 | # table_action3 label -> dst_address 2 | dst_ip_addr = struct.unpack("!L", socket.inet_aton(DST_IP))[0] 3 | tag_label = LABEL 4 | decision = DEC 5 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',tag_label, tag_label), 6 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 7 | data = table_action.make_data([gc.DataTuple('priority', 1), 8 | gc.DataTuple('decision', decision)], 'SwitchIngress.table_action3') 9 | table_action.entry_add(target, [key], [data]) 10 | 11 | # ======================================================== -------------------------------------------------------------------------------- /compiler/netcl.l: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | #define YY_DECL extern "C" int yylex() 11 | 12 | #include "netcl.tab.h" 13 | // support tags 0-Alice 1-Bob 2-Sales 3-Dev 14 | %} 15 | %% 16 | "//".* {/* comment */ } 17 | if { return IF; } 18 | then { return THEN; } 19 | drop { return DROP; } 20 | alice { return ALICE; } 21 | bob { return BOB; } 22 | sales { return SALES; } 23 | dev { return DEV; } 24 | modify { return MODIFYTTL; } 25 | fwd { return FWD; } 26 | reroute { return REROUTE; } 27 | match { return MATCH; } 28 | contains { return CONTAINS; } 29 | "(" { return LP; } 30 | ")" { return RP; } 31 | "==" { return EQ; } 32 | "&&" { return AND; } 33 | [ \t\n] ; 34 | "\""[0-9.]+"\"" { yylval.sval = strdup(yytext); return IP; } 35 | [0-9]+ { yylval.ival = atoi(yytext); return CONST; } 36 | [a-zA-Z0-9]+ { 37 | yylval.sval = strdup(yytext); 38 | return VAR; 39 | } 40 | . ; 41 | %% 42 | -------------------------------------------------------------------------------- /custom-recieve.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import sys 3 | import struct 4 | import os 5 | import re 6 | from scapy.all import sniff, sendp, hexdump, get_if_list, get_if_hwaddr 7 | from scapy.all import Packet, IPOption 8 | from scapy.all import ShortField, IntField, LongField, BitField, FieldListField, FieldLenField 9 | from scapy.all import IP, TCP, UDP, Raw 10 | from scapy.all import bind_layers 11 | from scapy.layers.inet import _IPOption_HDR 12 | 13 | class p4control(Packet): 14 | name = "p4control" 15 | fields_desc = [BitField("label", 0, 64), BitField("tracker", 0, 64)] 16 | 17 | bind_layers(TCP, p4control) 18 | 19 | # Update with your interface 20 | def get_if(): 21 | ifs=get_if_list() 22 | iface=None # "h1-eth0" 23 | for i in get_if_list(): 24 | if re.search("veth.", i): 25 | iface=i 26 | break; 27 | if not iface: 28 | print("Cannot find veth interface") 29 | exit(1) 30 | return iface 31 | 32 | def handle_pkt(pkt): 33 | if TCP in pkt and pkt[TCP].dport == 1234: 34 | print("got a packet") 35 | pkt.show2() 36 | # hexdump(pkt) 37 | sys.stdout.flush() 38 | 39 | 40 | def main(): 41 | ifaces = [i for i in os.listdir('/sys/class/net/') if 'veth' in i] 42 | iface = ifaces[0] 43 | print(("sniffing on %s, port 1234" % iface)) 44 | sys.stdout.flush() 45 | sniff(iface = iface, 46 | prn = lambda x: handle_pkt(x)) 47 | 48 | if __name__ == '__main__': 49 | main() -------------------------------------------------------------------------------- /custom-send.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import argparse 3 | import sys 4 | import socket 5 | import random 6 | import struct 7 | import re 8 | import binascii 9 | from scapy.all import sendp, send, get_if_list, get_if_hwaddr 10 | from scapy.all import Packet 11 | from scapy.all import Ether, IntField, ShortField, LongField, BitField, IP, UDP, TCP, Raw 12 | from scapy.all import bind_layers 13 | 14 | class p4control(Packet): 15 | name = "p4control" 16 | fields_desc = [BitField("label", 0, 64), BitField("tracker", 0, 64)] 17 | 18 | bind_layers(TCP, p4control) 19 | 20 | # Update with your interface 21 | def get_if(): 22 | ifs=get_if_list() 23 | iface=None # "h1-eth0" 24 | for i in get_if_list(): 25 | if re.search("veth.", i): 26 | iface=i 27 | break; 28 | if not iface: 29 | print("Cannot find veth interface") 30 | exit(1) 31 | return iface 32 | 33 | def main(): 34 | 35 | if len(sys.argv)<4: 36 | print('pass 4 arguments: ""') 37 | exit(1) 38 | 39 | addr = socket.gethostbyname(sys.argv[1]) 40 | iface = get_if() 41 | 42 | # hex_value = int(sys.argv[2]) 43 | label_tag = int(sys.argv[2]) 44 | id_tag = int(sys.argv[3]) 45 | 46 | print(("sending on interface %s to %s" % (iface, str(addr)))) 47 | pkt = Ether(src=get_if_hwaddr(iface), dst='ff:ff:ff:ff:ff:ff') 48 | pkt = pkt /IP(dst=addr, flags='evil') / TCP(dport=1234, sport=49153)/ p4control(trust=label_tag, id = id_tag) / sys.argv[4] 49 | pkt.show2() 50 | sendp(pkt, iface=iface, verbose=False) 51 | 52 | 53 | if __name__ == '__main__': 54 | main() 55 | -------------------------------------------------------------------------------- /switch/netcl.py: -------------------------------------------------------------------------------- 1 | def insert_rules: 2 | # ========================================================= 3 | # table_action2 Declassification 4 | 5 | # Define the key 6 | src_ip_addr = 0x0a000002 7 | dst_ip_addr = 0x0a000003 8 | key = table_action2.make_key([gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr), 9 | gc.KeyTuple('hdr.ipv4.src_addr',src_ip_addr)]) 10 | data = table_action2.make_data([gc.DataTuple('priority', 9), 11 | gc.DataTuple('decision', 0), 12 | gc.DataTuple('declassify_label', 0xFE)], 'SwitchIngress.table_action2') 13 | table_action2.entry_add(target, [key], [data]) 14 | 15 | 16 | # ======================================================== 17 | # table_action3 label -> dst_address 18 | dst_ip_addr = struct.unpack("!L", socket.inet_aton("10.0.0.3"))[0] 19 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',0x01, 0x01), 20 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 21 | data = table_action3.make_data([gc.DataTuple('priority', 1), 22 | gc.DataTuple('decision', 2)], 'SwitchIngress.table_action3') 23 | table_action3.entry_add(target, [key], [data]) 24 | 25 | # ======================================================== 26 | # table_action4 27 | key = table_action4.make_key([gc.KeyTuple('hdr.ipv4.dst_addr',0x0a000003), 28 | gc.KeyTuple('hdr.flowtag_id.tag_id',1)]) 29 | data = table_action4.make_data([gc.DataTuple('priority', 5), 30 | gc.DataTuple('decision', 2)], 'SwitchIngress.table_action4') 31 | table_action4.entry_add(target, [key], [data]) 32 | 33 | # ======================================================== -------------------------------------------------------------------------------- /compiler/compiled_rules: -------------------------------------------------------------------------------- 1 | # table_action3 label -> dst_address 2 | dst_ip_addr = struct.unpack("!L", socket.inet_aton("10.0.0.3"))[0] 3 | tag_label = 0x01 4 | decision = 1 5 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',tag_label, tag_label), 6 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 7 | data = table_action.make_data([gc.DataTuple('priority', 1), 8 | gc.DataTuple('decision', decision)], 'SwitchIngress.table_action3') 9 | table_action.entry_add(target, [key], [data]) 10 | 11 | # ======================================================== 12 | 13 | # table_action3 label -> dst_address 14 | dst_ip_addr = struct.unpack("!L", socket.inet_aton("10.0.0.3"))[0] 15 | tag_label = 0x02 16 | decision = 0 17 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',tag_label, tag_label), 18 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 19 | data = table_action.make_data([gc.DataTuple('priority', 1), 20 | gc.DataTuple('decision', decision)], 'SwitchIngress.table_action3') 21 | table_action.entry_add(target, [key], [data]) 22 | 23 | # ======================================================== 24 | 25 | # table_action3 label -> dst_address 26 | dst_ip_addr = struct.unpack("!L", socket.inet_aton("10.0.0.2"))[0] 27 | tag_label = 0x01 28 | decision = 0 29 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',tag_label, tag_label), 30 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 31 | data = table_action.make_data([gc.DataTuple('priority', 1), 32 | gc.DataTuple('decision', decision)], 'SwitchIngress.table_action3') 33 | table_action.entry_add(target, [key], [data]) 34 | 35 | # ======================================================== 36 | 37 | # table_action3 label -> dst_address 38 | dst_ip_addr = struct.unpack("!L", socket.inet_aton("10.0.0.1"))[0] 39 | tag_label = 0x02 40 | decision = 0 41 | key = table_action3.make_key([gc.KeyTuple('hdr.flowtag.tag_label',tag_label, tag_label), 42 | gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 43 | data = table_action.make_data([gc.DataTuple('priority', 1), 44 | gc.DataTuple('decision', decision)], 'SwitchIngress.table_action3') 45 | table_action.entry_add(target, [key], [data]) 46 | 47 | # ======================================================== 48 | -------------------------------------------------------------------------------- /host_agent/host_agent.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | # @lint-avoid-python-3-compatibility-imports 3 | 4 | from __future__ import print_function 5 | from bcc import BPF 6 | from bcc.containers import filter_by_containers 7 | from bcc.utils import ArgString, printb 8 | import bcc.utils as utils 9 | import argparse 10 | import re 11 | import time 12 | import pwd 13 | from collections import defaultdict 14 | from time import strftime 15 | import sqlite3 16 | import argparse as ap 17 | import socket 18 | from struct import pack 19 | from scapy.all import * 20 | from ctypes import * 21 | import pyroute2 22 | 23 | # initialize BPF 24 | b = BPF(src_file="host_agent_ebpf.c") 25 | 26 | 27 | execve_fnname = b.get_syscall_fnname("execve") 28 | b.attach_kretprobe(event=execve_fnname, fn_name="do_ret_sys_execve") 29 | 30 | event_name = b.get_syscall_fnname("clone") 31 | b.attach_kretprobe(event=event_name, fn_name ="syscall_clone") 32 | 33 | b.attach_kprobe(event="tcp_v4_connect", fn_name="trace_tcp_v4_connect_entry") 34 | # b.attach_kretprobe(event="tcp_v4_connect", fn_name="trace_tcp_v4_connect_return") 35 | 36 | # b.attach_kprobe(event="udp_sendmsg", fn_name="trace_udp_sendmsg") 37 | 38 | # b.attach_kprobe(event="vfs_create", fn_name="trace_create") 39 | # b.attach_kprobe(event="vfs_open", fn_name="trace_open") 40 | 41 | # b.attach_kprobe(event="vfs_read", fn_name="trace_read") 42 | # if BPF.get_kprobe_functions(b"security_inode_create"): 43 | # b.attach_kprobe(event="security_inode_create", fn_name="trace_security_inode_create") 44 | 45 | 46 | # Mellanox nic definitions 47 | nic_list = socket.if_nameindex() 48 | for i in nic_list: 49 | if "enp0s3" in i: 50 | device = "enp0s3" 51 | else: 52 | device = "enp8s0f0np0" 53 | 54 | print("USING NIC " + device) 55 | fn = b.load_func("handle_ingress", BPF.XDP) 56 | b.attach_xdp(device, fn, 0) 57 | 58 | f_egress = b.load_func("handle_egress", BPF.SCHED_CLS) 59 | ipr = pyroute2.IPRoute() 60 | eth = ipr.link_lookup(ifname=device)[0] 61 | ipr.tc("add", "clsact", eth) 62 | ipr.tc("add-filter", "bpf", eth, ":1", fd=f_egress.fd, name=f_egress.name, 63 | parent="ffff:fff3", classid=1, direct_action=True) 64 | 65 | 66 | 67 | while 1: 68 | try: 69 | b.trace_print() 70 | # b.perf_buffer_poll() 71 | except KeyboardInterrupt: 72 | b.remove_xdp(device, 0) 73 | exit() 74 | # tc qdisc del dev enp1s0f0np0 clsact 75 | # tc qdisc del dev enp0s31f6 clsact 76 | -------------------------------------------------------------------------------- /compiler/netcl.tab.h: -------------------------------------------------------------------------------- 1 | /* A Bison parser, made by GNU Bison 3.8.2. */ 2 | 3 | /* Bison interface for Yacc-like parsers in C 4 | 5 | Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 | Inc. 7 | 8 | This program is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | This program is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with this program. If not, see . */ 20 | 21 | /* As a special exception, you may create a larger work that contains 22 | part or all of the Bison parser skeleton and distribute that work 23 | under terms of your choice, so long as that work isn't itself a 24 | parser generator using the skeleton or a modified version thereof 25 | as a parser skeleton. Alternatively, if you modify or redistribute 26 | the parser skeleton itself, you may (at your option) remove this 27 | special exception, which will cause the skeleton and the resulting 28 | Bison output files to be licensed under the GNU General Public 29 | License without this special exception. 30 | 31 | This special exception was added by the Free Software Foundation in 32 | version 2.2 of Bison. */ 33 | 34 | /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 35 | especially those whose name start with YY_ or yy_. They are 36 | private implementation details that can be changed or removed. */ 37 | 38 | #ifndef YY_YY_NETCL_TAB_H_INCLUDED 39 | # define YY_YY_NETCL_TAB_H_INCLUDED 40 | /* Debug traces. */ 41 | #ifndef YYDEBUG 42 | # define YYDEBUG 0 43 | #endif 44 | #if YYDEBUG 45 | extern int yydebug; 46 | #endif 47 | 48 | /* Token kinds. */ 49 | #ifndef YYTOKENTYPE 50 | # define YYTOKENTYPE 51 | enum yytokentype 52 | { 53 | YYEMPTY = -2, 54 | YYEOF = 0, /* "end of file" */ 55 | YYerror = 256, /* error */ 56 | YYUNDEF = 257, /* "invalid token" */ 57 | IF = 258, /* IF */ 58 | THEN = 259, /* THEN */ 59 | MATCH = 260, /* MATCH */ 60 | DROP = 261, /* DROP */ 61 | FWD = 262, /* FWD */ 62 | MODIFYTTL = 263, /* MODIFYTTL */ 63 | REROUTE = 264, /* REROUTE */ 64 | LP = 265, /* LP */ 65 | RP = 266, /* RP */ 66 | EQ = 267, /* EQ */ 67 | CONTAINS = 268, /* CONTAINS */ 68 | AND = 269, /* AND */ 69 | ALICE = 270, /* ALICE */ 70 | BOB = 271, /* BOB */ 71 | SALES = 272, /* SALES */ 72 | DEV = 273, /* DEV */ 73 | CONST = 274, /* CONST */ 74 | VAR = 275, /* VAR */ 75 | IP = 276 /* IP */ 76 | }; 77 | typedef enum yytokentype yytoken_kind_t; 78 | #endif 79 | 80 | /* Value type. */ 81 | #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 82 | union YYSTYPE 83 | { 84 | #line 57 "netcl.y" 85 | 86 | int ival; 87 | float fval; 88 | char *sval; 89 | int listval[100]; 90 | 91 | #line 92 "netcl.tab.h" 92 | 93 | }; 94 | typedef union YYSTYPE YYSTYPE; 95 | # define YYSTYPE_IS_TRIVIAL 1 96 | # define YYSTYPE_IS_DECLARED 1 97 | #endif 98 | 99 | 100 | extern YYSTYPE yylval; 101 | 102 | 103 | int yyparse (void); 104 | 105 | 106 | #endif /* !YY_YY_NETCL_TAB_H_INCLUDED */ 107 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # P4Control 2 | 3 | This repository contains the artifacts for the paper titled "P4Control: Line-Rate Cross-Host Attack Prevention via In-Network Information Flow Control Enabled by Programmable Switches and eBPF", accepted at 45th IEEE Symposium on Security and Privacy (IEEE S&P / Oakland), 2024. For questions, please reach out to [Osama Bajaber](mailto:obajaber@vt.edu). 4 | 5 | ## Dependencies 6 | - Python 3.7 7 | - Tofino Switch SDE 9.7.0 8 | - BCC (Linux 5.15.0) 9 | - Bison 3.8.2 10 | - Flex 2.6.4 11 | - Scapy 2.4.5 12 | 13 | ## Setup 14 | Current settings assume three hosts are linked to the Tofino switch, each assigned with the following IP addresses and labels. (feel free to adjust these settings as per your topology) 15 | - ```Host1```, 10.0.0.1, Label={HOST1} 16 | - ```Host2```, 10.0.0.2, Label={HOST2} 17 | - ```Host3```, 10.0.0.3, Label={HOST3} 18 | 19 | ## How to use 20 | 21 | ### Run P4 Switch program 22 | Ensure that the Tofino switch SDE is installed and set the environment variables `SDE=~/bf-sde-9.7.0/` and `SDE_INSTALL=~/bf-sde-9.7.0/install`. Note: The `p4_build.sh` and `run_switchd.sh` scripts can be found within your SDE directory `/bf-sde-9.7.0/`. 23 | 24 | Step 1: Build the P4 program 25 | ``` 26 | ./p4_build.sh -p switch/p4control.p4 27 | ``` 28 | 29 | Step 2: Run the switch program in the Tofino switch 30 | ``` 31 | ./run_switchd.sh -p p4control 32 | ``` 33 | 34 | Step 3: Start the control plane 35 | ``` 36 | python3 switch/controller.py 37 | ``` 38 | 39 | This will load ```P4Control``` in the designated Tofino switch and run the control plane. The current control plane code inserts the needed ```NetCL``` policies to block traffic between ```Host1``` and ```Host3```. 40 | 41 | ### Run eBPF-based host agent 42 | 43 | Now, as the switch program is running, load the eBPF host agent to the hosts. We tested the host agent on Ubuntu 20.04.1 LTS, but it should work with other versions. Make sure to update the correct interface name in ```host_agent/host_agent.py```. 44 | 45 | Step 0: ```host_agent/host_agent_ebpf.c``` provides the ability to manually label a specific PID with a custom DIFC label for easy configuration 46 | 47 | In your opened terminal, check the PID of the current bash process by executing the following 48 | ``` 49 | ps 50 | ``` 51 | 52 | Copy the PID of the bash process to the defined ```TAGGED_TERMINAL``` variable at the top of ```host_agent/host_agent_ebpf.c``` 53 | ``` 54 | u32 TAGGED_TERMINAL = ; 55 | ``` 56 | 57 | Step 1: Run the host agent in all three hosts. The following command will attach all the needed eBPF programs inside the kernel 58 | ``` 59 | python3 host_agent/host_agent.py 60 | ``` 61 | 62 | ### Perform a cross-host attack 63 | 64 | To perform a cross-host attack from Host1 to Host3, using Host2 as a stepping stone 65 | 66 | Step 1: In ```Host2``` and ```Host3```, start a ```ncat``` listener 67 | ``` 68 | sudo ncat -nlvp 9999 -e /bin/bash 69 | ``` 70 | 71 | Step 2: From ```Host1```, connect to ```Host2``` 72 | ``` 73 | sudo ncat 10.0.0.2 9999 74 | ``` 75 | 76 | Step 3: From ```Host1``` establish a session to ```Host3``` through ```Host2``` 77 | ``` 78 | ncat 10.0.0.3 9999 79 | ``` 80 | 81 | P4Control will block the last connection as the label {Host1} is detected. 82 | 83 | ### Compile ```NetCL``` rules 84 | 85 | To compile ```NetCL``` rules 86 | 87 | Step 1: Run the following command 88 | ``` 89 | ./netcl-compile -i -o 90 | ``` 91 | 92 | Step 2: To add the compiled rules to the switch, copy the content of `````` to ```switch/netcl.py``` and re-run the control plane script 93 | ``` 94 | python3 switch/controller.py 95 | ``` 96 | 97 | ### Run custom tools 98 | 99 | We provide custom Scapy tools to send and receive customized packets with DIFC headers. These tools can be used to generate synthetic traffic to test the switch configurations 100 | 101 | Step 1: At the receiving host, run the following to start sniffing packets 102 | ``` 103 | python3 custom-receive.py 104 | ``` 105 | 106 | Step 2: At the sending host, run the following command to send the custom packet 107 | ``` 108 | python3 custom-send.py 109 | ``` 110 | 111 | 112 | ## Cite the paper 113 | 114 | If you like or use our work, please cite us using: 115 | 116 | ``` 117 | @inproceedings{bajaber2024p4control, 118 | title={P4Control: Line-Rate Cross-Host Attack Prevention via In-Network Information Flow Control Enabled by Programmable Switches and eBPF}, 119 | author={Bajaber, Osama and Ji, Bo and Gao, Peng}, 120 | booktitle={IEEE Symposium on Security and Privacy (SP)}, 121 | year={2024}, 122 | } 123 | ``` 124 | -------------------------------------------------------------------------------- /compiler/netcl.y: -------------------------------------------------------------------------------- 1 | %{ 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | using namespace std::chrono; 13 | using namespace std; 14 | 15 | string label; 16 | string src_ip_address; 17 | string dst_ip_address; 18 | string decision; 19 | 20 | bool is_ip_address(string s) { 21 | std::regex r ("\"[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}\""); 22 | if (regex_match(s, r)) { 23 | cout << "Detected an IP address " + s << endl; 24 | return true; 25 | } else { 26 | cout << s + " is not an IP address!" << endl; 27 | return false; 28 | } 29 | } 30 | 31 | using namespace std; 32 | 33 | 34 | extern "C" int yylex(); 35 | extern "C" int yyparse(); 36 | extern "C" FILE *yyin; 37 | 38 | void yyerror(const char *s); 39 | %} 40 | 41 | 42 | // use that union instead of "int" for the definition of "yystype": 43 | %union { 44 | int ival; 45 | float fval; 46 | char *sval; 47 | int listval[100]; 48 | } 49 | 50 | %token IF THEN 51 | %token MATCH 52 | 53 | // actions 54 | %token DROP FWD MODIFYTTL REROUTE 55 | 56 | // delineators 57 | %token LP RP 58 | 59 | // operators 60 | %token EQ CONTAINS 61 | %token AND 62 | %token ALICE BOB SALES DEV 63 | 64 | // base types 65 | %token CONST 66 | %token VAR 67 | %token IP 68 | 69 | %% 70 | netcl: 71 | statements { 72 | cout << "\nFile ready" << endl; 73 | } 74 | ; 75 | statements: 76 | statement 77 | ; 78 | 79 | matchexpr: 80 | MATCH LP binaryexpr RP { 81 | cout << "matchexpr" << endl; 82 | } 83 | ; 84 | 85 | statement: 86 | IF matchexpr THEN action { 87 | cout << "statement: matchexpr " << endl; 88 | } 89 | ; 90 | 91 | action: 92 | DROP { decision = "1"; cout << "Action: DROP" << endl;} 93 | | FWD { decision = "0"; cout << "Action: FWD" << endl;} 94 | | MODIFYTTL { decision = "2"; cout << "Action: MODIFYTTL" << endl;} 95 | | REROUTE { decision = "3"; cout << "Action: REROUTE" << endl;} 96 | 97 | ; 98 | 99 | binaryexpr: 100 | 101 | VAR binaryop VAR boolop VAR binaryop IP { 102 | label = $3; 103 | dst_ip_address = $7; 104 | cout << "binary expr" << endl; 105 | } 106 | ; 107 | 108 | binaryop: 109 | CONTAINS {cout << "contains" << endl;} 110 | | EQ {cout << "==" << endl;} 111 | ; 112 | 113 | boolop: 114 | AND 115 | ; 116 | %% 117 | 118 | static void usage() 119 | { 120 | fprintf(stderr, "To complie NetCL rules: ./netcl-compile -i -o \n"); 121 | } 122 | 123 | // helper function: find+replace string in a string 124 | void ReplaceStringInPlace(std::string& subject, const std::string& search, 125 | const std::string& replace) 126 | { 127 | size_t pos = 0; 128 | while ((pos = subject.find(search, pos)) != std::string::npos) { 129 | subject.replace(pos, search.length(), replace); 130 | pos += replace.length(); 131 | } 132 | } 133 | 134 | int generate_policy(string file_name) 135 | { 136 | ofstream policy(file_name); 137 | int ret; 138 | string rule_output; 139 | 140 | ifstream f("./templates/table_2_template.py"); 141 | string original_template((std::istreambuf_iterator(f)), 142 | (std::istreambuf_iterator())); 143 | rule_output = original_template; 144 | /* ReplaceStringInPlace(rule_output, "SRC_IP", check->src_ip); */ 145 | ReplaceStringInPlace(rule_output, "LABEL", label); 146 | ReplaceStringInPlace(rule_output, "DST_IP", dst_ip_address); 147 | ReplaceStringInPlace(rule_output, "DEC", decision); 148 | policy << rule_output << endl; 149 | rule_output = ""; 150 | cout << "finish generate" << endl; 151 | return 0; 152 | } 153 | 154 | int main(int argc, char *argv[]) { 155 | int opt; 156 | char *policy_file = NULL; 157 | char *output_file = NULL; 158 | 159 | // parse arguments 160 | while ((opt = getopt(argc, argv, "i:o:")) != -1) { 161 | switch (opt) { 162 | case 'i': 163 | policy_file = optarg; 164 | break; 165 | case 'o': 166 | output_file = optarg; 167 | break; 168 | default: 169 | usage(); 170 | exit(1); 171 | } 172 | } 173 | 174 | if (policy_file == NULL || output_file == NULL) { 175 | usage(); 176 | exit(1); 177 | } 178 | 179 | // open the policy file 180 | FILE *fp = fopen(policy_file, "r"); 181 | if (fp == NULL) { 182 | fprintf(stderr, "failed to open policy file %s", policy_file); 183 | return 1; 184 | } 185 | 186 | // set flex to read from it instead of defaulting to STDIN: 187 | yyin = fp; 188 | 189 | // parse through the input until there is no more: 190 | do { 191 | yyparse(); 192 | } while (!feof(yyin)); 193 | 194 | //Pushing soon compiling multiple policies and multiple table templates 195 | generate_policy(output_file); 196 | 197 | return 0; 198 | } 199 | 200 | 201 | 202 | void yyerror(const char *s) 203 | { 204 | cout << "Parse error! Message: " << s << endl; 205 | exit(-1); 206 | } 207 | -------------------------------------------------------------------------------- /switch/controller.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import ipaddress 3 | import sys 4 | import os 5 | sys.path.append(os.path.expandvars('$SDE/install/lib/python3.6/site-packages/tofino/')) 6 | from bfrt_grpc import client 7 | import grpc 8 | import bfrt_grpc.bfruntime_pb2 as bfruntime_pb2 9 | import bfrt_grpc.client as gc 10 | import socket, struct 11 | import netcl 12 | 13 | #Connect to BF Runtime Server 14 | interface = gc.ClientInterface(grpc_addr="localhost:50052", client_id=0,device_id=0) 15 | print('Connected to BF Runtime Server') 16 | # Get the information about the running program on the bfrt server. 17 | bfrt_info = interface.bfrt_info_get() 18 | print('The target runs program ', bfrt_info.p4_name_get()) 19 | # Establish that you are working with this program 20 | interface.bind_pipeline_config(bfrt_info.p4_name_get()) 21 | 22 | ####### You can now use BFRT CLIENT ####### 23 | target = gc.Target(device_id=0, pipe_id=0xffff) 24 | 25 | # Policy Rules 26 | table_action2 = bfrt_info.table_get("t_table_action2") 27 | table_action3 = bfrt_info.table_get("t_table_action3") 28 | table_action4 = bfrt_info.table_get("t_table_action4") 29 | # table_action5 = bfrt_info.table_get("t_table_action5") 30 | 31 | # Other tables 32 | forward_table = bfrt_info.table_get("table_forward") 33 | table_dst_tag_label = bfrt_info.table_get("table_dst_tag_label") 34 | table_dec = bfrt_info.table_get("table_dec") 35 | 36 | # Add by request (digest) 37 | table_conn = bfrt_info.table_get("table_conn") 38 | 39 | netcl.insert_rules() 40 | 41 | 42 | # table_dec 43 | key = table_dec.make_key([gc.KeyTuple('ig_md.decision', 0)]) 44 | data = table_dec.make_data([], 'NoAction') 45 | table_dec.entry_add(target, [key], [data]) 46 | 47 | key = table_dec.make_key([gc.KeyTuple('ig_md.decision', 1)]) 48 | data = table_dec.make_data([], 'SwitchIngress.miss') 49 | table_dec.entry_add(target, [key], [data]) 50 | 51 | key = table_dec.make_key([gc.KeyTuple('ig_md.decision', 2)]) 52 | data = table_dec.make_data([], 'SwitchIngress.modify') 53 | table_dec.entry_add(target, [key], [data]) 54 | 55 | key = table_dec.make_key([gc.KeyTuple('ig_md.decision', 3)]) 56 | data = table_dec.make_data([gc.DataTuple('egress_port', 62)], 'SwitchIngress.reroute') 57 | table_dec.entry_add(target, [key], [data]) 58 | 59 | # ==================================== 60 | #forward_table 61 | # Define the key 62 | dst_ip_addr = 0x0a000003 63 | key = forward_table.make_key([gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 64 | # Define the data for the matched key. 65 | dst_port= 62 66 | data = forward_table.make_data([gc.DataTuple('dst_port', dst_port)], 'SwitchIngress.route') 67 | # Add the entry to the table 68 | forward_table.entry_add(target, [key], [data]) 69 | 70 | # Define the key 71 | dst_ip_addr = 0x0a000002 72 | key = forward_table.make_key([gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 73 | dst_port= 61 74 | data = forward_table.make_data([gc.DataTuple('dst_port', dst_port)], 'SwitchIngress.route') 75 | # Add the entry to the table 76 | forward_table.entry_add(target, [key], [data]) 77 | 78 | # Define the key 79 | dst_ip_addr = 0x0a000001 80 | key = forward_table.make_key([gc.KeyTuple('hdr.ipv4.dst_addr',dst_ip_addr)]) 81 | # Define the data for the matched key. 82 | dst_port= 60 83 | data = forward_table.make_data([gc.DataTuple('dst_port', dst_port)], 'SwitchIngress.route') 84 | # Add the entry to the table 85 | forward_table.entry_add(target, [key], [data]) 86 | 87 | # ========================================================= 88 | # table_dst_tag_label 89 | 90 | # Define the key 91 | dst_ip_addr = 0x0a000001 92 | key = table_dst_tag_label.make_key([gc.KeyTuple('hdr.ipv4.dst_addr', value=dst_ip_addr)]) 93 | # Define the data for the matched key. 94 | dst_label_tag = 0x01 95 | data = table_dst_tag_label.make_data([gc.DataTuple('dst_label', dst_label_tag)], 'SwitchIngress.get_dst_label') 96 | # Add the entry to the table 97 | table_dst_tag_label.entry_add(target, [key], [data]) 98 | 99 | # Define the key 100 | dst_ip_addr = 0x0a000002 101 | key = table_dst_tag_label.make_key([gc.KeyTuple('hdr.ipv4.dst_addr', value=dst_ip_addr)]) 102 | # Define the data for the matched key. 103 | dst_label_tag = 0x02 104 | data = table_dst_tag_label.make_data([gc.DataTuple('dst_label', dst_label_tag)], 'SwitchIngress.get_dst_label') 105 | # Add the entry to the table 106 | table_dst_tag_label.entry_add(target, [key], [data]) 107 | 108 | # Define the key 109 | dst_ip_addr = 0x0a000003 110 | key = table_dst_tag_label.make_key([gc.KeyTuple('hdr.ipv4.dst_addr', value=dst_ip_addr)]) 111 | # Define the data for the matched key. 112 | dst_label_tag = 0x04 113 | data = table_dst_tag_label.make_data([gc.DataTuple('dst_label', dst_label_tag)], 'SwitchIngress.get_dst_label') 114 | # Add the entry to the table 115 | table_dst_tag_label.entry_add(target, [key], [data]) 116 | 117 | # ========================================================= 118 | 119 | 120 | print("DONE") 121 | 122 | def add_table_conn(src_addr, dst_addr, src_port, dst_port, decision): 123 | key = table_conn.make_key([gc.KeyTuple('hdr.ipv4.src_addr', value=src_addr), gc.KeyTuple('hdr.ipv4.dst_addr', value=dst_addr), gc.KeyTuple('hdr.tcp.src_port', value=src_port), gc.KeyTuple('hdr.tcp.dst_port', value=dst_port)]) 124 | # Define the data for the matched key. 125 | data = table_conn.make_data([gc.DataTuple('decision', decision)], 'SwitchIngress.enforce_dec') 126 | # Add the entry to the table 127 | table_conn.entry_add(target, [key], [data]) 128 | print("ADDED a new entry in table_conn") 129 | 130 | def handle_pkt(data_dict): 131 | src_addr = data_dict['src_addr'] 132 | dst_addr = data_dict['dst_addr'] 133 | src_port = data_dict['src_port'] 134 | dst_port = data_dict['dst_port'] 135 | tag_id = data_dict['tag_id'] 136 | digest_op = data_dict['digest_op'] 137 | tag_label = data_dict['tag_label'] 138 | decision = data_dict['decision'] 139 | block_dst_addr = data_dict['block_dst_addr'] 140 | tag_decision = data_dict['tag_decision'] 141 | 142 | if(data_dict['digest_op'] == 1): #DIGEST_ADD_CONN 143 | print("RECEIVED DIGEST_ADD_CONN | Decision is ", data_dict['decision']) 144 | add_table_conn(data_dict['src_addr'], data_dict['dst_addr'], data_dict['src_port'], data_dict['dst_port'], data_dict['decision']) 145 | 146 | while True: 147 | try: 148 | msg = interface.digest_get(timeout=0.1) 149 | if msg is not None: 150 | # print(msg) 151 | learn_filter = bfrt_info.learn_get("my_digest") 152 | data_list = learn_filter.make_data_list(msg) 153 | data_dict = data_list[0].to_dict() 154 | handle_pkt(data_dict) 155 | except: 156 | pass 157 | -------------------------------------------------------------------------------- /host_agent/host_agent_ebpf.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #pragma clang diagnostic push 7 | #pragma clang diagnostic ignored "-Wtautological-compare" 8 | #include 9 | #pragma clang diagnostic pop 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | #define TAGGED_TERMINAL 12345 25 | struct tag_hdr { 26 | __u64 label; 27 | __u64 tracker; 28 | }; 29 | 30 | 31 | BPF_HASH(tagged_pid, u32, struct tag_hdr); 32 | // BPF_ARRAY(tagged_pid, struct tag_hdr, 65535); 33 | 34 | BPF_HASH(tagged_port, u16, struct tag_hdr); 35 | // BPF_ARRAY(tagged_ports, u16, 65535); 36 | 37 | BPF_HASH(tagged_files, unsigned long, struct tag_hdr); 38 | 39 | BPF_HASH(time, u16, u64); 40 | 41 | BPF_HASH(currsock, u32, struct sock *); 42 | 43 | BPF_HASH(taggedflow, u16, struct tag_hdr); 44 | 45 | 46 | 47 | //#################################################################### 48 | // 49 | //execve trace 50 | // 51 | //#################################################################### 52 | 53 | int do_ret_sys_execve(struct pt_regs *ctx) 54 | { 55 | 56 | struct task_struct *task; 57 | struct tag_hdr *taghdr; 58 | u32 uid = bpf_get_current_uid_gid() & 0xffffffff; 59 | 60 | u32 pid = bpf_get_current_pid_tgid() >> 32; 61 | task = (struct task_struct *)bpf_get_current_task(); 62 | u32 ppid = task->real_parent->tgid; 63 | 64 | taghdr = tagged_pid.lookup(&ppid); 65 | if(taghdr != 0){ 66 | tagged_pid.update(&pid, taghdr); 67 | } 68 | 69 | else{ 70 | u32 newPid = TAGGED_TERMINAL; 71 | struct tag_hdr defult_hdr = {.tracker=htons(1), .label=htons(1),}; 72 | tagged_pid.update(&newPid, &defult_hdr); 73 | } 74 | return 0; 75 | } 76 | 77 | int syscall_clone (struct pt_regs *ctx, unsigned long flags, void *child_stack, 78 | void *ptid, void *ctid, struct pt_regs *regs) { 79 | struct task_struct *task; 80 | struct tag_hdr *taghdr; 81 | 82 | u32 pid = bpf_get_current_pid_tgid(); 83 | task = (struct task_struct *)bpf_get_current_task(); 84 | u32 ppid = task->parent->tgid; 85 | // u32 ppid = task->tgid; 86 | 87 | u32 child_pid = PT_REGS_RC(ctx); 88 | if (child_pid <= 0) { 89 | return 1; 90 | } 91 | 92 | taghdr = tagged_pid.lookup(&ppid); 93 | if(taghdr != 0){ 94 | tagged_pid.update(&child_pid, taghdr); 95 | } 96 | 97 | return 0; 98 | } 99 | 100 | //#################################################################### 101 | // 102 | //exit tracing 103 | // 104 | //#################################################################### 105 | 106 | TRACEPOINT_PROBE(sched, sched_process_exit) 107 | { 108 | struct task_struct *task = (typeof(task))bpf_get_current_task(); 109 | 110 | if(task != 0){ 111 | u32 pid = task->tgid; 112 | if(pid != 0) 113 | tagged_pid.delete(&pid); 114 | } 115 | return 0; 116 | } 117 | 118 | 119 | //#################################################################### 120 | // 121 | //Incoming passive tcp tracing 122 | // 123 | //#################################################################### 124 | 125 | 126 | 127 | int kretprobe__inet_csk_accept(struct pt_regs *ctx){ 128 | struct sock *newsk = (struct sock *)PT_REGS_RC(ctx); 129 | u32 pid = bpf_get_current_pid_tgid() >> 32; 130 | u32 uid = bpf_get_current_uid_gid() & 0xffffffff; 131 | 132 | if (newsk == NULL) 133 | return 0; 134 | 135 | u16 lport = newsk->__sk_common.skc_num; 136 | u16 dport = newsk->__sk_common.skc_dport; 137 | dport = ntohs(dport); 138 | 139 | 140 | struct tag_hdr * tagh; 141 | 142 | tagh = taggedflow.lookup(&dport); 143 | if(tagh != 0 && pid != 0){ 144 | tagged_pid.update(&pid, tagh); 145 | 146 | } 147 | 148 | return 0; 149 | 150 | } 151 | 152 | //#################################################################### 153 | // 154 | //Outgoing connections 155 | // 156 | //#################################################################### 157 | int trace_tcp_v4_connect_entry(struct pt_regs *ctx, struct sock *sk, int addr_len) 158 | { 159 | 160 | u32 pid = bpf_get_current_pid_tgid(); 161 | currsock.update(&pid, &sk); 162 | return 0; 163 | }; 164 | 165 | int kretprobe__inet_hash_connect(struct pt_regs * ctx) { 166 | u32 pid = bpf_get_current_pid_tgid() >> 32; 167 | 168 | int ret = PT_REGS_RC(ctx); 169 | 170 | struct sock ** skpp; 171 | skpp = currsock.lookup( & pid); 172 | if (skpp == 0) { 173 | return 0; // missed entry 174 | } 175 | 176 | if (ret != 0) { 177 | // failed to send SYNC packet, may not have populated 178 | // socket __sk_common.{skc_rcv_saddr, ...} 179 | currsock.delete( & pid); 180 | return 0; 181 | } 182 | 183 | struct task_struct *task; 184 | task = (struct task_struct *)bpf_get_current_task(); 185 | u32 ppid = task->real_parent->tgid; 186 | 187 | // pull in details 188 | struct sock * skp = * skpp; 189 | struct inet_sock * sockp = (struct inet_sock * ) skp; 190 | u16 sport = sockp -> inet_sport; 191 | u32 dest_ip = sockp -> inet_daddr; 192 | sport = ntohs(sport); 193 | 194 | struct tag_hdr *taghdr; 195 | 196 | taghdr = tagged_pid.lookup(&pid); 197 | if(taghdr != 0){ 198 | tagged_port.update(&sport, taghdr); 199 | } 200 | 201 | 202 | currsock.delete(&pid); 203 | 204 | return 0; 205 | } 206 | 207 | // int trace_udp_sendmsg(struct pt_regs *ctx) 208 | // { 209 | // __u64 pid_tgid = bpf_get_current_pid_tgid(); 210 | // struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx); 211 | // struct inet_sock *is = inet_sk(sk); 212 | // // only grab port 53 packets, 13568 is ntohs(53) 213 | // if (is->inet_dport == 13568) { 214 | // struct msghdr *msghdr = (struct msghdr *)PT_REGS_PARM2(ctx); 215 | // tbl_udp_msg_hdr.update(&pid_tgid, &msghdr); 216 | // } 217 | // bpf_trace_printk("UDP CATCH\\n"); 218 | // return 0; 219 | // } 220 | 221 | 222 | 223 | //#################################################################### 224 | // 225 | //File Create 226 | // 227 | //#################################################################### 228 | 229 | 230 | 231 | int trace_security_inode_create(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { 232 | u32 pid = bpf_get_current_pid_tgid() >> 32; 233 | 234 | // struct dentry *dentry = path->dentry; 235 | struct qstr d_name = dentry->d_name; 236 | struct tag_hdr *taghdr; 237 | unsigned long inode_num = dir->i_ino; 238 | 239 | if (dentry == NULL) 240 | 241 | 242 | taghdr = tagged_pid.lookup(&pid); 243 | if(taghdr != 0){ 244 | tagged_files.update(&inode_num, taghdr); 245 | } else { 246 | struct tag_hdr default_hdr = {.tracker=htons(1), .label=htons(1),}; 247 | tagged_files.update(&inode_num, &default_hdr); 248 | } 249 | 250 | return 0; 251 | } 252 | 253 | // int trace_open(struct pt_regs *ctx, struct path*path, struct file *file){ 254 | // struct dentry *dentry = path->dentry; 255 | 256 | // if (!(file->f_mode & FMODE_CREATED)) { 257 | // return 0; 258 | // } 259 | 260 | // unsigned long inode_num = dentry->d_inode->i_ino; 261 | // bpf_trace_printk("SECURITY INODE TRACE FILE INODE: %lu\\n", inode_num); 262 | 263 | // return 0; 264 | // } 265 | 266 | int trace_create(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { 267 | u32 pid = bpf_get_current_pid_tgid() >> 32; 268 | 269 | if (pid > 2000){ 270 | // struct dentry *dentry = path->dentry; 271 | struct qstr d_name = dentry->d_name; 272 | if (d_name.len == 0) 273 | return 0; 274 | } 275 | 276 | return 0; 277 | } 278 | 279 | //#################################################################### 280 | // 281 | //File Read 282 | // 283 | //#################################################################### 284 | 285 | int trace_open(struct pt_regs *ctx, struct path *path, struct file *file) 286 | { 287 | u32 pid = bpf_get_current_pid_tgid() >> 32; 288 | 289 | struct dentry *dentry = path->dentry; 290 | unsigned long inode_num = dentry->d_inode->i_ino; 291 | 292 | struct tag_hdr *file_taghdr; 293 | struct tag_hdr *process_taghdr; 294 | 295 | file_taghdr = tagged_files.lookup(&inode_num); 296 | process_taghdr = tagged_pid.lookup(&pid); 297 | if(file_taghdr != 0 && process_taghdr != 0){ 298 | process_taghdr->tracker = file_taghdr->tracker; 299 | // process_taghdr->id2 = file_taghdr->id2; 300 | process_taghdr->label = file_taghdr->label | process_taghdr->label; 301 | } 302 | 303 | return 0; 304 | } 305 | 306 | int trace_read(struct pt_regs *ctx, struct file *file, 307 | char __user *buf, size_t count, int is_read){ 308 | struct tag_hdr *taghdr_file; 309 | struct tag_hdr *taghdr_process; 310 | unsigned long inode = file->f_inode->i_ino; 311 | 312 | taghdr_file = tagged_files.lookup(&inode); 313 | if(taghdr_file != 0){ 314 | u32 pid = bpf_get_current_pid_tgid() >> 32; 315 | taghdr_process = tagged_pid.lookup(&pid); 316 | if(taghdr_process != 0){ 317 | taghdr_process->label = taghdr_process->label | taghdr_file->label; 318 | } 319 | } 320 | 321 | 322 | return 0; 323 | } 324 | 325 | 326 | //#################################################################### 327 | // 328 | //ingress handling 329 | // 330 | //#################################################################### 331 | #define IP_TCP 6 332 | 333 | 334 | int handle_ingress(struct xdp_md *ctx){ 335 | void *data_end = (void *)(long)ctx->data_end; 336 | void *data = (void *)(long)ctx->data; 337 | struct ethhdr *eth = data, eth_copy; 338 | struct iphdr *iph, iph_copy; 339 | struct tcphdr *tcph, tcph_copy; 340 | struct tag_hdr *tagh, tagh_copy; 341 | 342 | 343 | if (data + sizeof(*eth) > data_end) 344 | return XDP_PASS; 345 | 346 | if (bpf_ntohs(eth->h_proto) != ETH_P_IP) 347 | return XDP_PASS; 348 | 349 | if (data + sizeof(*eth) + sizeof(*iph) > data_end) 350 | return XDP_PASS; 351 | 352 | 353 | iph = data + sizeof(*eth); 354 | 355 | if (iph->protocol == IP_TCP){ 356 | 357 | if (data + sizeof(*eth) + sizeof(*iph) + sizeof(*tcph) > data_end) 358 | return XDP_PASS; 359 | 360 | tcph = data + sizeof(*eth) + sizeof(*iph); 361 | 362 | u16 dstport = ntohs(tcph->source); 363 | 364 | //0x0080 is converted to little endian 0x8000 365 | if(iph->frag_off & 0x0080){ 366 | iph->frag_off = iph->frag_off ^ 0x0080; 367 | 368 | 369 | if (data + sizeof(*eth) + sizeof(*iph) + sizeof(*tcph) + sizeof(*tagh) > data_end) 370 | return XDP_PASS; 371 | 372 | tagh = data + sizeof(*eth) + sizeof(*iph) + sizeof(*tcph); 373 | 374 | 375 | 376 | 377 | 378 | __builtin_memcpy(ð_copy, eth, sizeof(eth_copy)); 379 | __builtin_memcpy(&iph_copy, iph, sizeof(iph_copy)); 380 | __builtin_memcpy(&tcph_copy, tcph, sizeof(tcph_copy)); 381 | __builtin_memcpy(&tagh_copy, tagh, sizeof(tagh_copy)); 382 | 383 | u16 dest_port = ntohs(tcph->source); 384 | if (dest_port != 0 && tagh_copy.label != 0){ 385 | taggedflow.update(&dest_port, &tagh_copy); 386 | } 387 | 388 | if(bpf_xdp_adjust_head(ctx, 16)) 389 | return XDP_PASS; 390 | 391 | data = (void *)(long) ctx->data; 392 | data_end = (void *)(long) ctx->data_end; 393 | if(data + 1 > data_end) 394 | return XDP_PASS; 395 | 396 | eth = data; 397 | if (data + sizeof(*eth) > data_end) 398 | return XDP_PASS; 399 | 400 | if (data + sizeof(*eth) + sizeof(*iph) > data_end) 401 | return XDP_PASS; 402 | 403 | iph = data + sizeof(*eth); 404 | 405 | if (data + sizeof(*eth) + sizeof(*iph) + sizeof(*tcph) > data_end) 406 | return XDP_PASS; 407 | 408 | tcph = data + sizeof(*eth) + sizeof(*iph); 409 | 410 | __builtin_memcpy(eth, ð_copy, sizeof(*eth)); 411 | __builtin_memcpy(iph, &iph_copy, sizeof(*iph)); 412 | __builtin_memcpy(tcph, &tcph_copy, sizeof(*tcph)); 413 | 414 | 415 | return XDP_PASS; 416 | } 417 | return XDP_PASS; 418 | } 419 | return XDP_PASS; 420 | 421 | } 422 | 423 | 424 | //#################################################################### 425 | // 426 | //egress handling 427 | // 428 | //#################################################################### 429 | 430 | 431 | #define MAX_UDP_SIZE 1480 432 | 433 | __attribute__((__always_inline__)) 434 | static inline __u16 caltcpcsum(struct iphdr *iph, struct tcphdr *tcph, void *data_end) 435 | { 436 | __u32 csum_buffer = 0; 437 | __u16 *buf = (void *)tcph; 438 | 439 | // Compute pseudo-header checksum 440 | csum_buffer += (__u16)iph->saddr; 441 | csum_buffer += (__u16)(iph->saddr >> 16); 442 | csum_buffer += (__u16)iph->daddr; 443 | csum_buffer += (__u16)(iph->daddr >> 16); 444 | csum_buffer += (__u16)iph->protocol << 8; 445 | unsigned short tcpLen = ntohs(iph->tot_len) - (iph->ihl<<2); 446 | 447 | csum_buffer += htons(tcpLen); 448 | 449 | // Compute checksum on udp header + payload 450 | for (int i = 0; i < MAX_UDP_SIZE; i += 2) 451 | { 452 | if ((void *)(buf + 1) > data_end) 453 | { 454 | break; 455 | } 456 | 457 | csum_buffer += *buf; 458 | buf++; 459 | } 460 | 461 | if ((void *)buf + 1 <= data_end) 462 | { 463 | // In case payload is not 2 bytes aligned 464 | csum_buffer += *(__u8 *)buf; 465 | } 466 | 467 | __u16 csum = (__u16)csum_buffer + (__u16)(csum_buffer >> 16); 468 | csum = ~csum; 469 | 470 | return csum; 471 | } 472 | 473 | int handle_egress(struct __sk_buff *skb){ 474 | void *data_end = (void *)(long)skb->data_end; 475 | void *data = (void *)(long)skb->data; 476 | struct ethhdr *eth = data, eth_copy; 477 | struct iphdr *iph, iph_copy; 478 | struct tcphdr *tcph, tcph_copy; 479 | struct tag_hdr *thdr, thdr_copy; 480 | 481 | 482 | if (data + sizeof(*eth) > data_end) 483 | return TC_ACT_OK; 484 | 485 | if (bpf_ntohs(eth->h_proto) != ETH_P_IP) 486 | return TC_ACT_OK; 487 | 488 | if (data + sizeof(*eth) + sizeof(*iph) > data_end) 489 | return TC_ACT_OK; 490 | 491 | 492 | iph = data + sizeof(*eth); 493 | 494 | if (iph->protocol == IP_TCP){ 495 | if (data + sizeof(*eth) + sizeof(*iph) + sizeof(*tcph) > data_end) 496 | return TC_ACT_OK; 497 | 498 | tcph = data + sizeof(*eth) + sizeof(*iph); 499 | 500 | //measure packet sending latency 501 | // u16 sport; 502 | // u16 dsport = ntohs(tcph->dest); 503 | // if(dsport == 0) 504 | // return TC_ACT_OK; 505 | // u64 old_ts, *tsp; 506 | // tsp = time.lookup(&dsport); 507 | // if(tsp == 0) 508 | // return TC_ACT_OK; 509 | // u64 ts = bpf_ktime_get_ns(); 510 | // u64 new_ts = ts - *tsp; 511 | // bpf_trace_printk("TIME %d\\n", new_ts); 512 | 513 | 514 | if(tcph->syn){ 515 | u16 sport = ntohs(tcph->source); 516 | thdr = tagged_port.lookup(&sport); 517 | // bpf_trace_printk("TC EGRESS ACK \\n"); 518 | if(thdr != 0){ 519 | thdr_copy = *thdr; 520 | tagged_port.delete(&sport); 521 | 522 | tcph->check = 0; 523 | tcph->check = caltcpcsum(iph, tcph, data_end); 524 | 525 | 526 | iph->frag_off = iph->frag_off | 0x0080; 527 | // bpf_trace_printk("SKB len before %d\\n", skb->len); 528 | long ret = bpf_skb_load_bytes(skb, 0, ð_copy, sizeof(eth_copy)); 529 | if (ret) { 530 | return TC_ACT_SHOT; 531 | } 532 | // bpf_trace_printk("eth len before %d\\n", sizeof(eth_copy)); 533 | ret = bpf_skb_load_bytes(skb, sizeof(*eth), &iph_copy, sizeof(iph_copy)); 534 | if (ret) { 535 | return TC_ACT_SHOT; 536 | } 537 | // bpf_trace_printk("ip len before %d\\n", sizeof(*iph)); 538 | ret = bpf_skb_load_bytes(skb, sizeof(*eth) + sizeof(*iph), &tcph_copy, sizeof(tcph_copy)); 539 | if (ret) { 540 | return TC_ACT_SHOT; 541 | } 542 | if (ret) { 543 | return TC_ACT_SHOT; 544 | } 545 | // bpf_trace_printk("tcp len before %d\\n", sizeof(*tcph)); 546 | 547 | 548 | // bpf_trace_printk("IP ttl before adjust %d\\n", iph->ttl); 549 | ret = bpf_skb_adjust_room(skb, 16, BPF_ADJ_ROOM_MAC, BPF_F_ADJ_ROOM_FIXED_GSO); 550 | if (ret) { 551 | return TC_ACT_SHOT; 552 | } 553 | 554 | ret = bpf_skb_store_bytes(skb, 0, ð_copy, sizeof(eth_copy), 0); 555 | if (ret) { 556 | return TC_ACT_SHOT; 557 | } 558 | ret = bpf_skb_store_bytes(skb, sizeof(*eth), &iph_copy, sizeof(iph_copy), 0); 559 | if (ret) { 560 | return TC_ACT_SHOT; 561 | } 562 | ret = bpf_skb_store_bytes(skb, sizeof(*eth) + sizeof(*iph), &tcph_copy, sizeof(tcph_copy), 0); 563 | if (ret) { 564 | return TC_ACT_SHOT; 565 | } 566 | ret = bpf_skb_store_bytes(skb, sizeof(*eth) + sizeof(*iph) + sizeof(*tcph), &thdr_copy, 16, 0); 567 | if (ret) { 568 | return TC_ACT_SHOT; 569 | } 570 | 571 | 572 | } 573 | } 574 | 575 | return TC_ACT_OK; 576 | } 577 | 578 | return TC_ACT_OK; 579 | 580 | } -------------------------------------------------------------------------------- /switch/p4control.p4: -------------------------------------------------------------------------------- 1 | /******************************************************************************* 2 | * BAREFOOT NETWORKS CONFIDENTIAL & PROPRIETARY 3 | * 4 | * Copyright (c) 2019-present Barefoot Networks, Inc. 5 | * 6 | * All Rights Reserved. 7 | * 8 | * NOTICE: All information contained herein is, and remains the property of 9 | * Barefoot Networks, Inc. and its suppliers, if any. The intellectual and 10 | * technical concepts contained herein are proprietary to Barefoot Networks, Inc. 11 | * and its suppliers and may be covered by U.S. and Foreign Patents, patents in 12 | * process, and are protected by trade secret or copyright law. Dissemination of 13 | * this information or reproduction of this material is strictly forbidden unless 14 | * prior written permission is obtained from Barefoot Networks, Inc. 15 | * 16 | * No warranty, explicit or implicit is provided, unless granted under a written 17 | * agreement with Barefoot Networks, Inc. 18 | * 19 | ******************************************************************************/ 20 | 21 | #include 22 | #include 23 | 24 | // --------------------------------------------------------------------------- 25 | // Headers 26 | // --------------------------------------------------------------------------- 27 | 28 | //tags data types 29 | typedef bit<8> tag_id_t; 30 | 31 | typedef bit<8> tag_label_t; 32 | // typedef bit<256> tag_label_t; 33 | 34 | typedef bit<4> dec_t; 35 | typedef bit<4> bf_index_t; 36 | typedef bit<1> bf_out_t; 37 | typedef bit<16> conn_index_t; 38 | 39 | #define NUM_CELLS 86 40 | #define CONN_CELLS 210000 41 | 42 | #define DIGEST_REC 0 43 | #define DIGEST_ADD_CONN 1 44 | // #define DIGEST_ADD 2 45 | // #define DIGEST_ADD_MISSING_TAG 3 46 | 47 | #define BF_KEY1 32 48 | #define BF_KEY2 56 49 | #define BF_KEY3 210 50 | 51 | #define NOTAG 0 52 | #define DROP 1 53 | // #define FWD 2 54 | #define MODIFYTTL 2 55 | #define REC 15 56 | 57 | 58 | 59 | typedef bit<48> mac_addr_t; 60 | typedef bit<32> ipv4_addr_t; 61 | 62 | typedef bit<16> ether_type_t; 63 | const ether_type_t ETHERTYPE_IPV4 = 16w0x0800; 64 | 65 | typedef bit<8> ip_protocol_t; 66 | const ip_protocol_t IP_PROTOCOLS_ICMP = 1; 67 | const ip_protocol_t IP_PROTOCOLS_TCP = 6; 68 | const ip_protocol_t IP_PROTOCOLS_UDP = 17; 69 | 70 | const DigestType_t MY_DIGEST=1; 71 | 72 | const bit<16> EVIL_BIT = 0x8000; 73 | 74 | header ethernet_h { 75 | mac_addr_t dst_addr; 76 | mac_addr_t src_addr; 77 | bit<16> ether_type; 78 | } 79 | 80 | header ipv4_h { 81 | bit<4> version; 82 | bit<4> ihl; 83 | bit<8> diffserv; 84 | bit<16> total_len; 85 | bit<16> identification; 86 | bit<16> flags; 87 | // bit<13> frag_offset; 88 | bit<8> ttl; 89 | bit<8> protocol; 90 | bit<16> hdr_checksum; 91 | ipv4_addr_t src_addr; 92 | ipv4_addr_t dst_addr; 93 | } 94 | 95 | header tcp_h { 96 | bit<16> src_port; 97 | bit<16> dst_port; 98 | bit<32> seq_no; 99 | bit<32> ack_no; 100 | bit<4> data_offset; 101 | bit<4> res; 102 | bit<8> flags; 103 | bit<16> window; 104 | bit<16> checksum; 105 | bit<16> urgent_ptr; 106 | // bit<96> options; 107 | } 108 | 109 | header icmp_h { 110 | bit<8> type; 111 | bit<8> code; 112 | bit<16> checksum; 113 | bit<16> id; 114 | bit<16> seq_no; 115 | } 116 | 117 | header udp_h { 118 | bit<16> src_port; 119 | bit<16> dst_port; 120 | bit<16> hdr_length; 121 | bit<16> checksum; 122 | } 123 | 124 | 125 | 126 | header flowtag_h { 127 | tag_label_t tag_label; 128 | } 129 | 130 | header flowtag_id_h { 131 | tag_id_t tag_id; 132 | } 133 | 134 | // header timestamp_h { 135 | // bit<64> ingress_time; 136 | // bit<64> egress_time; 137 | // } 138 | 139 | struct header_t { 140 | ethernet_h ethernet; 141 | ipv4_h ipv4; 142 | icmp_h icmp; 143 | udp_h udp; 144 | tcp_h tcp; 145 | flowtag_h flowtag; 146 | flowtag_id_h flowtag_id; 147 | // timestamp_h timestamp; 148 | } 149 | 150 | struct digest_t { 151 | ipv4_addr_t dst_addr; 152 | ipv4_addr_t src_addr; 153 | bit<16> dst_port; 154 | bit<16> src_port; 155 | bit<2> digest_op; 156 | tag_label_t tag_label; 157 | dec_t decision; 158 | } 159 | 160 | struct metadata_t { 161 | // bridge_h bridge_hdr; 162 | 163 | ipv4_addr_t dst_addr; 164 | ipv4_addr_t src_addr; 165 | bit<16> dst_port; 166 | bit<16> src_port; 167 | // tag_id_t tag_id; 168 | 169 | tag_label_t tag_label; 170 | tag_label_t declassify_label; 171 | tag_label_t dst_tag_label; 172 | 173 | bit<2> digest_op; 174 | 175 | dec_t decision; 176 | dec_t decision2; 177 | 178 | bit<1> checksum_upd_ipv4; 179 | 180 | bit<16> priority_2; 181 | bit<16> priority_3; 182 | bit<16> priority_4; 183 | bit<16> priority_5; 184 | 185 | // dec_t priority_1_dec; 186 | dec_t priority_2_dec; 187 | dec_t priority_3_dec; 188 | dec_t priority_4_dec; 189 | dec_t priority_5_dec; 190 | } 191 | 192 | // --------------------------------------------------------------------------- 193 | // Ingress parser 194 | // --------------------------------------------------------------------------- 195 | parser TofinoIngressParser( 196 | packet_in pkt, 197 | out ingress_intrinsic_metadata_t ig_intr_md) { 198 | state start { 199 | pkt.extract(ig_intr_md); 200 | transition select(ig_intr_md.resubmit_flag) { 201 | 1 : parse_resubmit; 202 | 0 : parse_port_metadata; 203 | } 204 | } 205 | 206 | state parse_resubmit { 207 | // Parse resubmitted packet here. 208 | transition reject; 209 | } 210 | 211 | state parse_port_metadata { 212 | pkt.advance(PORT_METADATA_SIZE); 213 | transition accept; 214 | } 215 | } 216 | parser SwitchIngressParser( 217 | packet_in pkt, 218 | out header_t hdr, 219 | out metadata_t ig_md, 220 | out ingress_intrinsic_metadata_t ig_intr_md) { 221 | 222 | TofinoIngressParser() tofino_parser; 223 | 224 | 225 | 226 | state start { 227 | tofino_parser.apply(pkt, ig_intr_md); 228 | transition parse_ethernet; 229 | } 230 | 231 | state parse_ethernet { 232 | pkt.extract(hdr.ethernet); 233 | transition select (hdr.ethernet.ether_type) { 234 | ETHERTYPE_IPV4 : parse_ipv4; 235 | default : reject; 236 | } 237 | } 238 | 239 | state parse_ipv4 { 240 | pkt.extract(hdr.ipv4); 241 | transition select(hdr.ipv4.protocol) { 242 | IP_PROTOCOLS_TCP : parse_tcp; 243 | IP_PROTOCOLS_ICMP : parse_icmp; 244 | IP_PROTOCOLS_UDP : parse_udp; 245 | default: accept; 246 | } 247 | } 248 | 249 | state parse_tcp { 250 | pkt.extract(hdr.tcp); 251 | transition select (hdr.ipv4.flags[15:15]) { 252 | 1 : parse_tag; 253 | default : accept; 254 | } 255 | } 256 | 257 | state parse_udp { 258 | pkt.extract(hdr.udp); 259 | transition select (hdr.ipv4.flags[15:15]) { 260 | 1 : parse_tag; 261 | default : accept; 262 | } 263 | } 264 | 265 | state parse_icmp { 266 | pkt.extract(hdr.icmp); 267 | transition select (hdr.ipv4.flags[15:15]) { 268 | 1 : parse_tag; 269 | default : accept; 270 | } 271 | } 272 | 273 | state parse_tag { 274 | pkt.extract(hdr.flowtag); 275 | pkt.extract(hdr.flowtag_id); 276 | transition accept; 277 | } 278 | } 279 | 280 | 281 | // --------------------------------------------------------------------------- 282 | // Ingress Control 283 | // --------------------------------------------------------------------------- 284 | 285 | control SwitchIngress( 286 | inout header_t hdr, 287 | inout metadata_t ig_md, 288 | in ingress_intrinsic_metadata_t ig_intr_md, 289 | in ingress_intrinsic_metadata_from_parser_t ig_intr_prsr_md, 290 | inout ingress_intrinsic_metadata_for_deparser_t ig_dprsr_md, 291 | inout ingress_intrinsic_metadata_for_tm_t ig_intr_tm_md) { 292 | 293 | // bit<2> diff; 294 | tag_label_t check_label; 295 | 296 | bit<16> cur_priority = 0xFFFF; 297 | bit<16> priority2 = 0xFFFF; 298 | bit<16> priority3 = 0xFFFF; 299 | bit<16> priority4 = 0xFFFF; 300 | 301 | dec_t priority_2_dec = 0; 302 | dec_t priority_3_dec = 0; 303 | dec_t priority_4_dec = 0; 304 | dec_t priority_5_dec = 0; 305 | 306 | 307 | action route(bit<9> dst_port) { 308 | ig_intr_tm_md.ucast_egress_port = dst_port; 309 | ig_dprsr_md.drop_ctl = 0x0; 310 | } 311 | 312 | action miss() { 313 | ig_dprsr_md.drop_ctl = 0x1; // Drop packet. 314 | } 315 | 316 | table table_forward { 317 | key = { 318 | hdr.ipv4.dst_addr : exact; 319 | } 320 | 321 | actions = { 322 | route; 323 | miss; 324 | } 325 | 326 | const default_action = miss; 327 | size = 16; 328 | } 329 | 330 | //Connection table 331 | Register, conn_index_t> (size=CONN_CELLS, initial_value=0) cache_conn; 332 | //the first inout argument is the value of the Register entry being read and 333 | //updated, while the second optional out argument is the value that will be returned by 334 | //the execute method 335 | RegisterAction, conn_index_t, bit<8>>(cache_conn) conn_check = { 336 | void apply(inout bit<8> value, out bit<8> read_value) { 337 | read_value = value; 338 | } 339 | }; 340 | RegisterAction, conn_index_t, bit<8>>(cache_conn) conn_add = { 341 | void apply(inout bit<8> value, out bit<8> read_value) { 342 | read_value = (bit<8>) ig_md.decision; 343 | value = (bit<8>) ig_md.decision; 344 | } 345 | }; 346 | 347 | Hash(HashAlgorithm_t.CRC16) conn_hash; 348 | 349 | 350 | 351 | action prepare_digest(bit<2> digest_op){ 352 | ig_dprsr_md.digest_type = MY_DIGEST; 353 | ig_md.dst_addr = hdr.ipv4.dst_addr; 354 | ig_md.src_addr = hdr.ipv4.src_addr; 355 | ig_md.src_port = hdr.tcp.src_port; 356 | ig_md.dst_port = hdr.tcp.dst_port; 357 | // ig_md.tag_id = hdr.flowtag.tag_id; 358 | ig_md.digest_op = digest_op; 359 | ig_md.tag_label = hdr.flowtag.tag_label; 360 | } 361 | 362 | action enforce_dec(dec_t decision){ 363 | ig_md.decision = decision; 364 | } 365 | 366 | action get_dst_label(tag_label_t dst_label){ 367 | ig_md.dst_tag_label = dst_label; 368 | } 369 | 370 | table table_dst_tag_label { 371 | key = { 372 | hdr.ipv4.dst_addr : exact; 373 | } 374 | actions = { 375 | get_dst_label; 376 | } 377 | size = 32; 378 | } 379 | 380 | action reroute(bit<9> egress_port) { 381 | ig_intr_tm_md.ucast_egress_port = egress_port; 382 | } 383 | 384 | action modify(){ 385 | hdr.ipv4.ttl = 55; 386 | ig_md.checksum_upd_ipv4 = 1; 387 | } 388 | 389 | 390 | table table_dec { 391 | key = { 392 | ig_md.decision: exact; 393 | } 394 | 395 | actions = { 396 | reroute; 397 | miss; 398 | modify; 399 | // alert; //send with digest to control plane 400 | NoAction; 401 | } 402 | 403 | const default_action = NoAction; 404 | size = 16; 405 | } 406 | 407 | 408 | 409 | //maintain connection decision in a m/a table (also is maintained in register) 410 | table table_conn { 411 | key = { 412 | hdr.ipv4.src_addr: exact; 413 | hdr.ipv4.dst_addr: exact; 414 | hdr.tcp.src_port: exact; 415 | hdr.tcp.dst_port: exact; 416 | } 417 | actions = { 418 | enforce_dec; 419 | } 420 | size = CONN_CELLS; 421 | // size = 1024; 422 | } 423 | 424 | // action table_action(bit<16> priority, dec_t decision) { 425 | // // hdr.ipv4.ttl = 110; 426 | // ig_md.bridge_hdr.priority_1 = priority; 427 | // // ig_md.bridge_hdr.decision = decision; 428 | // cur_priority = min(priority, cur_priority); 429 | // } 430 | 431 | action table_action2(bit<16> priority, dec_t decision, tag_label_t declassify_label) { 432 | // hdr.ipv4.ttl = 120; 433 | priority2 = priority; 434 | hdr.flowtag.tag_label = hdr.flowtag.tag_label & declassify_label; 435 | priority_2_dec = decision; 436 | cur_priority = min(priority, cur_priority); 437 | } 438 | 439 | action table_action3(bit<16> priority, dec_t decision) { 440 | // hdr.ipv4.ttl = 130; 441 | priority3 = priority; 442 | priority_3_dec = decision; 443 | cur_priority = min(priority, cur_priority); 444 | } 445 | 446 | action table_action4(bit<16> priority, dec_t decision) { 447 | // hdr.ipv4.ttl = 140; 448 | priority4 = priority; 449 | priority_4_dec = decision; 450 | cur_priority = min(priority, cur_priority); 451 | } 452 | 453 | action table_action5(bit<16> priority, dec_t decision) { 454 | // hdr.ipv4.ttl = 150; 455 | // ig_md.priority_5 = priority; 456 | priority_5_dec = decision; 457 | cur_priority = min(priority, cur_priority); 458 | } 459 | 460 | 461 | //check label && dst 462 | // table t_table_action { 463 | // key = { 464 | // // hdr.ipv4.src_addr : exact; 465 | // hdr.ipv4.dst_addr : exact; 466 | // hdr.flowtag.tag_label : ternary; 467 | // } 468 | // actions = { 469 | // table_action; 470 | // } 471 | // size = 10000; 472 | // } 473 | 474 | //check src && dst 475 | table t_table_action2 { 476 | key = { 477 | hdr.ipv4.src_addr : exact; 478 | hdr.ipv4.dst_addr : exact; 479 | } 480 | actions = { 481 | table_action2; 482 | } 483 | size = 1000; 484 | } 485 | 486 | //check label && dst_label 487 | table t_table_action3 { 488 | key = { 489 | hdr.flowtag.tag_label : ternary; 490 | hdr.ipv4.dst_addr : exact; 491 | } 492 | actions = { 493 | table_action3; 494 | } 495 | size = 1000; 496 | } 497 | 498 | //check tag_id && dst 499 | table t_table_action4 { 500 | key = { 501 | hdr.ipv4.dst_addr : exact; 502 | hdr.flowtag_id.tag_id : exact; 503 | } 504 | actions = { 505 | table_action4; 506 | } 507 | size = 1000; 508 | } 509 | 510 | //check tag_id && dst_lable 511 | table t_table_action5 { 512 | key = { 513 | hdr.flowtag_id.tag_id : exact; 514 | ig_md.dst_tag_label : exact; 515 | } 516 | actions = { 517 | table_action5; 518 | } 519 | size = 1000; 520 | } 521 | 522 | 523 | apply { 524 | //merge dst label with current lable 525 | if(hdr.flowtag.isValid()){ 526 | table_dst_tag_label.apply(); 527 | hdr.flowtag.tag_label = hdr.flowtag.tag_label | ig_md.dst_tag_label; 528 | } 529 | 530 | // @stage(1){ 531 | // t_table_action.apply(); 532 | // } 533 | 534 | // @stage(3){ 535 | //Declassify and endorsement 536 | t_table_action2.apply(); 537 | // } 538 | 539 | // @stage(4){ 540 | t_table_action3.apply(); 541 | // } 542 | 543 | // @stage(4){ 544 | t_table_action4.apply(); 545 | // } 546 | 547 | // @stage(5){ 548 | t_table_action5.apply(); 549 | // } 550 | 551 | if(hdr.ipv4.flags[15:15] == (bit<1>)1){ 552 | if(cur_priority == priority2){ 553 | ig_md.decision = priority_2_dec; 554 | } else if(cur_priority == priority3){ 555 | ig_md.decision = priority_3_dec; 556 | } else if(cur_priority == priority4){ 557 | ig_md.decision = priority_4_dec; 558 | } else{ 559 | ig_md.decision = priority_5_dec; 560 | } 561 | ig_md.decision2 = ig_md.decision; 562 | conn_add.execute(conn_hash.get({hdr.ipv4.src_addr, hdr.ipv4.dst_addr, hdr.tcp.src_port, hdr.tcp.dst_port})); 563 | prepare_digest(DIGEST_ADD_CONN); 564 | } 565 | //else if the packet is following a tagged packet 566 | else{ 567 | ig_md.decision2 = (bit<4>)conn_check.execute(conn_hash.get({hdr.ipv4.src_addr, hdr.ipv4.dst_addr, hdr.tcp.src_port, hdr.tcp.dst_port})); 568 | table_conn.apply(); 569 | } 570 | 571 | ig_md.decision = ig_md.decision2; 572 | table_forward.apply(); 573 | table_dec.apply(); 574 | 575 | // No need for egress processing, skip it and use empty controls for egress. 576 | ig_intr_tm_md.bypass_egress = 1w1; 577 | } 578 | } 579 | // --------------------------------------------------------------------------- 580 | // Ingress Deparser 581 | // --------------------------------------------------------------------------- 582 | control SwitchIngressDeparser( 583 | packet_out pkt, 584 | inout header_t hdr, 585 | in metadata_t ig_md, 586 | in ingress_intrinsic_metadata_for_deparser_t ig_dprsr_md) { 587 | 588 | Digest() my_digest; 589 | Checksum() ipv4_checksum; 590 | 591 | apply { 592 | if (ig_dprsr_md.digest_type == MY_DIGEST) { 593 | my_digest.pack({ig_md.dst_addr, ig_md.src_addr, ig_md.dst_port, ig_md.src_port, ig_md.digest_op, ig_md.tag_label, ig_md.decision}); 594 | } 595 | 596 | if (ig_md.checksum_upd_ipv4==1) { 597 | hdr.ipv4.hdr_checksum = ipv4_checksum.update( 598 | {hdr.ipv4.version, 599 | hdr.ipv4.ihl, 600 | hdr.ipv4.diffserv, 601 | hdr.ipv4.total_len, 602 | hdr.ipv4.identification, 603 | hdr.ipv4.flags, 604 | hdr.ipv4.ttl, 605 | hdr.ipv4.protocol, 606 | hdr.ipv4.src_addr, 607 | hdr.ipv4.dst_addr}); 608 | } 609 | // pkt.emit(ig_md.bridge_hdr); 610 | pkt.emit(hdr); 611 | } 612 | } 613 | 614 | // --------------------------------------------------------------------------- 615 | // Egress Parser 616 | // --------------------------------------------------------------------------- 617 | // struct my_metadata_t{ 618 | 619 | // } 620 | parser SwitchEgressParser(packet_in packet, out header_t hdr, out metadata_t eg_md, out egress_intrinsic_metadata_t eg_intr_md) { 621 | state start { 622 | packet.extract(eg_intr_md); 623 | // packet.extract(eg_md.bridge_hdr); 624 | // packet.extract(meta.bridged_metadata); 625 | packet.extract(hdr.ethernet); 626 | packet.extract(hdr.ipv4); 627 | // packet.extract(hdr.tcp); 628 | // packet.extract(hdr.flowtag); 629 | // packet.extract(hdr.timestamp); 630 | transition accept; 631 | } 632 | 633 | } 634 | 635 | 636 | // --------------------------------------------------------------------------- 637 | // Egress Control 638 | // --------------------------------------------------------------------------- 639 | control SwitchEgress( 640 | inout header_t hdr, 641 | inout metadata_t eg_md, 642 | in egress_intrinsic_metadata_t eg_intr_md, 643 | in egress_intrinsic_metadata_from_parser_t eg_intr_parser_md, 644 | inout egress_intrinsic_metadata_for_deparser_t eg_intr_md_for_dprsr, 645 | inout egress_intrinsic_metadata_for_output_port_t eg_intr_md_for_oport) { 646 | 647 | 648 | apply{ 649 | 650 | } 651 | 652 | } 653 | 654 | // --------------------------------------------------------------------------- 655 | // Egress Deparser 656 | // --------------------------------------------------------------------------- 657 | control SwitchEgressDeparser(packet_out packet, inout header_t hdr, in metadata_t eg_md, in egress_intrinsic_metadata_for_deparser_t eg_dprsr_md) { 658 | apply { 659 | packet.emit(hdr); 660 | } 661 | 662 | } 663 | 664 | 665 | Pipeline(SwitchIngressParser(), 666 | SwitchIngress(), 667 | SwitchIngressDeparser(), 668 | SwitchEgressParser(), 669 | SwitchEgress(), 670 | SwitchEgressDeparser()) pipe; 671 | 672 | Switch(pipe) main; -------------------------------------------------------------------------------- /compiler/netcl.tab.c: -------------------------------------------------------------------------------- 1 | /* A Bison parser, made by GNU Bison 3.8.2. */ 2 | 3 | /* Bison implementation for Yacc-like parsers in C 4 | 5 | Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, 6 | Inc. 7 | 8 | This program is free software: you can redistribute it and/or modify 9 | it under the terms of the GNU General Public License as published by 10 | the Free Software Foundation, either version 3 of the License, or 11 | (at your option) any later version. 12 | 13 | This program is distributed in the hope that it will be useful, 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 | GNU General Public License for more details. 17 | 18 | You should have received a copy of the GNU General Public License 19 | along with this program. If not, see . */ 20 | 21 | /* As a special exception, you may create a larger work that contains 22 | part or all of the Bison parser skeleton and distribute that work 23 | under terms of your choice, so long as that work isn't itself a 24 | parser generator using the skeleton or a modified version thereof 25 | as a parser skeleton. Alternatively, if you modify or redistribute 26 | the parser skeleton itself, you may (at your option) remove this 27 | special exception, which will cause the skeleton and the resulting 28 | Bison output files to be licensed under the GNU General Public 29 | License without this special exception. 30 | 31 | This special exception was added by the Free Software Foundation in 32 | version 2.2 of Bison. */ 33 | 34 | /* C LALR(1) parser skeleton written by Richard Stallman, by 35 | simplifying the original so-called "semantic" parser. */ 36 | 37 | /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, 38 | especially those whose name start with YY_ or yy_. They are 39 | private implementation details that can be changed or removed. */ 40 | 41 | /* All symbols defined below should begin with yy or YY, to avoid 42 | infringing on user name space. This should be done even for local 43 | variables, as they might otherwise be expanded by user macros. 44 | There are some unavoidable exceptions within include files to 45 | define necessary library symbols; they are noted "INFRINGES ON 46 | USER NAME SPACE" below. */ 47 | 48 | /* Identify Bison output, and Bison version. */ 49 | #define YYBISON 30802 50 | 51 | /* Bison version string. */ 52 | #define YYBISON_VERSION "3.8.2" 53 | 54 | /* Skeleton name. */ 55 | #define YYSKELETON_NAME "yacc.c" 56 | 57 | /* Pure parsers. */ 58 | #define YYPURE 0 59 | 60 | /* Push parsers. */ 61 | #define YYPUSH 0 62 | 63 | /* Pull parsers. */ 64 | #define YYPULL 1 65 | 66 | 67 | 68 | 69 | /* First part of user prologue. */ 70 | #line 1 "netcl.y" 71 | 72 | #include 73 | #include 74 | #include 75 | #include 76 | #include 77 | #include 78 | #include 79 | #include 80 | #include 81 | #include 82 | using namespace std::chrono; 83 | using namespace std; 84 | 85 | string label; 86 | string src_ip_address; 87 | string dst_ip_address; 88 | string decision; 89 | 90 | bool is_header_name(string s) { 91 | std::regex r ("(h)*([s][r][c]){0,1}([d][s][t]){0,1}([t][a][g]){0,1}([0-3]*)"); 92 | if (regex_match(s, r)) { 93 | cout << "Detected a header " + s << endl; 94 | return true; 95 | } else { 96 | cout << s + " is not a header!" << endl; 97 | return false; 98 | } 99 | } 100 | 101 | bool is_ip_address(string s) { 102 | std::regex r ("\"[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}\""); 103 | if (regex_match(s, r)) { 104 | cout << "Detected an IP address " + s << endl; 105 | return true; 106 | } else { 107 | cout << s + " is not an IP address!" << endl; 108 | return false; 109 | } 110 | } 111 | 112 | using namespace std; 113 | 114 | // stuff from flex that bison needs to know about: 115 | extern "C" int yylex(); 116 | extern "C" int yyparse(); 117 | extern "C" FILE *yyin; 118 | 119 | void yyerror(const char *s); 120 | 121 | #line 122 "netcl.tab.c" 122 | 123 | # ifndef YY_CAST 124 | # ifdef __cplusplus 125 | # define YY_CAST(Type, Val) static_cast (Val) 126 | # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) 127 | # else 128 | # define YY_CAST(Type, Val) ((Type) (Val)) 129 | # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 130 | # endif 131 | # endif 132 | # ifndef YY_NULLPTR 133 | # if defined __cplusplus 134 | # if 201103L <= __cplusplus 135 | # define YY_NULLPTR nullptr 136 | # else 137 | # define YY_NULLPTR 0 138 | # endif 139 | # else 140 | # define YY_NULLPTR ((void*)0) 141 | # endif 142 | # endif 143 | 144 | #include "netcl.tab.h" 145 | /* Symbol kind. */ 146 | enum yysymbol_kind_t 147 | { 148 | YYSYMBOL_YYEMPTY = -2, 149 | YYSYMBOL_YYEOF = 0, /* "end of file" */ 150 | YYSYMBOL_YYerror = 1, /* error */ 151 | YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 152 | YYSYMBOL_IF = 3, /* IF */ 153 | YYSYMBOL_THEN = 4, /* THEN */ 154 | YYSYMBOL_MATCH = 5, /* MATCH */ 155 | YYSYMBOL_DROP = 6, /* DROP */ 156 | YYSYMBOL_FWD = 7, /* FWD */ 157 | YYSYMBOL_MODIFYTTL = 8, /* MODIFYTTL */ 158 | YYSYMBOL_REROUTE = 9, /* REROUTE */ 159 | YYSYMBOL_LP = 10, /* LP */ 160 | YYSYMBOL_RP = 11, /* RP */ 161 | YYSYMBOL_EQ = 12, /* EQ */ 162 | YYSYMBOL_CONTAINS = 13, /* CONTAINS */ 163 | YYSYMBOL_AND = 14, /* AND */ 164 | YYSYMBOL_ALICE = 15, /* ALICE */ 165 | YYSYMBOL_BOB = 16, /* BOB */ 166 | YYSYMBOL_SALES = 17, /* SALES */ 167 | YYSYMBOL_DEV = 18, /* DEV */ 168 | YYSYMBOL_CONST = 19, /* CONST */ 169 | YYSYMBOL_VAR = 20, /* VAR */ 170 | YYSYMBOL_IP = 21, /* IP */ 171 | YYSYMBOL_YYACCEPT = 22, /* $accept */ 172 | YYSYMBOL_netcl = 23, /* netcl */ 173 | YYSYMBOL_statements = 24, /* statements */ 174 | YYSYMBOL_matchexpr = 25, /* matchexpr */ 175 | YYSYMBOL_statement = 26, /* statement */ 176 | YYSYMBOL_action = 27, /* action */ 177 | YYSYMBOL_binaryexpr = 28, /* binaryexpr */ 178 | YYSYMBOL_binaryop = 29, /* binaryop */ 179 | YYSYMBOL_boolop = 30 /* boolop */ 180 | }; 181 | typedef enum yysymbol_kind_t yysymbol_kind_t; 182 | 183 | 184 | 185 | 186 | #ifdef short 187 | # undef short 188 | #endif 189 | 190 | /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 191 | and (if available) are included 192 | so that the code can choose integer types of a good width. */ 193 | 194 | #ifndef __PTRDIFF_MAX__ 195 | # include /* INFRINGES ON USER NAME SPACE */ 196 | # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 197 | # include /* INFRINGES ON USER NAME SPACE */ 198 | # define YY_STDINT_H 199 | # endif 200 | #endif 201 | 202 | /* Narrow types that promote to a signed type and that can represent a 203 | signed or unsigned integer of at least N bits. In tables they can 204 | save space and decrease cache pressure. Promoting to a signed type 205 | helps avoid bugs in integer arithmetic. */ 206 | 207 | #ifdef __INT_LEAST8_MAX__ 208 | typedef __INT_LEAST8_TYPE__ yytype_int8; 209 | #elif defined YY_STDINT_H 210 | typedef int_least8_t yytype_int8; 211 | #else 212 | typedef signed char yytype_int8; 213 | #endif 214 | 215 | #ifdef __INT_LEAST16_MAX__ 216 | typedef __INT_LEAST16_TYPE__ yytype_int16; 217 | #elif defined YY_STDINT_H 218 | typedef int_least16_t yytype_int16; 219 | #else 220 | typedef short yytype_int16; 221 | #endif 222 | 223 | /* Work around bug in HP-UX 11.23, which defines these macros 224 | incorrectly for preprocessor constants. This workaround can likely 225 | be removed in 2023, as HPE has promised support for HP-UX 11.23 226 | (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 227 | . */ 228 | #ifdef __hpux 229 | # undef UINT_LEAST8_MAX 230 | # undef UINT_LEAST16_MAX 231 | # define UINT_LEAST8_MAX 255 232 | # define UINT_LEAST16_MAX 65535 233 | #endif 234 | 235 | #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 236 | typedef __UINT_LEAST8_TYPE__ yytype_uint8; 237 | #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 238 | && UINT_LEAST8_MAX <= INT_MAX) 239 | typedef uint_least8_t yytype_uint8; 240 | #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 241 | typedef unsigned char yytype_uint8; 242 | #else 243 | typedef short yytype_uint8; 244 | #endif 245 | 246 | #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 247 | typedef __UINT_LEAST16_TYPE__ yytype_uint16; 248 | #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 249 | && UINT_LEAST16_MAX <= INT_MAX) 250 | typedef uint_least16_t yytype_uint16; 251 | #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 252 | typedef unsigned short yytype_uint16; 253 | #else 254 | typedef int yytype_uint16; 255 | #endif 256 | 257 | #ifndef YYPTRDIFF_T 258 | # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 259 | # define YYPTRDIFF_T __PTRDIFF_TYPE__ 260 | # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 261 | # elif defined PTRDIFF_MAX 262 | # ifndef ptrdiff_t 263 | # include /* INFRINGES ON USER NAME SPACE */ 264 | # endif 265 | # define YYPTRDIFF_T ptrdiff_t 266 | # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 267 | # else 268 | # define YYPTRDIFF_T long 269 | # define YYPTRDIFF_MAXIMUM LONG_MAX 270 | # endif 271 | #endif 272 | 273 | #ifndef YYSIZE_T 274 | # ifdef __SIZE_TYPE__ 275 | # define YYSIZE_T __SIZE_TYPE__ 276 | # elif defined size_t 277 | # define YYSIZE_T size_t 278 | # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 279 | # include /* INFRINGES ON USER NAME SPACE */ 280 | # define YYSIZE_T size_t 281 | # else 282 | # define YYSIZE_T unsigned 283 | # endif 284 | #endif 285 | 286 | #define YYSIZE_MAXIMUM \ 287 | YY_CAST (YYPTRDIFF_T, \ 288 | (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 289 | ? YYPTRDIFF_MAXIMUM \ 290 | : YY_CAST (YYSIZE_T, -1))) 291 | 292 | #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 293 | 294 | 295 | /* Stored state numbers (used for stacks). */ 296 | typedef yytype_int8 yy_state_t; 297 | 298 | /* State numbers in computations. */ 299 | typedef int yy_state_fast_t; 300 | 301 | #ifndef YY_ 302 | # if defined YYENABLE_NLS && YYENABLE_NLS 303 | # if ENABLE_NLS 304 | # include /* INFRINGES ON USER NAME SPACE */ 305 | # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 306 | # endif 307 | # endif 308 | # ifndef YY_ 309 | # define YY_(Msgid) Msgid 310 | # endif 311 | #endif 312 | 313 | 314 | #ifndef YY_ATTRIBUTE_PURE 315 | # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 316 | # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 317 | # else 318 | # define YY_ATTRIBUTE_PURE 319 | # endif 320 | #endif 321 | 322 | #ifndef YY_ATTRIBUTE_UNUSED 323 | # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 324 | # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 325 | # else 326 | # define YY_ATTRIBUTE_UNUSED 327 | # endif 328 | #endif 329 | 330 | /* Suppress unused-variable warnings by "using" E. */ 331 | #if ! defined lint || defined __GNUC__ 332 | # define YY_USE(E) ((void) (E)) 333 | #else 334 | # define YY_USE(E) /* empty */ 335 | #endif 336 | 337 | /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 338 | #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 339 | # if __GNUC__ * 100 + __GNUC_MINOR__ < 407 340 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 341 | _Pragma ("GCC diagnostic push") \ 342 | _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 343 | # else 344 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 345 | _Pragma ("GCC diagnostic push") \ 346 | _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 347 | _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 348 | # endif 349 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 350 | _Pragma ("GCC diagnostic pop") 351 | #else 352 | # define YY_INITIAL_VALUE(Value) Value 353 | #endif 354 | #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 355 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 356 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END 357 | #endif 358 | #ifndef YY_INITIAL_VALUE 359 | # define YY_INITIAL_VALUE(Value) /* Nothing. */ 360 | #endif 361 | 362 | #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 363 | # define YY_IGNORE_USELESS_CAST_BEGIN \ 364 | _Pragma ("GCC diagnostic push") \ 365 | _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 366 | # define YY_IGNORE_USELESS_CAST_END \ 367 | _Pragma ("GCC diagnostic pop") 368 | #endif 369 | #ifndef YY_IGNORE_USELESS_CAST_BEGIN 370 | # define YY_IGNORE_USELESS_CAST_BEGIN 371 | # define YY_IGNORE_USELESS_CAST_END 372 | #endif 373 | 374 | 375 | #define YY_ASSERT(E) ((void) (0 && (E))) 376 | 377 | #if !defined yyoverflow 378 | 379 | /* The parser invokes alloca or malloc; define the necessary symbols. */ 380 | 381 | # ifdef YYSTACK_USE_ALLOCA 382 | # if YYSTACK_USE_ALLOCA 383 | # ifdef __GNUC__ 384 | # define YYSTACK_ALLOC __builtin_alloca 385 | # elif defined __BUILTIN_VA_ARG_INCR 386 | # include /* INFRINGES ON USER NAME SPACE */ 387 | # elif defined _AIX 388 | # define YYSTACK_ALLOC __alloca 389 | # elif defined _MSC_VER 390 | # include /* INFRINGES ON USER NAME SPACE */ 391 | # define alloca _alloca 392 | # else 393 | # define YYSTACK_ALLOC alloca 394 | # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 395 | # include /* INFRINGES ON USER NAME SPACE */ 396 | /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 397 | # ifndef EXIT_SUCCESS 398 | # define EXIT_SUCCESS 0 399 | # endif 400 | # endif 401 | # endif 402 | # endif 403 | # endif 404 | 405 | # ifdef YYSTACK_ALLOC 406 | /* Pacify GCC's 'empty if-body' warning. */ 407 | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 408 | # ifndef YYSTACK_ALLOC_MAXIMUM 409 | /* The OS might guarantee only one guard page at the bottom of the stack, 410 | and a page size can be as small as 4096 bytes. So we cannot safely 411 | invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 412 | to allow for a few compiler-allocated temporary stack slots. */ 413 | # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 414 | # endif 415 | # else 416 | # define YYSTACK_ALLOC YYMALLOC 417 | # define YYSTACK_FREE YYFREE 418 | # ifndef YYSTACK_ALLOC_MAXIMUM 419 | # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 420 | # endif 421 | # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 422 | && ! ((defined YYMALLOC || defined malloc) \ 423 | && (defined YYFREE || defined free))) 424 | # include /* INFRINGES ON USER NAME SPACE */ 425 | # ifndef EXIT_SUCCESS 426 | # define EXIT_SUCCESS 0 427 | # endif 428 | # endif 429 | # ifndef YYMALLOC 430 | # define YYMALLOC malloc 431 | # if ! defined malloc && ! defined EXIT_SUCCESS 432 | void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 433 | # endif 434 | # endif 435 | # ifndef YYFREE 436 | # define YYFREE free 437 | # if ! defined free && ! defined EXIT_SUCCESS 438 | void free (void *); /* INFRINGES ON USER NAME SPACE */ 439 | # endif 440 | # endif 441 | # endif 442 | #endif /* !defined yyoverflow */ 443 | 444 | #if (! defined yyoverflow \ 445 | && (! defined __cplusplus \ 446 | || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 447 | 448 | /* A type that is properly aligned for any stack member. */ 449 | union yyalloc 450 | { 451 | yy_state_t yyss_alloc; 452 | YYSTYPE yyvs_alloc; 453 | }; 454 | 455 | /* The size of the maximum gap between one aligned stack and the next. */ 456 | # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 457 | 458 | /* The size of an array large to enough to hold all stacks, each with 459 | N elements. */ 460 | # define YYSTACK_BYTES(N) \ 461 | ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 462 | + YYSTACK_GAP_MAXIMUM) 463 | 464 | # define YYCOPY_NEEDED 1 465 | 466 | /* Relocate STACK from its old location to the new one. The 467 | local variables YYSIZE and YYSTACKSIZE give the old and new number of 468 | elements in the stack, and YYPTR gives the new location of the 469 | stack. Advance YYPTR to a properly aligned location for the next 470 | stack. */ 471 | # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 472 | do \ 473 | { \ 474 | YYPTRDIFF_T yynewbytes; \ 475 | YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 476 | Stack = &yyptr->Stack_alloc; \ 477 | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 478 | yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 479 | } \ 480 | while (0) 481 | 482 | #endif 483 | 484 | #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 485 | /* Copy COUNT objects from SRC to DST. The source and destination do 486 | not overlap. */ 487 | # ifndef YYCOPY 488 | # if defined __GNUC__ && 1 < __GNUC__ 489 | # define YYCOPY(Dst, Src, Count) \ 490 | __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 491 | # else 492 | # define YYCOPY(Dst, Src, Count) \ 493 | do \ 494 | { \ 495 | YYPTRDIFF_T yyi; \ 496 | for (yyi = 0; yyi < (Count); yyi++) \ 497 | (Dst)[yyi] = (Src)[yyi]; \ 498 | } \ 499 | while (0) 500 | # endif 501 | # endif 502 | #endif /* !YYCOPY_NEEDED */ 503 | 504 | /* YYFINAL -- State number of the termination state. */ 505 | #define YYFINAL 7 506 | /* YYLAST -- Last index in YYTABLE. */ 507 | #define YYLAST 21 508 | 509 | /* YYNTOKENS -- Number of terminals. */ 510 | #define YYNTOKENS 22 511 | /* YYNNTS -- Number of nonterminals. */ 512 | #define YYNNTS 9 513 | /* YYNRULES -- Number of rules. */ 514 | #define YYNRULES 13 515 | /* YYNSTATES -- Number of states. */ 516 | #define YYNSTATES 27 517 | 518 | /* YYMAXUTOK -- Last valid token kind. */ 519 | #define YYMAXUTOK 276 520 | 521 | 522 | /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 523 | as returned by yylex, with out-of-bounds checking. */ 524 | #define YYTRANSLATE(YYX) \ 525 | (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 526 | ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 527 | : YYSYMBOL_YYUNDEF) 528 | 529 | /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 530 | as returned by yylex. */ 531 | static const yytype_int8 yytranslate[] = 532 | { 533 | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 535 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 536 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 537 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 538 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 539 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 540 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 541 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 542 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 543 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 544 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 545 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 546 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 547 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 548 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 549 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 550 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 551 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 552 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 553 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 554 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 555 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 556 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 557 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 558 | 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 559 | 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 560 | 15, 16, 17, 18, 19, 20, 21 561 | }; 562 | 563 | #if YYDEBUG 564 | /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 565 | static const yytype_uint8 yyrline[] = 566 | { 567 | 0, 88, 88, 93, 97, 103, 109, 110, 111, 112, 568 | 118, 126, 127, 131 569 | }; 570 | #endif 571 | 572 | /** Accessing symbol of state STATE. */ 573 | #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 574 | 575 | #if YYDEBUG || 0 576 | /* The user-facing name of the symbol whose (internal) number is 577 | YYSYMBOL. No bounds checking. */ 578 | static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 579 | 580 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 581 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 582 | static const char *const yytname[] = 583 | { 584 | "\"end of file\"", "error", "\"invalid token\"", "IF", "THEN", "MATCH", 585 | "DROP", "FWD", "MODIFYTTL", "REROUTE", "LP", "RP", "EQ", "CONTAINS", 586 | "AND", "ALICE", "BOB", "SALES", "DEV", "CONST", "VAR", "IP", "$accept", 587 | "netcl", "statements", "matchexpr", "statement", "action", "binaryexpr", 588 | "binaryop", "boolop", YY_NULLPTR 589 | }; 590 | 591 | static const char * 592 | yysymbol_name (yysymbol_kind_t yysymbol) 593 | { 594 | return yytname[yysymbol]; 595 | } 596 | #endif 597 | 598 | #define YYPACT_NINF (-10) 599 | 600 | #define yypact_value_is_default(Yyn) \ 601 | ((Yyn) == YYPACT_NINF) 602 | 603 | #define YYTABLE_NINF (-1) 604 | 605 | #define yytable_value_is_error(Yyn) \ 606 | 0 607 | 608 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 609 | STATE-NUM. */ 610 | static const yytype_int8 yypact[] = 611 | { 612 | 3, 2, 8, -10, -10, -1, 6, -10, -9, -6, 613 | -8, 1, -10, -10, -10, -10, -10, -10, -10, -7, 614 | -10, 0, -10, -5, -8, -4, -10 615 | }; 616 | 617 | /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 618 | Performed when YYTABLE does not specify something else to do. Zero 619 | means the default is an error. */ 620 | static const yytype_int8 yydefact[] = 621 | { 622 | 0, 0, 0, 2, 3, 0, 0, 1, 0, 0, 623 | 0, 0, 6, 7, 8, 9, 5, 12, 11, 0, 624 | 4, 0, 13, 0, 0, 0, 10 625 | }; 626 | 627 | /* YYPGOTO[NTERM-NUM]. */ 628 | static const yytype_int8 yypgoto[] = 629 | { 630 | -10, -10, -10, -10, -10, -10, -10, -3, -10 631 | }; 632 | 633 | /* YYDEFGOTO[NTERM-NUM]. */ 634 | static const yytype_int8 yydefgoto[] = 635 | { 636 | 0, 2, 3, 6, 4, 16, 11, 19, 23 637 | }; 638 | 639 | /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 640 | positive, shift that token. If negative, reduce the rule whose 641 | number is the opposite. If YYTABLE_NINF, syntax error. */ 642 | static const yytype_int8 yytable[] = 643 | { 644 | 12, 13, 14, 15, 17, 18, 1, 5, 7, 8, 645 | 9, 10, 20, 21, 22, 24, 0, 26, 0, 0, 646 | 0, 25 647 | }; 648 | 649 | static const yytype_int8 yycheck[] = 650 | { 651 | 6, 7, 8, 9, 12, 13, 3, 5, 0, 10, 652 | 4, 20, 11, 20, 14, 20, -1, 21, -1, -1, 653 | -1, 24 654 | }; 655 | 656 | /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of 657 | state STATE-NUM. */ 658 | static const yytype_int8 yystos[] = 659 | { 660 | 0, 3, 23, 24, 26, 5, 25, 0, 10, 4, 661 | 20, 28, 6, 7, 8, 9, 27, 12, 13, 29, 662 | 11, 20, 14, 30, 20, 29, 21 663 | }; 664 | 665 | /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ 666 | static const yytype_int8 yyr1[] = 667 | { 668 | 0, 22, 23, 24, 25, 26, 27, 27, 27, 27, 669 | 28, 29, 29, 30 670 | }; 671 | 672 | /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ 673 | static const yytype_int8 yyr2[] = 674 | { 675 | 0, 2, 1, 1, 4, 4, 1, 1, 1, 1, 676 | 7, 1, 1, 1 677 | }; 678 | 679 | 680 | enum { YYENOMEM = -2 }; 681 | 682 | #define yyerrok (yyerrstatus = 0) 683 | #define yyclearin (yychar = YYEMPTY) 684 | 685 | #define YYACCEPT goto yyacceptlab 686 | #define YYABORT goto yyabortlab 687 | #define YYERROR goto yyerrorlab 688 | #define YYNOMEM goto yyexhaustedlab 689 | 690 | 691 | #define YYRECOVERING() (!!yyerrstatus) 692 | 693 | #define YYBACKUP(Token, Value) \ 694 | do \ 695 | if (yychar == YYEMPTY) \ 696 | { \ 697 | yychar = (Token); \ 698 | yylval = (Value); \ 699 | YYPOPSTACK (yylen); \ 700 | yystate = *yyssp; \ 701 | goto yybackup; \ 702 | } \ 703 | else \ 704 | { \ 705 | yyerror (YY_("syntax error: cannot back up")); \ 706 | YYERROR; \ 707 | } \ 708 | while (0) 709 | 710 | /* Backward compatibility with an undocumented macro. 711 | Use YYerror or YYUNDEF. */ 712 | #define YYERRCODE YYUNDEF 713 | 714 | 715 | /* Enable debugging if requested. */ 716 | #if YYDEBUG 717 | 718 | # ifndef YYFPRINTF 719 | # include /* INFRINGES ON USER NAME SPACE */ 720 | # define YYFPRINTF fprintf 721 | # endif 722 | 723 | # define YYDPRINTF(Args) \ 724 | do { \ 725 | if (yydebug) \ 726 | YYFPRINTF Args; \ 727 | } while (0) 728 | 729 | 730 | 731 | 732 | # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 733 | do { \ 734 | if (yydebug) \ 735 | { \ 736 | YYFPRINTF (stderr, "%s ", Title); \ 737 | yy_symbol_print (stderr, \ 738 | Kind, Value); \ 739 | YYFPRINTF (stderr, "\n"); \ 740 | } \ 741 | } while (0) 742 | 743 | 744 | /*-----------------------------------. 745 | | Print this symbol's value on YYO. | 746 | `-----------------------------------*/ 747 | 748 | static void 749 | yy_symbol_value_print (FILE *yyo, 750 | yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 751 | { 752 | FILE *yyoutput = yyo; 753 | YY_USE (yyoutput); 754 | if (!yyvaluep) 755 | return; 756 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 757 | YY_USE (yykind); 758 | YY_IGNORE_MAYBE_UNINITIALIZED_END 759 | } 760 | 761 | 762 | /*---------------------------. 763 | | Print this symbol on YYO. | 764 | `---------------------------*/ 765 | 766 | static void 767 | yy_symbol_print (FILE *yyo, 768 | yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 769 | { 770 | YYFPRINTF (yyo, "%s %s (", 771 | yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 772 | 773 | yy_symbol_value_print (yyo, yykind, yyvaluep); 774 | YYFPRINTF (yyo, ")"); 775 | } 776 | 777 | /*------------------------------------------------------------------. 778 | | yy_stack_print -- Print the state stack from its BOTTOM up to its | 779 | | TOP (included). | 780 | `------------------------------------------------------------------*/ 781 | 782 | static void 783 | yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 784 | { 785 | YYFPRINTF (stderr, "Stack now"); 786 | for (; yybottom <= yytop; yybottom++) 787 | { 788 | int yybot = *yybottom; 789 | YYFPRINTF (stderr, " %d", yybot); 790 | } 791 | YYFPRINTF (stderr, "\n"); 792 | } 793 | 794 | # define YY_STACK_PRINT(Bottom, Top) \ 795 | do { \ 796 | if (yydebug) \ 797 | yy_stack_print ((Bottom), (Top)); \ 798 | } while (0) 799 | 800 | 801 | /*------------------------------------------------. 802 | | Report that the YYRULE is going to be reduced. | 803 | `------------------------------------------------*/ 804 | 805 | static void 806 | yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 807 | int yyrule) 808 | { 809 | int yylno = yyrline[yyrule]; 810 | int yynrhs = yyr2[yyrule]; 811 | int yyi; 812 | YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 813 | yyrule - 1, yylno); 814 | /* The symbols being reduced. */ 815 | for (yyi = 0; yyi < yynrhs; yyi++) 816 | { 817 | YYFPRINTF (stderr, " $%d = ", yyi + 1); 818 | yy_symbol_print (stderr, 819 | YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 820 | &yyvsp[(yyi + 1) - (yynrhs)]); 821 | YYFPRINTF (stderr, "\n"); 822 | } 823 | } 824 | 825 | # define YY_REDUCE_PRINT(Rule) \ 826 | do { \ 827 | if (yydebug) \ 828 | yy_reduce_print (yyssp, yyvsp, Rule); \ 829 | } while (0) 830 | 831 | /* Nonzero means print parse trace. It is left uninitialized so that 832 | multiple parsers can coexist. */ 833 | int yydebug; 834 | #else /* !YYDEBUG */ 835 | # define YYDPRINTF(Args) ((void) 0) 836 | # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 837 | # define YY_STACK_PRINT(Bottom, Top) 838 | # define YY_REDUCE_PRINT(Rule) 839 | #endif /* !YYDEBUG */ 840 | 841 | 842 | /* YYINITDEPTH -- initial size of the parser's stacks. */ 843 | #ifndef YYINITDEPTH 844 | # define YYINITDEPTH 200 845 | #endif 846 | 847 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 848 | if the built-in stack extension method is used). 849 | 850 | Do not make this value too large; the results are undefined if 851 | YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 852 | evaluated with infinite-precision integer arithmetic. */ 853 | 854 | #ifndef YYMAXDEPTH 855 | # define YYMAXDEPTH 10000 856 | #endif 857 | 858 | 859 | 860 | 861 | 862 | 863 | /*-----------------------------------------------. 864 | | Release the memory associated to this symbol. | 865 | `-----------------------------------------------*/ 866 | 867 | static void 868 | yydestruct (const char *yymsg, 869 | yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 870 | { 871 | YY_USE (yyvaluep); 872 | if (!yymsg) 873 | yymsg = "Deleting"; 874 | YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 875 | 876 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 877 | YY_USE (yykind); 878 | YY_IGNORE_MAYBE_UNINITIALIZED_END 879 | } 880 | 881 | 882 | /* Lookahead token kind. */ 883 | int yychar; 884 | 885 | /* The semantic value of the lookahead symbol. */ 886 | YYSTYPE yylval; 887 | /* Number of syntax errors so far. */ 888 | int yynerrs; 889 | 890 | 891 | 892 | 893 | /*----------. 894 | | yyparse. | 895 | `----------*/ 896 | 897 | int 898 | yyparse (void) 899 | { 900 | yy_state_fast_t yystate = 0; 901 | /* Number of tokens to shift before error messages enabled. */ 902 | int yyerrstatus = 0; 903 | 904 | /* Refer to the stacks through separate pointers, to allow yyoverflow 905 | to reallocate them elsewhere. */ 906 | 907 | /* Their size. */ 908 | YYPTRDIFF_T yystacksize = YYINITDEPTH; 909 | 910 | /* The state stack: array, bottom, top. */ 911 | yy_state_t yyssa[YYINITDEPTH]; 912 | yy_state_t *yyss = yyssa; 913 | yy_state_t *yyssp = yyss; 914 | 915 | /* The semantic value stack: array, bottom, top. */ 916 | YYSTYPE yyvsa[YYINITDEPTH]; 917 | YYSTYPE *yyvs = yyvsa; 918 | YYSTYPE *yyvsp = yyvs; 919 | 920 | int yyn; 921 | /* The return value of yyparse. */ 922 | int yyresult; 923 | /* Lookahead symbol kind. */ 924 | yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 925 | /* The variables used to return semantic value and location from the 926 | action routines. */ 927 | YYSTYPE yyval; 928 | 929 | 930 | 931 | #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 932 | 933 | /* The number of symbols on the RHS of the reduced rule. 934 | Keep to zero when no symbol should be popped. */ 935 | int yylen = 0; 936 | 937 | YYDPRINTF ((stderr, "Starting parse\n")); 938 | 939 | yychar = YYEMPTY; /* Cause a token to be read. */ 940 | 941 | goto yysetstate; 942 | 943 | 944 | /*------------------------------------------------------------. 945 | | yynewstate -- push a new state, which is found in yystate. | 946 | `------------------------------------------------------------*/ 947 | yynewstate: 948 | /* In all cases, when you get here, the value and location stacks 949 | have just been pushed. So pushing a state here evens the stacks. */ 950 | yyssp++; 951 | 952 | 953 | /*--------------------------------------------------------------------. 954 | | yysetstate -- set current state (the top of the stack) to yystate. | 955 | `--------------------------------------------------------------------*/ 956 | yysetstate: 957 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 958 | YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 959 | YY_IGNORE_USELESS_CAST_BEGIN 960 | *yyssp = YY_CAST (yy_state_t, yystate); 961 | YY_IGNORE_USELESS_CAST_END 962 | YY_STACK_PRINT (yyss, yyssp); 963 | 964 | if (yyss + yystacksize - 1 <= yyssp) 965 | #if !defined yyoverflow && !defined YYSTACK_RELOCATE 966 | YYNOMEM; 967 | #else 968 | { 969 | /* Get the current used size of the three stacks, in elements. */ 970 | YYPTRDIFF_T yysize = yyssp - yyss + 1; 971 | 972 | # if defined yyoverflow 973 | { 974 | /* Give user a chance to reallocate the stack. Use copies of 975 | these so that the &'s don't force the real ones into 976 | memory. */ 977 | yy_state_t *yyss1 = yyss; 978 | YYSTYPE *yyvs1 = yyvs; 979 | 980 | /* Each stack pointer address is followed by the size of the 981 | data in use in that stack, in bytes. This used to be a 982 | conditional around just the two extra args, but that might 983 | be undefined if yyoverflow is a macro. */ 984 | yyoverflow (YY_("memory exhausted"), 985 | &yyss1, yysize * YYSIZEOF (*yyssp), 986 | &yyvs1, yysize * YYSIZEOF (*yyvsp), 987 | &yystacksize); 988 | yyss = yyss1; 989 | yyvs = yyvs1; 990 | } 991 | # else /* defined YYSTACK_RELOCATE */ 992 | /* Extend the stack our own way. */ 993 | if (YYMAXDEPTH <= yystacksize) 994 | YYNOMEM; 995 | yystacksize *= 2; 996 | if (YYMAXDEPTH < yystacksize) 997 | yystacksize = YYMAXDEPTH; 998 | 999 | { 1000 | yy_state_t *yyss1 = yyss; 1001 | union yyalloc *yyptr = 1002 | YY_CAST (union yyalloc *, 1003 | YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1004 | if (! yyptr) 1005 | YYNOMEM; 1006 | YYSTACK_RELOCATE (yyss_alloc, yyss); 1007 | YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1008 | # undef YYSTACK_RELOCATE 1009 | if (yyss1 != yyssa) 1010 | YYSTACK_FREE (yyss1); 1011 | } 1012 | # endif 1013 | 1014 | yyssp = yyss + yysize - 1; 1015 | yyvsp = yyvs + yysize - 1; 1016 | 1017 | YY_IGNORE_USELESS_CAST_BEGIN 1018 | YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1019 | YY_CAST (long, yystacksize))); 1020 | YY_IGNORE_USELESS_CAST_END 1021 | 1022 | if (yyss + yystacksize - 1 <= yyssp) 1023 | YYABORT; 1024 | } 1025 | #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1026 | 1027 | 1028 | if (yystate == YYFINAL) 1029 | YYACCEPT; 1030 | 1031 | goto yybackup; 1032 | 1033 | 1034 | /*-----------. 1035 | | yybackup. | 1036 | `-----------*/ 1037 | yybackup: 1038 | /* Do appropriate processing given the current state. Read a 1039 | lookahead token if we need one and don't already have one. */ 1040 | 1041 | /* First try to decide what to do without reference to lookahead token. */ 1042 | yyn = yypact[yystate]; 1043 | if (yypact_value_is_default (yyn)) 1044 | goto yydefault; 1045 | 1046 | /* Not known => get a lookahead token if don't already have one. */ 1047 | 1048 | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1049 | if (yychar == YYEMPTY) 1050 | { 1051 | YYDPRINTF ((stderr, "Reading a token\n")); 1052 | yychar = yylex (); 1053 | } 1054 | 1055 | if (yychar <= YYEOF) 1056 | { 1057 | yychar = YYEOF; 1058 | yytoken = YYSYMBOL_YYEOF; 1059 | YYDPRINTF ((stderr, "Now at end of input.\n")); 1060 | } 1061 | else if (yychar == YYerror) 1062 | { 1063 | /* The scanner already issued an error message, process directly 1064 | to error recovery. But do not keep the error token as 1065 | lookahead, it is too special and may lead us to an endless 1066 | loop in error recovery. */ 1067 | yychar = YYUNDEF; 1068 | yytoken = YYSYMBOL_YYerror; 1069 | goto yyerrlab1; 1070 | } 1071 | else 1072 | { 1073 | yytoken = YYTRANSLATE (yychar); 1074 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1075 | } 1076 | 1077 | /* If the proper action on seeing token YYTOKEN is to reduce or to 1078 | detect an error, take that action. */ 1079 | yyn += yytoken; 1080 | if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1081 | goto yydefault; 1082 | yyn = yytable[yyn]; 1083 | if (yyn <= 0) 1084 | { 1085 | if (yytable_value_is_error (yyn)) 1086 | goto yyerrlab; 1087 | yyn = -yyn; 1088 | goto yyreduce; 1089 | } 1090 | 1091 | /* Count tokens shifted since error; after three, turn off error 1092 | status. */ 1093 | if (yyerrstatus) 1094 | yyerrstatus--; 1095 | 1096 | /* Shift the lookahead token. */ 1097 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1098 | yystate = yyn; 1099 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1100 | *++yyvsp = yylval; 1101 | YY_IGNORE_MAYBE_UNINITIALIZED_END 1102 | 1103 | /* Discard the shifted token. */ 1104 | yychar = YYEMPTY; 1105 | goto yynewstate; 1106 | 1107 | 1108 | /*-----------------------------------------------------------. 1109 | | yydefault -- do the default action for the current state. | 1110 | `-----------------------------------------------------------*/ 1111 | yydefault: 1112 | yyn = yydefact[yystate]; 1113 | if (yyn == 0) 1114 | goto yyerrlab; 1115 | goto yyreduce; 1116 | 1117 | 1118 | /*-----------------------------. 1119 | | yyreduce -- do a reduction. | 1120 | `-----------------------------*/ 1121 | yyreduce: 1122 | /* yyn is the number of a rule to reduce with. */ 1123 | yylen = yyr2[yyn]; 1124 | 1125 | /* If YYLEN is nonzero, implement the default value of the action: 1126 | '$$ = $1'. 1127 | 1128 | Otherwise, the following line sets YYVAL to garbage. 1129 | This behavior is undocumented and Bison 1130 | users should not rely upon it. Assigning to YYVAL 1131 | unconditionally makes the parser a bit smaller, and it avoids a 1132 | GCC warning that YYVAL may be used uninitialized. */ 1133 | yyval = yyvsp[1-yylen]; 1134 | 1135 | 1136 | YY_REDUCE_PRINT (yyn); 1137 | switch (yyn) 1138 | { 1139 | case 2: /* netcl: statements */ 1140 | #line 88 "netcl.y" 1141 | { 1142 | cout << "\nFile ready" << endl; 1143 | } 1144 | #line 1145 "netcl.tab.c" 1145 | break; 1146 | 1147 | case 4: /* matchexpr: MATCH LP binaryexpr RP */ 1148 | #line 97 "netcl.y" 1149 | { 1150 | cout << "matchexpr" << endl; 1151 | } 1152 | #line 1153 "netcl.tab.c" 1153 | break; 1154 | 1155 | case 5: /* statement: IF matchexpr THEN action */ 1156 | #line 103 "netcl.y" 1157 | { 1158 | cout << "statement: matchexpr " << endl; 1159 | } 1160 | #line 1161 "netcl.tab.c" 1161 | break; 1162 | 1163 | case 6: /* action: DROP */ 1164 | #line 109 "netcl.y" 1165 | { decision = "1"; cout << "Action: DROP" << endl;} 1166 | #line 1167 "netcl.tab.c" 1167 | break; 1168 | 1169 | case 7: /* action: FWD */ 1170 | #line 110 "netcl.y" 1171 | { decision = "0"; cout << "Action: FWD" << endl;} 1172 | #line 1173 "netcl.tab.c" 1173 | break; 1174 | 1175 | case 8: /* action: MODIFYTTL */ 1176 | #line 111 "netcl.y" 1177 | { decision = "2"; cout << "Action: MODIFYTTL" << endl;} 1178 | #line 1179 "netcl.tab.c" 1179 | break; 1180 | 1181 | case 9: /* action: REROUTE */ 1182 | #line 112 "netcl.y" 1183 | { decision = "3"; cout << "Action: REROUTE" << endl;} 1184 | #line 1185 "netcl.tab.c" 1185 | break; 1186 | 1187 | case 10: /* binaryexpr: VAR binaryop VAR boolop VAR binaryop IP */ 1188 | #line 118 "netcl.y" 1189 | { 1190 | label = (yyvsp[-4].sval); 1191 | dst_ip_address = (yyvsp[0].sval); 1192 | cout << "binary expr" << endl; 1193 | } 1194 | #line 1195 "netcl.tab.c" 1195 | break; 1196 | 1197 | case 11: /* binaryop: CONTAINS */ 1198 | #line 126 "netcl.y" 1199 | {cout << "contains" << endl;} 1200 | #line 1201 "netcl.tab.c" 1201 | break; 1202 | 1203 | case 12: /* binaryop: EQ */ 1204 | #line 127 "netcl.y" 1205 | {cout << "==" << endl;} 1206 | #line 1207 "netcl.tab.c" 1207 | break; 1208 | 1209 | 1210 | #line 1211 "netcl.tab.c" 1211 | 1212 | default: break; 1213 | } 1214 | /* User semantic actions sometimes alter yychar, and that requires 1215 | that yytoken be updated with the new translation. We take the 1216 | approach of translating immediately before every use of yytoken. 1217 | One alternative is translating here after every semantic action, 1218 | but that translation would be missed if the semantic action invokes 1219 | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1220 | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1221 | incorrect destructor might then be invoked immediately. In the 1222 | case of YYERROR or YYBACKUP, subsequent parser actions might lead 1223 | to an incorrect destructor call or verbose syntax error message 1224 | before the lookahead is translated. */ 1225 | YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1226 | 1227 | YYPOPSTACK (yylen); 1228 | yylen = 0; 1229 | 1230 | *++yyvsp = yyval; 1231 | 1232 | /* Now 'shift' the result of the reduction. Determine what state 1233 | that goes to, based on the state we popped back to and the rule 1234 | number reduced by. */ 1235 | { 1236 | const int yylhs = yyr1[yyn] - YYNTOKENS; 1237 | const int yyi = yypgoto[yylhs] + *yyssp; 1238 | yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 1239 | ? yytable[yyi] 1240 | : yydefgoto[yylhs]); 1241 | } 1242 | 1243 | goto yynewstate; 1244 | 1245 | 1246 | /*--------------------------------------. 1247 | | yyerrlab -- here on detecting error. | 1248 | `--------------------------------------*/ 1249 | yyerrlab: 1250 | /* Make sure we have latest lookahead translation. See comments at 1251 | user semantic actions for why this is necessary. */ 1252 | yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 1253 | /* If not already recovering from an error, report this error. */ 1254 | if (!yyerrstatus) 1255 | { 1256 | ++yynerrs; 1257 | yyerror (YY_("syntax error")); 1258 | } 1259 | 1260 | if (yyerrstatus == 3) 1261 | { 1262 | /* If just tried and failed to reuse lookahead token after an 1263 | error, discard it. */ 1264 | 1265 | if (yychar <= YYEOF) 1266 | { 1267 | /* Return failure if at end of input. */ 1268 | if (yychar == YYEOF) 1269 | YYABORT; 1270 | } 1271 | else 1272 | { 1273 | yydestruct ("Error: discarding", 1274 | yytoken, &yylval); 1275 | yychar = YYEMPTY; 1276 | } 1277 | } 1278 | 1279 | /* Else will try to reuse lookahead token after shifting the error 1280 | token. */ 1281 | goto yyerrlab1; 1282 | 1283 | 1284 | /*---------------------------------------------------. 1285 | | yyerrorlab -- error raised explicitly by YYERROR. | 1286 | `---------------------------------------------------*/ 1287 | yyerrorlab: 1288 | /* Pacify compilers when the user code never invokes YYERROR and the 1289 | label yyerrorlab therefore never appears in user code. */ 1290 | if (0) 1291 | YYERROR; 1292 | ++yynerrs; 1293 | 1294 | /* Do not reclaim the symbols of the rule whose action triggered 1295 | this YYERROR. */ 1296 | YYPOPSTACK (yylen); 1297 | yylen = 0; 1298 | YY_STACK_PRINT (yyss, yyssp); 1299 | yystate = *yyssp; 1300 | goto yyerrlab1; 1301 | 1302 | 1303 | /*-------------------------------------------------------------. 1304 | | yyerrlab1 -- common code for both syntax error and YYERROR. | 1305 | `-------------------------------------------------------------*/ 1306 | yyerrlab1: 1307 | yyerrstatus = 3; /* Each real token shifted decrements this. */ 1308 | 1309 | /* Pop stack until we find a state that shifts the error token. */ 1310 | for (;;) 1311 | { 1312 | yyn = yypact[yystate]; 1313 | if (!yypact_value_is_default (yyn)) 1314 | { 1315 | yyn += YYSYMBOL_YYerror; 1316 | if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 1317 | { 1318 | yyn = yytable[yyn]; 1319 | if (0 < yyn) 1320 | break; 1321 | } 1322 | } 1323 | 1324 | /* Pop the current state because it cannot handle the error token. */ 1325 | if (yyssp == yyss) 1326 | YYABORT; 1327 | 1328 | 1329 | yydestruct ("Error: popping", 1330 | YY_ACCESSING_SYMBOL (yystate), yyvsp); 1331 | YYPOPSTACK (1); 1332 | yystate = *yyssp; 1333 | YY_STACK_PRINT (yyss, yyssp); 1334 | } 1335 | 1336 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1337 | *++yyvsp = yylval; 1338 | YY_IGNORE_MAYBE_UNINITIALIZED_END 1339 | 1340 | 1341 | /* Shift the error token. */ 1342 | YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1343 | 1344 | yystate = yyn; 1345 | goto yynewstate; 1346 | 1347 | 1348 | /*-------------------------------------. 1349 | | yyacceptlab -- YYACCEPT comes here. | 1350 | `-------------------------------------*/ 1351 | yyacceptlab: 1352 | yyresult = 0; 1353 | goto yyreturnlab; 1354 | 1355 | 1356 | /*-----------------------------------. 1357 | | yyabortlab -- YYABORT comes here. | 1358 | `-----------------------------------*/ 1359 | yyabortlab: 1360 | yyresult = 1; 1361 | goto yyreturnlab; 1362 | 1363 | 1364 | /*-----------------------------------------------------------. 1365 | | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1366 | `-----------------------------------------------------------*/ 1367 | yyexhaustedlab: 1368 | yyerror (YY_("memory exhausted")); 1369 | yyresult = 2; 1370 | goto yyreturnlab; 1371 | 1372 | 1373 | /*----------------------------------------------------------. 1374 | | yyreturnlab -- parsing is finished, clean up and return. | 1375 | `----------------------------------------------------------*/ 1376 | yyreturnlab: 1377 | if (yychar != YYEMPTY) 1378 | { 1379 | /* Make sure we have latest lookahead translation. See comments at 1380 | user semantic actions for why this is necessary. */ 1381 | yytoken = YYTRANSLATE (yychar); 1382 | yydestruct ("Cleanup: discarding lookahead", 1383 | yytoken, &yylval); 1384 | } 1385 | /* Do not reclaim the symbols of the rule whose action triggered 1386 | this YYABORT or YYACCEPT. */ 1387 | YYPOPSTACK (yylen); 1388 | YY_STACK_PRINT (yyss, yyssp); 1389 | while (yyssp != yyss) 1390 | { 1391 | yydestruct ("Cleanup: popping", 1392 | YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 1393 | YYPOPSTACK (1); 1394 | } 1395 | #ifndef yyoverflow 1396 | if (yyss != yyssa) 1397 | YYSTACK_FREE (yyss); 1398 | #endif 1399 | 1400 | return yyresult; 1401 | } 1402 | 1403 | #line 133 "netcl.y" 1404 | 1405 | 1406 | static void usage() 1407 | { 1408 | fprintf(stderr, "To complie NetCL rules: ./netcl-compile -i -o \n"); 1409 | } 1410 | 1411 | // helper function: find+replace string in a string 1412 | void ReplaceStringInPlace(std::string& subject, const std::string& search, 1413 | const std::string& replace) 1414 | { 1415 | size_t pos = 0; 1416 | while ((pos = subject.find(search, pos)) != std::string::npos) { 1417 | subject.replace(pos, search.length(), replace); 1418 | pos += replace.length(); 1419 | } 1420 | } 1421 | 1422 | int generate_policy(string file_name) 1423 | { 1424 | ofstream policy(file_name); 1425 | int ret; 1426 | string rule_output; 1427 | 1428 | ifstream f("./templates/table_2_template.py"); 1429 | string original_template((std::istreambuf_iterator(f)), 1430 | (std::istreambuf_iterator())); 1431 | rule_output = original_template; 1432 | /* ReplaceStringInPlace(rule_output, "SRC_IP", check->src_ip); */ 1433 | ReplaceStringInPlace(rule_output, "LABEL", label); 1434 | ReplaceStringInPlace(rule_output, "DST_IP", dst_ip_address); 1435 | ReplaceStringInPlace(rule_output, "DEC", decision); 1436 | policy << rule_output << endl; 1437 | rule_output = ""; 1438 | cout << "finish generate" << endl; 1439 | return 0; 1440 | } 1441 | 1442 | int main(int argc, char *argv[]) { 1443 | int opt; 1444 | char *policy_file = NULL; 1445 | char *output_file = NULL; 1446 | 1447 | // parse arguments 1448 | while ((opt = getopt(argc, argv, "i:o:")) != -1) { 1449 | switch (opt) { 1450 | case 'i': 1451 | policy_file = optarg; 1452 | break; 1453 | case 'o': 1454 | output_file = optarg; 1455 | break; 1456 | default: 1457 | usage(); 1458 | exit(1); 1459 | } 1460 | } 1461 | 1462 | if (policy_file == NULL || output_file == NULL) { 1463 | usage(); 1464 | exit(1); 1465 | } 1466 | 1467 | // open the policy file 1468 | FILE *fp = fopen(policy_file, "r"); 1469 | if (fp == NULL) { 1470 | fprintf(stderr, "failed to open policy file %s", policy_file); 1471 | return 1; 1472 | } 1473 | 1474 | // set flex to read from it instead of defaulting to STDIN: 1475 | yyin = fp; 1476 | 1477 | // parse through the input until there is no more: 1478 | do { 1479 | yyparse(); 1480 | } while (!feof(yyin)); 1481 | 1482 | //Pushing soon compiling multiple policies and multiple table templates 1483 | generate_policy(output_file); 1484 | 1485 | return 0; 1486 | } 1487 | 1488 | 1489 | 1490 | void yyerror(const char *s) 1491 | { 1492 | cout << "Parse error! Message: " << s << endl; 1493 | exit(-1); 1494 | } 1495 | -------------------------------------------------------------------------------- /compiler/lex.yy.c: -------------------------------------------------------------------------------- 1 | 2 | #line 2 "lex.yy.c" 3 | 4 | #define YY_INT_ALIGNED short int 5 | 6 | /* A lexical scanner generated by flex */ 7 | 8 | #define FLEX_SCANNER 9 | #define YY_FLEX_MAJOR_VERSION 2 10 | #define YY_FLEX_MINOR_VERSION 6 11 | #define YY_FLEX_SUBMINOR_VERSION 4 12 | #if YY_FLEX_SUBMINOR_VERSION > 0 13 | #define FLEX_BETA 14 | #endif 15 | 16 | /* First, we deal with platform-specific or compiler-specific issues. */ 17 | 18 | /* begin standard C headers. */ 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | /* end standard C headers. */ 25 | 26 | /* flex integer type definitions */ 27 | 28 | #ifndef FLEXINT_H 29 | #define FLEXINT_H 30 | 31 | /* C99 systems have . Non-C99 systems may or may not. */ 32 | 33 | #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 34 | 35 | /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 36 | * if you want the limit (max/min) macros for int types. 37 | */ 38 | #ifndef __STDC_LIMIT_MACROS 39 | #define __STDC_LIMIT_MACROS 1 40 | #endif 41 | 42 | #include 43 | typedef int8_t flex_int8_t; 44 | typedef uint8_t flex_uint8_t; 45 | typedef int16_t flex_int16_t; 46 | typedef uint16_t flex_uint16_t; 47 | typedef int32_t flex_int32_t; 48 | typedef uint32_t flex_uint32_t; 49 | #else 50 | typedef signed char flex_int8_t; 51 | typedef short int flex_int16_t; 52 | typedef int flex_int32_t; 53 | typedef unsigned char flex_uint8_t; 54 | typedef unsigned short int flex_uint16_t; 55 | typedef unsigned int flex_uint32_t; 56 | 57 | /* Limits of integral types. */ 58 | #ifndef INT8_MIN 59 | #define INT8_MIN (-128) 60 | #endif 61 | #ifndef INT16_MIN 62 | #define INT16_MIN (-32767-1) 63 | #endif 64 | #ifndef INT32_MIN 65 | #define INT32_MIN (-2147483647-1) 66 | #endif 67 | #ifndef INT8_MAX 68 | #define INT8_MAX (127) 69 | #endif 70 | #ifndef INT16_MAX 71 | #define INT16_MAX (32767) 72 | #endif 73 | #ifndef INT32_MAX 74 | #define INT32_MAX (2147483647) 75 | #endif 76 | #ifndef UINT8_MAX 77 | #define UINT8_MAX (255U) 78 | #endif 79 | #ifndef UINT16_MAX 80 | #define UINT16_MAX (65535U) 81 | #endif 82 | #ifndef UINT32_MAX 83 | #define UINT32_MAX (4294967295U) 84 | #endif 85 | 86 | #ifndef SIZE_MAX 87 | #define SIZE_MAX (~(size_t)0) 88 | #endif 89 | 90 | #endif /* ! C99 */ 91 | 92 | #endif /* ! FLEXINT_H */ 93 | 94 | /* begin standard C++ headers. */ 95 | 96 | /* TODO: this is always defined, so inline it */ 97 | #define yyconst const 98 | 99 | #if defined(__GNUC__) && __GNUC__ >= 3 100 | #define yynoreturn __attribute__((__noreturn__)) 101 | #else 102 | #define yynoreturn 103 | #endif 104 | 105 | /* Returned upon end-of-file. */ 106 | #define YY_NULL 0 107 | 108 | /* Promotes a possibly negative, possibly signed char to an 109 | * integer in range [0..255] for use as an array index. 110 | */ 111 | #define YY_SC_TO_UI(c) ((YY_CHAR) (c)) 112 | 113 | /* Enter a start condition. This macro really ought to take a parameter, 114 | * but we do it the disgusting crufty way forced on us by the ()-less 115 | * definition of BEGIN. 116 | */ 117 | #define BEGIN (yy_start) = 1 + 2 * 118 | /* Translate the current start state into a value that can be later handed 119 | * to BEGIN to return to the state. The YYSTATE alias is for lex 120 | * compatibility. 121 | */ 122 | #define YY_START (((yy_start) - 1) / 2) 123 | #define YYSTATE YY_START 124 | /* Action number for EOF rule of a given start state. */ 125 | #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 126 | /* Special action meaning "start processing a new file". */ 127 | #define YY_NEW_FILE yyrestart( yyin ) 128 | #define YY_END_OF_BUFFER_CHAR 0 129 | 130 | /* Size of default input buffer. */ 131 | #ifndef YY_BUF_SIZE 132 | #ifdef __ia64__ 133 | /* On IA-64, the buffer size is 16k, not 8k. 134 | * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. 135 | * Ditto for the __ia64__ case accordingly. 136 | */ 137 | #define YY_BUF_SIZE 32768 138 | #else 139 | #define YY_BUF_SIZE 16384 140 | #endif /* __ia64__ */ 141 | #endif 142 | 143 | /* The state buf must be large enough to hold one state per character in the main buffer. 144 | */ 145 | #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 146 | 147 | #ifndef YY_TYPEDEF_YY_BUFFER_STATE 148 | #define YY_TYPEDEF_YY_BUFFER_STATE 149 | typedef struct yy_buffer_state *YY_BUFFER_STATE; 150 | #endif 151 | 152 | #ifndef YY_TYPEDEF_YY_SIZE_T 153 | #define YY_TYPEDEF_YY_SIZE_T 154 | typedef size_t yy_size_t; 155 | #endif 156 | 157 | extern int yyleng; 158 | 159 | extern FILE *yyin, *yyout; 160 | 161 | #define EOB_ACT_CONTINUE_SCAN 0 162 | #define EOB_ACT_END_OF_FILE 1 163 | #define EOB_ACT_LAST_MATCH 2 164 | 165 | #define YY_LESS_LINENO(n) 166 | #define YY_LINENO_REWIND_TO(ptr) 167 | 168 | /* Return all but the first "n" matched characters back to the input stream. */ 169 | #define yyless(n) \ 170 | do \ 171 | { \ 172 | /* Undo effects of setting up yytext. */ \ 173 | int yyless_macro_arg = (n); \ 174 | YY_LESS_LINENO(yyless_macro_arg);\ 175 | *yy_cp = (yy_hold_char); \ 176 | YY_RESTORE_YY_MORE_OFFSET \ 177 | (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 178 | YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 179 | } \ 180 | while ( 0 ) 181 | #define unput(c) yyunput( c, (yytext_ptr) ) 182 | 183 | #ifndef YY_STRUCT_YY_BUFFER_STATE 184 | #define YY_STRUCT_YY_BUFFER_STATE 185 | struct yy_buffer_state 186 | { 187 | FILE *yy_input_file; 188 | 189 | char *yy_ch_buf; /* input buffer */ 190 | char *yy_buf_pos; /* current position in input buffer */ 191 | 192 | /* Size of input buffer in bytes, not including room for EOB 193 | * characters. 194 | */ 195 | int yy_buf_size; 196 | 197 | /* Number of characters read into yy_ch_buf, not including EOB 198 | * characters. 199 | */ 200 | int yy_n_chars; 201 | 202 | /* Whether we "own" the buffer - i.e., we know we created it, 203 | * and can realloc() it to grow it, and should free() it to 204 | * delete it. 205 | */ 206 | int yy_is_our_buffer; 207 | 208 | /* Whether this is an "interactive" input source; if so, and 209 | * if we're using stdio for input, then we want to use getc() 210 | * instead of fread(), to make sure we stop fetching input after 211 | * each newline. 212 | */ 213 | int yy_is_interactive; 214 | 215 | /* Whether we're considered to be at the beginning of a line. 216 | * If so, '^' rules will be active on the next match, otherwise 217 | * not. 218 | */ 219 | int yy_at_bol; 220 | 221 | int yy_bs_lineno; /**< The line count. */ 222 | int yy_bs_column; /**< The column count. */ 223 | 224 | /* Whether to try to fill the input buffer when we reach the 225 | * end of it. 226 | */ 227 | int yy_fill_buffer; 228 | 229 | int yy_buffer_status; 230 | 231 | #define YY_BUFFER_NEW 0 232 | #define YY_BUFFER_NORMAL 1 233 | /* When an EOF's been seen but there's still some text to process 234 | * then we mark the buffer as YY_EOF_PENDING, to indicate that we 235 | * shouldn't try reading from the input source any more. We might 236 | * still have a bunch of tokens to match, though, because of 237 | * possible backing-up. 238 | * 239 | * When we actually see the EOF, we change the status to "new" 240 | * (via yyrestart()), so that the user can continue scanning by 241 | * just pointing yyin at a new input file. 242 | */ 243 | #define YY_BUFFER_EOF_PENDING 2 244 | 245 | }; 246 | #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 247 | 248 | /* Stack of input buffers. */ 249 | static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 250 | static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 251 | static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ 252 | 253 | /* We provide macros for accessing buffer states in case in the 254 | * future we want to put the buffer states in a more general 255 | * "scanner state". 256 | * 257 | * Returns the top of the stack, or NULL. 258 | */ 259 | #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 260 | ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 261 | : NULL) 262 | /* Same as previous macro, but useful when we know that the buffer stack is not 263 | * NULL or when we need an lvalue. For internal use only. 264 | */ 265 | #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 266 | 267 | /* yy_hold_char holds the character lost when yytext is formed. */ 268 | static char yy_hold_char; 269 | static int yy_n_chars; /* number of characters read into yy_ch_buf */ 270 | int yyleng; 271 | 272 | /* Points to current character in buffer. */ 273 | static char *yy_c_buf_p = NULL; 274 | static int yy_init = 0; /* whether we need to initialize */ 275 | static int yy_start = 0; /* start state number */ 276 | 277 | /* Flag which is used to allow yywrap()'s to do buffer switches 278 | * instead of setting up a fresh yyin. A bit of a hack ... 279 | */ 280 | static int yy_did_buffer_switch_on_eof; 281 | 282 | void yyrestart ( FILE *input_file ); 283 | void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); 284 | YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); 285 | void yy_delete_buffer ( YY_BUFFER_STATE b ); 286 | void yy_flush_buffer ( YY_BUFFER_STATE b ); 287 | void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); 288 | void yypop_buffer_state ( void ); 289 | 290 | static void yyensure_buffer_stack ( void ); 291 | static void yy_load_buffer_state ( void ); 292 | static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); 293 | #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) 294 | 295 | YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); 296 | YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); 297 | YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); 298 | 299 | void *yyalloc ( yy_size_t ); 300 | void *yyrealloc ( void *, yy_size_t ); 301 | void yyfree ( void * ); 302 | 303 | #define yy_new_buffer yy_create_buffer 304 | #define yy_set_interactive(is_interactive) \ 305 | { \ 306 | if ( ! YY_CURRENT_BUFFER ){ \ 307 | yyensure_buffer_stack (); \ 308 | YY_CURRENT_BUFFER_LVALUE = \ 309 | yy_create_buffer( yyin, YY_BUF_SIZE ); \ 310 | } \ 311 | YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 312 | } 313 | #define yy_set_bol(at_bol) \ 314 | { \ 315 | if ( ! YY_CURRENT_BUFFER ){\ 316 | yyensure_buffer_stack (); \ 317 | YY_CURRENT_BUFFER_LVALUE = \ 318 | yy_create_buffer( yyin, YY_BUF_SIZE ); \ 319 | } \ 320 | YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 321 | } 322 | #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 323 | 324 | /* Begin user sect3 */ 325 | typedef flex_uint8_t YY_CHAR; 326 | 327 | FILE *yyin = NULL, *yyout = NULL; 328 | 329 | typedef int yy_state_type; 330 | 331 | extern int yylineno; 332 | int yylineno = 1; 333 | 334 | extern char *yytext; 335 | #ifdef yytext_ptr 336 | #undef yytext_ptr 337 | #endif 338 | #define yytext_ptr yytext 339 | 340 | static yy_state_type yy_get_previous_state ( void ); 341 | static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); 342 | static int yy_get_next_buffer ( void ); 343 | static void yynoreturn yy_fatal_error ( const char* msg ); 344 | 345 | /* Done after the current pattern has been matched and before the 346 | * corresponding action - sets up yytext. 347 | */ 348 | #define YY_DO_BEFORE_ACTION \ 349 | (yytext_ptr) = yy_bp; \ 350 | yyleng = (int) (yy_cp - yy_bp); \ 351 | (yy_hold_char) = *yy_cp; \ 352 | *yy_cp = '\0'; \ 353 | (yy_c_buf_p) = yy_cp; 354 | #define YY_NUM_RULES 23 355 | #define YY_END_OF_BUFFER 24 356 | /* This struct is not used in this scanner, 357 | but its presence is necessary. */ 358 | struct yy_trans_info 359 | { 360 | flex_int32_t yy_verify; 361 | flex_int32_t yy_nxt; 362 | }; 363 | static const flex_int16_t yy_accept[77] = 364 | { 0, 365 | 0, 0, 24, 22, 18, 18, 22, 22, 14, 15, 366 | 22, 20, 22, 21, 21, 21, 21, 21, 21, 21, 367 | 21, 21, 21, 21, 0, 17, 1, 20, 21, 16, 368 | 21, 21, 21, 21, 21, 21, 2, 21, 21, 21, 369 | 21, 21, 19, 1, 21, 6, 21, 8, 21, 10, 370 | 21, 21, 21, 21, 21, 21, 21, 4, 21, 21, 371 | 21, 21, 3, 5, 21, 12, 21, 21, 7, 21, 372 | 9, 21, 21, 11, 13, 0 373 | } ; 374 | 375 | static const YY_CHAR yy_ec[256] = 376 | { 0, 377 | 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 378 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 379 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 380 | 1, 2, 1, 4, 1, 1, 1, 5, 1, 6, 381 | 7, 1, 1, 1, 1, 8, 9, 10, 10, 10, 382 | 10, 10, 10, 10, 10, 10, 10, 1, 1, 1, 383 | 11, 1, 1, 1, 12, 12, 12, 12, 12, 12, 384 | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 385 | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 386 | 1, 1, 1, 1, 1, 1, 13, 14, 15, 16, 387 | 388 | 17, 18, 12, 19, 20, 12, 12, 21, 22, 23, 389 | 24, 25, 12, 26, 27, 28, 29, 30, 31, 12, 390 | 32, 12, 1, 1, 1, 1, 1, 1, 1, 1, 391 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 392 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 393 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 394 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 395 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 396 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 397 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 398 | 399 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 400 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 401 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 402 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 403 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 404 | 1, 1, 1, 1, 1 405 | } ; 406 | 407 | static const YY_CHAR yy_meta[33] = 408 | { 0, 409 | 1, 1, 2, 1, 1, 1, 1, 1, 1, 3, 410 | 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 411 | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 412 | 3, 3 413 | } ; 414 | 415 | static const flex_int16_t yy_base[79] = 416 | { 0, 417 | 0, 0, 89, 90, 90, 90, 25, 83, 90, 90, 418 | 78, 76, 74, 0, 63, 59, 58, 17, 50, 62, 419 | 23, 62, 65, 58, 34, 90, 0, 66, 0, 90, 420 | 55, 60, 50, 42, 47, 54, 0, 41, 52, 41, 421 | 45, 48, 90, 0, 49, 0, 35, 0, 37, 0, 422 | 46, 40, 35, 41, 34, 39, 42, 0, 35, 35, 423 | 23, 24, 0, 0, 29, 0, 14, 17, 0, 18, 424 | 0, 23, 12, 0, 0, 90, 34, 47 425 | } ; 426 | 427 | static const flex_int16_t yy_def[79] = 428 | { 0, 429 | 76, 1, 76, 76, 76, 76, 76, 76, 76, 76, 430 | 76, 77, 76, 77, 77, 77, 77, 77, 77, 77, 431 | 77, 77, 77, 77, 76, 76, 78, 77, 77, 76, 432 | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 433 | 77, 77, 76, 78, 77, 77, 77, 77, 77, 77, 434 | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 435 | 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 436 | 77, 77, 77, 77, 77, 0, 76, 76 437 | } ; 438 | 439 | static const flex_int16_t yy_nxt[123] = 440 | { 0, 441 | 4, 5, 6, 7, 8, 9, 10, 4, 11, 12, 442 | 13, 14, 15, 16, 17, 18, 14, 19, 14, 20, 443 | 14, 21, 14, 14, 14, 22, 23, 24, 14, 14, 444 | 14, 14, 25, 34, 25, 38, 29, 43, 75, 74, 445 | 73, 25, 35, 25, 72, 71, 39, 44, 70, 44, 446 | 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 447 | 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 448 | 49, 48, 47, 46, 45, 28, 42, 41, 40, 37, 449 | 36, 33, 32, 31, 30, 28, 27, 26, 76, 3, 450 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 451 | 452 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 453 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 454 | 76, 76 455 | } ; 456 | 457 | static const flex_int16_t yy_chk[123] = 458 | { 0, 459 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 460 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 461 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 462 | 1, 1, 7, 18, 7, 21, 77, 25, 73, 72, 463 | 70, 25, 18, 25, 68, 67, 21, 78, 65, 78, 464 | 62, 61, 60, 59, 57, 56, 55, 54, 53, 52, 465 | 51, 49, 47, 45, 42, 41, 40, 39, 38, 36, 466 | 35, 34, 33, 32, 31, 28, 24, 23, 22, 20, 467 | 19, 17, 16, 15, 13, 12, 11, 8, 3, 76, 468 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 469 | 470 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 471 | 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 472 | 76, 76 473 | } ; 474 | 475 | static yy_state_type yy_last_accepting_state; 476 | static char *yy_last_accepting_cpos; 477 | 478 | extern int yy_flex_debug; 479 | int yy_flex_debug = 0; 480 | 481 | /* The intent behind this definition is that it'll catch 482 | * any uses of REJECT which flex missed. 483 | */ 484 | #define REJECT reject_used_but_not_detected 485 | #define yymore() yymore_used_but_not_detected 486 | #define YY_MORE_ADJ 0 487 | #define YY_RESTORE_YY_MORE_OFFSET 488 | char *yytext; 489 | #line 1 "netcl.l" 490 | #line 2 "netcl.l" 491 | #include 492 | #include 493 | #include 494 | #include 495 | #include 496 | #include 497 | 498 | using namespace std; 499 | #define YY_DECL extern "C" int yylex() 500 | 501 | #include "netcl.tab.h" 502 | // support tags 0-Alice 1-Bob 2-Sales 3-Dev 503 | #line 503 "lex.yy.c" 504 | #line 504 "lex.yy.c" 505 | 506 | #define INITIAL 0 507 | 508 | #ifndef YY_NO_UNISTD_H 509 | /* Special case for "unistd.h", since it is non-ANSI. We include it way 510 | * down here because we want the user's section 1 to have been scanned first. 511 | * The user has a chance to override it with an option. 512 | */ 513 | #include 514 | #endif 515 | 516 | #ifndef YY_EXTRA_TYPE 517 | #define YY_EXTRA_TYPE void * 518 | #endif 519 | 520 | static int yy_init_globals ( void ); 521 | 522 | /* Accessor methods to globals. 523 | These are made visible to non-reentrant scanners for convenience. */ 524 | 525 | int yylex_destroy ( void ); 526 | 527 | int yyget_debug ( void ); 528 | 529 | void yyset_debug ( int debug_flag ); 530 | 531 | YY_EXTRA_TYPE yyget_extra ( void ); 532 | 533 | void yyset_extra ( YY_EXTRA_TYPE user_defined ); 534 | 535 | FILE *yyget_in ( void ); 536 | 537 | void yyset_in ( FILE * _in_str ); 538 | 539 | FILE *yyget_out ( void ); 540 | 541 | void yyset_out ( FILE * _out_str ); 542 | 543 | int yyget_leng ( void ); 544 | 545 | char *yyget_text ( void ); 546 | 547 | int yyget_lineno ( void ); 548 | 549 | void yyset_lineno ( int _line_number ); 550 | 551 | /* Macros after this point can all be overridden by user definitions in 552 | * section 1. 553 | */ 554 | 555 | #ifndef YY_SKIP_YYWRAP 556 | #ifdef __cplusplus 557 | extern "C" int yywrap ( void ); 558 | #else 559 | extern int yywrap ( void ); 560 | #endif 561 | #endif 562 | 563 | #ifndef YY_NO_UNPUT 564 | 565 | static void yyunput ( int c, char *buf_ptr ); 566 | 567 | #endif 568 | 569 | #ifndef yytext_ptr 570 | static void yy_flex_strncpy ( char *, const char *, int ); 571 | #endif 572 | 573 | #ifdef YY_NEED_STRLEN 574 | static int yy_flex_strlen ( const char * ); 575 | #endif 576 | 577 | #ifndef YY_NO_INPUT 578 | #ifdef __cplusplus 579 | static int yyinput ( void ); 580 | #else 581 | static int input ( void ); 582 | #endif 583 | 584 | #endif 585 | 586 | /* Amount of stuff to slurp up with each read. */ 587 | #ifndef YY_READ_BUF_SIZE 588 | #ifdef __ia64__ 589 | /* On IA-64, the buffer size is 16k, not 8k */ 590 | #define YY_READ_BUF_SIZE 16384 591 | #else 592 | #define YY_READ_BUF_SIZE 8192 593 | #endif /* __ia64__ */ 594 | #endif 595 | 596 | /* Copy whatever the last rule matched to the standard output. */ 597 | #ifndef ECHO 598 | /* This used to be an fputs(), but since the string might contain NUL's, 599 | * we now use fwrite(). 600 | */ 601 | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) 602 | #endif 603 | 604 | /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 605 | * is returned in "result". 606 | */ 607 | #ifndef YY_INPUT 608 | #define YY_INPUT(buf,result,max_size) \ 609 | if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 610 | { \ 611 | int c = '*'; \ 612 | int n; \ 613 | for ( n = 0; n < max_size && \ 614 | (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 615 | buf[n] = (char) c; \ 616 | if ( c == '\n' ) \ 617 | buf[n++] = (char) c; \ 618 | if ( c == EOF && ferror( yyin ) ) \ 619 | YY_FATAL_ERROR( "input in flex scanner failed" ); \ 620 | result = n; \ 621 | } \ 622 | else \ 623 | { \ 624 | errno=0; \ 625 | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ 626 | { \ 627 | if( errno != EINTR) \ 628 | { \ 629 | YY_FATAL_ERROR( "input in flex scanner failed" ); \ 630 | break; \ 631 | } \ 632 | errno=0; \ 633 | clearerr(yyin); \ 634 | } \ 635 | }\ 636 | \ 637 | 638 | #endif 639 | 640 | /* No semi-colon after return; correct usage is to write "yyterminate();" - 641 | * we don't want an extra ';' after the "return" because that will cause 642 | * some compilers to complain about unreachable statements. 643 | */ 644 | #ifndef yyterminate 645 | #define yyterminate() return YY_NULL 646 | #endif 647 | 648 | /* Number of entries by which start-condition stack grows. */ 649 | #ifndef YY_START_STACK_INCR 650 | #define YY_START_STACK_INCR 25 651 | #endif 652 | 653 | /* Report a fatal error. */ 654 | #ifndef YY_FATAL_ERROR 655 | #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 656 | #endif 657 | 658 | /* end tables serialization structures and prototypes */ 659 | 660 | /* Default declaration of generated scanner - a define so the user can 661 | * easily add parameters. 662 | */ 663 | #ifndef YY_DECL 664 | #define YY_DECL_IS_OURS 1 665 | 666 | extern int yylex (void); 667 | 668 | #define YY_DECL int yylex (void) 669 | #endif /* !YY_DECL */ 670 | 671 | /* Code executed at the beginning of each rule, after yytext and yyleng 672 | * have been set up. 673 | */ 674 | #ifndef YY_USER_ACTION 675 | #define YY_USER_ACTION 676 | #endif 677 | 678 | /* Code executed at the end of each rule. */ 679 | #ifndef YY_BREAK 680 | #define YY_BREAK /*LINTED*/break; 681 | #endif 682 | 683 | #define YY_RULE_SETUP \ 684 | YY_USER_ACTION 685 | 686 | /** The main scanner function which does all the work. 687 | */ 688 | YY_DECL 689 | { 690 | yy_state_type yy_current_state; 691 | char *yy_cp, *yy_bp; 692 | int yy_act; 693 | 694 | if ( !(yy_init) ) 695 | { 696 | (yy_init) = 1; 697 | 698 | #ifdef YY_USER_INIT 699 | YY_USER_INIT; 700 | #endif 701 | 702 | if ( ! (yy_start) ) 703 | (yy_start) = 1; /* first start state */ 704 | 705 | if ( ! yyin ) 706 | yyin = stdin; 707 | 708 | if ( ! yyout ) 709 | yyout = stdout; 710 | 711 | if ( ! YY_CURRENT_BUFFER ) { 712 | yyensure_buffer_stack (); 713 | YY_CURRENT_BUFFER_LVALUE = 714 | yy_create_buffer( yyin, YY_BUF_SIZE ); 715 | } 716 | 717 | yy_load_buffer_state( ); 718 | } 719 | 720 | { 721 | #line 15 "netcl.l" 722 | 723 | #line 723 "lex.yy.c" 724 | 725 | while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ 726 | { 727 | yy_cp = (yy_c_buf_p); 728 | 729 | /* Support of yytext. */ 730 | *yy_cp = (yy_hold_char); 731 | 732 | /* yy_bp points to the position in yy_ch_buf of the start of 733 | * the current run. 734 | */ 735 | yy_bp = yy_cp; 736 | 737 | yy_current_state = (yy_start); 738 | yy_match: 739 | do 740 | { 741 | YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; 742 | if ( yy_accept[yy_current_state] ) 743 | { 744 | (yy_last_accepting_state) = yy_current_state; 745 | (yy_last_accepting_cpos) = yy_cp; 746 | } 747 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 748 | { 749 | yy_current_state = (int) yy_def[yy_current_state]; 750 | if ( yy_current_state >= 77 ) 751 | yy_c = yy_meta[yy_c]; 752 | } 753 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 754 | ++yy_cp; 755 | } 756 | while ( yy_base[yy_current_state] != 90 ); 757 | 758 | yy_find_action: 759 | yy_act = yy_accept[yy_current_state]; 760 | if ( yy_act == 0 ) 761 | { /* have to back up */ 762 | yy_cp = (yy_last_accepting_cpos); 763 | yy_current_state = (yy_last_accepting_state); 764 | yy_act = yy_accept[yy_current_state]; 765 | } 766 | 767 | YY_DO_BEFORE_ACTION; 768 | 769 | do_action: /* This label is used only to access EOF actions. */ 770 | 771 | switch ( yy_act ) 772 | { /* beginning of action switch */ 773 | case 0: /* must back up */ 774 | /* undo the effects of YY_DO_BEFORE_ACTION */ 775 | *yy_cp = (yy_hold_char); 776 | yy_cp = (yy_last_accepting_cpos); 777 | yy_current_state = (yy_last_accepting_state); 778 | goto yy_find_action; 779 | 780 | case 1: 781 | YY_RULE_SETUP 782 | #line 16 "netcl.l" 783 | {/* comment */ } 784 | YY_BREAK 785 | case 2: 786 | YY_RULE_SETUP 787 | #line 17 "netcl.l" 788 | { return IF; } 789 | YY_BREAK 790 | case 3: 791 | YY_RULE_SETUP 792 | #line 18 "netcl.l" 793 | { return THEN; } 794 | YY_BREAK 795 | case 4: 796 | YY_RULE_SETUP 797 | #line 19 "netcl.l" 798 | { return DROP; } 799 | YY_BREAK 800 | case 5: 801 | YY_RULE_SETUP 802 | #line 20 "netcl.l" 803 | { return ALICE; } 804 | YY_BREAK 805 | case 6: 806 | YY_RULE_SETUP 807 | #line 21 "netcl.l" 808 | { return BOB; } 809 | YY_BREAK 810 | case 7: 811 | YY_RULE_SETUP 812 | #line 22 "netcl.l" 813 | { return SALES; } 814 | YY_BREAK 815 | case 8: 816 | YY_RULE_SETUP 817 | #line 23 "netcl.l" 818 | { return DEV; } 819 | YY_BREAK 820 | case 9: 821 | YY_RULE_SETUP 822 | #line 24 "netcl.l" 823 | { return MODIFYTTL; } 824 | YY_BREAK 825 | case 10: 826 | YY_RULE_SETUP 827 | #line 25 "netcl.l" 828 | { return FWD; } 829 | YY_BREAK 830 | case 11: 831 | YY_RULE_SETUP 832 | #line 26 "netcl.l" 833 | { return REROUTE; } 834 | YY_BREAK 835 | case 12: 836 | YY_RULE_SETUP 837 | #line 27 "netcl.l" 838 | { return MATCH; } 839 | YY_BREAK 840 | case 13: 841 | YY_RULE_SETUP 842 | #line 28 "netcl.l" 843 | { return CONTAINS; } 844 | YY_BREAK 845 | case 14: 846 | YY_RULE_SETUP 847 | #line 29 "netcl.l" 848 | { return LP; } 849 | YY_BREAK 850 | case 15: 851 | YY_RULE_SETUP 852 | #line 30 "netcl.l" 853 | { return RP; } 854 | YY_BREAK 855 | case 16: 856 | YY_RULE_SETUP 857 | #line 31 "netcl.l" 858 | { return EQ; } 859 | YY_BREAK 860 | case 17: 861 | YY_RULE_SETUP 862 | #line 32 "netcl.l" 863 | { return AND; } 864 | YY_BREAK 865 | case 18: 866 | /* rule 18 can match eol */ 867 | YY_RULE_SETUP 868 | #line 33 "netcl.l" 869 | ; 870 | YY_BREAK 871 | case 19: 872 | YY_RULE_SETUP 873 | #line 34 "netcl.l" 874 | { yylval.sval = strdup(yytext); return IP; } 875 | YY_BREAK 876 | case 20: 877 | YY_RULE_SETUP 878 | #line 35 "netcl.l" 879 | { yylval.ival = atoi(yytext); return CONST; } 880 | YY_BREAK 881 | case 21: 882 | YY_RULE_SETUP 883 | #line 36 "netcl.l" 884 | { 885 | yylval.sval = strdup(yytext); 886 | return VAR; 887 | } 888 | YY_BREAK 889 | case 22: 890 | YY_RULE_SETUP 891 | #line 40 "netcl.l" 892 | ; 893 | YY_BREAK 894 | case 23: 895 | YY_RULE_SETUP 896 | #line 41 "netcl.l" 897 | ECHO; 898 | YY_BREAK 899 | #line 899 "lex.yy.c" 900 | case YY_STATE_EOF(INITIAL): 901 | yyterminate(); 902 | 903 | case YY_END_OF_BUFFER: 904 | { 905 | /* Amount of text matched not including the EOB char. */ 906 | int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 907 | 908 | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 909 | *yy_cp = (yy_hold_char); 910 | YY_RESTORE_YY_MORE_OFFSET 911 | 912 | if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 913 | { 914 | /* We're scanning a new file or input source. It's 915 | * possible that this happened because the user 916 | * just pointed yyin at a new source and called 917 | * yylex(). If so, then we have to assure 918 | * consistency between YY_CURRENT_BUFFER and our 919 | * globals. Here is the right place to do so, because 920 | * this is the first action (other than possibly a 921 | * back-up) that will match for the new input source. 922 | */ 923 | (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 924 | YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 925 | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 926 | } 927 | 928 | /* Note that here we test for yy_c_buf_p "<=" to the position 929 | * of the first EOB in the buffer, since yy_c_buf_p will 930 | * already have been incremented past the NUL character 931 | * (since all states make transitions on EOB to the 932 | * end-of-buffer state). Contrast this with the test 933 | * in input(). 934 | */ 935 | if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 936 | { /* This was really a NUL. */ 937 | yy_state_type yy_next_state; 938 | 939 | (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 940 | 941 | yy_current_state = yy_get_previous_state( ); 942 | 943 | /* Okay, we're now positioned to make the NUL 944 | * transition. We couldn't have 945 | * yy_get_previous_state() go ahead and do it 946 | * for us because it doesn't know how to deal 947 | * with the possibility of jamming (and we don't 948 | * want to build jamming into it because then it 949 | * will run more slowly). 950 | */ 951 | 952 | yy_next_state = yy_try_NUL_trans( yy_current_state ); 953 | 954 | yy_bp = (yytext_ptr) + YY_MORE_ADJ; 955 | 956 | if ( yy_next_state ) 957 | { 958 | /* Consume the NUL. */ 959 | yy_cp = ++(yy_c_buf_p); 960 | yy_current_state = yy_next_state; 961 | goto yy_match; 962 | } 963 | 964 | else 965 | { 966 | yy_cp = (yy_c_buf_p); 967 | goto yy_find_action; 968 | } 969 | } 970 | 971 | else switch ( yy_get_next_buffer( ) ) 972 | { 973 | case EOB_ACT_END_OF_FILE: 974 | { 975 | (yy_did_buffer_switch_on_eof) = 0; 976 | 977 | if ( yywrap( ) ) 978 | { 979 | /* Note: because we've taken care in 980 | * yy_get_next_buffer() to have set up 981 | * yytext, we can now set up 982 | * yy_c_buf_p so that if some total 983 | * hoser (like flex itself) wants to 984 | * call the scanner after we return the 985 | * YY_NULL, it'll still work - another 986 | * YY_NULL will get returned. 987 | */ 988 | (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 989 | 990 | yy_act = YY_STATE_EOF(YY_START); 991 | goto do_action; 992 | } 993 | 994 | else 995 | { 996 | if ( ! (yy_did_buffer_switch_on_eof) ) 997 | YY_NEW_FILE; 998 | } 999 | break; 1000 | } 1001 | 1002 | case EOB_ACT_CONTINUE_SCAN: 1003 | (yy_c_buf_p) = 1004 | (yytext_ptr) + yy_amount_of_matched_text; 1005 | 1006 | yy_current_state = yy_get_previous_state( ); 1007 | 1008 | yy_cp = (yy_c_buf_p); 1009 | yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1010 | goto yy_match; 1011 | 1012 | case EOB_ACT_LAST_MATCH: 1013 | (yy_c_buf_p) = 1014 | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 1015 | 1016 | yy_current_state = yy_get_previous_state( ); 1017 | 1018 | yy_cp = (yy_c_buf_p); 1019 | yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1020 | goto yy_find_action; 1021 | } 1022 | break; 1023 | } 1024 | 1025 | default: 1026 | YY_FATAL_ERROR( 1027 | "fatal flex scanner internal error--no action found" ); 1028 | } /* end of action switch */ 1029 | } /* end of scanning one token */ 1030 | } /* end of user's declarations */ 1031 | } /* end of yylex */ 1032 | 1033 | /* yy_get_next_buffer - try to read in a new buffer 1034 | * 1035 | * Returns a code representing an action: 1036 | * EOB_ACT_LAST_MATCH - 1037 | * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1038 | * EOB_ACT_END_OF_FILE - end of file 1039 | */ 1040 | static int yy_get_next_buffer (void) 1041 | { 1042 | char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 1043 | char *source = (yytext_ptr); 1044 | int number_to_move, i; 1045 | int ret_val; 1046 | 1047 | if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 1048 | YY_FATAL_ERROR( 1049 | "fatal flex scanner internal error--end of buffer missed" ); 1050 | 1051 | if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1052 | { /* Don't try to fill the buffer, so this is an EOF. */ 1053 | if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 1054 | { 1055 | /* We matched a single character, the EOB, so 1056 | * treat this as a final EOF. 1057 | */ 1058 | return EOB_ACT_END_OF_FILE; 1059 | } 1060 | 1061 | else 1062 | { 1063 | /* We matched some text prior to the EOB, first 1064 | * process it. 1065 | */ 1066 | return EOB_ACT_LAST_MATCH; 1067 | } 1068 | } 1069 | 1070 | /* Try to read more data. */ 1071 | 1072 | /* First move last chars to start of buffer. */ 1073 | number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); 1074 | 1075 | for ( i = 0; i < number_to_move; ++i ) 1076 | *(dest++) = *(source++); 1077 | 1078 | if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1079 | /* don't do the read, it's not guaranteed to return an EOF, 1080 | * just force an EOF 1081 | */ 1082 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 1083 | 1084 | else 1085 | { 1086 | int num_to_read = 1087 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1088 | 1089 | while ( num_to_read <= 0 ) 1090 | { /* Not enough room in the buffer - grow it. */ 1091 | 1092 | /* just a shorter name for the current buffer */ 1093 | YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; 1094 | 1095 | int yy_c_buf_p_offset = 1096 | (int) ((yy_c_buf_p) - b->yy_ch_buf); 1097 | 1098 | if ( b->yy_is_our_buffer ) 1099 | { 1100 | int new_size = b->yy_buf_size * 2; 1101 | 1102 | if ( new_size <= 0 ) 1103 | b->yy_buf_size += b->yy_buf_size / 8; 1104 | else 1105 | b->yy_buf_size *= 2; 1106 | 1107 | b->yy_ch_buf = (char *) 1108 | /* Include room in for 2 EOB chars. */ 1109 | yyrealloc( (void *) b->yy_ch_buf, 1110 | (yy_size_t) (b->yy_buf_size + 2) ); 1111 | } 1112 | else 1113 | /* Can't grow it, we don't own it. */ 1114 | b->yy_ch_buf = NULL; 1115 | 1116 | if ( ! b->yy_ch_buf ) 1117 | YY_FATAL_ERROR( 1118 | "fatal error - scanner input buffer overflow" ); 1119 | 1120 | (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 1121 | 1122 | num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1123 | number_to_move - 1; 1124 | 1125 | } 1126 | 1127 | if ( num_to_read > YY_READ_BUF_SIZE ) 1128 | num_to_read = YY_READ_BUF_SIZE; 1129 | 1130 | /* Read in more data. */ 1131 | YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 1132 | (yy_n_chars), num_to_read ); 1133 | 1134 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1135 | } 1136 | 1137 | if ( (yy_n_chars) == 0 ) 1138 | { 1139 | if ( number_to_move == YY_MORE_ADJ ) 1140 | { 1141 | ret_val = EOB_ACT_END_OF_FILE; 1142 | yyrestart( yyin ); 1143 | } 1144 | 1145 | else 1146 | { 1147 | ret_val = EOB_ACT_LAST_MATCH; 1148 | YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1149 | YY_BUFFER_EOF_PENDING; 1150 | } 1151 | } 1152 | 1153 | else 1154 | ret_val = EOB_ACT_CONTINUE_SCAN; 1155 | 1156 | if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 1157 | /* Extend the array by 50%, plus the number we really need. */ 1158 | int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 1159 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( 1160 | (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); 1161 | if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1162 | YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 1163 | /* "- 2" to take care of EOB's */ 1164 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); 1165 | } 1166 | 1167 | (yy_n_chars) += number_to_move; 1168 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 1169 | YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 1170 | 1171 | (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1172 | 1173 | return ret_val; 1174 | } 1175 | 1176 | /* yy_get_previous_state - get the state just before the EOB char was reached */ 1177 | 1178 | static yy_state_type yy_get_previous_state (void) 1179 | { 1180 | yy_state_type yy_current_state; 1181 | char *yy_cp; 1182 | 1183 | yy_current_state = (yy_start); 1184 | 1185 | for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1186 | { 1187 | YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1188 | if ( yy_accept[yy_current_state] ) 1189 | { 1190 | (yy_last_accepting_state) = yy_current_state; 1191 | (yy_last_accepting_cpos) = yy_cp; 1192 | } 1193 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1194 | { 1195 | yy_current_state = (int) yy_def[yy_current_state]; 1196 | if ( yy_current_state >= 77 ) 1197 | yy_c = yy_meta[yy_c]; 1198 | } 1199 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1200 | } 1201 | 1202 | return yy_current_state; 1203 | } 1204 | 1205 | /* yy_try_NUL_trans - try to make a transition on the NUL character 1206 | * 1207 | * synopsis 1208 | * next_state = yy_try_NUL_trans( current_state ); 1209 | */ 1210 | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 1211 | { 1212 | int yy_is_jam; 1213 | char *yy_cp = (yy_c_buf_p); 1214 | 1215 | YY_CHAR yy_c = 1; 1216 | if ( yy_accept[yy_current_state] ) 1217 | { 1218 | (yy_last_accepting_state) = yy_current_state; 1219 | (yy_last_accepting_cpos) = yy_cp; 1220 | } 1221 | while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1222 | { 1223 | yy_current_state = (int) yy_def[yy_current_state]; 1224 | if ( yy_current_state >= 77 ) 1225 | yy_c = yy_meta[yy_c]; 1226 | } 1227 | yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1228 | yy_is_jam = (yy_current_state == 76); 1229 | 1230 | return yy_is_jam ? 0 : yy_current_state; 1231 | } 1232 | 1233 | #ifndef YY_NO_UNPUT 1234 | 1235 | static void yyunput (int c, char * yy_bp ) 1236 | { 1237 | char *yy_cp; 1238 | 1239 | yy_cp = (yy_c_buf_p); 1240 | 1241 | /* undo effects of setting up yytext */ 1242 | *yy_cp = (yy_hold_char); 1243 | 1244 | if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1245 | { /* need to shift things up to make room */ 1246 | /* +2 for EOB chars. */ 1247 | int number_to_move = (yy_n_chars) + 2; 1248 | char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 1249 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1250 | char *source = 1251 | &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 1252 | 1253 | while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1254 | *--dest = *--source; 1255 | 1256 | yy_cp += (int) (dest - source); 1257 | yy_bp += (int) (dest - source); 1258 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 1259 | (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 1260 | 1261 | if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1262 | YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1263 | } 1264 | 1265 | *--yy_cp = (char) c; 1266 | 1267 | (yytext_ptr) = yy_bp; 1268 | (yy_hold_char) = *yy_cp; 1269 | (yy_c_buf_p) = yy_cp; 1270 | } 1271 | 1272 | #endif 1273 | 1274 | #ifndef YY_NO_INPUT 1275 | #ifdef __cplusplus 1276 | static int yyinput (void) 1277 | #else 1278 | static int input (void) 1279 | #endif 1280 | 1281 | { 1282 | int c; 1283 | 1284 | *(yy_c_buf_p) = (yy_hold_char); 1285 | 1286 | if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1287 | { 1288 | /* yy_c_buf_p now points to the character we want to return. 1289 | * If this occurs *before* the EOB characters, then it's a 1290 | * valid NUL; if not, then we've hit the end of the buffer. 1291 | */ 1292 | if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1293 | /* This was really a NUL. */ 1294 | *(yy_c_buf_p) = '\0'; 1295 | 1296 | else 1297 | { /* need more input */ 1298 | int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); 1299 | ++(yy_c_buf_p); 1300 | 1301 | switch ( yy_get_next_buffer( ) ) 1302 | { 1303 | case EOB_ACT_LAST_MATCH: 1304 | /* This happens because yy_g_n_b() 1305 | * sees that we've accumulated a 1306 | * token and flags that we need to 1307 | * try matching the token before 1308 | * proceeding. But for input(), 1309 | * there's no matching to consider. 1310 | * So convert the EOB_ACT_LAST_MATCH 1311 | * to EOB_ACT_END_OF_FILE. 1312 | */ 1313 | 1314 | /* Reset buffer status. */ 1315 | yyrestart( yyin ); 1316 | 1317 | /*FALLTHROUGH*/ 1318 | 1319 | case EOB_ACT_END_OF_FILE: 1320 | { 1321 | if ( yywrap( ) ) 1322 | return 0; 1323 | 1324 | if ( ! (yy_did_buffer_switch_on_eof) ) 1325 | YY_NEW_FILE; 1326 | #ifdef __cplusplus 1327 | return yyinput(); 1328 | #else 1329 | return input(); 1330 | #endif 1331 | } 1332 | 1333 | case EOB_ACT_CONTINUE_SCAN: 1334 | (yy_c_buf_p) = (yytext_ptr) + offset; 1335 | break; 1336 | } 1337 | } 1338 | } 1339 | 1340 | c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 1341 | *(yy_c_buf_p) = '\0'; /* preserve yytext */ 1342 | (yy_hold_char) = *++(yy_c_buf_p); 1343 | 1344 | return c; 1345 | } 1346 | #endif /* ifndef YY_NO_INPUT */ 1347 | 1348 | /** Immediately switch to a different input stream. 1349 | * @param input_file A readable stream. 1350 | * 1351 | * @note This function does not reset the start condition to @c INITIAL . 1352 | */ 1353 | void yyrestart (FILE * input_file ) 1354 | { 1355 | 1356 | if ( ! YY_CURRENT_BUFFER ){ 1357 | yyensure_buffer_stack (); 1358 | YY_CURRENT_BUFFER_LVALUE = 1359 | yy_create_buffer( yyin, YY_BUF_SIZE ); 1360 | } 1361 | 1362 | yy_init_buffer( YY_CURRENT_BUFFER, input_file ); 1363 | yy_load_buffer_state( ); 1364 | } 1365 | 1366 | /** Switch to a different input buffer. 1367 | * @param new_buffer The new input buffer. 1368 | * 1369 | */ 1370 | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 1371 | { 1372 | 1373 | /* TODO. We should be able to replace this entire function body 1374 | * with 1375 | * yypop_buffer_state(); 1376 | * yypush_buffer_state(new_buffer); 1377 | */ 1378 | yyensure_buffer_stack (); 1379 | if ( YY_CURRENT_BUFFER == new_buffer ) 1380 | return; 1381 | 1382 | if ( YY_CURRENT_BUFFER ) 1383 | { 1384 | /* Flush out information for old buffer. */ 1385 | *(yy_c_buf_p) = (yy_hold_char); 1386 | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1387 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1388 | } 1389 | 1390 | YY_CURRENT_BUFFER_LVALUE = new_buffer; 1391 | yy_load_buffer_state( ); 1392 | 1393 | /* We don't actually know whether we did this switch during 1394 | * EOF (yywrap()) processing, but the only time this flag 1395 | * is looked at is after yywrap() is called, so it's safe 1396 | * to go ahead and always set it. 1397 | */ 1398 | (yy_did_buffer_switch_on_eof) = 1; 1399 | } 1400 | 1401 | static void yy_load_buffer_state (void) 1402 | { 1403 | (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 1404 | (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 1405 | yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 1406 | (yy_hold_char) = *(yy_c_buf_p); 1407 | } 1408 | 1409 | /** Allocate and initialize an input buffer state. 1410 | * @param file A readable stream. 1411 | * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 1412 | * 1413 | * @return the allocated buffer state. 1414 | */ 1415 | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 1416 | { 1417 | YY_BUFFER_STATE b; 1418 | 1419 | b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 1420 | if ( ! b ) 1421 | YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1422 | 1423 | b->yy_buf_size = size; 1424 | 1425 | /* yy_ch_buf has to be 2 characters longer than the size given because 1426 | * we need to put in 2 end-of-buffer characters. 1427 | */ 1428 | b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 1429 | if ( ! b->yy_ch_buf ) 1430 | YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1431 | 1432 | b->yy_is_our_buffer = 1; 1433 | 1434 | yy_init_buffer( b, file ); 1435 | 1436 | return b; 1437 | } 1438 | 1439 | /** Destroy the buffer. 1440 | * @param b a buffer created with yy_create_buffer() 1441 | * 1442 | */ 1443 | void yy_delete_buffer (YY_BUFFER_STATE b ) 1444 | { 1445 | 1446 | if ( ! b ) 1447 | return; 1448 | 1449 | if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 1450 | YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 1451 | 1452 | if ( b->yy_is_our_buffer ) 1453 | yyfree( (void *) b->yy_ch_buf ); 1454 | 1455 | yyfree( (void *) b ); 1456 | } 1457 | 1458 | /* Initializes or reinitializes a buffer. 1459 | * This function is sometimes called more than once on the same buffer, 1460 | * such as during a yyrestart() or at EOF. 1461 | */ 1462 | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 1463 | 1464 | { 1465 | int oerrno = errno; 1466 | 1467 | yy_flush_buffer( b ); 1468 | 1469 | b->yy_input_file = file; 1470 | b->yy_fill_buffer = 1; 1471 | 1472 | /* If b is the current buffer, then yy_init_buffer was _probably_ 1473 | * called from yyrestart() or through yy_get_next_buffer. 1474 | * In that case, we don't want to reset the lineno or column. 1475 | */ 1476 | if (b != YY_CURRENT_BUFFER){ 1477 | b->yy_bs_lineno = 1; 1478 | b->yy_bs_column = 0; 1479 | } 1480 | 1481 | b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1482 | 1483 | errno = oerrno; 1484 | } 1485 | 1486 | /** Discard all buffered characters. On the next scan, YY_INPUT will be called. 1487 | * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 1488 | * 1489 | */ 1490 | void yy_flush_buffer (YY_BUFFER_STATE b ) 1491 | { 1492 | if ( ! b ) 1493 | return; 1494 | 1495 | b->yy_n_chars = 0; 1496 | 1497 | /* We always need two end-of-buffer characters. The first causes 1498 | * a transition to the end-of-buffer state. The second causes 1499 | * a jam in that state. 1500 | */ 1501 | b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1502 | b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1503 | 1504 | b->yy_buf_pos = &b->yy_ch_buf[0]; 1505 | 1506 | b->yy_at_bol = 1; 1507 | b->yy_buffer_status = YY_BUFFER_NEW; 1508 | 1509 | if ( b == YY_CURRENT_BUFFER ) 1510 | yy_load_buffer_state( ); 1511 | } 1512 | 1513 | /** Pushes the new state onto the stack. The new state becomes 1514 | * the current state. This function will allocate the stack 1515 | * if necessary. 1516 | * @param new_buffer The new state. 1517 | * 1518 | */ 1519 | void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 1520 | { 1521 | if (new_buffer == NULL) 1522 | return; 1523 | 1524 | yyensure_buffer_stack(); 1525 | 1526 | /* This block is copied from yy_switch_to_buffer. */ 1527 | if ( YY_CURRENT_BUFFER ) 1528 | { 1529 | /* Flush out information for old buffer. */ 1530 | *(yy_c_buf_p) = (yy_hold_char); 1531 | YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 1532 | YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1533 | } 1534 | 1535 | /* Only push if top exists. Otherwise, replace top. */ 1536 | if (YY_CURRENT_BUFFER) 1537 | (yy_buffer_stack_top)++; 1538 | YY_CURRENT_BUFFER_LVALUE = new_buffer; 1539 | 1540 | /* copied from yy_switch_to_buffer. */ 1541 | yy_load_buffer_state( ); 1542 | (yy_did_buffer_switch_on_eof) = 1; 1543 | } 1544 | 1545 | /** Removes and deletes the top of the stack, if present. 1546 | * The next element becomes the new top. 1547 | * 1548 | */ 1549 | void yypop_buffer_state (void) 1550 | { 1551 | if (!YY_CURRENT_BUFFER) 1552 | return; 1553 | 1554 | yy_delete_buffer(YY_CURRENT_BUFFER ); 1555 | YY_CURRENT_BUFFER_LVALUE = NULL; 1556 | if ((yy_buffer_stack_top) > 0) 1557 | --(yy_buffer_stack_top); 1558 | 1559 | if (YY_CURRENT_BUFFER) { 1560 | yy_load_buffer_state( ); 1561 | (yy_did_buffer_switch_on_eof) = 1; 1562 | } 1563 | } 1564 | 1565 | /* Allocates the stack if it does not exist. 1566 | * Guarantees space for at least one push. 1567 | */ 1568 | static void yyensure_buffer_stack (void) 1569 | { 1570 | yy_size_t num_to_alloc; 1571 | 1572 | if (!(yy_buffer_stack)) { 1573 | 1574 | /* First allocation is just for 2 elements, since we don't know if this 1575 | * scanner will even need a stack. We use 2 instead of 1 to avoid an 1576 | * immediate realloc on the next call. 1577 | */ 1578 | num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 1579 | (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 1580 | (num_to_alloc * sizeof(struct yy_buffer_state*) 1581 | ); 1582 | if ( ! (yy_buffer_stack) ) 1583 | YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1584 | 1585 | memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1586 | 1587 | (yy_buffer_stack_max) = num_to_alloc; 1588 | (yy_buffer_stack_top) = 0; 1589 | return; 1590 | } 1591 | 1592 | if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 1593 | 1594 | /* Increase the buffer to prepare for a possible push. */ 1595 | yy_size_t grow_size = 8 /* arbitrary grow size */; 1596 | 1597 | num_to_alloc = (yy_buffer_stack_max) + grow_size; 1598 | (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 1599 | ((yy_buffer_stack), 1600 | num_to_alloc * sizeof(struct yy_buffer_state*) 1601 | ); 1602 | if ( ! (yy_buffer_stack) ) 1603 | YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 1604 | 1605 | /* zero only the new slots.*/ 1606 | memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 1607 | (yy_buffer_stack_max) = num_to_alloc; 1608 | } 1609 | } 1610 | 1611 | /** Setup the input buffer state to scan directly from a user-specified character buffer. 1612 | * @param base the character buffer 1613 | * @param size the size in bytes of the character buffer 1614 | * 1615 | * @return the newly allocated buffer state object. 1616 | */ 1617 | YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 1618 | { 1619 | YY_BUFFER_STATE b; 1620 | 1621 | if ( size < 2 || 1622 | base[size-2] != YY_END_OF_BUFFER_CHAR || 1623 | base[size-1] != YY_END_OF_BUFFER_CHAR ) 1624 | /* They forgot to leave room for the EOB's. */ 1625 | return NULL; 1626 | 1627 | b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 1628 | if ( ! b ) 1629 | YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1630 | 1631 | b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 1632 | b->yy_buf_pos = b->yy_ch_buf = base; 1633 | b->yy_is_our_buffer = 0; 1634 | b->yy_input_file = NULL; 1635 | b->yy_n_chars = b->yy_buf_size; 1636 | b->yy_is_interactive = 0; 1637 | b->yy_at_bol = 1; 1638 | b->yy_fill_buffer = 0; 1639 | b->yy_buffer_status = YY_BUFFER_NEW; 1640 | 1641 | yy_switch_to_buffer( b ); 1642 | 1643 | return b; 1644 | } 1645 | 1646 | /** Setup the input buffer state to scan a string. The next call to yylex() will 1647 | * scan from a @e copy of @a str. 1648 | * @param yystr a NUL-terminated string to scan 1649 | * 1650 | * @return the newly allocated buffer state object. 1651 | * @note If you want to scan bytes that may contain NUL values, then use 1652 | * yy_scan_bytes() instead. 1653 | */ 1654 | YY_BUFFER_STATE yy_scan_string (const char * yystr ) 1655 | { 1656 | 1657 | return yy_scan_bytes( yystr, (int) strlen(yystr) ); 1658 | } 1659 | 1660 | /** Setup the input buffer state to scan the given bytes. The next call to yylex() will 1661 | * scan from a @e copy of @a bytes. 1662 | * @param yybytes the byte buffer to scan 1663 | * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. 1664 | * 1665 | * @return the newly allocated buffer state object. 1666 | */ 1667 | YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) 1668 | { 1669 | YY_BUFFER_STATE b; 1670 | char *buf; 1671 | yy_size_t n; 1672 | int i; 1673 | 1674 | /* Get memory for full buffer, including space for trailing EOB's. */ 1675 | n = (yy_size_t) (_yybytes_len + 2); 1676 | buf = (char *) yyalloc( n ); 1677 | if ( ! buf ) 1678 | YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1679 | 1680 | for ( i = 0; i < _yybytes_len; ++i ) 1681 | buf[i] = yybytes[i]; 1682 | 1683 | buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 1684 | 1685 | b = yy_scan_buffer( buf, n ); 1686 | if ( ! b ) 1687 | YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1688 | 1689 | /* It's okay to grow etc. this buffer, and we should throw it 1690 | * away when we're done. 1691 | */ 1692 | b->yy_is_our_buffer = 1; 1693 | 1694 | return b; 1695 | } 1696 | 1697 | #ifndef YY_EXIT_FAILURE 1698 | #define YY_EXIT_FAILURE 2 1699 | #endif 1700 | 1701 | static void yynoreturn yy_fatal_error (const char* msg ) 1702 | { 1703 | fprintf( stderr, "%s\n", msg ); 1704 | exit( YY_EXIT_FAILURE ); 1705 | } 1706 | 1707 | /* Redefine yyless() so it works in section 3 code. */ 1708 | 1709 | #undef yyless 1710 | #define yyless(n) \ 1711 | do \ 1712 | { \ 1713 | /* Undo effects of setting up yytext. */ \ 1714 | int yyless_macro_arg = (n); \ 1715 | YY_LESS_LINENO(yyless_macro_arg);\ 1716 | yytext[yyleng] = (yy_hold_char); \ 1717 | (yy_c_buf_p) = yytext + yyless_macro_arg; \ 1718 | (yy_hold_char) = *(yy_c_buf_p); \ 1719 | *(yy_c_buf_p) = '\0'; \ 1720 | yyleng = yyless_macro_arg; \ 1721 | } \ 1722 | while ( 0 ) 1723 | 1724 | /* Accessor methods (get/set functions) to struct members. */ 1725 | 1726 | /** Get the current line number. 1727 | * 1728 | */ 1729 | int yyget_lineno (void) 1730 | { 1731 | 1732 | return yylineno; 1733 | } 1734 | 1735 | /** Get the input stream. 1736 | * 1737 | */ 1738 | FILE *yyget_in (void) 1739 | { 1740 | return yyin; 1741 | } 1742 | 1743 | /** Get the output stream. 1744 | * 1745 | */ 1746 | FILE *yyget_out (void) 1747 | { 1748 | return yyout; 1749 | } 1750 | 1751 | /** Get the length of the current token. 1752 | * 1753 | */ 1754 | int yyget_leng (void) 1755 | { 1756 | return yyleng; 1757 | } 1758 | 1759 | /** Get the current token. 1760 | * 1761 | */ 1762 | 1763 | char *yyget_text (void) 1764 | { 1765 | return yytext; 1766 | } 1767 | 1768 | /** Set the current line number. 1769 | * @param _line_number line number 1770 | * 1771 | */ 1772 | void yyset_lineno (int _line_number ) 1773 | { 1774 | 1775 | yylineno = _line_number; 1776 | } 1777 | 1778 | /** Set the input stream. This does not discard the current 1779 | * input buffer. 1780 | * @param _in_str A readable stream. 1781 | * 1782 | * @see yy_switch_to_buffer 1783 | */ 1784 | void yyset_in (FILE * _in_str ) 1785 | { 1786 | yyin = _in_str ; 1787 | } 1788 | 1789 | void yyset_out (FILE * _out_str ) 1790 | { 1791 | yyout = _out_str ; 1792 | } 1793 | 1794 | int yyget_debug (void) 1795 | { 1796 | return yy_flex_debug; 1797 | } 1798 | 1799 | void yyset_debug (int _bdebug ) 1800 | { 1801 | yy_flex_debug = _bdebug ; 1802 | } 1803 | 1804 | static int yy_init_globals (void) 1805 | { 1806 | /* Initialization is the same as for the non-reentrant scanner. 1807 | * This function is called from yylex_destroy(), so don't allocate here. 1808 | */ 1809 | 1810 | (yy_buffer_stack) = NULL; 1811 | (yy_buffer_stack_top) = 0; 1812 | (yy_buffer_stack_max) = 0; 1813 | (yy_c_buf_p) = NULL; 1814 | (yy_init) = 0; 1815 | (yy_start) = 0; 1816 | 1817 | /* Defined in main.c */ 1818 | #ifdef YY_STDINIT 1819 | yyin = stdin; 1820 | yyout = stdout; 1821 | #else 1822 | yyin = NULL; 1823 | yyout = NULL; 1824 | #endif 1825 | 1826 | /* For future reference: Set errno on error, since we are called by 1827 | * yylex_init() 1828 | */ 1829 | return 0; 1830 | } 1831 | 1832 | /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 1833 | int yylex_destroy (void) 1834 | { 1835 | 1836 | /* Pop the buffer stack, destroying each element. */ 1837 | while(YY_CURRENT_BUFFER){ 1838 | yy_delete_buffer( YY_CURRENT_BUFFER ); 1839 | YY_CURRENT_BUFFER_LVALUE = NULL; 1840 | yypop_buffer_state(); 1841 | } 1842 | 1843 | /* Destroy the stack itself. */ 1844 | yyfree((yy_buffer_stack) ); 1845 | (yy_buffer_stack) = NULL; 1846 | 1847 | /* Reset the globals. This is important in a non-reentrant scanner so the next time 1848 | * yylex() is called, initialization will occur. */ 1849 | yy_init_globals( ); 1850 | 1851 | return 0; 1852 | } 1853 | 1854 | /* 1855 | * Internal utility routines. 1856 | */ 1857 | 1858 | #ifndef yytext_ptr 1859 | static void yy_flex_strncpy (char* s1, const char * s2, int n ) 1860 | { 1861 | 1862 | int i; 1863 | for ( i = 0; i < n; ++i ) 1864 | s1[i] = s2[i]; 1865 | } 1866 | #endif 1867 | 1868 | #ifdef YY_NEED_STRLEN 1869 | static int yy_flex_strlen (const char * s ) 1870 | { 1871 | int n; 1872 | for ( n = 0; s[n]; ++n ) 1873 | ; 1874 | 1875 | return n; 1876 | } 1877 | #endif 1878 | 1879 | void *yyalloc (yy_size_t size ) 1880 | { 1881 | return malloc(size); 1882 | } 1883 | 1884 | void *yyrealloc (void * ptr, yy_size_t size ) 1885 | { 1886 | 1887 | /* The cast to (char *) in the following accommodates both 1888 | * implementations that use char* generic pointers, and those 1889 | * that use void* generic pointers. It works with the latter 1890 | * because both ANSI C and C++ allow castless assignment from 1891 | * any pointer type to void*, and deal with argument conversions 1892 | * as though doing an assignment. 1893 | */ 1894 | return realloc(ptr, size); 1895 | } 1896 | 1897 | void yyfree (void * ptr ) 1898 | { 1899 | free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 1900 | } 1901 | 1902 | #define YYTABLES_NAME "yytables" 1903 | 1904 | #line 41 "netcl.l" 1905 | 1906 | 1907 | --------------------------------------------------------------------------------