src/wifi-direct-iface.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /**
  21  * This file implements wifi direct manager interface functions.
  22  *
  23  * @file        wifi-direct-iface.c
  24  * @author      Nishant Chaprana (n.chaprana@samsung.com)
  25  * @version     0.1
  26  */
  27
  28 #include <stdlib.h>
  29
  30 #include <wifi-direct.h>
  31
  32 #include "wifi-direct-dbus.h"
  33 #include "wifi-direct-iface.h"
  34 #include "wifi-direct-ipc.h"
  35 #include "wifi-direct-error.h"
  36 #include "wifi-direct-log.h"
  37 #include "wifi-direct-manager.h"
  38 #include "wifi-direct-oem.h"
  39 #include "wifi-direct-session.h"
  40 #include "wifi-direct-util.h"
  41 #include "wifi-direct-group.h"
  42 #include "wifi-direct-state.h"
  43 #include <vconf.h>
  44 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
  45 #include "wifi-direct-service.h"
  46 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
  47
  48 #define WFD_DBUS_REPLY_ERROR_NONE(invocation) \
  49         g_dbus_method_invocation_return_value((invocation), g_variant_new("(i)", WIFI_DIRECT_ERROR_NONE))
  50
  51 #define WFD_DBUS_REPLY_PARAMS(invocation, params) \
  52         g_dbus_method_invocation_return_value((invocation), (params))
  53
  54 static int macaddr_atoe(const char *p, unsigned char mac[])
  55 {
  56         int i = 0;
  57
  58         for (;;) {
  59                 mac[i++] = (char) strtoul(p, (char **) &p, 16);
  60                 if (!*p++ || i == 6)
  61                         break;
  62         }
  63
  64         return (i == 6);
  65 }
  66
  67 // introspection xml to register interfaces
  68 const gchar wfd_manager_introspection_xml[] = {
  69         "<node name='/net/wifidirect'>"
  70                 "<interface name='net.wifidirect'>"
  71                         "<method name='Activate'>"
  72                                 "<arg type='i' name='error_code' direction='out'/>"
  73                         "</method>"
  74                         "<method name='Deactivate'>"
  75                                 "<arg type='i' name='error_code' direction='out'/>"
  76                         "</method>"
  77                         "<method name='StartDiscovery'>"
  78                                 "<arg type='a{sv}' name='parameters' direction='in'/>"
  79                                 "<arg type='i' name='error_code' direction='out'/>"
  80                         "</method>"
  81                         "<method name='StopDiscovery'>"
  82                                 "<arg type='i' name='error_code' direction='out'/>"
  83                         "</method>"
  84                         "<method name='GetDiscoveredPeers'>"
  85                                 "<arg type='i' name='error_code' direction='out'/>"
  86                                 "<arg type='aa{sv}' name='peer_details_list' direction='out'/>"
  87                         "</method>"
  88                         "<method name='Connect'>"
  89                                 "<arg type='s' name='mac_address' direction='in'/>"
  90                                 "<arg type='i' name='error_code' direction='out'/>"
  91                         "</method>"
  92                         "<method name='Disconnect'>"
  93                                 "<arg type='s' name='mac_address' direction='in'/>"
  94                                 "<arg type='i' name='error_code' direction='out'/>"
  95                         "</method>"
  96                         "<method name='CancelConnection'>"
  97                                 "<arg type='s' name='mac_address' direction='in'/>"
  98                                 "<arg type='i' name='error_code' direction='out'/>"
  99                         "</method>"
 100                         "<method name='AcceptConnection'>"
 101                                 "<arg type='s' name='mac_address' direction='in'/>"
 102                                 "<arg type='i' name='error_code' direction='out'/>"
 103                         "</method>"
 104                         "<method name='RejectConnection'>"
 105                                 "<arg type='s' name='mac_address' direction='in'/>"
 106                                 "<arg type='i' name='error_code' direction='out'/>"
 107                         "</method>"
 108                         "<method name='DisconnectAll'>"
 109                                 "<arg type='i' name='error_code' direction='out'/>"
 110                         "</method>"
 111                         "<method name='GetConnectedPeers'>"
 112                                 "<arg type='i' name='error_code' direction='out'/>"
 113                                 "<arg type='aa{sv}' name='peer_details_list' direction='out'/>"
 114                         "</method>"
 115                         "<method name='IsDiscoverable'>"
 116                                 "<arg type='b' name='result' direction='out'/>"
 117                         "</method>"
 118                         "<method name='IsListeningOnly'>"
 119                                 "<arg type='b' name='result' direction='out'/>"
 120                         "</method>"
 121                         "<method name='GetPeerInfo'>"
 122                                 "<arg type='s' name='mac_address' direction='in'/>"
 123                                 "<arg type='i' name='error_code' direction='out'/>"
 124                                 "<arg type='a{sv}' name='peer_details' direction='out'/>"
 125                         "</method>"
 126                         "<method name='GetState'>"
 127                                 "<arg type='i' name='error_code' direction='out'/>"
 128                                 "<arg type='i' name='state' direction='out'/>"
 129                         "</method>"
 130                         "<signal name='Activation'>"
 131                                 "<arg type='i' name='error_code'/>"
 132                         "</signal>"
 133                         "<signal name='Deactivation'>"
 134                                 "<arg type='i' name='error_code'/>"
 135                         "</signal>"
 136                         "<signal name='Connection'>"
 137                                 "<arg type='i' name='error_code'/>"
 138                                 "<arg type='i' name='connection_state'/>"
 139                                 "<arg type='s' name='peer_mac_address'/>"
 140                         "</signal>"
 141                         "<signal name='Disconnection'>"
 142                                 "<arg type='i' name='error_code'/>"
 143                                 "<arg type='i' name='connection_state'/>"
 144                                 "<arg type='s' name='peer_mac_address'/>"
 145                         "</signal>"
 146                         "<signal name='ListenStarted'>"
 147                         "</signal>"
 148                         "<signal name='DiscoveryStarted'>"
 149                         "</signal>"
 150                         "<signal name='DiscoveryFinished'>"
 151                         "</signal>"
 152                         "<signal name='PeerFound'>"
 153                                 "<arg type='s' name='peer_mac_address'/>"
 154                         "</signal>"
 155                         "<signal name='PeerLost'>"
 156                                 "<arg type='s' name='peer_mac_address'/>"
 157                         "</signal>"
 158                         "<signal name='PeerIPAssigned'>"
 159                                 "<arg type='s' name='peer_mac_address'/>"
 160                                 "<arg type='s' name='assigned_ip_address'/>"
 161                         "</signal>"
 162                 "</interface>"
 163                 "<interface name='net.wifidirect.group'>"
 164                         "<method name='CreateGroup'>"
 165                                 "<arg type='i' name='error_code' direction='out'/>"
 166                         "</method>"
 167                         "<method name='DestroyGroup'>"
 168                                 "<arg type='i' name='error_code' direction='out'/>"
 169                         "</method>"
 170                         "<method name='IsGroupOwner'>"
 171                                 "<arg type='b' name='result' direction='out'/>"
 172                         "</method>"
 173                         "<method name='IsAutoGroup'>"
 174                                 "<arg type='b' name='result' direction='out'/>"
 175                         "</method>"
 176                         "<method name='ActivatePushButton'>"
 177                                 "<arg type='i' name='error_code' direction='out'/>"
 178                         "</method>"
 179                         "<method name='GetPersistentGroups'>"
 180                                 "<arg type='i' name='error_code' direction='out'/>"
 181                                 "<arg type='aa{sv}' name='result' direction='out'/>"
 182                         "</method>"
 183                         "<method name='RemovePersistentGroup'>"
 184                                 "<arg type='s' name='mac_address' direction='in'/>"
 185                                 "<arg type='s' name='ssid' direction='in'/>"
 186                                 "<arg type='i' name='error_code' direction='out'/>"
 187                         "</method>"
 188                         "<method name='SetPassphrase'>"
 189                                 "<arg type='s' name='passphrase' direction='in'/>"
 190                                 "<arg type='i' name='error_code' direction='out'/>"
 191                         "</method>"
 192                         "<method name='GetPassphrase'>"
 193                                 "<arg type='i' name='error_code' direction='out'/>"
 194                                 "<arg type='s' name='passphrase' direction='out'/>"
 195                         "</method>"
 196                         "<method name='SetPersistentGroupEnabled'>"
 197                                 "<arg type='b' name='enable' direction='in'/>"
 198                                 "<arg type='i' name='error_code' direction='out'/>"
 199                         "</method>"
 200                         "<method name='IsPersistentGroupEnabled'>"
 201                                 "<arg type='b' name='result' direction='out'/>"
 202                         "</method>"
 203                         "<signal name='Created'>"
 204                         "</signal>"
 205                         "<signal name='Destroyed'>"
 206                         "</signal>"
 207                 "</interface>"
 208                 "<interface name='net.wifidirect.config'>"
 209                         "<method name='GetDeviceName'>"
 210                                 "<arg type='i' name='error_code' direction='out'/>"
 211                                 "<arg type='s' name='device_name' direction='out'/>"
 212                         "</method>"
 213                         "<method name='SetDeviceName'>"
 214                                 "<arg type='s' name='device_name' direction='in'/>"
 215                                 "<arg type='i' name='error_code' direction='out'/>"
 216                         "</method>"
 217                         "<method name='SetWpsPin'>"
 218                                 "<arg type='s' name='wps_pin' direction='in'/>"
 219                                 "<arg type='i' name='error_code' direction='out'/>"
 220                         "</method>"
 221                         "<method name='GetWpsPin'>"
 222                                 "<arg type='i' name='error_code' direction='out'/>"
 223                                 "<arg type='s' name='wps_pin' direction='out'/>"
 224                         "</method>"
 225                         "<method name='GenerateWpsPin'>"
 226                                 "<arg type='i' name='error_code' direction='out'/>"
 227                                 "<arg type='s' name='wps_pin' direction='out'/>"
 228                         "</method>"
 229                         "<method name='GetSupportedWpsMode'>"
 230                                 "<arg type='i' name='error_code' direction='out'/>"
 231                                 "<arg type='i' name='config_methods' direction='out'/>"
 232                         "</method>"
 233                         "<method name='GetReqWpsMode'>"
 234                                 "<arg type='i' name='error_code' direction='out'/>"
 235                                 "<arg type='i' name='req_wps_mode' direction='out'/>"
 236                         "</method>"
 237                         "<method name='SetReqWpsMode'>"
 238                                 "<arg type='i' name='req_wps_mode' direction='in'/>"
 239                                 "<arg type='i' name='error_code' direction='out'/>"
 240                         "</method>"
 241                         "<method name='GetLocalWpsMode'>"
 242                                 "<arg type='i' name='error_code' direction='out'/>"
 243                                 "<arg type='i' name='local_wps_mode' direction='out'/>"
 244                         "</method>"
 245                         "<method name='GetIPAddress'>"
 246                                 "<arg type='i' name='error_code' direction='out'/>"
 247                                 "<arg type='s' name='local_ip_address' direction='out'/>"
 248                         "</method>"
 249                         "<method name='GetMacAddress'>"
 250                                 "<arg type='i' name='error_code' direction='out'/>"
 251                                 "<arg type='s' name='local_mac_address' direction='out'/>"
 252                         "</method>"
 253                         "<method name='GetGoIntent'>"
 254                                 "<arg type='i' name='error_code' direction='out'/>"
 255                                 "<arg type='i' name='go_intent' direction='out'/>"
 256                         "</method>"
 257                         "<method name='SetGoIntent'>"
 258                                 "<arg type='i' name='go_intent' direction='in'/>"
 259                                 "<arg type='i' name='error_code' direction='out'/>"
 260                         "</method>"
 261                         "<method name='GetMaxClient'>"
 262                                 "<arg type='i' name='error_code' direction='out'/>"
 263                                 "<arg type='i' name='max_client' direction='out'/>"
 264                         "</method>"
 265                         "<method name='SetMaxClient'>"
 266                                 "<arg type='i' name='max_client' direction='in'/>"
 267                                 "<arg type='i' name='error_code' direction='out'/>"
 268                         "</method>"
 269                         "<method name='SetAutoConnectionMode'>"
 270                                 "<arg type='b' name='auto_connection_mode' direction='in'/>"
 271                                 "<arg type='i' name='error_code' direction='out'/>"
 272                         "</method>"
 273                         "<method name='IsAutoConnectionMode'>"
 274                                 "<arg type='i' name='error_code' direction='out'/>"
 275                                 "<arg type='b' name='result' direction='out'/>"
 276                         "</method>"
 277                         "<method name='GetOperatingChannel'>"
 278                                 "<arg type='i' name='error_code' direction='out'/>"
 279                                 "<arg type='i' name='operating_channel' direction='out'/>"
 280                         "</method>"
 281                         "<method name='SetAutoConnectionPeer'>"
 282                                 "<arg type='s' name='peer_mac_address' direction='in'/>"
 283                                 "<arg type='i' name='error_code' direction='out'/>"
 284                         "</method>"
 285                         "<method name='GetConnectingPeer'>"
 286                                 "<arg type='i' name='error_code' direction='out'/>"
 287                                 "<arg type='s' name='local_mac_address' direction='out'/>"
 288                         "</method>"
 289                         "<method name='GetInterfaceName'>"
 290                                 "<arg type='i' name='error_code' direction='out'/>"
 291                                 "<arg type='s' name='ifname' direction='out'/>"
 292                         "</method>"
 293                         "<method name='GetSubnetMask'>"
 294                                 "<arg type='i' name='error_code' direction='out'/>"
 295                                 "<arg type='s' name='subnet_mask' direction='out'/>"
 296                         "</method>"
 297                         "<method name='GetGateway'>"
 298                                 "<arg type='i' name='error_code' direction='out'/>"
 299                                 "<arg type='s' name='gateway_address' direction='out'/>"
 300                         "</method>"
 301                         "<method name='GetSessionTimer'>"
 302                                 "<arg type='i' name='error_code' direction='out'/>"
 303                                 "<arg type='i' name='session_timer' direction='out'/>"
 304                         "</method>"
 305                         "<method name='SetSessionTimer'>"
 306                                 "<arg type='i' name='session_timer' direction='in'/>"
 307                                 "<arg type='i' name='error_code' direction='out'/>"
 308                         "</method>"
 309                         "<method name='SetAutoGroupRemoval'>"
 310                                 "<arg type='b' name='enable' direction='in'/>"
 311                                 "<arg type='i' name='error_code' direction='out'/>"
 312                         "</method>"
 313                 "</interface>"
 314 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 315                 "<interface name='net.wifidirect.service'>"
 316                         "<method name='StartDiscovery'>"
 317                                 "<arg type='i' name='service_type' direction='in'/>"
 318                                 "<arg type='s' name='mac_addr' direction='in'/>"
 319                                 "<arg type='i' name='error_code' direction='out'/>"
 320                         "</method>"
 321                         "<method name='StopDiscovery'>"
 322                                 "<arg type='i' name='service_type' direction='in'/>"
 323                                 "<arg type='s' name='mac_addr' direction='in'/>"
 324                                 "<arg type='i' name='error_code' direction='out'/>"
 325                         "</method>"
 326                         "<method name='Register'>"
 327                                 "<arg type='i' name='service_type' direction='in'/>"
 328                                 "<arg type='s' name='info_string' direction='in'/>"
 329                                 "<arg type='i' name='error_code' direction='out'/>"
 330                                 "<arg type='i' name='service_id' direction='out'/>"
 331                         "</method>"
 332                         "<method name='Deregister'>"
 333                                 "<arg type='i' name='service_id' direction='in'/>"
 334                                 "<arg type='i' name='error_code' direction='out'/>"
 335                         "</method>"
 336                         "<signal name='DiscoveryStarted'>"
 337                         "</signal>"
 338                         "<signal name='DiscoveryFound'>"
 339                                 "<arg type='i' name='service_type'/>"
 340                                 "<arg type='s' name='response_data'/>"
 341                                 "<arg type='s' name='peer_mac_address'/>"
 342                         "</signal>"
 343                         "<signal name='DiscoveryFinished'>"
 344                         "</signal>"
 345                 "</interface>"
 346 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 347 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 348                 "<interface name='net.wifidirect.display'>"
 349                         "<method name='Init'>"
 350                                 "<arg type='i' name='error_code' direction='out'/>"
 351                         "</method>"
 352                         "<method name='Deinit'>"
 353                                 "<arg type='i' name='error_code' direction='out'/>"
 354                         "</method>"
 355                         "<method name='SetConfig'>"
 356                                 "<arg type='i' name='type' direction='in'/>"
 357                                 "<arg type='i' name='port' direction='in'/>"
 358                                 "<arg type='i' name='hdcp' direction='in'/>"
 359                                 "<arg type='i' name='error_code' direction='out'/>"
 360                         "</method>"
 361                         "<method name='SetAvailiability'>"
 362                                 "<arg type='i' name='availability' direction='in'/>"
 363                                 "<arg type='i' name='error_code' direction='out'/>"
 364                         "</method>"
 365                         "<method name='GetPeerType'>"
 366                                 "<arg type='s' name='peer_mac_addr' direction='in'/>"
 367                                 "<arg type='i' name='error_code' direction='out'/>"
 368                                 "<arg type='i' name='result' direction='out'/>"
 369                         "</method>"
 370                         "<method name='GetPeerAvailability'>"
 371                                 "<arg type='s' name='peer_mac_addr' direction='in'/>"
 372                                 "<arg type='i' name='error_code' direction='out'/>"
 373                                 "<arg type='i' name='result' direction='out'/>"
 374                         "</method>"
 375                         "<method name='GetPeerHdcp'>"
 376                                 "<arg type='s' name='peer_mac_addr' direction='in'/>"
 377                                 "<arg type='i' name='error_code' direction='out'/>"
 378                                 "<arg type='i' name='result' direction='out'/>"
 379                         "</method>"
 380                         "<method name='GetPeerPort'>"
 381                                 "<arg type='s' name='peer_mac_addr' direction='in'/>"
 382                                 "<arg type='i' name='error_code' direction='out'/>"
 383                                 "<arg type='i' name='result' direction='out'/>"
 384                         "</method>"
 385                         "<method name='GetPeerThroughput'>"
 386                                 "<arg type='s' name='peer_mac_addr' direction='in'/>"
 387                                 "<arg type='i' name='error_code' direction='out'/>"
 388                                 "<arg type='i' name='result' direction='out'/>"
 389                         "</method>"
 390                 "</interface>"
 391 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 392         "</node>"
 393 };
 394
 395
 396 static void __wfd_manager_manage_iface_handler(const gchar *method_name,
 397                                               GVariant    *parameters,
 398                                               GDBusMethodInvocation *invocation)
 399 {
 400         int ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 401         wfd_manager_s *manager = wfd_get_manager();
 402         GVariant *return_parameters = NULL;
 403         GError *err = NULL;
 404         gchar* dbus_error_name = NULL;
 405         WDS_LOGD("%s", method_name);
 406
 407         if (!g_strcmp0(method_name, "Activate")) {
 408
 409                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 410
 411                 ret = wfd_manager_activate(manager);
 412                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 413                                              "Activation",
 414                                              g_variant_new("(i)", ret));
 415                 return;
 416
 417         } else if (!g_strcmp0(method_name, "Deactivate")) {
 418
 419                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
 420                         WDS_LOGE("Already deactivated");
 421                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 422                         goto failed;
 423                 }
 424
 425                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 426
 427                 ret = wfd_manager_deactivate(manager);
 428                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 429                                              "Deactivation",
 430                                              g_variant_new("(i)", ret));
 431                 return;
 432
 433         } else if (!g_strcmp0(method_name, "StartDiscovery")) {
 434                 gboolean mode = FALSE;
 435                 gint32 timeout = 0;
 436                 guint32 channel = 0;
 437                 const gchar *type = NULL;
 438                 GVariantIter *iter = NULL;
 439                 gchar *key = NULL;
 440                 GVariant *var = NULL;
 441
 442                 g_variant_get(parameters, "(a{sv})", &iter);
 443                 while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
 444                         if (!g_strcmp0(key, "Mode"))
 445                                 g_variant_get(var, "b", &mode);
 446                         else if (!g_strcmp0(key, "Timeout"))
 447                                 g_variant_get(var, "i", &timeout);
 448                         else if (!g_strcmp0(key, "Type"))
 449                                 g_variant_get(var, "&s", &type);
 450                         else if (!g_strcmp0(key, "Channel"))
 451                                 g_variant_get(var, "i", &channel);
 452                         else
 453                                 ;/* Do Nothing */
 454                 }
 455                 g_variant_iter_free(iter);
 456
 457                 if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
 458                                 manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 459                                 manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
 460                         WDS_LOGE("Wi-Fi Direct is not available status for scanning.");
 461                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 462                         goto failed;
 463                 }
 464
 465                 if (mode && (manager->local->dev_role == WFD_DEV_ROLE_GO)) {
 466                         WDS_LOGW("Wi-Fi Direct device is already visible, do not start listen");
 467                         ret = WIFI_DIRECT_ERROR_NONE;
 468                         return_parameters = g_variant_new("(i)", ret);
 469                         goto done;
 470                 }
 471
 472                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 473
 474                 ret = wfd_manager_start_discovery(manager, mode, timeout, type, channel);
 475                 if (ret == WIFI_DIRECT_ERROR_NONE) {
 476                         if (mode == WFD_OEM_SCAN_MODE_PASSIVE) {
 477                                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 478                                                              "ListenStarted",
 479                                                              NULL);
 480                         } else {
 481                                 wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 482                                                              "DiscoveryStarted",
 483                                                              NULL);
 484                         }
 485                 }
 486                 return;
 487
 488         } else if (!g_strcmp0(method_name, "StopDiscovery")) {
 489                 int mode =  manager->scan_mode;
 490                 if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
 491                                 manager->state != WIFI_DIRECT_STATE_DISCOVERING) {
 492                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 493                         goto failed;
 494                 }
 495
 496                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 497
 498                 ret = wfd_manager_cancel_discovery(manager);
 499                 if (ret == WIFI_DIRECT_ERROR_NONE && mode == WFD_SCAN_MODE_PASSIVE)
 500                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 501                                                      "DiscoveryFinished", NULL);
 502                 return;
 503
 504         } else if (!g_strcmp0(method_name, "GetDiscoveredPeers")) {
 505                 wfd_discovery_entry_s *peers = NULL;
 506                 GVariantBuilder *builder_peers = NULL;
 507                 int peer_cnt = 0;
 508                 int i = 0;
 509
 510                 builder_peers = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
 511
 512                 peer_cnt = wfd_manager_get_peers(manager, &peers);
 513                 WDS_LOGD("Peer count [%d], Peer list [%p]", peer_cnt, peers);
 514                 if (peer_cnt < 0) {
 515                         WDS_LOGE("Failed to get scan result");
 516                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 517                         goto failed;
 518                 }
 519
 520                 if (peer_cnt > 255)
 521                         peer_cnt = 255;
 522
 523                 for (i = 0; i < peer_cnt; i++) {
 524                         GVariantBuilder builder_peer;
 525                         g_variant_builder_init(&builder_peer, G_VARIANT_TYPE("a{sv}"));
 526
 527                         g_variant_builder_add(&builder_peer, "{sv}",
 528                                         "DeviceName",
 529                                         g_variant_new_string(peers[i].device_name));
 530                         g_variant_builder_add(&builder_peer, "{sv}",
 531                                         "DeviceAddress",
 532                                         wfd_manager_dbus_pack_ay(peers[i].mac_address, MACADDR_LEN));
 533                         g_variant_builder_add(&builder_peer, "{sv}",
 534                                         "InterfaceAddress",
 535                                         wfd_manager_dbus_pack_ay(peers[i].intf_address, MACADDR_LEN));
 536                         g_variant_builder_add(&builder_peer, "{sv}",
 537                                         "Channel",
 538                                         g_variant_new_uint16(peers[i].channel));
 539 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 540                         g_variant_builder_add(&builder_peer, "{sv}",
 541                                         "Services",
 542                                         g_variant_new_uint16(peers[i].services));
 543 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 544                         g_variant_builder_add(&builder_peer, "{sv}",
 545                                         "IsGroupOwner",
 546                                         g_variant_new_boolean(peers[i].is_group_owner));
 547                         g_variant_builder_add(&builder_peer, "{sv}",
 548                                         "IsPersistentGO",
 549                                         g_variant_new_boolean(peers[i].is_persistent_go));
 550                         g_variant_builder_add(&builder_peer, "{sv}",
 551                                         "IsConnected",
 552                                         g_variant_new_boolean(peers[i].is_connected));
 553                         g_variant_builder_add(&builder_peer, "{sv}",
 554                                         "WpsDevicePwdID",
 555                                         g_variant_new_uint16(peers[i].wps_device_pwd_id));
 556                         g_variant_builder_add(&builder_peer, "{sv}",
 557                                         "WpsCfgMethods",
 558                                         g_variant_new_uint16(peers[i].wps_cfg_methods));
 559                         g_variant_builder_add(&builder_peer, "{sv}",
 560                                         "Category",
 561                                         g_variant_new_uint16(peers[i].category));
 562                         g_variant_builder_add(&builder_peer, "{sv}",
 563                                         "SubCategory",
 564                                         g_variant_new_uint16(peers[i].subcategory));
 565 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 566                         g_variant_builder_add(&builder_peer, "{sv}",
 567                                         "IsWfdDevice",
 568                                         g_variant_new_boolean(peers[i].is_wfd_device));
 569 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 570
 571                         WDS_LOGD("%dth peer [%s]", i, peers[i].device_name);
 572                         g_variant_builder_add_value(builder_peers, g_variant_builder_end(&builder_peer));
 573                 }
 574
 575                 ret = WIFI_DIRECT_ERROR_NONE;
 576                 return_parameters = g_variant_new("(iaa{sv})", ret, builder_peers);
 577                 g_variant_builder_unref(builder_peers);
 578                 goto done;
 579
 580         } else if (!g_strcmp0(method_name, "Connect")) {
 581                 const char *peer_mac_address = NULL;
 582                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 583
 584                 if (manager->state != WIFI_DIRECT_STATE_ACTIVATED &&
 585                                 manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
 586                                 manager->state != WIFI_DIRECT_STATE_GROUP_OWNER) {
 587                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 588                         goto failed;
 589                 }
 590
 591                 wfd_group_s *group = (wfd_group_s*) manager->group;
 592                 if (group && group->member_count >= manager->max_station) {
 593                         ret = WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
 594                         goto failed;
 595                 }
 596
 597                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 598
 599                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 600                 macaddr_atoe(peer_mac_address, mac_addr);
 601
 602                 ret = wfd_manager_connect(manager, mac_addr);
 603                 if (ret == WIFI_DIRECT_ERROR_NONE)
 604                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 605                                                      "Connection",
 606                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 607                                                                             WFD_EVENT_CONNECTION_IN_PROGRESS,
 608                                                                             peer_mac_address));
 609                 return;
 610
 611         } else if (!g_strcmp0(method_name, "Disconnect")) {
 612                 const char *peer_mac_address = NULL;
 613                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 614
 615                 if (!manager->group || manager->state < WIFI_DIRECT_STATE_CONNECTED) {
 616                         if (WIFI_DIRECT_STATE_DISCOVERING == manager->state) {
 617                                 ret = wfd_oem_stop_scan(manager->oem_ops);
 618                                 if (ret < 0) {
 619                                         WDS_LOGE("Failed to stop scan");
 620                                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 621                                         goto failed;
 622                                 }
 623                                 WDS_LOGI("Succeeded to stop scan");
 624                                 if (WFD_DEV_ROLE_GO == manager->local->dev_role) {
 625                                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 626                                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 627                                 } else {
 628                                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 629                                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 630                                 }
 631                         } else {
 632                                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 633                                 goto failed;
 634                         }
 635                 }
 636
 637                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 638
 639                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 640                 macaddr_atoe(peer_mac_address, mac_addr);
 641
 642                 ret = wfd_manager_disconnect(manager, mac_addr);
 643                 if (ret == WIFI_DIRECT_ERROR_NONE)
 644                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 645                                                      "Disconnection",
 646                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 647                                                                             WFD_EVENT_DISCONNECTION_RSP,
 648                                                                             peer_mac_address));
 649                 return;
 650
 651         } else if (!g_strcmp0(method_name, "CancelConnection")) {
 652                 const char *peer_mac_address = NULL;
 653                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 654
 655                 if (!manager->session && manager->state != WIFI_DIRECT_STATE_CONNECTING) {
 656                         WDS_LOGE("It's not CONNECTING state");
 657                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 658                         goto failed;
 659                 }
 660
 661                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 662
 663                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 664                 macaddr_atoe(peer_mac_address, mac_addr);
 665
 666                 ret = wfd_manager_cancel_connection(manager, mac_addr);
 667                 if (ret == WIFI_DIRECT_ERROR_NONE)
 668                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 669                                                      "Connection",
 670                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_CANCELED,
 671                                                                             WFD_EVENT_CONNECTION_RSP,
 672                                                                             peer_mac_address));
 673                 return;
 674
 675         } else if (!g_strcmp0(method_name, "AcceptConnection")) {
 676                 const char *peer_mac_address = NULL;
 677                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 678
 679                 if (manager->state != WIFI_DIRECT_STATE_CONNECTING) {
 680                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 681                         goto failed;
 682                 }
 683
 684                 wfd_group_s *group = (wfd_group_s*) manager->group;
 685                 if (group && group->member_count >= manager->max_station) {
 686                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 687                         goto failed;
 688                 }
 689
 690                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 691
 692                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 693                 macaddr_atoe(peer_mac_address, mac_addr);
 694
 695                 ret = wfd_manager_accept_connection(manager, mac_addr);
 696                 if (ret == WIFI_DIRECT_ERROR_NONE) {
 697                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 698                                                      "Connection",
 699                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_NONE,
 700                                                                             WFD_EVENT_CONNECTION_IN_PROGRESS,
 701                                                                             peer_mac_address));
 702                 } else {
 703                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 704                                                      "Connection",
 705                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_OPERATION_FAILED,
 706                                                                             WFD_EVENT_CONNECTION_RSP,
 707                                                                             peer_mac_address));
 708                 }
 709                 return;
 710
 711         } else if (!g_strcmp0(method_name, "RejectConnection")) {
 712                 wfd_session_s *session = manager->session;
 713                 const char *peer_mac_address = NULL;
 714                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 715
 716                 if (!session || manager->state != WIFI_DIRECT_STATE_CONNECTING) {
 717                         WDS_LOGE("It's not permitted with this state [%d]", manager->state);
 718                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 719                         goto failed;
 720                 }
 721
 722                 if (session->direction != SESSION_DIRECTION_INCOMING) {
 723                         WDS_LOGE("Only incomming session can be rejected");
 724                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 725                         goto failed;
 726                 }
 727
 728                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 729
 730                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 731                 macaddr_atoe(peer_mac_address, mac_addr);
 732
 733                 ret = wfd_manager_reject_connection(manager, mac_addr);
 734                 if (ret == WIFI_DIRECT_ERROR_NONE)
 735                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 736                                                      "Connection",
 737                                                      g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_CANCELED,
 738                                                                             WFD_EVENT_CONNECTION_RSP,
 739                                                                             peer_mac_address));
 740                 return;
 741
 742         } else if (!g_strcmp0(method_name, "DisconnectAll")) {
 743
 744                 if (!manager->group || manager->state < WIFI_DIRECT_STATE_CONNECTED) {
 745                         if (WIFI_DIRECT_STATE_DISCOVERING == manager->state) {
 746                                 ret = wfd_oem_stop_scan(manager->oem_ops);
 747                                 if (ret < 0) {
 748                                         WDS_LOGE("Failed to stop scan");
 749                                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 750                                         goto failed;
 751                                 }
 752                                 WDS_LOGI("Succeeded to stop scan");
 753                                 if (WFD_DEV_ROLE_GO == manager->local->dev_role) {
 754                                         wfd_state_set(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 755                                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_GROUP_OWNER);
 756                                 } else {
 757                                         wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
 758                                         wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
 759                                 }
 760                         } else {
 761                                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 762                                 goto failed;
 763                         }
 764                 }
 765
 766                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
 767
 768                 ret = wfd_manager_disconnect_all(manager);
 769                 if (ret == WIFI_DIRECT_ERROR_NONE)
 770                         wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
 771                                                      "Disconnection",
 772                                                      g_variant_new("(iis)", ret,
 773                                                                             WFD_EVENT_DISCONNECTION_RSP,
 774                                                                             ""));
 775                 return;
 776
 777         } else if (!g_strcmp0(method_name, "GetConnectedPeers")) {
 778                 wfd_connected_peer_info_s *peers = NULL;
 779                 GVariantBuilder *builder_peers = NULL;
 780                 int peer_cnt = 0;
 781                 int i = 0;
 782
 783                 builder_peers = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
 784
 785                 // even though status is not CONNECTED, this command can be excuted only when group exist
 786                 if (!manager->group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
 787                         WDS_LOGD("It's not connected state [%d]", manager->state);
 788                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 789                         goto failed;
 790                 }
 791
 792                 peer_cnt = wfd_manager_get_connected_peers(manager, &peers);
 793                 WDS_LOGD("Peer count [%d], Peer list [%x]", peer_cnt, peers);
 794                 if (peer_cnt < 0) {
 795                         WDS_LOGE("Failed to get scan result");
 796                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 797                         goto failed;
 798                 }
 799
 800                 for (i = 0; i < peer_cnt; i++) {
 801                         GVariantBuilder builder_peer;
 802                         g_variant_builder_init(&builder_peer, G_VARIANT_TYPE("a{sv}"));
 803
 804                         g_variant_builder_add(&builder_peer, "{sv}",
 805                                         "DeviceName",
 806                                         g_variant_new_string(peers[i].device_name));
 807                         g_variant_builder_add(&builder_peer, "{sv}",
 808                                         "DeviceAddress",
 809                                         wfd_manager_dbus_pack_ay(peers[i].mac_address, MACADDR_LEN));
 810                         g_variant_builder_add(&builder_peer, "{sv}",
 811                                         "InterfaceAddress",
 812                                         wfd_manager_dbus_pack_ay(peers[i].intf_address, MACADDR_LEN));
 813                         g_variant_builder_add(&builder_peer, "{sv}",
 814                                         "IPAddress",
 815                                         wfd_manager_dbus_pack_ay(peers[i].ip_address, IPADDR_LEN));
 816                         g_variant_builder_add(&builder_peer, "{sv}",
 817                                         "Channel",
 818                                         g_variant_new_uint16(peers[i].channel));
 819 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 820                         g_variant_builder_add(&builder_peer, "{sv}",
 821                                         "Services",
 822                                         g_variant_new_uint16(peers[i].services));
 823 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 824                         g_variant_builder_add(&builder_peer, "{sv}",
 825                                         "Category",
 826                                         g_variant_new_uint16(peers[i].category));
 827                         g_variant_builder_add(&builder_peer, "{sv}",
 828                                         "SubCategory",
 829                                         g_variant_new_uint16(peers[i].subcategory));
 830                         g_variant_builder_add(&builder_peer, "{sv}",
 831                                         "IsP2P",
 832                                         g_variant_new_boolean(peers[i].is_p2p));
 833 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 834                         g_variant_builder_add(&builder_peer, "{sv}",
 835                                         "IsWfdDevice",
 836                                         g_variant_new_boolean(peers[i].is_wfd_device));
 837 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 838
 839                         WDS_LOGD("%dth peer [%s]", i, peers[i].device_name);
 840                         g_variant_builder_add_value(builder_peers, g_variant_builder_end(&builder_peer));
 841                 }
 842
 843                 ret = WIFI_DIRECT_ERROR_NONE;
 844                 return_parameters = g_variant_new("(iaa{sv})", ret, builder_peers);
 845                 g_variant_builder_unref(builder_peers);
 846                 goto done;
 847
 848         } else if (!g_strcmp0(method_name, "IsDiscoverable")) {
 849                 ret = WIFI_DIRECT_ERROR_NONE;
 850                 return_parameters = g_variant_new("(b)",
 851                                                    (manager->state == WIFI_DIRECT_STATE_DISCOVERING ||
 852                                                     wfd_group_is_autonomous(manager->group) == TRUE));
 853                 goto done;
 854
 855         } else if (!g_strcmp0(method_name, "IsListeningOnly")) {
 856                 ret = WIFI_DIRECT_ERROR_NONE;
 857                 return_parameters = g_variant_new("(b)", (manager->scan_mode == WFD_SCAN_MODE_PASSIVE));
 858                 goto done;
 859
 860         } else if (!g_strcmp0(method_name, "GetPeerInfo")) {
 861                 wfd_discovery_entry_s *peer = NULL;
 862                 GVariantBuilder *builder_peer = NULL;
 863                 const char *peer_mac_address = NULL;
 864                 unsigned char mac_addr[MACADDR_LEN] = {0, };
 865
 866                 g_variant_get(parameters, "(&s)", &peer_mac_address);
 867                 macaddr_atoe(peer_mac_address, mac_addr);
 868
 869                 builder_peer = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 870
 871                 ret = wfd_manager_get_peer_info(manager, mac_addr, &peer);
 872                 if (ret < 0 || !peer) {
 873                         WDS_LOGE("Failed to get peer info");
 874                         g_free(peer);
 875                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 876                         goto failed;
 877                 }
 878
 879                 g_variant_builder_add(builder_peer, "{sv}",
 880                                 "DeviceName",
 881                                 g_variant_new_string(peer->device_name));
 882                 g_variant_builder_add(builder_peer, "{sv}",
 883                                 "DeviceAddress",
 884                                 wfd_manager_dbus_pack_ay(peer->mac_address, MACADDR_LEN));
 885                 g_variant_builder_add(builder_peer, "{sv}",
 886                                 "InterfaceAddress",
 887                                 wfd_manager_dbus_pack_ay(peer->intf_address, MACADDR_LEN));
 888                 g_variant_builder_add(builder_peer, "{sv}",
 889                                 "Channel",
 890                                 g_variant_new_uint16(peer->channel));
 891 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
 892                 g_variant_builder_add(builder_peer, "{sv}",
 893                                 "Services",
 894                                 g_variant_new_uint16(peer->services));
 895 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
 896                 g_variant_builder_add(builder_peer, "{sv}",
 897                                 "IsGroupOwner",
 898                                 g_variant_new_boolean(peer->is_group_owner));
 899                 g_variant_builder_add(builder_peer, "{sv}",
 900                                 "IsPersistentGO",
 901                                 g_variant_new_boolean(peer->is_persistent_go));
 902                 g_variant_builder_add(builder_peer, "{sv}",
 903                                 "IsConnected",
 904                                 g_variant_new_boolean(peer->is_connected));
 905                 g_variant_builder_add(builder_peer, "{sv}",
 906                                 "WpsDevicePwdID",
 907                                 g_variant_new_uint16(peer->wps_device_pwd_id));
 908                 g_variant_builder_add(builder_peer, "{sv}",
 909                                 "WpsCfgMethods",
 910                                 g_variant_new_uint16(peer->wps_cfg_methods));
 911                 g_variant_builder_add(builder_peer, "{sv}",
 912                                 "Category",
 913                                 g_variant_new_uint16(peer->category));
 914                 g_variant_builder_add(builder_peer, "{sv}",
 915                                 "SubCategory",
 916                                 g_variant_new_uint16(peer->subcategory));
 917 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
 918                 g_variant_builder_add(builder_peer, "{sv}",
 919                                 "IsWfdDevice",
 920                                 g_variant_new_boolean(peer->is_wfd_device));
 921 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
 922
 923                 ret = WIFI_DIRECT_ERROR_NONE;
 924                 return_parameters = g_variant_new("(ia{sv})", ret, builder_peer);
 925                 g_variant_builder_unref(builder_peer);
 926                 g_free(peer);
 927                 goto done;
 928
 929         } else if (!g_strcmp0(method_name, "GetState")) {
 930                 ret = WIFI_DIRECT_ERROR_NONE;
 931                 return_parameters = g_variant_new("(ii)", ret, manager->state);
 932                 goto done;
 933
 934         } else {
 935                 WDS_LOGD("method not handled");
 936                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 937                 goto failed;
 938         }
 939
 940 done:
 941         WFD_DBUS_REPLY_PARAMS(invocation, return_parameters);
 942         return;
 943
 944 failed:
 945
 946 //g_dbus_method_invocation_return_dbus_error(invocation, WFD_MANAGER_SERVICE ".Error", ".OperationFailed");
 947
 948         wfd_error_set_gerror(ret, &err);
 949         dbus_error_name = g_dbus_error_encode_gerror(err);
 950         WDS_LOGD("g_dbus_method_invocation_return_gerror with [%s]", dbus_error_name);
 951         g_free(dbus_error_name);
 952         g_dbus_method_invocation_return_gerror(invocation, err);
 953         g_clear_error(&err);
 954         return;
 955 }
 956
 957 static void __wfd_manager_group_iface_handler(const gchar *method_name,
 958                                              GVariant    *parameters,
 959                                              GDBusMethodInvocation *invocation)
 960 {
 961         int ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 962         wfd_manager_s *manager = wfd_get_manager();
 963         GVariant *return_parameters = NULL;
 964         GError *err = NULL;
 965         WDS_LOGD("%s", method_name);
 966
 967         if (!g_strcmp0(method_name, "CreateGroup")) {
 968                 wfd_group_s *group = manager->group;
 969                 wfd_oem_group_param_s param;
 970
 971                 if (group || manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
 972                         WDS_LOGE("Group already exist or not a proper state");
 973                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
 974                         goto failed;
 975                 }
 976
 977 #ifdef TIZEN_WLAN_BOARD_SPRD
 978                 group = wfd_create_pending_group(manager, manager->local->dev_addr);
 979 #else
 980                 group = wfd_create_pending_group(manager, manager->local->intf_addr);
 981 #endif
 982                 if (!group) {
 983                         WDS_LOGE("Failed to create pending group");
 984                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 985                         goto failed;
 986                 }
 987                 group->flags |= WFD_GROUP_FLAG_AUTONOMOUS;
 988                 manager->group = group;
 989
 990                 memset(&param, 0x0, sizeof(param));
 991
 992                 param.persistent = (manager->local->group_flags &
 993                                         WFD_GROUP_FLAG_PERSISTENT);
 994                 memcpy(&(param.passphrase), manager->local->passphrase,
 995                                         sizeof(param.passphrase));
 996
 997 #ifndef TIZEN_WLAN_BOARD_SPRD
 998                 param.freq = WFD_FREQ_2G;
 999 #endif
1000
1001                 ret = wfd_oem_create_group(manager->oem_ops, &param);
1002                 if (ret < 0) {
1003                         WDS_LOGE("Failed to create group");
1004                         wfd_destroy_group(manager, GROUP_IFNAME);
1005                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1006                         goto failed;
1007                 }
1008
1009                 WDS_LOGD("Succeeded to create pending group");
1010                 memset(manager->local->passphrase, 0x0, PASSPHRASE_LEN_MAX + 1);
1011                 ret = WIFI_DIRECT_ERROR_NONE;
1012                 return_parameters = g_variant_new("(i)", ret);
1013                 goto done;
1014
1015         } else if (!g_strcmp0(method_name, "DestroyGroup")) {
1016                 wfd_group_s *group = manager->group;
1017                 if (!group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1018                         WDS_LOGE("Group not exist");
1019                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1020                         goto failed;
1021                 }
1022
1023                 ret = wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1024                 if (ret < 0) {
1025                         WDS_LOGE("Failed to destroy group");
1026                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1027                         goto failed;
1028                 }
1029
1030                 ret = wfd_destroy_group(manager, group->ifname);
1031                 if (ret < 0)
1032                         WDS_LOGE("Failed to destroy group");
1033
1034                 wfd_state_set(manager, WIFI_DIRECT_STATE_ACTIVATED);
1035                 wfd_util_set_wifi_direct_state(WIFI_DIRECT_STATE_ACTIVATED);
1036
1037                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
1038
1039                 wfd_manager_dbus_emit_signal(WFD_MANAGER_GROUP_INTERFACE,
1040                                 "Destroyed", NULL);
1041                 return;
1042
1043         } else if (!g_strcmp0(method_name, "IsGroupOwner")) {
1044                 gboolean result;
1045                 wfd_device_s *local = manager->local;
1046                 result = local->dev_role == WFD_DEV_ROLE_GO;
1047                 WDS_LOGI("Is group owner : [%s]", result ? "Yes" : "No");
1048                 return_parameters = g_variant_new("(b)", result);
1049                 goto done;
1050
1051         } else if (!g_strcmp0(method_name, "IsAutoGroup")) {
1052                 int result;
1053                 if ((result = wfd_group_is_autonomous(manager->group)) < 0)
1054                         result = 0;
1055
1056                 WDS_LOGI("Is autonomous group : [%s]", result ? "Yes" : "No");
1057                 return_parameters = g_variant_new("(b)", result);
1058                 goto done;
1059
1060         } else if (!g_strcmp0(method_name, "ActivatePushButton")) {
1061                 if (manager->local->dev_role != WFD_DEV_ROLE_GO) {
1062                         WDS_LOGE("Wi-Fi Direct is not Group Owner.");
1063                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1064                         goto failed;
1065                 }
1066
1067                 ret = wfd_oem_wps_start(manager->oem_ops, NULL,
1068                                 WFD_WPS_MODE_PBC, NULL);
1069                 if (ret < 0) {
1070                         WDS_LOGE("Failed to start wps");
1071                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1072                         goto failed;
1073                 }
1074                 return_parameters = g_variant_new("(i)", ret);
1075                 goto done;
1076
1077         } else if (!g_strcmp0(method_name, "GetPersistentGroups")) {
1078                 int persistent_group_count = 0;
1079                 wfd_persistent_group_info_s *plist;
1080                 GVariantBuilder *builder_groups = NULL;
1081                 int i = 0;
1082
1083                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1084                         WDS_LOGE("Wi-Fi Direct is not activated.");
1085                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1086                         goto failed;
1087                 }
1088
1089
1090                 ret = wfd_oem_get_persistent_groups(manager->oem_ops,
1091                                 (wfd_oem_persistent_group_s**) &plist, &persistent_group_count);
1092                 if (ret < 0) {
1093                         WDS_LOGE("Error!! wfd_oem_get_persistent_group_info() failed..");
1094                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1095                         goto failed;
1096                 }
1097
1098                 builder_groups = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
1099
1100                 for (i = 0; i < persistent_group_count; i++) {
1101                         GVariantBuilder builder_group;
1102                         g_variant_builder_init(&builder_group, G_VARIANT_TYPE("a{sv}"));
1103
1104                         g_variant_builder_add(&builder_group, "{sv}",
1105                                         "NetworkID",
1106                                         g_variant_new_uint32(plist[i].network_id));
1107                         g_variant_builder_add(&builder_group, "{sv}",
1108                                         "SSID",
1109                                         g_variant_new_string(plist[i].ssid));
1110                         g_variant_builder_add(&builder_group, "{sv}",
1111                                         "GOMacAddress",
1112                                         wfd_manager_dbus_pack_ay(plist[i].go_mac_address, MACADDR_LEN));
1113
1114                         WDS_LOGD("%dth peer [%s]", i, plist[i].ssid);
1115                         g_variant_builder_add_value(builder_groups, g_variant_builder_end(&builder_group));
1116                 }
1117
1118                 ret = WIFI_DIRECT_ERROR_NONE;
1119                 return_parameters = g_variant_new("(iaa{sv})", ret, builder_groups);
1120                 g_variant_builder_unref(builder_groups);
1121                 goto done;
1122
1123         } else if (!g_strcmp0(method_name, "RemovePersistentGroup")) {
1124                 gchar *ssid;
1125                 gchar *mac_address;
1126                 unsigned char go_mac_address[6];
1127                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1128                         WDS_LOGE("Wi-Fi Direct is not activated.");
1129                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1130                         goto failed;
1131                 }
1132
1133                 g_variant_get(parameters, "(&s&s)", &mac_address, &ssid);
1134                 macaddr_atoe(mac_address, go_mac_address);
1135                 WDS_LOGD("Remove persistent group [%s][" MACSTR "]", ssid, MAC2STR(go_mac_address));
1136
1137                 ret = wfd_oem_remove_persistent_group(manager->oem_ops, ssid,
1138                                 go_mac_address);
1139                 if (ret < 0) {
1140                         WDS_LOGE("Failed to remove persistent group");
1141                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1142                         goto failed;
1143                 }
1144                 return_parameters = g_variant_new("(i)", ret);
1145                 goto done;
1146
1147         } else if (!g_strcmp0(method_name, "SetPassphrase")) {
1148                 gchar *passphrase;
1149                 int passphrase_len = 0;
1150                 wfd_group_s *group = manager->group;
1151
1152                 if (group) {
1153                         WDS_LOGE("Group already exists");
1154                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1155                         goto failed;
1156                 }
1157
1158                 g_variant_get(parameters, "(&s)", &passphrase);
1159                 passphrase_len = strlen(passphrase);
1160
1161                 if (passphrase_len < PASSPHRASE_LEN_MIN ||
1162                                 passphrase_len > PASSPHRASE_LEN_MAX) {
1163                         WDS_LOGE("Passphrase length incorrect [%s]:[%d]",
1164                                         passphrase, passphrase_len);
1165                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1166                         goto failed;
1167                 }
1168
1169                 g_strlcpy(manager->local->passphrase, passphrase, PASSPHRASE_LEN_MAX + 1);
1170                 WDS_LOGI("Passphrase string [%s]", manager->local->passphrase);
1171
1172                 ret = WIFI_DIRECT_ERROR_NONE;
1173                 return_parameters = g_variant_new("(i)", ret);
1174                 goto done;
1175
1176         } else if (!g_strcmp0(method_name, "GetPassphrase")) {
1177                 wfd_group_s *group = manager->group;
1178                 if (!group) {
1179                         WDS_LOGE("Group not exist");
1180                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1181                         goto failed;
1182                 }
1183
1184                 if (group->role == WFD_DEV_ROLE_GC) {
1185                         WDS_LOGE("Device is not GO");
1186                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1187                         goto failed;
1188                 }
1189
1190                 ret = WIFI_DIRECT_ERROR_NONE;
1191                 return_parameters = g_variant_new("(is)", ret, group->passphrase);
1192                 WDS_LOGI("group->pass : [%s]", group->passphrase);
1193                 goto done;
1194
1195
1196         } else if (!g_strcmp0(method_name, "SetPersistentGroupEnabled")) {
1197                 gboolean enabled;
1198
1199                 g_variant_get(parameters, "(b)", &enabled);
1200                 WDS_LOGI("Activate Persistent Group : [%s]",
1201                                 enabled ? "True" : "False");
1202                 if (enabled)
1203                         manager->local->group_flags |= WFD_GROUP_FLAG_PERSISTENT;
1204                 else
1205                         manager->local->group_flags &= ~(WFD_GROUP_FLAG_PERSISTENT);
1206                 ret = WIFI_DIRECT_ERROR_NONE;
1207                 return_parameters = g_variant_new("(i)", ret);
1208                 goto done;
1209
1210         } else if (!g_strcmp0(method_name, "IsPersistentGroupEnabled")) {
1211                 gboolean result;
1212                 result = ((manager->local->group_flags &
1213                                         WFD_GROUP_FLAG_PERSISTENT)
1214                                 == WFD_GROUP_FLAG_PERSISTENT);
1215                 WDS_LOGI("Is persistent group : [%s]", result ? "Yes" : "No");
1216                 return_parameters = g_variant_new("(b)", result);
1217                 goto done;
1218
1219         } else {
1220                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1221                 goto failed;
1222         }
1223
1224 done:
1225         WFD_DBUS_REPLY_PARAMS(invocation, return_parameters);
1226         return;
1227
1228 failed:
1229         wfd_error_set_gerror(ret, &err);
1230         g_dbus_method_invocation_return_gerror(invocation, err);
1231         g_clear_error(&err);
1232         return;
1233 }
1234
1235 static void __wfd_manager_config_iface_handler(const gchar *method_name,
1236                                               GVariant    *parameters,
1237                                               GDBusMethodInvocation *invocation)
1238 {
1239         int ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1240         wfd_manager_s *manager = wfd_get_manager();
1241         GVariant *return_parameters = NULL;
1242         GError *err = NULL;
1243         WDS_LOGD("%s", method_name);
1244
1245         if (!g_strcmp0(method_name, "GetDeviceName")) {
1246                 char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN+1] = {0, };
1247
1248                 ret = wfd_local_get_dev_name(device_name);
1249                 if (ret < 0) {
1250                         WDS_LOGE("Failed to get device name");
1251                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1252                         goto failed;
1253                 } else {
1254
1255                         ret = WIFI_DIRECT_ERROR_NONE;
1256                         return_parameters = g_variant_new("(is)", ret, device_name);
1257                 }
1258                 goto done;
1259
1260         } else if (!g_strcmp0(method_name, "SetDeviceName")) {
1261                 const char *device_name = NULL;
1262                 g_variant_get(parameters, "(&s)", &device_name);
1263
1264                 ret = wfd_local_set_dev_name((char *)device_name);
1265                 if (ret < 0) {
1266                         WDS_LOGE("Failed to set device name");
1267                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1268                         goto failed;
1269                 }
1270
1271                 ret = WIFI_DIRECT_ERROR_NONE;
1272                 return_parameters = g_variant_new("(i)", ret);
1273                 goto done;
1274
1275         } else if (!g_strcmp0(method_name, "GetWpsPin")) {
1276                 wfd_session_s *session = (wfd_session_s*) manager->session;
1277                 if (!session || manager->auto_pin[0] != 0) {
1278                         WDS_LOGE("Session not exist");
1279                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1280                         goto failed;
1281                 }
1282
1283                 if (session->wps_pin[0] == '\0') {
1284                         WDS_LOGE("WPS PIN is not set");
1285                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1286                         goto failed;
1287                 }
1288
1289                 ret = WIFI_DIRECT_ERROR_NONE;
1290                 return_parameters = g_variant_new("(is)", ret, session->wps_pin);
1291                 goto done;
1292
1293         } else if (!g_strcmp0(method_name, "SetWpsPin")) {
1294                 const char *pin = NULL;
1295                 wfd_session_s *session = (wfd_session_s*) manager->session;
1296
1297                 g_variant_get(parameters, "(&s)", &pin);
1298
1299                 if (!session) {
1300                         WDS_LOGE("Session not exist");
1301                         g_strlcpy(manager->auto_pin, pin, strlen(pin) + 1);
1302                 } else {
1303                         g_strlcpy(session->wps_pin, pin, strlen(pin) + 1);
1304                 }
1305
1306                 ret = WIFI_DIRECT_ERROR_NONE;
1307                 return_parameters = g_variant_new("(i)", ret);
1308                 goto done;
1309
1310         } else if (!g_strcmp0(method_name, "GetSupportedWpsMode")) {
1311                 int config_methods = 0;
1312
1313                 ret = wfd_local_get_supported_wps_mode(&config_methods);
1314                 if (ret < 0) {
1315                         WDS_LOGE("Failed to get supported wps mode");
1316                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1317                         goto failed;
1318                 }
1319
1320                 ret = WIFI_DIRECT_ERROR_NONE;
1321                 return_parameters = g_variant_new("(ii)", ret, config_methods);
1322                 goto done;
1323
1324         } else if (!g_strcmp0(method_name, "GetReqWpsMode")) {
1325                 int wps_mode = 0;
1326
1327                 ret = wfd_manager_get_req_wps_mode(&wps_mode);
1328                 if (ret < 0) {
1329                         WDS_LOGE("Failed to get request wps mode");
1330                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1331                         goto failed;
1332                 }
1333
1334                 ret = WIFI_DIRECT_ERROR_NONE;
1335                 return_parameters = g_variant_new("(ii)", ret, wps_mode);
1336                 goto done;
1337
1338         } else if (!g_strcmp0(method_name, "SetReqWpsMode")) {
1339                 int type = 0;
1340
1341                 g_variant_get(parameters, "(i)", &type);
1342                 ret = wfd_manager_set_req_wps_mode(type);
1343                 if(ret < 0) {
1344                         WDS_LOGE("Failed to set request wps mode");
1345                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1346                         goto failed;
1347                 }
1348
1349                 ret = WIFI_DIRECT_ERROR_NONE;
1350                 return_parameters = g_variant_new("(i)", ret);
1351                 goto done;
1352
1353         } else if (!g_strcmp0(method_name, "GetLocalWpsMode")) {
1354                 int wps_mode = 0;
1355
1356                 ret = wfd_local_get_wps_mode(&wps_mode);
1357                 if (ret < 0) {
1358                         WDS_LOGE("Failed to get request wps mode");
1359                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1360                         goto failed;
1361                 }
1362
1363                 ret = WIFI_DIRECT_ERROR_NONE;
1364                 return_parameters = g_variant_new("(ii)", ret, wps_mode);
1365                 goto done;
1366
1367         } else if (!g_strcmp0(method_name, "GetIPAddress")) {
1368                 char ip_addr_str[IPSTR_LEN+1] = {0, };
1369
1370                 if (manager->state < WIFI_DIRECT_STATE_CONNECTED) {
1371                         WDS_LOGE("Device is not connected yet");
1372                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1373                         goto failed;
1374                 }
1375
1376                 ret = wfd_local_get_ip_addr((char *)ip_addr_str);
1377                 if (ret < 0) {
1378                         WDS_LOGE("Failed to get local IP address");
1379                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1380                         goto failed;
1381                 }
1382
1383                 return_parameters = g_variant_new("(is)", ret, ip_addr_str);
1384                 WDS_LOGI("IP addr : [%s]", ip_addr_str);
1385                 goto done;
1386
1387         } else if (!g_strcmp0(method_name, "GetMacAddress")) {
1388                 char device_mac[MACSTR_LEN+1] = {0, };
1389
1390                 ret = wfd_local_get_dev_mac(device_mac);
1391                 if (ret < 0) {
1392                         WDS_LOGE("Failed to get device mac");
1393                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1394                         goto failed;
1395                 }
1396
1397                 ret = WIFI_DIRECT_ERROR_NONE;
1398                 return_parameters = g_variant_new("(is)", ret, device_mac);
1399                 goto done;
1400
1401         } else if (!g_strcmp0(method_name, "GetGoIntent")) {
1402                 int go_intent = 0;
1403
1404                 ret = wfd_manager_get_go_intent(&go_intent);
1405                 if (ret < 0) {
1406                         WDS_LOGE("Failed to get GO intent");
1407                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1408                         goto failed;
1409                 }
1410
1411                 ret = WIFI_DIRECT_ERROR_NONE;
1412                 return_parameters = g_variant_new("(ii)", ret, go_intent);
1413                 goto done;
1414
1415         } else if (!g_strcmp0(method_name, "SetGoIntent")) {
1416                 int go_intent = 0;
1417
1418                 g_variant_get(parameters, "(i)", &go_intent);
1419                 ret = wfd_manager_set_go_intent(go_intent);
1420                 if(ret < 0) {
1421                         WDS_LOGE("Failed to set GO intent");
1422                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1423                         goto failed;
1424                 }
1425
1426                 ret = WIFI_DIRECT_ERROR_NONE;
1427                 return_parameters = g_variant_new("(i)", ret);
1428                 goto done;
1429
1430         } else if (!g_strcmp0(method_name, "GetMaxClient")) {
1431                 int max_client = 0;
1432
1433                 ret = wfd_manager_get_max_station(&max_client);
1434                 if (ret < 0) {
1435                         WDS_LOGE("Failed to get max station");
1436                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1437                         goto failed;
1438                 }
1439
1440                 ret = WIFI_DIRECT_ERROR_NONE;
1441                 return_parameters = g_variant_new("(ii)", ret, max_client);
1442                 goto done;
1443
1444         } else if (!g_strcmp0(method_name, "SetMaxClient")) {
1445                 int max_client = 0;
1446                 g_variant_get(parameters, "(i)", &max_client);
1447
1448                 ret = wfd_manager_set_max_station(max_client);
1449                 if(ret < 0) {
1450                         WDS_LOGE("Failed to set max station");
1451                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1452                         goto failed;
1453                 }
1454
1455                 ret = WIFI_DIRECT_ERROR_NONE;
1456                 return_parameters = g_variant_new("(i)", ret);
1457                 goto done;
1458
1459         } else if (!g_strcmp0(method_name, "SetAutoConnectionMode")) {
1460                 gboolean mode = FALSE;
1461
1462                 g_variant_get(parameters, "(b)", &mode);
1463                 ret = wfd_manager_set_autoconnection(mode);
1464                 if(ret < 0) {
1465                         WDS_LOGE("Failed to set autoconnection");
1466                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1467                         goto failed;
1468                 }
1469
1470                 ret = WIFI_DIRECT_ERROR_NONE;
1471                 return_parameters = g_variant_new("(i)", ret);
1472                 goto done;
1473
1474         } else if (!g_strcmp0(method_name, "IsAutoConnectionMode")) {
1475                 int mode = 0;
1476
1477                 ret = wfd_manager_get_autoconnection(&mode);
1478                 if (ret < 0) {
1479                         WDS_LOGE("Failed to get autoconnection");
1480                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1481                         goto failed;
1482                 }
1483
1484                 ret = WIFI_DIRECT_ERROR_NONE;
1485                 return_parameters = g_variant_new("(ib)", ret, mode);
1486                 goto done;
1487
1488         } else if (!g_strcmp0(method_name, "GetOperatingChannel")) {
1489                 int channel = 0;
1490
1491                 wfd_group_s *group = manager->group;
1492                 if (!group) {
1493                         WDS_LOGE("Group not exist");
1494                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1495                         goto failed;
1496                 }
1497
1498                 channel = wfd_util_freq_to_channel(group->freq);
1499                 if (channel < 0) {
1500                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1501                         goto failed;
1502                 }
1503
1504                 ret = WIFI_DIRECT_ERROR_NONE;
1505                 return_parameters = g_variant_new("(ii)", ret, channel);
1506                 goto done;
1507
1508         } else if (!g_strcmp0(method_name, "SetAutoConnectionPeer")) {
1509                 ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1510                 goto failed;
1511
1512         } else if (!g_strcmp0(method_name, "GetInterfaceName")) {
1513                 wfd_group_s *group = (wfd_group_s *)manager->group;
1514                 if (!group) {
1515                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1516                         goto failed;
1517                 }
1518                 ret = WIFI_DIRECT_ERROR_NONE;
1519                 return_parameters = g_variant_new("(is)", ret, group->ifname);
1520                 goto done;
1521
1522         } else if (!g_strcmp0(method_name, "GetSubnetMask")) {
1523                         char *get_str = NULL;
1524                         char subnet_mask[IPSTR_LEN+1] = {0, };
1525
1526                         get_str = vconf_get_str(VCONFKEY_SUBNET_MASK);
1527                         if (!get_str) {
1528                                 WDS_LOGE("Get Subnet Mask failed");
1529                                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1530                                 goto failed;
1531                         }
1532                         WDS_LOGD("VCONFKEY_SUBNET_MASK(%s) : %s", VCONFKEY_SUBNET_MASK,
1533                                 get_str);
1534                         ret = WIFI_DIRECT_ERROR_NONE;
1535                         g_strlcpy(subnet_mask, get_str, IPSTR_LEN + 1);
1536                         return_parameters = g_variant_new("(is)", ret, subnet_mask);
1537                         free(get_str);
1538                         goto done;
1539
1540         } else if (!g_strcmp0(method_name, "GetGateway")) {
1541                         char *get_str = NULL;
1542                         char gateway_addr[IPSTR_LEN+1] = {0, };
1543                         get_str = vconf_get_str(VCONFKEY_GATEWAY);
1544                         if (!get_str) {
1545                                 WDS_LOGE("Get Gateway failed");
1546                                 ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1547                                 goto failed;
1548                         }
1549                         WDS_LOGD("VCONFKEY_GATEWAY_ADDR(%s) : %s", VCONFKEY_GATEWAY,
1550                                 get_str);
1551                         ret = WIFI_DIRECT_ERROR_NONE;
1552                         g_strlcpy(gateway_addr, get_str, IPSTR_LEN + 1);
1553                         return_parameters = g_variant_new("(is)", ret, gateway_addr);
1554                         free(get_str);
1555                         goto done;
1556
1557         } else if (!g_strcmp0(method_name, "GetSessionTimer")) {
1558
1559                 int session_timer = 0;
1560                 ret = WIFI_DIRECT_ERROR_NONE;
1561                 session_timer = manager->session_timer;
1562                 WDS_LOGD("Get Session Timer value is %d", session_timer);
1563                 return_parameters = g_variant_new("(ii)", ret, session_timer);
1564                 goto done;
1565
1566         } else if (!g_strcmp0(method_name, "SetSessionTimer")) {
1567
1568                 int session_timer = 0;
1569                 g_variant_get(parameters, "(i)", &session_timer);
1570                 WDS_LOGD("Set Session Timer value is %d", session_timer);
1571                 manager->session_timer = session_timer;
1572                 ret = WIFI_DIRECT_ERROR_NONE;
1573                 return_parameters = g_variant_new("(i)", ret);
1574                 goto done;
1575
1576         } else if (!g_strcmp0(method_name, "SetAutoGroupRemoval")) {
1577                 gboolean enable;
1578
1579
1580                 g_variant_get(parameters, "(b)", &enable);
1581                 WDS_LOGE("Activate Auto Group Removal Mode : [%s]",
1582                                 enable ? "True" : "False");
1583
1584                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1585                         WDS_LOGE("Wi-Fi Direct is not activated.");
1586                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1587                         goto failed;
1588                 }
1589
1590                 if (enable) {
1591                         manager->auto_group_remove_enable = TRUE;
1592
1593                         /* Enable Group destroy only if state is connecting */
1594                         if (manager->state == WIFI_DIRECT_STATE_CONNECTING) {
1595                                 WDS_LOGE("Wi-Fi Direct state is CONNECTING");
1596                                 ret = WIFI_DIRECT_ERROR_NONE;
1597                                 return_parameters = g_variant_new("(i)", ret);
1598                                 goto done;
1599                         }
1600                         /* Remove group immediately if no connected peer found */
1601                         if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
1602                                 wfd_group_s *group = (wfd_group_s*) manager->group;
1603                                 if (group && !group->member_count
1604                                                   && wfd_util_is_remove_group_allowed())
1605                                         wfd_oem_destroy_group(manager->oem_ops, group->ifname);
1606                           }
1607
1608                 } else
1609                         manager->auto_group_remove_enable = FALSE;
1610
1611
1612                 ret = WIFI_DIRECT_ERROR_NONE;
1613                 return_parameters = g_variant_new("(i)", ret);
1614                 goto done;
1615
1616         }  else {
1617                 WDS_LOGE("method not handled");
1618                 ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1619                 goto failed;
1620         }
1621
1622 done:
1623         WFD_DBUS_REPLY_PARAMS(invocation, return_parameters);
1624         return;
1625
1626 failed:
1627         wfd_error_set_gerror(ret, &err);
1628         g_dbus_method_invocation_return_gerror(invocation, err);
1629         g_clear_error(&err);
1630         return;
1631 }
1632
1633 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
1634 static void __wfd_manager_service_iface_handler(const gchar *method_name,
1635                                                GVariant    *parameters,
1636                                                GDBusMethodInvocation *invocation)
1637 {
1638         int ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1639         wfd_manager_s *manager = wfd_get_manager();
1640         GVariant *return_parameters = NULL;
1641         GError *err = NULL;
1642         WDS_LOGD("%s", method_name);
1643
1644         if (!g_strcmp0(method_name, "StartDiscovery")) {
1645                 const char *mac_address = NULL;
1646                 int service_type;
1647                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1648
1649                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1650                         WDS_LOGE("Wi-Fi Direct is not activated.");
1651                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1652                         goto failed;
1653                 }
1654
1655                 g_variant_get(parameters, "(i&s)", &service_type, &mac_address);
1656                 WDS_LOGD("Service type [%d]", service_type);
1657                 macaddr_atoe(mac_address, mac_addr);
1658
1659                 ret = wfd_oem_start_service_discovery(manager->oem_ops,
1660                                 mac_addr, service_type);
1661                 if (ret < 0) {
1662                         WDS_LOGE("Failed to start service discovery");
1663                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1664                         goto failed;
1665                 }
1666
1667                 WFD_DBUS_REPLY_ERROR_NONE(invocation);
1668
1669                 wfd_manager_dbus_emit_signal(WFD_MANAGER_SERVICE_INTERFACE,
1670                                 "DiscoveryStarted", NULL);
1671                 return;
1672
1673         } else if (!g_strcmp0(method_name, "StopDiscovery")) {
1674                 const char *mac_address = NULL;
1675                 int service_type;
1676                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1677
1678                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1679                         WDS_LOGE("Wi-Fi Direct is not activated.");
1680                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1681                         goto failed;
1682                 }
1683
1684                 g_variant_get(parameters, "(i&s)", &service_type, &mac_address);
1685                 WDS_LOGD("Service type [%d]", service_type);
1686                 macaddr_atoe(mac_address, mac_addr);
1687
1688                 ret = wfd_oem_cancel_service_discovery(manager->oem_ops,
1689                                 mac_addr, service_type);
1690                 if (ret < 0) {
1691                         WDS_LOGE("Failed to cancel service discovery");
1692                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1693                         goto failed;
1694                 }
1695                 ret = WIFI_DIRECT_ERROR_NONE;
1696                 return_parameters = g_variant_new("(i)", ret);
1697                 goto done;
1698
1699         } else if (!g_strcmp0(method_name, "Register")) {
1700                 int service_type;
1701                 int service_id = 0;
1702                 const char *info_str = NULL;
1703
1704                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1705                         WDS_LOGE("Wi-Fi Direct is not activated.");
1706                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1707                         goto failed;
1708                 }
1709
1710                 g_variant_get(parameters, "(i&s)", &service_type, &info_str);
1711                 WDS_LOGD("Register service [%d: %s]", service_type, info_str);
1712
1713                 ret = wfd_service_add(service_type, (char *)info_str, &service_id);
1714                 if (ret < 0) {
1715                         WDS_LOGE("Failed to add service");
1716                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1717                         goto failed;
1718                 }
1719
1720                 ret = WIFI_DIRECT_ERROR_NONE;
1721                 return_parameters = g_variant_new("(ii)", ret, service_id);
1722                 goto done;
1723
1724         } else if (!g_strcmp0(method_name, "Deregister")) {
1725                 int service_id = 0;
1726
1727                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1728                         WDS_LOGE("Wi-Fi Direct is not activated.");
1729                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1730                         goto failed;
1731                 }
1732
1733                 g_variant_get(parameters, "(i)", &service_id);
1734                 WDS_LOGD("Service id [%d]", service_id);
1735
1736                 ret = wfd_service_del(service_id);
1737                 if (ret < 0) {
1738                         WDS_LOGE("Failed to delete service");
1739                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1740                         goto failed;
1741                 }
1742
1743                 ret = WIFI_DIRECT_ERROR_NONE;
1744                 return_parameters = g_variant_new("(i)", ret);
1745                 goto done;
1746
1747         } else {
1748                 WDS_LOGD("method not handled");
1749                 ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1750                 goto failed;
1751         }
1752
1753 done:
1754         WFD_DBUS_REPLY_PARAMS(invocation, return_parameters);
1755         return;
1756
1757 failed:
1758         wfd_error_set_gerror(ret, &err);
1759         g_dbus_method_invocation_return_gerror(invocation, err);
1760         g_clear_error(&err);
1761         return;
1762 }
1763 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
1764
1765 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
1766 static void __wfd_manager_display_iface_handler(const gchar *method_name,
1767                                                GVariant    *parameters,
1768                                                GDBusMethodInvocation *invocation)
1769 {
1770         int ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1771         wfd_manager_s *manager = wfd_get_manager();
1772         GVariant *return_parameters = NULL;
1773         GError *err = NULL;
1774         WDS_LOGD("%s", method_name);
1775
1776         if (!g_strcmp0(method_name, "Init")) {
1777                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1778                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1779                         goto failed;
1780                 }
1781
1782                 wfd_device_s * device = manager->local;
1783
1784                 ret = wfd_oem_miracast_init(manager->oem_ops, TRUE);
1785                 if (ret < 0) {
1786                         WDS_LOGE("Failed to initialize display");
1787                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1788                         goto failed;
1789                 }
1790
1791                 device->display.type = WIFI_DISPLAY_DEFAULT_TYPE;
1792                 device->display.port = WIFI_DISPLAY_DEFAULT_PORT;
1793                 device->display.availability = WIFI_DISPLAY_DEFAULT_AVAIL;
1794                 device->display.hdcp_support = WIFI_DISPLAY_DEFAULT_HDCP;
1795
1796                 ret = WIFI_DIRECT_ERROR_NONE;
1797                 return_parameters = g_variant_new("(i)", ret);
1798                 goto done;
1799
1800         } else if (!g_strcmp0(method_name, "Deinit")) {
1801                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1802                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1803                         goto failed;
1804                 }
1805
1806                 wfd_device_s * device = manager->local;
1807
1808                 ret = wfd_oem_miracast_init(manager->oem_ops, FALSE);
1809                 if (ret < 0) {
1810                         WDS_LOGE("Failed to deinitialize display");
1811                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1812                         goto failed;
1813                 }
1814
1815                 memset(&(device->display), 0x0, sizeof(wfd_display_type_e));
1816
1817                 ret = WIFI_DIRECT_ERROR_NONE;
1818                 return_parameters = g_variant_new("(i)", ret);
1819                 goto done;
1820
1821         } else if (!g_strcmp0(method_name, "SetConfig")) {
1822                 int type, port, hdcp;
1823                 g_variant_get(parameters, "(iii)", &type, &port, &hdcp);
1824
1825                 if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1826                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1827                         goto failed;
1828                 }
1829
1830                 WDS_LOGD("type %d port %d hdcp %d", type, port, hdcp);
1831
1832                 ret = wfd_manager_set_display_device(type, port, hdcp);
1833                 if(ret < 0) {
1834                         WDS_LOGE("Failed to set display device settings");
1835                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1836                         goto failed;
1837                 }
1838
1839                 ret = WIFI_DIRECT_ERROR_NONE;
1840                 return_parameters = g_variant_new("(i)", ret);
1841                 goto done;
1842
1843         } else if (!g_strcmp0(method_name, "SetAvailiability")) {
1844                 int availability;
1845                 g_variant_get(parameters, "(i)", &availability);
1846
1847                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1848                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1849                         goto failed;
1850                 }
1851
1852                 ret = wfd_manager_set_session_availability(availability);
1853                 if (ret < 0) {
1854                         WDS_LOGE("Failed to set session availability");
1855                         ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1856                         goto failed;
1857                 }
1858
1859                 ret = WIFI_DIRECT_ERROR_NONE;
1860                 return_parameters = g_variant_new("(i)", ret);
1861                 goto done;
1862
1863         } else if (!g_strcmp0(method_name, "GetPeerType")) {
1864                 wfd_device_s *peer = NULL;
1865                 const char *mac_address = NULL;
1866                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1867
1868                 g_variant_get(parameters, "(&s)", &mac_address);
1869                 macaddr_atoe(mac_address, mac_addr);
1870
1871                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1872                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1873                         goto failed;
1874                 }
1875
1876                 peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
1877                 if(!peer) {
1878                         WDS_LOGE("Failed to get peer");
1879                         ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1880                         goto failed;
1881                 }
1882
1883                 ret = WIFI_DIRECT_ERROR_NONE;
1884                 return_parameters = g_variant_new("(ii)", ret, peer->display.type);
1885                 goto done;
1886
1887         } else if (!g_strcmp0(method_name, "GetPeerAvailability")) {
1888                 wfd_device_s *peer = NULL;
1889                 const char *mac_address = NULL;
1890                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1891
1892                 g_variant_get(parameters, "(&s)", &mac_address);
1893                 macaddr_atoe(mac_address, mac_addr);
1894
1895                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1896                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1897                         goto failed;
1898                 }
1899
1900                 peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
1901                 if(!peer) {
1902                         WDS_LOGE("Failed to get peer");
1903                         ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1904                         goto failed;
1905                 }
1906
1907                 ret = WIFI_DIRECT_ERROR_NONE;
1908                 return_parameters = g_variant_new("(ii)", ret, peer->display.availability);
1909                 goto done;
1910
1911         } else if (!g_strcmp0(method_name, "GetPeerHdcp")) {
1912                 wfd_device_s *peer = NULL;
1913                 const char *mac_address = NULL;
1914                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1915
1916                 g_variant_get(parameters, "(&s)", &mac_address);
1917                 macaddr_atoe(mac_address, mac_addr);
1918
1919                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1920                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1921                         goto failed;
1922                 }
1923
1924                 peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
1925                 if(!peer) {
1926                         WDS_LOGE("Failed to get peer");
1927                         ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1928                         goto failed;
1929                 }
1930
1931                 ret = WIFI_DIRECT_ERROR_NONE;
1932                 return_parameters = g_variant_new("(ii)", ret, peer->display.hdcp_support);
1933                 goto done;
1934
1935         } else if (!g_strcmp0(method_name, "GetPeerPort")) {
1936                 wfd_device_s *peer = NULL;
1937                 const char *mac_address = NULL;
1938                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1939
1940                 g_variant_get(parameters, "(&s)", &mac_address);
1941                 macaddr_atoe(mac_address, mac_addr);
1942
1943                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1944                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1945                         goto failed;
1946                 }
1947
1948                 peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
1949                 if(!peer) {
1950                         WDS_LOGE("Failed to get peer");
1951                         ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1952                         goto failed;
1953                 }
1954
1955                 ret = WIFI_DIRECT_ERROR_NONE;
1956                 return_parameters = g_variant_new("(ii)", ret, peer->display.port);
1957                 goto done;
1958
1959         } else if (!g_strcmp0(method_name, "GetPeerThroughput")) {
1960                 wfd_device_s *peer = NULL;
1961                 const char *mac_address = NULL;
1962                 unsigned char mac_addr[MACADDR_LEN] = {0, };
1963
1964                 g_variant_get(parameters, "(&s)", &mac_address);
1965                 macaddr_atoe(mac_address, mac_addr);
1966
1967                 if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
1968                         ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
1969                         goto failed;
1970                 }
1971
1972                 peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
1973                 if(!peer) {
1974                         WDS_LOGE("Failed to get peer");
1975                         ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
1976                         goto failed;
1977                 }
1978
1979                 ret = WIFI_DIRECT_ERROR_NONE;
1980                 return_parameters = g_variant_new("(ii)", ret, peer->display.max_tput);
1981                 goto done;
1982
1983         } else {
1984                 WDS_LOGD("method not handled");
1985                 ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
1986                 goto failed;
1987         }
1988
1989 done:
1990         WFD_DBUS_REPLY_PARAMS(invocation, return_parameters);
1991         return;
1992
1993 failed:
1994         wfd_error_set_gerror(ret, &err);
1995         g_dbus_method_invocation_return_gerror(invocation, err);
1996         g_clear_error(&err);
1997         return;
1998 }
1999 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
2000
2001 static struct {
2002         guint reg_id;
2003         const gchar *iface_name;
2004         void (*function) (const gchar *method_name,
2005                          GVariant    *parameters,
2006                          GDBusMethodInvocation *invocation);
2007 } wfd_manager_iface_map[] = {
2008         {
2009                 0,
2010                 WFD_MANAGER_MANAGE_INTERFACE,
2011                 __wfd_manager_manage_iface_handler
2012         },
2013         {
2014                 0,
2015                 WFD_MANAGER_GROUP_INTERFACE,
2016                 __wfd_manager_group_iface_handler
2017         },
2018         {
2019                 0,
2020                 WFD_MANAGER_CONFIG_INTERFACE,
2021                 __wfd_manager_config_iface_handler
2022         },
2023 #ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
2024         {
2025                 0,
2026                 WFD_MANAGER_SERVICE_INTERFACE,
2027                 __wfd_manager_service_iface_handler
2028         },
2029 #endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
2030 #ifdef TIZEN_FEATURE_WIFI_DISPLAY
2031         {
2032                 0,
2033                 WFD_MANAGER_DISPLAY_INTERFACE,
2034                 __wfd_manager_display_iface_handler
2035         },
2036 #endif /* TIZEN_FEATURE_WIFI_DISPLAY */
2037         {
2038                 0,
2039                 NULL,
2040                 NULL
2041         }
2042 };
2043
2044 // GDBus method handler
2045 static void wfd_manager_method_call_handler (GDBusConnection       *connection,
2046                                              const gchar           *sender,
2047                                              const gchar           *object_path,
2048                                              const gchar           *interface_name,
2049                                              const gchar           *method_name,
2050                                              GVariant              *parameters,
2051                                              GDBusMethodInvocation *invocation,
2052                                              gpointer               user_data)
2053 {
2054         int count = 0;
2055
2056         /* Method Call */
2057         WDS_LOGD("interface : [%s], method : [%s]", interface_name, method_name);
2058         DBUS_DEBUG_VARIANT(parameters);
2059
2060         while (wfd_manager_iface_map[count].iface_name != NULL) {
2061                 if (!g_strcmp0(interface_name, wfd_manager_iface_map[count].iface_name)) {
2062
2063                         wfd_manager_iface_map[count].function(method_name,
2064                                                               parameters,
2065                                                               invocation);
2066                         break;
2067                 }
2068                 count++;
2069         }
2070 }
2071
2072 static const GDBusInterfaceVTable wfd_manager_interface_vtable =
2073                                 {wfd_manager_method_call_handler, NULL, NULL};
2074
2075 void wfd_manager_dbus_unregister(void)
2076 {
2077         int count = 0;
2078
2079         wfd_error_deregister();
2080
2081         while (wfd_manager_iface_map[count].iface_name != NULL) {
2082                 wfd_manager_dbus_iface_unregister(wfd_manager_iface_map[count].reg_id);
2083                 count++;
2084         }
2085 }
2086
2087 gboolean wfd_manager_dbus_register(void)
2088 {
2089         GDBusNodeInfo *node_info = NULL;
2090         GError *Error = NULL;
2091         int count = 0;
2092
2093         wfd_error_register();
2094
2095         node_info = g_dbus_node_info_new_for_xml(wfd_manager_introspection_xml, &Error);
2096         if (node_info == NULL) {
2097                 WDS_LOGE("Failed to get node info, Error: %s", Error->message);
2098                 g_clear_error(&Error);
2099                 return FALSE;
2100         }
2101
2102         while (wfd_manager_iface_map[count].iface_name != NULL) {
2103                 wfd_manager_iface_map[count].reg_id =
2104                         wfd_manager_dbus_iface_register(wfd_manager_iface_map[count].iface_name,
2105                                                         WFD_MANAGER_PATH,
2106                                                         node_info,
2107                                                         &wfd_manager_interface_vtable);
2108
2109                 WDS_LOGD("Registered Interface [%d, %s]",
2110                                         wfd_manager_iface_map[count].reg_id,
2111                                         wfd_manager_iface_map[count].iface_name);
2112
2113                 count++;
2114         }
2115
2116         g_dbus_node_info_unref(node_info);
2117         return TRUE;
2118 }