module openflow-protocol {
    namespace "urn:opendaylight:openflow:protocol";
    prefix "ofproto";


    import ietf-inet-types {prefix inet;}
    import ietf-yang-types {prefix yang;}
    
    import openflow-types {prefix oft;}
    import openflow-extensible-match { prefix oxm;}
    import openflow-instruction { prefix ofinstruction;}
    import openflow-action {prefix ofaction;}



    revision "2013-07-31" {
        description "Initial model";
    }

    // Generic Structures

        grouping port {
            // reference "ofp_port";
            leaf port-no { 
                // reference "ofp_port.port_no"; 
                type uint32;
            }
            leaf hw-addr { 
                // reference "ofp_port.hw_addr"; 
                type yang:mac-address;
            }
            leaf name { 
                // reference "ofp_port.name"; 
                type string;
            }
            leaf config { 
                // reference "ofp_port.config"; 
                type oft:port-config;
            }
            leaf state { 
                // reference "ofp_port.state"; 
                type oft:port-state;
            }
            leaf current-features { 
                description "Current features.";
                // reference "ofp_port.curr"; 
                type oft:port-features; 
            }
            leaf advertised-features { 
                description "Features being advertised by the port.";
                // reference "ofp_port.advertised"; 
                type oft:port-features; 
            }
            leaf supported-features { 
                description "Features supported by the port.";
                // reference "ofp_port.supported"; 
                type oft:port-features; 
            }
            leaf peer-features { 
                description "Features advertised by peer.";
                // reference "ofp_port.peer"; 
                type oft:port-features; 
            }
            leaf curr_speed { 
                description "Current port bitrate in kbps.";
                // reference "ofp_port.curr_speed"; 
                type uint32; 
                units "kbps";
            }
            leaf max_speed { 
                description "Max port bitrate in kbps";
                // reference "ofp_port.max_speed"; 
                type uint32;
                units "kbps"; 
            }
        }
        
        grouping match {
            leaf type {
                type identityref {
                    base oft:match-type-base;
                }
            }
            uses oxm:oxm-fields;
        }
        
        container table-features-properties-container {
            uses table-features-properties;
        }
        
        grouping table-features-properties {
            list table-feature-properties {
                leaf type {
                    type oft:table-features-prop-type;
                }
            }
        }

    // TODO: ofp_packet_queue

