Merge branch 'master' into ashish/register_api

17 files changed, 135 insertions, 268 deletions

diff --git a/host/lib/error_c.cpp b/host/lib/error_c.cpp
index c3a83eec9..3ce63a81d 100644
--- a/host/lib/error_c.cpp
+++ b/host/lib/error_c.cpp
@@ -17,6 +17,11 @@
 
 #include <uhd/error.h>
 #include <uhd/exception.hpp>
+#include <uhd/utils/static.hpp>
+
+#include <boost/thread/mutex.hpp>
+
+#include <cstring>
 
 #define MAP_TO_ERROR(exception_type, error_type) \
     if (dynamic_cast<const uhd::exception_type*>(e)) return error_type;
@@ -38,3 +43,34 @@ uhd_error error_from_uhd_exception(const uhd::exception* e){
 
     return UHD_ERROR_EXCEPT;
 }
+
+// Store the error string in a single place in library
+UHD_SINGLETON_FCN(std::string, _c_global_error_string)
+
+static boost::mutex _error_c_mutex;
+
+const std::string& get_c_global_error_string(){
+    boost::mutex::scoped_lock lock(_error_c_mutex);
+    return _c_global_error_string();
+}
+
+void set_c_global_error_string(
+    const std::string &msg
+){
+    boost::mutex::scoped_lock lock(_error_c_mutex);
+    _c_global_error_string() = msg;
+}
+
+uhd_error uhd_get_last_error(
+    char* error_out,
+    size_t strbuffer_len
+){
+    try{
+        memset(error_out, '\0', strbuffer_len);
+        strncpy(error_out, _c_global_error_string().c_str(), strbuffer_len);
+    }
+    catch(...){
+        return UHD_ERROR_UNKNOWN;
+    }
+    return UHD_ERROR_NONE;
+}
diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt
index 9ec8a5c0b..6abc399b4 100644
--- a/host/lib/transport/CMakeLists.txt
+++ b/host/lib/transport/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010-2013 Ettus Research LLC
+# Copyright 2010-2013,2015 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
@@ -30,7 +30,7 @@ INCLUDE_SUBDIRECTORY(nirio)
 MESSAGE(STATUS "")
 FIND_PACKAGE(USB1)
 
-LIBUHD_REGISTER_COMPONENT("USB" ENABLE_USB ON "ENABLE_LIBUHD;LIBUSB_FOUND" OFF)
+LIBUHD_REGISTER_COMPONENT("USB" ENABLE_USB ON "ENABLE_LIBUHD;LIBUSB_FOUND" OFF OFF)
 
 IF(ENABLE_USB)
     MESSAGE(STATUS "USB support enabled via libusb.")
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
index 6925e7659..b67b36d0a 100644
--- a/host/lib/transport/libusb1_zero_copy.cpp
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -139,8 +139,8 @@ public:
 #endif
         const int ret = libusb_submit_transfer(_lut);
         if (ret != LIBUSB_SUCCESS)
-            throw uhd::runtime_error(str(boost::format("usb %s submit failed: %s")
-                                         % _name % libusb_strerror((libusb_error)ret)));
+	  throw uhd::usb_error(ret, str(boost::format(
+            "usb %s submit failed: %s") % _name % libusb_error_name(ret)));
     }
 
     template <typename buffer_type>
@@ -353,7 +353,7 @@ private:
                 _enqueued.push_back(_released.front());
                 _released.pop_front();
             }
