fyb/p4tutorials-turkce
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Created new subdirectory for Fall developer day. (#60)

Browse Source
This commit is contained in:
Robert Soule
2017-10-19 12:06:37 -07:00
committed by GitHub
parent 28a8414c58
commit cf4885329d
130 changed files with 8004 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
P4D2_2017_Spring/exercises/mri/README.md Normal file
View File

@@ -0,0 +1,206 @@
# Implementing MRI
## Introduction
The objective of this tutorial is to extend basic L3 forwarding with a
scaled-down version of In-Band Network Telemetry (INT), which we call
Multi-Hop Route Inspection (MRI).
MRI allows users to track the path that every packet travels through
the network. To support this functionality, you will need to write a
P4 program that appends an ID to the header stack of every packet. At
the destination, the sequence of switch IDs correspond to the path.
As before, we have already defined the control plane rules, so you
only need to implement the data plane logic of your P4 program.
> **Spoiler alert:** There is a reference solution in the `solution`
> sub-directory. Feel free to compare your implementation to the reference.
## Step 1: Run the (incomplete) starter code
The directory with this README also contains a skeleton P4 program,
`mri.p4`, which initially implements L3 forwarding. Your job (in the
next step) will be to extend it to properly append the MRI custom
headers.
Before that, let's compile the incomplete `mri.p4` and bring up a
switch in Mininet to test its behavior.
1. In your shell, run:
```bash
./run.sh
```
This will:
* compile `mri.p4`, and
* start a Mininet instance with three switches (`s1`, `s2`, `s3`) configured
in a triangle, each connected to one host (`h1`, `h2`, `h3`).
* The hosts are assigned IPs of `10.0.1.10`, `10.0.2.10`, etc.
2. You should now see a Mininet command prompt. Open two terminals for `h1` and `h2`, respectively:
```bash
mininet> xterm h1 h2
```
3. Each host includes a small Python-based messaging client and server. In `h2`'s xterm, start the server:
```bash
./receive.py
```
4. In `h1`'s xterm, send a message from the client:
```bash
./send.py 10.0.2.10 "P4 is cool"
```
The message "P4 is cool" should be received in `h2`'s xterm,
5. Type `exit` to leave each xterm and the Mininet command line.
You should see the message received at host `h2`, but without any information
about the path the message took. Your job is to extend the code in `mri.p4` to
implement the MRI logic to record the path.
### A note about the control plane
P4 programs define a packet-processing pipeline, but the rules governing packet
processing are inserted into the pipeline by the control plane. When a rule
matches a packet, its action is invoked with parameters supplied by the control
plane as part of the rule.
In this exercise, the control plane logic has already been implemented. As
part of bringing up the Mininet instance, the `run.sh` script will install
packet-processing rules in the tables of each switch. These are defined in the
`sX-commands.txt` files, where `X` corresponds to the switch number.
## Step 2: Implement MRI
The `mri.p4` file contains a skeleton P4 program with key pieces of
logic replaced by `TODO` comments. These should guide your
implementation---replace each `TODO` with logic implementing the missing piece.
MRI will require two custom headers. The first header, `mri_t`,
contains a single field `count`, which indicates the number of switch
IDs that follow. The second header, `switch_t`, contains a single
field with the switch ID.
One of the biggest challenges in implementing MRI is handling the
recursive logic for parsing these two headers. We will use a
`parser_metadata` field, `remaining`, to keep track of how many
`switch_t` headers we need to parse. In the `parse_mri` state, this
field should be set to `hdr.mri.count`. In the `parse_swid` state,
this field should be decremented. The `parse_swid` state will
transition to itself until `remaining` is 0.
The MRI custom headers will be carried inside an IP Options
header. The IP Options header contains a field, `option`, which
indicates the type of the option. We will use a special type 31 to
indicate the presence of the MRI headers.
Beyond the parser logic, you will add a table, `swid` to store the
switch ID, and actions that add the `mri_t` header if it doesn't
exist, increment the `count` field, and append a `switch_t` header.
A complete `mri.p4` will contain the following components:
1. Header type definitions for Ethernet (`ethernet_t`), IPv4 (`ipv4_t`),
IP Options (`ipv4_option_t`), MRI (`mri_t`), and Switch (`switch_t`).
2. Parsers for Ethernet, IPv4, IP Options, MRI, and Switch that will
populate `ethernet_t`, `ipv4_t`, `ipv4_option_t`, `mri_t`, and
`switch_t`.
3. An action to drop a packet, using `mark_to_drop()`.
4. An action (called `ipv4_forward`), which will:
1. Set the egress port for the next hop.
2. Update the ethernet destination address with the address of the next hop.
3. Update the ethernet source address with the address of the switch.
4. Decrement the TTL.
5. An action (called `add_mri_option`) that will add the IP Options and MRI
header. Note that you can use the `setValid()` function, which adds a
header if it does not exist, but otherwise leaves the packet
unmodified.
6. An action (called `add_swid`) that will add the switch ID header.
7. A table (`swid`) to store the switch ID, and calls `add_swid`.
8. A control that:
1. Defines a table that will read an IPv4 destination address, and
invoke either `drop` or `ipv4_forward`.
1. An `apply` block that applies the table.
9. A deparser that selects the order in which fields inserted into the outgoing
packet.
10. A `package` instantiation supplied with the parser, control, and deparser.
> In general, a package also requires instances of checksum verification
> and recomputation controls. These are not necessary for this tutorial
> and are replaced with instantiations of empty controls.
## Step 3: Run your solution
Follow the instructions from Step 1. This time, when your message from `h1` is
delivered to `h2`, you should see the seqeunce of switches
through which the packet traveled. The expected output will look like the
following, which shows the MRI header, with a `count` of 2, and switch ids (`swids`) 2 and 1.
```
got a packet
###[ Ethernet ]###
dst = 00:aa:00:02:00:02
src = f2:ed:e6:df:4e:fa
type = 0x800
###[ IP ]###
version = 4L
ihl = 8L
tos = 0x0
len = 33
id = 1
flags =
frag = 0L
ttl = 62
proto = udp
chksum = 0x63b8
src = 10.0.1.10
dst = 10.0.2.10
\options \
|###[ MRI ]###
| copy_flag = 1L
| optclass = debug
| option = 31L
| length = 12
| count = 2
| swids = [2, 1]
```
### Troubleshooting
There are several ways that problems might manifest:
1. `mri.p4` fails to compile. In this case, `run.sh` will report the
error emitted from the compiler and stop.
1. `mri.p4` compiles but does not support the control plane rules in
the `sX-commands.txt` files that `run.sh` tries to install using the BMv2 CLI.
In this case, `run.sh` will report these errors to `stderr`. Use these error
messages to fix your `ipv4_forward.p4` implementation.
1. `mri.p4` compiles, and the control plane rules are installed, but
the switch does not process packets in the desired way. The
`build/logs/<switch-name>.log` files contain trace messages describing how each
switch processes each packet. The output is detailed and can help pinpoint
logic errors in your implementation.
#### Cleaning up Mininet
In the latter two cases above, `run.sh` may leave a Mininet instance running in
the background. Use the following command to clean up these instances:
```bash
mn -c
```
## Next Steps
Congratulations, your implementation works! Move on to the next exercise:
implementing an [ARP and ICMP Responder](../arp).

286
P4D2_2017_Spring/exercises/mri/mri.p4 Normal file
View File

@@ -0,0 +1,286 @@
/* -*- P4_16 -*- */
#include <core.p4>
#include <v1model.p4>
const bit<8> UDP_PROTOCOL = 0x11;
const bit<16> TYPE_IPV4 = 0x800;
const bit<5> IPV4_OPTION_MRI = 31;
#define MAX_HOPS 9
/*************************************************************************
*********************** H E A D E R S ***********************************
*************************************************************************/
typedef bit<9> egressSpec_t;
typedef bit<48> macAddr_t;
typedef bit<32> ip4Addr_t;
typedef bit<32> switchID_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;
}
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] swids;
}
error { IPHeaderTooShort }
/*************************************************************************
*********************** P A R S E R ***********************************
*************************************************************************/
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) {
TYPE_IPV4: parse_ipv4;
default: accept;
}
}
state parse_ipv4 {
packet.extract(hdr.ipv4);
verify(hdr.ipv4.ihl >= 5, error.IPHeaderTooShort);
/*
* TODO: Modify the next line to select on the value of hdr.ipv4.ihl.
* If the value of hdr.ipv4.ihl is set to 5, accept.
* Otherwise, transition to parse_ipv4_option.
*/
transition accept;
}
/* TODO: Implement the logic for parse_ipv4_options, parse_mri, and parse_swid */
state parse_ipv4_option {
/*
* TODO: Add logic to:
* - Extract the ipv4_option header.
* - If the value is equal to IPV4_OPTION_MRI, transition to parse_mri.
* - Otherwise, accept.
*/
}
state parse_mri {
/*
* TODO: Add logic to:
* - Extract hdr.mri.
* - Set meta.parser_metadata.remaining to hdr.mri.count
* - Select on the value of meta.parser_metadata.remaining
* - If the value is equal to 0, accept.
* - Otherwise, transition to parse_swid.
*/
}
state parse_swid {
/*
* TODO: Add logic to:
* - Extract hdr.swids.next.
* - Decrement meta.parser_metadata.remaining by 1
* - Select on the value of meta.parser_metadata.remaining
* - If the value is equal to 0, accept.
* - Otherwise, transition to parse_swid.
*/
}
}
/*************************************************************************
************ C H E C K S U M V E R I F I C A T I O N *************
*************************************************************************/
control verifyChecksum(inout headers hdr, inout metadata meta) {
apply { }
}
/*************************************************************************
************** I N G R E S S P R O C E S S I N G *******************
*************************************************************************/
control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
action drop() {
mark_to_drop();
}
action add_mri_option() {
/*
* TODO: add logic to:
* - Call setValid() on hdr.ipv4_option, which will add the header if it is not
* there, or leave the packet unchanged.
* - Set hdr.ipv4_option.copyFlag to 1
* - Set hdr.ipv4_option.optClass to 2
* - Set hdr.ipv4_option.option to IPV4_OPTION_MRI
* - Set the hdr.ipv4_option.optionLength to 4
* - Call setValid() on hdr.mri
* - Set hdr.mri.count to 0
* - Increment hdr.ipv4.ihl by 1
*/
}
action add_swid(switchID_t id) {
/*
* TODO: add logic to:
- Increment hdr.mri.count by 1
- Add a new swid header by calling push_front(1) on hdr.swids.
- Set hdr.swids[0].swid to the id paremeter
- Incremement hdr.ipv4.ihl by 1
- Incrememtn hdr.ipv4_option.optionLength by 4
*/
}
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 swid {
actions =
{
/* TODO: repace NoAction with the correct action */
NoAction;
}
/* TODO: set a default action. */
}
table ipv4_lpm {
key = {
hdr.ipv4.dstAddr: lpm;
}
actions = {
ipv4_forward;
drop;
NoAction;
}
size = 1024;
default_action = NoAction();
}
apply {
ipv4_lpm.apply();
/*
* TODO: add logic to:
* - If hdr.ipv4 is valid:
* - Apply table ipv4_lpm
* - If hdr.mri is not valid, call add_mri_option()
* - Apply table swid
*/
}
}
/*************************************************************************
**************** E G R E S S P R O C E S S I N G *******************
*************************************************************************/
control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
apply { }
}
/*************************************************************************
************* C H E C K S U M C O M P U T A T I O N **************
*************************************************************************/
control computeChecksum(
inout headers hdr,
inout metadata meta)
{
/*
* Ignore checksum for now. The reference solution contains a checksum
* implementation.
*/
apply { }
}
/*************************************************************************
*********************** D E P A R S E R *******************************
*************************************************************************/
control DeparserImpl(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.swids);
}
}
/*************************************************************************
*********************** S W I T C H *******************************
*************************************************************************/
V1Switch(
ParserImpl(),
verifyChecksum(),
ingress(),
egress(),
computeChecksum(),
DeparserImpl()
) main;

33
P4D2_2017_Spring/exercises/mri/p4app.json Normal file
View File

@@ -0,0 +1,33 @@
{
"program": "mri.p4",
"language": "p4-16",
"targets": {
"multiswitch": {
"auto-control-plane": true,
"cli": true,
"pcap_dump": true,
"bmv2_log": true,
"links": [["h1", "s1"], ["s1", "s2"], ["s1", "s3"], ["s3", "s2"], ["s2", "h2"], ["s3", "h3"]],
"hosts": {
"h1": {
},
"h2": {
},
"h3": {
}
},
"switches": {
"s1": {
"entries": "s1-commands.txt"
},
"s2": {
"entries": "s2-commands.txt"
},
"s3": {
"entries": "s3-commands.txt"
}
}
}
}
}

50
P4D2_2017_Spring/exercises/mri/receive.py Executable file
View File

@@ -0,0 +1,50 @@
#!/usr/bin/env python
import sys
import struct
from scapy.all import sniff, sendp, hexdump, get_if_list, get_if_hwaddr
from scapy.all import Packet, IPOption
from scapy.all import ShortField, IntField, LongField, BitField, FieldListField, FieldLenField
from scapy.all import IP, UDP, Raw
from scapy.layers.inet import _IPOption_HDR
def get_if():
ifs=get_if_list()
iface=None
for i in get_if_list():
if "eth0" in i:
iface=i
break;
if not iface:
print "Cannot find eth0 interface"
exit(1)
return iface
class IPOption_MRI(IPOption):
name = "MRI"
option = 31
fields_desc = [ _IPOption_HDR,
FieldLenField("length", None, fmt="B",
length_of="swids",
adjust=lambda pkt,l:l+4),
ShortField("count", 0),
FieldListField("swids",
[],
IntField("", 0),
length_from=lambda pkt:pkt.count*4) ]
def handle_pkt(pkt):
print "got a packet"
pkt.show2()
# hexdump(pkt)
sys.stdout.flush()
def main():
iface = 'h2-eth0'
print "sniffing on %s" % iface
sys.stdout.flush()
sniff(filter="udp and port 4321", iface = iface,
prn = lambda x: handle_pkt(x))
if __name__ == '__main__':
main()

