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