src/wifi-dpp.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2019 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 #include <string.h>
  20 #include <glib.h>
  21
  22 #include <vconf.h>
  23 #include <vconf-keys.h>
  24
  25 #include "log.h"
  26 #include "util.h"
  27 #include "netdbus.h"
  28 #include "netsupplicant.h"
  29 #include "neterror.h"
  30 #include "wifi-config.h"
  31 #include "wifi-dpp.h"
  32 #include "wifi-key-encryption.h"
  33
  34 #define DEFAULT_BOOTSTRAP_TYPE "qrcode"
  35 #define DEFAULT_DPP_CHANNEL "81/6"
  36 #define DEFAULT_DPP_FREQ 2437
  37
  38 #define DEFAULT_DPP_CONFIG_PROCESSING_TYPE "0"
  39
  40 #define MACADDR_LEN 6
  41 #define MACSTR_LEN 18
  42 #define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
  43 #define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
  44
  45 typedef enum {
  46         WIFI_DPP_AKM_UNKNOWN,
  47         WIFI_DPP_AKM_PSK,
  48         WIFI_DPP_AKM_SAE,
  49         WIFI_DPP_AKM_DPP,
  50 } wifi_dpp_akm_e;
  51
  52 typedef enum {
  53         WIFI_DPP_STATE_NONE,
  54         WIFI_DPP_STATE_AWAITING,
  55         WIFI_DPP_STATE_PEER_QR_REQUESTED,
  56         WIFI_DPP_STATE_BOOTSTRAPPED,
  57         WIFI_DPP_STATE_AUTHENTICATING,
  58         WIFI_DPP_STATE_AUTHENTICATED,
  59         WIFI_DPP_STATE_CONFIGURED,
  60         WIFI_DPP_STATE_CONNECTING,
  61         WIFI_DPP_STATE_CONNECTED,
  62 } wifi_dpp_state_e;
  63
  64 typedef struct {
  65         gchar *ssid;
  66         gchar *akm;
  67         gchar *passphrase;
  68         gchar *connector;
  69         gchar *c_sign_key;
  70         gchar *net_access_key;
  71 } wifi_dpp_conf_obj;
  72
  73 typedef struct {
  74         guint32 peer_id;
  75         guint32 own_id;
  76         guint32 configurator_id;
  77         gboolean is_initiator;
  78         wifi_dpp_state_e state;
  79 } wifi_dpp_s;
  80
  81 gboolean g_in_progress = FALSE;
  82 static GSList *dpp_info_list = NULL;
  83
  84 static wifi_dpp_s *_get_dpp_info(guint32 peer_id, guint32 own_id)
  85 {
  86         wifi_dpp_s *ret = NULL;
  87         GSList *list = NULL;
  88
  89         for (list = dpp_info_list; list; list = list->next) {
  90                 ret = list->data;
  91                 if (ret->own_id == own_id && ret->peer_id == peer_id)
  92                         break;
  93                 ret = NULL;
  94         }
  95         return ret;
  96 }
  97
  98 static wifi_dpp_s *_get_dpp_in_progress()
  99 {
 100         wifi_dpp_s *ret = NULL;
 101         GSList *list = NULL;
 102
 103         for (list = dpp_info_list; list; list = list->next) {
 104                 ret = list->data;
 105                 if (ret->state > WIFI_DPP_STATE_NONE)
 106                         break;
 107                 ret = NULL;
 108         }
 109         return ret;
 110 }
 111
 112 static wifi_dpp_s *__create_dpp_info(gboolean is_initiator)
 113 {
 114         wifi_dpp_s *ret = g_try_malloc0(sizeof(wifi_dpp_s));
 115         if (ret)
 116                 ret->is_initiator = is_initiator;
 117
 118         return ret;
 119 }
 120
 121 static void __add_to_dpp_info_list(wifi_dpp_s * p_dpp)
 122 {
 123         dpp_info_list = g_slist_prepend(dpp_info_list, p_dpp);
 124 }
 125
 126 static void __remove_from_dpp_info_list(wifi_dpp_s * p_dpp)
 127 {
 128         dpp_info_list = g_slist_remove(dpp_info_list, p_dpp);
 129 }
 130
 131 static void __destroy_dpp_info(wifi_dpp_s *p_dpp)
 132 {
 133         g_free(p_dpp);
 134 }
 135
 136
 137 static void __free_critical(char *critical)
 138 {
 139         size_t length = 0;
 140         if (!critical)
 141                 return;
 142
 143         length = strlen(critical);
 144         memset((void *)critical, 0x0, length);
 145         g_free(critical);
 146 }
 147
 148 static void __netconfig_wifi_notify_dpp_uri_generated(guint32 own_id, const gchar *own_uri)
 149 {
 150         GVariantBuilder *builder = NULL;
 151
 152         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 153         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
 154         g_variant_builder_add(builder, "{sv}", "own_uri", g_variant_new_string(own_uri));
 155
 156         wifi_emit_dpp_uri_generated((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
 157         g_variant_builder_unref(builder);
 158
 159         return;
 160 }
 161
 162 static void __netconfig_wifi_notify_dpp_bootstrapped(guint32 peer_id)
 163 {
 164         GVariantBuilder *builder = NULL;
 165
 166         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 167         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
 168
 169         wifi_emit_dpp_bootstrapped((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
 170         g_variant_builder_unref(builder);
 171
 172         return;
 173 }
 174
 175 static void __netconfig_wifi_notify_dpp_awaiting(guint32 own_id)
 176 {
 177         GVariantBuilder *builder = NULL;
 178
 179         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 180         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
 181
 182         wifi_emit_dpp_awaiting((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
 183         g_variant_builder_unref(builder);
 184
 185         return;
 186 }
 187
 188 static void __netconfig_wifi_notify_dpp_authenticating(guint32 peer_id, guint32 own_id)
 189 {
 190         GVariantBuilder *builder = NULL;
 191
 192         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 193         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
 194         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
 195
 196         wifi_emit_dpp_authenticating((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
 197         g_variant_builder_unref(builder);
 198
 199         return;
 200 }
 201
 202 static void __netconfig_wifi_notify_dpp_failed()
 203 {
 204         wifi_emit_dpp_failed((Wifi *)get_wifi_object());
 205
 206         return;
 207 }
 208
 209 static void __netconfig_wifi_notify_dpp_removed(guint32 peer_id, guint32 own_id)
 210 {
 211         GVariantBuilder *builder = NULL;
 212
 213         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 214         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
 215         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
 216
 217         wifi_emit_dpp_removed((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
 218         g_variant_builder_unref(builder);
 219
 220         return;
 221 }
 222
 223 static char *__netconfig_dpp_get_supplicant_interface()
 224 {
 225         char *if_path = NULL;
 226
 227         if_path = netconfig_wifi_get_supplicant_p2p_interface();
 228         if (if_path)
 229                 return if_path;
 230
 231         if_path = netconfig_wifi_get_supplicant_interface();
 232
 233         return if_path;
 234 }
 235
 236 static gboolean __netconfig_wifi_invoke_dpp_set_dpp_config_processing()
 237 {
 238         char *if_path = NULL;
 239         GVariant *message = NULL;
 240         GVariant *params = NULL;
 241
 242         DBG("[TizenMW-->WPAS]: DPP Set config processing Request: ");
 243
 244         if_path = __netconfig_dpp_get_supplicant_interface();
 245         if (if_path == NULL) {
 246                 ERR("Fail to get wpa_supplicant DBus interface path");
 247                 return FALSE;
 248         }
 249
 250         params = g_variant_new("(ssv)", SUPPLICANT_INTERFACE ".Interface",
 251                         "DppConfigProcessing", g_variant_new_string(DEFAULT_DPP_CONFIG_PROCESSING_TYPE));
 252
 253         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 254                         if_path, DBUS_INTERFACE_PROPERTIES, "Set", params);
 255         g_free(if_path);
 256         if (message == NULL) {
 257                 ERR(" DPP : Failed to set DPP config processing !!!");
 258                 return FALSE;
 259         }
 260
 261         g_variant_unref(message);
 262         return TRUE;
 263 }
 264
 265 static gboolean __netconfig_wifi_invoke_dpp_qr_code(const char *peer_uri, guint32 *peer_id)
 266 {
 267         char *if_path = NULL;
 268         GVariant *message = NULL;
 269         GVariant *params = NULL;
 270
 271         DBG("[TizenMW-->WPAS]: DPP QrCode Request: ");
 272
 273         if_path = __netconfig_dpp_get_supplicant_interface();
 274         if (if_path == NULL) {
 275                 ERR("Fail to get wpa_supplicant DBus interface path");
 276                 return FALSE;
 277         }
 278
 279         params = g_variant_new("(s)", peer_uri);
 280         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 281                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "QrCode", params);
 282         g_free(if_path);
 283         if (message == NULL) {
 284                 ERR(" DPP : Failed to set peer URI !!!");
 285                 return FALSE;
 286         }
 287
 288         g_variant_get(message, "(u)", peer_id);
 289         INFO("DPP reply: [%u]", *peer_id);
 290
 291         g_variant_unref(message);
 292         return TRUE;
 293 }
 294 #define DEBUG_G_VARIANT(str, parameters)\
 295         do {\
 296                 gchar *parameters_debug_str = NULL;\
 297                 if (parameters)\
 298                         parameters_debug_str = g_variant_print(parameters, TRUE);\
 299                         DBG("%s[%s]", str, parameters_debug_str ? parameters_debug_str : "NULL");\
 300                 g_free(parameters_debug_str);\
 301         } while (0)
 302
 303
 304 static int __ws_unpack_ay(unsigned char *dst, GVariant *src, int size)
 305 {
 306         GVariantIter *iter = NULL;
 307         int length = 0;
 308
 309         if (!dst || !src || size == 0) {
 310                 DBG("Invalid parameter");
 311                 return -1;
 312         }
 313         g_variant_get(src, "ay", &iter);
 314         if (iter == NULL) {
 315                 DBG("failed to get iterator");
 316                 return -1;
 317         }
 318
 319         while (g_variant_iter_loop(iter, "y", &dst[length])) {
 320                 length++;
 321                 if (length >= size)
 322                         break;
 323         }
 324         g_variant_iter_free(iter);
 325
 326         return length;
 327 }
 328
 329 static gchar *__netconfig_get_p2p_address(const char *if_path)
 330 {
 331         GVariant *params = NULL;
 332         GVariant *message = NULL;
 333         GVariant *temp1 = NULL;
 334         GVariant *temp2 = NULL;
 335         guchar p2p_addr[MACADDR_LEN] = {0,};
 336         gchar address_str[MACSTR_LEN] = {0,};
 337
 338         params = g_variant_new("(ss)", SUPPLICANT_INTERFACE ".Interface", "P2PAddress");
 339
 340         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 341                         if_path,
 342                         DBUS_INTERFACE_PROPERTIES,
 343                         "Get",
 344                         params);
 345
 346         if (message == NULL) {
 347                 ERR("netconfig_supplicant_invoke_dbus_method() failed.");
 348                 return NULL;
 349         }
 350         DEBUG_G_VARIANT("reply:", message);
 351
 352         temp1 = g_variant_get_child_value(message, 0);
 353         temp2 = g_variant_get_child_value(temp1, 0);
 354         DEBUG_G_VARIANT("temp2:", temp2);
 355         __ws_unpack_ay(p2p_addr, temp2, MACADDR_LEN);
 356         g_variant_unref(temp1);
 357         g_variant_unref(temp2);
 358
 359         g_snprintf(address_str, MACSTR_LEN, MACSTR, MAC2STR(p2p_addr));
 360
 361         DBG("P2P address %s", address_str);
 362
 363         return g_strdup(address_str);
 364 }
 365
 366 static gboolean __netconfig_wifi_invoke_dpp_add_bootstrap(const char *key, guint32 *id)
 367 {
 368         char *if_path = NULL;
 369         GVariantBuilder *builder = NULL;
 370         GVariant *params = NULL;
 371         GVariant *message = NULL;
 372         gchar *current_mac_addr = NULL;
 373
 374         DBG("[TizenMW-->WPAS]: DPP AddBootstrap Request: ");
 375
 376         if_path = __netconfig_dpp_get_supplicant_interface();
 377         if (if_path == NULL) {
 378                 ERR("Fail to get wpa_supplicant DBus interface path");
 379                 return FALSE;
 380         }
 381         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 382         g_variant_builder_add(builder, "{sv}", "type", g_variant_new_string("qrcode"));
 383         g_variant_builder_add(builder, "{sv}", "channels", g_variant_new_string(DEFAULT_DPP_CHANNEL));
 384         /* TODO: find more comfortable way */
 385         current_mac_addr = __netconfig_get_p2p_address(if_path);
 386         if (current_mac_addr)
 387                 g_variant_builder_add(builder, "{sv}", "mac", g_variant_new_string(current_mac_addr));
 388         if (key)
 389                 g_variant_builder_add(builder, "{sv}", "key", g_variant_new_string(key));
 390         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 391         g_variant_builder_unref(builder);
 392
 393         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 394                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "AddBootstrap", params);
 395         g_free(if_path);
 396         g_free(current_mac_addr);
 397         if (message == NULL) {
 398                 ERR(" DPP : Failed to add bootstrap !!!");
 399                 return FALSE;
 400         }
 401
 402         g_variant_get(message, "(u)", id);
 403         INFO("DPP reply: [%u]", *id);
 404
 405         g_variant_unref(message);
 406         return TRUE;
 407 }
 408
 409 static gboolean __netconfig_wifi_invoke_dpp_get_bootstrap_uri(guint32 id, gchar **uri)
 410 {
 411         char *if_path = NULL;
 412         GVariant *message = NULL;
 413         GVariant *params = NULL;
 414
 415         if (id == 0) {
 416                 DBG("Invalid ID");
 417                 return FALSE;
 418         }
 419
 420         DBG("[TizenMW-->WPAS]: DPP GetBootstrapUri Request: ");
 421
 422         if_path = __netconfig_dpp_get_supplicant_interface();
 423         if (if_path == NULL) {
 424                 ERR("Fail to get wpa_supplicant DBus interface path");
 425                 return FALSE;
 426         }
 427
 428         params = g_variant_new("(u)", id);
 429         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 430                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "GetBootstrapUri", params);
 431         g_free(if_path);
 432         if (message == NULL) {
 433                 ERR(" DPP : Failed to get URI !!!");
 434                 return FALSE;
 435         }
 436
 437         g_variant_get(message, "(s)", uri);
 438         INFO("DPP reply: [%s]", *uri);
 439
 440         g_variant_unref(message);
 441         return TRUE;
 442 }
 443
 444 static gboolean __netconfig_wifi_invoke_dpp_add_configurator(const char *key, guint32 *id)
 445 {
 446         char *if_path = NULL;
 447         GVariantBuilder *builder = NULL;
 448         GVariant *params = NULL;
 449         GVariant *message = NULL;
 450
 451         DBG("[TizenMW-->WPAS]: DPP AddConfigurator Request: ");
 452
 453         if_path = __netconfig_dpp_get_supplicant_interface();
 454         if (if_path == NULL) {
 455                 ERR("Fail to get wpa_supplicant DBus interface path");
 456                 return FALSE;
 457         }
 458         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 459         if (key)
 460                 g_variant_builder_add(builder, "{sv}", "key", g_variant_new_string(key));
 461         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 462         g_variant_builder_unref(builder);
 463
 464         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 465                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "AddConfigurator", params);
 466         g_free(if_path);
 467         if (message == NULL) {
 468                 ERR(" DPP : Failed to add configurator !!!");
 469                 return FALSE;
 470         }
 471
 472         g_variant_get(message, "(u)", id);
 473         INFO("DPP reply: [%u]", *id);
 474
 475         g_variant_unref(message);
 476         return TRUE;
 477 }
 478
 479 static gchar *__generate_configurator_params(guint32 configurator_id, const char *ssid,
 480                 const char *net_role, const char *akm, const char *pass)
 481 {
 482         gchar ssid_hex[65] = {0,};
 483         gchar pass_hex[129] = {0,};
 484         gchar *ret = NULL;
 485
 486         gchar *conf_str = NULL;
 487
 488         netconfig_convert_bytes_to_hexstr(ssid, strlen(ssid), ssid_hex);
 489         conf_str = g_strdup_printf(" ssid=%s conf=%s-%s", ssid_hex, net_role, akm);
 490
 491         if (pass) {
 492                 netconfig_convert_bytes_to_hexstr(pass, strlen(pass), pass_hex);
 493                 ret = g_strdup_printf("%s pass=%s", conf_str, pass_hex);
 494         } else {
 495                 ret = g_strdup_printf(" configurator=%u%s", configurator_id, conf_str);
 496         }
 497         g_free(conf_str);
 498
 499         return ret;
 500 }
 501
 502 static gboolean __netconfig_wifi_invoke_dpp_set_configurator_params(guint configurator_id,
 503                 const char *ssid, const char *net_role, const char *akm, const char *pass)
 504 {
 505         char *if_path = NULL;
 506         GVariant *message = NULL;
 507         GVariant *params = NULL;
 508         gchar *configurator_param_str = NULL;
 509
 510         DBG("[TizenMW-->WPAS]: DPP Set configurator params Request: ");
 511
 512         if_path = __netconfig_dpp_get_supplicant_interface();
 513         if (if_path == NULL) {
 514                 ERR("Fail to get wpa_supplicant DBus interface path");
 515                 return FALSE;
 516         }
 517
 518         configurator_param_str = __generate_configurator_params(
 519                         configurator_id, ssid, net_role, akm, pass);
 520         if (!configurator_param_str) {
 521                 ERR(" DPP : Failed to gen conf params");
 522                 g_free(if_path);
 523                 return FALSE;
 524         }
 525         params = g_variant_new("(ssv)", SUPPLICANT_INTERFACE ".Interface",
 526                         "DPPConfiguratorParams", g_variant_new_string(configurator_param_str));
 527
 528         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 529                         if_path, DBUS_INTERFACE_PROPERTIES, "Set", params);
 530         g_free(if_path);
 531         g_free(configurator_param_str);
 532         if (message == NULL) {
 533                 ERR(" DPP : Failed to set configurator params !!!");
 534                 return FALSE;
 535         }
 536
 537         g_variant_unref(message);
 538         return TRUE;
 539 }
 540
 541 static gboolean __netconfig_wifi_invoke_dpp_listen(guint32 freq, const gchar *dev_role)
 542 {
 543         char *if_path = NULL;
 544         GVariantBuilder *builder = NULL;
 545         GVariant *params = NULL;
 546         GVariant *message = NULL;
 547
 548         DBG("[TizenMW-->WPAS]: DPP Listen Request: ");
 549
 550         if_path = __netconfig_dpp_get_supplicant_interface();
 551         if (if_path == NULL) {
 552                 ERR("Fail to get wpa_supplicant DBus interface path");
 553                 return FALSE;
 554         }
 555         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 556         g_variant_builder_add(builder, "{sv}", "freq", g_variant_new_uint32(freq));
 557         g_variant_builder_add(builder, "{sv}", "role", g_variant_new_string(dev_role));
 558         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 559         g_variant_builder_unref(builder);
 560
 561         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 562                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "Listen", params);
 563         g_free(if_path);
 564         if (message == NULL) {
 565                 ERR(" DPP : Failed to start DPP listen !!!");
 566                 return FALSE;
 567         }
 568
 569         g_variant_unref(message);
 570         return TRUE;
 571 }
 572
 573 static gboolean __netconfig_wifi_invoke_auth_init_enrollee(guint32 peer_id)
 574 {
 575         char *if_path = NULL;
 576         GVariantBuilder *builder = NULL;
 577         GVariant *params = NULL;
 578         GVariant *message = NULL;
 579
 580         DBG("[TizenMW-->WPAS]: DPP AuthInit Request: ");
 581
 582         if_path = __netconfig_dpp_get_supplicant_interface();
 583         if (if_path == NULL) {
 584                 ERR("Fail to get wpa_supplicant DBus interface path");
 585                 return FALSE;
 586         }
 587         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 588         g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_uint32(peer_id));
 589         g_variant_builder_add(builder, "{sv}", "role", g_variant_new_string("enrollee"));
 590         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 591         g_variant_builder_unref(builder);
 592
 593         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 594                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "AuthInit", params);
 595         g_free(if_path);
 596         if (message == NULL) {
 597                 ERR(" DPP : Failed to start DPP AuthInit !!!");
 598                 return FALSE;
 599         }
 600
 601         g_variant_unref(message);
 602         return TRUE;
 603 }
 604
 605 static gboolean __netconfig_wifi_invoke_auth_init_configurator(guint32 peer_id,
 606                 guint32 configurator_id, const char *conf, const char *ssid, const char *pass)
 607 {
 608         char *if_path = NULL;
 609         GVariantBuilder *builder = NULL;
 610         GVariant *params = NULL;
 611         GVariant *message = NULL;
 612         gchar ssid_hex[65] = {0,};
 613         gchar pass_hex[129] = {0,};
 614
 615         DBG("[TizenMW-->WPAS]: DPP AuthInit Request: ");
 616
 617         if_path = __netconfig_dpp_get_supplicant_interface();
 618         if (if_path == NULL) {
 619                 ERR("Fail to get wpa_supplicant DBus interface path");
 620                 return FALSE;
 621         }
 622         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 623         g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_uint32(peer_id));
 624         g_variant_builder_add(builder, "{sv}", "configurator", g_variant_new_uint32(configurator_id));
 625         g_variant_builder_add(builder, "{sv}", "role", g_variant_new_string("configurator"));
 626         g_variant_builder_add(builder, "{sv}", "conf", g_variant_new_string(conf));
 627         if (ssid) {
 628                 netconfig_convert_bytes_to_hexstr(ssid, strlen(ssid), ssid_hex);
 629                 g_variant_builder_add(builder, "{sv}", "ssid", g_variant_new_string(ssid_hex));
 630         }
 631         if (pass) {
 632                 netconfig_convert_bytes_to_hexstr(pass, strlen(pass), pass_hex);
 633                 g_variant_builder_add(builder, "{sv}", "passphrase", g_variant_new_string(pass_hex));
 634         }
 635         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 636         g_variant_builder_unref(builder);
 637
 638         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 639                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "AuthInit", params);
 640         g_free(if_path);
 641         if (message == NULL) {
 642                 ERR(" DPP : Failed to start DPP AuthInit !!!");
 643                 return FALSE;
 644         }
 645
 646         g_variant_unref(message);
 647         return TRUE;
 648 }
 649
 650 static void __netconfig_wifi_invoke_dpp_stop_listen()
 651 {
 652         char *if_path = NULL;
 653         GVariant *message = NULL;
 654
 655         DBG("[TizenMW-->WPAS]: DPP StopListen Request: ");
 656
 657         if_path = __netconfig_dpp_get_supplicant_interface();
 658         if (if_path == NULL) {
 659                 ERR("Fail to get wpa_supplicant DBus interface path");
 660                 return;
 661         }
 662
 663         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 664                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "StopListen", NULL);
 665         g_free(if_path);
 666         if (message == NULL) {
 667                 ERR(" DPP : Failed to stop listen !!!");
 668                 return;
 669         }
 670
 671         g_variant_unref(message);
 672         return;
 673 }
 674
 675 static void __netconfig_wifi_invoke_dpp_remove_bootstrap(guint32 uri_id)
 676 {
 677         char *if_path = NULL;
 678         GVariant *message = NULL;
 679         GVariant *params = NULL;
 680
 681         if (uri_id == 0) {
 682                 DBG("Invalid ID");
 683                 return;
 684         }
 685
 686         DBG("[TizenMW-->WPAS]: DPP RemoveBootstrap Request: ");
 687
 688         if_path = __netconfig_dpp_get_supplicant_interface();
 689         if (if_path == NULL) {
 690                 ERR("Fail to get wpa_supplicant DBus interface path");
 691                 return;
 692         }
 693
 694         params = g_variant_new("(u)", uri_id);
 695         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 696                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "RemoveBootstrap", params);
 697         g_free(if_path);
 698         if (message == NULL) {
 699                 ERR(" DPP : Failed to remove URI !!!");
 700                 return;
 701         }
 702
 703         g_variant_unref(message);
 704         return;
 705 }
 706
 707 static void __netconfig_wifi_invoke_dpp_remove_configurator(guint32 configurator_id)
 708 {
 709         char *if_path = NULL;
 710         GVariant *message = NULL;
 711         GVariant *params = NULL;
 712
 713         if (configurator_id == 0) {
 714                 DBG("Invalid ID");
 715                 return;
 716         }
 717
 718         DBG("[TizenMW-->WPAS]: DPP RemoveConfigurator Request: ");
 719
 720         if_path = __netconfig_dpp_get_supplicant_interface();
 721         if (if_path == NULL) {
 722                 ERR("Fail to get wpa_supplicant DBus interface path");
 723                 return;
 724         }
 725
 726         params = g_variant_new("(u)", configurator_id);
 727         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 728                         if_path, SUPPLICANT_INTERFACE ".Interface.DPP", "RemoveConfigurator", params);
 729         g_free(if_path);
 730         if (message == NULL) {
 731                 ERR(" DPP : Failed to remove configurator !!!");
 732                 return;
 733         }
 734
 735         g_variant_unref(message);
 736         return;
 737 }
 738 /*
 739 static void __wifi_dpp_connman_specific_scan_request_reply(GObject *source_object, GAsyncResult *res,
 740                 gpointer user_data)
 741 {
 742         GDBusConnection *conn = NULL;
 743         GError *error = NULL;
 744         GVariant *reply;
 745
 746         conn = G_DBUS_CONNECTION(source_object);
 747         reply = g_dbus_connection_call_finish(conn, res, &error);
 748         if (error != NULL) {
 749                 ERR("Scan failed. Error [%s]\n", error->message);
 750                 g_error_free(error);
 751         } else {
 752                 DBG("Specific Scan Request success\n");
 753         }
 754
 755         if (reply)
 756                 g_variant_unref(reply);
 757 }
 758
 759 static gboolean __netconfig_wifi_dpp_invoke_connman_specific_scan(gchar *ssid)
 760 {
 761         GVariant *params = NULL;
 762         GVariantBuilder *builder;
 763         gboolean ret;
 764
 765         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 766         g_variant_builder_add(builder, "{sv}", "SSID", g_variant_new_string(ssid));
 767
 768         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
 769         g_variant_builder_unref(builder);
 770
 771         ret = netconfig_invoke_dbus_method_nonblock(CONNMAN_SERVICE,
 772                         CONNMAN_WIFI_TECHNOLOGY_PREFIX,
 773                         CONNMAN_TECHNOLOGY_INTERFACE, "SpecificScan", params,
 774                         __wifi_dpp_connman_specific_scan_request_reply);
 775
 776         return ret;
 777 }
 778 */
 779 static void __wifi_dpp_connman_scan_request_reply(GObject *source_object, GAsyncResult *res,
 780                 gpointer user_data)
 781 {
 782         GDBusConnection *conn = NULL;
 783         GError *error = NULL;
 784         GVariant *reply;
 785
 786         conn = G_DBUS_CONNECTION(source_object);
 787         reply = g_dbus_connection_call_finish(conn, res, &error);
 788         if (error != NULL) {
 789                 ERR("Scan failed. Error [%s]\n", error->message);
 790                 g_error_free(error);
 791         } else {
 792                 DBG("Scan Request success\n");
 793         }
 794
 795         if (reply)
 796                 g_variant_unref(reply);
 797 }
 798
 799 static gboolean __netconfig_wifi_dpp_invoke_connman_scan()
 800 {
 801         return netconfig_invoke_dbus_method_nonblock(CONNMAN_SERVICE,
 802                         CONNMAN_WIFI_TECHNOLOGY_PREFIX,
 803                         CONNMAN_TECHNOLOGY_INTERFACE, "Scan", NULL,
 804                         __wifi_dpp_connman_scan_request_reply);
 805 }
 806
 807
 808
 809 static gboolean __netconfig_wifi_invoke_flush_bss()
 810 {
 811         GVariant *message = NULL;
 812         char *if_path = NULL;
 813         GVariant *params = NULL;
 814
 815         DBG("[TizenMW-->WPAS]: Wi-Fi Flush BSS Request: ");
 816
 817         if_path = netconfig_wifi_get_supplicant_interface();
 818         if (if_path == NULL) {
 819                 ERR("Fail to get wpa_supplicant DBus path");
 820                 return FALSE;
 821         }
 822
 823         params = g_variant_new("(u)", 0);
 824         message = netconfig_invoke_dbus_method(SUPPLICANT_SERVICE,
 825                         if_path, SUPPLICANT_INTERFACE ".Interface", "FlushBSS", params);
 826
 827         g_free(if_path);
 828         if (message == NULL) {
 829                 ERR(" Failed to flush BSS !!!");
 830                 return FALSE;
 831         }
 832
 833         g_variant_unref(message);
 834         return TRUE;
 835 }
 836
 837 static gboolean __netconfig_wifi_dpp_enter_peer_uri(GDBusMethodInvocation *context,
 838                 guint32 peer_id, guint32 own_id, gboolean is_initiator, gchar *peer_uri)
 839 {
 840         wifi_dpp_s *p_dpp_info = NULL;
 841         gboolean ret;
 842
 843         p_dpp_info = _get_dpp_info(peer_id, own_id);
 844         if (!p_dpp_info) {
 845                 ERR("Invalid parameter");
 846                 return FALSE;
 847         }
 848
 849         ret = __netconfig_wifi_invoke_dpp_qr_code(peer_uri, &(p_dpp_info->peer_id));
 850         if (!ret)
 851                 return FALSE;
 852
 853         __netconfig_wifi_notify_dpp_bootstrapped(p_dpp_info->peer_id);
 854
 855         return TRUE;
 856 }
 857
 858 static gboolean __netconfig_wifi_dpp_generate_uri(GDBusMethodInvocation *context,
 859                 guint32 peer_id, guint32 own_id, gboolean is_initiator, const gchar *key)
 860 {
 861         wifi_dpp_s *p_dpp_info = NULL;
 862         guint32 id = 0;
 863         gchar *generated_uri = NULL;
 864         gboolean ret;
 865
 866         p_dpp_info = _get_dpp_info(peer_id, own_id);
 867         if (!p_dpp_info) {
 868                 ERR("Invalid parameter");
 869                 return FALSE;
 870         }
 871
 872         ret = __netconfig_wifi_invoke_dpp_add_bootstrap(key, &id);
 873         if (!ret)
 874                 return FALSE;
 875
 876         ret = __netconfig_wifi_invoke_dpp_get_bootstrap_uri(id, &generated_uri);
 877         if (!ret) {
 878                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
 879                 return FALSE;
 880         }
 881
 882         p_dpp_info->own_id = id;
 883         __netconfig_wifi_notify_dpp_uri_generated(id, generated_uri);
 884         g_free(generated_uri);
 885
 886         return TRUE;
 887 }
 888
 889 static gboolean __netconfig_wifi_dpp_start_configurator_initiator(GDBusMethodInvocation *context,
 890                 const char *group_id, const char *ssid, const char *peer_uri, guint32 peer_id,
 891                 const char *net_role, const char *akm, const char *configurator_key,
 892                 const char *pass)
 893 {
 894         wifi_dpp_s *p_dpp_info = NULL;
 895         guint32 id = 0;
 896         char *conf_str = NULL;
 897         gboolean ret = FALSE;
 898
 899         p_dpp_info = __create_dpp_info(TRUE);
 900         if (!p_dpp_info) {
 901                 INFO("Failed to create DPP info");
 902                 return FALSE;
 903         }
 904
 905         ret = __netconfig_wifi_invoke_dpp_qr_code(peer_uri, &(id));
 906         if (!ret) {
 907                 __destroy_dpp_info(p_dpp_info);
 908                 return FALSE;
 909         }
 910
 911         ret = __netconfig_wifi_invoke_dpp_add_configurator(configurator_key, &(p_dpp_info->configurator_id));
 912         if (!ret) {
 913                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
 914                 __destroy_dpp_info(p_dpp_info);
 915                 return FALSE;
 916         }
 917         p_dpp_info->state = WIFI_DPP_STATE_BOOTSTRAPPED;
 918         __netconfig_wifi_notify_dpp_bootstrapped(id);
 919
 920         conf_str = g_strdup_printf("%s-%s", net_role, akm);
 921         ret = __netconfig_wifi_invoke_auth_init_configurator(id,
 922                         p_dpp_info->configurator_id, conf_str, ssid, pass);
 923         if (!ret) {
 924                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
 925                 __destroy_dpp_info(p_dpp_info);
 926                 g_free(conf_str);
 927                 return FALSE;
 928         }
 929
 930         p_dpp_info->is_initiator = TRUE;
 931         p_dpp_info->peer_id = id;
 932         __add_to_dpp_info_list(p_dpp_info);
 933         p_dpp_info->state = WIFI_DPP_STATE_AUTHENTICATING;
 934         __netconfig_wifi_notify_dpp_authenticating(id, p_dpp_info->own_id);
 935
 936         g_free(conf_str);
 937
 938         return TRUE;
 939 }
 940
 941 static gboolean __netconfig_wifi_dpp_start_configurator_responder(GDBusMethodInvocation *context,
 942                 const char *group_id, const char *ssid, const char *net_role,
 943                 const char *akm, const char *auth_key, const char *configurator_key,
 944                 const char *pass)
 945 {
 946         wifi_dpp_s *p_dpp_info = NULL;
 947         gboolean ret = FALSE;
 948         guint32 id = 0;
 949         gchar *generated_uri = NULL;
 950
 951         p_dpp_info = __create_dpp_info(FALSE);
 952         if (!p_dpp_info) {
 953                 INFO("Failed to create DPP info");
 954                 return FALSE;
 955         }
 956
 957         ret = __netconfig_wifi_invoke_dpp_add_configurator(configurator_key, &(p_dpp_info->configurator_id));
 958         if (!ret) {
 959                 __destroy_dpp_info(p_dpp_info);
 960                 return FALSE;
 961         }
 962
 963         ret = __netconfig_wifi_invoke_dpp_set_configurator_params(p_dpp_info->configurator_id, ssid, net_role, akm, pass);
 964         if (!ret) {
 965                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
 966                 __destroy_dpp_info(p_dpp_info);
 967                 return FALSE;
 968         }
 969
 970         ret = __netconfig_wifi_invoke_dpp_add_bootstrap(auth_key, &id);
 971         if (!ret) {
 972                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
 973                 __destroy_dpp_info(p_dpp_info);
 974                 return FALSE;
 975         }
 976
 977         ret = __netconfig_wifi_invoke_dpp_get_bootstrap_uri(id, &generated_uri);
 978         if (!ret) {
 979                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
 980                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
 981                 __destroy_dpp_info(p_dpp_info);
 982                 return FALSE;
 983         }
 984
 985         __netconfig_wifi_notify_dpp_uri_generated(id, generated_uri);
 986
 987         ret = __netconfig_wifi_invoke_dpp_listen(DEFAULT_DPP_FREQ, "configurator");
 988         if (!ret) {
 989                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
 990                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
 991                 g_free(generated_uri);
 992                 __destroy_dpp_info(p_dpp_info);
 993                 return FALSE;
 994         }
 995
 996         p_dpp_info->is_initiator = FALSE;
 997         p_dpp_info->own_id = id;
 998         __add_to_dpp_info_list(p_dpp_info);
 999         p_dpp_info->state = WIFI_DPP_STATE_AWAITING;
1000         __netconfig_wifi_notify_dpp_awaiting(id);
1001
1002         g_free(generated_uri);
1003
1004         return TRUE;
1005 }
1006
1007 static gboolean __netconfig_wifi_dpp_start_enrollee_initiator(GDBusMethodInvocation *context,
1008                 const char *peer_uri, guint32 peer_id)
1009 {
1010         wifi_dpp_s *p_dpp_info = NULL;
1011         guint32 id = 0;
1012         gboolean ret = FALSE;
1013
1014         p_dpp_info = __create_dpp_info(TRUE);
1015         if (!p_dpp_info) {
1016                 INFO("Failed to create DPP info");
1017                 return FALSE;
1018         }
1019
1020         ret = __netconfig_wifi_invoke_dpp_set_dpp_config_processing();
1021         if (!ret) {
1022                 __destroy_dpp_info(p_dpp_info);
1023                 return FALSE;
1024         }
1025
1026         ret = __netconfig_wifi_invoke_dpp_qr_code(peer_uri, &id);
1027         if (!ret) {
1028                 __destroy_dpp_info(p_dpp_info);
1029                 return FALSE;
1030         }
1031         p_dpp_info->state = WIFI_DPP_STATE_BOOTSTRAPPED;
1032         __netconfig_wifi_notify_dpp_bootstrapped(id);
1033
1034         ret = __netconfig_wifi_invoke_auth_init_enrollee(id);
1035         if (!ret) {
1036                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
1037                 __destroy_dpp_info(p_dpp_info);
1038                 return FALSE;
1039         }
1040
1041         p_dpp_info->is_initiator = TRUE;
1042         p_dpp_info->peer_id = id;
1043         __add_to_dpp_info_list(p_dpp_info);
1044         p_dpp_info->state = WIFI_DPP_STATE_AUTHENTICATING;
1045         __netconfig_wifi_notify_dpp_authenticating(id, p_dpp_info->own_id);
1046
1047         return TRUE;
1048 }
1049
1050 static gboolean __netconfig_wifi_dpp_start_enrollee_responder(GDBusMethodInvocation *context,
1051                 const char *auth_key)
1052 {
1053         wifi_dpp_s *p_dpp_info = NULL;
1054         gboolean ret = FALSE;
1055         guint32 id = 0;
1056         gchar *generated_uri = NULL;
1057
1058         p_dpp_info = __create_dpp_info(FALSE);
1059         if (!p_dpp_info) {
1060                 INFO("Failed to create DPP info");
1061                 return FALSE;
1062         }
1063
1064         ret = __netconfig_wifi_invoke_dpp_set_dpp_config_processing();
1065         if (!ret) {
1066                 __destroy_dpp_info(p_dpp_info);
1067                 return FALSE;
1068         }
1069
1070         ret = __netconfig_wifi_invoke_dpp_add_bootstrap(auth_key, &id);
1071         if (!ret) {
1072                 __destroy_dpp_info(p_dpp_info);
1073                 return FALSE;
1074         }
1075
1076         ret = __netconfig_wifi_invoke_dpp_get_bootstrap_uri(id, &generated_uri);
1077         if (!ret) {
1078                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
1079                 __destroy_dpp_info(p_dpp_info);
1080                 return FALSE;
1081         }
1082
1083         __netconfig_wifi_notify_dpp_uri_generated(id, generated_uri);
1084
1085         ret = __netconfig_wifi_invoke_dpp_listen(DEFAULT_DPP_FREQ, "enrollee");
1086         if (!ret) {
1087                 __netconfig_wifi_invoke_dpp_remove_bootstrap(id);
1088                 __destroy_dpp_info(p_dpp_info);
1089                 return FALSE;
1090         }
1091
1092         p_dpp_info->is_initiator = FALSE;
1093         p_dpp_info->own_id = id;
1094         __add_to_dpp_info_list(p_dpp_info);
1095         p_dpp_info->state = WIFI_DPP_STATE_AWAITING;
1096         __netconfig_wifi_notify_dpp_awaiting(id);
1097
1098         g_free(generated_uri);
1099
1100         return TRUE;
1101 }
1102
1103 static gboolean __netconfig_wifi_dpp_stop(GDBusMethodInvocation *context,
1104                 guint32 peer_id, guint32 own_id)
1105 {
1106         wifi_dpp_s *p_dpp_info = NULL;
1107
1108         p_dpp_info = _get_dpp_info(peer_id, own_id);
1109         if (!p_dpp_info) {
1110                 ERR("Invalid parameter");
1111                 return FALSE;
1112         }
1113
1114         __netconfig_wifi_invoke_dpp_stop_listen();
1115         __netconfig_wifi_invoke_dpp_remove_bootstrap(p_dpp_info->peer_id);
1116
1117         if (p_dpp_info->own_id != 0)
1118                 __netconfig_wifi_invoke_dpp_remove_bootstrap(p_dpp_info->own_id);
1119
1120         if (p_dpp_info->configurator_id != 0)
1121                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
1122
1123         __remove_from_dpp_info_list(p_dpp_info);
1124         __destroy_dpp_info(p_dpp_info);
1125         __netconfig_wifi_notify_dpp_removed(peer_id, own_id);
1126
1127         return TRUE;
1128 }
1129
1130
1131 void netconfig_wifi_dpp_auth_success_event(GVariant *message)
1132 {
1133         wifi_dpp_s *p_dpp_info = NULL;
1134         GVariantBuilder *builder = NULL;
1135
1136         p_dpp_info = _get_dpp_in_progress();
1137         if (!p_dpp_info) {
1138                 ERR("DPP :there's no DPP in progress");
1139                 return;
1140         }
1141
1142         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1143         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1144         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1145
1146         p_dpp_info->state = WIFI_DPP_STATE_AUTHENTICATED;
1147         wifi_emit_dpp_auth_success((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1148         g_variant_builder_unref(builder);
1149
1150
1151         return;
1152 }
1153
1154 static void __clear_dpp_process(wifi_dpp_s *p_dpp_info)
1155 {
1156         g_in_progress = FALSE;
1157         __netconfig_wifi_invoke_dpp_stop_listen();
1158
1159         __netconfig_wifi_invoke_dpp_remove_bootstrap(p_dpp_info->peer_id);
1160
1161         if (p_dpp_info->own_id != 0)
1162                 __netconfig_wifi_invoke_dpp_remove_bootstrap(p_dpp_info->own_id);
1163
1164         if (p_dpp_info->configurator_id != 0)
1165                 __netconfig_wifi_invoke_dpp_remove_configurator(p_dpp_info->configurator_id);
1166
1167         __remove_from_dpp_info_list(p_dpp_info);
1168         __netconfig_wifi_notify_dpp_removed(p_dpp_info->peer_id, p_dpp_info->own_id);
1169         __destroy_dpp_info(p_dpp_info);
1170 }
1171
1172 static void __resume_dpp_responder(wifi_dpp_s *p_dpp_info)
1173 {
1174         gchar *device_role = NULL;
1175         gboolean ret;
1176
1177         __netconfig_wifi_invoke_dpp_stop_listen();
1178
1179         if (p_dpp_info->configurator_id)
1180                 device_role = "configurator";
1181         else
1182                 device_role = "enrollee";
1183
1184         ret = __netconfig_wifi_invoke_dpp_listen(DEFAULT_DPP_FREQ, device_role);
1185         if (!ret) {
1186                 __clear_dpp_process(p_dpp_info);
1187         } else {
1188                 p_dpp_info->state = WIFI_DPP_STATE_AWAITING;
1189                 __netconfig_wifi_notify_dpp_awaiting(p_dpp_info->own_id);
1190         }
1191 }
1192
1193 static void __netconfig_wifi_dpp_wrap_up(wifi_dpp_s *p_dpp_info)
1194 {
1195         if (p_dpp_info->is_initiator)
1196                 __clear_dpp_process(p_dpp_info);
1197         else
1198                 __resume_dpp_responder(p_dpp_info);
1199 }
1200
1201 static void __netconfig_wifi_dpp_notify_dpp_failed(wifi_dpp_s *p_dpp_info)
1202 {
1203         GVariantBuilder *builder = NULL;
1204
1205         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1206         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1207         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1208
1209         wifi_emit_dpp_auth_failed((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1210         g_variant_builder_unref(builder);
1211
1212         __netconfig_wifi_dpp_wrap_up(p_dpp_info);
1213 }
1214
1215 void netconfig_wifi_dpp_auth_failed_event(GVariant *message)
1216 {
1217         wifi_dpp_s *p_dpp_info = NULL;
1218         p_dpp_info = _get_dpp_in_progress();
1219         if (!p_dpp_info) {
1220                 ERR("DPP :there's no DPP in progress");
1221                 return;
1222         }
1223
1224         __netconfig_wifi_dpp_notify_dpp_failed(p_dpp_info);
1225
1226         return;
1227 }
1228
1229 void netconfig_wifi_dpp_not_compatible_event(GVariant *message)
1230 {
1231         wifi_dpp_s *p_dpp_info = NULL;
1232         GVariantBuilder *builder = NULL;
1233
1234         p_dpp_info = _get_dpp_in_progress();
1235         if (!p_dpp_info) {
1236                 ERR("DPP :there's no DPP in progress");
1237                 return;
1238         }
1239
1240         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1241         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1242         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1243
1244         wifi_emit_dpp_not_compatible((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1245         g_variant_builder_unref(builder);
1246
1247         __netconfig_wifi_dpp_wrap_up(p_dpp_info);
1248
1249         return;
1250 }
1251
1252 void netconfig_wifi_dpp_conf_failed_event(GVariant *message)
1253 {
1254         wifi_dpp_s *p_dpp_info = NULL;
1255         GVariantBuilder *builder = NULL;
1256
1257         p_dpp_info = _get_dpp_in_progress();
1258         if (!p_dpp_info) {
1259                 ERR("DPP :there's no DPP in progress");
1260                 return;
1261         }
1262
1263         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1264         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1265         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1266
1267         wifi_emit_dpp_conf_failed((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1268         g_variant_builder_unref(builder);
1269
1270         __netconfig_wifi_dpp_wrap_up(p_dpp_info);
1271
1272         return;
1273 }
1274
1275 void netconfig_wifi_dpp_scan_peer_qr_event(GVariant *message)
1276 {
1277         wifi_dpp_s *p_dpp_info = NULL;
1278         GVariantBuilder *builder = NULL;
1279
1280         p_dpp_info = _get_dpp_in_progress();
1281         if (!p_dpp_info) {
1282                 ERR("DPP :there's no DPP in progress");
1283                 return;
1284         }
1285
1286         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1287         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1288         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1289
1290         wifi_emit_dpp_scan_peer_qr((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1291         g_variant_builder_unref(builder);
1292
1293         p_dpp_info->state = WIFI_DPP_STATE_PEER_QR_REQUESTED;
1294
1295         return;
1296 }
1297
1298 void netconfig_wifi_dpp_network_id_event(GVariant *message)
1299 {
1300         wifi_dpp_s *p_dpp_info = NULL;
1301         GVariantBuilder *builder = NULL;
1302
1303         p_dpp_info = _get_dpp_in_progress();
1304         if (!p_dpp_info) {
1305                 ERR("DPP :there's no DPP in progress");
1306                 return;
1307         }
1308
1309         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1310         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1311         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1312
1313         wifi_emit_dpp_network_id((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1314         g_variant_builder_unref(builder);
1315
1316         return;
1317 }
1318
1319 void netconfig_wifi_dpp_conf_sent_event(GVariant *message)
1320 {
1321         wifi_dpp_s *p_dpp_info = NULL;
1322         GVariantBuilder *builder = NULL;
1323
1324         p_dpp_info = _get_dpp_in_progress();
1325         if (!p_dpp_info) {
1326                 ERR("DPP :there's no DPP in progress");
1327                 return;
1328         }
1329
1330         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1331         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1332         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1333
1334         wifi_emit_dpp_conf_sent((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1335         g_variant_builder_unref(builder);
1336
1337         __netconfig_wifi_dpp_wrap_up(p_dpp_info);
1338
1339         return;
1340 }
1341
1342 void netconfig_wifi_dpp_conf_received_event(GVariant *message)
1343 {
1344         wifi_dpp_s *p_dpp_info = NULL;
1345         GVariantBuilder *builder = NULL;
1346
1347         p_dpp_info = _get_dpp_in_progress();
1348         if (!p_dpp_info) {
1349                 ERR("DPP :there's no DPP in progress");
1350                 return;
1351         }
1352
1353         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1354         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(p_dpp_info->peer_id));
1355         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(p_dpp_info->own_id));
1356
1357         wifi_emit_dpp_conf_received((Wifi *)get_wifi_object(), g_variant_builder_end(builder));
1358         g_variant_builder_unref(builder);
1359
1360         p_dpp_info->state = WIFI_DPP_STATE_CONFIGURED;
1361
1362         return;
1363 }
1364
1365 static wifi_dpp_akm_e __get_dpp_akm(const gchar *akm_str)
1366 {
1367         if (g_strcmp0(akm_str, "psk") == 0)
1368                 return WIFI_DPP_AKM_PSK;
1369         else if (g_strcmp0(akm_str, "sae") == 0)
1370                 return WIFI_DPP_AKM_SAE;
1371         else if (g_strcmp0(akm_str, "dpp") == 0)
1372                 return WIFI_DPP_AKM_DPP;
1373
1374         return WIFI_DPP_AKM_UNKNOWN;
1375 }
1376
1377 static gboolean __is_configuration_valid(wifi_dpp_akm_e akm, const gchar *passphrase,
1378                 const gchar *connector, const gchar *c_sign_key, const gchar *net_access_key)
1379 {
1380         if ((akm == WIFI_DPP_AKM_PSK || akm == WIFI_DPP_AKM_SAE) && passphrase)
1381                 return TRUE;
1382         else if (akm == WIFI_DPP_AKM_DPP && connector && c_sign_key && net_access_key)
1383                 return TRUE;
1384         return FALSE;
1385 }
1386
1387 gboolean __save_passphrase(GKeyFile *keyfile, gchar *group_name, gchar *key, gchar *value)
1388 {
1389         gchar *enc_data = NULL;
1390         gboolean ret = TRUE;
1391
1392         if (!value)
1393                 return ret;
1394
1395         enc_data = _netconfig_encrypt_passphrase(value);
1396         if (!enc_data) {
1397                 ERR("Failed to encrypt the passphrase");
1398                 ret = FALSE;
1399         } else {
1400                 g_key_file_set_string(keyfile, group_name, key, enc_data);
1401                 g_free(enc_data);
1402         }
1403
1404         return ret;
1405 }
1406
1407 gboolean __save_credentials(GKeyFile *keyfile, gchar *group_name, wifi_dpp_conf_obj *conf_obj)
1408 {
1409         gboolean ret;
1410
1411         ret = __save_passphrase(keyfile, group_name,
1412                         "Passphrase", conf_obj->passphrase);
1413         if (!ret)
1414                 return FALSE;
1415
1416         ret = __save_passphrase(keyfile, group_name,
1417                         "Connector", conf_obj->connector);
1418         if (!ret)
1419                 return FALSE;
1420
1421         ret = __save_passphrase(keyfile, group_name,
1422                         "CSignKey", conf_obj->c_sign_key);
1423         if (!ret)
1424                 return FALSE;
1425
1426         ret = __save_passphrase(keyfile, group_name,
1427                         "NetAccessKey", conf_obj->net_access_key);
1428         if (!ret)
1429                 return FALSE;
1430
1431         return TRUE;
1432 }
1433
1434
1435 static gboolean __save_configuration_object(wifi_dpp_conf_obj *conf_obj)
1436 {
1437         gchar ssid_hex[65] = {0,};
1438         gchar *config_id = NULL;
1439         gchar *group_name = NULL;
1440         GKeyFile *keyfile = NULL;
1441         gboolean ret;
1442
1443         if (!conf_obj->ssid) {
1444                 ERR("DPP :there's no SSID in configuration");
1445                 return FALSE;
1446         }
1447
1448         if (!__is_configuration_valid(__get_dpp_akm(conf_obj->akm),
1449                         conf_obj->passphrase,
1450                         conf_obj->connector,
1451                         conf_obj->c_sign_key,
1452                         conf_obj->net_access_key)) {
1453                 ERR("DPP :Invalid AKM information in configuration");
1454                 return FALSE;
1455         }
1456
1457         netconfig_convert_bytes_to_hexstr(conf_obj->ssid, strlen(conf_obj->ssid), ssid_hex);
1458         config_id = g_strdup_printf("%s_managed_%s", ssid_hex, conf_obj->akm);
1459         ret = wifi_config_get_group_name("wifi_", config_id, &group_name);
1460         if (!ret) {
1461                 ERR("Failed to get Wi-Fi config group name");
1462                 g_free(config_id);
1463                 return FALSE;
1464         }
1465
1466         keyfile = g_key_file_new();
1467         g_key_file_set_string(keyfile, group_name, "Name", conf_obj->ssid);
1468         g_key_file_set_string(keyfile, group_name, "SSID", ssid_hex);
1469
1470         if (!__save_credentials(keyfile, group_name, conf_obj)) {
1471                 g_key_file_free(keyfile);
1472                 g_free(config_id);
1473                 g_free(group_name);
1474                 return FALSE;
1475         }
1476
1477         g_key_file_set_boolean(keyfile, group_name, "Favorite", TRUE);
1478         g_key_file_set_boolean(keyfile, group_name, "AutoConnect", TRUE);
1479
1480         ret = wifi_config_save_configuration(config_id, keyfile);
1481         if (ret == TRUE)
1482                 INFO("Success to save configuration [%s]", config_id);
1483         else
1484                 INFO("Fail to save configuration [%s]", config_id);
1485
1486         g_key_file_free(keyfile);
1487         g_free(config_id);
1488         g_free(group_name);
1489
1490         return ret;
1491
1492 }
1493
1494 void netconfig_wifi_dpp_conf_obj_event(GVariant *message)
1495 {
1496         GVariantIter *iter = NULL;
1497         gchar *key = NULL;
1498         GVariant *value = NULL;
1499         wifi_dpp_s *p_dpp_info = NULL;
1500         wifi_dpp_conf_obj conf_obj = {0,};
1501
1502         p_dpp_info = _get_dpp_in_progress();
1503         if (!p_dpp_info) {
1504                 ERR("DPP :there's no DPP in progress");
1505                 return;
1506         }
1507
1508         g_variant_get(message, "(a{sv})", &iter);
1509         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
1510                 if (g_strcmp0(key, "ssid") == 0)
1511                         g_variant_get(value, "&s", &conf_obj.ssid);
1512                 else if (g_strcmp0(key, "akm") == 0)
1513                         g_variant_get(value, "&s", &conf_obj.akm);
1514                 else if (g_strcmp0(key, "passphrase") == 0)
1515                         g_variant_get(value, "&s", &conf_obj.passphrase);
1516                 else if (g_strcmp0(key, "connector") == 0)
1517                         g_variant_get(value, "&s", &conf_obj.connector);
1518                 else if (g_strcmp0(key, "c_sign_key") == 0)
1519                         g_variant_get(value, "&s", &conf_obj.c_sign_key);
1520                 else if (g_strcmp0(key, "net_access_key") == 0)
1521                         g_variant_get(value, "&s", &conf_obj.net_access_key);
1522         }
1523
1524         if (!__save_configuration_object(&conf_obj) || !__netconfig_wifi_invoke_flush_bss()) {
1525                 g_variant_iter_free(iter);
1526                 __netconfig_wifi_dpp_notify_dpp_failed(p_dpp_info);
1527                 return;
1528         }
1529
1530         g_variant_iter_free(iter);
1531         __clear_dpp_process(p_dpp_info);
1532         __netconfig_wifi_dpp_invoke_connman_scan();
1533         return;
1534 }
1535
1536 gboolean handle_dpp_enter_peer_uri(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1537 {
1538         gboolean ret = FALSE;
1539         GVariantIter *iter;
1540         GVariant *value;
1541         gchar *field;
1542         guint32 peer_id = 0;
1543         guint32 own_id = 0;
1544         gboolean is_initiator = FALSE;
1545         gchar *uri = NULL;
1546
1547         INFO("Received DPP enter peer uri Request");
1548         if ((wifi == NULL) || (dpp_info == NULL)) {
1549                 ERR("Invalid arguments");
1550                 netconfig_error_dbus_method_return(context,
1551                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1552                 return TRUE;
1553         }
1554
1555         g_variant_get(dpp_info, "a{sv}", &iter);
1556         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1557                 if (g_strcmp0(field, "peer_id") == 0 &&
1558                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1559                         peer_id = g_variant_get_uint32(value);
1560                 } else if (g_strcmp0(field, "own_id") == 0 &&
1561                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1562                         own_id = g_variant_get_uint32(value);
1563
1564                 } else if (g_strcmp0(field, "uri") == 0 &&
1565                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1566                         g_free(uri);
1567                         uri = g_strdup(g_variant_get_string(value, NULL));
1568                 }
1569         }
1570
1571         if (!own_id || !uri){
1572                 g_variant_iter_free(iter);
1573                 g_free(uri);
1574                 ERR("Invalid arguments");
1575                 netconfig_error_dbus_method_return(context,
1576                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1577                 return TRUE;
1578         }
1579         wifi_complete_dpp_enter_peer_uri(wifi, context);
1580
1581         ret = __netconfig_wifi_dpp_enter_peer_uri(context, peer_id, own_id,
1582                         is_initiator, uri);
1583         if (ret == TRUE)
1584                 INFO("Success to enter peer uri");
1585         else
1586                 __netconfig_wifi_notify_dpp_failed();
1587
1588         g_variant_iter_free(iter);
1589         g_free(uri);
1590
1591         return TRUE;
1592 }
1593
1594 gboolean handle_dpp_generate_uri(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1595 {
1596         gboolean ret = FALSE;
1597         GVariantIter *iter;
1598         GVariant *value;
1599         gchar *field;
1600         guint32 peer_id = 0;
1601         guint32 own_id = 0;
1602         gboolean is_initiator = FALSE;
1603         gchar *key = NULL;
1604
1605         INFO("Received DPP gen own uri Request");
1606         if ((wifi == NULL) || (dpp_info == NULL)) {
1607                 ERR("Invalid arguments");
1608                 netconfig_error_dbus_method_return(context,
1609                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1610                 return TRUE;
1611         }
1612
1613         g_variant_get(dpp_info, "a{sv}", &iter);
1614         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1615                 if (g_strcmp0(field, "peer_id") == 0 &&
1616                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1617                         peer_id = g_variant_get_uint32(value);
1618                 } else if (g_strcmp0(field, "own_id") == 0 &&
1619                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1620                         own_id = g_variant_get_uint32(value);
1621
1622                 } else if (g_strcmp0(field, "is_initiator") == 0 &&
1623                                 g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
1624                         is_initiator = g_variant_get_boolean(value);
1625                 } else if (g_strcmp0(field, "key") == 0 &&
1626                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1627                         __free_critical(key);
1628                         key = g_strdup(g_variant_get_string(value, NULL));
1629                 }
1630         }
1631
1632         if (!peer_id){
1633                 __free_critical(key);
1634                 g_variant_iter_free(iter);
1635                 ERR("Invalid arguments");
1636                 netconfig_error_dbus_method_return(context,
1637                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1638                 return TRUE;
1639         }
1640         wifi_complete_dpp_generate_uri(wifi, context);
1641
1642         ret = __netconfig_wifi_dpp_generate_uri(context, peer_id, own_id,
1643                         is_initiator, key);
1644         if (ret == TRUE)
1645                 INFO("Success to generate uri");
1646         else
1647                 __netconfig_wifi_notify_dpp_failed();
1648
1649         g_variant_iter_free(iter);
1650         __free_critical(key);
1651
1652         return TRUE;
1653 }
1654
1655 gboolean handle_dpp_start_configurator_initiator(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1656 {
1657         GVariantIter *iter;
1658         GVariant *value;
1659         gchar *field;
1660         gchar *group_id = NULL;
1661         gchar *ssid = NULL;
1662         gchar *peer_uri = NULL;
1663         guint32 peer_id = 0;
1664         gchar *net_role = NULL;
1665         gchar *akm = NULL;
1666         gchar *configurator_key = NULL;
1667         gchar *pass = NULL;
1668
1669         INFO("Received DPP start configurator initiator");
1670         if ((wifi == NULL) || (dpp_info == NULL)) {
1671                 ERR("Invalid arguments");
1672                 netconfig_error_dbus_method_return(context,
1673                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1674                 return TRUE;
1675         }
1676         if (g_in_progress) {
1677                 ERR("DPP in progress");;
1678                 netconfig_error_inprogress(context);
1679                 return TRUE;
1680         }
1681
1682         g_variant_get(dpp_info, "a{sv}", &iter);
1683         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1684                 if (g_strcmp0(field, "group_id") == 0 &&
1685                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1686                         g_free(group_id);
1687                         group_id = g_strdup(g_variant_get_string(value, NULL));
1688                 } else if (g_strcmp0(field, "ssid") == 0 &&
1689                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1690                         g_free(ssid);
1691                         ssid = g_strdup(g_variant_get_string(value, NULL));
1692                 } else if (g_strcmp0(field, "peer_uri") == 0 &&
1693                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1694                         g_free(peer_uri);
1695                         peer_uri = g_strdup(g_variant_get_string(value, NULL));
1696                 } else if (g_strcmp0(field, "peer_id") == 0 &&
1697                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1698                         peer_id = g_variant_get_uint32(value);
1699                 } else if (g_strcmp0(field, "net_role") == 0 &&
1700                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1701                         g_free(net_role);
1702                         net_role = g_strdup(g_variant_get_string(value, NULL));
1703                 } else if (g_strcmp0(field, "akm") == 0 &&
1704                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1705                         g_free(akm);
1706                         akm = g_strdup(g_variant_get_string(value, NULL));
1707                 } else if (g_strcmp0(field, "configurator_key") == 0 &&
1708                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1709                         __free_critical(configurator_key);
1710                         configurator_key = g_strdup(g_variant_get_string(value, NULL));
1711                 } else if (g_strcmp0(field, "pass") == 0 &&
1712                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1713                         __free_critical(pass);
1714                         pass = g_strdup(g_variant_get_string(value, NULL));
1715                 }
1716         }
1717
1718         if (!ssid || !akm || !net_role || !peer_uri){
1719                 g_variant_iter_free(iter);
1720                 g_free(group_id);
1721                 g_free(ssid);
1722                 g_free(peer_uri);
1723                 g_free(net_role);
1724                 g_free(akm);
1725                 __free_critical(configurator_key);
1726                 __free_critical(pass);
1727                 ERR("Invalid arguments");
1728                 netconfig_error_dbus_method_return(context,
1729                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1730                 return TRUE;
1731         }
1732
1733         wifi_complete_dpp_start_configurator_initiator(wifi, context);
1734
1735         g_in_progress = __netconfig_wifi_dpp_start_configurator_initiator(context, group_id,
1736                         ssid, peer_uri, peer_id, net_role, akm, configurator_key, pass);
1737         if (g_in_progress)
1738                 INFO("Success to dpp start configurator initiator");
1739         else
1740                 __netconfig_wifi_notify_dpp_failed();
1741
1742         g_variant_iter_free(iter);
1743         g_free(group_id);
1744         g_free(ssid);
1745         g_free(peer_uri);
1746         g_free(net_role);
1747         g_free(akm);
1748         __free_critical(configurator_key);
1749         __free_critical(pass);
1750         return TRUE;
1751 }
1752
1753 gboolean handle_dpp_start_enrollee_initiator(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1754 {
1755         GVariantIter *iter;
1756         GVariant *value;
1757         gchar *field;
1758         gchar *peer_uri = NULL;
1759         guint32 peer_id = 0;
1760
1761         INFO("Received DPP start enrollee initiator");
1762         if ((wifi == NULL) || (dpp_info == NULL)) {
1763                 ERR("Invalid arguments");
1764                 netconfig_error_dbus_method_return(context,
1765                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1766                 return TRUE;
1767         }
1768         if (g_in_progress) {
1769                 ERR("DPP in progress");;
1770                 netconfig_error_inprogress(context);
1771                 return TRUE;
1772         }
1773
1774         g_variant_get(dpp_info, "a{sv}", &iter);
1775         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1776
1777                 if (g_strcmp0(field, "peer_uri") == 0 &&
1778                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1779                         g_free(peer_uri);
1780                         peer_uri = g_strdup(g_variant_get_string(value, NULL));
1781                 } else if (g_strcmp0(field, "peer_id") == 0 &&
1782                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1783                         peer_id = g_variant_get_uint32(value);
1784                 }
1785         }
1786
1787         if (!peer_uri){
1788                 g_variant_iter_free(iter);
1789                 ERR("Invalid arguments");
1790                 netconfig_error_dbus_method_return(context,
1791                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1792                 return FALSE;
1793         }
1794         wifi_complete_dpp_start_enrollee_initiator(wifi, context);
1795
1796         g_in_progress = __netconfig_wifi_dpp_start_enrollee_initiator(context, peer_uri, peer_id);
1797         if (g_in_progress)
1798                 INFO("Success to dpp start enrollee initiator");
1799         else
1800                 __netconfig_wifi_notify_dpp_failed();
1801
1802         g_variant_iter_free(iter);
1803         g_free(peer_uri);
1804
1805         return TRUE;
1806 }
1807
1808 gboolean handle_dpp_start_configurator_responder(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1809 {
1810         GVariantIter *iter;
1811         GVariant *value;
1812         gchar *field;
1813         gchar *group_id = NULL;
1814         gchar *ssid = NULL;
1815         gchar *net_role = NULL;
1816         gchar *akm = NULL;
1817         gchar *auth_key = NULL;
1818         gchar *configurator_key = NULL;
1819         gchar *pass = NULL;
1820
1821         INFO("Received DPP start configurator responder");
1822         if ((wifi == NULL) || (dpp_info == NULL)) {
1823                 ERR("Invalid arguments");
1824                 netconfig_error_dbus_method_return(context,
1825                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1826                 return TRUE;
1827         }
1828         if (g_in_progress) {
1829                 ERR("DPP in progress");;
1830                 netconfig_error_inprogress(context);
1831                 return TRUE;
1832         }
1833
1834         g_variant_get(dpp_info, "a{sv}", &iter);
1835         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1836                 if (g_strcmp0(field, "group_id") == 0 &&
1837                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1838                         g_free(group_id);
1839                         group_id = g_strdup(g_variant_get_string(value, NULL));
1840                 } else if (g_strcmp0(field, "ssid") == 0 &&
1841                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1842                         g_free(ssid);
1843                         ssid = g_strdup(g_variant_get_string(value, NULL));
1844                 } else if (g_strcmp0(field, "net_role") == 0 &&
1845                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1846                         g_free(net_role);
1847                         net_role = g_strdup(g_variant_get_string(value, NULL));
1848                 } else if (g_strcmp0(field, "akm") == 0 &&
1849                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1850                         g_free(akm);
1851                         akm = g_strdup(g_variant_get_string(value, NULL));
1852                 } else if (g_strcmp0(field, "auth_key") == 0 &&
1853                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1854                         __free_critical(auth_key);
1855                         auth_key = g_strdup(g_variant_get_string(value, NULL));
1856                 } else if (g_strcmp0(field, "configurator_key") == 0 &&
1857                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1858                         __free_critical(configurator_key);
1859                         configurator_key = g_strdup(g_variant_get_string(value, NULL));
1860                 } else if (g_strcmp0(field, "pass") == 0 &&
1861                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1862                         __free_critical(pass);
1863                         pass = g_strdup(g_variant_get_string(value, NULL));
1864                 }
1865         }
1866
1867         if (!ssid || !akm || !net_role){
1868                 g_variant_iter_free(iter);
1869                 g_free(group_id);
1870                 g_free(ssid);
1871                 g_free(net_role);
1872                 g_free(akm);
1873                 __free_critical(auth_key);
1874                 __free_critical(configurator_key);
1875                 __free_critical(pass);
1876                 ERR("Invalid arguments");
1877                 netconfig_error_dbus_method_return(context,
1878                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1879                 return FALSE;
1880         }
1881         wifi_complete_dpp_start_configurator_responder(wifi, context);
1882
1883         g_in_progress = __netconfig_wifi_dpp_start_configurator_responder(context, group_id,
1884                         ssid, net_role, akm, auth_key, configurator_key, pass);
1885         if (g_in_progress)
1886                 INFO("Success to dpp start configurator responder");
1887         else
1888                 __netconfig_wifi_notify_dpp_failed();
1889
1890         g_variant_iter_free(iter);
1891         g_free(group_id);
1892         g_free(ssid);
1893         g_free(net_role);
1894         g_free(akm);
1895         __free_critical(auth_key);
1896         __free_critical(configurator_key);
1897         __free_critical(pass);
1898
1899         return TRUE;
1900 }
1901
1902 gboolean handle_dpp_start_enrollee_responder(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1903 {
1904         GVariantIter *iter;
1905         GVariant *value;
1906         gchar *field;
1907         gchar *auth_key = NULL;
1908
1909         INFO("Received DPP start enrollee responder");
1910         if ((wifi == NULL) || (dpp_info == NULL)) {
1911                 ERR("Invalid arguments");
1912                 netconfig_error_dbus_method_return(context,
1913                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1914                 return TRUE;
1915         }
1916         if (g_in_progress) {
1917                 ERR("DPP in progress");;
1918                 netconfig_error_inprogress(context);
1919                 return TRUE;
1920         }
1921
1922         g_variant_get(dpp_info, "a{sv}", &iter);
1923         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1924                 if (g_strcmp0(field, "auth_key") == 0 &&
1925                                 g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
1926                         __free_critical(auth_key);
1927                         auth_key = g_strdup(g_variant_get_string(value, NULL));
1928                 }
1929         }
1930         wifi_complete_dpp_start_enrollee_responder(wifi, context);
1931
1932         g_in_progress = __netconfig_wifi_dpp_start_enrollee_responder(context, auth_key);
1933         if (g_in_progress)
1934                 INFO("Success to dpp start enrolee responder");
1935         else
1936                 __netconfig_wifi_notify_dpp_failed();
1937
1938         g_variant_iter_free(iter);
1939         __free_critical(auth_key);
1940
1941         return TRUE;
1942 }
1943
1944 gboolean handle_dpp_stop(Wifi *wifi, GDBusMethodInvocation *context, GVariant *dpp_info)
1945 {
1946         GVariantIter *iter;
1947         GVariant *value;
1948         gchar *field;
1949         guint32 peer_id = 0;
1950         guint32 own_id = 0;
1951
1952         INFO("Received DPP stop Request");
1953         if ((wifi == NULL) || (dpp_info == NULL)) {
1954                 ERR("Invalid arguments");
1955                 netconfig_error_dbus_method_return(context,
1956                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1957                 return TRUE;
1958         }
1959
1960         g_variant_get(dpp_info, "a{sv}", &iter);
1961
1962         g_variant_get(dpp_info, "a{sv}", &iter);
1963         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
1964                 if (g_strcmp0(field, "peer_id") == 0 &&
1965                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1966                         peer_id = g_variant_get_uint32(value);
1967                 } else if (g_strcmp0(field, "own_id") == 0 &&
1968                                 g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
1969                         own_id = g_variant_get_uint32(value);
1970                 }
1971         }
1972         if (!peer_id && !own_id){
1973                 g_variant_iter_free(iter);
1974                 ERR("Invalid arguments");
1975                 netconfig_error_dbus_method_return(context,
1976                                 NETCONFIG_ERROR_INVALID_PARAMETER, "InvalidArguments");
1977                 return FALSE;
1978         }
1979         wifi_complete_dpp_stop(wifi, context);
1980
1981         g_in_progress = !(__netconfig_wifi_dpp_stop(context, peer_id, own_id));
1982         if (!g_in_progress)
1983                 INFO("Success to dpp stop");
1984         else
1985                 __netconfig_wifi_notify_dpp_failed();
1986
1987         g_variant_iter_free(iter);
1988
1989         return TRUE;
1990 }