ma_acc2.c

gsm map协议源代码

/********************************************************************16**

                         (c) COPYRIGHT 1989-2005 by 
                         Continuous Computing Corporation.
                         All rights reserved.

     This software is confidential and proprietary to Continuous Computing 
     Corporation (CCPU).  No part of this software may be reproduced,
     stored, transmitted, disclosed or used in any form or by any means
     other than as expressly provided by the written Software License 
     Agreement between CCPU and its licensee.

     CCPU warrants that for a period, as provided by the written
     Software License Agreement between CCPU and its licensee, this
     software will perform substantially to CCPU specifications as
     published at the time of shipment, exclusive of any updates or 
     upgrades, and the media used for delivery of this software will be 
     free from defects in materials and workmanship.  CCPU also warrants 
     that has the corporate authority to enter into and perform under the   
     Software License Agreement and it is the copyright owner of the software 
     as originally delivered to its licensee.

     CCPU MAKES NO OTHER WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
     WITHOUT LIMITATION WARRANTIES OF MERCHANTABILITY OR FITNESS FOR
     A PARTICULAR PURPOSE WITH REGARD TO THIS SOFTWARE, SERVICE OR ANY RELATED
     MATERIALS.

     IN NO EVENT SHALL CCPU BE LIABLE FOR ANY INDIRECT, SPECIAL,
     CONSEQUENTIAL DAMAGES, OR PUNITIVE DAMAGES IN CONNECTION WITH OR ARISING
     OUT OF THE USE OF, OR INABILITY TO USE, THIS SOFTWARE, WHETHER BASED
     ON BREACH OF CONTRACT, TORT (INCLUDING NEGLIGENCE), PRODUCT
     LIABILITY, OR OTHERWISE, AND WHETHER OR NOT IT HAS BEEN ADVISED
     OF THE POSSIBILITY OF SUCH DAMAGE.

                       Restricted Rights Legend

     This software and all related materials licensed hereby are
     classified as "restricted computer software" as defined in clause
     52.227-19 of the Federal Acquisition Regulation ("FAR") and were
     developed entirely at private expense for nongovernmental purposes,
     are commercial in nature and have been regularly used for
     nongovernmental purposes, and, to the extent not published and
     copyrighted, are trade secrets and confidential and are provided
     with all rights reserved under the copyright laws of the United
     States.  The government's rights to the software and related
     materials are limited and restricted as provided in clause
     52.227-19 of the FAR.

                    IMPORTANT LIMITATION(S) ON USE

     The use of this software is limited to the use set
     forth in the written Software License Agreement between CCPU and
     its Licensee. Among other things, the use of this software
     may be limited to a particular type of Designated Equipment, as 
     defined in such Software License Agreement.
     Before any installation, use or transfer of this software, please
     consult the written Software License Agreement or contact CCPU at
     the location set forth below in order to confirm that you are
     engaging in a permissible use of the software.

                    Continuous Computing Corporation
                    9380, Carroll Park Drive
                    San Diego, CA-92121, USA

                    Tel: [phone]
                    Fax: [phone]

                    Email: [e-mail]
                    Web: http://www.ccpu.com

*********************************************************************17*/

/********************************************************************20**
  
     Name:     MAP - Acceptance Test
 
     Type:     C source file
  
     Desc:     C source code used to initialize, run and test the
               MAP software in a TRILLIUM development environment.
               This is the version used for the MAP software
               test sample.

     File:     ma_acc2.c
  
     Sid:      ma_acc2.c@@/main/9 - Fri Sep 16 02:35:14 2005
   
     Prg:      ssk
  
*********************************************************************21*/
  
  
/* header include files (.h) */
#include "envopt.h"        /* environment options */
#include "envdep.h"        /* environment dependent */
#include "envind.h"        /* environment independent */
#include "gen.h"           /* general layer */
#include "ssi.h"           /* system services */
#include "cm5.h"
#include "cm_ss7.h"
#include "cm_err.h"        /* common error */
#include "stu.h"           /* tcap upper interface */
#include "mat.h"           /* inap upper interface */
#ifdef MA_FTHA
#include "sht.h"           /* SHT interface */
#endif /* MA_FTHA */
#include "lma.h"           /* layer management interface */
#include "ma_acc.h"        /* acceptance test defines */
#include "ma.h"
#include "ma_mf.h"
 #ifdef ZJ
#include "cm_ftha.h"       /* Common FTHA */
#include "cm_pftha.h"      /* Common PSF defines */
#include "cm_psfft.h"
#include "cm_tupsf.h"      /* Common TCAP user PSF */
#include "zj_acc.h"        /* PSF Acceptance Test */
#include "lzj.h"
#endif


/* header/extern include files (.x) */
#include "gen.x"           /* general layer */
#include "ssi.x"           /* system services */
#include "cm5.x"
#include "cm_ss7.x"        /* Common */
#include "cm_lib.x"        /* Common library headers */
#include "stu.x"           /* tcap upper interface */
#include "lma.x"           /* layer management interface */
#include "mat.x"           /* inap upper interface */
#ifdef MA_FTHA
#include "sht.x"           /* SHT interface */
#endif /* MA_FTHA */
#ifdef ZJ
#include "cm_ftha.x"       /* Common FTHA */
#include "cm_pftha.x"      /* Common PSF defines */
#include "cm_psfft.x"
#include "cm_tupsf.x"      /* Common TCAP user PSF */
#endif
#include "ma.x"
#include "ma_acc.x"        /* acceptance test defines */
#ifdef ZJ
#include "lzj.x"
#include "zj.x"
#include "zj_acc.x"
#endif
  
  
/* Global Variable */

EXTERN U8        maAccOprCode;  /* Sample Operation code  */
EXTERN MaAccCb   maAccCb;  /* MAP Acceptance Test control block */
EXTERN SpAddr    maAccAddrs[];
EXTERN MaApConName  maAccACNs[];
EXTERN MaAllSSEv maInvoke;  /* Global Invoke Structure */
EXTERN MaAllSSEv maRetRslt; /* Global Return Result  Structure */
EXTERN MaUsrErr  maUsrErr;  /* Global Return Result  Structure */
#ifdef MA_RUG
EXTERN CmIntfVer maAccLMIntfVer; /* LM interface version */
EXTERN CmIntfVer maAccUIntfVer;  /* Upper interface version */
EXTERN CmIntfVer maAccLIntfVer;  /* Lower interface version */
EXTERN Bool      maAccRemIntf;   /* Remote interface version is known or not */
#endif /* MA_RUG */
EXTERN U8        maAccMaFillExtCont;  /* Fill ExtCont selector */
PRIVATE Txt      prntBuf[MA_PRNTBUF_SIZE];   /* buffer to print */

#if (MAP_SEC && MAP_REL4 && MAP_REL99)
EXTERN SpAddr       maAccAddrs1[];
PRIVATE Bool        done; 
PRIVATE LmaSecOpComp   secOpComp[LMA_MAX_SEC_COMPS+100];  
#endif

/* local defines */
#define maAccUpdUsrInfo maAccUpdTknStrS   /* update the MAP user information */
  

/*
*
*       Fun:   maAccOprReq
*
*       Desc:  Send the Service Specific Operation Request
*
*       Ret:   ROK      
*
*       Notes: 
*
*       File:  ma_acc2.c
*
*/
#ifdef ANSI
PUBLIC S16 maAccOprReq
(
SpId        spId,             /* Service Provider Id */
U16         dlgIdx,           /* Dialogue Index */ 
MaInvokeId  *invId,           /* Invoke Id */
MaInvokeId  *lnkId,           /* Linked Id */
U8          oprCode,          /* Operation Code */
PTR          ev               /* Pointer to event structure */
)
#else
PUBLIC S16 maAccOprReq(spId, dlgIdx, invId, lnkId, oprCode,ev)
SpId        spId;             /* Service Provider Id */
U16         dlgIdx;           /* Dialogue Index */
MaInvokeId  *invId;           /* Invoke Id */
MaInvokeId  *lnkId;           /* Linked Id */
U8          oprCode;          /* Operation Code */
PTR          ev;              /* Pointer to event structure */
#endif
{
   TRC2(maAccOprReq)

  switch (oprCode)
  {
#if MAP_HLR
   case MAT_GETPASSWD:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSSEv,ssEv)
    }
    break;
#endif /* MAP_HLR */

#if MAP_VLR
   case MAT_REGSS:
   case MAT_ERASESS:
   case MAT_ACTVSS:
   case MAT_DACTVSS:
   case MAT_INTERSS:
   case MAT_REGPASSWD:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSSEv,ssEv)
    }
    break;
#endif /* MAP_VLR */

#if MAP_HLR
   case MAT_USSREQ:
   case MAT_USSNOTIFY:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSSEv,ssEv)
    }
    break;
#endif /* HLR */

#if (MAP_VLR || MAP_HLR)
   case MAT_PROCUSSDATA:
   case MAT_PROCUSSREQ:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSSEv,ssEv)
    }
    break;
#endif /* VLR || HLR */

