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