trema 0.1.3

data/src/examples/traffic_monitor/traffic_monitor.conf

@@ -0,0 +1,16 @@
+vswitch {
+  datapath_id "0xabc"
+}
+
+vhost ("host1") {
+  ip "192.168.0.1"
+  mac "00:00:00:00:00:01"
+}
+
+vhost ("host2") {
+  ip "192.168.0.2"
+  mac "00:00:00:00:00:02"
+}
+
+link "0xabc", "host1"
+link "0xabc", "host2"

data/src/lib/arp.h

@@ -0,0 +1,61 @@
+/*
+ * ARP header definitions
+ *
+ * Author: Kazuya Suzuki
+ *
+ * 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 ARP_H
+#define ARP_H
+
+
+#include <net/if_arp.h>
+#include <stdint.h>
+#include "buffer.h"
+#include "ether.h"
+
+
+/**
+ * ARP Header Specification
+ * For protocol details, please refer RFC 826 at http://tools.ietf.org/html/rfc826
+ *
+ * TODO: Move the following type definition into packet_info.h and
+ *       remove this file.
+ */
+typedef struct arp_header {
+  uint16_t ar_hrd;
+  uint16_t ar_pro;
+  uint8_t ar_hln;
+  uint8_t ar_pln;
+  uint16_t ar_op;
+  uint8_t sha[ ETH_ADDRLEN ];
+  uint32_t sip;
+  uint8_t tha[ ETH_ADDRLEN ];
+  uint32_t tip;
+} __attribute__((packed)) arp_header_t;
+
+
+#endif // ARP_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/bool.h

