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