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