microser/mmslib/ositcps/tp0callg.c

/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/*	(c) Copyright Systems Integration Specialists Company, Inc.,	*/
/*	1997-2005 All Rights Reserved					*/
/*									*/
/* MODULE NAME : tp0callg.c						*/
/* PRODUCT(S)  : Lean-T Stack						*/
/*									*/
/* MODULE DESCRIPTION :							*/
/*	TP0 functions for handling of "Calling" side of connections.	*/
/*									*/
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE :				*/
/*	tp0_connect							*/
/*	tp0_process_cc							*/
/*									*/
/* MODIFICATION LOG :							*/
/*  Date     Who   Rev     Comments					*/
/* --------  ---  ------   -------------------------------------------  */
/* 11/12/08  MDE    15     Added tpdu_cc->sock_info->user_conn_id check */
/* 07/30/08  JRB    14     Use DR reason codes valid for TP0.		*/
/* 05/06/05  EJV    13     Added port param to np_connect_req call.	*/
/* 03/29/05  EJV    12     Added MMSEASE_MOSI support.			*/
/* 09/17/04  JRB    11     Chg tp0_connect to return connection ID.	*/
/* 02/02/04  JRB    10     tp0_connect: fix tp_type, bind_id checks.	*/
/* 07/30/03  EJV    09     Added encrypt_ctrl to tp0_connect.		*/
/* 04/07/03  JRB    08     Add SPDU_RX_NO_PREALLOCATE option.		*/
/* 06/20/02  JRB    07     Pass ip addr as ulong to np_connect_req.	*/
/* 06/08/99  JRB    06     Chg to support 1024 connections.		*/
/* 08/13/98  JRB    05     Lint cleanup.				*/
/* 06/17/98  JRB    04     Increment loc_ref_offset before encoding CR	*/
/*			   to avoid sending duplicate CR.		*/
/* 12/04/97  JRB    03     Don't chk TSAPs on CC (may not be sent).	*/
/* 09/25/97  JRB    02     Don't generate exception for invalid state.	*/
/* 08/01/97  JRB    01     Created (compatible with MMS-EASE 7.0).	*/
/************************************************************************/
static char *thisFileName = __FILE__;	/* For TP4_EXCEPT and slog macros*/

#include "glbtypes.h"
#include "sysincs.h"
#include "mem_chk.h"
#include "tp4api.h"		/* User definitions for tp4	*/
#include "tp4.h"		/* Internal definitions for tp4	*/
#include "tp4_encd.h"		/* Encode/decode defs for tp4	*/
#include "tp4_log.h"

/************************************************************************/
/*			tp0_connect					*/
/* This function is called by the user to initiate a connect request to	*/
/* a remote node							*/
/* RETURNS: connection ID if successful, (-1) on error			*/
/* CRITICAL: connection ID = (conn_id+MIN_TP0_CONN_ID). Remember that	*/
/*	this is hoe we distinguish between TP0 and TP4 connections.	*/
/************************************************************************/

