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