src/wifi-direct-client-proxy.c

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