Esempio n. 1
0
File: fdb.c Progetto: mq24705/apps
bool
update_fdb( hash_table *fdb, const uint8_t mac[ OFP_ETH_ALEN ], uint64_t dpid, uint16_t port ) {
    assert( fdb != NULL );
    assert( mac != NULL );
    assert( port != 0 );

    fdb_entry *entry = lookup_hash_entry( fdb, mac );

    debug( "Updating fdb ( mac = %02x:%02x:%02x:%02x:%02x:%02x, dpid = %#" PRIx64 ", port = %u ).",
           mac[ 0 ], mac[ 1 ], mac[ 2 ], mac[ 3 ], mac[ 4 ], mac[ 5 ], dpid, port );

    if ( entry != NULL ) {
        if ( ( entry->dpid == dpid ) && ( entry->port == port ) ) {
            entry->updated_at = time( NULL );

            return true;
        }

        if ( entry->created_at + HOST_MOVE_GUARD_SEC < time( NULL ) ) {
            // Poisoning when the terminal moves
            poison( entry->dpid, mac );

            entry->dpid = dpid;
            entry->port = port;
            entry->created_at = time( NULL );
            entry->updated_at = entry->created_at;

            return true;
        }

        warn( "Failed to update fdb because host move detected in %d sec "
              "( mac = %02x:%02x:%02x:%02x:%02x:%02x, "
              "dpid = %#" PRIx64 " -> %#" PRIx64 ", port = %u -> %u ).",
              HOST_MOVE_GUARD_SEC,
              mac[ 0 ], mac[ 1 ], mac[ 2 ], mac[ 3 ], mac[ 4 ], mac[ 5 ],
              entry->dpid, dpid, entry->port, port );

        return false;
    }

    entry = xmalloc( sizeof( fdb_entry ) );
    entry->dpid = dpid;
    memcpy( entry->mac, mac, OFP_ETH_ALEN );
    entry->port = port;
    entry->created_at = time( NULL );
    entry->updated_at = entry->created_at;
    insert_hash_entry( fdb, entry->mac, entry );

    return true;
}
Esempio n. 2
0
void
insert_dpid_entry( uint64_t *dpid ) {
  assert( dpid_table != NULL );
  assert( dpid != NULL );

  if ( lookup_hash_entry( dpid_table, dpid ) != NULL ) {
    warn( "datapath %#" PRIx64 " is already registered.", *dpid );
    return;
  }

  uint64_t *new_entry = xmalloc( sizeof ( uint64_t ) );
  *new_entry = *dpid;
  insert_hash_entry( dpid_table, new_entry, new_entry );
}
Esempio n. 3
0
static void
handle_packet_in( uint64_t datapath_id, packet_in message ) {
  known_switch *sw = lookup_hash_entry(
    message.user_data,
    &datapath_id
  );
  if ( sw == NULL ) {
    warn( "Unknown switch (datapath ID = %#" PRIx64 ")", datapath_id );
    return;
  }
  
  packet_info packet_info = get_packet_info( message.data );
  learn( sw->forwarding_db, message.in_port, packet_info.eth_macsa );
  forwarding_entry *destination = lookup_hash_entry( sw->forwarding_db, 
                                                     packet_info.eth_macda );

  if ( destination == NULL ) {
    do_flooding( message );
  }
  else {
    send_packet( destination->port_no, message );
  }
}
Esempio n. 4
0
static void
test_increment_stat_succeeds_with_defined_key() {
  assert_true( init_stat() );

  const char *key = "key";
  assert_true( add_stat_entry( key ) );
  increment_stat( key );

  stat_entry *entry = lookup_hash_entry( stats, key );
  assert_string_equal( entry->key, key );
  uint64_t expected_value = 1;
  assert_memory_equal( &entry->value, &expected_value, sizeof( uint64_t ) );

  assert_true( finalize_stat() );
}
Esempio n. 5
0
/*
 * Removes a hash entry pointer from the table.
 *
 * If that hash does not exist, NULL is returned, or, if that hash
 * exists and is the first entry, ptr_next will be set to that entry
 * and NULL is returned. Otherwise the caller must maintain the
 * remaining list.
 */
