componentlib.c

ldap服务器源码

	if ( !k->comp_desc )  {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->comp_desc->cd_gser_encoder = (encoder_func*)GEncComponentNull;
	k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentNull;
	k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentNull;
	k->comp_desc->cd_free = (comp_free_func*)FreeComponentNull;
	k->comp_desc->cd_extract_i = NULL;
	k->comp_desc->cd_type = ASN_BASIC;
	k->comp_desc->cd_type_id = BASICTYPE_NULL;
	k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentNull;

	return LDAP_SUCCESS;
}

/*
 * Component BER Decoder : NULL
 */
int
BDecComponentNullTag ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode )
{
	return BDecComponentNull ( mem_op, b, 0, 0, v,bytesDecoded, mode|CALL_TAG_DECODER );
}

int
BDecComponentNull ( void* mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v,
			AsnLen *bytesDecoded, int mode )
{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentNull* k, **k2;
	AsnNull result;

        k = (ComponentNull*) v;
                                                                         
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentNull**) v;
                *k2 = (ComponentNull*) CompAlloc( mem_op, sizeof( ComponentNull ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

	if ( mode & CALL_TAG_DECODER ){
		mode = mode & CALL_CONTENT_DECODER;
		rc = BDecAsnNull ( mem_op, b, &result, bytesDecoded );
	}
	else {
		rc = BDecAsnNullContent ( mem_op, b, tagId, len, &result, bytesDecoded);
	}
	if ( rc < 0 ) {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->value = result;

	k->comp_desc = CompAlloc( mem_op, sizeof( ComponentDesc ) );
	if ( !k->comp_desc )  {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->comp_desc->cd_gser_encoder = (encoder_func*)GEncComponentNull;
	k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentNull;
	k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentNull;
	k->comp_desc->cd_free = (comp_free_func*)FreeComponentNull;
	k->comp_desc->cd_extract_i = NULL;
	k->comp_desc->cd_type = ASN_BASIC;
	k->comp_desc->cd_type_id = BASICTYPE_NULL;
	k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentNull;
	return LDAP_SUCCESS;
}

/*
 * Component BER Decoder : NumericString
 */
int
BDecComponentNumericStringTag ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode ) {
	return BDecComponentNumericString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

int
BDecComponentNumericString ( void* mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode )
{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentNumericString* k, **k2;
	NumericString result;

        k = (ComponentNumericString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentNumericString**) v;
                *k2 = (ComponentNumericString*) CompAlloc( mem_op, sizeof( ComponentNumericString ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

	if ( mode & CALL_TAG_DECODER ){
		mode = mode & CALL_CONTENT_DECODER;
		rc = BDecNumericString ( mem_op, b, &result, bytesDecoded );
	} else {
		rc = BDecNumericStringContent ( mem_op, b, tagId, len, &result, bytesDecoded);
	}
	if ( rc < 0 ) {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->value = result;

        k->comp_desc = CompAlloc( mem_op, sizeof( ComponentDesc ) );
	if ( !k->comp_desc )  {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->comp_desc->cd_gser_encoder = (encoder_func*)GEncComponentNumericString;
        k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentNumericString;
        k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentNumericString;
	k->comp_desc->cd_free = (comp_free_func*)FreeComponentNumericString;
        k->comp_desc->cd_extract_i = NULL;
        k->comp_desc->cd_type = ASN_BASIC;
        k->comp_desc->cd_type_id = BASICTYPE_NUMERIC_STR;
        k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentNumericString;

	return LDAP_SUCCESS;
}


/*
 * Free function : OCTET STRING
 */
void
FreeComponentOcts ( ComponentOcts* v) {
	FreeAsnOcts( &v->value );
}

/*
 * Matching function : OCTET STRING
 */
int
MatchingComponentOcts ( char* oid, ComponentSyntaxInfo* csi_attr,
			ComponentSyntaxInfo* csi_assert )
{
        int rc;
        MatchingRule* mr;
        ComponentOcts *a, *b;
                                                                          
        if( oid ) {
                mr = retrieve_matching_rule(oid, csi_attr->csi_comp_desc->cd_type_id );
                if ( mr )
                        return component_value_match( mr, csi_attr , csi_assert );
        }
        a = (ComponentOcts*) csi_attr;
        b = (ComponentOcts*) csi_assert;
	/* Assume that both of OCTET string has end of string character */
	if ( (a->value.octetLen == b->value.octetLen) &&
		strncmp ( a->value.octs, b->value.octs, a->value.octetLen ) == 0 )
        	return LDAP_COMPARE_TRUE;
	else
		return LDAP_COMPARE_FALSE;
}

/*
 * GSER Encoder : OCTET STRING
 */
int
GEncComponentOcts ( GenBuf* b, ComponentOcts *in )
{
	GAsnOcts t = {0};
	if ( !in || in->value.octetLen <= 0 )
		return (-1);

	t.value = in->value;
	return GEncAsnOctsContent ( b, &t );
}

/*
 * GSER Decoder : OCTET STRING
 */
int
GDecComponentOcts ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode )
{
        char *peek_head, *data;
        int i, j, strLen;
        void* component_values;
        ComponentOcts* k, **k2;
	GAsnOcts result;
                                                                          
        k = (ComponentOcts*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentOcts**) v;
                *k2 = (ComponentOcts*) CompAlloc( mem_op, sizeof( ComponentOcts ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

	if ( GDecAsnOctsContent ( mem_op, b, &result, bytesDecoded ) < 0 ) {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->value = result.value;

	k->comp_desc = CompAlloc( mem_op, sizeof( ComponentDesc ) );
	if ( !k->comp_desc )  {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->comp_desc->cd_gser_encoder = (encoder_func*)GEncComponentOcts;
	k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentOcts;
	k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentOcts;
	k->comp_desc->cd_free = (comp_free_func*)FreeComponentOcts;
	k->comp_desc->cd_extract_i = NULL;
	k->comp_desc->cd_type = ASN_BASIC;
	k->comp_desc->cd_type_id = BASICTYPE_OCTETSTRING;
	k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentOcts;

	return LDAP_SUCCESS;
}

/*
 * Component BER Decoder : OCTET STRING
 */
int
BDecComponentOctsTag ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode ) {
	return BDecComponentOcts ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

int
BDecComponentOcts ( void* mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v,
			AsnLen *bytesDecoded, int mode )
{
        char *peek_head, *data;
        int i, strLen, rc;
        void* component_values;
        ComponentOcts* k, **k2;
	AsnOcts result;
                                                                          
        k = (ComponentOcts*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentOcts**) v;
                *k2 = (ComponentOcts*) CompAlloc( mem_op, sizeof( ComponentOcts ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

	if ( mode & CALL_TAG_DECODER ){
		mode = mode & CALL_CONTENT_DECODER;
		rc = BDecAsnOcts ( mem_op, b, &result, bytesDecoded );
	} else {
		rc = BDecAsnOctsContent ( mem_op, b, tagId, len, &result, bytesDecoded );
	}
	if ( rc < 0 ) {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->value = result;

        k->comp_desc = CompAlloc( mem_op, sizeof( ComponentDesc ) );
	if ( !k->comp_desc )  {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->comp_desc->cd_gser_encoder = (encoder_func*)GEncComponentOcts;
        k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentOcts;
        k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentOcts;
	k->comp_desc->cd_free = (comp_free_func*)FreeComponentOcts;
        k->comp_desc->cd_extract_i = NULL;
        k->comp_desc->cd_type = ASN_BASIC;
        k->comp_desc->cd_type_id = BASICTYPE_OCTETSTRING;
        k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentOcts;
	return LDAP_SUCCESS;
}

/*
 * Matching function : OBJECT IDENTIFIER
 */
int
MatchingComponentOid ( char *oid, ComponentSyntaxInfo *csi_attr ,
			ComponentSyntaxInfo *csi_assert )
{
        int rc;
        MatchingRule* mr;
        ComponentOid *a, *b;
                                                                          
        if( oid ) {
                mr = retrieve_matching_rule(oid, csi_attr->csi_comp_desc->cd_type_id );
                if ( mr )
                        return component_value_match( mr, csi_attr , csi_assert );
        }

        a = (ComponentOid*)csi_attr;
        b = (ComponentOid*)csi_assert;
	if ( a->value.octetLen != b->value.octetLen )
		return LDAP_COMPARE_FALSE;
        rc = ( strncmp( a->value.octs, b->value.octs, a->value.octetLen ) == 0 );
                                                                          
        return rc ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

/*
 * GSER Encoder : OID
 */
GEncComponentOid ( GenBuf *b, ComponentOid *in )
{
	GAsnOid t = {0};

	if ( !in || in->value.octetLen <= 0 )
		return (-1);
	t.value = in->value;
	return GEncAsnOidContent( b, (GAsnOcts*)&t );
}

/*
 * GSER Decoder : OID
 */
int
GDecAsnDescOidContent ( void* mem_op, GenBuf *b, GAsnOid *result, AsnLen *bytesDecoded ){
	AttributeType *ad_type;
	struct berval name;
	char* peek_head;
	int strLen;

	strLen = LocateNextGSERToken ( mem_op, b, &peek_head, GSER_NO_COPY );
	name.bv_val = peek_head;
	name.bv_len = strLen;

	ad_type = at_bvfind( &name );

	if ( !ad_type )
		return LDAP_DECODING_ERROR;

	peek_head = ad_type->sat_atype.at_oid;
	strLen = strlen ( peek_head );

	result->value.octs = (char*)EncodeComponentOid ( mem_op, peek_head , &strLen );
	result->value.octetLen = strLen;
	return LDAP_SUCCESS;
}

int
IsNumericOid ( char* peek_head , int strLen ) {
	int i;
	int num_dot;
	for ( i = 0, num_dot = 0 ; i < strLen ; i++ ) {
		if ( peek_head[i] == '.' ) num_dot++;
		else if ( peek_head[i] > '9' || peek_head[i] < '0' )
			return (-1);
	}
	if ( num_dot )
		return (1);
	else
		return (-1);
}

int
GDecComponentOid ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode )
{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentOid* k, **k2;
	GAsnOid result;
                                                                          
        k = (ComponentOid*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentOid**) v;
                *k2 = (ComponentOid*) CompAlloc( mem_op, sizeof( ComponentOid ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

	strLen = LocateNextGSERToken ( mem_op, b, &peek_head, GSER_PEEK );
	if ( IsNumericOid ( peek_head , strLen ) >= 1 ) {
		/* numeric-oid */
		if ( GDecAsnOidContent ( mem_op, b, &result, bytesDecoded ) < 0 ) {
			if ( k ) CompFree ( mem_op, k );
			return LDAP_DECODING_ERROR;
		}
	}
	else {
		/*descr*/
		if ( GDecAsnDescOidContent ( mem_op, b, &result, bytesDecoded ) < 0 ){
			if ( k ) CompFree ( mem_op, k );
			return LDAP_DECODING_ERROR;
		}
	}
	k->value = result.value;
	k->comp_desc = get_component_description (BASICTYPE_OID);

	return LDAP_SUCCESS;
}

/*
 * Component BER Decoder : OID
 */
int
BDecComponentOidTag ( void* mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode ) {
	return BDecComponentOid ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

int
BDecComponentOid ( void* mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v,
			AsnLen *bytesDecoded, int mode )
{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentOid* k, **k2;
	AsnOid result;
                                                                          
        k = (ComponentOid*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentOid**) v;
                *k2 = (ComponentOid*) CompAlloc( mem_op, sizeof( ComponentOid ) );
		if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
	
	if ( mode & CALL_TAG_DECODER ){
		mode = mode & CALL_CONTENT_DECODER;
		rc = BDecAsnOid ( mem_op, b, &result, bytesDecoded );
	} else {
		rc = BDecAsnOidContent ( mem_op, b, tagId, len, &result, bytesDecoded );
	}
	if ( rc < 0 ) {
		if ( k ) CompFree ( mem_op, k );
		return LDAP_DECODING_ERROR;
	}
	k->value = result;

	k->comp_desc = get_component_description (BASICTYPE_OID);

	return LDAP_SUCCESS;
}