FreeCalypso > hg > fc-tourmaline

view src/g23m-fad/tcpip/socket_api.c @ 223:740a8e8fc9d7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
startup sync logic rework for the new PWON button boot scheme Previously we added logic to the MMI task to hold off PEI init until R2D is running, and then extended that condition to wait for FCHG init too. However, the dependencies of MMI upon R2D and FCHG don't start until mmiInit(), and that call is driven by Switch_ON() code, hence the wait for R2D and FCHG init can be made in that code path instead of the MMI task. Furthermore, with our new way of signaling PWON button boot to MMI, we need a new wait to ensure that the MMI task is up - previously this assurance was provided by the wait for Kp pointers to be set. Solution: revert our previous PEI init hold-off additions to MMI, add a new flag indicating MMI task init done, and put the combined wait for all needed conditions into our new PWON button boot code in power.c.
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 27 Apr 2021 06:24:52 +0000
parents fa8dc04885d8
children
line wrap: on
line source

/* 
+------------------------------------------------------------------------------
|  File:       socket.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 :  This file implements the socket API functionality.
|             For a description of this file read g23m\condat\doc\8462_601.doc
+----------------------------------------------------------------------------- 
*/ 

#ifndef SAP_DCM
#define SAP_DCM
#endif /* !SAP_DCM */

#define ENTITY_TCPIP

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "socket_api.h"

#include "custom.h"
#include "pei.h"   
#include "socket_int.h"
#include "dcm.h"
#include "aci_all.h"


LOCAL const int UNUSED = 0;

/* this function maps the DCM result codes to the Socket-API result codes */
LOCAL T_SOCK_RESULT map_dcm_result_code(S32 result)
{
  switch(result)
  {
    case DCM_OK:                return SOCK_RESULT_OK;
    case DCM_NOT_READY:         return SOCK_RESULT_NOT_READY;
    case DCM_ALREADY_ACTIVATED: return SOCK_RESULT_BEARER_ACTIVE;
    case DCM_UNKNOWN_EVENT:     return SOCK_RESULT_INTERNAL_ERROR;
    case DCM_INVALID_PARAMETER: return SOCK_RESULT_INVALID_PARAMETER;
    case DCM_BUSY:              return SOCK_RESULT_IN_PROGRESS;
    case DCM_PS_CONN_BROKEN:    return SOCK_RESULT_NETWORK_LOST;
    case DCM_NO_NETWORK:        return SOCK_RESULT_BEARER_NOT_READY;
    default:                    return SOCK_RESULT_INTERNAL_ERROR;
  }
}


/*******************************************************************************
** Function  :   FindSocketData
** Parameter :   T_SOCK_API_INSTANCE_DATA*
**               T_SOCK_SOCKET
** Description : The function returns a pointer to the data structure of a socket.
**               If the socket does not exist or api_data is NULL,
**               then it returns NULL.
*******************************************************************************/
LOCAL T_SOCK_SOCKET_DATA* FindSocketData(T_SOCK_API_INSTANCE_DATA* api_data,
                                         T_SOCK_SOCKET tcpip_socket)
{
  T_SOCK_SOCKET_DATA* socket_data;

  TRACE_FUNCTION("FindSocketData()");

  /* must be checked whether api_data is NULL or not.*/
  if(api_data != NULL)       
     socket_data = api_data->socket_data;
  else
  {
    TRACE_ERROR("FindSocketData: api_data = NULL!");
     return NULL;
  }
  
  while((socket_data != NULL) && (tcpip_socket != socket_data->tcpip_socket))
  {
    socket_data = socket_data->next_socket_data;
  }

  TRACE_EVENT_P2("FindSocketData: tcpip_data=%x, ret=%x",tcpip_socket,socket_data );
  return socket_data;
} /* FindSocketData */



/*******************************************************************************
** Function  : ReleaseSocketData
** Parameter : T_SOCK_API_INSTANCE_DATA*
**             T_SOCK_SOCKET_DATA*
** Description : The function releases the specified socket data.
*******************************************************************************/
static void ReleaseSocketData(T_SOCK_API_INSTANCE_DATA* api_data,
                              T_SOCK_SOCKET_DATA* socket_data)
{
  T_SOCK_SOCKET_DATA* temp_socket_data;

  TRACE_FUNCTION("ReleaseSocketData()");

  /* take socket data from linked list */
  if(api_data->socket_data == socket_data)
  {
    api_data->socket_data = socket_data->next_socket_data;
  }
  else
  {
    temp_socket_data = api_data->socket_data;
    while(temp_socket_data->next_socket_data != socket_data)
    {
      temp_socket_data = temp_socket_data->next_socket_data;
    }
    temp_socket_data->next_socket_data = socket_data->next_socket_data;
  }
  
  /* release socket data  */
  MFREE(socket_data);
} /* ReleaseSocketData */


/******************************************************************************/
BOOL sock_api_initialize(T_SOCK_API_INSTANCE *api_instance,
                         T_HANDLE app_handle,
                         char* app_name)
{
  T_SOCK_API_INSTANCE_DATA* api_data_p;
  T_HANDLE                  hCommAPP;
  T_HANDLE                  hCommTCPIP;
  T_HANDLE                  hCommDCM;

  TRACE_FUNCTION("[Socket API] sock_api_initialize()");

  /* open communication handles */
  if((hCommTCPIP = vsi_c_open (app_handle, TCPIP_NAME)) < VSI_OK)
  {
    TRACE_ERROR( "sock_api_initialize: vsi_c_open(TCP) failed");
    return FALSE;
  }

  if((hCommAPP = vsi_c_open (app_handle, app_name)) < VSI_OK)
  {
    TRACE_ERROR( "sock_api_initialize: vsi_c_open(APP) failed");
    return FALSE;
  }
  
  if((hCommDCM = vsi_c_open (app_handle, DCM_NAME)) < VSI_OK)
  {
    TRACE_ERROR( "sock_api_initialize: vsi_c_open(DCM) failed");
    return FALSE;
  }
  /* initialization successful */
  
  /* allocate API Data structure */
  MALLOC(api_data_p, sizeof(T_SOCK_API_INSTANCE_DATA));
  
  /*initialize API Data */
  api_data_p->app_handle  = app_handle;
  api_data_p->hCommAPP    = hCommAPP;
  api_data_p->hCommTCPIP  = hCommTCPIP;
  api_data_p->hCommDCM    = hCommDCM;
  api_data_p->socket_data = NULL;
 
  /* derefernce 'api_instance' and save address of 'api_data' */
  *api_instance = (T_SOCK_API_INSTANCE)api_data_p;
  return TRUE;
} /* sock_api_initialize */


/******************************************************************************/
void sock_api_deinitialize(T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_API_INSTANCE_DATA* api_data_p;
  T_SOCK_SOCKET_DATA*       socket_data1;
  T_SOCK_SOCKET_DATA*       socket_data2;

  TRACE_FUNCTION("[Socket API] sock_api_deinitialize()");

  /* get the address of 'api_data' */
  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
  /*close communication channels */
  vsi_c_close (api_data_p->app_handle, api_data_p->hCommAPP);
  vsi_c_close (api_data_p->app_handle, api_data_p->hCommTCPIP);
  vsi_c_close (api_data_p->app_handle, api_data_p->hCommDCM);

  /* release all socket data */
  socket_data1 = api_data_p->socket_data;

  while(socket_data1 != NULL)
  {
    socket_data2 = socket_data1;
    socket_data1 = socket_data1->next_socket_data;
    MFREE(socket_data2);
  }

  /* release API data */
  MFREE(api_data_p);
} 


