Back to index

openldap  2.4.31
Defines | Functions
componentlib.c File Reference
#include "portable.h"
#include <ac/string.h>
#include <ac/socket.h>
#include <ldap_pvt.h>
#include "lutil.h"
#include <ldap.h>
#include "slap.h"
#include "component.h"
#include "componentlib.h"
#include "asn.h"
#include <asn-gser.h>
#include <stdlib.h>

Go to the source code of this file.

Defines

#define SLAPD_COMP_MATCH   SLAPD_MOD_DYNAMIC

Functions

int MatchingComponentBits (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
void FreeComponentBits (ComponentBits *v)
int GEncComponentBits (GenBuf *b, ComponentBits *in)
int GDecComponentBits (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBitsTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBits (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int GEncComponentBMPString (GenBuf *b, ComponentBMPString *in)
int GDecComponentBMPString (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBMPStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBMPString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int GEncComponentUTF8String (GenBuf *b, ComponentUTF8String *in)
int GDecComponentUTF8String (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentUTF8StringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentUTF8String (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int GEncComponentTeletexString (GenBuf *b, ComponentTeletexString *in)
int GDecComponentTeletexString (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentBool (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentBool (GenBuf *b, ComponentBool *in)
int GDecComponentBool (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBoolTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentBool (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentEnum (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentEnum (GenBuf *b, ComponentEnum *in)
int GDecComponentEnum (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentEnumTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentEnum (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int GEncComponentIA5Stirng (GenBuf *b, ComponentIA5String *in)
int BDecComponentIA5StringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentIA5String (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentInt (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentInt (GenBuf *b, ComponentInt *in)
int GDecComponentInt (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentIntTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentInt (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentNull (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentNull (GenBuf *b, ComponentNull *in)
int GDecComponentNull (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentNullTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentNull (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentNumericStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentNumericString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
void FreeComponentOcts (ComponentOcts *v)
int MatchingComponentOcts (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentOcts (GenBuf *b, ComponentOcts *in)
int GDecComponentOcts (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentOctsTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentOcts (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentOid (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
 GEncComponentOid (GenBuf *b, ComponentOid *in)
int GDecAsnDescOidContent (void *mem_op, GenBuf *b, GAsnOid *result, AsnLen *bytesDecoded)
int IsNumericOid (char *peek_head, int strLen)
int GDecComponentOid (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentOidTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentOid (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentPrintableStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentPrintableString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentTeletexStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentTeletexString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentReal (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentReal (GenBuf *b, ComponentReal *in)
int GDecComponentReal (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentRealTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentReal (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int MatchingComponentRelativeOid (char *oid, ComponentSyntaxInfo *csi_attr, ComponentSyntaxInfo *csi_assert)
int GEncComponentRelativeOid (GenBuf *b, ComponentRelativeOid *in)
int GDecComponentRelativeOid (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentRelativeOidTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentRelativeOid (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int GEncComponentUniversalString (GenBuf *b, ComponentUniversalString *in)
static int UTF8toUniversalString (char *octs, int len)
int GDecComponentUniversalString (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentUniversalStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentUniversalString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentVisibleStringTag (void *mem_op, GenBuf *b, void *v, AsnLen *bytesDecoded, int mode)
int BDecComponentVisibleString (void *mem_op, GenBuf *b, AsnTag tagId, AsnLen len, void *v, AsnLen *bytesDecoded, int mode)
int CheckSelectTypeCorrect (void *mem_op, ComponentAnyInfo *cai, struct berval *select)
int SetAnyTypeByComponentOid (ComponentAny *v, ComponentOid *id)
void SetAnyTypeByComponentInt (ComponentAny *v, ComponentInt id)
int GEncComponentAny (GenBuf *b, ComponentAny *in)
int BEncComponentAny (void *mem_op, GenBuf *b, ComponentAny *result, AsnLen *bytesDecoded, int mode)
int BDecComponentAny (void *mem_op, GenBuf *b, ComponentAny *result, AsnLen *bytesDecoded, int mode)
int GDecComponentAny (void *mem_op, GenBuf *b, ComponentAny *result, AsnLen *bytesDecoded, int mode)
int MatchingComponentAny (char *oid, ComponentAny *result, ComponentAny *result2)
voidExtractingComponentAny (void *mem_op, ComponentReference *cr, ComponentAny *result)
void FreeComponentAny (ComponentAny *any)
void InstallAnyByComponentInt (int anyId, ComponentInt intId, unsigned int size, EncodeFcn encode, gser_decoder_func *G_decode, ber_tag_decoder_func *B_decode, ExtractFcn extract, MatchFcn match, FreeFcn free, PrintFcn print)
void InstallOidDecoderMapping (char *ch_oid, EncodeFcn encode, gser_decoder_func *G_decode, ber_tag_decoder_func *B_decode, ExtractFcn extract, MatchFcn match)
OidDecoderMapping * RetrieveOidDecoderMappingbyBV (struct berval *in)
OidDecoderMapping * RetrieveOidDecoderMappingbyOid (char *ch_oid, int oid_len)
OidDecoderMapping * RetrieveOidDecoderMappingbyDesc (char *desc, int desc_len)
void InstallAnyByComponentOid (int anyId, AsnOid *oid, unsigned int size, EncodeFcn encode, gser_decoder_func *G_decode, ber_tag_decoder_func *B_decode, ExtractFcn extract, MatchFcn match, FreeFcn free, PrintFcn print)
int BDecComponentTop (ber_decoder_func *decoder _AND_ void *mem_op _AND_ GenBuf *b _AND_ AsnTag tag _AND_ AsnLen elmtLen _AND_ void **v _AND_ AsnLen *bytesDecoded _AND_ int mode)
 increment_bv_mem_by_size (struct berval *in, int size)
int ConvertBER2Desc (char *in, int size, struct berval *out, int *pos)
int ConvertComponentAttributeTypeAndValue2RFC2253 (irAttributeTypeAndValue *in, struct berval *out, int *pos)
int ConvertRelativeDistinguishedName2RFC2253 (irRelativeDistinguishedName *in, struct berval *out, int *pos)
int ConvertRDN2RFC2253 (irRelativeDistinguishedName *in, struct berval *out)
int ConvertRDNSequence2RFC2253 (irRDNSequence *in, struct berval *out)

Define Documentation

#define SLAPD_COMP_MATCH   SLAPD_MOD_DYNAMIC

Definition at line 29 of file componentlib.c.


Function Documentation

int BDecComponentAny ( void mem_op,
GenBuf *  b,
ComponentAny result,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1864 of file componentlib.c.

                                                                                                  {
       int rc;
        ComponentAny *k, **k2;
                                                                          
        k = (ComponentAny*) result;

       if ( !k ) return (-1);
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentAny**) result;
                *k2 = (ComponentAny*) CompAlloc( mem_op, sizeof( ComponentAny ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ((result->cai != NULL) && (result->cai->BER_Decode != NULL)) {
              result->cai->BER_Decode ( mem_op, b, (ComponentSyntaxInfo*)&result->value, (int*)bytesDecoded, DEC_ALLOC_MODE_0 );

              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*)GEncComponentAny;
              k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentAny;
              k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentAny;
              k->comp_desc->cd_free = (comp_free_func*)FreeComponentAny;
              k->comp_desc->cd_extract_i = NULL;
              k->comp_desc->cd_type = ASN_BASIC;
              k->comp_desc->cd_type_id = BASICTYPE_ANY;
              k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentAny;
              return LDAP_SUCCESS;
       }
       else {
              Asn1Error ("ERROR - Component ANY Decode routine is NULL\n");
              return 0;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentBits ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 119 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentBits* k, **k2;
       AsnBits result;
                                                                          
        k = (ComponentBits*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBits**) v;
                *k2 = (ComponentBits*) CompAlloc( mem_op, sizeof( ComponentBits ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
        
       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnBits ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnBitsContent ( 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_BITSTRING);
 
       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentBitsTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 114 of file componentlib.c.

                                                                                          {
       return BDecComponentBits ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentBMPString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 213 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentBMPString* k, **k2;
       BMPString result;
                                                                          
        k = (ComponentBMPString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBMPString**) v;
                *k2 = (ComponentBMPString*) CompAlloc( mem_op, sizeof( ComponentBMPString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecBMPString ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecBMPStringContent ( 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_BMP_STR);
 
       return LDAP_SUCCESS;

}

Here is the caller graph for this function:

int BDecComponentBMPStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 208 of file componentlib.c.

                                                                                               {
       return BDecComponentBMPString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentBool ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 466 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        ComponentBool* k, **k2;
       AsnBool result;
                                                                          
        k = (ComponentBool*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBool**) v;
                *k2 = (ComponentBool*) CompAlloc( mem_op, sizeof( ComponentBool ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnBool ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnBoolContent( 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_BOOLEAN);

        return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentBoolTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 461 of file componentlib.c.

                                                                                          {
       return BDecComponentBool ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentEnum ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 592 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentEnum* k, **k2;
       AsnEnum result;
                                                                          
        k = (ComponentEnum*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentEnum**) v;
                *k2 = (ComponentEnum*) CompAlloc( mem_op, sizeof( ComponentEnum ) );
              if ( k ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnEnum ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnEnumContent ( 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*)GEncComponentEnum;
        k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentEnum;
        k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentEnum;
       k->comp_desc->cd_free = (comp_free_func*)NULL;
        k->comp_desc->cd_extract_i = NULL;
        k->comp_desc->cd_type = ASN_BASIC;
        k->comp_desc->cd_type_id = BASICTYPE_ENUMERATED;
        k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentEnum;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentEnumTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 587 of file componentlib.c.

                                                                                          {
       return BDecComponentEnum ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentIA5String ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 661 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentIA5String* k, **k2;
       IA5String result;
                                                                          
        k = (ComponentIA5String*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentIA5String**) v;
                *k2 = (ComponentIA5String*) CompAlloc( mem_op, sizeof( ComponentIA5String ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecIA5String ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecIA5StringContent ( 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*)GEncComponentIA5String;
        k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentIA5String;
        k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentIA5String;
       k->comp_desc->cd_free = (comp_free_func*)FreeComponentIA5String;
        k->comp_desc->cd_extract_i = NULL;
        k->comp_desc->cd_type = ASN_BASIC;
        k->comp_desc->cd_type_id = BASICTYPE_IA5_STR;
        k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentIA5String;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentIA5StringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 656 of file componentlib.c.

                                                                                               {
       return BDecComponentIA5String ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentInt ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 787 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentInt* k, **k2;
       AsnInt result;
                                                                          
        k = (ComponentInt*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentInt**) v;
                *k2 = (ComponentInt*) CompAlloc( mem_op, sizeof( ComponentInt ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnInt ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnIntContent ( mem_op, b, tagId, len, &result, bytesDecoded );
       }
       k->value = result;

       k->comp_desc = get_component_description (BASICTYPE_INTEGER );
        
        return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentIntTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 782 of file componentlib.c.

                                                                                         {
       return BDecComponentInt ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentNull ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 907 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentNullTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 901 of file componentlib.c.

{
       return BDecComponentNull ( mem_op, b, 0, 0, v,bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentNumericString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 963 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentNumericStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 958 of file componentlib.c.

                                                                                                   {
       return BDecComponentNumericString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentOcts ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1111 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentOctsTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1106 of file componentlib.c.

                                                                                          {
       return BDecComponentOcts ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentOid ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1286 of file componentlib.c.

{
        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;
}

Here is the caller graph for this function:

int BDecComponentOidTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1281 of file componentlib.c.

                                                                                         {
       return BDecComponentOid ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentPrintableString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1332 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentPrintableString* k, **k2;
       AsnOid result;
                                                                          
        k = (ComponentPrintableString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentPrintableString**) v;
                *k2 = (ComponentPrintableString*) CompAlloc( mem_op, sizeof( ComponentPrintableString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ) {
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecPrintableString ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecPrintableStringContent ( 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_PRINTABLE_STR);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentPrintableStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1326 of file componentlib.c.

{
       return BDecComponentPrintableString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentReal ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1488 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentReal* k, **k2;
       AsnReal result;
                                                                          
        k = (ComponentReal*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentReal**) v;
                *k2 = (ComponentReal*) CompAlloc( mem_op, sizeof( ComponentReal ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnReal ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnRealContent ( 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_REAL);

        return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentRealTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1483 of file componentlib.c.

                                                                                          {
       return BDecComponentReal ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentRelativeOid ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1602 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentRelativeOid* k, **k2;
       AsnRelativeOid result;
                                                                          
        k = (ComponentRelativeOid*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentRelativeOid**) v;
                *k2 = (ComponentRelativeOid*) CompAlloc( mem_op, sizeof( ComponentRelativeOid ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecAsnRelativeOid ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecAsnRelativeOidContent ( 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;
}

Here is the caller graph for this function:

int BDecComponentRelativeOidTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1597 of file componentlib.c.

                                                                                                 {
       return BDecComponentRelativeOid ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentTeletexString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1377 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentTeletexString* k, **k2;
       AsnOid result;
                                                                          
        k = (ComponentTeletexString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentTeletexString**) v;
                *k2 = (ComponentTeletexString*) CompAlloc( mem_op, sizeof( ComponentTeletexString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( mode & CALL_TAG_DECODER ) {
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecTeletexString ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecTeletexStringContent ( 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_T61_STR);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentTeletexStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1371 of file componentlib.c.

{
       return BDecComponentTeletexString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int BDecComponentTop ( ber_decoder_func *decoder _AND_ void *mem_op _AND_ GenBuf *b _AND_ AsnTag tag _AND_ AsnLen elmtLen _AND_ void **v _AND_ AsnLen *bytesDecoded _AND_ int  mode)

Definition at line 2164 of file componentlib.c.

          {
       tag = BDecTag ( b, bytesDecoded );
       elmtLen = BDecLen ( b, bytesDecoded );
       if ( elmtLen <= 0 ) return (-1);
       if ( tag != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE) ) {
              return (-1);
       }
              
       return (*decoder)( mem_op, b, tag, elmtLen, (ComponentSyntaxInfo*)v,(int*)bytesDecoded, mode );
}

Here is the caller graph for this function:

int BDecComponentUniversalString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1674 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentUniversalString* k, **k2;
       UniversalString result;

        k = (ComponentUniversalString*) v;

        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentUniversalString**) v;
                *k2 = (ComponentUniversalString*) CompAlloc( mem_op, sizeof( ComponentUniversalString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecUniversalString ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecUniversalStringContent ( 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_UNIVERSAL_STR);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentUniversalStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1669 of file componentlib.c.

                                                                                                     {
       return BDecComponentUniversalString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentUTF8String ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 306 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentUTF8String* k, **k2;
       UTF8String result;
                                                                          
        k = (ComponentUTF8String*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentUTF8String**) v;
                *k2 = (ComponentUTF8String*) CompAlloc( mem_op, sizeof( ComponentUTF8String ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecUTF8String ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecUTF8StringContent ( 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_UTF8_STR);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentUTF8StringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 301 of file componentlib.c.

                                                                                                {
       return BDecComponentUTF8String ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BDecComponentVisibleString ( void mem_op,
GenBuf *  b,
AsnTag  tagId,
AsnLen  len,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1716 of file componentlib.c.

{
        char* peek_head;
        int i, strLen, rc;
        void* component_values;
        ComponentVisibleString* k, **k2;
       VisibleString result;
                                                                          
        k = (ComponentVisibleString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentVisibleString**) v;
                *k2 = (ComponentVisibleString*) CompAlloc( mem_op, sizeof( ComponentVisibleString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ( mode & CALL_TAG_DECODER ){
              mode = mode & CALL_CONTENT_DECODER;
              rc = BDecVisibleString ( mem_op, b, &result, bytesDecoded );
       } else {
              rc = BDecVisibleStringContent ( mem_op, b, tagId, len, &result, bytesDecoded );
       }
       k->value = result;
       k->comp_desc = get_component_description (BASICTYPE_VISIBLE_STR);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int BDecComponentVisibleStringTag ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1711 of file componentlib.c.

                                                                                                   {
       return BDecComponentVisibleString ( mem_op, b, 0, 0, v, bytesDecoded, mode|CALL_TAG_DECODER );
}

Here is the call graph for this function:

int BEncComponentAny ( void mem_op,
GenBuf *  b,
ComponentAny result,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1822 of file componentlib.c.

{
        ComponentAny *k, **k2;
                                                                          
        k = (ComponentAny*) result;

       if ( !k ) return (-1);
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentAny**) result;
                *k2 = (ComponentAny*) CompAlloc( mem_op, sizeof( ComponentAny ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ((result->cai != NULL) && (result->cai->BER_Decode != NULL)) {
              result->value = (void*) CompAlloc ( mem_op, result->cai->size );
              if ( !result->value ) return 0;
              result->cai->BER_Decode ( mem_op, b, result->value, (int*)bytesDecoded, DEC_ALLOC_MODE_1);

              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*)GEncComponentAny;
              k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentAny;
              k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentAny;
              k->comp_desc->cd_free = (comp_free_func*)FreeComponentAny;
              k->comp_desc->cd_extract_i = NULL;
              k->comp_desc->cd_type = ASN_BASIC;
              k->comp_desc->cd_type_id = BASICTYPE_ANY;
              k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentAny;
              return LDAP_SUCCESS;
       }
       else {
              Asn1Error ("ERROR - Component ANY Decode routine is NULL\n");
              return 0;
       }
}

Here is the call graph for this function:

int CheckSelectTypeCorrect ( void mem_op,
ComponentAnyInfo cai,
struct berval select 
)

Definition at line 1751 of file componentlib.c.

                                                                                      {
       int strLen;
       AttributeType* ad_type;
       char* oid;
       char* result;

       if ( IsNumericOid ( select->bv_val , select->bv_len ) ) {
              oid = select->bv_val;
              strLen = select->bv_len;
       } else {
              ad_type = at_bvfind( select );

              if ( !ad_type )
                     return LDAP_DECODING_ERROR;

              oid = ad_type->sat_atype.at_oid;
              strLen = strlen ( oid );
       }
       result = EncodeComponentOid ( mem_op, oid , &strLen );
       if ( !result || strLen <= 0 ) return (-1);

       if ( cai->oid.octetLen == strLen &&
              strncmp ( cai->oid.octs, result, strLen ) == 0 )
              return (1);
       else
              return (-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ConvertBER2Desc ( char *  in,
int  size,
struct berval out,
int pos 
)

Definition at line 2214 of file componentlib.c.

                                                                    {
       int desc_size;
       char* desc_ptr;
       unsigned int firstArcNum;
       unsigned int arcNum;
       int i, rc, start_pos = *pos;
       char buf[MAX_OID_LEN];
       AttributeType *at;
       struct berval bv_name;

       /*convert BER oid to desc*/
       for ( i = 0, arcNum = 0; (i < size) && (in[i] & 0x80 ); i++ )
              arcNum = (arcNum << 7) + (in[i] & 0x7f);
       arcNum = (arcNum << 7) + (in[i] & 0x7f);
       i++;
       firstArcNum = (unsigned short)(arcNum/40);
       if ( firstArcNum > 2 )
              firstArcNum = 2;
       
       arcNum = arcNum - (firstArcNum * 40 );

       rc = intToAscii ( arcNum, buf );

       /*check if the buffer can store the first/second arc and two dots*/
       if ( out->bv_len < *pos + 2 + 1 + rc )
              increment_bv_mem_by_size ( out, INCREMENT_SIZE );

       if ( firstArcNum == 1)
              out->bv_val[*pos] = '1';
       else
              out->bv_val[*pos] = '2';
       (*pos)++;
       out->bv_val[*pos] = '.';
       (*pos)++;

       memcpy( out->bv_val + *pos, buf, rc );
       *pos += rc;
       out->bv_val[*pos] = '.';
       (*pos)++;

       for ( ; i < size ; ) {
              for ( arcNum=0; (i < size) && (in[i] & 0x80) ; i++ )
                     arcNum = (arcNum << 7) + (in[i] & 0x7f);
              arcNum = (arcNum << 7) + (in[i] & 0x7f);
              i++;

              rc = intToAscii ( arcNum, buf );

              if ( out->bv_len < *pos + rc + 1 )
                     increment_bv_mem_by_size ( out, INCREMENT_SIZE );

              memcpy( out->bv_val + *pos, buf, rc );
              *pos += rc;
              out->bv_val[*pos] = '.';
              (*pos)++;
       }
       (*pos)--;/*remove the last '.'*/

       /*
        * lookup OID database to locate desc
        * then overwrite OID with desc in *out
        * If failed to look up desc, OID form is used
        */
       bv_name.bv_val = out->bv_val + start_pos;
       bv_name.bv_len = *pos - start_pos;
       at = at_bvfind( &bv_name );
       if ( !at )
              return LDAP_SUCCESS;
       desc_size = at->sat_cname.bv_len;
       memcpy( out->bv_val + start_pos, at->sat_cname.bv_val, desc_size );
       *pos = start_pos + desc_size;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2289 of file componentlib.c.

                                                                                                            {
       int rc;
       int value_size = ((ComponentUTF8String*)in->value.value)->value.octetLen;
       char* value_ptr =  ((ComponentUTF8String*)in->value.value)->value.octs;

       rc = ConvertBER2Desc( in->type.value.octs, in->type.value.octetLen, out, pos );
       if ( rc != LDAP_SUCCESS ) return rc;
       if ( out->bv_len < *pos + 1/*for '='*/  )
              increment_bv_mem_by_size ( out, INCREMENT_SIZE );
       /*Between type and value, put '='*/
       out->bv_val[*pos] = '=';
       (*pos)++;

       /*Assume it is string*/            
       if ( out->bv_len < *pos + value_size )
              increment_bv_mem_by_size ( out, INCREMENT_SIZE );
       memcpy( out->bv_val + *pos, value_ptr, value_size );
       out->bv_len += value_size;
       *pos += value_size;
       
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2333 of file componentlib.c.

                                                                           {
       int rc, pos = 0;
       out->bv_val = (char*)malloc( INITIAL_DN_SIZE );
       out->bv_len = INITIAL_DN_SIZE;

       rc = ConvertRelativeDistinguishedName2RFC2253 ( in, out , &pos);
       if ( rc != LDAP_SUCCESS ) return rc;
       out->bv_val[pos] = '\0';
       out->bv_len = pos;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ConvertRDNSequence2RFC2253 ( irRDNSequence in,
struct berval out 
)

Definition at line 2346 of file componentlib.c.

                                                                    {
       irRelativeDistinguishedName* rdn_seq;
       AsnList* seq = &in->comp_list;
       int pos = 0, rc ;

       out->bv_val = (char*)malloc( INITIAL_DN_SIZE );
       out->bv_len = INITIAL_DN_SIZE;

       FOR_EACH_LIST_ELMT( rdn_seq, seq )
       {
              rc = ConvertRelativeDistinguishedName2RFC2253( rdn_seq, out, &pos );
              if ( rc != LDAP_SUCCESS ) return LDAP_INVALID_SYNTAX;

              if ( out->bv_len < pos + 1/*for ','*/ )
                     increment_bv_mem_by_size ( out, INCREMENT_SIZE );
              /*Between RDN, put comma*/
              out->bv_val[pos++] = ',';
       }
       pos--;/*remove the last '+'*/
       out->bv_val[pos] = '\0';
       out->bv_len =pos;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2313 of file componentlib.c.

                                                                                                           {
       irAttributeTypeAndValue* attr_typeNvalue;
       int rc;


       FOR_EACH_LIST_ELMT( attr_typeNvalue, &in->comp_list)
       {
              rc = ConvertComponentAttributeTypeAndValue2RFC2253( attr_typeNvalue, out, pos );
              if ( rc != LDAP_SUCCESS ) return LDAP_INVALID_SYNTAX;

              if ( out->bv_len < *pos + 1/*for '+'*/  )
                     increment_bv_mem_by_size ( out, INCREMENT_SIZE );
              /*between multivalued RDNs, put comma*/
              out->bv_val[(*pos)++] = '+';
       }
       (*pos)--;/*remove the last '+'*/
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* ExtractingComponentAny ( void mem_op,
ComponentReference *  cr,
ComponentAny result 
)

Definition at line 1969 of file componentlib.c.

                                                                                       {
       if ((result->cai != NULL) && (result->cai->Extract != NULL)) {
              return (void*) result->cai->Extract( mem_op, cr , result->value );
       }
       else {
              Asn1Error ("ERROR - ANY Extracting routine is NULL\n");
              return (void*)NULL;
       }
}

Definition at line 1980 of file componentlib.c.

                                     {
       if ( any->cai != NULL && any->cai->Free != NULL ) {
              any->cai->Free( any->value );
              free ( ((ComponentSyntaxInfo*)any->value)->csi_comp_desc );
              free ( any->value );
       }
       else
              Asn1Error ("ERROR - ANY Free routine is NULL\n");
}

Here is the caller graph for this function:

Definition at line 60 of file componentlib.c.

                                       {
       FreeAsnBits( &v->value );
}

Definition at line 1014 of file componentlib.c.

                                      {
       FreeAsnOcts( &v->value );
}

Here is the caller graph for this function:

int GDecAsnDescOidContent ( void mem_op,
GenBuf *  b,
GAsnOid *  result,
AsnLen *  bytesDecoded 
)

Definition at line 1200 of file componentlib.c.

                                                                                        {
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentAny ( void mem_op,
GenBuf *  b,
ComponentAny result,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1904 of file componentlib.c.

                                                                                                  {
        ComponentAny *k, **k2;
                                                                          
        k = (ComponentAny*) result;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentAny**) result;
                *k2 = (ComponentAny*) CompAlloc( mem_op, sizeof( ComponentAny ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       if ((result->cai != NULL) && (result->cai->GSER_Decode != NULL)) {
              result->value = (void*) CompAlloc ( mem_op, result->cai->size );
              if ( !result->value ) return 0;
              result->cai->GSER_Decode ( mem_op, b, result->value, (int*)bytesDecoded, DEC_ALLOC_MODE_1);
              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*)GEncComponentAny;
              k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentAny;
              k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentAny;
              k->comp_desc->cd_free = (comp_free_func*)FreeComponentAny;
              k->comp_desc->cd_type = ASN_BASIC;
              k->comp_desc->cd_extract_i = NULL;
              k->comp_desc->cd_type_id = BASICTYPE_ANY;
              k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentAny;
              return LDAP_SUCCESS;
       }
       else {
              Asn1Error ("ERROR - ANY Decode routine is NULL\n");
              return 0;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentBits ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 83 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentBits* k, **k2;
       GAsnBits result;

        k = (ComponentBits*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBits**) v;
                *k2 = (ComponentBits*) CompAlloc( mem_op, sizeof( ComponentBits ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
        
       if ( GDecAsnBitsContent ( 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_BITSTRING);

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int GDecComponentBMPString ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 173 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentBMPString* k, **k2;
       GBMPString result;
                                                                          
        k = (ComponentBMPString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBMPString**) v;
                *k2 = (ComponentBMPString*) CompAlloc( mem_op, sizeof( ComponentBMPString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

        *bytesDecoded = 0;

       if ( GDecBMPStringContent ( 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_BMP_STR);
 
       return LDAP_SUCCESS;

}

Here is the caller graph for this function:

int GDecComponentBool ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 430 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        ComponentBool* k, **k2;
       GAsnBool result;
                                                                          
        k = (ComponentBool*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentBool**) v;
                *k2 = (ComponentBool*) CompAlloc( mem_op, sizeof( ComponentBool ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( GDecAsnBoolContent( 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_BOOLEAN);
 
        return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int GDecComponentEnum ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 541 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentEnum* k, **k2;
       GAsnEnum result;
                                                                          
        k = (ComponentEnum*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentEnum**) v;
                *k2 = (ComponentEnum*) CompAlloc( mem_op, sizeof( ComponentEnum ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( GDecAsnEnumContent ( mem_op, b, &result, bytesDecoded ) < 0 ) {
              if ( k ) CompFree ( mem_op, k );
              return LDAP_DECODING_ERROR;
       }

       k->value_identifier.bv_val = result.value_identifier;
       k->value_identifier.bv_len = result.len;

       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*)GEncComponentEnum;
       k->comp_desc->cd_gser_decoder = (gser_decoder_func*)GDecComponentEnum;
       k->comp_desc->cd_ber_decoder = (ber_decoder_func*)BDecComponentEnum;
       k->comp_desc->cd_free = (comp_free_func*)NULL;
       k->comp_desc->cd_extract_i = NULL;
       k->comp_desc->cd_type = ASN_BASIC;
       k->comp_desc->cd_type_id = BASICTYPE_ENUMERATED;
       k->comp_desc->cd_all_match = (allcomponent_matching_func*)MatchingComponentEnum;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentInt ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 751 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentInt* k, **k2;
       GAsnInt result;
                                                                          
        k = (ComponentInt*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentInt**) v;
                *k2 = (ComponentInt*) CompAlloc( mem_op, sizeof( ComponentInt ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( GDecAsnIntContent ( 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_INTEGER );

        return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int GDecComponentNull ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 857 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentNull* k, **k2;
       GAsnNull 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 ( GDecAsnNullContent ( 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*)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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentOcts ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1062 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentOid ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1239 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentReal ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1452 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentReal* k, **k2;
       GAsnReal result;
                                                                          
        k = (ComponentReal*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentReal**) v;
                *k2 = (ComponentReal*) CompAlloc( mem_op, sizeof( ComponentReal ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

       if ( GDecAsnRealContent ( 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_REAL);

        return LDAP_SUCCESS;
}
int GDecComponentRelativeOid ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1566 of file componentlib.c.

{
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentRelativeOid* k, **k2;
       GAsnRelativeOid result;
                                                                          
        k = (ComponentRelativeOid*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentRelativeOid**) v;
                *k2 = (ComponentRelativeOid*) CompAlloc( mem_op, sizeof( ComponentRelativeOid ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }
       
       if ( GDecAsnRelativeOidContent ( 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;
}
int GDecComponentTeletexString ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 359 of file componentlib.c.

                                                                   {
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentTeletexString* k, **k2;
       GTeletexString result;
                                                                          
        k = (ComponentTeletexString*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentTeletexString**) v;
                *k2 = (ComponentTeletexString*)CompAlloc( mem_op, sizeof( ComponentTeletexString ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

        *bytesDecoded = 0;

       if ( GDecTeletexStringContent ( 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_VIDEOTEX_STR);
 
       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int GDecComponentUniversalString ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 1658 of file componentlib.c.

{
       if ( GDecComponentUTF8String ( mem_op, b, v, bytesDecoded, mode) < 0 )
       UTF8toUniversalString( ((ComponentUniversalString*)v)->value.octs, ((ComponentUniversalString*)v)->value.octetLen );
              return LDAP_DECODING_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int GDecComponentUTF8String ( void mem_op,
GenBuf *  b,
void v,
AsnLen *  bytesDecoded,
int  mode 
)

Definition at line 267 of file componentlib.c.

                                                            {
        char* peek_head;
        int i, strLen;
        void* component_values;
        ComponentUTF8String* k, **k2;
       GUTF8String result;
                                                                          
        k = (ComponentUTF8String*) v;
                                                                          
        if ( mode & DEC_ALLOC_MODE_0 ) {
                k2 = (ComponentUTF8String**) v;
                *k2 = (ComponentUTF8String*)CompAlloc( mem_op, sizeof( ComponentUTF8String ) );
              if ( !*k2 ) return LDAP_DECODING_ERROR;
                k = *k2;
        }

        *bytesDecoded = 0;

       if ( GDecUTF8StringContent ( 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_UTF8_STR);
 
       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int GEncComponentAny ( GenBuf *  b,
ComponentAny in 
)

Definition at line 1813 of file componentlib.c.

{
       if ( in->cai != NULL  && in->cai->Encode != NULL )
              return in->cai->Encode(b, &in->value );
       else
              return (-1);
}

Here is the caller graph for this function:

int GEncComponentBits ( GenBuf *  b,
ComponentBits in 
)

Definition at line 68 of file componentlib.c.

{
       GAsnBits bits = {0};

       bits.value = in->value;
       if ( !in )
              return (-1);
       return GEncAsnBitsContent ( b, &bits);
}
int GEncComponentBMPString ( GenBuf *  b,
ComponentBMPString in 
)

Definition at line 159 of file componentlib.c.

{
       GBMPString t = {0};

       if ( !in || in->value.octetLen <= 0 )
              return (-1);
       t.value = in->value;
       return GEncBMPStringContent ( b, &t );
}
int GEncComponentBool ( GenBuf *  b,
ComponentBool in 
)

Definition at line 416 of file componentlib.c.

{
       GAsnBool t = {0};

       if ( !in )
              return (-1);
       t.value = in->value;
       return GEncAsnBoolContent ( b, &t );
}
int GEncComponentEnum ( GenBuf *  b,
ComponentEnum in 
)

Definition at line 527 of file componentlib.c.

{
       GAsnEnum t = {0};

       if ( !in )
              return (-1);
       t.value = in->value;
       return GEncAsnEnumContent ( b, &t );
}

Here is the caller graph for this function:

int GEncComponentIA5Stirng ( GenBuf *  b,
ComponentIA5String in 
)

Definition at line 644 of file componentlib.c.

{
       GIA5String t = {0};
       t.value = in->value;
       if ( !in || in->value.octetLen <= 0 ) return (-1);
       return GEncIA5StringContent( b, &t );
}
int GEncComponentInt ( GenBuf *  b,
ComponentInt in 
)

Definition at line 737 of file componentlib.c.

{
       GAsnInt t = {0};

       if ( !in )
              return (-1);
       t.value = in->value;
       return GEncAsnIntContent ( b, &t );
}
int GEncComponentNull ( GenBuf *  b,
ComponentNull in 
)

Definition at line 843 of file componentlib.c.

{
       GAsnNull t = {0};

       if ( !in )
              return (-1);
       t.value = in->value;
       return GEncAsnNullContent ( b, &t );
}

Here is the caller graph for this function:

int GEncComponentOcts ( GenBuf *  b,
ComponentOcts in 
)

Definition at line 1048 of file componentlib.c.

{
       GAsnOcts t = {0};
       if ( !in || in->value.octetLen <= 0 )
              return (-1);

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

Here is the caller graph for this function:

GEncComponentOid ( GenBuf *  b,
ComponentOid in 
)

Definition at line 1186 of file componentlib.c.

{
       GAsnOid t = {0};

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

Definition at line 1439 of file componentlib.c.

{
       GAsnReal t = {0};
       if ( !in )
              return (-1);
       t.value = in->value;
       return GEncAsnRealContent ( b, &t );
}

Definition at line 1552 of file componentlib.c.

{
       GAsnRelativeOid t = {0};

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

Definition at line 345 of file componentlib.c.

{
       GTeletexString t = {0};

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

Definition at line 1639 of file componentlib.c.

{
       GUniversalString t = {0};
       if ( !in || in->value.octetLen <= 0 )
              return (-1);
       t.value = in->value;
       return GEncUniversalStringContent( b, &t );
}
int GEncComponentUTF8String ( GenBuf *  b,
ComponentUTF8String in 
)

Definition at line 254 of file componentlib.c.

{
       GUTF8String t = {0};
       if ( !in || in->value.octetLen <= 0 )
              return (-1);
       t.value = in->value;
       return GEncUTF8StringContent ( b, &t );
}
increment_bv_mem_by_size ( struct berval in,
int  size 
)

Definition at line 2207 of file componentlib.c.

                                                         {
       int new_size = in->bv_len + size;
       in->bv_val = realloc( in->bv_val, new_size );
       in->bv_len = new_size;
}

Here is the caller graph for this function:

void InstallAnyByComponentInt ( int  anyId,
ComponentInt  intId,
unsigned int  size,
EncodeFcn  encode,
gser_decoder_func *  G_decode,
ber_tag_decoder_func *  B_decode,
ExtractFcn  extract,
MatchFcn  match,
FreeFcn  free,
PrintFcn  print 
)

Definition at line 1991 of file componentlib.c.

{
       ComponentAnyInfo *a;
       Hash h;

       a = (ComponentAnyInfo*) malloc(sizeof (ComponentAnyInfo));
       a->anyId = anyId;
       a->oid.octs = NULL;
       a->oid.octetLen = 0;
       a->intId = intId;
       a->size = size;
       a->Encode = encode;
       a->GSER_Decode = G_decode;
       a->BER_Decode = B_decode;
       a->Match = match;
       a->Extract = extract;
       a->Free = free;
       a->Print = print;

       if (anyIntHashTblG == NULL)
              anyIntHashTblG = InitHash();

       h = MakeHash ((char*)&intId, sizeof (intId));

       if(anyIntHashTblG != NULL)
              Insert(anyIntHashTblG, a, h);
}
void InstallAnyByComponentOid ( int  anyId,
AsnOid *  oid,
unsigned int  size,
EncodeFcn  encode,
gser_decoder_func *  G_decode,
ber_tag_decoder_func *  B_decode,
ExtractFcn  extract,
MatchFcn  match,
FreeFcn  free,
PrintFcn  print 
)

Definition at line 2130 of file componentlib.c.

{
       ComponentAnyInfo *a;
       Hash h;

       a = (ComponentAnyInfo*) malloc (sizeof (ComponentAnyInfo));
       a->anyId = anyId;
       if ( oid ) {
              a->oid.octs = malloc( oid->octetLen );
              memcpy ( a->oid.octs, oid->octs, oid->octetLen );
              a->oid.octetLen = oid->octetLen;
       }
       a->size = size;
       a->Encode = encode;
       a->GSER_Decode = G_decode;
       a->BER_Decode = B_decode;
       a->Match = match;
       a->Extract = extract;
       a->Free = free;
       a->Print = print;

       h = MakeHash (oid->octs, oid->octetLen);

       if (anyOidHashTblG == NULL)
              anyOidHashTblG = InitHash();

       if(anyOidHashTblG != NULL)
              Insert(anyOidHashTblG, a, h);
}

Here is the caller graph for this function:

void InstallOidDecoderMapping ( char *  ch_oid,
EncodeFcn  encode,
gser_decoder_func *  G_decode,
ber_tag_decoder_func *  B_decode,
ExtractFcn  extract,
MatchFcn  match 
)

Definition at line 2031 of file componentlib.c.

                                                                                                                                                             {
       AsnOid oid;
       int strLen;
       void* mem_op;

       strLen = strlen( ch_oid );
       if( strLen <= 0 ) return;
       mem_op = comp_nibble_memory_allocator ( 128, 16 );
       oid.octs = EncodeComponentOid ( mem_op, ch_oid, &strLen );
       oid.octetLen = strLen;
       if( strLen <= 0 ) return;
       

       InstallAnyByComponentOid ( 0, &oid, 0, encode, G_decode, B_decode,
                                          extract, match, NULL, NULL);
       comp_nibble_memory_free(mem_op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int IsNumericOid ( char *  peek_head,
int  strLen 
)

Definition at line 1224 of file componentlib.c.

                                              {
       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);
}

Here is the caller graph for this function:

int MatchingComponentAny ( char *  oid,
ComponentAny result,
ComponentAny result2 
)

Definition at line 1941 of file componentlib.c.

                                                                              {
       void *comp1, *comp2;

       if ( result->comp_desc->cd_type_id == BASICTYPE_ANY )
              comp1 = result->value;
       else
              comp1 = result;

       if ( result2->comp_desc->cd_type_id == BASICTYPE_ANY )
              comp2 = result2->value;
       else
              comp2 = result2;
              
       if ((result->cai != NULL) && (result->cai->Match != NULL)) {
              if ( result->comp_desc->cd_type_id == BASICTYPE_ANY )
                     return result->cai->Match(oid, comp1, comp2 );
              else if ( result2->comp_desc->cd_type_id == BASICTYPE_ANY )
                     return result2->cai->Match(oid, comp1, comp2);
              else 
                     return LDAP_INVALID_SYNTAX;
       }
       else {
              Asn1Error ("ERROR - ANY Matching routine is NULL\n");
              return LDAP_INVALID_SYNTAX;
       }
}

Here is the caller graph for this function:

int MatchingComponentBits ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 37 of file componentlib.c.

{
       int rc;
        MatchingRule* mr;
        ComponentBits *a, *b;
                                                                          
        if ( oid ) {
                mr = retrieve_matching_rule(oid, (AsnTypeId)csi_attr->csi_comp_desc->cd_type_id );
                if ( mr )
                        return component_value_match( mr, csi_attr , csi_assert );
        }
        a = ((ComponentBits*)csi_attr);
        b = ((ComponentBits*)csi_assert);
       rc = ( a->value.bitLen == b->value.bitLen && 
              strncmp( a->value.bits,b->value.bits,a->value.bitLen ) == 0 );
        return rc ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentBool ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 394 of file componentlib.c.

{
        MatchingRule* mr;
        ComponentBool *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 = ((ComponentBool*)csi_attr);
        b = ((ComponentBool*)csi_assert);

        return (a->value == b->value) ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentEnum ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 504 of file componentlib.c.

{
        int rc;
        MatchingRule* mr;
        ComponentEnum *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 = ((ComponentEnum*)csi_attr);
        b = ((ComponentEnum*)csi_assert);
        rc = (a->value == b->value);
                                                                          
        return rc ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentInt ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 713 of file componentlib.c.

{
        MatchingRule* mr;
        ComponentInt *a, *b;
                                                                          
        if( oid ) {
                /* check if this ASN type's matching rule is overrided */
                mr = retrieve_matching_rule(oid, csi_attr->csi_comp_desc->cd_type_id );
                /* if existing function is overrided, call the overriding
function*/
                if ( mr )
                        return component_value_match( mr, csi_attr , csi_assert );
        }
        a = ((ComponentInt*)csi_attr);
        b = ((ComponentInt*)csi_assert);
                                                                          
        return ( a->value == b->value ) ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentNull ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 822 of file componentlib.c.

{
        MatchingRule* mr;
        ComponentNull *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 = ((ComponentNull*)csi_attr);
        b = ((ComponentNull*)csi_assert);
                                                                          
        return (a->value == b->value) ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentOcts ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 1022 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentOid ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 1161 of file componentlib.c.

{
        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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MatchingComponentReal ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 1416 of file componentlib.c.

{
        int rc;
        MatchingRule* mr;
        ComponentReal *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 = (ComponentReal*)csi_attr;
        b = (ComponentReal*)csi_assert;
        rc = (a->value == b->value);
                                                                          
        return rc ? LDAP_COMPARE_TRUE:LDAP_COMPARE_FALSE;
}

Here is the call graph for this function:

int MatchingComponentRelativeOid ( char *  oid,
ComponentSyntaxInfo *  csi_attr,
ComponentSyntaxInfo *  csi_assert 
)

Definition at line 1525 of file componentlib.c.

{
        int rc;
        MatchingRule* mr;
        ComponentRelativeOid *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 = (ComponentRelativeOid*)csi_attr;
        b = (ComponentRelativeOid*)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;
}

Here is the call graph for this function:

OidDecoderMapping* RetrieveOidDecoderMappingbyBV ( struct berval in)

Definition at line 2054 of file componentlib.c.

                                                   {
       if ( IsNumericOid ( in->bv_val, in->bv_len ) )
              return RetrieveOidDecoderMappingbyOid( in->bv_val, in->bv_len );
       else
              return RetrieveOidDecoderMappingbyDesc( in->bv_val, in->bv_len );
}

Here is the call graph for this function:

Here is the caller graph for this function:

OidDecoderMapping* RetrieveOidDecoderMappingbyDesc ( char *  desc,
int  desc_len 
)

Definition at line 2094 of file componentlib.c.

                                                            {
       Hash hash;
       void *anyInfo;
       AsnOid oid;
       AttributeType* ad_type;
       struct berval bv;
       void* mem_op;

       bv.bv_val = desc;
       bv.bv_len = desc_len;
       ad_type = at_bvfind( &bv );

       oid.octs = ad_type->sat_atype.at_oid;
       oid.octetLen = strlen ( oid.octs );

       if ( !ad_type )
              return (OidDecoderMapping*) NULL;

       mem_op = comp_nibble_memory_allocator ( 128, 16 );

       oid.octs = EncodeComponentOid ( mem_op, oid.octs , (int*)&oid.octetLen );
       if( oid.octetLen <= 0 ) {
              comp_nibble_memory_free( mem_op );
              return (OidDecoderMapping*) NULL;
       }
       
       /* use encoded oid as hash string */
       hash = MakeHash ( oid.octs, oid.octetLen);
       comp_nibble_memory_free( mem_op );
       if (CheckForAndReturnValue (anyOidHashTblG, hash, &anyInfo))
              return (OidDecoderMapping*) anyInfo;
       else
              return (OidDecoderMapping*) NULL;

}

Here is the call graph for this function:

Here is the caller graph for this function:

OidDecoderMapping* RetrieveOidDecoderMappingbyOid ( char *  ch_oid,
int  oid_len 
)

Definition at line 2065 of file componentlib.c.

                                                            {
       Hash hash;
       void *anyInfo;
       AsnOid oid;
       int strLen;
       void* mem_op;

       mem_op = comp_nibble_memory_allocator ( 128, 16 );
       oid.octs = EncodeComponentOid ( mem_op, ch_oid, &oid_len);
       oid.octetLen = oid_len;
       if( oid_len <= 0 ) {
              comp_nibble_memory_free( mem_op );
              return NULL;
       }
       
       /* use encoded oid as hash string */
       hash = MakeHash ( oid.octs, oid.octetLen);
       comp_nibble_memory_free( mem_op );
       if (CheckForAndReturnValue (anyOidHashTblG, hash, &anyInfo))
              return (OidDecoderMapping*) anyInfo;
       else
              return (OidDecoderMapping*) NULL;

}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1801 of file componentlib.c.

                                                            {
       Hash hash;
       void *anyInfo;

       hash = MakeHash ((char*)&id, sizeof (id));
       if (CheckForAndReturnValue (anyIntHashTblG, hash, &anyInfo))
              v->cai = (ComponentAnyInfo*) anyInfo;
       else
              v->cai = NULL;
}

Definition at line 1780 of file componentlib.c.

                                                               {
       Hash hash;
       void *anyInfo;

       /* use encoded oid as hash string */
       hash = MakeHash (id->value.octs, id->value.octetLen);
       if (CheckForAndReturnValue (anyOidHashTblG, hash, &anyInfo))
              v->cai = (ComponentAnyInfo*) anyInfo;
       else
              v->cai = NULL;

       if ( !v->cai ) {
       /*
        * If not found, the data considered as octet chunk
        * Yet-to-be-Implemented
        */
       }
       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

static int UTF8toUniversalString ( char *  octs,
int  len 
) [static]

Definition at line 1652 of file componentlib.c.

                                           {
       /* Need to be Implemented */
       return LDAP_SUCCESS;
}

Here is the caller graph for this function: