trema 0.1.3

data/src/tremashark/plugin/packet-trema/plugin.c

@@ -0,0 +1,31 @@
+/*
+ * Do not modify this file.
+ *
+ * It is created automatically by Makefile or Makefile.nmake.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <gmodule.h>
+
+#include "moduleinfo.h"
+
+#ifndef ENABLE_STATIC
+G_MODULE_EXPORT const gchar version[] = VERSION;
+
+/* Start the functions we need for the plugin stuff */
+
+G_MODULE_EXPORT void
+plugin_register (void)
+{
+  {extern void proto_register_trema (void); proto_register_trema ();}
+}
+
+G_MODULE_EXPORT void
+plugin_reg_handoff(void)
+{
+  {extern void proto_reg_handoff_trema (void); proto_reg_handoff_trema ();}
+}
+#endif

data/src/tremashark/plugin/user_dlts

@@ -0,0 +1,2 @@
+# This file is automatically generated, DO NOT MODIFY.
+"User 0 (DLT=147)","trema","0","","0",""

data/src/tremashark/queue.c

@@ -0,0 +1,168 @@
+/*
+ * Author: Yasunobu Chiba
+ *
+ * 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 "queue.h"
+
+
+queue *
+create_queue( void ) {
+  queue *new_queue = xmalloc( sizeof( queue ) );
+  new_queue->head = xmalloc( sizeof( queue_element ) );
+  new_queue->head->data = NULL;
+  new_queue->head->next = NULL;
+  new_queue->divider = new_queue->tail = new_queue->head;
+  new_queue->length = 0;
+
+  return new_queue;
+}
+
+
+bool
+delete_queue( queue *queue ) {
+  assert( queue != NULL );
+
+  while( queue->head != NULL ) {
+    queue_element *e = queue->head;
+    if ( queue->head->data != NULL ) {
+      free_buffer( queue->head->data );
+    }
+    queue->head = queue->head->next;
+    xfree( e );
+  }
+  xfree( queue );
+
+  return true;
+}
+
+
+static void
+collect_garbage( queue *queue ) {
+  while ( queue->head != queue->divider ) {
+    queue_element *e = queue->head;
+    queue->head = queue->head->next;
+    xfree( e );
+  }
+}
+
+
+bool
+enqueue( queue *queue, buffer *data ) {
+  assert( queue != NULL );
+  assert( data != NULL );
+  assert( data->length > 0 );
+
+  queue_element *new_tail = xmalloc( sizeof( queue_element ) );
+  new_tail->data = data;
+  new_tail->next = NULL;
+
+  queue->tail->next = new_tail;
+  queue->tail = new_tail;
+  queue->length++;
+
+  collect_garbage( queue );
+
+  return true;
+}
+
+
+buffer *
+dequeue( queue *queue ) {
+  assert( queue != NULL );
+
+  if ( queue->divider != queue->tail ) {
+    queue_element *next = queue->divider->next;
+    buffer *data = next->data;
+    next->data = NULL; // data must be freed by caller
+    queue->divider = next;
+    queue->length--;
+
+    return data;
+  }
+
+  return NULL;
+}
+
+
+buffer *
+peek( queue *queue ) {
+  assert( queue != NULL );
+
+  if ( queue->divider != queue->tail ) {
+    return queue->divider->next->data;
+  }
+
+  return NULL;
+}
+
+
+bool
+sort_queue( queue *queue, bool compare( const buffer *x, const buffer *y ) ) {
+  assert( queue != NULL );
+
+  collect_garbage( queue );
+
+  const int length = queue->length;
+  queue_element *elements[ length ];
+
+  int i = 0;
+  queue_element *element = queue->head;
+  while ( element->next != NULL ) {
+    elements[ i ] = element->next;
+    element = element->next;
+    i++;
+  }
+
+  int j = 0;
+  buffer *data;
+  for ( int i = 1; i < length; i++ ) {
+    data = elements[ i ]->data;
+    if ( compare( elements[ i - 1 ]->data, data ) ) {
+      j = i;
+      do {
+        elements[ j ]->data = elements[ j - 1 ]->data;
+        j--;
+      } while ( j > 0 && compare( elements[ j - 1 ]->data, data ) );
+      elements[ j ]->data = data;
+    }
+  }
+
+  return true;
+}
+
+
+void
+foreach_queue( queue *queue, void function( buffer *data ) ) {
+  assert( queue != NULL );
+
+  queue_element *e = queue->divider;
+  while ( e != queue->tail ) {
+    function( e->next->data );
+    e = e->next;
+  }
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/tremashark/queue.h

@@ -0,0 +1,60 @@
+/*
+ * Queue implementation.
+ *
+ * Author: Yasunobu Chiba
+ *
+ * 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 QUEUE_H
+#define QUEUE_H
+
+
+#include "trema.h"
+
+
+typedef struct queue_element {
+  buffer *data;
+  struct queue_element *next;
+} queue_element;
+
+typedef struct queue {
+  queue_element *head;
+  queue_element *divider;
+  queue_element *tail;
+  int length;
+} queue;
+
+
+queue *create_queue( void );
+bool delete_queue( queue *queue );
+bool enqueue( queue *queue, buffer *data );
+buffer *dequeue( queue *queue );
+buffer *peek( queue *queue );
+bool sort_queue( queue *queue, bool compare( const buffer *x, const buffer *y ) );
+void foreach_queue( queue *queue, void function( buffer *data ) );
+
+
+#endif // QUEUE_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/tremashark/stdin_relay.c

@@ -0,0 +1,257 @@
+/*
+ * stdin_relay: An application that relays text string from stdin to tremashark
+ * 
+ * Author: Yasunobu Chiba
+ *
+ * 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 <getopt.h>
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+#include "trema.h"
+
+
+static char *dump_service_name = NULL;
+static buffer *stdin_read_buffer = NULL;
+
+
+static void
+relay_string( buffer *string ) {
+  // retrieve current time
+  struct timespec now;
+  if ( clock_gettime( CLOCK_REALTIME, &now ) == -1 ) {
+    error( "Failed to retrieve system-wide real-time clock ( %s [%d] ).", strerror( errno ), errno );
+    return;
+  }
+
+  // allocate buffer
+  char *service_name = xstrdup( get_trema_name() );
+  uint16_t service_name_length = ( uint16_t ) ( strlen( service_name ) + 1 );
+  size_t buffer_length = sizeof( message_dump_header ) + service_name_length + sizeof( syslog_dump_header ) + string->length + 1;
+  buffer *buf = alloc_buffer_with_length( buffer_length );
+
+  // syslog_dump_header + service_name
+  message_dump_header *mdh = append_back_buffer( buf, sizeof( message_dump_header ) );
+  mdh->sent_time.sec = htonl( ( uint32_t ) now.tv_sec );
+  mdh->sent_time.nsec = htonl( ( uint32_t ) now.tv_nsec );
+  mdh->app_name_length = htons( 0 );
+  mdh->service_name_length = htons( service_name_length );
+  mdh->data_length = htonl( ( uint32_t ) ( sizeof( text_dump_header ) + string->length + 1 ) );
+  void *svn = append_back_buffer( buf, service_name_length );
+  memcpy( svn, service_name, service_name_length );
+  xfree( service_name );
+
+  // text_dump_header
+  text_dump_header *tdh = append_back_buffer( buf, sizeof( text_dump_header ) );
+  tdh->sent_time.sec = htonl( ( uint32_t ) now.tv_sec );
+  tdh->sent_time.nsec = htonl( ( uint32_t ) now.tv_nsec );
+
+  // message
+  void *p = append_back_buffer( buf, string->length + 1 );
+  memset( p, '\0', string->length + 1 );
+  memcpy( p, string->data, string->length );
+
+  bool ret = send_message( dump_service_name, MESSENGER_DUMP_TEXT, buf->data, buf->length );
+  if ( !ret ) {
+    error( "Failed to relay syslog message." );
+  }
+  free_buffer( buf );
+}
+
+
+static char *
+find_character( char *string, size_t length, char character ) {
+  assert( string != NULL );
+
+  for ( size_t i = 0; i < length; i++ ) {
+    if ( string[ i ] == character ) {
+      return &( string[ i ] );
+    }
+  }
+
+  return NULL;
+}
+
+
+static void
+read_stdin( int fd, void *data ) {
+  UNUSED( data );
+
+  char buf[ 1024 ];
+  memset( buf, '\0', sizeof( buf ) );
+  ssize_t ret = read( fd, buf, sizeof( buf ) );
+  if ( ret < 0 ) {
+    if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
+      return;
+    }
+
+    set_readable( fd, false );
+
+    error( "Read error ( errno = %s [%d] ).", strerror( errno ), errno );
+    return;
+  }
+  else if ( ret == 0 ) {
+    return;
+  }
+
+  if ( stdin_read_buffer == NULL ) {
+    set_readable( fd, false );
+
+    error( "Read buffer is not allocated yet" );
+    return;
+  }
+
+  char *p = append_back_buffer( stdin_read_buffer, ( size_t ) ret );
+  memcpy( p, buf, ( size_t ) ret );
+  char *lf = find_character( stdin_read_buffer->data, stdin_read_buffer->length, '\n' );
+  while ( lf != NULL ) {
+    size_t length = ( size_t ) ( lf - ( char * ) stdin_read_buffer->data );
+    if ( length > 0 ) {
+      buffer *string = alloc_buffer_with_length( length );
+      p = append_back_buffer( string, length );
+      memcpy( p, stdin_read_buffer->data, length );
+      relay_string( string );
+      free_buffer( string );
+      remove_front_buffer( stdin_read_buffer, length + 1 );
+    }
+    else {
+      if ( stdin_read_buffer->length > 0 ) {
+        remove_front_buffer( stdin_read_buffer, 1 );
+      }
+    }
+    if ( stdin_read_buffer->length == 0 ) {
+      break;
+    }
+    lf = find_character( stdin_read_buffer->data, stdin_read_buffer->length, '\n' );
+  }
+
+  // truncate head room manually
+  buffer *truncated = duplicate_buffer( stdin_read_buffer );
+  free_buffer( stdin_read_buffer );
+  stdin_read_buffer = truncated;
+}
+
+
+void
+usage( void ) {
+  printf(
+    "Usage: stdin_relay [OPTION]...\n"
+    "\n"
+    "  -s DUMP_SERVICE_NAME        dump service name\n"
+    "  -n, --name=SERVICE_NAME     service name\n"
+    "  -l, --logging_level=LEVEL   set logging level\n"
+    "  -h, --help                  display this help and exit\n"
+  );
+}
+
+
+static void
+print_usage_and_exit( void ) {
+  usage();
+  exit( EXIT_FAILURE );
+}
+
+
+static void
+parse_options( int *argc, char **argv[] ) {
+  int opt;
+
+  while( 1 ) {
+    opt = getopt( *argc, *argv, "s:" );
+
+    if( opt < 0 ){
+      break;
+    }
+
+    switch ( opt ){
+      case 's':
+        if ( optarg && dump_service_name == NULL ) {
+          dump_service_name = xstrdup( optarg );
+        }
+        else {
+          print_usage_and_exit();
+        }
+        break;
+
+      default:
+        print_usage_and_exit();
+    }
+  }
+
+  if ( dump_service_name == NULL ) {
+    dump_service_name = xstrdup( DEFAULT_DUMP_SERVICE_NAME );
+  }
+}
+
+
+static bool
+init_stdin_relay( int *argc, char **argv[] ) {
+  parse_options( argc, argv );
+
+  stdin_read_buffer = alloc_buffer_with_length( 1024 );
+
+  set_fd_handler( STDIN_FILENO, read_stdin, NULL, NULL, NULL );
+  set_readable( STDIN_FILENO, true );
+
+  return true;
+}
+
+
+static bool
+finalize_stdin_relay( void ) {
+  set_readable( STDIN_FILENO, false );
+  delete_fd_handler( STDIN_FILENO );
+
+  if ( dump_service_name != NULL ) {
+    xfree( dump_service_name );
+    dump_service_name = NULL;
+  }
+  if ( stdin_read_buffer != NULL ) {
+    free_buffer( stdin_read_buffer );
+    stdin_read_buffer = NULL;
+  }
+
+  return true;
+}
+
+
+int
+main( int argc, char *argv[] ) {
+  // Initialize the Trema world
+  init_trema( &argc, &argv );
+  init_stdin_relay( &argc, &argv );
+
+  // Main loop
+  start_trema();
+
+  // Cleanup
+  finalize_stdin_relay();
+
+  return 0;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */