src/lockd-process-mgr.c

   1 /*
   2  * Copyright (c) 2000 - 2015 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 <vconf.h>
  18 #include <vconf-keys.h>
  19 #include <aul.h>
  20 #include <pkgmgr-info.h>
  21 #include <sys/time.h>
  22 #include <sys/resource.h>
  23 #include <sys/types.h>
  24 #include <Ecore.h>
  25 #include <unistd.h>
  26
  27 #include "lockd-debug.h"
  28 #include "lockd-process-mgr.h"
  29 #include "starter-vconf.h"
  30
  31 #define LOCKD_DEFAULT_PKG_NAME "org.tizen.lockscreen"
  32 #define LOCKD_DRAG_LOCKSCREEN "com.samsung.draglock"
  33 #define LOCKD_PHONE_LOCK_PKG_NAME LOCKD_DEFAULT_PKG_NAME
  34 #define RETRY_MAXCOUNT 30
  35 #define RELAUNCH_INTERVAL 100*1000
  36
  37 #define LOCKD_VOICE_CALL_PKG_NAME "com.samsung.call"
  38 #define LOCKD_VIDEO_CALL_PKG_NAME "com.samsung.vtmain"
  39
  40 #define NICE_VALUE_PWLOCK -5
  41 #define NICE_VALUE_LOCKSCREEN -20
  42
  43 static char *default_lockscreen_pkg = NULL;
  44
  45 static bool _lockd_exist_package(char *pkgid)
  46 {
  47         int ret = 0;
  48         pkgmgrinfo_appinfo_h handle = NULL;
  49
  50         ret = pkgmgrinfo_appinfo_get_appinfo(pkgid, &handle);
  51         if (PMINFO_R_OK != ret || NULL == handle) {
  52                 LOCKD_SECURE_DBG("%s doesn't exist in this binary", pkgid);
  53                 return false;
  54         }
  55
  56         pkgmgrinfo_appinfo_destroy_appinfo(handle);
  57
  58         return true;
  59 }
  60
  61 void lockd_process_mgr_init(void)
  62 {
  63         default_lockscreen_pkg = vconf_get_str(VCONF_PRIVATE_LOCKSCREEN_DEFAULT_PKGNAME);
  64         LOCKD_SECURE_DBG("default lock screen pkg name is %s", default_lockscreen_pkg);
  65         if (default_lockscreen_pkg == NULL) {
  66                 default_lockscreen_pkg = LOCKD_DEFAULT_PKG_NAME;
  67         }
  68         if (!_lockd_exist_package(default_lockscreen_pkg)) {
  69                 LOCKD_SECURE_ERR("%s is not exist, default lock screen pkg name is set to %s", default_lockscreen_pkg, LOCKD_DRAG_LOCKSCREEN);
  70                 default_lockscreen_pkg = LOCKD_DRAG_LOCKSCREEN;
  71                 if (vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, default_lockscreen_pkg) != 0) {
  72                         LOCKD_SECURE_ERR("vconf key [%s] set [%s] is failed", VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, default_lockscreen_pkg);
  73                 }
  74         }
  75 }
  76
  77 static char *_lockd_process_mgr_get_pkgname(int lock_type)
  78 {
  79         char *pkgname = NULL;
  80
  81         if (lock_type > 1) {
  82                 pkgname = vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR);
  83                 LOCKD_SECURE_DBG("pkg name is %s", pkgname);
  84                 if (pkgname == NULL) {
  85                         pkgname = default_lockscreen_pkg;
  86                 } else if (_lockd_exist_package(pkgname) == FALSE) {
  87                         pkgname = default_lockscreen_pkg;
  88                 }
  89         } else {
  90                 pkgname = default_lockscreen_pkg;
  91         }
  92         return pkgname;
  93 }
  94
  95 int lockd_process_mgr_restart_lock(int lock_type)
  96 {
  97         char *lock_app_path = NULL;
  98         int pid;
  99         int i;
 100
 101         LOCKD_DBG("%s, %d", __func__, __LINE__);
 102         lock_app_path = _lockd_process_mgr_get_pkgname(lock_type);
 103
 104         for (i=0; i<RETRY_MAXCOUNT; i++)
 105         {
 106                 pid = aul_launch_app(lock_app_path, NULL);
 107                 LOCKD_DBG("aul_launch_app(%s), pid = %d", lock_app_path, pid);
 108                 if (pid == AUL_R_ETIMEOUT) {
 109                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 110                         usleep(RELAUNCH_INTERVAL);
 111                 } else {
 112                         return pid;
 113                 }
 114         }
 115
 116         LOCKD_SECURE_DBG("Reset : aul_launch_app(%s, NULL), pid = %d", lock_app_path,
 117                   pid);
 118         return pid;
 119 }
 120
 121 int
 122 lockd_process_mgr_start_lock(void *data, int (*dead_cb) (int, void *),
 123                              int lock_type)
 124 {
 125         char *lock_app_path = NULL;
 126         int pid;
 127         int i;
 128
 129         LOCKD_DBG("%s, %d", __func__, __LINE__);
 130         lock_app_path = _lockd_process_mgr_get_pkgname(lock_type);
 131
 132         for (i=0; i<RETRY_MAXCOUNT; i++)
 133         {
 134                 pid = aul_launch_app(lock_app_path, NULL);
 135
 136                 LOCKD_SECURE_DBG("aul_launch_app(%s), pid = %d", lock_app_path, pid);
 137
 138                 if ((pid == AUL_R_ECOMM) || (pid == AUL_R_ETERMINATING)) {
 139                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 140                         usleep(RELAUNCH_INTERVAL);
 141                 } else if (pid == AUL_R_ERROR) {
 142                         LOCKD_SECURE_ERR("launch[%s] is failed, launch default lock screen", lock_app_path);
 143                         pid = aul_launch_app(default_lockscreen_pkg, NULL);
 144                         if (pid == AUL_R_ERROR) {
 145                                 LOCKD_SECURE_ERR("launch[%s] is failed, launch drag lock screen", default_lockscreen_pkg);
 146                                 pid = aul_launch_app(LOCKD_DRAG_LOCKSCREEN, NULL);
 147                                 if (pid >0) {
 148                                         if (vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, LOCKD_DRAG_LOCKSCREEN) != 0) {
 149                                                 LOCKD_SECURE_ERR("vconf key [%s] set [%s] is failed", VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, LOCKD_DRAG_LOCKSCREEN);
 150                                         }
 151                                         return pid;
 152                                 }
 153                         } else {
 154                                 return pid;
 155                         }
 156                 } else {
 157                         return pid;
 158                 }
 159         }
 160         LOCKD_ERR("Relaunch lock application failed..!!");
 161         return pid;
 162 }
 163
 164 int lockd_process_mgr_start_normal_lock(void *data, int (*dead_cb) (int, void *))
 165 {
 166         int pid = 0;
 167
 168         int i;
 169         for (i=0; i<RETRY_MAXCOUNT; i++)
 170         {
 171                 pid = aul_launch_app(default_lockscreen_pkg, NULL);
 172
 173                 LOCKD_SECURE_DBG("aul_launch_app(%s), pid = %d", default_lockscreen_pkg, pid);
 174
 175                 if ((pid == AUL_R_ECOMM) || (pid == AUL_R_ETERMINATING)) {
 176                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 177                         usleep(RELAUNCH_INTERVAL);
 178                 } else if (pid == AUL_R_ERROR) {
 179                         LOCKD_SECURE_DBG("launch[%s] is failed, launch default lock screen", default_lockscreen_pkg);
 180                 } else {
 181                         return pid;
 182                 }
 183         }
 184         LOCKD_ERR("Relaunch lock application failed..!!");
 185         return pid;
 186 }
 187
 188 static Eina_Bool _set_priority_lockscreen_process_cb(void *data)
 189 {
 190         int prio;
 191         char buf[1024] = { 0, };
 192
 193         prio = getpriority(PRIO_PROCESS, (pid_t)data);
 194         if (prio == NICE_VALUE_LOCKSCREEN) {
 195                 LOCKD_DBG("%s (%d: %d)\n", "setpriority Success", (pid_t)data, prio);
 196                 return ECORE_CALLBACK_CANCEL;
 197         }
 198
 199         if (setpriority(PRIO_PROCESS, (pid_t)data, NICE_VALUE_LOCKSCREEN) < 0 ) {
 200                 LOCKD_DBG("%s\n", strerror_r(errno, buf, sizeof(buf)));
 201                 return ECORE_CALLBACK_CANCEL;
 202         }
 203
 204         return ECORE_CALLBACK_RENEW;
 205 }
 206
 207 static Eina_Bool _set_priority_pwlock_process_cb(void *data)
 208 {
 209         int prio;
 210         char buf[104] = { 0, };
 211
 212         prio = getpriority(PRIO_PROCESS, (pid_t)data);
 213         if (prio == NICE_VALUE_PWLOCK) {
 214                 LOCKD_DBG("%s (%d: %d)\n", "setpriority Success", (pid_t)data, prio);
 215                 return ECORE_CALLBACK_CANCEL;
 216         }
 217
 218         if (setpriority(PRIO_PROCESS, (pid_t)data, NICE_VALUE_PWLOCK) < 0 ) {
 219                 LOCKD_DBG("%s\n", strerror_r(errno, buf, sizeof(buf)));
 220                 return ECORE_CALLBACK_CANCEL;
 221         }
 222
 223         return ECORE_CALLBACK_RENEW;
 224 }
 225
 226 int lockd_process_mgr_start_phone_lock(void)
 227 {
 228         int pid = 0;
 229         bundle *b = NULL;
 230         int i;
 231
 232         LOCKD_DBG("%s, %d", __func__, __LINE__);
 233         b = bundle_create();
 234
 235         bundle_add(b, "lock_type", "phone_lock");
 236
 237         for (i=0; i<RETRY_MAXCOUNT; i++)
 238         {
 239                 pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 240
 241                 LOCKD_SECURE_DBG("aul_launch_app(%s), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME, pid);
 242
 243                 if ((pid == AUL_R_ECOMM) || (pid == AUL_R_ETERMINATING)) {
 244                         LOCKD_DBG("Relaunch lock application [%d]times", i);
 245                         usleep(RELAUNCH_INTERVAL);
 246                 } else {
 247                         if (b)
 248                                 bundle_free(b);
 249
 250                         return pid;
 251                 }
 252         }
 253
 254         if (b)
 255                 bundle_free(b);
 256
 257         return pid;
 258 }
 259
 260 int lockd_process_mgr_set_lockscreen_priority(int pid)
 261 {
 262         return !ecore_timer_add(1.0f, _set_priority_lockscreen_process_cb, (void *)pid);
 263 }
 264
 265 int lockd_process_mgr_set_pwlock_priority(int pid)
 266 {
 267         return !ecore_timer_add(1.0f, _set_priority_pwlock_process_cb, (void *)pid);
 268 }
 269
 270
 271 int lockd_process_mgr_start_recovery_lock(void)
 272 {
 273         int pid = 0;
 274         bundle *b = NULL;
 275
 276         LOCKD_DBG("%s, %d", __func__, __LINE__);
 277         b = bundle_create();
 278
 279         bundle_add(b, "lock_type", "recovery_lock");
 280
 281         pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 282         LOCKD_SECURE_DBG("aul_launch_app(%s, b), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME,
 283                   pid);
 284         if (b)
 285                 bundle_free(b);
 286
 287         return pid;
 288 }
 289
 290 int lockd_process_mgr_start_back_to_app_lock(void)
 291 {
 292         int pid = 0;
 293         bundle *b = NULL;
 294
 295         LOCKD_DBG("%s, %d", __func__, __LINE__);
 296         b = bundle_create();
 297
 298         bundle_add(b, "lock_type", "back_to_call");
 299
 300         pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 301         LOCKD_SECURE_DBG("aul_launch_app(%s, b), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME,
 302                   pid);
 303         if (b)
 304                 bundle_free(b);
 305
 306         return pid;
 307 }
 308
 309 int lockd_process_mgr_start_ready_lock(void)
 310 {
 311         int pid = 0;
 312         bundle *b = NULL;
 313
 314         LOCKD_DBG("%s, %d", __func__, __LINE__);
 315         b = bundle_create();
 316
 317         bundle_add(b, "lock_op", "start_ready");
 318
 319         pid = aul_launch_app(LOCKD_PHONE_LOCK_PKG_NAME, b);
 320         LOCKD_SECURE_DBG("aul_launch_app(%s, b), pid = %d", LOCKD_PHONE_LOCK_PKG_NAME,
 321                   pid);
 322         if (b)
 323                 bundle_free(b);
 324
 325         return pid;
 326 }
 327
 328 void
 329 lockd_process_mgr_terminate_lock_app(int lock_app_pid, int state)
 330 {
 331         LOCKD_DBG
 332             ("lockd_process_mgr_terminate_lock_app,  state:%d\n",
 333              state);
 334
 335         if (state == 1) {
 336                 if (lock_app_pid != 0) {
 337                         LOCKD_DBG("Terminate Lock app(pid : %d)", lock_app_pid);
 338                         aul_terminate_pid(lock_app_pid);
 339                 }
 340         }
 341 }
 342
 343 void lockd_process_mgr_terminate_phone_lock(int phone_lock_pid)
 344 {
 345         LOCKD_DBG("Terminate Phone Lock(pid : %d)", phone_lock_pid);
 346         aul_terminate_pid(phone_lock_pid);
 347 }
 348
 349 void lockd_process_mgr_kill_lock_app(int lock_app_pid)
 350 {
 351         LOCKD_DBG ("lockd_process_mgr_kill_lock_app [pid:%d]..", lock_app_pid);
 352         aul_kill_pid(lock_app_pid);
 353 }
 354
 355 int lockd_process_mgr_check_lock(int pid)
 356 {
 357         char buf[128];
 358         LOCKD_DBG("%s, %d", __func__, __LINE__);
 359         /* Check pid is invalid. */
 360         if (aul_app_get_pkgname_bypid(pid, buf, sizeof(buf)) < 0) {
 361                 LOCKD_DBG("no such pkg by pid %d\n", pid);
 362         } else {
 363                 LOCKD_SECURE_DBG("app pkgname = %s, pid = %d\n", buf, pid);
 364                 if (aul_app_is_running(buf) == TRUE) {
 365                         LOCKD_DBG("%s [pid = %d] is running\n", buf, pid);
 366                         return TRUE;
 367                 } else {
 368                         LOCKD_SECURE_DBG("[pid = %d] is exist but %s is not running\n",
 369                                   pid, buf);
 370                 }
 371         }
 372         return FALSE;
 373 }
 374
 375 int lockd_process_mgr_check_call(int pid)
 376 {
 377         char buf[128];
 378         LOCKD_DBG("%s, %d", __func__, __LINE__);
 379
 380         /* Check pid is invalid. */
 381         if (aul_app_get_pkgname_bypid(pid, buf, sizeof(buf)) < 0) {
 382                 LOCKD_DBG("no such pkg by pid %d", pid);
 383         } else {
 384                 LOCKD_SECURE_DBG("app pkgname = %s, pid = %d", buf, pid);
 385                 if ((!strncmp(buf, LOCKD_VOICE_CALL_PKG_NAME, strlen(buf)))
 386                     || (!strncmp(buf, LOCKD_VIDEO_CALL_PKG_NAME, strlen(buf)))) {
 387                     return TRUE;
 388                 }
 389         }
 390         return FALSE;
 391 }
 392
 393 int lockd_process_mgr_check_home(int pid)
 394 {
 395         char buf[128];
 396         char *pkgname = NULL;
 397
 398         LOCKD_DBG("%s, %d", __func__, __LINE__);
 399         /* Check pid is invalid. */
 400         if (aul_app_get_pkgname_bypid(pid, buf, sizeof(buf)) < 0) {
 401                 LOCKD_DBG("no such pkg by pid %d", pid);
 402         } else {
 403                 LOCKD_SECURE_DBG("app pkgname = %s, pid = %d", buf, pid);
 404
 405                 pkgname = vconf_get_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME);
 406
 407                 if ((pkgname != NULL) &&
 408                         (!strncmp(buf, pkgname, strlen(buf)))) {
 409                         LOCKD_SECURE_DBG("home pkgname = %s", pkgname);
 410                     return TRUE;
 411                 }
 412         }
 413         return FALSE;
 414 }