ITS#8284 olcRelay needs quotes

[openldap] / servers / slapd / result.c

diff --git a/servers/slapd/result.c b/servers/slapd/result.c
index 49d742933900c385fa858e09f43a20b82c9a10b8..a54e32844b8a6e5d3f6006aac7681b03c7940d1e 100644 (file)
--- a/servers/slapd/result.c
+++ b/servers/slapd/result.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2013 The OpenLDAP Foundation.
+ * Copyright 1998-2015 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -132,7 +132,21 @@ slap_req2res( ber_tag_t tag )
        return tag;
 }
 
-/* SlapReply debugging, prodo-slap.h overrides it in OpenLDAP releases */
+/*
+ * SlapReply debugging enabled by USE_RS_ASSERT.
+ *
+ * Disabled by default, but compiled in (but still unused) when
+ * LDAP_TEST.  #define USE_RS_ASSERT as nonzero to enable some
+ * assertions which check the SlapReply.  USE_RS_ASSERT = 2 or higher
+ * check aggressively, currently some code fail these tests.
+ *
+ * Environment variable $NO_RS_ASSERT controls how USE_RS_ASSERT handles
+ * errors.  > 0: ignore errors, 0: abort (the default), < 0: just warn.
+ *
+ * Wrap LDAP operation calls in macros SLAP_OP() & co from proto-slap.h
+ * to check the SlapReply.  contrib/slapd-tools/wrap_slap_ops converts
+ * source code to use the macros.
+ */
 #if defined(LDAP_TEST) || (defined(USE_RS_ASSERT) && (USE_RS_ASSERT))
 
 int rs_suppress_assert = 0;
@@ -279,6 +293,22 @@ rs_entry2modifiable( Operation *op, SlapReply *rs, slap_overinst *on )
        return 1;
 }
 
+/* Check for any callbacks that want to be informed about being blocked
+ * on output. These callbacks are expected to leave the callback list
+ * unmodified. Their result is ignored.
+ */
+static void
+slap_writewait_play(
+       Operation *op )
+{
+       slap_callback   *sc = op->o_callback;
+
+       for ( ; sc; sc = sc->sc_next ) {
+               if ( sc->sc_writewait )
+                       sc->sc_writewait( op, sc );
+       }
+}
+
 static long send_ldap_ber(
        Operation *op,
        BerElement *ber )
@@ -286,6 +316,7 @@ static long send_ldap_ber(
        Connection *conn = op->o_conn;
        ber_len_t bytes;
        long ret = 0;
+       char *close_reason;
 
        ber_get_option( ber, LBER_OPT_BER_BYTES_TO_WRITE, &bytes );
 
@@ -300,7 +331,9 @@ static long send_ldap_ber(
        conn->c_writers++;
 
        while ( conn->c_writers > 0 && conn->c_writing ) {
+               ldap_pvt_thread_pool_idle( &connection_pool );
                ldap_pvt_thread_cond_wait( &conn->c_write1_cv, &conn->c_write1_mutex );
+               ldap_pvt_thread_pool_unidle( &connection_pool );
        }
 
        /* connection was closed under us */
@@ -337,28 +370,37 @@ static long send_ldap_ber(
                    err, sock_errstr(err), 0 );
 
                if ( err != EWOULDBLOCK && err != EAGAIN ) {
+                       close_reason = "connection lost on write";
+fail:
                        conn->c_writers--;
                        conn->c_writing = 0;
                        ldap_pvt_thread_mutex_unlock( &conn->c_write1_mutex );
                        ldap_pvt_thread_mutex_lock( &conn->c_mutex );
-                       connection_closing( conn, "connection lost on write" );
-
+                       connection_closing( conn, close_reason );
                        ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
                        return -1;
                }
 
                /* wait for socket to be write-ready */
-               ldap_pvt_thread_mutex_lock( &conn->c_write2_mutex );
                conn->c_writewaiter = 1;
-               slapd_set_write( conn->c_sd, 2 );
-
                ldap_pvt_thread_mutex_unlock( &conn->c_write1_mutex );
                ldap_pvt_thread_pool_idle( &connection_pool );
-               ldap_pvt_thread_cond_wait( &conn->c_write2_cv, &conn->c_write2_mutex );
+               slap_writewait_play( op );
+               err = slapd_wait_writer( conn->c_sd );
                conn->c_writewaiter = 0;
-               ldap_pvt_thread_mutex_unlock( &conn->c_write2_mutex );
                ldap_pvt_thread_pool_unidle( &connection_pool );
                ldap_pvt_thread_mutex_lock( &conn->c_write1_mutex );
+               /* 0 is timeout, so we close it.
+                * -1 is an error, close it.
+                */
+               if ( err <= 0 ) {
+                       if ( err == 0 )
+                               close_reason = "writetimeout";
+                       else
+                               close_reason = "connection lost on writewait";
+                       goto fail;
+               }
+
                if ( conn->c_writers < 0 ) {
                        ret = 0;
                        break;