* limitations under the License.
*/
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <net/if.h>
-#include <linux/can.h>
-#include <linux/can/raw.h>
-#include <fcntl.h>
-#include <systemd/sd-event.h>
-#include <errno.h>
-#include <vector>
-#include <map>
+#include "low-can-binding.hpp"
+
#include <queue>
-#include <string>
-#include <functional>
-#include <memory>
+#include <mutex>
+#include <vector>
#include <thread>
-
+#include <fcntl.h>
+#include <linux/can.h>
#include <json-c/json.h>
-#include <openxc.pb.h>
+#include <systemd/sd-event.h>
-#include <afb/afb-binding.h>
-#include <afb/afb-service-itf.h>
+#include "timer.hpp"
+#include "openxc.pb.h"
+#include "can-utils.hpp"
+#include "can-signals.hpp"
+#include "openxc-utils.hpp"
-#include "ll-can-binding.h"
-#include "obd2.h"
+extern "C"
+{
+ #include <afb/afb-service-itf.h>
+};
/*
- * Interface between the daemon and the binding
+ * Interface between the daemon and the binding
*/
-static const struct afb_binding_interface *interface;
+const struct afb_binding_interface *binder_interface;
/********************************************************************************
*
-* Event management
+* Subscription and unsubscription
*
*********************************************************************************/
-/*
- * TBF TBF TBF
- * called on an event on the CAN bus
- */
-static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata)
+static int make_subscription_unsubscription(struct afb_req request, std::map<std::string, struct afb_event>::iterator& ss_i, bool subscribe)
{
- openxc_CanMessage can_message;
-
- can_message = openxc_CanMessage_init_default;
-
- /* read available data */
- if ((revents & EPOLLIN) != 0)
- {
- read_can(&can_message);
- send_event();
- }
-
- /* check if error or hangup */
- if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0)
+ /* Make the subscription or unsubscription to the event */
+ if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, ss_i->second)) < 0)
{
- sd_event_source_unref(s);
- close(fd);
- connect_to_event_loop();
+ ERROR(binder_interface, "Operation goes wrong for signal: %s", ss_i->first);
+ return 0;
}
+ return 1;
- return 0;
}
-/*
- * USELESS SINCE THREADS SEPARATION
- *
- * Get the event loop running.
- * Will trigger on_event function on EPOLLIN event on socket
- *
- * Return 0 or positive value on success. Else negative value for failure.
-static int connect_to_event_loop(CanBus &CanBus_handler)
+static int create_event_handle(std::map<std::string, struct afb_event>::iterator& ss_i)
{
- sd_event *event_loop;
- sd_event_source *source;
- int rc;
-
- if (CanBus_handler.socket < 0)
- {
- return CanBus_handler.socket;
- }
-
- event_loop = afb_daemon_get_event_loop(interface->daemon);
- rc = sd_event_add_io(event_loop, &source, CanBus_handler.socket, EPOLLIN, on_event, NULL);
- if (rc < 0)
- {
- CanBus_handler.close();
- ERROR(interface, "Can't connect CAN bus %s to the event loop", CanBus_handler.device);
- } else
+ ss_i->second = afb_daemon_make_event(binder_interface->daemon, ss_i->first.c_str());
+ if (!afb_event_is_valid(ss_i->second))
{
- NOTICE(interface, "Connected CAN bus %s to the event loop", CanBus_handler.device);
+ ERROR(binder_interface, "Can't create an event, something goes wrong.");
+ return 0;
}
- return rc;
+ return 1;
}
- */
-/********************************************************************************
-*
-* Subscription and unsubscription
-*
-*********************************************************************************/
+static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const CanSignal& sig)
+{
+ int ret;
-static int subscribe_unsubscribe_signal(struct afb_req request, int subscribe, std::map<CanSignal, struct afb_event>::iterator *s_sig)
- {
- if (!afb_event_is_valid(s_sig->second)) {
- if (!subscribe)
- return 1;
- sig->event = afb_daemon_make_event(afbitf->daemon, s_sig->first->genericName);
- if (!afb_event_is_valid(s_sig->second)) {
- return 0;
+ std::lock_guard<std::mutex> subscribed_signals_lock(subscribed_signals_mutex);
+ auto ss_i = subscribed_signals.find(sig.genericName);
+ if (ss_i != subscribed_signals.end() && !afb_event_is_valid(ss_i->second))
+ {
+ if(!subscribe)
+ {
+ NOTICE(binder_interface, "Event isn't valid, it can't be unsubscribed.");
+ ret = -1;
+ }
+ else
+ {
+ /* Event it isn't valid annymore, recreate it */
+ ret = create_event_handle(ss_i);
}
}
-
- if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s_sig->second)) < 0) {
- return 0;
+ else
+ {
+ /* Event don't exist , so let's create it */
+ struct afb_event empty_event = {nullptr, nullptr};
+ auto ss_i = subscribed_signals.insert(std::make_pair(sig.genericName, empty_event));
+ ret = create_event_handle(ss_i.first);
}
- return 1;
- }
+ /* Check whether or not the event handler has been correctly created and
+ * make the subscription/unsubscription operation is so.
+ */
+ if (ret <= 0)
+ return ret;
+ return make_subscription_unsubscription(request, ss_i, subscribe);
+}
-static int subscribe_unsubscribe_signals(struct afb_req request, int subscribe, std:vector<CanSignal> *signals)
+static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector<CanSignal>& signals)
{
- std::vector<CanSignal>::iterator signal_i;
- std::map <CanSignal, struct afb_event>::iterator s_signal_i;
-
- for(signal_i=signals.begin(); signal_i != signals.end(); signal_i++)
+ int ret = 0;
+
+ for(const auto& signal_i : signals)
{
- s_signal_i = subscribed_signals.find(signal_i);
- if(s_signal_i != subscribed_signals.end())
- subscribe_unsubscribe_signal(request, subscribe, s_signal_i);
- else
- {
- std::map <CanSignal, struct afb_event>::iterator it = subscribed_signals.begin();
- it = subscribed_signals.insert(it, std::pair<CanSignal, struct afb_event>(signal_i, NULL);
- subscribe_unsubscribe_signal(request, subscribe, it);
- }
- return 0;
+ ret = subscribe_unsubscribe_signal(request, subscribe, signal_i);
+ if(ret == 0)
+ return ret;
}
+ return ret;
}
-static int subscribe_unsubscribe_all(struct afb_req request, int subscribe)
+static int subscribe_unsubscribe_all(struct afb_req request, bool subscribe)
{
- int i, n, e;
+ int e = 0;
- n = sizeof OBD2_PIDS / sizeof * OBD2_PIDS;
- e = 0;
- for (i = 0 ; i < n ; i++)
- e += !subscribe_unsubscribe_sig(request, subscribe, &OBD2_PIDS[i]);
+ //for (const auto& sig : SIGNALS)
+ // e += !subscribe_unsubscribe_signals(request, subscribe, sig);
+ e += !subscribe_unsubscribe_signals(request, subscribe, getSignals());
+
return e == 0;
}
-static int subscribe_unsubscribe_name(struct afb_req request, int subscribe, const char *name)
+static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name)
{
- std::vector <CanSignal> *sig;
-
- if (0 == strcmp(name, "*"))
- return subscribe_unsubscribe_all(request, subscribe);
+ std::vector<CanSignal> sig;
+ int ret = 0;
- find_signals(name, sig);
- if (sig == NULL) {
- return 0;
+ if (!::strcmp(name, "*"))
+ ret = subscribe_unsubscribe_all(request, subscribe);
+ else
+ {
+ //if(obd2_handler_c.is_obd2_signal(name))
+ if(false)
+ {
+ // TODO
+ }
+ else
+ {
+ openxc_DynamicField search_key = build_DynamicField(name);
+ sig = find_can_signals(search_key);
+ if (sig.empty())
+ ret = 0;
+ }
+ ret = subscribe_unsubscribe_signals(request, subscribe, sig);
}
-
- return subscribe_unsubscribe_sig(request, subscribe, sig);
+ return ret;
}
-static void subscribe_unsubscribe(struct afb_req request, int subscribe)
+static void subscribe_unsubscribe(struct afb_req request, bool subscribe)
{
int ok, i, n;
struct json_object *args, *a, *x;
afb_req_fail(request, "error", NULL);
}
-static void subscribe(struct afb_req request)
-{
- subscribe_unsubscribe(request, 1);
-}
-
-static void unsubscribe(struct afb_req request)
+extern "C"
{
- subscribe_unsubscribe(request, 0);
-}
-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
+ static void subscribe(struct afb_req request)
+ {
+ subscribe_unsubscribe(request, true);
}
-};
-const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
-{
- interface = itf;
+ static void unsubscribe(struct afb_req request)
+ {
+ subscribe_unsubscribe(request, false);
+ }
- return &binding_desc;
-}
+ 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." }
+ };
-int afbBindingV1ServiceInit(struct afb_service service)
-{
- std::ifstream fd_conf;
- std::string fd_conf_content;
- json_object jo_canbus;
+ static const struct afb_binding binding_desc {
+ AFB_BINDING_VERSION_1,
+ {
+ "CAN bus service",
+ "can",
+ verbs
+ }
+ };
- /* Open JSON conf file */
- jo_canbus = json_object_new_object();
- fd_conf = afb_daemon_rootdir_open_locale(interface->daemon, "canbus.json", O_RDONLY, NULL);
- if (fd_conf)
+ const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
{
- fd_conf.seekg(0, std::ios::end);
- fd_conf_content.resize(fd_conf.tellg());
- fd_conf.seekg(0, std::ios::beg);
- fd_conf.read(&fd_conf_content[0], fd_conf_content.size());
- fd_conf.close();
+ binder_interface = itf;
+
+ return &binding_desc;
}
- jo_canbus = json_tokener_parse(&fd_conf_content);
+ /**
+ * @brief Initialize the binding.
+ *
+ * @param[in] service Structure which represent the Application Framework Binder.
+ *
+ * @return Exit code, zero if success.
+ */
+ int afbBindingV1ServiceInit(struct afb_service service)
+ {
+ int fd_conf;
+ fd_conf = afb_daemon_rootdir_open_locale(binder_interface->daemon, "can_bus.json", O_RDONLY, NULL);
- /* Open CAN socket */
- CanBus_c CanBus_handler(interface, json_object_get_string(json_object_object_get(jo_canbus, "deviceName"));
- CanBus_handler.open();
- CanBus_handler.start_threads();
-}
+ /* Initialize the CAN bus handler */
+ can_bus_t can_bus_handler(fd_conf);
+
+ /* Open CAN socket */
+ if(can_bus_handler.init_can_dev() == 0)
+ {
+ can_bus_handler.start_threads();
+ return 0;
+ }
+ ERROR(binder_interface, "There was something wrong with CAN device Initialization. Check your config file maybe");
+ return 1;
+ }
+};
Code Review / apps / agl-service-can-low-level.git / blobdiff