/*
+-----------------------------------------------------------------------------
|  Project :  ...
|  Modul   :  dti_conn_mng.c
+-----------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG
|                 All rights reserved.
|
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG
|                 The receipt of or possession of this file does not convey
|                 any rights to reproduce or disclose its contents or to
|                 manufacture, use, or sell anything it may describe, in
|                 whole, or in part, without the specific written consent of
|                 Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
|  Purpose :  Implementation of DTI Connection Manager
+-----------------------------------------------------------------------------
*/


#ifndef DTI_CONN_MNG_C
#define DTI_CONN_MNG_C
#endif


/*===== INCLUDES ===================================================*/

#include "config.h"
#include "fixedconf.h"
#include "condat-features.h"
#include "aci_conf.h"

#include "aci_all.h"

#include "pconst.cdg"
#include "mconst.cdg"
#include "cnf_aci.h"
#include "mon_aci.h"
#include "pei.h"
#include "aci_cmh.h"
#include "ati_cmd.h"
#include "aci_io.h"

#include "aci_cmh.h"
#include "aci_lst.h"
#include "aci_mem.h"

#include "dti.h"
#include "dti_conn_mng.h"
#include "dti_cntrl_mng.h"



LOCAL ULONG        used_dti_channels = 0;
LOCAL T_ACI_LIST  *dti_channel_list = NULL; /* list_begin */

LOCAL T_DTI_CONN_PARAMS glob_params;


/********************** LOCAL FUNCTIONS *****************************/


LOCAL UBYTE dti_conn_get_new_dti_id (void)
{
  ULONG tst_id;
  UBYTE i;

  TRACE_FUNCTION("dti_conn_get_new_dti_id()");

  /* create a new DTI ID */
  for (i = 0; i <= MAX_DTI_CONN_CHANNELS; i++)
  {
    tst_id = (0x01 << i) & used_dti_channels;
    if (!tst_id)
    {
      break;
    }
  }
  if (tst_id)
  {
    TRACE_EVENT("No DTI ID available");
    return (DTI_DTI_ID_NOTPRESENT);
  }
  used_dti_channels |= (0x01 << i);

  TRACE_EVENT_P1("DTI ID %d created", i);

  return (i);
}


LOCAL void dti_conn_remove_dti_id (UBYTE dti_id)
{
  ULONG tst_id;
  
  TRACE_FUNCTION("dti_conn_remove_id()");
  
  if (dti_id >= MAX_DTI_CONN_CHANNELS)
    return;

  tst_id = 0x01 << (dti_id);
  used_dti_channels &= ~tst_id;

  TRACE_EVENT_P1("DTI ID %d removed", dti_id);

}


LOCAL BOOL dti_conn_error_cb(UBYTE dti_id, T_DTI_CONN_STATE result_type)
{
  /* theorically should not be called... Yet helpfull for testing */
  TRACE_FUNCTION("dti_conn_error_cb()");

  TRACE_EVENT("ERROR: DTI connection callback has not been initialized !");

  return FALSE;
}


LOCAL void dti_conn_reset_conn_parms( T_DTI_CONN_CHANNEL *dti_channel )
{

  UBYTE i,j;

  TRACE_FUNCTION("dti_conn_reset_conn_parms()");

  dti_channel->erase_channel = FALSE;
  dti_channel->num_of_conns  = 0;
  dti_channel->conn_cb       = dti_conn_error_cb;
  dti_channel->state         = DTI_CONN_STATE_DISCONNECTED;

  for (i=0; i<MAX_DTI_CONN_TUPLES; i++)
  {
    dti_channel->tuple_list[i].state = DTI_CONN_STATE_DISCONNECTED;
    for (j=0; j<NUM_OF_PEERS; j++)
    {
      dti_channel->tuple_list[i].peers[j].state  = DTI_CONN_STATE_DISCONNECTED;
      dti_channel->tuple_list[i].peers[j].ent_id = DTI_ENTITY_INVALID;
    }
  }
}


LOCAL BOOL DTItest_dti_id( UBYTE dti_id, void *elem)
{
  T_DTI_CONN_CHANNEL *dti_channel = (T_DTI_CONN_CHANNEL *)elem;

  if (dti_channel EQ NULL)
    return FALSE;
  if (dti_channel -> dti_id EQ dti_id )
    return TRUE;
  else
    return FALSE;
}

LOCAL T_DTI_CONN_TUPLE *dti_conn_find_dti_tuple( T_DTI_CONN_CHANNEL *dti_channel, UBYTE tuple_no)
{
   return &(dti_channel->tuple_list[tuple_no]);
}


LOCAL T_DTI_CONN_CHANNEL *dti_conn_find_dti_conn( UBYTE dti_id )
{
  T_DTI_CONN_CHANNEL *dti_channel;

  TRACE_FUNCTION("dti_conn_find_dti_conn()");
  
  /*find channel in list */
  dti_channel = find_element (dti_channel_list, dti_id, DTItest_dti_id);

  return dti_channel;
}


LOCAL BOOL dti_conn_connect( T_DTI_CONN_CHANNEL* dti_channel, 
                              T_DTI_ENTITY_ID*   entity_list, 
                              UBYTE              num_entities, 
                              T_DTI_CONN_MODE    mode )
{
  ULONG link_id;
  UBYTE tuple_no;
  UBYTE i;

  TRACE_FUNCTION("dti_conn_connect()");

  dti_channel->state = DTI_CONN_STATE_CONNECTING;

  if (dti_channel->conn_cb)
  {
    (void )dti_channel->conn_cb(dti_channel->dti_id, DTI_CONN_STATE_CONNECTING);
  }
  else
  {
    TRACE_EVENT("conn_cb is NULL");
  }


  if (mode EQ APPEND)
  {
    tuple_no = dti_channel->num_of_conns;
  }
  else /* SPLIT */
  {
    tuple_no = 0;
    dti_channel->num_of_conns = 0;
  }

  for (i=0; i<num_entities-1; i++)
  {
    dti_channel->tuple_list[tuple_no].peers[0].ent_id = entity_list[i];
    dti_channel->tuple_list[tuple_no].peers[1].ent_id = entity_list[i+1];

    if ( (dti_channel->tuple_list[tuple_no].state NEQ DTI_CONN_STATE_DISCONNECTING) AND
         (dti_channel->tuple_list[tuple_no].state NEQ DTI_CONN_STATE_CONNECTING) )
    {
      dti_channel->tuple_list[tuple_no].state = DTI_CONN_STATE_CONNECTING;
      dti_channel->tuple_list[tuple_no].tuple_no = tuple_no;
      dti_channel->state = DTI_CONN_STATE_CONNECTING;

      link_id = dti_conn_compose_link_id(0, 0, dti_channel->dti_id, tuple_no);

      dti_channel->tuple_list[tuple_no].peers[0].state = DTI_CONN_STATE_CONNECTING;
      dti_channel->tuple_list[tuple_no].peers[1].state = DTI_CONN_STATE_CONNECTING;

      /* connect a tuple */
     (void) glob_params.mng_ent_cb(link_id, entity_list[i], entity_list[i+1], DTI_CONNECT);
      (void)glob_params.mng_ent_cb(link_id, entity_list[i+1], entity_list[i], DTI_CONNECT);
    }

    tuple_no++;
  }

  dti_channel->num_of_conns = tuple_no;

  return TRUE;
}


LOCAL BOOL dti_conn_disconnect( T_DTI_CONN_CHANNEL* dti_channel )
{
  ULONG link_id;
  UBYTE i;

  TRACE_FUNCTION("dti_conn_disconnect()");

  dti_channel->state = DTI_CONN_STATE_DISCONNECTING;

  if (dti_channel->conn_cb)
  {
    (void)dti_channel->conn_cb(dti_channel->dti_id, DTI_CONN_STATE_DISCONNECTING);
  }
  else
  {
    TRACE_EVENT("conn_cb is NULL");
  }

  for (i=0; i < dti_channel->num_of_conns; i++)
  {

    /* set tuple state only if it is not already DISCONNECTED */
    if (dti_channel->tuple_list[i].state NEQ DTI_CONN_STATE_DISCONNECTED)
    {
      dti_channel->tuple_list[i].state = DTI_CONN_STATE_DISCONNECTING;
    }

    link_id = dti_conn_compose_link_id(0, 0, dti_channel->dti_id, i);

    /* disconnect only a connected entity */
    if (dti_channel->tuple_list[i].peers[0].state EQ DTI_CONN_STATE_CONNECTED  OR
		dti_channel->tuple_list[i].peers[0].state EQ DTI_CONN_STATE_CONNECTING    )
    {
      dti_channel->tuple_list[i].peers[0].state = DTI_CONN_STATE_DISCONNECTING;
      (void)glob_params.mng_ent_cb(link_id, dti_channel->tuple_list[i].peers[0].ent_id, 
                           dti_channel->tuple_list[i].peers[1].ent_id, DTI_DISCONNECT);
    }

    /* disconnect only a connected entity */
    if (dti_channel->tuple_list[i].peers[1].state EQ DTI_CONN_STATE_CONNECTED  OR
		dti_channel->tuple_list[i].peers[1].state EQ DTI_CONN_STATE_CONNECTING    )
    {
      dti_channel->tuple_list[i].peers[1].state = DTI_CONN_STATE_DISCONNECTING;
      (void)glob_params.mng_ent_cb(link_id, dti_channel->tuple_list[i].peers[1].ent_id, 
                            dti_channel->tuple_list[i].peers[0].ent_id, DTI_DISCONNECT);
    }
  }

  return TRUE;
}







