gtest/wifi.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
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22 #include <stdint.h>
  23 #include <glib.h>
  24
  25 #include "wifi.h"
  26
  27 Wifi::Wifi()
  28 {
  29         Create();
  30 }
  31
  32 Wifi::~Wifi()
  33 {
  34         Destroy();
  35 }
  36
  37 error_e Wifi::GetWifiState(char *state)
  38 {
  39         GVariant *message = NULL;
  40         error_e error = ERROR_NONE;
  41
  42         message = InvokeMethod(NETCONFIG_SERVICE,
  43                 NETCONFIG_WIFI_PATH,
  44                 NETCONFIG_WIFI_INTERFACE,
  45                 GET_WIFI_STATE,
  46                 NULL,
  47                 &error);
  48
  49         if (message == NULL) {
  50                 GLOGD("Failed to invoke dbus method");
  51                 return error;
  52         }
  53
  54         g_variant_get(message, "(s)", state);
  55         g_variant_unref(message);
  56
  57         return ERROR_NONE;
  58 }
  59
  60 error_e Wifi::IsIpConflictDetectEnabled(bool *state)
  61 {
  62         GVariant *message = NULL;
  63         error_e error = ERROR_NONE;
  64
  65         message = InvokeMethod(NETCONFIG_SERVICE,
  66                 NETCONFIG_WIFI_PATH,
  67                 NETCONFIG_WIFI_INTERFACE,
  68                 IS_IP_CONFLICT_DETECT_ENABLED,
  69                 NULL,
  70                 &error);
  71
  72         if (message == NULL) {
  73                 GLOGD("Failed to invoke dbus method");
  74                 return error;
  75         }
  76
  77         g_variant_get(message, "(b)", state);
  78         g_variant_unref(message);
  79
  80         return ERROR_NONE;
  81 }
  82
  83 error_e Wifi::SetBgscan(int scan_mode)
  84 {
  85         GVariant *message = NULL;
  86         error_e error = ERROR_NONE;
  87
  88         message = InvokeMethod(NETCONFIG_SERVICE,
  89                 NETCONFIG_WIFI_PATH,
  90                 NETCONFIG_WIFI_INTERFACE,
  91                 SET_BGSCAN,
  92                 g_variant_new("(u)", scan_mode),
  93                 &error);
  94
  95         if (message == NULL) {
  96                 GLOGD("Failed to invoke dbus method");
  97                 return error;
  98         }
  99
 100         g_variant_unref(message);
 101
 102         return ERROR_NONE;
 103 }
 104
 105 error_e Wifi::GetAutoscan(bool *state)
 106 {
 107         GVariant *message = NULL;
 108         error_e error = ERROR_NONE;
 109
 110         message = InvokeMethod(NETCONFIG_SERVICE,
 111                 NETCONFIG_WIFI_PATH,
 112                 NETCONFIG_WIFI_INTERFACE,
 113                 GET_AUTOSCAN,
 114                 NULL,
 115                 &error);
 116
 117         if (message == NULL) {
 118                 GLOGD("Failed to invoke dbus method");
 119                 return error;
 120         }
 121
 122         g_variant_get(message, "(b)", state);
 123         g_variant_unref(message);
 124
 125         return ERROR_NONE;
 126 }
 127
 128 error_e Wifi::GetIpConflictState(int *state)
 129 {
 130         GVariant *message = NULL;
 131         error_e error = ERROR_NONE;
 132
 133         message = InvokeMethod(NETCONFIG_SERVICE,
 134                 NETCONFIG_WIFI_PATH,
 135                 NETCONFIG_WIFI_INTERFACE,
 136                 GET_IP_CONFLICT_STATE,
 137                 NULL,
 138                 &error);
 139
 140         if (message == NULL) {
 141                 GLOGD("Failed to invoke dbus method");
 142                 return error;
 143         }
 144
 145         g_variant_get(message, "(u)", state);
 146         g_variant_unref(message);
 147
 148         return ERROR_NONE;
 149 }
 150
 151 error_e Wifi::GetIpConflictPeriod(int *period)
 152 {
 153         GVariant *message = NULL;
 154         error_e error = ERROR_NONE;
 155
 156         message = InvokeMethod(NETCONFIG_SERVICE,
 157                 NETCONFIG_WIFI_PATH,
 158                 NETCONFIG_WIFI_INTERFACE,
 159                 GET_IP_CONFLICT_PERIOD,
 160                 NULL,
 161                 &error);
 162
 163         if (message == NULL) {
 164                 GLOGD("Failed to invoke dbus method");
 165                 return error;
 166         }
 167
 168         g_variant_get(message, "(u)", period);
 169         g_variant_unref(message);
 170
 171         return ERROR_NONE;
 172 }
 173
 174 error_e Wifi::GetAutoscanmode(int *autoscanmode)
 175 {
 176         GVariant *message = NULL;
 177         error_e error = ERROR_NONE;
 178
 179         message = InvokeMethod(NETCONFIG_SERVICE,
 180                 NETCONFIG_WIFI_PATH,
 181                 NETCONFIG_WIFI_INTERFACE,
 182                 GET_AUTOSCANMODE,
 183                 NULL,
 184                 &error);
 185
 186         if (message == NULL) {
 187                 GLOGD("Failed to invoke dbus method");
 188                 return error;
 189         }
 190
 191         g_variant_get(message, "(u)", autoscanmode);
 192         g_variant_unref(message);
 193
 194         return ERROR_NONE;
 195 }
 196
 197 error_e Wifi::NetlinkScan(const char *ssid)
 198 {
 199         GVariant *message = NULL;
 200         error_e error = ERROR_NONE;
 201         GVariantBuilder *builder;
 202         GVariant *params = NULL;
 203
 204         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 205         if (ssid[0] != '\0') {
 206                 g_variant_builder_add(builder, "{sv}", "SSID", g_variant_new_string(ssid));
 207         } else {
 208                 return ERROR_INVALID_PARAMETER;
 209         }
 210
 211         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 212         g_variant_builder_unref(builder);
 213
 214         message = InvokeMethod(NETCONFIG_SERVICE,
 215                 NETCONFIG_WIFI_PATH,
 216                 NETCONFIG_WIFI_INTERFACE,
 217                 NETLINK_SCAN,
 218                 params,
 219                 &error);
 220
 221         if (message == NULL) {
 222                 GLOGD("Failed to invoke dbus method");
 223                 return error;
 224         }
 225
 226         g_variant_unref(message);
 227
 228         return ERROR_NONE;
 229 }
 230
 231 error_e Wifi::RequestWpsConnect(const char *param)
 232 {
 233         GVariant *message = NULL;
 234         error_e error = ERROR_NONE;
 235
 236         message = InvokeMethod(NETCONFIG_SERVICE,
 237                 NETCONFIG_WIFI_PATH,
 238                 NETCONFIG_WIFI_INTERFACE,
 239                 REQUEST_WPS_CONNECT,
 240                 g_variant_new("(s)", param),
 241                 &error);
 242
 243         if (message == NULL) {
 244                 GLOGD("Failed to invoke dbus method");
 245                 return error;
 246         }
 247
 248         g_variant_unref(message);
 249
 250         return ERROR_NONE;
 251 }
 252 error_e Wifi::GetPasspoint(int *enable)
 253 {
 254         GVariant *message = NULL;
 255         error_e error = ERROR_NONE;
 256
 257         message = InvokeMethod(NETCONFIG_SERVICE,
 258                 NETCONFIG_WIFI_PATH,
 259                 NETCONFIG_WIFI_INTERFACE,
 260                 GET_PASSPOINT,
 261                 NULL,
 262                 &error);
 263
 264         if (message == NULL) {
 265                 GLOGD("Failed to invoke dbus method");
 266                 return error;
 267         }
 268
 269         g_variant_get(message, "(i)", enable);
 270         g_variant_unref(message);
 271
 272         return ERROR_NONE;
 273 }
 274
 275 error_e Wifi::SetPasspoint(int enable)
 276 {
 277         GVariant *message = NULL;
 278         error_e error = ERROR_NONE;
 279
 280         message = InvokeMethod(NETCONFIG_SERVICE,
 281                 NETCONFIG_WIFI_PATH,
 282                 NETCONFIG_WIFI_INTERFACE,
 283                 SET_PASSPOINT,
 284                 g_variant_new("(i)", enable),
 285                 &error);
 286
 287         if (message == NULL) {
 288                 GLOGD("Failed to invoke dbus method");
 289                 return error;
 290         }
 291
 292         g_variant_unref(message);
 293
 294         return ERROR_NONE;
 295 }
 296
 297 error_e Wifi::GetConfigIds(void)
 298 {
 299         GVariant *message = NULL;
 300         error_e error = ERROR_NONE;
 301
 302         message = InvokeMethod(NETCONFIG_SERVICE,
 303                 NETCONFIG_WIFI_PATH,
 304                 NETCONFIG_WIFI_INTERFACE,
 305                 GET_CONFIGIDS,
 306                 NULL,
 307                 &error);
 308
 309         if (message == NULL) {
 310                 GLOGD("Failed to invoke dbus method");
 311                 return error;
 312         }
 313
 314         g_variant_unref(message);
 315
 316         return ERROR_NONE;
 317 }
 318
 319 error_e Wifi::SaveConfiguration(const char *config_id, const char *name,
 320                 const char *ssid, const char *passphrase)
 321 {
 322         GVariant *message = NULL;
 323         error_e error = ERROR_NONE;
 324
 325         GVariantBuilder *b = NULL;
 326         GVariant *params = NULL;
 327
 328         b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 329         g_variant_builder_add(b, "{sv}", "Name", g_variant_new_string(name));
 330         g_variant_builder_add(b, "{sv}", "SSID", g_variant_new_string(ssid));
 331         if (passphrase != NULL)
 332                 g_variant_builder_add(b, "{sv}", "Passphrase", g_variant_new_string(passphrase));
 333         params = g_variant_new("(s@a{sv})", config_id, g_variant_builder_end(b));
 334         g_variant_builder_unref(b);
 335
 336         message = InvokeMethod(NETCONFIG_SERVICE,
 337                 NETCONFIG_WIFI_PATH,
 338                 NETCONFIG_WIFI_INTERFACE,
 339                 SAVE_CONFIGURATION,
 340                 params,
 341                 &error);
 342
 343         if (message == NULL) {
 344                 GLOGD("Failed to invoke dbus method");
 345                 return error;
 346         }
 347
 348         g_variant_unref(message);
 349
 350         return ERROR_NONE;
 351 }
 352
 353 error_e Wifi::SaveEapConfiguration(const char *config_id, const char *name,
 354                 const char *ssid)
 355 {
 356         GVariant *message = NULL;
 357         error_e error = ERROR_NONE;
 358
 359         GVariantBuilder *b = NULL;
 360         GVariant *params = NULL;
 361
 362         b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 363         g_variant_builder_add(b, "{sv}", "Name", g_variant_new_string(name));
 364         g_variant_builder_add(b, "{sv}", "SSID", g_variant_new_string(ssid));
 365         params = g_variant_new("(s@a{sv})", config_id, g_variant_builder_end(b));
 366         g_variant_builder_unref(b);
 367
 368         message = InvokeMethod(NETCONFIG_SERVICE,
 369                 NETCONFIG_WIFI_PATH,
 370                 NETCONFIG_WIFI_INTERFACE,
 371                 SAVE_EAP_CONFIGURATION,
 372                 params,
 373                 &error);
 374
 375         if (message == NULL) {
 376                 GLOGD("Failed to invoke dbus method");
 377                 return error;
 378         }
 379
 380         g_variant_unref(message);
 381
 382         return ERROR_NONE;
 383 }
 384
 385 error_e Wifi::SetIpConflictPeriod(unsigned int time)
 386 {
 387         GVariant *message = NULL;
 388         error_e error = ERROR_NONE;
 389
 390         message = InvokeMethod(NETCONFIG_SERVICE,
 391                 NETCONFIG_WIFI_PATH,
 392                 NETCONFIG_WIFI_INTERFACE,
 393                 SET_IP_CONFLICT_PERIOD,
 394                 g_variant_new("(u)", time),
 395                 &error);
 396
 397         if (message == NULL) {
 398                 GLOGD("Failed to invoke dbus method");
 399                 return error;
 400         }
 401
 402         g_variant_unref(message);
 403
 404         return ERROR_NONE;
 405 }
 406
 407 error_e Wifi::RemoveConfiguration(const char *config_id)
 408 {
 409         GVariant *message = NULL;
 410         error_e error = ERROR_NONE;
 411
 412         message = InvokeMethod(NETCONFIG_SERVICE,
 413                 NETCONFIG_WIFI_PATH,
 414                 NETCONFIG_WIFI_INTERFACE,
 415                 REMOVE_CONFIGURATION,
 416                 g_variant_new("(s)", config_id),
 417                 &error);
 418
 419         if (message == NULL) {
 420                 GLOGD("Failed to invoke dbus method");
 421                 return error;
 422         }
 423
 424         g_variant_unref(message);
 425
 426         return ERROR_NONE;
 427 }
 428
 429 error_e Wifi::LoadConfiguration(const char *config_id)
 430 {
 431         GVariant *message = NULL;
 432         error_e error = ERROR_NONE;
 433
 434         message = InvokeMethod(NETCONFIG_SERVICE,
 435                 NETCONFIG_WIFI_PATH,
 436                 NETCONFIG_WIFI_INTERFACE,
 437                 LOAD_CONFIGURATION,
 438                 g_variant_new("(s)", config_id),
 439                 &error);
 440
 441         if (message == NULL) {
 442                 GLOGD("Failed to invoke dbus method");
 443                 return error;
 444         }
 445
 446         g_variant_unref(message);
 447
 448         return ERROR_NONE;
 449 }
 450
 451 error_e Wifi::LoadEapConfiguration(const char *config_id)
 452 {
 453         GVariant *message = NULL;
 454         error_e error = ERROR_NONE;
 455
 456         message = InvokeMethod(NETCONFIG_SERVICE,
 457                 NETCONFIG_WIFI_PATH,
 458                 NETCONFIG_WIFI_INTERFACE,
 459                 LOAD_EAP_CONFIGURATION,
 460                 g_variant_new("(s)", config_id),
 461                 &error);
 462
 463         if (message == NULL) {
 464                 GLOGD("Failed to invoke dbus method");
 465                 return error;
 466         }
 467
 468         g_variant_unref(message);
 469
 470         return ERROR_NONE;
 471 }
 472
 473 error_e Wifi::SetConfigField(const char *config_id, const char *key,
 474                 const char *value)
 475 {
 476         GVariant *message = NULL;
 477         error_e error = ERROR_NONE;
 478
 479         message = InvokeMethod(NETCONFIG_SERVICE,
 480                 NETCONFIG_WIFI_PATH,
 481                 NETCONFIG_WIFI_INTERFACE,
 482                 SET_CONFIG_FIELD,
 483                 g_variant_new("(sss)", config_id, key, value),
 484                 &error);
 485
 486         if (message == NULL) {
 487                 GLOGD("Failed to invoke dbus method");
 488                 return error;
 489         }
 490
 491         g_variant_unref(message);
 492
 493         return ERROR_NONE;
 494 }
 495
 496 error_e Wifi::GetConfigPassphrase(const char *config_id, char *password)
 497 {
 498         GVariant *message = NULL;
 499         error_e error = ERROR_NONE;
 500
 501         message = InvokeMethod(NETCONFIG_SERVICE,
 502                 NETCONFIG_WIFI_PATH,
 503                 NETCONFIG_WIFI_INTERFACE,
 504                 GET_CONFIG_PASSPHRASE,
 505                 g_variant_new("(s)", config_id),
 506                 &error);
 507
 508         if (message == NULL) {
 509                 GLOGD("Failed to invoke dbus method");
 510                 return error;
 511         }
 512
 513         g_variant_get(message, "(s)", password);
 514         g_variant_unref(message);
 515
 516         return ERROR_NONE;
 517 }
 518
 519 error_e Wifi::CreateEapConfig(const char *profile_name)
 520 {
 521         GVariant *message = NULL;
 522         error_e error = ERROR_NONE;
 523         GVariant *params = NULL;
 524         GVariantBuilder *builder;
 525
 526         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
 527         g_variant_builder_add(builder, "{ss}", "Type", "wifi");
 528         g_variant_builder_add(builder, "{ss}",
 529                         "Name", "gtest");
 530
 531         params = g_variant_new("(o@a{ss})", (gchar *)profile_name,
 532                         g_variant_builder_end(builder));
 533
 534         g_variant_builder_unref(builder);
 535
 536         message = InvokeMethod(NETCONFIG_SERVICE,
 537                 NETCONFIG_WIFI_PATH,
 538                 NETCONFIG_WIFI_INTERFACE,
 539                 CREATE_EAP_CONFIG,
 540                 params,
 541                 &error);
 542
 543         if (message == NULL) {
 544                 GLOGD("Failed to invoke dbus method");
 545                 return error;
 546         }
 547
 548         g_variant_unref(message);
 549
 550         return ERROR_NONE;
 551 }
 552
 553 error_e Wifi::DeleteEapConfig(const char *profile_name)
 554 {
 555         GVariant *message = NULL;
 556         error_e error = ERROR_NONE;
 557
 558         message = InvokeMethod(NETCONFIG_SERVICE,
 559                 NETCONFIG_WIFI_PATH,
 560                 NETCONFIG_WIFI_INTERFACE,
 561                 DELETE_EAP_CONFIG,
 562                 g_variant_new("(s)", profile_name),
 563                 &error);
 564
 565         if (message == NULL) {
 566                 GLOGD("Failed to invoke dbus method");
 567                 return error;
 568         }
 569
 570         g_variant_unref(message);
 571
 572         return ERROR_NONE;
 573 }
 574
 575 error_e Wifi::IpConflictSetEnable(bool detect)
 576 {
 577         GVariant *message = NULL;
 578         error_e error = ERROR_NONE;
 579
 580         message = InvokeMethod(NETCONFIG_SERVICE,
 581                 NETCONFIG_WIFI_PATH,
 582                 NETCONFIG_WIFI_INTERFACE,
 583                 IP_CONFLICT_SET_ENABLE,
 584                 g_variant_new("(b)", detect),
 585                 &error);
 586
 587         if (message == NULL) {
 588                 GLOGD("Failed to invoke dbus method");
 589                 return error;
 590         }
 591
 592         g_variant_unref(message);
 593
 594         return ERROR_NONE;
 595 }
 596
 597 error_e Wifi::GetSimImsi(char *imsi)
 598 {
 599         GVariant *message = NULL;
 600         error_e error = ERROR_NONE;
 601
 602         message = InvokeMethod(NETCONFIG_SERVICE,
 603                 NETCONFIG_WIFI_PATH,
 604                 NETCONFIG_WIFI_INTERFACE,
 605                 GET_SIM_IMSI,
 606                 NULL,
 607                 &error);
 608
 609         if (message == NULL) {
 610                 GLOGD("Failed to invoke dbus method");
 611                 return error;
 612         }
 613
 614         g_variant_get(message, "(s)", imsi);
 615         g_variant_unref(message);
 616
 617         return ERROR_NONE;
 618 }
 619
 620 error_e Wifi::ReqSimAuth(const unsigned char *rand_data, unsigned int length,
 621         bool *result)
 622 {
 623         GVariant *message = NULL;
 624         error_e error = ERROR_NONE;
 625         GVariantBuilder *b;
 626         GVariant *v;
 627         b = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 628         for(unsigned int i = 0;i < length;i++)
 629                 g_variant_builder_add(b, "y", rand_data[i]);
 630
 631         v = g_variant_new("(ay)", b);
 632         g_variant_builder_unref(b);
 633
 634         message = InvokeMethod(NETCONFIG_SERVICE,
 635                 NETCONFIG_WIFI_PATH,
 636                 NETCONFIG_WIFI_INTERFACE,
 637                 REQ_SIM_AUTH,
 638                 v,
 639                 &error);
 640
 641         if (message == NULL) {
 642                 GLOGD("Failed to invoke dbus method");
 643                 return error;
 644         }
 645
 646         g_variant_get(message, "(b)", result);
 647         g_variant_unref(message);
 648
 649         return ERROR_NONE;
 650 }
 651
 652 error_e Wifi::ReqAkaAuth(const unsigned char *rand_data, int rand_length,
 653         const unsigned char *autn_data, int auth_length, bool *result)
 654 {
 655         GVariant *message = NULL;
 656         error_e error = ERROR_NONE;
 657         GVariantBuilder *b1, *b2;
 658         GVariant *v;
 659         b1 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 660         for(int i = 0;i < rand_length;i++)
 661                 g_variant_builder_add(b1, "y", rand_data[i]);
 662
 663         b2 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 664         for(int i = 0;i < auth_length;i++)
 665                 g_variant_builder_add(b2, "y", autn_data[i]);
 666
 667         v = g_variant_new("(@ay@ay)", g_variant_builder_end(b1), g_variant_builder_end(b2));
 668
 669         g_variant_builder_unref(b1);
 670         g_variant_builder_unref(b2);
 671
 672         message = InvokeMethod(NETCONFIG_SERVICE,
 673                 NETCONFIG_WIFI_PATH,
 674                 NETCONFIG_WIFI_INTERFACE,
 675                 REQ_AKA_AUTH,
 676                 v,
 677                 &error);
 678
 679         if (message == NULL) {
 680                 GLOGD("Failed to invoke dbus method");
 681                 return error;
 682         }
 683
 684         g_variant_get(message, "(b)", result);
 685         g_variant_unref(message);
 686
 687         return ERROR_NONE;
 688 }
 689
 690 error_e Wifi::GetSimAuth(const unsigned char *auth_data, unsigned int length)
 691 {
 692         GVariant *message = NULL;
 693         error_e error = ERROR_NONE;
 694         GVariantBuilder *b;
 695         GVariant *v;
 696         b = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 697         for(unsigned int i = 0;i < length;i++)
 698                 g_variant_builder_add(b, "y", auth_data[i]);
 699
 700         v = g_variant_new("(ay)", b);
 701         g_variant_builder_unref(b);
 702
 703         message = InvokeMethod(NETCONFIG_SERVICE,
 704                 NETCONFIG_WIFI_PATH,
 705                 NETCONFIG_WIFI_INTERFACE,
 706                 GET_SIM_AUTH,
 707                 v,
 708                 &error);
 709
 710         if (message == NULL) {
 711                 GLOGD("Failed to invoke dbus method");
 712                 return error;
 713         }
 714
 715         g_variant_unref(message);
 716
 717         return ERROR_NONE;
 718 }
 719
 720 error_e Wifi::CheckBlackList(const char *name, const char *sec_type,
 721                 const char *eap, bool *allowed)
 722 {
 723         GVariant *message = NULL;
 724         error_e error = ERROR_NONE;
 725
 726         message = InvokeMethod(NETCONFIG_SERVICE,
 727                 NETCONFIG_WIFI_PATH,
 728                 NETCONFIG_WIFI_INTERFACE,
 729                 CHECK_BLACKLIST,
 730                 g_variant_new("(sss)", name, sec_type, eap),
 731                 &error);
 732
 733         if (message == NULL) {
 734                 GLOGD("Failed to invoke dbus method");
 735                 return error;
 736         }
 737
 738         g_variant_get(message, "(b)", allowed);
 739         g_variant_unref(message);
 740
 741         return ERROR_NONE;
 742 }
 743
 744 error_e Wifi::TdlsDisconnect(const char *peer_mac_address, int *result)
 745 {
 746         GVariant *message = NULL;
 747         error_e error = ERROR_NONE;
 748
 749         message = InvokeMethod(NETCONFIG_SERVICE,
 750                 NETCONFIG_WIFI_PATH,
 751                 NETCONFIG_WIFI_INTERFACE,
 752                 TDLS_DISCONNECT,
 753                 g_variant_new("(s)", peer_mac_address),
 754                 &error);
 755
 756         if (message == NULL) {
 757                 GLOGD("Failed to invoke dbus method");
 758                 return error;
 759         }
 760
 761         g_variant_get(message, "(i)", result);
 762         g_variant_unref(message);
 763
 764         return ERROR_NONE;
 765 }
 766
 767 error_e Wifi::TdlsConnectedPeer(char *peer_mac_address)
 768 {
 769         GVariant *message = NULL;
 770         error_e error = ERROR_NONE;
 771
 772         message = InvokeMethod(NETCONFIG_SERVICE,
 773                 NETCONFIG_WIFI_PATH,
 774                 NETCONFIG_WIFI_INTERFACE,
 775                 TDLS_CONNECTED_PEER,
 776                 NULL,
 777                 &error);
 778
 779         if (message == NULL) {
 780                 GLOGD("Failed to invoke dbus method");
 781                 return error;
 782         }
 783
 784         g_variant_get(message, "(s)", peer_mac_address);
 785         g_variant_unref(message);
 786
 787         return ERROR_NONE;
 788 }
 789
 790 error_e Wifi::TdlsConnect(const char *peer_mac_address, int *result)
 791 {
 792         GVariant *message = NULL;
 793         error_e error = ERROR_NONE;
 794
 795         message = InvokeMethod(NETCONFIG_SERVICE,
 796                 NETCONFIG_WIFI_PATH,
 797                 NETCONFIG_WIFI_INTERFACE,
 798                 TDLS_CONNECT,
 799                 g_variant_new("(s)", peer_mac_address),
 800                 &error);
 801
 802         if (message == NULL) {
 803                 GLOGD("Failed to invoke dbus method");
 804                 return error;
 805         }
 806
 807         g_variant_get(message, "(i)", result);
 808         g_variant_unref(message);
 809
 810         return ERROR_NONE;
 811 }
 812
 813 error_e Wifi::TdlsDiscover(const char *peer_mac_address, int *result)
 814 {
 815         GVariant *message = NULL;
 816         error_e error = ERROR_NONE;
 817
 818         message = InvokeMethod(NETCONFIG_SERVICE,
 819                 NETCONFIG_WIFI_PATH,
 820                 NETCONFIG_WIFI_INTERFACE,
 821                 TDLS_DISCOVER,
 822                 g_variant_new("(s)", peer_mac_address),
 823                 &error);
 824
 825         if (message == NULL) {
 826                 GLOGD("Failed to invoke dbus method");
 827                 return error;
 828         }
 829
 830         g_variant_get(message, "(i)", result);
 831         g_variant_unref(message);
 832
 833         return ERROR_NONE;
 834 }
 835
 836 error_e Wifi::TdlsChannelSwitch(const char *peer_mac_address, int freq, int *result)
 837 {
 838         GVariant *message = NULL;
 839         error_e error = ERROR_NONE;
 840
 841         message = InvokeMethod(NETCONFIG_SERVICE,
 842                 NETCONFIG_WIFI_PATH,
 843                 NETCONFIG_WIFI_INTERFACE,
 844                 TDLS_CHANNEL_SWITCH,
 845                 g_variant_new("(si)", peer_mac_address, freq),
 846                 &error);
 847
 848         if (message == NULL) {
 849                 GLOGD("Failed to invoke dbus method");
 850                 return error;
 851         }
 852
 853         g_variant_get(message, "(i)", result);
 854         g_variant_unref(message);
 855
 856         return ERROR_NONE;
 857 }
 858
 859 error_e Wifi::TdlsCancelChannelSwitch(const char *peer_mac_address, int *result)
 860 {
 861         GVariant *message = NULL;
 862         error_e error = ERROR_NONE;
 863
 864         message = InvokeMethod(NETCONFIG_SERVICE,
 865                 NETCONFIG_WIFI_PATH,
 866                 NETCONFIG_WIFI_INTERFACE,
 867                 TDLS_CANCEL_CHANNEL_SWITCH,
 868                 g_variant_new("(s)", peer_mac_address),
 869                 &error);
 870
 871         if (message == NULL) {
 872                 GLOGD("Failed to invoke dbus method");
 873                 return error;
 874         }
 875
 876         g_variant_get(message, "(i)", result);
 877         g_variant_unref(message);
 878
 879         return ERROR_NONE;
 880 }
 881
 882 error_e Wifi::AddVsie(int frame_id, const char *vsie)
 883 {
 884         GVariant *message = NULL;
 885         error_e error = ERROR_NONE;
 886
 887         message = InvokeMethod(NETCONFIG_SERVICE,
 888                 NETCONFIG_WIFI_PATH,
 889                 NETCONFIG_WIFI_INTERFACE,
 890                 ADD_VSIE,
 891                 g_variant_new("(is)", frame_id, vsie),
 892                 &error);
 893
 894         if (message == NULL) {
 895                 GLOGD("Failed to invoke dbus method");
 896                 return error;
 897         }
 898
 899         g_variant_unref(message);
 900
 901         return ERROR_NONE;
 902 }
 903
 904 error_e Wifi::GetVsie(int frame_id, char *vsie)
 905 {
 906         GVariant *message = NULL;
 907         error_e error = ERROR_NONE;
 908
 909         message = InvokeMethod(NETCONFIG_SERVICE,
 910                 NETCONFIG_WIFI_PATH,
 911                 NETCONFIG_WIFI_INTERFACE,
 912                 GET_VSIE,
 913                 g_variant_new("(i)", frame_id),
 914                 &error);
 915
 916         if (message == NULL) {
 917                 GLOGD("Failed to invoke dbus method");
 918                 return error;
 919         }
 920
 921         g_variant_get(message, "(s)", vsie);
 922         g_variant_unref(message);
 923
 924         return ERROR_NONE;
 925 }
 926
 927 error_e Wifi::RemoveVsie(int frame_id, const char *vsie)
 928 {
 929         GVariant *message = NULL;
 930         error_e error = ERROR_NONE;
 931
 932         message = InvokeMethod(NETCONFIG_SERVICE,
 933                 NETCONFIG_WIFI_PATH,
 934                 NETCONFIG_WIFI_INTERFACE,
 935                 REMOVE_VSIE,
 936                 g_variant_new("(is)", frame_id, vsie),
 937                 &error);
 938
 939         if (message == NULL) {
 940                 GLOGD("Failed to invoke dbus method");
 941                 return error;
 942         }
 943
 944         g_variant_unref(message);
 945
 946         return ERROR_NONE;
 947 }
 948
 949 error_e Wifi::EncryptPassphrase(char **enc_data, const char *passphrase)
 950 {
 951         GVariant *message = NULL;
 952         error_e error = ERROR_NONE;
 953
 954         message = InvokeMethod(NETCONFIG_SERVICE,
 955                 NETCONFIG_WIFI_PATH,
 956                 NETCONFIG_WIFI_INTERFACE,
 957                 ENCRYPT_PASSPHRASE,
 958                 g_variant_new("(s)", passphrase),
 959                 &error);
 960
 961         if (message == NULL) {
 962                 GLOGD("Failed to invoke dbus method");
 963                 return error;
 964         }
 965
 966         g_variant_get(message, "(s)", enc_data);
 967         g_variant_unref(message);
 968
 969         return ERROR_NONE;
 970 }
 971
 972 error_e Wifi::DecryptPassphrase(const char *enc_data, char **passphrase)
 973 {
 974         GVariant *message = NULL;
 975         error_e error = ERROR_NONE;
 976
 977         message = InvokeMethod(NETCONFIG_SERVICE,
 978                 NETCONFIG_WIFI_PATH,
 979                 NETCONFIG_WIFI_INTERFACE,
 980                 DECRYPT_PASSPHRASE,
 981                 g_variant_new("(s)", enc_data),
 982                 &error);
 983
 984         if (message == NULL) {
 985                 GLOGD("Failed to invoke dbus method");
 986                 return error;
 987         }
 988
 989         g_variant_get(message, "(s)", passphrase);
 990         g_variant_unref(message);
 991
 992         return ERROR_NONE;
 993 }
 994
 995
 996 error_e Wifi::Stop(const char *device)
 997 {
 998         GVariant *message = NULL;
 999         error_e error = ERROR_NONE;
1000
1001         message = InvokeMethod(NETCONFIG_SERVICE,
1002                 NETCONFIG_WIFI_PATH,
1003                 NETCONFIG_WIFI_FIRMWARE_INTERFACE,
1004                 WIFI_FIRMWARE_STOP,
1005                 g_variant_new("(s)", device),
1006                 &error);
1007
1008         if (message == NULL) {
1009                 GLOGD("Failed to invoke dbus method");
1010                 return error;
1011         }
1012
1013         g_variant_unref(message);
1014
1015         return ERROR_NONE;
1016 }
1017
1018 error_e Wifi::Start(const char *device)
1019 {
1020         GVariant *message = NULL;
1021         error_e error = ERROR_NONE;
1022
1023         message = InvokeMethod(NETCONFIG_SERVICE,
1024                 NETCONFIG_WIFI_PATH,
1025                 NETCONFIG_WIFI_FIRMWARE_INTERFACE,
1026                 WIFI_FIRMWARE_START,
1027                 g_variant_new("(s)", device),
1028                 &error);
1029
1030         if (message == NULL) {
1031                 GLOGD("Failed to invoke dbus method");
1032                 return error;
1033         }
1034
1035         g_variant_unref(message);
1036
1037         return ERROR_NONE;
1038 }
1039
1040 error_e Wifi::LoadDriver(bool device_picker_test)
1041 {
1042         GVariant *message = NULL;
1043         error_e error = ERROR_NONE;
1044
1045         message = InvokeMethod(NETCONFIG_SERVICE,
1046                 NETCONFIG_WIFI_PATH,
1047                 NETCONFIG_WIFI_INTERFACE,
1048                 LOAD_DRIVER,
1049                 g_variant_new("(b)", device_picker_test),
1050                 &error);
1051
1052         if (message == NULL) {
1053                 GLOGD("Failed to invoke dbus method");
1054                 return error;
1055         }
1056
1057         g_variant_unref(message);
1058
1059         return ERROR_NONE;
1060 }
1061
1062 error_e Wifi::RemoveDriver()
1063 {
1064         GVariant *message = NULL;
1065         error_e error = ERROR_NONE;
1066
1067         message = InvokeMethod(NETCONFIG_SERVICE,
1068                 NETCONFIG_WIFI_PATH,
1069                 NETCONFIG_WIFI_INTERFACE,
1070                 REMOVE_DRIVER,
1071                 NULL,
1072                 &error);
1073
1074         if (message == NULL) {
1075                 GLOGD("Failed to invoke dbus method");
1076                 return error;
1077         }
1078
1079         g_variant_unref(message);
1080
1081         return ERROR_NONE;
1082 }