[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [stegotorus/master] Stop using the bufferevent enabled mask as a proxy for whether or not we have received or sent an EOF.



commit fc6be532e001c8171bcc627c2ea00c5fbe0bae4c
Author: Zack Weinberg <zackw@xxxxxxx>
Date:   Tue Jun 19 23:28:04 2012 -0700

    Stop using the bufferevent enabled mask as a proxy for whether or not we have received or sent an EOF.
---
 src/connections.cc   |   47 +++++++++++++++++++++-----------------
 src/connections.h    |   38 ++++++++++++++++++++++++------
 src/network.cc       |   62 +++++++++++++++++++------------------------------
 src/protocol/chop.cc |    2 +-
 src/protocol/null.cc |    2 +-
 5 files changed, 82 insertions(+), 69 deletions(-)

diff --git a/src/connections.cc b/src/connections.cc
index f252b23..505299a 100644
--- a/src/connections.cc
+++ b/src/connections.cc
@@ -135,16 +135,17 @@ conn_t::circuit() const
 void
 conn_send_eof(conn_t *dest)
 {
+  dest->pending_write_eof = true;
   struct evbuffer *outbuf = dest->outbound();
   if (evbuffer_get_length(outbuf)) {
     log_debug(dest, "flushing out %lu bytes",
               (unsigned long) evbuffer_get_length(outbuf));
     conn_do_flush(dest);
-  } else if (bufferevent_get_enabled(dest->buffer) & EV_WRITE) {
+  } else if (!dest->write_eof) {
     log_debug(dest, "sending EOF downstream");
-    bufferevent_disable(dest->buffer, EV_WRITE);
     shutdown(bufferevent_getfd(dest->buffer), SHUT_WR);
-  } /* otherwise, it's already been done */
+    dest->write_eof = true;
+  }
 }
 
 /* Circuits. */
@@ -244,10 +245,15 @@ circuit_send(circuit_t *ckt)
   }
 }
 
