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 (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 (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) {
1133                 WDS_LOGD("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
1134                                                                         MAC2SECSTR(event->dev_addr));
1135                 if (group) {
1136                         wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1137                         wfd_destroy_group(manager);
1138                 }
1139                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1140                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1141                 __WDS_LOG_FUNC_EXIT__;
1142                 return;
1143         }
1144
1145         peer = wfd_session_get_peer(session);
1146         if (!peer) {
1147                 WDS_LOGE("Peer not found");
1148                 __WDS_LOG_FUNC_EXIT__;
1149                 return;
1150         }
1151
1152         group = (wfd_group_s*) manager->group;
1153         if (!group) {
1154                 group = wfd_create_pending_group(manager, event->intf_addr);
1155                 if (!group) {
1156                         WDS_LOGE("Failed to create pending group");
1157                         __WDS_LOG_FUNC_EXIT__;
1158                         return;
1159                 }
1160                 manager->group = group;
1161         }
1162         wfd_group_add_member(group, peer->dev_addr);
1163
1164         session->state = SESSION_STATE_COMPLETED;
1165 #ifndef CTRL_IFACE_DBUS
1166         memcpy(peer->intf_addr, event->intf_addr, MACADDR_LEN);
1167 #endif /* CTRL_IFACE_DBUS */
1168         peer->state = WFD_PEER_STATE_CONNECTED;
1169
1170         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1171         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1172
1173         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1174         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1175                                      "Connection",
1176                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1177                                                             WFD_EVENT_CONNECTION_RSP,
1178                                                             peer_mac_address));
1179
1180 #ifdef CTRL_IFACE_DBUS
1181         wfd_update_peer(manager, peer);
1182 #endif /* CTRL_IFACE_DBUS */
1183 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
1184         if (event->ip_addr_peer[3]) {
1185                 peer->ip_type = WFD_IP_TYPE_OVER_EAPOL;
1186                 memcpy(peer->client_ip_addr, event->ip_addr_peer, IPADDR_LEN);
1187                 WDS_LOGE("Peer's client IP [" IPSTR "]", IP2STR((char*) &peer->client_ip_addr));
1188                 memcpy(peer->go_ip_addr, manager->local->ip_addr, IPADDR_LEN);
1189                 WDS_LOGE("Peer's GO IP [" IPSTR "]", IP2STR((char*) &peer->go_ip_addr));
1190         }
1191         if (peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
1192                 char peer_mac_address[MACSTR_LEN+1] = {0,};
1193                 char assigned_ip_address[IPSTR_LEN+1] = {0,};
1194
1195                 memcpy(peer->ip_addr, peer->client_ip_addr, IPADDR_LEN);
1196
1197                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1198                 g_snprintf(assigned_ip_address, IPSTR_LEN, IPSTR, IP2STR(peer->ip_addr));
1199                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1200                                      "PeerIPAssigned",
1201                                      g_variant_new("(ss)", peer_mac_address,
1202                                                            assigned_ip_address));
1203 #if defined(TIZEN_FEATURE_ASP)
1204         if (!ISZEROMACADDR(session->session_mac)) {
1205                 wfd_asp_connect_status(session->session_mac,
1206                                                         session->session_id,
1207                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_COMPLETED,
1208                                                         NULL);
1209
1210                 wfd_asp_session_peer_ip(session->session_mac, session->session_id,
1211                                 session->service_mac, peer->ip_addr);
1212         }
1213 #endif
1214         } else
1215 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
1216         wfd_util_dhcps_wait_ip_leased(peer);
1217         wfd_destroy_session(manager);
1218
1219         __WDS_LOG_FUNC_EXIT__;
1220         return;
1221 }
1222
1223 void wfd_event_sta_disconnected(wfd_oem_event_s *event)
1224 {
1225         __WDS_LOG_FUNC_ENTER__;
1226
1227         wfd_manager_s *manager = wfd_get_manager();
1228         wfd_group_s *group = NULL;
1229         wfd_device_s *peer = NULL;
1230         unsigned char peer_addr[MACADDR_LEN] = {0, };
1231         char peer_mac_address[MACSTR_LEN+1] = {0, };
1232
1233         group = (wfd_group_s*) manager->group;
1234         if (!group) {
1235                 WDS_LOGE("Group not found");
1236                 __WDS_LOG_FUNC_EXIT__;
1237                 return;
1238         }
1239
1240         if (ISZEROMACADDR(event->dev_addr)) {
1241                 WDS_LOGD("Legacy Peer Disconnected [Peer: " MACSTR "]", MAC2STR(event->intf_addr));
1242                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->intf_addr));
1243                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1244                                              "Disconnection",
1245                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1246                                                                     WFD_EVENT_DISCONNECTION_IND,
1247                                                                     peer_mac_address));
1248
1249                 wfd_group_remove_member(group, event->intf_addr);
1250
1251                 if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1252                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1253                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1254                 } else {
1255                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1256                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1257                 }
1258                 __WDS_LOG_FUNC_EXIT__;
1259                 return;
1260         }
1261
1262 #ifdef CTRL_IFACE_DBUS
1263         peer = wfd_group_find_member_by_addr(group, event->dev_addr);
1264 #else /* CTRL_IFACE_DBUS */
1265         peer = wfd_group_find_member_by_addr(group, event->intf_addr);
1266 #endif /* DBUS_IFACE */
1267         if (!peer) {
1268                 WDS_LOGE("Failed to find connected peer");
1269                 peer = wfd_session_get_peer(manager->session);
1270                 if (!peer) {
1271                         WDS_LOGE("Failed to find connecting peer");
1272                         __WDS_LOG_FUNC_EXIT__;
1273                         return;
1274                 }
1275
1276 #ifdef CTRL_IFACE_DBUS
1277                 /**
1278                  * If no peer connected and
1279                  * disconnected event is not for connecting peer
1280                  * then event should be ignored.
1281                  * This situation can arrise when TV is GO and
1282                  * some connected peer sent disassociation.
1283                  */
1284                 if (memcmp(peer_addr, event->dev_addr, MACADDR_LEN)) {
1285                         WDS_LOGE("Unexpected event, Ignore it...");
1286                         __WDS_LOG_FUNC_EXIT__;
1287                         return;
1288                 }
1289 #endif /* CTRL_DBUS_IFACE */
1290         }
1291         memcpy(peer_addr, peer->dev_addr, MACADDR_LEN);
1292
1293         /**
1294          * If state is not DISCONNECTING, connection is finished by peer.
1295          *  Required the check also, when Device is Group Owner and state is DISCOVERING.
1296          */
1297         if (manager->state >= WIFI_DIRECT_STATE_CONNECTED ||
1298                                 (manager->state == WIFI_DIRECT_STATE_DISCOVERING &&
1299                                  manager->local->dev_role == WFD_DEV_ROLE_GO)) {
1300                 wfd_group_remove_member(group, peer_addr);
1301                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1302                 if (group->member_count) {
1303                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1304                                                      "Disconnection",
1305                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1306                                                                             WFD_EVENT_DISASSOCIATION_IND,
1307                                                                             peer_mac_address));
1308                 } else {
1309                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1310                                                      "Disconnection",
1311                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1312                                                                             WFD_EVENT_DISCONNECTION_IND,
1313                                                                             peer_mac_address));
1314                 }
1315
1316         } else if (manager->state == WIFI_DIRECT_STATE_DISCONNECTING) {
1317                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1318                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1319                                              "Disconnection",
1320                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1321                                                                     WFD_EVENT_DISCONNECTION_RSP,
1322                                                                     peer_mac_address));
1323
1324         } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING &&
1325                         /* Some devices(GO) send disconnection message before connection completed.
1326                          * This message should be ignored when device is not GO */
1327                         manager->local->dev_role == WFD_DEV_ROLE_GO) {
1328                 if (WFD_PEER_STATE_CONNECTED == peer->state) {
1329                         WDS_LOGD("Peer is already Connected !!!");
1330                         wfd_group_remove_member(group, peer_addr);
1331                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1332                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1333                                                      "Disconnection",
1334                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1335                                                                             WFD_EVENT_DISASSOCIATION_IND,
1336                                                                             peer_mac_address));
1337
1338                 } else if (WFD_PEER_STATE_CONNECTING == peer->state) {
1339                         WDS_LOGD("Peer is Connecting...");
1340                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1341                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1342                                                      "Connection",
1343                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
1344                                                                             WFD_EVENT_CONNECTION_RSP,
1345                                                                             peer_mac_address));
1346 #if defined(TIZEN_FEATURE_ASP)
1347                         wfd_session_s *session = manager->session;
1348                         if (session && !ISZEROMACADDR(session->session_mac))
1349                                 wfd_asp_connect_status(session->session_mac,
1350                                                                         session->session_id,
1351                                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1352                                                                         NULL);
1353 #endif
1354                 } else {
1355                         WDS_LOGE("Unexpected Peer State. Ignore it");
1356                         __WDS_LOG_FUNC_EXIT__;
1357                         return;
1358                 }
1359         } else {
1360                 WDS_LOGE("Unexpected event. Ignore it");
1361                 __WDS_LOG_FUNC_EXIT__;
1362                 return;
1363         }
1364
1365         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1366                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1367                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1368         } else {
1369                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1370                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1371         }
1372
1373         /* If there is no member, GO should be destroyed */
1374         if (!group->member_count) {
1375                 wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1376                 wfd_destroy_group(manager);
1377                 wfd_peer_clear_all(manager);
1378         }
1379
1380         wfd_destroy_session(manager);
1381
1382         __WDS_LOG_FUNC_EXIT__;
1383         return;
1384 }
1385
1386 void wfd_event_terminating(wfd_oem_event_s *event)
1387 {
1388         __WDS_LOG_FUNC_ENTER__;
1389
1390         __WDS_LOG_FUNC_EXIT__;
1391         return;
1392 }
1393
1394 void wfd_event_group_formation_failure(wfd_oem_event_s *event)
1395 {
1396         __WDS_LOG_FUNC_ENTER__;
1397
1398         wfd_manager_s *manager = wfd_get_manager();
1399         wfd_session_s *session = (wfd_session_s*) manager->session;
1400         if (!session) {
1401                 WDS_LOGE("Unexpected event. Session not exist");
1402                 __WDS_LOG_FUNC_EXIT__;
1403                 return;
1404         }
1405
1406         unsigned char *peer_addr = wfd_session_get_peer_addr(session);
1407         if (!peer_addr) {
1408                 WDS_LOGE("Session do not has peer");
1409                 __WDS_LOG_FUNC_EXIT__;
1410                 return;
1411         }
1412
1413         char peer_mac_address[MACSTR_LEN+1] = {0, };
1414         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1415         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1416                                      "Connection",
1417                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
1418                                                             WFD_EVENT_CONNECTION_RSP,
1419                                                             peer_mac_address));
1420
1421 #if defined(TIZEN_FEATURE_ASP)
1422         if (!ISZEROMACADDR(session->session_mac))
1423                 wfd_asp_connect_status(session->session_mac,
1424                                                         session->session_id,
1425                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1426                                                         NULL);
1427 #endif
1428
1429         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1430         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1431         wfd_destroy_session(manager);
1432         manager->local->dev_role = WFD_DEV_ROLE_NONE;
1433
1434         wfd_oem_refresh(manager->oem_ops);
1435
1436         __WDS_LOG_FUNC_EXIT__;
1437         return;
1438 }
1439
1440 /**
1441  * This event is generated by supplicant when persitent invite is auto accepted
1442  * so that wfd-manager can get indication that a peer will be connected in near future.
1443  * session is started for that peer, so that it is not ignored when connected.
1444  */
1445 void wfd_event_invitation_accepted(wfd_oem_event_s *event)
1446 {
1447
1448         __WDS_LOG_FUNC_ENTER__;
1449
1450         wfd_manager_s *manager = wfd_get_manager();
1451         wfd_session_s *session = (wfd_session_s*) manager->session;
1452         wfd_device_s *peer = NULL;
1453         char peer_mac_address[MACSTR_LEN+1] = {0, };
1454
1455         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
1456         if (!peer) {
1457                 WDS_LOGI("Invitation from unknown peer. Add new peer");
1458                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
1459                 if (!peer) {
1460                         WDS_LOGE("Failed to add peer for invitation");
1461                         __WDS_LOG_FUNC_EXIT__;
1462                         return;
1463                 }
1464         }
1465         /**By default, peer device information is complete but there's some exception
1466         * if DEV-FOUND event was not preceding before connection start event.
1467         */
1468         wfd_update_peer(manager, peer);
1469         peer->dev_role = WFD_DEV_ROLE_GO;
1470
1471         if (!session) {
1472                 session = wfd_create_session(manager, event->dev_addr,
1473                                         event->wps_mode, SESSION_DIRECTION_INCOMING);
1474                 if (!session) {
1475                         WDS_LOGE("Failed to create session with peer [" MACSTR "]",
1476                                                         MAC2STR(event->dev_addr));
1477                         __WDS_LOG_FUNC_EXIT__;
1478                         return;
1479                 }
1480         }
1481
1482         session->state = SESSION_STATE_WPS;
1483         wfd_session_timer(session, 1);
1484
1485         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1486         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
1487                                          "Connection",
1488                                          g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
1489                                                                 WFD_EVENT_CONNECTION_IN_PROGRESS,
1490                                                                 peer_mac_address));
1491
1492         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
1493         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTING);
1494
1495         __WDS_LOG_FUNC_EXIT__;
1496 }
1497
1498 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1499 void wfd_event_serv_disc_resp(wfd_oem_event_s *event)
1500 {
1501         __WDS_LOG_FUNC_ENTER__;
1502
1503         wfd_manager_s *manager = wfd_get_manager();
1504         int service_type;
1505         char response_data[256] = {0, };
1506         char peer_mac_address[MACSTR_LEN+1] = {0, };
1507
1508         wfd_update_peer_time(manager, event->dev_addr);
1509
1510         if (event->edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE) {
1511                 wfd_oem_new_service_s *service = NULL;;
1512                 GList *temp = NULL;
1513                 GList *services = (GList*) event->edata;
1514                 int count = 0;
1515
1516                 WDS_LOGD("%d service data found", event->dev_role);
1517
1518                 temp = g_list_first(services);
1519                 while (temp && count < event->dev_role) {
1520                         service = (wfd_oem_new_service_s*) temp->data;
1521                         service_type = service->protocol;
1522                         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
1523                                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1524                                 g_snprintf(response_data, 256, "%s|%s", service->data.bonjour.query, service->data.bonjour.rdata);
1525                                 WDS_LOGD("Found service: [%d: %s] - [" MACSECSTR "]", service->protocol,
1526                                                         service->data.bonjour.query, MAC2SECSTR(event->dev_addr));
1527                         } else {
1528                                 WDS_LOGD("Found service is not supported");
1529                                 goto next;
1530                         }
1531
1532                         wfd_manager_dbus_emit_signal(WFD_MANAGER_SERVICE_INTERFACE,
1533                                                      "DiscoveryFound",
1534                                                      g_variant_new("(iss)", service_type,
1535                                                                             response_data,
1536                                                                             peer_mac_address));
1537 next:
1538                         temp = g_list_next(temp);
1539                         service = NULL;
1540                         count++;
1541                 }
1542         } else if (event->edata_type == WFD_OEM_EDATA_TYPE_SERVICE) {
1543                 wfd_oem_service_data_s *edata = (wfd_oem_service_data_s*) event->edata;
1544
1545                 if (!edata) {
1546                         service_type = -1;
1547                 } else {
1548                         service_type = edata->type;
1549                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1550                         switch (edata->type) {
1551                                 WDS_LOGE("Unknown type [type ID: %d]", edata->type);
1552                         }
1553                 }
1554
1555                 wfd_manager_dbus_emit_signal(WFD_MANAGER_SERVICE_INTERFACE,
1556                                              "DiscoveryFound",
1557                                              g_variant_new("(iss)", service_type,
1558                                                                     response_data,
1559                                                                     peer_mac_address));
1560         }
1561
1562         __WDS_LOG_FUNC_EXIT__;
1563         return;
1564 }
1565
1566 void wfd_event_serv_disc_started(wfd_oem_event_s *event)
1567 {
1568         __WDS_LOG_FUNC_ENTER__;
1569
1570         __WDS_LOG_FUNC_EXIT__;
1571         return;
1572 }
1573 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1574
1575
1576 #if defined(TIZEN_FEATURE_ASP)
1577 void wfd_event_asp_serv_resp(wfd_oem_event_s *event)
1578 {
1579         __WDS_LOG_FUNC_ENTER__;
1580
1581         wfd_oem_asp_service_s *service = NULL;
1582         GVariantBuilder *builder = NULL;
1583         GVariant *params = NULL;
1584
1585         service = (wfd_oem_asp_service_s *)event->edata;
1586         if (service == NULL) {
1587                 WDS_LOGE("P2P service found event has NULL information");
1588                 __WDS_LOG_FUNC_EXIT__;
1589                 return;
1590         }
1591
1592         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1593         g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("u", service->search_id));
1594         g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", event->dev_addr));
1595         g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
1596         g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
1597         if (service->service_type)
1598                 g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
1599         if (service->service_info)
1600                 g_variant_builder_add(builder, "{sv}", "service_info", g_variant_new("s", service->service_info));
1601         g_variant_builder_add(builder, "{sv}", "status", g_variant_new("y", service->status));
1602         params = g_variant_new("(a{sv})", builder);
1603         g_variant_builder_unref(builder);
1604
1605         wfd_manager_dbus_emit_signal(WFD_MANAGER_ASP_INTERFACE,
1606                                      "SearchResult",
1607                                      params);
1608
1609         __WDS_LOG_FUNC_EXIT__;
1610         return;
1611 }
1612
1613 int __wfd_handle_asp_prov(wfd_manager_s *manager, wfd_oem_event_s *event)
1614 {
1615         __WDS_LOG_FUNC_ENTER__;
1616
1617         wfd_session_s *session = NULL;
1618         wfd_oem_asp_prov_s *prov_params = NULL;
1619         int res = 0;
1620
1621         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1622         if (prov_params == NULL) {
1623                 WDS_LOGE("Invalid parameter");
1624                 __WDS_LOG_FUNC_EXIT__;
1625                 return -1;
1626         }
1627
1628         res = wfd_session_process_event(manager, event);
1629         session = (wfd_session_s *)manager->session;
1630         if (res < 0 || session == NULL) {
1631                 WDS_LOGE("Failed to process event of session");
1632                 __WDS_LOG_FUNC_EXIT__;
1633                 return -1;
1634         }
1635         session->session_id = prov_params->session_id;
1636         memcpy(session->session_mac, prov_params->session_mac, MACADDR_LEN);
1637         memcpy(session->service_mac, prov_params->service_mac, MACADDR_LEN);
1638
1639         __WDS_LOG_FUNC_EXIT__;
1640         return 0;
1641 }
1642
1643 int __wfd_handle_asp_prov_done(wfd_session_s *session, wfd_oem_event_s *event)
1644 {
1645         __WDS_LOG_FUNC_ENTER__;
1646
1647         wfd_oem_asp_prov_s *prov_params = NULL;
1648         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1649         int res = 0;
1650
1651         if (prov_params->persist &&
1652         (prov_params->network_role || prov_params->network_config)) {
1653                 WDS_LOGE("Persistent group is used but "
1654                                 "conncap/dev_passwd_id are present");
1655                 __WDS_LOG_FUNC_EXIT__;
1656                 return -1;
1657         }
1658
1659         if (!prov_params->persist &&
1660         (!prov_params->network_role && !prov_params->network_config)) {
1661                 WDS_LOGE("Persistent group not used but "
1662                                 "conncap/dev_passwd_id are missing");
1663                 __WDS_LOG_FUNC_EXIT__;
1664                 return -1;
1665         }
1666
1667         if (session->wps_mode == WFD_OEM_WPS_MODE_P2PS)
1668                 g_strlcpy(session->wps_pin, OEM_DEFAULT_P2PS_PIN, OEM_PINSTR_LEN + 1);
1669
1670         if (prov_params->persist) {
1671                 res = wfd_session_asp_persistent_connect(session, prov_params->persistent_group_id);
1672         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_NEW) {
1673                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_NEW);
1674         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_CLIENT) {
1675                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_CLIENT);
1676         } else if (prov_params->network_role == WFD_OEM_ASP_SESSION_ROLE_GO) {
1677                 res = wfd_session_asp_connect(session, WFD_OEM_ASP_SESSION_ROLE_GO);
1678                 WDS_LOGD("don't need to take action.");
1679
1680         } else {
1681                 WDS_LOGE("Unhandled event");
1682                 __WDS_LOG_FUNC_EXIT__;
1683                 res = -1;
1684         }
1685
1686         __WDS_LOG_FUNC_EXIT__;
1687         return res;
1688 }
1689 void wfd_event_asp_prov_start(wfd_oem_event_s *event)
1690 {
1691         __WDS_LOG_FUNC_ENTER__;
1692
1693         wfd_manager_s *manager = wfd_get_manager();
1694         wfd_session_s *session = NULL;
1695         wfd_oem_asp_prov_s *prov_params = NULL;
1696         int res = 0;
1697
1698         if (event == NULL || event->edata == NULL) {
1699                 WDS_LOGE("Invalid parameter");
1700                 __WDS_LOG_FUNC_EXIT__;
1701                 return;
1702         }
1703
1704         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1705         res = __wfd_handle_asp_prov(manager, event);
1706         session = (wfd_session_s *)manager->session;
1707         if (res < 0 || session == NULL) {
1708                 WDS_LOGE("Failed to process event of session");
1709                 __WDS_LOG_FUNC_EXIT__;
1710                 return;
1711         }
1712
1713         WDS_LOGD("created session [%u] with peer [" MACSTR "]", session->session_id,
1714                         MAC2STR(session->session_mac));
1715
1716         /* Incomming Session, auto_accept = TRUE emit request Received */
1717         /* generate SessionConfigRequest if event->wps_mode is not P2PS  and return*/
1718
1719         wfd_session_timer(session, 1);
1720         wfd_asp_session_request(prov_params);
1721         wfd_asp_connect_status(prov_params->session_mac,
1722                                                 prov_params->session_id,
1723                                                 ASP_CONNECT_STATUS_REQUEST_RECEIVED,
1724                                                 NULL);
1725
1726         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
1727
1728         __WDS_LOG_FUNC_EXIT__;
1729         return;
1730 }
1731
1732 void wfd_event_asp_prov_done(wfd_oem_event_s *event)
1733 {
1734         __WDS_LOG_FUNC_ENTER__;
1735
1736         wfd_manager_s *manager = wfd_get_manager();
1737         wfd_session_s *session = NULL;
1738         wfd_oem_asp_prov_s *prov_params;
1739         int res = 0;
1740
1741         if (event == NULL || event->edata == NULL) {
1742                 WDS_LOGE("Invalid parameter");
1743                 __WDS_LOG_FUNC_EXIT__;
1744                 return;
1745         }
1746
1747         prov_params = (wfd_oem_asp_prov_s *)event->edata;
1748         /* Incomming Session, auto_accept = TRUE emit request Received */
1749         /* generate SessionConfigRequest if event->wps_mode is not P2PS  and return*/
1750         if (manager->session == NULL) {
1751                 wfd_asp_session_request(prov_params);
1752                 wfd_asp_connect_status(prov_params->session_mac,
1753                                                         prov_params->session_id,
1754                                                         ASP_CONNECT_STATUS_REQUEST_RECEIVED,
1755                                                         NULL);
1756         }
1757
1758         res = __wfd_handle_asp_prov(manager, event);
1759         session = (wfd_session_s *)manager->session;
1760         if (res < 0 || session == NULL) {
1761                 WDS_LOGE("Failed to process event of session");
1762                 wfd_destroy_session(manager);
1763                 wfd_asp_connect_status(prov_params->session_mac,
1764                                                         prov_params->session_id,
1765                                                         ASP_CONNECT_STATUS_REQUEST_FAILED,
1766                                                         NULL);
1767                 wfd_oem_refresh(manager->oem_ops);
1768                 __WDS_LOG_FUNC_EXIT__;
1769                 return;
1770         }
1771
1772         if (prov_params->status != WFD_OEM_SC_SUCCESS &&
1773                         prov_params->status != WFD_OEM_SC_SUCCESS_ACCEPTED_BY_USER) {
1774                 WDS_LOGD("ASP-PROV failed. remove session.");
1775                 wfd_destroy_session(manager);
1776                 wfd_oem_refresh(manager->oem_ops);
1777                 wfd_asp_connect_status(prov_params->session_mac,
1778                                                         prov_params->session_id,
1779                                                         ASP_CONNECT_STATUS_REQUEST_FAILED,
1780                                                         NULL);
1781                 __WDS_LOG_FUNC_EXIT__;
1782                 return;
1783         }
1784
1785         wfd_asp_connect_status(prov_params->session_mac,
1786                                                 prov_params->session_id,
1787                                                 ASP_CONNECT_STATUS_REQUEST_ACCEPTED,
1788                                                 NULL);
1789
1790         wfd_asp_connect_status(prov_params->session_mac,
1791                                                 prov_params->session_id,
1792                                                 ASP_CONNECT_STATUS_GROUP_FORMATION_STARTED,
1793                                                 NULL);
1794         res = __wfd_handle_asp_prov_done(session, event);
1795         if (res < 0) {
1796                 WDS_LOGE("Connect failed. remove session.");
1797                 wfd_destroy_session(manager);
1798                 wfd_oem_refresh(manager->oem_ops);
1799
1800                 wfd_asp_connect_status(prov_params->session_mac,
1801                                                         prov_params->session_id,
1802                                                         ASP_CONNECT_STATUS_GROUP_FORMATION_FAILED,
1803                                                         NULL);
1804                 __WDS_LOG_FUNC_EXIT__;
1805                 return;
1806         }
1807
1808         WDS_LOGD("Provision done succeeded.");
1809         __WDS_LOG_FUNC_EXIT__;
1810         return;
1811 }
1812 #endif /* TIZEN_FEATURE_ASP */
1813
1814 void wfd_event_init(wfd_oem_event_cbs_s *event_cbs)
1815 {
1816         __WDS_LOG_FUNC_ENTER__;
1817
1818         if (!event_cbs) {
1819                 __WDS_LOG_FUNC_EXIT__;
1820                 return;
1821         }
1822
1823         event_cbs->deactivated_cb = wfd_event_deactivated;
1824         event_cbs->peer_found_cb = wfd_event_peer_found;
1825         event_cbs->peer_disappeared_cb = wfd_event_peer_disappeared;
1826         event_cbs->discovery_finished_cb = wfd_event_discovery_finished;
1827
1828         event_cbs->prov_disc_req_cb = wfd_event_prov_disc_req;
1829         event_cbs->prov_disc_resp_cb = wfd_event_prov_disc_resp;
1830         event_cbs->prov_disc_fail_cb = wfd_event_prov_disc_fail;
1831
1832         event_cbs->go_neg_req_cb = wfd_event_go_neg_req;
1833         event_cbs->go_neg_fail_cb = wfd_event_go_neg_fail;
1834         event_cbs->go_neg_done_cb = wfd_event_go_neg_done;
1835
1836         event_cbs->wps_fail_cb = wfd_event_wps_fail;
1837         event_cbs->wps_done_cb = wfd_event_wps_done;
1838         event_cbs->key_neg_fail_cb = wfd_event_key_neg_fail;
1839         event_cbs->key_neg_done_cb = wfd_event_key_neg_done;
1840
1841         event_cbs->conn_fail_cb = wfd_event_conn_fail;
1842         event_cbs->conn_done_cb = wfd_event_conn_done;
1843
1844         event_cbs->group_created_cb = wfd_event_group_created;
1845         event_cbs->group_destroyed_cb = wfd_event_group_destroyed;
1846
1847         event_cbs->invitation_req_cb = wfd_event_invitation_req;
1848         event_cbs->invitation_resp_cb = wfd_event_invitation_res;
1849         event_cbs->sta_connected_cb = wfd_event_sta_connected;
1850         event_cbs->sta_disconnected_cb = wfd_event_sta_disconnected;
1851
1852         event_cbs->terminating_cb = wfd_event_terminating;
1853
1854 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1855         event_cbs->serv_disc_resp_cb = wfd_event_serv_disc_resp;
1856         event_cbs->serv_disc_started_cb = wfd_event_serv_disc_started;
1857 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1858
1859         event_cbs->group_formation_failure_cb = wfd_event_group_formation_failure;
1860         event_cbs->invitation_accepted_cb = wfd_event_invitation_accepted;
1861
1862 #if defined(TIZEN_FEATURE_ASP)
1863         event_cbs->asp_serv_resp_cb = wfd_event_asp_serv_resp;
1864         event_cbs->asp_prov_start_cb = wfd_event_asp_prov_start;
1865         event_cbs->asp_prov_done_cb = wfd_event_asp_prov_done;
1866 #endif /* TIZEN_FEATURE_ASP */
1867
1868         event_cbs->extra_data = NULL;
1869
1870         __WDS_LOG_FUNC_EXIT__;
1871         return;
1872 }