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