daemon/access_control/ACLManager.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "ACLManager.h"
  18
  19 #define MAC_ADDRESS_LEN 17
  20 #define PASSKEY_DATAS 11
  21 #define PASSKEY_LEN 4
  22
  23 typedef struct {
  24         conv::acl_manager::PopupCallback callback;
  25         void *userdata;
  26 } usercallback_info;
  27
  28 usercallback_info *info = NULL;
  29
  30 static char passkey[5];
  31
  32 ACLResult conv::acl_manager::PasskeyChecker(char *input_passkey)
  33 {
  34         bool isShowPopup = false;
  35         const char *app_id = "org.tizen.d2d-conv-syspopup";
  36
  37         int ret = app_manager_is_running(app_id, &isShowPopup);
  38         if (ret != APP_MANAGER_ERROR_NONE){
  39                 _D("app_manager_is_running() is error.");
  40                 return ACLResult_Error;
  41         }
  42
  43         if(isShowPopup == true) {
  44                 _D("org.tizen.d2d-conv-syspopup is running.");
  45
  46                 if (!strcmp(passkey, input_passkey)){
  47                         _D("correct");
  48                         return ACLResult_OK;
  49
  50                 } else {
  51                         _D("incorrect");
  52                         return ACLResult_Error;
  53                 }
  54
  55         } else {
  56                 _D("org.tizen.d2d-conv-syspopup is closed.");
  57                 return ACLResult_Close;
  58         }
  59 }
  60
  61 void CreatePasskey()
  62 {
  63         char token[PASSKEY_DATAS] = "0123456789";
  64         unsigned int time_seed = (unsigned int)time(NULL);
  65
  66         srand(time_seed);
  67
  68         for (int index = 0; index < PASSKEY_LEN; index++) {
  69                 int random_num = rand_r(&time_seed) % (PASSKEY_DATAS - 1);
  70                 passkey[index] = token[random_num];
  71         }
  72
  73         passkey[PASSKEY_LEN] = '\0';
  74 }
  75
  76 static void LaunchPasskeyInputPopupCallback(app_control_h request, app_control_h reply, app_control_result_e result_e, void *user_data)
  77 {
  78         usercallback_info *info = (usercallback_info *)user_data;
  79
  80         int result = -1;
  81         char *passkey;
  82
  83         char *reply_message;
  84         app_control_get_extra_data(reply, "REPLY_MESSAGE", &reply_message);
  85
  86         if (!strcmp(reply_message, "CONNECT")) {
  87                 result = ACLResult_Connect;
  88                 app_control_get_extra_data(reply, "PASSKEY", &passkey);
  89         } else if (!strcmp(reply_message, "CANCEL")) {
  90                 result = ACLResult_Cancel;
  91         } else if (!strcmp(reply_message, "CLOSE")) {
  92                 result = ACLResult_Close;
  93         }
  94
  95         info->callback(info->userdata, result, passkey);
  96 }
  97
  98 void conv::acl_manager::LaunchPasskeyInputPopup(PopupCallback callback, void *userdata)
  99 {
 100         bundle *b = NULL;
 101         b = bundle_create();
 102         bundle_add(b, "TYPE", "PASSKEY_INPUT_POPUP");
 103
 104         int ret = syspopup_launch((char *)"d2d-conv-syspopup", b);
 105         if (ret != 0) {
 106                 _E("syspopup_launch Error (%d).", ret);
 107         }
 108
 109         bundle_free(b);
 110
 111         info = (usercallback_info *)malloc(sizeof(usercallback_info)*1);
 112         info->callback = callback;
 113         info->userdata = userdata;
 114
 115         app_control_h app_control;
 116         app_control_create(&app_control);
 117         app_control_set_app_id(app_control, "org.tizen.d2d-conv-syspopup");
 118         app_control_add_extra_data(app_control, "MESSAGE", "REGIST_CALLBACK");
 119         app_control_send_launch_request(app_control, LaunchPasskeyInputPopupCallback, info);
 120         app_control_destroy(app_control);
 121 }
 122
 123 void conv::acl_manager::LaunchPasskeyShowPopup(const char *deviceName)
 124 {
 125         CreatePasskey();
 126
 127         bundle *b = NULL;
 128         b = bundle_create();
 129         bundle_add(b, "TYPE", "PASSKEY_SHOW_POPUP");
 130         bundle_add(b, "DATA_PASSKEY", passkey);
 131         bundle_add(b, "DATA_DEVICE_NAME", deviceName);
 132
 133         int ret = syspopup_launch((char *)"d2d-conv-syspopup", b);
 134         if (ret != 0) {
 135                 _E("syspopup_launch Error (%d).", ret);
 136         }
 137
 138         bundle_free(b);
 139 }
 140
 141 static void LaunchToast(char *type)
 142 {
 143         app_control_h app_control;
 144         app_control_create(&app_control);
 145         app_control_set_app_id(app_control, "org.tizen.d2d-conv-syspopup");
 146         app_control_add_extra_data(app_control, "MESSAGE", type);
 147         app_control_send_launch_request(app_control, LaunchPasskeyInputPopupCallback, info);
 148         app_control_destroy(app_control);
 149 }
 150
 151 void conv::acl_manager::LaunchPopupCancelToast()
 152 {
 153         LaunchToast((char*)"CANCEL");
 154 }
 155
 156 void conv::acl_manager::LaunchPasskeyWrongToast()
 157 {
 158         LaunchToast((char*)"WRONG_PASSKEY");
 159 }
 160
 161 void conv::acl_manager::LaunchAccessAllowedToast()
 162 {
 163         LaunchToast((char*)"ACCESS_ALLOWED");
 164 }
 165
 166 void conv::acl_manager::LaunchAccessRejectedToast()
 167 {
 168         LaunchToast((char*)"REJECTED");
 169 }
 170
 171 static char convert_mac(char c)
 172 {
 173         char convertC = c;
 174         if ((convertC >= 'A') && (convertC <= 'F')) {
 175                 convertC = ((((convertC - 'A') + 10) | 0x02) - 10) + 'A';
 176         } else if ((convertC >= '0') && (convertC <= '9')) {
 177                 convertC = ((convertC - '0') | 0x02);
 178                 if (convertC < 10)
 179                         convertC = convertC + '0';
 180                 else
 181                         convertC = 'A' + (convertC - 10);
 182         } else {
 183                 _E("wrong byte for mac!");
 184         }
 185         return convertC;
 186 }
 187
 188 static int database_initialize(sqlite3 **database, sqlite3_stmt **stmt, const char *query)
 189 {
 190         int ret = sqlite3_open(DB_FILE_NAME, &(*database));
 191         if (ret != SQLITE_OK) {
 192                 _E("Open the database is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 193                 return ret;
 194         }
 195
 196         /*
 197         const char *create_table_query = "create table if not exists DEVICES_INFO(MAC_ADDRESS text(100) NOT NULL PRIMARY KEY, DEVICE_TYPE text(20) NOT NULL, DEVICE_NAME text(50) NOT NULL, ACL_STATE int NOT NULL);";
 198         ret = sqlite3_exec(*database, create_table_query, NULL, NULL, NULL);
 199         if (ret != SQLITE_OK) {
 200                 _E("Create the database table is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 201                 sqlite3_close(*database);
 202                 return ret;
 203         }
 204         */
 205
 206         while (true) {
 207                 ret = sqlite3_exec(*database, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, NULL);
 208                 if (ret != SQLITE_BUSY) {
 209                         if (ret == SQLITE_ERROR) {
 210                                 _E("Transaction begin is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 211                                 sqlite3_close(*database);
 212                                 return ret;
 213                         }
 214                         break;
 215                 }
 216         }
 217
 218         ret = sqlite3_prepare(*database, query, -1, &(*stmt), NULL);
 219         if (ret != SQLITE_OK) {
 220                 _E("Statement prepare is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 221                 return ret;
 222         }
 223
 224         ret = sqlite3_reset(*stmt);
 225         if (ret != SQLITE_OK) {
 226                 _E("Statement reset is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 227                 return ret;
 228         }
 229
 230         ret = sqlite3_clear_bindings(*stmt);
 231         if (ret != SQLITE_OK) {
 232                 _E("Statement binding clear is fail. (%d: %s)", ret, sqlite3_errmsg(*database));
 233                 return ret;
 234         }
 235
 236         return SQLITE_OK;
 237 }
 238
 239 static int database_finalize(sqlite3 *database, sqlite3_stmt *stmt)
 240 {
 241         int ret = sqlite3_finalize(stmt);
 242         if (ret != SQLITE_OK) {
 243                 _E("Statement free is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 244                 sqlite3_close(database);
 245                 return ret;
 246         }
 247
 248         while (true) {
 249                 ret = sqlite3_exec(database, "COMMIT TRANSACTION", NULL, NULL, NULL);
 250                 if (ret != SQLITE_BUSY) {
 251                         if (ret == SQLITE_ERROR) {
 252                                 _E("Transaction commit is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 253                                 sqlite3_close(database);
 254                                 return ret;
 255                         }
 256                         break;
 257                 }
 258         }
 259
 260         ret = sqlite3_close(database);
 261         if (ret != SQLITE_OK) {
 262                 _E("Close the database is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 263                 return ret;
 264         }
 265
 266         return SQLITE_OK;
 267 }
 268
 269 ACLResult conv::acl_manager::SetDeviceInfoAndACL(const char *macAddress, const char *deviceType, const char *deviceName, const char *deviceIP, ACManagerPolicy aclState)
 270 {
 271         sqlite3 *database = NULL;
 272         sqlite3_stmt *stmt = NULL;
 273         const char *insert_device_info_query = "insert into DEVICES_INFO (MAC_ADDRESS, DEVICE_TYPE, DEVICE_NAME, ACL_STATE) values (?, ?, ?, ?);";
 274
 275         int ret = database_initialize(&database, &stmt, insert_device_info_query);
 276         if (ret != SQLITE_OK) {
 277                 return ACLResult_Error;
 278         }
 279
 280         char _mac[MAC_ADDRESS_LEN + 1];
 281         strncpy(_mac, macAddress, MAC_ADDRESS_LEN);
 282         _mac[1] = convert_mac(_mac[1]);
 283         _mac[MAC_ADDRESS_LEN] = '\0';
 284
 285         ret = sqlite3_bind_text(stmt, 1, _mac, strlen(_mac), SQLITE_TRANSIENT);
 286         if (ret != SQLITE_OK) {
 287                 _E("Statement binding the macAddress text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 288         }
 289
 290         ret = sqlite3_bind_text(stmt, 2, deviceType, strlen(deviceType), SQLITE_TRANSIENT);
 291         if (ret != SQLITE_OK) {
 292                 _E("Statement binding the macAddress text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 293         }
 294
 295         ret = sqlite3_bind_text(stmt, 3, deviceName, strlen(deviceName), SQLITE_TRANSIENT);
 296         if (ret != SQLITE_OK) {
 297                 _E("Statement binding the deviceName text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 298         }
 299
 300         ret = sqlite3_bind_int(stmt, 4, aclState);
 301         if (ret != SQLITE_OK) {
 302                 _E("Statement binding the aclState integer is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 303         }
 304
 305         ret = sqlite3_step(stmt);
 306         if (ret != SQLITE_DONE) {
 307                 _E("Statement step is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 308         }
 309
 310         ret = database_finalize(database, stmt);
 311         if (ret != SQLITE_OK) {
 312                 return ACLResult_Error;
 313         }
 314
 315         return ACLResult_OK;
 316 }
 317
 318 ACLResult conv::acl_manager::GetACLState(const char *macAddress, ACManagerPolicy *aclState)
 319 {
 320         sqlite3 *database = NULL;
 321         sqlite3_stmt *stmt = NULL;
 322         const char *get_acl_state_query = "select ACL_STATE from DEVICES_INFO where MAC_ADDRESS=?;";
 323
 324         int ret = database_initialize(&database, &stmt, get_acl_state_query);
 325         if (ret != SQLITE_OK) {
 326                 return ACLResult_Error;
 327         }
 328
 329         char _mac[MAC_ADDRESS_LEN + 1];
 330         strncpy(_mac, macAddress, MAC_ADDRESS_LEN);
 331         _mac[1] = convert_mac(_mac[1]);
 332         _mac[MAC_ADDRESS_LEN] = '\0';
 333
 334         ret = sqlite3_bind_text(stmt, 1, _mac, strlen(_mac), SQLITE_TRANSIENT);
 335         if (ret != SQLITE_OK) {
 336                 _E("MacAddress Bind fail. (%d: %s)", ret, sqlite3_errmsg(database));
 337         }
 338
 339         while (sqlite3_step(stmt) == SQLITE_ROW) {
 340                 *aclState = static_cast<ACManagerPolicy> (sqlite3_column_int(stmt, 0));
 341         }
 342
 343         ret = database_finalize(database, stmt);
 344         if (ret != SQLITE_OK) {
 345                 return ACLResult_Error;
 346         }
 347
 348         return ACLResult_OK;
 349 }
 350
 351 ACLResult conv::acl_manager::AddACLDevice(const char *macAddress, const char *deviceName, const char *deviceIP, ACManagerPolicy *aclState)
 352 {
 353         if (aclState == NULL || macAddress == NULL || deviceName == NULL || deviceIP == NULL) {
 354                 return ACLResult_Error;
 355         }
 356
 357         *aclState = ACMANAGER_POLICY_U2;
 358
 359         int ret = conv::acl_manager::GetACLState(macAddress, aclState);
 360         if (ret != ACLResult_OK) {
 361                 return ACLResult_Error;
 362         }
 363
 364         return ACLResult_OK;
 365 }
 366
 367 static void RegistACLDevice(conv::Request *requestObj, const char *macAddress, const char *deviceType, const char *deviceName, ACManagerPolicy aclState)
 368 {
 369         int ret = conv::acl_manager::SetDeviceInfoAndACL(macAddress, deviceType, deviceName, NULL, aclState);
 370         if (ret != ACLResult_OK) {
 371                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 372                 delete requestObj;
 373                 return;
 374         }
 375
 376         requestObj->reply(CONV_ERROR_NONE);
 377         delete requestObj;
 378 }
 379
 380 static void ChangeACLState(conv::Request *requestObj, const char *macAddress, const char *deviceName, ACManagerPolicy aclState)
 381 {
 382         sqlite3 *database = NULL;
 383         sqlite3_stmt *stmt = NULL;
 384         const char *set_acl_state_query = "update DEVICES_INFO SET DEVICE_NAME=?, ACL_STATE=? where MAC_ADDRESS=?;";
 385
 386         int ret = database_initialize(&database, &stmt, set_acl_state_query);
 387         if (ret != SQLITE_OK) {
 388                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 389                 delete requestObj;
 390                 return;
 391         }
 392
 393         ret = sqlite3_bind_text(stmt, 1, deviceName, strlen(deviceName), SQLITE_TRANSIENT);
 394         if (ret != SQLITE_OK) {
 395                 _E("Statement binding the deviceName text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 396         }
 397
 398         ret = sqlite3_bind_int(stmt, 2, aclState);
 399         if (ret != SQLITE_OK) {
 400                 _E("Statement binding the aclState integer is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 401         }
 402
 403         char _mac[MAC_ADDRESS_LEN + 1];
 404         strncpy(_mac, macAddress, MAC_ADDRESS_LEN);
 405         _mac[1] = convert_mac(_mac[1]);
 406         _mac[MAC_ADDRESS_LEN] = '\0';
 407
 408         ret = sqlite3_bind_text(stmt, 3, _mac, strlen(_mac), SQLITE_TRANSIENT);
 409         if (ret != SQLITE_OK) {
 410                 _E("Statement binding the macAddress text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 411         }
 412
 413         ret = sqlite3_step(stmt);
 414         if (ret != SQLITE_DONE) {
 415                 _E("Statement step is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 416         }
 417
 418         ret = database_finalize(database, stmt);
 419         if (ret != SQLITE_OK) {
 420                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 421                 delete requestObj;
 422                 return;
 423         }
 424
 425         requestObj->reply(CONV_ERROR_NONE);
 426         delete requestObj;
 427 }
 428
 429 static void SetACLState(conv::Request *requestObj, const char *macAddress, const char *deviceType, const char *deviceName, ACManagerPolicy aclState)
 430 {
 431         sqlite3 *database = NULL;
 432         sqlite3_stmt *stmt = NULL;
 433
 434         const char *is_exist_query = "select count(*) from DEVICES_INFO where MAC_ADDRESS=?;";
 435
 436         int ret = database_initialize(&database, &stmt, is_exist_query);
 437         if (ret != SQLITE_OK) {
 438                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 439                 delete requestObj;
 440                 return;
 441         }
 442
 443         char _mac[MAC_ADDRESS_LEN + 1];
 444         strncpy(_mac, macAddress, MAC_ADDRESS_LEN);
 445         _mac[1] = convert_mac(_mac[1]);
 446         _mac[MAC_ADDRESS_LEN] = '\0';
 447
 448         ret = sqlite3_bind_text(stmt, 1, _mac, strlen(_mac), SQLITE_TRANSIENT);
 449         if (ret != SQLITE_OK) {
 450                 _E("Statement binding the macAddress text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 451         }
 452
 453         int count = 0;
 454
 455         while (sqlite3_step(stmt) == SQLITE_ROW) {
 456                 count = sqlite3_column_int(stmt, 0);
 457         }
 458
 459         ret = database_finalize(database, stmt);
 460         if (ret != SQLITE_OK){
 461                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 462                 delete requestObj;
 463                 return;
 464         }
 465
 466         switch (count)
 467         {
 468                 case 0 : RegistACLDevice(requestObj, macAddress, deviceType, deviceName, aclState); break;
 469                 case 1 : ChangeACLState(requestObj, macAddress, deviceName, aclState); break;
 470         }
 471 }
 472
 473 static void RemoveACLDevice(conv::Request *requestObj, const char *macAddress)
 474 {
 475         sqlite3 *database = NULL;
 476         sqlite3_stmt *stmt = NULL;
 477         const char *remove_acl_device_query = "delete from DEVICES_INFO WHERE MAC_ADDRESS=?;";
 478
 479         int ret = database_initialize(&database, &stmt, remove_acl_device_query);
 480         if (ret != SQLITE_OK) {
 481                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 482                 delete requestObj;
 483                 return;
 484         }
 485
 486         char _mac[MAC_ADDRESS_LEN + 1];
 487         strncpy(_mac, macAddress, MAC_ADDRESS_LEN);
 488         _mac[1] = convert_mac(_mac[1]);
 489         _mac[MAC_ADDRESS_LEN] = '\0';
 490
 491         ret = sqlite3_bind_text(stmt, 1, _mac, strlen(_mac), SQLITE_TRANSIENT);
 492         if (ret != SQLITE_OK) {
 493                 _E("Statement binding the macAddress text is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 494         }
 495
 496         ret = sqlite3_step(stmt);
 497         if (ret != SQLITE_DONE) {
 498                 _E("Statement step is fail. (%d: %s)", ret, sqlite3_errmsg(database));
 499         }
 500
 501         ret = database_finalize(database, stmt);
 502         if (ret != SQLITE_OK) {
 503                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 504                 delete requestObj;
 505                 return;
 506         }
 507
 508         requestObj->reply(CONV_ERROR_NONE);
 509         delete requestObj;
 510 }
 511
 512 static void GetACLDeviceList(conv::Request *requestObj)
 513 {
 514         sqlite3 *database = NULL;
 515         sqlite3_stmt *stmt = NULL;
 516         const char *get_acl_device_list_query = "select MAC_ADDRESS, DEVICE_TYPE, DEVICE_NAME, ACL_STATE from DEVICES_INFO;";
 517
 518         int ret = database_initialize(&database, &stmt, get_acl_device_list_query);
 519         if (ret != SQLITE_OK) {
 520                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 521                 delete requestObj;
 522                 return;
 523         }
 524
 525         while (sqlite3_step(stmt) == SQLITE_ROW) {
 526                 char *macAddress = (char *)sqlite3_column_text(stmt, 0);
 527                 char *deviceType = (char *)sqlite3_column_text(stmt, 1);
 528                 char *deviceName = (char *)sqlite3_column_text(stmt, 2);
 529                 ACManagerPolicy aclState = static_cast<ACManagerPolicy> (sqlite3_column_int(stmt, 3));
 530
 531                 _I("[ACL] MacAddress:%s, DeviceType:%s, DeviceName:%s, State:%d", macAddress, deviceType, deviceName, aclState);
 532
 533                 conv::Json result_data;
 534                 result_data.set(NULL, CONV_JSON_DEVICE_ID, macAddress);
 535                 result_data.set(NULL, CONV_JSON_DEVICE_TYPE, deviceType);
 536                 result_data.set(NULL, CONV_JSON_DEVICE_NAME, deviceName);
 537                 result_data.set(NULL, CONV_JSON_ACCESS_CONTROL_STATE, aclState);
 538                 requestObj->publish(CONV_ERROR_NONE, result_data);
 539         }
 540
 541         ret = database_finalize(database, stmt);
 542         if (ret != SQLITE_OK) {
 543                 requestObj->reply(CONV_ERROR_INVALID_OPERATION);
 544                 delete requestObj;
 545                 return;
 546         }
 547
 548         requestObj->reply(CONV_ERROR_NONE);
 549         delete requestObj;
 550 }
 551
 552 int conv::acl_manager::handleRequest(conv::Request *requestObj) {
 553         if (!strcmp(requestObj->getSubject(), CONV_SUBJECT_ACCESS_CONTROL_REGIST)) {
 554                 std::string mac_address;
 555                 std::string device_type;
 556                 std::string device_name;
 557                 int state;
 558
 559                 conv::Json output_data = requestObj->getDescription();
 560                 output_data.get(NULL, CONV_JSON_DEVICE_ID, &mac_address);
 561                 output_data.get(NULL, CONV_JSON_DEVICE_TYPE, &device_type);
 562                 output_data.get(NULL, CONV_JSON_DEVICE_NAME, &device_name);
 563                 output_data.get(NULL, CONV_JSON_ACCESS_CONTROL_STATE, &state);
 564
 565                 ACManagerPolicy aclState = ACMANAGER_POLICY_U2;
 566                 switch(state)
 567                 {
 568                         case 0 : aclState = ACMANAGER_POLICY_P; break;
 569                         case 1 : aclState = ACMANAGER_POLICY_D; break;
 570                 }
 571
 572                 RegistACLDevice(requestObj, (const char*)mac_address.c_str(), (const char*)device_type.c_str(), (const char*)device_name.c_str(), aclState);
 573
 574         } else if (!strcmp(requestObj->getSubject(), CONV_SUBJECT_ACCESS_CONTROL_SET)) {
 575                 std::string mac_address;
 576                 std::string device_type;
 577                 std::string device_name;
 578                 int state;
 579
 580                 conv::Json output_data = requestObj->getDescription();
 581                 output_data.get(NULL, CONV_JSON_DEVICE_ID, &mac_address);
 582                 output_data.get(NULL, CONV_JSON_DEVICE_TYPE, &device_type);
 583                 output_data.get(NULL, CONV_JSON_DEVICE_NAME, &device_name);
 584                 output_data.get(NULL, CONV_JSON_ACCESS_CONTROL_STATE, &state);
 585
 586                 ACManagerPolicy aclState = static_cast<ACManagerPolicy> (state);
 587                 SetACLState(requestObj, (const char*)mac_address.c_str(), (const char*)device_type.c_str(), (const char*)device_name.c_str(), aclState);
 588
 589         } else if (!strcmp(requestObj->getSubject(), CONV_SUBJECT_ACCESS_CONTROL_REMOVE)) {
 590                 std::string mac_address;
 591                 conv::Json output_data = requestObj->getDescription();
 592                 output_data.get(NULL, CONV_JSON_DEVICE_ID, &mac_address);
 593                 RemoveACLDevice(requestObj, (const char*)mac_address.c_str());
 594
 595         } else if (!strcmp(requestObj->getSubject(), CONV_SUBJECT_ACCESS_CONTROL_GET)) {
 596                 GetACLDeviceList(requestObj);
 597         }
 598
 599         return CONV_ERROR_NONE;
 600 }