plugin/wpasupplicant/ctrl_iface_dbus/wfd-plugin-wpasupplicant.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct wpasupplicant dbus plugin functions.
  22  *
  23  * @file                wfd-plugin-dbus-wpasupplicant.c
  24  * @author      Jiung Yu (jiung.yu@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <sys/types.h>
  32 #include <sys/wait.h>
  33 #include <sys/socket.h>
  34 #include <sys/un.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #define _GNU_SOURCE
  38 #include <poll.h>
  39 #include <errno.h>
  40 #include <sys/ioctl.h>
  41 #include <net/if.h>
  42
  43 #include <glib.h>
  44 #include <gio/gio.h>
  45
  46 #include <tzplatform_config.h>
  47
  48 #include "wifi-direct-oem.h"
  49 #include "wfd-plugin-log.h"
  50 #include "wfd-plugin-wpasupplicant.h"
  51 #include "dbus/wfd-plugin-supplicant-dbus.h"
  52
  53 #if defined(TIZEN_FEATURE_ASP)
  54 #define GLIST_ITER_START(arg_list, elem)\
  55         GList *temp = NULL;\
  56         temp = g_list_first(arg_list);\
  57         while (temp) {\
  58                 elem = temp->data;\
  59                 temp = g_list_next(temp);\
  60
  61 #define GLIST_ITER_END() }
  62 #endif
  63
  64 #define NETCONFIG_SERVICE "net.netconfig"
  65 #define NETCONFIG_WIFI_INTERFACE "net.netconfig.wifi"
  66 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
  67
  68 #define NETCONFIG_DBUS_REPLY_TIMEOUT (10 * 1000)
  69
  70 #if defined TIZEN_MOBILE
  71 #define DEFAULT_MAC_FILE_PATH tzplatform_mkpath(TZ_SYS_ETC, ".mac.info")
  72 #endif
  73
  74 #if defined TIZEN_WIFI_MODULE_BUNDLE
  75 #define DEFAULT_MAC_FILE_PATH "/sys/class/net/wlan0/address"
  76 #endif
  77
  78 #ifndef DEFAULT_MAC_FILE_PATH
  79 #define DEFAULT_MAC_FILE_PATH "/sys/class/net/p2p0/address"
  80 #endif
  81
  82 static wfd_oem_ops_s supplicant_ops = {
  83         .init = ws_init,
  84         .deinit = ws_deinit,
  85         .activate = ws_activate,
  86         .deactivate = ws_deactivate,
  87
  88         .start_scan = ws_start_scan,
  89         .stop_scan = ws_stop_scan,
  90         .get_visibility = ws_get_visibility,
  91         .set_visibility = ws_set_visibility,
  92         .get_scan_result = ws_get_scan_result,
  93         .get_peer_info = ws_get_peer_info,
  94
  95         .prov_disc_req = ws_prov_disc_req,
  96
  97         .connect = ws_connect,
  98         .disconnect = ws_disconnect,
  99         .reject_connection = ws_reject_connection,
 100         .cancel_connection = ws_cancel_connection,
 101
 102         .get_connected_peers = ws_get_connected_peers,
 103         .get_pin = ws_get_pin,
 104         .set_pin = ws_set_pin,
 105         .generate_pin = ws_generate_pin,
 106         .get_supported_wps_mode = ws_get_supported_wps_mode,
 107
 108         .create_group = ws_create_group,
 109         .destroy_group = ws_destroy_group,
 110         .invite = ws_invite,
 111         .wps_start = ws_wps_start,
 112         .enrollee_start = ws_enrollee_start,
 113         .wps_cancel = ws_wps_cancel,
 114
 115         .get_dev_name = ws_get_dev_name,
 116         .set_dev_name = ws_set_dev_name,
 117         .get_dev_mac = ws_get_dev_mac,
 118         .get_dev_type = ws_get_dev_type,
 119         .set_dev_type = ws_set_dev_type,
 120         .get_go_intent = ws_get_go_intent,
 121         .set_go_intent = ws_set_go_intent,
 122         .set_country = ws_set_country,
 123         .get_persistent_groups = ws_get_persistent_groups,
 124         .remove_persistent_group = ws_remove_persistent_group,
 125         .set_persistent_reconnect = ws_set_persistent_reconnect,
 126
 127 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 128         .start_service_discovery = ws_start_service_discovery,
 129         .cancel_service_discovery = ws_cancel_service_discovery,
 130
 131         .serv_add = ws_serv_add,
 132         .serv_del = ws_serv_del,
 133 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 134
 135 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 136         .miracast_init = ws_miracast_init,
 137         .set_display = ws_set_display,
 138 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 139
 140         .refresh = ws_refresh,
 141         .save_config =  ws_save_config,
 142         .set_operating_channel = ws_set_operating_channel,
 143         .remove_all_network = ws_remove_all_network,
 144         .get_wpa_status = ws_get_wpa_status,
 145
 146 #if defined(TIZEN_FEATURE_ASP)
 147         .advertise_service = ws_advertise_service,
 148         .cancel_advertise_service = ws_cancel_advertise_service,
 149         .seek_service = ws_seek_service,
 150         .cancel_seek_service = ws_cancel_seek_service,
 151         .asp_prov_disc_req = ws_asp_prov_disc_req,
 152 #endif /* TIZEN_FEATURE_ASP */
 153         };
 154
 155 static ws_dbus_plugin_data_s *g_pd;
 156
 157 static int is_peer_joined_notified = 0;
 158 static int is_peer_disconnected_notified = 0;
 159
 160 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 161 static GList *service_list;
 162 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 163
 164 static GList *seek_list;
 165
 166 static void _supplicant_signal_cb(GDBusConnection *connection,
 167                 const gchar *sender, const gchar *object_path, const gchar *interface,
 168                 const gchar *signal, GVariant *parameters, gpointer user_data);
 169
 170 static void _p2pdevice_signal_cb(GDBusConnection *connection,
 171                 const gchar *sender, const gchar *object_path, const gchar *interface,
 172                 const gchar *signal, GVariant *parameters, gpointer user_data);
 173
 174 static void _group_signal_cb(GDBusConnection *connection,
 175                 const gchar *sender, const gchar *object_path, const gchar *interface,
 176                 const gchar *signal, GVariant *parameters, gpointer user_data);
 177
 178 static void _interface_signal_cb(GDBusConnection *connection,
 179                 const gchar *sender, const gchar *object_path, const gchar *interface,
 180                 const gchar *signal, GVariant *parameters, gpointer user_data);
 181
 182 static int __ws_txt_to_mac(unsigned char *txt, unsigned char *mac)
 183 {
 184         int i = 0;
 185
 186         if (!txt || !mac) {
 187                 WDP_LOGE("Invalid parameter");
 188                 return -1;
 189         }
 190
 191         for (;;) {
 192                 mac[i++] = (char) strtoul((char *)txt, (char **)&txt, 16);
 193                 if (!*txt++ || i == 6)
 194                         break;
 195         }
 196
 197         if (i != WS_MACADDR_LEN)
 198                 return -1;
 199
 200         WDP_LOGD("Converted MAC address [" MACSECSTR "]", MAC2SECSTR(mac));
 201         return 0;
 202 }
 203
 204 static int __ws_mac_compact_to_normal(char *compact, unsigned char *mac)
 205 {
 206         g_snprintf((char *)mac, OEM_MACSTR_LEN, "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
 207                         compact[0], compact[1], compact[2], compact[3],
 208                         compact[4], compact[5], compact[6], compact[7],
 209                         compact[8], compact[9], compact[10], compact[11]);
 210         return 0;
 211 }
 212
 213 static char *__ws_wps_to_txt(int wps_mode)
 214 {
 215         switch (wps_mode) {
 216         case WFD_OEM_WPS_MODE_PBC:
 217                 return WS_DBUS_STR_PBC;
 218                 break;
 219         case WFD_OEM_WPS_MODE_DISPLAY:
 220                 return WS_DBUS_STR_DISPLAY;
 221                 break;
 222         case WFD_OEM_WPS_MODE_KEYPAD:
 223                 return WS_DBUS_STR_KEYPAD;
 224                 break;
 225 #if defined(TIZEN_FEATURE_ASP)
 226         case WFD_OEM_WPS_MODE_NONE:
 227         case WFD_OEM_WPS_MODE_P2PS:
 228                 return WS_DBUS_STR_P2PS;
 229 #endif /* TIZEN_FEATURE_ASP */
 230         default:
 231                 return "";
 232                 break;
 233         }
 234 }
 235 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 236 static int __ws_byte_to_hex(char *buf, int buf_size, unsigned char *data, int data_len)
 237 {
 238         int i;
 239         char *pos = buf;
 240         char *end = buf + buf_size;
 241         int ret;
 242         if (buf_size == 0)
 243                 return 0;
 244         for (i = 0; i < data_len; i++) {
 245                 ret = snprintf(pos, end - pos, "%02x", data[i]);
 246                 if (ret < 0 || ret >= end - pos) {
 247                         end[-1] = '\0';
 248                         return pos - buf;
 249                 }
 250                 pos += ret;
 251         }
 252         end[-1] = '\0';
 253         return pos - buf;
 254 }
 255
 256 static int __ws_hex_to_num(char *src, int len)
 257 {
 258         char *temp = NULL;
 259         int num = 0;
 260
 261         if (!src || len < 0) {
 262                 WDP_LOGE("Invalid parameter");
 263                 return -1;
 264         }
 265
 266         temp = (char*) g_try_malloc0(len+1);
 267         if (!temp) {
 268                 WDP_LOGE("Failed to allocate memory");
 269                 return -1;
 270         }
 271
 272         memcpy(temp, src, len);
 273         num = strtoul(temp, NULL, 16);
 274         g_free(temp);
 275
 276         return num;
 277 }
 278
 279 static int __ws_segment_to_service(char *segment, wfd_oem_new_service_s **service)
 280 {
 281         wfd_oem_new_service_s *serv_tmp = NULL;
 282         char *ptr = NULL;
 283         char *temp = NULL;
 284         int len = 0;
 285         int i = 0;
 286
 287         if (!segment || !service) {
 288                 WDP_LOGE("Invalid parameter");
 289                 return -1;
 290         }
 291
 292         ptr = segment;
 293         WDP_LOGD("Segment: %s", segment);
 294
 295         serv_tmp = (wfd_oem_new_service_s*) g_try_malloc0(sizeof(wfd_oem_new_service_s));
 296         if (!serv_tmp) {
 297                 WDP_LOGE("Failed to allocate memory for service");
 298                 return -1;
 299         }
 300
 301         serv_tmp->protocol = __ws_hex_to_num(ptr, 2);
 302         serv_tmp->trans_id = __ws_hex_to_num(ptr+2, 2);
 303         serv_tmp->status = __ws_hex_to_num(ptr+4, 2);
 304         ptr += 6;
 305         WDP_LOGD("Protocol[%d], Transaction ID[%d], Status[%d]", serv_tmp->protocol, serv_tmp->trans_id, serv_tmp->status);
 306
 307         if (serv_tmp->status != 0) {
 308                 WDP_LOGE("Service status is not success");
 309                 free(serv_tmp);
 310                 return -1;
 311         }
 312
 313         if (serv_tmp->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
 314                 WDP_LOGD("===== Bonjour service =====");
 315                 char compr[5] = {0, };
 316                 char query[256] = {0, };
 317                 char rdata[256] = {0, };
 318                 int dns_type = 0;
 319
 320                 while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
 321                         len = __ws_hex_to_num(ptr, 2);
 322                         ptr += 2;
 323                         if (len && len + 2 >= 0 && len <= 0xff) {
 324                                 temp = (char*) calloc(1, len+2);
 325                                 if (temp) {
 326                                         temp[0] = '.';
 327                                         for (i = 0; i < len; i++) {
 328                                                 temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
 329                                                 ptr += 2;
 330                                         }
 331                                         strncat(query, temp, len+1);
 332                                         g_free(temp);
 333                                         temp = NULL;
 334                                 }
 335                         }
 336                 }
 337
 338                 if (!strncmp(ptr, "c0", 2)) {
 339                         memcpy(compr, ptr, 4);
 340                         ptr += 2;
 341
 342                         if (!strncmp(ptr, "27", 2)) {
 343                                 WDP_LOGD("Segment ended");
 344                                 ptr += 2;
 345                         } else {
 346                                 ptr += 2;
 347                                 dns_type = __ws_hex_to_num(ptr, 4);
 348                                 ptr += 6;
 349                                 if (dns_type == 12) {
 350                                         if (!strncmp(compr, "c011", 4))
 351                                                 strncat(query, ".local.", 7);
 352                                         else if (!strncmp(compr, "c00c", 4))
 353                                                 strncat(query, "._tcp.local.", 12);
 354                                         else if (!strncmp(compr, "c01c", 4))
 355                                                 strncat(query, "._udp.local.", 12);
 356                                 }
 357                         }
 358                 }
 359                 serv_tmp->data.bonjour.query = strdup(query + 1);
 360                 while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
 361                         len = __ws_hex_to_num(ptr, 2);
 362                         ptr += 2;
 363                         if (len && len + 2 >= 0 && len <= 0xff) {
 364                                 temp = (char*) g_try_malloc0(len+2);
 365                                 if (temp) {
 366                                         temp[0] = '.';
 367                                         for (i = 0; i < len; i++) {
 368                                                 temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
 369                                                 ptr += 2;
 370                                         }
 371                                         strncat(rdata, temp, len+1);
 372                                         g_free(temp);
 373                                         temp = NULL;
 374                                 }
 375                         }
 376                 }
 377                 serv_tmp->data.bonjour.rdata = strdup(rdata + 1);
 378
 379                 WDP_LOGD("Query: %s", serv_tmp->data.bonjour.query);
 380                 WDP_LOGD("RData: %s", serv_tmp->data.bonjour.rdata);
 381         } else {
 382                 WDP_LOGE("Not supported yet. Only bonjour service supproted [%d]",
 383                                         serv_tmp->protocol);
 384                 g_free(serv_tmp);
 385                 return -1;
 386         }
 387
 388         *service = serv_tmp;
 389
 390         return 0;
 391 }
 392 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 393
 394 static void __ws_path_to_addr(char *peer_path,
 395                 unsigned char *dev_addr, GVariant *parameter)
 396 {
 397         __WDP_LOG_FUNC_ENTER__;
 398
 399         static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
 400         const char *path = NULL;
 401         char *loc = NULL;
 402
 403         g_variant_get(parameter, "(&o)", &path);
 404         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
 405         WDP_LOGD("Retrive Added path [%s]", peer_path);
 406
 407         loc = strrchr(peer_path, '/');
 408         if (loc != NULL)
 409                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
 410
 411         __ws_txt_to_mac(peer_dev, dev_addr);
 412         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
 413
 414         __WDP_LOG_FUNC_EXIT__;
 415         return;
 416 }
 417
 418 static int __ws_unpack_ay(unsigned char *dst, GVariant *src, int size)
 419 {
 420         GVariantIter *iter = NULL;
 421         int length = 0;
 422         int res = 1;
 423
 424         if (!dst || !src || size == 0) {
 425                 WDP_LOGE("Invalid parameter");
 426                 return -1;
 427         }
 428         g_variant_get(src, "ay", &iter);
 429         if (iter == NULL) {
 430                 WDP_LOGE("failed to get iterator");
 431                 return -1;
 432         }
 433
 434         while (g_variant_iter_loop(iter, "y", &dst[length])) {
 435                 length++;
 436                 if (length >= size)
 437                         break;
 438         }
 439         g_variant_iter_free(iter);
 440
 441         if (length < size) {
 442                 WDP_LOGE("array is shorter than size");
 443                 res = -1;
 444         }
 445
 446         return res;
 447 }
 448
 449 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 450 static int __parsing_wfd_info(unsigned char *wfd_dev_info,
 451                 wfd_oem_display_s* display)
 452 {
 453         __WDP_LOG_FUNC_ENTER__;
 454
 455         int wfd_info = 0;
 456         if (!wfd_dev_info || !display) {
 457                 WDP_LOGE("Invalid parameter");
 458                 __WDP_LOG_FUNC_EXIT__;
 459                 return -1;
 460         }
 461
 462         wfd_info = (wfd_dev_info[3]<<8 | wfd_dev_info[4]);
 463
 464         if (wfd_info & WS_WFD_INFO_PRIMARY_SINK)
 465                 display->type |= WS_WFD_INFO_PRIMARY_SINK;
 466         if (wfd_info & WS_WFD_INFO_SECONDARY_SINK)
 467                 display->type |= WS_WFD_INFO_SECONDARY_SINK;
 468
 469         display->availability = (wfd_info & WS_WFD_INFO_AVAILABILITY) >> 4;
 470         display->hdcp_support = (wfd_info & WS_WFD_INFO_HDCP_SUPPORT) >> 8;
 471
 472         display->port = (wfd_dev_info[5]<<8 | wfd_dev_info[6]);
 473         display->max_tput = (wfd_dev_info[7]<<8 | wfd_dev_info[8]);
 474
 475         WDP_LOGD("type [%d],availability [%d],hdcp_support [%d],ctrl_port [%d] "
 476                         "max_tput[%d]", display->type, display->availability,
 477                         display->hdcp_support, display->port, display->max_tput);
 478
 479         __WDP_LOG_FUNC_EXIT__;
 480         return 0;
 481 }
 482 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 483
 484 static int _ws_get_local_dev_mac(unsigned char *dev_mac)
 485 {
 486         __WDP_LOG_FUNC_ENTER__;
 487         FILE *fd = NULL;
 488         const char *file_path = DEFAULT_MAC_FILE_PATH;
 489         char local_mac[OEM_MACSTR_LEN] = {0, };
 490         char *ptr = NULL;
 491         int res = 0;
 492
 493         errno = 0;
 494         fd = fopen(file_path, "r");
 495         if (!fd) {
 496                 WDP_LOGE("Failed to open MAC info file [%s] (%s)", file_path, strerror(errno));
 497                 __WDP_LOG_FUNC_EXIT__;
 498                 return -1;
 499         }
 500
 501         errno = 0;
 502         ptr = fgets((char *)local_mac, WS_MACSTR_LEN, fd);
 503         if (!ptr) {
 504                 WDP_LOGE("Failed to read file or no data read(%s)", strerror(errno));
 505                 fclose(fd);
 506                 __WDP_LOG_FUNC_EXIT__;
 507                 return -1;
 508         }
 509         WDP_SECLOGD("Local MAC address [%s]", ptr);
 510         WDP_SECLOGD("Local MAC address [%s]", local_mac);
 511
 512         res = __ws_txt_to_mac((unsigned char *)local_mac, dev_mac);
 513         if (res < 0) {
 514                 WDP_LOGE("Failed to convert text to MAC address");
 515                 fclose(fd);
 516                 __WDP_LOG_FUNC_EXIT__;
 517                 return -1;
 518         }
 519
 520         WDP_LOGD("Local Device MAC address [" MACSECSTR "]", MAC2SECSTR(dev_mac));
 521
 522         fclose(fd);
 523         __WDP_LOG_FUNC_EXIT__;
 524         return 0;
 525 }
 526
 527 static void _supplicant_signal_cb(GDBusConnection *connection,
 528                 const gchar *sender, const gchar *object_path, const gchar *interface,
 529                 const gchar *signal, GVariant *parameters, gpointer user_data)
 530 {
 531 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 532         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 533 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 534
 535         if (!g_pd) {
 536                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
 537                 return;
 538         }
 539
 540         if (!g_strcmp0(signal, "InterfaceAdded")) {
 541                 WDP_LOGD("InterfaceAdded");
 542
 543         } else if (!g_strcmp0(signal, "InterfaceRemoved")) {
 544                 WDP_LOGD("InterfaceRemoved");
 545                 static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 546                 const char *path = NULL;
 547
 548                 g_variant_get(parameters, "(&o)", &path);
 549                 g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
 550
 551                 WDP_LOGD("Retrive removed path [%s]", interface_path);
 552
 553                 if (!g_strcmp0(g_pd->group_iface_path, interface_path)) {
 554
 555                         WDP_LOGD("p2p group interface removed");
 556                         memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
 557                 }
 558 #if defined(TIZEN_WLAN_CONCURRENT_ENABLE) && defined(TIZEN_MOBILE)
 559                 else if (!g_strcmp0(g_pd->iface_path, interface_path)) {
 560
 561                         WDP_LOGD("p2p interface removed");
 562                         wfd_oem_event_s event;
 563
 564                         ws_deactivate(1);
 565
 566                         memset(&event, 0x0, sizeof(wfd_oem_event_s));
 567                         event.event_id = WFD_OEM_EVENT_DEACTIVATED;
 568                         g_pd->callback(g_pd->user_data, &event);
 569
 570                         memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
 571                 }
 572 #endif /* TIZEN_WLAN_CONCURRENT_ENABLE && TIZEN_MOBILE */
 573         } else if (!g_strcmp0(signal, "PropertiesChanged")) {
 574                 WDP_LOGD("PropertiesChanged");
 575         }
 576 }
 577
 578 static void __ws_get_peer_property(const char *key, GVariant *value, void *user_data)
 579 {
 580         __WDP_LOG_FUNC_ENTER__;
 581
 582         wfd_oem_device_s *peer = (wfd_oem_device_s *)user_data;
 583         if (!peer) {
 584                 __WDP_LOG_FUNC_EXIT__;
 585                 return;
 586         }
 587 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 588         CHECK_KEY_VALUE(key, value);
 589 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 590
 591         if (g_strcmp0(key, "DeviceName") == 0) {
 592                 const char *name = NULL;
 593
 594                 g_variant_get(value, "&s", &name);
 595                 g_strlcpy(peer->dev_name, name, WS_SSID_LEN);
 596                 WDP_LOGD("Device name [%s]", peer->dev_name);
 597
 598         } else if (g_strcmp0(key, "config_method") == 0) {
 599                 int config_methods = 0;
 600                 g_variant_get(value, "q", &config_methods);
 601
 602                 if (config_methods & WS_CONFIG_METHOD_DISPLAY)
 603                         peer->config_methods |= WFD_OEM_WPS_MODE_DISPLAY;
 604                 if (config_methods & WS_CONFIG_METHOD_PUSHBUTTON)
 605                         peer->config_methods |= WFD_OEM_WPS_MODE_PBC;
 606                 if (config_methods & WS_CONFIG_METHOD_KEYPAD)
 607                         peer->config_methods |= WFD_OEM_WPS_MODE_KEYPAD;
 608                 WDP_LOGD("Config method [0x%x]", peer->config_methods);
 609
 610         } else if (g_strcmp0(key, "level") == 0) {
 611
 612         } else if (g_strcmp0(key, "devicecapability") == 0) {
 613                 unsigned char devicecapability = 0;
 614
 615                 g_variant_get(value, "y", &devicecapability);
 616                 peer->dev_flags = (int)devicecapability;
 617                 WDP_LOGD("Device Capa [0x%02x]", peer->dev_flags);
 618
 619         } else if (g_strcmp0(key, "groupcapability") == 0) {
 620                 unsigned char groupcapability = 0;
 621
 622                 g_variant_get(value, "y", &groupcapability);
 623                 WDP_LOGD("Group Capa [0x%02x]", groupcapability);
 624                 if (groupcapability & WS_GROUP_CAP_GROUP_OWNER) {
 625                         peer->group_flags = WFD_OEM_GROUP_FLAG_GROUP_OWNER;
 626                         peer->dev_role = WFD_OEM_DEV_ROLE_GO;
 627                 }
 628                 if (groupcapability & WS_GROUP_CAP_PERSISTENT_GROUP)
 629                         peer->group_flags = WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
 630
 631         } else if (g_strcmp0(key, "PrimaryDeviceType") == 0) {
 632                 unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
 633
 634                 if (__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
 635                         peer->pri_dev_type = primarydevicetype[1];
 636                         peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
 637                 }
 638         } else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
 639         } else if (g_strcmp0(key, "VendorExtension") == 0) {
 640 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 641         } else if (g_strcmp0(key, "IEs") == 0) {
 642                 unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
 643
 644                 if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
 645                         __parsing_wfd_info(ies, &(peer->display));
 646 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 647         } else if (g_strcmp0(key, "DeviceAddress") == 0) {
 648
 649                 if (__ws_unpack_ay(peer->dev_addr, value, WS_MACADDR_LEN))
 650                         WDP_LOGD("Device address [" MACSTR "]", MAC2STR(peer->dev_addr));
 651
 652         } else if (g_strcmp0(key, "InterfaceAddress") == 0) {
 653
 654                 if (__ws_unpack_ay(peer->intf_addr, value, WS_MACADDR_LEN))
 655                         WDP_LOGD("Interface address [" MACSTR "]", MAC2STR(peer->intf_addr));
 656
 657         } else if (g_strcmp0(key, "GODeviceAddress") == 0) {
 658
 659                 if (__ws_unpack_ay(peer->go_dev_addr, value, WS_MACADDR_LEN))
 660                         WDP_LOGD("GODevice address [" MACSTR "]", MAC2STR(peer->go_dev_addr));
 661
 662                 if (!ISZEROMACADDR(peer->go_dev_addr))
 663                         peer->dev_role = WFD_OEM_DEV_ROLE_GC;
 664         } else {
 665                 WDP_LOGD("Unknown value");
 666         }
 667         __WDP_LOG_FUNC_EXIT__;
 668         return;
 669 }
 670
 671 static void __ws_peer_property(const char *key, GVariant *value, void *user_data)
 672 {
 673         __WDP_LOG_FUNC_ENTER__;
 674         if (!user_data) {
 675                 __WDP_LOG_FUNC_EXIT__;
 676                 return;
 677         }
 678
 679         wfd_oem_dev_data_s *peer = (wfd_oem_dev_data_s *)user_data;
 680 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 681         CHECK_KEY_VALUE(key, value);
 682 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 683         if (g_strcmp0(key, "DeviceName") == 0) {
 684                 const char *name = NULL;
 685
 686                 g_variant_get(value, "&s", &name);
 687                 g_strlcpy(peer->name, name, WS_SSID_LEN);
 688                 WDP_LOGD("Device Name [%s]", peer->name);
 689
 690         } else if (g_strcmp0(key, "config_method") == 0) {
 691                 int config_methods = 0;
 692
 693                 g_variant_get(value, "q", &config_methods);
 694
 695                 if (config_methods & WS_CONFIG_METHOD_DISPLAY)
 696                         peer->config_methods |= WFD_OEM_WPS_MODE_DISPLAY;
 697                 if (config_methods & WS_CONFIG_METHOD_PUSHBUTTON)
 698                         peer->config_methods |= WFD_OEM_WPS_MODE_PBC;
 699                 if (config_methods & WS_CONFIG_METHOD_KEYPAD)
 700                         peer->config_methods |= WFD_OEM_WPS_MODE_KEYPAD;
 701                 WDP_LOGD("Config method [0x%x]", peer->config_methods);
 702
 703         } else if (g_strcmp0(key, "level") == 0) {
 704
 705         } else if (g_strcmp0(key, "devicecapability") == 0) {
 706                 unsigned char devicecapability = 0;
 707
 708                 g_variant_get(value, "y", &devicecapability);
 709                 peer->dev_flags = (int)devicecapability;
 710                 WDP_LOGD("Device Capa [0x%02x]", peer->dev_flags);
 711
 712         } else if (g_strcmp0(key, "groupcapability") == 0) {
 713                 unsigned char groupcapability = 0;
 714
 715                 g_variant_get(value, "y", &groupcapability);
 716                 WDP_LOGD("Group Capa [0x%02x]", groupcapability);
 717                 if (groupcapability & WS_GROUP_CAP_GROUP_OWNER) {
 718                         peer->group_flags = WFD_OEM_GROUP_FLAG_GROUP_OWNER;
 719                         peer->dev_role = WFD_OEM_DEV_ROLE_GO;
 720                 }
 721                 if (groupcapability & WS_GROUP_CAP_PERSISTENT_GROUP)
 722                         peer->group_flags = WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
 723
 724         } else if (g_strcmp0(key, "PrimaryDeviceType") == 0) {
 725                 unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
 726
 727                 if (__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
 728                         peer->pri_dev_type = primarydevicetype[1];
 729                         peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
 730                 }
 731         } else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
 732         } else if (g_strcmp0(key, "VendorExtension") == 0) {
 733 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 734         } else if (g_strcmp0(key, "IEs") == 0) {
 735                 unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
 736
 737                 if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
 738                         __parsing_wfd_info(ies, &(peer->display));
 739 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 740         } else if (g_strcmp0(key, "DeviceAddress") == 0) {
 741
 742                 if (__ws_unpack_ay(peer->p2p_dev_addr, value, WS_MACADDR_LEN))
 743                         WDP_LOGD("Device address [" MACSTR "]", MAC2STR(peer->p2p_dev_addr));
 744
 745         } else if (g_strcmp0(key, "InterfaceAddress") == 0) {
 746
 747                 if (__ws_unpack_ay(peer->p2p_intf_addr, value, WS_MACADDR_LEN))
 748                         WDP_LOGD("Interface Address [" MACSTR "]", MAC2STR(peer->p2p_intf_addr));
 749
 750         } else if (g_strcmp0(key, "GODeviceAddress") == 0) {
 751
 752                 unsigned char go_dev_addr[OEM_MACADDR_LEN] = {0,};
 753                 if (__ws_unpack_ay(go_dev_addr, value, WS_MACADDR_LEN))
 754                         WDP_LOGD("[" MACSTR "]", MAC2STR(go_dev_addr));
 755
 756                 if (!ISZEROMACADDR(go_dev_addr))
 757                         peer->dev_role = WFD_OEM_DEV_ROLE_GC;
 758 #if defined(TIZEN_FEATURE_ASP)
 759         } else if (g_strcmp0(key, "AdvertiseService") == 0) {
 760                 if (value != NULL && g_variant_get_size(value) != 0)
 761                         peer->has_asp_services = 1;
 762                 else
 763                         peer->has_asp_services = 0;
 764
 765 #endif /* TIZEN_FEATURE_ASP */
 766         } else {
 767                 WDP_LOGD("Unknown value");
 768         }
 769         __WDP_LOG_FUNC_EXIT__;
 770         return;
 771 }
 772
 773 void __ws_interface_property(const char *key, GVariant *value, void *user_data)
 774 {
 775         __WDP_LOG_FUNC_ENTER__;
 776         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 777         if (!event)
 778                 return;
 779 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 780         CHECK_KEY_VALUE(key, value);
 781 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 782         if (g_strcmp0(key, "Ifname") == 0) {
 783                 const char *ifname = NULL;
 784
 785                 g_variant_get(value, "&s", &ifname);
 786                 g_strlcpy(event->ifname, ifname, OEM_IFACE_NAME_LEN+1);
 787                 WDP_LOGD("Ifname [%s]", event->ifname);
 788
 789         }
 790         __WDP_LOG_FUNC_EXIT__;
 791         return;
 792 }
 793
 794 void __ws_group_property(const char *key, GVariant *value, void *user_data)
 795 {
 796         __WDP_LOG_FUNC_ENTER__;
 797         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 798         if (!event || !event->edata)
 799                 return;
 800
 801         wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
 802 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 803         CHECK_KEY_VALUE(key, value);
 804 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 805         if (g_strcmp0(key, "Role") == 0) {
 806                 const char *role = NULL;
 807
 808                 g_variant_get(value, "&s", &role);
 809                 WDP_LOGD("Role [%s]", role);
 810
 811                 if (!strncmp(role, "GO", 2))
 812                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 813                 else if (!strncmp(role, "client", 6))
 814                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 815
 816         } else if (g_strcmp0(key, "Frequency") == 0) {
 817                 int frequency = 0;
 818
 819                 g_variant_get(value, "q", &frequency);
 820                 group->freq = (int)frequency;
 821
 822         } else if (g_strcmp0(key, "Passphrase") == 0) {
 823                 const char *passphrase = NULL;
 824
 825                 g_variant_get(value, "&s", &passphrase);
 826                 g_strlcpy(group->pass, passphrase, OEM_PASS_PHRASE_LEN+1);
 827                 WDP_LOGD("passphrase [%s]", group->pass);
 828
 829         } else if (g_strcmp0(key, "Group") == 0) {
 830
 831         } else if (g_strcmp0(key, "SSID") == 0) {
 832                 unsigned char ssid[WS_SSID_LEN +1] = {0,};
 833
 834                 __ws_unpack_ay(ssid, value, WS_SSID_LEN);
 835                 memcpy(group->ssid, ssid, WS_SSID_LEN+1);
 836                 WDP_LOGD("ssid [%s]", group->ssid);
 837
 838         } else if (g_strcmp0(key, "BSSID") == 0) {
 839
 840                 if (__ws_unpack_ay(group->go_dev_addr, value, WS_MACADDR_LEN))
 841                         WDP_LOGD("[" MACSTR "]", MAC2STR(group->go_dev_addr));
 842
 843         } else {
 844                 WDP_LOGD("Unknown value");
 845         }
 846         __WDP_LOG_FUNC_EXIT__;
 847         return;
 848 }
 849
 850 void __ws_extract_invitation_details(const char *key, GVariant *value, void *user_data)
 851 {
 852         __WDP_LOG_FUNC_ENTER__;
 853         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 854         if (!event || !event->edata)
 855                 return;
 856
 857         wfd_oem_invite_data_s *invitation = (wfd_oem_invite_data_s *)event->edata;
 858 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 859         CHECK_KEY_VALUE(key, value);
 860 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 861         if (g_strcmp0(key, "sa") == 0) {
 862                 if (__ws_unpack_ay(invitation->sa, value, WS_MACADDR_LEN))
 863                         WDP_LOGD("SA [" MACSTR "]", MAC2STR(invitation->sa));
 864
 865         } else if (g_strcmp0(key, "go_dev_addr") == 0) {
 866                 if (__ws_unpack_ay(invitation->go_dev_addr, value, WS_MACADDR_LEN))
 867                                         WDP_LOGD("GO device address [" MACSTR "]", MAC2STR(invitation->go_dev_addr));
 868
 869         } else if (g_strcmp0(key, "bssid") == 0) {
 870                 if (__ws_unpack_ay(invitation->bssid, value, WS_MACADDR_LEN))
 871                                         WDP_LOGD("BSSID [" MACSTR "]", MAC2STR(invitation->bssid));
 872
 873         } else if (g_strcmp0(key, "persistent_id") == 0) {
 874                 g_variant_get(value, "i", &(invitation->persistent_id));
 875                 WDP_LOGD("persistent id [%d]", invitation->persistent_id);
 876
 877         } else if (g_strcmp0(key, "op_freq") == 0) {
 878                 g_variant_get(value, "i", &(invitation->oper_freq));
 879                 WDP_LOGD("op freq [%d]", invitation->oper_freq);
 880         } else {
 881                 WDP_LOGD("Unknown value");
 882         }
 883         __WDP_LOG_FUNC_EXIT__;
 884         return;
 885 }
 886
 887 void __ws_extract_group_details(const char *key, GVariant *value, void *user_data)
 888 {
 889         __WDP_LOG_FUNC_ENTER__;
 890         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 891         if (!event || !event->edata)
 892                 return;
 893
 894         if (!g_pd) {
 895                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
 896                 return;
 897         }
 898
 899         wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
 900 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 901         CHECK_KEY_VALUE(key, value);
 902 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 903         if (g_strcmp0(key, "interface_object") == 0) {
 904                 static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 905                 const char *i_path = NULL;
 906
 907                 g_variant_get(value, "&o", &i_path);
 908                 g_strlcpy(interface_path, i_path, DBUS_OBJECT_PATH_MAX);
 909                 WDP_LOGD("Retrive Added path [%s]", interface_path);
 910                 g_strlcpy(g_pd->group_iface_path, interface_path, DBUS_OBJECT_PATH_MAX);
 911                 dbus_property_get_all(interface_path, g_pd->g_dbus,
 912                                 SUPPLICANT_IFACE, __ws_interface_property, event);
 913
 914         } else if (g_strcmp0(key, "role") == 0) {
 915                 const char *role = NULL;
 916
 917                 g_variant_get(value, "&s", &role);
 918                 WDP_LOGD("Role [%s]", role);
 919
 920                 if (!strncmp(role, "GO", 2))
 921                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 922                 else if (!strncmp(role, "client", 6))
 923                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 924         } else if (g_strcmp0(key, "persistent") == 0) {
 925                 g_variant_get(value, "b", &group->is_persistent);
 926                 WDP_LOGD("Is Persistent : [%s]", group->is_persistent ? "YES" : "NO");
 927
 928 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
 929         } else if (g_strcmp0(key, "IpAddr") == 0) {
 930
 931                 if (__ws_unpack_ay(group->ip_addr, value, OEM_IPADDR_LEN))
 932                         WDP_LOGD("IP address [" IPSTR "]", IP2STR(group->ip_addr));
 933
 934         } else if (g_strcmp0(key, "IpAddrMask") == 0) {
 935
 936                 if (__ws_unpack_ay(group->ip_addr_mask, value, OEM_IPADDR_LEN))
 937                         WDP_LOGD("IP mask [" IPSTR "]", IP2STR(group->ip_addr_mask));
 938
 939         } else if (g_strcmp0(key, "IpAddrGo") == 0) {
 940
 941                 if (__ws_unpack_ay(group->ip_addr_go, value, OEM_IPADDR_LEN))
 942                         WDP_LOGD("GO IP address [" IPSTR "]", IP2STR(group->ip_addr_go));
 943 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
 944         } else if (g_strcmp0(key, "group_object") == 0) {
 945                 static char group_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 946                 const char *g_path;
 947
 948                 g_variant_get(value, "&o", &g_path);
 949                 g_strlcpy(group_path, g_path, DBUS_OBJECT_PATH_MAX);
 950                 WDP_LOGD("Retrive group path [%s]", group_path);
 951                 dbus_property_get_all(group_path, g_pd->g_dbus, SUPPLICANT_P2P_GROUP,
 952                                 __ws_group_property, event);
 953
 954                 g_pd->group_sub_id =
 955                         g_dbus_connection_signal_subscribe(
 956                                 g_pd->g_dbus,
 957                                 SUPPLICANT_SERVICE, /* bus name */
 958                                 SUPPLICANT_P2P_GROUP, /* interface */
 959                                 NULL, /* member */
 960                                 group_path, /* object path */
 961                                 NULL, /* arg0 */
 962                                 G_DBUS_SIGNAL_FLAGS_NONE,
 963                                 _group_signal_cb,
 964                                 NULL, NULL);
 965                 WDP_LOGD("Subscribed group iface signal: [%d]", g_pd->group_sub_id);
 966         }
 967         __WDP_LOG_FUNC_EXIT__;
 968         return;
 969 }
 970
 971 void __ws_extract_gonegfailaure_details(const char *key, GVariant *value, void *user_data)
 972 {
 973         __WDP_LOG_FUNC_ENTER__;
 974         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 975         if (!event || !event->edata)
 976                 return;
 977
 978         wfd_oem_conn_data_s *conn = (wfd_oem_conn_data_s *)event->edata;
 979 #if defined(TIZEN_DEBUG_DBUS_VALUE)
 980         CHECK_KEY_VALUE(key, value);
 981 #endif /* TIZEN_DEBUG_DBUS_VALUE */
 982         if (g_strcmp0(key, "peer_object") == 0) {
 983                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 984                 const char *path;
 985
 986                 g_variant_get(value, "&o", &path);
 987                 g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
 988                 WDP_LOGD("Retrive peer path [%s]", peer_path);
 989
 990         } else if (g_strcmp0(key, "status") == 0) {
 991                 int status = 0;
 992
 993                 g_variant_get(value, "i", &status);
 994                 WDP_LOGD("Retrive status [%d]", status);
 995                 conn->status = status;
 996         }
 997         __WDP_LOG_FUNC_EXIT__;
 998         return;
 999 }
1000
1001 void __ws_extract_gonegsuccess_details(const char *key, GVariant *value, void *user_data)
1002 {
1003         __WDP_LOG_FUNC_ENTER__;
1004         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1005         if (!event || !event->edata)
1006                 return;
1007
1008         wfd_oem_conn_data_s *edata = (wfd_oem_conn_data_s *)event->edata;
1009 #if defined(TIZEN_DEBUG_DBUS_VALUE)
1010         CHECK_KEY_VALUE(key, value);
1011 #endif /* TIZEN_DEBUG_DBUS_VALUE */
1012         if (g_strcmp0(key, "peer_object") == 0) {
1013
1014         } else if (g_strcmp0(key, "status") == 0) {
1015
1016         } else if (g_strcmp0(key, "passphrase") == 0) {
1017
1018         } else if (g_strcmp0(key, "role_go") == 0) {
1019                 /* local device role */
1020                 const char *role = NULL;
1021
1022                 g_variant_get(value, "&s", &role);
1023                 if (!strncmp(role, "GO", 2))
1024                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
1025                 else if (!strncmp(role, "client", 6))
1026                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
1027
1028         } else if (g_strcmp0(key, "ssid") == 0) {
1029                 unsigned char ssid[WS_SSID_LEN +1] = {0,};
1030
1031                 __ws_unpack_ay(ssid, value, WS_SSID_LEN);
1032                 memcpy(edata->ssid, ssid, WS_SSID_LEN+1);
1033                 WDP_LOGD("ssid [%s]", edata->ssid);
1034
1035         } else if (g_strcmp0(key, "peer_device_addr") == 0) {
1036
1037                 if (__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
1038                         WDP_LOGD("Device address[" MACSTR "]", MAC2STR(edata->peer_device_addr));
1039
1040         } else if (g_strcmp0(key, "peer_interface_addr") == 0) {
1041
1042                 if (__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
1043                         WDP_LOGD("Interface address [" MACSTR "]", MAC2STR(edata->peer_intf_addr));
1044
1045         } else if (g_strcmp0(key, "wps_method") == 0) {
1046
1047         } else if (g_strcmp0(key, "frequency_list") == 0) {
1048
1049         } else if (g_strcmp0(key, "persistent_group") == 0) {
1050
1051                 g_variant_get(value, "i", &(edata->persistent_group));
1052                 WDP_LOGD("persistent_group [%d]", edata->persistent_group);
1053
1054         } else if (g_strcmp0(key, "peer_config_timeout") == 0) {
1055
1056         }
1057         __WDP_LOG_FUNC_EXIT__;
1058         return;
1059 }
1060
1061 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1062 void __ws_extract_peer_service(wfd_oem_event_s *data, unsigned char *service_hex, int tlvs_len)
1063 {
1064         GList *services = NULL;
1065         wfd_oem_new_service_s *new_service = NULL;
1066         char *segment = NULL;
1067         int count = 0;
1068         int ptr = 0;
1069         int length = 0;
1070         int res = 0;
1071
1072         while (ptr + 2 < WS_MAX_SERVICE_LEN &&
1073                         (length = (service_hex[ptr+1]*256) + service_hex[ptr]) > 0) {
1074                 segment = (char*) g_try_malloc0(length*2+1);
1075                 if (segment) {
1076                         __ws_byte_to_hex(segment, length * 2 + 1, &service_hex[ptr + 3], length);
1077                         res = __ws_segment_to_service(segment, &new_service);
1078                         if (res < 0) {
1079                                 WDP_LOGE("Failed to convert segment as service instance");
1080                                 g_free(segment);
1081                                 segment = NULL;
1082                                 continue;
1083                         }
1084                         services = g_list_append(services, new_service);
1085                         count++;
1086                         ptr += length + 4;
1087                         g_free(segment);
1088                         segment = NULL;
1089                 }
1090                 data->edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
1091                 data->dev_role = count;
1092                 data->edata = (void*) services;
1093         }
1094 }
1095
1096 void __ws_extract_servicediscoveryresponse_details(const char *key, GVariant *value, void *user_data)
1097 {
1098         __WDP_LOG_FUNC_ENTER__;
1099         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1100
1101         if (!event)
1102                 return;
1103 #if defined(TIZEN_DEBUG_DBUS_VALUE)
1104         CHECK_KEY_VALUE(key, value);
1105 #endif /* TIZEN_DEBUG_DBUS_VALUE */
1106         if (g_strcmp0(key, "peer_object") == 0) {
1107                 static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
1108                 const char *path = NULL;
1109                 char *loc = NULL;
1110
1111                 g_variant_get(value, "&o", &path);
1112                 if (path == NULL)
1113                         return;
1114
1115                 WDP_LOGD("Retrive Added path [%s]", path);
1116                 loc = strrchr(path, '/');
1117                 if (loc != NULL)
1118                         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1119                 __ws_txt_to_mac(peer_dev, event->dev_addr);
1120
1121         } else if (g_strcmp0(key, "update_indicator")) {
1122
1123         } else if (g_strcmp0(key, "tlvs")) {
1124                 GVariantIter *iter = NULL;
1125                 unsigned char service_hex[WS_MAX_SERVICE_LEN];
1126                 int byte_length = 0;
1127
1128                 g_variant_get(value, "ay", &iter);
1129                 if (iter == NULL) {
1130                         WDP_LOGE("failed to get iterator");
1131                         return;
1132                 }
1133
1134                 memset(service_hex, 0x0, WS_MAX_SERVICE_LEN);
1135                 while (g_variant_iter_loop(iter, "y", &service_hex[byte_length]))
1136                         byte_length++;
1137                 g_variant_iter_free(iter);
1138
1139                 __ws_extract_peer_service(event, service_hex, byte_length);
1140         }
1141
1142         __WDP_LOG_FUNC_EXIT__;
1143 }
1144 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1145
1146 #if defined(TIZEN_FEATURE_ASP)
1147 static void __ws_extract_serviceaspresponse_details(const char *key, GVariant *value, void *user_data)
1148 {
1149         __WDP_LOG_FUNC_ENTER__;
1150         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1151         if (!event || !event->edata)
1152                 return;
1153
1154         wfd_oem_asp_service_s *service = (wfd_oem_asp_service_s *)event->edata;
1155
1156         if (g_strcmp0(key, "peer_object") == 0) {
1157                 static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
1158                 const char *path = NULL;
1159                 char *loc = NULL;
1160
1161                 g_variant_get(value, "o", &path);
1162                 if (path == NULL)
1163                         return;
1164
1165                 WDP_LOGD("Retrive Added path [%s]", path);
1166                 loc = strrchr(path, '/');
1167                 if (loc != NULL)
1168                         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1169                 __ws_txt_to_mac(peer_dev, event->dev_addr);
1170
1171         } else if (g_strcmp0(key, "srv_trans_id") == 0) {
1172                 unsigned int srv_trans_id = 0;
1173                 g_variant_get(value, "u", &srv_trans_id);
1174                 service->tran_id = srv_trans_id;
1175                 WDP_LOGD("Retrive srv_trans_id [%x]", service->tran_id);
1176
1177         } else if (g_strcmp0(key, "adv_id") == 0) {
1178                 unsigned int adv_id = 0;
1179                 g_variant_get(value, "u", &adv_id);
1180                 service->adv_id = adv_id;
1181                 WDP_LOGD("Retrive adv_id [%x]", service->adv_id);
1182
1183         } else if (g_strcmp0(key, "svc_status") == 0) {
1184                 unsigned char svc_status = 0;
1185                 g_variant_get(value, "u", &svc_status);
1186                 service->status = svc_status;
1187                 WDP_LOGD("Retrive svc_status [%x]", service->status);
1188
1189         } else if (g_strcmp0(key, "config_methods") == 0) {
1190                 unsigned int config_methods = 0;
1191                 g_variant_get(value, "q", &config_methods);
1192                 service->config_method = config_methods;
1193                 WDP_LOGD("Retrive config_methods [%x]", service->config_method);
1194
1195         } else if (g_strcmp0(key, "svc_str") == 0) {
1196                 const char *svc_str = NULL;
1197                 g_variant_get(value, "s", &svc_str);
1198                 if (svc_str != NULL)
1199                         service->service_type = g_strdup(svc_str);
1200                 WDP_LOGD("Retrive srv_name [%s]", service->service_type);
1201
1202         } else if (g_strcmp0(key, "info") == 0) {
1203                 const char *info = NULL;
1204                 g_variant_get(value, "s", &info);
1205                 if (info != NULL)
1206                         service->service_info = g_strdup(info);
1207                 WDP_LOGD("Retrive srv_info [%s]", service->service_info);
1208         }
1209         __WDP_LOG_FUNC_EXIT__;
1210 }
1211
1212 static void __ws_extract_asp_provision_start_details(const char *key, GVariant *value, void *user_data)
1213 {
1214         __WDP_LOG_FUNC_ENTER__;
1215         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1216         wfd_oem_asp_prov_s *asp_params = NULL;
1217         if (!event || !event->edata) {
1218                 __WDP_LOG_FUNC_EXIT__;
1219                 return;
1220         }
1221
1222         asp_params = (wfd_oem_asp_prov_s *)event->edata;
1223
1224         if (g_strcmp0(key, "peer_object") == 0) {
1225                 static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
1226                 const char *path = NULL;
1227                 char *loc = NULL;
1228
1229                 g_variant_get(value, "&o", &path);
1230                 if (path == NULL) {
1231                         __WDP_LOG_FUNC_EXIT__;
1232                         return;
1233                 }
1234
1235                 WDP_LOGD("Retrive Added path [%s]", path);
1236                 loc = strrchr(path, '/');
1237                 if (loc != NULL)
1238                         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1239                 __ws_txt_to_mac(peer_dev, event->dev_addr);
1240
1241         } else if (g_strcmp0(key, "adv_id") == 0) {
1242                 g_variant_get(value, "u", &asp_params->adv_id);
1243                 WDP_LOGD("Retrive adv_id [%u]", asp_params->adv_id);
1244
1245         } else if (g_strcmp0(key, "ses_id") == 0) {
1246                 g_variant_get(value, "u", &asp_params->session_id);
1247                 WDP_LOGD("Retrive session id [%u]", asp_params->session_id);
1248
1249         } else if (g_strcmp0(key, "dev_passwd_id") == 0) {
1250                 g_variant_get(value, "i", &event->wps_mode);
1251                 WDP_LOGD("Retrive dev_passwd_id [%d]", event->wps_mode);
1252
1253         } else if (g_strcmp0(key, "conncap") == 0) {
1254                 g_variant_get(value, "u", &asp_params->network_role);
1255                 WDP_LOGD("Retrive conncap [%x]", asp_params->network_role);
1256
1257         } else if (g_strcmp0(key, "adv_mac") == 0) {
1258                 if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
1259                         WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
1260
1261         } else if (g_strcmp0(key, "ses_mac") == 0) {
1262                 if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
1263                         WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
1264
1265         } else if (g_strcmp0(key, "session_info") == 0) {
1266                 const char *session_info = NULL;
1267                 g_variant_get(value, "&s", &session_info);
1268                 if (session_info != NULL)
1269                         asp_params->session_information = g_strdup(session_info);
1270                 WDP_LOGD("Retrive session_info [%s]", asp_params->session_information);
1271         }
1272         __WDP_LOG_FUNC_EXIT__;
1273 }
1274
1275 static void __ws_extract_asp_provision_done_details(const char *key, GVariant *value, void *user_data)
1276 {
1277         __WDP_LOG_FUNC_ENTER__;
1278         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1279         wfd_oem_asp_prov_s *asp_params = NULL;
1280         if (!event || !event->edata) {
1281                 __WDP_LOG_FUNC_EXIT__;
1282                 return;
1283         }
1284
1285         asp_params = (wfd_oem_asp_prov_s *)event->edata;
1286
1287
1288         if (g_strcmp0(key, "peer_object") == 0) {
1289                 static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
1290                 const char *path = NULL;
1291                 char *loc = NULL;
1292
1293                 g_variant_get(value, "&o", &path);
1294                 if (path == NULL) {
1295                         __WDP_LOG_FUNC_EXIT__;
1296                         return;
1297                 }
1298
1299                 WDP_LOGD("Retrive Added path [%s]", path);
1300                 loc = strrchr(path, '/');
1301                 if (loc != NULL)
1302                         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1303                 __ws_txt_to_mac(peer_dev, event->dev_addr);
1304
1305                 WDP_LOGD("peer address[" MACSTR "]", MAC2STR(event->dev_addr));
1306
1307         } else if (g_strcmp0(key, "adv_id") == 0) {
1308                 g_variant_get(value, "u", &asp_params->adv_id);
1309                 WDP_LOGD("Retrive adv_id [%u]", asp_params->adv_id);
1310
1311         } else if (g_strcmp0(key, "ses_id") == 0) {
1312                 g_variant_get(value, "u", &asp_params->session_id);
1313                 WDP_LOGD("Retrive session id [%u]", asp_params->session_id);
1314
1315         } else if (g_strcmp0(key, "dev_passwd_id") == 0) {
1316                 g_variant_get(value, "i", &event->wps_mode);
1317                 WDP_LOGD("Retrive dev_passwd_id [%d]", event->wps_mode);
1318
1319         } else if (g_strcmp0(key, "conncap") == 0) {
1320                 g_variant_get(value, "u", &asp_params->network_role);
1321                 WDP_LOGD("Retrive network role [%x]", asp_params->network_role);
1322
1323         } else if (g_strcmp0(key, "status") == 0) {
1324                 g_variant_get(value, "u", &asp_params->status);
1325                 WDP_LOGD("Retrive status [%x]", asp_params->status);
1326
1327         } else if (g_strcmp0(key, "persist") == 0) {
1328                 g_variant_get(value, "u", &asp_params->persistent_group_id);
1329                 asp_params->persist = 1;
1330                 WDP_LOGD("Retrive persist [%u]", asp_params->persistent_group_id);
1331
1332         }   else if (g_strcmp0(key, "adv_mac") == 0) {
1333                 if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
1334                         WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
1335
1336         } else if (g_strcmp0(key, "ses_mac") == 0) {
1337                 if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
1338                         WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
1339
1340         } else if (g_strcmp0(key, "group_mac") == 0) {
1341                 if (__ws_unpack_ay(asp_params->group_mac, value, WS_MACADDR_LEN))
1342                         WDP_LOGD("group address[" MACSTR "]", MAC2STR(asp_params->group_mac));
1343         }
1344         __WDP_LOG_FUNC_EXIT__;
1345 }
1346
1347 static void __ws_extract_provision_fail_details(const char *key, GVariant *value, void *user_data)
1348 {
1349         __WDP_LOG_FUNC_ENTER__;
1350         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
1351         wfd_oem_asp_prov_s *asp_params = NULL;
1352         if (!event || !event->edata) {
1353                 __WDP_LOG_FUNC_EXIT__;
1354                 return;
1355         }
1356
1357         asp_params = (wfd_oem_asp_prov_s *)event->edata;
1358
1359         if (g_strcmp0(key, "peer_object") == 0) {
1360                 static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
1361                 const char *path = NULL;
1362                 char *loc = NULL;
1363
1364                 g_variant_get(value, "&o", &path);
1365                 if (path == NULL) {
1366                         __WDP_LOG_FUNC_EXIT__;
1367                         return;
1368                 }
1369
1370                 WDP_LOGD("Retrive Added path [%s]", path);
1371                 loc = strrchr(path, '/');
1372                 if (loc != NULL)
1373                         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1374                 __ws_txt_to_mac(peer_dev, event->dev_addr);
1375
1376         } else if (g_strcmp0(key, "adv_id") == 0) {
1377                 g_variant_get(value, "u", &asp_params->adv_id);
1378                 WDP_LOGD("Retrive adv_id [%d]", asp_params->adv_id);
1379
1380         }  else if (g_strcmp0(key, "status") == 0) {
1381                 g_variant_get(value, "i", &asp_params->status);
1382                 WDP_LOGD("Retrive status [%d]", asp_params->status);
1383
1384         } else if (g_strcmp0(key, "deferred_session_resp") == 0) {
1385                 const char *session_info = NULL;
1386                 g_variant_get(value, "&s", &session_info);
1387                 if (session_info != NULL)
1388                         asp_params->session_information = g_strdup(session_info);
1389                 WDP_LOGD("Retrive deferred_session_resp [%s]", asp_params->session_information);
1390         }
1391         __WDP_LOG_FUNC_EXIT__;
1392 }
1393 #endif /* TIZEN_FEATURE_ASP */
1394
1395 static int _ws_flush()
1396 {
1397         __WDP_LOG_FUNC_ENTER__;
1398         GDBusConnection *g_dbus = NULL;
1399         dbus_method_param_s params;
1400         int res = 0;
1401
1402         if (!g_pd) {
1403                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
1404                 __WDP_LOG_FUNC_EXIT__;
1405                 return -1;
1406         }
1407
1408         g_dbus = g_pd->g_dbus;
1409         if (!g_dbus) {
1410                 WDP_LOGE("DBus connection is NULL");
1411                 __WDP_LOG_FUNC_EXIT__;
1412                 return -1;
1413         }
1414         memset(&params, 0x0, sizeof(dbus_method_param_s));
1415
1416         dbus_set_method_param(&params, "Flush", g_pd->iface_path, g_dbus);
1417         params.params = NULL;
1418
1419         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
1420         if (res < 0)
1421                 WDP_LOGE("Failed to send command to wpa_supplicant");
1422         else
1423                 WDP_LOGD("Succeeded to flush");
1424
1425         __WDP_LOG_FUNC_EXIT__;
1426         return 0;
1427 }
1428
1429 static int _ws_cancel()
1430 {
1431         __WDP_LOG_FUNC_ENTER__;
1432         GDBusConnection *g_dbus = NULL;
1433         dbus_method_param_s params;
1434         int res = 0;
1435
1436         if (!g_pd) {
1437                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
1438                 return -1;
1439         }
1440
1441
1442         g_dbus = g_pd->g_dbus;
1443         if (!g_dbus) {
1444                 WDP_LOGE("DBus connection is NULL");
1445                 return -1;
1446         }
1447         memset(&params, 0x0, sizeof(dbus_method_param_s));
1448
1449         dbus_set_method_param(&params, "Cancel", g_pd->iface_path , g_dbus);
1450         params.params = NULL;
1451
1452         res = dbus_method_call(&params, SUPPLICANT_WPS, NULL, NULL);
1453         if (res < 0)
1454                 WDP_LOGE("Failed to send command to wpa_supplicant");
1455         else
1456                 WDP_LOGD("Succeeded to cancel");
1457
1458         __WDP_LOG_FUNC_EXIT__;
1459         return 0;
1460 }
1461
1462 #if defined(TIZEN_FEATURE_ASP)
1463 int ws_get_advertise_service(const char *peer_path, GList **asp_services)
1464 {
1465         __WDP_LOG_FUNC_ENTER__;
1466         GDBusConnection *g_dbus = NULL;
1467         GVariant *param = NULL;
1468         GVariant *reply = NULL;
1469         GVariant *temp = NULL;
1470         GError *error = NULL;
1471         GVariantIter *iter = NULL;
1472         wfd_oem_advertise_service_s *service;
1473         wfd_oem_asp_service_s *seek = NULL;
1474         unsigned char desc[7];
1475         unsigned int adv_id;
1476         unsigned int config_method;
1477         unsigned char length;
1478         char *value;
1479         int cnt;
1480         int res = 0;
1481
1482         if (!g_pd) {
1483                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
1484                 return -1;
1485         }
1486
1487         g_dbus = g_pd->g_dbus;
1488         if (!g_dbus) {
1489                 WDP_LOGE("DBus connection is NULL");
1490                 return -1;
1491         }
1492
1493         param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseService");
1494 #if defined(TIZEN_DEBUG_DBUS_VALUE)
1495         DEBUG_PARAMS(param);
1496 #endif /* TIZEN_DEBUG_DBUS_VALUE */
1497
1498         reply = g_dbus_connection_call_sync(
1499                         g_dbus,
1500                         SUPPLICANT_SERVICE, /* bus name */
1501                         peer_path, /* object path */
1502                         DBUS_PROPERTIES_INTERFACE, /* interface name */
1503                         DBUS_PROPERTIES_METHOD_GET, /* method name */
1504                         param, /* GVariant *params */
1505                         NULL, /* reply_type */
1506                         G_DBUS_CALL_FLAGS_NONE, /* flags */
1507                         SUPPLICANT_TIMEOUT , /* timeout */
1508                         NULL, /* cancellable */
1509                         &error); /* error */
1510
1511         if (error != NULL) {
1512                 WDP_LOGE("Error! Failed to get peer advertise service: [%s]",
1513                                 error->message);
1514                 g_error_free(error);
1515                 if (reply)
1516                         g_variant_unref(reply);
1517                 __WDP_LOG_FUNC_EXIT__;
1518                 return -1;
1519         }
1520
1521         if (reply != NULL) {
1522
1523 #if defined(TIZEN_DEBUG_DBUS_VALUE)
1524                 DEBUG_PARAMS(reply);
1525 #endif /* TIZEN_DEBUG_DBUS_VALUE */
1526
1527                 /* replay will have the format <(<ay>,)>
1528                  * So, you need to remove tuple out side of variant and
1529                  * variant out side of byte array
1530                  * */
1531                 temp = g_variant_get_child_value(reply, 0);
1532                 temp = g_variant_get_child_value(temp, 0);
1533                 g_variant_get(temp, "ay", &iter);
1534                 if (iter == NULL) {
1535                         g_variant_unref(reply);
1536                         WDP_LOGE("Failed to get iterator");
1537                         return -1;
1538                 }
1539
1540                 while (1) {
1541                         /* 4byte advertisement ID, 2 byte config method, 1byte length */
1542
1543                         cnt = 0;
1544                         memset(desc, 0x0, 7);
1545                         while (cnt < 7 && g_variant_iter_loop(iter, "y", &desc[cnt]))
1546                                 cnt++;
1547
1548                         if (cnt != 7 || desc[6] == 0) {
1549                                 WDP_LOGE("Invalid descriptor header length cnt [%d]", cnt);
1550                                 g_variant_unref(reply);
1551                                 return res;
1552                         }
1553
1554                         adv_id = desc[3] << 24 | desc[2] << 16 | desc[1] << 8 | desc[0];
1555                         config_method = desc[4] << 8 | desc[4];
1556                         length = desc[6];
1557                         value = NULL;
1558                         value = g_try_malloc0(length + 1);
1559                         if (value == NULL) {
1560                                 WDP_LOGE("g_try_malloc0 failed");
1561                                 g_variant_unref(reply);
1562                                 return res;
1563                         }
1564                         WDP_LOGD("adv_id[%u] config_method[%u]  length[%hhu]", adv_id, config_method, length);
1565
1566                         cnt = 0;
1567                         while (cnt < length && g_variant_iter_loop(iter, "y", &value[cnt]))
1568                                 cnt++;
1569
1570                         if (cnt != length) {
1571                                 WDP_LOGE("Length doesn't matched with header value cnt [%d]", cnt);
1572                                 g_variant_unref(reply);
1573                                 g_free(value);
1574                                 return res;
1575                         }
1576
1577                         service = NULL;
1578                         service = (wfd_oem_advertise_service_s *)
1579                                         g_try_malloc0(sizeof(wfd_oem_advertise_service_s));
1580                         if (service == NULL) {
1581                                 WDP_LOGE("g_try_malloc0 failed");
1582                                 g_variant_unref(reply);
1583                                 g_free(value);
1584                                 return res;
1585                         }
1586                         service->adv_id = adv_id;
1587                         service->config_method = config_method;
1588                         service->service_type_length = length;
1589                         service->service_type = value;
1590
1591 GLIST_ITER_START(seek_list, seek)
1592                         if (g_strcmp0(seek->service_type, service->service_type) == 0) {
1593                                 WDP_LOGD("service type matched [%s] search_id [%llu]",
1594                                                 service->service_type, seek->search_id);
1595                         } else {
1596                                 seek = NULL;
1597                         }
1598 GLIST_ITER_END()
1599
1600                         if (seek != NULL && seek->service_info != NULL) {
1601                                 WDP_LOGD("service info exists, service discovery will be performed");
1602                         } else {
1603                                 WDP_LOGD("service info doesn't exists. Add service to list");
1604                                 if (seek)
1605                                         service->search_id = seek->search_id;
1606                                 *asp_services = g_list_append(*asp_services, service);
1607                         }
1608                 }
1609                 g_variant_unref(reply);
1610         }
1611         __WDP_LOG_FUNC_EXIT__;
1612         return res;
1613 }
1614 #endif /* TIZEN_FEATURE_ASP */
1615
1616 static void _ws_process_device_found(GDBusConnection *connection,
1617                 const gchar *object_path, GVariant *parameters)
1618 {
1619         __WDP_LOG_FUNC_ENTER__;
1620         wfd_oem_event_s event;
1621         wfd_oem_dev_data_s *edata = NULL;
1622         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1623
1624         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1625         if (!edata) {
1626                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1627                                 strerror(errno));
1628                 __WDP_LOG_FUNC_EXIT__;
1629                 return;
1630         }
1631         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1632
1633         event.edata = (void*) edata;
1634         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1635         event.event_id = WFD_OEM_EVENT_PEER_FOUND;
1636
1637         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1638
1639         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1640                         __ws_peer_property, event.edata);
1641
1642 #if defined(TIZEN_FEATURE_ASP)
1643         if (edata->has_asp_services)
1644                 ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
1645 #endif /* TIZEN_FEATURE_ASP */
1646
1647         g_pd->callback(g_pd->user_data, &event);
1648 #if defined(TIZEN_FEATURE_ASP)
1649         if (event.asp_services != NULL) {
1650                 GList *l;
1651                 wfd_oem_advertise_service_s *service;
1652                 for (l = (GList *)event.asp_services; l != NULL; l = l->next) {
1653                         service = (wfd_oem_advertise_service_s *)l->data;
1654                         event.asp_services = g_list_remove(l, service);
1655                         g_free(service->service_type);
1656                         g_free(service);
1657                 }
1658         }
1659 #endif /* TIZEN_FEATURE_ASP */
1660         g_free(event.edata);
1661
1662         __WDP_LOG_FUNC_EXIT__;
1663 }
1664
1665 static void _ws_process_device_lost(GDBusConnection *connection,
1666                 const gchar *object_path, GVariant *parameters)
1667 {
1668         __WDP_LOG_FUNC_ENTER__;
1669         wfd_oem_event_s event;
1670         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1671
1672         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1673
1674         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1675         event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
1676
1677         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1678
1679         g_pd->callback(g_pd->user_data, &event);
1680
1681         __WDP_LOG_FUNC_EXIT__;
1682 }
1683
1684 static void _ws_process_find_stoppped(GDBusConnection *connection,
1685                 const gchar *object_path, GVariant *parameters)
1686 {
1687         __WDP_LOG_FUNC_ENTER__;
1688         wfd_oem_event_s event;
1689
1690         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1691
1692         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1693         event.event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
1694
1695         g_pd->callback(g_pd->user_data, &event);
1696
1697         __WDP_LOG_FUNC_EXIT__;
1698 }
1699
1700 static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
1701                 const gchar *object_path, GVariant *parameters)
1702 {
1703         __WDP_LOG_FUNC_ENTER__;
1704
1705         wfd_oem_event_s event;
1706         wfd_oem_dev_data_s *edata = NULL;
1707
1708         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1709         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1710         const char *path = NULL;
1711         const char *pin = NULL;
1712         char *loc = NULL;
1713
1714         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1715         if (!edata) {
1716                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1717                                 strerror(errno));
1718                 __WDP_LOG_FUNC_EXIT__;
1719                 return;
1720         }
1721         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1722
1723         event.edata = (void*) edata;
1724         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1725         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1726         event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
1727
1728         g_variant_get(parameters, "(&o&s)", &path, &pin);
1729         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1730         WDP_LOGD("Retrive Added path [%s]", peer_path);
1731
1732         loc = strrchr(peer_path, '/');
1733         if (loc != NULL)
1734                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
1735         __ws_txt_to_mac(peer_dev, event.dev_addr);
1736         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1737
1738         g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
1739         WDP_LOGD("Retrive pin [%s]", event.wps_pin);
1740
1741         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1742                         __ws_peer_property, event.edata);
1743
1744         g_pd->callback(g_pd->user_data, &event);
1745         g_free(event.edata);
1746
1747         __WDP_LOG_FUNC_EXIT__;
1748 }
1749
1750 static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
1751                 const gchar *object_path, GVariant *parameters)
1752 {
1753         __WDP_LOG_FUNC_ENTER__;
1754
1755         wfd_oem_event_s event;
1756         wfd_oem_dev_data_s *edata = NULL;
1757
1758         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1759         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1760         const char *path = NULL;
1761         const char *pin = NULL;
1762         char *loc = NULL;
1763
1764         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1765         if (!edata) {
1766                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1767                                 strerror(errno));
1768                 __WDP_LOG_FUNC_EXIT__;
1769                 return;
1770         }
1771         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1772
1773         event.edata = (void*) edata;
1774         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1775         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1776         event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
1777
1778         g_variant_get(parameters, "(&o&s)", &path, &pin);
1779         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1780         WDP_LOGD("Retrive Added path [%s]", peer_path);
1781
1782         loc = strrchr(peer_path, '/');
1783         if (loc != NULL)
1784                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
1785         __ws_txt_to_mac(peer_dev, event.dev_addr);
1786         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1787
1788         g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
1789         WDP_LOGD("Retrive pin [%s]", event.wps_pin);
1790
1791         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1792                         __ws_peer_property, event.edata);
1793
1794         g_pd->callback(g_pd->user_data, &event);
1795         g_free(event.edata);
1796
1797         __WDP_LOG_FUNC_EXIT__;
1798 }
1799
1800 static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
1801                 const gchar *object_path, GVariant *parameters)
1802 {
1803         __WDP_LOG_FUNC_ENTER__;
1804         wfd_oem_event_s event;
1805         wfd_oem_dev_data_s *edata = NULL;
1806         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1807
1808         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1809         if (!edata) {
1810                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1811                                 strerror(errno));
1812                 __WDP_LOG_FUNC_EXIT__;
1813                 return;
1814         }
1815         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1816
1817         event.edata = (void*) edata;
1818         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1819         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1820         event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
1821
1822         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1823
1824         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1825                         __ws_peer_property, event.edata);
1826
1827         g_pd->callback(g_pd->user_data, &event);
1828         g_free(event.edata);
1829
1830         __WDP_LOG_FUNC_EXIT__;
1831 }
1832
1833 static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
1834                 const gchar *object_path, GVariant *parameters)
1835 {
1836         __WDP_LOG_FUNC_ENTER__;
1837         wfd_oem_event_s event;
1838         wfd_oem_dev_data_s *edata = NULL;
1839         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1840
1841         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1842         if (!edata) {
1843                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1844                                 strerror(errno));
1845                 __WDP_LOG_FUNC_EXIT__;
1846                 return;
1847         }
1848         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1849
1850         event.edata = (void*) edata;
1851         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1852         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1853         event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
1854
1855         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1856
1857         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1858                         __ws_peer_property, event.edata);
1859
1860         g_pd->callback(g_pd->user_data, &event);
1861         g_free(event.edata);
1862
1863         __WDP_LOG_FUNC_EXIT__;
1864 }
1865
1866 static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
1867                 const gchar *object_path, GVariant *parameters)
1868 {
1869         __WDP_LOG_FUNC_ENTER__;
1870         wfd_oem_event_s event;
1871         wfd_oem_dev_data_s *edata = NULL;
1872         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1873
1874         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1875         if (!edata) {
1876                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1877                                 strerror(errno));
1878                 __WDP_LOG_FUNC_EXIT__;
1879                 return;
1880         }
1881         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1882
1883         event.edata = (void*) edata;
1884         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1885         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1886         event.wps_mode = WFD_OEM_WPS_MODE_PBC;
1887
1888         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1889
1890         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1891                         __ws_peer_property, event.edata);
1892
1893         g_pd->callback(g_pd->user_data, &event);
1894         g_free(event.edata);
1895
1896         __WDP_LOG_FUNC_EXIT__;
1897 }
1898
1899 static void _ws_process_prov_disc_pbc_resp(GDBusConnection *connection,
1900                 const gchar *object_path, GVariant *parameters)
1901 {
1902         __WDP_LOG_FUNC_ENTER__;
1903         wfd_oem_event_s event;
1904         wfd_oem_dev_data_s *edata = NULL;
1905         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1906
1907         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1908         if (!edata) {
1909                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1910                                 strerror(errno));
1911                 __WDP_LOG_FUNC_EXIT__;
1912                 return;
1913         }
1914         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1915
1916         event.edata = (void*) edata;
1917         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1918         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1919         event.wps_mode = WFD_OEM_WPS_MODE_PBC;
1920
1921         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1922
1923         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1924                         __ws_peer_property, event.edata);
1925
1926         g_pd->callback(g_pd->user_data, &event);
1927         g_free(event.edata);
1928
1929         __WDP_LOG_FUNC_EXIT__;
1930 }
1931
1932 #if defined(TIZEN_FEATURE_ASP)
1933 static void _ws_process_prov_disc_failure(GDBusConnection *connection,
1934                 const gchar *object_path, GVariant *parameters)
1935 {
1936         __WDP_LOG_FUNC_ENTER__;
1937         GVariantIter *iter = NULL;
1938         wfd_oem_event_s event;
1939         wfd_oem_asp_prov_s *edata;
1940
1941         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
1942         if (!edata) {
1943                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1944                                 strerror(errno));
1945                 __WDP_LOG_FUNC_EXIT__;
1946                 return;
1947         }
1948         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1949
1950         event.edata = (void*) edata;
1951         event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
1952
1953         if (parameters != NULL) {
1954                 g_variant_get(parameters, "(a{sv})", &iter);
1955                 if (iter != NULL) {
1956                         dbus_property_foreach(iter, __ws_extract_provision_fail_details, &event);
1957                         event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
1958                         g_variant_iter_free(iter);
1959                 }
1960         } else {
1961                 WDP_LOGE("No Properties");
1962         }
1963
1964         g_pd->callback(g_pd->user_data, &event);
1965
1966         if (event.edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV)
1967                 g_free(edata->session_information);
1968         g_free(edata);
1969
1970         __WDP_LOG_FUNC_EXIT__;
1971 }
1972 #else
1973 static void _ws_process_prov_disc_failure(GDBusConnection *connection,
1974                 const gchar *object_path, GVariant *parameters)
1975 {
1976         __WDP_LOG_FUNC_ENTER__;
1977         wfd_oem_event_s event;
1978         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1979         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1980         const char *path = NULL;
1981         int prov_status = 0;
1982         char *loc = NULL;
1983
1984         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1985
1986         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1987         event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
1988
1989         g_variant_get(parameters, "(&oi)", &path, &prov_status);
1990         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1991         WDP_LOGD("Retrive Added path [%s]", peer_path);
1992         WDP_LOGD("Retrive Failure stateus [%d]", prov_status);
1993
1994         loc = strrchr(peer_path, '/');
1995         if (loc != NULL)
1996                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
1997         __ws_txt_to_mac(peer_dev, event.dev_addr);
1998         WDP_LOGE("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1999
2000         g_pd->callback(g_pd->user_data, &event);
2001
2002         __WDP_LOG_FUNC_EXIT__;
2003 }
2004 #endif /* TIZEN_FEATURE_ASP */
2005
2006
2007 static void _ws_process_group_started(GDBusConnection *connection,
2008                 const gchar *object_path, GVariant *parameters)
2009 {
2010         __WDP_LOG_FUNC_ENTER__;
2011         GVariantIter *iter = NULL;
2012         wfd_oem_event_s event;
2013         wfd_oem_group_data_s *edata = NULL;
2014
2015         edata = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
2016         if (!edata) {
2017                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2018                                 strerror(errno));
2019                 __WDP_LOG_FUNC_EXIT__;
2020                 return;
2021         }
2022         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2023
2024         event.edata = (void*) edata;
2025         event.edata_type = WFD_OEM_EDATA_TYPE_GROUP;
2026         event.event_id = WFD_OEM_EVENT_GROUP_CREATED;
2027
2028         if (parameters != NULL) {
2029                 g_variant_get(parameters, "(a{sv})", &iter);
2030
2031                 if (iter != NULL) {
2032                         dbus_property_foreach(iter, __ws_extract_group_details, &event);
2033                         g_variant_iter_free(iter);
2034                 }
2035         } else {
2036                 WDP_LOGE("No properties");
2037         }
2038
2039         g_pd->callback(g_pd->user_data, &event);
2040         g_free(event.edata);
2041
2042         __WDP_LOG_FUNC_EXIT__;
2043 }
2044
2045 static void _ws_process_go_neg_success(GDBusConnection *connection,
2046                 const gchar *object_path, GVariant *parameters)
2047 {
2048         __WDP_LOG_FUNC_ENTER__;
2049         GVariantIter *iter = NULL;
2050         wfd_oem_event_s event;
2051         wfd_oem_conn_data_s *edata = NULL;
2052
2053         edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
2054         if (!edata) {
2055                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2056                                 strerror(errno));
2057                 __WDP_LOG_FUNC_EXIT__;
2058                 return;
2059         }
2060         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2061
2062         event.edata = edata;
2063         event.edata_type = WFD_OEM_EDATA_TYPE_CONN;
2064         event.event_id = WFD_OEM_EVENT_GO_NEG_DONE;
2065
2066         if (parameters != NULL) {
2067                 g_variant_get(parameters, "(a{sv})", &iter);
2068
2069                 if (iter != NULL) {
2070                         dbus_property_foreach(iter, __ws_extract_gonegsuccess_details, &event);
2071                         g_variant_iter_free(iter);
2072                 }
2073         } else {
2074                 WDP_LOGE("No properties");
2075         }
2076
2077         g_pd->callback(g_pd->user_data, &event);
2078         g_free(edata);
2079
2080         __WDP_LOG_FUNC_EXIT__;
2081 }
2082
2083 static void _ws_process_go_neg_failure(GDBusConnection *connection,
2084                 const gchar *object_path, GVariant *parameters)
2085 {
2086         __WDP_LOG_FUNC_ENTER__;
2087         GVariantIter *iter = NULL;
2088         wfd_oem_event_s event;
2089         wfd_oem_conn_data_s *edata = NULL;
2090
2091         edata = (wfd_oem_conn_data_s *) g_try_malloc0(sizeof(wfd_oem_conn_data_s));
2092         if (!edata) {
2093                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2094                                 strerror(errno));
2095                 __WDP_LOG_FUNC_EXIT__;
2096                 return;
2097         }
2098         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2099
2100         event.edata = (void*) edata;
2101         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
2102         event.event_id = WFD_OEM_EVENT_GO_NEG_FAIL;
2103
2104         if (parameters != NULL) {
2105                 g_variant_get(parameters, "(a{sv})", &iter);
2106
2107                 if (iter != NULL) {
2108                         dbus_property_foreach(iter, __ws_extract_gonegfailaure_details, &event);
2109                         g_variant_iter_free(iter);
2110                 }
2111         } else {
2112                 WDP_LOGE("No properties");
2113         }
2114
2115         g_pd->callback(g_pd->user_data, &event);
2116         g_free(event.edata);
2117
2118         __WDP_LOG_FUNC_EXIT__;
2119 }
2120
2121 static void _ws_process_go_neg_request(GDBusConnection *connection,
2122                 const gchar *object_path, GVariant *parameters)
2123 {
2124         __WDP_LOG_FUNC_ENTER__;
2125         wfd_oem_event_s event;
2126         wfd_oem_dev_data_s *edata = NULL;
2127         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2128         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
2129         const char *path = NULL;
2130         char * loc = NULL;
2131
2132         int dev_passwd_id = 0;
2133         int device_go_intent = 0;
2134
2135         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
2136         if (!edata) {
2137                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2138                                 strerror(errno));
2139                 __WDP_LOG_FUNC_EXIT__;
2140                 return;
2141         }
2142         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2143
2144         event.edata = (void*) edata;
2145         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
2146         event.event_id = WFD_OEM_EVENT_GO_NEG_REQ;
2147
2148         g_variant_get(parameters, "(&oqy)", &path, &dev_passwd_id, &device_go_intent);
2149         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
2150
2151         WDP_LOGD("Retrive peer path [%s]", peer_path);
2152         WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
2153         WDP_LOGD("Retrive device_go_intent [%d]", device_go_intent);
2154
2155         if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
2156                 event.wps_mode = WFD_OEM_WPS_MODE_PBC;
2157         else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
2158                 event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
2159         else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
2160                 event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
2161         else
2162                 event.wps_mode = WFD_OEM_WPS_MODE_NONE;
2163         edata->device_go_intent = device_go_intent;
2164
2165         loc = strrchr(peer_path, '/');
2166         if (loc != NULL)
2167                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
2168         __ws_txt_to_mac(peer_dev, event.dev_addr);
2169         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
2170
2171         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
2172                         __ws_peer_property, event.edata);
2173
2174         g_pd->callback(g_pd->user_data, &event);
2175         g_free(event.edata);
2176
2177         __WDP_LOG_FUNC_EXIT__;
2178 }
2179 static void _ws_process_invitation_received(GDBusConnection *connection,
2180                 const gchar *object_path, GVariant *parameters)
2181 {
2182         __WDP_LOG_FUNC_ENTER__;
2183         GVariantIter *iter = NULL;
2184         wfd_oem_event_s event;
2185         wfd_oem_invite_data_s *edata = NULL;
2186
2187         edata = (wfd_oem_invite_data_s *) g_try_malloc0(sizeof(wfd_oem_invite_data_s));
2188         if (!edata) {
2189                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2190                                 strerror(errno));
2191                 __WDP_LOG_FUNC_EXIT__;
2192                 return;
2193         }
2194         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2195
2196         event.edata = (void*) edata;
2197         event.edata_type = WFD_OEM_EDATA_TYPE_INVITE;
2198         event.event_id = WFD_OEM_EVENT_INVITATION_REQ;
2199
2200         if (parameters != NULL) {
2201                 g_variant_get(parameters, "(a{sv})", &iter);
2202
2203                 if (iter != NULL) {
2204                         dbus_property_foreach(iter, __ws_extract_invitation_details, &event);
2205                         g_variant_iter_free(iter);
2206                 }
2207         } else {
2208                 WDP_LOGE("No properties");
2209         }
2210         memcpy(&(event.dev_addr), edata->sa, OEM_MACADDR_LEN);
2211
2212         g_pd->callback(g_pd->user_data, &event);
2213         g_free(event.edata);
2214
2215         __WDP_LOG_FUNC_EXIT__;
2216 }
2217
2218 static void _ws_process_invitation_result(GDBusConnection *connection,
2219                 const gchar *object_path, GVariant *parameters)
2220 {
2221         __WDP_LOG_FUNC_ENTER__;
2222         wfd_oem_event_s event;
2223         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2224
2225         __WDP_LOG_FUNC_EXIT__;
2226 }
2227
2228 static void _ws_process_group_finished(GDBusConnection *connection,
2229                 const gchar *object_path, GVariant *parameters)
2230 {
2231         __WDP_LOG_FUNC_ENTER__;
2232         wfd_oem_event_s event;
2233
2234         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2235
2236         event.event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
2237         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2238
2239         g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, g_pd->group_sub_id);
2240         memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
2241         _ws_flush();
2242
2243         g_pd->callback(g_pd->user_data, &event);
2244
2245         __WDP_LOG_FUNC_EXIT__;
2246 }
2247
2248 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
2249 static void _ws_process_service_discovery_response(GDBusConnection *connection,
2250                 const gchar *object_path, GVariant *parameters)
2251 {
2252         __WDP_LOG_FUNC_ENTER__;
2253         GVariantIter *iter = NULL;
2254         wfd_oem_event_s event;
2255
2256         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2257
2258         event.event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
2259
2260         if (parameters != NULL) {
2261                 g_variant_get(parameters, "(a{sv})", &iter);
2262                 if (iter != NULL) {
2263                         dbus_property_foreach(iter, __ws_extract_servicediscoveryresponse_details, &event);
2264                         event.edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
2265                         g_variant_iter_free(iter);
2266                 }
2267         } else {
2268                 WDP_LOGE("No Properties");
2269         }
2270
2271         g_pd->callback(g_pd->user_data, &event);
2272
2273         if (event.edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE)
2274                 g_list_free((GList*) event.edata);
2275
2276         __WDP_LOG_FUNC_EXIT__;
2277 }
2278 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
2279
2280 #if defined(TIZEN_FEATURE_ASP)
2281 static void _ws_process_service_asp_response(GDBusConnection *connection,
2282                 const gchar *object_path, GVariant *parameters)
2283 {
2284         __WDP_LOG_FUNC_ENTER__;
2285         GVariantIter *iter = NULL;
2286         wfd_oem_event_s event;
2287         wfd_oem_asp_service_s *service = NULL;
2288         wfd_oem_asp_service_s *tmp = NULL;
2289
2290         service = (wfd_oem_asp_service_s *) g_try_malloc0(sizeof(wfd_oem_asp_service_s));
2291         if (!service) {
2292                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2293                                 strerror(errno));
2294                 __WDP_LOG_FUNC_EXIT__;
2295                 return;
2296         }
2297         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2298
2299         event.edata = (void*) service;
2300         event.edata_type = WFD_OEM_EDATA_TYPE_ASP_SERVICE;
2301         event.event_id = WFD_OEM_EVENT_ASP_SERV_RESP;
2302
2303         if (parameters != NULL) {
2304                 g_variant_get(parameters, "(a{sv})", &iter);
2305                 if (iter != NULL) {
2306                         dbus_property_foreach(iter, __ws_extract_serviceaspresponse_details, &event);
2307                         g_variant_iter_free(iter);
2308                 }
2309         } else {
2310                 WDP_LOGE("No Properties");
2311         }
2312 GLIST_ITER_START(seek_list, tmp)
2313         if (tmp->tran_id == service->tran_id) {
2314                 WDP_LOGD("srv_trans_id matched [%d] search_id [%llu]"
2315                                 , tmp->tran_id, tmp->search_id);
2316                 service->search_id = tmp->search_id;
2317                 break;
2318         } else {
2319                 tmp = NULL;
2320         }
2321 GLIST_ITER_END()
2322
2323         if (tmp != NULL && tmp->service_info != NULL)
2324                 g_pd->callback(g_pd->user_data, &event);
2325         else
2326                 WDP_LOGD("service info is not required, don't notify to user");
2327
2328         g_free(service->service_type);
2329         g_free(service->service_info);
2330         g_free(service);
2331
2332         __WDP_LOG_FUNC_EXIT__;
2333 }
2334 #endif /* TIZEN_FEATURE_ASP */
2335
2336 static void _ws_process_persistent_group_added(GDBusConnection *connection,
2337                 const gchar *object_path, GVariant *parameters)
2338 {
2339         __WDP_LOG_FUNC_ENTER__;
2340         wfd_oem_event_s event;
2341         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2342
2343         __WDP_LOG_FUNC_EXIT__;
2344 }
2345
2346 static void _ws_process_persistent_group_removed(GDBusConnection *connection,
2347                 const gchar *object_path, GVariant *parameters)
2348 {
2349         __WDP_LOG_FUNC_ENTER__;
2350         wfd_oem_event_s event;
2351         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2352
2353         __WDP_LOG_FUNC_EXIT__;
2354 }
2355
2356 static void _ws_process_wps_failed(GDBusConnection *connection,
2357                 const gchar *object_path, GVariant *parameters)
2358 {
2359         __WDP_LOG_FUNC_ENTER__;
2360         GVariantIter *iter = NULL;
2361         wfd_oem_event_s event;
2362         const char *name = NULL;
2363
2364         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2365
2366         event.event_id = WFD_OEM_EVENT_WPS_FAIL;
2367         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2368
2369         g_variant_get(parameters, "(&sa{sv})", &name, &iter);
2370
2371         WDP_LOGD("code [%s]", name);
2372
2373         if (iter != NULL) {
2374
2375                 gchar *key = NULL;
2376                 GVariant *value = NULL;
2377
2378                 while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
2379 #if defined(TIZEN_DEBUG_DBUS_VALUE)
2380                         CHECK_KEY_VALUE(key, value);
2381 #endif /* TIZEN_DEBUG_DBUS_VALUE */
2382                 }
2383                 g_variant_iter_free(iter);
2384         }
2385
2386         g_pd->callback(g_pd->user_data, &event);
2387
2388         __WDP_LOG_FUNC_EXIT__;
2389 }
2390
2391 static void _ws_process_group_formation_failure(GDBusConnection *connection,
2392                 const gchar *object_path, GVariant *parameters)
2393 {
2394         __WDP_LOG_FUNC_ENTER__;
2395         wfd_oem_event_s event;
2396
2397         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2398
2399         event.event_id = WFD_OEM_EVENT_GROUP_FORMATION_FAILURE;
2400         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2401
2402         g_pd->callback(g_pd->user_data, &event);
2403
2404         __WDP_LOG_FUNC_EXIT__;
2405 }
2406
2407 static void _ws_process_invitation_accepted(GDBusConnection *connection,
2408                 const gchar *object_path, GVariant *parameters)
2409 {
2410         __WDP_LOG_FUNC_ENTER__;
2411         GVariantIter *iter = NULL;
2412         wfd_oem_event_s event;
2413
2414         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2415
2416         event.event_id = WFD_OEM_EVENT_INVITATION_ACCEPTED;
2417         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2418
2419         if (parameters != NULL) {
2420                 g_variant_get(parameters, "(a{sv})", &iter);
2421
2422                 if (iter != NULL) {
2423                         gchar *key = NULL;
2424                         GVariant *value = NULL;
2425
2426                         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
2427                                 CHECK_KEY_VALUE(key, value);
2428                                 if (g_strcmp0(key, "sa") == 0)
2429                                         if (__ws_unpack_ay(event.dev_addr, value, WS_MACADDR_LEN))
2430                                                 WDP_LOGI("[" MACSTR "]", MAC2STR(event.dev_addr));
2431                         }
2432                         g_variant_iter_free(iter);
2433                 }
2434         }
2435
2436         g_pd->callback(g_pd->user_data, &event);
2437         __WDP_LOG_FUNC_EXIT__;
2438 }
2439
2440 #if defined(TIZEN_FEATURE_ASP)
2441 static void _ws_process_asp_provision_start(GDBusConnection *connection,
2442                 const gchar *object_path, GVariant *parameters)
2443 {
2444         __WDP_LOG_FUNC_ENTER__;
2445         GVariantIter *iter = NULL;
2446         wfd_oem_event_s event;
2447         wfd_oem_asp_prov_s *edata;
2448
2449         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
2450         if (!edata) {
2451                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2452                                 strerror(errno));
2453                 __WDP_LOG_FUNC_EXIT__;
2454                 return;
2455         }
2456         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2457
2458         event.edata = (void*) edata;
2459         event.event_id = WFD_OEM_EVENT_ASP_PROV_START;
2460
2461         if (parameters != NULL) {
2462                 g_variant_get(parameters, "(a{sv})", &iter);
2463                 if (iter != NULL) {
2464                         dbus_property_foreach(iter, __ws_extract_asp_provision_start_details, &event);
2465                         event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
2466                         g_variant_iter_free(iter);
2467                 }
2468         } else {
2469                 WDP_LOGE("No Properties");
2470         }
2471
2472         g_pd->callback(g_pd->user_data, &event);
2473
2474         if (event.edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV)
2475                 g_free(edata->session_information);
2476         g_free(edata);
2477
2478         __WDP_LOG_FUNC_EXIT__;
2479 }
2480
2481 static void _ws_process_asp_provision_done(GDBusConnection *connection,
2482                 const gchar *object_path, GVariant *parameters)
2483 {
2484         __WDP_LOG_FUNC_ENTER__;
2485         GVariantIter *iter = NULL;
2486         wfd_oem_event_s event;
2487         wfd_oem_asp_prov_s *edata;
2488
2489         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
2490         if (!edata) {
2491                 WDP_LOGF("Failed to allocate memory for event. [%s]",
2492                                 strerror(errno));
2493                 __WDP_LOG_FUNC_EXIT__;
2494                 return;
2495         }
2496         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2497
2498         event.edata = (void*) edata;
2499         event.event_id = WFD_OEM_EVENT_ASP_PROV_DONE;
2500
2501         if (parameters != NULL) {
2502                 g_variant_get(parameters, "(a{sv})", &iter);
2503                 if (iter != NULL) {
2504                         dbus_property_foreach(iter, __ws_extract_asp_provision_done_details, &event);
2505                         event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
2506                         g_variant_iter_free(iter);
2507                 }
2508         } else {
2509                 WDP_LOGE("No Properties");
2510         }
2511
2512         g_pd->callback(g_pd->user_data, &event);
2513         g_free(edata);
2514
2515         __WDP_LOG_FUNC_EXIT__;
2516 }
2517 #endif /* TIZEN_FEATURE_ASP */
2518
2519 static struct {
2520         const char *interface;
2521         const char *member;
2522         void (*function) (GDBusConnection *connection, const gchar *object_path,
2523                         GVariant *parameters);
2524 } ws_p2pdevice_signal_map[] = {
2525         {
2526                 SUPPLICANT_P2PDEVICE,
2527                 "DeviceFound",
2528                 _ws_process_device_found
2529         },
2530         {
2531                 SUPPLICANT_P2PDEVICE,
2532                 "DeviceLost",
2533                 _ws_process_device_lost
2534         },
2535         {
2536                 SUPPLICANT_P2PDEVICE,
2537                 "FindStopped",
2538                 _ws_process_find_stoppped
2539         },
2540         {
2541                 SUPPLICANT_P2PDEVICE,
2542                 "ProvisionDiscoveryRequestDisplayPin",
2543                 _ws_process_prov_disc_req_display_pin
2544         },
2545         {
2546                 SUPPLICANT_P2PDEVICE,
2547                 "ProvisionDiscoveryResponseDisplayPin",
2548                 _ws_process_prov_disc_resp_display_pin
2549         },
2550         {
2551                 SUPPLICANT_P2PDEVICE,
2552                 "ProvisionDiscoveryRequestEnterPin",
2553                 _ws_process_prov_disc_req_enter_pin
2554         },
2555         {
2556                 SUPPLICANT_P2PDEVICE,
2557                 "ProvisionDiscoveryResponseEnterPin",
2558                 _ws_process_prov_disc_resp_enter_pin
2559         },
2560         {
2561                 SUPPLICANT_P2PDEVICE,
2562                 "ProvisionDiscoveryPBCRequest",
2563                 _ws_process_prov_disc_pbc_req
2564         },
2565         {
2566                 SUPPLICANT_P2PDEVICE,
2567                 "ProvisionDiscoveryPBCResponse",
2568                 _ws_process_prov_disc_pbc_resp
2569         },
2570         {
2571                 SUPPLICANT_P2PDEVICE,
2572                 "ProvisionDiscoveryFailure",
2573                 _ws_process_prov_disc_failure
2574         },
2575         {
2576                 SUPPLICANT_P2PDEVICE,
2577                 "GroupStarted",
2578                 _ws_process_group_started
2579         },
2580         {
2581                 SUPPLICANT_P2PDEVICE,
2582                 "GONegotiationSuccess",
2583                 _ws_process_go_neg_success
2584         },
2585         {
2586                 SUPPLICANT_P2PDEVICE,
2587                 "GONegotiationFailure",
2588                 _ws_process_go_neg_failure
2589         },
2590         {
2591                 SUPPLICANT_P2PDEVICE,
2592                 "GONegotiationRequest",
2593                 _ws_process_go_neg_request
2594         },
2595         {
2596                 SUPPLICANT_P2PDEVICE,
2597                 "InvitationReceived",
2598                 _ws_process_invitation_received
2599         },
2600         {
2601                 SUPPLICANT_P2PDEVICE,
2602                 "InvitationResult",
2603                 _ws_process_invitation_result
2604         },
2605         {
2606                 SUPPLICANT_P2PDEVICE,
2607                 "GroupFinished",
2608                 _ws_process_group_finished
2609         },
2610 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
2611         {
2612                 SUPPLICANT_P2PDEVICE,
2613                 "ServiceDiscoveryResponse",
2614                 _ws_process_service_discovery_response
2615         },
2616 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
2617 #if defined(TIZEN_FEATURE_ASP)
2618         {
2619                 SUPPLICANT_P2PDEVICE,
2620                 "ServiceASPResponse",
2621                 _ws_process_service_asp_response
2622         },
2623         {
2624                 SUPPLICANT_P2PDEVICE,
2625                 "ASPProvisionStart",
2626                 _ws_process_asp_provision_start
2627         },
2628         {
2629                 SUPPLICANT_P2PDEVICE,
2630                 "ASPProvisionDone",
2631                 _ws_process_asp_provision_done
2632         },
2633 #endif /* TIZEN_FEATURE_ASP */
2634         {
2635                 SUPPLICANT_P2PDEVICE,
2636                 "PersistentGroupAdded",
2637                 _ws_process_persistent_group_added
2638         },
2639         {
2640                 SUPPLICANT_P2PDEVICE,
2641                 "PersistentGroupRemoved",
2642                 _ws_process_persistent_group_removed
2643         },
2644         {
2645                 SUPPLICANT_P2PDEVICE,
2646                 "WpsFailed",
2647                 _ws_process_wps_failed
2648         },
2649         {
2650                 SUPPLICANT_P2PDEVICE,
2651                 "GroupFormationFailure",
2652                 _ws_process_group_formation_failure
2653         },
2654         {
2655                 SUPPLICANT_P2PDEVICE,
2656                 "InvitationAccepted",
2657                 _ws_process_invitation_accepted
2658         },
2659         {
2660                 NULL,
2661                 NULL,
2662                 NULL
2663         }
2664 };
2665
2666 static void _p2pdevice_signal_cb(GDBusConnection *connection,
2667                 const gchar *sender, const gchar *object_path, const gchar *interface,
2668                 const gchar *signal, GVariant *parameters, gpointer user_data)
2669 {
2670         int i = 0;
2671 #if defined(TIZEN_DEBUG_DBUS_VALUE)
2672         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
2673 #endif /* TIZEN_DEBUG_DBUS_VALUE */
2674
2675         if (!g_pd) {
2676                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2677                 return;
2678         }
2679
2680         for (i = 0; ws_p2pdevice_signal_map[i].member != NULL; i++) {
2681                 if (!g_strcmp0(signal, ws_p2pdevice_signal_map[i].member) &&
2682                                 ws_p2pdevice_signal_map[i].function != NULL)
2683                         ws_p2pdevice_signal_map[i].function(connection, object_path, parameters);
2684         }
2685 }
2686
2687
2688 static void _ws_process_sta_authorized(GDBusConnection *connection,
2689                 const gchar *object_path, GVariant *parameters)
2690 {
2691         __WDP_LOG_FUNC_ENTER__;
2692         wfd_oem_event_s event;
2693         const gchar* mac_str = NULL;
2694
2695         if (is_peer_joined_notified) {
2696                 is_peer_joined_notified = 0;
2697                 __WDP_LOG_FUNC_EXIT__;
2698                 return;
2699         }
2700
2701         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2702         g_variant_get(parameters, "(&s)", &mac_str);
2703         __ws_txt_to_mac((unsigned char *)mac_str, event.intf_addr);
2704
2705         event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
2706         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2707
2708         g_pd->callback(g_pd->user_data, &event);
2709         __WDP_LOG_FUNC_EXIT__;
2710 }
2711
2712 static void _ws_process_sta_deauthorized(GDBusConnection *connection,
2713                 const gchar *object_path, GVariant *parameters)
2714 {
2715         __WDP_LOG_FUNC_ENTER__;
2716         wfd_oem_event_s event;
2717         const gchar* mac_str = NULL;
2718
2719         if (is_peer_disconnected_notified) {
2720                 is_peer_disconnected_notified = 0;
2721                 __WDP_LOG_FUNC_EXIT__;
2722                 return;
2723         }
2724
2725         memset(&event, 0x0, sizeof(wfd_oem_event_s));
2726         g_variant_get(parameters, "(&s)", &mac_str);
2727         __ws_txt_to_mac((unsigned char *)mac_str, event.intf_addr);
2728
2729         event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
2730         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2731
2732         g_pd->callback(g_pd->user_data, &event);
2733         __WDP_LOG_FUNC_EXIT__;
2734 }
2735
2736 static struct {
2737         const char *interface;
2738         const char *member;
2739         void (*function) (GDBusConnection *connection, const gchar *object_path,
2740                         GVariant *parameters);
2741 } ws_interface_signal_map[] = {
2742         {
2743                 SUPPLICANT_INTERFACE,
2744                 "StaAuthorized",
2745                 _ws_process_sta_authorized
2746         },
2747         {
2748                 SUPPLICANT_INTERFACE,
2749                 "StaDeauthorized",
2750                 _ws_process_sta_deauthorized
2751         },
2752         {
2753                 NULL,
2754                 NULL,
2755                 NULL
2756         }
2757 };
2758
2759 static void _interface_signal_cb(GDBusConnection *connection,
2760                 const gchar *sender, const gchar *object_path, const gchar *interface,
2761                 const gchar *signal, GVariant *parameters, gpointer user_data)
2762 {
2763         int i = 0;
2764 #if defined(TIZEN_DEBUG_DBUS_VALUE)
2765         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
2766 #endif /* TIZEN_DEBUG_DBUS_VALUE */
2767
2768         if (!g_pd) {
2769                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2770                 __WDP_LOG_FUNC_EXIT__;
2771                 return;
2772         }
2773
2774         for (i = 0; ws_interface_signal_map[i].member != NULL; i++) {
2775                 if (!g_strcmp0(signal, ws_interface_signal_map[i].member) &&
2776                                 ws_interface_signal_map[i].function != NULL)
2777                         ws_interface_signal_map[i].function(connection, object_path, parameters);
2778         }
2779 }
2780
2781
2782 static void __ws_parse_peer_joined(char *peer_path,
2783                 unsigned char *dev_addr, unsigned char *ip_addr, GVariant *parameter)
2784 {
2785         __WDP_LOG_FUNC_ENTER__;
2786
2787         GVariantIter *iter;
2788         static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
2789         const char *path = NULL;
2790         char *loc = NULL;
2791 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
2792         int i = 0;
2793 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
2794
2795         g_variant_get(parameter, "(&oay)", &path, &iter);
2796         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
2797         WDP_LOGD("Retrive Added path [%s]", peer_path);
2798
2799         loc = strrchr(peer_path, '/');
2800         if (loc != NULL)
2801                 __ws_mac_compact_to_normal(loc + 1, peer_dev);
2802         __ws_txt_to_mac(peer_dev, dev_addr);
2803         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
2804 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
2805         for (i = 0; i < OEM_IPADDR_LEN; i++)
2806                 g_variant_iter_loop(iter, "y", &ip_addr[i]);
2807         g_variant_iter_free(iter);
2808
2809         WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
2810 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
2811
2812         __WDP_LOG_FUNC_EXIT__;
2813         return;
2814 }
2815
2816
2817 static void _group_signal_cb(GDBusConnection *connection,
2818                 const gchar *sender, const gchar *object_path, const gchar *interface,
2819                 const gchar *signal, GVariant *parameters, gpointer user_data)
2820 {
2821 #if defined(TIZEN_DEBUG_DBUS_VALUE)
2822         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
2823 #endif /* TIZEN_DEBUG_DBUS_VALUE */
2824
2825         if (!g_pd) {
2826                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2827                 return;
2828         }
2829
2830         if (!g_strcmp0(signal, "PeerJoined")) {
2831
2832                 wfd_oem_event_s event;
2833                 wfd_oem_dev_data_s *edata = NULL;
2834
2835                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2836
2837                 edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
2838                 if (!edata) {
2839                         WDP_LOGF("Failed to allocate memory for event. [%s]",
2840                                         strerror(errno));
2841                         __WDP_LOG_FUNC_EXIT__;
2842                         return;
2843                 }
2844                 memset(&event, 0x0, sizeof(wfd_oem_event_s));
2845
2846                 event.edata = (void*) edata;
2847                 event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
2848                 event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
2849
2850                 __ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
2851
2852                 dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
2853                                 __ws_peer_property, event.edata);
2854
2855                 g_pd->callback(g_pd->user_data, &event);
2856                 is_peer_joined_notified = 1;
2857
2858                 g_free(edata);
2859
2860         } else if (!g_strcmp0(signal, "PeerDisconnected")) {
2861
2862                 wfd_oem_event_s event;
2863
2864                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2865
2866                 memset(&event, 0x0, sizeof(wfd_oem_event_s));
2867
2868                 event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
2869                 event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
2870
2871                 __ws_path_to_addr(peer_path, event.dev_addr, parameters);
2872
2873                 g_pd->callback(g_pd->user_data, &event);
2874                 is_peer_disconnected_notified = 1;
2875         }
2876 }
2877
2878 static void __register_p2pdevice_signal(GVariant *value, void *user_data)
2879 {
2880         __WDP_LOG_FUNC_ENTER__;
2881         ws_dbus_plugin_data_s * pd_data;
2882         static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2883         const char *path = NULL;
2884
2885         if (!g_pd) {
2886                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2887                 return;
2888         }
2889
2890         pd_data = (ws_dbus_plugin_data_s *)g_pd;
2891
2892         g_variant_get(value, "(&o)", &path);
2893         g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
2894         g_strlcpy(pd_data->iface_path, path, DBUS_OBJECT_PATH_MAX);
2895
2896         WDP_LOGD("interface object path [%s]", interface_path);
2897
2898         /* subscribe Interface iface signal */
2899         pd_data->iface_sub_id = g_dbus_connection_signal_subscribe(
2900                 pd_data->g_dbus,
2901                 SUPPLICANT_SERVICE, /* bus name */
2902                 SUPPLICANT_IFACE, /* interface */
2903                 NULL, /* member */
2904                 NULL, /* object path */
2905                 NULL, /* arg0 */
2906                 G_DBUS_SIGNAL_FLAGS_NONE,
2907                 _interface_signal_cb,
2908                 NULL, NULL);
2909         WDP_LOGD("Subscribed Interface iface signal: [%d]", pd_data->iface_sub_id);
2910
2911         /* subscribe P2PDevice iface signal */
2912         pd_data->p2pdevice_sub_id = g_dbus_connection_signal_subscribe(
2913                 pd_data->g_dbus,
2914                 SUPPLICANT_SERVICE, /* bus name */
2915                 SUPPLICANT_P2PDEVICE, /* interface */
2916                 NULL, /* member */
2917                 NULL, /* object path */
2918                 NULL, /* arg0 */
2919                 G_DBUS_SIGNAL_FLAGS_NONE,
2920                 _p2pdevice_signal_cb,
2921                 NULL, NULL);
2922         WDP_LOGD("Subscribed P2PDevice iface signal: [%d]", pd_data->p2pdevice_sub_id);
2923         __WDP_LOG_FUNC_EXIT__;
2924 }
2925
2926 static int _ws_create_interface(const char *iface_name, handle_reply function, void *user_data)
2927 {
2928         __WDP_LOG_FUNC_ENTER__;
2929         GDBusConnection *g_dbus = NULL;
2930         GVariantBuilder *builder = NULL;
2931         dbus_method_param_s params;
2932
2933         int res = 0;
2934
2935         if (!g_pd) {
2936                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2937                 return -1;
2938         }
2939
2940         g_dbus = g_pd->g_dbus;
2941         if (!g_dbus) {
2942                 WDP_LOGE("DBus connection is NULL");
2943                 return -1;
2944         }
2945         memset(&params, 0x0, sizeof(dbus_method_param_s));
2946
2947         dbus_set_method_param(&params, "CreateInterface", SUPPLICANT_PATH, g_dbus);
2948
2949         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2950         g_variant_builder_add(builder, "{sv}", "Ifname", g_variant_new_string(iface_name));
2951         g_variant_builder_add(builder, "{sv}", "ConfigFile", g_variant_new_string(CONF_FILE_PATH));
2952         params.params = g_variant_new("(a{sv})", builder);
2953         g_variant_builder_unref(builder);
2954         res = dbus_method_call(&params, SUPPLICANT_INTERFACE, function, user_data);
2955         if (res < 0)
2956                 WDP_LOGE("Failed to send command to wpa_supplicant");
2957         else
2958                 WDP_LOGD("Succeeded to CreateInterface");
2959
2960         __WDP_LOG_FUNC_EXIT__;
2961         return 0;
2962 }
2963
2964 static int _ws_get_interface(const char *iface_name, handle_reply function, void *user_data)
2965 {
2966         __WDP_LOG_FUNC_ENTER__;
2967         GDBusConnection *g_dbus = NULL;
2968         dbus_method_param_s params;
2969         int res = 0;
2970
2971         if (!g_pd) {
2972                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
2973                 return -1;
2974         }
2975
2976         g_dbus = g_pd->g_dbus;
2977         if (!g_dbus) {
2978                 WDP_LOGE("DBus connection is NULL");
2979                 return -1;
2980         }
2981
2982         dbus_set_method_param(&params, SUPPLICANT_METHOD_GETINTERFACE,
2983                         SUPPLICANT_PATH, g_pd->g_dbus);
2984
2985         params.params = g_variant_new("(s)", iface_name);
2986 #if defined(TIZEN_DEBUG_DBUS_VALUE)
2987         DEBUG_PARAMS(params.params);
2988 #endif /* TIZEN_DEBUG_DBUS_VALUE */
2989
2990         res = dbus_method_call(&params, SUPPLICANT_INTERFACE,
2991                         function, user_data);
2992
2993         if (res < 0)
2994                 WDP_LOGE("Failed to send command to wpa_supplicant");
2995         else
2996                 WDP_LOGD("Succeeded to get interface");
2997
2998         __WDP_LOG_FUNC_EXIT__;
2999         return res;
3000 }
3001
3002 #if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
3003 static void __ws_remove_interface(GVariant *value, void *user_data)
3004 {
3005         __WDP_LOG_FUNC_ENTER__;
3006         GDBusConnection *g_dbus = NULL;
3007         dbus_method_param_s params;
3008         const char *path = NULL;
3009         static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
3010         int res = 0;
3011
3012         if (!g_pd) {
3013                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3014                 return;
3015         }
3016
3017         g_dbus = g_pd->g_dbus;
3018         if (!g_dbus) {
3019                 WDP_LOGE("DBus connection is NULL");
3020                 return;
3021         }
3022
3023         g_variant_get(value, "(&o)", &path);
3024         g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
3025         WDP_LOGD("interface object path [%s]", interface_path);
3026
3027         memset(&params, 0x0, sizeof(dbus_method_param_s));
3028
3029         dbus_set_method_param(&params, "RemoveInterface", SUPPLICANT_PATH, g_dbus);
3030         params.params = g_variant_new("(o)", interface_path);
3031
3032         res = dbus_method_call(&params, SUPPLICANT_INTERFACE, NULL, NULL);
3033         if (res < 0)
3034                 WDP_LOGE("Failed to send command to wpa_supplicant");
3035         else
3036                 WDP_LOGD("Succeeded to RemoveInterface");
3037
3038         __WDP_LOG_FUNC_EXIT__;
3039         return;
3040 }
3041 #endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
3042
3043 static int _ws_init_dbus_connection(void)
3044 {
3045         __WDP_LOG_FUNC_ENTER__;
3046         GDBusConnection *conn = NULL;
3047         GError *error = NULL;
3048         int res = 0;
3049
3050         if (!g_pd) {
3051                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3052                 return -1;
3053         }
3054
3055         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
3056
3057         if (conn == NULL) {
3058                 if (error != NULL) {
3059                         WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
3060                                         error->message);
3061                         g_error_free(error);
3062                 }
3063                 __WDP_LOG_FUNC_EXIT__;
3064                 return -1;
3065         }
3066
3067         g_pd->g_dbus = conn;
3068
3069         /* subscribe supplicant signal */
3070         g_pd->supp_sub_id = g_dbus_connection_signal_subscribe(
3071                 g_pd->g_dbus,
3072                 SUPPLICANT_SERVICE, /* bus name */
3073                 SUPPLICANT_INTERFACE, /* interface */
3074                 NULL, /* member */
3075                 SUPPLICANT_PATH, /* object path */
3076                 NULL, /* arg0 */
3077                 G_DBUS_SIGNAL_FLAGS_NONE,
3078                 _supplicant_signal_cb,
3079                 NULL, NULL);
3080         WDP_LOGD("Subscribed supplicant iface signal: [%d]", g_pd->supp_sub_id);
3081
3082 #if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
3083         if (_ws_get_interface(COMMON_IFACE_NAME, NULL, NULL) < 0)
3084                 _ws_create_interface(COMMON_IFACE_NAME, NULL, NULL);
3085         if (_ws_get_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
3086                 res = _ws_create_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL);
3087 #else /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
3088         if (_ws_get_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
3089                 res = _ws_create_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL);
3090 #endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
3091
3092         if (res < 0)
3093                 WDP_LOGE("Failed to subscribe interface signal");
3094         else
3095                 WDP_LOGI("Successfully register signal filters");
3096
3097         __WDP_LOG_FUNC_EXIT__;
3098         return res;
3099 }
3100
3101 static int _ws_deinit_dbus_connection(void)
3102 {
3103         GDBusConnection *g_dbus = NULL;
3104
3105         if (!g_pd) {
3106                 WDP_LOGE("Invalid parameter");
3107                 __WDP_LOG_FUNC_EXIT__;
3108                 return -1;
3109         }
3110
3111         g_dbus = g_pd->g_dbus;
3112         if (!g_dbus) {
3113                 WDP_LOGE("DBus connection is NULL");
3114                 return -1;
3115         }
3116
3117         g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->supp_sub_id);
3118         g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->iface_sub_id);
3119         g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->p2pdevice_sub_id);
3120         g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->group_sub_id);
3121
3122         g_pd->group_iface_sub_id = 0;
3123         g_pd->iface_sub_id = 0;
3124         g_pd->p2pdevice_sub_id = 0;
3125         g_pd->group_sub_id = 0;
3126         memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
3127         memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
3128
3129         g_object_unref(g_dbus);
3130         return 0;
3131 }
3132
3133 int wfd_plugin_load(wfd_oem_ops_s **ops)
3134 {
3135         if (!ops) {
3136                 WDP_LOGE("Invalid parameter");
3137                 return -1;
3138         }
3139
3140         *ops = &supplicant_ops;
3141
3142         return 0;
3143 }
3144
3145 static int _ws_reset_plugin(ws_dbus_plugin_data_s *f_pd)
3146 {
3147         __WDP_LOG_FUNC_ENTER__;
3148
3149         if (!f_pd) {
3150                 WDP_LOGE("Invalid parameter");
3151                 __WDP_LOG_FUNC_EXIT__;
3152                 return -1;
3153         }
3154
3155         _ws_deinit_dbus_connection();
3156
3157         if (f_pd->activated)
3158                 ws_deactivate(f_pd->concurrent);
3159
3160         g_free(f_pd);
3161
3162         __WDP_LOG_FUNC_EXIT__;
3163         return 0;
3164 }
3165
3166 #ifndef TIZEN_WIFI_MODULE_BUNDLE
3167 static int __ws_check_net_interface(char* if_name)
3168 {
3169         struct ifreq ifr;
3170         int fd;
3171
3172         if (if_name == NULL) {
3173                 WDP_LOGE("Invalid param");
3174                 return -1;
3175         }
3176
3177         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
3178         if (fd < 0) {
3179                 WDP_LOGE("socket create error: %d", fd);
3180                 return -2;
3181         }
3182
3183         memset(&ifr, 0, sizeof(ifr));
3184         strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
3185         ifr.ifr_name[IFNAMSIZ-1] = '\0';
3186
3187         if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
3188                 close(fd);
3189                 WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s [ %s ]", strerror(errno), if_name); /* interface is not found. */
3190                 return -3;
3191         }
3192
3193         close(fd);
3194
3195         if (ifr.ifr_flags & IFF_UP) {
3196                 WDP_LOGD("%s interface is up", if_name);
3197                 return 1;
3198         } else if (!(ifr.ifr_flags & IFF_UP)) {
3199                 WDP_LOGD("%s interface is down", if_name);
3200                 return 0;
3201         }
3202         return 0;
3203 }
3204 #endif
3205
3206 int ws_init(wfd_oem_event_cb callback, void *user_data)
3207 {
3208         __WDP_LOG_FUNC_ENTER__;
3209
3210         if (g_pd)
3211                 _ws_reset_plugin(g_pd);
3212
3213         errno = 0;
3214         g_pd = (ws_dbus_plugin_data_s*) g_try_malloc0(sizeof(ws_dbus_plugin_data_s));
3215         if (!g_pd) {
3216                 WDP_LOGE("Failed to allocate memory for plugin data. [%s]", strerror(errno));
3217                 return -1;
3218         }
3219
3220         g_pd->callback = callback;
3221         g_pd->user_data = user_data;
3222         g_pd->initialized = TRUE;
3223
3224         __WDP_LOG_FUNC_EXIT__;
3225         return 0;
3226 }
3227
3228 int ws_deinit()
3229 {
3230         __WDP_LOG_FUNC_ENTER__;
3231
3232         if (g_pd) {
3233                 _ws_reset_plugin(g_pd);
3234                 g_pd = NULL;
3235         }
3236
3237         __WDP_LOG_FUNC_EXIT__;
3238         return 0;
3239 }
3240
3241 gboolean _ws_util_execute_file(const char *file_path,
3242         char *const args[], char *const envs[])
3243 {
3244         pid_t pid = 0;
3245         int rv = 0;
3246         errno = 0;
3247         register unsigned int index = 0;
3248
3249         while (args[index] != NULL) {
3250                 WDP_LOGD("[%s]", args[index]);
3251                 index++;
3252         }
3253
3254         if (!(pid = fork())) {
3255                 WDP_LOGD("pid(%d), ppid(%d)", getpid(), getppid());
3256                 WDP_LOGD("Inside child, exec (%s) command", file_path);
3257
3258                 errno = 0;
3259                 if (execve(file_path, args, envs) == -1) {
3260                         WDP_LOGE("Fail to execute command (%s)", strerror(errno));
3261                         exit(1);
3262                 }
3263         } else if (pid > 0) {
3264                 if (waitpid(pid, &rv, 0) == -1)
3265                         WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
3266                 if (WIFEXITED(rv))
3267                         WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
3268                 else if (WIFSIGNALED(rv))
3269                         WDP_LOGD("killed by signal %d", WTERMSIG(rv));
3270                 else if (WIFSTOPPED(rv))
3271                         WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
3272                 else if (WIFCONTINUED(rv))
3273                         WDP_LOGD("continued");
3274
3275                 return TRUE;
3276         }
3277
3278         WDP_LOGE("failed to fork (%s)", strerror(errno));
3279         return FALSE;
3280 }
3281
3282 #ifndef TIZEN_WIFI_MODULE_BUNDLE
3283 static int __ws_p2p_firmware_start(void)
3284 {
3285         gboolean rv = FALSE;
3286         const char *path = "/usr/bin/wlan.sh";
3287         char *const args[] = { "/usr/bin/wlan.sh", "p2p", NULL };
3288         char *const envs[] = { NULL };
3289
3290         rv = _ws_util_execute_file(path, args, envs);
3291         if (rv != TRUE)
3292                 return -1;
3293
3294         WDP_LOGI("Successfully loaded p2p device driver");
3295         return 0;
3296 }
3297
3298 static int __ws_p2p_firmware_stop(void)
3299 {
3300         gboolean rv = FALSE;
3301         const char *path = "/usr/bin/wlan.sh";
3302         char *const args[] = { "/usr/bin/wlan.sh", "stop", NULL };
3303         char *const envs[] = { NULL };
3304         rv = _ws_util_execute_file(path, args, envs);
3305         if (rv < 0)
3306                 return -1;
3307
3308         WDP_LOGI("Successfully removed p2p device driver");
3309         return 0;
3310 }
3311 #endif
3312
3313 static int __ws_p2p_supplicant_start(void)
3314 {
3315         gboolean rv = FALSE;
3316         const char *path = "/usr/sbin/p2p_supp.sh";
3317         char *const args[] = { "/usr/sbin/p2p_supp.sh", "start_dbus", NULL };
3318         char *const envs[] = { NULL };
3319
3320         rv = _ws_util_execute_file(path, args, envs);
3321
3322         if (rv != TRUE) {
3323                 WDP_LOGE("Failed to start p2p_supp.sh");
3324                 return -1;
3325         }
3326
3327         WDP_LOGI("Successfully started p2p_supp.sh");
3328         return 0;
3329 }
3330
3331
3332 static int __ws_p2p_supplicant_stop(void)
3333 {
3334         gboolean rv = FALSE;
3335         const char *path = "/usr/sbin/p2p_supp.sh";
3336         char *const args[] = { "/usr/sbin/p2p_supp.sh", "stop", NULL };
3337         char *const envs[] = { NULL };
3338
3339         rv = _ws_util_execute_file(path, args, envs);
3340
3341         if (rv != TRUE) {
3342                 WDP_LOGE("Failed to stop p2p_supp.sh");
3343                 return -1;
3344         }
3345
3346         WDP_LOGI("Successfully stopped p2p_supp.sh");
3347         return 0;
3348 }
3349 #if 0
3350 static int __ws_p2p_on(void)
3351 {
3352         DBusError error;
3353         DBusMessage *reply = NULL;
3354         DBusMessage *message = NULL;
3355         DBusConnection *connection = NULL;
3356
3357         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
3358         if (connection == NULL) {
3359                 WDP_LOGE("Failed to get system bus");
3360                 return -EIO;
3361         }
3362
3363         message = dbus_message_new_method_call(NETCONFIG_SERVICE,
3364                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "LoadP2pDriver");
3365         if (message == NULL) {
3366                 WDP_LOGE("Failed DBus method call");
3367                 dbus_connection_unref(connection);
3368                 return -EIO;
3369         }
3370
3371         dbus_error_init(&error);
3372
3373         reply = dbus_connection_send_with_reply_and_block(connection, message,
3374                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
3375         if (dbus_error_is_set(&error) == TRUE) {
3376                 if (NULL != strstr(error.message, ".AlreadyExists")) {
3377                         /* p2p already enabled */
3378                 } else {
3379                         WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
3380                                         "DBus error [%s: %s]", error.name, error.message);
3381
3382                         dbus_error_free(&error);
3383                 }
3384
3385                 dbus_error_free(&error);
3386         }
3387
3388         if (reply != NULL)
3389                 dbus_message_unref(reply);
3390
3391         dbus_message_unref(message);
3392         dbus_connection_unref(connection);
3393
3394         return 0;
3395 }
3396
3397 static int __ws_p2p_off(void)
3398 {
3399         DBusError error;
3400         DBusMessage *reply = NULL;
3401         DBusMessage *message = NULL;
3402         DBusConnection *connection = NULL;
3403
3404         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
3405         if (connection == NULL) {
3406                 WDP_LOGE("Failed to get system bus");
3407                 return -EIO;
3408         }
3409
3410         message = dbus_message_new_method_call(NETCONFIG_SERVICE,
3411                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "RemoveP2pDriver");
3412         if (message == NULL) {
3413                 WDP_LOGE("Failed DBus method call");
3414                 dbus_connection_unref(connection);
3415                 return -EIO;
3416         }
3417
3418         dbus_error_init(&error);
3419
3420         reply = dbus_connection_send_with_reply_and_block(connection, message,
3421                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
3422         if (dbus_error_is_set(&error) == TRUE) {
3423                 if (NULL != strstr(error.message, ".AlreadyExists")) {
3424                         /*  p2p already disabled */
3425                 } else {
3426                         WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
3427                                         "DBus error [%s: %s]", error.name, error.message);
3428
3429                         dbus_error_free(&error);
3430                 }
3431
3432                 dbus_error_free(&error);
3433         }
3434
3435         if (reply != NULL)
3436                 dbus_message_unref(reply);
3437
3438         dbus_message_unref(message);
3439         dbus_connection_unref(connection);
3440
3441         return 0;
3442 }
3443 #endif
3444
3445 int __ws_init_p2pdevice()
3446 {
3447         __WDP_LOG_FUNC_ENTER__;
3448         GDBusConnection *g_dbus = NULL;
3449
3450         GVariant *value = NULL;
3451         GVariant *param = NULL;
3452         GVariantBuilder *builder = NULL;
3453         GVariantBuilder *type_builder = NULL;
3454         dbus_method_param_s params;
3455
3456         const char *primary_device_type = PRIMARY_DEVICE_TYPE;
3457
3458 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
3459         const char *ip_addr_go = DEFAULT_IP_GO;
3460         const char *ip_addr_mask = DEFAULT_IP_MASK;
3461         const char *ip_addr_start = DEFAULT_IP_START;
3462         const char *ip_addr_end = DEFAULT_IP_END;
3463 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
3464         int i = 0;
3465         int res = 0;
3466
3467         if (!g_pd) {
3468                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3469                 return -1;
3470         }
3471
3472         for (i = 0; i < WS_DEVTYPE_LEN; i++)
3473                 WDP_LOGD("device type[%02x]", primary_device_type[i]);
3474
3475         g_dbus = g_pd->g_dbus;
3476         if (!g_dbus) {
3477                 WDP_LOGE("DBus connection is NULL");
3478                 return -1;
3479         }
3480         memset(&params, 0x0, sizeof(dbus_method_param_s));
3481
3482         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3483                          g_dbus);
3484
3485         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3486         g_variant_builder_add(builder, "{sv}", "DeviceName",
3487                                         g_variant_new_string(DEFAULT_DEVICE_NAME));
3488
3489         g_variant_builder_add(builder, "{sv}", "GOIntent",
3490                                         g_variant_new_uint32(DEFAULT_GO_INTENT));
3491
3492         g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
3493                                         g_variant_new_boolean(DEFAULT_PERSISTENT_RECONNECT));
3494
3495         g_variant_builder_add(builder, "{sv}", "ListenRegClass",
3496                                         g_variant_new_uint32(DEFAULT_LISTEN_REG_CLASS));
3497
3498         g_variant_builder_add(builder, "{sv}", "ListenChannel",
3499                                         g_variant_new_uint32(DEFAULT_LISTEN_CHANNEL));
3500
3501         g_variant_builder_add(builder, "{sv}", "OperRegClass",
3502                                         g_variant_new_uint32(DEFAULT_OPER_REG_CLASS));
3503
3504         g_variant_builder_add(builder, "{sv}", "OperChannel",
3505                                         g_variant_new_uint32(DEFAULT_OPER_CHANNEL));
3506
3507         g_variant_builder_add(builder, "{sv}", "SsidPostfix",
3508                                         g_variant_new_string(DEFAULT_DEVICE_NAME));
3509
3510         g_variant_builder_add(builder, "{sv}", "NoGroupIface",
3511                                         g_variant_new_boolean(DEFAULT_NO_GROUP_IFACE));
3512
3513         type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3514         for (i = 0; i < WS_DEVTYPE_LEN; i++)
3515                 g_variant_builder_add(type_builder, "y", primary_device_type[i]);
3516         g_variant_builder_add(builder, "{sv}", "PrimaryDeviceType",
3517                         g_variant_new("ay", type_builder));
3518         g_variant_builder_unref(type_builder);
3519 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
3520         type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3521         for (i = 0; i < OEM_IPADDR_LEN; i++)
3522                 g_variant_builder_add(type_builder, "y", ip_addr_go[i]);
3523         g_variant_builder_add(builder, "{sv}", "IpAddrGO",
3524                         g_variant_new("ay", type_builder));
3525         g_variant_builder_unref(type_builder);
3526
3527         type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3528         for (i = 0; i < OEM_IPADDR_LEN; i++)
3529                 g_variant_builder_add(type_builder, "y", ip_addr_mask[i]);
3530         g_variant_builder_add(builder, "{sv}", "IpAddrMask",
3531                         g_variant_new("ay", type_builder));
3532         g_variant_builder_unref(type_builder);
3533
3534         type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3535         for (i = 0; i < OEM_IPADDR_LEN; i++)
3536                 g_variant_builder_add(type_builder, "y", ip_addr_start[i]);
3537         g_variant_builder_add(builder, "{sv}", "IpAddrStart",
3538                         g_variant_new("ay", type_builder));
3539         g_variant_builder_unref(type_builder);
3540
3541         type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3542         for (i = 0; i < OEM_IPADDR_LEN; i++)
3543                 g_variant_builder_add(type_builder, "y", ip_addr_end[i]);
3544         g_variant_builder_add(builder, "{sv}", "IpAddrEnd",
3545                         g_variant_new("ay", type_builder));
3546         g_variant_builder_unref(type_builder);
3547 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
3548         value = g_variant_new("a{sv}", builder);
3549         g_variant_builder_unref(builder);
3550
3551         param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
3552
3553         params.params = param;
3554 #if defined(TIZEN_DEBUG_DBUS_VALUE)
3555         DEBUG_PARAMS(params.params);
3556 #endif /* TIZEN_DEBUG_DBUS_VALUE */
3557
3558         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3559         if (res < 0)
3560                 WDP_LOGE("Failed to send command to wpa_supplicant");
3561         else
3562                 WDP_LOGD("Succeeded to initialize p2pdevice");
3563         __WDP_LOG_FUNC_EXIT__;
3564         return res;
3565 }
3566
3567 int __ws_set_config_methods()
3568 {
3569         __WDP_LOG_FUNC_ENTER__;
3570         GDBusConnection *g_dbus = NULL;
3571
3572         GVariant *value = NULL;
3573         GVariant *param = NULL;
3574
3575         dbus_method_param_s params;
3576         int res = 0;
3577
3578         if (!g_pd) {
3579                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3580                 return -1;
3581         }
3582
3583         g_dbus = g_pd->g_dbus;
3584         if (!g_dbus) {
3585                 WDP_LOGE("DBus connection is NULL");
3586                 return -1;
3587         }
3588         memset(&params, 0x0, sizeof(dbus_method_param_s));
3589
3590         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3591                          g_dbus);
3592
3593         value = g_variant_new_string(DEFAULT_CONFIG_METHOD);
3594
3595         param = g_variant_new("(ssv)", SUPPLICANT_WPS, "ConfigMethods", value);
3596         params.params = param;
3597
3598         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3599         if (res < 0)
3600                 WDP_LOGE("Failed to send command to wpa_supplicant");
3601         else
3602                 WDP_LOGD("Succeeded to set config method(%s)", DEFAULT_CONFIG_METHOD);
3603
3604         __WDP_LOG_FUNC_EXIT__;
3605         return res;
3606 }
3607
3608 int ws_activate(int concurrent)
3609 {
3610         __WDP_LOG_FUNC_ENTER__;
3611         int res = 0;
3612         int retry_count = 0;
3613
3614         if (!g_pd) {
3615                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3616                 return -1;
3617         }
3618
3619         res = __ws_p2p_supplicant_start();
3620         if (res < 0) {
3621                 res = __ws_p2p_supplicant_stop();
3622                 WDP_LOGI("P2P supplicant stopped with error %d", res);
3623                 __WDP_LOG_FUNC_EXIT__;
3624                 return -1;
3625         }
3626 #ifndef TIZEN_WIFI_MODULE_BUNDLE
3627         while (retry_count < WS_CONN_RETRY_COUNT) {
3628                 /* load wlan driver */
3629                 if (concurrent == 0)
3630                         res = __ws_p2p_firmware_start();
3631                 if (res < 0) {
3632                         WDP_LOGE("Failed to load driver [ret=%d]", res);
3633                         return -1;
3634                 }
3635                 WDP_LOGI("P2P firmware started with error %d", res);
3636
3637                 if (__ws_check_net_interface(COMMON_IFACE_NAME) < 0) {
3638                         usleep(150000); /* wait for 150ms */
3639                         concurrent = 0;
3640                         retry_count++;
3641                         WDP_LOGE("interface is not up: retry, %d", retry_count);
3642                 } else {
3643                         break;
3644                 }
3645         }
3646 #endif
3647         if (retry_count >= WS_CONN_RETRY_COUNT) {
3648                 WDP_LOGE("Driver loading is failed", res);
3649                 __WDP_LOG_FUNC_EXIT__;
3650                 return -1;
3651         }
3652         if (retry_count > 0) {
3653                 /* Give driver marginal time to config net */
3654                 WDP_LOGE("Driver loading is done. Wait marginal time for driver");
3655                 sleep(1); /* 1s */
3656         }
3657
3658         g_pd->concurrent = concurrent;
3659
3660         res = _ws_init_dbus_connection();
3661         if (res < 0) {
3662                 res = __ws_p2p_supplicant_stop();
3663                 WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
3664 #ifndef TIZEN_WIFI_MODULE_BUNDLE
3665                 res = __ws_p2p_firmware_stop();
3666                 WDP_LOGI("P2P firmware stopped with error %d", res);
3667 #endif
3668                 __WDP_LOG_FUNC_EXIT__;
3669                 return -1;
3670         }
3671
3672         g_pd->activated = TRUE;
3673         __ws_init_p2pdevice();
3674         __ws_set_config_methods();
3675         seek_list = NULL;
3676
3677         __WDP_LOG_FUNC_EXIT__;
3678         return 0;
3679 }
3680
3681 int ws_deactivate(int concurrent)
3682 {
3683         __WDP_LOG_FUNC_ENTER__;
3684 #if defined(TIZEN_FEATURE_ASP)
3685         wfd_oem_asp_service_s *data = NULL;
3686 #endif /* TIZEN_FEATURE_ASP */
3687         int res = 0;
3688
3689         if (!g_pd) {
3690                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3691                 return -1;
3692         }
3693
3694         if (!g_pd->activated) {
3695                 WDP_LOGE("Wi-Fi Direct is not activated");
3696                 return -1;
3697         }
3698
3699         ws_stop_scan();
3700
3701         g_pd->concurrent = concurrent;
3702 #if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
3703         _ws_get_interface(P2P_IFACE_NAME, __ws_remove_interface, NULL);
3704         if (concurrent == 0)
3705                 _ws_get_interface(COMMON_IFACE_NAME, __ws_remove_interface, NULL);
3706 #endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
3707
3708         _ws_deinit_dbus_connection();
3709
3710         if (concurrent == 0) {
3711                 res = __ws_p2p_supplicant_stop();
3712                 WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
3713 #ifndef TIZEN_WIFI_MODULE_BUNDLE
3714                 res = __ws_p2p_firmware_stop();
3715                 WDP_LOGI("P2P firmware stopped with error %d", res);
3716 #endif
3717         }
3718         g_pd->activated = FALSE;
3719
3720 #if defined(TIZEN_FEATURE_ASP)
3721         GLIST_ITER_START(seek_list, data)
3722
3723         if (data) {
3724                 temp = g_list_next(seek_list);
3725                 seek_list = g_list_remove(seek_list, data);
3726                 g_free(data->service_type);
3727                 g_free(data->service_info);
3728                 g_free(data);
3729         }
3730
3731         GLIST_ITER_END()
3732 #endif /* TIZEN_FEATURE_ASP */
3733         __WDP_LOG_FUNC_EXIT__;
3734         return 0;
3735 }
3736
3737 #if 0
3738 static gboolean _retry_start_scan(gpointer data)
3739 {
3740         __WDP_LOG_FUNC_ENTER__;
3741
3742         WDP_LOGD("Succeeded to start scan");
3743
3744         __WDP_LOG_FUNC_EXIT__;
3745         return 0;
3746 }
3747 #endif
3748
3749 #if defined(TIZEN_FEATURE_ASP)
3750 static void __ws_add_seek_params(GVariantBuilder *builder)
3751 {
3752         GVariantBuilder *outter = NULL;
3753         GVariantBuilder *inner = NULL;
3754         wfd_oem_asp_service_s *data = NULL;
3755         int len = 0;
3756         int i = 0;
3757
3758         if (seek_list == NULL || g_list_length(seek_list) == 0) {
3759                 WDP_LOGD("seek list is NULL");
3760                 return;
3761         }
3762         WDP_LOGD("seek list length [%d]", g_list_length(seek_list));
3763
3764         outter = g_variant_builder_new(G_VARIANT_TYPE("aay"));
3765
3766 GLIST_ITER_START(seek_list, data)
3767         if (data && data->service_type) {
3768                 len = strlen(data->service_type) + 1;
3769                 WDP_LOGD("data [%s] len [%d]", data->service_type, len);
3770                 inner = g_variant_builder_new(G_VARIANT_TYPE("ay"));
3771                 for (i = 0; i < len; i++)
3772                         g_variant_builder_add(inner, "y", data->service_type[i]);
3773                 g_variant_builder_add(outter, "ay", inner);
3774                 g_variant_builder_unref(inner);
3775         }
3776 GLIST_ITER_END()
3777         g_variant_builder_add(builder, "{sv}", "Seek", g_variant_new("aay", outter));
3778         g_variant_builder_unref(outter);
3779
3780         return;
3781 }
3782 #endif /* TIZEN_FEATURE_ASP */
3783
3784
3785 int ws_start_scan(wfd_oem_scan_param_s *param)
3786 {
3787         __WDP_LOG_FUNC_ENTER__;
3788         GDBusConnection *g_dbus = NULL;
3789         GVariantBuilder *builder = NULL;
3790         GVariant *value = NULL;
3791         dbus_method_param_s params;
3792         int res = 0;
3793
3794         if (!param) {
3795                 WDP_LOGE("Invalid parameter");
3796                 return -1;
3797         }
3798
3799         if (!g_pd) {
3800                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3801                 return -1;
3802         }
3803
3804         g_dbus = g_pd->g_dbus;
3805         if (!g_dbus) {
3806                 WDP_LOGE("DBus connection is NULL");
3807                 return -1;
3808         }
3809         memset(&params, 0x0, sizeof(dbus_method_param_s));
3810
3811         if (param->scan_mode == WFD_OEM_SCAN_MODE_ACTIVE) {
3812
3813                 dbus_set_method_param(&params, "Find",  g_pd->iface_path, g_dbus);
3814
3815                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3816
3817                         if (param->scan_time)
3818                                 g_variant_builder_add(builder, "{sv}", "Timeout",
3819                                                         g_variant_new_int32(param->scan_time));
3820                         if (param->scan_type == WFD_OEM_SCAN_TYPE_SOCIAL)
3821                                 g_variant_builder_add(builder, "{sv}", "DiscoveryType",
3822                                                         g_variant_new_string("social"));
3823 #if defined(TIZEN_FEATURE_ASP)
3824                         if (seek_list != NULL)
3825                                 __ws_add_seek_params(builder);
3826 #endif /* TIZEN_FEATURE_ASP */
3827
3828                         value = g_variant_new("(a{sv})", builder);
3829                         g_variant_builder_unref(builder);
3830         } else {
3831
3832                 dbus_set_method_param(&params, "Listen", g_pd->iface_path, g_dbus);
3833                 value = g_variant_new("(i)", param->scan_time);
3834         }
3835
3836         params.params = value;
3837 #if defined(TIZEN_DEBUG_DBUS_VALUE)
3838         DEBUG_PARAMS(params.params);
3839 #endif /* TIZEN_DEBUG_DBUS_VALUE */
3840
3841         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
3842         if (res < 0)
3843                 WDP_LOGE("Failed to send command to wpa_supplicant");
3844         else
3845                 WDP_LOGD("Succeeded to start scan");
3846
3847         __WDP_LOG_FUNC_EXIT__;
3848         return res;
3849 }
3850
3851 int ws_restart_scan(int freq)
3852 {
3853         __WDP_LOG_FUNC_ENTER__;
3854         GDBusConnection *g_dbus = NULL;
3855         GVariantBuilder *builder = NULL;
3856         GVariant *value = NULL;
3857         dbus_method_param_s params;
3858         int res = 0;
3859
3860         if (!g_pd) {
3861                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3862                 return -1;
3863         }
3864
3865         g_dbus = g_pd->g_dbus;
3866         if (!g_dbus) {
3867                 WDP_LOGE("DBus connection is NULL");
3868                 return -1;
3869         }
3870         memset(&params, 0x0, sizeof(dbus_method_param_s));
3871
3872         dbus_set_method_param(&params, "Find", g_pd->iface_path, g_dbus);
3873
3874         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3875         g_variant_builder_add(builder, "{sv}", "Timeout", g_variant_new_int32(2));
3876         g_variant_builder_add(builder, "{sv}", "DiscoveryType",
3877                                 g_variant_new_string("social"));
3878         value = g_variant_new("(a{sv})", builder);
3879         g_variant_builder_unref(builder);
3880
3881         params.params = value;
3882 #if defined(TIZEN_DEBUG_DBUS_VALUE)
3883         DEBUG_PARAMS(params.params);
3884 #endif /* TIZEN_DEBUG_DBUS_VALUE */
3885
3886         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
3887         if (res < 0)
3888                 WDP_LOGE("Failed to send command to wpa_supplicant");
3889         else
3890                 WDP_LOGD("Succeeded to start scan");
3891
3892         __WDP_LOG_FUNC_EXIT__;
3893         return res;
3894 }
3895
3896 int ws_stop_scan()
3897 {
3898         __WDP_LOG_FUNC_ENTER__;
3899         GDBusConnection *g_dbus = NULL;
3900         dbus_method_param_s params;
3901         int res = 0;
3902
3903         if (!g_pd) {
3904                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3905                 return -1;
3906         }
3907
3908         g_dbus = g_pd->g_dbus;
3909         if (!g_dbus) {
3910                 WDP_LOGE("DBus connection is NULL");
3911                 return -1;
3912         }
3913         memset(&params, 0x0, sizeof(dbus_method_param_s));
3914
3915         dbus_set_method_param(&params, "StopFind", g_pd->iface_path, g_dbus);
3916         params.params = NULL;
3917
3918         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
3919         if (res < 0)
3920                         WDP_LOGE("Failed to send command to wpa_supplicant");
3921         else
3922                 WDP_LOGD("Succeeded to stop scan");
3923
3924         __WDP_LOG_FUNC_EXIT__;
3925         return res;
3926 }
3927
3928 int ws_get_visibility(int *visibility)
3929 {
3930         __WDP_LOG_FUNC_ENTER__;
3931
3932         __WDP_LOG_FUNC_EXIT__;
3933         return 0;
3934 }
3935
3936 int ws_set_visibility(int visibility)
3937 {
3938         __WDP_LOG_FUNC_ENTER__;
3939
3940         __WDP_LOG_FUNC_EXIT__;
3941         return 0;
3942 }
3943
3944 int ws_get_scan_result(GList **peers, int *peer_count)
3945 {
3946         __WDP_LOG_FUNC_ENTER__;
3947
3948         __WDP_LOG_FUNC_EXIT__;
3949         return 0;
3950 }
3951
3952 int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
3953 {
3954         __WDP_LOG_FUNC_ENTER__;
3955         GDBusConnection *g_dbus = NULL;
3956         wfd_oem_device_s *ws_dev = NULL;
3957         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
3958         int res = 0;
3959
3960         if (!peer_addr || !peer) {
3961                 WDP_LOGE("Invalid parameter");
3962                 return -1;
3963         }
3964
3965         if (!g_pd) {
3966                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
3967                 return -1;
3968         }
3969
3970         g_dbus = g_pd->g_dbus;
3971         if (!g_dbus) {
3972                 WDP_LOGE("DBus connection is NULL");
3973                 return -1;
3974         }
3975
3976         ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
3977         if (!ws_dev) {
3978                 WDP_LOGF("Failed to allocate memory device. [%s]",
3979                                 strerror(errno));
3980                 __WDP_LOG_FUNC_EXIT__;
3981                 return -1;
3982         }
3983
3984         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
3985                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
3986
3987         WDP_LOGD("get peer path [%s]", peer_path);
3988
3989         res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
3990                                 __ws_get_peer_property, ws_dev);
3991
3992         if (res < 0) {
3993                         WDP_LOGE("Failed to send command to wpa_supplicant");
3994                         g_free(ws_dev);
3995                         __WDP_LOG_FUNC_EXIT__;
3996                         return -1;
3997         } else {
3998                 WDP_LOGD("succeeded to get peer info");
3999                 *peer = ws_dev;
4000         }
4001         __WDP_LOG_FUNC_EXIT__;
4002         return 0;
4003 }
4004
4005 int ws_prov_disc_req(unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
4006 {
4007         __WDP_LOG_FUNC_ENTER__;
4008         GDBusConnection *g_dbus = NULL;
4009         GVariant *value = NULL;
4010         dbus_method_param_s params;
4011         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
4012         int res = 0;
4013
4014         if (!peer_addr) {
4015                 WDP_LOGE("Invalid parameter");
4016                 __WDP_LOG_FUNC_EXIT__;
4017                 return -1;
4018         }
4019
4020         if (!g_pd) {
4021                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4022                 __WDP_LOG_FUNC_EXIT__;
4023                 return -1;
4024         }
4025
4026         g_dbus = g_pd->g_dbus;
4027         if (!g_dbus) {
4028                 WDP_LOGE("DBus connection is NULL");
4029                 __WDP_LOG_FUNC_EXIT__;
4030                 return -1;
4031         }
4032         memset(&params, 0x0, sizeof(dbus_method_param_s));
4033
4034         dbus_set_method_param(&params, "ProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
4035
4036         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
4037                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
4038         WDP_LOGD("get peer path [%s]", peer_path);
4039
4040         value = g_variant_new("(os)", peer_path, __ws_wps_to_txt(wps_mode));
4041
4042         params.params = value;
4043 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4044         DEBUG_PARAMS(params.params);
4045 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4046
4047         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4048         if (res < 0)
4049                 WDP_LOGE("Failed to send command to wpa_supplicant");
4050         else
4051                 WDP_LOGD("Succeeded to send prov disc to peer[" MACSTR "]", MAC2STR(peer_addr));
4052
4053         __WDP_LOG_FUNC_EXIT__;
4054         return res;
4055 }
4056
4057 int ws_connect(unsigned char *peer_addr, wfd_oem_conn_param_s *param)
4058 {
4059         __WDP_LOG_FUNC_ENTER__;
4060         GDBusConnection *g_dbus = NULL;
4061         GVariantBuilder *builder = NULL;
4062         GVariant *value = NULL;
4063         dbus_method_param_s params;
4064         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
4065         int res = 0;
4066
4067         if (!peer_addr || !param) {
4068                 WDP_LOGE("Invalid parameter");
4069                 __WDP_LOG_FUNC_EXIT__;
4070                 return -1;
4071         }
4072
4073         if (!g_pd) {
4074                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4075                 __WDP_LOG_FUNC_EXIT__;
4076                 return -1;
4077         }
4078
4079         g_dbus = g_pd->g_dbus;
4080         if (!g_dbus) {
4081                 WDP_LOGE("DBus connection is NULL");
4082                 __WDP_LOG_FUNC_EXIT__;
4083                 return -1;
4084         }
4085         memset(&params, 0x0, sizeof(dbus_method_param_s));
4086
4087         dbus_set_method_param(&params, "Connect", g_pd->iface_path, g_dbus);
4088
4089         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
4090                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
4091         WDP_LOGD("get peer path [%s]", peer_path);
4092
4093         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4094         g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
4095         if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
4096                 g_variant_builder_add(builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
4097
4098         if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
4099                 g_variant_builder_add(builder, "{sv}", "join", g_variant_new_boolean(TRUE));
4100
4101         if (param->conn_flags & WFD_OEM_CONN_TYPE_AUTH)
4102                 g_variant_builder_add(builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
4103
4104         if (param->wps_pin[0] != '\0')
4105                 g_variant_builder_add(builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
4106
4107         g_variant_builder_add(builder, "{sv}", "wps_method",
4108                                 g_variant_new_string(__ws_wps_to_txt(param->wps_mode)));
4109
4110         value = g_variant_new("(a{sv})", builder);
4111         g_variant_builder_unref(builder);
4112
4113         params.params = value;
4114 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4115         DEBUG_PARAMS(params.params);
4116 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4117
4118         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4119         if (res < 0)
4120                 WDP_LOGE("Failed to send command to wpa_supplicant");
4121         else
4122                 WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(peer_addr));
4123
4124         __WDP_LOG_FUNC_EXIT__;
4125         return res;
4126 }
4127
4128 int ws_disconnect(unsigned char *peer_addr, int is_iface_addr)
4129 {
4130         __WDP_LOG_FUNC_ENTER__;
4131         GDBusConnection *g_dbus = NULL;
4132         GVariant *value = NULL;
4133         dbus_method_param_s params;
4134         GVariantBuilder *builder = NULL;
4135         int res = 0;
4136
4137         if (!peer_addr) {
4138                 WDP_LOGE("Invalid parameter");
4139                 return -1;
4140         }
4141
4142         if (!g_pd) {
4143                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4144                 return -1;
4145         }
4146
4147         g_dbus = g_pd->g_dbus;
4148         if (!g_dbus) {
4149                 WDP_LOGE("DBus connection is NULL");
4150                 return -1;
4151         }
4152         memset(&params, 0x0, sizeof(dbus_method_param_s));
4153
4154         dbus_set_method_param(&params, "RemoveClient", g_pd->iface_path, g_dbus);
4155         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4156
4157         if (is_iface_addr) {
4158                 char peer_mac_str[WS_MACSTR_LEN] = {'\0', };
4159
4160                 g_snprintf(peer_mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
4161                 WDP_LOGI("peer addr [%s]", peer_mac_str);
4162                 g_variant_builder_add(builder, "{sv}", "iface",
4163                                 g_variant_new_string(peer_mac_str));
4164         } else {
4165                 char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0', };
4166
4167                 g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
4168                                 COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
4169                 g_variant_builder_add(builder, "{sv}", "peer",
4170                                 g_variant_new_object_path(peer_path));
4171         }
4172
4173         value = g_variant_new("(a{sv})", builder);
4174         g_variant_builder_unref(builder);
4175
4176         params.params = value;
4177 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4178         DEBUG_PARAMS(params.params);
4179 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4180
4181         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4182         if (res < 0)
4183                 WDP_LOGE("Failed to send command to wpa_supplicant");
4184         else
4185                 WDP_LOGD("Succeeded to send disconnection command to peer[" MACSECSTR "]",
4186                                 MAC2SECSTR(peer_addr));
4187
4188         __WDP_LOG_FUNC_EXIT__;
4189         return res;
4190 }
4191
4192 int ws_reject_connection(unsigned char *peer_addr)
4193 {
4194         __WDP_LOG_FUNC_ENTER__;
4195         GDBusConnection *g_dbus = NULL;
4196         GVariant *value = NULL;
4197         dbus_method_param_s params;
4198         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
4199         int res = 0;
4200
4201         if (!peer_addr) {
4202                 WDP_LOGE("Invalid parameter");
4203                 __WDP_LOG_FUNC_EXIT__;
4204                 return -1;
4205         }
4206
4207         if (!g_pd) {
4208                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4209                 __WDP_LOG_FUNC_EXIT__;
4210                 return -1;
4211         }
4212
4213         g_dbus = g_pd->g_dbus;
4214         if (!g_dbus) {
4215                 WDP_LOGE("DBus connection is NULL");
4216                 __WDP_LOG_FUNC_EXIT__;
4217                 return -1;
4218         }
4219         memset(&params, 0x0, sizeof(dbus_method_param_s));
4220
4221         dbus_set_method_param(&params, "RejectPeer", g_pd->iface_path, g_dbus);
4222
4223         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
4224                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
4225         WDP_LOGE("get peer path [%s]", peer_path);
4226
4227         value = g_variant_new("(o)", peer_path);
4228
4229         params.params = value;
4230 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4231         DEBUG_PARAMS(params.params);
4232 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4233
4234         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4235         if (res < 0)
4236                 WDP_LOGE("Failed to send command to wpa_supplicant");
4237         else
4238                 WDP_LOGD("Succeeded to reject peer[" MACSTR "]", MAC2STR(peer_addr));
4239
4240         _ws_flush();
4241         __WDP_LOG_FUNC_EXIT__;
4242         return res;
4243 }
4244
4245 int ws_cancel_connection(unsigned char *peer_addr)
4246 {
4247         __WDP_LOG_FUNC_ENTER__;
4248
4249         _ws_cancel();
4250
4251         __WDP_LOG_FUNC_EXIT__;
4252         return 0;
4253 }
4254
4255 int ws_get_connected_peers(GList **peers, int *peer_count)
4256 {
4257         __WDP_LOG_FUNC_ENTER__;
4258
4259         __WDP_LOG_FUNC_EXIT__;
4260         return 0;
4261 }
4262
4263 int ws_get_pin(char *pin)
4264 {
4265         __WDP_LOG_FUNC_ENTER__;
4266
4267         __WDP_LOG_FUNC_EXIT__;
4268         return 0;
4269 }
4270
4271 int ws_set_pin(char *pin)
4272 {
4273         __WDP_LOG_FUNC_ENTER__;
4274
4275         __WDP_LOG_FUNC_EXIT__;
4276         return 0;
4277 }
4278
4279 static void __ws_get_pin(GVariant *value, void *user_data)
4280 {
4281         __WDP_LOG_FUNC_ENTER__;
4282         const char *pin = NULL;
4283
4284         g_variant_get(value, "(&s)", &pin);
4285         g_strlcpy((char *)user_data, pin, OEM_PINSTR_LEN + 1);
4286
4287         __WDP_LOG_FUNC_EXIT__;
4288         return;
4289 }
4290
4291 int ws_generate_pin(char **pin)
4292 {
4293         __WDP_LOG_FUNC_ENTER__;
4294         GDBusConnection *g_dbus = NULL;
4295         dbus_method_param_s params;
4296         char n_pin[9] = {0,};
4297         int res = 0;
4298
4299         if (!g_pd) {
4300                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4301                 return -1;
4302         }
4303
4304         g_dbus = g_pd->g_dbus;
4305         if (!g_dbus) {
4306                 WDP_LOGE("DBus connection is NULL");
4307                 return -1;
4308         }
4309         memset(&params, 0x0, sizeof(dbus_method_param_s));
4310
4311         dbus_set_method_param(&params, "GeneratePin", g_pd->iface_path, g_dbus);
4312         params.params = NULL;
4313
4314         res = dbus_method_call(&params, SUPPLICANT_WPS, __ws_get_pin, (void *)n_pin);
4315         if (res < 0)
4316                 WDP_LOGE("Failed to send command to wpa_supplicant");
4317         else
4318                 WDP_LOGD("Succeeded to generate_pin [ %s ]", n_pin);
4319
4320         *pin = strndup(n_pin, OEM_PINSTR_LEN);
4321         __WDP_LOG_FUNC_EXIT__;
4322         return 0;
4323 }
4324
4325 int ws_get_supported_wps_mode()
4326 {
4327         __WDP_LOG_FUNC_ENTER__;
4328
4329         __WDP_LOG_FUNC_EXIT__;
4330         return 0;
4331 }
4332
4333 int _ws_get_persistent_net_id(int *persistent_network_id, const unsigned char *go_dev_mac)
4334 {
4335         __WDP_LOG_FUNC_ENTER__;
4336         int persistent_group_count = 0;
4337         int counter = 0;
4338         int res = 0;
4339
4340         wfd_oem_persistent_group_s *plist = NULL;
4341
4342         res = ws_get_persistent_groups(&plist, &persistent_group_count);
4343         if (res < 0) {
4344                 WDP_LOGE("failed to get persistent groups");
4345                 __WDP_LOG_FUNC_EXIT__;
4346                 return -1;
4347         }
4348
4349         if (persistent_group_count > WS_MAX_PERSISTENT_COUNT) {
4350                 WDP_LOGE("persistent group count greater than max Persistent count");
4351                 persistent_group_count = WS_MAX_PERSISTENT_COUNT;
4352         }
4353
4354         WDP_LOGD("Persistent Group Count=%d", persistent_group_count);
4355
4356         for (counter = 0; counter < persistent_group_count ; counter++) {
4357                 if (!memcmp(go_dev_mac, plist[counter].go_mac_address, WS_MACADDR_LEN)) {
4358                         *persistent_network_id = plist[counter].network_id;
4359                         break;
4360                 } else {
4361                         WDP_LOGD("Invite: Persistent GO[" MACSTR "], GO Addr[" MACSTR "]",
4362                                         MAC2STR(plist[counter].go_mac_address), MAC2STR(go_dev_mac));
4363                 }
4364         }
4365
4366         g_free(plist);
4367         plist = NULL;
4368         WDP_LOGD("persistent network ID : [%d]", *persistent_network_id);
4369
4370         __WDP_LOG_FUNC_EXIT__;
4371         return 0;
4372 }
4373
4374 static void __store_group_iface_path(GVariant* value, void* user_data)
4375 {
4376         __WDP_LOG_FUNC_ENTER__;
4377         ws_dbus_plugin_data_s * pd_data;
4378         const char *path = NULL;
4379
4380         if (!g_pd) {
4381                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4382                 return;
4383         }
4384
4385         pd_data = (ws_dbus_plugin_data_s *) g_pd;
4386
4387         g_variant_get(value, "(&o)", &path);
4388         g_strlcpy(pd_data->group_iface_path, path, DBUS_OBJECT_PATH_MAX);
4389
4390         WDP_LOGD("group object path [%s]", pd_data->group_iface_path);
4391         /* subscribe interface p2p signal */
4392 }
4393
4394 int ws_create_group(wfd_oem_group_param_s *param)
4395 {
4396         __WDP_LOG_FUNC_ENTER__;
4397         GDBusConnection *g_dbus = NULL;
4398         GVariantBuilder *builder = NULL;
4399         GVariant *value = NULL;
4400         dbus_method_param_s params;
4401         char persistent_group_obj_path[OBJECT_PATH_MAX] = {0,};
4402         int res = 0;
4403
4404         if (!param) {
4405                 WDP_LOGE("Invalid parameter");
4406                 __WDP_LOG_FUNC_EXIT__;
4407                 return -1;
4408         }
4409
4410         if (!g_pd) {
4411                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4412                 __WDP_LOG_FUNC_EXIT__;
4413                 return -1;
4414         }
4415
4416         g_dbus = g_pd->g_dbus;
4417         if (!g_dbus) {
4418                 WDP_LOGE("DBus connection is NULL");
4419                 __WDP_LOG_FUNC_EXIT__;
4420                 return -1;
4421         }
4422         memset(&params, 0x0, sizeof(dbus_method_param_s));
4423
4424         dbus_set_method_param(&params, "GroupAdd", g_pd->iface_path, g_dbus);
4425
4426         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4427
4428         if (param->persistent > 0) {
4429                 unsigned char mac_address[WS_MACADDR_LEN] = {0x00, };
4430                 int persistent_group_id = -1;
4431
4432                 res = _ws_get_local_dev_mac(mac_address);
4433                 if (res < 0) {
4434                         WDP_LOGE("failed to get local mac address");
4435                         __WDP_LOG_FUNC_EXIT__;
4436                         return -1;
4437                 }
4438
4439                 res = _ws_get_persistent_net_id(&persistent_group_id, mac_address);
4440                 if (res < 0) {
4441                         WDP_LOGE("failed to get persistent group ID");
4442                         __WDP_LOG_FUNC_EXIT__;
4443                         return -1;
4444                 }
4445
4446                 WDP_LOGD("persistent network ID : [%d]", persistent_group_id);
4447
4448                 g_variant_builder_add(builder, "{sv}", "persistent",
4449                                 g_variant_new_boolean(TRUE));
4450                 if (persistent_group_id > -1) {
4451                         g_snprintf(persistent_group_obj_path, OBJECT_PATH_MAX,
4452                                         "%s/" SUPPLICANT_PERSISTENT_GROUPS_PART "/%d",
4453                                         g_pd->iface_path, persistent_group_id);
4454                         g_variant_builder_add(builder, "{sv}", "persistent_group_object",
4455                                         g_variant_new_object_path(persistent_group_obj_path));
4456                 }
4457
4458         } else {
4459                 g_variant_builder_add(builder, "{sv}", "persistent",
4460                                 g_variant_new_boolean(FALSE));
4461         }
4462
4463         if (param->passphrase && strlen(param->passphrase) > 0)
4464                 g_variant_builder_add(builder, "{sv}", "passphrase",
4465                                 g_variant_new_string(param->passphrase));
4466
4467         if (param->freq)
4468                 g_variant_builder_add(builder, "{sv}", "frequency",
4469                                 g_variant_new_int32(param->freq));
4470
4471         value = g_variant_new("(a{sv})", builder);
4472         g_variant_builder_unref(builder);
4473
4474         params.params = value;
4475 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4476         DEBUG_PARAMS(params.params);
4477 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4478
4479         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE,
4480                         __store_group_iface_path, g_pd);
4481         if (res < 0)
4482                 WDP_LOGE("Failed to send command to wpa_supplicant");
4483         else
4484                 WDP_LOGD("Succeeded to add group");
4485
4486         __WDP_LOG_FUNC_EXIT__;
4487         return res;
4488 }
4489
4490 int ws_destroy_group(const char *ifname)
4491 {
4492         __WDP_LOG_FUNC_ENTER__;
4493         GDBusConnection *g_dbus = NULL;
4494         dbus_method_param_s params;
4495         int res = 0;
4496
4497         if (!ifname) {
4498                 WDP_LOGE("Invalid parameter");
4499                 return -1;
4500         }
4501
4502         if (!g_pd) {
4503                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4504                 return -1;
4505         }
4506
4507         g_dbus = g_pd->g_dbus;
4508         if (!g_dbus) {
4509                 WDP_LOGE("DBus connection is NULL");
4510                 return -1;
4511         }
4512
4513         if (g_pd->group_iface_path[0] == 0) {
4514                 WDP_LOGE("group iface path is NULL");
4515                 return -1;
4516         }
4517
4518         memset(&params, 0x0, sizeof(dbus_method_param_s));
4519
4520         dbus_set_method_param(&params, "Disconnect", g_pd->group_iface_path, g_dbus);
4521         params.params = NULL;
4522
4523         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4524         if (res < 0) {
4525                 WDP_LOGE("Failed to send command to wpa_supplicant");
4526                 __WDP_LOG_FUNC_EXIT__;
4527                 return -1;
4528         } else {
4529                 _ws_flush();
4530                 WDP_LOGD("Succeeded to remove group");
4531         }
4532
4533         __WDP_LOG_FUNC_EXIT__;
4534         return 0;
4535 }
4536
4537 int ws_invite(unsigned char *peer_addr, wfd_oem_invite_param_s *param)
4538 {
4539         __WDP_LOG_FUNC_ENTER__;
4540         GDBusConnection *g_dbus = NULL;
4541         GVariantBuilder *builder = NULL;
4542         GVariant *value = NULL;
4543         dbus_method_param_s params;
4544         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
4545         int res = 0;
4546
4547         if (!peer_addr || !param) {
4548                 WDP_LOGE("Invalid parameter");
4549                 return -1;
4550         }
4551
4552         if (!g_pd) {
4553                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4554                 return -1;
4555         }
4556
4557         g_dbus = g_pd->g_dbus;
4558         if (!g_dbus) {
4559                 WDP_LOGE("DBus connection is NULL");
4560                 return -1;
4561         }
4562         memset(&params, 0x0, sizeof(dbus_method_param_s));
4563
4564         dbus_set_method_param(&params, "Invite", g_pd->group_iface_path, g_dbus);
4565
4566         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
4567                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
4568         WDP_LOGE("get peer path [%s]", peer_path);
4569
4570         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4571         g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
4572         value = g_variant_new("(a{sv})", builder);
4573         g_variant_builder_unref(builder);
4574
4575         params.params = value;
4576 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4577         DEBUG_PARAMS(params.params);
4578 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4579
4580         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
4581         if (res < 0)
4582                 WDP_LOGE("Failed to send command to wpa_supplicant");
4583         else
4584                 WDP_LOGD("Succeeded to invite peer[" MACSTR "]", MAC2STR(peer_addr));
4585
4586         __WDP_LOG_FUNC_EXIT__;
4587         return 0;
4588 }
4589
4590 /* Only group owner can use this command */
4591 int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
4592 {
4593         __WDP_LOG_FUNC_ENTER__;
4594         GDBusConnection *g_dbus = NULL;
4595         GVariantBuilder *builder = NULL;
4596         GVariant *value = NULL;
4597         GVariant *dev_addr = NULL;
4598         dbus_method_param_s params;
4599         int i = 0;
4600         int res = 0;
4601
4602         if (!g_pd) {
4603                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4604                 return -1;
4605         }
4606
4607         g_dbus = g_pd->g_dbus;
4608         if (!g_dbus) {
4609                 WDP_LOGE("DBus connection is NULL");
4610                 return -1;
4611         }
4612
4613         memset(&params, 0x0, sizeof(dbus_method_param_s));
4614
4615         dbus_set_method_param(&params, "Start", g_pd->group_iface_path, g_dbus);
4616
4617         if (peer_addr != NULL) {
4618                 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
4619                 for (i = 0; i < WS_MACADDR_LEN; i++)
4620                         g_variant_builder_add(builder, "y", peer_addr[i]);
4621
4622                 dev_addr = g_variant_new("ay", builder);
4623                 g_variant_builder_unref(builder);
4624         }
4625
4626         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4627         g_variant_builder_add(builder, "{sv}", "Role", g_variant_new_string("enrollee"));
4628         if (peer_addr != NULL)
4629                 g_variant_builder_add(builder, "{sv}", "P2PDeviceAddress", dev_addr);
4630
4631         if (pin != NULL && pin[0] != '\0') {
4632                 g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pin"));
4633                 g_variant_builder_add(builder, "{sv}", "Pin", g_variant_new_string(pin));
4634         } else {
4635                 g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pbc"));
4636         }
4637
4638         value = g_variant_new("(a{sv})", builder);
4639         g_variant_builder_unref(builder);
4640
4641         params.params = value;
4642 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4643         DEBUG_PARAMS(params.params);
4644 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4645
4646         res = dbus_method_call(&params, SUPPLICANT_WPS, NULL, NULL);
4647         if (res < 0)
4648                 WDP_LOGE("Failed to send command to wpa_supplicant");
4649         else
4650                 WDP_LOGD("Succeeded to run wps");
4651
4652         __WDP_LOG_FUNC_EXIT__;
4653         return 0;
4654 }
4655
4656 int ws_enrollee_start(unsigned char *peer_addr, int wps_mode, const char *pin)
4657 {
4658         __WDP_LOG_FUNC_ENTER__;
4659
4660         WDP_LOGD("Succeeded to start WPS");
4661
4662         __WDP_LOG_FUNC_EXIT__;
4663         return 0;
4664 }
4665
4666 int ws_wps_cancel()
4667 {
4668         __WDP_LOG_FUNC_ENTER__;
4669         GDBusConnection *g_dbus = NULL;
4670         dbus_method_param_s params;
4671         int res = 0;
4672
4673         g_dbus = g_pd->g_dbus;
4674         if (!g_dbus) {
4675                 WDP_LOGE("DBus connection is NULL");
4676                 return -1;
4677         }
4678         memset(&params, 0x0, sizeof(dbus_method_param_s));
4679
4680         dbus_set_method_param(&params, "Cancel", g_pd->group_iface_path, g_dbus);
4681         params.params = NULL;
4682
4683         res = dbus_method_call(&params, SUPPLICANT_WPS, NULL, NULL);
4684         if (res < 0)
4685                 WDP_LOGE("Failed to send command to wpa_supplicant");
4686         else
4687                 WDP_LOGD("Succeeded to cancel WPS");
4688
4689         __WDP_LOG_FUNC_EXIT__;
4690         return 0;
4691 }
4692
4693 int ws_get_dev_name(char *dev_name)
4694 {
4695         __WDP_LOG_FUNC_ENTER__;
4696
4697         __WDP_LOG_FUNC_EXIT__;
4698         return 0;
4699 }
4700
4701 int ws_set_dev_name(char *dev_name)
4702 {
4703         __WDP_LOG_FUNC_ENTER__;
4704         GDBusConnection *g_dbus = NULL;
4705
4706         GVariant *value = NULL;
4707         GVariant *param = NULL;
4708         GVariantBuilder *builder = NULL;
4709         dbus_method_param_s params;
4710         int res = 0;
4711
4712         if (!dev_name) {
4713                 WDP_LOGE("Invalid parameter");
4714                 return -1;
4715         }
4716
4717         if (!g_pd) {
4718                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4719                 return -1;
4720         }
4721
4722         g_dbus = g_pd->g_dbus;
4723         if (!g_dbus) {
4724                 WDP_LOGE("DBus connection is NULL");
4725                 return -1;
4726         }
4727         memset(&params, 0x0, sizeof(dbus_method_param_s));
4728
4729         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
4730                          g_dbus);
4731
4732         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4733         g_variant_builder_add(builder, "{sv}", "DeviceName",
4734                                 g_variant_new_string(dev_name));
4735         g_variant_builder_add(builder, "{sv}", "SsidPostfix",
4736                                  g_variant_new_string(dev_name));
4737         value = g_variant_new("a{sv}", builder);
4738         g_variant_builder_unref(builder);
4739
4740         param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE,
4741                                 "P2PDeviceConfig", value);
4742
4743         params.params = param;
4744 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4745         DEBUG_PARAMS(params.params);
4746 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4747
4748         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
4749         if (res < 0)
4750                 WDP_LOGE("Failed to send command to wpa_supplicant");
4751         else
4752                 WDP_LOGD("Succeeded to set device name");
4753
4754         __WDP_LOG_FUNC_EXIT__;
4755         return res;
4756 }
4757
4758 int ws_get_dev_mac(char *dev_mac)
4759 {
4760         __WDP_LOG_FUNC_ENTER__;
4761
4762         __WDP_LOG_FUNC_EXIT__;
4763         return 0;
4764 }
4765
4766 int ws_get_dev_type(int *pri_dev_type, int *sec_dev_type)
4767 {
4768         __WDP_LOG_FUNC_ENTER__;
4769
4770         __WDP_LOG_FUNC_EXIT__;
4771         return 0;
4772 }
4773
4774 int ws_set_dev_type(int pri_dev_type, int sec_dev_type)
4775 {
4776         __WDP_LOG_FUNC_ENTER__;
4777
4778         __WDP_LOG_FUNC_EXIT__;
4779         return 0;
4780 }
4781
4782 int ws_get_go_intent(int *go_intent)
4783 {
4784         __WDP_LOG_FUNC_ENTER__;
4785         GDBusConnection *g_dbus = NULL;
4786         GVariant *param = NULL;
4787         GVariant *reply = NULL;
4788         GError *error = NULL;
4789         GVariantIter *iter = NULL;
4790
4791
4792         if (!go_intent) {
4793                 WDP_LOGE("Invalid parameter");
4794                 return -1;
4795         }
4796
4797         if (!g_pd) {
4798                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4799                 return -1;
4800         }
4801
4802         g_dbus = g_pd->g_dbus;
4803         if (!g_dbus) {
4804                 WDP_LOGE("DBus connection is NULL");
4805                 return -1;
4806         }
4807
4808         param = g_variant_new("(ss)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig");
4809 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4810         DEBUG_PARAMS(param);
4811 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4812
4813         reply = g_dbus_connection_call_sync(
4814                         g_dbus,
4815                         SUPPLICANT_SERVICE, /* bus name */
4816                         g_pd->iface_path, /* object path */
4817                         DBUS_PROPERTIES_INTERFACE, /* interface name */
4818                         DBUS_PROPERTIES_METHOD_GET, /* method name */
4819                         param, /* GVariant *params */
4820                         NULL, /* reply_type */
4821                         G_DBUS_CALL_FLAGS_NONE, /* flags */
4822                         SUPPLICANT_TIMEOUT , /* timeout */
4823                         NULL, /* cancellable */
4824                         &error); /* error */
4825
4826         if (error != NULL) {
4827                 WDP_LOGE("Error! Failed to get interface State: [%s]",
4828                                 error->message);
4829                 g_error_free(error);
4830                 if (reply)
4831                         g_variant_unref(reply);
4832                 __WDP_LOG_FUNC_EXIT__;
4833                 return -1;
4834         }
4835
4836         if (reply != NULL) {
4837                 g_variant_get(reply, "(a{sv})", &iter);
4838
4839                 if (iter != NULL) {
4840                         gchar *key = NULL;
4841                         GVariant *value = NULL;
4842
4843                         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4844 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4845                                 CHECK_KEY_VALUE(key, value);
4846 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4847                                 if (g_strcmp0(key, "GOIntent") == 0)
4848                                         g_variant_get(value, "u", go_intent);
4849                         }
4850                         g_variant_iter_free(iter);
4851                 }
4852                 g_variant_unref(reply);
4853         }
4854         __WDP_LOG_FUNC_EXIT__;
4855         return 0;
4856 }
4857
4858 int ws_set_go_intent(int go_intent)
4859 {
4860         __WDP_LOG_FUNC_ENTER__;
4861         GDBusConnection *g_dbus = NULL;
4862
4863         GVariant *value = NULL;
4864         GVariant *param = NULL;
4865         GVariantBuilder *builder = NULL;
4866         dbus_method_param_s params;
4867         int res = 0;
4868
4869         if (!g_pd) {
4870                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4871                 return -1;
4872         }
4873
4874         g_dbus = g_pd->g_dbus;
4875         if (!g_dbus) {
4876                 WDP_LOGE("DBus connection is NULL");
4877                 return -1;
4878         }
4879         memset(&params, 0x0, sizeof(dbus_method_param_s));
4880
4881         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
4882                          g_dbus);
4883
4884         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4885         g_variant_builder_add(builder, "{sv}", "GOIntent",
4886                                 g_variant_new_uint32(go_intent));
4887         value = g_variant_new("a{sv}", builder);
4888         g_variant_builder_unref(builder);
4889
4890         param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
4891
4892         params.params = param;
4893 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4894         DEBUG_PARAMS(params.params);
4895 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4896
4897         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
4898         if (res < 0)
4899                 WDP_LOGE("Failed to send command to wpa_supplicant");
4900         else
4901                 WDP_LOGE("Succeeded to set go intent");
4902         __WDP_LOG_FUNC_EXIT__;
4903         return res;
4904 }
4905
4906 int ws_set_country(char *ccode)
4907 {
4908         __WDP_LOG_FUNC_ENTER__;
4909         __WDP_LOG_FUNC_ENTER__;
4910         GDBusConnection *g_dbus = NULL;
4911
4912         GVariant *value = NULL;
4913         GVariant *param = NULL;
4914
4915         dbus_method_param_s params;
4916         int res = 0;
4917
4918         if (!g_pd) {
4919                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
4920                 return -1;
4921         }
4922
4923         g_dbus = g_pd->g_dbus;
4924         if (!g_dbus) {
4925                 WDP_LOGE("DBus connection is NULL");
4926                 return -1;
4927         }
4928         memset(&params, 0x0, sizeof(dbus_method_param_s));
4929
4930         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
4931                          g_dbus);
4932
4933         value = g_variant_new_string(ccode);
4934
4935         param = g_variant_new("(ssv)", SUPPLICANT_IFACE, "Country", value);
4936
4937         params.params = param;
4938 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4939         DEBUG_PARAMS(params.params);
4940 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4941
4942         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
4943         if (res < 0)
4944                 WDP_LOGE("Failed to send command to wpa_supplicant");
4945         else
4946                 WDP_LOGD("Succeeded to set country(%s)", ccode);
4947
4948         __WDP_LOG_FUNC_EXIT__;
4949         return res;
4950 }
4951
4952 void __parsing_networks(const char* key, GVariant* value, void* user_data)
4953 {
4954         __WDP_LOG_FUNC_ENTER__;
4955         if (!user_data) {
4956                 __WDP_LOG_FUNC_EXIT__;
4957                 return;
4958         }
4959
4960         ws_network_info_s *network = (ws_network_info_s *)user_data;
4961 #if defined(TIZEN_DEBUG_DBUS_VALUE)
4962         CHECK_KEY_VALUE(key, value);
4963 #endif /* TIZEN_DEBUG_DBUS_VALUE */
4964         if (g_strcmp0(key, "ssid") == 0) {
4965                 const char *ssid = NULL;
4966                 g_variant_get(value, "&s", &ssid);
4967                 WDP_LOGD("ssid [%s]", ssid);
4968                 g_strlcpy(network->ssid, ssid + 1, WS_SSID_LEN + 1);
4969                 network->ssid[strlen(ssid) - 2] = '\0';
4970
4971         } else if (g_strcmp0(key, "bssid") == 0) {
4972                 unsigned char *bssid = NULL;
4973                 g_variant_get(value, "&s", &bssid);
4974                 WDP_LOGD("bssid [%s]", bssid);
4975                 __ws_txt_to_mac(bssid, network->bssid);
4976
4977         } else if (g_strcmp0(key, "proto") == 0) {
4978                 const char *proto = NULL;
4979                 g_variant_get(value, "&s", &proto);
4980                 WDP_LOGD("proto [%s]", proto);
4981
4982                 if (g_strrstr(proto, WFD_OEM_STR_PROTO_WPA) != NULL)
4983                         network->proto |= WFD_OEM_PROTO_WPA;
4984                 if (g_strrstr(proto, WFD_OEM_STR_PROTO_RSN) != NULL)
4985                         network->proto |= WFD_OEM_PROTO_RSN;
4986
4987         } else if (g_strcmp0(key, "key_mgmt") == 0) {
4988                 const char *key_mgmt = NULL;
4989                 g_variant_get(value, "&s", &key_mgmt);
4990                 WDP_LOGD("key_mgmt [%s]", key_mgmt);
4991
4992                 if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_IEEE8021X) != NULL)
4993                         network->key_mgmt |= WFD_OEM_KEY_MGMT_IEEE8021X;
4994                 if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_PSK) != NULL)
4995                         network->key_mgmt |= WFD_OEM_KEY_MGMT_PSK;
4996                 if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_NONE) != NULL)
4997                         network->key_mgmt |= WFD_OEM_KEY_MGMT_NONE;
4998
4999         } else if (g_strcmp0(key, "pairwise") == 0) {
5000                 const char *pairwise = NULL;
5001                 g_variant_get(value, "&s", &pairwise);
5002                 WDP_LOGD("pairwise [%s]", pairwise);
5003
5004                 if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_NONE) != NULL)
5005                         network->pairwise |= WFD_OEM_CIPHER_NONE;
5006                 if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_TKIP) != NULL)
5007                         network->pairwise |= WFD_OEM_CIPHER_TKIP;
5008                 if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_CCMP) != NULL)
5009                         network->pairwise |= WFD_OEM_CIPHER_CCMP;
5010
5011         }  else if (g_strcmp0(key, "group") == 0) {
5012                 const char *group = NULL;
5013                 g_variant_get(value, "&s", &group);
5014                 WDP_LOGD("group [%s]", group);
5015
5016                 if (g_strrstr(group, WFD_OEM_STR_CIPHER_NONE) != NULL)
5017                         network->group |= WFD_OEM_CIPHER_NONE;
5018                 if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP40) != NULL)
5019                         network->group |= WFD_OEM_CIPHER_WEP40;
5020                 if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP104) != NULL)
5021                         network->group |= WFD_OEM_CIPHER_WEP104;
5022                 if (g_strrstr(group, WFD_OEM_STR_CIPHER_TKIP) != NULL)
5023                         network->group |= WFD_OEM_CIPHER_TKIP;
5024                 if (g_strrstr(group, WFD_OEM_STR_CIPHER_CCMP) != NULL)
5025                         network->group |= WFD_OEM_CIPHER_CCMP;
5026
5027         } else if (g_strcmp0(key, "auth_alg") == 0) {
5028                 const char *auth_alg = NULL;
5029                 g_variant_get(value, "&s", &auth_alg);
5030                 WDP_LOGD("auth_alg [%s]", auth_alg);
5031
5032                 if (g_strrstr(auth_alg, WFD_OEM_STR_AUTH_ALG_OPEN) != NULL)
5033                         network->auth_alg |= WFD_OEM_AUTH_ALG_OPEN;
5034
5035         } else if (g_strcmp0(key, "mode") == 0) {
5036                 const char *mode = NULL;
5037                 g_variant_get(value, "&s", &mode);
5038                 WDP_LOGD("mode [%s]", mode);
5039
5040                 if (g_strrstr(mode, WFD_OEM_STR_MODE_GC) != NULL)
5041                         network->mode |= WFD_OEM_PERSISTENT_MODE_GC;
5042                 if (g_strrstr(mode, WFD_OEM_STR_MODE_GO) != NULL)
5043                         network->mode |= WFD_OEM_PERSISTENT_MODE_GO;
5044
5045         } else if (g_strcmp0(key, "p2p_client_list") == 0) {
5046                 const char *p2p_client_list = NULL;
5047                 char *ptr = NULL;
5048                 int list_len = 0;
5049                 int num = 0;
5050
5051                 g_variant_get(value, "&s", &p2p_client_list);
5052                 WDP_LOGD("p2p_client_list [%s]", p2p_client_list);
5053                 ptr = (char *)p2p_client_list;
5054                 list_len = strlen(p2p_client_list);
5055                 WDP_LOGD("list_len [%d]", list_len);
5056                 while (ptr && list_len >= (OEM_MACSTR_LEN - 1)) {
5057                         __ws_txt_to_mac((unsigned char *)ptr, (network->p2p_client_list[num]));
5058                         ptr += OEM_MACSTR_LEN;
5059                         list_len -= OEM_MACSTR_LEN;
5060                         if (ptr && ptr[0] == ' ') {
5061                                 ptr += 1;
5062                                 list_len -= 1;
5063                         }
5064                         num++;
5065                         if (num >= OEM_MAX_PEER_NUM)
5066                                 break;
5067                 }
5068                 network->p2p_client_num = num;
5069                 WDP_LOGD("p2p_client_num [%d]", network->p2p_client_num);
5070         }
5071         return;
5072 }
5073
5074 void __ws_extract_p2pdevice_details(const char *key, GVariant *value, void *user_data)
5075 {
5076         __WDP_LOG_FUNC_ENTER__;
5077 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5078         CHECK_KEY_VALUE(key, value);
5079 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5080         if (g_strcmp0(key, "PersistentGroups") == 0) {
5081                 GVariantIter *iter = NULL;
5082                 const char *path = NULL;
5083                 int num = 0;
5084
5085                 ws_network_info_s *networks = NULL;
5086                 networks = (ws_network_info_s *)user_data;
5087                 if (!networks) {
5088                         WDP_LOGE("network is NULL");
5089                         __WDP_LOG_FUNC_EXIT__;
5090                         return;
5091                 }
5092
5093                 g_variant_get(value, "ao", &iter);
5094                 while (g_variant_iter_loop(iter, "&o", &path)) {
5095                         char *loc = NULL;
5096
5097                         if (num >= WS_MAX_PERSISTENT_COUNT)
5098                                 break;
5099
5100                         WDP_LOGD("Retrive persistent path [%s]", path);
5101                         g_strlcpy(networks[num].persistent_path, path, DBUS_OBJECT_PATH_MAX);
5102
5103                         loc = strrchr(networks[num].persistent_path, '/');
5104                         if (loc)
5105                                 networks[num].network_id = strtoul(loc+1, NULL, 10);
5106
5107                         WDP_LOGD("Retrive persistent path [%s]", networks[num].persistent_path);
5108                         dbus_property_get_all(networks[num].persistent_path, g_pd->g_dbus,
5109                                         SUPPLICANT_P2P_PERSISTENTGROUP, __parsing_networks, &networks[num]);
5110                         num++;
5111                 }
5112
5113                 networks[0].total = num;
5114                 WDP_LOGI("total number [%d]", num);
5115                 g_variant_iter_free(iter);
5116         }
5117         __WDP_LOG_FUNC_EXIT__;
5118 }
5119
5120
5121 int ws_get_persistent_groups(wfd_oem_persistent_group_s **groups, int *group_count)
5122 {
5123         __WDP_LOG_FUNC_ENTER__;
5124         GDBusConnection *g_dbus = NULL;
5125
5126         ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
5127         wfd_oem_persistent_group_s *wfd_persistent_groups = NULL;
5128         int i, cnt = 0;
5129
5130         if (!g_pd) {
5131                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5132                 __WDP_LOG_FUNC_EXIT__;
5133                 return -1;
5134         }
5135
5136         g_dbus = g_pd->g_dbus;
5137         if (!g_dbus) {
5138                 WDP_LOGE("DBus connection is NULL");
5139                 __WDP_LOG_FUNC_EXIT__;
5140                 return -1;
5141         }
5142
5143         memset(&networks, 0x0, WS_MAX_PERSISTENT_COUNT * sizeof(ws_network_info_s));
5144         dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICANT_P2PDEVICE,
5145                         __ws_extract_p2pdevice_details, &networks[0]);
5146
5147         cnt = networks[0].total;
5148
5149         WDP_LOGD("Persistent Group Count=%d", cnt);
5150         if (cnt > WS_MAX_PERSISTENT_COUNT) {
5151                 WDP_LOGE("Persistent group count exceeded or parsing error");
5152                 __WDP_LOG_FUNC_EXIT__;
5153                 return -1;
5154         }
5155
5156         if (cnt == 0) {
5157                 WDP_LOGE("Persistent group count zero");
5158                 *group_count = 0;
5159                 *groups = NULL;
5160                 __WDP_LOG_FUNC_EXIT__;
5161                 return 0;
5162         }
5163
5164         wfd_persistent_groups = (wfd_oem_persistent_group_s *) g_try_malloc0(cnt * sizeof(wfd_oem_persistent_group_s));
5165         if (wfd_persistent_groups == NULL) {
5166                 WDP_LOGE("Failed to allocate memory for wfd_persistent_groups ");
5167                 __WDP_LOG_FUNC_EXIT__;
5168                 return -1;
5169         }
5170
5171         for (i = 0; i < cnt; i++) {
5172                 int j = 0;
5173
5174                 WDP_LOGD("----persistent group [%d]----", i);
5175                 WDP_LOGD("network_id [%d]", networks[i].network_id);
5176                 WDP_LOGD("ssid [%s]", networks[i].ssid);
5177                 WDP_LOGD("bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
5178                 WDP_LOGD("p2p_client_num [%d]", networks[i].p2p_client_num);
5179                 for (j = 0; j < networks[i].p2p_client_num; j++)
5180                         WDP_LOGD("p2p_client_list ["MACSTR"]", MAC2STR(networks[i].p2p_client_list[j]));
5181
5182                 wfd_persistent_groups[i].network_id = networks[i].network_id;
5183                 g_strlcpy(wfd_persistent_groups[i].ssid, networks[i].ssid, WS_SSID_LEN + 1);
5184                 memcpy(wfd_persistent_groups[i].go_mac_address, networks[i].bssid, WS_MACADDR_LEN);
5185                 wfd_persistent_groups[i].p2p_client_num = networks[i].p2p_client_num;
5186                 if (wfd_persistent_groups[i].p2p_client_num > 0)
5187                         memcpy(wfd_persistent_groups[i].p2p_client_list, networks[i].p2p_client_list,
5188                                         OEM_MACADDR_LEN * OEM_MAX_PEER_NUM * sizeof(char));
5189         }
5190
5191         *group_count = cnt;
5192         *groups = wfd_persistent_groups;
5193
5194         __WDP_LOG_FUNC_EXIT__;
5195         return 0;
5196 }
5197
5198 int ws_remove_persistent_group(char *ssid, unsigned char *bssid)
5199 {
5200         __WDP_LOG_FUNC_ENTER__;
5201         GDBusConnection *g_dbus = NULL;
5202
5203         dbus_method_param_s params;
5204         ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
5205         int i, cnt = 0;
5206         int res = 0;
5207
5208         if (!g_pd) {
5209                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5210                 __WDP_LOG_FUNC_EXIT__;
5211                 return -1;
5212         }
5213
5214         g_dbus = g_pd->g_dbus;
5215         if (!g_dbus) {
5216                 WDP_LOGE("DBus connection is NULL");
5217                 __WDP_LOG_FUNC_EXIT__;
5218                 return -1;
5219         }
5220         dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICANT_P2PDEVICE,
5221                         __ws_extract_p2pdevice_details, networks);
5222
5223         cnt = networks[0].total;
5224
5225         WDP_LOGD("Persistent Group Count=%d", cnt);
5226         if (cnt > WS_MAX_PERSISTENT_COUNT) {
5227                 WDP_LOGE("Persistent group count exceeded or parsing error");
5228                 __WDP_LOG_FUNC_EXIT__;
5229                 return -1;
5230         }
5231
5232         for (i = 0; i < cnt; i++) {
5233                 int j = 0;
5234
5235                 WDP_LOGD("----persistent group [%d]----", i);
5236                 WDP_LOGD("network_id [%d]", networks[i].network_id);
5237                 WDP_LOGD("network ssid [%s]", networks[i].ssid);
5238                 WDP_LOGD("network bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
5239                 WDP_LOGD("network p2p_client_num [%d]", networks[i].p2p_client_num);
5240                 for (j = 0; j < networks[i].p2p_client_num; j++)
5241                         WDP_LOGD("network p2p_client_list ["MACSTR"]",
5242                                         MAC2STR(networks[i].p2p_client_list[j]));
5243
5244                 WDP_LOGD("ssid [%s]", ssid);
5245                 WDP_LOGD("bssid ["MACSTR"]", MAC2STR(bssid));
5246
5247                 if (!g_strcmp0(ssid, networks[i].ssid) &&
5248                                 !memcmp(bssid, networks[i].bssid, WS_MACADDR_LEN)) {
5249                         WDP_LOGD("Persistent group owner found [%d: %s]",
5250                                         networks[i].network_id, ssid);
5251
5252                         memset(&params, 0x0, sizeof(dbus_method_param_s));
5253                         dbus_set_method_param(&params, "RemovePersistentGroup",
5254                                         g_pd->iface_path, g_dbus);
5255                         params.params = g_variant_new("(o)", networks[i].persistent_path);
5256 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5257                         DEBUG_PARAMS(params.params);
5258 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5259
5260                         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
5261                         if (res < 0) {
5262                                 WDP_LOGE("Failed to send command to wpa_supplicant");
5263                                 __WDP_LOG_FUNC_EXIT__;
5264                                 return -1;
5265                         }
5266
5267                         WDP_LOGD("Succeeded to remove persistent group");;
5268                         break;
5269                 }
5270         }
5271
5272         if (i == cnt) {
5273                 WDP_LOGE("Persistent group not found [%s]", ssid);
5274                 return -1;
5275         }
5276
5277         __WDP_LOG_FUNC_EXIT__;
5278         return 0;
5279 }
5280
5281 int ws_set_persistent_reconnect(unsigned char *bssid, int reconnect)
5282 {
5283         __WDP_LOG_FUNC_ENTER__;
5284         GDBusConnection *g_dbus = NULL;
5285
5286         GVariant *value = NULL;
5287         GVariant *param = NULL;
5288         GVariantBuilder *builder = NULL;
5289         dbus_method_param_s params;
5290         int res = 0;
5291
5292         if (!g_pd) {
5293                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5294                 return -1;
5295         }
5296
5297         g_dbus = g_pd->g_dbus;
5298         if (!g_dbus) {
5299                 WDP_LOGE("DBus connection is NULL");
5300                 return -1;
5301         }
5302         memset(&params, 0x0, sizeof(dbus_method_param_s));
5303
5304         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
5305                         g_dbus);
5306
5307         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
5308         g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
5309                                 g_variant_new_boolean(reconnect));
5310         value = g_variant_new("a{sv}", builder);
5311         g_variant_builder_unref(builder);
5312
5313         param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
5314
5315         params.params = param;
5316 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5317         DEBUG_PARAMS(params.params);
5318 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5319
5320         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
5321         if (res < 0)
5322                 WDP_LOGE("Failed to send command to wpa_supplicant");
5323         else
5324                 WDP_LOGD("Succeeded to set persistent reconnect");
5325
5326         __WDP_LOG_FUNC_EXIT__;
5327         return res;
5328 }
5329
5330 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
5331 static int __ws_compress_query(char *compressed, char *query, int qtype)
5332 {
5333         char *token = NULL;
5334         char *temp = NULL;
5335         int token_num = 0;
5336         int token_len = 0;
5337         int length = 0;
5338
5339         token = strtok_r(query, ".", &temp);
5340         while (token) {
5341                 if (!strcmp(token, "local")) {
5342                         WDP_LOGD("Query conversion done");
5343                         break;
5344
5345                 } else if (!strncmp(token, "_tcp", 4)) {
5346                         memcpy(&compressed[length], WS_TCP_PTR_HEX, 2);
5347                         length += 2;
5348
5349                 } else if (!strncmp(token, "_udp", 4)) {
5350                         memcpy(&compressed[length], WS_UDP_PTR_HEX, 2);
5351                         length += 2;
5352
5353                 } else {
5354                         WDP_LOGD("Token: [%s]", token);
5355                         token_len = strlen(token);
5356                         compressed[length] = token_len;
5357                         length++;
5358
5359                         memcpy(&compressed[length], token, token_len);
5360                         length += token_len;
5361                 }
5362                 token_num++;
5363                 token = strtok_r(NULL, ".", &temp);
5364         }
5365         if (qtype == WS_QTYPE_PTR || token_num == 2)
5366                 memcpy(&compressed[length], WS_PTR_TYPE_HEX, 3);
5367         else if (qtype == WS_QTYPE_TXT || token_num == 3)
5368                 memcpy(&compressed[length], WS_TXT_TYPE_HEX, 3);
5369
5370         length += 3;
5371         WDP_LOGD("converted query length [%d] token num [%d]", length, token_num);
5372
5373         return length;
5374 }
5375
5376 static int __ws_compress_rdata(char *compressed, char *rdata, int qtype)
5377 {
5378         char *token = NULL;
5379         char *temp = NULL;
5380         int token_len = 0;
5381         int length = 0;
5382
5383         if (qtype == WS_QTYPE_PTR) {
5384
5385                 token = strtok_r(rdata, ".", &temp);
5386                 if (token) {
5387                         WDP_LOGD("Token: %s", token);
5388                         token_len = strlen(token);
5389                         compressed[length] = token_len;
5390                         length++;
5391
5392                         memcpy(&compressed[length], token, token_len);
5393                         length += token_len;
5394                 }
5395
5396                 compressed[length] = 0xc0;
5397                 compressed[length+1] = 0x27;
5398                 length += 2;
5399
5400         } else if (qtype == WS_QTYPE_TXT) {
5401
5402                 token = strtok_r(rdata, ", ", &temp);
5403
5404                 while (token) {
5405                         WDP_LOGD("Token: [%s]", token);
5406
5407                         token_len = strlen(token);
5408                         compressed[length] = token_len;
5409                         length++;
5410
5411                         memcpy(&compressed[length], token, token_len);
5412                         length += token_len;
5413
5414                         token = strtok_r(NULL, ", ", &temp);
5415                 }
5416         } else {
5417                 WDP_LOGD("RDATA is NULL");
5418         }
5419         return length;
5420 }
5421
5422 int _convert_bonjour_to_args(char *query, char *rdata, GVariantBuilder *builder)
5423 {
5424         GVariantBuilder *args = NULL;
5425         char compressed[256] = {0, };
5426         char *temp = NULL;
5427         int length = 0;
5428         int qtype = 0;
5429         int i = 0;
5430
5431         if (!query || !builder) {
5432                 WDP_LOGE("Invalid parameter");
5433                 return -1;
5434         }
5435         if (!rdata || !strlen(rdata)) {
5436                 WDP_LOGD("RDATA is NULL\n");
5437         } else {
5438                 temp = strstr(rdata, query);
5439
5440                 if (temp != NULL && temp - rdata > 0)
5441                         qtype = WS_QTYPE_PTR;
5442                 else
5443                         qtype = WS_QTYPE_TXT;
5444                 temp = NULL;
5445         }
5446
5447         g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("bonjour"));
5448
5449         /* compress query */
5450         length = __ws_compress_query(compressed, query, qtype);
5451
5452         args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5453         for (i = 0; i < length; i++)
5454                 g_variant_builder_add(args, "y", compressed[i]);
5455         g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", args));
5456         g_variant_builder_unref(args);
5457
5458         memset(compressed, 0x0, 256);
5459         length = 0;
5460         args = NULL;
5461
5462         if (qtype != 0) {
5463                 length = __ws_compress_rdata(compressed, rdata, qtype);
5464
5465                 args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5466                 for (i = 0; i < length; i++)
5467                         g_variant_builder_add(args, "y", compressed[i]);
5468                 g_variant_builder_add(builder, "{sv}", "response", g_variant_new("ay", args));
5469                 g_variant_builder_unref(args);
5470         }
5471
5472         return 0;
5473 }
5474
5475 int _check_service_query_exists(wfd_oem_service_s *service)
5476 {
5477         int count = 0;
5478         wfd_oem_service_s *data = NULL;
5479
5480         for (count = 0; count < g_list_length(service_list); count++) {
5481                 data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
5482                 if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
5483                         WDP_LOGD("Query already exists");
5484                         return 1;
5485                 }
5486         }
5487         return 0;
5488 }
5489
5490 static wfd_oem_service_s* _remove_service_query(char * s_type, char *mac_str, char *query_id)
5491 {
5492         if (NULL == s_type || NULL == mac_str || NULL == query_id)
5493                 return NULL;
5494
5495         int count = 0;
5496         wfd_oem_service_s *data = NULL;
5497
5498         for (count = 0; count < g_list_length(service_list); count++) {
5499                 data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
5500                 if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
5501                                 memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
5502                         strncpy(query_id, data->query_id, OEM_QUERY_ID_LEN);
5503                         break;
5504                 }
5505         }
5506         if (strlen(query_id) <= 0) {
5507                 WDP_LOGD("!! Query ID not found !!");
5508                 return NULL;
5509         }
5510
5511         WDP_LOGD("query id :[0x%s]", query_id);
5512
5513         return data;
5514 }
5515
5516 void __add_service_query(GVariant *value, void *mac_addr)
5517 {
5518         __WDP_LOG_FUNC_ENTER__;
5519         wfd_oem_service_s *service = NULL;
5520
5521         long long unsigned ref = 0;
5522         unsigned char *mac_address = (unsigned char *)mac_addr;
5523         char mac_str[18] = {0, };
5524
5525         int res = 0;
5526
5527         g_variant_get(value, "(t)", &ref);
5528
5529         service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
5530         if (!service) {
5531                 WDP_LOGE("Failed to allocate memory for service");
5532                 return;
5533         }
5534
5535         if (mac_address[0] == 0 && mac_address[1] == 0 && mac_address[2] == 0 &&
5536                         mac_address[3] == 0 && mac_address[4] == 0 && mac_address[5] == 0) {
5537                 g_snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
5538         } else {
5539                 g_snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_address));
5540         }
5541
5542         g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
5543         g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
5544
5545         res = _check_service_query_exists(service);
5546         if (res)
5547                 free(service);
5548         else
5549                 service_list = g_list_append(service_list, service);
5550
5551         __WDP_LOG_FUNC_EXIT__;
5552         return;
5553
5554 }
5555
5556 /* for now, supplicant dbus interface only provides upnp service fully */
5557 int ws_start_service_discovery(unsigned char *mac_addr, int service_type)
5558 {
5559         __WDP_LOG_FUNC_ENTER__;
5560         GDBusConnection *g_dbus = NULL;
5561         GVariantBuilder *builder = NULL;
5562         GVariant *value = NULL;
5563         dbus_method_param_s params;
5564         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
5565         int i = 0;
5566         int res = 0;
5567
5568         if (!mac_addr) {
5569                 WDP_LOGE("Invalid parameter");
5570                 __WDP_LOG_FUNC_EXIT__;
5571                 return -1;
5572         }
5573
5574         if (!g_pd) {
5575                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5576                 __WDP_LOG_FUNC_EXIT__;
5577                 return -1;
5578         }
5579
5580         g_dbus = g_pd->g_dbus;
5581         if (!g_dbus) {
5582                 WDP_LOGE("DBus connection is NULL");
5583                 __WDP_LOG_FUNC_EXIT__;
5584                 return -1;
5585         }
5586         memset(&params, 0x0, sizeof(dbus_method_param_s));
5587
5588         dbus_set_method_param(&params, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
5589
5590         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
5591
5592         if (mac_addr) {
5593                 g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
5594                                 COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
5595                 WDP_LOGD("get peer path [%s]", peer_path);
5596                 g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
5597         }
5598
5599         if (service_type == WFD_OEM_SERVICE_TYPE_ALL) {
5600
5601                 char *service_all = "\x02\x00\x00\x01";
5602                 GVariantBuilder *query = NULL;
5603
5604                 query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5605                 for (i = 0; i < SERVICE_QUERY_LEN; i++)
5606                         g_variant_builder_add(query, "y", service_all[i]);
5607                 g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
5608                 g_variant_builder_unref(query);
5609
5610                 } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
5611
5612                 g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
5613                 g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
5614
5615         } else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
5616
5617                 char *service_bonjour = "\x02\x00\x01\x01";
5618                 GVariantBuilder *query = NULL;
5619
5620                 query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5621                 for (i = 0; i < SERVICE_QUERY_LEN; i++)
5622                         g_variant_builder_add(query, "y", service_bonjour[i]);
5623                 g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
5624                 g_variant_builder_unref(query);
5625         }
5626
5627         value = g_variant_new("(a{sv})", builder);
5628         g_variant_builder_unref(builder);
5629
5630         params.params = value;
5631 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5632         DEBUG_PARAMS(params.params);
5633 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5634
5635         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, __add_service_query, mac_addr);
5636         if (res < 0)
5637                 WDP_LOGE("Failed to send command to wpa_supplicant");
5638         else
5639                 WDP_LOGD("Succeeded to start service discovery");
5640
5641         __WDP_LOG_FUNC_EXIT__;
5642         return res;
5643 }
5644
5645 int ws_cancel_service_discovery(unsigned char *mac_addr, int service_type)
5646 {
5647         __WDP_LOG_FUNC_ENTER__;
5648         GDBusConnection *g_dbus = NULL;
5649         dbus_method_param_s params;
5650         wfd_oem_service_s *data = NULL;
5651         char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
5652         char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
5653         char mac_str[18] = {0, };
5654
5655         int res = 0;
5656
5657         if (!mac_addr) {
5658                 WDP_LOGE("Invalid parameter");
5659                 __WDP_LOG_FUNC_EXIT__;
5660                 return -1;
5661         }
5662
5663         if (!g_pd) {
5664                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5665                 __WDP_LOG_FUNC_EXIT__;
5666                 return -1;
5667         }
5668
5669         g_dbus = g_pd->g_dbus;
5670         if (!g_dbus) {
5671                 WDP_LOGE("DBus connection is NULL");
5672                 __WDP_LOG_FUNC_EXIT__;
5673                 return -1;
5674         }
5675
5676         if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
5677                 mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
5678                 snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
5679         } else {
5680                 snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
5681         }
5682
5683         switch (service_type) {
5684         case WFD_OEM_SERVICE_TYPE_ALL:
5685                 strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
5686         break;
5687         case WFD_OEM_SERVICE_TYPE_BONJOUR:
5688                 strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
5689         break;
5690         case WFD_OEM_SERVICE_TYPE_UPNP:
5691                 strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
5692         break;
5693         default:
5694                 WDP_LOGE("Invalid Service type");
5695                 __WDP_LOG_FUNC_EXIT__;
5696                 return -1;
5697         }
5698
5699         WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
5700         WDP_LOGD("Cancel service discovery s_type [%s]", s_type);
5701
5702         data = _remove_service_query(s_type, mac_str, query_id);
5703         if (NULL == data) {
5704                 __WDP_LOG_FUNC_EXIT__;
5705                 return -1;
5706         }
5707         memset(&params, 0x0, sizeof(dbus_method_param_s));
5708
5709         dbus_set_method_param(&params, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
5710
5711         params.params = g_variant_new("(t)", strtoul(query_id, NULL, 16));
5712
5713         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
5714         if (res < 0)
5715                 WDP_LOGE("Failed to send command to wpa_supplicant");
5716         else
5717                 WDP_LOGD("Succeeded to cancel service discovery");
5718
5719         service_list = g_list_remove(service_list, data);
5720         free(data);
5721
5722         __WDP_LOG_FUNC_EXIT__;
5723         return res;
5724 }
5725
5726 int ws_serv_add(wfd_oem_new_service_s *service)
5727 {
5728         __WDP_LOG_FUNC_ENTER__;
5729         GDBusConnection *g_dbus = NULL;
5730         GVariantBuilder *builder = NULL;
5731         GVariant *value = NULL;
5732         dbus_method_param_s params;
5733         int res = 0;
5734
5735         if (!g_pd) {
5736                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5737                 return -1;
5738         }
5739
5740         g_dbus = g_pd->g_dbus;
5741         if (!g_dbus) {
5742                 WDP_LOGE("DBus connection is NULL");
5743                 return -1;
5744         }
5745         memset(&params, 0x0, sizeof(dbus_method_param_s));
5746
5747         dbus_set_method_param(&params, "AddService", g_pd->iface_path, g_dbus);
5748
5749         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
5750
5751         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
5752
5753                 WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
5754                 WDP_LOGD("Query: %s", service->data.bonjour.query);
5755                 WDP_LOGD("RData: %s", service->data.bonjour.rdata);
5756
5757                 res = _convert_bonjour_to_args(service->data.bonjour.query,
5758                                                             service->data.bonjour.rdata, builder);
5759                 if (res < 0) {
5760                         WDP_LOGE("Failed to convert Key string");
5761                         g_variant_builder_unref(builder);
5762                         return -1;
5763                 }
5764
5765         } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
5766                 g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
5767                 g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
5768                 g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
5769         }
5770
5771         value = g_variant_new("(a{sv})", builder);
5772         g_variant_builder_unref(builder);
5773
5774         params.params = value;
5775 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5776         DEBUG_PARAMS(params.params);
5777 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5778
5779         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
5780         if (res < 0)
5781                 WDP_LOGE("Failed to send command to wpa_supplicant");
5782         else
5783                 WDP_LOGD("Succeeded to add service");
5784
5785         __WDP_LOG_FUNC_EXIT__;
5786         return 0;
5787 }
5788
5789 int ws_serv_del(wfd_oem_new_service_s *service)
5790 {
5791         __WDP_LOG_FUNC_ENTER__;
5792         GDBusConnection *g_dbus = NULL;
5793         GVariantBuilder *builder = NULL;
5794         GVariant *value = NULL;
5795         dbus_method_param_s params;
5796         int res = 0;
5797
5798         if (!g_pd) {
5799                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5800                 return -1;
5801         }
5802
5803         g_dbus = g_pd->g_dbus;
5804         if (!g_dbus) {
5805                 WDP_LOGE("DBus connection is NULL");
5806                 return -1;
5807         }
5808         memset(&params, 0x0, sizeof(dbus_method_param_s));
5809
5810         dbus_set_method_param(&params, "DeleteService", g_pd->iface_path, g_dbus);
5811
5812         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
5813
5814         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
5815
5816                 WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
5817                 WDP_LOGD("Query: %s", service->data.bonjour.query);
5818
5819                 res = _convert_bonjour_to_args(service->data.bonjour.query,
5820                                                             NULL, builder);
5821                 if (res < 0) {
5822                         WDP_LOGE("Failed to convert Key string");
5823                         g_variant_builder_unref(builder);
5824                         return -1;
5825                 }
5826
5827         } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
5828                 g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
5829                 g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
5830                 g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
5831         }
5832
5833         value = g_variant_new("(a{sv})", builder);
5834         g_variant_builder_unref(builder);
5835
5836         params.params = value;
5837 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5838         DEBUG_PARAMS(params.params);
5839 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5840
5841         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
5842         if (res < 0)
5843                 WDP_LOGE("Failed to send command to wpa_supplicant");
5844         else
5845                 WDP_LOGD("Succeeded to del service");
5846
5847         __WDP_LOG_FUNC_EXIT__;
5848         return 0;
5849 }
5850 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
5851
5852 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
5853
5854 int _ws_disable_display()
5855 {
5856         __WDP_LOG_FUNC_ENTER__;
5857         GDBusConnection *g_dbus = NULL;
5858         GVariantBuilder *builder = NULL;
5859         GVariant *value = NULL;
5860         GVariant *param = NULL;
5861         dbus_method_param_s params;
5862         int res = 0;
5863
5864         if (!g_pd) {
5865                 WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
5866                 return -1;
5867         }
5868
5869         g_dbus = g_pd->g_dbus;
5870         if (!g_dbus) {
5871                 WDP_LOGE("DBus connection is NULL");
5872                 return -1;
5873         }
5874         memset(&params, 0x0, sizeof(dbus_method_param_s));
5875
5876         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
5877                          g_dbus);
5878
5879         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5880         value = g_variant_new("ay", builder);
5881         g_variant_builder_unref(builder);
5882
5883         param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
5884
5885         params.params = param;
5886 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5887         DEBUG_PARAMS(params.params);
5888 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5889
5890         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
5891         if (res < 0)
5892                 WDP_LOGE("Failed to send command to wpa_supplicant");
5893         else
5894                 WDP_LOGD("Succeeded to disable Wi-Fi display");
5895
5896         __WDP_LOG_FUNC_EXIT__;
5897         return res;
5898 }
5899
5900 int ws_miracast_init(int enable)
5901 {
5902         __WDP_LOG_FUNC_ENTER__;
5903         wfd_oem_display_s wifi_display;
5904         int res = 0;
5905
5906         memset(&wifi_display, 0x0, sizeof(wfd_oem_display_s));
5907
5908         wifi_display.availability = enable;
5909         wifi_display.hdcp_support = 1;
5910         wifi_display.port = 0x07E6;
5911         wifi_display.max_tput = 0x0028;
5912
5913         res = ws_set_display(&wifi_display);
5914         if (res < 0) {
5915                 WDP_LOGE("Failed to set miracast parameter(device info)");
5916                 __WDP_LOG_FUNC_EXIT__;
5917                 return -1;
5918         }
5919
5920         if (!enable) {
5921                 res = _ws_disable_display();
5922                 if (res < 0)
5923                         WDP_LOGE("Failed to disable wifi display");
5924                 else
5925                         WDP_LOGD("Succeeded to disable wifi display");
5926         }
5927         __WDP_LOG_FUNC_EXIT__;
5928         return res;
5929 }
5930
5931 int ws_set_display(wfd_oem_display_s *wifi_display)
5932 {
5933         __WDP_LOG_FUNC_ENTER__;
5934         GDBusConnection *g_dbus = NULL;
5935
5936         GVariant *value = NULL;
5937         GVariant *param = NULL;
5938         GVariantBuilder *builder = NULL;
5939         dbus_method_param_s params;
5940         int i = 0;
5941         int res = 0;
5942
5943         unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
5944
5945         if (!wifi_display) {
5946                 WDP_LOGE("Invalid parameter");
5947                 return -1;
5948         }
5949         g_dbus = g_pd->g_dbus;
5950         if (!g_dbus) {
5951                 WDP_LOGE("DBus connection is NULL");
5952                 return -1;
5953         }
5954         memset(&params, 0x0, sizeof(dbus_method_param_s));
5955
5956         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
5957                          g_dbus);
5958
5959         ies[2] = WFD_SUBELEM_LEN_DEV_INFO;
5960         ies[3] = wifi_display->hdcp_support;
5961         ies[4] = (wifi_display->type) | (wifi_display->availability<<4);
5962         ies[5] = wifi_display->port>>8;
5963         ies[6] = wifi_display->port&0xff;
5964         ies[7] = wifi_display->max_tput>>8;
5965         ies[8] = wifi_display->max_tput&0xff;
5966
5967         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
5968         for (i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
5969                 g_variant_builder_add(builder, "y", ies[i]);
5970         value = g_variant_new("ay", builder);
5971         g_variant_builder_unref(builder);
5972
5973         param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
5974
5975         params.params = param;
5976 #if defined(TIZEN_DEBUG_DBUS_VALUE)
5977         DEBUG_PARAMS(params.params);
5978 #endif /* TIZEN_DEBUG_DBUS_VALUE */
5979
5980         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
5981         if (res < 0)
5982                 WDP_LOGE("Failed to send command to wpa_supplicant");
5983         else
5984                 WDP_LOGD("Succeeded to set Wi-Fi Display");
5985
5986         __WDP_LOG_FUNC_EXIT__;
5987         return res;
5988 }
5989 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
5990
5991 int ws_refresh()
5992 {
5993         __WDP_LOG_FUNC_ENTER__;
5994
5995         _ws_cancel();
5996         _ws_flush();
5997
5998         __WDP_LOG_FUNC_EXIT__;
5999         return 0;
6000 }
6001
6002 int ws_save_config(void)
6003 {
6004         __WDP_LOG_FUNC_ENTER__;
6005         GDBusConnection *g_dbus = NULL;
6006         dbus_method_param_s params;
6007         int res = 0;
6008
6009         g_dbus = g_pd->g_dbus;
6010         if (!g_dbus) {
6011                 WDP_LOGE("DBus connection is NULL");
6012                 __WDP_LOG_FUNC_EXIT__;
6013                 return -1;
6014         }
6015         memset(&params, 0x0, sizeof(dbus_method_param_s));
6016
6017         dbus_set_method_param(&params, "SaveConfig", g_pd->iface_path, g_dbus);
6018         params.params = NULL;
6019
6020         res = dbus_method_call(&params, SUPPLICANT_IFACE, NULL, NULL);
6021         if (res < 0)
6022                 WDP_LOGE("Failed to save config to wpa_supplicant");
6023         else
6024                 WDP_LOGD("Succeeded to save config");
6025
6026         __WDP_LOG_FUNC_EXIT__;
6027         return res;
6028 }
6029
6030 int ws_set_operating_channel(int channel)
6031 {
6032         __WDP_LOG_FUNC_ENTER__;
6033         GDBusConnection *g_dbus = NULL;
6034         GVariant *value = NULL;
6035         GVariant *param = NULL;
6036         GVariantBuilder *builder = NULL;
6037         dbus_method_param_s params;
6038         int res = 0;
6039
6040         g_dbus = g_pd->g_dbus;
6041         if (!g_dbus) {
6042                 WDP_LOGE("DBus connection is NULL");
6043                 __WDP_LOG_FUNC_EXIT__;
6044                 return -1;
6045         }
6046
6047         memset(&params, 0x0, sizeof(dbus_method_param_s));
6048
6049         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path, g_dbus);
6050
6051         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
6052         g_variant_builder_add(builder, "{sv}", "OperChannel", g_variant_new_uint32(channel));
6053         value = g_variant_new("a{sv}", builder);
6054         g_variant_builder_unref(builder);
6055
6056         param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
6057         params.params = param;
6058
6059         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
6060         if (res < 0)
6061                 WDP_LOGE("Failed to send command to wpa_supplicant");
6062         else
6063                 WDP_LOGD("Succeeded to set Operating Channel");
6064
6065         __WDP_LOG_FUNC_EXIT__;
6066         return res;
6067 }
6068
6069 int ws_remove_all_network(void)
6070 {
6071         __WDP_LOG_FUNC_ENTER__;
6072         GDBusConnection *g_dbus = NULL;
6073         dbus_method_param_s params;
6074         int res = 0;
6075
6076         g_dbus = g_pd->g_dbus;
6077         if (!g_dbus) {
6078                 WDP_LOGE("DBus connection is NULL");
6079                 __WDP_LOG_FUNC_EXIT__;
6080                 return -1;
6081         }
6082         memset(&params, 0x0, sizeof(dbus_method_param_s));
6083
6084         dbus_set_method_param(&params, "RemoveAllNetworks", g_pd->iface_path, g_dbus);
6085         params.params = NULL;
6086
6087         res = dbus_method_call(&params, SUPPLICANT_IFACE, NULL, NULL);
6088         if (res < 0)
6089                 WDP_LOGE("Failed to send [RemoveAllNetworks] command to wpa_supplicant");
6090         else
6091                 WDP_LOGD("Succeeded to remove all networks from supplicant");
6092
6093         WDP_LOGD("Succeeded to remove all network");
6094         __WDP_LOG_FUNC_EXIT__;
6095         return res;
6096 }
6097
6098 int ws_get_wpa_status(int *wpa_status)
6099 {
6100         __WDP_LOG_FUNC_ENTER__;
6101         GDBusConnection *g_dbus = NULL;
6102         GVariant *param = NULL;
6103         GVariant *reply = NULL;
6104         GError *error = NULL;
6105
6106         if (!wpa_status) {
6107                 WDP_LOGE("Invalid parameter");
6108                 __WDP_LOG_FUNC_EXIT__;
6109                 return -1;
6110         }
6111
6112         *wpa_status = WFD_OEM_WPA_STATE_MAX;
6113
6114         g_dbus = g_pd->g_dbus;
6115         if (!g_dbus) {
6116                 WDP_LOGE("DBus connection is NULL");
6117                 __WDP_LOG_FUNC_EXIT__;
6118                 return -1;
6119         }
6120
6121         param = g_variant_new("(s)", SUPPLICANT_IFACE);
6122
6123         reply = g_dbus_connection_call_sync(
6124                         g_pd->g_dbus,
6125                         SUPPLICANT_SERVICE, /* bus name */
6126                         g_pd->iface_path, /* object path */
6127                         DBUS_PROPERTIES_INTERFACE, /* interface name */
6128                         DBUS_PROPERTIES_METHOD_GETALL, /* method name */
6129                         param, /* GVariant *params */
6130                         NULL, /* reply_type */
6131                         G_DBUS_CALL_FLAGS_NONE, /* flags */
6132                         SUPPLICANT_TIMEOUT , /* timeout */
6133                         NULL, /* cancellable */
6134                         &error); /* error */
6135
6136         if (error != NULL) {
6137                 WDP_LOGE("Error! Failed to get properties: [%s]",
6138                                                         error->message);
6139                 g_error_free(error);
6140                 if (reply)
6141                         g_variant_unref(reply);
6142                 __WDP_LOG_FUNC_EXIT__;
6143                 return -1;
6144         }
6145
6146         gchar *reply_str = NULL;
6147         if (reply)
6148                 reply_str = g_variant_print(reply, TRUE);
6149         WDP_LOGE("reply [%s]", reply_str ? reply_str : "NULL");
6150         g_free(reply_str);
6151
6152         if (reply != NULL) {
6153                 GVariantIter *iter = NULL;
6154                 g_variant_get(reply, "(a{sv})", &iter);
6155
6156                 if (iter != NULL) {
6157                         gchar *key = NULL;
6158                         GVariant *value = NULL;
6159
6160                         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
6161                                 if (g_strcmp0(key, "State") == 0) {
6162                                         const gchar *state = NULL;
6163                                         g_variant_get(value, "&s", &state);
6164                                         WDP_LOGI("state : [%s]", state);
6165
6166                                         if (g_strcmp0(state, "disconnected") == 0)
6167                                                 *wpa_status = WFD_OEM_WPA_STATE_DISCONNECTED;
6168                                         else if (g_strcmp0(state, "inactive") == 0)
6169                                                 *wpa_status = WFD_OEM_WPA_STATE_INACTIVE;
6170                                         else if (g_strcmp0(state, "scanning") == 0)
6171                                                 *wpa_status = WFD_OEM_WPA_STATE_SCANNING;
6172                                         else if (g_strcmp0(state, "authenticating") == 0)
6173                                                 *wpa_status = WFD_OEM_WPA_STATE_AUTHENTICATING;
6174                                         else if (g_strcmp0(state, "associating") == 0)
6175                                                 *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATING;
6176                                         else if (g_strcmp0(state, "associated") == 0)
6177                                                 *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATED;
6178                                         else if (g_strcmp0(state, "4way_handshake") == 0)
6179                                                 *wpa_status = WFD_OEM_WPA_STATE_4WAY_HANDSHAKE;
6180                                         else if (g_strcmp0(state, "group_handshake") == 0)
6181                                                 *wpa_status = WFD_OEM_WPA_STATE_GROUP_HANDSHAKE;
6182                                         else if (g_strcmp0(state, "completed") == 0)
6183                                                 *wpa_status = WFD_OEM_WPA_STATE_COMPLETED;
6184                                         else
6185                                                 *wpa_status = WFD_OEM_WPA_STATE_MAX;
6186                                 }
6187                         }
6188                         g_variant_iter_free(iter);
6189                 }
6190                 g_variant_unref(reply);
6191         } else {
6192                 WDP_LOGD("No properties");
6193         }
6194
6195         WDP_LOGI("wpa_status : [%d]", *wpa_status);
6196
6197         __WDP_LOG_FUNC_EXIT__;
6198         return 0;
6199 }
6200
6201 #if defined(TIZEN_FEATURE_ASP)
6202 int ws_advertise_service(wfd_oem_asp_service_s *service, int replace)
6203 {
6204         __WDP_LOG_FUNC_ENTER__;
6205         GDBusConnection *g_dbus = NULL;
6206         GVariantBuilder *builder = NULL;
6207         GVariant *value = NULL;
6208         dbus_method_param_s params;
6209         unsigned int config_method = 0x1108;
6210         int auto_accept = 0;
6211         gboolean rep;
6212         int res = 0;
6213
6214         g_dbus = g_pd->g_dbus;
6215         if (!g_dbus) {
6216                 WDP_LOGE("DBus connection is NULL");
6217                 return -1;
6218         }
6219
6220         if (service->config_method == 2) {
6221                 config_method = WS_CONFIG_METHOD_KEYPAD |
6222                                 WS_CONFIG_METHOD_DISPLAY;
6223         } else if (service->config_method == 3) {
6224                 config_method = WS_CONFIG_METHOD_DISPLAY;
6225         } else if (service->config_method == 4) {
6226                 config_method = WS_CONFIG_METHOD_KEYPAD;
6227         }
6228
6229         if (service->auto_accept) {
6230                 if (service->role == 0)
6231                         auto_accept = 1;
6232                 else
6233                         auto_accept = 2;
6234         } else {
6235                 auto_accept = 0;
6236         }
6237
6238         rep = (replace == 1);
6239
6240         memset(&params, 0x0, sizeof(dbus_method_param_s));
6241
6242         dbus_set_method_param(&params, "AddService", g_pd->iface_path, g_dbus);
6243
6244         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
6245
6246         g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
6247         g_variant_builder_add(builder, "{sv}", "auto_accept", g_variant_new_int32(auto_accept));
6248         g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
6249         g_variant_builder_add(builder, "{sv}", "svc_state", g_variant_new_uint32(service->status));
6250         g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new_uint32(config_method));
6251         g_variant_builder_add(builder, "{sv}", "replace", g_variant_new_boolean(rep));
6252         if (service->service_type != NULL)
6253                 g_variant_builder_add(builder, "{sv}", "adv_str", g_variant_new_string(service->service_type));
6254         if (service->service_info != NULL)
6255                 g_variant_builder_add(builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
6256
6257         value = g_variant_new("(a{sv})", builder);
6258         g_variant_builder_unref(builder);
6259 #if defined(TIZEN_DEBUG_DBUS_VALUE)
6260         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
6261 #endif /* TIZEN_DEBUG_DBUS_VALUE */
6262
6263         params.params = value;
6264
6265         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
6266         if (res < 0)
6267                 WDP_LOGE("Failed to send command to wpa_supplicant");
6268         else
6269                 WDP_LOGD("Succeeded to add service");
6270
6271         __WDP_LOG_FUNC_EXIT__;
6272         return 0;
6273 }
6274
6275 int ws_cancel_advertise_service(wfd_oem_asp_service_s *service)
6276 {
6277         __WDP_LOG_FUNC_ENTER__;
6278         GDBusConnection *g_dbus = NULL;
6279         GVariantBuilder *builder = NULL;
6280         GVariant *value = NULL;
6281         dbus_method_param_s params;
6282         int res = 0;
6283
6284         g_dbus = g_pd->g_dbus;
6285         if (!g_dbus) {
6286                 WDP_LOGE("DBus connection is NULL");
6287                 return -1;
6288         }
6289         memset(&params, 0x0, sizeof(dbus_method_param_s));
6290
6291         dbus_set_method_param(&params, "DeleteService", g_pd->iface_path, g_dbus);
6292
6293         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
6294
6295         g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
6296         g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
6297
6298         value = g_variant_new("(a{sv})", builder);
6299         g_variant_builder_unref(builder);
6300 #if defined(TIZEN_DEBUG_DBUS_VALUE)
6301         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
6302 #endif /* TIZEN_DEBUG_DBUS_VALUE */
6303         params.params = value;
6304
6305         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
6306         if (res < 0)
6307                 WDP_LOGE("Failed to send command to wpa_supplicant");
6308         else
6309                 WDP_LOGD("Succeeded to del service");
6310
6311         __WDP_LOG_FUNC_EXIT__;
6312         return 0;
6313 }
6314
6315 static void __ws_add_seek(wfd_oem_asp_service_s *service)
6316 {
6317         __WDP_LOG_FUNC_ENTER__;
6318         wfd_oem_asp_service_s *seek = NULL;
6319         if (!service) {
6320                 WDP_LOGE("invalid parameters");
6321                 return;
6322         }
6323
6324         seek = g_try_malloc0(sizeof(wfd_oem_asp_service_s));
6325         if (!seek) {
6326                 WDP_LOGE("Failed to allocate memory for service");
6327                 return;
6328         }
6329
6330         service->search_id = (intptr_t)seek;
6331         memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
6332         if (service->service_type)
6333                 seek->service_type = strdup(service->service_type);
6334         seek_list = g_list_prepend(seek_list, seek);
6335
6336         __WDP_LOG_FUNC_EXIT__;
6337         return;
6338 }
6339
6340 static wfd_oem_asp_service_s * __ws_get_seek(long long unsigned search_id)
6341 {
6342         __WDP_LOG_FUNC_ENTER__;
6343         wfd_oem_asp_service_s *seek = NULL;
6344         GList *list = NULL;
6345
6346         for (list = seek_list; list != NULL; list = list->next) {
6347                 seek = list->data;
6348                 if (seek && (seek->search_id == search_id)) {
6349                         WDP_LOGD("List found");
6350                         break;
6351                 } else {
6352                         seek = NULL;
6353                 }
6354         }
6355         __WDP_LOG_FUNC_EXIT__;
6356         return seek;
6357 }
6358
6359 static void __ws_remove_seek(wfd_oem_asp_service_s *service)
6360 {
6361         __WDP_LOG_FUNC_ENTER__;
6362         wfd_oem_asp_service_s *seek = NULL;
6363         GList *list = NULL;
6364
6365         for (list = seek_list; list != NULL; list = list->next) {
6366
6367                 seek = list->data;
6368                 if (seek && (seek->search_id == service->search_id)) {
6369                         WDP_LOGD("List remove");
6370                         seek_list = g_list_remove(seek_list, seek);
6371                         g_free(seek->service_type);
6372                         g_free(seek->service_info);
6373                         g_free(seek);
6374                 }
6375         }
6376         __WDP_LOG_FUNC_EXIT__;
6377         return;
6378 }
6379
6380 static void __get_asp_search_id(GVariant *value, void *args)
6381 {
6382         __WDP_LOG_FUNC_ENTER__;
6383         wfd_oem_asp_service_s *service = NULL;
6384         wfd_oem_asp_service_s *seek = NULL;
6385         long long unsigned search_id = 0;
6386
6387         g_variant_get(value, "(t)", &search_id);
6388
6389         service = (wfd_oem_asp_service_s *)args;
6390         if (!service) {
6391                 WDP_LOGE("invalid parameters");
6392                 __WDP_LOG_FUNC_EXIT__;
6393                 return;
6394         }
6395
6396         seek = g_try_malloc0(sizeof(wfd_oem_asp_service_s));
6397         if (!seek) {
6398                 WDP_LOGE("Failed to allocate memory for service");
6399                 __WDP_LOG_FUNC_EXIT__;
6400                 return;
6401         }
6402
6403         service->search_id = search_id;
6404         memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
6405         if (service->service_type)
6406                 seek->service_type = strdup(service->service_type);
6407         if (service->service_info)
6408                 seek->service_info = strdup(service->service_info);
6409         seek_list = g_list_append(seek_list, seek);
6410
6411         __WDP_LOG_FUNC_EXIT__;
6412         return;
6413 }
6414
6415 int ws_seek_service(wfd_oem_asp_service_s *service)
6416 {
6417         __WDP_LOG_FUNC_ENTER__;
6418         GDBusConnection *g_dbus = NULL;
6419         GList *list = NULL;
6420         wfd_oem_asp_service_s *seek = NULL;
6421         int res = 0;
6422
6423         g_dbus = g_pd->g_dbus;
6424         if (!g_dbus) {
6425                 WDP_LOGE("DBus connection is NULL");
6426                 __WDP_LOG_FUNC_EXIT__;
6427                 return -1;
6428         }
6429         list = g_list_last(seek_list);
6430         if (list == NULL) {
6431                 service->tran_id = 1;
6432
6433         } else {
6434                 seek = list->data;
6435                 if (seek)
6436                         service->tran_id = seek->tran_id + 1;
6437                 else
6438                         service->tran_id = 1;
6439         }
6440
6441         if (service->service_info) {
6442                 GVariantBuilder *builder = NULL;
6443                 GVariant *value = NULL;
6444                 dbus_method_param_s params;
6445
6446                 memset(&params, 0x0, sizeof(dbus_method_param_s));
6447                 dbus_set_method_param(&params, "ServiceDiscoveryRequest",
6448                                 g_pd->iface_path, g_dbus);
6449
6450                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
6451
6452                 g_variant_builder_add(builder, "{sv}", "service_type",
6453                                 g_variant_new_string("asp"));
6454                 g_variant_builder_add(builder, "{sv}", "transaction_id",
6455                                 g_variant_new_byte(service->tran_id));
6456                 if (service->service_type != NULL)
6457                         g_variant_builder_add(builder, "{sv}", "svc_str",
6458                                         g_variant_new_string(service->service_type));
6459
6460                 if (service->service_info != NULL)
6461                         g_variant_builder_add(builder, "{sv}", "svc_info",
6462                                         g_variant_new_string(service->service_info));
6463
6464                 value = g_variant_new("(a{sv})", builder);
6465                 g_variant_builder_unref(builder);
6466
6467 #if defined(TIZEN_DEBUG_DBUS_VALUE)
6468                 WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
6469 #endif /* TIZEN_DEBUG_DBUS_VALUE */
6470
6471                 params.params = value;
6472                 res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE,
6473                                 __get_asp_search_id, service);
6474
6475         } else {
6476                 __ws_add_seek(service);
6477         }
6478
6479         if (res < 0)
6480                 WDP_LOGE("Failed to send command to wpa_supplicant");
6481         else
6482                 WDP_LOGD("Succeeded to seek service");
6483
6484         __WDP_LOG_FUNC_EXIT__;
6485         return res;
6486 }
6487
6488 int ws_cancel_seek_service(wfd_oem_asp_service_s *service)
6489 {
6490         __WDP_LOG_FUNC_ENTER__;
6491         GDBusConnection *g_dbus = NULL;
6492         wfd_oem_asp_service_s *seek = NULL;
6493         dbus_method_param_s params;
6494         int res = 0;
6495
6496         g_dbus = g_pd->g_dbus;
6497         if (!g_dbus) {
6498                 WDP_LOGE("DBus connection is NULL");
6499                 __WDP_LOG_FUNC_EXIT__;
6500                 return -1;
6501         }
6502
6503         seek = __ws_get_seek(service->search_id);
6504         if (!seek) {
6505                 WDP_LOGE("seek data is NULL");
6506                 __WDP_LOG_FUNC_EXIT__;
6507                 return -1;
6508         }
6509
6510         if (seek->service_info) {
6511
6512                 memset(&params, 0x0, sizeof(dbus_method_param_s));
6513                 dbus_set_method_param(&params, "ServiceDiscoveryCancelRequest",
6514                                 g_pd->iface_path, g_dbus);
6515
6516                 params.params = g_variant_new("(t)", service->search_id);
6517
6518 #if defined(TIZEN_DEBUG_DBUS_VALUE)
6519                 WDP_LOGD("params [%s]", g_variant_print(params.params, TRUE));
6520 #endif /* TIZEN_DEBUG_DBUS_VALUE */
6521
6522                 res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
6523                 if (res < 0)
6524                         WDP_LOGE("Failed to send command to wpa_supplicant");
6525                 else
6526                         WDP_LOGD("Succeeded to cancel seek service");
6527         }
6528         if (res == 0)
6529                 __ws_remove_seek(seek);
6530
6531         __WDP_LOG_FUNC_EXIT__;
6532         return res;
6533 }
6534
6535 int ws_asp_prov_disc_req(wfd_oem_asp_prov_s *asp_params)
6536 {
6537         __WDP_LOG_FUNC_ENTER__;
6538         GDBusConnection *g_dbus = NULL;
6539         GVariantBuilder *builder = NULL;
6540         GVariantBuilder *mac_builder = NULL;
6541         GVariant *value = NULL;
6542         dbus_method_param_s params;
6543         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
6544         int config_method = 0x1000;
6545         int res = 0;
6546         int i = 0;
6547
6548         if (!asp_params) {
6549                 WDP_LOGE("Invalid parameter");
6550                 __WDP_LOG_FUNC_EXIT__;
6551                 return -1;
6552         }
6553         g_dbus = g_pd->g_dbus;
6554         if (!g_dbus) {
6555                 WDP_LOGE("DBus connection is NULL");
6556                 __WDP_LOG_FUNC_EXIT__;
6557                 return -1;
6558         }
6559
6560         if (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_DISPLAY)
6561                 config_method = 0x8;
6562         else if (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_KEYPAD)
6563                 config_method = 0x100;
6564
6565         memset(&params, 0x0, sizeof(dbus_method_param_s));
6566
6567         dbus_set_method_param(&params, "ASPProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
6568
6569         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
6570                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(asp_params->service_mac));
6571         WDP_LOGD("get peer path [%s]", peer_path);
6572
6573         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
6574         g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
6575
6576         g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(asp_params->adv_id));
6577         g_variant_builder_add(builder, "{sv}", "session_id", g_variant_new_uint32(asp_params->session_id));
6578         g_variant_builder_add(builder, "{sv}", "role", g_variant_new_byte(asp_params->network_role));
6579         g_variant_builder_add(builder, "{sv}", "method", g_variant_new_int32(config_method));
6580         if (asp_params->status > 0)
6581                 g_variant_builder_add(builder, "{sv}", "status", g_variant_new_int32(asp_params->status));
6582         if (asp_params->session_information)
6583                 g_variant_builder_add(builder, "{sv}", "info", g_variant_new_string(asp_params->session_information));
6584
6585         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
6586         for (i = 0; i < OEM_MACADDR_LEN; i++)
6587                 g_variant_builder_add(mac_builder, "y", asp_params->service_mac[i]);
6588         g_variant_builder_add(builder, "{sv}", "adv_mac",
6589                         g_variant_new("ay", mac_builder));
6590         g_variant_builder_unref(mac_builder);
6591
6592         mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
6593         for (i = 0; i < OEM_MACADDR_LEN; i++)
6594                 g_variant_builder_add(mac_builder, "y", asp_params->session_mac[i]);
6595         g_variant_builder_add(builder, "{sv}", "session_mac",
6596                         g_variant_new("ay", mac_builder));
6597         g_variant_builder_unref(mac_builder);
6598
6599         value = g_variant_new("(a{sv})", builder);
6600         g_variant_builder_unref(builder);
6601 #if defined(TIZEN_DEBUG_DBUS_VALUE)
6602         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
6603 #endif /* TIZEN_DEBUG_DBUS_VALUE */
6604
6605         params.params = value;
6606
6607         res = dbus_method_call(&params, SUPPLICANT_P2PDEVICE, NULL, NULL);
6608         if (res < 0)
6609                 WDP_LOGE("Failed to send command to wpa_supplicant");
6610         else
6611                 WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(asp_params->service_mac));
6612
6613         __WDP_LOG_FUNC_EXIT__;
6614         return res;
6615 }
6616 #endif /* TIZEN_FEATURE_ASP */