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