h235-security-messagesdec.c

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

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

   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ECKASDH_eckasdh2_weierstrassB                             */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue)
{
   static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 };
   int stat = ASN_OK;

   addSizeConstraint (pctxt, &lsize1);

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

   invokeBitStrValue (pctxt, pvalue->numbits, pvalue->data);

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ECKASDH_eckasdh2                                          */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue)
{
   int stat = ASN_OK;

   /* decode public_key */

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

   stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key);
   if (stat != ASN_OK) return stat;

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

   /* decode fieldSize */

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

   stat = asn1PD_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize);
   if (stat != ASN_OK) return stat;

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

   /* decode base */

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

   stat = asn1PD_H235ECpoint (pctxt, &pvalue->base);
   if (stat != ASN_OK) return stat;

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

   /* decode weierstrassA */

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

   stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA);
   if (stat != ASN_OK) return stat;

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

   /* decode weierstrassB */

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

   stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB);
   if (stat != ASN_OK) return stat;

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

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  ECKASDH                                                   */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue)
{
   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) {
         /* eckasdhp */
         case 0:
            invokeStartElement (pctxt, "eckasdhp", -1);

            pvalue->u.eckasdhp = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdhp);

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

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

            break;

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

            pvalue->u.eckasdh2 = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdh2);

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

            invokeEndElement (pctxt, "eckasdh2", -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);
}

/**************************************************************/
/*                                                            */
/*  ClearToken                                                */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue)
{
   int stat = ASN_OK;
   OOCTXT lctxt;
   OOCTXT lctxt2;
   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.timeStampPresent = optbit;

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

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

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

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

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

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

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

   /* decode tokenOID */

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

   stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID);
   if (stat != ASN_OK) return stat;
   invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid);

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

   /* decode timeStamp */

   if (pvalue->m.timeStampPresent) {
      invokeStartElement (pctxt, "timeStamp", -1);

      stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp);
      if (stat != ASN_OK) return stat;

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

   /* decode password */

   if (pvalue->m.passwordPresent) {
      invokeStartElement (pctxt, "password", -1);

      stat = asn1PD_H235Password (pctxt, &pvalue->password);
      if (stat != ASN_OK) return stat;

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

   /* decode dhkey */

   if (pvalue->m.dhkeyPresent) {
      invokeStartElement (pctxt, "dhkey", -1);

      stat = asn1PD_H235DHset (pctxt, &pvalue->dhkey);
      if (stat != ASN_OK) return stat;

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

   /* decode challenge */

   if (pvalue->m.challengePresent) {
      invokeStartElement (pctxt, "challenge", -1);

      stat = asn1PD_H235ChallengeString (pctxt, &pvalue->challenge);
      if (stat != ASN_OK) return stat;

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

   /* decode random */

   if (pvalue->m.randomPresent) {
      invokeStartElement (pctxt, "random", -1);

      stat = asn1PD_H235RandomVal (pctxt, &pvalue->random);
      if (stat != ASN_OK) return stat;

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

   /* decode certificate */

   if (pvalue->m.certificatePresent) {
      invokeStartElement (pctxt, "certificate", -1);

      stat = asn1PD_H235TypedCertificate (pctxt, &pvalue->certificate);
      if (stat != ASN_OK) return stat;

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

   /* decode generalID */

   if (pvalue->m.generalIDPresent) {
      invokeStartElement (pctxt, "generalID", -1);

      stat = asn1PD_H235Identifier (pctxt, &pvalue->generalID);
      if (stat != ASN_OK) return stat;

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

   /* decode nonStandard */

   if (pvalue->m.nonStandardPresent) {
      invokeStartElement (pctxt, "nonStandard", -1);

      stat = asn1PD_H235NonStandardParameter (pctxt, &pvalue->nonStandard);
      if (stat != ASN_OK) return stat;

      invokeEndElement (pctxt, "nonStandard", -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;

            if (i < 2 && openType.numocts > 0) {  /* known element */
               copyContext (&lctxt2, pctxt);
               initContextBuffer (pctxt, openType.data, openType.numocts);

               switch (i) {
                  case 0:
                     pvalue->m.eckasdhkeyPresent = 1;

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

                     stat = asn1PD_H235ECKASDH (pctxt, &pvalue->eckasdhkey);
                     if (stat != ASN_OK) return stat;

                     invokeEndElement (pctxt, "eckasdhkey", -1);
                     break;

                  case 1:
                     pvalue->m.sendersIDPresent = 1;

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

                     stat = asn1PD_H235Identifier (pctxt, &pvalue->sendersID);
                     if (stat != ASN_OK) return stat;

                     invokeEndElement (pctxt, "sendersID", -1);
                     break;

                  default:
                     pctxt->buffer.byteIndex += openType.numocts;
               }
               copyContext (pctxt, &lctxt2);
            }
            else {  /* unknown element */
               pctxt->buffer.byteIndex += openType.numocts;
            }
         }
      }
   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  IV8                                                       */
/*                                                            */
/**************************************************************/

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

/**************************************************************/
/*                                                            */
/*  IV16                                                      */
/*                                                            */
/**************************************************************/

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

/**************************************************************/
/*                                                            */
/*  Params                                                    */
/*                                                            */
/**************************************************************/

EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue)
{
   int stat = ASN_OK;
   OOCTXT lctxt;
   OOCTXT lctxt2;
   ASN1OpenType openType;
   ASN1UINT bitcnt;
   ASN1UINT i;
   ASN1BOOL optbit;
   ASN1BOOL extbit;

   /* extension bit */

   DECODEBIT (pctxt, &extbit);

   /* optional bits */