libcom_tcp.c

Go to the documentation of this file.

/******************************************************************************
%   File    : libcom_tcp.c
%   Primary Authors  : Adam Cheyer, Didier Guzzoni
%   Purpose : TCP instantiation of lowlevel communication primitives for OAA
%         Works for both Microsoft Windows (1st half) and UNIX (2nd half)
%   Updated : 01/98
%
%*/
/*
 * Copyright (C) 2006  SRI International
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * SRI International: 333 Ravenswood Ave, Menlo Park, CA 94025
 */

#define EXPORT_BORLAND

#ifdef IS_DLL
#define EXPORT_MSCPP __declspec(dllexport)
#else
#define EXPORT_MSCPP
#endif

#define OAA_BINARY_PORT_OFFSET 10

/****************************************************************************
 * Include files
 ****************************************************************************/
#ifndef _WINDOWS
#include <sys/param.h>  // used by com_get_localhost_ip_address()
#endif
#include <stdio.h>
#include <stdarg.h>   /* Variable length argument lists */
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include "libcom_tcp.h"
#include "libdb.h"
#include "libutils.h"
#include "libicl_private.h"
#include "libicl.h"
#include "libicl_depr.h"
#include "termreader.h"
#include "stringtermreader.h"
#include "binarytermreader.h"
#include "termsender.h"
#include "stringtermsender.h"
#include "binarytermsender.h"
#include "liboaa.h"

extern const char* oaa_library_version_str;

/****************************************************************************
 * Global variables and forward declarations
 ****************************************************************************/
#ifndef STREQ
#define STREQ(str1, str2) (strcmp((str1), (str2)) == 0)
#endif

int COM_BEST_FORMAT = 100;
int COM_STRING_FORMAT = 1;
int COM_BINARY_FORMAT = 2;

#ifdef NORMAL_GC
static void* termReaders[128];
static void* termSenders[128];
static int termReadersIdx = -1;
static int termSendersIdx = -1;
/*
static GPtrArray* termReaders = NULL;
static GPtrArray* termSenders = NULL;
*/
#endif

/* Communication database */
ICLDatabase *commdb = NULL;

static ICLTerm *eventBuffer = NULL;

static int stringListener = -1;

static int binaryListener = -1;

static int stringPort = -1;

static int binaryPort = -1;

static int nextStartingSeqNum = 0;

static const int HEARTBEAT_TIMEOUT = 10;

/* Forward definitions */
int com_ask_about_tcp_exception(int Port, char *Host);
void    tcpShutdown(SOCKET connection);
SOCKET  tcpConnect(char *hostName, int port);
// Timeout given in seconds
int tcpSelect(SOCKET socket, double timeout);
EXTERN void comPrintError(char *str, ...);

// new functions for direct_connect
static void checkEventBuffer(void);
static void com_accept_new_connection(int listenersocket);
static int com_add_event_to_buffer(ICLTerm *event);
static int com_disconnect_all_connection_ids();
static int com_find_all_connected_sockets(ICLTerm *ids, ICLTerm **sockets);
static int com_find_all_connection_ids(ICLTerm **ids);
static char *com_get_connection_id_from_socket(int socket);
static char *com_get_localhost_ip_address(void);
static int com_is_binary_listener(int socket);
static int com_is_listening(void);
static int com_read_events_into_buffer(double timeout);
static int com_select_event_from_buffer(ICLTerm **event);
static int com_select_event_from_socket(int socketNumber, double timeout, ICLTerm **event);
static char* new_direct_client_id(void);
static int opentcpport(int port);
static int tcpListenAtPort(int port);
static struct hostent* getHostEntry(char const* hostName);

static int close_socket(int socket);

#ifdef _WINDOWS
/****************************************************************************
 * Definitions for MICROSOFT WINDOWS (Unix follows)
 ****************************************************************************/
#include <windows.h>
#include <winsock.h>
int tcp_started = 0;
int EXPORT_MSCPP tcpStartup();
#include "oaa-windows.h"
#else
/****************************************************************************
 * Definitions for UNIX (Windows above)
 ****************************************************************************/
#include <stdio.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>  /* inet_addr        */
#include <netdb.h>
#include <strings.h>    /* bzero, bcopy     */
#include <unistd.h>     /* close        */
#include <sys/time.h>   /* For polling time */
#include <string.h>

#endif

static int close_socket(int socket)
{
#ifdef _WINDOWS
  return closesocket(socket);
#else
  return close(socket);
#endif
}

static int getNextStartingSeqnum()
{
  int result;
  if(nextStartingSeqNum == 0) {
    srand(1023);
  }
  result = rand();
  return (result < 0 ? -result : result) | 2;
}

EXPORT_MSCPP
SOCKET EXPORT_BORLAND
com_Connect(char *ConnectionId, ICLTerm *Address)
{
  return comConnectFormat(ConnectionId, ICL_EMPTY, Address, COM_BEST_FORMAT);
}

char const* commonStart = "event(ev_connect([";
char const* commonEnd = "query_formats(_),other_name('libcom_tcp_formatRequest_shouldDisconnect'),other_type(client)]),[])";
char const* otherVersionStart = "other_version(";
char const* otherVersionEnd = ")";
char const* passwordStart = "password(";
char const* passwordEnd = ")";
char const* comma = ",";

static ICLTerm* createEvConnectEvent(char const* password, ICLTerm* hostTerm)
{
  char* tempString;
  char* host = icl_NewStringFromTerm(hostTerm);
  ICLTerm* result;
  int tempStringLen = 
    strlen(commonStart) + 
    strlen(otherVersionStart) + strlen(oaa_library_version_str) + strlen(otherVersionEnd) + strlen(comma) +
    (password ? strlen(passwordStart) + strlen(password) + strlen(passwordEnd) + strlen(comma) : 0) +
    strlen(commonEnd) + 1;

  tempString = (char*)malloc(tempStringLen);
  snprintf(tempString, tempStringLen, "%s%s%s%s%s%s%s%s%s%s", 
           commonStart, 
           otherVersionStart, oaa_library_version_str, otherVersionEnd, comma,
           (password ? passwordStart : ""), (password ? password : ""), (password ? passwordEnd : ""), (password ? comma : ""),
           commonEnd);
  result = icl_NewTermFromString(tempString);
  free(tempString);
  icl_stFree(host);
  return result;
}

static void com_set_connect_info(char* connectionId, ICLTerm* params, ICLTerm* host, ICLTerm* port, ICLTerm* readerInfo, ICLTerm* senderInfo, SOCKET connection)
{
  ICLTerm *canonicalOtherAddress = NULL;
  ICLTerm *newConnectionInfo = NULL;
  ICLTerm *tempList = icl_NewList(NULL);
  ICLTerm *atmp;
  ICLTerm *templateTcpAddr = icl_NewStruct("tcp", 2, icl_CopyTerm(host), icl_CopyTerm(port));
  ICLTerm *typeMatcher = icl_NewStruct("type", 1, icl_NewVar("_"));

  icl_AddToList(tempList, readerInfo, FALSE);
  icl_AddToList(tempList, senderInfo, FALSE);


  if(!com_GetInfo(connectionId, typeMatcher, NULL)) {
    int startingSequenceNumber = getNextStartingSeqnum();
    ICLTerm* cHost;
    ICLTerm* cPort;
    icl_AddToList(tempList, icl_NewStruct("connection", 1, icl_NewInt(connection)),FALSE);
    icl_AddToList(tempList, icl_NewStruct("initiated", 1, icl_NewStr("true")), FALSE);
    icl_AddToList(tempList, icl_NewStruct("sequence", 1, icl_NewInt(startingSequenceNumber)), FALSE);
    icl_AddToList(tempList, icl_NewStruct("other_acked", 1, icl_NewInt(startingSequenceNumber - 1)), FALSE);

    // params added to call for direct_connect so that we
    // could get the "correct" other_address into the com_connection_info...
    {
      ICLTerm *tmp1;
      ICLTerm *tmp2;
      tmp1 = icl_NewStruct("other_address", 1, icl_NewVar("_"));
      if (icl_GetParamValue(tmp1, params, &tmp2)) {
        icl_AddToList(tempList, tmp2, TRUE);
      }
      else {
        cnx_CanonicalAddress(templateTcpAddr, connection, &canonicalOtherAddress);
        icl_AddToList(tempList, icl_NewStruct("other_address", 1, canonicalOtherAddress), FALSE);
      }
      icl_Free(tmp1);
    }

    cHost = icl_CopyTerm(host);
    cPort = icl_CopyTerm(port);
    atmp = icl_NewStruct("tcp", 2, cHost, cPort);

    newConnectionInfo = icl_NewStruct("com_connection_info", 5,
        icl_NewStr(connectionId),
        atmp, /*
          icl_NewStruct("tcp", 2, cHost, cPort),*/
        icl_NewStr("client"),
        tempList,
        icl_NewStr("connected"));

    {
      char* format = get64BitFormatWrapped("libcom_tcp com_Connect() Connected to %s ", ".");
      printf(format, icl_Str(host), icl_Int(port));
      printf("\n");
      free(format);
    }

    if (newConnectionInfo) {
      db_Assert(commdb, newConnectionInfo, ICL_EMPTY);
      /* DEBUG */
      /* db_PrintDB(commdb);*/
      icl_Free(newConnectionInfo);
    }
    else {
      fprintf(stderr, "Error! %s:%i com_connection_info could not be constructed.\n", __FILE__, __LINE__);
    }
  }
  else {
    icl_AddToList(tempList, icl_NewStruct("connection", 1, icl_NewInt(connection)),FALSE);

    // params added to call for direct_connect so that we
    // could get the "correct" other_address into the com_connection_info...
    {
      ICLTerm *tmp1;
      ICLTerm *tmp2;
      tmp1 = icl_NewStruct("other_address", 1, icl_NewVar("_"));
      if (icl_GetParamValue(tmp1, params, &tmp2)) {
        icl_AddToList(tempList, tmp2, TRUE);
      }
      else {
        cnx_CanonicalAddress(templateTcpAddr, connection, &canonicalOtherAddress);
        icl_AddToList(tempList, icl_NewStruct("other_address", 1, canonicalOtherAddress), FALSE);
      }
      icl_Free(tmp1);
    }

    com_UpdateInfo(connectionId, icl_NewStruct("protocol", 1, icl_NewStruct("tcp", 2, icl_CopyTerm(host), icl_CopyTerm(port))));
    com_UpdateInfo(connectionId, icl_NewStruct("type", 1, icl_NewStr("client")));
    com_UpdateInfo(connectionId, icl_NewStruct("status", 1, icl_NewStr("connected")));
    com_UpdateInfo(connectionId, tempList);
    {
      char* format = get64BitFormatWrapped("libcom_tcp com_Connect() Connected to %s ", ".");
      printf(format, icl_Str(host), icl_Int(port));
      printf("\n");
      free(format);
    }
  }
  icl_Free(templateTcpAddr);
  icl_Free(typeMatcher);
}