/******************************************************************************/
T_SOCK_RESULT sock_open_bearer(T_SOCK_API_INSTANCE api_instance,
                               T_SOCK_BEARER_TYPE bearer_select,
                               int profile_number,
                               T_SOCK_BEARER_INFO *params,
                               T_SOCK_CALLBACK sock_cb,
                               void *context)
{
  T_SOCK_API_INSTANCE_DATA* api_data_p;

  TRACE_FUNCTION("[Socket API] sock_open_bearer()");
  
if(sock_cb EQ NULL)
  return SOCK_RESULT_INVALID_PARAMETER;

  /* set API data pointer */
  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  api_data_p->context = context;
  api_data_p->callback = sock_cb;
  
  /* send primitive to DCM */
  {
    PALLOC(dcm_open_conn_req, DCM_OPEN_CONN_REQ);
    dcm_open_conn_req->api_instance = api_instance;
    dcm_open_conn_req->bearer_select = bearer_select;
    dcm_open_conn_req->profile_number = profile_number;

    dcm_open_conn_req->dcm_info_conn.bearer_handle = UNUSED;
    dcm_open_conn_req->dcm_info_conn.app_handle = params->app_handle;
    dcm_open_conn_req->dcm_info_conn.bearer_type = params->bearer_type;
    dcm_open_conn_req->dcm_info_conn.apn_valid = params->apn_valid;
    memcpy(dcm_open_conn_req->dcm_info_conn.apn, params->apn, SOCK_MAX_APN_LEN+1);
    dcm_open_conn_req->dcm_info_conn.phone_number_valid = params->phone_nr_valid;
    memcpy(dcm_open_conn_req->dcm_info_conn.phone_number, params->phone_nr,
           SOCK_MAX_PHONENUM_LEN+1);
    dcm_open_conn_req->dcm_info_conn.user_id_valid = params->user_id_valid;
    memcpy(dcm_open_conn_req->dcm_info_conn.user_id, params->user_id,
           SOCK_MAX_USERID_LEN+1);
    dcm_open_conn_req->dcm_info_conn.password_valid = params->password_valid;
    memcpy(dcm_open_conn_req->dcm_info_conn.password, params->password,
           SOCK_MAX_PASSWORD_LEN+1);
    dcm_open_conn_req->dcm_info_conn.cid = params->cid;
    dcm_open_conn_req->dcm_info_conn.ip_address = params->ip_address;
    dcm_open_conn_req->dcm_info_conn.dns1 = params->dns1;
    dcm_open_conn_req->dcm_info_conn.dns2 = params->dns2;
    dcm_open_conn_req->dcm_info_conn.gateway = params->gateway;
    dcm_open_conn_req->dcm_info_conn.auth_type = params->authtype;
    dcm_open_conn_req->dcm_info_conn.data_compr = params->data_compr;
    dcm_open_conn_req->dcm_info_conn.header_compr = params->header_comp;
    dcm_open_conn_req->dcm_info_conn.precedence = params->precedence;
    dcm_open_conn_req->dcm_info_conn.delay = params->precedence;
    dcm_open_conn_req->dcm_info_conn.reliability = params->reliability;
    dcm_open_conn_req->dcm_info_conn.peak_throughput = params->peak_throughput;
    dcm_open_conn_req->dcm_info_conn.mean_throughput = params->mean_througput;
    dcm_open_conn_req->dcm_info_conn.shareable = params->shareable;

    PSEND(api_data_p->hCommDCM, dcm_open_conn_req);
  }
  return SOCK_RESULT_OK;
}

/******************************************************************************/
LOCAL void sock_open_bearer_cnf(T_DCM_OPEN_CONN_CNF *dcm_open_conn_cnf,
                                      T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_OPEN_BEARER_CNF sock_open_bearer_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data_p;

  TRACE_FUNCTION("[Socket API] sock_open_bearer_cnf()");

  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
  /* fill signal struct */
  sock_open_bearer_cnf.result = map_dcm_result_code(dcm_open_conn_cnf->result);
  sock_open_bearer_cnf.socket = UNUSED;
  sock_open_bearer_cnf.event_type = SOCK_OPEN_BEARER_CNF;
  sock_open_bearer_cnf.bearer_handle = dcm_open_conn_cnf->bearer_handle;

  /* release primitive */
  PFREE(dcm_open_conn_cnf);
  
  api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_open_bearer_cnf,
                       api_data_p->context);
}

/******************************************************************************/
T_SOCK_RESULT sock_close_bearer(T_SOCK_API_INSTANCE api_instance,
                                T_SOCK_BEARER_HANDLE bearer_handle,
                                T_SOCK_CALLBACK sock_cb,
                                void *context)
{
  T_SOCK_API_INSTANCE_DATA* api_data_p;

  TRACE_FUNCTION("[Socket API] sock_close_bearer()");

  if(sock_cb EQ NULL) {
   return SOCK_RESULT_INVALID_PARAMETER;
  }

  /* set API data pointer */
  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  api_data_p->callback = sock_cb;
  api_data_p->context = context;

  /* send primitive to DCM */
  {
    PALLOC(dcm_close_conn_req, DCM_CLOSE_CONN_REQ);
    dcm_close_conn_req->api_instance = api_instance;
    dcm_close_conn_req->bearer_handle = bearer_handle;
    PSEND(api_data_p->hCommDCM, dcm_close_conn_req);
  }
  
  return SOCK_RESULT_OK;
}

/******************************************************************************/
LOCAL void sock_close_bearer_cnf(T_DCM_CLOSE_CONN_CNF *dcm_close_conn_cnf,
                                        T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_CLOSE_BEARER_CNF sock_close_bearer_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data_p;

  TRACE_FUNCTION("[Socket API] dcm_close_conn_cnf()");

  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_close_bearer_cnf.result = map_dcm_result_code(dcm_close_conn_cnf->result);
  sock_close_bearer_cnf.socket = UNUSED;
  sock_close_bearer_cnf.event_type = SOCK_CLOSE_BEARER_CNF;

  /* release primitive */
  PFREE(dcm_close_conn_cnf);

  /* call callback function */
  api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_close_bearer_cnf,
                       api_data_p->context);
}

/******************************************************************************/
T_SOCK_RESULT sock_bearer_info(T_SOCK_API_INSTANCE api_instance,
                               T_SOCK_BEARER_HANDLE bearer_handle,
                               T_SOCK_CALLBACK sock_cb,
                               void *context)
{
  T_SOCK_API_INSTANCE_DATA* api_data_p;

  TRACE_FUNCTION("[Socket API] sock_bearer_info()");

  if(sock_cb EQ NULL)
   return SOCK_RESULT_INVALID_PARAMETER;

  /* set API data pointer */
  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  api_data_p->callback = sock_cb;
  api_data_p->context = context;

  /* send primitive to DCM */
  {
    PALLOC(dcm_get_current_conn_req, DCM_GET_CURRENT_CONN_REQ);
    dcm_get_current_conn_req->api_instance = api_instance;
    dcm_get_current_conn_req->bearer_handle = bearer_handle;
    PSEND(api_data_p->hCommDCM, dcm_get_current_conn_req);
  }
  return SOCK_RESULT_OK;
}


