2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
23 #include <tzplatform_config.h>
24 #include <libsyscommon/list.h>
28 #include "storage-external.h"
30 const char *dir_path[STORAGE_DIRECTORY_MAX];
32 const int tz_id[STORAGE_DIRECTORY_MAX] = {
33 [STORAGE_DIRECTORY_IMAGES] = TZ_USER_IMAGES,
34 [STORAGE_DIRECTORY_SOUNDS] = TZ_USER_SOUNDS,
35 [STORAGE_DIRECTORY_VIDEOS] = TZ_USER_VIDEOS,
36 [STORAGE_DIRECTORY_CAMERA] = TZ_USER_CAMERA,
37 [STORAGE_DIRECTORY_DOWNLOADS] = TZ_USER_DOWNLOADS,
38 [STORAGE_DIRECTORY_MUSIC] = TZ_USER_MUSIC,
39 [STORAGE_DIRECTORY_DOCUMENTS] = TZ_USER_DOCUMENTS,
40 [STORAGE_DIRECTORY_OTHERS] = TZ_USER_OTHERS,
43 static GList *st_int_head; /* Internal storage list */
45 static GList *compat_cb_list;
46 struct compat_cb_info {
47 storage_state_changed_cb user_cb;
51 void add_device(const struct storage_ops *st)
53 SYS_G_LIST_APPEND(st_int_head, st);
56 void remove_device(const struct storage_ops *st)
58 SYS_G_LIST_REMOVE(st_int_head, st);
61 API int storage_foreach_device_supported(storage_device_supported_cb callback, void *user_data)
63 const struct storage_ops *st;
69 _E("Invalid parameter");
70 return STORAGE_ERROR_INVALID_PARAMETER;
73 if (getuid() <= USER_UID_START)
76 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
78 ret_val = callback(st->storage_id, st->type, st->get_state(),
79 st->root(), user_data);
80 /* if the return value is false, will be stop to iterate */
86 if (!storage_ext_is_supported()) {
88 _D("Block module is not enabled");
89 return STORAGE_ERROR_NONE;
93 ret_val = storage_ext_foreach_device_list(callback, user_data);
95 _E("Failed to iterate external devices (%d)", ret_val); //LCOV_EXCL_LINE
96 return STORAGE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
99 return STORAGE_ERROR_NONE;
102 API int storage_get_root_directory(int storage_id, char **path)
104 const struct storage_ops *st;
112 return STORAGE_ERROR_INVALID_PARAMETER;
115 _E("Invalid parameger");
116 return STORAGE_ERROR_INVALID_PARAMETER;
119 if (getuid() <= USER_UID_START)
122 /* internal storage */
123 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
124 if (st->storage_id != storage_id)
127 _E("Only apps and user session daemons are allowed "
128 "to use storage_get_root_directory(INTERNAL_STORAGE_ID, ...)");
129 return STORAGE_ERROR_INVALID_PARAMETER;
132 *path = strdup(st->root());
134 //LCOV_EXCL_START System Error
135 _E("Failed to copy the root string : %d", errno);
136 return STORAGE_ERROR_OUT_OF_MEMORY;
139 return STORAGE_ERROR_NONE;
142 /* external storage */
143 if (!storage_ext_is_supported()) {
145 _D("Block module is not enabled");
146 return STORAGE_ERROR_NOT_SUPPORTED;
150 ret_val = storage_ext_get_root(storage_id, root, sizeof(root), &extendedint);
152 _E("Failed to get root path of external storage(%d, %d", storage_id, ret_val);
153 if (ret_val == -ENODEV || ret_val == -EINVAL)
154 return STORAGE_ERROR_INVALID_PARAMETER;
156 else if (ret_val == -ENOMEM)
157 return STORAGE_ERROR_OUT_OF_MEMORY;
159 return STORAGE_ERROR_OPERATION_FAILED;
163 *path = strdup(root);
165 //LCOV_EXCL_START System error
166 _E("Failed to copy the root string : %d", errno);
167 return STORAGE_ERROR_OUT_OF_MEMORY;
171 return STORAGE_ERROR_NONE;
174 API int storage_get_directory(int storage_id, storage_directory_e type, char **path)
176 const struct storage_ops *st;
187 return STORAGE_ERROR_INVALID_PARAMETER;
190 _E("Invalid parameger");
191 return STORAGE_ERROR_INVALID_PARAMETER;
194 if (type < 0 || type >= STORAGE_DIRECTORY_MAX) {
195 _E("Invalid parameter");
196 return STORAGE_ERROR_INVALID_PARAMETER;
199 /* internal storage */
201 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
202 if (st->storage_id != storage_id)
208 if (getuid() <= USER_UID_START)
213 _E("Only apps and user session daemons are allowed "
214 "to use storage_get_root_directory(INTERNAL_STORAGE_ID, ...)");
216 return STORAGE_ERROR_INVALID_PARAMETER;
219 snprintf(root, sizeof(root), "%s", st->root());
220 if (type == STORAGE_DIRECTORY_SYSTEM_RINGTONES) {
221 temp2 = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
223 return STORAGE_ERROR_OPERATION_FAILED;
224 end = strrchr(temp2, '/');
227 snprintf(temp, PATH_MAX, "%s", temp2);
230 if ((ret_val = snprintf(temp, PATH_MAX, "%s/%s", root, dir_path[type])) > PATH_MAX - 1) {
232 _E("Path is longer than buffer. Need %d size of buffer.", ret_val + 1);
233 return STORAGE_ERROR_OUT_OF_MEMORY;
241 /* external storage */
242 if (!storage_ext_is_supported()) {
244 _D("Block module is not enabled");
245 return STORAGE_ERROR_NOT_SUPPORTED;
249 if (type == STORAGE_DIRECTORY_SYSTEM_RINGTONES) {
250 _E("Not support directory : id(%d) type(%d)", storage_id, type);
251 return STORAGE_ERROR_INVALID_PARAMETER;
254 ret_val = storage_ext_get_root(storage_id, root, sizeof(root), &extendedint);
256 _E("Failed to get root dir for external storage(id:%d, ret:%d)", storage_id, ret_val);
257 if (ret_val == -ENODEV || ret_val == -EINVAL)
258 return STORAGE_ERROR_INVALID_PARAMETER;
260 else if (ret_val == -ENOMEM)
261 return STORAGE_ERROR_OUT_OF_MEMORY;
263 return STORAGE_ERROR_OPERATION_FAILED;
266 /* The operation is not decided */
268 return STORAGE_ERROR_INVALID_PARAMETER;
270 if ((ret_val = snprintf(temp, sizeof(temp), "%s/%s", root, dir_path[type])) > sizeof(temp) - 1) {
272 _E("Path is longer than buffer. Need %d size of buffer.", ret_val + 1);
273 return STORAGE_ERROR_OUT_OF_MEMORY;
278 *path = strdup(temp);
280 //LCOV_EXCL_START System error
281 _E("Failed to copy the directory(%d) string : %d", type, errno);
282 return STORAGE_ERROR_OUT_OF_MEMORY;
286 return STORAGE_ERROR_NONE;
289 API int storage_get_type(int storage_id, storage_type_e *type)
291 const struct storage_ops *st;
298 return STORAGE_ERROR_INVALID_PARAMETER;
301 _E("Invalid parameger");
302 return STORAGE_ERROR_INVALID_PARAMETER;
305 /* internal storage */
306 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
307 if (st->storage_id != storage_id)
310 return STORAGE_ERROR_NONE;
313 /* external storage */
314 if (!storage_ext_is_supported()) {
316 _D("Block module is not enabled");
317 return STORAGE_ERROR_NOT_SUPPORTED;
321 ret_val = storage_ext_get_root(storage_id, root, sizeof(root), &extendedint);
323 _E("Failed to get type of external storage");
324 if (ret_val == -ENODEV || ret_val == -EINVAL)
325 return STORAGE_ERROR_INVALID_PARAMETER;
327 else if (ret_val == -ENOMEM)
328 return STORAGE_ERROR_OUT_OF_MEMORY;
330 return STORAGE_ERROR_OPERATION_FAILED;
334 *type = STORAGE_TYPE_EXTENDED_INTERNAL;
336 *type = STORAGE_TYPE_EXTERNAL;
338 return STORAGE_ERROR_NONE;
341 API int storage_get_state(int storage_id, storage_state_e *state)
343 const struct storage_ops *ops;
349 return STORAGE_ERROR_INVALID_PARAMETER;
352 _E("Invalid parameger");
353 return STORAGE_ERROR_INVALID_PARAMETER;
356 /* internal storage */
357 SYS_G_LIST_FOREACH(st_int_head, elem, ops) {
358 if (ops->storage_id != storage_id)
360 *state = ops->get_state();
361 return STORAGE_ERROR_NONE;
364 /* external storage */
365 if (!storage_ext_is_supported()) {
367 _D("Block module is not enabled");
368 return STORAGE_ERROR_NOT_SUPPORTED;
372 ret_val = storage_ext_get_state(storage_id, &st);
374 _E("Failed to get state (storage id(%d), ret_val(%d))", storage_id, ret_val);
375 if (ret_val == -ENODEV || ret_val == -EINVAL)
376 return STORAGE_ERROR_INVALID_PARAMETER;
378 else if (ret_val == -ENOMEM)
379 return STORAGE_ERROR_OUT_OF_MEMORY;
381 return STORAGE_ERROR_OPERATION_FAILED;
386 return STORAGE_ERROR_NONE;
389 //LCOV_EXCL_START Not called Callback
390 static void compat_cb(int storage_id,
391 storage_dev_e dev, storage_state_e state,
392 const char *fstype, const char *fsuuid, const char *mountpath,
393 bool primary, int flags, void *user_data)
395 struct compat_cb_info* ccb_info;
398 if (storage_id == STORAGE_TYPE_EXTERNAL && dev == STORAGE_DEV_EXT_SDCARD)
399 SYS_G_LIST_FOREACH(compat_cb_list, elem, ccb_info)
400 ccb_info->user_cb(storage_id, state, ccb_info->user_data);
404 API int storage_set_state_changed_cb(int storage_id, storage_state_changed_cb callback, void *user_data)
406 const struct storage_ops *st;
407 struct storage_cb_info info;
411 struct compat_cb_info* ccb_info;
412 static int compat_cb_init = 0;
415 return STORAGE_ERROR_INVALID_PARAMETER;
418 _E("Invalid parameger");
419 return STORAGE_ERROR_INVALID_PARAMETER;
422 /* For backward compatability */
423 if (storage_id == STORAGE_TYPE_EXTERNAL) {
424 if (!storage_ext_is_supported()) {
426 _D("Block module is not enabled");
427 return STORAGE_ERROR_NOT_SUPPORTED;
431 if (!compat_cb_init) {
432 ret = storage_set_changed_cb(STORAGE_TYPE_EXTERNAL, compat_cb, NULL);
433 if (ret == STORAGE_ERROR_NONE)
439 ccb_info = malloc(sizeof(struct compat_cb_info));
440 if (ccb_info == NULL)
441 return STORAGE_ERROR_OPERATION_FAILED;
442 ccb_info->user_cb = callback;
443 ccb_info->user_data = user_data;
444 SYS_G_LIST_APPEND(compat_cb_list, ccb_info);
446 return STORAGE_ERROR_NONE;
449 /* Internal storage does not support registering changed callback */
450 SYS_G_LIST_FOREACH(st_int_head, elem, st)
451 if (st->storage_id == storage_id)
452 return STORAGE_ERROR_NONE;
454 /* external storage */
455 if (!storage_ext_is_supported()) {
457 _D("Block module is not enabled");
458 return STORAGE_ERROR_NOT_SUPPORTED;
462 info.id = storage_id;
463 info.state_cb = callback;
464 info.user_data = user_data;
466 ret = storage_ext_register_cb(STORAGE_CALLBACK_ID, &info);
469 _E("Failed to register callback : id(%d)", storage_id);
470 return STORAGE_ERROR_OPERATION_FAILED;
474 return STORAGE_ERROR_NONE;
477 API int storage_unset_state_changed_cb(int storage_id, storage_state_changed_cb callback)
479 const struct storage_ops *st;
480 struct storage_cb_info info;
485 return STORAGE_ERROR_INVALID_PARAMETER;
488 _E("Invalid parameger");
489 return STORAGE_ERROR_INVALID_PARAMETER;
492 /* For backward compatability */
493 if (storage_id == STORAGE_TYPE_EXTERNAL) {
494 if (!storage_ext_is_supported()) {
496 _D("Block module is not enabled");
497 return STORAGE_ERROR_NOT_SUPPORTED;
502 struct compat_cb_info* ccb_info;
504 SYS_G_LIST_FOREACH_SAFE(compat_cb_list, elem, elem_n, ccb_info) {
505 if (ccb_info->user_cb == callback) {
506 SYS_G_LIST_REMOVE(compat_cb_list, ccb_info);
508 return STORAGE_ERROR_NONE;
511 return STORAGE_ERROR_OPERATION_FAILED;
514 /* Internal storage does not support registering changed callback */
515 SYS_G_LIST_FOREACH(st_int_head, elem, st)
516 if (st->storage_id == storage_id)
517 return STORAGE_ERROR_NONE;
519 /* external storage */
520 if (!storage_ext_is_supported()) {
522 _D("Block module is not enabled");
523 return STORAGE_ERROR_NOT_SUPPORTED;
527 info.id = storage_id;
528 info.state_cb = callback;
530 ret_val = storage_ext_unregister_cb(STORAGE_CALLBACK_ID, &info);
533 _E("Failed to unregister callback : id(%d)", storage_id);
534 return STORAGE_ERROR_OPERATION_FAILED;
538 return STORAGE_ERROR_NONE;
541 API int storage_get_total_space(int storage_id, unsigned long long *bytes)
543 const struct storage_ops *st;
544 unsigned long long total;
549 return STORAGE_ERROR_INVALID_PARAMETER;
552 _E("Invalid parameger");
553 return STORAGE_ERROR_INVALID_PARAMETER;
556 /* internal storage */
557 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
558 if (st->storage_id != storage_id)
560 ret_val = st->get_space(&total, NULL);
564 /* external storage */
565 if (!storage_ext_is_supported()) {
567 _D("Block module is not enabled");
568 return STORAGE_ERROR_NOT_SUPPORTED;
572 ret_val = storage_ext_get_space(storage_id, &total, NULL);
576 _E("Failed to get total memory : id(%d)", storage_id);
577 if (ret_val == -ENODEV || ret_val == -EINVAL)
578 return STORAGE_ERROR_INVALID_PARAMETER;
580 else if (ret_val == -ENOMEM)
581 return STORAGE_ERROR_OUT_OF_MEMORY;
583 return STORAGE_ERROR_OPERATION_FAILED;
588 return STORAGE_ERROR_NONE;
591 API int storage_get_available_space(int storage_id, unsigned long long *bytes)
593 const struct storage_ops *st;
594 unsigned long long avail;
599 return STORAGE_ERROR_INVALID_PARAMETER;
602 _E("Invalid parameger");
603 return STORAGE_ERROR_INVALID_PARAMETER;
606 /* internal storage */
607 SYS_G_LIST_FOREACH(st_int_head, elem, st) {
608 if (st->storage_id != storage_id)
610 ret_val = st->get_space(NULL, &avail);
614 /* external storage */
615 if (!storage_ext_is_supported()) {
617 _D("Block module is not enabled");
618 return STORAGE_ERROR_NOT_SUPPORTED;
622 ret_val = storage_ext_get_space(storage_id, NULL, &avail);
626 _E("Failed to get available memory : id(%d)", storage_id);
627 if (ret_val == -ENODEV || ret_val == -EINVAL)
628 return STORAGE_ERROR_INVALID_PARAMETER;
630 else if (ret_val == -ENOMEM)
631 return STORAGE_ERROR_OUT_OF_MEMORY;
633 return STORAGE_ERROR_OPERATION_FAILED;
638 return STORAGE_ERROR_NONE;
641 API int storage_set_changed_cb(storage_type_e type, storage_changed_cb callback, void *user_data)
644 struct storage_cb_info info;
646 if (type == STORAGE_TYPE_INTERNAL) {
647 _E("Internal storage is not supported");
648 return STORAGE_ERROR_INVALID_PARAMETER;
651 if (type != STORAGE_TYPE_EXTERNAL && type != STORAGE_TYPE_EXTENDED_INTERNAL) {
652 _E("Invalid type (%d)", type);
653 return STORAGE_ERROR_INVALID_PARAMETER;
657 _E("Callback is NULL");
658 return STORAGE_ERROR_INVALID_PARAMETER;
661 if (!storage_ext_is_supported()) {
663 _E("Block module is not enabled");
664 return STORAGE_ERROR_NOT_SUPPORTED;
668 /* external storage */
670 info.type_cb = callback;
671 info.user_data = user_data;
673 ret_val = storage_ext_register_cb(STORAGE_CALLBACK_TYPE, &info);
676 _E("Failed to register storage callback(ret:%d)", ret_val);
677 return STORAGE_ERROR_OPERATION_FAILED;
681 return STORAGE_ERROR_NONE;
684 API int storage_unset_changed_cb(storage_type_e type, storage_changed_cb callback)
686 struct storage_cb_info info;
689 if (type == STORAGE_TYPE_INTERNAL) {
690 _E("Internal storage is not supported");
691 return STORAGE_ERROR_INVALID_PARAMETER;
694 if (type != STORAGE_TYPE_EXTERNAL && type != STORAGE_TYPE_EXTENDED_INTERNAL) {
695 _E("Invalid type (%d)", type);
696 return STORAGE_ERROR_INVALID_PARAMETER;
700 _E("Callback is NULL");
701 return STORAGE_ERROR_INVALID_PARAMETER;
704 if (!storage_ext_is_supported()) {
706 _E("Block module is not enabled");
707 return STORAGE_ERROR_NOT_SUPPORTED;
711 /* external storage */
713 info.type_cb = callback;
715 ret_val = storage_ext_unregister_cb(STORAGE_CALLBACK_TYPE, &info);
718 _E("Failed to unregister storage callback(ret:%d)", ret_val);
719 return STORAGE_ERROR_OPERATION_FAILED;
723 return STORAGE_ERROR_NONE;
726 API int storage_get_type_dev(int storage_id, storage_type_e *type, storage_dev_e *dev)
728 storage_ext_device *ext_dev;
731 if (storage_id < 0 || !type || !dev) {
732 _E("Invalid parameter");
733 return STORAGE_ERROR_INVALID_PARAMETER;
736 ret = storage_get_type(storage_id, type);
737 if (ret != STORAGE_ERROR_NONE) {
739 _E("Failed to get storage type: %d", ret);
743 if (*type == STORAGE_TYPE_INTERNAL || *type == STORAGE_TYPE_EXTENDED_INTERNAL)
744 return STORAGE_ERROR_INVALID_PARAMETER;
746 if (!storage_ext_is_supported()) {
748 _D("Block module is not enabled");
749 return STORAGE_ERROR_NOT_SUPPORTED;
753 ext_dev = calloc(1, sizeof(storage_ext_device));
755 //LCOV_EXCL_START System Error
757 return STORAGE_ERROR_OUT_OF_MEMORY;
761 ret = storage_ext_get_device_info(storage_id, ext_dev);
763 _E("Cannot get the storage with id (%d, ret:%d)", storage_id, ret); //LCOV_EXCL_LINE
764 if (ret == -ENODEV) {
765 ret = STORAGE_ERROR_INVALID_PARAMETER;
769 ret = STORAGE_ERROR_OPERATION_FAILED;
774 if (ext_dev->type == STORAGE_EXT_SCSI)
775 *dev = STORAGE_DEV_EXT_USB_MASS_STORAGE;
776 else if (ext_dev->type == STORAGE_EXT_MMC)
777 *dev = STORAGE_DEV_EXT_SDCARD;
778 ret = STORAGE_ERROR_NONE;
779 _I("type: %d(internal:0, external:1) dev: %d(sdcard: 1001, usb: 1002)", *type, *dev);
782 storage_ext_release_device(&ext_dev);
786 static void __CONSTRUCTOR__ init(void)
792 for (i = 0 ; i <= STORAGE_DIRECTORY_OTHERS ; i++) {
793 tmp = tzplatform_getenv(tz_id[i]);
795 token = rindex(tmp, '/');
798 dir_path[i] = strdup(token);