reenable the part of the code that tries to flush as soon as an OR outbuf

has a full tls record available. perhaps this will make OR outbufs not grow
as huge except in rare cases, thus saving lots of cpu time plus memory.


svn:r4343

3 files changed, 17 insertions, 11 deletions

diff --git a/src/or/connection.c b/src/or/connection.c
index 9c9bea4517..263762f484 100644
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -975,6 +975,9 @@ static int connection_receiver_bucket_should_increase(connection_t *conn) {
 int connection_handle_read(connection_t *conn) {
   int max_to_read=-1, try_to_read;
 
+  if (conn->marked_for_close)
+    return 0; /* do nothing */
+
   conn->timestamp_lastread = time(NULL);
 
   switch (conn->type) {
@@ -1176,6 +1179,9 @@ int connection_handle_write(connection_t *conn) {
 
   tor_assert(!connection_is_listener(conn));
 
+  if (conn->marked_for_close)
+    return 0; /* do nothing */
+
   conn->timestamp_lastwritten = now;
 
   /* Sometimes, "writable" means "connected". */
diff --git a/src/or/connection_or.c b/src/or/connection_or.c
index 5aa875d59b..3d667f601e 100644
--- a/src/or/connection_or.c
+++ b/src/or/connection_or.c
@@ -579,20 +579,26 @@ void connection_or_write_cell_to_buf(const cell_t *cell, connection_t *conn) {
 
   connection_write_to_buf(n, CELL_NETWORK_SIZE, conn);
 
-#if 0 /* commented out -- can we get away with not doing this,
-       * because we're already round-robining in handle_read?
-       */
 #define MIN_TLS_FLUSHLEN 15872
 /* openssl tls record size is 16383, this is close. The goal here is to
  * push data out as soon as we know there's enough for a tls record, so
  * during periods of high load we won't read the entire megabyte from
- * input before pushing any data out. */
+ * input before pushing any data out. It also has the feature of not
+ * growing huge outbufs unless something is slow. */
   if (conn->outbuf_flushlen-CELL_NETWORK_SIZE < MIN_TLS_FLUSHLEN &&
       conn->outbuf_flushlen >= MIN_TLS_FLUSHLEN) {
     int extra = conn->outbuf_flushlen - MIN_TLS_FLUSHLEN;
     conn->outbuf_flushlen = MIN_TLS_FLUSHLEN;
     if (connection_handle_write(conn) < 0) {
-      log_fn(LOG_WARN,"flushing failed.");
+      if (!conn->marked_for_close) {
+        /* this connection is broken. remove it. */
+        log_fn(LOG_WARN,"Bug: unhandled error on write for OR conn (fd %d); removing",
+               conn->s);
+        tor_fragile_assert();
+        conn->has_sent_end = 1; /* otherwise we cry wolf about duplicate close */
+        /* XXX do we need a close-immediate here, so we don't try to flush? */
+        connection_mark_for_close(conn);
+      }
       return;
     }
     if (extra) {
@@ -600,8 +606,6 @@ void connection_or_write_cell_to_buf(const cell_t *cell, connection_t *conn) {
       connection_start_writing(conn);
     }
   }
-#endif
-
 }
 
 /** Process cells from <b>conn</b>'s inbuf.
diff --git a/src/or/main.c b/src/or/main.c
index 319358a9ba..204b055697 100644
--- a/src/or/main.c
+++ b/src/or/main.c
@@ -344,8 +344,6 @@ static void
 conn_read_callback(int fd, short event, void *_conn)
 {
   connection_t *conn = _conn;
-  if (conn->marked_for_close)
-    return;
 
   log_fn(LOG_DEBUG,"socket %d wants to read.",conn->s);
 
@@ -376,8 +374,6 @@ static void conn_write_callback(int fd, short events, void *_conn)
   connection_t *conn = _conn;
 
   log_fn(LOG_DEBUG,"socket %d wants to write.",conn->s);
-  if (conn->marked_for_close)
-    return;
 
   assert_connection_ok(conn, time(NULL));