/********************** GLOBAL FUNCTIONS *****************************/


GLOBAL T_DTI_CONN_LINK_ID dti_conn_compose_link_id(UBYTE dummy, UBYTE assoc, UBYTE dti_id, UBYTE tuple_no)
{
  T_DTI_CONN_LINK_ID link_id = 0;

  link_id += dummy;
  link_id <<= 8;
  link_id += assoc;
  link_id <<= 8;
  link_id += dti_id;
  link_id <<= 8;
  link_id += tuple_no;

  return link_id;
}


/*
+--------------------------------------------------------------------+
| PROJECT :                             MODULE  : DTI_CONN           |
| STATE   : code                        ROUTINE : dti_conn_init      |
+--------------------------------------------------------------------+

  PURPOSE : initialise the DTI Connection Manager

*/
GLOBAL void dti_conn_init( T_DTI_CONN_MNG_ENT_CB* mng_ent_cb )
{
  TRACE_FUNCTION("dti_conn_init()");

  dti_channel_list = new_list ();
 
  glob_params.conn_cb      = NULL;
  glob_params.mng_ent_cb   = mng_ent_cb;
  glob_params.num_entities = 0;

}


/*
+--------------------------------------------------------------------+
| PROJECT :                             MODULE  : DTI_CONN           |
| STATE   : code                        ROUTINE : dti_conn_new       |
+--------------------------------------------------------------------+

  PURPOSE : register new DTI channel

*/
GLOBAL UBYTE dti_conn_new(UBYTE dti_id )
{
  T_DTI_CONN_CHANNEL *dti_channel;

  TRACE_FUNCTION("dti_conn_new()");


  if (dti_id EQ DTI_DTI_ID_NOTPRESENT)
  {
    dti_id = dti_conn_get_new_dti_id ();
  }

  if (dti_id EQ DTI_DTI_ID_NOTPRESENT)
  {
    return (DTI_DTI_ID_NOTPRESENT);
  }

  /* search for an existing entry with correspondant dti_id */
  dti_channel = dti_conn_find_dti_conn (dti_id);

  if( dti_channel )
  {
    return (DTI_DTI_ID_NOTPRESENT); /* couldn't create a new entry */
  }

  ACI_MALLOC(dti_channel, sizeof(T_DTI_CONN_CHANNEL));

  dti_conn_reset_conn_parms (dti_channel);
  dti_channel->dti_id = dti_id;
  insert_list(dti_channel_list, dti_channel);

  return (dti_channel->dti_id);
}


/*
+---------------------------------------------------------------------+
| PROJECT :                            MODULE  : DTI_CONN             |
| STATE   : code                       ROUTINE : dti_conn_erase_entry |
+---------------------------------------------------------------------+

  PURPOSE :  erase entry from DTI channel list 

*/
GLOBAL void dti_conn_erase_entry(UBYTE dti_id)
{
  T_DTI_CONN_CHANNEL *dti_channel;

  TRACE_FUNCTION("dti_conn_erase_entry");

  /* find element to be erased */
  dti_channel = remove_element (dti_channel_list, dti_id, DTItest_dti_id);

  if( dti_channel NEQ NULL ) /* entry not erased yet */
    ACI_MFREE (dti_channel);

  dti_conn_remove_dti_id(dti_id);
}