/******************************************************************************/
LOCAL void sock_bearer_info_cnf(T_DCM_GET_CURRENT_CONN_CNF *current_conn_cnf,
                                      T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_BEARER_INFO_CNF bearer_info;
  T_SOCK_API_INSTANCE_DATA *api_data_p;

  TRACE_FUNCTION("[Socket API] sock_bearer_info_cnf()");

  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  bearer_info.result = map_dcm_result_code(current_conn_cnf->result);
  bearer_info.socket = UNUSED;
  bearer_info.event_type = SOCK_BEARER_INFO_CNF;

  bearer_info.bearer_params.bearer_handle = current_conn_cnf->dcm_info_conn.bearer_handle;
  bearer_info.bearer_params.app_handle = current_conn_cnf->dcm_info_conn.app_handle;
  bearer_info.bearer_params.bearer_type =(T_SOCK_BEARER_TYPE)current_conn_cnf->dcm_info_conn.bearer_type;
  bearer_info.bearer_params.apn_valid = current_conn_cnf->dcm_info_conn.apn_valid;
  memcpy(bearer_info.bearer_params.apn,
         current_conn_cnf->dcm_info_conn.apn, SOCK_MAX_APN_LEN);
  bearer_info.bearer_params.phone_nr_valid = current_conn_cnf->dcm_info_conn.phone_number_valid;
  memcpy(bearer_info.bearer_params.phone_nr,current_conn_cnf->dcm_info_conn.phone_number,
         SOCK_MAX_PHONENUM_LEN);
  bearer_info.bearer_params.user_id_valid = current_conn_cnf->dcm_info_conn.user_id_valid;
  memcpy(bearer_info.bearer_params.user_id, current_conn_cnf->dcm_info_conn.user_id,
         SOCK_MAX_USERID_LEN);
  bearer_info.bearer_params.password_valid = current_conn_cnf->dcm_info_conn.password_valid;
  memcpy(bearer_info.bearer_params.password, current_conn_cnf->dcm_info_conn.password,
         SOCK_MAX_PASSWORD_LEN);
  bearer_info.bearer_params.cid = current_conn_cnf->dcm_info_conn.cid;
  bearer_info.bearer_params.ip_address = current_conn_cnf->dcm_info_conn.ip_address;
  bearer_info.bearer_params.dns1 = current_conn_cnf->dcm_info_conn.dns1;
  bearer_info.bearer_params.dns2 = current_conn_cnf->dcm_info_conn.dns2;
  bearer_info.bearer_params.gateway = current_conn_cnf->dcm_info_conn.gateway;
  bearer_info.bearer_params.authtype = (T_SOCK_AUTHTYPE)current_conn_cnf->dcm_info_conn.auth_type;
  bearer_info.bearer_params.data_compr = current_conn_cnf->dcm_info_conn.data_compr;
  bearer_info.bearer_params.header_comp = current_conn_cnf->dcm_info_conn.header_compr;
  bearer_info.bearer_params.precedence = current_conn_cnf->dcm_info_conn.precedence;
  bearer_info.bearer_params.delay = current_conn_cnf->dcm_info_conn.delay;
  bearer_info.bearer_params.reliability = current_conn_cnf->dcm_info_conn.reliability;
  bearer_info.bearer_params.peak_throughput = current_conn_cnf->dcm_info_conn.peak_throughput;
  bearer_info.bearer_params.mean_througput = current_conn_cnf->dcm_info_conn.mean_throughput;
  bearer_info.bearer_params.shareable = current_conn_cnf->dcm_info_conn.shareable;

  /* release primitive */
  PFREE(current_conn_cnf);

  /* call callback function */
  api_data_p->callback((T_SOCK_EVENTSTRUCT *)&bearer_info, api_data_p->context);
}


/******************************************************************************/
LOCAL void sock_dcm_error_ind(T_DCM_ERROR_IND *dcm_error_ind,
                                    T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_BAERER_CLOSED_IND sock_bearer_closed_ind;
  T_SOCK_API_INSTANCE_DATA *api_data_p;

  TRACE_FUNCTION("[Socket API] sock_dcm_error_ind()");

  api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_bearer_closed_ind.event_type = SOCK_BAERER_CLOSED_IND;
  sock_bearer_closed_ind.result = map_dcm_result_code(dcm_error_ind->result);
  sock_bearer_closed_ind.socket = UNUSED;
  sock_bearer_closed_ind.dcm_error = dcm_error_ind->dcm_err;

  PFREE(dcm_error_ind);
  
  if(api_data_p->callback NEQ NULL)
  {
    api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_bearer_closed_ind,
                         api_data_p->context);
  }
}


/* ******************* Socket related functions ***************************** */

/******************************************************************************/
T_SOCK_RESULT sock_create(T_SOCK_API_INSTANCE api_instance,
                          T_SOCK_IPPROTO ipproto,
                          T_SOCK_CALLBACK callback,
                          void* context)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA*       socket_data;

  TRACE_FUNCTION("[Socket API] sock_create()");
  TRACE_EVENT_P1("IP-Protocol=%d",(U32)ipproto);
  
  /* set api_data  */
  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
 if(callback EQ NULL)
  return SOCK_RESULT_INVALID_PARAMETER;

 /* check for correct data */
  if((ipproto != SOCK_IPPROTO_UDP) && (ipproto != SOCK_IPPROTO_TCP))
  {
    TRACE_ERROR("[Socket API] Error: Invalid IP-Protocol");
    return SOCK_RESULT_INVALID_PARAMETER;
  } 
  if( api_data == NULL )
  {
    TRACE_ERROR("[Socket API] Error: api_instance == NULL!");
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  /* allocate socket data */
  MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
  
  /* put socket data in linked list */
  socket_data->next_socket_data = api_data->socket_data;
  api_data->socket_data         = socket_data;
  
  /* initialize socket data */
  socket_data->api_data        = api_data;
  socket_data->tcpip_socket    = 0;
  socket_data->callback        = callback;
  socket_data->context         = context;
  socket_data->rx_flow_control = SOCK_FLOW_XON;
  socket_data->tx_flow_control = SOCK_FLOW_XON;
  socket_data->rx_window       = 1;
  socket_data->tx_window       = 1;
  
  /* send primitive to TCPIP */
  {
    PALLOC(tcpip_create_req_prim, TCPIP_CREATE_REQ);

    tcpip_create_req_prim->app_handle = api_data->hCommAPP;
    tcpip_create_req_prim->ipproto    = ipproto;
    tcpip_create_req_prim->request_id = (T_SOCK_SOCKET)socket_data;

    PSEND(api_data->hCommTCPIP, tcpip_create_req_prim);
  }

  return SOCK_RESULT_OK;
}/* sock_create */


