src/wifi-direct-event.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 event functions.
  22  *
  23  * @file                wifi-direct-event.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 <poll.h>
  31 #include <unistd.h>
  32 #include <time.h>
  33 #include <errno.h>
  34
  35 #include <glib.h>
  36
  37 #include <wifi-direct.h>
  38
  39 #include "wifi-direct-ipc.h"
  40 #include "wifi-direct-manager.h"
  41 #include "wifi-direct-oem.h"
  42 #include "wifi-direct-peer.h"
  43 #include "wifi-direct-group.h"
  44 #include "wifi-direct-session.h"
  45 #include "wifi-direct-event.h"
  46 #include "wifi-direct-state.h"
  47 #include "wifi-direct-util.h"
  48 #include "wifi-direct-error.h"
  49 #include "wifi-direct-log.h"
  50 #include "wifi-direct-dbus.h"
  51 #if defined(TIZEN_FEATURE_ASP)
  52 #include "wifi-direct-asp.h"
  53 #endif /* TIZEN_FEATURE_ASP */
  54
  55 static int _wfd_event_update_peer(wfd_manager_s *manager, wfd_oem_dev_data_s *data)
  56 {
  57         __WDS_LOG_FUNC_ENTER__;
  58
  59         wfd_device_s *peer = NULL;
  60
  61         if (!manager || !data) {
  62                 WDS_LOGE("Invalid parameter");
  63                 __WDS_LOG_FUNC_EXIT__;
  64                 return -1;
  65         }
  66
  67         peer = wfd_peer_find_by_dev_addr(manager, data->p2p_dev_addr);
  68         if (!peer) {
  69                 peer = wfd_add_peer(manager, data->p2p_dev_addr, data->name);
  70                 if (!peer) {
  71                         WDS_LOGE("Failed to add peer");
  72                         __WDS_LOG_FUNC_EXIT__;
  73                         return -1;
  74                 }
  75         } else {
  76                 if (strcmp(peer->dev_name, data->name)) {
  77                         g_strlcpy(peer->dev_name, data->name, DEV_NAME_LEN + 1);
  78                         WDS_LOGD("Device name is changed [" MACSECSTR ": %s]",
  79                                         MAC2SECSTR(peer->dev_addr), peer->dev_name);
  80                 }
  81         }
  82         peer->pri_dev_type = data->pri_dev_type;
  83         peer->sec_dev_type = data->sec_dev_type;
  84         peer->config_methods = data->config_methods;
  85         peer->dev_flags = data->dev_flags;
  86         peer->group_flags = data->group_flags;
  87         peer->dev_role = data->dev_role;
  88         peer->rssi =  data->rssi;
  89         WDS_LOGD("Peer RSSI value is %d", peer->rssi);
  90
  91 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
  92         memcpy(&(peer->display), &(data->display), sizeof(wfd_display_s));
  93 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
  94
  95 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
  96         wfd_util_get_current_time(&peer->time);
  97 #else
  98         struct timeval tval;
  99         gettimeofday(&tval, NULL);
 100         peer->time = tval.tv_sec;
 101 #endif
 102         WDS_LOGI("Update time [%s - %ld]", peer->dev_name, peer->time);
 103
 104         __WDS_LOG_FUNC_EXIT__;
 105         return 0;
 106 }
 107
 108 gboolean _wfd_connection_retry(gpointer *data)
 109 {
 110         wfd_session_s *session = (wfd_session_s*) data;
 111         if (!session) {
 112                 WDS_LOGE("Session is NULL");
 113                 __WDS_LOG_FUNC_EXIT__;
 114                 return G_SOURCE_REMOVE;
 115         }
 116
 117         switch (session->state) {
 118         case SESSION_STATE_STARTED:
 119                 WDS_LOGD("PD again");
 120                 wfd_session_start(session);
 121         break;
 122         case SESSION_STATE_GO_NEG:
 123                 WDS_LOGD("Negotiation again");
 124                 wfd_session_connect(session);
 125         break;
 126         case SESSION_STATE_WPS:
 127                 WDS_LOGD("WPS again");
 128                 wfd_session_wps(session);
 129         break;
 130         default:
 131                 WDS_LOGE("Invalid session state [%d]", session->state);
 132         break;
 133         }
 134         __WDS_LOG_FUNC_EXIT__;
 135         return G_SOURCE_REMOVE;
 136 }
 137
 138 void wfd_event_deactivated(wfd_oem_event_s *event)
 139 {
 140         __WDS_LOG_FUNC_ENTER__;
 141
 142         wfd_manager_s *manager = wfd_get_manager();
 143
 144         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 145                                      "Deactivation",
 146                                      g_variant_new("(i)", WIFI_DIRECT_ERROR_NONE));
 147
 148         wfd_destroy_group(manager);
 149         wfd_destroy_session(manager);
 150         wfd_peer_clear_all(manager);
 151         wfd_local_reset_data(manager);
 152
 153         wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 154         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED);
 155         manager->req_wps_mode = WFD_WPS_MODE_PBC;
 156
 157 #ifdef TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT
 158         wfd_util_stop_wifi_direct_popup();
 159 #endif /* TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT */
 160         __WDS_LOG_FUNC_EXIT__;
 161         return;
 162 }
 163
 164 void wfd_event_peer_found(wfd_oem_event_s *event)
 165 {
 166         __WDS_LOG_FUNC_ENTER__;
 167
 168         wfd_manager_s *manager = wfd_get_manager();
 169         wfd_oem_dev_data_s *edata = NULL;
 170         char peer_mac_address[MACSTR_LEN+1] = {0, };
 171         int res = 0;
 172
 173         edata = (wfd_oem_dev_data_s*) event->edata;
 174         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 175                 WDS_LOGE("Invalid event data");
 176                 __WDS_LOG_FUNC_EXIT__;
 177                 return;
 178         }
 179
 180         res = _wfd_event_update_peer(manager, edata);
 181         if (res < 0) {
 182                 WDS_LOGE("Failed to update peer data");
 183                 __WDS_LOG_FUNC_EXIT__;
 184                 return;
 185         }
 186
 187         if (manager->state > WIFI_DIRECT_STATE_ACTIVATING &&
 188                         manager->state != WIFI_DIRECT_STATE_CONNECTING &&
 189                         manager->state != WIFI_DIRECT_STATE_DISCONNECTING) {
 190                 snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(edata->p2p_dev_addr));
 191                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 192                                              "PeerFound",
 193                                              g_variant_new("(s)", peer_mac_address));
 194         }
 195
 196 #if defined(TIZEN_FEATURE_ASP)
 197
 198         GList *list;
 199         GVariantBuilder *builder = NULL;
 200         GVariant *params = NULL;
 201         wfd_oem_advertise_service_s *service;
 202
 203         for (list = (GList *)event->asp_services; list != NULL; list = list->next) {
 204                 service = (wfd_oem_advertise_service_s *)list->data;
 205
 206                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 207                 g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("t", service->search_id));
 208                 g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", peer_mac_address));
 209                 g_variant_builder_add(builder, "{sv}", "device_name", g_variant_new("s", edata->name));
 210                 g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
 211                 g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
 212                 if (service->service_type)
 213                         g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
 214                 params = g_variant_new("(a{sv})", builder);
 215                 g_variant_builder_unref(builder);
 216
 217                 wfd_manager_dbus_emit_signal(WFD_MANAGER_ASP_INTERFACE,
 218                                              "SearchResult",
 219                                              params);
 220         }
 221
 222         for (list = (GList *)event->asp2_services; list != NULL; list = list->next) {
 223                 service = (wfd_oem_advertise_service_s *)list->data;
 224
 225                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 226                 g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("t", service->search_id));
 227                 g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", peer_mac_address));
 228                 g_variant_builder_add(builder, "{sv}", "device_name", g_variant_new("s", edata->name));
 229                 g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
 230                 g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
 231                 if (service->service_type)
 232                         g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
 233                 if (service->instance_name)
 234                         g_variant_builder_add(builder, "{sv}", "instance_name", g_variant_new("s", service->instance_name));
 235                 params = g_variant_new("(a{sv})", builder);
 236                 g_variant_builder_unref(builder);
 237
 238                 wfd_manager_dbus_emit_signal(WFD_MANAGER_ASP_INTERFACE,
 239                                              "SearchResult",
 240                                              params);
 241         }
 242 #endif
 243         __WDS_LOG_FUNC_EXIT__;
 244         return;
 245 }
 246
 247 void wfd_event_peer_disappeared(wfd_oem_event_s *event)
 248 {
 249         __WDS_LOG_FUNC_ENTER__;
 250
 251         wfd_manager_s *manager = wfd_get_manager();
 252         wfd_session_s *session = NULL;
 253         wfd_device_s *peer = NULL;
 254         char peer_mac_address[MACSTR_LEN+1] = {0, };
 255
 256         session = manager->session;
 257         if (session != NULL && session->peer != NULL) {
 258                 peer = session->peer;
 259                 WDS_LOGD("session peer [" MACSTR "] lost peer ["  MACSTR "]", MAC2STR(peer->dev_addr),
 260                                                 MAC2STR(event->dev_addr));
 261                 if (memcmp(peer->dev_addr, event->dev_addr, MACADDR_LEN) == 0) {
 262                         WDS_LOGD("peer already in connection");
 263                         return;
 264                 }
 265         }
 266
 267         wfd_remove_peer(manager, event->dev_addr);
 268
 269         snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
 270         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 271                                      "PeerLost",
 272                                      g_variant_new("(s)", peer_mac_address));
 273
 274         __WDS_LOG_FUNC_EXIT__;
 275         return;
 276 }
 277
 278 void wfd_event_discovery_finished(wfd_oem_event_s *event)
 279 {
 280         __WDS_LOG_FUNC_ENTER__;
 281
 282         wfd_manager_s *manager = wfd_get_manager();
 283
 284         if (manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 285                         manager->state != WIFI_DIRECT_STATE_ACTIVATED) {
 286                 WDS_LOGE("Notify finding stopped when discovering or activated. [%d]", manager->state);
 287                 __WDS_LOG_FUNC_EXIT__;
 288                 return;
 289         }
 290
 291         if (manager->scan_mode == WFD_SCAN_MODE_PASSIVE) {
 292                 WDS_LOGE("During passive scan, Discover Finished event will not notified");
 293                 __WDS_LOG_FUNC_EXIT__;
 294                 return;
 295         }
 296
 297         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 298                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 299                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 300         } else {
 301                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 302                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 303         }
 304         manager->scan_mode = WFD_SCAN_MODE_NONE;
 305
 306         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 307                                      "DiscoveryFinished",
 308                                      NULL);
 309
 310         __WDS_LOG_FUNC_EXIT__;
 311         return;
 312 }
 313
 314 void wfd_event_prov_disc_req(wfd_oem_event_s *event)
 315 {
 316         __WDS_LOG_FUNC_ENTER__;
 317
 318         wfd_manager_s *manager = wfd_get_manager();
 319         wfd_device_s *peer = NULL;
 320         wfd_device_s *member = NULL;
 321         int res = 0;
 322         wfd_group_s *group = (wfd_group_s*) manager->group;
 323
 324         if (group && group->role == WFD_DEV_ROLE_GC) {
 325                 WDS_LOGD("Device has GC role - ignore this provision request");
 326                 __WDS_LOG_FUNC_EXIT__;
 327                 return;
 328         }
 329
 330         member = wfd_group_find_member_by_addr(group,  event->dev_addr);
 331         if (member) {
 332                 /* PD request can be arrived from peer device
 333                  * when connection is timeout to close connection */
 334                 WDS_LOGE("Unexpected Event - Member already exist");
 335                 __WDS_LOG_FUNC_EXIT__;
 336                 return;
 337         }
 338
 339         wfd_oem_dev_data_s *edata = NULL;
 340
 341         edata = (wfd_oem_dev_data_s*) event->edata;
 342         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 343                 WDS_LOGE("Invalid event data");
 344                 __WDS_LOG_FUNC_EXIT__;
 345                 return;
 346         }
 347
 348         res = _wfd_event_update_peer(manager, edata);
 349         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 350
 351         if (WFD_DEV_ROLE_GO != manager->local->dev_role) {
 352                 WDS_LOGI("TV is not GO, updated peer data only.");
 353
 354                 manager->local->wps_mode = event->wps_mode;
 355                 if (event->wps_mode == WFD_WPS_MODE_PBC ||
 356                                 event->wps_mode == WFD_WPS_MODE_KEYPAD) {
 357                         __WDS_LOG_FUNC_EXIT__;
 358                         return;
 359                 }
 360         }
 361
 362         if (peer)
 363                 peer->state = WFD_PEER_STATE_CONNECTING;
 364
 365         res = wfd_session_process_event(manager, event);
 366         if (res < 0)
 367                 WDS_LOGE("Failed to process event of session");
 368
 369         __WDS_LOG_FUNC_EXIT__;
 370         return;
 371 }
 372
 373 void wfd_event_prov_disc_resp(wfd_oem_event_s *event)
 374 {
 375         __WDS_LOG_FUNC_ENTER__;
 376
 377         wfd_manager_s *manager = wfd_get_manager();
 378         wfd_device_s *peer = NULL;
 379         int res = 0;
 380
 381         wfd_oem_dev_data_s *edata = NULL;
 382
 383         edata = (wfd_oem_dev_data_s*) event->edata;
 384         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 385                 WDS_LOGE("Invalid event data");
 386                 __WDS_LOG_FUNC_EXIT__;
 387                 return;
 388         }
 389
 390         res = _wfd_event_update_peer(manager, edata);
 391         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 392         if (peer)
 393                 peer->state = WFD_PEER_STATE_CONNECTING;
 394
 395         res = wfd_session_process_event(manager, event);
 396         if (res < 0)
 397                 WDS_LOGE("Failed to process event of session");
 398
 399         __WDS_LOG_FUNC_EXIT__;
 400         return;
 401 }
 402
 403 void wfd_event_prov_disc_fail(wfd_oem_event_s *event)
 404 {
 405         __WDS_LOG_FUNC_ENTER__;
 406
 407         wfd_manager_s *manager = wfd_get_manager();
 408         wfd_session_s *session = NULL;
 409         unsigned char *peer_addr = NULL;
 410         char peer_mac_address[MACSTR_LEN+1] = {0, };
 411 #if defined(TIZEN_FEATURE_ASP)
 412         wfd_oem_asp_prov_s *prov_params = NULL;
 413         prov_params = (wfd_oem_asp_prov_s *)event->edata;
 414 #endif
 415
 416         session = (wfd_session_s*) manager->session;
 417         if (!session) {
 418                 WDS_LOGE("Unexpected event. Session not exist");
 419                 __WDS_LOG_FUNC_EXIT__;
 420                 return;
 421         }
 422
 423         peer_addr = wfd_session_get_peer_addr(session);
 424         if (!peer_addr) {
 425                 WDS_LOGE("Session do not have peer");
 426                 __WDS_LOG_FUNC_EXIT__;
 427                 return;
 428         }
 429 #if defined(TIZEN_FEATURE_ASP)
 430         if (!ISZEROMACADDR(session->session_mac)) {
 431                 /* This connection is for ASP session */
 432                 if (prov_params->status == WFD_OEM_SC_FAIL_INVALID_PARAMS) {
 433                         wfd_oem_scan_param_s param;
 434
 435                         WDS_LOGD("ASP prov disc deferred. wait response.");
 436                         wfd_asp_connect_status(session->session_mac,
 437                                                                 session->session_id,
 438                                                                 ASP_CONNECT_STATUS_REQUEST_DEFERRED,
 439                                                                 NULL);
 440                         /* start listen to wait for provision discovery request from peer */
 441                         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 442                         param.scan_mode = WFD_OEM_SCAN_MODE_PASSIVE;
 443                         wfd_oem_start_scan(manager->oem_ops, &param);
 444                         __WDS_LOG_FUNC_EXIT__;
 445                         return;
 446                 }
 447         }
 448 #endif
 449         snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 450         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 451                                      "Connection",
 452                                      g_variant_new("(iis)",
 453                                                    WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 454                                                    WFD_EVENT_CONNECTION_RSP,
 455                                                    peer_mac_address));
 456 #if defined(TIZEN_FEATURE_ASP)
 457         WDS_LOGD("ASP prov disc failed. remove session.");
 458         wfd_asp_connect_status(session->session_mac,
 459                                                 session->session_id,
 460                                                 ASP_CONNECT_STATUS_REQUEST_FAILED,
 461                                                 NULL);
 462 #endif
 463
 464         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 465                 wfd_group_s *group = (wfd_group_s*) manager->group;
 466                 if (group && !group->member_count &&
 467                     wfd_util_is_remove_group_allowed()) {
 468                         wfd_destroy_group(manager);
 469
 470                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 471                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 472                 } else {
 473                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 474                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 475                 }
 476         } else {
 477                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 478                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 479         }
 480
 481         wfd_destroy_session(manager);
 482
 483         wfd_oem_refresh(manager->oem_ops);
 484 #if 0
 485         /* After connection failed, scan again */
 486         wfd_oem_scan_param_s param;
 487         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 488         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 489         param.scan_time = 2;
 490         param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 491         wfd_oem_start_scan(manager->oem_ops, &param);
 492         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
 493 #endif
 494         __WDS_LOG_FUNC_EXIT__;
 495         return;
 496 }
 497
 498 void wfd_event_go_neg_req(wfd_oem_event_s *event)
 499 {
 500         __WDS_LOG_FUNC_ENTER__;
 501
 502         wfd_manager_s *manager = wfd_get_manager();
 503         wfd_group_s *group = (wfd_group_s*) manager->group;
 504         if (group && group->role == WFD_DEV_ROLE_GC) {
 505                 WDS_LOGD("Device has GC role - ignore this go neg request");
 506                 __WDS_LOG_FUNC_EXIT__;
 507                 return;
 508         }
 509
 510         wfd_oem_dev_data_s *edata = NULL;
 511         int res = 0;
 512
 513         edata = (wfd_oem_dev_data_s*) event->edata;
 514         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 515                 WDS_LOGE("Invalid event data");
 516                 __WDS_LOG_FUNC_EXIT__;
 517                 return;
 518         }
 519
 520         res = _wfd_event_update_peer(manager, edata);
 521         if (res < 0) {
 522                 WDS_LOGE("Failed to update peer data");
 523                 __WDS_LOG_FUNC_EXIT__;
 524                 return;
 525         }
 526
 527         wfd_session_process_event(manager, event);
 528         __WDS_LOG_FUNC_EXIT__;
 529         return;
 530 }
 531
 532 void wfd_event_go_neg_fail(wfd_oem_event_s *event)
 533 {
 534         __WDS_LOG_FUNC_ENTER__;
 535
 536         wfd_manager_s *manager = wfd_get_manager();
 537         wfd_session_s *session = NULL;
 538         wfd_oem_conn_data_s *edata = NULL;
 539         unsigned char *peer_addr = NULL;
 540         char peer_mac_address[MACSTR_LEN] = {0, };
 541
 542         session = (wfd_session_s*) manager->session;
 543         if (!session) {
 544                 WDS_LOGE("Unexpected event. Session not exist");
 545                 __WDS_LOG_FUNC_EXIT__;
 546                 return;
 547         }
 548
 549         peer_addr = wfd_session_get_peer_addr(session);
 550         if (!peer_addr) {
 551                 WDS_LOGE("Session do not have peer");
 552                 __WDS_LOG_FUNC_EXIT__;
 553                 return;
 554         }
 555
 556         edata = (wfd_oem_conn_data_s*) event->edata;
 557         if (!edata) {
 558                 WDS_LOGE("Invalid p2p connection data");
 559                 __WDS_LOG_FUNC_EXIT__;
 560                 return;
 561         }
 562
 563         if (edata->status < 0 && session->connecting_120) {
 564                 if (session->retry_gsrc) {
 565                         g_source_remove(session->retry_gsrc);
 566                         session->retry_gsrc = 0;
 567                 }
 568                 session->retry_gsrc = g_idle_add((GSourceFunc) _wfd_connection_retry, session);
 569                 WDS_LOGD("Connection will be retried");
 570                 __WDS_LOG_FUNC_EXIT__;
 571                 return;
 572         }
 573
 574         snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 575         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 576                                      "Connection",
 577                                      g_variant_new("(iis)",
 578                                                    WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 579                                                    WFD_EVENT_CONNECTION_RSP,
 580                                                    peer_mac_address));
 581
 582 #if defined(TIZEN_FEATURE_ASP)
 583         if (!ISZEROMACADDR(session->session_mac))
 584                 wfd_asp_connect_status(session->session_mac,
 585                                                         session->session_id,
 586                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
 587                                                         NULL);
 588 #endif
 589
 590         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 591         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 592
 593         wfd_destroy_group(manager);
 594         wfd_destroy_session(manager);
 595         manager->local->dev_role = WFD_DEV_ROLE_NONE;
 596         __WDS_LOG_FUNC_EXIT__;
 597         return;
 598 }
 599
 600 void wfd_event_go_neg_done(wfd_oem_event_s *event)
 601 {
 602         __WDS_LOG_FUNC_ENTER__;
 603
 604         wfd_manager_s *manager = wfd_get_manager();
 605         wfd_session_s *session = NULL;
 606         wfd_oem_conn_data_s *edata = NULL;
 607         wfd_device_s *peer = NULL;
 608
 609         edata = (wfd_oem_conn_data_s*) event->edata;
 610         if (edata == NULL) {
 611                 WDS_LOGE("Invalid event data");
 612                 __WDS_LOG_FUNC_EXIT__;
 613                 return;
 614         }
 615
 616         session = (wfd_session_s*) manager->session;
 617         if (session && session->peer) {
 618                 peer = session->peer;
 619                 memcpy(peer->intf_addr, edata->peer_intf_addr, MACADDR_LEN);
 620         }
 621
 622         wfd_session_process_event(manager, event);
 623         __WDS_LOG_FUNC_EXIT__;
 624         return;
 625 }
 626
 627 void wfd_event_wps_fail(wfd_oem_event_s *event)
 628 {
 629         __WDS_LOG_FUNC_ENTER__;
 630
 631         wfd_manager_s *manager = wfd_get_manager();
 632         wfd_session_s *session = NULL;
 633         unsigned char *peer_addr = NULL;
 634
 635         session = (wfd_session_s*) manager->session;
 636         if (!session) {
 637                 WDS_LOGE("Unexpected event. Session not exist");
 638                 __WDS_LOG_FUNC_EXIT__;
 639                 return;
 640         }
 641
 642         peer_addr = wfd_session_get_peer_addr(session);
 643         if (!peer_addr) {
 644                 WDS_LOGE("Session do not have peer");
 645                 __WDS_LOG_FUNC_EXIT__;
 646                 return;
 647         }
 648
 649         char peer_mac_address[MACSTR_LEN+1] = {0, };
 650         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 651         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 652                                      "Connection",
 653                                      g_variant_new("(iis)",
 654                                                    WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 655                                                    WFD_EVENT_CONNECTION_RSP,
 656                                                    peer_mac_address));
 657 #if defined(TIZEN_FEATURE_ASP)
 658         if (!ISZEROMACADDR(session->session_mac))
 659                 wfd_asp_connect_status(session->session_mac,
 660                                                         session->session_id,
 661                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_STARTED,
 662                                                         NULL);
 663 #endif
 664         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 665                 wfd_group_s *group = (wfd_group_s*) manager->group;
 666                 if (group && !group->member_count &&
 667                     wfd_util_is_remove_group_allowed()) {
 668                         wfd_destroy_group(manager);
 669
 670                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 671                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 672                 } else {
 673                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 674                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 675                 }
 676         } else {
 677                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 678                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 679         }
 680
 681         wfd_destroy_session(manager);
 682
 683         wfd_oem_refresh(manager->oem_ops);
 684 #if 0
 685         /* After connection failed, scan again */
 686         wfd_oem_scan_param_s param;
 687         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 688         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 689         param.scan_time = 2;
 690         param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 691         wfd_oem_start_scan(manager->oem_ops, &param);
 692         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
 693 #endif
 694         __WDS_LOG_FUNC_EXIT__;
 695         return;
 696 }
 697
 698 void wfd_event_wps_done(wfd_oem_event_s *event)
 699 {
 700         __WDS_LOG_FUNC_ENTER__;
 701
 702         wfd_manager_s *manager = wfd_get_manager();
 703         wfd_session_process_event(manager, event);
 704
 705         __WDS_LOG_FUNC_EXIT__;
 706         return;
 707 }
 708
 709 void wfd_event_key_neg_fail(wfd_oem_event_s *event)
 710 {
 711         __WDS_LOG_FUNC_ENTER__;
 712
 713         wfd_manager_s *manager = wfd_get_manager();
 714         wfd_session_s *session = NULL;
 715         unsigned char *peer_addr = NULL;
 716         char peer_mac_address[MACSTR_LEN+1] = {0, };
 717
 718         session = (wfd_session_s*) manager->session;
 719         if (!session) {
 720                 WDS_LOGE("Unexpected event. Session not exist");
 721                 __WDS_LOG_FUNC_EXIT__;
 722                 return;
 723         }
 724
 725         peer_addr = wfd_session_get_peer_addr(session);
 726         if (!peer_addr) {
 727                 WDS_LOGE("Session do not has peer");
 728                 __WDS_LOG_FUNC_EXIT__;
 729                 return;
 730         }
 731
 732         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 733         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 734                                      "Connection",
 735                                      g_variant_new("(iis)",
 736                                                    WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 737                                                    WFD_EVENT_CONNECTION_RSP,
 738                                                    peer_mac_address));
 739 #if defined(TIZEN_FEATURE_ASP)
 740         if (!ISZEROMACADDR(session->session_mac))
 741                 wfd_asp_connect_status(session->session_mac,
 742                                                         session->session_id,
 743                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_STARTED,
 744                                                         NULL);
 745 #endif
 746         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 747                 wfd_group_s *group = (wfd_group_s*) manager->group;
 748                 if (group && !group->member_count &&
 749                     wfd_util_is_remove_group_allowed()) {
 750                         wfd_destroy_group(manager);
 751
 752                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 753                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 754                 } else {
 755                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 756                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 757                 }
 758         } else {
 759                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 760                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 761         }
 762
 763         wfd_destroy_session(manager);
 764
 765         wfd_oem_refresh(manager->oem_ops);
 766 #if 0
 767         /* After connection failed, scan again */
 768         wfd_oem_scan_param_s param;
 769         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 770         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 771         param.scan_time = 2;
 772         param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 773         wfd_oem_start_scan(manager->oem_ops, &param);
 774         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
 775 #endif
 776         __WDS_LOG_FUNC_EXIT__;
 777         return;
 778 }
 779
 780 void wfd_event_key_neg_done(wfd_oem_event_s *event)
 781 {
 782         __WDS_LOG_FUNC_ENTER__;
 783
 784         __WDS_LOG_FUNC_EXIT__;
 785         return;
 786 }
 787
 788 void wfd_event_conn_fail(wfd_oem_event_s *event)
 789 {
 790         __WDS_LOG_FUNC_ENTER__;
 791
 792         __WDS_LOG_FUNC_EXIT__;
 793         return;
 794 }
 795
 796 void wfd_event_conn_done(wfd_oem_event_s *event)
 797 {
 798         __WDS_LOG_FUNC_ENTER__;
 799
 800         __WDS_LOG_FUNC_EXIT__;
 801         return;
 802 }
 803
 804 void wfd_event_group_created(wfd_oem_event_s *event)
 805 {
 806         __WDS_LOG_FUNC_ENTER__;
 807
 808         wfd_manager_s *manager = wfd_get_manager();
 809         wfd_group_s *group = (wfd_group_s*) manager->group;
 810         wfd_session_s *session = (wfd_session_s*) manager->session;
 811
 812         if (!group) {
 813                 group = wfd_create_pending_group(manager, event->intf_addr);
 814                 if (!group) {
 815                         WDS_LOGE("Failed to create pending group");
 816                         __WDS_LOG_FUNC_EXIT__;
 817                         return;
 818                 }
 819
 820                 manager->group = group;
 821         }
 822
 823         wfd_group_complete(manager, event);
 824
 825         if (group->role == WFD_DEV_ROLE_GC && session) {
 826 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
 827                 wfd_device_s *peer = session->peer;
 828                 if (peer == NULL) {
 829                         WDS_LOGE("Unexpected event. Peer doesn't exist");
 830                         return;
 831                 }
 832
 833                 wfd_update_peer(manager, peer);
 834
 835                 if (peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
 836                         char peer_mac_address[MACSTR_LEN+1] = {0, };
 837
 838                         wfd_util_ip_over_eap_assign(peer, event->ifname);
 839
 840                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
 841                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 842                                                      "Connection",
 843                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 844                                                                             WFD_EVENT_CONNECTION_RSP,
 845                                                                             peer_mac_address));
 846 #if defined(TIZEN_FEATURE_ASP)
 847         if (!ISZEROMACADDR(session->session_mac)) {
 848                 wfd_asp_connect_status(session->session_mac,
 849                                                         session->session_id,
 850                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_COMPLETED,
 851                                                         NULL);
 852                 wfd_asp_session_peer_ip(session->session_mac, session->session_id,
 853                                 session->service_mac, peer->ip_addr);
 854         }
 855 #endif
 856                         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTED);
 857                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTED);
 858
 859                         wfd_destroy_session(manager);
 860                 }
 861 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
 862                 wfd_peer_clear_all(manager);
 863         } else {
 864                 if (group->flags & WFD_GROUP_FLAG_AUTONOMOUS) {
 865                         wfd_manager_dbus_emit_signal(WFD_MANAGER_GROUP_INTERFACE,
 866                                                      "Created", NULL);
 867                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 868                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 869                 }
 870         }
 871         __WDS_LOG_FUNC_EXIT__;
 872         return;
 873 }
 874
 875 void wfd_event_group_destroyed(wfd_oem_event_s *event)
 876 {
 877         __WDS_LOG_FUNC_ENTER__;
 878
 879         wfd_manager_s *manager = wfd_get_manager();
 880         char peer_mac_address[MACSTR_LEN+1] = {0, };
 881         unsigned char *peer_addr = wfd_session_get_peer_addr(manager->session);
 882
 883         if (peer_addr != NULL)
 884                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 885         else
 886                 g_snprintf(peer_mac_address, MACSTR_LEN, "%s", "");
 887
 888         if (manager->state == WIFI_DIRECT_STATE_DISCONNECTING) {
 889                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 890                                              "Disconnection",
 891                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 892                                                                     WFD_EVENT_DISCONNECTION_RSP,
 893                                                                     peer_mac_address));
 894
 895         } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING && manager->session) {
 896                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 897                                              "Connection",
 898                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 899                                                                     WFD_EVENT_CONNECTION_RSP,
 900                                                                     peer_mac_address));
 901 #if defined(TIZEN_FEATURE_ASP)
 902                 wfd_session_s *session = manager->session;
 903                 if (!ISZEROMACADDR(session->session_mac))
 904                         wfd_asp_connect_status(session->session_mac,
 905                                         session->session_id,
 906                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
 907                                         NULL);
 908 #endif
 909         } else if (manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
 910                 if (manager->local->dev_role != WFD_DEV_ROLE_GO) {
 911                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 912                                                      "Disconnection",
 913                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 914                                                                             WFD_EVENT_DISCONNECTION_RSP,
 915                                                                             peer_mac_address));
 916                 } else {
 917                         wfd_manager_dbus_emit_signal(WFD_MANAGER_GROUP_INTERFACE,
 918                                                      "Destroyed", NULL);
 919                 }
 920         } else {
 921                 WDS_LOGD("Unexpected event(GROUP_DESTROYED). Ignore it");
 922                 __WDS_LOG_FUNC_EXIT__;
 923                 return;
 924         }
 925
 926         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 927         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 928         wfd_destroy_group(manager);
 929         wfd_destroy_session(manager);
 930         manager->local->dev_role = WFD_DEV_ROLE_NONE;
 931
 932         __WDS_LOG_FUNC_EXIT__;
 933         return;
 934 }
 935
 936 void wfd_event_invitation_req(wfd_oem_event_s *event)
 937 {
 938         __WDS_LOG_FUNC_ENTER__;
 939
 940         wfd_manager_s *manager = wfd_get_manager();
 941         wfd_device_s *peer = NULL;
 942         wfd_session_s *session = NULL;
 943         wfd_oem_invite_data_s *edata = NULL;
 944         int res = 0;
 945         char peer_mac_address[MACSTR_LEN+1] = {0, };
 946
 947         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 948         if (!peer) {
 949                 WDS_LOGD("Invitation from unknown peer. Add new peer");
 950                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
 951                 if (!peer) {
 952                         WDS_LOGE("Failed to add peer for invitation");
 953                         __WDS_LOG_FUNC_EXIT__;
 954                         return;
 955                 }
 956         }
 957         peer->dev_role = WFD_DEV_ROLE_GO;
 958
 959         edata = (wfd_oem_invite_data_s*) event->edata;
 960         memcpy(peer->intf_addr, edata->bssid, MACADDR_LEN);
 961         wfd_update_peer_time(manager, event->dev_addr);
 962
 963         if (!ISZEROMACADDR(edata->go_dev_addr))
 964                 session = wfd_create_session(manager, edata->go_dev_addr,
 965                                              manager->req_wps_mode,
 966                                              SESSION_DIRECTION_INCOMING);
 967         else
 968                 session = wfd_create_session(manager, event->dev_addr,
 969                                              manager->req_wps_mode,
 970                                              SESSION_DIRECTION_INCOMING);
 971         if (!session) {
 972                 WDS_LOGE("Failed to create session");
 973                 __WDS_LOG_FUNC_EXIT__;
 974                 return;
 975         }
 976         session->type = SESSION_TYPE_INVITE;
 977         wfd_session_timer(session, 1);
 978
 979         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
 980         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTING);
 981
 982         res = wfd_session_start(session);
 983         if (res < 0) {
 984                 WDS_LOGE("Failed to start session");
 985                 __WDS_LOG_FUNC_EXIT__;
 986                 return;
 987         }
 988
 989         if (!ISZEROMACADDR(edata->go_dev_addr))
 990                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR,
 991                            MAC2STR(edata->go_dev_addr));
 992         else
 993                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR,
 994                            MAC2STR(event->dev_addr));
 995
 996         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 997                                      "Connection",
 998                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 999                                                             WFD_EVENT_CONNECTION_REQ,
1000                                                             peer_mac_address));
1001
1002         __WDS_LOG_FUNC_EXIT__;
1003         return;
1004 }
1005
1006 void wfd_event_invitation_res(wfd_oem_event_s *event)
1007 {
1008         __WDS_LOG_FUNC_ENTER__;
1009
1010         __WDS_LOG_FUNC_EXIT__;
1011         return;
1012 }
1013
1014 void wfd_event_sta_connected(wfd_oem_event_s *event)
1015 {
1016         __WDS_LOG_FUNC_ENTER__;
1017
1018         wfd_manager_s *manager = wfd_get_manager();
1019         wfd_session_s *session = (wfd_session_s*) manager->session;
1020         wfd_group_s *group = (wfd_group_s*) manager->group;
1021         wfd_device_s *peer = NULL;
1022         char peer_mac_address[MACSTR_LEN+1] = {0, };
1023
1024         /* FIXME: Move this code to plugin */
1025         if (!memcmp(event->intf_addr, manager->local->intf_addr, MACADDR_LEN)) {
1026                 WDS_LOGD("Ignore this event");
1027                 __WDS_LOG_FUNC_EXIT__;
1028                 return;
1029         }
1030
1031         if (ISZEROMACADDR(event->dev_addr)) {
1032                 WDS_LOGD("Legacy Peer Connected [Peer: " MACSTR "]", MAC2STR(event->intf_addr));
1033
1034                 peer = wfd_peer_find_by_addr(manager, event->intf_addr);
1035                 if (!peer) {
1036                         WDS_LOGI("Add legacy peer");
1037                         peer = wfd_add_peer(manager, event->intf_addr, "LEGACY-PEER");
1038                         if (!peer) {
1039                                 WDS_LOGE("Failed to add Legacy peer.");
1040                                 __WDS_LOG_FUNC_EXIT__;
1041                                 return;
1042                         }
1043                 }
1044
1045                 if (wfd_group_add_member(group, peer->dev_addr) == -1) {
1046                         WDS_LOGE("Failed to add Legacy peer.");
1047                         __WDS_LOG_FUNC_EXIT__;
1048                         return;
1049                 }
1050
1051                 memcpy(peer->intf_addr, event->intf_addr, MACADDR_LEN);
1052                 peer->state = WFD_PEER_STATE_CONNECTED;
1053                 peer->is_p2p = FALSE;
1054
1055                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1056                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1057                                              "Connection",
1058                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1059                                                                     WFD_EVENT_CONNECTION_RSP,
1060                                                                     peer_mac_address));
1061
1062                 wfd_util_dhcps_wait_ip_leased(peer);
1063                 __WDS_LOG_FUNC_EXIT__;
1064                 return;
1065         }
1066
1067         session = (wfd_session_s*) manager->session;
1068         if (!session && group) {
1069                 if (group->flags & WFD_GROUP_FLAG_PERSISTENT) {
1070                         session = wfd_create_session(manager, event->dev_addr,
1071                                                      event->wps_mode,
1072                                                      SESSION_DIRECTION_INCOMING);
1073                         if (!session) {
1074                                 WDS_LOGE("Failed to create session with peer [" MACSTR "]",
1075                                          MAC2STR(event->dev_addr));
1076                                 __WDS_LOG_FUNC_EXIT__;
1077                                 return;
1078                         }
1079                 } else {
1080                         WDS_LOGD("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
1081                                  MAC2SECSTR(event->dev_addr));
1082                         if (group) {
1083                                 wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1084                                 wfd_destroy_group(manager);
1085                         }
1086
1087                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1088                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1089                         __WDS_LOG_FUNC_EXIT__;
1090                         return;
1091                 }
1092         }
1093
1094         peer = wfd_session_get_peer(session);
1095         if (!peer) {
1096                 WDS_LOGE("Peer not found");
1097                 __WDS_LOG_FUNC_EXIT__;
1098                 return;
1099         }
1100
1101         group = (wfd_group_s*) manager->group;
1102         if (!group) {
1103                 group = wfd_create_pending_group(manager, event->intf_addr);
1104                 if (!group) {
1105                         WDS_LOGE("Failed to create pending group");
1106                         __WDS_LOG_FUNC_EXIT__;
1107                         return;
1108                 }
1109                 manager->group = group;
1110         }
1111         wfd_group_add_member(group, peer->dev_addr);
1112
1113         session->state = SESSION_STATE_COMPLETED;
1114         peer->state = WFD_PEER_STATE_CONNECTED;
1115
1116         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1117         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1118
1119         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1120         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1121                                      "Connection",
1122                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1123                                                             WFD_EVENT_CONNECTION_RSP,
1124                                                             peer_mac_address));
1125
1126         wfd_update_peer(manager, peer);
1127 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
1128         if (event->ip_addr_peer[3]) {
1129                 peer->ip_type = WFD_IP_TYPE_OVER_EAPOL;
1130                 memcpy(peer->client_ip_addr, event->ip_addr_peer, IPADDR_LEN);
1131                 WDS_LOGE("Peer's client IP [" IPSTR "]", IP2STR((char*) &peer->client_ip_addr));
1132                 memcpy(peer->go_ip_addr, manager->local->ip_addr, IPADDR_LEN);
1133                 WDS_LOGE("Peer's GO IP [" IPSTR "]", IP2STR((char*) &peer->go_ip_addr));
1134         }
1135         if (peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
1136                 char peer_mac_address[MACSTR_LEN+1] = {0,};
1137                 char assigned_ip_address[IPSTR_LEN+1] = {0,};
1138
1139                 memcpy(peer->ip_addr, peer->client_ip_addr, IPADDR_LEN);
1140
1141                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1142                 g_snprintf(assigned_ip_address, IPSTR_LEN, IPSTR, IP2STR(peer->ip_addr));
1143                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1144                                      "PeerIPAssigned",
1145                                      g_variant_new("(ss)", peer_mac_address,
1146                                                            assigned_ip_address));
1147 #if defined(TIZEN_FEATURE_ASP)
1148         if (!ISZEROMACADDR(session->session_mac)) {
1149                 wfd_asp_connect_status(session->session_mac,
1150                                                         session->session_id,
1151                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_COMPLETED,
1152                                                         NULL);
1153
1154                 wfd_asp_session_peer_ip(session->session_mac, session->session_id,
1155                                 session->service_mac, peer->ip_addr);
1156         }
1157 #endif
1158         } else
1159 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
1160         wfd_util_dhcps_wait_ip_leased(peer);
1161         wfd_destroy_session(manager);
1162
1163         __WDS_LOG_FUNC_EXIT__;
1164         return;
1165 }
1166
1167 void wfd_event_sta_disconnected(wfd_oem_event_s *event)
1168 {
1169         __WDS_LOG_FUNC_ENTER__;
1170
1171         wfd_manager_s *manager = wfd_get_manager();
1172         wfd_group_s *group = NULL;
1173         wfd_device_s *peer = NULL;
1174         unsigned char peer_addr[MACADDR_LEN] = {0, };
1175         char peer_mac_address[MACSTR_LEN+1] = {0, };
1176
1177         group = (wfd_group_s*) manager->group;
1178         if (!group) {
1179                 WDS_LOGE("Group not found");
1180                 __WDS_LOG_FUNC_EXIT__;
1181                 return;
1182         }
1183
1184         if (ISZEROMACADDR(event->dev_addr)) {
1185                 WDS_LOGD("Legacy Peer Disconnected [Peer: " MACSTR "]", MAC2STR(event->intf_addr));
1186                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->intf_addr));
1187                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1188                                              "Disconnection",
1189                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1190                                                                     WFD_EVENT_DISCONNECTION_IND,
1191                                                                     peer_mac_address));
1192
1193                 wfd_group_remove_member(group, event->intf_addr);
1194
1195                 if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1196                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1197                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1198                 } else {
1199                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1200                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1201                 }
1202                 __WDS_LOG_FUNC_EXIT__;
1203                 return;
1204         }
1205
1206         peer = wfd_group_find_member_by_addr(group, event->dev_addr);
1207         if (!peer) {
1208                 WDS_LOGE("Failed to find connected peer");
1209                 peer = wfd_session_get_peer(manager->session);
1210                 if (!peer) {
1211                         WDS_LOGE("Failed to find connecting peer");
1212                         __WDS_LOG_FUNC_EXIT__;
1213                         return;
1214                 }
1215
1216                 /**
1217                  * If no peer connected and
1218                  * disconnected event is not for connecting peer
1219                  * then event should be ignored.
1220                  * This situation can arrise when TV is GO and
1221                  * some connected peer sent disassociation.
1222                  */
1223                 if (memcmp(peer_addr, event->dev_addr, MACADDR_LEN)) {
1224                         WDS_LOGE("Unexpected event, Ignore it...");
1225                         __WDS_LOG_FUNC_EXIT__;
1226                         return;
1227                 }
1228         }
1229         memcpy(peer_addr, peer->dev_addr, MACADDR_LEN);
1230
1231         /**
1232          * If state is not DISCONNECTING, connection is finished by peer.
1233          *  Required the check also, when Device is Group Owner and state is DISCOVERING.
1234          */
1235         if (manager->state >= WIFI_DIRECT_STATE_CONNECTED ||
1236                                 (manager->state == WIFI_DIRECT_STATE_DISCOVERING &&
1237                                  manager->local->dev_role == WFD_DEV_ROLE_GO)) {
1238                 wfd_group_remove_member(group, peer_addr);
1239                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1240                 if (group->member_count) {
1241                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1242                                                      "Disconnection",
1243                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1244                                                                             WFD_EVENT_DISASSOCIATION_IND,
1245                                                                             peer_mac_address));
1246                 } else {
1247                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1248                                                      "Disconnection",
1249                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1250                                                                             WFD_EVENT_DISCONNECTION_IND,
1251                                                                             peer_mac_address));
1252                 }
1253
1254         } else if (manager->state == WIFI_DIRECT_STATE_DISCONNECTING) {
1255                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1256                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1257                                              "Disconnection",
1258                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1259                                                                     WFD_EVENT_DISCONNECTION_RSP,
1260                                                                     peer_mac_address));
1261
1262         } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING &&
1263                         /* Some devices(GO) send disconnection message before connection completed.
1264                          * This message should be ignored when device is not GO */
1265                         manager->local->dev_role == WFD_DEV_ROLE_GO) {
1266                 if (WFD_PEER_STATE_CONNECTED == peer->state) {
1267                         WDS_LOGD("Peer is already Connected !!!");
1268                         wfd_group_remove_member(group, peer_addr);
1269                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1270                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1271                                                      "Disconnection",
1272                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1273                                                                             WFD_EVENT_DISASSOCIATION_IND,
1274                                                                             peer_mac_address));
1275
1276                 } else if (WFD_PEER_STATE_CONNECTING == peer->state) {
1277                         WDS_LOGD("Peer is Connecting...");
1278                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1279                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1280                                                      "Connection",
1281                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
1282                                                                             WFD_EVENT_CONNECTION_RSP,
1283                                                                             peer_mac_address));
1284 #if defined(TIZEN_FEATURE_ASP)
1285                         wfd_session_s *session = manager->session;
1286                         if (session && !ISZEROMACADDR(session->session_mac))
1287                                 wfd_asp_connect_status(session->session_mac,
1288                                                                         session->session_id,
1289                                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1290                                                                         NULL);
1291 #endif
1292                 } else {
1293                         WDS_LOGE("Unexpected Peer State. Ignore it");
1294                         __WDS_LOG_FUNC_EXIT__;
1295                         return;
1296                 }
1297         } else {
1298                 WDS_LOGE("Unexpected event. Ignore it");
1299                 __WDS_LOG_FUNC_EXIT__;
1300                 return;
1301         }
1302
1303         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1304                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1305                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1306         } else {
1307                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1308                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1309         }
1310
1311         /* If there is no member, GO should be destroyed */
1312         if (!group->member_count) {
1313                 wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1314                 wfd_destroy_group(manager);
1315                 wfd_peer_clear_all(manager);
1316         }
1317
1318         wfd_destroy_session(manager);
1319
1320         __WDS_LOG_FUNC_EXIT__;
1321         return;
1322 }
1323
1324 void wfd_event_terminating(wfd_oem_event_s *event)
1325 {
1326         __WDS_LOG_FUNC_ENTER__;
1327
1328         __WDS_LOG_FUNC_EXIT__;
1329         return;
1330 }
1331
1332 void wfd_event_group_formation_failure(wfd_oem_event_s *event)
1333 {
1334         __WDS_LOG_FUNC_ENTER__;
1335
1336         wfd_manager_s *manager = wfd_get_manager();
1337         wfd_session_s *session = (wfd_session_s*) manager->session;
1338         if (!session) {
1339                 WDS_LOGE("Unexpected event. Session not exist");
1340                 __WDS_LOG_FUNC_EXIT__;
1341                 return;
1342         }
1343
1344         unsigned char *peer_addr = wfd_session_get_peer_addr(session);
1345         if (!peer_addr) {
1346                 WDS_LOGE("Session do not has peer");
1347                 __WDS_LOG_FUNC_EXIT__;
1348                 return;
1349         }
1350
1351         char peer_mac_address[MACSTR_LEN+1] = {0, };
1352         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1353         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1354                                      "Connection",
1355                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
1356                                                             WFD_EVENT_CONNECTION_RSP,
1357                                                             peer_mac_address));
1358
1359 #if defined(TIZEN_FEATURE_ASP)
1360         if (!ISZEROMACADDR(session->session_mac))
1361                 wfd_asp_connect_status(session->session_mac,
1362                                                         session->session_id,
1363                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1364                                                         NULL);
1365 #endif
1366
1367         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1368         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1369         wfd_destroy_session(manager);
1370         manager->local->dev_role = WFD_DEV_ROLE_NONE;
1371
1372         wfd_oem_refresh(manager->oem_ops);
1373
1374         __WDS_LOG_FUNC_EXIT__;
1375         return;
1376 }
1377
1378 /**
1379  * This event is generated by supplicant when persitent invite is auto accepted
1380  * so that wfd-manager can get indication that a peer will be connected in near future.
1381  * session is started for that peer, so that it is not ignored when connected.
1382  */
1383 void wfd_event_invitation_accepted(wfd_oem_event_s *event)
1384 {
1385
1386         __WDS_LOG_FUNC_ENTER__;
1387
1388         wfd_manager_s *manager = wfd_get_manager();
1389         wfd_session_s *session = (wfd_session_s*) manager->session;
1390         wfd_device_s *peer = NULL;
1391         char peer_mac_address[MACSTR_LEN+1] = {0, };
1392
1393         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
1394         if (!peer) {
1395                 WDS_LOGI("Invitation from unknown peer. Add new peer");
1396                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
1397                 if (!peer) {
1398                         WDS_LOGE("Failed to add peer for invitation");
1399                         __WDS_LOG_FUNC_EXIT__;
1400                         return;
1401                 }
1402         }
1403         /**By default, peer device information is complete but there's some exception
1404         * if DEV-FOUND event was not preceding before connection start event.
1405         */
1406         wfd_update_peer(manager, peer);
1407         peer->dev_role = WFD_DEV_ROLE_GO;
1408
1409         if (!session) {
1410                 session = wfd_create_session(manager, event->dev_addr,
1411                                         event->wps_mode, SESSION_DIRECTION_INCOMING);
1412                 if (!session) {
1413                         WDS_LOGE("Failed to create session with peer [" MACSTR "]",
1414                                                         MAC2STR(event->dev_addr));
1415                         __WDS_LOG_FUNC_EXIT__;
1416                         return;
1417                 }
1418         }
1419
1420         session->state = SESSION_STATE_WPS;
1421         wfd_session_timer(session, 1);
1422
1423         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1424         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1425                                          "Connection",
1426                                          g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1427                                                                 WFD_EVENT_CONNECTION_IN_PROGRESS,
1428                                                                 peer_mac_address));
1429
1430         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
1431         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTING);
1432
1433         __WDS_LOG_FUNC_EXIT__;
1434 }
1435
1436 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1437 void wfd_event_serv_disc_resp(wfd_oem_event_s *event)
1438 {
1439         __WDS_LOG_FUNC_ENTER__;
1440
1441         wfd_manager_s *manager = wfd_get_manager();
1442         int service_type;
1443         char response_data[256] = {0, };
1444         char peer_mac_address[MACSTR_LEN+1] = {0, };
1445
1446         wfd_update_peer_time(manager, event->dev_addr);
1447
1448         if (event->edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE) {
1449                 wfd_oem_new_service_s *service = NULL;;
1450                 GList *temp = NULL;
1451                 GList *services = (GList*) event->edata;
1452                 int count = 0;
1453
1454                 WDS_LOGD("%d service data found", event->dev_role);
1455
1456                 temp = g_list_first(services);
1457                 while (temp && count < event->dev_role) {
1458                         service = (wfd_oem_new_service_s*) temp->data;
1459                         service_type = service->protocol;
1460                         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
1461                                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1462                                 g_snprintf(response_data, 256, "%s|%s", service->data.bonjour.query, service->data.bonjour.rdata);
1463                                 WDS_LOGD("Found service: [%d: %s] - [" MACSECSTR "]", service->protocol,
1464                                                         service->data.bonjour.query, MAC2SECSTR(event->dev_addr));
1465                         } else {
1466                                 WDS_LOGD("Found service is not supported");
1467                                 goto next;
1468                         }
1469
1470                         wfd_manager_dbus_emit_signal(WFD_MANAGER_SERVICE_INTERFACE,
1471                                                      "DiscoveryFound",
1472                                                      g_variant_new("(iss)", service_type,
1473                                                                             response_data,
1474                                                                             peer_mac_address));
1475 next:
1476                         temp = g_list_next(temp);
1477                         service = NULL;
1478                         count++;
1479                 }
1480         } else if (event->edata_type == WFD_OEM_EDATA_TYPE_SERVICE) {
1481                 wfd_oem_service_data_s *edata = (wfd_oem_service_data_s*) event->edata;
1482
1483                 if (!edata) {
1484                         service_type = -1;
1485                 } else {
1486                         service_type = edata->type;
1487                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1488                         switch (edata->type) {
1489                                 WDS_LOGE("Unknown type [type ID: %d]", edata->type);
1490                         }
1491                 }
1492
1493                 wfd_manager_dbus_emit_signal(WFD_MANAGER_SERVICE_INTERFACE,
1494                                              "DiscoveryFound",
1495                                              g_variant_new("(iss)", service_type,
1496                                                                     response_data,
1497                                                                     peer_mac_address));
1498         }
1499
1500         __WDS_LOG_FUNC_EXIT__;
1501         return;
1502 }
1503
1504 void wfd_event_serv_disc_started(wfd_oem_event_s *event)
1505 {
1506         __WDS_LOG_FUNC_ENTER__;
1507
1508         __WDS_LOG_FUNC_EXIT__;
1509         return;
1510 }
1511 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1512
1513
1514 #if defined(TIZEN_FEATURE_ASP)
1515 void wfd_event_asp_serv_resp(wfd_oem_event_s *event)
1516 {
1517         __WDS_LOG_FUNC_ENTER__;
1518
1519         wfd_oem_asp_service_s *service = NULL;
1520         GVariantBuilder *builder = NULL;
1521         GVariant *params = NULL;
1522
1523         service = (wfd_oem_asp_service_s *)event->edata;
1524         if (service == NULL) {
1525                 WDS_LOGE("P2P service found event has NULL information");
1526                 __WDS_LOG_FUNC_EXIT__;
1527                 return;
1528         }
1529
1530         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1531         g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("u", service->search_id));
1532         g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", event->dev_addr));
1533         g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
1534         g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
1535         if (service->service_type)
1536                 g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
1537         if (service->service_info)
1538                 g_variant_builder_add(builder, "{sv}", "service_info", g_variant_new("s", service->service_info));
1539         g_variant_builder_add(builder, "{sv}", "status", g_variant_new("y", service->status));
1540         params = g_variant_new("(a{sv})", builder);
1541         g_variant_builder_unref(builder);
1542
1543         wfd_manager_dbus_emit_signal(WFD_MANAGER_ASP_INTERFACE,
1544                                      "SearchResult",
1545                                      params);
1546
1547         __WDS_LOG_FUNC_EXIT__;
1548         return;
1549 }
1550
1551 int __wfd_handle_asp_prov(wfd_manager_s *manager, wfd_oem_event_s *event)
1552 {
1553         __WDS_LOG_FUNC_ENTER__;
1554
1555         wfd_session_s *session = NULL;
1556         wfd_oem_asp_prov_s *prov_params = NULL;
1557         int res = 0;
1558
1559         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1560         if (prov_params == NULL) {
1561                 WDS_LOGE("Invalid parameter");
1562                 __WDS_LOG_FUNC_EXIT__;
1563                 return -1;
1564         }
1565
1566         res = wfd_session_process_event(manager, event);
1567         session = (wfd_session_s *)manager->session;
1568         if (res < 0 || session == NULL) {
1569                 WDS_LOGE("Failed to process event of session");
1570                 __WDS_LOG_FUNC_EXIT__;
1571                 return -1;
1572         }
1573         session->session_id = prov_params->session_id;
1574         memcpy(session->session_mac, prov_params->session_mac, MACADDR_LEN);
1575         memcpy(session->service_mac, prov_params->service_mac, MACADDR_LEN);
1576
1577         __WDS_LOG_FUNC_EXIT__;
1578         return 0;
1579 }
1580
1581 int __wfd_handle_asp_prov_done(wfd_session_s *session, wfd_oem_event_s *event)
1582 {
1583         __WDS_LOG_FUNC_ENTER__;
1584
1585         wfd_oem_asp_prov_s *prov_params = NULL;
1586         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1587         int res = 0;
1588
1589         if (prov_params->persist &&
1590         (prov_params->network_role || prov_params->network_config)) {
1591                 WDS_LOGE("Persistent group is used but "
1592                                 "conncap/dev_passwd_id are present");
1593                 __WDS_LOG_FUNC_EXIT__;
1594                 return -1;
1595         }
1596
1597         if (!prov_params->persist &&
1598         (!prov_params->network_role && !prov_params->network_config)) {
1599                 WDS_LOGE("Persistent group not used but "
1600                                 "conncap/dev_passwd_id are missing");
1601                 __WDS_LOG_FUNC_EXIT__;
1602                 return -1;
1603         }
1604
1605         if (session->wps_mode == WFD_OEM_WPS_MODE_P2PS)
1606                 g_strlcpy(session->wps_pin, OEM_DEFAULT_P2PS_PIN, OEM_PINSTR_LEN + 1);
1607
1608         if (prov_params->persist) {
1609                 res = wfd_session_asp_persistent_connect(session, prov_params->persistent_group_id);
1610         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_NEW) {
1611                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_NEW);
1612         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_CLIENT) {
1613                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_CLIENT);
1614         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_GO) {
1615                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_GO);
1616                 WDS_LOGD("don't need to take action.");
1617
1618         } else {
1619                 WDS_LOGE("Unhandled event");
1620                 __WDS_LOG_FUNC_EXIT__;
1621                 res = -1;
1622         }
1623
1624         __WDS_LOG_FUNC_EXIT__;
1625         return res;
1626 }
1627 void wfd_event_asp_prov_start(wfd_oem_event_s *event)
1628 {
1629         __WDS_LOG_FUNC_ENTER__;
1630
1631         wfd_manager_s *manager = wfd_get_manager();
1632         wfd_session_s *session = NULL;
1633         wfd_oem_asp_prov_s *prov_params = NULL;
1634         int res = 0;
1635
1636         if (event == NULL || event->edata == NULL) {
1637                 WDS_LOGE("Invalid parameter");
1638                 __WDS_LOG_FUNC_EXIT__;
1639                 return;
1640         }
1641
1642         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1643         res = __wfd_handle_asp_prov(manager, event);
1644         session = (wfd_session_s *)manager->session;
1645         if (res < 0 || session == NULL) {
1646                 WDS_LOGE("Failed to process event of session");
1647                 __WDS_LOG_FUNC_EXIT__;
1648                 return;
1649         }
1650
1651         WDS_LOGD("created session [%u] with peer [" MACSTR "]", session->session_id,
1652                         MAC2STR(session->session_mac));
1653
1654         /* Incomming Session, auto_accept = TRUE emit request Received */
1655         /* generate SessionConfigRequest if event->wps_mode is not P2PS  and return*/
1656
1657         wfd_session_timer(session, 1);
1658         wfd_asp_session_request(prov_params);
1659         wfd_asp_connect_status(prov_params->session_mac,
1660                                                 prov_params->session_id,
1661                                                 ASP_CONNECT_STATUS_REQUEST_RECEIVED,
1662                                                 NULL);
1663
1664         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
1665
1666         __WDS_LOG_FUNC_EXIT__;
1667         return;
1668 }
1669
1670 void wfd_event_asp_prov_done(wfd_oem_event_s *event)
1671 {
1672         __WDS_LOG_FUNC_ENTER__;
1673
1674         wfd_manager_s *manager = wfd_get_manager();
1675         wfd_session_s *session = NULL;
1676         wfd_oem_asp_prov_s *prov_params;
1677         int res = 0;
1678
1679         if (event == NULL || event->edata == NULL) {
1680                 WDS_LOGE("Invalid parameter");
1681                 __WDS_LOG_FUNC_EXIT__;
1682                 return;
1683         }
1684
1685         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1686         /* Incomming Session, auto_accept = TRUE emit request Received */
1687         /* generate SessionConfigRequest if event->wps_mode is not P2PS  and return*/
1688         if (manager->session == NULL) {
1689                 wfd_asp_session_request(prov_params);
1690                 wfd_asp_connect_status(prov_params->session_mac,
1691                                                         prov_params->session_id,
1692                                                         ASP_CONNECT_STATUS_REQUEST_RECEIVED,
1693                                                         NULL);
1694         }
1695
1696         res = __wfd_handle_asp_prov(manager, event);
1697         session = (wfd_session_s *)manager->session;
1698         if (res < 0 || session == NULL) {
1699                 WDS_LOGE("Failed to process event of session");
1700                 wfd_destroy_session(manager);
1701                 wfd_asp_connect_status(prov_params->session_mac,
1702                                                         prov_params->session_id,
1703                                                         ASP_CONNECT_STATUS_REQUEST_FAILED,
1704                                                         NULL);
1705                 wfd_oem_refresh(manager->oem_ops);
1706                 __WDS_LOG_FUNC_EXIT__;
1707                 return;
1708         }
1709
1710         if (prov_params->status != WFD_OEM_SC_SUCCESS &&
1711                         prov_params->status != WFD_OEM_SC_SUCCESS_ACCEPTED_BY_USER) {
1712                 WDS_LOGD("ASP-PROV failed. remove session.");
1713                 wfd_destroy_session(manager);
1714                 wfd_oem_refresh(manager->oem_ops);
1715                 wfd_asp_connect_status(prov_params->session_mac,
1716                                                         prov_params->session_id,
1717                                                         ASP_CONNECT_STATUS_REQUEST_FAILED,
1718                                                         NULL);
1719                 __WDS_LOG_FUNC_EXIT__;
1720                 return;
1721         }
1722
1723         wfd_asp_connect_status(prov_params->session_mac,
1724                                                 prov_params->session_id,
1725                                                 ASP_CONNECT_STATUS_REQUEST_ACCEPTED,
1726                                                 NULL);
1727
1728         wfd_asp_connect_status(prov_params->session_mac,
1729                                                 prov_params->session_id,
1730                                                 ASP_CONNECT_STATUS_GROUP_FORMATION_STARTED,
1731                                                 NULL);
1732         res = __wfd_handle_asp_prov_done(session, event);
1733         if (res < 0) {
1734                 WDS_LOGE("Connect failed. remove session.");
1735                 wfd_destroy_session(manager);
1736                 wfd_oem_refresh(manager->oem_ops);
1737
1738                 wfd_asp_connect_status(prov_params->session_mac,
1739                                                         prov_params->session_id,
1740                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1741                                                         NULL);
1742                 __WDS_LOG_FUNC_EXIT__;
1743                 return;
1744         }
1745
1746         WDS_LOGD("Provision done succeeded.");
1747         __WDS_LOG_FUNC_EXIT__;
1748         return;
1749 }
1750 #endif /* TIZEN_FEATURE_ASP */
1751
1752 void wfd_event_init(wfd_oem_event_cbs_s *event_cbs)
1753 {
1754         __WDS_LOG_FUNC_ENTER__;
1755
1756         if (!event_cbs) {
1757                 __WDS_LOG_FUNC_EXIT__;
1758                 return;
1759         }
1760
1761         event_cbs->deactivated_cb = wfd_event_deactivated;
1762         event_cbs->peer_found_cb = wfd_event_peer_found;
1763         event_cbs->peer_disappeared_cb = wfd_event_peer_disappeared;
1764         event_cbs->discovery_finished_cb = wfd_event_discovery_finished;
1765
1766         event_cbs->prov_disc_req_cb = wfd_event_prov_disc_req;
1767         event_cbs->prov_disc_resp_cb = wfd_event_prov_disc_resp;
1768         event_cbs->prov_disc_fail_cb = wfd_event_prov_disc_fail;
1769
1770         event_cbs->go_neg_req_cb = wfd_event_go_neg_req;
1771         event_cbs->go_neg_fail_cb = wfd_event_go_neg_fail;
1772         event_cbs->go_neg_done_cb = wfd_event_go_neg_done;
1773
1774         event_cbs->wps_fail_cb = wfd_event_wps_fail;
1775         event_cbs->wps_done_cb = wfd_event_wps_done;
1776         event_cbs->key_neg_fail_cb = wfd_event_key_neg_fail;
1777         event_cbs->key_neg_done_cb = wfd_event_key_neg_done;
1778
1779         event_cbs->conn_fail_cb = wfd_event_conn_fail;
1780         event_cbs->conn_done_cb = wfd_event_conn_done;
1781
1782         event_cbs->group_created_cb = wfd_event_group_created;
1783         event_cbs->group_destroyed_cb = wfd_event_group_destroyed;
1784
1785         event_cbs->invitation_req_cb = wfd_event_invitation_req;
1786         event_cbs->invitation_resp_cb = wfd_event_invitation_res;
1787         event_cbs->sta_connected_cb = wfd_event_sta_connected;
1788         event_cbs->sta_disconnected_cb = wfd_event_sta_disconnected;
1789
1790         event_cbs->terminating_cb = wfd_event_terminating;
1791
1792 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1793         event_cbs->serv_disc_resp_cb = wfd_event_serv_disc_resp;
1794         event_cbs->serv_disc_started_cb = wfd_event_serv_disc_started;
1795 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1796
1797         event_cbs->group_formation_failure_cb = wfd_event_group_formation_failure;
1798         event_cbs->invitation_accepted_cb = wfd_event_invitation_accepted;
1799
1800 #if defined(TIZEN_FEATURE_ASP)
1801         event_cbs->asp_serv_resp_cb = wfd_event_asp_serv_resp;
1802         event_cbs->asp_prov_start_cb = wfd_event_asp_prov_start;
1803         event_cbs->asp_prov_done_cb = wfd_event_asp_prov_done;
1804 #endif /* TIZEN_FEATURE_ASP */
1805
1806         event_cbs->extra_data = NULL;
1807
1808         __WDS_LOG_FUNC_EXIT__;
1809         return;
1810 }