/**
 * @file    rnet_rt_api_new.c
 *
 * RNET_RT API
 *
 * @author  Regis Feneon
 * @version 0.1
 */

/*
 * $Id: rnet_rt_api_new.c,v 1.4 2002/10/30 15:23:34 rf Exp $
 * $Name: ti_20021030 $
 *
 * History:
 *
 *  Date        Author        Modification
 *  --------------------------------------------------
 *  3/22/2002   Regis Feneon  Create
 *  6/24/2002   Regis Feneon  RNET_SEND_CFM renamed RNET_SEND_RDY
 *                            send this message when a connection
 *                            is accepted
 * (C) Copyright 2002 by TI, All Rights Reserved
 *
 */

#include "rnet_cfg.h"
#ifdef RNET_CFG_REAL_TRANSPORT

#include "rnet_rt_i.h"
#include "rnet_rt_env.h"
#include "rnet_message.h"


/*
 * Send a message back to the user using socket's return path
 */
static int socket_send_msg( NGsock *so, T_RV_HDR *msg)
{
  if( ((T_RNET_RT_SOCK *) so)->return_path.callback_func != NULL) {
    /* Send the message using callback function. */
    ((T_RNET_RT_SOCK *) so)->return_path.callback_func( msg);
    return( RV_OK);
  }
  else {
    /* Send the message using mailbox. */
    return( rvf_send_msg( ((T_RNET_RT_SOCK *) so)->return_path.addr_id, msg));
  }
}

NGsock *cach_so = NULL ; 

//pinghua add two function to avoid abormal sock close. OMAPS00173156 patch fix 05122008
void cach_sock_message(NGsock *so)
{

     cach_so = so ;
     return ; 	 

}

void Send_cach_message(void )
{

  union {
    T_RNET_ERROR_IND eind;
    T_RNET_CONNECT_IND cind;
    T_RNET_CONNECT_CFM ccfm;
    T_RNET_SEND_RDY srdy;
    T_RNET_RECV_IND rind;
  } *msg;

   if(cach_so==NULL)
   	return ; 
   if(cach_so->so_rcv_cc!=0)
   	return ; 
  
      RNET_RT_SEND_TRACE("RNET_RT: Send_cach_message close! ",RV_TRACE_LEVEL_ERROR);	
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_ERROR_IND),
           RNET_ERROR_IND, (T_RV_HDR **) &msg) == RVF_RED) {
          return ;
        }
        msg->eind.desc = (T_RNET_DESC *) cach_so;
        msg->eind.error = RNET_CONN_CLOSED;
        socket_send_msg( cach_so, (T_RV_HDR *) msg);
        ((T_RNET_RT_SOCK *) cach_so)->flags &= ~RNET_RT_SOCKF_NOTIFY_CLOSED;  

	cach_so= NULL; 	

}
// end 
/*
 * Socket callback function.
 * The socket events are translated to RNET messages and sent the application.
 *
 */
