entry.p4i

# 1 "entry.p4"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "entry.p4"

# 1 "/usr/local/share/p4c/p4include/core.p4" 1
# 23 "/usr/local/share/p4c/p4include/core.p4"
error {
    NoError,
    PacketTooShort,
    NoMatch,
    StackOutOfBounds,
    HeaderTooShort,
    ParserTimeout
}

extern packet_in {



    void extract<T>(out T hdr);




    void extract<T>(out T variableSizeHeader,
                    in bit<32> variableFieldSizeInBits);



    T lookahead<T>();

    void advance(in bit<32> sizeInBits);


    bit<32> length();
}

extern packet_out {



    void emit<T>(in T hdr);
}




extern void verify(in bool check, in error toSignal);


action NoAction() {}




match_kind {

    exact,

    ternary,

    lpm
}
# 3 "entry.p4" 2
# 1 "/usr/local/share/p4c/p4include/v1model.p4" 1
# 22 "/usr/local/share/p4c/p4include/v1model.p4"
# 1 "/usr/local/share/p4c/p4include/core.p4" 1
# 23 "/usr/local/share/p4c/p4include/v1model.p4" 2

match_kind {
    range,

    selector
}


@metadata @name("standard_metadata")
struct standard_metadata_t {
    bit<9> ingress_port;
    bit<9> egress_spec;
    bit<9> egress_port;
    bit<32> clone_spec;
    bit<32> instance_type;
    bit<1> drop;
    bit<16> recirculate_port;
    bit<32> packet_length;
# 50 "/usr/local/share/p4c/p4include/v1model.p4"
    @alias("queueing_metadata.enq_timestamp") bit<32> enq_timestamp;
    @alias("queueing_metadata.enq_qdepth") bit<19> enq_qdepth;
    @alias("queueing_metadata.deq_timedelta") bit<32> deq_timedelta;
    @alias("queueing_metadata.deq_qdepth") bit<19> deq_qdepth;

    @alias("intrinsic_metadata.ingress_global_timestamp") bit<48> ingress_global_timestamp;
    @alias("intrinsic_metadata.egress_global_timestamp") bit<48> egress_global_timestamp;
    @alias("intrinsic_metadata.lf_field_list") bit<32> lf_field_list;
    @alias("intrinsic_metadata.mcast_grp") bit<16> mcast_grp;
    @alias("intrinsic_metadata.resubmit_flag") bit<32> resubmit_flag;
    @alias("intrinsic_metadata.egress_rid") bit<16> egress_rid;

    bit<1> checksum_error;
    @alias("intrinsic_metadata.recirculate_flag") bit<32> recirculate_flag;
}

enum CounterType {
    packets,
    bytes,
    packets_and_bytes
}

enum MeterType {
    packets,
    bytes
}

extern counter {
    counter(bit<32> size, CounterType type);
    void count(in bit<32> index);
}

extern direct_counter {
    direct_counter(CounterType type);
    void count();
}

extern meter {
    meter(bit<32> size, MeterType type);
    void execute_meter<T>(in bit<32> index, out T result);
}

extern direct_meter<T> {
    direct_meter(MeterType type);
    void read(out T result);
}

extern register<T> {
    register(bit<32> size);
    void read(out T result, in bit<32> index);
    void write(in bit<32> index, in T value);
}


extern action_profile {
    action_profile(bit<32> size);
}


extern void random<T>(out T result, in T lo, in T hi);


extern void digest<T>(in bit<32> receiver, in T data);

enum HashAlgorithm {
    crc32,
    crc32_custom,
    crc16,
    crc16_custom,
    random,
    identity,
    csum16,
    xor16
}

extern void mark_to_drop();
extern void hash<O, T, D, M>(out O result, in HashAlgorithm algo, in T base, in D data, in M max);

extern action_selector {
    action_selector(HashAlgorithm algorithm, bit<32> size, bit<32> outputWidth);
}

enum CloneType {
    I2E,
    E2E
}

