Include cleaning

[apps/agl-service-can-low-level.git] / src / can / can-bus-dev.cpp

diff --git a/src/can/can-bus-dev.cpp b/src/can/can-bus-dev.cpp
index f459567..85bed4a 100644 (file)
--- a/src/can/can-bus-dev.cpp
+++ b/src/can/can-bus-dev.cpp
@@ -16,30 +16,38 @@
 * limitations under the License.
 */
 
-
-
+#include <map>
+#include <mutex>
+#include <unistd.h>
 #include <string.h>
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <linux/can/raw.h>
 
-#include <mutex>
-
 #include "can-bus-dev.hpp"
 
 #include "can-bus.hpp"
 #include "can-message.hpp"
-#include "low-can-binding.hpp"
+#include "../low-can-binding.hpp"
 
 /// @brief Class constructor
 /// @param dev_name String representing the device name into the linux /dev tree
-can_bus_dev_t::can_bus_dev_t(const std::string& dev_name)
-       : device_name_{dev_name}
+can_bus_dev_t::can_bus_dev_t(const std::string& dev_name, int32_t address)
+       : device_name_{dev_name}, address_{address}
+{}
+
+std::string can_bus_dev_t::get_device_name() const
+{
+       return device_name_;
+}
+
+uint32_t can_bus_dev_t::get_address() const
 {
+       return address_;
 }
 
 /// @brief Open the can socket and returning it
-/// @return -1
+/// @return -1 if something wrong.
 int can_bus_dev_t::open()
 {
        const int canfd_on = 1;
@@ -48,7 +56,8 @@ int can_bus_dev_t::open()
        struct timeval timeout;
 
        DEBUG(binder_interface, "CAN Handler socket : %d", can_socket_.socket());
-       if (can_socket_) return 0;
+       if (can_socket_)
+               return 0;
 
        can_socket_.open(PF_CAN, SOCK_RAW, CAN_RAW);
        if (can_socket_)
@@ -95,26 +104,26 @@ int can_bus_dev_t::open()
                }
                close();
        }
-       else ERROR(binder_interface, "socket could not be created. Error was : %s", ::strerror(errno));
+       else ERROR(binder_interface, "open: socket could not be created. Error was : %s", ::strerror(errno));
        return -1;
 }
 
 /// @brief Close the bus.
-void can_bus_dev_t::close()
+int can_bus_dev_t::close()
 {
-       can_socket_.close();
+       return can_socket_.close();
 }
 
 /// @brief Read the can socket and retrieve canfd_frame
-std::pair<struct canfd_frame&, size_t> can_bus_dev_t::read()
+can_message_t can_bus_dev_t::read()
 {
        ssize_t nbytes;
        struct canfd_frame cfd;
 
        // Test that socket is really opened
-       if (can_socket_)
+       if (!can_socket_)
        {
-               ERROR(binder_interface, "read_can: Socket unavailable. Closing thread.");
+               ERROR(binder_interface, "read: Socket unavailable. Closing thread.");
                is_running_ = false;
        }
 
@@ -168,14 +177,14 @@ void can_bus_dev_t::can_reader(can_bus_t& can_bus)
 
 /// @brief Send a can message from a can_message_t object.
 /// @param[in] can_msg the can message object to send
-int can_bus_dev_t::send_can_message(can_message_t& can_msg)
+int can_bus_dev_t::send(can_message_t& can_msg)
 {
        ssize_t nbytes;
        canfd_frame f;
 
        f = can_msg.convert_to_canfd_frame();
 
-       if(can_socket_.socket())
+       if(can_socket_)
        {
                nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0,
                        (struct sockaddr*)&txAddress_, sizeof(txAddress_));
@@ -194,10 +203,15 @@ int can_bus_dev_t::send_can_message(can_message_t& can_msg)
        return 0;
 }
 
-/// @brief Send a can message from a can_message_t object.
-/// @param[in] can bus used to send the message
-/// @param[in] can_msg the can message object to send
-bool can_bus_dev_t::send_can_message(const uint16_t arbitration_id, const uint8_t* data, const uint8_t size)
+/// @brief Static method used to send diagnostic CAN message
+/// that follow isotp SendShimsMessage signature. This method is launched
+/// from diagnostic manager's' same name method. It will use the diagnostic
+/// manager configured CAN bus device to send the CAN message.
+///
+/// @param[in] arbitration_id - CAN arbitration id.
+/// @param[in] data - CAN message payload to send
+/// @param[in] size - size of the data to send
+bool can_bus_dev_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size)
 {
        ssize_t nbytes;
        canfd_frame f;
@@ -206,9 +220,9 @@ bool can_bus_dev_t::send_can_message(const uint16_t arbitration_id, const uint8_
        f.len = size;
        ::memcpy(f.data, data, size);
 
-       if(socket.socket())
+       if(can_socket_)
        {
-               nbytes = ::sendto(socket.socket(), &f, sizeof(struct canfd_frame), 0,
+               nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0,
                        (struct sockaddr*)&txAddress_, sizeof(txAddress_));
                if (nbytes == -1)
                {