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

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