/*****************************************************************************************
** Function  : sock_create_cnf
** Parameter : T_TCPIP_CREATE_CNF *
**             T_SOCK_API_INSTANCE ' this value will be ignored in this function
**             because you can find socket_data only using request_id
*****************************************************************************************/
LOCAL void sock_create_cnf(T_TCPIP_CREATE_CNF  *tcpip_create_cnf,
                                  T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA* socket_data;
  T_SOCK_CREATE_CNF   sock_create_cnf;

  TRACE_FUNCTION("[Socket API] sock_create_cnf()");

  /* set socket data */
  socket_data = (T_SOCK_SOCKET_DATA*)tcpip_create_cnf->request_id;
  
  /* set received values */
  socket_data->tcpip_socket = tcpip_create_cnf->socket;
  
  /* fill confirm struct */
  sock_create_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_create_cnf->event_type;
  sock_create_cnf.result     = (T_SOCK_RESULT)tcpip_create_cnf->result;
  sock_create_cnf.socket     = (T_SOCK_SOCKET)socket_data;
  
  socket_data->callback((T_SOCK_EVENTSTRUCT *)&sock_create_cnf, socket_data->context);

  /* release socket data if context creation was not successful */
  if(tcpip_create_cnf->result != TCPIP_RESULT_OK)
  {
    TRACE_ERROR("[Socket API] Error: sock_create() failed");
    ReleaseSocketData(socket_data->api_data, socket_data);
  }
  
  PFREE(tcpip_create_cnf);
}/* sock_create_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_close(T_SOCK_SOCKET socket)
{
  T_SOCK_API_INSTANCE_DATA*  api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_close()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data = sock_data->api_data;
   
  /* send primitive to TCPIP */
  {
    PALLOC(tcpip_close_req_prim, TCPIP_CLOSE_REQ);
    tcpip_close_req_prim->app_handle = api_data->hCommAPP;
    tcpip_close_req_prim->socket = sock_data->tcpip_socket;
    PSEND(api_data->hCommTCPIP, tcpip_close_req_prim);
  }
  return SOCK_RESULT_OK;
}/* sock_close */


/*******************************************************************************
** Function  : sock_close_cnf
** Parameter : T_SOCK_CLOSE_CNF *
*******************************************************************************/
LOCAL void sock_close_cnf(T_TCPIP_CLOSE_CNF *tcpip_close_cnf,
                                 T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA* sock_data;
  T_SOCK_CLOSE_CNF   sock_close_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_close_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_data =  FindSocketData(api_data ,tcpip_close_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_close_cnf);
    return;
  }

  /* fill confirm struct */
  sock_close_cnf.event_type  = (T_SOCK_EVENTTYPE)tcpip_close_cnf->event_type;
  sock_close_cnf.result      = (T_SOCK_RESULT)tcpip_close_cnf->result;
  sock_close_cnf.socket      = (T_SOCK_SOCKET)sock_data;
  
  sock_data->callback(&sock_close_cnf, sock_data->context);

  /* release socket data if sock closing was successful */
  if(tcpip_close_cnf->result == TCPIP_RESULT_OK)
  {
    ReleaseSocketData(sock_data->api_data, sock_data);
  }
  
  PFREE(tcpip_close_cnf);
}/* sock_close_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_bind(T_SOCK_SOCKET socket, T_SOCK_PORT  port)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA *sock_data;

  TRACE_FUNCTION("[Socket API] sock_bind()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data = sock_data->api_data;
  {
    PALLOC (tcpip_bind_req_prim, TCPIP_BIND_REQ);
    tcpip_bind_req_prim->app_handle = api_data->hCommAPP;
    tcpip_bind_req_prim->socket     = sock_data->tcpip_socket;
    tcpip_bind_req_prim->port       = port;
    PSEND(api_data->hCommTCPIP, tcpip_bind_req_prim);
  }
  return SOCK_RESULT_OK;
}/* sock_bind */


/*******************************************************************************
** Function  : sock_bind_cnf
** Parameter : T_SOCK_BIND_CNF *
**                   T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_bind_cnf(T_TCPIP_BIND_CNF  *tcpip_bind_cnf,
                                T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_BIND_CNF sock_bind_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_bind_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  sock_data =  FindSocketData(api_data ,tcpip_bind_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_bind_cnf);
    return;
  }

  /* fill confirm struct */
  sock_bind_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_bind_cnf->event_type;
  sock_bind_cnf.result     = (T_SOCK_RESULT)tcpip_bind_cnf->result; 
  sock_bind_cnf.socket     = (T_SOCK_SOCKET)sock_data;

  sock_data->callback(&sock_bind_cnf,sock_data->context);

  PFREE(tcpip_bind_cnf);
}/* sock_bind_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_listen(T_SOCK_SOCKET socket )
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;
    
  TRACE_FUNCTION("[Socket API] sock_listen()");
    
  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    TRACE_ERROR("[Socket API] listen() error: Invalid socket data");
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data   = sock_data->api_data;
  {
    PALLOC (tcpip_listen_req_prim, TCPIP_LISTEN_REQ);
    tcpip_listen_req_prim->app_handle = api_data->hCommAPP;
    tcpip_listen_req_prim->socket = sock_data->tcpip_socket;
    PSEND(api_data->hCommTCPIP,tcpip_listen_req_prim );
  }
	return SOCK_RESULT_OK;
}/* sock_listen */


/*******************************************************************************
** Function  : sock_listen_cnf
** Parameter : T_SOCK_LISTEN_CNF *
**             T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_listen_cnf(T_TCPIP_LISTEN_CNF *tcpip_listen_cnf,
                                 T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_LISTEN_CNF sock_listen_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_listen_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  sock_data = FindSocketData(api_data ,tcpip_listen_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_listen_cnf);
    return;
  }

  /* fill confirm struct */
  sock_listen_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_listen_cnf->event_type;
  sock_listen_cnf.result     = (T_SOCK_RESULT)tcpip_listen_cnf->result; 
  sock_listen_cnf.socket     = (T_SOCK_SOCKET)sock_data;

  sock_data->callback(&sock_listen_cnf,sock_data->context);

  PFREE(tcpip_listen_cnf);
} /* sock_listen_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_connect(T_SOCK_SOCKET socket,
                           T_SOCK_IPADDR ipaddr,
                           T_SOCK_PORT port)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("sock_connect()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
      TRACE_ERROR("[Socket API] connect error: Invalid socket data");
      return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data = sock_data->api_data;
  {
    PALLOC (tcpip_connect_req_prim, TCPIP_CONNECT_REQ);
    tcpip_connect_req_prim->app_handle = api_data->hCommAPP;
    tcpip_connect_req_prim->socket = sock_data->tcpip_socket;
    tcpip_connect_req_prim->ipaddr = ipaddr;
    tcpip_connect_req_prim->port   = port;
    PSEND(api_data->hCommTCPIP, tcpip_connect_req_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_connect */


/*******************************************************************************
** Function  : sock_connect_cnf
** Parameter : T_SOCK_CONNECT_CNF *
**             T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_connect_cnf(T_TCPIP_CONNECT_CNF *tcpip_connect_cnf,
                                   T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_CONNECT_CNF sock_connect_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("sock_connect_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  TRACE_EVENT_P3("api_data %d, socket %d, reslut %d",api_data,
                 tcpip_connect_cnf->socket,tcpip_connect_cnf->result);

  sock_data =  FindSocketData(api_data ,tcpip_connect_cnf->socket);
  if(sock_data == NULL)
  {
    TRACE_EVENT("sock data NULL !!!");
    PFREE(tcpip_connect_cnf);
    return;
  }

  /* fill confirm struct */
  sock_connect_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_connect_cnf->event_type;
  sock_connect_cnf.result     = (T_SOCK_RESULT)tcpip_connect_cnf->result; 
  sock_connect_cnf.socket     = (T_SOCK_SOCKET)sock_data;

  sock_data->callback(&sock_connect_cnf,sock_data->context);

  PFREE(tcpip_connect_cnf);
} /* sock_connect_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_getsockname(T_SOCK_SOCKET socket)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("sock_getsockname()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    TRACE_ERROR("[Socket API] getsockname() error: Invalid socket data");
    return SOCK_RESULT_INVALID_PARAMETER;
  }
    api_data   = sock_data->api_data;

  {
    PALLOC(tcpip_sockname_req_prim, TCPIP_SOCKNAME_REQ);
    tcpip_sockname_req_prim->app_handle = api_data->hCommAPP;
    tcpip_sockname_req_prim->socket = sock_data->tcpip_socket;
    PSEND(api_data->hCommTCPIP, tcpip_sockname_req_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_getsockname */



