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