trema 0.1.3

data/src/switch_manager/ofpmsg_recv.h

@@ -0,0 +1,42 @@
+/*
+ * 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 RSWITCH_RECV_H
+#define RSWITCH_RECV_H
+
+
+#include "trema.h"
+#include "switch.h"
+
+
+int ofpmsg_recv( struct switch_info *sw_info, buffer *buf );
+
+
+#endif // RSWITCH_RECV_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */
+

data/src/switch_manager/ofpmsg_send.c

@@ -0,0 +1,235 @@
+/*
+ * OpenFlow Switch Manager
+ *
+ * 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 <openflow.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include "cookie_table.h"
+#include "ofpmsg_send.h"
+#include "secure_channel_sender.h"
+#include "switch.h"
+#include "trema.h"
+#include "xid_table.h"
+
+
+int
+ofpmsg_send_hello( struct switch_info *sw_info ) {
+  int ret;
+  buffer *buf;
+
+  buf = create_hello( generate_xid() );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'hello' to a switch. fd:%d", sw_info->secure_channel_fd );
+  }
+
+  return ret;
+}
+
+
+int
+ofpmsg_send_echoreply( struct switch_info *sw_info, uint32_t xid, buffer *body ) {
+  int ret;
+  buffer *buf;
+
+  buf = create_echo_reply( xid, body );
+  free_buffer( body );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'echo reply' to a switch %#" PRIx64 ".", sw_info->datapath_id );
+  }
+
+  return ret;
+}
+
+
+int
+ofpmsg_send_featuresrequest( struct switch_info *sw_info ) {
+  int ret;
+  buffer *buf;
+
+  buf = create_features_request( generate_xid() );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'features request' to a switch. fd:%d", sw_info->secure_channel_fd );
+  }
+
+  return ret;
+}
+
+
+int
+ofpmsg_send_setconfig( struct switch_info *sw_info ) {
+  int ret;
+  buffer *buf;
+
+  buf = create_set_config( generate_xid(), sw_info->config_flags,
+                           sw_info->miss_send_len );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'set config request' to a switch %#" PRIx64 ".", sw_info->datapath_id );
+  }
+
+  return ret;
+}
+
+
+int
+ofpmsg_send_error_msg( struct switch_info *sw_info, uint16_t type, uint16_t code, buffer *data ) {
+  int ret;
+  buffer *buf;
+
+  if (data->length > OFP_ERROR_MSG_MAX_DATA ) {
+    // FIXME
+    data->length = OFP_ERROR_MSG_MAX_DATA;
+  }
+
+  buf = create_error( generate_xid(), type, code, data );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'error' to a switch %#" PRIx64 ".", sw_info->datapath_id );
+  }
+
+  return ret;
+}
+
+
+static int
+update_flowmod_cookie( buffer *buf, char *service_name ) {
+  struct ofp_flow_mod *flow_mod = buf->data;
+  uint16_t command = ntohs( flow_mod->command );
+  uint16_t flags = ntohs( flow_mod->flags );
+  uint64_t cookie = ntohll( flow_mod->cookie );
+
+  switch ( command ) {
+  case OFPFC_ADD:
+  {
+    uint64_t *new_cookie = insert_cookie_entry( &cookie, service_name, flags );
+    if ( new_cookie == NULL ) {
+      return -1;
+    }
+    flow_mod->cookie = htonll( *new_cookie );
+    flow_mod->flags = htons( flags | OFPFF_SEND_FLOW_REM );
+  }
+  break;
+
+  case OFPFC_MODIFY:
+  case OFPFC_MODIFY_STRICT:
+  {
+    cookie_entry_t *entry = lookup_cookie_entry_by_application( &cookie, service_name );
+    if ( entry != NULL ) {
+      flow_mod->cookie = htonll( entry->cookie );
+    }
+    else {
+      uint64_t *new_cookie = insert_cookie_entry( &cookie, service_name, flags );
+      if ( new_cookie == NULL ) {
+        return -1;
+      }
+      flow_mod->cookie = htonll( *new_cookie );
+    }
+    flow_mod->flags = htons( flags | OFPFF_SEND_FLOW_REM );
+  }
+  break;
+
+  case OFPFC_DELETE:
+  case OFPFC_DELETE_STRICT:
+  {
+    cookie_entry_t *entry = lookup_cookie_entry_by_application( &cookie, service_name );
+    if ( entry != NULL ) {
+      flow_mod->cookie = htonll( entry->cookie );
+    }
+    else {
+      flow_mod->cookie = htonll( RESERVED_COOKIE );
+    }
+    flow_mod->flags = htons( flags | OFPFF_SEND_FLOW_REM );
+  }
+  break;
+
+  default:
+    return -1;
+  }
+
+  return 0;
+}
+
+
+int
+ofpmsg_send( struct switch_info *sw_info, buffer *buf, char *service_name ) {
+  int ret;
+  struct ofp_header *ofp_header;
+  uint32_t new_xid;
+
+  ofp_header = buf->data;
+
+  new_xid = insert_xid_entry( ntohl( ofp_header->xid ), service_name );
+  ofp_header->xid = htonl( new_xid );
+
+  if ( ofp_header->type == OFPT_FLOW_MOD ) {
+    ret = update_flowmod_cookie( buf, service_name );
+    if ( ret < 0 ) {
+      error( "Failed to update cookie value ( ret = %d ).", ret );
+      free_buffer( buf );
+      return ret;
+    }
+  }
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send an OpenFlow message %d to a switch %#" PRIx64 ".",
+      ofp_header->type, sw_info->datapath_id );
+  }
+
+  return ret;
+}
+
+
+int
+ofpmsg_send_delete_all_flows( struct switch_info *sw_info ) {
+  int ret;
+  struct ofp_match match;
+  buffer *buf;
+
+  memset( &match, 0, sizeof( match ) );
+  match.wildcards = OFPFW_ALL;
+
+  buf = create_flow_mod( generate_xid(), match, RESERVED_COOKIE,
+                         OFPFC_DELETE, 0, 0, 0, 0, OFPP_NONE, 0, NULL );
+
+  ret = send_to_secure_channel( sw_info, buf );
+  if ( ret == 0 ) {
+    debug( "Send 'flow mod (delete all)' to a switch %#" PRIx64 ".", sw_info->datapath_id );
+  }
+
+  return ret;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/switch_manager/ofpmsg_send.h

@@ -0,0 +1,50 @@
+/*
+ * OpenFlow Switch Manager
+ *
+ * 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 OFPMSG_SEND_H
+#define OFPMSG_SEND_H
+
+
+#include "trema.h"
+#include "switch.h"
+
+
+#define OFP_ERROR_MSG_MAX_DATA 64
+
+
+int ofpmsg_send_hello( struct switch_info *sw_info );
+int ofpmsg_send_echoreply( struct switch_info *sw_info, uint32_t xid, buffer *body );
+int ofpmsg_send_featuresrequest( struct switch_info *sw_info );
+int ofpmsg_send_setconfig( struct switch_info *sw_info );
+int ofpmsg_send_error_msg( struct switch_info *sw_info, uint16_t type, uint16_t code, buffer *data );
+int ofpmsg_send( struct switch_info *sw_info, buffer *buf, char *service_name );
+int ofpmsg_send_delete_all_flows( struct switch_info *sw_info );
+
+
+#endif // OFPMSG_SEND_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */
+