/*
+-----------------------------------------------------------------------+
| PROJECT :               MODULE  : DTI_CONN                            |
| STATE   : code          ROUTINE : dti_conn_is_dti_channel_connected   |
+-----------------------------------------------------------------------+ 

  PURPOSE : returns TRUE if end-to-end DTI connection is connected and 
            the given entity is in this connection

*/
GLOBAL BOOL dti_conn_is_dti_channel_connected( T_DTI_ENTITY_ID ent_id, UBYTE dti_id )
{
  UBYTE count = 0;
  UBYTE i;
  UBYTE entity_found = FALSE;
  T_DTI_CONN_CHANNEL *dti_channel = dti_conn_find_dti_conn( dti_id );

  TRACE_FUNCTION("dti_conn_is_dti_channel_connected()");

  if (dti_channel EQ NULL)
  {
    TRACE_EVENT_P1("dti_channel for dti_id %d not found", dti_id);
    return FALSE;
  }

  for (i=0; i<dti_channel->num_of_conns; i++)
  {
    if ((dti_channel->tuple_list[i].peers[0].ent_id EQ ent_id) OR
        (dti_channel->tuple_list[i].peers[1].ent_id EQ ent_id))
    {
      entity_found = TRUE;
      break;
    }
  }

  if (entity_found EQ FALSE)
    return FALSE;

  if (dti_channel->state EQ DTI_CONN_STATE_CONNECTED)
  {
    return TRUE;
  }
  else
  {
    for (i=0; i<dti_channel->num_of_conns; i++)
    {
      if (dti_channel->tuple_list[i].state EQ DTI_CONN_STATE_CONNECTED)
      {
        count++;
      }
    }

    if (count EQ dti_channel->num_of_conns)
    {
      return TRUE;
    }
  }

  return FALSE;
}


/*
+--------------------------------------------------------------------------+
| PROJECT :               MODULE  : DTI_CONN                               |
| STATE   : code          ROUTINE : dti_conn_is_dti_channel_disconnected   |
+--------------------------------------------------------------------------+ 

  PURPOSE : returns TRUE if end-to-end DTI connection is disconnected

*/
GLOBAL BOOL dti_conn_is_dti_channel_disconnected( UBYTE dti_id )
{
  UBYTE count = 0;
  UBYTE i;
  T_DTI_CONN_CHANNEL *dti_channel = dti_conn_find_dti_conn( dti_id );

  TRACE_FUNCTION("dti_conn_is_dti_channel_disconnected()");


  if (dti_channel EQ NULL)
  {
    return TRUE;
  }

  if (dti_channel->state EQ DTI_CONN_STATE_DISCONNECTED)
  {
    return TRUE;
  }
  else
  {
    for (i=0; i<dti_channel->num_of_conns; i++)
    {
      if (dti_channel->tuple_list[i].state EQ DTI_CONN_STATE_DISCONNECTED)
      {
        count++;
      }
    }

    if (count EQ dti_channel->num_of_conns)
    {
      return TRUE;
    }
  }

  return FALSE;
}


/*
+---------------------------------------------------------------------+
| PROJECT :                             MODULE  : DTI_CONN            |
| STATE   : code                        ROUTINE : dti_conn_est_dpath  |
+---------------------------------------------------------------------+

  PURPOSE : establishes data path.

*/
GLOBAL BOOL dti_conn_est_dpath( UBYTE               dti_id,
                                T_DTI_ENTITY_ID*    entity_list,
                                UBYTE               num_entities,
                                T_DTI_CONN_MODE     mode,
                                T_DTI_CONN_CB*      cb)
{
  T_DTI_CONN_CHANNEL *dti_channel;

  TRACE_FUNCTION("dti_conn_est_dpath()");


  /*find channel in list */
  dti_channel = dti_conn_find_dti_conn (dti_id);

  if (dti_channel EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] dti_conn_est_dpath: dti_channel dti_id=%x not found",
                   dti_id);
    /* DTI ID not found */
    return FALSE;
  }
  
  if ( entity_list[0] EQ DTI_ENTITY_INVALID OR entity_list[1] EQ DTI_ENTITY_INVALID)
  {
    /* improper entity list */
    TRACE_EVENT("[ERR] improper entity list ");
    return FALSE;
  }

  /* if 'SPLIT' then the whole DTI channel must be disconnected before a 
   * new connection is established 
   */
  if ((mode EQ SPLIT) AND (dti_channel->state NEQ DTI_CONN_STATE_DISCONNECTED))
  {
    dti_conn_disconnect (dti_channel);
    
    /* save new entity list to entity list buffer */
    memcpy(glob_params.entity_list_buf, entity_list, sizeof(T_DTI_ENTITY_ID)*num_entities);
    glob_params.num_entities = num_entities;
    glob_params.conn_cb = cb;
  }
  else
  {
    dti_channel->conn_cb = cb;
    dti_conn_connect (dti_channel, entity_list, num_entities, mode);
  }

  return TRUE;
}


