13 files changed, 2272 insertions, 0 deletions
diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt
new file mode 100644
index 000000000..a5bf9c5f1
--- /dev/null
+++ b/host/lib/transport/CMakeLists.txt
@@ -0,0 +1,96 @@
+#
+# Copyright 2010-2011 Ettus Research LLC
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+########################################################################
+# This file included, use CMake directory variables
+########################################################################
+
+########################################################################
+# Setup libusb
+########################################################################
+MESSAGE(STATUS "")
+FIND_PACKAGE(USB1)
+
+LIBUHD_REGISTER_COMPONENT("USB" ENABLE_USB ON "ENABLE_LIBUHD;LIBUSB_FOUND" OFF)
+
+IF(ENABLE_USB)
+    MESSAGE(STATUS "USB support enabled via libusb.")
+    INCLUDE_DIRECTORIES(${LIBUSB_INCLUDE_DIR})
+    LIBUHD_APPEND_LIBS(${LIBUSB_LIBRARIES})
+    LIBUHD_APPEND_SOURCES(
+        ${CMAKE_CURRENT_SOURCE_DIR}/libusb1_control.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/libusb1_zero_copy.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/libusb1_base.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/libusb1_base.hpp
+    )
+ELSE(ENABLE_USB)
+    LIBUHD_APPEND_SOURCES(
+        ${CMAKE_CURRENT_SOURCE_DIR}/usb_dummy_impl.cpp
+    )
+ENDIF(ENABLE_USB)
+
+########################################################################
+# Setup defines for interface address discovery
+########################################################################
+MESSAGE(STATUS "")
+MESSAGE(STATUS "Configuring interface address discovery...")
+INCLUDE(CheckCXXSourceCompiles)
+INCLUDE(CheckIncludeFileCXX)
+
+CHECK_CXX_SOURCE_COMPILES("
+    #include <ifaddrs.h>
+    int main(){
+        struct ifaddrs *ifap;
+        getifaddrs(&ifap);
+        return 0;
+    }
+    " HAVE_GETIFADDRS
+)
+
+CHECK_INCLUDE_FILE_CXX(winsock2.h HAVE_WINSOCK2_H)
+
+IF(HAVE_GETIFADDRS)
+    MESSAGE(STATUS "  Interface address discovery supported through getifaddrs.")
+    SET(IF_ADDRS_DEFS HAVE_GETIFADDRS)
+ELSEIF(HAVE_WINSOCK2_H)
+    MESSAGE(STATUS "  Interface address discovery supported through SIO_GET_INTERFACE_LIST.")
+    SET(IF_ADDRS_DEFS HAVE_SIO_GET_INTERFACE_LIST)
+ELSE()
+    MESSAGE(STATUS "  Interface address discovery not supported.")
+    SET(IF_ADDRS_DEFS HAVE_IF_ADDRS_DUMMY)
+ENDIF()
+
+SET_SOURCE_FILES_PROPERTIES(
+    ${CMAKE_CURRENT_SOURCE_DIR}/if_addrs.cpp
+    PROPERTIES COMPILE_DEFINITIONS "${IF_ADDRS_DEFS}"
+)
+
+########################################################################
+# Append to the list of sources for lib uhd
+########################################################################
+LIBUHD_PYTHON_GEN_SOURCE(
+    ${CMAKE_CURRENT_SOURCE_DIR}/gen_vrt_if_packet.py
+    ${CMAKE_CURRENT_BINARY_DIR}/vrt_if_packet.cpp
+)
+
+LIBUHD_APPEND_SOURCES(
+    ${CMAKE_CURRENT_SOURCE_DIR}/buffer_pool.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/if_addrs.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/udp_simple.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/udp_zero_copy.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/vrt_packet_handler.hpp
+)
diff --git a/host/lib/transport/buffer_pool.cpp b/host/lib/transport/buffer_pool.cpp
new file mode 100644
index 000000000..971bbb75a
--- /dev/null
+++ b/host/lib/transport/buffer_pool.cpp
@@ -0,0 +1,80 @@
+//
+// Copyright 2011-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/transport/buffer_pool.hpp>
+#include <boost/shared_array.hpp>
+#include <vector>
+
+using namespace uhd::transport;
+
+//! pad the byte count to a multiple of alignment
+static size_t pad_to_boundary(const size_t bytes, const size_t alignment){
+    return bytes + (alignment - bytes)%alignment;
+}
+
+/***********************************************************************
+ * Buffer pool implementation
+ **********************************************************************/
+class buffer_pool_impl : public buffer_pool{
+public:
+    buffer_pool_impl(
+        const std::vector<ptr_type> &ptrs,
+        boost::shared_array<char> mem
+    ): _ptrs(ptrs), _mem(mem){
+        /* NOP */
+    }
+
+    ptr_type at(const size_t index) const{
+        return _ptrs.at(index);
+    }
+
+    size_t size(void) const{
+        return _ptrs.size();
+    }
+
+private:
+    std::vector<ptr_type> _ptrs;
+    boost::shared_array<char> _mem;
+};
+
+/***********************************************************************
+ * Buffer pool factor function
+ **********************************************************************/
+buffer_pool::sptr buffer_pool::make(
+    const size_t num_buffs,
+    const size_t buff_size,
+    const size_t alignment
+){
+    //1) pad the buffer size to be a multiple of alignment
+    //2) pad the overall memory size for room after alignment
+    //3) allocate the memory in one block of sufficient size
+    const size_t padded_buff_size = pad_to_boundary(buff_size, alignment);
+    boost::shared_array<char> mem(new char[padded_buff_size*num_buffs + alignment-1]);
+
+    //Fill a vector with boundary-aligned points in the memory
+    const size_t mem_start = pad_to_boundary(size_t(mem.get()), alignment);
+    std::vector<ptr_type> ptrs(num_buffs);
+    for (size_t i = 0; i < num_buffs; i++){
+        ptrs[i] = ptr_type(mem_start + padded_buff_size*i);
+    }
+
+    //Create a new buffer pool implementation with:
+    // - the pre-computed pointers, and
+    // - the reference to allocated memory.
+    return sptr(new buffer_pool_impl(ptrs, mem));
+}
+
diff --git a/host/lib/transport/gen_vrt_if_packet.py b/host/lib/transport/gen_vrt_if_packet.py
new file mode 100755
index 000000000..8481932ed
--- /dev/null
+++ b/host/lib/transport/gen_vrt_if_packet.py
@@ -0,0 +1,256 @@
+#!/usr/bin/env python
+#
+# Copyright 2010-2011 Ettus Research LLC
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""
+The vrt packer/unpacker code generator:
+
+This script will generate the pack and unpack routines that convert
+metatdata into vrt headers and vrt headers into metadata.
+
+The generated code infers jump tables to speed-up the parsing time.
+"""
+
+TMPL_TEXT = """
+#import time
+/***********************************************************************
+ * This file was generated by $file on $time.strftime("%c")
+ **********************************************************************/
+
+\#include <uhd/exception.hpp>
+\#include <uhd/transport/vrt_if_packet.hpp>
+\#include <uhd/utils/byteswap.hpp>
+\#include <boost/detail/endian.hpp>
+\#include <vector>
+
+//define the endian macros to convert integers
+\#ifdef BOOST_BIG_ENDIAN
+    \#define BE_MACRO(x) (x)
+    \#define LE_MACRO(x) uhd::byteswap(x)
+\#else
+    \#define BE_MACRO(x) uhd::byteswap(x)
+    \#define LE_MACRO(x) (x)
+\#endif
+
+using namespace uhd;
+using namespace uhd::transport;
+
+typedef size_t pred_type;
+typedef std::vector<pred_type> pred_table_type;
+#define pred_table_index(hdr) ((hdr >> 20) & 0x1ff)
+
+static pred_table_type get_pred_unpack_table(void){
+    pred_table_type table(1 << 9, 0); //only 9 bits useful here (20-28)
+    for (size_t i = 0; i < table.size(); i++){
+        boost::uint32_t vrt_hdr_word = i << 20;
+        if(vrt_hdr_word & $hex(0x1 << 28)) table[i] |= $hex($sid_p);
+        if(vrt_hdr_word & $hex(0x1 << 27)) table[i] |= $hex($cid_p);
+        if(vrt_hdr_word & $hex(0x3 << 22)) table[i] |= $hex($tsi_p);
+        if(vrt_hdr_word & $hex(0x3 << 20)) table[i] |= $hex($tsf_p);
+        if(vrt_hdr_word & $hex(0x1 << 26)) table[i] |= $hex($tlr_p);
+    }
+    return table;
+}
+
+static const pred_table_type pred_unpack_table(get_pred_unpack_table());
+
+########################################################################
+#def gen_code($XE_MACRO, $suffix)
+########################################################################
+
+void vrt::if_hdr_pack_$(suffix)(
+    boost::uint32_t *packet_buff,
+    if_packet_info_t &if_packet_info
+){
+    boost::uint32_t vrt_hdr_flags = 0;
+
+    pred_type pred = 0;
+    if (if_packet_info.has_sid) pred |= $hex($sid_p);
+    if (if_packet_info.has_cid) pred |= $hex($cid_p);
+    if (if_packet_info.has_tsi) pred |= $hex($tsi_p);
+    if (if_packet_info.has_tsf) pred |= $hex($tsf_p);
+    if (if_packet_info.has_tlr) pred |= $hex($tlr_p);
+
+    switch(pred){
+    #for $pred in range(2**5)
+    case $pred:
+        #set $num_header_words = 1
+        #set $flags = 0
+        ########## Stream ID ##########
+        #if $pred & $sid_p
+            packet_buff[$num_header_words] = $(XE_MACRO)(if_packet_info.sid);
+            #set $num_header_words += 1
+            #set $flags |= (0x1 << 28);
+        #end if
+        ########## Class ID ##########
+        #if $pred & $cid_p
+            packet_buff[$num_header_words] = 0; //not implemented
+            #set $num_header_words += 1
+            packet_buff[$num_header_words] = 0; //not implemented
+            #set $num_header_words += 1
+            #set $flags |= (0x1 << 27);
+        #end if
+        ########## Integer Time ##########
+        #if $pred & $tsi_p
+            packet_buff[$num_header_words] = $(XE_MACRO)(if_packet_info.tsi);
+            #set $num_header_words += 1
+            #set $flags |= (0x3 << 22);
+        #end if
+        ########## Fractional Time ##########
+        #if $pred & $tsf_p
+            packet_buff[$num_header_words] = $(XE_MACRO)(boost::uint32_t(if_packet_info.tsf >> 32));
+            #set $num_header_words += 1
+            packet_buff[$num_header_words] = $(XE_MACRO)(boost::uint32_t(if_packet_info.tsf >> 0));
+            #set $num_header_words += 1
+            #set $flags |= (0x1 << 20);
+        #end if
+        ########## Trailer ##########
+        #if $pred & $tlr_p
+            //packet_buff[$num_header_words+if_packet_info.num_payload_words32] = $(XE_MACRO)(if_packet_info.tlr);
+            #set $flags |= (0x1 << 26);
+            #set $num_trailer_words = 1;
+        #else
+            #set $num_trailer_words = 0;
+        #end if
+        ########## Variables ##########
+            if_packet_info.num_header_words32 = $num_header_words;
+            if_packet_info.num_packet_words32 = $($num_header_words + $num_trailer_words) + if_packet_info.num_payload_words32;
+            vrt_hdr_flags = $hex($flags);
+        break;
+    #end for
+    }
+
+    //set the burst flags
+    if (if_packet_info.sob) vrt_hdr_flags |= $hex(0x1 << 25);
+    if (if_packet_info.eob) vrt_hdr_flags |= $hex(0x1 << 24);
+
+    //fill in complete header word
+    packet_buff[0] = $(XE_MACRO)(boost::uint32_t(0
+        | vrt_hdr_flags
+        | ((if_packet_info.packet_count & 0xf) << 16)
+        | (if_packet_info.num_packet_words32 & 0xffff)
+    ));
+}
+
+void vrt::if_hdr_unpack_$(suffix)(
+    const boost::uint32_t *packet_buff,
+    if_packet_info_t &if_packet_info
+){
+    //extract vrt header
+    boost::uint32_t vrt_hdr_word = $(XE_MACRO)(packet_buff[0]);
+    /*
+    size_t packet_words32 = vrt_hdr_word & 0xffff;
+
+    //failure case
+    if (if_packet_info.num_packet_words32 < packet_words32)
+        throw uhd::value_error("bad vrt header or packet fragment");
+    */
+    //Fix for short packets sent from the fpga:
+    //  Use the num_packet_words32 passed in as input,
+    //  and do not use the header bits which could be wrong.
+    size_t packet_words32 = if_packet_info.num_packet_words32;
+
+    //extract fields from the header
+    if_packet_info.packet_type = if_packet_info_t::packet_type_t(vrt_hdr_word >> 29);
+    if_packet_info.packet_count = (vrt_hdr_word >> 16) & 0xf;
+    //if_packet_info.sob = bool(vrt_hdr_word & $hex(0x1 << 25)); //not implemented
+    //if_packet_info.eob = bool(vrt_hdr_word & $hex(0x1 << 24)); //not implemented
+
+    const pred_type pred = pred_unpack_table[pred_table_index(vrt_hdr_word)];
+
+    switch(pred){
+    #for $pred in range(2**5)
+    case $pred:
+        #set $has_time_spec = False
+        #set $num_header_words = 1
+        ########## Stream ID ##########
+        #if $pred & $sid_p
+            if_packet_info.has_sid = true;
+            if_packet_info.sid = $(XE_MACRO)(packet_buff[$num_header_words]);
+            #set $num_header_words += 1
+        #else
+            if_packet_info.has_sid = false;
+        #end if
+        ########## Class ID ##########
+        #if $pred & $cid_p
+            if_packet_info.has_cid = true;
+            if_packet_info.cid = 0; //not implemented
+            #set $num_header_words += 2
+        #else
+            if_packet_info.has_cid = false;
+        #end if
+        ########## Integer Time ##########
+        #if $pred & $tsi_p
+            if_packet_info.has_tsi = true;
+            if_packet_info.tsi = $(XE_MACRO)(packet_buff[$num_header_words]);
+            #set $num_header_words += 1
+        #else
+            if_packet_info.has_tsi = false;
+        #end if
+        ########## Fractional Time ##########
+        #if $pred & $tsf_p
+            if_packet_info.has_tsf = true;
+            if_packet_info.tsf = boost::uint64_t($(XE_MACRO)(packet_buff[$num_header_words])) << 32;
+            #set $num_header_words += 1
+            if_packet_info.tsf |= $(XE_MACRO)(packet_buff[$num_header_words]);
+            #set $num_header_words += 1
+        #else
+            if_packet_info.has_tsf = false;
+        #end if
+        ########## Trailer ##########
+        #if $pred & $tlr_p
+            if_packet_info.has_tlr = true;
+            if_packet_info.tlr = $(XE_MACRO)(packet_buff[packet_words32-1]);
+            #set $num_trailer_words = 1;
+        #else
+            if_packet_info.has_tlr = false;
+            #set $num_trailer_words = 0;
+        #end if
+        ########## Variables ##########
+            //another failure case
+            if (packet_words32 < $($num_header_words + $num_trailer_words))
+                throw uhd::value_error("bad vrt header or invalid packet length");
+            if_packet_info.num_header_words32 = $num_header_words;
+            if_packet_info.num_payload_words32 = packet_words32 - $($num_header_words + $num_trailer_words);
+        break;
+    #end for
+    }
+}
+
+########################################################################
+#end def
+########################################################################
+
+$gen_code("BE_MACRO", "be")
+$gen_code("LE_MACRO", "le")
+"""
+
+def parse_tmpl(_tmpl_text, **kwargs):
+    from Cheetah.Template import Template
+    return str(Template(_tmpl_text, kwargs))
+
+if __name__ == '__main__':
+    import sys
+    open(sys.argv[1], 'w').write(parse_tmpl(
+        TMPL_TEXT,
+        file=__file__,
+        sid_p = 0b00001,
+        cid_p = 0b00010,
+        tsi_p = 0b00100,
+        tsf_p = 0b01000,
+        tlr_p = 0b10000,
+    ))
diff --git a/host/lib/transport/if_addrs.cpp b/host/lib/transport/if_addrs.cpp
new file mode 100644
index 000000000..83a1ee56f
--- /dev/null
+++ b/host/lib/transport/if_addrs.cpp
@@ -0,0 +1,110 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/transport/if_addrs.hpp>
+#include <boost/asio/ip/address_v4.hpp>
+#include <boost/cstdint.hpp>
+#include <iostream>
+
+/***********************************************************************
+ * Interface address discovery through ifaddrs api
+ **********************************************************************/
+#ifdef HAVE_GETIFADDRS
+#include <ifaddrs.h>
+
+static boost::asio::ip::address_v4 sockaddr_to_ip_addr(sockaddr *addr){
+    return boost::asio::ip::address_v4(ntohl(
+        reinterpret_cast<sockaddr_in*>(addr)->sin_addr.s_addr
+    ));
+}
+
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+    std::vector<if_addrs_t> if_addrs;
+    struct ifaddrs *ifap;
+    if (getifaddrs(&ifap) == 0){
+        for (struct ifaddrs *iter = ifap; iter != NULL; iter = iter->ifa_next){
+            //ensure that the entries are valid
+            if (iter->ifa_addr == NULL) continue;
+            if (iter->ifa_addr->sa_family != AF_INET) continue;
+            if (iter->ifa_netmask->sa_family != AF_INET) continue;
+            if (iter->ifa_broadaddr->sa_family != AF_INET) continue;
+
+            //append a new set of interface addresses
+            if_addrs_t if_addr;
+            if_addr.inet = sockaddr_to_ip_addr(iter->ifa_addr).to_string();
+            if_addr.mask = sockaddr_to_ip_addr(iter->ifa_netmask).to_string();
+            if_addr.bcast = sockaddr_to_ip_addr(iter->ifa_broadaddr).to_string();
+            if_addrs.push_back(if_addr);
+        }
+        freeifaddrs(ifap);
+    }
+    return if_addrs;
+}
+
+#endif /* HAVE_GETIFADDRS */
+
+/***********************************************************************
+ * Interface address discovery through windows api
+ **********************************************************************/
+#ifdef HAVE_SIO_GET_INTERFACE_LIST
+#include <winsock2.h>
+
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+    std::vector<if_addrs_t> if_addrs;
+    SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
+    if (sd == SOCKET_ERROR) {
+        std::cerr << "Failed to get a socket. Error " << WSAGetLastError() <<
+            std::endl; return if_addrs;
+    }
+
+    INTERFACE_INFO InterfaceList[20];
+    unsigned long nBytesReturned;
+    if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList,
+			sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) {
+        std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError() <<
+				std::endl;
+		return if_addrs;
+    }
+
+    int nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
+    for (int i = 0; i < nNumInterfaces; ++i) {
+        boost::uint32_t iiAddress = ntohl(reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiAddress).sin_addr.s_addr);
+        boost::uint32_t iiNetmask = ntohl(reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiNetmask).sin_addr.s_addr);
+        boost::uint32_t iiBroadcastAddress = (iiAddress & iiNetmask) | ~iiNetmask;
+
+        if_addrs_t if_addr;
+        if_addr.inet = boost::asio::ip::address_v4(iiAddress).to_string();
+        if_addr.mask = boost::asio::ip::address_v4(iiNetmask).to_string();
+        if_addr.bcast = boost::asio::ip::address_v4(iiBroadcastAddress).to_string();
+        if_addrs.push_back(if_addr);
+    }
+
+    return if_addrs;
+}
+
+#endif /* HAVE_SIO_GET_INTERFACE_LIST */
+
+/***********************************************************************
+ * Interface address discovery not included
+ **********************************************************************/
+#ifdef HAVE_IF_ADDRS_DUMMY
+
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+    return std::vector<if_addrs_t>();
+}
+
+#endif /* HAVE_IF_ADDRS_DUMMY */
diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
new file mode 100644
index 000000000..6d4df7875
--- /dev/null
+++ b/host/lib/transport/libusb1_base.cpp
@@ -0,0 +1,265 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "libusb1_base.hpp"
+#include <uhd/exception.hpp>
+#include <uhd/types/dict.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/foreach.hpp>
+#include <iostream>
+
+using namespace uhd;
+using namespace uhd::transport;
+
+/***********************************************************************
+ * libusb session
+ **********************************************************************/
+class libusb_session_impl : public libusb::session{
+public:
+    libusb_session_impl(void){
+        UHD_ASSERT_THROW(libusb_init(&_context) == 0);
+        libusb_set_debug(_context, debug_level);
+    }
+
+    ~libusb_session_impl(void){
+        libusb_exit(_context);
+    }
+
+    libusb_context *get_context(void) const{
+        return _context;
+    }
+
+private:
+    libusb_context *_context;
+};
+
+libusb::session::sptr libusb::session::get_global_session(void){
+    static boost::weak_ptr<session> global_session;
+
+    //not expired -> get existing session
+    if (not global_session.expired()) return global_session.lock();
+
+    //create a new global session
+    sptr new_global_session(new libusb_session_impl());
+    global_session = new_global_session;
+    return new_global_session;
+}
+
+/***********************************************************************
+ * libusb device
+ **********************************************************************/
+class libusb_device_impl : public libusb::device{
+public:
+    libusb_device_impl(libusb_device *dev){
+        _session = libusb::session::get_global_session();
+        _dev = dev;
+    }
+
+    ~libusb_device_impl(void){
+        libusb_unref_device(this->get());
+    }
+
+    libusb_device *get(void) const{
+        return _dev;
+    }
+
+private:
+    libusb::session::sptr _session; //always keep a reference to session
+    libusb_device *_dev;
+};
+
+/***********************************************************************
+ * libusb device list
+ **********************************************************************/
+class libusb_device_list_impl : public libusb::device_list{
+public:
+    libusb_device_list_impl(void){
+        libusb::session::sptr sess = libusb::session::get_global_session();
+
+        //allocate a new list of devices
+        libusb_device** dev_list;
+        ssize_t ret = libusb_get_device_list(sess->get_context(), &dev_list);
+        if (ret < 0) throw uhd::os_error("cannot enumerate usb devices");
+
+        //fill the vector of device references
+        for (size_t i = 0; i < size_t(ret); i++) _devs.push_back(
+            libusb::device::sptr(new libusb_device_impl(dev_list[i]))
+        );
+
+        //free the device list but dont unref (done in ~device)
+        libusb_free_device_list(dev_list, false/*dont unref*/);
+    }
+
+    size_t size(void) const{
+        return _devs.size();
+    }
+
+    libusb::device::sptr at(size_t i) const{
+        return _devs.at(i);
+    }
+
+private:
+    std::vector<libusb::device::sptr> _devs;
+};
+
+libusb::device_list::sptr libusb::device_list::make(void){
+    return sptr(new libusb_device_list_impl());
+}
+
+/***********************************************************************
+ * libusb device descriptor
+ **********************************************************************/
+class libusb_device_descriptor_impl : public libusb::device_descriptor{
+public:
+    libusb_device_descriptor_impl(libusb::device::sptr dev){
+        _dev = dev;
+        UHD_ASSERT_THROW(libusb_get_device_descriptor(_dev->get(), &_desc) == 0);
+    }
+
+    const libusb_device_descriptor &get(void) const{
+        return _desc;
+    }
+
+    std::string get_ascii_serial(void) const{
+        if (this->get().iSerialNumber == 0) return "";
+
+        libusb::device_handle::sptr handle(
+            libusb::device_handle::get_cached_handle(_dev)
+        );
+
+        unsigned char buff[512];
+        ssize_t ret = libusb_get_string_descriptor_ascii(
+            handle->get(), this->get().iSerialNumber, buff, sizeof(buff)
+        );
+        if (ret < 0) return ""; //on error, just return empty string
+
+        return std::string((char *)buff, ret);
+    }
+
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+    libusb_device_descriptor _desc;
+};
+
+libusb::device_descriptor::sptr libusb::device_descriptor::make(device::sptr dev){
+    return sptr(new libusb_device_descriptor_impl(dev));
+}
+
+/***********************************************************************
+ * libusb device handle
+ **********************************************************************/
+class libusb_device_handle_impl : public libusb::device_handle{
+public:
+    libusb_device_handle_impl(libusb::device::sptr dev){
+        _dev = dev;
+        UHD_ASSERT_THROW(libusb_open(_dev->get(), &_handle) == 0);
+    }
+
+    ~libusb_device_handle_impl(void){
+        //release all claimed interfaces
+        for (size_t i = 0; i < _claimed.size(); i++){
+            libusb_release_interface(this->get(), _claimed[i]);
+        }
+        libusb_close(_handle);
+    }
+
+    libusb_device_handle *get(void) const{
+        return _handle;
+    }
+
+    void claim_interface(int interface){
+        UHD_ASSERT_THROW(libusb_claim_interface(this->get(), interface) == 0);
+        _claimed.push_back(interface);
+    }
+
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+    libusb_device_handle *_handle;
+    std::vector<int> _claimed;
+};
+
+libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::sptr dev){
+    static uhd::dict<libusb_device *, boost::weak_ptr<device_handle> > handles;
+
+    //not expired -> get existing handle
+    if (handles.has_key(dev->get()) and not handles[dev->get()].expired()){
+        return handles[dev->get()].lock();
+    }
+
+    //create a new cached handle
+    try{
+        sptr new_handle(new libusb_device_handle_impl(dev));
+        handles[dev->get()] = new_handle;
+        return new_handle;
+    }
+    catch(const uhd::exception &e){
+        std::cerr << "USB open failed: see the application notes for your device." << std::endl;
+        throw;
+    }
+}
+
+/***********************************************************************
+ * libusb special handle
+ **********************************************************************/
+class libusb_special_handle_impl : public libusb::special_handle{
+public:
+    libusb_special_handle_impl(libusb::device::sptr dev){
+        _dev = dev;
+    }
+
+    libusb::device::sptr get_device(void) const{
+        return _dev;
+    }
+
+    std::string get_serial(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get_ascii_serial();
+    }
+
+    boost::uint16_t get_vendor_id(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get().idVendor;
+    }
+
+    boost::uint16_t get_product_id(void) const{
+        return libusb::device_descriptor::make(this->get_device())->get().idProduct;
+    }
+
+private:
+    libusb::device::sptr _dev; //always keep a reference to device
+};
+
+libusb::special_handle::sptr libusb::special_handle::make(device::sptr dev){
+    return sptr(new libusb_special_handle_impl(dev));
+}
+
+/***********************************************************************
+ * list device handles implementations
+ **********************************************************************/
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
+    boost::uint16_t vid, boost::uint16_t pid
+){
+    std::vector<usb_device_handle::sptr> handles;
+
+    libusb::device_list::sptr dev_list = libusb::device_list::make();
+    for (size_t i = 0; i < dev_list->size(); i++){
+        usb_device_handle::sptr handle = libusb::special_handle::make(dev_list->at(i));
+        if (handle->get_vendor_id() == vid and handle->get_product_id() == pid){
+            handles.push_back(handle);
+        }
+    }
+
+    return handles;
+}
diff --git a/host/lib/transport/libusb1_base.hpp b/host/lib/transport/libusb1_base.hpp
new file mode 100644
index 000000000..04c1d6574
--- /dev/null
+++ b/host/lib/transport/libusb1_base.hpp
@@ -0,0 +1,149 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP
+#define INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP
+
+#include <uhd/config.hpp>
+#include <boost/utility.hpp>
+#include <boost/shared_ptr.hpp>
+#include <uhd/transport/usb_device_handle.hpp>
+#include <libusb.h>
+
+/***********************************************************************
+ * Libusb object oriented smart pointer wrappers:
+ * The following wrappers provide allocation and automatic deallocation
+ * for various libusb data types and handles. The construction routines
+ * also store tables of already allocated structures to avoid multiple
+ * occurrences of opened handles (for example).
+ **********************************************************************/
+namespace uhd { namespace transport {
+
+namespace libusb {
+
+    /*!
+     * This session class holds a global libusb context for this process.
+     * The get global session call will create a new context if none exists.
+     * When all references to session are destroyed, the context will be freed.
+     */
+    class session : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<session> sptr;
+
+        /*!
+         *   Level 0: no messages ever printed by the library (default)
+         *   Level 1: error messages are printed to stderr
+         *   Level 2: warning and error messages are printed to stderr
+         *   Level 3: informational messages are printed to stdout, warning
+         *            and error messages are printed to stderr
+         */
+        static const int debug_level = 0;
+
+        //! get a shared pointer to the global session
+        static sptr get_global_session(void);
+
+        //! get the underlying libusb context pointer
+        virtual libusb_context *get_context(void) const = 0;
+    };
+
+    /*!
+     * Holds a device pointer with a reference to the session.
+     */
+    class device : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device> sptr;
+
+        //! get the underlying device pointer
+        virtual libusb_device *get(void) const = 0;
+    };
+
+    /*!
+     * This device list class holds a device list that will be
+     * automatically freed when the last reference is destroyed.
+     */
+    class device_list : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_list> sptr;
+
+        //! make a new device list
+        static sptr make(void);
+
+        //! the number of devices in this list
+        virtual size_t size() const = 0;
+
+        //! get the device pointer at a particular index
+        virtual device::sptr at(size_t index) const = 0;
+    };
+
+    /*!
+     * Holds a device descriptor and a reference to the device.
+     */
+    class device_descriptor : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_descriptor> sptr;
+
+        //! make a new descriptor from a device reference
+        static sptr make(device::sptr);
+
+        //! get the underlying device descriptor
+        virtual const libusb_device_descriptor &get(void) const = 0;
+
+        virtual std::string get_ascii_serial(void) const = 0;
+    };
+
+    /*!
+     * Holds a device handle and a reference to the device.
+     */
+    class device_handle : boost::noncopyable {
+    public:
+        typedef boost::shared_ptr<device_handle> sptr;
+
+        //! get a cached handle or make a new one given the device
+        static sptr get_cached_handle(device::sptr);
+
+        //! get the underlying device handle
+        virtual libusb_device_handle *get(void) const = 0;
+
+        /*!
+         * Open USB interfaces for control using magic value
+         * IN interface:      2
+         * OUT interface:     1
+         * Control interface: 0
+         */
+        virtual void claim_interface(int) = 0;
+    };
+
+    /*!
+     * The special handle is our internal implementation of the
+     * usb device handle which is used publicly to identify a device.
+     */
+    class special_handle : public usb_device_handle {
+    public:
+        typedef boost::shared_ptr<special_handle> sptr;
+
+        //! make a new special handle from device
+        static sptr make(device::sptr);
+
+        //! get the underlying device reference
+        virtual device::sptr get_device(void) const = 0;
+    };
+
+}
+
+}} //namespace
+
+#endif /* INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP */
diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp
new file mode 100644
index 000000000..f903907d0
--- /dev/null
+++ b/host/lib/transport/libusb1_control.cpp
@@ -0,0 +1,64 @@
+//
+// Copyright 2010 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "libusb1_base.hpp"
+#include <uhd/transport/usb_control.hpp>
+
+using namespace uhd::transport;
+
+const int libusb_timeout = 0;
+
+/***********************************************************************
+ * libusb-1.0 implementation of USB control transport
+ **********************************************************************/
+class libusb_control_impl : public usb_control {
+public:
+    libusb_control_impl(libusb::device_handle::sptr handle):
+        _handle(handle)
+    {
+        _handle->claim_interface(0 /* control interface */);
+    }
+
+    ssize_t submit(boost::uint8_t request_type,
+                  boost::uint8_t request,
+                  boost::uint16_t value,
+                  boost::uint16_t index,
+                  unsigned char *buff,
+                  boost::uint16_t length
+    ){
+        return libusb_control_transfer(_handle->get(),
+                                       request_type,
+                                       request,
+                                       value,
+                                       index,
+                                       buff,
+                                       length,
+                                       libusb_timeout);
+    }
+
+private:
+    libusb::device_handle::sptr _handle;
+};
+
+/***********************************************************************
+ * USB control public make functions
+ **********************************************************************/
+usb_control::sptr usb_control::make(usb_device_handle::sptr handle){
+    return sptr(new libusb_control_impl(libusb::device_handle::get_cached_handle(
+        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
+    )));
+}
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
new file mode 100644
index 000000000..9f38ce97b
--- /dev/null
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -0,0 +1,297 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "libusb1_base.hpp"
+#include <uhd/transport/usb_zero_copy.hpp>
+#include <uhd/transport/bounded_buffer.hpp>
+#include <uhd/transport/buffer_pool.hpp>
+#include <uhd/utils/thread_priority.hpp>
+#include <uhd/exception.hpp>
+#include <boost/function.hpp>
+#include <boost/foreach.hpp>
+#include <boost/thread/thread.hpp>
+#include <list>
+#include <iostream>
+
+using namespace uhd;
+using namespace uhd::transport;
+
+static const size_t DEFAULT_NUM_XFERS = 16;     //num xfers
+static const size_t DEFAULT_XFER_SIZE = 32*512; //bytes
+
+//! helper function: handles all async callbacks
+static void libusb_async_cb(libusb_transfer *lut){
+    (*static_cast<boost::function<void()> *>(lut->user_data))();
+}
+
+//! callback to free transfer upon cancellation
+static void cancel_transfer_cb(libusb_transfer *lut){
+    if (lut->status == LIBUSB_TRANSFER_CANCELLED) libusb_free_transfer(lut);
+    else std::cout << "libusb cancel_transfer unexpected status " << lut->status << std::endl;
+}
+
+/***********************************************************************
+ * Reusable managed receiver buffer:
+ *  - Associated with a particular libusb transfer struct.
+ *  - Submits the transfer to libusb in the release method.
+ **********************************************************************/
+class libusb_zero_copy_mrb : public managed_recv_buffer{
+public:
+    libusb_zero_copy_mrb(libusb_transfer *lut):
+        _lut(lut), _expired(true) { /* NOP */ }
+
+    void release(void){
+        if (_expired) return;
+        UHD_ASSERT_THROW(libusb_submit_transfer(_lut) == 0);
+        _expired = true;
+    }
+
+    sptr get_new(void){
+        _expired = false;
+        return sptr(this, &libusb_zero_copy_mrb::fake_deleter);
+    }
+
+private:
+    static void fake_deleter(void *obj){
+        static_cast<libusb_zero_copy_mrb *>(obj)->release();
+    }
+
+    const void *get_buff(void) const{return _lut->buffer;}
+    size_t get_size(void) const{return _lut->actual_length;}
+
+    libusb_transfer *_lut;
+    bool _expired;
+};
+
+/***********************************************************************
+ * Reusable managed send buffer:
+ *  - Associated with a particular libusb transfer struct.
+ *  - Submits the transfer to libusb in the commit method.
+ **********************************************************************/
+class libusb_zero_copy_msb : public managed_send_buffer{
+public:
+    libusb_zero_copy_msb(libusb_transfer *lut):
+        _lut(lut), _expired(true) { /* NOP */ }
+
+    void commit(size_t len){
+        if (_expired) return;
+        _lut->length = len;
+        if(len == 0) libusb_async_cb(_lut);
+        else UHD_ASSERT_THROW(libusb_submit_transfer(_lut) == 0);
+        _expired = true;
+    }
+
+    sptr get_new(void){
+        _expired = false;
+        return sptr(this, &libusb_zero_copy_msb::fake_deleter);
+    }
+
+private:
+    static void fake_deleter(void *obj){
+        static_cast<libusb_zero_copy_msb *>(obj)->commit(0);
+    }
+
+    void *get_buff(void) const{return _lut->buffer;}
+    size_t get_size(void) const{return _lut->length;}
+
+    libusb_transfer *_lut;
+    bool _expired;
+};
+
+/***********************************************************************
+ * USB zero_copy device class
+ **********************************************************************/
+class libusb_zero_copy_impl : public usb_zero_copy{
+public:
+
+    libusb_zero_copy_impl(
+        libusb::device_handle::sptr handle,
+        size_t recv_endpoint,
+        size_t send_endpoint,
+        const device_addr_t &hints
+    ):
+        _handle(handle),
+        _recv_frame_size(size_t(hints.cast<double>("recv_frame_size", DEFAULT_XFER_SIZE))),
+        _num_recv_frames(size_t(hints.cast<double>("num_recv_frames", DEFAULT_NUM_XFERS))),
+        _send_frame_size(size_t(hints.cast<double>("send_frame_size", DEFAULT_XFER_SIZE))),
+        _num_send_frames(size_t(hints.cast<double>("num_send_frames", DEFAULT_NUM_XFERS))),
+        _recv_buffer_pool(buffer_pool::make(_num_recv_frames, _recv_frame_size)),
+        _send_buffer_pool(buffer_pool::make(_num_send_frames, _send_frame_size)),
+        _pending_recv_buffs(_num_recv_frames),
+        _pending_send_buffs(_num_send_frames)
+    {
+        _handle->claim_interface(2 /*in interface*/);
+        _handle->claim_interface(1 /*out interface*/);
+
+        //allocate libusb transfer structs and managed receive buffers
+        for (size_t i = 0; i < get_num_recv_frames(); i++){
+
+            libusb_transfer *lut = libusb_alloc_transfer(0);
+            UHD_ASSERT_THROW(lut != NULL);
+
+            _mrb_pool.push_back(libusb_zero_copy_mrb(lut));
+            _callbacks.push_back(boost::bind(
+                &libusb_zero_copy_impl::handle_recv, this, &_mrb_pool.back()
+            ));
+
+            libusb_fill_bulk_transfer(
+                lut,                                                    // transfer
+                _handle->get(),                                         // dev_handle
+                (recv_endpoint & 0x7f) | 0x80,                          // endpoint
+                static_cast<unsigned char *>(_recv_buffer_pool->at(i)), // buffer
+                this->get_recv_frame_size(),                            // length
+                libusb_transfer_cb_fn(&libusb_async_cb),                // callback
+                static_cast<void *>(&_callbacks.back()),                // user_data
+                0                                                       // timeout
+            );
+
+            _all_luts.push_back(lut);
+            _mrb_pool.back().get_new();
+        }
+
+        //allocate libusb transfer structs and managed send buffers
+        for (size_t i = 0; i < get_num_send_frames(); i++){
+
+            libusb_transfer *lut = libusb_alloc_transfer(0);
+            UHD_ASSERT_THROW(lut != NULL);
+
+            _msb_pool.push_back(libusb_zero_copy_msb(lut));
+            _callbacks.push_back(boost::bind(
+                &libusb_zero_copy_impl::handle_send, this, &_msb_pool.back()
+            ));
+
+            libusb_fill_bulk_transfer(
+                lut,                                                    // transfer
+                _handle->get(),                                         // dev_handle
+                (send_endpoint & 0x7f) | 0x00,                          // endpoint
+                static_cast<unsigned char *>(_send_buffer_pool->at(i)), // buffer
+                this->get_send_frame_size(),                            // length
+                libusb_transfer_cb_fn(&libusb_async_cb),                // callback
+                static_cast<void *>(&_callbacks.back()),                // user_data
+                0                                                       // timeout
+            );
+
+            _all_luts.push_back(lut);
+            libusb_async_cb(lut);
+        }
+
+        //spawn the event handler threads
+        size_t concurrency = hints.cast<size_t>("concurrency_hint", 1);
+        for (size_t i = 0; i < concurrency; i++) _thread_group.create_thread(
+            boost::bind(&libusb_zero_copy_impl::run_event_loop, this)
+        );
+    }
+
+    ~libusb_zero_copy_impl(void){
+        //cancel and free all transfers
+        BOOST_FOREACH(libusb_transfer *lut, _all_luts){
+            lut->callback = libusb_transfer_cb_fn(&cancel_transfer_cb);
+            libusb_cancel_transfer(lut);
+            while(lut->status != LIBUSB_TRANSFER_CANCELLED && lut->status != LIBUSB_TRANSFER_COMPLETED) {
+                boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+            }
+        }
+        //shutdown the threads
+        _threads_running = false;
+        _thread_group.interrupt_all();
+        _thread_group.join_all();
+    }
+
+    managed_recv_buffer::sptr get_recv_buff(double timeout){
+        libusb_zero_copy_mrb *mrb = NULL;
+        if (_pending_recv_buffs.pop_with_timed_wait(mrb, timeout)){
+            return mrb->get_new();
+        }
+        return managed_recv_buffer::sptr();
+    }
+
+    managed_send_buffer::sptr get_send_buff(double timeout){
+        libusb_zero_copy_msb *msb = NULL;
+        if (_pending_send_buffs.pop_with_timed_wait(msb, timeout)){
+            return msb->get_new();
+        }
+        return managed_send_buffer::sptr();
+    }
+
+    size_t get_num_recv_frames(void) const { return _num_recv_frames; }
+    size_t get_num_send_frames(void) const { return _num_send_frames; }
+
+    size_t get_recv_frame_size(void) const { return _recv_frame_size; }
+    size_t get_send_frame_size(void) const { return _send_frame_size; }
+
+private:
+    //! Handle a bound async callback for recv
+    void handle_recv(libusb_zero_copy_mrb *mrb){
+        _pending_recv_buffs.push_with_haste(mrb);
+    }
+
+    //! Handle a bound async callback for send
+    void handle_send(libusb_zero_copy_msb *msb){
+        _pending_send_buffs.push_with_haste(msb);
+    }
+
+    libusb::device_handle::sptr _handle;
+    const size_t _recv_frame_size, _num_recv_frames;
+    const size_t _send_frame_size, _num_send_frames;
+
+    //! Storage for transfer related objects
+    buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool;
+    bounded_buffer<libusb_zero_copy_mrb *> _pending_recv_buffs;
+    bounded_buffer<libusb_zero_copy_msb *> _pending_send_buffs;
+    std::list<libusb_zero_copy_mrb> _mrb_pool;
+    std::list<libusb_zero_copy_msb> _msb_pool;
+    std::list<boost::function<void()> > _callbacks;
+
+    //! a list of all transfer structs we allocated
+    std::list<libusb_transfer *> _all_luts;
+
+    //! event handler threads
+    boost::thread_group _thread_group;
+    bool _threads_running;
+
+    void run_event_loop(void){
+        set_thread_priority_safe();
+        libusb_context *context = libusb::session::get_global_session()->get_context();
+        _threads_running = true;
+        try{
+            while(_threads_running){
+                timeval tv;
+                tv.tv_sec = 0;
+                tv.tv_usec = 100000; //100ms
+                libusb_handle_events_timeout(context, &tv);
+            }
+        } catch(const boost::thread_interrupted &){}
+    }
+
+};
+
+/***********************************************************************
+ * USB zero_copy make functions
+ **********************************************************************/
+usb_zero_copy::sptr usb_zero_copy::make(
+    usb_device_handle::sptr handle,
+    size_t recv_endpoint,
+    size_t send_endpoint,
+    const device_addr_t &hints
+){
+    libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle(
+        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
+    ));
+    return sptr(new libusb_zero_copy_impl(
+        dev_handle, recv_endpoint, send_endpoint, hints
+    ));
+}
diff --git a/host/lib/transport/udp_common.hpp b/host/lib/transport/udp_common.hpp
new file mode 100644
index 000000000..47775d9c4
--- /dev/null
+++ b/host/lib/transport/udp_common.hpp
@@ -0,0 +1,53 @@
+//
+// Copyright 2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP
+#define INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP
+
+#include <uhd/config.hpp>
+#include <boost/asio.hpp>
+
+namespace uhd{ namespace transport{
+
+    typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_sptr;
+
+    /*!
+     * Wait for the socket to become ready for a receive operation.
+     * \param sock_fd the open socket file descriptor
+     * \param timeout the timeout duration in seconds
+     * \return true when the socket is ready for receive
+     */
+    UHD_INLINE bool wait_for_recv_ready(int sock_fd, double timeout){
+        //setup timeval for timeout
+        timeval tv;
+        //If the tv_usec > 1 second on some platforms, select will
+        //error EINVAL: An invalid timeout interval was specified.
+        tv.tv_sec = int(timeout);
+        tv.tv_usec = int(timeout*1000000)%1000000;
+
+        //setup rset for timeout
+        fd_set rset;
+        FD_ZERO(&rset);
+        FD_SET(sock_fd, &rset);
+
+        //call select with timeout on receive socket
+        return ::select(sock_fd+1, &rset, NULL, NULL, &tv) > 0;
+    }
+
+}} //namespace uhd::transport
+
+#endif /* INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP */
diff --git a/host/lib/transport/udp_simple.cpp b/host/lib/transport/udp_simple.cpp
new file mode 100644
index 000000000..1ee036d52
--- /dev/null
+++ b/host/lib/transport/udp_simple.cpp
@@ -0,0 +1,83 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "udp_common.hpp"
+#include <uhd/transport/udp_simple.hpp>
+#include <boost/format.hpp>
+#include <iostream>
+
+using namespace uhd::transport;
+namespace asio = boost::asio;
+
+/***********************************************************************
+ * UDP simple implementation: connected and broadcast
+ **********************************************************************/
+class udp_simple_impl : public udp_simple{
+public:
+    udp_simple_impl(
+        const std::string &addr, const std::string &port, bool bcast, bool connect
+    ):_connected(connect){
+        //std::cout << boost::format("Creating udp transport for %s %s") % addr % port << std::endl;
+
+        //resolve the address
+        asio::ip::udp::resolver resolver(_io_service);
+        asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port);
+        _receiver_endpoint = *resolver.resolve(query);
+
+        //create and open the socket
+        _socket = socket_sptr(new asio::ip::udp::socket(_io_service));
+        _socket->open(asio::ip::udp::v4());
+
+        //allow broadcasting
+        _socket->set_option(asio::socket_base::broadcast(bcast));
+
+        //connect the socket
+        if (connect) _socket->connect(_receiver_endpoint);
+
+    }
+
+    size_t send(const asio::const_buffer &buff){
+        if (_connected) return _socket->send(asio::buffer(buff));
+        return _socket->send_to(asio::buffer(buff), _receiver_endpoint);
+    }
+
+    size_t recv(const asio::mutable_buffer &buff, double timeout){
+        if (not wait_for_recv_ready(_socket->native(), timeout)) return 0;
+        return _socket->receive(asio::buffer(buff));
+    }
+
+private:
+    bool                    _connected;
+    asio::io_service        _io_service;
+    socket_sptr             _socket;
+    asio::ip::udp::endpoint _receiver_endpoint;
+};
+
+/***********************************************************************
+ * UDP public make functions
+ **********************************************************************/
+udp_simple::sptr udp_simple::make_connected(
+    const std::string &addr, const std::string &port
+){
+    return sptr(new udp_simple_impl(addr, port, false, true /* no bcast, connect */));
+}
+
+udp_simple::sptr udp_simple::make_broadcast(
+    const std::string &addr, const std::string &port
+){
+    return sptr(new udp_simple_impl(addr, port, true, false /* bcast, no connect */));
+}
diff --git a/host/lib/transport/udp_zero_copy.cpp b/host/lib/transport/udp_zero_copy.cpp
new file mode 100644
index 000000000..5810f441c
--- /dev/null
+++ b/host/lib/transport/udp_zero_copy.cpp
@@ -0,0 +1,310 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include "udp_common.hpp"
+#include <uhd/transport/udp_zero_copy.hpp>
+#include <uhd/transport/udp_simple.hpp> //mtu
+#include <uhd/transport/bounded_buffer.hpp>
+#include <uhd/transport/buffer_pool.hpp>
+#include <uhd/utils/warning.hpp>
+#include <boost/format.hpp>
+#include <iostream>
+#include <list>
+
+using namespace uhd;
+using namespace uhd::transport;
+namespace asio = boost::asio;
+
+//A reasonable number of frames for send/recv and async/sync
+static const size_t DEFAULT_NUM_FRAMES = 32;
+
+/***********************************************************************
+ * Reusable managed receiver buffer:
+ *  - Initialize with memory and a release callback.
+ *  - Call get new with a length in bytes to re-use.
+ **********************************************************************/
+class udp_zero_copy_asio_mrb : public managed_recv_buffer{
+public:
+    typedef boost::function<void(udp_zero_copy_asio_mrb *)> release_cb_type;
+
+    udp_zero_copy_asio_mrb(void *mem, const release_cb_type &release_cb):
+        _mem(mem), _len(0), _release_cb(release_cb){/* NOP */}
+
+    void release(void){
+        if (_len == 0) return;
+        this->_release_cb(this);
+        _len = 0;
+    }
+
+    sptr get_new(size_t len){
+        _len = len;
+        return sptr(this, &udp_zero_copy_asio_mrb::fake_deleter);
+    }
+
+    template <class T> T cast(void) const{return static_cast<T>(_mem);}
+
+private:
+    static void fake_deleter(void *obj){
+        static_cast<udp_zero_copy_asio_mrb *>(obj)->release();
+    }
+
+    const void *get_buff(void) const{return _mem;}
+    size_t get_size(void) const{return _len;}
+
+    void *_mem;
+    size_t _len;
+    release_cb_type _release_cb;
+};
+
+/***********************************************************************
+ * Reusable managed send buffer:
+ *  - Initialize with memory and a commit callback.
+ *  - Call get new with a length in bytes to re-use.
+ **********************************************************************/
+class udp_zero_copy_asio_msb : public managed_send_buffer{
+public:
+    typedef boost::function<void(udp_zero_copy_asio_msb *, size_t)> commit_cb_type;
+
+    udp_zero_copy_asio_msb(void *mem, const commit_cb_type &commit_cb):
+        _mem(mem), _len(0), _commit_cb(commit_cb){/* NOP */}
+
+    void commit(size_t len){
+        if (_len == 0) return;
+        this->_commit_cb(this, len);
+        _len = 0;
+    }
+
+    sptr get_new(size_t len){
+        _len = len;
+        return sptr(this, &udp_zero_copy_asio_msb::fake_deleter);
+    }
+
+private:
+    static void fake_deleter(void *obj){
+        static_cast<udp_zero_copy_asio_msb *>(obj)->commit(0);
+    }
+
+    void *get_buff(void) const{return _mem;}
+    size_t get_size(void) const{return _len;}
+
+    void *_mem;
+    size_t _len;
+    commit_cb_type _commit_cb;
+};
+
+/***********************************************************************
+ * Zero Copy UDP implementation with ASIO:
+ *   This is the portable zero copy implementation for systems
+ *   where a faster, platform specific solution is not available.
+ *   However, it is not a true zero copy implementation as each
+ *   send and recv requires a copy operation to/from userspace.
+ **********************************************************************/
+class udp_zero_copy_asio_impl : public udp_zero_copy{
+public:
+    typedef boost::shared_ptr<udp_zero_copy_asio_impl> sptr;
+
+    udp_zero_copy_asio_impl(
+        const std::string &addr,
+        const std::string &port,
+        const device_addr_t &hints
+    ):
+        _recv_frame_size(size_t(hints.cast<double>("recv_frame_size", udp_simple::mtu))),
+        _num_recv_frames(size_t(hints.cast<double>("num_recv_frames", DEFAULT_NUM_FRAMES))),
+        _send_frame_size(size_t(hints.cast<double>("send_frame_size", udp_simple::mtu))),
+        _num_send_frames(size_t(hints.cast<double>("num_send_frames", DEFAULT_NUM_FRAMES))),
+        _recv_buffer_pool(buffer_pool::make(_num_recv_frames, _recv_frame_size)),
+        _send_buffer_pool(buffer_pool::make(_num_send_frames, _send_frame_size)),
+        _pending_recv_buffs(_num_recv_frames),
+        _pending_send_buffs(_num_send_frames)
+    {
+        //std::cout << boost::format("Creating udp transport for %s %s") % addr % port << std::endl;
+
+        //resolve the address
+        asio::ip::udp::resolver resolver(_io_service);
+        asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port);
+        asio::ip::udp::endpoint receiver_endpoint = *resolver.resolve(query);
+
+        //create, open, and connect the socket
+        _socket = socket_sptr(new asio::ip::udp::socket(_io_service));
+        _socket->open(asio::ip::udp::v4());
+        _socket->connect(receiver_endpoint);
+        _sock_fd = _socket->native();
+
+        //allocate re-usable managed receive buffers
+        for (size_t i = 0; i < get_num_recv_frames(); i++){
+            _mrb_pool.push_back(udp_zero_copy_asio_mrb(_recv_buffer_pool->at(i),
+                boost::bind(&udp_zero_copy_asio_impl::release, this, _1))
+            );
+            handle_recv(&_mrb_pool.back());
+        }
+
+        //allocate re-usable managed send buffers
+        for (size_t i = 0; i < get_num_send_frames(); i++){
+            _msb_pool.push_back(udp_zero_copy_asio_msb(_send_buffer_pool->at(i),
+                boost::bind(&udp_zero_copy_asio_impl::commit, this, _1, _2))
+            );
+            handle_send(&_msb_pool.back());
+        }
+    }
+
+    //get size for internal socket buffer
+    template <typename Opt> size_t get_buff_size(void) const{
+        Opt option;
+        _socket->get_option(option);
+        return option.value();
+    }
+
+    //set size for internal socket buffer
+    template <typename Opt> size_t resize_buff(size_t num_bytes){
+        Opt option(num_bytes);
+        _socket->set_option(option);
+        return get_buff_size<Opt>();
+    }
+
+    /*******************************************************************
+     * Receive implementation:
+     *
+     * Perform a non-blocking receive for performance,
+     * and then fall back to a blocking receive with timeout.
+     * Return the managed receive buffer with the new length.
+     * When the caller is finished with the managed buffer,
+     * the managed receive buffer is released back into the queue.
+     ******************************************************************/
+    managed_recv_buffer::sptr get_recv_buff(double timeout){
+        udp_zero_copy_asio_mrb *mrb = NULL;
+        if (_pending_recv_buffs.pop_with_timed_wait(mrb, timeout)){
+
+            #ifdef MSG_DONTWAIT //try a non-blocking recv() if supported
+            ssize_t ret = ::recv(_sock_fd, mrb->cast<char *>(), _recv_frame_size, MSG_DONTWAIT);
+            if (ret > 0) return mrb->get_new(ret);
+            #endif
+
+            if (wait_for_recv_ready(_sock_fd, timeout)) return mrb->get_new(
+                ::recv(_sock_fd, mrb->cast<char *>(), _recv_frame_size, 0)
+            );
+
+            this->handle_recv(mrb); //timeout: return the managed buffer to the queue
+        }
+        return managed_recv_buffer::sptr();
+    }
+
+    UHD_INLINE void handle_recv(udp_zero_copy_asio_mrb *mrb){
+        _pending_recv_buffs.push_with_haste(mrb);
+    }
+
+    void release(udp_zero_copy_asio_mrb *mrb){
+        handle_recv(mrb);
+    }
+
+    size_t get_num_recv_frames(void) const {return _num_recv_frames;}
+    size_t get_recv_frame_size(void) const {return _recv_frame_size;}
+
+    /*******************************************************************
+     * Send implementation:
+     *
+     * Get a managed receive buffer immediately with max length set.
+     * The caller will fill the buffer and commit it when finished.
+     * The commit routine will perform a blocking send operation,
+     * and push the managed send buffer back into the queue.
+     ******************************************************************/
+    managed_send_buffer::sptr get_send_buff(double timeout){
+        udp_zero_copy_asio_msb *msb = NULL;
+        if (_pending_send_buffs.pop_with_timed_wait(msb, timeout)){
+            return msb->get_new(_send_frame_size);
+        }
+        return managed_send_buffer::sptr();
+    }
+
+    UHD_INLINE void handle_send(udp_zero_copy_asio_msb *msb){
+        _pending_send_buffs.push_with_haste(msb);
+    }
+
+    void commit(udp_zero_copy_asio_msb *msb, size_t len){
+        ::send(_sock_fd, msb->cast<const char *>(), len, 0);
+        handle_send(msb);
+    }
+
+    size_t get_num_send_frames(void) const {return _num_send_frames;}
+    size_t get_send_frame_size(void) const {return _send_frame_size;}
+
+private:
+    //memory management -> buffers and fifos
+    const size_t _recv_frame_size, _num_recv_frames;
+    const size_t _send_frame_size, _num_send_frames;
+    buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool;
+    bounded_buffer<udp_zero_copy_asio_mrb *> _pending_recv_buffs;
+    bounded_buffer<udp_zero_copy_asio_msb *> _pending_send_buffs;
+    std::list<udp_zero_copy_asio_msb> _msb_pool;
+    std::list<udp_zero_copy_asio_mrb> _mrb_pool;
+
+    //asio guts -> socket and service
+    asio::io_service        _io_service;
+    socket_sptr             _socket;
+    int                     _sock_fd;
+};
+
+/***********************************************************************
+ * UDP zero copy make function
+ **********************************************************************/
+template<typename Opt> static void resize_buff_helper(
+    udp_zero_copy_asio_impl::sptr udp_trans,
+    const size_t target_size,
+    const std::string &name
+){
+    std::string help_message;
+    #if defined(UHD_PLATFORM_LINUX)
+        help_message = str(boost::format(
+            "Please run: sudo sysctl -w net.core.%smem_max=%d\n"
+        ) % ((name == "recv")?"r":"w") % target_size);
+    #endif /*defined(UHD_PLATFORM_LINUX)*/
+
+    //resize the buffer if size was provided
+    if (target_size > 0){
+        size_t actual_size = udp_trans->resize_buff<Opt>(target_size);
+        if (target_size != actual_size) std::cout << boost::format(
+            "Target %s sock buff size: %d bytes\n"
+            "Actual %s sock buff size: %d bytes"
+        ) % name % target_size % name % actual_size << std::endl;
+        else std::cout << boost::format(
+            "Current %s sock buff size: %d bytes"
+        ) % name % actual_size << std::endl;
+        if (actual_size < target_size) uhd::warning::post(str(boost::format(
+            "The %s buffer could not be resized sufficiently.\n"
+            "See the transport application notes on buffer resizing.\n%s"
+        ) % name % help_message));
+    }
+}
+
+udp_zero_copy::sptr udp_zero_copy::make(
+    const std::string &addr,
+    const std::string &port,
+    const device_addr_t &hints
+){
+    udp_zero_copy_asio_impl::sptr udp_trans(
+        new udp_zero_copy_asio_impl(addr, port, hints)
+    );
+
+    //extract buffer size hints from the device addr
+    size_t recv_buff_size = size_t(hints.cast<double>("recv_buff_size", 0.0));
+    size_t send_buff_size = size_t(hints.cast<double>("send_buff_size", 0.0));
+
+    //call the helper to resize send and recv buffers
+    resize_buff_helper<asio::socket_base::receive_buffer_size>(udp_trans, recv_buff_size, "recv");
+    resize_buff_helper<asio::socket_base::send_buffer_size>   (udp_trans, send_buff_size, "send");
+
+    return udp_trans;
+}
diff --git a/host/lib/transport/usb_dummy_impl.cpp b/host/lib/transport/usb_dummy_impl.cpp
new file mode 100644
index 000000000..930678405
--- /dev/null
+++ b/host/lib/transport/usb_dummy_impl.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#include <uhd/transport/usb_device_handle.hpp>
+#include <uhd/transport/usb_control.hpp>
+#include <uhd/transport/usb_zero_copy.hpp>
+#include <uhd/exception.hpp>
+
+using namespace uhd;
+using namespace uhd::transport;
+
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(boost::uint16_t, boost::uint16_t){
+    return std::vector<usb_device_handle::sptr>(); //empty list
+}
+
+usb_control::sptr usb_control::make(usb_device_handle::sptr){
+    throw uhd::not_implemented_error("no usb support -> usb_control::make not implemented");
+}
+
+usb_zero_copy::sptr usb_zero_copy::make(
+    usb_device_handle::sptr,
+    size_t, size_t, const device_addr_t &
+){
+    throw uhd::not_implemented_error("no usb support -> usb_zero_copy::make not implemented");
+}
diff --git a/host/lib/transport/vrt_packet_handler.hpp b/host/lib/transport/vrt_packet_handler.hpp
new file mode 100644
index 000000000..d74b2c13c
--- /dev/null
+++ b/host/lib/transport/vrt_packet_handler.hpp
@@ -0,0 +1,470 @@
+//
+// Copyright 2010-2011 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP
+#define INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP
+
+#include <uhd/config.hpp>
+#include <uhd/device.hpp>
+#include <uhd/exception.hpp>
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/types/io_type.hpp>
+#include <uhd/types/otw_type.hpp>
+#include <uhd/types/metadata.hpp>
+#include <uhd/transport/vrt_if_packet.hpp>
+#include <uhd/convert.hpp>
+#include <uhd/transport/zero_copy.hpp>
+#include <boost/function.hpp>
+#include <stdexcept>
+#include <iostream>
+#include <vector>
+
+namespace vrt_packet_handler{
+
+//this may change in the future but its a constant for now
+static const size_t OTW_BYTES_PER_SAMP = sizeof(boost::uint32_t);
+
+template <typename T> UHD_INLINE T get_context_code(
+    const boost::uint32_t *vrt_hdr,
+    const uhd::transport::vrt::if_packet_info_t &if_packet_info
+){
+    //extract the context word (we dont know the endianness so mirror the bytes)
+    boost::uint32_t word0 = vrt_hdr[if_packet_info.num_header_words32] |
+              uhd::byteswap(vrt_hdr[if_packet_info.num_header_words32]);
+    return T(word0 & 0xff);
+}
+
+/***********************************************************************
+ * vrt packet handler for recv
+ **********************************************************************/
+    typedef std::vector<uhd::transport::managed_recv_buffer::sptr> managed_recv_buffs_t;
+    typedef boost::function<bool(managed_recv_buffs_t &)> get_recv_buffs_t;
+    typedef boost::function<void(size_t /*which channel*/)> handle_overflow_t;
+    typedef boost::function<void(const boost::uint32_t *, uhd::transport::vrt::if_packet_info_t &)> vrt_unpacker_t;
+
+    static inline void handle_overflow_nop(size_t){}
+
+    struct recv_state{
+        //width of the receiver in channels
+        size_t width;
+
+        //state variables to handle fragments
+        managed_recv_buffs_t managed_buffs;
+        std::vector<const boost::uint8_t *> copy_buffs;
+        size_t size_of_copy_buffs;
+        size_t fragment_offset_in_samps;
+        std::vector<void *> io_buffs;
+        std::vector<const void *> otw_buffs;
+
+        recv_state(size_t width = 1):
+            width(width),
+            managed_buffs(width),
+            copy_buffs(width, NULL),
+            size_of_copy_buffs(0),
+            fragment_offset_in_samps(0),
+            io_buffs(0) //resized later
+        {
+            /* NOP */
+        }
+    };
+
+    /*******************************************************************
+     * Unpack a received vrt header and set the copy buffer.
+     *  - helper function for vrt_packet_handler::_recv1
+     ******************************************************************/
+    static UHD_INLINE void _recv1_helper(
+        recv_state &state,
+        uhd::rx_metadata_t &metadata,
+        double tick_rate,
+        const vrt_unpacker_t &vrt_unpacker,
+        const handle_overflow_t &handle_overflow,
+        size_t vrt_header_offset_words32
+    ){
+        //vrt unpack each managed buffer
+        uhd::transport::vrt::if_packet_info_t if_packet_info;
+        for (size_t i = 0; i < state.width; i++){
+            if (state.managed_buffs[i].get() == NULL) continue; //better have a message packet coming up...
+
+            //extract packet words and check thats its enough to move on
+            size_t num_packet_words32 = state.managed_buffs[i]->size()/sizeof(boost::uint32_t);
+            if (num_packet_words32 <= vrt_header_offset_words32){
+                throw std::runtime_error("recv buffer smaller than vrt packet offset");
+            }
+
+            //unpack the vrt header into the info struct
+            const boost::uint32_t *vrt_hdr = state.managed_buffs[i]->cast<const boost::uint32_t *>() + vrt_header_offset_words32;
+            if_packet_info.num_packet_words32 = num_packet_words32 - vrt_header_offset_words32;
+            vrt_unpacker(vrt_hdr, if_packet_info);
+
+            //handle the non-data packet case and parse its contents
+            if (if_packet_info.packet_type != uhd::transport::vrt::if_packet_info_t::PACKET_TYPE_DATA){
+
+                metadata.error_code = get_context_code<uhd::rx_metadata_t::error_code_t>(vrt_hdr, if_packet_info);
+                if (metadata.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) handle_overflow(i);
+
+                //break to exit loop and store metadata below
+                state.size_of_copy_buffs = 0; break;
+            }
+
+            //setup the buffer to point to the data
+            state.copy_buffs[i] = reinterpret_cast<const boost::uint8_t *>(vrt_hdr + if_packet_info.num_header_words32);
+
+            //store the minimum payload length into the copy buffer length
+            size_t num_payload_bytes = if_packet_info.num_payload_words32*sizeof(boost::uint32_t);
+            if (i == 0 or state.size_of_copy_buffs > num_payload_bytes){
+                state.size_of_copy_buffs = num_payload_bytes;
+            }
+        }
+
+        //store the last vrt info into the metadata
+        metadata.has_time_spec = if_packet_info.has_tsi and if_packet_info.has_tsf;
+        metadata.time_spec = uhd::time_spec_t(
+            time_t(if_packet_info.tsi), size_t(if_packet_info.tsf), tick_rate
+        );
+        static const int tlr_sob_flags = (1 << 21) | (1 << 9); //enable and indicator bits
+        metadata.start_of_burst = if_packet_info.has_tlr and (int(if_packet_info.tlr & tlr_sob_flags) == tlr_sob_flags);
+        static const int tlr_eob_flags = (1 << 20) | (1 << 8); //enable and indicator bits
+        metadata.end_of_burst   = if_packet_info.has_tlr and (int(if_packet_info.tlr & tlr_eob_flags) == tlr_eob_flags);
+    }
+
+    /*******************************************************************
+     * Recv data, unpack a vrt header, and copy-convert the data.
+     *  - helper function for vrt_packet_handler::recv
+     ******************************************************************/
+    static UHD_INLINE size_t _recv1(
+        recv_state &state,
+        const uhd::device::recv_buffs_type &buffs,
+        size_t offset_bytes,
+        size_t total_samps,
+        uhd::rx_metadata_t &metadata,
+        uhd::convert::function_type &converter,
+        double tick_rate,
+        const vrt_unpacker_t &vrt_unpacker,
+        const get_recv_buffs_t &get_recv_buffs,
+        const handle_overflow_t &handle_overflow,
+        size_t vrt_header_offset_words32,
+        size_t chans_per_otw_buff
+    ){
+        metadata.error_code = uhd::rx_metadata_t::ERROR_CODE_NONE;
+
+        //perform a receive if no rx data is waiting to be copied
+        if (state.size_of_copy_buffs == 0){
+            state.fragment_offset_in_samps = 0;
+            if (not get_recv_buffs(state.managed_buffs)){
+                metadata.error_code = uhd::rx_metadata_t::ERROR_CODE_TIMEOUT;
+                return 0;
+            }
+            try{
+                _recv1_helper(
+                    state, metadata, tick_rate,
+                    vrt_unpacker, handle_overflow,
+                    vrt_header_offset_words32
+                );
+            }catch(const std::exception &e){
+                state.size_of_copy_buffs = 0; //reset copy buffs size
+                std::cerr << "Error (recv): " << e.what() << std::endl;
+                metadata.error_code = uhd::rx_metadata_t::ERROR_CODE_BAD_PACKET;
+                return 0;
+            }
+        }
+        //defaults for the metadata when this is a fragment
+        else{
+            metadata.has_time_spec = false;
+            metadata.start_of_burst = false;
+            metadata.end_of_burst = false;
+        }
+
+        //extract the number of samples available to copy
+        size_t bytes_per_item = OTW_BYTES_PER_SAMP;
+        size_t nsamps_available = state.size_of_copy_buffs/bytes_per_item;
+        size_t nsamps_to_copy = std::min(total_samps*chans_per_otw_buff, nsamps_available);
+        size_t bytes_to_copy = nsamps_to_copy*bytes_per_item;
+        size_t nsamps_to_copy_per_io_buff = nsamps_to_copy/chans_per_otw_buff;
+
+        for (size_t i = 0; i < buffs.size(); i+=chans_per_otw_buff){
+
+            //fill a vector with pointers to the io buffers
+            for (size_t j = 0; j < chans_per_otw_buff; j++){
+                state.io_buffs[j] = reinterpret_cast<boost::uint8_t *>(buffs[i+j]) + offset_bytes;
+            }
+
+            //copy-convert the samples from the recv buffer
+            converter(state.copy_buffs[i], state.io_buffs, nsamps_to_copy_per_io_buff);
+
+            //update the rx copy buffer to reflect the bytes copied
+            state.copy_buffs[i] += bytes_to_copy;
+        }
+        //update the copy buffer's availability
+        state.size_of_copy_buffs -= bytes_to_copy;
+
+        //setup the fragment flags and offset
+        metadata.more_fragments = state.size_of_copy_buffs != 0;
+        metadata.fragment_offset = state.fragment_offset_in_samps;
+        state.fragment_offset_in_samps += nsamps_to_copy; //set for next call
+
+        return nsamps_to_copy_per_io_buff;
+    }
+
+    /*******************************************************************
+     * Recv vrt packets and copy convert the samples into the buffer.
+     ******************************************************************/
+    static UHD_INLINE size_t recv(
+        recv_state &state,
+        const uhd::device::recv_buffs_type &buffs,
+        const size_t total_num_samps,
+        uhd::rx_metadata_t &metadata,
+        uhd::device::recv_mode_t recv_mode,
+        const uhd::io_type_t &io_type,
+        const uhd::otw_type_t &otw_type,
+        double tick_rate,
+        const vrt_unpacker_t &vrt_unpacker,
+        const get_recv_buffs_t &get_recv_buffs,
+        const handle_overflow_t &handle_overflow = &handle_overflow_nop,
+        size_t vrt_header_offset_words32 = 0,
+        size_t chans_per_otw_buff = 1
+    ){
+        state.io_buffs.resize(chans_per_otw_buff);
+
+        uhd::convert::function_type converter(
+            uhd::convert::get_converter_otw_to_cpu(
+                io_type, otw_type, 1, chans_per_otw_buff
+        ));
+
+        switch(recv_mode){
+
+        ////////////////////////////////////////////////////////////////
+        case uhd::device::RECV_MODE_ONE_PACKET:{
+        ////////////////////////////////////////////////////////////////
+            return _recv1(
+                state,
+                buffs, 0,
+                total_num_samps,
+                metadata,
+                converter,
+                tick_rate,
+                vrt_unpacker,
+                get_recv_buffs,
+                handle_overflow,
+                vrt_header_offset_words32,
+                chans_per_otw_buff
+            );
+        }
+
+        ////////////////////////////////////////////////////////////////
+        case uhd::device::RECV_MODE_FULL_BUFF:{
+        ////////////////////////////////////////////////////////////////
+            size_t accum_num_samps = 0;
+            uhd::rx_metadata_t tmp_md;
+            while(accum_num_samps < total_num_samps){
+                size_t num_samps = _recv1(
+                    state,
+                    buffs, accum_num_samps*io_type.size,
+                    total_num_samps - accum_num_samps,
+                    (accum_num_samps == 0)? metadata : tmp_md, //only the first metadata gets kept
+                    converter,
+                    tick_rate,
+                    vrt_unpacker,
+                    get_recv_buffs,
+                    handle_overflow,
+                    vrt_header_offset_words32,
+                    chans_per_otw_buff
+                );
+                if (num_samps == 0) break; //had a recv timeout or error, break loop
+                accum_num_samps += num_samps;
+            }
+            return accum_num_samps;
+        }
+
+        default: throw std::runtime_error("unknown recv mode");
+        }//switch(recv_mode)
+    }
+
+/***********************************************************************
+ * vrt packet handler for send
+ **********************************************************************/
+    typedef std::vector<uhd::transport::managed_send_buffer::sptr> managed_send_buffs_t;
+    typedef boost::function<bool(managed_send_buffs_t &)> get_send_buffs_t;
+    typedef boost::function<void(boost::uint32_t *, uhd::transport::vrt::if_packet_info_t &)> vrt_packer_t;
+
+    static const boost::uint64_t zeros = 0;
+
+    struct send_state{
+        //init the expected seq number
+        size_t next_packet_seq;
+        managed_send_buffs_t managed_buffs;
+        std::vector<const void *> zero_buffs;
+        std::vector<const void *> io_buffs;
+
+        send_state(size_t width = 1):
+            next_packet_seq(0),
+            managed_buffs(width),
+            zero_buffs(width, &zeros),
+            io_buffs(0) //resized later
+        {
+            /* NOP */
+        }
+    };
+
+    /*******************************************************************
+     * Pack a vrt header, copy-convert the data, and send it.
+     *  - helper function for vrt_packet_handler::send
+     ******************************************************************/
+    static UHD_INLINE size_t _send1(
+        send_state &state,
+        const uhd::device::send_buffs_type &buffs,
+        const size_t offset_bytes,
+        const size_t num_samps,
+        uhd::transport::vrt::if_packet_info_t &if_packet_info,
+        uhd::convert::function_type &converter,
+        const vrt_packer_t &vrt_packer,
+        const get_send_buffs_t &get_send_buffs,
+        const size_t vrt_header_offset_words32,
+        const size_t chans_per_otw_buff
+    ){
+        //load the rest of the if_packet_info in here
+        if_packet_info.num_payload_words32 = (num_samps*chans_per_otw_buff*OTW_BYTES_PER_SAMP)/sizeof(boost::uint32_t);
+        if_packet_info.packet_count = state.next_packet_seq;
+
+        //get send buffers for each otw channel
+        if (not get_send_buffs(state.managed_buffs)) return 0;
+
+        for (size_t i = 0; i < buffs.size(); i+=chans_per_otw_buff){
+            //calculate pointers with offsets to io and otw memory
+            for (size_t j = 0; j < chans_per_otw_buff; j++){
+                state.io_buffs[j] = reinterpret_cast<const boost::uint8_t *>(buffs[i+j]) + offset_bytes;
+            }
+            boost::uint32_t *otw_mem = state.managed_buffs[i]->cast<boost::uint32_t *>() + vrt_header_offset_words32;
+
+            //pack metadata into a vrt header
+            vrt_packer(otw_mem, if_packet_info);
+            otw_mem += if_packet_info.num_header_words32;
+
+            //copy-convert the samples into the send buffer
+            converter(state.io_buffs, otw_mem, num_samps);
+
+            //commit the samples to the zero-copy interface
+            size_t num_bytes_total = (vrt_header_offset_words32+if_packet_info.num_packet_words32)*sizeof(boost::uint32_t);
+            state.managed_buffs[i]->commit(num_bytes_total);
+        }
+        state.next_packet_seq++; //increment sequence after commits
+        return num_samps;
+    }
+
+    /*******************************************************************
+     * Send vrt packets and copy convert the samples into the buffer.
+     ******************************************************************/
+    static UHD_INLINE size_t send(
+        send_state &state,
+        const uhd::device::send_buffs_type &buffs,
+        const size_t total_num_samps,
+        const uhd::tx_metadata_t &metadata,
+        uhd::device::send_mode_t send_mode,
+        const uhd::io_type_t &io_type,
+        const uhd::otw_type_t &otw_type,
+        double tick_rate,
+        const vrt_packer_t &vrt_packer,
+        const get_send_buffs_t &get_send_buffs,
+        size_t max_samples_per_packet,
+        size_t vrt_header_offset_words32 = 0,
+        size_t chans_per_otw_buff = 1
+    ){
+        state.io_buffs.resize(chans_per_otw_buff);
+
+        uhd::convert::function_type converter(
+            uhd::convert::get_converter_cpu_to_otw(
+                io_type, otw_type, chans_per_otw_buff, 1
+        ));
+
+        //translate the metadata to vrt if packet info
+        uhd::transport::vrt::if_packet_info_t if_packet_info;
+        if_packet_info.has_sid = false;
+        if_packet_info.has_cid = false;
+        if_packet_info.has_tlr = false;
+        if_packet_info.tsi = boost::uint32_t(metadata.time_spec.get_full_secs());
+        if_packet_info.tsf = boost::uint64_t(metadata.time_spec.get_tick_count(tick_rate));
+
+        if (total_num_samps <= max_samples_per_packet) send_mode = uhd::device::SEND_MODE_ONE_PACKET;
+        switch(send_mode){
+
+        ////////////////////////////////////////////////////////////////
+        case uhd::device::SEND_MODE_ONE_PACKET:{
+        ////////////////////////////////////////////////////////////////
+
+            //fill in parts of the packet info overwrote in full buff mode
+            if_packet_info.has_tsi = metadata.has_time_spec;
+            if_packet_info.has_tsf = metadata.has_time_spec;
+            if_packet_info.sob = metadata.start_of_burst;
+            if_packet_info.eob = metadata.end_of_burst;
+
+            return _send1(
+                state,
+                //TODO remove this code when sample counts of zero are supported by hardware
+                (total_num_samps)?buffs : state.zero_buffs, 0,
+                std::max<size_t>(1, std::min(total_num_samps, max_samples_per_packet)),
+                if_packet_info,
+                converter,
+                vrt_packer,
+                get_send_buffs,
+                vrt_header_offset_words32,
+                chans_per_otw_buff
+            );
+        }
+
+        ////////////////////////////////////////////////////////////////
+        case uhd::device::SEND_MODE_FULL_BUFF:{
+        ////////////////////////////////////////////////////////////////
+            size_t total_num_samps_sent = 0;
+
+            //loop through the following fragment indexes
+            while(total_num_samps_sent < total_num_samps){
+
+                //calculate per-loop-iteration variables
+                const size_t total_num_samps_unsent = total_num_samps - total_num_samps_sent;
+                const bool first_fragment = (total_num_samps_sent == 0);
+                const bool final_fragment = (total_num_samps_unsent <= max_samples_per_packet);
+
+                //calculate new flags for the fragments
+                if_packet_info.has_tsi = metadata.has_time_spec  and first_fragment;
+                if_packet_info.has_tsf = if_packet_info.has_tsi;
+                if_packet_info.sob     = metadata.start_of_burst and first_fragment;
+                if_packet_info.eob     = metadata.end_of_burst   and final_fragment;
+
+                //send the fragment with the helper function
+                const size_t num_samps_sent = _send1(
+                    state,
+                    buffs, total_num_samps_sent*io_type.size,
+                    std::min(total_num_samps_unsent, max_samples_per_packet),
+                    if_packet_info,
+                    converter,
+                    vrt_packer,
+                    get_send_buffs,
+                    vrt_header_offset_words32,
+                    chans_per_otw_buff
+                );
+                total_num_samps_sent += num_samps_sent;
+                if (num_samps_sent == 0) return total_num_samps_sent;
+            }
+            return total_num_samps_sent;
+        }
+
+        default: throw std::runtime_error("unknown send mode");
+        }//switch(send_mode)
+    }
+
+} //namespace vrt_packet_handler
+
+#endif /* INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP */