libmedia_utils_la_SOURCES = lib/media-util-noti.c \
lib/media-util-ipc.c \
lib/media-util-db.c \
- lib/media-util-register.c
+ lib/media-util-register.c \
+ lib/media-util-cynara.c
libmedia_utils_la_CFLAGS = -I${srcdir}/lib/include \
$(GLIB_CFLAGS) \
$(DB_UTIL_CFLAGS) \
$(PHONESTATUS_CFLAGS) \
$(TZ_PLATFORM_CONFIG_CFLAGS) \
- $(LIBSMACK_CFLAGS)
+ $(LIBSMACK_CFLAGS) \
+ $(CYNARA_CLIENT_CFLAGS) \
+ $(CYNARA_SESSION_CFLAGS) \
+ $(CYNARA_CREDS_SOCKET_CFLAGS)
libmedia_utils_la_LIBADD = $(GLIB_LIBS) \
$(DLOG_LIBS) \
$(DB_UTIL_LIBS) \
$(PHONESTATUS_LIBS) \
$(TZ_PLATFORM_CONFIG_LIBS) \
- $(LIBSMACK_LIBS)
+ $(LIBSMACK_LIBS) \
+ $(CYNARA_CLIENT_LIBS) \
+ $(CYNARA_SESSION_LIBS) \
+ $(CYNARA_CREDS_SOCKET_LIBS)
### file-manager-server ###
src/server/media-server-main.c
media_server_CFLAGS = -I${srcdir}/src/common/include \
- -I${srcdir}/src/server/include \
+ -I${srcdir}/src/server/include \
-I${srcdir}/lib/include \
- $(GTHREAD_CFLAGS) \
- $(GLIB_CFLAGS) \
- $(PHONESTATUS_CFLAGS) \
- $(DLOG_CFLAGS) \
- $(AUL_CFLAG)\
- $(LIBPMCONTROL_CFLAGS) \
- $(DBUS_CFLAGS) \
- $(STATUS_CFLAGS)
+ $(GTHREAD_CFLAGS) \
+ $(GLIB_CFLAGS) \
+ $(PHONESTATUS_CFLAGS) \
+ $(DLOG_CFLAGS) \
+ $(AUL_CFLAG)\
+ $(LIBPMCONTROL_CFLAGS) \
+ $(DBUS_CFLAGS) \
+ $(STATUS_CFLAGS)
media_server_LDADD = libmedia-utils.la \
- $(GLIB_LIBS) \
- $(GTHREAD_LIBS) \
- $(PHONESTATUS_LIBS) \
- $(DLOG_LIBS) \
- $(AUL_LIBS) \
- $(LIBPMCONTROL_LIBS) \
- $(DBUS_LIBS) \
- -ldl \
- $(STATUS_LIBS)
+ $(GLIB_LIBS) \
+ $(GTHREAD_LIBS) \
+ $(PHONESTATUS_LIBS) \
+ $(DLOG_LIBS) \
+ $(AUL_LIBS) \
+ $(LIBPMCONTROL_LIBS) \
+ $(DBUS_LIBS) \
+ -ldl \
+ $(STATUS_LIBS)
media_scanner_SOURCES = src/common/media-common-utils.c \
- src/common/media-common-external-storage.c \
- src/scanner/media-scanner-db-svc.c \
- src/scanner/media-scanner-scan.c \
- src/scanner/media-scanner-socket.c \
- src/scanner/media-scanner.c
+ src/common/media-common-external-storage.c \
+ src/scanner/media-scanner-db-svc.c \
+ src/scanner/media-scanner-scan.c \
+ src/scanner/media-scanner-socket.c \
+ src/scanner/media-scanner.c
media_scanner_CFLAGS = -I${srcdir}/lib/include \
- -I${srcdir}/src/common/include \
- -I${srcdir}/src/scanner/include \
- $(GTHREAD_CFLAGS) \
- $(GLIB_CFLAGS) \
- $(PHONESTATUS_CFLAGS) \
- $(DLOG_CFLAGS) \
- $(AUL_CFLAG)\
- $(LIBPMCONTROL_CFLAGS) \
- $(DBUS_CFLAGS) \
- $(STATUS_CFLAGS)
+ -I${srcdir}/src/common/include \
+ -I${srcdir}/src/scanner/include \
+ $(GTHREAD_CFLAGS) \
+ $(GLIB_CFLAGS) \
+ $(PHONESTATUS_CFLAGS) \
+ $(DLOG_CFLAGS) \
+ $(AUL_CFLAG)\
+ $(LIBPMCONTROL_CFLAGS) \
+ $(DBUS_CFLAGS) \
+ $(STATUS_CFLAGS)
media_scanner_LDADD = libmedia-utils.la \
- $(GLIB_LIBS) \
- $(GTHREAD_LIBS) \
- $(PHONESTATUS_LIBS) \
- $(DLOG_LIBS) \
- $(AUL_LIBS) \
- $(LIBPMCONTROL_LIBS) \
- $(THUMB_GEN_LIBS) \
- $(DBUS_LIBS) \
- -ldl \
- $(STATUS_LIBS)
+ $(GLIB_LIBS) \
+ $(GTHREAD_LIBS) \
+ $(PHONESTATUS_LIBS) \
+ $(DLOG_LIBS) \
+ $(AUL_LIBS) \
+ $(LIBPMCONTROL_LIBS) \
+ $(THUMB_GEN_LIBS) \
+ $(DBUS_LIBS) \
+ -ldl \
+ $(STATUS_LIBS)
mediadb_update_SOURCES = src/mediadb-update.c
mediadb_update_CFLAGS = -I${srcdir}/lib/include \
- $(GTHREAD_CFLAGS) \
- $(GLIB_CFLAGS)
+ $(GTHREAD_CFLAGS) \
+ $(GLIB_CFLAGS)
mediadb_update_CFLAGS += -fPIE
mediadb_update_LDFLAGS = -pie
mediadb_update_LDADD = libmedia-utils.la \
- $(GLIB_LIBS) \
- $(GTHREAD_LIBS) \
- -ldl
+ $(GLIB_LIBS) \
+ $(GTHREAD_LIBS) \
+ -ldl
### includeheaders ###
includeheadersdir = $(includedir)/media-utils
lib/include/media-util-err.h \
lib/include/media-util-db.h \
lib/include/media-util-ipc.h \
+ lib/include/media-util-cynara.h \
lib/include/media-util.h \
lib/include/media-server-ipc.h
AC_SUBST(LIBSMACK_CFLAGS)
AC_SUBST(LIBSMACK_LIBS)
+#cynara
+PKG_CHECK_MODULES(CYNARA_CLIENT, cynara-client)
+AC_SUBST(CYNARA_CLIENT_CFLAGS)
+AC_SUBST(CYNARA_CLIENT_LIBS)
+
+#cynara-creds-socket
+PKG_CHECK_MODULES(CYNARA_CREDS_SOCKET, cynara-creds-socket)
+AC_SUBST(CYNARA_CREDS_SOCKET_CFLAGS)
+AC_SUBST(CYNARA_CREDS_SOCKET_LIBS)
+
+#cynara-session
+PKG_CHECK_MODULES(CYNARA_SESSION, cynara-session)
+AC_SUBST(CYNARA_SESSION_CFLAGS)
+AC_SUBST(CYNARA_SESSION_CFLAGS)
+
#ticker noti library
PKG_CHECK_MODULES(STATUS, notification)
AC_SUBST(STATUS_CFLAGS)
--- /dev/null
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <!-- allow only privileged applications to send and receive notifications -->
+ <policy context="default">
+ <check send_interface="com.mediaserver.dbus.Signal" privilege="http://tizen.org/privilege/mediastorage" />
+ <check receive_interface="com.mediaserver.dbus.Signal" privilege="http://tizen.org/privilege/mediastorage" />
+ </policy>
+
+ <!-- allow root to send and receive notifications -->
+ <policy user="root">
+ <allow send_interface="com.mediaserver.dbus.Signal" />
+ <allow receive_interface="com.mediaserver.dbus.Signal" />
+ </policy>
+</busconfig>
char dst_path[MAX_FILEPATH_LEN];
} thumbMsg;
-typedef struct _thumbRawAddMsg{
- int thumb_size;
- unsigned char *thumb_data;
-} thumbRawAddMsg;
-
#endif /*_MEDIA_SERVER_IPC_H_*/
--- /dev/null
+/*
+ * Media Utility
+ *
+ * Copyright (c) 2015 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.
+ *
+ */
+
+#ifndef _MEDIA_UTIL_CYNARA_H_
+#define _MEDIA_UTIL_CYNARA_H_
+
+#include <stdbool.h>
+#include <media-util-ipc.h>
+
+
+#define MEDIA_STORAGE_PRIVILEGE "http://tizen.org/privilege/mediastorage"
+#define CONTENT_WRITE_PRIVILEGE "http://tizen.org/privilege/content.write"
+
+typedef struct {
+ pid_t pid;
+ char *uid;
+ char *smack;
+} ms_peer_credentials;
+
+int ms_cynara_initialize(void);
+int ms_cynara_check(const ms_peer_credentials *creds, const char *privilege);
+int ms_cynara_receive_untrusted_message(int sockfd, ms_comm_msg_s *recv_msg, ms_peer_credentials *credentials);
+int ms_cynara_receive_untrusted_message_thumb(int sockfd, thumbMsg *recv_msg, ms_peer_credentials *credentials);
+int ms_cynara_enable_credentials_passing(int fd);
+void ms_cynara_finish(void);
+
+#endif/* _MEDIA_UTIL_CYNARA_H_ */
#define MSAPI_DBG_STRERROR(fmt) do { \
char buf[BUF_LENGTH] = {0,}; \
- strerror_r(errno, buf, BUF_LENGTH); \
- LOGE(fmt" : STANDARD ERROR [%s]", buf); \
+ LOGE(fmt" : STANDARD ERROR [%s]", strerror_r(errno, buf, BUF_LENGTH)); \
} while (0)
#define MSAPI_DBG_SLOG(fmt, args...) do { \
int ms_ipc_send_msg_to_server_tcp(int sockfd, ms_msg_port_type_e port, ms_comm_msg_s *send_msg, struct sockaddr_un *serv_addr);
int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr);
int ms_ipc_send_msg_to_client_tcp(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_un *client_addr);
-int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *client_addr, unsigned int *size);
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size);
int ms_ipc_receive_message_tcp(int client_sock, ms_comm_msg_s *recv_msg);
int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size);
int ms_ipc_wait_block_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *size);
#include <media-util-db.h>
#include <media-util-noti.h>
#include <media-util-ipc.h>
+#include <media-util-cynara.h>
+
#include <tzplatform_config.h>
--- /dev/null
+/*
+ * Media Server
+ *
+ * Copyright (c) 2015 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 contains Cynara integration code
+ *
+ * @file media-util-cynara.c
+ * @author Jacek Bukarewicz (j.bukarewicz@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <media-util-cynara.h>
+#include <media-util-dbg.h>
+#include <media-util-err.h>
+#include <media-util-ipc.h>
+#include <media-util-internal.h>
+
+#include <cynara-client.h>
+#include <cynara-session.h>
+#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
+#endif
+
+static cynara *_cynara = NULL;
+G_LOCK_DEFINE_STATIC(cynara_mutex);
+
+static void ms_cynara_dbg_err(const char *prefix, int error_code)
+{
+ char error_buffer[256];
+ int err;
+ error_buffer[0] = '\0';
+
+ err = cynara_strerror(error_code, error_buffer, sizeof(error_buffer));
+ if (err == CYNARA_API_SUCCESS) {
+ MSAPI_DBG_ERR("%s: %s", prefix, error_buffer);
+ } else {
+ MSAPI_DBG_ERR("%s: error code %i", prefix, error_code);
+ }
+}
+
+int ms_cynara_initialize(void)
+{
+ int ret = cynara_initialize(&_cynara, NULL);
+ if (ret != CYNARA_API_SUCCESS) {
+ ms_cynara_dbg_err("cynara_initialize", ret);
+ return MS_MEDIA_ERR_INTERNAL;
+ }
+
+ return MS_MEDIA_ERR_NONE;
+}
+
+void ms_cynara_finish(void)
+{
+ cynara_finish(_cynara);
+ _cynara = NULL;
+}
+
+int ms_cynara_receive_untrusted_message(int sockfd, ms_comm_msg_s *recv_msg, ms_peer_credentials *credentials)
+{
+ int ret = 0;
+ int recv_msg_size = 0;
+
+ if (!recv_msg ||!credentials)
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
+
+ if ((recv_msg_size = read(sockfd, recv_msg, sizeof(ms_comm_msg_s))) < 0) {
+ if (errno == EWOULDBLOCK) {
+ MSAPI_DBG_ERR("Timeout. Can't try any more");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
+ } else {
+ MSAPI_DBG_ERR("recv failed");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ }
+ }
+
+ MSAPI_DBG_SLOG("receive msg from [%d] %d, %s", recv_msg->pid, recv_msg->msg_type, recv_msg->msg);
+
+ if (!(recv_msg->msg_size > 0 && recv_msg->msg_size < MAX_FILEPATH_LEN)) {
+ MSAPI_DBG_ERR("IPC message is wrong. message size is %d", recv_msg->msg_size);
+ return MS_MEDIA_ERR_INVALID_IPC_MESSAGE;
+ }
+
+ 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;
+ }
+
+ 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;
+ }
+
+ 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_DBG_ERR("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack);
+
+ return MS_MEDIA_ERR_NONE;
+}
+
+int ms_cynara_receive_untrusted_message_thumb(int sockfd, thumbMsg *recv_msg, ms_peer_credentials *credentials)
+{
+ int ret = 0;
+ int header_size = 0;
+ int recv_msg_size = 0;
+ unsigned char *buf = NULL;
+
+ if (!recv_msg ||!credentials)
+ return MS_MEDIA_ERR_INVALID_PARAMETER;
+
+ header_size = sizeof(thumbMsg) -(MAX_FILEPATH_LEN * 2) - sizeof(unsigned char *);
+ MS_MALLOC(buf,header_size);
+
+ if ((recv_msg_size = recv(sockfd, buf, header_size, 0)) < 0) {
+ if (errno == EWOULDBLOCK) {
+ MSAPI_DBG_ERR("Timeout. Can't try any more");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
+ } else {
+ MSAPI_DBG_ERR("recv failed");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ }
+ }
+
+ 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_MALLOC(buf, (unsigned int)(recv_msg->origin_path_size));
+ if(buf == NULL) {
+ MSAPI_DBG_STRERROR("malloc failed");
+ return MS_MEDIA_ERR_OUT_OF_MEMORY;
+ }
+
+ if ((recv_msg_size = recv(sockfd, buf, recv_msg->origin_path_size, 0)) < 0) {
+ MS_SAFE_FREE(buf);
+ if (errno == EWOULDBLOCK) {
+ MSAPI_DBG_ERR("Timeout. Can't try any more");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
+ } else {
+ MSAPI_DBG_ERR("recv failed");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ }
+
+ }
+
+ strncpy(recv_msg->org_path, (char*)buf, recv_msg->origin_path_size);
+ 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;
+ }
+
+ MS_MALLOC(buf, (unsigned int)(recv_msg->dest_path_size));
+ if(buf == NULL) {
+ MSAPI_DBG_STRERROR("malloc failed");
+ return MS_MEDIA_ERR_OUT_OF_MEMORY;
+ }
+
+ if ((recv_msg_size = recv(sockfd, buf, recv_msg->dest_path_size, 0)) < 0) {
+ MS_SAFE_FREE(buf);
+ if (errno == EWOULDBLOCK) {
+ MSAPI_DBG_ERR("Timeout. Can't try any more");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
+ } else {
+ MSAPI_DBG_ERR("recv failed");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ }
+
+ }
+
+ strncpy(recv_msg->dst_path, (char*)buf, recv_msg->dest_path_size);
+ 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;
+ }
+
+ 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;
+ }
+
+ 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_DBG_ERR("cynara_creds_info : P[%d]U[%s]S[%s]", credentials->pid, credentials->uid, credentials->smack);
+
+ return MS_MEDIA_ERR_NONE;
+}
+
+int ms_cynara_check(const ms_peer_credentials *creds, const char *privilege)
+{
+ int result;
+ char *session;
+
+ if (!creds || !privilege)
+ 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;
+ }
+
+ G_LOCK(cynara_mutex);
+ result = cynara_check(_cynara, creds->smack, session, creds->uid, privilege);
+ G_UNLOCK(cynara_mutex);
+
+ if (result < 0)
+ ms_cynara_dbg_err("cynara_check", result);
+
+ MS_SAFE_FREE(session);
+ return result == CYNARA_API_ACCESS_ALLOWED ? MS_MEDIA_ERR_NONE : MS_MEDIA_ERR_PERMISSION_DENIED;
+}
+
+int ms_cynara_enable_credentials_passing(int fd)
+{
+ const int optval = 1;
+ int r;
+
+ r = setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &optval, sizeof(optval));
+ if (r != 0) {
+ MSAPI_DBG_ERR("Failed to set SO_PASSSEC socket option");
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
+ }
+
+ r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval));
+ if (r != 0) {
+ MSAPI_DBG_ERR("Failed to set SO_PASSCRED socket option");
+ return MS_MEDIA_ERR_SOCKET_INTERNAL;
+ }
+
+ return MS_MEDIA_ERR_NONE;
+}
+
+
*
*/
+#define _GNU_SOURCE
#include <unistd.h>
#include <string.h>
#include <errno.h>
{
char *result_psswd = NULL;
struct group *grpinfo = NULL;
- char * dir = NULL;
if(uid == getuid())
{
result_psswd = strdup(MEDIA_DB_NAME);
*
*/
+#define _GNU_SOURCE
#include <string.h>
#include <unistd.h>
#include <errno.h>
return res;
}
-int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_un *recv_addr, unsigned int *addr_size)
+int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size)
{
int recv_msg_size;
- struct sockaddr_un addr;
- socklen_t addr_len;
if (!recv_msg)
return MS_MEDIA_ERR_INVALID_PARAMETER;
- addr_len = sizeof(addr);
- if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)&addr, &addr_len)) < 0) {
- MSAPI_DBG_STRERROR("recvfrom failed");
- return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ if ((recv_msg_size = read(sockfd, recv_msg, sizeof(ms_comm_msg_s))) < 0) {
+ 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");
+ return MS_MEDIA_ERR_SOCKET_RECEIVE;
+ }
}
- MSAPI_DBG_SLOG("the path of received client address : %s", addr.sun_path);
-
- if (recv_addr != NULL)
- *recv_addr = addr;
- if (addr_size != NULL)
- *addr_size = addr_len;
-
return MS_MEDIA_ERR_NONE;
}
BuildRequires: pkgconfig(notification)
BuildRequires: pkgconfig(libsmack)
BuildRequires: pkgconfig(libtzplatform-config)
+BuildRequires: pkgconfig(cynara-client)
+BuildRequires: pkgconfig(cynara-session)
%description
Description: File manager service server
install -m 0775 ./data-media/dbspace/file-manager-service/.thumb/phone/PHONE_THUMB_HERE %{buildroot}%{TZ_SYS_DATA}/file-manager-service/.thumb/phone/
install -m 0775 ./data-media/dbspace/file-manager-service/.thumb/phone/.jpg* %{buildroot}%{TZ_SYS_DATA}/file-manager-service/.thumb/phone/
install -D -m 0775 ./data-media/dbspace/file-manager-service/* %{buildroot}%{TZ_SYS_DATA}/file-manager-service/
+mkdir -p %{buildroot}%{_sysconfdir}/dbus-1/system.d
+install -m 0644 dbus/media-server.conf %{buildroot}%{_sysconfdir}/dbus-1/system.d/
%post
vconftool set -t int db/filemanager/dbupdate "1" -f
%{_bindir}/media-server
%{_bindir}/media-scanner
%{_bindir}/mediadb-update
+%config %{_sysconfdir}/dbus-1/system.d/media-server.conf
%exclude %attr(755,-,-) %{_sysconfdir}/rc.d/init.d/mediasvr
%exclude /etc/rc.d/rc3.d/S46mediasvr
%exclude /etc/rc.d/rc5.d/S46mediasvr
{
char *result_psswd = NULL;
struct group *grpinfo = NULL;
+ int err = 0;
+
if(uid == getuid())
{
result_psswd = strdup(MEDIA_ROOT_PATH_INTERNAL);
MS_DBG_ERR("UID [%d] does not belong to 'users' group!", uid);
return NULL;
}
- asprintf(&result_psswd, "%s", userinfo->pw_dir);
+ err = asprintf(&result_psswd, "%s", userinfo->pw_dir);
+ if(err < 0) {
+ MS_DBG_ERR("asprintf failed [%d]", err);
+ return NULL;
+ }
}
return result_psswd;
return FALSE;
}
+ if (ms_cynara_enable_credentials_passing(sockfd) != MS_MEDIA_ERR_NONE) {
+ MS_DBG_ERR("Failed to set up credentials passing\n");
+ return FALSE;
+ }
+
/* Create TCP Socket for batch query*/
ret = ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_DB_BATCH_UPDATE_PORT, &tcp_sockfd);
if(ret != MS_MEDIA_ERR_NONE) {
_ms_new_global_variable();
+ if (ms_cynara_initialize() != MS_MEDIA_ERR_NONE) {
+ MS_DBG_ERR("Failed to initialize cynara");
+ return -1;
+ }
+
__ms_add_requst_receiver(mainloop, &channel);
/* recevie event from other modules */
g_thread_join(db_thread);
g_thread_join(thumb_thread);
+ ms_cynara_finish();
+
_ms_free_global_variable();
MS_DBG_ERR("*** Media Server is stopped ***");
/*prepare socket*/
/* create dir socket */
_mkdir("/var/run/media-server",S_IRWXU | S_IRWXG | S_IRWXO);
-
+
/* Create and bind new UDP socket */
if (ms_ipc_create_server_socket(MS_PROTOCOL_TCP, MS_SCANNER_PORT, &sockfd)
!= MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("Failed to create socket");
return;
} else {
+ if (ms_cynara_enable_credentials_passing(sockfd) != MS_MEDIA_ERR_NONE)
+ MS_DBG_ERR("Failed to setup credential passing");
+
context = g_main_loop_get_context(mainloop);
/* Create new channel to watch udp socket */
*
*/
+#define _GNU_SOURCE
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
{
char *result_psswd = NULL;
struct group *grpinfo = NULL;
+ int err = 0;
+
if(uid == getuid())
{
result_psswd = strdup(MEDIA_ROOT_PATH_INTERNAL);
MS_DBG_ERR("UID [%d] does not belong to 'users' group!", uid);
return NULL;
}
- asprintf(&result_psswd, "%s/%s", userinfo->pw_dir, MEDIA_CONTENT_PATH);
+ err = asprintf(&result_psswd, "%s/%s", userinfo->pw_dir, MEDIA_CONTENT_PATH);
+ if(err < 0) {
+ MS_DBG_ERR("asprintf failed![%d]", err);
+ return NULL;
+ }
}
return result_psswd;
}
-static int __ms_privilege_check(const char *msg, gboolean *privilege)
-{
-#define operation_cnt 3
-#define db_table_cnt 5
-
- int o_idx = 0;
- int t_idx = 0;
- gboolean is_privilege = TRUE;
-
- char *operation[operation_cnt] = {
- "INSERT INTO ",
- "DELETE FROM ",
- "UPDATE "
- };
-
- char *db_table[db_table_cnt] = {
- "playlist_map",
- "playlist",
- "tag_map",
- "tag",
- "bookmark"
- };
-
- if(strlen(msg) < 10) {
- MS_DBG_ERR("msg is too short!!");
- return MS_MEDIA_ERR_INVALID_PARAMETER;
- }
-
- for(o_idx = 0; o_idx < operation_cnt; o_idx++) {
- if(strncmp(operation[o_idx], msg, strlen(operation[o_idx])) == 0) {
- for(t_idx = 0; t_idx < db_table_cnt; t_idx++) {
- if(strncmp(db_table[t_idx], msg+strlen(operation[o_idx]), strlen(db_table[t_idx])) == 0) {
- MS_DBG("Non privilege [%s][%s]", operation[o_idx], db_table[t_idx]);
- is_privilege = FALSE;
- break;
- }
- }
- break;
- }
- }
-
- *privilege = is_privilege;
-
- return MS_MEDIA_ERR_NONE;
-}
-
-static int __ms_privilege_ask(int client_sockfd)
-{
-// int ret = 0;
- int res = MS_MEDIA_ERR_NONE;
-#if 0
- ret = security_server_check_privilege_by_sockfd(client_sockfd, "media-data::db", "w");
- if (ret == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
- MS_DBG_ERR("You do not have permission for this operation.");
- res = MS_MEDIA_ERR_PERMISSION_DENIED;
- } else {
- MS_DBG("PERMISSION OK");
- }
-#endif
- return res;
-}
gboolean ms_read_socket(gpointer user_data)
{
ms_comm_msg_s recv_msg;
int req_num = -1;
int client_sock = -1;
GIOChannel *src = user_data;
+ ms_peer_credentials creds;
sockfd = g_io_channel_unix_get_fd(src);
if (sockfd < 0) {
return TRUE;
}
- ret = ms_ipc_receive_message_tcp(client_sock, &recv_msg);
+ memset(&creds, 0, sizeof(creds));
+
+ ret = ms_cynara_receive_untrusted_message(client_sock, &recv_msg, &creds);
if (ret != MS_MEDIA_ERR_NONE) {
res = ret;
goto ERROR;
}
- ret = __ms_privilege_ask(client_sock);
- if (ret == MS_MEDIA_ERR_PERMISSION_DENIED) {
- res = MS_MEDIA_ERR_PERMISSION_DENIED;
+ if (ms_cynara_check(&creds, MEDIA_STORAGE_PRIVILEGE) != MS_MEDIA_ERR_NONE) {
+ res = ret;
goto ERROR;
}
+ MS_SAFE_FREE(creds.smack);
+ MS_SAFE_FREE(creds.uid);
+
/* copy received data */
req_num = recv_msg.msg_type;
pid = recv_msg.pid;
int ret = MS_MEDIA_ERR_NONE;
MediaDBHandle *db_handle = (MediaDBHandle *)data;
int send_msg = MS_MEDIA_ERR_NONE;
- gboolean privilege = TRUE;
+ ms_peer_credentials creds;
if (power_off == TRUE) {
MS_DBG_WARN("in the power off sequence");
return TRUE;
}
- ret = ms_ipc_receive_message_tcp(client_sock, &recv_msg);
+ memset(&creds, 0, sizeof(creds));
+
+ ret = ms_cynara_receive_untrusted_message(client_sock, &recv_msg, &creds);
if (ret != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("ms_ipc_receive_message_tcp failed [%d]", ret);
send_msg = ret;
goto ERROR;
}
- /* check privileage */
- if(__ms_privilege_check(recv_msg.msg, &privilege) != MS_MEDIA_ERR_NONE) {
+ if (ms_cynara_check(&creds, CONTENT_WRITE_PRIVILEGE) != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("invalid query. size[%d]", recv_msg.msg_size);
- send_msg = MS_MEDIA_ERR_SOCKET_RECEIVE;
+ send_msg = MS_MEDIA_ERR_PERMISSION_DENIED;
goto ERROR;
}
- if (privilege == TRUE) {
- ret = __ms_privilege_ask(client_sock);
- if (ret == MS_MEDIA_ERR_PERMISSION_DENIED) {
- send_msg = MS_MEDIA_ERR_PERMISSION_DENIED;
- goto ERROR;
- }
- }
+ MS_SAFE_FREE(creds.smack);
+ MS_SAFE_FREE(creds.uid);
if(media_db_connect(&db_handle, recv_msg.uid) != MS_MEDIA_ERR_NONE) {
MS_DBG_ERR("Failed to connect DB");
gboolean _ms_thumb_agent_timer();
static GMainLoop *g_thumb_agent_loop = NULL;
-static GIOChannel *g_udp_channel = NULL;
+static GIOChannel *g_tcp_channel = NULL;
static gboolean g_folk_thumb_server = FALSE;
static gboolean g_thumb_server_extracting = FALSE;
static gboolean g_shutdowning_thumb_server = FALSE;
extern char MEDIA_IPC_PATH[][70];
gboolean _ms_thumb_check_queued_request(gpointer data);
+gboolean _ms_thumb_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port);
+
gboolean _ms_thumb_agent_start_jobs(gpointer data)
{
return ret;
}
-int _ms_thumb_create_socket(int sock_type, int *sock)
-{
- int sock_fd = 0;
-
- if ((sock_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
- MS_DBG_STRERROR("socket failed");
- return MS_MEDIA_ERR_SOCKET_CONN;
- }
-
- if (sock_type == CLIENT_SOCKET) {
-
- 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");
- close(sock_fd);
- return MS_MEDIA_ERR_SOCKET_INTERNAL;
- }
- } else if (sock_type == SERVER_SOCKET) {
-
- int n_reuse = 1;
-
- if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
- MS_DBG_STRERROR("setsockopt failed: %s");
- close(sock_fd);
- return MS_MEDIA_ERR_SOCKET_INTERNAL;
- }
- }
-
- *sock = sock_fd;
-
- return MS_MEDIA_ERR_NONE;
-}
-
-
-int _ms_thumb_create_udp_socket(int *sock)
-{
- int sock_fd = 0;
-
- if ((sock_fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
- MS_DBG_STRERROR("socket failed");
- 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");
- close(sock_fd);
- return MS_MEDIA_ERR_SOCKET_INTERNAL;
- }
-
- *sock = sock_fd;
-
- return MS_MEDIA_ERR_NONE;
-}
-
int _media_thumb_get_error()
{
if (errno == EWOULDBLOCK) {
MS_SAFE_FREE(buf);
+ if(msg->msg_type == MS_MSG_THUMB_EXTRACT_ALL_DONE || msg->msg_type == 5) {
+ MS_DBG("msg_type only cases [%d]", msg->msg_type);
+ return MS_MEDIA_ERR_NONE;
+ }
+
if (msg->origin_path_size <= 0 || msg->origin_path_size > MS_FILE_PATH_LEN_MAX) {
MS_SAFE_FREE(buf);
MS_DBG_ERR("msg->origin_path_size is invalid %d", msg->origin_path_size );
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 recv_msg_len = 0;
- unsigned int from_addr_size = sizeof(struct sockaddr_un);
- unsigned char *buf = NULL;
-
- MS_MALLOC(buf, sizeof(thumbMsg));
- if(buf == NULL) {
- MS_DBG_ERR("malloc failed");
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
-
- recv_msg_len = ms_ipc_wait_message(sock, buf, sizeof(thumbMsg), from_addr, &from_addr_size);
- if (recv_msg_len != MS_MEDIA_ERR_NONE) {
- MS_DBG_STRERROR("ms_ipc_wait_message failed");
- MS_SAFE_FREE(buf);
- return _media_thumb_get_error();
- }
-
- memcpy(msg, buf, header_size);
- //MS_DBG("origin_path_size : %d, dest_path_size : %d", msg->origin_path_size, msg->dest_path_size);
-
- if (msg->origin_path_size <= 0 || msg->origin_path_size > MS_FILE_PATH_LEN_MAX) {
- MS_SAFE_FREE(buf);
- MS_DBG_ERR("msg->origin_path_size is invalid %d", msg->origin_path_size);
- return MS_MEDIA_ERR_DATA_TAINTED;
- }
-
- strncpy(msg->org_path, (char *)buf + header_size, msg->origin_path_size);
-
- if (msg->dest_path_size <= 0 || msg->dest_path_size > MS_FILE_PATH_LEN_MAX) {
- MS_SAFE_FREE(buf);
- MS_DBG_ERR("msg->origin_path_size is invalid %d", msg->dest_path_size );
- return MS_MEDIA_ERR_DATA_TAINTED;
- }
-
- strncpy(msg->dst_path, (char*)buf + header_size + msg->origin_path_size, msg->dest_path_size);
-
- MS_SAFE_FREE(buf);
-
- //Additional data
- if(msg->msg_type == 10 && msg->thumb_size > 0) { //THUMB_RESPONSE_RAW_DATA
- thumbRawAddMsg *thumbaddmsg = NULL;
- MS_MALLOC(thumbaddmsg, sizeof(thumbRawAddMsg));
- if(thumbaddmsg == NULL) {
- MS_DBG_ERR("malloc failed");
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
-
- MS_MALLOC(buf, (unsigned int)(msg->thumb_size));
- if(buf == NULL) {
- MS_DBG_ERR("malloc failed");
- MS_SAFE_FREE(thumbaddmsg);
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
-
- recv_msg_len = ms_ipc_wait_block_message(sock, buf, msg->thumb_size, from_addr, &from_addr_size);
- if (recv_msg_len != MS_MEDIA_ERR_NONE) {
- MS_DBG_ERR("ms_ipc_wait_message failed : %s", strerror(errno));
- MS_SAFE_FREE(buf);
- MS_SAFE_FREE(thumbaddmsg);
- return _media_thumb_get_error();
- }
- header_size = sizeof(thumbaddmsg);
-
- memcpy(thumbaddmsg, buf, header_size);
-
- msg->thumb_size = thumbaddmsg->thumb_size;
-
- if (msg->thumb_size <= 0) {
- MS_SAFE_FREE(buf);
- MS_SAFE_FREE(thumbaddmsg);
- MS_DBG_ERR("msg->thumb_size is invalid %d", msg->thumb_size);
- return MS_MEDIA_ERR_DATA_TAINTED;
- }
-
- MS_SAFE_FREE(msg->thumb_data);
- MS_MALLOC(msg->thumb_data, (unsigned int)(msg->thumb_size));
- if(msg->thumb_data == NULL) {
- MS_DBG_ERR("malloc failed");
- MS_SAFE_FREE(buf);
- MS_SAFE_FREE(thumbaddmsg);
- return MS_MEDIA_ERR_OUT_OF_MEMORY;
- }
- memcpy(msg->thumb_data, buf + header_size, msg->thumb_size);
-
- MS_SAFE_FREE(thumbaddmsg->thumb_data);
- MS_SAFE_FREE(thumbaddmsg);
- 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)
{
if (req_msg == NULL || buf == NULL) {
gboolean _ms_thumb_agent_recv_msg_from_server()
{
+ struct sockaddr_un serv_addr;
+ unsigned int serv_addr_len;
+
+ int sockfd = -1;
+
if (g_communicate_sock <= 0) {
- _ms_thumb_agent_prepare_udp_socket();
+ _ms_thumb_agent_prepare_tcp_socket(&g_communicate_sock, MS_THUMB_COMM_PORT);
+ }
+
+ serv_addr_len = sizeof(serv_addr);
+
+ if ((sockfd = accept(g_communicate_sock, (struct sockaddr*)&serv_addr, &serv_addr_len)) < 0) {
+ MS_DBG_STRERROR("accept failed");
+ return FALSE;
}
ms_thumb_server_msg recv_msg;
int recv_msg_size = 0;
- recv_msg_size = ms_ipc_receive_message(g_communicate_sock, & recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL);
+ recv_msg_size = ms_ipc_receive_message(sockfd, & recv_msg, sizeof(ms_thumb_server_msg));
if (recv_msg_size != MS_MEDIA_ERR_NONE) {
MS_DBG_STRERROR("ms_ipc_receive_message failed");
return FALSE;
MS_DBG("Thumbnail server is ready");
}
+ close(sockfd);
return TRUE;
}
gboolean _ms_thumb_agent_recv_thumb_done_from_server(GIOChannel *src, GIOCondition condition, gpointer data)
{
+ int ret = MS_MEDIA_ERR_NONE;
+ struct sockaddr_un thumb_serv_addr;
+ unsigned int thumb_serv_addr_len;
+
int sockfd = -1;
+ int thumb_serv_sockfd = -1;
/* Once all-thumb extraction is done, check if there is queued all-thumb request */
GSource *check_queued_all_thumb_request = NULL;
return FALSE;
}
+ thumb_serv_addr_len = sizeof(thumb_serv_addr);
+
+ if ((thumb_serv_sockfd = accept(sockfd, (struct sockaddr*)&thumb_serv_addr, &thumb_serv_addr_len)) < 0) {
+ MS_DBG_STRERROR("accept failed");
+ return FALSE;
+ }
+
ms_thumb_server_msg recv_msg;
- int recv_msg_size = 0;
- MS_DBG_ERR("THUMB SERVER SOCKET %d", sockfd);
+ MS_DBG_ERR("THUMB SERVER SOCKET %d", thumb_serv_sockfd);
- recv_msg_size = ms_ipc_receive_message(sockfd, &recv_msg, sizeof(ms_thumb_server_msg), NULL, NULL);
- if (recv_msg_size != MS_MEDIA_ERR_NONE) {
+ ret = ms_ipc_receive_message(thumb_serv_sockfd, &recv_msg, sizeof(ms_thumb_server_msg));
+ if (ret != MS_MEDIA_ERR_NONE) {
MS_DBG_STRERROR("ms_ipc_receive_message failed");
+ close(thumb_serv_sockfd);
return FALSE;
}
- MS_DBG("Receive : %d(%d)", recv_msg.msg_type, recv_msg_size);
+ close(thumb_serv_sockfd);
+
+ MS_DBG("Receive : %d", recv_msg.msg_type);
if (recv_msg.msg_type == MS_MSG_THUMB_EXTRACT_ALL_DONE) {
MS_DBG("Thumbnail extracting done");
g_thumb_server_extracting = FALSE;
ms_sock_info_s sock_info;
struct sockaddr_un serv_addr;
int send_str_len = strlen(recv_msg->org_path);
- sock_info.port = MS_THUMB_DAEMON_PORT;
if (send_str_len > MAX_FILEPATH_LEN) {
MS_DBG_ERR("original path's length exceeds %d(max packet size)", MAX_FILEPATH_LEN);
return FALSE;
}
- if (ms_ipc_create_client_socket(MS_PROTOCOL_UDP, MS_TIMEOUT_SEC_10, &sock_info) < 0) {
+ if (ms_ipc_create_client_socket(MS_PROTOCOL_TCP, MS_TIMEOUT_SEC_10, &sock_info) < 0) {
MS_DBG_ERR("ms_ipc_create_client_socket failed");
return FALSE;
}
memset(&serv_addr, 0, sizeof(serv_addr));
sock = sock_info.sock_fd;
serv_addr.sun_family = AF_UNIX;
-// MS_DBG_SLOG("%s", MEDIA_IPC_PATH[MS_THUMB_DAEMON_PORT]);
strncpy(serv_addr.sun_path, MEDIA_IPC_PATH[MS_THUMB_DAEMON_PORT], strlen(MEDIA_IPC_PATH[MS_THUMB_DAEMON_PORT]));
+ /* Connecting to the thumbnail server */
+ if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
+ MS_DBG_STRERROR("connect");
+ return MS_MEDIA_ERR_SOCKET_CONN;
+ }
+
int buf_size = 0;
- int header_size = 0;
unsigned char *buf = NULL;
_ms_thumb_set_buffer(recv_msg, &buf, &buf_size);
//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");
+ if (send(sock, buf, buf_size, 0) != buf_size) {
+ MS_DBG_STRERROR("send failed");
MS_SAFE_FREE(buf);
ms_ipc_delete_client_socket(&sock_info);
return FALSE;
MS_SAFE_FREE(buf);
MS_DBG_SLOG("Sending msg to thumbnail server is successful");
- struct sockaddr_un client_addr;
- unsigned int client_addr_len;
- header_size = sizeof(thumbMsg) - (MAX_FILEPATH_LEN * 2) - sizeof(unsigned char *);
-
- if (_ms_thumb_recv_udp_msg(sock, header_size, res_msg, &client_addr, &client_addr_len) < 0) {
- MS_DBG_ERR("_ms_thumb_recv_udp_msg failed");
+ if (_ms_thumb_recv_msg(sock, res_msg) < 0) {
+ MS_DBG_ERR("_ms_thumb_recv_msg failed");
ms_ipc_delete_client_socket(&sock_info);
return FALSE;
}
ms_ipc_delete_client_socket(&sock_info);
if (res_msg->msg_type == 2 && g_communicate_sock > 0) { // THUMB_REQUEST_ALL_MEDIA
- /* Create new channel to watch udp socket */
GSource *source = NULL;
- if (g_udp_channel == NULL)
- g_udp_channel = g_io_channel_unix_new(g_communicate_sock);
- source = g_io_create_watch(g_udp_channel, G_IO_IN);
+ if (g_tcp_channel == NULL)
+ g_tcp_channel = g_io_channel_unix_new(g_communicate_sock);
+ source = g_io_create_watch(g_tcp_channel, G_IO_IN);
/* Set callback to be called when socket is readable */
g_source_set_callback(source, (GSourceFunc)_ms_thumb_agent_recv_thumb_done_from_server, NULL, NULL);
int sock = -1;
int client_sock = -1;
unsigned char *buf = NULL;
- int recv_msg_len = 0;
struct ucred cr;
int cl = sizeof(struct ucred);
-
+
sock = g_io_channel_unix_get_fd(src);
if (sock < 0) {
MS_DBG_ERR("sock fd is invalid!");
client_addr_len = sizeof(client_addr);
if ((client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
- MS_DBG_ERR("accept failed : %s", strerror(errno));
+ MS_DBG_STRERROR("accept failed");
return TRUE;
}
res_msg.thumb_size = 0;
int buf_size = 0;
- unsigned char *buf = NULL;
_ms_thumb_set_buffer(&res_msg, &buf, &buf_size);
if (send(client_sock, buf, buf_size, 0) != buf_size) {
return TRUE;
}
-gboolean _ms_thumb_agent_prepare_tcp_socket(int *sock_fd)
+gboolean _ms_thumb_agent_prepare_tcp_socket(int *sock_fd, unsigned short serv_port)
{
int sock;
- unsigned short serv_port;
-
- serv_port = MS_THUMB_CREATOR_PORT;
if (ms_ipc_create_server_socket(MS_PROTOCOL_TCP, serv_port, &sock) < 0) {
MS_DBG_ERR("_ms_thumb_create_socket failed");
return TRUE;
}
-gboolean _ms_thumb_agent_prepare_udp_socket()
-{
- int sock;
- unsigned short serv_port;
-
- serv_port = MS_THUMB_COMM_PORT;
-
- if (ms_ipc_create_server_socket(MS_PROTOCOL_UDP, serv_port, &sock) < 0) {
- MS_DBG_ERR("ms_ipc_create_server_socket failed");
- return FALSE;
- }
-
- g_communicate_sock = sock;
-
- return TRUE;
-}
-
gpointer ms_thumb_agent_start_thread(gpointer data)
{
MS_DBG("");
GMainContext *context = NULL;
/* Create and bind new TCP socket */
- if (!_ms_thumb_agent_prepare_tcp_socket(&sockfd)) {
+ if (!_ms_thumb_agent_prepare_tcp_socket(&sockfd, MS_THUMB_CREATOR_PORT)) {
MS_DBG_ERR("Failed to create socket");
return NULL;
}
/*close an IO channel*/
g_io_channel_shutdown(channel, FALSE, NULL);
- g_io_channel_shutdown(g_udp_channel, FALSE, NULL);
+ g_io_channel_shutdown(g_tcp_channel, FALSE, NULL);
g_io_channel_unref(channel);
close(g_communicate_sock);
projects / platform / core / multimedia / media-server.git / commitdiff