/*
+---------------------------------------------------------------------+
| PROJECT :                           MODULE  : DTI_CONN              |
| STATE   : code                      ROUTINE : dti_conn_close_dpath  |
+---------------------------------------------------------------------+

  PURPOSE : closes a DTI connection

*/
GLOBAL BOOL dti_conn_close_dpath( UBYTE dti_id )
{
  T_DTI_CONN_CHANNEL *dti_channel;

  TRACE_FUNCTION("dti_conn_close_dpath()");


  dti_channel = dti_conn_find_dti_conn( dti_id );
  if (dti_channel EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] dti_conn_close_dpath: dti_channel dti_id=%x not found",
                   dti_id);
    return FALSE;
  }

  if (dti_channel->state NEQ DTI_CONN_STATE_DISCONNECTED)
  {
    dti_channel->state = DTI_CONN_STATE_DISCONNECTING;
        
    dti_conn_disconnect (dti_channel);
  }
  else
  {
    TRACE_EVENT("[ERR] dti_conn_close_dpath: try to close dpath which was DISCONNECTED");
    return FALSE;
  }

  return TRUE;
}


/*
+-----------------------------------------------------------------------+
| PROJECT :                        MODULE  : DTI_CONN                   |
| STATE   : code                   ROUTINE : dti_conn_entity_connected  |
+-----------------------------------------------------------------------+

  PURPOSE : response after a DTI connect request. This function is called 
            to inform the DTI Connection Manager that a connection is 
            established.

*/
GLOBAL void dti_conn_entity_connected( T_DTI_CONN_LINK_ID link_id, 
                                       T_DTI_ENTITY_ID    ent_id, 
                                       T_DTI_CONN_RESULT  result )
{
  T_DTI_CONN_CHANNEL    *dti_channel;
  T_DTI_CONN_TUPLE      *tuple;
  UBYTE                 i;
  UBYTE                 dti_id = EXTRACT_DTI_ID(link_id);
  BOOL                  both_entities_connected = FALSE;
  UBYTE                 count = 0;

  TRACE_FUNCTION("dti_conn_entity_connected()");


  dti_channel = dti_conn_find_dti_conn( dti_id );
  if (dti_channel EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] dti_conn_entity_connected: dti_channel link_id=%x not found",
                   link_id);
    return;
  }

  if (result EQ DTI_ERROR)
  {
    /* mark entity as disconnected */
    dti_conn_entity_disconnected( link_id, ent_id );

    /* close the whole DTI channel */
    dti_conn_close_dpath( dti_id );
    return;
  }

  if (dti_channel->state EQ DTI_CONN_STATE_CONNECTED)
  {
    TRACE_EVENT_P1("dti channel with dti_id=%x already connected", dti_id);
    return;
  }

  tuple = dti_conn_find_dti_tuple( dti_channel, EXTRACT_TUPLE_NO(link_id ) );

  for (i=0; i<NUM_OF_PEERS; i++)
  {
    if (tuple->peers[i].state EQ DTI_CONN_STATE_CONNECTED)
    {
      count++;
    }

    if (tuple->peers[i].ent_id EQ ent_id)
    {
      if (tuple->peers[i].state EQ DTI_CONN_STATE_CONNECTING)
      {
        tuple->peers[i].state = DTI_CONN_STATE_CONNECTED;
        count++;
      }
    }
    if (count EQ NUM_OF_PEERS)
    {
      both_entities_connected = TRUE;
    }
  }

  /* if both entities are CONNECTED */
  if (both_entities_connected)
  {
    tuple->state = DTI_CONN_STATE_CONNECTED;

    /* if all other tuples CONNECTED */
    if (dti_conn_is_dti_channel_connected(ent_id, dti_id))
    {
      dti_channel->state = DTI_CONN_STATE_CONNECTED;

      TRACE_EVENT_P1("DTI ID %d connected", dti_id);
      
      /* call connect_cb here */
      if (dti_channel->conn_cb)
      {
        (void)dti_channel->conn_cb(dti_id, DTI_CONN_STATE_CONNECTED);
      }
      else
      {
        TRACE_EVENT("conn_cb is NULL");
      }
    }
  }
}


