client/src/PrivacyGuardClient.cpp

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
   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 <algorithm>
  18 #include <memory>
  19 #include "Utils.h"
  20 #include "PrivacyGuardClient.h"
  21 #include "SocketClient.h"
  22 #include "PrivacyIdInfo.h"
  23
  24 #define COUNT 10
  25
  26 #undef __READ_DB_IPC__
  27
  28 std::mutex PrivacyGuardClient::m_singletonMutex;
  29 PrivacyGuardClient* PrivacyGuardClient::m_pInstance = NULL;
  30 const std::string PrivacyGuardClient::INTERFACE_NAME("PrivacyInfoService");
  31
  32 PrivacyGuardClient::PrivacyGuardClient(void)
  33 {
  34         std::unique_ptr<SocketClient> pSocketClient(new SocketClient(INTERFACE_NAME));
  35         m_pSocketClient = std::move(pSocketClient);
  36 }
  37
  38 PrivacyGuardClient*
  39 PrivacyGuardClient::getInstance(void)
  40 {
  41         std::lock_guard<std::mutex> guard(m_singletonMutex);
  42         if (m_pInstance == NULL)
  43                 m_pInstance = new PrivacyGuardClient();
  44         return m_pInstance;
  45 }
  46
  47 int
  48 PrivacyGuardClient::PgAddPrivacyAccessLog(const int userId, const std::string packageId, const std::string privacyId)
  49 {
  50         int result = PRIV_FLTR_ERROR_SUCCESS;
  51         logInfoList.push_back(std::pair <std::string, std::string> (packageId, privacyId));
  52         PF_LOGD("PrivacyGuardClient userId : %d, PgAddPrivacyAccessLog logInfoList.size() : %d", userId, logInfoList.size());
  53
  54         if(logInfoList.size() >= COUNT) {
  55                 int res = m_pSocketClient->connect();
  56                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
  57
  58                 res = m_pSocketClient->call("PgAddPrivacyAccessLog", userId, logInfoList, &result);
  59                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
  60
  61                 res = m_pSocketClient->disconnect();
  62                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
  63                 logInfoList.clear();
  64         }
  65
  66         return result;
  67 }
  68
  69 int
  70 PrivacyGuardClient::PgAddPrivacyAccessLogTest(const int userId, const std::string packageId, const std::string privacyId)
  71 {
  72         int result = PRIV_FLTR_ERROR_SUCCESS;
  73
  74         int res = m_pSocketClient->connect();
  75         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
  76
  77         res = m_pSocketClient->call("PgAddPrivacyAccessLogTest", userId, packageId, privacyId, &result);
  78         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
  79
  80         res = m_pSocketClient->disconnect();
  81         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
  82
  83         return result;
  84 }
  85
  86 int
  87 PrivacyGuardClient::PgAddPrivacyAccessLogBeforeTerminate(void)
  88 {
  89         int result = PRIV_FLTR_ERROR_SUCCESS;
  90         PF_LOGD("PgAddPrivacyAccessLogBeforeTerminate, logInfoList.size() : %d", logInfoList.size());
  91
  92         if(logInfoList.size() > 0) {
  93                 int res = m_pSocketClient->connect();
  94                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
  95
  96                 res = m_pSocketClient->call("PgAddPrivacyAccessLog", logInfoList, &result);
  97                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
  98
  99                 res = m_pSocketClient->disconnect();
 100                 TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 101                 logInfoList.clear();
 102         }
 103
 104         return result;
 105 }
 106
 107 int
 108 PrivacyGuardClient::PgAddMonitorPolicy(const int userId, const std::string pkgId, const std::list < std::string >& list, int monitorPolicy)
 109 {
 110
 111         std::list < std::string > privacyList;
 112
 113         int res = PrivacyIdInfo::getPrivacyIdListFromPrivilegeList(list, privacyList);
 114         if (res != PRIV_FLTR_ERROR_SUCCESS )
 115                 return res;
 116
 117         if (privacyList.size() == 0)
 118                 return PRIV_FLTR_ERROR_SUCCESS;
 119
 120         int result = PRIV_FLTR_ERROR_SUCCESS;
 121
 122         res = m_pSocketClient->connect();
 123         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 124
 125         res = m_pSocketClient->call("PgAddMonitorPolicy", userId, pkgId, privacyList, monitorPolicy, &result);
 126         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 127
 128         res = m_pSocketClient->disconnect();
 129         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 130
 131         return result;
 132 }
 133
 134 int
 135 PrivacyGuardClient::PgDeleteAllLogsAndMonitorPolicy(void)
 136 {
 137         int result = PRIV_FLTR_ERROR_SUCCESS;
 138
 139         int res = m_pSocketClient->connect();
 140         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 141
 142         res = m_pSocketClient->call("PgDeleteAllLogsAndMonitorPolicy", &result);
 143         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 144
 145         res = m_pSocketClient->disconnect();
 146         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 147
 148         return result;
 149 }
 150
 151 int
 152 PrivacyGuardClient::PgDeleteLogsByPackageId(const std::string packageId)
 153 {
 154         int result = PRIV_FLTR_ERROR_SUCCESS;
 155
 156         int res = m_pSocketClient->connect();
 157         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 158
 159         res = m_pSocketClient->call("PgDeleteLogsByPackageId", packageId, &result);
 160         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 161
 162         res = m_pSocketClient->disconnect();
 163         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 164
 165         return result;
 166 }
 167
 168 int
 169 PrivacyGuardClient::PgDeleteMonitorPolicyByPackageId(const std::string packageId)
 170 {
 171         int result = PRIV_FLTR_ERROR_SUCCESS;
 172
 173         int res = m_pSocketClient->connect();
 174         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 175
 176         res = m_pSocketClient->call("PgDeleteMonitorPolicyByPackageId", packageId, &result);
 177         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 178
 179         res = m_pSocketClient->disconnect();
 180         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 181
 182         return result;
 183 }
 184
 185 int
 186 PrivacyGuardClient::PgForeachTotalPrivacyCountOfPackage(const int userId, const int startDate, const int endDate, std::list < std::pair <std::string, int > > & packageInfoList) const
 187 {
 188         int result = PRIV_FLTR_ERROR_SUCCESS;
 189
 190         int res = m_pSocketClient->connect();
 191         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 192
 193         res = m_pSocketClient->call("PgForeachTotalPrivacyCountOfPackage", userId, startDate, endDate, &result, &packageInfoList);
 194         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 195
 196         res = m_pSocketClient->disconnect();
 197         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 198
 199         return result;
 200 }
 201
 202 int
 203 PrivacyGuardClient::PgForeachTotalPrivacyCountOfPrivacy(const int userId, const int startDate, const int endDate, std::list < std::pair <std::string, int > > & privacyInfoList) const
 204 {
 205         int result = PRIV_FLTR_ERROR_SUCCESS;
 206
 207         int res = m_pSocketClient->connect();
 208         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 209
 210         res = m_pSocketClient->call("PgForeachTotalPrivacyCountOfPrivacy", userId, startDate, endDate, &result, &privacyInfoList);
 211         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 212
 213         res = m_pSocketClient->disconnect();
 214         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 215
 216         return result;
 217 }
 218
 219 int
 220 PrivacyGuardClient::PgForeachPrivacyCountByPrivacyId(const int userId, const int startDate, const int endDate, const std::string privacyId, std::list < std::pair <std::string, int > > & packageInfoList) const
 221 {
 222         int result = PRIV_FLTR_ERROR_SUCCESS;
 223
 224         bool isValid = PrivacyIdInfo::isValidPrivacyId(privacyId);
 225
 226         if (!isValid)
 227                 return PRIV_FLTR_ERROR_INVALID_PARAMETER;
 228
 229         int res = m_pSocketClient->connect();
 230         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 231
 232         res = m_pSocketClient->call("PgForeachPrivacyCountByPrivacyId", userId, startDate, endDate, privacyId, &result, &packageInfoList);
 233         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 234
 235         res = m_pSocketClient->disconnect();
 236         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 237
 238         return result;
 239 }
 240
 241 int
 242 PrivacyGuardClient::PgForeachPrivacyCountByPackageId(const int userId, const int startDate, const int endDate, const std::string packageId, std::list < std::pair <std::string, int > > & privacyInfoList) const
 243 {
 244         int result = PRIV_FLTR_ERROR_SUCCESS;
 245
 246         int res = m_pSocketClient->connect();
 247         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 248
 249         res = m_pSocketClient->call("PgForeachPrivacyCountByPackageId", userId, startDate, endDate, packageId, &result, &privacyInfoList);
 250         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 251
 252         res = m_pSocketClient->disconnect();
 253         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 254
 255         return result;
 256 }
 257
 258 int
 259 PrivacyGuardClient::PgForeachPrivacyPackageId(const int userId, std::list < std::string > & packageList) const
 260 {
 261         int result = PRIV_FLTR_ERROR_SUCCESS;
 262
 263         int res = m_pSocketClient->connect();
 264         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 265
 266         res = m_pSocketClient->call("PgForeachPrivacyPackageId", userId, &result, &packageList);
 267         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 268
 269         res = m_pSocketClient->disconnect();
 270         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 271
 272         return result;
 273 }
 274
 275 int
 276 PrivacyGuardClient::PgForeachPackageByPrivacyId(const int userId, const std::string privacyId, std::list < std::string > & packageList) const
 277 {
 278         int result = PRIV_FLTR_ERROR_SUCCESS;
 279
 280         bool isValid = PrivacyIdInfo::isValidPrivacyId(privacyId);
 281
 282         if (!isValid)
 283                 return PRIV_FLTR_ERROR_INVALID_PARAMETER;
 284
 285         int res = m_pSocketClient->connect();
 286         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 287
 288         res = m_pSocketClient->call("PgForeachPackageByPrivacyId", userId, privacyId, &result, &packageList);
 289         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 290
 291         res = m_pSocketClient->disconnect();
 292         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 293
 294         return result;
 295 }
 296
 297 int
 298 PrivacyGuardClient::PgForeachMonitorPolicyByPackageId(const int userId, const std::string packageId,
 299                 std::list <privacy_data_s> & privacyInfoList) const
 300 {
 301         int result = PRIV_FLTR_ERROR_SUCCESS;
 302
 303         int res = m_pSocketClient->connect();
 304         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 305
 306         res = m_pSocketClient->call("PgForeachMonitorPolicyByPackageId", userId, packageId, &result, &privacyInfoList);
 307         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 308
 309         res = m_pSocketClient->disconnect();
 310         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 311
 312         return result;
 313 }
 314
 315 int
 316 PrivacyGuardClient::PgGetMonitorPolicy(const int userId, const std::string packageId,
 317                 const std::string privacyId, int &monitorPolicy) const
 318 {
 319         int result = PRIV_FLTR_ERROR_SUCCESS;
 320
 321         bool isValid = PrivacyIdInfo::isValidPrivacyId(privacyId);
 322
 323         if (!isValid)
 324                 return PRIV_FLTR_ERROR_INVALID_PARAMETER;
 325
 326         int res = m_pSocketClient->connect();
 327         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 328
 329         res = m_pSocketClient->call("PgGetMonitorPolicy", userId, packageId, privacyId, &result, &monitorPolicy);
 330         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 331
 332         res = m_pSocketClient->disconnect();
 333         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 334
 335         return result;
 336 }
 337
 338 int
 339 PrivacyGuardClient::PgGetAllMonitorPolicy(std::list < std::pair < std::string, int > > & monitorPolicyList) const
 340 {
 341         int result = PRIV_FLTR_ERROR_SUCCESS;
 342
 343         int res = m_pSocketClient->connect();
 344         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 345
 346         res = m_pSocketClient->call("PgGetAllMonitorPolicy", &result, &monitorPolicyList);
 347         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 348
 349         res = m_pSocketClient->disconnect();
 350         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 351
 352         return result;
 353 }
 354
 355 int
 356 PrivacyGuardClient::PgCheckPrivacyPackage(const int userId, const std::string packageId, bool &isPrivacyPackage)
 357 {
 358         int result = PRIV_FLTR_ERROR_SUCCESS;
 359
 360         int res = m_pSocketClient->connect();
 361         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 362
 363         res = m_pSocketClient->call("PgCheckPrivacyPackage", userId, packageId, &result, &isPrivacyPackage);
 364         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 365
 366         res = m_pSocketClient->disconnect();
 367         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 368
 369         return result;
 370 }
 371
 372 int
 373 PrivacyGuardClient::PgUpdateMonitorPolicy(const int userId, const std::string packageId,
 374                 const std::string privacyId, const int monitorPolicy)
 375 {
 376         int result = PRIV_FLTR_ERROR_SUCCESS;
 377
 378         bool isValid = PrivacyIdInfo::isValidPrivacyId(privacyId);
 379
 380         if (!isValid)
 381                 return PRIV_FLTR_ERROR_INVALID_PARAMETER;
 382
 383         int res = m_pSocketClient->connect();
 384         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 385
 386         res = m_pSocketClient->call("PgUpdateMonitorPolicy", userId, packageId, privacyId, monitorPolicy, &result);
 387         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 388
 389         res = m_pSocketClient->disconnect();
 390         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 391
 392         return result;
 393 }
 394
 395 int
 396 PrivacyGuardClient::PgGetMainMonitorPolicy(const int userId, bool &mainMonitorPolicy) const
 397 {
 398         int result = PRIV_FLTR_ERROR_SUCCESS;
 399
 400         int res = m_pSocketClient->connect();
 401         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 402
 403         res = m_pSocketClient->call("PgGetMainMonitorPolicy", userId, &result, &mainMonitorPolicy);
 404         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 405
 406         res = m_pSocketClient->disconnect();
 407         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 408
 409         return result;
 410 }
 411
 412 int
 413 PrivacyGuardClient::PgUpdateMainMonitorPolicy(const int userId, const bool mainMonitorPolicy)
 414 {
 415         int result = PRIV_FLTR_ERROR_SUCCESS;
 416
 417         int res = m_pSocketClient->connect();
 418         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 419
 420         res = m_pSocketClient->call("PgUpdateMainMonitorPolicy", userId, mainMonitorPolicy, &result);
 421         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 422
 423         res = m_pSocketClient->disconnect();
 424         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 425
 426         return result;
 427 }
 428
 429 int
 430 PrivacyGuardClient::PgDeleteMainMonitorPolicyByUserId(const int userId)
 431 {
 432         int result = PRIV_FLTR_ERROR_SUCCESS;
 433
 434         int res = m_pSocketClient->connect();
 435         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "connect : %d", res);
 436
 437         res = m_pSocketClient->call("PgDeleteMainMonitorPolicyByUserId", userId, &result);
 438         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 439
 440         res = m_pSocketClient->disconnect();
 441         TryReturn(res == PRIV_FLTR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 442
 443         return result;
 444 }