MS_MSG_SCANNER_COMPLETE,
MS_MSG_EXTRACTOR_COMPLETE,
MS_MSG_MEDIA_DB_RESET, /**< media DB is reset*/
- MS_MSG_RECEIVE_MSG_FAILED, /**ms_ipc_receive_message_tcp failed**/
MS_MSG_MEDIA_DB_MALFORMED,
MS_MSG_MAX /**< Invalid msg type */
} ms_msg_type_e;
MEDIA_REQUEST_SCAN_PARTIAL,
MEDIA_REQUEST_SCAN_COMPLETE,
MEDIA_REQUEST_EXTRACT_COMPLETE,
- MEDIA_REQUEST_ERROR_SERVER_RECEIVE_MSG_FAILED,
} media_request_type_e;
typedef struct {
}
}
- 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] S[%.*s]", recv_msg->pid, recv_msg->msg_type, MAX_MSG_SIZE, recv_msg->msg, MS_UUID_SIZE, recv_msg->storage_id);
if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
MSAPI_DBG_ERR("IPC message is wrong. message size is %d", strlen(recv_msg->msg));
return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
+ if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
+ MSAPI_DBG_ERR("IPC message is wrong. storage_id size is %d", strlen(recv_msg->storage_id));
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ }
+
ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));
MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get pid");
memcpy(recv_msg, buf, header_size);
MS_SAFE_FREE(buf);
+ if (strlen(recv_msg->org_path) == 0 || strlen(recv_msg->org_path) >= MAX_FILEPATH_LEN) {
+ MSAPI_DBG_ERR("org_path size is invlid[%d]", strlen(recv_msg->org_path));
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ }
+
+ if (strlen(recv_msg->dst_path) >= MAX_FILEPATH_LEN) {
+ MSAPI_DBG_ERR("dst_path size is invlid[%d]", strlen(recv_msg->dst_path));
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ }
+
ret = cynara_creds_socket_get_pid(sockfd, &(credentials->pid));
MSAPI_RETVM_IF(ret != 0, MS_MEDIA_ERR_INTERNAL, "[CYNARA]Failed to get pid");
if ((err = recv(sock, &recv_msg, sizeof(dcmMsg), 0)) < 0) {
MSAPI_DBG_STRERROR("recv failed ");
- if (strlen(recv_msg.msg) > 0)
+ if (strlen(recv_msg.msg) > 0 && strlen(recv_msg.msg) < MAX_FILEPATH_LEN)
__media_dcm_pop_data();
else
MSAPI_DBG_ERR("origin path size is wrong.");
return FALSE;
}
- MSAPI_DBG("Completed. msg_type[%d], msg[%s], result[%d]", recv_msg.msg_type, recv_msg.msg, recv_msg.result);
+ if (strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_FILEPATH_LEN) {
+ MSAPI_DBG_ERR("msg size is invlid[%d]", strlen(recv_msg.msg));
+ return FALSE;
+ }
+
+ MSAPI_DBG("Completed. msg_type[%d], msg[%.*s], result[%d]", recv_msg.msg_type, MAX_FILEPATH_LEN, recv_msg.msg, recv_msg.result);
if (__media_dcm_check_cancel()) {
MSAPI_DBG_INFO("Not canceled item. call cb");
return MS_MEDIA_ERR_NONE;
}
-
MSAPI_DBG_STRERROR("write failed");
return MS_MEDIA_ERR_SOCKET_SEND;
} else {
- MSAPI_DBG_SLOG("result[%d] message[%s]", send_msg->result, send_msg->msg);
+ MSAPI_DBG_SLOG("result[%d] message[%.*s]", send_msg->result, MAX_MSG_SIZE, send_msg->msg);
if (serv_addr != NULL)
*serv_addr = addr;
}
return MS_MEDIA_ERR_SOCKET_SEND;
}
- MSAPI_DBG_SLOG("result[%d] message[%s]", send_msg->result, send_msg->msg);
+ MSAPI_DBG_SLOG("result[%d] message[%.*s]", send_msg->result, MAX_MSG_SIZE, send_msg->msg);
return MS_MEDIA_ERR_NONE;
}
}
}
- MSAPI_DBG_SLOG("receive msg from P[%d] T[%d] M[%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, MAX_MSG_SIZE, recv_msg->msg);
if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
MSAPI_DBG_ERR("IPC message is wrong. message size is %d", strlen(recv_msg->msg));
MSAPI_DBG_STRERROR("recv failed");
return FALSE;
}
+ if (strlen(recv_msg.msg) > 0 && strlen(recv_msg.msg) < MAX_MSG_SIZE) {
+ req_result.complete_path = g_strdup(recv_msg.msg);
+ MSAPI_DBG("complete_path :%s", req_result.complete_path);
+ } else {
+ MSAPI_DBG("The message is invalid!");
+ return FALSE;
+ }
req_result.pid = recv_msg.pid;
req_result.result = recv_msg.result;
- if (recv_msg.msg_type == MS_MSG_SCANNER_RESULT) {
- req_result.complete_path = g_strdup(recv_msg.msg);
+ switch (recv_msg.msg_type) {
+ case MS_MSG_SCANNER_RESULT:
req_result.request_type = MEDIA_DIRECTORY_SCAN;
- MSAPI_DBG("complete_path :%s", req_result.complete_path);
- } else if (recv_msg.msg_type == MS_MSG_SCANNER_BULK_RESULT) {
- req_result.complete_path = g_strdup(recv_msg.msg);
+ break;
+ case MS_MSG_SCANNER_BULK_RESULT:
req_result.request_type = MEDIA_FILES_REGISTER;
- } else if (recv_msg.msg_type == MS_MSG_SCANNER_COMPLETE) {
- req_result.complete_path = g_strdup(recv_msg.msg);
+ break;
+ case MS_MSG_SCANNER_COMPLETE:
req_result.request_type = MEDIA_REQUEST_SCAN_COMPLETE;
- } else if (recv_msg.msg_type == MS_MSG_SCANNER_PARTIAL) {
- req_result.complete_path = g_strdup(recv_msg.msg);
+ break;
+ case MS_MSG_SCANNER_PARTIAL:
req_result.request_type = MEDIA_REQUEST_SCAN_PARTIAL;
- } else if (recv_msg.msg_type == MS_MSG_EXTRACTOR_COMPLETE) {
- req_result.complete_path = g_strdup(recv_msg.msg);
+ break;
+ case MS_MSG_EXTRACTOR_COMPLETE:
req_result.request_type = MEDIA_REQUEST_EXTRACT_COMPLETE;
- } else if (recv_msg.msg_type == MS_MSG_RECEIVE_MSG_FAILED) {
- MSAPI_DBG_ERR("in _read_socket MS_MSG_RECEIVE_MSG_FAILED");
- if (strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_MSG_SIZE)
- req_result.complete_path = g_strdup(recv_msg.msg);
-
- req_result.request_type = MEDIA_REQUEST_ERROR_SERVER_RECEIVE_MSG_FAILED;
- } else {
- MSAPI_DBG("The message is invalid!");
+ break;
+ default:
+ MSAPI_DBG("Invalid msg_type[%d]", recv_msg.msg_type);
+ MS_SAFE_FREE(req_result.complete_path);
return FALSE;
}
goto _POWEROFF;
}
- MS_DBG_WARN("DIRECTORY EXTRACT START [%s %d]", extract_data->msg, extract_data->msg_type);
+ MS_DBG_WARN("DIRECTORY EXTRACT START [%.*s %d]", MAX_MSG_SIZE, extract_data->msg, extract_data->msg_type);
io_err_count = 0;
goto NEXT;
}
- MS_DBG("path : [%s], storage_id : [%s]", extract_data->msg, storage_id);
+ MS_DBG("path : [%.*s], storage_id : [%s]", MAX_MSG_SIZE, extract_data->msg, storage_id);
update_path = g_strdup(extract_data->msg);
if (strlen(storage_id) == 0) {
- MS_DBG_ERR("storage_id length is 0. There is no information of your request [%s]", extract_data->msg);
+ MS_DBG_ERR("storage_id length is 0. There is no information of your request [%.*s]", MAX_MSG_SIZE, extract_data->msg);
ret = MS_MEDIA_ERR_INVALID_PARAMETER;
goto NEXT;
}
goto _POWEROFF;
}
- MS_DBG_WARN("DIRECTORY SCAN START [%s, %d]", scan_data->msg, scan_data->msg_type);
+ MS_DBG_WARN("DIRECTORY SCAN START [%.*s, %d]", MAX_MSG_SIZE, scan_data->msg, scan_data->msg_type);
msc_set_cur_scan_item(scan_data->msg, scan_data->pid);
g_directory_scan_processing2 = DIR_SCAN_NON_RECURSIVE;
goto NEXT;
}
- MS_DBG("path [%s], storage_id [%s], scan_type [%d]", scan_data->msg, storage_id, scan_type);
+ MS_DBG("path [%.*s], storage_id [%s], scan_type [%d]", MAX_MSG_SIZE, scan_data->msg, storage_id, scan_type);
if (strlen(storage_id) == 0) {
- MS_DBG_ERR("storage_id length is 0. There is no information of your request [%s]", scan_data->msg);
+ MS_DBG_ERR("storage_id length is 0. There is no information of your request [%.*s]", MAX_MSG_SIZE, scan_data->msg);
ret = MS_MEDIA_ERR_INVALID_PARAMETER;
goto NEXT;
}
if (ms_check_folder_exist(handle, storage_id, scan_data->msg) == MS_MEDIA_ERR_NONE) {
/*already exist in media DB*/
noti_type = MS_ITEM_UPDATE;
- MS_DBG_WARN("[%s] already exist", scan_data->msg);
+ MS_DBG_WARN("[%.*s] already exist", MAX_MSG_SIZE, scan_data->msg);
} else {
noti_type = MS_ITEM_INSERT;
- MS_DBG_WARN("[%s] new insert path", scan_data->msg);
+ MS_DBG_WARN("[%.*s] new insert path", MAX_MSG_SIZE, scan_data->msg);
}
} else {
/*directory is deleted*/
/*get the UUID of deleted folder*/
ms_get_folder_id(handle, storage_id, scan_data->msg, &folder_uuid);
- MS_DBG_WARN("[%s][%s] delete path", scan_data->msg, folder_uuid);
+ MS_DBG_WARN("[%.*s][%s] delete path", MAX_MSG_SIZE, scan_data->msg, folder_uuid);
}
if (scan_type == MS_MSG_DIRECTORY_SCANNING) {
err = __msc_check_scan_same_path(scan_data->msg);
if (MS_MEDIA_ERR_NONE == err) {
- MS_DBG_WARN("[%s] is scanning recursive, waiting...", scan_data->msg);
+ MS_DBG_WARN("[%.*s] is scanning recursive, waiting...", MAX_MSG_SIZE, scan_data->msg);
while (1) {
sleep(1);
break;
}
- MS_DBG_WARN("[%s] scan done, wait finished", scan_data->msg);
+ MS_DBG_WARN("[%.*s] scan done, wait finished", MAX_MSG_SIZE, scan_data->msg);
goto SCAN_DONE;
} else {
ms_check_folder_modified(handle, scan_data->msg, storage_id, &modified);
if (modified == FALSE) {
- MS_DBG_WARN("check [%s] has not been modified !!", scan_data->msg);
+ MS_DBG_WARN("check [%.*s] has not been modified !!", MAX_MSG_SIZE, scan_data->msg);
ms_get_folder_scan_status(handle, storage_id, scan_data->msg, (int*)&scan_status);
MS_DBG_WARN("folder scan status = [%d]", scan_status);
if (scan_status == MS_DIR_SCAN_DONE) {
/* do nothing */
- MS_DBG_WARN("[%s] scan done", scan_data->msg);
+ MS_DBG_WARN("[%.*s] scan done", MAX_MSG_SIZE, scan_data->msg);
/*fix timing issue, deleted items scanned by storage scan is set validity 1 again*/
/*err = ms_set_folder_item_validity(handle, storage_id, scan_data->msg, MS_VALIND, MS_NON_RECURSIVE, uid);*/
goto SCAN_DONE;
} else if (scan_status == MS_DIR_SCAN_PROCESSING) {
- MS_DBG_WARN("[%s] scanning, waiting...", scan_data->msg);
+ MS_DBG_WARN("[%.*s] scanning, waiting...", MAX_MSG_SIZE, scan_data->msg);
while (1) {
sleep(1);
ms_get_folder_scan_status(handle, storage_id, scan_data->msg, (int*)&scan_status);
if ((scan_status == MS_DIR_SCAN_DONE) || (scan_status == MS_DIR_SCAN_STOP)) {
- MS_DBG_WARN("[%s] scan status [%d]!!!", scan_data->msg, scan_status);
+ MS_DBG_WARN("[%.*s] scan status [%d]!!!", MAX_MSG_SIZE, scan_data->msg, scan_status);
break;
}
}
if (scan_status == MS_DIR_SCAN_DONE) {
- MS_DBG_WARN("[%s] scan done, wait finished", scan_data->msg);
+ MS_DBG_WARN("[%.*s] scan done, wait finished", MAX_MSG_SIZE, scan_data->msg);
goto SCAN_DONE;
} else {
MS_DBG_WARN("set folder item invalid");
err = ms_set_folder_item_validity(handle, storage_id, scan_data->msg, MS_INVALID, MS_NON_RECURSIVE, uid);
}
} else {
- MS_DBG_WARN("check [%s] has been modified !!", scan_data->msg);
+ MS_DBG_WARN("check [%.*s] has been modified !!", MAX_MSG_SIZE, scan_data->msg);
err = ms_set_folder_item_validity(handle, storage_id, scan_data->msg, MS_INVALID, MS_NON_RECURSIVE, uid);
}
}
/*call for bundle commit*/
ms_bacth_commit_disable(handle, TRUE, TRUE, uid);
- MS_DBG_WARN("folder scan done, sent cb event path = [%s]", scan_data->msg);
+ MS_DBG_WARN("folder scan done, sent cb event path = [%.*s]", MAX_MSG_SIZE, scan_data->msg);
__msc_call_dir_scan_cb();
/*delete invalid folder first, then delete invalid item, avoid to folder was deleted but item not when unmount*/
}*/
SCAN_DONE:
- MS_DBG_WARN("storage_id = [%s], dir Path = [%s], pid = [%d]", storage_id, scan_data->msg, scan_data->pid);
+ MS_DBG_WARN("storage_id = [%s], dir Path = [%.*s], pid = [%d]", storage_id, MAX_MSG_SIZE, scan_data->msg, scan_data->pid);
if (ret != MS_MEDIA_ERR_SCANNER_FORCE_STOP) {
if (noti_type == MS_ITEM_DELETE) {
ms_send_dir_update_noti(handle, storage_id, scan_data->msg, folder_uuid, noti_type, scan_data->pid);
goto _POWEROFF;
}
- MS_DBG_WARN("STORAGE SCAN START [%s]", scan_data->msg);
+ MS_DBG_WARN("STORAGE SCAN START [%.*s]", MAX_MSG_SIZE, scan_data->msg);
scan_type = scan_data->msg_type;
if (scan_type != MS_MSG_STORAGE_ALL
static void __msc_insert_register_request(GArray *register_array, ms_comm_msg_s *insert_data)
{
- MS_DBG_SLOG("path : %s", insert_data->msg);
+ MS_DBG_SLOG("path : %.*s", MAX_MSG_SIZE, insert_data->msg);
if (insert_data->pid == POWEROFF)
g_array_prepend_val(register_array, insert_data);
}
}
- if ((strlen((*register_data)->msg) <= 0) || (strlen((*register_data)->msg) > MS_FILE_PATH_LEN_MAX)) {
+ if ((strlen((*register_data)->msg) <= 0) || (strlen((*register_data)->msg) >= MS_FILE_PATH_LEN_MAX)) {
MS_DBG_ERR("message size[%d] is wrong", strlen((*register_data)->msg));
return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
/* If register_files operation is stopped, there is no necessrty for sending result. */
msc_send_result(ret, register_data);
- MS_DBG_WARN("BULK REGISTER END [%d |%s]", ret, register_data->msg);
+ MS_DBG_WARN("BULK REGISTER END [%d |%.*s]", ret, MAX_MSG_SIZE, register_data->msg);
__msc_clear_file_list(path_array);
for (i = 0; i < len; i++) {
/*create new queue to compare request*/
msg = g_async_queue_pop(scan_queue2);
- MS_DBG_WARN("msg->msg[%s], msg->pid[%d]", msg->msg, msg->pid);
+ MS_DBG_WARN("msg->msg[%.*s], msg->pid[%d]", MAX_MSG_SIZE, msg->msg, msg->pid);
if ((strcmp(msg->msg, cancel_path) == 0) && (pid == msg->pid)) {
msg->msg_type = MS_MSG_DIRECTORY_SCANNING_CANCEL;
msc_send_result(MS_MEDIA_ERR_SCANNER_FORCE_STOP, msg);
return MS_MEDIA_ERR_FILE_READ_FAIL;
}
- MS_DBG_SLOG("receive msg from [%d] %d, %s", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
+ if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
+ MS_DBG_ERR("msg size is invlid[%d]", strlen(recv_msg->msg));
+ return TRUE;
+ }
+
+ if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
+ MS_DBG_ERR("storage_id size is invlid[%d]", strlen(recv_msg->storage_id));
+ return TRUE;
+ }
+
+ MS_DBG_SLOG("receive msg from [%d][%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);
/* copy from recived data */
req_num = recv_msg->msg_type;
goto _POWEROFF;
}
- MS_DBG_WARN("DIRECTORY SCAN START [%s %d]", scan_data->msg, scan_data->msg_type);
+ MS_DBG_WARN("DIRECTORY SCAN START [%.*s %d]", MAX_MSG_SIZE, scan_data->msg, scan_data->msg_type);
ret = ms_connect_db(&handle, scan_data->uid);
if (ret != MS_MEDIA_ERR_NONE) {
goto NEXT;
}
} else {
- MS_DBG_ERR("storage_id length is 0. There is no information of your request [%s]", scan_data->msg);
+ MS_DBG_ERR("storage_id length is 0. There is no information of your request [%.*s]", MAX_MSG_SIZE, scan_data->msg);
ret = MS_MEDIA_ERR_INVALID_PARAMETER;
goto NEXT;
}
- MS_DBG("path : [%s], storage_id : [%s]", scan_data->msg, storage_id);
+ MS_DBG("path : [%.*s], storage_id : [%s]", MAX_MSG_SIZE, scan_data->msg, storage_id);
if (scan_type != MS_MSG_DIRECTORY_SCANNING && scan_type != MS_MSG_DIRECTORY_SCANNING_NON_RECURSIVE) {
MS_DBG_ERR("Invalid request");
if (ms_check_folder_exist(handle, storage_id, scan_data->msg) == MS_MEDIA_ERR_NONE) {
/*already exist in media DB*/
noti_type = MS_ITEM_UPDATE;
- MS_DBG_WARN("[%s] already exist", scan_data->msg);
+ MS_DBG_WARN("[%.*s] already exist", MAX_MSG_SIZE, scan_data->msg);
} else {
noti_type = MS_ITEM_INSERT;
- MS_DBG_WARN("[%s] new insert path", scan_data->msg);
+ MS_DBG_WARN("[%.*s] new insert path", MAX_MSG_SIZE, scan_data->msg);
}
} else {
/*directory is deleted*/
/*get the UUID of deleted folder*/
ms_get_folder_id(handle, storage_id, scan_data->msg, &folder_uuid);
- MS_DBG_WARN("[%s][%s] delete path", scan_data->msg, folder_uuid);
+ MS_DBG_WARN("[%.*s][%s] delete path", MAX_MSG_SIZE, scan_data->msg, folder_uuid);
}
if (noti_type != MS_ITEM_INSERT) {
goto _POWEROFF;
}
- MS_DBG_WARN("STORAGE SCAN START [%s][%s]", scan_data->msg, scan_data->storage_id);
+ MS_DBG_WARN("STORAGE SCAN START [%.*s][%s]", MAX_MSG_SIZE, scan_data->msg, scan_data->storage_id);
scan_type = scan_data->msg_type;
if (scan_type != MS_MSG_STORAGE_ALL
goto NEXT;
}
} else {
- MS_DBG_ERR("storage_id length is 0. There is no information of your request [%s]", scan_data->msg);
+ MS_DBG_ERR("storage_id length is 0. There is no information of your request [%.*s]", MAX_MSG_SIZE, scan_data->msg);
ret = MS_MEDIA_ERR_INVALID_PARAMETER;
goto NEXT;
}
static void __msc_insert_register_request(GArray *register_array, ms_comm_msg_s *insert_data)
{
- MS_DBG_SLOG("path : %s", insert_data->msg);
+ MS_DBG_SLOG("path : %.*s", MAX_MSG_SIZE, insert_data->msg);
if (insert_data->pid == POWEROFF)
g_array_prepend_val(register_array, insert_data);
}
}
- if ((strlen((*register_data)->msg) <= 0) || (strlen((*register_data)->msg) > MS_FILE_PATH_LEN_MAX)) {
+ if ((strlen((*register_data)->msg) <= 0) || (strlen((*register_data)->msg) >= MS_FILE_PATH_LEN_MAX)) {
MS_DBG_ERR("message size[%d] is wrong", strlen((*register_data)->msg));
return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
}
/* If register_files operation is stopped, there is no necessrty for sending result. */
msc_send_result(ret, register_data);
- MS_DBG_WARN("BULK REGISTER END [%d |%s]", ret, register_data->msg);
+ MS_DBG_WARN("BULK REGISTER END [%d |%.*s]", ret, MAX_MSG_SIZE, register_data->msg);
__msc_clear_file_list(path_array);
return MS_MEDIA_ERR_FILE_READ_FAIL;
}
- MS_DBG_SLOG("receive msg from [%d] %d, %s", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
+ if (strlen(recv_msg->msg) == 0 || strlen(recv_msg->msg) >= MAX_MSG_SIZE) {
+ MS_DBG_ERR("msg size is invlid[%d]", strlen(recv_msg->msg));
+ return TRUE;
+ }
+
+ if (strlen(recv_msg->storage_id) >= MS_UUID_SIZE) {
+ MS_DBG_ERR("storage_id size is invlid[%d]", strlen(recv_msg->storage_id));
+ return TRUE;
+ }
+
+ MS_DBG_SLOG("receive msg from [%d][%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);
/* copy from recived data */
req_num = recv_msg->msg_type;
}
memcpy(msg, buf, sizeof(dcmMsg));
+ if (strlen(msg->msg) >= MAX_FILEPATH_LEN) {
+ MS_DBG_ERR("msg size is invlid[%d]", strlen(msg->msg));
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ }
+
MS_SAFE_FREE(buf);
MS_DBG("msg_type [%d]", msg->msg_type);
struct sockaddr_un serv_addr;
int send_str_len = strlen(recv_msg->msg);
- if (send_str_len > MAX_FILEPATH_LEN) {
+ if (send_str_len >= MAX_FILEPATH_LEN) {
MS_DBG_ERR("original path's length exceeds %d(max packet size)", MAX_FILEPATH_LEN);
return FALSE;
}
return FALSE;
}
- MS_DBG_SLOG("recv %s(%d, %d) from DCM daemon is successful", res_msg->msg, res_msg->msg_type, res_msg->result);
+ MS_DBG_SLOG("recv %.*s(%d, %d) from DCM daemon is successful", MAX_FILEPATH_LEN, res_msg->msg, res_msg->msg_type, res_msg->result);
close(sock);
return TRUE;
if (send(client_sock, &res_msg, sizeof(res_msg), 0) != sizeof(res_msg))
MS_DBG_STRERROR("sendto failed");
else
- MS_DBG("Sent Refuse msg from %s", recv_msg->msg);
+ MS_DBG("Sent Refuse msg from %.*s", MAX_FILEPATH_LEN, recv_msg->msg);
close(client_sock);
if (send(client_sock, &res_msg, sizeof(dcmMsg), 0) != sizeof(dcmMsg))
MS_DBG_STRERROR("sendto failed");
else
- MS_DBG("Sent Refuse msg from %s", recv_msg->msg);
+ MS_DBG("Sent Refuse msg from %.*s", MAX_FILEPATH_LEN, recv_msg->msg);
close(client_sock);
MS_SAFE_FREE(dcm_req->recv_msg);
return TRUE;
}
- MS_DBG_SLOG("[%s] is queued", recv_msg->msg);
+ MS_DBG_SLOG("[%.*s] is queued", MAX_FILEPATH_LEN, recv_msg->msg);
g_queue_push_tail(g_dcm_request_queue, (gpointer)dcm_req);
if (!g_dcm_queue_work) {
case MS_MSG_BURSTSHOT_INSERT:
res_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
break;
- case MS_MSG_RECEIVE_MSG_FAILED:
- res_msg.msg_type = MS_MSG_RECEIVE_MSG_FAILED;
- break;
case MS_MSG_MEDIA_DB_MALFORMED:
res_msg.msg_type = MS_MSG_MEDIA_DB_MALFORMED;
break;
break;
}
- /* msg_size & msg */
if (root_path != NULL)
SAFE_STRLCPY(scan_msg.msg, root_path, sizeof(scan_msg.msg));
return MS_MEDIA_ERR_FILE_READ_FAIL;
}
- MS_DBG_SLOG("receive result from scanner [%d] %d, %s", recv_msg.pid, recv_msg.result, recv_msg.msg);
+ if (strlen(recv_msg.msg) == 0 || strlen(recv_msg.msg) >= MAX_MSG_SIZE) {
+ MS_DBG_ERR("msg size is invlid[%d]", strlen(recv_msg.msg));
+ return TRUE;
+ }
+
+ if (strlen(recv_msg.storage_id) >= MS_UUID_SIZE) {
+ MS_DBG_ERR("storage_id size is invlid[%d]", strlen(recv_msg.storage_id));
+ return TRUE;
+ }
+
+ MS_DBG_SLOG("receive result from scanner [%d][%d] M[%.*s] S[%.*s]", recv_msg.pid, recv_msg.result, MAX_MSG_SIZE, recv_msg.msg, MS_UUID_SIZE, recv_msg.storage_id);
msg_type = recv_msg.msg_type;
pid = recv_msg.pid;
break;
}
- /* msg_size & msg */
SAFE_STRLCPY(scan_msg.msg, path, sizeof(scan_msg.msg));
SAFE_STRLCPY(scan_msg.storage_id, device_uuid, sizeof(scan_msg.storage_id));
return MS_MEDIA_ERR_NONE;
}
- if (strlen(msg->org_path) == 0 || strlen(msg->org_path) > MS_FILE_PATH_LEN_MAX) {
+ if (strlen(msg->org_path) == 0 || strlen(msg->org_path) >= MS_FILE_PATH_LEN_MAX) {
MS_DBG_ERR("org_path size is invalid %d", strlen(msg->org_path));
return MS_MEDIA_ERR_DATA_TAINTED;
}
/* it can be empty string */
- if (strlen(msg->dst_path) > MS_FILE_PATH_LEN_MAX) {
+ if (strlen(msg->dst_path) >= MS_FILE_PATH_LEN_MAX) {
MS_DBG_ERR("dst_path size is invalid %d", strlen(msg->dst_path));
return MS_MEDIA_ERR_DATA_TAINTED;
struct sockaddr_un serv_addr;
int send_str_len = strlen(recv_msg->org_path);
- if (send_str_len > MAX_FILEPATH_LEN) {
+ if (send_str_len >= MAX_FILEPATH_LEN) {
MS_DBG_ERR("original path's length exceeds %d(max packet size)", MAX_FILEPATH_LEN);
return FALSE;
}