static void socket_callback( NGsock *so, void *data, int flags)
{
  NGsock *nso;
  NGsockaddr addr;
  NGbuf *bufp;
  char tmp[25]; 
  union {
    T_RNET_ERROR_IND eind;
    T_RNET_CONNECT_IND cind;
    T_RNET_CONNECT_CFM ccfm;
    T_RNET_SEND_RDY srdy;
    T_RNET_RECV_IND rind;
  } *msg;


   sprintf(tmp,"recv data len %d", so->so_rcv_cc);
   RNET_RT_SEND_TRACE(tmp,RV_TRACE_LEVEL_ERROR);

  msg = NULL;
  if( so->so_error != 0) {
    /* send RNET_ERROR_IND msg */
    RNET_RT_SEND_TRACE("RNET_RT: RNET_ERROR_IND ",RV_TRACE_LEVEL_ERROR);	
    if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_ERROR_IND),
       RNET_ERROR_IND, (T_RV_HDR **) &msg) == RVF_RED) {
      goto getbuf_error;
    }
    msg->eind.desc = (T_RNET_DESC *) so;
    msg->eind.error = rnet_rt_ngip_error( so->so_error);
    socket_send_msg( so, (T_RV_HDR *) msg);
    so->so_error = 0;
    return;
  }

  if( flags & NG_SAIO_READ) {
    if( so->so_state & NG_SS_CANTRCVMORE) {
      /* connection has been closed/aborted */
//pinghua add one condiction to avoid close abnormal 20080505
	  
      if( ((T_RNET_RT_SOCK *) so)->flags & RNET_RT_SOCKF_NOTIFY_CLOSED && ( so->so_rcv_cc==0 )  ) {
        /* connection is closed */
        /* send RNET_ERROR_IND/RNET_CONN_CLOSED msg */
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_ERROR_IND),
           RNET_ERROR_IND, (T_RV_HDR **) &msg) == RVF_RED) {
          goto getbuf_error;
        }
        msg->eind.desc = (T_RNET_DESC *) so;
        msg->eind.error = RNET_CONN_CLOSED;
        socket_send_msg( so, (T_RV_HDR *) msg);
        ((T_RNET_RT_SOCK *) so)->flags &= ~RNET_RT_SOCKF_NOTIFY_CLOSED;
      }
      else {              //buffer this close FIN messgae 

           cach_sock_message(so);

      	}

	  
    }
    else if( so->so_options & NG_SO_ACCEPTCONN) {
        

      /* accept a new connection */
      if( ngSAIOAccept( so, &addr, 0, &nso) == NG_EOK) {
        /* initialise rnet part of socket */
        ((T_RNET_RT_SOCK *) nso)->return_path = ((T_RNET_RT_SOCK *) so)->return_path;
        ((T_RNET_RT_SOCK *) nso)->flags =
          RNET_RT_SOCKF_NOTIFY_RECV|RNET_RT_SOCKF_NOTIFY_CLOSED;
        ((T_RNET_RT_SOCK *) nso)->user_data = NULL;
        /* install callback */
        ngSAIOSetCallback( nso, socket_callback, NULL);
        /* send RNET_CONNECT_IND msg */
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_CONNECT_IND),
           RNET_CONNECT_IND, (T_RV_HDR **) &msg) == RVF_RED) {
          ngSAIOClose( nso, 0);
          goto getbuf_error;
        }
        msg->cind.new_desc = (T_RNET_DESC *) nso;
        msg->cind.listen_desc = (T_RNET_DESC *) so;
        msg->cind.peer_addr = ngNTOHL( addr.sin_addr);
        msg->cind.peer_port = ngNTOHS( addr.sin_port);
        socket_send_msg( so, (T_RV_HDR *) msg);
        /* send first RNET_SEND_RDY message */
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_SEND_RDY),
           RNET_SEND_RDY, (T_RV_HDR **) &msg) == RVF_RED) {
          goto getbuf_error;
        }
        msg->srdy.desc = (T_RNET_DESC *) nso;
        socket_send_msg( so, (T_RV_HDR *) msg);
      }
      return;
    }
    else {
      if( ((T_RNET_RT_SOCK *) so)->flags & RNET_RT_SOCKF_NOTIFY_CONNECT) {
        /* active connection is done */
        /* send RNET_CONNECT_CFM msg */
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_CONNECT_CFM),
           RNET_CONNECT_CFM, (T_RV_HDR **) &msg) == RVF_RED) {
          goto getbuf_error;
        }
        msg->ccfm.desc = (T_RNET_DESC *) so;
        socket_send_msg( so, (T_RV_HDR *) msg);
        ((T_RNET_RT_SOCK *) so)->flags &= ~RNET_RT_SOCKF_NOTIFY_CONNECT;
        ((T_RNET_RT_SOCK *) so)->flags |= RNET_RT_SOCKF_NOTIFY_CLOSED;
        ((T_RNET_RT_SOCK *) so)->flags |= RNET_RT_SOCKF_NOTIFY_RECV ;
      }
      if( (((T_RNET_RT_SOCK *) so)->flags & RNET_RT_SOCKF_NOTIFY_RECV) &&
          (so->so_rcv_cc >= so->so_rcv_lowat)) {
        /* data has been received */
        /* send RNET_RECV_IND msg */
        if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_RECV_IND),
           RNET_RECV_IND, (T_RV_HDR **) &msg) == RVF_RED) {
          goto getbuf_error;
        }
        msg->rind.desc = (T_RNET_DESC *) so;
        /* fillin sender's address */
        if( so->so_state & NG_SS_ISCONNECTED) {
          /* socket is connected, get peer address in socket control block */
          msg->rind.peer_addr = ngNTOHL( so->so_faddr);
          msg->rind.peer_port = ngNTOHS( so->so_fport);
        }
        else if( (so->so_proto->pr_flags & NG_PR_ADDR) &&
                 ((bufp = (NGbuf *) so->so_rcv_q.qu_tail) != NULL)) {
          /* get address from last queued buffer */
          ngMemCpy( &addr, bufp->buf_iov, sizeof( NGsockaddr));
          msg->rind.peer_addr = ngNTOHL( addr.sin_addr);
          msg->rind.peer_port = ngNTOHS( addr.sin_port);
        }
        else {
          /* cannot get address, this should not happen... */
          msg->rind.peer_addr = 0;
          msg->rind.peer_port = 0;
        }
        socket_send_msg( so, (T_RV_HDR *) msg);
        ((T_RNET_RT_SOCK *) so)->flags &= ~RNET_RT_SOCKF_NOTIFY_RECV;
      }
    }
  }


  if( flags & NG_SAIO_WRITE) {
    if( !(so->so_state & NG_SS_CANTSENDMORE) &&
        (((T_RNET_RT_SOCK *) so)->flags & RNET_RT_SOCKF_NOTIFY_SEND) &&
        ((so->so_snd_hiwat - so->so_snd_cc) >= so->so_snd_lowat)) {
      /* send data has been acknowledged by peer */
      /* send RNET_SEND_RDY msg */
      if( rvf_get_msg_buf( rnet_rt_env_ctrl_blk_p->mb_id, sizeof(T_RNET_SEND_RDY),
         RNET_SEND_RDY, (T_RV_HDR **) &msg) == RVF_RED) {
        goto getbuf_error;
      }
      msg->srdy.desc = (T_RNET_DESC *) so;
      socket_send_msg( so, (T_RV_HDR *) msg);
      ((T_RNET_RT_SOCK *) so)->flags &= ~RNET_RT_SOCKF_NOTIFY_SEND;
    }
  }
  return;