@deprecated("Please use verify_checksum/update_checksum instead.")
extern Checksum16 {
    Checksum16();
    bit<16> get<D>(in D data);
}
# 156 "/usr/local/share/p4c/p4include/v1model.p4"
extern void verify_checksum<T, O>(in bool condition, in T data, inout O checksum, HashAlgorithm algo);
# 168 "/usr/local/share/p4c/p4include/v1model.p4"
extern void update_checksum<T, O>(in bool condition, in T data, inout O checksum, HashAlgorithm algo);
# 184 "/usr/local/share/p4c/p4include/v1model.p4"
extern void verify_checksum_with_payload<T, O>(in bool condition, in T data, inout O checksum, HashAlgorithm algo);
# 197 "/usr/local/share/p4c/p4include/v1model.p4"
extern void update_checksum_with_payload<T, O>(in bool condition, in T data, inout O checksum, HashAlgorithm algo);

extern void resubmit<T>(in T data);
extern void recirculate<T>(in T data);
extern void clone(in CloneType type, in bit<32> session);
extern void clone3<T>(in CloneType type, in bit<32> session, in T data);

extern void truncate(in bit<32> length);







parser Parser<H, M>(packet_in b,
                    out H parsedHdr,
                    inout M meta,
                    inout standard_metadata_t standard_metadata);





control VerifyChecksum<H, M>(inout H hdr,
                             inout M meta);
@pipeline
control Ingress<H, M>(inout H hdr,
                      inout M meta,
                      inout standard_metadata_t standard_metadata);
@pipeline
control Egress<H, M>(inout H hdr,
                     inout M meta,
                     inout standard_metadata_t standard_metadata);





control ComputeChecksum<H, M>(inout H hdr,
                              inout M meta);
@deparser
control Deparser<H>(packet_out b, in H hdr);

package V1Switch<H, M>(Parser<H, M> p,
                       VerifyChecksum<H, M> vr,
                       Ingress<H, M> ig,
                       Egress<H, M> eg,
                       ComputeChecksum<H, M> ck,
                       Deparser<H> dep
                       );
# 4 "entry.p4" 2


const bit<9> HOST = 1;


const bit<16> TYPE_IPV6 = 0x86dd;
const bit<8> TYPE_IPV6_2 = 41;
const bit<16> TYPE_GTP = 2152;
const bit<16> IS_UDP = 17;


const bit<8> TYPE_UDP = 17;
const bit<8> TYPE_TCP = 6;
const bit<8> TYPE_SRV6 = 43;
const bit<32> teste = 32;




const bit<1> not_srv6 = 1;
# 35 "entry.p4"
typedef bit<9> egressSpec_t;
typedef bit<48> macAddr_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> traffic_class;
    bit<20> flow_label;
    bit<16> payload_len;
    bit<8> next_hdr;
    bit<8> hop_limit;
    bit<128> src_addr;
    bit<128> dst_addr;
}

header gtp_t {
    bit<3> version_field_id;
    bit<1> proto_type_id;
    bit<1> spare;
    bit<1> extension_header_flag_id;
    bit<1> sequence_number_flag_id;
    bit<1> npdu_number_flag_id;
    bit<8> msgtype;
    bit<16> msglen;
    bit<32> teid;
}

header udp_t {
    bit<16> sport;
    bit<16> dport;
    bit<16> len;
    bit<16> checksum;
}

header srv6_t {
    bit<8> next_hdr;
    bit<8> hdr_ext_len;
    bit<8> routing_type;
    bit<8> segment_left;
    bit<8> last_entry;
    bit<8> flags;
    bit<16> tag;
}

header srv6_list_t {
    ip6Addr_t segment_id;
}


struct metadata {
    ip6Addr_t next_srv6_sid;
}

