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