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\(/;

1 files changed, 101 insertions, 101 deletions

diff --git a/src/test/test_buffers.c b/src/test/test_buffers.c
index d2d1223f31..44cfedf463 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);