plugin/wpasupplicant/src/wifi-direct-plugin.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012-2013 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 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <glib.h>
  23 #include <glib-object.h>
  24 #include <sys/socket.h>
  25 #include <unistd.h>
  26 #include <sys/un.h>
  27 #include <sys/poll.h>
  28 #include <net/if.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <sys/ioctl.h>
  32
  33 //#include "wifi-direct-utils.h"
  34 #include "wifi-direct-oem.h"
  35 #include "wifi-direct-service.h"
  36 #include "wifi-direct-wpasupplicant.h"
  37
  38 #define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
  39 #define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
  40
  41 int g_global_sockfd;
  42 int g_control_sockfd;
  43 int g_monitor_sockfd;
  44 int g_source_id;
  45
  46 static char g_local_interface_ip_address[20];
  47 static wfd_noti_cb g_noti_cb;
  48 wfd_oem_event_cb g_oem_event_callback;
  49 int g_oem_pipe[2];
  50 GList *g_conn_peer_addr;
  51 static unsigned char g_assoc_sta_mac[6];
  52 static unsigned char g_disassoc_sta_mac[6];
  53 char g_wps_pin[WPS_PIN_LEN];
  54 static int g_wps_event_block;
  55
  56 enum current_conn_direction
  57 {
  58         CONN_DIRECTION_NONE,
  59         CONN_DIRECTION_INCOMING,
  60         CONN_DIRECTION_OUTGOING,
  61 };
  62
  63 static struct wfd_oem_operations supplicant_ops =
  64 {
  65         .wfd_oem_init = wfd_ws_init,
  66         .wfd_oem_destroy = wfd_ws_destroy,
  67         .wfd_oem_activate = wfd_ws_activate,
  68         .wfd_oem_deactivate = wfd_ws_deactivate,
  69         .wfd_oem_connect = wfd_ws_connect,
  70         .wfd_oem_wps_pbc_start = wfd_ws_wps_pbc_start,
  71         .wfd_oem_wps_pin_start = wfd_ws_wps_pin_start,
  72         .wfd_oem_disconnect = wfd_ws_disconnect,
  73         .wfd_oem_disconnect_sta = wfd_ws_disconnect_sta,
  74         .wfd_oem_is_discovery_enabled = wfd_ws_is_discovery_enabled,
  75         .wfd_oem_start_discovery = wfd_ws_start_discovery,
  76         .wfd_oem_cancel_discovery = wfd_ws_cancel_discovery,
  77         .wfd_oem_get_discovery_result = wfd_ws_get_discovery_result,
  78         .wfd_oem_get_peer_info = wfd_ws_get_peer_info,
  79         .wfd_oem_send_provision_discovery_request = wfd_ws_send_provision_discovery_request,
  80         .wfd_oem_send_invite_request = wfd_ws_send_invite_request,
  81         .wfd_oem_create_group = wfd_ws_create_group,
  82         .wfd_oem_cancel_group = wfd_ws_cancel_group,
  83         .wfd_oem_activate_pushbutton = wfd_ws_activate_pushbutton,
  84         .wfd_oem_get_default_interface_name = wfd_ws_get_default_interface_name,
  85         .wfd_oem_dhcpc_get_ip_address = wfd_ws_dhcpc_get_ip_address,
  86         .wfd_oem_get_ip = wfd_ws_get_ip,
  87         .wfd_oem_set_ssid = wfd_ws_set_ssid,
  88         .wfd_oem_is_groupowner = wfd_ws_is_groupowner,
  89         .wfd_oem_get_ssid = wfd_ws_get_ssid,
  90         .wfd_oem_set_wps_pin = wfd_ws_set_wps_pin,
  91         .wfd_oem_get_wps_pin = wfd_ws_get_wps_pin,
  92         .wfd_oem_generate_wps_pin = wfd_ws_generate_wps_pin,
  93         .wfd_oem_set_wpa_passphrase = wfd_ws_set_wpa_passphrase,
  94         .wfd_oem_get_supported_wps_mode = wfd_ws_get_supported_wps_mode,
  95         .wfd_oem_get_connected_peers_info = wfd_ws_get_connected_peers_info,
  96         .wfd_oem_get_connected_peers_count = wfd_ws_get_connected_peers_count,
  97         .wfd_oem_set_oem_loglevel = wfd_ws_set_oem_loglevel,
  98         .wfd_oem_get_go_intent = wfd_ws_get_go_intent,
  99         .wfd_oem_set_go_intent = wfd_ws_set_go_intent,
 100         .wfd_oem_set_device_type = wfd_ws_set_device_type,
 101         .wfd_oem_get_device_mac_address = wfd_ws_get_device_mac_address,
 102         .wfd_oem_get_disassoc_sta_mac = wfd_ws_get_disassoc_sta_mac,
 103         .wfd_oem_get_assoc_sta_mac = wfd_ws_get_assoc_sta_mac,
 104         .wfd_oem_get_requestor_mac = wfd_ws_get_requestor_mac,
 105         .wfd_oem_get_operating_channel = wfd_ws_get_operating_channel,
 106         .wfd_oem_get_persistent_group_info = wfd_ws_get_persistent_group_info,
 107         .wfd_oem_remove_persistent_group = wfd_ws_remove_persistent_group,
 108         .wfd_oem_set_persistent_group_enabled = wfd_ws_set_persistent_reconnect,
 109         .wfd_oem_connect_for_persistent_group = wfd_ws_connect_for_persistent_group,
 110 };
 111
 112 int wfd_plugin_load( struct wfd_oem_operations **ops)
 113 {
 114         *ops = &supplicant_ops;
 115
 116         return true;
 117 }
 118
 119 static gboolean __wfd_oem_thread_safe_event_handler_cb(GIOChannel* source, GIOCondition condition, gpointer data)
 120 {
 121         wfd_event_t event;
 122         int n = 0;
 123
 124         // Read header part
 125         n = read(g_oem_pipe[0], &event, sizeof(event));
 126         if (n < 0)
 127         {
 128                 WDP_LOGE( "pipe read error, Error=[%s]\n",strerror(errno));
 129                 return 0;  // false
 130         }
 131
 132         if (g_oem_event_callback != NULL)
 133                 g_oem_event_callback(event);
 134
 135         return true;
 136 }
 137
 138 int __send_wpa_request(int sockfd, char *cmd, char *reply, size_t reply_buf_len)
 139 {
 140         __WDP_LOG_FUNC_ENTER__;
 141
 142         int result = 0;
 143         size_t cmd_len;
 144
 145         int pollret = 0;
 146         struct pollfd pollfd;
 147         int timeout = 6000; /** for 6.0 sec */
 148
 149         if (sockfd <=0 )
 150         {
 151                 WDP_LOGE("Invalid argument sfd=[%d]\n", sockfd);
 152                 return false;
 153         }
 154
 155         if(cmd == NULL)
 156         {
 157                 WDP_LOGE("Invalid argument. Command is NULL\n");
 158                 return false;
 159         }
 160         cmd_len = strlen(cmd);
 161         WDP_LOGI("cmd [%s] cmd_len[%d]\n", cmd, cmd_len);
 162
 163         result = write(sockfd, cmd, cmd_len);
 164         if ( result < 0)
 165         {
 166                 WDP_LOGE( "Send cmd failed: [%d]\n", result);
 167                 __WDP_LOG_FUNC_EXIT__;
 168                 return false;
 169         }
 170
 171         for (;;)
 172         {
 173                 pollfd.fd = sockfd;
 174                 pollfd.events = POLLIN | POLLERR | POLLHUP;
 175                 pollret = poll(&pollfd, 1, timeout);
 176
 177                 if (pollret == 0)
 178                 {
 179                         WDP_LOGI( "POLLing timeout. Nothing to read.\n");
 180                         __WDP_LOG_FUNC_EXIT__;
 181                         return 0;
 182                 }
 183                 else if (pollret < 0)
 184                 {
 185                         WDP_LOGE("Polling error [%d]\n", pollret);
 186                         __WDP_LOG_FUNC_EXIT__;
 187                         return false;
 188                 }
 189                 else
 190                 {
 191                         if (pollfd.revents == POLLIN)
 192                         {
 193                                 WDP_LOGD("POLLIN \n");
 194                                 result = read(sockfd, (char *) reply, reply_buf_len);
 195
 196                                 WDP_LOGD("sockfd %d retval %d\n", sockfd, result);
 197                                 WDP_LOGD("reply[%s]\n", reply);
 198
 199                                 if (result < 0)
 200                                 {
 201                                         WDP_LOGE( "Error!!! reading data, error [%s]\n", strerror(errno));
 202                                         __WDP_LOG_FUNC_EXIT__;
 203                                         return false;
 204                                 }
 205                                 break;
 206                         }
 207                         else
 208                         {
 209                                 WDP_LOGD("POLL EVENT=%d ignored\n", pollfd.revents);
 210                                 __WDP_LOG_FUNC_EXIT__;
 211                                 return false;
 212                         }
 213                 }
 214         }
 215
 216         __WDP_LOG_FUNC_EXIT__;
 217         return result;
 218 }
 219
 220
 221 int __create_ctrl_intf(char *ctrl_intf_name, char *path)
 222 {
 223         __WDP_LOG_FUNC_ENTER__;
 224
 225         struct sockaddr_un servAddr;
 226         struct sockaddr_un localAddr;
 227         char local_path[32] = {0, };
 228         int sockfd = 0;
 229         int len = 0;
 230         int ret = 0;
 231
 232         snprintf(local_path, sizeof(local_path), "/tmp/%s", ctrl_intf_name);
 233         unlink(local_path);
 234
 235         errno = 0;
 236         if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
 237         {
 238                 WDP_LOGE( "Error!!! creating sync socket. Error = [%s].\n", strerror(errno));
 239                 __WDP_LOG_FUNC_EXIT__;
 240                 return -1;
 241         }
 242
 243         WDP_LOGI( "Created socket [%d]\n", sockfd);
 244
 245         memset(&servAddr, 0, sizeof(servAddr));
 246         servAddr.sun_family = AF_UNIX;
 247         strcpy(servAddr.sun_path, path);
 248         len = sizeof(servAddr.sun_family) + strlen(path);
 249
 250         WDP_LOGD( "Connecting to server socket to register socket [%d]\n", sockfd);
 251
 252         memset(&localAddr, 0, sizeof(localAddr));
 253         localAddr.sun_family = AF_UNIX;
 254         strcpy(localAddr.sun_path, local_path);
 255
 256         if (bind(sockfd, (struct sockaddr*)&localAddr, sizeof(localAddr)) < 0)
 257         {
 258                 WDP_LOGE( "Error!!! bind(). Error = [%s]. Try again..\n", strerror(errno));
 259
 260                 unlink(localAddr.sun_path);
 261                 if (bind(sockfd, (struct sockaddr*)&localAddr, sizeof(localAddr)) < 0)
 262                 {
 263                         WDP_LOGE( "Error!!! bind(). Error = [%s]. Give up..\n", strerror(errno));
 264                         __WDP_LOG_FUNC_EXIT__;
 265                         return -1;
 266                 }
 267         }
 268
 269         errno = 0;
 270         if ((ret = connect(sockfd, (struct sockaddr *) &servAddr, sizeof(servAddr))) < 0)
 271         {
 272
 273                 if (unlink(path) < 0)
 274                 {
 275                         WDP_LOGE("unlink[ctrl_iface], Error=[%s]", strerror(errno));
 276                         __WDP_LOG_FUNC_EXIT__;
 277                         return -1;
 278                 }
 279
 280                 if (bind(sockfd, (struct sockaddr*)&servAddr, sizeof(servAddr)) < 0)
 281                 {
 282                         WDP_LOGE("bind[PF_UNIX], Error=[%s]", strerror(errno));
 283                         __WDP_LOG_FUNC_EXIT__;
 284                         return -1;
 285                 }
 286                 WDP_LOGI( "Successfully replaced leftover ctrl_iface socket [%s]\n", path);
 287         }
 288
 289         __WDP_LOG_FUNC_EXIT__;
 290
 291         return sockfd;
 292 }
 293
 294
 295 static int __read_socket_cb(int sockfd, char *dataptr, int datalen)
 296 {
 297         __WDP_LOG_FUNC_ENTER__;
 298
 299         int pollret = 0;
 300         struct pollfd pollfd;
 301         int timeout = 2000; /** for 2 sec */
 302         int retval = 0;
 303
 304         WDP_LOGD( "Reading msg from socketfd=[%d]\n", sockfd);
 305
 306         if (sockfd <= 0)
 307         {
 308                 WDP_LOGE( "Error!!! Invalid socket FD [%d]\n", sockfd);
 309                 __WDP_LOG_FUNC_EXIT__;
 310                 return -1;
 311         }
 312
 313         if ((dataptr == NULL) || (datalen <= 0))
 314         {
 315                 WDP_LOGE( "Error!!! Invalid parameter\n");
 316                 __WDP_LOG_FUNC_EXIT__;
 317
 318                 return -1;
 319         }
 320
 321         //printf("@@@@@@@ len = %d  @@@@@@@@@@@\n", datalen);
 322
 323         pollfd.fd = sockfd;
 324         pollfd.events = POLLIN | POLLERR | POLLHUP;
 325         pollret = poll(&pollfd, 1, timeout);
 326
 327         //printf("POLL ret = %d,  \n", pollret);
 328
 329         if (pollret > 0)
 330         {
 331                 if (pollfd.revents == POLLIN)
 332                 {
 333                         WDP_LOGD( "POLLIN\n");
 334
 335                         errno = 0;
 336                         retval = read(sockfd, (char *) dataptr, datalen);
 337                         WDP_LOGD( "sockfd %d retval %d\n", sockfd, retval);
 338                         if (retval <= 0)
 339                         {
 340                                 WDP_LOGD( "Error!!! reading data, Error=[%s]\n", strerror(errno));
 341                         }
 342                         __WDP_LOG_FUNC_EXIT__;
 343                         return retval;
 344                 }
 345                 else if (pollfd.revents & POLLHUP)
 346                 {
 347                         WDP_LOGD( "POLLHUP\n");
 348                         __WDP_LOG_FUNC_EXIT__;
 349
 350                         return 0;
 351                 }
 352                 else if (pollfd.revents & POLLERR)
 353                 {
 354                         WDP_LOGD( "POLLERR\n");
 355                         __WDP_LOG_FUNC_EXIT__;
 356                         return 0;
 357                 }
 358         }
 359         else if (pollret == 0)
 360         {
 361                 WDP_LOGD( "POLLing timeout  \n");
 362                 __WDP_LOG_FUNC_EXIT__;
 363                 return 0;
 364         }
 365         else
 366         {
 367                 WDP_LOGD( "Polling unknown error \n");
 368                 __WDP_LOG_FUNC_EXIT__;
 369                 return -1;
 370         }
 371
 372         __WDP_LOG_FUNC_EXIT__;
 373         return 1;
 374 }
 375
 376
 377 void __polling_ip(char *ipaddr_buf, int len, int is_IPv6)
 378 {
 379         int i = 0;
 380
 381         while(i < 24) {
 382                 if (wfd_ws_dhcpc_get_ip_address(ipaddr_buf, len, is_IPv6) == true)
 383                 {
 384                         return;
 385                 }
 386                 usleep(250);
 387                 i++;
 388         }
 389         WDP_LOGE( "** Failed to get IP address!!\n");
 390 }
 391
 392 char* __get_event_str(char*ptr, char* event_str)
 393 {
 394         char* p = ptr;
 395         int c = 0;
 396
 397         event_str[0] = '\0';
 398
 399         if (p==NULL)
 400                 return NULL;
 401
 402         while(*p != '\n')
 403         {
 404                 if (*p == '\0')
 405                 {
 406                         event_str[c] = '\0';
 407                         return NULL;
 408                 }
 409
 410                 if (*p == ' ')
 411                         break;
 412
 413                 event_str[c++] = *p++;
 414         }
 415         event_str[c]='\0';
 416         p++;
 417
 418         return p;
 419 }
 420
 421 int __extract_value_str(char *str, char *key, char *value)
 422 {
 423         __WDP_LOG_FUNC_ENTER__;
 424         char *tmp_str = NULL;
 425         int i = 0;
 426
 427         if(value == NULL)
 428                 return -1;
 429
 430         tmp_str = strstr(str, key);
 431         if(tmp_str == NULL)
 432         {
 433                 WDP_LOGE( "Key[%s] is not found\n", key);
 434                 return -1;
 435         }
 436         tmp_str = tmp_str + strlen(key) + 1;
 437         //WDP_LOGD( "tmp_str [%s]\n", tmp_str);
 438
 439         for(i = 0; tmp_str[i]; i++)
 440         {
 441                 if(tmp_str[i] == '\n' || tmp_str[i] == '\r' || tmp_str[i] == ' ')
 442                 {
 443                         break;
 444                 }
 445         }
 446
 447         memcpy(value, tmp_str, i);
 448         value[i] = '\0';
 449
 450         WDP_LOGD( "extracted value [%s]\n", value);
 451
 452         __WDP_LOG_FUNC_EXIT__;
 453         return i;
 454 }
 455
 456
 457 int __is_white_space(char c)
 458 {
 459         if (c < 32)
 460                 return 1;
 461
 462         return 0;
 463 }
 464
 465 int __is_item_char(char c)
 466 {
 467         if (c >= 'a' && c <= 'z')
 468                 return 1;
 469
 470         if (c >= 'A' && c <= 'Z')
 471                 return 1;
 472
 473         if (c >= '0' && c <= '9')
 474                 return 1;
 475
 476         if (c=='_')
 477                 return 1;
 478
 479         if (c=='-')
 480                 return 1;
 481
 482         if (c==':')
 483                 return 1;
 484
 485         if (c=='[')
 486                 return 1;
 487
 488         if (c==']')
 489                 return 1;
 490
 491         return 0;
 492 }
 493
 494
 495 char* __get_item_value(char*ptr, char* item, char* value)
 496 {
 497         char* p = ptr;
 498         int c = 0;
 499
 500         item[0] = '\0';
 501         value[0]='\0';
 502
 503         if (p==NULL)
 504                 return NULL;
 505
 506         while(*p != '=')
 507         {
 508                 if (*p == '\n')
 509                 {
 510                         item[c] = '\0';
 511                         return ++p;
 512                 }
 513                 if (*p == '\0')
 514                 {
 515                         item[c] = '\0';
 516                         return NULL;
 517                 }
 518                 if (__is_white_space(*p) || !__is_item_char(*p))
 519                         p++;
 520                 else
 521                         item[c++] = *p++;
 522         }
 523         item[c]='\0';
 524         p++;
 525
 526         c=0;
 527         while(*p != '\n')
 528         {
 529                 if (*p == '\0')
 530                 {
 531                         value[c] = '\0';
 532                         return NULL;
 533                 }
 534                 if (__is_white_space(*p))
 535                         p++;
 536                 else
 537                         value[c++] = *p++;
 538         }
 539         value[c]='\0';
 540         p++;
 541
 542         return p;
 543 }
 544
 545
 546 char* __get_persistent_group_value(char*ptr, ws_network_info_s* group)
 547 {
 548         char* p = ptr;
 549         int c;
 550         char value[128];
 551
 552         if (p==NULL)
 553                 return NULL;
 554
 555         /* network_id */
 556         c = 0;
 557         memset(value, 0, sizeof(value));
 558         while(__is_item_char(*p))
 559         {
 560                 value[c++] = *p++;
 561         }
 562         group->network_id = atoi(value);
 563
 564         while(!__is_item_char(*p))
 565         {
 566                 p++;
 567         }
 568
 569         /* ssid */
 570         c = 0;
 571         memset(value, 0, sizeof(value));
 572         while(__is_item_char(*p))
 573         {
 574                 value[c++] = *p++;
 575         }
 576         strncpy(group->ssid, value, NETWORK_SSID_LEN);
 577         group->ssid[NETWORK_SSID_LEN-1] = '\0';
 578
 579         while(!__is_item_char(*p))
 580         {
 581                 p++;
 582         }
 583
 584         /* bssid */
 585         c = 0;
 586         memset(value, 0, sizeof(value));
 587         while(__is_item_char(*p))
 588         {
 589                 value[c++] = *p++;
 590         }
 591         strncpy(group->bssid, value, NETWORK_BSSID_LEN);
 592         group->bssid[NETWORK_BSSID_LEN-1] = '\0';
 593
 594         while(!__is_item_char(*p))
 595         {
 596                 p++;
 597         }
 598
 599         /* flags */
 600         c = 0;
 601         memset(value, 0x00, sizeof(value));
 602         while(*p != '\n')
 603         {
 604                 value[c++] = *p++;
 605         }
 606         strncpy(group->flags, value, NETWORK_FLAGS_LEN);
 607         group->flags[NETWORK_FLAGS_LEN-1] = '\0';
 608
 609         p++;
 610         return p;
 611 }
 612
 613
 614 int __parsing_peer(char* buf, ws_discovered_peer_info_s* peer)
 615 {
 616         __WDP_LOG_FUNC_ENTER__;
 617
 618         char* ptr = buf;
 619         char item[64];
 620         char value[128];
 621         int i;
 622         int item_id;
 623
 624         memset(peer, 0, sizeof(ws_discovered_peer_info_s));
 625
 626         // Get mac address
 627         strncpy(peer->mac, ptr, MACSTR_LEN);
 628         peer->mac[MACSTR_LEN-1]='\0';
 629         ptr += 17+1;
 630
 631         WDP_LOGD( "mac=%s\n", peer->mac);
 632
 633         for(;;)
 634         {
 635                 ptr = __get_item_value(ptr, item, value);
 636                 if (ptr==NULL)
 637                         break;
 638
 639                 //printf("item=%s, value=%s\n", item,value);
 640
 641                 i=0;
 642                 item_id = WS_PEER_INFO_NONE;
 643                 while(g_ws_field_info[i].item_id != WS_PEER_INFO_NONE)
 644                 {
 645                         if (strcmp(g_ws_field_info[i].item_str, item)==0)
 646                         {
 647                                 item_id = g_ws_field_info[i].item_id;
 648                                 break;
 649                         }
 650                         i++;
 651                 }
 652
 653                 switch(item_id)
 654                 {
 655                 case WS_PEER_INFO_AGE:
 656                         peer->age = atoi(value);
 657                         break;
 658                 case WS_PEER_INFO_LISTEN_FREQ:
 659                         peer->listen_freq = atoi(value);
 660                         break;
 661                 case WS_PEER_INFO_LEVEL:
 662                         peer->level = atoi(value);
 663                         break;
 664                 case WS_PEER_INFO_WPS_METHOD:
 665                         strncpy(peer->wps_method, value, WPS_METHOD_LEN);
 666                         peer->wps_method[WPS_METHOD_LEN-1] = '\0';
 667                         break;
 668                 case WS_PEER_INFO_INTERFACE_ADDR:
 669                         strncpy(peer->interface_addr, value, MACSTR_LEN);
 670                         peer->interface_addr[MACSTR_LEN-1] = '\0';
 671                         break;
 672                 case WS_PEER_INFO_MEMBER_IN_GO_DEV:
 673                         strncpy(peer->member_in_go_dev, value, MACSTR_LEN);
 674                         peer->member_in_go_dev[MACSTR_LEN-1] = '\0';
 675                         break;
 676                 case WS_PEER_INFO_MEMBER_IN_GO_IFACE:
 677                         strncpy(peer->member_in_go_iface, value, MACSTR_LEN);
 678                         peer->member_in_go_iface[MACSTR_LEN-1] = '\0';
 679                         break;
 680                 case WS_PEER_INFO_PRI_DEV_TYPE:
 681                         strncpy(peer->pri_dev_type, value, DEVICE_TYPE_LEN);
 682                         peer->pri_dev_type[DEVICE_TYPE_LEN-1] = '\0';
 683                         break;
 684                 case WS_PEER_INFO_DEVICE_NAME:
 685                         strncpy(peer->device_name, value, DEVICE_NAME_LEN);
 686                         peer->device_name[DEVICE_NAME_LEN-1] = '\0';
 687                         break;
 688                 case WS_PEER_INFO_MANUFACTURER:
 689                         strncpy(peer->manufacturer, value, MANUFACTURER_LEN);
 690                         peer->manufacturer[MANUFACTURER_LEN-1] = '\0';
 691                         break;
 692                 case WS_PEER_INFO_MODEL_NAME:
 693                         strncpy(peer->model_name, value, MODEL_NAME_LEN);
 694                         peer->model_name[MODEL_NAME_LEN-1] = '\0';
 695                         break;
 696                 case WS_PEER_INFO_MODEL_NUMBER:
 697                         strncpy(peer->model_number, value, MODEL_NUMBER_LEN);
 698                         peer->model_number[MODEL_NUMBER_LEN-1] = '\0';
 699                         break;
 700                 case WS_PEER_INFO_SERIAL_NUMBER:
 701                         strncpy(peer->serial_number, value, SERIAL_NUMBER_LEN);
 702                         peer->serial_number[SERIAL_NUMBER_LEN-1] = '\0';
 703                         break;
 704                 case WS_PEER_INFO_CONFIG_METHODS:
 705                         {
 706                                 char* p = value;
 707                                 unsigned long int ret = 0;
 708                                 ret = strtoul(p, &p, 16);
 709                                 if (ret == ULONG_MAX)
 710                                 {
 711                                         peer->config_methods = 0;
 712                                         WDP_LOGE( "config_methods has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
 713                                 }
 714                                 else
 715                                 {
 716                                         peer->config_methods = (unsigned int)ret;
 717                                         WDP_LOGD( "config_methods value=[%x <- %s]\n", peer->config_methods, value);
 718                                 }
 719                         }
 720                         break;
 721                 case WS_PEER_INFO_DEV_CAPAB:
 722                         {
 723                                 char* p = value;
 724                                 unsigned long int ret = 0;
 725                                 ret = strtoul(p, &p, 16);
 726                                 if (ret == ULONG_MAX)
 727                                 {
 728                                         peer->dev_capab = 0;
 729                                         WDP_LOGE( "device_capab has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
 730                                 }
 731                                 else
 732                                 {
 733                                         peer->dev_capab = (unsigned int)ret;
 734                                         WDP_LOGD( "device_capab value=[%x <- %s]\n", peer->dev_capab, value);
 735                                 }
 736                         }
 737                         break;
 738                 case WS_PEER_INFO_GROUP_CAPAB:
 739                         {
 740                                 char* p = value;
 741                                 unsigned long int ret = 0;
 742                                 ret = strtoul(p, &p, 16);
 743                                 if (ret == ULONG_MAX)
 744                                 {
 745                                         peer->group_capab = 0;
 746                                         WDP_LOGE( "group_capab has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
 747                                 }
 748                                 else
 749                                 {
 750                                         peer->group_capab = (unsigned int)ret;
 751                                         WDP_LOGD( "group_capab value=[%x <- %s]\n", peer->group_capab, value);
 752                                 }
 753                         }
 754                         break;
 755                 case WS_PEER_INFO_GO_NEG_REQ_SENT:
 756                         peer->go_neg_req_sent = atoi(value);
 757                         break;
 758                 case WS_PEER_INFO_GO_STATE:
 759                         strncpy(peer->go_state, value, GO_STATE_LEN);
 760                         peer->go_state[GO_STATE_LEN-1] = '\0';
 761                         break;
 762                 case WS_PEER_INFO_DIALOG_TOKEN:
 763                         peer->dialog_token = atoi(value);
 764                         break;
 765                 case WS_PEER_INFO_INTENDED_ADDR:
 766                         strncpy(peer->intended_addr, value, MACSTR_LEN);
 767                         peer->intended_addr[MACSTR_LEN-1] = '\0';
 768                         break;
 769                 case WS_PEER_INFO_COUNTRY:
 770                         strncpy(peer->country, value, COUNTRY_CODE_LEN);
 771                         peer->country[COUNTRY_CODE_LEN-1] = '\0';
 772                         break;
 773                 case WS_PEER_INFO_OPER_FREQ:
 774                         peer->oper_freq = atoi(value);
 775                         break;
 776                 case WS_PEER_INFO_REQ_CONFIG_METHODS:
 777                         peer->req_config_methods = atoi(value);
 778                         break;
 779                 case WS_PEER_INFO_FLAGS:
 780                         strncpy(peer->flags, value, PEER_FLAGS_LEN);
 781                         peer->flags[PEER_FLAGS_LEN-1] = '\0';
 782                         break;
 783                 case WS_PEER_INFO_STATUS:
 784                         strncpy(peer->status, value, PEER_STATUS_LEN);
 785                         peer->status[PEER_STATUS_LEN-1] = '\0';
 786                         break;
 787                 case WS_PEER_INFO_WAIT_COUNT:
 788                         peer->wait_count = atoi(value);
 789                         break;
 790                 case WS_PEER_INFO_INVITATION_REQS:
 791                         peer->invitation_reqs = atoi(value);
 792                         break;
 793                 case WS_PEER_INFO_OPER_SSID:
 794                         strncpy(peer->oper_ssid, value, DEVICE_NAME_LEN);
 795                         peer->oper_ssid[DEVICE_NAME_LEN-1] = '\0';
 796                         break;
 797
 798 /*----- Miracast -----*/
 799                 case WS_PEER_INFO_IS_WFD_DEVICE:
 800                         peer->is_wfd_device = atoi(value);
 801                         break;
 802
 803                 default:
 804                         WDP_LOGD( "unknown field\n");
 805                         break;
 806                 }
 807         }
 808
 809         __WDP_LOG_FUNC_EXIT__;
 810         return 0;
 811 }
 812
 813
 814 int __parsing_persistent_group(char* buf, ws_network_info_s ws_persistent_group_list[], int* persistent_group_num)
 815 {
 816         __WDP_LOG_FUNC_ENTER__;
 817
 818         char* ptr = buf;
 819         ws_network_info_s group;
 820         int count;
 821
 822         memset(&group, 0, sizeof(ws_network_info_s));
 823
 824
 825         // Passing first line : "network id / ssid / bssid / flags"
 826         while (*ptr != '\n')
 827         {
 828                 ptr++;
 829         }
 830         ptr++;
 831
 832         count = 0;
 833         while(*ptr != '\0')
 834         {
 835                 ptr = __get_persistent_group_value(ptr, &group);
 836
 837                 ws_persistent_group_list[count].network_id = group.network_id;
 838                 strncpy(ws_persistent_group_list[count].ssid, group.ssid, sizeof(ws_persistent_group_list[count].ssid));
 839                 strncpy(ws_persistent_group_list[count].bssid, group.bssid, sizeof(ws_persistent_group_list[count].bssid));
 840                 strncpy(ws_persistent_group_list[count].flags, group.flags, sizeof(ws_persistent_group_list[count].flags));
 841                 count++;
 842         }
 843
 844         *persistent_group_num = count;
 845
 846         __WDP_LOG_FUNC_EXIT__;
 847         return 0;
 848
 849 }
 850
 851 void __parsing_ws_event(char* buf, ws_event_s *event)
 852 {
 853         __WDP_LOG_FUNC_ENTER__;
 854
 855         char* ptr = buf;
 856         char event_str[64];
 857         int i;
 858         ws_field_id_e event_id;
 859         int res = 0;
 860
 861         if (NULL == buf)
 862         {
 863                 WDP_LOGE( "ERROR : buf is NULL!!\n");
 864                 return;
 865         }
 866
 867         ptr = ptr +3;
 868         ptr = __get_event_str(ptr, event_str);
 869
 870         WDP_LOGD( "event str [%s]\n", event_str);
 871
 872         i=0;
 873         event_id = WS_EVENT_NONE;
 874         while(g_ws_event_info[i].id != WS_EVENT_NONE)
 875         {
 876                 if (strcmp(g_ws_event_info[i].str, event_str)==0)
 877                 {
 878                         event_id = g_ws_event_info[i].id;
 879                         break;
 880                 }
 881                 i++;
 882         }
 883
 884         switch(event_id)
 885         {
 886                 memset(event, 0, sizeof(ws_event_s));
 887
 888                 case WS_EVENT_DISCOVER_FOUND_PEER:
 889                         event->id = WS_EVENT_DISCOVER_FOUND_PEER;
 890                         WDP_LOGD( "WS EVENT : [WS_EVENT_DISCOVER_FOUND_PEER]\n");
 891                 break;
 892
 893                 case WS_EVENT_PROVISION_DISCOVERY_RESPONSE:
 894                         event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE;
 895                         ptr = __get_event_str(ptr, event_str);
 896                         strncpy(event->peer_mac_address, event_str, MACSTR_LEN);
 897                         event->peer_mac_address[MACSTR_LEN-1] = '\0';
 898                         WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE]\n");
 899                         WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 900                 break;
 901
 902                 case WS_EVENT_PROVISION_DISCOVERY_PBC_REQ:
 903                         event->id = WS_EVENT_PROVISION_DISCOVERY_PBC_REQ;
 904                         res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
 905                         if(res <= 0)
 906                         {
 907                                 WDP_LOGE( "Failed to extract p2p_dev_addr");
 908                                 // TO-DO: stop parsing and make event callback function stop
 909                                 __WDP_LOG_FUNC_EXIT__;
 910                                 return;
 911                         }
 912                         res = __extract_value_str(ptr, "name" , event->peer_ssid);
 913                         if(res <= 0)
 914                         {
 915                                 WDP_LOGE( "Failed to extract name(ssid)");
 916                                 // TO-DO: stop parsing and make event callback function stop
 917                                 __WDP_LOG_FUNC_EXIT__;
 918                                 return;
 919                         }
 920                         WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_PBC_REQ]\n");
 921                         WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 922                 break;
 923
 924                 case WS_EVENT_PROVISION_DISCOVERY_DISPLAY:
 925                         event->id = WS_EVENT_PROVISION_DISCOVERY_DISPLAY;
 926                         res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
 927                         if(res <= 0)
 928                         {
 929                                 WDP_LOGD( "Failed to extract p2p_dev_addr");
 930                                 WDP_LOGD( "Prov disc Response : DISPLAY");
 931                                 event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY;
 932                                 ptr = __get_event_str(ptr, event_str);
 933                                 strncpy(event->peer_mac_address, event_str, MACSTR_LEN);
 934                                 event->peer_mac_address[MACSTR_LEN-1] = '\0';
 935                                 WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY]\n");
 936                                 WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 937                                 ptr = __get_event_str(ptr, event_str);
 938                                 strncpy(event->wps_pin, event_str, WPS_PIN_LEN);
 939                                 event->wps_pin[WPS_PIN_LEN-1] = '\0';
 940                                 WDP_LOGD( "WS EVENT : [PIN : %s]\n", event_str);
 941                                 __WDP_LOG_FUNC_EXIT__;
 942                                 return;
 943                         }
 944                         ptr = __get_event_str(ptr, event_str); /* Stepping Mac Addr */
 945                         ptr = __get_event_str(ptr, event_str); /* Stepping PIN */
 946                         memset(event->wps_pin, 0x00, sizeof(event->wps_pin));
 947                         strncpy(event->wps_pin, event_str, WPS_PIN_LEN);
 948                         event->wps_pin[WPS_PIN_LEN-1] = '\0';
 949                         WDP_LOGD( "WS EVENT : [PIN : %s]\n", event_str);
 950
 951                         res = __extract_value_str(ptr, "name" , event->peer_ssid);
 952                         if(res <= 0)
 953                         {
 954                                 WDP_LOGE( "Failed to extract name(ssid)");
 955                                 __WDP_LOG_FUNC_EXIT__;
 956                                 return;
 957                         }
 958                         WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_DISPLAY]\n");
 959                         WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 960                 break;
 961
 962                 case WS_EVENT_PROVISION_DISCOVERY_KEYPAD:
 963                         event->id = WS_EVENT_PROVISION_DISCOVERY_KEYPAD;
 964                         res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
 965                         if(res <= 0)
 966                         {
 967                                 WDP_LOGD( "Failed to extract p2p_dev_addr");
 968                                 WDP_LOGD( "Prov disc Response : KEYPAD");
 969                                 event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD;
 970                                 ptr = __get_event_str(ptr, event_str);
 971                                 strncpy(event->peer_mac_address, event_str, MACSTR_LEN);
 972                                 event->peer_mac_address[MACSTR_LEN-1] = '\0';
 973                                 WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD]\n");
 974                                 WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 975                                 __WDP_LOG_FUNC_EXIT__;
 976                                 return;
 977                         }
 978                         res = __extract_value_str(ptr, "name" , event->peer_ssid);
 979                         if(res <= 0)
 980                         {
 981                                 WDP_LOGE( "Failed to extract name(ssid)");
 982                                 __WDP_LOG_FUNC_EXIT__;
 983                                 return;
 984                         }
 985                         WDP_LOGD( "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_KEYPAD]\n");
 986                         WDP_LOGD( "WS EVENT : [MAC : %s]\n", event_str);
 987                 break;
 988
 989                 case WS_EVENT_GROUP_FORMATION_SUCCESS:
 990                 case WS_EVENT_GROUP_FORMATION_FAILURE:
 991                         event->id = event_id;
 992                 break;
 993
 994                 case WS_EVENT_GROUP_STARTED:
 995                         event->id = WS_EVENT_GROUP_STARTED;
 996                         WDP_LOGD( "WS EVENT : [WS_EVENT_GROUP_STARTED]\n");
 997                         {
 998                                 int res = 0;
 999                                 char *dev_addr;
1000                                 dev_addr = (char*) calloc(1, 18);
1001                                 res = __extract_value_str(ptr, "dev_addr", dev_addr);
1002                                 if(res > 0)
1003                                         strcpy(event->peer_mac_address, dev_addr);
1004                                 free(dev_addr);
1005                                 WDP_LOGD( "connected peer mac address [%s]", event->peer_mac_address);
1006
1007                                 /* for checking persistent group */
1008                                 char *dummy;
1009                                 dummy = (char*) calloc(1, 18); /* dummy */
1010                                 res = __extract_value_str(ptr, "PERSISTENT", dummy);
1011                                 if(res >= 0)
1012                                 {
1013                                         WDP_LOGD( "[PERSISTENT GROUP]");
1014                                         event->id = WS_EVENT_PERSISTENT_GROUP_STARTED;
1015                                 }
1016                                 free(dummy);
1017                         }
1018                 break;
1019
1020                 case WS_EVENT_GROUP_REMOVED:
1021                         event->id = WS_EVENT_GROUP_REMOVED;
1022                         WDP_LOGD( "WS EVENT : [WS_EVENT_GROUP_REMOVED]\n");
1023                 break;
1024
1025                 case WS_EVENT_TERMINATING:
1026                         event->id = WS_EVENT_TERMINATING;
1027                         WDP_LOGD( "WS EVENT : [WS_EVENT_TERMINATING]\n");
1028                 break;
1029 #if 1
1030                 case WS_EVENT_CONNECTED:
1031                         {
1032                                 WDP_LOGD( "WS EVENT : [WS_EVENT_CONNECTED]\n");
1033                                 int res = 0;
1034                                 char *intf_addr;
1035                                 intf_addr = (char*) calloc(1, 18);
1036                                 event->id = WS_EVENT_CONNECTED;
1037                                 res = __extract_value_str(ptr, "to", intf_addr);
1038                                 if(res > 0)
1039                                         wfd_macaddr_atoe(intf_addr, g_assoc_sta_mac);
1040                                 WDP_LOGD( "connected peer interface mac address [%s]", intf_addr);
1041                                 free(intf_addr);
1042                         }
1043                 break;
1044 #endif
1045                 case WS_EVENT_STA_CONNECTED:
1046                         {
1047                                 WDP_LOGD( "WS EVENT : [WS_EVENT_STA_CONNECTED]\n");
1048                                 int res = 0;
1049                                 event->id = WS_EVENT_STA_CONNECTED;
1050
1051                                 ptr = __get_event_str(ptr, event_str);
1052                                 strncpy(event->peer_intf_mac_address, event_str, MACSTR_LEN);
1053                                 event->peer_intf_mac_address[MACSTR_LEN-1] = '\0';
1054
1055                                 res = __extract_value_str(ptr, "dev_addr", event->peer_mac_address);
1056                                 if (res < 0)
1057                                         WDP_LOGD("Key %s is not found", "dev_addr");
1058                                 else if (res == 0)
1059                                         WDP_LOGD("Empty value");
1060                                 else
1061                                         WDP_LOGD( "connected peer mac address [%s]", event->peer_intf_mac_address);
1062                         }
1063                 break;
1064
1065                 case WS_EVENT_DISCONNECTED:
1066                         {
1067                                 WDP_LOGD( "WS EVENT : [WS_EVENT_DISCONNECTED]\n");
1068                                 int res = 0;
1069                                 char *intf_addr;
1070                                 intf_addr = (char*) calloc(1, 18);
1071                                 event->id = WS_EVENT_DISCONNECTED;
1072                                 res = __extract_value_str(ptr, "to", intf_addr);
1073                                 if(res > 0) {
1074                                         strncpy(event->peer_mac_address, intf_addr, MACSTR_LEN);
1075                                         event->peer_mac_address[MACSTR_LEN-1] = '\0';
1076                                 }
1077                                 free(intf_addr);
1078                                 WDP_LOGD( "disconnected peer mac address [%s]", event->peer_mac_address);
1079                         }
1080                 break;
1081
1082                 case WS_EVENT_STA_DISCONNECTED:
1083                         {
1084                                 WDP_LOGD( "WS EVENT : [WS_EVENT_STA_DISCONNECTED]\n");
1085                                 int res = 0;
1086                                 event->id = WS_EVENT_STA_DISCONNECTED;
1087
1088                                 ptr = __get_event_str(ptr, event_str);
1089                                 strncpy(event->peer_intf_mac_address, event_str, MACSTR_LEN);
1090                                 event->peer_intf_mac_address[MACSTR_LEN-1] = '\0';
1091
1092                                 res = __extract_value_str(ptr, "dev_addr", event->peer_mac_address);
1093                                 if (res < 0)
1094                                         WDP_LOGD("Key %s is not found", "dev_addr");
1095                                 else if (res == 0)
1096                                         WDP_LOGD("Empty value");
1097                                 else
1098                                         WDP_LOGD( "disconnected peer mac address [%s]", event->peer_intf_mac_address);
1099                         }
1100                 break;
1101
1102                 case WS_EVENT_INVITATION_REQ:
1103                         {
1104                                 WDP_LOGD( "WS EVENT : [WS_EVENT_INVITATION_REQ]\n");
1105                                 int res = 0;
1106                                 event->id = WS_EVENT_INVITATION_REQ;
1107
1108 #if 1
1109                                 res = __extract_value_str(ptr, "go_dev_addr", event->peer_mac_address);
1110 #else
1111                                 res = __extract_value_str(ptr, "bssid", event->peer_mac_address);
1112 #endif
1113                                 if(res <= 0)
1114                                 {
1115                                         WDP_LOGE( "Failed to extract p2p_dev_addr");
1116                                         __WDP_LOG_FUNC_EXIT__;
1117                                         return;
1118                                 }
1119                                 WDP_LOGD( "WS EVENT : [GO MAC : %s]\n", event->peer_mac_address);
1120                         }
1121                 break;
1122
1123                 case WS_EVENT_INVITATION_RSP:
1124                         {
1125                                 WDP_LOGD( "WS EVENT : [WS_EVENT_INVITATION_RSP]\n");
1126                                 //int res = 0;
1127                                 event->id = WS_EVENT_INVITATION_RSP;
1128
1129 #if 0
1130                                 res = __extract_value_str(ptr, "status", );
1131                                 if(res <= 0)
1132                                 {
1133                                     WDP_LOGE( "Failed to extract p2p_dev_addr");
1134                                     return;
1135                                 }
1136                                 WDP_LOGD( "WS EVENT : [GO MAC : %s]\n", event->peer_mac_address);
1137 #endif
1138
1139                         }
1140                 break;
1141                 case WS_EVENT_GO_NEG_REQUEST:
1142                         {
1143                                 WDP_LOGD( "WS EVENT : [WS_EVENT_GO_NEG_REQUEST]");
1144
1145                                 event->id = WS_EVENT_GO_NEG_REQUEST;
1146                                 ptr = __get_event_str(ptr + 19, event_str);
1147                                 strncpy(event->peer_intf_mac_address, event_str, MACSTR_LEN);
1148                                 event->peer_intf_mac_address[MACSTR_LEN-1] = '\0';
1149                         }
1150                 break;
1151
1152                 case WS_EVENT_WPS_FAIL:
1153                         {
1154                                 WDP_LOGD("WS EVENT : [WS_EVENT_WPS_FAIL]");
1155                                 char config_error[4] = {0, };
1156                                 event->id = WS_EVENT_WPS_FAIL;
1157                                 ptr = __extract_value_str(ptr, "config_error", config_error);
1158                                 event->msg = atoi(config_error);
1159                         }
1160                 break;
1161
1162                 default:
1163                         WDP_LOGE( "ERROR : unknown event !!\n");
1164                 break;
1165         }
1166
1167         __WDP_LOG_FUNC_EXIT__;
1168
1169         return;
1170
1171 }
1172
1173 int __store_persistent_peer(int network_id, char* persistent_group_ssid, char* peer_mac_address)
1174 {
1175         __WDP_LOG_FUNC_ENTER__;
1176
1177         char buf[100] = "";
1178         FILE *fp = NULL;
1179
1180         snprintf(buf, sizeof(buf), "%d %s %s\n",network_id, persistent_group_ssid, peer_mac_address);
1181
1182         fp = fopen(PERSISTENT_PEER_PATH, "a");
1183         if (NULL == fp)
1184         {
1185                 WDP_LOGE( "ERROR : file open failed!! [persistent-peer]\n");
1186                 return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
1187         }
1188
1189         //fseek(fp, 0, SEEK_END);
1190         fputs(buf, fp);
1191         fclose(fp);
1192
1193         __WDP_LOG_FUNC_EXIT__;
1194         return true;
1195
1196 }
1197
1198 int __get_network_id_from_network_list_with_ssid(char* persistent_group_ssid)
1199 {
1200         __WDP_LOG_FUNC_ENTER__;
1201
1202         int persistent_group_count = 0;
1203         int i;
1204         int result;
1205         wfd_persistent_group_info_s* plist;
1206
1207         WDP_LOGD( "search with persistent_group_ssid = [%s]\n",persistent_group_ssid);
1208
1209         result = wfd_ws_get_persistent_group_info(&plist, &persistent_group_count);
1210         if (result == true)
1211         {
1212                 if (persistent_group_count > 0)
1213                 {
1214                         for(i=0; i<persistent_group_count; i++)
1215                         {
1216                                 WDP_LOGD( "plist[%d].ssid=[%s]\n", i,plist[i].ssid);
1217                                 if (strcmp(plist[i].ssid, persistent_group_ssid) == 0)
1218                                 {
1219                                         WDP_LOGD( "Found peer in persistent group list [network id : %d]\n", plist[i].network_id);
1220                                         return plist[i].network_id;
1221                                 }
1222                         }
1223                         WDP_LOGE( "There is no Persistent Group has ssid[%s]\n", persistent_group_ssid);
1224                         __WDP_LOG_FUNC_EXIT__;
1225                         return -1;
1226                 }
1227                 else
1228                 {
1229                         WDP_LOGE( "have no Persistent Group!!\n");
1230                         __WDP_LOG_FUNC_EXIT__;
1231                         return -1;
1232                 }
1233         }
1234         else
1235         {
1236                 WDP_LOGE( "Error!! wfd_ws_get_persistent_group_info() failed..\n");
1237                 __WDP_LOG_FUNC_EXIT__;
1238                 return -1;
1239         }
1240 }
1241
1242 int __get_network_id_from_network_list_with_go_mac(char* go_mac_address)
1243 {
1244         __WDP_LOG_FUNC_ENTER__;
1245
1246         int persistent_group_count = 0;
1247         int i;
1248         int result;
1249         wfd_persistent_group_info_s* plist;
1250         char mac_str[18] = {0, };
1251
1252         WDP_LOGD( "search with persistent_group go_mac_address = [%s]\n",go_mac_address);
1253
1254         result = wfd_ws_get_persistent_group_info(&plist, &persistent_group_count);
1255         if (result == true)
1256         {
1257                 if (persistent_group_count > 0)
1258                 {
1259                         for(i=0; i<persistent_group_count; i++)
1260                         {
1261                                 snprintf(mac_str, 18, MACSTR, MAC2STR(plist[i].go_mac_address));
1262                                 WDP_LOGD( "plist[%d].go_mac_address=[%s]\n", i,mac_str);
1263                                 if (strcmp(mac_str, go_mac_address) == 0)
1264                                 {
1265                                         WDP_LOGD( "Found peer in persistent group list [network id : %d]\n", plist[i].network_id);
1266                                         return plist[i].network_id;
1267                                 }
1268                         }
1269                         WDP_LOGE( "There is no Persistent Group has go mac[%s]\n", go_mac_address);
1270                         __WDP_LOG_FUNC_EXIT__;
1271                         return -1;
1272                 }
1273                 else
1274                 {
1275                         WDP_LOGE( "have no Persistent Group!!\n");
1276                         __WDP_LOG_FUNC_EXIT__;
1277                         return -1;
1278                 }
1279         }
1280         else
1281         {
1282                 WDP_LOGE( "Error!! wfd_ws_get_persistent_group_info() failed..\n");
1283                 __WDP_LOG_FUNC_EXIT__;
1284                 return -1;
1285         }
1286 }
1287
1288
1289 int __get_network_id_from_persistent_client_list_with_mac(char* peer_mac_address)
1290 {
1291         __WDP_LOG_FUNC_ENTER__;
1292
1293         FILE *fp = NULL;
1294         char buf[100] = "";
1295         int n = 0;
1296         int network_id;
1297         char stored_ssid[64] = "";
1298         char stored_peer_mac[18] = "";
1299
1300         fp = fopen(PERSISTENT_PEER_PATH, "r");
1301         if (NULL == fp)
1302         {
1303                 WDP_LOGE( "ERROR : file open failed!! [persistent-peer]\n");
1304                 return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
1305         }
1306
1307         while(fgets(buf, 100, fp) != NULL)
1308         {
1309                 n = sscanf(buf,"%d %s %s", &network_id, stored_ssid, stored_peer_mac);
1310                 WDP_LOGD( "network_id=[%d], ssid=[%s], peer_mac=[%s]\n",network_id, stored_ssid, stored_peer_mac);
1311
1312                 if (strcmp(stored_peer_mac, peer_mac_address) == 0)
1313                 {
1314                         return network_id;
1315                 }
1316         }
1317         fclose(fp);
1318
1319         WDP_LOGD( "Can not find peer mac in persistent peer list\n");
1320
1321         __WDP_LOG_FUNC_EXIT__;
1322         return -1;
1323
1324 }
1325
1326 bool __is_already_stored_persistent_client(int network_id, char* peer_mac_address)
1327 {
1328         __WDP_LOG_FUNC_ENTER__;
1329
1330         FILE *fp = NULL;
1331         char buf[100] = "";
1332         int n = 0;
1333         int stored_network_id;
1334         char stored_ssid[64] = "";
1335         char stored_peer_mac[18] = "";
1336
1337         fp = fopen(PERSISTENT_PEER_PATH, "r");
1338         if (NULL == fp)
1339         {
1340                 WDP_LOGE( "ERROR : file open failed!! [persistent-peer]\n");
1341                 return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
1342         }
1343
1344         while(fgets(buf, 100, fp) != NULL)
1345         {
1346                 n = sscanf(buf,"%d %s %s", &stored_network_id, stored_ssid, stored_peer_mac);
1347                 WDP_LOGD( "stored_network_id=[%d], stored_ssid=[%s], stored_peer_mac=[%s]\n",stored_network_id, stored_ssid, stored_peer_mac);
1348
1349                 if ((strcmp(stored_peer_mac, peer_mac_address) == 0)
1350                         && (stored_network_id == network_id))
1351                 {
1352                         WDP_LOGD( "found peer in persistent peer list\n");
1353                         __WDP_LOG_FUNC_EXIT__;
1354                         return true;
1355                 }
1356         }
1357         fclose(fp);
1358
1359         WDP_LOGD( "Can not find peer in persistent peer list\n");
1360         __WDP_LOG_FUNC_EXIT__;
1361         return false;
1362
1363 }
1364
1365 int __get_persistent_group_clients(void)
1366 {
1367         __WDP_LOG_FUNC_ENTER__;
1368
1369         FILE *fp = NULL;
1370         char buf[100] = "";
1371         int n = 0;
1372         int network_id;
1373         char ssid[64] = "";
1374         char peer_mac[18] = "";
1375
1376         fp = fopen(PERSISTENT_PEER_PATH, "r");
1377         if (NULL == fp)
1378         {
1379                 WDP_LOGE( "ERROR : file open failed!! [persistent-peer]\n");
1380                 return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
1381         }
1382
1383         while(fgets(buf, 100, fp) != NULL)
1384         {
1385                 n = sscanf(buf,"%d %s %s", &network_id, ssid, peer_mac);
1386                 WDP_LOGD( "network_id=[%d], ssid=[%s], peer_mac=[%s]\n",network_id, ssid, peer_mac);
1387         }
1388         fclose(fp);
1389
1390         __WDP_LOG_FUNC_EXIT__;
1391         return true;
1392
1393 }
1394
1395 int __send_invite_request_with_network_id(int network_id, unsigned char dev_mac_addr[6])
1396 {
1397         __WDP_LOG_FUNC_ENTER__;
1398
1399         char cmd[128] = {0, };
1400         char mac_str[18] = {0, };
1401         char res_buffer[1024]={0,};
1402         int res_buffer_len = sizeof(res_buffer);
1403         int result;
1404
1405         snprintf(mac_str, 18, MACSTR, MAC2STR(dev_mac_addr));
1406         snprintf(cmd, sizeof(cmd), "%s persistent=%d peer=%s", CMD_SEND_INVITE_REQ, network_id, mac_str);
1407
1408         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
1409         WDP_LOGD( "__send_wpa_request(p2p_invite persistent=%d peer=%s) result=[%d]\n", network_id, mac_str, result);
1410
1411         if (result < 0)
1412         {
1413                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
1414                 __WDP_LOG_FUNC_EXIT__;
1415                 return false;
1416         }
1417
1418         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
1419         {
1420                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
1421                 __WDP_LOG_FUNC_EXIT__;
1422                 return false;
1423         }
1424
1425         WDP_LOGD( "Invite... peer-MAC [%s]\n", mac_str);
1426
1427         __WDP_LOG_FUNC_EXIT__;
1428         return true;
1429 }
1430
1431 int glist_compare_peer_mac_cb(const void* data1, const void* data2)
1432 {
1433         char *mac_str1 = (char*) data1;
1434         char *mac_str2 = (char*) data2;
1435         int r = 0;
1436
1437         if (data1==NULL || data2==NULL)
1438         {
1439                 WDP_LOGE( "Error!! data is NULL\n");
1440                 return -1;
1441         }
1442
1443         r = strcmp(mac_str1, mac_str2);
1444         if (r==0)
1445                 return 0;
1446         else
1447                 return 1;
1448 }
1449
1450 void glist_print_connected_peer_cb(gpointer data, gpointer user_data)
1451 {
1452         char *mac_str = (char*) data;
1453         int count = *(int*)user_data;
1454         WDP_LOGD( "Connected peer[%d] mac=[%s]\n", count, mac_str);
1455         *(int*)user_data = count+1;
1456 }
1457
1458 void wfd_ws_print_connected_peer()
1459 {
1460         WDP_LOGD( "Connected Peer Table\n");
1461         int count = 0;
1462         g_list_foreach(g_conn_peer_addr, glist_print_connected_peer_cb, &count);
1463         WDP_LOGD( "Count=%d\n", count);
1464 }
1465
1466 void wfd_ws_glist_reset_connected_peer()
1467 {
1468         if(g_conn_peer_addr)
1469         {
1470                 GList *element = NULL;
1471
1472                 element = g_list_first(g_conn_peer_addr);
1473                 while(element)
1474                 {
1475                         if(element->data)
1476                                 free((char*) element->data);
1477                         element = g_list_next(element);
1478                 }
1479                 g_list_free(g_conn_peer_addr);
1480                 g_conn_peer_addr = NULL;
1481         }
1482 }
1483
1484
1485 static gboolean __ws_event_callback(GIOChannel * source,
1486                                                                                    GIOCondition condition,
1487                                                                                    gpointer data)
1488 {
1489         __WDP_LOG_FUNC_ENTER__;
1490
1491         int sockfd = g_monitor_sockfd;
1492         char buffer[4096] = {0, };
1493         int n = 0;
1494         ws_event_s event = {0,};
1495
1496         // Read socket
1497         if ( (n = __read_socket_cb(sockfd, buffer, sizeof(buffer))) < 0)
1498         {
1499                 WDP_LOGE( "Error!!! Reading Async Event[%d]\n", sockfd);
1500                 __WDP_LOG_FUNC_EXIT__;
1501                 return false;
1502         }
1503
1504         WDP_LOGD( "Received Event:[%d, %s]\n", n, buffer);
1505
1506         __parsing_ws_event(buffer, &event);
1507
1508         WDP_LOGD( "EVENT ID = %d\n", event.id);
1509
1510         switch (event.id)
1511         {
1512                 case WS_EVENT_DISCOVER_FOUND_PEER:
1513                         g_noti_cb(WFD_EVENT_DISCOVER_FOUND_PEERS);
1514                 break;
1515
1516                 case WS_EVENT_PROVISION_DISCOVERY_RESPONSE:
1517                 {
1518                         unsigned char la_mac_addr[6];
1519                         wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1520
1521                         wfd_server_control_t * wfd_server = wfd_server_get_control();
1522
1523                         WDP_LOGD( "wfd_server->current_peer.is_group_owner=[%d]\n", wfd_server->current_peer.is_group_owner);
1524                         if (wfd_server->current_peer.is_group_owner == FALSE)
1525                                 wfd_ws_connect(la_mac_addr, WIFI_DIRECT_WPS_TYPE_PBC);
1526                 }
1527                 break;
1528
1529                 case WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY:
1530                 {
1531                         if (g_wps_event_block)
1532                                 break;
1533
1534                         g_wps_event_block = 1;
1535                         unsigned char la_mac_addr[6];
1536                         wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1537                         memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
1538                         memcpy(g_incomming_peer_mac_address, la_mac_addr, 6);
1539                         memset(g_wps_pin, 0x00, sizeof(g_wps_pin));
1540                         memcpy(&g_wps_pin, event.wps_pin, 8);
1541                         WDP_LOGD( "MAC ADDR = " MACSTR "(a)\tPIN = %s\n", MAC2STR(g_incomming_peer_mac_address), g_wps_pin);
1542                         g_noti_cb(WFD_EVENT_PROV_DISCOVERY_RESPONSE_WPS_DISPLAY);
1543                 }
1544                 break;
1545
1546                 case WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD:
1547                 {
1548                         if (g_wps_event_block)
1549                                 break;
1550
1551                         g_wps_event_block = 1;
1552                         unsigned char la_mac_addr[6];
1553                         wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1554                         memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
1555                         memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
1556                         g_noti_cb(WFD_EVENT_PROV_DISCOVERY_RESPONSE_WPS_KEYPAD);
1557                 }
1558                 break;
1559
1560
1561                 case WS_EVENT_PROVISION_DISCOVERY_PBC_REQ:
1562                 case WS_EVENT_PROVISION_DISCOVERY_DISPLAY:
1563                 case WS_EVENT_PROVISION_DISCOVERY_KEYPAD:
1564                 {
1565                         if (g_wps_event_block)
1566                                 break;
1567
1568                         g_wps_event_block = 1;
1569                         WDP_LOGD("Incomming PROV_DISC [%d]", event.id);
1570                         unsigned char la_mac_addr[6];
1571                         wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1572                         memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
1573                         memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
1574                         memset(g_incomming_peer_ssid, 0, sizeof(g_incomming_peer_ssid));
1575                         strncpy(g_incomming_peer_ssid, event.peer_ssid, sizeof(g_incomming_peer_ssid));
1576
1577                         WDP_LOGD( "NEW PIN RECEIVED = %s\n", event.wps_pin);
1578                         memset(g_wps_pin, 0x00, sizeof(g_wps_pin));
1579                         strncpy(g_wps_pin, event.wps_pin, WPS_PIN_LEN);
1580
1581                         WDP_LOGD( "Prov Req:  mac[" MACSTR"] ssid=[%s]\n",
1582                                 MAC2STR(g_incomming_peer_mac_address), g_incomming_peer_ssid);
1583
1584                         if (WS_EVENT_PROVISION_DISCOVERY_DISPLAY == event.id)
1585                                 g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY);
1586                         else if (WS_EVENT_PROVISION_DISCOVERY_KEYPAD == event.id)
1587                                 g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD);
1588                         else
1589                                 g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST);
1590                 }
1591                 break;
1592
1593                 case WS_EVENT_GROUP_FORMATION_SUCCESS:
1594                 case WS_EVENT_GROUP_FORMATION_FAILURE:
1595                         g_wps_event_block = 0;
1596                 break;
1597
1598                 case WS_EVENT_GROUP_STARTED:
1599                 {
1600                         g_wps_event_block = 0;
1601
1602                         if(wfd_ws_is_groupowner())
1603                         {
1604                                 WDP_LOGD(" CHECK : It's AP... \n");
1605                                 system("/usr/bin/wifi-direct-dhcp.sh server");
1606                                 __polling_ip(g_local_interface_ip_address, 20, FALSE);
1607                                 WDP_LOGE( "*** IP : %s\n", g_local_interface_ip_address);
1608
1609                                 g_noti_cb(WFD_EVENT_SOFTAP_READY);
1610                         }
1611                         else
1612                         {
1613                                 wfd_ws_glist_reset_connected_peer();
1614
1615                                 g_conn_peer_addr = g_list_append(g_conn_peer_addr, strdup(event.peer_mac_address));
1616                                 WDP_LOGD( "connected peer[%s] is added\n", event.peer_mac_address);
1617
1618                                 g_noti_cb(WFD_EVENT_CREATE_LINK_COMPLETE);
1619                         }
1620                 }
1621                 break;
1622
1623                 case WS_EVENT_PERSISTENT_GROUP_STARTED:
1624                 {
1625                         if(wfd_ws_is_groupowner())
1626                         {
1627                                 WDP_LOGD(" CHECK : It's AP... \n");
1628                                 system("/usr/bin/wifi-direct-dhcp.sh server");
1629                                 __polling_ip(g_local_interface_ip_address, 20, FALSE);
1630                                 WDP_LOGE( "*** IP : %s\n", g_local_interface_ip_address);
1631
1632                                 g_noti_cb(WFD_EVENT_SOFTAP_READY);
1633                         }
1634                         else
1635                         {
1636                                 wfd_ws_glist_reset_connected_peer();
1637
1638                                 g_conn_peer_addr = g_list_append(g_conn_peer_addr, strdup(event.peer_mac_address));
1639                                 WDP_LOGD( "connected peer[%s] is added\n", event.peer_mac_address);
1640
1641                                 /* We need to store current peer
1642                                 because, persistent joining is excuted silencely without client event.*/
1643                                 unsigned char la_mac_addr[6];
1644                                 wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1645                                 wfd_server_remember_connecting_peer(la_mac_addr);
1646                                 wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTING);
1647
1648                                 g_noti_cb(WFD_EVENT_CREATE_LINK_COMPLETE);
1649                         }
1650                 }
1651                 break;
1652
1653                 case WS_EVENT_GROUP_REMOVED:
1654                 {
1655                         system("/usr/bin/wifi-direct-dhcp.sh stop");
1656                         g_noti_cb(WFD_EVENT_CREATE_LINK_CANCEL);
1657                         g_noti_cb(WFD_EVENT_CREATE_LINK_DOWN);
1658                         g_noti_cb(WFD_EVENT_SOFTAP_STOP);
1659
1660                         wfd_ws_glist_reset_connected_peer();
1661 #if 0
1662                         wfd_ws_flush();
1663 #endif
1664                 }
1665                 break;
1666
1667                 case WS_EVENT_TERMINATING:
1668                         system("/usr/bin/wlan.sh stop");
1669                         system("/usr/sbin/p2p_supp.sh stop");
1670                         WDP_LOGE( "Device is Deactivated\n");
1671                 break;
1672
1673                 case WS_EVENT_CONNECTED:
1674                         {
1675                                 // Nothing
1676                         }
1677                 break;
1678
1679                 case WS_EVENT_DISCONNECTED:
1680                         {
1681                                 GList *element = NULL;
1682                                 element = g_list_find(g_conn_peer_addr, event.peer_mac_address);
1683                                 if(element != NULL)
1684                                 {
1685                                         g_conn_peer_addr = g_list_remove(g_conn_peer_addr, event.peer_mac_address);
1686                                         WDP_LOGD( "disconnected peer[%s] is removed\n", event.peer_mac_address);
1687                                         free((char*) element->data);
1688                                 }
1689                         }
1690                 break;
1691
1692                 case WS_EVENT_STA_CONNECTED:
1693                         {
1694                                 g_wps_event_block = 0;
1695                                 GList *element = NULL;
1696                                 element = g_list_find_custom(g_conn_peer_addr, event.peer_mac_address, glist_compare_peer_mac_cb);
1697                                 if(element  == NULL)
1698                                 {
1699                                         g_conn_peer_addr = g_list_append(g_conn_peer_addr, strdup(event.peer_mac_address));
1700                                         WDP_LOGD( "connected peer[%s] is added\n", event.peer_mac_address);
1701                                 }
1702
1703                                 wfd_ws_print_connected_peer();
1704
1705                                 wfd_macaddr_atoe(event.peer_intf_mac_address, g_assoc_sta_mac);
1706
1707                                 wfd_server_control_t * wfd_server = wfd_server_get_control();
1708                                 if (wfd_server->config_data.want_persistent_group == true)
1709                                 {
1710                                         char g_persistent_group_ssid[64];
1711                                         int network_id;
1712                                         int result;
1713
1714                                         memset(g_persistent_group_ssid, 0, sizeof(g_persistent_group_ssid));
1715                                         wfd_ws_get_ssid(g_persistent_group_ssid, 64);
1716
1717                                         /* find network id with ssid */
1718                                         network_id = __get_network_id_from_network_list_with_ssid(g_persistent_group_ssid);
1719                                         if (network_id < 0)     /* NOT Persistent group */
1720                                         {
1721                                                 WDP_LOGD( "__get_network_id_from_network_list_with_ssid FAIL!![%d]\n", network_id);
1722                                                 WDP_LOGD( "[NOT Persistent Group]\n");
1723                                         }
1724                                         else    /* Persistent group */
1725                                         {
1726                                                 /* checking peer list whether the peer is already stored or not */
1727                                                 if (__is_already_stored_persistent_client(network_id, event.peer_mac_address) == false)
1728                                                 {
1729                                                         /* storing new persistent group client*/
1730                                                         result = __store_persistent_peer(network_id, g_persistent_group_ssid, event.peer_mac_address);
1731                                                         if (result != true)
1732                                                                 WDP_LOGD( "__store_persistent_peer FAIL!![%d]\n", result);
1733                                                 }
1734
1735                                                 /* We need to store current peer
1736                                                 because, persistent joining is excuted silencely without client event.*/
1737                                                 unsigned char la_mac_addr[6];
1738                                                 wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1739                                                 wfd_server_remember_connecting_peer(la_mac_addr);
1740                                                 wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTING);
1741                                         }
1742                                 }
1743
1744                                 g_noti_cb(WFD_EVENT_CREATE_LINK_COMPLETE);
1745                         }
1746                         break;
1747                 case WS_EVENT_STA_DISCONNECTED:
1748                         {
1749                                 GList *element = NULL;
1750
1751                                 wfd_ws_print_connected_peer();
1752
1753                                 element = g_list_find_custom(g_conn_peer_addr, event.peer_mac_address, glist_compare_peer_mac_cb);
1754                                 if(element != NULL)
1755                                 {
1756                                         g_conn_peer_addr = g_list_remove(g_conn_peer_addr, element->data);
1757                                         WDP_LOGD( "disconnected peer[%s] is removed\n", event.peer_mac_address);
1758                                         wfd_ws_print_connected_peer();
1759                                 }
1760                                 else
1761                                 {
1762                                         WDP_LOGD( "Something wrong.. disconnected peer[%s] is not in Table\n", event.peer_mac_address);
1763                                 }
1764                                 wfd_macaddr_atoe(event.peer_intf_mac_address, g_disassoc_sta_mac);
1765                                 g_noti_cb(WFD_EVENT_SOFTAP_STA_DISASSOC);
1766                         }
1767                         break;
1768
1769                 case WS_EVENT_INVITATION_REQ:
1770                 {
1771                         unsigned char la_mac_addr[6];
1772                         wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
1773                         memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
1774                         WDP_LOGD( "INVITATION REQ. RECEIVED:  mac[" MACSTR"]\n", MAC2STR(g_incomming_peer_mac_address));
1775                         wfd_ws_start_discovery(false, 0);
1776
1777                         g_noti_cb(WFD_EVENT_INVITE_REQUEST);
1778                 }
1779                 break;
1780
1781                 case WS_EVENT_INVITATION_RSP:
1782                         {
1783                         }
1784                 break;
1785
1786                 case WS_EVENT_WPS_FAIL:
1787                         {
1788                                 if (event.msg == WPS_ERROR_PASSWORD_MISMATCH) {
1789                                         WDP_LOGD("WPS_ERROR_PASSWORD_MISMATCH");
1790                                         g_noti_cb(WFD_EVENT_CREATE_LINK_AUTH_FAIL);
1791                                 }
1792                         }
1793                 break;
1794
1795                 default:
1796                 break;
1797
1798         }
1799
1800         __WDP_LOG_FUNC_EXIT__;
1801
1802         return true;
1803 }
1804
1805 int __convert_category_from_type(char *pri_dev_type)
1806 {
1807         __WDP_LOG_FUNC_ENTER__;
1808         char *saveptr = NULL;
1809         char *token = NULL;
1810
1811         if(pri_dev_type == NULL)
1812         {
1813                 WDP_LOGE( "Incorrect parameter\n");
1814                 return -1;
1815         }
1816
1817         token = strtok_r(pri_dev_type, "-", &saveptr);
1818         if(token == NULL)
1819         {
1820                 WDP_LOGD( "Extracting failed\n");
1821                 return -1;
1822         }
1823
1824         if(!strcmp(token, "255"))
1825                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_OTHER;
1826         else if(!strcmp(token, "11"))
1827                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_AUDIO;
1828         else if(!strcmp(token, "10"))
1829                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE;
1830         else if(!strcmp(token, "9"))
1831                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_GAME_DEVICE;
1832         else if(!strcmp(token, "8"))
1833                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_MULTIMEDIA_DEVICE;
1834         else if(!strcmp(token, "7"))
1835                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_DISPLAY;
1836         else if(!strcmp(token, "6"))
1837                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_NETWORK_INFRA;
1838         else if(!strcmp(token, "5"))
1839                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_STORAGE;
1840         else if(!strcmp(token, "4"))
1841                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_CAMERA;
1842         else if(!strcmp(token, "3"))
1843                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_PRINTER;
1844         else if(!strcmp(token, "2"))
1845                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_INPUT_DEVICE;
1846         else if(!strcmp(token, "1"))
1847                 return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_COMPUTER;
1848         else
1849         {
1850                 WDP_LOGD( "Unknown device type [%s]\n", token);
1851                 return -1;
1852         }
1853         __WDP_LOG_FUNC_EXIT__;
1854         return -1;
1855 }
1856
1857
1858 int __wpa_ctrl_attach(int sockfd)
1859 {
1860         __WDP_LOG_FUNC_ENTER__;
1861
1862         char cmd[8] = {0};
1863         char res_buffer[1024]={0,};
1864         int res_buffer_len=sizeof(res_buffer);
1865         int result= 0;
1866
1867         strncpy(cmd, CMD_ATTACH, sizeof(cmd));
1868         result = __send_wpa_request(sockfd, cmd, (char*)res_buffer,  res_buffer_len);
1869         WDP_LOGE( "__send_wpa_request(ATTACH) result=[%d]\n", result);
1870
1871         if (result < 0)
1872                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
1873
1874         __WDP_LOG_FUNC_EXIT__;
1875
1876         return result;
1877 }
1878
1879
1880
1881
1882 static char*
1883 __convert_wps_config_methods_value(wifi_direct_wps_type_e wps_config_methods)
1884 {
1885         __WDP_LOG_FUNC_ENTER__;
1886
1887         WDP_LOGD("wps_config_methods [%d]\n", wps_config_methods);
1888
1889         switch(wps_config_methods)
1890         {
1891                 case WIFI_DIRECT_WPS_TYPE_PBC:
1892                 {
1893                         __WDP_LOG_FUNC_EXIT__;
1894                         return "pbc";
1895                 }
1896                 break;
1897
1898                 case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
1899                 {
1900                         __WDP_LOG_FUNC_EXIT__;
1901                         return "display";
1902                 }
1903                 break;
1904
1905                 case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
1906                 {
1907                         __WDP_LOG_FUNC_EXIT__;
1908                         return "keypad";
1909                 }
1910                 break;
1911
1912                 default :
1913                 {
1914                         WDP_LOGD("Invalid input parameter!\n");
1915                         __WDP_LOG_FUNC_EXIT__;
1916                         return "";
1917                 }
1918                 break;
1919
1920         }
1921 }
1922
1923 static unsigned int
1924 __convert_device_type(char *ptr)
1925 {
1926         __WDP_LOG_FUNC_ENTER__;
1927
1928         char* p = ptr;
1929         int c = 0;
1930         char category_type[3] = {0,};
1931
1932         if (p==NULL)
1933         {
1934                 WDP_LOGE( "ERROR : ptr is NULL!!\n");
1935                 return 0;
1936         }
1937
1938         c = 0;
1939         while(*p != '-')   // take the first number before the first '-' (e.g. 1-0050F204-5)
1940         {
1941                 category_type[c++] = *p++;
1942         }
1943         category_type[c]='\0';
1944
1945         WDP_LOGD("category=[%d]\n", atoi(category_type));
1946
1947         __WDP_LOG_FUNC_EXIT__;
1948
1949         return atoi(category_type);
1950 }
1951
1952 static unsigned int
1953 __convert_secondary_device_type(char *ptr)
1954 {
1955         __WDP_LOG_FUNC_ENTER__;
1956
1957         char* p = NULL;
1958         int c = 0;
1959         char category_type[3] = {0,};
1960
1961         if (ptr==NULL)
1962         {
1963                 WDP_LOGE( "ERROR : ptr is NULL!!\n");
1964                 return 0;
1965         }
1966
1967         p = strstr(ptr, WIFI_ALLIANCE_OUI);
1968         if (p==NULL)
1969         {
1970                 WDP_LOGE( "ERROR : Unknown OUI, It's vendor specific device type..\n");
1971                 return 0;
1972         }
1973         p += strlen(WIFI_ALLIANCE_OUI); // // skip OUI (e.g. 1-0050F204-5)
1974         p ++;   // skip the second '-' (e.g. 1-0050F204-5)
1975
1976         c = 0;
1977         while(*p != '\0')
1978         {
1979                 category_type[c++] = *p++;
1980         }
1981         category_type[c]='\0';
1982
1983         WDP_LOGD("sub-category [%d]\n", atoi(category_type));
1984
1985         __WDP_LOG_FUNC_EXIT__;
1986
1987         return atoi(category_type);
1988 }
1989
1990
1991 int __convert_freq_to_channel(char *freq_kHz)
1992 {
1993         __WDP_LOG_FUNC_ENTER__;
1994         int i = 0;
1995         int channel = 0;
1996
1997         while(g_ws_op_channel_info[i].channel != 0)
1998         {
1999                 if (strcmp(g_ws_op_channel_info[i].freq, freq_kHz)==0)
2000                 {
2001                         channel = g_ws_op_channel_info[i].channel;
2002                         break;
2003                 }
2004                 i++;
2005         }
2006
2007         __WDP_LOG_FUNC_EXIT__;
2008         return channel;
2009 }
2010
2011
2012 #if 1  // Threadsafe event handling.
2013
2014 void __wfd_oem_callback(wfd_event_t event)
2015 {
2016         // write header parts
2017         write(g_oem_pipe[1], &event, sizeof(event));
2018 }
2019
2020 #else
2021
2022 void __wfd_oem_callback(wfd_event_t event_type)
2023 {
2024         if (g_oem_event_callback != NULL)
2025                 g_oem_event_callback(event_type);
2026 }
2027
2028 #endif
2029
2030 int __wfd_ws_reinvoke_persistent_group(int network_id)
2031 {
2032         __WDP_LOG_FUNC_ENTER__;
2033
2034         char cmd[64] = {0, };
2035         char res_buffer[1024]={0,};
2036         int res_buffer_len = sizeof(res_buffer);
2037         int result;
2038
2039         /* Persistent group mode */
2040         snprintf(cmd, sizeof(cmd), "%s %s%d", CMD_CREATE_GROUP, "persistent=", network_id);
2041
2042         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2043         WDP_LOGD( "__send_wpa_request(P2P_GROUP_ADD persistent=%d) result=[%d]\n", network_id, result);
2044
2045         if (result < 0)
2046         {
2047                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2048                 __WDP_LOG_FUNC_EXIT__;
2049                 return false;
2050         }
2051
2052         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2053         {
2054                 __WDP_LOG_FUNC_EXIT__;
2055                 return false;
2056         }
2057
2058         WDP_LOGD( "Create p2p persistent group... \n");
2059
2060         __WDP_LOG_FUNC_EXIT__;
2061         return true;
2062 }
2063
2064 int wfd_ws_init(wfd_oem_event_cb event_callback)
2065 {
2066         __WDP_LOG_FUNC_ENTER__;
2067
2068 #if 1  // Threadsafe event handling
2069         if (pipe(g_oem_pipe) < 0) {
2070                 WDP_LOGD( "pipe error : Error=[%s]\n", strerror(errno));
2071                 return false;
2072         }
2073
2074         GIOChannel* gio2 = g_io_channel_unix_new(g_oem_pipe[0]);
2075         g_io_add_watch(gio2, G_IO_IN, (GIOFunc)__wfd_oem_thread_safe_event_handler_cb, NULL);
2076         g_io_channel_unref(gio2);
2077 #endif
2078
2079         g_oem_event_callback = event_callback;
2080
2081         g_noti_cb = __wfd_oem_callback;
2082
2083         memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
2084         memset(g_incomming_peer_ssid, 0, sizeof(g_incomming_peer_ssid));
2085
2086         __WDP_LOG_FUNC_EXIT__;
2087         return true;
2088 }
2089
2090 int wfd_ws_destroy()
2091 {
2092         __WDP_LOG_FUNC_ENTER__;
2093
2094         // Do nothing upto now...
2095
2096         __WDP_LOG_FUNC_EXIT__;
2097         return true;
2098 }
2099
2100 int wfd_ws_activate()
2101 {
2102         __WDP_LOG_FUNC_ENTER__;
2103         int result = 0;
2104         char cmd[128] = {0, };
2105         char res_buffer[1024]={0,};
2106         int res_buffer_len=sizeof(res_buffer);
2107
2108         // Loading Driver,  Excuting p2p_supplicant
2109         system("/usr/bin/wlan.sh p2p");
2110         system("/usr/sbin/p2p_supp.sh start");
2111
2112         sleep(1);
2113         g_global_sockfd = __create_ctrl_intf("p2p_ctrl_global", "/var/run/p2p_global");
2114         if(g_global_sockfd < 0)
2115         {
2116                 WDP_LOGE( "Failed to create Global Control interface\n");
2117                 return false;
2118         }
2119
2120         strncpy(cmd, CMD_INTERFACE, sizeof(cmd));
2121         result = __send_wpa_request(g_global_sockfd, cmd, res_buffer,  res_buffer_len);
2122         WDP_LOGE( "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
2123         if(!strstr(res_buffer, "wlan0"))
2124         {
2125                 memset(cmd, 0x0, 128);
2126                 memset(res_buffer, 0x0, 1024);
2127
2128                 snprintf(cmd, sizeof(cmd), "%s %s", CMD_INTERFACE_ADD, "wlan0\t/usr/etc/wifi-direct/p2p_suppl.conf\tnl80211\t/var/run/p2p_supplicant");
2129                 result = __send_wpa_request(g_global_sockfd, cmd, res_buffer,  res_buffer_len);
2130                 WDP_LOGE( "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
2131         }
2132         memset(res_buffer, 0x0, 1024);
2133
2134         // Creating Socket
2135         int count = 10;
2136         do
2137         {
2138                 sleep(1);
2139
2140                 // Sync Socket
2141                 g_control_sockfd = __create_ctrl_intf("p2p_ctrl_control", "/var/run/p2p_supplicant/wlan0");
2142                 if (g_control_sockfd > 0) {
2143                         // Async Socket
2144                         g_monitor_sockfd = __create_ctrl_intf("p2p_ctrl_monitor", "/var/run/p2p_supplicant/wlan0");
2145                         if (g_monitor_sockfd > 0)
2146                         {
2147                                 if (__wpa_ctrl_attach(g_monitor_sockfd) < 0)
2148                                 {
2149                                         WDP_LOGE( "Failed to attach monitor socket! sockfd=[%d]", g_monitor_sockfd);
2150                                         return false;
2151                                 }
2152                                 break;
2153                         }
2154                 } else {
2155                         WDP_LOGE( "Failed to attach control socket! sockfd=[%d]", g_control_sockfd);
2156                 }
2157                 count--;
2158
2159                 if (count == 0)
2160                         WDP_LOGE( "Failed to create socket !!\n");
2161
2162         } while (count > 0);
2163
2164         WDP_LOGD( "Successfully socket connected to server !!\n");
2165
2166         GIOChannel *gio3;
2167
2168         gio3 = g_io_channel_unix_new(g_monitor_sockfd);
2169         g_source_id = g_io_add_watch(gio3, G_IO_IN | G_IO_ERR | G_IO_HUP, (GIOFunc) __ws_event_callback, NULL);
2170         g_io_channel_unref(gio3);
2171         WDP_LOGD( "Scoket is successfully registered to g_main_loop.\n");
2172
2173         //wfd_ws_set_oem_loglevel(3);
2174
2175         /* init miracast */
2176         if(wfd_ws_dsp_init() == true)
2177                 WDP_LOGD( "Success : wfd_ws_dsp_init() \n");
2178         else
2179                 WDP_LOGE( "Failed : wfd_ws_dsp_init()\n");
2180
2181         __get_persistent_group_clients();
2182
2183         __WDP_LOG_FUNC_EXIT__;
2184         return true;
2185 }
2186
2187 int wfd_ws_deactivate()
2188 {
2189         __WDP_LOG_FUNC_ENTER__;
2190
2191         char cmd[32] = {0, };
2192         char res_buffer[1024]={0,};
2193         int res_buffer_len=sizeof(res_buffer);
2194         int result = 0;
2195
2196         g_wps_event_block = 0;
2197
2198         // stop p2p_find
2199         wfd_ws_cancel_discovery();
2200
2201         // detach monitor interface
2202         strncpy(cmd, CMD_DETACH, sizeof(cmd));
2203         result = __send_wpa_request(g_monitor_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2204         WDP_LOGD( "__send_wpa_request(CMD_DETACH) result=[%d]\n", result);
2205         if (result < 0)
2206         {
2207                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2208                 __WDP_LOG_FUNC_EXIT__;
2209                 return false;
2210         }
2211         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2212         {
2213                 WDP_LOGE( "DETACH command Fail. result [%d], res_buffer [%s]\n", result, res_buffer);
2214                 __WDP_LOG_FUNC_EXIT__;
2215                 return false;
2216         }
2217         memset(cmd, 0x0, 32);
2218         memset(res_buffer, 0x0, 1024);
2219
2220         // close control interface
2221         g_source_remove(g_source_id);
2222         unlink("/tmp/wpa_ctrl_monitor");
2223         if (g_monitor_sockfd >= 0)
2224                 close(g_monitor_sockfd);
2225
2226         // terminate wpasupplicant
2227         strncpy(cmd, CMD_TERMINATE, sizeof(cmd));
2228         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2229         WDP_LOGD( "__send_wpa_request(CMD_TERMINATE) result=[%d]\n", result);
2230         if (result < 0)
2231         {
2232                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2233                 __WDP_LOG_FUNC_EXIT__;
2234                 return false;
2235         }
2236         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2237         {
2238                 WDP_LOGE( "DETACH command Fail. result [%d], res_buffer [%s]\n", result, res_buffer);
2239                 __WDP_LOG_FUNC_EXIT__;
2240                 return false;
2241         }
2242         memset(cmd, 0x0, 32);
2243         memset(res_buffer, 0x0, 1024);
2244
2245         unlink("/tmp/wpa_ctrl_control");
2246         if (g_control_sockfd >= 0)
2247                 close(g_control_sockfd);
2248
2249         wfd_ws_glist_reset_connected_peer();
2250
2251         // wlan.sh stop
2252         system("/usr/bin/wlan.sh stop");
2253
2254         __WDP_LOG_FUNC_EXIT__;
2255         return true;
2256 }
2257
2258 int wfd_ws_wps_pbc_start(unsigned char peer_addr[6])
2259 {
2260         __WDP_LOG_FUNC_ENTER__;
2261
2262         char cmd[40] = {0, };
2263         char res_buffer[1024]={0,};
2264         int res_buffer_len = sizeof(res_buffer);
2265         int result;
2266
2267         if (wfd_ws_is_groupowner()!=true)
2268         {
2269                 WDP_LOGE( "wps_pbc_start() can be called, only when device is go!!\n");
2270                 __WDP_LOG_FUNC_EXIT__;
2271                 return false;
2272         }
2273
2274         char tmp_mac[6] = {0,};
2275
2276         if (peer_addr == NULL) {
2277                 WDP_LOGD("Peer address is NULL");
2278                 if (memcmp(g_incomming_peer_mac_address, tmp_mac, 6) == 0) {
2279                         WDP_LOGD("Incomming peer [" MACSTR "]", MAC2STR(g_incomming_peer_mac_address));
2280                         snprintf(cmd, sizeof(cmd), "%s", CMD_WPS_PUSHBUTTON_START);
2281                 } else {
2282                         WDP_LOGD("Incomming peer [" MACSTR "]", MAC2STR(g_incomming_peer_mac_address));
2283                         snprintf(cmd, sizeof(cmd), "%s p2p_dev_addr=" MACSTR "", CMD_WPS_PUSHBUTTON_START, MAC2STR(g_incomming_peer_mac_address));
2284                 }
2285         } else if (memcmp(peer_addr, tmp_mac, 6) != 0){
2286                 WDP_LOGD("Peer address [" MACSTR "]", MAC2STR(peer_addr));
2287                 snprintf(cmd, sizeof(cmd), "%s p2p_dev_addr=" MACSTR "", CMD_WPS_PUSHBUTTON_START, MAC2STR(peer_addr));
2288         } else {
2289                 WDP_LOGE("Peer address is incorrent");
2290                 return false;
2291         }
2292
2293         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2294         WDP_LOGD( "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
2295         if (result < 0)
2296         {
2297                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2298                 __WDP_LOG_FUNC_EXIT__;
2299                 return false;
2300         }
2301
2302         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2303         {
2304                 __WDP_LOG_FUNC_EXIT__;
2305                 return false;
2306         }
2307
2308         WDP_LOGD( "start WPS PBC...\n");
2309
2310         __WDP_LOG_FUNC_EXIT__;
2311         return true;
2312 }
2313
2314 int wfd_ws_wps_pin_start(unsigned char peer_addr[6])
2315 {
2316         __WDP_LOG_FUNC_ENTER__;
2317
2318         char cmd[50] = {0, };
2319         char mac_str[18] = {0, };
2320         char res_buffer[1024]={0,};
2321         int res_buffer_len = sizeof(res_buffer);
2322         int result;
2323
2324         snprintf(mac_str, 18, MACSTR, MAC2STR(peer_addr));
2325         snprintf(cmd, sizeof(cmd),"%s %s %s", CMD_WPS_WPS_PIN_START, mac_str, g_wps_pin);
2326         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2327         WDP_LOGD( "__send_wpa_request(WPS_PIN) result=[%d]\n", result);
2328         if (result < 0)
2329         {
2330                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2331                 __WDP_LOG_FUNC_EXIT__;
2332                 return false;
2333         }
2334
2335         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2336         {
2337                 __WDP_LOG_FUNC_EXIT__;
2338                 return false;
2339         }
2340
2341         WDP_LOGD( "start WPS PBC...\n");
2342
2343
2344         __WDP_LOG_FUNC_EXIT__;
2345         return true;
2346 }
2347
2348 int wfd_ws_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config)
2349 {
2350         __WDP_LOG_FUNC_ENTER__;
2351
2352         char cmd[64] = {0, };
2353         char mac_str[18] = {0, };
2354         char res_buffer[1024]={0,};
2355         int res_buffer_len = sizeof(res_buffer);
2356         int result;
2357
2358         wfd_server_control_t * wfd_server = wfd_server_get_control();
2359         WDP_LOGD( "wfd_server->current_peer.is_group_owner=[%d]\n", wfd_server->current_peer.is_group_owner);
2360
2361         if (wfd_ws_is_groupowner()==true)
2362         {
2363                 strncpy(cmd, CMD_WPS_PUSHBUTTON_START, sizeof(cmd));
2364                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2365                 WDP_LOGD( "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
2366         }
2367
2368         if (wfd_server->current_peer.is_group_owner)
2369         {
2370                 snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2371                 if (wps_config == WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD ||
2372                         wps_config == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
2373                         snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, g_wps_pin);
2374                 }else {
2375                         snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(wps_config));
2376                 }
2377                 WDP_LOGD("Join command: [%s]", cmd);
2378                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2379                 WDP_LOGD( "__send_wpa_request(CMD_CONNECT join) result=[%d]\n", result);
2380         }
2381         else
2382         {
2383                 snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2384                 WDP_LOGD( "MAC ADDR = [%s]\t PIN = [%s]\n",
2385                                 mac_str, g_wps_pin);
2386
2387                 if (wps_config == WIFI_DIRECT_WPS_TYPE_PBC) {
2388                         WDP_LOGD("WIFI_DIRECT_WPS_TYPE_PBC");
2389                         snprintf(cmd, sizeof(cmd), "%s %s %s", CMD_CONNECT, mac_str, CMD_PBC_STRING);
2390                 } else if (wps_config == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
2391                         WDP_LOGD("WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY");
2392                         snprintf(cmd, sizeof(cmd), "%s %s %s %s", CMD_CONNECT, mac_str, g_wps_pin, CMD_DISPLAY_STRING);
2393                 } else if (wps_config == WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD) {
2394                         WDP_LOGD("WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD");
2395                         snprintf(cmd, sizeof(cmd), "%s %s %s %s", CMD_CONNECT, mac_str, g_wps_pin, CMD_KEYPAD_STRING);
2396                 } else {
2397                         WDP_LOGD( "UNKNOWN CONFIG METHOD\n");
2398                         return false;
2399                 }
2400
2401                 WDP_LOGD( "COMMAND = [%s]\n", cmd);
2402
2403                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2404                 WDP_LOGD( "__send_wpa_request(P2P_CONNECT) result=[%d]\n", result);
2405         }
2406
2407         if (result < 0)
2408         {
2409                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2410                 __WDP_LOG_FUNC_EXIT__;
2411                 return false;
2412         }
2413
2414         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2415         {
2416                 __WDP_LOG_FUNC_EXIT__;
2417                 return false;
2418         }
2419
2420         WDP_LOGD( "Connecting... peer-MAC [%s]\n", mac_str);
2421
2422         __WDP_LOG_FUNC_EXIT__;
2423         return true;
2424 }
2425 int wfd_ws_connect_for_go_neg(unsigned char mac_addr[6],
2426                 wifi_direct_wps_type_e wps_config)
2427 {
2428         __WDP_LOG_FUNC_ENTER__;
2429         char cmd[64] = {0, };
2430         char mac_str[18] = {0, };
2431         char res_buffer[1024]={0,};
2432         int res_buffer_len = sizeof(res_buffer);
2433         int result;
2434
2435         WDP_LOGD( "CONNECT REQUEST FOR GO NEGOTIATION");
2436         snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2437         snprintf(cmd, sizeof(cmd), "%s %s %s %s", CMD_CONNECT, mac_str, g_wps_pin, __convert_wps_config_methods_value(wps_config));
2438
2439         if (wps_config == WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD ||
2440                         wps_config == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
2441                 WDP_LOGD( "CONFIG = [%d] \n", wps_config);
2442         } else {
2443                 WDP_LOGE( "Not expected CONFIG METHOD\n");
2444                 return false;
2445         }
2446
2447         WDP_LOGD( "COMMAND = [%s]****\n", cmd);
2448         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer,
2449                         res_buffer_len);
2450         if (result < 0) {
2451                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2452                 __WDP_LOG_FUNC_EXIT__;
2453                 return false;
2454         }
2455         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0)) {
2456                 __WDP_LOG_FUNC_EXIT__;
2457                 return false;
2458         }
2459         WDP_LOGD( "Connecting... peer-MAC [%s]\n", mac_str);
2460         __WDP_LOG_FUNC_EXIT__;
2461         return true;
2462 }
2463
2464 /* for sending connection request in case Persistent mode enabled */
2465 int wfd_ws_connect_for_persistent_group(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config)
2466 {
2467         __WDP_LOG_FUNC_ENTER__;
2468
2469         char cmd[64] = {0, };
2470         char mac_str[18] = {0, };
2471         char res_buffer[1024]={0,};
2472         int res_buffer_len = sizeof(res_buffer);
2473         int result;
2474
2475         wfd_server_control_t * wfd_server = wfd_server_get_control();
2476         WDP_LOGD( "wfd_server->current_peer.is_group_owner=[%d]\n", wfd_server->current_peer.is_group_owner);
2477         WDP_LOGD( "wfd_server->current_peer.is_persistent_go=[%d]\n", wfd_server->current_peer.is_persistent_go);
2478
2479         int network_id;
2480
2481         WDP_LOGD( "[persistent mode!!!]\n");
2482         snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2483
2484         if (wfd_server->current_peer.is_group_owner)    /* join group */
2485         {
2486                 snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2487                 snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(wps_config));
2488                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2489                 WDP_LOGD( "__send_wpa_request(CMD_CONNECT join) result=[%d]\n", result);
2490         }
2491         else /* Creating or reinvoking my persistent group and send invite req. */
2492         {
2493 #if 1
2494                 /*  First, searching for peer in persistent client list : in case, My device is GO */
2495                 network_id = __get_network_id_from_persistent_client_list_with_mac(mac_str);
2496
2497                 if (network_id < 0)     /* If peer is not exist in client list, searching for peer in persistnet group GO list : in case, peer is GO */
2498                         network_id = __get_network_id_from_network_list_with_go_mac(mac_str);
2499
2500                 if (network_id < 0)     /* If can not find peer anywhere, Create new persistent group */
2501                 {
2502                         if (wfd_ws_create_group(NULL) != true)
2503                         {
2504                                 WDP_LOGE( "wfd_ws_create_group FAILED!!\n");
2505                                 __WDP_LOG_FUNC_EXIT__;
2506                                 return false;
2507                         }
2508
2509                         if (wfd_ws_send_invite_request(mac_addr) != true)
2510                         {
2511                                 WDP_LOGE( "wfd_ws_send_invite_request FAILED!!\n");
2512                                 __WDP_LOG_FUNC_EXIT__;
2513                                 return false;
2514                         }
2515                 }
2516                 else    /* Reinvoke persistent group and invite peer */
2517                 {
2518                         if (__send_invite_request_with_network_id(network_id, mac_addr) != true)
2519                         {
2520                                 WDP_LOGE( "__send_invite_request_with_network_id FAILED!!\n");
2521                                 __WDP_LOG_FUNC_EXIT__;
2522                                 return false;
2523                         }
2524
2525                         if (__wfd_ws_reinvoke_persistent_group(network_id) != true)
2526                         {
2527                                 WDP_LOGE( "__wfd_ws_reinvoke_persistent_group FAILED!!\n");
2528                                 __WDP_LOG_FUNC_EXIT__;
2529                                 return false;
2530                         }
2531                 }
2532 #else
2533                 int persistent_group_count = 0;
2534                 wfd_persistent_group_info_s* plist;
2535                 int i;
2536
2537                 result = wfd_ws_get_persistent_group_info(&plist, &persistent_group_count);
2538                 if (result == true)
2539                 {
2540                         /* checking already created persistent group list */
2541                         for(i=0; i<persistent_group_count; i++)
2542                         {
2543                                 WDP_LOGD( "plist[%d].go_mac_address=[%s]\n", i,plist[i].go_mac_address);
2544                                 if (strcmp(plist[i].go_mac_address, mac_str) == 0)
2545                                 {
2546                                         WDP_LOGD( "Found peer in persistent group list [network id : %d]\n", plist[i].network_id);
2547                                         snprintf(cmd, sizeof(cmd), "%s persistent=%d", CMD_CREATE_GROUP, plist[i].network_id);
2548                                         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2549                                         WDP_LOGD( "__send_wpa_request(P2P_GROUP_ADD persistent=%d) result=[%d]\n", plist[i].network_id, result);
2550                                         break;
2551                                 }
2552                         }
2553
2554                         if (i == persistent_group_count)        /* Can't find peer in persistent group list. Creation of new persistent group */
2555                         {
2556                                 /* Persistent group mode */
2557                                 snprintf(cmd, sizeof(cmd), "%s %s %s", CMD_CREATE_GROUP, "persistent", FREQUENCY_2G);
2558                                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2559                                 WDP_LOGD( "__send_wpa_request(P2P_GROUP_ADD) result=[%d]\n", result);
2560
2561                                 if (result < 0)
2562                                 {
2563                                         WDP_LOGE( "__send_wpa_request FAILED!!\n");
2564                                         __WDP_LOG_FUNC_EXIT__;
2565                                         return false;
2566                                 }
2567
2568                                 if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2569                                 {
2570                                         __WDP_LOG_FUNC_EXIT__;
2571                                         return false;
2572                                 }
2573
2574                                 wfd_ws_send_invite_request(mac_addr);
2575
2576                         }
2577                 }
2578                 else
2579                 {
2580                         WDP_LOGE( "Error!! wfd_ws_get_persistent_group_info() failed..\n");
2581                         __WDP_LOG_FUNC_EXIT__;
2582                         return false;
2583                 }
2584 #endif
2585
2586         }
2587
2588         WDP_LOGD( "Connecting... peer-MAC [%s]\n", mac_str);
2589
2590         __WDP_LOG_FUNC_EXIT__;
2591         return true;
2592 }
2593
2594 int wfd_ws_disconnect()
2595 {
2596         __WDP_LOG_FUNC_ENTER__;
2597
2598         char cmd[32] = {0, };
2599         char res_buffer[1024]={0,};
2600         int res_buffer_len = sizeof(res_buffer);
2601         int result;
2602
2603         g_wps_event_block = 0;
2604
2605         snprintf(cmd, sizeof(cmd), "%s %s", CMD_GROUP_REMOVE, DEFAULT_IF_NAME);
2606         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2607         WDP_LOGD( "__send_wpa_request(P2P_GROUP_REMOVE) result=[%d]\n", result);
2608
2609         if (result < 0)
2610         {
2611                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2612                 __WDP_LOG_FUNC_EXIT__;
2613                 return false;
2614         }
2615
2616         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2617         {
2618                 __WDP_LOG_FUNC_EXIT__;
2619                 return false;
2620         }
2621
2622         WDP_LOGD( "disconnect... remove group [%s]\n", DEFAULT_IF_NAME);
2623
2624         __WDP_LOG_FUNC_EXIT__;
2625         return true;
2626 }
2627
2628
2629 // TODO: should find how to disconnect with peer by peer_mac
2630 int wfd_ws_disconnect_sta(unsigned char mac_addr[6])
2631 {
2632         __WDP_LOG_FUNC_ENTER__;
2633
2634         int result;
2635
2636         result = wfd_ws_disconnect();
2637
2638         __WDP_LOG_FUNC_EXIT__;
2639         return result;
2640 }
2641
2642 bool wfd_ws_is_discovery_enabled()
2643 {
2644         __WDP_LOG_FUNC_ENTER__;
2645
2646         __WDP_LOG_FUNC_EXIT__;
2647         return false;
2648 }
2649
2650 bool wfd_ws_flush()
2651 {
2652         __WDP_LOG_FUNC_ENTER__;
2653
2654         char cmd[16] = {0, };
2655         char res_buffer[1024]={0,};
2656         int res_buffer_len=sizeof(res_buffer);
2657         int result = 0;
2658
2659         g_wps_event_block = 0;
2660
2661         // Skip checking result..
2662         strncpy(cmd, CMD_FLUSH, sizeof(cmd));
2663         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2664         WDP_LOGD( "__send_wpa_request(P2P_FLUSH) result=[%d]\n", result);
2665
2666         if (result < 0)
2667         {
2668                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2669                 __WDP_LOG_FUNC_EXIT__;
2670                 return false;
2671         }
2672
2673         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2674         {
2675                 __WDP_LOG_FUNC_EXIT__;
2676                 return false;
2677         }
2678
2679         __WDP_LOG_FUNC_EXIT__;
2680         return true;
2681 }
2682
2683
2684
2685 int wfd_ws_start_discovery(bool listen_only, int timeout)
2686 {
2687         __WDP_LOG_FUNC_ENTER__;
2688
2689         char cmd[16] = {0, };
2690         char res_buffer[1024]={0,};
2691         int res_buffer_len=sizeof(res_buffer);
2692         int result = 0;
2693
2694 #if 0
2695         if (wfd_ws_is_groupowner()==false && wfd_ws_is_groupclient()==false)
2696                 wfd_ws_flush();
2697 #endif
2698
2699         if (listen_only == true)
2700         {
2701                 if (timeout > 0)
2702                         snprintf(cmd, sizeof(cmd), "%s %d", CMD_START_LISTEN, timeout);
2703                 else
2704                         strncpy(cmd, CMD_START_LISTEN, sizeof(cmd));
2705
2706                         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2707                         WDP_LOGD( "__send_wpa_request(P2P_LISTEN) result=[%d]\n", result);
2708         }
2709         else
2710         {
2711                 strncpy(cmd, CMD_START_DISCOVER, sizeof(cmd));
2712                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2713                 WDP_LOGD( "__send_wpa_request(P2P_FIND) result=[%d]\n", result);
2714         }
2715
2716         if (result < 0)
2717         {
2718                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2719                 __WDP_LOG_FUNC_EXIT__;
2720                 return false;
2721         }
2722
2723         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2724         {
2725                 __WDP_LOG_FUNC_EXIT__;
2726                 return false;
2727         }
2728
2729         // to notify to the application.
2730         if (listen_only == true)
2731                 g_noti_cb(WFD_EVENT_DISCOVER_START_LISTEN_ONLY);
2732         else
2733                 g_noti_cb(WFD_EVENT_DISCOVER_START_80211_SCAN);
2734
2735         __WDP_LOG_FUNC_EXIT__;
2736         return true;
2737 }
2738
2739 int wfd_ws_cancel_discovery()
2740 {
2741         __WDP_LOG_FUNC_ENTER__;
2742
2743         char cmd[16] = {0, };
2744         char res_buffer[1024]={0,};
2745         int res_buffer_len=sizeof(res_buffer);
2746         int result = 0;
2747
2748         strncpy(cmd, CMD_CANCEL_DISCOVER, sizeof(cmd));
2749         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2750         WDP_LOGD( "__send_wpa_request(P2P_STOP_FIND) result=[%d]\n", result);
2751
2752         if (result < 0)
2753         {
2754                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2755                 __WDP_LOG_FUNC_EXIT__;
2756                 return false;
2757         }
2758
2759         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
2760         {
2761                 __WDP_LOG_FUNC_EXIT__;
2762                 return false;
2763         }
2764
2765         // to notify to the application.
2766         g_noti_cb(WFD_EVENT_DISCOVER_CANCEL);
2767
2768         __WDP_LOG_FUNC_EXIT__;
2769         return true;
2770 }
2771
2772 int wfd_ws_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num)
2773 {
2774         __WDP_LOG_FUNC_ENTER__;
2775
2776         char cmd[40] = {0, };
2777         char mac_str[18] = {0, };
2778         char res_buffer[1024] = {0,};
2779         int res_buffer_len = sizeof(res_buffer);
2780         int result = 0;
2781         int peer_count = 0;
2782         int i;
2783         ws_discovered_peer_info_s ws_peer_list[MAX_PEER_NUM];
2784         static wfd_discovery_entry_s wfd_peer_list[16];
2785
2786         memset(&ws_peer_list, 0, (sizeof(ws_discovered_peer_info_s)*MAX_PEER_NUM));
2787         memset(&wfd_peer_list, 0, (sizeof(wfd_discovery_entry_s)*16));
2788
2789         /* Reading first discovered peer */
2790         strncpy(cmd, CMD_GET_FIRST_DISCOVERED_PEER, sizeof(cmd));
2791         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2792         WDP_LOGD( "__send_wpa_request(P2P_PEER FIRST) result=[%d]\n", result);
2793         if (result < 0)
2794         {
2795                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2796                 *peer_num = 0;
2797                 *peer_list = NULL;
2798                 __WDP_LOG_FUNC_EXIT__;
2799                 return false;
2800         }
2801
2802         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))    /* p2p_supplicant returns the 'FAIL' if there is no discovered peer. */
2803         {
2804                 *peer_num = 0;
2805                 *peer_list = NULL;
2806                 __WDP_LOG_FUNC_EXIT__;
2807                 return false;
2808         }
2809
2810         __parsing_peer(res_buffer, &ws_peer_list[peer_count]);
2811         peer_count++;
2812
2813         /* Reading Next discovered peers */
2814         do
2815         {
2816                 memset(cmd, 0x0, 40);
2817                 memset(mac_str, 0x0, 18);
2818                 memset(res_buffer, 0, sizeof(res_buffer));
2819
2820                 strncpy(mac_str, ws_peer_list[peer_count-1].mac, sizeof(mac_str));
2821                 snprintf(cmd, sizeof(cmd), "%s%s", CMD_GET_NEXT_DISCOVERED_PEER, mac_str);
2822                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2823                 WDP_LOGD( "__send_wpa_request(P2P_PEER NEXT-) result=[%d]\n", result);
2824
2825                 if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))    /* p2p_supplicant returns the 'FAIL' if there is no discovered peer. */
2826                         break;
2827
2828                 __parsing_peer(res_buffer, &ws_peer_list[peer_count]);
2829                 peer_count++;
2830
2831         } while(1);
2832
2833         WDP_LOGD( "number of discovered peers: %d\n", peer_count);
2834
2835         for(i=0; i<peer_count; i++)
2836         {
2837                 memset(&wfd_peer_list[i], 0, sizeof(wfd_discovery_entry_s));
2838                 WDP_LOGD( "index [%d] MAC [%s] GOstate=[%s] groupCapab=[%x] devCapab=[%x] is_wfd_device[%d] Name[%s] type=[%s] ssid[%s]\n",
2839                                 i,
2840                                 ws_peer_list[i].mac,
2841                                 ws_peer_list[i].go_state,
2842                                 ws_peer_list[i].group_capab,
2843                                 ws_peer_list[i].dev_capab,
2844                                 ws_peer_list[i].is_wfd_device,
2845                                 ws_peer_list[i].device_name,
2846                                 ws_peer_list[i].pri_dev_type,
2847                                 ws_peer_list[i].oper_ssid);
2848 /*
2849                 typedef struct
2850                 {
2851                         bool is_group_owner;
2852                         char ssid[WIFI_DIRECT_MAX_SSID_LEN + 1];
2853                         unsigned char mac_address[6];
2854                         int channel;
2855                         bool is_connected;
2856                         unsigned int services;
2857                         bool is_persistent_go;
2858                         unsigned char intf_mac_address[6];
2859                         unsigned int wps_device_pwd_id;
2860                         unsigned int wps_cfg_methods;
2861                         unsigned int category;
2862                         unsigned int subcategory;
2863                 } wfd_discovery_entry_s;
2864 */
2865                 // Device MAC address
2866                 unsigned char la_mac_addr1[6];
2867
2868                 wfd_macaddr_atoe(ws_peer_list[i].mac, la_mac_addr1);
2869                 memcpy(wfd_peer_list[i].mac_address, (char*)(la_mac_addr1), sizeof(la_mac_addr1));
2870
2871                 // Interface MAC address
2872                 unsigned char la_mac_addr2[6];
2873
2874                 wfd_macaddr_atoe(ws_peer_list[i].interface_addr, la_mac_addr2);
2875                 memcpy(wfd_peer_list[i].intf_mac_address, (char*)(la_mac_addr2), sizeof(la_mac_addr2));
2876
2877                 // WPS Config method
2878                 wfd_peer_list[i].wps_cfg_methods = 0;
2879                 if ((ws_peer_list[i].config_methods & WPS_CONFIG_DISPLAY) > 0)
2880                         wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
2881                 if ((ws_peer_list[i].config_methods & WPS_CONFIG_PUSHBUTTON) > 0)
2882                         wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PBC;
2883                 if ((ws_peer_list[i].config_methods & WPS_CONFIG_KEYPAD) > 0)
2884                         wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
2885
2886                 // Device name --> SSID
2887                 strncpy(wfd_peer_list[i].device_name, ws_peer_list[i].device_name, DEVICE_NAME_LEN);
2888                 wfd_peer_list[i].device_name[DEVICE_NAME_LEN-1] = '\0';
2889
2890                 // is_group_owner
2891                 if ((ws_peer_list[i].group_capab & GROUP_CAPAB_GROUP_OWNER) > 0)  /* checking GO state */
2892                         wfd_peer_list[i].is_group_owner = true;
2893                 else
2894                         wfd_peer_list[i].is_group_owner = false;
2895
2896                 WDP_LOGD( "GroupOwnerCapab: %x & %x = %d\n", ws_peer_list[i].group_capab, GROUP_CAPAB_GROUP_OWNER, (ws_peer_list[i].group_capab & GROUP_CAPAB_GROUP_OWNER));
2897
2898                 // is_persistent_go
2899                 if ((ws_peer_list[i].group_capab & GROUP_CAPAB_PERSISTENT_GROUP) > 0)  /* checking persistent GO state */
2900                         wfd_peer_list[i].is_persistent_go = true;
2901                 else
2902                         wfd_peer_list[i].is_persistent_go = false;
2903
2904                 // is_connected
2905                 if (strncmp(ws_peer_list[i].member_in_go_dev, "00:00:00:00:00:00", strlen("00:00:00:00:00:00"))!=0)
2906                         wfd_peer_list[i].is_connected = true;
2907                 else
2908                         wfd_peer_list[i].is_connected = false;
2909
2910                 // Listen channel
2911                 // ToDo: convert freq to channel...
2912                 wfd_peer_list[i].channel = ws_peer_list[i].listen_freq;
2913
2914                 // wps_device_pwd_id
2915                 // ToDo: where to get it?
2916                 wfd_peer_list[i].wps_device_pwd_id = 0;
2917
2918                 wfd_peer_list[i].category = __convert_device_type(ws_peer_list[i].pri_dev_type);
2919                 wfd_peer_list[i].subcategory = __convert_secondary_device_type(ws_peer_list[i].pri_dev_type);
2920         }
2921
2922         *peer_num = peer_count;
2923         *peer_list = &wfd_peer_list[0];
2924
2925         WDP_LOGE( "Getting discovery result is Completed.\n");
2926
2927         __WDP_LOG_FUNC_EXIT__;
2928         return true;
2929
2930 }
2931
2932 int wfd_ws_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer)
2933 {
2934         __WDP_LOG_FUNC_ENTER__;
2935
2936         char cmd[32] = {0, };
2937         char mac_str[18] = {0, };
2938         char res_buffer[1024] = {0,};
2939         int res_buffer_len = sizeof(res_buffer);
2940         int result = 0;
2941         ws_discovered_peer_info_s ws_peer_info;
2942         wfd_discovery_entry_s* wfd_peer_info;
2943
2944         memset(&ws_peer_info, 0x0, sizeof(ws_discovered_peer_info_s));
2945         wfd_peer_info = (wfd_discovery_entry_s *) calloc(1, sizeof(wfd_discovery_entry_s));
2946
2947         /* Reading first discovered peer */
2948         snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
2949         snprintf(cmd, sizeof(cmd),"%s %s", CMD_GET_PEER_INFO, mac_str);
2950         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
2951         WDP_LOGD( "__send_wpa_request(P2P_PEER) result=[%d]\n", result);
2952         if (result < 0)
2953         {
2954                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
2955                 *peer = NULL;
2956                 __WDP_LOG_FUNC_EXIT__;
2957                 return false;
2958         }
2959
2960         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))    /* p2p_supplicant returns the 'FAIL' if there is no discovered peer. */
2961         {
2962                 *peer = NULL;
2963                 __WDP_LOG_FUNC_EXIT__;
2964                 return false;
2965         }
2966
2967         // TODO: parsing peer info
2968         __parsing_peer(res_buffer, &ws_peer_info);
2969
2970         WDP_LOGD( "MAC [%s] GOstate=[%s] groupCapab=[%x] devCapab=[%x] Name[%s] type=[%s] ssid[%s]\n",
2971                         ws_peer_info.mac,
2972                         ws_peer_info.go_state,
2973                         ws_peer_info.group_capab,
2974                         ws_peer_info.dev_capab,
2975                         ws_peer_info.device_name,
2976                         ws_peer_info.pri_dev_type,
2977                         ws_peer_info.oper_ssid);
2978
2979         // Device MAC address
2980         unsigned char la_mac_addr1[6];
2981
2982         wfd_macaddr_atoe(ws_peer_info.mac, la_mac_addr1);
2983         memcpy(wfd_peer_info->mac_address, (char*)(la_mac_addr1), sizeof(la_mac_addr1));
2984
2985         // Interface MAC address
2986         unsigned char la_mac_addr2[6];
2987
2988         wfd_macaddr_atoe(ws_peer_info.interface_addr, la_mac_addr2);
2989         memcpy(wfd_peer_info->intf_mac_address, (char*)(la_mac_addr2), sizeof(la_mac_addr2));
2990
2991         // WPS Config method
2992         wfd_peer_info->wps_cfg_methods = 0;
2993         if ((ws_peer_info.config_methods & WPS_CONFIG_DISPLAY) > 0)
2994                 wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
2995         if ((ws_peer_info.config_methods & WPS_CONFIG_PUSHBUTTON) > 0)
2996                 wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PBC;
2997         if ((ws_peer_info.config_methods & WPS_CONFIG_KEYPAD) > 0)
2998                 wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
2999
3000         // Device name --> SSID
3001         strncpy(wfd_peer_info->device_name, ws_peer_info.device_name, DEVICE_NAME_LEN);
3002         wfd_peer_info->device_name[DEVICE_NAME_LEN-1] = '\0';
3003
3004         // is_group_owner
3005         if ((ws_peer_info.group_capab & GROUP_CAPAB_GROUP_OWNER) > 0)  /* checking GO state */
3006                 wfd_peer_info->is_group_owner = true;
3007         else
3008                 wfd_peer_info->is_group_owner = false;
3009
3010         WDP_LOGD( "GroupOwnerCapab: %x & %x = %d\n", ws_peer_info.group_capab, GROUP_CAPAB_GROUP_OWNER, (ws_peer_info.group_capab & GROUP_CAPAB_GROUP_OWNER));
3011
3012         // is_persistent_go
3013         if ((ws_peer_info.group_capab & GROUP_CAPAB_PERSISTENT_GROUP) > 0)  /* checking persistent GO state */
3014                 wfd_peer_info->is_persistent_go = true;
3015         else
3016                 wfd_peer_info->is_persistent_go = false;
3017
3018         // is_connected
3019         if (strncmp(ws_peer_info.member_in_go_dev, "00:00:00:00:00:00", strlen("00:00:00:00:00:00"))!=0)
3020                 wfd_peer_info->is_connected = true;
3021         else
3022                 wfd_peer_info->is_connected = false;
3023
3024         // Listen channel
3025         // ToDo: convert freq to channel...
3026         wfd_peer_info->channel = ws_peer_info.listen_freq;
3027
3028         // wps_device_pwd_id
3029         // ToDo: where to get it?
3030         wfd_peer_info->wps_device_pwd_id = 0;
3031
3032         wfd_peer_info->category = __convert_device_type(ws_peer_info.pri_dev_type);
3033         wfd_peer_info->subcategory = __convert_secondary_device_type(ws_peer_info.pri_dev_type);
3034
3035         *peer = wfd_peer_info;
3036
3037         __WDP_LOG_FUNC_EXIT__;
3038         return true;
3039 }
3040
3041 int wfd_ws_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go)
3042 {
3043         __WDP_LOG_FUNC_ENTER__;
3044
3045         char cmd[64] = {0, };
3046         char mac_str[18] = {0, };
3047         char res_buffer[1024]={0,};
3048         int res_buffer_len = sizeof(res_buffer);
3049         int result;
3050
3051         WDP_LOGD("Outgoing PROV_DISC");
3052
3053         if (is_peer_go && config_method == WIFI_DIRECT_WPS_TYPE_PBC)
3054         {
3055                 snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
3056                 snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(config_method));
3057                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3058                 WDP_LOGD("Join command: [%s]", cmd);
3059                 WDP_LOGD( "__send_wpa_request(P2P_PROV_DISC) result=[%d]\n", result);
3060         }
3061         else
3062         {
3063                 snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
3064                 snprintf(cmd, sizeof(cmd),"%s %s %s", CMD_SEND_PROVISION_DISCOVERY_REQ, mac_str, __convert_wps_config_methods_value(config_method));
3065                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3066                 WDP_LOGD( "__send_wpa_request(P2P_PROV_DISC) result=[%d]\n", result);
3067         }
3068
3069         if (result < 0)
3070         {
3071                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3072                 __WDP_LOG_FUNC_EXIT__;
3073                 return false;
3074         }
3075
3076         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3077         {
3078                 __WDP_LOG_FUNC_EXIT__;
3079                 return false;
3080         }
3081
3082         WDP_LOGD( "Provisioning... peer-MAC [%s]\n", mac_str);
3083
3084         __WDP_LOG_FUNC_EXIT__;
3085         return true;
3086 }
3087
3088
3089 bool wfd_ws_get_go_dev_addr(char* p2p_device_address)
3090 {
3091         __WDP_LOG_FUNC_ENTER__;
3092
3093         char cmd[16] = {0, };
3094         char res_buffer[1024]={0,};
3095         int res_buffer_len = sizeof(res_buffer);
3096         int result;
3097
3098         if (p2p_device_address == NULL)
3099         {
3100                 WDP_LOGE( "Wrong param\n");
3101                 __WDP_LOG_FUNC_EXIT__;
3102                 return false;
3103         }
3104
3105         strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
3106         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3107         WDP_LOGD( "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
3108
3109         if (result < 0)
3110         {
3111                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3112                 __WDP_LOG_FUNC_EXIT__;
3113                 return false;
3114         }
3115
3116         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3117         {
3118                 __WDP_LOG_FUNC_EXIT__;
3119                 return false;
3120         }
3121
3122         char* ptr = strstr(res_buffer, "p2p_device_address=");
3123         if (ptr==NULL)
3124         {
3125             WDP_LOGD( "Can't find p2p_device_address...\n");
3126             __WDP_LOG_FUNC_EXIT__;
3127             return false;
3128         }
3129
3130         char item[32];
3131         char value[32];
3132
3133         if (__get_item_value(ptr, item, value) == NULL)
3134         {
3135             WDP_LOGD( "Can't wrong format to get p2p_device_address...\n");
3136             __WDP_LOG_FUNC_EXIT__;
3137             return false;
3138         }
3139
3140         if (strcmp(item, "p2p_device_address")!=0)
3141         {
3142             WDP_LOGD( "Can't get p2p_device_address.... item=[%s]\n", item);
3143             __WDP_LOG_FUNC_EXIT__;
3144             return false;
3145         }
3146
3147         strncpy(p2p_device_address, value, sizeof(value));
3148
3149         __WDP_LOG_FUNC_EXIT__;
3150         return true;
3151 }
3152
3153 int wfd_ws_send_invite_request(unsigned char dev_mac_addr[6])
3154 {
3155         __WDP_LOG_FUNC_ENTER__;
3156
3157         char cmd[128] = {0, };
3158         char mac_str[18] = {0, };
3159         char res_buffer[1024]={0,};
3160         char p2p_device_address[32];
3161         int res_buffer_len = sizeof(res_buffer);
3162         int result;
3163
3164         /* invite request sometimes failed in listen only mode */
3165         wfd_server_control_t * wfd_server = wfd_server_get_control();
3166         if (wfd_server->config_data.listen_only)
3167                 wfd_ws_start_discovery(false, 0);
3168
3169         if(wfd_ws_get_go_dev_addr(p2p_device_address) == false)
3170         {
3171                 __WDP_LOG_FUNC_EXIT__;
3172                 return false;
3173         }
3174
3175         snprintf(mac_str, 18, MACSTR, MAC2STR(dev_mac_addr));
3176         snprintf(cmd, sizeof(cmd), "%s group=p2p-wlan0-0 peer=%s go_dev_addr=%s", CMD_SEND_INVITE_REQ, mac_str, p2p_device_address);
3177
3178         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3179         WDP_LOGI( "__send_wpa_request(CMD_SEND_INVITE_REQ) result=[%d]\n", result);
3180
3181         if (result < 0)
3182         {
3183                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3184                 __WDP_LOG_FUNC_EXIT__;
3185                 return false;
3186         }
3187
3188         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3189         {
3190                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3191                 __WDP_LOG_FUNC_EXIT__;
3192                 return false;
3193         }
3194
3195         WDP_LOGD( "Invite... peer-MAC [%s]\n", mac_str);
3196
3197         __WDP_LOG_FUNC_EXIT__;
3198         return true;
3199 }
3200
3201
3202 int wfd_ws_create_group(char* ssid)
3203 {
3204         __WDP_LOG_FUNC_ENTER__;
3205
3206         char cmd[64] = {0, };
3207         char res_buffer[1024]={0,};
3208         int res_buffer_len = sizeof(res_buffer);
3209         int result;
3210         wfd_server_control_t * wfd_server = wfd_server_get_control();
3211
3212         if (wfd_server->config_data.want_persistent_group)
3213         {
3214                 /* Persistent group mode */
3215                 snprintf(cmd, sizeof(cmd), "%s %s %s", CMD_CREATE_GROUP, "persistent", FREQUENCY_2G);
3216         }
3217         else
3218         {
3219                 snprintf(cmd, sizeof(cmd), "%s %s", CMD_CREATE_GROUP, FREQUENCY_2G);
3220         }
3221
3222         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3223         WDP_LOGD( "__send_wpa_request(P2P_GROUP_ADD) result=[%d]\n", result);
3224
3225         if (result < 0)
3226         {
3227                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3228                 __WDP_LOG_FUNC_EXIT__;
3229                 return false;
3230         }
3231
3232         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3233         {
3234                 __WDP_LOG_FUNC_EXIT__;
3235                 return false;
3236         }
3237
3238         WDP_LOGD( "Create p2p group... \n");
3239
3240         __WDP_LOG_FUNC_EXIT__;
3241         return true;
3242 }
3243
3244 int wfd_ws_cancel_group()
3245 {
3246         __WDP_LOG_FUNC_ENTER__;
3247
3248         char cmd[30] = {0, };
3249         char res_buffer[1024]={0,};
3250         int res_buffer_len = sizeof(res_buffer);
3251         int result;
3252
3253         snprintf(cmd, sizeof(cmd), "%s %s", CMD_GROUP_REMOVE, DEFAULT_IF_NAME);
3254
3255         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3256         WDP_LOGD( "__send_wpa_request(P2P_GROUP_REMOVE) result=[%d]\n", result);
3257
3258         if (result < 0)
3259         {
3260                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3261                 __WDP_LOG_FUNC_EXIT__;
3262                 return false;
3263         }
3264
3265         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3266         {
3267                 __WDP_LOG_FUNC_EXIT__;
3268                 return false;
3269         }
3270
3271         WDP_LOGD( "Remove p2p group... \n");
3272
3273         __WDP_LOG_FUNC_EXIT__;
3274         return true;
3275 }
3276
3277 int wfd_ws_activate_pushbutton()
3278 {
3279         __WDP_LOG_FUNC_ENTER__;
3280
3281         char cmd[8] = {0, };
3282         char res_buffer[1024]={0,};
3283         int res_buffer_len = sizeof(res_buffer);
3284         int result;
3285
3286         strncpy(cmd, CMD_WPS_PUSHBUTTON_START, sizeof(cmd));
3287         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3288         WDP_LOGD( "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
3289         if (result < 0)
3290         {
3291                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3292                 __WDP_LOG_FUNC_EXIT__;
3293                 return false;
3294         }
3295
3296         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3297         {
3298                 __WDP_LOG_FUNC_EXIT__;
3299                 return false;
3300         }
3301
3302         WDP_LOGD( "start WPS PBC...\n");
3303
3304         __WDP_LOG_FUNC_EXIT__;
3305         return true;
3306  }
3307
3308 bool wfd_ws_is_groupowner()
3309 {
3310         __WDP_LOG_FUNC_ENTER__;
3311
3312         char cmd[16] = {0, };
3313         char res_buffer[1024]={0,};
3314         int res_buffer_len = sizeof(res_buffer);
3315         int result;
3316
3317         strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
3318         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3319         WDP_LOGD( "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
3320
3321         if (result < 0)
3322         {
3323                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3324                 __WDP_LOG_FUNC_EXIT__;
3325                 return false;
3326         }
3327
3328         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3329         {
3330                 __WDP_LOG_FUNC_EXIT__;
3331                 return false;
3332         }
3333
3334         if(strstr(res_buffer, "mode=P2P GO") == NULL)
3335         {
3336             WDP_LOGD( "This device is not Groupowner\n");
3337             __WDP_LOG_FUNC_EXIT__;
3338             return false;
3339         }
3340
3341         __WDP_LOG_FUNC_EXIT__;
3342         return true;
3343 }
3344
3345 bool wfd_ws_is_groupclient()
3346 {
3347         __WDP_LOG_FUNC_ENTER__;
3348         char cmd[16] = {0, };
3349         char res_buffer[1024]={0,};
3350         int res_buffer_len = sizeof(res_buffer);
3351         int result;
3352
3353         strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
3354         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3355         WDP_LOGD( "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
3356
3357         if (result < 0)
3358         {
3359                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3360                 __WDP_LOG_FUNC_EXIT__;
3361                 return false;
3362         }
3363
3364         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3365         {
3366                 __WDP_LOG_FUNC_EXIT__;
3367                 return false;
3368         }
3369
3370         if(strstr(res_buffer, "mode=station") == NULL)
3371         {
3372             WDP_LOGD( "This device is not client\n");
3373             __WDP_LOG_FUNC_EXIT__;
3374             return false;
3375         }
3376
3377         __WDP_LOG_FUNC_EXIT__;
3378         return true;
3379 }
3380
3381 int wfd_ws_get_ssid(char* ssid, int len)
3382 {
3383         __WDP_LOG_FUNC_ENTER__;
3384
3385         char cmd[12] = {0, };
3386         char tmp_ssid[64] = {0, };
3387         char res_buffer[1024]={0,};
3388         int res_buffer_len = sizeof(res_buffer);
3389         int result;
3390
3391         if(ssid == NULL)
3392         {
3393                 WDP_LOGE( "Incorrect parameter");
3394                 return -1;
3395         }
3396
3397         strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
3398         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3399         WDP_LOGD( "__send_wpa_request(STATUS) result=[%d]\n", result);
3400
3401         if (result < 0)
3402         {
3403                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3404                 __WDP_LOG_FUNC_EXIT__;
3405                 return -1;
3406         }
3407
3408         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3409         {
3410                 __WDP_LOG_FUNC_EXIT__;
3411                 return -1;
3412         }
3413
3414         result = __extract_value_str(res_buffer, "\nssid", (char*) tmp_ssid);
3415         if(result <= 0)
3416         {
3417                 WDP_LOGE( "Extracting value failed\n");
3418                 return -1;
3419         }
3420         WDP_LOGD( "######    ssid [%s]         ###########\n", tmp_ssid);
3421         memcpy(ssid, tmp_ssid, len);
3422         ssid[len] = '\0';
3423
3424         __WDP_LOG_FUNC_EXIT__;
3425         return true;
3426 }
3427
3428 char* wfd_ws_get_default_interface_name()
3429 {
3430         __WDP_LOG_FUNC_ENTER__;
3431
3432         __WDP_LOG_FUNC_EXIT__;
3433
3434         return DEFAULT_IF_NAME;
3435 }
3436
3437 bool wfd_ws_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6)
3438 {
3439         __WDP_LOG_FUNC_ENTER__;
3440
3441         struct ifreq IfRequest;
3442         struct sockaddr_in* sin = NULL;
3443         int fd;
3444
3445         if (ipaddr_buf == NULL)
3446                 return false;
3447
3448         if((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0) {
3449                 WDP_LOGE( "Failed to open socket\n");
3450                 return false;
3451         }
3452
3453         memset(IfRequest.ifr_name, 0x00, DEFAULT_IF_NAME_LEN);
3454         strncpy(IfRequest.ifr_name, DEFAULT_IF_NAME, DEFAULT_IF_NAME_LEN - 1);
3455
3456         if(ioctl(fd, SIOCGIFADDR, &IfRequest) < 0) {
3457                 WDP_LOGE( "Failed to get IP\n");
3458                 close(fd);
3459                 return false;
3460         }
3461
3462         sin = (struct sockaddr_in*)&IfRequest.ifr_broadaddr;
3463         if (ipaddr_buf != NULL)
3464                 strncpy(ipaddr_buf, (char*)inet_ntoa(sin->sin_addr), len);
3465
3466         __WDP_LOG_FUNC_EXIT__;
3467         return true;
3468 }
3469
3470
3471 char* wfd_ws_get_ip()
3472 {
3473         __WDP_LOG_FUNC_ENTER__;
3474
3475         char ip_string[20] = {0,};
3476
3477         snprintf(ip_string, 20, "%s", g_local_interface_ip_address);
3478         WDP_LOGD( "################################################\n");
3479         WDP_LOGD( "######    IP = %s         ###########\n", ip_string);
3480         WDP_LOGD( "################################################\n");
3481
3482         __WDP_LOG_FUNC_EXIT__;
3483         return ip_string;
3484 }
3485
3486 int wfd_ws_set_wps_pin(char* pin)
3487 {
3488         __WDP_LOG_FUNC_ENTER__;
3489         if (pin != NULL) {
3490                 strncpy(g_wps_pin, pin, WPS_PIN_LEN);
3491                 g_wps_pin[WPS_PIN_LEN-1] = '\0';
3492                 WDP_LOGD( "SETTING WPS PIN = %s\n", \
3493                                 g_wps_pin);
3494         } else {
3495                 return false;
3496         }
3497         __WDP_LOG_FUNC_EXIT__;
3498         return true;
3499  }
3500
3501 int wfd_ws_get_wps_pin(char* wps_pin, int len)
3502 {
3503         __WDP_LOG_FUNC_ENTER__;
3504
3505         if (wps_pin == NULL) {
3506                 return false;
3507         }
3508         strncpy(wps_pin, g_wps_pin, WPS_PIN_LEN);
3509         wps_pin[WPS_PIN_LEN-1] = '\0';
3510         WDP_LOGD( "FILLED WPS PIN = %s\n", wps_pin);
3511         __WDP_LOG_FUNC_EXIT__;
3512         return true;
3513 }
3514
3515 int wfd_ws_generate_wps_pin()
3516 {
3517         __WDP_LOG_FUNC_ENTER__;
3518
3519         __WDP_LOG_FUNC_EXIT__;
3520         return true;
3521
3522 }
3523
3524
3525 int wfd_ws_set_ssid(char* ssid)
3526 {
3527         __WDP_LOG_FUNC_ENTER__;
3528
3529         char cmd[128] = {0, };
3530         char res_buffer[1024]={0,};
3531         int res_buffer_len = sizeof(res_buffer);
3532         int result;
3533
3534         if (ssid == NULL || strlen(ssid) == 0)
3535         {
3536                 WDP_LOGE( "Wrong SSID\n");
3537                 __WDP_LOG_FUNC_EXIT__;
3538                 return false;
3539         }
3540
3541         snprintf(cmd, sizeof(cmd), "%s device_name %s", CMD_SET_PARAM, ssid);
3542         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3543         WDP_LOGD( "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
3544
3545         if (result < 0)
3546         {
3547                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3548                 __WDP_LOG_FUNC_EXIT__;
3549                 return false;
3550         }
3551         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3552         {
3553                 __WDP_LOG_FUNC_EXIT__;
3554                 return false;
3555         }
3556         memset(cmd, 0x0, 128);
3557         memset(res_buffer, 0x0, 1024);
3558
3559         snprintf(cmd, sizeof(cmd), "%s p2p_ssid_postfix %s", CMD_SET_PARAM, ssid);
3560         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3561         WDP_LOGD( "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
3562
3563         if (result < 0)
3564         {
3565                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3566                 __WDP_LOG_FUNC_EXIT__;
3567                 return false;
3568         }
3569         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3570         {
3571                 __WDP_LOG_FUNC_EXIT__;
3572                 return false;
3573         }
3574
3575         __WDP_LOG_FUNC_EXIT__;
3576         return true;
3577 }
3578
3579 int wfd_ws_set_wpa_passphrase(char* wpa_key)
3580 {
3581         __WDP_LOG_FUNC_ENTER__;
3582
3583         __WDP_LOG_FUNC_EXIT__;
3584         return true;
3585 }
3586
3587 int wfd_ws_get_supported_wps_mode()
3588 {
3589         __WDP_LOG_FUNC_ENTER__;
3590
3591         int wps_config;
3592
3593         //TO-DO : supplicant CLI command should be supported.
3594
3595         wps_config = WIFI_DIRECT_WPS_TYPE_PBC |WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY |WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
3596
3597         return wps_config;
3598
3599         __WDP_LOG_FUNC_EXIT__;
3600         return true;
3601 }
3602
3603 int wfd_ws_get_connected_peers_count(int* peer_num)
3604 {
3605         __WDP_LOG_FUNC_ENTER__;
3606         GList *element = NULL;
3607
3608         *peer_num = 0;
3609         element = g_list_first(g_conn_peer_addr);
3610         while(element)
3611         {
3612                 (*peer_num)++;
3613                 element = g_list_next(element);
3614         }
3615         WDP_LOGD( "Connected peer number [%d]\n", *peer_num);
3616         __WDP_LOG_FUNC_EXIT__;
3617         return true;
3618 }
3619
3620
3621 int wfd_ws_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num)
3622 {
3623         __WDP_LOG_FUNC_ENTER__;
3624         int i = 0;
3625         char cmd[32] = {0, };
3626         char res_buffer[1024]={0,};
3627         int res_buffer_len = sizeof(res_buffer);
3628         char pri_dev_type[16] ={0, };
3629         GList *element = NULL;
3630         int result;
3631
3632         if(peer_list == NULL || peer_num == NULL)
3633         {
3634                 WDP_LOGD( "Incorrect parameter\n");
3635                 return false;
3636         }
3637
3638         wfd_ws_get_connected_peers_count(peer_num);
3639
3640         wfd_connected_peer_info_s *tmp_peer_list = NULL;
3641
3642         tmp_peer_list = (wfd_connected_peer_info_s*) calloc(*peer_num, sizeof(wfd_connected_peer_info_s));
3643         if(tmp_peer_list == NULL)
3644         {
3645                 WDP_LOGD( "Memory allocatin failed\n");
3646                 *peer_list = NULL;
3647                 *peer_num = 0;
3648
3649                 return false;
3650         }
3651
3652         element = g_list_first(g_conn_peer_addr);
3653         while(element)
3654         {
3655                 WDP_LOGD( "element data is [%s]\n", (char*) element->data);
3656                 memset(cmd, 0x0, 32);
3657                 memset(res_buffer, 0x0, 1024);
3658
3659                 snprintf(cmd, sizeof(cmd), "%s %s", CMD_GET_PEER_INFO, (char*) element->data);
3660                 result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3661                 WDP_LOGD( "__send_wpa_request(%s) result=[%d]\n", cmd, result);
3662
3663                 if (result < 0)
3664                 {
3665                         WDP_LOGE( "__send_wpa_request FAILED!!\n");
3666                         *peer_list = NULL;
3667                         *peer_num = 0;
3668                         if (tmp_peer_list != NULL)
3669                                 free(tmp_peer_list);
3670
3671                         __WDP_LOG_FUNC_EXIT__;
3672                         return false;
3673                 }
3674
3675                 if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3676                 {
3677                         *peer_list = NULL;
3678                         *peer_num = 0;
3679                         if (tmp_peer_list != NULL)
3680                                 free(tmp_peer_list);
3681
3682                         __WDP_LOG_FUNC_EXIT__;
3683                         return false;
3684                 }
3685
3686                 /*
3687                         typedef struct
3688                         {
3689                                 char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1];
3690                                 unsigned char ip_address[4];
3691                                 unsigned char mac_address[6];
3692                                 unsigned char intf_mac_address[6];
3693                                 unsigned int services;
3694                                 bool is_p2p;
3695                                 unsigned short category;
3696                                 int channel;
3697                         } wfd_connected_peer_info_s;
3698                  */
3699
3700                 result = __extract_value_str(res_buffer, "device_name", (char*) tmp_peer_list[i].device_name);
3701                 if(result <= 0) {
3702                         WDP_LOGE( "Extracting value failed\n");
3703                         *peer_list = NULL;
3704                         *peer_num = 0;
3705                         if (tmp_peer_list != NULL)
3706                                 free(tmp_peer_list);
3707
3708                         return false;
3709                 }
3710
3711                 wfd_macaddr_atoe((char*) element->data, tmp_peer_list[i].mac_address);
3712
3713                 char intf_mac_address[18] = {0, };
3714                 result = __extract_value_str(res_buffer, "interface_addr", (char*) intf_mac_address);
3715                 if(result <= 0)
3716                 {
3717                         WDP_LOGE( "Extracting value failed\n");
3718                         *peer_list = NULL;
3719                         *peer_num = 0;
3720                         if (tmp_peer_list != NULL)
3721                                 free(tmp_peer_list);
3722
3723                         return false;
3724                 }
3725                 wfd_macaddr_atoe((char*) intf_mac_address, tmp_peer_list[i].intf_mac_address);
3726
3727                 tmp_peer_list[i].services = 0;
3728                 tmp_peer_list[i].is_p2p = true;
3729
3730                 result = __extract_value_str(res_buffer, "pri_dev_type", (char*) pri_dev_type);
3731                 if(result <= 0)
3732                 {
3733                         WDP_LOGE( "Extracting value failed\n");
3734                         *peer_list = NULL;
3735                         *peer_num = 0;
3736                         if (tmp_peer_list != NULL)
3737                                 free(tmp_peer_list);
3738
3739                         return false;
3740                 }
3741
3742                 tmp_peer_list[i].category = __convert_category_from_type(pri_dev_type);
3743                 if(tmp_peer_list[i].category < 0)
3744                 {
3745                         WDP_LOGE( "Category converting error\n");
3746                         *peer_list = NULL;
3747                         *peer_num = 0;
3748                         if (tmp_peer_list != NULL)
3749                                 free(tmp_peer_list);
3750
3751                         return false;
3752                 }
3753
3754                 element = g_list_next(element);
3755                 i++;
3756         }
3757
3758         *peer_list = tmp_peer_list;
3759         __WDP_LOG_FUNC_EXIT__;
3760         return true;
3761 }
3762
3763
3764 int wfd_ws_get_go_intent(int *p2p_go_intent)
3765 {
3766         __WDP_LOG_FUNC_ENTER__;
3767
3768         char cmd[32] = {0, };
3769         char res_buffer[1024]={0,};
3770         int res_buffer_len = sizeof(res_buffer);
3771         int result;
3772
3773         if (p2p_go_intent == NULL)
3774         {
3775                 WDP_LOGE( "p2p_go_intent is NULL\n", p2p_go_intent);
3776                 __WDP_LOG_FUNC_EXIT__;
3777                 return false;
3778         }
3779
3780         snprintf(cmd, sizeof(cmd), "%s p2p_go_intent", CMD_GET_PARAM);
3781         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3782         WDP_LOGD( "__send_wpa_request(GET P2P_GO_INTENT) result=[%d]\n", result);
3783
3784         if (result < 0)
3785         {
3786                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3787                 __WDP_LOG_FUNC_EXIT__;
3788                 return false;
3789         }
3790
3791         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3792         {
3793                 __WDP_LOG_FUNC_EXIT__;
3794                 return false;
3795         }
3796
3797         *p2p_go_intent = atoi(res_buffer);
3798
3799         __WDP_LOG_FUNC_EXIT__;
3800         return true;
3801 }
3802
3803 int wfd_ws_set_go_intent(int go_intent)
3804 {
3805         __WDP_LOG_FUNC_ENTER__;
3806
3807         char cmd[32] = {0, };
3808         char res_buffer[1024]={0,};
3809         int res_buffer_len = sizeof(res_buffer);
3810         int result;
3811
3812         if (go_intent < 0 || go_intent > 15)
3813         {
3814                 WDP_LOGE( "Wrong p2p_go_intent [%d]\n", go_intent);
3815                 __WDP_LOG_FUNC_EXIT__;
3816                 return false;
3817         }
3818
3819         snprintf(cmd, sizeof(cmd), "%s p2p_go_intent %d", CMD_SET_PARAM, go_intent);
3820         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3821         WDP_LOGD( "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
3822
3823         if (result < 0)
3824         {
3825                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3826                 __WDP_LOG_FUNC_EXIT__;
3827                 return false;
3828         }
3829
3830         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3831         {
3832                 __WDP_LOG_FUNC_EXIT__;
3833                 return false;
3834         }
3835
3836         __WDP_LOG_FUNC_EXIT__;
3837         return true;
3838 }
3839
3840
3841 int wfd_ws_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat)
3842 {
3843         __WDP_LOG_FUNC_ENTER__;
3844
3845         char cmd[32] = {0, };
3846         char res_buffer[1024]={0,};
3847         int res_buffer_len = sizeof(res_buffer);
3848         int result;
3849
3850         snprintf(cmd, sizeof(cmd), "%s device_type %d", CMD_SET_PARAM, primary_cat);
3851         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3852         WDP_LOGD( "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
3853
3854         if (result < 0)
3855         {
3856                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3857                 __WDP_LOG_FUNC_EXIT__;
3858                 return false;
3859         }
3860
3861         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3862         {
3863                 __WDP_LOG_FUNC_EXIT__;
3864                 return false;
3865         }
3866         memset(cmd, 0x0, 32);
3867         memset(res_buffer, 0x0, 1024);
3868
3869         snprintf(cmd, sizeof(cmd), "%s device_type %d", CMD_SET_PARAM, sub_cat);
3870         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3871         WDP_LOGD( "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
3872
3873         if (result < 0)
3874         {
3875                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3876                 __WDP_LOG_FUNC_EXIT__;
3877                 return false;
3878         }
3879
3880         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3881         {
3882                 __WDP_LOG_FUNC_EXIT__;
3883                 return false;
3884         }
3885
3886         __WDP_LOG_FUNC_EXIT__;
3887         return true;
3888 }
3889
3890
3891 int wfd_ws_get_device_mac_address(unsigned char* device_mac)
3892 {
3893         __WDP_LOG_FUNC_ENTER__;
3894
3895         char cmd[8] = {0, };
3896         char device_address[18] = {0, };
3897         char res_buffer[1024]={0,};
3898         int res_buffer_len = sizeof(res_buffer);
3899         int result;
3900
3901         strncpy(cmd, CMD_STATUS, sizeof(cmd));
3902         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
3903         WDP_LOGD( "__send_wpa_request(STATUS) result=[%d]\n", result);
3904
3905         if (result < 0)
3906         {
3907                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3908                 __WDP_LOG_FUNC_EXIT__;
3909                 return -1;
3910         }
3911
3912         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3913         {
3914                 __WDP_LOG_FUNC_EXIT__;
3915                 return -1;
3916         }
3917
3918         __extract_value_str(res_buffer, "p2p_device_address", (char*) device_address);
3919         if(strlen(device_address) ==18)
3920         {
3921                 wfd_macaddr_atoe((char*) device_address, device_mac);
3922         }
3923         else
3924         {
3925                 WDP_LOGE( "Extracting value failed\n");
3926                 return -1;
3927         }
3928
3929         __WDP_LOG_FUNC_EXIT__;
3930         return 0;
3931 }
3932
3933 int wfd_ws_set_oem_loglevel(int is_increase)
3934 {
3935         __WDP_LOG_FUNC_ENTER__;
3936
3937         char cmd[16] = {0, };
3938         char res_buffer[1024]={0,};
3939         int res_buffer_len = sizeof(res_buffer);
3940         int result;
3941
3942         snprintf(cmd, sizeof(cmd), "%s %d", CMD_LOG_LEVEL, is_increase);
3943         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer,  res_buffer_len);
3944         WDP_LOGE( "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
3945
3946         if (result < 0)
3947         {
3948                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
3949                 __WDP_LOG_FUNC_EXIT__;
3950                 return false;
3951         }
3952
3953         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
3954         {
3955                 __WDP_LOG_FUNC_EXIT__;
3956                 return false;
3957         }
3958
3959         __WDP_LOG_FUNC_EXIT__;
3960         return true;
3961 }
3962
3963 int wfd_ws_get_assoc_sta_mac(unsigned char *mac_addr)
3964 {
3965         __WDP_LOG_FUNC_ENTER__;
3966
3967         memcpy(mac_addr, g_assoc_sta_mac, 6);
3968
3969         __WDP_LOG_FUNC_EXIT__;
3970         return true;
3971 }
3972
3973 int wfd_ws_get_disassoc_sta_mac(unsigned char *mac_addr)
3974 {
3975         __WDP_LOG_FUNC_ENTER__;
3976         memcpy(mac_addr, g_disassoc_sta_mac, 6);
3977         __WDP_LOG_FUNC_EXIT__;
3978         return true;
3979 }
3980
3981 int wfd_ws_get_requestor_mac(unsigned char* mac_addr)
3982 {
3983         __WDP_LOG_FUNC_ENTER__;
3984
3985         memcpy(mac_addr, g_incomming_peer_mac_address, 6);
3986
3987         __WDP_LOG_FUNC_EXIT__;
3988         return true;
3989 }
3990
3991 int wfd_ws_get_operating_channel(void)
3992 {
3993         __WDP_LOG_FUNC_ENTER__;
3994
3995         char cmd[16] = {0, };
3996         char res_buffer[1024]={0,};
3997         int res_buffer_len = sizeof(res_buffer);
3998         int result;
3999         char item[32] = {0, };
4000         char freq_value[32] = {0,};
4001         int channel;
4002
4003
4004         strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
4005         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4006         WDP_LOGD( "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
4007
4008         if (result < 0)
4009         {
4010                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
4011                 __WDP_LOG_FUNC_EXIT__;
4012                 return false;
4013         }
4014
4015         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4016         {
4017                 __WDP_LOG_FUNC_EXIT__;
4018                 return false;
4019         }
4020
4021         char* ptr = strstr(res_buffer, "frequency=");
4022         if (ptr==NULL)
4023         {
4024                 WDP_LOGD( "Can't find frequency field...\n");
4025                 __WDP_LOG_FUNC_EXIT__;
4026                 return false;
4027         }
4028
4029         if (__get_item_value(ptr, item, freq_value) == NULL)
4030         {
4031                 WDP_LOGD( "Can't get value of frequency...\n");
4032                 __WDP_LOG_FUNC_EXIT__;
4033                 return false;
4034         }
4035
4036         if (strcmp(item, "frequency")!=0)
4037         {
4038                 WDP_LOGD( "Can't get frequency.... item=[%s]\n", item);
4039                 __WDP_LOG_FUNC_EXIT__;
4040                 return false;
4041         }
4042
4043         WDP_LOGD( "freq_value=[%s]\n", freq_value);
4044
4045         channel = __convert_freq_to_channel(freq_value);
4046
4047         WDP_LOGD( "channel=[%d]\n", channel);
4048
4049         __WDP_LOG_FUNC_EXIT__;
4050         return channel;
4051
4052 }
4053
4054
4055 /* -------------------- Miracast ---------------------------*/
4056
4057
4058 int wfd_ws_dsp_init(void)
4059 {
4060         __WDP_LOG_FUNC_ENTER__;
4061
4062         char cmd[32] = {0, };
4063         char res_buffer[1024]={0,};
4064         int res_buffer_len = sizeof(res_buffer);
4065         int result;
4066
4067         int enable = 1;
4068         char* dev_info = "0400";
4069         int ctrl_port = 2022;
4070         int max_tput = 40;
4071         char* cpled_sink_status = "00";
4072
4073         /* param : enable*/
4074         snprintf(cmd, sizeof(cmd), "%s enable %d", CMD_WFD_SET, enable);
4075         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4076         WDP_LOGD( "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
4077
4078         if (result < 0)
4079         {
4080                 WDP_LOGE( "__send_wpa_request FAILED[param : enable]!!\n");
4081                 __WDP_LOG_FUNC_EXIT__;
4082                 return false;
4083         }
4084         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4085         {
4086                 __WDP_LOG_FUNC_EXIT__;
4087                 return false;
4088         }
4089
4090         /* param : dev_info */
4091         memset(cmd, 0x0, 32);
4092         memset(res_buffer, 0x0, 1024);
4093
4094         snprintf(cmd, sizeof(cmd), "%s dev_info %s", CMD_WFD_SET, dev_info);
4095         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4096         WDP_LOGD( "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
4097
4098         if (result < 0)
4099         {
4100                 WDP_LOGE( "__send_wpa_request FAILED[param : dev_info]!!\n");
4101                 __WDP_LOG_FUNC_EXIT__;
4102                 return false;
4103         }
4104         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4105         {
4106                 __WDP_LOG_FUNC_EXIT__;
4107                 return false;
4108         }
4109
4110         /* param : ctrl_port */
4111         memset(cmd, 0x0, 32);
4112         memset(res_buffer, 0x0, 1024);
4113
4114         snprintf(cmd, sizeof(cmd), "%s ctrl_port %d", CMD_WFD_SET, ctrl_port);
4115         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4116         WDP_LOGD( "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
4117
4118         if (result < 0)
4119         {
4120                 WDP_LOGE( "__send_wpa_request FAILED[param : ctrl_port]!!\n");
4121                 __WDP_LOG_FUNC_EXIT__;
4122                 return false;
4123         }
4124         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4125         {
4126                 __WDP_LOG_FUNC_EXIT__;
4127                 return false;
4128         }
4129
4130         /* param : max_tput */
4131         memset(cmd, 0x0, 32);
4132         memset(res_buffer, 0x0, 1024);
4133
4134         snprintf(cmd, sizeof(cmd), "%s max_tput %d", CMD_WFD_SET, max_tput);
4135         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4136         WDP_LOGD( "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
4137
4138         if (result < 0)
4139         {
4140                 WDP_LOGE( "__send_wpa_request FAILED[param : max_tput]!!\n");
4141                 __WDP_LOG_FUNC_EXIT__;
4142                 return false;
4143         }
4144         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4145         {
4146                 __WDP_LOG_FUNC_EXIT__;
4147                 return false;
4148         }
4149
4150         /* param : cpled_sink_status */
4151         memset(cmd, 0x0, 32);
4152         memset(res_buffer, 0x0, 1024);
4153
4154         snprintf(cmd, sizeof(cmd), "%s cpled_sink_status %s", CMD_WFD_SET, cpled_sink_status);
4155         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4156         WDP_LOGD( "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
4157
4158         if (result < 0)
4159         {
4160                 WDP_LOGE( "__send_wpa_request FAILED[param : cpled_sink_status]!!\n");
4161                 __WDP_LOG_FUNC_EXIT__;
4162                 return false;
4163         }
4164         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4165         {
4166                 __WDP_LOG_FUNC_EXIT__;
4167                 return false;
4168         }
4169
4170         __WDP_LOG_FUNC_EXIT__;
4171         return true;
4172 }
4173
4174
4175 int wfd_ws_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num)
4176 {
4177         __WDP_LOG_FUNC_ENTER__;
4178
4179         char cmd[16] = {0, };
4180         char res_buffer[1024] = {0,};
4181         int res_buffer_len = sizeof(res_buffer);
4182         int result = 0;
4183         int i;
4184         ws_network_info_s ws_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
4185         wfd_persistent_group_info_s     wfd_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
4186
4187         memset(ws_persistent_group_list, 0, (sizeof(ws_network_info_s)*MAX_PERSISTENT_GROUP_NUM));
4188         memset(wfd_persistent_group_list, 0, (sizeof(wfd_persistent_group_info_s)*MAX_PERSISTENT_GROUP_NUM));
4189
4190         /* Reading lists the configured networks, including stored information for persistent groups.
4191         The identifier in this is used with p2p_group_add and p2p_invite to indicate witch persistent
4192         group is to be reinvoked. */
4193         strncpy(cmd, CMD_GET_LIST_NETWORKS, sizeof(cmd));
4194         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4195         WDP_LOGD( "__send_wpa_request(LIST_NETWORKS) result=[%d]\n", result);
4196         if (result < 0)
4197         {
4198                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
4199                 *persistent_group_num = 0;
4200                 *persistent_group_list = NULL;
4201                 __WDP_LOG_FUNC_EXIT__;
4202                 return false;
4203         }
4204
4205         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4206         {
4207                 *persistent_group_num = 0;
4208                 *persistent_group_list = NULL;
4209                 __WDP_LOG_FUNC_EXIT__;
4210                 return false;
4211         }
4212
4213         __parsing_persistent_group(res_buffer, ws_persistent_group_list, persistent_group_num);
4214
4215         WDP_LOGD( "Persistent Group Count=%d\n", *persistent_group_num);
4216         for(i=0;i<(*persistent_group_num);i++)
4217         {
4218                 WDP_LOGD( "----persistent group [%d]----\n", i);
4219                 WDP_LOGD( "network_id=%d\n", ws_persistent_group_list[i].network_id);
4220                 WDP_LOGD( "ssid=%s\n", ws_persistent_group_list[i].ssid);
4221                 WDP_LOGD( "bssid=%s\n", ws_persistent_group_list[i].bssid);
4222                 WDP_LOGD( "flags=%s\n", ws_persistent_group_list[i].flags);
4223
4224
4225 // TODO: should filer by [PERSISTENT] value of flags.
4226
4227                 wfd_persistent_group_list[i].network_id = ws_persistent_group_list[i].network_id;
4228                 strncpy(wfd_persistent_group_list[i].ssid, ws_persistent_group_list[i].ssid, NETWORK_SSID_LEN);
4229                 wfd_persistent_group_list[i].ssid[NETWORK_SSID_LEN-1] = '\0';
4230
4231                 unsigned char la_mac_addr[6];
4232                 wfd_macaddr_atoe(ws_persistent_group_list[i].bssid, la_mac_addr);
4233                 memcpy(wfd_persistent_group_list[i].go_mac_address, la_mac_addr, 6);
4234         }
4235
4236         *persistent_group_list = &wfd_persistent_group_list[0];
4237
4238         __WDP_LOG_FUNC_EXIT__;
4239         return true;
4240
4241 }
4242
4243 int wfd_ws_remove_persistent_group(wfd_persistent_group_info_s *persistent_group)
4244 {
4245         __WDP_LOG_FUNC_ENTER__;
4246         char cmd[32] = {0, };
4247         char res_buffer[1024] = {0,};
4248         int res_buffer_len = sizeof(res_buffer);
4249         int result = 0;
4250         int i;
4251         ws_network_info_s ws_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
4252         int persistent_group_num;
4253         char go_mac_str[18];
4254
4255         memset(ws_persistent_group_list, 0, (sizeof(ws_network_info_s)*MAX_PERSISTENT_GROUP_NUM));
4256         memset(go_mac_str, 0, sizeof(go_mac_str));
4257         snprintf(go_mac_str, 18, MACSTR, MAC2STR(persistent_group->go_mac_address));
4258
4259         strncpy(cmd, CMD_GET_LIST_NETWORKS, sizeof(cmd));
4260         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4261         WDP_LOGD( "__send_wpa_request(LIST_NETWORKS) result=[%d]\n", result);
4262         if (result < 0)
4263         {
4264                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
4265                 __WDP_LOG_FUNC_EXIT__;
4266                 return false;
4267         }
4268
4269         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4270         {
4271                 __WDP_LOG_FUNC_EXIT__;
4272                 return false;
4273         }
4274
4275         __parsing_persistent_group(res_buffer, ws_persistent_group_list, &persistent_group_num);
4276
4277         WDP_LOGD( "Persistent Group Count=%d\n", persistent_group_num);
4278         for(i=0;i<persistent_group_num;i++)
4279         {
4280                 WDP_LOGD( "----persistent group [%d]----\n", i);
4281                 WDP_LOGD( "network_id=%d\n", ws_persistent_group_list[i].network_id);
4282                 WDP_LOGD( "ssid=%s\n", ws_persistent_group_list[i].ssid);
4283                 WDP_LOGD( "bssid=%s\n", ws_persistent_group_list[i].bssid);
4284                 WDP_LOGD( "flags=%s\n", ws_persistent_group_list[i].flags);
4285
4286 // TODO: should filer by [PERSISTENT] value of flags.
4287
4288
4289                         WDP_LOGD( "persistent_group->ssid [%s]----\n", persistent_group->ssid);
4290                         WDP_LOGD( "ws_persistent_group_list[i].ssid [%s]----\n", ws_persistent_group_list[i].ssid);
4291                         WDP_LOGD( "go_mac_str [%s]----\n", go_mac_str);
4292                         WDP_LOGD( "ws_persistent_group_list[i].bssid [%s]----\n", ws_persistent_group_list[i].bssid);
4293
4294                 if (strcmp(persistent_group->ssid, ws_persistent_group_list[i].ssid) == 0
4295                         && strcmp(go_mac_str, ws_persistent_group_list[i].bssid) == 0)
4296                 {
4297
4298                         WDP_LOGD( "----Found persistent group [%d]----\n", i);
4299
4300                         memset(cmd, 0x0, sizeof(cmd));
4301                         memset(res_buffer, 0x0, sizeof(res_buffer));
4302
4303                         snprintf(cmd, sizeof(cmd), "%s %d", CMD_REMOVE_NETWORK, ws_persistent_group_list[i].network_id);
4304                         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4305                         WDP_LOGD( "__send_wpa_request(CMD_REMOVE_NETWORK) result=[%d]\n", result);
4306
4307                         if (result < 0)
4308                         {
4309                                 WDP_LOGE( "__send_wpa_request FAILED[CMD_REMOVE_NETWORK]!!\n");
4310                                 __WDP_LOG_FUNC_EXIT__;
4311                                 return false;
4312                         }
4313                         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4314                         {
4315                                 __WDP_LOG_FUNC_EXIT__;
4316                                 return false;
4317                         }
4318
4319
4320                         break;
4321                 }
4322
4323         }
4324
4325
4326
4327         __WDP_LOG_FUNC_EXIT__;
4328         return true;
4329 }
4330
4331 int wfd_ws_set_persistent_reconnect(bool enabled)
4332 {
4333         __WDP_LOG_FUNC_ENTER__;
4334
4335         char cmd[128] = {0, };
4336         char res_buffer[1024]={0,};
4337         int res_buffer_len = sizeof(res_buffer);
4338         int result;
4339
4340         snprintf(cmd, sizeof(cmd), "%s persistent_reconnect %d", CMD_SET_PARAM, enabled);
4341         result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
4342         WDP_LOGD( "__send_wpa_request(SET persistent_reconnect %d) result=[%d]\n", enabled, result);
4343
4344         if (result < 0)
4345         {
4346                 WDP_LOGE( "__send_wpa_request FAILED!!\n");
4347                 __WDP_LOG_FUNC_EXIT__;
4348                 return false;
4349         }
4350         if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
4351         {
4352                 __WDP_LOG_FUNC_EXIT__;
4353                 return false;
4354         }
4355
4356         __WDP_LOG_FUNC_EXIT__;
4357         return true;
4358 }