+/* N.B. "read_eof" and "write_eof" are relative to _upstream_, and
+   therefore may appear to be backward relative to the function names
+   here.  I find this less confusing than having them appear to be
+   backward relative to the shutdown() calls and buffer drain checks,
+   here and in network.cc. */
 void
 circuit_send_eof(circuit_t *ckt)
 {
-  ckt->pending_eof_send = true;
+  ckt->pending_read_eof = true;
   if (ckt->socks_state) {
     log_debug(ckt, "EOF during SOCKS phase");
     delete ckt;
@@ -260,24 +266,23 @@ circuit_send_eof(circuit_t *ckt)
 void
 circuit_recv_eof(circuit_t *ckt)
 {
-  if (ckt->up_buffer) {
-    struct evbuffer *outbuf = bufferevent_get_output(ckt->up_buffer);
-    size_t outlen = evbuffer_get_length(outbuf);
-    if (outlen) {
-      log_debug(ckt, "flushing %lu bytes to upstream", (unsigned long)outlen);
-      circuit_do_flush(ckt);
-    } else if (ckt->connected) {
-      log_debug(ckt, "sending EOF to upstream");
-      bufferevent_disable(ckt->up_buffer, EV_WRITE);
-      shutdown(bufferevent_getfd(ckt->up_buffer), SHUT_WR);
-    } else {
-      log_debug(ckt, "holding EOF till connection");
-      ckt->pending_eof_recv = true;
-    }
-  } else {
-    log_debug(ckt, "no buffer, holding EOF till connection");
-    ckt->pending_eof_recv = true;
+  ckt->pending_write_eof = true;
+  if (!ckt->up_buffer || !ckt->connected) {
+    log_debug(ckt, "holding EOF till connection");
+    return;
+  }
+
+  struct evbuffer *outbuf = bufferevent_get_output(ckt->up_buffer);
+  size_t outlen = evbuffer_get_length(outbuf);
+  if (outlen) {
+    log_debug(ckt, "flushing %lu bytes to upstream", (unsigned long)outlen);
+    circuit_do_flush(ckt);
+    return;
   }
+
+  log_debug(ckt, "sending EOF to upstream");
+  ckt->write_eof = true;
+  shutdown(bufferevent_getfd(ckt->up_buffer), SHUT_WR);
 }
 
 void
diff --git a/src/connections.h b/src/connections.h
index 76c5f56..ef51c63 100644
--- a/src/connections.h
+++ b/src/connections.h
@@ -19,10 +19,21 @@ struct conn_t {
   struct bufferevent *buffer;
   unsigned int        serial;
   bool                connected : 1;
-  bool                flushing : 1;
   bool                ever_received : 1;
-
-  conn_t() : connected(false), flushing(false), ever_received(false) {}
+  bool                read_eof : 1;
+  bool                write_eof : 1;
+  bool                pending_write_eof : 1;
+
+  conn_t()
+    : peername(0)
+    , buffer(0)
+    , serial(0)
+    , connected(false)
+    , ever_received(false)
+    , read_eof(false)
+    , write_eof(false)
+    , pending_write_eof(false)
+  {}
 
   /** Close and deallocate a connection.  If the connection is part of a
       circuit, disconnect it from the circuit; this may cause the circuit
@@ -120,13 +131,24 @@ struct circuit_t {
   unsigned int        serial;
 
   bool                connected : 1;
-  bool                flushing : 1;
-  bool                pending_eof_recv : 1;
-  bool                pending_eof_send : 1;
+  bool                read_eof : 1;
+  bool                write_eof : 1;
+  bool                pending_read_eof : 1;
+  bool                pending_write_eof : 1;
 
   circuit_t()
-  : connected(false), flushing(false),
-    pending_eof_recv(false), pending_eof_send(false) {}
+    : flush_timer(0)
+    , axe_timer(0)
+    , up_buffer(0)
+    , up_peer(0)
+    , socks_state(0)
+    , serial(0)
+    , connected(false)
+    , read_eof(false)
+    , write_eof(false)
+    , pending_read_eof(false)
+    , pending_write_eof(false)
+  {}
   virtual ~circuit_t();
 
   /** Return the configuration that this circuit belongs to. */
diff --git a/src/network.cc b/src/network.cc
index 25a05e4..71d5b16 100644
--- a/src/network.cc
+++ b/src/network.cc
@@ -324,7 +324,7 @@ downstream_read_cb(struct bufferevent *bev, void *arg)
  */
 
 static void
-upstream_event_cb(struct bufferevent *bev, short what, void *arg)
+upstream_event_cb(struct bufferevent *, short what, void *arg)
 {
   circuit_t *ckt = (circuit_t *)arg;
 
@@ -345,15 +345,8 @@ upstream_event_cb(struct bufferevent *bev, short what, void *arg)
     if (what == (BEV_EVENT_EOF|BEV_EVENT_READING)) {
       /* Upstream is done sending us data. */
       circuit_send_eof(ckt);
-      if (bufferevent_get_enabled(bev) ||
-          evbuffer_get_length(bufferevent_get_input(bev)) > 0 ||
-          ckt->pending_eof_send) {
-        log_debug(ckt, "acknowledging EOF upstream");
-        shutdown(bufferevent_getfd(bev), SHUT_RD);
-        bufferevent_disable(bev, EV_READ);
-      } else {
+      if (ckt->read_eof && ckt->write_eof)
         delete ckt;
-      }
     } else {
       delete ckt;
     }
@@ -396,14 +389,8 @@ downstream_event_cb(struct bufferevent *bev, short what, void *arg)
     if (what == (BEV_EVENT_EOF|BEV_EVENT_READING)) {
       /* Peer is done sending us data. */
       conn->recv_eof();
-      if (bufferevent_get_enabled(bev) ||
-          evbuffer_get_length(bufferevent_get_input(bev)) > 0 ||
-          evbuffer_get_length(bufferevent_get_output(bev)) > 0) {
-        log_debug(conn, "acknowledging EOF downstream");
-        shutdown(bufferevent_getfd(bev), SHUT_RD);
-      } else {
+      if (conn->read_eof && conn->write_eof)
         delete conn;
-      }
     } else {
       delete conn;
     }
@@ -423,22 +410,20 @@ upstream_flush_cb(struct bufferevent *bev, void *arg)
 {
   circuit_t *ckt = (circuit_t *)arg;
   size_t remain = evbuffer_get_length(bufferevent_get_output(bev));
-  log_debug(ckt, "%lu bytes still to transmit%s%s",
+  log_debug(ckt, "%lu bytes still to transmit%s%s%s",
             (unsigned long)remain,
             ckt->connected ? "" : " (not connected)",
-            ckt->flushing ? "" : " (not flushing)");
+            ckt->pending_write_eof ? " (received EOF)" : "",
+            ckt->write_eof ? " (at EOF)" : "");
 
-  if (remain == 0 && ckt->flushing && ckt->connected
-      && (!ckt->flush_timer || !evtimer_pending(ckt->flush_timer, NULL))) {
-    if (bufferevent_get_enabled(bev) ||
-        evbuffer_get_length(bufferevent_get_input(bev)) > 0 ||
-        ckt->pending_eof_send) {
+  if (remain == 0 && ckt->connected && ckt->pending_write_eof) {
+    if (!ckt->write_eof) {
       log_debug(ckt, "sending EOF upstream");
       shutdown(bufferevent_getfd(bev), SHUT_WR);
-      bufferevent_disable(bev, EV_WRITE);
-    } else {
-      delete ckt;
+      ckt->write_eof = true;
     }
+    if (ckt->read_eof && ckt->write_eof)
+      delete ckt;
   }
 }
 
@@ -450,22 +435,23 @@ downstream_flush_cb(struct bufferevent *bev, void *arg)
 {
   conn_t *conn = (conn_t *)arg;
   size_t remain = evbuffer_get_length(bufferevent_get_output(bev));
-  log_debug(conn, "%lu bytes still to transmit%s%s%s%s",
+  log_debug(conn, "%lu bytes still to transmit%s%s%s%s%s",
             (unsigned long)remain,
             conn->connected ? "" : " (not connected)",
-            conn->flushing ? "" : " (not flushing)",
+            conn->pending_write_eof ? " (received EOF)" : "",
+            conn->write_eof ? " (at EOF)" : "",
             conn->circuit() ? "" : " (no circuit)",
             conn->ever_received ? "" : " (never received)");
 
-  if (remain == 0 && ((conn->flushing && conn->connected)
+  if (remain == 0 && ((conn->pending_write_eof && conn->connected)
                       || (!conn->circuit() && conn->ever_received))) {
-    bufferevent_disable(bev, EV_WRITE);
-    if (bufferevent_get_enabled(bev)) {
+    if (!conn->write_eof) {
       log_debug(conn, "sending EOF downstream");
       shutdown(bufferevent_getfd(bev), SHUT_WR);
-    } else {
-      delete conn;
+      conn->write_eof = true;
     }
+    if (conn->read_eof && conn->write_eof)
+      delete conn;
   }
 }
 
@@ -488,7 +474,7 @@ upstream_connect_cb(struct bufferevent *bev, short what, void *arg)
                       upstream_event_cb, ckt);
     bufferevent_enable(ckt->up_buffer, EV_READ|EV_WRITE);
     ckt->connected = 1;
-    if (ckt->pending_eof_recv) {
+    if (ckt->pending_write_eof) {
       /* Try again to process the EOF. */
       circuit_recv_eof(ckt);
     }
@@ -533,7 +519,7 @@ downstream_connect_cb(struct bufferevent *bev, short what, void *arg)
       return;
     }
 
-    if (ckt->pending_eof_recv) {
+    if (ckt->pending_write_eof) {
       /* Try again to process the EOF. */
       circuit_recv_eof(ckt);
     }
@@ -627,7 +613,7 @@ downstream_socks_connect_cb(struct bufferevent *bev, short what, void *arg)
          connection. */
       upstream_read_cb(ckt->up_buffer, ckt);
 
-    if (ckt->pending_eof_recv) {
+    if (ckt->pending_write_eof) {
       /* Try again to process the EOF. */
       circuit_recv_eof(ckt);
     }
@@ -808,7 +794,7 @@ void
 circuit_do_flush(circuit_t *ckt)
 {
   size_t remain = evbuffer_get_length(bufferevent_get_output(ckt->up_buffer));
-  ckt->flushing = 1;
+  ckt->pending_write_eof = true;
 
   /* If 'remain' is already zero, we have to call the flush callback
      manually; libevent won't do it for us. */
@@ -822,7 +808,7 @@ void
 conn_do_flush(conn_t *conn)
 {
   size_t remain = evbuffer_get_length(conn->outbound());
-  conn->flushing = 1;
+  conn->pending_write_eof = true;
 
   /* If 'remain' is already zero, we have to call the flush callback
      manually; libevent won't do it for us. */
diff --git a/src/protocol/chop.cc b/src/protocol/chop.cc
index 82348a1..75204f0 100644
--- a/src/protocol/chop.cc
+++ b/src/protocol/chop.cc
@@ -872,7 +872,7 @@ chop_circuit_t::send_targeted(chop_conn_t *conn, size_t d, size_t p, opcode_t f,
   send_seq++;
   if (f == op_FIN) {
     sent_fin = true;
-    pending_eof_send = false;
+    read_eof = true;
   }
   if ((f == op_DAT && d > 0) || f == op_FIN)
     // We are making forward progress if we are _either_ sending or
diff --git a/src/protocol/null.cc b/src/protocol/null.cc
index dab712a..7467de1 100644
--- a/src/protocol/null.cc
+++ b/src/protocol/null.cc
@@ -208,7 +208,7 @@ null_circuit_t::send_eof()
 {
   if (this->downstream)
     conn_send_eof(this->downstream);
-  this->pending_eof_send = false;
+  this->read_eof = true;
   return 0;
 }
 



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits