4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Yong Yeon Kim <yy9875.kim@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
22 #include <sys/types.h>
25 #include <sys/statvfs.h>
28 #ifdef _SET_VIP_PROCESS
29 #include <sys/prctl.h>
31 #include <system_info.h>
32 #include <device/power.h>
34 #ifndef _USE_DEVICED_DBUS
35 #include <usb-device.h>
38 #include "media-util.h"
39 #include "media-server-ipc.h"
40 #include "media-common-dbg.h"
41 #include "media-common-system.h"
42 #include "media-common-utils.h"
44 int ms_strappend(char *res, const int size, const char *pattern, const char *str1, const char *str2)
47 int real_size = size - 1;
49 if (!res || !pattern || !str1 || !str2)
50 return MS_MEDIA_ERR_INVALID_PARAMETER;
52 if (real_size < (int)(strlen(str1) + strlen(str2)))
53 return MS_MEDIA_ERR_INVALID_PARAMETER;
55 len = snprintf(res, real_size, pattern, str1, str2);
57 return MS_MEDIA_ERR_INVALID_PARAMETER;
61 return MS_MEDIA_ERR_NONE;
64 bool ms_config_get_int(const char *key, int *value)
69 MS_DBG_ERR("Arguments key or value is NULL");
73 err = vconf_get_int(key, value);
77 MS_DBG_ERR("Error code: %d", err);
82 bool ms_config_set_int(const char *key, int value)
87 MS_DBG_ERR("Arguments key is NULL");
91 err = vconf_set_int(key, value);
95 MS_DBG_ERR("Error code: %d", err);
100 bool ms_config_get_str(const char *key, char **value)
104 if (key == NULL || value == NULL) {
105 MS_DBG_ERR("Arguments key or value is NULL");
109 res = vconf_get_str(key);
110 if (MS_STRING_VALID(res)) {
111 *value = g_strdup(res);
119 int ms_get_remain_space(double *free_space)
121 int ret = MS_MEDIA_ERR_NONE;
122 const char *path = "/opt";
125 ret = statvfs(path, &s);
127 MS_DBG_ERR("statvfs failed[%d]", ret);
129 return MS_MEDIA_ERR_INTERNAL;
132 /* f_bsize:unsigned long, f_bavail:fsblkcnt_t(unsigned long) */
133 *free_space = (double)(s.f_bsize * s.f_bavail);
135 return MS_MEDIA_ERR_NONE;
138 #ifdef _USE_RECORDED_CONTENT
139 bool ms_is_support_pvr(void)
143 if (system_info_get_value_int(SYSTEM_INFO_KEY_PVR_SUPPORTED, &nSupportPVR) != SYSTEM_INFO_ERROR_NONE) {
144 MS_DBG_ERR("Get PVR Support failed");
148 MS_DBG("PVR Support : [%d]", nSupportPVR);
150 return (nSupportPVR != 0);
154 #ifdef _USE_SENIOR_MODE
155 bool ms_is_support_senior_mode(void)
157 bool bSupportSeniorMode = false;
159 if (system_info_get_value_bool(SYSTEM_INFO_KEY_GET_SENIOR_MODE_SUPPORTED, &bSupportSeniorMode) != SYSTEM_INFO_ERROR_NONE) {
160 MS_DBG_ERR("Get senior mode support failed");
164 MS_DBG("Senior mode support : [%d]", bSupportSeniorMode);
166 return bSupportSeniorMode;
170 int ms_check_file_path(const char *file_path, uid_t uid)
172 ms_user_storage_type_e storage_type = -1;
173 int ret = MS_MEDIA_ERR_NONE;
175 if (!MS_STRING_VALID(file_path)) {
176 MS_DBG_ERR("Invalid path");
177 return MS_MEDIA_ERR_INVALID_PARAMETER;
180 ret = ms_user_get_storage_type(uid, file_path, &storage_type);
181 MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid path");
183 if (!g_file_test(file_path, G_FILE_TEST_IS_REGULAR)) {
184 MS_DBG_SERR("g_file_test fail [%s]", file_path);
185 return MS_MEDIA_ERR_INVALID_PARAMETER;
188 return MS_MEDIA_ERR_NONE;
191 int ms_check_ignore_dir(const char *full_path, uid_t uid)
193 int ret = MS_MEDIA_ERR_NONE;
194 char *dir_path = NULL;
195 char *leaf_path = NULL;
196 char *usr_path = NULL;
198 ret = ms_check_file_path(full_path, uid);
199 if (ret != MS_MEDIA_ERR_NONE) {
200 MS_DBG_ERR("invalid path : %s", full_path);
201 return MS_MEDIA_ERR_INVALID_PARAMETER;
204 dir_path = g_path_get_dirname(full_path);
205 if (dir_path == NULL || strcmp(dir_path, ".") == 0) {
206 MS_DBG_ERR("getting directory path is failed : %s", full_path);
208 return MS_MEDIA_ERR_INVALID_PARAMETER;
211 ret = ms_user_get_internal_root_path(uid, &usr_path);
212 if (ret != MS_MEDIA_ERR_NONE) {
213 MS_DBG_ERR("ms_user_get_internal_root_path() fail");
215 return MS_MEDIA_ERR_INTERNAL;
219 if (ms_check_scan_ignore(dir_path, uid) != MS_MEDIA_ERR_NONE) {
220 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
224 #ifdef _USE_SENIOR_MODE
225 if (ms_is_support_senior_mode()) {
226 if (strcmp(dir_path, MEDIA_ROOT_PATH_SENIOR_MODE) == 0)
230 if (strcmp(dir_path, usr_path) == 0)
232 else if (MS_STRING_VALID(MEDIA_ROOT_PATH_SDCARD) && (strncmp(dir_path, MEDIA_ROOT_PATH_SDCARD, strlen(MEDIA_ROOT_PATH_SDCARD)) == 0))
234 else if (MS_STRING_VALID(MEDIA_ROOT_PATH_USB) && (strncmp(dir_path, MEDIA_ROOT_PATH_USB, strlen(MEDIA_ROOT_PATH_USB)) == 0))
236 else if (MS_STRING_VALID(MEDIA_ROOT_PATH_DISC) && (strncmp(dir_path, MEDIA_ROOT_PATH_DISC, strlen(MEDIA_ROOT_PATH_DISC)) == 0))
239 leaf_path = strrchr(dir_path, '/');
240 if (leaf_path != NULL) {
241 int seek_len = leaf_path -dir_path;
242 dir_path[seek_len] = '\0';
244 MS_DBG_ERR("Fail to find leaf path");
245 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
256 static void __ms_trim_path(const char *input_path, char **output_path)
258 char buf[4096] = {0, };
259 char tmp[4096] = {0, };
262 SAFE_STRLCPY(buf, input_path, sizeof(buf));
264 while ((pos = strstr(buf, "//")) != NULL) {
265 memset(tmp, 0, sizeof(tmp));
266 SAFE_STRLCPY(tmp, buf, pos - buf + 1);
267 SAFE_STRLCAT(tmp, pos + 1, sizeof(tmp));
269 memset(buf, 0, sizeof(buf));
270 SAFE_STRLCPY(buf, tmp, sizeof(buf));
273 if (g_str_has_suffix(buf, "/"))
274 *output_path = g_strndup(buf, strlen(buf) - 1);
276 *output_path = g_strdup(buf);
279 int ms_check_scan_ignore(char * path, uid_t uid)
281 int ret = MS_MEDIA_ERR_NONE;
282 const char *ignore_file = ".scan_ignore";
283 char *tmp_path = NULL;
284 char *org_path = NULL;
285 char ignore_path[MS_FILE_PATH_LEN_MAX] = {0, };
287 #ifndef _USE_TVPD_MODE
288 char replace[MS_FILE_PATH_LEN_MAX] = {0, };
289 char *mediashared = NULL;
292 /* Check for symbolic link */
293 tmp_path = realpath(path, NULL);
294 /* Get trimmed path */
295 __ms_trim_path(path, &org_path);
297 #ifdef _USE_TVPD_MODE
298 if (g_strcmp0(tmp_path, org_path) != 0) {
299 MS_SAFE_FREE(tmp_path);
301 MS_DBG_ERR("symbolic link(directory)");
302 return MS_MEDIA_ERR_INVALID_PARAMETER;
305 if (g_str_has_prefix(tmp_path, MEDIA_SHARE_PATH)) {
306 ms_user_get_mediashared_path(uid, &mediashared);
307 snprintf(replace, MS_FILE_PATH_LEN_MAX, "%s%s", mediashared, tmp_path + strlen(MEDIA_SHARE_PATH));
308 MS_SAFE_FREE(mediashared);
309 if (g_strcmp0(replace, org_path) != 0) {
310 MS_SAFE_FREE(tmp_path);
312 MS_DBG_ERR("symbolic link(directory)");
313 return MS_MEDIA_ERR_INVALID_PARAMETER;
316 if (g_strcmp0(tmp_path, org_path) != 0) {
317 MS_SAFE_FREE(tmp_path);
319 MS_DBG_ERR("symbolic link(directory)");
320 return MS_MEDIA_ERR_INVALID_PARAMETER;
324 MS_SAFE_FREE(tmp_path);
327 if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
328 snprintf(ignore_path, sizeof(ignore_path), "%s/%s", path, ignore_file);
330 if (g_file_test(ignore_path, G_FILE_TEST_EXISTS)) {
331 MS_DBG_WARN("scan ignore file exist [%s]", ignore_path);
332 return MS_MEDIA_ERR_INVALID_PARAMETER;
335 MS_DBG_ERR("g_file_test fails[%s]", path);
336 ret = MS_MEDIA_ERR_INVALID_PARAMETER;
338 if (!MS_STRING_VALID(MEDIA_ROOT_PATH_USB)) {
339 MS_DBG_ERR("Fail to get USB path");
343 if (strstr(path, MEDIA_ROOT_PATH_USB) != NULL) {
344 /*if the directory does not exist, check the device is unmounted*/
345 if (!ms_storage_mount_status(path)) {
346 MS_DBG_ERR("Device is unmounted[%s]", path);
347 return MS_MEDIA_ERR_USB_UNMOUNTED;
355 bool ms_storage_mount_status(const char* start_path)
358 #ifndef _USE_DEVICED_DBUS
361 usb_device_list_h list;
363 char *mount_path = NULL;
365 char *storage_path = NULL;
366 char *remain_path = NULL;
369 remain_path = strstr(start_path+strlen(MEDIA_ROOT_PATH_USB) +1, "/");
370 if (remain_path != NULL)
371 remain_len = strlen(remain_path);
373 storage_path = g_strndup(start_path, strlen(start_path) - remain_len);
375 MS_DBG_SWARN("storage_path [%s]", storage_path);
377 err = usb_device_get_device_list(USB_MASS_STORAGE, &list);
379 count = usb_device_list_get_count(list);
381 err = usb_device_list_get_first(list, &device);
382 if (err != USB_ERROR_LIST_FAILED_TO_GET && device != NULL) {
383 mount_path = usb_device_get_mountpath(device);
384 if (mount_path != NULL) {
385 MS_DBG_SWARN("mount_path [%s]", mount_path);
386 if (strlen(mount_path) == strlen(storage_path)) {
387 if (strncmp(mount_path, storage_path, strlen(mount_path)) == 0) {
388 MS_DBG_SWARN("start path is mounted [%s]", start_path);
396 while (usb_device_list_get_next(list, &device) == 0) {
397 if (device != NULL) {
398 mount_path = usb_device_get_mountpath(device);
399 if (mount_path != NULL) {
400 MS_DBG_SWARN("mount_path [%s]", mount_path);
401 if (strlen(mount_path) == strlen(storage_path)) {
402 if (strncmp(mount_path, storage_path, strlen(mount_path)) == 0) {
403 MS_DBG_SWARN("start path is mounted [%s]", start_path);
414 usb_device_free_device_list(list);
416 MS_DBG_ERR("usb_device_get_device_list falied [%d]", err);
419 g_free(storage_path);
424 int ms_set_db_status(ms_db_status_type_t status, ms_user_storage_type_e storage_type)
426 int ret = MS_MEDIA_ERR_NONE;
428 if (status == MS_DB_UPDATING) {
429 if (!ms_config_set_int(VCONFKEY_FILEMANAGER_DB_STATUS, VCONFKEY_FILEMANAGER_DB_UPDATING))
432 if (storage_type == MS_USER_STORAGE_EXTERNAL) {
433 if (!ms_config_set_int(VCONFKEY_FILEMANAGER_MMC_STATUS, VCONFKEY_FILEMANAGER_MMC_LOADING))
437 if (!ms_config_set_int(VCONFKEY_FILEMANAGER_DB_STATUS, VCONFKEY_FILEMANAGER_DB_UPDATED))
440 if (storage_type == MS_USER_STORAGE_EXTERNAL) {
441 if (!ms_config_set_int(VCONFKEY_FILEMANAGER_MMC_STATUS, VCONFKEY_FILEMANAGER_MMC_LOADED))
446 ret = ms_set_power_mode(status);
447 if (ret != MS_MEDIA_ERR_NONE)
448 MS_DBG_ERR("ms_set_power_mode fail");
452 MS_DBG_ERR("ms_config_set_int failed");
453 return MS_MEDIA_ERR_INTERNAL;
456 int ms_set_power_mode(ms_db_status_type_t status)
458 int res = MS_MEDIA_ERR_NONE;
463 err = device_power_request_lock(POWER_LOCK_CPU, 0);
465 res = MS_MEDIA_ERR_INTERNAL;
468 err = device_power_release_lock(POWER_LOCK_CPU);
470 res = MS_MEDIA_ERR_INTERNAL;
473 MS_DBG_ERR("Unacceptable type : %d", status);
480 void ms_trim_dir_path(char *dir_path)
482 /* need implementation */
483 /* if dir_path is not NULL terminated, this function will occure crash */
484 int len = strlen(dir_path);
486 if (dir_path[len -1] == '/')
487 dir_path[len -1] = '\0';
490 int ms_check_size_mediadb(uid_t uid, double *db_size)
492 int ret = MS_MEDIA_ERR_NONE;
493 char *db_path = NULL;
496 ret = ms_user_get_media_db_path(uid, &db_path);
498 if (stat(db_path, &buf) == 0) {
499 *db_size = buf.st_size;
501 MS_DBG_STRERROR("stat failed");
502 ret = MS_MEDIA_ERR_INTERNAL;
510 #ifdef _SET_VIP_PROCESS
511 #define PROC_OOM_SCORE_ADJ_PATH "/proc/%d/oom_score_adj"
512 #define VIP_OOM_SCORE_ADJ (-1000)
513 #define PROC_NAME_MAX 1024
514 #define PROC_BUF_MAX 64
516 static int ms_get_cmdline_from_proc(pid_t pid, char *cmdline)
518 char buf[PROC_BUF_MAX];
519 char cmdline_buf[PROC_NAME_MAX];
523 snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
524 fp = fopen(buf, "r");
526 return MS_MEDIA_ERR_INTERNAL;
528 if (fgets(cmdline_buf, PROC_NAME_MAX-1, fp) == NULL) {
530 return MS_MEDIA_ERR_INTERNAL;
534 filename = strrchr(cmdline_buf, '/');
535 if (filename == NULL)
536 filename = cmdline_buf;
538 filename = filename + 1;
540 SAFE_STRLCPY(cmdline, filename, PROC_NAME_MAX);
542 return MS_MEDIA_ERR_NONE;
545 int ms_set_vip_process(void)
549 static pid_t pid = 0;
550 static char process_name[PROC_NAME_MAX] = {0};
551 static char *appid = NULL;
555 if (ms_get_cmdline_from_proc(pid, process_name)) {
556 MS_DBG_ERR("%s: Read process name failed pid[%d]", __func__, pid);
557 return MS_MEDIA_ERR_INTERNAL;
559 appid = process_name;
561 MS_DBG("Process name[%s]:Pid[%d]", appid, pid);
563 if (prctl(PR_GET_DUMPABLE) == 0)
564 prctl(PR_SET_DUMPABLE, 1);
566 snprintf(buf, sizeof(buf), PROC_OOM_SCORE_ADJ_PATH, pid);
567 id = open(buf, O_WRONLY, 0777);
569 MS_DBG_ERR("fopen %s failed errno:%d", buf, errno);
570 return MS_MEDIA_ERR_INTERNAL;
572 snprintf(buf, sizeof(buf), "%d", VIP_OOM_SCORE_ADJ);
573 if (write(id, buf, strlen(buf)) < 0) {
574 MS_DBG_ERR("write() failed errno=%d", errno);
576 return MS_MEDIA_ERR_INTERNAL;
579 return MS_MEDIA_ERR_NONE;