ST_LONG tp0_connect (ST_LONG tp0_bind_id, ST_LONG user_conn_id,
		     TP4_ADDR *rem_tp4_addr,
		     ST_INT conndata_len,
		     char *conndata,
                     S_SEC_ENCRYPT_CTRL *encrypt_ctrl)
  {
ST_UINT16 conn_id;		/* index into "tp0_conn_arr" array.		*/
TP0_CONN *tp_conn;
TPDU_CX *tpdu_cr;
ST_UCHAR *tp0_loc_tsap;

  if (rem_tp4_addr->tp_type == TP_TYPE_TCP)
    {
#if defined(MMSEASE_MOSI)
    if (tp0_check_bind_id (tp0_bind_id, &tp0_loc_tsap) != SD_SUCCESS)
#else
    tp0_loc_tsap = only_tp0_loc_tsap;
    if (tp0_bind_id != only_tp0_bind_id)
#endif
      {
      TP_LOG_ERR1 ("tp0_connect: bind id %ld invalid. TCP must be enabled in config.", tp0_bind_id);
      return (-1);
      }
    }    
  else		/* Transport type not TP0, this is error.	*/
    {
    TP_LOG_ERR0 ("tp0_connect: invalid transport type");
    return (-1);
    }

  if (rem_tp4_addr->tp4_sel_len > MAX_TSEL_LEN)
    {
    TP4_EXCEPT ();	/* If this happens, user code is invalid.	*/
    return (-1);
    }

  /* Look for available connection.	*/
  tp_conn = &tp0_conn_arr [0];
  for (conn_id = 0;  conn_id < tp0_cfg.max_num_conns;  conn_id++, tp_conn++)
    {
    if (tp_conn->state == TP_STATE_CLOSED)
      break;		/* Found one!!  "tp_conn" points to it now.	*/
    }	/* end "for"	*/
  if (conn_id >= tp0_cfg.max_num_conns)
    {			/* Didn't find one!!	*/
    TP_LOG_ERR0 ("TP-ERROR: tp0_connect: all connections in use");
    return (-1);
    }
  /* "tp_conn" now points to a connection in TP_STATE_CLOSED state.	*/    
  tp0_conn_clean (tp_conn);	/* Good time to clean up conn struct.	*/

  /* Increment "loc_ref_offset" to avoid duplicate CR.			*/
  inc_loc_ref_offset (tp_conn->loc_ref_offset);
  
  /* Set "tpdu_cr" pointing to "tp_conn->tpdu_cx" and fill in.		*/
  /* Info stored in "tp_conn" in case retransmissions needed.		*/
  tpdu_cr = &tp_conn->tpdu_cx;
  memcpy (tpdu_cr->loc_tsap, tp0_loc_tsap, tp0_loc_tsap [0]+1);
  tpdu_cr->rem_tsap [0] = (ST_UCHAR) rem_tp4_addr->tp4_sel_len;
  memcpy (&tpdu_cr->rem_tsap [1], rem_tp4_addr->tp4_sel, rem_tp4_addr->tp4_sel_len);
  tpdu_cr->loc_ref   = calc_loc_ref (conn_id, tp_conn->loc_ref_offset);
  tpdu_cr->rem_ref   = 0;
  tpdu_cr->max_tpdu_len_enc = tp0_cfg.max_tpdu_len_enc;
  tpdu_cr->preferred_class = 0;
  tpdu_cr->cdt       = 0;
  tpdu_cr->udata_len = min ((ST_UINT16) conndata_len, TP_MAX_CONN_UDATA);
  memcpy (tpdu_cr->udata_buf, conndata, tpdu_cr->udata_len);

  /* Set state before calling np_connect_req (may complete immediately).*/
  tp_conn->user_conn_id = user_conn_id;	/* Save User's ID for confirm.	*/
  tp_conn->state = TP_STATE_WFNC;
  if ((tp_conn->sock_info = np_connect_req ((ST_LONG) tp_conn, rem_tp4_addr->netAddr.ip,
                                            rem_tp4_addr->port, encrypt_ctrl)) == NULL)
    {
    tp_conn->state = TP_STATE_CLOSED;	/* CRITICAL: so tp_conn can be reused.*/
#if defined(SPDU_RX_NO_PREALLOCATE)
    M_FREE (MSMEM_STARTUP, tp_conn->spdu_rx.spdu_ptr);
#endif
    return (-1);	/* Network connect failed immediately.	*/
    }

  /* CRITICAL: For TP0, connection ID = (conn_id+MIN_TP0_CONN_ID).	*/
  return (conn_id+MIN_TP0_CONN_ID);
  }