5
P4D2_2017_Spring/exercises/mri/run.sh Executable file
View File

@@ -0,0 +1,5 @@
P4APPRUNNER=../../utils/p4apprunner.py
mkdir -p build
tar -czf build/p4app.tgz * --exclude='build'
#cd build
sudo python $P4APPRUNNER p4app.tgz --build-dir ./build

5
P4D2_2017_Spring/exercises/mri/s1-commands.txt Normal file
View File

@@ -0,0 +1,5 @@
table_set_default ipv4_lpm drop
table_set_default swid add_swid 1
table_add ipv4_lpm ipv4_forward 10.0.1.10/32 => 00:aa:00:01:00:01 1
table_add ipv4_lpm ipv4_forward 10.0.2.10/32 => f2:ed:e6:df:4e:fa 2
table_add ipv4_lpm ipv4_forward 10.0.3.10/32 => f2:ed:e6:df:4e:fb 3

5
P4D2_2017_Spring/exercises/mri/s2-commands.txt Normal file
View File

@@ -0,0 +1,5 @@
table_set_default ipv4_lpm drop
table_set_default swid add_swid 2
table_add ipv4_lpm ipv4_forward 10.0.2.10/32 => 00:aa:00:02:00:02 1
table_add ipv4_lpm ipv4_forward 10.0.1.10/32 => 22:a8:04:41:ab:d3 2
table_add ipv4_lpm ipv4_forward 10.0.3.10/32 => 22:a8:04:41:ab:d4 3

