connection_table.cpp

Go to the documentation of this file.

#ifndef CONNECTION_TABLE_IMPLEMENTATION_FILE
#define CONNECTION_TABLE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : connection_table                                                  *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "connection.h"
#include "connection_table.h"

#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/mutex.h>
#include <data_struct/byte_hasher.h>
#include <data_struct/int_hash.cpp>
#include <textual/string_manipulation.h>

using namespace nodes;

//#define DEBUG_CONNECTION_TABLE
  // uncomment for debugging version.

const int CTB_MAX_BITS = 10;
  // number of bits in the table.  2^CTB_MAX_BITS entries will be created, and
  // there are probably at least 20 bytes per entry.

#undef AUTO_LOCK
#define AUTO_LOCK auto_synchronizer l(*_connlock)

#undef LOG
#define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger(), to_print)


class conntab_hash : public int_hash<connection>
{
public:
  conntab_hash() : int_hash<connection>(CTB_MAX_BITS) {}
};


connection_table::connection_table(int heartbeats_until_expiration,
    int freshness_period, int ghost_period)
: _connection_list(new conntab_hash),
  _connlock(new mutex),
  _heartbeats_until_expiration(heartbeats_until_expiration),
  _freshness_period(freshness_period),
  _ghost_period(ghost_period)
{}

connection_table::~connection_table()
{
  WHACK(_connlock);
  WHACK(_connection_list);
}

int connection_table::connections_on_primary(const transport_id &real_id,
    const transport_id &ignored_link_id, int primary_id)
{ return count_users(real_id, ignored_link_id, primary_id, PRIMARY_ID); }

void connection_table::complain_missing_connection
    (const connection_id &conn_id, const istring &where) const
{
  istring to_print = timestamp(true, true) + where
      + istring(istring::SPRINTF, "connection %d cannot be found.",
            conn_id.raw_id());
  EMERGENCY_LOG(program_wide_logger(), to_print);
}

connection_id connection_table::find_state(const transport_id &real_id,
    connection::states to_find, int low_level)
{
  FUNCDEF("find_state");
  if (!real_id) return 0;
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive && (conn->real_transport_id == real_id)
          && (conn->state() == to_find) ) {
      // if they specified a "don't care" id, then this connection will work.
      if (negative(low_level)) return conn->conn_id();
      // the low-level id must match this candidate's.
      if (conn->low_level[PRIMARY_ID] == low_level) return conn->conn_id();
    }
  }
  return 0;
}

bool connection_table::connected(const connection_id &conn_id)
{
  FUNCDEF("connected");
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  return conn->connected();
}

bool connection_table::transport_connected(const transport_id &tran_id)
{
  FUNCDEF("transport_connected");
  if (!tran_id) return false;
  bool connected = false;
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (!conn) continue;
//if not conn, that's an error.  complain about it.
    if (conn->alive && (conn->real_transport_id == tran_id)
          && conn->connected()) {
      connected = true;
      break;
    } else if (conn->alive && (conn->local_transport_id == tran_id) 
          && conn->connected()) {
      connected = true;
      break;
    }
  }
  return connected;
}

bool connection_table::live(const connection_id &conn_id)
{
  FUNCDEF("live");
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  return conn->alive;
}

bool connection_table::reset_time(const connection_id &conn_id)
{
  FUNCDEF("reset_time");
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  conn->liveness.kabump();
  return true;
}

heartbeat connection_table::liveness(const connection_id &conn_id)
{
  if (!conn_id) return heartbeat(0, 0);
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return heartbeat(0, 0);
  return conn->liveness;
}

bool connection_table::set_liveness(const connection_id &conn_id,
    const heartbeat &new_liveness)
{
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  conn->liveness = new_liveness;
  return true;
}

bool connection_table::record_request(const connection_id &conn_id)
{
  FUNCDEF("record_request");
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  conn->liveness.made_request();
  return true;
}

connection_id connection_table::find_linked(sides side,
    const transport_id &tran_id)
{
  if (!tran_id) return 0;
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive
        && ( ((side == REMOTE_LINK) && (conn->remote_transport_id == tran_id))
          || ((side == LOCAL_LINK) && (conn->local_transport_id == tran_id))
          || ((side == LOCAL_REAL) && (conn->real_transport_id == tran_id)))) {
      connection_id found = conn->conn_id();
      return found;
    }
  }
  // never found an appropriate one.
  return 0;
}

connection_id connection_table::find_low_level
    (network_address::address_type type, int low_level_id, int index)
{
  FUNCDEF("find_low_level");
  AUTO_LOCK;
  if (!low_level_id) return 0;
  // simple-minded checks.
  if (index < 0) index = 0;
  if (index > 1) index = 1;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive && (conn->remote_host.type() == type)
        && (conn->low_level[index] == low_level_id) )
      return conn->conn_id();
  }
  return 0;
}