/************************************************************************/
/* tp0_process_cc							*/
/************************************************************************/
ST_VOID tp0_process_cc (TPDU_CX *tpdu_cc)
  {
ST_ULONG conn_id;	/* index into "tp0_conn_arr" array (Unsigned so	*/
		/* no sign-extension on compare to tp0_cfg.max_num_conns).*/
TP0_CONN *tp_conn;	/* ptr to struct in "tp0_conn_arr" array.	*/
TPDU_DR tpdu_dr;
ST_INT unacceptable_cc = SD_FALSE;
ST_INT reason;


  /* Fill in TPDU_DR struct in case DR needs to be sent.		*/
  /* Do not fill in "reason" yet.					*/
  tpdu_dr.loc_ref = tpdu_cc->loc_ref;
  tpdu_dr.rem_ref = tpdu_cc->rem_ref;
  tpdu_dr.sock_info = tpdu_cc->sock_info;

  /* Check connection ID.	*/
  if (tpdu_cc->sock_info->user_conn_id == INVALID_CONN_ID)
    {
    /* Invalid ID means CR has not been sent, so this CC is unexpected.	*/
    /* CC most likely received from "abnormal" application.		*/
    TP_LOG_ERR0 ("TP-ERROR: tp0_process_cc: Invalid tp_conn");
    /* May be intentional attack, so disconnect immediately.		*/
    np_disconnect_req (tpdu_cc->sock_info);  
    return;  
    }

  /* Find the correct "tp_conn". It should have been saved in sock_info.*/
  tp_conn = (TP0_CONN *) tpdu_cc->sock_info->user_conn_id;


  conn_id = tp_conn - tp0_conn_arr;	/* conn_id = index into array	*/

  switch (tp_conn->state)
    {
    case TP_STATE_CLOSED:
      tpdu_dr.reason = TP_DR_NO_SESSION;	/* We're not trying to connect*/
      tp0_send_dr (&tpdu_dr);
      break;
    case TP_STATE_WFCC:
      /* Check for Transport Class 0.  Don't allow any other.		*/
      if (tpdu_cc->preferred_class != 0)
        {
        unacceptable_cc = SD_TRUE;
        }
      /* Save negotiated TPDU len in tp_conn->max_tpdu_len.	*/
      switch (tpdu_cc->max_tpdu_len_enc)
        {
        case TP_PDU_MAX_SIZE_128  :	tp_conn->max_tpdu_len =   128; break;
        case TP_PDU_MAX_SIZE_256  :	tp_conn->max_tpdu_len =   256; break;
        case TP_PDU_MAX_SIZE_512  :	tp_conn->max_tpdu_len =   512; break;
        case TP_PDU_MAX_SIZE_1024 :	tp_conn->max_tpdu_len =  1024; break;
        case TP_PDU_MAX_SIZE_2048 :	tp_conn->max_tpdu_len =  2048; break;
        case TP_PDU_MAX_SIZE_4096 :	tp_conn->max_tpdu_len =  4096; break;
        case TP_PDU_MAX_SIZE_8192 :	tp_conn->max_tpdu_len =  8192; break;
        case TP_PDU_MAX_SIZE_65531:	tp_conn->max_tpdu_len = 65531; break;
        /* Default to ILLEGAL value (i.e. 0)	*/
        default:			tp_conn->max_tpdu_len =     0; break;
        }	/* end "switch"	*/
      /* If max_tpdu_len ILLEGAL or ">" proposed, this is protocol error.*/
      if (tp_conn->max_tpdu_len == 0  ||		/* ILLEGAL	*/
          tp_conn->max_tpdu_len > tp0_cfg.max_tpdu_len)	/* ">" proposed	*/
        {
        tpdu_dr.reason = TP_DR_NO_REASON;
        unacceptable_cc = SD_TRUE;
        }

      if (unacceptable_cc)
        {	/* UN-ACCEPTABLE CLASS 0 CC TPDU.	*/
        reason = 0xff;			/* Local user error	*/
        tp4_disconnect_ind (tp_conn->user_conn_id, reason,
                            0, NULL);	/* No user data passed up.	*/
        np_disconnect_req (tp_conn->sock_info);
        tp_conn->state = TP_STATE_CLOSED;
#if defined(SPDU_RX_NO_PREALLOCATE)
        M_FREE (MSMEM_STARTUP, tp_conn->spdu_rx.spdu_ptr);
#endif
        }
      else
        {	/* ACCEPTABLE CLASS 0 CC TPDU.	*/
        /* Save "rem_ref" in "tp_conn".			*/
        tp_conn->rem_ref = tpdu_cc->rem_ref;

        /* CRITICAL: set state before tp4_connect_cnf because may	*/
        /* send first Transport data from within tp4_connect_cnf.	*/
        tp_conn->state = TP_STATE_OPEN;
        tp4_connect_cnf (tp_conn->user_conn_id, conn_id+MIN_TP0_CONN_ID, 
                        (ST_UINT) tpdu_cc->udata_len, tpdu_cc->udata_buf);
        tp_conn->state = TP_STATE_OPEN;
        }
      break;

    default:
      TP_LOG_ERR1 ("TP-ERROR: invalid state (%d) for received CC. Ignored.",
        tp_conn->state);
      break;
    }		/* end "switch"	*/
  return;
  }