getbuf_error:
  RNET_RT_SEND_TRACE("RNET_RT: cannot allocate MSG ",RV_TRACE_LEVEL_ERROR);
  return;
}

/**
 * Creates a new connection identifier (T_RNET_DESC).
 *
 * The connection ID is not active until it has either been bound
 * to a local address or connected to a remote address.
 *
 * @param  proto  Protocol that should be used [IN].
 * @param  desc  Connection identifier created [OUT].
 * @param  return_path  Return path that should be used to send
 *          the messages like accept, connect, etc [IN].
 * @return  RNET_MEMORY_ERR      No available memory to create the new connection id.
 *      RNET_NOT_INITIALIZED  NET subsystem not initialized (internal error).
 *      RNET_INTERNAL_ERR    Network subsystem failed.
 *                or  No more socket descriptors available.
 *      RNET_NOT_READY      Still processing a callback function.
 *      RNET_NOT_SUPPORTED    Specified protocol not supported.
 *      RNET_OK          Connection ID successfully created.
 */

T_RNET_RET rnet_rt_new (T_RNET_IPPROTO proto,
           T_RNET_DESC ** desc,
           T_RV_RETURN_PATH return_path)
{
  NGsock *so;
  int type, err;

  /* check if SW entity has been initialised */
  if( rnet_rt_env_ctrl_blk_p == NULL) {
    return( RNET_NOT_INITIALIZED);
  }

  /* select type of socket, only TCP and UDP allowed */
  switch( proto) {
  case RNET_IPPROTO_TCP:
    type = NG_SOCK_STREAM;
    break;
  case RNET_IPPROTO_UDP:
    type = NG_SOCK_DGRAM;
    break;
  default:
    /* invalid protocol */
    /* could create raw IP socket... */
    return( RNET_NOT_SUPPORTED);
  }

  /* create ngip socket */
  
  rvf_lock_mutex( &rnet_rt_env_ctrl_blk_p->mutex);
  err = ngSAIOCreate( &so, NG_AF_INET, type, 0, NG_O_NONBLOCK);

  if( err == NG_EOK) {
    /* initialise rnet part of socket */
    ((T_RNET_RT_SOCK *) so)->return_path = return_path;
#if 0 /* RNET_RT bug!? [ni 2003-12-05 */
    ((T_RNET_RT_SOCK *) so)->flags = RNET_RT_SOCKF_NOTIFY_RECV |
                                           RNET_RT_SOCKF_NOTIFY_SEND;
#else
    if (proto == RNET_IPPROTO_UDP) {
      /* A UDP socket is ready for communication right after it has been
       * created, ... */
      ((T_RNET_RT_SOCK *) so)->flags =
        RNET_RT_SOCKF_NOTIFY_RECV | RNET_RT_SOCKF_NOTIFY_SEND;
    } else {
      /* ... whereas a TCP socket has to be connected first. */
      ((T_RNET_RT_SOCK *) so)->flags = 0 ;
    }
#endif /* 0 */
    ((T_RNET_RT_SOCK *) so)->user_data = NULL;

    
    /* install callback */
    ngSAIOSetCallback( so, socket_callback, NULL);


  }
  rvf_unlock_mutex( &rnet_rt_env_ctrl_blk_p->mutex);

  /* returns new socket */
  if( err == NG_EOK) {
    *desc = (T_RNET_DESC *) so;
    return( RNET_OK);
  }

  /* convert error code */
  return( rnet_rt_ngip_error( err));
}

#endif /* ifdef RNET_CFG_REAL_TRANSPORT */