h323-messagesdec.c

一个非常美妙的proxy。功能强大。基于sip的协议。如果还要的话

                          &pvalue->numocts,
                          pvalue->data,
                          sizeof(pvalue->data));
   if (stat != ASN_OK) return stat;
   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ANSI_41_UIM                                               */
/*                                                            */
/**************************************************************/

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet;

EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue)
{
   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst min_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst mdn_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst esn_lsize1 = { 0, 16, 16, 0 };
   static Asn1SizeCnst mscid_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst sesn_lsize1 = { 0, 16, 16, 0 };
   static Asn1SizeCnst soc_lsize1 = { 0, 3, 16, 0 };
   int stat = ASN_OK;
   OOCTXT lctxt;
   ASN1OpenType openType;
   ASN1UINT bitcnt;
   ASN1UINT i;
   ASN1BOOL optbit;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   /* optional bits */

   memset (&pvalue->m, 0, sizeof(pvalue->m));

   DECODEBIT (pctxt, &optbit);
   pvalue->m.imsiPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.minPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.mdnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.msisdnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.esnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.mscidPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.systemMyTypeCodePresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.systemAccessTypePresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.qualificationInformationCodePresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.sesnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.socPresent = optbit;

   /* decode imsi */

   if (pvalue->m.imsiPresent) {
      invokeStartElement (pctxt, "imsi", -1);

      addSizeConstraint (pctxt, &imsi_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->imsi);

      invokeEndElement (pctxt, "imsi", -1);
   }

   /* decode min */

   if (pvalue->m.minPresent) {
      invokeStartElement (pctxt, "min", -1);

      addSizeConstraint (pctxt, &min_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->min);

      invokeEndElement (pctxt, "min", -1);
   }

   /* decode mdn */

   if (pvalue->m.mdnPresent) {
      invokeStartElement (pctxt, "mdn", -1);

      addSizeConstraint (pctxt, &mdn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->mdn);

      invokeEndElement (pctxt, "mdn", -1);
   }

   /* decode msisdn */

   if (pvalue->m.msisdnPresent) {
      invokeStartElement (pctxt, "msisdn", -1);

      addSizeConstraint (pctxt, &msisdn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->msisdn);

      invokeEndElement (pctxt, "msisdn", -1);
   }

   /* decode esn */

   if (pvalue->m.esnPresent) {
      invokeStartElement (pctxt, "esn", -1);

      addSizeConstraint (pctxt, &esn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->esn);

      invokeEndElement (pctxt, "esn", -1);
   }

   /* decode mscid */

   if (pvalue->m.mscidPresent) {
      invokeStartElement (pctxt, "mscid", -1);

      addSizeConstraint (pctxt, &mscid_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->mscid);

      invokeEndElement (pctxt, "mscid", -1);
   }

   /* decode system_id */

   invokeStartElement (pctxt, "system_id", -1);

   stat = asn1PD_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id);
   if (stat != ASN_OK) return stat;

   invokeEndElement (pctxt, "system_id", -1);

   /* decode systemMyTypeCode */

   if (pvalue->m.systemMyTypeCodePresent) {
      invokeStartElement (pctxt, "systemMyTypeCode", -1);

      stat = asn1PD_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode);
      if (stat != ASN_OK) return stat;

      invokeEndElement (pctxt, "systemMyTypeCode", -1);
   }

   /* decode systemAccessType */

   if (pvalue->m.systemAccessTypePresent) {
      invokeStartElement (pctxt, "systemAccessType", -1);

      stat = asn1PD_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType);
      if (stat != ASN_OK) return stat;

      invokeEndElement (pctxt, "systemAccessType", -1);
   }

   /* decode qualificationInformationCode */

   if (pvalue->m.qualificationInformationCodePresent) {
      invokeStartElement (pctxt, "qualificationInformationCode", -1);

      stat = asn1PD_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode);
      if (stat != ASN_OK) return stat;

      invokeEndElement (pctxt, "qualificationInformationCode", -1);
   }

   /* decode sesn */

   if (pvalue->m.sesnPresent) {
      invokeStartElement (pctxt, "sesn", -1);

      addSizeConstraint (pctxt, &sesn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->sesn);

      invokeEndElement (pctxt, "sesn", -1);
   }

   /* decode soc */

   if (pvalue->m.socPresent) {
      invokeStartElement (pctxt, "soc", -1);

      addSizeConstraint (pctxt, &soc_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->soc);

      invokeEndElement (pctxt, "soc", -1);
   }

   if (extbit) {

      /* decode extension optional bits length */

      stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
      if (stat != ASN_OK) return stat;

      bitcnt += 1;

      ZEROCONTEXT (&lctxt);
      stat = setPERBufferUsingCtxt (&lctxt, pctxt);
      if (stat != ASN_OK) return stat;

      stat = moveBitCursor (pctxt, bitcnt);
      if (stat != ASN_OK) return stat;

      for (i = 0; i < bitcnt; i++) {
         DECODEBIT (&lctxt, &optbit);

         if (optbit) {
            stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
            if (stat != ASN_OK) return stat;

            pctxt->buffer.byteIndex += openType.numocts;
         }
      }
   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  GSM_UIM_tmsi                                              */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue)
{
   static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 };
   int stat = ASN_OK;

   addSizeConstraint (pctxt, &lsize1);

   stat = decodeOctetString (pctxt,
                          &pvalue->numocts,
                          pvalue->data,
                          sizeof(pvalue->data));
   if (stat != ASN_OK) return stat;
   invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  GSM_UIM                                                   */