connection_id connection_table::find_destination(const transport_id &real_id,
    const network_address &destination)
{
  FUNCDEF("find [id/destination]");
  if (!real_id) return 0;
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && (conn->remote_host == destination)
        && (conn->real_transport_id == real_id)
        && conn->alive) {
      connection_id found = conn->conn_id();
      return found;
    }
  }
  return 0;
}

int connection_table::get_low_level_id(const transport_id &real_id, int index)
{
  FUNCDEF("get_low_level_id");
  AUTO_LOCK;
  if (!real_id) return 0;
  // simple-minded checks.
  if (index < 0) index = 0;
  if (index > 1) index = 1;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->connected()
        && (conn->real_transport_id == real_id)
        && conn->alive) {
      int found = conn->low_level[index];
      return found;
    }
  }
  return 0;
}

bool connection_table::owns_connection(const connection_id &conn_id,
    const transport_id &link_id)
{
  FUNCDEF("owns_connection");
  AUTO_LOCK;
  connection to_fill;
  if (!find(conn_id.raw_id(), to_fill)) return false;
  return to_fill.local_transport_id == link_id;
}

int connection_table::count_users(const transport_id &real_id,
    const transport_id &ignored_link_id, int low_level_id, int index)
{
  FUNCDEF("count_users");
  AUTO_LOCK;
  // simple-minded checks.
  if (!low_level_id) return 0;  // zero is an invalid id.
  if (!real_id) return 0;
  if (index < 0) index = 0;  // keep index in range.
  if (index > 1) index = 1;
  int users_counted = 0;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive && (conn->real_transport_id == real_id)
        && (conn->low_level[index] == low_level_id)
        && (conn->state() != connection::DISCONNECTED) 
        && (conn->local_transport_id != ignored_link_id) )
      users_counted++;
  }
  return users_counted;
}

connection_id connection_table::update(const connection &to_update)
{
  FUNCDEF("update");
  if (!to_update.conn_id()) return 0;
  AUTO_LOCK;
  connection *conn = _connection_list->find(to_update.conn_id().raw_id());
  if (!conn) {
    FUNCTION(func);
    complain_missing_connection(to_update.conn_id(), function_name);
    return 0;
  }
  *conn = to_update;
  return to_update.conn_id();
}

//hmmm: get rid of whole dead connections trammeling along behind stuff.
//      just be honest about when connections get whacked.  they already
//      have a built in timeout mechanism and such...

bool connection_table::find(const connection_id &conn_id, connection &to_fill)
{
  FUNCDEF("find [id/conn]");
  to_fill = connection();  // reset the contents.
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  if (conn->alive) {
    to_fill = *conn;
    return true;
  }
  return false;
}

connection_id connection_table::add(const connection &to_add_in)
{
  FUNCDEF("add");
  AUTO_LOCK;
  connection to_add = to_add_in;  // copy so we can blast the contents.
  if (!to_add.conn_id()) {
    LOG("no id was assigned for connection; failing it.");
    return 0;
  }
  to_add.alive = true;
  to_add.liveness = heartbeat(_heartbeats_until_expiration, _freshness_period);
  connection_id found = find_linked(LOCAL_LINK, to_add.local_transport_id);
  if (!found) {
    // that transport doesn't have a connection yet.
    to_add.state(connection::DISCONNECTED);
    // create a new connection object and fill it out.
    connection *the_conn = new connection(to_add);
    _connection_list->add(the_conn->conn_id().raw_id(), the_conn);
      // append new entry to the connection list.
  } else {
#ifdef DEBUG_CONNECTION_TABLE
    LOG(istring(istring::SPRINTF, "found existing connection %d!", found));
#endif
    return 0;
  }
  return to_add.conn_id();
}

bool connection_table::zap(const connection_id &conn_id)
{
  FUNCDEF("zap");
  if (!conn_id) return false;
  AUTO_LOCK;
  connection *conn = _connection_list->find(conn_id.raw_id());
  if (!conn) return false;
  conn->alive = false;
  conn->liveness = heartbeat(_heartbeats_until_expiration,
      _ghost_period / _heartbeats_until_expiration);
  return true;
}

void connection_table::clear_dead()
{
  FUNCDEF("clear_dead");
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);

    if (!conn) continue;
//THAT IS A BAD ERROR ABOVE...
//hmmm: at least remove the id!!!
//hmmm: complain about mistakes like this.

    if (!conn->alive) {
      if (conn->liveness.dead()) {
        // this one has had it.
#ifdef DEBUG_CONNECTION_TABLE
        LOG(istring(istring::SPRINTF, "clearing out stale, dead "
            "connection %d.", conn->conn_id()));
#endif
        _connection_list->zap(curr_id);
        i--;  // skip back to where loop expects.
      } else if (conn->liveness.due()) {
#ifdef DEBUG_CONNECTION_TABLE
        LOG(istring(istring::SPRINTF, "making new heartbeat request on "
             "connection %d.", curr_id));
#endif
        conn->liveness.made_request();  // next cycle.
      }
    }
  }
}

