src/wifi-direct-session.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 session functions.
  22  *
  23  * @file                wifi-direct-session.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30
  31 #include <glib.h>
  32
  33 #include <wifi-direct.h>
  34
  35 #include "wifi-direct-ipc.h"
  36 #include "wifi-direct-manager.h"
  37 #include "wifi-direct-oem.h"
  38 #include "wifi-direct-peer.h"
  39 #include "wifi-direct-group.h"
  40 #include "wifi-direct-oem.h"
  41 #include "wifi-direct-util.h"
  42 #include "wifi-direct-session.h"
  43 #include "wifi-direct-state.h"
  44 #include "wifi-direct-error.h"
  45 #include "wifi-direct-log.h"
  46 #include "wifi-direct-dbus.h"
  47
  48
  49 static gboolean _session_timeout_cb(gpointer *user_data)
  50 {
  51         __WDS_LOG_FUNC_ENTER__;
  52         wfd_manager_s *manager = wfd_get_manager();
  53         wfd_session_s *session = (wfd_session_s*) manager->session;
  54         unsigned char *peer_addr = NULL;
  55         char peer_mac_address[MACSTR_LEN+1] = {0, };
  56
  57         if (!session) {
  58                 WDS_LOGE("Invalid parameter");
  59                 return FALSE;
  60         }
  61         session->connecting_120 = 0;
  62         session->timer = 0;
  63         WDS_LOGD("Session timer expired");
  64
  65         peer_addr = wfd_session_get_peer_addr(session);
  66         if(peer_addr != NULL)
  67                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
  68         else
  69                 g_snprintf(peer_mac_address, MACSTR_LEN, "%s", "");
  70
  71         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
  72                                      "Connection",
  73                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT,
  74                                                             WFD_EVENT_CONNECTION_RSP,
  75                                                             peer_mac_address));
  76
  77         wfd_session_cancel(session, peer_addr);
  78
  79         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
  80                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
  81                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
  82         } else {
  83                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
  84                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
  85         }
  86
  87         __WDS_LOG_FUNC_EXIT__;
  88         return FALSE;
  89 }
  90
  91 static void _wfd_notify_session_failed(wfd_manager_s *manager, unsigned char *peer_addr)
  92 {
  93         __WDS_LOG_FUNC_ENTER__;
  94         char peer_mac_address[MACSTR_LEN+1] = {0, };
  95
  96         snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
  97         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
  98                                      "Connection",
  99                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
 100                                                             WFD_EVENT_CONNECTION_RSP,
 101                                                             peer_mac_address));
 102
 103         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 104                 wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 105                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 106         } else {
 107                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 108                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 109         }
 110
 111         __WDS_LOG_FUNC_EXIT__;
 112 }
 113
 114 int wfd_session_timer(wfd_session_s *session, int start)
 115 {
 116         __WDS_LOG_FUNC_ENTER__;
 117
 118         if (!session) {
 119                 WDS_LOGE("Invalid parameter");
 120                 __WDS_LOG_FUNC_EXIT__;
 121                 return -1;
 122         }
 123
 124         if (start) {
 125                 if (!session->connecting_120)
 126                         session->connecting_120 = 1;
 127
 128                 if (session->timer > 0) {
 129                         WDS_LOGE("Session timer already started");
 130                         __WDS_LOG_FUNC_EXIT__;
 131                         return -1;
 132                 }
 133                 session->timer = g_timeout_add(120000,
 134                                                 (GSourceFunc) _session_timeout_cb,
 135                                                 NULL);
 136                 WDS_LOGD("Session timer started");
 137         } else {
 138                 session->connecting_120 = 0;
 139                 if (session->timer > 0) {
 140                         g_source_remove(session->timer);
 141                         session->timer = 0;
 142                         WDS_LOGD("Session timer stoped");
 143                 }
 144         }
 145
 146         __WDS_LOG_FUNC_EXIT__;
 147         return 0;
 148 }
 149
 150 // Check the session instance which has same peer address, before using this function
 151 wfd_session_s *wfd_create_session(void *data, unsigned char *peer_addr, int wps_mode, int direction)
 152 {
 153         __WDS_LOG_FUNC_ENTER__;
 154         wfd_manager_s *manager = (wfd_manager_s*) data;
 155         wfd_session_s *session = NULL;
 156         wfd_device_s *peer = NULL;
 157
 158         if (!data || !peer_addr) {
 159                 WDS_LOGE("Invalid parameter");
 160                 __WDS_LOG_FUNC_EXIT__;
 161                 return NULL;
 162         }
 163
 164         WDS_LOGD("create session for peer[" MACSTR "]", MAC2STR(peer_addr));
 165
 166         if (manager->session) {
 167                 WDS_LOGE("Session already exist");
 168                 return NULL;
 169         }
 170
 171         session = (wfd_session_s*) g_try_malloc0(sizeof(wfd_session_s));
 172         if (!session) {
 173                 WDS_LOGE("Failed to allocate memory for session");
 174                 __WDS_LOG_FUNC_EXIT__;
 175                 return NULL;
 176         }
 177
 178         peer = wfd_peer_find_by_dev_addr(manager, peer_addr);
 179         if (!peer) {
 180                 WDS_LOGE("Failed to find peer info[" MACSECSTR "]", MAC2SECSTR(peer_addr));
 181                 g_free(session);
 182                 __WDS_LOG_FUNC_EXIT__;
 183                 return NULL;
 184         }
 185         peer->state = WFD_PEER_STATE_CONNECTING;
 186
 187         session->peer = peer;
 188         session->req_wps_mode = wps_mode;
 189         if (wps_mode == WFD_WPS_MODE_DISPLAY)
 190                 session->wps_mode = WFD_WPS_MODE_KEYPAD;
 191         else if (wps_mode == WFD_WPS_MODE_KEYPAD)
 192                 session->wps_mode = WFD_WPS_MODE_DISPLAY;
 193         else
 194                 session->wps_mode = wps_mode;
 195         session->direction = direction;
 196         session->state = SESSION_STATE_CREATED;
 197
 198         manager->session = session;
 199         manager->local->wps_mode = session->wps_mode;
 200
 201         if (peer->dev_role == WFD_DEV_ROLE_GO &&
 202                         manager->local->wps_mode == WFD_WPS_MODE_DISPLAY) {
 203                         char *generated_pin = NULL;
 204                         session->wps_mode = WFD_WPS_MODE_DISPLAY;
 205                         session->req_wps_mode = WFD_WPS_MODE_KEYPAD;
 206
 207                         if (wfd_oem_generate_pin(manager->oem_ops, &generated_pin) != 0) {
 208                                 WDS_LOGE("Failed to generate pin");
 209                                 g_free(session);
 210                                 __WDS_LOG_FUNC_EXIT__;
 211                                 return NULL;
 212                         }
 213
 214                         g_strlcpy(session->wps_pin, generated_pin, PINSTR_LEN + 1);
 215                         g_free(generated_pin);
 216         }
 217
 218         if (peer->dev_role == WFD_DEV_ROLE_GO && manager->local->dev_role != WFD_DEV_ROLE_GO)
 219                 manager->local->dev_role = WFD_DEV_ROLE_GC;
 220
 221         __WDS_LOG_FUNC_EXIT__;
 222         return session;
 223 }
 224
 225 int wfd_destroy_session(void *data)
 226 {
 227         __WDS_LOG_FUNC_ENTER__;
 228         wfd_manager_s *manager = (wfd_manager_s*) data;
 229         wfd_session_s *session = NULL;
 230         wfd_device_s *peer = NULL;
 231
 232         if (!manager) {
 233                 WDS_LOGE("Invalid parameter");
 234                 return -1;
 235         }
 236
 237         session = (wfd_session_s*) manager->session;
 238         if (!session) {
 239                 WDS_LOGE("Session not found");  // self prevent 13029
 240                 return -1;
 241         }
 242         wfd_session_timer(session, 0);
 243         peer = session->peer;
 244
 245         if(peer) {
 246                 if (session->state == SESSION_STATE_COMPLETED)
 247                         peer->state = WFD_PEER_STATE_CONNECTED;
 248                 else
 249                         peer->state = WFD_PEER_STATE_DISCOVERED;
 250         } else {
 251                 WDS_LOGE("Peer not found");
 252         }
 253
 254         g_free(session);
 255         manager->session = NULL;
 256         manager->local->wps_mode = WFD_WPS_MODE_PBC;
 257         manager->autoconnection = 0;
 258         memset(manager->auto_pin, 0x0, PINSTR_LEN);
 259         if (manager->local->dev_role == WFD_DEV_ROLE_GC)
 260                 manager->local->dev_role = WFD_DEV_ROLE_NONE;
 261
 262         __WDS_LOG_FUNC_EXIT__;
 263         return 0;
 264 }
 265
 266 int wfd_session_start(wfd_session_s *session)
 267 {
 268         __WDS_LOG_FUNC_ENTER__;
 269         wfd_manager_s *manager = wfd_get_manager();
 270         wfd_device_s *peer = NULL;
 271         int join = 0;
 272         int res = 0;
 273
 274         if (!session) {
 275                 WDS_LOGE("Invalid parameter");
 276                 __WDS_LOG_FUNC_EXIT__;
 277                 return -1;
 278         }
 279
 280         if (session->state > SESSION_STATE_STARTED) {
 281                 WDS_LOGE("Invalid session state(%d)", session->state);
 282                 return -1;
 283         }
 284
 285         // Check: Invitation Received in Incomming case -> send prov_disc join
 286         // Check: User select peer to connect with in Outgoing case -> send prov_disc wps_mdde
 287
 288         wfd_oem_stop_scan(manager->oem_ops);
 289
 290         session->state = SESSION_STATE_STARTED;
 291         peer = session->peer;
 292         if (peer->dev_role == WFD_DEV_ROLE_GO || session->type == SESSION_TYPE_INVITE)
 293                 join = 1;
 294         res = wfd_oem_prov_disc_req(manager->oem_ops, peer->dev_addr,
 295                                         session->req_wps_mode, join);
 296         if (res < 0) {
 297                 WDS_LOGD("Failed to send provision discovery request to peer [" MACSECSTR "]",
 298                                                                         MAC2SECSTR(peer->dev_addr));
 299                 wfd_destroy_session(manager);
 300                 // TODO: send notification to App
 301                 __WDS_LOG_FUNC_EXIT__;
 302                 return -1;
 303         }
 304
 305         wfd_session_timer(session, 1);
 306
 307         __WDS_LOG_FUNC_EXIT__;
 308         return 0;
 309 }
 310
 311 #if 0
 312 int wfd_session_stop(wfd_session_s *session)
 313 {
 314         __WDS_LOG_FUNC_ENTER__;
 315         wfd_manager_s *manager = wfd_get_manager();
 316         wfd_device_s *peer = NULL;
 317         int res = 0;
 318
 319         if (!session) {
 320                 WDS_LOGE("Invalid parameter");
 321                 __WDS_LOG_FUNC_EXIT__;
 322                 return -1;
 323         }
 324
 325         if (session->state > SESSION_STATE_CREATED) {
 326                 peer = session->peer;
 327                 if (session->direction == SESSION_DIRECTION_INCOMING) {
 328                         res  = wfd_oem_reject_connection(manager->oem_ops, peer->dev_addr);
 329                 } else if (session->direction == SESSION_DIRECTION_OUTGOING) {
 330                         res = wfd_oem_cancel_connection(manager->oem_ops, peer->dev_addr);
 331                 }
 332                 if (res < 0) {
 333                         WDS_LOGE("Failed to reject or cancel connection");
 334                         __WDS_LOG_FUNC_EXIT__;
 335                         return -1;
 336                 }
 337         }
 338
 339         session->state = SESSION_STATE_STOPPED;
 340         wfd_destroy_session(manager);
 341
 342         __WDS_LOG_FUNC_EXIT__;
 343         return 0;
 344 }
 345 #endif
 346
 347 /* In case of incomming session, when user accept connection request, this function should be called.
 348  * In case of outgoing session, when prov_disc response arrived, this function should be called.
 349  * Even though peer is GO, we can use this function, which can decide using join itself.
 350  */
 351 int wfd_session_connect(wfd_session_s *session)
 352 {
 353         __WDS_LOG_FUNC_ENTER__;
 354         wfd_manager_s *manager = wfd_get_manager();
 355         wfd_oem_conn_param_s param;
 356         wfd_device_s *peer = NULL;
 357         int res = 0;
 358
 359         if (!session) {
 360                 WDS_LOGE("Invalid parameter");
 361                 __WDS_LOG_FUNC_EXIT__;
 362                 return -1;
 363         }
 364
 365         if (session->state > SESSION_STATE_GO_NEG) {
 366                 WDS_LOGE("Session already finished GO Negotiation");
 367                 return -1;
 368         }
 369
 370         session->state = SESSION_STATE_GO_NEG;
 371         peer = session->peer;
 372
 373         memset(&param, 0x00, sizeof(wfd_oem_conn_param_s));
 374         param.wps_mode = session->wps_mode;
 375         if (peer->dev_role == WFD_DEV_ROLE_GO || session->type == SESSION_TYPE_INVITE)
 376                 param.conn_flags |= WFD_OEM_CONN_TYPE_JOIN;
 377         param.go_intent = session->go_intent;
 378         param.freq = session->freq;
 379         if(manager->local->group_flags & WFD_GROUP_FLAG_PERSISTENT)
 380                 param.conn_flags |= WFD_OEM_CONN_TYPE_PERSISTENT;
 381
 382         if (session->wps_pin[0] != '\0') {
 383                 g_strlcpy(param.wps_pin, session->wps_pin, OEM_PINSTR_LEN + 1);
 384         }
 385
 386         /* To connect with windows phone,set go_intent value to 2.
 387         *  As windows phone does not connect when local device act as GO.
 388         *  WIFI_DIRECT_PRIMARY_DEVICE_TYPE_COMPUTER ==>1 (Assume Peer Device is Windows PC)
 389         *  WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_WINDOWS_MOBILE ==>1
 390         *  WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE ==> 10
 391         */
 392          if ((peer->pri_dev_type == 1) ||
 393                                  ((peer->pri_dev_type == 10) && (peer->sec_dev_type == 1))) {
 394                 param.go_intent = 2;
 395                 WDS_LOGD("go_intent set to %d, Windows device",param.go_intent);
 396          }
 397
 398         WDS_LOGD("connection go_intent: %d", param.go_intent);
 399         res = wfd_oem_connect(manager->oem_ops, peer->dev_addr, &param);
 400         if (res < 0) {
 401                 WDS_LOGD("Failed to connect peer [" MACSECSTR "]", MAC2SECSTR(peer->dev_addr));
 402                 wfd_destroy_session(manager);
 403                 __WDS_LOG_FUNC_EXIT__;
 404                 return -1;
 405         }
 406
 407         wfd_session_timer(session, 1);
 408
 409         __WDS_LOG_FUNC_EXIT__;
 410         return 0;
 411 }
 412
 413 int wfd_session_cancel(wfd_session_s *session, unsigned char *peer_addr)
 414 {
 415         __WDS_LOG_FUNC_ENTER__;
 416         wfd_manager_s *manager = wfd_get_manager();
 417         int res = 0;
 418
 419         if (!session || !session->peer) {
 420                 WDS_LOGE("Invalid parameter");
 421                 __WDS_LOG_FUNC_EXIT__;
 422                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 423         }
 424
 425         if (memcmp(peer_addr, session->peer->dev_addr, MACADDR_LEN)) {
 426                 WDS_LOGE("Peer is not included in this session");
 427                 return WIFI_DIRECT_ERROR_NOT_PERMITTED;
 428         }
 429
 430         if (manager->local->dev_role == WFD_DEV_ROLE_GO && session->state > SESSION_STATE_GO_NEG)
 431                 res = wfd_oem_wps_cancel(manager->oem_ops);
 432         else
 433                 res = wfd_oem_cancel_connection(manager->oem_ops, peer_addr);
 434
 435         if (res < 0) {
 436                 WDS_LOGE("Failed to cancel connection");
 437                 return WIFI_DIRECT_ERROR_OPERATION_FAILED;
 438         }
 439
 440         wfd_destroy_session(manager);
 441
 442         __WDS_LOG_FUNC_EXIT__;
 443         return 0;
 444 }
 445
 446 int wfd_session_reject(wfd_session_s *session, unsigned char *peer_addr)
 447 {
 448         __WDS_LOG_FUNC_ENTER__;
 449         wfd_manager_s *manager = wfd_get_manager();
 450         wfd_device_s *peer = NULL;
 451         int res = 0;
 452
 453         if (!session || !manager) {
 454                 WDS_LOGE("Invalid parameter");
 455                 __WDS_LOG_FUNC_EXIT__;
 456                 return -1;
 457         }
 458
 459         /* Invite received case state is just created */
 460         if (session->state < SESSION_STATE_CREATED ||
 461                 session->state >= SESSION_STATE_STOPPED) {
 462                 WDS_LOGE("Session state is Invalid [%d]", session->state);
 463                 __WDS_LOG_FUNC_EXIT__;
 464                 return -1;
 465         }
 466
 467         /*
 468          * TODO: check session status and do proper work
 469          * for example, reject prov_disc, reject nego, stop wps, etc.
 470          *
 471          */
 472
 473         peer = session->peer;
 474
 475         if (SESSION_TYPE_INVITE == session->type || SESSION_TYPE_JOIN == session->type)
 476                 res = wfd_oem_wps_cancel(manager->oem_ops);
 477         else
 478                 res = wfd_oem_reject_connection(manager->oem_ops, peer->dev_addr);
 479         if (res < 0) {
 480                 WDS_LOGE("Failed to reject connection");
 481                 __WDS_LOG_FUNC_EXIT__;
 482                 return -1;
 483         }
 484
 485         wfd_destroy_session(manager);
 486         // TODO: send notification to App
 487
 488         __WDS_LOG_FUNC_EXIT__;
 489         return 0;
 490 }
 491
 492 int wfd_session_join(wfd_session_s *session)
 493 {
 494         __WDS_LOG_FUNC_ENTER__;
 495         wfd_manager_s *manager = wfd_get_manager();
 496         wfd_oem_conn_param_s param;
 497         wfd_device_s *peer = NULL;
 498         int res = 0;
 499
 500         if (!session) {
 501                 WDS_LOGE("Invalid parameter");
 502                 __WDS_LOG_FUNC_EXIT__;
 503                 return -1;
 504         }
 505
 506         session->state = SESSION_STATE_WPS;
 507         peer = session->peer;
 508
 509         memset(&param, 0x00, sizeof(wfd_oem_conn_param_s));
 510         param.wps_mode = session->wps_mode;
 511         if (peer->dev_role == WFD_DEV_ROLE_GO)
 512                 param.conn_flags |= WFD_OEM_CONN_TYPE_JOIN;
 513         param.go_intent = session->go_intent;
 514         param.freq = session->freq;
 515         g_strlcpy(param.wps_pin, session->wps_pin, OEM_PINSTR_LEN + 1);
 516
 517         res = wfd_oem_connect(manager->oem_ops, peer->dev_addr, &param);
 518         if (res < 0) {
 519                 WDS_LOGD("Failed to join with peer [" MACSECSTR "]", MAC2SECSTR(peer->dev_addr));
 520                 wfd_destroy_session(manager);
 521                 __WDS_LOG_FUNC_EXIT__;
 522                 return -1;
 523         }
 524
 525         wfd_session_timer(session, 1);
 526
 527         __WDS_LOG_FUNC_EXIT__;
 528         return 0;
 529 }
 530
 531 int wfd_session_invite(wfd_session_s *session)
 532 {
 533         __WDS_LOG_FUNC_ENTER__;
 534         wfd_manager_s *manager = wfd_get_manager();
 535         wfd_oem_invite_param_s param;
 536         wfd_device_s *peer = NULL;
 537         wfd_group_s *group = NULL;
 538         int res = 0;
 539
 540         if (!session) {
 541                 WDS_LOGE("Invalid parameter");
 542                 __WDS_LOG_FUNC_EXIT__;
 543                 return -1;
 544         }
 545
 546         if (session->state > SESSION_STATE_CREATED) {
 547                 WDS_LOGE("Invalid session state(%d)", session->state);
 548                 return -1;
 549         }
 550
 551         peer = session->peer;
 552         group = (wfd_group_s*) manager->group;
 553
 554         memset(&param, 0x00, sizeof(wfd_oem_invite_param_s));
 555         param.ifname = strdup(group->ifname);
 556         memcpy(param.go_dev_addr, group->go_dev_addr, MACADDR_LEN);
 557
 558         WDS_LOGD("Invite: Peer[" MACSTR "], GO Addr[" MACSTR "]",
 559                                 MAC2STR(peer->dev_addr), MAC2STR(param.go_dev_addr));
 560
 561         res = wfd_oem_invite(manager->oem_ops, peer->dev_addr, &param);
 562         if (res < 0) {
 563                 WDS_LOGE("Failed to invite with peer [" MACSECSTR "]", MAC2SECSTR(peer->dev_addr));
 564                 wfd_destroy_session(manager);
 565                 __WDS_LOG_FUNC_EXIT__;
 566                 return -1;
 567         }
 568
 569         wfd_session_timer(session, 1);
 570
 571         __WDS_LOG_FUNC_EXIT__;
 572         return 0;
 573 }
 574
 575 int wfd_session_wps(wfd_session_s *session)
 576 {
 577         __WDS_LOG_FUNC_ENTER__;
 578         wfd_manager_s *manager = wfd_get_manager();
 579         wfd_device_s *peer = NULL;
 580         int res = 0;
 581
 582         if (!session) {
 583                 WDS_LOGE("Invalid parameter");
 584                 __WDS_LOG_FUNC_EXIT__;
 585                 return -1;
 586         }
 587
 588         if (session->state > SESSION_STATE_WPS) {
 589                 WDS_LOGE("Session already starts WPS");
 590                 return -1;
 591         }
 592
 593         session->state = SESSION_STATE_WPS;
 594         peer = session->peer;
 595
 596         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 597                 WDS_LOGD("My device is GO, so WPS will be started. WPS mode[%d]", session->wps_mode);
 598                 res = wfd_oem_wps_start(manager->oem_ops, peer->dev_addr, session->wps_mode, session->wps_pin);
 599         } else {
 600                 WDS_LOGD("My device is not GO, so Enrollee will be started. WPS mode[%d]", session->wps_mode);
 601                 wfd_oem_conn_param_s param;
 602                 memset(&param, 0x00, sizeof(wfd_oem_conn_param_s));
 603                 param.wps_mode = session->wps_mode;
 604                 param.conn_flags |= WFD_OEM_CONN_TYPE_JOIN;
 605                 param.freq = session->freq;     // currently not used
 606                 g_strlcpy(param.wps_pin, session->wps_pin, OEM_PINSTR_LEN + 1);
 607                 res = wfd_oem_connect(manager->oem_ops, peer->dev_addr, &param);
 608         }
 609         if (res < 0) {
 610                 WDS_LOGE("Failed to start wps with peer [" MACSECSTR "]", MAC2SECSTR(peer->dev_addr));
 611                 wfd_destroy_session(manager);
 612                 __WDS_LOG_FUNC_EXIT__;
 613                 return -1;
 614         }
 615
 616         __WDS_LOG_FUNC_EXIT__;
 617         return 0;
 618 }
 619
 620 wfd_device_s *wfd_session_get_peer(wfd_session_s *session)
 621 {
 622         __WDS_LOG_FUNC_ENTER__;
 623         wfd_device_s *peer = NULL;
 624
 625         if (!session) {
 626                 WDS_LOGE("Invalid parameter");
 627                 return NULL;
 628         }
 629
 630         peer = session->peer;
 631
 632         __WDS_LOG_FUNC_EXIT__;
 633         return peer;
 634 }
 635
 636 unsigned char *wfd_session_get_peer_addr(wfd_session_s *session)
 637 {
 638         __WDS_LOG_FUNC_ENTER__;
 639         wfd_device_s *peer = NULL;
 640
 641         if (!session || !session->peer) {
 642                 WDS_LOGE("Invalid parameter");
 643                 return NULL;
 644         }
 645
 646         peer = session->peer;
 647
 648         __WDS_LOG_FUNC_EXIT__;
 649         return peer->dev_addr;
 650 }
 651
 652 #if 0
 653 int wfd_session_get_wps_pin(wfd_session_s *session, unsigned char *pin)
 654 {
 655         __WDS_LOG_FUNC_ENTER__;
 656
 657         __WDS_LOG_FUNC_EXIT__;
 658         return 0;
 659 }
 660
 661 int wfd_session_set_wps_pin(wfd_session_s *session, unsigned char *pin)
 662 {
 663         __WDS_LOG_FUNC_ENTER__;
 664
 665         __WDS_LOG_FUNC_EXIT__;
 666         return 0;
 667 }
 668
 669 int wfd_session_set_freq(wfd_session_s *session, int freq)
 670 {
 671         __WDS_LOG_FUNC_ENTER__;
 672
 673         __WDS_LOG_FUNC_EXIT__;
 674         return 0;
 675 }
 676
 677 int wfd_session_get_state(wfd_session_s *session)
 678 {
 679         __WDS_LOG_FUNC_ENTER__;
 680
 681         __WDS_LOG_FUNC_EXIT__;
 682         return 0;
 683 }
 684
 685 int wfd_session_set_state(wfd_session_s *session, int state)
 686 {
 687         __WDS_LOG_FUNC_ENTER__;
 688
 689         __WDS_LOG_FUNC_EXIT__;
 690         return 0;
 691 }
 692 #endif
 693
 694 int wfd_session_process_event(wfd_manager_s *manager, wfd_oem_event_s *event)
 695 {
 696         __WDS_LOG_FUNC_ENTER__;
 697         wfd_session_s *session = NULL;
 698         int res = 0;
 699
 700         if (!manager || !event) {
 701                 WDS_LOGE("Invalid parameter");
 702                 return -1;
 703         }
 704
 705         WDS_LOGD("event ID [%d]", event->event_id);
 706         session = manager->session;
 707
 708         switch (event->event_id) {
 709         case WFD_OEM_EVENT_PROV_DISC_REQ:
 710         {
 711                 int req_wps_mode = WFD_WPS_MODE_NONE;
 712
 713                 if (event->wps_mode == WFD_WPS_MODE_DISPLAY) {
 714                         req_wps_mode = WFD_WPS_MODE_KEYPAD;
 715                 } else if (event->wps_mode == WFD_WPS_MODE_KEYPAD) {
 716                         req_wps_mode = WFD_WPS_MODE_DISPLAY;
 717                 } else {
 718                         req_wps_mode = WFD_WPS_MODE_PBC;
 719                 }
 720
 721                 /* Only peer initiated connection or invitation session can be allowed */
 722                 if (session) {
 723                         if (session->type != SESSION_TYPE_INVITE) {
 724                                 WDS_LOGE("Unexpected event. Session is exist [peer: " MACSECSTR "]",
 725                                                                 MAC2SECSTR(event->dev_addr));
 726                                 break;
 727                         }
 728                         WDS_LOGD("=====> session already exist. (invitation session)");
 729                         session->req_wps_mode = req_wps_mode;
 730                         session->wps_mode = event->wps_mode;
 731                 } else {
 732                         session = wfd_create_session(manager, event->dev_addr,
 733                                                                 req_wps_mode, SESSION_DIRECTION_INCOMING);
 734                         if (!session) {
 735                                 WDS_LOGE("Failed to create session with peer [" MACSECSTR "]",
 736                                                                 MAC2SECSTR(event->dev_addr));
 737                                 break;
 738                         }
 739                 }
 740
 741                 /* Update session */
 742                 if (event->wps_mode == WFD_WPS_MODE_DISPLAY) {
 743                         g_strlcpy(session->wps_pin, event->wps_pin, PINSTR_LEN + 1);
 744                 }
 745                 session->state = SESSION_STATE_STARTED;
 746                 if (session->type == SESSION_TYPE_INVITE) {
 747                         WDS_LOGD("Invitation session");
 748                 } else if (WFD_DEV_ROLE_GO == manager->local->dev_role) {
 749                         session->type = SESSION_TYPE_JOIN;
 750                 } else {
 751                         session->type = SESSION_TYPE_NORMAL;
 752                 }
 753                 wfd_session_timer(session, 1);
 754
 755                 /* Update local device */
 756                 manager->local->wps_mode = event->wps_mode;
 757
 758                 wfd_state_set(manager, WIFI_DIRECT_STATE_CONNECTING);
 759
 760                 if (session->type == SESSION_TYPE_INVITE) {
 761                         WDS_LOGD("Start WPS corresponding to OEM event [%d]", event->event_id);
 762                         if (session->wps_mode != WFD_WPS_MODE_PBC) {
 763                                 char peer_mac_address[MACSTR_LEN+1] = {0, };
 764
 765                                 g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
 766                                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 767                                                              "Connection",
 768                                                              g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 769                                                                                     WFD_EVENT_CONNECTION_WPS_REQ,
 770                                                                                     peer_mac_address));
 771                                 if (session->wps_mode == WFD_WPS_MODE_KEYPAD) {
 772                                         /* We have to wait until user type PIN using Keypad */
 773                                         break;
 774                                 }
 775                         }
 776                         res = wfd_session_wps(session);
 777                         if (res < 0)
 778                                 _wfd_notify_session_failed(manager, event->dev_addr);
 779                 } else {
 780                         char peer_mac_address[MACSTR_LEN+1] = {0, };
 781
 782                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
 783                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 784                                                      "Connection",
 785                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 786                                                                             WFD_EVENT_CONNECTION_REQ,
 787                                                                             peer_mac_address));
 788                 }
 789         }
 790         break;
 791         case WFD_OEM_EVENT_PROV_DISC_RESP:
 792         {
 793                 if (!session) {         // TODO: check validity of Event
 794                         WDS_LOGE("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
 795                                                                                 MAC2SECSTR(event->dev_addr));
 796                         break;
 797                 }
 798
 799                 if (session->state > SESSION_STATE_STARTED) {
 800                         WDS_LOGE("Unexpected event. Session is already started");
 801                         break;
 802                 }
 803
 804                 if (session->type == SESSION_TYPE_INVITE) {
 805                         WDS_LOGE("Session type is invite, ignore provision discovery response");
 806                         break;
 807                 }
 808
 809                 /* Update session */
 810                 session->wps_mode = event->wps_mode;
 811                 if (event->wps_mode == WFD_WPS_MODE_DISPLAY) {
 812                         session->req_wps_mode = WFD_WPS_MODE_KEYPAD;
 813                         g_strlcpy(session->wps_pin, event->wps_pin, PINSTR_LEN + 1);
 814                 } else if (event->wps_mode == WFD_WPS_MODE_KEYPAD) {
 815                         session->req_wps_mode = WFD_WPS_MODE_DISPLAY;
 816                 } else {
 817                         session->req_wps_mode = WFD_WPS_MODE_PBC;
 818                 }
 819                 session->state = SESSION_STATE_STARTED;
 820                 wfd_session_timer(session, 1);
 821
 822                 /* Update local device */
 823                 manager->local->wps_mode = event->wps_mode;
 824                 WDS_LOGD("Local WPS mode is %d", session->wps_mode);
 825
 826                 if (session->wps_mode != WFD_WPS_MODE_PBC) {
 827                         char peer_mac_address[MACSTR_LEN+1] = {0, };
 828
 829                         g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
 830                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 831                                                      "Connection",
 832                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 833                                                                             WFD_EVENT_CONNECTION_WPS_REQ,
 834                                                                             peer_mac_address));
 835                         if (session->wps_mode == WFD_WPS_MODE_KEYPAD) {
 836                                 /* We have to wait until user type PIN using Keypad */
 837                                 break;
 838                         }
 839                 }
 840
 841                 if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
 842                         WDS_LOGD("Start WPS corresponding to OEM event [%d]", event->event_id);
 843                         res = wfd_session_wps(session);
 844                 } else if (session->peer->dev_role == WFD_DEV_ROLE_GO) {
 845                         WDS_LOGD("Start WPS(join) corresponding to OEM event [%d]", event->event_id);
 846                         res = wfd_session_join(session);
 847                 } else {
 848                         WDS_LOGD("Start connection corresponding to OEM event [%d]", event->event_id);
 849                         res = wfd_session_connect(session);
 850                 }
 851         }
 852         if (res < 0)
 853                 _wfd_notify_session_failed(manager, event->dev_addr);
 854         break;
 855         case WFD_OEM_EVENT_GO_NEG_REQ:
 856                 if (!session) {
 857                         // TODO: check whether connection is started by negotiation not by prov_disc
 858                         WDS_LOGE("Unexpected event. Session not exist [peer: " MACSECSTR "]",
 859                                                 MAC2SECSTR(event->dev_addr));
 860                         break;
 861                 } else {
 862                         /* Sometimes, Provision Discovery response is not received.
 863                          * At this time, connection should be triggered by GO Negotiation request event */
 864                         if (session->direction == SESSION_DIRECTION_OUTGOING) {
 865                                 res = wfd_session_connect(session);
 866                         } else {
 867                                 /* In autoconnection mode, MT should not send GO Nego Req
 868                                    before receiving the GO Nego Req from peer (MO). */
 869                                 if (manager->autoconnection == TRUE)
 870                                         res  = wfd_session_connect(session);
 871                         }
 872                         if (res < 0)
 873                                 _wfd_notify_session_failed(manager, event->dev_addr);
 874                 }
 875                 break;
 876         case WFD_OEM_EVENT_GO_NEG_DONE:
 877                 if (!session) {
 878                         WDS_LOGE("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
 879                                                 MAC2SECSTR(event->dev_addr));
 880                         break;
 881                 } else {
 882                         manager->local->dev_role = event->dev_role;
 883                         session->state = SESSION_STATE_WPS;
 884                 }
 885
 886                 break;
 887         case WFD_OEM_EVENT_WPS_DONE:
 888                 if (!session) {
 889                         WDS_LOGE("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
 890                                                 MAC2SECSTR(event->dev_addr));
 891                         break;
 892                 } else {
 893                         session->state = SESSION_STATE_KEY_NEG;
 894                 }
 895
 896                 break;
 897         case WFD_OEM_EVENT_STA_CONNECTED:
 898                 if (!session) {
 899                         WDS_LOGE("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
 900                                                 MAC2SECSTR(event->dev_addr));
 901                         break;
 902                 } else {
 903                         session->state = SESSION_STATE_COMPLETED;
 904                 }
 905
 906                 break;
 907         default:
 908                 break;
 909         }
 910         __WDS_LOG_FUNC_EXIT__;
 911         return 0;
 912 }