struct headers {
    ethernet_t ethernet;
    ipv6_t ipv6_outer;
    srv6_t srv6;
    srv6_list_t[4] srv6_list;
    udp_t udp;
    gtp_t gtp;
    ipv6_t ipv6_inner;

}





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_outer;

        }
    }

    state parse_ipv6_outer {
        packet.extract(hdr.ipv6_outer);
        transition select(hdr.ipv6_outer.next_hdr){
            TYPE_UDP: parse_udp;
            TYPE_SRV6: parse_srv6;
        }
    }

    state parse_srv6{
        packet.extract(hdr.srv6);
        transition accept;
    }

    state parse_udp {
        packet.extract(hdr.udp);
        transition select(hdr.udp.dport){
            TYPE_GTP: parse_gtp;
        }
    }

    state parse_gtp {
        packet.extract(hdr.gtp);
        transition select(hdr.gtp.teid){
            teste: 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();
    }

    action srv6_pop(ip6Addr_t dst) {
        hdr.ipv6_outer.next_hdr = hdr.srv6.next_hdr;
        hdr.ipv6_outer.payload_len = hdr.ipv6_outer.payload_len - 56;
        hdr.ipv6_outer.dst_addr = dst;

        hdr.srv6_list[0].setInvalid();
        hdr.srv6_list[1].setInvalid();
        hdr.srv6_list[2].setInvalid();


        hdr.udp.setValid();
        hdr.ipv6_inner.setValid();
        hdr.gtp.setValid();
        hdr.gtp.spare = 1;
    }

    action ipv6_forward(macAddr_t dstAddr, egressSpec_t port) {
        standard_metadata.egress_spec = port;
        hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
        hdr.ethernet.dstAddr = dstAddr;
    }

   action build_srv6(bit<8> num_segments) {
        hdr.srv6.setValid();
        hdr.srv6.next_hdr = TYPE_UDP;
        hdr.srv6.hdr_ext_len = num_segments * 2;
        hdr.srv6.routing_type = 4;
        hdr.srv6.segment_left = num_segments -1;
        hdr.srv6.last_entry = num_segments - 1;
        hdr.srv6.flags = 0;
        hdr.srv6.tag = 0;
        hdr.ipv6_outer.next_hdr = TYPE_SRV6;

    }

    action srv6_t_insert_2(ip6Addr_t s1, ip6Addr_t s2){
        hdr.ipv6_outer.payload_len = hdr.ipv6_outer.payload_len + 40;
        hdr.srv6_list[0].setValid();
        hdr.srv6_list[0].segment_id = s1;
        hdr.srv6_list[1].setValid();
        hdr.srv6_list[1].segment_id = s2;
        hdr.ipv6_outer.dst_addr = s2;
        build_srv6(2);
    }

        action srv6_t_insert_3(ip6Addr_t s1, ip6Addr_t s2, ip6Addr_t s3){
        hdr.ipv6_outer.payload_len = hdr.ipv6_outer.payload_len + 56;
        hdr.srv6_list[0].setValid();
        hdr.srv6_list[0].segment_id = s1;
        hdr.srv6_list[1].setValid();
        hdr.srv6_list[1].segment_id = s2;
        hdr.srv6_list[2].setValid();
        hdr.srv6_list[2].segment_id = s3;
        hdr.ipv6_outer.dst_addr = s3;
        build_srv6(3);
    }



    table ipv6_outer_lpm {
        key = {
            hdr.ipv6_outer.dst_addr: lpm;
        }
        actions = {
            ipv6_forward;
            drop;
            NoAction;
        }
        size = 1024;
        default_action = drop();
    }


    table teid_exact{
        key = {
            hdr.gtp.teid: exact;
        }
        actions = {
            srv6_t_insert_2;
            srv6_t_insert_3;
        }
        size = 1024;
    }


    table my_sid {
        key = {
            hdr.ipv6_outer.dst_addr: lpm;
        }
        actions = {
            srv6_pop;
        }
        size = 1024;

    }
# 288 "entry.p4"
    apply{







        if (!hdr.srv6.isValid() && hdr.gtp.spare == 0){
            teid_exact.apply();
        } else if (hdr.srv6.isValid() && hdr.srv6.segment_left == 0){
            my_sid.apply();

        }
        ipv6_outer_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 { }
}





control MyDeparser(packet_out packet, in headers hdr) {
    apply {
        packet.emit(hdr.ethernet);
        packet.emit(hdr.ipv6_outer);
        packet.emit(hdr.srv6);
        packet.emit(hdr.srv6_list);
        packet.emit(hdr.udp);
        packet.emit(hdr.gtp);
        packet.emit(hdr.ipv6_inner);


    }
}





V1Switch(
MyParser(),
MyVerifyChecksum(),
MyIngress(),
MyEgress(),
MyComputeChecksum(),
MyDeparser()
) main;