/*******************************************************************************
** Function  : sock_connect_cnf
** Parameter : T_SOCK_SOCKNAME_CNF *
**             T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_sockname_cnf(T_TCPIP_SOCKNAME_CNF *tcpip_sockname_cnf,
                                    T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_SOCKNAME_CNF sock_sockname_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("sock_getsockname_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_data =  FindSocketData(api_data , tcpip_sockname_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_sockname_cnf);
    return;
  }

  /* fill confirm struct */
  sock_sockname_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_sockname_cnf->event_type;
  sock_sockname_cnf.result     = (T_SOCK_RESULT)tcpip_sockname_cnf->result; 
  sock_sockname_cnf.socket     = (T_SOCK_SOCKET)sock_data;
  sock_sockname_cnf.ipaddr     = tcpip_sockname_cnf->ipaddr;
  sock_sockname_cnf.port       = tcpip_sockname_cnf->port;

  sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_sockname_cnf,sock_data->context);

  PFREE(tcpip_sockname_cnf);
} /* sock_sockname_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_getpeername(T_SOCK_SOCKET socket)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("sock_getpeername()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  api_data   = sock_data->api_data;
  
  if((sock_data == NULL) OR (api_data == NULL))
  {
    TRACE_ERROR("[Socket API] getpeername() error: Invalid socket data");
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  {
    PALLOC (tcpip_peername_req_prim, TCPIP_PEERNAME_REQ);
    tcpip_peername_req_prim->app_handle = api_data->hCommAPP;
    tcpip_peername_req_prim->socket = sock_data->tcpip_socket;
    PSEND(api_data->hCommTCPIP, tcpip_peername_req_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_getpeername */


/*******************************************************************************
** Function  : sock_peername_cnf
** Parameter : T_SOCK_PEERNAME_CNF *
**                   T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_peername_cnf(T_TCPIP_PEERNAME_CNF *tcpip_peername_cnf,
                                   T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_PEERNAME_CNF sock_peername_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("sock_getpeername_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_data =  FindSocketData(api_data ,tcpip_peername_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_peername_cnf);
    return;
  }

  sock_peername_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_peername_cnf->event_type;
  sock_peername_cnf.result     = (T_SOCK_RESULT)tcpip_peername_cnf->result; 
  sock_peername_cnf.socket     = (T_SOCK_SOCKET)sock_data;
  sock_peername_cnf.ipaddr     = tcpip_peername_cnf->ipaddr;
  sock_peername_cnf.port       = tcpip_peername_cnf->port;
   
  sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_peername_cnf,sock_data->context);

  PFREE(tcpip_peername_cnf);
} /* sock_peername_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_gethostbyname(T_SOCK_API_INSTANCE api_instance,
                                 char* hostname, 
                                 T_SOCK_CALLBACK callback,
                                 void* context)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA*       socket_data;

  TRACE_FUNCTION("sock_gethostbyname()");
  TRACE_EVENT_P1("hostname: %s",hostname);

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  if(callback EQ NULL)
   return SOCK_RESULT_INVALID_PARAMETER;

  if(api_data == NULL)
  {
    TRACE_ERROR("[Socket API] gethostbyname() error: Invalid socket data");
    return SOCK_RESULT_INVALID_PARAMETER;
  }
  
  MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
  
  /* put socket data in linked list */
  socket_data->next_socket_data = api_data->socket_data;
  api_data->socket_data         = socket_data;
  
  /* initialize socket data */
  socket_data->api_data        = api_data;
  socket_data->tcpip_socket    = 0;
  socket_data->callback        = callback;
  socket_data->context         = context;
  socket_data->rx_flow_control = SOCK_FLOW_XON; 
  socket_data->tx_flow_control = SOCK_FLOW_XON;
  socket_data->rx_window       = 1;
  socket_data->tx_window       = 1;

  {
    PALLOC (tcpip_hostinfo_req_prim , TCPIP_HOSTINFO_REQ);
    tcpip_hostinfo_req_prim->app_handle = api_data->hCommAPP;
    tcpip_hostinfo_req_prim->ipaddr = 0;
    strcpy((char*)tcpip_hostinfo_req_prim->hostname, hostname);
    tcpip_hostinfo_req_prim->request_id = (T_SOCK_SOCKET)socket_data;     
    PSEND(api_data->hCommTCPIP,tcpip_hostinfo_req_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_gethostbyname */


/*******************************************************************************
** Function  : sock_hostinfo_cnf
** Parameter : T_SOCK_HOSTINFO_CNF *
**             T_SOCK_API_INSTANCE    this value will be ignored ...
**                                    because you can find sock_data using request_id.
*******************************************************************************/
LOCAL void sock_hostinfo_cnf(T_TCPIP_HOSTINFO_CNF* tcpip_hostinfo_cnf , 
                                       T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA* socket_data;
  T_SOCK_HOSTINFO_CNF  sock_hostinfo_cnf;

  socket_data = (T_SOCK_SOCKET_DATA*)tcpip_hostinfo_cnf->request_id;
  
  /* set received values */
  socket_data->tcpip_socket = tcpip_hostinfo_cnf->socket;
  
  /* fill confirm struct */
  sock_hostinfo_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_hostinfo_cnf->event_type;
  sock_hostinfo_cnf.result     = (T_SOCK_RESULT)tcpip_hostinfo_cnf->result;
  sock_hostinfo_cnf.socket     = (T_SOCK_SOCKET)socket_data;
  sock_hostinfo_cnf.ipaddr     =  tcpip_hostinfo_cnf->ipaddr;
  strcpy(sock_hostinfo_cnf.hostname,(char*)tcpip_hostinfo_cnf->hostname);

  socket_data->callback((T_SOCK_EVENTSTRUCT*)&sock_hostinfo_cnf, socket_data->context);

  ReleaseSocketData(socket_data->api_data, socket_data);
  
  PFREE(tcpip_hostinfo_cnf);
} /* sock_hostinfo_cnf */


/******************************************************************************/
T_SOCK_RESULT sock_send(T_SOCK_SOCKET socket, char* buffer, U16 buffer_length)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_send()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data   = sock_data->api_data;

  if(sock_data->tx_window != 0)
  {
    PALLOC(tcpip_data_req_prim,TCPIP_DATA_REQ);
  	tcpip_data_req_prim->app_handle = api_data->hCommAPP;
  	tcpip_data_req_prim->socket     = sock_data->tcpip_socket;
  	tcpip_data_req_prim->ipaddr     = 0;
  	tcpip_data_req_prim->port       = 0;
  	tcpip_data_req_prim->buflen     =  buffer_length;
  	tcpip_data_req_prim->data       = (U32) M_ALLOC(buffer_length);

  	if(tcpip_data_req_prim->data)
  	{
      /* copy the user data buffer, 
         the prim-data is freed by tcpip_clear_send_buffer() */
      memcpy((char *)tcpip_data_req_prim->data,buffer,buffer_length);
    }
  	else
  	{
      PFREE(tcpip_data_req_prim);
      return SOCK_RESULT_OUT_OF_MEMORY;
    }
    sock_data->tx_window--;
  	PSEND(api_data->hCommTCPIP,tcpip_data_req_prim); 
  	return SOCK_RESULT_OK;
  }
  else /* tx_window = 0 */
  {
    sock_data->tx_flow_control = SOCK_FLOW_XOFF;
    return SOCK_RESULT_NO_BUFSPACE;
  }
} /* sock_send */


/******************************************************************************/
T_SOCK_RESULT sock_sendto(T_SOCK_SOCKET socket, char* buffer,U16 buffer_length,
                          T_SOCK_IPADDR ipaddr,T_SOCK_PORT port)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_sendto()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
      return SOCK_RESULT_INVALID_PARAMETER;
  api_data   = sock_data->api_data;

  if(sock_data->tx_window != 0)
  {
    PALLOC(tcpip_data_req_prim,TCPIP_DATA_REQ);
  	tcpip_data_req_prim->app_handle = api_data->hCommAPP;
  	tcpip_data_req_prim->socket        = sock_data->tcpip_socket;
  	tcpip_data_req_prim->ipaddr        = ipaddr;
  	tcpip_data_req_prim->port          = port;
  	tcpip_data_req_prim->buflen        =  buffer_length;
	  tcpip_data_req_prim->data=(U32) M_ALLOC(buffer_length);
  	if(tcpip_data_req_prim->data )
  	{
      /* copy the user data buffer, 
         the prim-data is freed by tcpip_clear_send_buffer() */
      memcpy((char *)tcpip_data_req_prim->data,buffer,buffer_length);
  	}
  	else
  	{
  	  PFREE(tcpip_data_req_prim);
  	  return SOCK_RESULT_OUT_OF_MEMORY;
  	}

 	  sock_data->tx_window--;
 	  PSEND(api_data->hCommTCPIP, tcpip_data_req_prim);
    return SOCK_RESULT_OK;
  }
  else /* tx_window = 0 */
  {
    sock_data->tx_flow_control = SOCK_FLOW_XOFF;
    return SOCK_RESULT_NO_BUFSPACE;
  }
}

  
/*******************************************************************************
** Function  : sock_mtu_size_cnf
** Parameter : T_SOCK_MTU_SIZE_CNF *
**             T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_mtu_size_cnf(T_TCPIP_MTU_SIZE_CNF *tcpip_mtu_size_cnf ,
                                   T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_MTU_SIZE_CNF sock_mtu_size_cnf;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_mtu_size_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_data =  FindSocketData(api_data ,tcpip_mtu_size_cnf->socket);
  if(sock_data == NULL)
  {
    PFREE(tcpip_mtu_size_cnf);
    return;
  }

  sock_mtu_size_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_mtu_size_cnf->event_type;
  sock_mtu_size_cnf.result     = (T_SOCK_RESULT)tcpip_mtu_size_cnf->result; 
  sock_mtu_size_cnf.socket     = (T_SOCK_SOCKET)sock_data;
  sock_mtu_size_cnf.mtu_size   =  tcpip_mtu_size_cnf->mtu_size;

  sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_mtu_size_cnf,sock_data->context);

  PFREE(tcpip_mtu_size_cnf);
} /* sock_mtu_size_cnf */



