[tor-commits] [tor/master] Repair buffer API so everything starts with buf_.

nickm at torproject.org nickm at torproject.org
Tue Sep 5 18:18:13 UTC 2017


commit 4a7e90adc5828263a5d2dc3744818f2189c04bc7
Author: Nick Mathewson <nickm at torproject.org>
Date:   Tue Aug 8 15:16:39 2017 -0400

    Repair buffer API so everything starts with buf_.
    
    Our convention is that functions which manipulate a type T should be
    named T_foo.  But the buffer functions were super old, and followed
    all kinds of conventions.  Now they're uniform.
    
    Here's the perl I used to do this:
    
    \#!/usr/bin/perl -w -i -p
    
    s/read_to_buf\(/buf_read_from_socket\(/;
    s/flush_buf\(/buf_flush_to_socket\(/;
    s/read_to_buf_tls\(/buf_read_from_tls\(/;
    s/flush_buf_tls\(/buf_flush_to_tls\(/;
    s/write_to_buf\(/buf_add\(/;
    s/write_to_buf_compress\(/buf_add_compress\(/;
    s/move_buf_to_buf\(/buf_move_to_buf\(/;
    s/peek_from_buf\(/buf_peek\(/;
    s/fetch_from_buf\(/buf_get_bytes\(/;
    s/fetch_from_buf_line\(/buf_get_line\(/;
    s/fetch_from_buf_line\(/buf_get_line\(/;
    s/buf_remove_from_front\(/buf_drain\(/;
    s/peek_buf_startswith\(/buf_peek_startswith\(/;
    s/assert_buf_ok\(/buf_assert_ok\(/;
---
 src/common/buffers.c      |  48 +++++------
 src/common/buffers.h      |  22 ++---
 src/common/buffers_tls.c  |  10 +--
 src/common/buffers_tls.h  |   4 +-
 src/or/channeltls.c       |   2 +-
 src/or/connection.c       |  52 ++++++------
 src/or/connection.h       |  12 +--
 src/or/connection_edge.c  |  10 +--
 src/or/connection_or.c    |   8 +-
 src/or/control.c          |  18 ++---
 src/or/directory.c        |  36 ++++-----
 src/or/dirserv.c          |  10 +--
 src/or/ext_orport.c       |  18 ++---
 src/or/main.c             |   6 +-
 src/or/proto_cell.c       |   8 +-
 src/or/proto_control0.c   |   2 +-
 src/or/proto_ext_or.c     |   6 +-
 src/or/proto_http.c       |  14 ++--
 src/or/proto_socks.c      |   4 +-
 src/or/relay.c            |   8 +-
 src/test/test_buffers.c   | 202 +++++++++++++++++++++++-----------------------
 src/test/test_extorport.c |   8 +-
 src/test/test_helpers.c   |   2 +-
 src/test/test_oom.c       |   2 +-
 src/test/test_socks.c     |   2 +-
 25 files changed, 257 insertions(+), 257 deletions(-)

diff --git a/src/common/buffers.c b/src/common/buffers.c
index 1a9144e14..683952ddf 100644
--- a/src/common/buffers.c
+++ b/src/common/buffers.c
@@ -36,7 +36,7 @@
 #ifdef PARANOIA
 /** Helper: If PARANOIA is defined, assert that the buffer in local variable
  * <b>buf</b> is well-formed. */
-#define check() STMT_BEGIN assert_buf_ok(buf); STMT_END
+#define check() STMT_BEGIN buf_assert_ok(buf); STMT_END
 #else
 #define check() STMT_NIL
 #endif
@@ -282,14 +282,14 @@ buf_new_with_data(const char *cp, size_t sz)
   /* Allocate a buffer */
   buf_t *buf = buf_new_with_capacity(sz);
   tor_assert(buf);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tor_assert(!buf->head);
 
   /* Allocate a chunk that is sz bytes long */
   buf->head = chunk_new_with_alloc_size(CHUNK_ALLOC_SIZE(sz));
   buf->tail = buf->head;
   tor_assert(buf->head);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tor_assert(buf_allocation(buf) >= sz);
 
   /* Copy the data and size the buffers */
@@ -299,7 +299,7 @@ buf_new_with_data(const char *cp, size_t sz)
   buf->datalen = sz;
   buf->head->datalen = sz;
   buf->head->data = &buf->head->mem[0];
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
 
   /* Make sure everything is large enough */
   tor_assert(buf_allocation(buf) >= sz);
@@ -315,7 +315,7 @@ buf_new_with_data(const char *cp, size_t sz)
 
 /** Remove the first <b>n</b> bytes from buf. */
 void
-buf_remove_from_front(buf_t *buf, size_t n)
+buf_drain(buf_t *buf, size_t n)
 {
   tor_assert(buf->datalen >= n);
   while (n) {
@@ -551,7 +551,7 @@ read_to_chunk(buf_t *buf, chunk_t *chunk, tor_socket_t fd, size_t at_most,
  */
 /* XXXX indicate "read blocked" somehow? */
 int
-read_to_buf(tor_socket_t s, size_t at_most, buf_t *buf, int *reached_eof,
+buf_read_from_socket(tor_socket_t s, size_t at_most, buf_t *buf, int *reached_eof,
             int *socket_error)
 {
   /* XXXX It's stupid to overload the return values for these functions:
@@ -596,7 +596,7 @@ read_to_buf(tor_socket_t s, size_t at_most, buf_t *buf, int *reached_eof,
   return (int)total_read;
 }
 
-/** Helper for flush_buf(): try to write <b>sz</b> bytes from chunk
+/** Helper for buf_flush_to_socket(): try to write <b>sz</b> bytes from chunk
  * <b>chunk</b> of buffer <b>buf</b> onto socket <b>s</b>.  On success, deduct
  * the bytes written from *<b>buf_flushlen</b>.  Return the number of bytes
  * written on success, 0 on blocking, -1 on failure.
@@ -624,7 +624,7 @@ flush_chunk(tor_socket_t s, buf_t *buf, chunk_t *chunk, size_t sz,
     return 0;
   } else {
     *buf_flushlen -= write_result;
-    buf_remove_from_front(buf, write_result);
+    buf_drain(buf, write_result);
     tor_assert(write_result < INT_MAX);
     return (int)write_result;
   }
@@ -637,7 +637,7 @@ flush_chunk(tor_socket_t s, buf_t *buf, chunk_t *chunk, size_t sz,
  * -1 on failure.  Return 0 if write() would block.
  */
 int
-flush_buf(tor_socket_t s, buf_t *buf, size_t sz, size_t *buf_flushlen)
+buf_flush_to_socket(tor_socket_t s, buf_t *buf, size_t sz, size_t *buf_flushlen)
 {
   /* XXXX It's stupid to overload the return values for these functions:
    * "error status" and "number of bytes flushed" are not mutually exclusive.
@@ -677,7 +677,7 @@ flush_buf(tor_socket_t s, buf_t *buf, size_t sz, size_t *buf_flushlen)
  * Return the new length of the buffer on success, -1 on failure.
  */
 int
-write_to_buf(const char *string, size_t string_len, buf_t *buf)
+buf_add(const char *string, size_t string_len, buf_t *buf)
 {
   if (!string_len)
     return (int)buf->datalen;
@@ -712,14 +712,14 @@ write_to_buf(const char *string, size_t string_len, buf_t *buf)
  * onto <b>string</b>.
  */
 void
-peek_from_buf(char *string, size_t string_len, const buf_t *buf)
+buf_peek(char *string, size_t string_len, const buf_t *buf)
 {
   chunk_t *chunk;
 
   tor_assert(string);
   /* make sure we don't ask for too much */
   tor_assert(string_len <= buf->datalen);
-  /* assert_buf_ok(buf); */
+  /* buf_assert_ok(buf); */
 
   chunk = buf->head;
   while (string_len) {
@@ -739,7 +739,7 @@ peek_from_buf(char *string, size_t string_len, const buf_t *buf)
  * must be \<= the number of bytes on the buffer.
  */
 int
-fetch_from_buf(char *string, size_t string_len, buf_t *buf)
+buf_get_bytes(char *string, size_t string_len, buf_t *buf)
 {
   /* There must be string_len bytes in buf; write them onto string,
    * then memmove buf back (that is, remove them from buf).
@@ -747,8 +747,8 @@ fetch_from_buf(char *string, size_t string_len, buf_t *buf)
    * Return the number of bytes still on the buffer. */
 
   check();
-  peek_from_buf(string, string_len, buf);
-  buf_remove_from_front(buf, string_len);
+  buf_peek(string, string_len, buf);
+  buf_drain(buf, string_len);
   check();
   tor_assert(buf->datalen < INT_MAX);
   return (int)buf->datalen;
@@ -759,7 +759,7 @@ fetch_from_buf(char *string, size_t string_len, buf_t *buf)
  * Return the number of bytes actually copied.
  */
 int
-move_buf_to_buf(buf_t *buf_out, buf_t *buf_in, size_t *buf_flushlen)
+buf_move_to_buf(buf_t *buf_out, buf_t *buf_in, size_t *buf_flushlen)
 {
   /* We can do way better here, but this doesn't turn up in any profiles. */
   char b[4096];
@@ -781,8 +781,8 @@ move_buf_to_buf(buf_t *buf_out, buf_t *buf_in, size_t *buf_flushlen)
      * it does two copies instead of 1, but I kinda doubt that this will be
      * critical path. */
     size_t n = len > sizeof(b) ? sizeof(b) : len;
-    fetch_from_buf(b, n, buf_in);
-    write_to_buf(b, n, buf_out);
+    buf_get_bytes(b, n, buf_in);
+    buf_add(b, n, buf_out);
     len -= n;
   }
   *buf_flushlen -= cp;
@@ -901,7 +901,7 @@ buf_find_string_offset(const buf_t *buf, const char *s, size_t n)
 /** Return 1 iff <b>buf</b> starts with <b>cmd</b>. <b>cmd</b> must be a null
  * terminated string, of no more than PEEK_BUF_STARTSWITH_MAX bytes. */
 int
-peek_buf_startswith(const buf_t *buf, const char *cmd)
+buf_peek_startswith(const buf_t *buf, const char *cmd)
 {
   char tmp[PEEK_BUF_STARTSWITH_MAX];
   size_t clen = strlen(cmd);
@@ -909,7 +909,7 @@ peek_buf_startswith(const buf_t *buf, const char *cmd)
     return 0;
   if (buf->datalen < clen)
     return 0;
-  peek_from_buf(tmp, clen, buf);
+  buf_peek(tmp, clen, buf);
   return fast_memeq(tmp, cmd, clen);
 }
 
@@ -938,7 +938,7 @@ buf_find_offset_of_char(buf_t *buf, char ch)
  * length exceeds *<b>data_len</b>.
  */
 int
-fetch_from_buf_line(buf_t *buf, char *data_out, size_t *data_len)
+buf_get_line(buf_t *buf, char *data_out, size_t *data_len)
 {
   size_t sz;
   off_t offset;
@@ -954,7 +954,7 @@ fetch_from_buf_line(buf_t *buf, char *data_out, size_t *data_len)
     *data_len = sz + 2;
     return -1;
   }
-  fetch_from_buf(data_out, sz+1, buf);
+  buf_get_bytes(data_out, sz+1, buf);
   data_out[sz+1] = '\0';
   *data_len = sz+1;
   return 1;
@@ -965,7 +965,7 @@ fetch_from_buf_line(buf_t *buf, char *data_out, size_t *data_len)
  * <b>done</b> is true, flush the data in the state and finish the
  * compression/uncompression.  Return -1 on failure, 0 on success. */
 int
-write_to_buf_compress(buf_t *buf, tor_compress_state_t *state,
+buf_add_compress(buf_t *buf, tor_compress_state_t *state,
                       const char *data, size_t data_len,
                       const int done)
 {
@@ -1033,7 +1033,7 @@ buf_set_to_copy(buf_t **output,
 /** Log an error and exit if <b>buf</b> is corrupted.
  */
 void
-assert_buf_ok(buf_t *buf)
+buf_assert_ok(buf_t *buf)
 {
   tor_assert(buf);
   tor_assert(buf->magic == BUFFER_MAGIC);
diff --git a/src/common/buffers.h b/src/common/buffers.h
index 77cc9ce0f..73a688cff 100644
--- a/src/common/buffers.h
+++ b/src/common/buffers.h
@@ -35,27 +35,27 @@ size_t buf_slack(const buf_t *buf);
 uint32_t buf_get_oldest_chunk_timestamp(const buf_t *buf, uint32_t now);
 size_t buf_get_total_allocation(void);
 
-int read_to_buf(tor_socket_t s, size_t at_most, buf_t *buf, int *reached_eof,
+int buf_read_from_socket(tor_socket_t s, size_t at_most, buf_t *buf, int *reached_eof,
                 int *socket_error);
 
-int flush_buf(tor_socket_t s, buf_t *buf, size_t sz, size_t *buf_flushlen);
+int buf_flush_to_socket(tor_socket_t s, buf_t *buf, size_t sz, size_t *buf_flushlen);
 
-int write_to_buf(const char *string, size_t string_len, buf_t *buf);
-int write_to_buf_compress(buf_t *buf, struct tor_compress_state_t *state,
+int buf_add(const char *string, size_t string_len, buf_t *buf);
+int buf_add_compress(buf_t *buf, struct tor_compress_state_t *state,
                           const char *data, size_t data_len, int done);
-int move_buf_to_buf(buf_t *buf_out, buf_t *buf_in, size_t *buf_flushlen);
-void peek_from_buf(char *string, size_t string_len, const buf_t *buf);
-void buf_remove_from_front(buf_t *buf, size_t n);
-int fetch_from_buf(char *string, size_t string_len, buf_t *buf);
-int fetch_from_buf_line(buf_t *buf, char *data_out, size_t *data_len);
+int buf_move_to_buf(buf_t *buf_out, buf_t *buf_in, size_t *buf_flushlen);
+void buf_peek(char *string, size_t string_len, const buf_t *buf);
+void buf_drain(buf_t *buf, size_t n);
+int buf_get_bytes(char *string, size_t string_len, buf_t *buf);
+int buf_get_line(buf_t *buf, char *data_out, size_t *data_len);
 
 #define PEEK_BUF_STARTSWITH_MAX 16
-int peek_buf_startswith(const buf_t *buf, const char *cmd);
+int buf_peek_startswith(const buf_t *buf, const char *cmd);
 
 int buf_set_to_copy(buf_t **output,
                     const buf_t *input);
 
-void assert_buf_ok(buf_t *buf);
+void buf_assert_ok(buf_t *buf);
 
 int buf_find_string_offset(const buf_t *buf, const char *s, size_t n);
 void buf_pullup(buf_t *buf, size_t bytes,
diff --git a/src/common/buffers_tls.c b/src/common/buffers_tls.c
index e47073869..d22b56b63 100644
--- a/src/common/buffers_tls.c
+++ b/src/common/buffers_tls.c
@@ -57,7 +57,7 @@ read_to_chunk_tls(buf_t *buf, chunk_t *chunk, tor_tls_t *tls,
  * ready to write -- or vice versa.
  */
 int
-read_to_buf_tls(tor_tls_t *tls, size_t at_most, buf_t *buf)
+buf_read_from_tls(tor_tls_t *tls, size_t at_most, buf_t *buf)
 {
   int r = 0;
   size_t total_read = 0;
@@ -94,7 +94,7 @@ read_to_buf_tls(tor_tls_t *tls, size_t at_most, buf_t *buf)
   return (int)total_read;
 }
 
-/** Helper for flush_buf_tls(): try to write <b>sz</b> bytes from chunk
+/** Helper for buf_flush_to_tls(): try to write <b>sz</b> bytes from chunk
  * <b>chunk</b> of buffer <b>buf</b> onto socket <b>s</b>.  (Tries to write
  * more if there is a forced pending write size.)  On success, deduct the
  * bytes written from *<b>buf_flushlen</b>.  Return the number of bytes
@@ -125,17 +125,17 @@ flush_chunk_tls(tor_tls_t *tls, buf_t *buf, chunk_t *chunk,
     *buf_flushlen -= r;
   else
     *buf_flushlen = 0;
-  buf_remove_from_front(buf, r);
+  buf_drain(buf, r);
   log_debug(LD_NET,"flushed %d bytes, %d ready to flush, %d remain.",
             r,(int)*buf_flushlen,(int)buf->datalen);
   return r;
 }
 
-/** As flush_buf(), but writes data to a TLS connection.  Can write more than
+/** As buf_flush_to_socket(), but writes data to a TLS connection.  Can write more than
  * <b>flushlen</b> bytes.
  */
 int
-flush_buf_tls(tor_tls_t *tls, buf_t *buf, size_t flushlen,
+buf_flush_to_tls(tor_tls_t *tls, buf_t *buf, size_t flushlen,
               size_t *buf_flushlen)
 {
   int r;
diff --git a/src/common/buffers_tls.h b/src/common/buffers_tls.h
index 4fce6c113..d6b35fe93 100644
--- a/src/common/buffers_tls.h
+++ b/src/common/buffers_tls.h
@@ -10,9 +10,9 @@
 struct buf_t;
 struct tor_tls_t;
 
-int read_to_buf_tls(struct tor_tls_t *tls, size_t at_most,
+int buf_read_from_tls(struct tor_tls_t *tls, size_t at_most,
                     struct buf_t *buf);
-int flush_buf_tls(struct tor_tls_t *tls, struct buf_t *buf, size_t sz,
+int buf_flush_to_tls(struct tor_tls_t *tls, struct buf_t *buf, size_t sz,
                   size_t *buf_flushlen);
 
 #endif
diff --git a/src/or/channeltls.c b/src/or/channeltls.c
index 654745118..4ccd3b5fb 100644
--- a/src/or/channeltls.c
+++ b/src/or/channeltls.c
@@ -847,7 +847,7 @@ channel_tls_write_packed_cell_method(channel_t *chan,
   tor_assert(packed_cell);
 
   if (tlschan->conn) {
-    connection_write_to_buf(packed_cell->body, cell_network_size,
+    connection_buf_add(packed_cell->body, cell_network_size,
                             TO_CONN(tlschan->conn));
 
     /* This is where the cell is finished; used to be done from relay.c */
diff --git a/src/or/connection.c b/src/or/connection.c
index 866ce5e0b..1462bf480 100644
--- a/src/or/connection.c
+++ b/src/or/connection.c
@@ -37,7 +37,7 @@
  * they call connection_stop_reading() or connection_stop_writing().
  *
  * To queue data to be written on a connection, call
- * connection_write_to_buf().  When data arrives, the
+ * connection_buf_add().  When data arrives, the
  * connection_process_inbuf() callback is invoked, which dispatches to a
  * type-specific function (such as connection_edge_process_inbuf() for
  * example). Connection types that need notice of when data has been written
@@ -127,7 +127,7 @@ static int connection_finished_flushing(connection_t *conn);
 static int connection_flushed_some(connection_t *conn);
 static int connection_finished_connecting(connection_t *conn);
 static int connection_reached_eof(connection_t *conn);
-static int connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
+static int connection_buf_read_from_socket(connection_t *conn, ssize_t *max_to_read,
                                   int *socket_error);
 static int connection_process_inbuf(connection_t *conn, int package_partial);
 static void client_check_address_changed(tor_socket_t sock);
@@ -2143,7 +2143,7 @@ connection_proxy_connect(connection_t *conn, int type)
                      fmt_addrport(&conn->addr, conn->port));
       }
 
-      connection_write_to_buf(buf, strlen(buf), conn);
+      connection_buf_add(buf, strlen(buf), conn);
       conn->proxy_state = PROXY_HTTPS_WANT_CONNECT_OK;
       break;
     }
@@ -2209,7 +2209,7 @@ connection_proxy_connect(connection_t *conn, int type)
         buf[8] = 0; /* no userid */
       }
 
-      connection_write_to_buf((char *)buf, buf_size, conn);
+      connection_buf_add((char *)buf, buf_size, conn);
       tor_free(buf);
 
       conn->proxy_state = PROXY_SOCKS4_WANT_CONNECT_OK;
@@ -2240,7 +2240,7 @@ connection_proxy_connect(connection_t *conn, int type)
         conn->proxy_state = PROXY_SOCKS5_WANT_AUTH_METHOD_NONE;
       }
 
-      connection_write_to_buf((char *)buf, 2 + buf[1], conn);
+      connection_buf_add((char *)buf, 2 + buf[1], conn);
       break;
     }
 
@@ -2346,7 +2346,7 @@ connection_send_socks5_connect(connection_t *conn)
     memcpy(buf + 20, &port, 2);
   }
 
-  connection_write_to_buf((char *)buf, reqsize, conn);
+  connection_buf_add((char *)buf, reqsize, conn);
 
   conn->proxy_state = PROXY_SOCKS5_WANT_CONNECT_OK;
 }
@@ -2472,7 +2472,7 @@ connection_read_proxy_handshake(connection_t *conn)
         if (socks_args_string)
           tor_free(socks_args_string);
 
-        connection_write_to_buf((char *)buf, reqsize, conn);
+        connection_buf_add((char *)buf, reqsize, conn);
 
         conn->proxy_state = PROXY_SOCKS5_WANT_AUTH_RFC1929_OK;
         ret = 0;
@@ -3371,7 +3371,7 @@ connection_bucket_should_increase(int bucket, or_connection_t *conn)
 
 /** Read bytes from conn-\>s and process them.
  *
- * It calls connection_read_to_buf() to bring in any new bytes,
+ * It calls connection_buf_read_from_socket() to bring in any new bytes,
  * and then calls connection_process_inbuf() to process them.
  *
  * Mark the connection and return -1 if you want to close it, else
@@ -3413,7 +3413,7 @@ connection_handle_read_impl(connection_t *conn)
   tor_assert(!conn->marked_for_close);
 
   before = buf_datalen(conn->inbuf);
-  if (connection_read_to_buf(conn, &max_to_read, &socket_error) < 0) {
+  if (connection_buf_read_from_socket(conn, &max_to_read, &socket_error) < 0) {
     /* There's a read error; kill the connection.*/
     if (conn->type == CONN_TYPE_OR) {
       connection_or_notify_error(TO_OR_CONN(conn),
@@ -3510,7 +3510,7 @@ connection_handle_read(connection_t *conn)
  * Return -1 if we want to break conn, else return 0.
  */
 static int
-connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
+connection_buf_read_from_socket(connection_t *conn, ssize_t *max_to_read,
                        int *socket_error)
 {
   int result;
@@ -3551,7 +3551,7 @@ connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
 
     initial_size = buf_datalen(conn->inbuf);
     /* else open, or closing */
-    result = read_to_buf_tls(or_conn->tls, at_most, conn->inbuf);
+    result = buf_read_from_tls(or_conn->tls, at_most, conn->inbuf);
     if (TOR_TLS_IS_ERROR(result) || result == TOR_TLS_CLOSE)
       or_conn->tls_error = result;
     else
@@ -3600,7 +3600,7 @@ connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
       /* If we have any pending bytes, we read them now.  This *can*
        * take us over our read allotment, but really we shouldn't be
        * believing that SSL bytes are the same as TCP bytes anyway. */
-      int r2 = read_to_buf_tls(or_conn->tls, pending, conn->inbuf);
+      int r2 = buf_read_from_tls(or_conn->tls, pending, conn->inbuf);
       if (BUG(r2<0)) {
         log_warn(LD_BUG, "apparently, reading pending bytes can fail.");
         return -1;
@@ -3612,7 +3612,7 @@ connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
               result, (long)n_read, (long)n_written);
   } else if (conn->linked) {
     if (conn->linked_conn) {
-      result = move_buf_to_buf(conn->inbuf, conn->linked_conn->outbuf,
+      result = buf_move_to_buf(conn->inbuf, conn->linked_conn->outbuf,
                                &conn->linked_conn->outbuf_flushlen);
     } else {
       result = 0;
@@ -3630,7 +3630,7 @@ connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
     /* !connection_speaks_cells, !conn->linked_conn. */
     int reached_eof = 0;
     CONN_LOG_PROTECT(conn,
-        result = read_to_buf(conn->s, at_most, conn->inbuf, &reached_eof,
+        result = buf_read_from_socket(conn->s, at_most, conn->inbuf, &reached_eof,
                              socket_error));
     if (reached_eof)
       conn->inbuf_reached_eof = 1;
@@ -3700,17 +3700,17 @@ connection_read_to_buf(connection_t *conn, ssize_t *max_to_read,
 
 /** A pass-through to fetch_from_buf. */
 int
-connection_fetch_from_buf(char *string, size_t len, connection_t *conn)
+connection_buf_get_bytes(char *string, size_t len, connection_t *conn)
 {
-  return fetch_from_buf(string, len, conn->inbuf);
+  return buf_get_bytes(string, len, conn->inbuf);
 }
 
-/** As fetch_from_buf_line(), but read from a connection's input buffer. */
+/** As buf_get_line(), but read from a connection's input buffer. */
 int
-connection_fetch_from_buf_line(connection_t *conn, char *data,
+connection_buf_get_line(connection_t *conn, char *data,
                                size_t *data_len)
 {
-  return fetch_from_buf_line(conn->inbuf, data, data_len);
+  return buf_get_line(conn->inbuf, data, data_len);
 }
 
 /** As fetch_from_buf_http, but fetches from a connection's input buffer_t as
@@ -3747,7 +3747,7 @@ connection_outbuf_too_full(connection_t *conn)
  *
  * This function gets called either from conn_write_callback() in main.c
  * when libevent tells us that conn wants to write, or below
- * from connection_write_to_buf() when an entire TLS record is ready.
+ * from connection_buf_add() when an entire TLS record is ready.
  *
  * Update <b>conn</b>-\>timestamp_lastwritten to now, and call flush_buf
  * or flush_buf_tls appropriately. If it succeeds and there are no more
@@ -3858,7 +3858,7 @@ connection_handle_write_impl(connection_t *conn, int force)
 
     /* else open, or closing */
     initial_size = buf_datalen(conn->outbuf);
-    result = flush_buf_tls(or_conn->tls, conn->outbuf,
+    result = buf_flush_to_tls(or_conn->tls, conn->outbuf,
                            max_to_write, &conn->outbuf_flushlen);
 
     /* If we just flushed the last bytes, tell the channel on the
@@ -3921,7 +3921,7 @@ connection_handle_write_impl(connection_t *conn, int force)
     result = (int)(initial_size-buf_datalen(conn->outbuf));
   } else {
     CONN_LOG_PROTECT(conn,
-             result = flush_buf(conn->s, conn->outbuf,
+             result = buf_flush_to_socket(conn->s, conn->outbuf,
                                 max_to_write, &conn->outbuf_flushlen));
     if (result < 0) {
       if (CONN_IS_EDGE(conn))
@@ -4062,11 +4062,11 @@ connection_write_to_buf_impl_,(const char *string, size_t len,
   if (zlib) {
     dir_connection_t *dir_conn = TO_DIR_CONN(conn);
     int done = zlib < 0;
-    CONN_LOG_PROTECT(conn, r = write_to_buf_compress(conn->outbuf,
+    CONN_LOG_PROTECT(conn, r = buf_add_compress(conn->outbuf,
                                                      dir_conn->compress_state,
                                                      string, len, done));
   } else {
-    CONN_LOG_PROTECT(conn, r = write_to_buf(string, len, conn->outbuf));
+    CONN_LOG_PROTECT(conn, r = buf_add(string, len, conn->outbuf));
   }
   if (r < 0) {
     if (CONN_IS_EDGE(conn)) {
@@ -4977,9 +4977,9 @@ assert_connection_ok(connection_t *conn, time_t now)
 
   /* buffers */
   if (conn->inbuf)
-    assert_buf_ok(conn->inbuf);
+    buf_assert_ok(conn->inbuf);
   if (conn->outbuf)
-    assert_buf_ok(conn->outbuf);
+    buf_assert_ok(conn->outbuf);
 
   if (conn->type == CONN_TYPE_OR) {
     or_connection_t *or_conn = TO_OR_CONN(conn);
diff --git a/src/or/connection.h b/src/or/connection.h
index 0bcf0ccdc..57b9a4a1d 100644
--- a/src/or/connection.h
+++ b/src/or/connection.h
@@ -123,8 +123,8 @@ void connection_bucket_refill(int seconds_elapsed, time_t now);
 
 int connection_handle_read(connection_t *conn);
 
-int connection_fetch_from_buf(char *string, size_t len, connection_t *conn);
-int connection_fetch_from_buf_line(connection_t *conn, char *data,
+int connection_buf_get_bytes(char *string, size_t len, connection_t *conn);
+int connection_buf_get_line(connection_t *conn, char *data,
                                    size_t *data_len);
 int connection_fetch_from_buf_http(connection_t *conn,
                                char **headers_out, size_t max_headerlen,
@@ -139,18 +139,18 @@ int connection_flush(connection_t *conn);
 MOCK_DECL(void, connection_write_to_buf_impl_,
           (const char *string, size_t len, connection_t *conn, int zlib));
 /* DOCDOC connection_write_to_buf */
-static void connection_write_to_buf(const char *string, size_t len,
+static void connection_buf_add(const char *string, size_t len,
                                     connection_t *conn);
 /* DOCDOC connection_write_to_buf_compress */
-static void connection_write_to_buf_compress(const char *string, size_t len,
+static void connection_buf_add_compress(const char *string, size_t len,
                                              dir_connection_t *conn, int done);
 static inline void
-connection_write_to_buf(const char *string, size_t len, connection_t *conn)
+connection_buf_add(const char *string, size_t len, connection_t *conn)
 {
   connection_write_to_buf_impl_(string, len, conn, 0);
 }
 static inline void
-connection_write_to_buf_compress(const char *string, size_t len,
+connection_buf_add_compress(const char *string, size_t len,
                                  dir_connection_t *conn, int done)
 {
   connection_write_to_buf_impl_(string, len, TO_CONN(conn), done ? -1 : 1);
diff --git a/src/or/connection_edge.c b/src/or/connection_edge.c
index 4f990e0a0..9f47f4117 100644
--- a/src/or/connection_edge.c
+++ b/src/or/connection_edge.c
@@ -2276,7 +2276,7 @@ connection_ap_handshake_process_socks(entry_connection_t *conn)
 
   if (socks->replylen) {
     had_reply = 1;
-    connection_write_to_buf((const char*)socks->reply, socks->replylen,
+    connection_buf_add((const char*)socks->reply, socks->replylen,
                             base_conn);
     socks->replylen = 0;
     if (sockshere == -1) {
@@ -2373,7 +2373,7 @@ connection_ap_process_natd(entry_connection_t *conn)
 
   /* look for LF-terminated "[DEST ip_addr port]"
    * where ip_addr is a dotted-quad and port is in string form */
-  err = connection_fetch_from_buf_line(ENTRY_TO_CONN(conn), tmp_buf, &tlen);
+  err = connection_buf_get_line(ENTRY_TO_CONN(conn), tmp_buf, &tlen);
   if (err == 0)
     return 0;
   if (err < 0) {
@@ -3041,7 +3041,7 @@ connection_ap_handshake_socks_reply(entry_connection_t *conn, char *reply,
     return;
   }
   if (replylen) { /* we already have a reply in mind */
-    connection_write_to_buf(reply, replylen, ENTRY_TO_CONN(conn));
+    connection_buf_add(reply, replylen, ENTRY_TO_CONN(conn));
     conn->socks_request->has_finished = 1;
     return;
   }
@@ -3049,7 +3049,7 @@ connection_ap_handshake_socks_reply(entry_connection_t *conn, char *reply,
     memset(buf,0,SOCKS4_NETWORK_LEN);
     buf[1] = (status==SOCKS5_SUCCEEDED ? SOCKS4_GRANTED : SOCKS4_REJECT);
     /* leave version, destport, destip zero */
-    connection_write_to_buf(buf, SOCKS4_NETWORK_LEN, ENTRY_TO_CONN(conn));
+    connection_buf_add(buf, SOCKS4_NETWORK_LEN, ENTRY_TO_CONN(conn));
   } else if (conn->socks_request->socks_version == 5) {
     size_t buf_len;
     memset(buf,0,sizeof(buf));
@@ -3068,7 +3068,7 @@ connection_ap_handshake_socks_reply(entry_connection_t *conn, char *reply,
       /* 4 bytes for the header, 2 bytes for the port, 16 for the address. */
       buf_len = 22;
     }
-    connection_write_to_buf(buf,buf_len,ENTRY_TO_CONN(conn));
+    connection_buf_add(buf,buf_len,ENTRY_TO_CONN(conn));
   }
   /* If socks_version isn't 4 or 5, don't send anything.
    * This can happen in the case of AP bridges. */
diff --git a/src/or/connection_or.c b/src/or/connection_or.c
index 8cd36d66b..d890b58da 100644
--- a/src/or/connection_or.c
+++ b/src/or/connection_or.c
@@ -1979,7 +1979,7 @@ connection_or_write_cell_to_buf(const cell_t *cell, or_connection_t *conn)
   if (cell->command == CELL_PADDING)
     rep_hist_padding_count_write(PADDING_TYPE_CELL);
 
-  connection_write_to_buf(networkcell.body, cell_network_size, TO_CONN(conn));
+  connection_buf_add(networkcell.body, cell_network_size, TO_CONN(conn));
 
   /* Touch the channel's active timestamp if there is one */
   if (conn->chan) {
@@ -2009,8 +2009,8 @@ connection_or_write_var_cell_to_buf,(const var_cell_t *cell,
   tor_assert(cell);
   tor_assert(conn);
   n = var_cell_pack_header(cell, hdr, conn->wide_circ_ids);
-  connection_write_to_buf(hdr, n, TO_CONN(conn));
-  connection_write_to_buf((char*)cell->payload,
+  connection_buf_add(hdr, n, TO_CONN(conn));
+  connection_buf_add((char*)cell->payload,
                           cell->payload_len, TO_CONN(conn));
   if (conn->base_.state == OR_CONN_STATE_OR_HANDSHAKING_V3)
     or_handshake_state_record_var_cell(conn, conn->handshake_state, cell, 0);
@@ -2085,7 +2085,7 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn)
         channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
 
       circuit_build_times_network_is_live(get_circuit_build_times_mutable());
-      connection_fetch_from_buf(buf, cell_network_size, TO_CONN(conn));
+      connection_buf_get_bytes(buf, cell_network_size, TO_CONN(conn));
 
       /* retrieve cell info from buf (create the host-order struct from the
        * network-order string) */
diff --git a/src/or/control.c b/src/or/control.c
index cd78daa91..eb6f21352 100644
--- a/src/or/control.c
+++ b/src/or/control.c
@@ -357,7 +357,7 @@ static inline void
 connection_write_str_to_buf(const char *s, control_connection_t *conn)
 {
   size_t len = strlen(s);
-  connection_write_to_buf(s, len, TO_CONN(conn));
+  connection_buf_add(s, len, TO_CONN(conn));
 }
 
 /** Given a <b>len</b>-character string in <b>data</b>, made of lines
@@ -567,7 +567,7 @@ connection_printf_to_buf(control_connection_t *conn, const char *format, ...)
     tor_assert(0);
   }
 
-  connection_write_to_buf(buf, (size_t)len, TO_CONN(conn));
+  connection_buf_add(buf, (size_t)len, TO_CONN(conn));
 
   tor_free(buf);
 }
@@ -792,7 +792,7 @@ queued_events_flush_all(int force)
     SMARTLIST_FOREACH_BEGIN(controllers, control_connection_t *,
                             control_conn) {
       if (control_conn->event_mask & bit) {
-        connection_write_to_buf(ev->msg, msg_len, TO_CONN(control_conn));
+        connection_buf_add(ev->msg, msg_len, TO_CONN(control_conn));
       }
     } SMARTLIST_FOREACH_END(control_conn);
 
@@ -1074,7 +1074,7 @@ handle_control_getconf(control_connection_t *conn, uint32_t body_len,
     tor_assert(strlen(tmp)>4);
     tmp[3] = ' ';
     msg = smartlist_join_strings(answers, "", 0, &msg_len);
-    connection_write_to_buf(msg, msg_len, TO_CONN(conn));
+    connection_buf_add(msg, msg_len, TO_CONN(conn));
   } else {
     connection_write_str_to_buf("250 OK\r\n", conn);
   }
@@ -1656,12 +1656,12 @@ handle_control_mapaddress(control_connection_t *conn, uint32_t len,
   if (smartlist_len(reply)) {
     ((char*)smartlist_get(reply,smartlist_len(reply)-1))[3] = ' ';
     r = smartlist_join_strings(reply, "\r\n", 1, &sz);
-    connection_write_to_buf(r, sz, TO_CONN(conn));
+    connection_buf_add(r, sz, TO_CONN(conn));
     tor_free(r);
   } else {
     const char *response =
       "512 syntax error: not enough arguments to mapaddress.\r\n";
-    connection_write_to_buf(response, strlen(response), TO_CONN(conn));
+    connection_buf_add(response, strlen(response), TO_CONN(conn));
   }
 
   SMARTLIST_FOREACH(reply, char *, cp, tor_free(cp));
@@ -3246,7 +3246,7 @@ handle_control_getinfo(control_connection_t *conn, uint32_t len,
       size_t esc_len;
       esc_len = write_escaped_data(v, strlen(v), &esc);
       connection_printf_to_buf(conn, "250+%s=\r\n", k);
-      connection_write_to_buf(esc, esc_len, TO_CONN(conn));
+      connection_buf_add(esc, esc_len, TO_CONN(conn));
       tor_free(esc);
     }
   }
@@ -4987,7 +4987,7 @@ connection_control_process_inbuf(control_connection_t *conn)
             sizeof(buf)-6);
     body_len = 2+strlen(buf+6)+2; /* code, msg, nul. */
     set_uint16(buf+0, htons(body_len));
-    connection_write_to_buf(buf, 4+body_len, TO_CONN(conn));
+    connection_buf_add(buf, 4+body_len, TO_CONN(conn));
 
     connection_mark_and_flush(TO_CONN(conn));
     return 0;
@@ -5009,7 +5009,7 @@ connection_control_process_inbuf(control_connection_t *conn)
     /* First, fetch a line. */
     do {
       data_len = conn->incoming_cmd_len - conn->incoming_cmd_cur_len;
-      r = connection_fetch_from_buf_line(TO_CONN(conn),
+      r = connection_buf_get_line(TO_CONN(conn),
                               conn->incoming_cmd+conn->incoming_cmd_cur_len,
                               &data_len);
       if (r == 0)
diff --git a/src/or/directory.c b/src/or/directory.c
index 57dfdd9ca..b1094634f 100644
--- a/src/or/directory.c
+++ b/src/or/directory.c
@@ -1912,11 +1912,11 @@ directory_send_command(dir_connection_t *conn,
 
   request_len = strlen(request);
   total_request_len += request_len;
-  connection_write_to_buf(request, request_len, TO_CONN(conn));
+  connection_buf_add(request, request_len, TO_CONN(conn));
 
   url_len = strlen(url);
   total_request_len += url_len;
-  connection_write_to_buf(url, url_len, TO_CONN(conn));
+  connection_buf_add(url, url_len, TO_CONN(conn));
   tor_free(url);
 
   if (!strcmp(httpcommand, "POST") || payload) {
@@ -1933,11 +1933,11 @@ directory_send_command(dir_connection_t *conn,
 
   request_len = strlen(request);
   total_request_len += request_len;
-  connection_write_to_buf(request, request_len, TO_CONN(conn));
+  connection_buf_add(request, request_len, TO_CONN(conn));
 
   if (payload) {
     /* then send the payload afterwards too */
-    connection_write_to_buf(payload, payload_len, TO_CONN(conn));
+    connection_buf_add(payload, payload_len, TO_CONN(conn));
     total_request_len += payload_len;
   }
 
@@ -3466,7 +3466,7 @@ write_http_status_line(dir_connection_t *conn, int status,
     return;
   }
   log_debug(LD_DIRSERV,"Wrote status 'HTTP/1.0 %d %s'", status, reason_phrase);
-  connection_write_to_buf(buf, strlen(buf), TO_CONN(conn));
+  connection_buf_add(buf, strlen(buf), TO_CONN(conn));
 }
 
 /** Write the header for an HTTP/1.0 response onto <b>conn</b>-\>outbuf,
@@ -3539,7 +3539,7 @@ write_http_response_header_impl(dir_connection_t *conn, ssize_t length,
     memcpy(cp, "\r\n", 3);
   else
     tor_assert(0);
-  connection_write_to_buf(tmp, strlen(tmp), TO_CONN(conn));
+  connection_buf_add(tmp, strlen(tmp), TO_CONN(conn));
 }
 
 /** As write_http_response_header_impl, but sets encoding and content-typed
@@ -3902,7 +3902,7 @@ handle_get_frontpage(dir_connection_t *conn, const get_handler_args_t *args)
      *  this page no matter what.] */
     write_http_response_header_impl(conn, dlen, "text/html", "identity",
                                     NULL, DIRPORTFRONTPAGE_CACHE_LIFETIME);
-    connection_write_to_buf(frontpage, dlen, TO_CONN(conn));
+    connection_buf_add(frontpage, dlen, TO_CONN(conn));
   } else {
     write_http_status_line(conn, 404, "Not found");
   }
@@ -4539,15 +4539,15 @@ handle_get_status_vote(dir_connection_t *conn, const get_handler_args_t *args)
         conn->compress_state = tor_compress_new(1, compress_method,
                            choose_compression_level(estimated_len));
         SMARTLIST_FOREACH(items, const char *, c,
-                 connection_write_to_buf_compress(c, strlen(c), conn, 0));
-        connection_write_to_buf_compress("", 0, conn, 1);
+                 connection_buf_add_compress(c, strlen(c), conn, 0));
+        connection_buf_add_compress("", 0, conn, 1);
       } else {
         SMARTLIST_FOREACH(items, const char *, c,
-                         connection_write_to_buf(c, strlen(c), TO_CONN(conn)));
+                         connection_buf_add(c, strlen(c), TO_CONN(conn)));
       }
     } else {
       SMARTLIST_FOREACH(dir_items, cached_dir_t *, d,
-          connection_write_to_buf(compress_method != NO_METHOD ?
+          connection_buf_add(compress_method != NO_METHOD ?
                                     d->dir_compressed : d->dir,
                                   compress_method != NO_METHOD ?
                                     d->dir_compressed_len : d->dir_len,
@@ -4795,14 +4795,14 @@ handle_get_keys(dir_connection_t *conn, const get_handler_args_t *args)
       conn->compress_state = tor_compress_new(1, compress_method,
                                               choose_compression_level(len));
       SMARTLIST_FOREACH(certs, authority_cert_t *, c,
-            connection_write_to_buf_compress(
+            connection_buf_add_compress(
                 c->cache_info.signed_descriptor_body,
                 c->cache_info.signed_descriptor_len,
                 conn, 0));
-      connection_write_to_buf_compress("", 0, conn, 1);
+      connection_buf_add_compress("", 0, conn, 1);
     } else {
       SMARTLIST_FOREACH(certs, authority_cert_t *, c,
-            connection_write_to_buf(c->cache_info.signed_descriptor_body,
+            connection_buf_add(c->cache_info.signed_descriptor_body,
                                     c->cache_info.signed_descriptor_len,
                                     TO_CONN(conn)));
     }
@@ -4831,7 +4831,7 @@ handle_get_hs_descriptor_v2(dir_connection_t *conn,
       switch (rend_cache_lookup_v2_desc_as_dir(query, &descp)) {
         case 1: /* valid */
           write_http_response_header(conn, strlen(descp), NO_METHOD, 0);
-          connection_write_to_buf(descp, strlen(descp), TO_CONN(conn));
+          connection_buf_add(descp, strlen(descp), TO_CONN(conn));
           break;
         case 0: /* well-formed but not present */
           write_http_status_line(conn, 404, "Not found");
@@ -4883,7 +4883,7 @@ handle_get_hs_descriptor_v3(dir_connection_t *conn,
 
   /* Found requested descriptor! Pass it to this nice client. */
   write_http_response_header(conn, strlen(desc_str), NO_METHOD, 0);
-  connection_write_to_buf(desc_str, strlen(desc_str), TO_CONN(conn));
+  connection_buf_add(desc_str, strlen(desc_str), TO_CONN(conn));
 
  done:
   return 0;
@@ -4922,7 +4922,7 @@ handle_get_networkstatus_bridges(dir_connection_t *conn,
     status = networkstatus_getinfo_by_purpose("bridge", time(NULL));
     size_t dlen = strlen(status);
     write_http_response_header(conn, dlen, NO_METHOD, 0);
-    connection_write_to_buf(status, dlen, TO_CONN(conn));
+    connection_buf_add(status, dlen, TO_CONN(conn));
     tor_free(status);
     goto done;
   }
@@ -4939,7 +4939,7 @@ handle_get_robots(dir_connection_t *conn, const get_handler_args_t *args)
     const char robots[] = "User-agent: *\r\nDisallow: /\r\n";
     size_t len = strlen(robots);
     write_http_response_header(conn, len, NO_METHOD, ROBOTS_CACHE_LIFETIME);
-    connection_write_to_buf(robots, len, TO_CONN(conn));
+    connection_buf_add(robots, len, TO_CONN(conn));
   }
   return 0;
 }
diff --git a/src/or/dirserv.c b/src/or/dirserv.c
index 4faca9454..b3a0b0d23 100644
--- a/src/or/dirserv.c
+++ b/src/or/dirserv.c
@@ -3617,9 +3617,9 @@ spooled_resource_flush_some(spooled_resource_t *spooled,
       return SRFS_DONE;
     }
     if (conn->compress_state) {
-      connection_write_to_buf_compress((const char*)body, bodylen, conn, 0);
+      connection_buf_add_compress((const char*)body, bodylen, conn, 0);
     } else {
-      connection_write_to_buf((const char*)body, bodylen, TO_CONN(conn));
+      connection_buf_add((const char*)body, bodylen, TO_CONN(conn));
     }
     return SRFS_DONE;
   } else {
@@ -3656,11 +3656,11 @@ spooled_resource_flush_some(spooled_resource_t *spooled,
       return SRFS_ERR;
     ssize_t bytes = (ssize_t) MIN(DIRSERV_CACHED_DIR_CHUNK_SIZE, remaining);
     if (conn->compress_state) {
-      connection_write_to_buf_compress(
+      connection_buf_add_compress(
               ptr + spooled->cached_dir_offset,
               bytes, conn, 0);
     } else {
-      connection_write_to_buf(ptr + spooled->cached_dir_offset,
+      connection_buf_add(ptr + spooled->cached_dir_offset,
                               bytes, TO_CONN(conn));
     }
     spooled->cached_dir_offset += bytes;
@@ -3925,7 +3925,7 @@ connection_dirserv_flushed_some(dir_connection_t *conn)
   if (conn->compress_state) {
     /* Flush the compression state: there could be more bytes pending in there,
      * and we don't want to omit bytes. */
-    connection_write_to_buf_compress("", 0, conn, 1);
+    connection_buf_add_compress("", 0, conn, 1);
     tor_compress_free(conn->compress_state);
     conn->compress_state = NULL;
   }
diff --git a/src/or/ext_orport.c b/src/or/ext_orport.c
index 83dc13ecf..c22a2f13d 100644
--- a/src/or/ext_orport.c
+++ b/src/or/ext_orport.c
@@ -70,10 +70,10 @@ connection_write_ext_or_command(connection_t *conn,
     return -1;
   set_uint16(header, htons(command));
   set_uint16(header+2, htons(bodylen));
-  connection_write_to_buf(header, 4, conn);
+  connection_buf_add(header, 4, conn);
   if (bodylen) {
     tor_assert(body);
-    connection_write_to_buf(body, bodylen, conn);
+    connection_buf_add(body, bodylen, conn);
   }
   return 0;
 }
@@ -171,7 +171,7 @@ connection_ext_or_auth_neg_auth_type(connection_t *conn)
   if (connection_get_inbuf_len(conn) < 1)
     return 0;
 
-  if (connection_fetch_from_buf(authtype, 1, conn) < 0)
+  if (connection_buf_get_bytes(authtype, 1, conn) < 0)
     return -1;
 
   log_debug(LD_GENERAL, "Client wants us to use %d auth type", authtype[0]);
@@ -311,7 +311,7 @@ connection_ext_or_auth_handle_client_nonce(connection_t *conn)
   if (connection_get_inbuf_len(conn) < EXT_OR_PORT_AUTH_NONCE_LEN)
     return 0;
 
-  if (connection_fetch_from_buf(client_nonce,
+  if (connection_buf_get_bytes(client_nonce,
                                 EXT_OR_PORT_AUTH_NONCE_LEN, conn) < 0)
     return -1;
 
@@ -326,7 +326,7 @@ connection_ext_or_auth_handle_client_nonce(connection_t *conn)
                             &reply, &reply_len) < 0)
     return -1;
 
-  connection_write_to_buf(reply, reply_len, conn);
+  connection_buf_add(reply, reply_len, conn);
 
   memwipe(reply, 0, reply_len);
   tor_free(reply);
@@ -348,9 +348,9 @@ static void
 connection_ext_or_auth_send_result(connection_t *conn, int success)
 {
   if (success)
-    connection_write_to_buf("\x01", 1, conn);
+    connection_buf_add("\x01", 1, conn);
   else
-    connection_write_to_buf("\x00", 1, conn);
+    connection_buf_add("\x00", 1, conn);
 }
 
 /** Receive the client's hash from <b>conn</b>, validate that it's
@@ -368,7 +368,7 @@ connection_ext_or_auth_handle_client_hash(connection_t *conn)
   if (connection_get_inbuf_len(conn) < EXT_OR_PORT_AUTH_HASH_LEN)
     return 0;
 
-  if (connection_fetch_from_buf(provided_client_hash,
+  if (connection_buf_get_bytes(provided_client_hash,
                                 EXT_OR_PORT_AUTH_HASH_LEN, conn) < 0)
     return -1;
 
@@ -638,7 +638,7 @@ connection_ext_or_start_auth(or_connection_t *or_conn)
   log_debug(LD_GENERAL,
            "ExtORPort authentication: Sending supported authentication types");
 
-  connection_write_to_buf((const char *)authtypes, sizeof(authtypes), conn);
+  connection_buf_add((const char *)authtypes, sizeof(authtypes), conn);
   conn->state = EXT_OR_CONN_STATE_AUTH_WAIT_AUTH_TYPE;
 
   return 0;
diff --git a/src/or/main.c b/src/or/main.c
index a9d4bdb6e..9dc84f7de 100644
--- a/src/or/main.c
+++ b/src/or/main.c
@@ -836,7 +836,7 @@ conn_close_if_marked(int i)
                (int)conn->outbuf_flushlen,
                 conn->marked_for_close_file, conn->marked_for_close);
     if (conn->linked_conn) {
-      retval = move_buf_to_buf(conn->linked_conn->inbuf, conn->outbuf,
+      retval = buf_move_to_buf(conn->linked_conn->inbuf, conn->outbuf,
                                &conn->outbuf_flushlen);
       if (retval >= 0) {
         /* The linked conn will notice that it has data when it notices that
@@ -850,12 +850,12 @@ conn_close_if_marked(int i)
                 connection_wants_to_flush(conn));
     } else if (connection_speaks_cells(conn)) {
       if (conn->state == OR_CONN_STATE_OPEN) {
-        retval = flush_buf_tls(TO_OR_CONN(conn)->tls, conn->outbuf, sz,
+        retval = buf_flush_to_tls(TO_OR_CONN(conn)->tls, conn->outbuf, sz,
                                &conn->outbuf_flushlen);
       } else
         retval = -1; /* never flush non-open broken tls connections */
     } else {
-      retval = flush_buf(conn->s, conn->outbuf, sz, &conn->outbuf_flushlen);
+      retval = buf_flush_to_socket(conn->s, conn->outbuf, sz, &conn->outbuf_flushlen);
     }
     if (retval >= 0 && /* Technically, we could survive things like
                           TLS_WANT_WRITE here. But don't bother for now. */
diff --git a/src/or/proto_cell.c b/src/or/proto_cell.c
index 4c86b7e4d..4ce38ebfc 100644
--- a/src/or/proto_cell.c
+++ b/src/or/proto_cell.c
@@ -57,7 +57,7 @@ fetch_var_cell_from_buf(buf_t *buf, var_cell_t **out, int linkproto)
   *out = NULL;
   if (buf_datalen(buf) < header_len)
     return 0;
-  peek_from_buf(hdr, header_len, buf);
+  buf_peek(hdr, header_len, buf);
 
   command = get_uint8(hdr + circ_id_len);
   if (!(cell_command_is_var_length(command, linkproto)))
@@ -73,9 +73,9 @@ fetch_var_cell_from_buf(buf_t *buf, var_cell_t **out, int linkproto)
   else
     result->circ_id = ntohs(get_uint16(hdr));
 
-  buf_remove_from_front(buf, header_len);
-  peek_from_buf((char*) result->payload, length, buf);
-  buf_remove_from_front(buf, length);
+  buf_drain(buf, header_len);
+  buf_peek((char*) result->payload, length, buf);
+  buf_drain(buf, length);
 
   *out = result;
   return 1;
diff --git a/src/or/proto_control0.c b/src/or/proto_control0.c
index 5478d07e4..af8478648 100644
--- a/src/or/proto_control0.c
+++ b/src/or/proto_control0.c
@@ -16,7 +16,7 @@ peek_buf_has_control0_command(buf_t *buf)
   if (buf_datalen(buf) >= 4) {
     char header[4];
     uint16_t cmd;
-    peek_from_buf(header, sizeof(header), buf);
+    buf_peek(header, sizeof(header), buf);
     cmd = ntohs(get_uint16(header+2));
     if (cmd <= 0x14)
       return 1; /* This is definitely not a v1 control command. */
diff --git a/src/or/proto_ext_or.c b/src/or/proto_ext_or.c
index d7f8cab1b..70419265d 100644
--- a/src/or/proto_ext_or.c
+++ b/src/or/proto_ext_or.c
@@ -26,15 +26,15 @@ fetch_ext_or_command_from_buf(buf_t *buf, ext_or_cmd_t **out)
 
   if (buf_datalen(buf) < EXT_OR_CMD_HEADER_SIZE)
     return 0;
-  peek_from_buf(hdr, sizeof(hdr), buf);
+  buf_peek(hdr, sizeof(hdr), buf);
   len = ntohs(get_uint16(hdr+2));
   if (buf_datalen(buf) < (unsigned)len + EXT_OR_CMD_HEADER_SIZE)
     return 0;
   *out = ext_or_cmd_new(len);
   (*out)->cmd = ntohs(get_uint16(hdr));
   (*out)->len = len;
-  buf_remove_from_front(buf, EXT_OR_CMD_HEADER_SIZE);
-  fetch_from_buf((*out)->body, len, buf);
+  buf_drain(buf, EXT_OR_CMD_HEADER_SIZE);
+  buf_get_bytes((*out)->body, len, buf);
   return 1;
 }
 
diff --git a/src/or/proto_http.c b/src/or/proto_http.c
index 3977de186..6e0316574 100644
--- a/src/or/proto_http.c
+++ b/src/or/proto_http.c
@@ -13,11 +13,11 @@
 int
 peek_buf_has_http_command(const buf_t *buf)
 {
-  if (peek_buf_startswith(buf, "CONNECT ") ||
-      peek_buf_startswith(buf, "DELETE ") ||
-      peek_buf_startswith(buf, "GET ") ||
-      peek_buf_startswith(buf, "POST ") ||
-      peek_buf_startswith(buf, "PUT " ))
+  if (buf_peek_startswith(buf, "CONNECT ") ||
+      buf_peek_startswith(buf, "DELETE ") ||
+      buf_peek_startswith(buf, "GET ") ||
+      buf_peek_startswith(buf, "POST ") ||
+      buf_peek_startswith(buf, "PUT " ))
     return 1;
   return 0;
 }
@@ -110,14 +110,14 @@ fetch_from_buf_http(buf_t *buf,
   /* all happy. copy into the appropriate places, and return 1 */
   if (headers_out) {
     *headers_out = tor_malloc(headerlen+1);
-    fetch_from_buf(*headers_out, headerlen, buf);
+    buf_get_bytes(*headers_out, headerlen, buf);
     (*headers_out)[headerlen] = 0; /* NUL terminate it */
   }
   if (body_out) {
     tor_assert(body_used);
     *body_used = bodylen;
     *body_out = tor_malloc(bodylen+1);
-    fetch_from_buf(*body_out, bodylen, buf);
+    buf_get_bytes(*body_out, bodylen, buf);
     (*body_out)[bodylen] = 0; /* NUL terminate it */
   }
   return 1;
diff --git a/src/or/proto_socks.c b/src/or/proto_socks.c
index f153658bb..f92d61491 100644
--- a/src/or/proto_socks.c
+++ b/src/or/proto_socks.c
@@ -132,7 +132,7 @@ fetch_from_buf_socks(buf_t *buf, socks_request_t *req,
     if (n_drain < 0)
       buf_clear(buf);
     else if (n_drain > 0)
-      buf_remove_from_front(buf, n_drain);
+      buf_drain(buf, n_drain);
 
   } while (res == 0 && head && want_length < buf_datalen(buf) &&
            buf_datalen(buf) >= 2);
@@ -575,7 +575,7 @@ fetch_from_buf_socks_client(buf_t *buf, int state, char **reason)
   r = parse_socks_client((uint8_t*)head, datalen,
                          state, reason, &drain);
   if (drain > 0)
-    buf_remove_from_front(buf, drain);
+    buf_drain(buf, drain);
   else if (drain < 0)
     buf_clear(buf);
 
diff --git a/src/or/relay.c b/src/or/relay.c
index 18ccc65b8..15ab730a8 100644
--- a/src/or/relay.c
+++ b/src/or/relay.c
@@ -1670,7 +1670,7 @@ connection_edge_process_relay_cell(cell_t *cell, circuit_t *circ,
       }
 
       stats_n_data_bytes_received += rh.length;
-      connection_write_to_buf((char*)(cell->payload + RELAY_HEADER_SIZE),
+      connection_buf_add((char*)(cell->payload + RELAY_HEADER_SIZE),
                               rh.length, TO_CONN(conn));
 
 #ifdef MEASUREMENTS_21206
@@ -2038,13 +2038,13 @@ connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
     /* XXXX We could be more efficient here by sometimes packing
      * previously-sent optimistic data in the same cell with data
      * from the inbuf. */
-    fetch_from_buf(payload, length, entry_conn->sending_optimistic_data);
+    buf_get_bytes(payload, length, entry_conn->sending_optimistic_data);
     if (!buf_datalen(entry_conn->sending_optimistic_data)) {
         buf_free(entry_conn->sending_optimistic_data);
         entry_conn->sending_optimistic_data = NULL;
     }
   } else {
-    connection_fetch_from_buf(payload, length, TO_CONN(conn));
+    connection_buf_get_bytes(payload, length, TO_CONN(conn));
   }
 
   log_debug(domain,TOR_SOCKET_T_FORMAT": Packaging %d bytes (%d waiting).",
@@ -2056,7 +2056,7 @@ connection_edge_package_raw_inbuf(edge_connection_t *conn, int package_partial,
        retry */
     if (!entry_conn->pending_optimistic_data)
       entry_conn->pending_optimistic_data = buf_new();
-    write_to_buf(payload, length, entry_conn->pending_optimistic_data);
+    buf_add(payload, length, entry_conn->pending_optimistic_data);
   }
 
   if (connection_edge_send_command(conn, RELAY_COMMAND_DATA,
diff --git a/src/test/test_buffers.c b/src/test/test_buffers.c
index d2d1223f3..44cfedf46 100644
--- a/src/test/test_buffers.c
+++ b/src/test/test_buffers.c
@@ -45,15 +45,15 @@ test_buffers_basic(void *arg)
   for (j=0;j<256;++j) {
     str[j] = (char)j;
   }
-  write_to_buf(str, 256, buf);
-  write_to_buf(str, 256, buf);
+  buf_add(str, 256, buf);
+  buf_add(str, 256, buf);
   tt_int_op(buf_datalen(buf),OP_EQ, 512);
-  fetch_from_buf(str2, 200, buf);
+  buf_get_bytes(str2, 200, buf);
   tt_mem_op(str,OP_EQ, str2, 200);
   tt_int_op(buf_datalen(buf),OP_EQ, 312);
   memset(str2, 0, sizeof(str2));
 
-  fetch_from_buf(str2, 256, buf);
+  buf_get_bytes(str2, 256, buf);
   tt_mem_op(str+200,OP_EQ, str2, 56);
   tt_mem_op(str,OP_EQ, str2+56, 200);
   tt_int_op(buf_datalen(buf),OP_EQ, 56);
@@ -61,16 +61,16 @@ test_buffers_basic(void *arg)
   /* Okay, now we should be 512 bytes into the 4096-byte buffer.  If we add
    * another 3584 bytes, we hit the end. */
   for (j=0;j<15;++j) {
-    write_to_buf(str, 256, buf);
+    buf_add(str, 256, buf);
   }
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tt_int_op(buf_datalen(buf),OP_EQ, 3896);
-  fetch_from_buf(str2, 56, buf);
+  buf_get_bytes(str2, 56, buf);
   tt_int_op(buf_datalen(buf),OP_EQ, 3840);
   tt_mem_op(str+200,OP_EQ, str2, 56);
   for (j=0;j<15;++j) {
     memset(str2, 0, sizeof(str2));
-    fetch_from_buf(str2, 256, buf);
+    buf_get_bytes(str2, 256, buf);
     tt_mem_op(str,OP_EQ, str2, 256);
   }
   tt_int_op(buf_datalen(buf),OP_EQ, 0);
@@ -80,38 +80,38 @@ test_buffers_basic(void *arg)
   /* Okay, now make sure growing can work. */
   buf = buf_new_with_capacity(16);
   //test_eq(buf_capacity(buf), 16);
-  write_to_buf(str+1, 255, buf);
+  buf_add(str+1, 255, buf);
   //test_eq(buf_capacity(buf), 256);
-  fetch_from_buf(str2, 254, buf);
+  buf_get_bytes(str2, 254, buf);
   tt_mem_op(str+1,OP_EQ, str2, 254);
   //test_eq(buf_capacity(buf), 256);
-  assert_buf_ok(buf);
-  write_to_buf(str, 32, buf);
+  buf_assert_ok(buf);
+  buf_add(str, 32, buf);
   //test_eq(buf_capacity(buf), 256);
-  assert_buf_ok(buf);
-  write_to_buf(str, 256, buf);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
+  buf_add(str, 256, buf);
+  buf_assert_ok(buf);
   //test_eq(buf_capacity(buf), 512);
   tt_int_op(buf_datalen(buf),OP_EQ, 33+256);
-  fetch_from_buf(str2, 33, buf);
+  buf_get_bytes(str2, 33, buf);
   tt_int_op(*str2,OP_EQ, str[255]);
 
   tt_mem_op(str2+1,OP_EQ, str, 32);
   //test_eq(buf_capacity(buf), 512);
   tt_int_op(buf_datalen(buf),OP_EQ, 256);
-  fetch_from_buf(str2, 256, buf);
+  buf_get_bytes(str2, 256, buf);
   tt_mem_op(str,OP_EQ, str2, 256);
 
   /* now try shrinking: case 1. */
   buf_free(buf);
   buf = buf_new_with_capacity(33668);
   for (j=0;j<67;++j) {
-    write_to_buf(str,255, buf);
+    buf_add(str,255, buf);
   }
   //test_eq(buf_capacity(buf), 33668);
   tt_int_op(buf_datalen(buf),OP_EQ, 17085);
   for (j=0; j < 40; ++j) {
-    fetch_from_buf(str2, 255,buf);
+    buf_get_bytes(str2, 255,buf);
     tt_mem_op(str2,OP_EQ, str, 255);
   }
 
@@ -119,18 +119,18 @@ test_buffers_basic(void *arg)
   buf_free(buf);
   buf = buf_new_with_capacity(33668);
   for (j=0;j<67;++j) {
-    write_to_buf(str,255, buf);
+    buf_add(str,255, buf);
   }
   for (j=0; j < 20; ++j) {
-    fetch_from_buf(str2, 255,buf);
+    buf_get_bytes(str2, 255,buf);
     tt_mem_op(str2,OP_EQ, str, 255);
   }
   for (j=0;j<80;++j) {
-    write_to_buf(str,255, buf);
+    buf_add(str,255, buf);
   }
   //test_eq(buf_capacity(buf),33668);
   for (j=0; j < 120; ++j) {
-    fetch_from_buf(str2, 255,buf);
+    buf_get_bytes(str2, 255,buf);
     tt_mem_op(str2,OP_EQ, str, 255);
   }
 
@@ -139,27 +139,27 @@ test_buffers_basic(void *arg)
   buf = buf_new_with_capacity(4096);
   buf2 = buf_new_with_capacity(4096);
   for (j=0;j<100;++j)
-    write_to_buf(str, 255, buf);
+    buf_add(str, 255, buf);
   tt_int_op(buf_datalen(buf),OP_EQ, 25500);
   for (j=0;j<100;++j) {
     r = 10;
-    move_buf_to_buf(buf2, buf, &r);
+    buf_move_to_buf(buf2, buf, &r);
     tt_int_op(r,OP_EQ, 0);
   }
   tt_int_op(buf_datalen(buf),OP_EQ, 24500);
   tt_int_op(buf_datalen(buf2),OP_EQ, 1000);
   for (j=0;j<3;++j) {
-    fetch_from_buf(str2, 255, buf2);
+    buf_get_bytes(str2, 255, buf2);
     tt_mem_op(str2,OP_EQ, str, 255);
   }
   r = 8192; /*big move*/
-  move_buf_to_buf(buf2, buf, &r);
+  buf_move_to_buf(buf2, buf, &r);
   tt_int_op(r,OP_EQ, 0);
   r = 30000; /* incomplete move */
-  move_buf_to_buf(buf2, buf, &r);
+  buf_move_to_buf(buf2, buf, &r);
   tt_int_op(r,OP_EQ, 13692);
   for (j=0;j<97;++j) {
-    fetch_from_buf(str2, 255, buf2);
+    buf_get_bytes(str2, 255, buf2);
     tt_mem_op(str2,OP_EQ, str, 255);
   }
   buf_free(buf);
@@ -169,7 +169,7 @@ test_buffers_basic(void *arg)
   buf = buf_new_with_capacity(5);
   cp = "Testing. This is a moderately long Testing string.";
   for (j = 0; cp[j]; j++)
-    write_to_buf(cp+j, 1, buf);
+    buf_add(cp+j, 1, buf);
   tt_int_op(0,OP_EQ, buf_find_string_offset(buf, "Testing", 7));
   tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "esting", 6));
   tt_int_op(1,OP_EQ, buf_find_string_offset(buf, "est", 3));
@@ -187,7 +187,7 @@ test_buffers_basic(void *arg)
   {
     char *mem = tor_malloc_zero(65536);
     buf = buf_new();
-    write_to_buf(mem, 65536, buf);
+    buf_add(mem, 65536, buf);
     tor_free(mem);
 
     tt_int_op(buf_datalen(buf), OP_EQ, 65536);
@@ -233,62 +233,62 @@ test_buffer_pullup(void *arg)
 
   /* Let's add some data. */
   crypto_rand(stuff, 16384);
-  write_to_buf(stuff, 3000, buf);
-  write_to_buf(stuff+3000, 3000, buf);
+  buf_add(stuff, 3000, buf);
+  buf_add(stuff+3000, 3000, buf);
   buf_pullup(buf, 0, &cp, &sz);
   tt_ptr_op(cp, OP_NE, NULL);
   tt_int_op(sz, OP_LE, 4096);
 
   /* Make room for 3000 bytes in the first chunk, so that the pullup-move code
    * can get tested. */
-  tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 3000);
+  tt_int_op(buf_get_bytes(tmp, 3000, buf), OP_EQ, 3000);
   tt_mem_op(tmp,OP_EQ, stuff, 3000);
   buf_pullup(buf, 2048, &cp, &sz);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tt_ptr_op(cp, OP_NE, NULL);
   tt_int_op(sz, OP_GE, 2048);
   tt_mem_op(cp,OP_EQ, stuff+3000, 2048);
   tt_int_op(3000, OP_EQ, buf_datalen(buf));
-  tt_int_op(fetch_from_buf(tmp, 3000, buf), OP_EQ, 0);
+  tt_int_op(buf_get_bytes(tmp, 3000, buf), OP_EQ, 0);
   tt_mem_op(tmp,OP_EQ, stuff+3000, 2048);
 
   buf_free(buf);
 
   /* Now try the large-chunk case. */
   buf = buf_new_with_capacity(3000); /* rounds up to next power of 2. */
-  write_to_buf(stuff, 4000, buf);
-  write_to_buf(stuff+4000, 4000, buf);
-  write_to_buf(stuff+8000, 4000, buf);
-  write_to_buf(stuff+12000, 4000, buf);
+  buf_add(stuff, 4000, buf);
+  buf_add(stuff+4000, 4000, buf);
+  buf_add(stuff+8000, 4000, buf);
+  buf_add(stuff+12000, 4000, buf);
   tt_int_op(buf_datalen(buf), OP_EQ, 16000);
   buf_pullup(buf, 0, &cp, &sz);
   tt_ptr_op(cp, OP_NE, NULL);
   tt_int_op(sz, OP_LE, 4096);
 
   buf_pullup(buf, 12500, &cp, &sz);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tt_ptr_op(cp, OP_NE, NULL);
   tt_int_op(sz, OP_GE, 12500);
   tt_mem_op(cp,OP_EQ, stuff, 12500);
   tt_int_op(buf_datalen(buf), OP_EQ, 16000);
 
-  fetch_from_buf(tmp, 12400, buf);
+  buf_get_bytes(tmp, 12400, buf);
   tt_mem_op(tmp,OP_EQ, stuff, 12400);
   tt_int_op(buf_datalen(buf), OP_EQ, 3600);
-  fetch_from_buf(tmp, 3500, buf);
+  buf_get_bytes(tmp, 3500, buf);
   tt_mem_op(tmp,OP_EQ, stuff+12400, 3500);
-  fetch_from_buf(tmp, 100, buf);
+  buf_get_bytes(tmp, 100, buf);
   tt_mem_op(tmp,OP_EQ, stuff+15900, 10);
 
   buf_free(buf);
 
   /* Make sure that the pull-up-whole-buffer case works */
   buf = buf_new_with_capacity(3000); /* rounds up to next power of 2. */
-  write_to_buf(stuff, 4000, buf);
-  write_to_buf(stuff+4000, 4000, buf);
-  fetch_from_buf(tmp, 100, buf); /* dump 100 bytes from first chunk */
+  buf_add(stuff, 4000, buf);
+  buf_add(stuff+4000, 4000, buf);
+  buf_get_bytes(tmp, 100, buf); /* dump 100 bytes from first chunk */
   buf_pullup(buf, 16000, &cp, &sz);
-  assert_buf_ok(buf);
+  buf_assert_ok(buf);
   tt_ptr_op(cp, OP_NE, NULL);
   tt_int_op(sz, OP_EQ, 7900);
   tt_mem_op(cp,OP_EQ, stuff+100, 7900);
@@ -324,23 +324,23 @@ test_buffer_copy(void *arg)
   /* Now try with a short buffer. */
   s = "And now comes an act of enormous enormance!";
   len = strlen(s);
-  write_to_buf(s, len, buf);
+  buf_add(s, len, buf);
   tt_int_op(len, OP_EQ, buf_datalen(buf));
   /* Add junk to buf2 so we can test replacing.*/
-  write_to_buf("BLARG", 5, buf2);
+  buf_add("BLARG", 5, buf2);
   tt_int_op(0, OP_EQ, buf_set_to_copy(&buf2, buf));
   tt_int_op(len, OP_EQ, buf_datalen(buf2));
-  fetch_from_buf(b, len, buf2);
+  buf_get_bytes(b, len, buf2);
   tt_mem_op(b, OP_EQ, s, len);
   /* Now free buf2 and retry so we can test allocating */
   buf_free(buf2);
   buf2 = NULL;
   tt_int_op(0, OP_EQ, buf_set_to_copy(&buf2, buf));
   tt_int_op(len, OP_EQ, buf_datalen(buf2));
-  fetch_from_buf(b, len, buf2);
+  buf_get_bytes(b, len, buf2);
   tt_mem_op(b, OP_EQ, s, len);
   /* Clear buf for next test */
-  fetch_from_buf(b, len, buf);
+  buf_get_bytes(b, len, buf);
   tt_int_op(buf_datalen(buf),OP_EQ,0);
 
   /* Okay, now let's try a bigger buffer. */
@@ -350,13 +350,13 @@ test_buffer_copy(void *arg)
   len = strlen(s);
   for (i = 0; i < 256; ++i) {
     b[0]=i;
-    write_to_buf(b, 1, buf);
-    write_to_buf(s, len, buf);
+    buf_add(b, 1, buf);
+    buf_add(s, len, buf);
   }
   tt_int_op(0, OP_EQ, buf_set_to_copy(&buf2, buf));
   tt_int_op(buf_datalen(buf2), OP_EQ, buf_datalen(buf));
   for (i = 0; i < 256; ++i) {
-    fetch_from_buf(b, len+1, buf2);
+    buf_get_bytes(b, len+1, buf2);
     tt_int_op((unsigned char)b[0],OP_EQ,i);
     tt_mem_op(b+1, OP_EQ, s, len);
   }
@@ -381,13 +381,13 @@ test_buffer_ext_or_cmd(void *arg)
   tt_ptr_op(NULL, OP_EQ, cmd);
 
   /* Three bytes: shouldn't work. */
-  write_to_buf("\x00\x20\x00", 3, buf);
+  buf_add("\x00\x20\x00", 3, buf);
   tt_int_op(0, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_EQ, cmd);
   tt_int_op(3, OP_EQ, buf_datalen(buf));
 
   /* 0020 0000: That's a nil command. It should work. */
-  write_to_buf("\x00", 1, buf);
+  buf_add("\x00", 1, buf);
   tt_int_op(1, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_NE, cmd);
   tt_int_op(0x20, OP_EQ, cmd->cmd);
@@ -397,10 +397,10 @@ test_buffer_ext_or_cmd(void *arg)
   cmd = NULL;
 
   /* Now try a length-6 command with one byte missing. */
-  write_to_buf("\x10\x21\x00\x06""abcde", 9, buf);
+  buf_add("\x10\x21\x00\x06""abcde", 9, buf);
   tt_int_op(0, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_EQ, cmd);
-  write_to_buf("f", 1, buf);
+  buf_add("f", 1, buf);
   tt_int_op(1, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_NE, cmd);
   tt_int_op(0x1021, OP_EQ, cmd->cmd);
@@ -411,7 +411,7 @@ test_buffer_ext_or_cmd(void *arg)
   cmd = NULL;
 
   /* Now try a length-10 command with 4 extra bytes. */
-  write_to_buf("\xff\xff\x00\x0aloremipsum\x10\x00\xff\xff", 18, buf);
+  buf_add("\xff\xff\x00\x0aloremipsum\x10\x00\xff\xff", 18, buf);
   tt_int_op(1, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_NE, cmd);
   tt_int_op(0xffff, OP_EQ, cmd->cmd);
@@ -425,7 +425,7 @@ test_buffer_ext_or_cmd(void *arg)
    * waiting. */
   tt_int_op(0, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tmp = tor_malloc_zero(65535);
-  write_to_buf(tmp, 65535, buf);
+  buf_add(tmp, 65535, buf);
   tt_int_op(1, OP_EQ, fetch_ext_or_command_from_buf(buf, &cmd));
   tt_ptr_op(NULL, OP_NE, cmd);
   tt_int_op(0x1000, OP_EQ, cmd->cmd);
@@ -461,36 +461,36 @@ test_buffer_allocation_tracking(void *arg)
   tt_int_op(buf_allocation(buf1), OP_EQ, 0);
   tt_int_op(buf_get_total_allocation(), OP_EQ, 0);
 
-  write_to_buf(junk, 4000, buf1);
-  write_to_buf(junk, 4000, buf1);
-  write_to_buf(junk, 4000, buf1);
-  write_to_buf(junk, 4000, buf1);
+  buf_add(junk, 4000, buf1);
+  buf_add(junk, 4000, buf1);
+  buf_add(junk, 4000, buf1);
+  buf_add(junk, 4000, buf1);
   tt_int_op(buf_allocation(buf1), OP_EQ, 16384);
-  fetch_from_buf(junk, 100, buf1);
+  buf_get_bytes(junk, 100, buf1);
   tt_int_op(buf_allocation(buf1), OP_EQ, 16384); /* still 4 4k chunks */
 
   tt_int_op(buf_get_total_allocation(), OP_EQ, 16384);
 
-  fetch_from_buf(junk, 4096, buf1); /* drop a 1k chunk... */
+  buf_get_bytes(junk, 4096, buf1); /* drop a 1k chunk... */
   tt_int_op(buf_allocation(buf1), OP_EQ, 3*4096); /* now 3 4k chunks */
 
   tt_int_op(buf_get_total_allocation(), OP_EQ, 12288); /* that chunk was really
                                                        freed. */
 
-  write_to_buf(junk, 4000, buf2);
+  buf_add(junk, 4000, buf2);
   tt_int_op(buf_allocation(buf2), OP_EQ, 4096); /* another 4k chunk. */
   /*
    * We bounce back up to 16384 by allocating a new chunk.
    */
   tt_int_op(buf_get_total_allocation(), OP_EQ, 16384);
-  write_to_buf(junk, 4000, buf2);
+  buf_add(junk, 4000, buf2);
   tt_int_op(buf_allocation(buf2), OP_EQ, 8192); /* another 4k chunk. */
   tt_int_op(buf_get_total_allocation(),
             OP_EQ, 5*4096); /* that chunk was new. */
 
   /* Make a really huge buffer */
   for (i = 0; i < 1000; ++i) {
-    write_to_buf(junk, 4000, buf2);
+    buf_add(junk, 4000, buf2);
   }
   tt_int_op(buf_allocation(buf2), OP_GE, 4008000);
   tt_int_op(buf_get_total_allocation(), OP_GE, 4008000);
@@ -533,7 +533,7 @@ test_buffer_time_tracking(void *arg)
   tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC));
   tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
 
-  write_to_buf("ABCDEFG", 7, buf);
+  buf_add("ABCDEFG", 7, buf);
   tt_int_op(1000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+1000));
 
   buf2 = buf_copy(buf);
@@ -544,7 +544,7 @@ test_buffer_time_tracking(void *arg)
   /* Now add more bytes; enough to overflow the first chunk. */
   monotime_coarse_set_mock_time_nsec(START_NSEC + 123 * (uint64_t)1000000);
   for (i = 0; i < 600; ++i)
-    write_to_buf("ABCDEFG", 7, buf);
+    buf_add("ABCDEFG", 7, buf);
   tt_int_op(4207, OP_EQ, buf_datalen(buf));
 
   /* The oldest bytes are still in the front. */
@@ -552,12 +552,12 @@ test_buffer_time_tracking(void *arg)
 
   /* Once those bytes are dropped, the chunk is still on the first
    * timestamp. */
-  fetch_from_buf(tmp, 100, buf);
+  buf_get_bytes(tmp, 100, buf);
   tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2000));
 
   /* But once we discard the whole first chunk, we get the data in the second
    * chunk. */
-  fetch_from_buf(tmp, 4000, buf);
+  buf_get_bytes(tmp, 4000, buf);
   tt_int_op(107, OP_EQ, buf_datalen(buf));
   tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
 
@@ -565,12 +565,12 @@ test_buffer_time_tracking(void *arg)
      its time gets updated */
   monotime_coarse_set_mock_time_nsec(START_NSEC + 5617 * (uint64_t)1000000);
   for (i = 0; i < 600; ++i)
-    write_to_buf("ABCDEFG", 7, buf);
+    buf_add("ABCDEFG", 7, buf);
   tt_int_op(4307, OP_EQ, buf_datalen(buf));
 
   tt_int_op(2000, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+2123));
-  fetch_from_buf(tmp, 4000, buf);
-  fetch_from_buf(tmp, 306, buf);
+  buf_get_bytes(tmp, 4000, buf);
+  buf_get_bytes(tmp, 306, buf);
   tt_int_op(0, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+5617));
   tt_int_op(383, OP_EQ, buf_get_oldest_chunk_timestamp(buf, START_MSEC+6000));
 
@@ -596,23 +596,23 @@ test_buffers_compress_fin_at_chunk_end_impl(compress_method_t method,
   sz = buf_get_default_chunk_size(buf);
   msg = tor_malloc_zero(sz);
 
-  write_to_buf(msg, 1, buf);
+  buf_add(msg, 1, buf);
   tt_assert(buf->head);
 
   /* Fill up the chunk so the compression stuff won't fit in one chunk. */
   tt_uint_op(buf->head->memlen, OP_LT, sz);
   headerjunk = buf->head->memlen - 7;
-  write_to_buf(msg, headerjunk-1, buf);
+  buf_add(msg, headerjunk-1, buf);
   tt_uint_op(buf->head->datalen, OP_EQ, headerjunk);
   tt_uint_op(buf_datalen(buf), OP_EQ, headerjunk);
   /* Write an empty string, with finalization on. */
   compress_state = tor_compress_new(1, method, level);
-  tt_int_op(write_to_buf_compress(buf, compress_state, "", 0, 1), OP_EQ, 0);
+  tt_int_op(buf_add_compress(buf, compress_state, "", 0, 1), OP_EQ, 0);
 
   in_len = buf_datalen(buf);
   contents = tor_malloc(in_len);
 
-  tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);
+  tt_int_op(buf_get_bytes(contents, in_len, buf), OP_EQ, 0);
 
   if (method == NO_METHOD) {
     tt_uint_op(in_len, OP_EQ, headerjunk);
@@ -655,23 +655,23 @@ test_buffers_compress_impl(compress_method_t method,
 
   msg = tor_malloc(512);
   crypto_rand(msg, 512);
-  tt_int_op(write_to_buf_compress(buf, compress_state,
+  tt_int_op(buf_add_compress(buf, compress_state,
                                   msg, 128, 0), OP_EQ, 0);
-  tt_int_op(write_to_buf_compress(buf, compress_state,
+  tt_int_op(buf_add_compress(buf, compress_state,
                                   msg+128, 128, 0), OP_EQ, 0);
-  tt_int_op(write_to_buf_compress(buf, compress_state,
+  tt_int_op(buf_add_compress(buf, compress_state,
                                   msg+256, 256, 0), OP_EQ, 0);
   done = !finalize_with_nil;
-  tt_int_op(write_to_buf_compress(buf, compress_state,
+  tt_int_op(buf_add_compress(buf, compress_state,
                                   "all done", 9, done), OP_EQ, 0);
   if (finalize_with_nil) {
-    tt_int_op(write_to_buf_compress(buf, compress_state, "", 0, 1), OP_EQ, 0);
+    tt_int_op(buf_add_compress(buf, compress_state, "", 0, 1), OP_EQ, 0);
   }
 
   in_len = buf_datalen(buf);
   contents = tor_malloc(in_len);
 
-  tt_int_op(fetch_from_buf(contents, in_len, buf), OP_EQ, 0);
+  tt_int_op(buf_get_bytes(contents, in_len, buf), OP_EQ, 0);
 
   tt_int_op(0, OP_EQ, tor_uncompress(&expanded, &out_len,
                                      contents, in_len,
@@ -765,11 +765,11 @@ test_buffers_tls_read_mocked(void *arg)
   buf = buf_new();
 
   next_reply_val[0] = 1024;
-  tt_int_op(128, OP_EQ, read_to_buf_tls(NULL, 128, buf));
+  tt_int_op(128, OP_EQ, buf_read_from_tls(NULL, 128, buf));
 
   next_reply_val[0] = 5000;
   next_reply_val[1] = 5000;
-  tt_int_op(6000, OP_EQ, read_to_buf_tls(NULL, 6000, buf));
+  tt_int_op(6000, OP_EQ, buf_read_from_tls(NULL, 6000, buf));
 
  done:
   UNMOCK(tor_tls_read);
@@ -849,19 +849,19 @@ test_buffer_peek_startswith(void *arg)
   buf = buf_new();
   tt_ptr_op(buf, OP_NE, NULL);
 
-  tt_assert(peek_buf_startswith(buf, ""));
-  tt_assert(! peek_buf_startswith(buf, "X"));
+  tt_assert(buf_peek_startswith(buf, ""));
+  tt_assert(! buf_peek_startswith(buf, "X"));
 
-  write_to_buf("Tor", 3, buf);
+  buf_add("Tor", 3, buf);
 
-  tt_assert(peek_buf_startswith(buf, ""));
-  tt_assert(peek_buf_startswith(buf, "T"));
-  tt_assert(peek_buf_startswith(buf, "To"));
-  tt_assert(peek_buf_startswith(buf, "Tor"));
-  tt_assert(! peek_buf_startswith(buf, "Top"));
-  tt_assert(! peek_buf_startswith(buf, "For"));
-  tt_assert(! peek_buf_startswith(buf, "Tork"));
-  tt_assert(! peek_buf_startswith(buf, "Torpor"));
+  tt_assert(buf_peek_startswith(buf, ""));
+  tt_assert(buf_peek_startswith(buf, "T"));
+  tt_assert(buf_peek_startswith(buf, "To"));
+  tt_assert(buf_peek_startswith(buf, "Tor"));
+  tt_assert(! buf_peek_startswith(buf, "Top"));
+  tt_assert(! buf_peek_startswith(buf, "For"));
+  tt_assert(! buf_peek_startswith(buf, "Tork"));
+  tt_assert(! buf_peek_startswith(buf, "Torpor"));
 
  done:
   buf_free(buf);
diff --git a/src/test/test_extorport.c b/src/test/test_extorport.c
index fc9f27a5a..f8ee94c3a 100644
--- a/src/test/test_extorport.c
+++ b/src/test/test_extorport.c
@@ -78,7 +78,7 @@ connection_write_to_buf_impl_replacement(const char *string, size_t len,
 
   tor_assert(string);
   tor_assert(conn);
-  write_to_buf(string, len, conn->outbuf);
+  buf_add(string, len, conn->outbuf);
 }
 
 static char *
@@ -89,7 +89,7 @@ buf_get_contents(buf_t *buf, size_t *sz_out)
   if (*sz_out >= ULONG_MAX)
     return NULL; /* C'mon, really? */
   out = tor_malloc(*sz_out + 1);
-  if (fetch_from_buf(out, (unsigned long)*sz_out, buf) != 0) {
+  if (buf_get_bytes(out, (unsigned long)*sz_out, buf) != 0) {
     tor_free(out);
     return NULL;
   }
@@ -399,14 +399,14 @@ handshake_start(or_connection_t *conn, int receiving)
 
 #define WRITE(s,n)                                                      \
   do {                                                                  \
-    write_to_buf((s), (n), TO_CONN(conn)->inbuf);                       \
+    buf_add((s), (n), TO_CONN(conn)->inbuf);                       \
   } while (0)
 #define CONTAINS(s,n)                                           \
   do {                                                          \
     tt_int_op((n), OP_LE, sizeof(b));                              \
     tt_int_op(buf_datalen(TO_CONN(conn)->outbuf), OP_EQ, (n));     \
     if ((n)) {                                                  \
-      fetch_from_buf(b, (n), TO_CONN(conn)->outbuf);            \
+      buf_get_bytes(b, (n), TO_CONN(conn)->outbuf);            \
       tt_mem_op(b, OP_EQ, (s), (n));                               \
     }                                                           \
   } while (0)
diff --git a/src/test/test_helpers.c b/src/test/test_helpers.c
index 4c0580cff..997f24737 100644
--- a/src/test/test_helpers.c
+++ b/src/test/test_helpers.c
@@ -114,7 +114,7 @@ connection_write_to_buf_mock(const char *string, size_t len,
   tor_assert(string);
   tor_assert(conn);
 
-  write_to_buf(string, len, conn->outbuf);
+  buf_add(string, len, conn->outbuf);
 }
 
 /* Set up a fake origin circuit with the specified number of cells,
diff --git a/src/test/test_oom.c b/src/test/test_oom.c
index f03a504d1..2391a3052 100644
--- a/src/test/test_oom.c
+++ b/src/test/test_oom.c
@@ -67,7 +67,7 @@ add_bytes_to_buf(buf_t *buf, size_t n_bytes)
   while (n_bytes) {
     size_t this_add = n_bytes > sizeof(b) ? sizeof(b) : n_bytes;
     crypto_rand(b, this_add);
-    write_to_buf(b, this_add, buf);
+    buf_add(b, this_add, buf);
     n_bytes -= this_add;
   }
 }
diff --git a/src/test/test_socks.c b/src/test/test_socks.c
index 571f45735..0791db9a1 100644
--- a/src/test/test_socks.c
+++ b/src/test/test_socks.c
@@ -44,7 +44,7 @@ static const struct testcase_setup_t socks_setup = {
   buf_t *buf = testdata->buf;                   \
   socks_request_t *socks = testdata->req;
 #define ADD_DATA(buf, s)                                        \
-  write_to_buf(s, sizeof(s)-1, buf)
+  buf_add(s, sizeof(s)-1, buf)
 
 static void
 socks_request_clear(socks_request_t *socks)





More information about the tor-commits mailing list