src/wifi-direct-event.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct event functions.
  22  *
  23  * @file                wifi-direct-event.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <poll.h>
  31 #include <unistd.h>
  32 #include <time.h>
  33 #include <errno.h>
  34
  35 #include <glib.h>
  36
  37 #include <wifi-direct.h>
  38
  39 #include "wifi-direct-ipc.h"
  40 #include "wifi-direct-manager.h"
  41 #include "wifi-direct-oem.h"
  42 #include "wifi-direct-peer.h"
  43 #include "wifi-direct-group.h"
  44 #include "wifi-direct-session.h"
  45 #include "wifi-direct-event.h"
  46 #include "wifi-direct-client.h"
  47 #include "wifi-direct-state.h"
  48 #include "wifi-direct-util.h"
  49
  50
  51 static int _wfd_event_update_peer(wfd_manager_s *manager, wfd_oem_dev_data_s *data)
  52 {
  53         __WDS_LOG_FUNC_ENTER__;
  54
  55         wfd_device_s *peer = NULL;
  56
  57         if (!manager || !data) {
  58                 WDS_LOGE("Invalid parameter");
  59                 __WDS_LOG_FUNC_EXIT__;
  60                 return -1;
  61         }
  62
  63         peer = wfd_peer_find_by_dev_addr(manager, data->p2p_dev_addr);
  64         if (!peer) {
  65                 peer = wfd_add_peer(manager, data->p2p_dev_addr, data->name);
  66                 if (!peer) {
  67                         WDS_LOGE("Failed to add peer");
  68                         __WDS_LOG_FUNC_EXIT__;
  69                         return -1;
  70                 }
  71         } else {
  72                 if (strcmp(peer->dev_name, data->name)) {
  73                         g_strlcpy(peer->dev_name, data->name, DEV_NAME_LEN + 1);
  74                         WDS_LOGD("Device name is changed [" MACSECSTR ": %s]",
  75                                         MAC2SECSTR(peer->dev_addr), peer->dev_name);
  76                 }
  77         }
  78 #ifndef CTRL_IFACE_DBUS
  79         memcpy(peer->intf_addr, data->p2p_intf_addr, MACADDR_LEN);
  80 #endif /* CTRL_IFACE_DBUS */
  81         peer->pri_dev_type = data->pri_dev_type;
  82         peer->sec_dev_type = data->sec_dev_type;
  83         peer->config_methods = data->config_methods;
  84         peer->dev_flags = data->dev_flags;
  85         peer->group_flags = data->group_flags;
  86         peer->dev_role = data->dev_role;
  87 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
  88         memcpy(&(peer->display), &(data->display), sizeof(wfd_display_s));
  89 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
  90
  91 #if !(__GNUC__ <= 4 && __GNUC_MINOR__ < 8)
  92         wfd_util_get_current_time(&peer->time);
  93 #else
  94         struct timeval tval;
  95         gettimeofday(&tval, NULL);
  96         peer->time = tval.tv_sec;
  97 #endif
  98         WDS_LOGI("Update time [%s - %ld]", peer->dev_name, peer->time);
  99
 100         __WDS_LOG_FUNC_EXIT__;
 101         return 0;
 102 }
 103
 104  gboolean _wfd_connection_retry(gpointer *data)
 105 {
 106         wfd_session_s *session = (wfd_session_s*) data;
 107         if (!session) {
 108                 WDS_LOGE("Session is NULL");
 109                 __WDS_LOG_FUNC_EXIT__;
 110                 return G_SOURCE_REMOVE;
 111         }
 112
 113         switch (session->state) {
 114                 case SESSION_STATE_STARTED:
 115                         WDS_LOGD("PD again");
 116                         wfd_session_start(session);
 117                         break;
 118                 case SESSION_STATE_GO_NEG:
 119                         WDS_LOGD("Negotiation again");
 120                         wfd_session_connect(session);
 121                         break;
 122                 case SESSION_STATE_WPS:
 123                         WDS_LOGD("WPS again");
 124                         wfd_session_wps(session);
 125                         break;
 126                 default:
 127                         WDS_LOGE("Invalid session state [%d]", session->state);
 128                         break;
 129         }
 130         __WDS_LOG_FUNC_EXIT__;
 131         return G_SOURCE_REMOVE;
 132 }
 133
 134 static void __wfd_process_deactivated(wfd_manager_s *manager, wfd_oem_event_s *event)
 135 {
 136         __WDS_LOG_FUNC_ENTER__;
 137
 138         wifi_direct_client_noti_s noti;
 139
 140         if (event == NULL || manager == NULL) {
 141                 WDS_LOGE("Invalid parameter");
 142                 __WDS_LOG_FUNC_EXIT__;
 143                 return;
 144         }
 145
 146         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 147         noti.event = WIFI_DIRECT_CLI_EVENT_DEACTIVATION;
 148         noti.error = WIFI_DIRECT_ERROR_NONE;
 149         wfd_client_send_event(manager, &noti);
 150
 151         wfd_destroy_group(manager, GROUP_IFNAME);
 152         wfd_destroy_session(manager);
 153         wfd_peer_clear_all(manager);
 154         wfd_local_reset_data(manager);
 155
 156         wfd_state_set(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 157         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED);
 158         manager->req_wps_mode = WFD_WPS_MODE_PBC;
 159
 160 #ifdef TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT
 161         wfd_util_stop_wifi_direct_popup();
 162 #endif /* TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT */
 163         __WDS_LOG_FUNC_EXIT__;
 164         return;
 165 }
 166
 167 static void __wfd_process_peer_found(wfd_manager_s *manager, wfd_oem_event_s *event)
 168 {
 169         __WDS_LOG_FUNC_ENTER__;
 170
 171         wfd_oem_dev_data_s *edata = NULL;
 172         wifi_direct_client_noti_s noti;
 173         int res = 0;
 174
 175         if (event == NULL || manager == NULL) {
 176                 WDS_LOGE("Invalid parameter");
 177                 __WDS_LOG_FUNC_EXIT__;
 178                 return;
 179         }
 180
 181         edata = (wfd_oem_dev_data_s*) event->edata;
 182         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 183                 WDS_LOGE("Invalid event data");
 184                 __WDS_LOG_FUNC_EXIT__;
 185                 return;
 186         }
 187
 188         res = _wfd_event_update_peer(manager, edata);
 189         if (res < 0) {
 190                 WDS_LOGE("Failed to update peer data");
 191                 __WDS_LOG_FUNC_EXIT__;
 192                 return;
 193         }
 194
 195         if (manager->state > WIFI_DIRECT_STATE_ACTIVATING &&
 196                         manager->state != WIFI_DIRECT_STATE_CONNECTING &&
 197                         manager->state != WIFI_DIRECT_STATE_DISCONNECTING) {
 198                 memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 199                 snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(edata->p2p_dev_addr));
 200                 noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS;
 201                 noti.error = WIFI_DIRECT_ERROR_NONE;
 202                 wfd_client_send_event(manager, &noti);
 203         }
 204
 205         __WDS_LOG_FUNC_EXIT__;
 206         return;
 207 }
 208
 209 static void __wfd_process_peer_disappeared(wfd_manager_s *manager, wfd_oem_event_s *event)
 210 {
 211         __WDS_LOG_FUNC_ENTER__;
 212
 213         wifi_direct_client_noti_s noti;
 214         wfd_session_s *session = NULL;
 215         wfd_device_s *peer = NULL;
 216
 217         if (event == NULL || manager == NULL) {
 218                 WDS_LOGE("Invalid parameter");
 219                 __WDS_LOG_FUNC_EXIT__;
 220                 return;
 221         }
 222
 223         session = manager->session;
 224         if(session != NULL && session->peer != NULL) {
 225                 peer = session->peer;
 226                 WDS_LOGD("session peer [" MACSTR "] lost peer ["  MACSTR "]", MAC2STR(peer->dev_addr),
 227                                                 MAC2STR(event->dev_addr));
 228                 if(memcmp(peer->dev_addr, event->dev_addr, MACADDR_LEN) == 0) {
 229                         WDS_LOGD("peer already in connection");
 230                         return;
 231                 }
 232         }
 233
 234         wfd_remove_peer(manager, event->dev_addr);
 235
 236         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 237         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
 238         noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_LOST_PEERS;
 239         noti.error = WIFI_DIRECT_ERROR_NONE;
 240         wfd_client_send_event(manager, &noti);
 241
 242         __WDS_LOG_FUNC_EXIT__;
 243         return;
 244 }
 245
 246 static void __wfd_process_discovery_finished(wfd_manager_s *manager, wfd_oem_event_s *event)
 247 {
 248         __WDS_LOG_FUNC_ENTER__;
 249
 250         wifi_direct_client_noti_s noti;
 251
 252         if (event == NULL || manager == NULL) {
 253                 WDS_LOGE("Invalid parameter");
 254                 __WDS_LOG_FUNC_EXIT__;
 255                 return;
 256         }
 257
 258         if (manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 259                         manager->state != WIFI_DIRECT_STATE_ACTIVATED) {
 260                 WDS_LOGE("Notify finding stopped when discovering or activated. [%d]", manager->state);
 261                 __WDS_LOG_FUNC_EXIT__;
 262                 return;
 263         }
 264
 265         if (manager->scan_mode == WFD_SCAN_MODE_PASSIVE) {
 266                 WDS_LOGE("During passive scan, Discover Finished event will not notified");
 267                 __WDS_LOG_FUNC_EXIT__;
 268                 return;
 269         }
 270
 271         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 272                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 273                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 274         } else {
 275                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 276                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 277         }
 278         manager->scan_mode = WFD_SCAN_MODE_NONE;
 279
 280         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 281         noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;
 282         noti.error = WIFI_DIRECT_ERROR_NONE;
 283         wfd_client_send_event(manager, &noti);
 284
 285         __WDS_LOG_FUNC_EXIT__;
 286         return;
 287 }
 288
 289 static void __wfd_process_prov_disc_req(wfd_manager_s *manager, wfd_oem_event_s *event)
 290 {
 291         __WDS_LOG_FUNC_ENTER__;
 292
 293         wfd_device_s *peer = NULL;
 294         int res = 0;
 295
 296         if (event == NULL || manager == NULL) {
 297                 WDS_LOGE("Invalid parameter");
 298                 __WDS_LOG_FUNC_EXIT__;
 299                 return;
 300         }
 301
 302         wfd_group_s *group = (wfd_group_s*) manager->group;
 303         if (group && group->role == WFD_DEV_ROLE_GC &&
 304                                                 event->event_id == WFD_OEM_EVENT_PROV_DISC_REQ) {
 305                 WDS_LOGD("Device has GC role - ignore this provision request");
 306                 __WDS_LOG_FUNC_EXIT__;
 307                 return;
 308         }
 309
 310 #ifdef CTRL_IFACE_DBUS
 311         wfd_oem_dev_data_s *edata = NULL;
 312
 313         edata = (wfd_oem_dev_data_s*) event->edata;
 314         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 315                 WDS_LOGE("Invalid event data");
 316                 __WDS_LOG_FUNC_EXIT__;
 317                 return;
 318         }
 319
 320         res = _wfd_event_update_peer(manager, edata);
 321         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 322         if (peer)
 323                 peer->state = WFD_PEER_STATE_CONNECTING;
 324 #else /* CTRL_IFACE_DBUS */
 325         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 326         if (!peer) {
 327                 WDS_LOGD("Prov_disc from unknown peer. Add new peer");
 328                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
 329                 if (!peer) {
 330                         WDS_LOGE("Failed to add peer for invitation");
 331                         __WDS_LOG_FUNC_EXIT__;
 332                         return;
 333                 }
 334                 peer->state = WFD_PEER_STATE_CONNECTING;
 335                 wfd_update_peer(manager, peer);
 336         }
 337         wfd_update_peer_time(manager, event->dev_addr);
 338 #endif /* CTRL_IFACE_DBUS */
 339
 340         res = wfd_session_process_event(manager, event);
 341         if (res < 0)
 342                 WDS_LOGE("Failed to process event of session");
 343
 344         __WDS_LOG_FUNC_EXIT__;
 345         return;
 346 }
 347
 348 static void __wfd_process_prov_disc_resp(wfd_manager_s *manager, wfd_oem_event_s *event)
 349 {
 350         __WDS_LOG_FUNC_ENTER__;
 351
 352         wfd_device_s *peer = NULL;
 353         int res = 0;
 354
 355         if (event == NULL || manager == NULL) {
 356                 WDS_LOGE("Invalid parameter");
 357                 __WDS_LOG_FUNC_EXIT__;
 358                 return;
 359         }
 360
 361 #ifdef CTRL_IFACE_DBUS
 362         wfd_oem_dev_data_s *edata = NULL;
 363
 364         edata = (wfd_oem_dev_data_s*) event->edata;
 365         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 366                 WDS_LOGE("Invalid event data");
 367                 __WDS_LOG_FUNC_EXIT__;
 368                 return;
 369         }
 370
 371         res = _wfd_event_update_peer(manager, edata);
 372         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 373         if (peer)
 374                 peer->state = WFD_PEER_STATE_CONNECTING;
 375 #else /* CTRL_IFACE_DBUS */
 376         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 377         if (!peer) {
 378                 WDS_LOGD("Prov_disc from unknown peer. Add new peer");
 379                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
 380                 if (!peer) {
 381                         WDS_LOGE("Failed to add peer for invitation");
 382                         __WDS_LOG_FUNC_EXIT__;
 383                         return;
 384                 }
 385                 peer->state = WFD_PEER_STATE_CONNECTING;
 386                 wfd_update_peer(manager, peer);
 387         }
 388         wfd_update_peer_time(manager, event->dev_addr);
 389 #endif /* CTRL_IFACE_DBUS */
 390
 391         res = wfd_session_process_event(manager, event);
 392         if (res < 0)
 393                 WDS_LOGE("Failed to process event of session");
 394
 395         __WDS_LOG_FUNC_EXIT__;
 396         return;
 397 }
 398
 399 static void __wfd_process_prov_disc_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
 400 {
 401         __WDS_LOG_FUNC_ENTER__;
 402
 403         wfd_session_s *session = NULL;
 404         wifi_direct_client_noti_s noti;
 405         unsigned char *peer_addr = NULL;
 406
 407         if (event == NULL || manager == NULL) {
 408                 WDS_LOGE("Invalid parameter");
 409                 __WDS_LOG_FUNC_EXIT__;
 410                 return;
 411         }
 412
 413         session = (wfd_session_s*) manager->session;
 414         if (!session) {
 415                 WDS_LOGE("Unexpected event. Session not exist");
 416                 __WDS_LOG_FUNC_EXIT__;
 417                 return;
 418         }
 419
 420         peer_addr = wfd_session_get_peer_addr(session);
 421         if (!peer_addr) {
 422                 WDS_LOGE("Session do not have peer");
 423                 __WDS_LOG_FUNC_EXIT__;
 424                 return;
 425         }
 426
 427         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 428         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 429         noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
 430         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 431         wfd_client_send_event(manager, &noti);
 432
 433         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 434                 wfd_group_s *group = (wfd_group_s*) manager->group;
 435                 if (group && !group->member_count && (wfd_group_is_autonomous(group) == FALSE)) {
 436                         wfd_destroy_group(manager, GROUP_IFNAME);
 437
 438                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 439                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 440                 } else {
 441                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 442                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 443                 }
 444         } else {
 445                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 446                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 447         }
 448
 449         wfd_destroy_session(manager);
 450
 451         wfd_oem_refresh(manager->oem_ops);
 452 #if 0
 453         /* After connection failed, scan again */
 454         wfd_oem_scan_param_s param;
 455         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 456         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 457         param.scan_time = 2;
 458         param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 459         wfd_oem_start_scan(manager->oem_ops, &param);
 460         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
 461 #endif
 462         __WDS_LOG_FUNC_EXIT__;
 463         return;
 464 }
 465
 466 static void __wfd_process_go_neg_req(wfd_manager_s *manager, wfd_oem_event_s *event)
 467 {
 468         __WDS_LOG_FUNC_ENTER__;
 469
 470         wfd_session_s *session = NULL;
 471         wifi_direct_client_noti_s noti;
 472
 473         if (event == NULL || manager == NULL) {
 474                 WDS_LOGE("Invalid parameter");
 475                 __WDS_LOG_FUNC_EXIT__;
 476                 return;
 477         }
 478
 479         wfd_group_s *group = (wfd_group_s*) manager->group;
 480         if (group && group->role == WFD_DEV_ROLE_GC) {
 481                 WDS_LOGD("Device has GC role - ignore this go neg request");
 482                 __WDS_LOG_FUNC_EXIT__;
 483                 return;
 484         }
 485
 486 #ifdef CTRL_IFACE_DBUS
 487         wfd_oem_dev_data_s *edata = NULL;
 488         int res = 0;
 489
 490         edata = (wfd_oem_dev_data_s*) event->edata;
 491         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_DEVICE) {
 492                 WDS_LOGE("Invalid event data");
 493                 __WDS_LOG_FUNC_EXIT__;
 494                 return;
 495         }
 496
 497         res = _wfd_event_update_peer(manager, edata);
 498         if (res < 0) {
 499                 WDS_LOGE("Failed to update peer data");
 500                 __WDS_LOG_FUNC_EXIT__;
 501                 return;
 502         }
 503 #else /* CTRL_IFACE_DBUS */
 504         wfd_oem_conn_data_s *edata = NULL;
 505         wfd_device_s *peer = NULL;
 506
 507         edata = (wfd_oem_conn_data_s*) event->edata;
 508         if (!edata || event->edata_type != WFD_OEM_EDATA_TYPE_CONN) {
 509                 WDS_LOGE("Invalid connection event data");
 510                 __WDS_LOG_FUNC_EXIT__;
 511                 return;
 512         }
 513
 514         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 515         if (!peer) {
 516                 WDS_LOGD("Invitation from unknown peer. Add new peer");
 517                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
 518                 if (!peer) {
 519                         WDS_LOGE("Failed to add peer for invitation");
 520                         __WDS_LOG_FUNC_EXIT__;
 521                         return;
 522                 }
 523         }
 524
 525         if (edata->wps_mode == 0)
 526                 edata->wps_mode = 1;
 527 #endif /* CTRL_IFACE_DBUS */
 528
 529         session = (wfd_session_s*) manager->session;
 530         if (!session) {
 531                 session = wfd_create_session(manager, event->dev_addr,
 532 #ifdef CTRL_IFACE_DBUS
 533                                                 event->wps_mode, SESSION_DIRECTION_INCOMING);
 534 #else /* CTRL_IFACE_DBUS */
 535                                                 edata->wps_mode, SESSION_DIRECTION_INCOMING);
 536 #endif /* CTRL_IFACE_DBUS */
 537                 if (!session) {
 538                         WDS_LOGE("Failed to create session");
 539                         __WDS_LOG_FUNC_EXIT__;
 540                         return;
 541                 }
 542                 session->type = SESSION_TYPE_NORMAL;
 543                 session->state = SESSION_STATE_GO_NEG;
 544                 wfd_session_timer(session, 1);
 545                 wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
 546
 547                 memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 548                 noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ;
 549                 noti.error = WIFI_DIRECT_ERROR_NONE;
 550                 g_snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(event->dev_addr));
 551                 wfd_client_send_event(manager, &noti);
 552         } else {
 553                 wfd_session_process_event(manager, event);
 554         }
 555         __WDS_LOG_FUNC_EXIT__;
 556         return;
 557 }
 558
 559  static void __wfd_process_go_neg_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
 560  {
 561         __WDS_LOG_FUNC_ENTER__;
 562
 563         wfd_session_s *session = NULL;
 564         wfd_oem_conn_data_s *edata = NULL;
 565         wifi_direct_client_noti_s noti;
 566         unsigned char *peer_addr = NULL;
 567
 568         if (event == NULL || manager == NULL) {
 569                 WDS_LOGE("Invalid parameter");
 570                 __WDS_LOG_FUNC_EXIT__;
 571                 return;
 572         }
 573
 574         session = (wfd_session_s*) manager->session;
 575         if (!session) {
 576                 WDS_LOGE("Unexpected event. Session not exist");
 577                 __WDS_LOG_FUNC_EXIT__;
 578                 return;
 579         }
 580
 581         peer_addr = wfd_session_get_peer_addr(session);
 582         if (!peer_addr) {
 583                 WDS_LOGE("Session do not have peer");
 584                 __WDS_LOG_FUNC_EXIT__;
 585                 return;
 586         }
 587
 588         edata = (wfd_oem_conn_data_s*) event->edata;
 589         if (!edata) {
 590                 WDS_LOGE("Invalid p2p connection data");
 591                 __WDS_LOG_FUNC_EXIT__;
 592                 return;
 593         }
 594
 595         if (edata->status < 0 && session->connecting_120) {
 596                 if (session->retry_gsrc) {
 597                         g_source_remove(session->retry_gsrc);
 598                         session->retry_gsrc = 0;
 599                 }
 600                 session->retry_gsrc = g_idle_add((GSourceFunc) _wfd_connection_retry, session);
 601                 WDS_LOGD("Connection will be retried");
 602                 __WDS_LOG_FUNC_EXIT__;
 603                 return;
 604         }
 605
 606         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 607         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 608         noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
 609         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 610         wfd_client_send_event(manager, &noti);
 611
 612         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 613         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 614
 615         wfd_destroy_group(manager, GROUP_IFNAME);
 616         wfd_destroy_session(manager);
 617         manager->local->dev_role = WFD_DEV_ROLE_NONE;
 618         __WDS_LOG_FUNC_EXIT__;
 619         return;
 620 }
 621
 622 static void __wfd_process_go_neg_done(wfd_manager_s *manager, wfd_oem_event_s *event)
 623 {
 624         __WDS_LOG_FUNC_ENTER__;
 625
 626 #ifdef CTRL_IFACE_DBUS
 627         wfd_session_s *session = NULL;
 628         wfd_oem_conn_data_s *edata = NULL;
 629         wfd_device_s *peer = NULL;
 630
 631         if (event == NULL || manager == NULL) {
 632                 WDS_LOGE("Invalid parameter");
 633                 __WDS_LOG_FUNC_EXIT__;
 634                 return;
 635         }
 636
 637         edata = (wfd_oem_conn_data_s*) event->edata;
 638         if (edata == NULL) {
 639                 WDS_LOGE("Invalid event data");
 640                 __WDS_LOG_FUNC_EXIT__;
 641                 return;
 642         }
 643
 644         session = (wfd_session_s*) manager->session;
 645         if(session && session->peer) {
 646                 peer = session->peer;
 647                 memcpy(peer->intf_addr, edata->peer_intf_addr, MACADDR_LEN);
 648         }
 649         manager->local->dev_role = event->dev_role;
 650         wfd_session_process_event(manager, event);
 651 #endif /* CTRL_IFACE_DBUS */
 652         __WDS_LOG_FUNC_EXIT__;
 653         return;
 654 }
 655
 656 static void __wfd_process_wps_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
 657 {
 658         __WDS_LOG_FUNC_ENTER__;
 659
 660         wfd_session_s *session = NULL;
 661         wifi_direct_client_noti_s noti;
 662         unsigned char *peer_addr = NULL;
 663
 664         if (event == NULL || manager == NULL) {
 665                 WDS_LOGE("Invalid parameter");
 666                 __WDS_LOG_FUNC_EXIT__;
 667                 return;
 668         }
 669
 670         session = (wfd_session_s*) manager->session;
 671         if (!session) {
 672                 WDS_LOGE("Unexpected event. Session not exist");
 673                 __WDS_LOG_FUNC_EXIT__;
 674                 return;
 675         }
 676
 677         peer_addr = wfd_session_get_peer_addr(session);
 678         if (!peer_addr) {
 679                 WDS_LOGE("Session do not have peer");
 680                 __WDS_LOG_FUNC_EXIT__;
 681                 return;
 682         }
 683
 684         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 685         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 686         noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
 687         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 688         wfd_client_send_event(manager, &noti);
 689
 690         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 691                 wfd_group_s *group = (wfd_group_s*) manager->group;
 692                 if (group && !group->member_count && (wfd_group_is_autonomous(group) == FALSE)) {
 693                         wfd_destroy_group(manager, GROUP_IFNAME);
 694
 695                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 696                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 697                 } else {
 698                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 699                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 700                 }
 701         } else {
 702                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 703                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 704         }
 705
 706         wfd_destroy_session(manager);
 707
 708         wfd_oem_refresh(manager->oem_ops);
 709 #if 0
 710         /* After connection failed, scan again */
 711         wfd_oem_scan_param_s param;
 712         memset(&param, 0x0, sizeof(wfd_oem_scan_param_s));
 713         param.scan_mode = WFD_OEM_SCAN_MODE_ACTIVE;
 714         param.scan_time = 2;
 715         param.scan_type = WFD_OEM_SCAN_TYPE_SOCIAL;
 716         wfd_oem_start_scan(manager->oem_ops, &param);
 717         manager->scan_mode = WFD_SCAN_MODE_ACTIVE;
 718 #endif
 719         __WDS_LOG_FUNC_EXIT__;
 720         return;
 721 }
 722
 723  static void __wfd_process_wps_done(wfd_manager_s *manager, wfd_oem_event_s *event)
 724  {
 725         __WDS_LOG_FUNC_ENTER__;
 726
 727         wfd_session_process_event(manager, event);
 728
 729         __WDS_LOG_FUNC_EXIT__;
 730         return;
 731  }
 732
 733 static void __wfd_process_key_neg_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
 734 {
 735         __WDS_LOG_FUNC_ENTER__;
 736
 737         wfd_session_s *session = NULL;
 738         wifi_direct_client_noti_s noti;
 739         unsigned char *peer_addr = NULL;
 740
 741         if (event == NULL || manager == NULL) {
 742                 WDS_LOGE("Invalid parameter");
 743                 __WDS_LOG_FUNC_EXIT__;
 744                 return;
 745         }
 746
 747         session = (wfd_session_s*) manager->session;
 748         if (!session) {
 749                 WDS_LOGE("Unexpected event. Session not exist");
 750                 __WDS_LOG_FUNC_EXIT__;
 751                 return;
 752         }
 753
 754         peer_addr = wfd_session_get_peer_addr(session);
 755         if (!peer_addr) {
 756                 WDS_LOGE("Session do not has peer");
 757                 __WDS_LOG_FUNC_EXIT__;
 758                 return;
 759         }
 760
 761         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 762         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 763         noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
 764         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 765         wfd_client_send_event(manager, &noti);
 766
 767         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 768                 wfd_group_s *group = (wfd_group_s*) manager->group;
 769                 if (group && !group->member_count && (wfd_group_is_autonomous(group) == FALSE)) {
 770                         wfd_destroy_group(manager, GROUP_IFNAME);
 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__;
 797         return;
 798 }
 799
 800 static void __wfd_process_key_neg_done(wfd_manager_s *manager, wfd_oem_event_s *event)
 801 {
 802         __WDS_LOG_FUNC_ENTER__;
 803
 804         __WDS_LOG_FUNC_EXIT__;
 805         return;
 806 }
 807
 808 static void __wfd_process_conn_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
 809 {
 810         __WDS_LOG_FUNC_ENTER__;
 811
 812         __WDS_LOG_FUNC_EXIT__;
 813         return;
 814 }
 815
 816 static void __wfd_process_conn_done(wfd_manager_s *manager, wfd_oem_event_s *event)
 817 {
 818         __WDS_LOG_FUNC_ENTER__;
 819
 820         __WDS_LOG_FUNC_EXIT__;
 821         return;
 822 }
 823
 824 static void __wfd_process_group_created(wfd_manager_s *manager, wfd_oem_event_s *event)
 825 {
 826         __WDS_LOG_FUNC_ENTER__;
 827
 828         wfd_group_s *group = NULL;
 829         wfd_session_s *session = NULL;
 830         wifi_direct_client_noti_s noti;
 831
 832         if (event == NULL || manager == NULL) {
 833                 WDS_LOGE("Invalid parameter");
 834                 __WDS_LOG_FUNC_EXIT__;
 835                 return;
 836         }
 837
 838         group = (wfd_group_s*) manager->group;
 839         session = (wfd_session_s*)manager->session;
 840 #ifdef CTRL_IFACE_DBUS
 841         if(event->dev_role == WFD_DEV_ROLE_GC && !group) {
 842
 843                 group = wfd_create_pending_group(manager, event->intf_addr);
 844                 if (!group) {
 845                         WDS_LOGE("Failed to create pending group");
 846                         __WDS_LOG_FUNC_EXIT__;
 847                         return;
 848                 }
 849                 manager->group = group;
 850         }
 851 #endif /* CTRL_IFACE_DBUS */
 852         if (!group) {
 853                 if (!session) {
 854                         WDS_LOGE("Unexpected Event. Group should be removed(Client)");
 855                         wfd_oem_destroy_group(manager->oem_ops, event->ifname);
 856                         __WDS_LOG_FUNC_EXIT__;
 857                         return;
 858                 }
 859
 860                 group = wfd_create_group(manager, event);
 861                 if (!group) {
 862                         WDS_LOGE("Failed to create group");
 863                         __WDS_LOG_FUNC_EXIT__;
 864                         return;
 865                 }
 866         } else {
 867                 if (!session && !(group->flags & WFD_GROUP_FLAG_AUTONOMOUS)) {
 868                         WDS_LOGE("Unexpected Event. Group should be removed(Owner)");
 869                         wfd_oem_destroy_group(manager->oem_ops, group->ifname);
 870                         __WDS_LOG_FUNC_EXIT__;
 871                         return;
 872                 }
 873
 874                 if (group->pending) {
 875                         wfd_group_complete(manager, event);
 876                 } else {
 877                         WDS_LOGE("Unexpected event. Group already exist");
 878                         __WDS_LOG_FUNC_EXIT__;
 879                         return;
 880                 }
 881         }
 882
 883         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 884         if (group->role == WFD_DEV_ROLE_GC && session) {
 885 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
 886                 wfd_device_s *peer = session->peer;
 887                 if(peer == NULL) {
 888                         WDS_LOGE("Unexpected event. Peer doesn't exist");
 889                         return;
 890                 }
 891
 892                 wfd_update_peer(manager, peer);
 893
 894                 if(peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
 895
 896                         wfd_util_ip_over_eap_assign(peer, event->ifname);
 897
 898                         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 899                         noti.error = WIFI_DIRECT_ERROR_NONE;
 900                         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
 901                         wfd_client_send_event(manager, &noti);
 902
 903                         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTED);
 904                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_CONNECTED);
 905
 906                         wfd_destroy_session(manager);
 907                 }
 908 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
 909                 wfd_peer_clear_all(manager);
 910         } else {
 911                 if (group->flags & WFD_GROUP_FLAG_AUTONOMOUS) {
 912                         noti.event = WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP;
 913                         wfd_client_send_event(manager, &noti);
 914                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 915                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 916                 }
 917         }
 918         __WDS_LOG_FUNC_EXIT__;
 919         return;
 920 }
 921
 922 static void __wfd_process_group_destroyed(wfd_manager_s *manager, wfd_oem_event_s *event)
 923 {
 924         __WDS_LOG_FUNC_ENTER__;
 925
 926         wifi_direct_client_noti_s noti;
 927
 928         if (event == NULL || manager == NULL) {
 929                 WDS_LOGE("Invalid parameter");
 930                 __WDS_LOG_FUNC_EXIT__;
 931                 return;
 932         }
 933
 934         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
 935         if (manager->state == WIFI_DIRECT_STATE_DISCONNECTING) {
 936                 noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
 937                 noti.error = WIFI_DIRECT_ERROR_NONE;
 938         } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING && manager->session){
 939                 noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
 940                 noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
 941                 unsigned char *peer_addr = wfd_session_get_peer_addr(manager->session);
 942                 if(peer_addr != NULL)
 943                         g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
 944         } else if (manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
 945                 if(manager->local->dev_role != WFD_DEV_ROLE_GO)
 946                         noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
 947                 else
 948                         noti.event = WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP;
 949                 noti.error = WIFI_DIRECT_ERROR_NONE;
 950         } else {
 951                 WDS_LOGD("Unexpected event(GROUP_DESTROYED). Ignore it");
 952                 __WDS_LOG_FUNC_EXIT__;
 953                 return;
 954         }
 955         wfd_client_send_event(manager, &noti);
 956
 957         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 958         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 959         wfd_destroy_group(manager, event->ifname);
 960         wfd_destroy_session(manager);
 961         manager->local->dev_role = WFD_DEV_ROLE_NONE;
 962
 963         __WDS_LOG_FUNC_EXIT__;
 964         return;
 965 }
 966
 967 static void __wfd_process_invitation_req(wfd_manager_s *manager, wfd_oem_event_s *event)
 968 {
 969         __WDS_LOG_FUNC_ENTER__;
 970
 971         wfd_device_s *peer = NULL;
 972         wfd_session_s *session = NULL;
 973         wfd_oem_invite_data_s *edata = NULL;
 974         wifi_direct_client_noti_s noti;
 975         int res = 0;
 976
 977         if (event == NULL || manager == NULL) {
 978                 WDS_LOGE("Invalid parameter");
 979                 __WDS_LOG_FUNC_EXIT__;
 980                 return;
 981         }
 982
 983         peer = wfd_peer_find_by_dev_addr(manager, event->dev_addr);
 984         if (!peer) {
 985                 WDS_LOGD("Invitation from unknown peer. Add new peer");
 986                 peer = wfd_add_peer(manager, event->dev_addr, "DIRECT-");
 987                 if (!peer) {
 988                         WDS_LOGE("Failed to add peer for invitation");
 989                         __WDS_LOG_FUNC_EXIT__;
 990                         return;
 991                 }
 992         }
 993         peer->dev_role = WFD_DEV_ROLE_GO;
 994
 995         edata = (wfd_oem_invite_data_s*) event->edata;
 996         memcpy(peer->intf_addr, edata->bssid, MACADDR_LEN);
 997         wfd_update_peer_time(manager, event->dev_addr);
 998
 999         session = wfd_create_session(manager, event->dev_addr,
1000                                         manager->req_wps_mode, SESSION_DIRECTION_INCOMING);
1001         if (!session) {
1002                 WDS_LOGE("Failed to create session");
1003                 __WDS_LOG_FUNC_EXIT__;
1004                 return;
1005         }
1006         session->type = SESSION_TYPE_INVITE;
1007         wfd_session_timer(session, 1);
1008
1009         wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
1010
1011         res = wfd_session_start(session);
1012         if (res < 0) {
1013                 WDS_LOGE("Failed to start session");
1014                 __WDS_LOG_FUNC_EXIT__;
1015                 return;
1016         }
1017
1018         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1019         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ;
1020         noti.error = WIFI_DIRECT_ERROR_NONE;
1021         snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(event->dev_addr));
1022         wfd_client_send_event(manager, &noti);
1023
1024         __WDS_LOG_FUNC_EXIT__;
1025         return;
1026 }
1027
1028 static void __wfd_process_invitation_res(wfd_manager_s *manager, wfd_oem_event_s *event)
1029 {
1030         __WDS_LOG_FUNC_ENTER__;
1031
1032         __WDS_LOG_FUNC_EXIT__;
1033         return;
1034 }
1035
1036 static void __wfd_process_sta_connected(wfd_manager_s *manager, wfd_oem_event_s *event)
1037 {
1038         __WDS_LOG_FUNC_ENTER__;
1039
1040         wfd_session_s *session = NULL;
1041         wfd_device_s *peer = NULL;
1042         wfd_group_s *group = NULL;
1043         wifi_direct_client_noti_s noti;
1044
1045         if (event == NULL || manager == NULL) {
1046                 WDS_LOGE("Invalid parameter");
1047                 __WDS_LOG_FUNC_EXIT__;
1048                 return;
1049         }
1050
1051         // FIXME: Move this code to plugin
1052         if (!memcmp(event->intf_addr, manager->local->intf_addr, MACADDR_LEN)) {
1053                 WDS_LOGD("Ignore this event");
1054                 __WDS_LOG_FUNC_EXIT__;
1055                 return;
1056         }
1057
1058         session = (wfd_session_s*) manager->session;
1059         if (!session) {
1060                 WDS_LOGD("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
1061                                                                         MAC2SECSTR(event->dev_addr));
1062                 wfd_oem_destroy_group(manager->oem_ops, GROUP_IFNAME);
1063                 wfd_destroy_group(manager, GROUP_IFNAME);
1064                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1065                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1066                 __WDS_LOG_FUNC_EXIT__;
1067                 return;
1068         }
1069
1070         peer = wfd_session_get_peer(session);
1071         if (!peer) {
1072                 WDS_LOGE("Peer not found");
1073                 __WDS_LOG_FUNC_EXIT__;
1074                 return;
1075         }
1076
1077         group = (wfd_group_s*) manager->group;
1078         if (!group) {
1079                 group = wfd_create_pending_group(manager, event->intf_addr);
1080                 if (!group) {
1081                         WDS_LOGE("Failed to create pending group");
1082                         __WDS_LOG_FUNC_EXIT__;
1083                         return;
1084                 }
1085                 manager->group = group;
1086         }
1087         wfd_group_add_member(group, peer->dev_addr);
1088
1089         session->state = SESSION_STATE_COMPLETED;
1090 #ifndef CTRL_IFACE_DBUS
1091         memcpy(peer->intf_addr, event->intf_addr, MACADDR_LEN);
1092 #endif /* CTRL_IFACE_DBUS */
1093         peer->state = WFD_PEER_STATE_CONNECTED;
1094
1095         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1096         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1097
1098         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1099         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1100         noti.error = WIFI_DIRECT_ERROR_NONE;
1101         snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1102         wfd_client_send_event(manager, &noti);
1103 #ifdef CTRL_IFACE_DBUS
1104         wfd_update_peer(manager, peer);
1105 #endif /* CTRL_IFACE_DBUS */
1106 #ifdef TIZEN_FEATURE_IP_OVER_EAPOL
1107         if (event->ip_addr_peer[3]) {
1108                 peer->ip_type = WFD_IP_TYPE_OVER_EAPOL;
1109                 memcpy(peer->client_ip_addr, event->ip_addr_peer, IPADDR_LEN);
1110                 WDS_LOGE("Peer's client IP [" IPSTR "]", IP2STR((char*) &peer->client_ip_addr));
1111                 memcpy(peer->go_ip_addr, manager->local->ip_addr, IPADDR_LEN);
1112                 WDS_LOGE("Peer's GO IP [" IPSTR "]", IP2STR((char*) &peer->go_ip_addr));
1113         }
1114         if(peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
1115                 memcpy(peer->ip_addr, peer->client_ip_addr, IPADDR_LEN);
1116
1117                 wifi_direct_client_noti_s noti;
1118                 memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1119                 noti.event = WIFI_DIRECT_CLI_EVENT_IP_LEASED_IND;
1120                 noti.error = WIFI_DIRECT_ERROR_NONE;
1121                 snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer->dev_addr));
1122                 snprintf(noti.param2, IPSTR_LEN, IPSTR, IP2STR(peer->ip_addr));
1123                 wfd_client_send_event(manager, &noti);
1124         } else
1125 #endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
1126         wfd_util_dhcps_wait_ip_leased(peer);
1127         wfd_destroy_session(manager);
1128
1129         __WDS_LOG_FUNC_EXIT__;
1130         return;
1131 }
1132
1133 static void __wfd_process_sta_disconnected(wfd_manager_s *manager, wfd_oem_event_s *event)
1134 {
1135         __WDS_LOG_FUNC_ENTER__;
1136
1137         wfd_group_s *group = NULL;
1138         wfd_device_s *peer = NULL;
1139         wifi_direct_client_noti_s noti;
1140         unsigned char peer_addr[MACADDR_LEN] = {0, };
1141
1142         if (event == NULL || manager == NULL) {
1143                 WDS_LOGE("Invalid parameter");
1144                 __WDS_LOG_FUNC_EXIT__;
1145                 return;
1146         }
1147
1148         group = (wfd_group_s*) manager->group;
1149         if (!group) {
1150                 WDS_LOGE("Group not found");
1151                 __WDS_LOG_FUNC_EXIT__;
1152                 return;
1153         }
1154
1155 #ifdef CTRL_IFACE_DBUS
1156         peer = wfd_group_find_member_by_addr(group, event->dev_addr);
1157 #else /* CTRL_IFACE_DBUS */
1158         peer = wfd_group_find_member_by_addr(group, event->intf_addr);
1159 #endif /* DBUS_IFACE */
1160         if (!peer) {
1161                 WDS_LOGE("Failed to find connected peer");
1162                 peer = wfd_session_get_peer(manager->session);
1163                 if (!peer) {
1164                         WDS_LOGE("Failed to find connecting peer");
1165                         __WDS_LOG_FUNC_EXIT__;
1166                         return;
1167                 }
1168
1169 #ifdef CTRL_IFACE_DBUS
1170                 /**
1171                  * If no peer connected and
1172                  * disconnected event is not for connecting peer
1173                  * then event should be ignored.
1174                  * This situation can arrise when TV is GO and
1175                  * some connected peer sent disassociation.
1176                  */
1177                 if (memcmp(peer_addr, event->dev_addr, MACADDR_LEN)) {
1178                         WDS_LOGE("Unexpected event, Ignore it...");
1179                         __WDS_LOG_FUNC_EXIT__;
1180                         return;
1181                 }
1182 #endif /* CTRL_DBUS_IFACE */
1183         }
1184         memcpy(peer_addr, peer->dev_addr, MACADDR_LEN);
1185         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1186
1187         /* If state is not DISCONNECTING, connection is finished by peer */
1188         if (manager->state >= WIFI_DIRECT_STATE_CONNECTED) {
1189                 wfd_group_remove_member(group, peer_addr);
1190                 if (group->member_count)
1191                         noti.event = WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND;
1192                 else
1193                         noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND;
1194                 noti.error = WIFI_DIRECT_ERROR_NONE;
1195                 g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1196                 /* If there is no member, GO should be destroyed */
1197 #ifdef TIZEN_TV
1198                 /* If GO is Auto GO, then it should not be removed when no member left */
1199                 if (!group->member_count && (wfd_group_is_autonomous(group) == FALSE)) {
1200 #else /* TIZEN_TV */
1201                 if (!group->member_count) {
1202 #endif /* TIZEN_TV */
1203                         wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1204                         wfd_destroy_group(manager, group->ifname);
1205                         wfd_peer_clear_all(manager);
1206                 }
1207         } else if (manager->state == WIFI_DIRECT_STATE_DISCONNECTING) {
1208                 noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
1209                 noti.error = WIFI_DIRECT_ERROR_NONE;
1210                 g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1211         } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING &&
1212                         /* Some devices(GO) send disconnection message before connection completed.
1213                          * This message should be ignored when device is not GO */
1214                         manager->local->dev_role == WFD_DEV_ROLE_GO) {
1215                 if (WFD_PEER_STATE_CONNECTED == peer->state) {
1216                         WDS_LOGD("Peer is already Connected !!!");
1217                         noti.event = WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND;
1218                         noti.error = WIFI_DIRECT_ERROR_NONE;
1219                 } else if (WFD_PEER_STATE_CONNECTING == peer->state) {
1220                         WDS_LOGD("Peer is Connecting...");
1221                         noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
1222                         noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;
1223                 } else {
1224                         WDS_LOGE("Unexpected Peer State. Ignore it");
1225                         __WDS_LOG_FUNC_EXIT__;
1226                         return;
1227                 }
1228                 g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
1229         } else {
1230                 WDS_LOGE("Unexpected event. Ignore it");
1231                 __WDS_LOG_FUNC_EXIT__;
1232                 return;
1233         }
1234         wfd_client_send_event(manager, &noti);
1235
1236         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1237                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1238                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
1239         } else {
1240                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1241                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1242         }
1243
1244         wfd_destroy_session(manager);
1245
1246         __WDS_LOG_FUNC_EXIT__;
1247         return;
1248 }
1249
1250  static void __wfd_process_terminating(wfd_manager_s *manager, wfd_oem_event_s *event)
1251  {
1252         __WDS_LOG_FUNC_ENTER__;
1253
1254         __WDS_LOG_FUNC_EXIT__;
1255         return;
1256  }
1257
1258 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1259 static void __wfd_process_serv_disc_resp(wfd_manager_s *manager, wfd_oem_event_s *event)
1260 {
1261         __WDS_LOG_FUNC_ENTER__;
1262
1263         wifi_direct_client_noti_s noti;
1264
1265         if (event == NULL || manager == NULL) {
1266                 WDS_LOGE("Invalid parameter");
1267                 __WDS_LOG_FUNC_EXIT__;
1268                 return;
1269         }
1270
1271         wfd_update_peer_time(manager, event->dev_addr);
1272
1273         if (event->edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE) {
1274                 wfd_oem_new_service_s *service = NULL;;
1275                 GList *temp = NULL;
1276                 GList *services = (GList*) event->edata;
1277                 int count = 0;
1278
1279                 WDS_LOGD("%d service data found", event->dev_role);
1280
1281                 temp = g_list_first(services);
1282                 while(temp && count < event->dev_role) {
1283                         service = (wfd_oem_new_service_s*) temp->data;
1284                         memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1285                         noti.event = WIFI_DIRECT_CLI_EVENT_SERVICE_DISCOVERY_FOUND;
1286                         noti.type = service->protocol;
1287                         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
1288                                 g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1289                                 g_snprintf(noti.param2, 256, "%s|%s", service->data.bonjour.query, service->data.bonjour.rdata);
1290                                 WDS_LOGD("Found service: [%d: %s] - [" MACSECSTR "]", service->protocol,
1291                                                         service->data.bonjour.query, MAC2SECSTR(event->dev_addr));
1292                         } else {
1293                                 WDS_LOGD("Found service is not supported");
1294                                 goto next;
1295                         }
1296                         wfd_client_send_event(manager, &noti);
1297 next:
1298                         temp = g_list_next(temp);
1299                         service = NULL;
1300                         count++;
1301                 }
1302         } else if (event->edata_type == WFD_OEM_EDATA_TYPE_SERVICE) {
1303                 wfd_oem_service_data_s *edata = (wfd_oem_service_data_s*) event->edata;
1304
1305                 memset(&noti, 0x0, sizeof(wifi_direct_client_noti_s));
1306                 noti.event = WIFI_DIRECT_CLI_EVENT_SERVICE_DISCOVERY_FOUND;
1307                 if(!edata) {
1308                         noti.type = -1;
1309                 } else {
1310                         noti.type = edata->type;
1311                         g_snprintf(noti.param1, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
1312                         switch(edata->type) {
1313                                 WDS_LOGE("Unknown type [type ID: %d]", edata->type);
1314                         }
1315                 }
1316                 wfd_client_send_event(manager, &noti);
1317         }
1318
1319         __WDS_LOG_FUNC_EXIT__;
1320         return;
1321 }
1322
1323 static void __wfd_process_serv_disc_started(wfd_manager_s *manager, wfd_oem_event_s *event)
1324 {
1325         __WDS_LOG_FUNC_ENTER__;
1326
1327         __WDS_LOG_FUNC_EXIT__;
1328         return;
1329 }
1330 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1331
1332 static struct {
1333  const int event_id;
1334  void (*function) (wfd_manager_s *manager, wfd_oem_event_s *event);
1335 } wfd_oem_event_map[] = {
1336         {
1337                 WFD_OEM_EVENT_NONE,
1338                 NULL
1339         },
1340         {
1341                 WFD_OEM_EVENT_DEACTIVATED,
1342                 __wfd_process_deactivated
1343         },
1344         {
1345                 WFD_OEM_EVENT_PEER_FOUND,
1346                 __wfd_process_peer_found
1347         },
1348         {
1349                 WFD_OEM_EVENT_PEER_DISAPPEARED,
1350                 __wfd_process_peer_disappeared
1351         },
1352         {
1353                 WFD_OEM_EVENT_DISCOVERY_FINISHED,
1354                 __wfd_process_discovery_finished
1355         },
1356         {
1357                 WFD_OEM_EVENT_PROV_DISC_REQ,
1358                 __wfd_process_prov_disc_req
1359         },
1360         {
1361                 WFD_OEM_EVENT_PROV_DISC_RESP,
1362                 __wfd_process_prov_disc_resp
1363         },
1364         {
1365                 WFD_OEM_EVENT_PROV_DISC_FAIL,
1366                 __wfd_process_prov_disc_fail
1367         },
1368         {
1369                 WFD_OEM_EVENT_GO_NEG_REQ,
1370                 __wfd_process_go_neg_req
1371         },
1372         {
1373                 WFD_OEM_EVENT_GO_NEG_FAIL,
1374                 __wfd_process_go_neg_fail
1375         },
1376         {
1377                 WFD_OEM_EVENT_GO_NEG_DONE,
1378                 __wfd_process_go_neg_done
1379         },
1380         {
1381                 WFD_OEM_EVENT_WPS_FAIL,
1382                 __wfd_process_wps_fail
1383         },
1384         {
1385                 WFD_OEM_EVENT_WPS_DONE,
1386                 __wfd_process_wps_done
1387         },
1388         {
1389                 WFD_OEM_EVENT_KEY_NEG_FAIL,
1390                 __wfd_process_key_neg_fail
1391         },
1392         {
1393                 WFD_OEM_EVENT_KEY_NEG_DONE,
1394                 __wfd_process_key_neg_done
1395         },
1396         {
1397                 WFD_OEM_EVENT_CONN_FAIL,
1398                 __wfd_process_conn_fail
1399         },
1400         {
1401                 WFD_OEM_EVENT_CONN_DONE,
1402                 __wfd_process_conn_done
1403         },
1404         {
1405                 WFD_OEM_EVENT_GROUP_CREATED,
1406                 __wfd_process_group_created
1407         },
1408         {
1409                 WFD_OEM_EVENT_GROUP_DESTROYED,
1410                 __wfd_process_group_destroyed
1411         },
1412         {
1413                 WFD_OEM_EVENT_INVITATION_REQ,
1414                 __wfd_process_invitation_req
1415         },
1416         {
1417                 WFD_OEM_EVENT_INVITATION_RES,
1418                 __wfd_process_invitation_res
1419         },
1420         {
1421                 WFD_OEM_EVENT_STA_CONNECTED,
1422                 __wfd_process_sta_connected
1423         },
1424         {
1425                 WFD_OEM_EVENT_STA_DISCONNECTED,
1426                 __wfd_process_sta_disconnected
1427         },
1428         {
1429                 WFD_OEM_EVENT_TERMINATING,
1430                 __wfd_process_terminating
1431         },
1432 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1433         {
1434                 WFD_OEM_EVENT_SERV_DISC_RESP,
1435                 __wfd_process_serv_disc_resp
1436         },
1437         {
1438                 WFD_OEM_EVENT_SERV_DISC_STARTED,
1439                 __wfd_process_serv_disc_started
1440         },
1441 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1442         {
1443                 WFD_OEM_EVENT_MAX,
1444                 NULL
1445         }
1446  };
1447
1448  int wfd_process_event(void *user_data, void *data)
1449  {
1450         __WDS_LOG_FUNC_ENTER__;
1451         wfd_manager_s *manager = NULL;
1452         wfd_oem_event_s *event = NULL;
1453
1454         manager = (wfd_manager_s*) user_data;
1455         event = (wfd_oem_event_s*) data;
1456         if (!manager || !event) {
1457                 WDS_LOGE("Invalid parameter");
1458                 __WDS_LOG_FUNC_EXIT__;
1459                 return -1;
1460         }
1461
1462         WDS_LOGD("Event[%d] from " MACSECSTR, event->event_id,
1463                                                 MAC2SECSTR(event->dev_addr));
1464
1465         if(event->event_id > WFD_OEM_EVENT_NONE &&
1466                         event->event_id < WFD_OEM_EVENT_MAX)
1467                  wfd_oem_event_map[event->event_id].function(manager, event);
1468         else
1469                 WDS_LOGE("Invalid event ID");
1470
1471         __WDS_LOG_FUNC_EXIT__;
1472         return 0;
1473  }