    // # MESSAGE Structures
        /* Immutable messages. */
            grouping ofHeader {
                //reference "ofpt_header struct in Openflow Switch 1.3 Spec"
                leaf version {
                    type uint8;
                    //reference "OpenFlow Header - OFP_VERSION";
                }
                leaf xid {
                    type uint32;
                    //reference "OpenFlow Header - transaction id";
                }
            }
            grouping ofHelloElementHeader {
                //reference "ofpt_hello_elem_header struct in Openflow Switch 1.3 Spec"
                leaf type {
                    type oft:hello-element-type;
                    //reference "OpenFlow Header element type - OFPHET_*";
                }
            }
            grouping hello {
                // reference "OFPT_HELLO message in Openflow Switch 1.3 Spec"
                /* Symmetric message */
                uses ofHeader;
                
                list elements {
                    uses ofHelloElementHeader;
                    
                    leaf-list version-bitmap {
                        type boolean;
                    }
                    
                    leaf data {
                        type binary;
                    }
                }
            }
            grouping error {
                // reference "OFPT_ERROR message in Openflow Switch 1.3 Spec"
                /* Symmetric message */
                uses ofHeader;
                
                leaf type {
                    type oft:error-type;
                }
                leaf code {
                    type uint16;
                }
                leaf data {
                    type binary; 
                }
            }
            grouping echo-request {
                // reference "OFPT_ECHO_REQUEST message in Openflow Switch 1.3 Spec"
                /* Symmetric message */
                uses ofHeader;
                
                leaf data {
                    type binary;
                }
            }
            grouping echo-reply {
                // reference "OFPT_ECHO_REPLY message in Openflow Switch 1.3 Spec"
                /* Symmetric message */
                uses ofHeader;
                
                leaf data {
                    type binary;
                }
            }
            grouping experimenter {
                // reference "OFPT_EXPERIMENTER message in Openflow Switch 1.3 Spec"
                /* Symmetric message */
                uses ofHeader;
                
                leaf experimenter {
                    type uint32;
                }
                leaf exp_type {
                    type uint32;
                }
                leaf data {
                    type binary;
                }
            }
        /* Switch configuration messages. */
            grouping features-request {
                // reference "OFPT_FEATURES_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
            }
            grouping features-reply {
                // reference "OFPT_FEATURES_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
                
                leaf datapathId {
                    type uint64;
                }
                leaf buffers {
                    type uint32;
                }
                leaf tables {
                    type uint8;
                }
                leaf auxiliaryId {
                    type uint8;
                }
                leaf capabilities {
                    type uint32;
                }
                leaf reserved {
                    type uint32;
                }
            }
            grouping get-config-request {
                // reference "OFPT_GET_CONFIG_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
            }
            grouping get-config-reply {
                // reference "OFPT_GET_CONFIG_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
                
                leaf flags {
                    type oft:switch-config-flag;
                }
                leaf miss-send-len {
                    type uint16;
                }
            }
            grouping set-config {
                // reference "OFPT_SET_CONFIG message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf-list flags {
                    type oft:switch-config-flag;
                }
                leaf miss-send-len {
                    type uint16;
                }
            }
        /* Asynchronous messages. */
            grouping packet-in {
                // reference "OFPT_PACKET_IN message in Openflow Switch 1.3 Spec"
                /* Async message */
                
                uses ofHeader;
                
                leaf buffer-id {
                    // ID assigned by datapath.
                    type uint32;
                }
                leaf total-len {
                    // Full length of frame.
                    type uint16;
                }
                leaf reason {
                    // Reason packet is being sent (one of OFPR_*) 
                    type uint8;
                }
                leaf table-id {
                    // ID of the table that was looked up
                    type oft:table-id;
                }
                leaf cookie {
                    // Cookie of the flow entry that was looked up.
                    type uint64;
                }
                container match {
                    uses match;
                }

// struct ofp_match match; /* Packet metadata. Variable size. */
// /* The variable size and padded match is always followed by:
//  *   - Exactly 2 all-zero padding bytes, then
//  *   - An Ethernet frame whose length is inferred from header.length.
//  * The padding bytes preceding the Ethernet frame ensure that the IP
//  * header (if any) following the Ethernet header is 32-bit aligned.
//  */
                leaf data {
                    type binary;
                }
                
            }
            grouping flow-removed {
                // reference "OFPT_FLOW_REMOVED message in Openflow Switch 1.3 Spec"
                /* Async message */
                uses ofHeader;
                
                leaf cookie {
                    type uint64;
                }
                leaf priority {
                    type uint16;
                }
                leaf reason {
                    type oft:flow-removed-reason;
                }
                leaf table-id {
                    type oft:table-id;
                }
                leaf duration-sec {
                    type uint32;
                }
                leaf duration-nsec {
                    type uint32;
                }
                leaf idle-timeout {
                    type uint16;
                }
                leaf hard-timeout {
                    type uint16;
                }
                leaf packet-count {
                    type uint64;
                }
                leaf byte-count {
                    type uint64;
                }
                container match {
                    uses match;
                }
            } 
            grouping port-status {
                // reference "OFPT_PORT_STATUS message in Openflow Switch 1.3 Spec"
                
                uses ofHeader;
                
                uses port;
                
                leaf reason {
                    type oft:port-reason;
                }
            } /* Async message */
        /* Controller command messages. */
            grouping packet-out {
                // reference "OFPT_PACKET_OUT message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                list actions-list {
                    uses ofaction:action-header;
                    
                    leaf data {
                        type binary;
                    }
                }
                
                leaf buffer-id {
                    type uint32;
                }
                leaf in-port {
                    type oft:port-number;
                }
            } 
            grouping flow-mod {
                // reference "OFPT_FLOW_MOD message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf cookie {
                    type uint64;
                }
                leaf cookie-mask {
                    type uint64;
                }
                leaf table-id {
                    type oft:table-id;
                }
                leaf command {
                    type oft:flow-mod-command;
                }
                leaf idle-timeout {
                    type uint16;
                }
                leaf hard-timeout {
                    type uint16;
                }
                leaf priority {
                    type uint16;
                }
                leaf buffer-id {
                    type uint32;
                }
                leaf out-port {
                    type oft:port-number;
                }
                leaf out-group {
                    type uint32;
                }
                leaf flags {
                    type oft:flow-mod-flags;
                }
                container match {
                    uses match;
                }
            } 
            grouping group-mod {
                // reference "OFPT_GROUP_MOD message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf command {
                    type oft:group-mod-command;
                }
                leaf type {
                    type oft:group-type;
                }
                leaf group-id {
                    type uint32;
                }
                
                list buckets {
                    uses bucket;
                }
            }
            grouping bucket {
                leaf weight {
                    type uint16;
                }
                leaf watch-port {
                    type oft:port-number;
                }
                leaf watch-group {
                    type uint32;
                }
                list actions-list {
                    uses ofaction:action-header;
                }
            }
            grouping port-mod {
                // reference "OFPT_PORT_MOD message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf port-no {
                    type oft:port-number;
                }
                leaf hw-address {
                    type yang:mac-address;
                }       
                leaf config {
                    type oft:port-config;
                }   
                leaf mask {
                    type oft:port-config;
                }  
                leaf advertise {
                    type oft:port-features;
                }
            } 
            grouping table-mod {
                // reference "OFPT_TABLE_MOD message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf table-id {
                    type oft:table-id;
                }
                leaf config {
                    type oft:port-config;
                }                
            } 
            
        /* Multipart messages. */
            grouping multipart-request {
                // reference "OFPT_MULTIPART_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf type {
                    type oft:multipart-type;
                }          
                leaf flags {
                    type oft:multipart-request-flags;
                }      
                choice multipart-request-body {
                    case multipart-request-flow {
                        leaf table-id {
                            type uint8;
                        }
                        leaf out-port {
                            type uint32;
                        }
                        leaf out-group {
                            type uint32;
                        }
                        leaf cookie {
                            type uint64;
                        }
                        leaf cookie-mask {
                            type uint64;
                        }
                        container match {
                            uses match;
                        }
                    }
                    case multipart-request-aggregate {
                        leaf table-id {
                            type uint8;
                        }
                        leaf out-port {
                            type uint32;
                        }
                        leaf out-group {
                            type uint32;
                        }
                        leaf cookie {
                            type uint64;
                        }
                        leaf cookie-mask {
                            type uint64;
                        }
                        container match {
                            uses match;
                        }
                    }
                    case multipart-request-port-stats {
                        leaf port-no {
                            type uint32;
                        }
                    }
                    case multipart-request-queue {
                        leaf port-no {
                            type uint32;
                        }
                        leaf queue-id {
                            type uint32;
                        }
                    }
                    case multipart-request-group {
                        leaf group-id {
                            type uint32;
                        }
                    }
                    case multipart-request-meter {
                        leaf meter-id {
                            type uint32;
                        }
                    }
                    case multipart-request-meter-config {
                        leaf meter-id {
                            type uint32;
                        }
                    }
                    case multipart-request-table-features {
                        list table-features {
                            leaf table-id {
                                type uint8;
                            }
                            leaf name {
                                type string;
                            }
                            leaf metadata-match {
                                type uint64;
                            }
                            leaf metadata-write {
                                type uint64;
                            }
                            leaf config {
                                type oft:table-config;
                            }
                            leaf max-entries {
                                type uint32;
                            }
                            uses table-features-properties;
                        }
                    }
                    case multipart-request-experimenter {
                        leaf experimenter {
                            type uint32;
                        }
                        leaf exp-type {
                            type uint32;
                        }
                    }
                }
            } 
            grouping multipart-reply {
                // reference "OFPT_MULTIPART_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf type {
                    type oft:multipart-type;
                }
                leaf flags {
                    type oft:multipart-request-flags;
                }
                choice multipart-reply-body {
                    case multipart-reply-desc {
                        leaf mfr_desc {
                            type string;
                        }
                        leaf hw_desc {
                            type string;
                        }
                        leaf sw_desc {
                            type string;
                        }
                        leaf serial_num {
                            type string;
                        }
                        leaf dp_desc {
                            type string;
                        }
                    }
                    case multipart-reply-flow {
                        list flow-stats {
                            leaf table-id {
                                type uint8;
                            }
                            leaf duration-sec {
                                type uint32;
                            }
                            leaf duration-nsec {
                                type uint32;
                            }
                            leaf priority {
                                type uint16;
                            }
                            leaf idle-timeout {
                                type uint16;
                            }
                            leaf hard-timeout {
                                type uint16;
                            }
                            leaf flags {
                                type oft:flow-mod-flags;
                            }
                            leaf cookie {
                                type uint64;
                            }
                            leaf packet-count {
                                type uint64;
                            }
                            leaf byte-count {
                                type uint64;
                            }
                            container match {
                                uses match;
                            }
                        }
                    }
                    case multipart-reply-aggregate {
                        leaf packet-count {
                            type uint64;
                        }
                        leaf byte-count {
                            type uint64;
                        }
                        leaf flow-count {
                            type uint32;
                        }
                    }
                    case multipart-reply-table {
                        list table-stats {
                            leaf table-id {
                                type uint8;
                            }
                            leaf active-count {
                                type uint32;
                            }
                            leaf lookup-count {
                                type uint64;
                            }
                            leaf matched-count {
                                type uint64;
                            }
                        }
                    }
                    case multipart-reply-port-stats {
                        list port-stats {
                            leaf port-no {
                                type uint32;
                            }
                            leaf rx-packets {
                                type uint64;
                            }
                            leaf tx-packets {
                                type uint64;
                            }
                            leaf rx-bytes {
                                type uint64;
                            }
                            leaf tx-bytes {
                                type uint64;
                            }
                            leaf rx-dropped {
                                type uint64;
                            }
                            leaf tx-dropped {
                                type uint64;
                            }
                            leaf rx-errors {
                                type uint64;
                            }
                            leaf tx-errors {
                                type uint64;
                            }
                            leaf rx-frame-err {
                                type uint64;
                            }
                            leaf rx-over-err {
                                type uint64;
                            }
                            leaf rx-crc-err {
                                type uint64;
                            }
                            leaf collisions {
                                type uint64;
                            }
                            leaf duration-sec {
                                type uint32;
                            }
                            leaf duration-nsec {
                                type uint32;
                            }
                        }
                    }
                    case multipart-reply-queue {
                        list queue-stats {
                            leaf port-no {
                                type uint32;
                            }
                            leaf queue-id {
                                type uint32;
                            }
                            leaf tx-bytes {
                                type uint64;
                            }
                            leaf tx-packets {
                                type uint64;
                            }
                            leaf tx-errors {
                                type uint64;
                            }
                            leaf duration-sec {
                                type uint32;
                            }
                            leaf duration-nsec {
                                type uint32;
                            }
                        }
                    }
                    case multipart-reply-group {
                        list group-stats {
                            leaf group-id {
                                type uint32;
                            }
                            leaf ref-count {
                                type uint32;
                            }
                            leaf packet-count {
                                type uint64;
                            }
                            leaf byte-count {
                                type uint64;
                            }
                            leaf duration-sec {
                                type uint32;
                            }
                            leaf duration-nsec {
                                type uint32;
                            }
                            list bucket-stats {
                                leaf packet-count {
                                    type uint64;
                                }
                                leaf byte-count {
                                    type uint64;
                                }
                            }
                        }
                    }
                    case multipart-reply-group-desc {
                        list group-desc {
                            leaf type {
                                //type uint8;
                                type oft:group-type;
                            }
                            leaf group-id {
                                type uint32;
                            }
                            list buckets {
                                uses bucket;
                            }
                        }
                    }
                    case multipart-reply-group-features {
                        leaf types {
                            type oft:group-types;
                        }
                        leaf capabilities {
                            type oft:group-capabilities;
                        }
                        leaf-list max_groups {
                            type uint32;
                        }
                        //leaf-list actions {
                        //    type ofaction:action-type;
                        //}
                        list actions-list {
                            uses ofaction:action-header;
                        }
                    }
                    case multipart-reply-meter {
                        list meter-stats {
                            leaf meter-id {
                                type uint32;
                            }
                            leaf flow-count {
                                type uint32;
                            }
                            leaf packet-in-count {
                                type uint64;
                            }
                            leaf byte-in-count {
                                type uint64;
                            }
                            leaf duration-sec {
                                type uint32;
                            }
                            leaf duration-nsec {
                                type uint32;
                            }
                            list meter-band-stats {
                                leaf packet-band-count {
                                    type uint64;
                                }
                                leaf byte-band-count {
                                    type uint64;
                                }
                            }
                        }
                    }
                    case multipart-reply-meter-config {
                        list meter-config {
                            leaf flags {
                                type oft:meter-mod-command;
                            }
                            leaf meter-id {
                                type uint32;
                            }
                            list bands {
                                uses meter-band-header;
                            }
                        }
                    }
                    case multipart-reply-meter-features {
                        leaf max-meter {
                            type uint32;
                        }
                        leaf band-types {
                            type oft:meter-band-type;
                        }
                        leaf capabilities {
                            type oft:meter-flags;
                        }
                        leaf max-bands {
                            type uint8;
                        }
                        leaf max-color {
                            type uint8;
                        }
                    }
                    case multipart-reply-table-features {
                        list table-features {
                            leaf table-id {
                                type uint8;
                            }
                            leaf name {
                                type string;
                            }
                            leaf metadata-match {
                                type binary;
                            }
                            leaf metadata-write {
                                type binary;
                            }
                            leaf config {
                                type oft:port-config;
                            } 
                            leaf max-entries {
                                type uint32;
                            }
                        }
                    }
                    case multipart-reply-port-desc {
                        list ports {
                            uses port;
                        }
                    }
                    case multipart-reply-experimenter {
                        leaf experimenter {
                            type uint32;
                        }
                        leaf exp-type {
                            type uint32;
                        }
                    }
                }
            } 
            /* Barrier messages. */
            grouping barrier-request {
                // reference "OFPT_BARRIER_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
            } 
            grouping barrier-reply {
                // reference "OFPT_BARRIER_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                uses ofHeader;
            } 
        /* Queue Configuration messages. */
            grouping queue-get-config-request {
                // reference "OFPT_QUEUE_GET_CONFIG_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf port {
                    type oft:port-number;
                }
            } 
            grouping queue-get-config-reply {
                // reference "OFPT_QUEUE_GET_CONFIG_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf port {
                    type oft:port-number;
                }
                list queues {
                    uses packet-queue;
                }
            } 
            grouping packet-queue {
                leaf queue-id {
                    type oft:queue-id;
                }
                leaf port {
                    type oft:port-number;
                }
                list properties {
                    uses queue-property-header;
                }
            }
            grouping queue-property-header {
                leaf property {
                    type oft:queue-property;
                }
            }
            /* Controller role change request messages. */
            grouping role-request {
                // reference "OFPT_ROLE_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf role {
                    type oft:controller-role;
                }
                leaf generation-id {
                    type uint64;
                }
            } 
            grouping role-reply {
                // reference "OFPT_ROLE_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf role {
                    type oft:controller-role;
                }
                leaf generation-id {
                    type uint64;
                }
            } 
            /* Asynchronous message configuration. */
            grouping get-async-request {
                // reference "OFPT_GET_ASYNC_REQUEST message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;                
            } 
            grouping get-async-reply {
                // reference "OFPT_GET_ASYNC_REPLY message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                list packet-in-mask {
                    leaf-list mask {
                        type oft:packet-in-reason;
                    }
                }
                list port-status-mask {
                    leaf-list mask {
                        type oft:port-reason;
                    }
                }
                list flow-removed-mask {
                    leaf-list mask {
                        type oft:flow-removed-reason;
                    }
                }
            } 
            grouping set-async {
                // reference "OFPT_SET_ASYNC message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */
                
                uses ofHeader;
                
                leaf-list packet-in-mask {
                    type oft:packet-in-reason;
                }
                leaf-list port-status-mask {
                    type oft:port-reason;
                }
                leaf-list flow-removed-mask {
                    type oft:flow-removed-reason;
                }
            } 
            /* Meters and rate limiters configuration messages. */
            grouping meter-mod {
                // reference "OFPT_METER_MOD message in Openflow Switch 1.3 Spec"
                /* Controller/switch message */

                uses ofHeader;
                
                leaf command {
                    type oft:meter-mod-command;
                } 
                leaf flags {
                    type oft:meter-flags;
                }            
                leaf meter-id {
                    type oft:meter-id;
                }   
                list bands {
                    uses meter-band-header;
                }
            } 
            
            grouping meter-band-header {
                choice meter-band {
                    case meter-band-drop {
                        uses meter-band-commons;
                    }
                    case meter-band-dscp-remark {
                        uses meter-band-commons;
                        leaf prec-level {
                            type uint8;
                        }
                    }
                    case meter-band-experimenter {
                        uses meter-band-commons;
                        leaf experimenter {
                            type uint32;
                        }
                    }
                }
            }
            
            grouping meter-band-commons {
                leaf type {
                    type oft:meter-band-type;
                }
                leaf rate {
                    type uint32;
                }
                leaf burst-size {
                    type uint32;
                }
            }


            /* Immutable messages. */
            notification hello-message {
                uses hello;
                // reference "OFPT_HELLO message in Openflow Switch 1.3 Spec"
                
                /* Symmetric message */
            }
            notification error-message {
                uses error;
                // reference "OFPT_ERROR message in Openflow Switch 1.3 Spec"
                
                /* Symmetric message */
            }
            notification echo-request-message {
                uses echo-request;
                // reference "OFPT_ECHO_REQUEST message in Openflow Switch 1.3 Spec"
                
                /* Symmetric message */
            }
            notification experimenter-message {
                uses experimenter;
                // reference "OFPT_EXPERIMENTER message in Openflow Switch 1.3 Spec"
                // TODO:: does switch send this when understood experimenter msg from lib?
                /* Symmetric message */
            }
    // # Notification and RPCs
        /* Symmetric RPC. */
            rpc echo {
                // reference "OFPT_ECHO_REQUEST message in Openflow Switch 1.3 Spec"
                input {
                    uses echo-request;
                }
                /* Controller/switch message */
                output {
                    uses echo-reply;
                }
            }
            
            rpc echo-reply {
                // reference "OFPT_ECHO_REQUEST message in Openflow Switch 1.3 Spec"
                input {
                    uses echo-reply;
                }
            }
            
            rpc hello {
                // reference "OFPT_HELLO message in Openflow Switch 1.3 Spec"
                input {
                    uses hello;
                }
            }
            
            rpc experimenter {
                // reference "OFPT_EXPERIMENTER message in Openflow Switch 1.3 Spec"
                input {
                    uses experimenter;
                }
            }

        /* Switch configuration messages. */
            rpc get-features {
                // reference "OFPT_FEATURES_REQUEST message in Openflow Switch 1.3 Spec"
                input {
                    uses features-request;
                }
                /* Controller/switch message */
                output {
                    uses features-reply;
                }
            }
            
            rpc get-config {
                // reference "OFPT_GET_CONFIG_REQUEST message in Openflow Switch 1.3 Spec"
                input {
                    uses get-config-request;
                }
                output {
                    uses get-config-reply;
                }
                /* Controller/switch message */
            }
            
            rpc set-config {
                // reference "OFPT_SET_CONFIG message in Openflow Switch 1.3 Spec"
                input {
                    uses set-config;
                }   
                /* Controller/switch message */
            }
        /* Asynchronous messages. */
            notification packet-in-message {
                uses packet-in;
                // reference "OFPT_PACKET_IN message in Openflow Switch 1.3 Spec"
                
             /* Async message */
            }
            notification flow-removed-message {
                uses flow-removed;
                // reference "OFPT_FLOW_REMOVED message in Openflow Switch 1.3 Spec"
                
                /* Async message */
            } 
            notification port-status-message {
                uses port-status;
                // reference "OFPT_PORT_STATUS message in Openflow Switch 1.3 Spec"
                
            } /* Async message */

        /* Controller command messages. */
            rpc packet-out {
                input {
                    uses packet-out;
                    // reference "OFPT_PACKET_OUT message in Openflow Switch 1.3 Spec"
                }
                /* Controller/switch message */
            } 
            rpc flow-mod {
                input {
                    uses flow-mod;
                    // reference "OFPT_FLOW_MOD message in Openflow Switch 1.3 Spec"
                }
                /* Controller/switch message */
            } 
            rpc group-mod {
                input {
                    uses group-mod;
                    // reference "OFPT_GROUP_MOD message in Openflow Switch 1.3 Spec"
                }
                /* Controller/switch message */
            } 
            rpc port-mod {
                input {
                    uses port-mod;
                    // reference "OFPT_PORT_MOD message in Openflow Switch 1.3 Spec"
                }
            } /* Controller/switch message */
            
            rpc table-mod {
                input {
                    uses table-mod;
                    // reference "OFPT_TABLE_MOD message in Openflow Switch 1.3 Spec"
                }
            } /* Controller/switch message */

        /* Multipart messages. */
            //FIXME: Arent this wire protocol specific?

            notification multipart-request-message {
                uses multipart-request;
                // reference "OFPT_MULTIPART_REQUEST message in Openflow Switch 1.3 Spec"
                
            } /* Controller/switch message */
            notification multipart-reply-message {
                uses multipart-reply;
                // reference "OFPT_MULTIPART_REPLY message in Openflow Switch 1.3 Spec"
                
            } /* Controller/switch message */
            

            /* Barrier messages. */
            rpc barrier {
                input {
                    uses barrier-request;
                    // reference "OFPT_BARRIER_REQUEST message in Openflow Switch 1.3 Spec"
                }
                output {
                    uses barrier-reply;
                    // reference "OFPT_BARRIER_REPLY message in Openflow Switch 1.3 Spec"
                }
            }
        /* Queue Configuration messages. */
            rpc get-queue-config {
                input {
                    uses queue-get-config-request;
                    // reference "OFPT_QUEUE_GET_CONFIG_REQUEST message in Openflow Switch 1.3 Spec"
                }
                output {
                    uses queue-get-config-reply;
                    // reference "OFPT_QUEUE_GET_CONFIG_REPLY message in Openflow Switch 1.3 Spec"
                }
            } 

        /* Controller role change request messages. */
            rpc role-request {
                input {
                    uses role-request;
                    // reference "OFPT_ROLE_REQUEST message in Openflow Switch 1.3 Spec"
                }
                output {
                    uses role-reply;
                    // reference "OFPT_ROLE_REPLY message in Openflow Switch 1.3 Spec"
                }
            } /* Controller/switch message */
            
        /* Asynchronous message configuration. */
            rpc get-async {
                input {
                    uses get-async-request;
                    // reference "OFPT_GET_ASYNC_REQUEST message in Openflow Switch 1.3 Spec"
                }
                output {
                    uses get-async-reply;
                    // reference "OFPT_GET_ASYNC_REPLY message in Openflow Switch 1.3 Spec"
                }
            } 
             /* Controller/switch message */
            rpc set-async {
                input { 
                    uses set-async;
                // reference "OFPT_SET_ASYNC message in Openflow Switch 1.3 Spec"
                }
                
            } 
        /* Meters and rate limiters configuration messages. */
            rpc meter-mod {
                input {
                    uses meter-mod;
                    // reference "OFPT_METER_MOD message in Openflow Switch 1.3 Spec"
                }
            } /* Controller/switch message */
}