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 "wifi-direct-oem.h"
  47 #include "wfd-plugin-log.h"
  48 #include "wfd-plugin-wpasupplicant.h"
  49 #include "dbus/wfd-plugin-supplicant-dbus.h"
  50
  51 #define NETCONFIG_SERVICE "net.netconfig"
  52 #define NETCONFIG_WIFI_INTERFACE "net.netconfig.wifi"
  53 #define NETCONFIG_WIFI_PATH "/net/netconfig/wifi"
  54
  55 #define NETCONFIG_DBUS_REPLY_TIMEOUT (10 * 1000)
  56
  57 static wfd_oem_ops_s supplicant_ops = {
  58         .init = ws_init,
  59         .deinit = ws_deinit,
  60         .activate = ws_activate,
  61         .deactivate = ws_deactivate,
  62
  63         .start_scan = ws_start_scan,
  64         .stop_scan = ws_stop_scan,
  65         .get_visibility = ws_get_visibility,
  66         .set_visibility = ws_set_visibility,
  67         .get_scan_result = ws_get_scan_result,
  68         .get_peer_info = ws_get_peer_info,
  69
  70         .prov_disc_req = ws_prov_disc_req,
  71
  72         .connect = ws_connect,
  73         .disconnect = ws_disconnect,
  74         .reject_connection = ws_reject_connection,
  75         .cancel_connection = ws_cancel_connection,
  76
  77         .get_connected_peers = ws_get_connected_peers,
  78         .get_pin = ws_get_pin,
  79         .set_pin = ws_set_pin,
  80         .get_supported_wps_mode = ws_get_supported_wps_mode,
  81
  82         .create_group = ws_create_group,
  83         .destroy_group = ws_destroy_group,
  84         .invite = ws_invite,
  85         .wps_start = ws_wps_start,
  86         .enrollee_start = ws_enrollee_start,
  87         .wps_cancel = ws_wps_cancel,
  88
  89         .get_dev_name = ws_get_dev_name,
  90         .set_dev_name = ws_set_dev_name,
  91         .get_dev_mac = ws_get_dev_mac,
  92         .get_dev_type = ws_get_dev_type,
  93         .set_dev_type = ws_set_dev_type,
  94         .get_go_intent = ws_get_go_intent,
  95         .set_go_intent = ws_set_go_intent,
  96         .set_country = ws_set_country,
  97         .get_persistent_groups = ws_get_persistent_groups,
  98         .remove_persistent_group = ws_remove_persistent_group,
  99         .set_persistent_reconnect = ws_set_persistent_reconnect,
 100
 101 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 102         .start_service_discovery = ws_start_service_discovery,
 103         .cancel_service_discovery = ws_cancel_service_discovery,
 104
 105         .serv_add = ws_serv_add,
 106         .serv_del = ws_serv_del,
 107 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 108
 109 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 110         .miracast_init = ws_miracast_init,
 111         .set_display = ws_set_display,
 112 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 113
 114         .refresh = ws_refresh,
 115
 116         };
 117
 118 static ws_dbus_plugin_data_s *g_pd;
 119
 120 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 121 static GList *service_list;
 122 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 123
 124 static void _supplicant_signal_cb(GDBusConnection *connection,
 125                 const gchar *sender, const gchar *object_path, const gchar *interface,
 126                 const gchar *signal, GVariant *parameters, gpointer user_data);
 127
 128 static void _p2pdevice_signal_cb(GDBusConnection *connection,
 129                 const gchar *sender, const gchar *object_path, const gchar *interface,
 130                 const gchar *signal, GVariant *parameters, gpointer user_data);
 131
 132 static void _group_signal_cb(GDBusConnection *connection,
 133                 const gchar *sender, const gchar *object_path, const gchar *interface,
 134                 const gchar *signal, GVariant *parameters, gpointer user_data);
 135
 136 static int __ws_txt_to_mac(unsigned char *txt, unsigned char *mac)
 137 {
 138         int i = 0;
 139
 140         if (!txt || !mac) {
 141                 WDP_LOGE("Invalid parameter");
 142                 return -1;
 143         }
 144
 145         for (;;) {
 146                 mac[i++] = (char) strtoul((char *)txt, (char **)&txt, 16);
 147                 if (!*txt++ || i == 6)
 148                         break;
 149         }
 150
 151         if (i != WS_MACADDR_LEN)
 152                 return -1;
 153
 154         return 0;
 155 }
 156
 157 static int __ws_mac_compact_to_normal(char *compact, unsigned char *mac)
 158 {
 159         g_snprintf((char *)mac, OEM_MACSTR_LEN, "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
 160                         compact[0], compact[1], compact[2], compact[3],
 161                         compact[4], compact[5], compact[6], compact[7],
 162                         compact[8], compact[9], compact[10], compact[11]);
 163         return 0;
 164 }
 165
 166 static char *__ws_wps_to_txt(int wps_mode)
 167 {
 168         switch (wps_mode) {
 169         case WFD_OEM_WPS_MODE_PBC:
 170                 return WS_DBUS_STR_PBC;
 171                 break;
 172         case WFD_OEM_WPS_MODE_DISPLAY:
 173                 return WS_DBUS_STR_DISPLAY;
 174                 break;
 175         case WFD_OEM_WPS_MODE_KEYPAD:
 176                 return WS_DBUS_STR_KEYPAD;
 177                 break;
 178         default:
 179                 return "";
 180                 break;
 181         }
 182 }
 183 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 184 static int __ws_byte_to_hex(char *buf, int buf_size, unsigned char *data, int data_len)
 185 {
 186         int i;
 187         char *pos = buf;
 188         char *end = buf + buf_size;
 189         int ret;
 190         if (buf_size == 0)
 191                 return 0;
 192         for (i = 0; i < data_len; i++) {
 193                 ret = snprintf(pos, end - pos, "%02x", data[i]);
 194                 if (ret < 0 || ret >= end - pos) {
 195                         end[-1] = '\0';
 196                         return pos - buf;
 197                 }
 198                 pos += ret;
 199         }
 200         end[-1] = '\0';
 201         return pos - buf;
 202 }
 203
 204 static int __ws_hex_to_num(char *src, int len)
 205 {
 206         char *temp = NULL;
 207         int num = 0;
 208
 209         if (!src || len < 0) {
 210                 WDP_LOGE("Invalid parameter");
 211                 return -1;
 212         }
 213
 214         temp = (char*) g_try_malloc0(len+1);
 215         if (!temp) {
 216                 WDP_LOGE("Failed to allocate memory");
 217                 return -1;
 218         }
 219
 220         memcpy(temp, src, len);
 221         num = strtoul(temp, NULL, 16);
 222         g_free(temp);
 223
 224         return num;
 225 }
 226
 227 static int __ws_hex_to_txt(char *src, int length, char *dest)
 228 {
 229         // TODO: check it is good to change dest parameter as double pointer.
 230         // It could be better to allocate memory for dest parameter here.
 231         char *temp = NULL;
 232         char *ptr = NULL;
 233         int len = 0;
 234         int i = 0;
 235
 236         if (!src || length < 0 || !dest) {
 237                 WDP_LOGE("Invalid parameter");
 238                 return -1;
 239         }
 240
 241         // TODO: flush destination memory
 242
 243         ptr = src;
 244         temp = dest;
 245
 246         if (!length)
 247                 len = strlen(src);
 248         else
 249                 len = length;
 250
 251         for (i=0; i<len/2 && *ptr!=0; i++) {
 252                 temp[i] = (char) __ws_hex_to_num(ptr, 2);
 253                 if (temp[i] < 0) {
 254                         WDP_LOGE("Failed to convert hexa string to num");
 255                         return -1;
 256                 }
 257                 ptr += 2;
 258         }
 259
 260         return 0;
 261 }
 262
 263 gboolean _ws_util_execute_file(const char *file_path,
 264         char *const args[], char *const envs[])
 265 {
 266         pid_t pid = 0;
 267         int rv = 0;
 268         errno = 0;
 269         register unsigned int index = 0;
 270
 271         while (args[index] != NULL) {
 272                 WDP_LOGD("[%s]", args[index]);
 273                 index++;
 274         }
 275
 276         if (!(pid = fork())) {
 277                 WDP_LOGD("pid(%d), ppid(%d)", getpid(), getppid());
 278                 WDP_LOGD("Inside child, exec (%s) command", file_path);
 279
 280                 errno = 0;
 281                 if (execve(file_path, args, envs) == -1) {
 282                         WDP_LOGE("Fail to execute command (%s)", strerror(errno));
 283                         exit(1);
 284                 }
 285         } else if (pid > 0) {
 286                 if (waitpid(pid, &rv, 0) == -1)
 287                         WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
 288                 if (WIFEXITED(rv)) {
 289                         WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
 290                 } else if (WIFSIGNALED(rv)) {
 291                         WDP_LOGD("killed by signal %d", WTERMSIG(rv));
 292                 } else if (WIFSTOPPED(rv)) {
 293                         WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
 294                 } else if (WIFCONTINUED(rv)) {
 295                         WDP_LOGD("continued");
 296                 }
 297
 298                 return TRUE;
 299         }
 300
 301         WDP_LOGE("failed to fork (%s)", strerror(errno));
 302         return FALSE;
 303 }
 304
 305 static int __ws_segment_to_service(char *segment, wfd_oem_new_service_s **service)
 306 {
 307         wfd_oem_new_service_s *serv_tmp = NULL;
 308         char *ptr = NULL;
 309         char *temp = NULL;
 310         int len = 0;
 311         int i = 0;
 312
 313         if (!segment || !service) {
 314                 WDP_LOGE("Invalid parameter");
 315                 return -1;
 316         }
 317
 318         ptr = segment;
 319         WDP_LOGD("Segment: %s", segment);
 320
 321         serv_tmp = (wfd_oem_new_service_s*) calloc(1, sizeof(wfd_oem_new_service_s));
 322         if (!serv_tmp) {
 323                 WDP_LOGE("Failed to allocate memory for service");
 324                 return -1;
 325         }
 326
 327         serv_tmp->protocol = __ws_hex_to_num(ptr, 2);
 328         serv_tmp->trans_id = __ws_hex_to_num(ptr+2, 2);
 329         serv_tmp->status = __ws_hex_to_num(ptr+4, 2);
 330         ptr += 6;
 331         WDP_LOGD("Protocol[%d], Transaction ID[%d], Status[%d]", serv_tmp->protocol, serv_tmp->trans_id, serv_tmp->status);
 332
 333         if (serv_tmp->status != 0) {
 334                 WDP_LOGE("Service status is not success");
 335                 free(serv_tmp);
 336                 return -1;
 337         }
 338
 339         if (serv_tmp->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
 340                 WDP_LOGD("===== Bonjour service =====");
 341                 char compr[5] = {0, };
 342                 char query[256] = {0, };
 343                 char rdata[256] = {0, };
 344                 int dns_type = 0;
 345
 346                 while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
 347                         len = __ws_hex_to_num(ptr, 2);
 348                         ptr +=2;
 349                         if (len) {
 350                                 temp = (char*) calloc(1, len+2);
 351                                 temp[0] = '.';
 352                                 for (i=0; i<len; i++) {
 353                                         temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
 354                                         ptr += 2;
 355                                 }
 356                                 strncat(query, temp, len+1);
 357                                 free(temp);
 358                                 temp = NULL;
 359                         }
 360                 }
 361
 362                 if (!strncmp(ptr, "c0", 2)) {
 363                         memcpy(compr, ptr, 4);
 364                         ptr += 2;
 365
 366                         if (!strncmp(ptr, "27", 2)) {
 367                                 WDP_LOGD("Segment ended");
 368                                 ptr += 2;
 369                         } else {
 370                                 ptr += 2;
 371                                 dns_type = __ws_hex_to_num(ptr, 4);
 372                                 ptr += 6;
 373                                 if (dns_type == 12) {
 374                                         if (!strncmp(compr, "c011", 4))
 375                                                 strncat(query, ".local.", 7);
 376                                         else if (!strncmp(compr, "c00c", 4))
 377                                                 strncat(query, "._tcp.local.", 12);
 378                                         else if (!strncmp(compr, "c01c", 4))
 379                                                 strncat(query, "._udp.local.", 12);
 380                                 }
 381                         }
 382                 }
 383                 serv_tmp->data.bonjour.query = strdup(query + 1);
 384                 while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
 385                         len = __ws_hex_to_num(ptr, 2);
 386                         ptr += 2;
 387                         if (len) {
 388                                 temp = (char*) calloc(1, len+2);
 389                                 temp[0] = '.';
 390                                 for (i=0; i<len; i++) {
 391                                         temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
 392                                         ptr += 2;
 393                                 }
 394                                 strncat(rdata, temp, len+1);
 395                                 free(temp);
 396                                 temp = NULL;
 397                         }
 398                 }
 399                 serv_tmp->data.bonjour.rdata = strdup(rdata + 1);
 400
 401                 WDP_LOGD("Query: %s", serv_tmp->data.bonjour.query);
 402                 WDP_LOGD("RData: %s", serv_tmp->data.bonjour.rdata);
 403         } else if (serv_tmp->protocol == WFD_OEM_SERVICE_TYPE_VENDOR) {
 404                 WDP_LOGD("===== Vendor specific service =====");
 405                 if (!strncmp(ptr, "0000f00b", 8)) {
 406                         WDP_LOGD("\tSAMSUNG_BT_ADDR");
 407                         ptr += 16;
 408                         serv_tmp->protocol = WFD_OEM_SERVICE_TYPE_BT_ADDR;
 409                         serv_tmp->data.vendor.data1 = (char*) calloc(1, 9);
 410                         g_strlcpy(serv_tmp->data.vendor.data1, "0000f00b", 9);
 411                         serv_tmp->data.vendor.data2 = (char*) calloc(1, 18);
 412                         __ws_hex_to_txt(ptr, 0, serv_tmp->data.vendor.data2);
 413                 }
 414                 WDP_LOGD("Info1: %s", serv_tmp->data.vendor.data1);
 415                 WDP_LOGD("Info2: %s", serv_tmp->data.vendor.data2);
 416         } else {
 417                 WDP_LOGE("Not supported yet. Only bonjour and samsung vendor service supproted [%d]",
 418                                         serv_tmp->protocol);
 419                 free(serv_tmp);
 420                 return -1;
 421         }
 422
 423         *service = serv_tmp;
 424
 425         return 0;
 426 }
 427 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 428
 429 static void __ws_path_to_addr(char *peer_path,
 430                 unsigned char *dev_addr, GVariant *parameter)
 431 {
 432         __WDP_LOG_FUNC_ENTER__;
 433
 434         static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
 435         const char *path = NULL;
 436         char *loc = NULL;
 437
 438         g_variant_get(parameter, "(o)", &path);
 439         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
 440         WDP_LOGE("Retrive Added path [%s]", peer_path);
 441
 442         loc = strrchr(peer_path,'/');
 443         __ws_mac_compact_to_normal(loc + 1, peer_dev);
 444
 445         __ws_txt_to_mac(peer_dev, dev_addr);
 446         WDP_LOGE("peer mac [" MACSTR "]", MAC2STR(dev_addr));
 447
 448         return;
 449         __WDP_LOG_FUNC_EXIT__;
 450 }
 451
 452 static int __ws_unpack_ay(unsigned char *dst, GVariant *src, int size)
 453 {
 454         GVariantIter *iter = NULL;
 455         int length = 0;
 456         int res = 1;
 457
 458         if (!dst || !src || size == 0) {
 459                 WDP_LOGE("Invalid parameter");
 460                 return -1;
 461         }
 462         g_variant_get(src, "ay", &iter);
 463         if (iter == NULL) {
 464                 WDP_LOGE("failed to get iterator");
 465                 return -1;
 466         }
 467
 468         while (g_variant_iter_loop (iter, "y", &dst[length])) {
 469                 length++;
 470                 if(length >= size)
 471                         break;
 472         }
 473         g_variant_iter_free(iter);
 474
 475         if (length < size) {
 476                 WDP_LOGE("array is shorter than size");
 477                 res = -1;
 478         }
 479
 480         return res;
 481 }
 482
 483 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 484 static int __parsing_wfd_info(unsigned char *wfd_dev_info,
 485                 wfd_oem_display_s *display )
 486 {
 487         __WDP_LOG_FUNC_ENTER__;
 488
 489         int wfd_info = 0;
 490         if (!wfd_dev_info || !display) {
 491                 WDP_LOGE("Invalid parameter");
 492                 __WDP_LOG_FUNC_EXIT__;
 493                 return -1;
 494         }
 495
 496         wfd_info = (wfd_dev_info[3]<<8 | wfd_dev_info[4]);
 497
 498         if (wfd_info & WS_WFD_INFO_PRIMARY_SINK)
 499                 display->type |= WS_WFD_INFO_PRIMARY_SINK;
 500         if (wfd_info & WS_WFD_INFO_SECONDARY_SINK)
 501                 display->type |= WS_WFD_INFO_SECONDARY_SINK;
 502
 503         display->availablity = (wfd_info & WS_WFD_INFO_AVAILABLITY) >> 4;
 504         display->hdcp_support = (wfd_info & WS_WFD_INFO_HDCP_SUPPORT) >> 8;
 505
 506         display->port = (wfd_dev_info[5]<<8 | wfd_dev_info[6]);
 507         display->max_tput = (wfd_dev_info[7]<<8 | wfd_dev_info[8]);
 508
 509         WDP_LOGD("type [%d],availablity [%d],hdcp_support [%d],ctrl_port [%d] "
 510                         "max_tput[%d]", display->type, display->availablity,
 511                         display->hdcp_support, display->port,display->max_tput);
 512
 513         __WDP_LOG_FUNC_EXIT__;
 514         return 0;
 515 }
 516 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 517
 518 static void _supplicant_signal_cb(GDBusConnection *connection,
 519                 const gchar *sender, const gchar *object_path, const gchar *interface,
 520                 const gchar *signal, GVariant *parameters, gpointer user_data)
 521 {
 522         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
 523
 524         if (!g_strcmp0(signal,"InterfaceAdded")) {
 525                 WDP_LOGD("InterfaceAdded");
 526                 static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 527                 const char *path = NULL;
 528                 GVariantIter *iter = NULL;
 529                 const char *ifname = NULL;
 530
 531                 g_variant_get(parameters, "(oa{sv})", &path, &iter);
 532
 533                 g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
 534                 WDP_LOGD("Retrive Added path [%s]", interface_path);
 535
 536                 if (iter != NULL) {
 537                         gchar *key = NULL;
 538                         GVariant *value = NULL;
 539
 540                         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
 541                                 CHECK_KEY_VALUE(key, value);
 542
 543                                 if (!g_strcmp0(key,"Ifname")) {
 544                                         g_variant_get(value, "s", &ifname);
 545                                         WDP_LOGD("Retrive added interface [%s]", ifname);
 546                                         if(!g_strcmp0(ifname, GROUP_IFACE_NAME))
 547                                                 g_strlcpy(g_pd->group_iface_path, path, DBUS_OBJECT_PATH_MAX);
 548                                 }
 549                         }
 550                         g_variant_iter_free(iter);
 551                 }
 552
 553         } else if (!g_strcmp0(signal,"InterfaceRemoved")) {
 554                 WDP_LOGE("InterfaceRemoved");
 555                 static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 556                 const char *path = NULL;
 557
 558                 g_variant_get(parameters, "(o)", &path);
 559                 g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
 560
 561                 WDP_LOGD("Retrive removed path [%s]", interface_path);
 562                 if (!g_strcmp0(g_pd->group_iface_path, interface_path))
 563                         memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
 564
 565         } else if(!g_strcmp0(signal,"PropertiesChanged")){
 566                 WDP_LOGD("PropertiesChanged");
 567         }
 568 }
 569
 570 static void __ws_get_peer_property(const char *key, GVariant *value, void *user_data)
 571 {
 572         __WDP_LOG_FUNC_ENTER__;
 573
 574         wfd_oem_device_s *peer = (wfd_oem_device_s *)user_data;
 575         if(!peer) {
 576                 __WDP_LOG_FUNC_EXIT__;
 577                 return;
 578         }
 579         CHECK_KEY_VALUE(key, value);
 580
 581         if (g_strcmp0(key, "DeviceName") == 0) {
 582                 const char *name = NULL;
 583
 584                 g_variant_get(value, "s", &name);
 585                 g_strlcpy(peer->dev_name, name, WS_SSID_LEN);
 586                 WDP_LOGD("[%s]", peer->dev_name);
 587
 588         } else if (g_strcmp0(key, "config_method") == 0) {
 589                 int config_methods = 0;
 590                 g_variant_get(value, "q", &config_methods);
 591
 592                 if (config_methods & WS_CONFIG_METHOD_DISPLAY)
 593                         peer->config_methods |= WFD_OEM_WPS_MODE_DISPLAY;
 594                 if (config_methods & WS_CONFIG_METHOD_PUSHBUTTON)
 595                         peer->config_methods |= WFD_OEM_WPS_MODE_PBC;
 596                 if (config_methods & WS_CONFIG_METHOD_KEYPAD)
 597                         peer->config_methods |= WFD_OEM_WPS_MODE_KEYPAD;
 598                 WDP_LOGD("[0x%x]", peer->config_methods);
 599
 600         } else if (g_strcmp0(key, "level") == 0) {
 601
 602         } else if (g_strcmp0(key, "devicecapability") == 0) {
 603                 unsigned char devicecapability = 0;
 604
 605                 g_variant_get(value, "y", &devicecapability);
 606                 peer->dev_flags = (int)devicecapability;
 607                 WDP_LOGD("[0x%02x]", peer->dev_flags);
 608
 609         } else if (g_strcmp0(key, "groupcapability") == 0) {
 610                 unsigned char groupcapability = 0;
 611
 612                 g_variant_get(value, "y", &groupcapability);
 613                 WDP_LOGD("[0x%02x]", groupcapability);
 614                 if (groupcapability & WS_GROUP_CAP_GROUP_OWNER) {
 615                         peer->group_flags = WFD_OEM_GROUP_FLAG_GROUP_OWNER;
 616                         peer->dev_role = WFD_OEM_DEV_ROLE_GO;
 617                 }
 618                 if (groupcapability & WS_GROUP_CAP_PERSISTENT_GROUP)
 619                         peer->group_flags = WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
 620
 621         } else if (g_strcmp0(key, "PrimaryDeviceType") == 0) {
 622                 unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
 623
 624                 if(__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
 625                         peer->pri_dev_type = primarydevicetype[1];
 626                         peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
 627                 }
 628         } else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
 629         } else if (g_strcmp0(key, "VendorExtension") == 0) {
 630 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 631         } else if (g_strcmp0(key, "IEs") == 0) {
 632                 unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
 633
 634                 if(__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
 635                         __parsing_wfd_info(ies, &(peer->display));
 636 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 637         } else if (g_strcmp0(key, "DeviceAddress") == 0) {
 638
 639                 if (__ws_unpack_ay(peer->dev_addr, value, WS_MACADDR_LEN))
 640                         WDP_LOGD("[" MACSTR "]", MAC2STR(peer->dev_addr));
 641
 642         } else if (g_strcmp0(key, "InterfacedAddress") == 0) {
 643
 644                 if (__ws_unpack_ay(peer->intf_addr, value, WS_MACADDR_LEN))
 645                         WDP_LOGE("[" MACSTR "]", MAC2STR(peer->intf_addr));
 646
 647         }  else {
 648                 WDP_LOGE("Unknown value");
 649         }
 650         __WDP_LOG_FUNC_EXIT__;
 651 }
 652
 653 static void __ws_peer_property(const char *key, GVariant *value, void *user_data)
 654 {
 655         __WDP_LOG_FUNC_ENTER__;
 656         if(!user_data) {
 657                 __WDP_LOG_FUNC_EXIT__;
 658                 return;
 659         }
 660
 661         wfd_oem_dev_data_s *peer = (wfd_oem_dev_data_s *)user_data;
 662
 663         CHECK_KEY_VALUE(key, value);
 664
 665         if (g_strcmp0(key, "DeviceName") == 0) {
 666                 const char *name = NULL;
 667
 668                 g_variant_get(value, "s", &name);
 669                 g_strlcpy(peer->name, name, WS_SSID_LEN);
 670                 WDP_LOGD("[%s]", peer->name);
 671
 672         } else if (g_strcmp0(key, "config_method") == 0) {
 673                 int config_methods = 0;
 674
 675                 g_variant_get(value, "q", &config_methods);
 676
 677                 if (config_methods & WS_CONFIG_METHOD_DISPLAY)
 678                         peer->config_methods |= WFD_OEM_WPS_MODE_DISPLAY;
 679                 if (config_methods & WS_CONFIG_METHOD_PUSHBUTTON)
 680                         peer->config_methods |= WFD_OEM_WPS_MODE_PBC;
 681                 if (config_methods & WS_CONFIG_METHOD_KEYPAD)
 682                         peer->config_methods |= WFD_OEM_WPS_MODE_KEYPAD;
 683                 WDP_LOGD("[0x%x]", peer->config_methods);
 684
 685         } else if (g_strcmp0(key, "level") == 0) {
 686
 687         } else if (g_strcmp0(key, "devicecapability") == 0) {
 688                 unsigned char devicecapability = 0;
 689
 690                 g_variant_get(value, "y", &devicecapability);
 691                 peer->dev_flags = (int)devicecapability;
 692                 WDP_LOGD("[0x%02x]", peer->dev_flags);
 693
 694         } else if (g_strcmp0(key, "groupcapability") == 0) {
 695                 unsigned char groupcapability = 0;
 696
 697                 g_variant_get(value, "y", &groupcapability);
 698                 WDP_LOGD("[0x%02x]", groupcapability);
 699                 if (groupcapability & WS_GROUP_CAP_GROUP_OWNER) {
 700                         peer->group_flags = WFD_OEM_GROUP_FLAG_GROUP_OWNER;
 701                         peer->dev_role = WFD_OEM_DEV_ROLE_GO;
 702                 }
 703                 if (groupcapability & WS_GROUP_CAP_PERSISTENT_GROUP)
 704                         peer->group_flags = WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
 705
 706         } else if (g_strcmp0(key, "PrimaryDeviceType") == 0) {
 707                 unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
 708
 709                 if (__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
 710                         peer->pri_dev_type = primarydevicetype[1];
 711                         peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
 712                 }
 713         } else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
 714         } else if (g_strcmp0(key, "VendorExtension") == 0) {
 715 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 716         } else if (g_strcmp0(key, "IEs") == 0) {
 717                 unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
 718
 719                 if(__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
 720                         __parsing_wfd_info(ies, &(peer->display));
 721 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 722         } else if (g_strcmp0(key, "DeviceAddress") == 0) {
 723
 724                 if (__ws_unpack_ay(peer->p2p_dev_addr, value, WS_MACADDR_LEN))
 725                         WDP_LOGE("[" MACSTR "]", MAC2STR(peer->p2p_dev_addr));
 726
 727         } else if (g_strcmp0(key, "InterfacedAddress") == 0) {
 728
 729                 if (__ws_unpack_ay(peer->p2p_intf_addr, value, WS_MACADDR_LEN))
 730                         WDP_LOGE("[" MACSTR "]", MAC2STR(peer->p2p_intf_addr));
 731
 732         }  else {
 733                 WDP_LOGE("Unknown value");
 734         }
 735         __WDP_LOG_FUNC_EXIT__;
 736 }
 737
 738 void __ws_interface_property(const char *key, GVariant *value, void *user_data)
 739 {
 740         __WDP_LOG_FUNC_ENTER__;
 741         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 742         if(!event)
 743                 return;
 744
 745         CHECK_KEY_VALUE(key, value);
 746
 747         if (g_strcmp0(key, "Ifname") == 0) {
 748                 const char *ifname = NULL;
 749
 750                 g_variant_get(value, "s", &ifname);
 751                 g_strlcpy(event->ifname, ifname, OEM_IFACE_NAME_LEN+1);
 752                 WDP_LOGE("Ifname [%s]", event->ifname);
 753
 754         }
 755
 756         __WDP_LOG_FUNC_EXIT__;
 757 }
 758
 759 void __ws_group_property(const char *key, GVariant *value, void *user_data)
 760 {
 761         __WDP_LOG_FUNC_ENTER__;
 762         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 763         if(!event || !event->edata)
 764                 return;
 765
 766         wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
 767
 768         CHECK_KEY_VALUE(key, value);
 769
 770         if (g_strcmp0(key, "Role") == 0) {
 771                 const char *role = NULL;
 772
 773                 g_variant_get(value, "s", &role);
 774                 WDP_LOGD("role [%s]", role);
 775
 776                 if (!strncmp(role, "GO", 2))
 777                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 778                 else if (!strncmp(role, "client", 6))
 779                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 780
 781         } else if (g_strcmp0(key, "Frequency") == 0) {
 782                 int frequency = 0;
 783
 784                 g_variant_get(value, "q", &frequency);
 785                 group->freq = (int)frequency;
 786
 787         } else if (g_strcmp0(key, "Passphrase") == 0) {
 788                 const char *passphrase = NULL;
 789
 790                 g_variant_get(value, "s", &passphrase);
 791                 g_strlcpy(group->pass, passphrase, OEM_PASS_PHRASE_LEN+1);
 792                 WDP_LOGD("passphrase [%s]", group->pass);
 793
 794         } else if (g_strcmp0(key, "Group") == 0) {
 795
 796         } else if (g_strcmp0(key, "SSID") == 0) {
 797                 unsigned char ssid[WS_SSID_LEN +1] = {0,};
 798
 799                 __ws_unpack_ay(ssid, value, WS_SSID_LEN);
 800                         memcpy(group->ssid, ssid, WS_SSID_LEN+1);
 801                         WDP_LOGD("ssid [%s]", group->ssid);
 802
 803         } else if (g_strcmp0(key, "BSSID") == 0) {
 804
 805                 if (__ws_unpack_ay(group->go_dev_addr, value, WS_MACADDR_LEN))
 806                         WDP_LOGE("[" MACSTR "]", MAC2STR(group->go_dev_addr));
 807
 808         } else {
 809                 WDP_LOGE("Unknown value");
 810         }
 811         __WDP_LOG_FUNC_EXIT__;
 812 }
 813
 814 void __ws_extract_group_details(const char *key, GVariant *value, void *user_data)
 815 {
 816
 817         __WDP_LOG_FUNC_ENTER__;
 818         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 819         if(!event || !event->edata)
 820                 return;
 821
 822         CHECK_KEY_VALUE(key, value);
 823
 824         if (g_strcmp0(key, "interface_object") == 0) {
 825                 static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 826                 const char *i_path = NULL;
 827
 828                 g_variant_get(value, "o", &i_path);
 829                 g_strlcpy(interface_path, i_path, DBUS_OBJECT_PATH_MAX);
 830                 WDP_LOGD("Retrive Added path [%s]", interface_path);
 831                 g_strlcpy(g_pd->group_iface_path, interface_path, DBUS_OBJECT_PATH_MAX);
 832                 dbus_property_get_all(interface_path, g_pd->g_dbus,
 833                                 SUPPLICANT_IFACE, __ws_interface_property, event);
 834
 835         } else if (g_strcmp0(key, "role") == 0) {
 836                 const char *role = NULL;
 837
 838                 g_variant_get(value, "s", &role);
 839                 WDP_LOGD("role [%s]", role);
 840
 841                 if (!strncmp(role, "GO", 2))
 842                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 843                 else if (!strncmp(role, "client", 6))
 844                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 845
 846         } else if (g_strcmp0(key, "group_object") == 0) {
 847                 static char group_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 848                 const char *g_path;
 849
 850                 g_variant_get(value, "o", &g_path);
 851                 g_strlcpy(group_path, g_path, DBUS_OBJECT_PATH_MAX);
 852                 WDP_LOGD("Retrive group path [%s]", group_path);
 853                 dbus_property_get_all(group_path, g_pd->g_dbus, SUPPLICANT_P2P_GROUP,
 854                                 __ws_group_property, event);
 855
 856                 g_pd->group_sub_id =
 857                         g_dbus_connection_signal_subscribe(
 858                                 g_pd->g_dbus,
 859                                 SUPPLICANT_SERVICE, /* bus name */
 860                                 SUPPLICANT_P2P_GROUP, /* interface */
 861                                 NULL, /* member */
 862                                 group_path, /* object path */
 863                                 NULL, /* arg0 */
 864                                 G_DBUS_SIGNAL_FLAGS_NONE,
 865                                 _group_signal_cb,
 866                                 NULL, NULL);
 867         }
 868         __WDP_LOG_FUNC_EXIT__;
 869 }
 870
 871 void __ws_extract_gonegfailaure_details(const char *key, GVariant *value, void *user_data)
 872 {
 873         __WDP_LOG_FUNC_ENTER__;
 874         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 875         if(!event || !event->edata)
 876                 return;
 877
 878         wfd_oem_conn_data_s *conn = (wfd_oem_conn_data_s *)event->edata;
 879
 880         CHECK_KEY_VALUE(key, value);
 881
 882         if (g_strcmp0(key, "peer_object") == 0) {
 883                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
 884                 const char *path;
 885
 886                 g_variant_get(value, "o", &path);
 887                 g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
 888                 WDP_LOGD("Retrive peer path [%s]", peer_path);
 889
 890         } else if (g_strcmp0(key, "status") == 0) {
 891                 int status = 0;
 892
 893                 g_variant_get(value, "i", &status);
 894                 WDP_LOGD("Retrive status [%d]", status);
 895                 conn->status = status;
 896         }
 897         __WDP_LOG_FUNC_EXIT__;
 898 }
 899
 900 void __ws_extract_gonegsuccess_details(const char *key, GVariant *value, void *user_data)
 901 {
 902         __WDP_LOG_FUNC_ENTER__;
 903         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 904         wfd_oem_conn_data_s *edata = (wfd_oem_conn_data_s *)event->edata;
 905         if(!event || !edata)
 906                 return;
 907
 908         CHECK_KEY_VALUE(key, value);
 909
 910         if (g_strcmp0(key, "peer_object") == 0) {
 911
 912         } else if (g_strcmp0(key, "status") == 0) {
 913
 914         } else if (g_strcmp0(key, "passphrase") == 0) {
 915
 916         } else if (g_strcmp0(key, "role_go") == 0) {
 917                 //local device role
 918                 const char *role = NULL;
 919
 920                 g_variant_get(value, "s", &role);
 921                 if (!strncmp(role, "GO", 2))
 922                         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 923                 else if (!strncmp(role, "client", 6))
 924                         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 925
 926         } else if (g_strcmp0(key, "ssid") == 0) {
 927                 unsigned char ssid[WS_SSID_LEN +1] = {0,};
 928
 929                 __ws_unpack_ay(ssid, value, WS_SSID_LEN);
 930                         memcpy(edata->ssid, ssid, WS_SSID_LEN+1);
 931                         WDP_LOGD("ssid [%s]", edata->ssid);
 932
 933         } else if (g_strcmp0(key, "peer_device_addr") == 0) {
 934
 935                 if(__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
 936                         WDP_LOGD("[" MACSTR "]", MAC2STR(edata->peer_device_addr));
 937
 938         } else if(g_strcmp0(key, "peer_interface_addr") == 0) {
 939
 940                 if(__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
 941                         WDP_LOGD("[" MACSTR "]", MAC2STR(edata->peer_intf_addr));
 942
 943         } else if (g_strcmp0(key, "wps_method") == 0) {
 944
 945         } else if (g_strcmp0(key, "frequency_list") == 0) {
 946
 947         } else if (g_strcmp0(key, "persistent_group") == 0) {
 948
 949                 g_variant_get(value, "i", &(edata->persistent_group));
 950                 WDP_LOGD("persistent_group [%d]", edata->persistent_group);
 951
 952         } else if (g_strcmp0(key, "peer_config_timeout") == 0) {
 953
 954         }
 955         __WDP_LOG_FUNC_EXIT__;
 956 }
 957
 958 void __ws_extract_peer_service(wfd_oem_event_s *data, unsigned char *service_hex, int tlvs_len)
 959 {
 960         GList *services = NULL;
 961         wfd_oem_new_service_s *new_service = NULL;
 962         char *segment = NULL;
 963         int count = 0;
 964         int ptr = 0;
 965         int length = 0;
 966         int res = 0;
 967
 968         while(ptr + 2 < WS_MAX_SERVICE_LEN &&
 969                         (length = (service_hex[ptr+1]*256) + service_hex[ptr]) > 0) {
 970                 segment = (char*) g_try_malloc0(length*2+1);
 971                 if(segment) {
 972                         __ws_byte_to_hex(segment, length * 2 + 1, &service_hex[ptr + 3], length);
 973                         res = __ws_segment_to_service(segment, &new_service);
 974                         if (res < 0) {
 975                                 WDP_LOGE("Failed to convert segment as service instance");
 976                                 g_free(segment);
 977                                 segment = NULL;
 978                                 continue;
 979                         }
 980                         services = g_list_append(services, new_service);
 981                         count++;
 982                         ptr += length + 4;
 983                         g_free(segment);
 984                         segment = NULL;
 985                 }
 986                 data->edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
 987                 data->dev_role = count;
 988                 data->edata = (void*) services;
 989         }
 990 }
 991
 992 void __ws_extract_servicediscoveryresponse_details(const char *key, GVariant *value, void *user_data)
 993 {
 994         __WDP_LOG_FUNC_ENTER__;
 995         wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
 996
 997         if(!event)
 998                 return;
 999
1000         CHECK_KEY_VALUE(key, value);
1001
1002         if (g_strcmp0(key, "peer_object") == 0) {
1003                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1004                 __ws_path_to_addr(peer_path, event->dev_addr, value);
1005
1006         } else if (g_strcmp0(key, "update_indicator")) {
1007
1008         } else if (g_strcmp0(key, "tlvs")) {
1009                 GVariantIter *iter = NULL;
1010                 unsigned char service_hex[WS_MAX_SERVICE_LEN];
1011                 int byte_length = 0;
1012
1013                 g_variant_get(value, "ay", &iter);
1014                 if (iter == NULL) {
1015                         WDP_LOGE("failed to get iterator");
1016                         return;
1017                 }
1018
1019                 memset(service_hex, 0x0, WS_MAX_SERVICE_LEN);
1020                 while (g_variant_iter_loop (iter, "y", &service_hex[byte_length]))
1021                         byte_length++;
1022
1023                 __ws_extract_peer_service(event, service_hex, byte_length);
1024         }
1025
1026         __WDP_LOG_FUNC_EXIT__;
1027 }
1028
1029 static void _ws_process_device_found(GDBusConnection *connection,
1030                 const gchar *object_path, GVariant *parameters)
1031 {
1032         __WDP_LOG_FUNC_ENTER__;
1033         wfd_oem_event_s event;
1034         wfd_oem_dev_data_s *edata = NULL;
1035         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1036
1037         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1038         if (!edata) {
1039                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1040                                 strerror(errno));
1041                 __WDP_LOG_FUNC_EXIT__;
1042                 return;
1043         }
1044         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1045
1046         event.edata = (void*) edata;
1047         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1048         event.event_id = WFD_OEM_EVENT_PEER_FOUND;
1049
1050         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1051
1052         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1053                         __ws_peer_property, event.edata);
1054
1055         g_pd->callback(g_pd->user_data, &event);
1056         g_free(event.edata);
1057
1058         __WDP_LOG_FUNC_EXIT__;
1059 }
1060
1061 static void _ws_process_device_lost(GDBusConnection *connection,
1062                 const gchar *object_path, GVariant *parameters)
1063 {
1064         __WDP_LOG_FUNC_ENTER__;
1065         wfd_oem_event_s event;
1066         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1067
1068         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1069
1070         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1071         event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
1072
1073         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1074
1075         g_pd->callback(g_pd->user_data, &event);
1076
1077         __WDP_LOG_FUNC_EXIT__;
1078 }
1079
1080 static void _ws_process_find_stoppped(GDBusConnection *connection,
1081                 const gchar *object_path, GVariant *parameters)
1082 {
1083         __WDP_LOG_FUNC_ENTER__;
1084         wfd_oem_event_s event;
1085
1086         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1087
1088         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1089         event.event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
1090
1091         g_pd->callback(g_pd->user_data, &event);
1092
1093         __WDP_LOG_FUNC_EXIT__;
1094 }
1095
1096 static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
1097                 const gchar *object_path, GVariant *parameters)
1098 {
1099         __WDP_LOG_FUNC_ENTER__;
1100
1101         wfd_oem_event_s event;
1102         wfd_oem_dev_data_s *edata = NULL;
1103
1104         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1105         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1106         const char *path = NULL;
1107         const char *pin = NULL;
1108         char *loc = NULL;
1109
1110         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1111         if (!edata) {
1112                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1113                                 strerror(errno));
1114                 __WDP_LOG_FUNC_EXIT__;
1115                 return;
1116         }
1117         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1118
1119         event.edata = (void*) edata;
1120         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1121         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1122         event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
1123
1124         g_variant_get(parameters, "(os)", &path, &pin);
1125         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1126         WDP_LOGD("Retrive Added path [%s]", peer_path);
1127
1128         loc = strrchr(peer_path,'/');
1129         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1130         __ws_txt_to_mac(peer_dev, event.dev_addr);
1131         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1132
1133         g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
1134         WDP_LOGD("Retrive pin [%s]", event.wps_pin);
1135
1136         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1137                         __ws_peer_property, event.edata);
1138
1139         g_pd->callback(g_pd->user_data, &event);
1140         g_free(event.edata);
1141
1142         __WDP_LOG_FUNC_EXIT__;
1143 }
1144
1145 static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
1146                 const gchar *object_path, GVariant *parameters)
1147 {
1148         __WDP_LOG_FUNC_ENTER__;
1149
1150         wfd_oem_event_s event;
1151         wfd_oem_dev_data_s *edata = NULL;
1152
1153         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1154         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1155         const char *path = NULL;
1156         const char *pin = NULL;
1157         char *loc = NULL;
1158
1159         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1160         if (!edata) {
1161                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1162                                 strerror(errno));
1163                 __WDP_LOG_FUNC_EXIT__;
1164                 return;
1165         }
1166         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1167
1168         event.edata = (void*) edata;
1169         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1170         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1171         event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
1172
1173         g_variant_get(parameters, "(os)", &path, &pin);
1174         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1175         WDP_LOGD("Retrive Added path [%s]", peer_path);
1176
1177         loc = strrchr(peer_path,'/');
1178         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1179         __ws_txt_to_mac(peer_dev, event.dev_addr);
1180         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1181
1182         g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
1183         WDP_LOGE("Retrive pin [%s]", event.wps_pin);
1184
1185         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1186                         __ws_peer_property, event.edata);
1187
1188         g_pd->callback(g_pd->user_data, &event);
1189         g_free(event.edata);
1190
1191         __WDP_LOG_FUNC_EXIT__;
1192 }
1193
1194 static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
1195                 const gchar *object_path, GVariant *parameters)
1196 {
1197         __WDP_LOG_FUNC_ENTER__;
1198         wfd_oem_event_s event;
1199         wfd_oem_dev_data_s *edata = NULL;
1200         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1201
1202         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1203         if (!edata) {
1204                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1205                                 strerror(errno));
1206                 __WDP_LOG_FUNC_EXIT__;
1207                 return;
1208         }
1209         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1210
1211         event.edata = (void*) edata;
1212         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1213         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1214         event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
1215
1216         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1217
1218         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1219                         __ws_peer_property, event.edata);
1220
1221         g_pd->callback(g_pd->user_data, &event);
1222         g_free(event.edata);
1223
1224         __WDP_LOG_FUNC_EXIT__;
1225 }
1226
1227 static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
1228                 const gchar *object_path, GVariant *parameters)
1229 {
1230         __WDP_LOG_FUNC_ENTER__;
1231         wfd_oem_event_s event;
1232         wfd_oem_dev_data_s *edata = NULL;
1233         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1234
1235         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1236         if (!edata) {
1237                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1238                                 strerror(errno));
1239                 __WDP_LOG_FUNC_EXIT__;
1240                 return;
1241         }
1242         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1243
1244         event.edata = (void*) edata;
1245         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1246         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1247         event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
1248
1249         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1250
1251         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1252                         __ws_peer_property, event.edata);
1253
1254         g_pd->callback(g_pd->user_data, &event);
1255         g_free(event.edata);
1256
1257         __WDP_LOG_FUNC_EXIT__;
1258 }
1259
1260 static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
1261                 const gchar *object_path, GVariant *parameters)
1262 {
1263         __WDP_LOG_FUNC_ENTER__;
1264         wfd_oem_event_s event;
1265         wfd_oem_dev_data_s *edata = NULL;
1266         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1267
1268         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1269         if (!edata) {
1270                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1271                                 strerror(errno));
1272                 __WDP_LOG_FUNC_EXIT__;
1273                 return;
1274         }
1275         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1276
1277         event.edata = (void*) edata;
1278         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1279         event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
1280         event.wps_mode = WFD_OEM_WPS_MODE_PBC;
1281
1282         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1283
1284         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1285                         __ws_peer_property, event.edata);
1286
1287         g_pd->callback(g_pd->user_data, &event);
1288         g_free(event.edata);
1289
1290         __WDP_LOG_FUNC_EXIT__;
1291 }
1292
1293 static void _ws_process_prov_disc_pbc_resp(GDBusConnection *connection,
1294                 const gchar *object_path, GVariant *parameters)
1295 {
1296         __WDP_LOG_FUNC_ENTER__;
1297         wfd_oem_event_s event;
1298         wfd_oem_dev_data_s *edata = NULL;
1299         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1300
1301         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1302         if (!edata) {
1303                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1304                                 strerror(errno));
1305                 __WDP_LOG_FUNC_EXIT__;
1306                 return;
1307         }
1308         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1309
1310         event.edata = (void*) edata;
1311         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1312         event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
1313         event.wps_mode = WFD_OEM_WPS_MODE_PBC;
1314
1315         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1316
1317         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1318                         __ws_peer_property, event.edata);
1319
1320         g_pd->callback(g_pd->user_data, &event);
1321         g_free(event.edata);
1322
1323         __WDP_LOG_FUNC_EXIT__;
1324 }
1325
1326 static void _ws_process_prov_disc_failure(GDBusConnection *connection,
1327                 const gchar *object_path, GVariant *parameters)
1328 {
1329         __WDP_LOG_FUNC_ENTER__;
1330         wfd_oem_event_s event;
1331         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1332         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1333         const char *path = NULL;
1334         int prov_status = 0;
1335         char *loc = NULL;
1336
1337         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1338
1339         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1340         event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
1341
1342         g_variant_get(parameters, "(oi)", &path, &prov_status);
1343         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1344         WDP_LOGD("Retrive Added path [%s]", peer_path);
1345         WDP_LOGD("Retrive Failure stateus [%d]", prov_status);
1346
1347         loc = strrchr(peer_path,'/');
1348         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1349         __ws_txt_to_mac(peer_dev, event.dev_addr);
1350         WDP_LOGE("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1351
1352         g_pd->callback(g_pd->user_data, &event);
1353
1354         __WDP_LOG_FUNC_EXIT__;
1355 }
1356
1357 static void _ws_process_group_started(GDBusConnection *connection,
1358                 const gchar *object_path, GVariant *parameters)
1359 {
1360         __WDP_LOG_FUNC_ENTER__;
1361         GVariantIter *iter = NULL;
1362         wfd_oem_event_s event;
1363         wfd_oem_group_data_s *edata = NULL;
1364
1365         edata = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
1366         if (!edata) {
1367                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1368                                 strerror(errno));
1369                 __WDP_LOG_FUNC_EXIT__;
1370                 return;
1371         }
1372         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1373
1374         event.edata = (void*) edata;
1375         event.edata_type = WFD_OEM_EDATA_TYPE_GROUP;
1376         event.event_id = WFD_OEM_EVENT_GROUP_CREATED;
1377
1378         if(parameters != NULL){
1379                 g_variant_get(parameters, "(a{sv})", &iter);
1380
1381                 if (iter != NULL) {
1382                         dbus_property_foreach(iter, __ws_extract_group_details, &event);
1383                         g_variant_iter_free(iter);
1384                 }
1385         } else {
1386                 WDP_LOGE("No properties");
1387         }
1388
1389         g_pd->callback(g_pd->user_data, &event);
1390         g_free(event.edata);
1391
1392         __WDP_LOG_FUNC_EXIT__;
1393 }
1394
1395 static void _ws_process_go_neg_success(GDBusConnection *connection,
1396                 const gchar *object_path, GVariant *parameters)
1397 {
1398         __WDP_LOG_FUNC_ENTER__;
1399         GVariantIter *iter = NULL;
1400         wfd_oem_event_s event;
1401         wfd_oem_conn_data_s *edata = NULL;
1402
1403         edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
1404         if (!edata) {
1405                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1406                                 strerror(errno));
1407                 __WDP_LOG_FUNC_EXIT__;
1408                 return;
1409         }
1410         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1411
1412         event.edata = edata;
1413         event.edata_type = WFD_OEM_EDATA_TYPE_CONN;
1414         event.event_id = WFD_OEM_EVENT_GO_NEG_DONE;
1415
1416         if (parameters != NULL){
1417                 g_variant_get(parameters, "(a{sv})", &iter);
1418
1419                 if (iter != NULL) {
1420                         dbus_property_foreach(iter, __ws_extract_gonegsuccess_details, &event);
1421                         g_variant_iter_free(iter);
1422                 }
1423         } else {
1424                 WDP_LOGE("No properties");
1425         }
1426
1427         g_pd->callback(g_pd->user_data, &event);
1428         g_free(edata);
1429
1430         __WDP_LOG_FUNC_EXIT__;
1431 }
1432
1433 static void _ws_process_go_neg_failure(GDBusConnection *connection,
1434                 const gchar *object_path, GVariant *parameters)
1435 {
1436         __WDP_LOG_FUNC_ENTER__;
1437         GVariantIter *iter = NULL;
1438         wfd_oem_event_s event;
1439         wfd_oem_conn_data_s *edata = NULL;
1440
1441         edata = (wfd_oem_conn_data_s *) g_try_malloc0(sizeof(wfd_oem_conn_data_s));
1442         if (!edata) {
1443                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1444                                 strerror(errno));
1445                 __WDP_LOG_FUNC_EXIT__;
1446                 return;
1447         }
1448         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1449
1450         event.edata = (void*) edata;
1451         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1452         event.event_id = WFD_OEM_EVENT_GO_NEG_FAIL;
1453
1454         if (parameters != NULL) {
1455                 g_variant_get(parameters, "(a{sv})", &iter);
1456
1457                 if (iter != NULL) {
1458                         dbus_property_foreach(iter, __ws_extract_gonegfailaure_details, &event);
1459                         g_variant_iter_free(iter);
1460                 }
1461         } else {
1462                 WDP_LOGE("No properties");
1463         }
1464
1465         g_pd->callback(g_pd->user_data, &event);
1466         g_free(event.edata);
1467
1468         __WDP_LOG_FUNC_EXIT__;
1469 }
1470
1471 static void _ws_process_go_neg_request(GDBusConnection *connection,
1472                 const gchar *object_path, GVariant *parameters)
1473 {
1474         __WDP_LOG_FUNC_ENTER__;
1475         wfd_oem_event_s event;
1476         wfd_oem_dev_data_s *edata = NULL;
1477         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1478         static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
1479         const char *path = NULL;
1480         char * loc = NULL;
1481
1482         int dev_pwd_id = 0;
1483
1484         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1485         if (!edata) {
1486                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1487                                 strerror(errno));
1488                 __WDP_LOG_FUNC_EXIT__;
1489                 return;
1490         }
1491
1492         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1493
1494         event.edata = (void*) edata;
1495         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1496         event.event_id = WFD_OEM_EVENT_GO_NEG_REQ;
1497
1498         g_variant_get(parameters, "(oq)", &path, &dev_pwd_id);
1499         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1500         WDP_LOGD("Retrive peer path [%s]", peer_path);
1501
1502         WDP_LOGD("Retrive dev_passwd_id [%d]", dev_pwd_id);
1503
1504         if (dev_pwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
1505                 event.wps_mode = WFD_OEM_WPS_MODE_PBC;
1506         else if (dev_pwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
1507                 event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
1508         else if (dev_pwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
1509                 event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
1510         else
1511                 event.wps_mode = WFD_OEM_WPS_MODE_NONE;
1512
1513         g_variant_get(parameters, "(o)", &path);
1514         g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
1515         WDP_LOGD("Retrive Added path [%s]", peer_path);
1516
1517         loc = strrchr(peer_path,'/');
1518         __ws_mac_compact_to_normal(loc + 1, peer_dev);
1519         __ws_txt_to_mac(peer_dev, event.dev_addr);
1520         WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
1521
1522         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1523                         __ws_peer_property, event.edata);
1524
1525         g_pd->callback(g_pd->user_data, &event);
1526         g_free(event.edata);
1527
1528         __WDP_LOG_FUNC_EXIT__;
1529 }
1530
1531 static void _ws_process_invitation_result(GDBusConnection *connection,
1532                 const gchar *object_path, GVariant *parameters)
1533 {
1534         __WDP_LOG_FUNC_ENTER__;
1535         wfd_oem_event_s event;
1536         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1537
1538 //      g_pd->callback(g_pd->user_data, event);
1539
1540         __WDP_LOG_FUNC_EXIT__;
1541 }
1542
1543 static void _ws_process_group_finished(GDBusConnection *connection,
1544                 const gchar *object_path, GVariant *parameters)
1545 {
1546         __WDP_LOG_FUNC_ENTER__;
1547         wfd_oem_event_s event;
1548
1549         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1550
1551         event.event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
1552         event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1553
1554         g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, g_pd->group_sub_id);
1555         memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
1556
1557         g_pd->callback(g_pd->user_data, &event);
1558
1559         __WDP_LOG_FUNC_EXIT__;
1560 }
1561
1562 static void _ws_process_service_discovery_response(GDBusConnection *connection,
1563                 const gchar *object_path, GVariant *parameters)
1564 {
1565         __WDP_LOG_FUNC_ENTER__;
1566         GVariantIter *iter = NULL;
1567         wfd_oem_event_s event;
1568
1569         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1570
1571         event.event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
1572
1573         if(parameters != NULL) {
1574                 g_variant_get(parameters, "(a{sv}", &iter);
1575                 if(iter != NULL) {
1576                         dbus_property_foreach(iter, __ws_extract_servicediscoveryresponse_details, &event);
1577                         event.edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
1578                         g_variant_iter_free(iter);
1579                 }
1580         } else {
1581                 WDP_LOGE("No Properties");
1582         }
1583
1584         g_pd->callback(g_pd->user_data, &event);
1585
1586         if (event.edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE)
1587                 g_list_free((GList*) event.edata);
1588
1589         __WDP_LOG_FUNC_EXIT__;
1590 }
1591
1592 static void _ws_process_persistent_group_added(GDBusConnection *connection,
1593                 const gchar *object_path, GVariant *parameters)
1594 {
1595         __WDP_LOG_FUNC_ENTER__;
1596         wfd_oem_event_s event;
1597         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1598
1599 //      g_pd->callback(g_pd->user_data, &event);
1600
1601         __WDP_LOG_FUNC_EXIT__;
1602 }
1603
1604 static void _ws_process_persistent_group_removed(GDBusConnection *connection,
1605                 const gchar *object_path, GVariant *parameters)
1606 {
1607         __WDP_LOG_FUNC_ENTER__;
1608         wfd_oem_event_s event;
1609         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1610
1611 //      g_pd->callback(g_pd->user_data, &event);
1612
1613         __WDP_LOG_FUNC_EXIT__;
1614 }
1615
1616 static void _ws_process_wps_failed(GDBusConnection *connection,
1617                 const gchar *object_path, GVariant *parameters)
1618 {
1619         __WDP_LOG_FUNC_ENTER__;
1620         GVariantIter *iter = NULL;
1621         wfd_oem_event_s event;
1622         const char *name = NULL;
1623
1624         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1625
1626         event.event_id = WFD_OEM_EVENT_WPS_FAIL;
1627
1628         g_variant_get(parameters, "(sa{sv})", &name, &iter);
1629
1630         WDP_LOGD("code [%s]", name);
1631
1632         if (iter != NULL) {
1633
1634                 gchar *key = NULL;
1635                 GVariant *value = NULL;
1636
1637                 while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
1638                         CHECK_KEY_VALUE(key, value);
1639                 }
1640                 g_variant_iter_free(iter);
1641         }
1642
1643         g_pd->callback(g_pd->user_data, &event);
1644
1645         __WDP_LOG_FUNC_EXIT__;
1646 }
1647
1648 static struct {
1649         const char *interface;
1650         const char *member;
1651         void (*function) (GDBusConnection *connection,const gchar *object_path,
1652                         GVariant *parameters);
1653 } ws_p2pdevice_signal_map[] = {
1654         {
1655                 SUPPLICNAT_P2PDEVICE,
1656                 "DeviceFound",
1657                 _ws_process_device_found
1658         },
1659         {
1660                 SUPPLICNAT_P2PDEVICE,
1661                 "DeviceLost",
1662                 _ws_process_device_lost
1663         },
1664         {
1665                 SUPPLICNAT_P2PDEVICE,
1666                 "FindStopped",
1667                 _ws_process_find_stoppped
1668         },
1669         {
1670                 SUPPLICNAT_P2PDEVICE,
1671                 "ProvisionDiscoveryRequestDisplayPin",
1672                 _ws_process_prov_disc_req_display_pin
1673         },
1674         {
1675                 SUPPLICNAT_P2PDEVICE,
1676                 "ProvisionDiscoveryResponseDisplayPin",
1677                 _ws_process_prov_disc_resp_display_pin
1678         },
1679         {
1680                         SUPPLICNAT_P2PDEVICE,
1681                 "ProvisionDiscoveryRequestEnterPin",
1682                 _ws_process_prov_disc_req_enter_pin
1683         },
1684         {
1685                 SUPPLICNAT_P2PDEVICE,
1686                 "ProvisionDiscoveryResponseEnterPin",
1687                 _ws_process_prov_disc_resp_enter_pin
1688         },
1689         {
1690                 SUPPLICNAT_P2PDEVICE,
1691                 "ProvisionDiscoveryPBCRequest",
1692                 _ws_process_prov_disc_pbc_req
1693         },
1694         {
1695                 SUPPLICNAT_P2PDEVICE,
1696                 "ProvisionDiscoveryPBCResponse",
1697                 _ws_process_prov_disc_pbc_resp
1698         },
1699         {
1700                 SUPPLICNAT_P2PDEVICE,
1701                 "ProvisionDiscoveryFailure",
1702                 _ws_process_prov_disc_failure
1703         },
1704         {
1705                 SUPPLICNAT_P2PDEVICE,
1706                 "GroupStarted",
1707                 _ws_process_group_started
1708         },
1709         {
1710                 SUPPLICNAT_P2PDEVICE,
1711                 "GONegotiationSuccess",
1712                 _ws_process_go_neg_success
1713         },
1714         {
1715                 SUPPLICNAT_P2PDEVICE,
1716                 "GONegotiationFailure",
1717                 _ws_process_go_neg_failure
1718         },
1719         {
1720                 SUPPLICNAT_P2PDEVICE,
1721                 "GONegotiationRequest",
1722                 _ws_process_go_neg_request
1723         },
1724         {
1725                 SUPPLICNAT_P2PDEVICE,
1726                 "InvitationResult",
1727                 _ws_process_invitation_result
1728         },
1729         {
1730                 SUPPLICNAT_P2PDEVICE,
1731                 "GroupFinished",
1732                 _ws_process_group_finished
1733         },
1734         {
1735                 SUPPLICNAT_P2PDEVICE,
1736                 "ServiceDiscoveryResponse",
1737                 _ws_process_service_discovery_response
1738         },
1739         {
1740                 SUPPLICNAT_P2PDEVICE,
1741                 "PersistentGroupAdded",
1742                 _ws_process_persistent_group_added
1743         },
1744         {
1745                 SUPPLICNAT_P2PDEVICE,
1746                 "PersistentGroupRemoved",
1747                 _ws_process_persistent_group_removed
1748         },
1749         {
1750                 SUPPLICNAT_P2PDEVICE,
1751                 "WpsFailed ",
1752                 _ws_process_wps_failed
1753         },
1754         {
1755                 NULL,
1756                 NULL,
1757                 NULL
1758         }
1759 };
1760
1761 static void _p2pdevice_signal_cb(GDBusConnection *connection,
1762                 const gchar *sender, const gchar *object_path, const gchar *interface,
1763                 const gchar *signal, GVariant *parameters, gpointer user_data)
1764 {
1765         int i = 0;
1766         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
1767
1768         for (i = 0; ws_p2pdevice_signal_map[i].member != NULL; i++) {
1769                 if (!g_strcmp0(signal, ws_p2pdevice_signal_map[i].member) &&
1770                                 ws_p2pdevice_signal_map[i].function != NULL)
1771                         ws_p2pdevice_signal_map[i].function(connection, object_path, parameters);
1772         }
1773 }
1774
1775
1776 static void _group_signal_cb(GDBusConnection *connection,
1777                 const gchar *sender, const gchar *object_path, const gchar *interface,
1778                 const gchar *signal, GVariant *parameters, gpointer user_data)
1779 {
1780         DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
1781
1782         if(!g_strcmp0(signal,"PeerJoined")){
1783
1784                         wfd_oem_event_s event;
1785                         wfd_oem_dev_data_s *edata = NULL;
1786
1787                         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1788
1789                         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
1790                         if (!edata) {
1791                                 WDP_LOGF("Failed to allocate memory for event. [%s]",
1792                                                 strerror(errno));
1793                                 __WDP_LOG_FUNC_EXIT__;
1794                                 return;
1795                         }
1796                         memset(&event, 0x0, sizeof(wfd_oem_event_s));
1797
1798                         event.edata = (void*) edata;
1799                         event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
1800                         event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
1801
1802                         __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1803
1804                         dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
1805                                                 __ws_peer_property, event.edata);
1806
1807                         g_pd->callback(g_pd->user_data, &event);
1808                         g_free(edata);
1809
1810         } else if (!g_strcmp0(signal,"PeerDisconnected")) {
1811
1812                 wfd_oem_event_s event;
1813
1814                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1815
1816                 memset(&event, 0x0, sizeof(wfd_oem_event_s));
1817
1818                 event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
1819                 event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
1820
1821                 __ws_path_to_addr(peer_path, event.dev_addr, parameters);
1822
1823                 g_pd->callback(g_pd->user_data, &event);
1824         }
1825 }
1826
1827 static void __register_p2pdevice_signal(GVariant *value, void *user_data)
1828 {
1829         __WDP_LOG_FUNC_ENTER__;
1830         ws_dbus_plugin_data_s * pd_data;
1831         static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1832         const char *path = NULL;
1833
1834         pd_data = (ws_dbus_plugin_data_s *)g_pd;
1835
1836         g_variant_get(value, "(o)", &path);
1837         g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
1838         g_strlcpy(pd_data->iface_path, path, DBUS_OBJECT_PATH_MAX);
1839
1840         WDP_LOGD("interface object path [%s]", interface_path);
1841         /* subscribe interface p2p signal */
1842         WDP_LOGD("register P2PDevice iface signal");
1843         pd_data->p2pdevice_sub_id = g_dbus_connection_signal_subscribe(
1844                 pd_data->g_dbus,
1845                 SUPPLICANT_SERVICE, /* bus name */
1846                 SUPPLICNAT_P2PDEVICE, /* interface */
1847                 NULL, /* member */
1848                 NULL, /* object path */
1849                 NULL, /* arg0 */
1850                 G_DBUS_SIGNAL_FLAGS_NONE,
1851                 _p2pdevice_signal_cb,
1852                 NULL, NULL);
1853         __WDP_LOG_FUNC_EXIT__;
1854 }
1855
1856 static int _ws_create_interface(const char *iface_name)
1857 {
1858         __WDP_LOG_FUNC_ENTER__;
1859         GDBusConnection *g_dbus = NULL;
1860         GVariantBuilder *builder = NULL;
1861         dbus_method_param_s params;
1862
1863         int res = 0;
1864
1865         g_dbus = g_pd->g_dbus;
1866         if (!g_dbus) {
1867                 WDP_LOGE("DBus connection is NULL");
1868                 return -1;
1869         }
1870         memset(&params, 0x0, sizeof(dbus_method_param_s));
1871
1872         dbus_set_method_param(&params, "CreateInterface", SUPPLICANT_PATH, g_dbus);
1873
1874         builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
1875         g_variant_builder_add(builder, "{sv}", "Ifname", g_variant_new_string(iface_name));
1876         g_variant_builder_add(builder, "{sv}", "Driver", g_variant_new_string("nl80211"));
1877         g_variant_builder_add(builder, "{sv}", "ConfigFile", g_variant_new_string(CONF_FILE_PATH));
1878         params.params = g_variant_new("(a{sv})", builder);
1879         g_variant_builder_unref(builder);
1880
1881         res = dbus_method_call(&params, SUPPLICANT_INTERFACE, __register_p2pdevice_signal, NULL);
1882         if (res < 0)
1883                 WDP_LOGE("Failed to send command to wpa_supplicant");
1884         else
1885                 WDP_LOGD("Succeeded to CreateInterface");
1886
1887         __WDP_LOG_FUNC_EXIT__;
1888         return 0;
1889 }
1890
1891 static int _ws_get_interface(const char *iface_name)
1892 {
1893         __WDP_LOG_FUNC_ENTER__;
1894         GDBusConnection *g_dbus = NULL;
1895         dbus_method_param_s params;
1896         int res = 0;
1897
1898         g_dbus = g_pd->g_dbus;
1899         if (!g_dbus) {
1900                 WDP_LOGE("DBus connection is NULL");
1901                 return -1;
1902         }
1903
1904         dbus_set_method_param(&params, SUPPLICANT_METHOD_GETINTERFACE,
1905                         SUPPLICANT_PATH, g_pd->g_dbus);
1906
1907         params.params = g_variant_new("(s)", iface_name);
1908         WDP_LOGE("param [%s]", g_variant_print(params.params,TRUE));
1909
1910         res = dbus_method_call(&params, SUPPLICANT_INTERFACE,
1911                                 __register_p2pdevice_signal, g_pd);
1912
1913         if (res < 0)
1914                 WDP_LOGE("Failed to send command to wpa_supplicant");
1915         else
1916                 WDP_LOGD("Succeeded to get interface");
1917
1918         __WDP_LOG_FUNC_EXIT__;
1919         return res;
1920 }
1921
1922 #if 0
1923 static int _ws_remove_interface(const char *iface_name)
1924 {
1925         __WDP_LOG_FUNC_ENTER__;
1926         GDBusConnection *g_dbus = NULL;
1927         dbus_method_param_s params;
1928         static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
1929         int res = 0;
1930
1931         g_dbus = g_pd->g_dbus;
1932         if (!g_dbus) {
1933                 WDP_LOGE("DBus connection is NULL");
1934                 return -1;
1935         }
1936
1937         res = _ws_get_interface(iface_name, interface_path);
1938         if (res < 0) {
1939                 WDP_LOGE("Failed to get interface object");
1940                 return -1;
1941         }
1942         memset(&params, 0x0, sizeof(dbus_method_param_s));
1943
1944         dbus_set_method_param(&params, "RemoveInterface", SUPPLICANT_PATH, g_dbus);
1945         params.params = g_variant_new("(o)", interface_path);
1946
1947         res = dbus_method_call(&params, SUPPLICANT_INTERFACE, NULL, NULL);
1948         if (res < 0)
1949                 WDP_LOGE("Failed to send command to wpa_supplicant");
1950         else
1951                 WDP_LOGD("Succeeded to RemoveInterface");
1952
1953         __WDP_LOG_FUNC_EXIT__;
1954         return 0;
1955 }
1956 #endif
1957
1958 static int _ws_init_dbus_connection(void)
1959 {
1960         __WDP_LOG_FUNC_ENTER__;
1961         GDBusConnection *conn = NULL;
1962         GError *error = NULL;
1963         int res = 0;
1964
1965         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1966
1967         if (conn == NULL) {
1968                 if(error != NULL){
1969                         WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
1970                                         error->message);
1971                         g_error_free(error);
1972                 }
1973                 __WDP_LOG_FUNC_EXIT__;
1974                 return -1;
1975         }
1976
1977         g_pd->g_dbus = conn;
1978
1979         WDP_LOGD("register supplicant signal");
1980         /* subscribe supplicant signal */
1981         g_pd->supp_sub_id = g_dbus_connection_signal_subscribe(
1982                 g_pd->g_dbus,
1983                 SUPPLICANT_SERVICE, /* bus name */
1984                 SUPPLICANT_INTERFACE, /* interface */
1985                 NULL, /* member */
1986                 SUPPLICANT_PATH, /* object path */
1987                 NULL, /* arg0 */
1988                 G_DBUS_SIGNAL_FLAGS_NONE,
1989                 _supplicant_signal_cb,
1990                 NULL, NULL);
1991
1992         if(_ws_get_interface(COMMON_IFACE_NAME) < 0)
1993                 res = _ws_create_interface(COMMON_IFACE_NAME);
1994
1995         if (res < 0)
1996                         WDP_LOGE("Failed to subscribe interface signal");
1997         else
1998                 WDP_LOGI("Successfully register signal filters");
1999         return res;
2000         __WDP_LOG_FUNC_EXIT__;
2001 }
2002
2003 static int _ws_deinit_dbus_connection(void)
2004 {
2005         GDBusConnection *g_dbus = NULL;
2006
2007         g_dbus = g_pd->g_dbus;
2008         if (!g_dbus) {
2009                 WDP_LOGE("DBus connection is NULL");
2010                 return -1;
2011         }
2012         if(g_pd != NULL) {
2013                 g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->supp_sub_id);
2014                 g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->p2pdevice_sub_id);
2015                 g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->group_sub_id);
2016         }
2017
2018         g_object_unref(g_dbus);
2019         return 0;
2020 }
2021
2022 int wfd_plugin_load(wfd_oem_ops_s **ops)
2023 {
2024         if (!ops) {
2025                 WDP_LOGE("Invalid parameter");
2026                 return -1;
2027         }
2028
2029         *ops = &supplicant_ops;
2030
2031         return 0;
2032 }
2033
2034 static int _ws_reset_plugin(ws_dbus_plugin_data_s *g_pd)
2035 {
2036         __WDP_LOG_FUNC_ENTER__;
2037
2038         if (!g_pd) {
2039                 WDP_LOGE("Invalid parameter");
2040                 __WDP_LOG_FUNC_EXIT__;
2041                 return -1;
2042         }
2043
2044         _ws_deinit_dbus_connection();
2045
2046         if (g_pd->activated)
2047                 ws_deactivate(g_pd->concurrent);
2048
2049         g_free(g_pd);
2050
2051         __WDP_LOG_FUNC_EXIT__;
2052         return 0;
2053 }
2054
2055
2056 static int __ws_check_net_interface(char* if_name)
2057 {
2058         struct ifreq ifr;
2059         int fd;
2060
2061         if (if_name == NULL) {
2062                 WDP_LOGE("Invalid param");
2063                 return -1;
2064         }
2065
2066         fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
2067         if (fd < 0) {
2068                 WDP_LOGE("socket create error: %d", fd);
2069                 return -2;
2070         }
2071
2072         memset(&ifr, 0, sizeof(ifr));
2073         strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
2074         ifr.ifr_name[IFNAMSIZ-1] = '\0';
2075
2076         if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
2077                 close(fd);
2078                 WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s", strerror(errno)); /* interface is not found. */
2079                 return -3;
2080         }
2081
2082         close(fd);
2083
2084         if (ifr.ifr_flags & IFF_UP) {
2085                 WDP_LOGD("%s interface is up", if_name);
2086                 return 1;
2087         } else if (!(ifr.ifr_flags & IFF_UP)) {
2088                 WDP_LOGD("%s interface is down", if_name);
2089                 return 0;
2090         }
2091         return 0;
2092 }
2093
2094 int ws_init(wfd_oem_event_cb callback, void *user_data)
2095 {
2096         __WDP_LOG_FUNC_ENTER__;
2097
2098         if (g_pd)
2099                 _ws_reset_plugin(g_pd);
2100
2101         errno = 0;
2102         g_pd = (ws_dbus_plugin_data_s*) g_try_malloc0 (sizeof(ws_dbus_plugin_data_s));
2103         if (!g_pd) {
2104                 WDP_LOGE("Failed to allocate memory for plugin data. [%s]", strerror(errno));
2105                 return -1;
2106         }
2107
2108         g_pd->callback = callback;
2109         g_pd->user_data = user_data;
2110         g_pd->initialized = TRUE;
2111
2112         __WDP_LOG_FUNC_EXIT__;
2113         return 0;
2114 }
2115
2116 int ws_deinit()
2117 {
2118         __WDP_LOG_FUNC_ENTER__;
2119
2120         if (g_pd) {
2121                 _ws_reset_plugin(g_pd);
2122                 g_pd = NULL;
2123         }
2124
2125         __WDP_LOG_FUNC_EXIT__;
2126         return 0;
2127 }
2128 #if 0
2129 static int __ws_p2p_firmware_start(void)
2130 {
2131         GError *error = NULL;
2132         GVariant *reply = NULL;
2133         GVariant *param = NULL;
2134         GDBusConnection *connection = NULL;
2135         const char *device = "p2p";
2136
2137         connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
2138         if (connection == NULL) {
2139                 if(error != NULL){
2140                         WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
2141                                         error->message);
2142                         g_error_free(error);
2143                 }
2144                 __WDP_LOG_FUNC_EXIT__;
2145                 return -1;
2146         }
2147         param = g_variant_new("(s)", device);
2148
2149         reply = g_dbus_connection_call_sync (connection,
2150                         NETCONFIG_SERVICE, /* bus name */
2151                         NETCONFIG_WIFI_PATH, /* object path */
2152                         NETCONFIG_WIFI_INTERFACE ".Firmware", /* interface name */
2153                         "Start", /* method name */
2154                         param, /* GVariant *params */
2155                         NULL, /* reply_type */
2156                         G_DBUS_CALL_FLAGS_NONE, /* flags */
2157                         NETCONFIG_DBUS_REPLY_TIMEOUT , /* timeout */
2158                         NULL, /* cancellable */
2159                         &error); /* error */
2160
2161         if(error != NULL){
2162                 if(strstr(error->message, ".AlreadyExists") != NULL) {
2163                         WDP_LOGD("p2p already enabled");
2164                         g_error_free(error);
2165
2166                 } else {
2167                         WDP_LOGE("Error! Failed to call net-config method: [%s]",
2168                                         error->message);
2169                         g_error_free(error);
2170                         if(reply)
2171                                  g_variant_unref(reply);
2172                         g_object_unref(connection);
2173                         __WDP_LOG_FUNC_EXIT__;
2174                         return -1;
2175                 }
2176         }
2177         if(reply)
2178                  g_variant_unref(reply);
2179         g_object_unref(connection);
2180         return 0;
2181 }
2182
2183 static int __ws_p2p_firmware_stop(void)
2184 {
2185         GError *error = NULL;
2186         GVariant *reply = NULL;
2187         GVariant *param = NULL;
2188         GDBusConnection *connection = NULL;
2189         const char *device = "p2p";
2190
2191         connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
2192         if (connection == NULL) {
2193                 if(error != NULL){
2194                         WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
2195                                         error->message);
2196                         g_error_free(error);
2197                 }
2198                 __WDP_LOG_FUNC_EXIT__;
2199                 return -1;
2200         }
2201         param = g_variant_new("(s)", device);
2202
2203         reply = g_dbus_connection_call_sync (connection,
2204                         NETCONFIG_SERVICE, /* bus name */
2205                         NETCONFIG_WIFI_PATH, /* object path */
2206                         NETCONFIG_WIFI_INTERFACE ".Firmware", /* interface name */
2207                         "Stop", /* method name */
2208                         param, /* GVariant *params */
2209                         NULL, /* reply_type */
2210                         G_DBUS_CALL_FLAGS_NONE, /* flags */
2211                         NETCONFIG_DBUS_REPLY_TIMEOUT , /* timeout */
2212                         NULL, /* cancellable */
2213                         &error); /* error */
2214
2215         if(error != NULL){
2216                 if(strstr(error->message, ".AlreadyExists") != NULL) {
2217                         WDP_LOGD("p2p already disabled");
2218                         g_error_free(error);
2219
2220                 } else {
2221                         WDP_LOGE("Error! Failed to call net-config method: [%s]",
2222                                         error->message);
2223                         g_error_free(error);
2224                         if(reply)
2225                                  g_variant_unref(reply);
2226                         g_object_unref(connection);
2227                         __WDP_LOG_FUNC_EXIT__;
2228                         return -1;
2229                 }
2230         }
2231         if(reply)
2232                  g_variant_unref(reply);
2233         g_object_unref(connection);
2234         return 0;
2235 }
2236
2237 static int __ws_p2p_supplicant_start(void)
2238 {
2239         gboolean rv = FALSE;
2240         const char *path = "/usr/sbin/p2p_supp.sh";
2241         char *const args[] = { "/usr/sbin/p2p_supp.sh", "start_dbus", NULL };
2242         char *const envs[] = { NULL };
2243
2244         rv = _ws_util_execute_file(path, args, envs);
2245
2246         if (rv != TRUE) {
2247                 WDP_LOGE("Failed to start p2p_supp.sh");
2248                 return -1;
2249         }
2250
2251         WDP_LOGI("Successfully started p2p_supp.sh");
2252         return 0;
2253 }
2254 #endif
2255
2256 static int __ws_if_up(void)
2257 {
2258         gboolean rv = FALSE;
2259         const char *path = "/usr/sbin/ifconfig";
2260         char *const args[] = { "/usr/sbin/ifconfig", "wlan0", "up", NULL };
2261         char *const envs[] = { NULL };
2262
2263         rv = _ws_util_execute_file(path, args, envs);
2264
2265         if (rv != TRUE) {
2266                 WDP_LOGE("Failed to start if down");
2267                 return -1;
2268         }
2269
2270         WDP_LOGI("Successfully if up");
2271         return 0;
2272 }
2273
2274 static int __ws_if_down(void)
2275 {
2276         gboolean rv = FALSE;
2277         const char *path = "/usr/sbin/ifconfig";
2278         char *const args[] = { "/usr/sbin/ifconfig", "wlan0", "down", NULL };
2279         char *const envs[] = { NULL };
2280
2281         rv = _ws_util_execute_file(path, args, envs);
2282
2283         if (rv != TRUE) {
2284                 WDP_LOGE("Failed to start if down");
2285                 return -1;
2286         }
2287
2288         WDP_LOGI("Successfully if down");
2289         return 0;
2290 }
2291
2292 static int __ws_p2p_supplicant_stop(void)
2293 {
2294         gboolean rv = FALSE;
2295         const char *path = "/usr/sbin/p2p_supp.sh";
2296         char *const args[] = { "/usr/sbin/p2p_supp.sh", "stop", NULL };
2297         char *const envs[] = { NULL };
2298
2299         rv = _ws_util_execute_file(path, args, envs);
2300
2301         if (rv != TRUE) {
2302                 WDP_LOGE("Failed to stop p2p_supp.sh");
2303                 return -1;
2304         }
2305
2306         WDP_LOGI("Successfully stopped p2p_supp.sh");
2307         return 0;
2308 }
2309
2310 #if 0
2311 static int __ws_p2p_on(void)
2312 {
2313         DBusError error;
2314         DBusMessage *reply = NULL;
2315         DBusMessage *message = NULL;
2316         DBusConnection *connection = NULL;
2317
2318         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
2319         if (connection == NULL) {
2320                 WDP_LOGE("Failed to get system bus");
2321                 return -EIO;
2322         }
2323
2324         message = dbus_message_new_method_call(NETCONFIG_SERVICE,
2325                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "LoadP2pDriver");
2326         if (message == NULL) {
2327                 WDP_LOGE("Failed DBus method call");
2328                 dbus_connection_unref(connection);
2329                 return -EIO;
2330         }
2331
2332         dbus_error_init(&error);
2333
2334         reply = dbus_connection_send_with_reply_and_block(connection, message,
2335                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
2336         if (dbus_error_is_set(&error) == TRUE) {
2337                 if (NULL != strstr(error.message, ".AlreadyExists")) {
2338                         // p2p already enabled
2339                 } else {
2340                         WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
2341                                         "DBus error [%s: %s]", error.name, error.message);
2342
2343                         dbus_error_free(&error);
2344                 }
2345
2346                 dbus_error_free(&error);
2347         }
2348
2349         if (reply != NULL)
2350                 dbus_message_unref(reply);
2351
2352         dbus_message_unref(message);
2353         dbus_connection_unref(connection);
2354
2355         return 0;
2356 }
2357
2358 static int __ws_p2p_off(void)
2359 {
2360         DBusError error;
2361         DBusMessage *reply = NULL;
2362         DBusMessage *message = NULL;
2363         DBusConnection *connection = NULL;
2364
2365         connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
2366         if (connection == NULL) {
2367                 WDP_LOGE("Failed to get system bus");
2368                 return -EIO;
2369         }
2370
2371         message = dbus_message_new_method_call(NETCONFIG_SERVICE,
2372                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "RemoveP2pDriver");
2373         if (message == NULL) {
2374                 WDP_LOGE("Failed DBus method call");
2375                 dbus_connection_unref(connection);
2376                 return -EIO;
2377         }
2378
2379         dbus_error_init(&error);
2380
2381         reply = dbus_connection_send_with_reply_and_block(connection, message,
2382                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
2383         if (dbus_error_is_set(&error) == TRUE) {
2384                 if (NULL != strstr(error.message, ".AlreadyExists")) {
2385                         // p2p already disabled
2386                 } else {
2387                         WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
2388                                         "DBus error [%s: %s]", error.name, error.message);
2389
2390                         dbus_error_free(&error);
2391                 }
2392
2393                 dbus_error_free(&error);
2394         }
2395
2396         if (reply != NULL)
2397                 dbus_message_unref(reply);
2398
2399         dbus_message_unref(message);
2400         dbus_connection_unref(connection);
2401
2402         return 0;
2403 }
2404 #endif
2405
2406 int ws_activate(int concurrent)
2407 {
2408         __WDP_LOG_FUNC_ENTER__;
2409         int res = 0;
2410         int retry_count = 0;
2411
2412         while (retry_count < WS_CONN_RETRY_COUNT) {
2413                 /* load wlan driver */
2414                 res = __ws_if_up();
2415                 if (res < 0) {
2416                         WDP_LOGE("Failed to load driver [ret=%d]", res);
2417                         return -1;
2418                 }
2419                 WDP_LOGI("P2P firmware started with error %d", res);
2420
2421                 if (__ws_check_net_interface(COMMON_IFACE_NAME) < 0) {
2422                         usleep(150000); // wait for 150ms
2423                         retry_count++;
2424                         WDP_LOGE("interface is not up: retry, %d", retry_count);
2425                 } else {
2426                         break;
2427                 }
2428         }
2429
2430         if (retry_count >= WS_CONN_RETRY_COUNT) {
2431                 WDP_LOGE("Driver loading is failed", res);
2432                 __WDP_LOG_FUNC_EXIT__;
2433                 return -1;
2434         }
2435         if (retry_count > 0) {
2436                 // Give driver marginal time to config net
2437                 WDP_LOGE("Driver loading is done. Wait marginal time for driver");
2438                 sleep(1); // 1s
2439         }
2440
2441         g_pd->concurrent = concurrent;
2442
2443         res = _ws_init_dbus_connection();
2444         if (res < 0) {
2445                 res = __ws_p2p_supplicant_stop();
2446                 WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
2447                 res = __ws_if_down();
2448                 WDP_LOGI("P2P firmware stopped with error %d", res);
2449                 __WDP_LOG_FUNC_EXIT__;
2450                 return -1;
2451         }
2452
2453         g_pd->activated = TRUE;
2454
2455         __WDP_LOG_FUNC_EXIT__;
2456         return 0;
2457 }
2458
2459 int ws_deactivate(int concurrent)
2460 {
2461         __WDP_LOG_FUNC_ENTER__;
2462         int res = 0;
2463
2464         if (!g_pd->activated) {
2465                 WDP_LOGE("Wi-Fi Direct is not activated");
2466                 return -1;
2467         }
2468
2469         ws_stop_scan();
2470
2471         g_pd->concurrent = concurrent;
2472
2473         _ws_deinit_dbus_connection();
2474
2475         res = __ws_p2p_supplicant_stop();
2476         WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
2477
2478         res = __ws_if_down();
2479         WDP_LOGI("P2P firmware stopped with error %d", res);
2480         g_pd->activated = FALSE;
2481
2482         __WDP_LOG_FUNC_EXIT__;
2483         return 0;
2484 }
2485
2486 static int _ws_flush()
2487 {
2488         __WDP_LOG_FUNC_ENTER__;
2489         GDBusConnection *g_dbus = NULL;
2490         dbus_method_param_s params;
2491         int res = 0;
2492
2493         g_dbus = g_pd->g_dbus;
2494         if (!g_dbus) {
2495                 WDP_LOGE("DBus connection is NULL");
2496                 return -1;
2497         }
2498         memset(&params, 0x0, sizeof(dbus_method_param_s));
2499
2500         dbus_set_method_param(&params, "Flush", g_pd->iface_path, g_dbus);
2501         params.params = NULL;
2502
2503         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2504         if (res < 0)
2505                 WDP_LOGE("Failed to send command to wpa_supplicant");
2506         else
2507                 WDP_LOGD("Succeeded to flush");
2508
2509         __WDP_LOG_FUNC_EXIT__;
2510         return 0;
2511 }
2512
2513 static int _ws_cancel()
2514 {
2515         __WDP_LOG_FUNC_ENTER__;
2516         GDBusConnection *g_dbus = NULL;
2517         dbus_method_param_s params;
2518         int res = 0;
2519
2520         g_dbus = g_pd->g_dbus;
2521         if (!g_dbus) {
2522                 WDP_LOGE("DBus connection is NULL");
2523                 return -1;
2524         }
2525         memset(&params, 0x0, sizeof(dbus_method_param_s));
2526
2527         dbus_set_method_param(&params, "Cancel", g_pd->iface_path , g_dbus);
2528         params.params = NULL;
2529
2530         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2531         if (res < 0)
2532                 WDP_LOGE("Failed to send command to wpa_supplicant");
2533         else
2534                 WDP_LOGD("Succeeded to cancel");
2535
2536         __WDP_LOG_FUNC_EXIT__;
2537         return 0;
2538 }
2539
2540 #if 0
2541 static gboolean _retry_start_scan(gpointer data)
2542 {
2543         __WDP_LOG_FUNC_ENTER__;
2544
2545         WDP_LOGD("Succeeded to start scan");
2546
2547         __WDP_LOG_FUNC_EXIT__;
2548         return 0;
2549 }
2550 #endif
2551
2552 int ws_start_scan(wfd_oem_scan_param_s *param)
2553 {
2554         __WDP_LOG_FUNC_ENTER__;
2555         GDBusConnection *g_dbus = NULL;
2556         GVariantBuilder *builder = NULL;
2557         GVariant *value = NULL;
2558         dbus_method_param_s params;
2559         int res = 0;
2560
2561         if (!param) {
2562                 WDP_LOGE("Invalid parameter");
2563                 return -1;
2564         }
2565         g_dbus = g_pd->g_dbus;
2566         if (!g_dbus) {
2567                 WDP_LOGE("DBus connection is NULL");
2568                 return -1;
2569         }
2570         memset(&params, 0x0, sizeof(dbus_method_param_s));
2571
2572         if (param->scan_mode == WFD_OEM_SCAN_MODE_ACTIVE) {
2573
2574                 dbus_set_method_param(&params, "Find",  g_pd->iface_path, g_dbus);
2575
2576                 builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
2577
2578                         if (param->scan_time)
2579                                 g_variant_builder_add (builder, "{sv}", "Timeout",
2580                                                         g_variant_new_int32(param->scan_time));
2581                         if (param->scan_type == WFD_OEM_SCAN_TYPE_SOCIAL)
2582                                 g_variant_builder_add (builder, "{sv}", "DiscoveryType",
2583                                                         g_variant_new_string("social"));
2584
2585                         value = g_variant_new ("(a{sv})", builder);
2586                         g_variant_builder_unref (builder);
2587         } else {
2588
2589                 dbus_set_method_param(&params, "Listen", g_pd->iface_path, g_dbus);
2590                 value = g_variant_new ("(i)", param->scan_time);
2591         }
2592
2593         params.params = value;
2594
2595         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
2596         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2597         g_variant_unref(value);
2598         if (res < 0)
2599                 WDP_LOGE("Failed to send command to wpa_supplicant");
2600         else
2601                 WDP_LOGD("Succeeded to start scan");
2602
2603         __WDP_LOG_FUNC_EXIT__;
2604         return res;
2605 }
2606
2607 int ws_restart_scan(int freq)
2608 {
2609         __WDP_LOG_FUNC_ENTER__;
2610         GDBusConnection *g_dbus = NULL;
2611         GVariantBuilder *builder = NULL;
2612         GVariant *value = NULL;
2613         dbus_method_param_s params;
2614         int res = 0;
2615
2616         g_dbus = g_pd->g_dbus;
2617         if (!g_dbus) {
2618                 WDP_LOGE("DBus connection is NULL");
2619                 return -1;
2620         }
2621         memset(&params, 0x0, sizeof(dbus_method_param_s));
2622
2623         dbus_set_method_param(&params, "Find", g_pd->iface_path, g_dbus);
2624
2625         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
2626         g_variant_builder_add (builder, "{sv}", "Timeout", g_variant_new_int32(2));
2627         g_variant_builder_add (builder, "{sv}", "DiscoveryType",
2628                                 g_variant_new_string("social"));
2629         value = g_variant_new ("(a{sv})", builder);
2630         g_variant_builder_unref (builder);
2631
2632         params.params = value;
2633
2634         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
2635         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2636         g_variant_unref(value);
2637         if (res < 0)
2638                 WDP_LOGE("Failed to send command to wpa_supplicant");
2639         else
2640                 WDP_LOGD("Succeeded to start scan");
2641
2642         __WDP_LOG_FUNC_EXIT__;
2643         return res;
2644 }
2645
2646 int ws_stop_scan()
2647 {
2648         __WDP_LOG_FUNC_ENTER__;
2649         GDBusConnection *g_dbus = NULL;
2650         dbus_method_param_s params;
2651         int res = 0;
2652
2653         g_dbus = g_pd->g_dbus;
2654         if (!g_dbus) {
2655                 WDP_LOGE("DBus connection is NULL");
2656                 return -1;
2657         }
2658         memset(&params, 0x0, sizeof(dbus_method_param_s));
2659
2660         dbus_set_method_param(&params, "StopFind", g_pd->iface_path, g_dbus);
2661         params.params = NULL;
2662
2663         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2664         if (res < 0)
2665                         WDP_LOGE("Failed to send command to wpa_supplicant");
2666         else
2667                 WDP_LOGD("Succeeded to stop scan");
2668
2669         __WDP_LOG_FUNC_EXIT__;
2670         return res;
2671 }
2672
2673 int ws_get_visibility(int *visibility)
2674 {
2675         __WDP_LOG_FUNC_ENTER__;
2676
2677         __WDP_LOG_FUNC_EXIT__;
2678         return 0;
2679 }
2680
2681 int ws_set_visibility(int visibility)
2682 {
2683         __WDP_LOG_FUNC_ENTER__;
2684
2685         __WDP_LOG_FUNC_EXIT__;
2686         return 0;
2687 }
2688
2689 int ws_get_scan_result(GList **peers, int *peer_count)
2690 {
2691         __WDP_LOG_FUNC_ENTER__;
2692
2693         __WDP_LOG_FUNC_EXIT__;
2694         return 0;
2695 }
2696
2697 int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
2698 {
2699         __WDP_LOG_FUNC_ENTER__;
2700         GDBusConnection *g_dbus = NULL;
2701         wfd_oem_device_s *ws_dev = NULL;
2702         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2703         int res = 0;
2704
2705         if (!peer_addr || !peer) {
2706                 WDP_LOGE("Invalid parameter");
2707                 return -1;
2708         }
2709         g_dbus = g_pd->g_dbus;
2710         if (!g_dbus) {
2711                 WDP_LOGE("DBus connection is NULL");
2712                 return -1;
2713         }
2714
2715         ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
2716         if (!ws_dev) {
2717                 WDP_LOGF("Failed to allocate memory device. [%s]",
2718                                 strerror(errno));
2719                 __WDP_LOG_FUNC_EXIT__;
2720                 return -1;
2721         }
2722
2723         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
2724                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
2725
2726         WDP_LOGD("get peer path [%s]", peer_path);
2727
2728         res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
2729                                 __ws_get_peer_property, ws_dev);
2730
2731         if (res < 0) {
2732                         WDP_LOGE("Failed to send command to wpa_supplicant");
2733                         g_free(ws_dev);
2734                         __WDP_LOG_FUNC_EXIT__;
2735                         return -1;
2736         } else {
2737                 WDP_LOGD("succeeded to get peer info");
2738                 *peer = ws_dev;
2739         }
2740         __WDP_LOG_FUNC_EXIT__;
2741         return 0;
2742 }
2743
2744 int ws_prov_disc_req(unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
2745 {
2746         __WDP_LOG_FUNC_ENTER__;
2747         GDBusConnection *g_dbus = NULL;
2748         GVariant *value = NULL;
2749         dbus_method_param_s params;
2750         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2751         int res = 0;
2752
2753         if (!peer_addr) {
2754                 WDP_LOGE("Invalid parameter");
2755                 return -1;
2756         }
2757         g_dbus = g_pd->g_dbus;
2758         if (!g_dbus) {
2759                 WDP_LOGE("DBus connection is NULL");
2760                 return -1;
2761         }
2762         memset(&params, 0x0, sizeof(dbus_method_param_s));
2763
2764         dbus_set_method_param(&params, "ProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
2765
2766         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
2767                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
2768         WDP_LOGD("get peer path [%s]", peer_path);
2769
2770         value = g_variant_new ("(os)", peer_path, __ws_wps_to_txt(wps_mode));
2771         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
2772
2773         params.params = value;
2774
2775         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2776         g_variant_unref(value);
2777         if (res < 0)
2778                 WDP_LOGE("Failed to send command to wpa_supplicant");
2779         else
2780                 WDP_LOGD("Succeeded to send prov disc to peer[" MACSTR "]", MAC2STR(peer_addr));
2781
2782         __WDP_LOG_FUNC_EXIT__;
2783         return res;
2784 }
2785
2786 int ws_connect(unsigned char *peer_addr, wfd_oem_conn_param_s *param)
2787 {
2788         __WDP_LOG_FUNC_ENTER__;
2789         GDBusConnection *g_dbus = NULL;
2790         GVariantBuilder *builder = NULL;
2791         GVariant *value = NULL;
2792         dbus_method_param_s params;
2793         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2794         int res = 0;
2795
2796         if (!peer_addr || !param) {
2797                 WDP_LOGE("Invalid parameter");
2798                 return -1;
2799         }
2800         g_dbus = g_pd->g_dbus;
2801         if (!g_dbus) {
2802                 WDP_LOGE("DBus connection is NULL");
2803                 return -1;
2804         }
2805         memset(&params, 0x0, sizeof(dbus_method_param_s));
2806
2807         dbus_set_method_param(&params, "Connect", g_pd->iface_path, g_dbus);
2808
2809         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
2810                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
2811         WDP_LOGD("get peer path [%s]", peer_path);
2812
2813         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
2814         g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
2815         if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
2816                 g_variant_builder_add (builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
2817
2818         if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
2819                 g_variant_builder_add (builder, "{sv}", "join", g_variant_new_boolean(TRUE));
2820
2821         if (param->conn_flags& WFD_OEM_CONN_TYPE_AUTH)
2822                 g_variant_builder_add (builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
2823
2824         if (param->wps_pin[0] != '\0')
2825                 g_variant_builder_add (builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
2826
2827         g_variant_builder_add (builder, "{sv}", "wps_method",
2828                                 g_variant_new_string(__ws_wps_to_txt(param->wps_mode)));
2829
2830         value = g_variant_new ("(a{sv})", builder);
2831         g_variant_builder_unref (builder);
2832
2833         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
2834
2835         params.params = value;
2836
2837         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2838         g_variant_unref(value);
2839         if (res < 0)
2840                 WDP_LOGE("Failed to send command to wpa_supplicant");
2841         else
2842                 WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(peer_addr));
2843
2844         __WDP_LOG_FUNC_EXIT__;
2845         return res;
2846 }
2847
2848 int ws_disconnect(unsigned char *peer_addr)
2849 {
2850         __WDP_LOG_FUNC_ENTER__;
2851         GDBusConnection *g_dbus = NULL;
2852         GVariant *value = NULL;
2853         dbus_method_param_s params;
2854         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2855         int res = 0;
2856
2857         if (!peer_addr) {
2858                 WDP_LOGE("Invalid parameter");
2859                 return -1;
2860         }
2861         g_dbus = g_pd->g_dbus;
2862         if (!g_dbus) {
2863                 WDP_LOGE("DBus connection is NULL");
2864                 return -1;
2865         }
2866         memset(&params, 0x0, sizeof(dbus_method_param_s));
2867
2868         dbus_set_method_param(&params, "RemoveClient", g_pd->iface_path ,g_dbus);
2869
2870         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
2871                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
2872         WDP_LOGE("get peer path [%s]", peer_path);
2873
2874         value = g_variant_new ("(oi)", peer_path, 0);
2875         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
2876
2877         params.params = value;
2878
2879         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2880         g_variant_unref(value);
2881         if (res < 0)
2882                 WDP_LOGE("Failed to send command to wpa_supplicant");
2883         else
2884                 WDP_LOGD("Succeeded to stop scan");
2885
2886         __WDP_LOG_FUNC_EXIT__;
2887         return res;
2888 }
2889
2890 int ws_reject_connection(unsigned char *peer_addr)
2891 {
2892         __WDP_LOG_FUNC_ENTER__;
2893         GDBusConnection *g_dbus = NULL;
2894         GVariant *value = NULL;
2895         dbus_method_param_s params;
2896         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
2897         int res = 0;
2898
2899         if (!peer_addr) {
2900                 WDP_LOGE("Invalid parameter");
2901                 return -1;
2902         }
2903         g_dbus = g_pd->g_dbus;
2904         if (!g_dbus) {
2905                 WDP_LOGE("DBus connection is NULL");
2906                 return -1;
2907         }
2908         memset(&params, 0x0, sizeof(dbus_method_param_s));
2909
2910         dbus_set_method_param(&params, "RejectPeer", g_pd->iface_path ,g_dbus);
2911
2912         g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
2913                         COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
2914         WDP_LOGE("get peer path [%s]", peer_path);
2915
2916         value = g_variant_new ("(o)", peer_path);
2917         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
2918
2919         params.params = value;
2920
2921         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
2922         g_variant_unref(value);
2923         if (res < 0)
2924                 WDP_LOGE("Failed to send command to wpa_supplicant");
2925         else
2926                 WDP_LOGD("Succeeded to reject peer[" MACSTR "]", MAC2STR(peer_addr));
2927
2928         __WDP_LOG_FUNC_EXIT__;
2929         return res;
2930 }
2931
2932 int ws_cancel_connection(unsigned char *peer_addr)
2933 {
2934         __WDP_LOG_FUNC_ENTER__;
2935
2936         _ws_cancel();
2937
2938         __WDP_LOG_FUNC_EXIT__;
2939         return 0;
2940 }
2941
2942 int ws_get_connected_peers(GList **peers, int *peer_count)
2943 {
2944         __WDP_LOG_FUNC_ENTER__;
2945
2946         __WDP_LOG_FUNC_EXIT__;
2947         return 0;
2948 }
2949
2950 int ws_get_pin(char *pin)
2951 {
2952         __WDP_LOG_FUNC_ENTER__;
2953
2954         __WDP_LOG_FUNC_EXIT__;
2955         return 0;
2956 }
2957
2958 int ws_set_pin(char *pin)
2959 {
2960         __WDP_LOG_FUNC_ENTER__;
2961
2962         __WDP_LOG_FUNC_EXIT__;
2963         return 0;
2964 }
2965
2966 int ws_get_supported_wps_mode()
2967 {
2968         __WDP_LOG_FUNC_ENTER__;
2969
2970         __WDP_LOG_FUNC_EXIT__;
2971         return 0;
2972 }
2973
2974 int ws_create_group(int persistent, int freq, const char *passphrase)
2975 {
2976         __WDP_LOG_FUNC_ENTER__;
2977         GDBusConnection *g_dbus = NULL;
2978         GVariantBuilder *builder = NULL;
2979         GVariant *value = NULL;
2980         dbus_method_param_s params;
2981         int res = 0;
2982
2983         g_dbus = g_pd->g_dbus;
2984         if (!g_dbus) {
2985                 WDP_LOGE("DBus connection is NULL");
2986                 return -1;
2987         }
2988         memset(&params, 0x0, sizeof(dbus_method_param_s));
2989
2990         dbus_set_method_param(&params, "GroupAdd", g_pd->iface_path, g_dbus);
2991
2992         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
2993
2994         if (persistent)
2995                 g_variant_builder_add (builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
2996
2997         if(freq)
2998                 g_variant_builder_add (builder, "{sv}", "frequency", g_variant_new_int32(freq));
2999         else
3000                 g_variant_builder_add (builder, "{sv}", "frequency", g_variant_new_int32(2));
3001
3002         value = g_variant_new ("(a{sv})", builder);
3003         g_variant_builder_unref (builder);
3004
3005         WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
3006
3007         params.params = value;
3008
3009         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
3010         g_variant_unref(value);
3011         if (res < 0)
3012                 WDP_LOGE("Failed to send command to wpa_supplicant");
3013         else
3014                 WDP_LOGD("Succeeded to add group");
3015
3016         __WDP_LOG_FUNC_EXIT__;
3017         return res;
3018 }
3019
3020 int ws_destroy_group(const char *ifname)
3021 {
3022         __WDP_LOG_FUNC_ENTER__;
3023         GDBusConnection *g_dbus = NULL;
3024         dbus_method_param_s params;
3025         int res = 0;
3026
3027         if (!ifname) {
3028                 WDP_LOGE("Invalid parameter");
3029                 return -1;
3030         }
3031         g_dbus = g_pd->g_dbus;
3032         if (!g_dbus) {
3033                 WDP_LOGE("DBus connection is NULL");
3034                 return -1;
3035         }
3036         memset(&params, 0x0, sizeof(dbus_method_param_s));
3037
3038         dbus_set_method_param(&params, "Disconnect", g_pd->group_iface_path, g_dbus);
3039         params.params = NULL;
3040
3041         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
3042         if (res < 0) {
3043                         WDP_LOGE("Failed to send command to wpa_supplicant");
3044                         __WDP_LOG_FUNC_EXIT__;
3045                         return -1;
3046         } else {
3047                 _ws_flush();
3048                 WDP_LOGD("Succeeded to remove group");
3049         }
3050
3051         __WDP_LOG_FUNC_EXIT__;
3052         return 0;
3053 }
3054
3055 int ws_invite(unsigned char *peer_addr, wfd_oem_invite_param_s *param)
3056 {
3057         __WDP_LOG_FUNC_ENTER__;
3058                 GDBusConnection *g_dbus = NULL;
3059                 GVariantBuilder *builder = NULL;
3060                 GVariant *value = NULL;
3061                 dbus_method_param_s params;
3062                 static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
3063                 int res = 0;
3064
3065                 if (!peer_addr || !param) {
3066                         WDP_LOGE("Invalid parameter");
3067                         return -1;
3068                 }
3069                 g_dbus = g_pd->g_dbus;
3070                 if (!g_dbus) {
3071                         WDP_LOGE("DBus connection is NULL");
3072                         return -1;
3073                 }
3074                 memset(&params, 0x0, sizeof(dbus_method_param_s));
3075
3076                 dbus_set_method_param(&params, "Invite", g_pd->group_iface_path, g_dbus);
3077
3078                 g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
3079                                 COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
3080                 WDP_LOGE("get peer path [%s]", peer_path);
3081
3082                 builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
3083                 g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
3084                 value = g_variant_new ("(a{sv})", builder);
3085                 g_variant_builder_unref (builder);
3086
3087                 WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
3088
3089                 params.params = value;
3090
3091                 res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
3092                 g_variant_unref(value);
3093                 if (res < 0)
3094                         WDP_LOGE("Failed to send command to wpa_supplicant");
3095                 else
3096                         WDP_LOGD("Succeeded to invite peer[" MACSTR "]", MAC2STR(peer_addr));
3097
3098                 __WDP_LOG_FUNC_EXIT__;
3099                 return 0;
3100 }
3101
3102 // Only group owner can use this command
3103 int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
3104 {
3105         __WDP_LOG_FUNC_ENTER__;
3106         GDBusConnection *g_dbus = NULL;
3107         GVariantBuilder *builder = NULL;
3108         GVariant *value = NULL;
3109         GVariant *dev_addr = NULL;
3110         dbus_method_param_s params;
3111         int i = 0;
3112         int res = 0;
3113
3114         g_dbus = g_pd->g_dbus;
3115         if (!g_dbus) {
3116                 WDP_LOGE("DBus connection is NULL");
3117                 return -1;
3118         }
3119
3120         memset(&params, 0x0, sizeof(dbus_method_param_s));
3121
3122         dbus_set_method_param(&params, "Start", g_pd->group_iface_path, g_dbus);
3123
3124         if (peer_addr != NULL) {
3125                 builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
3126                 for(i = 0; i < WS_MACADDR_LEN; i++)
3127                         g_variant_builder_add(builder, "y", peer_addr[i]);
3128
3129                 dev_addr = g_variant_new ("ay", builder);
3130                 g_variant_builder_unref (builder);
3131         }
3132
3133         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
3134         g_variant_builder_add (builder, "{sv}", "Role", g_variant_new_string("enrollee"));
3135         if (peer_addr != NULL)
3136                 g_variant_builder_add (builder, "{sv}", "P2PDeviceAddress", dev_addr);
3137
3138         if (pin != NULL && pin[0] != '\0') {
3139                 g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pin"));
3140                 g_variant_builder_add (builder, "{sv}", "Pin", g_variant_new_string(pin));
3141         } else {
3142                 g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pbc"));
3143         }
3144
3145         value = g_variant_new ("(a{sv})", builder);
3146         g_variant_builder_unref (builder);
3147
3148         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
3149
3150         params.params = value;
3151
3152         res = dbus_method_call(&params, SUPPLICNAT_WPS, NULL, NULL);
3153         g_variant_unref(params.params);
3154
3155         if (peer_addr != NULL)
3156                 g_variant_unref(dev_addr);
3157         if (res < 0)
3158                 WDP_LOGE("Failed to send command to wpa_supplicant");
3159         else
3160                 WDP_LOGD("Succeeded to run wps");
3161
3162         __WDP_LOG_FUNC_EXIT__;
3163         return 0;
3164 }
3165
3166 int ws_enrollee_start(unsigned char *peer_addr, int wps_mode, const char *pin)
3167 {
3168         __WDP_LOG_FUNC_ENTER__;
3169
3170         WDP_LOGD("Succeeded to start WPS");
3171
3172         __WDP_LOG_FUNC_EXIT__;
3173         return 0;
3174 }
3175
3176 int ws_wps_cancel()
3177 {
3178         __WDP_LOG_FUNC_ENTER__;
3179         GDBusConnection *g_dbus = NULL;
3180         dbus_method_param_s params;
3181         int res = 0;
3182
3183         g_dbus = g_pd->g_dbus;
3184         if (!g_dbus) {
3185                 WDP_LOGE("DBus connection is NULL");
3186                 return -1;
3187         }
3188         memset(&params, 0x0, sizeof(dbus_method_param_s));
3189
3190         dbus_set_method_param(&params, "Cancel", g_pd->group_iface_path, g_dbus);
3191         params.params = NULL;
3192
3193         res = dbus_method_call(&params, SUPPLICNAT_WPS, NULL, NULL);
3194         if (res < 0)
3195                 WDP_LOGE("Failed to send command to wpa_supplicant");
3196         else
3197                 WDP_LOGD("Succeeded to cancel WPS");
3198
3199         __WDP_LOG_FUNC_EXIT__;
3200         return 0;
3201 }
3202
3203 int ws_get_dev_name(char *dev_name)
3204 {
3205         __WDP_LOG_FUNC_ENTER__;
3206
3207         __WDP_LOG_FUNC_EXIT__;
3208         return 0;
3209 }
3210
3211 int ws_set_dev_name(char *dev_name)
3212 {
3213         __WDP_LOG_FUNC_ENTER__;
3214         GDBusConnection *g_dbus = NULL;
3215
3216         GVariant *value = NULL;
3217         GVariant *param = NULL;
3218         GVariantBuilder *builder = NULL;
3219         dbus_method_param_s params;
3220         int res = 0;
3221
3222         if (!dev_name) {
3223                 WDP_LOGE("Invalid parameter");
3224                 return -1;
3225         }
3226         g_dbus = g_pd->g_dbus;
3227         if (!g_dbus) {
3228                 WDP_LOGE("DBus connection is NULL");
3229                 return -1;
3230         }
3231         memset(&params, 0x0, sizeof(dbus_method_param_s));
3232
3233         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3234                          g_dbus);
3235
3236         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
3237         g_variant_builder_add (builder, "{sv}", "DeviceName",
3238                                 g_variant_new_string(dev_name));
3239         g_variant_builder_add (builder, "{sv}", "SsidPostfix",
3240                                  g_variant_new_string(dev_name));
3241         value = g_variant_new ("a{sv}", builder);
3242         g_variant_builder_unref (builder);
3243
3244         param = g_variant_new("(ssv)", SUPPLICNAT_P2PDEVICE,
3245                                 "P2PDeviceConfig", value);
3246         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
3247
3248         params.params = param;
3249
3250         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3251         g_variant_unref(value);
3252         g_variant_unref(param);
3253         if (res < 0)
3254                 WDP_LOGE("Failed to send command to wpa_supplicant");
3255         else
3256                 WDP_LOGD("Succeeded to set device name");
3257
3258         __WDP_LOG_FUNC_EXIT__;
3259         return res;
3260 }
3261
3262 int ws_get_dev_mac(char *dev_mac)
3263 {
3264         __WDP_LOG_FUNC_ENTER__;
3265
3266         __WDP_LOG_FUNC_EXIT__;
3267         return 0;
3268 }
3269
3270 int ws_get_dev_type(int *pri_dev_type, int *sec_dev_type)
3271 {
3272         __WDP_LOG_FUNC_ENTER__;
3273
3274         __WDP_LOG_FUNC_EXIT__;
3275         return 0;
3276 }
3277
3278 int ws_set_dev_type(int pri_dev_type, int sec_dev_type)
3279 {
3280         __WDP_LOG_FUNC_ENTER__;
3281
3282         __WDP_LOG_FUNC_EXIT__;
3283         return 0;
3284 }
3285
3286 int ws_get_go_intent(int *go_intent)
3287 {
3288         __WDP_LOG_FUNC_ENTER__;
3289         GDBusConnection *g_dbus = NULL;
3290         GVariant *param = NULL;
3291         GVariant *reply = NULL;
3292         GError *error = NULL;
3293         GVariantIter *iter = NULL;
3294
3295
3296         if (!go_intent) {
3297                 WDP_LOGE("Invalid parameter");
3298                 return -1;
3299         }
3300         g_dbus = g_pd->g_dbus;
3301         if (!g_dbus) {
3302                 WDP_LOGE("DBus connection is NULL");
3303                 return -1;
3304         }
3305
3306         param = g_variant_new("(ss)", SUPPLICNAT_P2PDEVICE, "P2PDeviceConfig");
3307         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
3308
3309         reply = g_dbus_connection_call_sync (
3310                         g_dbus,
3311                         SUPPLICANT_SERVICE, /* bus name */
3312                         SUPPLICANT_INTERFACE, /* object path */
3313                         DBUS_PROPERTIES_INTERFACE, /* interface name */
3314                         DBUS_PROPERTIES_METHOD_GET, /* method name */
3315                         param, /* GVariant *params */
3316                         NULL, /* reply_type */
3317                         G_DBUS_CALL_FLAGS_NONE, /* flags */
3318                         SUPPLICANT_TIMEOUT , /* timeout */
3319                         NULL, /* cancellable */
3320                         &error); /* error */
3321
3322         if(error != NULL) {
3323                 WDP_LOGE("Error! Failed to get interface State: [%s]",
3324                                 error->message);
3325                 g_error_free(error);
3326                 if(reply)
3327                         g_variant_unref(reply);
3328                 __WDP_LOG_FUNC_EXIT__;
3329                 return -1;
3330         }
3331         g_variant_unref(param);
3332
3333
3334         if(reply != NULL){
3335                 g_variant_get(reply, "(a{sv})", &iter);
3336
3337                 if(iter != NULL){
3338
3339                         gchar *key = NULL;
3340                         GVariant *value = NULL;
3341
3342                         while(g_variant_iter_loop(iter, "{sv}", &key, &value)) {
3343                                 CHECK_KEY_VALUE(key, value);
3344                                 if(g_strcmp0(key, "GOIntent") == 0)
3345                                         g_variant_get(value, "u", go_intent);
3346                         }
3347                         g_variant_iter_free(iter);
3348                 }
3349                 g_variant_unref(reply);
3350         }
3351         __WDP_LOG_FUNC_EXIT__;
3352         return 0;
3353 }
3354
3355 int ws_set_go_intent(int go_intent)
3356 {
3357         __WDP_LOG_FUNC_ENTER__;
3358         GDBusConnection *g_dbus = NULL;
3359
3360         GVariant *value = NULL;
3361         GVariant *param = NULL;
3362         GVariantBuilder *builder = NULL;
3363         dbus_method_param_s params;
3364         int res = 0;
3365
3366         g_dbus = g_pd->g_dbus;
3367         if (!g_dbus) {
3368                 WDP_LOGE("DBus connection is NULL");
3369                 return -1;
3370         }
3371         memset(&params, 0x0, sizeof(dbus_method_param_s));
3372
3373         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3374                          g_dbus);
3375
3376         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
3377         g_variant_builder_add (builder, "{sv}", "GOIntent",
3378                                 g_variant_new_uint32(go_intent));
3379         value = g_variant_new ("a{sv}", builder);
3380         g_variant_builder_unref (builder);
3381
3382         param = g_variant_new("(ssv)", SUPPLICNAT_P2PDEVICE, "P2PDeviceConfig", value);
3383         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
3384
3385         params.params = param;
3386
3387         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3388         g_variant_unref(value);
3389         g_variant_unref(param);
3390         if (res < 0)
3391                 WDP_LOGE("Failed to send command to wpa_supplicant");
3392         else
3393                 WDP_LOGE("Succeeded to set go intent");
3394         __WDP_LOG_FUNC_EXIT__;
3395         return res;
3396 }
3397
3398 int ws_set_country(char *ccode)
3399 {
3400         __WDP_LOG_FUNC_ENTER__;
3401         __WDP_LOG_FUNC_ENTER__;
3402         GDBusConnection *g_dbus = NULL;
3403
3404         GVariant *value = NULL;
3405         GVariant *param = NULL;
3406
3407         dbus_method_param_s params;
3408         int res = 0;
3409
3410         g_dbus = g_pd->g_dbus;
3411         if (!g_dbus) {
3412                 WDP_LOGE("DBus connection is NULL");
3413                 return -1;
3414         }
3415         memset(&params, 0x0, sizeof(dbus_method_param_s));
3416
3417         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3418                          g_dbus);
3419
3420         value = g_variant_new_string(ccode);
3421
3422         param = g_variant_new("(ssv)", SUPPLICANT_IFACE, "Country", value);
3423         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
3424
3425         params.params = param;
3426
3427         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3428         g_variant_unref(value);
3429         g_variant_unref(param);
3430         if (res < 0)
3431                 WDP_LOGE("Failed to send command to wpa_supplicant");
3432         else
3433                 WDP_LOGD("Succeeded to set country(%s)", ccode);
3434
3435         __WDP_LOG_FUNC_EXIT__;
3436         return res;
3437 }
3438
3439 int _parsing_networks(char* buf, ws_network_info_s networks[], int *network_cnt)
3440 {
3441         __WDP_LOG_FUNC_ENTER__;
3442
3443         __WDP_LOG_FUNC_EXIT__;
3444         return 0;
3445 }
3446
3447 void __parsing_networks (const char *key, GVariant *value, void *user_data)
3448 {
3449         __WDP_LOG_FUNC_ENTER__;
3450         if(!user_data) {
3451                 __WDP_LOG_FUNC_EXIT__;
3452                 return;
3453         }
3454
3455         ws_network_info_s *network = (ws_network_info_s *)user_data;
3456
3457         CHECK_KEY_VALUE(key, value);
3458
3459         if (g_strcmp0(key, "ssid") == 0) {
3460                 const char *ssid = NULL;
3461                 g_variant_get(value, "s", &ssid);
3462                 WDP_LOGD("ssid [%s]", ssid);
3463                 g_strlcpy(network->ssid, ssid + 1, WS_SSID_LEN + 1);
3464                 network->ssid[strlen(ssid) - 2] = '\0';
3465
3466         } else if (g_strcmp0(key, "bssid") == 0) {
3467                 unsigned char *bssid = NULL;
3468                 g_variant_get(value, "s", &bssid);
3469                 WDP_LOGD("bssid [%s]", bssid);
3470                 __ws_txt_to_mac(bssid, network->bssid);
3471
3472         } else if (g_strcmp0(key, "mode") == 0) {
3473
3474         }
3475         return;
3476 }
3477
3478 void __ws_extract_p2pdevice_details(const char *key, GVariant *value, void *user_data)
3479 {
3480
3481         __WDP_LOG_FUNC_ENTER__;
3482
3483         CHECK_KEY_VALUE(key, value);
3484
3485         if (g_strcmp0(key, "PersistentGroups") == 0) {
3486                 GVariantIter *iter = NULL;
3487                 const char *path = NULL;
3488                 int num = 0;
3489
3490                 ws_network_info_s *networks = NULL;
3491                 networks = (ws_network_info_s *)user_data;
3492                 if(!networks) {
3493                         WDP_LOGE("network is NULL");
3494                         __WDP_LOG_FUNC_EXIT__;
3495                         return;
3496                 }
3497
3498                 g_variant_get(value, "ao", &iter);
3499                 while(g_variant_iter_loop(iter, "o", &path)) {
3500                         if(num >= WS_MAX_PERSISTENT_COUNT)
3501                                 break;
3502                         WDP_LOGD("Retrive persistent path [%s]", path);
3503                         g_strlcpy(networks[num].persistent_path, path, DBUS_OBJECT_PATH_MAX);
3504                         WDP_LOGD("Retrive persistent path [%s]", networks[num].persistent_path);
3505                         dbus_property_get_all(networks[num].persistent_path, g_pd->g_dbus,
3506                                         SUPPLICANT_P2P_PERSISTENTGROUP, __parsing_networks, &networks[num]);
3507                         num++;
3508                 }
3509                 networks[0].total = num;
3510                 WDP_LOGE("total number [%d]", num);
3511
3512         }
3513         __WDP_LOG_FUNC_EXIT__;
3514 }
3515
3516
3517 int ws_get_persistent_groups(wfd_oem_persistent_group_s **groups, int *group_count)
3518 {
3519         __WDP_LOG_FUNC_ENTER__;
3520         GDBusConnection *g_dbus = NULL;
3521
3522         ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
3523         wfd_oem_persistent_group_s *wfd_persistent_groups = NULL;
3524         int i, cnt = 0;
3525
3526         g_dbus = g_pd->g_dbus;
3527         if (!g_dbus) {
3528                 WDP_LOGE("DBus connection is NULL");
3529                 return -1;
3530         }
3531         dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICNAT_P2PDEVICE, __ws_extract_p2pdevice_details, &networks[0]);
3532
3533         cnt = networks[0].total;
3534
3535         WDP_LOGD("Persistent Group Count=%d", cnt);
3536         if (cnt > WS_MAX_PERSISTENT_COUNT) {
3537                 WDP_LOGE("Persistent group count exceeded or parsing error");
3538                 __WDP_LOG_FUNC_EXIT__;
3539                 return -1;
3540         }
3541
3542         wfd_persistent_groups = (wfd_oem_persistent_group_s*) g_try_malloc0(cnt * sizeof(wfd_oem_persistent_group_s));
3543         for(i = 0; i < cnt; i++) {
3544                 WDP_LOGD("----persistent group [%d]----", i);
3545                 WDP_LOGD("network_id=%d", networks[i].network_id);
3546                 WDP_LOGD("ssid=%s", networks[i].ssid);
3547                 WDP_LOGD("bssid=" MACSTR, MAC2STR(networks[i].bssid));
3548
3549                 wfd_persistent_groups[i].network_id = networks[i].network_id;
3550                 g_strlcpy(wfd_persistent_groups[i].ssid, networks[i].ssid, WS_SSID_LEN + 1);
3551                 memcpy(wfd_persistent_groups[i].go_mac_address, networks[i].bssid, WS_MACADDR_LEN);
3552         }
3553
3554         *group_count = cnt;
3555         *groups = wfd_persistent_groups;
3556
3557         __WDP_LOG_FUNC_EXIT__;
3558         return 0;
3559 }
3560
3561 int ws_remove_persistent_group(char *ssid, unsigned char *bssid)
3562 {
3563         __WDP_LOG_FUNC_ENTER__;
3564         GDBusConnection *g_dbus = NULL;
3565
3566         dbus_method_param_s params;
3567         ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
3568         int i, cnt = 0;
3569         int res = 0;
3570
3571         g_dbus = g_pd->g_dbus;
3572         if (!g_dbus) {
3573                 WDP_LOGE("DBus connection is NULL");
3574                 return -1;
3575         }
3576         dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICNAT_P2PDEVICE, __ws_extract_p2pdevice_details, networks);
3577
3578         cnt = networks[0].total;
3579
3580         WDP_LOGD("Persistent Group Count=%d", cnt);
3581         if (cnt > WS_MAX_PERSISTENT_COUNT) {
3582                 WDP_LOGE("Persistent group count exceeded or parsing error");
3583                 __WDP_LOG_FUNC_EXIT__;
3584                 return -1;
3585         }
3586
3587         for(i=0;i<cnt;i++) {
3588                 WDP_LOGD("----persistent group [%d]----", i);
3589                 WDP_LOGD("network_id=%d", networks[i].network_id);
3590                 WDP_LOGD("network ssid=%s", networks[i].ssid);
3591                 WDP_LOGD("network bssid=" MACSTR, MAC2STR(networks[i].bssid));
3592
3593                 WDP_LOGD("ssid=%s", ssid);
3594                 WDP_LOGD("bssid=" MACSTR, MAC2STR(bssid));
3595
3596
3597                 if (!memcmp(bssid, networks[i].bssid, WS_MACADDR_LEN) &&
3598                                 !strcmp(ssid, networks[i].ssid)) {
3599
3600                         WDP_LOGD("Persistent group found [%d: %s]", networks[i].network_id, ssid);
3601
3602                         memset(&params, 0x0, sizeof(dbus_method_param_s));
3603                         dbus_set_method_param(&params, "RemovePersistentGroup",
3604                                         g_pd->iface_path, g_dbus);
3605                         params.params = g_variant_new ("(o)", networks[i].persistent_path);
3606
3607                         WDP_LOGD("params [%s]", g_variant_print(params.params, TRUE));
3608                         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
3609                         if (res < 0) {
3610                                 WDP_LOGE("Failed to send command to wpa_supplicant");
3611                                 __WDP_LOG_FUNC_EXIT__;
3612                                 return -1;
3613                         }
3614                         WDP_LOGD("Succeeded to remove persistent group");;
3615                         break;
3616                 }
3617         }
3618
3619         if (i == cnt) {
3620                 WDP_LOGE("Persistent group not found [%s]", ssid);
3621                 return -1;
3622         }
3623
3624         __WDP_LOG_FUNC_EXIT__;
3625         return 0;
3626 }
3627
3628 int ws_set_persistent_reconnect(unsigned char *bssid, int reconnect)
3629 {
3630         __WDP_LOG_FUNC_ENTER__;
3631         GDBusConnection *g_dbus = NULL;
3632
3633         GVariant *value = NULL;
3634         GVariant *param = NULL;
3635         GVariantBuilder *builder = NULL;
3636         dbus_method_param_s params;
3637         int res = 0;
3638
3639         g_dbus = g_pd->g_dbus;
3640         if (!g_dbus) {
3641                 WDP_LOGE("DBus connection is NULL");
3642                 return -1;
3643         }
3644         memset(&params, 0x0, sizeof(dbus_method_param_s));
3645
3646         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
3647                         g_dbus);
3648
3649         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
3650         g_variant_builder_add (builder, "{sv}", "PersistentReconnect",
3651                                 g_variant_new_boolean(reconnect));
3652         value = g_variant_new ("a{sv}", builder);
3653         g_variant_builder_unref (builder);
3654
3655         param = g_variant_new("(ssv)", SUPPLICNAT_P2PDEVICE, "P2PDeviceConfig", value);
3656         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
3657
3658         params.params = param;
3659
3660         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
3661         g_variant_unref(value);
3662         g_variant_unref(param);
3663         if (res < 0)
3664                 WDP_LOGE("Failed to send command to wpa_supplicant");
3665         else
3666                 WDP_LOGD("Succeeded to set persistent reconnect");
3667
3668         __WDP_LOG_FUNC_EXIT__;
3669         return res;
3670 }
3671
3672 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
3673 static int __ws_compress_query(char *compressed, char *query, int qtype)
3674 {
3675         char *token = NULL;
3676         char *temp = NULL;
3677         int token_num = 0;
3678         int token_len = 0;
3679         int length = 0;
3680
3681         token = strtok_r(query, ".", &temp);
3682         while (token) {
3683                 if (!strcmp(token, "local")) {
3684                         WDP_LOGD("Query conversion done");
3685                         break;
3686
3687                 } else if (!strncmp(token, "_tcp", 4)) {
3688                         memcpy(&compressed[length], WS_TCP_PTR_HEX, 2);
3689                         length+=2;
3690
3691                 } else if (!strncmp(token, "_udp", 4)) {
3692                         memcpy(&compressed[length], WS_UDP_PTR_HEX, 2);
3693                         length+=2;
3694
3695                 } else {
3696                         WDP_LOGD("Token: [%s]", token);
3697                         token_len = strlen(token);
3698                         compressed[length] = token_len;
3699                         length++;
3700
3701                         memcpy(&compressed[length], token, token_len);
3702                         length+=token_len;
3703                 }
3704                 token_num++;
3705                 token = strtok_r(NULL, ".", &temp);
3706         }
3707         if(qtype == WS_QTYPE_PTR || token_num == 2) {
3708                 memcpy(&compressed[length], WS_PTR_TYPE_HEX, 3);
3709         } else if (qtype == WS_QTYPE_TXT || token_num == 3) {
3710                 memcpy(&compressed[length], WS_TXT_TYPE_HEX, 3);
3711         }
3712         length+=3;
3713         WDP_LOGD("converted query length [%d] token num [%d]", length, token_num);
3714
3715         return length;
3716 }
3717
3718 static int __ws_compress_rdata(char *compressed, char *rdata, int qtype)
3719 {
3720         char *token = NULL;
3721         char *temp = NULL;
3722         int token_len = 0;
3723         int length = 0;
3724
3725         if (qtype == WS_QTYPE_PTR) {
3726
3727                 token = strtok_r(rdata, ".", &temp);
3728                 if (token) {
3729                         WDP_LOGD("Token: %s", token);
3730                         token_len = strlen(token);
3731                         compressed[length] = token_len;
3732                         length++;
3733
3734                         memcpy(&compressed[length], token, token_len);
3735                         length+=token_len;
3736                 }
3737
3738                 compressed[length] = 0xc0;
3739                 compressed[length+1] = 0x27;
3740                 length+=2;
3741
3742         } else if (qtype == WS_QTYPE_TXT) {
3743
3744                 token = strtok_r(rdata, ",", &temp);
3745
3746                 while (token) {
3747                         WDP_LOGD("Token: [%s]", token);
3748
3749                         token_len = strlen(token);
3750                         compressed[length] = token_len;
3751                         length++;
3752
3753                         memcpy(&compressed[length], token, token_len);
3754                         length+=token_len;
3755
3756                         token = strtok_r(NULL, ",", &temp);
3757                 }
3758         } else {
3759                 WDP_LOGD("RDATA is NULL");
3760         }
3761         return length;
3762 }
3763
3764 int _convert_bonjour_to_args(char *query, char *rdata, GVariantBuilder *builder)
3765 {
3766         GVariantBuilder *args = NULL;
3767         char compressed[256] = {0, };
3768         char *temp = NULL;
3769         int length = 0;
3770         int qtype = 0;
3771         int i = 0;
3772
3773         if (!query || !builder) {
3774                 WDP_LOGE("Invalid parameter");
3775                 return -1;
3776         }
3777         if (!rdata || !strlen(rdata)) {
3778                 WDP_LOGD("RDATA is NULL\n");
3779         } else {
3780                 temp = strstr(rdata, query);
3781
3782                 if(temp != NULL && temp - rdata > 0)
3783                         qtype = WS_QTYPE_PTR;
3784                 else
3785                         qtype = WS_QTYPE_TXT;
3786                 temp = NULL;
3787         }
3788
3789         /* compress query */
3790         length = __ws_compress_query(compressed, query, qtype);
3791
3792         args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
3793         for (i = 0; i < length; i++)
3794                 g_variant_builder_add(args, "y", compressed[i]);
3795         g_variant_builder_add (builder, "{sv}", "query", g_variant_new ("ay", args));
3796         g_variant_builder_unref (args);
3797
3798         memset(compressed, 0x0, 256);
3799         length = 0;
3800         args = NULL;
3801
3802         if(qtype != 0) {
3803                 length = __ws_compress_rdata(compressed, rdata, qtype);
3804
3805                 args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
3806                 for (i = 0; i < length; i++)
3807                         g_variant_builder_add(args, "y", compressed[i]);
3808                 g_variant_builder_add (builder, "{sv}", "response", g_variant_new ("ay", args));
3809                 g_variant_builder_unref (args);
3810         }
3811
3812         return 0;
3813 }
3814
3815 int _check_service_query_exists(wfd_oem_service_s *service)
3816 {
3817         int count = 0;
3818         wfd_oem_service_s *data = NULL;
3819
3820         for (count = 0; count < g_list_length(service_list); count ++) {
3821                 data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
3822                 if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
3823                         WDP_LOGD("Query already exists");
3824                         return 1;
3825                 }
3826         }
3827         return 0;
3828 }
3829
3830 static wfd_oem_service_s* _remove_service_query(char * s_type, char *mac_str, char *query_id)
3831 {
3832         if (NULL == s_type || NULL == mac_str || NULL == query_id)
3833                 return NULL;
3834
3835         int count = 0;
3836         wfd_oem_service_s *data = NULL;
3837
3838         for (count = 0; count < g_list_length(service_list); count ++) {
3839                 data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
3840                 if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
3841                                 memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
3842                         strncpy(query_id, data->query_id, OEM_QUERY_ID_LEN);
3843                         break;
3844                 }
3845         }
3846         if (strlen(query_id) <= 0) {
3847                 WDP_LOGD("!! Query ID not found !!");
3848                 return NULL;
3849         }
3850
3851         WDP_LOGD("query id :[0x%s]",query_id);
3852
3853         return data;
3854 }
3855
3856 void __add_service_query(GVariant *value, void *mac_addr)
3857 {
3858         __WDP_LOG_FUNC_ENTER__;
3859         wfd_oem_service_s *service = NULL;
3860
3861         long long unsigned ref = 0;
3862         unsigned char *mac_address = (unsigned char *)mac_addr;
3863         char mac_str[18] = {0, };
3864
3865         int res = 0;
3866
3867         g_variant_get(value, "(t)", &ref);
3868
3869         service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
3870         if (!service) {
3871                 WDP_LOGE("Failed to allocate memory for service");
3872                 return;
3873         }
3874
3875         if (mac_address[0] == 0 && mac_address[1] == 0 && mac_address[2] == 0 &&
3876                         mac_address[3] == 0 && mac_address[4] == 0 && mac_address[5] == 0) {
3877                 g_snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
3878         } else {
3879                 g_snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_address));
3880         }
3881
3882         g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
3883         g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
3884
3885         res = _check_service_query_exists(service);
3886         if(res) {
3887                 free(service);
3888         } else {
3889                 service_list = g_list_append(service_list, service);
3890         }
3891
3892         __WDP_LOG_FUNC_EXIT__;
3893         return;
3894
3895 }
3896
3897 /* for now, supplicant dbus interface only provides upnp service fully */
3898 int ws_start_service_discovery(unsigned char *mac_addr, int service_type)
3899 {
3900         __WDP_LOG_FUNC_ENTER__;
3901         GDBusConnection *g_dbus = NULL;
3902         GVariantBuilder *builder = NULL;
3903         GVariant *value = NULL;
3904         dbus_method_param_s params;
3905         static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
3906         int i = 0;
3907         int res = 0;
3908
3909         g_dbus = g_pd->g_dbus;
3910         if (!g_dbus) {
3911                 WDP_LOGE("DBus connection is NULL");
3912                 return -1;
3913         }
3914         memset(&params, 0x0, sizeof(dbus_method_param_s));
3915
3916         dbus_set_method_param(&params, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
3917
3918         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
3919
3920         if(mac_addr) {
3921                 g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
3922                                 COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
3923                 WDP_LOGD("get peer path [%s]", peer_path);
3924                 g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
3925         }
3926
3927         if (service_type == WFD_OEM_SERVICE_TYPE_ALL) {
3928
3929                 char *service_all = "\x02\x00\x00\x01";
3930                 GVariantBuilder *query = NULL;
3931
3932                 query = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
3933                 for (i = 0; i < SERVICE_QUERY_LEN; i++)
3934                         g_variant_builder_add(query, "y", service_all[i]);
3935                 g_variant_builder_add (builder, "{sv}", "query", g_variant_new ("ay", query));
3936                 g_variant_builder_unref (query);
3937
3938                 } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
3939
3940                 g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
3941                 g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
3942
3943         } else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
3944
3945                 char *service_bonjour = "\x02\x00\x01\x01";
3946                 GVariantBuilder *query = NULL;
3947
3948                 query = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
3949                 for (i = 0; i < SERVICE_QUERY_LEN; i++)
3950                         g_variant_builder_add(query, "y", service_bonjour[i]);
3951                 g_variant_builder_add (builder, "{sv}", "query", g_variant_new ("ay", query));
3952                 g_variant_builder_unref (query);
3953         }
3954
3955         value = g_variant_new ("(a{sv})", builder);
3956         g_variant_builder_unref (builder);
3957
3958         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
3959
3960         params.params = value;
3961
3962         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, __add_service_query, mac_addr);
3963         if (res < 0)
3964                 WDP_LOGE("Failed to send command to wpa_supplicant");
3965         else
3966                 WDP_LOGD("Succeeded to start service discovery");
3967
3968         __WDP_LOG_FUNC_EXIT__;
3969         return res;
3970 }
3971
3972 int ws_cancel_service_discovery(unsigned char *mac_addr, int service_type)
3973 {
3974         __WDP_LOG_FUNC_ENTER__;
3975         GDBusConnection *g_dbus = NULL;
3976         dbus_method_param_s params;
3977         wfd_oem_service_s *data = NULL;
3978         char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
3979         char s_type[OEM_SERVICE_TYPE_LEN + 1] ={0, };
3980         char mac_str[18] = {0, };
3981
3982         int res = 0;
3983
3984         g_dbus = g_pd->g_dbus;
3985         if (!g_dbus) {
3986                 WDP_LOGE("DBus connection is NULL");
3987                 return -1;
3988         }
3989
3990         if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
3991                 mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
3992                 snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
3993         } else {
3994                 snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
3995         }
3996
3997         switch(service_type) {
3998                 case WFD_OEM_SERVICE_TYPE_ALL:
3999                         strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
4000                 break;
4001                 case WFD_OEM_SERVICE_TYPE_BONJOUR:
4002                         strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
4003                 break;
4004                 case WFD_OEM_SERVICE_TYPE_UPNP:
4005                         strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
4006                 break;
4007                 case WFD_OEM_SERVICE_TYPE_BT_ADDR:
4008                         strncpy(s_type, SERVICE_TYPE_BT_ADDR, OEM_SERVICE_TYPE_LEN);
4009                         break;
4010                 case WFD_OEM_SERVICE_TYPE_CONTACT_INFO:
4011                         strncpy(s_type, SERVICE_TYPE_CONTACT_INFO, OEM_SERVICE_TYPE_LEN);
4012                         break;
4013                 default:
4014                         __WDP_LOG_FUNC_EXIT__;
4015                         WDP_LOGE("Invalid Service type");
4016                         return -1;
4017         }
4018
4019         WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
4020         WDP_LOGD("Cancel service discovery s_type [%s]", s_type);
4021
4022         data = _remove_service_query(s_type, mac_str, query_id);
4023         if (NULL == data)
4024                 return -1;
4025
4026         memset(&params, 0x0, sizeof(dbus_method_param_s));
4027
4028         dbus_set_method_param(&params, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
4029
4030         params.params = g_variant_new ("(t)", strtoul(query_id, NULL, 16));
4031
4032         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
4033         if (res < 0)
4034                 WDP_LOGE("Failed to send command to wpa_supplicant");
4035         else
4036                 WDP_LOGD("Succeeded to cancel service discovery");
4037
4038         service_list = g_list_remove(service_list, data);
4039         free(data);
4040
4041         __WDP_LOG_FUNC_EXIT__;
4042         return res;
4043 }
4044
4045 int ws_serv_add(wfd_oem_new_service_s *service)
4046 {
4047         __WDP_LOG_FUNC_ENTER__;
4048         GDBusConnection *g_dbus = NULL;
4049         GVariantBuilder *builder = NULL;
4050         GVariant *value = NULL;
4051         dbus_method_param_s params;
4052         int res = 0;
4053
4054         g_dbus = g_pd->g_dbus;
4055         if (!g_dbus) {
4056                 WDP_LOGE("DBus connection is NULL");
4057                 return -1;
4058         }
4059         memset(&params, 0x0, sizeof(dbus_method_param_s));
4060
4061         dbus_set_method_param(&params, "AddService", g_pd->iface_path, g_dbus);
4062
4063         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
4064
4065         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
4066
4067                 WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
4068                 WDP_LOGD("Query: %s", service->data.bonjour.query);
4069                 WDP_LOGD("RData: %s", service->data.bonjour.rdata);
4070
4071                 res = _convert_bonjour_to_args(service->data.bonjour.query,
4072                                                             service->data.bonjour.rdata, builder);
4073                 if (res < 0) {
4074                         WDP_LOGE("Failed to convert Key string");
4075                         g_variant_builder_unref (builder);
4076                         return -1;
4077                 }
4078
4079         } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
4080                 g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
4081                 g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
4082                 g_variant_builder_add (builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
4083         }
4084
4085         value = g_variant_new ("(a{sv})", builder);
4086         g_variant_builder_unref (builder);
4087
4088         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
4089
4090         params.params = value;
4091
4092         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
4093         if (res < 0)
4094                 WDP_LOGE("Failed to send command to wpa_supplicant");
4095         else
4096                 WDP_LOGD("Succeeded to add service");
4097
4098         __WDP_LOG_FUNC_EXIT__;
4099         return 0;
4100 }
4101
4102 int ws_serv_del(wfd_oem_new_service_s *service)
4103 {
4104         __WDP_LOG_FUNC_ENTER__;
4105         GDBusConnection *g_dbus = NULL;
4106         GVariantBuilder *builder = NULL;
4107         GVariant *value = NULL;
4108         dbus_method_param_s params;
4109         int res = 0;
4110
4111         g_dbus = g_pd->g_dbus;
4112         if (!g_dbus) {
4113                 WDP_LOGE("DBus connection is NULL");
4114                 return -1;
4115         }
4116         memset(&params, 0x0, sizeof(dbus_method_param_s));
4117
4118         dbus_set_method_param(&params, "DeleteService", g_pd->iface_path, g_dbus);
4119
4120         builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
4121
4122         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
4123
4124                 WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
4125                 WDP_LOGD("Query: %s", service->data.bonjour.query);
4126
4127                 res = _convert_bonjour_to_args(service->data.bonjour.query,
4128                                                             NULL, builder);
4129                 if (res < 0) {
4130                         WDP_LOGE("Failed to convert Key string");
4131                         g_variant_builder_unref (builder);
4132                         return -1;
4133                 }
4134
4135         } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
4136                 g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
4137                 g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
4138                 g_variant_builder_add (builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
4139         }
4140
4141         value = g_variant_new ("(a{sv})", builder);
4142         g_variant_builder_unref (builder);
4143
4144         WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
4145
4146         params.params = value;
4147
4148         res = dbus_method_call(&params, SUPPLICNAT_P2PDEVICE, NULL, NULL);
4149         if (res < 0)
4150                 WDP_LOGE("Failed to send command to wpa_supplicant");
4151         else
4152                 WDP_LOGD("Succeeded to del service");
4153
4154         __WDP_LOG_FUNC_EXIT__;
4155         return 0;
4156 }
4157 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
4158
4159 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
4160
4161 int _ws_disable_display()
4162 {
4163         __WDP_LOG_FUNC_ENTER__;
4164         GDBusConnection *g_dbus = NULL;
4165         GVariantBuilder *builder = NULL;
4166         GVariant *value = NULL;
4167         GVariant *param = NULL;
4168         dbus_method_param_s params;
4169         int res = 0;
4170
4171         g_dbus = g_pd->g_dbus;
4172         if (!g_dbus) {
4173                 WDP_LOGE("DBus connection is NULL");
4174                 return -1;
4175         }
4176         memset(&params, 0x0, sizeof(dbus_method_param_s));
4177
4178         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
4179                          g_dbus);
4180
4181         builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
4182         value = g_variant_new ("ay", builder);
4183         g_variant_builder_unref (builder);
4184
4185         param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
4186         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
4187
4188         params.params = param;
4189
4190         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
4191         g_variant_unref(value);
4192         g_variant_unref(param);
4193         if (res < 0)
4194                 WDP_LOGE("Failed to send command to wpa_supplicant");
4195         else
4196                 WDP_LOGD("Succeeded to disable Wi-Fi display");
4197
4198         __WDP_LOG_FUNC_EXIT__;
4199         return res;
4200 }
4201
4202 int ws_miracast_init(int enable)
4203 {
4204         __WDP_LOG_FUNC_ENTER__;
4205         wfd_oem_display_s wifi_display;
4206         int res = 0;
4207
4208         memset(&wifi_display, 0x0, sizeof(wfd_oem_display_s));
4209
4210         wifi_display.availablity = enable;
4211         wifi_display.hdcp_support = 1;
4212         wifi_display.port = 0x07E6;
4213         wifi_display.max_tput = 0x0028;
4214
4215         res = ws_set_display(&wifi_display);
4216         if (res < 0) {
4217                 WDP_LOGE("Failed to set miracast parameter(device info)");
4218                 __WDP_LOG_FUNC_EXIT__;
4219                 return -1;
4220         }
4221
4222         if(!enable) {
4223                 res = _ws_disable_display();
4224                 if (res < 0)
4225                         WDP_LOGE("Failed to disable wifi display");
4226                 else
4227                         WDP_LOGD("Succeeded to disable wifi display");
4228         }
4229         __WDP_LOG_FUNC_EXIT__;
4230         return res;
4231 }
4232
4233 int ws_set_display(wfd_oem_display_s *wifi_display)
4234 {
4235         __WDP_LOG_FUNC_ENTER__;
4236         GDBusConnection *g_dbus = NULL;
4237
4238         GVariant *value = NULL;
4239         GVariant *param = NULL;
4240         GVariantBuilder *builder = NULL;
4241         dbus_method_param_s params;
4242         int i = 0;
4243         int res = 0;
4244
4245         unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
4246
4247         if (!wifi_display) {
4248                 WDP_LOGE("Invalid parameter");
4249                 return -1;
4250         }
4251         g_dbus = g_pd->g_dbus;
4252         if (!g_dbus) {
4253                 WDP_LOGE("DBus connection is NULL");
4254                 return -1;
4255         }
4256         memset(&params, 0x0, sizeof(dbus_method_param_s));
4257
4258         dbus_set_method_param(&params, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
4259                          g_dbus);
4260
4261         ies[2] = WFD_SUBELEM_LEN_DEV_INFO;
4262         ies[3] = wifi_display->hdcp_support;
4263         ies[4] = (wifi_display->type) | (wifi_display->availablity<<4);
4264         ies[5] = wifi_display->port>>8;
4265         ies[6] = wifi_display->port&0xff;
4266         ies[7] = wifi_display->max_tput>>8;
4267         ies[8] = wifi_display->max_tput&0xff;
4268
4269         builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
4270         for(i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
4271                 g_variant_builder_add(builder, "y", ies[i]);
4272         value = g_variant_new ("ay", builder);
4273         g_variant_builder_unref (builder);
4274
4275         WDP_LOGD("value [%s]", g_variant_print(value,TRUE));
4276
4277         param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
4278         WDP_LOGE("param [%s]", g_variant_print(param,TRUE));
4279
4280         params.params = param;
4281
4282         res = dbus_method_call(&params, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
4283         g_variant_unref(value);
4284         g_variant_unref(param);
4285         if (res < 0)
4286                 WDP_LOGE("Failed to send command to wpa_supplicant");
4287         else
4288                 WDP_LOGD("Succeeded to set Wi-Fi Display");
4289
4290         __WDP_LOG_FUNC_EXIT__;
4291         return res;
4292 }
4293 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
4294
4295 int ws_refresh()
4296 {
4297         __WDP_LOG_FUNC_ENTER__;
4298
4299         _ws_cancel();
4300         _ws_flush();
4301
4302         __WDP_LOG_FUNC_EXIT__;
4303         return 0;
4304 }