have llarp_ev_* use llarp_buffer_t

include/llarp/dns.hpp

@@ -115,7 +115,6 @@ extern "C"
 
   void
   llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
-                            const struct sockaddr *addr, const void *buf,
-                            ssize_t sz);
+                            const struct sockaddr *addr, llarp_buffer_t buf);
 }
 #endif

include/llarp/dnsc.hpp

@@ -50,8 +50,7 @@ struct dnsc_answer_request
 /// event handler for processing DNS responses
 void
 llarp_handle_dnsc_recvfrom(struct llarp_udp_io *const udp,
-                           const struct sockaddr *addr, const void *buf,
-                           const ssize_t sz);
+                           const struct sockaddr *addr, llarp_buffer_t buf);
 
 /// generic handler for processing DNS responses
 /// this doesn't look like it exists

include/llarp/dnsd.hpp

@@ -16,7 +16,7 @@ struct dnsd_context;
 /// sendto hook functor
 using sendto_dns_hook_func =
     std::function< ssize_t(void *sock, const struct sockaddr *from,
-                           const void *buffer, size_t length) >;
+                           llarp_buffer_t) >;
 // FIXME: llarp::Addr
 
 /// DNS server query request
@@ -53,8 +53,7 @@ struct dnsd_query_hook_response
 /// called by the llarp_handle_dns_recvfrom generic (dnsd/dnsc) handler in dns
 void
 llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
-                           const struct sockaddr *addr, const void *buf,
-                           ssize_t sz);
+                           const struct sockaddr *addr,llarp_buffer_t buf);
 
 //
 // output structures/functions:

include/llarp/ev.h

@@ -15,6 +15,7 @@
 #include <stdlib.h>
 #include <tuntap.h>
 #include <llarp/time.hpp>
+#include <llarp/buffer.h>
 
 /**
  * ev.h
@@ -64,9 +65,8 @@ struct llarp_udp_io
 
   /// called every event loop tick after reads
   void (*tick)(struct llarp_udp_io *);
-  // sockaddr * is the source
-  void (*recvfrom)(struct llarp_udp_io *, const struct sockaddr *, const void *,
-                   ssize_t);
+  /// sockaddr * is the source address
+  void (*recvfrom)(struct llarp_udp_io *, const struct sockaddr *,llarp_buffer_t);
 };
 
 /// add UDP handler
@@ -74,10 +74,10 @@ int
 llarp_ev_add_udp(struct llarp_ev_loop *ev, struct llarp_udp_io *udp,
                  const struct sockaddr *src);
 
-/// schedule UDP packet
+/// send a UDP packet
 int
 llarp_ev_udp_sendto(struct llarp_udp_io *udp, const struct sockaddr *to,
-                    const void *data, size_t sz);
+                    llarp_buffer_t pkt);
 
 /// close UDP handler
 int
@@ -96,7 +96,7 @@ struct llarp_tcp_conn
   /// parent loop (dont set me)
   struct llarp_ev_loop *loop;
   /// handle read event
-  void (*read)(struct llarp_tcp_conn *, const void *, size_t);
+  void (*read)(struct llarp_tcp_conn *, llarp_buffer_t);
   /// handle close event (free-ing is handled by event loop)
   void (*closed)(struct llarp_tcp_conn *);
   /// handle event loop tick
@@ -106,7 +106,7 @@ struct llarp_tcp_conn
 /// queue async write a buffer in full
 /// return if we queueed it or not
 bool
-llarp_tcp_conn_async_write(struct llarp_tcp_conn *, const void *, size_t);
+llarp_tcp_conn_async_write(struct llarp_tcp_conn *, llarp_buffer_t);
 
 /// close a tcp connection
 void
@@ -181,7 +181,7 @@ struct llarp_tun_io
   void (*before_write)(struct llarp_tun_io *);
   /// called every event loop tick after reads
   void (*tick)(struct llarp_tun_io *);
-  void (*recvpkt)(struct llarp_tun_io *, const void *, ssize_t);
+  void (*recvpkt)(struct llarp_tun_io *, llarp_buffer_t);
 };
 
 /// create tun interface with network interface name ifname
@@ -192,6 +192,6 @@ llarp_ev_add_tun(struct llarp_ev_loop *ev, struct llarp_tun_io *tun);
 /// async write a packet on tun interface
 /// returns true if queued, returns false on drop
 bool
-llarp_ev_tun_async_write(struct llarp_tun_io *tun, const void *pkt, size_t sz);
+llarp_ev_tun_async_write(struct llarp_tun_io *tun, llarp_buffer_t);
 
 #endif

include/llarp/handlers/tun.hpp

@@ -85,7 +85,7 @@ namespace llarp
 
       /// called every time we wish to read a packet from the tun interface
       static void
-      tunifRecvPkt(llarp_tun_io* t, const void* pkt, ssize_t sz);
+      tunifRecvPkt(llarp_tun_io* t, llarp_buffer_t buf);
 
       /// called in the endpoint logic thread
       static void

include/llarp/link/server.hpp

@@ -39,8 +39,7 @@ namespace llarp
     }
 
     static void
-    udp_recv_from(llarp_udp_io* udp, const sockaddr* from, const void* buf,
-                  const ssize_t sz)
+    udp_recv_from(llarp_udp_io* udp, const sockaddr* from, llarp_buffer_t buf)
     {
       if(!udp)
       {
@@ -48,7 +47,8 @@ namespace llarp
         return;
       }
       // maybe chekc from too?
-      static_cast< ILinkLayer* >(udp->user)->RecvFrom(*from, buf, sz);
+      // no it's never null
+      static_cast< ILinkLayer* >(udp->user)->RecvFrom(*from, buf.base, buf.sz);
     }
 
     bool

include/llarp/service/address.hpp

@@ -9,6 +9,7 @@ namespace llarp
 {
   namespace service
   {
+    /// Snapp Address
     struct Address
     {
       std::string

libabyss/src/client.cpp

@@ -2,6 +2,7 @@
 #include <abyss/http.hpp>
 #include <llarp/logger.hpp>
 #include <llarp/crypto.hpp>
+#include <llarp/buffer.hpp>
 
 namespace abyss
 {
@@ -59,10 +60,10 @@ namespace abyss
       }
 
       static void
-      OnRead(llarp_tcp_conn* conn, const void* buf, size_t sz)
+      OnRead(llarp_tcp_conn* conn, llarp_buffer_t buf)
       {
         ConnImpl* self = static_cast< ConnImpl* >(conn->user);
-        if(!self->ProcessRead((const char*)buf, sz))
+        if(!self->ProcessRead((const char*)buf.base, buf.sz))
           self->CloseError();
       }
 
@@ -219,7 +220,7 @@ namespace abyss
                           body.size());
         if(sz <= 0)
           return;
-        if(!llarp_tcp_conn_async_write(m_Conn, buf, sz))
+        if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(buf, sz)))
         {
           llarp::LogError("failed to write first part of request");
           CloseError();
@@ -235,40 +236,40 @@ namespace abyss
         for(const auto& item : m_SendHeaders)
         {
           // header name
-          if(!llarp_tcp_conn_async_write(m_Conn, item.first.c_str(),
-                                         item.first.size()))
+          if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(item.first.c_str(),
+                                         item.first.size())))
           {
             CloseError();
             return;
           }
           // header delimiter
-          if(!llarp_tcp_conn_async_write(m_Conn, buf, 2 * sizeof(char)))
+          if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(buf, 2 * sizeof(char))))
           {
             CloseError();
             return;
           }
           // header value
-          if(!llarp_tcp_conn_async_write(m_Conn, item.second.c_str(),
-                                         item.second.size()))
+          if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(item.second.c_str(),
+                                         item.second.size())))
           {
             CloseError();
             return;
           }
           // CRLF
-          if(!llarp_tcp_conn_async_write(m_Conn, buf + 2, 2 * sizeof(char)))
+          if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(buf + 2, 2 * sizeof(char))))
           {
             CloseError();
             return;
           }
         }
         // CRLF
-        if(!llarp_tcp_conn_async_write(m_Conn, buf + 2, 2 * sizeof(char)))
+        if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(buf + 2, 2 * sizeof(char))))
         {
           CloseError();
           return;
         }
         // request body
-        if(!llarp_tcp_conn_async_write(m_Conn, body.c_str(), body.size()))
+        if(!llarp_tcp_conn_async_write(m_Conn, llarp::InitBuffer(body.c_str(), body.size())))
         {
           CloseError();
           return;

libabyss/src/server.cpp

@@ -1,6 +1,7 @@
 #include <abyss/server.hpp>
 #include <abyss/http.hpp>
 #include <llarp/time.hpp>
+#include <llarp/buffer.hpp>
 #include <sstream>
 #include <unordered_map>
 #include <string>
@@ -109,12 +110,12 @@ namespace abyss
                           code, msg.c_str(), contentType, contentLength);
         if(sz <= 0)
           return false;
-        if(!llarp_tcp_conn_async_write(_conn, buf, sz))
+        if(!llarp_tcp_conn_async_write(_conn, llarp::InitBuffer(buf, sz)))
           return false;
 
         m_State = eWriteHTTPBody;
 
-        return llarp_tcp_conn_async_write(_conn, content, contentLength);
+        return llarp_tcp_conn_async_write(_conn, llarp::InitBuffer(content,  contentLength));
       }
 
       bool
@@ -256,10 +257,10 @@ namespace abyss
       }
 
       static void
-      OnRead(llarp_tcp_conn* conn, const void* buf, size_t sz)
+      OnRead(llarp_tcp_conn* conn, llarp_buffer_t buf)
       {
         ConnImpl* self = static_cast< ConnImpl* >(conn->user);
-        if(!self->ProcessRead((const char*)buf, sz))
+        if(!self->ProcessRead((const char *)buf.base, buf.sz))
           self->MarkBad();
       }
 

llarp/dns.cpp

@@ -433,10 +433,9 @@ extern "C"
 
   void
   llarp_handle_dns_recvfrom(struct llarp_udp_io *udp,
-                            const struct sockaddr *addr, const void *buf,
-                            ssize_t sz)
+                            const struct sockaddr *addr, llarp_buffer_t buf)
   {
-    unsigned char *castBuf = (unsigned char *)buf;
+    unsigned char *castBuf = buf.base;
     // auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
     dns_msg_header *hdr = decode_hdr((const char *)castBuf);
     // castBuf += 12;
@@ -453,12 +452,12 @@ extern "C"
     if(hdr->qr)
     {
       llarp::LogDebug("handling as dnsc answer");
-      llarp_handle_dnsc_recvfrom(udp, addr, buf, sz);
+      llarp_handle_dnsc_recvfrom(udp, addr, buf);
     }
     else
     {
       llarp::LogDebug("handling as dnsd question");
-      llarp_handle_dnsd_recvfrom(udp, addr, buf, sz);
+      llarp_handle_dnsd_recvfrom(udp, addr, buf);
     }
     delete hdr;
     /*

llarp/dnsc.cpp

@@ -590,14 +590,13 @@ raw_resolve_host(struct dnsc_context *const dnsc, const char *url,
 /// intermediate udp_io handler
 void
 llarp_handle_dnsc_recvfrom(struct llarp_udp_io *const udp,
-                           const struct sockaddr *saddr, const void *buf,
-                           const ssize_t sz)
+                           const struct sockaddr *saddr, llarp_buffer_t buf)
 {
   if(!saddr)
   {
     llarp::LogWarn("saddr isnt set");
   }
-  unsigned char *castBuf = (unsigned char *)buf;
+  unsigned char *castBuf = buf.base;
   // auto buffer            = llarp::StackBuffer< decltype(castBuf) >(castBuf);
   dns_msg_header *hdr = decode_hdr((const char *)castBuf);
 
@@ -610,7 +609,7 @@ llarp_handle_dnsc_recvfrom(struct llarp_udp_io *const udp,
   // sometimes we'll get double responses
   if(request)
   {
-    generic_handle_dnsc_recvfrom(request, saddr, buf, sz);
+    generic_handle_dnsc_recvfrom(request, saddr, buf.base, buf.sz);
   }
   else
   {
@@ -680,7 +679,7 @@ llarp_resolve_host(struct dnsc_context *const dnsc, const char *url,
 
   // ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->server, bytes, length);
   ssize_t ret = llarp_ev_udp_sendto(dnsc->udp, dnsc->resolvers[0],
-                                    dns_packet->request, dns_packet->length);
+                                    llarp::InitBuffer(dns_packet->request, dns_packet->length));
   delete dns_packet;
   if(ret < 0)
   {

llarp/dnsd.cpp

@@ -12,17 +12,17 @@ constexpr size_t BUFFER_SIZE = 1500;
 
 ssize_t
 raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
-                         const void *buffer, size_t length)
+                        llarp_buffer_t buf)
 {
   int *fd = (int *)sock;
   // how do we get to these??
   socklen_t addrLen = sizeof(struct sockaddr_in);
-  return sendto(*fd, (const char *)buffer, length, 0, from, addrLen);
+  return sendto(*fd, buf.base, buf.sz, 0, from, addrLen);
 }
 
 ssize_t
 llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
-                           const void *buffer, size_t length)
+                           llarp_buffer_t buf)
 {
   struct llarp_udp_io *udp = (struct llarp_udp_io *)sock;
   if(!udp)
@@ -35,7 +35,7 @@ llarp_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
   // this call isn't calling the function...
   // llarp::ev_io * evio = static_cast< llarp::ev_io * >(udp->impl);
   // printf("ev_io[%x]\n", evio);
-  return llarp_ev_udp_sendto(udp, from, buffer, length);
+  return llarp_ev_udp_sendto(udp, from, buf);
 }
 
 void
@@ -75,7 +75,7 @@ write404_dnss_response(const struct sockaddr *from,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending 404, ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 void
@@ -143,7 +143,7 @@ writecname_dnss_response(std::string cname, const struct sockaddr *from,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending cname, ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 void
@@ -182,7 +182,7 @@ writesend_dnss_revresponse(std::string reverse, const struct sockaddr *from,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending reverse: ", reverse, " ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 // FIXME: we need an DNS answer not a sockaddr
@@ -250,7 +250,7 @@ writesend_dnss_response(llarp::huint32_t *hostRes, const struct sockaddr *from,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending found, ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 void
@@ -293,7 +293,7 @@ writesend_dnss_mxresponse(uint16_t priority, std::string mx,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending found, ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 void
@@ -336,7 +336,7 @@ writesend_dnss_txtresponse(std::string txt, const struct sockaddr *from,
   uint32_t out_bytes = write_buffer - bufferBegin;
   llarp::LogDebug("Sending found, ", out_bytes, " bytes");
   // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
-  request->sendto_hook(request->user, from, buf, out_bytes);
+  request->sendto_hook(request->user, from, llarp::InitBuffer(buf, out_bytes));
 }
 
 void
@@ -505,8 +505,7 @@ handle_recvfrom(const char *buffer, __attribute__((unused)) ssize_t nbytes,
 
 void
 llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
-                           const struct sockaddr *saddr, const void *buf,
-                           ssize_t sz)
+                           const struct sockaddr *saddr, llarp_buffer_t buf)
 {
   if(!dns_udp_tracker.dnsd)
   {
@@ -524,7 +523,7 @@ llarp_handle_dnsd_recvfrom(struct llarp_udp_io *udp,
       &llarp_sendto_dns_hook_func;  // set sock hook
 
   // llarp::LogInfo("Server request's UDP ", llarp_dns_request->user);
-  handle_recvfrom((char *)buf, sz, llarp_dns_request->from, llarp_dns_request);
+  handle_recvfrom((const char*)buf.base, buf.sz, llarp_dns_request->from, llarp_dns_request);
 }
 
 void

llarp/ev.cpp

@@ -108,9 +108,9 @@ llarp_ev_loop_stop(struct llarp_ev_loop *loop)
 
 int
 llarp_ev_udp_sendto(struct llarp_udp_io *udp, const sockaddr *to,
-                    const void *buf, size_t sz)
+                    llarp_buffer_t buf)
 {
-  auto ret = static_cast< llarp::ev_io * >(udp->impl)->sendto(to, buf, sz);
+  auto ret = static_cast< llarp::ev_io * >(udp->impl)->sendto(to, buf.base, buf.sz);
   if(ret == -1 && errno != 0)
   {
     llarp::LogWarn("sendto failed ", strerror(errno));
@@ -132,24 +132,24 @@ llarp_ev_add_tun(struct llarp_ev_loop *loop, struct llarp_tun_io *tun)
 }
 
 bool
-llarp_tcp_conn_async_write(struct llarp_tcp_conn *conn, const void *pkt,
-                           size_t sz)
+llarp_tcp_conn_async_write(struct llarp_tcp_conn *conn, llarp_buffer_t buf)
 {
-  const byte_t *ptr     = (const byte_t *)pkt;
   llarp::tcp_conn *impl = static_cast< llarp::tcp_conn * >(conn->impl);
   if(impl->_shouldClose)
   {
     llarp::LogError("write on closed connection");
     return false;
   }
+  size_t sz = buf.sz;
+  buf.cur = buf.base;
   while(sz > EV_WRITE_BUF_SZ)
   {
-    if(!impl->queue_write((const byte_t *)ptr, EV_WRITE_BUF_SZ))
+    if(!impl->queue_write(buf.cur, EV_WRITE_BUF_SZ))
       return false;
-    ptr += EV_WRITE_BUF_SZ;
+    buf.cur += EV_WRITE_BUF_SZ;
     sz -= EV_WRITE_BUF_SZ;
   }
-  return impl->queue_write(ptr, sz);
+  return impl->queue_write(buf.cur, sz);
 }
 
 void
@@ -214,15 +214,15 @@ llarp_tcp_acceptor_close(struct llarp_tcp_acceptor *tcp)
 }
 
 bool
-llarp_ev_tun_async_write(struct llarp_tun_io *tun, const void *buf, size_t sz)
+llarp_ev_tun_async_write(struct llarp_tun_io *tun, llarp_buffer_t buf)
 {
-  if(sz > EV_WRITE_BUF_SZ)
+  if(buf.sz > EV_WRITE_BUF_SZ)
   {
-    llarp::LogWarn("packet too big, ", sz, " > ", EV_WRITE_BUF_SZ);
+    llarp::LogWarn("packet too big, ", buf.sz, " > ", EV_WRITE_BUF_SZ);
     return false;
   }
   return static_cast< llarp::tun * >(tun->impl)->queue_write(
-      (const byte_t *)buf, sz);
+     buf.base, buf.sz);
 }
 
 void

llarp/ev_epoll.hpp

@@ -34,7 +34,7 @@ namespace llarp
     if(amount > 0)
     {
       if(tcp.read)
-        tcp.read(&tcp, buf, amount);
+        tcp.read(&tcp, llarp::InitBuffer(buf, amount));
     }
     else
     {
@@ -144,7 +144,7 @@ namespace llarp
         return -1;
       if(static_cast< size_t >(ret) > sz)
         return -1;
-      udp->recvfrom(udp, addr, buf, ret);
+      udp->recvfrom(udp, addr, llarp::InitBuffer(buf, ret));
       return 0;
     }
 
@@ -219,7 +219,7 @@ namespace llarp
       if(ret > 0 && t->recvpkt)
       {
         // does not have pktinfo
-        t->recvpkt(t, buf, ret);
+        t->recvpkt(t, llarp::InitBuffer(buf,ret));
       }
       return ret;
     }

llarp/ev_kqueue.hpp

@@ -26,7 +26,7 @@ namespace llarp
     if(sz == 0)
     {
       if(tcp.read)
-        tcp.read(&tcp, 0, 0);
+        tcp.read(&tcp, llarp::InitBuffer(nullptr,0));
       return 0;
     }
     if(_shouldClose)
@@ -37,7 +37,7 @@ namespace llarp
     if(amount >= 0)
     {
       if(tcp.read)
-        tcp.read(&tcp, buf, amount);
+        tcp.read(&tcp, llarp::InitBuffer(buf, amount));
     }
     else
     {
@@ -176,7 +176,7 @@ namespace llarp
         llarp::LogWarn("no source addr");
       }
       // Addr is the source
-      udp->recvfrom(udp, addr, buf, ret);
+      udp->recvfrom(udp, addr, llarp::InitBuffer(buf, ret));
       return 0;
     }
 
@@ -271,7 +271,11 @@ namespace llarp
 #endif
       ssize_t ret = tuntap_read(tunif, buf, sz);
       if(ret > offset && t->recvpkt)
-        t->recvpkt(t, ((byte_t*)buf) + offset, ret - offset);
+      {
+        byte_t * ptr = ((byte_t*)buf) + offset;
+        ret -= offset;
+        t->recvpkt(t, llarp::InitBuffer(ptr, ret));
+      }
       return ret;
     }
 

llarp/ev_win32.hpp

@@ -28,7 +28,7 @@ namespace llarp
     if(amount > 0)
     {
       if(tcp.read)
-        tcp.read(&tcp, buf, amount);
+        tcp.read(&tcp, llarp::InitBuffer(buf, amount);
     }
     else
     {
@@ -153,7 +153,7 @@ namespace llarp
         llarp::LogWarn("recv socket error ", s_errno);
         return -1;
       }
-      udp->recvfrom(udp, addr, buf, sz);
+      udp->recvfrom(udp, addr, llarp::InitBuffer(buf, sz));
       return 0;
     }
 
@@ -195,7 +195,7 @@ namespace llarp
     OVERLAPPED* tun_async[2];
     tun(llarp_tun_io* tio, llarp_ev_loop* l)
         : ev_io(INVALID_HANDLE_VALUE,
-                new LossyWriteQueue_t("win32_tun_write", l))
+                new LossyWriteQueue_t("win32_tun_write", l, l))
         , t(tio)
         , tunif(tuntap_init()){};
 
@@ -240,7 +240,7 @@ namespace llarp
       if(ret > 0 && t->recvpkt)
         // should have pktinfo
         // I have no idea...
-        t->recvpkt(t, (byte_t*)buf, ret);
+        t->recvpkt(t, llarp::InitBuffer(buf, ret));
       return ret;
     }
 

llarp/handlers/exit.cpp

@@ -9,10 +9,9 @@ namespace llarp
   namespace handlers
   {
     static void
-    ExitHandlerRecvPkt(llarp_tun_io *tun, const void *pkt, ssize_t sz)
+    ExitHandlerRecvPkt(llarp_tun_io *tun, llarp_buffer_t buf)
     {
-      static_cast< ExitEndpoint * >(tun->user)->OnInetPacket(
-          llarp::InitBuffer(pkt, sz));
+      static_cast< ExitEndpoint * >(tun->user)->OnInetPacket(buf);
     }
     static void
     ExitHandlerFlushInbound(llarp_tun_io *tun)
@@ -174,7 +173,7 @@ namespace llarp
     bool
     ExitEndpoint::QueueOutboundTraffic(llarp_buffer_t buf)
     {
-      return llarp_ev_tun_async_write(&m_Tun, buf.base, buf.sz);
+      return llarp_ev_tun_async_write(&m_Tun, buf);
     }
 
     void

llarp/handlers/tun.cpp

@@ -514,7 +514,7 @@ namespace llarp
       // called in the isolated network thread
       TunEndpoint *self = static_cast< TunEndpoint * >(tun->user);
       self->m_NetworkToUserPktQueue.Process([tun](net::IPv4Packet &pkt) {
-        if(!llarp_ev_tun_async_write(tun, pkt.buf, pkt.sz))
+        if(!llarp_ev_tun_async_write(tun, pkt.Buffer()))
           llarp::LogWarn("packet dropped");
       });
       if(self->m_UserToNetworkPktQueue.Size())
@@ -529,19 +529,18 @@ namespace llarp
     }
 
     void
-    TunEndpoint::tunifRecvPkt(llarp_tun_io *tun, const void *buf, ssize_t sz)
+    TunEndpoint::tunifRecvPkt(llarp_tun_io *tun, llarp_buffer_t buf)
     {
       // called for every packet read from user in isolated network thread
       TunEndpoint *self = static_cast< TunEndpoint * >(tun->user);
-      llarp::LogDebug("got pkt ", sz, " bytes");
       if(!self->m_UserToNetworkPktQueue.EmplaceIf(
-             [buf, sz](net::IPv4Packet &pkt) -> bool {
-               return pkt.Load(llarp::InitBuffer(buf, sz))
+             [buf](net::IPv4Packet &pkt) -> bool {
+               return pkt.Load(buf)
                    && pkt.Header()->version == 4;
              }))
       {
         llarp::LogInfo("Failed to parse ipv4 packet");
-        llarp::DumpBuffer(llarp::InitBuffer(buf, sz));
+        llarp::DumpBuffer(buf);
       }
     }
 

llarp/service/address.cpp

@@ -22,7 +22,7 @@ namespace llarp
       auto sub = str.substr(0, pos);
       // make sure it's lowercase
       std::transform(sub.begin(), sub.end(), sub.begin(), ::tolower);
-      ;
+
       return Base32Decode(sub, *this);
     }
   }  // namespace service

test/test_dns_unit.cpp

@@ -189,7 +189,7 @@ TEST_F(DNSTest, handleDNSrecvFrom)
   llarp::Zero(&buffer, 15);
   ssize_t sz = 0;
   // hdr->qr decides dnsc (1) or dnsd (0)
-  llarp_handle_dns_recvfrom((llarp_udp_io *)&udp, &addr, buffer, sz);
+  llarp_handle_dns_recvfrom((llarp_udp_io *)&udp, &addr, llarp::InitBuffer(buffer, sz));
   // llarp_handle_dnsc_recvfrom
   // llarp_handle_dnsd_recvfrom
 }

test/test_dnsd_unit.cpp

@@ -10,17 +10,17 @@ std::string g_result  = "";
 ssize_t
 test_sendto_dns_hook(__attribute__((unused)) void *sock,
                      __attribute__((unused)) const struct sockaddr *from,
-                     const void *buffer, size_t length)
+                     llarp_buffer_t buf)
 {
-  char *hex_buffer       = new char[length * 3 + 1];
-  hex_buffer[length * 3] = 0;
-  for(unsigned int j = 0; j < length; j++)
-    sprintf(&hex_buffer[3 * j], "%02X ", ((const char *)buffer)[j]);
+  char *hex_buffer       = new char[buf.sz * 3 + 1];
+  hex_buffer[buf.sz* 3] = 0;
+  for(unsigned int j = 0; j < buf.sz; j++)
+    sprintf(&hex_buffer[3 * j], "%02X ", ((char*)buf.base)[j]);
   // printf("Got [%zu] bytes: [%s]\n", length, hex_buffer);
   g_result = hex_buffer;
-  g_length = length;
+  g_length = buf.sz;
   delete[] hex_buffer;
-  return length;
+  return buf.sz;
 }
 
 struct llarpDNSdTest : public ::testing::Test