Git init

1 files changed, 277 insertions, 0 deletions

diff --git a/src/ipc/media-thumb-ipc.c b/src/ipc/media-thumb-ipc.c
new file mode 100755
index 0000000..3718f6f
--- /dev/null
+++ b/src/ipc/media-thumb-ipc.c
@@ -0,0 +1,277 @@
+/*
+ * libmedia-thumbnail
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hyunjun Ko <zzoon.ko@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "media-thumbnail.h"
+#include "media-thumb-ipc.h"
+#include "media-thumb-util.h"
+#include "media-thumb-db.h"
+#include <glib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+static __thread int g_tries = 0;
+
+int
+_media_thumb_request(int msg_type, media_thumb_type thumb_type, const char *origin_path, char *thumb_path, int max_length, media_thumb_info *thumb_info)
+{
+	int sock;
+	const char *serv_ip = "127.0.0.1";
+	struct sockaddr_in serv_addr;
+	struct sockaddr_in from_addr;
+
+	unsigned int from_size;
+
+	int send_str_len = strlen(origin_path);
+	int recv_msg_len;
+	int recv_str_len;
+	int pid;
+
+	thumbMsg req_msg;
+	thumbMsg recv_msg;
+
+	memset((void *)&req_msg, 0, sizeof(thumbMsg));
+	memset((void *)&recv_msg, 0, sizeof(thumbMsg));
+
+	req_msg.msg_type = msg_type;
+	req_msg.thumb_type = thumb_type;
+	strncpy(req_msg.org_path, origin_path, sizeof(req_msg.org_path));
+	req_msg.org_path[strlen(req_msg.org_path)] = '\0';
+
+	if (msg_type == THUMB_REQUEST_SAVE) {
+		strncpy(req_msg.dst_path, thumb_path, sizeof(req_msg.dst_path));
+		req_msg.dst_path[strlen(req_msg.dst_path)] = '\0';
+	}
+
+	struct timeval tv_timeout = { TIMEOUT_SEC, 0 };
+
+	serv_ip = "127.0.0.1";
+
+	if (send_str_len > MAX_PATH_SIZE) {
+		thumb_err("original path's length exceeds %d(max packet size)", MAX_PATH_SIZE);
+		return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+	}
+
+	pid = getpid();
+	req_msg.pid = pid;
+
+	/* Creaete a datagram/UDP socket */
+	if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+		thumb_err("socket failed: %d\n", errno);
+		return MEDIA_THUMB_ERROR_NETWORK;
+	}
+
+	if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
+		thumb_err("setsockopt failed: %d\n", errno);
+		return MEDIA_THUMB_ERROR_NETWORK;
+	}
+	
+	memset(&serv_addr, 0, sizeof(serv_addr));
+	serv_addr.sin_family = AF_INET;
+	serv_addr.sin_addr.s_addr = inet_addr(serv_ip);
+	serv_addr.sin_port = htons(THUMB_DAEMON_PORT);
+
+	if (sendto(sock, &req_msg, sizeof(req_msg), 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != sizeof(req_msg)) {
+		thumb_err("sendto failed: %d\n", errno);
+		close(sock);
+		return MEDIA_THUMB_ERROR_NETWORK;
+	}
+
+	thumb_dbg("Sending msg to thumbnail daemon is successful");
+
+	/* recv a response */
+	from_size = sizeof(from_addr);
+
+	while(1) {
+		if ((recv_msg_len = recvfrom(sock, &recv_msg, sizeof(recv_msg), 0, (struct sockaddr *)&from_addr, &from_size)) < 0) {
+
+			if (errno == EWOULDBLOCK) {
+#ifdef DO_RETRY
+				thumb_warn("Timeout..%d more tries", MAX_TRIES - g_tries);
+				if (g_tries < MAX_TRIES) {
+					if (sendto(sock, &req_msg, sizeof(req_msg), 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != sizeof(req_msg)) {
+						thumb_err("sendto failed: %d\n", errno);
+						close(sock);
+						g_tries = 0;
+						return MEDIA_THUMB_ERROR_NETWORK;
+					}
+				} else {
+					thumb_err("Timeout. Can't try any more");
+					close(sock);
+					g_tries = 0;
+					return MEDIA_THUMB_ERROR_TIMEOUT;
+				}
+				g_tries++;
+#else
+				thumb_warn("Timeout. Can't try any more");
+				g_tries = 0;
+				close(sock);
+				return MEDIA_THUMB_ERROR_TIMEOUT;
+#endif
+			} else {
+				thumb_err("recvfrom failed");
+				g_tries = 0;
+				close(sock);
+				return MEDIA_THUMB_ERROR_NETWORK;
+			}
+		} else {
+			thumb_dbg("recvfrom done");
+			break;
+		}
+	}
+
+	g_tries = 0;
+
+	if (serv_addr.sin_addr.s_addr != from_addr.sin_addr.s_addr) {
+		thumb_err("addr is different");
+		close(sock);
+		return MEDIA_THUMB_ERROR_NETWORK;
+	}
+
+	recv_msg.org_path[MAX_PATH_SIZE - 1] = '\0';
+	recv_str_len = strlen(recv_msg.org_path);
+	thumb_dbg("recv %s(%d) from thumb daemon is successful", recv_msg.org_path, recv_str_len);
+
+	close(sock);
+
+	if (recv_str_len > max_length) {
+		thumb_err("user buffer is too small. Output's length is %d", recv_str_len);
+		return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+	}
+
+	if (recv_msg.status == THUMB_FAIL) {
+		thumb_err("Failed to make thumbnail");
+		return -1;
+	}
+
+	if (msg_type != THUMB_REQUEST_SAVE) {
+		strncpy(thumb_path, recv_msg.dst_path, max_length);
+	}
+
+	thumb_info->origin_width = recv_msg.origin_width;
+	thumb_info->origin_height = recv_msg.origin_height;
+
+	return 0;
+}
+
+int
+_media_thumb_process(thumbMsg *req_msg, thumbMsg *res_msg)
+{
+	int err = -1;
+	unsigned char *data = NULL;
+	int thumb_size = 0;
+	int thumb_w = 0;
+	int thumb_h = 0;
+	int origin_w = 0;
+	int origin_h = 0;
+	int max_length = 0;
+	char *thumb_path = NULL;
+
+	if (req_msg == NULL || res_msg == NULL) {
+		thumb_err("Invalid msg!");
+		return MEDIA_THUMB_ERROR_INVALID_PARAMETER;
+	}
+
+	int msg_type = req_msg->msg_type;
+	media_thumb_type thumb_type = req_msg->thumb_type;
+	const char *origin_path = req_msg->org_path;
+
+	media_thumb_format thumb_format = MEDIA_THUMB_BGRA;
+
+	thumb_path = req_msg->dst_path;
+	max_length = sizeof(req_msg->dst_path);
+
+	if (msg_type == THUMB_REQUEST_DB) {
+		err = _media_thumb_get_hash_name(origin_path, thumb_path, max_length);
+		if (err < 0) {
+			thumb_err("_media_thumb_get_hash_name failed - %d\n", err);
+			strncpy(thumb_path, THUMB_DEFAULT_PATH, max_length);
+			return err;
+		}
+
+		thumb_path[strlen(thumb_path)] = '\0';
+	}
+
+	thumb_dbg("Thumb path : %s", thumb_path);
+
+	if (g_file_test(thumb_path, 
+					G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
+		thumb_warn("thumb path already exists in file system");
+		strncpy(res_msg->dst_path, thumb_path, sizeof(res_msg->dst_path));
+		return 0;
+	}
+
+	err = _thumbnail_get_data(origin_path, thumb_type, thumb_format, &data, &thumb_size, &thumb_w, &thumb_h, &origin_w, &origin_h);
+	if (err < 0) {
+		thumb_err("_thumbnail_get_data failed - %d\n", err);
+		SAFE_FREE(data);
+
+		strncpy(thumb_path, THUMB_DEFAULT_PATH, max_length);
+		return err;
+	}
+
+	thumb_dbg("Size : %d, W:%d, H:%d", thumb_size, thumb_w, thumb_h);
+	thumb_dbg("Origin W:%d, Origin H:%d\n", origin_w, origin_h);
+	thumb_dbg("Thumb : %s", thumb_path);
+
+	res_msg->msg_type = THUMB_RESPONSE;
+	res_msg->thumb_size = thumb_size;
+	res_msg->thumb_width = thumb_w;
+	res_msg->thumb_height = thumb_h;
+	res_msg->origin_width = origin_w;
+	res_msg->origin_height = origin_h;
+
+	err = _media_thumb_save_to_file_with_evas(data, thumb_w, thumb_h, thumb_path);
+	if (err < 0) {
+		thumb_err("save_to_file_with_evas failed - %d\n", err);
+		SAFE_FREE(data);
+
+		if (msg_type == THUMB_REQUEST_DB)
+			strncpy(thumb_path, THUMB_DEFAULT_PATH, max_length);
+
+		return err;
+	} else {
+		thumb_dbg("file save success\n");
+	}
+
+	/* fsync */
+	int fd = 0;
+	fd = open(thumb_path, O_WRONLY);
+	if (fd < 0) {
+		thumb_warn("open failed");
+	} else {
+		err = fsync(fd);
+		if (err == -1) {
+			thumb_warn("fsync failed");
+		}
+
+		close(fd);
+	}
+	/* End of fsync */
+
+	strncpy(res_msg->dst_path, thumb_path, sizeof(res_msg->dst_path));
+
+	SAFE_FREE(data);
+	
+	return 0;
+}
+
+