static void *remove_hash_entry(unsigned int hash, void *ptr, void *ptr_next,
			       struct hash_table *table)
{
	struct hash_table_entry *entry = lookup_hash_entry(hash, table);
	if (!entry->ptr)
		return NULL;
	else if (entry->ptr == ptr) {
		entry->ptr = ptr_next;
		entry->hash = hash;
		if (!ptr_next)
			table->nr--;
		return NULL;
	} else
		return entry->ptr;
}
Esempio n. 6
0
static void
test_insert_twice_overwrites_old_value() {
  char *prev;
  char key[] = "key";
  table = create_hash( compare_string, hash_string );

  char old_value[] = "old value";
  char new_value[] = "new value";

  insert_hash_entry( table, key, old_value );
  prev = insert_hash_entry( table, key, new_value );

  assert_string_equal( lookup_hash_entry( table, key ), "new value" );
  assert_string_equal( prev, "old value" );

  delete_hash( table );
}
Esempio n. 7
0
void
insert_match_entry( struct ofp_match *ofp_match, uint16_t priority, const char *service_name, const char *entry_name ) {
  match_entry *new_entry, *entry;
  list_element *list;

  pthread_mutex_lock( match_table_head.mutex );

  new_entry = allocate_match_entry( ofp_match, priority, service_name, entry_name );

  if ( !ofp_match->wildcards ) {
    entry = lookup_hash_entry( match_table_head.exact_table, ofp_match );
    if ( entry != NULL ) {
      warn( "insert entry exits" );
      free_match_entry( new_entry );
      pthread_mutex_unlock( match_table_head.mutex );
      return;
    }
    insert_hash_entry( match_table_head.exact_table, &new_entry->ofp_match, new_entry );
    pthread_mutex_unlock( match_table_head.mutex );
    return;
  }

  // wildcard flags are set
  for ( list = match_table_head.wildcard_table; list != NULL; list = list->next ) {
    entry = list->data;
    if ( entry->priority <= new_entry->priority ) {
      break;
    }
  }
  if ( list == NULL ) {
    // wildcard_table is null or tail
    append_to_tail( &match_table_head.wildcard_table, new_entry );
    pthread_mutex_unlock( match_table_head.mutex );
    return;
  }
  if ( list == match_table_head.wildcard_table ) {
    // head
    insert_in_front( &match_table_head.wildcard_table, new_entry );
    pthread_mutex_unlock( match_table_head.mutex );
    return;
  }

  // insert brefore
  insert_before( &match_table_head.wildcard_table, list->data, new_entry );
  pthread_mutex_unlock( match_table_head.mutex );
}
Esempio n. 8
0
static http_transaction *
lookup_http_transaction( CURL *easy_handle ) {
  debug( "Looking up a HTTP transaction ( easy_handle = %p, transactions = %p ).", easy_handle, transactions );

  assert( easy_handle != NULL );
  assert( transactions != NULL );

  http_transaction *transaction = lookup_hash_entry( transactions, easy_handle );
  if ( transaction == NULL ) {
    debug( "Failed to lookup a transaction ( transactions = %p, easy_handle = %p ).", transactions, easy_handle );
    return NULL;
  }

  debug( "Transaction found ( transaction = %p, transactions = %p, easy_handle = %p ).", transaction, transactions, easy_handle );

  return transaction;
}
Esempio n. 9
0
static bool
insert_exact_match_entry( hash_table *exact_table, struct ofp_match *match, void *data ) {
  assert( exact_table != NULL );
  assert( match != NULL );

  match_entry *entry = lookup_hash_entry( exact_table, match );
  if ( entry != NULL ) {
    char match_string[ MATCH_STRING_LENGTH ];
    match_to_string( match, match_string, sizeof( match_string ) );
    warn( "exact match entry already exists ( match = [%s] )", match_string );
    return false;
  }
  match_entry *new_entry = allocate_match_entry( match, 0 /* dummy priority */, data );
  match_entry *conflict_entry = insert_hash_entry( exact_table, &new_entry->match, new_entry );
  assert( conflict_entry == NULL );
  return true;
}
Esempio n. 10
0
static void *
delete_exact_match_strict_entry( hash_table *exact_table, struct ofp_match *match ) {
  assert( exact_table != NULL );
  assert( match != NULL );

  match_entry *entry = lookup_hash_entry( exact_table, match );
  if ( entry == NULL ) {
    char match_string[ MATCH_STRING_LENGTH ];
    match_to_string( match, match_string, sizeof( match_string ) );
    warn( "exact match entry not found ( match = [%s] )",
          match_string );
    return NULL;
  }
  void *data = entry->data;
  delete_hash_entry( exact_table, match );
  free_match_entry( entry );
  return data;
}
static transaction_entry *
lookup_transaction_entry_by_barrier_xid( uint32_t transaction_id ) {
  debug( "Looking up a transaction entry by barrier transaction id ( transaction_db = %p, transaction_id = %#x ).", transaction_db, transaction_id );

  assert( transaction_db != NULL );
  assert( transaction_db->barrier_xid != NULL );

  transaction_entry *entry = lookup_hash_entry( transaction_db->barrier_xid, &transaction_id );
  if ( entry != NULL ) {
    debug( "A transaction entry found." );
    dump_transaction_entry( debug, entry );
  }
  else {
    debug( "Failed to lookup a transaction entry by barrier transaction id ( transaction_db = %p, transaction_id = %#x ).", transaction_db, transaction_id );
  }

  return entry;
}
void
print_with_graph_easy_format( void *param, size_t entries, const topology_link_status *s ) {
  size_t i;

  UNUSED( param );

  debug( "topology: entries %d", entries );

  hash_table *link_hash = create_hash( compare_link, hash_link );
  // show_topology graph-easy | graph-easy
  // Graph-Easy:
  //   http://search.cpan.org/~shlomif/Graph-Easy/bin/graph-easy
  printf("#! /usr/bin/env graph-easy\n" );

  for ( i = 0; i < entries; i++ ) {
    if ( s[ i ].status != TD_LINK_UP ) {
      continue;
    }
    topology_link_status r;
    r.from_dpid = s[ i ].to_dpid;
    r.from_portno = s[ i ].to_portno;
    r.to_dpid = s[ i ].from_dpid;
    r.to_portno = s[ i ].from_portno;

    topology_link_status *e = lookup_hash_entry( link_hash, &r );
    if ( e != NULL ) {
      delete_hash_entry( link_hash, e );
      print_link_status( e, true );
    } else {
      insert_hash_entry( link_hash, ( void * ) ( intptr_t ) &s[ i ], ( void *) ( intptr_t ) &s[ i ] );
    }
  }
  hash_iterator iter;
  init_hash_iterator( link_hash, &iter );
  hash_entry *e;
  while ( ( e = iterate_hash_next( &iter ) ) != NULL ) {
    topology_link_status *le = e->value;
    print_link_status( le, false );
  }

  delete_hash( link_hash );

  stop_trema();
}
static transaction_entry *
lookup_transaction( uint64_t datapath_id, uint32_t vni ) {
  debug( "Looking up a transaction record ( datapath_id = %#" PRIx64 ", vni = %#x ).", datapath_id, vni );

  if ( !valid_vni( vni ) ) {
    return NULL;
  }

  transaction_entry key = { datapath_id, vni, 0, 0, 0, 0, NULL, NULL };
  transaction_entry *entry = lookup_hash_entry( transactions, &key );
  if ( entry != NULL ) {
    debug( "Transaction record found ( datapath_id = %#" PRIx64 ", vni = %#x, operation = %#x, port_wait_count = %d, callback = %p, user_data = %p ).",
           entry->datapath_id, entry->vni, entry->operation, entry->port_wait_count, entry->callback, entry->user_data );
  }
  else {
    debug( "Failed to lookup a transaction record ( datapath_id = %#" PRIx64 ", vni = %#x ).", datapath_id, vni );
  }

  return entry;
}
Esempio n. 14
0
static void
test_send_then_message_received_callback_is_called() {
  init_messenger( "/tmp" );

  const char service_name[] = "Say HELLO";

  expect_value( callback_hello, tag, 43556 );
  expect_string( callback_hello, data, "HELLO" );
  expect_value( callback_hello, len, 6 );

  add_message_received_callback( service_name, callback_hello );
  send_message( service_name, 43556, "HELLO", strlen( "HELLO" ) + 1 );
  start_messenger();
  start_event_handler();

  delete_message_received_callback( service_name, callback_hello );
  delete_send_queue( lookup_hash_entry( send_queues, service_name ) );

  finalize_messenger();
}
static void
handle_port_desc_reply( uint64_t datapath_id, uint32_t transaction_id,
                        uint16_t type, uint16_t flags, const buffer *data,
                       void *user_data ) {
  UNUSED( transaction_id );
  UNUSED( type );
  UNUSED( flags );
  show_desc *show_desc = user_data;

  desc_entry *desc = lookup_hash_entry( show_desc->db, &datapath_id );
  if ( desc == NULL ) {
    return;
  }
  append_to_tail( &desc->port_desc, duplicate_buffer( data ) );

  if ( more_requests( flags ) ) {
    return;
  }

  display_desc( &desc->desc_stats );
  display_datapath_id( datapath_id );
  for ( list_element *e = desc->port_desc; e != NULL; e = e->next ) {
    buffer *data = e->data;
    struct ofp_port *port = ( struct ofp_port  * ) data->data;
    size_t length = data->length;
    while ( length >= sizeof( struct ofp_port ) ) {
      display_port( port );
      length -= ( uint16_t ) sizeof( struct ofp_port );
      port++;
    }
    free_buffer( e->data );
  }
  delete_list( desc->port_desc );
  delete_hash_entry( show_desc->db, &datapath_id );
  show_desc->count--;
  xfree( desc );

  if ( show_desc->count == 0 ) {
    stop_trema();
  }
}
Esempio n. 16
0
void *
lookup_datapath_entry( hash_table *db, uint64_t datapath_id ) {
  datapath_entry *entry = lookup_hash_entry( db, &datapath_id );
  debug( "lookup datapath: %#" PRIx64 " ( entry = %p )", datapath_id, entry );
  return entry != NULL ? entry->user_data : NULL;
}
Esempio n. 17
0
File: fdb.c Progetto: Milstein/trema
uint16_t
lookup_fdb( hash_table *db, uint8_t *mac ) {
  fdb *entry = lookup_hash_entry( db, mac );
  return ( uint16_t ) ( entry == NULL ? ENTRY_NOT_FOUND_IN_FDB : entry->port_number );

}
Esempio n. 18
0
xid_entry_t *
lookup_xid_entry( uint32_t xid ) {
  return lookup_hash_entry( xid_table.hash, &xid );
}
Esempio n. 19
0
switch_port *
lookup_switch_port( uint32_t port_no ) {
  assert( switch_ports != NULL );

  return lookup_hash_entry( switch_ports, &port_no );
}
Esempio n. 20
0
void *lookup_hash(unsigned int hash, const struct hash_table *table)
{
	if (!table->array)
		return NULL;
	return lookup_hash_entry(hash, table)->ptr;
}