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