CPPFLAGS="${CPPFLAGS} -DRND_LINUX"
#using UDS socket
+CPPFLAGS="${CPPFLAGS} -D_USE_UDS_SOCKET_"
#CPPFLAGS="${CPPFLAGS} -D_USE_UDS_SOCKET_TCP_"
# FMS_DEBUG - File Manager Service debug options
#define MS_TIMEOUT_SEC_10 10 /**< Response from Server time out */
#define MS_TIMEOUT_SEC_20 20 /**< Response from Media server time out */
+#ifdef _USE_UDS_SOCKET_
typedef enum{
MS_DB_BATCH_UPDATE_PORT = 0, /**< Media DB batch update */
MS_SCAN_DAEMON_PORT, /**< Port of communication between scanner and server */
MS_THUMB_DAEMON_PORT, /**< Port of Thumbnail server */
MS_PORT_MAX,
}ms_msg_port_type_e;
+#else
+#define MS_SCANNER_PORT 1001 /**< Directory Scanner */
+#define MS_DB_UPDATE_PORT 1002 /**< Media DB Update */
+#define MS_THUMB_CREATOR_PORT 1003 /**< Create thumbnail */
+#define MS_THUMB_DAEMON_PORT 1004 /**< Port of Thumbnail server */
+#define MS_THUMB_COMM_PORT 1005 /**< Port of communication between creator and server */
+#define MS_DB_BATCH_UPDATE_PORT 1006 /**< Media DB batch update */
+#define MS_SCAN_DAEMON_PORT 1007 /**< Port of communication between scanner and server */
+#define MS_SCAN_COMM_PORT 1008 /**< Port of communication between scanner and server */
+#endif
-#define MAX_MSG_SIZE 4096*2
-#define MAX_FILEPATH_LEN 4096
+#ifdef _USE_UDS_SOCKET_TCP_
+typedef enum{
+ MS_DB_BATCH_UPDATE_TCP_PORT = 0, /**< Media DB batch update */
+ MS_THUMB_CREATOR_TCP_PORT, /**< Create thumbnail */
+ MS_PORT_MAX,
+}ms_msg_port_type_e;
+#endif
+
+#define MAX_MSG_SIZE 4096
typedef enum{
MS_MSG_DB_UPDATE = 0, /**< Media DB Update */
typedef struct
{
- int sock_fd;
- char *sock_path;
-}ms_sock_info_s;
-
-typedef struct
-{
ms_msg_type_e msg_type;
int pid;
uid_t uid;
typedef struct _thumbMsg{
int msg_type;
- int request_id;
+ int thumb_type;
int status;
int pid;
uid_t uid;
int origin_height;
int origin_path_size;
int dest_path_size;
- unsigned char *thumb_data;
- char org_path[MAX_FILEPATH_LEN];
- char dst_path[MAX_FILEPATH_LEN];
+ char org_path[MAX_MSG_SIZE];
+ char dst_path[MAX_MSG_SIZE];
} thumbMsg;
-typedef struct _thumbRawAddMsg{
- int thumb_size;
- unsigned char *thumb_data;
-} thumbRawAddMsg;
#endif /*_MEDIA_SERVER_IPC_H_*/
#include <stdio.h>
#include <stdlib.h>
#include <dlog.h>
-#include <error.h>
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MEDIA_UTIL"
-#define BUF_LENGTH 256
#define FONT_COLOR_RESET "\033[0m"
#define FONT_COLOR_RED "\033[31m"
#define FONT_COLOR_CYAN "\033[36m"
#define FONT_COLOR_GRAY "\033[37m"
-#define MSAPI_DBG_STRERROR(fmt) do { \
- char buf[BUF_LENGTH] = {0,}; \
- strerror_r(errno, buf, BUF_LENGTH); \
- LOGE(fmt" : STANDARD ERROR [%s]", buf); \
- } while (0)
-
-#define MSAPI_DBG_SLOG(fmt, args...) do { \
- SECURE_LOGD(fmt "\n", ##args); \
- } while (0)
-
#define MSAPI_DBG(fmt, arg...) do { \
LOGD(FONT_COLOR_RESET fmt, ##arg); \
} while (0)
#define MSAPI_DBG_INFO(fmt, arg...) do { \
- LOGI(FONT_COLOR_GREEN fmt, ##arg); \
+ LOGD(FONT_COLOR_GREEN fmt, ##arg); \
} while (0)
#define MSAPI_DBG_ERR(fmt, arg...) do { \
LOGD(FONT_COLOR_RESET); \
} while (0)
+
#define MSAPI_RETV_IF(expr, val) do { \
if(expr) { \
LOGE(FONT_COLOR_RED); \
extern "C" {
#endif
+#ifdef _USE_UDS_SOCKET_
#include <sys/un.h>
+#else
+#include <sys/socket.h>
+#endif
+
+#ifdef _USE_UDS_SOCKET_TCP_
+#include <sys/un.h>
+#endif
+
#include <netinet/in.h>
#include <arpa/inet.h>
MS_PROTOCOL_TCP
} ms_protocol_e;
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd, int port);
+#else
+int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd);
+#endif
#ifdef _USE_UDS_SOCKET_TCP_
int ms_ipc_create_client_tcp_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd, int port);
int ms_ipc_create_server_tcp_socket(ms_protocol_e protocol, int port, int *sock_fd);
#endif
+
int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd);
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr);
int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr);
int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *client_addr, unsigned int *size, int *recv_socket);
int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size, int connected);
-int ms_ipc_wait_block_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size);
+#else
+int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_in *serv_addr);
+int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_in *client_addr);
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *client_addr, unsigned int *size);
+int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *size);
+#endif
#ifdef __cplusplus
}
+++ /dev/null
-/*
- * Media Utility
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Yong Yeon Kim <yy9875.kim@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.
- *
- */
-
-/**
- * This file defines api utilities of contents manager engines.
- *
- * @file media-util-not-commoni.h
- * @author Yong Yeon Kim(yy9875.kim@samsung.com)
- * @version 1.0
- * @brief
- */
- #ifndef _MEDIA_UTIL_NOTI_COMMON_H_
-#define _MEDIA_UTIL_NOTI_COMMON_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
- MS_MEDIA_ITEM_FILE = 0,
- MS_MEDIA_ITEM_DIRECTORY = 1,
-}media_item_type_e;
-
-typedef enum {
- MS_MEDIA_ITEM_INSERT = 0,
- MS_MEDIA_ITEM_DELETE = 1,
- 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_update_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 */
- char *mime_type, /* optional */
- void *user_data);
-
-typedef void (*clear_user_data_cb)(void * user_data);
-
-typedef void *MediaNotiHandle; /**< Handle */
-
-#define MS_MEDIA_DBUS_PATH "/com/mediaserver/dbus/notify"
-#define MS_MEDIA_DBUS_INTERFACE "com.mediaserver.dbus.Signal"
-#define MS_MEDIA_DBUS_MATCH_RULE "type='signal',interface='com.mediaserver.dbus.Signal'"
-
-/**
-* @}
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_MEDIA_UTIL_NOTI_COMMON_H_*/
extern "C" {
#endif
-#include "media-util-noti-common.h"
-
/**
* @fn int media_db_update_subscribe(void);
* @brief This function announce media database is updated to other applications.<br>
*/
+typedef enum {
+ MS_MEDIA_ITEM_FILE = 0,
+ MS_MEDIA_ITEM_DIRECTORY = 1,
+}media_item_type_e;
+
+typedef enum {
+ MS_MEDIA_ITEM_INSERT = 0,
+ MS_MEDIA_ITEM_DELETE = 1,
+ 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_update_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 */
+ char *mime_type, /* optional */
+ void *user_data);
+
int media_db_update_subscribe(db_update_cb user_cb, void *user_data);
int media_db_update_unsubscribe(void);
int request_msg_size = 0;
int sockfd = -1;
int err = -1;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
-
+#else
+ struct sockaddr_in serv_addr;
+#endif
unsigned int serv_addr_len = -1;
int port = MS_DB_UPDATE_PORT;
send_msg.uid = uid;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sockfd, port);
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sockfd);
+#endif
MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
ret = ms_ipc_send_msg_to_server(sockfd, port, &send_msg, &serv_addr);
if (ret != MS_MEDIA_ERR_NONE) {
MSAPI_DBG_ERR("ms_ipc_send_msg_to_server failed : %d", ret);
close(sockfd);
- return MS_MEDIA_ERR_SOCKET_CONN;
+ return ret;
}
return g_tcp_client_sock;
}
+#ifdef _USE_UDS_SOCKET_
extern char MEDIA_IPC_PATH[][70];
+#elif defined(_USE_UDS_SOCKET_TCP_)
+extern char MEDIA_IPC_PATH[][50];
+#endif
static int __media_db_prepare_tcp_client_socket()
{
int ret = MS_MEDIA_ERR_NONE;
int sockfd = -1;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#elif defined(_USE_UDS_SOCKET_TCP_)
+ struct sockaddr_un serv_addr;
+#else
+ struct sockaddr_in serv_addr;
+#endif
int port = MS_DB_BATCH_UPDATE_PORT;
/*Create TCP Socket*/
-#ifdef _USE_UDS_SOCKET_TCP_
+#ifdef _USE_UDS_SOCKET_
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sockfd, 0);
+#elif defined(_USE_UDS_SOCKET_TCP_)
ret = ms_ipc_create_client_tcp_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sockfd, MS_DB_BATCH_UPDATE_TCP_PORT);
#else
- ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sockfd, 0);
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sockfd);
#endif
MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
/*Set server Address*/
memset(&serv_addr, 0, sizeof(serv_addr));
+#ifdef _USE_UDS_SOCKET_
+ serv_addr.sun_family = AF_UNIX;
+ MSAPI_DBG("%s", MEDIA_IPC_PATH[port]);
+ strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[port]);
+#elif defined(_USE_UDS_SOCKET_TCP_)
serv_addr.sun_family = AF_UNIX;
-#ifdef _USE_UDS_SOCKET_TCP_
-
MSAPI_DBG("%s", MEDIA_IPC_PATH[MS_DB_BATCH_UPDATE_TCP_PORT]);
strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[MS_DB_BATCH_UPDATE_TCP_PORT]);
#else
- MSAPI_DBG("%s", MEDIA_IPC_PATH[port]);
- strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[port]);
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ //serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ serv_addr.sin_port = htons(port);
#endif
/* Connecting to the media db server */
if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
- MSAPI_DBG_STRERROR("connect error");
+ MSAPI_DBG_ERR("connect error : %s", strerror(errno));
close(sockfd);
return MS_MEDIA_ERR_SOCKET_CONN;
}
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;
- }
- g_tcp_client_sock = -1;
- }
+ close(g_tcp_client_sock);
+ g_tcp_client_sock = -1;
- return ret;
+ return 0;
}
static int __media_db_request_batch_update(ms_msg_type_e msg_type, const char *request_msg, uid_t uid)
return MS_MEDIA_ERR_INVALID_PARAMETER;
}
- MSAPI_DBG_SLOG("querysize[%d] query[%s]", request_msg_size, request_msg);
+ MSAPI_DBG("querysize[%d] query[%s]", request_msg_size, request_msg);
ms_comm_msg_s send_msg;
memset((void *)&send_msg, 0, sizeof(ms_comm_msg_s));
/* Send request */
if (send(sockfd, &send_msg, sizeof(send_msg), 0) != sizeof(send_msg)) {
- MSAPI_DBG_STRERROR("send failed");
+ MSAPI_DBG_ERR("send failed : %s", strerror(errno));
__media_db_close_tcp_client_socket(sockfd);
return MS_MEDIA_ERR_SOCKET_SEND;
+ } else {
+ MSAPI_DBG("Sent successfully");
}
/*Receive Response*/
int recv_msg_size = -1;
int recv_msg = -1;
if ((recv_msg_size = recv(sockfd, &recv_msg, sizeof(recv_msg), 0)) < 0) {
- MSAPI_DBG_ERR("recv failed : [%d]", sockfd);
+ MSAPI_DBG_ERR("recv failed : %s", strerror(errno));
+
__media_db_close_tcp_client_socket(sockfd);
if (errno == EWOULDBLOCK) {
MSAPI_DBG_ERR("Timeout. Can't try any more");
return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
- MSAPI_DBG_STRERROR("recv failed");
+ MSAPI_DBG_ERR("recv failed : %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
MSAPI_DBG("RECEIVE OK [%d]", recv_msg);
ret = recv_msg;
- if (ret != MS_MEDIA_ERR_NONE) {
- MSAPI_DBG_ERR("batch updated[%d] failed, error [%d]", msg_type, ret);
- }
-
return ret;
}
MSAPI_RETVM_IF(!MS_STRING_VALID(query_str), MS_MEDIA_ERR_INVALID_PARAMETER, "Invalid Query");
ret = __media_db_prepare_tcp_client_socket();
- if (ret != MS_MEDIA_ERR_NONE) {
+
+ if (ret < MS_MEDIA_ERR_NONE) {
MSAPI_DBG_ERR("__media_db_prepare_tcp_client_socket failed : %d", ret);
__media_db_close_tcp_client_socket();
return ret;
#include "media-util-dbg.h"
#include "media-util.h"
-#ifdef _USE_UDS_SOCKET_TCP_
-char MEDIA_IPC_PATH[][50] ={
- {"/tmp/media_ipc_dbbatchupdate.dat"},
- {"/tmp/media_ipc_thumbcreator.dat"},
-};
-#else
+#ifdef _USE_UDS_SOCKET_
char MEDIA_IPC_PATH[][70] ={
{"/var/run/media-server/media_ipc_dbbatchupdate.socket"},
{"/var/run/media-server/media_ipc_scandaemon.socket"},
{"/var/run/media-server/media_ipc_thumbcomm_client%i.socket"},
{"/var/run/media-server/media_ipc_thumbdaemon_client%i.socket"},
};
+
+#elif defined(_USE_UDS_SOCKET_TCP_)
+char MEDIA_IPC_PATH[][50] ={
+ {"/tmp/media_ipc_dbbatchupdate.dat"},
+ {"/tmp/media_ipc_thumbcreator.dat"},
+};
#endif
static int _mkdir(const char *dir, mode_t mode) {
return mkdir(tmp, mode);
}
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd, int port)
+#else
+int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd)
+#endif
{
int sock = -1;
char *path;
int cx,len;
+#ifdef _USE_UDS_SOCKET_
+
if (tzplatform_getuid(TZ_USER_NAME) == 0 ){
cx = snprintf ( NULL, 0, MEDIA_IPC_PATH_CLIENT_ROOT[port],getpid());
buffer = (char*)malloc((cx + 1 )*sizeof(char));
buffer = (char*)malloc((cx + 1 )*sizeof(char));
snprintf ( buffer, cx + 1, MEDIA_IPC_PATH_CLIENT[port],tzplatform_getuid(TZ_USER_NAME),getpid());
}
+#endif
if(protocol == MS_PROTOCOL_UDP)
{
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#endif
/* Create a datagram/UDP socket */
+#ifdef _USE_UDS_SOCKET_
if ((sock = socket(PF_FILE, SOCK_DGRAM, 0)) < 0) {
- MSAPI_DBG_STRERROR("socket failed");
+#else
+ if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+#endif
+ MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_CONN;
}
+#ifdef _USE_UDS_SOCKET_
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sun_family = AF_UNIX;
MSAPI_DBG("%s", buffer);
/* Bind to the local address */
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
- MSAPI_DBG_STRERROR("bind failed");
+ MSAPI_DBG_ERR("bind failed : %s", strerror(errno));
close(sock);
+#ifdef _USE_UDS_SOCKET_
free(buffer);
+#endif
return MS_MEDIA_ERR_SOCKET_CONN;
}
+#endif
}
else
{
/*Create TCP Socket*/
+#ifdef _USE_UDS_SOCKET_
if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
- MSAPI_DBG_STRERROR("socket failed");
+#else
+ if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+#endif
+ MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
+#ifdef _USE_UDS_SOCKET_
free(buffer);
+#endif
return MS_MEDIA_ERR_SOCKET_CONN;
}
}
if (timeout_sec > 0) {
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
- MSAPI_DBG_STRERROR("setsockopt failed");
+ MSAPI_DBG_ERR("setsockopt failed: %s", strerror(errno));
close(sock);
+#ifdef _USE_UDS_SOCKET_
free(buffer);
-
+#endif
return MS_MEDIA_ERR_SOCKET_CONN;
}
}
*sock_fd = sock;
+#ifdef _USE_UDS_SOCKET_
free(buffer);
+#endif
return MS_MEDIA_ERR_NONE;
}
bool bind_success = false;
int sock = -1;
int n_reuse = 1;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
mode_t orig_mode;
+#else
+ struct sockaddr_in serv_addr;
+#endif
unsigned short serv_port;
serv_port = port;
if(protocol == MS_PROTOCOL_UDP)
{
/* Create a datagram/UDP socket */
+#ifdef _USE_UDS_SOCKET_
if ((sock = socket(PF_FILE, SOCK_DGRAM, 0)) < 0) {
- MSAPI_DBG_STRERROR("socket failed");
+#else
+ if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+#endif
+ MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_CONN;
}
}
else
{
/* Create a TCP socket */
+#ifdef _USE_UDS_SOCKET_
if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) {
- MSAPI_DBG_STRERROR("socket failed");
+#else
+ if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+#endif
+ MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_CONN;
}
}
-
+#ifdef _USE_UDS_SOCKET_
+#else
+ if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
+ MSAPI_DBG_ERR("setsockopt failed: %s", strerror(errno));
+ close(sock);
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
+ }
+#endif
memset(&serv_addr, 0, sizeof(serv_addr));
-
+#ifdef _USE_UDS_SOCKET_
serv_addr.sun_family = AF_UNIX;
-// MSAPI_DBG_SLOG("%s", MEDIA_IPC_PATH[serv_port]);
+ MSAPI_DBG("%s", MEDIA_IPC_PATH[serv_port]);
unlink(MEDIA_IPC_PATH[serv_port]);
strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[serv_port]);
+#else
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+// serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ serv_addr.sin_port = htons(serv_port);
+#endif
+
orig_mode = umask(0);
/* Bind to the local address */
umask(orig_mode);
if (bind_success == false) {
- MSAPI_DBG_STRERROR("bind failed");
+ MSAPI_DBG_ERR("bind failed : %s %d_", strerror(errno), errno);
close(sock);
return MS_MEDIA_ERR_SOCKET_CONN;
}
/* Listening */
if (protocol == MS_PROTOCOL_TCP) {
if (listen(sock, SOMAXCONN) < 0) {
- MSAPI_DBG_ERR("listen failed");
+ MSAPI_DBG_ERR("listen failed : %s", strerror(errno));
close(sock);
return MS_MEDIA_ERR_SOCKET_CONN;
}
return MS_MEDIA_ERR_NONE;
}
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr)
+#else
+int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_in *serv_addr)
+#endif
{
int res = MS_MEDIA_ERR_NONE;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un addr;
+#else
+ struct sockaddr_in addr;
+#endif
/* Set server Address */
memset(&addr, 0, sizeof(addr));
+#ifdef _USE_UDS_SOCKET_
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, MEDIA_IPC_PATH[port]);
MSAPI_DBG("%s", addr.sun_path);
+#else
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ addr.sin_port = htons(port);
+#endif
if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)&addr, sizeof(addr)) != sizeof(*(send_msg))) {
- MSAPI_DBG_STRERROR("sendto failed");
+ MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
res = 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("sent %d", send_msg->result);
+ MSAPI_DBG("sent %s", send_msg->msg);
if (serv_addr != NULL)
*serv_addr = addr;
}
return res;
}
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr)
+#else
+int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_in *client_addr)
+#endif
{
int res = MS_MEDIA_ERR_NONE;
if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)client_addr, sizeof(*(client_addr))) != sizeof(*(send_msg))) {
- MSAPI_DBG_STRERROR("sendto failed");
+ MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
res = 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("sent %d", send_msg->result);
+ MSAPI_DBG("sent %s", send_msg->msg);
}
return res;
}
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size, int *recv_socket)
+#else
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
+#endif
{
int recv_msg_size;
int client_socket = -1;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un addr;
+#else
+ struct sockaddr_in addr;
+#endif
socklen_t addr_len;
if (!recv_msg)
return MS_MEDIA_ERR_INVALID_PARAMETER;
+#ifdef _USE_UDS_SOCKET_
addr_len = sizeof(addr);
+#else
+ addr_len = sizeof(struct sockaddr_in);
+#endif
+
if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)&addr, &addr_len)) < 0) {
- MSAPI_DBG_STRERROR("recvfrom failed");
+ MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
- MSAPI_DBG_SLOG("the path of received client address : %s", addr.sun_path);
+#ifdef _USE_UDS_SOCKET_
+ if (recv_socket != NULL)
+ *recv_socket = client_socket;
+#endif
if (recv_addr != NULL)
*recv_addr = addr;
return MS_MEDIA_ERR_NONE;
}
+#ifdef _USE_UDS_SOCKET_
int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size, int connected)
+#else
+int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
+#endif
{
int recv_msg_size;
socklen_t addr_len;
if (!recv_msg ||!recv_addr)
return MS_MEDIA_ERR_INVALID_PARAMETER;
+#ifdef _USE_UDS_SOCKET_
addr_len = sizeof(struct sockaddr_un);
+#else
+ addr_len = sizeof(struct sockaddr_in);
+#endif
+
if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)recv_addr, &addr_len)) < 0) {
- MSAPI_DBG_STRERROR("recvfrom failed");
+ MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
if (errno == EWOULDBLOCK) {
MSAPI_DBG_ERR("recvfrom Timeout.");
return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
- MSAPI_DBG_STRERROR("recvfrom error");
+ MSAPI_DBG_ERR("recvfrom error [%s]", strerror(errno));
return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
+#ifdef _USE_UDS_SOCKET_
#include <sys/un.h>
+#else
+#include <sys/socket.h>
+#endif
#include <sys/syscall.h>
#include <string.h>
#include <stdbool.h>
strncpy(send_msg.msg, request_msg, request_msg_size);
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, port);
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
+#endif
MSAPI_RETV_IF(ret != MS_MEDIA_ERR_NONE, ret);
ret = ms_ipc_send_msg_to_server(sockfd, port, &send_msg, NULL);
int media_directory_scanning_async(const char *directory_path, bool recursive_on, scan_complete_cb user_callback, void *user_data, uid_t uid)
{
- int ret = MS_MEDIA_ERR_NONE;
+ int ret;
ret = _check_dir_path(directory_path,uid);
if(ret != MS_MEDIA_ERR_NONE)
int media_files_register(const char *list_path, insert_complete_cb user_callback, void *user_data, uid_t uid)
{
- int ret = MS_MEDIA_ERR_NONE;
+ int ret;
ret = __media_db_request_update_async(MS_MSG_BULK_INSERT, list_path, user_callback, user_data, uid);
int media_burstshot_register(const char *list_path, insert_complete_cb user_callback, void *user_data, uid_t uid)
{
- int ret = MS_MEDIA_ERR_NONE;
+ int ret;
ret = __media_db_request_update_async(MS_MSG_BURSTSHOT_INSERT, list_path, user_callback, user_data, uid);
MSAPI_DBG("client receive: %d", ret);
return ret;
+
}
#include <sys/syscall.h>
#include <dlog.h>
-#include <errno.h>
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MEDIA_COMMON"
-#define BUF_LENGTH 256
-
-#define MS_DBG_STRERROR(fmt) do { \
- char buf[BUF_LENGTH] = {0,}; \
- strerror_r(errno, buf, BUF_LENGTH); \
- LOGE(fmt" : STANDARD ERROR [%s]", buf); \
- } while (0)
-
-
-#define MS_DBG_SLOG(fmt, args...) SECURE_LOGD(fmt "\n", ##args);
#define MS_DBG(fmt, args...) LOGD(fmt "\n", ##args);
#define MS_DBG_INFO(fmt, args...) do{ if (true) { \
- LOGI(fmt "\n" , ##args); \
+ LOGE(fmt "\n" , ##args); \
}} while(false)
#define MS_DBG_WARN(fmt, args...) do{ if (true) { \
#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);} }
+ else { src = malloc(size); memset(src, 0x0, size);} }
/*System default folder definition*/
#define FAT_FILENAME_LEN_MAX 255 /* not inc null */
#include <dirent.h>
#include <malloc.h>
#include <vconf.h>
-#include <errno.h>
#include <notification.h>
#include "media-util.h"
{"/opt/storage/sdcard/Camera"}
};
+
#define DIR_NUM ((int)(sizeof(default_path)/sizeof(default_path[0])))
void
/*at the first time, the directroies are made permission 755*/
ret = chmod(default_path[i], 0777);
if (ret != 0) {
- MS_DBG_STRERROR("chmod failed");
+ MS_DBG_ERR("chmod failed [%s]", strerror(errno));
}
ret = chown(default_path[i], tzplatform_getuid(TZ_USER_NAME), tzplatform_getgid(TZ_USER_NAME));
if (ret != 0) {
- MS_DBG_STRERROR("chown failed");
+ MS_DBG_ERR("chown failed [%s]", strerror(errno));
}
} else {
closedir(dp);
r = setlocale(LC_ALL, "");
if (r == NULL) {
r = setlocale(LC_ALL, vconf_get_str(VCONFKEY_LANGSET));
- MS_DBG_ERR("*****appcore setlocale=%s", r);
+ MS_DBG_ERR("*****appcore setlocale=%s\n", r);
}
free(lang);
}
if (status == MS_SDCARD_INSERTED)
ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_PREPARING_SD_CARD"));
else if (status == MS_SDCARD_REMOVED)
- ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_SD_CARD_UNEXPECTEDLY_REMOVED"));
+ ret = notification_status_message_post(_GETSYSTEMSTR("IDS_COM_BODY_SD_CARD_REMOVED"));
if(ret != NOTIFICATION_ERROR_NONE)
return MS_MEDIA_ERR_INTERNAL;
+
return MS_MEDIA_ERR_NONE;
}
res = vconf_get_str(key);
if (res) {
strncpy(value, res, strlen(res) + 1);
- free(res);
return true;
}
return NOT_OK;
}
} else {
- printf("stat error");
+ printf("stat error : %s", strerror(errno));
}
return NOT_OK;
#define _MEDIA_SCANNER_DBG_H_
#include <sys/syscall.h>
#include <dlog.h>
-#include <errno.h>
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MEDIA_SCANNER"
-#define BUF_LENGTH 256
-
-#define MSC_DBG_STRERROR(fmt) do { \
- char buf[BUF_LENGTH] = {0,}; \
- strerror_r(errno, buf, BUF_LENGTH); \
- LOGE(fmt" : STANDARD ERROR [%s]", buf); \
- } while (0)
-
-#define MSC_DBG_SLOG(fmt, args...) do{ if (true) { \
- SECURE_LOGD(fmt "\n", ##args); \
- }} while(false)
-
-#define MSC_DBG(fmt, args...) do{ if (true) { \
- LOGD(fmt "\n", ##args); \
- }} while(false)
-
-#define MSC_DBG_INFO(fmt, args...) do{ if (true) { \
- LOGI(fmt "\n", ##args); \
- }} while(false)
-
+#define MSC_DBG_INFO(fmt, args...) LOGD(fmt "\n" , ##args);
#define MSC_DBG_ERR(fmt, args...) do{ if (true) { \
LOGE(fmt "\n", ##args); \
}} while(false)
-#define MSC_DBG_WAN(fmt, args...) do{ if (true) { \
- LOGW(fmt "\n", ##args); \
- }} while(false)
-
/**
* @}
*/
} else {
len = pos - buf + EXT_LEN;
*name = strndup(buf, len);
+ MSC_DBG_INFO("%s", *name);
}
return 0;
_msc_load_config();
if(so_array->len == 0) {
- MSC_DBG_ERR("There is no information for functions");
+ MSC_DBG_INFO("There is no information for functions");
return MS_MEDIA_ERR_DYNAMIC_LINK;
}
/*the number of functions*/
lib_num = so_array->len;
- MSC_DBG_SLOG("The number of information of so : %d", lib_num);
+ MSC_DBG_INFO("The number of information of so : %d", lib_num);
MS_MALLOC(scan_func_handle, sizeof(void*) * lib_num);
if (scan_func_handle == NULL) {
MSC_DBG_ERR("malloc failed");
while(lib_index < lib_num) {
/*get handle*/
- MSC_DBG_SLOG("[name of so : %s]", g_array_index(so_array, char*, lib_index));
+ MSC_DBG_INFO("[name of so : %s]", g_array_index(so_array, char*, lib_index));
scan_func_handle[lib_index] = dlopen(g_array_index(so_array, char*, lib_index), RTLD_LAZY);
if (!scan_func_handle[lib_index]) {
MSC_DBG_ERR("%s", dlerror());
dlerror(); /* Clear any existing error */
/*allocate for array of functions*/
- MS_MALLOC(func_array, sizeof(void**) * lib_num);
+ MS_MALLOC(func_array, sizeof(void*) * lib_num);
if (func_array == NULL) {
MSC_DBG_ERR("malloc failed");
MS_SAFE_FREE(scan_func_handle);
MS_SAFE_FREE(func_array);
MS_SAFE_FREE(scan_func_handle);
- MSC_DBG_ERR("dlsym failed [%s]", func_list[func_index]);
+ MSC_DBG_ERR("dlsym failed");
return MS_MEDIA_ERR_DYNAMIC_LINK;
}
}
/*check poweroff status*/
if (power_off) {
- MSC_DBG_ERR("Power off");
+ MSC_DBG_INFO("Power off");
ret = MS_MEDIA_ERR_SCANNER_FORCE_STOP;
}
/*check SD card in out */
if ((mmc_state != VCONFKEY_SYSMAN_MMC_MOUNTED) && (storage_type == MS_STORAGE_EXTERNAL)) {
- MSC_DBG_ERR("Directory scanning is stopped");
+ MSC_DBG_INFO("Directory scanning is stopped");
ret = MS_MEDIA_ERR_SCANNER_FORCE_STOP;
}
/* get the current path from directory array */
current_path = g_array_index(dir_array , char*, 0);
g_array_remove_index (dir_array, 0);
-// MSC_DBG_SLOG("%d", dir_array->len);
+ //MSC_DBG_INFO("%d", dir_array->len);
if (_msc_check_scan_ignore(current_path)) {
MSC_DBG_ERR("%s is ignore", current_path);
if (err != MS_MEDIA_ERR_NONE) {
MSC_DBG_ERR("error : %d", err);
}
- } else if (scan_type == MS_MSG_STORAGE_INVALID) {
+ } else if ( scan_type == MS_MSG_STORAGE_INVALID) {
MSC_DBG_INFO("INVALID");
/*In this case, update just validation record*/
/*update just valid type*/
while (1) {
scan_data = g_async_queue_pop(scan_queue);
if (scan_data->pid == POWEROFF) {
- MSC_DBG_ERR("power off");
+ MSC_DBG_INFO("power off");
goto _POWEROFF;
}
- MSC_DBG_INFO("DIRECTORY SCAN START [%s]", scan_data->msg);
+ MSC_DBG_INFO("DIRECTORY SCAN START");
/*connect to media db, if conneting is failed, db updating is stopped*/
err = msc_connect_db(&handle, scan_data->uid);
noti_path = strndup(scan_data->msg, scan_data->msg_size);
msc_count_delete_items_in_folder(handle, noti_path, &count);
- MSC_DBG_SLOG("delete count %d", count);
- MSC_DBG_SLOG("insert count %d", insert_count);
+ MSC_DBG_INFO("delete count %d", count);
+ MSC_DBG_INFO("insert count %d", insert_count);
msc_delete_invalid_items_in_folder(handle, scan_data->msg,scan_data->uid);
insert_count = 0;
if (power_off) {
- MSC_DBG_WAN("power off");
+ MSC_DBG_INFO("power off");
goto _POWEROFF;
}
while (1) {
scan_data = g_async_queue_pop(storage_queue);
if (scan_data->pid == POWEROFF) {
- MSC_DBG_WAN("power off");
+ MSC_DBG_INFO("power off");
goto _POWEROFF;
}
- MSC_DBG_INFO("STORAGE SCAN START [%s]", scan_data->msg);
+ MSC_DBG_INFO("STORAGE SCAN START");
scan_type = scan_data->msg_type;
if (scan_type != MS_MSG_STORAGE_ALL
_msc_set_db_status(MS_DB_UPDATED);
if (power_off) {
- MSC_DBG_ERR("[No-error] power off");
+ MSC_DBG_INFO("power off");
goto _POWEROFF;
}
static void _msc_insert_register_request(GArray *register_array, ms_comm_msg_s *insert_data)
{
- MSC_DBG_SLOG("path : %s", insert_data->msg);
+ MSC_DBG_INFO("path : %s", insert_data->msg);
if (insert_data->pid == POWEROFF) {
g_array_prepend_val(register_array, insert_data);
*/
#include <arpa/inet.h>
#include <sys/types.h>
-#include <errno.h>
+#ifdef _USE_UDS_SOCKET_
#include <sys/un.h>
+#else
+#include <sys/socket.h>
+#endif
#include <malloc.h>
#include <vconf.h>
ms_comm_msg_s send_msg;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
+#endif
if (ret != MS_MEDIA_ERR_NONE)
return MS_MEDIA_ERR_SOCKET_CONN;
ms_comm_msg_s send_msg;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
+#endif
if (ret != MS_MEDIA_ERR_NONE)
return MS_MEDIA_ERR_SOCKET_CONN;
- /* send result message */
+ /* send ready message */
memset(&send_msg, 0x0, sizeof(ms_comm_msg_s));
send_msg.msg_type = MS_MSG_SCANNER_BULK_RESULT;
send_msg.pid = reg_data->pid;
ms_comm_msg_s send_msg;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_COMM_PORT);
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
+#endif
if (ret != MS_MEDIA_ERR_NONE)
return MS_MEDIA_ERR_SOCKET_CONN;
msc_send_ready();
- MSC_DBG_ERR("*****************************************");
- MSC_DBG_ERR("*** Scanner is running ***");
- MSC_DBG_ERR("*****************************************");
+ MSC_DBG_INFO("*****************************************");
+ MSC_DBG_INFO("*** Scanner is running ***");
+ MSC_DBG_INFO("*****************************************");
g_main_loop_run(scanner_mainloop);
int
ms_invalidate_all_items(void **handle, ms_storage_type_t store_type, uid_t uid);
-#endif /*_MEDIA_SERVER_DB_SVC_H_*/
\ No newline at end of file
+#endif /*_MEDIA_SERVER_DB_SVC_H_*/
#include <sys/syscall.h>
#include <dlog.h>
-#include <errno.h>
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "MEDIA_SERVER"
-#define BUF_LENGTH 256
-#define MS_DBG_STRERROR(fmt) do { \
- char buf[BUF_LENGTH] = {0,}; \
- strerror_r(errno, buf, BUF_LENGTH); \
- LOGE(fmt" : STANDARD ERROR [%s]", buf); \
- } while (0)
-
-#define MS_DBG_SLOG(fmt, args...) do{ if (true) { \
- SECURE_LOGD(fmt "\n" , ##args); \
- }} while(false)
-
-#define MS_DBG(fmt, args...) do{ if (true) { \
- LOGD(fmt "\n" , ##args); \
- }} while(false)
+#define MS_DBG(fmt, args...) LOGD(fmt "\n", ##args);
#define MS_DBG_INFO(fmt, args...) do{ if (true) { \
- LOGI(fmt "\n" , ##args); \
+ LOGE(fmt "\n" , ##args); \
}} while(false)
#define MS_DBG_WARN(fmt, args...) do{ if (true) { \
*/
#include <glib.h>
+#ifdef _USE_UDS_SOCKET_
#include <sys/un.h>
+#else
+#include <sys/socket.h>
+#endif
#include <arpa/inet.h>
#include "media-common-types.h"
#include "media-server-ipc.h"
int
_ms_thumb_recv_msg(int sock, int header_size, thumbMsg *msg);
+#ifdef _USE_UDS_SOCKET_
int
_ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr_un *from_addr, unsigned int *from_size);
+#else
+int
+_ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr_in *from_addr, unsigned int *from_size);
+#endif
int
_ms_thumb_set_buffer(thumbMsg *req_msg, unsigned char **buf, int *buf_size);
/* Create Socket*/
ret = ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_DB_UPDATE_PORT, &sockfd);
if(ret != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("Failed to create socket");
+
+ MS_DBG_ERR("Failed to create socket\n");
return FALSE;
}
#endif
if(ret != MS_MEDIA_ERR_NONE) {
close(sockfd);
- MS_DBG_ERR("Failed to create socket");
+ MS_DBG_ERR("Failed to create socket\n");
return FALSE;
}
g_db_mainloop = g_main_loop_new(context, FALSE);
//context = g_main_loop_get_context(g_db_mainloop);
- /* Create new channel to watch UDP socket */
+ /* Create new channel to watch udp socket */
channel = g_io_channel_unix_new(sockfd);
source = g_io_create_watch(channel, G_IO_IN);
pdir = opendir("/proc");
if (pdir == NULL) {
- MS_DBG_ERR("err: NO_DIR");
+ MS_DBG_ERR("err: NO_DIR\n");
return 0;
}
static void _power_off_cb(void* data)
{
- MS_DBG_ERR("POWER OFF");
+ MS_DBG("++++++++++++++++++++++++++++++++++++++");
+ MS_DBG("POWER OFF");
+ MS_DBG("++++++++++++++++++++++++++++++++++++++");
/*Quit Thumbnail Thread*/
GMainLoop *thumb_mainloop = ms_get_thumb_thread_mainloop();
sigset.sa_handler = _ms_signal_handler;
if (sigaction(SIGCHLD, &sigset, NULL) < 0) {
- MS_DBG_STRERROR("sigaction failed");
+ MS_DBG_ERR("sigaction failed [%s]", strerror(errno));
+ } else {
+ MS_DBG("handler ok");
}
/*clear previous data of sdcard on media database and check db status for updating*/
/* stop media scanner */
if (child_pid >0 ) {
if (kill(child_pid, SIGKILL) < 0) {
- MS_DBG_STRERROR("kill failed");
+ MS_DBG_ERR("kill failed : %s", strerror(errno));
g_mutex_unlock(scanner_mutex);
return TRUE;
}
g_source_unref(src);
}
-int ms_scanner_start(void)
+int
+ms_scanner_start(void)
{
int pid;
int sockfd = -1;
int err = -1;
int n_reuse = 1;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#else
+ struct sockaddr_in serv_addr;
+#endif
unsigned int serv_addr_len = -1;
int port = MS_SCAN_COMM_PORT;
ms_comm_msg_s recv_msg;
GMainContext *res_context = NULL;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_server_socket(MS_PROTOCOL_UDP, MS_SCAN_COMM_PORT, &sockfd);
if (ret != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("ms_ipc_create_server_socket failed [%d]",ret);
g_mutex_unlock(scanner_mutex);
return MS_MEDIA_ERR_SOCKET_CONN;
}
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sockfd);
+ if (ret != MS_MEDIA_ERR_NONE) {
+ MS_DBG_ERR("ms_ipc_create_client_socket failed [%d]",ret);
+ g_mutex_unlock(scanner_mutex);
+ return MS_MEDIA_ERR_SOCKET_CONN;
+ }
+ /* set socket re-use */
+ if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
+ MS_DBG_ERR("setsockopt failed: %s", strerror(errno));
+ close(sockfd);
+ g_mutex_unlock(scanner_mutex);
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
+ }
+ /*Set server Address*/
+ memset(&serv_addr, 0, sizeof(serv_addr));
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ serv_addr.sin_port = htons(port);
+ /* Bind to the local address */
+ if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+ MS_DBG_ERR("bind failed [%s]", strerror(errno));
+ close(sockfd);
+ g_mutex_unlock(scanner_mutex);
+ return MS_MEDIA_ERR_SOCKET_BIND;
+ }
+#endif
/*Receive Response*/
serv_addr_len = sizeof(serv_addr);
#include <arpa/inet.h>
#include <sys/types.h>
+#ifdef _USE_UDS_SOCKET_
#include <sys/un.h>
+#else
+#include <sys/socket.h>
+#endif
#include <errno.h>
#include <malloc.h>
#include <vconf.h>
{
int pid;
int index;
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un *client_addr;
int client_socket;
+#else
+ struct sockaddr_in *client_addr;
+#endif
}ms_req_owner_data;
int _ms_add_owner(ms_req_owner_data *owner_data)
{
+// MS_DBG("the length of array : %d", owner_list->len);
+// MS_DBG("pid : %d", owner_data->pid);
+// MS_DBG("client_addr : %p", owner_data->client_addr);
owner_data->index = -1;
g_array_append_val(owner_list, owner_data);
gboolean ms_read_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un *client_addr = NULL;
+#else
+ struct sockaddr_in *client_addr = NULL;
+#endif
socklen_t client_addr_len;
ms_comm_msg_s recv_msg;
ms_comm_msg_s scan_msg;
}
/* Socket is readable */
+#ifdef _USE_UDS_SOCKET_
MS_MALLOC(client_addr, sizeof(struct sockaddr_un));
+#else
+ MS_MALLOC(client_addr, sizeof(struct sockaddr_in));
+#endif
if (client_addr == NULL) {
MS_DBG_ERR("malloc failed");
g_mutex_unlock(scanner_mutex);
return TRUE;
}
+#ifdef _USE_UDS_SOCKET_
client_addr_len = sizeof(struct sockaddr_un);
+#else
+ client_addr_len = sizeof(struct sockaddr_in);
+#endif
ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), client_addr, NULL, &client_sock);
if (ret != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("ms_ipc_receive_message failed");
int sockfd = -1;
/*Create Socket*/
+#ifdef _USE_UDS_SOCKET_
ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd, MS_SCAN_DAEMON_PORT);
-
+#else
+ ret = ms_ipc_create_client_socket(MS_PROTOCOL_UDP, 0, &sockfd);
+#endif
if (ret != MS_MEDIA_ERR_NONE)
return MS_MEDIA_ERR_SOCKET_CONN;
.msg_size = 0,
.msg = {0},
};
-
+
/* msg_type */
switch (scan_type) {
case MS_SCAN_PART:
gboolean ms_read_db_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un client_addr;
+#else
+ struct sockaddr_in client_addr;
+#endif
+
ms_comm_msg_s recv_msg;
int send_msg = MS_MEDIA_ERR_NONE;
int sockfd = MS_SOCK_NOT_ALLOCATE;
ret = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(recv_msg), &client_addr, NULL, &client_sock);
if (ret != MS_MEDIA_ERR_NONE) {
+ MS_DBG_ERR("ms_ipc_receive_message failed");
return TRUE;
}
gboolean ms_read_db_tcp_socket(GIOChannel *src, GIOCondition condition, gpointer data)
{
+#ifdef _USE_UDS_SOCKET_
+ struct sockaddr_un client_addr;
+#elif defined(_USE_UDS_SOCKET_TCP_)
struct sockaddr_un client_addr;
+#else
+ struct sockaddr_in client_addr;
+#endif
unsigned int client_addr_len;
ms_comm_msg_s recv_msg;
thumbMsg *recv_msg;
} thumbRequest;
+#ifdef _USE_UDS_SOCKET_
extern char MEDIA_IPC_PATH[][70];
+#endif
+
gboolean _ms_thumb_agent_start_jobs(gpointer data)
{
MS_DBG("");
return;
}
-GMainLoop* ms_get_thumb_thread_mainloop(void)
+GMainLoop *
+ms_get_thumb_thread_mainloop(void)
{
return g_thumb_agent_loop;
}
if (g_thumb_server_extracting) {
/* Need to inplement when crash happens */
+#if 0
+ /* Restart thumbnail server */
+ if (_ms_thumb_agent_execute_server() < 0) {
+ MS_DBG_ERR("starting thumbnail-server failed");
+ } else {
+ MS_DBG("Thumbnail-server is started");
+ }
+
+ thumbMsg msg;
+ thumbMsg recv_msg;
+ memset((void *)&msg, 0, sizeof(msg));
+ memset((void *)&recv_msg, 0, sizeof(recv_msg));
+
+ msg.msg_type = 2; // THUMB_REQUEST_ALL_MEDIA
+ msg.org_path[0] = '\0';
+ msg.origin_path_size = 1;
+ msg.dst_path[0] = '\0';
+ msg.dest_path_size = 1;
+
+ /* Command all thumbnail extraction to thumbnail server */
+ if (!_ms_thumb_agent_send_msg_to_thumb_server(&msg, &recv_msg)) {
+ MS_DBG_ERR("_ms_thumb_agent_send_msg_to_thumb_server is failed");
+ }
+
+ _ms_thumb_create_timer(g_timer_id);
+#else
MS_DBG_ERR("Thumbnail server is dead when processing all-thumbs extraction");
g_thumb_server_extracting = FALSE;
g_server_pid = 0;
+#endif
} else {
g_thumb_server_extracting = FALSE;
g_server_pid = 0;
pdir = opendir("/proc");
if (pdir == NULL) {
- MS_DBG_ERR("err: NO_DIR");
+ MS_DBG_ERR("err: NO_DIR\n");
return 0;
}
return ret;
}
-
-int _ms_thumb_create_socket(int sock_type, int *sock)
+int
+_ms_thumb_create_socket(int sock_type, int *sock)
{
int sock_fd = 0;
+#ifdef _USE_UDS_SOCKET_
if ((sock_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
- MS_DBG_STRERROR("socket failed");
+#elif defined(_USE_UDS_SOCKET_TCP_)
+ if ((sock_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+#else
+ if ((sock_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+#endif
+ MS_DBG_ERR("socket failed: %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_CONN;
}
struct timeval tv_timeout = { MS_TIMEOUT_SEC_10, 0 };
if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
- MS_DBG_STRERROR("setsockopt failed");
+ MS_DBG_ERR("setsockopt failed: %s", strerror(errno));
close(sock_fd);
return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
int n_reuse = 1;
if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
- MS_DBG_STRERROR("setsockopt failed: %s");
+ MS_DBG_ERR("setsockopt failed: %s", strerror(errno));
close(sock_fd);
return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
}
-int _ms_thumb_create_udp_socket(int *sock)
+int
+_ms_thumb_create_udp_socket(int *sock)
{
int sock_fd = 0;
+#ifdef _USE_UDS_SOCKET_
if ((sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
- MS_DBG_STRERROR("socket failed");
+#else
+ if ((sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+#endif
+ MS_DBG_ERR("socket failed: %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_CONN;
}
struct timeval tv_timeout = { MS_TIMEOUT_SEC_10, 0 };
if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
- MS_DBG_STRERROR("setsockopt failed");
+ MS_DBG_ERR("setsockopt failed: %s", strerror(errno));
close(sock_fd);
return MS_MEDIA_ERR_SOCKET_INTERNAL;
}
return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
} else {
- MS_DBG_STRERROR("recvfrom failed");
+ MS_DBG_ERR("recvfrom failed : %s", strerror(errno));
return MS_MEDIA_ERR_SOCKET_RECEIVE;
}
}
-int _ms_thumb_recv_msg(int sock, int header_size, thumbMsg *msg)
+int
+_ms_thumb_recv_msg(int sock, int header_size, thumbMsg *msg)
{
int recv_msg_len = 0;
unsigned char *buf = NULL;
buf = (unsigned char*)malloc(header_size);
if ((recv_msg_len = recv(sock, buf, header_size, 0)) < 0) {
- MS_DBG_STRERROR("recv failed");
+ MS_DBG_ERR("recv failed : %s", strerror(errno));
MS_SAFE_FREE(buf);
return _media_thumb_get_error();
}
- memcpy(msg, buf, header_size);
+ memcpy(msg, buf, header_size);
//MS_DBG("origin_path_size : %d, dest_path_size : %d", msg->origin_path_size, msg->dest_path_size);
MS_SAFE_FREE(buf);
buf = (unsigned char*)malloc(msg->origin_path_size);
if ((recv_msg_len = recv(sock, buf, msg->origin_path_size, 0)) < 0) {
- MS_DBG_STRERROR("recv failed");
+ MS_DBG_ERR("recv failed : %s", strerror(errno));
MS_SAFE_FREE(buf);
return _media_thumb_get_error();
}
+
strncpy(msg->org_path, (char*)buf, msg->origin_path_size);
+ //MS_DBG("original path : %s", msg->org_path);
MS_SAFE_FREE(buf);
//MS_DBG("destination path : %s", msg->dst_path);
MS_SAFE_FREE(buf);
-
return MS_MEDIA_ERR_NONE;
}
-int _ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr_un *from_addr, unsigned int *from_size)
+
+int
+#ifdef _USE_UDS_SOCKET_
+_ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr_un *from_addr, unsigned int *from_size)
+#else
+_ms_thumb_recv_udp_msg(int sock, int header_size, thumbMsg *msg, struct sockaddr_in *from_addr, unsigned int *from_size)
+#endif
{
int recv_msg_len = 0;
+#ifdef _USE_UDS_SOCKET_
unsigned int from_addr_size = sizeof(struct sockaddr_un);
+#else
+ unsigned int from_addr_size = sizeof(struct sockaddr_in);
+#endif
unsigned char *buf = NULL;
buf = (unsigned char*)malloc(sizeof(thumbMsg));
-
+
recv_msg_len = ms_ipc_wait_message(sock, buf, sizeof(thumbMsg), from_addr, &from_addr_size, TRUE);
if (recv_msg_len != MS_MEDIA_ERR_NONE) {
- MS_DBG_STRERROR("ms_ipc_wait_message failed");
+ MS_DBG_ERR("ms_ipc_wait_message failed : %s", strerror(errno));
MS_SAFE_FREE(buf);
return _media_thumb_get_error();
}
return MS_MEDIA_ERR_DATA_TAINTED;
}
- strncpy(msg->org_path, (char *)buf + header_size, msg->origin_path_size);
+ strncpy(msg->org_path, (char*)buf + header_size, msg->origin_path_size);
+ //MS_DBG("original path : %s", msg->org_path);
if (msg->dest_path_size <= 0 || msg->dest_path_size > MS_FILE_PATH_LEN_MAX) {
MS_SAFE_FREE(buf);
}
strncpy(msg->dst_path, (char*)buf + header_size + msg->origin_path_size, msg->dest_path_size);
+ //MS_DBG("destination path : %s", msg->dst_path);
MS_SAFE_FREE(buf);
*from_size = from_addr_size;
return MS_MEDIA_ERR_NONE;
}
-int _ms_thumb_set_buffer(thumbMsg *req_msg, unsigned char **buf, int *buf_size)
+int
+_ms_thumb_set_buffer(thumbMsg *req_msg, unsigned char **buf, int *buf_size)
{
if (req_msg == NULL || buf == NULL) {
return -1;
recv_msg_size = ms_ipc_receive_message(g_communicate_sock, & recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL, NULL);
if (recv_msg_size != MS_MEDIA_ERR_NONE) {
- MS_DBG_STRERROR("ms_ipc_receive_message failed");
+ MS_DBG_ERR("ms_ipc_receive_message failed : %s\n", strerror(errno));
return FALSE;
}
recv_msg_size = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL, NULL);
if (recv_msg_size != MS_MEDIA_ERR_NONE) {
- MS_DBG_STRERROR("ms_ipc_receive_message failed");
+ MS_DBG_ERR("ms_ipc_receive_message failed : %s\n", strerror(errno));
return FALSE;
}
MS_DBG("Child process is %d", pid);
g_folk_thumb_server = TRUE;
}
-
+#if 0
+ GSource *child_watch_src = g_child_watch_source_new(pid);
+ g_source_set_callback(child_watch_src, _ms_thumb_agent_child_handler, GINT_TO_POINTER(pid), NULL);
+ g_source_attach(child_watch_src, g_main_context_get_thread_default());
+#endif
+ //g_child_watch_add(pid, _ms_thumb_agent_child_handler, NULL);
g_server_pid = pid;
if (!_ms_thumb_agent_recv_msg_from_server()) {
{
int sock;
const char *serv_ip = "127.0.0.1";
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#else
+ struct sockaddr_in serv_addr;
+#endif
+
int send_str_len = strlen(recv_msg->org_path);
if (send_str_len > MAX_MSG_SIZE) {
return FALSE;
}
+#if 0
+ /* Creaete a datagram/UDP socket */
+ if (_ms_thumb_create_udp_socket(&sock) < 0) {
+ MS_DBG_ERR("_ms_thumb_create_udp_socket failed");
+ return FALSE;
+ }
+#endif
+#ifdef _USE_UDS_SOCKET_
if (ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sock, MS_THUMB_DAEMON_PORT) < 0) {
+#else
+ if (ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sock) < 0) {
+#endif
MS_DBG_ERR("ms_ipc_create_client_socket failed");
return FALSE;
}
memset(&serv_addr, 0, sizeof(serv_addr));
+#ifdef _USE_UDS_SOCKET_
serv_addr.sun_family = AF_UNIX;
MS_DBG("%s", MEDIA_IPC_PATH[MS_THUMB_DAEMON_PORT]);
strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[MS_THUMB_DAEMON_PORT]);
+#else
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = inet_addr(serv_ip);
+ serv_addr.sin_port = htons(MS_THUMB_DAEMON_PORT);
+#endif
int buf_size = 0;
int header_size = 0;
//MS_DBG("buffer size : %d", buf_size);
if (sendto(sock, buf, buf_size, 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != buf_size) {
- MS_DBG_STRERROR("sendto failed");
+ MS_DBG_ERR("sendto failed: %s\n", strerror(errno));
MS_SAFE_FREE(buf);
close(sock);
return FALSE;
}
MS_SAFE_FREE(buf);
- MS_DBG_SLOG("Sending msg to thumbnail server is successful");
+ MS_DBG("Sending msg to thumbnail server is successful");
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un client_addr;
+#else
+ struct sockaddr_in client_addr;
+#endif
unsigned int client_addr_len;
header_size = sizeof(thumbMsg) - MAX_MSG_SIZE*2;
MS_DBG("Timer is called.. Now killing media-thumbnail-server[%d]", g_server_pid);
if (g_server_pid > 0) {
+#if 0
+ if (kill(g_server_pid, SIGKILL) < 0) {
+ MS_DBG_ERR("kill failed : %s", strerror(errno));
+ }
+#else
/* Kill thumbnail server */
thumbMsg msg;
thumbMsg recv_msg;
if (!_ms_thumb_agent_send_msg_to_thumb_server(&msg, &recv_msg)) {
MS_DBG_ERR("_ms_thumb_agent_send_msg_to_thumb_server is failed");
}
-
+#endif
usleep(200000);
} else {
MS_DBG_ERR("g_server_pid is %d. Maybe there's problem in thumbnail-server", g_server_pid);
GIOCondition condition,
gpointer data)
{
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un client_addr;
+#else
+ struct sockaddr_in client_addr;
+#endif
unsigned int client_addr_len;
thumbMsg recv_msg;
GIOCondition condition,
gpointer data)
{
+#ifdef _USE_UDS_SOCKET_
+ struct sockaddr_un client_addr;
+#elif defined(_USE_UDS_SOCKET_TCP_)
struct sockaddr_un client_addr;
+#else
+ struct sockaddr_in client_addr;
+#endif
unsigned int client_addr_len;
+
thumbMsg *recv_msg = NULL;
int header_size = 0;
int sock = -1;
if (send(client_sock, buf, buf_size, 0) != buf_size) {
MS_DBG_ERR("sendto failed : %s", strerror(errno));
} else {
- MS_DBG("Sent Refuse msg from %s", recv_msg->org_path);
+ MS_DBG("Sent Refuse msg from %s \n", recv_msg->org_path);
}
close(client_sock);
return TRUE;
}
- MS_DBG_SLOG("%s is queued", recv_msg->org_path);
+ MS_DBG("%s is queued", recv_msg->org_path);
g_queue_push_tail(g_request_queue, (gpointer)thumb_req);
if (!g_queue_work) {
}
#endif
+
gboolean _ms_thumb_agent_prepare_tcp_socket(int *sock_fd)
{
int sock;
#endif
#if 0
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#else
+ struct sockaddr_in serv_addr;
+#endif
/* Create a TCP socket */
if (_ms_thumb_create_socket(SERVER_SOCKET, &sock) < 0) {
}
memset(&serv_addr, 0, sizeof(serv_addr));
+#ifdef _USE_UDS_SOCKET_
serv_addr.sun_family = AF_UNIX;
strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[serv_port]);
+#else
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ serv_addr.sin_port = htons(serv_port);
+#endif
/* Bind to the local address */
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
return FALSE;
}
#if 0
+#ifdef _USE_UDS_SOCKET_
struct sockaddr_un serv_addr;
+#else
+ struct sockaddr_in serv_addr;
+#endif
/* Creaete a UDP socket */
if (_ms_thumb_create_udp_socket(&sock) < 0) {
}
memset(&serv_addr, 0, sizeof(serv_addr));
+#ifdef _USE_UDS_SOCKET_
serv_addr.sun_family = AF_UNIX;
strcpy(serv_addr.sun_path, MEDIA_IPC_PATH[serv_port]);
+#else
+ serv_addr.sin_family = AF_INET;
+ serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ serv_addr.sin_port = htons(serv_port);
+#endif
/* Bind to the local address */
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
MS_DBG("");
int sockfd = -1;
- GSource *source = NULL;
+ GSource *source = NULL;
GIOChannel *channel = NULL;
GMainContext *context = NULL;
/* Create and bind new TCP socket */
if (!_ms_thumb_agent_prepare_tcp_socket(&sockfd)) {
- MS_DBG_ERR("Failed to create socket");
+ MS_DBG_ERR("Failed to create socket\n");
return NULL;
}
g_source_set_callback(source, (GSourceFunc)_ms_thumb_agent_read_socket, NULL, NULL);
g_source_attach(source, context);
+
MS_DBG("************************************");
MS_DBG("*** Thumbnail Agent thread is running ***");
MS_DBG("************************************");
projects / platform / core / multimedia / media-server.git / commitdiff