h323-messagesdec.c

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

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         default:
            return ASN_E_INVOPT;
      }
   }
   else {
      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 7;

      stat = decodeByteAlign (pctxt);
      if (stat != ASN_OK) return stat;

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

   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  PublicPartyNumber                                         */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue)
{
   int stat = ASN_OK;

   /* decode publicTypeOfNumber */

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

   stat = asn1PD_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber);
   if (stat != ASN_OK) return stat;

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

   /* decode publicNumberDigits */

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

   stat = asn1PD_H225NumberDigits (pctxt, &pvalue->publicNumberDigits);
   if (stat != ASN_OK) return stat;

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

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  PrivateTypeOfNumber                                       */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue)
{
   int stat = ASN_OK;
   ASN1UINT ui;
   ASN1OpenType openType;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   if (!extbit) {
      stat = decodeConsUnsigned (pctxt, &ui, 0, 5);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 1;

      switch (ui) {
         /* unknown */
         case 0:
            invokeStartElement (pctxt, "unknown", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         /* level2RegionalNumber */
         case 1:
            invokeStartElement (pctxt, "level2RegionalNumber", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         /* level1RegionalNumber */
         case 2:
            invokeStartElement (pctxt, "level1RegionalNumber", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         /* pISNSpecificNumber */
         case 3:
            invokeStartElement (pctxt, "pISNSpecificNumber", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         /* localNumber */
         case 4:
            invokeStartElement (pctxt, "localNumber", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         /* abbreviatedNumber */
         case 5:
            invokeStartElement (pctxt, "abbreviatedNumber", -1);

            /* NULL */
            invokeNullValue (pctxt);

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

            break;

         default:
            return ASN_E_INVOPT;
      }
   }
   else {
      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 7;

      stat = decodeByteAlign (pctxt);
      if (stat != ASN_OK) return stat;

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

   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  PrivatePartyNumber                                        */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue)
{
   int stat = ASN_OK;

   /* decode privateTypeOfNumber */

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

   stat = asn1PD_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber);
   if (stat != ASN_OK) return stat;

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

   /* decode privateNumberDigits */

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

   stat = asn1PD_H225NumberDigits (pctxt, &pvalue->privateNumberDigits);
   if (stat != ASN_OK) return stat;

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

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  PartyNumber                                               */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue)
{
   int stat = ASN_OK;
   ASN1UINT ui;
   ASN1OpenType openType;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   if (!extbit) {
      stat = decodeConsUnsigned (pctxt, &ui, 0, 4);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 1;

      switch (ui) {
         /* e164Number */
         case 0:
            invokeStartElement (pctxt, "e164Number", -1);

            pvalue->u.e164Number = ALLOC_ASN1ELEM (pctxt, H225PublicPartyNumber);

            stat = asn1PD_H225PublicPartyNumber (pctxt, pvalue->u.e164Number);
            if (stat != ASN_OK) return stat;

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

            break;

         /* dataPartyNumber */
         case 1:
            invokeStartElement (pctxt, "dataPartyNumber", -1);

            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.dataPartyNumber);
            if (stat != ASN_OK) return stat;

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

            break;

         /* telexPartyNumber */
         case 2:
            invokeStartElement (pctxt, "telexPartyNumber", -1);

            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.telexPartyNumber);
            if (stat != ASN_OK) return stat;

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

            break;

         /* privateNumber */
         case 3:
            invokeStartElement (pctxt, "privateNumber", -1);

            pvalue->u.privateNumber = ALLOC_ASN1ELEM (pctxt, H225PrivatePartyNumber);

            stat = asn1PD_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber);
            if (stat != ASN_OK) return stat;

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

            break;

         /* nationalStandardPartyNumber */
         case 4:
            invokeStartElement (pctxt, "nationalStandardPartyNumber", -1);

            stat = asn1PD_H225NumberDigits (pctxt, &pvalue->u.nationalStandardPartyNumber);
            if (stat != ASN_OK) return stat;

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

            break;

         default:
            return ASN_E_INVOPT;
      }
   }
   else {
      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 6;

      stat = decodeByteAlign (pctxt);
      if (stat != ASN_OK) return stat;

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

   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ANSI_41_UIM_system_id                                     */
/*                                                            */
/**************************************************************/

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet;

extern EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet;

EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue)
{
   static Asn1SizeCnst sid_lsize1 = { 0, 1, 4, 0 };
   static Asn1SizeCnst mid_lsize1 = { 0, 1, 4, 0 };
   int stat = ASN_OK;
   ASN1UINT ui;
   ASN1OpenType openType;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   if (!extbit) {
      stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 1;

      switch (ui) {
         /* sid */
         case 0:
            invokeStartElement (pctxt, "sid", -1);

            addSizeConstraint (pctxt, &sid_lsize1);

            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7);
            if (stat != ASN_OK) return stat;
            invokeCharStrValue (pctxt, pvalue->u.sid);

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

            break;

         /* mid */
         case 1:
            invokeStartElement (pctxt, "mid", -1);

            addSizeConstraint (pctxt, &mid_lsize1);

            stat = decodeConstrainedStringEx (pctxt, &pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7);
            if (stat != ASN_OK) return stat;
            invokeCharStrValue (pctxt, pvalue->u.mid);

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

            break;

         default:
            return ASN_E_INVOPT;
      }
   }
   else {
      stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
      if (stat != ASN_OK) return stat;
      else pvalue->t = ui + 3;

      stat = decodeByteAlign (pctxt);
      if (stat != ASN_OK) return stat;

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

   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ANSI_41_UIM_systemMyTypeCode                              */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue)
{
   static Asn1SizeCnst lsize1 = { 0, 1, 1, 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);
}

/**************************************************************/
/*                                                            */
/*  ANSI_41_UIM_systemAccessType                              */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue)
{
   static Asn1SizeCnst lsize1 = { 0, 1, 1, 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);
}

/**************************************************************/
/*                                                            */
/*  ANSI_41_UIM_qualificationInformationCode                  */
/*                                                            */
/**************************************************************/

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

   addSizeConstraint (pctxt, &lsize1);

   stat = decodeOctetString (pctxt,