X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fresult.c;h=228d4efdc4f666e39cae25e8f30820896a9f4fa4;hb=f89308915aabff352eb390a1e58a71127b7ebd26;hp=78b5f7d99c4a2c51833c01b6cf2d9e451bf9bbcb;hpb=448fc0e99a35e3b19b9e6f633dceac845616f0b1;p=openldap diff --git a/servers/slapd/result.c b/servers/slapd/result.c index 78b5f7d99c..228d4efdc4 100644 --- a/servers/slapd/result.c +++ b/servers/slapd/result.c @@ -1,5 +1,9 @@ /* result.c - routines to send ldap results, errors, and referrals */ /* $OpenLDAP$ */ +/* + * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ #include "portable.h" @@ -15,34 +19,44 @@ #include "slap.h" -/* we need LBER internals */ -#include "../../libraries/liblber/lber-int.h" - -static char *v2ref( struct berval **ref, const char *text ) +static char *v2ref( BerVarray ref, const char *text ) { size_t len = 0, i = 0; char *v2; - if(ref == NULL) return (char *)text; - - if (text) { + if(ref == NULL) { + if (text) { + return ch_strdup(text); + } else { + return NULL; + } + } + + if ( text != NULL ) { len = strlen( text ); - if (text[len-1] != '\n') + if (text[len-1] != '\n') { i = 1; + } } + v2 = ch_malloc( len+i+sizeof("Referral:") ); - if (text) { + if( text != NULL ) { strcpy(v2, text); - if (i) + if( i ) { v2[len++] = '\n'; + } } strcpy( v2+len, "Referral:" ); + len += sizeof("Referral:"); - for( i=0; ref[i] != NULL; i++ ) { - v2 = ch_realloc( v2, len + ref[i]->bv_len + 1 ); + for( i=0; ref[i].bv_val != NULL; i++ ) { + v2 = ch_realloc( v2, len + ref[i].bv_len + 1 ); v2[len-1] = '\n'; - memcpy(&v2[len], ref[i]->bv_val, ref[i]->bv_len ); - len += ref[i]->bv_len; + AC_MEMCPY(&v2[len], ref[i].bv_val, ref[i].bv_len ); + len += ref[i].bv_len; + if (ref[i].bv_val[ref[i].bv_len-1] != '/') { + ++len; + } } v2[len-1] = '\0'; @@ -75,96 +89,19 @@ static ber_tag_t req2res( ber_tag_t tag ) break; default: - assert( 0 ); - tag = LBER_ERROR; - } - return tag; -} - -static void trim_refs_urls( - struct berval **refs ) -{ - unsigned i; - - if( refs == NULL ) return; - - for( i=0; refs[i] != NULL; i++ ) { - if( refs[i]->bv_len > sizeof("ldap://")-1 && - strncasecmp( refs[i]->bv_val, "ldap://", - sizeof("ldap://")-1 ) == 0 ) - { - unsigned j; - for( j=sizeof("ldap://")-1; jbv_len ; j++ ) { - if( refs[i]->bv_val[j] == '/' ) { - refs[i]->bv_val[j] = '\0'; - refs[i]->bv_len = j; - break; - } - } - } - } -} - -struct berval **get_entry_referrals( - Backend *be, - Connection *conn, - Operation *op, - Entry *e ) -{ - Attribute *attr; - struct berval **refs; - unsigned i, j; - - attr = attr_find( e->e_attrs, "ref" ); - - if( attr == NULL ) return NULL; - - for( i=0; attr->a_vals[i] != NULL; i++ ) { - /* count references */ - } - - if( i < 1 ) return NULL; - - refs = ch_malloc( i + 1 ); - - for( i=0, j=0; attr->a_vals[i] != NULL; i++ ) { - unsigned k; - struct berval *ref = ber_bvdup( attr->a_vals[i] ); - - /* trim the label */ - for( k=0; kbv_len; k++ ) { - if( isspace(ref->bv_val[k]) ) { - ref->bv_val[k] = '\0'; - ref->bv_len = k; - break; - } - } - - if( ref->bv_len > 0 ) { - refs[j++] = ref; - - } else { - ber_bvfree( ref ); - } - } - - refs[j] = NULL; - - if( j == 0 ) { - ber_bvecfree( refs ); - refs = NULL; + tag = LBER_SEQUENCE; } - /* we should check that a referral value exists... */ - - return refs; + return tag; } static long send_ldap_ber( Connection *conn, BerElement *ber ) { - ber_len_t bytes = ber_pvt_ber_bytes( ber ); + ber_len_t bytes; + + ber_get_option( ber, LBER_OPT_BER_BYTES_TO_WRITE, &bytes ); /* write only one pdu at a time - wait til it's our turn */ ldap_pvt_thread_mutex_lock( &conn->c_write_mutex ); @@ -175,6 +112,7 @@ static long send_ldap_ber( /* write the pdu */ while( 1 ) { int err; + ber_socket_t sd; if ( connection_state_closing( conn ) ) { ldap_pvt_thread_mutex_unlock( &conn->c_mutex ); @@ -195,8 +133,14 @@ static long send_ldap_ber( * it's a hard error and return. */ +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_ldap_ber: conn %d ber_flush failed err=%d (%s)\n", + conn ? conn->c_connid : 0, err, sock_errstr(err) )); +#else Debug( LDAP_DEBUG_CONNS, "ber_flush failed errno=%d reason=\"%s\"\n", - err, STRERROR(err), 0 ); + err, sock_errstr(err), 0 ); +#endif if ( err != EWOULDBLOCK && err != EAGAIN ) { connection_closing( conn ); @@ -209,7 +153,8 @@ static long send_ldap_ber( /* wait for socket to be write-ready */ conn->c_writewaiter = 1; - slapd_set_write( ber_pvt_sb_get_desc( conn->c_sb ), 1 ); + ber_sockbuf_ctrl( conn->c_sb, LBER_SB_OPT_GET_FD, &sd ); + slapd_set_write( sd, 1 ); ldap_pvt_thread_cond_wait( &conn->c_write_cv, &conn->c_mutex ); conn->c_writewaiter = 0; @@ -230,72 +175,143 @@ send_ldap_response( ber_int_t err, const char *matched, const char *text, - struct berval **ref, + BerVarray ref, const char *resoid, struct berval *resdata, + struct berval *sasldata, LDAPControl **ctrls ) { - BerElement *ber; + char berbuf[256]; + BerElement *ber = (BerElement *)berbuf; int rc; long bytes; + if (op->o_callback && op->o_callback->sc_response) { + op->o_callback->sc_response( conn, op, tag, msgid, err, matched, + text, ref, resoid, resdata, sasldata, ctrls ); + return; + } + assert( ctrls == NULL ); /* ctrls not implemented */ - ber = ber_alloc_t( LBER_USE_DER ); + ber_init_w_nullc( ber, LBER_USE_DER ); - Debug( LDAP_DEBUG_TRACE, "send_ldap_response: msgid=%ld tag=%ld err=%ld\n", +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_ldap_response: conn %d msgid=%ld tag=%ld err=%ld\n", + conn ? conn->c_connid : 0, (long)msgid, (long)tag, (long)err )); +#else + Debug( LDAP_DEBUG_TRACE, + "send_ldap_response: msgid=%ld tag=%ld err=%ld\n", (long) msgid, (long) tag, (long) err ); +#endif + + if( ref ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ARGS, + "send_ldap_response: conn %d ref=\"%s\"\n", + conn ? conn->c_connid : 0, + ref[0].bv_val ? ref[0].bv_val : "NULL" )); +#else + Debug( LDAP_DEBUG_ARGS, "send_ldap_response: ref=\"%s\"\n", + ref[0].bv_val ? ref[0].bv_val : "NULL", + NULL, NULL ); +#endif - if ( ber == NULL ) { - Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 ); - return; } #ifdef LDAP_CONNECTIONLESS - if ( op->o_cldap ) { - rc = ber_printf( ber, "{is{t{ess}}}", msgid, "", tag, - err, matched ? matched : "", text ? text : "" ); + if (conn->c_is_udp) { + rc = ber_write(ber, (char *)&op->o_peeraddr, sizeof(struct sockaddr), 0); + if (rc != sizeof(struct sockaddr)) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_ldap_response: conn %d ber_write failed\n", + conn ? conn->c_connid : 0 )); +#else + Debug( LDAP_DEBUG_ANY, "ber_write failed\n", 0, 0, 0 ); +#endif + ber_free_buf( ber ); + return; + } + } + if (conn->c_is_udp && op->o_protocol == LDAP_VERSION2) { + rc = ber_printf( ber, "{is{t{ess", + msgid, "", tag, err, + matched == NULL ? "" : matched, + text == NULL ? "" : text ); } else #endif { - rc = ber_printf( ber, "{it{ess", - msgid, tag, err, - matched == NULL ? "" : matched, - text == NULL ? "" : text ); + rc = ber_printf( ber, "{it{ess", + msgid, tag, err, + matched == NULL ? "" : matched, + text == NULL ? "" : text ); + } - if( rc != -1 && ref != NULL ) { - rc = ber_printf( ber, "{V}", ref ); + if( rc != -1 ) { + if ( ref != NULL ) { + assert( err == LDAP_REFERRAL ); + rc = ber_printf( ber, "t{W}", + LDAP_TAG_REFERRAL, ref ); + } else { + assert( err != LDAP_REFERRAL ); } + } - if( rc != -1 && resoid != NULL ) { - rc = ber_printf( ber, "s", resoid ); - } + if( rc != -1 && sasldata != NULL ) { + rc = ber_printf( ber, "tO", + LDAP_TAG_SASL_RES_CREDS, sasldata ); + } - if( rc != -1 && resdata != NULL ) { - rc = ber_printf( ber, "O", resdata ); + if( rc != -1 && resoid != NULL ) { + rc = ber_printf( ber, "ts", + LDAP_TAG_EXOP_RES_OID, resoid ); + } - } + if( rc != -1 && resdata != NULL ) { + rc = ber_printf( ber, "tO", + LDAP_TAG_EXOP_RES_VALUE, resdata ); + } - if( rc != -1 ) { - rc = ber_printf( ber, "}}" ); - } + if( rc != -1 ) { + rc = ber_printf( ber, "N}N}" ); } +#ifdef LDAP_CONNECTIONLESS + if( conn->c_is_udp && op->o_protocol == LDAP_VERSION2 && rc != -1 ) { + rc = ber_printf( ber, "N}" ); + } +#endif if ( rc == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_ldap_response: conn %d ber_printf failed\n", + conn ? conn->c_connid : 0 )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); +#endif + + ber_free_buf( ber ); return; } /* send BER */ bytes = send_ldap_ber( conn, ber ); - ber_free( ber, 1 ); + ber_free_buf( ber ); if ( bytes < 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_ldap_response: conn %d ber write failed\n", + conn ? conn->c_connid : 0 )); +#else Debug( LDAP_DEBUG_ANY, "send_ldap_response: ber write failed\n", 0, 0, 0 ); +#endif + return; } @@ -326,9 +342,16 @@ send_ldap_disconnect( assert( LDAP_UNSOLICITED_ERROR( err ) ); +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_ldap_disconnect: conn %d %d:%s\n", + conn ? conn->c_connid : 0, err, text ? text : "" )); +#else Debug( LDAP_DEBUG_TRACE, "send_ldap_disconnect %d:%s\n", err, text ? text : "", NULL ); +#endif + if ( op->o_protocol < LDAP_VERSION3 ) { reqoid = NULL; @@ -341,24 +364,14 @@ send_ldap_disconnect( msgid = 0; } -#ifdef LDAP_CONNECTIONLESS - if ( op->o_cldap ) { - ber_pvt_sb_udp_set_dst( conn->c_sb, &op->o_clientaddr ); - Debug( LDAP_DEBUG_TRACE, "UDP response to %s port %d\n", - inet_ntoa(((struct sockaddr_in *) - &op->o_clientaddr)->sin_addr ), - ((struct sockaddr_in *) &op->o_clientaddr)->sin_port, - 0 ); - } -#endif send_ldap_response( conn, op, tag, msgid, err, NULL, text, NULL, - reqoid, NULL, NULL ); + reqoid, NULL, NULL, NULL ); Statslog( LDAP_DEBUG_STATS, - "conn=%ld op=%ld DISCONNECT err=%ld tag=%lu text=%s\n", + "conn=%ld op=%ld DISCONNECT tag=%lu err=%ld text=%s\n", (long) op->o_connid, (long) op->o_opid, - (long) tag, (long) err, text ? text : "" ); + (unsigned long) tag, (long) err, text ? text : "" ); } void @@ -368,7 +381,7 @@ send_ldap_result( ber_int_t err, const char *matched, const char *text, - struct berval **ref, + BerVarray ref, LDAPControl **ctrls ) { @@ -378,17 +391,42 @@ send_ldap_result( assert( !LDAP_API_ERROR( err ) ); - Debug( LDAP_DEBUG_TRACE, "send_ldap_result: conn=%ld op=%ld p=%d\n", +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_ldap_result : conn %ld op=%ld p=%d\n", + (long)op->o_connid, (long)op->o_opid, op->o_protocol )); +#else + Debug( LDAP_DEBUG_TRACE, + "send_ldap_result: conn=%ld op=%ld p=%d\n", (long) op->o_connid, (long) op->o_opid, op->o_protocol ); - Debug( LDAP_DEBUG_ARGS, "send_ldap_result: %d:%s:%s\n", - err, matched ? matched : "", text ? text : "" ); +#endif + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ARGS, + "send_ldap_result: conn=%ld err=%d matched=\"%s\" text=\"%s\"\n", + (long)op->o_connid, err, matched ? matched : "", text ? text : "" )); +#else + Debug( LDAP_DEBUG_ARGS, + "send_ldap_result: err=%d matched=\"%s\" text=\"%s\"\n", + err, matched ? matched : "", text ? text : "" ); +#endif - assert( err != LDAP_PARTIAL_RESULTS ); - if( op->o_tag != LDAP_REQ_SEARCH ) { - trim_refs_urls( ref ); + if( ref ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ARGS, + "send_ldap_result: referral=\"%s\"\n", + ref[0].bv_val ? ref[0].bv_val : "NULL" )); +#else + Debug( LDAP_DEBUG_ARGS, + "send_ldap_result: referral=\"%s\"\n", + ref[0].bv_val ? ref[0].bv_val : "NULL", + NULL, NULL ); +#endif } + assert( err != LDAP_PARTIAL_RESULTS ); + if ( err == LDAP_REFERRAL ) { if( ref == NULL ) { err = LDAP_NO_SUCH_OBJECT; @@ -406,31 +444,91 @@ send_ldap_result( tag = req2res( op->o_tag ); msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0; -#ifdef LDAP_CONNECTIONLESS - if ( op->o_cldap ) { - ber_pvt_sb_udp_set_dst( conn->c_sb, &op->o_clientaddr ); - Debug( LDAP_DEBUG_TRACE, "UDP response to %s port %d\n", - inet_ntoa(((struct sockaddr_in *) - &op->o_clientaddr)->sin_addr ), - ((struct sockaddr_in *) &op->o_clientaddr)->sin_port, - 0 ); - } -#endif - send_ldap_response( conn, op, tag, msgid, err, matched, text, ref, - NULL, NULL, ctrls ); + NULL, NULL, NULL, ctrls ); Statslog( LDAP_DEBUG_STATS, "conn=%ld op=%ld RESULT tag=%lu err=%ld text=%s\n", (long) op->o_connid, (long) op->o_opid, - (long) tag, (long) err, text ? text : "" ); + (unsigned long) tag, (long) err, text ? text : "" ); if( tmp != NULL ) { - free(tmp); + ch_free(tmp); } } +void +send_ldap_sasl( + Connection *conn, + Operation *op, + ber_int_t err, + const char *matched, + const char *text, + BerVarray ref, + LDAPControl **ctrls, + struct berval *cred +) +{ + ber_tag_t tag; + ber_int_t msgid; + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_ldap_sasl: conn %d err=%ld len=%ld\n", + op->o_connid, (long)err, cred ? cred->bv_len : -1 )); +#else + Debug( LDAP_DEBUG_TRACE, "send_ldap_sasl: err=%ld len=%ld\n", + (long) err, cred ? cred->bv_len : -1, NULL ); +#endif + + + tag = req2res( op->o_tag ); + msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0; + + send_ldap_response( conn, op, tag, msgid, + err, matched, text, ref, + NULL, NULL, cred, ctrls ); +} + +void +send_ldap_extended( + Connection *conn, + Operation *op, + ber_int_t err, + const char *matched, + const char *text, + BerVarray refs, + const char *rspoid, + struct berval *rspdata, + LDAPControl **ctrls +) +{ + ber_tag_t tag; + ber_int_t msgid; + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_ldap_extended: conn %d err=%ld oid=%s len=%ld\n", + op->o_connid, (long)err, rspoid ? rspoid : "", + rspdata != NULL ? (long)rspdata->bv_len : (long)0 )); +#else + Debug( LDAP_DEBUG_TRACE, + "send_ldap_extended err=%ld oid=%s len=%ld\n", + (long) err, + rspoid ? rspoid : "", + rspdata != NULL ? (long) rspdata->bv_len : (long) 0 ); +#endif + + + tag = req2res( op->o_tag ); + msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0; + + send_ldap_response( conn, op, tag, msgid, + err, matched, text, refs, + rspoid, rspdata, NULL, ctrls ); +} + void send_search_result( @@ -439,7 +537,7 @@ send_search_result( ber_int_t err, const char *matched, const char *text, - struct berval **refs, + BerVarray refs, LDAPControl **ctrls, int nentries ) @@ -447,14 +545,28 @@ send_search_result( ber_tag_t tag; ber_int_t msgid; char *tmp = NULL; + assert( !LDAP_API_ERROR( err ) ); - Debug( LDAP_DEBUG_TRACE, "send_ldap_search_result %d:%s:%s\n", - err, matched ? matched : "", text ? text : "" ); + if (op->o_callback && op->o_callback->sc_sresult) { + op->o_callback->sc_sresult(conn, op, err, matched, text, refs, + ctrls, nentries); + return; + } + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_search_result: conn %d err=%d matched=\"%s\"\n", + op->o_connid, err, matched ? matched : "", + text ? text : "" )); +#else + Debug( LDAP_DEBUG_TRACE, + "send_search_result: err=%d matched=\"%s\" text=\"%s\"\n", + err, matched ? matched : "", text ? text : "" ); +#endif - assert( err != LDAP_PARTIAL_RESULTS ); - trim_refs_urls( refs ); + assert( err != LDAP_PARTIAL_RESULTS ); if( op->o_protocol < LDAP_VERSION3 ) { /* send references in search results */ @@ -465,6 +577,7 @@ send_search_result( tmp = v2ref( refs, text ); text = tmp; refs = NULL; + } else { /* don't send references in search results */ assert( refs == NULL ); @@ -478,28 +591,24 @@ send_search_result( tag = req2res( op->o_tag ); msgid = (tag != LBER_SEQUENCE) ? op->o_msgid : 0; -#ifdef LDAP_CONNECTIONLESS - if ( op->o_cldap ) { - ber_pvt_sb_udp_set_dst( conn->c_sb, &op->o_clientaddr ); - Debug( LDAP_DEBUG_TRACE, "UDP response to %s port %d\n", - inet_ntoa(((struct sockaddr_in *) - &op->o_clientaddr)->sin_addr ), - ((struct sockaddr_in *) &op->o_clientaddr)->sin_port, - 0 ); - } -#endif - send_ldap_response( conn, op, tag, msgid, err, matched, text, refs, - NULL, NULL, ctrls ); + NULL, NULL, NULL, ctrls ); Statslog( LDAP_DEBUG_STATS, "conn=%ld op=%ld SEARCH RESULT tag=%lu err=%ld text=%s\n", (long) op->o_connid, (long) op->o_opid, - (long) tag, (long) err, text ? text : "" ); + (unsigned long) tag, (long) err, text ? text : "" ); + if (tmp != NULL) { + ch_free(tmp); + } } +static struct berval AllUser = { sizeof(LDAP_ALL_USER_ATTRIBUTES)-1, + LDAP_ALL_USER_ATTRIBUTES }; +static struct berval AllOper = { sizeof(LDAP_ALL_OPERATIONAL_ATTRIBUTES)-1, + LDAP_ALL_OPERATIONAL_ATTRIBUTES }; int send_search_entry( @@ -507,220 +616,359 @@ send_search_entry( Connection *conn, Operation *op, Entry *e, - char **attrs, + AttributeName *attrs, int attrsonly, LDAPControl **ctrls ) { - BerElement *ber; - Attribute *a; + char berbuf[256]; + BerElement *ber = (BerElement *)berbuf; + Attribute *a, *aa; int i, rc=-1, bytes; - char *edn; + char *edn; int userattrs; int opattrs; - Debug( LDAP_DEBUG_TRACE, "=> send_search_entry: \"%s\"\n", e->e_dn, 0, 0 ); + AttributeDescription *ad_entry = slap_schema.si_ad_entry; + + if (op->o_callback && op->o_callback->sc_sendentry) { + return op->o_callback->sc_sendentry( be, conn, op, e, attrs, + attrsonly, ctrls ); + } + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_search_entry: conn %d dn=\"%s\"%s\n", + op->o_connid, e->e_dn, + attrsonly ? " (attrsOnly)" : "" )); +#else + Debug( LDAP_DEBUG_TRACE, + "=> send_search_entry: dn=\"%s\"%s\n", + e->e_dn, attrsonly ? " (attrsOnly)" : "", 0 ); +#endif + if ( ! access_allowed( be, conn, op, e, - "entry", NULL, ACL_READ ) ) + ad_entry, NULL, ACL_READ ) ) { - Debug( LDAP_DEBUG_ACL, "acl: access to entry not allowed\n", +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_entry: conn %d access to entry (%s) not allowed\n", + op->o_connid, e->e_dn )); +#else + Debug( LDAP_DEBUG_ACL, + "send_search_entry: access to entry not allowed\n", 0, 0, 0 ); +#endif + return( 1 ); } edn = e->e_ndn; - ber = ber_alloc_t( LBER_USE_DER ); + ber_init_w_nullc( ber, LBER_USE_DER ); - if ( ber == NULL ) { - Debug( LDAP_DEBUG_ANY, "ber_alloc failed\n", 0, 0, 0 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "allocating BER error", NULL, NULL ); - goto error_return; +#ifdef LDAP_CONNECTIONLESS + if (conn->c_is_udp) { + rc = ber_write(ber, (char *)&op->o_peeraddr, sizeof(struct sockaddr), 0); + if (rc != sizeof(struct sockaddr)) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + conn ? conn->c_connid : 0 )); +#else + Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); +#endif + ber_free_buf( ber ); + return; + } + } + if (conn->c_is_udp && op->o_protocol == LDAP_VERSION2) { + rc = ber_printf( ber, "{is{t{O{" /*}}}*/, + op->o_msgid, "", LDAP_RES_SEARCH_ENTRY, &e->e_name ); + } else +#endif + { + rc = ber_printf( ber, "{it{O{" /*}}}*/, op->o_msgid, + LDAP_RES_SEARCH_ENTRY, &e->e_name ); } - - rc = ber_printf( ber, "{it{s{", op->o_msgid, - LDAP_RES_SEARCH_ENTRY, e->e_dn ); if ( rc == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encoding dn error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encoding DN error", NULL, NULL ); goto error_return; } /* check for special all user attributes ("*") type */ userattrs = ( attrs == NULL ) ? 1 - : charray_inlist( attrs, LDAP_ALL_USER_ATTRIBUTES ); + : an_find( attrs, &AllUser ); /* check for special all operational attributes ("+") type */ opattrs = ( attrs == NULL ) ? 0 - : charray_inlist( attrs, LDAP_ALL_OPERATIONAL_ATTRIBUTES ); + : an_find( attrs, &AllOper ); for ( a = e->e_attrs; a != NULL; a = a->a_next ) { + AttributeDescription *desc = a->a_desc; + if ( attrs == NULL ) { - /* all addrs request, skip operational attributes */ - if( !opattrs && oc_check_operational_attr( a->a_type ) ) { + /* all attrs request, skip operational attributes */ + if( is_at_operational( desc->ad_type ) ) { continue; } } else { - /* specific addrs requested */ - if ( oc_check_operational_attr( a->a_type ) ) { - if( !opattrs && !charray_inlist( attrs, a->a_type ) ) - { + /* specific attrs requested */ + if ( is_at_operational( desc->ad_type ) ) { + if( !opattrs && !ad_inlist( desc, attrs ) ) { continue; } + } else { - if (!userattrs && !charray_inlist( attrs, a->a_type ) ) - { + if (!userattrs && !ad_inlist( desc, attrs ) ) { continue; } } } - if ( ! access_allowed( be, conn, op, e, - a->a_type, NULL, ACL_READ ) ) - { - Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s not allowed\n", - a->a_type, 0, 0 ); + if ( ! access_allowed( be, conn, op, e, desc, NULL, ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, "send_search_entry: " + "conn %d access to attribute %s not allowed\n", + op->o_connid, desc->ad_cname.bv_val )); +#else + Debug( LDAP_DEBUG_ACL, "acl: " + "access to attribute %s not allowed\n", + desc->ad_cname.bv_val, 0, 0 ); +#endif + continue; } - if (( rc = ber_printf( ber, "{s[" /*]}*/ , a->a_type )) == -1 ) { + if (( rc = ber_printf( ber, "{O[" /*]}*/ , &desc->ad_cname )) == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encoding type error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encoding description error", NULL, NULL ); goto error_return; } if ( ! attrsonly ) { - for ( i = 0; a->a_vals[i] != NULL; i++ ) { + for ( i = 0; a->a_vals[i].bv_val != NULL; i++ ) { if ( ! access_allowed( be, conn, op, e, - a->a_type, a->a_vals[i], ACL_READ ) ) + desc, &a->a_vals[i], ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_entry: conn %d access to attribute %s, value %d not allowed\n", + op->o_connid, desc->ad_cname.bv_val, i )); +#else Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s, value %d not allowed\n", - a->a_type, i, 0 ); + desc->ad_cname.bv_val, i, 0 ); +#endif + continue; } - if (( rc = ber_printf( ber, "O", a->a_vals[i] )) == -1 ) { + if (( rc = ber_printf( ber, "O", &a->a_vals[i] )) == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed.\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encoding value error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encoding values error", NULL, NULL ); goto error_return; } } } - if (( rc = ber_printf( ber, /*{[*/ "]}" )) == -1 ) { + if (( rc = ber_printf( ber, /*{[*/ "]N}" )) == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, NULL, "encode end error", NULL, NULL ); goto error_return; } } -#ifdef SLAPD_SCHEMA_DN /* eventually will loop through generated operational attributes */ /* only have subschemaSubentry implemented */ - a = backend_subschemasubentry( be ); + aa = backend_operational( be, conn, op, e, attrs, opattrs ); - do { + for (a = aa ; a != NULL; a = a->a_next ) { + AttributeDescription *desc = a->a_desc; + if ( attrs == NULL ) { - /* all addrs request, skip operational attributes */ - if( !opattrs && oc_check_operational_attr( a->a_type ) ) { + /* all attrs request, skip operational attributes */ + if( is_at_operational( desc->ad_type ) ) { continue; } } else { - /* specific addrs requested */ - if ( oc_check_operational_attr( a->a_type ) ) { - if( !opattrs && !charray_inlist( attrs, a->a_type ) ) - { + /* specific attrs requested */ + if( is_at_operational( desc->ad_type ) ) { + if( !opattrs && !ad_inlist( desc, attrs ) ) { continue; } } else { - if (!userattrs && !charray_inlist( attrs, a->a_type ) ) + if (!userattrs && !ad_inlist( desc, attrs ) ) { continue; } } } - if ( ! access_allowed( be, conn, op, e, - a->a_type, NULL, ACL_READ ) ) - { + if ( ! access_allowed( be, conn, op, e, desc, NULL, ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_entry: conn %s access to attribute %s not allowed\n", + op->o_connid, desc->ad_cname.bv_val )); +#else Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s not allowed\n", - a->a_type, 0, 0 ); + desc->ad_cname.bv_val, 0, 0 ); +#endif + continue; } - if (( rc = ber_printf( ber, "{s[" /*]}*/ , a->a_type )) == -1 ) { + rc = ber_printf( ber, "{O[" /*]}*/ , &desc->ad_cname ); + if ( rc == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encoding type error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encoding description error", NULL, NULL ); + attrs_free( aa ); goto error_return; } if ( ! attrsonly ) { - for ( i = 0; a->a_vals[i] != NULL; i++ ) { + for ( i = 0; a->a_vals[i].bv_val != NULL; i++ ) { if ( ! access_allowed( be, conn, op, e, - a->a_type, a->a_vals[i], ACL_READ ) ) + desc, &a->a_vals[i], ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_entry: conn %d access to %s, value %d not allowed\n", + op->o_connid, desc->ad_cname.bv_val, i )); +#else Debug( LDAP_DEBUG_ACL, "acl: access to attribute %s, value %d not allowed\n", - a->a_type, i, 0 ); + desc->ad_cname.bv_val, i, 0 ); +#endif + continue; } - if (( rc = ber_printf( ber, "O", a->a_vals[i] )) == -1 ) { + if (( rc = ber_printf( ber, "O", &a->a_vals[i] )) == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encoding value error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encoding values error", NULL, NULL ); + attrs_free( aa ); goto error_return; } } } - if (( rc = ber_printf( ber, /*{[*/ "]}" )) == -1 ) { + if (( rc = ber_printf( ber, /*{[*/ "]N}" )) == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, NULL, "encode end error", NULL, NULL ); + attrs_free( aa ); goto error_return; } - } while (0); -#endif + } + + attrs_free( aa ); - rc = ber_printf( ber, /*{{{*/ "}}}" ); + rc = ber_printf( ber, /*{{{*/ "}N}N}" ); +#ifdef LDAP_CONNECTIONLESS + if (conn->c_is_udp && op->o_protocol == LDAP_VERSION2 && rc != -1) + rc = ber_printf( ber, "}" ); +#endif if ( rc == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_entry: conn %d ber_printf failed\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, NULL, "encode entry end error", NULL, NULL ); return( 1 ); } bytes = send_ldap_ber( conn, ber ); - ber_free( ber, 1 ); + ber_free_buf( ber ); if ( bytes < 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_ldap_response: conn %d ber write failed.\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "send_ldap_response: ber write failed\n", 0, 0, 0 ); +#endif + return -1; } @@ -733,7 +981,14 @@ send_search_entry( Statslog( LDAP_DEBUG_STATS2, "conn=%ld op=%ld ENTRY dn=\"%s\"\n", (long) conn->c_connid, (long) op->o_opid, e->e_dn, 0, 0 ); +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_search_entry: conn %d exit.\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_TRACE, "<= send_search_entry\n", 0, 0, 0 ); +#endif + rc = 0; @@ -747,75 +1002,107 @@ send_search_reference( Connection *conn, Operation *op, Entry *e, - struct berval **refs, - int scope, + BerVarray refs, LDAPControl **ctrls, - struct berval ***v2refs + BerVarray *v2refs ) { - BerElement *ber; + char berbuf[256]; + BerElement *ber = (BerElement *)berbuf; int rc; int bytes; - Debug( LDAP_DEBUG_TRACE, "=> send_search_reference (%s)\n", e->e_dn, 0, 0 ); + AttributeDescription *ad_ref = slap_schema.si_ad_ref; + AttributeDescription *ad_entry = slap_schema.si_ad_entry; + +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_search_reference: conn %d dn=\"%s\"\n", + op->o_connid, e->e_dn )); +#else + Debug( LDAP_DEBUG_TRACE, + "=> send_search_reference: dn=\"%s\"\n", + e->e_dn, 0, 0 ); +#endif + if ( ! access_allowed( be, conn, op, e, - "entry", NULL, ACL_READ ) ) + ad_entry, NULL, ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_reference: conn %d access to entry %s not allowed\n", + op->o_connid, e->e_dn )); +#else Debug( LDAP_DEBUG_ACL, "send_search_reference: access to entry not allowed\n", 0, 0, 0 ); +#endif + return( 1 ); } if ( ! access_allowed( be, conn, op, e, - "ref", NULL, ACL_READ ) ) + ad_ref, NULL, ACL_READ ) ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "acl", LDAP_LEVEL_INFO, + "send_search_reference: conn %d access to reference not allowed.\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ACL, "send_search_reference: access to reference not allowed\n", 0, 0, 0 ); +#endif + return( 1 ); } if( refs == NULL ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_reference: null ref in (%s).\n", + op->o_connid, e->e_dn )); +#else Debug( LDAP_DEBUG_ANY, "send_search_reference: null ref in (%s)\n", e->e_dn, 0, 0 ); +#endif + return( 1 ); } if( op->o_protocol < LDAP_VERSION3 ) { /* save the references for the result */ - if( *refs == NULL ) { + if( refs[0].bv_val != NULL ) { value_add( v2refs, refs ); } return 0; } - ber = ber_alloc_t( LBER_USE_DER ); + ber_init_w_nullc( ber, LBER_USE_DER ); - if ( ber == NULL ) { - Debug( LDAP_DEBUG_ANY, - "send_search_reference: ber_alloc failed\n", 0, 0, 0 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "alloc BER error", NULL, NULL ); - return -1; - } - - rc = ber_printf( ber, "{it{V}}", op->o_msgid, + rc = ber_printf( ber, "{it{W}N}", op->o_msgid, LDAP_RES_SEARCH_REFERENCE, refs ); if ( rc == -1 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ERR, + "send_search_reference: conn %d ber_printf failed.\n", + op->o_connid )); +#else Debug( LDAP_DEBUG_ANY, "send_search_reference: ber_printf failed\n", 0, 0, 0 ); - ber_free( ber, 1 ); - send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, - NULL, "encode dn error", NULL, NULL ); +#endif + + ber_free_buf( ber ); + send_ldap_result( conn, op, LDAP_OTHER, + NULL, "encode DN error", NULL, NULL ); return -1; } bytes = send_ldap_ber( conn, ber ); - ber_free( ber, 1 ); + ber_free_buf( ber ); ldap_pvt_thread_mutex_lock( &num_sent_mutex ); num_bytes_sent += bytes; @@ -823,10 +1110,15 @@ send_search_reference( num_pdu_sent++; ldap_pvt_thread_mutex_unlock( &num_sent_mutex ); - Statslog( LDAP_DEBUG_STATS2, "conn=%ld op=%ld ENTRY dn=\"%s\"\n", - (long) conn->c_connid, (long) op->o_opid, e->e_dn, 0, 0 ); + Statslog( LDAP_DEBUG_STATS2, "conn=%ld op=%ld REF dn=\"%s\"\n", + (long) conn->c_connid, (long) op->o_opid, e->e_dn, 0, 0 ); +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_ENTRY, + "send_search_reference: conn %d exit.\n", op->o_connid )); +#else Debug( LDAP_DEBUG_TRACE, "<= send_search_reference\n", 0, 0, 0 ); +#endif return 0; } @@ -848,8 +1140,14 @@ str2result( *info = NULL; if ( strncasecmp( s, "RESULT", 6 ) != 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_INFO, + "str2result: (%s), expecting \"RESULT\"\n", s )); +#else Debug( LDAP_DEBUG_ANY, "str2result (%s) expecting \"RESULT\"\n", s, 0, 0 ); +#endif + return( -1 ); } @@ -877,8 +1175,14 @@ str2result( *info = c; } } else { +#ifdef NEW_LOGGING + LDAP_LOG(( "operation", LDAP_LEVEL_INFO, + "str2result: (%s) unknown.\n", s )); +#else Debug( LDAP_DEBUG_ANY, "str2result (%s) unknown\n", s, 0, 0 ); +#endif + rc = -1; } }