ma_acc.x

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 include file
  
     Desc:     Structures, variables and typedefs required by MAP Test.
  
     File:     ma_acc.x
  
     Sid:      ma_acc.x@@/main/8 - Fri Sep 16 02:36:32 2005
  
     Prg:      ssk
  
*********************************************************************21*/
  
#ifndef __MAACCX__
#define __MAACCX__
  
#ifdef __cplusplus
extern "C" {
#endif

/* Message Queue between MAP User and MAP Acceptance Test modules */

/* Message Queue Element */
typedef struct maAccMsgQElm
{
   U8           evtType;              /* Primitive type */
   SuId         suId;                 /* Sap Id */
   StDlgId      suDlgId;              /* Service User dialogue Id */
   StDlgId      spDlgId;              /* Service Provider dialogue Id */
   U8           status;               /* Status */

   union
   {
      MaOpenEv     openEv;            /* Open Ind. and Cfm. */
      MaCloseEv    closeEv;           /* Close Ind. */
      MaAbrtEv     abrtEv;            /* Abort Ind. */
    
      struct
      {
         MaInvokeId    invId;         /* Invoke Id */
         U8            primType;      /* Primitive Type  */
      } statEv;                        /* Notice Indication */

      struct
      {
         RCause        cause;         /* Return Cause, set by SCCP */
      } notEv;                        /* Notice Indication */

      struct
      {
         MaInvokeId    invId;         /* Invoke Id */
         MaInvokeId    lnkId;         /* Linked Invoke Id */
         MaOprType     oprCode;       /* Operation Code   */
         MaUsrErr      usrErr;        /* Operation Error  */
         MaPrvErr      prvErr;        /* Operation Error  */
         MaAllSSEv     oprEv;         /* Operation Event  */
      } operEv;
#ifdef MATV2
      MatSteMgmtEv     matSteMgmtEv;            /* Open Ind. and Cfm. */
#endif /* MATV2 */
   } s;
} MaAccMsgQElm;

/* Message Queue structure */
typedef struct maAccMsgQ
{
   MaAccMsgQElm q[MA_ACC_MSG_QSIZE];  /* Message Queue */
   U16          rdPtr;                /* Next queue location to read */
   U16          wrPtr;                /* Next queue location to write in */
} MaAccMsgQ;

/* Component Queue at MAP-TCAP interface to queue component requests */

/* Component queue element */
typedef struct maAccCmpQElm
{
   Buffer      *cpBuf;                /* Component parameter buffer */
   StComps     compEv;                /* Component Event */
} MaAccCmpQElm;

/* Component Queue structure */
typedef struct maAccCmpQ
{
   MaAccCmpQElm q[MA_ACC_CMP_QSIZE];  /* Component Queue */
   U16          rdPtr;                /* Next queue location to read */
   U16          wrPtr;                /* Next queue location to write in */
} MaAccCmpQ;

/* Bad Parameter Test Information */
typedef struct maAccBadParamInfo
{
   U16           oprCodeSpec;          /* operation code specifier */
   U16           idxToCpt;             /* index to corrupt */
   U8            valToCpt;             /* value to corrupt */
   S32           probCodeExp;          /* problem code expected from peer */
} MaAccBadParamInfo;

/* Current Test context information */
typedef struct maAccTest
{
   Bool         init;                 /* If test context has been initialized */
   Bool         end;                  /* If the test is completed */
   U8           state;                /* State of the test case */
   U16          id;                   /* Test case Id */
   U8           result;               /* Test case passed or failed */
   Bool         cptFlag;              /* If true then corrupt the cpBuf */
   U32          idx;                  /* Index of the octet to be corrupted */
   Data         data;                 /* Corrupted Data value */
   Bool         loopBack;             /* If prim. should be looped or dropped */
   Bool         prntFlag;             /* Prints enable/disable flag */
   Bool         tstOnOff;             /* Test On/Off flag */
   U16          onOffCntr;            /* Test On/Off counter */
#ifdef MA_FTHA
   TranId       transID;              /* Transaction ID */
#endif /* MA_FTHA */
} MaAccTest;

/* Test Routine */
typedef S16 (*MaAccPFS16)      ARGS((Void));

/* Test Dialogue Control point */
typedef struct maAccDlgCp
{
   SpId        spId;                  /* Sap Id */
   StDlgId     auDlgId;               /* MAP user dialogue id */     
   StDlgId     smaDlgId;              /* Source MAP dialogue id */
   StDlgId     sstDlgId;              /* Source TCAP dialogue id */
   StDlgId     dmaDlgId;              /* Destination MAP dialogue id */
   StDlgId     dstDlgId;              /* Destination TCAP dialogue id */
   MaAccCmpQ   cmpQ;                  /* Component queue */
} MaAccDlgCp;

/* Acceptance test control block */
typedef struct maAccCb
{
   TskInit      init;                 /* Task Initialization structure */
   Bool         testFlg;              /* Test On/Off Flag */
   Swtch        pSwtch;               /* protocol swicth */
   Pst          smPst;                /* From SM to MAP */
   Pst          uiPst;                /* From AU to MAP */
   Pst          liPst;                /* From TCAP to MAP */
#ifdef ZJ
   Pst          selfPst;              /* From PSF to PSF */
   Pst          smZjPst;              /* From SM to PSF  */
   Pst          shZjPst;              /* From SH to PSF  */
#endif /* ZJ */
   MaAccMsgQ    msgQ;                 /* Message Queue */
   StDlgId      dlgIdPool;            /* Keeps the next available dialogue Id */
   MaAccPFS16   tstTbl[MA_ACC_MAX_TESTS];     /* Test matrix */
   U16          tstSeqTbl[MA_ACC_MAX_TESTS];  /* Test Sequence Table */
   U16          nxtIdx;             /* Next index in the test sequence table */
   MaAccTest    curTst;               /* Current test context */
   U32          crntCntr;             /* Current Counter */
   Ticks        crntTime;             /* Current time */
   SpAddr       srcAddr;              /* Default Source SCCP Address */
   SpAddr       dstAddr;              /* Default Destination SCCP Address */
   StQosSet     qos;                  /* Default Quality of Service set */
   MaAccDlgCp   dlgCp[(MA_ACC_MAX_DLGS + 1) * 2]; /* Dialogue Table */
   Bool         invTbl[MA_ACC_MAX_OPRS];           /* invoke table */
   Cntr         nmbLoops;             /* number of times the test has passed */
   Queue        lmRxQ;                /* Receive Queue for LM primitive */
#ifdef ZJ
   Queue        mrRsetQ[ZJACC_MAX_RSETS]; /* MR receive Q for each rset */
   Queue        shRxQ;                /* Q for messages received by SH */
#endif /* ZJ */
   U16          checkMsg;             /* Number of trmas to check msg Q */
   Bool         cfgDone;              /* MAP Configuration done or not */
   U16          state;
   Bool         extn;
   /* parameters introduced for STU RUG testing */
   Bool         defMgmtParam;         /* default mgmt parameter */
   U8           curTstSccpState;      /* Sccp state for current test */
   U8           curTstRil;            /* ril for current test */
#ifdef ZJ
   U8           tests;                /* tests to execute - all, psf only, map only */
#endif
   CmAlarm      alarm;                  /* The last MA alarm that was generated */
} MaAccCb;


/* Message structure for primitives received by LM */
typedef struct maAccLmMsg
{
  Pst           pst;
  MaMngmt       maMngmt;     /* MAP Managmement structure */
#ifdef ZJ
  CmTuMngmt     zjMngmt;     /* PSF Management structrue for CORE2 */
#endif /* ZJ */
#ifdef MA_FTHA
#ifdef MA_RUG
  ShtCntrlCfmEvnt shMngmt;   /* SHT interface information */
#endif /* MA_RUG */  
#endif /* MA_FTHA */
} MaAccLmMsg;


EXTERN U8          maAccMaUiSel;   /* upper layer selector from map */
EXTERN U8          maAccAuUiSel;   /* upper layer selector from map */