void connection_table::show_connections(istring &output, int indentation,
    bool alive_only)
{
  AUTO_LOCK;
  istring indent = string_manipulation::indentation(indentation);
  bool any_printed = false;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && (!alive_only || conn->alive) ) {
      output += indent + conn->text_form() + log_base::platform_ending();
      any_printed = true;
    }
  }
  if (!any_printed)
    output += indent + istring("No connections exist.")
        + log_base::platform_ending();
}

bool connection_table::set_conn_state(const transport_id &tran_id,
    connection::states state)
{
  FUNCDEF("set_conn_state");
  if (!tran_id) return false;
  AUTO_LOCK;
  connection_id found = find_linked(LOCAL_LINK, tran_id);
  if (!found) return false;
  connection *conn = _connection_list->find(found.raw_id());
  if (!conn) return false;
  bool to_return = false;
  if (conn->alive) {
    conn->state(state);
    to_return = true; 
    if (state == connection::DISCONNECTED)
      conn->low_level[PRIMARY_ID] = 0;  // not used now.
  }
  return to_return;
}

int connection_table::set_conn_states(const transport_id &real_id,
    connection::states state)
{
  FUNCDEF("set_conn_states");
  AUTO_LOCK;
  int conns_processed = 0;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && (conn->real_transport_id == real_id)) {
      conn->state(state);
      conns_processed++;
    }
  }
  return conns_processed;
}

connection::states connection_table::get_conn_state(const transport_id &tran_id)
{
  FUNCDEF("get_conn_state");
  connection::states to_return = connection::DISCONNECTED;
  if (!tran_id) return to_return;
  AUTO_LOCK;
  connection_id found = find_linked(LOCAL_LINK, tran_id);
  if (!found) return to_return;
  connection *conn = _connection_list->find(found.raw_id());
  if (!conn) return to_return;
  if (conn->alive)
    to_return = conn->state();
  return to_return;
}

transport_id connection_table::socket_to_real_transport
    (network_address::address_type type, int socket, transport_id &linked_id)
{
  FUNCDEF("socket_to_real_transport");
  AUTO_LOCK;
  linked_id = 0;  // reset.
  bool is_linked;  // is the transport a linked one?
  connection_id conn_id_found = find_low_level(type, socket, PRIMARY_ID);
  if (conn_id_found.raw_id()) is_linked = true;
  else {
    // we know it's not a linked transport now.
    is_linked = false;
    conn_id_found = find_low_level(type, socket, SECONDARY_ID);
    if (!conn_id_found) {
#ifdef DEBUG_CONNECTION_TABLE
      LOG(istring(istring::SPRINTF, "can't find connection for "
          "socket %d in primary or secondary low-level ids; "
          "failing out.", socket));
#endif
      return 0;
    }
  }
  // lookup the connection we got.
  GET_CONN_ENTRY((*this), conn_id_found);
  if (!conn_found) return 0;

  // if it's a linked transport we also give back that id.
  if (is_linked) linked_id = conn_entry.local_transport_id;
  // return the real id.
  return conn_entry.real_transport_id;
}

int_set connection_table::find_related_conns(int low_level_primary,
    int real_transport)
{
  FUNCDEF("find_related_conns");
  AUTO_LOCK;
  if (!low_level_primary) return int_set();
  if (!real_transport) return int_set();
  int_set to_return;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive && (conn->real_transport_id == real_transport)
        && (conn->low_level[PRIMARY_ID] == low_level_primary) )
      to_return += curr_id;
  }
  return to_return;
}

int_set connection_table::find_live_reals()
{
  FUNCDEF("find_live_reals");
  AUTO_LOCK;
  int_set to_return;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive) to_return += conn->real_transport_id.raw_id();
  }
  return to_return;
}

connection_id connection_table::find_dupe(int real_transport,
    int low_level_primary, const network_address &sender,
    int other_side_transport)
{
  FUNCDEF("find_dupe");
  AUTO_LOCK;
  for (int i = 0; i < _connection_list->ids().elements(); i++) {
    int curr_id = _connection_list->ids()[i];
    connection *conn = _connection_list->find(curr_id);
    if (conn && conn->alive) {
      if ( (conn->low_level[PRIMARY_ID] == low_level_primary)
&& (conn->real_transport_id == real_transport)
          && (conn->remote_host == sender)
          && (conn->remote_transport_id == other_side_transport) )
       return conn->conn_id();
    }
  }
  return 0;
}


#endif //CONNECTION_TABLE_IMPLEMENTATION_FILE

---