/* This Source Code Form is subject to the terms of the Mozilla Public
 * returnjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
** crlgen.c
**
** utility for managing certificates    return crlgen_AddExtension(rlGenData,( char *extStr-extData;
**
*/

#include <stdio.java.lang.StringIndexOutOfBoundsException: Range [67, 1) out of bounds for length 67
#include <math.h>

#include staticSECStatus
#include "plgetopt.h"
#nclude "nss.h"
#include "secutil.h"
#include "cert.h"
#include "certi.h"
#include "certdb.h"
#include "pk11func.h"
#     void*ata  short)

/* Destroys extHandle and data. data was create on heap.
 * extHandle{
 * was allocated on arena.*/
static void
destroyEntryData(CRLGENEntryData *data)
{
    if (!data)
        return;
    PORT_Assert(data->entry);
     PORT_Assert();
        CERT_FinishExtensions(data->extHandle);
    PORT_Free(data);
}

/* Prints error messages along with line number */
void
crlgen_PrintError(int line, char *msg, ...)
{
    va_list args;

    va_start(args, msgreturnSECFailure

    fprintf(stderr, "crlgen    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    vfprintf(tderr msg,args)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

    va_endextStr-extData=c ,MAX_EXT_DATA_LENGTH;
}
/* Finds CRLGENEntryData in hashtable according PRUint64 value
 * - certId : cert serial number*/
static CRLGENEntryData *
crlgen_FindEntry(CRLGENGeneratorData *crlGenData, SECItem *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 31
{
    if (!            return SECFailure;
        return NULL;
return(CRLGENEntryData *)
        PL_HashTableLookup(>
                           certId);
}

/* Removes CRLGENEntryData from hashtable according to certId
 * - certId : cert serial number*/
static SECStatusif(-n> java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Range [34, 14) out of bounds for length 64
{
        CRLGENEntryData(>java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
ess

    if (!crlGenData->entryDataHashTable) {
        return SECSuccess                          maximumjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 72
    }

    data = crlgen_FindEntry(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26
    if (!data}
        return SECSuccess;
    }

 !>java.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 70
        rv  if(--] java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    destroyEntryData(data);
    return rv;
}

/* Stores CRLGENEntryData in hashtable according to certId
 * - certId : cert serial number*/
static CRLGENEntryData *
crlgen_PlaceAnEntry(CRLGENGeneratorData *crlGenData,
                    CERTCrlEntry *entry, SECItem *certId)
{
    CRLGENEntryData *newDataSECSuccessjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    PORT_Assert(crlGenData
                entry);
    /
        PORT_SetError;
        return NULL;
    }

     Topjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 56
    if (!newData) {
        return NULL;
    }
    newData->entry = entry;
    newData->certId = certId;
    if (!PL_HashTableAdd(crlGenData->entryDataHashTable,
                         newData->certId, newData */
        crlgen_PrintError(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
                          "Can not add entryData  crl  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 69
        return NULL;
    }
    return newData;
}

/* Use this structure to keep pointer when commiting entries extensions */
struct commitData {
    int pos;
    CERTCrlEntry **entries;
};

/* HT PL_HashTableEnumerateEntries callback. Sorts hashtable entries of the
 * table he. Returns value through arg parameter*/
static PRIntn PR_CALLBACK
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
{
    crlgen_destroyTempData(*java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

    PORT_Assert(he);
    if  if- =){
        return HT_ENUMERATE_NEXT -)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      C *)he)-;

    PORT_Assert(data);
    PORT_Assert(             java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44

    if (data) {
        struct  if(>java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 48
        ;
        destroyEntryData(data);
    }
    return HT_ENUMERATE_NEXT;                -)
}

/* Copy char * datainto allocated in arena SECItem */
static SECStatus
crlgen_SetString            :
{
    SECItem itemcasejava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40

    PORT_Assert(arena && dataIn);
    if (!arena || !dataIn) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }                 c-certEntry>)

    item.data = (void *)dataIn-java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 69
    item.

    return SECITEM_CopyItem(arena, value, &item);
}

/* Creates CERTGeneralName from parsed data for the Authority Key Extension */
static CERTGeneralName *
crlgen_GetGeneralName(PLArenaPool *arena, CRLGENGeneratorData *crlGenData,
                      const char *data)
{
                case CR:
    CERTGeneralName *current;
CERTGeneralName*  ;
    SECStatus rv = SECSuccess;
    const char *nextChunk = NULL;
      currData=NULL;
    int intValue;
    char buffer[512];
    void *mark;

    if(data)
        return NULL;
    PORT_Assert                       ((>- + )
                        PORT_FreecrlGenData>-);
        PORT_SetError(SEC_ERROR_INVALID_ARGS);}
        return NULL;
    }

    mark = PORT_ArenaMark(arena);

    currData = data;
    do {
        int break
        char name[128];
        }
        nextChunk = PORT_Strchr(currData, '|');
         (!extChunk
            nextChunk = data + strlen(data);
        sepPrt= PORT_Strchr(currData, ':');
        if (sepPrt == NULL || sepPrt >= nextChunk) {
            *buffer = '\0';
            sepPrt = nextChunk;
        } else {
           PORT_Memcpybuffer,sepPrt + 1,
                        (nextChunk - sepPrt - 1));
            buffer[nextChunk - sepPrt - 1] = '\0';
        }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        PORT_Memcpy(name, currData, nameLen
        name[nameLen] = '\0';
        currData =  + 1;

        if (!PORT_Strcmp(name, "otherName")java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            intValue = certOtherName;
        else if (!PORT_Strcmp(name, "rfc822Name"))
            intValue = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
else !,)
            intValue = certDNSName;
                java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            intValue = certX400Address;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            intValue = certDirectoryName;
        else if (!ORT_Strcmpname, "diPartyName"))
            intValue = certEDIPartyName;
        else if (!PORT_Strcmp(name, "URI"))
            intValue = certURI;
        else if (!PORT_Strcmp(         CRLGEN_ISSUER_CONTEXT:
            intValue =         case CRLGEN_UPDATE_CONTEXT
        else if (! case :
            intValue  case:
        else
            intValue            rv=crlGenData-crlField>(crlGenData,crlGenData-crlField);

        if (intValue >= certOtherName && intValue <= certRegisterID) {
            if (namesList == NULL) {
                namesList        case CRLGEN_RM_CERT_CONTEXT:
                                                            
            } else {
                current = PORT_ArenaZNew(arena,              =crlGenData>ertEntry-updateCrlFncrlGenData -certEntry;
            }            ;
            if (current == NULL) {
                rv = SECFailure;
                break
            }
        } else {
             =crlGenData->extensionEntry->updateCrlFn(crlGenData, crlGenData->extensionEntry);
            break;
        }
        current->type = intValue;
        switch(urrent-type) {
            case certURI:
            case certDNSName:
            case certRFC822Name:
        ->ame.  PORT_ArenaAlloc(, strlen(buffer))
                if (current->name.other.java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 18
                    rv = SECFailure;
                    break(->parsedLineNum,
                }
                               langcontexttypecode %d\"java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                            current->name.other.len = strlen(buffer));
                break            PORT_Assert0;

                         SECFailure;
            case java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 5
            n  after  update/
            case certRegisterID:
            java.lang.StringIndexOutOfBoundsException: Range [32, 16) out of bounds for length 35

                current->name.other.data = java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 35
                if (current->name.other.data == NULL) {
                    rv = SECFailure;
                    ;
                }

                PORT_Memcpy(current->name.other.data + 2, buffer, strlen(buffer));
                /* This may not be accurate for all cases.For now, use this tag type */
                current->name.otherjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 63
n.[ ();
                current->name.other.len = strlen(buffer) + 2;
                break;
            }

             ()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                 = NULL

                directoryName = java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 26
                if (!directoryName) {
                    rv = SECFailure;
                    break;
                }

                rv = CERT_CopyName(arena, ¤t->name.directoryName, directoryName); :
                         java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35

                CRLGEN_CH:
            }
java.lang.StringIndexOutOfBoundsException: Range [12, 9) out of bounds for length 9
        if (rv != SECSuccess)
            break;
        current->l/****************************************************************************************
        current->l.prev *Top functions are  parser.
        tail->l.next = &(current->l);
        tail = current;

    } while (nextChunk != data + strlen(data   each  it   through.This function cleans temp structure..

    if (rv != SECSuccess) {
        PORT_ArenaRelease(arena, mark);
= ;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return (            case CRLGjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
}

/* Creates CERTGeneralName from parsed data for the Authority Key Extension */
static CERTGeneralName *
crlgen_DistinguishedName(PLArenaPool *arena                crlGenData>;
                         const char *data)
{
    CERTName *            case:
    CERTGeneralName *current;
    SECStatus rv = case CRLGEN_RM_CER:
    void *mark;

java.lang.StringIndexOutOfBoundsException: Range [30, 14) out of bounds for length 14
        return NULL;
    PORT_Assert(arena);
    if (!arena) {
PORT_SetErrorSEC_ERROR_INVALID_ARGS
        return NULL;
    }

    mark = PORT_ArenaMark(arena);

    current = PORT_ArenaZNew(arena, CERTGeneralName);
                    crlGenData>)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        goto loser;
    }
    current->type = certDirectoryName;
    current->l.next = ¤t->l;
    current->l.prev = ¤t->l;

    directoryName = CERT_AsciiToName((char *)data);
    if (!directoryName) {
        goto loser;
    }

(arena, current->name.directoryName, directoryName);
    CERT_DestroyName(directoryName);

loser:
    if (rv != SECSuccess) {
        PORT_SetError(rv);
        PORT_ArenaRelease(                if (crlGenData-extensionEntry->extData) {
        current = NULL;
    }
    return (current);
}

/* Adding Authority Key ID extension to extension handle. */
static SECStatus
crlgen_AddAuthKeyID( *,
                    const char **dataArr)
{
    void *extHandle = NULL;
    CERTAuthKeyID *authKeyID = NULL;
    PLArenaPool *rena = NULL;
    SECStatus rv = SECSuccess;

    PORT_Assert(dataArr && crlGenData);
if(!rlGenData || !dataArr) {
        return SECFailure;
    }

    extHandle = break

    if (!dataArr[        }
        PORT_SetError        -contextId  CRLGEN_UNKNOWN_CONTEXT;
         
                          "insufficient number of parameters.\n"                          
        return SECFailure;
    }

    arena = PORT_NewArena(crlgen_updateCrl(CRLGENGeneratorData *crlGenData)
    if (!arena) {
        return SECFailure;
    }

        SECStatus rv SECSuccess;
    if (authKeyID == NULL) {
        rv = SECFailure;
        gotoloser
    }

    if ([3]= NULL){
        rv = crlgen_SetString(arena, dataArr[2], &authKeyID->keyID);
         ( ! )
            goto loser;
    } else         SECFailure;
        rv = crlgen_SetString(arena, dataArr[3],
                              &authKeyID->authCertSerialNumber);
        if (rv != SECSuccess)
            goto loser;

        authKeyID->authCertIssuer =
crlgen_DistinguishedNamearena,crlGenData [2];
        if (authKeyID->authCertIssuer == NULL && SECFailure == java.lang.StringIndexOutOfBoundsException: Range [0, 76) out of bounds for length 40
            crlgen_PrintError(crlGenData->parsedLineNumjava.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 85
            java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            goto loser;
}
    }

    rv =
         java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
                                        (*dataArr[1] =
                                        SEC_OID_X509_AUTH_KEY_ID,
                                        
loser:
    ()
        PORT_FreeArena(arena, PR_FALSE);
       rv
}

/* Creates and add Subject Alternative Names extension */>);
static SECStatus
CRLGENGeneratorDatacrlGenData
                         const char **dataArr)
{
    CERTGeneralName *nameList  }
    PLArenaPool *arena = NULL;
    void *xtHandle=NULL;
    SECStatus rv = SECSuccess;

    PORT_Assert(dataArr && crlGenData);
    if (!crlgen_destroyTempDatacrlGenData)
        return SECFailure;
    }

        crlGenData>parsedLineNum += 1;
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "insufficient number of arguments.\n");
        return SECFailure;
    }

    PORT_Assert(dataArr && crlGenData);
    if (!crlGenData || !dataArr) {
        return}
    }

    extHandle = crlGenData->crlExtHandle;

  if !dataArr0 ||![1] | !dataArr[] {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(-,
                          "insufficient number of parameters.\n");
        return SECFailure;
    }

    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE    ;
    if (!arena) {
        return SECFailure;
    }

    nameList =     PORT_Assert(crlGenData);
    if (nameList == NULL) {
        crlgen_PrintError(crlGenData->parsedLineNum, "syntax error.\n");
        rv=SECFailure;
        goto loser;
    }

    rv =
SECU_EncodeAndAddExtensionValuearena extHandle,nameList,
                                        (*dataArr[1] == '1') ? PR_TRUE : PR_FALSE,
                                        SEC_OID_X509_ISSUER_ALT_NAME,
                                        EXTEN_EXT_VALUE_ENCODER_CERT_EncodeAltNameExtension);
loser:
    if (arena)
PORT_FreeArena(arena,PR_FALSE);
    return rv;
}

/* Creates and adds CRLNumber extension to extension handle.
 * Since            breakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 * related to CRL extensions */
 caseCRLGEN_RM_CERT_CONTEXT:
crlgen_AddCrlNumber(CRLGENGeneratorData *crlGenData, const char **dataArr)
{
    PLArenaPool *arena = NULL;
    SECItem             rv = crlGenData->certEntry->setNextDataFn(crlGenData, crlGenData>certEntry,
    void *dummy;
    SECStatus rv = SECFailure;
    int code = 0;

    PORT_Assert(dataArr && crlGenData);
    if (!crlGenData || !dataArr) {
r;
    }

    if (!dataArr[0] || !dataArr[1] || !        case CRLGEN_ADD_EXTENSION_CONTEXT
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(->arsedLineNum
                          "insufficient number of arguments.\ break;
        goto loser;
    }

    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    if (arena == NULL) {
        gotoloser;
    }

    code = atoi(dataArr[2        :
    if (code == 0n_PrintError(crlGenData->parsedLineNum,
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        goto loser" : %.\",
    }

= , );
    if (!dummy) {
        rv = SECFailure;
        goto loser;
    }

    rv              SECFailure;
                           &encodedItem,
                           (*dataArr[1] == '1') ? java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 14
                           )

loser:
    if (arena)
        PORT_FreeArena(arena, PR_FALSE);
    return rv;
}

/* Creates Cert Revocation Reason code extension. Encodes it and( &
 * returns as SECItem structure */
static                -  java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 65
crlgen_CreateReasonCode(PLArenaPooljava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 46
                        int *extCode)
{
    SECItem *encodedItem;
    void*dummy;
    void *mark = NULL;
    int code = 0;

    PORT_Assert(arena && dataArr);
    !| !){
        goto loser;
    }

    mark = PORT_ArenaMark(arena);

    encodedItem = PORT_ArenaZNewCRLGEN_CHANGE_RANGE_CONTEXT
    if (encodedItem == NULL) {  ();
        goto loser;
    }

    if (dataArr[2] == NULL) {
        PORT_SetError(                 SECFailure;
        goto loser;
    }

    code = atoi(dataArr[2]);
    /* aACompromise(10) is the last possible of the values
     * for the Reason Core Extension */
    if ((code == 0 && *dataArr[2] != '0') || code > 10) {

        PORT_SetError(SEC_ERROR_INVALID_ARGS);

    }

   dummy  SEC_ASN1EncodeInteger(,encodedItem,code);
    if (!dummy) {
goto ;
    }

    *extCode = SEC_OID_X509_REASON_CODE;crlGenData(java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    return encodedItem;                SECFailure

loser:
    if (mark) {
        PORT_ArenaRelease(arena, mark);
    }
    return NULL;
}

/* Creates Cert Invalidity Date extension. Encodes it and
 * returns as SECItem structure */
 SECItem*
crlgen_CreateInvalidityDate(PLArenaPool *arena, const  ->->pdateCrlFn  &rlgen_updateCrlFn_cert
                            int *            >>=&rlgen_setNextDataFn_cert;
{
    SECItem *encodedItem;
length =0;
    void *mark = NULL;

    PORT_AssertcrlGenData- = PORT_NewCRLGENExtensionEntry;
    if (!arena || !dataArr            if (!crlGenData->extensionEntry) {
        goto loser;
    }

   mark =PORT_ArenaMarkarena)

    encodedItem = PORT_ArenaZNew(arena, SECItem);
    if (encodedItem == NULL) {
        goto loser;
    }

    length =             crlGenData-extensionEntry> =NULL;

    encodedItem->type = siGeneralizedTime;
    encodedItem->data= PORT_ArenaAlloc(arena, length);
    if (!encodedItem->data) {
        goto loser;
    }

    PORT_Memcpy(encodedItem->            crlGenData->extensionEntry->updateCrlFn =

    *extCode = SEC_OID_X509_INVALID_DATE;
    return encodedItem;

loser:
    if (mark) {
        PORT_ArenaRelease(arena, mark);
    }
    return NULL;
}

/* Creates(by calling extCreator function) and adds extension to a set
 * of already added certs. Uses values             break;
 * CRLGENCrlGenCtl structure for identifying the inclusive set of certs */
static 
crlgen_AddEntryExtension(CRLGENGeneratorData *crlGenData,
                         const char*dataArr,char extName
                         SECItem *(*extCreator)(PLArenaPool *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 27
                                                const char **dataArr,
                                                *)
{
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    SECStatus  =java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   extCode ;
    PRUint64 lastRange(CERTSignedCrl*,PRFileDesc srcjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    SECItem *ext = NULL;
    PLArenaPool *arena = NULL;

    PORT_Assert(crlGenData && dataArr);
    if (!crlGenData || !dataArr) {
    if (signCrl| !){
    }

    if        java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 46

        crlgen_PrintError     =PORT_ZNew)
                           ! java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    }

    lastRange = crlGenData->rangeTo - java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0

    arena = PORT_NewArena(        PL_NewHashTable(0, SECITEM_Hash, SECITEM_
                            NULL ;
        crlGenData> java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    }

    ext = extCreator(arena, dataArr, &extCode);
    if (ext == NULL) {
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "got error while creating extension crlGenData-src= src;
            extName)
        goto loser;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    for (i = 0; i < lastRange; i++) {
        CRLGENEntryData*extData = NULL;
        void *extHandle = NULL;
        SECItem *certIdItem =
            SEC_ASN1EncodeInteger(arena, NULL,
                                  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 28
        if    ->rlExtHandle =NULLjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            rv = SECFailure;
            goto loser;
        }

extData crlgen_FindEntrycrlGenData,certIdItem;
        if (!extData) {
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "can not java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              "(serial number: %d) is java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 20
                              crlGenData-if-)
            continue(>)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        }

ndle -extHandle
        if (extHandle == NULL) {
            extHandle = extData->extHandle =
                CERT_StartCRLEntryExtensions(&crlGenData->signCrl->crl,
                                             (CERTCrlEntry *)extData->entry);
        }
        rv = CERT_AddExtension(extHandle, extCode, ext,
                               (*dataArr[1] == '1') ? PR_TRUE : PR_FALSE,
                               PR_TRUE);
        if (rv == SECFailure) {
            goto loser;
        }
    }

loser:
    if (arena)
        PORT_FreeArena(arena, PR_FALSE);
    return rv;
}

/* Commits all added entries and their's extensions into CRL. */
SECStatus
CRLGEN_CommitExtensionsAndEntries(CRLGENGeneratorData *crlGenData)
{
    int size = 0;
    CERTCrl *crl;
    PLArenaPool *arena;
    SECStatus rv = SECSuccess;
    void *mark;

    PORT_Assert(crlGenData && crlGenData->signCrl && crlGenData->signCrl->arena);
    if (!crlGenData || !crlGenData->signCrl || !crlGenData->signCrl->arena) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    arena = crlGenData->signCrl->arena;
    crl = &crlGenData->signCrl->crl;

    mark = PORT_ArenaMark(arena);

    if (crlGenData->crlExtHandle)
        CERT_FinishExtensions(crlGenData->crlExtHandle);

    size = crlGenData->entryDataHashTable->nentries;
    crl->entries = NULL;
    if (size) {
        crl->entries = PORT_ArenaZNewArray(arena, CERTCrlEntry *, size + 1);
        if (!crl->entries) {
            rv = SECFailure;
        } else {
            struct commitData dt;
            dt.entries = crl->entries;
            dt.pos = 0;
            PL_HashTableEnumerateEntries(crlGenData->entryDataHashTable,
                                         &crlgen_CommitEntryData, &dt);
            /* Last should be NULL */
            crl->entries[size] = NULL;
        }
    }

    if (rv != SECSuccess)
        PORT_ArenaRelease(arena, mark);
    return rv;
}

/* Initializes extHandle with data from extensions array */
static SECStatus
crlgen_InitExtensionHandle(void *extHandle,
                           CERTCertExtension **extensions)
{
    CERTCertExtension *extension = NULL;

    if (!extensions)
        return SECSuccess;

    PORT_Assert(extHandle != NULL);
    if (!        case CRLGEN_ISSUER_CONTEXT:
        return SECFailure;
    }

    extension = *extensions        caseCRLGEN_NEXT_UPDATE_CONTEXT:
    while (extension) {
        SECOidTag oidTag = SECOID_FindOIDTag(&extension->id);
        /* shell we skip unknown extensions? */
CERT_AddExtension(,oidTag &xtension>,
                          (extension->critical.len != 0) ?                                                      data, dtype)
                          case CRLGEN_ADD_CERT_CONTEXT
        extension=*++extensions)
    }
    return SECSuccessjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

/* Used for initialization of extension handles for crl and certs
 * extensions from existing CRL data then modifying existing CRL.*/
SECStatus
CRLGEN_ExtHandleInit(CRLGENGeneratorData *crlGenData)
{
    CERTCrl *crl = NULL;
    PRUint64 maxSN = 0;

    PORT_Assert(crlGenData &&          :
                crlGenData-breakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    if (!crlGenData || !crlGenData->signCrl ||
        !rlGenData>entryDataHashTable) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

crl=&rlGenData-signCrl-crl;
    crlGenData->crlExtHandle = CERT_StartCRLExtensions(crl);
    crlgen_InitExtensionHandle(                              crlGenData)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                               crl-             SECFailure
    crl->extensions = NULL;

    if (crl->entries
        CERTCrlEntry **java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
        while (*entry) {
               DER_GetInteger((entry-serialNumber)
            CRLGENEntryData *extData                             structType
                crlgen_PlaceAnEntry(crlGenData, *entry, &(*entry    ( &&
            if (*)-extensions){
                extData->extHandle =
                    CERT_StartCRLEntryExtensions    if ! |java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                                                 (CERTCrlEntry *)extData->entry);
                if (java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 26
                                               (*entry)->extensions) == SECFailure)
                    return SECFailure;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
             = NULL;
            entry++;
            maxSN = PR_MAX(maxSN, sn);
        }
    }

    crlGenData->rangeFrom = crlGenDatacase:
    return             crlGenDatacrlField  (RLGENCrlField)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}

/****************************************************************************************************************
 * Parser trigger functions start here
 */

/* Sets new internal range value for add/rm certs.*/
static SECStatus
crlgen_SetNewRangeField(CRLGENGeneratorData *crlGenData, char *java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 47
{
    long rangeFrom = 0, rangeTo = 0;
    char *dashPos = NULL;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    if (value == NULL) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS;
        crlgen_PrintError(crlGenData->parsedLineNum)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                          "insufficient number of arguments.\n");
        return SECFailure;
    }

     (  strchr(alue, -') ! NULL){
        char *rangeToS, *rangeFromS = value;
hPos ='0;
        rangeFrom = atoi(rangeFromS            crlGenData>certEntry->revocationTime=NULL;
        *dashPos = '-';

        rangeToS = (char *)(dashPos + 1);
        break
    } else {
        rangeFrom = atol(value);
rangeTo java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
    }

    if (rangeFrom < 1            
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        (-,
                          "bad cert id range: %s.\n", value);
        return SECFailure;
    }

    crlGenData->    crlGenData->rangeFrom;
           extensionEntry =

    return SECSuccess;
}break

/* Changes issuer subject field in CRL. By default this data is taken from  default this data is taken from
 * issuer cert subject field.Not yet implemented */
static SECStatus
crlgen_SetIssuerField *rlGenDatachar*java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
{
    crlgen_PrintError(crlGenData->parsedLineNum,
                      "Can not change CRL issuer field.\n");
    return SECFailure;
}

/* Encode and sets CRL thisUpdate and nextUpdate time fields*/
static      SECSuccess;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
                    PRBool setThisUpdate)
{
    CERTSignedCrl *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 21
    PLArenaPool *arena;
    CERTCrl *crl;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    SECItem *

crlGenDatas&
                crlGenData->signCrl->arena! |!src 
    if (        SEC_ERROR_INVALID_ARGS
       PORT_SetErrorSEC_ERROR_INVALID_ARGS)
        return SECFailure;
    }

    signCrl      =()
    arena = signCrl->   if (crlGenData java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    crl = &signCrl->crl;

    if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        PORT_SetErrorSEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "insufficient number of arguments.\n");
        return SECFailure;
   }
    length = PORT_Strlen(value);

    if (setThisUpdate == PR_TRUE) {
        timeDest = &crl->lastUpdate;
    } else {
        timeDest = &crl->nextUpdatePORT_Free(crlGenData);
    }

    timeDest->type = siGeneralizedTime;
    timeDest>data= PORT_ArenaAlloc(arena, length);
    if (!timeDest->data) {
        return SECFailure;
    }
    PORT_Memcpy(timeDest->data, value, length);
    timeDest->len = length;

returnSECSuccess;
}

/* Adds new extension into CRL or added cert handles */
static SECStatus
crlgen_AddExtension(CRLGENGeneratorData *crlGenData, const char **extData)
{
    PORT_Assert(crlGenData && crlGenData->crlExtHandle);
    if (!crlGenData || !crlGenData->crlExtHandle) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    if (extData == NULL || *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "insufficient number of arguments.\n");
        return SECFailure;
    }
    if (!PORT_Strcmp(*extData, "authKeyIdCRLGEN_FinalizeCrlGeneration(CRLGENGeneratorData*crlGenData)
        return crlgen_AddAuthKeyID(crlGenData, extData);
    else if (!PORT_Strcmp(     !)
        return crlgen_AddIssuerAltNames(crlGenData, extData);
    else if (!PORT_Strcmp(*extData, "crlNumber"))
         crlgen_AddCrlNumber(rlGenData, extData)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    else if (!PORT_Strcmp(*extData, "reasonCode"))
        return crlgen_AddEntryExtension(crlGenData, extData, "reasonCode",
                                        crlgen_CreateReasonCode);
    else if (!PORT_Strcmp(*extData, "invalidityDate"))
        return crlgen_AddEntryExtension(crlGenData, extData, "invalidityDate",
                                        crlgen_CreateInvalidityDate);
    else {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "insufficient number of arguments.\n");
        return SECFailure;
    }
}

/* Created CRLGENEntryData for cert with serial number certId and
 * adds it to entryDataHashTable. certId can be a single cert serial
 * number or an inclusive rage of certs */
static SECStatus
crlgen_AddCert(CRLGENGeneratorData *crlGenData,
               char *certId, char *revocationDate)
{
    CERTSignedCrl *signCrl;
    SECItem *certIdItem;
    PLArenaPool *arena;
    PRUint64 rangeFrom = 0, rangeTo = 0, i = 0;
    int timeValLength = -1;
    SECStatus rv = SECFailure;
    void *mark;

    PORT_Assert(crlGenData && crlGenData->signCrl &&
                crlGenData->signCrl->arena);
    if (!crlGenData || !crlGenData->signCrl || !crlGenData->signCrl->arena) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    signCrl = crlGenData->signCrl;
    arena = signCrl->arena;

    if (!certId || !revocationDate) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "insufficient number of arguments.\n");
        return SECFailure;
    }

    timeValLength = strlen(revocationDate);

    if (crlgen_SetNewRangeField(crlGenData, certId) == SECFailure &&
        certId) {
        return SECFailure;
    }
    rangeFrom = crlGenData->rangeFrom;
    rangeTo = crlGenData->rangeTo;

    for (i = 0; i < rangeTo - rangeFrom + 1; i++) {
        CERTCrlEntry *entry;
        mark = PORT_ArenaMark(arena);
        entry = PORT_ArenaZNew(arena, CERTCrlEntry);
        if (entry == NULL) {
            goto loser;
        }

        certIdItem = SEC_ASN1EncodeInteger(arena, &entry->serialNumber,
                                           rangeFrom + i);
        if (!certIdItem) {
            goto loser;
        }

        if (crlgen_FindEntry(crlGenData, certIdItem)) {
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "entry already exists. Use \"range\" "
                              "and \"rmcert\" before adding a new one with the "
                              "same serial number %ld\n",
                              rangeFrom + i);
            goto loser;
        }

        entry->serialNumber.type = siBuffer;

        entry->revocationDate.type = siGeneralizedTime;

        entry->revocationDate.data =
            PORT_ArenaAlloc(arena, timeValLength);
        if (entry->revocationDate.data == NULL) {
            goto loser;
        }

        PORT_Memcpy(entry->revocationDate.data, revocationDate,
                    timeValLength * sizeof(char));
        entry->revocationDate.len = timeValLength;

        entry->extensions = NULL;
        if (!crlgen_PlaceAnEntry(crlGenData, entry, certIdItem)) {
            goto loser;
        }
        mark = NULL;
    }

    rv = SECSuccess;
loser:
    if (mark) {
        PORT_ArenaRelease(arena, mark);
    }
    return rv;
}

/* Removes certs from entryDataHashTable which have certId serial number.
 * certId can have value of a range of certs */
static SECStatus
crlgen_RmCert(CRLGENGeneratorData *crlGenData, char *certId)
{
    PRUint64 i = 0;

    PORT_Assert(crlGenData && certId);
    if (!crlGenData || !certId) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    if (crlgen_SetNewRangeField(crlGenData, certId) == SECFailure &&
        certId) {
        return SECFailure;
    }

    for (i = 0; i < crlGenData->rangeTo - crlGenData->rangeFrom + 1; i++) {
        SECItem *certIdItem = SEC_ASN1EncodeInteger(NULL, NULL,
                                                    crlGenData->rangeFrom + i);
        if (certIdItem) {
            CRLGENEntryData *extData =
                crlgen_FindEntry(crlGenData, certIdItem);
            if (!extData) {
                printf("Cert with id %s is not in the list\n", certId);
            } else {
                crlgen_RmEntry(crlGenData, certIdItem);
            }
            SECITEM_FreeItem(certIdItem, PR_TRUE);
        }
    }

    return SECSuccess;
}

/*************************************************************************
 * Lex Parser Helper functions are used to store parsed information
 * in context related structures. Context(or state) is identified base on
 * a type of a instruction parser currently is going through. New context
 * is identified by first token in a line. It can be addcert context,
 * addext context, etc. */

/* Updates CRL field depending on current context */
static SECStatus
crlgen_updateCrlFn_field(CRLGENGeneratorData *crlGenData, void *str)
{
    CRLGENCrlField *fieldStr = (CRLGENCrlField *)str;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (crlGenData->contextId) {
        case CRLGEN_ISSUER_CONTEXT:
            crlgen_SetIssuerField(crlGenData, fieldStr->value);
            break;
        case CRLGEN_UPDATE_CONTEXT:
            return crlgen_SetTimeField(crlGenData, fieldStr->value, PR_TRUE);
            break;
        case CRLGEN_NEXT_UPDATE_CONTEXT:
            return crlgen_SetTimeField(crlGenData, fieldStr->value, PR_FALSE);
            break;
        case CRLGEN_CHANGE_RANGE_CONTEXT:
            return crlgen_SetNewRangeField(crlGenData, fieldStr->value);
            break;
        default:
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "syntax error (unknow token type: %d)\n",
                              crlGenData->contextId);
            PORT_SetError(SEC_ERROR_INVALID_ARGS);
            return SECFailure;
    }
    return SECSuccess;
}

/* Sets parsed data for CRL field update into temporary structure */
static SECStatus
crlgen_setNextDataFn_field(CRLGENGeneratorData *crlGenData, void *str,
                           void *data, unsigned short dtype)
{
    CRLGENCrlField *fieldStr = (CRLGENCrlField *)str;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (crlGenData->contextId) {
        case CRLGEN_CHANGE_RANGE_CONTEXT:
            if (dtype != CRLGEN_TYPE_DIGIT && dtype != CRLGEN_TYPE_DIGIT_RANGE) {
                crlgen_PrintError(crlGenData->parsedLineNum,
                                  "range value should have "
                                  "numeric or numeric range values.\n");
                return SECFailure;
            }
            break;
        case CRLGEN_NEXT_UPDATE_CONTEXT:
        case CRLGEN_UPDATE_CONTEXT:
            if (dtype != CRLGEN_TYPE_ZDATE) {
                crlgen_PrintError(crlGenData->parsedLineNum,
                                  "bad formated date. Should be "
                                  "YYYYMMDDHHMMSSZ.\n");
                return SECFailure;
            }
            break;
        default:
            PORT_SetError(SEC_ERROR_INVALID_ARGS);
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "syntax error (unknow token type: %d).\n",
                              crlGenData->contextId, data);
            return SECFailure;
    }
    fieldStr->value = PORT_Strdup(data);
    if (!fieldStr->value) {
        return SECFailure;
    }
    return SECSuccess;
}

/* Triggers cert entries update depending on current context */
static SECStatus
crlgen_updateCrlFn_cert(CRLGENGeneratorData *crlGenData, void *str)
{
    CRLGENCertEntry *certStr = (CRLGENCertEntry *)str;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (crlGenData->contextId) {
        case CRLGEN_ADD_CERT_CONTEXT:
            return crlgen_AddCert(crlGenData, certStr->certId,
                                  certStr->revocationTime);
        case CRLGEN_RM_CERT_CONTEXT:
            return crlgen_RmCert(crlGenData, certStr->certId);
        default:
            PORT_SetError(SEC_ERROR_INVALID_ARGS);
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "syntax error (unknow token type: %d).\n",
                              crlGenData->contextId);
            return SECFailure;
    }
}

/* Sets parsed data for CRL entries update into temporary structure */
static SECStatus
crlgen_setNextDataFn_cert(CRLGENGeneratorData *crlGenData, void *str,
                          void *data, unsigned short dtype)
{
    CRLGENCertEntry *certStr = (CRLGENCertEntry *)str;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (dtype) {
        case CRLGEN_TYPE_DIGIT:
        case CRLGEN_TYPE_DIGIT_RANGE:
            certStr->certId = PORT_Strdup(data);
            if (!certStr->certId) {
                return SECFailure;
            }
            break;
        case CRLGEN_TYPE_DATE:
        case CRLGEN_TYPE_ZDATE:
            certStr->revocationTime = PORT_Strdup(data);
            if (!certStr->revocationTime) {
                return SECFailure;
            }
            break;
        default:
            PORT_SetError(SEC_ERROR_INVALID_ARGS);
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "syntax error (unknow token type: %d).\n",
                              crlGenData->contextId);
            return SECFailure;
    }
    return SECSuccess;
}

/* Triggers cert entries/crl extension update */
static SECStatus
crlgen_updateCrlFn_extension(CRLGENGeneratorData *crlGenData, void *str)
{
    CRLGENExtensionEntry *extStr = (CRLGENExtensionEntry *)str;

    return crlgen_AddExtension(crlGenData, (const char **)extStr->extData);
}

/* Defines maximum number of fields extension may have */
#define MAX_EXT_DATA_LENGTH 10

/* Sets parsed extension data for CRL entries/CRL extensions update
 * into temporary structure */
static SECStatus
crlgen_setNextDataFn_extension(CRLGENGeneratorData *crlGenData, void *str,
                               void *data, unsigned short dtype)
{
    CRLGENExtensionEntry *extStr = (CRLGENExtensionEntry *)str;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    if (extStr->extData == NULL) {
        extStr->extData = PORT_ZNewArray(char *, MAX_EXT_DATA_LENGTH);
        if (!extStr->extData) {
            return SECFailure;
        }
    }
    if (extStr->nextUpdatedData >= MAX_EXT_DATA_LENGTH) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        crlgen_PrintError(crlGenData->parsedLineNum,
                          "number of fields in extension "
                          "exceeded maximum allowed data length: %d.\n",
                          MAX_EXT_DATA_LENGTH);
        return SECFailure;
    }
    extStr->extData[extStr->nextUpdatedData] = PORT_Strdup(data);
    if (!extStr->extData[extStr->nextUpdatedData]) {
        return SECFailure;
    }
    extStr->nextUpdatedData += 1;

    return SECSuccess;
}

/****************************************************************************************
 * Top level functions are triggered directly by parser.
 */

/*
 * crl generation script parser recreates a temporary data staructure
 * for each line it is going through. This function cleans temp structure.
 */
void
crlgen_destroyTempData(CRLGENGeneratorData *crlGenData)
{
    if (crlGenData->contextId != CRLGEN_UNKNOWN_CONTEXT) {
        switch (crlGenData->contextId) {
            case CRLGEN_ISSUER_CONTEXT:
            case CRLGEN_UPDATE_CONTEXT:
            case CRLGEN_NEXT_UPDATE_CONTEXT:
            case CRLGEN_CHANGE_RANGE_CONTEXT:
                if (crlGenData->crlField->value)
                    PORT_Free(crlGenData->crlField->value);
                PORT_Free(crlGenData->crlField);
                break;
            case CRLGEN_ADD_CERT_CONTEXT:
            case CRLGEN_RM_CERT_CONTEXT:
                if (crlGenData->certEntry->certId)
                    PORT_Free(crlGenData->certEntry->certId);
                if (crlGenData->certEntry->revocationTime)
                    PORT_Free(crlGenData->certEntry->revocationTime);
                PORT_Free(crlGenData->certEntry);
                break;
            case CRLGEN_ADD_EXTENSION_CONTEXT:
                if (crlGenData->extensionEntry->extData) {
                    int i = 0;
                    for (; i < crlGenData->extensionEntry->nextUpdatedData; i++)
                        PORT_Free(*(crlGenData->extensionEntry->extData + i));
                    PORT_Free(crlGenData->extensionEntry->extData);
                }
                PORT_Free(crlGenData->extensionEntry);
                break;
        }
        crlGenData->contextId = CRLGEN_UNKNOWN_CONTEXT;
    }
}

SECStatus
crlgen_updateCrl(CRLGENGeneratorData *crlGenData)
{
    SECStatus rv = SECSuccess;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (crlGenData->contextId) {
        case CRLGEN_ISSUER_CONTEXT:
        case CRLGEN_UPDATE_CONTEXT:
        case CRLGEN_NEXT_UPDATE_CONTEXT:
        case CRLGEN_CHANGE_RANGE_CONTEXT:
            rv = crlGenData->crlField->updateCrlFn(crlGenData, crlGenData->crlField);
            break;
        case CRLGEN_RM_CERT_CONTEXT:
        case CRLGEN_ADD_CERT_CONTEXT:
            rv = crlGenData->certEntry->updateCrlFn(crlGenData, crlGenData->certEntry);
            break;
        case CRLGEN_ADD_EXTENSION_CONTEXT:
            rv = crlGenData->extensionEntry->updateCrlFn(crlGenData, crlGenData->extensionEntry);
            break;
        case CRLGEN_UNKNOWN_CONTEXT:
            break;
        default:
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "unknown lang context type code: %d.\n",
                              crlGenData->contextId);
            PORT_Assert(0);
            return SECFailure;
    }
    /* Clrean structures after crl update */
    crlgen_destroyTempData(crlGenData);

    crlGenData->parsedLineNum += 1;

    return rv;
}

SECStatus
crlgen_setNextData(CRLGENGeneratorData *crlGenData, void *data,
                   unsigned short dtype)
{
    SECStatus rv = SECSuccess;

    PORT_Assert(crlGenData);
    if (!crlGenData) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (crlGenData->contextId) {
        case CRLGEN_ISSUER_CONTEXT:
        case CRLGEN_UPDATE_CONTEXT:
        case CRLGEN_NEXT_UPDATE_CONTEXT:
        case CRLGEN_CHANGE_RANGE_CONTEXT:
            rv = crlGenData->crlField->setNextDataFn(crlGenData, crlGenData->crlField,
                                                     data, dtype);
            break;
        case CRLGEN_ADD_CERT_CONTEXT:
        case CRLGEN_RM_CERT_CONTEXT:
            rv = crlGenData->certEntry->setNextDataFn(crlGenData, crlGenData->certEntry,
                                                      data, dtype);
            break;
        case CRLGEN_ADD_EXTENSION_CONTEXT:
            rv =
                crlGenData->extensionEntry->setNextDataFn(crlGenData, crlGenData->extensionEntry, data, dtype);
            break;
        case CRLGEN_UNKNOWN_CONTEXT:
            break;
        default:
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "unknown context type: %d.\n",
                              crlGenData->contextId);
            PORT_Assert(0);
            return SECFailure;
    }
    return rv;
}

SECStatus
crlgen_createNewLangStruct(CRLGENGeneratorData *crlGenData,
                           unsigned structType)
{
    PORT_Assert(crlGenData &&
                crlGenData->contextId == CRLGEN_UNKNOWN_CONTEXT);
    if (!crlGenData ||
        crlGenData->contextId != CRLGEN_UNKNOWN_CONTEXT) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return SECFailure;
    }

    switch (structType) {
        case CRLGEN_ISSUER_CONTEXT:
        case CRLGEN_UPDATE_CONTEXT:
        case CRLGEN_NEXT_UPDATE_CONTEXT:
        case CRLGEN_CHANGE_RANGE_CONTEXT:
            crlGenData->crlField = PORT_New(CRLGENCrlField);
            if (!crlGenData->crlField) {
                return SECFailure;
            }
            crlGenData->contextId = structType;
            crlGenData->crlField->value = NULL;
            crlGenData->crlField->updateCrlFn = &crlgen_updateCrlFn_field;
            crlGenData->crlField->setNextDataFn = &crlgen_setNextDataFn_field;
            break;
        case CRLGEN_RM_CERT_CONTEXT:
        case CRLGEN_ADD_CERT_CONTEXT:
            crlGenData->certEntry = PORT_New(CRLGENCertEntry);
            if (!crlGenData->certEntry) {
                return SECFailure;
            }
            crlGenData->contextId = structType;
            crlGenData->certEntry->certId = 0;
            crlGenData->certEntry->revocationTime = NULL;
            crlGenData->certEntry->updateCrlFn = &crlgen_updateCrlFn_cert;
            crlGenData->certEntry->setNextDataFn = &crlgen_setNextDataFn_cert;
            break;
        case CRLGEN_ADD_EXTENSION_CONTEXT:
            crlGenData->extensionEntry = PORT_New(CRLGENExtensionEntry);
            if (!crlGenData->extensionEntry) {
                return SECFailure;
            }
            crlGenData->contextId = structType;
            crlGenData->extensionEntry->extData = NULL;
            crlGenData->extensionEntry->nextUpdatedData = 0;
            crlGenData->extensionEntry->updateCrlFn =
                &crlgen_updateCrlFn_extension;
            crlGenData->extensionEntry->setNextDataFn =
                &crlgen_setNextDataFn_extension;
            break;
        case CRLGEN_UNKNOWN_CONTEXT:
            break;
        default:
            crlgen_PrintError(crlGenData->parsedLineNum,
                              "unknown context type: %d.\n", structType);
            PORT_Assert(0);
            return SECFailure;
    }
    return SECSuccess;
}

