int ms_ipc_send_msg_to_server_tcp(int sockfd, ms_msg_port_type_e port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr);
int ms_ipc_send_msg_to_client_tcp(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr);
int ms_ipc_accept_client_tcp(int serv_sock, int* client_sock);
+int ms_ipc_request_recovery(uid_t uid);
+int ms_ipc_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg, uid_t uid);
#ifdef __cplusplus
}
MS_MEDIA_ITEM_UPDATE = 2,
} media_item_update_type_e;
-typedef enum {
- MS_MEDIA_UNKNOWN = -1, /**< Unknown Conntent*/
- MS_MEDIA_IMAGE = 0, /**< Image Content*/
- MS_MEDIA_VIDEO = 1, /**< Video Content*/
- MS_MEDIA_SOUND = 2, /**< Sound Content like Ringtone*/
- MS_MEDIA_MUSIC = 3, /**< Music Content like mp3*/
- MS_MEDIA_OTHER = 4, /**< Invalid Content*/
-} media_type_e;
-
typedef void (*db_updated_cb)(int pid, /* mandatory */
media_item_type_e item, /* mandatory */
media_item_update_type_e update_type, /* mandatory */
char *path, /* mandatory */
char *uuid, /* optional */
- media_type_e media_type, /* optional */
+ int media_type, /* optional */
char *mime_type, /* optional */
void *user_data);
media_item_update_type_e update_type, /* mandatory */
const char *path, /* mandatory */
const char *uuid, /* optional */
- media_type_e media_type, /* optional */
+ int media_type, /* optional */
const char *mime_type /* optional */
);
#define _MEDIA_UTIL_USER_H_
#include <stddef.h>
+#include <stdbool.h>
+#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
size_t ms_user_get_root_length(const char *path, uid_t uid);
-char *ms_user_get_ipc_path(ms_msg_port_type_e type);
+int ms_user_make_ipc_path(char *dest, const char *src, size_t dest_len);
#ifdef __cplusplus
}
#include <media-util-cynara.h>
#include <media-util-user.h>
-#ifdef _USE_TVPD_MODE
-#define MEDIA_DB_SIZE_LIMIT_2 20000000
-#define MEDIA_DB_SIZE_LIMIT_1 10000000
-#define MEDIA_DB_SPACE_LIMIT 20971520
-#endif
-
-#define MS_SAFE_FREE(src) { if (src) {free(src); src = NULL; } }
-
#endif /*_MEDIA_UTIL_H_*/
return MS_MEDIA_ERR_IPC;
}
- MSAPI_RETVM_IF(!strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE, MS_MEDIA_ERR_IPC, "Invalid msg");
+ MSAPI_RETVM_IF(strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE, MS_MEDIA_ERR_IPC, "Invalid msg");
MSAPI_DBG_SLOG("receive msg from P[%d] T[%d] M[%.*s] S[%.*s]", recv_msg->pid, recv_msg->msg_type, MAX_MSG_SIZE, recv_msg->msg, MS_UUID_SIZE, recv_msg->storage_id);
#include <vconf.h>
#include "media-util-dbg.h"
-#include "media-util.h"
-
-#define MS_TIMEOUT_SEC 10
-
-static int __media_db_request_recovery(uid_t uid);
+#include "media-util-ipc.h"
+#include "media-util-db.h"
+#include "media-util-err.h"
+#include "media-util-user.h"
static int __media_db_busy_handler(void *pData, int count)
{
char *sql = NULL;
MSAPI_DBG_ERR("need_write[%d]", need_write);
ret = ms_user_get_media_db_path(uid, &db_path);
- MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_DB_INTERNAL, "ms_user_get_media_db_path failed");
+ MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "ms_user_get_media_db_path failed");
+ MSAPI_RETVM_IF(!db_path, MS_MEDIA_ERR_DB_INTERNAL, "db_path is NULL");
/*Connect DB*/
if (need_write)
if (SQLITE_OK != ret) {
MSAPI_DBG_ERR("error when db open path[%s],ret[%d]", db_path, ret);
- g_free(db_path);
+ free(db_path);
*db_handle = NULL;
return MS_MEDIA_ERR_DB_INTERNAL;
}
- g_free(db_path);
+ free(db_path);
if (*db_handle == NULL) {
MSAPI_DBG_ERR("*db_handle is NULL");
return MS_MEDIA_ERR_NONE;
}
-#define MAX_RETRY_COUNT 3
-
-static int __media_db_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
-{
- int ret = MS_MEDIA_ERR_NONE;
- int sockfd = -1;
- struct sockaddr_un serv_addr = { 0, };
- int retry_count = 0;
- g_autofree gchar *ipc_path = NULL;
-
- MSAPI_RETVM_IF(!request_msg || strlen(request_msg) == 0, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid request_msg");
-
- ms_comm_msg_s send_msg = { 0, };
-
- send_msg.msg_type = msg_type;
- if (g_strlcpy(send_msg.msg, request_msg, sizeof(send_msg.msg)) >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("request_msg exceeds MAX_MSG_SIZE");
- return MS_MEDIA_ERR_INVALID_PARAMETER;
- }
-
- send_msg.uid = uid;
-
- /*Create Socket*/
- ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC, &sockfd);
- MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
-
- /*Set server Address*/
- serv_addr.sun_family = AF_UNIX;
- ipc_path = ms_user_get_ipc_path(MS_DB_UPDATE_PORT);
- MSAPI_RETV_IF(!ipc_path, MS_MEDIA_ERR_INTERNAL);
- g_strlcpy(serv_addr.sun_path, ipc_path, sizeof(serv_addr.sun_path));
-
- /* Connecting to the media db server */
- if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
- MSAPI_DBG_STRERROR("connect error");
- close(sockfd);
- if (errno == EACCES)
- return MS_MEDIA_ERR_PERMISSION_DENIED;
- else
- return MS_MEDIA_ERR_IPC;
- }
-
- /* Send request */
- if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
- MSAPI_DBG_STRERROR("send failed");
- close(sockfd);
- return MS_MEDIA_ERR_IPC;
- }
-
- /*Receive Response*/
- int recv_msg_size = -1;
- int recv_msg = -1;
-RETRY:
- if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
- MSAPI_DBG_STRERROR("recv failed");
-
- if (errno == EINTR || errno == EWOULDBLOCK) {
- if (retry_count < MAX_RETRY_COUNT) {
- MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
- retry_count++;
- goto RETRY;
- }
- }
- close(sockfd);
- return MS_MEDIA_ERR_IPC;
- }
-
- MSAPI_DBG("RECEIVE OK [%d]", recv_msg);
- ret = recv_msg;
-
- close(sockfd);
-
- return ret;
-}
-
#define RETRY_CNT 9
#define SLEEP_TIME 1000 * 1000
static int __media_db_update_directly(sqlite3 *db_handle, const char *sql_str)
if (ret == MS_MEDIA_ERR_DB_CORRUPT && retry_cnt == 0) {
retry_cnt++;
- ret = __media_db_request_recovery(uid);
+ ret = ms_ipc_request_recovery(uid);
if (ret == MS_MEDIA_ERR_NONE)
goto RETRY_CONN;
else
MSAPI_RETVM_IF(!query_str || strlen(query_str) == 0, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
- ret = __media_db_request_update_tcp(MS_MSG_DB_UPDATE, query_str, uid);
+ ret = ms_ipc_request_update_tcp(MS_MSG_DB_UPDATE, query_str, uid);
if (ret != MS_MEDIA_ERR_NONE)
- MSAPI_DBG_ERR("__media_db_request_update_tcp failed : %d", ret);
+ MSAPI_DBG_ERR("ms_ipc_request_update_tcp failed : %d", ret);
return ret;
}
return ret;
}
-static int __media_db_request_recovery(uid_t uid)
-{
- int ret = MS_MEDIA_ERR_NONE;
- int sockfd = -1;
- struct sockaddr_un serv_addr = { 0, };
- int retry_count = 0;
- char *db_path = NULL;
- g_autofree gchar *ipc_path = NULL;
-
- ret = ms_user_get_media_db_path(uid, &db_path);
- MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PARAMETER, "ms_user_get_media_db_path failed");
- MSAPI_RETVM_IF(!db_path, MS_MEDIA_ERR_INVALID_PARAMETER, "db_path is NULL");
-
- ms_comm_msg_s send_msg = { 0, };
-
- send_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
- if (g_strlcpy(send_msg.msg, db_path, sizeof(send_msg.msg)) >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("db_path exceeds MAX_MSG_SIZE");
- return MS_MEDIA_ERR_INVALID_PARAMETER;
- }
- g_free(db_path);
- send_msg.uid = uid;
-
- /*Create Socket*/
- ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC, &sockfd);
- MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
-
- /*Set server Address*/
- serv_addr.sun_family = AF_UNIX;
- ipc_path = ms_user_get_ipc_path(MS_SCANNER_PORT);
- MSAPI_RETV_IF(!ipc_path, MS_MEDIA_ERR_INTERNAL);
- g_strlcpy(serv_addr.sun_path, ipc_path, sizeof(serv_addr.sun_path));
-
- /* Connecting to the media db server */
- if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
- MSAPI_DBG_STRERROR("connect error");
- close(sockfd);
- return MS_MEDIA_ERR_IPC;
- }
-
- /* Send request */
- if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
- MSAPI_DBG_STRERROR("send failed");
- close(sockfd);
- return MS_MEDIA_ERR_IPC;
- }
-
- /*Receive Response*/
- int recv_msg_size = -1;
- ms_comm_msg_s recv_msg;
-RETRY:
- if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
- MSAPI_DBG_STRERROR("recv failed");
-
- if (errno == EINTR || errno == EWOULDBLOCK) {
- if (retry_count < MAX_RETRY_COUNT) {
- MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
- retry_count++;
- goto RETRY;
- }
- }
- close(sockfd);
- return MS_MEDIA_ERR_IPC;
- }
-
- MSAPI_DBG("RECEIVE OK [%d]", recv_msg.result);
- ret = recv_msg.result;
-
- close(sockfd);
-
- return ret;
-}
-
int media_db_get_result(sqlite3 *handle, char *sql_str, sqlite3_stmt **stmt)
{
int err = -1;
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
+#include <glib.h>
#include "media-util-dbg.h"
-#include "media-util.h"
+#include "media-util-err.h"
+#include "media-util-ipc.h"
+#include "media-util-user.h"
+
+#define MAX_RETRY_COUNT 3
+#define MS_TIMEOUT_SEC 10
+#define MS_DB_SOCK_PATH "media-server/media_ipc_dbupdate.socket"
+#define MS_SCAN_SOCK_PATH "media-server/media_ipc_scanner.socket"
int ms_ipc_create_client_socket(int timeout_sec, int *sock_fd)
{
int ms_ipc_create_server_socket(ms_msg_port_type_e port, int *sock_fd)
{
+ int ret = MS_MEDIA_ERR_NONE;
int i;
int sock = -1;
struct sockaddr_un serv_addr = { 0, };
- g_autofree gchar *ipc_path = NULL;
+
/* Create a TCP socket */
if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
MSAPI_DBG_STRERROR("socket failed");
}
serv_addr.sun_family = AF_UNIX;
- ipc_path = ms_user_get_ipc_path(port);
- MSAPI_RETV_IF(!ipc_path, MS_MEDIA_ERR_INTERNAL);
- unlink(ipc_path);
- g_strlcpy(serv_addr.sun_path, ipc_path, sizeof(serv_addr.sun_path));
+ if (port == MS_DB_UPDATE_PORT)
+ ret = ms_user_make_ipc_path(serv_addr.sun_path, MS_DB_SOCK_PATH, sizeof(serv_addr.sun_path));
+ else
+ ret = ms_user_make_ipc_path(serv_addr.sun_path, MS_SCAN_SOCK_PATH, sizeof(serv_addr.sun_path));
+ if (ret != MS_MEDIA_ERR_NONE) {
+ MSAPI_DBG_ERR("ms_user_make_ipc_path failed[%d]", ret);
+ goto ERROR;
+ }
+ unlink(serv_addr.sun_path);
/* Bind to the local address */
for (i = 0; i < 100; i++) {
MSAPI_DBG("Listening...");
/*change permission of sock file*/
- if (chmod(ipc_path, 0776) < 0)
+ if (chmod(serv_addr.sun_path, 0776) < 0)
MSAPI_DBG_STRERROR("chmod failed");
*sock_fd = sock;
int ms_ipc_send_msg_to_server_tcp(int sockfd, ms_msg_port_type_e port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr)
{
+ int ret = MS_MEDIA_ERR_NONE;
struct sockaddr_un addr = { 0, };
- g_autofree gchar *ipc_path = NULL;
addr.sun_family = AF_UNIX;
- ipc_path = ms_user_get_ipc_path(port);
- MSAPI_RETV_IF(!ipc_path, MS_MEDIA_ERR_INTERNAL);
- g_strlcpy(addr.sun_path, ipc_path, sizeof(addr.sun_path));
+ if (port == MS_DB_UPDATE_PORT)
+ ret = ms_user_make_ipc_path(addr.sun_path, MS_DB_SOCK_PATH, sizeof(addr.sun_path));
+ else
+ ret = ms_user_make_ipc_path(addr.sun_path, MS_SCAN_SOCK_PATH, sizeof(addr.sun_path));
+ MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
/* Connecting to the media db server */
if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
return MS_MEDIA_ERR_NONE;
}
+
+int ms_ipc_request_recovery(uid_t uid)
+{
+ int ret = MS_MEDIA_ERR_NONE;
+ int sockfd = -1;
+ struct sockaddr_un serv_addr = { 0, };
+ int retry_count = 0;
+ g_autofree gchar *db_path = NULL;
+
+ ret = ms_user_get_media_db_path(uid, &db_path);
+ MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PARAMETER, "ms_user_get_media_db_path failed");
+ MSAPI_RETVM_IF(!db_path, MS_MEDIA_ERR_INVALID_PARAMETER, "db_path is NULL");
+
+ ms_comm_msg_s send_msg = { 0, };
+
+ send_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
+ if (g_strlcpy(send_msg.msg, db_path, sizeof(send_msg.msg)) >= MAX_MSG_SIZE) {
+ MSAPI_DBG_ERR("db_path exceeds MAX_MSG_SIZE");
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
+ }
+ send_msg.uid = uid;
+
+ /*Create Socket*/
+ ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC, &sockfd);
+ MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
+
+ /*Set server Address*/
+ serv_addr.sun_family = AF_UNIX;
+ ret = ms_user_make_ipc_path(serv_addr.sun_path, MS_DB_SOCK_PATH, sizeof(serv_addr.sun_path));
+ if (ret != MS_MEDIA_ERR_NONE) {
+ close(sockfd);
+ return ret;
+ }
+
+ /* Connecting to the media db server */
+ if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
+ MSAPI_DBG_STRERROR("connect error");
+ close(sockfd);
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ /* Send request */
+ if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
+ MSAPI_DBG_STRERROR("send failed");
+ close(sockfd);
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ /*Receive Response*/
+ int recv_msg_size = -1;
+ ms_comm_msg_s recv_msg;
+RETRY:
+ if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
+ MSAPI_DBG_STRERROR("recv failed");
+
+ if (errno == EINTR || errno == EWOULDBLOCK) {
+ if (retry_count < MAX_RETRY_COUNT) {
+ MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
+ retry_count++;
+ goto RETRY;
+ }
+ }
+ close(sockfd);
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ MSAPI_DBG("RECEIVE OK [%d]", recv_msg.result);
+ ret = recv_msg.result;
+
+ close(sockfd);
+
+ return ret;
+}
+
+int ms_ipc_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
+{
+ int ret = MS_MEDIA_ERR_NONE;
+ int sockfd = -1;
+ struct sockaddr_un serv_addr = { 0, };
+ int retry_count = 0;
+
+ MSAPI_RETVM_IF(!request_msg || strlen(request_msg) == 0, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid request_msg");
+
+ ms_comm_msg_s send_msg = { 0, };
+
+ send_msg.msg_type = msg_type;
+ if (g_strlcpy(send_msg.msg, request_msg, sizeof(send_msg.msg)) >= MAX_MSG_SIZE) {
+ MSAPI_DBG_ERR("request_msg exceeds MAX_MSG_SIZE");
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
+ }
+
+ send_msg.uid = uid;
+
+ /*Create Socket*/
+ ret = ms_ipc_create_client_socket(MS_TIMEOUT_SEC, &sockfd);
+ MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
+
+ /*Set server Address*/
+ serv_addr.sun_family = AF_UNIX;
+ ret = ms_user_make_ipc_path(serv_addr.sun_path, MS_DB_SOCK_PATH, sizeof(serv_addr.sun_path));
+ if (ret != MS_MEDIA_ERR_NONE) {
+ close(sockfd);
+ return ret;
+ }
+
+ /* Connecting to the media db server */
+ if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
+ MSAPI_DBG_STRERROR("connect error");
+ close(sockfd);
+ if (errno == EACCES)
+ return MS_MEDIA_ERR_PERMISSION_DENIED;
+ else
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ /* Send request */
+ if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
+ MSAPI_DBG_STRERROR("send failed");
+ close(sockfd);
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ /*Receive Response*/
+ int recv_msg_size = -1;
+ int recv_msg = -1;
+RETRY:
+ if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
+ MSAPI_DBG_STRERROR("recv failed");
+
+ if (errno == EINTR || errno == EWOULDBLOCK) {
+ if (retry_count < MAX_RETRY_COUNT) {
+ MSAPI_DBG_ERR("TIME OUT[%d]", retry_count);
+ retry_count++;
+ goto RETRY;
+ }
+ }
+ close(sockfd);
+ return MS_MEDIA_ERR_IPC;
+ }
+
+ MSAPI_DBG("RECEIVE OK [%d]", recv_msg);
+ ret = recv_msg;
+
+ close(sockfd);
+
+ return ret;
+}
\ No newline at end of file
* @brief
*/
+#include <stdbool.h>
#include <glib.h>
#include <gio/gio.h>
#include "media-util-dbg.h"
-#include "media-util.h"
+#include "media-util-noti.h"
+#include "media-util-err.h"
static GList *handle_list;
static GMutex noti_mutex;
media_item_update_type_e update_type, /* mandatory */
const char *path, /* mandatory */
const char *uuid, /* optional */
- media_type_e media_type, /* optional */
+ int media_type, /* optional */
const char *mime_type /* optional */
)
{
{
gint32 item = -1;
gint32 pid = 0;
- gint32 update_type = MS_MEDIA_UNKNOWN;
+ gint32 update_type = 0;
gint32 content_type = -1;
char *update_path = NULL;
char *uuid = NULL;
g_variant_get(message, "(iiis)", &item, &pid, &update_type, &update_path);
if (item == MS_MEDIA_ITEM_DIRECTORY)
- content_type = MS_MEDIA_UNKNOWN;
+ content_type = 0;
/* getting data complete */
user_cb(pid, item, update_type, update_path, uuid, content_type, mime_type, userdata);
#include <unistd.h>
#include <sys/syscall.h>
+#include <glib.h>
#include "media-util-dbg.h"
-#include "media-util.h"
+#include "media-util-register.h"
+#include "media-util-err.h"
+#include "media-util-user.h"
+#include "media-util-ipc.h"
static GMutex scan_req_mutex;
*/
#include "media-util-dbg.h"
-#include "media-util.h"
+#include "media-util-err.h"
+#include "media-util-user.h"
#include <glib.h>
#include <unistd.h>
}
#endif
-static char MEDIA_IPC_PATH[][70] = {
- {"media-server/media_ipc_scanner.socket"},
- {"media-server/media_ipc_dbupdate.socket"},
-};
-char *ms_user_get_ipc_path(ms_msg_port_type_e type)
+int ms_user_make_ipc_path(char *dest, const char *src, size_t dest_len)
{
- if (type != MS_SCANNER_PORT && type != MS_DB_UPDATE_PORT)
- return NULL;
+ MSAPI_RETVM_IF(!dest, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid dest");
+ MSAPI_RETVM_IF(!src, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid src");
+ MSAPI_RETVM_IF(dest_len == 0, MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid dest_len");
- return g_strdup(tzplatform_mkpath(TZ_SYS_RUN, MEDIA_IPC_PATH[type]));
+ if (snprintf(dest, dest_len, "%s/%s", tzplatform_getenv(TZ_SYS_RUN), src) < 0)
+ return MS_MEDIA_ERR_INTERNAL;
+
+ return MS_MEDIA_ERR_NONE;
}
size_t ms_user_get_root_length(const char *path, uid_t uid)
#ifdef _USE_TVPD_MODE
#include <inttypes.h>
+#define MEDIA_DB_SIZE_LIMIT_2 20000000
+#define MEDIA_DB_SIZE_LIMIT_1 10000000
+#define MEDIA_DB_SPACE_LIMIT 20971520
#endif
+#define MS_SAFE_FREE(src) { if (src) {free(src); src = NULL; } }
+
bool ms_is_valid_symlink(const char *path);
int ms_verify_all_parent_dirs(const char *full_path, uid_t uid);
int ms_check_scan_ignore(char *path, uid_t uid);
void ms_trim_dir_path(char *dir_path);
#ifdef _USE_TVPD_MODE
-
bool ms_config_get_int(const char *key, int *value);
bool ms_config_set_int(const char *key, int value);
int ms_set_db_status(ms_db_status_type_t status);
typedef int (*SEND_DIR_UPDATE_NOTI)(const char *, const char *, int, int);
typedef int (*INSERT_ITEM)(sqlite3 *, const char *, const char *, uid_t);
-typedef int (*SET_ITEM_VALIDITY)(const char *, const char *, int, int, uid_t);
+typedef int (*SET_ITEM_VALIDITY)(const char *, const char *, int, uid_t);
typedef int (*GET_STORAGE_ID)(sqlite3 *, const char *, char *, uid_t uid);
typedef int (*INSERT_FOLDER)(sqlite3 *, const char *, const char *, uid_t);
typedef int (*SET_FOLDER_VALIDITY)(sqlite3 *, const char *, const char *, int, bool, uid_t);
#endif
} else if (ret == MS_MEDIA_ERR_NONE) {
if (!modified) {
- ret = ((SET_ITEM_VALIDITY)func_array[eSET_VALIDITY])(storage_id, path, true, true, uid);
+ ret = ((SET_ITEM_VALIDITY)func_array[eSET_VALIDITY])(storage_id, path, true, uid);
MS_DBG_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "SET_ITEM_VALIDITY failed [%d]", ret);
} else {
ret = ((REFRESH_ITEM)func_array[eREFRESH_ITEM])(handle, storage_id, path, uid);
#ifdef _USE_TVPD_MODE
media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_INSERT,
- mount_path, mount_uuid, MS_MEDIA_UNKNOWN, PROD_CUSTOM_MIME_ADDED);
+ mount_path, mount_uuid, 0, PROD_CUSTOM_MIME_ADDED);
#endif
}
if (ms_set_storage_scan_status(handle, storage_id, MEDIA_SCAN_PREPARE, uid) != MS_MEDIA_ERR_NONE)
MS_DBG_ERR("ms_set_storage_scan_status failed");
- media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, storage_id, MS_MEDIA_UNKNOWN, PROD_CUSTOM_MIME_ADDED);
+ media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, storage_id, 0, PROD_CUSTOM_MIME_ADDED);
} else {
/* there is no information of this storage in Media DB */
ret = ms_insert_storage(handle, storage_id, mount_path, uid);
- media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_INSERT, mount_path, storage_id, MS_MEDIA_UNKNOWN, PROD_CUSTOM_MIME_ADDED);
+ media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_INSERT, mount_path, storage_id, 0, PROD_CUSTOM_MIME_ADDED);
}
} else {
MS_DBG_ERR("STORAGE ID IS NUILL");
ms_send_storage_otg_scan_request(mount_path, device_id, MS_SCAN_INVALID, uid);
}
- media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, device_id, MS_MEDIA_UNKNOWN, PROD_CUSTOM_MIME_REMOVED);
+ media_db_update_send(getpid(), MS_MEDIA_ITEM_STORAGE, MS_MEDIA_ITEM_UPDATE, mount_path, device_id, 0, PROD_CUSTOM_MIME_REMOVED);
}
ms_disconnect_db(handle);
projects / platform / core / multimedia / media-server.git / commitdiff