EXPORT_MSCPP
SOCKET EXPORT_BORLAND
comConnectFormat(char* ConnectionId, ICLTerm* Params,
                 ICLTerm* Address, int format)
{
  ICLTerm *connectionInfo = NULL, *host = NULL, *port = NULL;
  ICLTerm *t1;
  SOCKET connection = 0;
  SOCKET oldConnection = 0;
  ICLTerm *readerInfo = NULL;
  ICLTerm *senderInfo = NULL;
  int res;
  ICLTerm* usePassword = NULL;
  ICLTerm* passwordTerm = NULL;
  char* password = NULL;

#ifdef _WINDOWS
  if (!tcp_started)
    tcp_started = tcpStartup();
#endif

  /* DEBUG */
  /* printf("Address %s\n", icl_NewStringFromTerm(Address)); */

  /* Make sure database is initialized */
  if (!commdb) {
    commdb = db_NewDB();
  }

  t1 = icl_NewStruct("tcp", 2, icl_NewVar("Host"), icl_NewVar("Port"));
  res = icl_Unify(Address, t1 ,&connectionInfo);
  if (ConnectionId && *ConnectionId && res) {

    /* connectionInfo = tcp(Host,Port) */
    host = icl_CopyTerm(icl_NthTerm(connectionInfo, 1));
    port = icl_CopyTerm(icl_NthTerm(connectionInfo, 2));
    icl_Free(connectionInfo);

    /* if variable address, look it up... */
    if (icl_IsVar(host) || icl_IsVar(port)) {
      ICLTerm* resolved_var = NULL;

      oaa_ResolveVariable("default_facilitator", &resolved_var);
      if (icl_IsVar(host)) {
  icl_Free(host);
  host = icl_CopyTerm(icl_NthTerm(resolved_var, 1));
      }
      if (icl_IsVar(port)) {
  icl_Free(port);
  port = icl_CopyTerm(icl_NthTerm(resolved_var, 2));
      }
      icl_Free(resolved_var);
    }

    /* by now, host and port should be known */
    if (host && port && !icl_IsVar(host) && !icl_IsVar(port))
      connection = tcpConnect(icl_Str(host), icl_Int(port));

    oaa_ResolveVariable("use_password", &usePassword);

    if(usePassword != NULL) {
      if(icl_IsStr(usePassword) && 
         (strlen(icl_Str(usePassword)) == 4) &&
         (strncmp(icl_Str(usePassword), "true", 4) == 0)) {
        oaa_ResolveVariable("client_password", &passwordTerm);
        if(passwordTerm != NULL) {
          password = icl_NewStringFromTerm(passwordTerm);
        }
        else {
          password = strdup("_");
        }
      }
    }

    if(connection > 0) {
      // create an initial connection to determine what formats are supported
      TermReader* initialTr = termReader_create();
      StringTermReader* str;
      TermSender* initialTs = termSender_create();
      StringTermSender* sts;
      ICLTerm* whatFormats = NULL;
      ICLTerm* reply = NULL;
      ICLTerm* resultList = NULL;
      gint64 realPort = icl_Int(port);
      TermReader* realTr = NULL;
      TermSender* realTs = NULL;
      char* readerPtr;
      char* readerInfoBuf;
      char* senderPtr;
      char* senderInfoBuf;
      whatFormats = createEvConnectEvent(password, host);
      if(!whatFormats) {
        printf("NULL whatFormats\n");
      }
      icl_stFree(password);
      password = NULL;

      str = stringTermReader_create(initialTr, connection);
      sts = stringTermSender_create(initialTs, connection);
      
      termSender_sendTerm(initialTs, whatFormats);
      icl_Free(whatFormats);
      /*
      printf("libcom_tcp.c sending whatFormats message sent\n");
      */
      if(termSender_getError(initialTs) != TERMSENDER_OKAY) {
        fprintf(stderr, "libcom_tcp com_Connect could not send formatRequest message: %i\n", termSender_getError(initialTs));
        close_socket(termSender_getSocket(initialTs));
        termSender_free(initialTs);
        termReader_free(initialTr);
        goto failedconnect;
      }
      reply = NULL;
      do {
        /*
        printf("libcom_tcp.c sending whatFormats waiting for reply...\n");
        */
        if(reply != NULL) {
          icl_Free(reply);
        }
        reply = termReader_getNextTerm(initialTr, 0);
        /*
        printf("libcom_tcp.c sending whatFormats waiting got a reply\n");
        */
      } while(termReader_getError(initialTr) == TERMREADER_TIMEOUT);

      if(termReader_getError(initialTr) != TERMREADER_OKAY) {
        fprintf(stderr, "libcom_tcp com_Connect could not read next term: %i\n", termReader_getError(initialTr));
        close_socket(termReader_getSocket(initialTr));
        termReader_free(initialTr);
        termSender_free(initialTs);
        goto failedconnect;
      }

      if(icl_IsStruct(icl_NthTerm(icl_NthTerm(icl_NthTerm(reply, 1), 1), 1))) {
        ICLTerm* resStruct = icl_NthTerm(icl_NthTerm(icl_NthTerm(reply, 1), 1), 1);
        char* functor = icl_Functor(resStruct);
        if(functor != NULL) {
          if((strlen(functor) == 9) &&
             (strncmp(functor, "exception", 9) == 0)) {
            char* exceptionData = icl_NewStringFromTerm(icl_NthTerm(resStruct, 1));
            fprintf(stderr, "Exception in comConnectFormat: %s\n", exceptionData);
            icl_stFree(exceptionData);
            goto failedconnect;
          }
        }
      }

      /*
       * save old socket so we can close it later--this is only done because the Prolog
       * facilitator gets mixed up if we close this connection before opening the new
       * one.
       */
      oldConnection = connection;
      resultList = icl_NthTerm(icl_NthTerm(icl_NthTerm(reply, 1), 1), 1);
      if(((format == COM_BEST_FORMAT) || (format == COM_BINARY_FORMAT))  &&
         (icl_ParamValueAsInt("binary", resultList, &realPort) == TRUE)) {
        BinaryTermReader* btr;
        BinaryTermSender* bts;


        printf("libcom_tcp com_Connect() using binary format\n");

        connection = tcpConnect(icl_Str(host), (int)realPort);
        realTr = termReader_create();
        btr = binaryTermReader_create(realTr, connection);
        realTs = termSender_create();
        bts = binaryTermSender_create(realTs, connection);
      }
      else { /* if(icl_ParamValueAsInt("ascii", resultList, &realPort)) */
        StringTermReader* str;
        StringTermSender* sts;

        /*
        printf("libcom_tcp com_Connect() using ascii format\n");
        */
        connection = tcpConnect(icl_Str(host), (int)icl_Int(port));
        realTr = termReader_create();
        str = stringTermReader_create(realTr, connection);
#ifdef NORMAL_GC
        printf("created str (%p) from realTr(%p)\n", str, realTr);
#endif
        CHECK_LEAKS();
        realTs = termSender_create();
        sts = stringTermSender_create(realTs, connection);
        CHECK_LEAKS();
      }
      CHECK_LEAKS();

      icl_Free(reply);
      CHECK_LEAKS();

      close_socket(oldConnection);
      termReader_free(initialTr);
      termSender_free(initialTs);
      CHECK_LEAKS();
#ifdef NORMAL_GC
      /* so we don't lose the pointer */
      /*
      if(termReaders == NULL) {
        termReaders = g_ptr_array_new();
      }
      g_ptr_array_add(termReaders, realTr);
      */
      termReaders[++termReadersIdx] = realTr;
      CHECK_LEAKS();
#endif
      CHECK_LEAKS();
      readerPtr = pointerToString(realTr);
      readerInfoBuf = (char*)malloc(strlen(readerPtr) + 10 + 1);
      CHECK_LEAKS();
      strncpy(readerInfoBuf, "reader('", 8);
      strncpy(readerInfoBuf + 8, readerPtr, strlen(readerPtr));
      readerInfoBuf[strlen(readerPtr) + 8] = '\'';
      readerInfoBuf[strlen(readerPtr) + 9] = ')';
      readerInfoBuf[strlen(readerPtr) + 10] = '\0';
      CHECK_LEAKS();
      readerInfo = icl_NewTermFromString(readerInfoBuf);
      free(readerPtr);
      free(readerInfoBuf);
      senderPtr = pointerToString(realTs);
#ifdef NORMAL_GC
      /* so we don't lose the pointer */
      /*
      if(termSenders == NULL) {
        termSenders = g_ptr_array_new();
      }
      g_ptr_array_add(termSenders, realTs);
      */
      termSenders[++termSendersIdx] = realTs;
#endif
      senderInfoBuf = (char*)malloc(strlen(senderPtr) + 10 + 1);
      strncpy(senderInfoBuf, "sender('", 8);
      strncpy(senderInfoBuf + 8, senderPtr, strlen(senderPtr));
      senderInfoBuf[strlen(senderPtr) + 8] = '\'';
      senderInfoBuf[strlen(senderPtr) + 9] = ')';
      senderInfoBuf[strlen(senderPtr) + 10] = '\0';
      senderInfo = icl_NewTermFromString(senderInfoBuf);
      free(senderPtr);
      free(senderInfoBuf);
    }

    if (connection>0) {
      com_set_connect_info(ConnectionId, Params, host, port, readerInfo, senderInfo, connection);
    }
    else {
      char* format = get64BitFormatWrapped("com_Connect: failed to connect to %s ", ".");
      fprintf(stderr, format, icl_Str(host), icl_Int(port));
      fprintf(stderr, "\n");
      free(format);
    }
    if (!host && !port)
      fprintf(stderr, "Make sure you have a valid setup.pl file\n");
  }
  else {
    char* addressString = icl_NewStringFromTerm(Address);
    fprintf(stderr, "%s Error!  Bad arguments to com_Connect(): connectionId = %s address = %s\n", __FILE__, ConnectionId, addressString);
    icl_stFree(addressString);
  }

  icl_Free(t1);
#ifdef NORMAL_GC
  printf("Leaving comConnectFormat\n");
#endif

  if(port) icl_Free(port);
  if(host) icl_Free(host);
  return connection;

failedconnect:
  if(port) icl_Free(port);
  if(host) icl_Free(host);
  return -1;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_Disconnect(char *ConnectionId)
{
  ICLTerm *t1, *info = NULL;

  if (ConnectionId == NULL) {
    return com_disconnect_all_connection_ids();
  }

  if (ConnectionId && *ConnectionId && commdb) {
    if (com_GetInfo(ConnectionId,
                    (t1 = icl_NewStruct("connection", 1,
                                        icl_NewVar("_"))), &info)) {

      tcpShutdown(icl_Int(icl_NthTerm(info, 1)));
      icl_Free(info);
      icl_Free(t1);
      db_Retract(commdb,
                 (t1 = icl_NewStruct("com_connection_info", 5,
                                     icl_NewStr(ConnectionId),
                                     icl_NewVar("TCP"),
                                     icl_NewVar("_Type"),
                                     icl_NewVar("_Info"),
                                     icl_NewStr("connected"))),
                 ICL_EMPTY);
    }
    icl_Free(t1);
    return TRUE;
  }
  else return FALSE;
}

EXPORT_MSCPP
SOCKET EXPORT_BORLAND
com_Connected(char* ConnectionId)
{
  ICLTerm *t1;

  /* Make sure there's a valid connection id */
  if (ConnectionId && *ConnectionId) {
    ICLTerm *currentStatus = NULL;
    com_GetInfo(ConnectionId,
                (t1 = icl_NewStruct("status", 1,
                                    icl_NewStr("connected"))),&currentStatus);
    icl_Free(t1);
    if (currentStatus && STREQ(icl_Str(currentStatus),"connected")) {
      icl_Free(currentStatus);
      return TRUE;
    }
  }
  return FALSE;
}

/****************************************************************************
 * name:    com_GetAllValidConnections
 * purpose:
 * remarks:
 ****************************************************************************/
EXPORT_MSCPP
int EXPORT_BORLAND
com_GetAllValidConnections(ICLTerm** result)
{
  int index;
  ICLTerm *resultFromDb = (ICLTerm *)NULL;
  static ICLTerm* info = NULL;

  if (!icl_IsValid(info)) {
    info = icl_NewTermFromData("com_connection_info(Id,Protocol,Type,InfoList,connected)",56);
  }

  *result = icl_NewList(NULL);

  if (db_Solve(commdb, info, ICL_EMPTY, &resultFromDb)) {
    /*
      Retreives all Id from the list of connected connections.
      Not the best optimized way to to it (n^2 order), but lists of connections
      are not going to be huge.
    */

    ICLTerm *item = NULL;

    /* DEBUG */
    /*
      printf("Result from db_Solve %s\n", icl_NewStringFromTerm(resultFromDb));
    */

    for (index = 1; index <= icl_ListLen(resultFromDb) ; index ++) {
      item = icl_NthTerm(resultFromDb, index);
      icl_AddToList(*result, icl_CopyTerm(icl_NthTerm(item, 1)), TRUE);
    }
    icl_Free(resultFromDb);
    return TRUE;
  }
  icl_Free(resultFromDb);
  return FALSE;
};

int com_GetConnectionFromInfo(ICLTerm *Info, char** connectionName)
{
  ICLTerm *resultFromDb = (ICLTerm *)NULL;
  int      res = FALSE;
  static ICLTerm* info = NULL;

  if (!icl_IsValid(info)) {
    info = icl_NewTermFromData("com_connection_info(Conn,Protocol,Type,InfoList,Status)",55);
  }

  (void)Info;

  if (db_Solve(commdb, info, ICL_EMPTY, &resultFromDb)) {
    *connectionName =
      strdup(icl_Str(icl_NthTerm(icl_NthTerm(resultFromDb, 1),1)));
    res = TRUE;
    icl_Free(resultFromDb);
  }
  return res;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_ListenAt(char *ConnectionId, ICLTerm *Params, ICLTerm *Address)
{
  ICLTerm *connectionInfo = NULL, *host = NULL, *port = NULL;
  ICLTerm *info = NULL, *t1 = NULL;
  ICLTerm *resolve_vars_false = icl_NewTermFromData("resolve_vars(false)",19);
  int do_resolve_vars = TRUE;
  char cmd[600];
  char *addressString = NULL;
  char *hostString = NULL;
  int res = FALSE;
  ICLTerm* addrFromCmdLine = NULL;
  ICLTerm* addrFromSetup = NULL;
  ICLTerm* addrFromEnv = NULL;

  // Make sure database is initialized
  if (!commdb)
    commdb = db_NewDB();

  t1 = icl_NewStruct("tcp", 2, icl_NewVar("Host"), icl_NewVar("Port"));
  if (ConnectionId && *ConnectionId && icl_Unify(Address, t1, &connectionInfo)) {

    // connectionInfo = tcp(Host,Port)
    host = icl_NthTerm(connectionInfo, 1);
    port = icl_NthTerm(connectionInfo, 2);

    // if variable address, look it up...
    do_resolve_vars = !icl_GetParamValue(resolve_vars_false, Params, NULL);
    icl_Free(resolve_vars_false);
    if (do_resolve_vars && (icl_IsVar(host) || icl_IsVar(port))) {
        oaa_ResolveVariable("oaa_connect", &addrFromSetup);   // setup file
        Address = addrFromSetup;
        addressString = getenv("OAA_CONNECT");         // env var
        if (addressString) {
          icl_Free(Address);
          addrFromEnv = icl_NewTermFromString(addressString);
          Address = addrFromEnv;
        }
        if(oaa_ResolveVariable("-oaa_connect", &addrFromCmdLine)) {  // cmd line
          icl_Free(Address);
          Address = addrFromCmdLine;
        }
    }

    icl_Free(connectionInfo);

    // by now, host and port should be known
    icl_Unify(Address, t1, &connectionInfo);

    // connectionInfo = tcp(Host,Port)
    host = icl_NthTerm(connectionInfo, 1);
    port = icl_NthTerm(connectionInfo, 2);

    if (!icl_IsVar(host) && !icl_IsVar(port))

      do {
        //
        hostString = strdup(icl_Str(host));
        if (!strcmp("localhost", hostString)) {
          icl_stFree(hostString);
          hostString = com_get_localhost_ip_address();
        }
        // stringPort, binaryPort, stringListener, and binaryListener
        // have file scope
        stringPort = icl_Int(port);
        binaryPort = stringPort + OAA_BINARY_PORT_OFFSET;
        stringListener = tcpListenAtPort(stringPort);
        binaryListener = tcpListenAtPort(binaryPort);
        if ( (stringListener > 0) && (binaryListener > 0) ) {
          sprintf(cmd, "com_connection_info('%s', tcp, server, \
            [oaa_address(addr(tcp('%s',%d))), oaa_host('%s'), oaa_port(%d)], \
            connected)",
                  ConnectionId, hostString, stringPort,
                  hostString, stringPort);
          info = icl_NewTermFromString(cmd);

          if (info) {
            db_Assert(commdb, info, ICL_EMPTY);
            icl_Free(info);
          }
          else {
            printf("Error! %s:%i com_connection_info could not be constructed.\n", __FILE__, __LINE__);
          }
          res = TRUE;
        }
        else {
          if (!com_ask_about_tcp_exception(icl_Int(port),
                                           icl_NewStringFromTerm(host))) {
            icl_Free(connectionInfo);
            icl_Free(t1);
            icl_stFree(hostString);
            return FALSE;
          }
        }
      } while (!res);
    icl_Free(connectionInfo);
  }
  else {
    printf("Error! Bad arguments to com_ListenAt()\n");
            db_Assert(commdb, info, ICL_EMPTY);
  }
  icl_Free(t1);
  icl_stFree(hostString);
  return res;
} // end of com_ListenAt

/****************************************************************************
 * Utility functions for com_ListenAt
 ****************************************************************************/

void
com_print_tcp_exception_help() {
#ifdef _WINDOWS
#else
  printf("I've just attempted to listen on the specified port, but was unable\n");
  printf("to gain control of it.  This could be because there's already a\n");
  printf("Facilitator, or some other program, making use of that port.  Or, it\n");
  printf("could be that a Facilitator using that port was just terminated.  In\n");
  printf("such cases, the port may be inaccessible for a brief period (usually\n");
  printf("only a few seconds, but sometimes more).  It may help to kill any\n");
  printf("client agents which may still be connected to the defunct Facilitator.\n");

  printf("If you think the specified port may now be accessible, enter \"y\" and\n");
  printf("I'll try again.  You may request retry any number of times.\n");

  printf("If you want me to listen on a different port, enter \"n\", which will\n");
  printf("cause me to terminate.  Then change your port specification (it's\n");
  printf("either in a setup file or an environment variable).  Then restart me.\n");

#endif
}

int
com_ask_about_tcp_exception(int Port, char *Host) {

  char response[100];

  do {
    printf("Currently unable to access %s port %d.\n Try again? [y)es, n)o, h(elp] ", Host, Port);

    scanf("%s\n", (char *)(&response));

    if (strcmp(response,"y") == 0)
      return 1;
    else

      if (strcmp(response, "n") == 0)
        return 0;
      else

        if (strcmp(response, "h") == 0)
          com_print_tcp_exception_help();
  } while (TRUE);
}

int com_get_socket_from_connection_id(char* ConnectionId) {
  ICLTerm *info = NULL;
  int socketNumber = -1;

  /* DEBUG */
  /*
    if (commdb)
    db_PrintDB(commdb);
  */

  ICLTerm* requestTerm = icl_NewStruct("connection", 1, icl_NewVar("_"));
  if (ConnectionId && *ConnectionId && commdb &&
      com_GetInfo(ConnectionId, requestTerm, &info)) {
    icl_NthTermAsInt(info, 1, &socketNumber);
    icl_Free(info);
  }
  icl_Free(requestTerm);

  return socketNumber;
}

int basic_send(SOCKET inSocket, char *Data, int Size)
{
  int res = FALSE;

  /* send data */
  if (inSocket>0) {
#ifdef _WINDOWS  /* ---------------------------------------------------- */
    if (send(inSocket, Data, Size,0) == SOCKET_ERROR)
      res = -1;
#else
    res = (write(inSocket, Data, Size) == Size);
#endif  /* --------------------------------------------------------------- */
  }
  return res;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_SendData(char *ConnectionId, char *Data, int Size)
{
  int res = FALSE;
  int socketNumber = com_get_socket_from_connection_id(ConnectionId);

  /* send data */
  if (socketNumber>0) {
    char *buffer = (char*)malloc(Size+8);    /* count \0 too */
    sprintf(buffer,"term(%s).", Data);

    /* DEBUG */
    /*
      printDebug(5, "Sending %s\n", buffer);
    */

    basic_send(socketNumber, buffer, strlen(buffer));
    buffer[0] = 10;
    basic_send(socketNumber, buffer, 1);

    free(buffer);
  }
  return res;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_SendTerm(char* connectionId, ICLTerm* term)
{
  ICLTerm* result;
  ICLTerm* query = icl_NewStruct("sender", 1, icl_NewVar("_"));
  char* pointerStr;
  TermSender* ts;
  if(!com_GetInfo(connectionId, query, &result)) {
    icl_Free(query);
    return FALSE;
  }

  pointerStr = icl_Str(icl_NthTerm(result, 1));
  pointerStr = strdup(pointerStr);
  icl_stRemoveQuotes(pointerStr);
  ts = (TermSender*)stringToPointer(pointerStr);
  free(pointerStr);
  termSender_sendTerm(ts, term);
  if(termSender_getError(ts) != TERMSENDER_OKAY) {
    fprintf(stderr, "com_SendTerm(char*, ICLTerm*) did not send term\n");
    icl_Free(query);
    icl_Free(result);
    return FALSE;
  }
  icl_Free(query);
  icl_Free(result);
  return TRUE;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_AddInfo(char *ConnectionId, ICLTerm *NewInfo)
{
  ICLTerm *info = NULL, *result = NULL;
  char cmd[200];
  int changed = FALSE;
  int res = FALSE;

  /* Make sure there's a valid connection id */
  if (!ConnectionId || !*ConnectionId || !commdb)
    return FALSE;

  sprintf(cmd, "com_connection_info('%s', Protocol, Type,InfoList,Status)",
          ConnectionId);
  info = icl_NewTermFromString(cmd);

  if (db_Solve(commdb, info, ICL_EMPTY, &result)) {
    ICLTerm *ninfo = NULL, *item;
    ICLTerm *protocol, *type, *infolist, *status;
    ICLTerm* templateProtocol =  icl_NewStruct("protocol", 1, icl_NewVar("_"));
    ICLTerm* templateStatus =  icl_NewStruct("status", 1, icl_NewVar("_"));
    ICLTerm* templateType =  icl_NewStruct("type", 1, icl_NewVar("_"));

    db_Retract(commdb, info, ICL_EMPTY);
    item = icl_NthTerm(result, 1);

    if (icl_Unify(templateProtocol, NewInfo, NULL)) {
      protocol = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else protocol = icl_NthTerm(item, 2);

    if (icl_Unify(templateType, NewInfo, NULL)) {
      type = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else type = icl_NthTerm(item, 3);

    if (icl_Unify(templateStatus, NewInfo, NULL)) {
      status = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else status = icl_NthTerm(item, 5);

    if (!changed) {
      if (icl_IsList(NewInfo)) {
        ICLListType *p = icl_List(NewInfo);
        while (p) {
          icl_AddToList(icl_NthTerm(item, 4), icl_CopyTerm(p->elt), TRUE);
          p = p->next;
        }
      }
      else
        icl_AddToList(icl_NthTerm(item, 4), icl_CopyTerm(NewInfo), TRUE);
    }
    infolist = icl_NthTerm(item, 4);

    ninfo = icl_NewStruct("com_connection_info", 5, icl_NewStr(ConnectionId),
                          icl_CopyTerm(protocol), icl_CopyTerm(type),
                          icl_CopyTerm(infolist), icl_CopyTerm(status));

    db_Assert(commdb, ninfo, ICL_EMPTY);

    icl_Free(ninfo);
    icl_Free(result);
    icl_Free(templateProtocol);
    icl_Free(templateStatus);
    icl_Free(templateType);
    res = TRUE;
  }
  else {
    res = FALSE;
  }
  icl_Free(info);
  return res;
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_RemoveInfo(char *connectionId, ICLTerm *toMatch)
{
  ICLTerm *info = NULL, *result = NULL;
  char cmd[200];
  int res = FALSE;

  /* Make sure there's a valid connection id */
  if (!connectionId || !*connectionId || !commdb)
    return FALSE;
  sprintf(cmd, "com_connection_info('%s', Protocol, Type,InfoList,Status)",
          connectionId);
  info = icl_NewTermFromString(cmd);

  if (db_Solve(commdb, info, ICL_EMPTY, &result)) {
    ICLTerm *ninfo = NULL, *item;
    ICLTerm *protocol, *existingList, *type, *status;

    db_Retract(commdb, info, ICL_EMPTY);
    item = icl_NthTerm(result, 1);

    protocol = icl_NthTerm(item, 2);
    type = icl_NthTerm(item, 3);
    status = icl_NthTerm(item, 5);

    existingList = icl_NthTerm(item, 4);
    if (icl_IsList(toMatch)) {
      ICLListType *p;
      for(p = icl_List(toMatch); p; p = p->next) {
        ICLTerm* unifier = icl_GenerateSimpleUnifyingTerm(p->elt);
        icl_RemoveUnifyingFromList(existingList, unifier, TRUE);
        icl_FreeTerm(unifier);
      }
    }
    else {
      ICLTerm* unifier = icl_GenerateSimpleUnifyingTerm(toMatch);
      icl_RemoveUnifyingFromList(existingList, unifier, TRUE);
      icl_FreeTerm(unifier);
    }

    ninfo = icl_NewStruct("com_connection_info", 5, icl_NewStr(connectionId),
                          icl_CopyTerm(protocol), icl_CopyTerm(type),
                          icl_CopyTerm(existingList), icl_CopyTerm(status));

    db_Assert(commdb, ninfo, ICL_EMPTY);

    icl_Free(ninfo);
    icl_Free(result);
    res = TRUE;
  }
  else {
    res = FALSE;
  }
  icl_Free(info);
  return res;
  
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_UpdateInfo(char *ConnectionId, ICLTerm *NewInfo)
{
  ICLTerm *info = NULL, *result = NULL;
  char cmd[200];
  int changed = FALSE;
  int res = FALSE;

  /* Make sure there's a valid connection id */
  if (!ConnectionId || !*ConnectionId || !commdb)
    return FALSE;
  sprintf(cmd, "com_connection_info('%s', Protocol, Type,InfoList,Status)",
          ConnectionId);
  info = icl_NewTermFromString(cmd);

  if (db_Solve(commdb, info, ICL_EMPTY, &result)) {
    ICLTerm *ninfo = NULL, *item;
    ICLTerm *protocol, *existingList, *type, *status;
    ICLTerm* templateProtocol =  icl_NewStruct("protocol", 1, icl_NewVar("_"));
    ICLTerm* templateStatus =  icl_NewStruct("status", 1, icl_NewVar("_"));
    ICLTerm* templateType =  icl_NewStruct("type", 1, icl_NewVar("_"));

    db_Retract(commdb, info, ICL_EMPTY);
    item = icl_NthTerm(result, 1);

    if (icl_Unify(templateProtocol, NewInfo, NULL)) {
      protocol = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else protocol = icl_NthTerm(item, 2);

    if (icl_Unify(templateType, NewInfo, NULL)) {
      type = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else type = icl_NthTerm(item, 3);

    if (icl_Unify(templateStatus, NewInfo, NULL)) {
      status = icl_NthTerm(NewInfo, 1);
      changed = TRUE;
    }
    else status = icl_NthTerm(item, 5);

    existingList = icl_NthTerm(item, 4);
    if (!changed) {
      if (icl_IsList(NewInfo)) {
        ICLListType *p;
        for(p = icl_List(NewInfo); p; p = p->next) {
          ICLTerm* unifier = icl_GenerateSimpleUnifyingTerm(p->elt);
          int numReplaced = icl_ReplaceUnifying(existingList, unifier, p->elt, TRUE);

          if(numReplaced < 1) {
            icl_AddToList(existingList, icl_CopyTerm(p->elt), TRUE);
          }
          icl_FreeTerm(unifier);
        }
      }
      else {
        ICLTerm* unifier = icl_GenerateSimpleUnifyingTerm(NewInfo);
        int numReplaced = icl_ReplaceUnifying(existingList, unifier, NewInfo, TRUE);
        if(numReplaced < 1) {
          icl_AddToList(existingList, icl_CopyTerm(NewInfo), TRUE);
        }
        icl_FreeTerm(unifier);
      }
    }

    ninfo = icl_NewStruct("com_connection_info", 5, icl_NewStr(ConnectionId),
                          icl_CopyTerm(protocol), icl_CopyTerm(type),
                          icl_CopyTerm(existingList), icl_CopyTerm(status));

    db_Assert(commdb, ninfo, ICL_EMPTY);

    icl_Free(ninfo);
    icl_Free(result);
    icl_Free(templateProtocol);
    icl_Free(templateStatus);
    icl_Free(templateType);
    res = TRUE;
  }
  else {
    res = FALSE;
  }
  icl_Free(info);
  return res;
}

static void com_getMatchingInfos(ICLTerm const*info, ICLTerm **result)
{
  ICLTerm* allMatcher = icl_NewStruct("com_connection_info", 5, icl_NewVar("_"), icl_NewVar("_"), icl_NewVar("_"), icl_NewVar("_"), icl_NewVar("_"));
  ICLTerm* allMatches = NULL;
  *result = icl_NewList(NULL);
  if(db_Solve(commdb, allMatcher, ICL_EMPTY, &allMatches)) {
    // each entry in allMatches is a com_connection_info struct, and we need to check for the
    // the presence of things that unify with the given ICLTerm* info
    ICLListType* listElem;
    for(listElem = icl_List(allMatches); listElem; listElem = icl_ListNext(listElem)) {
      if(icl_Member(info, icl_NthTerm(icl_ListElt(listElem), 4), NULL)) {
        icl_AddToList(*result, icl_CopyTerm(icl_ListElt(listElem)), FALSE);
      }
    }
    icl_Free(allMatches);
  }
  icl_Free(allMatcher);
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_GetInfo(char *ConnectionId, ICLTerm *GInfo, ICLTerm **Result)
{
  ICLTerm *info = NULL, *result = NULL;
  char cmd[200];
  int res = FALSE;

  /* DEBUG */
  /* printf("Comm get info for %s\n", icl_NewStringFromTerm(GInfo));*/


  /* Make sure there's a valid connection id */
  if (!ConnectionId || !*ConnectionId || !commdb)
    return FALSE;

  sprintf(cmd, "com_connection_info(%s, Protocol, Type,InfoList,Status)",
          ConnectionId);
  info = icl_NewTermFromString(cmd);

  if (db_Solve(commdb, info, ICL_EMPTY, &result)) {

    ICLTerm *item = NULL;
    ICLTerm* templateProtocol =  icl_NewStruct("protocol", 1, icl_NewVar("_"));
    ICLTerm* templateStatus =  icl_NewStruct("status", 1, icl_NewVar("_"));
    ICLTerm* templateType =  icl_NewStruct("type", 1, icl_NewVar("_"));

    /* DEBUG */
    /* printf("Result from solve %s\n", icl_NewStringFromTerm(result));*/

    res = TRUE;
    item = icl_NthTerm(result, 1);

    if (icl_Unify(templateProtocol, GInfo, NULL)) {
      if (Result!=NULL) {
        *Result = icl_CopyTerm(icl_NthTerm(item, 2));
      }
      res = TRUE;
    }
    else if (icl_Unify(templateStatus, GInfo, NULL)){
      if (Result!=NULL) {
  *Result = icl_CopyTerm(icl_NthTerm(item, 5));
      }
      res = TRUE;
    }
    else if (icl_Unify(templateType, GInfo, NULL)){
      if (Result!=NULL) {
  *Result = icl_CopyTerm(icl_NthTerm(item, 3));
      }
      res = TRUE;
    }
    else if (Result!=NULL) {
      ICLTerm* tempList = icl_NthTerm(item, 4);
      /* printf("List %s\n", icl_NewStringFromTerm(tempList)); */
      res = icl_Member(GInfo, tempList, Result);
    }

    icl_Free(templateProtocol);
    icl_Free(templateStatus);
    icl_Free(templateType);
    icl_Free(result);
  }
  else {
    res = FALSE;
  }
  icl_Free(info);

  return res;
}


EXPORT_MSCPP
int EXPORT_BORLAND
com_GetConnectionId(char **ConnectionId, ICLTerm *GInfo)
{
  static ICLTerm *info = NULL;
  ICLTerm *result = NULL;
  int res = FALSE;

  if (!icl_IsValid(info)) {
    info = icl_NewTermFromData("com_connection_info(ConnectionId,Protocol,Type,InfoList,Status)",63);
  }

  /*
   * Retrieve all connection_info terms from the db
   */
  if (db_Solve(commdb, info, ICL_EMPTY, &result)) {

    ICLListType *reslist = icl_List(result);

    while(reslist != NULL) {
      ICLTerm *current = reslist->elt;
      ICLTerm *infolist = icl_NthTerm(current, 4);
      reslist = reslist->next;

      /*
       * check for the various types of info to match against
       */
      if(icl_ParamValue(icl_Functor(GInfo), icl_NthTerm(GInfo, 1),
                        infolist, NULL)) {
        *ConnectionId = strdup(icl_Str(icl_NthTerm(current, 1)));
        res = TRUE;
        break;
      }
    }
    icl_Free(result);
    /* Free reslist */
  }
  return res;
} // end of com_GetConnectionId

/*
 * name:    com_SelectEvent
 * purpose:
 * remarks:
 * returns: True if success
 * @deprecated use com_SelectEventFromAllIds
 */
EXPORT_MSCPP
int EXPORT_BORLAND
com_SelectEvent(char* inConnectionId, double timeout, ICLTerm **event){
  ICLTerm* readerTerm;
  ICLTerm* query;
  TermReader* reader;
  char* readerString;

  query = icl_NewTermFromData("reader(_)",9);
  if(!com_GetInfo(inConnectionId, query, &readerTerm)) {
    icl_Free(query);
    fprintf(stderr, "com_SelectEvent could not find reader\n");
    return FALSE;
  }
  readerString = icl_Str(icl_NthTerm(readerTerm, 1));
  readerString = strdup(readerString);
  icl_stRemoveQuotes(readerString);
  reader = (TermReader*)stringToPointer(readerString);
  free(readerString);
  *event = termReader_getNextTerm(reader, timeout);
  icl_Free(query);
  icl_Free(readerTerm);
  if(*event == NULL) {
    int te = termReader_getError(reader);
    fprintf(stderr, "com_SelectEvent error in reading term: %i\n", te);
    return FALSE;
  }
  else {
    return TRUE;
  }
}

EXTERN void comPrintError(char *str, ...) {
  char buf[512];
  va_list ptr;
  va_start(ptr,str);
  vsprintf(buf,str,ptr);
  printf("COM ERROR : %s\n",  buf);
  va_end(ptr);
}

/****************************************************************************
 * Definitions for MICROSOFT WINDOWS Specific functions
 ****************************************************************************/

#ifdef _WINDOWS   /*---------------------------------------------------*/

int EXPORT_MSCPP tcpStartup()
{
  WORD wVersionRequested;
  WSADATA wsaData;

  /* Asking for version 1.1 */
  wVersionRequested=MAKEWORD(1,1);

  if (WSAStartup(wVersionRequested,&wsaData)!=0)
    return (0);

  if (LOBYTE(wsaData.wVersion)!=1 ||
      HIBYTE(wsaData.wVersion)!=1) {
    WSACleanup();
    return(0);
  }

  return(1);
}

void EXPORT_MSCPP tcpTestDLL(void)
{
  MessageBox(NULL, "Testing, one ,two, ...", "TCP Dll", MB_OK);
}

#endif /* _WINDOWS */

/****************************************************************************
 * General definitions
 ****************************************************************************/

void tcpShutdown(SOCKET socket) {
  shutdown(socket,2);
#ifdef _WINDOWS
  shutdown(socket, 0);
#else
  close(socket);
#endif
}

struct hostent* getHostEntry(char const* hostName)
{
  struct hostent* he = gethostbyname(hostName);
  u_long addr;
  if (!he) {
    addr = inet_addr(hostName);
    if ((int)addr != -1) {
      he = gethostbyaddr((char *)&addr, sizeof(u_long), AF_INET);
    }
  }

  return he;
}

SOCKET tcpConnect(char *hostName, int port)
{
  SOCKET s;
  int ret;
  struct sockaddr_in saddr;
  struct hostent *he;

  he = getHostEntry(hostName);
  if (!he) {
    printf("TCP - Could not resolve host: %s\n", hostName);
    return -1;
  }

  ret = socket(AF_INET, SOCK_STREAM, 0);

  if (ret < 0) {
    printf("TCP - Could not create socket.\n");
    return -1;
  }
  else s = ret;


#ifndef _WINDOWS
  memset((char*)&saddr, 0, sizeof(saddr));
  memcpy((char*)&saddr.sin_addr.s_addr, he->h_addr, he->h_length);
  memset(&(saddr.sin_zero), '\0', 8);
#else
  memcpy((char FAR *) &saddr.sin_addr, (char FAR *)he->h_addr, he->h_length);
#endif

  saddr.sin_family = AF_INET;
  saddr.sin_port = htons(port);

  if (connect(s, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
    printf("TCP - Could not connect to %s #%d\n", hostName,port);
    perror("Reason");
    tcpShutdown(s);
    return -1;
  }

  return s;
}


int tcpSelect(SOCKET socket, double timeout) {

  struct timeval  time, *timep = NULL;
#ifndef _WINDOWS
  struct timezone timezone;
#endif

  int width;
  fd_set readfds;

  if (timeout > 0) {
#ifndef _WINDOWS
    if(gettimeofday(&time, &timezone) == -1)
      printf("TCP - error getting time of data\n");
    else {
#endif
      long i;
      i = (long)timeout;        /* Convert double to integer, loss of data ! */
      time.tv_sec = i;    /* Add number of seconds to current time */
      time.tv_usec = 0.5 + (timeout - i) * 1e6;  /* Add fractional msecs */
      timep = &time;
#ifndef _WINDOWS
    }
#endif
  }

  width = socket + 1;          /* Width must include current fd   */
  FD_ZERO(&readfds);           /* Clear fds                       */
  FD_SET(socket, &readfds);    /* Add file descriptor to read set */

  return select(width, &readfds, NULL, NULL, timep);
}

EXPORT_MSCPP
char * EXPORT_BORLAND
com_GetDefaultConnectionId()
{
  static ICLTerm *info = NULL;
  ICLTerm *answers = NULL;
  char *result = NULL;

  if (!icl_IsValid(info)) {
    info = icl_NewTermFromData(
      "com_connection_info(Id,Protocol,Type,InfoList,Status)",53);
  }

  /* Make sure there's a valid database */
  if (!commdb)
    return NULL;

  if (db_Solve(commdb, info, ICL_EMPTY, &answers)) {
    ICLTerm *item = icl_NthTerm(answers, 1);
    result = strdup(icl_Str(icl_NthTerm(item, 1)));
  }
  icl_Free(answers);
  return result;
}

EXPORT_MSCPP
void EXPORT_BORLAND
cnx_CanonicalAddress(ICLTerm *address, SOCKET socket, ICLTerm **result)
{
  ICLTerm *addressStruct = icl_NewTermFromData("tcp(Host,Port)",14);

  if (icl_Unify(addressStruct, address, NULL) && (socket>0)) {
    struct sockaddr_in* ptr_distaddr;
    struct sockaddr distaddr;
    int remotePortNumber = -1;
    char remoteHostName[255];

#ifdef _WINDOWS
    int addrlen = sizeof(distaddr);
#else
    socklen_t addrlen = sizeof(distaddr);
#endif

    sprintf(remoteHostName, "unknown");
    ptr_distaddr = (struct sockaddr_in *)&(distaddr);

    if (getpeername(socket, &distaddr, &addrlen)==0) {

      /* HACK
         ptr_distaddr->sin_port does not work under windows !
         #ifndef _WINDOWS
         remotePortNumber = ptr_distaddr->sin_port;
         #else
         remotePortNumber = icl_Int(icl_NthTerm(address, 2));
         #endif
      */
      remotePortNumber = icl_Int(icl_NthTerm(address, 2));

      /* To get the host name */
      /*
        disthost=gethostbyaddr((const void*)(&ptr_distaddr->sin_addr), 4, AF_INET);
        if (disthost)
        sprintf(remoteHostName,"%s",disthost->h_name);
      */
      /* To get the IP number */
      sprintf(remoteHostName,"%s",inet_ntoa(ptr_distaddr->sin_addr));


      if (result!=NULL)
        *result = icl_NewStruct("addr", 1,
                                icl_NewStruct("tcp", 2,
                                              icl_NewStr(remoteHostName),
                                              icl_NewInt(remotePortNumber)));

    }
    else {
      comPrintError("%s",
                    "cnx_CanonicalAddress() can only be called on CONNECTED socket!");
    }
  }
  icl_Free(addressStruct);
}

/* -------------------------------------------------------------------------- */

// new functions added to support direct_connect

static void checkEventBuffer() {
  if (eventBuffer == NULL) {
    eventBuffer = icl_NewList(NULL);
  }
} // end of checkEventBuffer(

static void com_accept_new_connection(int listenersocket) {
  int connection = -1;
  char* namestring = NULL;
  ICLTerm *readerInfo = NULL;
  ICLTerm *senderInfo = NULL;
  ICLTerm *ev_conn = NULL;

  connection = accept(listenersocket, NULL, NULL);

  if (connection > 0) {
    ICLTerm *canonicalOtherAddress = NULL;
    ICLTerm *newConnectionInfo = NULL;
    ICLTerm *tempList = icl_NewList(NULL);
    char *ConnectionId = new_direct_client_id();
    ICLTerm *templateTcpAddr = icl_NewTermFromData("tcp(Host,Port)",14);
    char buf[1000];

    memset(buf, 0, sizeof(buf));
    cnx_CanonicalAddress(templateTcpAddr, connection, &canonicalOtherAddress);

    icl_AddToList(tempList, icl_NewStruct("other_address", 1, canonicalOtherAddress), FALSE);
    icl_AddToList(tempList, icl_NewStruct("connection", 1, icl_NewInt(connection)),FALSE);

    {
      TermReader* realTr = NULL;
      TermSender* realTs = NULL;
      char* readerPtr;
      char* readerInfoBuf;
      char* senderPtr;
      char* senderInfoBuf;

      if (com_is_binary_listener(listenersocket)) {
        BinaryTermReader* btr;
        BinaryTermSender* bts;
        realTr = termReader_create();
        btr = binaryTermReader_create(realTr, connection);
        realTs = termSender_create();
        bts = binaryTermSender_create(realTs, connection);
      }
      else {
        StringTermReader* str;
        StringTermSender* sts;
        realTr = termReader_create();
        str = stringTermReader_create(realTr, connection);
        realTs = termSender_create();
        sts = stringTermSender_create(realTs, connection);
      }

      readerPtr = pointerToString(realTr);
#ifdef NORMAL_GC
      /* so we don't lose the pointer */
      /*
      if(termReaders == NULL) {
        termReaders = g_ptr_array_new();
      }
      g_ptr_array_add(termReaders, realTr);
      */
      termReaders[++termReadersIdx] = realTr;
#endif
      readerInfoBuf = (char*)malloc(strlen(readerPtr) + 10 + 1);
      strncpy(readerInfoBuf, "reader('", 8);
      strncpy(readerInfoBuf + 8, readerPtr, strlen(readerPtr));
      readerInfoBuf[strlen(readerPtr) + 8] = '\'';
      readerInfoBuf[strlen(readerPtr) + 9] = ')';
      readerInfoBuf[strlen(readerPtr) + 10] = '\0';
      readerInfo = icl_NewTermFromString(readerInfoBuf);
      free(readerPtr);
      free(readerInfoBuf);
      senderPtr = pointerToString(realTs);
#ifdef NORMAL_GC
      /* so we don't lose the pointer */
      /*
      if(termSenders == NULL) {
        termSenders = g_ptr_array_new();
      }
      g_ptr_array_add(termSenders, realTs);
      */
      termSenders[++termSendersIdx] = realTs;
#endif
      senderInfoBuf = (char*)malloc(strlen(senderPtr) + 10 + 1);
      strncpy(senderInfoBuf, "sender('", 8);
      strncpy(senderInfoBuf + 8, senderPtr, strlen(senderPtr));
      senderInfoBuf[strlen(senderPtr) + 8] = '\'';
      senderInfoBuf[strlen(senderPtr) + 9] = ')';
      senderInfoBuf[strlen(senderPtr) + 10] = '\0';
      senderInfo = icl_NewTermFromString(senderInfoBuf);
      free(senderPtr);
      free(senderInfoBuf);
    }

    icl_AddToList(tempList, readerInfo, FALSE);
    icl_AddToList(tempList, senderInfo, FALSE);

    newConnectionInfo = icl_NewStruct("com_connection_info", 5,
                                      icl_NewStr(ConnectionId),
                                      icl_NewStr("tcp"),
                                      icl_NewStr("client"),
                                      tempList,
                                      icl_NewStr("connected"));

    if (newConnectionInfo) {
     db_Assert(commdb, newConnectionInfo, ICL_EMPTY);
     icl_Free(newConnectionInfo);
    }
    else {
     printf("Error! %s:%i com_connection_info could not be constructed.\n", __FILE__, __LINE__);
    }

    {
    ICLTerm *ConnEvent = NULL;
    ICLTerm *EventTerm = NULL;
    ICLTerm *t1   = NULL;
    // Get the connection acknowledgement from the same ConnectionId.
    // A timeout of 0.0 means we'll block on this socket.
    com_select_event_from_socket(connection, 0.0, &EventTerm);

    ConnEvent = icl_NthTerm(icl_NthTerm(EventTerm, 1), 1);

    if (!icl_Unify(ConnEvent,
                  (t1 = icl_NewStruct("ev_connect",
                                      1,
                                      icl_NewVar("_"))),
                   NULL)) {
      fprintf(stderr, "Warning in com_accept_new_connection: ");
      fprintf(stderr, "Expected ev_connect, got %s\n", icl_Functor(ConnEvent));
      fflush(stderr);
    }
    icl_Free(t1);
    icl_Free(EventTerm);
   }

    namestring = oaa_name_string();
    sprintf(buf, "event(ev_connected([other_name('%s'), "
                 "other_language(c), other_type(client), "
                 "other_version(%s), ascii(%d), binary(%d)]),[])",
                 namestring, oaa_library_version_str,
                 stringPort, binaryPort);
    icl_stFree(namestring);

    ev_conn = icl_NewTermFromString(buf);
    com_SendTerm(ConnectionId, ev_conn);
    icl_Free(ev_conn);
    icl_Free(templateTcpAddr);
    free(ConnectionId);
  }

} // end of com_accept_new_connection

static int com_add_event_to_buffer(ICLTerm *event) {
  int answer = FALSE;
  checkEventBuffer();
  // add to end of list
  answer = icl_AddToList(eventBuffer, event, TRUE);
  return answer;
} //end of com_add_event_to_buffer

static int com_disconnect_all_connection_ids() {
  int answer = TRUE;
  ICLTerm *cids = NULL;
  ICLListType *cidslist = NULL;
  com_find_all_connection_ids(&cids);
  cidslist = icl_List(cids);
  while (icl_ListHasMoreElements(cidslist)) {
    char *cid = icl_Str(icl_ListElement(cidslist));
    if (cid != NULL) {
      answer = com_Disconnect(cid) && answer;
    }
    cidslist = icl_ListNextElement(cidslist);
  }
  icl_Free(cids);
  return answer;
} // end of com_disconnect_from_all_connection_ids


static int com_find_all_connected_sockets(ICLTerm *ids, ICLTerm **sockets) {
  int numberOfSockets = 0;
  ICLListType *idlist = icl_List(ids);
  *sockets = icl_NewList(NULL);
  while(icl_ListHasMoreElements(idlist)) {
    char *id = icl_Str(icl_ListElement(idlist));
    int socket = com_get_socket_from_connection_id(id);
    if (socket > 0) {
      icl_AddToList(*sockets, icl_NewInt(socket), TRUE);
      numberOfSockets++;
    }
    idlist = icl_ListNextElement(idlist);
  }
  return numberOfSockets;
} // end of com_find_all_connected_sockets


static int com_find_all_connection_ids(ICLTerm **ids) {
  int answer = FALSE;
  ICLTerm *result = NULL;
  ICLListType *resultlist;
  static ICLTerm *info = NULL;

  if (!icl_IsValid(info)) {
    info = icl_NewTermFromData(
      "com_connection_info(ConnectionId,Protocol,Type,InfoList,Status)",63);
  }

  if ( (answer = db_Solve(commdb, info, ICL_EMPTY, &result)) ) {
    resultlist = icl_List(result);
    *ids = icl_NewList(NULL);
    while(icl_ListHasMoreElements(resultlist)) {
      ICLTerm *item = icl_ListElement(resultlist);
      ICLTerm *id = icl_NthTerm(item,1);
      icl_AddToList(*ids, icl_CopyTerm(id), FALSE);
      resultlist = icl_ListNextElement(resultlist);
    }
  }
  icl_Free(result);
  return answer;
} // end of com_find_all_connection_ids

static char* com_get_connection_id_from_socket(int socket) {
  char *answer = NULL;
  ICLTerm *cids = NULL;
  ICLListType *cidslist = NULL;
  com_find_all_connection_ids(&cids);
  cidslist = icl_List(cids);
  while (icl_ListHasMoreElements(cidslist)) {
    char *cid = icl_Str(icl_ListElement(cidslist));
    if (socket == com_get_socket_from_connection_id(cid)) {
      answer = strdup(cid);
      break;
    }
    cidslist = icl_ListNextElement(cidslist);
  }
  icl_Free(cids);
  return answer;
} // end of com_get_connection_id_from_socket

EXPORT_MSCPP
int EXPORT_BORLAND
com_GetEventFromConnection(char *ConnectionId, double timeout, ICLTerm **event) {
  int socketNumber = com_get_socket_from_connection_id(ConnectionId);
  return com_select_event_from_socket(socketNumber, timeout, event);
} // end of com_GetEventFromConnection

static char *com_get_localhost_ip_address(void) {
    struct hostent *h = NULL;
    char name[MAXHOSTNAMELEN + 1];

    if ( (gethostname(name, sizeof(name)) != 0) ||
         ((h = gethostbyname(name)) == NULL) ) {
      fprintf(stderr,"Warning: could not determine address for localhost\n");
      return NULL;
    }
   return strdup(inet_ntoa(*((struct in_addr *) *(h->h_addr_list))));
}

static int com_is_binary_listener(int socket) {
  return (socket == binaryListener);
} // end of com_is_binary_listener

static int com_is_listening() {
  return stringListener > 0;
} // end of com_is_listening



static int com_read_events_into_buffer(double timeout) {
  int numberOfEventsAdded = 0;
  ICLTerm *ids = NULL;
  ICLTerm *connectedSockets = NULL;
  ICLListType *connectedSocketList = NULL;

  struct timeval  time;
  struct timeval* timep = NULL;
  int width = 0;
  fd_set read_set;

  // timeout = 0.0 means select should block
  if(timeout == 0 || timeout > 1) {
    time.tv_sec = 1;
    time.tv_usec = 0;
    timep = &time;
  }
  else if(timeout > 0) {
    long i = (long)floor(timeout);
    time.tv_sec = i;
    time.tv_usec = (long)floor((timeout - i) * 1e6);
    timep = &time;
  }

  FD_ZERO(&read_set);

  // if we have listener sockets, add them to the fd_set
  if (com_is_listening()) {
    FD_SET(stringListener, &read_set);
    FD_SET(binaryListener, &read_set);
  }

  com_find_all_connection_ids(&ids);
  com_find_all_connected_sockets(ids, &connectedSockets);
  connectedSocketList = icl_List(connectedSockets);

  // add connected sockets to fd_set
  while(icl_ListHasMoreElements(connectedSocketList)) {
    int socket = icl_Int(icl_ListElement(connectedSocketList));
    FD_SET(socket, &read_set);
    width = MAX(width, socket+1);
    connectedSocketList = icl_ListNextElement(connectedSocketList);
  }

  if (select(width, &read_set, NULL, NULL, timep) <= 0) {
    // nothing to do...clean up and return
    icl_Free(ids);
    icl_Free(connectedSockets);
    return 0;
  }

  if (com_is_listening()) {
    // handle requests to connect, if any
    if (FD_ISSET(stringListener, &read_set)) {
      com_accept_new_connection(stringListener);
      FD_CLR(stringListener, &read_set);
    }

    if (FD_ISSET(binaryListener, &read_set)) {
      com_accept_new_connection(binaryListener);
      FD_CLR(stringListener, &read_set);
    }
  }

  // check connected sockets
  connectedSocketList = icl_List(connectedSockets);
  while(icl_ListHasMoreElements(connectedSocketList)) {
    int socket = icl_Int(icl_ListElement(connectedSocketList));

    // read incoming events to the eventbuffer
    if (FD_ISSET(socket, &read_set)) {
      ICLTerm *event = NULL;
      double totalTime = 0;
      while(((timeout == 0) || (totalTime < timeout)) &&
            com_select_event_from_socket(socket, 0.01, &event)) {
        com_add_event_to_buffer(event);
        ++numberOfEventsAdded;
        totalTime += 0.01;
        if(icl_IsStruct(event) &&
           (icl_NumTerms(event) == 1) &&
           (strcmp(icl_Functor(event), "event") == 0)) {
          ICLTerm* firstArg = icl_NthTerm(event, 1);
          if(icl_IsStr(firstArg) &&
             (strcmp(icl_Str(firstArg), "timeout") == 0)) {
            break;
          }
        }
      }
    }
    connectedSocketList = icl_ListNextElement(connectedSocketList);
  }

  icl_Free(ids);
  icl_Free(connectedSockets);
  return numberOfEventsAdded;
} // end of com_read_events_into_buffer

static int com_select_event_from_buffer(ICLTerm **event) {
  ICLListType *eventList = NULL;

  // bail quickly if buffer is empty
  checkEventBuffer();
  if (icl_ListLen(eventBuffer) == 0 ) {
    *event = NULL;
    return FALSE;
  }

  // select and remove from the head of the list...
  eventList = icl_List(eventBuffer);
  *event = eventList->elt;
  eventBuffer->p = eventList->next;
#ifdef NORMAL_GC
  memset(eventList, 0, sizeof(ICLListType));
#endif
  free(eventList);

  return TRUE;
} // end of com_select_event_from_buffer

static int com_select_event_from_socket(int socketNumber, double timeout, ICLTerm **event){
  ICLTerm* readerTerm;
  ICLTerm* query;
  TermReader* reader;
  char* readerString;
  char *inConnectionId;
  inConnectionId = com_get_connection_id_from_socket(socketNumber);
  query = icl_NewStruct("reader", 1, icl_NewVar("_"));
  if(!com_GetInfo(inConnectionId, query, &readerTerm)) {
    icl_Free(query);
    fprintf(stderr, "com_select_event_from_socket could not find reader\n");
    icl_stFree(inConnectionId);
    return FALSE;
  }
  readerString = icl_Str(icl_NthTerm(readerTerm, 1));
  readerString = strdup(readerString);
  icl_stRemoveQuotes(readerString);
  reader = (TermReader*)stringToPointer(readerString);
  free(readerString);
  CHECK_LEAKS();
  *event = termReader_getNextTerm(reader, timeout);
  CHECK_LEAKS();
  icl_Free(query);
  icl_Free(readerTerm);
  if(*event == NULL) {
    int te = termReader_getError(reader);
    // print an error message if it is not an "ordinary" error
    if ( (te != TERMREADER_OKAY) &&
         (te != TERMREADER_TIMEOUT) &&
         (te != TERMREADER_READERR) &&
         (te != TERMREADER_NOCONN) ) {
      fprintf(stderr,
        "com_select_event_from_socket error in reading term: %i\n", te);
    }
    // disconnect if it was not a timeout error
    if ( (te != TERMREADER_OKAY) &&
         (te != TERMREADER_TIMEOUT) ) {
      com_Disconnect(inConnectionId);
//      fprintf(stderr, "disconnected connection_id: %s socket: %d\n",
//              inConnectionId, socketNumber);fflush(stderr);
    }
    icl_stFree(inConnectionId);
    return FALSE;
  }
  else {
    // if present, copy connection id into params (for direct_connect)
    if (!strcmp(icl_Functor(*event),"term")) {
      ICLTerm *CID = icl_NewStruct("connection_id",1,icl_NewStr(inConnectionId));
      if (icl_NumTerms(*event) == 1) {
        icl_AddToList(icl_NthTerm(icl_NthTerm(*event,1),2), CID, TRUE);
      }
      else if (icl_NumTerms(*event) == 2) {
        icl_AddToList(icl_NthTerm(icl_NthTerm(*event,2),2), CID, TRUE);
      }
    }
    icl_stFree(inConnectionId);
    return TRUE;
  }
} // end of com_select_event_from_socket

static ICLTerm* initiatedTerm = NULL;
static void sendHeartbeats()
{
  ICLTerm* initiatedConnections = NULL;
  ICLListType* listElem;

  if(!initiatedTerm) {
    initiatedTerm = icl_NewStruct("initiated", 1, icl_NewStr("true"));
  }

  com_getMatchingInfos(initiatedTerm, &initiatedConnections);

  for(listElem = icl_List(initiatedConnections); listElem; listElem = icl_ListNext(listElem)) {
    char* connectionId = icl_Str(icl_NthTerm(icl_ListElt(listElem), 1));
    if(oaa_SupportsSequenceNumbers(connectionId)) {
      ICLTerm* heartbeatEvent = icl_NewStruct("event", 2, icl_NewStr("ev_heartbeat"), icl_NewList(NULL));
      com_SendTerm(connectionId, heartbeatEvent);
      icl_Free(heartbeatEvent);
    }
  }

  icl_Free(initiatedConnections);
}

static void checkForFailedHeartbeats()
{
  ICLTerm* initiatedConnections = NULL;
  ICLListType* listElem;
  GTimeVal now;
  glong nowSec;

  g_get_current_time(&now);
  nowSec = now.tv_sec;

  com_getMatchingInfos(initiatedTerm, &initiatedConnections);

  for(listElem = icl_List(initiatedConnections); listElem; listElem = icl_ListNext(listElem)) {
    ICLTerm* lastHeartbeat = NULL;
    ICLTerm* infoList = icl_NthTerm(icl_ListElt(listElem), 4);
    if(!icl_ParamValue("last_heartbeat", NULL, infoList, &lastHeartbeat)) {
      continue;
    }
    else {
      char* connectionId = icl_Str(icl_NthTerm(icl_ListElt(listElem), 1));
      glong prevHeartbeatSec = icl_Int(icl_NthTerm(lastHeartbeat, 1));
      if(nowSec - prevHeartbeatSec > HEARTBEAT_TIMEOUT) {
        ICLTerm* socketTerm;
        int socket;
        if(!icl_ParamValue("connection", NULL, infoList, &socketTerm)) {
          fprintf(stderr, "Unable to determine socket for failed connection %s\n", connectionId);
          return;
        }
        if(!(socket = icl_Int(icl_NthTerm(socketTerm, 1)))) {
          char* socketTermString = icl_NewStringFromTerm(socketTerm);
          fprintf(stderr, "Unable to determine socket from socket term %s\n", socketTermString);
          icl_stFree(socketTermString);
          return;
        }
        close_socket(socket);
        {
          ICLTerm* senderQuery = icl_NewStruct("sender", 1, icl_NewVar("_"));
          ICLTerm* senderTerm = NULL;
          if(!com_GetInfo(connectionId, senderQuery, &senderTerm)) {
            fprintf(stderr, "Unable to find sender pointer for connection %s\n", connectionId);
          }
          if(senderTerm) {
            char *pointerStr = strdup(icl_Str(icl_NthTerm(senderTerm, 1)));
            TermSender* ts;
            icl_stRemoveQuotes(pointerStr);
            ts = (TermSender*)stringToPointer(pointerStr);
            free(ts);
            free(pointerStr);
            com_RemoveInfo(connectionId, senderQuery);
          }
          icl_Free(senderQuery);
        }
        {
          ICLTerm* readerQuery = icl_NewStruct("reader", 1, icl_NewVar("_"));
          ICLTerm* readerTerm = NULL;
          if(!com_GetInfo(connectionId, readerQuery, &readerTerm)) {
            fprintf(stderr, "Unable to find reader pointer for connection %s\n", connectionId);
          }
          if(readerTerm) {
            char *pointerStr = strdup(icl_Str(icl_NthTerm(readerTerm, 1)));
            TermSender* ts;
            icl_stRemoveQuotes(pointerStr);
            ts = (TermSender*)stringToPointer(pointerStr);
            free(ts);
            free(pointerStr);
            com_RemoveInfo(connectionId, readerQuery);
          }
          icl_Free(readerQuery);
        }
        com_RemoveInfo(connectionId, lastHeartbeat);
        {
          ICLTerm* reconnectTerm = icl_NewStruct("needs_reconnect", 1, icl_NewStr("true"));
          com_UpdateInfo(connectionId, reconnectTerm);
        }
        printf("Failed connection %s\n", connectionId);
      }
      icl_Free(lastHeartbeat);
    }
  }
  if(initiatedConnections) icl_Free(initiatedConnections);
}

static void tryReconnects()
{
  ICLTerm* reconnectConnections = NULL;
  //ICLListType* listElem;
  ICLTerm* reconnectTerm = icl_NewStruct("needs_reconnect", 1, icl_NewStr("true"));
  ICLTerm* otherAddressMatcher = icl_NewStruct("other_address", 1, icl_NewVar("_"));
  ICLTerm* myAddressMatcher = icl_NewStruct("oaa_address", 1, icl_NewVar("_"));
  ICLTerm* otherSequenceMatcher = icl_NewStruct("other_sequence", 1, icl_NewVar("_"));
  ICLListType* listElem;
  ICLTerm* myNameMatcher = icl_NewStruct("oaa_name", 1, icl_NewVar("_"));

  com_getMatchingInfos(reconnectTerm, &reconnectConnections);
  for(listElem = icl_List(reconnectConnections); listElem; listElem = icl_ListNext(listElem)) {
    char* connId = icl_Str(icl_NthTerm(icl_ListElt(listElem), 1));
    ICLTerm* otherAddress;
    ICLTerm* connectAddress;
    ICLTerm* myAddress;
    ICLTerm* otherSequence;
    ICLTerm* myName;
    int lastSeen;

    com_RemoveInfo(connId, reconnectTerm);
    if(!icl_Member(otherAddressMatcher, icl_NthTerm(icl_ListElt(listElem), 4), &otherAddress)) {
      fprintf(stderr, "reconnect required for connection %s, but no other_address found\n", connId);
      goto cleanup;
    }
    connectAddress = icl_CopyTerm(icl_NthTerm(icl_NthTerm(otherAddress, 1), 1));
    if(!com_GetInfo(connId, myAddressMatcher, &myAddress)) {
      fprintf(stderr, "reconnect required for connection %s, but no oaa_address found\n", connId);
      goto cleanup;
    }
    if(!com_GetInfo(connId, myNameMatcher, &myName)) {
      fprintf(stderr, "reconnect required for connection %s, but no oaa_name found\n", connId);
      goto cleanup;
    }
    if(!com_GetInfo(connId, otherSequenceMatcher, &otherSequence)) {
      lastSeen = -1;
    }
    else {
      lastSeen = icl_Int(icl_NthTerm(otherSequence, 1));
      icl_Free(otherSequence);
    }
    if(com_Connect(connId, connectAddress)) {
      com_add_event_to_buffer(
        icl_NewStruct("term", 1, 
          icl_NewStruct("event", 2, 
            icl_NewStruct("ev_reconnected_needs_handshake", 5,
              icl_NewStr(connId),
              icl_NewStr(icl_Str(icl_NthTerm(myName, 1))),
              icl_NewStruct("reconnect", 1, icl_NewInt(lastSeen)),
              icl_NewStruct("other_address", 1, icl_CopyTerm(icl_NthTerm(myAddress, 1))),
              icl_NewStruct("other_name", 1, icl_NewStr(icl_Str(icl_NthTerm(myName, 1))))
              ),
            icl_NewList(NULL))));
    }

    icl_Free(connectAddress);
  }

cleanup:
  icl_Free(reconnectConnections);
  icl_Free(otherAddressMatcher);
  icl_Free(myAddressMatcher);
  icl_Free(otherSequenceMatcher);
  icl_Free(myNameMatcher);
  icl_Free(reconnectTerm);
}

int initializedLastFired = FALSE;
static GTimeVal lastFired;

static void fireTimers()
{
  if(!initializedLastFired) {
    g_get_current_time(&lastFired);
    initializedLastFired = TRUE;
  }
  else {
    GTimeVal now;
    guint64 udiff;
    g_get_current_time(&now);
    udiff = (now.tv_sec - lastFired.tv_sec) * 1000000 + (now.tv_usec - lastFired.tv_usec);
    if(udiff > 1000000) {
      lastFired.tv_sec = now.tv_sec;
      lastFired.tv_usec = now.tv_usec;
    }
    else {
      return;
    }
  }

  sendHeartbeats();
  checkForFailedHeartbeats();
  tryReconnects();
}

EXPORT_MSCPP
int EXPORT_BORLAND
com_SelectEventFromAllIds(double timeout, ICLTerm **event) {
  int answer = FALSE;
  checkEventBuffer();

  if (com_select_event_from_buffer(event)) {
    CHECK_LEAKS();
    answer = TRUE;
  }
  else if (com_read_events_into_buffer(timeout)) {
    CHECK_LEAKS();
    answer = com_select_event_from_buffer(event);
    CHECK_LEAKS();
  }
  else {
    answer = FALSE;
  }
  fireTimers();
  CHECK_LEAKS();
  return answer;
} // end of com_SelectEventFromAllIds

static char* new_direct_client_id() {
    static int counter = 1;
    char temp[255];
    sprintf(temp, "direct_client%d", counter++);
    return strdup(temp);
} // end of new_direct_client_id


static int opentcpport(int port) {
   int socketFd; /* File descriptor for the socket */
   struct sockaddr_in addr; /* Address to receive data from */

   // Open the socket
   socketFd = socket(AF_INET, SOCK_STREAM, 0);
   if (socketFd < 0) {
      printf("opentcpport: socket open failure: %m\n");
      return -1;
   }

   // Clear the address
   memset(&addr, 0, sizeof(addr));

   // Set the address family to INET
   addr.sin_family = AF_INET;

   // Set the address mask to any address using network byte order
   addr.sin_addr.s_addr = htonl(INADDR_ANY);

   // Set the port using network byte order
   addr.sin_port = htons(port);

   // Bind the port to the socket
   if (bind(socketFd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
      printf("opentcpport: bind failure on port %d: %m\n", port);
      return -1;
   }

   // Return the file descriptor
   return socketFd;
} // end of opentcpport

static int tcpListenAtPort(int port) {
  char listenAtString[600];
  ICLTerm *listenAtTerm;
  int socketFd;

  // Make sure database is initialized
  if (!commdb)
    commdb = db_NewDB();

    socketFd = opentcpport(port);

    if (listen(socketFd, 5) < 0) // backlog = 5
    {
        printf("listen() error: %m\n");
    }

    if (socketFd >= 0) {
        sprintf(listenAtString, "tcp_listener(%d)", socketFd);
    }
    listenAtTerm = icl_NewTermFromString(listenAtString);

    if (listenAtTerm) {
        db_Assert(commdb, listenAtTerm, ICL_EMPTY);
        icl_Free(listenAtTerm);
    }
    else {
        printf("Error! tcp_listener could not be constructed.\n");
    }

    return socketFd;
} // end of tcpListenAtPort

---