/*******************************************************************************
** Function  : sock_connect_ind
** Parameter : T_SOCK_CONNECT_IND *
**                   T_SOCK_API_INSTANCE
** Description : new socket_data will be linked to current socket_data(listening socke_data)
*******************************************************************************/
LOCAL void sock_connect_ind(T_TCPIP_CONNECT_IND *tcpip_connect_ind , 
                                  T_SOCK_API_INSTANCE api_instance )
{
  T_SOCK_SOCKET_DATA *cur_sock_data;   /* listening socket_data */
  T_SOCK_SOCKET_DATA *new_sock_data;   /* connected socket_data */
  T_SOCK_CONNECT_IND sock_connect_ind;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_connect_ind()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  /* find listening socket_data
   * tcpip_connent_ind->socket is listening socket descrpitor
   */
  cur_sock_data =  FindSocketData(api_data ,tcpip_connect_ind->socket);
  if(cur_sock_data == NULL)
  {
    PFREE(tcpip_connect_ind);
    return;
  }

  /* allocate socket data */
  MALLOC(new_sock_data, sizeof(T_SOCK_SOCKET_DATA));

  /* put socket data in linked list */
  new_sock_data->next_socket_data = NULL;     
  cur_sock_data->next_socket_data = new_sock_data;

  /* initialize socket data */
  new_sock_data->api_data        = api_data;
  new_sock_data->tcpip_socket    = tcpip_connect_ind->new_socket;
  /* server must register callback using socket_get_callback() after receiving */
  /* connect ind event.                                                        */
  new_sock_data->callback        = NULL; 
  new_sock_data->context         = NULL;  
  new_sock_data->rx_flow_control = SOCK_FLOW_XON;
  new_sock_data->tx_flow_control = SOCK_FLOW_XON;
  new_sock_data->rx_window       = 1;
  new_sock_data->tx_window       = 1;

  /* fill confirm struct */
  sock_connect_ind.event_type   = (T_SOCK_EVENTTYPE)tcpip_connect_ind->event_type;
  sock_connect_ind.result       = (T_SOCK_RESULT)tcpip_connect_ind->result; 
  /* Check !!! why cur_sock data become new_sock_data */
  /* sock_connect_ind.socket       = (T_SOCK_SOCKET)cur_sock_data;*/
  sock_connect_ind.socket          = (T_SOCK_SOCKET)new_sock_data;   
  sock_connect_ind.new_socket   =  tcpip_connect_ind->new_socket;
  sock_connect_ind.peer_ipaddr  =  tcpip_connect_ind->ipaddr;
  sock_connect_ind.peer_port    =  tcpip_connect_ind->port;

  cur_sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_connect_ind,cur_sock_data->context);

  PFREE(tcpip_connect_ind);
} /* sock_connect_ind */


/*******************************************************************************
** Function  : sock_conn_closed_ind
** Parameter : T_SOCK_CONN_CLOSED_IND *
**             T_SOCK_API_INSTANCE
**             Release closed socket data
*******************************************************************************/
LOCAL void sock_conn_closed_ind(T_TCPIP_CONN_CLOSED_IND *tcpip_conn_closed_ind,
                                      T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_CONN_CLOSED_IND sock_conn_closed_ind;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_closed_ind()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;

  sock_data =  FindSocketData(api_data, tcpip_conn_closed_ind->socket);
  if(sock_data != NULL)
  {
    sock_conn_closed_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_conn_closed_ind->event_type; 
    sock_conn_closed_ind.result     = (T_SOCK_RESULT)tcpip_conn_closed_ind->result;  
    sock_conn_closed_ind.socket     = (T_SOCK_SOCKET)sock_data;

    sock_data->callback(&sock_conn_closed_ind,sock_data->context);

    ReleaseSocketData(sock_data->api_data,sock_data);
  }
  else {;}

  PFREE(tcpip_conn_closed_ind);
} /* sock_conn_closed_ind */


/*******************************************************************************
** Function  : sock_error_ind
** Parameter : T_SOCK_ERROR_IND *
**             T_SOCK_API_INSTANCE
*******************************************************************************/
LOCAL void sock_error_ind(T_TCPIP_ERROR_IND* tcpip_error_ind , 
                                T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA*   sock_data;
  T_SOCK_ERROR_IND sock_error_ind;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_error_ind()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
  sock_data =  FindSocketData(api_data , tcpip_error_ind->socket);
  if(sock_data != NULL)
  {
    /* fill confirm struct */
    sock_error_ind.event_type   = (T_SOCK_EVENTTYPE)tcpip_error_ind->event_type;
    sock_error_ind.result       = (T_SOCK_RESULT)tcpip_error_ind->result; 
    sock_error_ind.socket       = (T_SOCK_SOCKET)sock_data;

    sock_data->callback(&sock_error_ind,sock_data->context);
  }
  else {;}
  
  PFREE(tcpip_error_ind);
} /* sock_error_ind */


