CANRawSocket.cpp

#include "CANRawSocket.h"
#include "TempFailure.h"
 
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <poll.h>
 
using namespace NET;
 
CANRawSocket::CANRawSocket()
: CANSocket( SOCK_RAW, CAN_RAW)
{}
 
void CANRawSocket::send( const ::can_frame& frame)
{
    SimpleSocket::send( &frame, sizeof(frame));
}
 
int CANRawSocket::receive( ::can_frame& frame)
{
    return SimpleSocket::receive( &frame, sizeof(frame));
}
 
int CANRawSocket::timedReceive( ::can_frame& frame, int timeout)
{
    return SimpleSocket::timedReceive( &frame, sizeof(frame), timeout);
}
 
void CANRawSocket::sendTo( const ::can_frame& frame, std::string_view interface)
{
    sockaddr_can destAddr;
    destAddr.can_family = AF_CAN;
    destAddr.can_ifindex = getInterfaceIndex(interface);
 
    int sent = TEMP_FAILURE_RETRY (::sendto( m_socket, (const raw_type*)&frame, sizeof(frame), 0, (sockaddr*)&destAddr, sizeof(destAddr)));
 
    // Write out the whole buffer as a single message
    if( sent != sizeof(frame))
        throw SocketException("Send failed (sendto)");
}
 
int CANRawSocket::receiveFrom( ::can_frame& frame, std::string& interface)
{
    sockaddr_can clientAddr;
    socklen_t addrLen = sizeof(clientAddr);
 
    int ret = TEMP_FAILURE_RETRY (::recvfrom( m_socket, (raw_type*)&frame, sizeof(frame), 0, (sockaddr*)&clientAddr, &addrLen));
    if( ret < 0)
        throw SocketException("Receive failed (recvfrom)");
 
    interface = getInterfaceName(clientAddr);
    return ret;
}
 
int CANRawSocket::timedReceiveFrom( ::can_frame& frame, std::string& interface, int timeout)
{
    struct pollfd poll;
    poll.fd = m_socket;
    poll.events = POLLIN | POLLPRI | POLLRDHUP;
 
    int ret = TEMP_FAILURE_RETRY (::poll( &poll, 1, timeout));
 
    if( ret == 0) return 0;
    if( ret < 0)  throw SocketException("timedReceive failed (poll)");
 
    if( poll.revents & POLLRDHUP || poll.revents & POLLHUP)
        m_peerDisconnected = true;
 
    if( poll.revents & POLLIN || poll.revents & POLLPRI)
        return receiveFrom( frame, interface);
 
    if( poll.revents & (POLLERR | POLLNVAL))
        throw SocketException("timedReceive failed (poll)");
 
    return 0;
}
 
void CANRawSocket::setReceiveFilter( const ::can_filter* filter, size_t len)
{
    if( ::setsockopt( m_socket, SOL_CAN_RAW, CAN_RAW_FILTER, filter, sizeof(::can_filter) * len) < 0)
        throw SocketException("Set receive filter failed (setsockopt)");
}
 
void CANRawSocket::setErrorFilter( ::can_err_mask_t filter)
{
    if( ::setsockopt( m_socket, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &filter, sizeof(::can_err_mask_t)) < 0)
        throw SocketException("Set error filter failed (setsockopt)");
}
 
void CANRawSocket::setLocalLoopback( bool enable)
{
    const int value = enable;
    if( ::setsockopt( m_socket, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &value, sizeof(value)) < 0)
        throw SocketException("Set local loopback failed (setsockopt)");
}
 
void CANRawSocket::setReceiveOwnMessages( bool enable)
{
    const int value = enable;
    if( ::setsockopt( m_socket, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, &value, sizeof(value)) < 0)
        throw SocketException("Set receive own messages failed (setsockopt)");
}