P4 学习笔记（二）- 基础语法和 Parser

  bool        // Boolean value
  bit<W>      // Bit-string of width W
  int<W>      // Signed integer of width W
  varbit<W>   // Bit-string of dynamic length <= W
  match_kind  // Describes ways to match table keys
  error       // Used to signal errors
  void        // No values, used in few restricted circumstances

  header Ethernet_h {
    bit<48> dstAddr;          // Destination address
    bit<48> srcAddr;          // Source address
    bit<16> etherType;        // EtherType field
  }

  Ethernet_h ethernetHeader;  // Declaration

  packet.extract(ethernetHeader);

  header Mpls_h {
    bit<20> label;
    bit<3>  tc;
    bit     bos;
    bit<8>  ttl;
  }

  Mpls_h[10] mols;    // 一列 10 个 MPLS headers

  // 只用其中的一种
  header_union IP_h {
    IPv4_h v4;
    IPv6_h v6;
  } 

  P4        |  对比
  header    |  c 语言里的 packed struct, 比如：struct __attribute__((__packed__)) mystruct {...};
  struct    |  python 里的 dictionary

  // reference: https://github.com/p4lang/behavioral-model/blob/master/docs/simple_switch.md
  struct standard_metadata_t {
    bit<9> ingress_port;   // 收到 packet 的 port number，只读
    bit<9> egress_spec;    // 准备发出 packet 的 port number，也可以设置成 drop
    bit<9> egress_port;    // 准备发出 packet 的 port number, 只读
    ...
  }

  tuple<bit<32>, bool> x;
  x = {10, false};

  /* variable */
  bit<8> x = 123;

  typedef bit<8> MyType;
  MyType x;
  x = 123;


  /* constant */
  const bit<8> x = 123;

  typedef bit<8> MyType;
  const MyType x = 123;

  if (x == 123) {...} else {...}

  switch (t.apply().action_run) {
    action1: {...}
    action2: {...}
  }

  // source routing 的 header 结构
  header srcRoute_t {
    bit<1>  bos;
    bit<15> port;
  }

  // 定义所有 header 的结构
  struct headers {
    ethernet_t           ethernet;  
    srcRoute_t[MAX_HOPS] srcRoutes;
    ipv4_t               ipv4;
  }

  parser MyParser(...) {

    state start {
      transition parse_ethernet;  // 0: 直接跳转到 parse_ethernet
    }

    state parse_ethernet {
      packet.extract(hdr.ethernet);
      transition select(hdr.ethernet.etherType) {  // 1: 下一个跳转的分支取决于 EtherType 的值
        TYPE_SRCROUTING: parse_srcRouting;
        0x800: parse_ipv4;
        default: accept;
      }
    }

    state parse_srcRouting {
      packet.extract(hdr.srcRoutes.next);
      transition select(hdr.srcRoutes.last.bos) {
        1: parse_ipv4;              // 如果是最后一个 source routing 的 header，去解析 ipv4
        default: parse_srcRouting;  // 否则继续解析 source routing 的下一个 header
      }
    }

    state parse_ipv4 {
      packet.extract(hdr.ipv4);
      transition select(hdr.ipv4.protocol) {
        6: parse_tcp;
        17: parse_udp;
        default: accept;
      } 

    state parse_tcp {
      packet.extract(hdr.tcp);
      transition: accept;
    }

    state parse_udp {
      packet.extract(hdr.udp);
      transition accept;
    }

  }

  header IPv4_no_options_h {
    ...
    bit<32> srcAddr;           // 固定长度
    bit<32> dstAddr;
  }

  header IPv4_options_h {
    varbit<320> options;       // 可变长度
  }

  ...

  parser MyParser(...) {
    ...
    state parse_ipv4 {
      packet.extract(headers.ipv4);
      transition select (headers.ipv4.ihl) {  
        5: dispatch_on_protocol;     // 如果 ihl==5，那么没有 options，直接按照对应的 protocol 解析
        default: parse_ipv4_options; // 否则解析 options
      }
    }

    state parse_ipv4_options {
      packet.extract(headers.ipv4options, (headers.ipv4.ihl - 5) << 2); // ihl 决定了 options 的长度
      transition dispatch_on_protocol;
    }
  }

  parser Tcp_option_parser(packet_in b,
                           in bit<4> tcp_hdr_data_offset,
                           out Tcp_option_stack vec,
                           out Tcp_option_padding_h padding)
  {
      bit<7> tcp_hdr_bytes_left;

      state start {
          // RFC 793 - the Data Offset field is the length of the TCP
          // header in units of 32-bit words.  It must be at least 5 for
          // the minimum length TCP header, and since it is 4 bits in
          // size, can be at most 15, for a maximum TCP header length of
          // 15*4 = 60 bytes.
          verify(tcp_hdr_data_offset >= 5, error.TcpDataOffsetTooSmall);
          tcp_hdr_bytes_left = 4 * (bit<7>) (tcp_hdr_data_offset - 5);
          // always true here: 0 <= tcp_hdr_bytes_left <= 40
          transition next_option;
      }
      state next_option {
          transition select(tcp_hdr_bytes_left) {
              0 : accept;  // no TCP header bytes left
              default : next_option_part2;
          }
      }
      state next_option_part2 {
          // precondition: tcp_hdr_bytes_left >= 1
          transition select(b.lookahead<bit<8>>()) {
              0: parse_tcp_option_end;
              1: parse_tcp_option_nop;
              2: parse_tcp_option_ss;
              3: parse_tcp_option_s;
              5: parse_tcp_option_sack;
          }
      }
      state parse_tcp_option_end {
          b.extract(vec.next.end);
          // TBD: This code is an example demonstrating why it would be
          // useful to have sizeof(vec.next.end) instead of having to
          // put in a hard-coded length for each TCP option.
          tcp_hdr_bytes_left = tcp_hdr_bytes_left - 1;
          transition consume_remaining_tcp_hdr_and_accept;
      }
      state consume_remaining_tcp_hdr_and_accept {
          // A more picky sub-parser implementation would verify that
          // all of the remaining bytes are 0, as specified in RFC 793,
          // setting an error and rejecting if not.  This one skips past
          // the rest of the TCP header without checking this.

          // tcp_hdr_bytes_left might be as large as 40, so multiplying
          // it by 8 it may be up to 320, which requires 9 bits to avoid
          // losing any information.
          b.extract(padding, (bit<32>) (8 * (bit<9>) tcp_hdr_bytes_left));
          transition accept;
      }
      state parse_tcp_option_nop {
          b.extract(vec.next.nop);
          tcp_hdr_bytes_left = tcp_hdr_bytes_left - 1;
          transition next_option;
      }
      state parse_tcp_option_ss {
          verify(tcp_hdr_bytes_left >= 5, error.TcpOptionTooLongForHeader);
          tcp_hdr_bytes_left = tcp_hdr_bytes_left - 5;
          b.extract(vec.next.ss);
          transition next_option;
      }
      state parse_tcp_option_s {
          verify(tcp_hdr_bytes_left >= 4, error.TcpOptionTooLongForHeader);
          tcp_hdr_bytes_left = tcp_hdr_bytes_left - 4;
          b.extract(vec.next.s);
          transition next_option;
      }
      state parse_tcp_option_sack {
          bit<8> n_sack_bytes = b.lookahead<Tcp_option_sack_top>().length;
          // I do not have global knowledge of all TCP SACK
          // implementations, but from reading the RFC, it appears that
          // the only SACK option lengths that are legal are 2+8*n for
          // n=1, 2, 3, or 4, so set an error if anything else is seen.
          verify(n_sack_bytes == 10 || n_sack_bytes == 18 ||
                 n_sack_bytes == 26 || n_sack_bytes == 34,
                 error.TcpBadSackOptionLength);
          verify(tcp_hdr_bytes_left >= (bit<7>) n_sack_bytes,
                 error.TcpOptionTooLongForHeader);
          tcp_hdr_bytes_left = tcp_hdr_bytes_left - (bit<7>) n_sack_bytes;
          b.extract(vec.next.sack, (bit<32>) (8 * n_sack_bytes - 16));
          transition next_option;
      }
  }