data/src/switch_manager/secure_channel_listener.c

@@ -0,0 +1,281 @@
+/*
+ * 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 <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "trema.h"
+#include "secure_channel_listener.h"
+#include "switch_manager.h"
+
+
+const int LISTEN_SOCK_MAX = 128;
+const int SWITCH_MANAGER_DEFAULT_ARGC = 10;
+
+#ifdef UNIT_TESTING
+#define static
+
+#ifdef close
+#undef close
+#endif
+#define close mock_close
+int mock_close( int fd );
+
+#ifdef socket
+#undef socket
+#endif
+#define socket mock_socket
+int mock_socket( int domain, int type, int protocol );
+
+#ifdef bind
+#undef bind
+#endif
+#define bind mock_bind
+int mock_bind( int sockfd, const struct sockaddr *addr, socklen_t addrlen );
+
+#ifdef listen
+#undef listen
+#endif
+#define listen mock_listen
+int mock_listen( int sockfd, int backlog );
+
+#ifdef accept
+#undef accept
+#endif
+#define accept mock_accept
+int mock_accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen );
+
+#ifdef setsockopt
+#undef setsockopt
+#endif
+#define setsockopt mock_setsockopt
+int mock_setsockopt( int sockfd, int level, int optname, const void *optval,
+  socklen_t optlen );
+
+#ifdef fork
+#undef fork
+#endif
+#define fork mock_fork
+pid_t mock_fork( void );
+
+#ifdef dup2
+#undef dup2
+#endif
+#define dup2 mock_dup2
+int mock_dup2( int oldfd, int newfd );
+
+#ifdef open
+#undef open
+#endif
+#define open mock_open
+int mock_open(const char *pathname, int flags);
+
+#ifdef execvp
+#undef execvp
+#endif
+#define execvp mock_execvp
+int mock_execvp( const char *file, char *const argv[] );
+
+#ifdef exit
+#undef exit
+#endif
+#define exit mock_exit
+void mock_exit( int status );
+
+#endif // UNIT_TESTING
+
+
+bool
+secure_channel_listen_start( struct listener_info *listener_info ) {
+  struct sockaddr_in addr;
+  int listen_fd;
+  int flag;
+  int ret;
+
+  if ( listener_info->listen_fd >= 0 ) {
+    close( listener_info->listen_fd );
+  }
+  listener_info->listen_fd = -1;
+
+  memset( &addr, 0, sizeof( struct sockaddr_in ) );
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons( listener_info->listen_port );
+  addr.sin_addr.s_addr = htonl( INADDR_ANY );
+
+  listen_fd = socket( PF_INET, SOCK_STREAM, 0 );
+  if ( listen_fd < 0 ) {
+    error( "Failed to create socket." );
+    return false;
+  }
+  flag = 1;
+
+  ret = setsockopt( listen_fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof( flag ) );
+  if ( ret < 0 ) {
+    warn( "Failed to set socket options." );
+  }
+
+  ret = setsockopt( listen_fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof( flag ) );
+  if ( ret < 0 ) {
+    warn( "Failed to set socket options." );
+  }
+
+  ret = bind( listen_fd, ( struct sockaddr * ) &addr, sizeof( struct sockaddr_in ) );
+  if ( ret < 0 ) {
+    error( "%s: Failed to bind socket.: %s(%d)",
+           inet_ntoa( addr.sin_addr ), strerror( errno ), errno );
+    close( listen_fd );
+    return false;
+  }
+
+  ret = listen( listen_fd, LISTEN_SOCK_MAX );
+  if ( ret < 0 ) {
+    error( "Failed to listen." );
+    close( listen_fd );
+    return false;
+  }
+
+  listener_info->listen_fd = listen_fd;
+
+  return true;
+}
+
+
+static char **
+make_switch_daemon_args( struct listener_info *listener_info, struct sockaddr_in *addr, int accept_fd ) {
+  int argc = SWITCH_MANAGER_DEFAULT_ARGC + listener_info->switch_daemon_argc + 1;
+  char **argv = xcalloc( ( size_t ) argc, sizeof( char * ) );
+  char *command_name = xasprintf( "%s%s:%u", SWITCH_MANAGER_COMMAND_PREFIX,
+                                  inet_ntoa( addr->sin_addr ),
+                                   ntohs( addr->sin_port ) );
+  char *service_name = xasprintf( "%s%s%s:%u", SWITCH_MANAGER_NAME_OPTION,
+                                  SWITCH_MANAGER_PREFIX,
+                                  inet_ntoa( addr->sin_addr ),
+                                  ntohs( addr->sin_port ) );
+  char *socket_opt = xasprintf( "%s%d", SWITCH_MANAGER_SOCKET_OPTION,
+                                accept_fd );
+  char *daemonize_opt = xstrdup( SWITCH_MANAGER_DAEMONIZE_OPTION );
+  char *notify_opt = xasprintf( "%s%s", SWITCH_MANAGER_STATE_PREFIX,
+                                get_trema_name() );
+
+  int i = 0;
+  argv[ i++ ] = command_name;
+  argv[ i++ ] = service_name;
+  argv[ i++ ] = socket_opt;
+  argv[ i++ ] = daemonize_opt;
+  argv[ i++ ] = notify_opt;
+  int j;
+  for ( j = 0; j < listener_info->switch_daemon_argc; i++, j++ ) {
+    argv[ i ] = xstrdup( listener_info->switch_daemon_argv[ j ] );
+  }
+
+  return argv;
+}
+
+
+static void
+free_switch_daemon_args( char **argv ) {
+  int i;
+  for ( i = 0; argv[ i ] != NULL; i++ ) {
+    free( argv[ i ] );
+  }
+  free( argv );
+}
+
+
+static const int ACCEPT_FD = 3;
+
+
+void
+secure_channel_accept( int fd, void *data ) {
+  struct listener_info *listener_info = data;
+  struct sockaddr_in addr;
+  socklen_t addr_len;
+  int accept_fd;
+  int pid;
+
+  addr_len = sizeof( struct sockaddr_in );
+  accept_fd = accept( fd, ( struct sockaddr * ) &addr, &addr_len );
+  if ( accept_fd < 0 ) {
+    // TODO: close listener socket
+    error( "Failed to accept from switch. :%s.", strerror( errno )  );
+    return;
+  }
+  pid = fork();
+  if ( pid < 0 ) {
+    error( "Failed to fork. %s.", strerror( errno ) );
+    close( accept_fd );
+    return;
+  }
+  if ( pid == 0 ) {
+    close( listener_info->listen_fd );
+    if ( accept_fd < ACCEPT_FD ) {
+      dup2( accept_fd, ACCEPT_FD );
+      close( accept_fd );
+      accept_fd = ACCEPT_FD;
+    }
+
+    char **argv = make_switch_daemon_args( listener_info, &addr, accept_fd );
+
+    int in_fd = open( "/dev/null", O_RDONLY );
+    if ( in_fd != 0 ) {
+      dup2( in_fd, 0 );
+      close( in_fd );
+    }
+    int out_fd = open( "/dev/null", O_WRONLY );
+    if ( out_fd != 1 ) {
+      dup2( out_fd, 1 );
+      close( out_fd );
+    }
+    int err_fd = open( "/dev/null", O_WRONLY );
+    if ( err_fd != 2 ) {
+      dup2( err_fd, 2 );
+      close( err_fd );
+    }
+
+    execvp( listener_info->switch_daemon, argv );
+    error( "Failed to execvp: %s(%s) %s %s. %s.",
+      argv[ 0 ], listener_info->switch_daemon,
+      argv[ 1 ], argv[ 2 ], strerror( errno ) );
+
+    free_switch_daemon_args( argv );
+
+    UNREACHABLE();
+  }
+  else {
+    /* parent */
+    close( accept_fd );
+  }
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */