← Back to branch summary

~ubuntu-branches/ubuntu/maverick/openldap/maverick-proposed

« back to all changes in this revision

Viewing changes to libraries/libldap/result.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug, Steve Langasek, Mathias Gug
  • Date: 2009-02-18 18:44:00 UTC
  • mfrom: (1.1.2 upstream) (0.1.2 lenny)
  • Revision ID: james.westby@ubuntu.com-20090218184400-zw4mjse9eywt5566
Tags: 2.4.14-0ubuntu1
http://bugs.debian.org/497697
http://bugs.debian.org/421946
https://launchpad.net/bugs/203529
https://launchpad.net/bugs/286063
https://launchpad.net/bugs/288908
https://launchpad.net/bugs/257667
[ Steve Langasek ]
* New upstream version
  - Fixes a bug with the pcache overlay not returning cached entries
    (closes: #497697)
  - Update evolution-ntlm patch to apply to current Makefiles.
  - (tentatively) drop gnutls-ciphers, since this bug was reported to be
    fixed upstream in 2.4.8.  The fix applied in 2.4.8 didn't match the
    patch from the bug report, so this should be watched for regressions.
* Build against db4.7 instead of db4.2 at last!  Closes: #421946.
* Build with --disable-ndb, to avoid a misbuild when libmysqlclient is
  installed in the build environment.
* New patch, no-crlcheck-for-gnutls, to fix a build failure when using
  --with-tls=gnutls.

[ Mathias Gug ]
* Merge from debian unstable, remaining changes:
  - debian/apparmor-profile: add AppArmor profile
  - debian/slapd.postinst: Reload AA profile on configuration
  - updated debian/slapd.README.Debian for note on AppArmor
  - debian/control: Recommends apparmor >= 2.1+1075-0ubuntu6
  - debian/control: Conflicts with apparmor-profiles << 2.1+1075-0ubuntu4
    to make sure that if earlier version of apparmour-profiles gets
    installed it won't overwrite our profile.
  - Modify Maintainer value to match the DebianMaintainerField
    speficication.
  - follow ApparmorProfileMigration and force apparmor compalin mode on 
    some upgrades (LP: #203529)
  - debian/slapd.dirs: add etc/apparmor.d/force-complain
  - debian/slapd.preinst: create symlink for force-complain on pre-feisty
    upgrades, upgrades where apparmor-profiles profile is unchanged (ie
    non-enforcing) and upgrades where apparmor profile does not exist.
  - debian/slapd.postrm: remove symlink in force-complain/ on purge
  - debian/patches/fix-ucred-libc due to changes how newer glibc handle
    the ucred struct now.
  - debian/control:
    - Build-depend on libltdl7-dev rather then libltdl3-dev.
  - debian/patches/autogen.sh:
    - Call libtoolize with the --install option to install config.{guess,sub}
      files.
  - Don't use local statement in config script as it fails if /bin/sh
    points to bash (LP: #286063).
  - Disable the testsuite on hppa. Allows building of packages on this
    architecture again, once this package is in the archive.
    LP: #288908.
  - debian/slapd.postinst, debian/slapd.script-common: set correct ownership
    and permissions on /var/lib/ldap, /etc/ldap/slapd.d (group readable) and
    /var/run/slapd (world readable). (LP: #257667).
  - debian/patches/nssov-build, debian/rules: 
    Build and package the nss overlay.
    debian/schema/misc.ldif: add ldif file for the misc schema, which defines
    rfc822MailMember (required by the nss overlay).
  - debian/{control,rules}: enable PIE hardening
  - Use cn=config as the default configuration backend instead of 
    slapd.conf. Migrate slapd.conf  file to /etc/ldap/slapd.d/ on upgrade
    asking the end user to enter a new password to control the access to the
    cn=config tree.
* debian/patches/corrupt-contextCSN: The contextCSN can get corrupted at
  times. (ITS: #5947)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libraries/libldap/result.c
1
1
/* result.c - wait for an ldap result */
2
 
/* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.124.2.12 2008/07/09 23:16:48 quanah Exp $ */
 
2
/* $OpenLDAP: pkg/ldap/libraries/libldap/result.c,v 1.124.2.17 2009/02/10 23:42:16 quanah Exp $ */
3
3
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4
4
 *
5
 
 * Copyright 1998-2008 The OpenLDAP Foundation.
 
5
 * Copyright 1998-2009 The OpenLDAP Foundation.
6
6
 * All rights reserved.
7
7
 *
8
8
 * Redistribution and use in source and binary forms, with or without
71
71
static int wait4msg LDAP_P(( LDAP *ld, ber_int_t msgid, int all, struct timeval *timeout,
72
72
        LDAPMessage **result ));
73
73
static ber_tag_t try_read1msg LDAP_P(( LDAP *ld, ber_int_t msgid,
74
 
        int all, LDAPConn **lc, LDAPMessage **result ));
 
74
        int all, LDAPConn *lc, LDAPMessage **result ));
75
75
static ber_tag_t build_result_ber LDAP_P(( LDAP *ld, BerElement **bp, LDAPRequest *lr ));
76
76
static void merge_error_info LDAP_P(( LDAP *ld, LDAPRequest *parentr, LDAPRequest *lr ));
77
77
static LDAPMessage * chkResponseList LDAP_P(( LDAP *ld, int msgid, int all));
106
106
        struct timeval *timeout,
107
107
        LDAPMessage **result )
108
108
{
109
 
        LDAPMessage     *lm = NULL;
 
109
        LDAPMessage     *lm;
110
110
        int             rc;
111
111
 
112
112
        assert( ld != NULL );
118
118
        ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex );
119
119
#endif
120
120
 
121
 
#if 0
122
 
        /* this is already done inside wait4msg(), right?... */
123
 
        lm = chkResponseList( ld, msgid, all );
124
 
#endif
125
 
 
126
 
        if ( lm == NULL ) {
127
 
                rc = wait4msg( ld, msgid, all, timeout, result );
128
 
 
129
 
        } else {
130
 
                *result = lm;
131
 
                ld->ld_errno = LDAP_SUCCESS;
132
 
                rc = lm->lm_msgtype;
133
 
        }
 
121
        rc = wait4msg( ld, msgid, all, timeout, result );
134
122
 
135
123
#ifdef LDAP_R_COMPILE
136
124
        ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex );
335
323
                                if ( ber_sockbuf_ctrl( lc->lconn_sb,
336
324
                                        LBER_SB_OPT_DATA_READY, NULL ) )
337
325
                                {
338
 
#ifdef LDAP_R_COMPILE
339
 
                                        ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
340
 
#endif
341
 
                                        rc = try_read1msg( ld, msgid, all, &lc, result );
342
 
#ifdef LDAP_R_COMPILE
343
 
                                        ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
344
 
#endif
345
326
                                        lc_ready = 1;
346
327
                                        break;
347
328
                                }
375
356
                                        rc = LDAP_MSG_X_KEEP_LOOKING;   /* select interrupted: loop */
376
357
 
377
358
                                } else {
378
 
                                        rc = LDAP_MSG_X_KEEP_LOOKING;
379
 
#ifdef LDAP_R_COMPILE
380
 
                                        ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
381
 
#endif
382
 
                                        if ( ld->ld_requests &&
383
 
                                                ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
384
 
                                                ldap_is_write_ready( ld,
385
 
                                                        ld->ld_requests->lr_conn->lconn_sb ) )
386
 
                                        {
387
 
                                                ldap_int_flush_request( ld, ld->ld_requests );
388
 
                                        }
389
 
#ifdef LDAP_R_COMPILE
390
 
                                        ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
391
 
                                        ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
392
 
#endif
393
 
                                        for ( lc = ld->ld_conns;
394
 
                                                rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL; )
395
 
                                        {
396
 
                                                if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
397
 
                                                        ldap_is_read_ready( ld, lc->lconn_sb ) )
398
 
                                                {
399
 
#ifdef LDAP_R_COMPILE
400
 
                                                        ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
401
 
#endif
402
 
                                                        rc = try_read1msg( ld, msgid, all, &lc, result );
403
 
#ifdef LDAP_R_COMPILE
404
 
                                                        ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
405
 
#endif
406
 
                                                        if ( lc == NULL ) {
407
 
                                                                /* if lc gets free()'d,
408
 
                                                                 * there's no guarantee
409
 
                                                                 * lc->lconn_next is still
410
 
                                                                 * sane; better restart
411
 
                                                                 * (ITS#4405) */
412
 
                                                                lc = ld->ld_conns;
 
359
                                        lc_ready = 1;
 
360
                                }
 
361
                        }
 
362
                        if ( lc_ready ) {
 
363
                                LDAPConn *lnext;
 
364
                                rc = LDAP_MSG_X_KEEP_LOOKING;
 
365
#ifdef LDAP_R_COMPILE
 
366
                                ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
 
367
#endif
 
368
                                if ( ld->ld_requests &&
 
369
                                        ld->ld_requests->lr_status == LDAP_REQST_WRITING &&
 
370
                                        ldap_is_write_ready( ld,
 
371
                                                ld->ld_requests->lr_conn->lconn_sb ) )
 
372
                                {
 
373
                                        ldap_int_flush_request( ld, ld->ld_requests );
 
374
                                }
 
375
#ifdef LDAP_R_COMPILE
 
376
                                ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
 
377
                                ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 
378
#endif
 
379
                                for ( lc = ld->ld_conns;
 
380
                                        rc == LDAP_MSG_X_KEEP_LOOKING && lc != NULL;
 
381
                                        lc = lnext )
 
382
                                {
 
383
                                        if ( lc->lconn_status == LDAP_CONNST_CONNECTED &&
 
384
                                                ldap_is_read_ready( ld, lc->lconn_sb ) )
 
385
                                        {
 
386
                                                /* Don't let it get freed out from under us */
 
387
                                                ++lc->lconn_refcnt;
 
388
#ifdef LDAP_R_COMPILE
 
389
                                                ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
 
390
#endif
 
391
                                                rc = try_read1msg( ld, msgid, all, lc, result );
 
392
                                                lnext = lc->lconn_next;
413
393
 
414
 
                                                                /* don't get to next conn! */
415
 
                                                                break;
416
 
                                                        }
 
394
                                                /* Only take locks if we're really freeing */
 
395
                                                if ( lc->lconn_refcnt <= 1 ) {
 
396
#ifdef LDAP_R_COMPILE
 
397
                                                        ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
 
398
#endif
 
399
                                                        ldap_free_connection( ld, lc, 0, 1 );
 
400
#ifdef LDAP_R_COMPILE
 
401
                                                        ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
 
402
#endif
 
403
                                                } else {
 
404
                                                        --lc->lconn_refcnt;
417
405
                                                }
418
 
 
419
 
                                                /* next conn */
420
 
                                                lc = lc->lconn_next;
 
406
#ifdef LDAP_R_COMPILE
 
407
                                                ldap_pvt_thread_mutex_lock( &ld->ld_conn_mutex );
 
408
#endif
 
409
                                        } else {
 
410
                                                lnext = lc->lconn_next;
421
411
                                        }
422
 
#ifdef LDAP_R_COMPILE
423
 
                                        ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
424
 
#endif
425
412
                                }
 
413
#ifdef LDAP_R_COMPILE
 
414
                                ldap_pvt_thread_mutex_unlock( &ld->ld_conn_mutex );
 
415
#endif
426
416
                        }
427
417
                }
428
418
 
482
472
        LDAP *ld,
483
473
        ber_int_t msgid,
484
474
        int all,
485
 
        LDAPConn **lcp,
 
475
        LDAPConn *lc,
486
476
        LDAPMessage **result )
487
477
{
488
478
        BerElement      *ber;
493
483
        ber_len_t       len;
494
484
        int             foundit = 0;
495
485
        LDAPRequest     *lr, *tmplr, dummy_lr = { 0 };
496
 
        LDAPConn        *lc;
497
486
        BerElement      tmpber;
498
487
        int             rc, refer_cnt, hadref, simple_request, err;
499
488
        ber_int_t       lderr;
504
493
#endif
505
494
 
506
495
        assert( ld != NULL );
507
 
        assert( lcp != NULL );
508
 
        assert( *lcp != NULL );
 
496
        assert( lc != NULL );
509
497
        
510
498
#ifdef LDAP_R_COMPILE
511
499
        LDAP_PVT_THREAD_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex );
514
502
        Debug( LDAP_DEBUG_TRACE, "read1msg: ld %p msgid %d all %d\n",
515
503
                (void *)ld, msgid, all );
516
504
 
517
 
        lc = *lcp;
518
 
 
519
505
retry:
520
506
        if ( lc->lconn_ber == NULL ) {
521
507
                lc->lconn_ber = ldap_alloc_ber_with_options( ld );
561
547
                if ( err == EAGAIN ) return LDAP_MSG_X_KEEP_LOOKING;
562
548
#endif
563
549
                ld->ld_errno = LDAP_SERVER_DOWN;
564
 
#ifdef LDAP_R_COMPILE
565
 
                ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
566
 
#endif
567
 
                ldap_free_connection( ld, lc, 1, 0 );
568
 
#ifdef LDAP_R_COMPILE
569
 
                ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
570
 
#endif
571
 
                lc = *lcp = NULL;
 
550
                --lc->lconn_refcnt;
 
551
                lc->lconn_status = 0;
572
552
                return -1;
573
553
 
574
554
        default:
648
628
                        ber_scanf(ber, "x{");
649
629
                }
