#define MS_SAFE_FREE(src) { if (src) {free(src); src = NULL; } }
#define MS_MALLOC(src, size) { if (size > SIZE_MAX || size <= 0) src = NULL; \
else { src = malloc(size); if (src) memset(src, 0x0, size); } }
-#define MS_STRING_VALID(str) \
- ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
-#define SAFE_STRLCPY(dst, src, n) g_strlcpy(dst, src, n);
+#define MS_SQL_SAFE_FREE(x) {if (x != NULL) {sqlite3_free(x); x = NULL; } }
+#define MS_STRING_VALID(str) ((str != NULL && strlen(str) > 0) ? TRUE : FALSE)
+#define SAFE_STRLCPY(dst, src, n) g_strlcpy(dst, src, n);
int media_db_update_db(MediaDBHandle *handle, const char *query_str);
int media_db_update_db_batch_start(const char *query_str);
#include <cynara-error.h>
#include <cynara-creds-socket.h>
-
/* this definition is missing in glibc headers (version 2.21). It was introduced in kernel version 2.6.17 */
#ifndef SCM_SECURITY
#define SCM_SECURITY 0x03
}
ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_pid failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get pid");
ret = cynara_creds_socket_get_user(sockfd, USER_METHOD_UID, &(credentials->uid));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_user failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get uid");
ret = cynara_creds_socket_get_client(sockfd, CLIENT_METHOD_SMACK, &(credentials->smack));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_client failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get smack");
// MSAPI_DBG_ERR("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack);
}
memcpy(recv_msg, buf, header_size);
-
MS_SAFE_FREE(buf);
if (recv_msg->origin_path_size <= 0) {
- MS_SAFE_FREE(buf);
MSAPI_DBG_ERR("msg->origin_path_size is invalid %d", recv_msg->origin_path_size);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
MS_SAFE_FREE(buf);
if (recv_msg->dest_path_size <= 0) {
- MS_SAFE_FREE(buf);
MSAPI_DBG_ERR("msg->origin_path_size is invalid %d", recv_msg->dest_path_size);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
SAFE_STRLCPY(recv_msg->dst_path, (char*)buf, sizeof(recv_msg->dst_path));
MS_SAFE_FREE(buf);
-
ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_pid failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get pid");
ret = cynara_creds_socket_get_user(sockfd, USER_METHOD_UID, &(credentials->uid));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_user failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get uid");
ret = cynara_creds_socket_get_client(sockfd, CLIENT_METHOD_SMACK, &(credentials->smack));
- if (ret < 0) {
- MSAPI_DBG_ERR("cynara_creds_socket_get_client failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get smack");
// MSAPI_DBG_ERR("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack);
return MS_MEDIA_ERR_INVALID_PARAMETER;
session = cynara_session_from_pid(creds->pid);
- if (session == NULL) {
- MSAPI_DBG_ERR("cynara_session_from_pid failed");
- return MS_MEDIA_ERR_INTERNAL;
- }
+ MSAPI_RETVM_IF(session == NULL, MS_MEDIA_ERR_INTERNAL, "cynara_session_from_pid failed");
G_LOCK(cynara_mutex);
result = cynara_check(_cynara, creds->smack, session, creds->uid, privilege);
int err;
err = setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &optval, sizeof(optval));
- if (err != 0) {
- MSAPI_DBG_ERR("Failed to set SO_PASSSEC socket option");
- return MS_MEDIA_ERR_SOCKET_INTERNAL;
- }
+ MSAPI_RETVM_IF(err != 0, MS_MEDIA_ERR_SOCKET_INTERNAL, "Failed to set SO_PASSSEC socket option");
err = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval));
- if (err != 0) {
- MSAPI_DBG_ERR("Failed to set SO_PASSCRED socket option");
- return MS_MEDIA_ERR_SOCKET_INTERNAL;
- }
+ MSAPI_RETVM_IF(err != 0, MS_MEDIA_ERR_SOCKET_INTERNAL, "Failed to set SO_PASSCRED socket option");
return MS_MEDIA_ERR_NONE;
}
-
#include <string.h>
#include <errno.h>
#include <db-util.h>
-#include <grp.h>
-#include <pwd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/smack.h>
#include "media-util-internal.h"
#include "media-util.h"
-#define BUFSIZE 4096
#define BATCH_START "BEGIN"
#define BATCH_END "COMMIT"
static __thread GArray *sql_list = NULL;
-static int __media_db_busy_handler(void *pData, int count);
-static int __media_db_connect_db_with_handle(sqlite3 **db_handle, uid_t uid, bool need_write);
-static int __media_db_disconnect_db_with_handle(sqlite3 *db_handle);
-static int __media_db_request_update_tcp(ms_msg_type_e msg_type, const char *request_msg, uid_t uid);
static int __media_db_request_recovery(uid_t uid);
static void __media_db_destroy_sql_list()
/*Register busy handler*/
ret = sqlite3_busy_handler(*db_handle, __media_db_busy_handler, NULL);
-
if (SQLITE_OK != ret) {
-
if (*db_handle)
MSAPI_DBG_ERR("[error when register busy handler] %s", sqlite3_errmsg(*db_handle));
return MS_MEDIA_ERR_DB_CONNECT_FAIL;
}
- /*In TV case, if the HDD is inserted, so many data can be inserted.
- So the size of the journal file is incresed.
- We are trucate the journal for reducing the usage rate of the internal storage.*/
- /*ret = sqlite3_exec(*db_handle, "PRAGMA journal_mode = TRUNCATE", NULL, NULL, NULL);*/
+ /*For TV internal space issue, change TRUNCATE to OFF */
sql = sqlite3_mprintf("%s", "PRAGMA journal_mode = OFF");
ret = sqlite3_exec(*db_handle, sql, NULL, NULL, NULL);
- sqlite3_free(sql);
+ MS_SQL_SAFE_FREE(sql);
if (SQLITE_OK != ret) {
-
if (*db_handle)
MSAPI_DBG_ERR("[error when change the journal mode] %s", sqlite3_errmsg(*db_handle));
int ret = MS_MEDIA_ERR_NONE;
ret = db_util_close(db_handle);
-
if (SQLITE_OK != ret) {
- MSAPI_DBG_ERR("error when db close");
- MSAPI_DBG_ERR("Error : %s", sqlite3_errmsg(db_handle));
+ MSAPI_DBG_ERR("error when db close [%s]", sqlite3_errmsg(db_handle));
db_handle = NULL;
return MS_MEDIA_ERR_DB_DISCONNECT_FAIL;
}
request_msg_size = strlen(request_msg);
if (request_msg_size >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("Query is Too long. [%d] query size limit is [%d]", request_msg_size, MAX_MSG_SIZE);
+ MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
static int __media_db_close_tcp_client_socket()
{
- int ret = MS_MEDIA_ERR_NONE;
-
if (g_tcp_client_sock != -1) {
if (close(g_tcp_client_sock) < 0) {
- MSAPI_DBG_ERR("sock(%d) close failed", g_tcp_client_sock);
MSAPI_DBG_STRERROR("socket close failed");
- ret = MS_MEDIA_ERR_SOCKET_INTERNAL;
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
g_tcp_client_sock = -1;
}
- return ret;
+ return MS_MEDIA_ERR_NONE;
}
static int __media_db_request_batch_update(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
request_msg_size = strlen(request_msg);
if (request_msg_size >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("Query is Too long. [%d] query size limit is [%d]", request_msg_size, MAX_MSG_SIZE);
+ MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
SAFE_STRLCPY(send_msg.msg, request_msg, sizeof(send_msg.msg));
sockfd = __media_db_get_client_tcp_sock();
- if (sockfd <= 0)
- return MS_MEDIA_ERR_SOCKET_CONN;
+ MSAPI_RETV_IF(sockfd <= 0, MS_MEDIA_ERR_SOCKET_CONN);
/* Send request */
if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
ret = sqlite3_exec(db_handle, sql_str, NULL, NULL, &zErrMsg);
if (SQLITE_OK != ret) {
- MSAPI_ERR_SLOG("%s", sql_str);
- MSAPI_DBG_ERR("ERROR [%s]", zErrMsg);
+ MSAPI_ERR_SLOG("Query[%s] Error[%s]", sql_str, zErrMsg);
+ MS_SQL_SAFE_FREE(zErrMsg);
if (ret == SQLITE_BUSY) {
ret = MS_MEDIA_ERR_DB_BUSY_FAIL;
} else if (ret == SQLITE_CONSTRAINT) {
}
}
- if (zErrMsg)
- sqlite3_free(zErrMsg);
-
return ret;
}
request_msg_size = strlen(db_path);
if (request_msg_size >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("Query is Too long. [%d] query size limit is [%d]", request_msg_size, MAX_MSG_SIZE);
+ MSAPI_DBG_ERR("Too long query[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
MS_SAFE_FREE(db_path);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
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 res = MS_MEDIA_ERR_NONE;
struct sockaddr_un addr;
/* Set server Address */
/* Connecting to the media db server */
if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
MSAPI_DBG_STRERROR("connect error");
- res = MS_MEDIA_ERR_SOCKET_CONN;
-
if (errno == EACCES || errno == EPERM)
- res = MS_MEDIA_ERR_PERMISSION_DENIED;
-
- return res;
+ return MS_MEDIA_ERR_PERMISSION_DENIED;
+ else
+ return MS_MEDIA_ERR_SOCKET_CONN;
}
if (write(sockfd, send_msg, sizeof(*(send_msg))) != sizeof(*(send_msg))) {
MSAPI_DBG_STRERROR("write failed");
- res = MS_MEDIA_ERR_SOCKET_SEND;
+ return MS_MEDIA_ERR_SOCKET_SEND;
} else {
- MSAPI_DBG("sent result [%d]", send_msg->result);
- MSAPI_DBG_SLOG("result message [%s]", send_msg->msg);
+ MSAPI_DBG_SLOG("result[%d] message[%s]", send_msg->result, send_msg->msg);
if (serv_addr != NULL)
*serv_addr = addr;
}
- return res;
+ return MS_MEDIA_ERR_NONE;
}
int ms_ipc_send_msg_to_client_tcp(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr)
{
- int res = MS_MEDIA_ERR_NONE;
-
if (write(sockfd, send_msg, sizeof(*(send_msg))) != sizeof(*(send_msg))) {
MSAPI_DBG_STRERROR("sendto failed");
- res = MS_MEDIA_ERR_SOCKET_SEND;
- } else {
- MSAPI_DBG("sent result [%d]", send_msg->result);
- MSAPI_DBG_SLOG("result message [%s]", send_msg->msg);
+ return MS_MEDIA_ERR_SOCKET_SEND;
}
- return res;
+ MSAPI_DBG_SLOG("result[%d] message[%s]", send_msg->result, send_msg->msg);
+
+ return MS_MEDIA_ERR_NONE;
}
int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size)
{
int recv_msg_size;
- if (!recv_msg)
- return MS_MEDIA_ERR_INVALID_PARAMETER;
+ MSAPI_RETV_IF(recv_msg == NULL, MS_MEDIA_ERR_INVALID_PARAMETER);
if ((recv_msg_size = read(sockfd, recv_msg, sizeof(ms_comm_msg_s))) < 0) {
if (errno == EWOULDBLOCK) {
struct sockaddr_un client_addr;
socklen_t client_addr_len;
- if (client_sock == NULL)
- return MS_MEDIA_ERR_INVALID_PARAMETER;
+ MSAPI_RETV_IF(client_sock == NULL, MS_MEDIA_ERR_INVALID_PARAMETER);
client_addr_len = sizeof(client_addr);
if ((sockfd = accept(serv_sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
}
}
- MSAPI_DBG_SLOG("receive msg from [%d] %d, %s", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
+ MSAPI_DBG_SLOG("receive msg from P[%d] T[%d] M[%s]", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
if (!(recv_msg->msg_size > 0 && recv_msg->msg_size < MAX_MSG_SIZE)) {
MSAPI_DBG_ERR("IPC message is wrong. message size is %d", recv_msg->msg_size);
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
-#include <sys/types.h>
-#include <sys/stat.h>
#include <fcntl.h>
#include <sys/un.h>
#include <sys/syscall.h>
#include <string.h>
#include <stdbool.h>
-#include <dirent.h>
-#include <vconf.h>
-#include <grp.h>
-#include <pwd.h>
#include "media-server-ipc.h"
#include "media-util-internal.h"
static int _check_dir_path(const char *dir_path, uid_t uid)
{
- struct stat sb;
- DIR *dp = NULL;
ms_user_storage_type_e storage_type;
int ret = MS_MEDIA_ERR_NONE;
ret = ms_user_get_storage_type(uid, dir_path, &storage_type);
MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PATH, "Invalid path");
- if (stat(dir_path, &sb) == -1) {
- MSAPI_DBG("stat failed");
- dp = opendir(dir_path);
- if (dp == NULL) {
- /*if openning directory is failed, check it exists. */
- if (errno == ENOENT) {
- /* this directory is deleted */
- return MS_MEDIA_ERR_NONE;
- }
- } else {
- closedir(dp);
- }
- return MS_MEDIA_ERR_INTERNAL;
- } else {
- if ((sb.st_mode & S_IFMT) != S_IFDIR) {
- MSAPI_DBG("Invalid path : %s is not directory", dir_path);
- return MS_MEDIA_ERR_INVALID_PATH;
- }
+ if (g_file_test(dir_path, G_FILE_TEST_EXISTS)) {
+ if (!g_file_test(dir_path, G_FILE_TEST_IS_DIR))
+ MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, MS_MEDIA_ERR_INVALID_PATH, "Invalid path : %s is not directory", dir_path);
}
return MS_MEDIA_ERR_NONE;
}
-
/* receive message from media-server[function : ms_receive_message_from_scanner] */
gboolean _read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
return FALSE;
}
- MSAPI_DBG("pid :%d", req_result.pid);
- MSAPI_DBG("result :%d", req_result.result);
- MSAPI_DBG("request_type :%d", req_result.request_type);
+ MSAPI_DBG("pid[%d] result[%d] request_type[%d]", req_result.pid, req_result.result, req_result.request_type);
source = ((media_callback_data *)data)->source;
user_callback = ((media_callback_data *)data)->user_callback;
media_callback_data *cb_data;
cb_data = malloc(sizeof(media_callback_data));
- if (cb_data == NULL) {
- MSAPI_DBG_ERR("Malloc failed");
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
+ MSAPI_RETVM_IF(cb_data == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY, "allocate failed");
memset(cb_data, 0, sizeof(media_callback_data));
/*get the global default main context*/
g_source_attach(source, context);
g_source_unref(source);
- _add_request(req_path, cb_data, channel);
-
- return MS_MEDIA_ERR_NONE;
+ return _add_request(req_path, cb_data, channel);
}
static int __media_db_request_update_async(ms_msg_type_e msg_type, const char *storage_id, const char *request_msg, scan_complete_cb user_callback, void *user_data, uid_t uid)
}
ret = _attach_callback(request_msg, &sockfd, NULL, user_callback, user_data);
- if (ret != MS_MEDIA_ERR_NONE)
- return ret;
return ret;
}
request_msg_size = strlen(request_msg);
if (request_msg_size >= MAX_MSG_SIZE) {
- MSAPI_DBG_ERR("Query is Too long. [%d] query size limit is [%d]", request_msg_size, MAX_MSG_SIZE);
+ MSAPI_DBG_ERR("Too long msg:query length[%d] limit[%d]", request_msg_size, MAX_MSG_SIZE);
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
ret = ms_ipc_send_msg_to_server_tcp(sockfd, MS_SCANNER_PORT, &send_msg, NULL);
close(sockfd);
- if (ret != MS_MEDIA_ERR_NONE) {
- MSAPI_DBG_ERR("ms_ipc_send_msg_to_server failed : %d", ret);
- return ret;
- }
+ MSAPI_RETVM_IF(ret != MS_MEDIA_ERR_NONE, ret, "ms_ipc_send_msg_to_server failed : %d", ret);
ret = _remove_request(request_msg);
- if (ret != MS_MEDIA_ERR_NONE)
- return ret;
return ret;
}
int ret = MS_MEDIA_ERR_NONE;
ret = _check_dir_path(directory_path, uid);
- if (ret != MS_MEDIA_ERR_NONE)
- return ret;
+ MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
if (recursive_on == TRUE)
ret = __media_db_request_update_async(MS_MSG_DIRECTORY_SCANNING, storage_id, directory_path, user_callback, user_data, uid);
int ret = MS_MEDIA_ERR_NONE;
ret = _check_dir_path(directory_path, uid);
- if (ret != MS_MEDIA_ERR_NONE)
- return ret;
+ MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
ret = __media_db_request_update_cancel(MS_MSG_DIRECTORY_SCANNING_CANCEL, directory_path);
projects / platform / core / multimedia / media-server.git / commitdiff