src/wifi-direct-manager.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct manager functions.
  22  *
  23  * @file                wifi-direct-manager.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <dlfcn.h>
  31 #include <sys/utsname.h>
  32 #include <time.h>
  33 #include <errno.h>
  34
  35 #include <glib.h>
  36 #include <glib-object.h>
  37
  38 #include <wifi-direct.h>
  39
  40 #include "wifi-direct-ipc.h"
  41 #include "wifi-direct-manager.h"
  42 #include "wifi-direct-oem.h"
  43 #include "wifi-direct-session.h"
  44 #include "wifi-direct-group.h"
  45 #include "wifi-direct-peer.h"
  46 #include "wifi-direct-state.h"
  47 #include "wifi-direct-event.h"
  48 #include "wifi-direct-util.h"
  49 #include "wifi-direct-log.h"
  50 #include "wifi-direct-error.h"
  51 #include "wifi-direct-iface.h"
  52 #include "wifi-direct-dbus.h"
  53
  54 wfd_manager_s *g_manager;
  55
  56 wfd_manager_s *wfd_get_manager()
  57 {
  58         return g_manager;
  59 }
  60
  61 static int _wfd_local_init_device(wfd_manager_s *manager)
  62 {
  63         __WDS_LOG_FUNC_ENTER__;
  64         wfd_device_s *local = NULL;
  65         int res = 0;
  66
  67         if (!manager) {
  68                 WDS_LOGE("Invalid parameter");
  69                 return -1;
  70         }
  71
  72         errno = 0;
  73         local = (wfd_device_s*) g_try_malloc0(sizeof(wfd_device_s));
  74         if (!local) {
  75                 WDS_LOGE("Failed to allocate memory for local device [%s]", strerror(errno));
  76                 return -1;
  77         }
  78
  79         res = wfd_util_get_phone_name(local->dev_name);
  80         if (res < 0) {
  81                 WDS_LOGE("Failed to get phone name of local device. Use default device name");
  82                 g_strlcpy(local->dev_name, DEFAULT_DEVICE_NAME, DEV_NAME_LEN + 1);
  83         }
  84         WDS_LOGD("Local Device name [%s]", local->dev_name);
  85         wfd_util_set_dev_name_notification();
  86
  87         res = wfd_util_get_local_dev_mac(local->dev_addr);
  88         if (res < 0)
  89                 WDS_LOGE("Failed to get local device MAC address");
  90
  91         memcpy(local->intf_addr, local->dev_addr, MACADDR_LEN);
  92         local->intf_addr[4] ^= 0x80;
  93         WDS_LOGD("Local Interface MAC address [" MACSECSTR "]",
  94                                         MAC2SECSTR(local->intf_addr));
  95
  96         local->config_methods = WFD_WPS_MODE_PBC | WFD_WPS_MODE_DISPLAY | WFD_WPS_MODE_KEYPAD;
  97         local->wps_mode = WFD_WPS_MODE_PBC;
  98 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
  99         local->services = NULL;
 100         local->service_count = 0;
 101 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 102         /* TODO: initialize other local device datas */
 103         manager->local = local;
 104
 105         __WDS_LOG_FUNC_EXIT__;
 106         return 0;
 107 }
 108
 109 static int _wfd_local_deinit_device(wfd_manager_s *manager)
 110 {
 111         __WDS_LOG_FUNC_ENTER__;
 112
 113         if (!manager) {
 114                 WDS_LOGE("Invalid parameter");
 115                 return -1;
 116         }
 117
 118         wfd_util_unset_dev_name_notification();
 119
 120         /* TODO: free member of local device */
 121         g_free(manager->local);
 122
 123         __WDS_LOG_FUNC_EXIT__;
 124         return 0;
 125 }
 126
 127 int wfd_local_reset_data(wfd_manager_s *manager)
 128 {
 129         __WDS_LOG_FUNC_ENTER__;
 130         wfd_device_s *local = NULL;
 131
 132         if (!manager) {
 133                 WDS_LOGE("Invalid parameter");
 134                 return -1;
 135         }
 136
 137         local = manager->local;
 138         /* init local device data */
 139         local->dev_role = WFD_DEV_ROLE_NONE;
 140         local->wps_mode = WFD_WPS_MODE_PBC;
 141         memset(local->go_dev_addr, 0x0, MACADDR_LEN);
 142 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 143         memset(&(local->display), 0x0, sizeof(wfd_display_s));
 144 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 145         memset(local->ip_addr, 0x0, IPADDR_LEN);
 146
 147         __WDS_LOG_FUNC_EXIT__;
 148         return 0;
 149 }
 150
 151 int wfd_local_get_dev_name(char *dev_name)
 152 {
 153         __WDS_LOG_FUNC_ENTER__;
 154         wfd_device_s *local = g_manager->local;
 155
 156         if (!dev_name) {
 157                 WDS_LOGE("Invalid parameter");
 158                 __WDS_LOG_FUNC_EXIT__;
 159                 return -1;
 160         }
 161
 162         g_strlcpy(dev_name, local->dev_name, DEV_NAME_LEN + 1);
 163         WDS_LOGD("Local device name [%s]", dev_name);
 164
 165         __WDS_LOG_FUNC_EXIT__;
 166         return 0;
 167 }
 168
 169 int wfd_local_set_dev_name(char *dev_name)
 170 {
 171         __WDS_LOG_FUNC_ENTER__;
 172         wfd_device_s *local = g_manager->local;
 173
 174         if (!dev_name) {
 175                 WDS_LOGE("Invalid parameter");
 176                 __WDS_LOG_FUNC_EXIT__;
 177                 return -1;
 178         }
 179
 180         g_strlcpy(local->dev_name, dev_name, DEV_NAME_LEN + 1);
 181
 182         if (g_manager->state >= WIFI_DIRECT_STATE_ACTIVATED) {
 183                 wfd_oem_set_dev_name(g_manager->oem_ops, dev_name);
 184                 WDS_LOGD("Device name changed.");
 185         } else {
 186                 WDS_LOGE("Device name can't changed: state is %d", g_manager->state);
 187         }
 188
 189         __WDS_LOG_FUNC_EXIT__;
 190         return 0;
 191 }
 192
 193 int wfd_local_get_dev_mac(char *dev_mac)
 194 {
 195         __WDS_LOG_FUNC_ENTER__;
 196         wfd_device_s *local = g_manager->local;
 197
 198         if (!dev_mac) {
 199                 WDS_LOGE("Invalid parameter");
 200                 __WDS_LOG_FUNC_EXIT__;
 201                 return -1;
 202         }
 203
 204         g_snprintf(dev_mac, MACSTR_LEN, MACSTR, MAC2STR(local->dev_addr));
 205         WDS_SECLOGD("Local device MAC address [%s]", dev_mac);
 206
 207         __WDS_LOG_FUNC_EXIT__;
 208         return 0;
 209 }
 210
 211 #if 0
 212 int wfd_local_get_intf_mac(unsigned char *intf_mac)
 213 {
 214         __WDS_LOG_FUNC_ENTER__;
 215         wfd_device_s *local = g_manager->local;
 216
 217         if (!intf_mac) {
 218                 WDS_LOGE("Invalid parameter");
 219                 __WDS_LOG_FUNC_EXIT__;
 220                 return -1;
 221         }
 222
 223         g_snprintf(intf_mac, MACSTR_LEN, MACSTR, MAC2STR(local->intf_addr));
 224         WDS_SECLOGD("Local interface MAC address [%s]", intf_mac);
 225
 226         __WDS_LOG_FUNC_EXIT__;
 227         return 0;
 228 }
 229 #endif
 230
 231 int wfd_local_get_ip_addr(char *ip_str)
 232 {
 233         __WDS_LOG_FUNC_ENTER__;
 234         wfd_device_s *local = g_manager->local;
 235
 236         if (!ip_str) {
 237                 WDS_LOGE("Invalid parameter");
 238                 __WDS_LOG_FUNC_EXIT__;
 239                 return -1;
 240         }
 241
 242         snprintf(ip_str, IPSTR_LEN, IPSTR, IP2STR(local->ip_addr));
 243         WDS_SECLOGD("Local IP address [" IPSECSTR "]", IP2SECSTR(local->ip_addr));
 244
 245         __WDS_LOG_FUNC_EXIT__;
 246         return 0;
 247 }
 248
 249 int wfd_local_get_supported_wps_mode(int *config_methods)
 250 {
 251         __WDS_LOG_FUNC_ENTER__;
 252         wfd_device_s *local = g_manager->local;
 253
 254         if (!config_methods) {
 255                 WDS_LOGE("Invalid parameter");
 256                 __WDS_LOG_FUNC_EXIT__;
 257                 return -1;
 258         }
 259
 260         *config_methods = local->config_methods;
 261         WDS_LOGD("Local config method [0x%x]", *config_methods);
 262
 263         __WDS_LOG_FUNC_EXIT__;
 264         return 0;
 265 }
 266
 267 int wfd_local_get_wps_mode(int *wps_mode)
 268 {
 269         __WDS_LOG_FUNC_ENTER__;
 270         wfd_device_s *local = g_manager->local;
 271
 272         if (!wps_mode) {
 273                 WDS_LOGE("Invalid parameter");
 274                 __WDS_LOG_FUNC_EXIT__;
 275                 return -1;
 276         }
 277
 278         *wps_mode = local->wps_mode;
 279         WDS_LOGD("Local wps mode [0x%x]", *wps_mode);
 280
 281         __WDS_LOG_FUNC_EXIT__;
 282         return 0;
 283 }
 284
 285 #if 0
 286 int wfd_local_set_wps_mode(int wps_mode)
 287 {
 288         __WDS_LOG_FUNC_ENTER__;
 289         wfd_device_s *local = g_manager->local;
 290
 291         if (!wps_mode) {
 292                 WDS_LOGE("Invalid parameter");
 293                 __WDS_LOG_FUNC_EXIT__;
 294                 return -1;
 295         }
 296
 297         local->wps_mode = wps_mode;
 298         WDS_LOGD("Local wps mode [0x%x]", wps_mode);
 299
 300         __WDS_LOG_FUNC_EXIT__;
 301         return 0;
 302 }
 303 #endif
 304
 305 int wfd_manager_get_go_intent(int *go_intent)
 306 {
 307         __WDS_LOG_FUNC_ENTER__;
 308         if (!go_intent) {
 309                 WDS_LOGE("Invalid parameter");
 310                 __WDS_LOG_FUNC_EXIT__;
 311                 return -1;
 312         }
 313
 314         *go_intent = g_manager->go_intent;
 315         WDS_LOGD("Local GO intent [%d]", *go_intent);
 316
 317         __WDS_LOG_FUNC_EXIT__;
 318         return 0;
 319 }
 320
 321 int wfd_manager_set_go_intent(int go_intent)
 322 {
 323         __WDS_LOG_FUNC_ENTER__;
 324
 325         if (go_intent < 0 || go_intent > 15) {
 326                 WDS_LOGE("Invalid parameter");
 327                 __WDS_LOG_FUNC_EXIT__;
 328                 return -1;
 329         }
 330
 331         g_manager->go_intent = go_intent;
 332         if (g_manager->state >= WIFI_DIRECT_STATE_ACTIVATED)
 333                 wfd_oem_set_go_intent(g_manager->oem_ops, go_intent);
 334
 335         __WDS_LOG_FUNC_EXIT__;
 336         return 0;
 337 }
 338
 339 int wfd_manager_get_max_station(int *max_station)
 340 {
 341         __WDS_LOG_FUNC_ENTER__;
 342
 343         if (!max_station) {
 344                 WDS_LOGE("Invalid parameter");
 345                 __WDS_LOG_FUNC_EXIT__;
 346                 return -1;
 347         }
 348
 349         *max_station = g_manager->max_station;
 350         WDS_LOGD("Local max station[%d]", *max_station);
 351
 352         __WDS_LOG_FUNC_EXIT__;
 353         return 0;
 354 }
 355
 356 int wfd_manager_set_max_station(int max_station)
 357 {
 358         __WDS_LOG_FUNC_ENTER__;
 359
 360         if (max_station < 1) {
 361                 WDS_LOGE("Invalid parameter");
 362                 __WDS_LOG_FUNC_EXIT__;
 363                 return -1;
 364         }
 365
 366         g_manager->max_station = max_station;
 367
 368         __WDS_LOG_FUNC_EXIT__;
 369         return 0;
 370 }
 371
 372 int wfd_manager_get_autoconnection(int *autoconnection)
 373 {
 374         __WDS_LOG_FUNC_ENTER__;
 375         if (!autoconnection) {
 376                 WDS_LOGE("Invalid parameter");
 377                 __WDS_LOG_FUNC_EXIT__;
 378                 return -1;
 379         }
 380
 381         *autoconnection = g_manager->autoconnection;
 382         WDS_LOGD("Local autoconnection [%s]", *autoconnection ? "TRUE" : "FALSE");
 383
 384         __WDS_LOG_FUNC_EXIT__;
 385         return 0;
 386 }
 387
 388 int wfd_manager_set_autoconnection(int autoconnection)
 389 {
 390         __WDS_LOG_FUNC_ENTER__;
 391         if (autoconnection < 0) {
 392                 WDS_LOGE("Invalid parameter");
 393                 __WDS_LOG_FUNC_EXIT__;
 394                 return -1;
 395         }
 396
 397         g_manager->autoconnection = autoconnection;
 398
 399         __WDS_LOG_FUNC_EXIT__;
 400         return 0;
 401 }
 402
 403 int wfd_manager_get_req_wps_mode(int *req_wps_mode)
 404 {
 405         __WDS_LOG_FUNC_ENTER__;
 406
 407         if (!req_wps_mode) {
 408                 WDS_LOGE("Invalid parameter");
 409                 __WDS_LOG_FUNC_EXIT__;
 410                 return -1;
 411         }
 412
 413         *req_wps_mode = g_manager->req_wps_mode;
 414         WDS_LOGD("Requested wps mode [0x%x]", *req_wps_mode);
 415
 416         __WDS_LOG_FUNC_EXIT__;
 417         return 0;
 418 }
 419
 420 int wfd_manager_set_req_wps_mode(int req_wps_mode)
 421 {
 422         __WDS_LOG_FUNC_ENTER__;
 423         wfd_device_s *local = g_manager->local;
 424
 425         if (req_wps_mode != WIFI_DIRECT_WPS_TYPE_PBC &&
 426                         req_wps_mode != WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY &&
 427                         req_wps_mode != WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD) {
 428                 WDS_LOGE("Invalid parameter");
 429                 __WDS_LOG_FUNC_EXIT__;
 430                 return -1;
 431         }
 432
 433         g_manager->req_wps_mode = req_wps_mode;
 434         WDS_LOGD("Requested wps mode [0x%x]", req_wps_mode);
 435         if (req_wps_mode == WFD_WPS_MODE_DISPLAY)
 436                 local->wps_mode = WFD_WPS_MODE_KEYPAD;
 437         else if (req_wps_mode == WFD_WPS_MODE_KEYPAD)
 438                 local->wps_mode = WFD_WPS_MODE_DISPLAY;
 439         else
 440                 local->wps_mode = req_wps_mode;
 441
 442         __WDS_LOG_FUNC_EXIT__;
 443         return 0;
 444 }
 445
 446 int wfd_manager_local_config_set(wfd_manager_s *manager)
 447 {
 448         __WDS_LOG_FUNC_ENTER__;
 449         wfd_device_s *local = NULL;
 450         int res = 0;
 451
 452         if (!manager) {
 453                 WDS_LOGE("Invalid parameter");
 454                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 455         }
 456
 457         local = manager->local;
 458
 459         local->wps_mode = WFD_WPS_MODE_PBC;
 460         WDS_LOGD("Device name set as %s", local->dev_name);
 461         res = wfd_oem_set_dev_name(manager->oem_ops, local->dev_name);
 462         if (res < 0) {
 463                 WDS_LOGE("Failed to set device name");
 464                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 465         }
 466
 467         res = wfd_oem_set_dev_type(manager->oem_ops, local->pri_dev_type, local->sec_dev_type);
 468         if (res < 0) {
 469                 WDS_LOGE("Failed to set device type");
 470                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 471         }
 472
 473         res = wfd_oem_set_go_intent(manager->oem_ops, manager->go_intent);
 474         if (res < 0) {
 475                 WDS_LOGE("Failed to set go intent");
 476                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 477         }
 478
 479         return WIFI_DIRECT_ERROR_NONE;
 480 }
 481
 482 int wfd_manager_activate(wfd_manager_s *manager)
 483 {
 484         __WDS_LOG_FUNC_ENTER__;
 485         int prev_state = 0;
 486         int res = 0;
 487
 488         if (!manager) {
 489                 WDS_LOGE("Invalid parameter");
 490                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 491         }
 492
 493         if (manager->state > WIFI_DIRECT_STATE_ACTIVATING) {
 494                 WDS_LOGE("Already activated");
 495                 return 1;
 496         }
 497
 498         if (manager->state == WIFI_DIRECT_STATE_ACTIVATING) {
 499                 WDS_LOGE("In progress");
 500                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 501         }
 502
 503         res = wfd_util_wifi_direct_activatable();
 504         if (res < 0)
 505                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 506
 507         wfd_state_get(manager, &prev_state);
 508         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATING);
 509 #if defined(TIZEN_WLAN_CONCURRENT_ENABLE)
 510         res = wfd_util_check_wifi_state();
 511         if (res < 0) {
 512                 WDS_LOGE("Failed to get wifi state");
 513                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 514         } else if (res == 0) {
 515 #endif /* TIZEN_WLAN_CONCURRENT_ENABLE */
 516         res = wfd_oem_activate(manager->oem_ops, 0);
 517         if (res < 0) {
 518                 WDS_LOGE("Failed to activate");
 519                 wfd_state_set(manager, prev_state);
 520                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 521         }
 522 #if defined(TIZEN_WLAN_CONCURRENT_ENABLE)
 523         } else {
 524                 res = wfd_oem_activate(manager->oem_ops, res);
 525                 if (res < 0) {
 526                         WDS_LOGE("Failed to activate");
 527                         wfd_state_set(manager, prev_state);
 528                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 529                 }
 530         }
 531 #endif /* TIZEN_WLAN_CONCURRENT_ENABLE */
 532         WDS_LOGE("Succeeded to activate");
 533
 534         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 535         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 536
 537         wfd_manager_local_config_set(manager);
 538         wfd_util_set_country();
 539 #ifdef TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT
 540         wfd_util_start_wifi_direct_popup();
 541 #endif /* TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT */
 542
 543         res = wfd_util_get_local_dev_mac(manager->local->dev_addr);
 544         if (res < 0)
 545                 WDS_LOGE("Failed to get local device MAC address");
 546
 547         memcpy(manager->local->intf_addr, manager->local->dev_addr, MACADDR_LEN);
 548         manager->local->intf_addr[4] ^= 0x80;
 549         WDS_LOGD("Local Interface MAC address [" MACSECSTR "]",
 550                                         MAC2SECSTR(manager->local->intf_addr));
 551
 552         __WDS_LOG_FUNC_EXIT__;
 553         return WIFI_DIRECT_ERROR_NONE;
 554 }
 555
 556 int wfd_manager_deactivate(wfd_manager_s *manager)
 557 {
 558         __WDS_LOG_FUNC_ENTER__;
 559         int prev_state = 0;
 560         int res = 0;
 561
 562         if (!manager) {
 563                 WDS_LOGE("Invalid parameter");
 564                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 565         }
 566
 567         wfd_state_get(manager, &prev_state);
 568         wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATING);
 569
 570 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 571         res = wfd_oem_miracast_init(manager->oem_ops, false);
 572         if (res < 0)
 573                 WDS_LOGE("Failed to initialize miracast");
 574 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 575
 576         res = wfd_oem_destroy_group(manager->oem_ops, GROUP_IFNAME);
 577         if (res < 0)
 578                 WDS_LOGE("Failed to destroy group before deactivation");
 579
 580 #if defined(TIZEN_WLAN_CONCURRENT_ENABLE) && defined(TIZEN_MOBILE)
 581         res = wfd_util_check_wifi_state();
 582         if (res < 0) {
 583                 WDS_LOGE("Failed to get wifi state");
 584                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 585         } else if (res == 0) {
 586 #endif /* TIZEN_WLAN_CONCURRENT_ENABLE && TIZEN_MOBILE */
 587                 res = wfd_oem_deactivate(manager->oem_ops, 0);
 588                 if (res < 0) {
 589                         WDS_LOGE("Failed to deactivate");
 590                         wfd_state_set(manager, prev_state);
 591                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 592                 }
 593 #if defined(TIZEN_WLAN_CONCURRENT_ENABLE) && defined(TIZEN_MOBILE)
 594         } else {
 595                 /* FIXME: We should do something to stop p2p feature of Driver */
 596                 res = wfd_oem_deactivate(manager->oem_ops, res);
 597                 if (res < 0) {
 598                         WDS_LOGE("Failed to deactivate");
 599                         wfd_state_set(manager, prev_state);
 600                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 601                 }
 602                 WDS_LOGE("Do not need to deactivate Wi-Fi");
 603         }
 604 #endif /* TIZEN_WLAN_CONCURRENT_ENABLE && TIZEN_MOBILE */
 605         WDS_LOGE("Succeeded to deactivate");
 606
 607         wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 608         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED);
 609
 610         manager->req_wps_mode = WFD_WPS_MODE_PBC;
 611
 612         wfd_destroy_group(manager, GROUP_IFNAME);
 613         wfd_destroy_session(manager);
 614         wfd_peer_clear_all(manager);
 615         wfd_local_reset_data(manager);
 616
 617 #ifdef TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT
 618         wfd_util_stop_wifi_direct_popup();
 619 #endif /* TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT */
 620         __WDS_LOG_FUNC_EXIT__;
 621         return WIFI_DIRECT_ERROR_NONE;
 622 }
 623
 624 int wfd_manager_connect(wfd_manager_s *manager, unsigned char *peer_addr)
 625 {
 626         __WDS_LOG_FUNC_ENTER__;
 627         wfd_session_s *session = NULL;
 628         int res = 0;
 629
 630         if (!manager || !peer_addr) {
 631                 WDS_LOGE("Invalid parameter");
 632                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 633         }
 634
 635         if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
 636                         manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 637                         manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
 638                 __WDS_LOG_FUNC_EXIT__;
 639                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 640         }
 641
 642         wfd_group_s *group = (wfd_group_s*) manager->group;
 643         if (group && group->member_count >= manager->max_station) {
 644                 __WDS_LOG_FUNC_EXIT__;
 645                 return WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
 646         }
 647
 648         session = (wfd_session_s*) manager->session;
 649         if (session && session->type != SESSION_TYPE_INVITE) {
 650                 WDS_LOGE("Session already exist and it's not an invitation session");
 651                 __WDS_LOG_FUNC_EXIT__;
 652                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 653         }
 654
 655         if (!session) {
 656                 session = wfd_create_session(manager, peer_addr,
 657                                         manager->req_wps_mode, SESSION_DIRECTION_OUTGOING);
 658                 if (!session) {
 659                         WDS_LOGE("Failed to create new session");
 660                         __WDS_LOG_FUNC_EXIT__;
 661                         return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 662                 }
 663         }
 664
 665         if (manager->local->dev_role == WFD_DEV_ROLE_GO &&
 666                         session->type != SESSION_TYPE_INVITE) {
 667                 session->type = SESSION_TYPE_INVITE;
 668                 res = wfd_session_invite(session);
 669         } else {
 670                 res = wfd_session_start(session);
 671         }
 672         if (res < 0) {
 673                 WDS_LOGE("Failed to start session");
 674                 wfd_destroy_session(manager);
 675                 __WDS_LOG_FUNC_EXIT__;
 676                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 677         }
 678         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
 679
 680         __WDS_LOG_FUNC_EXIT__;
 681         return WIFI_DIRECT_ERROR_NONE;
 682 }
 683
 684 int wfd_manager_accept_connection(wfd_manager_s *manager, unsigned char *peer_addr)
 685 {
 686         __WDS_LOG_FUNC_ENTER__;
 687         wfd_session_s *session = NULL;
 688         wfd_device_s *peer = NULL;
 689         int res = 0;
 690
 691         if (!manager || !peer_addr) {
 692                 WDS_LOGE("Invalid parameter");
 693                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 694         }
 695
 696         session = (wfd_session_s*) manager->session;
 697         if (!session) {
 698                 WDS_LOGE("Session not found");
 699                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 700         }
 701
 702         peer = wfd_peer_find_by_dev_addr(manager, peer_addr);
 703         if (!peer) {
 704                 WDS_LOGE("Peer is NULL");
 705                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 706         }
 707
 708         /* TODO: check peer_addr with session's peer_addr */
 709
 710         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 711                 WDS_LOGD("My device is GO and peer want to join my group, so WPS will be started");
 712                 res = wfd_session_wps(session);
 713         } else if (peer->dev_role == WFD_DEV_ROLE_GO) {
 714                 WDS_LOGD("Peer device is GO, so Prov_Disc or Join will be started");
 715                 if (session->type == SESSION_TYPE_INVITE) {
 716                         if (session->state == SESSION_STATE_CREATED) {
 717                                 WDS_LOGD("Invitation session. PD will be started");
 718                                 res = wfd_session_start(session);
 719                         } else {
 720                                 WDS_LOGD("Invitation session. Join will be started");
 721                                 res = wfd_session_join(session);
 722                         }
 723                 } else {
 724                         if (manager->autoconnection && (manager->auto_pin[0] != 0))
 725                                 g_strlcpy(session->wps_pin, manager->auto_pin, PINSTR_LEN + 1);
 726
 727                         WDS_LOGD("Peer device is GO, so WPS will be started");
 728                         res = wfd_session_connect(session);
 729                 }
 730         } else {
 731                 /* We should wait GO_NEGO_REQ from peer(MO) in autoconnection mode. */
 732                 /* Otherwise, GO Nego is sometimes failed. */
 733                 if (manager->autoconnection == FALSE) {
 734                         WDS_LOGD("My device is Device, so Negotiation will be started");
 735                         res = wfd_session_connect(session);
 736                 }
 737         }
 738         if (res < 0) {
 739                 WDS_LOGE("Failed to start session");
 740                 if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 741                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 742                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 743                 } else {
 744                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 745                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 746                 }
 747                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 748         }
 749         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
 750
 751         __WDS_LOG_FUNC_EXIT__;
 752         return WIFI_DIRECT_ERROR_NONE;
 753 }
 754
 755
 756 int wfd_manager_cancel_connection(wfd_manager_s *manager, unsigned char *peer_addr)
 757 {
 758         __WDS_LOG_FUNC_ENTER__;
 759         wfd_group_s *group = NULL;
 760         int res = 0;
 761
 762         if (!manager || !peer_addr) {
 763                 WDS_LOGE("Invalid parameter");
 764                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
 765         }
 766
 767         if (!manager->session && manager->state != WIFI_DIRECT_STATE_CONNECTING) {
 768                 WDS_LOGE("It's not CONNECTING state");
 769                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 770         }
 771
 772         res = wfd_session_cancel(manager->session, peer_addr);
 773         if (res < 0) {
 774                 WDS_LOGE("Failed to cancel session");
 775                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 776         }
 777
 778         group = (wfd_group_s*) manager->group;
 779         if (group)
 780                 wfd_group_remove_member(group, peer_addr);
 781
 782         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 783                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 784                 if (group && group->member_count)
 785                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 786         } else {
 787                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 788                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 789         }
 790
 791         __WDS_LOG_FUNC_EXIT__;
 792         return WIFI_DIRECT_ERROR_NONE;
 793 }
 794
 795
 796 int wfd_manager_reject_connection(wfd_manager_s *manager, unsigned char *peer_addr)
 797 {
 798         __WDS_LOG_FUNC_ENTER__;
 799         wfd_session_s *session = NULL;
 800         int res = 0;
 801
 802         if (!manager || !peer_addr) {
 803                 WDS_LOGE("Invalid parameter");
 804                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 805         }
 806
 807         session = (wfd_session_s*) manager->session;
 808         if (!session) {
 809                 WDS_LOGE("Session not found");
 810                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 811         }
 812
 813         if (manager->state != WIFI_DIRECT_STATE_CONNECTING) {
 814                 WDS_LOGE("It's not permitted with this state [%d]", manager->state);
 815                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 816         }
 817
 818         if (session->direction != SESSION_DIRECTION_INCOMING) {
 819                 WDS_LOGE("Only incomming session can be rejected");
 820                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 821         }
 822
 823         res = wfd_session_reject(session, peer_addr);
 824         if (res < 0) {
 825                 WDS_LOGE("Failed to reject connection");
 826                 /* TODO: check whether set state and break */
 827         }
 828         wfd_destroy_session(manager);
 829
 830         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 831                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 832                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 833         } else {
 834                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 835                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 836         }
 837
 838         __WDS_LOG_FUNC_EXIT__;
 839         return WIFI_DIRECT_ERROR_NONE;
 840 }
 841
 842
 843 int wfd_manager_disconnect(wfd_manager_s *manager, unsigned char *peer_addr)
 844 {
 845         __WDS_LOG_FUNC_ENTER__;
 846         wfd_group_s *group = NULL;
 847         wfd_device_s *peer = NULL;
 848         int res = 0;
 849
 850         if (!manager) {
 851                 WDS_LOGE("Invalid parameter");
 852                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 853         }
 854
 855         if (!peer_addr) {
 856                 WDS_LOGE("Invalid parameter");
 857                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
 858         }
 859
 860         group = (wfd_group_s*) manager->group;
 861         if (!group) {
 862                 WDS_LOGE("Group not found");
 863                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 864         }
 865
 866         peer = wfd_group_find_member_by_addr(group, peer_addr);
 867         if (!peer) {
 868                 WDS_LOGE("Connected peer not found");
 869                 return WIFI_DIRECT_ERROR_INVALID_PARAMETER;
 870         }
 871
 872         wfd_state_set(manager, WIFI_DIRECT_STATE_DISCONNECTING);
 873
 874         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 875                 if (peer->is_legacy)
 876                         res = wfd_oem_disconnect(manager->oem_ops, peer->intf_addr, 1);
 877                 else
 878                         res = wfd_oem_disconnect(manager->oem_ops, peer->dev_addr, 0);
 879         } else {
 880                 res = wfd_oem_destroy_group(manager->oem_ops, group->ifname);
 881         }
 882
 883         if (res < 0) {
 884                 WDS_LOGE("Failed to disconnect peer");
 885                 res = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 886                 goto failed;
 887         }
 888         WDS_LOGE("Succeeded to disconnect peer");
 889
 890         wfd_group_remove_member(group, peer_addr);
 891         if (!group->member_count) {
 892                 wfd_oem_destroy_group(manager->oem_ops, group->ifname);
 893                 wfd_destroy_group(manager, group->ifname);
 894         }
 895
 896         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 897                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 898                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 899         } else {
 900                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 901                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 902         }
 903
 904         __WDS_LOG_FUNC_EXIT__;
 905         return WIFI_DIRECT_ERROR_NONE;
 906
 907 failed:
 908         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 909                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 910                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 911         } else {
 912                 wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTED);
 913                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTED);
 914         }
 915
 916         __WDS_LOG_FUNC_EXIT__;
 917         return res;
 918 }
 919
 920 int wfd_manager_disconnect_all(wfd_manager_s *manager)
 921 {
 922         __WDS_LOG_FUNC_ENTER__;
 923         wfd_group_s *group = NULL;
 924         int res = 0;
 925
 926         if (!manager) {
 927                 WDS_LOGE("Invalid parameter");
 928                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 929         }
 930
 931         group = (wfd_group_s*) manager->group;
 932         if (!group) {
 933                 WDS_LOGE("Group not found");
 934                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 935         }
 936
 937         wfd_state_set(manager, WIFI_DIRECT_STATE_DISCONNECTING);
 938
 939         res = wfd_oem_destroy_group(manager->oem_ops, group->ifname);
 940         if (res < 0) {
 941                 WDS_LOGE("Failed to destroy group");
 942                 res = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 943                 goto failed;
 944         }
 945         WDS_LOGE("Succeeded to disconnect all peer");
 946
 947         wfd_destroy_group(manager, group->ifname);
 948
 949         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 950         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 951
 952         __WDS_LOG_FUNC_EXIT__;
 953         return WIFI_DIRECT_ERROR_NONE;
 954
 955 failed:
 956         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 957                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 958                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 959         } else {
 960                 wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTED);
 961                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTED);
 962         }
 963
 964         __WDS_LOG_FUNC_EXIT__;
 965         return res;
 966 }
 967
 968 int wfd_manager_get_peer_info(wfd_manager_s *manager, unsigned char *addr, wfd_discovery_entry_s **peer)
 969 {
 970         __WDS_LOG_FUNC_ENTER__;
 971         wfd_device_s *peer_dev = NULL;
 972         wfd_discovery_entry_s *peer_info;
 973         wfd_oem_device_s *oem_dev = NULL;
 974         int res = 0;
 975
 976         if (!manager || !addr) {
 977                 WDS_LOGE("Invalid parameter");
 978                 return -1;
 979         }
 980
 981         unsigned long time = 0;
 982 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
 983         wfd_util_get_current_time(&time);
 984 #else
 985         struct timeval tval;
 986         gettimeofday(&tval, NULL);
 987         time = tval.tv_sec;
 988 #endif
 989         WDS_LOGI("Current time [%ld]", time);
 990
 991         res = wfd_oem_get_peer_info(manager->oem_ops, addr, &oem_dev);
 992         if (res < 0 || !oem_dev) {
 993                 WDS_LOGE("Failed to get peer information");
 994                 return -1;
 995         }
 996
 997         peer_dev = wfd_peer_find_by_addr(manager, addr);
 998         if (!peer_dev) {
 999                 peer_dev = (wfd_device_s*) g_try_malloc0(sizeof(wfd_device_s));
1000                 if (!peer_dev) {
1001                         WDS_LOGE("Failed to allocate memory for peer device. [%s]", strerror(errno));
1002                         free(oem_dev);
1003                         return -1;
1004                 }
1005                 memcpy(peer_dev->dev_addr, addr, MACADDR_LEN);
1006                 manager->peers = g_list_prepend(manager->peers, peer_dev);
1007                 manager->peer_count++;
1008                 peer_dev->time = time;
1009                 WDS_LOGD("peer_count[%d]", manager->peer_count);
1010         } else {
1011                 if (oem_dev->age > 30 && peer_dev->state == WFD_PEER_STATE_DISCOVERED) {
1012                         WDS_LOGE("Too old age to update peer");
1013                         free(oem_dev);
1014                         return -1;
1015                 }
1016         }
1017
1018         g_strlcpy(peer_dev->dev_name, oem_dev->dev_name, DEV_NAME_LEN + 1);
1019         memcpy(peer_dev->intf_addr, oem_dev->intf_addr, MACADDR_LEN);
1020         memcpy(peer_dev->go_dev_addr, oem_dev->go_dev_addr, MACADDR_LEN);
1021         peer_dev->dev_role = oem_dev->dev_role;
1022         peer_dev->config_methods = oem_dev->config_methods;
1023         peer_dev->pri_dev_type = oem_dev->pri_dev_type;
1024         peer_dev->sec_dev_type = oem_dev->sec_dev_type;
1025         peer_dev->dev_flags = oem_dev->dev_flags;
1026         peer_dev->group_flags = oem_dev->group_flags;
1027         peer_dev->wps_mode =  oem_dev->wps_mode;
1028
1029 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1030         memcpy(&(peer_dev->display), &(oem_dev->display), sizeof(wfd_display_s));
1031 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
1032
1033         peer_dev->time = time;
1034         peer_dev->channel = oem_dev->channel;
1035
1036         free(oem_dev);
1037
1038         peer_info = (wfd_discovery_entry_s*) g_try_malloc0(sizeof(wfd_discovery_entry_s));
1039         if (!(peer_info)) {
1040                 WDS_LOGE("Failed to allocate memory for peer data. [%s]", strerror(errno));
1041                 return -1;
1042         }
1043
1044         g_strlcpy(peer_info->device_name, peer_dev->dev_name, DEV_NAME_LEN + 1);
1045         memcpy(peer_info->mac_address, peer_dev->dev_addr, MACADDR_LEN);
1046         memcpy(peer_info->intf_address, peer_dev->intf_addr, MACADDR_LEN);
1047         peer_info->channel = peer_dev->channel;
1048 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1049         peer_info->services = 0;
1050 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1051         peer_info->is_group_owner = peer_dev->dev_role == WFD_DEV_ROLE_GO;
1052         peer_info->is_persistent_go = peer_dev->group_flags & WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
1053         peer_info->is_connected = peer_dev->dev_role == WFD_DEV_ROLE_GC;
1054         peer_info->wps_device_pwd_id = 0;
1055         peer_info->wps_cfg_methods = peer_dev->config_methods;
1056         peer_info->category = peer_dev->pri_dev_type;
1057         peer_info->subcategory = peer_dev->sec_dev_type;
1058
1059 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1060         if (peer_dev->display.availability && peer_dev->display.port)
1061                 peer_info->is_wfd_device = 1;
1062 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
1063
1064         *peer = peer_info;
1065
1066         __WDS_LOG_FUNC_EXIT__;
1067         return res;
1068 }
1069
1070
1071 int wfd_manager_get_peers(wfd_manager_s *manager, wfd_discovery_entry_s **peers_data)
1072 {
1073         __WDS_LOG_FUNC_ENTER__;
1074         GList *temp = NULL;
1075         wfd_device_s *peer = NULL;
1076         wfd_discovery_entry_s *peers = NULL;
1077         int peer_count = 0;
1078         int count = 0;
1079         int res = 0;
1080
1081         if (!manager || !peers_data) {
1082                 WDS_LOGE("Invalid parameter");
1083                 return -1;
1084         }
1085
1086         unsigned long time = 0;
1087 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
1088         wfd_util_get_current_time(&time);
1089 #else
1090         struct timeval tval;
1091         gettimeofday(&tval, NULL);
1092         time = tval.tv_sec;
1093 #endif
1094         WDS_LOGI("Current time [%ld]", time);
1095
1096         peer_count = manager->peer_count;
1097         WDS_LOGI("peer count [%ld]", peer_count);
1098         if (peer_count < 0)
1099                 return -1;
1100         else if (peer_count == 0)
1101                 return 0;
1102
1103         errno = 0;
1104         peers = (wfd_discovery_entry_s*) g_try_malloc0_n(peer_count, sizeof(wfd_discovery_entry_s));
1105         if (!peers) {
1106                 WDS_LOGE("Failed to allocate memory for peer data. [%s]", strerror(errno));
1107                 return -1;
1108         }
1109
1110         temp = g_list_first(manager->peers);
1111         while (temp && count < peer_count) {
1112                 peer = temp->data;
1113                 if (!peer)
1114                         goto next;
1115                 if (peer->time + 8 < time) {
1116                         WDS_LOGD("Device data is too old to report to application [%s]", peer->dev_name);
1117                         res = wfd_update_peer(manager, peer);
1118                         if (res < 0) {
1119                                 WDS_LOGE("This device is disappeared [%s]", peer->dev_name);
1120                                 temp = g_list_next(temp);
1121                                 manager->peers = g_list_remove(manager->peers, peer);
1122                                 manager->peer_count--;
1123                                 g_free(peer);
1124                                 peer = NULL;
1125                                 continue;
1126                         }
1127                 }
1128
1129                 g_strlcpy(peers[count].device_name, peer->dev_name, DEV_NAME_LEN + 1);
1130                 memcpy(peers[count].mac_address, peer->dev_addr, MACADDR_LEN);
1131                 memcpy(peers[count].intf_address, peer->intf_addr, MACADDR_LEN);
1132                 peers[count].channel = peer->channel;
1133 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1134                 peers[count].services = 0;
1135 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1136                 peers[count].is_group_owner = peer->dev_role == WFD_DEV_ROLE_GO;
1137                 peers[count].is_persistent_go = peer->group_flags & WFD_OEM_GROUP_FLAG_PERSISTENT_GROUP;
1138                 peers[count].is_connected = peer->dev_role == WFD_DEV_ROLE_GC;
1139                 peers[count].wps_device_pwd_id = 0;
1140                 peers[count].wps_cfg_methods = peer->config_methods;
1141                 peers[count].category = peer->pri_dev_type;
1142                 peers[count].subcategory = peer->sec_dev_type;
1143
1144 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1145                 if (peer->display.availability && peer->display.port)
1146                         peers[count].is_wfd_device = 1;
1147 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
1148                 count++;
1149                 WDS_LOGD("%dth peer [%s]", count, peer->dev_name);
1150 next:
1151                 temp = g_list_next(temp);
1152                 peer = NULL;
1153         }
1154         WDS_LOGD("%d peers converted", count);
1155         WDS_LOGD("Final peer count is %d", manager->peer_count);
1156
1157         *peers_data = peers;
1158
1159         __WDS_LOG_FUNC_EXIT__;
1160         return count;
1161 }
1162
1163 int wfd_manager_get_connected_peers(wfd_manager_s *manager, wfd_connected_peer_info_s **peers_data)
1164 {
1165         __WDS_LOG_FUNC_ENTER__;
1166         wfd_connected_peer_info_s *peers = NULL;
1167         wfd_group_s *group = NULL;
1168         wfd_device_s *peer = NULL;
1169         GList *temp = NULL;
1170         int peer_count = 0;
1171         int count = 0;
1172
1173         if (!manager || !peers_data) {
1174                 WDS_LOGE("Invalid parameter");
1175                 return -1;
1176         }
1177
1178         group = manager->group;
1179         if (!group) {
1180                 WDS_LOGE("Group not exist");
1181                 return -1;
1182         }
1183
1184         peer_count = group->member_count;
1185         if (peer_count == 0) {
1186                 WDS_LOGD("Member not exist");
1187                 return 0;
1188         }
1189
1190         errno = 0;
1191         peers = (wfd_connected_peer_info_s*) g_try_malloc0_n(peer_count, sizeof(wfd_connected_peer_info_s));
1192         if (!peers) {
1193                 WDS_LOGE("Failed to allocate memory for connected peer data. [%s]", strerror(errno));
1194                 return -1;
1195         }
1196
1197         temp = g_list_first(group->members);
1198         while (temp && count < group->member_count) {
1199                 peer = temp->data;
1200                 {
1201                         g_strlcpy(peers[count].device_name, peer->dev_name, DEV_NAME_LEN + 1);
1202                         memcpy(peers[count].mac_address, peer->dev_addr, MACADDR_LEN);
1203                         memcpy(peers[count].intf_address, peer->intf_addr, MACADDR_LEN);
1204                         memcpy(peers[count].ip_address, peer->ip_addr, IPADDR_LEN);
1205                         peers[count].category = peer->pri_dev_type;
1206                         peers[count].subcategory = peer->sec_dev_type;
1207                         peers[count].channel = peer->channel;
1208                         peers[count].is_p2p = 1;
1209 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1210                         peers[count].services = 0;
1211 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1212
1213 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1214                         if (peer->display.availability && peer->display.port)
1215                                 peers[count].is_wfd_device = 1;
1216
1217 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
1218
1219                         WDS_LOGD("%dth member converted[%s]", count, peers[count].device_name);
1220                         count++;
1221                 }
1222                 temp = g_list_next(temp);
1223                 peer = NULL;
1224         }
1225         WDS_LOGD("%d members converted", count);
1226
1227         *peers_data = peers;
1228
1229         __WDS_LOG_FUNC_EXIT__;
1230         return count;
1231 }
1232
1233 #if 0
1234 wfd_device_s *wfd_manager_find_connected_peer(wfd_manager_s *manager, unsigned char *peer_addr)
1235 {
1236         __WDS_LOG_FUNC_ENTER__;
1237         wfd_device_s *peer = NULL;
1238
1239         if (!manager || !peer_addr) {
1240                 WDS_LOGE("Invalid parameter");
1241                 return NULL;
1242         }
1243
1244         peer = wfd_group_find_member_by_addr(manager->group, peer_addr);
1245
1246         __WDS_LOG_FUNC_EXIT__;
1247         return peer;
1248 }
1249 #endif
1250
1251 int wfd_manager_get_goup_ifname(char **ifname)
1252 {
1253         __WDS_LOG_FUNC_ENTER__;
1254         wfd_group_s *group = g_manager->group;
1255
1256         if (!ifname) {
1257                 WDS_LOGE("Invalid parameter");
1258                 __WDS_LOG_FUNC_EXIT__;
1259                 return -1;
1260         }
1261
1262         if (!group) {
1263                 WDS_LOGE("Group not exist");
1264                 return -1;
1265         }
1266
1267         *ifname = group->ifname;
1268
1269         __WDS_LOG_FUNC_EXIT__;
1270         return 0;
1271 }
1272
1273 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1274 int wfd_manager_set_display_device(int type, int port, int hdcp)
1275 {
1276         __WDS_LOG_FUNC_ENTER__;
1277         wfd_device_s * device = g_manager->local;
1278         wfd_oem_display_s display;
1279         int res = 0;
1280
1281         if (!device) {
1282                 WDS_LOGE("Invalid parameter");
1283                 __WDS_LOG_FUNC_EXIT__;
1284                 return -1;
1285         }
1286
1287         memset(&display, 0x0, sizeof(wfd_oem_display_s));
1288
1289         display.type = type;
1290         display.port = port;
1291         display.hdcp_support = hdcp;
1292
1293         display.availability = device->display.availability;
1294         display.max_tput = device->display.max_tput;
1295
1296         res = wfd_oem_set_display(g_manager->oem_ops, (wfd_oem_display_s*)&display);
1297         if (res < 0) {
1298                 WDS_LOGE("Failed to set wifi display");
1299                 return -1;
1300         }
1301
1302         device->display.type = type;
1303         device->display.port = port;
1304         device->display.hdcp_support = hdcp;
1305
1306         __WDS_LOG_FUNC_EXIT__;
1307         return res;
1308 }
1309
1310 int wfd_manager_set_session_availability(int availability)
1311 {
1312         __WDS_LOG_FUNC_ENTER__;
1313         wfd_device_s * device = g_manager->local;
1314         wfd_oem_display_s display;
1315         int res = 0;
1316
1317         if (!device) {
1318                 WDS_LOGE("Invalid parameter");
1319                 __WDS_LOG_FUNC_EXIT__;
1320                 return -1;
1321         }
1322
1323         memset(&display, 0x0, sizeof(wfd_oem_display_s));
1324
1325         display.availability = availability;
1326
1327         display.type = device->display.type;
1328         display.hdcp_support = device->display.hdcp_support;
1329         display.port = device->display.port;
1330         display.max_tput = device->display.max_tput;
1331
1332         res = wfd_oem_set_display(g_manager->oem_ops, (wfd_oem_display_s*)&display);
1333         if (res < 0) {
1334                 WDS_LOGE("Failed to set wifi display session availability");
1335                 return -1;
1336         }
1337
1338         device->display.availability = availability;
1339
1340         __WDS_LOG_FUNC_EXIT__;
1341         return res;
1342 }
1343
1344 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
1345
1346 int wfd_manager_start_discovery(wfd_manager_s *manager, int mode, int timeout,
1347                                 const char* type, int channel)
1348 {
1349         __WDS_LOG_FUNC_ENTER__;
1350         int res = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1351         wfd_oem_scan_param_s param;
1352         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
1353
1354         WDS_LOGI("Mode: [%d], Timeout: [%d], type: [%s]", mode, timeout, type, channel);
1355
1356         if (manager->local->dev_role == WFD_DEV_ROLE_GO)
1357                 param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
1358
1359         if (channel == WFD_DISCOVERY_FULL_SCAN) {
1360                 param.scan_type = WFD_OEM_SCAN_TYPE_FULL;
1361         } else if (channel == WFD_DISCOVERY_SOCIAL_CHANNEL) {
1362                 param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
1363         } else if (channel == WFD_DISCOVERY_CHANNEL1) {
1364                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL1;
1365                 param.freq = 2412;
1366         } else if (channel == WFD_DISCOVERY_CHANNEL6) {
1367                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL6;
1368                 param.freq = 2437;
1369         } else if (channel == WFD_DISCOVERY_CHANNEL11) {
1370                 param.scan_type = WFD_OEM_SCAN_TYPE_CHANNEL11;
1371                 param.freq = 2462;
1372         } else {
1373                 param.scan_type = WFD_OEM_SCAN_TYPE_SPECIFIC;
1374                 param.freq = wfd_util_channel_to_freq(channel);
1375         }
1376
1377         if (mode)
1378                 param.scan_mode = WFD_OEM_SCAN_MODE_PASSIVE;
1379         else
1380                 param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
1381
1382         param.scan_time = timeout;
1383
1384         res = wfd_oem_start_scan(manager->oem_ops, &param);
1385         if (res < 0) {
1386                 WDS_LOGE("Failed to start scan");
1387                 __WDS_LOG_FUNC_EXIT__;
1388                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1389         }
1390
1391         if (mode)
1392                 manager->scan_mode = WFD_SCAN_MODE_PASSIVE;
1393         else
1394                 manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
1395
1396         if (manager->local->dev_role != WFD_DEV_ROLE_GO) {
1397                 wfd_state_set(manager, WIFI_DIRECT_STATE_DISCOVERING);
1398                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DISCOVERING);
1399         }
1400
1401         WDS_LOGD("Succeeded to start scan");
1402         __WDS_LOG_FUNC_EXIT__;
1403         return WIFI_DIRECT_ERROR_NONE;
1404 }
1405
1406 int wfd_manager_cancel_discovery(wfd_manager_s *manager)
1407 {
1408         __WDS_LOG_FUNC_ENTER__;
1409         int res = 0;
1410
1411         res = wfd_oem_stop_scan(manager->oem_ops);
1412         if (res < 0) {
1413                 WDS_LOGE("Failed to stop scan");
1414                 __WDS_LOG_FUNC_EXIT__;
1415                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
1416         }
1417
1418         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1419                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1420                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1421         } else {
1422                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1423                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1424         }
1425
1426         WDS_LOGD("Succeeded to stop scan");
1427         __WDS_LOG_FUNC_EXIT__;
1428         return WIFI_DIRECT_ERROR_NONE;
1429 }
1430
1431 wfd_device_s *wfd_manager_get_peer_by_addr(wfd_manager_s *manager, unsigned char *peer_addr)
1432 {
1433         __WDS_LOG_FUNC_ENTER__;
1434         wfd_device_s *peer = NULL;
1435         if (manager->group)
1436                 peer = wfd_group_find_member_by_addr(manager->group, peer_addr);
1437
1438         if (peer)
1439                 return peer;
1440
1441         peer = wfd_peer_find_by_addr(manager, peer_addr);
1442
1443         __WDS_LOG_FUNC_EXIT__;
1444         return peer;
1445 }
1446
1447 static wfd_manager_s *wfd_manager_init()
1448 {
1449         __WDS_LOG_FUNC_ENTER__;
1450         wfd_manager_s *manager = NULL;
1451         int res = 0;
1452
1453         manager = (wfd_manager_s*) g_try_malloc0(sizeof(wfd_manager_s));
1454         if (!manager) {
1455                 WDS_LOGE("Failed to allocate memory for wfd_manager structure");
1456                 return NULL;
1457         }
1458
1459         manager->go_intent = 7;
1460         manager->req_wps_mode = WFD_WPS_MODE_PBC;
1461         manager->max_station = 8;
1462         manager->session_timer = 120;
1463         manager->auto_group_remove_enable = TRUE;
1464         res = _wfd_local_init_device(manager);
1465         if (res < 0) {
1466                 WDS_LOGE("Failed to initialize local device");
1467                 g_free(manager);
1468                 return NULL;            /* really stop manager? */
1469         }
1470         WDS_LOGD("Succeeded to initialize local device");
1471
1472         __WDS_LOG_FUNC_EXIT__;
1473         return manager;
1474 }
1475
1476 int wfd_manager_deinit(wfd_manager_s *manager)
1477 {
1478         __WDS_LOG_FUNC_ENTER__;
1479
1480         if (!manager) {
1481                 WDS_LOGE("Invalid parameter");
1482                 __WDS_LOG_FUNC_EXIT__;
1483                 return -1;
1484         }
1485
1486         _wfd_local_deinit_device(manager);
1487
1488         g_free(manager);
1489
1490         __WDS_LOG_FUNC_EXIT__;
1491         return 0;
1492 }
1493
1494 static void *wfd_plugin_init(wfd_manager_s *manager)
1495 {
1496         __WDS_LOG_FUNC_ENTER__;
1497         void *handle;
1498         struct utsname kernel_info;
1499         int res;
1500
1501         if (!manager) {
1502                 WDS_LOGE("Invalid parameter");
1503                 __WDS_LOG_FUNC_EXIT__;
1504                 return NULL;
1505         }
1506
1507         res = uname(&kernel_info);
1508         if (res) {
1509                 WDS_LOGE("Failed to detect target type");
1510                 __WDS_LOG_FUNC_EXIT__;
1511                 return NULL;
1512         }
1513         WDS_LOGD("Node name [%s], HW ID [%s]", kernel_info.nodename, kernel_info.machine);
1514
1515         errno = 0;
1516
1517 #if defined(TIZEN_ARCH_64)
1518                 handle = dlopen(SUPPL_PLUGIN_64BIT_PATH, RTLD_NOW);
1519 #else
1520                 handle = dlopen(SUPPL_PLUGIN_PATH, RTLD_NOW);
1521 #endif
1522         if (!handle) {
1523                 WDS_LOGE("Failed to open shared object. [%s]", dlerror());
1524                 __WDS_LOG_FUNC_EXIT__;
1525                 return NULL;
1526         }
1527
1528         errno = 0;
1529         int (*plugin_load)(wfd_oem_ops_s **ops) = NULL;
1530         plugin_load = (int (*)(wfd_oem_ops_s **ops)) dlsym(handle, "wfd_plugin_load");
1531         if (!plugin_load) {
1532                 WDS_LOGE("Failed to load symbol. Error = [%s]", strerror(errno));
1533                 dlclose(handle);
1534                 __WDS_LOG_FUNC_EXIT__;
1535                 return NULL;
1536         }
1537
1538         wfd_oem_ops_s *temp_ops;
1539         (*plugin_load)(&temp_ops);
1540         manager->oem_ops = temp_ops;
1541
1542         res = wfd_oem_init(temp_ops, (wfd_oem_event_cb) wfd_process_event, manager);
1543         if (res < 0) {
1544                 WDS_LOGE("Failed to initialize OEM");
1545                 dlclose(handle);
1546                 __WDS_LOG_FUNC_EXIT__;
1547                 return NULL;
1548         }
1549         WDS_LOGD("Succeeded to initialize OEM");
1550
1551         __WDS_LOG_FUNC_EXIT__;
1552         return handle;
1553 }
1554
1555 static int wfd_plugin_deinit(wfd_manager_s *manager)
1556 {
1557         __WDS_LOG_FUNC_ENTER__;
1558
1559         if (!manager || !manager->plugin_handle) {
1560                 WDS_LOGE("Invalid parameter");
1561                 __WDS_LOG_FUNC_EXIT__;
1562                 return -1;
1563         }
1564
1565         dlclose(manager->plugin_handle);
1566         manager->plugin_handle = NULL;
1567
1568         __WDS_LOG_FUNC_EXIT__;
1569         return 0;
1570 }
1571
1572 int main(int argc, char *argv[])
1573 {
1574         __WDS_LOG_FUNC_ENTER__;
1575         GMainLoop *main_loop = NULL;
1576
1577 #if !GLIB_CHECK_VERSION(2, 32, 0)
1578         if (!g_thread_supported())
1579                 g_thread_init(NULL);
1580 #endif
1581
1582 #if !GLIB_CHECK_VERSION(2, 36, 0)
1583         g_type_init();
1584 #endif
1585
1586         /* TODO: Parsing argument */
1587         /* Wi-Fi direct connection for S-Beam can be optimized using argument */
1588
1589         /**
1590          * wfd-manager initialization
1591          */
1592         g_manager = wfd_manager_init();
1593         if (!g_manager) {
1594                 WDS_LOGE("Failed to initialize wifi-direct manager");
1595                 __WDS_LOG_FUNC_EXIT__;
1596                 return -1;
1597         }
1598         WDS_LOGD("Succeeded to initialize manager");
1599
1600         /**
1601          * wfd_manager_plugin initialization
1602          */
1603         g_manager->plugin_handle = wfd_plugin_init(g_manager);
1604         if (!g_manager->plugin_handle) {
1605                 WDS_LOGE("Failed to initialize plugin");
1606                 wfd_manager_deinit(g_manager);
1607                 __WDS_LOG_FUNC_EXIT__;
1608                 return -1;
1609         }
1610         WDS_LOGD("Succeeded to load plugin");
1611
1612         if (!wfd_manager_dbus_init()) {
1613                 WDS_LOGE("Failed to DBus");
1614                 wfd_plugin_deinit(g_manager);
1615                 wfd_manager_deinit(g_manager);
1616                 __WDS_LOG_FUNC_EXIT__;
1617                 return -1;
1618         }
1619
1620         main_loop = g_main_loop_new(NULL, FALSE);
1621         if (main_loop == NULL) {
1622                 WDS_LOGE("Failed to create GMainLoop structure");
1623                 __WDS_LOG_FUNC_EXIT__;
1624                 return -1;
1625         }
1626         g_manager->main_loop = main_loop;
1627         g_main_loop_run(main_loop);
1628
1629         wfd_manager_dbus_unregister();
1630         wfd_manager_dbus_deinit();
1631
1632         wfd_plugin_deinit(g_manager);
1633         wfd_manager_deinit(g_manager);
1634
1635         __WDS_LOG_FUNC_EXIT__;
1636         return 0;
1637 }