/******************************************************************************/
T_SOCK_RESULT sock_gethostbyaddr(T_SOCK_API_INSTANCE api_instance,
                                 T_SOCK_IPADDR ipaddr, 
                                 T_SOCK_CALLBACK callback,
                                 void* context )
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA*     socket_data;

  TRACE_FUNCTION("[Socket API] sock_gethostbyaddr()");

  if(callback EQ NULL)
   return SOCK_RESULT_INVALID_PARAMETER;

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
  MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
   
  /* put socket data in linked list */
  socket_data->next_socket_data = api_data->socket_data;
  api_data->socket_data         = socket_data;
  
  /* initialize socket data */
  socket_data->api_data        = api_data;
  socket_data->tcpip_socket    = 0;
  socket_data->callback        = callback;
  socket_data->context         = context;
  socket_data->rx_flow_control = SOCK_FLOW_XON;
  socket_data->tx_flow_control = SOCK_FLOW_XON;
  socket_data->rx_window       = 1;
  socket_data->tx_window       = 1;
  
  {
    PALLOC (tcpip_hostinfo_req_prim ,TCPIP_HOSTINFO_REQ);
    tcpip_hostinfo_req_prim->app_handle = api_data->hCommAPP;
    tcpip_hostinfo_req_prim->ipaddr = ipaddr;
    *tcpip_hostinfo_req_prim->hostname = 0;
    tcpip_hostinfo_req_prim->request_id = (T_SOCK_SOCKET)socket_data;     
    PSEND(api_data->hCommTCPIP, tcpip_hostinfo_req_prim);
 }
 return SOCK_RESULT_OK;
} /* sock_gethostbyaddr */


/*******************************************************************************
   Function     :  sock_recv_ind
   Parameter    :  T_TCPIP_DATA_IND*
                   T_SOCK_API_INSTANCE  
   Return       : VOID
   Return Event : None
*******************************************************************************/
static void sock_recv_ind(T_TCPIP_DATA_IND* tcpip_data_ind,
                                T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA*   sock_data;
  T_SOCK_RECV_IND sock_receive_ind;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_recv_ind()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  
  sock_data =  FindSocketData(api_data , tcpip_data_ind->socket);
  if(sock_data == NULL)
  {
    MFREE(tcpip_data_ind->data);
    PFREE(tcpip_data_ind);
    return;
  }

  sock_data->rx_window--;  /* when data received, window size will be descreased..*/

  if(sock_data->rx_flow_control == SOCK_FLOW_XOFF )
  {
    /* case sock flow xoff, sock_data will be stored and send to the application
       with sock_flow_xon() */
    sock_data->recv_ind.socket  = tcpip_data_ind->socket;
    sock_data->recv_ind.result = (T_SOCK_RESULT)tcpip_data_ind->result;
    sock_data->recv_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_data_ind->event_type;
    sock_data->recv_ind.data_length = tcpip_data_ind->buflen;
    sock_data->recv_ind.data_buffer = (char*)tcpip_data_ind->data;
  }
  else 
  {
    /* case sock flow xon , sock_data will be sent to application...*/
    sock_receive_ind.event_type   =  (T_SOCK_EVENTTYPE)tcpip_data_ind->event_type;
    sock_receive_ind.result       =  (T_SOCK_RESULT)tcpip_data_ind->result;
    sock_receive_ind.socket       =  (T_SOCK_SOCKET)sock_data;
    sock_receive_ind.data_length  =  tcpip_data_ind->buflen;
    sock_receive_ind.data_buffer  =  (char *)tcpip_data_ind->data;

    sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_receive_ind,sock_data->context);

    /* send primitive */
    if( (sock_data->rx_flow_control != SOCK_FLOW_XOFF) &&
        (sock_data->rx_window == 0) )
    {
      PALLOC(tcpip_data_res_prim,TCPIP_DATA_RES);
      tcpip_data_res_prim->app_handle = api_data->hCommAPP;
      ACI_ASSERT(sock_data->tcpip_socket == tcpip_data_ind->socket);
      tcpip_data_res_prim->socket       =  tcpip_data_ind->socket ;
      tcpip_data_res_prim->window       = 1;  
      sock_data->rx_window   = 1;
      PSEND(api_data->hCommTCPIP, tcpip_data_res_prim);	
    }
  }
  PFREE(tcpip_data_ind);
} /* sock_recv_ind */


/*******************************************************************************
** Function  : sock_send_cnf
** Parameter : T_TCPIP_DATA_CNF *
**                   T_SOCK_API_INSTANCE
*******************************************************************************/
static void sock_send_cnf(T_TCPIP_DATA_CNF* tcpip_data_cnf,
                                T_SOCK_API_INSTANCE api_instance)
{
  T_SOCK_SOCKET_DATA *sock_data;
  T_SOCK_API_INSTANCE_DATA *api_data;
  T_SOCK_FLOW_READY_IND sock_flow_ready_ind;

  TRACE_FUNCTION("[Socket API] sock_send_cnf()");

  api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  sock_data =  FindSocketData(api_data , tcpip_data_cnf->socket);

  if(sock_data == NULL)
  {
    PFREE(tcpip_data_cnf);
    return;
  }
  /* if tcpip_data_cnf->window is 0,*/
  /* this value will be 1 because 0 and 1 is the same meaning in the Rnet TCPIP.*/
  if( tcpip_data_cnf->window  == 0 )
  {
    sock_data->tx_window  = 1;
  }
  else
  {
    sock_data->tx_window = tcpip_data_cnf->window;
  }

  sock_flow_ready_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_data_cnf->event_type;
  sock_flow_ready_ind.result     = (T_SOCK_RESULT)tcpip_data_cnf->result; 
  sock_flow_ready_ind.socket     = (T_SOCK_SOCKET)sock_data;
  /* permit next packet to be send */
  sock_data->tx_flow_control     = SOCK_FLOW_XON;

  sock_data->callback(&sock_flow_ready_ind,sock_data->context);

  PFREE(tcpip_data_cnf);
}


/******************************************************************************/
T_SOCK_RESULT sock_set_callback(T_SOCK_SOCKET socket ,T_SOCK_CALLBACK new_callback, 
                                void* new_context)
{
  T_SOCK_SOCKET_DATA* sock_data;

  sock_data = (T_SOCK_SOCKET_DATA*)socket;

  if(new_callback EQ NULL)
   return SOCK_RESULT_INVALID_PARAMETER;

  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  sock_data->callback = new_callback;
  sock_data->context = new_context;

  return SOCK_RESULT_OK;
}


/******************************************************************************/
T_SOCK_RESULT sock_get_callback(T_SOCK_SOCKET socket, T_SOCK_CALLBACK *callback_p,
                                void **context_p)
{
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_get_callback()");
  
  /* get current callback,context */    
  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }
  if(callback_p != NULL)
  {
    callback_p = &sock_data->callback;
  }
  if(context_p != NULL)
  {
    context_p  = &sock_data->context;
  }
  return SOCK_RESULT_OK;
} /* socket_get_callback */


/******************************************************************************/
T_SOCK_RESULT sock_flow_xoff(T_SOCK_SOCKET socket)
{
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_flow_xoff()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  sock_data->rx_flow_control = SOCK_FLOW_XOFF;

  return SOCK_RESULT_OK;
 
} /* sock_flow_xoff */


/******************************************************************************/
T_SOCK_RESULT sock_flow_xon(T_SOCK_SOCKET socket)
{
  T_SOCK_SOCKET_DATA* sock_data;
  T_SOCK_RECV_IND sock_receive_ind;
  T_SOCK_API_INSTANCE_DATA *api_data;

  TRACE_FUNCTION("[Socket API] sock_flow_xon()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;

  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data = sock_data->api_data;
  sock_data->rx_flow_control = SOCK_FLOW_XON;
  
  if(sock_data->recv_ind.data_length != 0)
  {     
    sock_receive_ind.event_type  = sock_data->recv_ind.event_type;
    sock_receive_ind.result      = sock_data->recv_ind.result;
    sock_receive_ind.socket      = (T_SOCK_SOCKET)sock_data;
    sock_receive_ind.data_length  = sock_data->recv_ind.data_length;
    sock_receive_ind.data_buffer  = sock_data->recv_ind.data_buffer;

    /* clear recv_ind struct, buffer is freed by application */
    memset(&sock_data->recv_ind, 0x00 , sizeof(T_SOCK_RECV_IND)); 

    sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_receive_ind,sock_data->context);
  }

  if((sock_data->rx_flow_control != SOCK_FLOW_XOFF) && (sock_data->rx_window == 0))
  {
    PALLOC(tcpip_data_res_prim,TCPIP_DATA_RES);
    tcpip_data_res_prim->app_handle = api_data->hCommAPP;
    tcpip_data_res_prim->socket   =  sock_data->tcpip_socket;
    tcpip_data_res_prim->window  = 1;
    sock_data->rx_window = 1;

    PSEND(api_data->hCommTCPIP, tcpip_data_res_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_flow_xon */


/******************************************************************************/
T_SOCK_RESULT sock_get_mtu_size(T_SOCK_SOCKET socket)
{
  T_SOCK_API_INSTANCE_DATA* api_data;
  T_SOCK_SOCKET_DATA* sock_data;

  TRACE_FUNCTION("[Socket API] sock_get_mtu_size()");

  sock_data = (T_SOCK_SOCKET_DATA*)socket;

  /* check whether sock_data is NULL or not */
  if(sock_data == NULL)
  {
    return SOCK_RESULT_INVALID_PARAMETER;
  }

  api_data   = sock_data->api_data;

  /* send primitive */
  {
    PALLOC (tcpip_mtu_size_req_prim, TCPIP_MTU_SIZE_REQ);
    tcpip_mtu_size_req_prim->app_handle = api_data->hCommAPP;
    tcpip_mtu_size_req_prim->socket     = sock_data->tcpip_socket;
    PSEND(api_data->hCommTCPIP, tcpip_mtu_size_req_prim);
  }
  return SOCK_RESULT_OK;
} /* sock_get_mtu_size */


/******************************************************************************/
LOCAL void pei_not_supported (void *data)
{
  TRACE_FUNCTION ("pei_not_supported()");

  PFREE (data);
}


/******************************************************************************/
BOOL sock_api_handles_primitive( T_SOCK_API_INSTANCE api_instance, T_PRIM* prim)
{
  LOCAL const T_FUNC tcpip_table[] = 
  {
    MAK_FUNC_N( pei_not_supported,     0 /*TCPIP_INITIALIZE_CNF*/ ),  /* 0x00 */
    MAK_FUNC_N( pei_not_supported,     0 /*TCPIP_SHUTDOWN_CNF*/   ),  /* 0x01 */
    MAK_FUNC_N( pei_not_supported,     0 /*TCPIP_IFCONFIG_CNF */  ),  /* 0x02 */
    MAK_FUNC_N( pei_not_supported,     0 /*TCPIP_DTI_CNF*/        ),  /* 0x03 */
    MAK_FUNC_0( sock_create_cnf,       TCPIP_CREATE_CNF           ),  /* 0x04 */
    MAK_FUNC_0( sock_close_cnf,        TCPIP_CLOSE_CNF            ),  /* 0x05 */
    MAK_FUNC_0( sock_bind_cnf,         TCPIP_BIND_CNF             ),  /* 0x06 */
    MAK_FUNC_0( sock_listen_cnf,       TCPIP_LISTEN_CNF           ),  /* 0x07 */
    MAK_FUNC_0( sock_connect_cnf,      TCPIP_CONNECT_CNF          ),  /* 0x08 */
    MAK_FUNC_0( sock_send_cnf,         TCPIP_DATA_CNF             ),  /* 0x09 */
    MAK_FUNC_0( sock_recv_ind,         TCPIP_DATA_IND             ),  /* 0x0a */
    MAK_FUNC_0( sock_sockname_cnf,     TCPIP_SOCKNAME_CNF         ),  /* 0x0b */
    MAK_FUNC_0( sock_peername_cnf,     TCPIP_PEERNAME_CNF         ),  /* 0x0c */
    MAK_FUNC_0( sock_hostinfo_cnf,     TCPIP_HOSTINFO_CNF         ),  /* 0x0d */
    MAK_FUNC_0( sock_mtu_size_cnf,     TCPIP_MTU_SIZE_CNF         ),  /* 0x0e */
    MAK_FUNC_0( sock_connect_ind,      TCPIP_CONNECT_IND          ),  /* 0x0f */
    MAK_FUNC_0( sock_conn_closed_ind,  TCPIP_CONN_CLOSED_IND      ),  /* 0x10 */
    MAK_FUNC_0( sock_error_ind,        TCPIP_ERROR_IND            ),  /* 0x11 */
  };

  LOCAL const T_FUNC dcm_table[] =
  {
    MAK_FUNC_0( sock_open_bearer_cnf,     DCM_OPEN_CONN_CNF       ),
    MAK_FUNC_0( sock_close_bearer_cnf,    DCM_CLOSE_CONN_CNF      ),
    MAK_FUNC_0( sock_bearer_info_cnf,     DCM_GET_CURRENT_CONN_CNF),
    MAK_FUNC_0( sock_dcm_error_ind,       DCM_ERROR_IND           ),
  };

  TRACE_FUNCTION("sock_api_handles_primitive()");

  if(prim NEQ NULL)
  {
    ULONG        opc = prim->custom.opc;
    USHORT       tabsize;
    const T_FUNC *table = 0;

    switch( SAP_NR(opc) )
    {
      case SAP_NR(TCPIP_DL):
        table = tcpip_table;
        tabsize = TAB_SIZE (tcpip_table);
        break;
      case SAP_NR(DCM_UL):
        table = dcm_table;
        tabsize = TAB_SIZE(dcm_table);
        break;       
      default:
        /* Primitive is not for these SAP's */
        return FALSE;
    }
    
    if (PRIM_NR(opc) < tabsize)
    {
      table += PRIM_NR(opc);
      { 
        TRACE_EVENT_P1( "sock_api_handles_primitive: %d", PRIM_NR(opc) );
      }
      JUMP (table->func) (P2D(prim),api_instance);
    }
    else
    {
      TRACE_ERROR("PRIM_NR(opc) >= tabsize");
      return FALSE;
    }
  }
  return TRUE;
} /* sock_api_handles_primitive */