-            catch (uhd::runtime_error& e)
+            catch (uhd::usb_error& e)
             {
                 _status = STATUS_ERROR;
                 throw e;
diff --git a/host/lib/types/CMakeLists.txt b/host/lib/types/CMakeLists.txt
index 891977065..ebb788183 100644
--- a/host/lib/types/CMakeLists.txt
+++ b/host/lib/types/CMakeLists.txt
@@ -97,10 +97,10 @@ LIBUHD_APPEND_SOURCES(
 
 IF(ENABLE_C_API)
     LIBUHD_APPEND_SOURCES(
-	${CMAKE_CURRENT_SOURCE_DIR}/device_addrs_c.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/metadata_c.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/ranges_c.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/sensors_c.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/string_vector_c.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/tune_c.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/usrp_info_c.cpp
     )
diff --git a/host/lib/types/device_addrs_c.cpp b/host/lib/types/string_vector_c.cpp
index 3a24551d3..b50c7cdff 100644
--- a/host/lib/types/device_addrs_c.cpp
+++ b/host/lib/types/string_vector_c.cpp
@@ -15,18 +15,20 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
-#include <uhd/types/device_addrs.h>
+#include <uhd/types/string_vector.h>
 
-uhd_error uhd_device_addrs_make(
-    uhd_device_addrs_handle *h
+#include <string.h>
+
+uhd_error uhd_string_vector_make(
+    uhd_string_vector_handle *h
 ){
     UHD_SAFE_C(
-        (*h) = new uhd_device_addrs_t;
+        (*h) = new uhd_string_vector_t;
     )
 }
 
-uhd_error uhd_device_addrs_free(
-    uhd_device_addrs_handle *h
+uhd_error uhd_string_vector_free(
+    uhd_string_vector_handle *h
 ){
     UHD_SAFE_C(
         delete (*h);
@@ -34,17 +36,17 @@ uhd_error uhd_device_addrs_free(
     )
 }
 
-uhd_error uhd_device_addrs_push_back(
-    uhd_device_addrs_handle h,
+uhd_error uhd_string_vector_push_back(
+    uhd_string_vector_handle *h,
     const char* value
 ){
-    UHD_SAFE_C_SAVE_ERROR(h,
-        h->device_addrs_cpp.push_back(uhd::device_addr_t(value));
+    UHD_SAFE_C_SAVE_ERROR((*h),
+        (*h)->string_vector_cpp.push_back(value);
     )
 }
 
-uhd_error uhd_device_addrs_at(
-    uhd_device_addrs_handle h,
+uhd_error uhd_string_vector_at(
+    uhd_string_vector_handle h,
     size_t index,
     char* value_out,
     size_t strbuffer_len
@@ -52,22 +54,22 @@ uhd_error uhd_device_addrs_at(
     UHD_SAFE_C_SAVE_ERROR(h,
         memset(value_out, '\0', strbuffer_len);
 
-        std::string value_cpp = h->device_addrs_cpp.at(index).to_string();
+        const std::string& value_cpp = h->string_vector_cpp.at(index);
         strncpy(value_out, value_cpp.c_str(), strbuffer_len);
     )
 }
 
-uhd_error uhd_device_addrs_size(
-    uhd_device_addrs_handle h,
+uhd_error uhd_string_vector_size(
+    uhd_string_vector_handle h,
     size_t *size_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        *size_out = h->device_addrs_cpp.size();
+        *size_out = h->string_vector_cpp.size();
     )
 }
 
-uhd_error uhd_device_addrs_last_error(
-    uhd_device_addrs_handle h,
+uhd_error uhd_string_vector_last_error(
+    uhd_string_vector_handle h,
     char* error_out,
     size_t strbuffer_len
 ){
diff --git a/host/lib/usrp/CMakeLists.txt b/host/lib/usrp/CMakeLists.txt
index e01e5e09d..5c9592970 100644
--- a/host/lib/usrp/CMakeLists.txt
+++ b/host/lib/usrp/CMakeLists.txt
@@ -43,7 +43,7 @@ IF(ENABLE_C_API)
     )
 ENDIF(ENABLE_C_API)
 
-LIBUHD_REGISTER_COMPONENT("GPSD" ENABLE_GPSD OFF "ENABLE_LIBUHD;ENABLE_GPSD;LIBGPS_FOUND" OFF)
+LIBUHD_REGISTER_COMPONENT("GPSD" ENABLE_GPSD OFF "ENABLE_LIBUHD;ENABLE_GPSD;LIBGPS_FOUND" OFF OFF)
 
 IF(ENABLE_GPSD)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp/b100/CMakeLists.txt b/host/lib/usrp/b100/CMakeLists.txt
index bcc5ac74d..1558cd974 100644
--- a/host/lib/usrp/b100/CMakeLists.txt
+++ b/host/lib/usrp/b100/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2011-2013 Ettus Research LLC
+# Copyright 2011-2013,2015 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
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the B100 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("B100" ENABLE_B100 ON "ENABLE_LIBUHD;ENABLE_USB" OFF)
+LIBUHD_REGISTER_COMPONENT("B100" ENABLE_B100 ON "ENABLE_LIBUHD;ENABLE_USB" OFF OFF)
 
 IF(ENABLE_B100)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp/b200/CMakeLists.txt b/host/lib/usrp/b200/CMakeLists.txt
index cd8ebcba7..76710dc65 100644
--- a/host/lib/usrp/b200/CMakeLists.txt
+++ b/host/lib/usrp/b200/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2012-2013 Ettus Research LLC
+# Copyright 2012-2013,2015 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
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the B200 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("B200" ENABLE_B200 ON "ENABLE_LIBUHD;ENABLE_USB" OFF)
+LIBUHD_REGISTER_COMPONENT("B200" ENABLE_B200 ON "ENABLE_LIBUHD;ENABLE_USB" OFF OFF)
 
 IF(ENABLE_B200)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp/e100/CMakeLists.txt b/host/lib/usrp/e100/CMakeLists.txt
index ac9d8c655..2a1e14eab 100644
--- a/host/lib/usrp/e100/CMakeLists.txt
+++ b/host/lib/usrp/e100/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010-2011 Ettus Research LLC
+# Copyright 2010-2011,2015 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
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the USRP-E100 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("E100" ENABLE_E100 OFF "ENABLE_LIBUHD;LINUX" OFF)
+LIBUHD_REGISTER_COMPONENT("E100" ENABLE_E100 OFF "ENABLE_LIBUHD;LINUX" OFF OFF)
 
 IF(ENABLE_E100)
     INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
diff --git a/host/lib/usrp/e300/CMakeLists.txt b/host/lib/usrp/e300/CMakeLists.txt
index ae817c620..9c8aa29b9 100644
--- a/host/lib/usrp/e300/CMakeLists.txt
+++ b/host/lib/usrp/e300/CMakeLists.txt
@@ -24,7 +24,7 @@
 ########################################################################
 find_package(UDev)
 
-LIBUHD_REGISTER_COMPONENT("E300" ENABLE_E300 OFF "ENABLE_LIBUHD" OFF)
+LIBUHD_REGISTER_COMPONENT("E300" ENABLE_E300 OFF "ENABLE_LIBUHD" OFF OFF)
 
 IF(ENABLE_E300)
     LIST(APPEND E300_SOURCES
diff --git a/host/lib/usrp/usrp1/CMakeLists.txt b/host/lib/usrp/usrp1/CMakeLists.txt
index 70bebe502..47344e841 100644
--- a/host/lib/usrp/usrp1/CMakeLists.txt
+++ b/host/lib/usrp/usrp1/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010-2011 Ettus Research LLC
+# Copyright 2010-2011,2015 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
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the USRP1 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("USRP1" ENABLE_USRP1 ON "ENABLE_LIBUHD;ENABLE_USB" OFF)
+LIBUHD_REGISTER_COMPONENT("USRP1" ENABLE_USRP1 ON "ENABLE_LIBUHD;ENABLE_USB" OFF OFF)
 
 IF(ENABLE_USRP1)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp/usrp2/CMakeLists.txt b/host/lib/usrp/usrp2/CMakeLists.txt
index bd302895b..d9894adaf 100644
--- a/host/lib/usrp/usrp2/CMakeLists.txt
+++ b/host/lib/usrp/usrp2/CMakeLists.txt
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the USRP2 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("USRP2" ENABLE_USRP2 ON "ENABLE_LIBUHD" OFF)
+LIBUHD_REGISTER_COMPONENT("USRP2" ENABLE_USRP2 ON "ENABLE_LIBUHD" OFF OFF)
 
 IF(ENABLE_USRP2)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp/usrp_c.cpp b/host/lib/usrp/usrp_c.cpp
index 829014829..724b907a1 100644
--- a/host/lib/usrp/usrp_c.cpp
+++ b/host/lib/usrp/usrp_c.cpp
@@ -132,14 +132,14 @@ uhd_error uhd_rx_streamer_recv(
     uhd_rx_streamer_handle h,
     void **buffs,
     size_t samps_per_buff,
-    uhd_rx_metadata_handle md,
+    uhd_rx_metadata_handle *md,
     double timeout,
     bool one_packet,
     size_t *items_recvd
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
         uhd::rx_streamer::buffs_type buffs_cpp(buffs, RX_STREAMER(h)->get_num_channels());
-        *items_recvd = RX_STREAMER(h)->recv(buffs_cpp, samps_per_buff, md->rx_metadata_cpp, timeout, one_packet);
+        *items_recvd = RX_STREAMER(h)->recv(buffs_cpp, samps_per_buff, (*md)->rx_metadata_cpp, timeout, one_packet);
     )
 }
 
@@ -208,9 +208,9 @@ uhd_error uhd_tx_streamer_max_num_samps(
 uhd_error uhd_tx_streamer_send(
     uhd_tx_streamer_handle h,
     const void **buffs,
-    const size_t samps_per_buff,
-    const uhd_tx_metadata_handle md,
-    const double timeout,
+    size_t samps_per_buff,
+    uhd_tx_metadata_handle *md,
+    double timeout,
     size_t *items_sent
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
@@ -218,7 +218,7 @@ uhd_error uhd_tx_streamer_send(
         *items_sent = TX_STREAMER(h)->send(
             buffs_cpp,
             samps_per_buff,
-            md->tx_metadata_cpp,
+            (*md)->tx_metadata_cpp,
             timeout
         );
     )
@@ -226,12 +226,12 @@ uhd_error uhd_tx_streamer_send(
 
 uhd_error uhd_tx_streamer_recv_async_msg(
     uhd_tx_streamer_handle h,
-    uhd_async_metadata_handle md,
+    uhd_async_metadata_handle *md,
     const double timeout,
     bool *valid
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        *valid = TX_STREAMER(h)->recv_async_msg(md->async_metadata_cpp, timeout);
+        *valid = TX_STREAMER(h)->recv_async_msg((*md)->async_metadata_cpp, timeout);
     )
 }
 
@@ -251,15 +251,17 @@ uhd_error uhd_tx_streamer_last_error(
  ***************************************************************************/
 static boost::mutex _usrp_find_mutex;
 uhd_error uhd_usrp_find(
-    uhd_device_addrs_handle h,
     const char* args,
-    size_t *num_found
+    uhd_string_vector_handle *strings_out
 ){
-    UHD_SAFE_C_SAVE_ERROR(h,
+    UHD_SAFE_C(
         boost::mutex::scoped_lock _lock(_usrp_find_mutex);
 
-        h->device_addrs_cpp = uhd::device::find(std::string(args), uhd::device::USRP);
-        *num_found = h->device_addrs_cpp.size();
+        uhd::device_addrs_t devs = uhd::device::find(std::string(args), uhd::device::USRP);
+        (*strings_out)->string_vector_cpp.clear();
+        BOOST_FOREACH(const uhd::device_addr_t &dev, devs){
+            (*strings_out)->string_vector_cpp.push_back(dev.to_string());
+        }
     )
 }
 
@@ -539,16 +541,6 @@ uhd_error uhd_usrp_clear_command_time(
     )
 }
 
-uhd_error uhd_usrp_issue_stream_cmd(
-    uhd_usrp_handle h,
-    uhd_stream_cmd_t *stream_cmd,
-    size_t chan
-){
-    UHD_SAFE_C_SAVE_ERROR(h,
-        USRP(h)->issue_stream_cmd(stream_cmd_c_to_cpp(stream_cmd), chan);
-    )
-}
-
 uhd_error uhd_usrp_set_time_source(
     uhd_usrp_handle h,
     const char* time_source,
@@ -573,25 +565,10 @@ uhd_error uhd_usrp_get_time_source(
 uhd_error uhd_usrp_get_time_sources(
     uhd_usrp_handle h,
     size_t mboard,
-    char* time_sources_out,
-    size_t strbuffer_len,
-    size_t *num_time_sources_out
+    uhd_string_vector_handle *time_sources_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> time_sources = USRP(h)->get_time_sources(mboard);
-        *num_time_sources_out = time_sources.size();
-
-        std::string time_sources_str = "";
-        BOOST_FOREACH(const std::string &time_source, time_sources){
-            time_sources_str += time_source;
-            time_sources_str += ',';
-        }
-        if(time_sources.size() > 0){
-            time_sources_str.resize(time_sources_str.size()-1);
-        }
-
-        memset(time_sources_out, '\0', strbuffer_len);
-        strncpy(time_sources_out, time_sources_str.c_str(), strbuffer_len);
+        (*time_sources_out)->string_vector_cpp = USRP(h)->get_time_sources(mboard);
     )
 }
 
@@ -619,25 +596,10 @@ uhd_error uhd_usrp_get_clock_source(
 uhd_error uhd_usrp_get_clock_sources(
     uhd_usrp_handle h,
     size_t mboard,
-    char* clock_sources_out,
-    size_t strbuffer_len,
-    size_t *num_clock_sources_out
+    uhd_string_vector_handle *clock_sources_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> clock_sources = USRP(h)->get_clock_sources(mboard);
-        *num_clock_sources_out = clock_sources.size();
-
-        std::string clock_sources_str = "";
-        BOOST_FOREACH(const std::string &clock_source, clock_sources){
-            clock_sources_str += clock_source;
-            clock_sources_str += ',';
-        }
-        if(clock_sources.size() > 0){
-            clock_sources_str.resize(clock_sources_str.size()-1);
-        }
-
-        memset(clock_sources_out, '\0', strbuffer_len);
-        strncpy(clock_sources_out, clock_sources_str.c_str(), strbuffer_len);
+        (*clock_sources_out)->string_vector_cpp = USRP(h)->get_clock_sources(mboard);
     )
 }
 
@@ -664,36 +626,21 @@ uhd_error uhd_usrp_get_mboard_sensor(
     uhd_usrp_handle h,
     const char* name,
     size_t mboard,
-    uhd_sensor_value_handle sensor_value_out
+    uhd_sensor_value_handle *sensor_value_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        delete sensor_value_out->sensor_value_cpp;
-        sensor_value_out->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_mboard_sensor(name, mboard));
+        delete (*sensor_value_out)->sensor_value_cpp;
+        (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_mboard_sensor(name, mboard));
     )
 }
 
 uhd_error uhd_usrp_get_mboard_sensor_names(
     uhd_usrp_handle h,
     size_t mboard,
-    char* mboard_sensor_names_out,
-    size_t strbuffer_len,
-    size_t *num_mboard_sensors_out
+    uhd_string_vector_handle *mboard_sensor_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> mboard_sensor_names = USRP(h)->get_mboard_sensor_names(mboard);
-        *num_mboard_sensors_out = mboard_sensor_names.size();
-
-        std::string mboard_sensor_names_str = "";
-        BOOST_FOREACH(const std::string &mboard_sensor_name, mboard_sensor_names){
-            mboard_sensor_names_str += mboard_sensor_name;
-            mboard_sensor_names_str += ',';
-        }
-        if(mboard_sensor_names.size() > 0){
-            mboard_sensor_names_str.resize(mboard_sensor_names_str.size()-1);
-        }
-
-        memset(mboard_sensor_names_out, '\0', strbuffer_len);
-        strncpy(mboard_sensor_names_out, mboard_sensor_names_str.c_str(), strbuffer_len);
+        (*mboard_sensor_names_out)->string_vector_cpp = USRP(h)->get_mboard_sensor_names(mboard);
     )
 }
 
@@ -968,25 +915,10 @@ uhd_error uhd_usrp_get_rx_gain_range(
 uhd_error uhd_usrp_get_rx_gain_names(
     uhd_usrp_handle h,
     size_t chan,
-    char* gain_names_out,
-    size_t strbuffer_len,
-    size_t *num_rx_gain_names_out
+    uhd_string_vector_handle *gain_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> rx_gain_names = USRP(h)->get_rx_gain_names(chan);
-        *num_rx_gain_names_out = rx_gain_names.size();
-
-        std::string rx_gain_names_str = "";
-        BOOST_FOREACH(const std::string &gain_name, rx_gain_names){
-            rx_gain_names_str += gain_name;
-            rx_gain_names_str += ',';
-        }
-        if(rx_gain_names.size() > 0){
-            rx_gain_names_str.resize(rx_gain_names_str.size()-1);
-        }
-
-        memset(gain_names_out, '\0', strbuffer_len);
-        strncpy(gain_names_out, rx_gain_names_str.c_str(), strbuffer_len);
+        (*gain_names_out)->string_vector_cpp = USRP(h)->get_rx_gain_names(chan);
     )
 }
 
@@ -1015,25 +947,10 @@ uhd_error uhd_usrp_get_rx_antenna(
 uhd_error uhd_usrp_get_rx_antennas(
     uhd_usrp_handle h,
     size_t chan,
-    char* antennas_out,
-    size_t strbuffer_len,
-    size_t *num_rx_antennas_out
+    uhd_string_vector_handle *antennas_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> rx_antennas = USRP(h)->get_rx_antennas(chan);
-        *num_rx_antennas_out = rx_antennas.size();
-
-        std::string rx_antennas_str = "";
-        BOOST_FOREACH(const std::string &rx_antenna, rx_antennas){
-            rx_antennas_str += rx_antenna;
-            rx_antennas_str += ',';
-        }
-        if(rx_antennas.size() > 0){
-            rx_antennas_str.resize(rx_antennas_str.size()-1);
-        }
-
-        memset(antennas_out, '\0', strbuffer_len);
-        strncpy(antennas_out, rx_antennas_str.c_str(), strbuffer_len);
+        (*antennas_out)->string_vector_cpp = USRP(h)->get_rx_antennas(chan);
     )
 }
 
@@ -1071,36 +988,21 @@ uhd_error uhd_usrp_get_rx_sensor(
     uhd_usrp_handle h,
     const char* name,
     size_t chan,
-    uhd_sensor_value_handle sensor_value_out
+    uhd_sensor_value_handle *sensor_value_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        delete sensor_value_out->sensor_value_cpp;
-        sensor_value_out->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_rx_sensor(name, chan));
+        delete (*sensor_value_out)->sensor_value_cpp;
+        (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_rx_sensor(name, chan));
     )
 }
 
 uhd_error uhd_usrp_get_rx_sensor_names(
     uhd_usrp_handle h,
     size_t chan,
-    char* sensor_names_out,
-    size_t strbuffer_len,
-    size_t *num_rx_sensors_out
+    uhd_string_vector_handle *sensor_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> rx_sensor_names = USRP(h)->get_rx_sensor_names(chan);
-        *num_rx_sensors_out = rx_sensor_names.size();
-
-        std::string rx_sensor_names_str = "";
-        BOOST_FOREACH(const std::string &rx_sensor_name, rx_sensor_names){
-            rx_sensor_names_str += rx_sensor_name;
-            rx_sensor_names_str += ',';
-        }
-        if(rx_sensor_names.size() > 0){
-            rx_sensor_names_str.resize(rx_sensor_names_str.size()-1);
-        }
-
-        memset(sensor_names_out, '\0', strbuffer_len);
-        strncpy(sensor_names_out, rx_sensor_names_str.c_str(), strbuffer_len);
+        (*sensor_names_out)->string_vector_cpp = USRP(h)->get_rx_sensor_names(chan);
     )
 }
 
@@ -1311,25 +1213,10 @@ uhd_error uhd_usrp_get_tx_gain_range(
 uhd_error uhd_usrp_get_tx_gain_names(
     uhd_usrp_handle h,
     size_t chan,
-    char* gain_names_out,
-    size_t strbuffer_len,
-    size_t *num_tx_gain_names_out
+    uhd_string_vector_handle *gain_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> tx_gain_names = USRP(h)->get_tx_gain_names(chan);
-        *num_tx_gain_names_out = tx_gain_names.size();
-
-        std::string tx_gain_names_str = "";
-        BOOST_FOREACH(const std::string &tx_gain_name, tx_gain_names){
-            tx_gain_names_str += tx_gain_name;
-            tx_gain_names_str += ',';
-        }
-        if(tx_gain_names.size() > 0){
-            tx_gain_names_str.resize(tx_gain_names_str.size()-1);
-        }
-
-        memset(gain_names_out, '\0', strbuffer_len);
-        strncpy(gain_names_out, tx_gain_names_str.c_str(), strbuffer_len);
+        (*gain_names_out)->string_vector_cpp = USRP(h)->get_tx_gain_names(chan);
     )
 }
 
@@ -1358,25 +1245,10 @@ uhd_error uhd_usrp_get_tx_antenna(
 uhd_error uhd_usrp_get_tx_antennas(
     uhd_usrp_handle h,
     size_t chan,
-    char* antennas_out,
-    size_t strbuffer_len,
-    size_t *num_tx_antennas_out
+    uhd_string_vector_handle *antennas_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> tx_antennas = USRP(h)->get_tx_antennas(chan);
-        *num_tx_antennas_out = tx_antennas.size();
-
-        std::string tx_antennas_str = "";
-        BOOST_FOREACH(const std::string &tx_antenna, tx_antennas){
-            tx_antennas_str += tx_antenna;
-            tx_antennas_str += ',';
-        }
-        if(tx_antennas.size() > 0){
-            tx_antennas_str.resize(tx_antennas_str.size()-1);
-        }
-
-        memset(antennas_out, '\0', strbuffer_len);
-        strncpy(antennas_out, tx_antennas_str.c_str(), strbuffer_len);
+        (*antennas_out)->string_vector_cpp = USRP(h)->get_tx_antennas(chan);
     )
 }
 
@@ -1414,36 +1286,21 @@ uhd_error uhd_usrp_get_tx_sensor(
     uhd_usrp_handle h,
     const char* name,
     size_t chan,
-    uhd_sensor_value_handle sensor_value_out
+    uhd_sensor_value_handle *sensor_value_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        delete sensor_value_out->sensor_value_cpp;
-        sensor_value_out->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_tx_sensor(name, chan));
+        delete (*sensor_value_out)->sensor_value_cpp;
+        (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(USRP(h)->get_tx_sensor(name, chan));
     )
 }
 
 uhd_error uhd_usrp_get_tx_sensor_names(
     uhd_usrp_handle h,
     size_t chan,
-    char* sensor_names_out,
-    size_t strbuffer_len,
-    size_t *num_tx_sensors_out
+    uhd_string_vector_handle *sensor_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> tx_sensor_names = USRP(h)->get_tx_sensor_names(chan);
-        *num_tx_sensors_out = tx_sensor_names.size();
-
-        std::string tx_sensor_names_str = "";
-        BOOST_FOREACH(const std::string &tx_sensor_name, tx_sensor_names){
-            tx_sensor_names_str += tx_sensor_name;
-            tx_sensor_names_str += ',';
-        }
-        if(tx_sensor_names.size() > 0){
-            tx_sensor_names_str.resize(tx_sensor_names_str.size()-1);
-        }
-
-        memset(sensor_names_out, '\0', strbuffer_len);
-        strncpy(sensor_names_out, tx_sensor_names_str.c_str(), strbuffer_len);
+        (*sensor_names_out)->string_vector_cpp = USRP(h)->get_tx_sensor_names(chan);
     )
 }
 
@@ -1474,25 +1331,10 @@ uhd_error uhd_usrp_set_tx_iq_balance_enabled(
 uhd_error uhd_usrp_get_gpio_banks(
     uhd_usrp_handle h,
     size_t chan,
-    char* gpio_banks_out,
-    size_t strbuffer_len,
-    size_t *num_gpio_banks_out
+    uhd_string_vector_handle *gpio_banks_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> gpio_banks = USRP(h)->get_gpio_banks(chan);
-        *num_gpio_banks_out = gpio_banks.size();
-
-        std::string gpio_banks_str = "";
-        BOOST_FOREACH(const std::string &gpio_bank, gpio_banks){
-            gpio_banks_str += gpio_bank;
-            gpio_banks_str += ',';
-        }
-        if(gpio_banks.size() > 0){
-            gpio_banks_str.resize(gpio_banks_str.size()-1);
-        }
-
-        memset(gpio_banks_out, '\0', strbuffer_len);
-        strncpy(gpio_banks_out, gpio_banks_str.c_str(), strbuffer_len);
+        (*gpio_banks_out)->string_vector_cpp = USRP(h)->get_gpio_banks(chan);
     )
 }
 
diff --git a/host/lib/usrp/x300/CMakeLists.txt b/host/lib/usrp/x300/CMakeLists.txt
index 9a8601452..3d6348eec 100644
--- a/host/lib/usrp/x300/CMakeLists.txt
+++ b/host/lib/usrp/x300/CMakeLists.txt
@@ -22,7 +22,7 @@
 ########################################################################
 # Conditionally configure the X300 support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("X300" ENABLE_X300 ON "ENABLE_LIBUHD" OFF)
+LIBUHD_REGISTER_COMPONENT("X300" ENABLE_X300 ON "ENABLE_LIBUHD" OFF OFF)
 
 IF(ENABLE_X300)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp_clock/octoclock/CMakeLists.txt b/host/lib/usrp_clock/octoclock/CMakeLists.txt
index c489657e2..96b670115 100644
--- a/host/lib/usrp_clock/octoclock/CMakeLists.txt
+++ b/host/lib/usrp_clock/octoclock/CMakeLists.txt
@@ -18,7 +18,7 @@
 ########################################################################
 # Conditionally configure the OctoClock support
 ########################################################################
-LIBUHD_REGISTER_COMPONENT("OctoClock" ENABLE_OCTOCLOCK ON "ENABLE_LIBUHD" OFF)
+LIBUHD_REGISTER_COMPONENT("OctoClock" ENABLE_OCTOCLOCK ON "ENABLE_LIBUHD" OFF OFF)
 
 IF(ENABLE_OCTOCLOCK)
     LIBUHD_APPEND_SOURCES(
diff --git a/host/lib/usrp_clock/usrp_clock_c.cpp b/host/lib/usrp_clock/usrp_clock_c.cpp
index dc5913534..220112f37 100644
--- a/host/lib/usrp_clock/usrp_clock_c.cpp
+++ b/host/lib/usrp_clock/usrp_clock_c.cpp
@@ -56,15 +56,17 @@ UHD_SINGLETON_FCN(usrp_clock_ptrs, get_usrp_clock_ptrs);
  ***************************************************************************/
 static boost::mutex _usrp_clock_find_mutex;
 uhd_error uhd_usrp_clock_find(
-    uhd_device_addrs_handle h,
     const char* args,
-    size_t *num_found
+    uhd_string_vector_t *devices_out
 ){
-    UHD_SAFE_C_SAVE_ERROR(h,
+    UHD_SAFE_C(
         boost::mutex::scoped_lock lock(_usrp_clock_find_mutex);
 
-        h->device_addrs_cpp = uhd::device::find(std::string(args), uhd::device::CLOCK);
-        *num_found = h->device_addrs_cpp.size();
+        uhd::device_addrs_t devs = uhd::device::find(std::string(args), uhd::device::CLOCK);
+        devices_out->string_vector_cpp.clear();
+        BOOST_FOREACH(const uhd::device_addr_t &dev, devs){
+            devices_out->string_vector_cpp.push_back(dev.to_string());
+        }
     )
 }
 
@@ -155,35 +157,20 @@ uhd_error uhd_usrp_clock_get_sensor(
     uhd_usrp_clock_handle h,
     const char* name,
     size_t board,
-    uhd_sensor_value_handle sensor_value_out
+    uhd_sensor_value_handle *sensor_value_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        delete sensor_value_out->sensor_value_cpp;
-        sensor_value_out->sensor_value_cpp = new uhd::sensor_value_t(USRP_CLOCK(h)->get_sensor(name, board));
+        delete (*sensor_value_out)->sensor_value_cpp;
+        (*sensor_value_out)->sensor_value_cpp = new uhd::sensor_value_t(USRP_CLOCK(h)->get_sensor(name, board));
     )
 }
 
 uhd_error uhd_usrp_clock_get_sensor_names(
     uhd_usrp_clock_handle h,
     size_t board,
-    char* sensor_names_out,
-    size_t strbuffer_len,
-    size_t *num_sensors_out
+    uhd_string_vector_handle *sensor_names_out
 ){
     UHD_SAFE_C_SAVE_ERROR(h,
-        std::vector<std::string> sensor_names = USRP_CLOCK(h)->get_sensor_names(board);
-        *num_sensors_out = sensor_names.size();
-
-        std::string sensor_names_str = "";
-        BOOST_FOREACH(const std::string &sensor_name, sensor_names){
-            sensor_names_str += sensor_name;
-            sensor_names_str += ','; 
-        }
-        if(sensor_names.size() > 0){
-            sensor_names_str.resize(sensor_names_str.size()-1);
-        }
-
-        memset(sensor_names_out, '\0', strbuffer_len);
-        strncpy(sensor_names_out, sensor_names_str.c_str(), strbuffer_len);
-    )    
+        (*sensor_names_out)->string_vector_cpp = USRP_CLOCK(h)->get_sensor_names(board);
+    )
 }
diff --git a/host/lib/utils/paths.cpp b/host/lib/utils/paths.cpp
index ac4a010a7..eb9e69a49 100644
--- a/host/lib/utils/paths.cpp
+++ b/host/lib/utils/paths.cpp
@@ -261,7 +261,7 @@ std::string _get_images_path_from_registry(const std::string& registry_key_path)
 }
 #endif  /*UHD_PLATFORM_WIN32*/
 
-std::string uhd::get_images_dir(const std::string search_paths) {
+std::string uhd::get_images_dir(const std::string &search_paths) {
 
     /*   This function will check for the existence of directories in this
      *   order:
@@ -332,7 +332,7 @@ std::string uhd::get_images_dir(const std::string search_paths) {
     }
 }
 
-std::string uhd::find_image_path(const std::string &image_name, const std::string search_paths){
+std::string uhd::find_image_path(const std::string &image_name, const std::string &search_paths){
     /* If a path was provided on the command-line or as a hint from the caller,
      * we default to that. */
     if (fs::exists(image_name)){
@@ -364,7 +364,7 @@ std::string uhd::find_image_path(const std::string &image_name, const std::strin
             + uhd::print_utility_error("uhd_images_downloader.py"));
 }
 
-std::string uhd::find_utility(std::string name) {
+std::string uhd::find_utility(const std::string &name) {
     return fs::path(fs::path(uhd::get_pkg_path()) / UHD_LIB_DIR / "uhd" / "utils" / name)
         .string();
 }