diff --git a/individual_files/000028__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 b/individual_files/000028__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9d5f155d4c42078ab6893f3d5c3ec3a63d59c1e0 --- /dev/null +++ b/individual_files/000028__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 @@ -0,0 +1,224 @@ +#include + +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_8021Q = 0x8100; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<16> tpid_t; + +header ethernet_t{ + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header vlanTag_t{ + tpid_t tpid; + +// Tag protocol identifier + bit<1> pcp; + +// Priority code point + bit<3> dei; + +// Drop eligible indicator + bit<12> vid; + +// VLAN identifier +} + +header ipv4_t{ + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct headers{ + ethernet_t ethernet; + vlanTag_t vlanTag; + ipv4_t ipv4; +} + +struct metadata{ + egressSpec_t port; +} + +parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + state start{ + + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_8021Q: parse_vlanTag; + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_vlanTag{ + pkt.extract(hdr.vlanTag); + transition accept; + } + + state parse_ipv4{ + pkt.extract(hdr.ipv4); + transition accept; + } +} + +control myVerifyChecksum(inout headers hdr, inout metadata meta){ + apply{} +} + +control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + action drop(){ + mark_to_drop(stdmeta); + } + + action mac_forward(macAddr_t dstAddr, egressSpec_t port){ + stdmeta.egress_spec = port; + meta.port = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + } + + table vlan_parse_exact{ + key = { + hdr.ethernet.srcAddr: exact; + } + actions = { + mac_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + + + action add_vlanTag(macAddr_t dstAddr, egressSpec_t port, bit<12> vid){ + stdmeta.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.vlanTag.tpid = TYPE_8021Q; + hdr.vlanTag.vid = vid; + hdr.vlanTag.setValid(); + hdr.ethernet.etherType = TYPE_8021Q; + } + + table add_vlanTag_exact{ + key = { + hdr.ethernet.srcAddr: exact; + } + + actions = { + add_vlanTag; + drop; + NoAction; + } + default_action = NoAction(); + } + + apply{ + if(hdr.ipv4.isValid() && !hdr.vlanTag.isValid()){ + add_vlanTag_exact.apply(); + + } + else if(hdr.vlanTag.isValid()){ + vlan_parse_exact.apply(); + } + } +} + + +control cEgress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + + action remove_vlanTag(){ + hdr.vlanTag.setInvalid(); + hdr.ethernet.etherType = TYPE_IPV4; + } + + action remove(){ + hdr.vlanTag.setInvalid(); + hdr.ethernet.etherType = TYPE_IPV4; + } + + table remove_vlanTag_exact{ + key = { + meta.port: exact; + } + + actions = { + remove_vlanTag; + remove; + NoAction; + } + + default_action = remove(); + } + apply{ + + + if(hdr.vlanTag.isValid()){ + remove_vlanTag_exact.apply(); + } + + } +} + + +control myComputeChecksum(inout headers hdr, inout metadata meta){ + apply{/* + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + */ + } +} + +control deparserI(packet_out packet, in headers hdr){ + apply{ + packet.emit(hdr.ethernet); + + packet.emit(hdr.ipv4); + } +} + +V1Switch( + parserI(), + myVerifyChecksum(), + cIngress(), + cEgress(), + myComputeChecksum(), + deparserI() +) main; diff --git a/individual_files/000029__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 b/individual_files/000029__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8520d6bb547d728c6ed1c8365f0bbce95d9c329b --- /dev/null +++ b/individual_files/000029__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 @@ -0,0 +1,232 @@ +#include + +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<8> TYPE_TCP = 6; +const bit<8> TYPE_UDP = 17; + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<128> ip6Addr_t; + +typedef bit<32> packetCounter_t; +typedef bit<8> port_id_t; + +header ethernet_t{ + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t{ + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +header udp_t{ + bit<16> source_port; + bit<16> destination_port; + bit<16> length; + bit<16> check_sum; +} + +header tcp_t{ + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<4> res; + bit<1> cwr; + bit<1> ece; + bit<1> urg; + bit<1> ack; + bit<1> psh; + bit<1> rst; + bit<1> syn; + bit<1> fin; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +struct headers{ + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + +struct metadata{ + bit<16> port; +} + +parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + state start{ + + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4{ + pkt.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + TYPE_TCP: parse_transport; + TYPE_UDP: parse_transport; + default: accept; + } + } + + state parse_transport{ + pkt.extract(hdr.tcp); + + transition accept; + } +} + +control myVerifyChecksum(inout headers hdr, inout metadata meta){ + apply{} +} + +control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + + counter(64, CounterType.packets) count_parsed; + direct_counter(CounterType.packets) count_dropped; + + action drop(){ + count_dropped.count(); + +// counts dropped packets on all ports + mark_to_drop(stdmeta); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port){ + stdmeta.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + count_parsed.count((bit<32>) stdmeta.ingress_port); + +// counts + } + + table ipv4_lpm{ + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + table traffic_filter{ + key = { + hdr.ipv4.dstAddr: ternary; + + } + actions = { + ipv4_forward; + drop; + } + counters = count_dropped; + size = 1024; + default_action = drop(); + } + + apply{ + if(hdr.ipv4.isValid()){ + + + if(hdr.tcp.isValid()){ + traffic_filter.apply(); + } + } + } +} + + +control cEgress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + + counter(64, CounterType.packets) count_sent; + + action updateCounter(){ + count_sent.count((bit<32>) stdmeta.egress_spec); + } + + table statistics{ + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + updateCounter; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + apply{ + statistics.apply(); + } +} + + +control myComputeChecksum(inout headers hdr, inout metadata meta){ + apply{ + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + +control deparserI(packet_out packet, in headers hdr){ + apply{ + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + } +} + +V1Switch( + parserI(), + myVerifyChecksum(), + cIngress(), + cEgress(), + myComputeChecksum(), + deparserI() +) main; diff --git a/individual_files/000032__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 b/individual_files/000032__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 new file mode 100644 index 0000000000000000000000000000000000000000..af0f7f8911a827e61e070d23ebaa7205aa7d10df --- /dev/null +++ b/individual_files/000032__raw-repositories__bartoszlomiej__Mininet-P4-introduction.p4 @@ -0,0 +1,213 @@ +#include + +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_8021Q = 0x8100; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<16> tpid_t; + +header ethernet_t{ + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header vlanTag_t{ + tpid_t tpid; + +// Tag protocol identifier + bit<1> pcp; + +// Priority code point + bit<3> dei; + +// Drop eligible indicator + bit<12> vid; + +// VLAN identifier +} + +header ipv4_t{ + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct headers{ + ethernet_t ethernet; + vlanTag_t vlanTag; + ipv4_t ipv4; +} + +struct mac_learn_t{ + bit<48> srcAddr; + bit<9> ingress_port; + bit<32> srcIpAddr; +} + +struct metadata{ + egressSpec_t port; + mac_learn_t mac_learn_msg; +} + +parser parserI(packet_in pkt, out headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + state start{ + + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4{ + pkt.extract(hdr.ipv4); + meta.mac_learn_msg.srcIpAddr = hdr.ipv4.srcAddr; + transition accept; + } +} + +control myVerifyChecksum(inout headers hdr, inout metadata meta){ + apply{} +} + +control cIngress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + + action drop(){ + mark_to_drop(stdmeta); + } + + action unknown_source(){ + meta.mac_learn_msg.srcAddr = hdr.ethernet.srcAddr; + meta.mac_learn_msg.ingress_port = stdmeta.ingress_port; + + digest(0, meta.mac_learn_msg); + +// possible error + } + + table learned_MAC{ + key = { + hdr.ethernet.srcAddr: exact; + } + actions = { + unknown_source; + NoAction; + } + default_action = unknown_source(); + } + + action mac_forward(macAddr_t dstAddr, egressSpec_t port){ + stdmeta.egress_spec = port; + + hdr.ethernet.dstAddr = dstAddr; + } + + table l2_table{ + key = { + hdr.ipv4.dstAddr: exact; + } + actions = { + mac_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply{ + if(hdr.ipv4.isValid()){ + learned_MAC.apply(); + l2_table.apply(); + } + } +} + + +control cEgress(inout headers hdr, inout metadata meta, inout standard_metadata_t stdmeta){ + + action remove_vlanTag(){ + hdr.vlanTag.setInvalid(); + hdr.ethernet.etherType = TYPE_IPV4; + } + + action remove(){ + hdr.vlanTag.setInvalid(); + hdr.ethernet.etherType = TYPE_IPV4; + } + + table remove_vlanTag_exact{ + key = { + meta.port: exact; + } + + actions = { + remove_vlanTag; + remove; + NoAction; + } + default_action = NoAction(); + } + apply{ + + + } +} + + +control myComputeChecksum(inout headers hdr, inout metadata meta){ + apply{/* + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + */ + } +} + +control deparserI(packet_out packet, in headers hdr){ + apply{ + packet.emit(hdr.ethernet); + + packet.emit(hdr.ipv4); + } +} + +V1Switch( + parserI(), + myVerifyChecksum(), + cIngress(), + cEgress(), + myComputeChecksum(), + deparserI() +) main; diff --git a/individual_files/000033__raw-repositories__0Shark__p4lab.p4 b/individual_files/000033__raw-repositories__0Shark__p4lab.p4 new file mode 100644 index 0000000000000000000000000000000000000000..bc00f90d642a5a523d503b973bf112b38110c0ac --- /dev/null +++ b/individual_files/000033__raw-repositories__0Shark__p4lab.p4 @@ -0,0 +1,414 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_HULA = 0x2345; + +#define MAX_HOPS 9 +#define TOR_NUM 32 +#define TOR_NUM_1 33 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<15> qdepth_t; +typedef bit<32> digest_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header srcRoute_t { + bit<1> bos; + bit<15> port; +} + +header hula_t { + +/* 0 is forward path, 1 is the backward path */ + bit<1> dir; + +/* max qdepth seen so far in the forward path */ + qdepth_t qdepth; + +/* digest of the source routing list to uniquely identify each path */ + digest_t digest; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +struct metadata { + + bit<32> index; +} + +struct headers { + ethernet_t ethernet; + srcRoute_t[MAX_HOPS] srcRoutes; + ipv4_t ipv4; + udp_t udp; + hula_t hula; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_HULA : parse_hula; + TYPE_IPV4 : parse_ipv4; + default : accept; + } + } + + state parse_hula { + packet.extract(hdr.hula); + transition parse_srcRouting; + } + + state parse_srcRouting { + packet.extract(hdr.srcRoutes.next); + transition select(hdr.srcRoutes.last.bos) { + 1 : parse_ipv4; + default : parse_srcRouting; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 8w17: parse_udp; + default: accept; + } + } + + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } + +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + + register(TOR_NUM) srcindex_qdepth_reg; + + + register(TOR_NUM) srcindex_digest_reg; + + +/* At each hop, saves the next hop to reach each destination ToR */ + register>(TOR_NUM) dstindex_nhop_reg; + + +/* At each hop saves the next hop for each flow */ + register>(65536) flow_port_reg; + + +/* This action will drop packets */ + action drop() { + mark_to_drop(standard_metadata); + } + + action nop() { + } + + action update_ttl(){ + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + action set_dmac(macAddr_t dstAddr){ + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + } + + +/* This action just applies source routing */ + action srcRoute_nhop() { + standard_metadata.egress_spec = (bit<9>)hdr.srcRoutes[0].port; + hdr.srcRoutes.pop_front(1); + } + + + action hula_dst(bit<32> index) { + meta.index = index; + } + + + action hula_set_nhop(bit<32> index) { + dstindex_nhop_reg.write(index, (bit<16>)standard_metadata.ingress_port); + } + + + action hula_get_nhop(bit<32> index){ + bit<16> tmp; + dstindex_nhop_reg.read(tmp, index); + standard_metadata.egress_spec = (bit<9>)tmp; + } + + +/* Record best path at destination ToR */ + action change_best_path_at_dst(){ + srcindex_qdepth_reg.write(meta.index, hdr.hula.qdepth); + srcindex_digest_reg.write(meta.index, hdr.hula.digest); + } + + + action return_hula_to_src(){ + hdr.hula.dir = 1; + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + + table hula_fwd { + key = { + hdr.ipv4.dstAddr: exact; + hdr.ipv4.srcAddr: exact; + } + actions = { + hula_dst; + srcRoute_nhop; + } + default_action = srcRoute_nhop; + size = TOR_NUM_1; + + } + + + table hula_bwd { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + hula_set_nhop; + } + size = TOR_NUM; + } + + + table hula_src { + key = { + hdr.ipv4.srcAddr: exact; + } + actions = { + drop; + srcRoute_nhop; + } + default_action = srcRoute_nhop; + size = 2; + } + + +/* Get nexthop based on dstAddr using registers */ + table hula_nhop { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + hula_get_nhop; + drop; + } + default_action = drop; + size = TOR_NUM; + } + + +/* Set right dmac for packets going to hosts */ + table dmac { + key = { + standard_metadata.egress_spec : exact; + } + actions = { + set_dmac; + nop; + } + default_action = nop; + size = 16; + } + + apply { + if (hdr.hula.isValid()){ + if (hdr.hula.dir == 0){ + switch(hula_fwd.apply().action_run){ + + + hula_dst: { + + +/* if it is the destination ToR compare qdepth */ + qdepth_t old_qdepth; + srcindex_qdepth_reg.read(old_qdepth, meta.index); + + if (old_qdepth > hdr.hula.qdepth){ + change_best_path_at_dst(); + + +/* only return hula packets that update best path */ + return_hula_to_src(); + }else{ + + + digest_t old_digest; + srcindex_digest_reg.read(old_digest, meta.index); + if (old_digest == hdr.hula.digest){ + srcindex_qdepth_reg.write(meta.index, hdr.hula.qdepth); + } + + drop(); + } + } + } + }else { + +/* update routing table in reverse path */ + hula_bwd.apply(); + + +/* drop if source ToR */ + hula_src.apply(); + } + } else if (hdr.ipv4.isValid()){ + bit<32> flow_hash; + hash( + flow_hash, + HashAlgorithm.crc16, + 32w0, + { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.srcPort}, + 32w65536 + ); + + bit<16> port; + flow_port_reg.read(port, flow_hash); + + if (port == 0) { + +// next hop for destination ToR + hula_nhop.apply(); + bit<16> next_hop = (bit<16>)standard_metadata.egress_spec; + flow_port_reg.write(flow_hash, next_hop); + } else { + standard_metadata.egress_spec = (bit<9>)port; + } + + +/* set the right dmac so that ping and iperf work */ + dmac.apply(); + }else { + drop(); + } + + if (hdr.ipv4.isValid()){ + update_ttl(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + +//hula header is valid and forward path + if (hdr.hula.isValid() && hdr.hula.dir == 0) { + +// hula qdepth greater than curr queue depth + if (hdr.hula.qdepth < (qdepth_t)standard_metadata.deq_qdepth) { + hdr.hula.qdepth = (qdepth_t)standard_metadata.deq_qdepth; + } + } + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.hula); + packet.emit(hdr.srcRoutes); + packet.emit(hdr.ipv4); + packet.emit(hdr.udp); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000034__raw-repositories__0Shark__p4lab.p4 b/individual_files/000034__raw-repositories__0Shark__p4lab.p4 new file mode 100644 index 0000000000000000000000000000000000000000..967381b1f9b4b955634a6f6678386ca7b142172a --- /dev/null +++ b/individual_files/000034__raw-repositories__0Shark__p4lab.p4 @@ -0,0 +1,214 @@ +#include +#include + + + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +struct metadata { + bit<14> ecmp_select; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state start { + transition parse_ethernet; + } + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 0x800: parse_ipv4; + default: accept; + } + } + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 6: parse_tcp; + default: accept; + } + } + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + bit<14> flow_hash; + + action drop() { + mark_to_drop(standard_metadata); + } + action set_ecmp_select(bit<16> ecmp_base, bit<32> ecmp_count) { + hash( + flow_hash, + HashAlgorithm.crc16, + ecmp_base, + { hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr, + hdr.ipv4.protocol, + hdr.tcp.srcPort, + hdr.tcp.dstPort }, + ecmp_count + ); + + meta.ecmp_select = flow_hash; + } + action set_nhop(bit<48> nhop_dmac, bit<32> nhop_ipv4, bit<9> port) { + hdr.ethernet.dstAddr = nhop_dmac; + hdr.ipv4.dstAddr = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + table ecmp_group { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + drop; + set_ecmp_select; + } + size = 1024; + } + table ecmp_nhop { + key = { + meta.ecmp_select: exact; + } + actions = { + drop; + set_nhop; + } + size = 2; + } + apply { + + if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) { + ecmp_group.apply(); + ecmp_nhop.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action rewrite_mac(bit<48> smac) { + hdr.ethernet.srcAddr = smac; + } + action drop() { + mark_to_drop(standard_metadata); + } + table send_frame { + key = { + standard_metadata.egress_port: exact; + } + actions = { + rewrite_mac; + drop; + } + size = 256; + } + apply { + send_frame.apply(); + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000035__raw-repositories__0Shark__p4lab.p4 b/individual_files/000035__raw-repositories__0Shark__p4lab.p4 new file mode 100644 index 0000000000000000000000000000000000000000..3b99694ce454c5c880a6aa372468ba745bddb258 --- /dev/null +++ b/individual_files/000035__raw-repositories__0Shark__p4lab.p4 @@ -0,0 +1,184 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x800; + + +/* IP protocols */ +const bit<8> IP_PROTOCOLS_ICMP = 1; +const bit<8> IP_PROTOCOLS_IGMP = 2; +const bit<8> IP_PROTOCOLS_IPV4 = 4; +const bit<8> IP_PROTOCOLS_TCP = 6; +const bit<8> IP_PROTOCOLS_UDP = 17; +const bit<8> IP_PROTOCOLS_IPV6 = 41; +const bit<8> IP_PROTOCOLS_GRE = 47; +const bit<8> IP_PROTOCOLS_IPSEC_ESP = 50; +const bit<8> IP_PROTOCOLS_IPSEC_AH = 51; +const bit<8> IP_PROTOCOLS_ICMPV6 = 58; +const bit<8> IP_PROTOCOLS_EIGRP = 88; +const bit<8> IP_PROTOCOLS_OSPF = 89; +const bit<8> IP_PROTOCOLS_PIM = 103; +const bit<8> IP_PROTOCOLS_VRRP = 112; + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +struct metadata { +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + + + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + + apply { + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.tos, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000036__raw-repositories__0Shark__p4lab.p4 b/individual_files/000036__raw-repositories__0Shark__p4lab.p4 new file mode 100644 index 0000000000000000000000000000000000000000..62e9d8c91972c589cad21c74e8c084cb6848b2db --- /dev/null +++ b/individual_files/000036__raw-repositories__0Shark__p4lab.p4 @@ -0,0 +1,158 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_SRCROUTING = 0x1234; + +#define MAX_HOPS 9 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header srcRoute_t { + bit<1> bos; + bit<15> port; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + srcRoute_t[MAX_HOPS] srcRoutes; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + + transition accept; + } + + state parse_srcRouting { + + transition accept; + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action srcRoute_nhop() { + + } + + action srcRoute_finish() { + hdr.ethernet.etherType = TYPE_IPV4; + } + + action update_ttl(){ + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + apply { + if (hdr.srcRoutes[0].isValid()){ + + + if (hdr.ipv4.isValid()){ + update_ttl(); + } + }else{ + drop(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.srcRoutes); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000037__raw-repositories__ana13zs__p4tutorials.p4 b/individual_files/000037__raw-repositories__ana13zs__p4tutorials.p4 new file mode 100644 index 0000000000000000000000000000000000000000..36adfabf4489a8c38fc3a4de847eb3b67d585471 --- /dev/null +++ b/individual_files/000037__raw-repositories__ana13zs__p4tutorials.p4 @@ -0,0 +1,144 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + + ipv4_lpm.apply(); + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000038__raw-repositories__ana13zs__p4tutorials.p4 b/individual_files/000038__raw-repositories__ana13zs__p4tutorials.p4 new file mode 100644 index 0000000000000000000000000000000000000000..ed0662eda9e26574d114adccd9c9c0296b3b2d94 --- /dev/null +++ b/individual_files/000038__raw-repositories__ana13zs__p4tutorials.p4 @@ -0,0 +1,183 @@ +#include +#include + + +// NOTE: new type added here +const bit<16> TYPE_MYTUNNEL = 0x1212; +const bit<16> TYPE_IPV4 = 0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +// NOTE: added new header type +header myTunnel_t { + bit<16> proto_id; + bit<16> dst_id; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { + +/* empty */ +} + + +// NOTE: Added new header type to headers struct +struct headers { + ethernet_t ethernet; + myTunnel_t myTunnel; + ipv4_t ipv4; +} + + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4 : parse_ipv4; + default : accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + + +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + + + + + + + apply { + + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000039__raw-repositories__ana13zs__p4tutorials.p4 b/individual_files/000039__raw-repositories__ana13zs__p4tutorials.p4 new file mode 100644 index 0000000000000000000000000000000000000000..f3726d72250af291cfad0d7124ac8d5c14680c74 --- /dev/null +++ b/individual_files/000039__raw-repositories__ana13zs__p4tutorials.p4 @@ -0,0 +1,163 @@ +#include +#include + +const bit<8> TCP_PROTOCOL = 0x06; +const bit<16> TYPE_IPV4 = 0x800; +const bit<19> ECN_THRESHOLD = 10; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + } + size = 1024; + default_action = drop; + } + + apply { + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.tos, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000040__raw-repositories__ana13zs__p4tutorials.p4 b/individual_files/000040__raw-repositories__ana13zs__p4tutorials.p4 new file mode 100644 index 0000000000000000000000000000000000000000..63370b4a0605de35579611294a165eff356fc54b --- /dev/null +++ b/individual_files/000040__raw-repositories__ana13zs__p4tutorials.p4 @@ -0,0 +1,232 @@ +#include +#include + +const bit<8> UDP_PROTOCOL = 0x11; +const bit<16> TYPE_IPV4 = 0x800; +const bit<5> IPV4_OPTION_MRI = 31; + +#define MAX_HOPS 9 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<32> switchID_t; +typedef bit<32> qdepth_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv4_option_t { + bit<1> copyFlag; + bit<2> optClass; + bit<5> option; + bit<8> optionLength; +} + +header mri_t { + bit<16> count; +} + +header switch_t { + switchID_t swid; + qdepth_t qdepth; +} + +struct ingress_metadata_t { + bit<16> count; +} + +struct parser_metadata_t { + bit<16> remaining; +} + +struct metadata { + ingress_metadata_t ingress_metadata; + parser_metadata_t parser_metadata; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv4_option_t ipv4_option; + mri_t mri; + switch_t[MAX_HOPS] swtraces; +} + +error { IPHeaderTooShort } + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + verify(hdr.ipv4.ihl >= 5, error.IPHeaderTooShort); + transition select(hdr.ipv4.ihl) { + 5 : accept; + default : parse_ipv4_option; + } + } + + state parse_ipv4_option { + + transition accept; + } + + state parse_mri { + + transition accept; + } + + state parse_swtrace { + + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action add_swtrace(switchID_t swid) { + + } + + table swtrace { + actions = { + add_swtrace; + NoAction; + } + + default_action = NoAction(); + } + + apply { + + swtrace.apply(); + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000041__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 b/individual_files/000041__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 new file mode 100644 index 0000000000000000000000000000000000000000..e4e87658441a720e8fab31f7462826a3012f6ac7 --- /dev/null +++ b/individual_files/000041__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 @@ -0,0 +1,279 @@ +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; +typedef bit<10> PortId_t; +const PortId_t NUM_PORTS = 512; +#define PACKET_COUNT_WIDTH 32 +#define TRESHOLD 200 +#define BYTE_COUNT_WIDTH 48 + +#define PACKET_BYTE_COUNT_WIDTH 80 + +#define PACKET_COUNT_RANGE (PACKET_BYTE_COUNT_WIDTH-1):BYTE_COUNT_WIDTH +#define BYTE_COUNT_RANGE (BYTE_COUNT_WIDTH-1):0 + +#define FLOW_TABLE_SIZE_EACH 1024 +#define HASH_BASE 10w0 +#define HASH_MAX 10w1023 +typedef bit PacketByteCountState_t; + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +struct ingress_metadata_t { + + bit<64> my_flowID; + bit<64> my_estimated_count; + bit<1> already_matched; + bit<32> nhop_ipv4; + bit<64> carry_min; + bit<64> carry_min_plus_one; + bit<8> min_stage; + bit<1> do_recirculate; + bit<9> orig_egr_port; + + bit<32> hashed_flow; + bit<32> hashed_flow_opposite; + bit<32> hashed_address_s3; + + bit<64> random_bits; + bit<12> random_bits_short; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; + ip4Addr_t realsrcAddr; + ip4Addr_t realdstAddr; +} + +struct metadata { + @name("ingress_metadata") + ingress_metadata_t ingress_metadata; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + direct_counter(CounterType.packets) c; + register>(1024) last_seen; + + register>(1024) flows; + + action get_inter_packet_gap(out bit<48> interval,bit<32> flow_id) + + { + bit<48> last_pkt_cnt; + bit<32> index; + +/* Get the time the previous packet was seen */ + last_seen.read(last_pkt_cnt,flow_id); + interval = last_pkt_cnt + 1; + +/* Update the register with the new timestamp */ + last_seen.write((bit<32>)flow_id, + interval); + } + action compute_flow_id () { + +// combines the source and destination IP addresses to create a unique flow ID for each flow + meta.ingress_metadata.my_flowID[31:0]=hdr.ipv4.srcAddr; + meta.ingress_metadata.my_flowID[63:32]=hdr.ipv4.dstAddr; + } + action compute_reg_index () { + + hash(meta.ingress_metadata.hashed_flow, HashAlgorithm.crc16, HASH_BASE, + {hdr.ipv4.srcAddr, 7w11, hdr.ipv4.dstAddr}, HASH_MAX); + hash(meta.ingress_metadata.hashed_flow_opposite, HashAlgorithm.crc16, HASH_BASE, + {hdr.ipv4.dstAddr, 7w11, hdr.ipv4.srcAddr}, HASH_MAX); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + action update_origin(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + counters = c; + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + if (hdr.ipv4.isValid()) { + +// if the packet is an IPv4 packet + ipv4_lpm.apply(); + +// apply the LPM table for routing + bit<48> tmp; + bit<32> flow; + bit<32> flow_opp; + compute_reg_index(); + +// compute the register index for the flow + bit<48> last_pkt_cnt; + bit<48> last_pkt_cnt_opp; + +/* Get the time the previous packet was seen */ + flow = meta.ingress_metadata.hashed_flow; + +// get the flow ID + flow_opp = meta.ingress_metadata.hashed_flow_opposite; + +// get the opposite flow ID + last_seen.read(last_pkt_cnt,flow); + +// read the last packet count of the flow + last_seen.read(last_pkt_cnt_opp,flow_opp); + +// read the last packet count of the opposite flow + tmp = last_pkt_cnt - last_pkt_cnt_opp + 1; + +// calculate the inter-packet gap + if(tmp < TRESHOLD) { + +// if the inter-packet gap is less than the threshold + + get_inter_packet_gap(last_pkt_cnt,flow); + +// it updates the inter-packet gap + } + else{ + drop(); + } + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000042__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 b/individual_files/000042__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 new file mode 100644 index 0000000000000000000000000000000000000000..f201925bc05805468e0f919c8caa2167e0e2e8db --- /dev/null +++ b/individual_files/000042__raw-repositories__benedettapacilli__programmable-networking-lab-exercises.p4 @@ -0,0 +1,292 @@ +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; +typedef bit<10> PortId_t; +const PortId_t NUM_PORTS = 512; +#define PACKET_COUNT_WIDTH 32 +#define TRESHOLD 200 + +//microseconds +#define WINDOW 15000000 + +// 15 seconds, time window for resetting asymmetric flow detection +#define BYTE_COUNT_WIDTH 48 + +#define PACKET_BYTE_COUNT_WIDTH 80 + +#define PACKET_COUNT_RANGE (PACKET_BYTE_COUNT_WIDTH-1):BYTE_COUNT_WIDTH +#define BYTE_COUNT_RANGE (BYTE_COUNT_WIDTH-1):0 + +#define FLOW_TABLE_SIZE_EACH 1024 +#define HASH_BASE 10w0 +#define HASH_MAX 10w1023 +typedef bit PacketByteCountState_t; + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +struct ingress_metadata_t { + + bit<64> my_flowID; + bit<64> my_estimated_count; + bit<1> already_matched; + bit<32> nhop_ipv4; + bit<64> carry_min; + bit<64> carry_min_plus_one; + bit<8> min_stage; + bit<1> do_recirculate; + bit<9> orig_egr_port; + + + bit<32> hashed_flow; + bit<32> hashed_flow_opposite; + bit<32> hashed_address_s3; + + bit<64> random_bits; + bit<12> random_bits_short; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; + ip4Addr_t realsrcAddr; + ip4Addr_t realdstAddr; +} + +struct metadata { + @name("ingress_metadata") + ingress_metadata_t ingress_metadata; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + direct_counter(CounterType.packets) c; + register>(1024) last_seen; + register>(1024) window; + + action get_inter_packet_gap(out bit<48> interval,bit<32> flow_id) + + { + bit<48> last_pkt_cnt; + bit<32> index; + +/* Get the time the previous packet was seen */ + last_seen.read(last_pkt_cnt,flow_id); + interval = last_pkt_cnt + 1; + +/* Update the register with the new timestamp */ + last_seen.write((bit<32>)flow_id, + interval); + } + + action restore_flow(bit<32> flow,bit<32> flow_opp) + +// resets the flow and the opposite registers + { + + last_seen.write((bit<32>)flow,0); + last_seen.write((bit<32>)flow_opp,0); + } + + action compute_reg_index () { + + hash(meta.ingress_metadata.hashed_flow, HashAlgorithm.crc16, HASH_BASE, + {hdr.ipv4.srcAddr, 7w11, hdr.ipv4.dstAddr}, HASH_MAX); + hash(meta.ingress_metadata.hashed_flow_opposite, HashAlgorithm.crc16, HASH_BASE, + {hdr.ipv4.dstAddr, 7w11, hdr.ipv4.srcAddr}, HASH_MAX); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + counters = c; + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + bit<48> tmp; + bit<48> time; + bit<32> flow; + bit<32> flow_opp; + compute_reg_index(); + bit<48> last_pkt_cnt; + bit<48> last_pkt_cnt_opp; + + bit<48> last_time; + bit<48> intertime; + +/* Get the time the previous packet was seen */ + flow = meta.ingress_metadata.hashed_flow; + flow_opp = meta.ingress_metadata.hashed_flow_opposite; + + window.read(last_time,flow); + + +// first time initialize + if(last_time == (bit<48>)0){ + window.write((bit<32>)flow,standard_metadata.ingress_global_timestamp); + +// write the first packet + } + + intertime = standard_metadata.ingress_global_timestamp - last_time; + +// intertime is the time difference between the last packet and the current packet + window.write((bit<32>)flow,standard_metadata.ingress_global_timestamp); + +// check window + if(intertime > WINDOW){ + +// if the time difference is greater than the window, reset the flow + restore_flow(flow,flow_opp); + } + else{ + + } + + last_seen.read(last_pkt_cnt,flow); + last_seen.read(last_pkt_cnt_opp,flow_opp); + tmp = last_pkt_cnt - last_pkt_cnt_opp + 1; + + if(tmp < TRESHOLD) { + get_inter_packet_gap(last_pkt_cnt,flow); + } + else{ + drop(); + } + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000043__raw-repositories__ByungUkMin__p4-encryption.p4 b/individual_files/000043__raw-repositories__ByungUkMin__p4-encryption.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8ef61ccc1499586284dcf5964ea694dcf0121cc7 --- /dev/null +++ b/individual_files/000043__raw-repositories__ByungUkMin__p4-encryption.p4 @@ -0,0 +1,164 @@ +#include +#include + +#define MCAST_ID 1 +#define CPU_PORT 255 + + +typedef bit<48> macAddr_t; + + +/**/ +/* Headers */ +/**/ + +@controller_header("packet_in") +header packet_in_header_t { + bit<9> ingress_port; + bit<7> _pad; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + packet_in_header_t packet_in; +} + + +/**/ +/* Parser */ +/**/ + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition accept; + } +} + + +/**/ +/* Checksum Verification */ +/**/ + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +/**/ +/* Ingress Processing */ +/**/ + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action flood() { + standard_metadata.mcast_grp = MCAST_ID; + } + + table bridge_table { + key = { + hdr.ethernet.dstAddr: exact; + standard_metadata.ingress_port: exact; + } + actions = { + drop; + flood; + } + size = 1024; + default_action = flood; + } + + apply { + bridge_table.apply(); + } +} + + +/**/ +/* Egress Processing */ +/**/ + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action to_controller() { + hdr.packet_in.setValid(); + hdr.packet_in.ingress_port = standard_metadata.ingress_port; + } + + apply { + +// Prune multicast packets going to ingress port to prevent loops + if (standard_metadata.egress_port == standard_metadata.ingress_port) + drop(); + + +// Send a copy of the packet to the controller for learning + if (standard_metadata.egress_port == CPU_PORT) + to_controller(); + } +} + + +/**/ +/* Checksum Computation */ +/**/ + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +/**/ +/* Deparser */ +/**/ + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.packet_in); + packet.emit(hdr.ethernet); + } +} + + +/**/ +/* Bridge */ +/**/ + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000044__raw-repositories__ByungUkMin__p4-encryption.p4 b/individual_files/000044__raw-repositories__ByungUkMin__p4-encryption.p4 new file mode 100644 index 0000000000000000000000000000000000000000..29e3da4379c024f0e354b720848442a9fd90c590 --- /dev/null +++ b/individual_files/000044__raw-repositories__ByungUkMin__p4-encryption.p4 @@ -0,0 +1,287 @@ +#include +#include + +#define MCAST_ID 1 +#define CPU_PORT 255 + + +#define ETH_TYPE_ARP 0x0806 +#define ETH_TYPE_VLAN 0x8100 + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; + + +/**/ +/* Headers */ +/**/ + +@controller_header("packet_in") +header packet_in_header_t { + bit<9> ingress_port; + bit<7> _pad; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header vlan_t { + bit<3> pcp; + bit<1> cfi; + bit<12> vid; + bit<16> etherType; +} + +struct metadata { + bit<12> vid; + bit<16> etherType; + bit<4> _pad; +} + +struct headers { + vlan_t vlan; + ethernet_t ethernet; + packet_in_header_t packet_in; +} + + +/**/ +/* Parser */ +/**/ + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + meta.vid = 0; + meta.etherType = hdr.ethernet.etherType; + transition select(hdr.ethernet.etherType) { + ETH_TYPE_VLAN: parse_vlan; + default: accept; + } + } + + state parse_vlan { + packet.extract(hdr.vlan); + meta.vid = hdr.vlan.vid; + meta.etherType = hdr.vlan.etherType; + transition accept; + } +} + + +/**/ +/* Checksum Verification */ +/**/ + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +/**/ +/* Ingress Processing */ +/**/ + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action forward(egressSpec_t port) { + standard_metadata.egress_spec = port; + } + + action flood() { + standard_metadata.mcast_grp = MCAST_ID; + } + +/**/ +/* Switch Table Logic - Begins */ +/**/ + + + + table switch_table { + key = { + hdr.ethernet.dstAddr: exact; + meta.vid: exact; + + } + actions = { + flood; + forward; + } + size = 1024; + default_action = flood; + } + + +/**/ +/* Switch Table Logic - Ends */ +/**/ + + apply { + +/**/ +/* Ingress Apply Logic - Begins */ +/**/ + + + + if (hdr.ethernet.etherType == ETH_TYPE_VLAN) { + +// VLAN-enabled + if (meta.etherType == ETH_TYPE_ARP) { + +// VLAN-enabled + ARP packet + flood(); + } + else { + +// VLAN-enabled + Non-ARP packet + switch_table.apply(); + } + } + else if (hdr.ethernet.etherType == ETH_TYPE_ARP) { + +// Non-VLAN + ARP packet + flood(); + } + else { + +// Non-VLAN + Non-ARP packet + switch_table.apply(); + } + + +/**/ +/* Ingress Apply Logic - Ends */ +/**/ + } +} + + +/**/ +/* Egress Processing */ +/**/ + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action noop() { + +/* empty */ + } + + action drop() { + mark_to_drop(standard_metadata); + } + + action to_controller() { + hdr.packet_in.setValid(); + hdr.packet_in.ingress_port = standard_metadata.ingress_port; + } + + +/**/ +/* VLAN Table Logic - Begins */ +/**/ + + + + table vlan_table { + key = { + + meta.vid: exact; + standard_metadata.egress_port: exact; + } + actions = { + noop; + drop; + } + size = 1024; + default_action = drop; + } + + +/**/ +/* Switch Table Logic - Ends */ +/**/ + + apply { + +/**/ +/* Egress Apply Logic - Begins */ +/**/ + + + + +// (1) Prune multicast packets going to ingress port to prevent loops + if (standard_metadata.egress_port == standard_metadata.ingress_port) + drop(); + + + +// (2) Send a copy of the packet to the controller for learning + if (standard_metadata.egress_port == CPU_PORT) + to_controller(); + + +// (3) Check if the VLAN header exists. If yes, then drop packets ... + if (hdr.ethernet.etherType == ETH_TYPE_VLAN) { + vlan_table.apply(); + } + + +/**/ +/* Egress Apply Logic - Ends */ +/**/ + } +} + + +/**/ +/* Checksum Computation */ +/**/ + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +/**/ +/* Deparser */ +/**/ + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.packet_in); + packet.emit(hdr.ethernet); + packet.emit(hdr.vlan); + } +} + + +/**/ +/* Switch */ +/**/ + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000045__raw-repositories__cpt-harlock__p4-cuckoo-hash.p4 b/individual_files/000045__raw-repositories__cpt-harlock__p4-cuckoo-hash.p4 new file mode 100644 index 0000000000000000000000000000000000000000..2fa3fd2cbc7821f7ffe831884e97834fc22aacb0 --- /dev/null +++ b/individual_files/000045__raw-repositories__cpt-harlock__p4-cuckoo-hash.p4 @@ -0,0 +1,198 @@ +#include +#include + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + +#define CH_LENGTH 512 +#define CH_LENGTH_BIT 16w512 + +// 106 bits per register, first 96 bits for key and others for value +register>(CH_LENGTH) ch_first_row; +register>(CH_LENGTH) ch_second_row; +register>(1) counter_reg; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 0x0800: parse_ip; + default: reject; + } + } + + state parse_ip { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 0x6: parse_tcp; + default: reject; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + + + + + + + + +//compute CH indices + apply { + bit<32> first_index; + bit<32> second_index; + bit<96> packet_key = hdr.ipv4.srcAddr ++ hdr.ipv4.dstAddr ++ hdr.tcp.srcPort ++ hdr.tcp.dstPort; + hash(first_index, HashAlgorithm.crc16, 16w0, { 0w0, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.srcPort, hdr.tcp.dstPort }, 16w512); + hash(second_index, HashAlgorithm.crc16, 16w0, { 1w0, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.srcPort, hdr.tcp.dstPort }, 16w512); + bit<106> first_result; + bit<106> second_result; + bit<10> counter_result; + ch_first_row.read(first_result, first_index); + ch_second_row.read(second_result, second_index); + if (first_result[95:0] == packet_key) { + +//do nothing + } else if (second_result[95:0] == packet_key) { + +//do nothing + } else if (first_result[95:0] == 96w0) { + counter_reg.read(counter_result, 0); + ch_first_row.write(first_index, counter_result ++ packet_key); + counter_reg.write(0, counter_result+1); + } else if (second_result[95:0] == 96w0) { + counter_reg.read(counter_result, 0); + ch_second_row.write(second_index, counter_result ++ packet_key); + counter_reg.write(0, counter_result+1); + } + + + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000046__raw-repositories__bennyrubin__HydraCode.p4 b/individual_files/000046__raw-repositories__bennyrubin__HydraCode.p4 new file mode 100644 index 0000000000000000000000000000000000000000..f5ef987dd4ac752c1ea99977b9bdfecdaf215151 --- /dev/null +++ b/individual_files/000046__raw-repositories__bennyrubin__HydraCode.p4 @@ -0,0 +1,406 @@ +#include +#include + +#include + +#define ETHERTYPE_CHECKER 0x5678; + +header eth_type2_t { + bit<16> value; +} +header variables_t { + +} +header slices_preamble_t { + bit<8> num_items_slices; +} +header slices_item_t { + bit<32> value; +} +struct hydra_header_t { + eth_type2_t eth_type; + variables_t variables; + slices_preamble_t slices_preamble; + slices_item_t[3] slices; +} +struct hydra_metadata_t { + bool reject0; + bit<8> num_list_items; + bit<32> switch_slice; +} +parser CheckerHeaderParser(packet_in packet, out hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + state start { + packet.extract(hydra_header.eth_type); + transition parse_variables; + } + state parse_variables { + packet.extract(hydra_header.variables); + transition parse_slices_preamble; + } + state parse_slices_preamble + { + packet.extract(hydra_header.slices_preamble); + hydra_metadata.num_list_items = + hydra_header.slices_preamble.num_items_slices; + transition select(hydra_metadata.num_list_items) { + 0: accept; + default: parse_slices; + } + } + state parse_slices + { + packet.extract(hydra_header.slices.next); + hydra_metadata.num_list_items = hydra_metadata.num_list_items-1; + transition select(hydra_metadata.num_list_items) { + 0: accept; + default: parse_slices; + } + } +} +control CheckerHeaderDeparser(packet_out packet, + in hydra_header_t hydra_header) { + apply + { + packet.emit(hydra_header.eth_type); + packet.emit(hydra_header.variables); + packet.emit(hydra_header.slices_preamble); + packet.emit(hydra_header.slices); + } +} +control initControl(inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + action init_cp_vars(bit<32> switch_slice) + { + hydra_metadata.switch_slice = switch_slice; + } + table tb_init_cp_vars { + key = { + + } + actions = { + init_cp_vars; + } + size = 2; + } + apply + { + tb_init_cp_vars.apply(); + hydra_header.eth_type.setValid(); + hydra_header.eth_type.value = ETHERTYPE_CHECKER; + hydra_header.slices_preamble.setValid(); + hydra_header.slices_preamble.num_items_slices = 0; + } +} +control telemetryControl(inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + action init_cp_vars(bit<32> switch_slice) + { + hydra_metadata.switch_slice = switch_slice; + } + table tb_init_cp_vars { + key = { + + } + actions = { + init_cp_vars; + } + size = 2; + } + apply + { + tb_init_cp_vars.apply(); + hydra_header.slices.push_front(1); + hydra_header.slices[0].setValid(); + hydra_header.slices[0].value = 1; + hydra_header.slices_preamble.num_items_slices = hydra_header.slices_preamble.num_items_slices + 1; + } +} +control checkerControl(inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + action init_cp_vars(bit<32> switch_slice) + { + hydra_metadata.switch_slice = switch_slice; + } + table tb_init_cp_vars { + key = { + + } + actions = { + init_cp_vars; + } + size = 2; + } + apply + { + tb_init_cp_vars.apply(); + bit<32> prev_slice = hydra_header.slices[0].value; + bit<32> slice; + if (hydra_header.slices[0].isValid()) + { + slice = hydra_header.slices[0].value; + if (prev_slice!=slice) { + hydra_metadata.reject0 = true; + } + prev_slice = slice; + if (hydra_header.slices[1].isValid()) + { + slice = hydra_header.slices[1].value; + if (prev_slice!=slice) { + hydra_metadata.reject0 = true; + } + prev_slice = slice; + if (hydra_header.slices[2].isValid()) + { + slice = hydra_header.slices[2].value; + if (prev_slice!=slice) { + hydra_metadata.reject0 = true; + } + prev_slice = slice; + } + } + } + + hydra_header.eth_type.setInvalid(); + hydra_header.variables.setInvalid(); + hydra_header.slices_preamble.setInvalid(); + hydra_header.slices[0].setInvalid(); + hydra_header.slices[1].setInvalid(); + hydra_header.slices[2].setInvalid(); + } +} + + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_HYDRA = 0x5678; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; +} + +header eth_type_t { + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { + bool first_hop; + bool last_hop; + hydra_metadata_t hydra_metadata; +} + +struct headers { + ethernet_t ethernet; + hydra_header_t hydra_header; + eth_type_t eth_type; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + CheckerHeaderParser() hydra_parser; + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition parse_tele_or_eth_type; + } + + state parse_tele_or_eth_type { + transition select(packet.lookahead>()) { + TYPE_HYDRA: parse_hydra_headers; + default: parse_eth_type; + } + } + + state parse_hydra_headers { + hydra_parser.apply(packet, hdr.hydra_header, meta.hydra_metadata); + transition parse_eth_type; + } + + state parse_eth_type { + packet.extract(hdr.eth_type); + transition select(hdr.eth_type.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + action set_first_hop() { + meta.first_hop = true; + } + + table tb_check_first_hop { + key = { + standard_metadata.ingress_port: exact; + } + actions = { + @defaultonly NoAction; + set_first_hop; + } + const default_action = NoAction(); + size = 512; + } + + apply { + tb_check_first_hop.apply(); + if (meta.first_hop) { + initControl.apply(hdr.hydra_header, meta.hydra_metadata); + } + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action set_last_hop() { + meta.last_hop = true; + } + + table tb_check_last_hop { + key = { + standard_metadata.egress_port: exact; + } + actions = { + @defaultonly NoAction; + set_last_hop; + } + const default_action = NoAction(); + size = 512; + } + + apply { + telemetryControl.apply(hdr.hydra_header, meta.hydra_metadata); + tb_check_last_hop.apply(); + if (meta.last_hop) { + checkerControl.apply(hdr.hydra_header, meta.hydra_metadata); + } + if (meta.hydra_metadata.reject0) { + mark_to_drop(standard_metadata); + } + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + + CheckerHeaderDeparser() hydra_deparser; + + apply { + packet.emit(hdr.ethernet); + hydra_deparser.apply(packet, hdr.hydra_header); + packet.emit(hdr.eth_type); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000047__raw-repositories__bennyrubin__HydraCode.p4 b/individual_files/000047__raw-repositories__bennyrubin__HydraCode.p4 new file mode 100644 index 0000000000000000000000000000000000000000..f934ed42079ae5d19d278e017081a9af7fb252b1 --- /dev/null +++ b/individual_files/000047__raw-repositories__bennyrubin__HydraCode.p4 @@ -0,0 +1,487 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_SRCROUTING = 0x1234; +const bit<16> TYPE_HYDRA = 0x5678; + + +#define MAX_HOPS 9 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header srcRoute_t { + bit<1> bos; + bit<15> port; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +#include + +#define ETHERTYPE_CHECKER 0x5678; + + +header eth_type2_t { + bit<16> value; +} +header variables_t { + bit<7> index; + bool to_reject; +} +header expected_path_preamble_t { + bit<8> num_items_expected_path; +} +header expected_path_item_t { + bit<16> value; +} +struct hydra_header_t { + eth_type2_t eth_type; + variables_t variables; + expected_path_preamble_t expected_path_preamble; + expected_path_item_t[3] expected_path; +} +struct hydra_metadata_t { + bool reject0; + bit<8> num_list_items; + bit<16> switch_id; + bit<32> expected_s3_dict_var0; + bit<32> expected_s2_dict_var0; + bit<32> expected_s1_dict_var0; + bit<16> expected_s1_dict; + bit<16> expected_s2_dict; + bit<16> expected_s3_dict; +} +parser CheckerHeaderParser(packet_in packet, out hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + state start { + packet.extract(hydra_header.eth_type); + transition parse_variables; + } + state parse_variables { + packet.extract(hydra_header.variables); + transition parse_expected_path_preamble; + } + + state parse_expected_path_preamble + { + packet.extract(hydra_header.expected_path_preamble); + hydra_metadata.num_list_items = + hydra_header.expected_path_preamble.num_items_expected_path; + transition select(hydra_metadata.num_list_items) { + 0: accept; + default: parse_expected_path; + } + } + + state parse_expected_path + { + packet.extract(hydra_header.expected_path.next); + hydra_metadata.num_list_items = hydra_metadata.num_list_items-1; + transition select(hydra_metadata.num_list_items) { + 0: accept; + default: parse_expected_path; + } + } +} +control CheckerHeaderDeparser(packet_out packet, + in hydra_header_t hydra_header) { + apply + { + packet.emit(hydra_header.eth_type); + packet.emit(hydra_header.variables); + packet.emit(hydra_header.expected_path_preamble); + packet.emit(hydra_header.expected_path); + } +} +control initControl(in ipv4_t ipv4, + inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + + action lkp_cp_dict_expected_s3_dict(bit<16> expected_s3_dict) + { + hydra_metadata.expected_s3_dict = expected_s3_dict; + } + table tbl_lkp_cp_dict_expected_s3_dict + { + key = { + hydra_metadata.expected_s3_dict_var0: lpm; + } + actions = { + lkp_cp_dict_expected_s3_dict; + } + size = 64; + } + + action lkp_cp_dict_expected_s2_dict(bit<16> expected_s2_dict) + { + hydra_metadata.expected_s2_dict = expected_s2_dict; + } + + table tbl_lkp_cp_dict_expected_s2_dict + { + key = { + hydra_metadata.expected_s2_dict_var0: lpm; + } + actions = { + lkp_cp_dict_expected_s2_dict; + } + size = 64; + } + + action lkp_cp_dict_expected_s1_dict(bit<16> expected_s1_dict) + { + hydra_metadata.expected_s1_dict = expected_s1_dict; + } + + table tbl_lkp_cp_dict_expected_s1_dict + { + key = { + hydra_metadata.expected_s1_dict_var0: lpm; + } + actions = { + lkp_cp_dict_expected_s1_dict; + } + size = 64; + } + + table tb_debug { + key = { + hydra_header.expected_path[0].value: exact; + hydra_header.expected_path[1].value: exact; + hydra_header.expected_path[2].value: exact; + } + actions = { + lkp_cp_dict_expected_s1_dict; + } + const entries = { + (0,0,0): lkp_cp_dict_expected_s1_dict(0); + } + size = 2; + } + + apply + { + hydra_header.eth_type.setValid(); + hydra_header.eth_type.value = ETHERTYPE_CHECKER; + hydra_header.variables.setValid(); + hydra_header.variables.index = 0; + hydra_header.variables.to_reject = false; + hydra_header.expected_path_preamble.setValid(); + hydra_metadata.expected_s3_dict_var0 = ipv4.dstAddr; + +// 167773188; + tbl_lkp_cp_dict_expected_s3_dict.apply(); + hydra_header.expected_path.push_front(1); + hydra_header.expected_path[0].setValid(); + hydra_header.expected_path[0].value = + hydra_metadata.expected_s3_dict; + hydra_metadata.expected_s2_dict_var0 = ipv4.dstAddr; + tbl_lkp_cp_dict_expected_s2_dict.apply(); + hydra_header.expected_path.push_front(1); + hydra_header.expected_path[0].setValid(); + hydra_header.expected_path[0].value = + hydra_metadata.expected_s2_dict; + hydra_metadata.expected_s1_dict_var0 = ipv4.dstAddr; + tbl_lkp_cp_dict_expected_s1_dict.apply(); + hydra_header.expected_path.push_front(1); + hydra_header.expected_path[0].setValid(); + hydra_header.expected_path[0].value = + hydra_metadata.expected_s1_dict; + hydra_header.expected_path_preamble.num_items_expected_path = 3; + tb_debug.apply(); + } +} +control telemetryControl( + inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + action init_cp_vars(bit<16> switch_id) + { + hydra_metadata.switch_id = switch_id; + } + table tb_init_cp_vars { + key = { + hydra_header.eth_type.isValid(): exact; + } + actions = { + init_cp_vars; + } + size = 2; + } + + table tb_debug { + key = { + hydra_header.expected_path[0].value: exact; + hydra_header.expected_path[1].value: exact; + hydra_header.expected_path[2].value: exact; + hydra_metadata.switch_id: exact; + hydra_header.variables.index: exact; + } + actions = { + init_cp_vars; + } + const entries = { + (0,0,0,0,0): init_cp_vars(0); + } + size = 2; + } + + apply { + tb_init_cp_vars.apply(); + tb_debug.apply(); + if (hydra_header.expected_path[hydra_header.variables.index].value != hydra_metadata.switch_id) + { + hydra_header.variables.to_reject = true; + } else { + if (hydra_header.variables.index<3) { + hydra_header.variables.index = hydra_header.variables.index+1; + } else { + hydra_header.variables.to_reject = true; + } + } + } +} +control checkerControl( + inout hydra_header_t hydra_header, + inout hydra_metadata_t hydra_metadata) { + + apply + { + + if (hydra_header.variables.to_reject) { + hydra_metadata.reject0 = true; + } + hydra_header.eth_type.setInvalid(); + hydra_header.variables.setInvalid(); + hydra_header.expected_path_preamble.setInvalid(); + hydra_header.expected_path[0].setInvalid(); + hydra_header.expected_path[1].setInvalid(); + hydra_header.expected_path[2].setInvalid(); + } +} + + + + +struct metadata { + bool first_hop; + bool last_hop; + hydra_metadata_t hydra_metadata; +} + +struct headers { + ethernet_t ethernet; + hydra_header_t hydra_header; + srcRoute_t[MAX_HOPS] srcRoutes; + ipv4_t ipv4; +} + + + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + CheckerHeaderParser() hydra_parser; + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition parse_hydra_or_eth_type; + } + + state parse_hydra_or_eth_type { + transition select(packet.lookahead>()) { + TYPE_HYDRA: parse_hydra_headers; + default: parse_srcRouting_first; + } + } + + state parse_hydra_headers { + hydra_parser.apply(packet, hdr.hydra_header, meta.hydra_metadata); + transition parse_srcRouting_first; + } + + state parse_srcRouting_first { + transition select(hdr.ethernet.etherType) { + TYPE_SRCROUTING: parse_srcRouting; + default: accept; + } + } + + state parse_srcRouting { + packet.extract(hdr.srcRoutes.next); + transition select(hdr.srcRoutes.last.bos) { + 1: parse_ipv4; + default: parse_srcRouting; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action srcRoute_nhop() { + standard_metadata.egress_spec = (bit<9>)hdr.srcRoutes[0].port; + hdr.srcRoutes.pop_front(1); + } + + action srcRoute_finish() { + hdr.ethernet.etherType = TYPE_IPV4; + } + + action update_ttl(){ + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + action set_first_hop() { + meta.first_hop = true; + } + + table tb_check_first_hop { + key = { + standard_metadata.ingress_port: exact; + } + actions = { + @defaultonly NoAction; + set_first_hop; + } + const default_action = NoAction(); + size = 512; + } + + apply { + + tb_check_first_hop.apply(); + if (meta.first_hop) { + initControl.apply(hdr.ipv4, hdr.hydra_header, meta.hydra_metadata); + } + + if (hdr.srcRoutes[0].isValid()){ + if (hdr.srcRoutes[0].bos == 1){ + srcRoute_finish(); + } + srcRoute_nhop(); + if (hdr.ipv4.isValid()){ + update_ttl(); + } + }else{ + drop(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action set_last_hop() { + meta.last_hop = true; + } + + table tb_check_last_hop { + key = { + standard_metadata.egress_port: exact; + } + actions = { + @defaultonly NoAction; + set_last_hop; + } + const default_action = NoAction(); + size = 512; + } + + apply { + telemetryControl.apply(hdr.hydra_header, meta.hydra_metadata); + tb_check_last_hop.apply(); + if (meta.last_hop) { + checkerControl.apply(hdr.hydra_header, meta.hydra_metadata); + } + if (meta.hydra_metadata.reject0) { + mark_to_drop(standard_metadata); + } + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + + CheckerHeaderDeparser() hydra_deparser; + + apply { + packet.emit(hdr.ethernet); + hydra_deparser.apply(packet, hdr.hydra_header); + packet.emit(hdr.srcRoutes); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000048__raw-repositories__cslev__p4.p4 b/individual_files/000048__raw-repositories__cslev__p4.p4 new file mode 100644 index 0000000000000000000000000000000000000000..e57f3848fbc686dc50da383b468d6f309430a511 --- /dev/null +++ b/individual_files/000048__raw-repositories__cslev__p4.p4 @@ -0,0 +1,114 @@ +#include +#include + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition accept; + } + +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action portfwd(egressSpec_t port) { + standard_metadata.egress_spec = port; + } + + + table port_exact { + key = { + standard_metadata.ingress_port: exact; + } + actions = { + portfwd; + drop; + } + size = 10; + default_action = drop; + } + + + apply { + port_exact.apply(); + + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } + +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000049__raw-repositories__dcomp-leris__VR-AR-CG-network-telemetry.p4 b/individual_files/000049__raw-repositories__dcomp-leris__VR-AR-CG-network-telemetry.p4 new file mode 100644 index 0000000000000000000000000000000000000000..ffbdbea0da74128bb65b8c2202b7923daee22c73 --- /dev/null +++ b/individual_files/000049__raw-repositories__dcomp-leris__VR-AR-CG-network-telemetry.p4 @@ -0,0 +1,252 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<8> IP_PROTO = 253; + + +#define PKT_INSTANCE_TYPE_NORMAL 0 +#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1 +#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2 +#define PKT_INSTANCE_TYPE_COALESCED 3 +#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4 + + +#define MAX_HOPS 10 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<31> switchID_v; +typedef bit<9> ingress_port_v; +typedef bit<9> egress_port_v; +typedef bit<9> egressSpec_v; +typedef bit<48> ingress_global_timestamp_v; +typedef bit<48> egress_global_timestamp_v; +typedef bit<32> enq_timestamp_v; +typedef bit<19> enq_qdepth_v; +typedef bit<32> deq_timedelta_v; +typedef bit<19> deq_qdepth_v; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header nodeCount_h{ + bit<16> count; +} + +header InBandNetworkTelemetry_h { + switchID_v swid; + ingress_port_v ingress_port; + egress_port_v egress_port; + egressSpec_v egress_spec; + ingress_global_timestamp_v ingress_global_timestamp; + egress_global_timestamp_v egress_global_timestamp; + enq_timestamp_v enq_timestamp; + enq_qdepth_v enq_qdepth; + deq_timedelta_v deq_timedelta; + deq_qdepth_v deq_qdepth; +} + + +struct ingress_metadata_t { + bit<16> count; +} + +struct parser_metadata_t { + bit<16> remaining; +} + + +struct metadata { + ingress_metadata_t ingress_metadata; + parser_metadata_t parser_metadata; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + nodeCount_h nodeCount; + InBandNetworkTelemetry_h[MAX_HOPS] INT; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + IP_PROTO: parse_count; + default: accept; + } + } + + state parse_count{ + packet.extract(hdr.nodeCount); + meta.parser_metadata.remaining = hdr.nodeCount.count; + transition select(meta.parser_metadata.remaining) { + 0 : accept; + default: parse_int; + } + } + + state parse_int { + packet.extract(hdr.INT.next); + meta.parser_metadata.remaining = meta.parser_metadata.remaining - 1; + transition select(meta.parser_metadata.remaining) { + 0 : accept; + default: parse_int; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action send_back() { + standard_metadata.egress_spec = standard_metadata.ingress_port; + bit<48> tmp_mac; + bit<32> tmp_ip; + + tmp_mac = hdr.ethernet.srcAddr; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = tmp_mac; + + tmp_ip = hdr.ipv4.srcAddr; + hdr.ipv4.srcAddr = hdr.ipv4.dstAddr; + hdr.ipv4.dstAddr = tmp_ip; + } + + apply { + if (hdr.nodeCount.isValid() && standard_metadata.instance_type == PKT_INSTANCE_TYPE_INGRESS_RECIRC) { + send_back(); + } else { + standard_metadata.egress_spec = (standard_metadata.ingress_port+1)%2; + } + + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action my_recirculate() { + recirculate_preserving_field_list(0); + } + + action add_swtrace() { + hdr.nodeCount.count = hdr.nodeCount.count + 1; + hdr.INT.push_front(1); + hdr.INT[0].setValid(); + +//1 para downlink, 2 para uplink + if (hdr.nodeCount.count == 2){ + hdr.INT[0].swid = 1; + } else { + hdr.INT[0].swid = 2; + } + hdr.INT[0].ingress_port = (ingress_port_v)standard_metadata.ingress_port; + hdr.INT[0].egress_port = (egress_port_v)standard_metadata.egress_port; + hdr.INT[0].egress_spec = (egressSpec_v)standard_metadata.egress_spec; + hdr.INT[0].ingress_global_timestamp = (ingress_global_timestamp_v)standard_metadata.ingress_global_timestamp; + hdr.INT[0].egress_global_timestamp = (egress_global_timestamp_v)standard_metadata.egress_global_timestamp; + hdr.INT[0].enq_timestamp = (enq_timestamp_v)standard_metadata.enq_timestamp; + hdr.INT[0].enq_qdepth = (enq_qdepth_v)standard_metadata.enq_qdepth; + hdr.INT[0].deq_timedelta = (deq_timedelta_v)standard_metadata.deq_timedelta; + hdr.INT[0].deq_qdepth = (deq_qdepth_v)standard_metadata.deq_qdepth; + + hdr.ipv4.totalLen = hdr.ipv4.totalLen + 32; + + } + + apply { + + if (hdr.nodeCount.isValid()) { + add_swtrace(); + if (hdr.nodeCount.count < 2){ + my_recirculate(); + } + } + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.nodeCount); + packet.emit(hdr.INT); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000050__raw-repositories__DETERMINISTIC6G__det6g-blog-prog-soft-tsn-switch.p4 b/individual_files/000050__raw-repositories__DETERMINISTIC6G__det6g-blog-prog-soft-tsn-switch.p4 new file mode 100644 index 0000000000000000000000000000000000000000..369a105dcc3b8d45f605560e03108c98e6e6e9f6 --- /dev/null +++ b/individual_files/000050__raw-repositories__DETERMINISTIC6G__det6g-blog-prog-soft-tsn-switch.p4 @@ -0,0 +1,168 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<16> TYPE_VLAN = 0x8100; + +const bit<8> TYPE_UDP = 0x11; + +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header vlan_h { + bit<3> pcp; + bit<1> dei; + bit<12> vid; + bit<16> etherType; +} + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> udpTotalLen; + bit<16> checksum; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + vlan_h vlan; + ipv4_t ipv4; + udp_t udp; +} + +parser myParser(packet_in packet, out headers hdr, + inout metadata meta, inout standard_metadata_t std_data) { + + state start { + + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_VLAN: parse_vlan; + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_vlan { + packet.extract(hdr.vlan); + transition select(hdr.vlan.etherType){ + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + TYPE_UDP: parse_udp; + default : accept; + } + } + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } +} + + +control myVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + +control myIngress(inout headers hdr, inout metadata meta, + inout standard_metadata_t std_data) { + apply { + +// naif routing + if( std_data.ingress_port == 1 ) + std_data.egress_spec = 2; + else + std_data.egress_spec = 1; + } +} + + + +register >(1) last_tc0_packet_ts; + +control myEgress(inout headers hdr, inout metadata meta, + inout standard_metadata_t std_data) { + bit<48> ts; + bit<48> last_ts; + apply { + +//enable VLAN if it is not existing + if( ! hdr.vlan.isValid() ){ + hdr.vlan.setValid(); + hdr.vlan.etherType = hdr.ethernet.etherType; + hdr.ethernet.etherType = TYPE_VLAN; + } + + @atomic { + +//get ingress timestamp (in microsecond) of the current packet + ts = std_data.ingress_global_timestamp; + +//dynamically adjust VLAN PCP + if( hdr.udp.isValid() && hdr.udp.dstPort == 1000 ){ + hdr.vlan.pcp = 0; + + last_tc0_packet_ts.write( 0, ts); + } else { + +// get the timestamp from the first element of the array + last_tc0_packet_ts.read( last_ts, 0 ); + if( ts - last_ts > 1*1000*1000 ) + hdr.vlan.pcp = 0; + else + hdr.vlan.pcp = 1; + } + } + } +} + +control myComputeChecksum(inout headers hdr, inout metadata meta) { + apply {} +} + +control myDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.vlan); + packet.emit(hdr.ipv4); + packet.emit(hdr.udp); + } +} + + +//switch architecture +V1Switch( + myParser(), myVerifyChecksum(), myIngress(), myEgress(), myComputeChecksum(), myDeparser() +) main; diff --git a/individual_files/000051__raw-repositories__emdneto__dh-aes-p4.p4 b/individual_files/000051__raw-repositories__emdneto__dh-aes-p4.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9a4b28d7ac69deef21c6c29e5f0431c5af2d624b --- /dev/null +++ b/individual_files/000051__raw-repositories__emdneto__dh-aes-p4.p4 @@ -0,0 +1,172 @@ +// Standard headers +#include +#include + + + +// useful for DH +typedef bit<256> keys_t; +typedef bit<48> macAddr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + macAddr_t srcAddr; + macAddr_t dstAddr; +} + +header tcp_t{ + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<4> res; + bit<1> cwr; + bit<1> ece; + bit<1> urg; + bit<1> ack; + bit<1> psh; + bit<1> rst; + bit<1> syn; + bit<1> fin; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +#define ETHERTYPE_AES_TOY 0x9999 + +header aes_inout_t { + bit<128> value; +} + +struct my_headers_t { + ethernet_t ethernet; + aes_inout_t aes_inout; +} + +header aes_meta_t { + +// internal state, 4 rows +} + +header dh_meta_t { + bit<256> secrect; + bit<256> pu; +} +struct my_metadata_t { + aes_meta_t aes; +} + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + ETHERTYPE_AES_TOY : parse_aes; + default : accept; + } + } + + state parse_aes { + packet.extract(hdr.aes_inout); + transition accept; + } +} + +control MyVerifyChecksum(inout my_headers_t hdr, inout my_metadata_t meta) { + apply { } +} + +control MyIngress( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + + action l2_fwd() { + hdr.aes_inout.setValid(); + } + + action set_egress_spec(bit<9> port) { + standard_metadata.egress_spec = port; + } + + table forward { + key = { + standard_metadata.ingress_port: exact; + } + actions = { + set_egress_spec; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + + if (forward.apply().hit) { + + if (hdr.ethernet.etherType == 0x9999) { + l2_fwd(); + } + } + } +} + +control MyEgress( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) { + + apply { + + } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.aes_inout); + } +} + +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000052__raw-repositories__epap011__P4Lang-SimpleLoadBalancer.p4 b/individual_files/000052__raw-repositories__epap011__P4Lang-SimpleLoadBalancer.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9bbdf2ec348be9aa68cd763817232f523cd2481c --- /dev/null +++ b/individual_files/000052__raw-repositories__epap011__P4Lang-SimpleLoadBalancer.p4 @@ -0,0 +1,416 @@ +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_ARP = 0x806; +const bit<32> serviceIP = 0xa010203; +const bit<48> lbMAC = 0xa0000000001; + + + + +/* type definitions for ease of reference */ +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + +/* ethernet frame header */ +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +/* ARP packet header */ +header arp_t { + bit<16> hwType; + bit<16> protoType; + bit<8> hwAddrLen; + bit<8> protoAddrLen; + bit<16> opCode; + macAddr_t hwSrcAddr; + ip4Addr_t protoSrcAddr; + macAddr_t hwDstAddr; + ip4Addr_t protoDstAddr; +} + + +/* IP packet header */ +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +/* metadata carried by the packet through the processing pipelines */ +struct metadata { + macAddr_t dstMAC; + +// the dst MAC to which the packet should be directed on L2 + bit<1> isClient; + +// whether the src IP of the packet belongs to a client + bit<1> isServer; + +// whether the src IP of the packet belongs to a server + bit<8> srcGroup; + +// the group of the src host + bit<8> dstGroup; + +// the group of the dst host +} + +struct headers { + ethernet_t ethernet; + arp_t arp; + ipv4_t ipv4; +} + + + +parser SLBParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + +/* begin with pointing to Ethernet frame parser */ + state start { + transition parse_ethernet; + } + + +/* parser ethernet frame */ + state parse_ethernet { + +/* WRITE YOUR CODE HERE */ + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_ARP: parse_arp; + TYPE_IPV4: parse_ipv4; + default:accept; + } + + } + + state parse_arp { + packet.extract(hdr.arp); + transition accept; + +// accept; the ARP packet will be pushed to ingress pipeline + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + +// accept; the IP packet will be pushed to ingress pipeline + transition accept; + } + +} + + + +control SLBVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + + +control SLBIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + +/* Action that instructs the pipeline to drop a packet */ + action drop() { + mark_to_drop(standard_metadata); + } + + +/* Action that transforms an ARP request into a suitable ARP reply */ + action arp_request_to_reply(macAddr_t srcMAC, macAddr_t dstMAC, ip4Addr_t srcIP, ip4Addr_t dstIP) { + +/* WRITE YOUR CODE HERE */ + hdr.ethernet.srcAddr = dstMAC; + hdr.ethernet.dstAddr = srcMAC; + + hdr.arp.hwSrcAddr = dstMAC; + hdr.arp.hwDstAddr = srcMAC; + hdr.arp.protoSrcAddr = dstIP; + hdr.arp.protoDstAddr = srcIP; + hdr.arp.opCode = 2; + + standard_metadata.egress_spec = standard_metadata.ingress_port; + +// the reply should be sent out of the in-port + } + + + action set_egress_metadata(macAddr_t dstMAC, egressSpec_t port) { + meta.dstMAC = dstMAC; + standard_metadata.egress_spec = port; + } + + + action set_client_metadata(ip4Addr_t firstAllowedReplica, ip4Addr_t lastAllowedReplica) { + meta.isClient = 1; + meta.isServer = 0; + +/* WRITE YOUR CODE HERE */ + random(hdr.ipv4.dstAddr, firstAllowedReplica, lastAllowedReplica); + } + + +/* Action that updates metadata with the info that the src IP does not belong to a client */ + action unset_client_metadata() { + meta.isClient = 0; + } + + +/* Action that updates metadata with the info that the src IP belongs to a server */ + action set_server_metadata() { + meta.isServer = 1; + meta.isClient = 0; + } + + +/* Action that updates metadata with the info that the src IP does not belong to a server */ + action unset_server_metadata() { + meta.isServer = 0; + } + + +/* Action that sets the group membership for a src host */ + action set_src_membership(bit<8> group) { + meta.srcGroup = group; + } + + +/* Action that sets the group membership for a dst host */ + action set_dst_membership(bit<8> group) { + meta.dstGroup = group; + } + + +/* Table that stores the mapping between dst IP and dst MAC and egress port */ + table arpmap { + +/* WRITE YOUR CODE HERE */ + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + set_egress_metadata; + } + } + + +/* Table that stores the info that a certain IP belongs to a client */ + table ipv4_clients { + key = { + hdr.ipv4.srcAddr: lpm; + } + actions = { + set_client_metadata; + unset_client_metadata; + } + } + + +/* Table that stores the info that a certain IP belongs to a server */ + table ipv4_servers { + +/* WRITE YOUR CODE HERE */ + key = { + hdr.ipv4.srcAddr: lpm; + } + actions = { + set_server_metadata; + unset_server_metadata; + } + } + + +/* Table that stores the info about which src IP is member of which group */ + table src_group_membership { + +/* WRITE YOUR CODE HERE */ + key = { + hdr.ipv4.srcAddr: lpm; + } + actions = { + set_src_membership; + } + } + + +/* Table that stores the info about which dst IP is member of which group */ + table dst_group_membership { + +/* WRITE YOUR CODE HERE */ + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + set_dst_membership; + } + } + + +/* Apply ingress workflow */ + apply { + if (!(hdr.arp.isValid() || hdr.ipv4.isValid())) { + drop(); + +// drop irrelevant/invalid traffic + } + else if (hdr.arp.isValid() && hdr.arp.opCode == 1) { + +// handle incoming ARP requests +/* WRITE YOUR CODE HERE */ + arp_request_to_reply(hdr.ethernet.srcAddr, lbMAC, hdr.arp.protoSrcAddr, hdr.arp.protoDstAddr); + } + else if (hdr.ipv4.isValid()) { + +/* WRITE YOUR CODE HERE */ + ipv4_clients.apply(); + ipv4_servers.apply(); + src_group_membership.apply(); + dst_group_membership.apply(); + + if (!((meta.isClient == 1) || meta.isServer == 1) || meta.srcGroup != meta.dstGroup) { + drop(); + +// drop if not coming from client or server + } + +// of if the src/dst groups differ + else { + arpmap.apply(); + +// prepare for egress + } + } + } +} + + + +control SLBEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + +/* Action that rewrites the header of client-to-server packets */ + action rewrite_client_to_server() { + +/* WRITE YOUR CODE HERE */ + hdr.ethernet.srcAddr = lbMAC; + hdr.ethernet.dstAddr = meta.dstMAC; + } + + +/* Action that rewrites the header of server-to-client packets */ + action rewrite_server_to_client() { + +/* WRITE YOUR CODE HERE */ + hdr.ipv4.srcAddr = serviceIP; + + hdr.ethernet.srcAddr = lbMAC; + hdr.ethernet.dstAddr = meta.dstMAC; + } + + +/* Apply egress workflow */ + apply { + if (hdr.ipv4.isValid()) { + +/* WRITE YOUR CODE HERE */ + if(meta.isClient == 1) { + rewrite_client_to_server(); + } + else if(meta.isServer == 1) { + rewrite_server_to_client(); + } + } + } +} + + + +control SLBComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control SLBDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + +// emit ethernet frame + packet.emit(hdr.arp); + +// emit ARP packet + packet.emit(hdr.ipv4); + +// emit IP packet + } +} + + + +V1Switch( + SLBParser(), + +// parse packet headers + SLBVerifyChecksum(), + +// verify thet the packet is valid + SLBIngress(), + +// apply ingress logic + SLBEgress(), + +// apply egress logic + SLBComputeChecksum(), + +// compute the new checksum for the IP packet + SLBDeparser() + +// deparse (serialize) the packet +) main; diff --git a/individual_files/000053__raw-repositories__ebiken__p4srv6.p4 b/individual_files/000053__raw-repositories__ebiken__p4srv6.p4 new file mode 100644 index 0000000000000000000000000000000000000000..7d3ef71b1087f7e685e894fbf9206af9d437e16d --- /dev/null +++ b/individual_files/000053__raw-repositories__ebiken__p4srv6.p4 @@ -0,0 +1,1067 @@ +#include +#include + + +#ifdef _V1_MODEL_P4_ +typedef bit<9> PortId_t; + +#endif /* _V1_MODEL_P4_ */ + + + + + +#ifndef _HEADERS_ +#define _HEADERS_ + + +typedef bit<48> EthernetAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; + +typedef bit<16> EthernetType; +const EthernetType ETH_P_IPV4 = 16w0x0800; +const EthernetType ETH_P_ARP = 16w0x0806; +const EthernetType ETH_P_VLAN = 16w0x8100; +const EthernetType ETH_P_IPV6 = 16w0x86dd; + + +typedef bit<8> IPProtocol; +const IPProtocol IPPROTO_HOPOPT = 0; + +// IPv6 Hop-by-Hop Option +const IPProtocol IPPROTO_ICMP = 1; +const IPProtocol IPPROTO_IPV4 = 4; +const IPProtocol IPPROTO_TCP = 6; +const IPProtocol IPPROTO_UDP = 17; +const IPProtocol IPPROTO_IPV6 = 41; +const IPProtocol IPPROTO_ROUTE = 43; + +// Routing Header for IPv6 +const IPProtocol IPPROTO_FRAG = 44; + +// Fragment Header for IPv6 +const IPProtocol IPPROTO_GRE = 47; +const IPProtocol IPPROTO_ICMPv6 = 58; + +// ICMP for IPv6 +const IPProtocol IPPROTO_NONXT = 59; + +// No Next Header for IPv6 + +typedef bit<16> UDPPort; +const UDPPort UDP_PORT_GTPC = 2123; +const UDPPort UDP_PORT_GTPU = 2152; + +header Ethernet_h { + EthernetAddress dstAddr; + EthernetAddress srcAddr; + EthernetType etherType; +} + +header IPv4_h { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + IPProtocol protocol; + bit<16> hdrChecksum; + IPv4Address srcAddr; + IPv4Address dstAddr; +} + +header IPv6_h { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + IPv6Address srcAddr; + IPv6Address dstAddr; +} + +header TCP_h { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seq; + bit<32> ack; + bit<4> dataOffset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header UDP_h { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length; + bit<16> checksum; +} + +header ICMP_h { + bit<8> type; + bit<8> code; + bit<16> hdrChecksum; + bit<32> restOfHeader; + +} + + +header SRH_h { + bit<8> nextHdr; + bit<8> hdrExtLen; + bit<8> routingType; + bit<8> segmentsLeft; + bit<8> lastEntry; + bit<8> flags; + bit<12> tag; + bit<4> gtpMessageType; + +// least significant 4 bits of tag field +} + +header SRH_SegmentList_h { + bit<128> sid; +} + + +typedef bit<8> GTPv1Type; +const GTPv1Type GTPV1_ECHO = 1; + +// Echo Request +const GTPv1Type GTPV1_ECHORES = 2; + +// Echo Response +const GTPv1Type GTPV1_ERROR = 26; + +// Error Indication +const GTPv1Type GTPV1_END = 254; + +// End Marker +const GTPv1Type GTPV1_GPDU = 255; + +// G-PDU + + +// 3GPP TS 29.060 V15.3.0 (2018-12) "6 GTP Header" +header GTPU_h { + bit<3> version; + +// Version field: always 1 for GTPv1 + bit<1> pt; + +// Protocol Type (PT): GTP(1), GTP'(0) + bit<1> reserved; + +// always zero (0) + bit<1> e; + +// Extension Header flag (E) + bit<1> s; + +// Sequence number flag (S): not present(0), present(1) + bit<1> pn; + +// N-PDU Number flag (PN) + GTPv1Type messageType; + bit<16> messageLen; + bit<32> teid; + + bit<16> seq; + +// Sequence Number + bit<8> npdu; + +// N-PDU number + bit<8> nextExtHdr; + +// Next Extention Header Type +} + + + +#endif /* _HEADERS_ */ + + +#define SRH_SID_MAX 4 + +// Max number of SIDs in SRH Segment List +struct Header { + Ethernet_h ether; + IPv6_h ipv6; + SRH_h srh; + SRH_SegmentList_h[SRH_SID_MAX] srh_sid; + + IPv4_h ipv4; + ICMP_h icmp; + TCP_h tcp; + UDP_h udp; + GTPU_h gtpu; + +// inner headers + Ethernet_h inner_ether; + IPv6_h inner_ipv6; + IPv4_h inner_ipv4; + + TCP_h inner_tcp; + UDP_h inner_udp; +} + + + + +// Generic ingress metadata (architecture independent) +struct IngressMetadata { + +// none defined yet +} + +// Generic egress metadata (architecture independent) +struct EgressMetadata { + +} +struct SRv6Metadata { + bit<128> nextsid; + bit<4> gtp_message_type; + + bit<8> gtpv1_type; + +} + +// User Metadata (for v1model) +struct UserMetadata { + IngressMetadata ig_md; + EgressMetadata eg_md; + SRv6Metadata srv6; +} + + + + +#ifndef _PARSER_ +#define _PARSER_ + + + +parser SwitchParser( + packet_in pkt, + out Header hdr, + inout UserMetadata user_md, + inout standard_metadata_t st_md) { + + state start { + transition parse_ethernet; + } + state parse_ethernet { + pkt.extract(hdr.ether); + transition select(hdr.ether.etherType) { + ETH_P_IPV4 : parse_ipv4; + ETH_P_IPV6 : parse_ipv6; + + default : accept; + } + } + state parse_ipv4 { + pkt.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + IPPROTO_TCP : parse_tcp; + IPPROTO_UDP : parse_udp; + default : accept; + } + } + state parse_ipv6 { + pkt.extract(hdr.ipv6); + transition select(hdr.ipv6.nextHdr) { + IPPROTO_TCP : parse_tcp; + IPPROTO_UDP : parse_udp; + IPPROTO_ROUTE : parse_srh; + IPPROTO_IPV4 : parse_inner_ipv4; + IPPROTO_IPV6 : parse_inner_ipv6; + default : accept; + } + } + state parse_tcp { + pkt.extract(hdr.tcp); + transition accept; + } + state parse_udp { + pkt.extract(hdr.udp); + transition select(hdr.udp.dstPort) { + UDP_PORT_GTPU: parse_gtpu; + default: accept; + } + } + state parse_gtpu { + pkt.extract(hdr.gtpu); + user_md.srv6.gtpv1_type = hdr.gtpu.messageType; + bit<4> ip_ver = pkt.lookahead>(); + transition select(ip_ver) { + 4w4 : parse_inner_ipv4; + 4w6 : parse_inner_ipv6; + default : parse_inner_ether; + } + } + state parse_inner_ipv4 { + pkt.extract(hdr.inner_ipv4); + transition select(hdr.inner_ipv4.protocol) { + IPPROTO_TCP : parse_inner_tcp; + IPPROTO_UDP : parse_inner_udp; + default : accept; + } + } + state parse_inner_ipv6 { + pkt.extract(hdr.inner_ipv6); + transition select(hdr.inner_ipv6.nextHdr) { + IPPROTO_TCP : parse_inner_tcp; + IPPROTO_UDP : parse_inner_udp; + default : accept; + } + } + state parse_inner_ether { + pkt.extract(hdr.inner_ether); + transition accept; + } + +/*** PARSE SRH (SRv6) ***/ + state parse_srh { + pkt.extract(hdr.srh); + user_md.srv6.gtp_message_type = hdr.srh.gtpMessageType; + transition parse_srh_sid_0; + } +#define PARSE_SRH_SID(curr, next) \ + state parse_srh_sid_##curr { \ + pkt.extract(hdr.srh_sid[curr]); \ + transition select(hdr.srh.lastEntry) { \ + curr : parse_srh_next_header; \ + default : parse_srh_sid_##next; \ + } \ + } \ + +PARSE_SRH_SID(0, 1) +PARSE_SRH_SID(1, 2) +PARSE_SRH_SID(2, 3) + state parse_srh_sid_3 { + pkt.extract(hdr.srh_sid[3]); + transition select(hdr.srh.lastEntry) { + 3 : parse_srh_next_header; + +// v1model: no default rule: all other packets rejected +#ifndef _V1_MODEL_P4_ + default : reject; + +// Too many SIDs +#endif /* _V1_MODEL_P4_ */ + } + } + state parse_srh_next_header { + transition select(hdr.srh.nextHdr) { + IPPROTO_TCP : parse_tcp; + IPPROTO_UDP : parse_udp; + IPPROTO_IPV4 : parse_inner_ipv4; + IPPROTO_IPV6 : parse_inner_ipv6; + default : accept; + } + } + state parse_inner_udp { + pkt.extract(hdr.inner_udp); + transition accept; + } + state parse_inner_tcp { + pkt.extract(hdr.inner_tcp); + transition accept; + } +} + + + + +control SwitchDeparser( + packet_out pkt, + in Header hdr) { + + apply { + pkt.emit(hdr.ether); + pkt.emit(hdr.ipv6); + pkt.emit(hdr.srh); + pkt.emit(hdr.srh_sid); + pkt.emit(hdr.ipv4); + + pkt.emit(hdr.tcp); + pkt.emit(hdr.udp); + pkt.emit(hdr.gtpu); + pkt.emit(hdr.inner_ether); + pkt.emit(hdr.inner_ipv6); + pkt.emit(hdr.inner_ipv4); + pkt.emit(hdr.inner_tcp); + pkt.emit(hdr.inner_udp); + } +} +#endif /* _PARSER_ */ + + + +#ifndef _SRV6_ +#define _SRV6_ + +control SRv6( + inout Header hdr, + inout UserMetadata user_md, + in PortId_t in_port, + inout PortId_t egress_port) { + + +// Counters for actions in transit and end (localsid) behaviors. +#ifdef _V1_MODEL_P4_ + +// see v1model.p4 for counter definitions. + direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_v4; + direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_v6; + direct_counter(CounterType.packets_and_bytes) cnt_srv6_t_udp; + direct_counter(CounterType.packets_and_bytes) cnt_srv6_e; + direct_counter(CounterType.packets_and_bytes) cnt_srv6_e_iif; +#endif /* _V1_MODEL_P4_ */ + + +/*** HELPER ACTIONS */ + action remove_srh_header() { + hdr.srh.setInvalid(); + + hdr.srh_sid[0].setInvalid(); + hdr.srh_sid[1].setInvalid(); + hdr.srh_sid[2].setInvalid(); + hdr.srh_sid[3].setInvalid(); + hdr.srh.setInvalid(); + } + + +/*** HELPER ACTIONS : PUSH SRH/SID */ + action push_srh(bit<8> nextHdr, bit<8> hdrExtLen, bit<8> segmentsLeft, bit<8> lastEntry) { + hdr.srh.setValid(); + hdr.srh.nextHdr = nextHdr; + hdr.srh.hdrExtLen = hdrExtLen; + hdr.srh.routingType = 4; + +// TBD, to be assigned by IANA (suggested value: 4) + hdr.srh.segmentsLeft = segmentsLeft; + hdr.srh.lastEntry = lastEntry; + hdr.srh.flags = 0; + hdr.srh.tag = 0; + } + action push_srh_sid1( + bit<8> nextHdr, + bit<8> segmentsLeft, + bit<128> sid1) { + +// SID List + hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w24; + +// SRH(8) + SID(16) + push_srh(nextHdr, 8w2, segmentsLeft, 8w0); + hdr.srh_sid[0].setValid(); + hdr.srh_sid[0].sid = sid1; + } + action push_srh_sid2( + bit<8> nextHdr, + bit<8> segmentsLeft, + bit<128> sid1, bit<128> sid2) { + +// SID List + hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w40; + +// SRH(8) + SID(16)*2 + push_srh(nextHdr, 8w4, segmentsLeft, 8w1); + hdr.srh_sid[0].setValid(); + hdr.srh_sid[0].sid = sid2; + hdr.srh_sid[1].setValid(); + hdr.srh_sid[1].sid = sid1; + } + action push_srh_sid3( + bit<8> nextHdr, + bit<8> segmentsLeft, + bit<128> sid1, bit<128> sid2, bit<128> sid3) { + +// SID List + hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w56; + +// SRH(8) + SID(16)*3 + push_srh(nextHdr, 8w6, segmentsLeft, 8w2); + hdr.srh_sid[0].setValid(); + hdr.srh_sid[0].sid = sid3; + hdr.srh_sid[1].setValid(); + hdr.srh_sid[1].sid = sid2; + hdr.srh_sid[2].setValid(); + hdr.srh_sid[2].sid = sid1; + } + action push_srh_sid4( + bit<8> nextHdr, + bit<8> segmentsLeft, + bit<128> sid1, bit<128> sid2, bit<128> sid3, bit<128> sid4) { + +// SID List + hdr.ipv6.payloadLen = hdr.ipv6.payloadLen + 16w72; + +// SRH(8) + SID(16)*4 + push_srh(nextHdr, 8w8, segmentsLeft, 8w3); + hdr.srh_sid[0].setValid(); + hdr.srh_sid[0].sid = sid4; + hdr.srh_sid[1].setValid(); + hdr.srh_sid[1].sid = sid3; + hdr.srh_sid[2].setValid(); + hdr.srh_sid[2].sid = sid2; + hdr.srh_sid[3].setValid(); + hdr.srh_sid[3].sid = sid1; + } + + +/*** TRANSIT ACTION & TABLES */ + + +// T.Insert will use ipv6.dstAddr as 1st SID. Thus, will have +1 SIDs. + action t_insert_sid1(bit<128> sid1) { + push_srh_sid2(hdr.ipv6.nextHdr, 1, sid1, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_v6.count(); + } + action t_insert_sid2(bit<128> sid1, bit<128> sid2) { + push_srh_sid3(hdr.ipv6.nextHdr, 2, sid1, sid2, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_v6.count(); + } + action t_insert_sid3(bit<128> sid1, bit<128> sid2, bit<128> sid3) { + push_srh_sid4(hdr.ipv6.nextHdr, 3, sid1, sid2, sid3, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_v6.count(); + } + + + action t_m_gtp4_d_synthesize(bit<32> iw_prefix, bit<64> src_prefix) { + + hdr.ether.etherType = ETH_P_IPV6; + hdr.ipv6.setValid(); + hdr.ipv6.version = 4w6; + hdr.ipv6.trafficClass = 8w0; + hdr.ipv6.flowLabel = 20w0; + hdr.ipv6.payloadLen = hdr.ipv4.totalLen - 16w40; + hdr.ipv6.nextHdr = 8w4; + + hdr.ipv6.hopLimit = hdr.ipv4.ttl; + +// Synthesize IPv6 SA from GTP packet + hdr.ipv6.srcAddr[127:64] = src_prefix; + +// Local SRGW Src Prefix (64) + hdr.ipv6.srcAddr[63:32] = hdr.ipv4.srcAddr; + +// IPv4 SA (32) + hdr.ipv6.srcAddr[31:0] = 32w0; + + hdr.ipv6.dstAddr[127:96] = iw_prefix; + +// GTP SRv6 InterWork prefix + hdr.ipv6.dstAddr[95:64] = hdr.ipv4.dstAddr; + + hdr.ipv6.dstAddr[63:56] = 8w0; + +// GTP QFI/RQI (0 for now) + hdr.ipv6.dstAddr[55:24] = hdr.gtpu.teid; + hdr.ipv6.dstAddr[23:0] = 24w0; + + hdr.gtpu.setInvalid(); + hdr.udp.setInvalid(); + hdr.ipv4.setInvalid(); + } + + action t_m_gtp4_d(bit<32> iw_prefix, bit<64> src_prefix) { + t_m_gtp4_d_synthesize(iw_prefix, src_prefix); + cnt_srv6_t_udp.count(); + } + + action t_m_gtp4_d_sid1(bit<32> iw_prefix, bit<64> src_prefix, + bit<128> sid1) { + t_m_gtp4_d_synthesize(iw_prefix, src_prefix); + push_srh_sid2(hdr.ipv6.nextHdr, 1, sid1, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_udp.count(); + } + action t_m_gtp4_d_sid2(bit<32> iw_prefix, bit<64> src_prefix, + bit<128> sid1, bit<128> sid2) { + t_m_gtp4_d_synthesize(iw_prefix, src_prefix); + push_srh_sid3(hdr.ipv6.nextHdr, 2, sid1, sid2, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_udp.count(); + } + action t_m_gtp4_d_sid3(bit<32> iw_prefix, bit<64> src_prefix, + bit<128> sid1, bit<128> sid2, bit<128> sid3) { + t_m_gtp4_d_synthesize(iw_prefix, src_prefix); + push_srh_sid4(hdr.ipv6.nextHdr, 3, sid1, sid2, sid3, hdr.ipv6.dstAddr); + hdr.ipv6.nextHdr = IPPROTO_ROUTE; + hdr.ipv6.dstAddr = sid1; + cnt_srv6_t_udp.count(); + } + action srv6_debug_v6() { + + cnt_srv6_t_v6.count(); + } + table srv6_transit_v6 { + key = { + hdr.ipv6.dstAddr: exact; + + } + actions = { + @defaultonly NoAction; + t_insert_sid1; + +// T.Insert with 2 SIDs (DA + sid1) + t_insert_sid2; + +// T.Insert with 3 SIDs (DA + sid1/2) + t_insert_sid3; + + } + const default_action = NoAction; + counters = cnt_srv6_t_v6; + } + table srv6_transit_v4 { + key = { + hdr.ipv4.dstAddr: exact; + + } + actions = { + @defaultonly NoAction; + + } + const default_action = NoAction; + counters = cnt_srv6_t_v4; + } + table srv6_transit_udp { + key = { + hdr.udp.dstPort : exact; + } + actions = { + @defaultonly NoAction; + +// SRv6 Mobile Userplane : draft-ietf-dmm-srv6-mobile-uplane + t_m_gtp4_d; + t_m_gtp4_d_sid1; + +// 2 SIDs (DA + sid1) + t_m_gtp4_d_sid2; + +// 3 SIDs (DA + sid1/2) + t_m_gtp4_d_sid3; + +// 4 SIDs (DA + sid1/2/3) + } + const default_action = NoAction; + counters = cnt_srv6_t_udp; + } + + action end() { + + hdr.srh.segmentsLeft = hdr.srh.segmentsLeft - 1; + + hdr.ipv6.dstAddr = user_md.srv6.nextsid; + + } + action end_m_gtp4_e() { + hdr.ether.etherType = ETH_P_IPV4; + hdr.ipv4.setValid(); + hdr.ipv4.version = 4w4; + hdr.ipv4.ihl = 4w5; + hdr.ipv4.diffserv = 8w0; + + hdr.ipv4.totalLen = hdr.ipv6.payloadLen - 16w8 - (bit<16>)hdr.srh.hdrExtLen*8 + 16w40; + + hdr.ipv4.identification = 16w0; + hdr.ipv4.flags = 3w0; + hdr.ipv4.fragOffset = 13w0; + hdr.ipv4.ttl = hdr.ipv6.hopLimit; + hdr.ipv4.protocol = IPPROTO_UDP; + +// IPv4 header checksum will be calculated later. + hdr.ipv4.srcAddr = hdr.ipv6.srcAddr[63:32]; + hdr.ipv4.dstAddr = hdr.ipv6.dstAddr[95:64]; + hdr.udp.setValid(); + hdr.udp.srcPort = UDP_PORT_GTPU; + + hdr.udp.dstPort = UDP_PORT_GTPU; + + hdr.udp.length = hdr.ipv6.payloadLen + 16w20 -16w40; + + hdr.gtpu.setValid(); + hdr.gtpu.version = 3w1; + hdr.gtpu.pt = 1w1; + hdr.gtpu.reserved = 1w0; + hdr.gtpu.e = 1w0; + +// No Extention Header + hdr.gtpu.s = 1w1; + +// YES Sequence number + hdr.gtpu.pn = 1w0; + hdr.gtpu.messageType = GTPV1_GPDU; + + hdr.gtpu.messageLen = hdr.ipv6.payloadLen - 16w8 - (bit<16>)hdr.srh.hdrExtLen*8 + 16w4; + hdr.gtpu.teid = hdr.ipv6.dstAddr[55:24]; + + hdr.gtpu.seq = 16w0; + + hdr.gtpu.npdu = 8w0; + hdr.gtpu.nextExtHdr = 8w0; + +// remove IPv6/SRH headers + remove_srh_header(); + hdr.ipv6.setInvalid(); + + cnt_srv6_e.count(); + } + + action end_am(PortId_t oif, EthernetAddress dmac) { + + hdr.ipv6.dstAddr = hdr.srh_sid[0].sid; + hdr.ether.dstAddr = dmac; + egress_port = oif; + } + + action end_am_d(PortId_t oif) { + + hdr.srh.segmentsLeft = hdr.srh.segmentsLeft - 1; + hdr.ipv6.dstAddr = user_md.srv6.nextsid; + egress_port = oif; + + } + table srv6_end { + +// localsid + key = { + hdr.ipv6.dstAddr : ternary; + + } + actions = { + @defaultonly NoAction; + +// SRv6 Network Program : draft-filsfils-spring-srv6-network-programming + end; + + + +// SRv6 Mobile Userplane : draft-ietf-dmm-srv6-mobile-uplane + end_m_gtp4_e; + +// End.M.GTP4.E + + +// Proxy Functions : draft-xuclad-spring-sr-service-programming + end_am; + } + const default_action = NoAction; + counters = cnt_srv6_e; + } + table srv6_end_iif { + +// Input Interface based SRv6 End.* table + key = { + in_port : exact; + + } + actions = { + @defaultonly NoAction; + +// Proxy Functions : draft-xuclad-spring-sr-service-programming + end_am_d; + } + const default_action = NoAction; + counters = cnt_srv6_e_iif; + } + + + +/*** HELPER TABLE TO SET NEXT SID */ + action set_nextsid_1() { + user_md.srv6.nextsid = hdr.srh_sid[0].sid; + } + action set_nextsid_2() { + user_md.srv6.nextsid = hdr.srh_sid[1].sid; + } + action set_nextsid_3() { + user_md.srv6.nextsid = hdr.srh_sid[2].sid; + } + action set_nextsid_4() { + user_md.srv6.nextsid = hdr.srh_sid[3].sid; + } + table srv6_set_nextsid { + +// helper table + key = { + hdr.srh.segmentsLeft : exact; + } + actions = { + NoAction; + set_nextsid_1; + set_nextsid_2; + set_nextsid_3; + set_nextsid_4; + } + const default_action = NoAction; + const entries = { + (1) : set_nextsid_1(); + (2) : set_nextsid_2(); + (3) : set_nextsid_3(); + (4) : set_nextsid_4(); + } + } + + action set_gtpu_type(bit<8> type) { + hdr.gtpu.messageType = type; + } + action set_srv6_GTPV1_END() { + hdr.srh.gtpMessageType = 1; + } + action set_srv6_GTPV1_ERROR() { + hdr.srh.gtpMessageType = 2; + } + action set_srv6_GTPV1_ECHO() { + hdr.srh.gtpMessageType = 4; + } + action set_srv6_GTPV1_ECHORES() { + hdr.srh.gtpMessageType = 8; + } + apply { + if (hdr.srh.isValid()) { + srv6_set_nextsid.apply(); + } + if (hdr.ipv6.isValid()) { + if(!srv6_end_iif.apply().hit) { + if(srv6_end.apply().hit) { + +// draft-murakami-dmm-user-plane-message-encoding + if (user_md.srv6.gtp_message_type == 1) { + + set_gtpu_type(GTPV1_END); + } else if (user_md.srv6.gtp_message_type == 2) { + set_gtpu_type(GTPV1_ERROR); + } else if (user_md.srv6.gtp_message_type == 4) { + set_gtpu_type(GTPV1_ECHO); + } else if (user_md.srv6.gtp_message_type == 8) { + set_gtpu_type(GTPV1_ECHORES); + } + } else { + srv6_transit_v6.apply(); + } + } + } else if (hdr.ipv4.isValid()) { + if(srv6_transit_udp.apply().hit) { + +// Assuming this is GTP/SRv6 translation + if (user_md.srv6.gtpv1_type == GTPV1_END) { + set_srv6_GTPV1_END(); + } else if (user_md.srv6.gtpv1_type == GTPV1_ERROR){ + set_srv6_GTPV1_ERROR(); + } else if (user_md.srv6.gtpv1_type == GTPV1_ECHO){ + set_srv6_GTPV1_ECHO(); + } else if (user_md.srv6.gtpv1_type == GTPV1_ECHORES){ + set_srv6_GTPV1_ECHORES(); + } + } else { + srv6_transit_v4.apply(); + } + } + } +} + + +#endif /* _SRV6_ */ + + + + +control L2Fwd( + in EthernetAddress ether_dst_addr, + inout IngressMetadata ig_md, + inout PortId_t egress_port) + (bit<32> table_size_dmac) { + + action dmac_miss() { + + } + action dmac_hit(PortId_t port) { + egress_port = port; + } + + table dmac { + key = { + ether_dst_addr : exact; + } + actions = { + dmac_miss; + dmac_hit; + } + const default_action = dmac_miss; + size = table_size_dmac; + } + + apply { + dmac.apply(); + } +} +control PortFwd( + in PortId_t in_port, + inout PortId_t egress_port) { + + action set_egress_port(PortId_t port) { + egress_port = port; + } + + table portfwd { + key = { + in_port : exact; + +// ingress phy port + } + + actions = { + set_egress_port; + } + } + + apply { + portfwd.apply(); + } +} + + +// CONTROL: INGRESS + +control SwitchIngress( + inout Header hdr, + inout UserMetadata user_md, + inout standard_metadata_t st_md) { + + +// Instantiate controlls + PortFwd() port_fwd; + SRv6() srv6; + L2Fwd(1024) l2fwd; + + +// Local MAC address. Apply Layer 3 tables when hit. + action local_mac_hit() {} + table local_mac { + key = { + hdr.ether.dstAddr : exact; + } + actions = { + NoAction; + local_mac_hit(); + } + const default_action = NoAction; + size = 512; + +// number of Layer 3 interfaces + } + + apply { + + mark_to_drop(st_md); + +// set default action to drop to avoid unexpected packets going out. + + +// policy L1 (port) forwarding table useful untill l2fwd is implemented. + port_fwd.apply(st_md.ingress_port, st_md.egress_spec); + + + srv6.apply(hdr, user_md, st_md.ingress_port, st_md.egress_spec); + + + l2fwd.apply(hdr.ether.dstAddr, user_md.ig_md, st_md.egress_spec); + } +} + + + + +// CONTROL: EGRESS + +control SwitchEgress( + inout Header hdr, + inout UserMetadata user_md, + inout standard_metadata_t st_md) { + +// do nothing + apply { } +} + + + +// CONTROL: CHECKSUM + +control NoSwitchVerifyChecksum( + inout Header hdr, + inout UserMetadata user_md) { + +// dummy control to skip checkum + apply { } +} +control SwitchVerifyChecksum( + inout Header hdr, + inout UserMetadata user_md) { + apply { + verify_checksum(hdr.ipv4.isValid() && hdr.ipv4.ihl == 5, + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +/***************************************************** + +control SwitchComputeChecksum( + inout Header hdr, + inout UserMetadata user_md) { + apply { + update_checksum(hdr.ipv4.isValid() && hdr.ipv4.ihl == 5, + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +V1Switch(SwitchParser(), + + NoSwitchVerifyChecksum(), + SwitchIngress(), + SwitchEgress(), + SwitchComputeChecksum(), + + SwitchDeparser()) main; diff --git a/individual_files/000054__raw-repositories__ElhNoah__INT.p4 b/individual_files/000054__raw-repositories__ElhNoah__INT.p4 new file mode 100644 index 0000000000000000000000000000000000000000..46313b21953fd05be77adba5ffa962058e549137 --- /dev/null +++ b/individual_files/000054__raw-repositories__ElhNoah__INT.p4 @@ -0,0 +1,1277 @@ +#include +#include + + + +#define MAX_PORTS 511 +#define CLONE_PKT 1 + +const bit<6> HW_ID = 1; + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<8> IP_PROTO_UDP = 0x11; +const bit<8> IP_PROTO_TCP = 0x6; + +const bit<6> DSCP_INT = 0x17; +const bit<6> DSCP_MASK = 0x3F; + +typedef bit<48> mac_t; +typedef bit<32> ip_address_t; +typedef bit<16> l4_port_t; +typedef bit<9> port_t; +typedef bit<32> node_id_t; + +const bit<32> REPORT_MIRROR_SESSION_ID = 500; + + +header ethernet_t { + bit<48> dst_addr; + bit<48> src_addr; + bit<16> ether_type; +} + +const bit<8> ETH_HEADER_LEN = 14; + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> dscp; + bit<2> ecn; + bit<16> len; + bit<16> identification; + bit<3> flags; + bit<13> frag_offset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdr_checksum; + bit<32> src_addr; + bit<32> dst_addr; +} + +const bit<8> IPV4_MIN_HEAD_LEN = 20; + + +header udp_t { + bit<16> src_port; + bit<16> dst_port; + bit<16> length_; + bit<16> checksum; +} + +const bit<8> UDP_HEADER_LEN = 8; + + +header tcp_t { + bit<16> src_port; + bit<16> dst_port; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; +} + +const bit<8> TCP_HEADER_LEN = 20; + + + +// INT shim header for INT over TCP/UDP +header intl4_shim_t { + bit<4> int_type; + +// Type of INT Header + bit<2> npt; + +// Next protocol type + bit<2> rsvd1; + +// Reserved + bit<8> len; + +// Length of INT Metadata header and INT stack in 4-byte words, not including the shim header (1 word) + bit<8> rsvd2; + +// Reserved + bit<6> original_dscp; + +// Original DSCP value + bit<2> rsvd3; + +// Reserved +} + +const bit<16> INT_SHIM_HEADER_SIZE = 4; + + +// INT header +header int_header_t { + bit<4> ver; + +// Version + bit<1> d; + +// Discard + bit<1> e; + bit<1> m; + bit<12> rsvd1; + bit<5> hop_metadata_len; + bit<8> remaining_hop_cnt; + bit<4> instruction_mask_0003; + +// Split the bits for lookup + bit<4> instruction_mask_0407; + bit<4> instruction_mask_0811; + bit<4> instruction_mask_1215; + bit<16> domain_specific_id; + +// Unique INT Domain ID + bit<16> ds_instruction; + +// Instruction bitmap specific to the INT Domain identified by the Domain specific ID + bit<16> ds_flags; + +// Domain specific flags +} + +const bit<16> INT_HEADER_SIZE = 12; +const bit<8> INT_HEADER_WORD = 3; +const bit<16> INT_TOTAL_HEADER_SIZE = INT_HEADER_SIZE + INT_SHIM_HEADER_SIZE; + + + +// INT meta-value headers - different header for each value type to monitor +header int_node_id_t { + bit<32> node_id; +} +header int_level1_port_ids_t { + bit<16> ingress_port_id; + bit<16> egress_port_id; +} +header int_hop_latency_t { + bit<32> hop_latency; +} +header int_q_occupancy_t { + bit<8> q_id; + bit<24> q_occupancy; +} +header int_ingress_tstamp_t { + bit<64> ingress_tstamp; +} +header int_egress_tstamp_t { + bit<64> egress_tstamp; +} +header int_level2_port_ids_t { + bit<32> ingress_port_id; + bit<32> egress_port_id; +} + + +// These two are not implemented yet +header int_egress_port_tx_util_t { + bit<32> egress_port_tx_util; + +// This is used but the queue latency is gathered instead +} + +header int_buffer_t { + bit<8> buffer_id; + bit<24> buffer_occupancy; +} + +header int_data_t { + + varbit<1920> data; +} + + +// Report Telemetry Headers - Group Header +header report_group_header_t { + bit<4> ver; + bit<6> hw_id; + bit<22> seq_no; + bit<32> node_id; +} +const bit<8> REPORT_GROUP_HEADER_LEN = 8; + + +// Report Telemetry Headers - Individual Header +header report_individual_header_t { + bit<4> rep_type; + bit<4> in_type; + bit<8> len; + bit<8> rep_md_len; + bit<1> d; + bit<1> q; + bit<1> f; + bit<1> i; + bit<4> rsvd; + + bit<16> rep_md_bits; + bit<16> domain_specific_id; + bit<16> domain_specific_md_bits; + bit<16> domain_specific_md_status; +} +const bit<8> REPORT_INDIVIDUAL_HEADER_LEN = 12; + + +// Preserving metadata header for the cloned packet +struct preserving_metadata_t { + @field_list(1) + bit<9> ingress_port; + @field_list(1) + bit<9> egress_port; + @field_list(1) + bit<32> deq_timedelta; + @field_list(1) + bit<19> deq_qdepth; + @field_list(1) + bit<48> ingress_global_timestamp; + @field_list(1) + bit<48> egress_global_timestamp; +} + +struct headers { + + +// Original Packet Headers + ethernet_t ethernet; + ipv4_t ipv4; + udp_t udp; + tcp_t tcp; + + +// INT Report Encapsulation + ethernet_t report_ethernet; + ipv4_t report_ipv4; + udp_t report_udp; + + +// INT Headers + int_header_t int_header; + intl4_shim_t intl4_shim; + + +//INT Metadata + int_data_t int_data; + int_node_id_t int_node_id; + int_level1_port_ids_t int_level1_port_ids; + int_hop_latency_t int_hop_latency; + int_q_occupancy_t int_q_occupancy; + int_ingress_tstamp_t int_ingress_tstamp; + int_egress_tstamp_t int_egress_tstamp; + int_level2_port_ids_t int_level2_port_ids; + int_egress_port_tx_util_t int_egress_tx_util; + + +// INT Report Headers + report_group_header_t report_group_header; + report_individual_header_t report_individual_header; +} + +struct int_metadata_t { + node_id_t node_id; + bit<16> new_bytes; + bit<8> new_words; + bool source; + bool sink; + bit<8> intl4_shim_len; +} + +struct local_metadata_t { + bit<16> l4_src_port; + bit<16> l4_dst_port; + int_metadata_t int_meta; + preserving_metadata_t perserv_meta; +} + + + +parser MyParser( packet_in packet, + out headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.ether_type) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + IP_PROTO_UDP: parse_udp; + IP_PROTO_TCP: parse_tcp; + default: accept; + } + } + + state parse_udp { + packet.extract(hdr.udp); + local_metadata.l4_src_port = hdr.udp.src_port; + local_metadata.l4_dst_port = hdr.udp.dst_port; + transition select(hdr.ipv4.dscp) { + DSCP_INT &&& DSCP_MASK: parse_shim; + default: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + local_metadata.l4_src_port = hdr.tcp.src_port; + local_metadata.l4_dst_port = hdr.tcp.dst_port; + transition select(hdr.ipv4.dscp) { + DSCP_INT &&& DSCP_MASK: parse_shim; + default: accept; + } + } + + state parse_shim { + packet.extract(hdr.intl4_shim); + local_metadata.int_meta.intl4_shim_len = hdr.intl4_shim.len; + transition parse_int_hdr; + } + + state parse_int_hdr { + packet.extract(hdr.int_header); + transition parse_int_data; + } + + state parse_int_data { + packet.extract(hdr.int_data, ((bit<32>) (local_metadata.int_meta.intl4_shim_len - INT_HEADER_WORD)) << 5); + transition accept; + } +} + + + + +control MyDeparser(packet_out packet, + in headers hdr) { + + apply { + + packet.emit(hdr.report_ethernet); + packet.emit(hdr.report_ipv4); + packet.emit(hdr.report_udp); + + packet.emit(hdr.report_group_header); + packet.emit(hdr.report_individual_header); + + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.udp); + packet.emit(hdr.tcp); + + packet.emit(hdr.intl4_shim); + packet.emit(hdr.int_header); + + packet.emit(hdr.int_node_id); + packet.emit(hdr.int_level1_port_ids); + packet.emit(hdr.int_hop_latency); + packet.emit(hdr.int_q_occupancy); + packet.emit(hdr.int_ingress_tstamp); + packet.emit(hdr.int_egress_tstamp); + packet.emit(hdr.int_level2_port_ids); + packet.emit(hdr.int_egress_tx_util); + + packet.emit(hdr.int_data); + } +} + +control MyVerifyChecksum(inout headers hdr, inout local_metadata_t local_metadata) { + apply { + verify_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.ecn, + hdr.ipv4.len, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.frag_offset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr }, + hdr.ipv4.hdr_checksum, + HashAlgorithm.csum16 + ); + } +} + +control MyComputeChecksum(inout headers hdr, inout local_metadata_t local_metadata){ + apply{ + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.ecn, + hdr.ipv4.len, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.frag_offset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr }, + hdr.ipv4.hdr_checksum, + HashAlgorithm.csum16 + ); + + } + +} + +control process_int_sink ( + inout headers hdr) { + + action restore_header () { + hdr.ipv4.dscp = hdr.intl4_shim.original_dscp; + bit<16> len_bytes = (((bit<16>)hdr.intl4_shim.len) << 2) + INT_SHIM_HEADER_SIZE; + hdr.ipv4.len = hdr.ipv4.len - len_bytes; + if(hdr.udp.isValid()) { + hdr.udp.length_ = hdr.udp.length_ - len_bytes; + } + } + + + action int_sink() { + +// remove all the INT information from the packet + hdr.intl4_shim.setInvalid(); + hdr.int_header.setInvalid(); + hdr.int_node_id.setInvalid(); + hdr.int_level1_port_ids.setInvalid(); + hdr.int_hop_latency.setInvalid(); + hdr.int_q_occupancy.setInvalid(); + hdr.int_ingress_tstamp.setInvalid(); + hdr.int_egress_tstamp.setInvalid(); + hdr.int_level2_port_ids.setInvalid(); + hdr.int_egress_tx_util.setInvalid(); + hdr.int_data.setInvalid(); + } + + apply { + restore_header(); + int_sink(); + } +} + + +// Action for the INT telemetry report, as it is encapsulated with new Ethernet, IP and UDP headers +control process_int_report (inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + +// Register for sequence number + register>(1) seq_number; + + action increment_counter() { + bit<22> tmp; + seq_number.read(tmp, 0); + tmp = tmp + 1; + seq_number.write(0, tmp); + } + + action do_report_encapsulation(mac_t src_mac, + mac_t mon_mac, + ip_address_t src_ip, + ip_address_t mon_ip, + l4_port_t src_port, + l4_port_t mon_port) { + + +// Report Ethernet Header + hdr.report_ethernet.setValid(); + hdr.report_ethernet.dst_addr = mon_mac; + hdr.report_ethernet.src_addr = src_mac; + hdr.report_ethernet.ether_type = 0x0800; + + +// Report IPV4 Header + hdr.report_ipv4.setValid(); + hdr.report_ipv4.version = 4w4; + hdr.report_ipv4.ihl = 4w5; + hdr.report_ipv4.dscp = 6w0; + hdr.report_ipv4.ecn = 2w0; + + if (hdr.udp.isValid()) { + hdr.report_ipv4.len = (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + + local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2); + } else if (hdr.tcp.isValid()) { + hdr.report_ipv4.len = (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + + local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) TCP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2); + } + + hdr.report_ipv4.identification = 0; + hdr.report_ipv4.flags = 0; + hdr.report_ipv4.frag_offset = 0; + hdr.report_ipv4.ttl = 64; + hdr.report_ipv4.protocol = IP_PROTO_UDP; + hdr.report_ipv4.src_addr = src_ip; + hdr.report_ipv4.dst_addr = mon_ip; + + +//Report UDP Header + hdr.report_udp.setValid(); + hdr.report_udp.src_port = src_port; + hdr.report_udp.dst_port = mon_port; + + if (hdr.udp.isValid()) { + hdr.report_udp.length_ = (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + + local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) UDP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2); + } else if (hdr.tcp.isValid()) { + hdr.report_udp.length_ = (bit<16>) UDP_HEADER_LEN + (bit<16>) REPORT_GROUP_HEADER_LEN + (bit<16>) REPORT_INDIVIDUAL_HEADER_LEN + + local_metadata.int_meta.new_bytes + (bit<16>) IPV4_MIN_HEAD_LEN + (bit<16>) TCP_HEADER_LEN + (bit<16>) INT_SHIM_HEADER_SIZE + (((bit<16>) hdr.intl4_shim.len) << 2); + } + + +// Telemetry Group Header + hdr.report_group_header.setValid(); + hdr.report_group_header.ver = 2; + +// Version 2.0 + hdr.report_group_header.hw_id = HW_ID; + +// Default Value 1 + seq_number.read(hdr.report_group_header.seq_no, 0); + increment_counter(); + hdr.report_group_header.node_id = local_metadata.int_meta.node_id; + + + +// Telemetry Report Individual Header + hdr.report_individual_header.setValid(); + hdr.report_individual_header.rep_type = 1; + +// INT Report + hdr.report_individual_header.in_type = 4; + +// Individual Report Inner Content is an IPv4 packet + if (hdr.udp.isValid()) { + hdr.report_individual_header.len = 2 + local_metadata.int_meta.new_words + 5 + 2 + 4; + } else if (hdr.tcp.isValid()) { + hdr.report_individual_header.len = 2 + local_metadata.int_meta.new_words + 5 + 5 + 4; + } + hdr.report_individual_header.rep_md_len = local_metadata.int_meta.new_words; + hdr.report_individual_header.d = 0; + hdr.report_individual_header.q = 0; + hdr.report_individual_header.f = 1; + hdr.report_individual_header.i = 0; + hdr.report_individual_header.rsvd = 0; + + +// Individual report main contents + hdr.report_individual_header.rep_md_bits = hdr.int_header.instruction_mask_0003 ++ hdr.int_header.instruction_mask_0407 ++ + hdr.int_header.instruction_mask_0811 ++ hdr.int_header.instruction_mask_1215; + hdr.report_individual_header.domain_specific_id = 0; + hdr.report_individual_header.domain_specific_md_bits = 0; + hdr.report_individual_header.domain_specific_md_status = 0; + + hdr.ethernet.setInvalid(); + } + + table tb_generate_report { + actions = { + do_report_encapsulation; + NoAction(); + } + default_action = do_report_encapsulation(0, 0, 0, 0, 0, 0); + } + + apply { + tb_generate_report.apply(); + } +} + +control process_int_transit ( + inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + action init_metadata(node_id_t node_id) { + local_metadata.int_meta.node_id = node_id; + } + + +// Node ID + action int_set_header_0() { + hdr.int_node_id.setValid(); + hdr.int_node_id.node_id = local_metadata.int_meta.node_id; + } + + +// Level 1 ingress interface ID + Egress interface ID + action int_set_header_1() { + hdr.int_level1_port_ids.setValid(); + hdr.int_level1_port_ids.ingress_port_id = (bit<16>) standard_metadata.ingress_port; + hdr.int_level1_port_ids.egress_port_id = (bit<16>) standard_metadata.egress_port; + } + + +// Hop latency + action int_set_header_2() { + hdr.int_hop_latency.setValid(); + hdr.int_hop_latency.hop_latency = (bit<32>) standard_metadata.egress_global_timestamp - (bit<32>) standard_metadata.ingress_global_timestamp; + } + + +// Queue ID and queue occupancy + action int_set_header_3() { + hdr.int_q_occupancy.setValid(); + + hdr.int_q_occupancy.q_id = 0; + hdr.int_q_occupancy.q_occupancy = (bit<24>) standard_metadata.deq_qdepth; + } + + +// Ingress timestamp + action int_set_header_4() { + hdr.int_ingress_tstamp.setValid(); + hdr.int_ingress_tstamp.ingress_tstamp = (bit<64>) standard_metadata.ingress_global_timestamp; + } + + +// Egress timestamp + action int_set_header_5() { + hdr.int_egress_tstamp.setValid(); + hdr.int_egress_tstamp.egress_tstamp = (bit<64>) standard_metadata.egress_global_timestamp; + } + + +// Level 2 Ingress Interface ID + Egress Interface ID + action int_set_header_6() { + hdr.int_level2_port_ids.setValid(); + hdr.int_level2_port_ids.ingress_port_id = (bit<32>) local_metadata.l4_src_port; + hdr.int_level2_port_ids.egress_port_id = (bit<32>) local_metadata.l4_dst_port; + } + + +// Egress interface TX utilization + action int_set_header_7() { + hdr.int_egress_tx_util.setValid(); + hdr.int_egress_tx_util.egress_port_tx_util = (bit<32>) standard_metadata.deq_timedelta; + } + + +// Actions to keep track of the new metadata added + action add_1() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 1; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 4; + } + + + action add_2() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 2; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 8; + } + + + action add_3() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 3; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 12; + } + + + action add_4() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 4; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 16; + } + + + action add_5() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 5; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 20; + } + + action add_6() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 6; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 24; + } + + action add_7() { + local_metadata.int_meta.new_words = local_metadata.int_meta.new_words + 7; + local_metadata.int_meta.new_bytes = local_metadata.int_meta.new_bytes + 28; + } + + +// Action to process instruction bits 0-3 + action int_set_header_0003_i0() { + } + + action int_set_header_0003_i1() { + int_set_header_3(); + add_1(); + } + + action int_set_header_0003_i2() { + int_set_header_2(); + add_1(); + } + + action int_set_header_0003_i3() { + int_set_header_3(); + int_set_header_2(); + add_2(); + } + + action int_set_header_0003_i4() { + int_set_header_1(); + add_1(); + } + + action int_set_header_0003_i5() { + int_set_header_3(); + int_set_header_1(); + add_2(); + } + + action int_set_header_0003_i6() { + int_set_header_2(); + int_set_header_1(); + add_2(); + } + + action int_set_header_0003_i7() { + int_set_header_3(); + int_set_header_2(); + int_set_header_1(); + add_3(); + } + + action int_set_header_0003_i8() { + int_set_header_0(); + add_1(); + } + + action int_set_header_0003_i9() { + int_set_header_3(); + int_set_header_0(); + add_2(); + } + + action int_set_header_0003_i10() { + int_set_header_2(); + int_set_header_0(); + add_2(); + } + + action int_set_header_0003_i11() { + int_set_header_3(); + int_set_header_2(); + int_set_header_0(); + add_3(); + } + + action int_set_header_0003_i12() { + int_set_header_1(); + int_set_header_0(); + add_2(); + } + + action int_set_header_0003_i13() { + int_set_header_3(); + int_set_header_1(); + int_set_header_0(); + add_3(); + } + + action int_set_header_0003_i14() { + int_set_header_2(); + int_set_header_1(); + int_set_header_0(); + add_3(); + } + + action int_set_header_0003_i15() { + int_set_header_3(); + int_set_header_2(); + int_set_header_1(); + int_set_header_0(); + add_4(); + } + + +// Action to process instruction bits 4-7 + action int_set_header_0407_i0() { + } + + action int_set_header_0407_i1() { + int_set_header_7(); + add_1(); + } + + action int_set_header_0407_i2() { + int_set_header_6(); + add_2(); + } + + action int_set_header_0407_i3() { + int_set_header_7(); + int_set_header_6(); + add_3(); + } + + action int_set_header_0407_i4() { + int_set_header_5(); + add_2(); + } + + action int_set_header_0407_i5() { + int_set_header_7(); + int_set_header_5(); + add_3(); + } + + action int_set_header_0407_i6() { + int_set_header_6(); + int_set_header_5(); + add_4(); + } + + action int_set_header_0407_i7() { + int_set_header_7(); + int_set_header_6(); + int_set_header_5(); + add_5(); + } + + action int_set_header_0407_i8() { + int_set_header_4(); + add_2(); + } + + action int_set_header_0407_i9() { + int_set_header_7(); + int_set_header_4(); + add_3(); + } + + action int_set_header_0407_i10() { + int_set_header_6(); + int_set_header_4(); + add_4(); + } + + action int_set_header_0407_i11() { + int_set_header_7(); + int_set_header_6(); + int_set_header_4(); + add_5(); + } + + action int_set_header_0407_i12() { + int_set_header_5(); + int_set_header_4(); + add_4(); + } + + action int_set_header_0407_i13() { + int_set_header_7(); + int_set_header_5(); + int_set_header_4(); + add_5(); + } + + action int_set_header_0407_i14() { + int_set_header_6(); + int_set_header_5(); + int_set_header_4(); + add_6(); + } + + action int_set_header_0407_i15() { + int_set_header_7(); + int_set_header_6(); + int_set_header_5(); + int_set_header_4(); + add_7(); + } + + +// Default action used to set node ID. + table tb_int_insert { + actions = { + init_metadata; + NoAction; + } + default_action = init_metadata(0); + size = 1; + } + + +// Table to process instruction bits 0-3 + table tb_int_inst_0003 { + key = { + hdr.int_header.instruction_mask_0003 : exact; + } + actions = { + int_set_header_0003_i0; + int_set_header_0003_i1; + int_set_header_0003_i2; + int_set_header_0003_i3; + int_set_header_0003_i4; + int_set_header_0003_i5; + int_set_header_0003_i6; + int_set_header_0003_i7; + int_set_header_0003_i8; + int_set_header_0003_i9; + int_set_header_0003_i10; + int_set_header_0003_i11; + int_set_header_0003_i12; + int_set_header_0003_i13; + int_set_header_0003_i14; + int_set_header_0003_i15; + } + + const entries = { + (0x0) : int_set_header_0003_i0(); + (0x1) : int_set_header_0003_i1(); + (0x2) : int_set_header_0003_i2(); + (0x3) : int_set_header_0003_i3(); + (0x4) : int_set_header_0003_i4(); + (0x5) : int_set_header_0003_i5(); + (0x6) : int_set_header_0003_i6(); + (0x7) : int_set_header_0003_i7(); + (0x8) : int_set_header_0003_i8(); + (0x9) : int_set_header_0003_i9(); + (0xA) : int_set_header_0003_i10(); + (0xB) : int_set_header_0003_i11(); + (0xC) : int_set_header_0003_i12(); + (0xD) : int_set_header_0003_i13(); + (0xE) : int_set_header_0003_i14(); + (0xF) : int_set_header_0003_i15(); + } + } + + +// Table to process instruction bits 4-7 + table tb_int_inst_0407 { + key = { + hdr.int_header.instruction_mask_0407 : exact; + } + actions = { + int_set_header_0407_i0; + int_set_header_0407_i1; + int_set_header_0407_i2; + int_set_header_0407_i3; + int_set_header_0407_i4; + int_set_header_0407_i5; + int_set_header_0407_i6; + int_set_header_0407_i7; + int_set_header_0407_i8; + int_set_header_0407_i9; + int_set_header_0407_i10; + int_set_header_0407_i11; + int_set_header_0407_i12; + int_set_header_0407_i13; + int_set_header_0407_i14; + int_set_header_0407_i15; + } + + const entries = { + (0x0) : int_set_header_0407_i0(); + (0x1) : int_set_header_0407_i1(); + (0x2) : int_set_header_0407_i2(); + (0x3) : int_set_header_0407_i3(); + (0x4) : int_set_header_0407_i4(); + (0x5) : int_set_header_0407_i5(); + (0x6) : int_set_header_0407_i6(); + (0x7) : int_set_header_0407_i7(); + (0x8) : int_set_header_0407_i8(); + (0x9) : int_set_header_0407_i9(); + (0xA) : int_set_header_0407_i10(); + (0xB) : int_set_header_0407_i11(); + (0xC) : int_set_header_0407_i12(); + (0xD) : int_set_header_0407_i13(); + (0xE) : int_set_header_0407_i14(); + (0xF) : int_set_header_0407_i15(); + } + } + + apply { + tb_int_insert.apply(); + + tb_int_inst_0003.apply(); + tb_int_inst_0407.apply(); + + +// Decrement remaining hop cnt + hdr.int_header.remaining_hop_cnt = hdr.int_header.remaining_hop_cnt - 1; + + +// Update headers lengths. + if (hdr.ipv4.isValid()) { + hdr.ipv4.len = hdr.ipv4.len + local_metadata.int_meta.new_bytes; + } + if (hdr.udp.isValid()) { + hdr.udp.length_ = hdr.udp.length_ + local_metadata.int_meta.new_bytes; + } + if (hdr.intl4_shim.isValid()) { + hdr.intl4_shim.len = hdr.intl4_shim.len + local_metadata.int_meta.new_words; + } + } +} + +control process_int_source_sink ( + inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + action int_set_source () { + local_metadata.int_meta.source = true; + } + + action int_set_sink () { + local_metadata.int_meta.sink = true; + } + + table tb_set_source { + key = { + standard_metadata.ingress_port: exact; + } + actions = { + int_set_source; + NoAction(); + } + const default_action = NoAction(); + size = MAX_PORTS; + } + + table tb_set_sink { + key = { + standard_metadata.egress_port: exact; + } + actions = { + int_set_sink; + NoAction(); + } + const default_action = NoAction(); + size = MAX_PORTS; + } + + apply { + tb_set_source.apply(); + tb_set_sink.apply(); + } +} + + +// Insert INT header to the packet +control process_int_source ( + inout headers hdr, + inout local_metadata_t local_metadata) { + + action int_source(bit<5> hop_metadata_len, bit<8> remaining_hop_cnt, bit<4> ins_mask0003, bit<4> ins_mask0407) { + + hdr.intl4_shim.setValid(); + +// insert INT shim header + hdr.intl4_shim.int_type = 1; + +// INT type: MD-type (1) , destination type (2), MX-type (3) + hdr.intl4_shim.npt = 0; + +// next protocol type: 0 + hdr.intl4_shim.len = 3; + + hdr.intl4_shim.original_dscp = hdr.ipv4.dscp; + +// original DSCP + + +// insert INT header + hdr.int_header.setValid(); + hdr.int_header.ver = 2; + +// INT 2.1 + hdr.int_header.d = 0; + hdr.int_header.hop_metadata_len = hop_metadata_len; + hdr.int_header.remaining_hop_cnt = remaining_hop_cnt; + hdr.int_header.instruction_mask_0003 = ins_mask0003; + hdr.int_header.instruction_mask_0407 = ins_mask0407; + hdr.int_header.instruction_mask_0811 = 0; + +// bit 8 is buffer related (not yet implemented), rest are reserved + hdr.int_header.instruction_mask_1215 = 0; + +// reserved + + hdr.int_header.domain_specific_id = 0; + +// Unique INT Domain ID (not yet implemented) + hdr.int_header.ds_instruction = 0; + +// Instruction bitmap specific to the INT Domain identified by the Domain specific ID (not yet implemented) + hdr.int_header.ds_flags = 0; + +// Domain specific flags (not yet implemented) + + +// add the header len (3 words) to total len + hdr.ipv4.len = hdr.ipv4.len + INT_TOTAL_HEADER_SIZE; + if(hdr.udp.isValid()) { + hdr.udp.length_ = hdr.udp.length_ + INT_TOTAL_HEADER_SIZE; + } + + hdr.ipv4.dscp = DSCP_INT; + } + + table tb_int_source { + key = { + + hdr.ipv4.dst_addr: lpm; + } + actions = { + int_source; + NoAction; + } + const default_action = NoAction(); + } + + apply { + tb_int_source.apply(); + } +} + +control l3_forward(inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(mac_t dstAddr, mac_t srcAddr, port_t port) { + standard_metadata.egress_spec = port; + standard_metadata.egress_port = port; + hdr.ethernet.src_addr = srcAddr; + hdr.ethernet.dst_addr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dst_addr : lpm; + } + actions = { + ipv4_forward; + drop; + } + size = 1024; + const default_action = drop(); + } + + apply { + if(hdr.ipv4.ttl == 0) { + drop(); + } + if(hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + + } +} + + + + +control MyIngress(inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + apply { + if(hdr.ipv4.isValid()) { + + +// Perform L2 forwarding based on IPv4 destination address + l3_forward.apply(hdr, local_metadata, standard_metadata); + + if (hdr.udp.isValid() || hdr.tcp.isValid()) { + + +// Setting source and sink local metadata + process_int_source_sink.apply(hdr, local_metadata, standard_metadata); + + +// In case of source add the INT header + if (local_metadata.int_meta.source == true) { + process_int_source.apply(hdr, local_metadata); + } + + +// Clone packet for Telemetry Report + if (local_metadata.int_meta.sink == true && hdr.int_header.isValid()) { + local_metadata.perserv_meta.ingress_port = standard_metadata.ingress_port; + local_metadata.perserv_meta.egress_port = standard_metadata.egress_port; + local_metadata.perserv_meta.deq_qdepth = standard_metadata.deq_qdepth; + local_metadata.perserv_meta.deq_timedelta = standard_metadata.deq_timedelta; + local_metadata.perserv_meta.ingress_global_timestamp = standard_metadata.ingress_global_timestamp; + local_metadata.perserv_meta.egress_global_timestamp = standard_metadata.egress_global_timestamp; + clone_preserving_field_list(CloneType.I2E, REPORT_MIRROR_SESSION_ID, 1); + + } + } + } + } +} + + + +control MyEgress(inout headers hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + apply { + +// Insert old packet metadata into the cloned packet + if(hdr.int_header.isValid() && standard_metadata.instance_type == CLONE_PKT) { + standard_metadata.ingress_port = local_metadata.perserv_meta.ingress_port; + standard_metadata.egress_port = local_metadata.perserv_meta.egress_port; + standard_metadata.deq_qdepth = local_metadata.perserv_meta.deq_qdepth; + standard_metadata.deq_timedelta = local_metadata.perserv_meta.deq_timedelta; + standard_metadata.ingress_global_timestamp = local_metadata.perserv_meta.ingress_global_timestamp; + standard_metadata.egress_global_timestamp = local_metadata.perserv_meta.egress_global_timestamp; + } + + process_int_transit.apply(hdr, local_metadata, standard_metadata); + + +// In case of cloned packet, send telemetry report + if (standard_metadata.instance_type == CLONE_PKT) { + process_int_report.apply(hdr, local_metadata, standard_metadata); + } + + +// In case of sink, remove INT header from original packet + if (hdr.int_header.isValid() && local_metadata.int_meta.sink == true && standard_metadata.instance_type != CLONE_PKT) { + process_int_sink.apply(hdr); + } + } +} + + + +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000055__raw-repositories__felipejrampazzo__Projeto-IA376C.p4 b/individual_files/000055__raw-repositories__felipejrampazzo__Projeto-IA376C.p4 new file mode 100644 index 0000000000000000000000000000000000000000..bea246d0a21456d7c597eff12f0c4cbde80378ab --- /dev/null +++ b/individual_files/000055__raw-repositories__felipejrampazzo__Projeto-IA376C.p4 @@ -0,0 +1,618 @@ + +#include +#include + +#define DIMENSION 4 + +register>(20) register_pub_matrix; +register>(10) register_secret_vector; +register>(10) register_noise_vector; +register>(10) register_public_vector; +register>(36) register_public_vector_full; +register>(18) register_mod_public_vector; +register >(4) register_seed; + + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + + +const bit<16> P4CALC_ETYPE = 0x1234; +const bit<8> P4CALC_P = 0x4B; + +// K - KYBER +const bit<8> GEN = 0x47; + +// 'G' +const bit<8> ENC = 0x45; + +// 'E' +const bit<8> DEC = 0x44; + +// 'D' +const bit<32> PARAM_Q = 3329; + +header p4calc_t { + bit<8> p; + bit<8> op; + + bit<32> t_0; + bit<32> t_1; + bit<32> t_2; + bit<32> t_3; + bit<32> t_4; + bit<32> t_5; + bit<32> t_6; + bit<32> t_7; + bit<32> t_8; + bit<32> t_9; + + bit<32> seed; +} + + +struct headers { + ethernet_t ethernet; + p4calc_t p4calc; +} + + +struct metadata { + +/* In our case it is empty */ +} + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + P4CALC_ETYPE : check_p4calc; + default : accept; + } + } + + state check_p4calc { + transition select(packet.lookahead().p) { + (P4CALC_P) : parse_p4calc; + default : accept; + } + } + + state parse_p4calc { + packet.extract(hdr.p4calc); + transition accept; + } +} + + +control MyVerifyChecksum(inout headers hdr, + inout metadata meta) { + apply { } +} + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action send_back() { + bit<48> tmp; + + tmp = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = hdr.ethernet.srcAddr; + hdr.ethernet.srcAddr = tmp; + + +/* Send the packet back to the port it came from */ + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + #define gen_matrix(INDEX, ROUND) action gen_matrix_i##INDEX##_r##ROUND##() { \ + bit<32> coef; \ + register_seed.read(coef, 0); \ + hash(coef, HashAlgorithm.crc32, (bit<32>) 0, {coef}, (bit<32>) PARAM_Q); \ + register_pub_matrix.write(##INDEX##, coef); \ + register_seed.write(0, coef); \ + } + gen_matrix(0, 1) + gen_matrix(1, 1) + gen_matrix(2, 1) + gen_matrix(3, 1) + gen_matrix(4, 1) + gen_matrix(5, 1) + gen_matrix(6, 1) + gen_matrix(7, 1) + gen_matrix(8, 1) + gen_matrix(9, 1) + gen_matrix(10, 1) + gen_matrix(11, 1) + gen_matrix(12, 1) + gen_matrix(13, 1) + gen_matrix(14, 1) + gen_matrix(15, 1) + gen_matrix(16, 1) + gen_matrix(17, 1) + gen_matrix(18, 1) + gen_matrix(19, 1) + + + #define gen_secret_vector(INDEX) action gen_secret_vector_i##INDEX##() { \ + bit<32> coef; \ + random(coef, 1, 4); \ + register_secret_vector.write(##INDEX##, coef); \ + } + gen_secret_vector(0) + gen_secret_vector(1) + gen_secret_vector(2) + gen_secret_vector(3) + gen_secret_vector(4) + gen_secret_vector(5) + gen_secret_vector(6) + gen_secret_vector(7) + gen_secret_vector(8) + gen_secret_vector(9) + + + #define gen_noise_vector(INDEX) action gen_noise_vector_i##INDEX##() { \ + bit<32> coef; \ + random(coef, 1, 4); \ + register_noise_vector.write(##INDEX##, coef); \ + } + gen_noise_vector(0) + gen_noise_vector(1) + gen_noise_vector(2) + gen_noise_vector(3) + gen_noise_vector(4) + gen_noise_vector(5) + gen_noise_vector(6) + gen_noise_vector(7) + gen_noise_vector(8) + gen_noise_vector(9) + + + #define matrix_mult(I_A, I_SU, I_TU) action matrix_mult_ia##I_A##_isr##I_SU##_itu##I_TU##() { \ + bit<32> a; \ + bit<32> s_r; \ + bit<32> t_u; \ + bit<32> temp; \ + register_pub_matrix.read(a, ##I_A##); \ + register_secret_vector.read(s_r, ##I_SU##); \ + register_public_vector_full.read(t_u, ##I_TU##); \ + temp = (a * s_r) + t_u; \ + register_public_vector_full.write(##I_TU##, temp); \ + } + matrix_mult(0, 0, 0) + matrix_mult(0, 1, 1) + matrix_mult(0, 2, 2) + matrix_mult(0, 3, 3) + matrix_mult(0, 4, 4) + matrix_mult(1, 0, 1) + matrix_mult(1, 1, 2) + matrix_mult(1, 2, 3) + matrix_mult(1, 3, 4) + matrix_mult(1, 4, 5) + matrix_mult(2, 0, 2) + matrix_mult(2, 1, 3) + matrix_mult(2, 2, 4) + matrix_mult(2, 3, 5) + matrix_mult(2, 4, 6) + matrix_mult(3, 0, 3) + matrix_mult(3, 1, 4) + matrix_mult(3, 2, 5) + matrix_mult(3, 3, 6) + matrix_mult(3, 4, 7) + matrix_mult(4, 0, 4) + matrix_mult(4, 1, 5) + matrix_mult(4, 2, 6) + matrix_mult(4, 3, 7) + matrix_mult(4, 4, 8) + matrix_mult(5, 5, 9) + matrix_mult(5, 6, 10) + matrix_mult(5, 7, 11) + matrix_mult(5, 8, 12) + matrix_mult(5, 9, 13) + matrix_mult(6, 5, 10) + matrix_mult(6, 6, 11) + matrix_mult(6, 7, 12) + matrix_mult(6, 8, 13) + matrix_mult(6, 9, 14) + matrix_mult(7, 5, 11) + matrix_mult(7, 6, 12) + matrix_mult(7, 7, 13) + matrix_mult(7, 8, 14) + matrix_mult(7, 9, 15) + matrix_mult(8, 5, 12) + matrix_mult(8, 6, 13) + matrix_mult(8, 7, 14) + matrix_mult(8, 8, 15) + matrix_mult(8, 9, 16) + matrix_mult(9, 5, 13) + matrix_mult(9, 6, 14) + matrix_mult(9, 7, 15) + matrix_mult(9, 8, 16) + matrix_mult(9, 9, 17) + matrix_mult(10, 0, 18) + matrix_mult(10, 1, 19) + matrix_mult(10, 2, 20) + matrix_mult(10, 3, 21) + matrix_mult(10, 4, 22) + matrix_mult(11, 0, 19) + matrix_mult(11, 1, 20) + matrix_mult(11, 2, 21) + matrix_mult(11, 3, 22) + matrix_mult(11, 4, 23) + matrix_mult(12, 0, 20) + matrix_mult(12, 1, 21) + matrix_mult(12, 2, 22) + matrix_mult(12, 3, 23) + matrix_mult(12, 4, 24) + matrix_mult(13, 0, 21) + matrix_mult(13, 1, 22) + matrix_mult(13, 2, 23) + matrix_mult(13, 3, 24) + matrix_mult(13, 4, 25) + matrix_mult(14, 0, 22) + matrix_mult(14, 1, 23) + matrix_mult(14, 2, 24) + matrix_mult(14, 3, 25) + matrix_mult(14, 4, 26) + matrix_mult(15, 5, 27) + matrix_mult(15, 6, 28) + matrix_mult(15, 7, 29) + matrix_mult(15, 8, 30) + matrix_mult(15, 9, 31) + matrix_mult(16, 5, 28) + matrix_mult(16, 6, 29) + matrix_mult(16, 7, 30) + matrix_mult(16, 8, 31) + matrix_mult(16, 9, 32) + matrix_mult(17, 5, 29) + matrix_mult(17, 6, 30) + matrix_mult(17, 7, 31) + matrix_mult(17, 8, 32) + matrix_mult(17, 9, 33) + matrix_mult(18, 5, 30) + matrix_mult(18, 6, 31) + matrix_mult(18, 7, 32) + matrix_mult(18, 8, 33) + matrix_mult(18, 9, 34) + matrix_mult(19, 5, 31) + matrix_mult(19, 6, 32) + matrix_mult(19, 7, 33) + matrix_mult(19, 8, 34) + matrix_mult(19, 9, 35) + + + #define poly_pub_add(X, Y, Z) action poly_pub_add_##X##_##Y##_##Z##() { \ + bit<32> x; \ + bit<32> y; \ + bit<32> sum; \ + register_public_vector_full.read(x, ##X##); \ + register_public_vector_full.read(y, ##Y##); \ + sum = x + y; \ + register_mod_public_vector.write(##Z##, sum); \ + } + poly_pub_add(0, 9, 0) + poly_pub_add(1, 10, 1) + poly_pub_add(2, 11, 2) + poly_pub_add(3, 12, 3) + poly_pub_add(4, 13, 4) + poly_pub_add(5, 14, 5) + poly_pub_add(6, 15, 6) + poly_pub_add(7, 16, 7) + poly_pub_add(8, 17, 8) + poly_pub_add(18, 27, 9) + poly_pub_add(19, 28, 10) + poly_pub_add(20, 29, 11) + poly_pub_add(21, 30, 12) + poly_pub_add(22, 31, 13) + poly_pub_add(23, 32, 14) + poly_pub_add(24, 33, 15) + poly_pub_add(25, 34, 16) + poly_pub_add(26, 35, 17) + + #define poly_mod(X, Y, Z) action poly_mod_##X##_##Y##_##Z##() { \ + bit<32> x; \ + bit<32> y; \ + bit<32> e; \ + bit<32> minus; \ + register_mod_public_vector.read(x, ##X##); \ + if (##Y## == 100){ \ + y = 0; \ + } \ + else{ \ + register_mod_public_vector.read(y, ##Y##); \ + } \ + hash(x, HashAlgorithm.identity, (bit<32>) 0, {x}, (bit<32>) PARAM_Q); \ + hash(y, HashAlgorithm.identity, (bit<32>) 0, {y}, (bit<32>) PARAM_Q); \ + if (x < y){ \ + x = x + PARAM_Q; \ + } \ + minus = x - y; \ + register_noise_vector.read(e, ##Z##); \ + minus = minus + e; \ + hash(minus, HashAlgorithm.identity, (bit<32>) 0, {minus}, (bit<32>) PARAM_Q); \ + register_public_vector.write(##Z##, minus); \ + hdr.p4calc.t_##Z## = minus; \ + } + poly_mod(4, 100, 0) + poly_mod(5, 0, 1) + poly_mod(6, 1, 2) + poly_mod(7, 2, 3) + poly_mod(8, 3, 4) + poly_mod(13, 100, 5) + poly_mod(14, 9, 6) + poly_mod(15, 10, 7) + poly_mod(16, 11, 8) + poly_mod(17, 12, 9) + + + action gen_keys() { + register_seed.write(0, hdr.p4calc.seed); + gen_matrix_i0_r1(); + gen_matrix_i1_r1(); + gen_matrix_i2_r1(); + gen_matrix_i3_r1(); + gen_matrix_i4_r1(); + gen_matrix_i5_r1(); + gen_matrix_i6_r1(); + gen_matrix_i7_r1(); + gen_matrix_i8_r1(); + gen_matrix_i9_r1(); + gen_matrix_i10_r1(); + gen_matrix_i11_r1(); + gen_matrix_i12_r1(); + gen_matrix_i13_r1(); + gen_matrix_i14_r1(); + gen_matrix_i15_r1(); + gen_matrix_i16_r1(); + gen_matrix_i17_r1(); + gen_matrix_i18_r1(); + gen_matrix_i19_r1(); + + gen_secret_vector_i0(); + gen_secret_vector_i1(); + gen_secret_vector_i2(); + gen_secret_vector_i3(); + gen_secret_vector_i4(); + gen_secret_vector_i5(); + gen_secret_vector_i6(); + gen_secret_vector_i7(); + gen_secret_vector_i8(); + gen_secret_vector_i9(); + + gen_noise_vector_i0(); + gen_noise_vector_i1(); + gen_noise_vector_i2(); + gen_noise_vector_i3(); + gen_noise_vector_i4(); + gen_noise_vector_i5(); + gen_noise_vector_i6(); + gen_noise_vector_i7(); + gen_noise_vector_i8(); + gen_noise_vector_i9(); + + matrix_mult_ia0_isr0_itu0(); + matrix_mult_ia0_isr1_itu1(); + matrix_mult_ia0_isr2_itu2(); + matrix_mult_ia0_isr3_itu3(); + matrix_mult_ia0_isr4_itu4(); + matrix_mult_ia1_isr0_itu1(); + matrix_mult_ia1_isr1_itu2(); + matrix_mult_ia1_isr2_itu3(); + matrix_mult_ia1_isr3_itu4(); + matrix_mult_ia1_isr4_itu5(); + matrix_mult_ia2_isr0_itu2(); + matrix_mult_ia2_isr1_itu3(); + matrix_mult_ia2_isr2_itu4(); + matrix_mult_ia2_isr3_itu5(); + matrix_mult_ia2_isr4_itu6(); + matrix_mult_ia3_isr0_itu3(); + matrix_mult_ia3_isr1_itu4(); + matrix_mult_ia3_isr2_itu5(); + matrix_mult_ia3_isr3_itu6(); + matrix_mult_ia3_isr4_itu7(); + matrix_mult_ia4_isr0_itu4(); + matrix_mult_ia4_isr1_itu5(); + matrix_mult_ia4_isr2_itu6(); + matrix_mult_ia4_isr3_itu7(); + matrix_mult_ia4_isr4_itu8(); + + matrix_mult_ia5_isr5_itu9(); + matrix_mult_ia5_isr6_itu10(); + matrix_mult_ia5_isr7_itu11(); + matrix_mult_ia5_isr8_itu12(); + matrix_mult_ia5_isr9_itu13(); + matrix_mult_ia6_isr5_itu10(); + matrix_mult_ia6_isr6_itu11(); + matrix_mult_ia6_isr7_itu12(); + matrix_mult_ia6_isr8_itu13(); + matrix_mult_ia6_isr9_itu14(); + matrix_mult_ia7_isr5_itu11(); + matrix_mult_ia7_isr6_itu12(); + matrix_mult_ia7_isr7_itu13(); + matrix_mult_ia7_isr8_itu14(); + matrix_mult_ia7_isr9_itu15(); + matrix_mult_ia8_isr5_itu12(); + matrix_mult_ia8_isr6_itu13(); + matrix_mult_ia8_isr7_itu14(); + matrix_mult_ia8_isr8_itu15(); + matrix_mult_ia8_isr9_itu16(); + matrix_mult_ia9_isr5_itu13(); + matrix_mult_ia9_isr6_itu14(); + matrix_mult_ia9_isr7_itu15(); + matrix_mult_ia9_isr8_itu16(); + matrix_mult_ia9_isr9_itu17(); + + matrix_mult_ia10_isr0_itu18(); + matrix_mult_ia10_isr1_itu19(); + matrix_mult_ia10_isr2_itu20(); + matrix_mult_ia10_isr3_itu21(); + matrix_mult_ia10_isr4_itu22(); + matrix_mult_ia11_isr0_itu19(); + matrix_mult_ia11_isr1_itu20(); + matrix_mult_ia11_isr2_itu21(); + matrix_mult_ia11_isr3_itu22(); + matrix_mult_ia11_isr4_itu23(); + matrix_mult_ia12_isr0_itu20(); + matrix_mult_ia12_isr1_itu21(); + matrix_mult_ia12_isr2_itu22(); + matrix_mult_ia12_isr3_itu23(); + matrix_mult_ia12_isr4_itu24(); + matrix_mult_ia13_isr0_itu21(); + matrix_mult_ia13_isr1_itu22(); + matrix_mult_ia13_isr2_itu23(); + matrix_mult_ia13_isr3_itu24(); + matrix_mult_ia13_isr4_itu25(); + matrix_mult_ia14_isr0_itu22(); + matrix_mult_ia14_isr1_itu23(); + matrix_mult_ia14_isr2_itu24(); + matrix_mult_ia14_isr3_itu25(); + matrix_mult_ia14_isr4_itu26(); + + matrix_mult_ia15_isr5_itu27(); + matrix_mult_ia15_isr6_itu28(); + matrix_mult_ia15_isr7_itu29(); + matrix_mult_ia15_isr8_itu30(); + matrix_mult_ia15_isr9_itu31(); + matrix_mult_ia16_isr5_itu28(); + matrix_mult_ia16_isr6_itu29(); + matrix_mult_ia16_isr7_itu30(); + matrix_mult_ia16_isr8_itu31(); + matrix_mult_ia16_isr9_itu32(); + matrix_mult_ia17_isr5_itu29(); + matrix_mult_ia17_isr6_itu30(); + matrix_mult_ia17_isr7_itu31(); + matrix_mult_ia17_isr8_itu32(); + matrix_mult_ia17_isr9_itu33(); + matrix_mult_ia18_isr5_itu30(); + matrix_mult_ia18_isr6_itu31(); + matrix_mult_ia18_isr7_itu32(); + matrix_mult_ia18_isr8_itu33(); + matrix_mult_ia18_isr9_itu34(); + matrix_mult_ia19_isr5_itu31(); + matrix_mult_ia19_isr6_itu32(); + matrix_mult_ia19_isr7_itu33(); + matrix_mult_ia19_isr8_itu34(); + matrix_mult_ia19_isr9_itu35(); + + poly_pub_add_0_9_0(); + poly_pub_add_1_10_1(); + poly_pub_add_2_11_2(); + poly_pub_add_3_12_3(); + poly_pub_add_4_13_4(); + poly_pub_add_5_14_5(); + poly_pub_add_6_15_6(); + poly_pub_add_7_16_7(); + poly_pub_add_8_17_8(); + + poly_pub_add_18_27_9(); + poly_pub_add_19_28_10(); + poly_pub_add_20_29_11(); + poly_pub_add_21_30_12(); + poly_pub_add_22_31_13(); + poly_pub_add_23_32_14(); + poly_pub_add_24_33_15(); + poly_pub_add_25_34_16(); + poly_pub_add_26_35_17(); + + poly_mod_4_100_0(); + poly_mod_5_0_1(); + poly_mod_6_1_2(); + poly_mod_7_2_3(); + poly_mod_8_3_4(); + poly_mod_13_100_5(); + poly_mod_14_9_6(); + poly_mod_15_10_7(); + poly_mod_16_11_8(); + poly_mod_17_12_9(); + + send_back(); + } + + action enc() { + + bit<32> e2; + random(e2, 0, 4); + bit<32> m; + random(m, 0, 2); + + send_back(); + } + + action dec() { + + send_back(); + } + + action operation_drop() { + mark_to_drop(standard_metadata); + } + + table calculate { + key = { + hdr.p4calc.op : exact; + } + actions = { + gen_keys; + enc; + dec; + operation_drop; + } + const default_action = operation_drop(); + const entries = { + GEN : gen_keys(); + ENC: enc(); + DEC : dec(); + } + } + + + apply { + if (hdr.p4calc.isValid()) { + calculate.apply(); + } else { + operation_drop(); + } + } +} + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.p4calc); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000056__raw-repositories__f-555__Lemon.p4 b/individual_files/000056__raw-repositories__f-555__Lemon.p4 new file mode 100644 index 0000000000000000000000000000000000000000..74db398fe88b15473d7aa36a34ffb80ab73445a0 --- /dev/null +++ b/individual_files/000056__raw-repositories__f-555__Lemon.p4 @@ -0,0 +1,278 @@ +#include +#include + +#define HASH_THRESHOLD 1288490189 + +#define BLOOM_SIZE 65536 +#define PKT_INSTANCE_TYPE_NORMAL 0 +#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1 +#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2 +#define PKT_INSTANCE_TYPE_COALESCED 3 +#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4 +#define PKT_INSTANCE_TYPE_REPLICATION 5 +#define PKT_INSTANCE_TYPE_RESUBMIT 6 + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<16> VirtualLAN= 0x8100; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<16> ether_type_t; +const ether_type_t ETHERTYPE_IPV4 = 16w0x0800; +const ether_type_t ETHERTYPE_ARP = 16w0x0806; +const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd; +const ether_type_t ETHERTYPE_VLAN = 16w0x8100; + +typedef bit<8> ip_protocol_t; +const ip_protocol_t IP_PROTOCOLS_ICMP = 1; +const ip_protocol_t IP_PROTOCOLS_TCP = 6; +const ip_protocol_t IP_PROTOCOLS_UDP = 17; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> src_port; + bit<16> dst_port; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; +} + +header udp_t { + bit<16> src_port; + bit<16> dst_port; + bit<16> hdr_length; + bit<16> checksum; +} + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +header vlan_tag_h { + bit<3> pcp; + bit<1> cfi; + bit<12> vid; + bit<16> type; +} + +struct metadata { + bit<32> dstip; + bit<32> srcip; + bit<16> srcport; + bit<16> dstport; + bit<8> protocol; + bit<8> kmvflag; + bit<32> khash; + bit<32> counter; + bit<16> epoch; +} + + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + udp_t udp; + tcp_t tcp; + icmp_t icmp; + vlan_tag_h vlan; +} + + + + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: ipv4; + VirtualLAN:vlan; + default: accept; + } + } + + state vlan{ + packet.extract(hdr.vlan); + transition select(hdr.vlan.type){ + TYPE_IPV4: ipv4; + default: accept; + } + } + + state ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + IP_PROTOCOLS_TCP : parse_tcp; + IP_PROTOCOLS_UDP : parse_udp; + IP_PROTOCOLS_ICMP : parse_icmp; + default : accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } +} + + + + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + + action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) { + hash(rhash, HashAlgorithm.crc16, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w12); + } + + action forward(in bit<32> rhash){ + bit<9> finalport = 1; + finalport=rhash[8:0] +1; + if( finalport >= 12) + finalport = 12; + if( finalport < 1) + finalport = 1; + if(standard_metadata.ingress_port != 14) { + finalport = 0; + } + standard_metadata.egress_spec = finalport; + } + + apply { + bit<32> rhash=1; + if (hdr.tcp.isValid()) { + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash); + forward(rhash); + } + else if (hdr.udp.isValid()) { + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash); + forward(rhash); + }else{ + standard_metadata.egress_spec = 0; + } + + if(standard_metadata.ingress_port != 14) { + standard_metadata.egress_spec = 0; + } + } +} + + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + } +} + + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.tos, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + +//parsed headers have to be added again into the packet. + packet.emit(hdr.ethernet); + packet.emit(hdr.vlan); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + packet.emit(hdr.udp); + packet.emit(hdr.icmp); + } +} + + + + + +//switch architecture + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000057__raw-repositories__f-555__Lemon.p4 b/individual_files/000057__raw-repositories__f-555__Lemon.p4 new file mode 100644 index 0000000000000000000000000000000000000000..aec0384990c6eef0bcda32a15585b84f01065061 --- /dev/null +++ b/individual_files/000057__raw-repositories__f-555__Lemon.p4 @@ -0,0 +1,471 @@ +/*Lemon sketch for packets counting per-dstIP */ +#include +#include + +#define PKT_INSTANCE_TYPE_NORMAL 0 +#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1 +#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2 +#define PKT_INSTANCE_TYPE_COALESCED 3 +#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4 +#define PKT_INSTANCE_TYPE_REPLICATION 5 +#define PKT_INSTANCE_TYPE_RESUBMIT 6 +#define HEAVY_T 100 + +#define T1 16384 +#define T2 8192 +#define T3 1024 +#define T4 256 +#define Th 256 + +#define layer1_size 32w524288 +#define layer2_size 32w65536 +#define layer3_size 32w8192 +#define layer4_size 32w2048 +#define layer5_size 32w1024 + +#define layer1_size_bit1 32w4194304 +#define layer2_size_bit1 32w2097152 +#define layer3_size_bit1 32w262144 +#define layer4_size_bit1 32w65536 +#define layer5_size_bit1 32w524288 + +#define l1_bitmap 32w8 +#define l2_bitmap 32w32 +#define l3_bitmap 32w32 +#define l4_bitmap 32w32 +#define l5_bitmap 32w512 + +#define Hsize 32w8192 + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<16> VirtualLAN= 0x8100; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<16> ether_type_t; +const ether_type_t ETHERTYPE_IPV4 = 16w0x0800; +const ether_type_t ETHERTYPE_ARP = 16w0x0806; +const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd; +const ether_type_t ETHERTYPE_VLAN = 16w0x8100; + +typedef bit<8> ip_protocol_t; +const ip_protocol_t IP_PROTOCOLS_ICMP = 1; +const ip_protocol_t IP_PROTOCOLS_TCP = 6; +const ip_protocol_t IP_PROTOCOLS_UDP = 17; + + +header cpu_t { + bit<32> hash; + bit<32> hash1; + bit<32> srcip; + bit<32> dstip; + bit<16> srcport; + bit<16> dstport; + bit<8> protocol; + bit<32> counter; + bit<16> epoch; + bit <8> outputport; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> src_port; + bit<16> dst_port; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; + bit<16> payload; +} + +header udp_t { + bit<16> src_port; + bit<16> dst_port; + bit<16> hdr_length; + bit<16> checksum; + bit<16> payload; +} + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +header vlan_tag_h { + bit<3> pcp; + bit<1> cfi; + bit<12> vid; + bit<16> type; +} + +struct metadata { + bit<32> dstip; + bit<32> srcip; + bit<16> srcport; + bit<16> dstport; + bit<8> protocol; + bit<8> kmvflag; + bit<32> khash; + bit<32> khash1; + bit<32> counter; + bit<16> epoch; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + cpu_t cpu; + udp_t udp; + tcp_t tcp; + icmp_t icmp; + vlan_tag_h vlan; +} + + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: ipv4; + VirtualLAN:vlan; + default: accept; + } + } + + state vlan{ + packet.extract(hdr.vlan); + transition select(hdr.vlan.type){ + TYPE_IPV4: ipv4; + default: accept; + } + } + + state ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + IP_PROTOCOLS_TCP : parse_tcp; + IP_PROTOCOLS_UDP : parse_udp; + + default : reject; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + register>(layer1_size_bit1) lemon_layer1; + register>(layer2_size_bit1) lemon_layer2; + register>(layer3_size_bit1) lemon_layer3; + register>(layer4_size_bit1) lemon_layer4; + register>(layer5_size_bit1) lemon_layer5; + + register>(4) hash_deep_threshold; + + register>(layer1_size) counter; + + register>(8192) lemon_heavy_id; + + register>(8192) lemon_heavy_tag; + + + register>(1) sip_mask_f; + register>(1) dip_mask_f; + register>(1) sport_mask_f; + register>(1) dport_mask_f; + register>(1) protol_f; + + register>(1) sip_mask; + register>(1) dip_mask; + register>(1) sport_mask; + register>(1) dport_mask; + register>(1) protol; + register>(1) ip_checksum; + register>(1) transport_checksum; + register>(1) perpkt_tag; + + action deep_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> ipsum, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<16> payload,out bit<16> dhash){ + hash(dhash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,ipsum,checksum,seq_no,hdlen,payload}, 16w65535); + } + + action slot_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> shash) { + hash(shash, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, layer1_size); + } + + action bitmap_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> ipsum, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<16> payload,out bit<32> bhash) { + hash(bhash, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,ipsum,checksum,seq_no,hdlen,payload}, l5_bitmap); + } + + action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) { + hash(rhash, HashAlgorithm.crc32_custom, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w3); + } + + action slot_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> shash) { + hash(shash, HashAlgorithm.identity, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, layer1_size); + } + + register>(Hsize) Heavy_dst; + + action forward(in bit<32> rhash){ + bit<9> finalport = 1; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + + if(hdr.ipv4.ttl == 0) + finalport = 10; + + standard_metadata.egress_spec = 1; + +// for chuanxing + } + + apply { + + bit<32> rhash; + +//only if IPV4 the rule is applied. Therefore other packets will not be forwarded. + if (hdr.ipv4.isValid()){ + + meta.srcip=hdr.ipv4.srcAddr; + meta.dstip=hdr.ipv4.dstAddr; + meta.protocol=hdr.ipv4.protocol; + } + + bit<16> deep_h = 0; + bit<32> slot_h = 0; + bit<32> slot_h2 = 0; + bit<32> bitmap_h = 0; + + + bit<32> sip_mask_f = 0; + + bit<32> dip_mask_f = 0xffffffff; + bit<16> sport_mask_f = 0; + bit<16> dport_mask_f = 0; + bit<8> protocol_mask_f = 0; + + bit<32> sip_mask = 0xffffffff; + bit<32> dip_mask = 0xffffffff; + bit<16> sport_mask = 0xffff; + bit<16> dport_mask = 0xffff; + bit<8> protocol_mask = 0xff; + bit<16> ip_checksum_mask = 0xffff; + bit<16> transport_checksum_mask = 0xffff; + bit<16> payload_mask = 0xffff; + + if (hdr.tcp.isValid()) { + deep_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.tcp.checksum,hdr.tcp.seq_no, 0, hdr.tcp.payload, deep_h); + slot_hash(hdr.ipv4.srcAddr & sip_mask_f, hdr.ipv4.dstAddr & dip_mask_f, hdr.tcp.src_port & sport_mask_f, hdr.tcp.dst_port & dport_mask_f,hdr.ipv4.protocol & protocol_mask_f, slot_h); + bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.tcp.checksum,hdr.tcp.seq_no, 0, 0, bitmap_h); + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash); + +//forward(rhash); + } + else if (hdr.udp.isValid()) { + deep_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, deep_h); + slot_hash(hdr.ipv4.srcAddr & sip_mask_f, hdr.ipv4.dstAddr & dip_mask_f, hdr.udp.src_port & sport_mask_f, hdr.udp.dst_port & dport_mask_f,hdr.ipv4.protocol & protocol_mask_f, slot_h); + bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol,hdr.ipv4.hdrChecksum, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, bitmap_h); + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash); + +//forward(rhash); + } + + + + bit<16> deep1; + bit<16> deep2; + bit<16> deep3; + bit<16> deep4; + + hash_deep_threshold.write(0, T1); + hash_deep_threshold.write(1, T2); + hash_deep_threshold.write(2, T3); + hash_deep_threshold.write(3, T4); + + hash_deep_threshold.read(deep1,0); + hash_deep_threshold.read(deep2,1); + hash_deep_threshold.read(deep3,2); + hash_deep_threshold.read(deep4,3); + + + bit<32> counter_hash = 0; + bit<32> counter_val = 0; + counter_hash[18:0] = slot_h[18:0]; + counter.read(counter_val, counter_hash); + counter_val = counter_val + 1; + counter.write(counter_hash,counter_val); + + bit<16> roll = 0; + if(deep_h<=deep4){ + bit<32> slot = 0; + slot[18:9] = slot_h[9:0]; + slot[8:0] = bitmap_h[8:0]; + + lemon_layer5.write(slot,1); + } + if(deep_h<=deep3 && deep_h>deep4){ + bit<32> slot = 0; + slot[15:5] = slot_h[10:0]; + slot[4:0] = bitmap_h[4:0]; + + lemon_layer4.write(slot,1); + } + if(deep_h<=deep2 && deep_h>deep3){ + + bit<32> slot = 0; + slot[17:5] = slot_h[12:0]; + slot[4:0] = bitmap_h[4:0]; + + lemon_layer3.write(slot,1); + } + if(deep_h<=deep1 && deep_h>deep2){ + + bit<32> slot = 0; + slot[20:5] = slot_h[15:0]; + slot[4:0] = bitmap_h[4:0]; + + lemon_layer2.write(slot,1); + } + if(deep_h > deep1){ + + bit<32> slot = 0; + slot[21:3] = slot_h[18:0]; + slot[2:0] = bitmap_h[2:0]; + + lemon_layer1.write(slot,1); + } + if(deep_h < deep3){ + bit<32> slot = 0; + slot[12:0] = slot_h[12:0]; + lemon_heavy_id.write(slot,hdr.ipv4.dstAddr); + lemon_heavy_tag.write(slot,slot_h); + } + hdr.ipv4.srcAddr[31:0] = 0; + + hdr.ipv4.identification[15:0] = deep_h; + standard_metadata.egress_spec = 1; + } +} + + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + + } + +} + + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.tos, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + +//parsed headers have to be added again into the packet. + + } +} + + + + + +//switch architecture + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000058__raw-repositories__f-555__Lemon.p4 b/individual_files/000058__raw-repositories__f-555__Lemon.p4 new file mode 100644 index 0000000000000000000000000000000000000000..454b9be9e6fcb3026bf2d6ef882830cd3f43664c --- /dev/null +++ b/individual_files/000058__raw-repositories__f-555__Lemon.p4 @@ -0,0 +1,454 @@ +#include +#include + +#define PKT_INSTANCE_TYPE_NORMAL 0 +#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1 +#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2 +#define PKT_INSTANCE_TYPE_COALESCED 3 +#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4 +#define PKT_INSTANCE_TYPE_REPLICATION 5 +#define PKT_INSTANCE_TYPE_RESUBMIT 6 +#define HEAVY_T 25 + +#define Lsize 32w524288 + +// 8*8192 256 bitmap +#define Lsize_bitmap 32w16 + +#define Lsize_totle 32w8388608 + +#define Hsize 32w1024 + +// size of heavy part +#define Hsize_hll 32w32 + +// +#define Hsize_totle 32w524288 + + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<16> VirtualLAN= 0x8100; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +typedef bit<16> ether_type_t; +const ether_type_t ETHERTYPE_IPV4 = 16w0x0800; +const ether_type_t ETHERTYPE_ARP = 16w0x0806; +const ether_type_t ETHERTYPE_IPV6 = 16w0x86dd; +const ether_type_t ETHERTYPE_VLAN = 16w0x8100; + +typedef bit<8> ip_protocol_t; +const ip_protocol_t IP_PROTOCOLS_ICMP = 1; +const ip_protocol_t IP_PROTOCOLS_TCP = 6; +const ip_protocol_t IP_PROTOCOLS_UDP = 17; + + +header cpu_t { + bit<32> hash; + bit<32> hash1; + bit<32> srcip; + bit<32> dstip; + bit<16> srcport; + bit<16> dstport; + bit<8> protocol; + bit<32> counter; + bit<16> epoch; + bit <8> outputport; +} + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> src_port; + bit<16> dst_port; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; +} + +header udp_t { + bit<16> src_port; + bit<16> dst_port; + bit<16> hdr_length; + bit<16> checksum; + bit<48> payload; +} + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +header vlan_tag_h { + bit<3> pcp; + bit<1> cfi; + bit<12> vid; + bit<16> type; +} + +struct metadata { + bit<32> dstip; + bit<32> srcip; + bit<16> srcport; + bit<16> dstport; + bit<8> protocol; + bit<8> hllflag; + bit<32> khash; + bit<32> khash1; + bit<32> counter; + bit<16> epoch; +} + + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + cpu_t cpu; + udp_t udp; + tcp_t tcp; + icmp_t icmp; + vlan_tag_h vlan; +} + + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + TYPE_IPV4: ipv4; + VirtualLAN:vlan; + default: accept; + } + } + + state vlan{ + packet.extract(hdr.vlan); + transition select(hdr.vlan.type){ + TYPE_IPV4: ipv4; + default: accept; + } + } + + state ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + IP_PROTOCOLS_TCP : parse_tcp; + IP_PROTOCOLS_UDP : parse_udp; + IP_PROTOCOLS_ICMP : parse_icmp; + default : accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + register>(Lsize) Light_counter1; + register>(Lsize_totle) Light_1; + + + register>(Hsize_totle) Heavy; + register>(Hsize) Heavy_sip; + register>(Hsize) Heavy_dip; + register>(Hsize) Heavy_sp; + register>(Hsize) Heavy_dp; + register>(Hsize) Heavy_prot; + register>(Hsize) Heavy_lhash1; + register>(Hsize) Heavy_lhash2; + + register>(1) pkgcounter; + register>(1) epoch; + + action bloom_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<32> h1, out bit<32> h2, out bit<32> h3) { + hash(h1, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff); + hash(h2, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff); + hash(h3, HashAlgorithm.crc32_custom, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,checksum,seq_no,hdlen,payload}, 32w0x0003ffff); + } + + action light_slot_hash1(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) { + hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Lsize); + } + action light_slot_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) { + hash(khash, HashAlgorithm.identity, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Lsize); + } + action bitmap_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload,out bit<32> khash) { + hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, Lsize_bitmap); + } + + action heavy_slot_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> khash) { + hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, Hsize); + } + action heavy_slot_armoma_hash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<32> khash) { + hash(khash, HashAlgorithm.crc32, 32w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, Hsize_hll); + } + action hll_hash1(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<16> khash) { + hash(khash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, 16w0xffff); + } + action hll_hash2(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, in bit<16> checksum, in bit<32> seq_no, in bit<16> hdlen, in bit<48> payload, out bit<16> khash) { + hash(khash, HashAlgorithm.crc32_custom, 16w0, {ipv4_src, ipv4_dst,srcport,dstport,protocol,checksum,seq_no,hdlen,payload}, 16w0xffff); + } + + + action routehash(in bit<32> ipv4_src, in bit<32> ipv4_dst, in bit<16> srcport, in bit<16> dstport, in bit<8> protocol, out bit<32> rhash) { + hash(rhash, HashAlgorithm.crc32, 32w00000000, {ipv4_src, ipv4_dst,srcport,dstport,protocol}, 32w3); + } + + action forward(in bit<32> rhash){ + bit<9> finalport = 1; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + + if(hdr.ipv4.ttl == 0) + finalport = 10; + standard_metadata.egress_spec = finalport+1; + } + + apply { + + bit<32> rhash; + +//only if IPV4 the rule is applied. Therefore other packets will not be forwarded. + if (hdr.ipv4.isValid()){ + meta.srcip=hdr.ipv4.srcAddr; + meta.dstip=hdr.ipv4.dstAddr; + meta.protocol=hdr.ipv4.protocol; + } + + + bit<32> h1=0; + bit<32> h2=0; + bit<32> h3=0; + + bit<32> light_slot_h1=0; + bit<32> bitmap_h=0; + + bit<32> heavy_slot_h=0; + bit<32> heavy_slot_armoma_h=0; + bit<16> khash1=0; + bit<16> khash2=0; + + if (hdr.tcp.isValid()) { + bloom_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, h1, h2, h3); + + light_slot_hash1(0, hdr.ipv4.dstAddr, 0, 0, 0, light_slot_h1); + + bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no , 0,0 , bitmap_h); + + heavy_slot_hash(0, hdr.ipv4.dstAddr, 0, 0, 0, heavy_slot_h); + heavy_slot_armoma_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, heavy_slot_armoma_h); + hll_hash1(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, khash1); + hll_hash2(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, hdr.tcp.checksum,hdr.tcp.seq_no,0,0, khash2); + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.tcp.src_port, hdr.tcp.dst_port,hdr.ipv4.protocol, rhash); + + khash1[7:4]=khash2[7:4]; + forward(rhash); + } + else if (hdr.udp.isValid()) { + bloom_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload,h1, h2, h3); + + light_slot_hash1(0, hdr.ipv4.dstAddr, 0, 0, 0, light_slot_h1); + + bitmap_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, bitmap_h); + + heavy_slot_hash(0, hdr.ipv4.dstAddr, 0, 0, 0, heavy_slot_h); + heavy_slot_armoma_hash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port, hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, heavy_slot_armoma_h); + hll_hash1(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, khash1); + hll_hash2(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, hdr.udp.checksum, 0,hdr.udp.hdr_length,hdr.udp.payload, khash2); + routehash(hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.udp.src_port, hdr.udp.dst_port,hdr.ipv4.protocol, rhash); + + khash1[7:4]=khash2[7:4]; + forward(rhash); + }else{ + standard_metadata.egress_spec =0; + } + + + bit<16> counternow1 = 0; + bit<16> counternow2 = 0; + bit<16> heavy_flag = 0; + Light_counter1.read(counternow1,light_slot_h1); + counternow1 = counternow1 +1; + Light_counter1.write(light_slot_h1,counternow1); + + if(counternow1 >= HEAVY_T) + heavy_flag = 1; + + if(heavy_flag == 0){ + bit<32> l_index = 0; + bit<32> bitmap1 = 0; + bit<8> roll = 0; + +// for bitmap + l_index[22:4] = light_slot_h1[18:0]; + l_index[3:0] = bitmap_h[3:0]; + Light_1.write(l_index,1); + } + + bit<16> hashnow; + bit<32> h_index; + h_index[14:5]=heavy_slot_h[9:0]; + h_index[4:0]=heavy_slot_armoma_h[4:0]; + if(heavy_flag == 1){ + Heavy.read(hashnow,h_index); + if((hashnow > khash1 || hashnow==0)){ + Heavy.write(h_index,khash1); + } + Heavy_sip.write(heavy_slot_h,hdr.ipv4.srcAddr); + Heavy_dip.write(heavy_slot_h,hdr.ipv4.dstAddr); + Heavy_prot.write(heavy_slot_h,hdr.ipv4.protocol); + Heavy_lhash1.write(heavy_slot_h, light_slot_h1); + if(hdr.tcp.isValid()){ + Heavy_sp.write(heavy_slot_h,hdr.tcp.src_port); + Heavy_dp.write(heavy_slot_h,hdr.tcp.dst_port); + } + if(hdr.udp.isValid()){ + Heavy_sp.write(heavy_slot_h,hdr.udp.src_port); + Heavy_dp.write(heavy_slot_h,hdr.udp.dst_port); + } + } + } +} + + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + + if (standard_metadata.instance_type != 0){ + hdr.ethernet.etherType =0x1234; + hdr.cpu.setValid(); + hdr.vlan.setInvalid(); + hdr.cpu.hash = meta.khash; + hdr.cpu.hash1 = meta.khash1; + hdr.cpu.srcip = meta.srcip; + hdr.cpu.dstip = meta.dstip; + hdr.cpu.srcport = meta.srcport; + hdr.cpu.dstport = meta.dstport; + hdr.cpu.protocol = meta.protocol; + hdr.cpu.counter = meta.counter; + hdr.cpu.epoch= meta.epoch; + hdr.cpu.outputport = standard_metadata.egress_spec[7:0]; + } + } + +} + + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.tos, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + +//parsed headers have to be added again into the packet. + packet.emit(hdr.ethernet); + packet.emit(hdr.vlan); + packet.emit(hdr.cpu); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + packet.emit(hdr.udp); + packet.emit(hdr.icmp); + } +} + + + + + +//switch architecture + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000059__raw-repositories__diogocampos__p4-data-flow.p4 b/individual_files/000059__raw-repositories__diogocampos__p4-data-flow.p4 new file mode 100644 index 0000000000000000000000000000000000000000..524c2b63636742cfbcfcf039d068575a53e66a94 --- /dev/null +++ b/individual_files/000059__raw-repositories__diogocampos__p4-data-flow.p4 @@ -0,0 +1,287 @@ +#include + + +typedef bit<48> mac_addr_t; +typedef bit<128> ipv6_addr_t; +typedef bit<9> port_t; +const bit<16> TYPE_IPV6 = 0x86dd; +const bit<9> TYPE_CPU = 9w192; +const bit<8> PROTO_TCP = 6; +const bit<8> PROTO_UDP = 17; +const bit<8> PROTO_ICMP6 = 58; +const bit<8> TCP_SEQ_LEN = 4; +const bit<8> ICMP6_ECHO_REQUEST = 128; +const bit<8> ICMP6_ECHO_REPLY = 129; + +header ethernet_t { + mac_addr_t dstAddr; + mac_addr_t srcAddr; + bit<16> etherType; +} + +header ipv6_t { + bit<4> version; + bit<8> traffic_class; + bit<20> flow_label; + bit<16> payload_length; + bit<8> nextHdr; + bit<8> hopLimit; + ipv6_addr_t srcAddr; + ipv6_addr_t dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + int<32> seqNo; + int<32> ackNo; + bit<4> data_offset; + bit<4> res; + bit<1> cwr; + bit<1> ece; + bit<1> urg; + bit<1> ack; + bit<1> psh; + bit<1> rst; + bit<1> syn; + bit<1> fin; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +header icmp6_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +struct headers { + ethernet_t inner_ethernet; + icmp6_t inner_icmp6; + ipv6_t inner_ipv6; + tcp_t inner_tcp; + udp_t inner_udp; + ethernet_t ethernet; + icmp6_t icmp6; + ipv6_t ipv6; + tcp_t tcp; + udp_t udp; +} + +struct l3_metadata_t { + bit<2> lkp_ip_type; + bit<4> lkp_ip_version; + bit<8> lkp_ip_proto; + bit<8> lkp_dscp; + bit<8> lkp_ip_ttl; + bit<16> lkp_l4_sport; + bit<16> lkp_l4_dport; + bit<16> lkp_outer_l4_sport; + bit<16> lkp_outer_l4_dport; + bit<16> vrf; + bit<10> rmac_group; + bit<1> rmac_hit; + bit<2> urpf_mode; + bit<1> urpf_hit; + bit<1> urpf_check_fail; + bit<16> urpf_bd_group; + bit<1> fib_hit; + bit<16> fib_nexthop; + bit<2> fib_nexthop_type; + bit<16> same_bd_check; + bit<16> nexthop_index; + bit<1> routed; + bit<1> outer_routed; + bit<8> mtu_index; + bit<1> l3_copy; + bit<16> l3_mtu_check; + bit<16> egress_l4_sport; + bit<16> egress_l4_dport; +} + +struct tunnel_metadata_t { + bit<5> ingress_tunnel_type; + bit<24> tunnel_vni; + bit<5> egress_tunnel_type; + bit<14> tunnel_index; + bit<9> tunnel_src_index; + bit<9> tunnel_smac_index; + bit<14> tunnel_dst_index; + bit<14> tunnel_dmac_index; + bit<24> vnid; + bit<1> tunnel_terminate; + bit<1> tunnel_if_check; + bit<4> egress_header_count; + bit<8> inner_ip_proto; + bit<1> skip_encap_inner; +} + +struct l2_metadata_t { + bit<48> lkp_mac_sa; + bit<48> lkp_mac_da; + bit<3> lkp_pkt_type; + bit<16> lkp_mac_type; + bit<3> lkp_pcp; + bit<16> l2_nexthop; + bit<2> l2_nexthop_type; + bit<1> l2_redirect; + bit<1> l2_src_miss; + bit<16> l2_src_move; + bit<10> stp_group; + bit<3> stp_state; + bit<16> bd_stats_idx; + bit<1> learning_enabled; + bit<1> port_vlan_mapping_miss; + bit<16> same_if_check; +} + +struct ipv6_metadata_t { + bit<128> lkp_ipv6_sa; + bit<128> lkp_ipv6_da; + bit<1> ipv6_unicast_enabled; + bit<1> ipv6_src_is_link_local; + bit<2> ipv6_urpf_mode; +} + +struct acl_metadata_t { + bit<1> acl_deny; /* ifacl/vacl deny action */ + bit<24> vnid; /* vnid for acls */ + bit<14> acl_stats_index; /* acl stats index */ + bit<16> egress_if_label; /* if label for egress acls */ + bit<16> egress_bd_label; /* bd label for egress acls */ +} + +struct fwd_meta_t { + bit<32> l2ptr; + bit<24> out_bd; +} + +struct metadata_t { + port_t ingress_port; + port_t egress_port; + bit<16> tcp_length; + bit<32> cast_length; + bit<1> do_cksum; + l2_metadata_t l2_metadata; + l3_metadata_t l3_metadata; + ipv6_metadata_t ipv6_metadata; + tunnel_metadata_t tunnel_metadata; + fwd_meta_t fwd; +} + + +const bit<32> BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION = 5; +#define IS_REPLICATED(std_meta) (std_meta.instance_type == BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION) + +parser MyParser(packet_in packet, out headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV6: ipv6; + default: accept; + } + } + state ipv6 { + packet.extract(hdr.ipv6); + transition select(hdr.ipv6.nextHdr) { + PROTO_UDP: parse_udp; + PROTO_ICMP6: icmp6; + default: accept; + } + } + state icmp6 { + packet.extract(hdr.icmp6); + transition accept; + } + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } +} + + +control ingress(inout headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + action set_mcast_grp(bit<16> mcast_grp, bit<9> port) { + standard_metadata.mcast_grp = mcast_grp; + meta.egress_port = port; + } + table ipv6_tbl { + key = { + (hdr.ipv6.dstAddr[127:120] == 8w0xff) : exact @name("mcast_key"); + } + actions = {set_mcast_grp;} + } + + apply { + if (hdr.ipv6.isValid()) { + ipv6_tbl.apply(); + } + } +} + +control egress(inout headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + action set_out_bd (bit<24> bd) { + meta.fwd.out_bd = bd; + } + table get_multicast_copy_out_bd { + key = { + standard_metadata.mcast_grp : exact; + standard_metadata.egress_rid : exact; + } + actions = { set_out_bd; } + } + + action drop() { + mark_to_drop(standard_metadata); + } + action rewrite_mac(bit<48> smac) { + hdr.ethernet.srcAddr = smac; + } + table send_frame { + key = { + meta.fwd.out_bd: exact; + } + actions = {rewrite_mac; drop;} + default_action = drop; + } + + apply { + if (IS_REPLICATED(standard_metadata)) { + get_multicast_copy_out_bd.apply(); + send_frame.apply(); + } + } +} + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv6); + packet.emit(hdr.icmp6); + packet.emit(hdr.udp); + } +} + +control MyVerifyChecksum(inout headers hdr, inout metadata_t meta) { + apply { + } +} + +control MyComputeChecksum(inout headers hdr, inout metadata_t meta) { + apply { + } +} + +V1Switch(MyParser(), MyVerifyChecksum(), ingress(), egress(), +MyComputeChecksum(), MyDeparser()) main; diff --git a/individual_files/000060__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000060__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..5ad9a22b571a2f63f01e0336d7aa34ca9082e25a --- /dev/null +++ b/individual_files/000060__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,285 @@ +#include +#include + +// HEADERS + + +// Define header types + +header arp_t { + bit<16> ptype; + bit<8> plen; + bit<16> oper; + bit<16> htype; + bit<8> hlen; +} +header arp_ipv4_t { + bit<32> tpa; + bit<48> tha; + bit<32> spa; + bit<48> sha; +} +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header icmp_t { + bit<8> type; + bit<16> checksum; +} +header ipv4_t { + bit<8> ttl; + bit<32> srcAddr; + bit<8> protocol; + bit<32> dstAddr; +} + +// Assemble headers in a single struct +struct my_headers_t { + arp_t arp; + arp_ipv4_t arp_ipv4; + ethernet_t ethernet; + icmp_t icmp; + ipv4_t ipv4; +} + + + +// METADATA + + +struct my_metadata_t { + + bit<48> my_mac; + bit<48> mac_sa; + bit<48> mac_da; + bit<9> egress_port; + bit<32> dst_ipv4; + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_arp { + packet.extract(hdr.arp); + transition select(hdr.arp.htype,hdr.arp.ptype,hdr.arp.hlen,hdr.arp.plen){ + (16w1,16w2048,8w6,8w4) : parse_arp_ipv4; + default : accept; + } + + } + + + state parse_arp_ipv4 { + packet.extract(hdr.arp_ipv4); + meta.dst_ipv4 = hdr.arp_ipv4.tpa; + transition accept; + } + + + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + meta.dst_ipv4 = hdr.ipv4.dstAddr; + transition select(hdr.ipv4.protocol){ + (8w1) : parse_icmp; + default : accept; + } + + } + + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + (16w2054) : parse_arp; + default : accept; + } + + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<9> egress_port; + bit<1> exited; + bit<48> mac_da; + bit<48> mac_sa; + bit<32> tmp_ip; + bit<48> tmp_mac; + + +// Action Definitions + action forward_action_0(){ + hdr.ethernet.dstAddr = meta.mac_da; + hdr.ethernet.srcAddr = meta.mac_sa; + hdr.ipv4.ttl = (hdr.ipv4.ttl - 8w1); + standard_metadata.egress_spec = meta.egress_port; + } + + action forward_action_1(){ + hdr.ethernet.dstAddr = hdr.arp_ipv4.sha; + hdr.ethernet.srcAddr = meta.mac_da; + hdr.arp.oper = 16w2; + hdr.arp_ipv4.tha = hdr.arp_ipv4.sha; + hdr.arp_ipv4.tpa = hdr.arp_ipv4.spa; + hdr.arp_ipv4.sha = meta.mac_da; + hdr.arp_ipv4.spa = meta.dst_ipv4; + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + action forward_action_2(){ + tmp_mac = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = hdr.ethernet.srcAddr; + hdr.ethernet.srcAddr = tmp_mac; + tmp_ip = hdr.ipv4.dstAddr; + hdr.ipv4.dstAddr = hdr.ipv4.srcAddr; + hdr.ipv4.srcAddr = tmp_ip; + hdr.icmp.type = 8w0; + hdr.icmp.checksum = 16w0; + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + action forward_action_3(){ + standard_metadata.egress_spec = 9w511; + exited = 1w1; + } + + action ipv4_lpm_action_0(bit<48> mac_da,bit<48> mac_sa,bit<9> egress_port){ + meta.mac_da = mac_da; + meta.mac_sa = mac_sa; + meta.egress_port = egress_port; + } + + action ipv4_lpm_action_1(){ + standard_metadata.egress_spec = 9w511; + exited = 1w1; + } + + +// Table Definitions + + table forward { + key = { + hdr.arp.isValid() : exact; + hdr.arp.oper : exact; + hdr.arp_ipv4.isValid() : exact; + hdr.ipv4.isValid() : exact; + hdr.icmp.isValid() : exact; + hdr.icmp.type : ternary; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + forward_action_3; + } + } + + table ipv4_lpm { + key = { + meta.dst_ipv4 : exact; + } + actions = { + ipv4_lpm_action_0; + ipv4_lpm_action_1; + } + } + + + apply { + +// Pipeline + meta.my_mac = 48w102030405; + if ((1w1 == exited)) {} else { + ipv4_lpm.apply(); + forward.apply(); + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Action Definitions + + +// Table Definitions + + + apply { + +// Pipeline + + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000061__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000061__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9a93ca747aa98bc32318d63b471344d36ff3af05 --- /dev/null +++ b/individual_files/000061__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,243 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<8> protocol; + bit<32> dstAddr; +} +header tcp_t { + +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +// METADATA + + + +struct routing_metadata_t { + + bit<32> nhop_ipv4; + +} +struct my_metadata_t { + routing_metadata_t routing_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w6) : parse_tcp; + default : accept; + } + + } + + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> dmac; + bit<32> nhop_ipv4; + bit<9> port; + + +// Action Definitions + action ecmp_group_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action ecmp_group_action_1(bit<32> nhop_ipv4,bit<9> port){ + meta.routing_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action ecmp_group_action_2(){ + + } + + action forward_action_0(bit<48> dmac){ + hdr.ethernet.dstAddr = dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + +// Table Definitions + + table ecmp_group { + key = { + hdr.ipv4.dstAddr : ternary; + } + actions = { + ecmp_group_action_0; + ecmp_group_action_1; + ecmp_group_action_2; + } + } + + table forward { + key = { + meta.routing_metadata.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + + apply { + +// Pipeline + if (!((hdr.ipv4.isValid() ? 1w1 : 1w0) == 1w1)) {} else { + if (!(hdr.ipv4.ttl > 8w0)) {} else { + ecmp_group.apply(); + forward.apply(); + } + + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> smac; + + +// Action Definitions + action send_frame_action_0(bit<48> smac){ + hdr.ethernet.srcAddr = smac; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + +// Table Definitions + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + } + } + + + apply { + +// Pipeline + send_frame.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000062__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000062__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..d89243e4c4ffa19b063ae5c84db8d4b21993bcb9 --- /dev/null +++ b/individual_files/000062__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,374 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<32> srcAddr; + bit<8> protocol; + bit<32> dstAddr; +} +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +// METADATA + + + +struct ingress_metadata_t { + + bit<32> nhop_ipv4; + bit<13> flowlet_map_index; + bit<32> flowlet_lasttime; + bit<16> flowlet_id; + bit<32> flow_ipg; + bit<14> ecmp_offset; + +} + +struct intrinsic_metadata_t { + + bit<48> ingress_global_timestamp; + +} +struct my_metadata_t { + ingress_metadata_t ingress_metadata; + intrinsic_metadata_t intrinsic_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w6) : parse_tcp; + default : accept; + } + + } + + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + + state start { + packet.extract(hdr.ethernet); + transition accept; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<13> DEVNULL_flowlet_id_lookup_flowlet_map; + bit<13> DEVNULL_flowlet_id_update_flowlet_id_index; + bit<16> DEVNULL_flowlet_id_update_flowlet_id_value; + bit<13> DEVNULL_flowlet_lasttime_lookup_flowlet_map; + bit<13> DEVNULL_flowlet_lasttime_lookup_flowlet_map_index; + bit<48> DEVNULL_flowlet_lasttime_lookup_flowlet_map_value; + bit<48> dmac; + bit<8> ecmp_base; + bit<8> ecmp_count; + bit<16> flowlet_id_lookup_flowlet_map; + bit<32> flowlet_lasttime_lookup_flowlet_map; + bit<13> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index; + bit<32> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_0; + bit<32> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_1; + bit<8> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_2; + bit<16> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_3; + bit<16> lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_4; + bit<32> nhop_ipv4; + bit<9> port; + bit<14> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset; + bit<32> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_0; + bit<32> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_1; + bit<8> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_2; + bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_3; + bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_4; + bit<16> set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_5; + + +// Action Definitions + action ecmp_group_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action ecmp_group_action_1(bit<8> ecmp_base,bit<8> ecmp_count){ + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_0 = hdr.ipv4.srcAddr; + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_1 = hdr.ipv4.dstAddr; + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_2 = hdr.ipv4.protocol; + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_3 = hdr.tcp.srcPort; + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_4 = hdr.tcp.dstPort; + set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset_5 = meta.ingress_metadata.flowlet_id; + + + meta.ingress_metadata.ecmp_offset = set_ecmp_select_hash_crc16_meta__ingress_metadata__ecmp_offset; + } + + action ecmp_group_action_2(){ + + } + + action ecmp_nhop_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action ecmp_nhop_action_1(bit<32> nhop_ipv4,bit<9> port){ + meta.ingress_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action ecmp_nhop_action_2(){ + + } + + action flowlet_action_0(){ + lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_0 = hdr.ipv4.srcAddr; + lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_1 = hdr.ipv4.dstAddr; + lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_2 = hdr.ipv4.protocol; + lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_3 = hdr.tcp.srcPort; + lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index_4 = hdr.tcp.dstPort; + + + meta.ingress_metadata.flowlet_map_index = lookup_flowlet_map_hash_crc16_meta__ingress_metadata__flowlet_map_index; + DEVNULL_flowlet_id_lookup_flowlet_map = meta.ingress_metadata.flowlet_map_index; + meta.ingress_metadata.flowlet_id = flowlet_id_lookup_flowlet_map; + meta.ingress_metadata.flow_ipg = meta.intrinsic_metadata.ingress_global_timestamp[31:0]; + DEVNULL_flowlet_lasttime_lookup_flowlet_map = meta.ingress_metadata.flowlet_map_index; + meta.ingress_metadata.flowlet_lasttime = flowlet_lasttime_lookup_flowlet_map; + meta.ingress_metadata.flow_ipg = (meta.ingress_metadata.flow_ipg - meta.ingress_metadata.flowlet_lasttime); + DEVNULL_flowlet_lasttime_lookup_flowlet_map_index = meta.ingress_metadata.flowlet_map_index; + DEVNULL_flowlet_lasttime_lookup_flowlet_map_value = meta.intrinsic_metadata.ingress_global_timestamp; + } + + action flowlet_action_1(){ + + } + + action forward_action_0(){ + hdr.ethernet.dstAddr = dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + action new_flowlet_action_0(){ + meta.ingress_metadata.flowlet_id = (meta.ingress_metadata.flowlet_id + 16w1); + DEVNULL_flowlet_id_update_flowlet_id_index = meta.ingress_metadata.flowlet_map_index; + DEVNULL_flowlet_id_update_flowlet_id_value = meta.ingress_metadata.flowlet_id; + } + + action new_flowlet_action_1(){ + + } + + +// Table Definitions + + table ecmp_group { + key = { + hdr.ipv4.dstAddr : ternary; + } + actions = { + ecmp_group_action_0; + ecmp_group_action_1; + ecmp_group_action_2; + } + } + + table ecmp_nhop { + key = { + meta.ingress_metadata.ecmp_offset : exact; + } + actions = { + ecmp_nhop_action_0; + ecmp_nhop_action_1; + ecmp_nhop_action_2; + } + } + + table flowlet { + key = { + } + actions = { + flowlet_action_0; + flowlet_action_1; + } + } + + table forward { + key = { + meta.ingress_metadata.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + table new_flowlet { + key = { + } + actions = { + new_flowlet_action_0; + new_flowlet_action_1; + } + } + + + apply { + +// Pipeline + + flowlet.apply(); + if (!(meta.ingress_metadata.flow_ipg > 32w50000)) {} else { + new_flowlet.apply(); + } + + ecmp_group.apply(); + ecmp_nhop.apply(); + forward.apply(); + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> smac; + + +// Action Definitions + action send_frame_action_0(bit<48> smac){ + hdr.ethernet.srcAddr = smac; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action send_frame_action_2(){ + + } + + +// Table Definitions + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + send_frame_action_2; + } + } + + + apply { + +// Pipeline + send_frame.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000063__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000063__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..968932f0067a5bfdad8363305e0e77eece72a146 --- /dev/null +++ b/individual_files/000063__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,274 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<32> srcAddr; + bit<8> protocol; + bit<32> dstAddr; +} +header tcp_t { + +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +// METADATA + + + +struct routing_metadata_t { + + bit<32> nhop_ipv4; + +} +struct my_metadata_t { + routing_metadata_t routing_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w6) : parse_tcp; + default : accept; + } + + } + + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> dmac; + bit<32> idx; + bit<9> port; + bit<32> set_nhop; + + +// Action Definitions + action count_table_action_0(bit<32> idx){ + + } + + action count_table_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action count_table_action_2(){ + + } + + action forward_action_0(bit<48> dmac){ + hdr.ethernet.dstAddr = dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + action ipv4_lpm_action_0(bit<32> set_nhop,bit<9> port){ + meta.routing_metadata.nhop_ipv4 = set_nhop; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action ipv4_lpm_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action ipv4_lpm_action_2(){ + + } + + +// Table Definitions + + table count_table { + key = { + hdr.ipv4.srcAddr : ternary; + } + actions = { + count_table_action_0; + count_table_action_1; + count_table_action_2; + } + } + + table forward { + key = { + meta.routing_metadata.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr : ternary; + } + actions = { + ipv4_lpm_action_0; + ipv4_lpm_action_1; + ipv4_lpm_action_2; + } + } + + + apply { + +// Pipeline + count_table.apply(); + ipv4_lpm.apply(); + forward.apply(); + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> smac; + + +// Action Definitions + action send_frame_action_0(bit<48> smac){ + hdr.ethernet.srcAddr = smac; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action send_frame_action_2(){ + + } + + +// Table Definitions + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + send_frame_action_2; + } + } + + + apply { + +// Pipeline + send_frame.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000064__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000064__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..c4f6e35eee669ee358402b76db76e35e6b59eba1 --- /dev/null +++ b/individual_files/000064__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,340 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<32> srcAddr; + bit<8> protocol; + bit<32> dstAddr; +} +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +// METADATA + + + +struct custom_metadata_t { + + bit<32> nhop_ipv4; + bit<16> hash_val2; + bit<16> hash_val1; + bit<16> count_val2; + bit<16> count_val1; + +} +struct my_metadata_t { + custom_metadata_t custom_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w6) : parse_tcp; + default : accept; + } + + } + + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count; + bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_index; + bit<16> DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_value; + bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count; + bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_index; + bit<16> DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_value; + bit<48> dmac; + bit<16> heavy_hitter_counter1_set_heavy_hitter_count; + bit<16> heavy_hitter_counter2_set_heavy_hitter_count; + bit<32> nhop_ipv4; + bit<9> port; + bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2; + bit<32> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_0; + bit<32> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_1; + bit<8> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_2; + bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_3; + bit<16> set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_4; + bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1; + bit<32> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_0; + bit<32> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_1; + bit<8> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_2; + bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_3; + bit<16> set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_4; + + +// Action Definitions + action drop_heavy_hitter_table_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action drop_heavy_hitter_table_action_1(){ + + } + + action forward_action_0(bit<48> dmac){ + hdr.ethernet.dstAddr = dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){ + meta.custom_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action ipv4_lpm_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action ipv4_lpm_action_2(){ + + } + + action set_heavy_hitter_count_table_action_0(){ + set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_0 = hdr.ipv4.srcAddr; + set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_1 = hdr.ipv4.dstAddr; + set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_2 = hdr.ipv4.protocol; + set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_3 = hdr.tcp.srcPort; + set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1_4 = hdr.tcp.dstPort; + + + meta.custom_metadata.hash_val1 = set_heavy_hitter_count_hash_csum16_meta__custom_metadata__hash_val1; + DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count = meta.custom_metadata.hash_val1; + meta.custom_metadata.count_val2 = heavy_hitter_counter1_set_heavy_hitter_count; + meta.custom_metadata.count_val2 = (meta.custom_metadata.count_val2 + 16w1); + DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_index = meta.custom_metadata.hash_val1; + DEVNULL_heavy_hitter_counter1_set_heavy_hitter_count_value = meta.custom_metadata.count_val2; + set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_0 = hdr.ipv4.srcAddr; + set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_1 = hdr.ipv4.dstAddr; + set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_2 = hdr.ipv4.protocol; + set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_3 = hdr.tcp.srcPort; + set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2_4 = hdr.tcp.dstPort; + + + meta.custom_metadata.hash_val2 = set_heavy_hitter_count_hash_crc16_meta__custom_metadata__hash_val2; + DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count = meta.custom_metadata.hash_val2; + meta.custom_metadata.count_val1 = heavy_hitter_counter2_set_heavy_hitter_count; + meta.custom_metadata.count_val1 = (meta.custom_metadata.count_val1 + 16w1); + DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_index = meta.custom_metadata.hash_val2; + DEVNULL_heavy_hitter_counter2_set_heavy_hitter_count_value = meta.custom_metadata.count_val1; + } + + action set_heavy_hitter_count_table_action_1(){ + + } + + +// Table Definitions + + table drop_heavy_hitter_table { + key = { + } + actions = { + drop_heavy_hitter_table_action_0; + drop_heavy_hitter_table_action_1; + } + } + + table forward { + key = { + meta.custom_metadata.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr : ternary; + } + actions = { + ipv4_lpm_action_0; + ipv4_lpm_action_1; + ipv4_lpm_action_2; + } + } + + table set_heavy_hitter_count_table { + key = { + } + actions = { + set_heavy_hitter_count_table_action_0; + set_heavy_hitter_count_table_action_1; + } + } + + + apply { + +// Pipeline + + set_heavy_hitter_count_table.apply(); + if (!((meta.custom_metadata.count_val2 > 16w100) && (meta.custom_metadata.count_val1 > 16w100))) { + ipv4_lpm.apply(); + forward.apply(); + } else { + drop_heavy_hitter_table.apply(); + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> smac; + + +// Action Definitions + action send_frame_action_0(bit<48> smac){ + hdr.ethernet.srcAddr = smac; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action send_frame_action_2(){ + + } + + +// Table Definitions + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + send_frame_action_2; + } + } + + + apply { + +// Pipeline + send_frame.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000065__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000065__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..3df628a7caa8081454710ca8dae83087c472888d --- /dev/null +++ b/individual_files/000065__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,222 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<16> etherType; +} +header ipv4_t { + bit<8> ttl; + bit<8> protocol; + bit<32> dstAddr; +} +header udp_t { + +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + udp_t udp; +} + + + +// METADATA + + + +struct intrinsic_metadata_t { + + bit<16> mcast_grp; + bit<16> egress_rid; + +} +struct my_metadata_t { + intrinsic_metadata_t intrinsic_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w17) : parse_udp; + default : accept; + } + + } + + + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<16> mcast_group; + + +// Action Definitions + action set_mcg_action_0(bit<16> mcast_group){ + meta.intrinsic_metadata.mcast_grp = mcast_group; + } + + action set_mcg_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action set_mcg_action_2(){ + + } + + +// Table Definitions + + table set_mcg { + key = { + hdr.ipv4.dstAddr : exact; + } + actions = { + set_mcg_action_0; + set_mcg_action_1; + set_mcg_action_2; + } + } + + + apply { + +// Pipeline + + set_mcg.apply(); + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<32> dst_ip; + + +// Action Definitions + action nat_table_action_0(bit<32> dst_ip){ + hdr.ipv4.dstAddr = dst_ip; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action nat_table_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action nat_table_action_2(){ + + } + + +// Table Definitions + + table nat_table { + key = { + meta.intrinsic_metadata.egress_rid : exact; + hdr.ipv4.dstAddr : exact; + } + actions = { + nat_table_action_0; + nat_table_action_1; + nat_table_action_2; + } + } + + + apply { + +// Pipeline + nat_table.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000066__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000066__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8fcc3e24693c22f5f026c52203d8ddd0ab4c271a --- /dev/null +++ b/individual_files/000066__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,387 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<16> totalLen; + bit<8> protocol; + bit<32> dstAddr; +} +header ndp_t { + bit<16> flags; +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + ndp_t ndp; +} + + + +// METADATA + + + +struct meta_t { + + bit<16> register_tmp; + bit<16> ndpflags; + +} + +struct routing_metadata_t { + + bit<32> nhop_ipv4; + +} +struct my_metadata_t { + meta_t meta; + routing_metadata_t routing_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w199) : parse_ndp; + default : accept; + } + + } + + + state parse_ndp { + packet.extract(hdr.ndp); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<9> DEVNULL_buffersense_readbuffer; + bit<9> DEVNULL_buffersense_set_dmac; + bit<9> DEVNULL_buffersense_setpriolow; + bit<9> DEVNULL_buffersense_setpriolow_index; + bit<16> DEVNULL_buffersense_setpriolow_value; + bit<16> buffersense_readbuffer; + bit<16> buffersense_set_dmac; + bit<16> buffersense_setpriolow; + bit<48> dmac; + bit<32> nhop_ipv4; + bit<9> port; + + +// Action Definitions + action directtoprio_action_0(){ + standard_metadata.egress_spec = 9w1; + meta.meta.ndpflags = hdr.ndp.flags; + } + + action directtoprio_action_1(){ + + } + + action forward_action_0(bit<48> dmac){ + hdr.ethernet.dstAddr = dmac; + DEVNULL_buffersense_set_dmac = standard_metadata.egress_port; + meta.meta.register_tmp = buffersense_set_dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){ + meta.routing_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_port = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl + 8w255); + } + + action ipv4_lpm_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action ipv4_lpm_action_2(){ + + } + + action readbuffersense_action_0(){ + DEVNULL_buffersense_readbuffer = standard_metadata.egress_port; + meta.meta.register_tmp = buffersense_readbuffer; + } + + action readbuffersense_action_1(){ + + } + + action setprio_action_0(){ + standard_metadata.egress_spec = 9w0; + DEVNULL_buffersense_setpriolow = standard_metadata.egress_port; + meta.meta.register_tmp = buffersense_setpriolow; + DEVNULL_buffersense_setpriolow_index = standard_metadata.egress_port; + DEVNULL_buffersense_setpriolow_value = (meta.meta.register_tmp + 16w1); + } + + action setprio_action_1(){ + hdr.ipv4.totalLen = 16w20; + standard_metadata.egress_spec = 9w1; + } + + action setprio_action_2(){ + + } + + +// Table Definitions + + table directtoprio { + key = { + meta.meta.register_tmp : exact; + } + actions = { + directtoprio_action_0; + directtoprio_action_1; + } + } + + table forward { + key = { + meta.routing_metadata.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr : ternary; + } + actions = { + ipv4_lpm_action_0; + ipv4_lpm_action_1; + ipv4_lpm_action_2; + } + } + + table readbuffersense { + key = { + meta.meta.register_tmp : exact; + } + actions = { + readbuffersense_action_0; + readbuffersense_action_1; + } + } + + table setprio { + key = { + meta.meta.register_tmp : exact; + } + actions = { + setprio_action_0; + setprio_action_1; + setprio_action_2; + } + } + + + apply { + +// Pipeline + if (!(1w1 == (hdr.ipv4.isValid() ? 1w1 : 1w0))) { + standard_metadata.egress_spec = 9w511; + } else { + if (!(hdr.ipv4.ttl > 8w0)) { + standard_metadata.egress_spec = 9w511; + } else { + ipv4_lpm.apply(); + if (!(1w1 == (hdr.ndp.isValid() ? 1w1 : 1w0))) { + readbuffersense.apply(); + setprio.apply(); + } else { + if (!(hdr.ndp.flags > 16w1)) { + readbuffersense.apply(); + setprio.apply(); + } else { + directtoprio.apply(); + } + + } + + forward.apply(); + } + + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<9> DEVNULL_buffersense_decreasereg; + bit<9> DEVNULL_buffersense_decreasereg_index; + bit<16> DEVNULL_buffersense_decreasereg_value; + bit<16> buffersense_decreasereg; + bit<48> smac; + + +// Action Definitions + action dec_counter_action_0(){ + DEVNULL_buffersense_decreasereg = standard_metadata.egress_port; + meta.meta.register_tmp = buffersense_decreasereg; + DEVNULL_buffersense_decreasereg_index = standard_metadata.egress_port; + DEVNULL_buffersense_decreasereg_value = ((meta.meta.register_tmp - 16w1) + (7w0 ++ standard_metadata.egress_spec)); + } + + action dec_counter_action_1(){ + + } + + action dec_counter_action_2(){ + + } + + action send_frame_action_0(bit<48> smac){ + hdr.ethernet.srcAddr = smac; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action send_frame_action_2(){ + + } + + +// Table Definitions + + table dec_counter { + key = { + meta.meta.ndpflags : exact; + } + actions = { + dec_counter_action_0; + dec_counter_action_1; + dec_counter_action_2; + } + } + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + send_frame_action_2; + } + } + + + apply { + +// Pipeline + dec_counter.apply(); + send_frame.apply(); + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000067__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000067__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..502157c96fd98ea4bf93a73c9c3ef22d39ccc4b3 --- /dev/null +++ b/individual_files/000067__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,323 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<16> etherType; +} +header ipv4_t { + bit<8> protocol; +} +header paxos_t { + bit<16> vproposal; + bit<32> val; + bit<16> proposal; + bit<16> msgtype; + bit<32> inst; + bit<16> acpt; +} +header udp_t { + bit<16> dstPort; + bit<16> checksum; +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + paxos_t paxos; + udp_t udp; +} + + + +// METADATA + + + +struct local_metadata_t { + + bit<16> proposal; + +} +struct my_metadata_t { + local_metadata_t local_metadata; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w17) : parse_udp; + default : accept; + } + + } + + + state parse_paxos { + packet.extract(hdr.paxos); + transition accept; + } + + + state parse_udp { + packet.extract(hdr.udp); + transition select(hdr.udp.dstPort){ + (16w34952) : parse_paxos; + default : accept; + } + + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<32> DEVNULL_acceptor_id; + bit<32> DEVNULL_acceptor_id_1a; + bit<32> DEVNULL_proposal_register_1a_index; + bit<16> DEVNULL_proposal_register_1a_value; + bit<32> DEVNULL_proposal_register_2a_index; + bit<16> DEVNULL_proposal_register_2a_value; + bit<32> DEVNULL_proposal_register_read_round; + bit<32> DEVNULL_val_register_1a; + bit<32> DEVNULL_val_register_index; + bit<32> DEVNULL_val_register_value; + bit<32> DEVNULL_vproposal_register_1a; + bit<32> DEVNULL_vproposal_register_2a_index; + bit<16> DEVNULL_vproposal_register_2a_value; + bit<16> acceptor_id; + bit<16> acceptor_id_1a; + bit<9> port; + bit<16> proposal_register_read_round; + bit<32> val_register_1a; + bit<16> vproposal_register_1a; + + +// Action Definitions + action drop_tbl_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action drop_tbl_action_1(){ + + } + + action fwd_tbl_action_0(bit<9> port){ + standard_metadata.egress_spec = port; + } + + action fwd_tbl_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action fwd_tbl_action_2(){ + + } + + action paxos_tbl_action_0(){ + DEVNULL_proposal_register_1a_index = hdr.paxos.inst; + DEVNULL_proposal_register_1a_value = hdr.paxos.proposal; + DEVNULL_vproposal_register_1a = hdr.paxos.inst; + hdr.paxos.vproposal = vproposal_register_1a; + DEVNULL_val_register_1a = hdr.paxos.inst; + hdr.paxos.val = val_register_1a; + DEVNULL_acceptor_id_1a = 32w0; + hdr.paxos.acpt = acceptor_id_1a; + hdr.udp.checksum = 16w0; + } + + action paxos_tbl_action_1(){ + DEVNULL_proposal_register_2a_index = hdr.paxos.inst; + DEVNULL_proposal_register_2a_value = hdr.paxos.proposal; + DEVNULL_vproposal_register_2a_index = hdr.paxos.inst; + DEVNULL_vproposal_register_2a_value = hdr.paxos.proposal; + DEVNULL_val_register_index = hdr.paxos.inst; + DEVNULL_val_register_value = hdr.paxos.val; + hdr.paxos.msgtype = 16w4; + hdr.paxos.vproposal = hdr.paxos.proposal; + DEVNULL_acceptor_id = 32w0; + hdr.paxos.acpt = acceptor_id; + hdr.udp.checksum = 16w0; + } + + action paxos_tbl_action_2(){ + + } + + action round_tbl_action_0(){ + DEVNULL_proposal_register_read_round = hdr.paxos.inst; + meta.local_metadata.proposal = proposal_register_read_round; + } + + action round_tbl_action_1(){ + + } + + +// Table Definitions + + table drop_tbl { + key = { + } + actions = { + drop_tbl_action_0; + drop_tbl_action_1; + } + } + + table fwd_tbl { + key = { + standard_metadata.ingress_port : exact; + } + actions = { + fwd_tbl_action_0; + fwd_tbl_action_1; + fwd_tbl_action_2; + } + } + + table paxos_tbl { + key = { + hdr.paxos.msgtype : exact; + } + actions = { + paxos_tbl_action_0; + paxos_tbl_action_1; + paxos_tbl_action_2; + } + } + + table round_tbl { + key = { + } + actions = { + round_tbl_action_0; + round_tbl_action_1; + } + } + + + apply { + +// Pipeline + if (!((hdr.ipv4.isValid() ? 1w1 : 1w0) == 1w1)) { + if (!((hdr.paxos.isValid() ? 1w1 : 1w0) == 1w1)) { + standard_metadata.egress_spec = 9w511; + } else { + round_tbl.apply(); + if (!(meta.local_metadata.proposal <= hdr.paxos.proposal)) { + drop_tbl.apply(); + } else { + paxos_tbl.apply(); + } + + } + + } else { + fwd_tbl.apply(); + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Action Definitions + + +// Table Definitions + + + apply { + +// Pipeline + + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000068__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000068__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..c807ef5feb98e4fde3c0f831703cc9d347011349 --- /dev/null +++ b/individual_files/000068__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,180 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; +} + + + +// METADATA + + + +struct mymeta_t { + + bit<8> f2; + bit<8> f1; + +} +struct my_metadata_t { + mymeta_t mymeta; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<9> port; + + +// Action Definitions + action t_ingress_1_action_0(){ + + } + + action t_ingress_1_action_1(){ + standard_metadata.egress_spec = port; + } + + action t_ingress_2_action_0(){ + + } + + action t_ingress_2_action_1(){ + meta.mymeta.f1 = 8w1; + } + + +// Table Definitions + + table t_ingress_1 { + key = { + meta.mymeta.f1 : exact; + } + actions = { + t_ingress_1_action_0; + t_ingress_1_action_1; + } + } + + table t_ingress_2 { + key = { + meta.mymeta.f2 : exact; + } + actions = { + t_ingress_2_action_0; + t_ingress_2_action_1; + } + } + + + apply { + +// Pipeline + t_ingress_1.apply(); + t_ingress_2.apply(); + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Action Definitions + + +// Table Definitions + + + apply { + +// Pipeline + + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000069__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000069__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9af61dc92aaf784e9207e240bb853e31541a83b8 --- /dev/null +++ b/individual_files/000069__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,392 @@ +#include +#include + +// HEADERS + + +// Define header types + +header cpu_header_t { + bit<8> reason; + bit<64> preamble; + bit<8> if_index; + bit<8> device; +} +header ethernet_t { + bit<48> srcAddr; + bit<16> etherType; + bit<48> dstAddr; +} +header ipv4_t { + bit<8> ttl; + bit<16> totalLen; + bit<32> srcAddr; + bit<8> protocol; + bit<32> dstAddr; +} +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; +} + +// Assemble headers in a single struct +struct my_headers_t { + cpu_header_t cpu_header; + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + + +// METADATA + + + +struct meta_t { + + bit<16> tcp_sp; + bit<16> tcp_dp; + bit<16> tcpLength; + bit<32> nhop_ipv4; + bit<1> is_ext_if; + bit<32> ipv4_sa; + bit<32> ipv4_da; + bit<48> if_mac_addr; + bit<32> if_ipv4_addr; + bit<8> if_index; + bit<1> do_forward; + +} +struct my_metadata_t { + meta_t meta; + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + meta.meta.ipv4_sa = hdr.ipv4.srcAddr; + meta.meta.ipv4_da = hdr.ipv4.dstAddr; + meta.meta.tcpLength = (hdr.ipv4.totalLen - 16w20); + transition select(hdr.ipv4.protocol){ + (8w6) : parse_tcp; + default : accept; + } + + } + + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> dmac; + bit<32> dstAddr; + bit<16> dstPort; + bit<32> ipv4_addr; + bit<1> is_ext; + bit<48> mac_addr; + bit<32> nhop_ipv4; + bit<9> port; + + +// Action Definitions + action forward_action_0(bit<48> dmac){ + hdr.ethernet.dstAddr = dmac; + } + + action forward_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action forward_action_2(){ + + } + + action if_info_action_0(bit<32> ipv4_addr,bit<48> mac_addr,bit<1> is_ext){ + meta.meta.if_ipv4_addr = ipv4_addr; + meta.meta.if_mac_addr = mac_addr; + meta.meta.is_ext_if = is_ext; + } + + action if_info_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action if_info_action_2(){ + + } + + action ipv4_lpm_action_0(bit<32> nhop_ipv4,bit<9> port){ + meta.meta.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = (hdr.ipv4.ttl - 8w1); + } + + action ipv4_lpm_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action ipv4_lpm_action_2(){ + + } + + action nat_action_0(){ + standard_metadata.egress_spec = 9w511; + } + + action nat_action_1(){ + + } + + action nat_action_2(){ + meta.meta.do_forward = 1w0; + standard_metadata.egress_spec = 9w511; + } + + action nat_action_3(){ + + } + + action nat_action_4(bit<32> dstAddr,bit<16> dstPort){ + meta.meta.do_forward = 1w1; + meta.meta.ipv4_da = dstAddr; + meta.meta.tcp_dp = dstPort; + } + + action nat_action_5(){ + meta.meta.do_forward = 1w1; + } + + action nat_action_6(){ + + } + + +// Table Definitions + + table forward { + key = { + meta.meta.nhop_ipv4 : exact; + } + actions = { + forward_action_0; + forward_action_1; + forward_action_2; + } + } + + table if_info { + key = { + meta.meta.if_index : exact; + } + actions = { + if_info_action_0; + if_info_action_1; + if_info_action_2; + } + } + + table ipv4_lpm { + key = { + meta.meta.ipv4_da : exact; + } + actions = { + ipv4_lpm_action_0; + ipv4_lpm_action_1; + ipv4_lpm_action_2; + } + } + + table nat { + key = { + meta.meta.is_ext_if : exact; + hdr.ipv4.isValid() : exact; + hdr.tcp.isValid() : exact; + hdr.ipv4.srcAddr : ternary; + hdr.ipv4.dstAddr : ternary; + hdr.tcp.srcPort : ternary; + hdr.tcp.dstPort : ternary; + } + actions = { + nat_action_0; + nat_action_1; + nat_action_2; + nat_action_3; + nat_action_4; + nat_action_5; + nat_action_6; + } + } + + + apply { + +// Pipeline + if_info.apply(); + nat.apply(); + if (!(meta.meta.do_forward == 1w1)) {} else { + if ((hdr.ipv4.ttl == 8w0)) {} else { + ipv4_lpm.apply(); + forward.apply(); + } + + } + + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<48> smac; + + +// Action Definitions + action send_frame_action_0(bit<48> smac){ + hdr.cpu_header.setInvalid(); + hdr.ethernet.srcAddr = smac; + hdr.ipv4.srcAddr = meta.meta.ipv4_sa; + hdr.ipv4.dstAddr = meta.meta.ipv4_da; + hdr.tcp.srcPort = meta.meta.tcp_sp; + hdr.tcp.dstPort = meta.meta.tcp_dp; + } + + action send_frame_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action send_frame_action_2(){ + + } + + action send_to_cpu_action_0(){ + hdr.cpu_header.setValid(); + hdr.cpu_header.preamble = 64w0; + hdr.cpu_header.device = 8w0; + hdr.cpu_header.reason = 8w171; + hdr.cpu_header.if_index = meta.meta.if_index; + } + + action send_to_cpu_action_1(){ + + } + + +// Table Definitions + + table send_frame { + key = { + standard_metadata.egress_port : exact; + } + actions = { + send_frame_action_0; + send_frame_action_1; + send_frame_action_2; + } + } + + table send_to_cpu { + key = { + } + actions = { + send_to_cpu_action_0; + send_to_cpu_action_1; + } + } + + + apply { + +// Pipeline + if (!(standard_metadata.instance_type == 32w0)) { + send_to_cpu.apply(); + } else { + send_frame.apply(); + } + + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000070__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000070__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..f19d7da1db1de22bfa6f19d5b92c092c3d4c0855 --- /dev/null +++ b/individual_files/000070__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,200 @@ +#include +#include + +// HEADERS + + +// Define header types + +header ethernet_t { + bit<16> etherType; +} +header ipv4_t { + bit<8> protocol; + bit<32> dstAddr; +} +header rtp_t { + bit<32> timestamp; +} +header udp_t { + +} + +// Assemble headers in a single struct +struct my_headers_t { + ethernet_t ethernet; + ipv4_t ipv4; + rtp_t rtp; + udp_t udp; +} + + + +// METADATA + + +struct my_metadata_t { + + +} + +// PARSER + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Parser state machine + + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType){ + (16w2048) : parse_ipv4; + default : accept; + } + + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + (8w17) : parse_udp; + default : accept; + } + + } + + + state parse_rtp { + packet.extract(hdr.rtp); + transition accept; + } + + + state parse_udp { + packet.extract(hdr.udp); + transition parse_rtp; + } + + + state start { + + transition parse_ethernet; + } + +} + + +// INGRESS + +control MyIngress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + bit<32> dst_ip; + + +// Action Definitions + action schedule_table_action_0(){ + standard_metadata.egress_spec = 9w1; + hdr.ipv4.dstAddr = dst_ip; + } + + action schedule_table_action_1(){ + standard_metadata.egress_spec = 9w511; + } + + action schedule_table_action_2(){ + + } + + +// Table Definitions + + table schedule_table { + key = { + hdr.ipv4.dstAddr : exact; + hdr.rtp.timestamp : ternary; + } + actions = { + schedule_table_action_0; + schedule_table_action_1; + schedule_table_action_2; + } + } + + + apply { + +// Pipeline + + schedule_table.apply(); + } +} + + +// EGRESS + +control MyEgress ( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + +// Variable Definitions + + +// Action Definitions + + +// Table Definitions + + + apply { + +// Pipeline + + } +} + + +// OTHER +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + } +} +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000071__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000071__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8f3856247e7f348f0aba560057eaa3aa2d3fb8c4 --- /dev/null +++ b/individual_files/000071__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,213 @@ +#include +#include + +struct custom_metadata_t { + bit<32> nhop_ipv4; + bit<16> hash_val1; + bit<16> hash_val2; + bit<16> count_val1; + bit<16> count_val2; +} + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +struct metadata { + custom_metadata_t custom_metadata; +} + +struct headers { + + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x800: parse_ipv4; + default: accept; + } + } + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 8w6: parse_tcp; + default: accept; + } + } + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + state start { + transition parse_ethernet; + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + action rewrite_mac(bit<48> smac) { + hdr.ethernet.srcAddr = smac; + } + action _drop() { + mark_to_drop(standard_metadata); + } + table send_frame { + actions = { + rewrite_mac; + _drop; + } + key = { + standard_metadata.egress_port: exact; + } + size = 256; + } + apply { + send_frame.apply(); + } +} + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + register>(32w16) heavy_hitter_counter1; + register>(32w16) heavy_hitter_counter2; + + action _drop() { + mark_to_drop(standard_metadata); + } + + action set_dmac(bit<48> dmac) { + hdr.ethernet.dstAddr = dmac; + } + + action set_nhop(bit<32> nhop_ipv4, bit<9> port) { + meta.custom_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_spec = port; + hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255; + } + action set_heavy_hitter_count() { + +// Count the hash 1 for indexing + hash(meta.custom_metadata.hash_val1, HashAlgorithm.csum16, (bit<16>)0, { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.ipv4.protocol, hdr.tcp.srcPort, hdr.tcp.dstPort }, (bit<32>)16); + +// Read the value in the register with that index + heavy_hitter_counter1.read(meta.custom_metadata.count_val1, (bit<32>)meta.custom_metadata.hash_val1); + +// Incremet the value with 1 + meta.custom_metadata.count_val1 = meta.custom_metadata.count_val1 + 16w1; + +// Write the value back to the register with that index + heavy_hitter_counter1.write((bit<32>)meta.custom_metadata.hash_val1, (bit<16>)meta.custom_metadata.count_val1); + +// Count the hash 2 for another indexing, similar to the first hash + hash(meta.custom_metadata.hash_val2, HashAlgorithm.crc16, (bit<16>)0, { hdr.ipv4.srcAddr, hdr.ipv4.dstAddr, hdr.ipv4.protocol, hdr.tcp.srcPort, hdr.tcp.dstPort }, (bit<32>)16); + heavy_hitter_counter2.read(meta.custom_metadata.count_val2, (bit<32>)meta.custom_metadata.hash_val2); + meta.custom_metadata.count_val2 = meta.custom_metadata.count_val2 + 16w1; + heavy_hitter_counter2.write((bit<32>)meta.custom_metadata.hash_val2, (bit<16>)meta.custom_metadata.count_val2); + } + + table drop_heavy_hitter_table { + actions = { + _drop; + } + size = 1; + } + + table forward { + actions = { + set_dmac; + _drop; + } + key = { + meta.custom_metadata.nhop_ipv4: exact; + } + size = 512; + } + + table ipv4_lpm { + actions = { + set_nhop; + +// Set next hop + _drop; + } + key = { + hdr.ipv4.dstAddr: lpm; + } + size = 1024; + } + + table set_heavy_hitter_count_table { + actions = { + set_heavy_hitter_count; + } + size = 1; + } + + apply { + set_heavy_hitter_count_table.apply(); + + if (meta.custom_metadata.count_val1 > 16w100 && meta.custom_metadata.count_val2 > 16w100) { + drop_heavy_hitter_table.apply(); + } + else { + ipv4_lpm.apply(); + forward.apply(); + } + } +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply { + verify_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000072__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000072__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..2752b0d5a6a0453aad09679ed4280c55b72efc27 --- /dev/null +++ b/individual_files/000072__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,177 @@ +#include +#define V1MODEL_VERSION 20200408 +#include + +struct ghost_t { + bit<1> assign; + bit<1> alloc; + bit<1> deref; +} + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header icmp_t { + bit<16> typeCode; + bit<16> hdrChecksum; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +header ipv6_t { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + bit<128> srcAddr; + bit<128> dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +header vlan_tag_t { + bit<3> pcp; + bit<1> cfi; + bit<12> vid; + bit<16> etherType; +} + +struct metadata { + bit<16> ptr; + ghost_t spec; +} + +struct headers { + ethernet_t ethernet; + icmp_t icmp; + ipv4_t ipv4; + ipv6_t ipv6; + tcp_t tcp; + udp_t udp; + vlan_tag_t vlan_tag; +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".start") state start { + packet.extract(hdr.ethernet); + transition accept; + } +} + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + action alloc () { + meta.spec.alloc = 1w1; + } + action unalloc () { + meta.spec.alloc = 1w0; + } + action drop_ () { + mark_to_drop(standard_metadata); + } + action fwd (bit<9> port) { + standard_metadata.egress_spec = port; + meta.spec.deref = 1w1; + } + action assign_(bit<16> ptr){ + meta.ptr = ptr; + meta.spec.assign = 1w1; + } + table assign { + key = { + hdr.ethernet.dstAddr : exact; + } + actions = { + assign_; + drop_; + } + } + table allocator { + key = { + meta.ptr : exact; + } + actions = { + alloc; + @defaultonly unalloc; + } + const default_action = unalloc; + } + table deref { + key = { + meta.ptr : exact; + } + actions = { + fwd; + @defaultonly drop_; + } + const default_action = drop_; + } + + apply { + meta.spec.assign = 1w0; + meta.spec.alloc = 1w0; + meta.spec.deref = 1w0; + + assign.apply(); + allocator.apply(); + deref.apply(); + assert(meta.spec.assign == 1w0 || meta.spec.alloc == 1w1); + assert(meta.spec.deref == 1w0 || meta.spec.alloc == 1w1); + standard_metadata.egress_spec = 9w511; + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + apply {} +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply {} +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply {} +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000073__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000073__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8e482bd5fda3a142c337c434c9df280f18ec473a --- /dev/null +++ b/individual_files/000073__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,279 @@ + +#include +#include + + + + +/* Define the headers the program will recognize */ + + +typedef bit<48> mac_addr_t; +typedef bit<32> ipv4_addr_t; +typedef bit<9> port_id_t; + +header ethernet_t { + mac_addr_t dstAddr; + mac_addr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ipv4_addr_t srcAddr; + ipv4_addr_t dstAddr; +} + + + +header arp_t { + bit<16> htype; + bit<16> ptype; + bit<8> hlen; + bit<8> plen; + bit<16> oper; +} + +header arp_ipv4_t { + mac_addr_t sha; + ipv4_addr_t spa; + mac_addr_t tha; + ipv4_addr_t tpa; +} + + + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + + +/* Assemble headers in a single struct */ +struct my_headers_t { + ethernet_t ethernet; + arp_t arp; + arp_ipv4_t arp_ipv4; + ipv4_t ipv4; + icmp_t icmp; +} + + +/* Define the global metadata for your program */ + +struct my_metadata_t { + ipv4_addr_t dst_ipv4; + mac_addr_t mac_da; + mac_addr_t mac_sa; + port_id_t egress_port; + mac_addr_t my_mac; +} + + +parser MyParser( + packet_in packet, + out my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x0800 : parse_ipv4; + 16w0x0806 : parse_arp; + default : accept; + } + } + + state parse_arp { + packet.extract(hdr.arp); + transition select(hdr.arp.htype, hdr.arp.ptype, + hdr.arp.hlen, hdr.arp.plen) { + (16w0x0001, 16w0x0800, + 8w6, 8w4) : parse_arp_ipv4; + default : accept; + } + } + + state parse_arp_ipv4 { + packet.extract(hdr.arp_ipv4); + meta.dst_ipv4 = hdr.arp_ipv4.tpa; + transition accept; + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + meta.dst_ipv4 = hdr.ipv4.dstAddr; + transition select(hdr.ipv4.protocol) { + 8w0x01 : parse_icmp; + default : accept; + } + } + + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } +} + + +control MyVerifyChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + + +control MyIngress( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) +{ + action drop() { + mark_to_drop(standard_metadata); + exit; + } + + action set_dst_info(mac_addr_t mac_da, + mac_addr_t mac_sa, + port_id_t egress_port) + { + meta.mac_da = mac_da; + meta.mac_sa = mac_sa; + meta.egress_port = egress_port; + } + + table ipv4_lpm { + key = { meta.dst_ipv4 : lpm; } + actions = { set_dst_info; drop; } + default_action = drop(); + } + + action forward_ipv4() { + hdr.ethernet.dstAddr = meta.mac_da; + hdr.ethernet.srcAddr = meta.mac_sa; + hdr.ipv4.ttl = hdr.ipv4.ttl - 8w1; + + standard_metadata.egress_spec = meta.egress_port; + } + + action send_arp_reply() { + hdr.ethernet.dstAddr = hdr.arp_ipv4.sha; + hdr.ethernet.srcAddr = meta.mac_da; + + hdr.arp.oper = 16w2; + + hdr.arp_ipv4.tha = hdr.arp_ipv4.sha; + hdr.arp_ipv4.tpa = hdr.arp_ipv4.spa; + hdr.arp_ipv4.sha = meta.mac_da; + hdr.arp_ipv4.spa = meta.dst_ipv4; + + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + action send_icmp_reply() { + mac_addr_t tmp_mac; + ipv4_addr_t tmp_ip; + + tmp_mac = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = hdr.ethernet.srcAddr; + hdr.ethernet.srcAddr = tmp_mac; + + tmp_ip = hdr.ipv4.dstAddr; + hdr.ipv4.dstAddr = hdr.ipv4.srcAddr; + hdr.ipv4.srcAddr = tmp_ip; + + hdr.icmp.type = 8w0; + hdr.icmp.checksum = 16w0; + +// For now + + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + table forward { + key = { + hdr.arp.isValid() : exact; + hdr.arp.oper : ternary; + hdr.arp_ipv4.isValid() : exact; + hdr.ipv4.isValid() : exact; + hdr.icmp.isValid() : exact; + hdr.icmp.type : ternary; + } + actions = { + forward_ipv4; + send_arp_reply; + send_icmp_reply; + drop; + } + const default_action = drop(); + const entries = { + ( true, 16w1, true, false, false, _ ) : + send_arp_reply(); + ( false, _, false, true, false, _ ) : + forward_ipv4(); + ( false, _, false, true, true, 8w8 ) : + send_icmp_reply(); + } + } + + apply { + meta.my_mac = 48w0x000102030405; + ipv4_lpm.apply(); + forward.apply(); + } +} + + +control MyEgress( + inout my_headers_t hdr, + inout my_metadata_t meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + +control MyComputeChecksum( + inout my_headers_t hdr, + inout my_metadata_t meta) +{ + apply { } +} + + +control MyDeparser( + packet_out packet, + in my_headers_t hdr) +{ + apply { + packet.emit(hdr.ethernet); + +/* ARP Case */ + packet.emit(hdr.arp); + packet.emit(hdr.arp_ipv4); + +/* IPv4 case */ + packet.emit(hdr.ipv4); + packet.emit(hdr.icmp); + } +} + +V1Switch( + MyParser(), + MyVerifyChecksum(), + MyIngress(), + MyEgress(), + MyComputeChecksum(), + MyDeparser() +) main; diff --git a/individual_files/000074__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000074__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..4165a720545590dd2c9fd1ec73823e35c080f1e0 --- /dev/null +++ b/individual_files/000074__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,246 @@ +#include +#include + + + +struct meta_t { + bit<16> register_tmp; + bit<16> ndpflags; +} + +struct routing_metadata_t { + bit<32> nhop_ipv4; +} + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +header ndp_t { + bit<16> flags; + bit<16> checksum; + bit<32> sport; + bit<32> dport; + bit<32> seqpull; + bit<32> pacerecho; +} + +struct metadata { + @name(".meta") + meta_t meta; + @name(".routing_metadata") + routing_metadata_t routing_metadata; +} + +struct headers { + @name(".ethernet") + ethernet_t ethernet; + @name(".ipv4") + ipv4_t ipv4; + @name(".ndp") + ndp_t ndp; +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".parse_ethernet") state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x800: parse_ipv4; + default: accept; + } + } + @name(".parse_ipv4") state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 8w199: parse_ndp; + default: accept; + } + } + @name(".parse_ndp") state parse_ndp { + packet.extract(hdr.ndp); + transition accept; + } + @name(".start") state start { + transition parse_ethernet; + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".buffersense") register>(32w4) buffersense; + @name(".decreasereg") action decreasereg() { + buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port); + buffersense.write((bit<32>)standard_metadata.egress_port, (bit<16>)(meta.meta.register_tmp - 16w1 + (bit<16>)standard_metadata.egress_spec)); + } + @name(".cont") action cont() { + } + @name(".rewrite_mac") action rewrite_mac(bit<48> smac) { + hdr.ethernet.srcAddr = smac; + } + @name("._drop") action _drop() { + mark_to_drop(standard_metadata); + } + @name(".dec_counter") table dec_counter { + actions = { + decreasereg; + cont; + } + key = { + meta.meta.ndpflags: ternary; + } + size = 2; + } + @name(".send_frame") table send_frame { + actions = { + rewrite_mac; + _drop; + } + key = { + standard_metadata.egress_port: exact; + } + size = 256; + } + apply { + dec_counter.apply(); + send_frame.apply(); + } +} + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".buffersense") register>(32w4) buffersense; + @name(".directpriohigh") action directpriohigh() { + standard_metadata.egress_spec = 9w1; + meta.meta.ndpflags = hdr.ndp.flags; + } + @name(".set_dmac") action set_dmac(bit<48> dmac) { + hdr.ethernet.dstAddr = dmac; + buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port); + } + @name("._drop") action _drop() { + mark_to_drop(standard_metadata); + } + @name(".set_nhop") action set_nhop(bit<32> nhop_ipv4, bit<9> port) { + meta.routing_metadata.nhop_ipv4 = nhop_ipv4; + standard_metadata.egress_port = port; + hdr.ipv4.ttl = hdr.ipv4.ttl + 8w255; + } + @name(".readbuffer") action readbuffer() { + buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port); + } + @name(".setpriolow") action setpriolow() { + standard_metadata.egress_spec = 9w0; + buffersense.read(meta.meta.register_tmp, (bit<32>)standard_metadata.egress_port); + buffersense.write((bit<32>)standard_metadata.egress_port, (bit<16>)(meta.meta.register_tmp + 16w1)); + } + @name(".setpriohigh") action setpriohigh() { + truncate((bit<32>)32w54); + hdr.ipv4.totalLen = 16w20; + standard_metadata.egress_spec = 9w1; + } + @name(".directtoprio") table directtoprio { + actions = { + directpriohigh; + } + key = { + meta.meta.register_tmp: ternary; + } + size = 2; + } + @name(".forward") table forward { + actions = { + set_dmac; + _drop; + } + key = { + meta.routing_metadata.nhop_ipv4: exact; + } + size = 512; + } + @name(".ipv4_lpm") table ipv4_lpm { + actions = { + set_nhop; + _drop; + } + key = { + hdr.ipv4.dstAddr: lpm; + } + size = 1024; + } + @name(".readbuffersense") table readbuffersense { + actions = { + readbuffer; + } + key = { + meta.meta.register_tmp: ternary; + } + size = 2; + } + @name(".setprio") table setprio { + actions = { + setpriolow; + setpriohigh; + } + key = { + meta.meta.register_tmp: ternary; + } + size = 2; + } + apply { + if (hdr.ipv4.isValid()) { + if (hdr.ipv4.ttl > 8w0) { + ipv4_lpm.apply(); + if (hdr.ndp.isValid()) { + if (hdr.ndp.flags > 16w1) { + directtoprio.apply(); + } else { + readbuffersense.apply(); + setprio.apply(); + } + } + else { + readbuffersense.apply(); + setprio.apply(); + } + forward.apply(); + } + } + } +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.ndp); + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply { + verify_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum(true, { hdr.ipv4.version, hdr.ipv4.ihl, hdr.ipv4.diffserv, hdr.ipv4.totalLen, hdr.ipv4.identification, hdr.ipv4.flags, hdr.ipv4.fragOffset, hdr.ipv4.ttl, hdr.ipv4.protocol, hdr.ipv4.srcAddr, hdr.ipv4.dstAddr }, hdr.ipv4.hdrChecksum, HashAlgorithm.csum16); + } +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000075__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000075__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..7426b0f25705f694a9f0d61fec57ba6b2493fa19 --- /dev/null +++ b/individual_files/000075__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,98 @@ +#include +#include + +struct intrinsic_metadata_t { + bit<4> mcast_grp; + bit<4> egress_rid; + bit<32> lf_field_list; + bit<16> resubmit_flag; +} + +struct mymeta_t { + bit<8> f1; +} + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +struct metadata { + @name(".mymeta") + mymeta_t mymeta; +} + +struct headers { + @name(".ethernet") + ethernet_t ethernet; +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".parse_ethernet") state parse_ethernet { + packet.extract(hdr.ethernet); + transition accept; + } + @name(".start") state start { + transition parse_ethernet; + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + apply { + } +} + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name("._nop") action _nop() { + } + @name(".set_port") action set_port(bit<9> port) { + standard_metadata.egress_spec = port; + } + @name("._resubmit") action _resubmit() { + meta.mymeta.f1 = 8w1; + + } + @name(".t_ingress_1") table t_ingress_1 { + actions = { + _nop; + set_port; + } + key = { + meta.mymeta.f1: exact; + } + size = 128; + } + @name(".t_ingress_2") table t_ingress_2 { + actions = { + _nop; + _resubmit; + } + key = { + meta.mymeta.f1: exact; + } + size = 128; + } + apply { + t_ingress_1.apply(); + t_ingress_2.apply(); + } +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000076__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000076__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..0f6a3918209cd77e58e99d8a6399239f39fc7153 --- /dev/null +++ b/individual_files/000076__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,122 @@ +#include +#define V1MODEL_VERSION 20200408 +#include + +struct ingress_metadata_t { +} + +header h_t { + bit<16> value; +} + +struct metadata { + ingress_metadata_t ing_metadata; +} + +struct headers { + h_t h0; + h_t h1; + h_t h2; + h_t h3; + h_t h4; +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".start") state start { + packet.extract(hdr.h0); + } +} + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + action drop_() { + mark_to_drop(standard_metadata); + } + action validate_h1(bit<16> value) { + hdr.h1.setValid(); + hdr.h1.value = value; + } + action validate_h2(bit<16> value) { + hdr.h2.setValid(); + hdr.h2.value = value; + } + action validate_h3(bit<16> value) { + hdr.h3.setValid(); + hdr.h3.value = value; + } + action use_h1_h2_h3() { + hdr.h4.setValid(); + hdr.h4.value = + (hdr.h1.value & (hdr.h2.value | hdr.h3.value)) - + ((hdr.h1.value | (hdr.h2.value & hdr.h3.value))); + assert(hdr.h4.value <= (hdr.h1.value & (hdr.h2.value | hdr.h3.value))); + +// underflow protection + + } + table t1 { + key = { + hdr.h0.value: exact; + } + actions = { + validate_h1; + drop_; + } + } + table t2 { + key = { + hdr.h0.value: exact; + } + actions = { + validate_h2; + drop_; + } + } + table t3 { + key = { + hdr.h0.value: exact; + } + actions = { + validate_h3; + drop_; + } + } + table t4 { + key = { + hdr.h0.value: exact; + } + actions = { + use_h1_h2_h3; + drop_; + } + } + apply { + hdr.h1.setInvalid(); + hdr.h2.setInvalid(); + hdr.h3.setInvalid(); + hdr.h4.setInvalid(); + t1.apply(); + t2.apply(); + t3.apply(); + t4.apply(); + standard_metadata.egress_spec = 9w511; + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + apply {} +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply {} +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply {} +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000077__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000077__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..04e6cf66527a8269d1d11d3e34b0e243f4ff06c1 --- /dev/null +++ b/individual_files/000077__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,186 @@ +#include +#include + +#define TYPE_IPV4 16w0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv6_t { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + bit<128> srcAddr; + bit<128> dstAddr; +} + +struct metadata { + bit<1> l3_admit; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv6_t ipv6; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + + state parse_ipv6 { + packet.extract(hdr.ipv6); + transition accept; + } + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x0800: parse_ipv4; + default : reject; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action packet_type(bit<1> is_l3) { + meta.l3_admit = is_l3; + } + + table l2 { + key = { + hdr.ethernet.srcAddr: exact; + } + actions = { + drop; + NoAction; + } + } + + action ctrl() { + standard_metadata.egress_spec = 9w510; + +// or whatever the controller port number is + } + + table l3 { + key = { hdr.ipv4.ttl : exact; } + actions = { drop; NoAction; } + } + + table punt { + key = { hdr.ethernet.srcAddr: exact; + hdr.ethernet.dstAddr: exact; + hdr.ipv4.srcAddr: exact; + hdr.ipv4.ttl : exact; + hdr.ipv4.dstAddr : exact; } + actions = { ctrl; NoAction; } + } + + apply { + standard_metadata.egress_spec = 9w0; + l2.apply(); + l3.apply(); + punt.apply(); + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000078__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000078__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8159d93a56bbf36a1465f8833e7830e0fb8e1c23 --- /dev/null +++ b/individual_files/000078__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,172 @@ +#include +#include + +#define TYPE_IPV4 16w0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv6_t { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + bit<128> srcAddr; + bit<128> dstAddr; +} + +struct metadata { + bit<1> l3_admit; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv6_t ipv6; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + + state parse_ipv6 { + packet.extract(hdr.ipv6); + transition accept; + } + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x0800: parse_ipv4; + default : reject; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action packet_type(bit<1> is_l3) { + meta.l3_admit = is_l3; + } + + table get_type { + key = { + hdr.ethernet.etherType: exact; + } + actions = { + packet_type; + drop; + } + } + + action fwd_(bit<9> port) { + standard_metadata.egress_spec = port; + } + + table fwd { + key = { meta.l3_admit : exact ; hdr.ipv4.dstAddr : lpm; } + actions = { fwd_; drop; NoAction; } + } + apply { + get_type.apply(); + fwd.apply(); + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000079__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000079__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..999848a2925464a86f0a9f5d03633a7c1054c2ad --- /dev/null +++ b/individual_files/000079__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,191 @@ +#include +#include + +#define TYPE_IPV4 16w0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv6_t { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + bit<128> srcAddr; + bit<128> dstAddr; +} + +struct metadata { + bit<1> is_v4; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv6_t ipv6; + ipv4_t inner_ipv4; + ipv6_t inner_ipv6; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + + state parse_ipv6 { + packet.extract(hdr.ipv6); + transition accept; + } + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x0800: parse_ipv4; + 16w0x86DD: parse_ipv6; + default : reject; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action packet_type(bit<1> version) { + meta.is_v4 = version; + } + + action encap_v4(){ + hdr.inner_ipv4.setValid(); + + } + + action encap_v6() { + hdr.inner_ipv6.setValid(); + + } + + table get_type { + key = { + hdr.ethernet.etherType: exact; + } + actions = { + packet_type; + } + } + + table ipv4_encap { + key = { hdr.ethernet.etherType : exact; } + actions = { encap_v4; NoAction; } + } + + table ipv6_encap { + key = { hdr.ethernet.etherType : exact; } + actions = { encap_v6; NoAction; } + } + apply { + hdr.inner_ipv6.setInvalid(); + hdr.inner_ipv4.setInvalid(); + ipv4_encap.apply(); + ipv6_encap.apply(); + + assert((!hdr.ipv4.isValid()) || (!hdr.inner_ipv6.isValid())); + assert((!hdr.ipv6.isValid()) || (!hdr.inner_ipv4.isValid())); + standard_metadata.egress_spec = 9w511; + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000080__raw-repositories__cornell-netlab__capisce.p4 b/individual_files/000080__raw-repositories__cornell-netlab__capisce.p4 new file mode 100644 index 0000000000000000000000000000000000000000..c71601e49778a7b2a3fe8c95ebabc214ad931746 --- /dev/null +++ b/individual_files/000080__raw-repositories__cornell-netlab__capisce.p4 @@ -0,0 +1,180 @@ +#include +#include + +#define TYPE_IPV4 16w0x800; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv6_t { + bit<4> version; + bit<8> trafficClass; + bit<20> flowLabel; + bit<16> payloadLen; + bit<8> nextHdr; + bit<8> hopLimit; + bit<128> srcAddr; + bit<128> dstAddr; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv6_t ipv6; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } + + state parse_ipv6 { + packet.extract(hdr.ipv6); + transition accept; + } + + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x0800: parse_ipv4; + 16w0x8D66: parse_ipv6; + default : accept; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 8w1; + } + + action ipv6_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv6.hopLimit = hdr.ipv6.hopLimit - 8w1; + } + + table l3_lpm { + key = { + hdr.ethernet.etherType: exact; + hdr.ipv4.dstAddr: ternary; + hdr.ipv6.dstAddr: ternary; + } + actions = { + ipv4_forward; + ipv6_forward; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + l3_lpm.apply(); + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000081__raw-repositories__doraeric__p4-ja3.p4 b/individual_files/000081__raw-repositories__doraeric__p4-ja3.p4 new file mode 100644 index 0000000000000000000000000000000000000000..c3fe30f453bd2833ad9dc6bf948da000920a5cbd --- /dev/null +++ b/individual_files/000081__raw-repositories__doraeric__p4-ja3.p4 @@ -0,0 +1,1389 @@ +#include +#include + + + + +#ifndef __HEADERS__ +#define __HEADERS__ + + + + +#ifndef __DEFINES__ +#define __DEFINES__ + +#define ETH_TYPE_IPV4 0x0800 +#define ETH_TYPE_ARP 0x0806 +#define IP_PROTO_TCP 8w6 +#define IP_PROTO_UDP 8w17 +#define IP_VERSION_4 4w4 +#define IPV4_IHL_MIN 4w5 +#define MAX_PORTS 511 + +#define TLS_TYPE_HANDSHAKE 22 +#define TLS_HSK_TYPE_CLIENT_HELLO 1 + +#ifndef _BOOL +#define _BOOL bool +#endif +#ifndef _TRUE +#define _TRUE true +#endif +#ifndef _FALSE +#define _FALSE false +#endif + +#define ACL_TABLE_SIZE 1024 + +typedef bit<48> mac_t; +typedef bit<32> ip_address_t; +typedef bit<16> l4_port_t; +typedef bit<9> port_t; +typedef bit<16> next_hop_id_t; + +const port_t CPU_PORT = 255; + +typedef bit<8> MeterColor; +const MeterColor MeterColor_GREEN = 8w0; +const MeterColor MeterColor_YELLOW = 8w1; +const MeterColor MeterColor_RED = 8w2; + +#endif + + +@controller_header("packet_in") +header packet_in_header_t { + bit<9> ingress_port; + bit<7> _padding; +} + +@controller_header("packet_out") +header packet_out_header_t { + bit<9> egress_port; + bit<7> _padding; +} + +header ethernet_t { + bit<48> dst_addr; + bit<48> src_addr; + bit<16> ether_type; +} +const bit<8> ETH_HEADER_LEN = 14; + + +header arp_t { + bit<16> hw_type; + bit<16> protocol; + bit<8> hlen; + bit<8> plen; + bit<16> opcode; + bit<48> hw_src_addr; + bit<32> proto_src_addr; + bit<48> hw_dst_addr; + bit<32> proto_dst_addr; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> dscp; + bit<2> ecn; + bit<16> len; + bit<16> identification; + bit<3> flags; + bit<13> frag_offset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdr_checksum; + bit<32> src_addr; + bit<32> dst_addr; +} +const bit<8> IPV4_MIN_HEAD_LEN = 20; + +header tcp_t { + bit<16> src_port; + bit<16> dst_port; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; +} + +header tcp_options_t { + varbit<320> options; +} + +header udp_t { + bit<16> src_port; + bit<16> dst_port; + bit<16> length_; + bit<16> checksum; +} +const bit<8> UDP_HEADER_LEN = 8; + +header tls_record_t { + bit<8> type; + bit<16> legacy_record_version; + bit<16> len; +} + +header tls_handshake_t { + bit<8> msg_type; + bit<24> len; +} + +header tls_client_hello_t { + bit<16> legacy_version; + + bit<256> random; + +} + +header tls_session_t { + bit<8> session_id_len; + varbit<256> legacy_session_id; +} + + +header tls_cipher_len_t { + bit<16> len; +} + +header tls_compression_t { + bit<8> legacy_compression_methods_len; + varbit<512> legacy_compression_methods; +} + + +header tls_exts_len_t { + bit<16> len; +} + + + + + +header one_byte_t { + bit<8> data; +} + +header two_byte_t { + bit<16> data; +} + +error { + noAppLayerData, + TcpDataOffsetTooSmall +} + +#endif + + + +#ifndef __CUSTOM_HEADERS__ +#define __CUSTOM_HEADERS__ +struct headers_t { + packet_out_header_t packet_out; + packet_in_header_t packet_in; + ethernet_t ethernet; + arp_t arp; + ipv4_t ipv4; + tcp_t tcp; + udp_t udp; + tcp_options_t tcp_options; + tls_record_t tls_record; + tls_handshake_t tls_hsk; + tls_client_hello_t tls_client_hello; + tls_session_t tls_session; + + tls_cipher_len_t tls_cipher_len; + two_byte_t[128] tls_ciphers; + tls_compression_t tls_compression; + tls_exts_len_t tls_exts_len; + + one_byte_t[256] tls_ext_buffer; +} + +struct local_metadata_t { + bit<16> l4_src_port; + bit<16> l4_dst_port; + next_hop_id_t next_hop_id; + bool skip_next; + +// skip control pipelines + @field_list(1) + bool update_tcp_checksum; + @field_list(1) + bit<16> app_len; + +// app-layer length in bytes + @field_list(1) + bit<16> tcp_len; + bit<16> tls_ext_type_len; + bit<16> tls_ext_type_0; + bit<16> tls_ext_type_1; + bit<16> tls_ext_type_2; + bit<16> tls_ext_type_3; + bit<16> tls_ext_type_4; + bit<16> tls_ext_type_5; + bit<16> tls_ext_type_6; + bit<16> tls_ext_type_7; + bit<16> tls_ext_type_8; + bit<16> tls_ext_type_9; + bit<16> tls_ext_type_10; + bit<16> tls_ext_type_11; + bit<16> tls_ext_type_12; + bit<16> tls_ext_type_13; + bit<16> tls_ext_type_14; + bit<16> tls_ext_type_15; + bit<16> tls_ext_type_16; + bit<16> tls_ext_type_17; + bit<16> tls_ext_type_18; + bit<16> tls_ext_type_19; + bit<16> tls_ext_type_20; + bit<16> tls_ext_type_21; + bit<16> tls_ext_type_22; + bit<16> tls_ext_type_23; + bit<16> tls_ext_type_24; + bit<16> tls_ext_type_25; + bit<16> tls_ext_type_26; + bit<16> tls_ext_type_27; + bit<16> tls_ext_type_28; + bit<16> tls_ext_type_29; + bit<16> tls_ext_type_30; + bit<16> tls_ext_type_31; + bit<16> tls_ext_grp_len; + + bit<16> tls_ext_grps_0; + bit<16> tls_ext_grps_1; + bit<16> tls_ext_grps_2; + bit<16> tls_ext_grps_3; + bit<16> tls_ext_grps_4; + bit<16> tls_ext_grps_5; + bit<16> tls_ext_grps_6; + bit<16> tls_ext_grps_7; + bit<16> tls_ext_grps_8; + bit<16> tls_ext_grps_9; + bit<16> tls_ext_grps_10; + bit<16> tls_ext_grps_11; + bit<16> tls_ext_grps_12; + bit<16> tls_ext_grps_13; + bit<16> tls_ext_grps_14; + bit<16> tls_ext_grps_15; + bit<16> tls_ext_grps_16; + bit<16> tls_ext_grps_17; + bit<16> tls_ext_grps_18; + bit<16> tls_ext_grps_19; + bit<16> tls_ext_grps_20; + bit<16> tls_ext_grps_21; + bit<16> tls_ext_grps_22; + bit<16> tls_ext_grps_23; + bit<16> tls_ext_grps_24; + bit<16> tls_ext_grps_25; + bit<16> tls_ext_grps_26; + bit<16> tls_ext_grps_27; + bit<16> tls_ext_grps_28; + bit<16> tls_ext_grps_29; + bit<16> tls_ext_grps_30; + bit<16> tls_ext_grps_31; + bit<8> tls_ext_ec_len; + bit<8> tls_ext_ec_0; + bit<8> tls_ext_ec_1; + bit<8> tls_ext_ec_2; + bit<8> tls_ext_ec_3; + bit<8> tls_ext_ec_4; + bit<8> tls_ext_ec_5; + bit<8> tls_ext_ec_6; + bit<8> tls_ext_ec_7; +} + +#endif + + + +#ifndef __PARSERS__ +#define __PARSERS__ + + + +parser parser_impl( + packet_in packet, + out headers_t hdr, + inout local_metadata_t meta, + inout standard_metadata_t stdmeta) { + + bit<16> reamin_exts_len = 0; + bit<16> remain_ext_len = 0; + bit<16> remain_ciphers_len = 0; + bit<16> grp_len = 0; + bit<16> grp_idx = 0; + bit<16> grp = 0; + bit<16> ext_idx = 0; + bit<16> ext_type = 0; + bit<8> ec_idx = 0; + state start { + transition select(stdmeta.ingress_port) { + CPU_PORT: parse_packet_out; + default: parse_ethernet; + } + } + + state parse_packet_out { + packet.extract(hdr.packet_out); + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.ether_type) { + ETH_TYPE_IPV4: parse_ipv4; + ETH_TYPE_ARP: parse_arp; + default: accept; + } + } + + state parse_arp { + packet.extract(hdr.arp); + transition accept; + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + IP_PROTO_TCP: parse_tcp; + IP_PROTO_UDP: parse_udp; + default: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + meta.l4_src_port = hdr.tcp.src_port; + meta.l4_dst_port = hdr.tcp.dst_port; + meta.tcp_len = hdr.ipv4.len - (bit<16>)hdr.ipv4.ihl * 4; + meta.update_tcp_checksum = false; + verify(hdr.tcp.data_offset >=5, error.TcpDataOffsetTooSmall); + transition select(hdr.tcp.data_offset){ + 5: parse_app_len; + default: parse_tcp_options; + } + } + + state parse_tcp_options { + bit<10> len = ((bit<10>)(hdr.tcp.data_offset - 5) * 4 * 8); + packet.extract(hdr.tcp_options, (bit<32>)len); + transition parse_app_len; + } + + state parse_udp { + packet.extract(hdr.udp); + meta.l4_src_port = hdr.udp.src_port; + meta.l4_dst_port = hdr.udp.dst_port; + transition accept; + } + + state parse_app_len { + + meta.app_len = + hdr.ipv4.len - ((bit<16>)hdr.ipv4.ihl + (bit<16>)hdr.tcp.data_offset) * 4; + transition select(meta.app_len) { + 0: accept; + default: parse_app; + } + } + + state parse_app { + transition select(hdr.tcp.dst_port) { + 443: parse_tls_record; + default: accept; + } + } + + state parse_tls_record { + packet.extract(hdr.tls_record); + transition select(hdr.tls_record.type) { + TLS_TYPE_HANDSHAKE: parse_tls_handshake; + default: accept; + } + } + + state parse_tls_handshake { + packet.extract(hdr.tls_hsk); + transition select(hdr.tls_hsk.msg_type) { + TLS_HSK_TYPE_CLIENT_HELLO: parse_tls_client_hello; + default: accept; + } + } + + state parse_tls_client_hello { + packet.extract(hdr.tls_client_hello); + transition parse_tls_session; + } + + state parse_tls_session { + bit<8> tls_sess_len = packet.lookahead>(); + packet.extract(hdr.tls_session, (bit<32>)tls_sess_len*8); + transition parse_tls_cipher; + } + + state parse_tls_cipher { + + packet.extract(hdr.tls_cipher_len); + remain_ciphers_len = hdr.tls_cipher_len.len; + transition parse_tls_cipher_entry; + } + state parse_tls_cipher_entry { + transition select(remain_ciphers_len) { + 0: parse_tls_compress; + default: parse_tls_cipher_entry_2; + } + } + state parse_tls_cipher_entry_2 { + packet.extract(hdr.tls_ciphers.next); + remain_ciphers_len = remain_ciphers_len - 2; + transition parse_tls_cipher_entry; + } + + state parse_tls_compress { + bit<8> tls_comp_len = packet.lookahead>(); + packet.extract(hdr.tls_compression, (bit<32>)tls_comp_len*8); + transition parse_tls_extensions_len; + } + + state parse_tls_extensions_len { + packet.extract(hdr.tls_exts_len); + reamin_exts_len = hdr.tls_exts_len.len; + ext_idx = 0; + transition parse_tls_extensions; + } + + state parse_tls_extensions { + bit<1> loop = reamin_exts_len > 0 ? 1w1 : 0; + transition select(loop) { + 1: parse_tls_extension; + default: accept; + } + } + + state parse_tls_extension { + ext_type = packet.lookahead>(); + packet.extract(hdr.tls_ext_buffer.next); + packet.extract(hdr.tls_ext_buffer.next); + bit<16> ext_len = packet.lookahead>(); + packet.extract(hdr.tls_ext_buffer.next); + packet.extract(hdr.tls_ext_buffer.next); + reamin_exts_len = reamin_exts_len - 4; + remain_ext_len = ext_len; + transition select(ext_idx) { + 0: save_tls_ext_type_0; + 1: save_tls_ext_type_1; + 2: save_tls_ext_type_2; + 3: save_tls_ext_type_3; + 4: save_tls_ext_type_4; + 5: save_tls_ext_type_5; + 6: save_tls_ext_type_6; + 7: save_tls_ext_type_7; + 8: save_tls_ext_type_8; + 9: save_tls_ext_type_9; + 10: save_tls_ext_type_10; + 11: save_tls_ext_type_11; + 12: save_tls_ext_type_12; + 13: save_tls_ext_type_13; + 14: save_tls_ext_type_14; + 15: save_tls_ext_type_15; + 16: save_tls_ext_type_16; + 17: save_tls_ext_type_17; + 18: save_tls_ext_type_18; + 19: save_tls_ext_type_19; + 20: save_tls_ext_type_20; + 21: save_tls_ext_type_21; + 22: save_tls_ext_type_22; + 23: save_tls_ext_type_23; + 24: save_tls_ext_type_24; + 25: save_tls_ext_type_25; + 26: save_tls_ext_type_26; + 27: save_tls_ext_type_27; + 28: save_tls_ext_type_28; + 29: save_tls_ext_type_29; + 30: save_tls_ext_type_30; + 31: save_tls_ext_type_31; + default: parse_tls_extension_2; + } + } + state parse_tls_extension_2 { + transition select(ext_type) { + 0xa: parse_tls_ext_supported_grp; + 0xb: parse_tls_ext_ec_point; + default: parse_tls_ext_data; + } + } +#define save_ext(N) state save_tls_ext_type_##N { \ + meta.tls_ext_type_##N = ext_type; \ + ext_idx = ext_idx + 1; \ + meta.tls_ext_type_len = ext_idx; \ + transition parse_tls_extension_2; \ +} + save_ext(0) save_ext(1) save_ext(2) save_ext(3) save_ext(4) save_ext(5) + save_ext(6) save_ext(7) save_ext(8) save_ext(9) save_ext(10) save_ext(11) + save_ext(12) save_ext(13) save_ext(14) save_ext(15) save_ext(16) save_ext(17) + save_ext(18) save_ext(19) save_ext(20) save_ext(21) save_ext(22) save_ext(23) + save_ext(24) save_ext(25) save_ext(26) save_ext(27) save_ext(28) save_ext(29) + save_ext(30) save_ext(31) + + state parse_tls_ext_supported_grp { + grp_len = packet.lookahead>(); + meta.tls_ext_grp_len = grp_len; + grp_idx = 0; + packet.extract(hdr.tls_ext_buffer.next); + packet.extract(hdr.tls_ext_buffer.next); + reamin_exts_len = reamin_exts_len - 2; + remain_ext_len = remain_ext_len - 2; + transition select(remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_supported_grp_2; + } + } + state parse_tls_ext_supported_grp_2 { + grp = packet.lookahead>(); + packet.extract(hdr.tls_ext_buffer.next); + packet.extract(hdr.tls_ext_buffer.next); + + reamin_exts_len = reamin_exts_len - 2; + remain_ext_len = remain_ext_len - 2; + + transition select(grp_idx) { + 0: save_tls_ext_supported_grp_0; + 1: save_tls_ext_supported_grp_1; + 2: save_tls_ext_supported_grp_2; + 3: save_tls_ext_supported_grp_3; + 4: save_tls_ext_supported_grp_4; + 5: save_tls_ext_supported_grp_5; + 6: save_tls_ext_supported_grp_6; + 7: save_tls_ext_supported_grp_7; + 8: save_tls_ext_supported_grp_8; + 9: save_tls_ext_supported_grp_9; + 10: save_tls_ext_supported_grp_10; + 11: save_tls_ext_supported_grp_11; + 12: save_tls_ext_supported_grp_12; + 13: save_tls_ext_supported_grp_13; + 14: save_tls_ext_supported_grp_14; + 15: save_tls_ext_supported_grp_15; + 16: save_tls_ext_supported_grp_16; + 17: save_tls_ext_supported_grp_17; + 18: save_tls_ext_supported_grp_18; + 19: save_tls_ext_supported_grp_19; + 20: save_tls_ext_supported_grp_20; + 21: save_tls_ext_supported_grp_21; + 22: save_tls_ext_supported_grp_22; + 23: save_tls_ext_supported_grp_23; + 24: save_tls_ext_supported_grp_24; + 25: save_tls_ext_supported_grp_25; + 26: save_tls_ext_supported_grp_26; + 27: save_tls_ext_supported_grp_27; + 28: save_tls_ext_supported_grp_28; + 29: save_tls_ext_supported_grp_29; + 30: save_tls_ext_supported_grp_30; + 31: save_tls_ext_supported_grp_31; + default: parse_tls_ext_supported_grp_3; + } + } + state parse_tls_ext_supported_grp_3 { + transition select (remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_supported_grp_2; + } + } +#define save_grp(N) state save_tls_ext_supported_grp_##N { \ + meta.tls_ext_grps_##N = grp; \ + grp_idx = grp_idx + 1; \ + transition parse_tls_ext_supported_grp_3; \ +} + + save_grp(0) save_grp(1) save_grp(2) save_grp(3) save_grp(4) save_grp(5) + save_grp(6) save_grp(7) save_grp(8) save_grp(9) save_grp(10) save_grp(11) + save_grp(12) save_grp(13) save_grp(14) save_grp(15) save_grp(16) save_grp(17) + save_grp(18) save_grp(19) save_grp(20) save_grp(21) save_grp(22) save_grp(23) + save_grp(24) save_grp(25) save_grp(26) save_grp(27) save_grp(28) save_grp(29) + save_grp(30) save_grp(31) + + state parse_tls_ext_ec_point { + + packet.extract(hdr.tls_ext_buffer.next); + reamin_exts_len = reamin_exts_len - 1; + remain_ext_len = remain_ext_len - 1; + ec_idx = 0; + transition select (remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_ec_point_2; + } + } + state parse_tls_ext_ec_point_2 { + packet.extract(hdr.tls_ext_buffer.next); + reamin_exts_len = reamin_exts_len - 1; + remain_ext_len = remain_ext_len - 1; + transition select(ec_idx) { + 0: save_tls_ext_ec_0; + 1: save_tls_ext_ec_1; + 2: save_tls_ext_ec_2; + 3: save_tls_ext_ec_3; + 4: save_tls_ext_ec_4; + 5: save_tls_ext_ec_5; + 6: save_tls_ext_ec_6; + 7: save_tls_ext_ec_7; + default: parse_tls_ext_ec_point_3; + } + } + state parse_tls_ext_ec_point_3 { + transition select (remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_ec_point_2; + } + } +#define save_ec(N) state save_tls_ext_ec_##N { \ + meta.tls_ext_ec_##N = hdr.tls_ext_buffer.last.data; \ + ec_idx = ec_idx + 1; \ + meta.tls_ext_ec_len = ec_idx; \ + transition parse_tls_ext_ec_point_3; \ +} + save_ec(0) save_ec(1) save_ec(2) save_ec(3) + save_ec(4) save_ec(5) save_ec(6) save_ec(7) + + state parse_tls_ext_data { + transition select(remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_data_2; + } + } + state parse_tls_ext_data_2 { + packet.extract(hdr.tls_ext_buffer.next); + reamin_exts_len = reamin_exts_len - 1; + remain_ext_len = remain_ext_len - 1; + transition select(remain_ext_len) { + 0: parse_tls_extensions; + default: parse_tls_ext_data_2; + } + } + + + + +} + +control deparser(packet_out packet, in headers_t hdr) { + apply { + packet.emit(hdr.packet_in); + packet.emit(hdr.ethernet); + packet.emit(hdr.arp); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + packet.emit(hdr.tcp_options); + packet.emit(hdr.udp); + packet.emit(hdr.tls_record); + packet.emit(hdr.tls_hsk); + packet.emit(hdr.tls_client_hello); + packet.emit(hdr.tls_session); + + packet.emit(hdr.tls_cipher_len); + packet.emit(hdr.tls_ciphers); + packet.emit(hdr.tls_compression); + + packet.emit(hdr.tls_exts_len); + packet.emit(hdr.tls_ext_buffer); + } +} + +#endif + + + +#ifndef __ACTIONS__ +#define __ACTIONS__ + + + +action nop() { + NoAction(); +} + +#endif + + + +#ifndef __PORT_COUNTERS__ +#define __PORT_COUNTERS__ + + + +control port_counters_ingress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + + counter(MAX_PORTS, CounterType.packets) ingress_port_counter; + + apply { + ingress_port_counter.count((bit<32>) standard_metadata.ingress_port); + } +} + +control port_counters_egress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + + counter(MAX_PORTS, CounterType.packets) egress_port_counter; + + apply { + egress_port_counter.count((bit<32>) standard_metadata.egress_port); + } +} + +#endif + + + +#ifndef METERS +#define METERS + + +control port_meters_ingress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + meter(MAX_PORTS, MeterType.bytes) ingress_port_meter; + MeterColor ingress_color = MeterColor_GREEN; + + apply { + ingress_port_meter.execute_meter((bit<32>)standard_metadata.ingress_port, ingress_color); + if (ingress_color == MeterColor_RED) { + mark_to_drop(standard_metadata); + } + } +} + +control port_meters_egress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + + meter(MAX_PORTS, MeterType.bytes) egress_port_meter; + MeterColor egress_color = MeterColor_GREEN; + + apply { + egress_port_meter.execute_meter((bit<32>)standard_metadata.egress_port, egress_color); + if (egress_color == MeterColor_RED) { + mark_to_drop(standard_metadata); + } + } +} +#endif + + + +#ifndef __CHECKSUMS__ +#define __CHECKSUMS__ + + + +control verify_checksum_control(inout headers_t hdr, + inout local_metadata_t local_metadata) { + apply { + +// Assume checksum is always correct. + } +} + +control compute_checksum_control(inout headers_t hdr, + inout local_metadata_t local_metadata) { + apply { + update_checksum(hdr.ipv4.isValid(), + { + hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.ecn, + hdr.ipv4.len, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.frag_offset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr + }, + hdr.ipv4.hdr_checksum, + HashAlgorithm.csum16 + ); + + update_checksum( + hdr.tcp.isValid() && local_metadata.update_tcp_checksum, + { + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr, + +// align to 2 bytes + 8w0, + hdr.ipv4.protocol, + local_metadata.tcp_len, + hdr.tcp.src_port, + hdr.tcp.dst_port, + hdr.tcp.seq_no, + hdr.tcp.ack_no, + hdr.tcp.data_offset, + hdr.tcp.res, + hdr.tcp.ecn, + hdr.tcp.ctrl, + hdr.tcp.window, + hdr.tcp.urgent_ptr, + hdr.tcp_options + }, + hdr.tcp.checksum, + HashAlgorithm.csum16 + ); + + + #ifdef __INT_HEADERS__ + update_checksum(hdr.report_ipv4.isValid(), + { + hdr.report_ipv4.version, + hdr.report_ipv4.ihl, + hdr.report_ipv4.dscp, + hdr.report_ipv4.ecn, + hdr.report_ipv4.len, + hdr.report_ipv4.identification, + hdr.report_ipv4.flags, + hdr.report_ipv4.frag_offset, + hdr.report_ipv4.ttl, + hdr.report_ipv4.protocol, + hdr.report_ipv4.src_addr, + hdr.report_ipv4.dst_addr + }, + hdr.report_ipv4.hdr_checksum, + HashAlgorithm.csum16 + ); + #endif + + } +} + +#endif + + + +#ifndef __PACKET_IO__ +#define __PACKET_IO__ + + + +control packetio_ingress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + apply { + if (standard_metadata.ingress_port == CPU_PORT) { + standard_metadata.egress_spec = hdr.packet_out.egress_port; + hdr.packet_out.setInvalid(); + exit; + } + } +} + +control packetio_egress(inout headers_t hdr, + inout standard_metadata_t standard_metadata) { + apply { + if (standard_metadata.egress_port == CPU_PORT) { + hdr.packet_in.setValid(); + hdr.packet_in.ingress_port = standard_metadata.ingress_port; + } + } +} + +#endif + + + +#ifndef __TABLE0__ +#define __TABLE0__ + + + +control Acl( + inout headers_t hdr, + inout local_metadata_t meta, + inout standard_metadata_t stdmeta) { + + direct_counter(CounterType.packets_and_bytes) acl_counter; + + action set_next_hop_id(next_hop_id_t next_hop_id) { + meta.next_hop_id = next_hop_id; + acl_counter.count(); + } + + action send_to_cpu() { + stdmeta.egress_spec = CPU_PORT; + acl_counter.count(); + } + + action clone_to_cpu() { + + clone(CloneType.I2E, (bit<32>)CPU_PORT); + } + + action set_egress_port(port_t port) { + stdmeta.egress_spec = port; + acl_counter.count(); + } + + action drop() { + mark_to_drop(stdmeta); + meta.skip_next = true; + acl_counter.count(); + } + + action nop_acl() { + acl_counter.count(); + } + + table acl { + key = { + stdmeta.ingress_port : ternary @name("ig_port"); + hdr.ethernet.src_addr : ternary @name("eth_src"); + hdr.ethernet.dst_addr : ternary @name("eth_dst"); + hdr.ethernet.ether_type : ternary @name("eth_type"); + hdr.ipv4.src_addr : ternary @name("ipv4_src"); + hdr.ipv4.dst_addr : ternary @name("ipv4_dst"); + hdr.ipv4.protocol : ternary @name("ip_proto"); + hdr.tcp.ctrl : ternary @name("tcp_flag"); + meta.l4_src_port : ternary @name("l4_sport"); + meta.l4_dst_port : ternary @name("l4_dport"); + +// TLS + hdr.tls_hsk.msg_type : ternary @name("tls_hsk_type"); + + hdr.tls_client_hello.legacy_version: ternary @name("tls_version"); + + hdr.tls_ciphers[0].data : ternary @name("tls_cipher_0"); + hdr.tls_ciphers[1].data : ternary @name("tls_cipher_1"); + hdr.tls_ciphers[2].data : ternary @name("tls_cipher_2"); + hdr.tls_ciphers[3].data : ternary @name("tls_cipher_3"); + hdr.tls_ciphers[4].data : ternary @name("tls_cipher_4"); + hdr.tls_ciphers[5].data : ternary @name("tls_cipher_5"); + hdr.tls_ciphers[6].data : ternary @name("tls_cipher_6"); + hdr.tls_ciphers[7].data : ternary @name("tls_cipher_7"); + hdr.tls_ciphers[8].data : ternary @name("tls_cipher_8"); + hdr.tls_ciphers[9].data : ternary @name("tls_cipher_9"); + hdr.tls_ciphers[10].data : ternary @name("tls_cipher_10"); + hdr.tls_ciphers[11].data : ternary @name("tls_cipher_11"); + hdr.tls_ciphers[12].data : ternary @name("tls_cipher_12"); + hdr.tls_ciphers[13].data : ternary @name("tls_cipher_13"); + hdr.tls_ciphers[14].data : ternary @name("tls_cipher_14"); + hdr.tls_ciphers[15].data : ternary @name("tls_cipher_15"); + hdr.tls_ciphers[16].data : ternary @name("tls_cipher_16"); + hdr.tls_ciphers[17].data : ternary @name("tls_cipher_17"); + hdr.tls_ciphers[18].data : ternary @name("tls_cipher_18"); + hdr.tls_ciphers[19].data : ternary @name("tls_cipher_19"); + hdr.tls_ciphers[20].data : ternary @name("tls_cipher_20"); + hdr.tls_ciphers[21].data : ternary @name("tls_cipher_21"); + hdr.tls_ciphers[22].data : ternary @name("tls_cipher_22"); + hdr.tls_ciphers[23].data : ternary @name("tls_cipher_23"); + hdr.tls_ciphers[24].data : ternary @name("tls_cipher_24"); + hdr.tls_ciphers[25].data : ternary @name("tls_cipher_25"); + hdr.tls_ciphers[26].data : ternary @name("tls_cipher_26"); + hdr.tls_ciphers[27].data : ternary @name("tls_cipher_27"); + hdr.tls_ciphers[28].data : ternary @name("tls_cipher_28"); + hdr.tls_ciphers[29].data : ternary @name("tls_cipher_29"); + hdr.tls_ciphers[30].data : ternary @name("tls_cipher_30"); + hdr.tls_ciphers[31].data : ternary @name("tls_cipher_31"); + hdr.tls_ciphers[32].data : ternary @name("tls_cipher_32"); + hdr.tls_ciphers[33].data : ternary @name("tls_cipher_33"); + hdr.tls_ciphers[34].data : ternary @name("tls_cipher_34"); + hdr.tls_ciphers[35].data : ternary @name("tls_cipher_35"); + hdr.tls_ciphers[36].data : ternary @name("tls_cipher_36"); + hdr.tls_ciphers[37].data : ternary @name("tls_cipher_37"); + hdr.tls_ciphers[38].data : ternary @name("tls_cipher_38"); + hdr.tls_ciphers[39].data : ternary @name("tls_cipher_39"); + hdr.tls_ciphers[40].data : ternary @name("tls_cipher_40"); + hdr.tls_ciphers[41].data : ternary @name("tls_cipher_41"); + hdr.tls_ciphers[42].data : ternary @name("tls_cipher_42"); + hdr.tls_ciphers[43].data : ternary @name("tls_cipher_43"); + hdr.tls_ciphers[44].data : ternary @name("tls_cipher_44"); + hdr.tls_ciphers[45].data : ternary @name("tls_cipher_45"); + hdr.tls_ciphers[46].data : ternary @name("tls_cipher_46"); + hdr.tls_ciphers[47].data : ternary @name("tls_cipher_47"); + hdr.tls_ciphers[48].data : ternary @name("tls_cipher_48"); + hdr.tls_ciphers[49].data : ternary @name("tls_cipher_49"); + hdr.tls_ciphers[50].data : ternary @name("tls_cipher_50"); + hdr.tls_ciphers[51].data : ternary @name("tls_cipher_51"); + hdr.tls_ciphers[52].data : ternary @name("tls_cipher_52"); + hdr.tls_ciphers[53].data : ternary @name("tls_cipher_53"); + hdr.tls_ciphers[54].data : ternary @name("tls_cipher_54"); + hdr.tls_ciphers[55].data : ternary @name("tls_cipher_55"); + hdr.tls_ciphers[56].data : ternary @name("tls_cipher_56"); + hdr.tls_ciphers[57].data : ternary @name("tls_cipher_57"); + hdr.tls_ciphers[58].data : ternary @name("tls_cipher_58"); + hdr.tls_ciphers[59].data : ternary @name("tls_cipher_59"); + hdr.tls_ciphers[60].data : ternary @name("tls_cipher_60"); + hdr.tls_ciphers[61].data : ternary @name("tls_cipher_61"); + hdr.tls_ciphers[62].data : ternary @name("tls_cipher_62"); + hdr.tls_ciphers[63].data : ternary @name("tls_cipher_63"); + hdr.tls_ciphers[64].data : ternary @name("tls_cipher_64"); + hdr.tls_ciphers[65].data : ternary @name("tls_cipher_65"); + hdr.tls_ciphers[66].data : ternary @name("tls_cipher_66"); + hdr.tls_ciphers[67].data : ternary @name("tls_cipher_67"); + hdr.tls_ciphers[68].data : ternary @name("tls_cipher_68"); + hdr.tls_ciphers[69].data : ternary @name("tls_cipher_69"); + hdr.tls_ciphers[70].data : ternary @name("tls_cipher_70"); + hdr.tls_ciphers[71].data : ternary @name("tls_cipher_71"); + hdr.tls_ciphers[72].data : ternary @name("tls_cipher_72"); + hdr.tls_ciphers[73].data : ternary @name("tls_cipher_73"); + hdr.tls_ciphers[74].data : ternary @name("tls_cipher_74"); + hdr.tls_ciphers[75].data : ternary @name("tls_cipher_75"); + hdr.tls_ciphers[76].data : ternary @name("tls_cipher_76"); + hdr.tls_ciphers[77].data : ternary @name("tls_cipher_77"); + hdr.tls_ciphers[78].data : ternary @name("tls_cipher_78"); + hdr.tls_ciphers[79].data : ternary @name("tls_cipher_79"); + hdr.tls_ciphers[80].data : ternary @name("tls_cipher_80"); + hdr.tls_ciphers[81].data : ternary @name("tls_cipher_81"); + hdr.tls_ciphers[82].data : ternary @name("tls_cipher_82"); + hdr.tls_ciphers[83].data : ternary @name("tls_cipher_83"); + hdr.tls_ciphers[84].data : ternary @name("tls_cipher_84"); + hdr.tls_ciphers[85].data : ternary @name("tls_cipher_85"); + hdr.tls_ciphers[86].data : ternary @name("tls_cipher_86"); + hdr.tls_ciphers[87].data : ternary @name("tls_cipher_87"); + hdr.tls_ciphers[88].data : ternary @name("tls_cipher_88"); + hdr.tls_ciphers[89].data : ternary @name("tls_cipher_89"); + hdr.tls_ciphers[90].data : ternary @name("tls_cipher_90"); + hdr.tls_ciphers[91].data : ternary @name("tls_cipher_91"); + hdr.tls_ciphers[92].data : ternary @name("tls_cipher_92"); + hdr.tls_ciphers[93].data : ternary @name("tls_cipher_93"); + hdr.tls_ciphers[94].data : ternary @name("tls_cipher_94"); + hdr.tls_ciphers[95].data : ternary @name("tls_cipher_95"); + hdr.tls_ciphers[96].data : ternary @name("tls_cipher_96"); + hdr.tls_ciphers[97].data : ternary @name("tls_cipher_97"); + hdr.tls_ciphers[98].data : ternary @name("tls_cipher_98"); + hdr.tls_ciphers[99].data : ternary @name("tls_cipher_99"); + hdr.tls_ciphers[100].data : ternary @name("tls_cipher_100"); + hdr.tls_ciphers[101].data : ternary @name("tls_cipher_101"); + hdr.tls_ciphers[102].data : ternary @name("tls_cipher_102"); + hdr.tls_ciphers[103].data : ternary @name("tls_cipher_103"); + hdr.tls_ciphers[104].data : ternary @name("tls_cipher_104"); + hdr.tls_ciphers[105].data : ternary @name("tls_cipher_105"); + hdr.tls_ciphers[106].data : ternary @name("tls_cipher_106"); + hdr.tls_ciphers[107].data : ternary @name("tls_cipher_107"); + hdr.tls_ciphers[108].data : ternary @name("tls_cipher_108"); + hdr.tls_ciphers[109].data : ternary @name("tls_cipher_109"); + hdr.tls_ciphers[110].data : ternary @name("tls_cipher_110"); + hdr.tls_ciphers[111].data : ternary @name("tls_cipher_111"); + hdr.tls_ciphers[112].data : ternary @name("tls_cipher_112"); + hdr.tls_ciphers[113].data : ternary @name("tls_cipher_113"); + hdr.tls_ciphers[114].data : ternary @name("tls_cipher_114"); + hdr.tls_ciphers[115].data : ternary @name("tls_cipher_115"); + hdr.tls_ciphers[116].data : ternary @name("tls_cipher_116"); + hdr.tls_ciphers[117].data : ternary @name("tls_cipher_117"); + hdr.tls_ciphers[118].data : ternary @name("tls_cipher_118"); + hdr.tls_ciphers[119].data : ternary @name("tls_cipher_119"); + hdr.tls_ciphers[120].data : ternary @name("tls_cipher_120"); + hdr.tls_ciphers[121].data : ternary @name("tls_cipher_121"); + hdr.tls_ciphers[122].data : ternary @name("tls_cipher_122"); + hdr.tls_ciphers[123].data : ternary @name("tls_cipher_123"); + hdr.tls_ciphers[124].data : ternary @name("tls_cipher_124"); + hdr.tls_ciphers[125].data : ternary @name("tls_cipher_125"); + hdr.tls_ciphers[126].data : ternary @name("tls_cipher_126"); + hdr.tls_ciphers[127].data : ternary @name("tls_cipher_127"); + + meta.tls_ext_type_0 : ternary @name("tls_ext_type_0"); + meta.tls_ext_type_1 : ternary @name("tls_ext_type_1"); + meta.tls_ext_type_2 : ternary @name("tls_ext_type_2"); + meta.tls_ext_type_3 : ternary @name("tls_ext_type_3"); + meta.tls_ext_type_4 : ternary @name("tls_ext_type_4"); + meta.tls_ext_type_5 : ternary @name("tls_ext_type_5"); + meta.tls_ext_type_6 : ternary @name("tls_ext_type_6"); + meta.tls_ext_type_7 : ternary @name("tls_ext_type_7"); + meta.tls_ext_type_8 : ternary @name("tls_ext_type_8"); + meta.tls_ext_type_9 : ternary @name("tls_ext_type_9"); + meta.tls_ext_type_10 : ternary @name("tls_ext_type_10"); + meta.tls_ext_type_11 : ternary @name("tls_ext_type_11"); + meta.tls_ext_type_12 : ternary @name("tls_ext_type_12"); + meta.tls_ext_type_13 : ternary @name("tls_ext_type_13"); + meta.tls_ext_type_14 : ternary @name("tls_ext_type_14"); + meta.tls_ext_type_15 : ternary @name("tls_ext_type_15"); + meta.tls_ext_type_16 : ternary @name("tls_ext_type_16"); + meta.tls_ext_type_17 : ternary @name("tls_ext_type_17"); + meta.tls_ext_type_18 : ternary @name("tls_ext_type_18"); + meta.tls_ext_type_19 : ternary @name("tls_ext_type_19"); + meta.tls_ext_type_20 : ternary @name("tls_ext_type_20"); + meta.tls_ext_type_21 : ternary @name("tls_ext_type_21"); + meta.tls_ext_type_22 : ternary @name("tls_ext_type_22"); + meta.tls_ext_type_23 : ternary @name("tls_ext_type_23"); + meta.tls_ext_type_24 : ternary @name("tls_ext_type_24"); + meta.tls_ext_type_25 : ternary @name("tls_ext_type_25"); + meta.tls_ext_type_26 : ternary @name("tls_ext_type_26"); + meta.tls_ext_type_27 : ternary @name("tls_ext_type_27"); + meta.tls_ext_type_28 : ternary @name("tls_ext_type_28"); + meta.tls_ext_type_29 : ternary @name("tls_ext_type_29"); + meta.tls_ext_type_30 : ternary @name("tls_ext_type_30"); + meta.tls_ext_type_31 : ternary @name("tls_ext_type_31"); + + meta.tls_ext_grps_0 : ternary @name("tls_grp_0"); + meta.tls_ext_grps_1 : ternary @name("tls_grp_1"); + meta.tls_ext_grps_2 : ternary @name("tls_grp_2"); + meta.tls_ext_grps_3 : ternary @name("tls_grp_3"); + meta.tls_ext_grps_4 : ternary @name("tls_grp_4"); + meta.tls_ext_grps_5 : ternary @name("tls_grp_5"); + meta.tls_ext_grps_6 : ternary @name("tls_grp_6"); + meta.tls_ext_grps_7 : ternary @name("tls_grp_7"); + meta.tls_ext_grps_8 : ternary @name("tls_grp_8"); + meta.tls_ext_grps_9 : ternary @name("tls_grp_9"); + meta.tls_ext_grps_10 : ternary @name("tls_grp_10"); + meta.tls_ext_grps_11 : ternary @name("tls_grp_11"); + meta.tls_ext_grps_12 : ternary @name("tls_grp_12"); + meta.tls_ext_grps_13 : ternary @name("tls_grp_13"); + meta.tls_ext_grps_14 : ternary @name("tls_grp_14"); + meta.tls_ext_grps_15 : ternary @name("tls_grp_15"); + meta.tls_ext_grps_16 : ternary @name("tls_grp_16"); + meta.tls_ext_grps_17 : ternary @name("tls_grp_17"); + meta.tls_ext_grps_18 : ternary @name("tls_grp_18"); + meta.tls_ext_grps_19 : ternary @name("tls_grp_19"); + meta.tls_ext_grps_20 : ternary @name("tls_grp_20"); + meta.tls_ext_grps_21 : ternary @name("tls_grp_21"); + meta.tls_ext_grps_22 : ternary @name("tls_grp_22"); + meta.tls_ext_grps_23 : ternary @name("tls_grp_23"); + meta.tls_ext_grps_24 : ternary @name("tls_grp_24"); + meta.tls_ext_grps_25 : ternary @name("tls_grp_25"); + meta.tls_ext_grps_26 : ternary @name("tls_grp_26"); + meta.tls_ext_grps_27 : ternary @name("tls_grp_27"); + meta.tls_ext_grps_28 : ternary @name("tls_grp_28"); + meta.tls_ext_grps_29 : ternary @name("tls_grp_29"); + meta.tls_ext_grps_30 : ternary @name("tls_grp_30"); + meta.tls_ext_grps_31 : ternary @name("tls_grp_31"); + + meta.tls_ext_ec_0 : ternary @name("tls_ec_0"); + meta.tls_ext_ec_1 : ternary @name("tls_ec_1"); + meta.tls_ext_ec_2 : ternary @name("tls_ec_2"); + meta.tls_ext_ec_3 : ternary @name("tls_ec_3"); + meta.tls_ext_ec_4 : ternary @name("tls_ec_4"); + meta.tls_ext_ec_5 : ternary @name("tls_ec_5"); + meta.tls_ext_ec_6 : ternary @name("tls_ec_6"); + meta.tls_ext_ec_7 : ternary @name("tls_ec_7"); + } + actions = { + set_egress_port; + send_to_cpu; + clone_to_cpu; + set_next_hop_id; + drop; + nop_acl; + } + const default_action = nop_acl(); + size = ACL_TABLE_SIZE; + counters = acl_counter; + } + + apply { + acl.apply(); + } +} + +#endif + +#ifndef __NEXT__ +#define __NEXT__ + + + +struct timestamp_digest_t { + bit<48> ingress; + bit<32> ipv4; +} + +control next( + inout headers_t hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + action arp_reply(mac_t target_addr) { + hdr.ethernet.dst_addr = hdr.ethernet.src_addr; + hdr.ethernet.src_addr = target_addr; + hdr.arp.opcode = 2; + hdr.arp.hw_dst_addr = hdr.arp.hw_src_addr; + hdr.arp.hw_src_addr = target_addr; + bit<32> tmp = hdr.arp.proto_dst_addr; + hdr.arp.proto_dst_addr = hdr.arp.proto_src_addr; + hdr.arp.proto_src_addr = tmp; + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + table arp_table { + key = { + hdr.arp.opcode: exact; + hdr.arp.proto_dst_addr: exact; + } + actions = { + arp_reply; + NoAction; + } + size = 256; + default_action = NoAction(); + } + + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(mac_t dst_addr, port_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.src_addr = hdr.ethernet.dst_addr; + hdr.ethernet.dst_addr = dst_addr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + action forward_to_cpu() { + digest(1, {standard_metadata.ingress_global_timestamp, hdr.ipv4.src_addr}); + standard_metadata.egress_spec = CPU_PORT; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dst_addr: lpm; + } + actions = { + ipv4_forward; + forward_to_cpu; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + apply { + if (hdr.arp.isValid()) { + arp_table.apply(); + } + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } +} + +#endif + + + +#ifndef __HOST_METER_TABLE__ +#define __HOST_METER_TABLE__ + + + +control host_meter_control(inout headers_t hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + MeterColor meter_tag = MeterColor_GREEN; + direct_meter(MeterType.bytes) host_meter; + + action read_meter() { + host_meter.read(meter_tag); + } + + table host_meter_table { + key = { + hdr.ethernet.src_addr : lpm; + } + actions = { + read_meter(); + NoAction; + } + meters = host_meter; + default_action = NoAction(); + } + + apply { + host_meter_table.apply(); + if (meter_tag == MeterColor_RED) { + mark_to_drop(standard_metadata); + } + } +} + +#endif + +#ifndef __TLS_P4__ +#define __TLS_P4__ + + + +struct tls_ja3_t { + bit<16> tls_version; + bit<16> cipher_len; + bit<16> cipher_0; + bit<16> tls_ext_type_len; + bit<16> tls_ext_type_0; + bit<16> grp_len; + bit<16> grp_0; + bit<8> ec_len; + bit<8> ec_0; +} + +control tls( + inout headers_t hdr, + inout local_metadata_t meta, + inout standard_metadata_t stdmeta) { + apply { + if (hdr.tls_exts_len.isValid()) { + digest(1, { + hdr.tls_client_hello.legacy_version, + hdr.tls_cipher_len.len/2, + hdr.tls_ciphers[0].data, + meta.tls_ext_type_len, + meta.tls_ext_type_0, + meta.tls_ext_grp_len, + meta.tls_ext_grps_0, + meta.tls_ext_ec_len, + meta.tls_ext_ec_0 + }); + } + } +} + +#endif + + + + +control ingress(inout headers_t hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + Acl() acl; + apply { + port_counters_ingress.apply(hdr, standard_metadata); + port_meters_ingress.apply(hdr, standard_metadata); + packetio_ingress.apply(hdr, standard_metadata); + acl.apply(hdr, local_metadata, standard_metadata); + if (!local_metadata.skip_next) { + next.apply(hdr, local_metadata, standard_metadata); + } + if (!local_metadata.skip_next) { + tls.apply(hdr, local_metadata, standard_metadata); + } + host_meter_control.apply(hdr, local_metadata, standard_metadata); + } +} + + + +control egress(inout headers_t hdr, + inout local_metadata_t local_metadata, + inout standard_metadata_t standard_metadata) { + + apply { + port_counters_egress.apply(hdr, standard_metadata); + port_meters_egress.apply(hdr, standard_metadata); + packetio_egress.apply(hdr, standard_metadata); + } +} + + + +V1Switch(parser_impl(), + verify_checksum_control(), + ingress(), + egress(), + compute_checksum_control(), + deparser()) main; diff --git a/individual_files/000082__raw-repositories__goldthree-shit__mrc.p4 b/individual_files/000082__raw-repositories__goldthree-shit__mrc.p4 new file mode 100644 index 0000000000000000000000000000000000000000..87fac906e473c727542bc9358ace95602f6f86fa --- /dev/null +++ b/individual_files/000082__raw-repositories__goldthree-shit__mrc.p4 @@ -0,0 +1,304 @@ +#include +#include + +const bit<8> UDP_PROTOCOL = 0x11; +const bit<16> TYPE_IPV4 = 0x800; +const bit<5> IPV4_OPTION_MRI = 31; +const bit<8> CONFIGURATION = 2; + +#define MAX_HOPS 9 + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<32> switchID_t; +typedef bit<32> qdepth_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header ipv4_option_t { + bit<1> copyFlag; + bit<2> optClass; + bit<5> option; + bit<8> optionLength; +} + +header mri_t { + bit<16> count; +} + +header switch_t { + switchID_t swid; + qdepth_t qdepth; +} + +struct ingress_metadata_t { + bit<16> count; +} + +struct parser_metadata_t { + bit<16> remaining; +} + +struct metadata { + ingress_metadata_t ingress_metadata; + parser_metadata_t parser_metadata; +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + ipv4_option_t ipv4_option; + mri_t mri; + switch_t[MAX_HOPS] swtraces; +} + +error { IPHeaderTooShort } + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + verify(hdr.ipv4.ihl >= 5, error.IPHeaderTooShort); + transition select(hdr.ipv4.ihl) { + 5 : accept; + default : parse_ipv4_option; + } + } + + state parse_ipv4_option { + packet.extract(hdr.ipv4_option); + transition select(hdr.ipv4_option.option){ + IPV4_OPTION_MRI: parse_mri; + default : accept; + } + } + + state parse_mri { + packet.extract(hdr.mri); + meta.parser_metadata.remaining = hdr.mri.count; + transition select(meta.parser_metadata.remaining){ + 0 : accept; + default : parse_swtrace; + } + } + + state parse_swtrace { + packet.extract(hdr.swtraces.next); + meta.parser_metadata.remaining = meta.parser_metadata.remaining - 1; + transition select(meta.parser_metadata.remaining){ + 0 : accept; + default : parse_swtrace; + } + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + action ipv4_forward_restricted(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + + if(hdr.mri.count != 0){ + hdr.ipv4.ttl = 2; + + } + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + table ipv4_lpm2 { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + ipv4_forward_restricted; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + table ipv4_lpm3 { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + ipv4_forward_restricted; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + apply { + if (hdr.mri.count == 0){ + hdr.ipv4.diffserv = CONFIGURATION * 4; + } + if (hdr.ipv4.isValid()) { + if(hdr.ipv4.diffserv == 0){ + ipv4_lpm.apply(); + } + else if(hdr.ipv4.diffserv == 4){ + ipv4_lpm2.apply(); + } + else{ + ipv4_lpm3.apply(); + } + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action add_swtrace(switchID_t swid) { + hdr.mri.count = hdr.mri.count + 1; + hdr.swtraces.push_front(1); + hdr.swtraces[0].setValid(); + hdr.swtraces[0].swid = swid; + hdr.swtraces[0].qdepth = (qdepth_t)standard_metadata.deq_qdepth; + hdr.ipv4.ihl = hdr.ipv4.ihl + 2; + hdr.ipv4.totalLen = hdr.ipv4.totalLen + 8; + hdr.ipv4_option.optionLength = hdr.ipv4_option.optionLength + 8; + } + + table swtrace { + actions = { + add_swtrace; + NoAction; + } + + default_action = NoAction(); + } + + apply { + if(hdr.mri.isValid()){ + swtrace.apply(); + } + + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.ipv4_option); + packet.emit(hdr.mri); + packet.emit(hdr.swtraces); + + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000083__raw-repositories__greatbn__sfc-integrity.p4 b/individual_files/000083__raw-repositories__greatbn__sfc-integrity.p4 new file mode 100644 index 0000000000000000000000000000000000000000..7a23afc246c7e593cebe0efc85e61466c291517e --- /dev/null +++ b/individual_files/000083__raw-repositories__greatbn__sfc-integrity.p4 @@ -0,0 +1,319 @@ +#include +#include + +const bit<16> TYPE_SFC = 0x1212; + +// Define TYPE for SFC +const bit<8> TYPE_TCP = 0x06; +const bit<8> TYPE_UDP = 0x11; +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_NSH = 0x894F; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<16> tunnelAddr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header tunnel_t { + tunnelAddr_t dst_id; + +// Next SF + tunnelAddr_t NxpHp_id; + +// Next SFF/SF +} +header sfc_t { + bit<2> ver; + bit<1> zerobit; + bit<1> u1; + bit<6> ttl; + bit<6> len; + bit<4> u2; + bit<4> MDtype; + bit<8> protocol; + bit<24> SPI; + bit<8> SI; + bit<128> context; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> dscp; + +// We use DSCP field to assign SFP + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> len; + bit<16> checksum; + +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + sfc_t sfc; + ipv4_t ipv4; + tcp_t tcp; + udp_t udp; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_NSH: parse_sfc; + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + state parse_sfc { + packet.extract(hdr.sfc); + transition parse_ipv4; + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + TYPE_TCP: parse_tcp; + TYPE_UDP: parse_udp; + default: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + state parse_udp { + packet.extract(hdr.udp); + transition accept; + } +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + action sfc_decapsulation() { + hdr.ethernet.etherType = TYPE_IPV4; + hdr.ipv4.dscp = 0; + hdr.sfc.setInvalid(); + } + table sfc_termination { + key = { + hdr.ethernet.dstAddr: exact; + } + actions = { + sfc_decapsulation; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + action sfc_encapsulation(bit<24> SPI) { + hdr.ethernet.etherType = TYPE_NSH; + hdr.sfc.setValid(); + hdr.sfc.ver = 0x1; + + hdr.sfc.zerobit = 0; + hdr.sfc.u1 = 0; + hdr.sfc.ttl = 63; + hdr.sfc.len = 0x6; + hdr.sfc.u2 = 0; + hdr.sfc.MDtype = 0x1; + +// Fixed sized + hdr.sfc.protocol = 0x1; + + hdr.sfc.SPI = SPI; + hdr.sfc.SI = 255; + } + table sfc_classifier { + key = { + hdr.ipv4.dscp: exact; + } + actions = { + sfc_encapsulation; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + action sfc_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table sfc_egress { + key = { + hdr.sfc.SPI: exact; + hdr.sfc.SI: exact; + } + actions = { + sfc_forward; + NoAction; + drop; + } + size = 1024; + default_action = drop(); + } + + + apply { + if (hdr.ipv4.isValid() && hdr.ipv4.dscp == 0) { + +// Process only non-SFC packets + ipv4_lpm.apply(); + } + else{ + if (!hdr.sfc.isValid()){ + sfc_classifier.apply(); + } + else{ + hdr.sfc.ttl = hdr.sfc.ttl - 1; + hdr.sfc.SI = hdr.sfc.SI - 1; + } + if (hdr.sfc.SI == 0 || hdr.sfc.ttl == 0){ + drop(); + } + sfc_egress.apply(); + sfc_termination.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.sfc); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + packet.emit(hdr.udp); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000084__raw-repositories__GEANT-DataPlaneProgramming__int-platform-dpdk.p4 b/individual_files/000084__raw-repositories__GEANT-DataPlaneProgramming__int-platform-dpdk.p4 new file mode 100644 index 0000000000000000000000000000000000000000..c2c9ec00e28a16f3722b7cb28eee4dae7a8f533f --- /dev/null +++ b/individual_files/000084__raw-repositories__GEANT-DataPlaneProgramming__int-platform-dpdk.p4 @@ -0,0 +1,560 @@ + + +#include +#include + + +#ifndef _CONFIG_P4_ +#define _CONFIG_P4_ + +#define SRC_ENABLE true +#define SINK_ENABLE false +#define SWITCH_ID 0 + +#endif + + + + +#ifndef _HEADERS_P4_ +#define _HEADERS_P4_ + +header ethernet_t { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> dscp; + bit<2> ecn; + bit<16> totalLen; + bit<16> id; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> checksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> len; + bit<16> csum; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNum; + bit<32> ackNum; + bit<4> dataOffset; + bit<3> reserved; + bit<9> flags; + bit<16> winSize; + bit<16> csum; + bit<16> urgPoint; +} + +const bit<6> IPv4_DSCP_INT = 0x20; + +// indicates that INT header in the packet +const bit<16> INT_SHIM_HEADER_LEN_BYTES = 4; +const bit<8> INT_TYPE_HOP_BY_HOP = 1; + +header intl4_shim_t { + bit<8> int_type; + bit<8> rsvd1; + bit<8> len; + +// the length of all INT headers in 4-byte words + bit<6> dscp; + +// copy DSCP here + bit<2> rsvd3; +} + +const bit<16> INT_HEADER_LEN_BYTES = 8; +const bit<4> INT_VERSION = 1; + +header int_header_t { + bit<4> ver; + bit<2> rep; + bit<1> c; + bit<1> e; + bit<1> m; + bit<7> rsvd1; + bit<3> rsvd2; + bit<5> hop_metadata_len; + +// the length of the metadata added by a single INT node (4-byte words) + bit<8> remaining_hop_cnt; + +// how many switches can still add INT metadata + bit<16> instruction_mask; + bit<16> seq; +} + +const bit<16> INT_ALL_HEADER_LEN_BYTES = INT_SHIM_HEADER_LEN_BYTES + INT_HEADER_LEN_BYTES; + +header int_switch_id_t { + bit<32> switch_id; +} + +header int_port_ids_t { + bit<16> ingress_port_id; + bit<16> egress_port_id; +} + +header int_hop_latency_t { + bit<32> hop_latency; +} + +header int_q_occupancy_t { + bit<8> q_id; + bit<24> q_occupancy; +} + +header int_ingress_tstamp_t { + bit<32> ingress_tstamp_h; + bit<32> ingress_tstamp_l; +} + +header int_egress_tstamp_t { + bit<32> egress_tstamp_h; + bit<32> egress_tstamp_l; +} + +header int_level2_port_ids_t { + bit<16> ingress_port_id; + bit<16> egress_port_id; +} + +header int_egress_port_tx_util_t { + bit<32> egress_port_tx_util; +} + +header influx_t { + bit<32> srcAddr; + bit<32> dstAddr; + bit<16> ingress_port_id; + bit<16> egress_port_id; + bit<8> meta_len; + bit<3> resv1; + bit<5> hop_meta_len; + bit<16> rsvd2; + bit<32> ndk_tstamp_h; + bit<32> ndk_tstamp_l; + bit<32> delay_h; + bit<32> delay_l; + bit<32> seq; +} + + +struct layer34_metadata_t { + bit<16> l4_src; + bit<16> l4_dst; + bit<6> dscp; +} + +struct metadata { + bit<7> padding; + bit<32> ingress_tstamp_system_h; + bit<32> ingress_tstamp_system_l; + bit<32> egress_tstamp_system_h; + bit<32> egress_tstamp_system_l; + layer34_metadata_t layer34_metadata; +} + +struct headers { + +// normal headers + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; + udp_t udp; + + +// INT headers + intl4_shim_t int_shim; + int_header_t int_header; + + +// local INT node metadata + int_egress_port_tx_util_t int_egress_port_tx_util; + int_egress_tstamp_t int_egress_tstamp; + int_hop_latency_t int_hop_latency; + int_ingress_tstamp_t int_ingress_tstamp; + int_port_ids_t int_port_ids; + int_level2_port_ids_t int_level2_port_ids; + int_q_occupancy_t int_q_occupancy; + int_switch_id_t int_switch_id; + + +// INT Sink export header + influx_t influx; +} + +#endif + + + +error +{ + INTShimLenTooShort, + INTVersionNotSupported +} + +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + state start { + transition parse_ethernet; + } + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + 16w0x800: parse_ipv4; + default: accept; + } + } + state parse_ipv4 { + packet.extract(hdr.ipv4); + meta.layer34_metadata.dscp = hdr.ipv4.dscp; + transition select(hdr.ipv4.protocol) { + 8w0x11: parse_udp; + 8w0x6: parse_tcp; + default: accept; + } + } + state parse_tcp { + packet.extract(hdr.tcp); + meta.layer34_metadata.l4_src = hdr.tcp.srcPort; + meta.layer34_metadata.l4_dst = hdr.tcp.dstPort; + transition select(meta.layer34_metadata.dscp) { + IPv4_DSCP_INT: parse_int_shim; + default: accept; + } + } + state parse_udp { + packet.extract(hdr.udp); + meta.layer34_metadata.l4_src = hdr.udp.srcPort; + meta.layer34_metadata.l4_dst = hdr.udp.dstPort; + transition select(meta.layer34_metadata.dscp) { + IPv4_DSCP_INT: parse_int_shim; + default: accept; + } + } + state parse_int_shim { + packet.extract(hdr.int_shim); + verify(hdr.int_shim.len >= 3, error.INTShimLenTooShort); + transition parse_int_header; + } + state parse_int_header { + packet.extract(hdr.int_header); + verify(hdr.int_header.ver == INT_VERSION, error.INTVersionNotSupported); + transition accept; + } +} + + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + +// original headers + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.udp); + packet.emit(hdr.tcp); + + +// INT headers + packet.emit(hdr.int_shim); + packet.emit(hdr.int_header); + + +// local INT node metadata + packet.emit(hdr.int_switch_id); + +// bit 1 + packet.emit(hdr.int_port_ids); + +// bit 2 + packet.emit(hdr.int_hop_latency); + +// bit 3 + packet.emit(hdr.int_q_occupancy); + +// bit 4 + packet.emit(hdr.int_ingress_tstamp); + +// bit 5 + packet.emit(hdr.int_egress_tstamp); + +// bit 6 + packet.emit(hdr.int_level2_port_ids); + +// bit 7 + packet.emit(hdr.int_egress_port_tx_util); + +// bit 8 + + packet.emit(hdr.influx); + } +} + +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + + + + +control Int_source(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + + register>(1) reg1; + + action configure_source() { + hdr.int_shim.setValid(); + hdr.int_shim.int_type = INT_TYPE_HOP_BY_HOP; + hdr.int_shim.len = (bit<8>)INT_ALL_HEADER_LEN_BYTES>>2; + + hdr.int_header.setValid(); + hdr.int_header.ver = INT_VERSION; + hdr.int_header.rep = 0; + hdr.int_header.c = 0; + hdr.int_header.e = 0; + hdr.int_header.rsvd1 = 1; + hdr.int_header.rsvd2 = 0; + hdr.int_header.hop_metadata_len = 0x06; + hdr.int_header.remaining_hop_cnt = 0xff; + +// will be decreased immediately by 1 within transit process + hdr.int_header.instruction_mask = 0x00cc; + + + reg1.read(hdr.int_header.seq, 0); + reg1.write(0, hdr.int_header.seq); + + reg1.read(hdr.int_header.seq, 0); + hdr.int_header.seq = hdr.int_header.seq + 1; + reg1.write(0, hdr.int_header.seq); + + hdr.int_shim.dscp = hdr.ipv4.dscp; + + hdr.ipv4.dscp = IPv4_DSCP_INT; + +// indicates that INT header in the packet + hdr.ipv4.totalLen = hdr.ipv4.totalLen + INT_ALL_HEADER_LEN_BYTES; + +// adding size of INT headers + + hdr.udp.len = hdr.udp.len + INT_ALL_HEADER_LEN_BYTES; + hdr.udp.csum = 0; + hdr.tcp.csum = 0; + } + + + table tb_int_source { + actions = { + configure_source; + } + key = { + hdr.ipv4.srcAddr : ternary; + hdr.ipv4.dstAddr : ternary; + meta.layer34_metadata.l4_src: ternary; + meta.layer34_metadata.l4_dst: ternary; + } + size = 128; + default_action = configure_source(); + + } + + apply { + if (SRC_ENABLE) + tb_int_source.apply(); + } +} + + + + +control Int_transit(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + action int_set_header_0() { + hdr.int_switch_id.setValid(); + hdr.int_switch_id.switch_id = SWITCH_ID; + } + action int_set_header_1() { + hdr.int_port_ids.setValid(); + hdr.int_port_ids.ingress_port_id = (bit<16>)standard_metadata.ingress_port; + hdr.int_port_ids.egress_port_id = (bit<16>)standard_metadata.egress_port; + } + action int_set_header_2() { + hdr.int_hop_latency.setValid(); + hdr.int_hop_latency.hop_latency = 0; + + } + action int_set_header_3() { + hdr.int_q_occupancy.setValid(); + hdr.int_q_occupancy.q_id = 0; + +// qid not defined in v1model + hdr.int_q_occupancy.q_occupancy = (bit<24>)standard_metadata.enq_qdepth; + } + action int_set_header_4() { + hdr.int_ingress_tstamp.setValid(); + hdr.int_ingress_tstamp.ingress_tstamp_h = meta.ingress_tstamp_system_h; + hdr.int_ingress_tstamp.ingress_tstamp_l = meta.ingress_tstamp_system_l; + } + action int_set_header_5() { + hdr.int_egress_tstamp.setValid(); + hdr.int_egress_tstamp.egress_tstamp_h = meta.egress_tstamp_system_h; + hdr.int_egress_tstamp.egress_tstamp_l = meta.egress_tstamp_system_l; + } + action int_set_header_6() { + hdr.int_level2_port_ids.setValid(); + hdr.int_level2_port_ids.ingress_port_id = 0; + hdr.int_level2_port_ids.egress_port_id = 0; + } + action int_set_header_7() { + hdr.int_egress_port_tx_util.setValid(); + hdr.int_egress_port_tx_util.egress_port_tx_util = 0; + } + + action int_hop_cnt_increment() { + hdr.int_header.remaining_hop_cnt = hdr.int_header.remaining_hop_cnt - 1; + } + action int_hop_exceeded() { + hdr.int_header.e = 1w1; + } + + + + apply { + if (!SINK_ENABLE) { + +// INT transit must process only INT packets + if (!hdr.int_header.isValid()) + return; + + int_set_header_0(); + int_set_header_1(); + int_set_header_4(); + int_set_header_5(); + + hdr.ipv4.totalLen = hdr.ipv4.totalLen + 24; + + hdr.udp.len = hdr.udp.len + 24; + hdr.int_shim.len = hdr.int_shim.len + 6; + + int_hop_cnt_increment(); + } + } +} + + + +control Int_sink(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + action fill_influx() { + hdr.influx.srcAddr = hdr.ipv4.srcAddr; + hdr.influx.dstAddr = hdr.ipv4.dstAddr; + hdr.influx.ndk_tstamp_h = meta.ingress_tstamp_system_h; + hdr.influx.ndk_tstamp_l = meta.ingress_tstamp_system_l; + hdr.influx.delay_h = meta.ingress_tstamp_system_h; + hdr.influx.delay_l = meta.ingress_tstamp_system_l; + hdr.influx.hop_meta_len = hdr.int_header.hop_metadata_len; + hdr.influx.meta_len = hdr.int_shim.len - 3; + + hdr.ethernet.etherType = 0xffff; + hdr.ipv4.setInvalid(); + hdr.int_shim.setInvalid(); + hdr.int_header.setInvalid(); + } + + action remove_tcp() { + hdr.influx.setValid(); + hdr.influx.seq = hdr.tcp.seqNum; + hdr.influx.ingress_port_id = hdr.tcp.srcPort; + hdr.influx.egress_port_id = hdr.tcp.dstPort; + hdr.tcp.setInvalid(); + } + + action remove_udp() { + hdr.influx.setValid(); + hdr.influx.seq = 0; + hdr.influx.ingress_port_id = hdr.udp.srcPort; + hdr.influx.egress_port_id = hdr.udp.dstPort; + hdr.udp.setInvalid(); + } + + action drop() { + mark_to_drop(standard_metadata); + } + + apply { + if (SINK_ENABLE) { + if (hdr.tcp.isValid()) + remove_tcp(); + else if (hdr.udp.isValid()) + remove_udp(); + else + drop(); + + fill_influx(); + } + } +} + + + +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t ig_intr_md) { + action ip_checksum_sub(bit<16> value) { + hdr.ipv4.checksum = ~hdr.ipv4.checksum; + if (hdr.ipv4.checksum < value) + hdr.ipv4.checksum = hdr.ipv4.checksum - 1; + hdr.ipv4.checksum = hdr.ipv4.checksum - value; + hdr.ipv4.checksum = ~hdr.ipv4.checksum; + } + + action ip_checksum_add(bit<16> value) { + hdr.ipv4.checksum = ~hdr.ipv4.checksum; + hdr.ipv4.checksum = hdr.ipv4.checksum + value; + if (hdr.ipv4.checksum < value) + hdr.ipv4.checksum = hdr.ipv4.checksum + 1; + hdr.ipv4.checksum = ~hdr.ipv4.checksum; + } + + apply { + if (!hdr.udp.isValid() && !hdr.tcp.isValid()) + exit; + + ip_checksum_sub(hdr.ipv4.totalLen); + ip_checksum_sub(hdr.ipv4.version ++ hdr.ipv4.ihl ++ hdr.ipv4.dscp ++ hdr.ipv4.ecn); + + Int_source.apply(hdr, meta, ig_intr_md); + Int_transit.apply(hdr, meta, ig_intr_md); + + ip_checksum_add(hdr.ipv4.totalLen); + ip_checksum_add(hdr.ipv4.version ++ hdr.ipv4.ihl ++ hdr.ipv4.dscp ++ hdr.ipv4.ecn); + + Int_sink.apply(hdr, meta, ig_intr_md); + } +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t eg_intr_md) { + apply { + hdr.int_egress_tstamp.egress_tstamp_h = meta.egress_tstamp_system_h; + hdr.int_egress_tstamp.egress_tstamp_l = meta.egress_tstamp_system_l; + } +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main; diff --git a/individual_files/000085__raw-repositories__guimvmatos__P4_RED.p4 b/individual_files/000085__raw-repositories__guimvmatos__P4_RED.p4 new file mode 100644 index 0000000000000000000000000000000000000000..2bab12d2a3678114734de455357280d99faea9b9 --- /dev/null +++ b/individual_files/000085__raw-repositories__guimvmatos__P4_RED.p4 @@ -0,0 +1,218 @@ +#include +#include + +const bit<8> TCP_PROTOCOL = 0x06; +const bit<16> TYPE_IPV4 = 0x800; +const bit<19> ECN_THRESHOLD = 10; +const bit<19> Wq = 10; +const bit<19> MinTh = 32; +const bit<19> MaxTh = 50; + + +#define REGISTER_LENGTH 100 + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> diffserv; + bit<2> ecn; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct metadata { +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + + + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + } + size = 1024; + default_action = drop; + } + + apply { + if (hdr.ipv4.isValid()) { + + ipv4_lpm.apply(); + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + register>(REGISTER_LENGTH) avg_r; + register>(1) dp_r; + + apply { + + + + + bit<32>reg_pos_zero = 0; + bit<19> queue_size_now = standard_metadata.enq_qdepth; + bit<19> Old_AVG; + avg_r.read(Old_AVG,reg_pos_zero); + bit<19> new_AVG = (Old_AVG*98)+(queue_size_now*2); + avg_r.write(reg_pos_zero,new_AVG); + + + if (new_AVG > MinTh && new_AVG < MaxTh) { + bit<32> pos_zero = 0; + bit<11> drop_prob_read = 0; + dp_r.read(drop_prob_read,pos_zero); + if (drop_prob_read == 0){ + drop_prob_read = 1; + }; + bit<11> drop_prob_write = drop_prob_read * 2; + dp_r.write(pos_zero,drop_prob_write); + bit<11> rand_val; + random>(rand_val, 0, 16); + if (drop_prob_write > rand_val){ + drop(); + } + } + + if (new_AVG > MaxTh) { + drop(); + } + + + + + } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.ecn, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000086__raw-repositories__FredShi97__p4.p4 b/individual_files/000086__raw-repositories__FredShi97__p4.p4 new file mode 100644 index 0000000000000000000000000000000000000000..a00a0794252614b56077fd7944abd1650dc3d9c3 --- /dev/null +++ b/individual_files/000086__raw-repositories__FredShi97__p4.p4 @@ -0,0 +1,1127 @@ +#include + +#define V1MODEL_VERSION 20200408 +#include + + + +#ifndef __DEFINE__ +#define __DEFINE__ + + + +#define CPU_PORT 255 + + +#define CPU_CLONE_SESSION_ID 99 + + +// Table sizes to be tuned for hardware +#define MAX_PDRS 1024 +#define MAX_APP_METERS 1024 +#define MAX_SESSION_METERS 1024 +#define MAX_ROUTES 1024 + + + +// Some sizes +#define ETH_HDR_SIZE 14 +#define IPV4_HDR_SIZE 20 +#define IPV4_MIN_IHL 5 +#define UDP_HDR_SIZE 8 +#define GTP_HDR_MIN_SIZE 8 +#define GTPU_OPTIONS_HDR_BYTES 4 +#define GTPU_EXT_PSC_HDR_BYTES 4 +#define SLICE_ID_WIDTH 4 +#define TC_WIDTH 2 +#define SLICE_TC_WIDTH 6 + +// Some field values that would be excessive as enums +const bit<4> IP_VERSION_4 = 4; +const bit<8> DEFAULT_IPV4_TTL = 64; + +typedef bit<48> mac_addr_t; +typedef bit<32> ipv4_addr_t; +typedef bit<16> l4_port_t; +typedef bit<8> ip_proto_t; +typedef bit<16> eth_type_t; + +const bit<16> UDP_PORT_GTPU = 2152; +const bit<3> GTP_V1 = 0x1; +const bit<1> GTP_PROTOCOL_TYPE_GTP = 0x1; +const bit<8> GTP_MESSAGE_TYPE_UPDU = 0xff; +const bit<8> GTPU_NEXT_EXT_NONE = 0x0; +const bit<8> GTPU_NEXT_EXT_PSC = 0x85; +const bit<4> GTPU_EXT_PSC_TYPE_DL = 4w0; + +// Downlink +const bit<4> GTPU_EXT_PSC_TYPE_UL = 4w1; + +// Uplink +const bit<8> GTPU_EXT_PSC_LEN = 8w1; + +// 1*4-octets + +typedef bit<32> teid_t; +typedef bit<6> qfi_t; +typedef bit<32> counter_index_t; +typedef bit<8> tunnel_peer_id_t; +typedef bit<32> app_meter_idx_t; +typedef bit<32> session_meter_idx_t; +typedef bit slice_tc_meter_idx_t; + +typedef bit slice_id_t; +typedef bit tc_t; + +// Traffic Class (for QoS) within a slice + +const qfi_t DEFAULT_QFI = 0; + + +// Signal that NO application ID has been set +const bit<8> APP_ID_UNKNOWN = 0; + +const session_meter_idx_t DEFAULT_SESSION_METER_IDX = 0; +const app_meter_idx_t DEFAULT_APP_METER_IDX = 0; + + + +enum bit<8> GTPUMessageType { + GPDU = 255 +} + +enum bit<16> EtherType { + IPV4 = 0x0800, + IPV6 = 0x86dd + +// unused +} + +enum bit<8> IpProtocol { + ICMP = 1, + TCP = 6, + UDP = 17 +} + +enum bit<16> L4Port { + DHCP_SERV = 67, + + DHCP_CLIENT = 68, + GTP_GPDU = 2152, + IPV4_IN_UDP = 9875 + +// placeholder. port has not yet been assigned by IANA +} + +enum bit<8> Direction { + UNKNOWN = 0x0, + UPLINK = 0x1, + DOWNLINK = 0x2, + OTHER = 0x3 +}; + +enum bit<8> InterfaceType { + UNKNOWN = 0x0, + ACCESS = 0x1, + CORE = 0x2 +} + +enum bit<4> Slice { + DEFAULT = 0x0 +} + +enum bit<2> TrafficClass { + BEST_EFFORT = 0, + CONTROL = 1, + REAL_TIME = 2, + ELASTIC = 3 +} + +enum bit<2> MeterColor { + GREEN = V1MODEL_METER_COLOR_GREEN, + YELLOW = V1MODEL_METER_COLOR_YELLOW, + RED = V1MODEL_METER_COLOR_RED +} + +#endif + + +#ifndef __HEADERS__ +#define __HEADERS__ + + + + +header ethernet_t { + mac_addr_t dst_addr; + mac_addr_t src_addr; + eth_type_t ether_type; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<6> dscp; + bit<2> ecn; + bit<16> total_len; + bit<16> identification; + bit<3> flags; + bit<13> frag_offset; + bit<8> ttl; + ip_proto_t proto; + bit<16> checksum; + ipv4_addr_t src_addr; + ipv4_addr_t dst_addr; +} + +header tcp_t { + l4_port_t sport; + l4_port_t dport; + bit<32> seq_no; + bit<32> ack_no; + bit<4> data_offset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgent_ptr; +} + +header udp_t { + l4_port_t sport; + l4_port_t dport; + bit<16> len; + bit<16> checksum; +} + +header icmp_t { + bit<8> icmp_type; + bit<8> icmp_code; + bit<16> checksum; + bit<16> identifier; + bit<16> sequence_number; + bit<64> timestamp; +} + +header gtpu_t { + bit<3> version; /* version */ + bit<1> pt; /* protocol type */ + bit<1> spare; /* reserved */ + bit<1> ex_flag; /* next extension hdr present? */ + bit<1> seq_flag; /* sequence no. */ + bit<1> npdu_flag; /* n-pdn number present ? */ + bit<8> msgtype; /* message type */ + bit<16> msglen; /* message length */ + teid_t teid; /* tunnel endpoint id */ +} + + +header gtpu_options_t { + bit<16> seq_num; /* Sequence number */ + bit<8> n_pdu_num; /* N-PDU number */ + bit<8> next_ext; /* Next extension header */ +} + + +header gtpu_ext_psc_t { + bit<8> len; /* Length in 4-octet units (common to all extensions) */ + bit<4> type; /* Uplink or downlink */ + bit<4> spare0; /* Reserved */ + bit<1> ppp; /* Paging Policy Presence (UL only, not supported) */ + bit<1> rqi; /* Reflective QoS Indicator (UL only) */ + bit<6> qfi; /* QoS Flow Identifier */ + bit<8> next_ext; +} + +@controller_header("packet_out") +header packet_out_t { + bit<8> reserved; + +// Not used +} + +@controller_header("packet_in") +header packet_in_t { + PortId_t ingress_port; + bit<7> _pad; +} + + +struct parsed_headers_t { + packet_out_t packet_out; + packet_in_t packet_in; + ethernet_t ethernet; + ipv4_t ipv4; + udp_t udp; + tcp_t tcp; + icmp_t icmp; + gtpu_t gtpu; + gtpu_options_t gtpu_options; + gtpu_ext_psc_t gtpu_ext_psc; + ipv4_t inner_ipv4; + udp_t inner_udp; + tcp_t inner_tcp; + icmp_t inner_icmp; +} + + + +struct ddn_digest_t { + ipv4_addr_t ue_address; +} + + +// The primary metadata structure. +struct local_metadata_t { + Direction direction; + + teid_t teid; + + slice_id_t slice_id; + tc_t tc; + + ipv4_addr_t next_hop_ip; + + ipv4_addr_t ue_addr; + ipv4_addr_t inet_addr; + l4_port_t ue_l4_port; + l4_port_t inet_l4_port; + + l4_port_t l4_sport; + l4_port_t l4_dport; + + ip_proto_t ip_proto; + + bit<8> application_id; + + bit<8> src_iface; + bool needs_gtpu_decap; + bool needs_tunneling; + bool needs_buffering; + bool needs_dropping; + bool terminations_hit; + + counter_index_t ctr_idx; + + tunnel_peer_id_t tunnel_peer_id; + + +// GTP tunnel out parameters + ipv4_addr_t tunnel_out_src_ipv4_addr; + ipv4_addr_t tunnel_out_dst_ipv4_addr; + l4_port_t tunnel_out_udp_sport; + teid_t tunnel_out_teid; + qfi_t tunnel_out_qfi; + + session_meter_idx_t session_meter_idx_internal; + app_meter_idx_t app_meter_idx_internal; + MeterColor session_color; + MeterColor app_color; + MeterColor slice_tc_color; + + @field_list(0) + PortId_t preserved_ingress_port; +} + +#endif + + + +#ifndef __PARSER__ +#define __PARSER__ + + + + + +parser ParserImpl (packet_in packet, + out parsed_headers_t hdr, + inout local_metadata_t local_meta, + inout standard_metadata_t std_meta) +{ + + + state start { + transition select(std_meta.ingress_port) { + CPU_PORT: parse_packet_out; + default: parse_ethernet; + } + } + + state parse_packet_out { + packet.extract(hdr.packet_out); + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.ether_type){ + EtherType.IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.proto) { + IpProtocol.UDP: parse_udp; + IpProtocol.TCP: parse_tcp; + IpProtocol.ICMP: parse_icmp; + default: accept; + } + } + + +// Eventualy add VLAN header parsing + + state parse_udp { + packet.extract(hdr.udp); + +// note: this eventually wont work + local_meta.l4_sport = hdr.udp.sport; + local_meta.l4_dport = hdr.udp.dport; + gtpu_t gtpu = packet.lookahead(); + transition select(hdr.udp.dport, gtpu.version, gtpu.msgtype) { + (L4Port.IPV4_IN_UDP, _, _): parse_inner_ipv4; + +// Treat GTP control traffic as payload. + (L4Port.GTP_GPDU, GTP_V1, GTPUMessageType.GPDU): parse_gtpu; + default: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + local_meta.l4_sport = hdr.tcp.sport; + local_meta.l4_dport = hdr.tcp.dport; + transition accept; + } + + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } + + state parse_gtpu { + packet.extract(hdr.gtpu); + local_meta.teid = hdr.gtpu.teid; + transition select(hdr.gtpu.ex_flag, hdr.gtpu.seq_flag, hdr.gtpu.npdu_flag) { + (0, 0, 0): parse_inner_ipv4; + default: parse_gtpu_options; + } + } + + state parse_gtpu_options { + packet.extract(hdr.gtpu_options); + bit<8> gtpu_ext_len = packet.lookahead>(); + transition select(hdr.gtpu_options.next_ext, gtpu_ext_len) { + (GTPU_NEXT_EXT_PSC, GTPU_EXT_PSC_LEN): parse_gtpu_ext_psc; + default: accept; + } + } + + state parse_gtpu_ext_psc { + packet.extract(hdr.gtpu_ext_psc); + transition select(hdr.gtpu_ext_psc.next_ext) { + GTPU_NEXT_EXT_NONE: parse_inner_ipv4; + default: accept; + } + } + + + + state parse_inner_ipv4 { + packet.extract(hdr.inner_ipv4); + transition select(hdr.inner_ipv4.proto) { + IpProtocol.UDP: parse_inner_udp; + IpProtocol.TCP: parse_inner_tcp; + IpProtocol.ICMP: parse_inner_icmp; + default: accept; + } + } + + state parse_inner_udp { + packet.extract(hdr.inner_udp); + local_meta.l4_sport = hdr.inner_udp.sport; + local_meta.l4_dport = hdr.inner_udp.dport; + transition accept; + } + + state parse_inner_tcp { + packet.extract(hdr.inner_tcp); + local_meta.l4_sport = hdr.inner_tcp.sport; + local_meta.l4_dport = hdr.inner_tcp.dport; + transition accept; + } + + state parse_inner_icmp { + packet.extract(hdr.inner_icmp); + transition accept; + } +} + + +control DeparserImpl(packet_out packet, in parsed_headers_t hdr) { + apply { + packet.emit(hdr.packet_in); + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.udp); + packet.emit(hdr.tcp); + packet.emit(hdr.icmp); + packet.emit(hdr.gtpu); + packet.emit(hdr.gtpu_options); + packet.emit(hdr.gtpu_ext_psc); + packet.emit(hdr.inner_ipv4); + packet.emit(hdr.inner_udp); + packet.emit(hdr.inner_tcp); + packet.emit(hdr.inner_icmp); + } +} + + +#endif + + + +#ifndef __CHECKSUM__ +#define __CHECKSUM__ + + + + +control VerifyChecksumImpl(inout parsed_headers_t hdr, + inout local_metadata_t meta) +{ + apply { + verify_checksum(hdr.ipv4.isValid(), + { + hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.ecn, + hdr.ipv4.total_len, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.frag_offset, + hdr.ipv4.ttl, + hdr.ipv4.proto, + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr + }, + hdr.ipv4.checksum, + HashAlgorithm.csum16 + ); + verify_checksum(hdr.inner_ipv4.isValid(), + { + hdr.inner_ipv4.version, + hdr.inner_ipv4.ihl, + hdr.inner_ipv4.dscp, + hdr.inner_ipv4.ecn, + hdr.inner_ipv4.total_len, + hdr.inner_ipv4.identification, + hdr.inner_ipv4.flags, + hdr.inner_ipv4.frag_offset, + hdr.inner_ipv4.ttl, + hdr.inner_ipv4.proto, + hdr.inner_ipv4.src_addr, + hdr.inner_ipv4.dst_addr + }, + hdr.inner_ipv4.checksum, + HashAlgorithm.csum16 + ); + + } +} + + +control ComputeChecksumImpl(inout parsed_headers_t hdr, + inout local_metadata_t local_meta) +{ + apply { + +// Compute Outer IPv4 checksum + update_checksum(hdr.ipv4.isValid(),{ + hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.dscp, + hdr.ipv4.ecn, + hdr.ipv4.total_len, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.frag_offset, + hdr.ipv4.ttl, + hdr.ipv4.proto, + hdr.ipv4.src_addr, + hdr.ipv4.dst_addr + }, + hdr.ipv4.checksum, + HashAlgorithm.csum16 + ); + + + + +// Compute IPv4 checksum + update_checksum(hdr.inner_ipv4.isValid(),{ + hdr.inner_ipv4.version, + hdr.inner_ipv4.ihl, + hdr.inner_ipv4.dscp, + hdr.inner_ipv4.ecn, + hdr.inner_ipv4.total_len, + hdr.inner_ipv4.identification, + hdr.inner_ipv4.flags, + hdr.inner_ipv4.frag_offset, + hdr.inner_ipv4.ttl, + hdr.inner_ipv4.proto, + hdr.inner_ipv4.src_addr, + hdr.inner_ipv4.dst_addr + }, + hdr.inner_ipv4.checksum, + HashAlgorithm.csum16 + ); + } +} + +#endif + + + +control Acl( + inout parsed_headers_t hdr, + inout local_metadata_t local_meta, + inout standard_metadata_t std_meta) { + + action set_port(PortId_t port) { + std_meta.egress_spec = port; + } + + action punt() { + set_port(CPU_PORT); + } + + action clone_to_cpu() { + + ; + } + + action drop() { + mark_to_drop(std_meta); + exit; + } + + table acls { + key = { + std_meta.ingress_port : ternary @name("inport"); + local_meta.src_iface : ternary @name("src_iface"); + hdr.ethernet.src_addr : ternary @name("eth_src"); + hdr.ethernet.dst_addr : ternary @name("eth_dst"); + hdr.ethernet.ether_type : ternary @name("eth_type"); + hdr.ipv4.src_addr : ternary @name("ipv4_src"); + hdr.ipv4.dst_addr : ternary @name("ipv4_dst"); + hdr.ipv4.proto : ternary @name("ipv4_proto"); + local_meta.l4_sport : ternary @name("l4_sport"); + local_meta.l4_dport : ternary @name("l4_dport"); + } + actions = { + set_port; + punt; + clone_to_cpu; + drop; + NoAction; + } + const default_action = NoAction; + @name("acls") + counters = direct_counter(CounterType.packets_and_bytes); + } + + apply { + acls.apply(); + } +} + + +control Routing(inout parsed_headers_t hdr, + inout local_metadata_t local_meta, + inout standard_metadata_t std_meta) { + action drop() { + mark_to_drop(std_meta); + } + + action route(mac_addr_t src_mac, + mac_addr_t dst_mac, + PortId_t egress_port) { + std_meta.egress_spec = egress_port; + hdr.ethernet.src_addr = src_mac; + hdr.ethernet.dst_addr = dst_mac; + } + + table routes_v4 { + key = { + hdr.ipv4.dst_addr : lpm @name("dst_prefix"); + } + actions = { + route; + NoAction; + + } + const default_action = NoAction; + size = 1024; + } + + apply { + + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + if (hdr.ipv4.ttl == 0) { + drop(); + } + else { + routes_v4.apply(); + } + } +} + + +control PreQosPipe (inout parsed_headers_t hdr, + inout local_metadata_t local_meta, + inout standard_metadata_t std_meta) { + + + counter(MAX_PDRS, CounterType.packets_and_bytes) pre_qos_counter; + meter(MAX_APP_METERS, MeterType.bytes) app_meter; + meter(MAX_SESSION_METERS, MeterType.bytes) session_meter; + meter(1 << SLICE_TC_WIDTH, MeterType.bytes) slice_tc_meter; + + action _initialize_metadata() { + local_meta.session_meter_idx_internal = DEFAULT_SESSION_METER_IDX; + local_meta.app_meter_idx_internal = DEFAULT_APP_METER_IDX; + local_meta.application_id = APP_ID_UNKNOWN; + local_meta.preserved_ingress_port = std_meta.ingress_port; + } + + table my_station { + key = { + hdr.ethernet.dst_addr : exact @name("dst_mac"); + } + actions = { + NoAction; + } + } + + action set_source_iface(InterfaceType src_iface, Direction direction, slice_id_t slice_id) { + + local_meta.src_iface = src_iface; + local_meta.direction = direction; + local_meta.slice_id = slice_id; + } + table interfaces { + key = { + hdr.ipv4.dst_addr : lpm @name("ipv4_dst_prefix"); + } + actions = { + set_source_iface; + } + const default_action = set_source_iface(InterfaceType.UNKNOWN, Direction.UNKNOWN, Slice.DEFAULT); + } + + @hidden + action gtpu_decap() { + hdr.ipv4 = hdr.inner_ipv4; + hdr.inner_ipv4.setInvalid(); + hdr.udp = hdr.inner_udp; + hdr.inner_udp.setInvalid(); + hdr.tcp = hdr.inner_tcp; + hdr.inner_tcp.setInvalid(); + hdr.icmp = hdr.inner_icmp; + hdr.inner_icmp.setInvalid(); + hdr.gtpu.setInvalid(); + hdr.gtpu_options.setInvalid(); + hdr.gtpu_ext_psc.setInvalid(); + } + + @hidden + action do_buffer() { + + digest(1, { local_meta.ue_addr }); + +// The actual buffering cannot be expressed in the logical pipeline. + mark_to_drop(std_meta); + exit; + } + + action do_drop() { + mark_to_drop(std_meta); + exit; + } + + action set_session_uplink(session_meter_idx_t session_meter_idx) { + local_meta.needs_gtpu_decap = true; + local_meta.session_meter_idx_internal = session_meter_idx; + } + + action set_session_uplink_drop() { + local_meta.needs_dropping = true; + } + + action set_session_downlink(tunnel_peer_id_t tunnel_peer_id, session_meter_idx_t session_meter_idx) { + local_meta.tunnel_peer_id = tunnel_peer_id; + local_meta.session_meter_idx_internal = session_meter_idx; + } + action set_session_downlink_drop() { + local_meta.needs_dropping = true; + } + + action set_session_downlink_buff(session_meter_idx_t session_meter_idx) { + local_meta.needs_buffering = true; + local_meta.session_meter_idx_internal = session_meter_idx; + } + + table sessions_uplink { + key = { + hdr.ipv4.dst_addr : exact @name("n3_address"); + local_meta.teid : exact @name("teid"); + } + actions = { + set_session_uplink; + set_session_uplink_drop; + @defaultonly do_drop; + } + const default_action = do_drop; + } + + table sessions_downlink { + key = { + hdr.ipv4.dst_addr : exact @name("ue_address"); + } + actions = { + set_session_downlink; + set_session_downlink_drop; + set_session_downlink_buff; + @defaultonly do_drop; + } + const default_action = do_drop; + } + + @hidden + action common_term(counter_index_t ctr_idx) { + local_meta.ctr_idx = ctr_idx; + local_meta.terminations_hit = true; + } + + action uplink_term_fwd(counter_index_t ctr_idx, TrafficClass tc, app_meter_idx_t app_meter_idx) { + common_term(ctr_idx); + local_meta.app_meter_idx_internal = app_meter_idx; + local_meta.tc = tc; + } + + action uplink_term_drop(counter_index_t ctr_idx) { + common_term(ctr_idx); + local_meta.needs_dropping = true; + } + + + action downlink_term_fwd(counter_index_t ctr_idx, teid_t teid, qfi_t qfi, TrafficClass tc, app_meter_idx_t app_meter_idx) { + common_term(ctr_idx); + local_meta.tunnel_out_teid = teid; + local_meta.tunnel_out_qfi = qfi; + local_meta.app_meter_idx_internal = app_meter_idx; + local_meta.tc = tc; + } + + action downlink_term_drop(counter_index_t ctr_idx) { + common_term(ctr_idx); + local_meta.needs_dropping = true; + } + + table terminations_uplink { + key = { + local_meta.ue_addr : exact @name("ue_address"); + +// Session ID + local_meta.application_id : exact @name("app_id"); + } + actions = { + uplink_term_fwd; + uplink_term_drop; + @defaultonly do_drop; + } + const default_action = do_drop; + } + + table terminations_downlink { + key = { + local_meta.ue_addr : exact @name("ue_address"); + +// Session ID + local_meta.application_id : exact @name("app_id"); + } + actions = { + downlink_term_fwd; + downlink_term_drop; + @defaultonly do_drop; + } + const default_action = do_drop; + } + + action set_app_id(bit<8> app_id) { + local_meta.application_id = app_id; + } + + table applications { + key = { + local_meta.slice_id : exact @name("slice_id"); + local_meta.inet_addr : lpm @name("app_ip_addr"); + local_meta.inet_l4_port : range @name("app_l4_port"); + local_meta.ip_proto : ternary @name("app_ip_proto"); + } + actions = { + set_app_id; + } + const default_action = set_app_id(APP_ID_UNKNOWN); + } + + action load_tunnel_param(ipv4_addr_t src_addr, + ipv4_addr_t dst_addr, + l4_port_t sport + ) { + local_meta.tunnel_out_src_ipv4_addr = src_addr; + local_meta.tunnel_out_dst_ipv4_addr = dst_addr; + local_meta.tunnel_out_udp_sport = sport; + local_meta.needs_tunneling = true; + } + + table tunnel_peers { + key = { + local_meta.tunnel_peer_id : exact @name("tunnel_peer_id"); + } + actions = { + load_tunnel_param; + } + } + + @hidden + action _udp_encap(ipv4_addr_t src_addr, ipv4_addr_t dst_addr, + l4_port_t udp_sport, l4_port_t udp_dport, + bit<16> ipv4_total_len, + bit<16> udp_len) { + hdr.inner_udp = hdr.udp; + hdr.udp.setInvalid(); + hdr.inner_tcp = hdr.tcp; + hdr.tcp.setInvalid(); + hdr.inner_icmp = hdr.icmp; + hdr.icmp.setInvalid(); + hdr.udp.setValid(); + hdr.udp.sport = udp_sport; + hdr.udp.dport = udp_dport; + hdr.udp.len = udp_len; + hdr.udp.checksum = 0; + +// Never updated due to p4 limitations + + hdr.inner_ipv4 = hdr.ipv4; + hdr.ipv4.setValid(); + hdr.ipv4.version = IP_VERSION_4; + hdr.ipv4.ihl = IPV4_MIN_IHL; + hdr.ipv4.dscp = 0; + hdr.ipv4.ecn = 0; + hdr.ipv4.total_len = ipv4_total_len; + hdr.ipv4.identification = 0x1513; + + hdr.ipv4.flags = 0; + hdr.ipv4.frag_offset = 0; + hdr.ipv4.ttl = DEFAULT_IPV4_TTL; + hdr.ipv4.proto = IpProtocol.UDP; + hdr.ipv4.src_addr = src_addr; + hdr.ipv4.dst_addr = dst_addr; + hdr.ipv4.checksum = 0; + +// Updated later + + + } + + @hidden + action _gtpu_encap(teid_t teid) { + hdr.gtpu.setValid(); + hdr.gtpu.version = GTP_V1; + hdr.gtpu.pt = GTP_PROTOCOL_TYPE_GTP; + hdr.gtpu.spare = 0; + hdr.gtpu.ex_flag = 0; + hdr.gtpu.seq_flag = 0; + hdr.gtpu.npdu_flag = 0; + hdr.gtpu.msgtype = GTPUMessageType.GPDU; + hdr.gtpu.msglen = hdr.inner_ipv4.total_len; + hdr.gtpu.teid = teid; + } + + action do_gtpu_tunnel() { + _udp_encap(local_meta.tunnel_out_src_ipv4_addr, + local_meta.tunnel_out_dst_ipv4_addr, + local_meta.tunnel_out_udp_sport, + L4Port.GTP_GPDU, + hdr.ipv4.total_len + IPV4_HDR_SIZE + UDP_HDR_SIZE + GTP_HDR_MIN_SIZE, + hdr.ipv4.total_len + UDP_HDR_SIZE + GTP_HDR_MIN_SIZE); + _gtpu_encap(local_meta.tunnel_out_teid); + } + + + action do_gtpu_tunnel_with_psc() { + _udp_encap(local_meta.tunnel_out_src_ipv4_addr, + local_meta.tunnel_out_dst_ipv4_addr, + local_meta.tunnel_out_udp_sport, + L4Port.GTP_GPDU, + hdr.ipv4.total_len + IPV4_HDR_SIZE + UDP_HDR_SIZE + GTP_HDR_MIN_SIZE + + GTPU_OPTIONS_HDR_BYTES + GTPU_EXT_PSC_HDR_BYTES, + hdr.ipv4.total_len + UDP_HDR_SIZE + GTP_HDR_MIN_SIZE + + GTPU_OPTIONS_HDR_BYTES + GTPU_EXT_PSC_HDR_BYTES); + _gtpu_encap(local_meta.tunnel_out_teid); + hdr.gtpu.msglen = hdr.inner_ipv4.total_len + GTPU_OPTIONS_HDR_BYTES + + GTPU_EXT_PSC_HDR_BYTES; + + hdr.gtpu.ex_flag = 1; + + hdr.gtpu_options.setValid(); + hdr.gtpu_options.seq_num = 0; + hdr.gtpu_options.n_pdu_num = 0; + hdr.gtpu_options.next_ext = GTPU_NEXT_EXT_PSC; + hdr.gtpu_ext_psc.setValid(); + hdr.gtpu_ext_psc.len = GTPU_EXT_PSC_LEN; + hdr.gtpu_ext_psc.type = GTPU_EXT_PSC_TYPE_DL; + hdr.gtpu_ext_psc.spare0 = 0; + hdr.gtpu_ext_psc.ppp = 0; + hdr.gtpu_ext_psc.rqi = 0; + hdr.gtpu_ext_psc.qfi = local_meta.tunnel_out_qfi; + hdr.gtpu_ext_psc.next_ext = GTPU_NEXT_EXT_NONE; + } + + + apply { + _initialize_metadata(); + if (hdr.packet_out.isValid()) { + + hdr.packet_out.setInvalid(); + } else { + +// Only process if the packet is destined for our MAC addr. We don't handle switching + if (!my_station.apply().hit) { + return; + } + + if (interfaces.apply().hit) { + +// Normalize so the UE address/port appear as the same field regardless of direction + if (local_meta.direction == Direction.UPLINK) { + local_meta.ue_addr = hdr.inner_ipv4.src_addr; + local_meta.inet_addr = hdr.inner_ipv4.dst_addr; + local_meta.ue_l4_port = local_meta.l4_sport; + local_meta.inet_l4_port = local_meta.l4_dport; + local_meta.ip_proto = hdr.inner_ipv4.proto; + + sessions_uplink.apply(); + } else if (local_meta.direction == Direction.DOWNLINK) { + local_meta.ue_addr = hdr.ipv4.dst_addr; + local_meta.inet_addr = hdr.ipv4.src_addr; + local_meta.ue_l4_port = local_meta.l4_dport; + local_meta.inet_l4_port = local_meta.l4_sport; + local_meta.ip_proto = hdr.ipv4.proto; + + sessions_downlink.apply(); + tunnel_peers.apply(); + } + + applications.apply(); + + if (local_meta.direction == Direction.UPLINK) { + terminations_uplink.apply(); + } else if (local_meta.direction == Direction.DOWNLINK) { + terminations_downlink.apply(); + } + + if (local_meta.terminations_hit) { + +// Count packets at a counter index unique to whichever termination matched. + pre_qos_counter.count(local_meta.ctr_idx); + } + + app_meter.execute_meter(local_meta.app_meter_idx_internal, local_meta.app_color); + if (local_meta.app_color == MeterColor.RED) { + local_meta.needs_dropping = true; + } else { + session_meter.execute_meter(local_meta.session_meter_idx_internal, local_meta.session_color); + if (local_meta.session_color == MeterColor.RED) { + local_meta.needs_dropping = true; + } else { + slice_tc_meter.execute_meter(local_meta.slice_id++local_meta.tc, local_meta.slice_tc_color); + if (local_meta.slice_tc_color == MeterColor.RED) { + local_meta.needs_dropping = true; + } + } + } + + + if (local_meta.needs_gtpu_decap) { + gtpu_decap(); + } + if (local_meta.needs_buffering) { + do_buffer(); + } + if (local_meta.needs_tunneling) { + if (local_meta.tunnel_out_qfi == 0) { + +// 4G + do_gtpu_tunnel(); + } else { + +// 5G + do_gtpu_tunnel_with_psc(); + } + } + if (local_meta.needs_dropping) { + do_drop(); + } + } + } + + + Routing.apply(hdr, local_meta, std_meta); + + +// Administrative override ACL is standard in network devices + Acl.apply(hdr, local_meta, std_meta); + } +} + + +control PostQosPipe (inout parsed_headers_t hdr, + inout local_metadata_t local_meta, + inout standard_metadata_t std_meta) { + + + counter(MAX_PDRS, CounterType.packets_and_bytes) post_qos_counter; + + apply { + + post_qos_counter.count(local_meta.ctr_idx); + + + if (std_meta.egress_port == CPU_PORT) { + + hdr.packet_in.setValid(); + hdr.packet_in.ingress_port = local_meta.preserved_ingress_port; + +// Exit the pipeline here. + exit; + } + } +} + + +V1Switch( + ParserImpl(), + VerifyChecksumImpl(), + PreQosPipe(), + PostQosPipe(), + ComputeChecksumImpl(), + DeparserImpl() +) main; diff --git a/individual_files/000087__raw-repositories__Hajdulord__p4-in-network-memory.p4 b/individual_files/000087__raw-repositories__Hajdulord__p4-in-network-memory.p4 new file mode 100644 index 0000000000000000000000000000000000000000..60fbffb7869c6d26ee6724e935a4ce95bba5af98 --- /dev/null +++ b/individual_files/000087__raw-repositories__Hajdulord__p4-in-network-memory.p4 @@ -0,0 +1,113 @@ +#include +#include + +#define MAX_ADDR 1024 + + +// Header struct for incoming packets +header ethernetHeader { + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + + +// the custom layer type for memory header +const bit<16> MEMORY_ETYPE = 0x1234; + +header memoryHeader { + bit<1> isWrite; + +// 1 for write, 0 for read + bit<32> address; + +// address of the registry + bit<32> data; + +// data to save + bit<7> padding; + +// padding to make the header a multiple of 8 +} + +struct headers { + ethernetHeader ethernet; + memoryHeader memory; +} + +struct metadata { + +/* In our case it is empty */ +} + + +// Register array +register>(MAX_ADDR) memory; + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + MEMORY_ETYPE: parse_memory; + default: accept; + } + } + + state parse_memory { + packet.extract(hdr.memory); + transition accept; + } +} + +control MyVerifyChecksum(inout headers hdr, + inout metadata meta) { + apply { } +} + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + if (hdr.memory.isWrite == 1) { + memory.write(hdr.memory.address, hdr.memory.data); + } else { + bit<32> read_data; + memory.read(read_data, hdr.memory.address); + hdr.memory.data = read_data; + + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + } +} + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.memory); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000088__raw-repositories__howlbz__Softwarized-and-Virtualized-Mobile-Networks.p4 b/individual_files/000088__raw-repositories__howlbz__Softwarized-and-Virtualized-Mobile-Networks.p4 new file mode 100644 index 0000000000000000000000000000000000000000..2ccc459f41d7ec623f79570103fc668e3ab2190d --- /dev/null +++ b/individual_files/000088__raw-repositories__howlbz__Softwarized-and-Virtualized-Mobile-Networks.p4 @@ -0,0 +1,284 @@ +#include +#include + +const bit<16> TYPE_IPV4 = 0x0800; +const bit<16> TYPE_ARP = 0x0806; +const bit<8> TYPE_UDP = 0x11; +const bit<8> TYPE_TCP = 0x06; +const bit<8> TYPE_ICMP = 0x01; + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +header arp_t { + bit<16> hrd; + +// Hardware Type + bit<16> pro; + +// Protocol Type + bit<8> hln; + +// Hardware Address Length + bit<8> pln; + +// Protocol Address Length + bit<16> op; + +// Opcode + macAddr_t sha; + +// Sender Hardware Address + ip4Addr_t spa; + +// Sender Protocol Address + macAddr_t tha; + +// Target Hardware Address + ip4Addr_t tpa; + +// Target Protocol Address +} + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<3> res; + bit<3> ecn; + bit<6> ctrl; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + arp_t arp; + udp_t udp; + tcp_t tcp; + icmp_t icmp; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + TYPE_ARP: parse_arp; + default: accept; + } + } + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + TYPE_UDP: parse_udp; + TYPE_TCP: parse_tcp; + TYPE_ICMP: parse_icmp; + + default : accept;} + } + + state parse_arp { + packet.extract(hdr.arp); + transition accept; + } + state parse_udp{ + packet.extract(hdr.udp); + transition accept; + } + + state parse_tcp{ + packet.extract(hdr.tcp); + transition accept; + } + + state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } +} + + + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action drop() { + mark_to_drop(standard_metadata); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + + action arp_process (ip4Addr_t target_ip, macAddr_t dstAddr) + { + hdr.arp.op = 2; + hdr.arp.tha = hdr.arp.sha; + hdr.arp.tpa = hdr.arp.spa; + hdr.arp.sha = dstAddr; + hdr.arp.spa = target_ip; + hdr.ethernet.srcAddr = dstAddr; + hdr.ethernet.dstAddr = hdr.arp.tha; + standard_metadata.egress_spec = standard_metadata.ingress_port; + } + + table arp_table { + key = { + hdr.arp.tpa: exact; + } + actions = { + arp_process; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + apply { + if (hdr.arp.isValid()) { + arp_table.apply(); + } + else{ + if (hdr.ipv4.isValid()) { + ipv4_lpm.apply(); + } + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + + + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.arp); + packet.emit(hdr.udp); + packet.emit(hdr.tcp); + packet.emit(hdr.icmp); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000089__raw-repositories__IETF-Hackathon__p4-ipv6-switch-ml.p4 b/individual_files/000089__raw-repositories__IETF-Hackathon__p4-ipv6-switch-ml.p4 new file mode 100644 index 0000000000000000000000000000000000000000..9cfeae439eeb6efd340ca0c17ba2137860312551 --- /dev/null +++ b/individual_files/000089__raw-repositories__IETF-Hackathon__p4-ipv6-switch-ml.p4 @@ -0,0 +1,342 @@ +#include + + +typedef bit<48> mac_addr_t; +typedef bit<128> ipv6_addr_t; +typedef bit<9> port_t; +const bit<16> TYPE_IPV6 = 0x86dd; +const bit<9> TYPE_CPU = 9w192; +const bit<8> PROTO_TCP = 6; +const bit<8> PROTO_UDP = 17; +const bit<8> PROTO_ICMP6 = 58; +const bit<8> TCP_SEQ_LEN = 4; +const bit<8> ICMP6_ECHO_REQUEST = 128; +const bit<8> ICMP6_ECHO_REPLY = 129; + +header ethernet_t { + mac_addr_t dstAddr; + mac_addr_t srcAddr; + bit<16> etherType; +} + +header ipv6_t { + bit<4> version; + bit<8> traffic_class; + bit<20> flow_label; + bit<16> payload_length; + bit<8> nextHdr; + bit<8> hopLimit; + ipv6_addr_t srcAddr; + ipv6_addr_t dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + int<32> seqNo; + int<32> ackNo; + bit<4> data_offset; + bit<4> res; + bit<1> cwr; + bit<1> ece; + bit<1> urg; + bit<1> ack; + bit<1> psh; + bit<1> rst; + bit<1> syn; + bit<1> fin; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header udp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +header icmp6_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + + +const bit<8> K = 20; + +// Number of Workers. +const bit<8> N = 10; + +// Number of integer aggregators +const bit<8> S = 128; + +// for 10G switch ports + +header count_t { + bit<8> cnt; +} + +header ml_hdr_t { + int<8> idx; +} + +header vec_e_t { + bit<32> e; +} + +header aggregator_t { + bit<32> val; +} + +struct headers { + ethernet_t inner_ethernet; + icmp6_t inner_icmp6; + ipv6_t inner_ipv6; + tcp_t inner_tcp; + udp_t inner_udp; + ethernet_t ethernet; + icmp6_t icmp6; + ipv6_t ipv6; + tcp_t tcp; + udp_t udp; + ml_hdr_t ml; + vec_e_t[K] vector; +} + +struct l3_metadata_t { + bit<2> lkp_ip_type; + bit<4> lkp_ip_version; + bit<8> lkp_ip_proto; + bit<8> lkp_dscp; + bit<8> lkp_ip_ttl; + bit<16> lkp_l4_sport; + bit<16> lkp_l4_dport; + bit<16> lkp_outer_l4_sport; + bit<16> lkp_outer_l4_dport; + bit<16> vrf; + bit<10> rmac_group; + bit<1> rmac_hit; + bit<2> urpf_mode; + bit<1> urpf_hit; + bit<1> urpf_check_fail; + bit<16> urpf_bd_group; + bit<1> fib_hit; + bit<16> fib_nexthop; + bit<2> fib_nexthop_type; + bit<16> same_bd_check; + bit<16> nexthop_index; + bit<1> routed; + bit<1> outer_routed; + bit<8> mtu_index; + bit<1> l3_copy; + bit<16> l3_mtu_check; + bit<16> egress_l4_sport; + bit<16> egress_l4_dport; +} + +struct tunnel_metadata_t { + bit<5> ingress_tunnel_type; + bit<24> tunnel_vni; + bit<5> egress_tunnel_type; + bit<14> tunnel_index; + bit<9> tunnel_src_index; + bit<9> tunnel_smac_index; + bit<14> tunnel_dst_index; + bit<14> tunnel_dmac_index; + bit<24> vnid; + bit<1> tunnel_terminate; + bit<1> tunnel_if_check; + bit<4> egress_header_count; + bit<8> inner_ip_proto; + bit<1> skip_encap_inner; +} + +struct l2_metadata_t { + bit<48> lkp_mac_sa; + bit<48> lkp_mac_da; + bit<3> lkp_pkt_type; + bit<16> lkp_mac_type; + bit<3> lkp_pcp; + bit<16> l2_nexthop; + bit<2> l2_nexthop_type; + bit<1> l2_redirect; + bit<1> l2_src_miss; + bit<16> l2_src_move; + bit<10> stp_group; + bit<3> stp_state; + bit<16> bd_stats_idx; + bit<1> learning_enabled; + bit<1> port_vlan_mapping_miss; + bit<16> same_if_check; +} + +struct ipv6_metadata_t { + bit<128> lkp_ipv6_sa; + bit<128> lkp_ipv6_da; + bit<1> ipv6_unicast_enabled; + bit<1> ipv6_src_is_link_local; + bit<2> ipv6_urpf_mode; +} + +struct acl_metadata_t { + bit<1> acl_deny; /* ifacl/vacl deny action */ + bit<24> vnid; /* vnid for acls */ + bit<14> acl_stats_index; /* acl stats index */ + bit<16> egress_if_label; /* if label for egress acls */ + bit<16> egress_bd_label; /* bd label for egress acls */ +} + +struct fwd_meta_t { + bit<32> l2ptr; + bit<24> out_bd; +} + +struct metadata_t { + port_t ingress_port; + port_t egress_port; + bit<16> tcp_length; + bit<32> cast_length; + bit<1> do_cksum; + l2_metadata_t l2_metadata; + l3_metadata_t l3_metadata; + ipv6_metadata_t ipv6_metadata; + tunnel_metadata_t tunnel_metadata; + fwd_meta_t fwd; +} + + +const bit<32> BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION = 5; +#define IS_REPLICATED(std_meta) (std_meta.instance_type == BMV2_V1MODEL_INSTANCE_TYPE_REPLICATION) + +parser MyParser(packet_in packet, out headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + state start { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV6: ipv6; + default: accept; + } + } + state ipv6 { + packet.extract(hdr.ipv6); + transition select(hdr.ipv6.nextHdr) { + PROTO_UDP: parse_udp; + PROTO_ICMP6: icmp6; + default: accept; + } + } + state icmp6 { + packet.extract(hdr.icmp6); + transition accept; + } + state parse_udp { + packet.extract(hdr.udp); + transition parse_ml; + } + state parse_ml { + packet.extract(hdr.ml); + transition parse_ml_vector; + } + state parse_ml_vector { + packet.extract(hdr.vector.next); + transition select(hdr.vector.last.e) { + _: accept; + } + } + +} + + +control ingress(inout headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + + aggregator_t[S] pool; + count_t[S] count; + + action set_mcast_grp(bit<16> mcast_grp, bit<9> port) { + standard_metadata.mcast_grp = mcast_grp; + meta.egress_port = port; + } + table ipv6_tbl { + key = { + (hdr.ipv6.dstAddr[127:120] == 8w0xff) : exact @name("mcast_key"); + } + actions = {set_mcast_grp;} + } + + apply { + if (hdr.ipv6.isValid()) { + ipv6_tbl.apply(); + } + + pool[hdr.ml.idx].val = pool[hdr.ml.idx].val + hdr.vector[0].e; + count[hdr.ml.idx].cnt = count[hdr.ml.idx].cnt + 1; + if (count[hdr.ml.idx].cnt == N) { + hdr.vector[0].e = pool[hdr.ml.idx].val; + pool[hdr.ml.idx] = {0}; + count[hdr.ml.idx] = {0}; + +// multicast packet occurs in egress control. + } else + mark_to_drop(standard_metadata); + } +} + +control egress(inout headers hdr, inout metadata_t meta, + inout standard_metadata_t standard_metadata) { + action set_out_bd (bit<24> bd) { + meta.fwd.out_bd = bd; + } + table get_multicast_copy_out_bd { + key = { + standard_metadata.mcast_grp : exact; + standard_metadata.egress_rid : exact; + } + actions = { set_out_bd; } + } + + action drop() { + mark_to_drop(standard_metadata); + } + action rewrite_mac(bit<48> smac) { + hdr.ethernet.srcAddr = smac; + } + table send_frame { + key = { + meta.fwd.out_bd: exact; + } + actions = {rewrite_mac; drop;} + default_action = drop; + } + + apply { + if (IS_REPLICATED(standard_metadata)) { + get_multicast_copy_out_bd.apply(); + send_frame.apply(); + } + } +} + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv6); + packet.emit(hdr.icmp6); + packet.emit(hdr.udp); + } +} + +control MyVerifyChecksum(inout headers hdr, inout metadata_t meta) { + apply { + } +} + +control MyComputeChecksum(inout headers hdr, inout metadata_t meta) { + apply { + } +} + +V1Switch(MyParser(), MyVerifyChecksum(), ingress(), egress(), +MyComputeChecksum(), MyDeparser()) main; diff --git a/individual_files/000090__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000090__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..91839461e8036bfa8c4e8417d0a4e7e261bfbae9 --- /dev/null +++ b/individual_files/000090__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,2273 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_query_tc{ + dns_qtype_class tc_query; +} + +header dns_a { + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; +} + +header dns_a_ip { + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_4 q1_part8_1; + dns_q_part_4 q1_part8_2; + dns_q_part_4 q1_part16_1; + dns_q_part_4 q1_part16_2; + dns_q_part_4 q1_part16_3; + dns_q_part_4 q1_part16_4; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_4 q2_part8_1; + dns_q_part_4 q2_part8_2; + dns_q_part_4 q2_part16_1; + dns_q_part_4 q2_part16_2; + dns_q_part_4 q2_part16_3; + dns_q_part_4 q2_part16_4; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_4 q3_part8_1; + dns_q_part_4 q3_part8_2; + dns_q_part_4 q3_part16_1; + dns_q_part_4 q3_part16_2; + dns_q_part_4 q3_part16_3; + dns_q_part_4 q3_part16_4; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + dns_q_part_4 q4_part8_1; + dns_q_part_4 q4_part8_2; + dns_q_part_4 q4_part16_1; + dns_q_part_4 q4_part16_2; + dns_q_part_4 q4_part16_3; + dns_q_part_4 q4_part16_4; + + dns_q_label label5; + dns_q_part_1 q5_part1; + dns_q_part_2 q5_part2; + dns_q_part_4 q5_part4; + dns_q_part_4 q5_part8_1; + dns_q_part_4 q5_part8_2; + dns_q_part_4 q5_part16_1; + dns_q_part_4 q5_part16_2; + dns_q_part_4 q5_part16_3; + dns_q_part_4 q5_part16_4; + + dns_q_label label6; + + dns_query_tc query_tc; + + dns_a dns_answer; + dns_a_ip dns_ip; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<3> last_label; + + bit<1> matched_domain; + + bit<32> q1_id; + bit<32> q2_id; + bit<32> q3_id; + bit<32> q4_id; + bit<32> domain_id; + + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + user_metadata.last_label = 0; + + p.q5_part1.part = 0; + p.q5_part2.part = 0; + p.q5_part4.part = 0; + p.q5_part8_1.part = 0; + p.q5_part8_2.part = 0; + p.q5_part16_1.part = 0; + p.q5_part16_2.part = 0; + p.q5_part16_3.part = 0; + p.q5_part16_4.part = 0; + + p.q4_part1.part = 0; + p.q4_part2.part = 0; + p.q4_part4.part = 0; + p.q4_part8_1.part = 0; + p.q4_part8_2.part = 0; + p.q4_part16_1.part = 0; + p.q4_part16_2.part = 0; + p.q4_part16_3.part = 0; + p.q4_part16_4.part = 0; + + p.q3_part1.part = 0; + p.q3_part2.part = 0; + p.q3_part4.part = 0; + p.q3_part8_1.part = 0; + p.q3_part8_2.part = 0; + p.q3_part16_1.part = 0; + p.q3_part16_2.part = 0; + p.q3_part16_3.part = 0; + p.q3_part16_4.part = 0; + + p.q2_part1.part = 0; + p.q2_part2.part = 0; + p.q2_part4.part = 0; + p.q2_part8_1.part = 0; + p.q2_part8_2.part = 0; + p.q2_part16_1.part = 0; + p.q2_part16_2.part = 0; + p.q2_part16_3.part = 0; + p.q2_part16_4.part = 0; + + p.q1_part1.part = 0; + p.q1_part2.part = 0; + p.q1_part4.part = 0; + p.q1_part8_1.part = 0; + p.q1_part8_2.part = 0; + p.q1_part16_1.part = 0; + p.q1_part16_2.part = 0; + p.q1_part16_3.part = 0; + p.q1_part16_4.part = 0; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_query_tc; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + 16: parse_dns_q1_len16; + 17: parse_dns_q1_len17; + 18: parse_dns_q1_len18; + 19: parse_dns_q1_len19; + 20: parse_dns_q1_len20; + 21: parse_dns_q1_len21; + 22: parse_dns_q1_len22; + 23: parse_dns_q1_len23; + 24: parse_dns_q1_len24; + 25: parse_dns_q1_len25; + 26: parse_dns_q1_len26; + 27: parse_dns_q1_len27; + 28: parse_dns_q1_len28; + 29: parse_dns_q1_len29; + 30: parse_dns_q1_len30; + 31: parse_dns_q1_len31; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len16 { + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len17 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len18 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len19 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len20 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len21 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len22 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len23 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len24 { + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len25 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len26 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len27 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len28 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len29 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len30 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + state parse_dns_q1_len31 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + pkt.extract(p.q1_part16_1); + pkt.extract(p.q1_part16_2); + pkt.extract(p.q1_part16_3); + pkt.extract(p.q1_part16_4); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_query_tc; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + 16: parse_dns_q2_len16; + 17: parse_dns_q2_len17; + 18: parse_dns_q2_len18; + 19: parse_dns_q2_len19; + 20: parse_dns_q2_len20; + 21: parse_dns_q2_len21; + 22: parse_dns_q2_len22; + 23: parse_dns_q2_len23; + 24: parse_dns_q2_len24; + 25: parse_dns_q2_len25; + 26: parse_dns_q2_len26; + 27: parse_dns_q2_len27; + 28: parse_dns_q2_len28; + 29: parse_dns_q2_len29; + 30: parse_dns_q2_len30; + 31: parse_dns_q2_len31; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len16 { + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len17 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len18 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len19 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len20 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len21 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len22 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len23 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len24 { + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len25 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len26 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len27 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len28 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len29 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len30 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + state parse_dns_q2_len31 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + pkt.extract(p.q2_part16_1); + pkt.extract(p.q2_part16_2); + pkt.extract(p.q2_part16_3); + pkt.extract(p.q2_part16_4); + transition parse_dns_query3; + } + + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_query_tc; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + 16: parse_dns_q3_len16; + 17: parse_dns_q3_len17; + 18: parse_dns_q3_len18; + 19: parse_dns_q3_len19; + 20: parse_dns_q3_len20; + 21: parse_dns_q3_len21; + 22: parse_dns_q3_len22; + 23: parse_dns_q3_len23; + 24: parse_dns_q3_len24; + 25: parse_dns_q3_len25; + 26: parse_dns_q3_len26; + 27: parse_dns_q3_len27; + 28: parse_dns_q3_len28; + 29: parse_dns_q3_len29; + 30: parse_dns_q3_len30; + 31: parse_dns_q3_len31; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len16 { + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len17 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len18 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len19 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len20 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len21 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len22 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len23 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len24 { + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len25 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len26 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len27 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len28 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len29 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len30 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + state parse_dns_q3_len31 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + pkt.extract(p.q3_part16_1); + pkt.extract(p.q3_part16_2); + pkt.extract(p.q3_part16_3); + pkt.extract(p.q3_part16_4); + transition parse_dns_query4; + } + + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_query_tc; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + 8: parse_dns_q4_len8; + 9: parse_dns_q4_len9; + 10: parse_dns_q4_len10; + 11: parse_dns_q4_len11; + 12: parse_dns_q4_len12; + 13: parse_dns_q4_len13; + 14: parse_dns_q4_len14; + 15: parse_dns_q4_len15; + 16: parse_dns_q4_len16; + 17: parse_dns_q4_len17; + 18: parse_dns_q4_len18; + 19: parse_dns_q4_len19; + 20: parse_dns_q4_len20; + 21: parse_dns_q4_len21; + 22: parse_dns_q4_len22; + 23: parse_dns_q4_len23; + 24: parse_dns_q4_len24; + 25: parse_dns_q4_len25; + 26: parse_dns_q4_len26; + 27: parse_dns_q4_len27; + 28: parse_dns_q4_len28; + 29: parse_dns_q4_len29; + 30: parse_dns_q4_len30; + 31: parse_dns_q4_len31; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len8 { + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len9 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len10 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len11 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len12 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len13 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len14 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len15 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len16 { + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len17 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len18 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len19 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len20 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len21 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len22 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len23 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len24 { + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len25 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len26 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len27 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len28 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len29 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len30 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + state parse_dns_q4_len31 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + pkt.extract(p.q4_part16_1); + pkt.extract(p.q4_part16_2); + pkt.extract(p.q4_part16_3); + pkt.extract(p.q4_part16_4); + transition parse_dns_query5; + } + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_query_tc; + 1: parse_dns_q5_len1; + 2: parse_dns_q5_len2; + 3: parse_dns_q5_len3; + 4: parse_dns_q5_len4; + 5: parse_dns_q5_len5; + 6: parse_dns_q5_len6; + 7: parse_dns_q5_len7; + 8: parse_dns_q5_len8; + 9: parse_dns_q5_len9; + 10: parse_dns_q5_len10; + 11: parse_dns_q5_len11; + 12: parse_dns_q5_len12; + 13: parse_dns_q5_len13; + 14: parse_dns_q5_len14; + 15: parse_dns_q5_len15; + 16: parse_dns_q5_len16; + 17: parse_dns_q5_len17; + 18: parse_dns_q5_len18; + 19: parse_dns_q5_len19; + 20: parse_dns_q5_len20; + 21: parse_dns_q5_len21; + 22: parse_dns_q5_len22; + 23: parse_dns_q5_len23; + 24: parse_dns_q5_len24; + 25: parse_dns_q5_len25; + 26: parse_dns_q5_len26; + 27: parse_dns_q5_len27; + 28: parse_dns_q5_len28; + 29: parse_dns_q5_len29; + 30: parse_dns_q5_len30; + 31: parse_dns_q5_len31; + default: accept; + } + } + + state parse_dns_q5_len1 { + pkt.extract(p.q5_part1); + transition parse_dns_query6; + } + + state parse_dns_q5_len2 { + pkt.extract(p.q5_part2); + transition parse_dns_query6; + } + + state parse_dns_q5_len3 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + transition parse_dns_query6; + } + + state parse_dns_q5_len4 { + pkt.extract(p.q5_part4); + transition parse_dns_query6; + } + + state parse_dns_q5_len5 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part4); + transition parse_dns_query6; + } + + state parse_dns_q5_len6 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + transition parse_dns_query6; + } + + state parse_dns_q5_len7 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + transition parse_dns_query6; + } + + state parse_dns_q5_len8 { + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len9 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len10 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len11 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len12 { + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len13 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len14 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len15 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + transition parse_dns_query6; + } + + state parse_dns_q5_len16 { + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len17 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len18 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len19 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len20 { + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len21 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len22 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len23 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len24 { + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len25 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len26 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len27 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len28 { + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len29 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len30 { + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + state parse_dns_q5_len31 { + pkt.extract(p.q5_part1); + pkt.extract(p.q5_part2); + pkt.extract(p.q5_part4); + pkt.extract(p.q5_part8_1); + pkt.extract(p.q5_part8_2); + pkt.extract(p.q5_part16_1); + pkt.extract(p.q5_part16_2); + pkt.extract(p.q5_part16_3); + pkt.extract(p.q5_part16_4); + transition parse_dns_query6; + } + + + +// Parsel DNS Query Label 6 + state parse_dns_query6 { + pkt.extract(p.label6); + user_metadata.last_label = 6; + + transition select(p.label6.label) { + 0: parse_query_tc; + default: accept; + } + } + + state parse_query_tc { + pkt.extract(p.query_tc); + user_metadata.parsed_answer = 0; + transition parse_dns_answer; + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + + transition select(p.dns_answer.tc_ans.type) { + 1: parse_a_ip; + 5: parse_cname; + default: accept; + } + } + + state parse_cname { + pkt.advance((bit<32>)(8 * p.dns_answer.rd_length)); + + transition parse_dns_answer; + } + + state parse_a_ip { + pkt.extract(p.dns_ip); + user_metadata.parsed_answer = 1; + + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + action match_q1(known_domain_id q1id) { + user_metadata.q1_id = q1id; + } + + action match_q2(known_domain_id q2id) { + user_metadata.q2_id = q2id; + } + + action match_q3(known_domain_id q3id) { + user_metadata.q3_id = q3id; + } + + action match_q4(known_domain_id q4id) { + user_metadata.q4_id = q4id; + } + + action match_domain(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain = 1; + } + + table known_domain_list_q1 { + key = { + headers.q1_part1.part: ternary; + headers.q1_part2.part: ternary; + headers.q1_part4.part: ternary; + headers.q1_part8_1.part: ternary; + headers.q1_part8_2.part: ternary; + headers.q1_part16_1.part: ternary; + headers.q1_part16_2.part: ternary; + headers.q1_part16_3.part: ternary; + headers.q1_part16_4.part: ternary; + } + + actions = { + match_q1; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + table known_domain_list_q2 { + key = { + headers.q2_part1.part: ternary; + headers.q2_part2.part: ternary; + headers.q2_part4.part: ternary; + headers.q2_part8_1.part: ternary; + headers.q2_part8_2.part: ternary; + headers.q2_part16_1.part: ternary; + headers.q2_part16_2.part: ternary; + headers.q2_part16_3.part: ternary; + headers.q2_part16_4.part: ternary; + user_metadata.q1_id: ternary; + } + + actions = { + match_q2; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + table known_domain_list_q3 { + key = { + headers.q3_part1.part: ternary; + headers.q3_part2.part: ternary; + headers.q3_part4.part: ternary; + headers.q3_part8_1.part: ternary; + headers.q3_part8_2.part: ternary; + headers.q3_part16_1.part: ternary; + headers.q3_part16_2.part: ternary; + headers.q3_part16_3.part: ternary; + headers.q3_part16_4.part: ternary; + user_metadata.q2_id: ternary; + } + + actions = { + match_q3; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + table known_domain_list_q4 { + key = { + headers.q4_part1.part: ternary; + headers.q4_part2.part: ternary; + headers.q4_part4.part: ternary; + headers.q4_part8_1.part: ternary; + headers.q4_part8_2.part: ternary; + headers.q4_part16_1.part: ternary; + headers.q4_part16_2.part: ternary; + headers.q4_part16_3.part: ternary; + headers.q4_part16_4.part: ternary; + user_metadata.q3_id: ternary; + } + + actions = { + match_q4; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + table known_domain_list_q5 { + key = { + headers.q5_part1.part: ternary; + headers.q5_part2.part: ternary; + headers.q5_part4.part: ternary; + headers.q5_part8_1.part: ternary; + headers.q5_part8_2.part: ternary; + headers.q5_part16_1.part: ternary; + headers.q5_part16_2.part: ternary; + headers.q5_part16_3.part: ternary; + headers.q5_part16_4.part: ternary; + user_metadata.q4_id: ternary; + } + + actions = { + match_domain; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + user_metadata.q1_id = 0; + user_metadata.q2_id = 0; + user_metadata.q3_id = 0; + user_metadata.q4_id = 0; + user_metadata.domain_id = 0; + user_metadata.matched_domain = 0; + + known_domain_list_q1.apply(); + known_domain_list_q2.apply(); + known_domain_list_q3.apply(); + known_domain_list_q4.apply(); + known_domain_list_q5.apply(); + + if (user_metadata.matched_domain == 1) { + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_ip.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_ip.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_ip.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_ip.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_ip.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_ip.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_ip.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_ip.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + } + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000091__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000091__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..20f70f8f56a16aacd152b30c9ebc2cf0a919fadd --- /dev/null +++ b/individual_files/000091__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,1070 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_query_tc{ + dns_qtype_class tc_query; +} + +header dns_a { + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; +} + +header dns_a_ip { + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_4 q1_part8_1; + dns_q_part_4 q1_part8_2; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_4 q2_part8_1; + dns_q_part_4 q2_part8_2; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_4 q3_part8_1; + dns_q_part_4 q3_part8_2; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + dns_q_part_4 q4_part8_1; + dns_q_part_4 q4_part8_2; + + dns_q_label label5; + + dns_query_tc query_tc; + + dns_a dns_answer; + dns_a_ip dns_ip; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<3> last_label; + + bit<1> matched_domain; + bit<32> domain_id; + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + user_metadata.last_label = 0; + + p.q4_part1.part = 0; + p.q4_part2.part = 0; + p.q4_part4.part = 0; + p.q4_part8_1.part = 0; + p.q4_part8_2.part = 0; + + p.q3_part1.part = 0; + p.q3_part2.part = 0; + p.q3_part4.part = 0; + p.q3_part8_1.part = 0; + p.q3_part8_2.part = 0; + + p.q2_part1.part = 0; + p.q2_part2.part = 0; + p.q2_part4.part = 0; + p.q2_part8_1.part = 0; + p.q2_part8_2.part = 0; + + p.q1_part1.part = 0; + p.q1_part2.part = 0; + p.q1_part4.part = 0; + p.q1_part8_1.part = 0; + p.q1_part8_2.part = 0; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_query_tc; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8_1); + pkt.extract(p.q1_part8_2); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_query_tc; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8_1); + pkt.extract(p.q2_part8_2); + transition parse_dns_query3; + } + + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_query_tc; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8_1); + pkt.extract(p.q3_part8_2); + transition parse_dns_query4; + } + + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_query_tc; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + 8: parse_dns_q4_len8; + 9: parse_dns_q4_len9; + 10: parse_dns_q4_len10; + 11: parse_dns_q4_len11; + 12: parse_dns_q4_len12; + 13: parse_dns_q4_len13; + 14: parse_dns_q4_len14; + 15: parse_dns_q4_len15; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len8 { + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len9 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len10 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len11 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len12 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len13 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len14 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + state parse_dns_q4_len15 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8_1); + pkt.extract(p.q4_part8_2); + transition parse_dns_query5; + } + + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_query_tc; + default: accept; + } + } + + state parse_query_tc { + pkt.extract(p.query_tc); + user_metadata.parsed_answer = 0; + transition parse_dns_answer; + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + + transition select(p.dns_answer.tc_ans.type) { + 1: parse_a_ip; + 5: parse_cname; + default: accept; + } + } + + state parse_cname { + pkt.advance((bit<32>)(8 * p.dns_answer.rd_length)); + + transition parse_dns_answer; + } + + state parse_a_ip { + pkt.extract(p.dns_ip); + user_metadata.parsed_answer = 1; + + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + + action match_domain(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain = 1; + } + + table known_domain_list { + key = { + headers.q1_part1.part: ternary; + headers.q1_part2.part: ternary; + headers.q1_part4.part: ternary; + headers.q1_part8_1.part: ternary; + headers.q1_part8_2.part: ternary; + + headers.q2_part1.part: ternary; + headers.q2_part2.part: ternary; + headers.q2_part4.part: ternary; + headers.q2_part8_1.part: ternary; + headers.q2_part8_2.part: ternary; + + headers.q3_part1.part: ternary; + headers.q3_part2.part: ternary; + headers.q3_part4.part: ternary; + headers.q3_part8_1.part: ternary; + headers.q3_part8_2.part: ternary; + + headers.q4_part1.part: ternary; + headers.q4_part2.part: ternary; + headers.q4_part4.part: ternary; + headers.q4_part8_1.part: ternary; + headers.q4_part8_2.part: ternary; + } + + actions = { + match_domain; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + user_metadata.domain_id = 0; + user_metadata.matched_domain = 0; + + known_domain_list.apply(); + + if (user_metadata.matched_domain == 1) { + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_ip.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_ip.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_ip.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_ip.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_ip.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_ip.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_ip.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_ip.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + } + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000092__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000092__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..462699f6be2bb130b06724bbd3763d0b9b04df57 --- /dev/null +++ b/individual_files/000092__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,1039 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +header dns_q_part_8 { + bit<64> part; +} + +header dns_q_part_16 { + bit<128> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_query_tc{ + dns_qtype_class tc_query; +} + +header dns_a { + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; +} + +header dns_a_ip { + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_8 q1_part8; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_8 q2_part8; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_8 q3_part8; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + dns_q_part_8 q4_part8; + + dns_q_label label5; + + dns_query_tc query_tc; + + dns_a dns_answer; + dns_a_ip dns_ip; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<32> last_label; + + + bit<1> matched_domain; + bit<32> domain_id; + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + user_metadata.last_label = 0; + + p.q4_part1.part = 0; + p.q4_part2.part = 0; + p.q4_part4.part = 0; + p.q4_part8.part = 0; + + p.q3_part1.part = 0; + p.q3_part2.part = 0; + p.q3_part4.part = 0; + p.q3_part8.part = 0; + + p.q2_part1.part = 0; + p.q2_part2.part = 0; + p.q2_part4.part = 0; + p.q2_part8.part = 0; + + p.q1_part1.part = 0; + p.q1_part2.part = 0; + p.q1_part4.part = 0; + p.q1_part8.part = 0; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_dns_answer; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_dns_answer; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_dns_answer; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_dns_answer; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + 8: parse_dns_q4_len8; + 9: parse_dns_q4_len9; + 10: parse_dns_q4_len10; + 11: parse_dns_q4_len11; + 12: parse_dns_q4_len12; + 13: parse_dns_q4_len13; + 14: parse_dns_q4_len14; + 15: parse_dns_q4_len15; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len8 { + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len9 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len10 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len11 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len12 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len13 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len14 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len15 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_query_tc; + default: accept; + } + } + + state parse_query_tc { + pkt.extract(p.query_tc); + user_metadata.parsed_answer = 0; + transition parse_dns_answer; + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + + transition select(p.dns_answer.tc_ans.type) { + 1: parse_a_ip; + 5: parse_cname; + default: accept; + } + } + + state parse_cname { + pkt.advance((bit<32>)(8 * p.dns_answer.rd_length)); + + transition parse_dns_answer; + } + + state parse_a_ip { + pkt.extract(p.dns_ip); + user_metadata.parsed_answer = 1; + + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + + + action match_domain_fail() { + user_metadata.domain_id = 0; + +// Completely misc. domain + user_metadata.matched_domain = 0; + } + + action match_domain(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain = 1; + } + + table known_domain_list { + key = { + headers.q1_part1.part: ternary; + headers.q1_part2.part: ternary; + headers.q1_part4.part: ternary; + headers.q1_part8.part: ternary; + + headers.q2_part1.part: ternary; + headers.q2_part2.part: ternary; + headers.q2_part4.part: ternary; + headers.q2_part8.part: ternary; + + headers.q3_part1.part: ternary; + headers.q3_part2.part: ternary; + headers.q3_part4.part: ternary; + headers.q3_part8.part: ternary; + + headers.q4_part1.part: ternary; + headers.q4_part2.part: ternary; + headers.q4_part4.part: ternary; + headers.q4_part8.part: ternary; + } + + actions = { + match_domain; + match_domain_fail; + } + size = NUM_KNOWN_DOMAINS; + default_action = match_domain_fail(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + + known_domain_list.apply(); + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_ip.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_ip.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_ip.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_ip.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_ip.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_ip.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_ip.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_ip.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000093__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000093__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..ccf824bdfba57a3e9635240440dd787e5acb9adf --- /dev/null +++ b/individual_files/000093__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,1685 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +header dns_q_part_8 { + bit<64> part; +} + +header dns_q_part_16 { + bit<128> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_query_tc{ + dns_qtype_class tc_query; +} + +header dns_a { + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; +} + +header dns_a_ip { + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_8 q1_part8; + dns_q_part_16 q1_part16; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_8 q2_part8; + dns_q_part_16 q2_part16; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_8 q3_part8; + dns_q_part_16 q3_part16; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + dns_q_part_8 q4_part8; + dns_q_part_16 q4_part16; + + dns_q_label label5; + + dns_query_tc query_tc; + + dns_a dns_answer; + dns_a_ip dns_ip; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<3> last_label; + + bit<1> matched_domain4; + bit<1> matched_domain3; + bit<1> matched_domain2; + bit<1> matched_domain1; + bit<32> domain_id; + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_dns_answer; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + 16: parse_dns_q1_len16; + 17: parse_dns_q1_len17; + 18: parse_dns_q1_len18; + 19: parse_dns_q1_len19; + 20: parse_dns_q1_len20; + 21: parse_dns_q1_len21; + 22: parse_dns_q1_len22; + 23: parse_dns_q1_len23; + 24: parse_dns_q1_len24; + 25: parse_dns_q1_len25; + 26: parse_dns_q1_len26; + 27: parse_dns_q1_len27; + 28: parse_dns_q1_len28; + 29: parse_dns_q1_len29; + 30: parse_dns_q1_len30; + 31: parse_dns_q1_len31; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len16 { + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len17 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len18 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len19 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len20 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len21 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len22 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len23 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len24 { + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len25 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len26 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len27 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len28 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len29 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len30 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + state parse_dns_q1_len31 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + pkt.extract(p.q1_part16); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_dns_answer; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + 16: parse_dns_q2_len16; + 17: parse_dns_q2_len17; + 18: parse_dns_q2_len18; + 19: parse_dns_q2_len19; + 20: parse_dns_q2_len20; + 21: parse_dns_q2_len21; + 22: parse_dns_q2_len22; + 23: parse_dns_q2_len23; + 24: parse_dns_q2_len24; + 25: parse_dns_q2_len25; + 26: parse_dns_q2_len26; + 27: parse_dns_q2_len27; + 28: parse_dns_q2_len28; + 29: parse_dns_q2_len29; + 30: parse_dns_q2_len30; + 31: parse_dns_q2_len31; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len16 { + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len17 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len18 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len19 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len20 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len21 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len22 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len23 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len24 { + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len25 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len26 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len27 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len28 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len29 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len30 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len31 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_dns_answer; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + 16: parse_dns_q3_len16; + 17: parse_dns_q3_len17; + 18: parse_dns_q3_len18; + 19: parse_dns_q3_len19; + 20: parse_dns_q3_len20; + 21: parse_dns_q3_len21; + 22: parse_dns_q3_len22; + 23: parse_dns_q3_len23; + 24: parse_dns_q3_len24; + 25: parse_dns_q3_len25; + 26: parse_dns_q3_len26; + 27: parse_dns_q3_len27; + 28: parse_dns_q3_len28; + 29: parse_dns_q3_len29; + 30: parse_dns_q3_len30; + 31: parse_dns_q3_len31; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len16 { + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len17 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len18 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len19 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len20 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len21 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len22 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len23 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len24 { + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len25 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len26 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len27 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len28 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len29 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len30 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len31 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_dns_answer; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + 8: parse_dns_q4_len8; + 9: parse_dns_q4_len9; + 10: parse_dns_q4_len10; + 11: parse_dns_q4_len11; + 12: parse_dns_q4_len12; + 13: parse_dns_q4_len13; + 14: parse_dns_q4_len14; + 15: parse_dns_q4_len15; + 16: parse_dns_q4_len16; + 17: parse_dns_q4_len17; + 18: parse_dns_q4_len18; + 19: parse_dns_q4_len19; + 20: parse_dns_q4_len20; + 21: parse_dns_q4_len21; + 22: parse_dns_q4_len22; + 23: parse_dns_q4_len23; + 24: parse_dns_q4_len24; + 25: parse_dns_q4_len25; + 26: parse_dns_q4_len26; + 27: parse_dns_q4_len27; + 28: parse_dns_q4_len28; + 29: parse_dns_q4_len29; + 30: parse_dns_q4_len30; + 31: parse_dns_q4_len31; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len8 { + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len9 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len10 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len11 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len12 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len13 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len14 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len15 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + transition parse_dns_query5; + } + + state parse_dns_q4_len16 { + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len17 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len18 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len19 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len20 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len21 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len22 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len23 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len24 { + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len25 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len26 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len27 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len28 { + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len29 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len30 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + state parse_dns_q4_len31 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + pkt.extract(p.q4_part8); + pkt.extract(p.q4_part16); + transition parse_dns_query5; + } + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_query_tc; + default: accept; + } + } + + state parse_query_tc { + pkt.extract(p.query_tc); + user_metadata.parsed_answer = 0; + transition parse_dns_answer; + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + + transition select(p.dns_answer.tc_ans.type) { + 1: parse_a_ip; + 5: parse_cname; + default: accept; + } + } + + state parse_cname { + pkt.advance((bit<32>)(8 * p.dns_answer.rd_length)); + + transition parse_dns_answer; + } + + state parse_a_ip { + pkt.extract(p.dns_ip); + user_metadata.parsed_answer = 1; + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + action match_domain4_fail() { + user_metadata.domain_id = 0; + +// Completely misc. domain + user_metadata.matched_domain4 = 0; + } + + action match_domain4(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain4 = 1; + } + + action match_domain3_fail() { + user_metadata.matched_domain3 = 0; + } + + action match_domain3(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain3 = 1; + } + + action match_domain2_fail() { + user_metadata.matched_domain2 = 0; + } + + action match_domain2(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain2 = 1; + } + + action match_domain1_fail() { + user_metadata.matched_domain1 = 0; + } + + action match_domain1(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain1 = 1; + } + + table known_domain_list_q4 { + key = { + headers.q4_part1.part: exact; + headers.q4_part2.part: exact; + headers.q4_part4.part: exact; + headers.q4_part8.part: exact; + headers.q4_part16.part: exact; + } + + actions = { + match_domain4; + match_domain4_fail; + } + size = NUM_KNOWN_DOMAINS; + default_action = match_domain4_fail(); + } + + table known_domain_list_q3 { + key = { + headers.q3_part1.part: exact; + headers.q3_part2.part: exact; + headers.q3_part4.part: exact; + headers.q3_part8.part: exact; + headers.q3_part16.part: exact; + user_metadata.domain_id: exact; + } + + actions = { + match_domain3; + match_domain3_fail; + } + size = NUM_KNOWN_DOMAINS; + default_action = match_domain3_fail(); + } + + table known_domain_list_q2 { + key = { + headers.q2_part1.part: exact; + headers.q2_part2.part: exact; + headers.q2_part4.part: exact; + headers.q2_part8.part: exact; + headers.q2_part16.part: exact; + user_metadata.domain_id: exact; + } + + actions = { + match_domain2; + match_domain2_fail; + } + size = NUM_KNOWN_DOMAINS; + default_action = match_domain2_fail(); + } + + table known_domain_list_q1 { + key = { + headers.q1_part1.part: exact; + headers.q1_part2.part: exact; + headers.q1_part4.part: exact; + headers.q1_part8.part: exact; + headers.q1_part16.part: exact; + user_metadata.domain_id: exact; + } + + actions = { + match_domain1; + match_domain1_fail; + } + size = NUM_KNOWN_DOMAINS; + default_action = match_domain1_fail(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + + + + +// Shift over by one + if (user_metadata.last_label == 4) { + headers.q4_part1.part = headers.q3_part1.part; + headers.q4_part2.part = headers.q3_part2.part; + headers.q4_part4.part = headers.q3_part4.part; + headers.q4_part8.part = headers.q3_part8.part; + headers.q4_part16.part = headers.q3_part16.part; + + headers.q3_part1.part = headers.q2_part1.part; + headers.q3_part2.part = headers.q2_part2.part; + headers.q3_part4.part = headers.q2_part4.part; + headers.q3_part8.part = headers.q2_part8.part; + headers.q3_part16.part = headers.q2_part16.part; + + headers.q2_part1.part = headers.q1_part1.part; + headers.q2_part2.part = headers.q1_part2.part; + headers.q2_part4.part = headers.q1_part4.part; + headers.q2_part8.part = headers.q1_part8.part; + headers.q2_part16.part = headers.q1_part16.part; + + headers.q1_part1.part = 0; + headers.q1_part2.part = 0; + headers.q1_part4.part = 0; + headers.q1_part8.part = 0; + headers.q1_part16.part = 0; + } + else if (user_metadata.last_label == 3) { + headers.q4_part1.part = headers.q2_part1.part; + headers.q4_part2.part = headers.q2_part2.part; + headers.q4_part4.part = headers.q2_part4.part; + headers.q4_part8.part = headers.q2_part8.part; + headers.q4_part16.part = headers.q2_part16.part; + + headers.q3_part1.part = headers.q1_part1.part; + headers.q3_part2.part = headers.q1_part2.part; + headers.q3_part4.part = headers.q1_part4.part; + headers.q3_part8.part = headers.q1_part8.part; + headers.q3_part16.part = headers.q1_part16.part; + + headers.q2_part1.part = 0; + headers.q2_part2.part = 0; + headers.q2_part4.part = 0; + headers.q2_part8.part = 0; + headers.q2_part16.part = 0; + + headers.q1_part1.part = 0; + headers.q1_part2.part = 0; + headers.q1_part4.part = 0; + headers.q1_part8.part = 0; + headers.q1_part16.part = 0; + } + else if (user_metadata.last_label == 2) { + headers.q4_part1.part = headers.q1_part1.part; + headers.q4_part2.part = headers.q1_part2.part; + headers.q4_part4.part = headers.q1_part4.part; + headers.q4_part8.part = headers.q1_part8.part; + headers.q4_part16.part = headers.q1_part16.part; + + headers.q3_part1.part = 0; + headers.q3_part2.part = 0; + headers.q3_part4.part = 0; + headers.q3_part8.part = 0; + headers.q3_part16.part = 0; + + headers.q2_part1.part = 0; + headers.q2_part2.part = 0; + headers.q2_part4.part = 0; + headers.q2_part8.part = 0; + headers.q2_part16.part = 0; + + headers.q1_part1.part = 0; + headers.q1_part2.part = 0; + headers.q1_part4.part = 0; + headers.q1_part8.part = 0; + headers.q1_part16.part = 0; + } + + known_domain_list_q4.apply(); + if (user_metadata.matched_domain4 == 1) { + known_domain_list_q3.apply(); + if (user_metadata.matched_domain3 == 1) { + known_domain_list_q2.apply(); + if (user_metadata.matched_domain2 == 1) { + known_domain_list_q1.apply(); + } + } + } + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_ip.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_ip.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_ip.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_ip.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_ip.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_ip.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_ip.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_ip.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000094__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000094__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..e83fb589656769bfe55a2dab677213013dbe3b73 --- /dev/null +++ b/individual_files/000094__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,1178 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +header dns_q_part_8 { + bit<64> part; +} + +header dns_q_part_16 { + bit<128> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_a { + dns_qtype_class tc_query; + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_8 q1_part8; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_8 q2_part8; + dns_q_part_16 q2_part16; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_8 q3_part8; + dns_q_part_16 q3_part16; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + + dns_q_label label5; + + dns_a dns_answer; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<3> last_label; + + bit<1> matched_domain; + bit<32> domain_id; + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_dns_answer; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_dns_answer; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + 16: parse_dns_q2_len16; + 17: parse_dns_q2_len17; + 18: parse_dns_q2_len18; + 19: parse_dns_q2_len19; + 20: parse_dns_q2_len20; + 21: parse_dns_q2_len21; + 22: parse_dns_q2_len22; + 23: parse_dns_q2_len23; + 24: parse_dns_q2_len24; + 25: parse_dns_q2_len25; + 26: parse_dns_q2_len26; + 27: parse_dns_q2_len27; + 28: parse_dns_q2_len28; + 29: parse_dns_q2_len29; + 30: parse_dns_q2_len30; + 31: parse_dns_q2_len31; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len16 { + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len17 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len18 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len19 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len20 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len21 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len22 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len23 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len24 { + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len25 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len26 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len27 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len28 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len29 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len30 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len31 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_dns_answer; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + 16: parse_dns_q3_len16; + 17: parse_dns_q3_len17; + 18: parse_dns_q3_len18; + 19: parse_dns_q3_len19; + 20: parse_dns_q3_len20; + 21: parse_dns_q3_len21; + 22: parse_dns_q3_len22; + 23: parse_dns_q3_len23; + 24: parse_dns_q3_len24; + 25: parse_dns_q3_len25; + 26: parse_dns_q3_len26; + 27: parse_dns_q3_len27; + 28: parse_dns_q3_len28; + 29: parse_dns_q3_len29; + 30: parse_dns_q3_len30; + 31: parse_dns_q3_len31; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len16 { + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len17 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len18 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len19 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len20 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len21 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len22 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len23 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len24 { + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len25 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len26 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len27 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len28 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len29 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len30 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len31 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_dns_answer; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_dns_answer; + default: accept; + } + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + user_metadata.parsed_answer = 0; + + transition select(p.dns_answer.tc_ans.type) { + 1: set_metadata; + default: accept; + } + } + + state set_metadata { + user_metadata.parsed_answer = 1; + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + action match_domain(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain = 1; + } + + table known_domain_list { + key = { + headers.q1_part1.part: exact; + headers.q1_part2.part: exact; + headers.q1_part4.part: exact; + headers.q1_part8.part: exact; + headers.q2_part1.part: exact; + headers.q2_part2.part: exact; + headers.q2_part4.part: exact; + headers.q2_part8.part: exact; + headers.q2_part16.part: exact; + headers.q3_part1.part: exact; + headers.q3_part2.part: exact; + headers.q3_part4.part: exact; + headers.q3_part8.part: exact; + headers.q3_part16.part: exact; + headers.q4_part1.part: exact; + headers.q4_part2.part: exact; + headers.q4_part4.part: exact; + } + + actions = { + match_domain; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + + user_metadata.matched_domain = 0; + + known_domain_list.apply(); + + if (user_metadata.matched_domain == 1) { + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_answer.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_answer.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_answer.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_answer.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_answer.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_answer.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_answer.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_answer.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_answer.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_answer.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_answer.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_answer.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_answer.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + } + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000095__raw-repositories__hyojoonkim__IWSpring2020.p4 b/individual_files/000095__raw-repositories__hyojoonkim__IWSpring2020.p4 new file mode 100644 index 0000000000000000000000000000000000000000..4aa4865b6404c831c91ed9c9068e35ddcca2f68b --- /dev/null +++ b/individual_files/000095__raw-repositories__hyojoonkim__IWSpring2020.p4 @@ -0,0 +1,1202 @@ +#include +#include + +#define NUM_KNOWN_DOMAINS 1024 +#define NUM_KNOWN_DOMAINS_BITS 10 +#define TABLE_SIZE 1024 +#define HASH_TABLE_BASE 10w0 +#define HASH_TABLE_MAX 10w1023 +#define TIMEOUT 600000000 + +// 10 minutes + +typedef bit<48> MacAddress; +typedef bit<32> IPv4Address; +typedef bit<128> IPv6Address; +typedef bit<32> known_domain_id; + +header ethernet_h { + MacAddress dst; + MacAddress src; + bit<16> etherType; +} +header ipv4_h { + bit<4> version; + bit<4> ihl; + bit<8> tos; + bit<16> len; + bit<16> id; + bit<3> flags; + bit<13> frag; + bit<8> ttl; + bit<8> proto; + bit<16> chksum; + IPv4Address src; + IPv4Address dst; +} +header ipv6_h { + bit<4> version; + bit<8> tc; + bit<20> fl; + bit<16> plen; + bit<8> nh; + bit<8> hl; + IPv6Address src; + IPv6Address dst; +} +header tcp_h { + bit<16> sport; + bit<16> dport; + bit<32> seq; + bit<32> ack; + bit<4> dataofs; + bit<4> reserved; + bit<8> flags; + bit<16> window; + bit<16> chksum; + bit<16> urgptr; +} +header udp_h { + bit<16> sport; + bit<16> dport; + bit<16> len; + bit<16> chksum; +} + +header dns_h { + bit<16> id; + bit<1> is_response; + bit<4> opcode; + bit<1> auth_answer; + bit<1> trunc; + bit<1> recur_desired; + bit<1> recur_avail; + bit<1> reserved; + bit<1> authentic_data; + bit<1> checking_disabled; + bit<4> resp_code; + bit<16> q_count; + bit<16> answer_count; + bit<16> auth_rec; + bit<16> addn_rec; +} + +header dns_q_label { + bit<8> label; +} + +header dns_q_part_1 { + bit<8> part; +} + +header dns_q_part_2 { + bit<16> part; +} + +header dns_q_part_4 { + bit<32> part; +} + +header dns_q_part_8 { + bit<64> part; +} + +header dns_q_part_16 { + bit<128> part; +} + +struct dns_qtype_class { + bit<16> type; + bit<16> class; +} + +header dns_query_tc{ + dns_qtype_class tc_query; +} + +header dns_a { + bit<16> qname_pointer; + dns_qtype_class tc_ans; + bit<32> ttl; + bit<16> rd_length; +} + +header dns_a_ip { + bit<32> rdata; + +// IPV4 is always 32 bit. +} + + +// List of all recognized headers +struct Parsed_packet { + ethernet_h ethernet; + ipv4_h ipv4; + udp_h udp; + dns_h dns_header; + + dns_q_label label1; + dns_q_part_1 q1_part1; + dns_q_part_2 q1_part2; + dns_q_part_4 q1_part4; + dns_q_part_8 q1_part8; + + dns_q_label label2; + dns_q_part_1 q2_part1; + dns_q_part_2 q2_part2; + dns_q_part_4 q2_part4; + dns_q_part_8 q2_part8; + dns_q_part_16 q2_part16; + + dns_q_label label3; + dns_q_part_1 q3_part1; + dns_q_part_2 q3_part2; + dns_q_part_4 q3_part4; + dns_q_part_8 q3_part8; + dns_q_part_16 q3_part16; + + dns_q_label label4; + dns_q_part_1 q4_part1; + dns_q_part_2 q4_part2; + dns_q_part_4 q4_part4; + + dns_q_label label5; + + dns_query_tc query_tc; + + dns_a dns_answer; + dns_a_ip dns_ip; +} + + +struct user_metadata_t { + bit<1> do_dns; + bit<1> recur_desired; + bit<1> response_set; + bit<1> is_dns; + bit<1> is_ip; + bit<3> unused; + + bit<3> last_label; + + bit<1> matched_domain; + bit<32> domain_id; + bit<32> index_1; + bit<32> index_2; + bit<32> index_3; + bit<32> temp_timestamp; + bit<32> temp_cip; + bit<32> temp_sip; + bit<1> already_matched; + bit<64> min_counter; + bit<2> min_table; + bit<32> temp_packet_counter; + bit<32> temp_byte_counter; + + bit<32> temp_total_dns; + bit<32> temp_total_missed; + bit<1> parsed_answer; +} + + +// parsers +parser TopParser(packet_in pkt, + out Parsed_packet p, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + state start { + pkt.extract(p.ethernet); + +// These are set appropriately in the TopPipe. + user_metadata.do_dns = 0; + user_metadata.recur_desired = 0; + user_metadata.response_set = 0; + user_metadata.is_dns = 0; + user_metadata.is_ip = 0; + + transition select(p.ethernet.etherType) { + 0x800: parse_ip; + default: accept; + } + } + + state parse_ip { + pkt.extract(p.ipv4); + + user_metadata.is_ip = 1; + user_metadata.is_dns = 0; + transition select(p.ipv4.proto) { + 17: parse_udp; + default: accept; + } + } + + state parse_udp { + pkt.extract(p.udp); + + transition select(p.udp.dport == 53 || p.udp.sport == 53) { + true: parse_dns_header; + false: accept; + } + } + + state parse_dns_header { + pkt.extract(p.dns_header); + user_metadata.is_dns = 1; + + transition select(p.dns_header.is_response) { + 1: parse_dns_query1; + default: accept; + } + } + + +// Parsel DNS Query Label 1 + state parse_dns_query1 { + pkt.extract(p.label1); + user_metadata.last_label = 1; + + transition select(p.label1.label) { + 0: parse_query_tc; + 1: parse_dns_q1_len1; + 2: parse_dns_q1_len2; + 3: parse_dns_q1_len3; + 4: parse_dns_q1_len4; + 5: parse_dns_q1_len5; + 6: parse_dns_q1_len6; + 7: parse_dns_q1_len7; + 8: parse_dns_q1_len8; + 9: parse_dns_q1_len9; + 10: parse_dns_q1_len10; + 11: parse_dns_q1_len11; + 12: parse_dns_q1_len12; + 13: parse_dns_q1_len13; + 14: parse_dns_q1_len14; + 15: parse_dns_q1_len15; + default: accept; + } + } + + state parse_dns_q1_len1 { + pkt.extract(p.q1_part1); + transition parse_dns_query2; + } + + state parse_dns_q1_len2 { + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len3 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + transition parse_dns_query2; + } + + state parse_dns_q1_len4 { + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len5 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len6 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len7 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + transition parse_dns_query2; + } + + state parse_dns_q1_len8 { + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len9 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len10 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len11 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len12 { + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len13 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len14 { + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + state parse_dns_q1_len15 { + pkt.extract(p.q1_part1); + pkt.extract(p.q1_part2); + pkt.extract(p.q1_part4); + pkt.extract(p.q1_part8); + transition parse_dns_query2; + } + + +// Parsel DNS Query Label 2 + state parse_dns_query2 { + pkt.extract(p.label2); + user_metadata.last_label = 2; + + transition select(p.label2.label) { + 0: parse_query_tc; + 1: parse_dns_q2_len1; + 2: parse_dns_q2_len2; + 3: parse_dns_q2_len3; + 4: parse_dns_q2_len4; + 5: parse_dns_q2_len5; + 6: parse_dns_q2_len6; + 7: parse_dns_q2_len7; + 8: parse_dns_q2_len8; + 9: parse_dns_q2_len9; + 10: parse_dns_q2_len10; + 11: parse_dns_q2_len11; + 12: parse_dns_q2_len12; + 13: parse_dns_q2_len13; + 14: parse_dns_q2_len14; + 15: parse_dns_q2_len15; + 16: parse_dns_q2_len16; + 17: parse_dns_q2_len17; + 18: parse_dns_q2_len18; + 19: parse_dns_q2_len19; + 20: parse_dns_q2_len20; + 21: parse_dns_q2_len21; + 22: parse_dns_q2_len22; + 23: parse_dns_q2_len23; + 24: parse_dns_q2_len24; + 25: parse_dns_q2_len25; + 26: parse_dns_q2_len26; + 27: parse_dns_q2_len27; + 28: parse_dns_q2_len28; + 29: parse_dns_q2_len29; + 30: parse_dns_q2_len30; + 31: parse_dns_q2_len31; + default: accept; + } + } + + state parse_dns_q2_len1 { + pkt.extract(p.q2_part1); + transition parse_dns_query3; + } + + state parse_dns_q2_len2 { + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len3 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + transition parse_dns_query3; + } + + state parse_dns_q2_len4 { + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len5 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len6 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len7 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + transition parse_dns_query3; + } + + state parse_dns_q2_len8 { + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len9 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len10 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len11 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len12 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len13 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len14 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len15 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + transition parse_dns_query3; + } + + state parse_dns_q2_len16 { + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len17 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len18 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len19 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len20 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len21 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len22 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len23 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len24 { + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len25 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len26 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len27 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len28 { + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len29 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len30 { + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + state parse_dns_q2_len31 { + pkt.extract(p.q2_part1); + pkt.extract(p.q2_part2); + pkt.extract(p.q2_part4); + pkt.extract(p.q2_part8); + pkt.extract(p.q2_part16); + transition parse_dns_query3; + } + + +// Parsel DNS Query Label 3 + state parse_dns_query3 { + pkt.extract(p.label3); + user_metadata.last_label = 3; + + transition select(p.label3.label) { + 0: parse_query_tc; + 1: parse_dns_q3_len1; + 2: parse_dns_q3_len2; + 3: parse_dns_q3_len3; + 4: parse_dns_q3_len4; + 5: parse_dns_q3_len5; + 6: parse_dns_q3_len6; + 7: parse_dns_q3_len7; + 8: parse_dns_q3_len8; + 9: parse_dns_q3_len9; + 10: parse_dns_q3_len10; + 11: parse_dns_q3_len11; + 12: parse_dns_q3_len12; + 13: parse_dns_q3_len13; + 14: parse_dns_q3_len14; + 15: parse_dns_q3_len15; + 16: parse_dns_q3_len16; + 17: parse_dns_q3_len17; + 18: parse_dns_q3_len18; + 19: parse_dns_q3_len19; + 20: parse_dns_q3_len20; + 21: parse_dns_q3_len21; + 22: parse_dns_q3_len22; + 23: parse_dns_q3_len23; + 24: parse_dns_q3_len24; + 25: parse_dns_q3_len25; + 26: parse_dns_q3_len26; + 27: parse_dns_q3_len27; + 28: parse_dns_q3_len28; + 29: parse_dns_q3_len29; + 30: parse_dns_q3_len30; + 31: parse_dns_q3_len31; + default: accept; + } + } + + state parse_dns_q3_len1 { + pkt.extract(p.q3_part1); + transition parse_dns_query4; + } + + state parse_dns_q3_len2 { + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len3 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + transition parse_dns_query4; + } + + state parse_dns_q3_len4 { + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len5 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len6 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len7 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + transition parse_dns_query4; + } + + state parse_dns_q3_len8 { + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len9 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len10 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len11 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len12 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len13 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len14 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len15 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + transition parse_dns_query4; + } + + state parse_dns_q3_len16 { + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len17 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len18 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len19 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len20 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len21 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len22 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len23 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len24 { + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len25 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len26 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len27 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len28 { + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len29 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len30 { + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + state parse_dns_q3_len31 { + pkt.extract(p.q3_part1); + pkt.extract(p.q3_part2); + pkt.extract(p.q3_part4); + pkt.extract(p.q3_part8); + pkt.extract(p.q3_part16); + transition parse_dns_query4; + } + + +// Parsel DNS Query Label 4 + state parse_dns_query4 { + pkt.extract(p.label4); + user_metadata.last_label = 4; + + transition select(p.label4.label) { + 0: parse_query_tc; + 1: parse_dns_q4_len1; + 2: parse_dns_q4_len2; + 3: parse_dns_q4_len3; + 4: parse_dns_q4_len4; + 5: parse_dns_q4_len5; + 6: parse_dns_q4_len6; + 7: parse_dns_q4_len7; + default: accept; + } + } + + state parse_dns_q4_len1 { + pkt.extract(p.q4_part1); + transition parse_dns_query5; + } + + state parse_dns_q4_len2 { + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len3 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + transition parse_dns_query5; + } + + state parse_dns_q4_len4 { + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len5 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len6 { + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + state parse_dns_q4_len7 { + pkt.extract(p.q4_part1); + pkt.extract(p.q4_part2); + pkt.extract(p.q4_part4); + transition parse_dns_query5; + } + + +// Parsel DNS Query Label 5 + state parse_dns_query5 { + pkt.extract(p.label5); + user_metadata.last_label = 5; + + transition select(p.label5.label) { + 0: parse_query_tc; + default: accept; + } + } + + state parse_query_tc { + pkt.extract(p.query_tc); + user_metadata.parsed_answer = 0; + transition parse_dns_answer; + } + + state parse_dns_answer { + pkt.extract(p.dns_answer); + + transition select(p.dns_answer.tc_ans.type) { + 1: parse_a_ip; + 5: parse_cname; + default: accept; + } + } + + state parse_cname { + pkt.advance((bit<32>)p.dns_answer.rd_length); + + transition parse_dns_answer; + } + + state parse_a_ip { + pkt.extract(p.dns_ip); + user_metadata.parsed_answer = 1; + transition accept; + } +} + + +control TopVerifyChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { } +} + +control TopIngress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + + +// PRECISION STYLE TABLES + register>(TABLE_SIZE) dns_cip_table_1; + register>(TABLE_SIZE) dns_sip_table_1; + register>(TABLE_SIZE) dns_name_table_1; + register>(TABLE_SIZE) dns_timestamp_table_1; + + register>(TABLE_SIZE) dns_cip_table_2; + register>(TABLE_SIZE) dns_sip_table_2; + register>(TABLE_SIZE) dns_name_table_2; + register>(TABLE_SIZE) dns_timestamp_table_2; + + register>(TABLE_SIZE) dns_cip_table_3; + register>(TABLE_SIZE) dns_sip_table_3; + register>(TABLE_SIZE) dns_name_table_3; + register>(TABLE_SIZE) dns_timestamp_table_3; + + + register>(NUM_KNOWN_DOMAINS) packet_counts_table; + register>(NUM_KNOWN_DOMAINS) byte_counts_table; + + +// REGISTER ARRAY FOR KEEPING TRACK OF OVERFLOW DNS RESPONSES + register>(NUM_KNOWN_DOMAINS) dns_total_queried; + register>(NUM_KNOWN_DOMAINS) dns_total_missed; + + action match_domain(known_domain_id id) { + user_metadata.domain_id = id; + user_metadata.matched_domain = 1; + } + + table known_domain_list { + key = { + headers.q1_part1.part: ternary; + headers.q1_part2.part: ternary; + headers.q1_part4.part: ternary; + headers.q1_part8.part: ternary; + headers.q2_part1.part: ternary; + headers.q2_part2.part: ternary; + headers.q2_part4.part: ternary; + headers.q2_part8.part: ternary; + headers.q2_part16.part: ternary; + headers.q3_part1.part: ternary; + headers.q3_part2.part: ternary; + headers.q3_part4.part: ternary; + headers.q3_part8.part: ternary; + headers.q3_part16.part: ternary; + headers.q4_part1.part: ternary; + headers.q4_part2.part: ternary; + headers.q4_part4.part: ternary; + } + + actions = { + match_domain; + NoAction; + } + size = NUM_KNOWN_DOMAINS; + default_action = NoAction(); + } + + apply { + if(user_metadata.parsed_answer == 1) { + + user_metadata.matched_domain = 0; + + known_domain_list.apply(); + + if (user_metadata.matched_domain == 1) { + + +// Increment total DNS queries for this domain name + dns_total_queried.read(user_metadata.temp_total_dns, user_metadata.domain_id); + dns_total_queried.write(user_metadata.domain_id, user_metadata.temp_total_dns + 1); + + if (headers.dns_ip.rdata > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.dns_ip.rdata, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.dns_ip.rdata, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.dns_ip.rdata, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.dns_ip.rdata}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.dns_ip.rdata}, HASH_TABLE_MAX); + } + + user_metadata.already_matched = 0; + +// access table 1 + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + dns_timestamp_table_1.read(user_metadata.temp_timestamp, user_metadata.index_1); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_1.write(user_metadata.index_1, headers.ipv4.dst); + dns_sip_table_1.write(user_metadata.index_1, headers.dns_ip.rdata); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_1.write(user_metadata.index_1, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + + +// access table 2 + if (user_metadata.already_matched == 0) { + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + dns_timestamp_table_2.read(user_metadata.temp_timestamp, user_metadata.index_2); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_2.write(user_metadata.index_2, headers.ipv4.dst); + dns_sip_table_2.write(user_metadata.index_2, headers.dns_ip.rdata); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_2.write(user_metadata.index_2, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + +// access table 3 + if (user_metadata.already_matched == 0) { + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + dns_timestamp_table_3.read(user_metadata.temp_timestamp, user_metadata.index_3); + if (user_metadata.temp_timestamp == 0 || user_metadata.temp_timestamp + TIMEOUT < (bit<32>)standard_metadata.ingress_global_timestamp || (user_metadata.temp_cip == headers.ipv4.dst && user_metadata.temp_sip == headers.dns_ip.rdata)) { + dns_cip_table_3.write(user_metadata.index_3, headers.ipv4.dst); + dns_sip_table_3.write(user_metadata.index_3, headers.dns_ip.rdata); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + dns_name_table_3.write(user_metadata.index_3, user_metadata.domain_id); + user_metadata.already_matched = 1; + } + } + + if (user_metadata.already_matched == 0) { + +// Increment total DNS queries missed for this domain name + dns_total_missed.read(user_metadata.temp_total_missed, user_metadata.domain_id); + dns_total_missed.write(user_metadata.domain_id, user_metadata.temp_total_missed + 1); + } + } + } + +// HANDLE NORMAL, NON-DNS PACKETS + else if (user_metadata.is_ip == 1 && user_metadata.is_dns == 0) { + + if (headers.ipv4.src > headers.ipv4.dst) { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.src, 7w11, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.src, 5w3, headers.ipv4.dst}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.src, 1w1, headers.ipv4.dst}, HASH_TABLE_MAX); + } + else { + hash(user_metadata.index_1, HashAlgorithm.crc16, HASH_TABLE_BASE, {headers.ipv4.dst, 7w11, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_2, HashAlgorithm.crc16, HASH_TABLE_BASE, {3w5, headers.ipv4.dst, 5w3, headers.ipv4.src}, HASH_TABLE_MAX); + hash(user_metadata.index_3, HashAlgorithm.crc16, HASH_TABLE_BASE, {2w0, headers.ipv4.dst, 1w1, headers.ipv4.src}, HASH_TABLE_MAX); + } + + + dns_cip_table_1.read(user_metadata.temp_cip, user_metadata.index_1); + dns_sip_table_1.read(user_metadata.temp_sip, user_metadata.index_1); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_1.read(user_metadata.domain_id, user_metadata.index_1); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_1.write(user_metadata.index_1, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_2.read(user_metadata.temp_cip, user_metadata.index_2); + dns_sip_table_2.read(user_metadata.temp_sip, user_metadata.index_2); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_2.read(user_metadata.domain_id, user_metadata.index_2); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_2.write(user_metadata.index_2, (bit<32>)standard_metadata.ingress_global_timestamp); + } + + dns_cip_table_3.read(user_metadata.temp_cip, user_metadata.index_3); + dns_sip_table_3.read(user_metadata.temp_sip, user_metadata.index_3); + if ((headers.ipv4.dst == user_metadata.temp_cip && headers.ipv4.src == user_metadata.temp_sip) || (headers.ipv4.dst == user_metadata.temp_sip && headers.ipv4.src == user_metadata.temp_cip)) { + dns_name_table_3.read(user_metadata.domain_id, user_metadata.index_3); + packet_counts_table.read(user_metadata.temp_packet_counter, user_metadata.domain_id); + byte_counts_table.read(user_metadata.temp_byte_counter, user_metadata.domain_id); + packet_counts_table.write(user_metadata.domain_id, user_metadata.temp_packet_counter + 1); + byte_counts_table.write(user_metadata.domain_id, user_metadata.temp_byte_counter + (bit<32>)headers.ipv4.len); + dns_timestamp_table_3.write(user_metadata.index_3, (bit<32>)standard_metadata.ingress_global_timestamp); + } + } + } +} + +control TopEgress(inout Parsed_packet headers, + inout user_metadata_t user_metadata, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control TopComputeChecksum(inout Parsed_packet headers, inout user_metadata_t user_metadata) { + apply { + update_checksum( + headers.ipv4.isValid(), + { + headers.ipv4.version, + headers.ipv4.ihl, + headers.ipv4.tos, + headers.ipv4.len, + headers.ipv4.id, + headers.ipv4.flags, + headers.ipv4.frag, + headers.ipv4.ttl, + headers.ipv4.proto, + headers.ipv4.src, + headers.ipv4.dst + }, + headers.ipv4.chksum, + HashAlgorithm.csum16); + } +} + + +// Deparser Implementation +control TopDeparser(packet_out b, + in Parsed_packet p) { + apply { + } +} + + +// Instantiate the switch +V1Switch(TopParser(), TopVerifyChecksum(), TopIngress(), TopEgress(), TopComputeChecksum(), TopDeparser()) main; diff --git a/individual_files/000096__raw-repositories__ir-masters__p4-In-network-latency-emulator.p4 b/individual_files/000096__raw-repositories__ir-masters__p4-In-network-latency-emulator.p4 new file mode 100644 index 0000000000000000000000000000000000000000..72c5bd5c8e1c24590ee5f0fc26b1502df5831747 --- /dev/null +++ b/individual_files/000096__raw-repositories__ir-masters__p4-In-network-latency-emulator.p4 @@ -0,0 +1,304 @@ +/* BMv2 */ +#include +#include + + +#define PKT_INSTANCE_TYPE_NORMAL 0 +#define PKT_INSTANCE_TYPE_INGRESS_CLONE 1 +#define PKT_INSTANCE_TYPE_EGRESS_CLONE 2 +#define PKT_INSTANCE_TYPE_COALESCED 3 +#define PKT_INSTANCE_TYPE_INGRESS_RECIRC 4 +#define PKT_INSTANCE_TYPE_REPLICATION 5 +#define PKT_INSTANCE_TYPE_RESUBMIT 6 + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_CUSTOMDATA = 0x1313; + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + +/* Define the Ethernet header */ +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +/* Define the IPv4 header */ +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +/* Define the custom data header for latency emulation */ +header customdata_t { + bit<16> proto_id; + bit<16> content_id; + bit<16> ingress_num; + bit<8> egress_num; + bit<48> hop_latency; + +} + +const bit<8> RECIRC_FL_1 = 1; +const bit<16> MAX_RECIRC = 100000; + + +/* Metadata structure for resubmitting packets */ +struct resubmit_meta_t { + @field_list(RECIRC_FL_1) + bit<16> i; + @field_list(RECIRC_FL_1) + bit<48> arrival_time; + @field_list(RECIRC_FL_1) + bit<48> departure_time; +} + + +/* Define the metadata structure */ +struct metadata { + resubmit_meta_t resubmit_meta; +} + + +/* Define the headers structure */ +struct headers { + ethernet_t ethernet; + customdata_t customdata; + ipv4_t ipv4; +} + + + + +/* Define the parser */ +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + TYPE_CUSTOMDATA: parse_customdata; + default: accept; + } + } + + state parse_customdata { + packet.extract(hdr.customdata); + transition select(hdr.customdata.proto_id) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + + + +/* Checksum verification control block */ +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + + +/* Define the ingress processing control block */ +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + +/* Drop action */ + action drop() { + mark_to_drop(standard_metadata); + } + + +/* Update custom data processing count */ + action update_customdata_processing_count_by_num(in bit<16> ingress_num) { + hdr.customdata.ingress_num = hdr.customdata.ingress_num + ingress_num; + } + + +/* IPv4 forwarding action */ + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + +/* Custom data forwarding action */ + action customdata_forward(egressSpec_t port) { + standard_metadata.egress_spec = port; + } + + +/* Recirculate packet action */ + action recirculate_packet() { + resubmit_preserving_field_list(RECIRC_FL_1); + } + + +/* Timestamp packet arrival */ + action timestamp_packet() { + meta.resubmit_meta.arrival_time = standard_metadata.ingress_global_timestamp; + } + + +/* Calculate departure time */ + action calculate_departure_time(bit<48> latency) { + meta.resubmit_meta.departure_time = meta.resubmit_meta.arrival_time + latency; + } + + +/* Table for IPv4 forwarding */ + table ipv4_forward_table { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = NoAction(); + } + + +/* Table for custom data forwarding */ + table customdata_forward_table { + key = { + hdr.customdata.content_id: exact; + } + actions = { + customdata_forward; + drop; + } + size = 1024; + default_action = drop(); + } + + apply { + if (hdr.customdata.isValid()) { + if (standard_metadata.instance_type != PKT_INSTANCE_TYPE_INGRESS_RECIRC) { + timestamp_packet(); + calculate_departure_time(hdr.customdata.hop_latency); + update_customdata_processing_count_by_num(meta.resubmit_meta.i); + } + if (meta.resubmit_meta.departure_time > standard_metadata.ingress_global_timestamp) { + if (meta.resubmit_meta.i < MAX_RECIRC) { + meta.resubmit_meta.i = meta.resubmit_meta.i + 1; + recirculate_packet(); + } + } + update_customdata_processing_count_by_num(1); + customdata_forward_table.apply(); + } + + if (hdr.ipv4.isValid() && !hdr.customdata.isValid()) { + ipv4_forward_table.apply(); + } + } +} + + + + +/* Define the egress processing control block */ +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + +/* Update custom data processing count */ + action update_customdata_processing_count_by_num(in bit<8> egress_num) { + hdr.customdata.egress_num = hdr.customdata.egress_num + egress_num; + } + + apply { + if (hdr.customdata.isValid()) { + update_customdata_processing_count_by_num(1); + } + } +} + + + + +/* Checksum computation control block */ +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + + +/* Define the deparser */ +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.customdata); + packet.emit(hdr.ipv4); + } +} + + + + +/* Define the main switch */ +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000097__raw-repositories__In-Network-Machine-Learning__DINC.p4 b/individual_files/000097__raw-repositories__In-Network-Machine-Learning__DINC.p4 new file mode 100644 index 0000000000000000000000000000000000000000..59b595655ba5f071d156c338df987b29ef3ad731 --- /dev/null +++ b/individual_files/000097__raw-repositories__In-Network-Machine-Learning__DINC.p4 @@ -0,0 +1,260 @@ +######################################################################## +# This program is a free software tool, which does ensemble in-network machine learning. +# licensed under Apache-2.0 +# +# Copyright (c) 2020-2021 Changgang Zheng +# Copyright (c) Computing Infrastructure Group, Department of Engineering Science, University of Oxford & YINS, Yale University +# E-mail: changgang.zheng@eng.ox.ac.uk (valid until July 2024), +# changgang.zheng@yale.edu (valid until October 2022) or changgangzheng@qq.com (no expiration date) +######################################################################### +# This file was autogenerated + +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_DINC = 0x1234; +const bit<8> DINC_P = 0x50; + +// 'P' +const bit<8> DINC_4 = 0x34; + +// '4' +const bit<8> DINC_VER = 0x01; + +// v0.1 +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + + +header ethernet_h { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_h{ + bit < 4 > version; + bit < 4 > ihl; + bit < 8 > diffserv; + bit < 16 > totalLen; + bit < 16 > identification; + bit < 3 > flags; + bit < 13 > fragOffset; + bit < 8 > ttl; + bit < 8 > protocol; + bit < 16 > hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header DINC_h{ + bit<8> p; + bit<8> four; + bit<8> ver; + bit<8> typ; + bit<32> E_bitmap; + } + +header DINC_meta_h{ + bit<32> storage0; + bit<32> storage1; + bit<32> storage2; + bit<32> storage3; +} + +struct header_t { + ethernet_h ethernet; + ipv4_h ipv4; + DINC_h DINC; + DINC_meta_h DINC_meta; +} + + + +struct metadata_t { + bit<1> code_f0; + bit<2> code_f1; + bit<32> result; + bit<3> code_f2; + bit<3> code_f3; +} + + + +parser SwitchParser( + packet_in pkt, + out header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_DINC : check_DINC_version; + TYPE_IPV4 : parse_ipv4; + default : accept; + } + } + + state parse_ipv4 { + pkt.extract(hdr.ipv4); + transition accept; + } + + state check_DINC_version { + pkt.extract(hdr.ipv4); + transition select(pkt.lookahead().E_bitmap) { + 0b11000000000000000000000000000000: parse_DINC0; + default : accept; + } + } + + state parse_DINC0{ + pkt.extract(hdr.DINC_meta); + meta.code_f0 = hdr.DINC_meta.storage0[0:0]; + meta.code_f1 = hdr.DINC_meta.storage0[2:1]; + meta.code_f2 = hdr.DINC_meta.storage0[5:3]; + meta.code_f3 = hdr.DINC_meta.storage0[8:6]; + transition accept; + } +} + + + +control SwitchDeparser( + packet_out pkt, + in header_t hdr) { + apply { + pkt.emit(hdr); + } +} + + + +control SwitchVerifyChecksum(inout header_t hdr, + inout metadata_t meta) { + apply {} +} + + +control SwitchComputeChecksum(inout header_t hdr, + inout metadata_t meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + +control SwitchIngress( + inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + action drop() { + mark_to_drop(ig_intr_md); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + ig_intr_md.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + + + + action write_default_class() { + meta.result = 1; + } + + action read_lable(bit<32> label){ + meta.result = label; + } + + table decision { + key = { meta.code_f0[0:0]:exact; + meta.code_f1[1:0]:exact; + meta.code_f2[2:0]:exact; + meta.code_f3[2:0]:exact; + } + actions={ + read_lable; + write_default_class; + } + size = 13; + default_action = write_default_class; + } + + + apply{ + if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) { + ipv4_lpm.apply(); + } + + if (hdr.DINC.isValid()) { + if (hdr.DINC.E_bitmap[2:2] != 1) { + decision.apply(); + } + if (hdr.DINC.E_bitmap == 0b11000000000000000000000000000000){ + hdr.DINC_meta.storage0 = meta.result; + } + + } + + } +} + + +control SwitchEgress(inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t eg_intr_md) { + apply { + } +} + + +V1Switch( + SwitchParser(), + SwitchVerifyChecksum(), + SwitchIngress(), + SwitchEgress(), + SwitchComputeChecksum(), + SwitchDeparser() +) main; diff --git a/individual_files/000098__raw-repositories__In-Network-Machine-Learning__DINC.p4 b/individual_files/000098__raw-repositories__In-Network-Machine-Learning__DINC.p4 new file mode 100644 index 0000000000000000000000000000000000000000..0934ac610eec4b6f2dc4d62864e8c785abdd63bf --- /dev/null +++ b/individual_files/000098__raw-repositories__In-Network-Machine-Learning__DINC.p4 @@ -0,0 +1,270 @@ +######################################################################## +# This program is a free software tool, which does ensemble in-network machine learning. +# licensed under Apache-2.0 +# +# Copyright (c) 2020-2021 Changgang Zheng +# Copyright (c) Computing Infrastructure Group, Department of Engineering Science, University of Oxford & YINS, Yale University +# E-mail: changgang.zheng@eng.ox.ac.uk (valid until July 2024), +# changgang.zheng@yale.edu (valid until October 2022) or changgangzheng@qq.com (no expiration date) +######################################################################### +# This file was autogenerated + +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; +const bit<16> TYPE_DINC = 0x1234; +const bit<8> DINC_P = 0x50; + +// 'P' +const bit<8> DINC_4 = 0x34; + +// '4' +const bit<8> DINC_VER = 0x01; + +// v0.1 +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + + +header ethernet_h { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_h{ + bit < 4 > version; + bit < 4 > ihl; + bit < 8 > diffserv; + bit < 16 > totalLen; + bit < 16 > identification; + bit < 3 > flags; + bit < 13 > fragOffset; + bit < 8 > ttl; + bit < 8 > protocol; + bit < 16 > hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header DINC_h{ + bit<8> p; + bit<8> four; + bit<8> ver; + bit<8> typ; + bit<32> E_bitmap; + } + +header DINC_meta_h{ + bit<32> storage0; + bit<32> storage1; + bit<32> storage2; + bit<32> storage3; +} + +struct header_t { + ethernet_h ethernet; + ipv4_h ipv4; + DINC_h DINC; + DINC_meta_h DINC_meta; +} + + + +struct metadata_t { + bit<1> code_f0; + bit<2> code_f1; + bit<32> feature2; + bit<32> feature3; + bit<3> code_f2; + bit<3> code_f3; +} + + + +parser SwitchParser( + packet_in pkt, + out header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_DINC : check_DINC_version; + TYPE_IPV4 : parse_ipv4; + default : accept; + } + } + + state parse_ipv4 { + pkt.extract(hdr.ipv4); + transition accept; + } + + state check_DINC_version { + pkt.extract(hdr.ipv4); + transition select(pkt.lookahead().E_bitmap) { + 0b10000000000000000000000000000000: parse_DINC0; + default : accept; + } + } + + state parse_DINC0{ + pkt.extract(hdr.DINC_meta); + meta.code_f0 = hdr.DINC_meta.storage0[0:0]; + meta.code_f1 = hdr.DINC_meta.storage0[2:1]; + meta.feature2 = hdr.DINC_meta.storage0[31:3] ++ hdr.DINC_meta.storage1[2:0]; + meta.feature3 = hdr.DINC_meta.storage1[31:3] ++ hdr.DINC_meta.storage2[2:0]; + transition accept; + } +} + + + +control SwitchDeparser( + packet_out pkt, + in header_t hdr) { + apply { + pkt.emit(hdr); + } +} + + + +control SwitchVerifyChecksum(inout header_t hdr, + inout metadata_t meta) { + apply {} +} + + +control SwitchComputeChecksum(inout header_t hdr, + inout metadata_t meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + +control SwitchIngress( + inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + action drop() { + mark_to_drop(ig_intr_md); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + ig_intr_md.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + + + + action extract_feature2(out bit<3> meta_code, bit<3> tree){ + meta_code = tree; + } + + action extract_feature3(out bit<3> meta_code, bit<3> tree){ + meta_code = tree; + } + + + table lookup_feature2 { + key = { meta.feature2:ternary; } + actions = { + extract_feature2(meta.code_f2); + NoAction; + } + size = 15; + default_action = NoAction; + } + + table lookup_feature3 { + key = { meta.feature3:ternary; } + actions = { + extract_feature3(meta.code_f3); + NoAction; + } + size = 10; + default_action = NoAction; + } + + + + apply{ + if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) { + ipv4_lpm.apply(); + } + + if (hdr.DINC.isValid()) { + if (hdr.DINC.E_bitmap[1:1] != 1) { + lookup_feature2.apply(); + lookup_feature3.apply(); + } + if (hdr.DINC.E_bitmap == 0b10000000000000000000000000000000){ + hdr.DINC_meta.storage0[8:0] = meta.code_f0 ++ meta.code_f1 ++ meta.code_f2 ++ meta.code_f3; + } + + } + + } +} + + +control SwitchEgress(inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t eg_intr_md) { + apply { + } +} + + +V1Switch( + SwitchParser(), + SwitchVerifyChecksum(), + SwitchIngress(), + SwitchEgress(), + SwitchComputeChecksum(), + SwitchDeparser() +) main; diff --git a/individual_files/000099__raw-repositories__In-Network-Machine-Learning__DINC.p4 b/individual_files/000099__raw-repositories__In-Network-Machine-Learning__DINC.p4 new file mode 100644 index 0000000000000000000000000000000000000000..1827aa41c1300ce55ba94dcc240c4110bb4e9f9f --- /dev/null +++ b/individual_files/000099__raw-repositories__In-Network-Machine-Learning__DINC.p4 @@ -0,0 +1,176 @@ +######################################################################## +# This program is a free software tool, which does ensemble in-network machine learning. +# licensed under Apache-2.0 +# +# Copyright (c) 2020-2021 Changgang Zheng +# Copyright (c) Computing Infrastructure Group, Department of Engineering Science, University of Oxford & YINS, Yale University +# E-mail: changgang.zheng@eng.ox.ac.uk (valid until July 2024), +# changgang.zheng@yale.edu (valid until October 2022) or changgangzheng@qq.com (no expiration date) +######################################################################### +# This file was autogenerated + +#include +#include + + + +const bit<16> TYPE_IPV4 = 0x800; + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + + + +header ethernet_h { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_h{ + bit < 4 > version; + bit < 4 > ihl; + bit < 8 > diffserv; + bit < 16 > totalLen; + bit < 16 > identification; + bit < 3 > flags; + bit < 13 > fragOffset; + bit < 8 > ttl; + bit < 8 > protocol; + bit < 16 > hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +struct header_t { + ethernet_h ethernet; + ipv4_h ipv4; +} + + + +struct metadata_t { +} + + + +parser SwitchParser( + packet_in pkt, + out header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + pkt.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4 : parse_ipv4; + default : accept; + } + } + + state parse_ipv4 { + pkt.extract(hdr.ipv4); + transition accept; + } + +} + + + +control SwitchDeparser( + packet_out pkt, + in header_t hdr) { + apply { + pkt.emit(hdr); + } +} + + + +control SwitchVerifyChecksum(inout header_t hdr, + inout metadata_t meta) { + apply {} +} + + +control SwitchComputeChecksum(inout header_t hdr, + inout metadata_t meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + +control SwitchIngress( + inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t ig_intr_md) { + + action drop() { + mark_to_drop(ig_intr_md); + } + + action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + ig_intr_md.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_lpm { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + apply{ + if (hdr.ipv4.isValid() && hdr.ipv4.ttl > 0) { + ipv4_lpm.apply(); + } + + } +} + + +control SwitchEgress(inout header_t hdr, + inout metadata_t meta, + inout standard_metadata_t eg_intr_md) { + apply { + } +} + + +V1Switch( + SwitchParser(), + SwitchVerifyChecksum(), + SwitchIngress(), + SwitchEgress(), + SwitchComputeChecksum(), + SwitchDeparser() +) main; diff --git a/individual_files/000100__raw-repositories__jaguar-project__p4_memory_allocation.p4 b/individual_files/000100__raw-repositories__jaguar-project__p4_memory_allocation.p4 new file mode 100644 index 0000000000000000000000000000000000000000..8876268ca009d041213e88b6fa2f9ee75a36e0fe --- /dev/null +++ b/individual_files/000100__raw-repositories__jaguar-project__p4_memory_allocation.p4 @@ -0,0 +1,88 @@ +#include +#include + + +register>(1) input_traffic_bytes; +register>(1) sum_rtt_Tr; +register>(1) num_pkts_with_rtt; + +const bit<32> MAX_ALLOWABLE_RTT = 30; + +header H { + bit<32> rtt; +} + +struct metadata { + +/* empty */ + bit<32> pkt_len; +} + +struct headers { + H H_header; +} + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition accept; + } + +} + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + @atomic{ + bit<32> input_traffic_bytes_tmp; + input_traffic_bytes.read(input_traffic_bytes_tmp, 0); + input_traffic_bytes_tmp = input_traffic_bytes_tmp + meta.pkt_len; + input_traffic_bytes.write(0, input_traffic_bytes_tmp); + + if (hdr.H_header.rtt < MAX_ALLOWABLE_RTT) { + bit<32> sum_rtt_Tr_tmp; + sum_rtt_Tr.read(sum_rtt_Tr_tmp, 1); + sum_rtt_Tr_tmp = sum_rtt_Tr_tmp + hdr.H_header.rtt; + sum_rtt_Tr.write(1, sum_rtt_Tr_tmp); + + bit<32> num_pkts_with_rtt_tmp; + num_pkts_with_rtt.read(num_pkts_with_rtt_tmp, 2); + num_pkts_with_rtt_tmp = num_pkts_with_rtt_tmp + 1; + num_pkts_with_rtt.write(2, num_pkts_with_rtt_tmp); + } + } + } +} + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { } +} + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + +control MyDeparser(packet_out packet, in headers hdr) { + apply { } +} + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000101__raw-repositories__JJK96__P4-filtering.p4 b/individual_files/000101__raw-repositories__JJK96__P4-filtering.p4 new file mode 100644 index 0000000000000000000000000000000000000000..34546666420b63a594de0a23991fcaebec1ec02d --- /dev/null +++ b/individual_files/000101__raw-repositories__JJK96__P4-filtering.p4 @@ -0,0 +1,268 @@ +#include +#include + +#define OUT_PORT 2 +#define MAX_ADDRESS 32w4194304 +#define PKT_THRESHOLD 32w5 +#define DAY_THRESHOLD 32w1 + + +// Two weeks +#define TIMEOUT 48w1209600000000 +#define DAY 48w86400000000 + +const bit<16> TYPE_IPV4 = 0x800; + +register>(MAX_ADDRESS) pkt; +register>(MAX_ADDRESS) timestamp; +register>(MAX_ADDRESS) days; + +// First timestamp of the day +register>(32w1) day_start; +register>(32w1) attack; + +// Indicates whether an attack is happening or not + + +// Headers + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +struct metadata { + +/* empty */ +} + +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + tcp_t tcp; +} + + +// Parser + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV4: parse_ipv4; + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + 8w0x6: parse_tcp; + default: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } +} + + +// Checksum verification + +control MyVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + +// Ingress pipeline + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + action get_data(inout bit<32> address ,inout bit<32> num_packets, inout bit<48> ts, inout bit<32> num_days) { + hash(address, + HashAlgorithm.crc32, + 32w0, + { hdr.ipv4.srcAddr }, + MAX_ADDRESS); + +// Read the files in the registers + pkt.read(num_packets, address); + timestamp.read(ts, address); + days.read(num_days, address); + } + + action sliding_window(inout bit<32> num_packets, in bit<48> ts, inout bit<32> num_days) { + +// Sliding window + if (standard_metadata.ingress_global_timestamp - ts > TIMEOUT) { + num_packets = 0; + num_days = 0; + } + } + + action update_hashtable(inout bit<32> address, inout bit<32> num_packets, inout bit<48> ts, inout bit<32> num_days) { + bit<48> cur_time = standard_metadata.ingress_global_timestamp; + bit<48> ds; + +// Start of the day + day_start.read(ds, 32w0); + if (ts < ds || ts == 0) { + +// Last seen was before today or not seen before + num_days = num_days + 1; + } + num_packets = num_packets + 1; + + +// Write new values to the registers + pkt.write(address, num_packets); + timestamp.write(address, cur_time); + days.write(address, num_days); + } + + apply { + standard_metadata.egress_spec = OUT_PORT; + + bit<48> ds; + day_start.read(ds,32w0); + if (ds == 0) { + ds = standard_metadata.ingress_global_timestamp; + day_start.write(32w0,standard_metadata.ingress_global_timestamp); + } + bit<1> flag; + bit<32> num_packets = 0; + bit<48> ts = 0; + +// Time stamp + bit<32> num_days = 0; + bit<32> address = 0; + get_data(address, num_packets,ts,num_days); + attack.read(flag, 0); + +// Check if under attack + if (flag == 1w1) { + + if (num_packets < PKT_THRESHOLD || num_days < DAY_THRESHOLD) { + drop(); + } + } else { + update_hashtable(address, num_packets,ts,num_days); + } + +// Update start of the day + if (standard_metadata.ingress_global_timestamp - ds > DAY) { + +// One day + day_start.write(32w0,standard_metadata.ingress_global_timestamp); + +// A new day has started + } + } + +} + + +// Egress pipeline + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + hdr.ethernet.etherType = TYPE_IPV4; + } +} + + +// Checksum computation + +control MyComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + +// Deparser + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + } +} + + +// Switch + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000104__raw-repositories__KB00100100__P4NIS.p4 b/individual_files/000104__raw-repositories__KB00100100__P4NIS.p4 new file mode 100644 index 0000000000000000000000000000000000000000..7e1a7d9f3fc2ec1da935db2c1237e1045478f7b3 --- /dev/null +++ b/individual_files/000104__raw-repositories__KB00100100__P4NIS.p4 @@ -0,0 +1,408 @@ +#include +#include + +const bit<16> TYPE_IPV6 = 0x86DD; +const bit<16> TYPE_IPV4 = 0x800; +register< bit<32> >(1) count; +register< bit<8> >(256) es_box; +register< bit<8> >(256) ds_box; +register< bit<128> >(1) unicom_ip; +register< bit<32> >(1) mobile_ip; +register< bit<128> >(1) telcom_ip; +register< bit<16> >(3) udp_port; + + + + +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<32> ip4Addr_t; +typedef bit<128> ip6Addr_t; + + +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +header ipv6_t { + bit<4> version; + bit<8> trafclass; + bit<20> flowlabel; + bit<16> payloadlen; + bit<8> nextheader; + bit<8> hoplimit; + ip6Addr_t srcAddr; + ip6Addr_t dstAddr; +} + + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + ip4Addr_t srcAddr; + ip4Addr_t dstAddr; +} + + +header tcp_t { + bit<16> srcport; + bit<16> dstport; + bit<32> sequence; + bit<32> ackseq; + bit<4> headerlength; + bit<6> reservation; + bit<1> URG; + bit<1> ACK; + bit<1> PSH; + bit<1> RST; + bit<1> SYN; + bit<1> FIN; + bit<16> windowsize; + bit<16> checksum; + bit<16> pointer; +} + +header udp_t { + bit<16> srcport; + bit<16> dstport; + bit<16> userlength; + bit<16> checksum; +} + +struct metadata { + +} + +struct headers { + ethernet_t ethernet; + ipv6_t ipv6; + ipv4_t ipv4_tunnel; + ipv4_t ipv4; + tcp_t tcp; + udp_t udp_tunnel; +} + + + +parser MyParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_IPV6: parse_ipv6; + TYPE_IPV4: parse_select; + default: accept; + } + } + + state parse_ipv6 { + packet.extract(hdr.ipv6); + transition select(hdr.ipv6.nextheader) { + 0x41: parse_ipv4; + default: accept; + } + + } + + state parse_select { + transition select(standard_metadata.ingress_port) { + 2: parse_myTunnel; + _: parse_ipv4; + } + } + + state parse_myTunnel { + packet.extract(hdr.ipv4_tunnel); + transition select(hdr.ipv4_tunnel.protocol) { + 0x11: parse_udp; + default: accept; + } + } + +//only parse the udp tunnel + state parse_udp { + packet.extract(hdr.udp_tunnel); + transition select(hdr.udp_tunnel.checksum) { + 0x0: parse_ipv4; + default: reject; + } + } + + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol){ + 6: parse_tcp; + _: accept; + } + } + + state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + +} + + + + +control MyVerifyChecksum(inout headers hdr,inout metadata meta) { + apply { } +} + + + + +control MyIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action creatipv6(){ + hdr.ipv6.setValid(); + hdr.ipv6.version = 6; + hdr.ipv6.payloadlen = hdr.ipv4.totalLen; + hdr.ipv6.nextheader = 0x41; + hdr.ipv6.hoplimit = 0x40; + hdr.ethernet.etherType = TYPE_IPV6; + + } + + action creatmytunnel() { + hdr.ipv4_tunnel.setValid(); + hdr.ipv4_tunnel.version = hdr.ipv4.version; + hdr.ipv4_tunnel.ihl = 5; + hdr.ipv4_tunnel.diffserv = hdr.ipv4.diffserv; + hdr.ipv4_tunnel.totalLen = hdr.ipv4.totalLen+28; + hdr.ipv4_tunnel.identification = hdr.ipv4.identification; + hdr.ipv4_tunnel.flags = hdr.ipv4.flags; + hdr.ipv4_tunnel.fragOffset = hdr.ipv4.fragOffset; + hdr.ipv4_tunnel.ttl = hdr.ipv4.ttl; + hdr.ipv4_tunnel.protocol = 0x11; + hdr.udp_tunnel.setValid(); + hdr.udp_tunnel.srcport = 0x0050; + hdr.udp_tunnel.userlength = hdr.ipv4.totalLen; + hdr.udp_tunnel.checksum = 0x0000; + } + + + action rewrite_ipv4(){ + mobile_ip.read(hdr.ipv4_tunnel.dstAddr,(bit<32>)0); + hdr.ipv4_tunnel.srcAddr = 0xdbf270fb; + + hdr.ethernet.dstAddr = 0xdcda8025e301; + +// the mac of gw + hdr.ethernet.srcAddr = 0x6cb311222985; + +// the mac of enp8s0f1 + udp_port.read(hdr.udp_tunnel.dstport,(bit<32>)1); + } + action rewrite_ipv6_1(){ + unicom_ip.read(hdr.ipv6.dstAddr,(bit<32>)0); + + hdr.ipv6.srcAddr = 0x20010da8020520606eb311fffe222984; + +// the ipv6 address of enp8s0f0 + hdr.ethernet.dstAddr = 0xdcda8025e301; + +// the mac of gw + hdr.ethernet.srcAddr = 0x6cb311222984; + +// the mac of enp8s0f0 + } + action rewrite_ipv6_2(){ + telcom_ip.read(hdr.ipv6.dstAddr,(bit<32>)0); + + hdr.ipv6.srcAddr = 0x20010da8020520606eb311fffe222986; + +// the ipv6 address of enp8s0f2 + hdr.ethernet.dstAddr = 0xdcda8025e301; + +// the mac of gw + hdr.ethernet.srcAddr = 0x6cb311222986; + +// the mac of enp8s0f2 + } + + action read_esbox() { + es_box.read(hdr.tcp.sequence[7:0],(bit<32>)hdr.tcp.sequence[7:0]); + es_box.read(hdr.tcp.sequence[15:8],(bit<32>)hdr.tcp.sequence[15:8]); + es_box.read(hdr.tcp.sequence[23:16],(bit<32>)hdr.tcp.sequence[23:16]); + es_box.read(hdr.tcp.sequence[31:24],(bit<32>)hdr.tcp.sequence[31:24]); + es_box.read(hdr.tcp.ackseq[7:0],(bit<32>)hdr.tcp.ackseq[7:0]); + es_box.read(hdr.tcp.ackseq[15:8],(bit<32>)hdr.tcp.ackseq[15:8]); + es_box.read(hdr.tcp.ackseq[23:16],(bit<32>)hdr.tcp.ackseq[23:16]); + es_box.read(hdr.tcp.ackseq[31:24],(bit<32>)hdr.tcp.ackseq[31:24]); + } + + bit<32> temp = 0; + action do_read_count() { + count.read(temp,(bit<32>)0); + } + + apply { + + if(standard_metadata.ingress_port == 0){ + +//processing the user packages + if((hdr.ethernet.dstAddr != 0xffffffffffff) && (hdr.ethernet.srcAddr != 0x0)){ + +//processing the user packages + if(hdr.tcp.isValid()){ + read_esbox(); + } + do_read_count(); + if(temp == 0){ + creatipv6(); + rewrite_ipv6_1(); + count.write((bit<32>)0, (bit<32>)1); + standard_metadata.egress_spec = 1; + } + +// send the packages to egress 2 + if(temp == 1){ + creatmytunnel(); + rewrite_ipv4(); + count.write((bit<32>)0, (bit<32>)2); + standard_metadata.egress_spec = 2; + } + +// send the packages to egress 3 + if(temp == 2){ + creatipv6(); + rewrite_ipv6_2(); + count.write((bit<32>)0, (bit<32>)0); + standard_metadata.egress_spec = 3; + } + } + } + +// the packages come from tunnel + else { + if(standard_metadata.ingress_port == 1 && hdr.ipv6.nextheader == 0x41 && hdr.ipv6.srcAddr[63:0] == 0xf4ffa8fffea4508d){ + unicom_ip.write((bit<32>)0, hdr.ipv6.srcAddr); + }else if(standard_metadata.ingress_port == 2 && hdr.udp_tunnel.isValid() && hdr.udp_tunnel.checksum == 0x0){ + mobile_ip.write((bit<32>)0, hdr.ipv4_tunnel.srcAddr); + udp_port.write((bit<32>)1,hdr.udp_tunnel.srcport); + }else if(standard_metadata.ingress_port == 3 && hdr.ipv6.nextheader == 0x41 && hdr.ipv6.srcAddr[63:0] == 0x003410fffe2df90f){ + telcom_ip.write((bit<32>)0, hdr.ipv6.srcAddr); + } + + hdr.ethernet.etherType = TYPE_IPV4; + hdr.ethernet.dstAddr = 0x7a76233598a0; + +// the mac address of veth1 + if(hdr.ipv4_tunnel.isValid()){ + hdr.ipv4_tunnel.setInvalid(); + hdr.udp_tunnel.setInvalid(); + }else if(hdr.ipv6.isValid()){ + hdr.ipv6.setInvalid(); + } + standard_metadata.egress_spec = 0; + } + } +} + + + +control MyEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + action read_dsbox() { + ds_box.read(hdr.tcp.sequence[7:0],(bit<32>)hdr.tcp.sequence[7:0]); + ds_box.read(hdr.tcp.sequence[15:8],(bit<32>)hdr.tcp.sequence[15:8]); + ds_box.read(hdr.tcp.sequence[23:16],(bit<32>)hdr.tcp.sequence[23:16]); + ds_box.read(hdr.tcp.sequence[31:24],(bit<32>)hdr.tcp.sequence[31:24]); + ds_box.read(hdr.tcp.ackseq[7:0],(bit<32>)hdr.tcp.ackseq[7:0]); + ds_box.read(hdr.tcp.ackseq[15:8],(bit<32>)hdr.tcp.ackseq[15:8]); + ds_box.read(hdr.tcp.ackseq[23:16],(bit<32>)hdr.tcp.ackseq[23:16]); + ds_box.read(hdr.tcp.ackseq[31:24],(bit<32>)hdr.tcp.ackseq[31:24]); + } + apply { + if(standard_metadata.egress_port == 0 && hdr.tcp.isValid()) { + read_dsbox(); + } + } +} + + + +control MyComputeChecksum(inout headers hdr,inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + + update_checksum( + hdr.ipv4_tunnel.isValid(), + { hdr.ipv4_tunnel.version, + hdr.ipv4_tunnel.ihl, + hdr.ipv4_tunnel.diffserv, + hdr.ipv4_tunnel.totalLen, + hdr.ipv4_tunnel.identification, + hdr.ipv4_tunnel.flags, + hdr.ipv4_tunnel.fragOffset, + hdr.ipv4_tunnel.ttl, + hdr.ipv4_tunnel.protocol, + hdr.ipv4_tunnel.srcAddr, + hdr.ipv4_tunnel.dstAddr }, + hdr.ipv4_tunnel.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control MyDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.ipv6); + packet.emit(hdr.ipv4_tunnel); + packet.emit(hdr.udp_tunnel); + packet.emit(hdr.ipv4); + packet.emit(hdr.tcp); + } +} + + + +V1Switch( +MyParser(), +MyVerifyChecksum(), +MyIngress(), +MyEgress(), +MyComputeChecksum(), +MyDeparser() +) main; diff --git a/individual_files/000105__raw-repositories__KB00100100__P4NIS.p4 b/individual_files/000105__raw-repositories__KB00100100__P4NIS.p4 new file mode 100644 index 0000000000000000000000000000000000000000..fc92f843fde138b9279b824e3829ba8da0128196 --- /dev/null +++ b/individual_files/000105__raw-repositories__KB00100100__P4NIS.p4 @@ -0,0 +1,1035 @@ + +#include +#include + + +const bit<16> TYPE_SINET = 0x9999; +const bit<16> TYPE_IPv4 = 0x0800; + + +//definitions of some global type. +typedef bit<9> egressSpec_t; +typedef bit<48> macAddr_t; +typedef bit<8> sinetAddrLength_t; +typedef bit<256> sinetAddr_t; + + + +//the template of ethernet header. +header ethernet_t { + macAddr_t dstAddr; + macAddr_t srcAddr; + bit<16> etherType; +} + + +//the template of sinet header. +header sinet_t { + bit<4> version; + bit<8> slicing_id; + bit<20> flow_label; + bit<16> payload_length; + bit<8> next_header; + bit<8> srcAddr_length; + bit<8> dstAddr_length; + bit<8> hop_limit; + bit<16> extra_state_info; + bit<32> srcAddr; + bit<32> dstAddr; +} + + +header sinet_extend_src_graft_t { + bit<8> next_header; + bit<24> srcAddr; +} + + +header sinet_extend_dst_graft_t { + bit<8> next_header; + bit<24> dstAddr; +} + + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + +struct metadata { + +/* empty */ + bit<256> sinetAddr_src; + bit<256> sinetAddr_dst; +} + + +//instantiate the headers. +struct headers { + ethernet_t ethernet; + ipv4_t ipv4; + + sinet_t sinet; + sinet_extend_src_graft_t sinet_extend_src_graft0; + sinet_extend_src_graft_t sinet_extend_src_graft1; + sinet_extend_src_graft_t sinet_extend_src_graft2; + sinet_extend_src_graft_t sinet_extend_src_graft3; + sinet_extend_src_graft_t sinet_extend_src_graft4; + sinet_extend_src_graft_t sinet_extend_src_graft5; + sinet_extend_src_graft_t sinet_extend_src_graft6; + sinet_extend_src_graft_t sinet_extend_src_graft7; + sinet_extend_src_graft_t sinet_extend_src_graft8; + sinet_extend_src_graft_t sinet_extend_src_graft9; + sinet_extend_dst_graft_t sinet_extend_dst_graft0; + sinet_extend_dst_graft_t sinet_extend_dst_graft1; + sinet_extend_dst_graft_t sinet_extend_dst_graft2; + sinet_extend_dst_graft_t sinet_extend_dst_graft3; + sinet_extend_dst_graft_t sinet_extend_dst_graft4; + sinet_extend_dst_graft_t sinet_extend_dst_graft5; + sinet_extend_dst_graft_t sinet_extend_dst_graft6; + sinet_extend_dst_graft_t sinet_extend_dst_graft7; + sinet_extend_dst_graft_t sinet_extend_dst_graft8; + sinet_extend_dst_graft_t sinet_extend_dst_graft9; +} + + + + +parser BlackBoxParser(packet_in packet, + out headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + state start { + transition parse_ethernet; + } + + state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + TYPE_SINET: parse_sinet; + TYPE_IPv4: parse_ipv4; + default: accept; + } + } + + state parse_sinet { + packet.extract(hdr.sinet); + +//32 bits + meta.sinetAddr_src[255:224] = hdr.sinet.srcAddr; + meta.sinetAddr_dst[255:224] = hdr.sinet.dstAddr; + transition select(hdr.sinet.next_header) { + 0x80: parse_sinet_extend_src_graft0; + 0x90: parse_sinet_extend_dst_graft0; + 0x88: parse_ipv4; + default: accept; + } + } + + state parse_sinet_extend_src_graft0 { + packet.extract(hdr.sinet_extend_src_graft0); + + meta.sinetAddr_src[223:200] = hdr.sinet_extend_src_graft0.srcAddr; + transition select(hdr.sinet_extend_src_graft0.next_header) { + 0x80: parse_sinet_extend_src_graft1; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft1 { + packet.extract(hdr.sinet_extend_src_graft1); + + meta.sinetAddr_src[199:176] = hdr.sinet_extend_src_graft1.srcAddr; + transition select(hdr.sinet_extend_src_graft1.next_header) { + 0x80: parse_sinet_extend_src_graft2; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft2 { + packet.extract(hdr.sinet_extend_src_graft2); + + meta.sinetAddr_src[175:152] = hdr.sinet_extend_src_graft2.srcAddr; + transition select(hdr.sinet_extend_src_graft2.next_header) { + 0x80: parse_sinet_extend_src_graft3; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft3 { + packet.extract(hdr.sinet_extend_src_graft3); + + meta.sinetAddr_src[151:128] = hdr.sinet_extend_src_graft3.srcAddr; + transition select(hdr.sinet_extend_src_graft3.next_header) { + 0x80: parse_sinet_extend_src_graft4; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft4 { + packet.extract(hdr.sinet_extend_src_graft4); + + meta.sinetAddr_src[127:104] = hdr.sinet_extend_src_graft4.srcAddr; + transition select(hdr.sinet_extend_src_graft4.next_header) { + 0x80: parse_sinet_extend_src_graft5; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft5 { + packet.extract(hdr.sinet_extend_src_graft5); + + meta.sinetAddr_src[103:80] = hdr.sinet_extend_src_graft5.srcAddr; + transition select(hdr.sinet_extend_src_graft5.next_header) { + 0x80: parse_sinet_extend_src_graft6; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft6 { + packet.extract(hdr.sinet_extend_src_graft6); + + meta.sinetAddr_src[79:56] = hdr.sinet_extend_src_graft6.srcAddr; + transition select(hdr.sinet_extend_src_graft6.next_header) { + 0x80: parse_sinet_extend_src_graft7; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft7 { + packet.extract(hdr.sinet_extend_src_graft7); + + meta.sinetAddr_src[55:32] = hdr.sinet_extend_src_graft7.srcAddr; + transition select(hdr.sinet_extend_src_graft7.next_header) { + 0x80: parse_sinet_extend_src_graft8; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft8 { + packet.extract(hdr.sinet_extend_src_graft8); + + meta.sinetAddr_src[31:8] = hdr.sinet_extend_src_graft8.srcAddr; + transition select(hdr.sinet_extend_src_graft8.next_header) { + 0x80: parse_sinet_extend_src_graft9; + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_src_graft9 { + packet.extract(hdr.sinet_extend_src_graft9); + + meta.sinetAddr_src[7:0] = hdr.sinet_extend_src_graft9.srcAddr[23:16]; + transition select(hdr.sinet_extend_src_graft9.next_header) { + 0x90: parse_sinet_extend_dst_graft0; + default: accept; + } + } + + state parse_sinet_extend_dst_graft0 { + packet.extract(hdr.sinet_extend_dst_graft0); + + meta.sinetAddr_dst[223:200] = hdr.sinet_extend_dst_graft0.dstAddr; + transition select(hdr.sinet_extend_dst_graft0.next_header) { + 0x90: parse_sinet_extend_dst_graft1; + default: accept; + } + } + + state parse_sinet_extend_dst_graft1 { + packet.extract(hdr.sinet_extend_dst_graft1); + + meta.sinetAddr_dst[199:176] = hdr.sinet_extend_dst_graft1.dstAddr; + transition select(hdr.sinet_extend_dst_graft1.next_header) { + 0x90: parse_sinet_extend_dst_graft2; + default: accept; + } + } + + state parse_sinet_extend_dst_graft2 { + packet.extract(hdr.sinet_extend_dst_graft2); + + meta.sinetAddr_dst[175:152] = hdr.sinet_extend_dst_graft2.dstAddr; + transition select(hdr.sinet_extend_dst_graft2.next_header) { + 0x90: parse_sinet_extend_dst_graft3; + default: accept; + } + } + + state parse_sinet_extend_dst_graft3 { + packet.extract(hdr.sinet_extend_dst_graft3); + + meta.sinetAddr_dst[151:128] = hdr.sinet_extend_dst_graft3.dstAddr; + transition select(hdr.sinet_extend_dst_graft3.next_header) { + 0x90: parse_sinet_extend_dst_graft4; + default: accept; + } + } + + state parse_sinet_extend_dst_graft4 { + packet.extract(hdr.sinet_extend_dst_graft4); + + meta.sinetAddr_dst[127:104] = hdr.sinet_extend_dst_graft4.dstAddr; + transition select(hdr.sinet_extend_dst_graft4.next_header) { + 0x90: parse_sinet_extend_dst_graft5; + default: accept; + } + } + + state parse_sinet_extend_dst_graft5 { + packet.extract(hdr.sinet_extend_dst_graft5); + + meta.sinetAddr_dst[103:80] = hdr.sinet_extend_dst_graft5.dstAddr; + transition select(hdr.sinet_extend_dst_graft5.next_header) { + 0x90: parse_sinet_extend_dst_graft6; + default: accept; + } + } + + state parse_sinet_extend_dst_graft6 { + packet.extract(hdr.sinet_extend_dst_graft6); + + meta.sinetAddr_dst[79:56] = hdr.sinet_extend_dst_graft6.dstAddr; + transition select(hdr.sinet_extend_dst_graft6.next_header) { + 0x90: parse_sinet_extend_dst_graft7; + default: accept; + } + } + + state parse_sinet_extend_dst_graft7 { + packet.extract(hdr.sinet_extend_dst_graft7); + + meta.sinetAddr_dst[55:32] = hdr.sinet_extend_dst_graft7.dstAddr; + transition select(hdr.sinet_extend_dst_graft7.next_header) { + 0x90: parse_sinet_extend_dst_graft8; + default: accept; + } + } + + state parse_sinet_extend_dst_graft8 { + packet.extract(hdr.sinet_extend_dst_graft8); + + meta.sinetAddr_dst[31:8] = hdr.sinet_extend_dst_graft8.dstAddr; + transition select(hdr.sinet_extend_dst_graft8.next_header) { + 0x90: parse_sinet_extend_dst_graft9; + default: accept; + } + } + + state parse_sinet_extend_dst_graft9 { + packet.extract(hdr.sinet_extend_dst_graft9); + + meta.sinetAddr_dst[7:0] = hdr.sinet_extend_dst_graft9.dstAddr[23:16]; + transition select(hdr.sinet_extend_dst_graft9.next_header) { + default: accept; + } + } + + state parse_ipv4 { + packet.extract(hdr.ipv4); + transition accept; + } +} + + +control BlackBoxVerifyChecksum(inout headers hdr, inout metadata meta) { + apply { } +} + + + +control BlackBoxIngress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + + action drop() { + mark_to_drop(standard_metadata); + } + + + action ipv4_sinet_forward(macAddr_t dst_mac_addr, sinetAddrLength_t src_sinet_length, sinetAddr_t src_sinet_addr, sinetAddrLength_t dst_sinet_length, sinetAddr_t dst_sinet_addr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dst_mac_addr; + hdr.sinet.srcAddr_length = src_sinet_length; + meta.sinetAddr_src = src_sinet_addr; + hdr.sinet.dstAddr_length = dst_sinet_length; + meta.sinetAddr_dst = dst_sinet_addr; + hdr.sinet.hop_limit = hdr.ipv4.ttl - 1; + } + + +//para: + action sinet_ipv4_forward(macAddr_t dstAddr, egressSpec_t port) { + standard_metadata.egress_spec = port; + hdr.ethernet.srcAddr = hdr.ethernet.dstAddr; + hdr.ethernet.dstAddr = dstAddr; + hdr.ipv4.ttl = hdr.ipv4.ttl - 1; + } + + table ipv4_sinet { + key = { + hdr.ipv4.dstAddr: lpm; + } + actions = { + ipv4_sinet_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + table sinet_ipv4 { + key = { + meta.sinetAddr_dst: lpm; + } + actions = { + sinet_ipv4_forward; + drop; + NoAction; + } + size = 1024; + default_action = drop(); + } + + apply{ + + if(!hdr.sinet.isValid()) { + hdr.sinet.setValid(); + + hdr.ethernet.etherType = TYPE_SINET; + ipv4_sinet.apply(); + } + else{ + hdr.sinet.setInvalid(); + if(hdr.sinet_extend_src_graft0.isValid()) { + hdr.sinet_extend_src_graft0.setInvalid(); + } + if(hdr.sinet_extend_src_graft1.isValid()) { + hdr.sinet_extend_src_graft1.setInvalid(); + } + if(hdr.sinet_extend_src_graft2.isValid()) { + hdr.sinet_extend_src_graft2.setInvalid(); + } + if(hdr.sinet_extend_src_graft3.isValid()) { + hdr.sinet_extend_src_graft3.setInvalid(); + } + if(hdr.sinet_extend_src_graft4.isValid()) { + hdr.sinet_extend_src_graft4.setInvalid(); + } + if(hdr.sinet_extend_src_graft5.isValid()) { + hdr.sinet_extend_src_graft5.setInvalid(); + } + if(hdr.sinet_extend_src_graft6.isValid()) { + hdr.sinet_extend_src_graft6.setInvalid(); + } + if(hdr.sinet_extend_src_graft7.isValid()) { + hdr.sinet_extend_src_graft7.setInvalid(); + } + if(hdr.sinet_extend_src_graft8.isValid()) { + hdr.sinet_extend_src_graft8.setInvalid(); + } + if(hdr.sinet_extend_src_graft9.isValid()) { + hdr.sinet_extend_src_graft9.setInvalid(); + } + if(hdr.sinet_extend_dst_graft0.isValid()) { + hdr.sinet_extend_dst_graft0.setInvalid(); + } + if(hdr.sinet_extend_dst_graft1.isValid()) { + hdr.sinet_extend_dst_graft1.setInvalid(); + } + if(hdr.sinet_extend_dst_graft2.isValid()) { + hdr.sinet_extend_dst_graft2.setInvalid(); + } + if(hdr.sinet_extend_dst_graft3.isValid()) { + hdr.sinet_extend_dst_graft3.setInvalid(); + } + if(hdr.sinet_extend_dst_graft4.isValid()) { + hdr.sinet_extend_dst_graft4.setInvalid(); + } + if(hdr.sinet_extend_dst_graft5.isValid()) { + hdr.sinet_extend_dst_graft5.setInvalid(); + } + if(hdr.sinet_extend_dst_graft6.isValid()) { + hdr.sinet_extend_dst_graft6.setInvalid(); + } + if(hdr.sinet_extend_dst_graft7.isValid()) { + hdr.sinet_extend_dst_graft7.setInvalid(); + } + if(hdr.sinet_extend_dst_graft8.isValid()) { + hdr.sinet_extend_dst_graft8.setInvalid(); + } + if(hdr.sinet_extend_dst_graft9.isValid()) { + hdr.sinet_extend_dst_graft9.setInvalid(); + } + hdr.ethernet.etherType = TYPE_IPv4; + sinet_ipv4.apply(); + } + } +} + + + +control BlackBoxEgress(inout headers hdr, + inout metadata meta, + inout standard_metadata_t standard_metadata) { + apply { + if(hdr.sinet.isValid()) { + +// modify the variable srcAddr length + if(hdr.sinet.srcAddr_length >= 239) { + hdr.sinet_extend_src_graft9.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft9.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft9.next_header = 0x88; + } + hdr.sinet_extend_src_graft9.srcAddr[23:16] = meta.sinetAddr_src[7:0]; + hdr.sinet_extend_src_graft8.setValid(); + hdr.sinet_extend_src_graft8.next_header = 0x80; + hdr.sinet_extend_src_graft8.srcAddr = meta.sinetAddr_src[31:8]; + hdr.sinet_extend_src_graft7.setValid(); + hdr.sinet_extend_src_graft7.next_header = 0x80; + hdr.sinet_extend_src_graft7.srcAddr = meta.sinetAddr_src[55:32]; + hdr.sinet_extend_src_graft6.setValid(); + hdr.sinet_extend_src_graft6.next_header = 0x80; + hdr.sinet_extend_src_graft6.srcAddr = meta.sinetAddr_src[79:56]; + hdr.sinet_extend_src_graft5.setValid(); + hdr.sinet_extend_src_graft5.next_header = 0x80; + hdr.sinet_extend_src_graft5.srcAddr = meta.sinetAddr_src[103:80]; + hdr.sinet_extend_src_graft4.setValid(); + hdr.sinet_extend_src_graft4.next_header = 0x80; + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 216) { + hdr.sinet_extend_src_graft8.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft8.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft8.next_header = 0x88; + } + hdr.sinet_extend_src_graft8.srcAddr = meta.sinetAddr_src[31:8]; + hdr.sinet_extend_src_graft7.setValid(); + hdr.sinet_extend_src_graft7.next_header = 0x80; + hdr.sinet_extend_src_graft7.srcAddr = meta.sinetAddr_src[55:32]; + hdr.sinet_extend_src_graft6.setValid(); + hdr.sinet_extend_src_graft6.next_header = 0x80; + hdr.sinet_extend_src_graft6.srcAddr = meta.sinetAddr_src[79:56]; + hdr.sinet_extend_src_graft5.setValid(); + hdr.sinet_extend_src_graft5.next_header = 0x80; + hdr.sinet_extend_src_graft5.srcAddr = meta.sinetAddr_src[103:80]; + hdr.sinet_extend_src_graft4.setValid(); + hdr.sinet_extend_src_graft4.next_header = 0x80; + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 193) { + hdr.sinet_extend_src_graft7.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft7.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft7.next_header = 0x88; + } + hdr.sinet_extend_src_graft7.srcAddr = meta.sinetAddr_src[55:32]; + hdr.sinet_extend_src_graft6.setValid(); + hdr.sinet_extend_src_graft6.next_header = 0x80; + hdr.sinet_extend_src_graft6.srcAddr = meta.sinetAddr_src[79:56]; + hdr.sinet_extend_src_graft5.setValid(); + hdr.sinet_extend_src_graft5.next_header = 0x80; + hdr.sinet_extend_src_graft5.srcAddr = meta.sinetAddr_src[103:80]; + hdr.sinet_extend_src_graft4.setValid(); + hdr.sinet_extend_src_graft4.next_header = 0x80; + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 170) { + hdr.sinet_extend_src_graft6.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft6.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft6.next_header = 0x88; + } + hdr.sinet_extend_src_graft6.srcAddr = meta.sinetAddr_src[79:56]; + hdr.sinet_extend_src_graft5.setValid(); + hdr.sinet_extend_src_graft5.next_header = 0x80; + hdr.sinet_extend_src_graft5.srcAddr = meta.sinetAddr_src[103:80]; + hdr.sinet_extend_src_graft4.setValid(); + hdr.sinet_extend_src_graft4.next_header = 0x80; + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 147) { + hdr.sinet_extend_src_graft5.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft5.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft5.next_header = 0x88; + } + hdr.sinet_extend_src_graft5.srcAddr = meta.sinetAddr_src[103:80]; + hdr.sinet_extend_src_graft4.setValid(); + hdr.sinet_extend_src_graft4.next_header = 0x80; + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 124) { + hdr.sinet_extend_src_graft4.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft4.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft4.next_header = 0x88; + } + hdr.sinet_extend_src_graft4.srcAddr = meta.sinetAddr_src[127:104]; + hdr.sinet_extend_src_graft3.setValid(); + hdr.sinet_extend_src_graft3.next_header = 0x80; + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 101) { + hdr.sinet_extend_src_graft3.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft3.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft3.next_header = 0x88; + } + hdr.sinet_extend_src_graft3.srcAddr = meta.sinetAddr_src[151:128]; + hdr.sinet_extend_src_graft2.setValid(); + hdr.sinet_extend_src_graft2.next_header = 0x80; + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 78) { + hdr.sinet_extend_src_graft2.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft2.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft2.next_header = 0x88; + } + hdr.sinet_extend_src_graft2.srcAddr = meta.sinetAddr_src[175:152]; + hdr.sinet_extend_src_graft1.setValid(); + hdr.sinet_extend_src_graft1.next_header = 0x80; + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 55) { + hdr.sinet_extend_src_graft1.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft1.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft1.next_header = 0x88; + } + hdr.sinet_extend_src_graft1.srcAddr = meta.sinetAddr_src[199:176]; + hdr.sinet_extend_src_graft0.setValid(); + hdr.sinet_extend_src_graft0.next_header = 0x80; + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else if(hdr.sinet.srcAddr_length >= 32) { + hdr.sinet_extend_src_graft0.setValid(); + if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_src_graft0.next_header = 0x90; + } + else { + hdr.sinet_extend_src_graft0.next_header = 0x88; + } + hdr.sinet_extend_src_graft0.srcAddr = meta.sinetAddr_src[223:200]; + hdr.sinet.next_header = 0x80; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + else { + hdr.sinet.next_header = 0x88; + hdr.sinet.srcAddr = meta.sinetAddr_src[255:224]; + } + + +// modify the variable srcAddr length + if(hdr.sinet.dstAddr_length >= 239) { + hdr.sinet_extend_dst_graft9.setValid(); + hdr.sinet_extend_dst_graft9.next_header = 0x88; + hdr.sinet_extend_dst_graft9.dstAddr[23:16] = meta.sinetAddr_dst[7:0]; + hdr.sinet_extend_dst_graft8.setValid(); + hdr.sinet_extend_dst_graft8.next_header = 0x90; + hdr.sinet_extend_dst_graft8.dstAddr = meta.sinetAddr_dst[31:8]; + hdr.sinet_extend_dst_graft7.setValid(); + hdr.sinet_extend_dst_graft7.next_header = 0x90; + hdr.sinet_extend_dst_graft7.dstAddr = meta.sinetAddr_dst[55:32]; + hdr.sinet_extend_dst_graft6.setValid(); + hdr.sinet_extend_dst_graft6.next_header = 0x90; + hdr.sinet_extend_dst_graft6.dstAddr = meta.sinetAddr_dst[79:56]; + hdr.sinet_extend_dst_graft5.setValid(); + hdr.sinet_extend_dst_graft5.next_header = 0x90; + hdr.sinet_extend_dst_graft5.dstAddr = meta.sinetAddr_dst[103:80]; + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x90; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 216) { + hdr.sinet_extend_dst_graft8.setValid(); + hdr.sinet_extend_dst_graft8.next_header = 0x88; + hdr.sinet_extend_dst_graft8.dstAddr = meta.sinetAddr_dst[31:8]; + hdr.sinet_extend_dst_graft7.setValid(); + hdr.sinet_extend_dst_graft7.next_header = 0x90; + hdr.sinet_extend_dst_graft7.dstAddr = meta.sinetAddr_dst[55:32]; + hdr.sinet_extend_dst_graft6.setValid(); + hdr.sinet_extend_dst_graft6.next_header = 0x90; + hdr.sinet_extend_dst_graft6.dstAddr = meta.sinetAddr_dst[79:56]; + hdr.sinet_extend_dst_graft5.setValid(); + hdr.sinet_extend_dst_graft5.next_header = 0x90; + hdr.sinet_extend_dst_graft5.dstAddr = meta.sinetAddr_dst[103:80]; + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x90; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 193) { + hdr.sinet_extend_dst_graft7.setValid(); + hdr.sinet_extend_dst_graft7.next_header = 0x88; + hdr.sinet_extend_dst_graft7.dstAddr = meta.sinetAddr_dst[55:32]; + hdr.sinet_extend_dst_graft6.setValid(); + hdr.sinet_extend_dst_graft6.next_header = 0x90; + hdr.sinet_extend_dst_graft6.dstAddr = meta.sinetAddr_dst[79:56]; + hdr.sinet_extend_dst_graft5.setValid(); + hdr.sinet_extend_dst_graft5.next_header = 0x90; + hdr.sinet_extend_dst_graft5.dstAddr = meta.sinetAddr_dst[103:80]; + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x90; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 170) { + hdr.sinet_extend_dst_graft6.setValid(); + hdr.sinet_extend_dst_graft6.next_header = 0x88; + hdr.sinet_extend_dst_graft6.dstAddr = meta.sinetAddr_dst[79:56]; + hdr.sinet_extend_dst_graft5.setValid(); + hdr.sinet_extend_dst_graft5.next_header = 0x90; + hdr.sinet_extend_dst_graft5.dstAddr = meta.sinetAddr_dst[103:80]; + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x90; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 147) { + hdr.sinet_extend_dst_graft5.setValid(); + hdr.sinet_extend_dst_graft5.next_header = 0x88; + hdr.sinet_extend_dst_graft5.dstAddr = meta.sinetAddr_dst[103:80]; + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x90; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 124) { + hdr.sinet_extend_dst_graft4.setValid(); + hdr.sinet_extend_dst_graft4.next_header = 0x88; + hdr.sinet_extend_dst_graft4.dstAddr = meta.sinetAddr_dst[127:104]; + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x90; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 101) { + hdr.sinet_extend_dst_graft3.setValid(); + hdr.sinet_extend_dst_graft3.next_header = 0x88; + hdr.sinet_extend_dst_graft3.dstAddr = meta.sinetAddr_dst[151:128]; + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x90; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 78) { + hdr.sinet_extend_dst_graft2.setValid(); + hdr.sinet_extend_dst_graft2.next_header = 0x88; + hdr.sinet_extend_dst_graft2.dstAddr = meta.sinetAddr_dst[175:152]; + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x90; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 55) { + hdr.sinet_extend_dst_graft1.setValid(); + hdr.sinet_extend_dst_graft1.next_header = 0x88; + hdr.sinet_extend_dst_graft1.dstAddr = meta.sinetAddr_dst[199:176]; + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x90; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else if(hdr.sinet.dstAddr_length >= 32) { + hdr.sinet_extend_dst_graft0.setValid(); + hdr.sinet_extend_dst_graft0.next_header = 0x88; + hdr.sinet_extend_dst_graft0.dstAddr = meta.sinetAddr_dst[223:200]; + + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + else { + hdr.sinet.dstAddr = meta.sinetAddr_dst[255:224]; + } + } + } +} + + + +control BlackBoxComputeChecksum(inout headers hdr, inout metadata meta) { + apply { + update_checksum( + hdr.ipv4.isValid(), + { hdr.ipv4.version, + hdr.ipv4.ihl, + hdr.ipv4.diffserv, + hdr.ipv4.totalLen, + hdr.ipv4.identification, + hdr.ipv4.flags, + hdr.ipv4.fragOffset, + hdr.ipv4.ttl, + hdr.ipv4.protocol, + hdr.ipv4.srcAddr, + hdr.ipv4.dstAddr }, + hdr.ipv4.hdrChecksum, + HashAlgorithm.csum16); + } +} + + + +control BlackBoxDeparser(packet_out packet, in headers hdr) { + apply { + packet.emit(hdr.ethernet); + packet.emit(hdr.sinet); + packet.emit(hdr.sinet_extend_src_graft0); + packet.emit(hdr.sinet_extend_src_graft1); + packet.emit(hdr.sinet_extend_src_graft2); + packet.emit(hdr.sinet_extend_src_graft3); + packet.emit(hdr.sinet_extend_src_graft4); + packet.emit(hdr.sinet_extend_src_graft5); + packet.emit(hdr.sinet_extend_src_graft6); + packet.emit(hdr.sinet_extend_src_graft7); + packet.emit(hdr.sinet_extend_src_graft8); + packet.emit(hdr.sinet_extend_src_graft9); + packet.emit(hdr.sinet_extend_dst_graft0); + packet.emit(hdr.sinet_extend_dst_graft1); + packet.emit(hdr.sinet_extend_dst_graft2); + packet.emit(hdr.sinet_extend_dst_graft3); + packet.emit(hdr.sinet_extend_dst_graft4); + packet.emit(hdr.sinet_extend_dst_graft5); + packet.emit(hdr.sinet_extend_dst_graft6); + packet.emit(hdr.sinet_extend_dst_graft7); + packet.emit(hdr.sinet_extend_dst_graft8); + packet.emit(hdr.sinet_extend_dst_graft9); + packet.emit(hdr.ipv4); + } +} + + +V1Switch( +BlackBoxParser(), +BlackBoxVerifyChecksum(), +BlackBoxIngress(), +BlackBoxEgress(), +BlackBoxComputeChecksum(), +BlackBoxDeparser() +) main; diff --git a/individual_files/000107__raw-repositories__intrig-unicamp__macsad-usecases.p4 b/individual_files/000107__raw-repositories__intrig-unicamp__macsad-usecases.p4 new file mode 100644 index 0000000000000000000000000000000000000000..4a2c16ea5f796734a02ae80b14e246942c858398 --- /dev/null +++ b/individual_files/000107__raw-repositories__intrig-unicamp__macsad-usecases.p4 @@ -0,0 +1,509 @@ +#include +#include + +/*Unless required by applicable law or agreed to in writing, software */ + + +#ifndef _STANDARD_HEADERS_P4_ +#define _STANDARD_HEADERS_P4_ + + +header cpu_header_t { + bit<64> preamble; + bit<8> device; + bit<8> reason; + bit<8> if_index; +} + +header arp_t { + bit<16> htype; + bit<16> ptype; + bit<8> hlen; + bit<8> plen; + bit<16> oper; +} + +header ethernet_t +{ + bit<48> dstAddr; + bit<48> srcAddr; + bit<16> etherType; +} + +header ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; +} + + + +header icmp_t { + bit<8> type; + bit<8> code; + bit<16> checksum; +} + +header tcp_t { + bit<16> srcPort; + bit<16> dstPort; + bit<32> seqNo; + bit<32> ackNo; + bit<4> dataOffset; + bit<4> res; + bit<8> flags; + bit<16> window; + bit<16> checksum; + bit<16> urgentPtr; +} + +header gre_t { + bit<1> C; + bit<1> R; + bit<1> K; + bit<1> S; + bit<1> s; + bit<3> recurse; + bit<5> flags; + bit<3> ver; + bit<16> proto; +} + +header udp_h { + bit<16> srcPort; + bit<16> dstPort; + bit<16> length_; + bit<16> checksum; +} + +header sctp_h { + bit<16> srcPort; + bit<16> dstPort; + bit<32> verifTag; + bit<32> checksum; +} + + +header arp_ipv4_t { + bit<48> sha; + bit<32> spa; + bit<48> tha; + bit<32> tpa; +} +#endif + + + +const bit<16> ETHERTYPE_IPV4 = 0x0800; +const bit<16> ETHERTYPE_ARP = 0x0806; +const bit<8> IPPROTO_ICMP = 0x01; + + +/*headers*/ + +const bit<16> ARP_HTYPE_ETHERNET = 0x0001; +const bit<16> ARP_PTYPE_IPV4 = 0x0800; +const bit<8> ARP_HLEN_ETHERNET = 6; +const bit<8> ARP_PLEN_IPV4 = 4; + + +struct headers { + ethernet_t ethernet; + ethernet_t outer_ethernet; + ethernet_t ethernet_decap; + arp_t arp; + ipv4_t ipv4; + ipv4_t outer_ipv4; + + gre_t gre; + tcp_t tcp; + icmp_t icmp; + @name("inner_ipv4") + ipv4_t inner_ipv4; + @name("inner_ethernet") + ethernet_t inner_ethernet; + @name("inner_tcp") + tcp_t inner_tcp; + @name("inner_icmp") + icmp_t inner_icmp; +} + + struct meta_ipv4_t { + bit<4> version; + bit<4> ihl; + bit<8> diffserv; + bit<16> totalLen; + bit<16> identification; + bit<3> flags; + bit<13> fragOffset; + bit<8> ttl; + bit<8> protocol; + bit<16> hdrChecksum; + bit<32> srcAddr; + bit<32> dstAddr; + } + +/*metadata*/ +struct routing_metadata_t { + bit<32> nhgroup; + + bit<32> dst_ipv4; + bit<32> src_ipv4; + bit<48> mac_da; + bit<48> mac_sa; + bit<9> egress_port; + bit<48> my_mac; + + bit<32> nhop_ipv4; + bit<1> do_forward; + bit<1> rewrite_outer; + bit<16> tcp_sp; + bit<16> tcp_dp; + + bit<8> if_index; + bit<32> if_ipv4_addr; + bit<48> if_mac_addr; + bit<1> is_ext_if; + + bit<32> tunnel_id; + bit<5> ingress_tunnel_type; + bit<1> tcp_inner_en; + bit<16> lkp_inner_l4_sport; + bit<16> lkp_inner_l4_dport; + + bit<32> dst_inner_ipv4; + bit<32> src_inner_ipv4; + + bit<32> meter_tag; + +} + +struct metadata { + @name(".routing_metadata") + routing_metadata_t routing_metadata; + @name(".meta_ipv4") + meta_ipv4_t meta_ipv4 ; + +} + + + + +/*parser*/ +parser ParserImpl(packet_in packet, out headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + @name(".start") state start { + transition parse_ethernet; + } + @name ("parse_ethernet") state parse_ethernet { + packet.extract(hdr.ethernet); + transition select(hdr.ethernet.etherType) { + ETHERTYPE_IPV4 : parse_ipv4; + ETHERTYPE_ARP : parse_arp; + default : accept; + } + } + @name ("parse_arp") state parse_arp { + packet.extract(hdr.arp); + transition accept; + } + + @name("parse_ipv4") state parse_ipv4 { + packet.extract(hdr.ipv4); + transition select(hdr.ipv4.protocol) { + IPPROTO_ICMP : parse_icmp; + 8w0x6 : parse_tcp; + 8w47 : parse_gre; + default : accept; + } + } + @name("parse_icmp") state parse_icmp { + packet.extract(hdr.icmp); + transition accept; + } + @name("parse_tcp") state parse_tcp { + packet.extract(hdr.tcp); + transition accept; + } + @name("parse_gre") state parse_gre { + packet.extract(hdr.gre); + transition select(hdr.gre.C, hdr.gre.R, hdr.gre.K, hdr.gre.S, hdr.gre.s, hdr.gre.recurse, hdr.gre.flags, hdr.gre.ver, hdr.gre.proto) { + (1w0x0, 1w0x0, 1w0x0, 1w0x0, 1w0x0, 3w0x0, 5w0x0, 3w0x0, 16w0x800): parse_gre_ipv4; + default: accept; + } + } + @name(".parse_gre_ipv4") state parse_gre_ipv4 { + transition parse_inner_ipv4; + } + + @name(".parse_inner_ipv4") state parse_inner_ipv4 { + packet.extract(hdr.inner_ipv4); + transition select(hdr.inner_ipv4.fragOffset, hdr.inner_ipv4.ihl, hdr.inner_ipv4.protocol) { + (13w0x0, 4w0x5, 8w0x1): parse_inner_icmp; + (13w0x0, 4w0x5, 8w0x6): parse_inner_tcp; + + default: accept; + } + } + @name(".parse_inner_icmp") state parse_inner_icmp { + packet.extract(hdr.inner_icmp); + transition accept; + } + + @name(".parse_inner_tcp") state parse_inner_tcp { + packet.extract(hdr.inner_tcp); + transition accept; + } + + @name(".parse_inner_ethernet") state parse_inner_ethernet { + packet.extract(hdr.inner_ethernet); + transition select(hdr.inner_ethernet.etherType) { + 16w0x800: parse_inner_ipv4; + default: accept; + } + } +} +@name("mac_learn_digest") struct mac_learn_digest { + bit<8> in_port; /* 9 bits?, it doesnt compile with other value like 16, why? */ + bit<48> mac_sa; +} + + + +/*ingress processing */ +control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + + +/* Drop */ + @name(".drop")action drop() { + + + } + +/* set IF info and others */ + @name(".set_if_info") action set_if_info(bit<1> is_ext) { + + + meta.routing_metadata.mac_da = hdr.ethernet.dstAddr; + meta.routing_metadata.mac_sa = hdr.ethernet.srcAddr; + meta.routing_metadata.if_ipv4_addr = 0x7fef4800 ; + meta.routing_metadata.if_mac_addr = 0x010101010100; + meta.routing_metadata.is_ext_if = is_ext; + + } + @name(".if_info") table if_info { + key = { meta.routing_metadata.if_index: exact;} + + actions = { drop; set_if_info; } + default_action = drop(); + + } + +/* process mac learn */ + + @name(".generate_learn_notify") action generate_learn_notify() { + digest(32w1024, {meta.routing_metadata.if_index, hdr.ethernet.srcAddr }); + } + @name(".smac") table smac { + actions = { + generate_learn_notify; + } + key = { + hdr.ethernet.srcAddr: exact; + } + size = 512; + } + + +/* tunnel control decap */ + @name(".decap_gre_inner_ipv4") action decap_gre_inner_ipv4(bit <32> tunnel_id) { + + hdr.ipv4.setInvalid(); + hdr.gre.setInvalid(); + meta.routing_metadata.tunnel_id = tunnel_id; + meta.routing_metadata.dst_ipv4 = hdr.inner_ipv4.dstAddr; + standard_metadata.egress_port = 1; + meta.routing_metadata.is_ext_if = 0; + + } + + @name("decap_process_outer") table decap_process_outer { + actions = {decap_gre_inner_ipv4; drop; } + key ={ hdr.ethernet.srcAddr: exact;} + + size = 1024; + default_action = drop(); + } + + +/* Nat control */ + @name(".nat_hit_int_to_ext") action nat_hit_int_to_ext(bit<32> srcAddr, bit<16> srcPort) { + meta.routing_metadata.rewrite_outer = 1w1; + hdr.inner_ipv4.srcAddr= srcAddr; + hdr.inner_tcp.srcPort = srcPort; + } + + @name(".nat_up") table nat_up { + actions = { drop; nat_hit_int_to_ext; } + key = { hdr.inner_ipv4.srcAddr: exact;} + size = 1024; + default_action = drop(); + } + + @name(".nat_hit_ext_to_int") action nat_hit_ext_to_int(bit<32> dstAddr, bit<16> dstPort) { + meta.routing_metadata.rewrite_outer = 1w0; + meta.routing_metadata.dst_ipv4 = dstAddr; /* to lpm */ + hdr.ipv4.dstAddr = dstAddr; + hdr.tcp.dstPort = dstPort; + } + @name(".nat_dw") table nat_dw { + actions = { drop; nat_hit_ext_to_int; } + key = {meta.routing_metadata.is_ext_if: exact; } + size = 1024; + default_action = drop(); + } + + +/* tunnel control encap */ + + + @name(".ipv4_gre_rewrite") action ipv4_gre_rewrite(bit<32> gre_srcAddr) { + hdr.ethernet.setInvalid(); + hdr.gre.setValid(); + hdr.gre.proto = 16w0x800; + + meta.meta_ipv4.version = hdr.ipv4.version ; + meta.meta_ipv4.ihl = hdr.ipv4.ihl ; + meta.meta_ipv4.diffserv = hdr.ipv4.diffserv ; + meta.meta_ipv4.totalLen = hdr.ipv4.totalLen ; + meta.meta_ipv4.identification = hdr.ipv4.identification ; + meta.meta_ipv4.flags = hdr.ipv4.flags ; + meta.meta_ipv4.fragOffset = hdr.ipv4.fragOffset ; + meta.meta_ipv4.ttl = hdr.ipv4.ttl ; + meta.meta_ipv4.protocol = hdr.ipv4.protocol ; + meta.meta_ipv4.hdrChecksum = hdr.ipv4.hdrChecksum ; + meta.meta_ipv4.srcAddr = hdr.ipv4.srcAddr ; + meta.meta_ipv4.dstAddr = hdr.ipv4.dstAddr ; + + hdr.outer_ipv4.setValid(); + hdr.outer_ipv4.srcAddr = 0x04000001; + hdr.outer_ipv4.dstAddr = gre_srcAddr; + hdr.outer_ipv4.protocol = 47; + hdr.outer_ipv4.version = meta.meta_ipv4.version ; + hdr.outer_ipv4.ihl = meta.meta_ipv4.ihl ; + hdr.outer_ipv4.diffserv = meta.meta_ipv4.diffserv ; + hdr.outer_ipv4.totalLen = meta.meta_ipv4.totalLen ; + hdr.outer_ipv4.identification = meta.meta_ipv4.identification ; + hdr.outer_ipv4.flags = meta.meta_ipv4.flags ; + hdr.outer_ipv4.fragOffset = meta.meta_ipv4.fragOffset ; + hdr.outer_ipv4.ttl = meta.meta_ipv4.ttl ; + + hdr.outer_ethernet.setValid(); + hdr.outer_ethernet.dstAddr = 0x000000000001; + hdr.outer_ethernet.srcAddr = 0x000000000002; + hdr.outer_ethernet.etherType = 16w0x800; + standard_metadata.egress_port = 1; + meta.routing_metadata.dst_ipv4= hdr.outer_ipv4.dstAddr; + meta.routing_metadata.rewrite_outer = 0; + + } + + @name(".tunnel_encap_process_outer") table tunnel_encap_process_outer { + actions = {ipv4_gre_rewrite; drop; } + key = { hdr.ipv4.dstAddr : exact; } + size = 128; + } + + + + + @name(".set_nhop") action set_nhop(bit<9> port) { + standard_metadata.egress_port = port; + } + + @name(".ipv4_up") table ipv4_up { + key = {meta.routing_metadata.dst_ipv4 : lpm;} + actions = { set_nhop; drop; } + } + @name(".rewrite_src_mac") action rewrite_src_mac(bit<48> src_mac) { + + hdr.ethernet.setInvalid(); + hdr.ethernet_decap.setValid(); + hdr.ethernet_decap.dstAddr = meta.routing_metadata.mac_da; + hdr.ethernet_decap.srcAddr = src_mac; + hdr.ethernet_decap.etherType = 16w0x800; + } + + @name(".sendout") table sendout { + actions = {drop; rewrite_src_mac; } + key = { standard_metadata.egress_port: exact; } + size = 512; + } + + @name(".rewrite_src_mac_dw") action rewrite_src_mac_dw(bit<48> src_mac) { + hdr.outer_ethernet.dstAddr = meta.routing_metadata.mac_da; + hdr.outer_ethernet.srcAddr = src_mac; + hdr.outer_ethernet.etherType = 16w0x800; + } + + @name(".sendout_dw") table sendout_dw { + actions = {drop; rewrite_src_mac_dw; } + key = { standard_metadata.egress_port: exact; } + size = 512; + } + + +/* APPLY */ + apply { + if_info.apply(); + smac.apply(); + +/* decap */ + if(hdr.ipv4.protocol== 8w47){ + decap_process_outer.apply(); + nat_up.apply(); + } + + if(meta.routing_metadata.is_ext_if == 1){ + nat_dw.apply(); + tunnel_encap_process_outer.apply(); + } + ipv4_up.apply(); + + if (meta.routing_metadata.rewrite_outer == 1w1) {sendout.apply(); } + if (meta.routing_metadata.rewrite_outer == 1w0) {sendout_dw.apply(); } + + } + +} + +control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) { + apply { + } +} + +control DeparserImpl(packet_out packet, in headers hdr) { + apply { + } +} + +/* checksum veification */ +control verifyChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +control computeChecksum(inout headers hdr, inout metadata meta) { + apply { + } +} + +V1Switch(ParserImpl(), verifyChecksum(), ingress(), egress(), computeChecksum(), DeparserImpl()) main;