* flag and abort the operation at a convenient time.

       */

      for (o = pb_conn->c_ops; o != NULL; o = o->o_next) {

          if (o->o_msgid == id && o != pb_op)

              break;

                           o->o_results.r.r_search.nentries, (int64_t)o_hr_time_end.tv_sec, (int64_t)o_hr_time_end.tv_nsec);

      }

      /*

       * Wake up the persistent searches, so they

       * can notice if they've been abandoned.

          slapi_pblock_get(pb, SLAPI_PWPOLICY, &pw_response_requested);

      }

      bind_credentials_clear(pb_conn, PR_FALSE, /* do not lock conn */

                             PR_FALSE /* do not clear external creds. */);

       * bound user can work properly

       */

      pb_conn->c_needpw = 0;

      log_bind_access(pb, dn ? dn : "empty", method, version, saslmech, NULL);

      connection_cleanup(conn);

      /* free the private content, the buffer has been freed by above connection_cleanup */

      slapi_ch_free((void **)&conn->c_private);

      if (NULL != conn->c_sb) {

          ber_sockbuf_free(conn->c_sb);

      }

      if (NULL != conn->c_pdumutex) {

          PR_DestroyLock(conn->c_pdumutex);

      }

      /* PAGED_RESULTS */

      pagedresults_cleanup_all(conn, 0);

      /*

       * WARNING: There is a memory leak here! During a shutdown, connections

       * can still have events in ns add io timeout job because of post connection

      int rc;

      if (use_lock) {

      }

      rc = conn->c_sd == SLAPD_INVALID_SOCKET && conn->c_refcnt == 0 &&

           !(conn->c_flags & CONN_FLAG_CLOSING);

      if (use_lock) {

      }

      return rc;

      size_t buffer_data_avail;

      int conn_closed = 0;

      /*

       * if the socket is still valid, get the ber element

       * waiting for us on this connection. timeout is handled

      }

      op->o_tag = *tag;

  done:

      return ret;

  }

  void

  connection_make_readable(Connection *conn)

  {

      conn->c_gettingber = 0;

      signal_listner();

  }

  {

      int current_count = 0;

      int delta_count = 0;

      /* get the current op count */

      current_count = conn->c_opscompleted;

      /* compare to the previous op count */

      conn->c_private->previous_op_count = current_count;

      /* update the last checked time */

      conn->c_private->previous_count_check_time = slapi_current_utc_time();

      slapi_log_err(SLAPI_LOG_CONNS, "connection_check_activity_level", "conn %" PRIu64 " activity level = %d\n", conn->c_connid, delta_count);

  }

      int connection_count = 0;

      int our_rank = 0;

      int threshold_rank = 0;

      /* We can already be in turbo mode, or not */

      current_mode = current_turbo_flag;

      if (pagedresults_in_use_nolock(conn)) {

              new_mode = 1;

          }

      }

      if (current_mode != new_mode) {

          if (current_mode) {

              slapi_log_err(SLAPI_LOG_CONNS, "connection_enter_leave_turbo", "conn %" PRIu64 " leaving turbo mode\n", conn->c_connid);

                      return;

                  }

                  if (pb_conn->c_anonlimits_set == 0) {

                      /*

                       * We have a new connection, set the anonymous reslimit idletimeout

                       */

                      pb_conn->c_anonlimits_set = 1;

                  }

                  if (connection_call_io_layer_callbacks(pb_conn)) {

                      slapi_log_err(SLAPI_LOG_ERR, "connection_threadmain",

              */

              PR_Sleep(PR_INTERVAL_NO_WAIT);

              /* Make our own pb in turbo mode */

              connection_make_new_pb(pb, conn);

              if (connection_call_io_layer_callbacks(conn)) {

                  slapi_log_err(SLAPI_LOG_ERR, "connection_threadmain",

                                "Could not add/remove IO layers from connection\n");

              }

              if (!config_check_referral_mode()) {

                  slapi_counter_increment(ops_initiated);

                  slapi_counter_increment(g_get_global_snmp_vars()->ops_tbl.dsInOps);

          if ((tag != LDAP_REQ_UNBIND) && !thread_turbo_flag && !replication_connection) {

              if (!more_data) {

                  conn->c_flags &= ~CONN_FLAG_MAX_THREADS;

                  connection_make_readable_nolock(conn);

                  /* once the connection is readable, another thread may access conn,

                   * so need locking from here on */

                  signal_listner();

                   */

              } else if (!enable_nunc_stans) { /* more data in conn - just put back on work_q - bypass poll */

                  bypasspollcnt++;

                  /* don't do this if it would put us over the max threads per conn */

                  if (conn->c_threadnumber < maxthreads) {

                      /* for turbo, c_idlesince is set above - for !turbo and

                      /* keep count of how many times maxthreads has blocked an operation */

                      conn->c_maxthreadsblocked++;

                  }

              }

          }

      done:

          if (doshutdown) {

              connection_remove_operation_ext(pb, conn, op);

              connection_make_readable_nolock(conn);

              conn->c_threadnumber--;

              slapi_counter_decrement(conns_in_maxthreads);

              slapi_counter_decrement(g_get_global_snmp_vars()->ops_tbl.dsConnectionsInMaxThreads);

              connection_release_nolock(conn);

              signal_listner();

              slapi_pblock_destroy(pb);

              return;

               * continues to hold the connection

               */

              if (!thread_turbo_flag && !more_data) {

                  connection_release_nolock(conn); /* psearch acquires ref to conn - release this one now */

              }

              /* ps_add makes a shallow copy of the pb - so we

                   * can't free it or init it here - just set operation to NULL.

          } else {

              /* delete from connection operation queue & decr refcnt */

              int conn_closed = 0;

              connection_remove_operation_ext(pb, conn, op);

              /* If we're in turbo mode, we keep our reference to the connection alive */

                      signal_listner();

                  }

              }

          }

      } /* while (1) */

  }

      size_t dnlen;

      size_t typelen;

      dnlen = conn->c_dn ? strlen(conn->c_dn) : 0;

      typelen = conn->c_authtype ? strlen(conn->c_authtype) : 0;

          op->o_ssf = conn->c_local_ssf;

      }

  }

  /* Sets the SSL SSF in the connection struct. */

  static void

  connection_set_ssl_ssf(Connection *conn)

  {

      if (conn->c_flags & CONN_FLAG_SSL) {

          SSL_SecurityStatus(conn->c_prfd, NULL, NULL, NULL, &(conn->c_ssl_ssf), NULL, NULL);

          conn->c_ssl_ssf = 0;

      }

  }

  static int

  void

  disconnect_server(Connection *conn, PRUint64 opconnid, int opid, PRErrorCode reason, PRInt32 error)

  {

      disconnect_server_nomutex(conn, opconnid, opid, reason, error);

  }

  static ps_wakeup_all_fn_ptr ps_wakeup_all_fn = NULL;

          ct->c[i].c_prev = NULL;

          ct->c[i].c_ci = i;

          ct->c[i].c_fdi = SLAPD_INVALID_SOCKET_INDEX;

      }

      return ct;

  }

  {

      int i;

      for (i = 0; i < ct->size; i++) {

              connection_abandon_operations(&ct->c[i]);

          }

      }

  }

  connection_table_disconnect_all(Connection_Table *ct)

  {

      for (size_t i = 0; i < ct->size; i++) {

              Connection *c = &(ct->c[i]);

              disconnect_server_nomutex(c, c->c_connid, -1, SLAPD_DISCONNECT_ABORT, ECANCELED);

          }

      }

  }

          /* Do not use slot 0, slot 0 is head of the list of active connections */

          if (index == 0) {

              continue;

              break;

              break;

          }

      }

          PR_ASSERT(c->c_next == NULL);

          PR_ASSERT(c->c_prev == NULL);

          PR_ASSERT(c->c_extension == NULL);

              PR_Lock(ct->table_mutex);

              c->c_pdumutex = PR_NewLock();

              PR_Unlock(ct->table_mutex);

                  c->c_pdumutex = NULL;

                  slapi_log_err(SLAPI_LOG_ERR, "connection_table_get_connection", "PR_NewLock failed\n");

                  exit(1);

              }

          }

          /* Let's make sure there's no cruft left on there from the last time this connection was used. */

          /* Note: no need to lock c->c_mutex because this function is only

      nreadwaiters = 0;

      for (i = 0; i < (ct != NULL ? ct->size : 0); i++) {

          PR_Lock(ct->table_mutex);

              PR_Unlock(ct->table_mutex);

              continue;

          }

          /* Can't take c_mutex if holding table_mutex; temporarily unlock */

          PR_Unlock(ct->table_mutex);

          if (ct->c[i].c_sd != SLAPD_INVALID_SOCKET) {

              char buf2[SLAPI_TIMESTAMP_BUFSIZE+1];

              size_t lendn = ct->c[i].c_dn ? strlen(ct->c[i].c_dn) : 6; /* "NULLDN" */

              attrlist_merge(&e->e_attrs, "connection", vals);

              slapi_ch_free_string(&newbuf);

          }

      }

      snprintf(buf, sizeof(buf), "%d", nconns);

      for (i = 0; i < ct->size; i++) {

          Connection *c = &(ct->c[i]);

              /* Find the connection we are referring to */

              int j = c->c_fdi;

              if ((c->c_sd != SLAPD_INVALID_SOCKET) &&

                  (j >= 0) && (c->c_prfd == ct->fd[j].fd)) {

                  int r = ct->fd[j].out_flags & SLAPD_POLL_FLAGS;

                                    "activity on %d%s\n", i, r ? "r" : "");

                  }

              }

          }

      }

  }

      ns_handle_pr_read_ready,

      ns_handle_closure

  };

  /* Globals which are used to store the sockets between

   * calls to daemon_pre_setuid_init() and the daemon thread

   * creation. */

      c = connection_table_get_first_active_connection(ct);

      while (c) {

          next = connection_table_get_next_active_connection(ct, c);

              connection_table_move_connection_out_of_active_list(ct, c);

          } else {

              /* we try to acquire the connection mutex, if it is already

               * acquired by another thread, don't wait

               */

                  c = next;

                  continue;

              }

                      c->c_fdi = SLAPD_INVALID_SOCKET_INDEX;

                  }

              }

          }

          c = next;

      }

       */

      for (c = connection_table_get_first_active_connection(ct); c != NULL;

           c = connection_table_get_next_active_connection(ct, c)) {

              /* this check can be done without acquiring the mutex */

                  continue;

              if (connection_is_active_nolock(c) && c->c_gettingber == 0) {

                  PRInt16 out_flags;

                  short readready;

                                                SLAPD_DISCONNECT_IDLE_TIMEOUT, EAGAIN);

                  }

              }

          }

      }

  }

      Connection *c = (Connection *)ns_job_get_data(job);

      int do_yield = 0;

      /* Assert we really have the right job state. */

      PR_ASSERT(job == c->c_job);

      /* Because handle closure will add a new job, we need to detach our current one. */

      c->c_job = NULL;

      do_yield = ns_handle_closure_nomutex(c);

      /* Remove this task now. */

      ns_job_done(job);

      if (do_yield) {

  {

      Connection *c = (Connection *)ns_job_get_data(job);

      /* Assert we really have the right job state. */

      PR_ASSERT(job == c->c_job);

                        c->c_connid, c->c_sd);

      }

      /* Since we call done on the job, we need to remove it here. */

      ns_job_done(job);

      return;

  }

          PR_Close(pr_acceptfd);

          return -1;

      }

      /*

       * Set the default idletimeout and the handle.  We'll update c_idletimeout

          connection_table_move_connection_on_to_active_list(the_connection_table, conn);

      }

      g_increment_current_conn_count();

       * that poll() was avoided, even at the expense of putting this new fd back

       * in nunc-stans to poll for read ready.

       */

      ns_connection_post_io_or_closing(c);

      return;

  }

       */

      slapi_pblock_get(pb, SLAPI_CONNECTION, &pb_conn);

      if (pb_conn) {

          pb_conn->c_flags |= CONN_FLAG_IMPORT;

          pb_conn->c_bi_backend = be;

      }

      slapi_pblock_set(pb, SLAPI_EXT_OP_RET_OID, EXTOP_BULK_IMPORT_START_OID);

      Connection *pb_conn;

      slapi_pblock_get(pb, SLAPI_CONNECTION, &pb_conn);

      pb_conn->c_flags &= ~CONN_FLAG_IMPORT;

      be = pb_conn->c_bi_backend;

      pb_conn->c_bi_backend = NULL;

      if ((be == NULL) || (be->be_wire_import == NULL)) {

          /* can this even happen? */

  {

      int rc;

      /* rc = connection_acquire_nolock(conn); */

      /* connection in the closing state can't be acquired */

      if (conn->c_flags & CONN_FLAG_CLOSING) {

          conn->c_refcnt++;

          rc = 0;

      }

      return (rc);

  }

      int rc = 0;

      Slapi_Operation **olist = &conn->c_ops;

      Slapi_Operation **tmp;

      /* connection_remove_operation_ext(pb, conn,op); */

      for (tmp = olist; *tmp != NULL && *tmp != op; tmp = &(*tmp)->o_next)

          ; /* NULL */

              rc = 0;

          }

      }

      return (rc);

  }

         * In async paged result case, the search result might be released

         * by other theads.  We need to double check it in the locked region.

         */

              pr_search_result = pagedresults_get_search_result(pb_conn, operation, 1 /*locked*/, pr_idx);

              if (pr_search_result) {

                  if (pagedresults_is_abandoned_or_notavailable(pb_conn, 1 /*locked*/, pr_idx)) {

                      /* Previous operation was abandoned and the simplepaged object is not in use. */

                      send_ldap_result(pb, 0, NULL, "Simple Paged Results Search abandoned", 0, NULL);

                      rc = LDAP_SUCCESS;

                      goto free_and_return;

                  } else {

                      slapi_pblock_set(pb, SLAPI_SEARCH_RESULT_SET, pr_search_result);

                  pr_stat = PAGEDRESULTS_SEARCH_END;

                  rc = LDAP_SUCCESS;

              }

              pagedresults_unlock(pb_conn, pr_idx);

              if ((PAGEDRESULTS_SEARCH_END == pr_stat) || (0 == pnentries)) {

                  /* PAGED RESULTS */

                  if (op_is_pagedresults(operation)) {

                      /* cleanup the slot */

                      pagedresults_set_search_result(pb_conn, operation, NULL, 1, pr_idx);

                      rc = pagedresults_set_current_be(pb_conn, NULL, pr_idx, 1);

                  }

                  if (1 == flag_no_such_object) {

                      break;

                      slapi_pblock_get(pb, SLAPI_SEARCH_RESULT_SET, &sr);

                      if ((PAGEDRESULTS_SEARCH_END == pr_stat) || (0 == pnentries)) {

                          /* no more entries, but at least another backend */

                          pagedresults_set_search_result(pb_conn, operation, NULL, 1, pr_idx);

                          be->be_search_results_release(&sr);

                          rc = pagedresults_set_current_be(pb_conn, next_be, pr_idx, 1);

                          pr_stat = PAGEDRESULTS_SEARCH_END; /* make sure stat is SEARCH_END */

                          if (NULL == next_be) {

                              /* no more entries && no more backends */

                      next_be = NULL; /* to break the loop */

                      if (operation->o_status & SLAPI_OP_STATUS_ABANDONED) {

                          /* It turned out this search was abandoned. */

                          pagedresults_free_one_msgid_nolock(pb_conn, operation->o_msgid);

                          /* paged-results-request was abandoned; making an empty cookie. */

                          pagedresults_set_response_control(pb, 0, estimate, -1, pr_idx);

                          send_ldap_result(pb, 0, NULL, "Simple Paged Results Search abandoned", 0, NULL);

          return LDAP_UNWILLING_TO_PERFORM;

      }

      /* the ber encoding is no longer needed */

      ber_free(ber, 1);

      if (cookie.bv_len <= 0) {

              }

          }

      }

      slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_parse_control_value",

                    "<= idx %d\n", *index);

      slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_free_one",

                    "=> idx=%d\n", index);

      if (conn && (index > -1)) {

          if (conn->c_pagedresults.prl_count <= 0) {

              slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_free_one",

                            "conn=%" PRIu64 " paged requests list count is %d\n",

              conn->c_pagedresults.prl_count--;

              rc = 0;

          }

      }

      slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_free_one", "<= %d\n", rc);

      slapi_log_err(SLAPI_LOG_TRACE,

                    "pagedresults_get_current_be", "=> idx=%d\n", index);

      if (conn && (index > -1)) {

          if (index < conn->c_pagedresults.prl_maxlen) {

              be = conn->c_pagedresults.prl_list[index].pr_current_be;

          }

      }

      slapi_log_err(SLAPI_LOG_TRACE,

                    "pagedresults_get_current_be", "<= %p\n", be);

                    "pagedresults_set_current_be", "=> idx=%d\n", index);

      if (conn && (index > -1)) {

          if (!nolock)

          if (index < conn->c_pagedresults.prl_maxlen) {

              conn->c_pagedresults.prl_list[index].pr_current_be = be;

          }

          rc = 0;

          if (!nolock)

      }

      slapi_log_err(SLAPI_LOG_TRACE,

                    "pagedresults_set_current_be", "<= %d\n", rc);

                    locked ? "locked" : "not locked", index);

      if (conn && (index > -1)) {

          if (!locked) {

          }

          if (index < conn->c_pagedresults.prl_maxlen) {

              sr = conn->c_pagedresults.prl_list[index].pr_search_result_set;

          }

          if (!locked) {

          }

      }

      slapi_log_err(SLAPI_LOG_TRACE,

                    index, sr);

      if (conn && (index > -1)) {

          if (!locked)

          if (index < conn->c_pagedresults.prl_maxlen) {

              PagedResults *prp = conn->c_pagedresults.prl_list + index;

              if (!(prp->pr_flags & CONN_FLAG_PAGEDRESULTS_ABANDONED) || !sr) {

              rc = 0;

          }

          if (!locked)

      }

      slapi_log_err(SLAPI_LOG_TRACE,

                    "pagedresults_set_search_result", "=> %d\n", rc);

      slapi_log_err(SLAPI_LOG_TRACE,

                    "pagedresults_get_search_result_count", "=> idx=%d\n", index);

      if (conn && (index > -1)) {