[tor-commits] [tor/master] Remember optimistically sent data until we have gotten a CONNECTED
nickm at torproject.org
nickm at torproject.org
Wed Jul 20 13:51:20 UTC 2011
commit 218e84b634d10c25a6d5d002a983ddb051278bdf
Author: Nick Mathewson <nickm at torproject.org>
Date: Mon Jul 18 15:38:05 2011 -0400
Remember optimistically sent data until we have gotten a CONNECTED
Since we can retry failed streams under some circumstances, we need
to be ready to send data queued on them.
---
src/or/connection.c | 7 ++++++-
src/or/connection_edge.c | 9 ++++++++-
src/or/or.h | 15 ++++++++++++---
src/or/relay.c | 44 ++++++++++++++++++++++++++++++++++++++++++--
4 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/src/or/connection.c b/src/or/connection.c
index 8b9fb12..1ccd2b6 100644
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -444,7 +444,12 @@ _connection_free(connection_t *conn)
tor_free(edge_conn->chosen_exit_name);
if (edge_conn->socks_request)
socks_request_free(edge_conn->socks_request);
-
+ if (edge_conn->pending_optimistic_data) {
+ generic_buffer_free(edge_conn->pending_optimistic_data);
+ }
+ if (edge_conn->sending_optimistic_data) {
+ generic_buffer_free(edge_conn->sending_optimistic_data);
+ }
rend_data_free(edge_conn->rend_data);
}
if (conn->type == CONN_TYPE_CONTROL) {
diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c
index 20f8bc9..79f0db0 100644
--- a/src/or/connection_edge.c
+++ b/src/or/connection_edge.c
@@ -738,6 +738,12 @@ connection_ap_detach_retriable(edge_connection_t *conn, origin_circuit_t *circ,
{
control_event_stream_status(conn, STREAM_EVENT_FAILED_RETRIABLE, reason);
conn->_base.timestamp_lastread = time(NULL);
+
+ if (conn->pending_optimistic_data) {
+ generic_buffer_set_to_copy(&conn->sending_optimistic_data,
+ conn->pending_optimistic_data);
+ }
+
if (!get_options()->LeaveStreamsUnattached || conn->use_begindir) {
/* If we're attaching streams ourself, or if this connection is
* a tunneled directory connection, then just attach it. */
@@ -2429,7 +2435,8 @@ connection_ap_handshake_send_begin(edge_connection_t *ap_conn)
control_event_stream_status(ap_conn, STREAM_EVENT_SENT_CONNECT, 0);
/* If there's queued-up data, send it now */
- if (connection_get_inbuf_len(TO_CONN(ap_conn)) &&
+ if ((connection_get_inbuf_len(TO_CONN(ap_conn)) ||
+ ap_conn->sending_optimistic_data) &&
connection_ap_supports_optimistic_data(ap_conn)) {
log_info(LD_APP, "Sending up to %ld bytes of queued-up data",
connection_get_inbuf_len(TO_CONN(ap_conn)));
diff --git a/src/or/or.h b/src/or/or.h
index c784267..7097b5f 100644
--- a/src/or/or.h
+++ b/src/or/or.h
@@ -1237,11 +1237,20 @@ typedef struct edge_connection_t {
* NATd connection */
unsigned int is_transparent_ap:1;
- /** Set if this connection's target exit node allows optimistic data.
- * (That is, data sent on this stream before the exit has sent a
- * CONNECTED cell.)*/
+ /** For AP connections only: Set if this connection's target exit node
+ * allows optimistic data. (That is, data sent on this stream before
+ * the exit has sent a CONNECTED cell.)*/
unsigned int exit_allows_optimistic_data : 1;
+ /** For AP connections only: buffer for data that we have sent
+ * optimistically, which we might need to re-send if we have to
+ * retry this connection. */
+ generic_buffer_t *pending_optimistic_data;
+ /* For AP connections only: buffer for data that we previously sent
+ * optimistically which we are currently re-sending as we retry this
+ * connection. */
+ generic_buffer_t *sending_optimistic_data;
+
/** If this is a DNSPort connection, this field holds the pending DNS
* request that we're going to try to answer. */
struct evdns_server_request *dns_server_request;
diff --git a/src/or/relay.c b/src/or/relay.c
index df6d0a8..3fa31a3 100644
--- a/src/or/relay.c
+++ b/src/or/relay.c
@@ -944,6 +944,12 @@ connection_edge_process_relay_cell_not_open(
break;
}
}
+ /* This is definitely a success, so forget about any pending data we
+ * had sent. */
+ if (conn->pending_optimistic_data) {
+ generic_buffer_free(conn->pending_optimistic_data);
+ conn->pending_optimistic_data = NULL;
+ }
/* handle anything that might have queued */
if (connection_edge_package_raw_inbuf(conn, 1, NULL) < 0) {
@@ -1343,6 +1349,10 @@ connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
char payload[CELL_PAYLOAD_SIZE];
circuit_t *circ;
unsigned domain = conn->cpath_layer ? LD_APP : LD_EXIT;
+ int sending_from_optimistic = 0;
+ const int sending_optimistically =
+ conn->_base.type == CONN_TYPE_AP &&
+ conn->_base.state != AP_CONN_STATE_OPEN;
tor_assert(conn);
@@ -1375,7 +1385,18 @@ connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
return 0;
}
- amount_to_process = connection_get_inbuf_len(TO_CONN(conn));
+ sending_from_optimistic = conn->sending_optimistic_data != NULL;
+
+ if (PREDICT_UNLIKELY(sending_from_optimistic)) {
+ amount_to_process = generic_buffer_len(conn->sending_optimistic_data);
+ if (PREDICT_UNLIKELY(!amount_to_process)) {
+ log_warn(LD_BUG, "sending_optimistic_data was non-NULL but empty");
+ amount_to_process = connection_get_inbuf_len(TO_CONN(conn));
+ sending_from_optimistic = 0;
+ }
+ } else {
+ amount_to_process = connection_get_inbuf_len(TO_CONN(conn));
+ }
if (!amount_to_process)
return 0;
@@ -1391,11 +1412,30 @@ connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
stats_n_data_bytes_packaged += length;
stats_n_data_cells_packaged += 1;
- connection_fetch_from_buf(payload, length, TO_CONN(conn));
+ if (PREDICT_UNLIKELY(sending_from_optimistic)) {
+ /* XXX023 We could be more efficient here by sometimes packing
+ * previously-sent optimistic data in the same cell with data
+ * from the inbuf. */
+ generic_buffer_get(conn->sending_optimistic_data, payload, length);
+ if (!generic_buffer_len(conn->sending_optimistic_data)) {
+ generic_buffer_free(conn->sending_optimistic_data);
+ conn->sending_optimistic_data = NULL;
+ }
+ } else {
+ connection_fetch_from_buf(payload, length, TO_CONN(conn));
+ }
log_debug(domain,"(%d) Packaging %d bytes (%d waiting).", conn->_base.s,
(int)length, (int)connection_get_inbuf_len(TO_CONN(conn)));
+ if (sending_optimistically && !sending_from_optimistic) {
+ /* This is new optimistic data; remember it in case we need to detach and
+ retry */
+ if (!conn->pending_optimistic_data)
+ conn->pending_optimistic_data = generic_buffer_new();
+ generic_buffer_add(conn->pending_optimistic_data, payload, length);
+ }
+
if (connection_edge_send_command(conn, RELAY_COMMAND_DATA,
payload, length) < 0 )
/* circuit got marked for close, don't continue, don't need to mark conn */
More information about the tor-commits
mailing list