A bunch of bug fixes

Author: fpagliughi

include/sockpp/canbus_frame.h

@@ -233,6 +233,7 @@ class canbusfd_frame : public ::canfd_frame
     canbusfd_frame(canid_t canID, const void* data, size_t n) : base{} {
         this->can_id = canID;
         if (data && n != 0) {
+            n = std::min(n, size_t(CANFD_MAX_DLEN));
             this->len = n;
             ::memcpy(&this->data, data, n);
         }
@@ -241,7 +242,7 @@ class canbusfd_frame : public ::canfd_frame
      * Construct an FD frame from a classic CAN 2.0 frame.
      * @param frame A classic CAN 2.0 frame.
      */
-    canbusfd_frame(const canbus_frame& frame) {
+    canbusfd_frame(const canbus_frame& frame) : base{} {
         // TODO: Should we reject RTR or error frames?
         std::memcpy(frame_ptr(), frame.frame_ptr(), sizeof(::can_frame));
     }

include/sockpp/canbus_socket.h

@@ -194,7 +194,9 @@ class canbus_socket : public raw_socket
      * @return @em true if the filters were set, @em false otherwise.
      */
     result<> set_filters(const can_filter* filters, size_t n) {
-        return set_option(SOL_CAN_RAW, CAN_RAW_FILTER, filters, socklen_t(n));
+        return set_option(
+            SOL_CAN_RAW, CAN_RAW_FILTER, filters, socklen_t(n * sizeof(can_filter))
+        );
     }
 
     /**

src/connector.cpp

@@ -85,8 +85,10 @@ result<> connector::connect(const sock_address& addr, microseconds timeout) {
         is_non_blocking();
 #endif
 
-    if (!non_blocking)
-        set_non_blocking(true);
+    if (!non_blocking) {
+        if (auto res = set_non_blocking(true); !res)
+            return res;
+    }
 
     auto res = check_res(::connect(handle(), addr.sockaddr_ptr(), addr.size()));
 

src/linux/canbus_frame.cpp

@@ -58,8 +58,10 @@ canbus_frame::canbus_frame(const canbusfd_frame& fdframe) {
 }
 
 canbus_frame::canbus_frame(const canbusfd_frame& fdframe, error_code& ec) {
-    if (fdframe.len > CAN_MAX_DLEN)
+    if (fdframe.len > CAN_MAX_DLEN) {
         ec = make_error_code(errc::invalid_argument);
+        return;
+    }
     ec = error_code{};
     std::memcpy(frame_ptr(), fdframe.frame_ptr(), SZ);
 }

src/linux/canbus_socket.cpp

@@ -85,5 +85,12 @@ result<canbus_frame> canbus_socket::recv(int flags /*=0*/) {
     return frame;
 }
 
+result<canbusfd_frame> canbus_socket::recv_fd(int flags /*=0*/) {
+    canbusfd_frame frame;
+    if (auto res = recv(&frame, flags); !res)
+        return res.error();
+    return frame;
+}
+
 /////////////////////////////////////////////////////////////////////////////
 }  // namespace sockpp

src/stream_socket.cpp

@@ -79,10 +79,14 @@ result<size_t> stream_socket::read_n(void* buf, size_t n) {
 
     while (nx < n) {
         auto res = read(b + nx, n - nx);
-        if (!res && res != errc::interrupted)
+        if (!res) {
+            if (res == errc::interrupted)
+                continue;
             return res.error();
-
-        nx += size_t(res.value());
+        }
+        if (res.value() == 0)
+            break;  // EOF: peer closed connection
+        nx += res.value();
     }
 
     return nx;
@@ -144,9 +148,14 @@ result<size_t> stream_socket::write_n(const void* buf, size_t n) {
 
     while (nx < n) {
         auto res = write(b + nx, n - nx);
-        if (!res && res != errc::interrupted)
+        if (!res) {
+            if (res == errc::interrupted)
+                continue;
             return res.error();
-        nx += size_t(res.value());
+        }
+        if (res.value() == 0)
+            break;
+        nx += res.value();
     }
 
     return nx;

tests/unit/test_canbus_frame.cpp

@@ -54,8 +54,19 @@ static const string IFACE{"vcan0"};
 
 // --------------------------------------------------------------------------
 
+TEST_CASE("canbus_frame construction", "[can]") {
+    SECTION("canbus_frame default constructor") {
+        canbus_frame frame{};
+        REQUIRE(frame.id_value() == 0);
+        REQUIRE(!frame.has_extended_id());
+        REQUIRE(!frame.is_remote());
+        REQUIRE(!frame.is_error());
+        REQUIRE(frame.len == 0);
+    }
+}
+
 TEST_CASE("canbus_frame conversions", "[can]") {
-    SECTION("standard to FD frames") {
+    SECTION("classic to FD frames") {
         canbus_frame frame{0x42, "hello"s};
 
         canbusfd_frame fdframe{frame};