trema 0.1.3

data/src/switch_manager/secure_channel_listener.h

@@ -0,0 +1,42 @@
+/*
+ * OpenFlow Switch Listener
+ *
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef SECURE_CANNEL_LISTENER_H
+#define SECURE_CANNEL_LISTENER_H
+
+
+#include "switch_manager.h"
+
+
+bool secure_channel_listen_start( struct listener_info *listener_info );
+void secure_channel_accept( int fd, void *data );
+
+
+#endif // SECURE_CANNEL_LISTENER_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/secure_channel_receiver.c

@@ -0,0 +1,126 @@
+/*
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <openflow.h>
+#include <string.h>
+#include <unistd.h>
+#include "trema.h"
+#include "message_queue.h"
+#include "ofpmsg_recv.h"
+#include "ofpmsg_send.h"
+#include "secure_channel_receiver.h"
+
+
+static const size_t RECEIVE_BUFFFER_SIZE = UINT16_MAX + sizeof(struct ofp_packet_in) - 2;
+
+
+int
+recv_from_secure_channel( struct switch_info *sw_info ) {
+  assert( sw_info != NULL );
+  assert( sw_info->recv_queue != NULL );
+
+  // all queued messages should be processed before receiving new messages from remote
+  if ( sw_info->recv_queue->length > 0 ) {
+    return 0;
+  }
+
+  if ( sw_info->fragment_buf == NULL ) {
+    sw_info->fragment_buf = alloc_buffer_with_length( RECEIVE_BUFFFER_SIZE );
+  }
+
+  size_t remaining_length = RECEIVE_BUFFFER_SIZE - sw_info->fragment_buf->length;
+  char *recv_buf = ( char * ) sw_info->fragment_buf->data + sw_info->fragment_buf->length;
+  ssize_t recv_length = read( sw_info->secure_channel_fd, recv_buf, remaining_length );
+  if ( recv_length < 0 ) {
+    if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
+      return 0;
+    }
+    error( "Receive error:%s(%d)", strerror( errno ), errno );
+    return -1;
+  }
+  if ( recv_length == 0 ) {
+    debug( "Connection closed by peer." );
+    return -1;
+  }
+  sw_info->fragment_buf->length += ( size_t ) recv_length;
+
+  size_t read_total = 0;
+  while ( sw_info->fragment_buf->length >= sizeof( struct ofp_header ) ) {
+    struct ofp_header *header = sw_info->fragment_buf->data;
+    if ( header->version != OFP_VERSION ) {
+      error( "Receive error: invalid version (version %d)", header->version );
+      ofpmsg_send_error_msg( sw_info,
+                             OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION, sw_info->fragment_buf );
+      return -1;
+    }
+    uint16_t message_length = ntohs( header->length );
+    if ( message_length > sw_info->fragment_buf->length ) {
+      break;
+    }
+    buffer *message = alloc_buffer_with_length( message_length );
+    char *p = append_back_buffer( message, message_length );
+    memcpy( p, sw_info->fragment_buf->data, message_length );
+    remove_front_buffer( sw_info->fragment_buf, message_length ); 
+    enqueue_message( sw_info->recv_queue, message );
+    read_total += message_length;
+  }
+
+  // remove headroom manually for next call
+  if ( read_total > 0 ) {
+    memmove( ( char * ) sw_info->fragment_buf->data - read_total,
+             sw_info->fragment_buf->data,
+             sw_info->fragment_buf->length );
+    sw_info->fragment_buf->data = ( char * ) sw_info->fragment_buf->data - read_total;
+  }
+
+  return 0;
+}
+
+
+int
+handle_messages_from_secure_channel( struct switch_info *sw_info ) {
+  assert( sw_info != NULL );
+  assert( sw_info->recv_queue != NULL );
+
+  int ret;
+  int errors = 0;
+  buffer *message;
+
+  while ( ( message = dequeue_message( sw_info->recv_queue ) ) != NULL ) {
+    ret = ofpmsg_recv( sw_info, message );
+    if ( ret < 0 ) {
+      error( "Failed to handle message to application." );
+      errors++;
+    }
+  }
+
+  return errors == 0 ? 0 : -1;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/secure_channel_receiver.h

@@ -0,0 +1,43 @@
+/*
+ * OpenFlow Switch Manager
+ *
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef SECURE_CHANNEL_RECEIVER_H
+#define SECURE_CHANNEL_RECEIVER_H
+
+
+#include "switch.h"
+
+
+int recv_from_secure_channel( struct switch_info *sw_info );
+int handle_messages_from_secure_channel( struct switch_info *sw_info );
+
+
+#endif // SECURE_CHANNEL_RECEIVER_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */
+