/*
+-----------------------------------------------------------------------+
| PROJECT :                     MODULE  : DTI_CONN                      |
| STATE   : code                ROUTINE : dti_conn_entity_disconnected  |
+-----------------------------------------------------------------------+

  PURPOSE : response after a DTI connect request. This function is called 
            to inform the DTI Connection Manager that a connection is 
            closed.

*/
GLOBAL void dti_conn_entity_disconnected( T_DTI_CONN_LINK_ID link_id, T_DTI_ENTITY_ID ent_id )
{
  T_DTI_CONN_CHANNEL    *dti_channel;
  T_DTI_CONN_TUPLE      *tuple;
  UBYTE                 i;
  UBYTE                 dti_id = EXTRACT_DTI_ID(link_id);
  UBYTE                 count = 0;

  TRACE_FUNCTION("dti_conn_entity_disconnected()");


  dti_channel = dti_conn_find_dti_conn( dti_id );
  if (dti_channel EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] dti_conn_entity_disconnected: dti_channel link_id=%x not found",
                   link_id);
    return;
  }

  if (dti_channel->state EQ DTI_CONN_STATE_DISCONNECTED)
  {
    TRACE_EVENT_P1("dti channel with dti_id=%x already diconnected", dti_id);
    return;
  }


  tuple = dti_conn_find_dti_tuple( dti_channel, EXTRACT_TUPLE_NO(link_id) );

  for (i=0; i<NUM_OF_PEERS; i++)
  {
    if (tuple->peers[i].state EQ DTI_CONN_STATE_DISCONNECTED)
    {
      count++;
    }

    /* find disconnected entity */
    if (tuple->peers[i].ent_id EQ ent_id)
    {
      tuple->peers[i].state  = DTI_CONN_STATE_DISCONNECTED;
      tuple->peers[i].ent_id = DTI_ENTITY_INVALID;
      count++;

      tuple->state = DTI_CONN_STATE_DISCONNECTING;

      if (dti_channel->state EQ DTI_CONN_STATE_CONNECTED)
      {
        /* set DTI channel state */
        dti_channel->state = DTI_CONN_STATE_DISCONNECTING;
      }
    }
  }

  /* if both entities are DISCONNECTED */
  if (count EQ NUM_OF_PEERS)
  {
    /* set tuple state */
    tuple->state = DTI_CONN_STATE_DISCONNECTED;

    /* if all other tuples DISCONNECTED */
    if (dti_conn_is_dti_channel_disconnected(dti_id))
    {
      dti_channel->state = DTI_CONN_STATE_DISCONNECTED;

      TRACE_EVENT_P1("DTI ID %d disconnected", dti_id);

      /* reset number of conns */
      dti_channel->num_of_conns = 0;
      
      /* call disconnect_cb here */
      if (dti_channel->conn_cb)
      {
        (void)dti_channel->conn_cb(dti_id, DTI_CONN_STATE_DISCONNECTED);
      }
      else
      {
        TRACE_EVENT("conn_cb is NULL");
      }

      if (glob_params.num_entities NEQ 0)
      {
        dti_channel->conn_cb = glob_params.conn_cb;
        dti_conn_connect( dti_channel, glob_params.entity_list_buf, glob_params.num_entities, SPLIT );
        glob_params.num_entities = 0;
      }
      else
      {
        if (dti_channel->erase_channel EQ TRUE)
        {
          /* erase entry in DTI Conn Mng */
          dti_conn_erase_entry(dti_id);
        }
      }
    }
  }
}


/*
+-----------------------------------------------------------------------+
| PROJECT :                     MODULE  : DTI_CONN                      |
| STATE   : code                ROUTINE : dti_conn_close_all_connections|
+-----------------------------------------------------------------------+

  PURPOSE : This function is called to close all established DTI 
            connections.

*/
GLOBAL void dti_conn_close_all_connections()
{
  T_DTI_CONN_CHANNEL *dti_channel=NULL;

  TRACE_FUNCTION("dti_conn_close_all_connections()");
  
  while(TRUE)
  {
    dti_channel = get_next_element (dti_channel_list, dti_channel);
    if (dti_channel EQ NULL)
    {
      return;
    }

    if (dti_channel->state EQ DTI_CONN_STATE_CONNECTED)
    {
      dti_conn_close_dpath(dti_channel->dti_id);
      dti_channel->erase_channel = TRUE;
    }
    else
    {
      dti_conn_erase_entry(dti_channel->dti_id);
    }
   }
}