/*                                                            */
/**************************************************************/

extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet;

EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue)
{
   static Asn1SizeCnst imsi_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst msisdn_lsize1 = { 0, 3, 16, 0 };
   static Asn1SizeCnst imei_lsize1 = { 0, 15, 16, 0 };
   static Asn1SizeCnst hplmn_lsize1 = { 0, 1, 4, 0 };
   static Asn1SizeCnst vplmn_lsize1 = { 0, 1, 4, 0 };
   int stat = ASN_OK;
   OOCTXT lctxt;
   ASN1OpenType openType;
   ASN1UINT bitcnt;
   ASN1UINT i;
   ASN1BOOL optbit;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   /* optional bits */

   memset (&pvalue->m, 0, sizeof(pvalue->m));

   DECODEBIT (pctxt, &optbit);
   pvalue->m.imsiPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.tmsiPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.msisdnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.imeiPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.hplmnPresent = optbit;

   DECODEBIT (pctxt, &optbit);
   pvalue->m.vplmnPresent = optbit;

   /* decode imsi */

   if (pvalue->m.imsiPresent) {
      invokeStartElement (pctxt, "imsi", -1);

      addSizeConstraint (pctxt, &imsi_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->imsi);

      invokeEndElement (pctxt, "imsi", -1);
   }

   /* decode tmsi */

   if (pvalue->m.tmsiPresent) {
      invokeStartElement (pctxt, "tmsi", -1);

      stat = asn1PD_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi);
      if (stat != ASN_OK) return stat;

      invokeEndElement (pctxt, "tmsi", -1);
   }

   /* decode msisdn */

   if (pvalue->m.msisdnPresent) {
      invokeStartElement (pctxt, "msisdn", -1);

      addSizeConstraint (pctxt, &msisdn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->msisdn);

      invokeEndElement (pctxt, "msisdn", -1);
   }

   /* decode imei */

   if (pvalue->m.imeiPresent) {
      invokeStartElement (pctxt, "imei", -1);

      addSizeConstraint (pctxt, &imei_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->imei);

      invokeEndElement (pctxt, "imei", -1);
   }

   /* decode hplmn */

   if (pvalue->m.hplmnPresent) {
      invokeStartElement (pctxt, "hplmn", -1);

      addSizeConstraint (pctxt, &hplmn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->hplmn);

      invokeEndElement (pctxt, "hplmn", -1);
   }

   /* decode vplmn */

   if (pvalue->m.vplmnPresent) {
      invokeStartElement (pctxt, "vplmn", -1);

      addSizeConstraint (pctxt, &vplmn_lsize1);

      stat = decodeConstrainedStringEx (pctxt, &pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7);
      if (stat != ASN_OK) return stat;
      invokeCharStrValue (pctxt, pvalue->vplmn);

      invokeEnd