X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Furl.c;h=1eadf029f152df0f0a7d4d209ce323eb45b49fc7;hb=c3e28a5488a8011ef0352f48fca85c48679205ba;hp=d3620152e9d65a73cf6a5dd968761946f89da422;hpb=acbb5cf689a4336af05c9f259d909d8141055bac;p=openldap diff --git a/libraries/libldap/url.c b/libraries/libldap/url.c index d3620152e9..1eadf029f1 100644 --- a/libraries/libldap/url.c +++ b/libraries/libldap/url.c @@ -1,8 +1,8 @@ -/* LIBLDAP url.c -- LDAP URL (RFC 2255) related routines */ +/* LIBLDAP url.c -- LDAP URL (RFC 4516) related routines */ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2006 The OpenLDAP Foundation. + * Copyright 1998-2007 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -25,7 +25,7 @@ * where: * attributes is a comma separated list * scope is one of these three strings: base one sub (default=base) - * filter is an string-represented filter as in RFC 2254 + * filter is an string-represented filter as in RFC 4515 * * e.g., ldap://host:port/dc=com?o,cn?base?(o=openldap)?extension * @@ -257,34 +257,83 @@ skip_url_prefix( return( NULL ); } - -static int str2scope( const char *p ) +int +ldap_pvt_scope2bv( int scope, struct berval *bv ) { - if ( strcasecmp( p, "one" ) == 0 ) { - return LDAP_SCOPE_ONELEVEL; + switch ( scope ) { + case LDAP_SCOPE_BASE: + BER_BVSTR( bv, "base" ); + break; + + case LDAP_SCOPE_ONELEVEL: + BER_BVSTR( bv, "one" ); + break; + + case LDAP_SCOPE_SUBTREE: + BER_BVSTR( bv, "sub" ); + break; + + case LDAP_SCOPE_SUBORDINATE: + BER_BVSTR( bv, "subordinate" ); + break; - } else if ( strcasecmp( p, "onelevel" ) == 0 ) { - return LDAP_SCOPE_ONELEVEL; + default: + return LDAP_OTHER; + } - } else if ( strcasecmp( p, "base" ) == 0 ) { - return LDAP_SCOPE_BASE; + return LDAP_SUCCESS; +} - } else if ( strcasecmp( p, "sub" ) == 0 ) { - return LDAP_SCOPE_SUBTREE; +const char * +ldap_pvt_scope2str( int scope ) +{ + struct berval bv; - } else if ( strcasecmp( p, "subtree" ) == 0 ) { - return LDAP_SCOPE_SUBTREE; + if ( ldap_pvt_scope2bv( scope, &bv ) == LDAP_SUCCESS ) { + return bv.bv_val; + } - } else if ( strcasecmp( p, "subordinate" ) == 0 ) { - return LDAP_SCOPE_SUBORDINATE; + return NULL; +} - } else if ( strcasecmp( p, "children" ) == 0 ) { - return LDAP_SCOPE_SUBORDINATE; +int +ldap_pvt_bv2scope( struct berval *bv ) +{ + static struct { + struct berval bv; + int scope; + } v[] = { + { BER_BVC( "one" ), LDAP_SCOPE_ONELEVEL }, + { BER_BVC( "onelevel" ), LDAP_SCOPE_ONELEVEL }, + { BER_BVC( "base" ), LDAP_SCOPE_BASE }, + { BER_BVC( "sub" ), LDAP_SCOPE_SUBTREE }, + { BER_BVC( "subtree" ), LDAP_SCOPE_SUBTREE }, + { BER_BVC( "subord" ), LDAP_SCOPE_SUBORDINATE }, + { BER_BVC( "subordinate" ), LDAP_SCOPE_SUBORDINATE }, + { BER_BVC( "children" ), LDAP_SCOPE_SUBORDINATE }, + { BER_BVNULL, -1 } + }; + int i; + + for ( i = 0; v[ i ].scope != -1; i++ ) { + if ( ber_bvstrcasecmp( bv, &v[ i ].bv ) == 0 ) { + return v[ i ].scope; + } } return( -1 ); } +int +ldap_pvt_str2scope( const char *p ) +{ + struct berval bv; + + ber_str2bv( p, 0, 0, &bv ); + + return ldap_pvt_bv2scope( &bv ); +} + static const char hex[] = "0123456789ABCDEF"; #define URLESC_NONE 0x0000U @@ -346,7 +395,7 @@ hex_escape_len( const char *s, unsigned list ) /* RFC 2396: unreserved alphanum */ default: - if ( !isalnum( s[0] ) ) { + if ( !isalnum( (unsigned char) s[0] ) ) { len += 3; } else { len++; @@ -411,7 +460,7 @@ hex_escape( char *buf, int len, const char *s, unsigned list ) /* RFC 2396: unreserved alphanum */ default: - if ( !isalnum( s[i] ) ) { + if ( !isalnum( (unsigned char) s[i] ) ) { escape = 1; } break; @@ -482,8 +531,9 @@ hex_escape_list( char *buf, int len, char **s, unsigned flags ) static int desc2str_len( LDAPURLDesc *u ) { - int sep = 0; - int len = 0; + int sep = 0; + int len = 0; + struct berval scope; if ( u == NULL ) { return -1; @@ -503,36 +553,11 @@ desc2str_len( LDAPURLDesc *u ) } } - switch ( u->lud_scope ) { - case LDAP_SCOPE_BASE: - case LDAP_SCOPE_ONELEVEL: - case LDAP_SCOPE_SUBTREE: - case LDAP_SCOPE_SUBORDINATE: - switch ( u->lud_scope ) { - case LDAP_SCOPE_BASE: - len += STRLENOF( "base" ); - break; - - case LDAP_SCOPE_ONELEVEL: - len += STRLENOF( "one" ); - break; - - case LDAP_SCOPE_SUBTREE: - len += STRLENOF( "sub" ); - break; - - case LDAP_SCOPE_SUBORDINATE: - len += STRLENOF( "subordinate" ); - break; - } - + if ( ldap_pvt_scope2bv( u->lud_scope, &scope ) == LDAP_SUCCESS ) { + len += scope.bv_len; if ( !sep ) { sep = 3; } - break; - - default: - break; } if ( u->lud_attrs ) { @@ -573,10 +598,10 @@ desc2str_len( LDAPURLDesc *u ) int desc2str( LDAPURLDesc *u, char *s, int len ) { - int i; - int sep = 0; - int sofar = 0; - int gotscope = 0; + int i; + int sep = 0; + int sofar = 0; + struct berval scope = BER_BVNULL; if ( u == NULL ) { return -1; @@ -586,20 +611,13 @@ desc2str( LDAPURLDesc *u, char *s, int len ) return -1; } - switch ( u->lud_scope ) { - case LDAP_SCOPE_BASE: - case LDAP_SCOPE_ONELEVEL: - case LDAP_SCOPE_SUBTREE: - case LDAP_SCOPE_SUBORDINATE: - gotscope = 1; - break; - } + ldap_pvt_scope2bv( u->lud_scope, &scope ); if ( u->lud_exts ) { sep = 5; } else if ( u->lud_filter ) { sep = 4; - } else if ( gotscope ) { + } else if ( !BER_BVISEMPTY( &scope ) ) { sep = 3; } else if ( u->lud_attrs ) { sep = 2; @@ -662,30 +680,10 @@ desc2str( LDAPURLDesc *u, char *s, int len ) assert( len >= 0 ); - switch ( u->lud_scope ) { - case LDAP_SCOPE_BASE: - strcpy( &s[sofar], "base" ); - sofar += STRLENOF("base"); - len -= STRLENOF("base"); - break; - - case LDAP_SCOPE_ONELEVEL: - strcpy( &s[sofar], "one" ); - sofar += STRLENOF("one"); - len -= STRLENOF("one"); - break; - - case LDAP_SCOPE_SUBTREE: - strcpy( &s[sofar], "sub" ); - sofar += STRLENOF("sub"); - len -= STRLENOF("sub"); - break; - - case LDAP_SCOPE_SUBORDINATE: - strcpy( &s[sofar], "children" ); - sofar += STRLENOF("children"); - len -= STRLENOF("children"); - break; + if ( !BER_BVISNULL( &scope ) ) { + strcpy( &s[sofar], scope.bv_val ); + sofar += scope.bv_len; + len -= scope.bv_len; } assert( len >= 0 ); @@ -759,7 +757,7 @@ ldap_url_desc2str( LDAPURLDesc *u ) } int -ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) +ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp, unsigned flags ) { /* * Pick apart the pieces of an LDAP URL. @@ -772,6 +770,8 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) const char *url_tmp; char *url; + int check_dn = 1; + if( url_in == NULL || ludpp == NULL ) { return LDAP_URL_ERR_PARAM; } @@ -825,7 +825,7 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) ludp->lud_port = 0; ludp->lud_dn = NULL; ludp->lud_attrs = NULL; - ludp->lud_scope = LDAP_SCOPE_DEFAULT; + ludp->lud_scope = ( flags & LDAP_PVT_URL_PARSE_NODEF_SCOPE ) ? LDAP_SCOPE_BASE : LDAP_SCOPE_DEFAULT; ludp->lud_filter = NULL; ludp->lud_exts = NULL; @@ -879,6 +879,18 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) } } + if ( ( flags & LDAP_PVT_URL_PARSE_DEF_PORT ) && ludp->lud_port == 0 ) { + if ( strcmp( ludp->lud_scheme, "ldap" ) == 0 ) { + ludp->lud_port = LDAP_PORT; +#ifdef LDAP_CONNECTIONLESS + } else if ( strcmp( ludp->lud_scheme, "cldap" ) == 0 ) { + ludp->lud_port = LDAP_PORT; +#endif + } else if ( strcmp( ludp->lud_scheme, "ldaps" ) == 0 ) { + ludp->lud_port = LDAPS_PORT; + } + } + ldap_pvt_hex_unescape( url ); /* If [ip address]:port syntax, url is [ip and we skip the [ */ @@ -890,6 +902,14 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) return LDAP_URL_ERR_MEM; } + if ( ( flags & LDAP_PVT_URL_PARSE_NOEMPTY_HOST ) + && ludp->lud_host != NULL + && *ludp->lud_host == '\0' ) + { + LDAP_FREE( ludp->lud_host ); + ludp->lud_host = NULL; + } + /* * Kludge. ldap://111.222.333.444:389??cn=abc,o=company * @@ -908,11 +928,15 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) /* parse dn part */ ldap_pvt_hex_unescape( q ); ludp->lud_dn = LDAP_STRDUP( q ); - } else { + + } else if ( !( flags & LDAP_PVT_URL_PARSE_NOEMPTY_DN ) ) { ludp->lud_dn = LDAP_STRDUP( "" ); + + } else { + check_dn = 0; } - if( ludp->lud_dn == NULL ) { + if ( check_dn && ludp->lud_dn == NULL ) { LDAP_FREE( url ); ldap_free_urldesc( ludp ); return LDAP_URL_ERR_MEM; @@ -938,11 +962,15 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) /* parse dn part */ ldap_pvt_hex_unescape( p ); ludp->lud_dn = LDAP_STRDUP( p ); - } else { + + } else if ( !( flags & LDAP_PVT_URL_PARSE_NOEMPTY_DN ) ) { ludp->lud_dn = LDAP_STRDUP( "" ); + + } else { + check_dn = 0; } - if( ludp->lud_dn == NULL ) { + if( check_dn && ludp->lud_dn == NULL ) { LDAP_FREE( url ); ldap_free_urldesc( ludp ); return LDAP_URL_ERR_MEM; @@ -995,7 +1023,7 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) if( *p != '\0' ) { /* parse the scope */ ldap_pvt_hex_unescape( p ); - ludp->lud_scope = str2scope( p ); + ludp->lud_scope = ldap_pvt_str2scope( p ); if( ludp->lud_scope == -1 ) { LDAP_FREE( url ); @@ -1092,34 +1120,7 @@ ldap_url_parse_ext( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) int ldap_url_parse( LDAP_CONST char *url_in, LDAPURLDesc **ludpp ) { - int rc = ldap_url_parse_ext( url_in, ludpp ); - - if( rc != LDAP_URL_SUCCESS ) { - return rc; - } - - if ((*ludpp)->lud_scope == LDAP_SCOPE_DEFAULT) { - (*ludpp)->lud_scope = LDAP_SCOPE_BASE; - } - - if ((*ludpp)->lud_host != NULL && *(*ludpp)->lud_host == '\0') { - LDAP_FREE( (*ludpp)->lud_host ); - (*ludpp)->lud_host = NULL; - } - - if ((*ludpp)->lud_port == 0) { - if( strcmp((*ludpp)->lud_scheme, "ldap") == 0 ) { - (*ludpp)->lud_port = LDAP_PORT; -#ifdef LDAP_CONNECTIONLESS - } else if( strcmp((*ludpp)->lud_scheme, "cldap") == 0 ) { - (*ludpp)->lud_port = LDAP_PORT; -#endif - } else if( strcmp((*ludpp)->lud_scheme, "ldaps") == 0 ) { - (*ludpp)->lud_port = LDAPS_PORT; - } - } - - return rc; + return ldap_url_parse_ext( url_in, ludpp, LDAP_PVT_URL_PARSE_HISTORIC ); } LDAPURLDesc * @@ -1218,8 +1219,8 @@ ldap_url_duplist (LDAPURLDesc *ludlist) } static int -ldap_url_parselist_int (LDAPURLDesc **ludlist, const char *url, const char *sep, - int (*url_parse)( const char *, LDAPURLDesc ** ) ) +ldap_url_parselist_int (LDAPURLDesc **ludlist, const char *url, const char *sep, unsigned flags ) + { int i, rc; LDAPURLDesc *ludp; @@ -1230,7 +1231,11 @@ ldap_url_parselist_int (LDAPURLDesc **ludlist, const char *url, const char *sep, *ludlist = NULL; - urls = ldap_str2charray(url, sep); + if ( sep == NULL ) { + sep = ", "; + } + + urls = ldap_str2charray( url, sep ); if (urls == NULL) return LDAP_URL_ERR_MEM; @@ -1238,30 +1243,30 @@ ldap_url_parselist_int (LDAPURLDesc **ludlist, const char *url, const char *sep, for (i = 0; urls[i] != NULL; i++) ; /* ...and put them in the "stack" backward */ while (--i >= 0) { - rc = url_parse( urls[i], &ludp ); + rc = ldap_url_parse_ext( urls[i], &ludp, flags ); if ( rc != 0 ) { - ldap_charray_free(urls); - ldap_free_urllist(*ludlist); + ldap_charray_free( urls ); + ldap_free_urllist( *ludlist ); *ludlist = NULL; return rc; } ludp->lud_next = *ludlist; *ludlist = ludp; } - ldap_charray_free(urls); + ldap_charray_free( urls ); return LDAP_URL_SUCCESS; } int ldap_url_parselist (LDAPURLDesc **ludlist, const char *url ) { - return ldap_url_parselist_int( ludlist, url, ", ", ldap_url_parse ); + return ldap_url_parselist_int( ludlist, url, ", ", LDAP_PVT_URL_PARSE_HISTORIC ); } int -ldap_url_parselist_ext (LDAPURLDesc **ludlist, const char *url, const char *sep ) +ldap_url_parselist_ext (LDAPURLDesc **ludlist, const char *url, const char *sep, unsigned flags ) { - return ldap_url_parselist_int( ludlist, url, sep, ldap_url_parse_ext ); + return ldap_url_parselist_int( ludlist, url, sep, flags ); } int @@ -1309,12 +1314,18 @@ ldap_url_parsehosts( specs[i] = ludp->lud_host; ludp->lud_host = p; p = strchr( ludp->lud_host, ']' ); - if ( p == NULL ) + if ( p == NULL ) { + LDAP_FREE(ludp); + ldap_charray_free(specs); return LDAP_PARAM_ERROR; + } *p++ = '\0'; if ( *p != ':' ) { - if ( *p != '\0' ) + if ( *p != '\0' ) { + LDAP_FREE(ludp); + ldap_charray_free(specs); return LDAP_PARAM_ERROR; + } p = NULL; } } else { @@ -1328,6 +1339,8 @@ ldap_url_parsehosts( ldap_pvt_hex_unescape(p); ludp->lud_port = strtol( p, &next, 10 ); if ( next == p || next[0] != '\0' ) { + LDAP_FREE(ludp); + ldap_charray_free(specs); return LDAP_PARAM_ERROR; } }