5
P4D2_2017_Spring/exercises/mri/s3-commands.txt Normal file
View File

@@ -0,0 +1,5 @@
table_set_default ipv4_lpm drop
table_set_default swid add_swid 3
table_add ipv4_lpm ipv4_forward 10.0.3.10/32 => 00:aa:00:03:00:01 1
table_add ipv4_lpm ipv4_forward 10.0.1.10/32 => f2:ed:e6:df:4e:fb 2
table_add ipv4_lpm ipv4_forward 10.0.2.10/32 => f2:ed:e6:df:4e:fa 3

58
P4D2_2017_Spring/exercises/mri/send.py Executable file
View File

@@ -0,0 +1,58 @@
#!/usr/bin/env python
import argparse
import sys
import socket
import random
import struct
from scapy.all import sendp, send, hexdump, get_if_list, get_if_hwaddr
from scapy.all import Packet, IPOption
from scapy.all import Ether, IP, UDP
from scapy.all import IntField, FieldListField, FieldLenField, ShortField
from scapy.layers.inet import _IPOption_HDR
def get_if():
ifs=get_if_list()
iface=None # "h1-eth0"
for i in get_if_list():
if "eth0" in i:
iface=i
break;
if not iface:
print "Cannot find eth0 interface"
exit(1)
return iface
class IPOption_MRI(IPOption):
name = "MRI"
option = 31
fields_desc = [ _IPOption_HDR,
FieldLenField("length", None, fmt="B",
length_of="swids",
adjust=lambda pkt,l:l+4),
ShortField("count", 0),
FieldListField("swids",
[],
IntField("", 0),
length_from=lambda pkt:pkt.count*4) ]
def main():
if len(sys.argv)<3:
print 'pass 2 arguments: <destination> "<message>"'
exit(1)
addr = socket.gethostbyname(sys.argv[1])
iface = get_if()
pkt = Ether(src=get_if_hwaddr(iface), dst="ff:ff:ff:ff:ff:ff") / IP(dst=addr) / UDP(dport=4321, sport=1234) / sys.argv[2]
#pkt = Ether(src=get_if_hwaddr(iface), dst="ff:ff:ff:ff:ff:ff") / IP(dst=addr, options = IPOption_MRI(count=2, swids=[3,4])) / UDP(dport=4321, sport=1234) / sys.argv[2]
pkt.show2()
#hexdump(pkt)
sendp(pkt, iface=iface)
if __name__ == '__main__':
main()

274
P4D2_2017_Spring/exercises/mri/solution/mri.p4 Normal file
View File

@@ -0,0 +1,274 @@
/* -*- P4_16 -*- */
#include <core.p4>
#include <v1model.p4>
const bit<8> UDP_PROTOCOL = 0x11;
const bit<16> TYPE_IPV4 = 0x800;
const bit<5> IPV4_OPTION_MRI = 31;
#define MAX_HOPS 9
/*************************************************************************
*********************** H E A D E R S ***********************************
*************************************************************************/
typedef bit<9> egressSpec_t;
typedef bit<48> macAddr_t;
typedef bit<32> ip4Addr_t;
typedef bit<32> switchID_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;
}
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] swids;
}
error { IPHeaderTooShort }
/*************************************************************************
*********************** P A R S E R ***********************************
*************************************************************************/
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) {
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_swid;
}
}
state parse_swid {
packet.extract(hdr.swids.next);
meta.parser_metadata.remaining = meta.parser_metadata.remaining - 1;
transition select(meta.parser_metadata.remaining) {
0 : accept;
default: parse_swid;
}
}
}
/*************************************************************************
************ C H E C K S U M V E R I F I C A T I O N *************
*************************************************************************/
control verifyChecksum(inout headers hdr, inout metadata meta) {
apply { }
}
/*************************************************************************
************** I N G R E S S P R O C E S S I N G *******************
*************************************************************************/
control ingress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
action drop() {
mark_to_drop();
}
action add_mri_option() {
hdr.ipv4_option.setValid();
hdr.ipv4_option.copyFlag = 1;
hdr.ipv4_option.optClass = 2; /* Debugging and Measurement */
hdr.ipv4_option.option = IPV4_OPTION_MRI;
hdr.ipv4_option.optionLength = 4; /* sizeof(ipv4_option) + sizeof(mri) */
hdr.mri.setValid();
hdr.mri.count = 0;
hdr.ipv4.ihl = hdr.ipv4.ihl + 1;
}
action add_swid(switchID_t id) {
hdr.mri.count = hdr.mri.count + 1;
hdr.swids.push_front(1);
hdr.swids[0].swid = id;
hdr.ipv4.ihl = hdr.ipv4.ihl + 1;
hdr.ipv4_option.optionLength = hdr.ipv4_option.optionLength + 4;
}
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 swid {
actions = { add_swid; NoAction; }
default_action = NoAction();
}
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();
if (!hdr.mri.isValid()) {
add_mri_option();
}
swid.apply();
}
}
}
/*************************************************************************
**************** E G R E S S P R O C E S S I N G *******************
*************************************************************************/
control egress(inout headers hdr, inout metadata meta, inout standard_metadata_t standard_metadata) {
apply { }
}
/*************************************************************************
************* C H E C K S U M C O M P U T A T I O N **************
*************************************************************************/
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);
}
}
/*************************************************************************
*********************** D E P A R S E R *******************************
*************************************************************************/
control DeparserImpl(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.swids);
}
}
/*************************************************************************
*********************** S W I T C H *******************************
*************************************************************************/
V1Switch(
ParserImpl(),
verifyChecksum(),
ingress(),
egress(),
computeChecksum(),
DeparserImpl()
) main;