blob: b08f25322f79f55096038aae2ac3e766d5473682 [file] [log] [blame]
/******************************************************************************
* Copyright (c) 2000-2019 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
*
* Contributors:
* Michael Josenhans
******************************************************************************/
//
// File: SocketCAN_PT.cc
// Description: SocketCAN_PT test port source
//
// Revision R2D
#include "SocketCAN_PT.hh"
#include "SocketCAN_PortType.hh"
#include <Addfunc.hh>
#include <Bitstring.hh>
#include <Charstring.hh>
#include <errno.h>
#include <Error.hh>
#include <Hexstring.hh>
#include <Integer.hh>
#include <linux/can/bcm.h>
#include <linux/can/raw.h>
#include <linux/if.h>
#include <Logger.hh>
#include <memory.h>
#include <Octetstring.hh>
#include <Optional.hh>
#include <Port.hh>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <Template.hh>
#include <unistd.h>
#include <algorithm>
#include <cerrno>
#include <cstdarg>
#include <cstddef>
#include <cstring>
#include <iostream>
struct bcm_msg_head;
struct can_frame;
struct canfd_frame;
#define DEFAULT_NUM_SOCK 10
#define BCM_FRAME_BUFFER_SIZE 256
#define BCM_FRAME_FLAGS_SIZE 32 // size of SocketCAN_bcm_frame in Bit
#define ISOTP_RECIEVE_BUFSIZE 5000
// workaround, as some of those below may not yet be defined in "linux/can/raw.h":
#define CAN_RAW_FILTER 1 /* set 0 .. n can_filter(s) */
#define CAN_RAW_ERR_FILTER 2 /* set filter for error frames */
#define CAN_RAW_LOOPBACK 3 /* local loopback (default:on) */
#define CAN_RAW_RECV_OWN_MSGS 4 /* receive my own msgs (default:off) */
#define CAN_RAW_FD_FRAMES 5 /* allow CAN FD frames (default:off) */
#define CAN_RAW_JOIN_FILTERS 6 /* all filters must match to trigger */
// workaround, as not yet defined in all versions of "linux/Can.h":
#ifndef CAN_MAX_DLEN
#define CAN_MAX_DLEN 8
#endif
// workaround, as not defined in some older kernel versions
#ifndef CAN_MTU
#define CAN_MTU (sizeof(struct can_frame))
#endif //CAN_MTU
// comment out the following define, if your kernel does not have CANFD support
#define CANFD_SUPPORT
#ifdef CANFD_SUPPORT
// make sure CANFD_MTU is defined, as not defined in some older kernel versions.
#ifndef CANFD_MTU
#define CANFD_MTU (sizeof(struct canfd_frame))
#endif //CANFD_MTU
// make sure CAN_FD_FRAME is defined, as not defined in some older kernel versions
// and thus canfd frames can not be used for data transfer between
// kernel module and userspace
#ifndef CAN_FD_FRAME
#define CAN_FD_FRAME 0x0800
#endif //CAN_FD_FRAME
#define CANFD_FRAME_STRUCT_DEFINED
#define RAW_CANFD_SUPPORT
#define BCM_CANFD_SUPPORT
#endif //CANFD_SUPPORT
namespace SocketCAN__PortType {
SocketCAN__PT_PROVIDER::SocketCAN__PT_PROVIDER(const char *par_port_name) :
PORT(par_port_name), num_of_sock(0), sock_list_length(0), target_fd(-1), can_interface_name(
NULL), debugging(false), debugging_configured(false), config_finished(
false) {
sock_list = NULL;
//&num_of_sock = 0;
//sock_list_length = 0;
}
SocketCAN__PT_PROVIDER::~SocketCAN__PT_PROVIDER() {
Free(sock_list);
reset_configuration();
}
void SocketCAN__PT_PROVIDER::set_parameter(const char * parameter_name,
const char * parameter_value) {
log("entering SocketCAN__PT_PROVIDER::set_parameter(%s, %s)",
parameter_name, parameter_value);
if (config_finished) {
reset_configuration();
config_finished = false;
}
if (strcmp(parameter_name, "SocketCAN_can_interface_name") == 0) {
InitStrPar(can_interface_name, parameter_name, parameter_value);
} else if (strcmp(parameter_name, "SocketCAN_debugging") == 0) {
if (strcmp(parameter_value, "YES") == 0) {
debugging = true;
debugging_configured = true;
log("Reading testport parameter debugging: ", debugging);
} else if (strcmp(parameter_value, "NO") == 0) {
debugging = false;
debugging_configured = true;
log("Reading testport parameter debugging: ", debugging);
}
} else {
TTCN_error(
"SocketCAN parameter configuration error: Configuration file does not correctly configure parameter 'SocketCAN_debugging' however parameter name '%s' as parameter value: '%s'!!\nExpecting: \n*.*.SocketCAN_debugging := \"YES\"\n or \n*.*.SocketCAN_debugging := \"NO\"",
parameter_name, parameter_value);
}
log("leaving SocketCAN__PT_PROVIDER::set_parameter(%s, %s)", parameter_name,
parameter_value);
}
/*void SocketCAN__PT_PROVIDER::Handle_Fd_Event(int fd, boolean is_readable,
boolean is_writable, boolean is_error) {}*/
void SocketCAN__PT_PROVIDER::Handle_Fd_Event_Error(int /*fd*/) {
}
void SocketCAN__PT_PROVIDER::Handle_Fd_Event_Writable(int /*fd*/) {
}
void SocketCAN__PT_PROVIDER::Handle_Fd_Event_Readable(int sock) {
log("entering SocketCAN__PT_PROVIDER::Handle_Fd_Event_Readable()");
int res;
for (int a = 0; a < sock_list_length; a++) {
if ((sock == sock_list[a].fd)
and (sock_list[a].status != SOCKET_NOT_ALLOCATED)) {
switch (sock_list[a].protocol_family) {
case SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_ISOTP: {
SocketCAN__Types::SocketCAN__receive__isotp__pdu parameters;
unsigned char msg[ISOTP_RECIEVE_BUFSIZE];
int nbytes = 0;
struct sockaddr_can addr;
socklen_t addr_len = sizeof(addr);
//ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
// struct sockaddr *src_addr, socklen_t *addrlen);
nbytes = recvfrom(sock, msg, ISOTP_RECIEVE_BUFSIZE, 0,
(struct sockaddr*) &addr, &addr_len);
//nbytes = read(sock, msg, ISOTP_RECIEVE_BUFSIZE);
if (nbytes > 0 && nbytes < ISOTP_RECIEVE_BUFSIZE) {
struct ifreq ifr;
ifr.ifr_ifindex = addr.can_ifindex;
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() = ifr.ifr_name;
parameters.id() = a;
parameters.pdu() = OCTETSTRING(nbytes, msg);
incoming_message(parameters);
}
}
break;
case SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_RAW: {
SocketCAN__Types::SocketCAN__receive__CAN__or__CAN__FD__frame parameters;
struct sockaddr_can addr;
socklen_t addr_len = sizeof(addr);
//ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
// struct sockaddr *src_addr, socklen_t *addrlen);
#ifdef CANFD_FRAME_STRUCT_DEFINED // struct canfd_frame is supported
struct canfd_frame frame; // always assume a CANFD_Frame shall be received
ssize_t nbytes = recvfrom(sock, &frame, CANFD_MTU, 0,
(struct sockaddr*) &addr, &addr_len);
#else //CANFD_FRAME_STRUCT_DEFINED
struct can_frame frame; // CANFD_Frame is not supported by this kernel version
ssize_t nbytes = recvfrom(sock, &frame, CAN_MTU, 0,
(struct sockaddr*) &addr, &addr_len);
#endif //CANFD_FRAME_STRUCT_DEFINED
if (nbytes <= 0) {
//there is an empty message, or error in receive
//remove the socket
TTCN_error(
"Closing socket %d with interface index %d due to an empty message or error in reception\n",
sock, addr.can_ifindex);
std::cout << "close_fd" << sock << std::endl;
sock_list[a].status = SOCKET_NOT_ALLOCATED;
sock_list[a].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL;
num_of_sock--;
Handler_Remove_Fd_Read(sock);
close(sock);
} else
if ((nbytes == CAN_MTU)
#ifdef CANFD_FRAME_STRUCT_DEFINED
or (nbytes == CANFD_MTU)
#endif //CANFD_FRAME_STRUCT_DEFINED
) {
// A CAN Frame has been received. However use the struct canfd_frame to access it.
// As it is a CAN frame, the flags field contains invalid data and the can_dlc field
// is here called len as in CAN FD.
struct ifreq ifr;
ifr.ifr_ifindex = addr.can_ifindex;
/* get interface name of the received CAN frame */
res = ioctl(sock, SIOCGIFNAME, &ifr);
if (res != 0) {
TTCN_error(
"SocketCAN frame reception: Ioctl failed while retrieving the interface name from the socket: %d with interface index %d\n",
sock, ifr.ifr_ifindex);
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() =
"SocketCAN : device name unknown, ioctl failed";
} else {
#ifdef CANFD_FRAME_STRUCT_DEFINED
if (nbytes == CANFD_MTU) {
log(
"SocketCAN: Received a CANFD frame from interface %s",
ifr.ifr_name, nbytes, frame.len);
} else {
log(
"SocketCAN: Received a CAN frame from interface %s",
ifr.ifr_name, nbytes, frame.len);
}
#else //CANFD_FRAME_STRUCT_DEFINED
log("SocketCAN: Received a CAN frame from interface %s",
ifr.ifr_name, nbytes, frame.can_dlc);
#endif //CANFD_FRAME_STRUCT_DEFINED
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() = ifr.ifr_name;
}
struct timeval tv;
res = ioctl(sock, SIOCGSTAMP, &tv);
if (res != 0) {
TTCN_error(
"SocketCAN frame reception: Ioctl failed while retrieving the timestamp from the socket: %d with interface name %s\n",
sock, ifr.ifr_name);
} else {
parameters.timestamp().tv__sec() = tv.tv_sec;
parameters.timestamp().tv__usec() = tv.tv_usec;
}
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() = ifr.ifr_name;
parameters.id() = a;
INTEGER can_id;
can_id.set_long_long_val(frame.can_id);
#ifdef CANFD_FRAME_STRUCT_DEFINED
const INTEGER len = frame.len;
#else //CANFD_FRAME_STRUCT_DEFINED
const INTEGER len = frame.can_dlc;
#endif //CANFD_FRAME_STRUCT_DEFINED
// frame type specific part:
if (nbytes == CAN_MTU) {
// CAN frame received:
Can::CAN__frame& frameref =
parameters.frame().can__frame();
log(
"Received a CAN frame from interface %s of %d bytes and with payload length %d",
ifr.ifr_name, nbytes, (int) len);
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() = ifr.ifr_name;
parameters.id() = a;
frameref.can__id() = int2oct(can_id, 4);
frameref.can__pdu() = OCTETSTRING(len, frame.data);
} else {
// CAN FD frame received:
Can::CANFD__frame& frameref =
parameters.frame().canfd__frame();
log(
"Received a CAN FD frame from interface %s of %d bytes and with payload length %d",
ifr.ifr_name, nbytes, (int) len);
frameref.can__id() = int2oct(can_id, 4);
#ifdef CANFD_FRAME_STRUCT_DEFINED
if (nbytes == CANFD_MTU) {
frameref.can__flags() = BITSTRING(
int2bit(frame.flags, 8));
}
#endif //CANFD_FRAME_STRUCT_DEFINED
frameref.can__pdu() = OCTETSTRING(len, frame.data);
}
incoming_message(parameters);
}
}
break;
case SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_BCM: {
SocketCAN__Types::SocketCAN__receive__BCM__message parameters;
struct sockaddr_can addr;
struct {
struct bcm_msg_head msg_head;
#ifdef CANFD_FRAME_STRUCT_DEFINED
struct canfd_frame frame[BCM_FRAME_BUFFER_SIZE];
#else //CANFD_FRAME_STRUCT_DEFINED
struct can_frame frame[BCM_FRAME_BUFFER_SIZE];
#endif //CANFD_FRAME_STRUCT_DEFINED
} bcm_msg;
struct ifreq ifr;
socklen_t addr_len = sizeof(addr);
ssize_t nbytes = recvfrom(sock, &bcm_msg,
sizeof(struct can_frame), 0, (struct sockaddr*) &addr,
&addr_len);
if (nbytes < 0) {
//there is an empty message, or error in receive
//remove the socket
TTCN_error(
"Closing socket %d with interface index %d due to an empty BCM message or error in reception\n",
sock, addr.can_ifindex);
std::cout << "close_fd" << sock << std::endl;
sock_list[a].status = SOCKET_NOT_ALLOCATED;
sock_list[a].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL;
num_of_sock--;
Handler_Remove_Fd_Read(sock);
close(sock);
} else {
ifr.ifr_ifindex = addr.can_ifindex;
// get interface name of the received CAN frame
// currently handling of can_ifindex == 0 (= any interface) is unclear.
// res = ioctl(sock, SIOCGIFNAME, &ifr);
// if (res == -1) {
// TTCN_error(
// "Ioctl failed while receiving a BCM message frame on socket: %d with interface index %d with errno: %d\n",
// sock, ifr.ifr_ifindex, errno);
// }
const INTEGER msg_head_flags = bcm_msg.msg_head.flags;
log(
"Received a BCM message from interface index %d of bytes %d",
ifr.ifr_ifindex, nbytes);
parameters.id() = bcm_msg.msg_head.can_id;
parameters.ifr().if__index() = ifr.ifr_ifindex;
parameters.ifr().if__name() = ifr.ifr_name;
uint32_t nframes = bcm_msg.msg_head.nframes;
INTEGER opcode;
opcode.set_long_long_val(bcm_msg.msg_head.opcode);
parameters.frame().opcode() = int2oct(opcode, 4);
parameters.frame().flags() = BITSTRING(
int2bit(INTEGER(msg_head_flags),
BCM_FRAME_FLAGS_SIZE));
parameters.frame().count() = bcm_msg.msg_head.count;
parameters.frame().ival1().tv__sec() =
bcm_msg.msg_head.ival1.tv_sec;
parameters.frame().ival1().tv__usec() =
bcm_msg.msg_head.ival1.tv_usec;
parameters.frame().ival2().tv__sec() =
bcm_msg.msg_head.ival2.tv_sec;
parameters.frame().ival2().tv__usec() =
bcm_msg.msg_head.ival2.tv_usec;
INTEGER bcm_head_can_id;
bcm_head_can_id.set_long_long_val(bcm_msg.msg_head.can_id);
parameters.frame().can__id() = int2oct(bcm_head_can_id, 4);
#ifdef BCM_CANFD_SUPPORT
long flags = bcm_msg.msg_head.flags;
if ((flags & CAN_FD_FRAME ) == CAN_FD_FRAME ) {
// Handle CAN FD frames
parameters.frame().frames().can__frame().set_size(nframes);
for (uint32_t i = 0; i < nframes; i++) {
INTEGER len;
len = bcm_msg.frame[i].len;
if (len > CANFD_MAX_DLEN) {
TTCN_error("Writing data: CAN FD pdu size too large\n");
};
INTEGER can_id;
can_id.set_long_long_val(bcm_msg.frame[i].can_id);
parameters.frame().frames().canfd__frame()[i].can__id() = int2oct(can_id, 4);
//Here the bitstring shall be stored into a
parameters.frame().frames().canfd__frame()[i].can__flags() =
BITSTRING(32,
(const unsigned char*) &(bcm_msg.frame[i].flags));
parameters.frame().frames().canfd__frame()[i].can__pdu() =
OCTETSTRING(len,
(const unsigned char*) &(bcm_msg.frame[i].data));
}
incoming_message(parameters);
}
else
#endif //BCM_CANFD_SUPPORT
{
parameters.frame().frames().can__frame().set_size(
nframes);
for (uint32_t i = 0; i < nframes; i++) {
INTEGER len;
#ifdef CANFD_FRAME_STRUCT_DEFINED // struct canfd_frame is supported
len = bcm_msg.frame[i].len;
#else //CANFD_FRAME_STRUCT_DEFINED // struct canfd_frame is supported
len = bcm_msg.frame[i].can_dlc;
#endif //CANFD_FRAME_STRUCT_DEFINED // struct canfd_frame is supported
// Handle legacy CAN frames
if (len > CAN_MAX_DLEN) {
TTCN_error(
"Writing data: CAN pdu size too large\n");
len = CAN_MAX_DLEN;
};
INTEGER can_id;
can_id.set_long_long_val(bcm_msg.frame[i].can_id);
parameters.frame().frames().can__frame()[i].can__id() =
int2oct(can_id, 4);
parameters.frame().frames().can__frame()[i].can__pdu() =
OCTETSTRING(len,
(const unsigned char*) &(bcm_msg.frame[i].data));
}
incoming_message(parameters);
}
}
}
break;
default: {
TTCN_error(
"SocketCAN Handle_Fd_Event_Readable (%d): unhandled protocol configured",
sock);
}
break;
}
}
}
log("leaving SocketCAN__PT_PROVIDER::Handle_Fd_Event_Readable()");
}
void SocketCAN__PT_PROVIDER::user_map(const char */*system_port */) {
log("entering SocketCAN__PT_PROVIDER::user_map()");
config_finished = true;
if (debugging_configured == false) {
// The debugging mode has not been defined in TTCN configuration file.
TTCN_error(
"Missing mandatory parameter: SocketCAN_debuhhing for can_interface_name %s \n",
can_interface_name);
}
if (sock_list != NULL)
TTCN_error("SocketCAN Test Port (%s): Internal error: "
"sock_list is not NULL when mapping.", port_name);
sock_list = (sock_data*) Malloc(DEFAULT_NUM_SOCK * sizeof(*sock_list));
num_of_sock = 0;
sock_list_length = DEFAULT_NUM_SOCK;
for (int a = 0; a < sock_list_length; a++) {
sock_list[a].fd = 0;
sock_list[a].status = SOCKET_NOT_ALLOCATED;
sock_list[a].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL;
}
log("leaving SocketCAN__PT_PROVIDER::user_map()");
}
void SocketCAN__PT_PROVIDER::user_unmap(const char * /*system_port*/) {
log("entering SocketCAN__PT_PROVIDER::user_unmap()");
closeDownSocket();
log("leaving SocketCAN__PT_PROVIDER::user_unmap()");
}
void SocketCAN__PT_PROVIDER::user_start() {
}
void SocketCAN__PT_PROVIDER::user_stop() {
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__socket& send_par) {
log("entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__socket)");
int cn;
SocketCAN__Types::SocketCAN__socket__result result;
if (num_of_sock < sock_list_length) {
cn = 0;
while (sock_list[cn].status == SOCKET_OPEN) {
cn++;
}
} else {
sock_list = (sock_data*) Realloc(sock_list,
2 * sock_list_length * sizeof(*sock_list));
for (int a = sock_list_length; a < sock_list_length * 2; a++) {
sock_list[a].status = SOCKET_NOT_ALLOCATED;
}
cn = sock_list_length;
sock_list_length *= 2;
}
//extern int socket (int __domain, int __type, int __protocol) __THROW;
target_fd = socket(send_par.domain(), send_par.ptype(),
send_par.protocol());
if (target_fd <= 0) {
TTCN_error("Cannot open socket \n");
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "Cannot open socket";
} else {
log("SocketCAN opened socket %d \n", target_fd);
sock_list[cn].fd = target_fd;
sock_list[cn].status = SOCKET_OPEN;
num_of_sock++;
//Handler_Add_Fd_Read(target_fd);
result.id() = cn;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
incoming_message(result);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__socket)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__ioctl& send_par) {
log("entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__ioctl)");
struct ifreq ifr;
int sock;
int cn = send_par.id();
int res;
SocketCAN__Types::SocketCAN__ioctl__result result;
if ((cn < sock_list_length) and (sock_list[cn].status == SOCKET_OPEN)) {
sock = sock_list[cn].fd;
if (send_par.ifu().is_present()) {
const OPTIONAL<SocketCAN__Types::SocketCAN__ioctl__ifu>& ifu =
send_par.ifu();
switch (ifu().get_selection()) {
case SocketCAN__Types::SocketCAN__ioctl__ifu::ALT_if__name:
strcpy(ifr.ifr_name, ifu().if__name());
res = ioctl(sock, SIOCGIFINDEX, &ifr);
if (res != 0) {
TTCN_error(
"Ioctl failed on socket: %d with interface name %s\n",
sock, (const char *) ifu().if__name());
result.ifr().if__name() = ifu().if__name();
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "Ioctl failed";
} else {
log("SocketCAN ioctl successful on socket %d \n", sock);
result.ifr().if__name() = ifu().if__name();
result.ifr().if__index() = ifr.ifr_ifindex;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
break;
case SocketCAN__Types::SocketCAN__ioctl__ifu::ALT_if__index:
res = ioctl(sock, SIOCGIFNAME, &ifr);
if (res != 0) {
TTCN_error(
"Ioctl failed on socket: %d with interface index %llu \n",
sock, ifu().if__index().get_long_long_val());
result.ifr().if__index() = ifr.ifr_ifindex;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "Ioctl failed";
} else {
log("SocketCAN ioctl successful on socket %d \n", sock);
result.ifr().if__name() = ifr.ifr_name;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
break;
default:
TTCN_error("Ioctl failed due to unknown union selection");
break;
}
} else {
// optional ifu filed is not present, set take interface name from applicable TTCN configuration file
if (can_interface_name == NULL) {
TTCN_error(
"Missing mandatory parameter: \"SocketCAN_can_interface_name\" has not been defined in function call to Send Data nor in test configuration file! ");
} else {
strcpy(ifr.ifr_name, can_interface_name);
res = ioctl(sock, SIOCGIFINDEX, &ifr);
if (res != 0) {
TTCN_error(
"Ioctl failed on socket: %d with interface name %s \n",
sock, can_interface_name);
result.ifr().if__index() = ifr.ifr_ifindex;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "Ioctl failed";
} else {
log("SocketCAN ioctl successful on socket %d \n", sock);
result.ifr().if__name() = ifr.ifr_name;
result.ifr().if__index() = ifr.ifr_ifindex;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
if (strlen(can_interface_name) <= IFNAMSIZ) {
std::strcpy(ifr.ifr_name, can_interface_name);
} else {
TTCN_error(
"Ioctl failed due to interface name too long.\n");
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"Ioctl failed due to interface name too long";
}
}
}
} else {
TTCN_error("Ioctl failed due to unknown socket reference: %d \n", cn);
result.ifr().if__name() = ifr.ifr_name;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"Ioctl failed due to unknown socket reference";
}
incoming_message(result);
log("SocketCAN__PT::outgoing_send(SocketCAN__ioctl)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__connect& send_par) {
//Client connects to BCM
log("entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__connect)");
int sock;
struct sockaddr_can addr = { };
int cn = send_par.id();
int res;
SocketCAN__Types::SocketCAN__connect__result result;
if ((cn < sock_list_length) and (sock_list[cn].status == SOCKET_OPEN)) {
if (sock_list[cn].protocol_family
== SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL) {
sock = sock_list[cn].fd;
addr.can_family = AF_CAN;
SocketCAN__Types::SocketCAN__connectu connectu =
send_par.connectu();
switch (connectu.get_selection()) {
case SocketCAN__Types::SocketCAN__connectu::ALT_bcm:
addr.can_ifindex = connectu.bcm().if__index();
sock_list[cn].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_BCM;
break;
default:
TTCN_error(
"connectu union selection does not exist on socket %d: \n",
sock);
break;
}
log("Connecting socket: %d with index: %d", sock, addr.can_ifindex);
//extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
res = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
if (res != 0) {
TTCN_error("Connecting to socket %d failed: \n", sock);
log("Connecting to socket %d failed", sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "Connecting to socket failed";
} else {
log("Connecting socket %d was successful", sock);
sock_list[cn].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_BCM;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
sock_list[cn].remote_Addr.can_family = AF_CAN;
Handler_Add_Fd_Read(target_fd);
}
} else {
TTCN_error("Socket reference already connected or bound: %d \n",
cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"Socket reference already connected or bound";
}
} else {
TTCN_error("Unknown socket reference: %d \n", cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() = "Unknown socket reference";
}
incoming_message(result);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__connect)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__bind& send_par) {
//Client binds
log("entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__bind)");
int sock;
struct sockaddr_can addr = { };
int cn = send_par.id();
int res;
SocketCAN__Types::SocketCAN__bind__result result;
if ((cn < sock_list_length) and (sock_list[cn].status == SOCKET_OPEN)) {
if (sock_list[cn].protocol_family
== SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL) {
int if_index;
SocketCAN__PortType::SocketCAN__PT_PROVIDER::socket_protocol_family_enum protocol_family;
sock = sock_list[cn].fd;
addr.can_family = AF_CAN;
SocketCAN__Types::SocketCAN__bindu bindu = send_par.bindu();
switch (bindu.get_selection()) {
case SocketCAN__Types::SocketCAN__bindu::ALT_raw: {
const int canfd_on = 1;
setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on,
sizeof(canfd_on));
if_index = bindu.raw().if__index();
protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_RAW;
}
break;
case SocketCAN__Types::SocketCAN__bindu::ALT_isotp:
if_index = bindu.isotp().if__index();
addr.can_addr.tp.rx_id = oct2int(bindu.isotp().rx__can__id());
addr.can_addr.tp.tx_id = oct2int(bindu.isotp().tx__can__id());
protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_ISOTP;
break;
default:
TTCN_error(
"bindu union selection does not exist on socket %d: \n",
sock);
break;
}
addr.can_ifindex = if_index;
log("Binding socket: %d with index: %d", sock, if_index);
res = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
if (res != 0) {
log("Binding to socket %d failed", sock);
TTCN_error("Binding to socket %d failed:\n", sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
} else {
log("Binding socket %d was successful", sock);
sock_list[cn].protocol_family = protocol_family;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
sock_list[cn].remote_Addr.can_family = AF_CAN;
Handler_Add_Fd_Read(target_fd);
}
} else {
TTCN_error("Socket reference already connected or bound: %d \n",
cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"Socket reference already connected or bound";
}
} else {
TTCN_error("Unknown socket reference: %d \n", cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() = "Unknown socket reference";
}
incoming_message(result);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__bind)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__send__data& send_par) {
log(
"entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__send__data)");
SocketCAN__Types::SocketCAN__send__data__result result;
int res = 0;
int sock;
int cn = send_par.id();
if ((cn < sock_list_length)) {
struct sockaddr_can addr;
struct ifreq ifr;
int nrOfBytesSent, nrOfBytestoSend;
sock = sock_list[cn].fd;
if (send_par.ifu().is_present()) {
const OPTIONAL<SocketCAN__Types::SocketCAN__send__data__ifu>& ifu =
send_par.ifu();
switch (ifu().get_selection()) {
case SocketCAN__Types::SocketCAN__send__data__ifu::ALT_if__index:
addr.can_ifindex = ifu().if__index();
addr.can_family = AF_CAN;
break;
case SocketCAN__Types::SocketCAN__send__data__ifu::ALT_if__name:
strcpy(ifr.ifr_name, ifu().if__name());
res = ioctl(sock, SIOCGIFINDEX, &ifr);
if (res != 0) {
TTCN_error(
"SocketCAN: Send CAN frame: Ioctl failed while retrieving the interface : %d with interface index %s\n",
sock, ifr.ifr_name);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN: Send CAN frame: Ioctl failed while retrieving the interface";
}
addr.can_ifindex = ifr.ifr_ifindex;
addr.can_family = AF_CAN;
break;
case SocketCAN__Types::SocketCAN__send__data__ifu::ALT_if__any:
addr.can_ifindex = 0;
addr.can_family = AF_CAN;
break;
default:
TTCN_error(
"SocketCAN: Send CAN frame: Unknown union selection");
res = -1;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN: Send CAN frame: Unknown union selection";
}
} else {
// optional ifu filed is not present, thus send to any interface:
addr.can_ifindex = 0;
addr.can_family = AF_CAN;
}
if (res == 0) { // check if previous interface inquiry step failed
switch (send_par.frame().get_selection()) {
case SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame::ALT_can__frame: {
struct can_frame frame;
log("SocketCAN: Sending CAN frame)");
logOctet(" to can id: ",
send_par.frame().can__frame().can__id());
logOctet("containing data: ",
send_par.frame().can__frame().can__pdu());
size_t can_dlc =
send_par.frame().can__frame().can__pdu().lengthof();
frame.can_id = oct2int(send_par.frame().can__frame().can__id());
memcpy(frame.data, send_par.frame().can__frame().can__pdu(),
can_dlc);
frame.can_dlc = can_dlc;
nrOfBytestoSend = sizeof(frame);
if (send_par.ifu().is_present()) {
nrOfBytesSent = sendto(sock, &frame, nrOfBytestoSend, 0,
(struct sockaddr*) &addr, sizeof(addr));
if (nrOfBytesSent < 0) {
log(
"SocketCAN: Sent CAN frame with sendto of size %d failed",
nrOfBytesSent);
TTCN_error(
"SocketCAN send with sendto() error while trying to send %d bytes",
nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN send with sendto() error";
} else {
log(
"SocketCAN send data with sendto() successful on socket %d \n",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
} else {
nrOfBytesSent = send(sock, &frame, nrOfBytestoSend, 0);
log("Sent CAN frame with send of size %d", nrOfBytesSent);
if (nrOfBytesSent < 0) {
log("Sent CAN frame with send of size %d failed",
nrOfBytesSent);
TTCN_error(
"SocketCAN send with send() error while trying to send CAN frame of %d bytes",
nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN send with send() error";
} else {
log(
"SocketCAN send data with send() successful on socket %d \n",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
}
break;
#ifdef RAW_CANFD_SUPPORT
case SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame::ALT_canfd__frame: {
{
// Enabling FD support had been successful!
log(
"SocketCAN: Enabling FD support had been successful on socket %d",
sock);
struct canfd_frame fd_frame;
log("SocketCAN: Sending CAN FD frame)");
logOctet(" to can id: ",
send_par.frame().canfd__frame().can__id());
logBitstring("with flags: ",
send_par.frame().canfd__frame().can__flags());
logOctet("containing data: ",
send_par.frame().canfd__frame().can__pdu());
size_t len =
send_par.frame().canfd__frame().can__pdu().lengthof();
fd_frame.can_id = oct2int(
send_par.frame().canfd__frame().can__id());
fd_frame.flags = bit2int(
send_par.frame().canfd__frame().can__flags());
memcpy(fd_frame.data,
send_par.frame().canfd__frame().can__pdu(), len);
fd_frame.len = len;
fd_frame.__res0 = 0x00;
fd_frame.__res1 = 0x00;
nrOfBytestoSend = sizeof(fd_frame);
if (send_par.ifu().is_present()) {
nrOfBytesSent = sendto(sock, &fd_frame, nrOfBytestoSend,
0, (struct sockaddr*) &addr, sizeof(addr));
if (nrOfBytesSent < 0) {
TTCN_error(
"SocketCAN FD send with sendto() error while trying to send %d bytes with error code: %d",
nrOfBytestoSend, nrOfBytesSent);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN FD send with sendto() error";
} else {
log(
"SocketCAN: Sent CAN FD frame with sendto() of size %d",
nrOfBytesSent);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
} else {
nrOfBytesSent = send(sock, &fd_frame, nrOfBytestoSend,
0);
if (nrOfBytesSent < 0) {
TTCN_error(
"SocketCAN FD send with send() error while trying to send %d bytes",
nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN FD send with send() error";
} else {
log(
"SocketCAN: Sent CAN FD frame with send() of size %d",
nrOfBytesSent);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
}
}
break;
#else // RAW_CANFD_SUPPORT
case SocketCAN__Types::SocketCAN__CAN__or__CAN__FD__frame::ALT_canfd__frame: {
TTCN_error(
"SocketCAN: CAN FD is not supported by your current kernel error");
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN: CAN FD is not supported by your current kernel error";
}
break;
#endif // RAW_CANFD_SUPPORT
default:
TTCN_error("SocketCAN send unknown frame type error");
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN send unknown frame type error";
break;
}
log("SocketCAN: Nr of bytes sent = %d", nrOfBytesSent);
if ((nrOfBytesSent > 0) and (nrOfBytesSent != nrOfBytestoSend)
and (nrOfBytestoSend != 0)) {
TTCN_error(
"Send system call failed: %d bytes were sent instead of %d",
nrOfBytesSent, nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write failed as wrong number of bytes have been written";
}
}
} else {
TTCN_error("SocketCAN: Unknown socket reference: %d \n", cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() = "Unknown socket reference";
}
incoming_message(result);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__send__data)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__write__data& send_par) {
log(
"entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__write__data)");
SocketCAN__Types::SocketCAN__write__data__result result;
int sock;
int cn = send_par.id();
if ((cn < sock_list_length)
and (sock_list[cn].protocol_family
== SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_BCM)
and (sock_list[cn].status == SOCKET_OPEN)) {
sock = sock_list[cn].fd;
switch (send_par.bcm__tx__msg().frames().get_selection()) {
case Bcm::SocketCAN__bcm__frame_frames::ALT_can__frame: {
int nrOfBytesSent = 0;
int nrOfBytestoSend = 0;
struct {
struct bcm_msg_head msg_head;
struct can_frame frame[BCM_FRAME_BUFFER_SIZE];
} bcm_msg = { };
const Bcm::SocketCAN__bcm__frame& bcm__tx__msg =
send_par.bcm__tx__msg();
int nframes = bcm__tx__msg.frames().can__frame().lengthof();
if (nframes > BCM_FRAME_BUFFER_SIZE) {
TTCN_error(
"SocketCAN: Writing data: number of CAN frames too large: %d \n",
nframes);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN sending CAN data with write() failed, as more than BCM_FRAME_BUFFER_SIZE number of CAN frames to be sent";
TTCN_error(
"SocketCAN sending CAN data with write() failed, as more than BCM_FRAME_BUFFER_SIZE number of CAN frames to be sent");
} else {
const Bcm::SocketCAN__bcm__frame& bcm__tx__msg =
send_par.bcm__tx__msg();
bcm_msg.msg_head.opcode = oct2int(bcm__tx__msg.opcode());
bcm_msg.msg_head.flags = bit2int(
send_par.bcm__tx__msg().flags());
bcm_msg.msg_head.count = bcm__tx__msg.count();
bcm_msg.msg_head.ival1.tv_sec = bcm__tx__msg.ival1().tv__sec();
bcm_msg.msg_head.ival1.tv_usec =
bcm__tx__msg.ival1().tv__usec();
bcm_msg.msg_head.ival2.tv_sec = bcm__tx__msg.ival2().tv__sec();
bcm_msg.msg_head.ival2.tv_usec =
bcm__tx__msg.ival2().tv__usec();
bcm_msg.msg_head.can_id = oct2int(bcm__tx__msg.can__id());
bcm_msg.msg_head.nframes = nframes;
log("SocketCAN: Sending BCM Message)");
logOctet(" opcode: ", bcm__tx__msg.opcode());
logBitstring(" flags: ", bcm__tx__msg.flags());
logInteger(" count: ", bcm__tx__msg.count());
logInteger(" ival1: ", bcm__tx__msg.ival1().tv__sec());
logInteger(" ival1: ", bcm__tx__msg.ival1().tv__usec());
logInteger(" ival2: ", bcm__tx__msg.ival2().tv__sec());
logInteger(" ival2: ", bcm__tx__msg.ival2().tv__usec());
logOctet(" can_id: ", bcm__tx__msg.can__id());
logInteger(" nframes: ", nframes);
for (int i = 0; i < nframes; i++) {
const Bcm::SocketCAN__bcm__frame_frames_can__frame& frame =
bcm__tx__msg.frames().can__frame();
bcm_msg.frame[i].can_id = oct2int(frame[i].can__id());
unsigned int can_dlc;
can_dlc = frame[i].can__pdu().lengthof();
if (can_dlc > CAN_MAX_DLEN) {
TTCN_error(
"SocketCAN writing data: CAN pdu size too large\n");
can_dlc = CAN_MAX_DLEN;
};
log(" containing CAN frame:)");
logOctet(" can id: ", frame[i].can__id());
logInteger(" can dlc: ", can_dlc);
bcm_msg.frame[i].can_dlc = can_dlc;
for (unsigned int j = 0; j < can_dlc; j++) {
bcm_msg.frame[i].data[j] = oct2int(
frame[i].can__pdu()[j]);
logOctet(" data: ", frame[i].can__pdu()[j]);
}
}
// assuming that the struct within the structure are aligned cm_msg without passing
// BCM_write does not calculate unused fields from nframes to BCM_FRAME_BUFFER_SIZE
nrOfBytestoSend = sizeof(struct bcm_msg_head)
+ nframes * sizeof(struct can_frame);
nrOfBytesSent = write(sock, &bcm_msg, (int) nrOfBytestoSend);
if ((nrOfBytesSent) < 0) {
int myerrno = errno;
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = myerrno;
result.result().err__text() =
"SocketCAN sending CAN data with write() failed";
logInteger("bcm_msg.msg_head.can_id: ",
(bcm_msg.msg_head.can_id));
logInteger("bcm_msg.msg_head.count: ",
bcm_msg.msg_head.count);
logInteger("bcm_msg.msg_head.flags: ",
bcm_msg.msg_head.flags);
logInteger("bcm_msg.msg_head.ival1.tv_sec: ",
bcm_msg.msg_head.ival1.tv_sec);
logInteger("bcm_msg.msg_head.ival1.tv_usec: ",
bcm_msg.msg_head.ival1.tv_usec);
logInteger("bcm_msg.msg_head.ival2.tv_sec: ",
bcm_msg.msg_head.ival2.tv_sec);
logInteger("bcm_msg.msg_head.ival2.tv_usec: ",
bcm_msg.msg_head.ival2.tv_usec);
logInteger("bcm_msg.msg_head.nframes: ",
bcm_msg.msg_head.nframes);
logInteger("bcm_msg.msg_head.opcode: ",
bcm_msg.msg_head.opcode);
TTCN_error(
//"SocketCAN sending CAN data with write() failed");
"SocketCAN sending CAN data with write() failed. nrOfBytestoSend: %d, sizeof(struct bcm_msg_head): %d, nframes: %d, sizeof(struct can_frame): %d, nrOfBytesSent: %d, errno: %d\n",
nrOfBytestoSend,
((int) sizeof(struct bcm_msg_head)),
((int) nframes), ((int) sizeof(struct can_frame)),
(int) nrOfBytesSent, (int) myerrno);
} else {
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = nrOfBytesSent;
result.result().err__text() = OMIT_VALUE;
}
log("Nr of bytes sent = %d", nrOfBytesSent);
if (nrOfBytesSent != nrOfBytestoSend) {
TTCN_error(
"SocketCAN frame write failed: %d bytes were sent instead of %d",
nrOfBytesSent, nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write failed as wrong number of bytes have been written";
}
}
}
break;
#ifdef BCM_CANFD_SUPPORT
case Bcm::SocketCAN__bcm__frame_frames::ALT_canfd__frame: {
int nrOfBytesSent = 0;
int nrOfBytestoSend = 0;
struct {
struct bcm_msg_head msg_head;
struct canfd_frame frame[BCM_FRAME_BUFFER_SIZE];
}bcm_msg;
const Bcm::SocketCAN__bcm__frame& bcm__tx__msg =
send_par.bcm__tx__msg();
unsigned int nframes =
bcm__tx__msg.frames().canfd__frame().lengthof();
if (nframes > BCM_FRAME_BUFFER_SIZE) {
TTCN_error(
"SocketCAN writing data: number of CAN FD frames too large: %d \n",
nframes);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN sending CAN FD data with write() failed, as more than BCM_FRAME_BUFFER_SIZE number of CAN FD frames to be sent";
TTCN_error(
"SocketCAN sending CAN FD data with write() failed, as more than BCM_FRAME_BUFFER_SIZE number of CAN FD frames to be sent");
} else {
const Bcm::SocketCAN__bcm__frame& bcm__tx__msg =
send_par.bcm__tx__msg();
bcm_msg.msg_head.opcode = oct2int(bcm__tx__msg.opcode());
bcm_msg.msg_head.flags = bit2int(
send_par.bcm__tx__msg().flags()) | CAN_FD_FRAME;
// set CAN_FD_FRAME-flag to indicate canfd frames are following
bcm_msg.msg_head.count = bcm__tx__msg.count();
bcm_msg.msg_head.ival1.tv_sec = bcm__tx__msg.ival1().tv__sec();
bcm_msg.msg_head.ival1.tv_usec =
bcm__tx__msg.ival1().tv__usec();
bcm_msg.msg_head.ival2.tv_sec = bcm__tx__msg.ival2().tv__sec();
bcm_msg.msg_head.ival2.tv_usec =
bcm__tx__msg.ival2().tv__usec();
bcm_msg.msg_head.nframes = nframes;
log("SocketCAN: Sending BCM Message)");
logOctet(" opcode: ", bcm__tx__msg.opcode());
logBitstring(" flags: ", bcm__tx__msg.flags());
logInteger(" count: ", bcm__tx__msg.count());
logInteger(" ival1: ", bcm__tx__msg.ival1().tv__sec());
logInteger(" ival1: ", bcm__tx__msg.ival1().tv__usec());
logInteger(" ival2: ", bcm__tx__msg.ival2().tv__sec());
logInteger(" ival2: ", bcm__tx__msg.ival2().tv__usec());
logOctet(" can_id: ", send_par.bcm__tx__msg().can__id());
logInteger(" nframes: ", nframes);
for (unsigned int i = 0; i < nframes; i++) {
const Bcm::SocketCAN__bcm__frame_frames_canfd__frame& frame =
bcm__tx__msg.frames().canfd__frame();
bcm_msg.frame[i].can_id = oct2int(frame[i].can__id());
bcm_msg.frame[i].flags = bit2int(frame[i].can__flags());
unsigned int len = frame[i].can__pdu().lengthof();
if (len > CANFD_MAX_DLEN) {
TTCN_error("Writing data: CAN FD pdu size too large\n");
len = CANFD_MAX_DLEN;
};
log(" containing CAN FD frame:)");
logOctet(" can id: ", frame[i].can__id());
logInteger(" can len: ", len);
bcm_msg.frame[i].len = len;
for (unsigned int j = 0; j < len; j++) {
bcm_msg.frame[i].data[j] = oct2int(
frame[i].can__pdu()[j]);
logOctet(" data: ", frame[i].can__pdu()[j]);
}
}
// assuming that the structs within the structure are aligned cm_msg without passing
// BCM_write does not calculate unused fields from nframes to BCM_FRAME_BUFFER_SIZE
nrOfBytestoSend = sizeof(struct bcm_msg_head)
+ nframes * sizeof(struct canfd_frame);
nrOfBytesSent = write(sock, &bcm_msg, nrOfBytestoSend);
if (nrOfBytesSent < 0) {
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN sending CAN FD data with write() failed";
TTCN_error(
"SocketCAN sending CAN FD data with write() failed");
} else {
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
log("Nr of bytes sent = %d", nrOfBytesSent);
if (nrOfBytesSent != nrOfBytestoSend) {
TTCN_error(
"SocketCAN CAN fd frame write failed: %d bytes were sent instead of %d",
nrOfBytesSent, nrOfBytestoSend);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write failed as wrong number of bytes have been written";
}
}
break;
#endif //BCM_CANFD_SUPPORT
default:
TTCN_error("SocketCAN write unknown frame type error");
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write unknown frame type error";
break;
}
} else {
TTCN_error(
"SocketCAN write data failed due to unknown socket reference: %d \n",
cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write data failed due to unknown socket reference";
}
incoming_message(result);
log(
"leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__write__data)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__write__isotp& send_par) {
log(
"entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__write__isotp)");
SocketCAN__Types::SocketCAN__write__isotp__result result;
int sock;
int cn = send_par.id();
if ((cn < sock_list_length)
and (sock_list[cn].protocol_family
== SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_PROTOCOL_CAN_ISOTP)
and (sock_list[cn].status == SOCKET_OPEN)) {
sock = sock_list[cn].fd;
int nrOfBytesSent = 0;
int nrOfBytestoSend = send_par.pdu().lengthof();
logOctet("Writing ISOTP data on socket: ", send_par.pdu());
nrOfBytesSent = write(sock, send_par.pdu(), nrOfBytestoSend);
log(
"Written to ISOTP %d bytes data of the expected %d bytes on socket %d: ",
nrOfBytesSent, nrOfBytestoSend, sock);
if (nrOfBytesSent != nrOfBytestoSend) {
TTCN_warning(
"SocketCAN write isotp has written %d bytes, which are fewer than expected %d bytes to socket: %d \n",
nrOfBytesSent, nrOfBytestoSend, sock);
}
if (nrOfBytesSent < 0) {
TTCN_error("SocketCAN write isotp failed with error code %d:\n",
errno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "SocketCAN write isotp failed";
} else {
log("SocketCAN: write isotp successful on socket %d", sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
} else {
TTCN_error(
"SocketCAN write isotp failed due to unknown socket reference: %d with protocol family %d and status %d\n",
cn, sock_list[cn].protocol_family, sock_list[cn].status);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN write isotp failed due to unknown socket reference";
}
incoming_message(result);
log(
"leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__write__isotp)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__setsockopt& send_par) {
log(
"entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__setsockopt)");
int sock;
int cn = send_par.id();
int res;
SocketCAN__Types::SocketCAN__setsockopt__result result;
if ((cn < sock_list_length) and (sock_list[cn].status == SOCKET_OPEN)) {
sock = sock_list[cn].fd;
SocketCAN__Types::SocketCAN__setsockopt__commandu::union_selection_type command_selection =
send_par.command().get_selection();
switch (command_selection) {
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_rfilter: {
std::size_t rfilter_size = (sizeof(send_par.command().rfilter())
/ sizeof(send_par.command().rfilter()[0]));
struct can_filter rfilter[rfilter_size];
if (rfilter_size == 0) {
// deactivate filters
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);
} else {
for (std::size_t i = 0; i < rfilter_size; i++) {
rfilter[i].can_id = oct2int(
send_par.command().rfilter()[i].can__id());
rfilter[i].can_mask = oct2int(
send_par.command().rfilter()[i].can__mask());
};
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter,
sizeof(rfilter));
}
if (res < 0) {
TTCN_error(
"SocketCAN setsockopt rfilter failed with error code %d:\n",
errno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN setsockopt rfilter failed";
} else {
log("SocketCAN: setsockopt rfilter successful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
break;
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_err__mask: {
can_err_mask_t err_mask = bit2int(send_par.command().err__mask());
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_ERR_FILTER, &err_mask,
sizeof(err_mask));
if (res < 0) {
int myerrno = errno;
TTCN_error(
"SocketCAN setsockopt can__err__mask failed with error code %d:\n",
myerrno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = myerrno;
result.result().err__text() =
"SocketCAN setsockopt can__err__mask failed";
} else {
log(
"SocketCAN: setsockopt can__err__mask successful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
break;
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_loopback: {
int loopback = send_par.command().loopback();
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback,
sizeof(loopback));
if (res < 0) {
int myerrno = errno;
TTCN_error(
"SocketCAN setsockopt loopbackfailed with error code %d:\n",
myerrno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = myerrno;
result.result().err__text() =
"SocketCAN setsockopt loopback failed";
} else {
log("SocketCAN: setsockopt loopback successful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
break;
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_recv__own__msgs: {
int recv_own_msgs = send_par.command().recv__own__msgs();
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS,
&recv_own_msgs, sizeof(recv_own_msgs));
if (res < 0) {
TTCN_error(
"SocketCAN setsockopt recv__own__msg failed with error code %d:\n",
errno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN setsockopt recv__own__msg failed";
} else {
log(
"SocketCAN: setsockopt recv__own__msg successful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
break;
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_fd__frames: {
int fd_frames = send_par.command().fd__frames();
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &fd_frames,
sizeof(fd_frames));
if (res < 0) {
TTCN_error(
"SocketCAN setsockopt fd__frames failed with error code %d:\n",
errno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN setsockopt fd__frames failed";
} else {
log("SocketCAN: setsockopt fd__frames successful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
break;
case SocketCAN__Types::SocketCAN__setsockopt__commandu::ALT_join__filters: {
{
int join_filters = send_par.command().join__filters();
res = setsockopt(sock, SOL_CAN_RAW, CAN_RAW_JOIN_FILTERS,
&join_filters, sizeof(join_filters));
if (res < 0) {
TTCN_error(
"SocketCAN setsockopt join__filters failed with error code %d:\n",
errno);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() =
"SocketCAN setsockopt join__filters failed";
} else {
log(
"SocketCAN: setsockopt join__filterssuccessful on socket %d",
sock);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__SUCCESS;
result.result().err() = OMIT_VALUE;
result.result().err__text() = OMIT_VALUE;
}
}
}
break;
default: {
TTCN_error(
"SocketCAN: Unknown SocketCAN_setsockopt commandu union selection: %d \n",
cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = OMIT_VALUE;
result.result().err__text() =
"SocketCAN: Unknown SocketCAN_setsockopt commandu union selection";
break;
}
}
} else {
TTCN_error("SocketCAN: Unknown socket reference: %d \n", cn);
result.result().result__code() =
SocketCAN__Types::SocketCAN__Result__code::SocketCAN__ERROR;
result.result().err() = errno;
result.result().err__text() = "SocketCAN: Unknown socket reference";
}
incoming_message(result);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__setsockopt)");
}
void SocketCAN__PT_PROVIDER::outgoing_send(
const SocketCAN__Types::SocketCAN__close& send_par) {
log("entering SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__close)");
int sock = sock_list[send_par.id()].fd;
sock_list[send_par.id()].status = SOCKET_NOT_ALLOCATED;
sock_list[send_par.id()].fd = 0;
sock_list[send_par.id()].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL;
num_of_sock--;
Handler_Remove_Fd_Read(sock);
close(sock);
log("leaving SocketCAN__PT_PROVIDER::outgoing_send(SocketCAN__close)");
}
void SocketCAN__PT_PROVIDER::reset_configuration() {
free(can_interface_name);
can_interface_name = NULL;
debugging = false;
debugging_configured = false;
}
void SocketCAN__PT_PROVIDER::InitStrPar(char *&par, const char* name,
const char* val) {
if (name)
log("%s: Reading testport parameter: "
"%s = %s", port_name, name, val);
if (par)
free(par);
par = (char*) malloc(strlen(val) + 1);
if (par == NULL)
TTCN_error("Not enough memory.");
strcpy(par, val);
}
void SocketCAN__PT_PROVIDER::log(const char *fmt, ...) {
if (debugging == true) {
TTCN_Logger::begin_event (TTCN_DEBUG);
TTCN_Logger::log_event("SocketCAN test port (%s): ", get_name());
va_list args;
va_start(args, fmt);
TTCN_Logger::log_event_va_list(fmt, args);
va_end(args);
TTCN_Logger::end_event();
}
}
void SocketCAN__PT_PROVIDER::logOctet(const char *prompt,
const OCTETSTRING& msg) {
if (debugging == true) { //if debug
TTCN_Logger::begin_event (TTCN_DEBUG);
TTCN_Logger::log_event_str(prompt);
TTCN_Logger::log_event("Size: %d,\nMsg: ", msg.lengthof());
for (int i = 0; i < msg.lengthof(); i++) {
TTCN_Logger::log_event(" %02x", ((const unsigned char*) msg)[i]);
}
TTCN_Logger::log_event("\n");
TTCN_Logger::end_event();
}
}
void SocketCAN__PT_PROVIDER::logHex(const char *prompt, const HEXSTRING& msg) {
if (debugging == true) { //if debug
TTCN_Logger::begin_event (TTCN_DEBUG);
TTCN_Logger::log_event_str(prompt);
TTCN_Logger::log_event("Size: %d,\nMsg: ", msg.lengthof());
for (int i = 0; i < msg.lengthof(); i++) {
TTCN_Logger::log_event(" %02x", ((const unsigned char*) msg)[i]);
}
TTCN_Logger::log_event("\n");
TTCN_Logger::end_event();
}
}
void SocketCAN__PT_PROVIDER::logInteger(const char *prompt, const int number) {
if (debugging) { //if debug
TTCN_Logger::begin_event (TTCN_DEBUG);
TTCN_Logger::log_event_str(prompt);
TTCN_Logger::log_event("Value: %d,\n: ", number);
TTCN_Logger::log_event("\n");
TTCN_Logger::end_event();
}
}
void SocketCAN__PT_PROVIDER::logBitstring(const char *prompt,
const BITSTRING& msg) {
if (debugging == true) { //if debug
TTCN_Logger::begin_event (TTCN_DEBUG);
TTCN_Logger::log_event_str(prompt);
int len = msg.lengthof();
TTCN_Logger::log_event("Size: %d,\nMsg: 0b", len);
for (int i = 0; i < msg.lengthof(); i++) {
TTCN_Logger::log_event("%d", (int) bit2int(msg[i]));
}
TTCN_Logger::log_event("\n");
TTCN_Logger::end_event();
}
}
void SocketCAN__PT_PROVIDER::setUpSocket() {
log("entering SocketCAN__PT_PROVIDER::setUpSocket()");
log("leaving SocketCAN__PT_PROVIDER::setUpSocket()");
}
void SocketCAN__PT_PROVIDER::closeDownSocket() {
log("entering SocketCAN__PT_PROVIDER::closeDownSocket()");
for (int a = 0; a < sock_list_length; a++) {
if (sock_list[a].status == SOCKET_OPEN) {
sock_list[a].status = SOCKET_NOT_ALLOCATED;
sock_list[a].protocol_family =
SocketCAN__PortType::SocketCAN__PT_PROVIDER::SOCKET_NO_PROTOCOL;
close(sock_list[a].fd);
Handler_Remove_Fd_Read(sock_list[a].fd);
}
}
Free(sock_list);
sock_list = NULL;
log("leaving SocketCAN__PT_PROVIDER::closeDownSocket()");
}
}
/* end of namespace */