2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
23 #ifdef TIZEN_DPM_ENABLE
24 #include "bt-service-dpm.h"
31 #include "bluetooth-api.h"
32 #include "bt-internal-types.h"
34 #include "bt-service-common.h"
35 #include "bt-service-event.h"
36 #include "bt-service-util.h"
37 #include "bt-service-obex-agent.h"
38 #include "bt-service-obex-server.h"
39 #include "bt-service-agent.h"
41 #define DBUS_TIMEOUT 20 * 1000 /* 20 Seconds */
42 #define BT_OBEX_SERVER_AGENT_PATH "/org/obex/server_agent"
44 #define BT_OBEX_SERVICE "org.bluez.obex"
45 #define BT_OBEX_MANAGER "org.bluez.obex.AgentManager1"
46 #define BT_OBEX_PATH "/org/bluez/obex"
48 #define BT_OBEX_PATH_PREFIX "/opt/usr/media"
49 #define BT_OBEX_DEFAULT_PATH "/opt/usr/home/owner/media"
50 #define BT_OBEX_PATH_MAX_LENGTH 255
66 GDBusMethodInvocation *reply_context;
73 unsigned char contact_auth_info[5];
86 bt_auth_info_t *auth_info;
87 bt_server_info_t *native_server;
88 bt_server_info_t *custom_server;
89 } bt_obex_agent_info_t;
97 static GSList *transfers;
98 static bt_obex_agent_info_t agent_info;
99 static GSList *session_list = NULL;
101 static bt_session_info_t *__bt_find_session_by_path(char *transfer_path)
104 bt_session_info_t *session;
106 retv_if(transfer_path == NULL, NULL);
108 for (l = session_list; l != NULL; l = l->next) {
114 if (g_strcmp0(session->path, transfer_path) == 0)
121 static GQuark __bt_obex_error_quark(void)
123 static GQuark quark = 0;
125 quark = g_quark_from_static_string("agent");
130 static bt_transfer_info_t *__bt_find_transfer_by_id(int transfer_id)
133 bt_transfer_info_t *transfer;
135 for (l = transfers; l != NULL; l = l->next) {
138 if (transfer == NULL)
141 if (transfer->transfer_id == transfer_id)
148 bt_transfer_info_t *__bt_find_transfer_by_address(const char *address)
152 bt_transfer_info_t *transfer;
154 retv_if(address == NULL, NULL);
156 for (l = transfers; l != NULL; l = l->next) {
159 if (transfer == NULL)
162 if (g_strcmp0(transfer->address, address) == 0)
169 static bt_transfer_info_t *__bt_find_transfer_by_path(const char *transfer_path)
172 bt_transfer_info_t *transfer;
174 retv_if(transfer_path == NULL, NULL);
176 for (l = transfers; l != NULL; l = l->next) {
179 if (transfer == NULL)
182 if (g_strcmp0(transfer->path, transfer_path) == 0)
189 static void __bt_free_server_info(bt_server_info_t *server_info)
191 ret_if(server_info == NULL);
193 g_free(server_info->sender);
194 g_free(server_info->dest_path);
198 static void __bt_free_auth_info(bt_auth_info_t *auto_info)
200 ret_if(auto_info == NULL);
202 g_free(auto_info->filename);
203 g_free(auto_info->transfer_path);
204 g_free(auto_info->device_name);
205 g_free(auto_info->address);
209 static void __bt_free_transfer_info(bt_transfer_info_t *transfer_info)
211 ret_if(transfer_info == NULL);
213 g_free(transfer_info->path);
214 g_free(transfer_info->filename);
215 g_free(transfer_info->file_path);
216 g_free(transfer_info->type);
217 g_free(transfer_info->device_name);
218 g_free(transfer_info->address);
219 g_free(transfer_info);
222 void _bt_obex_check_pending_transfer(const char *address)
225 GVariant *param = NULL;
226 bt_transfer_info_t *transfer_info = __bt_find_transfer_by_address(address);
227 if (transfer_info != NULL) {
228 int result = BLUETOOTH_ERROR_CANCEL;
229 param = g_variant_new("(issssstii)", result,
230 transfer_info->filename,
232 transfer_info->device_name,
233 transfer_info->file_path,
234 transfer_info->address,
235 transfer_info->file_size,
236 transfer_info->transfer_id,
237 agent_info.server_type);
238 _bt_send_event(BT_OPP_SERVER_EVENT,
239 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
241 transfers = g_slist_remove(transfers, transfer_info);
242 __bt_free_transfer_info(transfer_info);
247 static char *__bt_get_remote_device_name(const char *bdaddress)
249 char *device_path = NULL;
252 GVariant *result = NULL;
254 GDBusProxy *device_proxy;
255 GDBusConnection *conn;
257 retv_if(bdaddress == NULL, NULL);
259 device_path = _bt_get_device_object_path((char *)bdaddress);
260 retv_if(device_path == NULL, NULL);
262 conn = _bt_gdbus_get_system_gconn();
263 retv_if(conn == NULL, NULL);
264 BT_INFO("Device_path %s", device_path);
265 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
268 BT_PROPERTIES_INTERFACE,
272 retv_if(device_proxy == NULL, NULL);
274 result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
275 g_variant_new("(s)", BT_DEVICE_INTERFACE),
276 G_DBUS_CALL_FLAGS_NONE,
280 BT_ERR("DBus Error : %s", err->message);
284 if (result == NULL) {
285 BT_ERR("g_dbus_proxy_call_sync function return NULL");
288 g_variant_get(result, "(@a{sv})", &value);
291 GVariant *temp_value = g_variant_lookup_value(value, "Alias",
292 G_VARIANT_TYPE_STRING);
293 g_variant_get(temp_value, "s", &name);
295 g_variant_unref(temp_value);
298 DBG_SECURE("Alias Name [%s]", name);
300 temp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
301 g_variant_get(temp_value, "s", &name);
303 g_variant_unref(temp_value);
304 DBG_SECURE("Name = %s", name);
307 g_variant_unref(result);
308 g_object_unref(device_proxy);
312 static void __bt_get_remote_device_name_authinfo(const char *bdaddress,
313 char **device_name, unsigned char *auth_info)
315 char *device_path = NULL;
317 gboolean is_alias_set;
319 GVariant *result = NULL;
321 GDBusProxy *device_proxy;
322 GDBusConnection *conn;
324 ret_if(bdaddress == NULL);
326 device_path = _bt_get_device_object_path((char *)bdaddress);
327 ret_if(device_path == NULL);
329 conn = _bt_gdbus_get_system_gconn();
330 ret_if(conn == NULL);
331 BT_INFO("Device_path %s", device_path);
332 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
335 BT_PROPERTIES_INTERFACE,
339 ret_if(device_proxy == NULL);
341 result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
342 g_variant_new("(s)", BT_DEVICE_INTERFACE),
343 G_DBUS_CALL_FLAGS_NONE,
347 BT_ERR("DBus Error : %s", err->message);
351 if (result == NULL) {
352 BT_ERR("g_dbus_proxy_call_sync function return NULL");
355 g_variant_get(result, "(@a{sv})", &value);
358 GVariant *temp_value = g_variant_lookup_value(value, "Alias",
359 G_VARIANT_TYPE_STRING);
360 g_variant_get(temp_value, "s", &name);
362 g_variant_unref(temp_value);
365 DBG_SECURE("Alias Name [%s]", name);
367 temp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
368 g_variant_get(temp_value, "s", &name);
370 g_variant_unref(temp_value);
371 DBG_SECURE("Name = %s", name);
373 temp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_BOOLEAN);
375 is_alias_set = g_variant_get_boolean(temp_value);
376 g_variant_unref(temp_value);
378 is_alias_set = FALSE;
381 if (is_alias_set == FALSE)
382 __bt_get_auth_info(value, (char *)auth_info);
384 g_variant_unref(result);
385 g_object_unref(device_proxy);
387 *device_name = g_strdup(name);
392 static int __bt_get_transfer_id(const char *path)
398 tmp = strrchr(path, 'r') + 1;
399 retv_if(tmp == NULL, -1);
404 static GDBusProxy *__bt_get_transfer_proxy(const char *transfer_path)
406 GDBusConnection *conn;
410 conn = _bt_gdbus_get_session_gconn();
411 retv_if(conn == NULL, NULL);
413 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
414 NULL, BT_OBEX_SERVICE_NAME,
416 BT_OBEX_TRANSFER_INTERFACE,
420 BT_ERR("Error : %s", err->message);
428 static GDBusProxy *__bt_get_transfer_properties_proxy(const char *transfer_path)
430 GDBusConnection *conn;
433 conn = _bt_gdbus_get_session_gconn();
434 retv_if(conn == NULL, NULL);
436 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
437 NULL, BT_OBEX_SERVICE_NAME,
439 BT_PROPERTIES_INTERFACE,
442 BT_ERR("Error : %s", err->message);
449 static int __bt_get_transfer_properties(bt_transfer_info_t *transfer_info,
450 const char *transfer_path)
452 GDBusProxy *transfer_proxy;
453 GVariant *result = NULL;
455 GVariantIter *iter = NULL;
456 BT_CHECK_PARAMETER(transfer_info, return);
457 BT_CHECK_PARAMETER(transfer_path, return);
459 transfer_proxy = __bt_get_transfer_properties_proxy(transfer_path);
461 retv_if(transfer_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
463 result = g_dbus_proxy_call_sync(transfer_proxy, "GetAll",
464 g_variant_new("(s)", BT_OBEX_TRANSFER_INTERFACE),
465 G_DBUS_CALL_FLAGS_NONE,
470 BT_ERR("DBus Error : %s", err->message);
474 if (result == NULL) {
475 BT_ERR("g_dbus_proxy_call_sync function return NULL");
479 g_variant_get(result, "(a{sv})", &iter);
480 g_variant_unref(result);
485 while (g_variant_iter_loop(iter, "{sv}", &key, &val)) {
486 if (g_strcmp0(key, "Operation") == 0) {
487 transfer_info->type = g_variant_dup_string(val, &len);
488 } else if (g_strcmp0(key, "Name") == 0) {
489 transfer_info->filename = g_variant_dup_string(val, &len);
490 } else if (g_strcmp0(key, "Size") == 0) {
491 transfer_info->file_size = g_variant_get_uint64(val);
492 } else if (g_strcmp0(key, "Address") == 0) {
493 transfer_info->address = g_variant_dup_string(val, &len);
494 BT_INFO("addressss %s", transfer_info->address);
495 } else if (g_strcmp0(key, "Filename") == 0) {
496 transfer_info->file_path = g_variant_dup_string(val, &len);
497 if (!transfer_info->file_path)
498 transfer_info->file_path = g_strdup(transfer_info->filename);
501 g_variant_iter_free(iter);
503 if (transfer_info->address == NULL)
505 transfer_info->device_name = __bt_get_remote_device_name(transfer_info->address);
506 transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
507 if (!transfer_info->device_name)
508 transfer_info->device_name = g_strdup(transfer_info->address);
510 if (transfer_info->type == NULL)
513 transfer_info->path = g_strdup(transfer_path);
516 g_object_unref(transfer_proxy);
517 return BLUETOOTH_ERROR_NONE;
520 g_object_unref(transfer_proxy);
521 return BLUETOOTH_ERROR_INTERNAL;
524 static gboolean __bt_authorize_cb(GDBusMethodInvocation *context,
528 char *device_name = NULL;
529 unsigned char auth_info[5] = {0, };
530 int result = BLUETOOTH_ERROR_NONE;
531 GDBusProxy *transfer_properties_proxy;
532 char * bdaddress = NULL;
535 GVariant *param = NULL;
537 bt_session_info_t *session_info = NULL;
539 BT_DBG(" path [%s] \n", path);
541 transfer_properties_proxy = __bt_get_transfer_properties_proxy(path);
543 retv_if(transfer_properties_proxy == NULL, FALSE);
545 ret = g_dbus_proxy_call_sync(transfer_properties_proxy, "GetAll",
546 g_variant_new("(s)", BT_OBEX_TRANSFER_INTERFACE),
547 G_DBUS_CALL_FLAGS_NONE,
551 BT_ERR("DBus Error : %s", err->message);
556 BT_ERR("g_dbus_proxy_call_sync function return NULL");
559 g_variant_get(ret, "(a{sv})", &iter);
560 g_variant_unref(ret);
562 g_object_unref(transfer_properties_proxy);
566 __bt_free_auth_info(agent_info.auth_info);
568 agent_info.auth_info = g_malloc(sizeof(bt_auth_info_t));
570 memset(agent_info.auth_info, 0, sizeof(bt_auth_info_t));
572 agent_info.auth_info->reply_context = context;
574 agent_info.auth_info->transfer_path = g_strdup(path);
576 #ifdef TIZEN_DPM_ENABLE
577 if (_bt_dpm_get_allow_bluetooth_mode() == DPM_BT_HANDSFREE_ONLY) {
578 /* Free auth info in next function */
579 _bt_obex_server_reject_authorize();
587 while (g_variant_iter_loop(iter, "{sv}", &key, &val)) {
588 if (g_strcmp0(key, "Name") == 0)
589 agent_info.auth_info->filename = g_variant_dup_string(val, &len);
590 else if (g_strcmp0(key, "Address") == 0)
591 bdaddress = g_variant_dup_string(val, &len);
592 else if (g_strcmp0(key, "Size") == 0)
593 agent_info.auth_info->file_size = g_variant_get_uint64(val);
595 g_variant_iter_free(iter);
598 __bt_get_remote_device_name_authinfo(bdaddress, &device_name, auth_info);
601 device_name = g_strdup(bdaddress);
603 agent_info.auth_info->address = g_strdup(bdaddress);
604 agent_info.auth_info->device_name = device_name;
605 memcpy(agent_info.auth_info->contact_auth_info, auth_info, 5);
607 session_info = __bt_find_session_by_path((char *)path);
608 if (NULL == session_info) {
609 session_info = g_malloc0(sizeof(bt_session_info_t));
610 session_info->path = g_strdup(path);
611 session_info->address = g_strdup(bdaddress);
612 session_info->authorized = FALSE;
613 session_list = g_slist_append(session_list, session_info);
616 g_object_unref(transfer_properties_proxy);
619 if (agent_info.server_type == BT_CUSTOM_SERVER) {
620 /* No need to send the event */
621 _bt_obex_server_accept_authorize(agent_info.auth_info->filename, FALSE);
625 if (session_info->authorized == FALSE) {
626 _bt_launch_system_popup(BT_AGENT_EVENT_EXCHANGE_REQUEST, device_name,
627 auth_info, NULL, NULL, BT_OBEX_SERVER_AGENT_PATH);
629 param = g_variant_new("(istss)", result,
630 agent_info.auth_info->filename,
631 agent_info.auth_info->file_size,
632 agent_info.auth_info->address,
633 agent_info.auth_info->device_name);
634 _bt_send_event(BT_OPP_SERVER_EVENT,
635 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE, param);
641 void _bt_obex_transfer_started(const char *transfer_path)
643 bt_transfer_info_t *transfer_info;
644 request_info_t *req_info;
645 GVariant *out_param1 = NULL;
646 GVariant *param = NULL;
647 GVariantBuilder *builder = NULL;
648 int result = BLUETOOTH_ERROR_NONE;
651 BT_DBG("%s", transfer_path);
653 transfer_info = g_malloc0(sizeof(bt_transfer_info_t));
655 if (agent_info.auth_info != NULL
656 && g_strcmp0(transfer_path, agent_info.auth_info->transfer_path) == 0) {
657 transfer_info->filename = g_strdup(agent_info.auth_info->filename);
658 transfer_info->file_size = agent_info.auth_info->file_size;
659 transfer_info->type = g_strdup(TRANSFER_PUT);
660 transfer_info->path = g_strdup(agent_info.auth_info->transfer_path);
661 transfer_info->device_name = g_strdup(agent_info.auth_info->device_name);
662 transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
663 transfer_info->file_path = agent_info.auth_info->file_path;
664 transfer_info->address = g_strdup(agent_info.auth_info->address);
667 if (__bt_get_transfer_properties(transfer_info, transfer_path) < 0) {
668 BT_ERR("Get Properties failed");
669 __bt_free_transfer_info(transfer_info);
672 agent_info.server_type = BT_FTP_SERVER;
675 if (agent_info.server_type == BT_CUSTOM_SERVER) {
676 if (agent_info.custom_server == NULL) {
677 __bt_free_transfer_info(transfer_info);
678 __bt_free_auth_info(agent_info.auth_info);
679 agent_info.auth_info = NULL;
683 req_info = _bt_get_request_info(agent_info.accept_id);
684 if (req_info == NULL || req_info->context == NULL) {
685 BT_ERR("info is NULL");
689 agent_info.accept_id = 0;
690 result = BLUETOOTH_ERROR_NONE;
691 GArray *g_out_param1 = NULL;
692 g_out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
693 if (out_param1 == NULL) {
694 out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
695 g_out_param1->data, g_out_param1->len,
699 g_dbus_method_invocation_return_value(req_info->context,
700 g_variant_new("(iv)", result, out_param1));
701 g_array_free(g_out_param1, TRUE);
702 _bt_delete_request_list(req_info->req_id);
705 transfers = g_slist_append(transfers, transfer_info);
707 BT_DBG("Transfer id %d", transfer_info->transfer_id);
709 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
710 for (i = 0; i < 5; i++) {
711 if (agent_info.auth_info)
712 g_variant_builder_add(builder, "y", agent_info.auth_info->contact_auth_info[i]);
715 param = g_variant_new("(isssstii(ay))", result,
716 transfer_info->device_name,
717 transfer_info->filename,
719 transfer_info->address,
720 transfer_info->file_size,
721 transfer_info->transfer_id,
722 agent_info.server_type,
725 __bt_free_auth_info(agent_info.auth_info);
726 agent_info.auth_info = NULL;
728 g_variant_builder_unref(builder);
730 _bt_send_event(BT_OPP_SERVER_EVENT,
731 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
735 void _bt_obex_transfer_progress(const char *transfer_path,
739 bt_transfer_info_t *transfer_info;
740 int current_progress = 0;
741 int previous_progress;
742 GVariant *param = NULL;
743 int result = BLUETOOTH_ERROR_NONE;
745 transfer_info = __bt_find_transfer_by_path(transfer_path);
746 ret_if(transfer_info == NULL);
748 current_progress = (int)(((gdouble)transferred /
749 (gdouble)transfer_info->file_size) * 100);
751 previous_progress = (int)(((gdouble)transfer_info->progress /
752 (gdouble)transfer_info->file_size) * 100);
754 if (current_progress == previous_progress) {
755 BT_DBG("Same Percentage Value: Do not emit Signal");
759 transfer_info->progress = transferred;
760 param = g_variant_new("(isssstiii)", result,
761 transfer_info->filename,
763 transfer_info->device_name,
764 transfer_info->address,
765 transfer_info->file_size,
766 transfer_info->transfer_id,
768 agent_info.server_type);
769 _bt_send_event(BT_OPP_SERVER_EVENT,
770 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
775 void _bt_obex_transfer_completed(const char *transfer_path, gboolean success)
777 bt_transfer_info_t *transfer_info;
778 GVariantBuilder *builder = NULL;
779 GVariant *param = NULL;
782 BT_DBG("Transfer [%s] Success [%d] \n", transfer_path, success);
784 result = (success == TRUE) ? BLUETOOTH_ERROR_NONE
785 : BLUETOOTH_ERROR_CANCEL;
787 transfer_info = __bt_find_transfer_by_path(transfer_path);
789 if (transfer_info == NULL) {
790 BT_DBG("Very small files receiving case, did not get Active status from obexd");
791 if (agent_info.auth_info == NULL ||
792 g_strcmp0(transfer_path,
793 agent_info.auth_info->transfer_path) != 0) {
794 BT_ERR("auth_info is NULL, returning");
798 transfer_info = g_new0(bt_transfer_info_t, 1);
800 transfer_info->filename = g_strdup(agent_info.auth_info->filename);
801 transfer_info->file_size = agent_info.auth_info->file_size;
802 transfer_info->type = g_strdup(TRANSFER_PUT);
803 transfer_info->path = g_strdup(agent_info.auth_info->transfer_path);
804 transfer_info->device_name = g_strdup(agent_info.auth_info->device_name);
805 transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
806 transfer_info->file_path = agent_info.auth_info->file_path;
807 transfer_info->address = g_strdup(agent_info.auth_info->address);
809 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
810 for (i = 0; i < 5; i++)
811 g_variant_builder_add(builder, "y", agent_info.auth_info->contact_auth_info[i]);
813 param = g_variant_new("(isssstii(ay))", result,
814 transfer_info->filename,
816 transfer_info->device_name,
817 transfer_info->address,
818 transfer_info->file_size,
819 transfer_info->transfer_id,
820 agent_info.server_type,
822 _bt_send_event(BT_OPP_SERVER_EVENT,
823 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
825 g_variant_builder_unref(builder);
827 param = g_variant_new("(issssstii)", result,
828 transfer_info->filename,
830 transfer_info->device_name,
831 transfer_info->file_path,
832 transfer_info->address,
833 transfer_info->file_size,
834 transfer_info->transfer_id,
835 agent_info.server_type);
836 _bt_send_event(BT_OPP_SERVER_EVENT,
837 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
839 transfers = g_slist_remove(transfers, transfer_info);
840 __bt_free_transfer_info(transfer_info);
843 void _bt_obex_transfer_connected(const char *obj_path)
847 int result = BLUETOOTH_ERROR_NONE;
848 GVariant *param = NULL;
849 bt_transfer_info_t *transfer_info = NULL;
851 transfer_info = g_new0(bt_transfer_info_t, 1);
852 __bt_get_transfer_properties(transfer_info, obj_path);
853 INFO_SECURE("Address[%s] Name[%s] TransferID[%d] ", transfer_info->address,
854 transfer_info->device_name, transfer_info->transfer_id);
856 param = g_variant_new("(issi)", result, transfer_info->address,
857 transfer_info->device_name, transfer_info->transfer_id);
859 _bt_send_event(BT_OPP_SERVER_EVENT,
860 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
863 __bt_free_transfer_info(transfer_info);
867 void _bt_obex_transfer_disconnected(char * obj_path)
871 int result = BLUETOOTH_ERROR_NONE;
872 GVariant *param = NULL;
873 bt_session_info_t *session = NULL;
874 int transfer_id = -1;
876 session = __bt_find_session_by_path(obj_path);
877 ret_if(session == NULL);
879 transfer_id = __bt_get_transfer_id(obj_path);
880 DBG_SECURE("transfer_id: [%d]", transfer_id);
882 DBG_SECURE("%s", session->address);
883 param = g_variant_new("(isi)", result, session->address, transfer_id);
884 _bt_send_event(BT_OPP_SERVER_EVENT,
885 BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
887 session_list = g_slist_remove(session_list, session);
888 g_free(session->address);
889 g_free(session->path);
894 int _bt_register_obex_server(void)
896 GDBusConnection *g_conn;
897 GDBusProxy *manager_proxy;
898 GVariant *result = NULL;
899 GError *g_error = NULL;
901 /* Get the session bus. */
902 g_conn = _bt_gdbus_get_session_gconn();
903 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
905 _bt_obex_agent_new(BT_OBEX_SERVER_AGENT_PATH);
907 _bt_obex_setup(BT_OBEX_SERVER_AGENT_PATH);
909 _bt_obex_set_authorize_cb(BT_OBEX_SERVER_AGENT_PATH,
910 __bt_authorize_cb, NULL);
912 manager_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
913 NULL, BT_OBEX_SERVICE,
918 if (manager_proxy == NULL)
919 return BLUETOOTH_ERROR_INTERNAL;
921 result = g_dbus_proxy_call_sync(manager_proxy, "RegisterAgent",
922 g_variant_new("(o)", BT_OBEX_SERVER_AGENT_PATH),
923 G_DBUS_CALL_FLAGS_NONE,
927 if (g_error != NULL) {
928 BT_ERR("Agent registration failed: %s\n", g_error->message);
929 g_object_unref(manager_proxy);
930 g_error_free(g_error);
931 return BLUETOOTH_ERROR_INTERNAL;
935 g_variant_unref(result);
937 agent_info.proxy = manager_proxy;
939 return BLUETOOTH_ERROR_NONE;
942 int _bt_unregister_obex_server(void)
944 GVariant *result = NULL;
945 GError *g_error = NULL;
947 retv_if(agent_info.proxy == NULL,
948 BLUETOOTH_ERROR_INTERNAL);
950 result = g_dbus_proxy_call_sync(agent_info.proxy, "UnregisterAgent",
951 g_variant_new("(o)", BT_OBEX_SERVER_AGENT_PATH),
952 G_DBUS_CALL_FLAGS_NONE,
955 if (g_error != NULL) {
956 BT_ERR("Agent unregistration failed: %s", g_error->message);
957 g_error_free(g_error);
961 g_variant_unref(result);
963 _bt_obex_agent_destroy(BT_OBEX_SERVER_AGENT_PATH);
964 g_object_unref(agent_info.proxy);
965 agent_info.proxy = NULL;
967 return BLUETOOTH_ERROR_NONE;
970 gboolean __bt_check_folder_path(const char *dest_path)
974 retv_if(dest_path == NULL, FALSE);
976 dp = opendir(dest_path);
979 BT_ERR("The directory does not exist");
988 char *__bt_transfer_folder_path(char *dest_path)
990 char *dst_path = (char *)g_malloc0(BT_OBEX_PATH_MAX_LENGTH);
991 if (g_str_has_prefix(dest_path, BT_OBEX_PATH_PREFIX))
992 snprintf(dst_path, BT_OBEX_PATH_MAX_LENGTH, BT_OBEX_DEFAULT_PATH"%s", dest_path + strlen(BT_OBEX_PATH_PREFIX));
994 snprintf(dst_path, BT_OBEX_PATH_MAX_LENGTH, "%s", dest_path);
996 BT_INFO("obex transfed path : %s", dst_path);
1000 int _bt_obex_server_allocate(char *sender, const char *dest_path, int app_pid, gboolean is_native)
1005 dst_path = __bt_transfer_folder_path((char *)dest_path);
1007 if (__bt_check_folder_path(dst_path) == FALSE) {
1009 return BLUETOOTH_ERROR_INVALID_PARAM;
1012 if (is_native == TRUE) {
1013 if (agent_info.native_server) {
1014 BT_ERR("obex native server busy");
1016 return BLUETOOTH_ERROR_DEVICE_BUSY;
1019 /* Force to change the control to native */
1020 agent_info.native_server = g_malloc0(sizeof(bt_server_info_t));
1021 agent_info.native_server->dest_path = g_strdup(dst_path);
1022 agent_info.native_server->sender = g_strdup(sender);
1023 agent_info.native_server->app_pid = app_pid;
1024 agent_info.server_type = BT_NATIVE_SERVER;
1025 _bt_unregister_osp_server_in_agent(BT_OBEX_SERVER, NULL);
1027 if (agent_info.custom_server) {
1028 BT_ERR("obex custom server busy");
1030 return BLUETOOTH_ERROR_DEVICE_BUSY;
1033 /* Force to change the control to custom */
1034 agent_info.custom_server = g_malloc0(sizeof(bt_server_info_t));
1035 agent_info.custom_server->dest_path = g_strdup(dst_path);
1036 agent_info.custom_server->sender = g_strdup(sender);
1037 agent_info.custom_server->app_pid = app_pid;
1038 agent_info.server_type = BT_CUSTOM_SERVER;
1039 _bt_register_osp_server_in_agent(BT_OBEX_SERVER, NULL, NULL, -1);
1044 return BLUETOOTH_ERROR_NONE;
1047 int _bt_obex_server_deallocate(int app_pid, gboolean is_native)
1049 if (is_native == TRUE) {
1050 retv_if(agent_info.native_server == NULL,
1051 BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST);
1053 retv_if(agent_info.native_server->app_pid != app_pid,
1054 BLUETOOTH_ERROR_ACCESS_DENIED);
1056 __bt_free_server_info(agent_info.native_server);
1057 agent_info.native_server = NULL;
1059 /* Change the control to custom */
1060 if (agent_info.custom_server) {
1061 agent_info.server_type = BT_CUSTOM_SERVER;
1062 _bt_register_osp_server_in_agent(BT_OBEX_SERVER,
1066 retv_if(agent_info.custom_server == NULL,
1067 BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST);
1069 retv_if(agent_info.custom_server->app_pid != app_pid,
1070 BLUETOOTH_ERROR_ACCESS_DENIED);
1072 __bt_free_server_info(agent_info.custom_server);
1073 agent_info.custom_server = NULL;
1075 _bt_unregister_osp_server_in_agent(BT_OBEX_SERVER, NULL);
1077 /* Change the control to native */
1078 if (agent_info.native_server)
1079 agent_info.server_type = BT_NATIVE_SERVER;
1082 return BLUETOOTH_ERROR_NONE;
1085 int _bt_obex_server_accept_authorize(const char *filename, gboolean is_native)
1087 char file_path[BT_FILE_PATH_MAX] = { 0 };
1088 bt_server_info_t *server_info;
1090 BT_CHECK_PARAMETER(filename, return);
1092 retv_if(agent_info.auth_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1094 retv_if(agent_info.auth_info->reply_context == NULL,
1095 BLUETOOTH_ERROR_INTERNAL);
1097 if (is_native == TRUE)
1098 server_info = agent_info.native_server;
1100 server_info = agent_info.custom_server;
1102 retv_if(server_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1104 if (server_info->dest_path != NULL)
1105 snprintf(file_path, sizeof(file_path), "%s/%s",
1106 server_info->dest_path, filename);
1108 snprintf(file_path, sizeof(file_path), "%s", filename);
1110 g_dbus_method_invocation_return_value(agent_info.auth_info->reply_context,
1111 g_variant_new("(s)", &file_path));
1112 agent_info.auth_info->reply_context = NULL;
1113 agent_info.auth_info->file_path = g_strdup(file_path);
1114 g_free(agent_info.auth_info->filename);
1115 agent_info.auth_info->filename = g_strdup(filename);
1117 return BLUETOOTH_ERROR_NONE;
1120 void _bt_obex_server_reply_accept(void)
1122 GVariant *param = NULL;
1123 bt_session_info_t *session_info = NULL;
1124 int result = BLUETOOTH_ERROR_NONE;
1125 param = g_variant_new("(istss)", result,
1126 agent_info.auth_info->filename,
1127 agent_info.auth_info->file_size,
1128 agent_info.auth_info->address,
1129 agent_info.auth_info->device_name);
1130 BT_INFO("Send Obex Authorize");
1131 _bt_send_event(BT_OPP_SERVER_EVENT, BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE, param);
1133 session_info = __bt_find_session_by_path(agent_info.auth_info->transfer_path);
1135 if (NULL == session_info)
1136 BT_ERR("Couldn't get the session info from the list");
1138 session_info->authorized = TRUE;
1141 int _bt_obex_server_reject_authorize(void)
1145 retv_if(agent_info.auth_info->reply_context == NULL,
1146 BLUETOOTH_ERROR_INTERNAL);
1148 g_error = g_error_new(__bt_obex_error_quark(),
1149 BT_OBEX_AGENT_ERROR_CANCEL,
1152 g_dbus_method_invocation_return_gerror(agent_info.auth_info->reply_context,
1154 g_error_free(g_error);
1156 __bt_free_auth_info(agent_info.auth_info);
1157 agent_info.auth_info = NULL;
1159 return BLUETOOTH_ERROR_NONE;
1162 int _bt_obex_server_set_destination_path(const char *dest_path,
1165 bt_server_info_t *server_info;
1166 BT_CHECK_PARAMETER(dest_path, return);
1169 dst_path = __bt_transfer_folder_path((char *)dest_path);
1173 dp = opendir(dst_path);
1176 BT_ERR("The directory does not exist");
1178 return BLUETOOTH_ERROR_INVALID_PARAM;
1183 if (is_native == TRUE)
1184 server_info = agent_info.native_server;
1186 server_info = agent_info.custom_server;
1189 BT_ERR("obex server info is NULL");
1191 return BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST;
1194 g_free(server_info->dest_path);
1195 server_info->dest_path = g_strdup(dst_path);
1198 return BLUETOOTH_ERROR_NONE;
1201 int _bt_obex_server_set_root(const char *root)
1203 GVariant *result = NULL;
1204 GError *g_error = NULL;
1205 GVariant *folder = NULL;
1206 char *string = "Root";
1209 BT_CHECK_PARAMETER(root, return);
1212 dst_root = __bt_transfer_folder_path((char *)root);
1214 if (!agent_info.proxy) {
1215 BT_ERR("obex agent_info proxy error");
1217 return BLUETOOTH_ERROR_INTERNAL;
1220 dp = opendir(dst_root);
1223 BT_ERR("The directory does not exist");
1225 return BLUETOOTH_ERROR_INVALID_PARAM;
1230 folder = g_variant_new_string(dst_root);
1231 result = g_dbus_proxy_call_sync(agent_info.proxy, "SetProperty",
1232 g_variant_new("(sv)", string, folder),
1233 G_DBUS_CALL_FLAGS_NONE,
1238 BT_ERR("SetProperty Fail: %s", g_error->message);
1239 g_error_free(g_error);
1241 return BLUETOOTH_ERROR_INTERNAL;
1245 g_variant_unref(result);
1248 return BLUETOOTH_ERROR_NONE;
1251 int _bt_obex_server_cancel_transfer(int transfer_id)
1253 bt_transfer_info_t *transfer = NULL;
1255 GVariant *result = NULL;
1258 transfer = __bt_find_transfer_by_id(transfer_id);
1260 retv_if(transfer == NULL, BLUETOOTH_ERROR_NOT_FOUND);
1261 proxy = __bt_get_transfer_proxy(transfer->path);
1263 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1265 result = g_dbus_proxy_call_sync(proxy, "Cancel", NULL,
1266 G_DBUS_CALL_FLAGS_NONE,
1267 DBUS_TIMEOUT, NULL, &err);
1269 BT_ERR("Dbus Err: %s", err->message);
1270 g_clear_error(&err);
1273 g_object_unref(proxy);
1276 g_variant_unref(result);
1278 return BLUETOOTH_ERROR_NONE;
1281 int _bt_obex_server_cancel_all_transfers(void)
1284 bt_transfer_info_t *transfer;
1286 for (l = transfers; l != NULL; l = l->next) {
1289 if (transfer == NULL)
1292 _bt_obex_server_cancel_transfer(transfer->transfer_id);
1295 return BLUETOOTH_ERROR_NONE;
1298 int _bt_obex_server_is_activated(gboolean *activated)
1300 BT_CHECK_PARAMETER(activated, return);
1302 if (agent_info.custom_server)
1307 return BLUETOOTH_ERROR_NONE;
1310 int _bt_obex_server_check_allocation(gboolean *allocation)
1312 BT_CHECK_PARAMETER(allocation, return);
1314 if (agent_info.native_server || agent_info.custom_server)
1317 *allocation = FALSE;
1319 return BLUETOOTH_ERROR_NONE;
1322 int _bt_obex_server_check_termination(char *sender)
1324 BT_CHECK_PARAMETER(sender, return);
1326 if (agent_info.native_server) {
1327 if (g_strcmp0(sender, agent_info.native_server->sender) == 0) {
1328 _bt_obex_server_deallocate(agent_info.native_server->app_pid,
1333 if (agent_info.custom_server) {
1334 if (g_strcmp0(sender, agent_info.custom_server->sender) == 0) {
1335 _bt_obex_server_deallocate(agent_info.custom_server->app_pid,
1340 return BLUETOOTH_ERROR_NONE;
1343 int _bt_obex_server_is_receiving(gboolean *receiving)
1345 BT_CHECK_PARAMETER(receiving, return);
1347 if (transfers == NULL || g_slist_length(transfers) == 0)
1352 return BLUETOOTH_ERROR_NONE;
1355 gboolean __bt_obex_server_accept_timeout_cb(gpointer user_data)
1357 request_info_t *req_info;
1358 GVariant *out_param1 = NULL;
1359 int result = BLUETOOTH_ERROR_TIMEOUT;
1361 /* Already reply in _bt_obex_transfer_started */
1362 retv_if(agent_info.accept_id == 0, FALSE);
1364 req_info = _bt_get_request_info(agent_info.accept_id);
1365 if (req_info == NULL || req_info->context == NULL) {
1366 BT_ERR("info is NULL");
1370 agent_info.accept_id = 0;
1371 GArray *g_out_param1 = NULL;
1372 g_out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
1373 if (out_param1 == NULL) {
1374 out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
1375 g_out_param1->data, g_out_param1->len,
1379 g_dbus_method_invocation_return_value(req_info->context,
1380 g_variant_new("(iv)", result, out_param1));
1381 g_array_free(g_out_param1, TRUE);
1382 _bt_delete_request_list(req_info->req_id);
1387 /* To support the BOT */
1388 int _bt_obex_server_accept_connection(int request_id)
1390 if (!_bt_agent_reply_authorize(TRUE))
1391 return BLUETOOTH_ERROR_INTERNAL;
1393 agent_info.accept_id = request_id;
1395 g_timeout_add(BT_SERVER_ACCEPT_TIMEOUT,
1396 (GSourceFunc)__bt_obex_server_accept_timeout_cb,
1399 return BLUETOOTH_ERROR_NONE;
1402 /* To support the BOT */
1403 int _bt_obex_server_reject_connection(void)
1405 if (!_bt_agent_reply_authorize(FALSE))
1406 return BLUETOOTH_ERROR_INTERNAL;
1408 return BLUETOOTH_ERROR_NONE;
1411 int _bt_opp_get_server_progress(int transfer_id, guint8 *progress)
1413 bt_transfer_info_t *requested_transfer = NULL;
1414 requested_transfer = __bt_find_transfer_by_id(transfer_id);
1415 if (requested_transfer == NULL) {
1416 BT_ERR("No Matching Inbound transfer");
1417 return BLUETOOTH_ERROR_NOT_FOUND;
1420 *progress = (int)(((double)requested_transfer->progress /
1421 requested_transfer->file_size) * 100);
1423 BT_DBG("Percentage: %d", *progress);
1424 return BLUETOOTH_ERROR_NONE;