cert.c

PGP—Pretty Good Privacy

        bytesused += PKIPackPrintableStringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIPrintableString *)(asnstruct->data),
                     PKIID_PrintableString,
                     erret);
        break;

    case PKIID_UniversalString:
        bytesused += PKIPackUniversalStringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIUniversalString *)(asnstruct->data),
                     PKIID_UniversalString,
                     erret);
        break;

    case PKIID_UTF8String:
        bytesused += PKIPackUTF8StringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIUTF8String *)(asnstruct->data),
                     PKIID_UTF8String,
                     erret);
        break;

    case PKIID_BMPString:
        bytesused += PKIPackBMPStringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIBMPString *)(asnstruct->data),
                     PKIID_BMPString,
                     erret);
        break;

    default:
        PKIERR( PKIErrChoiceBadType );
        break;
    } /* switch */

    if (bytesused < datasize && *erret == 0)
        PKIERR(PKIErrPackUnderrun)
    else if (bytesused > datasize && *erret == 0)
        PKIERR(PKIErrPackOverrun)

  return bytesused;
} /* PKIPackDirectoryStringInternal */

size_t PKIUnpkInPlaceDirectoryString(
     PKICONTEXT *ctx,
     PKIDirectoryString *asnstruct,/* output block */
     const unsigned char *buf,
     size_t buflen,
     unsigned char tag,
     int *erret)
{
    (void)tag; /* unused */


    if (erret == NULL) return 0; /* can't report errors */

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }
    if (asnstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }

    if (buf == NULL) {
        PKIERR(PKIErrUnpackNoBlockPtr);
        return 0;
    }

    if (buflen <= 0) return 0; /* no error -- no block */

    switch (*buf) {

    /* teletexString */
    case PKIID_T61String:
    case 0x20|PKIID_T61String:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewT61String(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceT61String(ctx, (PKIT61String *)(asnstruct->data),
                    buf, buflen,
                    PKIID_T61String, erret));
        /*NOTREACHED*/
        break;

    /* printableString */
    case PKIID_PrintableString:
    case 0x20|PKIID_PrintableString:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewPrintableString(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlacePrintableString(ctx, (PKIPrintableString *)(asnstruct->data),
                    buf, buflen,
                    PKIID_PrintableString, erret));
        /*NOTREACHED*/
        break;

    /* universalString */
    case PKIID_UniversalString:
    case 0x20|PKIID_UniversalString:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewUniversalString(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceUniversalString(ctx, (PKIUniversalString *)(asnstruct->data),
                    buf, buflen,
                    PKIID_UniversalString, erret));
        /*NOTREACHED*/
        break;

    /* utf8String */
    case PKIID_UTF8String:
    case 0x20|PKIID_UTF8String:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewUTF8String(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceUTF8String(ctx, (PKIUTF8String *)(asnstruct->data),
                    buf, buflen,
                    PKIID_UTF8String, erret));
        /*NOTREACHED*/
        break;

    /* bmpString */
    case PKIID_BMPString:
    case 0x20|PKIID_BMPString:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewBMPString(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceBMPString(ctx, (PKIBMPString *)(asnstruct->data),
                    buf, buflen,
                    PKIID_BMPString, erret));
        /*NOTREACHED*/
        break;

    default:
        PKIERR(PKIErrChoiceBadType);
        return 0;

    } /* switch */

} /* PKIUnpkInPlaceDirectoryString */

size_t PKIUnpackDirectoryStringInternal(
    PKICONTEXT *ctx,
    PKIDirectoryString **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int *erret)
{
    size_t bytesused;
    PKIDirectoryString *local = NULL ;

    if (erret == NULL) return 0;
    *erret = 0;

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }
    if (asnstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }
    *asnstruct = NULL;

    if (buflen <= 0) return 0; /* no bytes left */

    local = PKINewDirectoryString(ctx) ; /* carve a block for it */
    bytesused = PKIUnpkInPlaceDirectoryString(ctx, local, buf, buflen, tag, erret);
    if (*erret == PKIErrChoiceBadType) {
        *erret = 0;
        if (local != NULL) PKIFreeDirectoryString(ctx, local);
        return 0;
    }
    if (*erret != 0) {
        if (local != NULL) PKIFreeDirectoryString(ctx, local);
        return 0;
    }

    *asnstruct = local;
    return bytesused;
} /* PKIUnpackDirectoryStringInternal */


/******************************************************************
 * Routines for DisplayText
 ******************************************************************/

size_t PKISizeofDisplayTextInternal(
    PKIDisplayText *asnstruct,
    int outerSizeFlag,
    int expTaggedFlag)
{
    size_t body_size = 0;

    if (asnstruct == NULL)
        return 0;

    switch (asnstruct->CHOICE_field_type) {
      case PKIID_VisibleString:
      case 0x20|PKIID_VisibleString:
        body_size = PKISizeofVisibleStringInternal((PKIVisibleString *)(asnstruct->data), outerSizeFlag, expTaggedFlag);
        break;

      case PKIID_BMPString:
      case 0x20|PKIID_BMPString:
        body_size = PKISizeofBMPStringInternal((PKIBMPString *)(asnstruct->data), outerSizeFlag, expTaggedFlag);
        break;

      case PKIID_UTF8String:
      case 0x20|PKIID_UTF8String:
        body_size = PKISizeofUTF8StringInternal((PKIUTF8String *)(asnstruct->data), outerSizeFlag, expTaggedFlag);
        break;

      default:
        break;

    } /* switch */

    return (body_size);
} /* PKISizeofDisplayTextInternal */

void PKIDropInPlaceDisplayText(
    PKICONTEXT *ctx,
    PKIDisplayText *f)
{
    if (ctx == NULL) return;
    if (f == NULL) return;

    switch(f->CHOICE_field_type) {

    case PKIID_VisibleString:
    case 0x20|PKIID_VisibleString:
        PKIFreeVisibleString(ctx, (PKIVisibleString *)( f->data ));
        break;
    case PKIID_BMPString:
    case 0x20|PKIID_BMPString:
        PKIFreeBMPString(ctx, (PKIBMPString *)( f->data ));
        break;
    case PKIID_UTF8String:
    case 0x20|PKIID_UTF8String:
        PKIFreeUTF8String(ctx, (PKIUTF8String *)( f->data ));
        break;
    default:
        break;
    } /* switch */

} /* PKIDropInPlaceDisplayText */

size_t PKIPackDisplayTextInternal(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIDisplayText *asnstruct,
    unsigned char tag,
    int *erret)
{
    size_t bytesused = 0;
    size_t datasize;

    (void)tag; /* unused */

    if (erret == NULL) return 0; /* can't report errors */

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }
    if (asnstruct == NULL) return 0;

    /* lth of the block body */
    datasize = PKISizeofDisplayText(ctx, asnstruct, PKITRUE);
    if (datasize > buflen) {
        PKIERR(PKIErrPackBufferTooShort);
        return 0;
    }

    switch ( (asnstruct->CHOICE_field_type & 0xDF) ) {

    case PKIID_VisibleString:
        bytesused += PKIPackVisibleStringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIVisibleString *)(asnstruct->data),
                     PKIID_VisibleString,
                     erret);
        break;

    case PKIID_BMPString:
        bytesused += PKIPackBMPStringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIBMPString *)(asnstruct->data),
                     PKIID_BMPString,
                     erret);
        break;

    case PKIID_UTF8String:
        bytesused += PKIPackUTF8StringInternal(ctx, buf+bytesused, buflen-bytesused,
                     (PKIUTF8String *)(asnstruct->data),
                     PKIID_UTF8String,
                     erret);
        break;

    default:
        PKIERR( PKIErrChoiceBadType );
        break;
    } /* switch */

    if (bytesused < datasize && *erret == 0)
        PKIERR(PKIErrPackUnderrun)
    else if (bytesused > datasize && *erret == 0)
        PKIERR(PKIErrPackOverrun)

  return bytesused;
} /* PKIPackDisplayTextInternal */

size_t PKIUnpkInPlaceDisplayText(
     PKICONTEXT *ctx,
     PKIDisplayText *asnstruct,/* output block */
     const unsigned char *buf,
     size_t buflen,
     unsigned char tag,
     int *erret)
{
    (void)tag; /* unused */


    if (erret == NULL) return 0; /* can't report errors */

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }
    if (asnstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }

    if (buf == NULL) {
        PKIERR(PKIErrUnpackNoBlockPtr);
        return 0;
    }

    if (buflen <= 0) return 0; /* no error -- no block */

    switch (*buf) {

    /* visibleString */
    case PKIID_VisibleString:
    case 0x20|PKIID_VisibleString:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewVisibleString(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceVisibleString(ctx, (PKIVisibleString *)(asnstruct->data),
                    buf, buflen,
                    PKIID_VisibleString, erret));
        /*NOTREACHED*/
        break;

    /* bmpString */
    case PKIID_BMPString:
    case 0x20|PKIID_BMPString:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewBMPString(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceBMPString(ctx, (PKIBMPString *)(asnstruct->data),
                    buf, buflen,
                    PKIID_BMPString, erret));
        /*NOTREACHED*/
        break;

    /* utf8String */
    case PKIID_UTF8String:
    case 0x20|PKIID_UTF8String:
        asnstruct->CHOICE_field_type = *buf;
        asnstruct->data = (void *)PKINewUTF8String(ctx);
        if (asnstruct->data == NULL) {
            PKIERR(PKIErrOutOfMemory);
            return 0;
        }
        return (PKIUnpkInPlaceUTF8String(ctx, (PKIUTF8String *)(asnstruct->data),
                    buf, buflen,
                    PKIID_UTF8String, erret));
        /*NOTREACHED*/
        break;

    default:
        PKIERR(PKIErrChoiceBadType);
        return 0;

    } /* switch */

} /* PKIUnpkInPlaceDisplayText */

size_t PKIUnpackDisplayTextInternal(
    PKICONTEXT *ctx,
    PKIDisplayText **asnstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int *erret)
{
    size_t bytesused;
    PKIDisplayText *local = NULL ;

    if (erret == NULL) return 0;
    *erret = 0;

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }
    if (asnstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }
    *asnstruct = NULL;

    if (buflen <= 0) return 0; /* no bytes left */

    local = PKINewDisplayText(ctx) ; /* carve a block for it */
    bytesused = PKIUnpkInPlaceDisplayText(ctx, local, buf, buflen, tag, erret);
    if (*erret == PKIErrChoiceBadType) {
        *erret = 0;
        if (local != NULL) PKIFreeDisplayText(ctx, local);
        return 0;
    }
    if (*erret != 0) {
        if (local != NULL) PKIFreeDisplayText(ctx, local);
        return 0;
    }

    *asnstruct = local;
    return bytesused;
} /* PKIUnpackDisplayTextInternal */


/******************************************************************
 * Routines for Dss_Parms
 ******************************************************************/

size_t PKISizeofDss_ParmsInternal(
    PKIDss_Parms *asnstruct,
    int outerSizeFlag,
    int expTaggedFlag)
{
    size_t body_size = 0;

    if (asnstruct == NULL)
        return 0;

    body_size =
            PKISizeofINTEGERInternal(&asnstruct->p, PKITRUE, PKIFALSE)
          + PKISizeofINTEGERInternal(&asnstruct->q, PKITRUE, PKIFALSE)