trema 0.2.5 → 0.2.6

data/src/lib/messenger.h

@@ -75,7 +75,7 @@ enum {
   MESSENGER_DUMP_SEND_REFUSED,
   MESSENGER_DUMP_SEND_OVERFLOW,
   MESSENGER_DUMP_SEND_CLOSED,
-  MESSENGER_DUMP_LOGGER, 
+  MESSENGER_DUMP_LOGGER,
   MESSENGER_DUMP_PCAP,
   MESSENGER_DUMP_SYSLOG,
   MESSENGER_DUMP_TEXT,
@@ -115,13 +115,14 @@ extern bool ( *add_message_received_callback )( const char *service_name, const
 extern bool ( *rename_message_received_callback )( const char *old_service_name, const char *new_service_name );
 extern bool ( *delete_message_received_callback )( const char *service_name, void ( *callback )( uint16_t tag, void *data, size_t len ) );
 extern bool ( *add_message_requested_callback )( const char *service_name, void ( *callback )( const messenger_context_handle *handle, uint16_t tag, void *data, size_t len ) );
+extern bool ( *rename_message_requested_callback )( const char *old_service_name, const char *new_service_name );
 extern bool ( *delete_message_requested_callback )( const char *service_name, void ( *callback )( const messenger_context_handle *handle, uint16_t tag, void *data, size_t len ) );
 extern bool ( *add_message_replied_callback )( const char *service_name, void ( *callback )( uint16_t tag, void *data, size_t len, void *user_data ) );
 extern bool ( *delete_message_replied_callback )( const char *service_name, void ( *callback )( uint16_t tag, void *data, size_t len, void *user_data ) );
 extern bool ( *send_message )( const char *service_name, const uint16_t tag, const void *data, size_t len );
 extern bool ( *send_request_message )( const char *to_service_name, const char *from_service_name, const uint16_t tag, const void *data, size_t len, void *user_data );
 extern bool ( *send_reply_message )( const messenger_context_handle *handle, const uint16_t tag, const void *data, size_t len );
-extern bool ( *clear_send_queue ) ( const char *service_name );
+extern bool ( *clear_send_queue )( const char *service_name );
 
 bool init_messenger( const char *working_directory );
 bool finalize_messenger( void );

data/src/lib/openflow_application_interface.c

@@ -538,8 +538,8 @@ handle_error( const uint64_t datapath_id, buffer *data ) {
   body = duplicate_buffer( data );
   remove_front_buffer( body, offsetof( struct ofp_error_msg, data ) );
 
-  debug( "An error message is received from %#lx "
-         "( transaction_id = %#x, type = %u, code = %u, data length = %u ).",
+  debug( "An error message is received from %#" PRIx64 " "
+         "( transaction_id = %#x, type = %#x, code = %#x, data length = %zu ).",
          datapath_id, transaction_id, type, code, body->length );
 
   if ( event_handlers.error_callback == NULL ) {
@@ -718,7 +718,7 @@ handle_features_reply( const uint64_t datapath_id, buffer *data ) {
 
   if ( event_handlers.features_reply_callback == NULL ) {
     debug( "Callback function for features reply events is not set." );
-    if( phy_ports_head != NULL ) {
+    if ( phy_ports_head != NULL ) {
       element = phy_ports_head;
       while ( element != NULL ) {
         xfree( element->data );
@@ -811,7 +811,7 @@ handle_packet_in( const uint64_t datapath_id, buffer *data ) {
 
   debug(
     "A packet_in message is received from %#" PRIx64
-    " (transaction_id = %#x, buffer_id = %#x, total_len = %u, in_port = %u, reason = %#x, body length = %u).",
+    " ( transaction_id = %#x, buffer_id = %#x, total_len = %u, in_port = %u, reason = %#x, body length = %u ).",
     datapath_id,
     transaction_id,
     buffer_id,
@@ -843,7 +843,7 @@ handle_packet_in( const uint64_t datapath_id, buffer *data ) {
   }
 
   assert( event_handlers.packet_in_callback != NULL );
-  debug( "Calling packet_in handler (callback = %p, user_data = %p).",
+  debug( "Calling packet_in handler ( callback = %p, user_data = %p ).",
          event_handlers.packet_in_callback,
          event_handlers.packet_in_user_data
   );
@@ -926,7 +926,7 @@ handle_flow_removed( const uint64_t datapath_id, buffer *data ) {
   }
 
   debug(
-    "Calling flow removed handler (callback = %p, user_data = %p).",
+    "Calling flow removed handler ( callback = %p, user_data = %p ).",
     event_handlers.flow_removed_callback,
     event_handlers.flow_removed_user_data
   );
@@ -1162,7 +1162,7 @@ handle_stats_reply( const uint64_t datapath_id, buffer *data ) {
       if ( body != NULL ) {
         free_buffer( body );
       }
-      critical( "Unhandled stats type ( type = %u ).", type );
+      critical( "Unhandled stats type ( type = %#x ).", type );
       assert( 0 );
       break;
     }
@@ -1368,7 +1368,7 @@ handle_switch_ready( uint64_t datapath_id ) {
 static void
 handle_messenger_openflow_disconnected( uint64_t datapath_id ) {
   if ( event_handlers.switch_disconnected_callback != NULL ) {
-    debug( "Calling switch disconnected handler (callback = %p, user_data = %p).",
+    debug( "Calling switch disconnected handler ( callback = %p, user_data = %p ).",
            event_handlers.switch_disconnected_callback, event_handlers.switch_disconnected_user_data );
     event_handlers.switch_disconnected_callback( datapath_id, event_handlers.switch_disconnected_user_data );
   }
@@ -1384,7 +1384,7 @@ handle_switch_events( uint16_t type, void *data, size_t length ) {
   assert( data != NULL );
   assert( length == sizeof( openflow_service_header_t ) );
 
-  debug( "Received a switch event (type = %u) from remote.", type );
+  debug( "Received a switch event ( type = %#x ) from remote.", type );
 
   openflow_service_header_t *message = data;
   uint64_t datapath_id = ntohll( message->datapath_id );
@@ -1401,7 +1401,7 @@ handle_switch_events( uint16_t type, void *data, size_t length ) {
       handle_messenger_openflow_disconnected( datapath_id );
       break;
     default:
-      error( "Unhandled switch event (type = %u).", type );
+      error( "Unhandled switch event ( type = %#x ).", type );
       break;
   }
 
@@ -1543,7 +1543,7 @@ handle_openflow_message( void *data, size_t length ) {
   ret = validate_openflow_message( buffer );
 
   if ( ret < 0 ) {
-    error( "Failed to validate an OpenFlow message ( code = %d, length = %u ).", ret, length );
+    error( "Failed to validate an OpenFlow message ( code = %d, length = %zu ).", ret, length );
     free_buffer( buffer );
 
     return;
@@ -1586,7 +1586,7 @@ handle_openflow_message( void *data, size_t length ) {
     handle_queue_get_config_reply( datapath_id, buffer );
     break;
   default:
-    error( "Unhandled OpenFlow message ( type = %u ).", header->type );
+    error( "Unhandled OpenFlow message ( type = %#x ).", header->type );
     break;
   }
 
@@ -1601,7 +1601,7 @@ handle_message( uint16_t type, void *data, size_t length ) {
   assert( data != NULL );
   assert( length >= sizeof( openflow_service_header_t ) );
 
-  debug( "A message is received from remote ( type = %u ).", type );
+  debug( "A message is received from remote ( type = %#x ).", type );
 
   switch ( type ) {
   case MESSENGER_OPENFLOW_MESSAGE:
@@ -1612,7 +1612,7 @@ handle_message( uint16_t type, void *data, size_t length ) {
   case MESSENGER_OPENFLOW_DISCONNECTED:
     return handle_switch_events( type, data, length );
   default:
-    error( "Unhandled message ( type = %u ).", type );
+    error( "Unhandled message ( type = %#x ).", type );
     update_switch_event_stats( type, OPENFLOW_MESSAGE_RECEIVE, true );
     break;
   }
@@ -1647,10 +1647,10 @@ handle_list_switches_reply( uint16_t message_type, void *data, size_t length, vo
   UNUSED( message_type );
   assert( data != NULL );
 
-  uint64_t *dpid = ( uint64_t *) data;
+  uint64_t *dpid = ( uint64_t * ) data;
   size_t num_switch = length / sizeof( uint64_t );
 
-  debug( "A list switches reply message is received ( number of switches = %u ).",
+  debug( "A list switches reply message is received ( number of switches = %zu ).",
          num_switch );
 
   if ( event_handlers.list_switches_reply_callback == NULL ) {
@@ -1663,7 +1663,7 @@ handle_list_switches_reply( uint16_t message_type, void *data, size_t length, vo
 
   unsigned int i;
   for ( i = 0; i < num_switch; ++i ) {
-    uint64_t *datapath_id = ( uint64_t *) xmalloc( sizeof( uint64_t ) );
+    uint64_t *datapath_id = ( uint64_t * ) xmalloc( sizeof( uint64_t ) );
     *datapath_id = ntohll( dpid[ i ] );
     insert_dpid( &switches, datapath_id );
   }

data/src/lib/openflow_message.c

@@ -57,10 +57,12 @@ extern void mock_debug( const char *format, ... );
 #endif // UNIT_TESTING
 
 
-#define VLAN_VID_MASK 0x0fff // 12 bits
-#define VLAN_PCP_MASK 0x07   // 3 bits
-#define NW_TOS_MASK 0xfc     // upper 6 bits
-#define ARP_OP_MASK 0x00ff   // 8 bits
+#define VLAN_VID_MASK 0x0fff  // 12 bits
+#define VLAN_PCP_MASK 0x07    // 3 bits
+#define NW_TOS_MASK 0xfc      // upper 6 bits
+#define ARP_OP_MASK 0x00ff    // 8 bits
+#define ICMP_TYPE_MASK 0x00ff // 8 bits
+#define ICMP_CODE_MASK 0x00ff // 8 bits
 
 #define PORT_CONFIG ( OFPPC_PORT_DOWN | OFPPC_NO_STP | OFPPC_NO_RECV      \
                       | OFPPC_NO_RECV_STP | OFPPC_NO_FLOOD | OFPPC_NO_FWD \
@@ -104,7 +106,7 @@ init_openflow_message( void ) {
 
 static buffer *
 create_header( const uint32_t transaction_id, const uint8_t type, const uint16_t length ) {
-  debug( "Creating an OpenFlow header (version = %#x, type = %#x, length = %u, xid = %#x).",
+  debug( "Creating an OpenFlow header ( version = %#x, type = %#x, length = %u, xid = %#x ).",
          OFP_VERSION, type, length, transaction_id );
 
   assert( length >= sizeof( struct ofp_header ) );
@@ -291,7 +293,7 @@ create_features_reply( const uint32_t transaction_id, const uint64_t datapath_id
 
   if ( n_ports ) {
     phy_port = ( struct ofp_phy_port * ) ( ( char * ) buffer->data
-                                           + offsetof( struct ofp_switch_features, ports) );
+                                           + offsetof( struct ofp_switch_features, ports ) );
     port = p;
     while ( port != NULL ) {
       phy_port_to_string( port->data, port_str, sizeof( port_str ) );
@@ -433,7 +435,7 @@ create_flow_removed( const uint32_t transaction_id, const struct ofp_match match
 
 buffer *
 create_port_status( const uint32_t transaction_id, const uint8_t reason,
-                    const struct ofp_phy_port desc) {
+                    const struct ofp_phy_port desc ) {
   char desc_str[ 1024 ];
   buffer *buffer;
   struct ofp_phy_port d = desc;
@@ -480,10 +482,10 @@ get_actions_length( const openflow_actions *actions ) {
     action = action->next;
   }
 
-  debug( "Total length of actions = %u.", actions_length );
+  debug( "Total length of actions = %d.", actions_length );
 
   if ( actions_length > UINT16_MAX ) {
-    critical( "Too many actions ( # of actions = %d, actions length = %u ).",
+    critical( "Too many actions ( # of actions = %d, actions length = %d ).",
               actions->n_actions, actions_length );
     assert( 0 );
   }
@@ -585,7 +587,7 @@ create_flow_mod( const uint32_t transaction_id, const struct ofp_match match,
            "buffer_id = %#x, out_port = %u, flags = %#x ).",
            transaction_id, match_str, cookie, command,
            idle_timeout, hard_timeout, priority,
-           buffer_id, out_port, flags  );
+           buffer_id, out_port, flags );
   }
 
   if ( actions != NULL ) {
@@ -922,7 +924,7 @@ create_flow_stats_reply( const uint32_t transaction_id, const uint16_t flags,
     flow = flow->next;
   }
 
-  debug( "# of flows = %u.", n_flows );
+  debug( "# of flows = %d.", n_flows );
 
   length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body ) + length );
 
@@ -1635,7 +1637,7 @@ append_action_vendor( openflow_actions *actions, const uint32_t vendor, const bu
     body_length = ( uint16_t ) body->length;
   }
 
-  debug( "Appending a vendor action ( vendor = %#" PRIx64 ", body length = %u ).", vendor, body_length );
+  debug( "Appending a vendor action ( vendor = %#" PRIx32 ", body length = %u ).", vendor, body_length );
 
   assert( actions != NULL );
 
@@ -1645,6 +1647,10 @@ append_action_vendor( openflow_actions *actions, const uint32_t vendor, const bu
   action_vendor->len = ( uint16_t ) ( sizeof( struct ofp_action_vendor_header ) + body_length );
   action_vendor->vendor = vendor;
 
+  if ( body_length > 0 ) {
+    memcpy( ( char * ) action_vendor + sizeof( struct ofp_action_vendor_header ), body->data, body_length );
+  }
+
   ret = append_to_tail( &actions->list, ( void * ) action_vendor );
   if ( ret ) {
     actions->n_actions++;
@@ -3447,18 +3453,14 @@ validate_action_enqueue( const struct ofp_action_enqueue *action ) {
 
 int
 validate_action_vendor( const struct ofp_action_vendor_header *action ) {
-  struct ofp_action_vendor_header vendor;
-
-  ntoh_action_vendor( &vendor, action );
-
-  if ( vendor.type != OFPAT_VENDOR ) {
+  if ( ntohs( action->type ) != OFPAT_VENDOR ) {
     return ERROR_INVALID_ACTION_TYPE;
   }
-  if ( vendor.len < sizeof( struct ofp_action_vendor_header ) ) {
+  if ( ntohs( action->len ) < sizeof( struct ofp_action_vendor_header ) ) {
     return ERROR_TOO_SHORT_ACTION_VENDOR;
   }
 
-  // vendor.vendor
+  // action->vendor
 
   return 0;
 }
@@ -3929,6 +3931,7 @@ set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
                        const uint32_t wildcards, const buffer *packet ) {
   // Note that wildcards must be filled before calling this function.
 
+  assert( match != NULL );
   assert( packet != NULL );
   assert( packet->user_data != NULL );
 
@@ -3948,8 +3951,8 @@ set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
     if ( packet_type_eth_vtag( packet ) ) {
       match->dl_vlan = ( ( packet_info * ) packet->user_data )->vlan_vid;
       if ( ( match->dl_vlan & ~VLAN_VID_MASK ) != 0 ) {
-        warn( "Invalid vlan id ( change %u to %u )", match->dl_vlan, match->dl_vlan & VLAN_VID_MASK );
-	match->dl_vlan = ( uint16_t ) ( match->dl_vlan & VLAN_VID_MASK );
+        warn( "Invalid vlan id ( change %#x to %#x )", match->dl_vlan, match->dl_vlan & VLAN_VID_MASK );
+        match->dl_vlan = ( uint16_t ) ( match->dl_vlan & VLAN_VID_MASK );
       }
     }
     else {
@@ -3961,7 +3964,7 @@ set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
       match->dl_vlan_pcp = ( ( packet_info * ) packet->user_data )->vlan_prio;
       if ( ( match->dl_vlan_pcp & ~VLAN_PCP_MASK ) != 0 ) {
         warn( "Invalid vlan pcp ( change %u to %u )", match->dl_vlan_pcp, match->dl_vlan_pcp & VLAN_PCP_MASK );
-	match->dl_vlan_pcp = ( uint8_t ) ( match->dl_vlan_pcp & VLAN_PCP_MASK );
+        match->dl_vlan_pcp = ( uint8_t ) ( match->dl_vlan_pcp & VLAN_PCP_MASK );
       }
     }
   }
@@ -3972,7 +3975,7 @@ set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
     if ( !( wildcards & OFPFW_NW_TOS ) ) {
       match->nw_tos = ( ( packet_info * ) packet->user_data )->ipv4_tos;
       if ( ( match->nw_tos & ~NW_TOS_MASK ) != 0 ) {
-        warn( "Invalid ipv4 tos ( change %u to %u )", match->nw_tos, match->nw_tos & NW_TOS_MASK );
+        warn( "Invalid ipv4 tos ( change %#x to %#x )", match->nw_tos, match->nw_tos & NW_TOS_MASK );
         match->nw_tos = ( uint8_t ) ( match->nw_tos & NW_TOS_MASK );
       }
     }
@@ -4034,6 +4037,155 @@ set_match_from_packet( struct ofp_match *match, const uint16_t in_port,
 }
 
 
+void
+normalize_match( struct ofp_match *match ) {
+
+  assert( match != NULL );
+
+  char match_string[ 1024 ];
+  match_to_string( match, match_string, sizeof( match_string ) );
+  debug( "Normalizing match structure ( original match = [%s] ).", match_string );
+
+  memset( match->pad1, 0, sizeof( match->pad1 ) );
+  memset( match->pad2, 0, sizeof( match->pad2 ) );
+
+  match->wildcards &= OFPFW_ALL;
+
+  if ( match->wildcards & OFPFW_IN_PORT ) {
+    match->in_port = 0;
+  }
+  if ( match->wildcards & OFPFW_DL_VLAN ) {
+    match->dl_vlan = 0;
+  }
+  else {
+    if ( match->dl_vlan == UINT16_MAX ) {
+      match->wildcards |= ( uint32_t ) OFPFW_DL_VLAN_PCP;
+      match->dl_vlan_pcp = 0;
+    }
+    else {
+      match->dl_vlan &= VLAN_VID_MASK;
+    }
+  }
+  if ( match->wildcards & OFPFW_DL_SRC ) {
+    memset( match->dl_src, 0, sizeof( match->dl_src ) );
+  }
+  if ( match->wildcards & OFPFW_DL_DST ) {
+    memset( match->dl_dst, 0, sizeof( match->dl_dst ) );
+  }
+  if ( match->wildcards & OFPFW_DL_TYPE ) {
+    match->dl_type = 0;
+    match->wildcards |= ( uint32_t ) OFPFW_NW_TOS;
+    match->wildcards |= ( uint32_t ) OFPFW_NW_PROTO;
+    match->wildcards |= ( uint32_t ) OFPFW_NW_SRC_MASK;
+    match->wildcards |= ( uint32_t ) OFPFW_NW_DST_MASK;
+    match->wildcards |= ( uint32_t ) OFPFW_TP_SRC;
+    match->wildcards |= ( uint32_t ) OFPFW_TP_DST;
+    match->nw_tos = 0;
+    match->nw_proto = 0;
+    match->nw_src = 0;
+    match->nw_dst = 0;
+    match->tp_src = 0;
+    match->tp_dst = 0;
+  }
+  else {
+    if ( match->dl_type == ETH_ETHTYPE_ARP ) {
+      match->wildcards |= ( uint32_t ) OFPFW_NW_TOS;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_SRC;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_DST;
+      match->nw_tos = 0;
+      match->tp_src = 0;
+      match->tp_dst = 0;
+    }
+    else if ( match->dl_type != ETH_ETHTYPE_IPV4 ) {
+      match->wildcards |= ( uint32_t ) OFPFW_NW_TOS;
+      match->wildcards |= ( uint32_t ) OFPFW_NW_PROTO;
+      match->wildcards |= ( uint32_t ) OFPFW_NW_SRC_MASK;
+      match->wildcards |= ( uint32_t ) OFPFW_NW_DST_MASK;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_SRC;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_DST;
+      match->nw_tos = 0;
+      match->nw_proto = 0;
+      match->nw_src = 0;
+      match->nw_dst = 0;
+      match->tp_src = 0;
+      match->tp_dst = 0;
+    }
+  }
+  if ( match->wildcards & OFPFW_NW_PROTO ) {
+    match->nw_proto = 0;
+    if ( match->dl_type != ETH_ETHTYPE_IPV4 ) {
+      match->wildcards |= ( uint32_t ) OFPFW_TP_SRC;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_DST;
+      match->tp_src = 0;
+      match->tp_dst = 0;
+    }
+  }
+  else {
+    if ( match->dl_type == ETH_ETHTYPE_ARP ) {
+      match->nw_proto &= ARP_OP_MASK;
+    }
+    if ( match->dl_type == ETH_ETHTYPE_IPV4 &&
+         match->nw_proto != IPPROTO_TCP && match->nw_proto != IPPROTO_UDP && match->nw_proto != IPPROTO_ICMP ) {
+      match->wildcards |= ( uint32_t ) OFPFW_TP_SRC;
+      match->wildcards |= ( uint32_t ) OFPFW_TP_DST;
+      match->tp_src = 0;
+      match->tp_dst = 0;
+    }
+  }
+
+  unsigned int nw_src_mask_len = ( match->wildcards & OFPFW_NW_SRC_MASK ) >> OFPFW_NW_SRC_SHIFT;
+  if ( nw_src_mask_len >= 32 ) {
+    match->wildcards &= ( uint32_t ) ~OFPFW_NW_SRC_MASK;
+    match->wildcards |= OFPFW_NW_SRC_ALL;
+    match->nw_src = 0;
+  }
+  else {
+    match->nw_src &= ( 0xffffffff << nw_src_mask_len );
+  }
+  unsigned int nw_dst_mask_len = ( match->wildcards & OFPFW_NW_DST_MASK ) >> OFPFW_NW_DST_SHIFT;
+  if ( nw_dst_mask_len >= 32 ) {
+    match->wildcards &= ( uint32_t ) ~OFPFW_NW_DST_MASK;
+    match->wildcards |= OFPFW_NW_DST_ALL;
+    match->nw_dst = 0;
+  }
+  else {
+    match->nw_dst &= ( 0xffffffff << nw_dst_mask_len );
+  }
+  if ( match->wildcards & OFPFW_TP_SRC ) {
+    match->tp_src = 0;
+  }
+  else {
+    if ( match->nw_proto == IPPROTO_ICMP ) {
+      match->tp_src &= ICMP_TYPE_MASK;
+    }
+  }
+  if ( match->wildcards & OFPFW_TP_DST ) {
+    match->tp_dst = 0;
+  }
+  else {
+    if ( match->nw_proto == IPPROTO_ICMP ) {
+      match->tp_dst &= ICMP_CODE_MASK;
+    }
+  }
+
+  if ( match->wildcards & OFPFW_DL_VLAN_PCP ) {
+    match->dl_vlan_pcp = 0;
+  }
+  else {
+    match->dl_vlan_pcp &= VLAN_PCP_MASK;
+  }
+  if ( match->wildcards & OFPFW_NW_TOS ) {
+    match->nw_tos = 0;
+  }
+  else {
+    match->nw_tos &= NW_TOS_MASK;
+  }
+
+  match_to_string( match, match_string, sizeof( match_string ) );
+  debug( "Normalization completed ( updated match = [%s] ).", match_string );
+}
+
+
 /*
  * Local variables:
  * c-basic-offset: 2