src/wifi-direct-client.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct client functions.
  22  *
  23  * @file                wifi-direct-client.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <sys/stat.h>
  34 #include <sys/un.h>
  35 #include <poll.h>
  36 #include <unistd.h>
  37 #include <errno.h>
  38
  39 #include <glib.h>
  40 #include <vconf.h>
  41
  42 #include <wifi-direct.h>
  43 //#include <security-server/security-server.h>
  44
  45 #include "wifi-direct-ipc.h"
  46 #include "wifi-direct-manager.h"
  47 #include "wifi-direct-oem.h"
  48 #include "wifi-direct-session.h"
  49 #include "wifi-direct-group.h"
  50 #include "wifi-direct-client.h"
  51 #include "wifi-direct-util.h"
  52 #include "wifi-direct-state.h"
  53 #include "wifi-direct-peer.h"
  54
  55 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
  56 #include "wifi-direct-service.h"
  57 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
  58
  59
  60 static int _wfd_deregister_client(void *data, int client_id);
  61 static gboolean wfd_client_process_request(GIOChannel *source,
  62                                                                         GIOCondition condition,
  63                                                                         gpointer user_data);
  64 #if 0
  65 #if !defined TIZEN_TV
  66 static int _wfd_check_client_privilege(int client_sock, int cmd);
  67 #endif
  68 #endif
  69 char *wfd_server_print_cmd(wifi_direct_cmd_e cmd)
  70 {
  71         switch (cmd)
  72         {
  73         case WIFI_DIRECT_CMD_REGISTER:
  74                 return "WIFI_DIRECT_CMD_REGISTER";
  75         case WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET:
  76                 return "WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET";
  77         case WIFI_DIRECT_CMD_DEREGISTER:
  78                 return "WIFI_DIRECT_CMD_DEREGISTER";
  79         case WIFI_DIRECT_CMD_ACTIVATE:
  80                 return "WIFI_DIRECT_CMD_ACTIVATE";
  81         case WIFI_DIRECT_CMD_DEACTIVATE:
  82                 return "WIFI_DIRECT_CMD_DEACTIVATE";
  83         case WIFI_DIRECT_CMD_START_DISCOVERY:
  84                 return "WIFI_DIRECT_CMD_START_DISCOVERY";
  85         case WIFI_DIRECT_CMD_START_DISCOVERY_SPECIFIC_CHANNEL:
  86                 return "WIFI_DIRECT_CMD_START_DISCOVERY_SPECIFIC_CHANNEL";
  87         case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
  88                 return "WIFI_DIRECT_CMD_CANCEL_DISCOVERY";
  89         case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
  90                 return "WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT";
  91         case WIFI_DIRECT_CMD_GET_LINK_STATUS:
  92                 return "WIFI_DIRECT_CMD_GET_LINK_STATUS";
  93         case WIFI_DIRECT_CMD_CONNECT:
  94                 return "WIFI_DIRECT_CMD_CONNECT";
  95         case WIFI_DIRECT_CMD_CANCEL_CONNECTION:
  96                 return "WIFI_DIRECT_CMD_CANCEL_CONNECTION";
  97         case WIFI_DIRECT_CMD_REJECT_CONNECTION:
  98                 return "WIFI_DIRECT_CMD_REJECT_CONNECTION";
  99
 100         case WIFI_DIRECT_CMD_DISCONNECT_ALL:
 101                 return "WIFI_DIRECT_CMD_DISCONNECT_ALL";
 102         case WIFI_DIRECT_CMD_CREATE_GROUP:
 103                 return "WIFI_DIRECT_CMD_CREATE_GROUP";
 104         case WIFI_DIRECT_CMD_IS_GROUPOWNER:
 105                 return "WIFI_DIRECT_CMD_IS_GROUPOWNER";
 106         case WIFI_DIRECT_CMD_GET_SSID:
 107                 return "WIFI_DIRECT_CMD_GET_SSID";
 108         case WIFI_DIRECT_CMD_SET_SSID:
 109                 return "WIFI_DIRECT_CMD_SET_SSID";
 110         case WIFI_DIRECT_CMD_GET_IP_ADDR:
 111                 return "WIFI_DIRECT_CMD_GET_IP_ADDR";
 112         case WIFI_DIRECT_CMD_GET_CONFIG:
 113                 return "WIFI_DIRECT_CMD_GET_CONFIG";
 114         case WIFI_DIRECT_CMD_SET_CONFIG:
 115                 return "WIFI_DIRECT_CMD_SET_CONFIG";
 116         case WIFI_DIRECT_CMD_SEND_CONNECT_REQ:
 117                 return "WIFI_DIRECT_CMD_SEND_CONNECT_REQ";
 118
 119         case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
 120                 return "WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON";
 121         case WIFI_DIRECT_CMD_SET_WPS_PIN:
 122                 return "WIFI_DIRECT_CMD_SET_WPS_PIN";
 123         case WIFI_DIRECT_CMD_GET_WPS_PIN:
 124                 return "WIFI_DIRECT_CMD_GET_WPS_PIN";
 125         case WIFI_DIRECT_CMD_GENERATE_WPS_PIN:
 126                 return "WIFI_DIRECT_CMD_GENERATE_WPS_PIN";
 127         case WIFI_DIRECT_CMD_SET_WPA:
 128                 return "WIFI_DIRECT_CMD_SET_WPA";
 129         case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:
 130                 return "WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE";
 131         case WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE:
 132                 return "WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE";
 133         case WIFI_DIRECT_CMD_GET_REQ_WPS_MODE:
 134                 return "WIFI_DIRECT_CMD_GET_REQ_WPS_MODE";
 135         case WIFI_DIRECT_CMD_SET_REQ_WPS_MODE:
 136                 return "WIFI_DIRECT_CMD_SET_REQ_WPS_MODE";
 137         case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
 138                 return "WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO";
 139         case WIFI_DIRECT_CMD_DESTROY_GROUP:
 140                 return "WIFI_DIRECT_CMD_DESTROY_GROUP";
 141
 142         case WIFI_DIRECT_CMD_DISCONNECT:
 143                 return "WIFI_DIRECT_CMD_DISCONNECT";
 144         case WIFI_DIRECT_CMD_SET_GO_INTENT:
 145                 return "WIFI_DIRECT_CMD_SET_GO_INTENT";
 146         case WIFI_DIRECT_CMD_GET_GO_INTENT:
 147                 return "WIFI_DIRECT_CMD_GET_GO_INTENT";
 148         case WIFI_DIRECT_CMD_GET_MAC_ADDR:
 149                 return "WIFI_DIRECT_CMD_GET_MAC_ADDR";
 150         case WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP:
 151                 return "WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP";
 152         case WIFI_DIRECT_CMD_SET_MAX_CLIENT:
 153                 return "WIFI_DIRECT_CMD_SET_MAX_CLIENT";
 154         case WIFI_DIRECT_CMD_GET_MAX_CLIENT:
 155                 return "WIFI_DIRECT_CMD_GET_MAX_CLIENT";
 156         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE:
 157                 return "WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE";
 158
 159         case WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE:
 160                 return "WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE";
 161         case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
 162                 return "WIFI_DIRECT_CMD_IS_DISCOVERABLE";
 163         case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
 164                 return "WIFI_DIRECT_CMD_IS_LISTENING_ONLY";
 165         case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
 166                 return "WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL";
 167         case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
 168                 return "WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP";
 169         case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
 170                 return "WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP";
 171         case WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP:
 172                 return "WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP";
 173         case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO:
 174                 return "WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO";
 175         case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:
 176                 return "WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP";
 177         case WIFI_DIRECT_CMD_GET_DEVICE_NAME:
 178                 return "WIFI_DIRECT_CMD_GET_DEVICE_NAME";
 179
 180         case WIFI_DIRECT_CMD_SET_DEVICE_NAME:
 181                 return "WIFI_DIRECT_CMD_SET_DEVICE_NAME";
 182         case WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL:
 183                 return "WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL";
 184         case WIFI_DIRECT_CMD_GET_PEER_INFO:
 185                 return "WIFI_DIRECT_CMD_GET_PEER_INFO";
 186
 187         case WIFI_DIRECT_CMD_SET_PASSPHRASE:
 188                 return "WIFI_DIRECT_CMD_SET_PASSPHRASE";
 189         case WIFI_DIRECT_CMD_GET_PASSPHRASE:
 190                 return "WIFI_DIRECT_CMD_GET_PASSPHRASE";
 191         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_PEER:
 192                 return "WIFI_DIRECT_CMD_SET_AUTOCONNECTION_PEER";
 193
 194 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 195         case WIFI_DIRECT_CMD_REGISTER_LOCAL_SERVICE:
 196                 return "WIFI_DIRECT_CMD_REGISTER_LOCAL_SERVICE";
 197         case WIFI_DIRECT_CMD_DEREGISTER_LOCAL_SERVICE:
 198                 return "WIFI_DIRECT_CMD_DEREGISTER_LOCAL_SERVICE";
 199         case WIFI_DIRECT_CMD_START_SERVICE_DISCOVERY:
 200                 return "WIFI_DIRECT_CMD_START_SERVICE_DISCOVERY";
 201         case WIFI_DIRECT_CMD_CANCEL_SERVICE_DISCOVERY:
 202                 return "WIFI_DIRECT_CMD_CANCEL_SERVICE_DISCOVERY";
 203         case WIFI_DIRECT_CMD_REGISTER_SERVICE:
 204                 return "WIFI_DIRECT_CMD_REGISTER_SERVICE";
 205         case WIFI_DIRECT_CMD_DEREGISTER_SERVICE:
 206                 return "WIFI_DIRECT_CMD_DEREGISTER_SERVICE";
 207 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 208
 209 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 210         case WIFI_DIRECT_CMD_INIT_MIRACAST:
 211                 return "WIFI_DIRECT_CMD_INIT_MIRACAST";
 212         case WIFI_DIRECT_CMD_INIT_DISPLAY:
 213                 return "WIFI_DIRECT_CMD_INIT_DISPLAY";
 214         case WIFI_DIRECT_CMD_DEINIT_DISPLAY:
 215                 return "WIFI_DIRECT_CMD_DEINIT_DISPLAY";
 216         case WIFI_DIRECT_CMD_SET_DISPLAY:
 217                 return "WIFI_DIRECT_CMD_SET_DISPLAY";
 218         case WIFI_DIRECT_CMD_SET_DISPLAY_AVAILABILITY:
 219                 return "WIFI_DIRECT_CMD_SET_DISPLAY_AVAILABILITY";
 220         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_TYPE:
 221                 return "WIFI_DIRECT_CMD_GET_PEER_DISPLAY_TYPE";
 222         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_AVAILABILITY:
 223                 return "WIFI_DIRECT_CMD_GET_PEER_DISPLAY_AVAILABILITY";
 224         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_HDCP:
 225                 return "WIFI_DIRECT_CMD_GET_PEER_DISPLAY_HDCP";
 226         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_PORT:
 227                 return "WIFI_DIRECT_CMD_GET_PEER_DISPLAY_PORT";
 228         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_THROUGHPUT:
 229                 return "WIFI_DIRECT_CMD_GET_PEER_DISPLAY_THROUGHPUT";
 230 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 231
 232         default:
 233                 return "WIFI_DIRECT_CMD_INVALID";
 234
 235         }
 236 }
 237
 238 static wfd_client_s *_wfd_client_find_by_id(GList *clients, int client_id)
 239 {
 240         __WDS_LOG_FUNC_ENTER__;
 241         wfd_client_s *client = NULL;
 242         GList *temp = NULL;
 243
 244         if (!clients || client_id < 0) {
 245                 WDS_LOGE("Invalid parameter(client_id:%d)", client_id);
 246                 return NULL;
 247         }
 248
 249         temp = g_list_first(clients);
 250         while (temp) {
 251                 client = (wfd_client_s*) temp->data;
 252                 if (client->client_id == client_id) {
 253                         WDS_LOGD("Client found. [%d]", client_id);
 254                         break;
 255                 }
 256                 temp = g_list_next(temp);
 257                 client = NULL;
 258         }
 259
 260         __WDS_LOG_FUNC_EXIT__;
 261         return client;
 262 }
 263
 264 static int _wfd_client_check_socket(int sock)
 265 {
 266         struct pollfd p_fd;
 267         int res = 0;
 268
 269         p_fd.fd = sock;
 270         p_fd.events = POLLIN | POLLOUT | POLLERR | POLLHUP | POLLNVAL;
 271         res = poll((struct pollfd *) &p_fd, 1, 1);
 272
 273         if (res < 0) {
 274                 WDS_LOGE("Polling error from socket[%d]. [%s]", sock, strerror(errno));
 275                 return -1;
 276         } else if (res == 0) {
 277                 WDS_LOGD( "poll timeout. socket is busy\n");
 278                 return 1;
 279         } else {
 280
 281                 if (p_fd.revents & POLLERR) {
 282                         WDS_LOGE("Error! POLLERR from socket[%d]", sock);
 283                         return -1;
 284                 } else if (p_fd.revents & POLLHUP) {
 285                         WDS_LOGE("Error! POLLHUP from socket[%d]", sock);
 286                         return -1;
 287                 } else if (p_fd.revents & POLLNVAL) {
 288                         WDS_LOGE("Error! POLLNVAL from socket[%d]", sock);
 289                         return -1;
 290                 } else if (p_fd.revents & POLLIN) {
 291                         WDS_LOGD("POLLIN from socket [%d]", sock);
 292                         return 0;
 293                 } else if (p_fd.revents & POLLOUT) {
 294                         WDS_LOGD("POLLOUT from socket [%d]", sock);
 295                         return 0;
 296                 }
 297         }
 298
 299         WDS_LOGD("Unknown poll event [%d]", p_fd.revents);
 300         return -1;
 301 }
 302
 303 static int _wfd_send_to_client(int sock, char *data, int data_len)
 304 {
 305         __WDS_LOG_FUNC_ENTER__;
 306         int wbytes = 0;
 307         int left_len = data_len;
 308         char *ptr = data;
 309         int res = 0;
 310
 311         if (sock < SOCK_FD_MIN || !data || data_len < 0) {
 312                 WDS_LOGE("Invalid parameter");
 313                 return -1;
 314         }
 315
 316         res = _wfd_client_check_socket(sock);
 317         if (res < 0) {
 318                 WDS_LOGE("Socket error");
 319                 return -1;
 320         } else if (res > 0) {
 321                 WDS_LOGE("Socket is busy");
 322                 return -2;
 323         }
 324
 325         errno = 0;
 326         while (left_len) {
 327                 wbytes = write(sock, ptr, left_len);
 328                 if (wbytes <= 0) {
 329                         WDS_LOGE("Failed to write data into socket[%d]. [error=%s]", sock, strerror(errno));
 330                         break;
 331                 }else if (wbytes < left_len) {
 332                         WDS_LOGD("%d bytes left. Continue sending...", left_len - wbytes);
 333                         left_len -= wbytes;
 334                         ptr += wbytes;
 335                 } else if (wbytes == left_len) {
 336                         WDS_LOGD("Succeeded to write data[%d bytes] into socket [%d]", wbytes, sock);
 337                         left_len = 0;
 338                 } else {
 339                         WDS_LOGE("Unknown error occurred. [%s]", strerror(errno));
 340                         break;
 341                 }
 342         }
 343
 344         __WDS_LOG_FUNC_EXIT__;
 345         if (left_len)
 346                 return -1;
 347         else
 348                 return 0;
 349 }
 350
 351 static int _wfd_read_from_client(int sock, char *data, int data_len)
 352 {
 353         __WDS_LOG_FUNC_ENTER__;
 354         int rbytes = 0;
 355         int total_rbytes = 0;
 356         int res = 0;
 357
 358         if(sock < SOCK_FD_MIN || !data || data_len <= 0) {
 359                 WDS_LOGE("Invalid parameter");
 360                 return -1;
 361         }
 362
 363         res = _wfd_client_check_socket(sock);
 364         if (res < 0) {
 365                 WDS_LOGE("Socket error");
 366                 return -1;
 367         } else if (res > 0) {
 368                 WDS_LOGE("Socket is busy");
 369                 return -2;
 370         }
 371
 372         while(data_len) {
 373                 errno = 0;
 374                 rbytes = read(sock, data, data_len);
 375                 if (rbytes <= 0) {
 376                         WDS_LOGE("Failed to read data from socket[%d]", sock);
 377                         return -1;
 378                 }
 379                 total_rbytes += rbytes;
 380                 data += rbytes;
 381                 data_len -= rbytes;
 382         }
 383
 384         __WDS_LOG_FUNC_EXIT__;
 385         return total_rbytes;
 386 }
 387
 388 int wfd_client_send_event(wfd_manager_s *manager, wifi_direct_client_noti_s *noti)
 389 {
 390         __WDS_LOG_FUNC_ENTER__;
 391         int cnt = 0;
 392         int res = 0;
 393         wfd_client_s *client = NULL;
 394         GList *temp = NULL;
 395
 396         if (!manager || !noti) {
 397                 WDS_LOGE("Invalid parameter");
 398                 __WDS_LOG_FUNC_EXIT__;
 399                 return -1;
 400         }
 401
 402         temp = g_list_first(manager->clients);
 403         while (temp) {
 404                 client = temp->data;
 405                 res = _wfd_send_to_client(client->asock, (char*) noti, sizeof(wifi_direct_client_noti_s));
 406                 if (res < 0) {
 407                         WDS_LOGE("Failed to send Notification[%d] to client [%d]", noti->event, client->client_id);
 408                         temp = g_list_next(temp);
 409                         _wfd_deregister_client(manager, client->client_id);
 410                 } else {
 411                         WDS_LOGD("Succeeded to send Notification [%d:%d] to client [%d]", noti->event,
 412                                                                         noti->error, client->client_id);
 413                         temp = g_list_next(temp);
 414                         cnt++;
 415                 }
 416                 client = NULL;
 417         }
 418         WDS_LOGD("Notification[%d:%d] sent to %d clients, Not Sent [%d]",
 419                                         noti->event, noti->error, cnt, manager->client_count - cnt);
 420
 421
 422         __WDS_LOG_FUNC_EXIT__;
 423         return 0;
 424 }
 425
 426 static int _wfd_register_client(void *data, int sock)
 427 {
 428         __WDS_LOG_FUNC_ENTER__;
 429         int rbytes = 0;
 430         wifi_direct_client_request_s req;
 431         wifi_direct_client_response_s rsp;
 432         wfd_manager_s *manager = (wfd_manager_s*) data;
 433         wfd_client_s *client = NULL;
 434         int res = 0;
 435
 436         if (sock < SOCK_FD_MIN) {
 437                 WDS_LOGE("Invalid argument");
 438                 __WDS_LOG_FUNC_EXIT__;
 439                 return -1;
 440         }
 441
 442         errno = 0;
 443         rbytes = read(sock, (char*) &req, sizeof(wifi_direct_client_request_s));
 444         if (rbytes <= 0) {
 445                 WDS_LOGE("Failed to read socket data from client. [%s]", strerror(errno));
 446                 __WDS_LOG_FUNC_EXIT__;
 447                 return -1;
 448         }
 449
 450         if (req.cmd == WIFI_DIRECT_CMD_REGISTER) {
 451                 // TODO: check validity of command
 452                 client = _wfd_client_find_by_id(manager->clients, req.client_id);
 453                 if (client) {
 454                         WDS_LOGE("Client already exist. client_id [%d]", sock);
 455                         res = WIFI_DIRECT_ERROR_NOT_PERMITTED; // WIFI_DIRECT_ERROR_ALREADY_EXIST
 456                         goto send_response;
 457                 }
 458 /*FixMe: Tizen TV Plardorm return the "ACCESS DENIED" error
 459 Ignore the check for now*/
 460 #if 0
 461 #if !defined TIZEN_TV
 462                 if (_wfd_check_client_privilege(sock, req.cmd) != WIFI_DIRECT_ERROR_NONE) {
 463                         rsp.result = WIFI_DIRECT_ERROR_AUTH_FAILED;
 464                         goto done;
 465                 }
 466 #endif
 467 #endif
 468                 client = (wfd_client_s*) g_try_malloc0(sizeof(wfd_client_s));
 469                 if (!client) {
 470                         WDS_LOGE("Failed to allocate memory");
 471                         return -1;
 472                 }
 473                 client->client_id = sock;
 474                 client->ssock = sock;
 475                 client->asock = WFD_CLIENT_PENDING_SOCKET;
 476
 477                 GIOChannel *gio = NULL;
 478                 gio = g_io_channel_unix_new(sock);
 479                 client->gsource_id = g_io_add_watch(gio, G_IO_IN | G_IO_ERR | G_IO_HUP,
 480                                                         (GIOFunc) wfd_client_process_request, (gpointer) sock);
 481                 g_io_channel_unref(gio);
 482
 483                 manager->clients = g_list_prepend(manager->clients, (gpointer) client);
 484                 manager->client_count++;
 485                 WDS_LOGD("Client [%d] is added. %d client alive", client->client_id, manager->client_count);
 486
 487                 res = WIFI_DIRECT_ERROR_NONE;
 488                 WDS_LOGD("New client[%d] added. Total count [%d]", client->client_id, manager->client_count);
 489         } else if (req.cmd == WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET) {
 490                 client = _wfd_client_find_by_id(manager->clients, req.client_id);
 491                 if (!client) {
 492                         WDS_LOGE("Client not found. client_id[%d]", req.client_id);
 493                         res = WIFI_DIRECT_ERROR_NOT_PERMITTED; // WIFI_DIRECT_ERROR_UNKNOWN_CLIENT
 494                         goto done;
 495                 }
 496
 497         /*FixMe: Tizen TV Plardorm return the "ACCESS DENIED" error
 498         Ignore the check for now*/
 499 #if 0
 500 #if !defined TIZEN_TV
 501                 if (_wfd_check_client_privilege(sock, req.cmd) != WIFI_DIRECT_ERROR_NONE) {
 502                         res = WIFI_DIRECT_ERROR_AUTH_FAILED;
 503                         goto done;
 504                 }
 505 #endif
 506 #endif
 507                 client->asock = sock;
 508                 WDS_LOGD("Async socket[%d] for New client[%d] added.", sock, client->client_id);
 509                 goto done;
 510         } else {
 511                 WDS_LOGE("Unknown command from client. [%d]", req.cmd);
 512                 __WDS_LOG_FUNC_EXIT__;
 513                 return -1;
 514         }
 515
 516 send_response:
 517         rsp.cmd = req.cmd;
 518         rsp.client_id = client->client_id;
 519         rsp.result = res;
 520         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(wifi_direct_client_response_s));
 521         if (res < 0) {
 522                 WDS_LOGE("Failed to send response to client");
 523                 _wfd_deregister_client(manager, req.client_id);
 524                 __WDS_LOG_FUNC_EXIT__;
 525                 return -1;
 526         }
 527 done:
 528         __WDS_LOG_FUNC_EXIT__;
 529         return 0;
 530 }
 531
 532 static gboolean _wfd_remove_event_source(gpointer data)
 533 {
 534         __WDS_LOG_FUNC_ENTER__;
 535         int source_id = (int) data;
 536         int res = 0;
 537
 538         if (source_id < 0) {
 539                 WDS_LOGE("Invalid source ID [%d]", source_id);
 540                 return FALSE;
 541         }
 542
 543         res = g_source_remove(source_id);
 544         if (!res) {
 545                 WDS_LOGE("Failed to remove GSource");
 546                 return FALSE;
 547         }
 548         WDS_LOGD("Succeeded to remove GSource");
 549
 550         __WDS_LOG_FUNC_EXIT__;
 551         return FALSE;
 552 }
 553
 554 static int _wfd_deregister_client(void *data, int client_id)
 555 {
 556         __WDS_LOG_FUNC_ENTER__;
 557         wfd_client_s *client = NULL;
 558         wfd_manager_s *manager = (wfd_manager_s*) data;
 559
 560         client =  _wfd_client_find_by_id(manager->clients, client_id);
 561         if (!client) {
 562                 WDS_LOGE("Failed to find client[%d]", client_id);
 563                 return -1;
 564         }
 565
 566         if (client->asock == WFD_CLIENT_PENDING_SOCKET) {
 567                 WDS_LOGE("This client[%d] is initializing(pending)...", client->client_id);
 568                 return 1;
 569         }
 570
 571         manager->clients = g_list_remove(manager->clients, client);
 572         manager->client_count--;
 573         WDS_LOGD("Client [%d] is removed. %d client left", client->client_id, manager->client_count);
 574
 575         if (client->asock >= SOCK_FD_MIN)
 576                 close(client->asock);
 577         client->asock = -1;
 578         if (client->ssock >= SOCK_FD_MIN)
 579                 close(client->ssock);
 580         client->ssock = -1;
 581         g_idle_add((GSourceFunc) _wfd_remove_event_source, (gpointer) client->gsource_id);
 582         client->gsource_id = 0;
 583
 584         g_free(client);
 585
 586         __WDS_LOG_FUNC_EXIT__;
 587         return 0;
 588 }
 589
 590 static int _wfd_create_server_socket(wfd_manager_s *manager)
 591 {
 592         __WDS_LOG_FUNC_ENTER__;
 593         int sock;
 594         struct sockaddr_un saddr;
 595         int sock_opt = 1;
 596         int res = 0;
 597
 598         if (!manager) {
 599                 WDS_LOGE("Invalid parameter(NULL)");
 600                 return -1;
 601         }
 602
 603         /* Server socket initialization */
 604         unlink(WFD_SERVER_SOCK_PATH);
 605
 606         errno = 0;
 607         sock = socket(AF_UNIX, SOCK_STREAM, 0);
 608         if (sock < SOCK_FD_MIN) {
 609                 WDS_LOGE("Failed to create server socket. [%s]", strerror(errno));
 610                 if (sock >= 0)
 611                         close(sock);
 612                 __WDS_LOG_FUNC_EXIT__;
 613                 return -1;
 614         }
 615
 616         errno = 0;
 617         res = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &sock_opt, sizeof(sock_opt));
 618         if (res == -1) {
 619                 WDS_LOGE("Failed to set socket option. [%s]", strerror(errno));
 620                 close(sock);
 621                 return -1;
 622         }
 623
 624         memset(&saddr, 0x00, sizeof(saddr));
 625         saddr.sun_family = AF_UNIX;
 626         snprintf(saddr.sun_path, sizeof(saddr.sun_path), WFD_SERVER_SOCK_PATH);
 627
 628         errno = 0;
 629         res = bind(sock, (struct sockaddr*) &saddr, sizeof(saddr));
 630         if (res == -1) {
 631                 WDS_LOGE("Failed to bind server socket. [%s]", strerror(errno));
 632                 close(sock);
 633                 __WDS_LOG_FUNC_EXIT__;
 634                 return -1;
 635         }
 636
 637         errno = 0;
 638         res = chmod(WFD_SERVER_SOCK_PATH, WFD_SERVER_SOCK_MODE);
 639         if (res == -1) {
 640                 WDS_LOGE("Failed to change mode of server socket file. [%s]", strerror(errno));
 641                 close(sock);
 642                 __WDS_LOG_FUNC_EXIT__;
 643                 return -1;
 644         }
 645
 646         errno = 0;
 647         res = listen(sock, WFD_MAX_CLIENT);
 648         if (res == -1) {
 649                 WDS_LOGE("Failed to listen server socket. [%s]", strerror(errno));
 650                 close(sock);
 651                 __WDS_LOG_FUNC_EXIT__;
 652                 return -1;
 653         }
 654
 655         manager->serv_sock = sock;
 656         WDS_LOGD("Succeeded to create server socket. [%d]", sock);
 657
 658         __WDS_LOG_FUNC_EXIT__;
 659         return 0;
 660 }
 661
 662 static gboolean _wfd_accept_client(GIOChannel *source,
 663                                                                         GIOCondition condition,
 664                                                                         gpointer user_data)
 665 {
 666         __WDS_LOG_FUNC_ENTER__;
 667         wfd_manager_s *manager = (wfd_manager_s*) user_data;
 668         int cli_sock = -1;
 669         socklen_t cli_len = 0;
 670         int res = 0;
 671
 672         if (!manager || manager->serv_sock < 0) {
 673                 WDS_LOGE("Invalid parameter");
 674                 return FALSE;
 675         }
 676
 677         errno = 0;
 678         cli_sock = accept(manager->serv_sock, NULL, &cli_len);
 679         if (cli_sock == -1) {
 680                 WDS_LOGE("Failed to accept client. [%s]", strerror(errno));
 681                 return FALSE;
 682         }
 683
 684         res = _wfd_register_client(manager, cli_sock);
 685         if (res < 0) {
 686                 WDS_LOGE("Failed to register client.");
 687                 close(cli_sock);
 688                 return TRUE;
 689         }
 690
 691         __WDS_LOG_FUNC_EXIT__;
 692         return TRUE;
 693 }
 694
 695 int wfd_client_handler_init(wfd_manager_s *manager)
 696 {
 697         __WDS_LOG_FUNC_ENTER__;
 698         GList *clients = manager->clients;
 699         int res = 0;
 700
 701         if (clients) {
 702                 g_list_free(clients);
 703                 clients = NULL;
 704         }
 705
 706         res = _wfd_create_server_socket(manager);
 707         if (res < 0) {
 708                 WDS_LOGE("Failed to create server socket");
 709                 return -1;
 710         }
 711
 712         GIOChannel *gio = g_io_channel_unix_new(manager->serv_sock);
 713         manager->client_handle = g_io_add_watch(gio, G_IO_IN,
 714                                                         (GIOFunc) _wfd_accept_client, manager);
 715         g_io_channel_unref(gio);
 716
 717         __WDS_LOG_FUNC_EXIT__;
 718         return 0;
 719 }
 720
 721 int wfd_client_handler_deinit(wfd_manager_s *manager)
 722 {
 723         __WDS_LOG_FUNC_ENTER__;
 724         GList *temp = NULL;
 725         wfd_client_s *client = NULL;
 726
 727         if (manager->serv_sock >= SOCK_FD_MIN)
 728                 close(manager->serv_sock);
 729         manager->serv_sock = -1;
 730         g_source_remove(manager->client_handle);
 731         manager->client_handle = 0;
 732
 733         temp = g_list_first(manager->clients);
 734         while(temp) {
 735                 client = temp->data;
 736                 if(client != NULL) {
 737                         if (client->ssock >= SOCK_FD_MIN)
 738                                 close(client->ssock);
 739                         client->ssock = -1;
 740                         if (client->asock >= SOCK_FD_MIN)
 741                                 close(client->asock);
 742                         client->asock = -1;
 743                         g_source_remove(client->gsource_id);
 744                         client->gsource_id = 0;
 745                         g_free(client);
 746                 }
 747                 temp = g_list_next(temp);
 748         }
 749
 750         if (manager->clients) {
 751                 g_list_free(manager->clients);
 752                 manager->clients = NULL;
 753         }
 754
 755         manager->client_count = 0;
 756         manager->clients = NULL;
 757         __WDS_LOG_FUNC_EXIT__;
 758         return 0;
 759 }
 760 #if 0
 761 #if !defined TIZEN_TV
 762 static int _wfd_check_client_privilege(int client_sock, int cmd)
 763 {
 764         __WDS_LOG_FUNC_ENTER__;
 765         int ret = SECURITY_SERVER_API_ERROR_ACCESS_DENIED;
 766
 767         switch (cmd) {
 768         case WIFI_DIRECT_CMD_ACTIVATE:
 769         case WIFI_DIRECT_CMD_DEACTIVATE:
 770         case WIFI_DIRECT_CMD_CONNECT:
 771         case WIFI_DIRECT_CMD_CANCEL_CONNECT:
 772         case WIFI_DIRECT_CMD_CANCEL_CONNECTION:
 773         case WIFI_DIRECT_CMD_SEND_CONNECT_REQ:
 774         case WIFI_DIRECT_CMD_REJECT_CONNECTION:
 775         case WIFI_DIRECT_CMD_DISCONNECT:
 776         case WIFI_DIRECT_CMD_DISCONNECT_ALL:
 777         case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
 778         case WIFI_DIRECT_CMD_CREATE_GROUP:
 779         case WIFI_DIRECT_CMD_DESTROY_GROUP:
 780         case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
 781         case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
 782         case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:
 783         case WIFI_DIRECT_CMD_SET_GO_INTENT:
 784         case WIFI_DIRECT_CMD_GENERATE_WPS_PIN:
 785         case WIFI_DIRECT_CMD_SET_WPS_PIN:
 786         case WIFI_DIRECT_CMD_SET_DEVICE_NAME:
 787         case WIFI_DIRECT_CMD_SET_SSID:
 788         case WIFI_DIRECT_CMD_SET_MAX_CLIENT:
 789         case WIFI_DIRECT_CMD_SET_PASSPHRASE:
 790         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_PEER:
 791
 792 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 793         case WIFI_DIRECT_CMD_INIT_MIRACAST:
 794
 795         case WIFI_DIRECT_CMD_INIT_DISPLAY:
 796         case WIFI_DIRECT_CMD_DEINIT_DISPLAY:
 797         case WIFI_DIRECT_CMD_SET_DISPLAY:
 798         case WIFI_DIRECT_CMD_SET_DISPLAY_AVAILABILITY:
 799 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 800
 801 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 802         case WIFI_DIRECT_CMD_REGISTER_LOCAL_SERVICE:
 803         case WIFI_DIRECT_CMD_DEREGISTER_LOCAL_SERVICE:
 804         case WIFI_DIRECT_CMD_REGISTER_SERVICE:
 805         case WIFI_DIRECT_CMD_DEREGISTER_SERVICE:
 806 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 807                 ret = security_server_check_privilege_by_sockfd(client_sock, "wifi-direct::admin", "rw");
 808                 break;
 809         case WIFI_DIRECT_CMD_START_DISCOVERY:
 810         case WIFI_DIRECT_CMD_START_DISCOVERY_SPECIFIC_CHANNEL:
 811         case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
 812
 813 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 814         case WIFI_DIRECT_CMD_START_SERVICE_DISCOVERY:
 815         case WIFI_DIRECT_CMD_CANCEL_SERVICE_DISCOVERY:
 816 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 817                 ret = security_server_check_privilege_by_sockfd(client_sock, "wifi-direct::discover", "w");
 818                 break;
 819         case WIFI_DIRECT_CMD_REGISTER:
 820         case WIFI_DIRECT_CMD_DEREGISTER:
 821         case WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET:
 822         case WIFI_DIRECT_CMD_GET_LINK_STATUS:
 823         case WIFI_DIRECT_CMD_GET_DEVICE_NAME:
 824         case WIFI_DIRECT_CMD_GET_SSID:
 825         case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
 826         case WIFI_DIRECT_CMD_GET_GO_INTENT:
 827         case WIFI_DIRECT_CMD_GET_MAX_CLIENT:
 828         case WIFI_DIRECT_CMD_GET_IP_ADDR:
 829         case WIFI_DIRECT_CMD_GET_MAC_ADDR:
 830         case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:
 831         case WIFI_DIRECT_CMD_GET_REQ_WPS_MODE:
 832         case WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE:
 833         case WIFI_DIRECT_CMD_GET_WPS_PIN:
 834         case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
 835         case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
 836         case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO:
 837         case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
 838         case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
 839         case WIFI_DIRECT_CMD_IS_GROUPOWNER:
 840         case WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP:
 841         case WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE:
 842         case WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP:
 843         case WIFI_DIRECT_CMD_GET_PEER_INFO:
 844         case WIFI_DIRECT_CMD_GET_PASSPHRASE:
 845 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 846         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_TYPE:
 847         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_AVAILABILITY:
 848         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_HDCP:
 849         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_PORT:
 850         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_THROUGHPUT:
 851 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 852         ret = security_server_check_privilege_by_sockfd(client_sock, "wifi-direct::info", "r");
 853                 break;
 854         case WIFI_DIRECT_CMD_SET_REQ_WPS_MODE:
 855         ret = security_server_check_privilege_by_sockfd(client_sock, "wifi-direct::info", "rw");
 856                 break;
 857         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE:
 858         ret = security_server_check_privilege_by_sockfd(client_sock, "wifi-direct::native", "rw");
 859                 break;
 860         default:
 861                 WDS_LOGE("Unknown command[%d]", cmd);
 862                 break;
 863         }
 864
 865         if(ret == SECURITY_SERVER_API_SUCCESS) {
 866                 WDS_LOGD("Security Server: API Access Validation Success");
 867                 return WIFI_DIRECT_ERROR_NONE;
 868         } else if(ret == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
 869                 WDS_LOGE("Access denied to client id [%d]", client_sock);
 870                 return WIFI_DIRECT_ERROR_PERMISSION_DENIED;
 871         } else {
 872                 WDS_LOGE("Security Server, exception[%d]", ret);
 873                 return WIFI_DIRECT_ERROR_AUTH_FAILED;
 874         }
 875 }
 876 #endif
 877 #endif
 878 static gboolean wfd_client_process_request(GIOChannel *source,
 879                                                                         GIOCondition condition,
 880                                                                         gpointer user_data)
 881 {
 882         __WDS_LOG_FUNC_ENTER__;
 883         int sock = (int) user_data;
 884         wifi_direct_client_request_s req;
 885         wifi_direct_client_response_s rsp;
 886         char *extra_rsp = NULL;
 887         wifi_direct_client_noti_s *noti = NULL;
 888         wfd_manager_s *manager = wfd_get_manager();
 889         int res = 0;
 890
 891         if (sock < SOCK_FD_MIN) {
 892                 WDS_LOGE("Invalid argument");
 893                 __WDS_LOG_FUNC_EXIT__;
 894                 return FALSE;
 895         }
 896
 897         memset(&req, 0x0, sizeof(wifi_direct_client_request_s));
 898         memset(&rsp, 0x0, sizeof(wifi_direct_client_response_s));
 899
 900         res = _wfd_read_from_client(sock, (char*) &req, sizeof(req));
 901         if (res < 0) {
 902                 WDS_LOGE("Client socket Hanged up");
 903                 _wfd_deregister_client(manager, req.client_id);
 904                 __WDS_LOG_FUNC_EXIT__;
 905                 return FALSE;
 906         } else if (res == 0) {
 907                 WDS_LOGE("Client socket busy");
 908                 return TRUE;
 909         }
 910         WDS_LOGI("Client request [%d:%s], %d bytes read from socket[%d]", req.cmd, wfd_server_print_cmd(req.cmd), res, sock);
 911
 912         rsp.cmd = req.cmd;
 913         rsp.client_id = req.client_id;
 914         rsp.result = WIFI_DIRECT_ERROR_NONE;
 915 #if 0
 916 #if !defined TIZEN_TV
 917         /*FixMe: Tizen TV Plardorm return the "ACCESS DENIED" error
 918         Ignore the check for now*/
 919         if (_wfd_check_client_privilege(sock, req.cmd) != WIFI_DIRECT_ERROR_NONE) {
 920                 rsp.result = WIFI_DIRECT_ERROR_AUTH_FAILED;
 921                 goto send_response;
 922         }
 923 #endif
 924 #endif
 925         switch (req.cmd) {
 926         case WIFI_DIRECT_CMD_DEREGISTER:        // manager
 927                 _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
 928
 929                 res = _wfd_deregister_client(manager, req.client_id);
 930                 if (res < 0) {
 931                         WDS_LOGE("Failed to deregister client[%d]", sock);
 932                 }
 933
 934                 goto done;
 935                 break;
 936         case WIFI_DIRECT_CMD_ACTIVATE:  // manager (event)
 937                 if (manager->state > WIFI_DIRECT_STATE_DEACTIVATED) {
 938                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 939                         break;
 940                 }
 941                 rsp.result = wfd_util_wifi_direct_activatable();
 942                 if (rsp.result < 0)
 943                         break;
 944
 945                 res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
 946                 if (res < 0) {
 947                         WDS_LOGE("Failed to send response to client");
 948                         _wfd_deregister_client(manager, req.client_id);
 949                         __WDS_LOG_FUNC_EXIT__;
 950                         return FALSE;
 951                 }
 952
 953                 noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
 954                 noti->event = WIFI_DIRECT_CLI_EVENT_ACTIVATION;
 955                 noti->error = wfd_manager_activate(manager);
 956                 goto send_notification;
 957                 break;
 958         case WIFI_DIRECT_CMD_DEACTIVATE:        // manager (event)
 959                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
 960                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 961                         break;
 962                 }
 963                 res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
 964                 if (res < 0) {
 965                         WDS_LOGE("Failed to send response to client");
 966                         _wfd_deregister_client(manager, req.client_id);
 967                         __WDS_LOG_FUNC_EXIT__;
 968                         return FALSE;
 969                 }
 970
 971                 noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
 972                 noti->event = WIFI_DIRECT_CLI_EVENT_DEACTIVATION;
 973                 noti->error = wfd_manager_deactivate(manager);
 974                 goto send_notification;
 975                 break;
 976         case WIFI_DIRECT_CMD_GET_LINK_STATUS:
 977                 rsp.param1 = manager->state;
 978                 break;
 979         case WIFI_DIRECT_CMD_START_DISCOVERY:
 980                 {
 981                         if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
 982                                         manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 983                                         manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
 984                                 WDS_LOGE("Wi-Fi Direct is not available status for scanning.");
 985                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 986                                 break;
 987                         }
 988
 989                         wfd_oem_scan_param_s param;
 990                         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 991                         if (req.data.int1)      // listen_only
 992                                 param.scan_mode = WFD_OEM_SCAN_MODE_PASSIVE;
 993                         else
 994                                 param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 995                         param.scan_time = req.data.int2;        // timeout
 996                         if (manager->local->dev_role == WFD_DEV_ROLE_GO)
 997                                 param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 998
 999                         res = wfd_oem_start_scan(manager->oem_ops, &param);
1000                         if (res < 0) {
1001                                 WDS_LOGE("Failed to start scan");
1002                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1003                                 break;
1004                         }
1005                         WDS_LOGE("Succeeded to start scan");
1006                         wfd_state_set(manager, WIFI_DIRECT_STATE_DISCOVERING);
1007                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DISCOVERING);
1008
1009                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1010                         if (req.data.int1) {
1011                                 noti->event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY;
1012                                 manager->scan_mode = WFD_SCAN_MODE_PASSIVE;
1013                         } else {
1014                                 noti->event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START;
1015                                 manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
1016                         }
1017                         noti->error = WIFI_DIRECT_ERROR_NONE;
1018                 }
1019                 break;
1020         case WIFI_DIRECT_CMD_START_DISCOVERY_SPECIFIC_CHANNEL:
1021                 {
1022                         if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
1023                                         manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
1024                                         manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
1025                                 WDS_LOGE("Wi-Fi Direct is not available status for scanning.");
1026                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1027                                 break;
1028                         }
1029
1030                         wfd_oem_scan_param_s param;
1031                         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
1032                         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
1033                         param.scan_time = req.data.int1;        // timeout
1034                         int channel = req.data.int2;    // channel
1035
1036                         if (channel == WIFI_DIRECT_DISCOVERY_FULL_SCAN) {
1037                                 param.scan_type = WFD_OEM_SCAN_TYPE_FULL;
1038                         } else if (channel == WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL) {
1039                                 param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
1040                         } else if (channel == WIFI_DIRECT_DISCOVERY_CHANNEL1) {
1041                                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL1;
1042                                 param.freq = 2412;
1043                         } else if (channel == WIFI_DIRECT_DISCOVERY_CHANNEL6) {
1044                                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL6;
1045                                 param.freq = 2437;
1046                         } else if (channel == WIFI_DIRECT_DISCOVERY_CHANNEL11) {
1047                                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL11;
1048                                 param.freq = 2462;
1049                         } else {
1050                                 param.scan_type = WFD_OEM_SCAN_TYPE_SPECIFIC;
1051                                 param.freq = wfd_util_channel_to_freq(channel);
1052                         }
1053
1054                         WDS_LOGD("timeout[%d], frequency[%d] ", param.scan_time, param.freq);
1055                         res = wfd_oem_start_scan(manager->oem_ops, &param);
1056                         if (res < 0) {
1057                                 WDS_LOGE("Failed to start specific scan");
1058                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1059                                 break;
1060                         }
1061                         WDS_LOGE("Succeeded to start specific scan");
1062                         wfd_state_set(manager, WIFI_DIRECT_STATE_DISCOVERING);
1063                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DISCOVERING);
1064
1065                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1066                         if (channel == WIFI_DIRECT_DISCOVERY_FULL_SCAN)
1067                                 noti->event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START;
1068                         else
1069                                 noti->event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN;
1070                         noti->error = WIFI_DIRECT_ERROR_NONE;
1071                         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
1072                 }
1073                 break;
1074         case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
1075                 if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
1076                                 manager->state != WIFI_DIRECT_STATE_DISCOVERING) {
1077                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1078                         break;
1079                 }
1080
1081                 res = wfd_oem_stop_scan(manager->oem_ops);
1082                 if (res < 0) {
1083                         WDS_LOGE("Failed to stop scan");
1084                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1085                         break;
1086                 }
1087                 WDS_LOGE("Succeeded to stop scan");
1088
1089                 noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1090                 noti->event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;
1091                 noti->error = WIFI_DIRECT_ERROR_NONE;
1092                 if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1093                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1094                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1095                 } else {
1096                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1097                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1098                 }
1099
1100                 break;
1101         case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
1102                 rsp.param1 = manager->scan_mode == WFD_SCAN_MODE_PASSIVE;
1103                 break;
1104         case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
1105                 {
1106                         wfd_discovery_entry_s *peers = NULL;
1107                         int peer_cnt = 0;
1108                         peer_cnt = wfd_manager_get_peers(manager, &peers);
1109                         WDS_LOGD("Peer count [%d], Peer list [%x]", peer_cnt, peers);
1110                         if (peer_cnt < 0) {
1111                                 WDS_LOGE("Failed to get scan result");
1112                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1113                                 break;
1114                         }
1115                         rsp.param1 = peer_cnt;
1116                         rsp.result = WIFI_DIRECT_ERROR_NONE;
1117
1118                         rsp.data_length = peer_cnt * sizeof(wfd_discovery_entry_s);
1119                         extra_rsp = (char*) peers;
1120                         WDS_LOGD("extra_rsp length [%d], extra_rsp [%x]", rsp.data_length, extra_rsp);
1121                 }
1122                 break;
1123         case WIFI_DIRECT_CMD_CONNECT: //session (event)
1124                 {
1125                         if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
1126                                         manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
1127                                         manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
1128                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1129                                 goto send_response;
1130                         }
1131
1132                         wfd_group_s *group = (wfd_group_s*) manager->group;
1133                         if (group && group->member_count >= manager->max_station) {
1134                                 rsp.result = WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
1135                                 goto send_response;
1136                         }
1137
1138                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1139                         if (res < 0) {
1140                                 WDS_LOGE("Failed to send response to client");
1141                                 _wfd_deregister_client(manager, req.client_id);
1142                                 __WDS_LOG_FUNC_EXIT__;
1143                                 return FALSE;
1144                         }
1145
1146                         res = wfd_manager_connect(manager, req.data.mac_addr);
1147                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1148                         if (res < 0) {
1149                                 noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1150                                 noti->error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1151                         } else {
1152                                 noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_START;
1153                                 noti->error = WIFI_DIRECT_ERROR_NONE;
1154                         }
1155                         g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(req.data.mac_addr));
1156                         goto send_notification;
1157                 }
1158                 break;
1159         case WIFI_DIRECT_CMD_SEND_CONNECT_REQ:
1160                 {
1161                         if (manager->state != WIFI_DIRECT_STATE_CONNECTING) {
1162                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1163                                 goto send_response;
1164                         }
1165
1166                         wfd_group_s *group = (wfd_group_s*) manager->group;
1167                         if (group && group->member_count >= manager->max_station) {
1168                                 rsp.result = WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
1169                                 goto send_response;
1170                         }
1171
1172                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1173                         if (res < 0) {
1174                                 WDS_LOGE("Failed to send response to client");
1175                                 _wfd_deregister_client(manager, req.client_id);
1176                                 __WDS_LOG_FUNC_EXIT__;
1177                                 return FALSE;
1178                         }
1179
1180                         res = wfd_manager_accept_connection(manager, req.data.mac_addr);
1181                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1182                         if (res < 0) {
1183                                 noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1184                                 noti->error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1185                         } else {
1186                                 noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_START;
1187                                 noti->error = WIFI_DIRECT_ERROR_NONE;
1188                         }
1189                         g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(req.data.mac_addr));
1190                         goto send_notification;
1191                 }
1192                 break;
1193         case WIFI_DIRECT_CMD_CANCEL_CONNECT:    // deprecated
1194                 {
1195                         wfd_session_s *session = (wfd_session_s*) manager->session;
1196                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1197                         if (res < 0) {
1198                                 WDS_LOGE("Failed to send response to client");
1199                                 _wfd_deregister_client(manager, req.client_id);
1200                                 __WDS_LOG_FUNC_EXIT__;
1201                                 return FALSE;
1202                         }
1203
1204                         res = wfd_oem_cancel_connection(manager->oem_ops, NULL);
1205                         if (res < 0)
1206                                 WDS_LOGE("Failed to cancel connection");
1207
1208                         res = wfd_oem_destroy_group(manager->oem_ops, GROUP_IFNAME);
1209                         if (res < 0)
1210                                 WDS_LOGE("Failed to destroy group");
1211
1212                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1213                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1214
1215                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1216                         noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1217                         noti->error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1218                         if (session)
1219                                 g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(session->peer->dev_addr));
1220                         goto send_notification;
1221                 }
1222                 break;
1223         case WIFI_DIRECT_CMD_CANCEL_CONNECTION:
1224                 {
1225                         if (!manager->session && manager->state != WIFI_DIRECT_STATE_CONNECTING) {
1226                                 WDS_LOGE("It's not CONNECTING state");
1227                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1228                                 break;
1229                         }
1230
1231                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1232                         if (res < 0) {
1233                                 WDS_LOGE("Failed to send response to client");
1234                                 _wfd_deregister_client(manager, req.client_id);
1235                                 __WDS_LOG_FUNC_EXIT__;
1236                                 return FALSE;
1237                         }
1238
1239                         res = wfd_manager_cancel_connection(manager, req.data.mac_addr);
1240                         if (res < 0)
1241                                 WDS_LOGE("Failed to cancel connection");
1242
1243                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1244                         noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1245                         noti->error = WIFI_DIRECT_ERROR_CONNECTION_CANCELED;
1246                         g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(req.data.mac_addr));
1247                         goto send_notification;
1248                 }
1249                 break;
1250         case WIFI_DIRECT_CMD_REJECT_CONNECTION:
1251                 {
1252                         wfd_session_s *session = (wfd_session_s*) manager->session;
1253
1254                         if (!session || manager->state != WIFI_DIRECT_STATE_CONNECTING) {
1255                                 WDS_LOGE("It's not permitted with this state [%d]", manager->state);
1256                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1257                                 break;
1258                         }
1259
1260                         if (session->direction != SESSION_DIRECTION_INCOMING) {
1261                                 WDS_LOGE("Only incomming session can be rejected");
1262                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1263                                 break;
1264                         }
1265
1266                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1267                         if (res < 0) {
1268                                 WDS_LOGE("Failed to send response to client");
1269                                 _wfd_deregister_client(manager, req.client_id);
1270                                 __WDS_LOG_FUNC_EXIT__;
1271                                 return FALSE;
1272                         }
1273
1274                         res = wfd_manager_reject_connection(manager, req.data.mac_addr);
1275                         if (res < 0) {
1276                                 WDS_LOGE("Failed to reject connection");
1277                                 // TODO: check whether to set state and break
1278                         }
1279
1280                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1281                         noti->event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1282                         noti->error = WIFI_DIRECT_ERROR_CONNECTION_CANCELED;
1283                         g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(req.data.mac_addr));
1284                         goto send_notification;
1285                 }
1286                 break;
1287         case WIFI_DIRECT_CMD_DISCONNECT:        // group, session
1288                 {
1289                         if (!manager->group || manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1290                                 if (WIFI_DIRECT_STATE_DISCOVERING == manager->state) {
1291                                         res = wfd_oem_stop_scan(manager->oem_ops);
1292                                         if (res < 0) {
1293                                                 WDS_LOGE("Failed to stop scan");
1294                                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1295                                                 break;
1296                                         }
1297                                         WDS_LOGI("Succeeded to stop scan");
1298                                         if (WFD_DEV_ROLE_GO == manager->local->dev_role) {
1299                                                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1300                                                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1301                                         } else {
1302                                                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1303                                                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1304                                         }
1305                                 } else {
1306                                         WDS_LOGE("It's not permitted with this state [%d]", manager->state);
1307                                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1308                                         break;
1309                                 }
1310                         }
1311
1312                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1313                         if (res < 0) {
1314                                 WDS_LOGE("Failed to send response to client");
1315                                 _wfd_deregister_client(manager, req.client_id);
1316                                 __WDS_LOG_FUNC_EXIT__;
1317                                 return FALSE;
1318                         }
1319
1320                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1321                         noti->event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
1322                         noti->error = wfd_manager_disconnect(manager, req.data.mac_addr);
1323                         g_snprintf(noti->param1, MACSTR_LEN, MACSTR, MAC2STR(req.data.mac_addr));
1324                         goto send_notification;
1325                 }
1326                 break;
1327         case WIFI_DIRECT_CMD_DISCONNECT_ALL:
1328                 {
1329                         if (!manager->group || manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1330                                 if (WIFI_DIRECT_STATE_DISCOVERING == manager->state) {
1331                                         res = wfd_oem_stop_scan(manager->oem_ops);
1332                                         if (res < 0) {
1333                                                 WDS_LOGE("Failed to stop scan");
1334                                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1335                                                 break;
1336                                         }
1337                                         WDS_LOGI("Succeeded to stop scan");
1338                                         if (WFD_DEV_ROLE_GO == manager->local->dev_role) {
1339                                                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1340                                                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1341                                         } else {
1342                                                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1343                                                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1344                                         }
1345                                 } else {
1346                                         WDS_LOGE("It's not permitted with this state [%d]", manager->state);
1347                                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1348                                         break;
1349                                 }
1350                         }
1351
1352                         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
1353                         if (res < 0) {
1354                                 WDS_LOGE("Failed to send response to client");
1355                                 _wfd_deregister_client(manager, req.client_id);
1356                                 __WDS_LOG_FUNC_EXIT__;
1357                                 return FALSE;
1358                         }
1359
1360                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1361                         noti->event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
1362                         noti->error = wfd_manager_disconnect_all(manager);
1363                         goto send_notification;
1364                 }
1365                 break;
1366         case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
1367                 {
1368                         // even though status is not CONNECTED, this command can be excuted only when group exist
1369                         if (!manager->group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1370                                 WDS_LOGD("It's not connected state [%d]", manager->state);
1371                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1372                                 break;
1373                         }
1374
1375                         wfd_connected_peer_info_s *peers = NULL;
1376                         int peer_cnt = 0;
1377                         peer_cnt = wfd_manager_get_connected_peers(manager, &peers);
1378                         WDS_LOGD("Peer count [%d], Peer list [%x]", peer_cnt, peers);
1379                         if (peer_cnt < 0) {
1380                                 WDS_LOGE("Failed to get scan result");
1381                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1382                                 break;
1383                         }
1384                         rsp.param1 = peer_cnt;
1385                         rsp.result = WIFI_DIRECT_ERROR_NONE;
1386
1387                         rsp.data_length = peer_cnt * sizeof(wfd_connected_peer_info_s);
1388                         extra_rsp = (char*) peers;
1389                         WDS_LOGD("extra_rsp length [%d], extra_rsp [%x]", rsp.data_length, extra_rsp);
1390                 }
1391                 break;
1392         case WIFI_DIRECT_CMD_CREATE_GROUP:      // group
1393                 {
1394                         int persistent = 0;
1395                         wfd_group_s *group = manager->group;
1396                         if (group || manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1397                                 WDS_LOGE("Group already exist or not a proper state");
1398                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1399                                 break;
1400                         }
1401
1402                         group = wfd_create_pending_group(manager, manager->local->intf_addr);
1403                         if (!group) {
1404                                 WDS_LOGE("Failed to create pending group");
1405                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1406                                 break;
1407                         }
1408                         group->flags |= WFD_GROUP_FLAG_AUTONOMOUS;
1409                         manager->group = group;
1410                         WDS_LOGD("Succeeded to create pending group");
1411
1412                         persistent = (manager->local->group_flags & WFD_GROUP_FLAG_PERSISTENT);
1413
1414                         res = wfd_oem_create_group(manager->oem_ops, persistent, 0, manager->local->passphrase);
1415                         if (res < 0) {
1416                                 WDS_LOGE("Failed to create group");
1417                                 wfd_destroy_group(manager, GROUP_IFNAME);
1418                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1419                         }
1420
1421                         memset(manager->local->passphrase, 0x0, PASSPHRASE_LEN);
1422                 }
1423                 break;
1424         case WIFI_DIRECT_CMD_DESTROY_GROUP:
1425                 {
1426                         wfd_group_s *group = manager->group;
1427                         if (!group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1428                                 WDS_LOGE("Group not exist");
1429                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1430                                 break;
1431                         }
1432
1433                         res = wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1434                         if (res < 0) {
1435                                 WDS_LOGE("Failed to destroy group");
1436                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1437                                 break;
1438                         }
1439
1440                         res = wfd_destroy_group(manager, group->ifname);
1441                         if (res < 0)
1442                                 WDS_LOGE("Failed to destroy group");
1443
1444                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1445                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1446
1447                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1448                         noti->event = WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP;
1449                         noti->error = WIFI_DIRECT_ERROR_NONE;
1450                 }
1451                 break;
1452         case WIFI_DIRECT_CMD_IS_GROUPOWNER:
1453                 {
1454                         wfd_device_s *local = manager->local;
1455                         rsp.param1 = local->dev_role == WFD_DEV_ROLE_GO;
1456                 }
1457                 break;
1458         case WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP:
1459                 {
1460                         wfd_group_s *group = manager->group;
1461                         if (!group) {
1462                                 WDS_LOGE("Group not exist");
1463                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1464                                 break;
1465                         }
1466                         rsp.param1 = group->flags & WFD_GROUP_FLAG_AUTONOMOUS;
1467                 }
1468                 break;
1469         case WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP:
1470                 {
1471                         wfd_group_s *group = manager->group;
1472                         if (!group) {
1473                                 WDS_LOGE("Group not exist");
1474                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1475                                 break;
1476                         }
1477                         rsp.param1 = group->flags & WFD_GROUP_FLAG_PERSISTENT;
1478                 }
1479                 break;
1480         case WIFI_DIRECT_CMD_GET_OPERATING_CHANNEL:
1481                 {
1482                         wfd_group_s *group = manager->group;
1483                         if (!group) {
1484                                 WDS_LOGE("Group not exist");
1485                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1486                                 break;
1487                         }
1488                         rsp.param1 = wfd_util_freq_to_channel(group->freq);
1489                         // TODO: check channel value
1490                 }
1491                 break;
1492         case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO: // group
1493                 {
1494                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1495                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1496                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1497                                 break;
1498                         }
1499
1500                         int persistent_group_count = 0;
1501                         wfd_persistent_group_info_s *plist;
1502
1503                         res = wfd_oem_get_persistent_groups(manager->oem_ops, (wfd_oem_persistent_group_s**) &plist, &persistent_group_count);
1504                         if (res < 0) {
1505                                 WDS_LOGE("Error!! wfd_oem_get_persistent_group_info() failed..");
1506                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1507                                 break;
1508                         }
1509
1510                         rsp.param1 = persistent_group_count;
1511                         rsp.result = WIFI_DIRECT_ERROR_NONE;
1512                         rsp.data_length = persistent_group_count * sizeof(wfd_persistent_group_info_s);
1513                         extra_rsp = (char*) plist;
1514                         WDS_LOGD("extra_rsp length [%d], extra_rsp [%x]", rsp.data_length, extra_rsp);
1515                 }
1516                 break;
1517         case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
1518                 {
1519                         manager->local->group_flags |= WFD_GROUP_FLAG_PERSISTENT;
1520                 }
1521                 break;
1522         case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
1523                 {
1524                         manager->local->group_flags &= ~(WFD_GROUP_FLAG_PERSISTENT);
1525                 }
1526                 break;
1527         case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:   // group
1528                 {
1529                         wfd_persistent_group_info_s persistent_group;
1530
1531                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1532                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1533                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1534                                 _wfd_read_from_client(sock, (char*) &persistent_group, sizeof(wfd_persistent_group_info_s));
1535                                 break;
1536                         }
1537
1538                         res = _wfd_read_from_client(sock, (char*) &persistent_group, sizeof(wfd_persistent_group_info_s));
1539                         if (res == -2) {
1540                                 WDS_LOGE("Client socket Hanged up");
1541                                 _wfd_deregister_client(manager, sock);
1542                                 return FALSE;
1543                         } else if (res == -1) {
1544                                 WDS_LOGE("Failed to read socket [%d]", sock);
1545                                 return TRUE;
1546                         }
1547                         WDS_LOGD("Remove persistent group [%s]", persistent_group.ssid);
1548                         WDS_LOGD("Remove persistent group [" MACSTR "]", MAC2STR(persistent_group.go_mac_address));
1549
1550                         res = wfd_oem_remove_persistent_group(manager->oem_ops,
1551                                                                         persistent_group.ssid, persistent_group.go_mac_address);
1552                         if (res < 0) {
1553                                 WDS_LOGE("Failed to remove persistent group");
1554                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1555                         }
1556                 }
1557                 break;
1558         case WIFI_DIRECT_CMD_GET_SSID:
1559         case WIFI_DIRECT_CMD_GET_DEVICE_NAME:   // manager (sync)
1560                 res = wfd_local_get_dev_name(rsp.param2);
1561                 if (res < 0) {
1562                         WDS_LOGE("Failed to get device name");
1563                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1564                 }
1565                 break;
1566         case WIFI_DIRECT_CMD_SET_SSID:
1567         case WIFI_DIRECT_CMD_SET_DEVICE_NAME:   // manager (sync)
1568                 {
1569                         char dev_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN] = {0, };
1570                         res = _wfd_read_from_client(sock, dev_name, WIFI_DIRECT_MAX_DEVICE_NAME_LEN);
1571                         if (res < 0) {
1572                                 WDS_LOGE("Failed to set device name");
1573                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1574                                 break;
1575                         }
1576
1577                         res = wfd_local_set_dev_name(dev_name);
1578                         if (res < 0) {
1579                                 WDS_LOGE("Failed to set device name");
1580                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1581                         }
1582                 }
1583                 break;
1584         case WIFI_DIRECT_CMD_GET_MAC_ADDR:      // manager (sync)
1585
1586                 res = wfd_local_get_dev_mac(rsp.param2);
1587                 if (res < 0) {
1588                         WDS_LOGE("Failed to get device mac");
1589                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1590                         break;
1591                 }
1592                 break;
1593         case WIFI_DIRECT_CMD_GET_IP_ADDR:       // group
1594                 if (manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1595                         WDS_LOGE("Device is not connected yet");
1596                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1597                         break;
1598                 }
1599
1600                 unsigned char ip_addr[IPADDR_LEN] = {0,};
1601
1602                 res = wfd_util_get_local_ip(ip_addr);
1603                 if (res < 0) {
1604                         WDS_LOGE("Failed to get local IP address");
1605                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1606                 }
1607                 g_snprintf(rsp.param2, IPSTR_LEN, IPSTR, IP2STR(ip_addr));
1608                 break;
1609         case WIFI_DIRECT_CMD_GET_GO_INTENT:     // manager (sync)
1610                 res = wfd_manager_get_go_intent(&rsp.param1);
1611                 if (res < 0) {
1612                         WDS_LOGE("Failed to get GO intent");
1613                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1614                 }
1615                 break;
1616         case WIFI_DIRECT_CMD_SET_GO_INTENT:     // manager (sync)
1617                 res = wfd_manager_set_go_intent(req.data.int1);
1618                 if (res < 0) {
1619                         WDS_LOGE("Failed to set GO intent");
1620                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1621                 }
1622                 break;
1623         case WIFI_DIRECT_CMD_GET_MAX_CLIENT:
1624                 res = wfd_manager_get_max_station(&rsp.param1);
1625                 if (res < 0) {
1626                         WDS_LOGE("Failed to get max station");
1627                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1628                 }
1629                 break;
1630         case WIFI_DIRECT_CMD_SET_MAX_CLIENT:
1631                 res = wfd_manager_set_max_station(req.data.int1);
1632                 if (res < 0) {
1633                         WDS_LOGE("Failed to set max station");
1634                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1635                 }
1636                 break;
1637         case WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE:
1638                 res = wfd_manager_get_autoconnection(&rsp.param1);
1639                 if (res < 0) {
1640                         WDS_LOGE("Failed to get autoconnection");
1641                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1642                 }
1643                 break;
1644         case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE:   // manager (sync)
1645                 res = wfd_manager_set_autoconnection(req.data.int1);
1646                 if (res < 0) {
1647                         WDS_LOGE("Failed to set autoconnection");
1648                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1649                 }
1650                 break;
1651         case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
1652                 if (manager->state == WIFI_DIRECT_STATE_DISCOVERING
1653                                 || wfd_group_is_autonomous(manager->group) == 1)
1654                         rsp.param1 = TRUE;
1655                 else
1656                         rsp.param1 = FALSE;
1657                 break;
1658         case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:    // manager (sync)
1659                 res = wfd_local_get_supported_wps_mode(&rsp.param1);
1660                 if (res < 0) {
1661                         WDS_LOGE("Failed to get supported wps mode");
1662                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1663                 }
1664                 break;
1665         case WIFI_DIRECT_CMD_GET_LOCAL_WPS_MODE:
1666                 res = wfd_local_get_wps_mode(&rsp.param1);
1667                 if (res < 0) {
1668                         WDS_LOGE("Failed to get wps mode");
1669                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1670                 }
1671                 break;
1672         case WIFI_DIRECT_CMD_GET_REQ_WPS_MODE:
1673                 res = wfd_manager_get_req_wps_mode(&rsp.param1);
1674                 if (res < 0) {
1675                         WDS_LOGE("Failed to get request wps mode");
1676                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1677                 }
1678                 break;
1679         case WIFI_DIRECT_CMD_SET_REQ_WPS_MODE:
1680                 res = wfd_manager_set_req_wps_mode(req.data.int1);
1681                 if (res < 0) {
1682                         WDS_LOGE("Failed to set request wps mode");
1683                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1684                 }
1685                 break;
1686         case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
1687                 if (manager->local->dev_role != WFD_DEV_ROLE_GO) {
1688                         WDS_LOGE("Wi-Fi Direct is not Group Owner.");
1689                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1690                         break;
1691                 }
1692
1693                 res = wfd_oem_wps_start(manager->oem_ops, NULL, WFD_WPS_MODE_PBC, NULL);
1694                 if (res < 0) {
1695                         WDS_LOGE("Failed to start wps");
1696                         rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1697                 }
1698                 break;
1699         case WIFI_DIRECT_CMD_GET_WPS_PIN:       // session
1700                 {
1701                         wfd_session_s *session = (wfd_session_s*) manager->session;
1702                         if (!session || manager->auto_pin[0] != 0) {
1703                                 WDS_LOGE("Session not exist");
1704                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1705                                 break;
1706                         }
1707
1708                         if (session->wps_pin[0] == '\0') {
1709                                 WDS_LOGE("WPS PIN is not set");
1710                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1711                                 break;
1712                         }
1713                         g_snprintf(rsp.param2, sizeof(rsp.param2), "%s", session->wps_pin);
1714                 }
1715                 break;
1716         case WIFI_DIRECT_CMD_SET_WPS_PIN:       // session
1717                 {
1718                         char *pin = NULL;
1719                         wfd_session_s *session = (wfd_session_s*) manager->session;
1720                         if (!session) {
1721                                 WDS_LOGE("Session not exist");
1722                                 pin = manager->auto_pin;
1723                         } else {
1724                                 pin = session->wps_pin;
1725                         }
1726                         res = _wfd_read_from_client(sock, pin, PINSTR_LEN);
1727                         if (res == -2) {
1728                                 WDS_LOGE("Client socket Hanged up");
1729                                 _wfd_deregister_client(manager, sock);
1730                                 return FALSE;
1731                         } else if (res == -1) {
1732                                 WDS_LOGE("Failed to read socket [%d]", sock);
1733                                 return TRUE;
1734                         }
1735                         pin[PINSTR_LEN] = '\0';
1736                         WDS_LOGD("PIN string [%s]", pin);
1737                 }
1738                 break;
1739         case WIFI_DIRECT_CMD_GENERATE_WPS_PIN:  // manager
1740                 // TODO: implement in plugin
1741                 break;
1742
1743
1744         case WIFI_DIRECT_CMD_GET_PEER_INFO:
1745                 {
1746                         wfd_discovery_entry_s *peer = NULL;
1747                         int res = 0;
1748                         res = wfd_manager_get_peer_info(manager,req.data.mac_addr, &peer);
1749                         if (res < 0 || !peer) {
1750                                 WDS_LOGE("Failed to get peer info");
1751                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1752                                 if(peer)
1753                                         free(peer);
1754                                 break;
1755                         }
1756                         rsp.result = WIFI_DIRECT_ERROR_NONE;
1757
1758                         rsp.data_length = sizeof(wfd_discovery_entry_s);
1759                         extra_rsp = (char*) peer;
1760                         WDS_LOGD("extra_rsp length [%d], extra_rsp [%x]", rsp.data_length, extra_rsp);
1761                 }
1762                 break;
1763         case WIFI_DIRECT_CMD_SET_PASSPHRASE:
1764                 {
1765                         char passphrase[PASSPHRASE_LEN + 1] = {0,};
1766                         wfd_group_s *group = manager->group;
1767                         if (group) {
1768                                 WDS_LOGE("Group already exists");
1769                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1770                                 _wfd_read_from_client(sock, passphrase, PASSPHRASE_LEN);
1771                                 break;
1772                         }
1773
1774                         res = _wfd_read_from_client(sock, manager->local->passphrase, PASSPHRASE_LEN);
1775                         if (res == -2) {
1776                                 WDS_LOGE("Client socket Hanged up");
1777                                 _wfd_deregister_client(manager, sock);
1778                                 return FALSE;
1779                         } else if (res == -1) {
1780                                 WDS_LOGE("Failed to read socket [%d]", sock);
1781                                 return TRUE;
1782                         }
1783                         manager->local->passphrase[PASSPHRASE_LEN] = '\0';
1784                         WDS_LOGD("Passphrase string [%s]", manager->local->passphrase);
1785                 }
1786                 break;
1787         case WIFI_DIRECT_CMD_GET_PASSPHRASE:
1788                 {
1789                         wfd_group_s *group = manager->group;
1790                         if (!group) {
1791                                 WDS_LOGE("Group not exist");
1792                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1793                                 break;
1794                         }
1795                         if (group->role == WFD_DEV_ROLE_GC) {
1796                                 WDS_LOGE("Device is not GO");
1797                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1798                                 break;
1799                         }
1800                         g_strlcpy(rsp.param2, group->passphrase, PASSPHRASE_LEN + 1);
1801                         WDS_LOGD("group->pass : [%s]", group->passphrase);
1802                 }
1803                 break;
1804 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1805         case WIFI_DIRECT_CMD_REGISTER_SERVICE:
1806                 {
1807                         int service_type = req.data.int1;
1808                         char *info_str = NULL;
1809
1810                         info_str = (char*) g_try_malloc0(req.cmd_data_len);
1811                         if (!info_str) {
1812                                 WDS_LOGE("Failed to allocate memory for info string");
1813                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1814                                 break;
1815                         }
1816
1817                         res = _wfd_read_from_client(sock, info_str, req.cmd_data_len);
1818                         if (res < 0) {
1819                                 WDS_LOGE("Failed to read from socket");
1820                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1821                                 g_free(info_str);
1822                                 break;
1823                         }
1824                         info_str[req.cmd_data_len] = '\0';
1825                         WDS_LOGD("Register service [%d: %s]", service_type, info_str);
1826
1827                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1828                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1829                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1830                                 g_free(info_str);
1831                                 break;
1832                         }
1833
1834                         res = wfd_service_add(&(manager->local->services), service_type, info_str, &rsp.param1);
1835                         if (res < 0) {
1836                                 WDS_LOGE("Failed to add service");
1837                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1838                         }
1839
1840                         g_free(info_str);
1841                 }
1842                 break;
1843
1844         case WIFI_DIRECT_CMD_DEREGISTER_SERVICE:
1845                 {
1846                         int service_id = req.data.int1;
1847
1848                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1849                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1850                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1851                                 break;
1852                         }
1853
1854                         res = wfd_service_del(manager->local->services, service_id);
1855                         if (res < 0) {
1856                                 WDS_LOGE("Failed to delete service");
1857                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1858                         }
1859                 }
1860                 break;
1861
1862         case WIFI_DIRECT_CMD_START_SERVICE_DISCOVERY:
1863                 {
1864                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1865                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1866                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1867                                 break;
1868                         }
1869
1870                         int service_type = req.data.int1;
1871                         WDS_LOGD("Service type [%d]", service_type);
1872
1873                         res = wfd_oem_start_service_discovery(manager->oem_ops, req.data.mac_addr, service_type);
1874                         if (res < 0) {
1875                                 WDS_LOGE("Failed to start service discovery");
1876                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1877                         }
1878
1879                         noti = (wifi_direct_client_noti_s*) g_try_malloc0(sizeof(wifi_direct_client_noti_s));
1880                         noti->event = WIFI_DIRECT_CLI_EVENT_SERVICE_DISCOVERY_STARTED;
1881                         noti->error = WIFI_DIRECT_ERROR_NONE;
1882                 }
1883                 break;
1884
1885         case WIFI_DIRECT_CMD_CANCEL_SERVICE_DISCOVERY:
1886                 {
1887                         int service_type;
1888
1889                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1890                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1891                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1892                                 break;
1893                         }
1894
1895                         service_type = req.data.int1;
1896                         WDS_LOGD("Service type [%d]", service_type);
1897
1898                         res = wfd_oem_cancel_service_discovery(manager->oem_ops, req.data.mac_addr, service_type);
1899                         if (res < 0) {
1900                                 WDS_LOGE("Failed to cancel service discovery");
1901                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1902                         }
1903                 }
1904                 break;
1905 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1906
1907 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1908         case WIFI_DIRECT_CMD_INIT_MIRACAST:
1909                 {
1910                         if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1911                                 WDS_LOGE("Wi-Fi Direct is not activated.");
1912                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1913                                 break;
1914                         }
1915
1916                         int miracast_enable = req.data.int1;
1917                         WDS_LOGD("Miracast enable [%d]", miracast_enable);
1918
1919                         res = wfd_oem_miracast_init(manager->oem_ops, miracast_enable);
1920                         if (res < 0) {
1921                                 WDS_LOGE("Failed to initialize miracast");
1922                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1923
1924                         } else {
1925
1926                                 if(miracast_enable) {
1927                                         manager->local->display.type = WIFI_DISPLAY_DEFAULT_TYPE;
1928                                         manager->local->display.port = WIFI_DISPLAY_DEFAULT_PORT;
1929                                         manager->local->display.availablity = WIFI_DISPLAY_DEFAULT_AVAIL;
1930                                         manager->local->display.hdcp_support = WIFI_DISPLAY_DEFAULT_HDCP;
1931                                         manager->local->display.max_tput = WIFI_DISPLAY_DEFAULT_TPUT;
1932                                 } else {
1933                                         memset(&(manager->local->display), 0x0, sizeof(wfd_display_type_e));
1934                                 }
1935 #if 0
1936                                 int screen_mirroring_status;
1937                                 if (vconf_get_int(VCONFKEY_SCREEN_MIRRORING_STATE, &screen_mirroring_status) < 0)
1938                                         WDS_LOGE("Failed to get vconf VCONFKEY_SCREEN_MIRRORING_STATE\n");
1939                                 WDS_LOGD("screen_mirroring_status: %d\n", screen_mirroring_status);
1940
1941                                 if (miracast_enable == TRUE) {
1942
1943                                         /* set go intent 14 so that can be Group Owner. value 15 can cause connection fail when nego with peer has 15 go intent value.  */
1944                                         res = wfd_manager_set_go_intent(14);
1945                                         if (res < 0)
1946                                                 WDS_LOGE("Failed to set GO intent");
1947
1948                                         /* set vconf of Screen Mirroring state. This is necessary to avoid 5 min. auto-deactivation in case of applications using Screen Mirroring. */
1949                                         if(screen_mirroring_status < VCONFKEY_SCREEN_MIRRORING_ACTIVATED)
1950                                         {
1951                                                 if (vconf_set_int(VCONFKEY_SCREEN_MIRRORING_STATE, VCONFKEY_SCREEN_MIRRORING_ACTIVATED) < 0)
1952                                                         WDS_LOGE("Failed to get vconf VCONFKEY_SCREEN_MIRRORING_STATE\n");
1953                                         }
1954
1955                                 } else {
1956
1957                                         /* set go intent to default value */
1958                                         res = wfd_manager_set_go_intent(7);
1959                                         if (res < 0)
1960                                                 WDS_LOGE("Failed to set GO intent");
1961
1962                                         /* set vconf of Screen Mirroring state. This is necessary in case of applications using Screen Mirroring. */
1963                                         if(screen_mirroring_status < VCONFKEY_SCREEN_MIRRORING_CONNECTED)
1964                                         {
1965                                                 if (vconf_set_int(VCONFKEY_SCREEN_MIRRORING_STATE, VCONFKEY_SCREEN_MIRRORING_DEACTIVATED) < 0)
1966                                                         WDS_LOGE("Failed to get vconf VCONFKEY_SCREEN_MIRRORING_STATE\n");
1967                                         }
1968                                 }
1969 #endif
1970                         }
1971                 }
1972                 break;
1973         case WIFI_DIRECT_CMD_INIT_DISPLAY:
1974                 {
1975                         if(manager->state < WIFI_DIRECT_STATE_ACTIVATED || manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
1976                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1977                                 break;
1978                         }
1979
1980                         wfd_device_s * device = manager->local;
1981
1982                         res = wfd_oem_miracast_init(manager->oem_ops, true);
1983                         if (res < 0) {
1984                                 WDS_LOGE("Failed to initialize display");
1985                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1986                         } else {
1987                                 device->display.type = WIFI_DISPLAY_DEFAULT_TYPE;
1988                                 device->display.port = WIFI_DISPLAY_DEFAULT_PORT;
1989                                 device->display.availablity = WIFI_DISPLAY_DEFAULT_AVAIL;
1990                                 device->display.hdcp_support = WIFI_DISPLAY_DEFAULT_HDCP;
1991                                 device->display.max_tput = WIFI_DISPLAY_DEFAULT_TPUT;
1992                         }
1993                 }
1994                 break;
1995         case WIFI_DIRECT_CMD_DEINIT_DISPLAY:
1996                 {
1997                         if(manager->state < WIFI_DIRECT_STATE_ACTIVATED || manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
1998                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1999                                 break;
2000                         }
2001
2002                         wfd_device_s * device = manager->local;
2003
2004                         res = wfd_oem_miracast_init(manager->oem_ops, false);
2005                         if (res < 0) {
2006                                 WDS_LOGE("Failed to deinitialize display");
2007                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
2008
2009                         }
2010                         memset(&(device->display), 0x0, sizeof(wfd_display_type_e));
2011                 }
2012                 break;
2013         case WIFI_DIRECT_CMD_SET_DISPLAY:
2014                 {
2015                         if(manager->state < WIFI_DIRECT_STATE_ACTIVATED || manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
2016                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2017                                 break;
2018                         }
2019
2020                         int type = req.data.int1;       // type
2021                         int port = req.data.int2;       // port
2022                         int hdcp = req.data.int3;       // hdcp
2023
2024                         res = wfd_manager_set_display_device(type, port, hdcp);
2025                         if (res < 0) {
2026                                 WDS_LOGE("Failed to set display device settings");
2027                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
2028                         }
2029                 }
2030                 break;
2031         case WIFI_DIRECT_CMD_SET_DISPLAY_AVAILABILITY:
2032                 {
2033                         if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2034                                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2035                                 break;
2036                         }
2037                         res = wfd_manager_set_session_availability(req.data.int1);
2038                         if (res < 0) {
2039                                 WDS_LOGE("Failed to set session availability");
2040                                 rsp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
2041                                 break;
2042                         }
2043                 }
2044                 break;
2045         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_TYPE:
2046         {
2047                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2048                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2049                         break;
2050                 }
2051
2052                 wfd_device_s *peer = NULL;
2053
2054                 peer = wfd_manager_get_peer_by_addr(manager, req.data.mac_addr);
2055                 if(peer) {
2056                         rsp.param1 = peer->display.type;
2057                 } else {
2058                         WDS_LOGE("Failed to get peer");
2059                         rsp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2060                         break;
2061                 }
2062         }
2063         break;
2064         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_AVAILABILITY:
2065         {
2066                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2067                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2068                         break;
2069                 }
2070
2071                 wfd_device_s *peer = NULL;
2072
2073                 peer = wfd_manager_get_peer_by_addr(manager, req.data.mac_addr);
2074                 if(peer) {
2075                         rsp.param1 = peer->display.availablity;
2076                 } else {
2077                         WDS_LOGE("Failed to get peer");
2078                         rsp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2079                         break;
2080                 }
2081         }
2082         break;
2083         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_HDCP:
2084         {
2085                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2086                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2087                         break;
2088                 }
2089
2090                 wfd_device_s *peer = NULL;
2091
2092                 peer = wfd_manager_get_peer_by_addr(manager, req.data.mac_addr);
2093                 if(peer) {
2094                         rsp.param1 = peer->display.hdcp_support;
2095                 } else {
2096                         WDS_LOGE("Failed to get peer");
2097                         rsp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2098                         break;
2099                 }
2100         }
2101         break;
2102         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_PORT:
2103         {
2104                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2105                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2106                         break;
2107                 }
2108
2109                 wfd_device_s *peer = NULL;
2110
2111                 peer = wfd_manager_get_peer_by_addr(manager, req.data.mac_addr);
2112                 if(peer) {
2113                         rsp.param1 = peer->display.port;
2114                 } else {
2115                         WDS_LOGE("Failed to get peer");
2116                         rsp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2117                         break;
2118                 }
2119         }
2120         break;
2121         case WIFI_DIRECT_CMD_GET_PEER_DISPLAY_THROUGHPUT:
2122         {
2123                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
2124                         rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2125                         break;
2126                 }
2127
2128                 wfd_device_s *peer = NULL;
2129
2130                 peer = wfd_manager_get_peer_by_addr(manager, req.data.mac_addr);
2131                 if(peer) {
2132                         rsp.param1 = peer->display.max_tput;
2133                 } else {
2134                         WDS_LOGE("Failed to get peer");
2135                         rsp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
2136                         break;
2137                 }
2138         }
2139         break;
2140 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
2141         default:
2142                 WDS_LOGE("Unknown command[%d]", req.cmd);
2143                 rsp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
2144                 break;
2145         }
2146
2147 send_response:
2148         res = _wfd_send_to_client(sock, (char*) &rsp, sizeof(rsp));
2149         if (res < 0) {
2150                 WDS_LOGE("Failed to send response to client");
2151                 g_free(extra_rsp);
2152                 g_free(noti);
2153                 _wfd_deregister_client(manager, req.client_id);
2154                 __WDS_LOG_FUNC_EXIT__;
2155                 return FALSE;
2156         }
2157
2158         if (rsp.data_length > 0) {
2159                 res = _wfd_send_to_client(sock, (char*) extra_rsp, rsp.data_length);
2160                 if (res < 0) {
2161                         WDS_LOGE("Failed to send extra response data to client");
2162                         g_free(extra_rsp);
2163                         g_free(noti);
2164                         _wfd_deregister_client(manager, req.client_id);
2165                         __WDS_LOG_FUNC_EXIT__;
2166                         return FALSE;
2167                 }
2168                 g_free(extra_rsp);
2169                 extra_rsp = NULL;
2170         }
2171
2172 send_notification:
2173         if (noti) {
2174                 res = wfd_client_send_event(manager, noti);
2175                 if (res < 0) {
2176                         WDS_LOGE("Failed to send Notification to client");
2177                         g_free(extra_rsp);
2178                         g_free(noti);
2179                         __WDS_LOG_FUNC_EXIT__;
2180                         return FALSE;
2181                 }
2182                 WDS_LOGD("Succeeded to send Notification[%d] to client", noti->event);
2183                 g_free(noti);
2184         }
2185
2186 done:
2187         g_free(extra_rsp);
2188         __WDS_LOG_FUNC_EXIT__;
2189         return TRUE;
2190 }
2191