src/wifi-direct-client-proxy.c

   1 /*
   2  * libwifi-direct
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Sungsik Jang <sungsik.jang@samsung.com>, Dongwook Lee <dwmax.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22
  23 /*****************************************************************************
  24  *      Standard headers
  25  *****************************************************************************/
  26 #define _GNU_SOURCE
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdbool.h>
  30 #include <netdb.h>
  31 #include <sys/socket.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <sys/un.h>
  35 #include <fcntl.h>
  36 #include <errno.h>
  37 #include <sys/ioctl.h>
  38 #include <signal.h>
  39 #include <glib.h>
  40 #include <linux/unistd.h>
  41 #include <sys/poll.h>
  42 #include <pthread.h>
  43
  44 /*****************************************************************************
  45  *      System headers
  46  *****************************************************************************/
  47 #include <vconf.h>
  48
  49 /*****************************************************************************
  50  *      Wi-Fi Direct Service headers
  51  *****************************************************************************/
  52 #include "wifi-direct.h"
  53 #include "wifi-direct-client-proxy.h"
  54 #include "wifi-direct-internal.h"
  55
  56 /*****************************************************************************
  57  *      Macros and Typedefs
  58  *****************************************************************************/
  59
  60 /*****************************************************************************
  61  *      Global Variables
  62  *****************************************************************************/
  63 wifi_direct_client_info_s g_client_info = {
  64         .is_registered = FALSE,
  65         .client_id = -1,
  66         .sync_sockfd = -1,
  67         .async_sockfd = -1,
  68         .activation_cb = NULL,
  69         .discover_cb = NULL,
  70         .connection_cb = NULL,
  71         .ip_assigned_cb = NULL,
  72         .user_data_for_cb_activation = NULL,
  73         .user_data_for_cb_discover = NULL,
  74         .user_data_for_cb_connection = NULL,
  75         .user_data_for_cb_ip_assigned = NULL,
  76         .mutex = PTHREAD_MUTEX_INITIALIZER
  77 };
  78
  79 /*****************************************************************************
  80  *      Local Functions Definition
  81  *****************************************************************************/
  82
  83 #ifdef __NR_gettid
  84 pid_t gettid(void)
  85 {
  86         return syscall(__NR_gettid);
  87 }
  88 #else
  89 #error "__NR_gettid is not defined, please include linux/unistd.h"
  90 #endif
  91
  92 static wifi_direct_client_info_s *__wfd_get_control()
  93 {
  94         return &g_client_info;
  95 }
  96
  97 static void __wfd_reset_control()
  98 {
  99
 100         if (g_client_info.g_source_id > 0)
 101                 g_source_remove(g_client_info.g_source_id);
 102         g_client_info.g_source_id = -1;
 103
 104         // Protect standard input / output / error
 105         if (g_client_info.sync_sockfd > 0)
 106                 close(g_client_info.sync_sockfd);
 107         g_client_info.sync_sockfd = -1;
 108
 109         if (g_client_info.async_sockfd > 0)
 110                 close(g_client_info.async_sockfd);
 111         g_client_info.async_sockfd = -1;
 112
 113         g_client_info.is_registered = FALSE;
 114
 115         // Initialize callbacks
 116         g_client_info.activation_cb = NULL;
 117         g_client_info.discover_cb = NULL;
 118         g_client_info.connection_cb = NULL;
 119         g_client_info.ip_assigned_cb = NULL;
 120         g_client_info.user_data_for_cb_activation = NULL;
 121         g_client_info.user_data_for_cb_discover = NULL;
 122         g_client_info.user_data_for_cb_connection = NULL;
 123         g_client_info.user_data_for_cb_ip_assigned = NULL;
 124
 125         pthread_mutex_destroy(&g_client_info.mutex);
 126 }
 127
 128 static int macaddr_atoe(const char *p, unsigned char mac[])
 129 {
 130         int i = 0;
 131
 132         for (;;) {
 133                 mac[i++] = (char) strtoul(p, &p, 16);
 134                 if (!*p++ || i == 6)
 135                         break;
 136         }
 137
 138         return (i == 6);
 139 }
 140
 141 static char *__wfd_print_event(wfd_client_event_e event)
 142 {
 143         switch (event)
 144         {
 145         case WIFI_DIRECT_CLI_EVENT_INVALID:
 146                 return "WIFI_DIRECT_CLI_EVENT_INVALID";
 147                 break;
 148         case WIFI_DIRECT_CLI_EVENT_ACTIVATION:
 149                 return "ACTIVATION";
 150                 break;
 151         case WIFI_DIRECT_CLI_EVENT_DEACTIVATION:
 152                 return "DEACTIVATION";
 153                 break;
 154         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START:
 155                 return "WIFI_DIRECT_CLI_EVENT_DISCOVER_START";
 156                 break;
 157         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY:
 158                 return "WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY";
 159                 break;
 160         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN:
 161                 return "WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN";
 162                 break;
 163         case WIFI_DIRECT_CLI_EVENT_DISCOVER_END:
 164                 return "WIFI_DIRECT_CLI_EVENT_DISCOVER_END";
 165                 break;
 166         case WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS:
 167                 return "WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS";
 168                 break;
 169         case WIFI_DIRECT_CLI_EVENT_CONNECTION_START:
 170                 return "WIFI_DIRECT_CLI_EVENT_CONNECTION_START";
 171                 break;
 172         case WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ:
 173                 return "WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ";
 174                 break;
 175         case WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP:
 176                 return "WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP";
 177                 break;
 178         case WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ:
 179                 return "WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ";
 180                 break;
 181         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP:
 182                 return "WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP";
 183                 break;
 184         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND:
 185                 return "WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND";
 186                 break;
 187         case WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND:
 188                 return "WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND";
 189                 break;
 190         case WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP:
 191                 return "WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP";
 192                 break;
 193         case WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP:
 194                 return "WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP";
 195                 break;
 196         case WIFI_DIRECT_CLI_EVENT_IP_LEASED_IND:
 197                 return "WIFI_DIRECT_CLI_EVENT_IP_LEASED_IND";
 198                 break;
 199         case WIFI_DIRECT_CLI_EVENT_INVITATION_REQ:
 200                 return "WIFI_DIRECT_CLI_EVENT_INVITATION_REQ";
 201                 break;
 202         default:
 203                 return "WIFI_DIRECT_CLI_EVENT_unknown";
 204                 break;
 205         }
 206 }
 207
 208 static char *__wfd_print_error(wifi_direct_error_e error)
 209 {
 210         switch (error)
 211         {
 212         case WIFI_DIRECT_ERROR_NONE:
 213                 return "WIFI_DIRECT_ERROR_NONE";
 214         case WIFI_DIRECT_ERROR_NOT_PERMITTED:
 215                 return "WIFI_DIRECT_ERROR_NOT_PERMITTED";
 216         case WIFI_DIRECT_ERROR_OUT_OF_MEMORY:
 217                 return "WIFI_DIRECT_ERROR_OUT_OF_MEMORY";
 218         case WIFI_DIRECT_ERROR_RESOURCE_BUSY:
 219                 return "WIFI_DIRECT_ERROR_RESOURCE_BUSY";
 220         case WIFI_DIRECT_ERROR_INVALID_PARAMETER:
 221                 return "WIFI_DIRECT_ERROR_INVALID_PARAMETER";
 222         case WIFI_DIRECT_ERROR_NOT_INITIALIZED:
 223                 return "WIFI_DIRECT_ERROR_NOT_INITIALIZED";
 224         case WIFI_DIRECT_ERROR_COMMUNICATION_FAILED:
 225                 return "WIFI_DIRECT_ERROR_COMMUNICATION_FAILED";
 226         case WIFI_DIRECT_ERROR_WIFI_USED:
 227                 return "WIFI_DIRECT_ERROR_WIFI_USED";
 228         case WIFI_DIRECT_ERROR_MOBILE_AP_USED:
 229                 return "WIFI_DIRECT_ERROR_MOBILE_AP_USED";
 230         case WIFI_DIRECT_ERROR_CONNECTION_FAILED:
 231                 return "WIFI_DIRECT_ERROR_CONNECTION_FAILED";
 232         case WIFI_DIRECT_ERROR_AUTH_FAILED:
 233                 return "WIFI_DIRECT_ERROR_AUTH_FAILED";
 234         case WIFI_DIRECT_ERROR_OPERATION_FAILED:
 235                 return "WIFI_DIRECT_ERROR_OPERATION_FAILED";
 236         case WIFI_DIRECT_ERROR_TOO_MANY_CLIENT:
 237                 return "WIFI_DIRECT_ERROR_TOO_MANY_CLIENT";
 238         case WIFI_DIRECT_ERROR_ALREADY_INITIALIZED:
 239                 return "WIFI_DIRECT_ERROR_ALREADY_INITIALIZED";
 240         default:
 241                 WDC_LOGE("Invalid error value: [%d]", error);
 242                 return "Invalid error";
 243         }
 244 }
 245
 246 static int __wfd_convert_client_event(wfd_client_event_e event)
 247 {
 248         __WDC_LOG_FUNC_START__;
 249
 250         switch (event)
 251         {
 252         case WIFI_DIRECT_CLI_EVENT_ACTIVATION:
 253                 return WIFI_DIRECT_DEVICE_STATE_ACTIVATED;
 254                 break;
 255         case WIFI_DIRECT_CLI_EVENT_DEACTIVATION:
 256                 return WIFI_DIRECT_DEVICE_STATE_DEACTIVATED;
 257                 break;
 258
 259         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY:
 260                 return WIFI_DIRECT_ONLY_LISTEN_STARTED;
 261                 break;
 262         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START:
 263                 return WIFI_DIRECT_DISCOVERY_STARTED;
 264                 break;
 265         case WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS:
 266                 return WIFI_DIRECT_DISCOVERY_FOUND;
 267                 break;
 268         case WIFI_DIRECT_CLI_EVENT_DISCOVER_END:
 269                 return WIFI_DIRECT_DISCOVERY_FINISHED;
 270                 break;
 271         case WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ:
 272                 return WIFI_DIRECT_CONNECTION_REQ;
 273                 break;
 274         case WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ:
 275                 return WIFI_DIRECT_CONNECTION_WPS_REQ;
 276                 break;
 277         case WIFI_DIRECT_CLI_EVENT_CONNECTION_START:
 278                 return WIFI_DIRECT_CONNECTION_IN_PROGRESS;
 279                 break;
 280         case WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP:
 281                 return WIFI_DIRECT_CONNECTION_RSP;
 282                 break;
 283         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP:
 284                 return WIFI_DIRECT_DISCONNECTION_RSP;
 285                 break;
 286         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND:
 287                 return WIFI_DIRECT_DISCONNECTION_IND;
 288                 break;
 289         case WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND:
 290                 return WIFI_DIRECT_DISASSOCIATION_IND;
 291                 break;
 292         case WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP:
 293                 return WIFI_DIRECT_GROUP_CREATED;
 294                 break;
 295         case WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP:
 296                 return WIFI_DIRECT_GROUP_DESTROYED;
 297                 break;
 298         case WIFI_DIRECT_CLI_EVENT_INVITATION_REQ:
 299                 return WIFI_DIRECT_INVITATION_REQ;
 300                 break;
 301         default:
 302                 WDC_LOGE("Invalid event : [%d]", event);
 303                 break;
 304         }
 305
 306         __WDC_LOG_FUNC_END__;
 307         return -1;
 308 }
 309
 310 char *__wfd_client_print_cmd(wifi_direct_cmd_e cmd)
 311 {
 312         switch (cmd)
 313         {
 314         case WIFI_DIRECT_CMD_REGISTER:
 315                 return "WIFI_DIRECT_CMD_REGISTER";
 316         case WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET:
 317                 return "WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET";
 318         case WIFI_DIRECT_CMD_DEREGISTER:
 319                 return "WIFI_DIRECT_CMD_DEREGISTER";
 320         case WIFI_DIRECT_CMD_ACTIVATE:
 321                 return "WIFI_DIRECT_CMD_ACTIVATE";
 322         case WIFI_DIRECT_CMD_DEACTIVATE:
 323                 return "WIFI_DIRECT_CMD_DEACTIVATE";
 324         case WIFI_DIRECT_CMD_START_DISCOVERY:
 325                 return "WIFI_DIRECT_CMD_START_DISCOVERY";
 326         case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
 327                 return "WIFI_DIRECT_CMD_CANCEL_DISCOVERY";
 328         case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
 329                 return "WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT";
 330         case WIFI_DIRECT_CMD_GET_LINK_STATUS:
 331                 return "WIFI_DIRECT_CMD_GET_LINK_STATUS";
 332         case WIFI_DIRECT_CMD_CONNECT:
 333                 return "WIFI_DIRECT_CMD_CONNECT";
 334         case WIFI_DIRECT_CMD_CANCEL_CONNECTION:
 335                 return "WIFI_DIRECT_CMD_CANCEL_CONNECTION";
 336         case WIFI_DIRECT_CMD_REJECT_CONNECTION:
 337                 return "WIFI_DIRECT_CMD_REJECT_CONNECTION";
 338         case WIFI_DIRECT_CMD_DISCONNECT_ALL:
 339                 return "WIFI_DIRECT_CMD_DISCONNECT_ALL";
 340         case WIFI_DIRECT_CMD_CREATE_GROUP:
 341                 return "WIFI_DIRECT_CMD_CREATE_GROUP";
 342         case WIFI_DIRECT_CMD_IS_GROUPOWNER:
 343                 return "WIFI_DIRECT_CMD_IS_GROUPOWNER";
 344         case WIFI_DIRECT_CMD_GET_SSID:
 345                 return "WIFI_DIRECT_CMD_GET_SSID";
 346         case WIFI_DIRECT_CMD_SET_SSID:
 347                 return "WIFI_DIRECT_CMD_SET_SSID";
 348         case WIFI_DIRECT_CMD_GET_IP_ADDR:
 349                 return "WIFI_DIRECT_CMD_GET_IP_ADDR";
 350         case WIFI_DIRECT_CMD_GET_CONFIG:
 351                 return "WIFI_DIRECT_CMD_GET_CONFIG";
 352         case WIFI_DIRECT_CMD_SET_CONFIG:
 353                 return "WIFI_DIRECT_CMD_SET_CONFIG";
 354         case WIFI_DIRECT_CMD_SEND_CONNECT_REQ:
 355                 return "WIFI_DIRECT_CMD_SEND_CONNECT_REQ";
 356         case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
 357                 return "WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON";
 358         case WIFI_DIRECT_CMD_SET_WPS_PIN:
 359                 return "WIFI_DIRECT_CMD_SET_WPS_PIN";
 360         case WIFI_DIRECT_CMD_GET_WPS_PIN:
 361                 return "WIFI_DIRECT_CMD_GET_WPS_PIN";
 362         case WIFI_DIRECT_CMD_GENERATE_WPS_PIN:
 363                 return "WIFI_DIRECT_CMD_GENERATE_WPS_PIN";
 364         case WIFI_DIRECT_CMD_SET_WPA:
 365                 return "WIFI_DIRECT_CMD_SET_WPA";
 366         case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:
 367                 return "WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE";
 368         case WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE:
 369                 return "WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE";
 370         case WIFI_DIRECT_CMD_SET_REQ_WPS_MODE:
 371                 return "WIFI_DIRECT_CMD_SET_REQ_WPS_MODE";
 372         case WIFI_DIRECT_CMD_GET_REQ_WPS_MODE:
 373                 return "WIFI_DIRECT_CMD_GET_REQ_WPS_MODE";
 374         case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
 375                 return "WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO";
 376         case WIFI_DIRECT_CMD_DESTROY_GROUP:
 377                 return "WIFI_DIRECT_CMD_DESTROY_GROUP";
 378         case WIFI_DIRECT_CMD_DISCONNECT:
 379                 return "WIFI_DIRECT_CMD_DISCONNECT";
 380         case WIFI_DIRECT_CMD_SET_GO_INTENT:
 381                 return "WIFI_DIRECT_CMD_SET_GO_INTENT";
 382         case WIFI_DIRECT_CMD_GET_GO_INTENT:
 383                 return "WIFI_DIRECT_CMD_GET_GO_INTENT";
 384         case WIFI_DIRECT_CMD_GET_DEVICE_MAC:
 385                 return "WIFI_DIRECT_CMD_GET_DEVICE_MAC";
 386         case WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP:
 387                 return "WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP";
 388         case WIFI_DIRECT_CMD_SET_MAX_CLIENT:
 389                 return "WIFI_DIRECT_CMD_SET_MAX_CLIENT";
 390         case WIFI_DIRECT_CMD_GET_MAX_CLIENT:
 391                 return "WIFI_DIRECT_CMD_GET_MAX_CLIENT";
 392         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE:
 393                 return "WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE";
 394         case WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE:
 395                 return "WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE";
 396         case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
 397                 return "WIFI_DIRECT_CMD_IS_DISCOVERABLE";
 398         case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
 399                 return "WIFI_DIRECT_CMD_IS_LISTENING_ONLY";
 400         case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
 401                 return "WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL";
 402         case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
 403                 return "WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP";
 404         case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
 405                 return "WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP";
 406         case WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP:
 407                 return "WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP";
 408         case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO:
 409                 return "WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO";
 410         case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:
 411                 return "WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP";
 412         case WIFI_DIRECT_CMD_GET_DEVICE_NAME:
 413                 return "WIFI_DIRECT_CMD_GET_DEVICE_NAME";
 414         case WIFI_DIRECT_CMD_SET_DEVICE_NAME:
 415                 return "WIFI_DIRECT_CMD_SET_DEVICE_NAME";
 416         case WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL:
 417                 return "WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL";
 418         case WIFI_DIRECT_CMD_SERVICE_ADD:
 419                 return "WIFI_DIRECT_CMD_SERVICE_ADD";
 420         case WIFI_DIRECT_CMD_SERVICE_DEL:
 421                 return "WIFI_DIRECT_CMD_SERVICE_DEL";
 422         case WIFI_DIRECT_CMD_SERV_DISC_REQ:
 423                 return "WIFI_DIRECT_CMD_SERV_DISC_REQ";
 424         case WIFI_DIRECT_CMD_SERV_DISC_CANCEL:
 425                 return "WIFI_DIRECT_CMD_SERV_DISC_CANCEL";
 426         case WIFI_DIRECT_CMD_INIT_WIFI_DISPLAY:
 427                 return "WIFI_DIRECT_CMD_INIT_WIFI_DISPLAY";
 428         case WIFI_DIRECT_CMD_DEINIT_WIFI_DISPLAY:
 429                 return "WIFI_DIRECT_CMD_DEINIT_WIFI_DISPLAY";
 430         case WIFI_DIRECT_CMD_GET_DISPLAY_PORT:
 431                 return "WIFI_DIRECT_CMD_GET_DISPLAY_PORT";
 432         case WIFI_DIRECT_CMD_GET_DISPLAY_TYPE:
 433                 return "WIFI_DIRECT_CMD_GET_DISPLAY_TYPE";
 434         case WIFI_DIRECT_CMD_ADD_TO_ACCESS_LIST:
 435                 return "WIFI_DIRECT_CMD_ADD_TO_ACCESS_LIST";
 436         case WIFI_DIRECT_CMD_DEL_FROM_ACCESS_LIST:
 437                 return "WIFI_DIRECT_CMD_DEL_FROM_ACCESS_LIST";
 438         default:
 439                 return "WIFI_DIRECT_CMD_INVALID";
 440
 441         }
 442 }
 443
 444 static int __wfd_client_check_socket(int sock, int timeout)
 445 {
 446         struct pollfd p_fd;
 447         int res = 0;
 448
 449         if (sock < SOCK_FD_MIN || timeout < 0) {
 450                 WDC_LOGE("Invalid parameter");
 451                 return -1;
 452         }
 453
 454         p_fd.fd = sock;
 455         p_fd.events = POLLIN | POLLERR | POLLHUP | POLLNVAL;
 456         res = poll((struct pollfd *) &p_fd, 1, timeout);
 457
 458         if (res < 0) {
 459                 WDC_LOGE("Polling error from socket[%d]. [%s]", sock, strerror(errno));
 460                 return -1;
 461         } else if (res == 0) {
 462                 WDC_LOGD( "poll timeout. socket is busy");
 463                 return 1;
 464         } else {
 465                 if (p_fd.revents & POLLERR) {
 466                         WDC_LOGE("Error! POLLERR from socket[%d]", sock);
 467                         return -1;
 468                 } else if (p_fd.revents & POLLHUP) {
 469                         WDC_LOGE("Error! POLLHUP from socket[%d]", sock);
 470                         return -1;
 471                 } else if (p_fd.revents & POLLNVAL) {
 472                         WDC_LOGE("Error! POLLNVAL from socket[%d]", sock);
 473                         return -1;
 474                 } else if (p_fd.revents & POLLIN) {
 475                         WDC_LOGD("POLLIN from socket [%d]", sock);
 476                         return 0;
 477                 }
 478         }
 479
 480         WDC_LOGD("Unknown poll event [%d]", p_fd.revents);
 481         return -1;
 482 }
 483
 484 static int __wfd_client_write_socket(int sockfd, void *data, int data_len)
 485 {
 486         __WDC_LOG_FUNC_START__;
 487         int wbytes = 0;
 488
 489         if (sockfd < SOCK_FD_MIN || !data || data_len <= 0) {
 490                 WDC_LOGE("Invalid parameter");
 491                 __WDC_LOG_FUNC_END__;
 492                 return -1;
 493         }
 494
 495         WDC_LOGD("Write [%d] bytes to socket [%d].", data_len, sockfd);
 496         errno = 0;
 497         wbytes = write(sockfd, (char*) data, data_len);
 498         if (wbytes <= 0) {
 499                 WDC_LOGE("Error!!! writing to the socket. Error = %s", strerror(errno));
 500                 __WDC_LOG_FUNC_END__;
 501                 return -1;
 502         }
 503
 504         __WDC_LOG_FUNC_END__;
 505         return 0;
 506 }
 507
 508 static int __wfd_client_read_socket(int sockfd, char *data, int data_len)
 509 {
 510         __WDC_LOG_FUNC_START__;
 511         int rbytes = 0;
 512         int total_rbytes = 0;
 513         int res = 0;
 514
 515         if (sockfd < SOCK_FD_MIN) {
 516                 WDC_LOGE("Error!!! Invalid socket FD [%d]", sockfd);
 517                 __WDC_LOG_FUNC_END__;
 518                 return -1;
 519         }
 520
 521         if (!data || data_len <= 0) {
 522                 WDC_LOGE("Error!!! Invalid parameter");
 523                 __WDC_LOG_FUNC_END__;
 524                 return -1;
 525         }
 526
 527         res = __wfd_client_check_socket(sockfd, 10000);
 528         if (res < 0) {
 529                 WDC_LOGE("Socket error");
 530                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 531         } else if (res > 0) {
 532                 WDC_LOGE("Socket is busy");
 533                 return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
 534         }
 535
 536         while(data_len) {
 537                 errno = 0;
 538                 rbytes = read(sockfd, data, data_len);
 539                 if (rbytes <= 0) {
 540                         WDC_LOGE("Failed to read socket[%d] [%s]", sockfd, strerror(errno));
 541                         return -1;
 542                 }
 543                 total_rbytes += rbytes;
 544                 data += rbytes;
 545                 data_len -= rbytes;
 546         }
 547
 548         __WDC_LOG_FUNC_END__;
 549         return total_rbytes;
 550 }
 551
 552 static int __wfd_client_send_request(int sockfd, wifi_direct_client_request_s *req,
 553                                                                 wifi_direct_client_response_s *rsp)
 554 {
 555         __WDC_LOG_FUNC_START__;
 556         int res = 0;
 557
 558         if (!req || !rsp || sockfd < SOCK_FD_MIN) {
 559                 WDC_LOGE("Invalid parameter");
 560                 __WDC_LOG_FUNC_END__;
 561                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
 562         }
 563
 564         pthread_mutex_lock(&g_client_info.mutex);
 565         res = __wfd_client_write_socket(sockfd, req, sizeof(wifi_direct_client_request_s));
 566         if (res != WIFI_DIRECT_ERROR_NONE) {
 567                 WDC_LOGE("Failed to write into socket [%s]", __wfd_print_error(res));
 568                 __wfd_reset_control();
 569                 pthread_mutex_unlock(&g_client_info.mutex);
 570                 __WDC_LOG_FUNC_END__;
 571                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 572         }
 573         WDC_LOGD("Succeeded to send request [%d: %s]", req->cmd, __wfd_client_print_cmd(req->cmd));
 574
 575         res = __wfd_client_read_socket(sockfd, rsp, sizeof(wifi_direct_client_response_s));
 576         pthread_mutex_unlock(&g_client_info.mutex);
 577         if (res <= 0) {
 578                 WDC_LOGE("Failed to read socket [%d]", res);
 579                 __wfd_reset_control();
 580                 __WDC_LOG_FUNC_END__;
 581                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 582         } else {
 583                 if (rsp->cmd != req->cmd) {
 584                         WDC_LOGE("Invalid resp [%d], Original request [%d]", rsp->cmd, req->cmd);
 585                         __WDC_LOG_FUNC_END__;
 586                         return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 587                 }
 588
 589                 if (rsp->result != WIFI_DIRECT_ERROR_NONE) {
 590                         WDC_LOGE("Result received [%s]", __wfd_print_error(rsp->result));
 591                         __WDC_LOG_FUNC_END__;
 592                         return rsp->result;
 593                 }
 594         }
 595
 596         __WDC_LOG_FUNC_END__;
 597         return WIFI_DIRECT_ERROR_NONE;
 598 }
 599
 600 static gboolean __wfd_client_process_event(GIOChannel *source,
 601                                                                                    GIOCondition condition,
 602                                                                                    gpointer data)
 603 {
 604         wfd_client_event_e event = WIFI_DIRECT_CLI_EVENT_INVALID;
 605         wifi_direct_client_info_s *client = __wfd_get_control();
 606         int sockfd = client->async_sockfd;
 607         wifi_direct_client_noti_s client_noti;
 608         wifi_direct_error_e error = WIFI_DIRECT_ERROR_NONE;
 609         char param1[64] = { 0, };
 610         char param2[64] = { 0, };
 611         int res = 0;
 612
 613         memset(&client_noti, 0, sizeof(wifi_direct_client_noti_s));
 614
 615         // 1.Read socket
 616         res = __wfd_client_read_socket(sockfd, (char*) &client_noti,
 617                                                                 sizeof(wifi_direct_client_noti_s));
 618         if (res <= 0) {
 619                 WDC_LOGE("Error!!! Reading Async Event[%d]", sockfd);
 620                 __wfd_reset_control();
 621                 __WDC_LOG_FUNC_END__;
 622                 return false;
 623         }
 624         WDC_LOGD( "Received Event is [%d,%s], error[%d]", client_noti.event,
 625                                         __wfd_print_event(client_noti.event), client_noti.error);
 626
 627         event = client_noti.event;
 628         error = client_noti.error;
 629         memcpy(param1, client_noti.param1, sizeof(client_noti.param1));
 630         memcpy(param2, client_noti.param2, sizeof(client_noti.param2));
 631
 632
 633         // 2. dispatch event
 634         switch (event) {
 635         case WIFI_DIRECT_CLI_EVENT_ACTIVATION:
 636         case WIFI_DIRECT_CLI_EVENT_DEACTIVATION:
 637                 if (!client->activation_cb) {
 638                         WDC_LOGE("activation_cb is NULL!!");
 639                         break;
 640                 }
 641                 client->activation_cb(error,
 642                                         (wifi_direct_device_state_e) __wfd_convert_client_event(event),
 643                                         client->user_data_for_cb_activation);
 644                 break;
 645
 646         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START:
 647         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY:
 648         case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN:
 649         case WIFI_DIRECT_CLI_EVENT_DISCOVER_END:
 650         case WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS:
 651                 if (!client->discover_cb) {
 652                         WDC_LOGE("discover_cb is NULL!!");
 653                         break;
 654                 }
 655                 client->discover_cb(error,
 656                                         (wifi_direct_discovery_state_e) __wfd_convert_client_event(event),
 657                                         client->user_data_for_cb_discover);
 658                 break;
 659
 660         case WIFI_DIRECT_CLI_EVENT_CONNECTION_START:
 661         case WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ:
 662         case WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP:
 663         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP:
 664         case WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ:
 665         case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND:
 666         case WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND:
 667         case WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP:
 668         case WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP:
 669         case WIFI_DIRECT_CLI_EVENT_INVITATION_REQ:
 670                 if (!client->connection_cb) {
 671                         WDC_LOGE("connection_cb is NULL!!");
 672                         break;
 673                 }
 674                 client->connection_cb(error,
 675                                         (wifi_direct_connection_state_e) __wfd_convert_client_event(event),
 676                                         param1, client->user_data_for_cb_connection);
 677                 break;
 678
 679         // ToDo:  Handling IP lease event...
 680         case WIFI_DIRECT_CLI_EVENT_IP_LEASED_IND:
 681                 if (!client->ip_assigned_cb) {
 682                         WDC_LOGE("ip_assigned_cb is NULL!!");
 683                         break;
 684                 }
 685                 char *ifname = NULL;
 686                 ifname = vconf_get_str(VCONFKEY_IFNAME);
 687                 if (!ifname) {
 688                         WDC_LOGD("vconf (%s) value is NULL!!!", VCONFKEY_IFNAME);
 689                         break;
 690                 }
 691                 WDC_LOGD("VCONFKEY_IFNAME(%s) : %s", VCONFKEY_IFNAME, ifname);
 692                 client->ip_assigned_cb(param1, param2, ifname,
 693                                         client->user_data_for_cb_ip_assigned);
 694                 free(ifname);
 695                 break;
 696
 697         default:
 698                 break;
 699         }
 700
 701         __WDC_LOG_FUNC_END__;
 702
 703         return TRUE;
 704 }
 705
 706 void __wfd_client_print_entry_list(wfd_discovery_entry_s *list, int num)
 707 {
 708         int i = 0;
 709
 710         WDC_LOGD("------------------------------------------");
 711         for (i = 0; i < num; i++)
 712         {
 713                 WDC_LOGD("== Peer index : %d ==", i);
 714                 WDC_LOGD("is Group Owner ? %s", list[i].is_group_owner ? "YES" : "NO");
 715                 WDC_LOGD("device_name : %s", list[i].device_name);
 716                 WDC_LOGD("MAC address : "MACSTR, MAC2STR(list[i].mac_address));
 717                 WDC_LOGD("wps cfg method : %x", list[i].wps_cfg_methods);
 718         }
 719         WDC_LOGD("------------------------------------------");
 720 }
 721
 722 void __wfd_client_print_connected_peer_info(wfd_connected_peer_info_s *list, int num)
 723 {
 724         int i = 0;
 725
 726         WDC_LOGD("------------------------------------------\n");
 727         for (i = 0; i < num; i++)
 728         {
 729                 WDC_LOGD("== Peer index : %d ==\n", i);
 730                 WDC_LOGD("device_name : %s\n", list[i].device_name);
 731                 WDC_LOGD("Device MAC : " MACSTR "\n", MAC2STR(list[i].mac_address));
 732                 WDC_LOGD("Interface MAC : " MACSTR "\n", MAC2STR(list[i].intf_address));
 733                 WDC_LOGD("services : %d\n", list[i].services);
 734                 WDC_LOGD("is_p2p : %d\n", list[i].is_p2p);
 735                 WDC_LOGD("category : %d\n", list[i].category);
 736                 WDC_LOGD("channel : %d\n", list[i].channel);
 737                 WDC_LOGD("IP ["IPSTR"]\n", IP2STR(list[i].ip_address));
 738         }
 739         WDC_LOGD("------------------------------------------\n");
 740 }
 741
 742 void __wfd_client_print_persistent_group_info(wfd_persistent_group_info_s *list, int num)
 743 {
 744         int i = 0;
 745
 746         WDC_LOGD("------------------------------------------\n");
 747         for (i = 0; i < num; i++)
 748         {
 749                 WDC_LOGD("== Persistent Group index : %d ==\n", i);
 750                 WDC_LOGD("ssid : %s\n", list[i].ssid);
 751                 WDC_LOGD("GO MAC : " MACSTR "\n",
 752                                            MAC2STR(list[i].go_mac_address));
 753         }
 754         WDC_LOGD("------------------------------------------\n");
 755 }
 756
 757 static int __wfd_client_async_event_init(int clientid)
 758 {
 759         __WDC_LOG_FUNC_START__;
 760         int sockfd = 0;
 761         struct sockaddr_un saddr;
 762         wifi_direct_client_info_s *client_info = __wfd_get_control();
 763         wifi_direct_client_request_s req;
 764         int res = 0;
 765
 766         errno = 0;
 767         sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
 768         if (sockfd < 0) {
 769                 WDC_LOGE("Failed to async socket[%s]", strerror(errno));
 770                 __WDC_LOG_FUNC_END__;
 771                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 772         }
 773         WDC_LOGD("Succeeded to create async socket[%d]", sockfd);
 774
 775         memset(&saddr, 0, sizeof(saddr));
 776         saddr.sun_family = AF_UNIX;
 777         snprintf(saddr.sun_path, sizeof(saddr.sun_path), WFD_SOCK_FILE_PATH);
 778
 779         WDC_LOGD("Connecting to server socket to register async socket [%d]", sockfd);
 780         errno = 0;
 781         res = connect(sockfd, (struct sockaddr *) &saddr, sizeof(saddr));
 782         if (res < 0) {
 783                 WDC_LOGE("Error!!! connecting to server socket. Error = [%s].", strerror(errno));
 784                 close(sockfd);
 785                 __WDC_LOG_FUNC_END__;
 786                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 787         }
 788
 789         memset(&req, 0, sizeof(wifi_direct_client_request_s));
 790
 791         req.cmd = WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET;
 792         req.client_id = clientid;
 793
 794         res = __wfd_client_write_socket(sockfd, &req, sizeof(wifi_direct_client_request_s));
 795         if (res < WIFI_DIRECT_ERROR_NONE) {
 796                 WDC_LOGE("Failed to write to socket[%s]", strerror(errno));
 797                 WDC_LOGE("Error!!! [%s]", __wfd_print_error(res));
 798                 close(sockfd);
 799                 __WDC_LOG_FUNC_END__;
 800                 return res;
 801         }
 802         client_info->async_sockfd = sockfd;
 803
 804         WDC_LOGE("Async socket is created= %d", sockfd);
 805
 806         return sockfd;
 807 }
 808
 809 static gboolean wfd_client_execute_file(const char *file_path,
 810         char *const args[], char *const envs[])
 811 {
 812         pid_t pid = 0;
 813         int rv = 0;
 814         errno = 0;
 815         register unsigned int index = 0;
 816
 817         while (args[index] != NULL) {
 818                 WDC_LOGD("[%s]", args[index]);
 819                 index++;
 820         }
 821
 822         if (!(pid = fork())) {
 823                 WDC_LOGD("pid(%d), ppid(%d)", getpid(), getppid());
 824                 WDC_LOGD("Inside child, exec (%s) command", file_path);
 825
 826                 errno = 0;
 827                 if (execve(file_path, args, envs) == -1) {
 828                         WDC_LOGE("Fail to execute command (%s)", strerror(errno));
 829                         exit(1);
 830                 }
 831         } else if (pid > 0) {
 832                 if (waitpid(pid, &rv, 0) == -1)
 833                         WDC_LOGD("wait pid (%u) rv (%d)", pid, rv);
 834                 if (WIFEXITED(rv)) {
 835                         WDC_LOGD("exited, rv=%d", WEXITSTATUS(rv));
 836                 } else if (WIFSIGNALED(rv)) {
 837                         WDC_LOGD("killed by signal %d", WTERMSIG(rv));
 838                 } else if (WIFSTOPPED(rv)) {
 839                         WDC_LOGD("stopped by signal %d", WSTOPSIG(rv));
 840                 } else if (WIFCONTINUED(rv)) {
 841                         WDC_LOGD("continued");
 842                 }
 843
 844                 return TRUE;
 845         }
 846
 847         WDC_LOGE("failed to fork (%s)", strerror(errno));
 848         return FALSE;
 849 }
 850
 851 static int __wfd_client_launch_server_dbus(void)
 852 {
 853         gboolean rv = FALSE;
 854         const char *path = "/usr/bin/dbus-send";
 855         char *const args[] = { "/usr/bin/dbus-send", "--system", "--print-reply", "--dest=net.netconfig", "/net/netconfig/wifi", "net.netconfig.wifi.LaunchDirect", NULL };
 856         char *const envs[] = { NULL };
 857
 858         rv = wfd_client_execute_file(path, args, envs);
 859
 860         if (rv != TRUE) {
 861                 WDC_LOGE("Failed to launch wfd-manager");
 862                 return -1;
 863         }
 864
 865         WDC_LOGD("Successfully launched wfd-manager");
 866         return 0;
 867 }
 868
 869 int wifi_direct_initialize(void)
 870 {
 871         __WDC_LOG_FUNC_START__;
 872         struct sockaddr_un saddr;
 873         wifi_direct_client_info_s *client_info = __wfd_get_control();
 874         wifi_direct_client_request_s req;
 875         wifi_direct_client_response_s resp;
 876         int retry_count = 3;
 877         int sockfd = 0;
 878         int res = 0;
 879
 880         if (client_info->is_registered == TRUE) {
 881                 WDC_LOGW("Warning!!! Already registered\nUpdate user data and callback!");
 882                 __WDC_LOG_FUNC_END__;
 883                 return WIFI_DIRECT_ERROR_NONE;
 884         }
 885
 886         errno = 0;
 887         sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
 888         if (sockfd < SOCK_FD_MIN) {
 889                 WDC_LOGE("Error!!! creating sync socket[%s]", strerror(errno));
 890                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 891         }
 892         WDC_LOGD("Created sync socket [%d]", sockfd);
 893
 894         memset(&saddr, 0, sizeof(saddr));
 895         saddr.sun_family = AF_UNIX;
 896         snprintf(saddr.sun_path, sizeof(saddr.sun_path), WFD_SOCK_FILE_PATH);
 897
 898         WDC_LOGD("Connecting to server socket to register sync socket [%d]", sockfd);
 899         while (retry_count > 0) {
 900                 errno = 0;
 901                 res = connect(sockfd, (struct sockaddr*) &saddr, sizeof(saddr));
 902                 if (!res){
 903                         WDC_LOGD("Succeeded to connect to server socket");
 904                         break;
 905                 }
 906
 907                 WDC_LOGD("Launching wfd-server..\n");
 908                 res = __wfd_client_launch_server_dbus();
 909                 if (res == -1)
 910                         WDC_LOGE("Failed to send dbus msg[%s]", strerror(errno));
 911                 retry_count--;
 912
 913                 /* wait a little before retrying the next socket connection */
 914                 usleep(100000);
 915         }
 916
 917         if (res < 0) {
 918                 WDC_LOGE("Failed to connect to server[%s]", strerror(errno));
 919                 if (sockfd > SOCK_FD_MIN)
 920                         close(sockfd);
 921                 __WDC_LOG_FUNC_END__;
 922                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 923         }
 924
 925         memset(&req, 0, sizeof(wifi_direct_client_request_s));
 926         memset(&resp, 0, sizeof(wifi_direct_client_response_s));
 927
 928         req.cmd = WIFI_DIRECT_CMD_REGISTER;
 929         req.client_id = gettid();
 930         WDC_LOGD("Client ID = %d", req.client_id);
 931
 932         res = __wfd_client_send_request(sockfd, &req, &resp);
 933         if (res < 0) {
 934                 __WDC_LOG_FUNC_END__;
 935                 return res;
 936         } else {
 937                 client_info->sync_sockfd = sockfd;
 938                 client_info->client_id = resp.client_id;
 939                 client_info->is_registered = TRUE;
 940         }
 941
 942         int async_sockfd = -1;
 943         async_sockfd = __wfd_client_async_event_init(client_info->client_id);
 944         if (async_sockfd < 0) {
 945                 WDC_LOGE("Failed to create async socket \n");
 946                 if (sockfd > 0)
 947                         close(sockfd);
 948                 __wfd_reset_control();
 949                 __WDC_LOG_FUNC_END__;
 950                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
 951         }
 952         client_info->async_sockfd = async_sockfd;
 953
 954         GIOChannel *gio = g_io_channel_unix_new(client_info->async_sockfd);
 955         int g_source_id = g_io_add_watch(gio, G_IO_IN | G_IO_ERR | G_IO_HUP,
 956                                                         (GIOFunc) __wfd_client_process_event, NULL);
 957         g_io_channel_unref(gio);
 958
 959         client_info->g_source_id = g_source_id;
 960
 961         // Initialize callbacks
 962         client_info->activation_cb = NULL;
 963         client_info->discover_cb = NULL;
 964         client_info->connection_cb = NULL;
 965         client_info->ip_assigned_cb = NULL;
 966         client_info->user_data_for_cb_activation = NULL;
 967         client_info->user_data_for_cb_discover = NULL;
 968         client_info->user_data_for_cb_connection = NULL;
 969         client_info->user_data_for_cb_ip_assigned = NULL;
 970
 971         __WDC_LOG_FUNC_END__;
 972         return WIFI_DIRECT_ERROR_NONE;
 973 }
 974
 975 int wifi_direct_deinitialize(void)
 976 {
 977         __WDC_LOG_FUNC_START__;
 978         wifi_direct_client_info_s *client_info = __wfd_get_control();
 979
 980         if (client_info->is_registered == false) {
 981                 WDC_LOGE("Client is already deregistered");
 982                 __WDC_LOG_FUNC_END__;
 983                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 984         }
 985
 986         client_info->activation_cb = NULL;
 987         client_info->discover_cb = NULL;
 988         client_info->connection_cb = NULL;
 989         client_info->ip_assigned_cb = NULL;
 990         client_info->user_data_for_cb_activation = NULL;
 991         client_info->user_data_for_cb_discover = NULL;
 992         client_info->user_data_for_cb_connection = NULL;
 993         client_info->user_data_for_cb_ip_assigned = NULL;
 994
 995         wifi_direct_client_request_s req;
 996         wifi_direct_client_response_s rsp;
 997         int res = WIFI_DIRECT_ERROR_NONE;
 998
 999         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1000         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1001
1002         req.cmd = WIFI_DIRECT_CMD_DEREGISTER;
1003         req.client_id = client_info->client_id;
1004
1005         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1006         if (res < 0)
1007                 WDC_LOGD("Failed to deinitialize. But continue deinitialization");
1008         else
1009                 WDC_LOGD("Deinit Successfull");
1010
1011         __wfd_reset_control();
1012         __WDC_LOG_FUNC_END__;
1013         return WIFI_DIRECT_ERROR_NONE;
1014 }
1015
1016
1017 int wifi_direct_set_device_state_changed_cb(wifi_direct_device_state_changed_cb cb,
1018                                                                                                 void *user_data)
1019 {
1020         __WDC_LOG_FUNC_START__;
1021         wifi_direct_client_info_s *client_info = __wfd_get_control();
1022
1023         if (!cb) {
1024                 WDC_LOGE("Invalid parameter");
1025                 __WDC_LOG_FUNC_END__;
1026                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1027         }
1028
1029         if (client_info->is_registered == false) {
1030                 WDC_LOGE("Client is not initialized.");
1031                 __WDC_LOG_FUNC_END__;
1032                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1033         }
1034
1035         client_info->activation_cb = cb;
1036         client_info->user_data_for_cb_activation = user_data;
1037
1038         __WDC_LOG_FUNC_END__;
1039         return WIFI_DIRECT_ERROR_NONE;
1040 }
1041
1042
1043 int wifi_direct_unset_device_state_changed_cb(void)
1044 {
1045         __WDC_LOG_FUNC_START__;
1046         wifi_direct_client_info_s *client_info = __wfd_get_control();
1047
1048         if (client_info->is_registered == false) {
1049                 WDC_LOGE("Client is not initialized.\n");
1050                 __WDC_LOG_FUNC_END__;
1051                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1052         }
1053
1054         client_info->activation_cb = NULL;
1055         client_info->user_data_for_cb_activation = NULL;
1056
1057         __WDC_LOG_FUNC_END__;
1058         return WIFI_DIRECT_ERROR_NONE;
1059 }
1060
1061
1062 int
1063 wifi_direct_set_discovery_state_changed_cb(wifi_direct_discovery_state_chagned_cb cb,
1064                                                                                                 void *user_data)
1065 {
1066         __WDC_LOG_FUNC_START__;
1067         wifi_direct_client_info_s *client_info = __wfd_get_control();
1068
1069         if (!cb) {
1070                 WDC_LOGE("Callback is NULL.\n");
1071                 __WDC_LOG_FUNC_END__;
1072                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1073         }
1074
1075         if (client_info->is_registered == false) {
1076                 WDC_LOGE("Client is not initialized.\n");
1077                 __WDC_LOG_FUNC_END__;
1078                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1079         }
1080
1081         client_info->discover_cb = cb;
1082         client_info->user_data_for_cb_discover = user_data;
1083
1084         __WDC_LOG_FUNC_END__;
1085         return WIFI_DIRECT_ERROR_NONE;
1086 }
1087
1088
1089 int wifi_direct_unset_discovery_state_changed_cb(void)
1090 {
1091         __WDC_LOG_FUNC_START__;
1092         wifi_direct_client_info_s *client_info = __wfd_get_control();
1093
1094         if (client_info->is_registered == false) {
1095                 WDC_LOGE("Client is not initialized.\n");
1096                 __WDC_LOG_FUNC_END__;
1097                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1098         }
1099
1100         client_info->discover_cb = NULL;
1101         client_info->user_data_for_cb_discover = NULL;
1102
1103         __WDC_LOG_FUNC_END__;
1104         return WIFI_DIRECT_ERROR_NONE;
1105 }
1106
1107
1108 int wifi_direct_set_connection_state_changed_cb(wifi_direct_connection_state_changed_cb cb,
1109                                                                                                 void *user_data)
1110 {
1111         __WDC_LOG_FUNC_START__;
1112         wifi_direct_client_info_s *client_info = __wfd_get_control();
1113
1114         if (!cb) {
1115                 WDC_LOGE("Callback is NULL.\n");
1116                 __WDC_LOG_FUNC_END__;
1117                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1118         }
1119
1120         if (client_info->is_registered == false) {
1121                 WDC_LOGE("Client is not initialized.\n");
1122                 __WDC_LOG_FUNC_END__;
1123                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1124         }
1125
1126         client_info->connection_cb = cb;
1127         client_info->user_data_for_cb_connection = user_data;
1128
1129         __WDC_LOG_FUNC_END__;
1130         return WIFI_DIRECT_ERROR_NONE;
1131 }
1132
1133
1134 int wifi_direct_unset_connection_state_changed_cb(void)
1135 {
1136         __WDC_LOG_FUNC_START__;
1137         wifi_direct_client_info_s *client_info = __wfd_get_control();
1138
1139         if (client_info->is_registered == false) {
1140                 WDC_LOGE("Client is not initialized");
1141                 __WDC_LOG_FUNC_END__;
1142                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1143         }
1144
1145         client_info->connection_cb = NULL;
1146         client_info->user_data_for_cb_connection = NULL;
1147
1148         __WDC_LOG_FUNC_END__;
1149         return WIFI_DIRECT_ERROR_NONE;
1150 }
1151
1152
1153 int wifi_direct_set_client_ip_address_assigned_cb(wifi_direct_client_ip_address_assigned_cb cb,
1154                                                                                                 void* user_data)
1155 {
1156         __WDC_LOG_FUNC_START__;
1157         wifi_direct_client_info_s *client_info = __wfd_get_control();
1158
1159         if (!cb) {
1160                 WDC_LOGE("Callback is NULL");
1161                 __WDC_LOG_FUNC_END__;
1162                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1163         }
1164
1165         if (client_info->is_registered == false) {
1166                 WDC_LOGE("Client is not initialized");
1167                 __WDC_LOG_FUNC_END__;
1168                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1169         }
1170
1171         client_info->ip_assigned_cb = cb;
1172         client_info->user_data_for_cb_ip_assigned = user_data;
1173
1174         __WDC_LOG_FUNC_END__;
1175         return WIFI_DIRECT_ERROR_NONE;
1176 }
1177
1178 int wifi_direct_unset_client_ip_address_assigned_cb(void)
1179 {
1180         __WDC_LOG_FUNC_START__;
1181         wifi_direct_client_info_s *client_info = __wfd_get_control();
1182
1183         if (client_info->is_registered == false) {
1184                 WDC_LOGE("Client is not initialized");
1185                 __WDC_LOG_FUNC_END__;
1186                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1187         }
1188
1189         client_info->ip_assigned_cb = NULL;
1190         client_info->user_data_for_cb_ip_assigned = NULL;
1191
1192         __WDC_LOG_FUNC_END__;
1193         return WIFI_DIRECT_ERROR_NONE;
1194 }
1195
1196
1197 int wifi_direct_activate(void)
1198 {
1199         __WDC_LOG_FUNC_START__;
1200         wifi_direct_client_info_s *client_info = __wfd_get_control();
1201         wifi_direct_client_request_s req;
1202         wifi_direct_client_response_s rsp;
1203         int res = WIFI_DIRECT_ERROR_NONE;
1204
1205         if ((client_info->is_registered == false) ||
1206                         (client_info->client_id == WFD_INVALID_ID)) {
1207                 WDC_LOGE("Client is NOT registered");
1208                 __WDC_LOG_FUNC_END__;
1209                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1210         }
1211
1212         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1213         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1214
1215         req.cmd = WIFI_DIRECT_CMD_ACTIVATE;
1216         req.client_id = client_info->client_id;
1217
1218         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1219         if (res != WIFI_DIRECT_ERROR_NONE) {
1220                 __WDC_LOG_FUNC_END__;
1221                 return res;
1222         }
1223         WDC_LOGD("wifi_direct_activate() SUCCESS");
1224
1225         __WDC_LOG_FUNC_END__;
1226         return WIFI_DIRECT_ERROR_NONE;
1227 }
1228
1229 int wifi_direct_deactivate(void)
1230 {
1231         __WDC_LOG_FUNC_START__;
1232         wifi_direct_client_info_s *client_info = __wfd_get_control();
1233         wifi_direct_client_request_s req;
1234         wifi_direct_client_response_s rsp;
1235         int res = WIFI_DIRECT_ERROR_NONE;
1236
1237         if ((client_info->is_registered == false) ||
1238                         (client_info->client_id == WFD_INVALID_ID)) {
1239                 WDC_LOGE("Client is NOT registered");
1240                 __WDC_LOG_FUNC_END__;
1241                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1242         }
1243
1244         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1245         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1246
1247         req.cmd = WIFI_DIRECT_CMD_DEACTIVATE;
1248         req.client_id = client_info->client_id;
1249
1250         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1251         if (res != WIFI_DIRECT_ERROR_NONE) {
1252                 __WDC_LOG_FUNC_END__;
1253                 return res;
1254         }
1255         WDC_LOGD("wifi_direct_deactivate() SUCCESS");
1256
1257         __WDC_LOG_FUNC_END__;
1258         return WIFI_DIRECT_ERROR_NONE;
1259 }
1260
1261 int wifi_direct_start_discovery(bool listen_only, int timeout)
1262 {
1263         __WDC_LOG_FUNC_START__;
1264         wifi_direct_client_info_s *client_info = __wfd_get_control();
1265         wifi_direct_client_request_s req;
1266         wifi_direct_client_response_s rsp;
1267         int res = WIFI_DIRECT_ERROR_NONE;
1268
1269         if ((client_info->is_registered == false) ||
1270                         (client_info->client_id == WFD_INVALID_ID)) {
1271                 WDC_LOGE("Client is NOT registered");
1272                 __WDC_LOG_FUNC_END__;
1273                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1274         }
1275
1276         if (timeout < 0) {
1277                 WDC_LOGE("Nagative value. Param [timeout]!");
1278                 __WDC_LOG_FUNC_END__;
1279                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1280         }
1281
1282         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1283         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1284
1285         req.cmd = WIFI_DIRECT_CMD_START_DISCOVERY;
1286         req.client_id = client_info->client_id;
1287         req.data.int1 = listen_only;
1288         req.data.int2 = timeout;
1289         WDC_LOGE("listen only (%d) timeout (%d)",
1290                                    listen_only, timeout);
1291
1292         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1293         if (res != WIFI_DIRECT_ERROR_NONE) {
1294                 __WDC_LOG_FUNC_END__;
1295                 return res;
1296         }
1297         WDC_LOGD("wifi_direct_start_discovery() SUCCESS");
1298
1299         __WDC_LOG_FUNC_END__;
1300         return WIFI_DIRECT_ERROR_NONE;
1301 }
1302
1303 int wifi_direct_cancel_discovery(void)
1304 {
1305         __WDC_LOG_FUNC_START__;
1306         wifi_direct_client_info_s *client_info = __wfd_get_control();
1307         wifi_direct_client_request_s req;
1308         wifi_direct_client_response_s rsp;
1309         int res = WIFI_DIRECT_ERROR_NONE;
1310
1311         if ((client_info->is_registered == false) ||
1312                         (client_info->client_id == WFD_INVALID_ID)) {
1313                 WDC_LOGE("Client is NOT registered");
1314                 __WDC_LOG_FUNC_END__;
1315                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1316         }
1317
1318         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1319         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1320
1321         req.cmd = WIFI_DIRECT_CMD_CANCEL_DISCOVERY;
1322         req.client_id = client_info->client_id;
1323
1324         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1325         if (res != WIFI_DIRECT_ERROR_NONE) {
1326                 __WDC_LOG_FUNC_END__;
1327                 return res;
1328         }
1329         WDC_LOGD("wifi_direct_cancel_discovery() SUCCESS");
1330
1331         __WDC_LOG_FUNC_END__;
1332         return WIFI_DIRECT_ERROR_NONE;
1333 }
1334
1335 static char **get_service_list(char *services, unsigned int *count)
1336 {
1337         __WDC_LOG_FUNC_START__;
1338         char **result = NULL;
1339         char *pos1 = services;
1340         char *pos2 = strdup(services);
1341         unsigned int cnt = 0;
1342         unsigned int i = 0;
1343         unsigned int j = 0;
1344
1345         if (!count || !services ||      (services && strlen(services) <= 0)) {
1346                 WDC_LOGE("Invalid parameters.");
1347                 __WDC_LOG_FUNC_END__;
1348                 return NULL;
1349         }
1350
1351         pos1 = strtok (pos1,",\n");
1352         while (pos1) {
1353                 cnt++;
1354                 pos1 = strtok (NULL, ",\n");
1355         }
1356         WDC_LOGD("Total Service Count = %d", cnt);
1357
1358         if (cnt > 0) {
1359                 result = (char**) calloc(cnt, sizeof(char *));
1360                 if (!result) {
1361                         WDC_LOGE("Failed to allocate memory for result");
1362                         return NULL;
1363                 }
1364                 pos1 = pos2;
1365                 pos2 = strtok (pos2,",\n");
1366                 while (pos2 != NULL) {
1367                         char *s = strchr(pos2, ' ');
1368                         if (s) {
1369                                 *s = '\0';
1370                                 result[i++] = strdup(pos2);
1371                                 pos2 = strtok (NULL, ",\n");
1372                         }
1373                 }
1374         }
1375
1376         free(pos1);
1377         if (cnt == i) {
1378                 *count = cnt;
1379                 return result;
1380         } else {
1381                 *count = 0;
1382                 if (result) {
1383                         for (j=0; j<i && result[j] != NULL; j++)
1384                                 free(result[j]);
1385                         free(result);
1386                 }
1387                 return NULL;
1388         }
1389 }
1390
1391 int wifi_direct_foreach_discovered_peers(wifi_direct_discovered_peer_cb cb,
1392                                                                                                 void *user_data)
1393 {
1394         __WDC_LOG_FUNC_START__;
1395         wifi_direct_client_info_s *client_info = __wfd_get_control();
1396         wifi_direct_client_request_s req;
1397         wifi_direct_client_response_s rsp;
1398         int res = WIFI_DIRECT_ERROR_NONE;
1399         int i;
1400
1401         if ((client_info->is_registered == false) ||
1402                         (client_info->client_id == WFD_INVALID_ID)) {
1403                 WDC_LOGE("Client is NOT registered");
1404                 __WDC_LOG_FUNC_END__;
1405                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1406         }
1407
1408         if (!cb) {
1409                 WDC_LOGE("NULL Param [callback]!");
1410                 __WDC_LOG_FUNC_END__;
1411                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1412         }
1413
1414         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1415         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1416
1417         req.cmd = WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT;
1418         req.client_id = client_info->client_id;
1419
1420         pthread_mutex_lock(&g_client_info.mutex);
1421         res = __wfd_client_write_socket(client_info->sync_sockfd, &req, sizeof(wifi_direct_client_request_s));
1422         if (res != WIFI_DIRECT_ERROR_NONE) {
1423                 WDC_LOGE("Failed to write into socket [%s]", __wfd_print_error(res));
1424                 __wfd_reset_control();
1425                 pthread_mutex_unlock(&g_client_info.mutex);
1426                 __WDC_LOG_FUNC_END__;
1427                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1428         }
1429         WDC_LOGD("Succeeded to send request [%d: %s]", req.cmd, __wfd_client_print_cmd(req.cmd));
1430
1431         res = __wfd_client_read_socket(client_info->sync_sockfd, &rsp, sizeof(wifi_direct_client_response_s));
1432         if (res <= 0) {
1433                 WDC_LOGE("Failed to read socket [%d]", res);
1434                 __wfd_reset_control();
1435                 pthread_mutex_unlock(&g_client_info.mutex);
1436                 __WDC_LOG_FUNC_END__;
1437                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1438         } else {
1439                 if (rsp.cmd != req.cmd) {
1440                         WDC_LOGE("Invalid resp [%d]", rsp.cmd);
1441                         pthread_mutex_unlock(&g_client_info.mutex);
1442                         __WDC_LOG_FUNC_END__;
1443                         return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1444                 }
1445
1446                 if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
1447                         WDC_LOGE("Result received [%s]", __wfd_print_error(rsp.result));
1448                         pthread_mutex_unlock(&g_client_info.mutex);
1449                         __WDC_LOG_FUNC_END__;
1450                         return rsp.result;
1451                 }
1452         }
1453
1454         int num = rsp.param1;
1455         wfd_discovery_entry_s *buff = NULL;
1456
1457         WDC_LOGD("Num of found peers = %d", num);
1458
1459         if (num > 0) {
1460                 buff = (wfd_discovery_entry_s*) calloc(num, sizeof (wfd_discovery_entry_s));
1461                 if (!buff) {
1462                         WDC_LOGE("Failed to alloc memory");
1463                         pthread_mutex_unlock(&g_client_info.mutex);
1464                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1465                 }
1466
1467                 res = __wfd_client_read_socket(client_info->sync_sockfd, (char*) buff,
1468                                                                 num * sizeof(wfd_discovery_entry_s));
1469                 pthread_mutex_unlock(&g_client_info.mutex);
1470                 if (res <= 0) {
1471                         free(buff);
1472                         WDC_LOGE("Failed to read socket");
1473                         __wfd_reset_control();
1474                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1475                 }
1476
1477                 __wfd_client_print_entry_list(buff, num);
1478                 WDC_LOGD("wifi_direct_foreach_discovered_peers() SUCCESS");
1479
1480                 wifi_direct_discovered_peer_info_s *peer_list;
1481
1482                 for (i = 0; i < num; i++) {
1483                         peer_list = (wifi_direct_discovered_peer_info_s *) calloc(1, sizeof(wifi_direct_discovered_peer_info_s));
1484                         peer_list->device_name = strdup(buff[i].device_name);
1485                         peer_list->mac_address = (char*) calloc(1, MACSTR_LEN);
1486                         snprintf(peer_list->mac_address, MACSTR_LEN, MACSTR, MAC2STR(buff[i].mac_address));
1487                         peer_list->channel = buff[i].channel;
1488                         peer_list->is_connected = buff[i].is_connected;
1489                         peer_list->is_group_owner = buff[i].is_group_owner;
1490                         peer_list->is_persistent_group_owner = buff[i].is_persistent_go;
1491                         peer_list->interface_address = (char*) calloc(1, MACSTR_LEN);
1492                         snprintf(peer_list->interface_address, MACSTR_LEN, MACSTR, MAC2STR(buff[i].intf_address));
1493                         peer_list->supported_wps_types= buff[i].wps_cfg_methods;
1494                         peer_list->service_list = get_service_list(buff[i].services, &peer_list->service_count);
1495                         peer_list->primary_device_type = buff[i].category;
1496                         peer_list->is_wfd_device = buff[i].is_wfd_device;
1497
1498                         if (!cb(peer_list, user_data))
1499                                 break;
1500                 }
1501
1502                 if (buff)
1503                         free(buff);
1504         } else {
1505                 pthread_mutex_unlock(&g_client_info.mutex);
1506         }
1507
1508         __WDC_LOG_FUNC_END__;
1509         return WIFI_DIRECT_ERROR_NONE;
1510 }
1511
1512 int wifi_direct_connect(const char *mac_address)
1513 {
1514         __WDC_LOG_FUNC_START__;
1515         wifi_direct_client_info_s *client_info = __wfd_get_control();
1516         unsigned char la_mac_addr[6];
1517         wifi_direct_client_request_s req;
1518         wifi_direct_client_response_s rsp;
1519         int res = WIFI_DIRECT_ERROR_NONE;
1520
1521         if ((client_info->is_registered == false) ||
1522                         (client_info->client_id == WFD_INVALID_ID)) {
1523                 WDC_LOGE("Client is NOT registered");
1524                 __WDC_LOG_FUNC_END__;
1525                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1526         }
1527
1528         if (!mac_address) {
1529                 WDC_LOGE("mac_addr is NULL");
1530                 __WDC_LOG_FUNC_END__;
1531                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1532         }
1533
1534         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1535         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1536
1537         req.cmd = WIFI_DIRECT_CMD_CONNECT;
1538         req.client_id = client_info->client_id;
1539         macaddr_atoe(mac_address, la_mac_addr);
1540         memcpy(req.data.mac_addr, la_mac_addr, MACADDR_LEN);
1541
1542         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1543         if (res != WIFI_DIRECT_ERROR_NONE) {
1544                 __WDC_LOG_FUNC_END__;
1545                 return res;
1546         }
1547         WDC_LOGD("wifi_direct_connect() SUCCESS");
1548
1549         __WDC_LOG_FUNC_END__;
1550         return WIFI_DIRECT_ERROR_NONE;
1551 }
1552
1553 int wifi_direct_cancel_connection(const char *mac_address)
1554 {
1555         __WDC_LOG_FUNC_START__;
1556         wifi_direct_client_info_s *client_info = __wfd_get_control();
1557         wifi_direct_client_request_s req;
1558         wifi_direct_client_response_s rsp;
1559         int res = WIFI_DIRECT_ERROR_NONE;
1560
1561         if ((client_info->is_registered == false)
1562                 || (client_info->client_id == WFD_INVALID_ID))
1563         {
1564                 WDC_LOGE("Client is NOT registered.");
1565                 __WDC_LOG_FUNC_END__;
1566                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1567         }
1568
1569         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1570         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1571
1572         req.cmd = WIFI_DIRECT_CMD_CANCEL_CONNECTION;
1573         req.client_id = client_info->client_id;
1574         macaddr_atoe(mac_address, req.data.mac_addr);
1575
1576         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1577         if (res != WIFI_DIRECT_ERROR_NONE) {
1578                 __WDC_LOG_FUNC_END__;
1579                 return res;
1580         }
1581         WDC_LOGD("wifi_direct_cancel_connect() SUCCESS");
1582
1583         __WDC_LOG_FUNC_END__;
1584         return WIFI_DIRECT_ERROR_NONE;
1585 }
1586
1587
1588 int wifi_direct_reject_connection(const char *mac_address)
1589 {
1590         __WDC_LOG_FUNC_START__;
1591         wifi_direct_client_info_s *client_info = __wfd_get_control();
1592         wifi_direct_client_request_s req;
1593         wifi_direct_client_response_s rsp;
1594         int res = WIFI_DIRECT_ERROR_NONE;
1595
1596         if ((client_info->is_registered == false) ||
1597                         (client_info->client_id == WFD_INVALID_ID)) {
1598                 WDC_LOGE("Client is NOT registered");
1599                 __WDC_LOG_FUNC_END__;
1600                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1601         }
1602
1603         if (!mac_address) {
1604                 WDC_LOGE("mac_addr is NULL");
1605                 __WDC_LOG_FUNC_END__;
1606                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1607         }
1608
1609         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1610         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1611
1612         req.cmd = WIFI_DIRECT_CMD_REJECT_CONNECTION;
1613         req.client_id = client_info->client_id;
1614         macaddr_atoe(mac_address, req.data.mac_addr);
1615
1616         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1617         if (res != WIFI_DIRECT_ERROR_NONE) {
1618                 __WDC_LOG_FUNC_END__;
1619                 return res;
1620         }
1621         WDC_LOGE("wifi_direct_reject_connection() SUCCESS");
1622
1623         __WDC_LOG_FUNC_END__;
1624         return WIFI_DIRECT_ERROR_NONE;
1625 }
1626
1627
1628 int wifi_direct_disconnect_all(void)
1629 {
1630         __WDC_LOG_FUNC_START__;
1631         wifi_direct_client_info_s *client_info = __wfd_get_control();
1632         wifi_direct_client_request_s req;
1633         wifi_direct_client_response_s rsp;
1634         int res = WIFI_DIRECT_ERROR_NONE;
1635
1636         if ((client_info->is_registered == false) ||
1637                         (client_info->client_id == WFD_INVALID_ID)) {
1638                 WDC_LOGE("Client is NOT registered");
1639                 __WDC_LOG_FUNC_END__;
1640                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1641         }
1642
1643         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1644         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1645
1646         req.cmd = WIFI_DIRECT_CMD_DISCONNECT_ALL;
1647         req.client_id = client_info->client_id;
1648
1649         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1650         if (res != WIFI_DIRECT_ERROR_NONE) {
1651                 __WDC_LOG_FUNC_END__;
1652                 return res;
1653         }
1654         WDC_LOGE("wifi_direct_disconnect_all() SUCCESS");
1655
1656         __WDC_LOG_FUNC_END__;
1657         return WIFI_DIRECT_ERROR_NONE;
1658 }
1659
1660
1661 int wifi_direct_disconnect(const char *mac_address)
1662 {
1663         __WDC_LOG_FUNC_START__;
1664         wifi_direct_client_info_s *client_info = __wfd_get_control();
1665         unsigned char la_mac_addr[6];
1666         wifi_direct_client_request_s req;
1667         wifi_direct_client_response_s rsp;
1668         int res = WIFI_DIRECT_ERROR_NONE;
1669
1670         if ((client_info->is_registered == false) ||
1671                         (client_info->client_id == WFD_INVALID_ID)) {
1672                 WDC_LOGE("Client is NOT registered");
1673                 __WDC_LOG_FUNC_END__;
1674                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1675         }
1676
1677         if (!mac_address) {
1678                 WDC_LOGE("mac_address is NULL");
1679                 __WDC_LOG_FUNC_END__;
1680                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1681         }
1682
1683         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1684         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1685
1686         req.cmd = WIFI_DIRECT_CMD_DISCONNECT;
1687         req.client_id = client_info->client_id;
1688         macaddr_atoe(mac_address, la_mac_addr);
1689         memcpy(req.data.mac_addr, la_mac_addr, 6);
1690
1691         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1692         if (res != WIFI_DIRECT_ERROR_NONE) {
1693                 __WDC_LOG_FUNC_END__;
1694                 return res;
1695         }
1696         WDC_LOGE("wifi_direct_disconnect() SUCCESS");
1697
1698         __WDC_LOG_FUNC_END__;
1699         return WIFI_DIRECT_ERROR_NONE;
1700
1701 }
1702
1703 int wifi_direct_accept_connection(char *mac_address)
1704 {
1705         __WDC_LOG_FUNC_START__;
1706         wifi_direct_client_info_s *client_info = __wfd_get_control();
1707         unsigned char la_mac_addr[6];
1708         wifi_direct_client_request_s req;
1709         wifi_direct_client_response_s rsp;
1710         int res = WIFI_DIRECT_ERROR_NONE;
1711
1712         if ((client_info->is_registered == false) ||
1713                         (client_info->client_id == WFD_INVALID_ID)) {
1714                 WDC_LOGE("Client is NOT registered");
1715                 __WDC_LOG_FUNC_END__;
1716                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1717         }
1718
1719         if (!mac_address) {
1720                 WDC_LOGE("mac_addr is NULL");
1721                 __WDC_LOG_FUNC_END__;
1722                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1723         }
1724
1725         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1726         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1727
1728         req.cmd = WIFI_DIRECT_CMD_SEND_CONNECT_REQ;
1729         req.client_id = client_info->client_id;
1730         macaddr_atoe(mac_address, la_mac_addr);
1731         memcpy(req.data.mac_addr, la_mac_addr, 6);
1732
1733         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1734         if (res != WIFI_DIRECT_ERROR_NONE) {
1735                 __WDC_LOG_FUNC_END__;
1736                 return res;
1737         }
1738         WDC_LOGE("wifi_direct_connect() SUCCESS \n");
1739
1740         __WDC_LOG_FUNC_END__;
1741         return WIFI_DIRECT_ERROR_NONE;
1742 }
1743
1744
1745 int wifi_direct_foreach_connected_peers(wifi_direct_connected_peer_cb cb,
1746                                                                                                 void *user_data)
1747 {
1748         __WDC_LOG_FUNC_START__;
1749         wifi_direct_client_info_s *client_info = __wfd_get_control();
1750         wifi_direct_client_request_s req;
1751         wifi_direct_client_response_s rsp;
1752         int res = WIFI_DIRECT_ERROR_NONE;
1753         int i;
1754
1755         if ((client_info->is_registered == false) ||
1756                         (client_info->client_id == WFD_INVALID_ID)) {
1757                 WDC_LOGE("Client is NOT registered");
1758                 __WDC_LOG_FUNC_END__;
1759                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1760         }
1761
1762         if (!cb) {
1763                 WDC_LOGE("NULL Param [callback]!");
1764                 __WDC_LOG_FUNC_END__;
1765                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1766         }
1767
1768         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1769         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1770
1771         req.cmd = WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO;
1772         req.client_id = client_info->client_id;
1773
1774         pthread_mutex_lock(&g_client_info.mutex);
1775         res = __wfd_client_write_socket(client_info->sync_sockfd, &req, sizeof(wifi_direct_client_request_s));
1776         if (res != WIFI_DIRECT_ERROR_NONE) {
1777                 WDC_LOGE("Failed to write into socket [%s]", __wfd_print_error(res));
1778                 __wfd_reset_control();
1779                 pthread_mutex_unlock(&g_client_info.mutex);
1780                 __WDC_LOG_FUNC_END__;
1781                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1782         }
1783         WDC_LOGD("Succeeded to send request [%d: %s]", req.cmd, __wfd_client_print_cmd(req.cmd));
1784
1785         res = __wfd_client_read_socket(client_info->sync_sockfd, &rsp, sizeof(wifi_direct_client_response_s));
1786         if (res <= 0) {
1787                 WDC_LOGE("Failed to read socket [%d]", res);
1788                 __wfd_reset_control();
1789                 pthread_mutex_unlock(&g_client_info.mutex);
1790                 __WDC_LOG_FUNC_END__;
1791                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1792         } else {
1793                 if (rsp.cmd != req.cmd) {
1794                         WDC_LOGE("Invalid resp [%d]", rsp.cmd);
1795                         pthread_mutex_unlock(&g_client_info.mutex);
1796                         __WDC_LOG_FUNC_END__;
1797                         return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
1798                 }
1799
1800                 if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
1801                         WDC_LOGE("Result received [%s]", __wfd_print_error(rsp.result));
1802                         pthread_mutex_unlock(&g_client_info.mutex);
1803                         __WDC_LOG_FUNC_END__;
1804                         return rsp.result;
1805                 }
1806         }
1807
1808         int num = rsp.param1;
1809         wfd_connected_peer_info_s *buff = NULL;
1810
1811         WDC_LOGD("Num of connected peers = %d", (int) rsp.param1);
1812
1813         if (num > 0) {
1814                 buff = (wfd_connected_peer_info_s*) calloc(num, sizeof(wfd_connected_peer_info_s));
1815                 if (!buff) {
1816                         WDC_LOGF("malloc() failed!!!");
1817                         pthread_mutex_unlock(&g_client_info.mutex);
1818                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1819                 }
1820
1821                 res= __wfd_client_read_socket(client_info->sync_sockfd, (char*) buff,
1822                                                                 num * sizeof(wfd_connected_peer_info_s));
1823                 pthread_mutex_unlock(&g_client_info.mutex);
1824                 if (res <= 0) {
1825                         free(buff);
1826                         WDC_LOGE("socket read error");
1827                         __wfd_reset_control();
1828                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1829                 }
1830
1831                 __wfd_client_print_connected_peer_info(buff, num);
1832                 WDC_LOGD("wifi_direct_foreach_connected_peers() SUCCESS");
1833
1834                 wifi_direct_connected_peer_info_s *peer_list = NULL;
1835
1836                 for (i = 0; i < num; i++) {
1837                         peer_list = (wifi_direct_connected_peer_info_s *) calloc(1, sizeof(wifi_direct_connected_peer_info_s));
1838                         peer_list->device_name = strdup(buff[i].device_name);
1839                         peer_list->ip_address= (char*) calloc(1, IPSTR_LEN);
1840                         snprintf(peer_list->ip_address, IPSTR_LEN, IPSTR, IP2STR(buff[i].ip_address));
1841                         peer_list->mac_address = (char*) calloc(1, MACSTR_LEN);
1842                         snprintf(peer_list->mac_address, MACSTR_LEN, MACSTR, MAC2STR(buff[i].mac_address));
1843                         peer_list->interface_address = (char*) calloc(1, MACSTR_LEN);
1844                         snprintf(peer_list->interface_address, MACSTR_LEN, MACSTR, MAC2STR(buff[i].intf_address));
1845                         peer_list->p2p_supported = buff[i].is_p2p;
1846                         peer_list->primary_device_type = buff[i].category;
1847                         peer_list->channel = buff[i].channel;
1848                         peer_list->service_list = get_service_list(buff[i].services, &peer_list->service_count);
1849
1850                         if (!cb(peer_list, user_data))
1851                                 break;
1852                 }
1853                 if (buff)
1854                         free(buff);
1855         } else {
1856                 pthread_mutex_unlock(&g_client_info.mutex);
1857         }
1858
1859         __WDC_LOG_FUNC_END__;
1860         return WIFI_DIRECT_ERROR_NONE;
1861 }
1862
1863
1864 int wifi_direct_create_group(void)
1865 {
1866         __WDC_LOG_FUNC_START__;
1867         wifi_direct_client_info_s *client_info = __wfd_get_control();
1868         wifi_direct_client_request_s req;
1869         wifi_direct_client_response_s rsp;
1870         int res = WIFI_DIRECT_ERROR_NONE;
1871
1872         if ((client_info->is_registered == false) ||
1873                         (client_info->client_id == WFD_INVALID_ID)) {
1874                 WDC_LOGE("Client is NOT registered");
1875                 __WDC_LOG_FUNC_END__;
1876                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1877         }
1878
1879         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1880         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1881
1882         req.cmd = WIFI_DIRECT_CMD_CREATE_GROUP;
1883         req.client_id = client_info->client_id;
1884
1885         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1886         if (res != WIFI_DIRECT_ERROR_NONE) {
1887                 __WDC_LOG_FUNC_END__;
1888                 return res;
1889         }
1890         WDC_LOGE("wifi_direct_create_group() SUCCESS \n");
1891
1892         __WDC_LOG_FUNC_END__;
1893         return WIFI_DIRECT_ERROR_NONE;
1894 }
1895
1896
1897 int wifi_direct_destroy_group(void)
1898 {
1899         __WDC_LOG_FUNC_START__;
1900         wifi_direct_client_info_s *client_info = __wfd_get_control();
1901         wifi_direct_client_request_s req;
1902         wifi_direct_client_response_s rsp;
1903         int res = WIFI_DIRECT_ERROR_NONE;
1904
1905         if ((client_info->is_registered == false) ||
1906                         (client_info->client_id == WFD_INVALID_ID)) {
1907                 WDC_LOGE("Client is NOT registered");
1908                 __WDC_LOG_FUNC_END__;
1909                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1910         }
1911
1912         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1913         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1914
1915         req.cmd = WIFI_DIRECT_CMD_DESTROY_GROUP;
1916         req.client_id = client_info->client_id;
1917
1918         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1919         if (res != WIFI_DIRECT_ERROR_NONE) {
1920                 __WDC_LOG_FUNC_END__;
1921                 return res;
1922         }
1923         WDC_LOGE("wifi_direct_destroy_group() SUCCESS");
1924
1925         __WDC_LOG_FUNC_END__;
1926         return WIFI_DIRECT_ERROR_NONE;
1927 }
1928
1929
1930 int wifi_direct_is_group_owner(bool *owner)
1931 {
1932         __WDC_LOG_FUNC_START__;
1933         wifi_direct_client_info_s *client_info = __wfd_get_control();
1934         wifi_direct_client_request_s req;
1935         wifi_direct_client_response_s rsp;
1936         int res = WIFI_DIRECT_ERROR_NONE;
1937
1938         if ((client_info->is_registered == false) ||
1939                         (client_info->client_id == WFD_INVALID_ID)) {
1940                 WDC_LOGE("Client is NOT registered");
1941                 __WDC_LOG_FUNC_END__;
1942                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1943         }
1944
1945         if (!owner) {
1946                 WDC_LOGE("NULL Param [owner]!");
1947                 __WDC_LOG_FUNC_END__;
1948                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1949         }
1950
1951         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1952         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1953
1954         req.cmd = WIFI_DIRECT_CMD_IS_GROUPOWNER;
1955         req.client_id = client_info->client_id;
1956
1957         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1958         if (res != WIFI_DIRECT_ERROR_NONE) {
1959                 __WDC_LOG_FUNC_END__;
1960                 return res;
1961         }
1962         WDC_LOGD("wifi_direct_is_group_owner() SUCCESS");
1963         *owner = (bool) rsp.param1;
1964
1965         __WDC_LOG_FUNC_END__;
1966         return WIFI_DIRECT_ERROR_NONE;
1967 }
1968
1969 int wifi_direct_is_autonomous_group(bool *autonomous_group)
1970 {
1971         __WDC_LOG_FUNC_START__;
1972         wifi_direct_client_info_s *client_info = __wfd_get_control();
1973         wifi_direct_client_request_s req;
1974         wifi_direct_client_response_s rsp;
1975         int res = WIFI_DIRECT_ERROR_NONE;
1976
1977         if ((client_info->is_registered == false) ||
1978                         (client_info->client_id == WFD_INVALID_ID)) {
1979                 WDC_LOGE("Client is NOT registered");
1980                 __WDC_LOG_FUNC_END__;
1981                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
1982         }
1983
1984         if (!autonomous_group) {
1985                 WDC_LOGE("NULL Param [autonomous_group]!\n");
1986                 __WDC_LOG_FUNC_END__;
1987                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1988         }
1989
1990         memset(&req, 0, sizeof(wifi_direct_client_request_s));
1991         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
1992
1993         req.cmd = WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP;
1994         req.client_id = client_info->client_id;
1995
1996         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
1997         if (res != WIFI_DIRECT_ERROR_NONE) {
1998                 __WDC_LOG_FUNC_END__;
1999                 return res;
2000         }
2001         WDC_LOGD("wifi_direct_is_autonomous_group() SUCCESS");
2002         *autonomous_group = (bool) rsp.param1;
2003
2004         __WDC_LOG_FUNC_END__;
2005         return WIFI_DIRECT_ERROR_NONE;
2006 }
2007
2008
2009 int wifi_direct_set_group_owner_intent(int intent)
2010 {
2011         __WDC_LOG_FUNC_START__;
2012         wifi_direct_client_info_s *client_info = __wfd_get_control();
2013         wifi_direct_client_request_s req;
2014         wifi_direct_client_response_s rsp;
2015         int res = WIFI_DIRECT_ERROR_NONE;
2016
2017         if ((client_info->is_registered == false) ||
2018                         (client_info->client_id == WFD_INVALID_ID)) {
2019                 WDC_LOGE("Client is NOT registered");
2020                 __WDC_LOG_FUNC_END__;
2021                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2022         }
2023
2024         if (intent < 0 || intent > 15) {
2025                 WDC_LOGE("Invalid Param : intent[%d]", intent);
2026                 __WDC_LOG_FUNC_END__;
2027                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2028         }
2029
2030         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2031         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2032
2033         req.cmd = WIFI_DIRECT_CMD_SET_GO_INTENT;
2034         req.client_id = client_info->client_id;
2035         req.data.int1 = intent;
2036
2037         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2038         if (res != WIFI_DIRECT_ERROR_NONE) {
2039                 __WDC_LOG_FUNC_END__;
2040                 return res;
2041         }
2042         WDC_LOGD("wifi_direct_set_group_owner_intent() SUCCESS");
2043
2044         __WDC_LOG_FUNC_END__;
2045         return WIFI_DIRECT_ERROR_NONE;
2046 }
2047
2048 int wifi_direct_get_group_owner_intent(int *intent)
2049 {
2050         __WDC_LOG_FUNC_START__;
2051         wifi_direct_client_info_s *client_info = __wfd_get_control();
2052         wifi_direct_client_request_s req;
2053         wifi_direct_client_response_s rsp;
2054         int res = WIFI_DIRECT_ERROR_NONE;
2055
2056         if ((client_info->is_registered == false) ||
2057                         (client_info->client_id == WFD_INVALID_ID)) {
2058                 WDC_LOGE("Client is NOT registered");
2059                 __WDC_LOG_FUNC_END__;
2060                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2061         }
2062
2063         if (!intent) {
2064                 WDC_LOGE("Invalid Parameter");
2065                 __WDC_LOG_FUNC_END__;
2066                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2067         }
2068
2069         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2070         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2071
2072         req.cmd = WIFI_DIRECT_CMD_GET_GO_INTENT;
2073         req.client_id = client_info->client_id;
2074
2075         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2076         if (res != WIFI_DIRECT_ERROR_NONE) {
2077                 __WDC_LOG_FUNC_END__;
2078                 return res;
2079         }
2080         WDC_LOGD("int wifi_direct_get_group_owner_intent() intent[%d] SUCCESS", rsp.param1);
2081         *intent = rsp.param1;
2082
2083         __WDC_LOG_FUNC_END__;
2084         return WIFI_DIRECT_ERROR_NONE;
2085 }
2086
2087 int wifi_direct_set_max_clients(int max)
2088 {
2089         __WDC_LOG_FUNC_START__;
2090         wifi_direct_client_info_s *client_info = __wfd_get_control();
2091         wifi_direct_client_request_s req;
2092         wifi_direct_client_response_s rsp;
2093         int res = WIFI_DIRECT_ERROR_NONE;
2094
2095         if ((client_info->is_registered == false) ||
2096                         (client_info->client_id == WFD_INVALID_ID)) {
2097                 WDC_LOGE("Client is NOT registered");
2098                 __WDC_LOG_FUNC_END__;
2099                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2100         }
2101         WDC_LOGD("max client [%d]\n", max);
2102
2103         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2104         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2105
2106         req.cmd = WIFI_DIRECT_CMD_SET_MAX_CLIENT;
2107         req.client_id = client_info->client_id;
2108         req.data.int1 = max;
2109
2110         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2111         if (res != WIFI_DIRECT_ERROR_NONE) {
2112                 __WDC_LOG_FUNC_END__;
2113                 return res;
2114         }
2115         WDC_LOGD("int wifi_direct_set_max_clients() SUCCESS");
2116
2117         __WDC_LOG_FUNC_END__;
2118         return WIFI_DIRECT_ERROR_NONE;
2119 }
2120
2121 int wifi_direct_get_max_clients(int *max)
2122 {
2123         __WDC_LOG_FUNC_START__;
2124         wifi_direct_client_info_s *client_info = __wfd_get_control();
2125         wifi_direct_client_request_s req;
2126         wifi_direct_client_response_s rsp;
2127         int res = WIFI_DIRECT_ERROR_NONE;
2128
2129         if ((client_info->is_registered == false) ||
2130                         (client_info->client_id == WFD_INVALID_ID)) {
2131                 WDC_LOGE("Client is NOT registered");
2132                 __WDC_LOG_FUNC_END__;
2133                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2134         }
2135
2136         if (!max) {
2137                 WDC_LOGE("Invalid Parameter");
2138                 __WDC_LOG_FUNC_END__;
2139                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2140         }
2141
2142         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2143         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2144
2145         req.cmd = WIFI_DIRECT_CMD_GET_MAX_CLIENT;
2146         req.client_id = client_info->client_id;
2147
2148         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2149         if (res != WIFI_DIRECT_ERROR_NONE) {
2150                 __WDC_LOG_FUNC_END__;
2151                 return res;
2152         }
2153         WDC_LOGD("int wifi_direct_get_max_clients() max_client[%d] SUCCESS", rsp.param1);
2154         *max = rsp.param1;
2155
2156         __WDC_LOG_FUNC_END__;
2157         return WIFI_DIRECT_ERROR_NONE;
2158 }
2159
2160 int wifi_direct_get_operating_channel(int *channel)
2161 {
2162         __WDC_LOG_FUNC_START__;
2163         wifi_direct_client_info_s *client_info = __wfd_get_control();
2164         wifi_direct_client_request_s req;
2165         wifi_direct_client_response_s rsp;
2166         int res = WIFI_DIRECT_ERROR_NONE;
2167
2168         if ((client_info->is_registered == false) ||
2169                         (client_info->client_id == WFD_INVALID_ID)) {
2170                 WDC_LOGE("Client is NOT registered");
2171                 __WDC_LOG_FUNC_END__;
2172                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2173         }
2174
2175         if (!channel) {
2176                 WDC_LOGE("NULL Param [channel]!\n");
2177                 __WDC_LOG_FUNC_END__;
2178                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2179         }
2180
2181         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2182         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2183
2184         req.cmd = WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL;
2185         req.client_id = client_info->client_id;
2186
2187         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2188         if (res != WIFI_DIRECT_ERROR_NONE) {
2189                 __WDC_LOG_FUNC_END__;
2190                 return res;
2191         }
2192         WDC_LOGD("channel = [%d]", (int) rsp.param1);
2193         *channel = rsp.param1;
2194
2195         __WDC_LOG_FUNC_END__;
2196
2197         return WIFI_DIRECT_ERROR_NONE;
2198
2199 }
2200
2201
2202 int wifi_direct_get_passphrase(char** passphrase)
2203 {
2204         __WDC_LOG_FUNC_START__;
2205         wifi_direct_client_info_s *client_info = __wfd_get_control();
2206         wifi_direct_client_request_s req;
2207         wifi_direct_client_response_s rsp;
2208         char la_passphrase[WIFI_DIRECT_WPA_LEN+1] = {0,};
2209         int res = WIFI_DIRECT_ERROR_NONE;
2210
2211         if ((client_info->is_registered == false) ||
2212                         (client_info->client_id == WFD_INVALID_ID)) {
2213                 WDC_LOGE("Client is NOT registered.");
2214                 __WDC_LOG_FUNC_END__;
2215                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2216         }
2217
2218         if(!passphrase){
2219                 WDC_LOGE("NULL Param [passphrase]!");
2220                 __WDC_LOG_FUNC_END__;
2221                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2222         }
2223
2224         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2225         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2226
2227         req.cmd = WIFI_DIRECT_CMD_GET_PASSPHRASE;
2228         req.client_id = client_info->client_id;
2229
2230         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2231         if (res != WIFI_DIRECT_ERROR_NONE) {
2232                 __WDC_LOG_FUNC_END__;
2233                 return res;
2234         }
2235
2236         WDC_LOGD("wifi_direct_get_wpa_passphrase() SUCCESS");
2237         strncpy(la_passphrase, rsp.param2, WIFI_DIRECT_WPA_LEN);
2238         la_passphrase[WIFI_DIRECT_WPA_LEN] = '\0';
2239         *passphrase = strdup(la_passphrase);
2240
2241         __WDC_LOG_FUNC_END__;
2242         return WIFI_DIRECT_ERROR_NONE;
2243 }
2244
2245 int wifi_direct_set_wpa_passphrase(char *passphrase)
2246 {
2247         __WDC_LOG_FUNC_START__;
2248         wifi_direct_client_info_s *client_info = __wfd_get_control();
2249         wifi_direct_client_request_s req;
2250         wifi_direct_client_response_s rsp;
2251         int status = WIFI_DIRECT_ERROR_NONE;
2252
2253         if ((client_info->is_registered == false) ||
2254                         (client_info->client_id == WFD_INVALID_ID)) {
2255                 WDC_LOGE("Client is NOT registered.");
2256                 __WDC_LOG_FUNC_END__;
2257                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2258         }
2259
2260         if (!passphrase) {
2261                 WDC_LOGE("NULL Param [passphrase]!");
2262                 __WDC_LOG_FUNC_END__;
2263                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2264         }
2265         WDC_LOGD("passphrase = [%s]", passphrase);
2266
2267         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2268         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2269
2270         req.cmd = WIFI_DIRECT_CMD_SET_WPA;
2271         req.client_id = client_info->client_id;
2272         req.cmd_data_len = 64;
2273
2274         pthread_mutex_lock(&g_client_info.mutex);
2275         status = __wfd_client_write_socket(client_info->sync_sockfd, &req,
2276                                                                   sizeof(wifi_direct_client_request_s));
2277         if (status != WIFI_DIRECT_ERROR_NONE) {
2278                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2279                 __wfd_reset_control();
2280                 pthread_mutex_unlock(&g_client_info.mutex);
2281                 __WDC_LOG_FUNC_END__;
2282                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2283         }
2284         WDC_LOGD("writing msg hdr is success!");
2285
2286         status = __wfd_client_write_socket(client_info->sync_sockfd, passphrase, req.cmd_data_len);
2287         if (status != WIFI_DIRECT_ERROR_NONE) {
2288                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2289                 __wfd_reset_control();
2290                 pthread_mutex_unlock(&g_client_info.mutex);
2291                 __WDC_LOG_FUNC_END__;
2292                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2293         }
2294
2295         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
2296                                                                   sizeof(wifi_direct_client_response_s));
2297         pthread_mutex_unlock(&g_client_info.mutex);
2298         if (status <= 0) {
2299                 WDC_LOGE("Error!!! reading socket, status = %d", status);
2300                 __wfd_reset_control();
2301                 __WDC_LOG_FUNC_END__;
2302                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2303         } else {
2304                 if (rsp.cmd == WIFI_DIRECT_CMD_SET_WPA) {
2305                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
2306                                 WDC_LOGE("Error!!! Result received = %d", rsp.result);
2307                                 WDC_LOGE("Error!!! [%s]", __wfd_print_error(rsp.result));
2308                                 __WDC_LOG_FUNC_END__;
2309                                 return rsp.result;
2310                         }
2311                 } else {
2312                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
2313                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
2314                 }
2315         }
2316
2317         __WDC_LOG_FUNC_END__;
2318         return WIFI_DIRECT_ERROR_NONE;
2319 }
2320
2321 int wifi_direct_activate_pushbutton(void)
2322 {
2323         __WDC_LOG_FUNC_START__;
2324         wifi_direct_client_info_s *client_info = __wfd_get_control();
2325         wifi_direct_client_request_s req;
2326         wifi_direct_client_response_s rsp;
2327         int res = WIFI_DIRECT_ERROR_NONE;
2328
2329         if ((client_info->is_registered == false) ||
2330                         (client_info->client_id == WFD_INVALID_ID)) {
2331                 WDC_LOGE("Client is NOT registered");
2332                 __WDC_LOG_FUNC_END__;
2333                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2334         }
2335
2336         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2337         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2338
2339         req.cmd = WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON;
2340         req.client_id = client_info->client_id;
2341
2342         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2343         if (res != WIFI_DIRECT_ERROR_NONE) {
2344                 __WDC_LOG_FUNC_END__;
2345                 return res;
2346         }
2347         WDC_LOGD("wifi_direct_activate_pushbutton() SUCCESS");
2348
2349         __WDC_LOG_FUNC_END__;
2350         return WIFI_DIRECT_ERROR_NONE;
2351 }
2352
2353 int wifi_direct_set_wps_pin(char *pin)
2354 {
2355         __WDC_LOG_FUNC_START__;
2356         wifi_direct_client_info_s *client_info = __wfd_get_control();
2357         wifi_direct_client_request_s req;
2358         wifi_direct_client_response_s rsp;
2359         int status = WIFI_DIRECT_ERROR_NONE;
2360
2361         if ((client_info->is_registered == false) ||
2362                         (client_info->client_id == WFD_INVALID_ID)) {
2363                 WDC_LOGE("Client is NOT registered");
2364                 __WDC_LOG_FUNC_END__;
2365                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2366         }
2367
2368         if (!pin) {
2369                 WDC_LOGE("NULL Param [pin]!");
2370                 __WDC_LOG_FUNC_END__;
2371                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2372         }
2373         WDC_LOGE("pin = [%s]\n", pin);
2374
2375         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2376         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2377
2378         req.cmd = WIFI_DIRECT_CMD_SET_WPS_PIN;
2379         req.client_id = client_info->client_id;
2380         req.cmd_data_len = WIFI_DIRECT_WPS_PIN_LEN+1;
2381
2382         pthread_mutex_lock(&g_client_info.mutex);
2383         status = __wfd_client_write_socket(client_info->sync_sockfd, &req,
2384                                                                   sizeof(wifi_direct_client_request_s));
2385         if (status != WIFI_DIRECT_ERROR_NONE) {
2386                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2387                 __wfd_reset_control();
2388                 pthread_mutex_unlock(&g_client_info.mutex);
2389                 __WDC_LOG_FUNC_END__;
2390                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2391         }
2392         WDC_LOGD("writing msg hdr is success!\n");
2393
2394         status = __wfd_client_write_socket(client_info->sync_sockfd, pin,
2395                                                                   WIFI_DIRECT_WPS_PIN_LEN);
2396         if (status != WIFI_DIRECT_ERROR_NONE) {
2397                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2398                 __wfd_reset_control();
2399                 pthread_mutex_unlock(&g_client_info.mutex);
2400                 __WDC_LOG_FUNC_END__;
2401                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2402         }
2403
2404         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
2405                                                                   sizeof(wifi_direct_client_response_s));
2406         pthread_mutex_unlock(&g_client_info.mutex);
2407         if (status <= 0) {
2408                 WDC_LOGE("Error!!! reading socket, status = %d", status);
2409                 __wfd_reset_control();
2410                 __WDC_LOG_FUNC_END__;
2411                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2412         } else {
2413                 if (rsp.cmd == WIFI_DIRECT_CMD_SET_WPS_PIN) {
2414                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
2415                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
2416                                 WDC_LOGD("Error!!! [%s]", __wfd_print_error(rsp.result));
2417                                 __WDC_LOG_FUNC_END__;
2418                                 return rsp.result;
2419                         }
2420                 } else {
2421                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
2422                         __WDC_LOG_FUNC_END__;
2423                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
2424                 }
2425         }
2426
2427         __WDC_LOG_FUNC_END__;
2428         return WIFI_DIRECT_ERROR_NONE;
2429 }
2430
2431
2432 int wifi_direct_get_wps_pin(char **pin)
2433 {
2434         __WDC_LOG_FUNC_START__;
2435         wifi_direct_client_info_s *client_info = __wfd_get_control();
2436         wifi_direct_client_request_s req;
2437         wifi_direct_client_response_s rsp;
2438         char la_pin[WIFI_DIRECT_WPS_PIN_LEN + 1] = { 0, };
2439         int res = WIFI_DIRECT_ERROR_NONE;
2440
2441         if ((client_info->is_registered == false) ||
2442                         (client_info->client_id == WFD_INVALID_ID)) {
2443                 WDC_LOGE("Client is NOT registered");
2444                 __WDC_LOG_FUNC_END__;
2445                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2446         }
2447
2448         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2449         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2450
2451         req.cmd = WIFI_DIRECT_CMD_GET_WPS_PIN;
2452         req.client_id = client_info->client_id;
2453
2454         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2455         if (res != WIFI_DIRECT_ERROR_NONE) {
2456                 __WDC_LOG_FUNC_END__;
2457                 return res;
2458         }
2459         WDC_LOGD("wifi_direct_get_wps_pin() SUCCESS");
2460         strncpy(la_pin, rsp.param2, WIFI_DIRECT_WPS_PIN_LEN);
2461         la_pin[WIFI_DIRECT_WPS_PIN_LEN] = '\0';
2462         *pin = strdup(la_pin);
2463
2464         __WDC_LOG_FUNC_END__;
2465         return WIFI_DIRECT_ERROR_NONE;
2466 }
2467
2468 int wifi_direct_generate_wps_pin(void)
2469 {
2470         __WDC_LOG_FUNC_START__;
2471         wifi_direct_client_info_s *client_info = __wfd_get_control();
2472         wifi_direct_client_request_s req;
2473         wifi_direct_client_response_s rsp;
2474         int res = WIFI_DIRECT_ERROR_NONE;
2475
2476         if ((client_info->is_registered == false) ||
2477                         (client_info->client_id == WFD_INVALID_ID)) {
2478                 WDC_LOGE("Client is NOT registered");
2479                 __WDC_LOG_FUNC_END__;
2480                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2481         }
2482
2483         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2484         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2485
2486         req.cmd = WIFI_DIRECT_CMD_GENERATE_WPS_PIN;
2487         req.client_id = client_info->client_id;
2488
2489         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2490         if (res != WIFI_DIRECT_ERROR_NONE) {
2491                 __WDC_LOG_FUNC_END__;
2492                 return res;
2493         }
2494         WDC_LOGD("wifi_direct_generate_wps_pin() SUCCESS");
2495
2496         __WDC_LOG_FUNC_END__;
2497         return WIFI_DIRECT_ERROR_NONE;
2498 }
2499
2500
2501 int wifi_direct_get_supported_wps_mode(int *wps_mode)
2502 {
2503         __WDC_LOG_FUNC_START__;
2504         wifi_direct_client_info_s *client_info = __wfd_get_control();
2505         wifi_direct_client_request_s req;
2506         wifi_direct_client_response_s rsp;
2507         int res = WIFI_DIRECT_ERROR_NONE;
2508
2509         if ((client_info->is_registered == false) ||
2510                         (client_info->client_id == WFD_INVALID_ID)) {
2511                 WDC_LOGE("Client is NOT registered");
2512                 __WDC_LOG_FUNC_END__;
2513                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2514         }
2515
2516         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2517         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2518
2519         req.cmd = WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE;
2520         req.client_id = client_info->client_id;
2521
2522         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2523         if (res != WIFI_DIRECT_ERROR_NONE) {
2524                 __WDC_LOG_FUNC_END__;
2525                 return res;
2526         }
2527         WDC_LOGD("Supported wps config = [%d]", (int) rsp.param1);
2528         *wps_mode = rsp.param1;
2529
2530         __WDC_LOG_FUNC_END__;
2531         return WIFI_DIRECT_ERROR_NONE;
2532 }
2533
2534 int wifi_direct_foreach_supported_wps_types(wifi_direct_supported_wps_type_cb cb, void* user_data)
2535 {
2536         __WDC_LOG_FUNC_START__;
2537         wifi_direct_client_info_s *client_info = __wfd_get_control();
2538         wifi_direct_client_request_s req;
2539         wifi_direct_client_response_s rsp;
2540         int res = WIFI_DIRECT_ERROR_NONE;
2541
2542         if ((client_info->is_registered == false) ||
2543                         (client_info->client_id == WFD_INVALID_ID)) {
2544                 WDC_LOGE("Client is NOT registered");
2545                 __WDC_LOG_FUNC_END__;
2546                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2547         }
2548
2549         if (!cb) {
2550                 WDC_LOGE("NULL Param [callback]!");
2551                 __WDC_LOG_FUNC_END__;
2552                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2553         }
2554
2555         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2556         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2557
2558         req.cmd = WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE;
2559         req.client_id = client_info->client_id;
2560
2561         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2562         if (res != WIFI_DIRECT_ERROR_NONE) {
2563                 __WDC_LOG_FUNC_END__;
2564                 return res;
2565         }
2566         WDC_LOGD("Supported wps config = [%d]", (int) rsp.param1);
2567
2568         int wps_mode;
2569         bool result = TRUE;
2570
2571         wps_mode = rsp.param1;
2572         if (wps_mode & WIFI_DIRECT_WPS_TYPE_PBC)
2573                 result = cb(WIFI_DIRECT_WPS_TYPE_PBC, user_data);
2574         if ((result == true) && (wps_mode & WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY))
2575                 result = cb(WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY, user_data);
2576         if ((result == true) && (wps_mode & WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD))
2577                 result = cb(WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD, user_data);
2578
2579         __WDC_LOG_FUNC_END__;
2580         return WIFI_DIRECT_ERROR_NONE;
2581 }
2582
2583 int wifi_direct_get_local_wps_type(wifi_direct_wps_type_e *type)
2584 {
2585         __WDC_LOG_FUNC_START__;
2586         wifi_direct_client_info_s *client_info = __wfd_get_control();
2587         wifi_direct_client_request_s req;
2588         wifi_direct_client_response_s rsp;
2589         int res = WIFI_DIRECT_ERROR_NONE;
2590
2591         if ((client_info->is_registered == false) ||
2592                         (client_info->client_id == WFD_INVALID_ID)) {
2593                 WDC_LOGE("Client is NOT registered");
2594                 __WDC_LOG_FUNC_END__;
2595                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2596         }
2597
2598         if (type == NULL) {
2599                 WDC_LOGE("NULL Param [type]!\n");
2600                 __WDC_LOG_FUNC_END__;
2601                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2602         }
2603
2604         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2605         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2606
2607         req.cmd = WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE;
2608         req.client_id = client_info->client_id;
2609
2610         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2611         if (res != WIFI_DIRECT_ERROR_NONE) {
2612                 __WDC_LOG_FUNC_END__;
2613                 return res;
2614         }
2615         WDC_LOGD("wifi_direct_get_wps_type() SUCCESS");
2616         *type = rsp.param1;
2617
2618         __WDC_LOG_FUNC_END__;
2619         return WIFI_DIRECT_ERROR_NONE;
2620 }
2621
2622 int wifi_direct_set_req_wps_type(wifi_direct_wps_type_e type)
2623 {
2624         __WDC_LOG_FUNC_START__;
2625         wifi_direct_client_info_s *client_info = __wfd_get_control();
2626         wifi_direct_client_request_s req;
2627         wifi_direct_client_response_s rsp;
2628         int res = WIFI_DIRECT_ERROR_NONE;
2629
2630         if ((client_info->is_registered == false) ||
2631                         (client_info->client_id == WFD_INVALID_ID)) {
2632                 WDC_LOGE("Client is NOT registered");
2633                 __WDC_LOG_FUNC_END__;
2634                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2635         }
2636
2637         if (type == WIFI_DIRECT_WPS_TYPE_PBC ||
2638                         type == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY ||
2639                         type == WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD) {
2640                 WDC_LOGD("Param wps_mode [%d]", type);
2641         } else {
2642                 WDC_LOGE("Invalid Param [wps_mode]!");
2643                 __WDC_LOG_FUNC_END__;
2644                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2645         }
2646
2647         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2648         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2649
2650         req.cmd = WIFI_DIRECT_CMD_SET_REQ_WPS_MODE;
2651         req.client_id = client_info->client_id;
2652         req.data.int1 = type;
2653
2654         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2655         if (res != WIFI_DIRECT_ERROR_NONE) {
2656                 __WDC_LOG_FUNC_END__;
2657                 return res;
2658         }
2659         WDC_LOGD("wifi_direct_set_req_wps_type() SUCCESS");
2660
2661         __WDC_LOG_FUNC_END__;
2662         return WIFI_DIRECT_ERROR_NONE;
2663 }
2664
2665 int wifi_direct_get_req_wps_type(wifi_direct_wps_type_e *type)
2666 {
2667         __WDC_LOG_FUNC_START__;
2668         wifi_direct_client_info_s *client_info = __wfd_get_control();
2669         wifi_direct_client_request_s req;
2670         wifi_direct_client_response_s rsp;
2671         int res = WIFI_DIRECT_ERROR_NONE;
2672
2673         if ((client_info->is_registered == false) ||
2674                         (client_info->client_id == WFD_INVALID_ID)) {
2675                 WDC_LOGE("Client is NOT registered");
2676                 __WDC_LOG_FUNC_END__;
2677                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2678         }
2679
2680         if (type == NULL) {
2681                 WDC_LOGE("NULL Param [type]!\n");
2682                 __WDC_LOG_FUNC_END__;
2683                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2684         }
2685
2686         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2687         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2688
2689         req.cmd = WIFI_DIRECT_CMD_GET_REQ_WPS_MODE;
2690         req.client_id = client_info->client_id;
2691
2692         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2693         if (res != WIFI_DIRECT_ERROR_NONE) {
2694                 __WDC_LOG_FUNC_END__;
2695                 return res;
2696         }
2697         WDC_LOGD("wifi_direct_get_req_wps_type() SUCCESS");
2698         *type = rsp.param1;
2699
2700         __WDC_LOG_FUNC_END__;
2701         return WIFI_DIRECT_ERROR_NONE;
2702 }
2703
2704 /* DPRECATED */
2705 int wifi_direct_set_ssid(const char *ssid)
2706 {
2707         __WDC_LOG_FUNC_START__;
2708         wifi_direct_client_info_s *client_info = __wfd_get_control();
2709         wifi_direct_client_request_s req;
2710         wifi_direct_client_response_s rsp;
2711         int res = WIFI_DIRECT_ERROR_NONE;
2712
2713         if ((client_info->is_registered == false) ||
2714                         (client_info->client_id == WFD_INVALID_ID)) {
2715                 WDC_LOGE("Client is NOT registered");
2716                 __WDC_LOG_FUNC_END__;
2717                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2718         }
2719
2720         if (!ssid) {
2721                 WDC_LOGE("NULL Param [ssid]!");
2722                 __WDC_LOG_FUNC_END__;
2723                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2724         }
2725         WDC_LOGE("ssid = [%s]", ssid);
2726
2727         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2728         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2729
2730         req.cmd = WIFI_DIRECT_CMD_SET_SSID;
2731         req.client_id = client_info->client_id;
2732
2733         pthread_mutex_lock(&g_client_info.mutex);
2734         res = __wfd_client_write_socket(client_info->sync_sockfd, &req,
2735                                                                   sizeof(wifi_direct_client_request_s));
2736         if (res != WIFI_DIRECT_ERROR_NONE) {
2737                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(res));
2738                 __wfd_reset_control();
2739                 pthread_mutex_unlock(&g_client_info.mutex);
2740                 __WDC_LOG_FUNC_END__;
2741                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2742         }
2743         WDC_LOGD("writing msg hdr is success!");
2744
2745         res = __wfd_client_write_socket(client_info->sync_sockfd, (void*) ssid,
2746                                                                   WIFI_DIRECT_MAX_SSID_LEN);
2747         if (res != WIFI_DIRECT_ERROR_NONE) {
2748                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(res));
2749                 __wfd_reset_control();
2750                 pthread_mutex_unlock(&g_client_info.mutex);
2751                 __WDC_LOG_FUNC_END__;
2752                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2753         }
2754
2755         res = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
2756                                                                   sizeof(wifi_direct_client_response_s));
2757         pthread_mutex_unlock(&g_client_info.mutex);
2758         if (res <= 0) {
2759                 WDC_LOGE("Error!!! reading socket, status = %d", res);
2760                 __wfd_reset_control();
2761                 __WDC_LOG_FUNC_END__;
2762                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2763         } else {
2764                 if (rsp.cmd == WIFI_DIRECT_CMD_SET_SSID) {
2765                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
2766                                 WDC_LOGE("Error!!! Result received = %d", rsp.result);
2767                                 WDC_LOGE("Error!!! [%s]", __wfd_print_error(rsp.result));
2768                                 __WDC_LOG_FUNC_END__;
2769                                 return rsp.result;
2770                         }
2771                 } else {
2772                         WDC_LOGE("Error!!! Invalid resp cmd = %d\n", rsp.cmd);
2773                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
2774                 }
2775         }
2776
2777         __WDC_LOG_FUNC_END__;
2778         return WIFI_DIRECT_ERROR_NONE;
2779 }
2780
2781 int wifi_direct_get_ssid(char **ssid)
2782 {
2783         __WDC_LOG_FUNC_START__;
2784         wifi_direct_client_info_s *client_info = __wfd_get_control();
2785         wifi_direct_client_request_s req;
2786         wifi_direct_client_response_s rsp;
2787         char la_ssid[WIFI_DIRECT_MAX_SSID_LEN + 1] = { 0, };
2788         int res = WIFI_DIRECT_ERROR_NONE;
2789
2790         if ((client_info->is_registered == false) ||
2791                         (client_info->client_id == WFD_INVALID_ID)) {
2792                 WDC_LOGE("Client is NOT registered");
2793                 __WDC_LOG_FUNC_END__;
2794                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2795         }
2796
2797         if (!ssid) {
2798                 WDC_LOGE("NULL Param [ssid]!");
2799                 __WDC_LOG_FUNC_END__;
2800                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2801         }
2802
2803         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2804         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2805
2806         req.cmd = WIFI_DIRECT_CMD_GET_SSID;
2807         req.client_id = client_info->client_id;
2808
2809         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2810         if (res != WIFI_DIRECT_ERROR_NONE) {
2811                 __WDC_LOG_FUNC_END__;
2812                 return res;
2813         }
2814         WDC_LOGD("wifi_direct_get_ssid() %s SUCCESS", rsp.param2);
2815         strncpy(la_ssid, rsp.param2, WIFI_DIRECT_MAX_SSID_LEN);
2816         la_ssid[WIFI_DIRECT_MAX_SSID_LEN] = '\0';
2817         *ssid = strdup(la_ssid);
2818
2819         __WDC_LOG_FUNC_END__;
2820         return WIFI_DIRECT_ERROR_NONE;
2821 }
2822
2823 int wifi_direct_get_device_name(char **device_name)
2824 {
2825         __WDC_LOG_FUNC_START__;
2826         wifi_direct_client_info_s *client_info = __wfd_get_control();
2827         wifi_direct_client_request_s req;
2828         wifi_direct_client_response_s rsp;
2829         char la_device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1] = { 0, };
2830         int res = WIFI_DIRECT_ERROR_NONE;
2831
2832         if ((client_info->is_registered == false) ||
2833                         (client_info->client_id == WFD_INVALID_ID)) {
2834                 WDC_LOGE("Client is NOT registered");
2835                 __WDC_LOG_FUNC_END__;
2836                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2837         }
2838
2839         if (!device_name) {
2840                 WDC_LOGE("NULL Param [device_name]!");
2841                 __WDC_LOG_FUNC_END__;
2842                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2843         }
2844
2845         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2846         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2847
2848         req.cmd = WIFI_DIRECT_CMD_GET_DEVICE_NAME;
2849         req.client_id = client_info->client_id;
2850
2851         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
2852         if (res != WIFI_DIRECT_ERROR_NONE) {
2853                 __WDC_LOG_FUNC_END__;
2854                 return res;
2855         }
2856         WDC_LOGD("wifi_direct_get_device_name() %s SUCCESS \n", rsp.param2);
2857         strncpy(la_device_name, rsp.param2, WIFI_DIRECT_MAX_DEVICE_NAME_LEN);
2858         la_device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN] = '\0';
2859         *device_name = strdup(la_device_name);
2860
2861         __WDC_LOG_FUNC_END__;
2862         return WIFI_DIRECT_ERROR_NONE;
2863 }
2864
2865 int wifi_direct_set_device_name(const char *device_name)
2866 {
2867         __WDC_LOG_FUNC_START__;
2868         wifi_direct_client_info_s *client_info = __wfd_get_control();
2869         wifi_direct_client_request_s req;
2870         wifi_direct_client_response_s rsp;
2871         int status = WIFI_DIRECT_ERROR_NONE;
2872
2873         if ((client_info->is_registered == false) ||
2874                         (client_info->client_id == WFD_INVALID_ID)) {
2875                 WDC_LOGE("Client is NOT registered");
2876                 __WDC_LOG_FUNC_END__;
2877                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2878         }
2879
2880         if (!device_name) {
2881                 WDC_LOGE("NULL Param [device_name]!");
2882                 __WDC_LOG_FUNC_END__;
2883                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2884         }
2885         WDC_LOGE("device_name = [%s]", device_name);
2886
2887         memset(&req, 0, sizeof(wifi_direct_client_request_s));
2888         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
2889
2890         req.cmd = WIFI_DIRECT_CMD_SET_DEVICE_NAME;
2891         req.client_id = client_info->client_id;
2892
2893         pthread_mutex_lock(&g_client_info.mutex);
2894         status = __wfd_client_write_socket(client_info->sync_sockfd, &req,
2895                                                                   sizeof(wifi_direct_client_request_s));
2896         if (status != WIFI_DIRECT_ERROR_NONE) {
2897                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2898                 __wfd_reset_control();
2899                 pthread_mutex_unlock(&g_client_info.mutex);
2900                 __WDC_LOG_FUNC_END__;
2901                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2902         }
2903         WDC_LOGD( "writing msg hdr is success!\n");
2904
2905         status = __wfd_client_write_socket(client_info->sync_sockfd, (void*) device_name,
2906                                                                   WIFI_DIRECT_MAX_DEVICE_NAME_LEN);
2907         if (status != WIFI_DIRECT_ERROR_NONE) {
2908                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
2909                 __wfd_reset_control();
2910                 pthread_mutex_unlock(&g_client_info.mutex);
2911                 __WDC_LOG_FUNC_END__;
2912                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2913         }
2914
2915         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
2916                                                                   sizeof(wifi_direct_client_response_s));
2917         pthread_mutex_unlock(&g_client_info.mutex);
2918         if (status <= 0) {
2919                 WDC_LOGE("Error!!! reading socket, status = %d", status);
2920                 __wfd_reset_control();
2921                 __WDC_LOG_FUNC_END__;
2922                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
2923         } else {
2924                 if (rsp.cmd == WIFI_DIRECT_CMD_SET_DEVICE_NAME) {
2925                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
2926                                 WDC_LOGE("Error!!! Result received = %d", rsp.result);
2927                                 WDC_LOGE("Error!!! [%s]", __wfd_print_error(rsp.result));
2928                                 __WDC_LOG_FUNC_END__;
2929                                 return rsp.result;
2930                         }
2931                 } else {
2932                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
2933                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
2934                 }
2935         }
2936
2937         __WDC_LOG_FUNC_END__;
2938         return WIFI_DIRECT_ERROR_NONE;
2939 }
2940
2941 int wifi_direct_get_network_interface_name(char **name)
2942 {
2943         __WDC_LOG_FUNC_START__;
2944         wifi_direct_client_info_s *client_info = __wfd_get_control();
2945         wifi_direct_state_e status = 0;
2946         char *get_str = NULL;
2947         int result;
2948
2949         if ((client_info->is_registered == false) ||
2950                         (client_info->client_id == WFD_INVALID_ID)) {
2951                 WDC_LOGE("Client is NOT registered");
2952                 __WDC_LOG_FUNC_END__;
2953                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2954         }
2955
2956         if (!name) {
2957                 WDC_LOGE("NULL Param [name]!\n");
2958                 __WDC_LOG_FUNC_END__;
2959                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2960         }
2961
2962         result = wifi_direct_get_state(&status);
2963         WDC_LOGD("wifi_direct_get_state() state=[%d], result=[%d]\n", status, result);
2964
2965         if (status < WIFI_DIRECT_STATE_CONNECTED) {
2966                 WDC_LOGE("Device is not connected!\n");
2967                 __WDC_LOG_FUNC_END__;
2968                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
2969         }
2970
2971         get_str = vconf_get_str(VCONFKEY_IFNAME);
2972         if (!get_str) {
2973                 WDC_LOGD( "vconf (%s) value is NULL!!!\n", VCONFKEY_IFNAME);
2974                 __WDC_LOG_FUNC_END__;
2975                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
2976         }
2977         WDC_LOGD( "VCONFKEY_IFNAME(%s) : %s\n", VCONFKEY_IFNAME, get_str);
2978         *name = strdup(get_str);
2979         free(get_str);
2980
2981         __WDC_LOG_FUNC_END__;
2982         return WIFI_DIRECT_ERROR_NONE;
2983 }
2984
2985 int wifi_direct_get_ip_address(char **ip_address)
2986 {
2987         __WDC_LOG_FUNC_START__;
2988         wifi_direct_client_info_s *client_info = __wfd_get_control();
2989         wifi_direct_state_e state = 0;
2990         char *get_str = NULL;
2991         int result;
2992
2993         if ((client_info->is_registered == false) ||
2994                         (client_info->client_id == WFD_INVALID_ID)) {
2995                 WDC_LOGE("Client is NOT registered");
2996                 __WDC_LOG_FUNC_END__;
2997                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
2998         }
2999
3000         if (!ip_address) {
3001                 WDC_LOGE("NULL Param [ip_address]!\n");
3002                 __WDC_LOG_FUNC_END__;
3003                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3004         }
3005
3006         result = wifi_direct_get_state(&state);
3007         WDC_LOGD( "wifi_direct_get_state() state=[%d], result=[%d]", state, result);
3008         if( state < WIFI_DIRECT_STATE_CONNECTED) {
3009                 WDC_LOGE("Device is not connected!");
3010                 __WDC_LOG_FUNC_END__;
3011                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3012         }
3013
3014         get_str = vconf_get_str(VCONFKEY_LOCAL_IP);
3015         if (!get_str)
3016         {
3017                 WDC_LOGD("vconf (%s) value is NULL!!!", VCONFKEY_LOCAL_IP);
3018                 __WDC_LOG_FUNC_END__;
3019                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3020         }
3021         WDC_LOGD("VCONFKEY_LOCAL_IP(%s) : %s", VCONFKEY_LOCAL_IP, get_str);
3022         *ip_address = strdup(get_str);
3023         free(get_str);
3024
3025         __WDC_LOG_FUNC_END__;
3026         return WIFI_DIRECT_ERROR_NONE;
3027 }
3028
3029 int wifi_direct_get_subnet_mask(char **subnet_mask)
3030 {
3031         __WDC_LOG_FUNC_START__;
3032         wifi_direct_client_info_s *client_info = __wfd_get_control();
3033         wifi_direct_state_e status = 0;
3034         char *get_str = NULL;
3035         int result;
3036
3037         if ((client_info->is_registered == false) ||
3038                         (client_info->client_id == WFD_INVALID_ID)) {
3039                 WDC_LOGE("Client is NOT registered");
3040                 __WDC_LOG_FUNC_END__;
3041                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3042         }
3043
3044         if (!subnet_mask) {
3045                 WDC_LOGE("NULL Param [subnet_mask]!");
3046                 __WDC_LOG_FUNC_END__;
3047                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3048         }
3049
3050         result = wifi_direct_get_state(&status);
3051         WDC_LOGD("wifi_direct_get_state() state=[%d], result=[%d]", status, result);
3052         if( status < WIFI_DIRECT_STATE_CONNECTED) {
3053                 WDC_LOGE("Device is not connected!");
3054                 __WDC_LOG_FUNC_END__;
3055                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3056         }
3057
3058         get_str = vconf_get_str(VCONFKEY_SUBNET_MASK);
3059         if (!get_str) {
3060                 WDC_LOGD("vconf (%s) value is NULL!!!", VCONFKEY_SUBNET_MASK);
3061                 __WDC_LOG_FUNC_END__;
3062                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3063         }
3064         WDC_LOGD("VCONFKEY_SUBNET_MASK(%s) : %s", VCONFKEY_SUBNET_MASK, get_str);
3065         *subnet_mask = strdup(get_str);
3066         free(get_str);
3067
3068         __WDC_LOG_FUNC_END__;
3069         return WIFI_DIRECT_ERROR_NONE;
3070 }
3071
3072 int wifi_direct_get_gateway_address(char **gateway_address)
3073 {
3074         __WDC_LOG_FUNC_START__;
3075         wifi_direct_client_info_s *client_info = __wfd_get_control();
3076         wifi_direct_state_e status = 0;
3077         char *get_str = NULL;
3078         int result;
3079
3080         if ((client_info->is_registered == false) ||
3081                         (client_info->client_id == WFD_INVALID_ID)) {
3082                 WDC_LOGE("Client is NOT registered");
3083                 __WDC_LOG_FUNC_END__;
3084                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3085         }
3086
3087         if (!gateway_address) {
3088                 WDC_LOGE("NULL Param [gateway_address]!");
3089                 __WDC_LOG_FUNC_END__;
3090                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3091         }
3092
3093         result = wifi_direct_get_state(&status);
3094         WDC_LOGD("wifi_direct_get_state() state=[%d], result=[%d]", status, result);
3095         if(status < WIFI_DIRECT_STATE_CONNECTED) {
3096                 WDC_LOGE("Device is not connected!");
3097                 __WDC_LOG_FUNC_END__;
3098                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3099         }
3100
3101         get_str = vconf_get_str(VCONFKEY_GATEWAY);
3102         if (!get_str) {
3103                 WDC_LOGD("vconf (%s) value is NULL!!!", VCONFKEY_GATEWAY);
3104                 __WDC_LOG_FUNC_END__;
3105                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
3106         }
3107         WDC_LOGD("VCONFKEY_GATEWAY(%s) : %s", VCONFKEY_GATEWAY, get_str);
3108         *gateway_address = strdup(get_str);
3109         free(get_str);
3110
3111         __WDC_LOG_FUNC_END__;
3112         return WIFI_DIRECT_ERROR_NONE;
3113 }
3114
3115 int wifi_direct_get_mac_address(char **mac_address)
3116 {
3117         __WDC_LOG_FUNC_START__;
3118         wifi_direct_client_info_s *client_info = __wfd_get_control();
3119         int fd;
3120         int n;
3121         char mac_info[MACSTR_LEN];
3122         unsigned char la_mac_addr[6];
3123
3124         if ((client_info->is_registered == false) ||
3125                         (client_info->client_id == WFD_INVALID_ID)) {
3126                 WDC_LOGE("Client is NOT registered");
3127                 __WDC_LOG_FUNC_END__;
3128                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3129         }
3130
3131         if (!mac_address) {
3132                 WDC_LOGE("NULL Param [mac_address]!");
3133                 __WDC_LOG_FUNC_END__;
3134                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3135         }
3136
3137         memset(mac_info, 0, sizeof(mac_info));
3138
3139         fd = open(WIFI_DIRECT_MAC_ADDRESS_INFO_FILE, O_RDONLY);
3140         if (fd == -1) {
3141                 WDC_LOGE("[.mac.info] file open failed.");
3142                 __WDC_LOG_FUNC_END__;
3143                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3144         }
3145
3146         n = read(fd, mac_info, MACSTR_LEN);
3147         if(n < 0) {
3148                 WDC_LOGE("[.mac.info] file read failed.");
3149                 if (fd > 0)
3150                         close(fd);
3151                 __WDC_LOG_FUNC_END__;
3152                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3153         }
3154         mac_info[17] = '\0';
3155         WDC_LOGD("mac_address = [%s]", mac_info);
3156
3157         memset(la_mac_addr, 0, sizeof(la_mac_addr));
3158         macaddr_atoe(mac_info, la_mac_addr);
3159         la_mac_addr[0] |= 0x02;
3160
3161         *mac_address = (char*) calloc(1, MACSTR_LEN);
3162         snprintf(*mac_address, MACSTR_LEN, MACSTR, MAC2STR(la_mac_addr));
3163
3164         if (fd > 0)
3165                 close(fd);
3166
3167         __WDC_LOG_FUNC_END__;
3168         return WIFI_DIRECT_ERROR_NONE;
3169 }
3170
3171
3172 int wifi_direct_get_state(wifi_direct_state_e *state)
3173 {
3174         __WDC_LOG_FUNC_START__;
3175         wifi_direct_client_info_s *client_info = __wfd_get_control();
3176         wifi_direct_client_request_s req;
3177         wifi_direct_client_response_s rsp;
3178         int res = WIFI_DIRECT_ERROR_NONE;
3179
3180         if (!state) {
3181                 WDC_LOGE("NULL Param [state]!");
3182                 __WDC_LOG_FUNC_END__;
3183                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3184         }
3185
3186         if ((client_info->is_registered == false) ||
3187                         (client_info->client_id == WFD_INVALID_ID)) {
3188                 WDC_LOGE("Client is NOT registered");
3189                 __WDC_LOG_FUNC_END__;
3190                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3191         }
3192
3193         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3194         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3195
3196         req.cmd = WIFI_DIRECT_CMD_GET_LINK_STATUS;
3197         req.client_id = client_info->client_id;
3198
3199         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3200         if (res != WIFI_DIRECT_ERROR_NONE) {
3201                 __WDC_LOG_FUNC_END__;
3202                 return res;
3203         }
3204         WDC_LOGD("Link Status = %d", (int) rsp.param1);
3205         *state = (wifi_direct_state_e) rsp.param1;
3206
3207         /* for CAPI : there is no WIFI_DIRECT_STATE_GROUP_OWNER type in CAPI */
3208         if(*state == WIFI_DIRECT_STATE_GROUP_OWNER)
3209                 *state = WIFI_DIRECT_STATE_CONNECTED;
3210
3211         __WDC_LOG_FUNC_END__;
3212         return WIFI_DIRECT_ERROR_NONE;
3213 }
3214
3215
3216 int wifi_direct_is_discoverable(bool* discoverable)
3217 {
3218         __WDC_LOG_FUNC_START__;
3219         wifi_direct_client_info_s *client_info = __wfd_get_control();
3220         wifi_direct_client_request_s req;
3221         wifi_direct_client_response_s rsp;
3222         int res = WIFI_DIRECT_ERROR_NONE;
3223
3224         if ((client_info->is_registered == false) ||
3225                         (client_info->client_id == WFD_INVALID_ID)) {
3226                 WDC_LOGE("Client is NOT registered");
3227                 __WDC_LOG_FUNC_END__;
3228                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3229         }
3230
3231         if (!discoverable) {
3232                 WDC_LOGE("NULL Param [discoverable]!");
3233                 __WDC_LOG_FUNC_END__;
3234                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3235         }
3236
3237         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3238         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3239
3240         req.cmd = WIFI_DIRECT_CMD_IS_DISCOVERABLE;
3241         req.client_id = client_info->client_id;
3242
3243         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3244         if (res != WIFI_DIRECT_ERROR_NONE) {
3245                 __WDC_LOG_FUNC_END__;
3246                 return res;
3247         }
3248         WDC_LOGD("wifi_direct_is_discoverable() SUCCESS");
3249         *discoverable = (bool) rsp.param1;
3250
3251         __WDC_LOG_FUNC_END__;
3252         return WIFI_DIRECT_ERROR_NONE;
3253 }
3254
3255 int wifi_direct_is_listening_only(bool* listen_only)
3256 {
3257         __WDC_LOG_FUNC_START__;
3258         wifi_direct_client_info_s *client_info = __wfd_get_control();
3259         wifi_direct_client_request_s req;
3260         wifi_direct_client_response_s rsp;
3261         int res = WIFI_DIRECT_ERROR_NONE;
3262
3263         if ((client_info->is_registered == false) ||
3264                         (client_info->client_id == WFD_INVALID_ID)) {
3265                 WDC_LOGE("Client is NOT registered");
3266                 __WDC_LOG_FUNC_END__;
3267                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3268         }
3269
3270         if (!listen_only) {
3271                 WDC_LOGE("NULL Param [listen_only]!");
3272                 __WDC_LOG_FUNC_END__;
3273                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3274         }
3275
3276         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3277         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3278
3279         req.cmd = WIFI_DIRECT_CMD_IS_LISTENING_ONLY;
3280         req.client_id = client_info->client_id;
3281
3282         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3283         if (res != WIFI_DIRECT_ERROR_NONE) {
3284                 __WDC_LOG_FUNC_END__;
3285                 return res;
3286         }
3287         WDC_LOGD("wifi_direct_is_listening_only() SUCCESS");
3288         *listen_only = (bool) rsp.param1;
3289
3290         __WDC_LOG_FUNC_END__;
3291         return WIFI_DIRECT_ERROR_NONE;
3292 }
3293
3294
3295 int wifi_direct_get_primary_device_type(wifi_direct_primary_device_type_e* type)
3296 {
3297         __WDC_LOG_FUNC_START__;
3298         wifi_direct_client_info_s *client_info = __wfd_get_control();
3299
3300         if (!type) {
3301                 WDC_LOGE("NULL Param [type]!");
3302                 __WDC_LOG_FUNC_END__;
3303                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3304         }
3305
3306         if ((client_info->is_registered == false) ||
3307                         (client_info->client_id == WFD_INVALID_ID)) {
3308                 WDC_LOGE("Client is NOT registered");
3309                 __WDC_LOG_FUNC_END__;
3310                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3311         }
3312
3313         WDC_LOGD("Current primary_dev_type [%d]", WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE);
3314         *type = WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE;
3315
3316         __WDC_LOG_FUNC_END__;
3317         return WIFI_DIRECT_ERROR_NONE;
3318 }
3319
3320 int wifi_direct_get_secondary_device_type(wifi_direct_secondary_device_type_e* type)
3321 {
3322         __WDC_LOG_FUNC_START__;
3323         wifi_direct_client_info_s *client_info = __wfd_get_control();
3324
3325         if ((client_info->is_registered == false) ||
3326                         (client_info->client_id == WFD_INVALID_ID)) {
3327                 WDC_LOGE("Client is NOT registered");
3328                 __WDC_LOG_FUNC_END__;
3329                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3330         }
3331
3332         if (NULL == type) {
3333                 WDC_LOGE("NULL Param [type]!");
3334                 __WDC_LOG_FUNC_END__;
3335                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3336         }
3337
3338         WDC_LOGD("Current second_dev_type [%d]", WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PHONE_SM_DUAL);
3339         *type = WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PHONE_SM_DUAL;        // smart phone dual mode (wifi and cellular)
3340
3341         __WDC_LOG_FUNC_END__;
3342         return WIFI_DIRECT_ERROR_NONE;
3343 }
3344
3345 int wifi_direct_set_autoconnection_mode(bool mode)
3346 {
3347         __WDC_LOG_FUNC_START__;
3348         wifi_direct_client_info_s *client_info = __wfd_get_control();
3349         wifi_direct_client_request_s req;
3350         wifi_direct_client_response_s rsp;
3351         int res = WIFI_DIRECT_ERROR_NONE;
3352
3353         if ((client_info->is_registered == false) ||
3354                         (client_info->client_id == WFD_INVALID_ID)) {
3355                 WDC_LOGE("Client is NOT registered");
3356                 __WDC_LOG_FUNC_END__;
3357                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3358         }
3359
3360         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3361         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3362
3363         req.cmd = WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE;
3364         req.client_id = client_info->client_id;
3365         req.data.int1 = mode;
3366
3367         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3368         if (res != WIFI_DIRECT_ERROR_NONE) {
3369                 __WDC_LOG_FUNC_END__;
3370                 return res;
3371         }
3372
3373         __WDC_LOG_FUNC_END__;
3374         return WIFI_DIRECT_ERROR_NONE;
3375 }
3376
3377 int wifi_direct_is_autoconnection_mode(bool *mode)
3378 {
3379         __WDC_LOG_FUNC_START__;
3380         wifi_direct_client_info_s *client_info = __wfd_get_control();
3381         wifi_direct_client_request_s req;
3382         wifi_direct_client_response_s rsp;
3383         int res = WIFI_DIRECT_ERROR_NONE;
3384
3385         if ((client_info->is_registered == false) ||
3386                         (client_info->client_id == WFD_INVALID_ID)) {
3387                 WDC_LOGE("Client is NOT registered");
3388                 __WDC_LOG_FUNC_END__;
3389                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3390         }
3391
3392         if (!mode) {
3393                 WDC_LOGE("NULL Param [mode]!");
3394                 __WDC_LOG_FUNC_END__;
3395                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3396         }
3397
3398         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3399         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3400
3401         req.cmd = WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE;
3402         req.client_id = client_info->client_id;
3403
3404         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3405         if (res != WIFI_DIRECT_ERROR_NONE) {
3406                 __WDC_LOG_FUNC_END__;
3407                 return res;
3408         }
3409         WDC_LOGD("wifi_direct_is_autoconnection_mode() SUCCESS");
3410         *mode = (bool) rsp.param1;
3411
3412         __WDC_LOG_FUNC_END__;
3413         return WIFI_DIRECT_ERROR_NONE;
3414
3415 }
3416
3417
3418 int wifi_direct_set_persistent_group_enabled(bool enabled)
3419 {
3420         __WDC_LOG_FUNC_START__;
3421         wifi_direct_client_info_s *client_info = __wfd_get_control();
3422         wifi_direct_client_request_s req;
3423         wifi_direct_client_response_s rsp;
3424         int res = WIFI_DIRECT_ERROR_NONE;
3425
3426         if ((client_info->is_registered == false) ||
3427                         (client_info->client_id == WFD_INVALID_ID)) {
3428                 WDC_LOGE("Client is NOT registered");
3429                 __WDC_LOG_FUNC_END__;
3430                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3431         }
3432
3433         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3434         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3435
3436         if (enabled == true)
3437                 req.cmd = WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP;
3438         else
3439                 req.cmd = WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP;
3440         req.client_id = client_info->client_id;
3441
3442         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3443         if (res != WIFI_DIRECT_ERROR_NONE) {
3444                 __WDC_LOG_FUNC_END__;
3445                 return res;
3446         }
3447         WDC_LOGD("wifi_direct_set_persistent_group_enabled() SUCCESS");
3448
3449         __WDC_LOG_FUNC_END__;
3450         return WIFI_DIRECT_ERROR_NONE;
3451 }
3452
3453
3454 int wifi_direct_is_persistent_group_enabled(bool *enabled)
3455 {
3456         __WDC_LOG_FUNC_START__;
3457         wifi_direct_client_info_s *client_info = __wfd_get_control();
3458         wifi_direct_client_request_s req;
3459         wifi_direct_client_response_s rsp;
3460         int res = WIFI_DIRECT_ERROR_NONE;
3461
3462         if ((client_info->is_registered == false) ||
3463                         (client_info->client_id == WFD_INVALID_ID)) {
3464                 WDC_LOGE("Client is NOT registered");
3465                 __WDC_LOG_FUNC_END__;
3466                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3467         }
3468
3469         if (!enabled) {
3470                 WDC_LOGE("NULL Param [enabled]!");
3471                 __WDC_LOG_FUNC_END__;
3472                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3473         }
3474
3475         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3476         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3477
3478         req.cmd = WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP;
3479         req.client_id = client_info->client_id;
3480
3481         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3482         if (res != WIFI_DIRECT_ERROR_NONE) {
3483                 __WDC_LOG_FUNC_END__;
3484                 return res;
3485         }
3486         WDC_LOGD("wifi_direct_is_persistent_group_enabled() SUCCESS");
3487         *enabled = (bool) rsp.param1;
3488
3489         __WDC_LOG_FUNC_END__;
3490         return WIFI_DIRECT_ERROR_NONE;
3491 }
3492
3493 int wifi_direct_foreach_persistent_groups(wifi_direct_persistent_group_cb cb,
3494                                                                                                 void* user_data)
3495 {
3496         __WDC_LOG_FUNC_START__;
3497         wifi_direct_client_info_s *client_info = __wfd_get_control();
3498         wifi_direct_client_request_s req;
3499         wifi_direct_client_response_s rsp;
3500         int res = WIFI_DIRECT_ERROR_NONE;
3501         int i;
3502
3503         if ((client_info->is_registered == false) ||
3504                         (client_info->client_id == WFD_INVALID_ID)) {
3505                 WDC_LOGE("Client is NOT registered");
3506                 __WDC_LOG_FUNC_END__;
3507                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3508         }
3509
3510         if (!cb) {
3511                 WDC_LOGE("NULL Param [callback]!");
3512                 __WDC_LOG_FUNC_END__;
3513                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3514         }
3515
3516         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3517         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3518
3519         req.cmd = WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO;
3520         req.client_id = client_info->client_id;
3521
3522         pthread_mutex_lock(&g_client_info.mutex);
3523         res = __wfd_client_write_socket(client_info->sync_sockfd, &req, sizeof(wifi_direct_client_request_s));
3524         if (res != WIFI_DIRECT_ERROR_NONE) {
3525                 WDC_LOGE("Failed to write into socket [%s]", __wfd_print_error(res));
3526                 __wfd_reset_control();
3527                 pthread_mutex_unlock(&g_client_info.mutex);
3528                 __WDC_LOG_FUNC_END__;
3529                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3530         }
3531         WDC_LOGD("Succeeded to send request [%d: %s]", req.cmd, __wfd_client_print_cmd(req.cmd));
3532
3533         res = __wfd_client_read_socket(client_info->sync_sockfd, &rsp, sizeof(wifi_direct_client_response_s));
3534         if (res <= 0) {
3535                 WDC_LOGE("Failed to read socket [%d]", res);
3536                 __wfd_reset_control();
3537                 pthread_mutex_unlock(&g_client_info.mutex);
3538                 __WDC_LOG_FUNC_END__;
3539                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3540         } else {
3541                 if (rsp.cmd != req.cmd) {
3542                         WDC_LOGE("Invalid resp [%d]", rsp.cmd);
3543                         pthread_mutex_unlock(&g_client_info.mutex);
3544                         __WDC_LOG_FUNC_END__;
3545                         return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3546                 }
3547
3548                 if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
3549                         WDC_LOGE("Result received [%s]", __wfd_print_error(rsp.result));
3550                         pthread_mutex_unlock(&g_client_info.mutex);
3551                         __WDC_LOG_FUNC_END__;
3552                         return rsp.result;
3553                 }
3554         }
3555
3556         int num = rsp.param1;
3557         wfd_persistent_group_info_s *buff = NULL;
3558
3559         WDC_LOGD("Num of persistent groups = %d", (int) rsp.param1);
3560
3561         if (num > 0) {
3562                 buff = (wfd_persistent_group_info_s *) malloc(num * sizeof(wfd_persistent_group_info_s));
3563                 if (!buff) {
3564                         WDC_LOGE("malloc() failed!!!.");
3565                         pthread_mutex_unlock(&g_client_info.mutex);
3566                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3567                 }
3568
3569                 res = __wfd_client_read_socket(client_info->sync_sockfd, (char*) buff,
3570                                                                                 num * sizeof(wfd_persistent_group_info_s));
3571                 pthread_mutex_unlock(&g_client_info.mutex);
3572                 if (res <= 0){
3573                         free(buff);
3574                         WDC_LOGE("socket read error.");
3575                         __wfd_reset_control();
3576                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3577                 }
3578
3579                 __wfd_client_print_persistent_group_info(buff, num);
3580                 WDC_LOGD("wifi_direct_foreach_persistent_groups() SUCCESS");
3581
3582                 char *ssid;
3583                 char *go_mac_address;
3584
3585                 for (i = 0; i < num; i++) {
3586                         ssid = strdup(buff[i].ssid);
3587                         if (!ssid) {
3588                                 WDC_LOGD("Failed to copy ssid");
3589                                 break;
3590                         }
3591                         go_mac_address = (char*) calloc(1, MACSTR_LEN);
3592                         if (!go_mac_address) {
3593                                 WDC_LOGD("Failed to allocate memory for GO MAC address");
3594                                 free(ssid);
3595                                 free(buff);
3596                                 return WIFI_DIRECT_ERROR_OUT_OF_MEMORY;
3597                         }
3598                         snprintf(go_mac_address, MACSTR_LEN, MACSTR, MAC2STR(buff[i].go_mac_address));
3599
3600                         res = cb(go_mac_address, ssid, user_data);
3601                         free(ssid);
3602                         ssid = NULL;
3603                         free(go_mac_address);
3604                         go_mac_address = NULL;
3605                         if (!res)
3606                                 break;
3607                 }
3608
3609                 if (buff)
3610                         free(buff);
3611
3612         } else {
3613                 pthread_mutex_unlock(&g_client_info.mutex);
3614         }
3615
3616         __WDC_LOG_FUNC_END__;
3617         return WIFI_DIRECT_ERROR_NONE;
3618 }
3619
3620 int wifi_direct_remove_persistent_group(const char *mac_address, const char *ssid)
3621 {
3622         __WDC_LOG_FUNC_START__;
3623         wifi_direct_client_info_s *client_info = __wfd_get_control();
3624         wifi_direct_client_request_s req;
3625         wifi_direct_client_response_s rsp;
3626         wfd_persistent_group_info_s persistent_group_info;
3627         int status = WIFI_DIRECT_ERROR_NONE;
3628
3629         if ((client_info->is_registered == false) ||
3630                         (client_info->client_id == WFD_INVALID_ID)) {
3631                 WDC_LOGE("Client is NOT registered");
3632                 __WDC_LOG_FUNC_END__;
3633                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3634         }
3635
3636         if (!mac_address || !ssid) {
3637                 WDC_LOGE("NULL Param");
3638                 __WDC_LOG_FUNC_END__;
3639                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3640         }
3641
3642         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3643         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3644
3645         req.cmd = WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP;
3646         req.client_id = client_info->client_id;
3647
3648         pthread_mutex_lock(&g_client_info.mutex);
3649         status = __wfd_client_write_socket(client_info->sync_sockfd, &req,
3650                                                                   sizeof(wifi_direct_client_request_s));
3651         if (status != WIFI_DIRECT_ERROR_NONE) {
3652                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
3653                 __wfd_reset_control();
3654                 pthread_mutex_unlock(&g_client_info.mutex);
3655                 __WDC_LOG_FUNC_END__;
3656                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3657         }
3658         WDC_LOGD("writing msg hdr is success!");
3659
3660         strncpy(persistent_group_info.ssid, ssid, WIFI_DIRECT_MAX_SSID_LEN);
3661         persistent_group_info.ssid[WIFI_DIRECT_MAX_SSID_LEN] ='\0';
3662         macaddr_atoe(mac_address, persistent_group_info.go_mac_address);
3663
3664         status = __wfd_client_write_socket(client_info->sync_sockfd, &persistent_group_info,
3665                                                                   sizeof(wfd_persistent_group_info_s));
3666         if (status != WIFI_DIRECT_ERROR_NONE) {
3667                 WDC_LOGE("Error!!! writing to socket[%s]", __wfd_print_error(status));
3668                 __wfd_reset_control();
3669                 pthread_mutex_unlock(&g_client_info.mutex);
3670                 __WDC_LOG_FUNC_END__;
3671                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3672         }
3673
3674         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
3675                                                                   sizeof(wifi_direct_client_response_s));
3676         pthread_mutex_unlock(&g_client_info.mutex);
3677         if (status <= 0) {
3678                 WDC_LOGE("Error!!! reading socket, status = %d", status);
3679                 __wfd_reset_control();
3680                 __WDC_LOG_FUNC_END__;
3681                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3682         } else {
3683                 if (rsp.cmd == WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP) {
3684                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
3685                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
3686                                 WDC_LOGD("Error!!! [%s]", __wfd_print_error(rsp.result));
3687                                 __WDC_LOG_FUNC_END__;
3688                                 return rsp.result;
3689                         }
3690                 } else {
3691                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
3692                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3693                 }
3694         }
3695
3696         __WDC_LOG_FUNC_END__;
3697         return WIFI_DIRECT_ERROR_NONE;
3698 }
3699
3700 int wifi_direct_set_p2poem_loglevel(int increase_log_level)
3701 {
3702         __WDC_LOG_FUNC_START__;
3703         wifi_direct_client_info_s *client_info = __wfd_get_control();
3704         wifi_direct_client_request_s req;
3705         wifi_direct_client_response_s rsp;
3706         int res = WIFI_DIRECT_ERROR_NONE;
3707
3708         if ((client_info->is_registered == false) ||
3709                         (client_info->client_id == WFD_INVALID_ID)) {
3710                 WDC_LOGE("Client is NOT registered");
3711                 __WDC_LOG_FUNC_END__;
3712                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3713         }
3714
3715         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3716         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3717
3718         req.cmd = WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL;
3719         req.client_id = client_info->client_id;
3720         if (increase_log_level == 0)
3721                 req.data.int1 = false;
3722         else
3723                 req.data.int1 = true;
3724
3725         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
3726         if (res != WIFI_DIRECT_ERROR_NONE) {
3727                 __WDC_LOG_FUNC_END__;
3728                 return res;
3729         }
3730
3731         __WDC_LOG_FUNC_END__;
3732         return WIFI_DIRECT_ERROR_NONE;
3733 }
3734
3735 int wifi_direct_service_add(wifi_direct_service_type_e type, char *data1, char *data2)
3736 {
3737         __WDC_LOG_FUNC_START__;
3738         wifi_direct_client_info_s *client_info = __wfd_get_control();
3739         wifi_direct_client_request_s req;
3740         wifi_direct_client_response_s rsp;
3741         char *buf = NULL;
3742         char *ptr = NULL;
3743         int status = WIFI_DIRECT_ERROR_NONE;
3744         int len = 0;
3745         int data_len=0;
3746
3747         if (!data1 && !strlen(data1)) {
3748                 WDC_LOGE("NULL Param [data1]!");
3749                 __WDC_LOG_FUNC_END__;
3750                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3751         }
3752
3753         if ((client_info->is_registered == false) ||
3754                         (client_info->client_id == WFD_INVALID_ID)) {
3755                 WDC_LOGE("Client is NOT registered.");
3756                 __WDC_LOG_FUNC_END__;
3757                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3758         }
3759
3760         if (type >= WIFI_DIRECT_SERVICE_BONJOUR &&
3761                         type <= WIFI_DIRECT_SERVICE_VENDORSPEC) {
3762                 WDC_LOGD("Param service_type [%d]", type);
3763         } else {
3764                 WDC_LOGE("Invalid Param [type]!");
3765                 __WDC_LOG_FUNC_END__;
3766                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3767         }
3768
3769         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3770         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3771
3772 //TODO: modify the method to handle the NULL or zero length data
3773
3774         if (data2 && (data_len=strlen(data2)))
3775                 len =data_len +strlen(data1)+2;
3776         else
3777                 len = strlen(data1)+1;
3778
3779         WDC_LOGD("data1 [%s], data2 [%s], len [%d]", data1, data2, len);
3780         buf= calloc(sizeof(wifi_direct_client_request_s)+len, sizeof(char));
3781         if (NULL == buf) {
3782                 WDC_LOGE("Memory can't be allocated for Buf\n");
3783                 return WIFI_DIRECT_ERROR_OUT_OF_MEMORY;
3784         }
3785
3786         req.cmd = WIFI_DIRECT_CMD_SERVICE_ADD;
3787         req.client_id = client_info->client_id;
3788         req.data.int1 = type;
3789         req.data.int2 = data_len;
3790         req.cmd_data_len = len;
3791
3792         memcpy(buf, &req, sizeof(wifi_direct_client_request_s));
3793         ptr = buf;
3794         ptr += sizeof(wifi_direct_client_request_s);
3795         if(data_len)
3796                 snprintf(ptr, len, "%s %s", data2, data1);
3797         else
3798                 snprintf(ptr, len, "%s", data1);
3799
3800         pthread_mutex_lock(&g_client_info.mutex);
3801         status = __wfd_client_write_socket(client_info->sync_sockfd, buf,
3802                                                                         sizeof(wifi_direct_client_request_s) + len);
3803         free(buf);
3804         if (status != WIFI_DIRECT_ERROR_NONE) {
3805                 WDC_LOGE("Error!!! writing to socket, Errno = %s", strerror(errno));
3806                 __wfd_reset_control();
3807                 pthread_mutex_unlock(&g_client_info.mutex);
3808                 __WDC_LOG_FUNC_END__;
3809                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3810         }
3811         WDC_LOGD("Success writing data to the socket!");
3812
3813         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
3814                                                                                                 sizeof(wifi_direct_client_response_s));
3815         pthread_mutex_unlock(&g_client_info.mutex);
3816         if (status <= 0) {
3817                 WDC_LOGE("Error!!! reading socket, status = %d", status);
3818                 __wfd_reset_control();
3819                 __WDC_LOG_FUNC_END__;
3820                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3821         } else {
3822                 if (rsp.cmd == WIFI_DIRECT_CMD_SERVICE_ADD) {
3823                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
3824                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
3825                                 WDC_LOGD("Error!!! [%spin]", __wfd_print_error(rsp.result));
3826                                 __WDC_LOG_FUNC_END__;
3827                                 return rsp.result;
3828                         }
3829                 } else {
3830                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
3831                         __WDC_LOG_FUNC_END__;
3832                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3833                 }
3834         }
3835
3836         __WDC_LOG_FUNC_END__;
3837         return WIFI_DIRECT_ERROR_NONE;
3838 }
3839
3840 int wifi_direct_service_del(wifi_direct_service_type_e type, char *data1, char *data2)
3841 {
3842         __WDC_LOG_FUNC_START__;
3843         wifi_direct_client_info_s *client_info = __wfd_get_control();
3844         wifi_direct_client_request_s req;
3845         wifi_direct_client_response_s rsp;
3846         char *buf = NULL;
3847         char *ptr = NULL;
3848         int status = WIFI_DIRECT_ERROR_NONE;
3849         int len = 0;
3850         int data_len=0;
3851
3852         if (!data1 && !strlen(data1)) {
3853                 WDC_LOGE("NULL Param [data1]!");
3854                 __WDC_LOG_FUNC_END__;
3855                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3856         }
3857
3858         if ((client_info->is_registered == false) ||
3859                         (client_info->client_id == WFD_INVALID_ID)) {
3860                 WDC_LOGE("Client is NOT registered.");
3861                 __WDC_LOG_FUNC_END__;
3862                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3863         }
3864
3865         if (type >= WIFI_DIRECT_SERVICE_BONJOUR &&
3866                         type <= WIFI_DIRECT_SERVICE_VENDORSPEC) {
3867                 WDC_LOGD("Param service_type [%d]", type);
3868         } else {
3869                 WDC_LOGE("Invalid Param [type]!");
3870                 __WDC_LOG_FUNC_END__;
3871                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3872         }
3873
3874         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3875         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3876
3877 //TODO: modify the method to handle the NULL or zero length data
3878
3879         if (data2 && (data_len=strlen(data2)))
3880                 len =data_len +strlen(data1)+2;
3881         else
3882                 len = strlen(data1)+1;
3883
3884         WDC_LOGD("data1 [%s], data2 [%s], len [%d]", data1, data2, len);
3885         buf= calloc(sizeof(wifi_direct_client_request_s) + len, sizeof(char));
3886         if (NULL == buf) {
3887                 WDC_LOGE("Memory can't be allocated for Buf\n");
3888                 return WIFI_DIRECT_ERROR_OUT_OF_MEMORY;
3889         }
3890
3891         req.cmd = WIFI_DIRECT_CMD_SERVICE_DEL;
3892         req.client_id = client_info->client_id;
3893         req.data.int1 = type;
3894         req.data.int2 = data_len;
3895         req.cmd_data_len = len;
3896
3897         memcpy(buf, &req, sizeof(wifi_direct_client_request_s));
3898         ptr = buf;
3899         ptr += sizeof(wifi_direct_client_request_s);
3900         if(data_len)
3901                 snprintf(ptr, len, "%s %s", data2, data1);
3902         else
3903                 snprintf(ptr, len, "%s", data1);
3904
3905         pthread_mutex_lock(&g_client_info.mutex);
3906         status = __wfd_client_write_socket(client_info->sync_sockfd, buf,
3907                                                                         sizeof(wifi_direct_client_request_s) + len);
3908         free(buf);
3909         if (status != WIFI_DIRECT_ERROR_NONE) {
3910                 WDC_LOGE("Error!!! writing to socket, Errno = %s", strerror(errno));
3911                 __wfd_reset_control();
3912                 pthread_mutex_unlock(&g_client_info.mutex);
3913                 __WDC_LOG_FUNC_END__;
3914                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3915         }
3916         WDC_LOGD("Success writing data to the socket!");
3917
3918         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
3919                                                                                                 sizeof(wifi_direct_client_response_s));
3920         pthread_mutex_unlock(&g_client_info.mutex);
3921         if (status <= 0) {
3922                 WDC_LOGE("Error!!! reading socket, status = %d", status);
3923                 __wfd_reset_control();
3924                 __WDC_LOG_FUNC_END__;
3925                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
3926         } else {
3927                 if (rsp.cmd == WIFI_DIRECT_CMD_SERVICE_DEL) {
3928                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
3929                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
3930                                 WDC_LOGD("Error!!! [%spin]", __wfd_print_error(rsp.result));
3931                                 __WDC_LOG_FUNC_END__;
3932                                 return rsp.result;
3933                         }
3934                 } else {
3935                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
3936                         __WDC_LOG_FUNC_END__;
3937                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
3938                 }
3939         }
3940
3941         __WDC_LOG_FUNC_END__;
3942         return WIFI_DIRECT_ERROR_NONE;
3943 }
3944
3945
3946 int wifi_direct_serv_disc_req(char* mac_address, wifi_direct_service_type_e type, char *data1, char *data2)
3947 {
3948         __WDC_LOG_FUNC_START__;
3949         wifi_direct_client_info_s *client_info = __wfd_get_control();
3950         wifi_direct_client_request_s req;
3951         wifi_direct_client_response_s rsp;
3952         unsigned char la_mac_addr[6];
3953         char *buf = NULL;
3954         char *ptr = NULL;
3955         int status = WIFI_DIRECT_ERROR_NONE;
3956         int query_len = 0;
3957         int data_len = 0;
3958
3959
3960         if ((client_info->is_registered == false) ||
3961                         (client_info->client_id == WFD_INVALID_ID)) {
3962                 WDC_LOGE("Client is NOT registered.");
3963                 __WDC_LOG_FUNC_END__;
3964                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
3965         }
3966
3967         if (type >= WIFI_DIRECT_SERVICE_ALL &&
3968                         type <= WIFI_DIRECT_SERVICE_VENDORSPEC) {
3969                 WDC_LOGD("Param service_type [%d]", type);
3970         } else {
3971                 WDC_LOGE("Invalid Param [type]!");
3972                 __WDC_LOG_FUNC_END__;
3973                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
3974         }
3975
3976         memset(&req, 0, sizeof(wifi_direct_client_request_s));
3977         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
3978
3979         if(data2 && (data_len = strlen(data2)))
3980                 data_len++;
3981         if(data1 && (query_len = strlen(data1)))
3982                 query_len++;
3983
3984         WDC_LOGD("data [%s], query [%s]", data2, data1);
3985         buf= calloc(sizeof(wifi_direct_client_request_s)+data_len+query_len, sizeof(char));
3986         if (NULL == buf) {
3987                 WDC_LOGE("Memory can't be allocated for Buf\n");
3988                 return WIFI_DIRECT_ERROR_OUT_OF_MEMORY;
3989         }
3990
3991         req.cmd = WIFI_DIRECT_CMD_SERV_DISC_REQ;
3992         req.client_id = client_info->client_id;
3993         req.data.int1 = type;
3994         req.data.int2 = data_len;
3995         req.cmd_data_len = data_len+ query_len;
3996         macaddr_atoe(mac_address, la_mac_addr);
3997         memcpy(req.data.mac_addr, la_mac_addr, MACADDR_LEN);
3998
3999         memcpy(buf, &req, sizeof(wifi_direct_client_request_s));
4000         ptr = buf;
4001         ptr += sizeof(wifi_direct_client_request_s);
4002
4003         if(data_len)
4004                 snprintf(ptr, data_len+query_len, "%s %s", data2, data1);
4005         else if(query_len)
4006                 snprintf(ptr, query_len, "%s", data1);
4007
4008         pthread_mutex_lock(&g_client_info.mutex);
4009         status = __wfd_client_write_socket(client_info->sync_sockfd, buf,
4010                                                                         sizeof(wifi_direct_client_request_s) + req.cmd_data_len);
4011         free(buf);
4012         if (status != WIFI_DIRECT_ERROR_NONE) {
4013                 WDC_LOGE("Error!!! writing to socket, Errno = %s", strerror(errno));
4014                 __wfd_reset_control();
4015                 pthread_mutex_unlock(&g_client_info.mutex);
4016                 __WDC_LOG_FUNC_END__;
4017                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
4018         }
4019         WDC_LOGD("Success writing data to the socket!");
4020
4021         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
4022                                                                                                 sizeof(wifi_direct_client_response_s));
4023         pthread_mutex_unlock(&g_client_info.mutex);
4024         if (status <= 0) {
4025                 WDC_LOGE("Error!!! reading socket, status = %d", status);
4026                 __wfd_reset_control();
4027                 __WDC_LOG_FUNC_END__;
4028                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
4029         } else {
4030                 if (rsp.cmd == WIFI_DIRECT_CMD_SERV_DISC_REQ) {
4031                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
4032                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
4033                                 WDC_LOGD("Error!!! [%spin]", __wfd_print_error(rsp.result));
4034                                 __WDC_LOG_FUNC_END__;
4035                                 return rsp.result;
4036                         }
4037                 } else {
4038                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
4039                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
4040                 }
4041         }
4042         WDC_LOGD("handle = [%d]\n", (int) rsp.param1);
4043         __WDC_LOG_FUNC_END__;
4044         return rsp.param1;
4045 }
4046
4047 int wifi_direct_serv_disc_cancel(int handle)
4048 {
4049         __WDC_LOG_FUNC_START__;
4050         wifi_direct_client_info_s *client_info = __wfd_get_control();
4051         wifi_direct_client_request_s req;
4052         wifi_direct_client_response_s rsp;
4053         int res = WIFI_DIRECT_ERROR_NONE;
4054
4055         if ((client_info->is_registered == false) ||
4056                         (client_info->client_id == WFD_INVALID_ID)) {
4057                 WDC_LOGE("Client is NOT registered");
4058                 __WDC_LOG_FUNC_END__;
4059                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4060         }
4061
4062         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4063         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4064
4065         req.cmd = WIFI_DIRECT_CMD_SERV_DISC_CANCEL;
4066         req.client_id = client_info->client_id;
4067         req.data.int1 = handle;
4068
4069         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4070         if (res != WIFI_DIRECT_ERROR_NONE) {
4071                 __WDC_LOG_FUNC_END__;
4072                 return res;
4073         }
4074
4075         __WDC_LOG_FUNC_END__;
4076         return WIFI_DIRECT_ERROR_NONE;
4077 }
4078
4079 int wifi_direct_init_wifi_display(wifi_direct_display_type_e type, int port, int hdcp)
4080 {
4081         __WDC_LOG_FUNC_START__;
4082         wifi_direct_client_info_s *client_info = __wfd_get_control();
4083         wifi_direct_client_request_s req;
4084         wifi_direct_client_response_s rsp;
4085         char *buf = NULL;
4086         char *ptr = NULL;
4087         int status = WIFI_DIRECT_ERROR_NONE;
4088                 if ((client_info->is_registered == false) ||
4089                         (client_info->client_id == WFD_INVALID_ID)) {
4090                 WDC_LOGE("Client is NOT registered.");
4091                 __WDC_LOG_FUNC_END__;
4092                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4093         }
4094
4095         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4096         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4097
4098         WDC_LOGD("type [%d], port [%d], hdcp [%d]", type, port, hdcp);
4099         buf= calloc(sizeof(wifi_direct_client_request_s) + sizeof(int), sizeof(char));
4100         if (NULL == buf) {
4101                 WDC_LOGE("Memory can't be allocated for Buf\n");
4102                 return WIFI_DIRECT_ERROR_OUT_OF_MEMORY;
4103         }
4104
4105         req.cmd = WIFI_DIRECT_CMD_INIT_WIFI_DISPLAY;
4106         req.client_id = client_info->client_id;
4107         req.data.int1 = type;
4108         req.data.int2 = port;
4109         req.cmd_data_len = sizeof(int);
4110
4111         memcpy(buf, &req, sizeof(wifi_direct_client_request_s));
4112         ptr = buf;
4113         ptr += sizeof(wifi_direct_client_request_s);
4114         memcpy(ptr, &hdcp, sizeof(int));
4115
4116         pthread_mutex_lock(&g_client_info.mutex);
4117         status = __wfd_client_write_socket(client_info->sync_sockfd, buf,
4118                                                                         sizeof(wifi_direct_client_request_s) + sizeof(int));
4119         free(buf);
4120         if (status != WIFI_DIRECT_ERROR_NONE) {
4121                 WDC_LOGE("Error!!! writing to socket, Errno = %s", strerror(errno));
4122                 __wfd_reset_control();
4123                 pthread_mutex_unlock(&g_client_info.mutex);
4124                 __WDC_LOG_FUNC_END__;
4125                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
4126         }
4127         WDC_LOGD("Success writing data to the socket!");
4128
4129         status = __wfd_client_read_socket(client_info->sync_sockfd, (char*) &rsp,
4130                                                                                                 sizeof(wifi_direct_client_response_s));
4131         pthread_mutex_unlock(&g_client_info.mutex);
4132         if (status <= 0) {
4133                 WDC_LOGE("Error!!! reading socket, status = %d", status);
4134                 __wfd_reset_control();
4135                 __WDC_LOG_FUNC_END__;
4136                 return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
4137         } else {
4138                 if (rsp.cmd == WIFI_DIRECT_CMD_INIT_WIFI_DISPLAY) {
4139                         if (rsp.result != WIFI_DIRECT_ERROR_NONE) {
4140                                 WDC_LOGD("Error!!! Result received = %d", rsp.result);
4141                                 WDC_LOGD("Error!!! [%spin]", __wfd_print_error(rsp.result));
4142                                 __WDC_LOG_FUNC_END__;
4143                                 return rsp.result;
4144                         }
4145                 } else {
4146                         WDC_LOGE("Error!!! Invalid resp cmd = %d", rsp.cmd);
4147                         __WDC_LOG_FUNC_END__;
4148                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
4149                 }
4150         }
4151         __WDC_LOG_FUNC_END__;
4152         return WIFI_DIRECT_ERROR_NONE;
4153 }
4154
4155 int wifi_direct_deinit_wifi_display(void)
4156 {
4157         __WDC_LOG_FUNC_START__;
4158         wifi_direct_client_info_s *client_info = __wfd_get_control();
4159         wifi_direct_client_request_s req;
4160         wifi_direct_client_response_s rsp;
4161         int res = WIFI_DIRECT_ERROR_NONE;
4162
4163         if ((client_info->is_registered == false) ||
4164                         (client_info->client_id == WFD_INVALID_ID)) {
4165                 WDC_LOGE("Client is NOT registered");
4166                 __WDC_LOG_FUNC_END__;
4167                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4168         }
4169
4170         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4171         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4172
4173         req.cmd = WIFI_DIRECT_CMD_DEINIT_WIFI_DISPLAY;
4174         req.client_id = client_info->client_id;
4175
4176         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4177         if (res != WIFI_DIRECT_ERROR_NONE) {
4178                 __WDC_LOG_FUNC_END__;
4179                 return res;
4180         }
4181         WDC_LOGD("wifi_direct_deinit_wifi_display() SUCCESS");
4182
4183         __WDC_LOG_FUNC_END__;
4184         return WIFI_DIRECT_ERROR_NONE;
4185 }
4186
4187 int wifi_direct_get_display_port(int *port)
4188 {
4189         __WDC_LOG_FUNC_START__;
4190         wifi_direct_client_info_s *client_info = __wfd_get_control();
4191         wifi_direct_client_request_s req;
4192         wifi_direct_client_response_s rsp;
4193         int res = WIFI_DIRECT_ERROR_NONE;
4194
4195         if ((client_info->is_registered == false) ||
4196                         (client_info->client_id == WFD_INVALID_ID)) {
4197                 WDC_LOGE("Client is NOT registered");
4198                 __WDC_LOG_FUNC_END__;
4199                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4200         }
4201
4202         if (!port) {
4203                 WDC_LOGE("NULL Param [port]!");
4204                 __WDC_LOG_FUNC_END__;
4205                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
4206         }
4207
4208         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4209         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4210
4211         req.cmd = WIFI_DIRECT_CMD_GET_DISPLAY_PORT;
4212         req.client_id = client_info->client_id;
4213
4214         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4215         if (res != WIFI_DIRECT_ERROR_NONE) {
4216                 __WDC_LOG_FUNC_END__;
4217                 return res;
4218         }
4219         WDC_LOGD("wifi_direct_get_display_port() SUCCESS");
4220         *port = (int) rsp.param1;
4221
4222         __WDC_LOG_FUNC_END__;
4223         return WIFI_DIRECT_ERROR_NONE;
4224 }
4225
4226 int wifi_direct_get_display_type(wifi_direct_display_type_e *type)
4227 {
4228         __WDC_LOG_FUNC_START__;
4229         wifi_direct_client_info_s *client_info = __wfd_get_control();
4230         wifi_direct_client_request_s req;
4231         wifi_direct_client_response_s rsp;
4232         int res = WIFI_DIRECT_ERROR_NONE;
4233
4234         if ((client_info->is_registered == false) ||
4235                         (client_info->client_id == WFD_INVALID_ID)) {
4236                 WDC_LOGE("Client is NOT registered");
4237                 __WDC_LOG_FUNC_END__;
4238                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4239         }
4240
4241         if (!type) {
4242                 WDC_LOGE("NULL Param [type]!");
4243                 __WDC_LOG_FUNC_END__;
4244                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
4245         }
4246
4247         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4248         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4249
4250         req.cmd = WIFI_DIRECT_CMD_GET_DISPLAY_TYPE;
4251         req.client_id = client_info->client_id;
4252
4253         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4254         if (res != WIFI_DIRECT_ERROR_NONE) {
4255                 __WDC_LOG_FUNC_END__;
4256                 return res;
4257         }
4258         WDC_LOGD("wifi_direct_get_display_type() SUCCESS");
4259         *type = (wifi_direct_display_type_e) rsp.param1;
4260
4261         __WDC_LOG_FUNC_END__;
4262         return WIFI_DIRECT_ERROR_NONE;
4263 }
4264
4265 int wifi_direct_add_to_access_list(const char *mac_address, bool allow)
4266 {
4267         __WDC_LOG_FUNC_START__;
4268         wifi_direct_client_info_s *client_info = __wfd_get_control();
4269         unsigned char la_mac_addr[6];
4270         wifi_direct_client_request_s req;
4271         wifi_direct_client_response_s rsp;
4272         int res = WIFI_DIRECT_ERROR_NONE;
4273
4274         if ((client_info->is_registered == false) ||
4275                         (client_info->client_id == WFD_INVALID_ID)) {
4276                 WDC_LOGE("Client is NOT registered");
4277                 __WDC_LOG_FUNC_END__;
4278                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4279         }
4280
4281         if (!mac_address) {
4282                 WDC_LOGE("mac_addr is NULL");
4283                 __WDC_LOG_FUNC_END__;
4284                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
4285         }
4286
4287         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4288         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4289
4290         req.cmd = WIFI_DIRECT_CMD_ADD_TO_ACCESS_LIST;
4291         req.client_id = client_info->client_id;
4292         req.data.int1 = allow;
4293         macaddr_atoe(mac_address, la_mac_addr);
4294         memcpy(req.data.mac_addr, la_mac_addr, MACADDR_LEN);
4295
4296         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4297         if (res != WIFI_DIRECT_ERROR_NONE) {
4298                 __WDC_LOG_FUNC_END__;
4299                 return res;
4300         }
4301         WDC_LOGD("wifi_direct_add_device_to_list() SUCCESS");
4302
4303         __WDC_LOG_FUNC_END__;
4304         return WIFI_DIRECT_ERROR_NONE;
4305 }
4306
4307 int wifi_direct_del_from_access_list(const char *mac_address)
4308 {
4309         __WDC_LOG_FUNC_START__;
4310         wifi_direct_client_info_s *client_info = __wfd_get_control();
4311         unsigned char la_mac_addr[6];
4312         wifi_direct_client_request_s req;
4313         wifi_direct_client_response_s rsp;
4314         int res = WIFI_DIRECT_ERROR_NONE;
4315
4316         if ((client_info->is_registered == false) ||
4317                         (client_info->client_id == WFD_INVALID_ID)) {
4318                 WDC_LOGE("Client is NOT registered");
4319                 __WDC_LOG_FUNC_END__;
4320                 return WIFI_DIRECT_ERROR_NOT_INITIALIZED;
4321         }
4322
4323         if (!mac_address) {
4324                 WDC_LOGE("mac_addr is NULL");
4325                 __WDC_LOG_FUNC_END__;
4326                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
4327         }
4328
4329         memset(&req, 0, sizeof(wifi_direct_client_request_s));
4330         memset(&rsp, 0, sizeof(wifi_direct_client_response_s));
4331
4332         req.cmd = WIFI_DIRECT_CMD_DEL_FROM_ACCESS_LIST;
4333         req.client_id = client_info->client_id;
4334         macaddr_atoe(mac_address, la_mac_addr);
4335         memcpy(req.data.mac_addr, la_mac_addr, MACADDR_LEN);
4336
4337         res = __wfd_client_send_request(client_info->sync_sockfd, &req, &rsp);
4338         if (res != WIFI_DIRECT_ERROR_NONE) {
4339                 __WDC_LOG_FUNC_END__;
4340                 return res;
4341         }
4342         WDC_LOGD("wifi_direct_del_device_from_list() SUCCESS");
4343
4344         __WDC_LOG_FUNC_END__;
4345         return WIFI_DIRECT_ERROR_NONE;
4346 }
4347