3 * neard - Near Field Communication manager
5 * Copyright (C) 2011 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
38 /* We check for the tag being present every 2 seconds */
39 #define CHECK_PRESENCE_PERIOD 2
41 static DBusConnection *connection = NULL;
43 static GHashTable *adapter_hash;
45 #define NEAR_ADAPTER_MODE_INITIATOR 0x1
46 #define NEAR_ADAPTER_MODE_TARGET 0x2
47 #define NEAR_ADAPTER_MODE_DUAL 0x3
60 near_bool_t constant_poll;
64 struct near_tag *tag_link;
68 struct near_device *device_link;
75 guint presence_timeout;
78 struct near_adapter_ioreq {
81 unsigned char buf[1024];
91 static void free_adapter(gpointer data)
93 struct near_adapter *adapter = data;
95 if (adapter->presence_timeout > 0)
96 g_source_remove(adapter->presence_timeout);
98 g_free(adapter->name);
99 g_free(adapter->path);
103 static void free_tag(gpointer data)
105 struct near_tag *tag = data;
107 __near_tag_remove(tag);
110 static void free_device(gpointer data)
112 struct near_device *device = data;
114 __near_device_remove(device);
117 static void polling_changed(struct near_adapter *adapter)
120 near_dbus_property_changed_basic(adapter->path,
121 NFC_ADAPTER_INTERFACE, "Polling",
122 DBUS_TYPE_BOOLEAN, &adapter->polling);
125 static int adapter_start_poll(struct near_adapter *adapter)
128 uint32_t im_protos, tm_protos;
130 if (g_hash_table_size(adapter->tags) > 0) {
131 DBG("Clearing tags");
133 g_hash_table_remove_all(adapter->tags);
134 __near_adapter_tags_changed(adapter->idx);
137 if (g_hash_table_size(adapter->devices) > 0) {
138 DBG("Clearing devices");
140 g_hash_table_remove_all(adapter->devices);
141 __near_adapter_devices_changed(adapter->idx);
144 DBG("Poll mode 0x%x", adapter->poll_mode);
146 im_protos = tm_protos = 0;
148 if (adapter->poll_mode & NEAR_ADAPTER_MODE_INITIATOR)
149 im_protos = adapter->protocols;
151 if (adapter->poll_mode & NEAR_ADAPTER_MODE_TARGET)
152 tm_protos = adapter->protocols;
154 err = __near_netlink_start_poll(adapter->idx, im_protos, tm_protos);
158 adapter->polling = TRUE;
160 polling_changed(adapter);
165 static void append_path(gpointer key, gpointer value, gpointer user_data)
167 struct near_adapter *adapter = value;
168 DBusMessageIter *iter = user_data;
170 DBG("%s", adapter->path);
172 if (adapter->path == NULL)
175 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
179 void __near_adapter_list(DBusMessageIter *iter, void *user_data)
181 g_hash_table_foreach(adapter_hash, append_path, iter);
184 static void append_protocols(DBusMessageIter *iter, void *user_data)
186 struct near_adapter *adapter = user_data;
189 DBG("protocols 0x%x", adapter->protocols);
191 if (adapter->protocols & NFC_PROTO_FELICA_MASK) {
194 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
197 if (adapter->protocols & NFC_PROTO_MIFARE_MASK) {
200 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
203 if (adapter->protocols & NFC_PROTO_JEWEL_MASK) {
206 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
209 if (adapter->protocols & NFC_PROTO_ISO14443_MASK) {
212 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
215 if (adapter->protocols & NFC_PROTO_NFC_DEP_MASK) {
218 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
222 static void append_tag_path(gpointer key, gpointer value, gpointer user_data)
224 struct near_tag *tag = value;
225 DBusMessageIter *iter = user_data;
226 const char *tag_path;
228 tag_path = __near_tag_get_path(tag);
229 if (tag_path == NULL)
234 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &tag_path);
237 static void append_tags(DBusMessageIter *iter, void *user_data)
239 struct near_adapter *adapter = user_data;
243 g_hash_table_foreach(adapter->tags, append_tag_path, iter);
246 static void append_device_path(gpointer key, gpointer value, gpointer user_data)
248 struct near_device *device = value;
249 DBusMessageIter *iter = user_data;
250 const char *device_path;
252 device_path = __near_device_get_path(device);
253 if (device_path == NULL)
256 DBG("%s", device_path);
258 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
262 static void append_devices(DBusMessageIter *iter, void *user_data)
264 struct near_adapter *adapter = user_data;
268 g_hash_table_foreach(adapter->devices, append_device_path, iter);
271 void __near_adapter_tags_changed(uint32_t adapter_idx)
273 struct near_adapter *adapter;
277 adapter = g_hash_table_lookup(adapter_hash,
278 GINT_TO_POINTER(adapter_idx));
282 near_dbus_property_changed_array(adapter->path,
283 NFC_ADAPTER_INTERFACE, "Tags",
284 DBUS_TYPE_OBJECT_PATH, append_tags,
288 void __near_adapter_devices_changed(uint32_t adapter_idx)
290 struct near_adapter *adapter;
294 adapter = g_hash_table_lookup(adapter_hash,
295 GINT_TO_POINTER(adapter_idx));
299 near_dbus_property_changed_array(adapter->path,
300 NFC_ADAPTER_INTERFACE, "Devices",
301 DBUS_TYPE_OBJECT_PATH, append_devices,
305 static DBusMessage *get_properties(DBusConnection *conn,
306 DBusMessage *msg, void *data)
308 struct near_adapter *adapter = data;
310 DBusMessageIter array, dict;
312 DBG("conn %p", conn);
314 reply = dbus_message_new_method_return(msg);
318 dbus_message_iter_init_append(reply, &array);
320 near_dbus_dict_open(&array, &dict);
322 near_dbus_dict_append_basic(&dict, "Powered",
323 DBUS_TYPE_BOOLEAN, &adapter->powered);
325 near_dbus_dict_append_basic(&dict, "Polling",
326 DBUS_TYPE_BOOLEAN, &adapter->polling);
328 near_dbus_dict_append_array(&dict, "Protocols",
329 DBUS_TYPE_STRING, append_protocols, adapter);
331 near_dbus_dict_append_array(&dict, "Tags",
332 DBUS_TYPE_OBJECT_PATH, append_tags, adapter);
334 near_dbus_dict_append_array(&dict, "Devices",
335 DBUS_TYPE_OBJECT_PATH, append_devices, adapter);
337 near_dbus_dict_close(&array, &dict);
342 static DBusMessage *set_property(DBusConnection *conn,
343 DBusMessage *msg, void *data)
345 struct near_adapter *adapter = data;
346 DBusMessageIter iter, value;
350 DBG("conn %p", conn);
352 if (dbus_message_iter_init(msg, &iter) == FALSE)
353 return __near_error_invalid_arguments(msg);
355 dbus_message_iter_get_basic(&iter, &name);
356 dbus_message_iter_next(&iter);
357 dbus_message_iter_recurse(&iter, &value);
359 type = dbus_message_iter_get_arg_type(&value);
361 if (g_str_equal(name, "Powered") == TRUE) {
364 if (type != DBUS_TYPE_BOOLEAN)
365 return __near_error_invalid_arguments(msg);
367 dbus_message_iter_get_basic(&value, &powered);
369 err = __near_netlink_adapter_enable(adapter->idx, powered);
371 if (err == -EALREADY) {
373 return __near_error_already_enabled(msg);
375 return __near_error_already_disabled(msg);
378 return __near_error_failed(msg, -err);
381 adapter->powered = powered;
383 return __near_error_invalid_property(msg);
386 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
389 static DBusMessage *start_poll_loop(DBusConnection *conn,
390 DBusMessage *msg, void *data)
392 struct near_adapter *adapter = data;
393 const char *dbus_mode;
396 DBG("conn %p", conn);
398 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &dbus_mode,
401 DBG("Mode %s", dbus_mode);
403 if (g_strcmp0(dbus_mode, "Initiator") == 0)
404 adapter->poll_mode = NEAR_ADAPTER_MODE_INITIATOR;
405 else if (g_strcmp0(dbus_mode, "Target") == 0)
406 adapter->poll_mode = NEAR_ADAPTER_MODE_TARGET;
407 else if (g_strcmp0(dbus_mode, "Dual") == 0)
408 adapter->poll_mode = NEAR_ADAPTER_MODE_DUAL;
410 adapter->poll_mode = NEAR_ADAPTER_MODE_INITIATOR;
412 err = adapter_start_poll(adapter);
414 return __near_error_failed(msg, -err);
416 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
419 static DBusMessage *stop_poll_loop(DBusConnection *conn,
420 DBusMessage *msg, void *data)
422 struct near_adapter *adapter = data;
425 DBG("conn %p", conn);
427 if (adapter->polling == FALSE)
428 return __near_error_not_polling(msg);
430 err = __near_netlink_stop_poll(adapter->idx);
432 return __near_error_failed(msg, -err);
434 adapter->polling = FALSE;
436 polling_changed(adapter);
438 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
441 static void tag_present_cb(uint32_t adapter_idx, uint32_t target_idx,
444 static gboolean check_presence(gpointer user_data)
446 struct near_adapter *adapter = user_data;
447 struct near_tag *tag;
455 tag = adapter->tag_link;
459 err = __near_tag_check_presence(tag, tag_present_cb);
461 DBG("Could not check target presence");
468 near_adapter_disconnect(adapter->idx);
469 if (adapter->constant_poll == TRUE)
470 adapter_start_poll(adapter);
475 static void tag_present_cb(uint32_t adapter_idx, uint32_t target_idx,
478 struct near_adapter *adapter;
482 adapter = g_hash_table_lookup(adapter_hash,
483 GINT_TO_POINTER(adapter_idx));
490 near_adapter_disconnect(adapter->idx);
491 if (adapter->constant_poll == TRUE)
492 adapter_start_poll(adapter);
497 adapter->presence_timeout =
498 g_timeout_add_seconds(CHECK_PRESENCE_PERIOD,
499 check_presence, adapter);
502 void __near_adapter_start_check_presence(uint32_t adapter_idx,
505 struct near_adapter *adapter;
509 adapter = g_hash_table_lookup(adapter_hash,
510 GINT_TO_POINTER(adapter_idx));
514 adapter->presence_timeout =
515 g_timeout_add_seconds(CHECK_PRESENCE_PERIOD,
516 check_presence, adapter);
519 void __near_adapter_stop_check_presence(uint32_t adapter_idx,
522 struct near_adapter *adapter;
526 adapter = g_hash_table_lookup(adapter_hash,
527 GINT_TO_POINTER(adapter_idx));
531 if (adapter->presence_timeout > 0)
532 g_source_remove(adapter->presence_timeout);
535 static const GDBusMethodTable adapter_methods[] = {
536 { GDBUS_METHOD("GetProperties",
537 NULL, GDBUS_ARGS({"properties", "a{sv}"}),
539 { GDBUS_METHOD("SetProperty",
540 GDBUS_ARGS({"name", "s"}, {"value", "v"}),
541 NULL, set_property) },
542 { GDBUS_METHOD("StartPollLoop", GDBUS_ARGS({"name", "s"}), NULL,
544 { GDBUS_METHOD("StopPollLoop", NULL, NULL, stop_poll_loop) },
548 static const GDBusSignalTable adapter_signals[] = {
549 { GDBUS_SIGNAL("PropertyChanged",
550 GDBUS_ARGS({"name", "s"}, {"value", "v"})) },
551 { GDBUS_SIGNAL("TagFound", GDBUS_ARGS({"address", "o"})) },
552 { GDBUS_SIGNAL("TagLost", GDBUS_ARGS({"address", "o"})) },
556 struct near_adapter * __near_adapter_create(uint32_t idx,
557 const char *name, uint32_t protocols, near_bool_t powered)
559 struct near_adapter *adapter;
561 adapter = g_try_malloc0(sizeof(struct near_adapter));
565 adapter->name = g_strdup(name);
566 if (adapter->name == NULL) {
571 adapter->protocols = protocols;
572 adapter->powered = powered;
573 adapter->constant_poll = near_setting_get_bool("ConstantPoll");
574 adapter->dep_up = FALSE;
575 adapter->tags = g_hash_table_new_full(g_direct_hash, g_direct_equal,
577 adapter->tag_sock = -1;
579 adapter->devices = g_hash_table_new_full(g_direct_hash, g_direct_equal,
581 adapter->device_sock = -1;
583 adapter->path = g_strdup_printf("%s/nfc%d", NFC_PATH, idx);
588 void __near_adapter_destroy(struct near_adapter *adapter)
592 free_adapter(adapter);
595 const char *__near_adapter_get_path(struct near_adapter *adapter)
597 return adapter->path;
600 struct near_adapter *__near_adapter_get(uint32_t idx)
602 return g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
605 int __near_adapter_set_dep_state(uint32_t idx, near_bool_t dep)
607 struct near_adapter *adapter;
611 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
615 adapter->dep_up = dep;
617 if (dep == FALSE && adapter->constant_poll == TRUE)
618 adapter_start_poll(adapter);
623 target_idx = __neard_device_get_idx(adapter->device_link);
624 __near_adapter_remove_target(idx, target_idx);
626 __near_adapter_devices_changed(idx);
632 near_bool_t __near_adapter_get_dep_state(uint32_t idx)
634 struct near_adapter *adapter;
638 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
642 return adapter->dep_up;
645 int __near_adapter_add(struct near_adapter *adapter)
647 uint32_t idx = adapter->idx;
649 DBG("%s", adapter->path);
651 if (g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx)) != NULL)
654 g_hash_table_insert(adapter_hash, GINT_TO_POINTER(idx), adapter);
656 DBG("connection %p", connection);
658 g_dbus_register_interface(connection, adapter->path,
659 NFC_ADAPTER_INTERFACE,
660 adapter_methods, adapter_signals,
661 NULL, adapter, NULL);
666 void __near_adapter_remove(struct near_adapter *adapter)
668 DBG("%s", adapter->path);
670 g_dbus_unregister_interface(connection, adapter->path,
671 NFC_ADAPTER_INTERFACE);
673 g_hash_table_remove(adapter_hash, GINT_TO_POINTER(adapter->idx));
676 static void tag_read_cb(uint32_t adapter_idx, uint32_t target_idx, int status)
678 struct near_adapter *adapter;
680 DBG("status %d", status);
682 adapter = g_hash_table_lookup(adapter_hash,
683 GINT_TO_POINTER(adapter_idx));
688 near_adapter_disconnect(adapter->idx);
689 if (adapter->constant_poll == TRUE)
690 adapter_start_poll(adapter);
695 __near_adapter_tags_changed(adapter_idx);
697 adapter->presence_timeout =
698 g_timeout_add_seconds(CHECK_PRESENCE_PERIOD,
699 check_presence, adapter);
702 static void device_read_cb(uint32_t adapter_idx, uint32_t target_idx,
705 struct near_adapter *adapter;
707 DBG("status %d", status);
709 adapter = g_hash_table_lookup(adapter_hash,
710 GINT_TO_POINTER(adapter_idx));
715 if (adapter->device_link != NULL) {
716 __near_netlink_dep_link_down(adapter->idx);
717 adapter->device_link = NULL;
720 if (adapter->constant_poll == TRUE)
721 adapter_start_poll(adapter);
727 static int adapter_add_tag(struct near_adapter *adapter, uint32_t target_idx,
729 uint16_t sens_res, uint8_t sel_res,
730 uint8_t *nfcid, uint8_t nfcid_len)
732 struct near_tag *tag;
736 tag = __near_tag_add(adapter->idx, target_idx, protocols,
742 g_hash_table_insert(adapter->tags, GINT_TO_POINTER(target_idx), tag);
744 tag_type = __near_tag_get_type(tag);
746 err = near_adapter_connect(adapter->idx, target_idx, tag_type);
748 near_error("Could not connect");
752 return __near_tag_read(tag, tag_read_cb);
755 static int adapter_add_device(struct near_adapter *adapter,
757 uint8_t *nfcid, uint8_t nfcid_len)
759 struct near_device *device;
762 device = __near_device_add(adapter->idx, target_idx, nfcid, nfcid_len);
766 g_hash_table_insert(adapter->devices, GINT_TO_POINTER(target_idx),
769 /* For p2p, reading is listening for an incoming connection */
770 err = __near_device_listen(device, device_read_cb);
772 near_error("Could not read device");
776 adapter->device_link = device;
778 if (adapter->dep_up == TRUE)
781 err = __near_netlink_dep_link_up(adapter->idx, target_idx,
782 NFC_COMM_ACTIVE, NFC_RF_INITIATOR);
785 adapter->device_link = NULL;
790 int __near_adapter_add_target(uint32_t idx, uint32_t target_idx,
791 uint32_t protocols, uint16_t sens_res, uint8_t sel_res,
792 uint8_t *nfcid, uint8_t nfcid_len)
794 struct near_adapter *adapter;
798 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
802 adapter->polling = FALSE;
803 polling_changed(adapter);
805 if (protocols & NFC_PROTO_NFC_DEP_MASK)
806 return adapter_add_device(adapter, target_idx,
809 return adapter_add_tag(adapter, target_idx, protocols,
810 sens_res, sel_res, nfcid, nfcid_len);
813 int __near_adapter_remove_target(uint32_t idx, uint32_t target_idx)
815 struct near_adapter *adapter;
819 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
823 if (g_hash_table_remove(adapter->tags,
824 GINT_TO_POINTER(target_idx)) == TRUE) {
825 __near_adapter_tags_changed(idx);
830 if (g_hash_table_remove(adapter->devices,
831 GINT_TO_POINTER(target_idx)) == TRUE) {
832 __near_adapter_devices_changed(idx);
840 int __near_adapter_add_device(uint32_t idx, uint8_t *nfcid, uint8_t nfcid_len)
842 struct near_adapter *adapter;
846 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
850 adapter->polling = FALSE;
851 adapter->dep_up = TRUE;
852 polling_changed(adapter);
854 __near_adapter_devices_changed(idx);
856 return adapter_add_device(adapter, 0, nfcid, nfcid_len);
859 int __near_adapter_remove_device(uint32_t idx)
861 struct near_adapter *adapter;
862 uint32_t device_idx = 0;
866 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
870 if (g_hash_table_remove(adapter->devices,
871 GINT_TO_POINTER(device_idx)) == FALSE)
874 __near_adapter_devices_changed(idx);
876 adapter->dep_up = FALSE;
878 if (adapter->constant_poll == TRUE)
879 adapter_start_poll(adapter);
884 static void adapter_flush_rx(struct near_adapter *adapter, int error)
888 for (list = adapter->ioreq_list; list; list = list->next) {
889 struct near_adapter_ioreq *req = list->data;
894 req->cb(NULL, error, req->data);
898 g_list_free(adapter->ioreq_list);
899 adapter->ioreq_list = NULL;
902 static gboolean execute_recv_cb(gpointer user_data)
904 struct near_adapter_ioreq *req = user_data;
906 DBG("data %p", req->data);
908 req->cb(req->buf, req->len, req->data);
915 static gboolean adapter_recv_event(GIOChannel *channel, GIOCondition condition,
918 struct near_adapter *adapter = user_data;
919 struct near_adapter_ioreq *req;
923 DBG("condition 0x%x", condition);
925 if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
926 near_error("Error while reading NFC bytes");
928 adapter_flush_rx(adapter, -EIO);
930 near_adapter_disconnect(adapter->idx);
932 adapter->presence_timeout =
933 g_timeout_add_seconds(2 * CHECK_PRESENCE_PERIOD,
934 check_presence, adapter);
938 sk = g_io_channel_unix_get_fd(channel);
939 first = g_list_first(adapter->ioreq_list);
944 req->len = recv(sk, req->buf, sizeof(req->buf), 0);
946 adapter->ioreq_list = g_list_remove(adapter->ioreq_list, req);
948 g_idle_add(execute_recv_cb, req);
953 int near_adapter_connect(uint32_t idx, uint32_t target_idx, uint8_t protocol)
955 struct near_adapter *adapter;
956 struct near_tag *tag;
957 struct sockaddr_nfc addr;
962 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
966 if (adapter->tag_sock != -1)
969 tag = g_hash_table_lookup(adapter->tags,
970 GINT_TO_POINTER(target_idx));
974 sock = socket(AF_NFC, SOCK_SEQPACKET, NFC_SOCKPROTO_RAW);
978 addr.sa_family = AF_NFC;
980 addr.target_idx = target_idx;
981 addr.nfc_protocol = protocol;
983 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
989 adapter->tag_sock = sock;
990 adapter->tag_link = tag;
992 if (adapter->channel == NULL)
993 adapter->channel = g_io_channel_unix_new(adapter->tag_sock);
995 g_io_channel_set_flags(adapter->channel, G_IO_FLAG_NONBLOCK, NULL);
996 g_io_channel_set_close_on_unref(adapter->channel, TRUE);
998 if (adapter->watch == 0)
999 adapter->watch = g_io_add_watch(adapter->channel,
1000 G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
1001 adapter_recv_event, adapter);
1006 int near_adapter_disconnect(uint32_t idx)
1008 struct near_adapter *adapter;
1009 uint32_t target_idx;
1014 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
1015 if (adapter == NULL)
1018 DBG("link %p", adapter->tag_link);
1020 if (adapter->tag_link == NULL)
1023 tag_type = __near_tag_get_type(adapter->tag_link);
1024 target_idx = near_tag_get_target_idx(adapter->tag_link);
1026 DBG("tag type %d", tag_type);
1028 __near_adapter_remove_target(adapter->idx, target_idx);
1030 if (adapter->tag_sock == -1)
1033 if (adapter->watch > 0) {
1034 g_source_remove(adapter->watch);
1038 g_io_channel_unref(adapter->channel);
1039 adapter->channel = NULL;
1040 adapter->tag_sock = -1;
1041 adapter->tag_link = NULL;
1046 int near_adapter_send(uint32_t idx, uint8_t *buf, size_t length,
1047 near_recv cb, void *data, near_release data_rel)
1049 struct near_adapter *adapter;
1050 struct near_adapter_ioreq *req = NULL;
1055 adapter = g_hash_table_lookup(adapter_hash, GINT_TO_POINTER(idx));
1056 if (adapter == NULL) {
1061 if (adapter->tag_sock == -1 || adapter->tag_link == NULL) {
1066 if (cb != NULL && adapter->watch != 0) {
1067 req = g_try_malloc0(sizeof(*req));
1073 DBG("req %p cb %p data %p", req, cb, data);
1075 req->target_idx = near_tag_get_target_idx(adapter->tag_link);
1079 adapter->ioreq_list =
1080 g_list_append(adapter->ioreq_list, req);
1083 err = send(adapter->tag_sock, buf, length, 0);
1091 GList *last = g_list_last(adapter->ioreq_list);
1094 adapter->ioreq_list =
1095 g_list_delete_link(adapter->ioreq_list, last);
1098 if (data_rel != NULL)
1099 return (*data_rel)(err, data);
1104 static void adapter_listen(gpointer key, gpointer value, gpointer user_data)
1106 struct near_adapter *adapter = value;
1107 struct near_device_driver *driver = user_data;
1109 DBG("%s", adapter->path);
1111 if (adapter->path == NULL)
1114 driver->listen(adapter->idx, device_read_cb);
1117 void __near_adapter_listen(struct near_device_driver *driver)
1119 g_hash_table_foreach(adapter_hash, adapter_listen, driver);
1122 int __near_adapter_init(void)
1126 connection = near_dbus_get_connection();
1128 adapter_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1129 NULL, free_adapter);
1134 void __near_adapter_cleanup(void)
1138 g_hash_table_destroy(adapter_hash);
1139 adapter_hash = NULL;