650
630
nextresp2:
 
631
                ;
651
632
#endif
652
633
        }
653
634
 
937
918
                         * shouldn't necessarily end the connection
938
919
                         */
939
920
                        if ( lc != NULL && id != 0 ) {
940
 
#ifdef LDAP_R_COMPILE
941
 
                                ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
942
 
#endif
943
 
                                ldap_free_connection( ld, lc, 0, 1 );
944
 
#ifdef LDAP_R_COMPILE
945
 
                                ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
946
 
#endif
947
 
                                lc = *lcp = NULL;
 
921
                                --lc->lconn_refcnt;
 
922
                                lc = NULL;
948
923
                        }
949
924
                }
950
925
        }
1010
985
 
1011
986
                        /* get rid of the connection... */
1012
987
                        if ( lc != NULL ) {
1013
 
#ifdef LDAP_R_COMPILE
1014
 
                                ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex );
1015
 
#endif
1016
 
                                ldap_free_connection( ld, lc, 0, 1 );
1017
 
#ifdef LDAP_R_COMPILE
1018
 
                                ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex );
1019
 
#endif
1020
 
                                lc = *lcp = NULL;
 
988
                                --lc->lconn_refcnt;
1021
989
                        }
1022
990
 
1023
991
                        /* need to return -1, because otherwise
1126
1094
        if ( msgid == LDAP_RES_ANY || id == msgid ) {
1127
1095
                if ( all == LDAP_MSG_ONE
1128
1096
                        || ( newmsg->lm_msgtype != LDAP_RES_SEARCH_RESULT
1129
 
                                && newmsg->lm_msgtype != LDAP_RES_SEARCH_ENTRY
 
1097
                                && newmsg->lm_msgtype != LDAP_RES_SEARCH_ENTRY
 
1098
                                && newmsg->lm_msgtype != LDAP_RES_INTERMEDIATE
1130
1099
                                && newmsg->lm_msgtype != LDAP_RES_SEARCH_REFERENCE ) )
1131
1100
                {
1132
1101
                        *result = newmsg;
1434
1403
 
1435
1404
        /* NOTE: those assertions are repeated in ldap_int_bisect_delete() */
1436
1405
        assert( idx >= 0 );
1437
 
        assert( idx < ld->ld_nabandoned );
 
1406
        assert( (unsigned) idx < ld->ld_nabandoned );
1438
1407
        assert( ld->ld_abandoned[ idx ] == msgid );
1439
1408
 
1440
1409
        return ldap_int_bisect_delete( &ld->ld_abandoned, &ld->ld_nabandoned,