@@ -0,0 +1,49 @@
+/*
+ * bool type definition.
+ *
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>
+ *
+ * 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 BOOL_H
+#define BOOL_H
+
+
+#ifdef __cplusplus
+// use C++ built-in bool type
+#elif defined __STDC__ && defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+// have a C99 compiler
+#include <stdbool.h>
+#else
+// do not have a C99 compiler
+typedef enum bool {
+  false = 0,
+  true,
+} bool;
+#endif
+
+
+#endif // BOOL_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/buffer.c

@@ -0,0 +1,305 @@
+/*
+ * Author: Shin-ya Zenke
+ *
+ * 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 <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "buffer.h"
+#include "checks.h"
+#include "utility.h"
+#include "wrapper.h"
+
+
+typedef struct {
+  buffer public;
+  size_t real_length;
+  void *top;
+  pthread_mutex_t *mutex;
+} private_buffer;
+
+
+static size_t
+front_length_of( const private_buffer *pbuf ) {
+  assert( pbuf != NULL );
+
+  return ( size_t ) ( ( char * ) pbuf->public.data - ( char * ) pbuf->top );
+}
+
+
+static bool
+already_allocated( private_buffer *pbuf, size_t length ) {
+  assert( pbuf != NULL );
+
+  size_t required_length = ( size_t ) front_length_of( pbuf ) + pbuf->public.length + length;
+
+  return ( pbuf->real_length >= required_length );
+}
+
+
+static private_buffer *
+alloc_new_data( private_buffer *pbuf, size_t length ) {
+  assert( pbuf != NULL );
+
+  pbuf->public.data = xmalloc( length );
+  pbuf->public.length = length;
+  pbuf->top = pbuf->public.data;
+  pbuf->real_length = length;
+
+  return pbuf;
+}
+
+
+static private_buffer *
+alloc_private_buffer() {
+  private_buffer *new_buf = xcalloc( 1, sizeof( private_buffer ) );
+
+  new_buf->public.data = NULL;
+  new_buf->public.length = 0;
+  new_buf->public.user_data = NULL;
+  new_buf->public.user_data_free_function = NULL;
+  new_buf->top = NULL;
+  new_buf->real_length = 0;
+
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init( &attr );
+  pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
+  new_buf->mutex = xmalloc( sizeof( pthread_mutex_t ) );
+  pthread_mutex_init( new_buf->mutex, &attr );
+
+  return new_buf;
+}
+
+
+static private_buffer *
+append_front( private_buffer *pbuf, size_t length ) {
+  assert( pbuf != NULL );
+
+  size_t new_length = front_length_of( pbuf ) + pbuf->public.length + length;
+  void *new_data = xmalloc( new_length );
+  memcpy( ( char * ) new_data + front_length_of( pbuf ) + length, pbuf->public.data, pbuf->public.length );
+  xfree( pbuf->top );
+
+  pbuf->public.data = ( char * ) new_data + front_length_of( pbuf );
+  pbuf->real_length = new_length;
+  pbuf->top = new_data;
+
+  return pbuf;
+}
+
+
+static private_buffer *
+append_back( private_buffer *pbuf, size_t length ) {
+  assert( pbuf != NULL );
+
+  size_t new_length = front_length_of( pbuf ) + pbuf->public.length + length;
+  void *new_data = xmalloc( new_length );
+  memcpy( ( char * ) new_data + front_length_of( pbuf ), pbuf->public.data, pbuf->public.length );
+  xfree( pbuf->top );
+
+  pbuf->public.data = ( char * ) new_data + front_length_of( pbuf );
+  pbuf->real_length = new_length;
+  pbuf->top = new_data;
+
+  return pbuf;
+}
+
+
+buffer *
+alloc_buffer() {
+  return ( buffer * ) alloc_private_buffer();
+}
+
+
+buffer *
+alloc_buffer_with_length( size_t length ) {
+  assert( length != 0 );
+
+  private_buffer *new_buf = xcalloc( 1, sizeof( private_buffer ) );
+  new_buf->public.data = xmalloc( length );
+  new_buf->public.length = 0;
+  new_buf->public.user_data = NULL;
+  new_buf->public.user_data_free_function = NULL;
+  new_buf->top = new_buf->public.data;
+  new_buf->real_length = length;
+
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init( &attr );
+  pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
+  new_buf->mutex = xmalloc( sizeof( pthread_mutex_t ) );
+  pthread_mutex_init( new_buf->mutex, &attr );
+
+  return ( buffer * ) new_buf;
+}
+
+
+void
+free_buffer( buffer *buf ) {
+  assert( buf != NULL );
+
+  if ( buf->user_data != NULL && buf->user_data_free_function != NULL ) {
+    ( *buf->user_data_free_function )( buf );
+    assert( buf->user_data == NULL );
+    assert( buf->user_data_free_function == NULL );
+  }
+  pthread_mutex_lock( ( ( private_buffer * ) buf )->mutex );
+  private_buffer *delete_me = ( private_buffer * ) buf;
+  if ( delete_me->top != NULL ) {
+    xfree( delete_me->top );
+  }
+  pthread_mutex_unlock( delete_me->mutex );
+  pthread_mutex_destroy( delete_me->mutex );
+  xfree( delete_me->mutex );
+  xfree( delete_me );
+}
+
+
+void *
+append_front_buffer( buffer *buf, size_t length ) {
+  assert( buf != NULL );
+  assert( length != 0 );
+
+  pthread_mutex_lock( ( ( private_buffer * ) buf )->mutex );
+
+  private_buffer *pbuf = ( private_buffer * ) buf;
+
+  if ( pbuf->top == NULL ) {
+    alloc_new_data( pbuf, length );
+    pthread_mutex_unlock( pbuf->mutex );
+    return pbuf->public.data;
+  }
+
+  buffer *b = &( pbuf->public );
+  if ( already_allocated( pbuf, length ) ) {
+    memmove( ( char * ) b->data + length, b->data, b->length );
+    memset( b->data, 0, length );
+  } else {
+    append_front( pbuf, length );
+  }
+  b->length += length;
+
+  pthread_mutex_unlock( pbuf->mutex );
+
+  return b->data;
+}
+
+
+void *
+remove_front_buffer( buffer *buf, size_t length ) {
+  assert( buf != NULL );
+  assert( length != 0 );
+
+  pthread_mutex_lock( ( ( private_buffer * ) buf )->mutex );
+
+  private_buffer *pbuf = ( private_buffer * ) buf;
+  assert( pbuf->public.length >= length );
+
+  pbuf->public.data = ( char * ) pbuf->public.data + length;
+  pbuf->public.length -= length;
+
+  pthread_mutex_unlock( pbuf->mutex );
+
+  return pbuf->public.data;
+}
+
+
+void *
+append_back_buffer( buffer *buf, size_t length ) {
+  assert( buf != NULL );
+  assert( length != 0 );
+
+  pthread_mutex_lock( ( ( private_buffer * ) buf )->mutex );
+
+  private_buffer *pbuf = ( private_buffer * ) buf;
+
+  if ( pbuf->real_length == 0 ) {
+    alloc_new_data( pbuf, length );
+    pthread_mutex_unlock( pbuf->mutex );
+    return ( char * ) pbuf->public.data;
+  }
+ 
+  if ( !already_allocated( pbuf, length ) ) {
+    append_back( pbuf, length );
+  }
+
+  void *appended = ( char * ) pbuf->public.data + pbuf->public.length;
+  pbuf->public.length += length;
+
+  pthread_mutex_unlock( pbuf->mutex );
+
+  return appended;
+}
+
+
+buffer *
+duplicate_buffer( const buffer *buf ) {
+  assert( buf != NULL );
+
+  pthread_mutex_lock( ( ( const private_buffer * ) buf )->mutex );
+
+  private_buffer *new_buffer = alloc_private_buffer();
+  const private_buffer *old_buffer = ( const private_buffer * ) buf;
+
+  if ( old_buffer->real_length == 0 ) {
+    pthread_mutex_unlock( old_buffer->mutex );
+    return ( buffer * ) new_buffer;
+  }
+
+  alloc_new_data( new_buffer, old_buffer->real_length );
+  memcpy( new_buffer->top, old_buffer->top, old_buffer->real_length );
+
+  new_buffer->public.length = old_buffer->public.length;
+  new_buffer->public.user_data = old_buffer->public.user_data;
+  new_buffer->public.user_data_free_function = NULL;
+  new_buffer->public.data = ( char * ) ( new_buffer->public.data ) + front_length_of( old_buffer );
+
+  pthread_mutex_unlock( old_buffer->mutex );
+
+  return ( buffer * ) new_buffer;
+}
+
+
+void
+dump_buffer( const buffer *buf, void dump_function( const char *format, ... ) ) {
+  assert( dump_function != NULL );
+
+  pthread_mutex_lock( ( ( const private_buffer * ) buf )->mutex );
+
+  char *hex = xmalloc( sizeof( char ) * ( buf->length * 2 + 1 ) );
+  char *datap = buf->data;
+  char *hexp = hex;
+  for ( unsigned int i = 0; i < buf->length; i++, datap++, hexp += 2 ) {
+    snprintf( hexp, 3, "%02x", *datap );
+  }
+  ( *dump_function )( "%s", hex );
+
+  xfree( hex );
+
+  pthread_mutex_unlock( ( ( const private_buffer * ) buf )->mutex );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/src/lib/buffer.h

@@ -0,0 +1,56 @@
+/*
+ * Buffer library.
+ *
+ * Author: Shin-ya Zenke
+ *
+ * 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 BUFFER_H
+#define BUFFER_H
+
+
+#include <stddef.h>
+
+
+typedef struct buffer {
+  void *data;
+  size_t length;
+  void *user_data;
+  void ( *user_data_free_function )( struct buffer *buffer );
+} buffer;
+
+
+buffer *alloc_buffer( void );
+buffer *alloc_buffer_with_length( size_t length );
+void free_buffer( buffer *buf );
+void *append_front_buffer( buffer *buf, size_t length );
+void *remove_front_buffer( buffer *buf, size_t length );
+void *append_back_buffer( buffer *buf, size_t length );
+buffer *duplicate_buffer( const buffer *buf );
+void dump_buffer( const buffer *buf, void dump_function( const char *format, ... ) );
+
+
+#endif // BUFFER_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */