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