/******************************************************************************
 * Copyright (c) 2000-2018 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 */