dti_conn_mng.c

是一个手机功能的模拟程序

  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 ((mode EQ SPLIT) AND (dti_channel->state EQ DTI_CONN_STATE_CONNECTED))
  {
    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;
  UBYTE i=0;

  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)
      {
        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)
      {
        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;

  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);
    }
  }
}