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