oem/wifi-direct-oem.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 oem functions.
  22  *
  23  * @file                wifi-direct-oem.c
  24  * @author      Gibyoung Kim (lastkgb.kim@samsung.com)
  25  * @version     0.7
  26  */
  27
  28 #include <stdio.h>
  29
  30 #include <glib.h>
  31
  32 #include "wifi-direct-oem.h"
  33 #include "wifi-direct-event.h"
  34
  35 #if defined TIZEN_ENABLE_PRD
  36 #include "wifi-direct-prd.h"
  37
  38 wfd_oem_prd_event_cbs_s g_prd_event_cbs;
  39 #endif /* TIZEN_ENABLE_PRD */
  40
  41 wfd_oem_event_cbs_s g_event_cbs;
  42
  43 int wfd_oem_configure(wfd_oem_ops_s *ops, wfd_oem_config_s *conf)
  44 {
  45         if (!ops || !ops->configure)
  46 #if defined(BUILD_GTESTS)
  47                 return 0;
  48 #else
  49                 return -1;
  50 #endif
  51
  52         return ops->configure(conf);
  53 }
  54
  55 int wfd_oem_init(wfd_oem_ops_s *ops)
  56 {
  57         if (!ops || !ops->init)
  58                 return -1;
  59
  60         wfd_event_init(&g_event_cbs);
  61
  62         return ops->init(&g_event_cbs);
  63 }
  64
  65 #if 0
  66 int wfd_oem_deinit(wfd_oem_ops_s *ops)
  67 {
  68         if (!ops || !ops->deinit)
  69                 return -1;
  70
  71         return ops->deinit();
  72 }
  73 #endif
  74
  75 int wfd_oem_activate(wfd_oem_ops_s *ops, int concurrent)
  76 {
  77         if (!ops || !ops->activate)
  78 #if defined(BUILD_GTESTS)
  79                 return 0;
  80 #else
  81                 return -1;
  82 #endif
  83         return ops->activate(concurrent);
  84 }
  85
  86 int wfd_oem_deactivate(wfd_oem_ops_s *ops, int concurrent)
  87 {
  88         if (!ops || !ops->deactivate)
  89 #if defined(BUILD_GTESTS)
  90                 return 0;
  91 #else
  92                 return -1;
  93 #endif
  94
  95         return ops->deactivate(concurrent);
  96 }
  97
  98 int wfd_oem_start_scan(wfd_oem_ops_s *ops, wfd_oem_scan_param_s *param)
  99 {
 100         if (!ops || !ops->start_scan)
 101 #if defined(BUILD_GTESTS)
 102                 return 0;
 103 #else
 104                 return -1;
 105 #endif
 106
 107         return ops->start_scan(param);
 108 }
 109
 110 int wfd_oem_stop_scan(wfd_oem_ops_s *ops)
 111 {
 112         if (!ops || !ops->stop_scan)
 113 #if defined(BUILD_GTESTS)
 114                 return 0;
 115 #else
 116                 return -1;
 117 #endif
 118
 119         return ops->stop_scan();
 120 }
 121
 122 int wfd_oem_get_visibility(wfd_oem_ops_s *ops, int *visibility)
 123 {
 124         if (!ops || !ops->get_visibility)
 125 #if defined(BUILD_GTESTS)
 126                 return 0;
 127 #else
 128                 return -1;
 129 #endif
 130
 131         return ops->get_visibility(visibility);
 132 }
 133
 134 int wfd_oem_set_visibility(wfd_oem_ops_s *ops, int visibility)
 135 {
 136         if (!ops || !ops->set_visibility)
 137 #if defined(BUILD_GTESTS)
 138                 return 0;
 139 #else
 140                 return -1;
 141 #endif
 142
 143         return ops->set_visibility(visibility);
 144 }
 145
 146 int wfd_oem_get_scan_result(wfd_oem_ops_s *ops, GList **peers, int *peer_count)
 147 {
 148         if (!ops || !ops->get_scan_result)
 149 #if defined(BUILD_GTESTS)
 150                 return 0;
 151 #else
 152                 return -1;
 153 #endif
 154
 155         return ops->get_scan_result(peers, peer_count);
 156 }
 157
 158 int wfd_oem_get_peer_info(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_device_s **peer)
 159 {
 160         if (!ops || !ops->get_peer_info)
 161 #if defined(BUILD_GTESTS)
 162                 return 0;
 163 #else
 164                 return -1;
 165 #endif
 166
 167         return ops->get_peer_info(peer_addr, peer);
 168 }
 169
 170 int wfd_oem_prov_disc_req(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
 171 {
 172         if (!ops || !ops->prov_disc_req)
 173 #if defined(BUILD_GTESTS)
 174                 return 0;
 175 #else
 176                 return -1;
 177 #endif
 178
 179         return ops->prov_disc_req(peer_addr, wps_mode, join);
 180 }
 181
 182 int wfd_oem_connect(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_conn_param_s *param)
 183 {
 184         if (!ops || !ops->connect)
 185 #if defined(BUILD_GTESTS)
 186                 return 0;
 187 #else
 188                 return -1;
 189 #endif
 190
 191         return ops->connect(peer_addr, param);
 192 }
 193
 194 int wfd_oem_reject_connection(wfd_oem_ops_s *ops, unsigned char *peer_addr)
 195 {
 196         if (!ops || !ops->reject_connection)
 197 #if defined(BUILD_GTESTS)
 198                 return 0;
 199 #else
 200                 return -1;
 201 #endif
 202
 203         return ops->reject_connection(peer_addr);
 204 }
 205
 206 int wfd_oem_cancel_connection(wfd_oem_ops_s *ops, unsigned char *peer_addr)
 207 {
 208         if (!ops || !ops->cancel_connection)
 209 #if defined(BUILD_GTESTS)
 210                 return 0;
 211 #else
 212                 return -1;
 213 #endif
 214
 215         return ops->cancel_connection(peer_addr);
 216 }
 217
 218 int wfd_oem_disconnect(wfd_oem_ops_s *ops, unsigned char *peer_addr, int is_iface_addr)
 219 {
 220         if (!ops || !ops->disconnect)
 221 #if defined(BUILD_GTESTS)
 222                 return 0;
 223 #else
 224                 return -1;
 225 #endif
 226
 227         return ops->disconnect(peer_addr, is_iface_addr);
 228 }
 229
 230 int wfd_oem_get_connected_peers(wfd_oem_ops_s *ops, GList **peers, int *peer_count)
 231 {
 232         if (!ops || !ops->get_connected_peers)
 233 #if defined(BUILD_GTESTS)
 234                 return 0;
 235 #else
 236                 return -1;
 237 #endif
 238
 239         return ops->get_connected_peers(peers, peer_count);
 240 }
 241
 242 int wfd_oem_get_pin(wfd_oem_ops_s *ops, char *pin)
 243 {
 244         if (!ops || !ops->get_pin)
 245 #if defined(BUILD_GTESTS)
 246                 return 0;
 247 #else
 248                 return -1;
 249 #endif
 250
 251         return ops->get_pin(pin);
 252 }
 253
 254 int wfd_oem_set_pin(wfd_oem_ops_s *ops, char *pin)
 255 {
 256         if (!ops || !ops->set_pin)
 257 #if defined(BUILD_GTESTS)
 258                 return 0;
 259 #else
 260                 return -1;
 261 #endif
 262
 263         return ops->set_pin(pin);
 264 }
 265
 266 int wfd_oem_generate_pin(wfd_oem_ops_s *ops, char **pin)
 267 {
 268         if (!ops || !ops->generate_pin)
 269 #if defined(BUILD_GTESTS)
 270                 return 0;
 271 #else
 272                 return -1;
 273 #endif
 274
 275         return ops->generate_pin(pin);
 276 }
 277
 278 int wfd_oem_get_supported_wps_mode(wfd_oem_ops_s *ops, int *wps_mode)
 279 {
 280         if (!ops || !ops->get_supported_wps_mode)
 281 #if defined(BUILD_GTESTS)
 282                 return 0;
 283 #else
 284                 return -1;
 285 #endif
 286
 287         return ops->get_supported_wps_mode(wps_mode);
 288 }
 289
 290 int wfd_oem_create_group(wfd_oem_ops_s *ops, wfd_oem_group_param_s *param)
 291 {
 292         if (!ops || !ops->create_group)
 293 #if defined(BUILD_GTESTS)
 294                 return 0;
 295 #else
 296                 return -1;
 297 #endif
 298
 299         return ops->create_group(param);
 300 }
 301
 302 int wfd_oem_destroy_group(wfd_oem_ops_s *ops, const char *ifname)
 303 {
 304         if (!ops || !ops->destroy_group)
 305 #if defined(BUILD_GTESTS)
 306                 return 0;
 307 #else
 308                 return -1;
 309 #endif
 310
 311         return ops->destroy_group(ifname);
 312 }
 313
 314 int wfd_oem_invite(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_invite_param_s *param)
 315 {
 316         if (!ops || !ops->invite)
 317 #if defined(BUILD_GTESTS)
 318                 return 0;
 319 #else
 320                 return -1;
 321 #endif
 322
 323         return ops->invite(peer_addr, param);
 324 }
 325
 326 int wfd_oem_wps_start(wfd_oem_ops_s *ops, unsigned char *peer_addr, int wps_mode, const char *pin)
 327 {
 328         if (!ops || !ops->wps_start)
 329 #if defined(BUILD_GTESTS)
 330                 return 0;
 331 #else
 332                 return -1;
 333 #endif
 334
 335         return ops->wps_start(peer_addr, wps_mode, pin);
 336 }
 337
 338 int wfd_oem_enrollee_start(wfd_oem_ops_s *ops, unsigned char *peer_addr, int wps_mode, const char *pin)
 339 {
 340         if (!ops || !ops->enrollee_start)
 341 #if defined(BUILD_GTESTS)
 342                 return 0;
 343 #else
 344                 return -1;
 345 #endif
 346
 347         return ops->enrollee_start(peer_addr, wps_mode, pin);
 348 }
 349
 350 int wfd_oem_wps_cancel(wfd_oem_ops_s *ops)
 351 {
 352         if (!ops || !ops->wps_cancel)
 353 #if defined(BUILD_GTESTS)
 354                 return 0;
 355 #else
 356                 return -1;
 357 #endif
 358
 359         return ops->wps_cancel();
 360 }
 361
 362 int wfd_oem_get_dev_name(wfd_oem_ops_s *ops, char *dev_name)
 363 {
 364         if (!ops || !ops->get_dev_name)
 365 #if defined(BUILD_GTESTS)
 366                 return 0;
 367 #else
 368                 return -1;
 369 #endif
 370
 371         return ops->get_dev_name(dev_name);
 372 }
 373
 374 int wfd_oem_set_dev_name(wfd_oem_ops_s *ops, char *dev_name)
 375 {
 376         if (!ops || !ops->set_dev_name)
 377 #if defined(BUILD_GTESTS)
 378                 return 0;
 379 #else
 380                 return -1;
 381 #endif
 382
 383         return ops->set_dev_name(dev_name);
 384 }
 385
 386 int wfd_oem_get_dev_mac(wfd_oem_ops_s *ops, char *dev_mac)
 387 {
 388         if (!ops || !ops->get_dev_mac)
 389 #if defined(BUILD_GTESTS)
 390                 return 0;
 391 #else
 392                 return -1;
 393 #endif
 394
 395         return ops->get_dev_mac(dev_mac);
 396 }
 397
 398 int wfd_oem_get_dev_type(wfd_oem_ops_s *ops, int *pri_dev_type, int *sec_dev_type)
 399 {
 400         if (!ops || !ops->get_dev_type)
 401 #if defined(BUILD_GTESTS)
 402                 return 0;
 403 #else
 404                 return -1;
 405 #endif
 406
 407         return ops->get_dev_type(pri_dev_type, sec_dev_type);
 408 }
 409
 410 int wfd_oem_set_dev_type(wfd_oem_ops_s *ops, int pri_dev_type, int sec_dev_type)
 411 {
 412         if (!ops || !ops->set_dev_type)
 413 #if defined(BUILD_GTESTS)
 414                 return 0;
 415 #else
 416                 return -1;
 417 #endif
 418
 419         return ops->set_dev_type(pri_dev_type, sec_dev_type);
 420 }
 421
 422 int wfd_oem_get_go_intent(wfd_oem_ops_s *ops, int *go_intent)
 423 {
 424         if (!ops || !ops->get_go_intent)
 425 #if defined(BUILD_GTESTS)
 426                 return 0;
 427 #else
 428                 return -1;
 429 #endif
 430
 431         return ops->get_go_intent(go_intent);
 432 }
 433
 434 int wfd_oem_set_go_intent(wfd_oem_ops_s *ops, int go_intent)
 435 {
 436         if (!ops || !ops->set_go_intent)
 437 #if defined(BUILD_GTESTS)
 438                 return 0;
 439 #else
 440                 return -1;
 441 #endif
 442
 443         return ops->set_go_intent(go_intent);
 444 }
 445
 446 int wfd_oem_set_country(wfd_oem_ops_s *ops, char *ccode)
 447 {
 448         if (!ops || !ops->set_country)
 449 #if defined(BUILD_GTESTS)
 450                 return 0;
 451 #else
 452                 return -1;
 453 #endif
 454
 455         return ops->set_country(ccode);
 456 }
 457
 458 int wfd_oem_get_persistent_groups(wfd_oem_ops_s *ops, wfd_oem_persistent_group_s **groups, int *group_count)
 459 {
 460         if (!ops || !ops->get_persistent_groups)
 461 #if defined(BUILD_GTESTS)
 462                 return 0;
 463 #else
 464                 return -1;
 465 #endif
 466
 467         return ops->get_persistent_groups(groups, group_count);
 468 }
 469
 470 int wfd_oem_remove_persistent_group(wfd_oem_ops_s *ops, char *ssid, unsigned char *bssid)
 471 {
 472         if (!ops || !ops->remove_persistent_group)
 473 #if defined(BUILD_GTESTS)
 474                 return 0;
 475 #else
 476                 return -1;
 477 #endif
 478
 479         return ops->remove_persistent_group(ssid, bssid);
 480
 481 }
 482
 483 int wfd_oem_set_persistent_reconnect(wfd_oem_ops_s *ops, unsigned char *bssid, int reconnect)
 484 {
 485         if (!ops || !ops->set_persistent_reconnect)
 486 #if defined(BUILD_GTESTS)
 487                 return 0;
 488 #else
 489                 return -1;
 490 #endif
 491
 492         return ops->set_persistent_reconnect(bssid, reconnect);
 493 }
 494
 495 int wfd_oem_start_service_discovery(wfd_oem_ops_s *ops, unsigned char *peer_addr, int service_type)
 496 {
 497         if (!ops || !ops->start_service_discovery)
 498 #if defined(BUILD_GTESTS)
 499                 return 0;
 500 #else
 501                 return -1;
 502 #endif
 503
 504         return ops->start_service_discovery(peer_addr, service_type);
 505 }
 506
 507 int wfd_oem_cancel_service_discovery(wfd_oem_ops_s *ops, unsigned char *peer_addr, int service_type)
 508 {
 509         if (!ops || !ops->cancel_service_discovery)
 510 #if defined(BUILD_GTESTS)
 511                 return 0;
 512 #else
 513                 return -1;
 514 #endif
 515
 516         return ops->cancel_service_discovery(peer_addr, service_type);
 517 }
 518
 519 int wfd_oem_serv_add(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
 520 {
 521         if (!ops || !ops->serv_add)
 522 #if defined(BUILD_GTESTS)
 523                 return 0;
 524 #else
 525                 return -1;
 526 #endif
 527
 528         return ops->serv_add(service);
 529 }
 530
 531 int wfd_oem_serv_del(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
 532 {
 533         if (!ops || !ops->serv_del)
 534 #if defined(BUILD_GTESTS)
 535                 return 0;
 536 #else
 537                 return -1;
 538 #endif
 539
 540         return ops->serv_del(service);
 541 }
 542
 543 int wfd_oem_serv_disc_start(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
 544 {
 545         if (!ops || !ops->serv_disc_start)
 546 #if defined(BUILD_GTESTS)
 547                 return 0;
 548 #else
 549                 return -1;
 550 #endif
 551
 552         return ops->serv_disc_start(service);
 553 }
 554
 555 int wfd_oem_serv_disc_stop(wfd_oem_ops_s *ops, int handle)
 556 {
 557         if (!ops || !ops->serv_disc_stop)
 558 #if defined(BUILD_GTESTS)
 559                 return 0;
 560 #else
 561                 return -1;
 562 #endif
 563
 564         return ops->serv_disc_stop(handle);
 565 }
 566
 567 int wfd_oem_miracast_init(wfd_oem_ops_s *ops, int enable)
 568 {
 569         if (!ops || !ops->miracast_init)
 570 #if defined(BUILD_GTESTS)
 571                 return 0;
 572 #else
 573                 return -1;
 574 #endif
 575
 576         return ops->miracast_init(enable);
 577 }
 578
 579 int wfd_oem_set_display(wfd_oem_ops_s *ops, wfd_oem_display_s *wifi_display)
 580 {
 581         if (!ops || !ops->set_display)
 582 #if defined(BUILD_GTESTS)
 583                 return 0;
 584 #else
 585                 return -1;
 586 #endif
 587
 588         return ops->set_display(wifi_display);
 589 }
 590
 591 int wfd_oem_refresh(wfd_oem_ops_s *ops)
 592 {
 593         if (!ops || !ops->refresh)
 594                 return -1;
 595
 596         return ops->refresh();
 597 }
 598
 599 int wfd_oem_advertise_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service, int replace)
 600 {
 601         if (!ops || !ops->advertise_service)
 602 #if defined(BUILD_GTESTS)
 603                 return 0;
 604 #else
 605                 return -1;
 606 #endif
 607
 608         return ops->advertise_service(service, replace);
 609 }
 610
 611 int wfd_oem_cancel_advertise_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
 612 {
 613         if (!ops || !ops->cancel_advertise_service)
 614 #if defined(BUILD_GTESTS)
 615                 return 0;
 616 #else
 617                 return -1;
 618 #endif
 619
 620         return ops->cancel_advertise_service(service);
 621 }
 622
 623 int wfd_oem_seek_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
 624 {
 625         if (!ops || !ops->seek_service)
 626 #if defined(BUILD_GTESTS)
 627                 return 0;
 628 #else
 629                 return -1;
 630 #endif
 631
 632         return ops->seek_service(service);
 633 }
 634
 635 int wfd_oem_cancel_seek_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
 636 {
 637         if (!ops || !ops->cancel_seek_service)
 638 #if defined(BUILD_GTESTS)
 639                 return 0;
 640 #else
 641                 return -1;
 642 #endif
 643
 644         return ops->cancel_seek_service(service);
 645 }
 646
 647 int wfd_oem_asp_prov_disc_req(wfd_oem_ops_s *ops, wfd_oem_asp_prov_s *params)
 648 {
 649         if (!ops || !ops->asp_prov_disc_req)
 650 #if defined(BUILD_GTESTS)
 651                 return 0;
 652 #else
 653                 return -1;
 654 #endif
 655
 656         return ops->asp_prov_disc_req(params);
 657 }
 658
 659 int wfd_oem_set_eapol_ip_config(wfd_oem_ops_s *ops, int enable)
 660 {
 661         if (!ops || !ops->set_eapol_ip_config)
 662 #if defined(BUILD_GTESTS)
 663                 return 0;
 664 #else
 665                 return -1;
 666 #endif
 667
 668         return ops->set_eapol_ip_config(enable);
 669 }
 670
 671 int wfd_oem_add_vsie(wfd_oem_ops_s *ops, wfd_oem_vsie_frames_e frame_id,
 672                      const char* vsie)
 673 {
 674         if (!ops || !ops->add_vsie)
 675 #if defined(BUILD_GTESTS)
 676                 return 0;
 677 #else
 678                 return -1;
 679 #endif
 680
 681         return ops->add_vsie(frame_id, vsie);
 682 }
 683
 684 int wfd_oem_get_vsie(wfd_oem_ops_s *ops, wfd_oem_vsie_frames_e frame_id,
 685                      char **vsie)
 686 {
 687         if (!ops || !ops->get_vsie)
 688 #if defined(BUILD_GTESTS)
 689                 return 0;
 690 #else
 691                 return -1;
 692 #endif
 693
 694         return ops->get_vsie(frame_id, vsie);
 695 }
 696
 697 int wfd_oem_remove_vsie(wfd_oem_ops_s *ops, wfd_oem_vsie_frames_e frame_id,
 698                         const char *vsie)
 699 {
 700         if (!ops || !ops->remove_vsie)
 701 #if defined(BUILD_GTESTS)
 702                 return 0;
 703 #else
 704                 return -1;
 705 #endif
 706
 707         return ops->remove_vsie(frame_id, vsie);
 708 }
 709
 710 #if defined TIZEN_ENABLE_PRD
 711 int wfd_oem_prd_init(wfd_oem_ops_s *ops)
 712 {
 713         wfd_oem_prd_ops_s *prd_ops;
 714
 715         if (!ops)
 716                 return -1;
 717
 718         prd_ops = ops->extra_data;
 719
 720         if (!prd_ops || !prd_ops->prd_init)
 721                 return -1;
 722
 723         g_event_cbs.extra_data = &g_prd_event_cbs;
 724         wfd_prd_event_init(&g_event_cbs);
 725
 726         return prd_ops->prd_init(&g_event_cbs);
 727 }
 728 #endif /* TIZEN_ENABLE_PRD */
 729
 730 int wfd_oem_set_supported_wps_mode(wfd_oem_ops_s *ops, int wps_mode)
 731 {
 732         if (!ops || !ops->set_supported_wps_mode) {
 733                 return -1;
 734         }
 735
 736         return ops->set_supported_wps_mode(wps_mode);
 737 }
 738
 739 int wfd_oem_remove_persistent_device(wfd_oem_ops_s *ops, unsigned char *peer_mac_address)
 740 {
 741         if (!ops || !ops->remove_persistent_device) {
 742                 return -1;
 743         }
 744
 745         return ops->remove_persistent_device(peer_mac_address);
 746 }
 747
 748 int wfd_oem_remove_all_persistent_device(wfd_oem_ops_s *ops)
 749 {
 750         if (!ops || !ops->remove_all_persistent_device) {
 751                 return -1;
 752         }
 753
 754         return ops->remove_all_persistent_device();
 755 }
 756
 757 int wfd_oem_get_supported_channels(wfd_oem_ops_s *ops, wfd_oem_supported_channels_s *data)
 758 {
 759         if (!ops || !ops->get_supported_channels)
 760                 return -1;
 761
 762         return ops->get_supported_channels(data);
 763 }