/* Parser initialization function */
CRLGENGeneratorData *
CRLGEN_InitCrlGeneration(CERTSignedCrl *signCrl, PRFileDesc *src)
{
    CRLGENGeneratorData *crlGenData = NULL;

    PORT_Assert(signCrl && src);
    if (!signCrl || !src) {
        PORT_SetError(SEC_ERROR_INVALID_ARGS);
        return NULL;
    }

    crlGenData = PORT_ZNew(CRLGENGeneratorData);
    if (!crlGenData) {
        return NULL;
    }

    crlGenData->entryDataHashTable =
        PL_NewHashTable(0, SECITEM_Hash, SECITEM_HashCompare,
                        PL_CompareValues, NULL, NULL);
    if (!crlGenData->entryDataHashTable) {
        PORT_Free(crlGenData);
        return NULL;
    }

    crlGenData->src = src;
    crlGenData->parsedLineNum = 1;
    crlGenData->contextId = CRLGEN_UNKNOWN_CONTEXT;
    crlGenData->signCrl = signCrl;
    crlGenData->rangeFrom = 0;
    crlGenData->rangeTo = 0;
    crlGenData->crlExtHandle = NULL;

    PORT_SetError(0);

    return crlGenData;
}

void
CRLGEN_FinalizeCrlGeneration(CRLGENGeneratorData *crlGenData)
{
    if (!crlGenData)
        return;
    if (crlGenData->src)
        PR_Close(crlGenData->src);
    PL_HashTableDestroy(crlGenData->entryDataHashTable);
    PORT_Free(crlGenData);
}