#if (MAP_MSC || MAP_HLR)
   case MAT_SSINV_NOTIFY:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break; 
#endif /* MAP_MSC || MAP_HLR */

#if (MAP_HLR || MAP_MSC)
   case MAT_ROUTINFO:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;
#endif
#if MAP_MSC
#if MAP_REL99
   case MAT_IST_ALERT:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;
#endif /* MAP_REL99 */

   case MAT_ROUTINFOSM:
   case MAT_SMDEL:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break;
#endif /* MAP_MSC */

#if MAP_HLR
   case MAT_INFSC:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break;
#endif /* MAP_HLR */

#if MAP_HLR
   case MAT_ALRTSC:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break;
#endif  /* HLR */

#if MAP_VLR
   case MAT_REGCCENT:
   case MAT_ERASECCENT:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSSEv,ssEv)
    }
    break;
#endif /* MAP_VLR */

#if MAP_HLR
   case MAT_SETRPTSTATE:
   case MAT_RMTUSRFREE:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;
#endif /* MAP_HLR */

#if MAP_VLR
   case MAT_UPLOC:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }
    break;
#endif  /* VLR */
#if MAP_REL99
#if (MAP_VLR || MAP_GSN)
   case MAT_NOTE_MMEVT:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }
    break;
#endif
#endif /* MAP_REL99 */

#if MAP_MSC
   case MAT_PRE_HO:
   case MAT_PER_HO:
   case MAT_SNDENDSIG:
   case MAT_PROCACCSIG:
   case MAT_FWDACCSIG:
   case MAT_PRE_SUBSHO:
   case MAT_PER_SUBSHO:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaHoEv,hoEv)
    }
    break;
   case MAT_RESCALLHANDL:
   case MAT_PRO_GRPCALLSIG:
   case MAT_FWD_GRPCALLSIG:
   case MAT_SND_GRPCALLENDSIG:
   case MAT_PROV_SIWFS_NMB:
   case MAT_SIWFS_SIGMOD:
   case MAT_PREP_GRPCALL:
/* ma006.203: Guarded the operation under the following flag
   combination */      
#if (MAP_MSC || MAP_VLR || MAP_HLR)
#if MAP_REL6
   case MAT_REL_RES:
#endif
#endif /* MAP_MSC || MAP_VLR || MAP_HLR */

    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;
#endif  /* MSC */

#if MAP_VLR
   case MAT_STARPT:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;

  /* Send Identification Request */
  case MAT_SNDID:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }
    break;

   case MAT_RESTOREDATA: 
    {
      MA_ACC_ALLOC_LWLC_PTR(MaFREv,frEv)
    }
    break;
#endif  /* MAP_VLR */

#if  (MAP_VLR || MAP_GSN)
   case MAT_SNDPARAM: 
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSubEv,subEv)
    }
    break;
#endif /* MAP_VLR || MAP_GSN */

#if MAP_HLR
   case MAT_ANY_INTER:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSubEv,subEv)
    }
    break;

   case MAT_PROVROAMNMB:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaCallEv,callEv)
    }
    break;
#endif /* MAP_HLR */

#if MAP_HLR
   case MAT_CANCELLOC:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }
    break;
#endif /* MAP_HLR */

#if (MAP_VLR || MAP_GSN)
   case MAT_PURGE:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }

    break;
#endif /* MAP_VLR || MAP_GSN */

#if MAP_GSN
   case MAT_GPRS_UPLOC:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaLocEv,locEv)
    }
    break;
   case MAT_GPRS_ROUTINFO:
   case MAT_FAILRPT:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaPdpActvEv,pdpActvEv)
    }
     break;
#endif  /* MAP_GSN */

#if MAP_HLR
   case MAT_GPRS_NOTEMSPRES:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaPdpActvEv,pdpActvEv)
    }
     break;
#endif /* MAP_HLR */

#if (MAP_MSC || MAP_GSN)
   case MAT_FWDSM:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break;
#endif /* MAP_MSC || MAP_GSN */

#if MAP_MSC
   case MAT_MT_FWDSM:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break;
#endif /* MAP_MSC */

#if (MAP_VLR || MAP_GSN)
   case MAT_SMRDY:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSMEv,smEv)
    }
    break; 
#endif /* MAP_VLR || MAP_GSN */

#if MAP_HLR
   case MAT_INSSUBSDATA:
   case MAT_DELSUBSDATA:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSubEv,subEv)
    }
    break;
#endif /* MAP_HLR */

#if MAP_HLR
   case MAT_PROVSUBSINFO:
    {
      MA_ACC_ALLOC_LWLC_PTR(MaSubEv,subEv)
    }
    break;