Silence warning. Also avoids pointless umask(0) when umask already is 0.

[openldap] / servers / slapd / connection.c

diff --git a/servers/slapd/connection.c b/servers/slapd/connection.c
index 7cfcd7b927cfad80ea4e4ba20fb26fbe1f2a5bb7..05e8122c62cdcfa6110bb61fe61b0e9f959de708 100644 (file)
--- a/servers/slapd/connection.c
+++ b/servers/slapd/connection.c
@@ -222,17 +222,23 @@ int connections_shutdown(void)
  */
 int connections_timeout_idle(time_t now)
 {
-       int i = 0;
+       int i = 0, writers = 0;
        int connindex;
        Connection* c;
+       time_t old;
+
+       old = slapd_get_writetime();
 
        for( c = connection_first( &connindex );
                c != NULL;
                c = connection_next( c, &connindex ) )
        {
                /* Don't timeout a slow-running request or a persistent
-                * outbound connection */
-               if( c->c_n_ops_executing || c->c_conn_state == SLAP_C_CLIENT ) {
+                * outbound connection. But if it has a writewaiter, see
+                * if the waiter has been there too long.
+                */
+               if(( c->c_n_ops_executing && !c->c_writewaiter)
+                       || c->c_conn_state == SLAP_C_CLIENT ) {
                        continue;
                }
 
@@ -241,9 +247,21 @@ int connections_timeout_idle(time_t now)
                        connection_closing( c, "idletimeout" );
                        connection_close( c );
                        i++;
+                       continue;
+               }
+               if ( c->c_writewaiter ) {
+                       writers = 1;
+                       if( difftime( c->c_activitytime+global_writetimeout, now) < 0 ) {
+                               /* close it */
+                               connection_closing( c, "writetimeout" );
+                               connection_close( c );
+                               i++;
+                       }
                }
        }
        connection_done( c );
+       if ( !writers )
+               slapd_clr_writetime( old );
 
        return i;
 }
@@ -1003,7 +1021,7 @@ conn_counter_init( Operation *op, void *ctx )
 static void *
 connection_operation( void *ctx, void *arg_v )
 {
-       int rc = LDAP_OTHER;
+       int rc = LDAP_OTHER, cancel;
        Operation *op = arg_v;
        SlapReply rs = {REP_RESULT};
        ber_tag_t tag = op->o_tag;
@@ -1107,22 +1125,32 @@ operations_error:
                INCR_OP_COMPLETED( opidx );
        }
 
-       if ( op->o_cancel == SLAP_CANCEL_REQ ) {
-               if ( rc == SLAPD_ABANDON ) {
-                       op->o_cancel = SLAP_CANCEL_ACK;
-               } else {
-                       op->o_cancel = LDAP_TOO_LATE;
+       ldap_pvt_thread_mutex_lock( &conn->c_mutex );
+
+       if ( opidx == SLAP_OP_BIND && conn->c_conn_state == SLAP_C_BINDING )
+               conn->c_conn_state = SLAP_C_ACTIVE;
+
+       cancel = op->o_cancel;
+       if ( cancel != SLAP_CANCEL_NONE && cancel != SLAP_CANCEL_DONE ) {
+               if ( cancel == SLAP_CANCEL_REQ ) {
+                       op->o_cancel = rc == SLAPD_ABANDON
+                               ? SLAP_CANCEL_ACK : LDAP_TOO_LATE;
                }
-       }
 
-       while ( op->o_cancel != SLAP_CANCEL_NONE &&
-               op->o_cancel != SLAP_CANCEL_DONE )
-       {
-               ldap_pvt_thread_yield();
+               do {
+                       /* Fake a cond_wait with thread_yield, then
+                        * verify the result properly mutex-protected.
+                        */
+                       ldap_pvt_thread_mutex_unlock( &conn->c_mutex );
+                       do {
+                               ldap_pvt_thread_yield();
+                       } while ( (cancel = op->o_cancel) != SLAP_CANCEL_NONE
+                                       && cancel != SLAP_CANCEL_DONE );
+                       ldap_pvt_thread_mutex_lock( &conn->c_mutex );
+               } while ( (cancel = op->o_cancel) != SLAP_CANCEL_NONE
+                               && cancel != SLAP_CANCEL_DONE );
        }
 
-       ldap_pvt_thread_mutex_lock( &conn->c_mutex );
-
        ber_set_option( op->o_ber, LBER_OPT_BER_MEMCTX, &memctx_null );
 
        LDAP_STAILQ_REMOVE( &conn->c_ops, op, Operation, o_next);
@@ -1253,24 +1281,6 @@ int connection_read_activate( ber_socket_t s )
        return rc;
 }
 
-void
-connection_hangup( ber_socket_t s )
-{
-       Connection *c;
-
-       c = connection_get( s );
-       if ( c ) {
-               if ( c->c_conn_state == SLAP_C_CLIENT ) {
-                       connection_return( c );
-                       connection_read_activate( s );
-               } else {
-                       connection_closing( c, "connection lost" );
-                       connection_close( c );
-                       connection_return( c );
-               }
-       }
-}
-
 static int
 connection_read( ber_socket_t s, conn_readinfo *cri )
 {
@@ -1527,6 +1537,9 @@ connection_input( Connection *conn , conn_readinfo *cri )
        ctx = cri->ctx;
        op = slap_op_alloc( ber, msgid, tag, conn->c_n_ops_received++, ctx );
 
+       Debug( LDAP_DEBUG_TRACE, "op tag 0x%lx, time %ld\n", tag,
+               (long) op->o_time, 0);
+
        op->o_conn = conn;
        /* clear state if the connection is being reused from inactive */
        if ( conn->c_conn_state == SLAP_C_INACTIVE ) {
@@ -1712,8 +1725,6 @@ static int connection_bind_cleanup_cb( Operation *op, SlapReply *rs )
 static int connection_bind_cb( Operation *op, SlapReply *rs )
 {
        ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex );
-       if ( op->o_conn->c_conn_state == SLAP_C_BINDING )
-               op->o_conn->c_conn_state = SLAP_C_ACTIVE;
        op->o_conn->c_sasl_bind_in_progress =
                ( rs->sr_err == LDAP_SASL_BIND_IN_PROGRESS );