Clean up old file

Change-Id: I569b0686b7f86718759f7a3f5dac4ae35d97a151
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

1 files changed, 0 insertions, 559 deletions

diff --git a/iotbzh-CAN-binding.c b/iotbzh-CAN-binding.c
deleted file mode 100644
index 1dc66574..00000000
--- a/iotbzh-CAN-binding.c
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * Copyright (C) 2015, 2016 "IoT.bzh"
- * Author "Romain Forlot" <romain.forlot@iot.bzh>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#define _GNU_SOURCE
-
-#include <string.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <net/if.h>
-#include <sys/time.h>
-#include <linux/can.h>
-#include <linux/can/raw.h>
-#include <math.h>
-#include <fcntl.h>
-#include <systemd/sd-event.h>
-#include <errno.h>
-
-#include <json-c/json.h>
-#include <openxc.pb.h>
-
-#include <afb/afb-binding.h>
-#include <afb/afb-service-itf.h>
-
-/*****************************************************************************************/
-/*****************************************************************************************/
-/**											**/
-/**											**/
-/**	   SECTION: GLOBAL VARIABLES							**/
-/**											**/
-/**											**/
-/*****************************************************************************************/
-/*****************************************************************************************/
-
-/* max. number of CAN interfaces given on the cmdline */
-#define MAXSOCK 16
-
-/* buffer sizes for CAN frame string representations */
-#define CL_ID (sizeof("12345678##1"))
-#define CL_DATA sizeof(".AA")
-#define CL_BINDATA sizeof(".10101010")
-
- /* CAN FD ASCII hex short representation with DATA_SEPERATORs */
-#define CL_CFSZ (2*CL_ID + 64*CL_DATA)
-
-#define CANID_DELIM '#'
-
-/*
- * the type of position expected
- *
- * here, this type is the selection of protocol
- */
-enum type {
-	type_OBDII,
-	type_CAN,
-	type_DEFAULT = type_CAN,
-	type_INVALID = -1
-};
-
-#define type_size sizeof(enum type)-2
-
-/*
- * each generated event
- */
-struct event {
-	struct event *next;	/* link for the same period */
-	const char *name;	/* name of the event */
-	struct afb_event event;	/* the event for the binder */
-	enum type type;		/* the type of data expected */
-	int id;			/* id of the event for unsubscribe */
-};
-
-/* CAN variable initialization */
-
-static __u32 dropcnt[MAXSOCK];
-static __u32 last_dropcnt[MAXSOCK];
-struct timeval tv;
-struct canfd_frame canfd_frame;
-
-struct can_handler {
-	int socket;
-	char *device;
-	openxc_CanMessage *msg;
-	struct sockaddr_can txAddress;
-};
-
-
-
-/*****************************************************************************************/
-/*****************************************************************************************/
-/**											**/
-/**											**/
-/**	   SECTION: UTILITY FUNCTIONS							**/
-/**											**/
-/**											**/
-/*****************************************************************************************/
-/*****************************************************************************************/
-/*
- * Interface between the daemon and the binding
- */
-static const struct afb_binding_interface *interface;
-
-/*
- * @brief Retry a function 3 times
- *
- * @param int function(): function that return an int wihtout any parameter
- *
- * @ return : 0 if ok, -1 if failed
- *
- */
-static int retry( int(*func)());
-static int retry( int(*func)())
-{
-	int i;
-
-	for (i=0;i<4;i++)
-	{
-		if ( (*func)() >= 0)
-		{
-			return 0;
-		}
-		usleep(100000);
-	}
-	return -1;
-}
-
-/*****************************************************************************************/
-/*****************************************************************************************/
-/**											**/
-/**											**/
-/**	   SECTION: HANDLE CAN DEVICE							**/
-/**											**/
-/**											**/
-/*****************************************************************************************/
-/*****************************************************************************************/
-const char hex_asc_upper[] = "0123456789ABCDEF";
-
-#define hex_asc_upper_lo(x) hex_asc_upper[((x) & 0x0F)]
-#define hex_asc_upper_hi(x) hex_asc_upper[((x) & 0xF0) >> 4]
-
-static inline void _put_id(char *buf, int end_offset, canid_t id)
-{
-	/* build 3 (SFF) or 8 (EFF) digit CAN identifier */
-	while (end_offset >= 0) {
-		buf[end_offset--] = hex_asc_upper[id & 0xF];
-		id >>= 4;
-	}
-}
-
-#define put_sff_id(buf, id) _put_id(buf, 2, id)
-#define put_eff_id(buf, id) _put_id(buf, 7, id)
-
-static void canread_frame_parse(struct canfd_frame *canfd_frame, int maxdlen);
-
-/*
- * names of the types
- */
-static const char * const type_NAMES[type_size] = {
-	"OBDII",
-	"CAN"
-};
-
-
-// Initialize default can_handler values
-static struct can_handler can_handler = {
-	.socket = -1,
-	.device = "vcan0",
-};
-
-
-/*
- * open the can socket
- */
-static int open_can_dev()
-{
-	const int canfd_on = 1;
-	struct ifreq ifr;
-	struct timeval timeout = {1,0};
-	openxc_CanMessage *can_msg;
-
-	DEBUG(interface, "open_can_dev: CAN Handler socket : %d", can_handler.socket);
-	close(can_handler.socket);
-
-	can_handler.socket = socket(PF_CAN, SOCK_RAW, CAN_RAW);
-	if (can_handler.socket < 0)
-	{
-		ERROR(interface, "open_can_dev: socket could not be created");
-	}
-	else
-	{
-		/* Set timeout for read */
-		setsockopt(can_handler.socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
-		/* try to switch the socket into CAN_FD mode */
-		can_msg->has_frame_format = true;
-		if (setsockopt(can_handler.socket, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0)
-		{
-			NOTICE(interface, "open_can_dev: Can not switch into CAN Extended frame format.");
-			can_msg->frame_format = openxc_CanMessage_FrameFormat_STANDARD;
-		} else {
-			can_msg->frame_format = openxc_CanMessage_FrameFormat_EXTENDED;
-		}
-
-		/* Attempts to open a socket to CAN bus */
-		strcpy(ifr.ifr_name, can_handler.device);
-		if(ioctl(can_handler.socket, SIOCGIFINDEX, &ifr) < 0)
-		{
-			ERROR(interface, "open_can_dev: ioctl failed");
-		}
-		else
-		{
-			can_handler.txAddress.can_family = AF_CAN;
-			can_handler.txAddress.can_ifindex = ifr.ifr_ifindex;
-
-			/* And bind it to txAddress */
-			if (bind(can_handler.socket, (struct sockaddr *)&can_handler.txAddress, sizeof(can_handler.txAddress)) < 0)
-			{
-				ERROR(interface, "open_can_dev: bind failed");
-			}
-			else
-			{
-				fcntl(can_handler.socket, F_SETFL, O_NONBLOCK);
-				can_handler.msg = can_msg;
-				return 0;
-			}
-		}
-		close(can_handler.socket);
-		can_handler.socket = -1;
-	}
-	return -1;
-}
-
-static int write_can()
-{
-	int rc = 0;
-
-	rc = can_handler.socket;
-	if (rc >= 0)
-	{
-/*
- * TODO change old hvac write can frame to generic on_event
- */
-		rc = sendto(can_handler.socket, &canfd_frame, sizeof(struct canfd_frame), 0,
-			    (struct sockaddr*)&can_handler.txAddress, sizeof(can_handler.txAddress));
-		if (rc < 0)
-		{
-			ERROR(interface, "Sending CAN frame failed.");
-		}
-	}
-	else
-	{
-		ERROR(interface, "socket not initialized. Attempt to reopen can device socket.");
-		retry(open_can_dev);
-	}
-	return rc;
-}
-
-/*
- * Read on CAN bus and return how much bytes has been read.
- */
-static int read_can()
-{
-	int bytes_read, maxdlen;
-
-	bytes_read = read(can_handler.socket, &canfd_frame, sizeof(struct canfd_frame));
-
-	if (bytes_read < 0)
-	{
-		if (errno == ENETDOWN) {
-			ERROR(interface, "%s: interface down", can_handler.device);
-		}
-		ERROR(interface, "Error reading CAN bus");
-		return -1;
-	}
-
-	/* CAN frame integrity check */
-	if ((size_t)bytes_read == CAN_MTU)
-		maxdlen = CAN_MAX_DLEN;
-	else if ((size_t)bytes_read == CANFD_MTU)
-		maxdlen = CANFD_MAX_DLEN;
-	else
-	{
-		ERROR(interface, "CAN frame incomplete");
-		return -2;
-	}
-
-	canread_frame_parse(&canfd_frame, maxdlen);
-}
-
-/*
- * Parse the CAN frame data payload as a CAN packet
- * TODO: parse as an OpenXC Can Message
- */
-static void canread_frame_parse(struct canfd_frame *canfd_frame, int maxdlen)
-{
-	int i,offset;
-	int len = (canfd_frame->len > maxdlen) ? maxdlen : canfd_frame->len;
-	char buf[CL_CFSZ];
-
-	if (canfd_frame->can_id & CAN_ERR_FLAG) {
-		put_eff_id(buf, canfd_frame->can_id & (CAN_ERR_MASK|CAN_ERR_FLAG));
-		buf[8] = '#';
-		offset = 9;
-	} else if (canfd_frame->can_id & CAN_EFF_FLAG) {
-		put_eff_id(buf, canfd_frame->can_id & CAN_EFF_MASK);
-		buf[8] = '#';
-		offset = 9;
-	} else {
-		put_sff_id(buf, canfd_frame->can_id & CAN_SFF_MASK);
-		buf[3] = '#';
-		offset = 4;
-	}
-
-	/* standard CAN frames may have RTR enabled. There are no ERR frames with RTR */
-	if (maxdlen == CAN_MAX_DLEN && canfd_frame->can_id & CAN_RTR_FLAG) {
-		buf[offset++] = 'R';
-		/* print a given CAN 2.0B DLC if it's not zero */
-		if (canfd_frame->len && canfd_frame->len <= CAN_MAX_DLC)
-			buf[offset++] = hex_asc_upper[canfd_frame->len & 0xF];
-
-		buf[offset] = 0;
-	}
-
-	if (maxdlen == CANFD_MAX_DLEN) {
-		/* add CAN FD specific escape char and flags */
-		buf[offset++] = '#';
-		buf[offset++] = hex_asc_upper[canfd_frame->flags & 0xF];
-	}
-/*
-	for (i = 0; i < len; i++) {
-		put_hex_byte(buf + offset, canfd_frame->data[i]);
-		offset += 2;
-	}
-
-buf[offset] = 0;
-
-	can_message->has_id = true;
-	can_message->id = msg.id; // TODO make the parsing to extract id from data and only return left data into msg.msg_iov
-	can_message->has_data = true;
-	can_message->data = msg.msg_iov;
-	*/
-}
-
-/***************************************************************************************/
-/***************************************************************************************/
-/**                                                                                   **/
-/**                                                                                   **/
-/**       SECTION: MANAGING EVENTS                                                    **/
-/**                                                                                   **/
-/**                                                                                   **/
-/***************************************************************************************/
-/***************************************************************************************/
-static int connect_to_event_loop();
-
-/*
- * called on an event on the CAN bus
- */
-static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata)
-{
-	openxc_CanMessage can_message;
-
-	/* read available data */
-	if ((revents & EPOLLIN) != 0)
-	{
-		read_can(&can_message);
-//		event_send();
-	}
-
-	/* check if error or hangup */
-	if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0)
-	{
-		sd_event_source_unref(s);
-		close(fd);
-		connect_to_event_loop();
-	}
-
-	return 0;
-}
-
-/*
- * get or create an event handler for the type
- * TODO: implement function and handle retrieve or create an event as needed
- */
-static struct event *event_get(enum type type)
-{
-
-}
-
-static struct event *event_of_id(int id)
-{
-
-}
-
-/*****************************************************************************************/
-/*****************************************************************************************/
-/**											**/
-/**											**/
-/**	   SECTION: BINDING VERBS IMPLEMENTATION					**/
-/**											**/
-/**											**/
-/*****************************************************************************************/
-/*****************************************************************************************/
-/*
- * Returns the type corresponding to the given name
- */
-static enum type type_of_name(const char *name)
-{
-	enum type result;
-	if (name == NULL)
-		return type_DEFAULT;
-	for (result = 0 ; result < type_size; result++)
-		if (strcmp(type_NAMES[result], name) == 0)
-			return result;
-	return type_INVALID;
-}
-
-/*
- * extract a valid type from the request
- */
-static int get_type_for_req(struct afb_req req, enum type *type)
-{
-	if ((*type = type_of_name(afb_req_value(req, "type"))) != type_INVALID)
-		return 1;
-	afb_req_fail(req, "unknown-type", NULL);
-	return 0;
-}
-
-/*
- * subscribe to notification of new CAN messages
- *
- * parameters of the subscription are:
- *
- *    TODO type: string:  choose between CAN and OBDII messages formats.
- *
- * returns an object with 2 fields:
- *
- *    name:   string:  the name of the event without its prefix
- *    id:     integer: a numeric identifier of the event to be used for unsubscribing
- */
-static void subscribe(struct afb_req req)
-{
-	enum type type;
-	const char *period;
-	struct event *event;
-	struct json_object *json;
-
-	if (get_type_for_req(req, &type))
-	{
-		event = event_get(type);
-		if (event == NULL)
-			afb_req_fail(req, "out-of-memory", NULL);
-		else if (afb_req_subscribe(req, event->event) != 0)
-			afb_req_fail_f(req, "failed", "afb_req_subscribe returned an error: %m");
-		else
-		{
-			json = json_object_new_object();
-			json_object_object_add(json, "name", json_object_new_string(event->name));
-			json_object_object_add(json, "id", json_object_new_int(event->id));
-			afb_req_success(req, json, NULL);
-		}
-	}
-}
-
-/*
- * unsubscribe a previous subscription
- *
- * parameters of the unsubscription are:
- *
- *    id:   integer: the numeric identifier of the event as returned when subscribing
- */
-static void unsubscribe(struct afb_req req)
-{
-	const char *id;
-	struct event *event;
-
-	id = afb_req_value(req, "id");
-	if (id == NULL)
-		afb_req_fail(req, "missing-id", NULL);
-	else
-	{
-		event = event_of_id(atoi(id));
-		if (event == NULL)
-			afb_req_fail(req, "bad-id", NULL);
-		else
-		{
-			afb_req_unsubscribe(req, event->event);
-			afb_req_success(req, NULL, NULL);
-		}
-	}
-}
-
-static int connect_to_event_loop()
-{
-	sd_event_source *source;
-	int rc;
-
-	retry(open_can_dev);
-
-	if (can_handler.socket < 0)
-	{
-		return can_handler.socket;
-	}
-
-	rc = sd_event_add_io(afb_daemon_get_event_loop(interface->daemon), &source, can_handler.socket, EPOLLIN, on_event, NULL);
-	if (rc < 0)
-	{
-		close(can_handler.socket);
-		ERROR(interface, "Can't connect CAN bus %s to the event loop", can_handler.device);
-	} else
-	{
-		NOTICE(interface, "Connected CAN bus %s to the event loop", can_handler.device);
-	}
-
-	return rc;
-}
-
-
-// TODO: Have to change session management flag to AFB_SESSION_CHECK to use token auth
-static const struct afb_verb_desc_v1 verbs[]=
-{
-  { .name= "subscribe",    .session= AFB_SESSION_NONE, .callback= subscribe,    .info= "subscribe to notification of CAN bus messages." },
-  { .name= "unsubscribe",  .session= AFB_SESSION_NONE, .callback= unsubscribe,  .info= "unsubscribe a previous subscription." },
-	{NULL}
-};
-
-static const struct afb_binding binding_desc = {
-	.type = AFB_BINDING_VERSION_1,
-	.v1 = {
-		.info = "CAN bus service",
-		.prefix = "can",
-		.verbs = verbs
-	}
-};
-
-const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
-{
-	interface = itf;
-
-	return &binding_desc;
-}
-
-int afbBindingV1ServiceInit(struct afb_service service)
-{
-	return connect_to_event_loop();
-}