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

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