unittest/event_injector.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <glib.h>
  19 #include "wifi-direct-oem.h"
  20 #include "event_injector.h"
  21
  22 const int EventInjector::mac_addr_len = 6;
  23 const char *EventInjector::peer_device_addr_str = "aa:bb:cc:dd:ee:ff";
  24 const char *EventInjector::legacy_peer_iface_addr_str = "ab:cd:ef:ef:cd:ab";
  25 const char *EventInjector::local_mac_str = "aa:bb:cc:dd:ee:dd";
  26 const char *EventInjector::peer_iface_addr_str = "ac:bb:cc:dd:ee:ff";
  27 const char *EventInjector::peer_go_addr_str = "00:11:22:33:44:55";
  28 const char *EventInjector::peer_device_name = "TEST";
  29 const int EventInjector::peer_config_methods = WFD_OEM_WPS_MODE_PBC;
  30 const int EventInjector::peer_dev_flag = 0x25;
  31 const int EventInjector::peer_group_flag = 0x0;
  32 const int EventInjector::peer_dev_role = WFD_OEM_DEV_ROLE_NONE;
  33 const unsigned char EventInjector::peer_pri_dev_type = 10;
  34 const unsigned char EventInjector::peer_sec_dev_type = 1;
  35 const char *EventInjector::pin_str = "12345678";
  36 const unsigned char EventInjector::ip_addr[4] = {192, 168, 49, 100};
  37 const unsigned char EventInjector::ip_addr_mask[4] = {255, 255, 255, 0};
  38 const unsigned char EventInjector::ip_addr_go[4] = {192, 168, 49, 1};
  39 const int EventInjector::group_freq = 2412;
  40 const char *EventInjector::group_pass = "abcdefgh";
  41
  42 EventInjector::EventInjector()
  43 {
  44         this->event_data = NULL;
  45         this->event_data = g_try_malloc0(sizeof(wfd_oem_event_s));
  46 }
  47
  48 static void __destroy_asp_service(gpointer data)
  49 {
  50         wfd_oem_advertise_service_s *service;
  51
  52         service  = (wfd_oem_advertise_service_s *)data;
  53         g_free(service->service_type);
  54         g_free(service->instance_name);
  55         g_free(service);
  56
  57         return;
  58 }
  59
  60 static void __destroy_wfds(gpointer data)
  61 {
  62         wfd_oem_new_service_s * service = (wfd_oem_new_service_s *)data;
  63         if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
  64                 g_free(service->data.bonjour.query);
  65                 g_free(service->data.bonjour.rdata);
  66         } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
  67                 g_free(service->data.upnp.version);
  68                 g_free(service->data.upnp.service);
  69         }
  70         g_free(service);
  71 }
  72
  73 EventInjector::~EventInjector()
  74 {
  75         wfd_oem_event_s *data = (wfd_oem_event_s *)this->event_data;
  76         if (data) {
  77                 if (data->edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE) {
  78                         g_list_free_full((GList*) data->edata, __destroy_wfds);
  79                         data->edata = NULL;
  80                 }
  81
  82                 if (data->edata_type == WFD_OEM_EDATA_TYPE_ASP_SERVICE) {
  83
  84                         wfd_oem_asp_service_s *service = (wfd_oem_asp_service_s *)data->edata;
  85                         g_free(service->service_type);
  86                         g_free(service->service_info);
  87                         g_free(service);
  88                         data->edata = NULL;
  89                 }
  90
  91                 if (data->edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV) {
  92                         wfd_oem_asp_prov_s *edata = (wfd_oem_asp_prov_s *)data->edata;
  93                         g_free(edata->session_information);
  94                         g_free(edata);
  95                         data->edata = NULL;
  96
  97                 }
  98
  99                 if (data->edata) {
 100                         g_free(data->edata);
 101                         data->edata = NULL;
 102                 }
 103
 104                 if (data->asp_services) {
 105                         g_list_free_full((GList *)data->asp_services, __destroy_asp_service);
 106                         data->asp_services = NULL;
 107                 }
 108
 109                 if (data->asp2_services) {
 110                         g_list_free_full((GList *)data->asp2_services, __destroy_asp_service);
 111                         data->asp2_services = NULL;
 112                 }
 113
 114                 g_free(data);
 115                 this->event_data  = NULL;
 116         }
 117 }
 118
 119 int EventInjector::txt_to_mac(const char *txt, unsigned char *mac)
 120 {
 121         int i = 0;
 122
 123         if (!txt || !mac) {
 124                 return -1;
 125         }
 126
 127         for (;;) {
 128                 mac[i++] = (char) strtoul((char *)txt, (char **)&txt, 16);
 129                 if (!*txt++ || i == 6)
 130                         break;
 131         }
 132
 133         if (i != this->mac_addr_len)
 134                 return -1;
 135
 136         return 0;
 137 }
 138
 139 void EventInjector::InitData()
 140 {
 141         wfd_oem_event_s *event = NULL;
 142         event = (wfd_oem_event_s *)this->event_data;
 143         if (event->edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE) {
 144                 g_list_free_full((GList*) event->edata, __destroy_wfds);
 145                 event->edata = NULL;
 146         }
 147
 148         if (event->edata_type == WFD_OEM_EDATA_TYPE_ASP_SERVICE) {
 149
 150                 wfd_oem_asp_service_s *service = (wfd_oem_asp_service_s *)event->edata;
 151                 g_free(service->service_type);
 152                 g_free(service->service_info);
 153                 g_free(service);
 154         }
 155
 156         if (event->edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV) {
 157                 wfd_oem_asp_prov_s *edata = (wfd_oem_asp_prov_s *)event->edata;
 158                 g_free(edata->session_information);
 159                 g_free(edata);
 160                 event->edata = NULL;
 161
 162         }
 163
 164         if (event->edata) {
 165                 g_free(event->edata);
 166         }
 167
 168         if (event->asp_services) {
 169                 g_list_free_full((GList *)event->asp_services, __destroy_asp_service);
 170                 event->asp_services = NULL;
 171         }
 172
 173         if (event->asp2_services) {
 174                 g_list_free_full((GList *)event->asp2_services, __destroy_asp_service);
 175                 event->asp2_services = NULL;
 176         }
 177
 178         memset(event, 0, sizeof(wfd_oem_event_s));
 179 }
 180
 181 void *EventInjector::GetData()
 182 {
 183         return this->event_data;
 184 }
 185
 186 void *EventInjector::Deactivated()
 187 {
 188         wfd_oem_event_s *event = NULL;
 189         this->InitData();
 190
 191         event = (wfd_oem_event_s *)this->event_data;
 192         event->event_id = WFD_OEM_EVENT_DEACTIVATED;
 193         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 194
 195         return this->event_data;
 196 }
 197
 198 void *EventInjector::PeerFound()
 199 {
 200         wfd_oem_event_s *event = NULL;
 201         wfd_oem_dev_data_s *edata = NULL;
 202         this->InitData();
 203
 204         event = (wfd_oem_event_s *)this->event_data;
 205         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 206
 207         event->edata = (void*) edata;
 208         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 209         event->event_id = WFD_OEM_EVENT_PEER_FOUND;
 210
 211         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 212         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 213         edata->config_methods = this->peer_config_methods;
 214         edata->dev_flags = this->peer_dev_flag;
 215         edata->group_flags = this->peer_group_flag;
 216         edata->dev_role = this->peer_dev_role;
 217         edata->pri_dev_type = this->peer_pri_dev_type;
 218         edata->sec_dev_type = this->peer_sec_dev_type;
 219         edata->rssi = -56;
 220
 221         edata->display.type = WFD_OEM_DISPLAY_TYPE_SOURCE;
 222         edata->display.availability = 1;
 223         edata->display.hdcp_support = 1;
 224         edata->display.max_tput = 54;
 225         edata->display.port = 7236;
 226
 227         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 228         return this->event_data;
 229 }
 230
 231 void *EventInjector::GoFound()
 232 {
 233         wfd_oem_event_s *event = NULL;
 234         wfd_oem_dev_data_s *edata = NULL;
 235         this->InitData();
 236
 237         event = (wfd_oem_event_s *)this->event_data;
 238         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 239
 240         event->edata = (void*) edata;
 241         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 242         event->event_id = WFD_OEM_EVENT_PEER_FOUND;
 243
 244         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 245         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 246         edata->config_methods = this->peer_config_methods;
 247         edata->dev_flags = this->peer_dev_flag;
 248         edata->group_flags = this->peer_group_flag;
 249         edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 250         edata->pri_dev_type = this->peer_pri_dev_type;
 251         edata->sec_dev_type = this->peer_sec_dev_type;
 252         edata->rssi = -56;
 253
 254         edata->display.type = WFD_OEM_DISPLAY_TYPE_SOURCE;
 255         edata->display.availability = 1;
 256         edata->display.hdcp_support = 1;
 257         edata->display.max_tput = 54;
 258         edata->display.port = 7236;
 259
 260         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 261         this->txt_to_mac(this->peer_iface_addr_str, edata->p2p_intf_addr);
 262         return this->event_data;
 263 }
 264
 265 void *EventInjector::PeerJoined()
 266 {
 267         wfd_oem_event_s *event = NULL;
 268         wfd_oem_dev_data_s *edata = NULL;
 269         this->InitData();
 270
 271         event = (wfd_oem_event_s *)this->event_data;
 272         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 273
 274         event->edata = (void*) edata;
 275         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 276         event->event_id = WFD_OEM_EVENT_STA_CONNECTED;
 277
 278         /* connected as Group Client*/
 279         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 280         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 281         edata->config_methods = this->peer_config_methods;
 282         edata->dev_flags = this->peer_dev_flag;
 283         edata->group_flags = this->peer_group_flag;
 284         edata->dev_role = WFD_OEM_DEV_ROLE_GC;
 285         edata->pri_dev_type = this->peer_pri_dev_type;
 286         edata->sec_dev_type = this->peer_sec_dev_type;
 287         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 288
 289         return this->event_data;
 290 }
 291
 292 void *EventInjector::PeerJoinedwithIP()
 293 {
 294         wfd_oem_event_s *event = NULL;
 295         wfd_oem_dev_data_s *edata = NULL;
 296         this->InitData();
 297
 298         event = (wfd_oem_event_s *)this->event_data;
 299         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 300
 301         event->edata = (void*) edata;
 302         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 303         event->event_id = WFD_OEM_EVENT_STA_CONNECTED;
 304
 305         /* connected as Group Client*/
 306         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 307         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 308         edata->config_methods = this->peer_config_methods;
 309         edata->dev_flags = this->peer_dev_flag;
 310         edata->group_flags = this->peer_group_flag;
 311         edata->dev_role = WFD_OEM_DEV_ROLE_GC;
 312         edata->pri_dev_type = this->peer_pri_dev_type;
 313         edata->sec_dev_type = this->peer_sec_dev_type;
 314         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 315
 316         for (int i = 0; i <OEM_IPADDR_LEN; i++) {
 317                 event->ip_addr_peer[i] = this->ip_addr[i];
 318         }
 319
 320         return this->event_data;
 321 }
 322
 323 void *EventInjector::PeerDisconnected()
 324 {
 325         wfd_oem_event_s *event = NULL;
 326         this->InitData();
 327
 328         event = (wfd_oem_event_s *)this->event_data;
 329
 330         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 331         event->event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
 332
 333         /* Disconnected device device address*/
 334         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 335
 336         return this->event_data;
 337 }
 338 void *EventInjector::LegacyPeerJoined()
 339 {
 340         wfd_oem_event_s *event = NULL;
 341         wfd_oem_dev_data_s *edata = NULL;
 342         this->InitData();
 343
 344         event = (wfd_oem_event_s *)this->event_data;
 345         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 346
 347         event->edata = (void*) edata;
 348         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 349         event->event_id = WFD_OEM_EVENT_STA_CONNECTED;
 350
 351         /* connected as Group Client*/
 352         this->txt_to_mac(this->legacy_peer_iface_addr_str, event->intf_addr);
 353
 354         return this->event_data;
 355 }
 356 void *EventInjector::LegacyPeerDisconnected()
 357 {
 358         wfd_oem_event_s *event = NULL;
 359         this->InitData();
 360
 361         event = (wfd_oem_event_s *)this->event_data;
 362
 363         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 364         event->event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
 365
 366         /* Disconnected device device address*/
 367         this->txt_to_mac(this->legacy_peer_iface_addr_str, event->intf_addr);
 368
 369         return this->event_data;
 370 }
 371
 372 void *EventInjector::DeviceLost()
 373 {
 374         wfd_oem_event_s *event = NULL;
 375         this->InitData();
 376
 377         event = (wfd_oem_event_s *)this->event_data;
 378
 379         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 380         event->event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
 381
 382         /* Disappeared device device address*/
 383         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 384
 385         return this->event_data;
 386 }
 387
 388 void *EventInjector::FindStopped()
 389 {
 390         wfd_oem_event_s *event = NULL;
 391         this->InitData();
 392
 393         event = (wfd_oem_event_s *)this->event_data;
 394
 395         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 396         event->event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
 397
 398         return this->event_data;
 399 }
 400
 401 void *EventInjector::ProvReqDisplayPin(bool from_go)
 402 {
 403         wfd_oem_event_s *event = NULL;
 404         wfd_oem_dev_data_s *edata = NULL;
 405         this->InitData();
 406
 407         event = (wfd_oem_event_s *)this->event_data;
 408         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 409
 410         event->edata = (void*) edata;
 411         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 412         event->event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
 413         event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
 414
 415         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 416         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 417         edata->config_methods = this->peer_config_methods;
 418         edata->dev_flags = this->peer_dev_flag;
 419         edata->group_flags = this->peer_group_flag;
 420         edata->dev_role = this->peer_dev_role;
 421         edata->pri_dev_type = this->peer_pri_dev_type;
 422         edata->sec_dev_type = this->peer_sec_dev_type;
 423         if (from_go)
 424                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 425
 426         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 427         g_strlcpy(event->wps_pin, this->pin_str, OEM_PINSTR_LEN + 1);
 428
 429         return this->event_data;
 430 }
 431
 432 void *EventInjector::ProvRespDisplayPin(bool from_go)
 433 {
 434         wfd_oem_event_s *event = NULL;
 435         wfd_oem_dev_data_s *edata = NULL;
 436         this->InitData();
 437
 438         event = (wfd_oem_event_s *)this->event_data;
 439         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 440
 441         event->edata = (void*) edata;
 442         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 443         event->event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
 444         event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
 445
 446         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 447         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 448         edata->config_methods = this->peer_config_methods;
 449         edata->dev_flags = this->peer_dev_flag;
 450         edata->group_flags = this->peer_group_flag;
 451         edata->dev_role = this->peer_dev_role;
 452         edata->pri_dev_type = this->peer_pri_dev_type;
 453         edata->sec_dev_type = this->peer_sec_dev_type;
 454         if (from_go)
 455                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 456
 457         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 458         g_strlcpy(event->wps_pin, this->pin_str, OEM_PINSTR_LEN + 1);
 459
 460         return this->event_data;
 461 }
 462
 463 void *EventInjector::ProvReqEnterPin(bool from_go)
 464 {
 465         wfd_oem_event_s *event = NULL;
 466         wfd_oem_dev_data_s *edata = NULL;
 467         this->InitData();
 468
 469         event = (wfd_oem_event_s *)this->event_data;
 470         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 471
 472         event->edata = (void*) edata;
 473         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 474         event->event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
 475         event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
 476
 477         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 478         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 479         edata->config_methods = this->peer_config_methods;
 480         edata->dev_flags = this->peer_dev_flag;
 481         edata->group_flags = this->peer_group_flag;
 482         edata->dev_role = this->peer_dev_role;
 483         edata->pri_dev_type = this->peer_pri_dev_type;
 484         edata->sec_dev_type = this->peer_sec_dev_type;
 485         if (from_go)
 486                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 487
 488         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 489         return this->event_data;
 490 }
 491
 492 void *EventInjector::ProvRespEnterPin(bool from_go)
 493 {
 494         wfd_oem_event_s *event = NULL;
 495         wfd_oem_dev_data_s *edata = NULL;
 496         this->InitData();
 497
 498         event = (wfd_oem_event_s *)this->event_data;
 499         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 500
 501         event->edata = (void*) edata;
 502         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 503         event->event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
 504         event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
 505
 506         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 507         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 508         edata->config_methods = this->peer_config_methods;
 509         edata->dev_flags = this->peer_dev_flag;
 510         edata->group_flags = this->peer_group_flag;
 511         edata->dev_role = this->peer_dev_role;
 512         edata->pri_dev_type = this->peer_pri_dev_type;
 513         edata->sec_dev_type = this->peer_sec_dev_type;
 514         if (from_go)
 515                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 516
 517         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 518         return this->event_data;
 519 }
 520
 521 void *EventInjector::ProvPbcReq(bool from_go)
 522 {
 523         wfd_oem_event_s *event = NULL;
 524         wfd_oem_dev_data_s *edata = NULL;
 525         this->InitData();
 526
 527         event = (wfd_oem_event_s *)this->event_data;
 528         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 529
 530         event->edata = (void*) edata;
 531         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 532         event->event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
 533         event->wps_mode = WFD_OEM_WPS_MODE_PBC;
 534
 535         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 536         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 537         edata->config_methods = this->peer_config_methods;
 538         edata->dev_flags = this->peer_dev_flag;
 539         edata->group_flags = this->peer_group_flag;
 540         edata->dev_role = this->peer_dev_role;
 541         edata->pri_dev_type = this->peer_pri_dev_type;
 542         edata->sec_dev_type = this->peer_sec_dev_type;
 543         if (from_go)
 544                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 545
 546         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 547         return this->event_data;
 548 }
 549
 550 void *EventInjector::ProvPbcResp(bool from_go)
 551 {
 552         wfd_oem_event_s *event = NULL;
 553         wfd_oem_dev_data_s *edata = NULL;
 554         this->InitData();
 555
 556         event = (wfd_oem_event_s *)this->event_data;
 557         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 558
 559         event->edata = (void*) edata;
 560         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 561         event->event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
 562         event->wps_mode = WFD_OEM_WPS_MODE_PBC;
 563
 564         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 565         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 566         edata->config_methods = this->peer_config_methods;
 567         edata->dev_flags = this->peer_dev_flag;
 568         edata->group_flags = this->peer_group_flag;
 569         edata->dev_role = this->peer_dev_role;
 570         edata->pri_dev_type = this->peer_pri_dev_type;
 571         edata->sec_dev_type = this->peer_sec_dev_type;
 572         if (from_go)
 573                 edata->dev_role = WFD_OEM_DEV_ROLE_GO;
 574
 575         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 576         return this->event_data;
 577 }
 578
 579 void *EventInjector::ProvFailure()
 580 {
 581         wfd_oem_event_s *event = NULL;
 582         this->InitData();
 583
 584         event = (wfd_oem_event_s *)this->event_data;
 585         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 586         event->event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
 587
 588         return this->event_data;
 589 }
 590
 591 void *EventInjector::GroupStartedGO()
 592 {
 593         wfd_oem_event_s *event = NULL;
 594         wfd_oem_group_data_s *group;
 595         this->InitData();
 596
 597         event = (wfd_oem_event_s *)this->event_data;
 598         group = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
 599
 600         event->edata = (void*) group;
 601         event->edata_type = WFD_OEM_EDATA_TYPE_GROUP;
 602         event->event_id = WFD_OEM_EVENT_GROUP_CREATED;
 603
 604         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 605         group->is_persistent = false;
 606         group->freq = this->group_freq;
 607         g_strlcpy(group->pass, this->group_pass, OEM_PASS_PHRASE_LEN+1);
 608
 609         return this->event_data;
 610 }
 611
 612 void *EventInjector::GroupStartedGOPersistent()
 613 {
 614         wfd_oem_event_s *event = NULL;
 615         wfd_oem_group_data_s *group;
 616         this->InitData();
 617
 618         event = (wfd_oem_event_s *)this->event_data;
 619         group = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
 620
 621         event->edata = (void*) group;
 622         event->edata_type = WFD_OEM_EDATA_TYPE_GROUP;
 623         event->event_id = WFD_OEM_EVENT_GROUP_CREATED;
 624
 625         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 626         group->is_persistent = true;
 627         group->freq = this->group_freq;
 628         g_strlcpy(group->pass, this->group_pass, OEM_PASS_PHRASE_LEN+1);
 629
 630         return this->event_data;
 631 }
 632
 633 void *EventInjector::GroupStartedGC()
 634 {
 635         wfd_oem_event_s *event = NULL;
 636         wfd_oem_group_data_s *group;
 637         this->InitData();
 638
 639         event = (wfd_oem_event_s *)this->event_data;
 640         group = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
 641
 642         event->edata = (void*) group;
 643         event->edata_type = WFD_OEM_EDATA_TYPE_GROUP;
 644         event->event_id = WFD_OEM_EVENT_GROUP_CREATED;
 645
 646         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 647         group->is_persistent = false;
 648         group->freq = this->group_freq;
 649         g_strlcpy(group->pass, this->group_pass, OEM_PASS_PHRASE_LEN+1);
 650
 651         for (int i = 0; i <OEM_IPADDR_LEN; i++) {
 652                 group->ip_addr[i] = this->ip_addr[i];
 653                 group->ip_addr_mask[i] = this->ip_addr_mask[i];
 654                 group->ip_addr_go[i] = this->ip_addr_go[i];
 655         }
 656
 657         return this->event_data;
 658 }
 659
 660 void *EventInjector::GroupStartedGCPersistent()
 661 {
 662         wfd_oem_event_s *event = NULL;
 663         wfd_oem_group_data_s *group;
 664         this->InitData();
 665
 666         event = (wfd_oem_event_s *)this->event_data;
 667         group = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
 668
 669         event->edata = (void*) group;
 670         event->edata_type = WFD_OEM_EDATA_TYPE_GROUP;
 671         event->event_id = WFD_OEM_EVENT_GROUP_CREATED;
 672
 673         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 674         group->is_persistent = true;
 675         group->freq = this->group_freq;
 676         g_strlcpy(group->pass, this->group_pass, OEM_PASS_PHRASE_LEN+1);
 677
 678         for (int i = 0; i <OEM_IPADDR_LEN; i++) {
 679                 group->ip_addr[i] = this->ip_addr[i];
 680                 group->ip_addr_mask[i] = this->ip_addr_mask[i];
 681                 group->ip_addr_go[i] = this->ip_addr_go[i];
 682         }
 683
 684         return this->event_data;
 685 }
 686
 687 void *EventInjector::GroupStartedGCwithoutIP()
 688 {
 689         wfd_oem_event_s *event = NULL;
 690         wfd_oem_group_data_s *group;
 691         this->InitData();
 692
 693         event = (wfd_oem_event_s *)this->event_data;
 694         group = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
 695
 696         event->edata = (void*) group;
 697         event->edata_type = WFD_OEM_EDATA_TYPE_GROUP;
 698         event->event_id = WFD_OEM_EVENT_GROUP_CREATED;
 699
 700         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 701         group->is_persistent = false;
 702         group->freq = this->group_freq;
 703         g_strlcpy(group->pass, this->group_pass, OEM_PASS_PHRASE_LEN+1);
 704
 705         return this->event_data;
 706 }
 707
 708 void *EventInjector::GoNegSuccessGo()
 709 {
 710         wfd_oem_event_s *event;
 711         wfd_oem_conn_data_s *edata = NULL;
 712         this->InitData();
 713
 714         event = (wfd_oem_event_s *)this->event_data;
 715         edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
 716
 717         event->edata = (void*) edata;
 718         event->edata_type = WFD_OEM_EDATA_TYPE_CONN;
 719         event->event_id = WFD_OEM_EVENT_GO_NEG_DONE;
 720
 721         event->dev_role = WFD_OEM_DEV_ROLE_GO;
 722
 723         this->txt_to_mac(this->peer_device_addr_str, edata->peer_device_addr);
 724         this->txt_to_mac(this->peer_iface_addr_str, edata->peer_intf_addr);
 725
 726         return this->event_data;
 727 }
 728
 729 void *EventInjector::GoNegSuccessGc()
 730 {
 731         wfd_oem_event_s *event;
 732         wfd_oem_conn_data_s *edata = NULL;
 733         this->InitData();
 734
 735         event = (wfd_oem_event_s *)this->event_data;
 736         edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
 737
 738         event->edata = (void*) edata;
 739         event->edata_type = WFD_OEM_EDATA_TYPE_CONN;
 740         event->event_id = WFD_OEM_EVENT_GO_NEG_DONE;
 741
 742         event->dev_role = WFD_OEM_DEV_ROLE_GC;
 743
 744         this->txt_to_mac(this->peer_device_addr_str, edata->peer_device_addr);
 745         this->txt_to_mac(this->peer_iface_addr_str, edata->peer_intf_addr);
 746
 747         return this->event_data;
 748 }
 749
 750 void *EventInjector::GoNegFailure()
 751 {
 752         wfd_oem_event_s *event;
 753         wfd_oem_conn_data_s *edata = NULL;
 754         this->InitData();
 755
 756         event = (wfd_oem_event_s *)this->event_data;
 757         edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
 758
 759         event->edata = (void*) edata;
 760         event->edata_type = WFD_OEM_EDATA_TYPE_CONN;
 761         event->event_id = WFD_OEM_EVENT_GO_NEG_FAIL;
 762
 763         /* TODO: check status */
 764         edata->status = 0;
 765
 766         return this->event_data;
 767 }
 768
 769 void *EventInjector::GoNegRequestPbc()
 770 {
 771         wfd_oem_event_s *event;
 772         wfd_oem_dev_data_s *edata = NULL;
 773         this->InitData();
 774
 775         event = (wfd_oem_event_s *)this->event_data;
 776         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 777
 778         event->edata = (void*) edata;
 779         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 780         event->event_id = WFD_OEM_EVENT_GO_NEG_REQ;
 781         event->wps_mode = WFD_OEM_WPS_MODE_PBC;
 782
 783         edata->device_go_intent = 7;
 784
 785         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 786         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 787         edata->config_methods = this->peer_config_methods;
 788         edata->dev_flags = this->peer_dev_flag;
 789         edata->group_flags = this->peer_group_flag;
 790         edata->dev_role = this->peer_dev_role;
 791         edata->pri_dev_type = this->peer_pri_dev_type;
 792         edata->sec_dev_type = this->peer_sec_dev_type;
 793         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 794
 795         return this->event_data;
 796 }
 797
 798 void *EventInjector::GoNegRequestDisplay()
 799 {
 800         wfd_oem_event_s *event;
 801         wfd_oem_dev_data_s *edata = NULL;
 802         this->InitData();
 803
 804         event = (wfd_oem_event_s *)this->event_data;
 805         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 806
 807         event->edata = (void*) edata;
 808         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 809         event->event_id = WFD_OEM_EVENT_GO_NEG_REQ;
 810         event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
 811
 812         edata->device_go_intent = 7;
 813
 814         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 815         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 816         edata->config_methods = this->peer_config_methods;
 817         edata->dev_flags = this->peer_dev_flag;
 818         edata->group_flags = this->peer_group_flag;
 819         edata->dev_role = this->peer_dev_role;
 820         edata->pri_dev_type = this->peer_pri_dev_type;
 821         edata->sec_dev_type = this->peer_sec_dev_type;
 822         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 823
 824         return this->event_data;
 825 }
 826
 827 void *EventInjector::GoNegRequestKeypad()
 828 {
 829         wfd_oem_event_s *event;
 830         wfd_oem_dev_data_s *edata = NULL;
 831         this->InitData();
 832
 833         event = (wfd_oem_event_s *)this->event_data;
 834         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 835
 836         event->edata = (void*) edata;
 837         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 838         event->event_id = WFD_OEM_EVENT_GO_NEG_REQ;
 839
 840         event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
 841
 842         edata->device_go_intent = 7;
 843
 844         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 845         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
 846         edata->config_methods = this->peer_config_methods;
 847         edata->dev_flags = this->peer_dev_flag;
 848         edata->group_flags = this->peer_group_flag;
 849         edata->dev_role = this->peer_dev_role;
 850         edata->pri_dev_type = this->peer_pri_dev_type;
 851         edata->sec_dev_type = this->peer_sec_dev_type;
 852         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
 853
 854         return this->event_data;
 855 }
 856
 857 void *EventInjector::InvitationReceived()
 858 {
 859         wfd_oem_event_s *event;
 860         wfd_oem_invite_data_s *edata = NULL;
 861         this->InitData();
 862
 863         event = (wfd_oem_event_s *)this->event_data;
 864         edata = (wfd_oem_invite_data_s *) g_try_malloc0(sizeof(wfd_oem_invite_data_s));
 865
 866         event->edata = (void*) edata;
 867         event->edata_type = WFD_OEM_EDATA_TYPE_INVITE;
 868         event->event_id = WFD_OEM_EVENT_INVITATION_REQ;
 869
 870         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 871         this->txt_to_mac(this->peer_iface_addr_str, edata->bssid);
 872
 873         return this->event_data;
 874 }
 875
 876 void *EventInjector::GroupFinished()
 877 {
 878         wfd_oem_event_s *event;
 879         this->InitData();
 880
 881         event = (wfd_oem_event_s *)this->event_data;
 882
 883         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 884         event->event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
 885
 886         return this->event_data;
 887 }
 888
 889 void *EventInjector::WpsFailed()
 890 {
 891         wfd_oem_event_s *event;
 892         this->InitData();
 893
 894         event = (wfd_oem_event_s *)this->event_data;
 895
 896         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 897         event->event_id = WFD_OEM_EVENT_WPS_FAIL;
 898
 899         return this->event_data;
 900 }
 901
 902 void *EventInjector::KeyNegFailed()
 903 {
 904         wfd_oem_event_s *event;
 905         this->InitData();
 906
 907         event = (wfd_oem_event_s *)this->event_data;
 908
 909         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 910         event->event_id = WFD_OEM_EVENT_KEY_NEG_FAIL;
 911
 912         return this->event_data;
 913 }
 914
 915 void *EventInjector::GroupFormationFailed()
 916 {
 917         wfd_oem_event_s *event;
 918         this->InitData();
 919
 920         event = (wfd_oem_event_s *)this->event_data;
 921
 922         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 923         event->event_id = WFD_OEM_EVENT_GROUP_FORMATION_FAILURE;
 924
 925         return this->event_data;
 926 }
 927
 928 void *EventInjector::InvitationAccepted()
 929 {
 930         wfd_oem_event_s *event;
 931         this->InitData();
 932
 933         event = (wfd_oem_event_s *)this->event_data;
 934
 935         event->edata_type = WFD_OEM_EDATA_TYPE_NONE;
 936         event->event_id = WFD_OEM_EVENT_INVITATION_ACCEPTED;
 937
 938         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 939
 940         return this->event_data;
 941 }
 942
 943 void *EventInjector::ServDiscResp()
 944 {
 945         GList *services = NULL;
 946         wfd_oem_new_service_s *new_service = NULL;
 947         wfd_oem_event_s *event;
 948         int count = 0;
 949
 950         this->InitData();
 951
 952         event = (wfd_oem_event_s *)this->event_data;
 953
 954         event->edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
 955         event->event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
 956
 957         new_service = (wfd_oem_new_service_s*)g_try_malloc0(sizeof(wfd_oem_new_service_s));
 958         new_service->protocol = WFD_OEM_SERVICE_TYPE_BONJOUR;
 959         new_service->trans_id = 1;
 960         new_service->status = 1;
 961         new_service->data.bonjour.query = strdup("_afpovertcp._tcp.local.");
 962         new_service->data.bonjour.rdata = strdup("Example._afpovertcp._tcp.local");
 963
 964         services = g_list_append(services, new_service);
 965         count++;
 966
 967         new_service = (wfd_oem_new_service_s*)g_try_malloc0(sizeof(wfd_oem_new_service_s));
 968         new_service->protocol = WFD_OEM_SERVICE_TYPE_UPNP;
 969         new_service->trans_id = 2;
 970         new_service->status = 1;
 971         new_service->data.upnp.version = strdup("10");
 972         new_service->data.upnp.service = strdup("uuid:6859dede-8574-59ab-9332-123456789012::upnp:rootdevice");
 973
 974         services = g_list_append(services, new_service);
 975         count++;
 976
 977         event->dev_role = count;
 978         event->edata = (void*) services;
 979
 980         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 981
 982         return this->event_data;
 983 }
 984
 985 void *EventInjector::AspPeerFound()
 986 {
 987         wfd_oem_event_s *event = NULL;
 988         wfd_oem_dev_data_s *edata = NULL;
 989         this->InitData();
 990
 991         event = (wfd_oem_event_s *)this->event_data;
 992         edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
 993
 994         event->edata = (void*) edata;
 995         event->edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
 996         event->event_id = WFD_OEM_EVENT_PEER_FOUND;
 997
 998         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
 999         g_strlcpy(edata->name, this->peer_device_name, OEM_DEV_NAME_LEN);
1000         edata->config_methods = this->peer_config_methods;
1001         edata->dev_flags = this->peer_dev_flag;
1002         edata->group_flags = this->peer_group_flag;
1003         edata->dev_role = this->peer_dev_role;
1004         edata->pri_dev_type = this->peer_pri_dev_type;
1005         edata->sec_dev_type = this->peer_sec_dev_type;
1006         edata->rssi = -56;
1007
1008         edata->display.type = WFD_OEM_DISPLAY_TYPE_SOURCE;
1009         edata->display.availability = 1;
1010         edata->display.hdcp_support = 1;
1011         edata->display.max_tput = 54;
1012         edata->display.port = 7236;
1013
1014         this->txt_to_mac(this->peer_device_addr_str, edata->p2p_dev_addr);
1015
1016         /* P2PS service */
1017         wfd_oem_advertise_service_s *service;
1018         char *service_type = strdup("service_type");
1019         int service_type_len = strlen(service_type);
1020
1021         service = (wfd_oem_advertise_service_s *)
1022                         g_try_malloc0(sizeof(wfd_oem_advertise_service_s));
1023         event->asp_services =  g_list_append((GList *)event->asp_services, service);
1024
1025         service->adv_id = 0;
1026         service->config_method = 0;
1027         service->service_type_length = service_type_len;
1028         service->service_type = service_type;
1029         service->search_id  = 0;
1030
1031         /* ASP service */
1032         event->asp2_services;
1033
1034         char *asp_service_type = strdup("asp_service_type");
1035         int asp_service_type_len = strlen(asp_service_type);
1036         char *instance_name = strdup("instance_name");
1037         int instance_name_len = strlen(instance_name);
1038
1039         service = (wfd_oem_advertise_service_s *)
1040                         g_try_malloc0(sizeof(wfd_oem_advertise_service_s));
1041         event->asp2_services =  g_list_append((GList *)event->asp2_services, service);
1042
1043         service->adv_id = 1;
1044         service->config_method = 0;
1045         service->service_type_length = asp_service_type_len;
1046         service->service_type = asp_service_type;
1047         service->instance_name_length = instance_name_len;
1048         service->instance_name = instance_name;
1049         service->search_id  = 0;
1050
1051         return this->event_data;
1052 }
1053 void *EventInjector::AspServiceFound()
1054 {
1055         wfd_oem_event_s *event = NULL;
1056         wfd_oem_asp_service_s *service = NULL;
1057         char *asp_service_type = g_strdup("asp_service_type");
1058         char *service_info = g_strdup("service_info");
1059         this->InitData();
1060
1061         event = (wfd_oem_event_s *)this->event_data;
1062         service = (wfd_oem_asp_service_s *)g_try_malloc0(sizeof(wfd_oem_asp_service_s));
1063
1064         event->edata = (void*) service;
1065         event->edata_type = WFD_OEM_EDATA_TYPE_ASP_SERVICE;
1066         event->event_id = WFD_OEM_EVENT_ASP_SERV_RESP;
1067
1068         service->adv_id = 0;
1069         service->status = 0;
1070         service->config_method = 0;
1071         service->service_type = asp_service_type;
1072         service->service_info = service_info;
1073
1074         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
1075
1076         return this->event_data;
1077 }
1078
1079 void *EventInjector::AspProvStart(int wps_mode, int network_role)
1080 {
1081         wfd_oem_event_s *event = NULL;
1082         wfd_oem_asp_prov_s *edata;
1083         this->InitData();
1084
1085         event = (wfd_oem_event_s *)this->event_data;
1086         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
1087
1088         event->edata = (void*) edata;
1089         event->edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
1090         event->event_id = WFD_OEM_EVENT_ASP_PROV_START;
1091
1092         edata->adv_id = 0;
1093         edata->session_id = 0;
1094         edata->network_role = network_role;
1095         edata->session_information = strdup("session_info");
1096
1097         this->txt_to_mac(this->local_mac_str, edata->service_mac);
1098         this->txt_to_mac(this->peer_device_addr_str, edata->session_mac);
1099
1100         event->wps_mode = wps_mode;
1101
1102         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
1103
1104         return this->event_data;
1105 }
1106
1107 void *EventInjector::AspProvDone(int status, int wps_mode, int network_role, int persist, int persist_id)
1108 {
1109         wfd_oem_event_s *event = NULL;
1110         wfd_oem_asp_prov_s *edata;
1111         this->InitData();
1112
1113         event = (wfd_oem_event_s *)this->event_data;
1114         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
1115
1116         event->edata = (void*) edata;
1117         event->edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
1118         event->event_id = WFD_OEM_EVENT_ASP_PROV_DONE;
1119
1120         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
1121
1122         edata->adv_id = 0;
1123         edata->session_id = 0;
1124         edata->network_role = network_role;
1125         edata->session_information = strdup("session_info");
1126         edata->status = status;
1127         if (persist) {
1128                 edata->persist = persist;
1129                 edata->persistent_group_id = persist_id;
1130         }
1131
1132         this->txt_to_mac(this->local_mac_str, edata->service_mac);
1133         this->txt_to_mac(this->peer_device_addr_str, edata->session_mac);
1134
1135         event->wps_mode = 0;
1136
1137         this->txt_to_mac(this->peer_device_addr_str, event->dev_addr);
1138
1139         return this->event_data;
1140 }
1141
1142 void *EventInjector::AspProvFail(int status)
1143 {
1144         wfd_oem_event_s *event = NULL;
1145         wfd_oem_asp_prov_s *edata;
1146         this->InitData();
1147
1148         event = (wfd_oem_event_s *)this->event_data;
1149         edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_s));
1150
1151         event->edata = (void*) edata;
1152         event->edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
1153         event->event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
1154
1155         edata->adv_id = 0;
1156         edata->status = status;
1157         edata->session_information = strdup("session_info");
1158
1159         return this->event_data;
1160 }