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