secoid.c

来自「支持SSL v2/v3, TLS, PKCS #5, PKCS #7, PKCS」· C语言 代码 · 共 1,534 行 · 第 1/5 页

static int secoidLastHashEntry = 0;

static SECStatus
secoid_DynamicRehash(void)
{
    DBT key;
    DBT data;
    int rv;
    SECOidData *oid;
    int i;
    int last = secoidLastDynamicEntry;

    if (!oid_d_hash) {
        oid_d_hash = dbopen( 0, O_RDWR | O_CREAT, 0600, DB_HASH, 0 );
    }


    if ( !oid_d_hash ) {
	PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	return(SECFailure);
    }

    for ( i = secoidLastHashEntry; i < last; i++ ) {
	oid = secoidDynamicTable[i];

	/* invalid assert ... guarrenteed not to be true */
	/* PORT_Assert ( oid->offset == i ); */

	key.data = oid->oid.data;
	key.size = oid->oid.len;
	
	data.data = &oid;
	data.size = sizeof(oid);

	rv = (* oid_d_hash->put)( oid_d_hash, &key, &data, R_NOOVERWRITE );
	if ( rv ) {
	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	    return(SECFailure);
	}
    }
    secoidLastHashEntry = last;
    return(SECSuccess);
}

/*
 * Lookup a Dynamic OID. Dynamic OID's still change slowly, so it's
 * cheaper to rehash the table when it changes than it is to do the loop
 * each time. Worry: what about thread safety here? Global Static data with
 * no locks.... (sigh).
 */
static SECStatus
secoid_FindDynamic(DBT *key, DBT *data) {
    if (secoidDynamicTable == NULL) {
	return SECFailure;
    }
    if (secoidLastHashEntry != secoidLastDynamicEntry) {
	SECStatus rv = secoid_DynamicRehash();
	if ( rv != SECSuccess ) {
	    return rv;
	}
    }
    return (SECStatus)(* oid_d_hash->get)( oid_d_hash, key, data, 0 );
	
}

static SECOidData *
secoid_FindDynamicByTag(SECOidTag tagnum)
{
    int tagNumDiff;

    if (secoidDynamicTable == NULL) {
	return NULL;
    }

    if (tagnum < SEC_OID_TOTAL) {
	return NULL;
    }

    tagNumDiff = tagnum - SEC_OID_TOTAL;
    if (tagNumDiff >= secoidLastDynamicEntry) {
	return NULL;
    }

    return(secoidDynamicTable[tagNumDiff]);
}

/*
 * this routine is definately not thread safe. It is only called out
 * of the UI, or at init time. If we want to call it any other time,
 * we need to make it thread safe.
 */
SECStatus
SECOID_AddEntry(SECItem *oid, char *description, unsigned long mech) {
    SECOidData *oiddp = (SECOidData *)PORT_Alloc(sizeof(SECOidData));
    int last = secoidLastDynamicEntry;
    int tableSize = secoidDynamicTableSize;
    int next = last++;
    SECOidData **newTable = secoidDynamicTable;
    SECOidData **oldTable = NULL;

    if (oid == NULL) {
	return SECFailure;
    }

    /* fill in oid structure */
    if (SECITEM_CopyItem(NULL,&oiddp->oid,oid) != SECSuccess) {
	PORT_Free(oiddp);
	return SECFailure;
    }
    oiddp->offset = (SECOidTag)(next + SEC_OID_TOTAL);
    /* may we should just reference the copy passed to us? */
    oiddp->desc = PORT_Strdup(description);
    oiddp->mechanism = mech;


    if (last > tableSize) {
	int oldTableSize = tableSize;
	tableSize += 10;
	oldTable = newTable;
	newTable = (SECOidData **)PORT_ZAlloc(sizeof(SECOidData *)*tableSize);
	if (newTable == NULL) {
	   PORT_Free(oiddp->oid.data);
	   PORT_Free(oiddp);
	   return SECFailure;
	}
	PORT_Memcpy(newTable,oldTable,sizeof(SECOidData *)*oldTableSize);
	PORT_Free(oldTable);
    }

    newTable[next] = oiddp;
    secoidDynamicTable = newTable;
    secoidDynamicTableSize = tableSize;
    secoidLastDynamicEntry= last;
    return SECSuccess;
}
	

/* normal static table processing */
static DB *oidhash     = NULL;
static DB *oidmechhash = NULL;

static SECStatus
InitOIDHash(void)
{
    DBT key;
    DBT data;
    int rv;
    SECOidData *oid;
    int i;
    
    oidhash = dbopen( 0, O_RDWR | O_CREAT, 0600, DB_HASH, 0 );
    oidmechhash = dbopen( 0, O_RDWR | O_CREAT, 0600, DB_HASH, 0 );

    if ( !oidhash || !oidmechhash) {
	PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
 	PORT_Assert(0); /*This function should never fail. */
	return(SECFailure);
    }

    for ( i = 0; i < ( sizeof(oids) / sizeof(SECOidData) ); i++ ) {
	oid = &oids[i];

	PORT_Assert ( oid->offset == i );

	key.data = oid->oid.data;
	key.size = oid->oid.len;
	
	data.data = &oid;
	data.size = sizeof(oid);

	rv = (* oidhash->put)( oidhash, &key, &data, R_NOOVERWRITE );
	if ( rv ) {
	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
            PORT_Assert(0); /*This function should never fail. */
	    return(SECFailure);
	}

	if ( oid->mechanism != CKM_INVALID_MECHANISM ) {
	    key.data = &oid->mechanism;
	    key.size = sizeof(oid->mechanism);

	    rv = (* oidmechhash->put)( oidmechhash, &key, &data, R_NOOVERWRITE);
	    /* Only error out if the error value returned is not
	     * RET_SPECIAL, ie the mechanism already has a registered 
	     * OID.
	     */
	    if ( rv && rv != RET_SPECIAL) {
	        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
                PORT_Assert(0); /* This function should never fail. */
		return(SECFailure);
	    }
	}
    }

    PORT_Assert (i == SEC_OID_TOTAL);

    return(SECSuccess);
}

SECOidData *
SECOID_FindOIDByMechanism(unsigned long mechanism)
{
    DBT key;
    DBT data;
    SECOidData *ret;
    int rv;

    if ( !oidhash ) {
        rv = InitOIDHash();
	if ( rv != SECSuccess ) {
	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	    return NULL;
	}
    }
    key.data = &mechanism;
    key.size = sizeof(mechanism);

    rv = (* oidmechhash->get)( oidmechhash, &key, &data, 0 );
    if ( rv || ( data.size != sizeof(unsigned long) ) ) {
        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	return NULL;
    }
    PORT_Memcpy(&ret, data.data, data.size);

    return (ret);
}

SECOidData *
SECOID_FindOID(SECItem *oid)
{
    DBT key;
    DBT data;
    SECOidData *ret;
    int rv;
    
    if ( !oidhash ) {
	rv = InitOIDHash();
	if ( rv != SECSuccess ) {
	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	    return NULL;
	}
    }
    
    key.data = oid->data;
    key.size = oid->len;
    
    rv = (* oidhash->get)( oidhash, &key, &data, 0 );
    if ( rv || ( data.size != sizeof(SECOidData*) ) ) {
	rv = secoid_FindDynamic(&key, &data);
	if (rv != SECSuccess) {
	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
	    return(0);
	}
    }

    PORT_Memcpy(&ret, data.data, data.size);

    return(ret);
}

SECOidTag
SECOID_FindOIDTag(SECItem *oid)
{
    SECOidData *oiddata;

    oiddata = SECOID_FindOID (oid);
    if (oiddata == NULL)
	return SEC_OID_UNKNOWN;

    return oiddata->offset;
}

SECOidData *
SECOID_FindOIDByTag(SECOidTag tagnum)
{

    if (tagnum >= SEC_OID_TOTAL) {
	return secoid_FindDynamicByTag(tagnum);
    }

    PORT_Assert((unsigned int)tagnum < (sizeof(oids) / sizeof(SECOidData)));
    return(&oids[tagnum]);
}

PRBool SECOID_KnownCertExtenOID (SECItem *extenOid)
{
    SECOidData * oidData;

    oidData = SECOID_FindOID (extenOid);
    if (oidData == (SECOidData *)NULL)
	return (PR_FALSE);
    return ((oidData->supportedExtension == SUPPORTED_CERT_EXTENSION) ?
            PR_TRUE : PR_FALSE);
}


const char *
SECOID_FindOIDTagDescription(SECOidTag tagnum)
{
  SECOidData *oidData = SECOID_FindOIDByTag(tagnum);
  if (!oidData)
    return 0;
  else
    return oidData->desc;
}