data/src/switch_manager/secure_channel_sender.c

@@ -0,0 +1,126 @@
+/*
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <assert.h>
+#include <errno.h>
+#include <openflow.h>
+#include <string.h>
+#include <unistd.h>
+#include "event_handler.h"
+#include "message_queue.h"
+#include "ofpmsg_send.h"
+#include "secure_channel_sender.h"
+#include "trema.h"
+
+
+int
+send_to_secure_channel( struct switch_info *sw_info, buffer *buf ) {
+  assert( sw_info != NULL );
+  assert( buf != NULL );
+  assert( buf->length > 0 );
+
+  if ( sw_info->send_queue == NULL ) {
+    return -1;
+  }
+
+  bool res = enqueue_message( sw_info->send_queue, buf );
+  if ( res ) {
+    set_writable( sw_info->secure_channel_fd, true );
+  }
+  return res ? 0 : -1;
+}
+
+
+typedef struct {
+  struct iovec *iov;
+  int iovcnt;
+} writev_args;
+
+
+static void
+append_to_writev_args( buffer *message, void *user_data ) {
+  writev_args *args = user_data;
+
+  args->iov[ args->iovcnt ].iov_base = message->data;
+  args->iov[ args->iovcnt ].iov_len = message->length;
+  args->iovcnt++;
+}
+
+
+int
+flush_secure_channel( struct switch_info *sw_info ) {
+  assert( sw_info != NULL );
+  assert( sw_info->send_queue != NULL );
+  assert( sw_info->secure_channel_fd >= 0 );
+
+  buffer *buf;
+  ssize_t write_length;
+
+  if ( sw_info->send_queue->length == 0 ) {
+    return 0;
+  }
+  set_writable( sw_info->secure_channel_fd, false );
+  writev_args args;
+  args.iov = xmalloc( sizeof( struct iovec ) * ( size_t ) sw_info->send_queue->length );
+  args.iovcnt = 0;
+  foreach_message_queue( sw_info->send_queue, append_to_writev_args, &args );
+  if ( args.iovcnt == 0 ) {
+    xfree( args.iov );
+    return 0;
+  }
+  write_length = writev( sw_info->secure_channel_fd, args.iov, args.iovcnt );
+  xfree( args.iov );
+  if ( write_length < 0 ) {
+    if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
+      set_writable( sw_info->secure_channel_fd, true );
+      return 0;
+    }
+    error( "Failed to send a message to secure channel ( errno = %s [%d] ).",
+           strerror( errno ), errno );
+    return -1;
+  }
+  if ( write_length == 0 ) {
+    return 0;
+  }
+  while ( ( buf = peek_message( sw_info->send_queue ) ) != NULL ) {
+    if ( write_length == 0 ) {
+      set_writable( sw_info->secure_channel_fd, true );
+      return 0;
+    }
+    if ( ( size_t ) write_length < buf->length ) {
+      remove_front_buffer( buf, ( size_t ) write_length );
+      set_writable( sw_info->secure_channel_fd, true );
+      return 0;
+    }
+    write_length -= ( ssize_t ) buf->length;
+    buf = dequeue_message( sw_info->send_queue );
+    free_buffer( buf );
+  }
+
+  return 0;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/secure_channel_sender.h

@@ -0,0 +1,43 @@
+/*
+ * OpenFlow Switch Manager
+ *
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef SECURE_CHANNEL_SENDER_H
+#define SECURE_CHANNEL_SENDER_H
+
+
+#include "trema.h"
+#include "switch.h"
+
+
+int send_to_secure_channel( struct switch_info *sw_info, buffer *buf );
+int flush_secure_channel( struct switch_info *sw_info );
+
+
+#endif // SECURE_CHANNEL_SENDER_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/service_interface.c

@@ -0,0 +1,181 @@
+/*
+ * Author: Kazushi SUGYO
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <string.h>
+#include <inttypes.h>
+#include "ofpmsg_send.h"
+#include "openflow_service_interface.h"
+#include "service_interface.h"
+#include "trema.h"
+
+
+static buffer *
+create_openflow_application_message( uint64_t *datapath_id, buffer *data ) {
+  openflow_service_header_t *message;
+  buffer *buf;
+  void *append;
+  size_t append_len = 0;
+
+  if ( data != NULL ) {
+     append_len = data->length;
+  }
+  buf = alloc_buffer_with_length( sizeof( openflow_service_header_t ) + append_len );
+  message = append_back_buffer( buf, sizeof( openflow_service_header_t ) );
+  if ( datapath_id == NULL ) {
+    message->datapath_id = ~0U; // FIXME: defined invalid datapath_id
+  } else {
+    message->datapath_id = htonll( *datapath_id );
+  }
+  message->service_name_length = htons( 0 );
+  // TODO: append ipaddress and port
+  if ( append_len > 0 ) {
+    append = append_back_buffer( buf, append_len );
+    memcpy( append, data->data, append_len );
+  }
+
+  return buf;
+}
+
+
+void
+service_send_to_reply( char *service_name, uint16_t message_type, uint64_t *datapath_id, buffer *data ) {
+  buffer *buf;
+
+  if ( service_name == NULL ) {
+    return;
+  }
+
+  buf = create_openflow_application_message( datapath_id, data );
+  if ( !send_message( service_name, message_type, buf->data, buf->length ) ) {
+    error( "Failed to send to reply ( service_name = %s ).", service_name );
+  }
+  free_buffer( buf );
+}
+
+
+void
+service_send_to_application( list_element *service_name_list, uint16_t message_type, uint64_t *datapath_id, buffer *data ) {
+  buffer *buf;
+  list_element *list;
+  char *service_name;
+
+  if ( service_name_list == NULL ) {
+    return;
+  }
+
+  buf = create_openflow_application_message( datapath_id, data );
+
+  static const char *error_service_name = NULL;
+  for ( list = service_name_list; list != NULL; list = list->next ) {
+    service_name = list->data;
+    if ( !send_message( service_name, message_type, 
+                        buf->data, buf->length ) ) {
+      if ( error_service_name != service_name ) {
+        warn( "Failed to send message ( service_name = %s ).", service_name );
+      }
+      error_service_name = service_name;
+    }
+    else {
+      error_service_name = NULL;
+    }
+  }
+  free_buffer( buf );
+}
+
+
+static void
+handle_openflow_message( uint64_t *datapath_id, char *service_name, buffer *buf ) {
+  struct ofp_header *header;
+  int ret;
+
+  ret = validate_openflow_message( buf );
+  if ( ret != 0 ) {
+    header = buf->data;
+    notice( "Validation error. dpid = %#" PRIx64 ", type %u, errno %d, service_name = %s",
+            *datapath_id, header->type, ret, service_name );
+    free_buffer( buf );
+
+    return;
+  }
+
+  switch_event_recv_from_application( datapath_id, service_name, buf );
+}
+
+
+static void
+handle_openflow_disconnect_request( uint64_t *datapath_id ) {
+  switch_event_disconnect_request( datapath_id );
+}
+
+
+void
+service_recv_from_application( uint16_t message_type, buffer *buf ) {
+   openflow_service_header_t *message;
+   uint64_t datapath_id;
+   uint16_t service_name_length;
+   char *service_name;
+
+  if ( buf->length < sizeof( openflow_service_header_t ) + sizeof( struct ofp_header ) ) {
+    error( "Too short openflow application message(%u).", buf->length );
+    free_buffer( buf );
+
+    return;
+  }
+
+  message = buf->data;
+  datapath_id = ntohll( message->datapath_id );
+  service_name_length = ntohs( message->service_name_length );
+  service_name = remove_front_buffer( buf, sizeof( openflow_service_header_t ) );
+  if ( service_name_length < 1 ) {
+    error( "Invalid service name length %u.", service_name_length );
+    free_buffer( buf );
+
+    return;
+  }
+  if ( service_name[ service_name_length - 1 ] != '\0' ) {
+    error( "Service name is not null terminated." );
+    free_buffer( buf );
+
+    return;
+  }
+  remove_front_buffer( buf, service_name_length );
+
+  switch ( message_type ) {
+  case MESSENGER_OPENFLOW_MESSAGE:
+    handle_openflow_message( &datapath_id, service_name, buf );
+    break;
+  case MESSENGER_OPENFLOW_DISCONNECT_REQUEST:
+    free_buffer( buf );
+    handle_openflow_disconnect_request( &datapath_id );
+    break;
+  default:
+    error( "Unknown message type %d.", message_type );
+    free_buffer( buf );
+    break;
+  }
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */