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