trema 0.2.5 → 0.2.6

data/src/lib/management_interface.c

@@ -0,0 +1,361 @@
+/*
+ * Author: Yasunobu Chiba
+ *
+ * Copyright (C) 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 <string.h>
+#include "bool.h"
+#include "checks.h"
+#include "log.h"
+#include "management_interface.h"
+#include "management_service_interface.h"
+#include "trema.h" // FIXME: don't include trema.h here (move get_trema_name() to trema_private.c)
+#include "trema_private.h"
+#include "trema_wrapper.h"
+#include "wrapper.h"
+
+
+static bool initialized = false;
+static management_application_request_handler application_callback = NULL;
+static void *application_user_data = NULL;
+
+
+static void
+handle_echo_request( const messenger_context_handle *handle, management_echo_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL );
+  assert( ntohs( request->header.type ) == MANAGEMENT_ECHO_REQUEST );
+  assert( ntohl( request->header.length ) == sizeof( management_echo_request ) );
+
+  debug( "Handling an echo request from %s ( sent_at = %u.%09u ).",
+         handle->service_name, ntohl( request->sent_at.tv_sec ), ntohl( request->sent_at.tv_nsec ) );
+
+  bool ret = true;
+  management_echo_reply reply;
+  memset( &reply, 0, sizeof( management_echo_reply ) );
+  reply.header.type = htons( MANAGEMENT_ECHO_REPLY );
+  reply.header.length = htonl( sizeof( management_echo_reply ) );
+  reply.sent_at = request->sent_at;
+
+  struct timespec now = { 0, 0 };
+  int retval = clock_gettime( CLOCK_REALTIME, &now );
+  if ( retval < 0 ) {
+    error( "Failed to retrieve clock." );
+    ret = false;
+  }
+  reply.received_at.tv_sec = htonl( ( uint32_t ) now.tv_sec );
+  reply.received_at.tv_nsec = htonl( ( uint32_t ) now.tv_nsec );
+  reply.header.status = ( uint8_t ) ( ret == true ? MANAGEMENT_REQUEST_SUCCEEDED : MANAGEMENT_REQUEST_FAILED );
+
+  ret = send_reply_message( handle, MESSENGER_MANAGEMENT_REPLY, &reply, sizeof( management_echo_reply ) );
+  if ( ret == false ) {
+    error( "Failed to send an echo reply." );
+  }
+}
+
+
+static void
+handle_set_logging_level_request( const messenger_context_handle *handle, management_set_logging_level_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL );
+  assert( ntohs( request->header.type ) == MANAGEMENT_SET_LOGGING_LEVEL_REQUEST );
+  assert( ntohl( request->header.length ) == sizeof( management_set_logging_level_request ) );
+
+  request->level[ LOGGING_LEVEL_STR_LENGTH - 1 ] = '\0';
+
+  debug( "Handling a set logging level request from %s ( level = %s ).", handle->service_name, request->level );
+
+  management_set_logging_level_reply reply;
+  memset( &reply, 0, sizeof( management_set_logging_level_reply ) );
+  reply.header.type = htons( MANAGEMENT_SET_LOGGING_LEVEL_REPLY );
+  reply.header.length = htonl( sizeof( management_set_logging_level_reply ) );
+
+  bool ret = valid_logging_level( request->level );
+  if ( ret ) {
+    ret = set_logging_level( request->level );
+  }
+
+  if ( ret ) {
+    reply.header.status = MANAGEMENT_REQUEST_SUCCEEDED;
+  }
+  else {
+    reply.header.status = MANAGEMENT_REQUEST_FAILED;
+  }
+
+  ret = send_reply_message( handle, MESSENGER_MANAGEMENT_REPLY, &reply, sizeof( management_set_logging_level_reply ) );
+  if ( ret == false ) {
+    error( "Failed to send a set logging level reply." );
+  }
+}
+
+
+static void
+append_stat( const char *key, const uint64_t value, void *user_data ) {
+  assert( key != NULL );
+  assert( user_data != NULL );
+
+  list_element **stats = user_data;
+
+  stat_entry *entry = xmalloc( sizeof( stat_entry ) );
+  memset( entry, 0, sizeof( stat_entry ) );
+  memcpy( entry->key, key, sizeof( entry->key ) );
+  entry->value = htonll( value );
+
+  append_to_tail( stats, entry );
+}
+
+
+static void
+handle_show_stats_request( const messenger_context_handle *handle, management_show_stats_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL );
+  assert( ntohs( request->header.type ) == MANAGEMENT_SHOW_STATS_REQUEST );
+  assert( ntohl( request->header.length ) == sizeof( management_show_stats_request ) );
+
+  debug( "Handling a show stats request from %s.", handle->service_name );
+
+  list_element *stats = NULL;
+  create_list( &stats );
+  foreach_stat( append_stat, &stats );
+  unsigned int n_stats = list_length_of( stats );
+
+  const size_t send_queue_length = 400000; // MESSENGER_RECV_BUFFER * 4
+  const size_t send_queue_margin = 256; // headroom for various headers
+  unsigned int n_max_entries = ( unsigned int ) ( send_queue_length - send_queue_margin ) / sizeof( stat_entry );
+
+  management_show_stats_reply *reply = NULL;
+  size_t length = 0;
+
+  if ( n_stats <= n_max_entries ) {
+    length = offsetof( management_show_stats_reply, entries ) + sizeof( stat_entry ) * n_stats;
+    reply = xmalloc( length );
+    memset( reply, 0, length );
+    reply->header.type = htons( MANAGEMENT_SHOW_STATS_REPLY );
+    reply->header.length = htonl( ( uint32_t ) length );
+    reply->header.status = MANAGEMENT_REQUEST_SUCCEEDED;
+
+    stat_entry *p = reply->entries;
+    for ( list_element *e = stats; e != NULL; e = e->next ) {
+      assert( e->data != NULL );
+      memcpy( p, e->data, sizeof( stat_entry ) );
+      p++;
+    }
+  }
+  else {
+    // TODO: Send statistics via out-of-band channel or by multiple replies.
+
+    error( "Too many statistic entries ( %u > %u ).", n_stats, n_max_entries );
+
+    length = offsetof( management_show_stats_reply, entries );
+    reply = xmalloc( length );
+    memset( reply, 0, length );
+    reply->header.type = htons( MANAGEMENT_SHOW_STATS_REPLY );
+    reply->header.length = htonl( ( uint32_t ) length );
+    reply->header.status = MANAGEMENT_REQUEST_FAILED;
+  }
+
+  if ( stats != NULL ) {
+    for ( list_element *e = stats; e != NULL; e = e->next ) {
+      assert( e->data != NULL );
+      xfree( e->data );
+    }
+    delete_list( stats );
+  }
+
+  bool ret = send_reply_message( handle, MESSENGER_MANAGEMENT_REPLY, reply, length );
+  if ( ret == false ) {
+    error( "Failed to send a show stats reply." );
+  }
+  xfree( reply );
+}
+
+
+void
+_set_management_application_request_handler( management_application_request_handler callback, void *user_data ) {
+  application_callback = callback;
+  application_user_data = user_data;
+}
+
+
+static void
+handle_application_request( const messenger_context_handle *handle, management_application_request *request ) {
+  assert( handle != NULL );
+  assert( request != NULL );
+  assert( ntohs( request->header.type ) == MANAGEMENT_APPLICATION_REQUEST );
+  assert( ntohl( request->header.length ) >= offsetof( management_application_request, data ) );
+
+  debug( "Handling an application specific management request from %s ( application_id = %#x ).",
+         handle->service_name, request->application_id );
+
+  if ( application_callback != NULL ) {
+    size_t length = ( size_t ) ntohl( request->header.length ) - offsetof( management_application_request, data );
+    void *data = NULL;
+    if ( length > 0 ) {
+      data = request->data;
+    }
+    application_callback( handle, ntohl( request->application_id ), data, length, application_user_data );
+  }
+  else {
+    management_application_reply *reply = create_management_application_reply( MANAGEMENT_REQUEST_FAILED,
+                                                                               ntohl( request->application_id ), NULL, 0 );
+    send_management_application_reply( handle, reply );
+    xfree( reply );
+  }
+}
+
+
+static void
+handle_management_request( const messenger_context_handle *handle, void *data, size_t length ) {
+  assert( handle != NULL );
+  assert( data != NULL );
+  assert( length >= sizeof( management_request_header ) );
+
+  management_request_header *header = data;
+
+  assert( length == ( size_t ) ntohl( header->length ) );
+
+  switch ( ntohs( header->type ) ) {
+    case MANAGEMENT_ECHO_REQUEST:
+    {
+      if ( length != sizeof( management_echo_request ) ) {
+        error( "Invalid echo request ( length = %zu ).", length );
+        return;
+      }
+
+      handle_echo_request( handle, data );
+    }
+    break;
+
+    case MANAGEMENT_SET_LOGGING_LEVEL_REQUEST:
+    {
+      if ( length != sizeof( management_set_logging_level_request ) ) {
+        error( "Invalid set logging level request ( length = %zu ).", length );
+        return;
+      }
+
+      handle_set_logging_level_request( handle, data );
+    }
+    break;
+
+    case MANAGEMENT_SHOW_STATS_REQUEST:
+    {
+      if ( length != sizeof( management_show_stats_request ) ) {
+        error( "Invalid show stats request ( length = %zu ).", length );
+        return;
+      }
+
+      handle_show_stats_request( handle, data );
+    }
+    break;
+
+    case MANAGEMENT_APPLICATION_REQUEST:
+    {
+      if ( length < offsetof( management_application_request, data ) ) {
+        error( "Invalid application specific management request ( length = %zu ).", length );
+        return;
+      }
+
+      handle_application_request( handle, data );
+    }
+    break;
+
+    default:
+    {
+      error( "Undefined management request type ( type = %#x ).", header->type );
+    }
+    break;
+  }
+}
+
+
+static void
+handle_request( const messenger_context_handle *handle, uint16_t tag, void *data, size_t length ) {
+  assert( handle != NULL );
+
+  debug( "Handling a request ( handle = %p, tag = %#x, data = %p, length = %zu ).",
+         handle, tag, data, length );
+
+  switch ( tag ) {
+    case MESSENGER_MANAGEMENT_REQUEST:
+    {
+      if ( length < sizeof( management_request_header ) ) {
+        error( "Invalid management request. Too short message ( length = %zu ).", length );
+        return;
+      }
+
+      handle_management_request( handle, data, length );
+    }
+    break;
+
+    default:
+    {
+      warn( "Undefined request tag ( tag = %#x ).", tag );
+    }
+    break;
+  }
+}
+
+
+bool
+init_management_interface() {
+  if ( initialized ) {
+    error( "Management interface is already initialized." );
+    return false;
+  }
+
+  add_message_requested_callback( get_management_service_name( get_trema_name() ), handle_request );
+
+  initialized = true;
+
+  debug( "Management interface is initialized ( trema_name = %s, service_name = %s ).",
+         get_trema_name(), get_management_service_name( get_trema_name() ) );
+
+  return true;
+}
+
+
+bool
+finalize_management_interface() {
+  if ( !initialized ) {
+    error( "Management interface is not initialized yet or already finalized." );
+    return false;
+  }
+
+  delete_message_requested_callback( get_management_service_name( get_trema_name() ), handle_request );
+
+  initialized = false;
+
+  debug( "Management interface is finalized ( trema_name = %s ).", get_trema_name() );
+
+  return true;
+}
+
+
+bool *
+_get_management_interface_initialized() {
+  return &initialized;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/management_interface.h

@@ -0,0 +1,42 @@
+/*
+ * A management interface library
+ *
+ * Author: Yasunobu Chiba
+ *
+ * Copyright (C) 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 MANAGEMENT_INTERFACE_H
+#define MANAGEMENT_INTERFACE_H
+
+
+#include "bool.h"
+
+
+bool init_management_interface();
+bool finalize_management_interface();
+
+
+#endif // MANAGEMENT_INTERFACE_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/management_service_interface.c

@@ -0,0 +1,104 @@
+/*
+ * Author: Yasunobu Chiba
+ *
+ * Copyright (C) 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 <assert.h>
+#include <string.h>
+#include "bool.h"
+#include "checks.h"
+#include "log.h"
+#include "management_service_interface.h"
+#include "messenger.h"
+#include "trema_private.h"
+#include "trema_wrapper.h"
+#include "utility.h"
+#include "wrapper.h"
+
+
+static char management_service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+
+
+static const char *
+_get_management_service_name( const char *service_name ) {
+  if ( service_name == NULL ) {
+    die( "Service name must not be NULL." );
+  }
+  if ( strlen( service_name ) == 0 ) {
+    die( "Service name length must not be zero." );
+  }
+  if ( strlen( service_name ) >= ( MESSENGER_SERVICE_NAME_LENGTH - 2 ) ) {
+    die( "Too long service name ( %s ).", service_name );
+  }
+
+  memset( management_service_name, '\0', MESSENGER_SERVICE_NAME_LENGTH );
+  snprintf( management_service_name, MESSENGER_SERVICE_NAME_LENGTH, "%s.m", service_name );
+
+  return management_service_name;
+}
+const char *( *get_management_service_name )( const char *service_name ) = _get_management_service_name;
+
+
+management_application_reply *
+_create_management_application_reply( uint8_t status, uint32_t application_id, void *data, size_t data_length ) {
+  size_t length = offsetof( management_application_reply, data );
+  if ( data != NULL ) {
+    length += data_length;
+  }
+  management_application_reply *reply = xmalloc( length );
+  memset( reply, 0, length );
+  reply->header.type = htons( MANAGEMENT_APPLICATION_REPLY );
+  reply->header.status = status;
+  reply->header.length = htonl( ( uint32_t ) length );
+  reply->application_id = htonl( application_id );
+  if ( data != NULL ) {
+    memcpy( reply->data, data, data_length );
+  }
+
+  return reply;
+}
+management_application_reply *( *create_management_application_reply )( uint8_t status, uint32_t application_id, void *data, size_t data_length ) = _create_management_application_reply;
+
+
+bool
+_send_management_application_reply( const messenger_context_handle *handle, const management_application_reply *reply ) {
+  if ( handle == NULL || reply == NULL ) {
+    error( "Both context handle and reply message must not be NULL ( handle = %p, reply = %p ).", handle, reply );
+    return false;
+  }
+  bool ret = send_reply_message( handle, MESSENGER_MANAGEMENT_REPLY, reply, ( size_t ) ntohl( reply->header.length ) );
+  if ( !ret ) {
+    error( "Failed to send an application specific management reply." );
+    return false;
+  }
+
+  return true;
+}
+bool ( *send_management_application_reply )( const messenger_context_handle *handle, const management_application_reply *reply ) = _send_management_application_reply;
+
+
+void ( *set_management_application_request_handler )( management_application_request_handler callback, void *user_data ) = _set_management_application_request_handler;
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */