mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2024-12-21 03:10:25 +08:00
Code Issues Packages Projects Releases Wiki Activity
759bfa0c51
openldap/servers/ldapd/syntax.c
Hallvard Furuseth 786bbe4fc1 enclose macro arguments in ()
1999-04-30 00:35:27 +00:00

1039 lines
23 KiB
C
Raw Blame History

/*
* Copyright (c) 1990 Regents of the University of Michigan.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that this notice is preserved and that due credit is given
* to the University of Michigan at Ann Arbor. The name of the University
* may not be used to endorse or promote products derived from this
* software without specific prior written permission. This software
* is provided ``as is'' without express or implied warranty.
*/
#include "portable.h"
#include <stdio.h>
#include <ac/ctype.h>
#include <ac/socket.h>
#include <ac/string.h>
#include <quipu/commonarg.h>
#include <quipu/attrvalue.h>
#include <quipu/ds_error.h>
#include <quipu/ds_search.h>
#include <quipu/dap2.h>
#include <quipu/dua.h>
extern oid_table_attr *name2attr( char * );
/*extern AttributeValue str_at2AttrV( char *, IF_AttributeType * );*/
#include "lber.h"
#include "../../libraries/liblber/lber-int.h" /* get struct berelement */
#include "ldap.h"
#include "common.h"
short ldap_photo_syntax;
short ldap_jpeg_syntax;
short ldap_jpeg_nonfile_syntax;
short ldap_audio_syntax;
short ldap_dn_syntax;
short ldap_postaladdress_syntax;
short ldap_acl_syntax;
short ldap_mtai_syntax;
short ldap_rts_cred_syntax;
short ldap_rtl_syntax;
short ldap_mailbox_syntax;
short ldap_caseignorelist_syntax;
short ldap_caseexactstring_syntax;
short ldap_certif_syntax;
short ldap_iattr_syntax;
short ldap_telex_syntax;
short ldap_octetstring_syntax;
short ldap_deliverymethod_syntax;
short ldap_facsimileTelephoneNumber_syntax;
short ldap_presentationAddress_syntax;
short ldap_teletexTerminalIdentifier_syntax;
short ldap_searchGuide_syntax;
short ldap_dLSubmitPermission_syntax;
static void de_t61( char *s, int t61mark );
static int syntax_is_string( short syntax );
static int
get_one_syntax( char *attrib, int required )
{
oid_table_attr *p;
if ( (p = name2attr( attrib )) != (oid_table_attr *) 0 )
return( p->oa_syntax );
if ( !required )
return( -1 );
Debug( LDAP_DEBUG_ANY, "name2attr (%s) failed - exiting\n", attrib,
0, 0 );
log_and_exit( 1 );
}
void
get_syntaxes( void )
{
Debug( LDAP_DEBUG_TRACE, "get_syntaxes\n", 0, 0, 0 );
ldap_photo_syntax = get_one_syntax( "photo", 0 );
ldap_jpeg_syntax = get_one_syntax( "jpegPhoto", 0 );
ldap_jpeg_nonfile_syntax = str2syntax( "jpeg" );
ldap_audio_syntax = get_one_syntax( "audio", 0 );
ldap_postaladdress_syntax = get_one_syntax( "postaladdress", 0 );
ldap_dn_syntax = get_one_syntax( "aliasedObjectName", 1 );
ldap_acl_syntax = get_one_syntax( "acl", 0 );
ldap_mtai_syntax = get_one_syntax( "mTAInfo", 0 );
ldap_rts_cred_syntax= get_one_syntax( "initiatingRTSCredentials", 0 );
ldap_rtl_syntax= get_one_syntax( "routingTreeList", 0 );
ldap_mailbox_syntax = get_one_syntax( "otherMailbox", 0 );
ldap_caseignorelist_syntax = str2syntax( "CaseIgnoreList" );
ldap_caseexactstring_syntax = str2syntax( "caseexactstring" );
ldap_octetstring_syntax = str2syntax( "OctetString" );
ldap_deliverymethod_syntax = str2syntax( "DeliveryMethod" );
ldap_iattr_syntax = get_one_syntax( "inheritedAttribute", 0 );
ldap_certif_syntax = get_one_syntax( "userCertificate", 0 );
ldap_telex_syntax = get_one_syntax( "telexNumber", 0 );
ldap_facsimileTelephoneNumber_syntax =
get_one_syntax( "facsimileTelephoneNumber", 0 );
ldap_presentationAddress_syntax =
get_one_syntax( "presentationAddress", 0 );
ldap_teletexTerminalIdentifier_syntax =
get_one_syntax( "teletexTerminalIdentifier", 0 );
ldap_searchGuide_syntax = get_one_syntax( "searchGuide", 0 );
ldap_dLSubmitPermission_syntax =
get_one_syntax( "mhsDLSubmitPermissions", 0 );
certif_init(); /* initialize certificate syntax handler */
}
/*
* From RFC 1779 "A String Representation of Distinguished Names"
*
* Key Attribute (X.520 keys)
* ------------------------------
* CN CommonName
* L LocalityName
* ST StateOrProvinceName
* O OrganizationName
* OU OrganizationalUnitName
* C CountryName
* STREET StreetAddress
*
*
* Table 1: Standardised Keywords
*
* There is an escape mechanism from the normal user oriented form, so
* that this syntax may be used to print any valid distinguished name.
*
* 1. Attributes types are represented in a (big-endian) dotted
* notation. (e.g., OID.2.6.53).
*
*/
static void
attr_key_rfc1779(
AttributeType at,
char *key /* return key, caller allocated */
)
{
char *x;
x = attr2name_aux ( at );
if ( x == NULL ) {
x = "?";
} else if ( isdigit ( (unsigned char) *x ) ) {
sprintf ( key, "OID.%s", x );
return;
} else if (strcasecmp(x,"commonName")==0) {
x = "CN";
} else if (strcasecmp(x,"localityName")==0) {
x = "l";
} else if (strcasecmp(x,"stateOrProvinceName")==0) {
x = "st";
} else if (strcasecmp(x,"organizationName")==0) {
x = "o";
} else if (strcasecmp(x,"organizationalUnitName")==0) {
x = "ou";
} else if (strcasecmp(x,"countryName")==0) {
x = "c";
} else if (strcasecmp(x,"streetAddress")==0) {
x = "street";
}
strcpy ( key, x );
}
#define SEPARATOR(c) ((c) == ',' || (c) == ';')
#define SPACE(c) ((c) == ' ' || (c) == '\n')
int
dn_print_real(
PS ps,
DN dn,
int format
)
{
RDN rdn;
int firstrdn;
char *value;
PS rps;
char key[512];
if ( dn == NULLDN )
return( 0 );
if ( dn->dn_parent != NULLDN ) {
dn_print_real( ps, dn->dn_parent, format );
ps_print( ps, ", " );
}
if ( (rps = ps_alloc( str_open )) == NULLPS )
return( -1 );
if ( str_setup( rps, NULLCP, 0, 0 ) == NOTOK )
return( -1 );
firstrdn = 1;
for ( rdn = dn->dn_rdn; rdn != NULLRDN; rdn = rdn->rdn_next ) {
if ( firstrdn )
firstrdn = 0;
else
ps_print( ps, " + " );
attr_key_rfc1779 ( rdn->rdn_at, key );
ps_print ( ps, key );
ps_print( ps, "=" );
if ( rdn->rdn_at->oa_syntax == ldap_dn_syntax ) {
dn_print_real( rps, (DN) rdn->rdn_av.av_struct,
format );
*rps->ps_ptr = '\0';
value = rps->ps_base;
} else {
AttrV_print( rps, &rdn->rdn_av, EDBOUT );
*rps->ps_ptr = '\0';
if ( rps->ps_ptr - rps->ps_base >= 5 &&
strncmp( rps->ps_base, "{ASN}", 5 ) == 0 ) {
*rps->ps_base = '#';
SAFEMEMCPY( rps->ps_base + 1, rps->ps_base + 5,
rps->ps_ptr - rps->ps_base - 4 );
}
value = rps->ps_base;
de_t61( value, 0 );
}
/*
* ,+="\\\n all go in quotes. " and \\ need to
* be preceeded by \\.
*/
if ( strpbrk( value, ",+=\"\\\n" ) != NULL || SPACE( value[0] )
|| SPACE( value[max( strlen(value) - 1, (size_t) 0 )] ) ) {
char *p, *t, *tmp;
int specialcount;
ps_print( ps, "\"" );
specialcount = 0;
for ( p = value; *p != '\0'; p++ ) {
if ( *p == '"' || *p == '\\' ) {
specialcount++;
}
}
if ( specialcount > 0 ) {
tmp = smalloc( strlen( value ) + specialcount
+ 1 );
for ( p = value, t = tmp; *p != '\0'; p++ ) {
switch ( *p ) {
case '"':
case '\\':
*t++ = '\\';
/* FALL THROUGH */
default:
*t++ = *p;
}
}
*t = '\0';
ps_print( ps, tmp );
free( tmp );
} else {
ps_print( ps, value );
}
ps_print( ps, "\"" );
} else {
ps_print( ps, value );
}
rps->ps_ptr = rps->ps_base;
}
ps_free( rps );
return( 0 );
}
void
ldap_dn_print(
PS ps,
DN dn,
DN base, /* if non-NULL, subsitute '*' for base (for CLDAP) */
int format
)
{
DN tmpdn;
int addstar;
Debug( LDAP_DEBUG_TRACE, "ldap_dn_print\n", 0, 0, 0 );
addstar = 0;
if ( base != NULLDN && dn != NULL ) {
for ( tmpdn = dn; base != NULLDN && tmpdn != NULLDN;
base = base->dn_parent, tmpdn = tmpdn->dn_parent ) {
if ( dn_comp_cmp( base, tmpdn ) == NOTOK ) {
break;
}
}
if (( addstar = ( base == NULLDN && tmpdn != NULL ))) {
dn = tmpdn;
}
}
dn_print_real( ps, dn, format );
if ( addstar ) {
ps_print( ps, ", *" );
}
}
int
encode_dn(
BerElement *ber,
DN dn,
DN base /* if non-NULL, subsitute '*' for base (for CLDAP) */
)
{
PS ps;
int rc;
Debug( LDAP_DEBUG_TRACE, "encode_dn\n", 0, 0, 0 );
if ( (ps = ps_alloc( str_open )) == NULLPS )
return( -1 );
if ( str_setup( ps, NULLCP, 0, 0 ) == NOTOK )
return( -1 );
ldap_dn_print( ps, dn, base, EDBOUT );
*ps->ps_ptr = '\0';
rc = ber_printf( ber, "s", ps->ps_base );
ps_free( ps );
return( rc );
}
static int
put_jpeg_value( BerElement *ber, AttributeValue av )
{
PE pe;
int len;
Debug( LDAP_DEBUG_TRACE, "put_jpeg_value\n", 0, 0, 0 );
if (av->av_syntax == AV_FILE)
pe = (PE) (((struct file_syntax *) av->av_struct)->
fs_attr->av_struct);
else
pe = (PE) av->av_struct;
Debug( LDAP_DEBUG_ARGS,
"put_jpeg_value: pe_class %x, pe_form %x, pe_id %x\n",
pe->pe_class, pe->pe_form, pe->pe_id );
if ( (pe->pe_class != PE_CLASS_UNIV && pe->pe_class != PE_CLASS_CONT)
|| pe->pe_form != PE_FORM_PRIM || pe->pe_id != PE_PRIM_OCTS ) {
Debug( LDAP_DEBUG_ANY, "put_jpeg_value: unknown type\n", 0,
0, 0 );
return( -1 );
}
if ( pe_pullup( pe ) == NOTOK ) {
Debug( LDAP_DEBUG_ANY, "put_jpeg_value: cannot pullup\n", 0,
0, 0 );
return( -1 );
}
len = ps_get_abs( pe );
Debug( LDAP_DEBUG_ARGS, "put_jeg_value: ber_printf %d bytes\n",
len, 0, 0 );
if ( ber_printf( ber, "o", (char *) pe->pe_prim, len ) == -1 ) {
Debug( LDAP_DEBUG_ANY, "put_jpeg_value: ber_printf failed\n",
0, 0, 0 );
return( -1 );
}
return( 0 );
}
static int
put_audio_value( BerElement *ber, AttributeValue av )
{
struct qbuf *qb, *p;
int rc, len;
char *buf;
Debug( LDAP_DEBUG_TRACE, "put_audio_value\n", 0, 0, 0 );
qb = (struct qbuf *) (((struct file_syntax *)
av->av_struct)->fs_attr->av_struct);
len = 0;
for ( p = qb->qb_forw; p != qb; p = p->qb_forw ) {
len += p->qb_len;
}
if ( (buf = (char *) malloc( len )) == NULL )
return( -1 );
len = 0;
for ( p = qb->qb_forw; p != qb; p = p->qb_forw ) {
SAFEMEMCPY( buf + len, p->qb_data, p->qb_len );
len += p->qb_len;
}
Debug( LDAP_DEBUG_ARGS, "put_audio_value: ber_printf %d bytes\n",
len, 0, 0 );
if ( (rc = ber_printf( ber, "o", buf, len )) == -1 )
Debug( LDAP_DEBUG_ANY, "put_audio_value: ber_printf failed\n",
0, 0, 0 );
free( buf );
return( rc );
}
static int
put_photo_value( BerElement *ber, AttributeValue av )
{
PE pe;
PS ps;
int len;
char *faxparamset = "\000\300\000\000";
BerElement *phber;
Debug( LDAP_DEBUG_TRACE, "put_photo_value\n", 0, 0, 0 );
pe = (PE) (((struct file_syntax *) av->av_struct)->fs_attr->av_struct);
/* old bit string-like format - only handle this for now */
if ( pe->pe_class == PE_CLASS_UNIV && pe->pe_form == PE_FORM_PRIM
&& pe->pe_id == PE_PRIM_BITS ) {
len = ps_get_abs( pe );
Debug( LDAP_DEBUG_ARGS, "put_photo_val: ber_printf %d bytes\n",
len, 0, 0 );
if (( phber = der_alloc()) == NULLBER ) {
Debug( LDAP_DEBUG_ANY, "der_alloc failed\n", 0, 0, 0 );
return( -1 );
}
if ( ber_printf( phber, "t{[tB]{B}}", 0xA3, 0x81, faxparamset,
31, (char *)pe->pe_prim, len * 8 ) == -1 ) {
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
ber_free( phber, 1 );
return( -1 );
}
if ( ber_printf( ber, "o", phber->ber_buf, phber->ber_ptr
- phber->ber_buf ) == -1 ) {
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
ber_free( phber, 1 );
return( -1 );
}
ber_free( phber, 1 );
} else {
/*
* try just writing this into a PS and sending it along
*/
ps_len_strategy = PS_LEN_LONG;
if ( (ps = ps_alloc( str_open )) == NULLPS )
return( -1 );
if ( str_setup( ps, NULLCP, 0, 0 ) == NOTOK ||
pe2ps( ps, pe ) == NOTOK ) {
ps_free( ps );
return( -1 );
}
len = ps->ps_ptr - ps->ps_base;
Debug( LDAP_DEBUG_ARGS, "put_photo_val: ber_printf %d bytes\n",
len, 0, 0 );
if ( ber_printf( ber, "o", (char *) ps->ps_base, len ) == -1 ) {
Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 );
ps_free( ps );
return( -1 );
}
ps_free( ps );
}
return( 0 );
}
static int
put_values(
BerElement *ber,
PS ps,
short syntax,
AV_Sequence vals
)
{
AV_Sequence av;
char *strvalue;
Debug( LDAP_DEBUG_TRACE, "put_values\n", 0, 0, 0 );
for ( av = vals; av != NULLAV; av = av->avseq_next ) {
if ( syntax == ldap_jpeg_syntax ||
syntax == ldap_jpeg_nonfile_syntax ) {
if ( put_jpeg_value( ber, &av->avseq_av ) == -1 )
return( -1 );
} else if ( syntax == ldap_photo_syntax ) {
if ( put_photo_value( ber, &av->avseq_av ) == -1 )
return( -1 );
} else if ( syntax == ldap_audio_syntax ) {
if ( put_audio_value( ber, &av->avseq_av ) == -1 )
return( -1 );
} else if ( syntax == ldap_dn_syntax ) {
if ( encode_dn( ber, (DN) av->avseq_av.av_struct,
NULLDN ) == -1 )
return( -1 );
} else if ( syntax > AV_WRITE_FILE ) {
struct file_syntax *fsyntax;
fsyntax = (struct file_syntax *) av->avseq_av.av_struct;
ps->ps_ptr = ps->ps_base;
AttrV_print( ps, fsyntax->fs_attr, EDBOUT );
*ps->ps_ptr = '\0';
if ( ber_printf( ber, "o", ps->ps_base,
ps->ps_ptr - ps->ps_base ) == -1 )
return( -1 );
} else {
ps->ps_ptr = ps->ps_base;
AttrV_print( ps, &av->avseq_av, EDBOUT );
*ps->ps_ptr = '\0';
de_t61( ps->ps_base, 0 );
if ( syntax_is_string( av->avseq_av.av_syntax ) &&
*ps->ps_base == '\0' ) {
/*
* If this is a zero-length string, make it
* a single blank (this is gross, but it works
* around a dsap library bug).
*/
Debug( LDAP_DEBUG_ANY,
"put_values: replaced zero-length string with single blank\n", 0, 0, 0 );
strvalue = " ";
} else {
strvalue = ps->ps_base;
}
if ( ber_printf( ber, "s", strvalue ) == -1 )
return( -1 );
}
}
return( 0 );
}
int
encode_attrs( BerElement *ber, Attr_Sequence as )
{
PS ps;
Debug( LDAP_DEBUG_TRACE, "encode_attrs\n", 0, 0, 0 );
if ( (ps = ps_alloc( str_open )) == NULLPS )
return( -1 );
if ( str_setup( ps, NULLCP, 0, 0 ) == NOTOK )
return( -1 );
#ifdef LDAP_COMPAT20
if ( ber_printf( ber, "t{", ldap_compat == 20 ? OLD_LBER_SEQUENCE :
LBER_SEQUENCE ) == -1 ) {
#else
if ( ber_printf( ber, "{" ) == -1 ) {
#endif
ps_free( ps );
return( -1 );
}
while ( as != NULLATTR ) {
ps->ps_ptr = ps->ps_base;
AttrT_print( ps, as->attr_type, EDBOUT );
*ps->ps_ptr = '\0';
#ifdef LDAP_COMPAT20
if ( ber_printf( ber, "t{st[", ldap_compat == 20 ?
OLD_LBER_SEQUENCE : LBER_SEQUENCE, ps->ps_base,
ldap_compat == 20 ? OLD_LBER_SET : LBER_SET ) == -1 ) {
#else
if ( ber_printf( ber, "{s[", ps->ps_base ) == -1 ) {
#endif
ps_free( ps );
return( -1 );
}
put_values( ber, ps, as->attr_type->oa_syntax, as->attr_value );
if ( ber_printf( ber, "]}" ) == -1 ) {
ps_free( ps );
return( -1 );
}
as = as->attr_link;
}
ps_free( ps );
if ( ber_printf( ber, "}" ) == -1 )
return( -1 );
return( 0 );
}
static void
trim_trailing_spaces( char *s )
{
char *t;
t = s + strlen( s );
while ( --t > s ) {
if ( SPACE( *t ) ) {
*t = '\0';
} else {
break;
}
}
}
DN
ldap_str2dn( char *str )
{
DN dn, save;
RDN rdn, newrdn, tmprdn;
AttributeType at;
AttributeValue av;
char *type, *value, *savestr;
int morerdncomps;
Debug( LDAP_DEBUG_TRACE, "ldap_str2dn\n", 0, 0, 0 );
savestr = str = strdup( str );
dn = NULLDN;
do {
char *r;
int state;
rdn = NULLRDN;
morerdncomps = 1;
do {
/* get the type */
while ( *str == ' ' || *str == '\n' )
str++;
type = str;
while ( *str != '\0' && *str != '=' )
str++;
if ( *str == '\0' ) {
free( savestr );
Debug( LDAP_DEBUG_ARGS, "no =\n", 0, 0, 0 );
return( NULLDN );
}
*str++ = '\0';
if ( strncmp( type, "OID.", 4 ) == 0 )
type += 4;
#define BEGINVALUE 1
#define INVALUE 2
#define INQUOTE 3
#define ENDVALUE 4
if ( *str == '#' ) {
++str;
}
r = value = str;
state = BEGINVALUE;
/* break or return out */
while ( state != ENDVALUE ) {
switch ( *str ) {
case '"':
if ( state == BEGINVALUE ) {
state = INQUOTE;
str++;
} else if ( state == INQUOTE ) {
state = ENDVALUE;
str++;
} else {
free( savestr );
Debug( LDAP_DEBUG_ARGS,
"quote state %d\n", state,
0, 0 );
return( NULLDN );
}
break;
case ',':
case ';':
case '+':
if ( state == INVALUE ) {
state = ENDVALUE;
} else if ( state == INQUOTE ) {
*r++ = *str++;
} else {
free( savestr );
Debug( LDAP_DEBUG_ARGS,
"comma state %d\n", state,
0, 0 );
return( NULLDN );
}
break;
case ' ':
case '\n':
if ( state == BEGINVALUE ) {
str++;
} else {
*r++ = *str++;
}
break;
case '\\':
str++;
*r++ = *str++;
break;
case '\0':
state = ENDVALUE;
break;
default:
if ( state == BEGINVALUE )
state = INVALUE;
*r++ = *str++;
break;
}
}
while ( SPACE( *str ) )
str++;
if ( *str == '+' ) {
morerdncomps = 1;
str++;
} else {
morerdncomps = 0;
if ( SEPARATOR( *str ) )
str++;
}
*r = '\0';
/* type */
trim_trailing_spaces( type );
if ( (at = str2AttrT( type )) == NULLAttrT ) {
dn_free( dn );
free( savestr );
Debug( LDAP_DEBUG_ARGS, "bad type (%s)\n",
type, 0, 0 );
return( NULLDN ); /* LDAP_UNDEFINED_TYPE */
}
/* value */
if ( (av = ldap_str2AttrV( value, at->oa_syntax ))
== NULLAttrV ) {
dn_free( dn );
free( savestr );
Debug( LDAP_DEBUG_ARGS, "bad val\n", 0, 0, 0 );
return( NULLDN ); /* LDAP_INVALID_SYNTAX */
}
/* make the rdn */
newrdn = rdn_comp_new( at, av );
/* add it to the list */
for ( tmprdn = rdn; tmprdn != NULLRDN &&
tmprdn->rdn_next != NULLRDN;
tmprdn = tmprdn->rdn_next )
; /* NULL */
if ( tmprdn != NULLRDN )
tmprdn->rdn_next = newrdn;
else
rdn = newrdn;
AttrV_free( av );
} while ( morerdncomps );
save = dn;
dn = dn_comp_new( rdn );
dn->dn_parent = save;
} while ( str != NULL && *str != '\0' );
free( savestr );
Debug( LDAP_DEBUG_TRACE, "ldap_str2dn OK\n", 0, 0, 0 );
return( dn );
}
#define T61 "{T.61}"
#define T61LEN 6
static void
de_t61( char *s, int t61mark )
{
char *next = s;
unsigned char c;
unsigned int hex;
while ( *s ) {
switch ( *s ) {
case '{' :
if ( strncasecmp( s, T61, T61LEN) == 0 ) {
s += T61LEN;
if ( t61mark )
*next++ = '@';
} else {
*next++ = *s++;
}
break;
case '\\':
c = *(s + 1);
if ( c == '\n' ) {
s += 2;
if ( *s == '\t' )
s++;
break;
}
if ( c == '\\' ) {
/* reverse solidus character itself */
s += 2;
*next++ = c;
break;
}
if ( isdigit( c ) )
hex = c - '0';
else if ( c >= 'A' && c <= 'F' )
hex = c - 'A' + 10;
else if ( c >= 'a' && c <= 'f' )
hex = c - 'a' + 10;
else {
*next++ = *s++;
break;
}
hex <<= 4;
c = *(s + 2);
if ( isdigit( c ) )
hex += c - '0';
else if ( c >= 'A' && c <= 'F' )
hex += c - 'A' + 10;
else if ( c >= 'a' && c <= 'f' )
hex += c - 'a' + 10;
else {
*next++ = *s++;
*next++ = *s++;
break;
}
*next++ = hex;
s += 3;
break;
default:
*next++ = *s++;
break;
}
}
*next = '\0';
}
static PE
bv_asn2pe( struct berval *bv )
{
PS ps;
PE pe;
if (( ps = ps_alloc(str_open)) == NULLPS || str_setup( ps, bv->bv_val,
bv->bv_len, 0 ) == NOTOK ) {
Debug( LDAP_DEBUG_TRACE, "bv_asn2pe: ps_alloc failed\n",
0, 0, 0 );
return( NULLPE );
}
pe = ps2pe( ps );
if ( ps->ps_errno != PS_ERR_NONE ) {
Debug( LDAP_DEBUG_TRACE, "bv_asn2pe: ps2pe failed %s\n",
ps_error(ps->ps_errno), 0, 0 );
if ( pe != NULLPE ) {
pe_free( pe );
}
return( NULLPE );
}
return( pe );
}
AttributeValue
bv_octet2AttrV( struct berval *bv )
{
AttributeValue av;
av = AttrV_alloc();
if ( av == NULLAttrV ) {
return( NULLAttrV );
}
if (( av->av_struct = (caddr_t) str2prim( bv->bv_val, bv->bv_len,
PE_CLASS_UNIV, PE_PRIM_OCTS )) == NULL ) {
free((char *)av );
return( NULLAttrV );
}
av->av_syntax = 0;
return( av );
}
AttributeValue
bv_asn2AttrV( struct berval *bv )
{
AttributeValue av;
av = AttrV_alloc();
if ( av == NULLAttrV ) {
return( NULLAttrV );
}
if (( av->av_struct = (caddr_t) bv_asn2pe( bv )) == NULL ) {
free((char *)av );
return( NULLAttrV );
}
av->av_syntax = 0;
return( av );
}
AttributeValue
ldap_strdn2AttrV( char *dnstr )
{
DN dn;
AttributeValue av;
if (( dn = ldap_str2dn( dnstr )) == NULL ) {
return( NULLAttrV );
}
av = AttrV_alloc();
if ( av == NULLAttrV ) {
dn_free( dn );
return( NULLAttrV );
}
av->av_struct = (caddr_t)dn;
av->av_syntax = ldap_dn_syntax;
return( av );
}
RDN
ldap_str2rdn( char *rdnstr )
{
DN dn;
RDN rdn;
if ( (dn = ldap_str2dn( rdnstr )) == NULL ) {
return( NULL );
}
if ( (rdn = rdn_cpy( dn->dn_rdn )) == NULL ) {
return( NULL );
}
dn_free( dn );
return( rdn );
}
AttributeValue
ldap_str_at2AttrV( char *str, AttributeType type )
{
char *s, *res, *r;
Debug( LDAP_DEBUG_TRACE, "ldap_str_at2AttrV str (%s) type (%s)\n", str,
type->oa_ot.ot_name, 0 );
if ( type->oa_syntax == ldap_rts_cred_syntax ||
type->oa_syntax == ldap_mtai_syntax ||
type->oa_syntax == ldap_acl_syntax ||
type->oa_syntax == ldap_mailbox_syntax ||
type->oa_syntax == ldap_caseignorelist_syntax ||
type->oa_syntax == ldap_certif_syntax ||
type->oa_syntax == ldap_iattr_syntax ||
type->oa_syntax == ldap_telex_syntax ||
type->oa_syntax == ldap_deliverymethod_syntax ||
type->oa_syntax == ldap_facsimileTelephoneNumber_syntax ||
type->oa_syntax == ldap_presentationAddress_syntax ||
type->oa_syntax == ldap_teletexTerminalIdentifier_syntax ||
type->oa_syntax == ldap_searchGuide_syntax ||
type->oa_syntax == ldap_dLSubmitPermission_syntax ||
type->oa_syntax == ldap_rtl_syntax ) {
res = str;
} else {
res = (char *) malloc( max( 2 * strlen( str ), (size_t) 10 ) );
r = res;
for ( s = str; *s; s++ ) {
switch ( *s ) {
case '&':
case '#':
case '$':
case '%':
case '@':
case '\\':
sprintf( r, "\\%02x", *s & 0xff );
r += 3;
break;
default:
*r++ = *s;
}
}
*r = '\0';
}
Debug( LDAP_DEBUG_TRACE, "ldap_str_at2AttrV returning (%s)\n", res,
0, 0 );
return( str_at2AttrV( res, type ) );
}
AttributeValue
ldap_str2AttrV( char *value, short syntax )
{
if ( syntax == ldap_dn_syntax ) {
return( ldap_strdn2AttrV( value ) );
} else {
return( str2AttrV( value, syntax ) );
}
}
static int
syntax_is_string( short syntax )
{
/*
* this code depends on the order and nunber of strings that are in
* the ISODE file lib/syntax/x500/string.c
*/
return ( syntax >= ldap_caseexactstring_syntax &&
syntax <= ldap_caseexactstring_syntax + 8 );
}
Reference in New Issue View Git Blame Copy Permalink