modified access_control

Change-Id: I80a0b440237a4db90650e7788ad81715a7b10916

diff --git a/client/cal_client_db_helper.c b/client/cal_client_db_helper.c
index 7f5cf25..7e59939 100644 (file)
--- a/client/cal_client_db_helper.c
+++ b/client/cal_client_db_helper.c
@@ -1655,7 +1655,7 @@ int cal_client_db_get_last_change_version(calendar_h handle, int* last_version)
        *last_version = 0;
 
        bool result = false;
-       ret = cal_client_ipc_client_check_permission(CAL_PERMISSION_READ, &result);
+       ret = cal_client_ipc_client_check_permission(handle, CAL_PERMISSION_READ, &result);
        if (CALENDAR_ERROR_NONE != ret) {
                ERR("cal_client_ipc_client_check_permission() Fail (%d)", ret);
                return ret;

diff --git a/client/cal_client_ipc.c b/client/cal_client_ipc.c
index 825e8d4..035a26e 100644 (file)
--- a/client/cal_client_ipc.c
+++ b/client/cal_client_ipc.c
@@ -25,6 +25,7 @@
 
 #include "calendar_db.h"
 #include "calendar_types.h"
+#include "cal_client_service.h"
 #include "cal_client_service_helper.h"
 #include "cal_client_utils.h"
 #include "cal_client_ipc.h"
@@ -312,7 +313,7 @@ int cal_client_ipc_get_change_version(calendar_h handle)
        return h->version;
 }
 
-int cal_client_ipc_client_check_permission(int permission, bool *result)
+int cal_client_ipc_client_check_permission(calendar_h handle, int permission, bool *result)
 {
        pims_ipc_data_h indata = NULL;
        pims_ipc_data_h outdata = NULL;
@@ -327,6 +328,13 @@ int cal_client_ipc_client_check_permission(int permission, bool *result)
                return CALENDAR_ERROR_OUT_OF_MEMORY;
        }
 
+       ret = cal_ipc_marshal_handle(handle, indata);
+       if (CALENDAR_ERROR_NONE != ret) {
+               ERR("cal_ipc_marshal_handle() Fail(%d)", ret);
+               pims_ipc_data_destroy(indata);
+               return ret;
+       }
+
        ret = cal_ipc_marshal_int(permission, indata);
        if (CALENDAR_ERROR_NONE != ret) {
                ERR("cal_ipc_marshal_int() Fail(%d)", ret);

diff --git a/client/cal_client_ipc.h b/client/cal_client_ipc.h
index 2dd4a04..9c23aeb 100644 (file)
--- a/client/cal_client_ipc.h
+++ b/client/cal_client_ipc.h
@@ -29,7 +29,7 @@ int cal_client_ipc_disconnect(calendar_h handle, unsigned int id, int connection
 
 bool cal_client_ipc_is_call_inprogress(void);
 int cal_client_ipc_call(char *module, char *function, pims_ipc_h data_in, pims_ipc_data_h *data_out);
-int cal_client_ipc_client_check_permission(int permission, bool *result);
+int cal_client_ipc_client_check_permission(calendar_h handle, int permission, bool *result);
 int cal_client_ipc_get_change_version(calendar_h handle);
 void cal_client_ipc_set_change_version(calendar_h handle, int version);
 void cal_client_ipc_lock(void);

diff --git a/client/cal_client_reminder.c b/client/cal_client_reminder.c
index 40dbe7d..ca7599a 100644 (file)
--- a/client/cal_client_reminder.c
+++ b/client/cal_client_reminder.c
@@ -143,10 +143,13 @@ API int calendar_reminder_add_cb(calendar_reminder_cb callback, void *user_data)
        GSList *it = NULL;
        callback_info_s *cb_info = NULL;
        bool result = false;
+       calendar_h handle = NULL;
+       ret = cal_client_handle_get_p(&handle);
+       RETVM_IF(CALENDAR_ERROR_NONE != ret, ret, "cal_client_handle_get_p() Fail(%d)", ret);
 
        RETV_IF(NULL == callback, CALENDAR_ERROR_INVALID_PARAMETER);
 
-       ret = cal_client_ipc_client_check_permission(CAL_PERMISSION_READ, &result);
+       ret = cal_client_ipc_client_check_permission(handle, CAL_PERMISSION_READ, &result);
        RETVM_IF(CALENDAR_ERROR_NONE != ret, ret, "ctsvc_ipc_client_check_permission() Fail(%d)", ret);
        RETVM_IF(result == false, CALENDAR_ERROR_PERMISSION_DENIED, "Permission denied (calendar read)");
 

diff --git a/client/cal_client_service_helper.c b/client/cal_client_service_helper.c
index 7c21af5..7a288f9 100644 (file)
--- a/client/cal_client_service_helper.c
+++ b/client/cal_client_service_helper.c
@@ -59,9 +59,9 @@ int cal_client_connect(calendar_h handle, unsigned int id, int *connection_count
 
        if (0 == *connection_count) { /* total connection */
                g_type_init(); /* for alarmmgr */
-               ret = cal_inotify_initialize();
+               ret = cal_inotify_init();
                if (CALENDAR_ERROR_NONE != ret) {
-                       ERR("cal_inotify_initialize() Fail(%d)", ret);
+                       ERR("cal_inotify_init() Fail(%d)", ret);
                        cal_mutex_unlock(CAL_MUTEX_CONNECTION);
                        return ret;
                }
@@ -113,7 +113,7 @@ int cal_client_disconnect(calendar_h handle, unsigned int id, int *connection_co
                DBG("[System] disconnected successfully");
                cal_client_reminder_destroy_for_subscribe();
                cal_view_finalize();
-               cal_inotify_finalize();
+               cal_inotify_deinit();
        }
        else if (1 < *connection_count) {
                DBG("[System] connection count(%d)", *connection_count);

diff --git a/common/cal_inotify.c b/common/cal_inotify.c
index b1eed79..57e1282 100644 (file)
--- a/common/cal_inotify.c
+++ b/common/cal_inotify.c
@@ -195,7 +195,7 @@ static inline int _inotify_attach_handler(int fd)
        return ret;
 }
 
-int cal_inotify_initialize(void)
+int cal_inotify_init(void)
 {
        int ret;
 
@@ -526,7 +526,7 @@ static void __clear_nslot_list(gpointer data, gpointer user_data)
        free(data);
 }
 
-void cal_inotify_finalize(void)
+void cal_inotify_deinit(void)
 {
 #ifdef CAL_IPC_CLIENT
        cal_mutex_lock(CAL_MUTEX_INOTIFY);

diff --git a/common/cal_inotify.h b/common/cal_inotify.h
index 5f1701e..d3e314c 100644 (file)
--- a/common/cal_inotify.h
+++ b/common/cal_inotify.h
@@ -27,11 +27,11 @@
 void cal_inotify_call_pending_callback(void);
 #endif
 
-int cal_inotify_initialize(void);
+int cal_inotify_init(void);
 int cal_inotify_subscribe(cal_noti_type_e type, const char *path, calendar_db_changed_cb callback, void *data);
 int cal_inotify_unsubscribe_with_data(const char *path, calendar_db_changed_cb callback, void *user_data);
 int cal_inotify_subscribe_ipc_ready(calendar_h handle, void (*cb)(void *), void *user_data);
 int cal_inotify_unsubscribe_ipc_ready(calendar_h handle);
-void cal_inotify_finalize(void);
+void cal_inotify_deinit(void);
 
 #endif /* __CALENDAR_SVC_INOTIFY_H__ */

diff --git a/server/cal_access_control.c b/server/cal_access_control.c
index d8c929b..73b6472 100644 (file)
--- a/server/cal_access_control.c
+++ b/server/cal_access_control.c
@@ -41,21 +41,25 @@ typedef struct {
        pims_ipc_h ipc;
        char *smack_label;
        int *write_list;
-} calendar_permission_info_s;
+       int write_list_count;
+} cal_permission_info_s;
 
-static GList *__thread_list = NULL;
-
-static int have_smack = -1;
+enum {
+       CAL_SMACK_NOT_CHECKED,
+       CAL_SMACK_ENABLED, /* 1 */
+       CAL_SMACK_DISABLED, /* 0 */
+};
 
-static calendar_permission_info_s* __cal_access_control_find_permission_info(unsigned int thread_id);
+static GList *__thread_list = NULL;
+static int have_smack = CAL_SMACK_NOT_CHECKED;
 static void _cal_access_control_disconnected_cb(pims_ipc_h ipc, void *user_data);
 
-static calendar_permission_info_s* _cal_access_control_find_permission_info(unsigned int thread_id)
+static cal_permission_info_s* _cal_access_control_find_permission_info(unsigned int thread_id)
 {
        GList *cursor;
 
        for(cursor=__thread_list;cursor;cursor=cursor->next) {
-               calendar_permission_info_s *info = NULL;
+               cal_permission_info_s *info = NULL;
                info = cursor->data;
                if (info->thread_id == thread_id)
                        return info;
@@ -66,40 +70,48 @@ static calendar_permission_info_s* _cal_access_control_find_permission_info(unsi
 /* check SMACK enable or disable */
 static int _cal_have_smack(void)
 {
-       if (-1 == have_smack) {
+       if (CAL_SMACK_NOT_CHECKED == have_smack) {
                if (NULL == smack_smackfs_path())
-                       have_smack = 0;
+                       have_smack = CAL_SMACK_DISABLED;
                else
-                       have_smack = 1;
+                       have_smack = CAL_SMACK_ENABLED;
        }
        return have_smack;
 }
 
-static void _cal_access_control_set_permission_info(calendar_permission_info_s *info)
+static void _cal_access_control_set_permission_info(cal_permission_info_s *info)
 {
+       int ret = 0;
        bool smack_enabled = false;
 
-       if (_cal_have_smack() == 1)
+       if (CAL_SMACK_ENABLED == _cal_have_smack())
                smack_enabled = true;
        else
                INFO("SAMCK disabled");
 
+       /* white listing : core module */
        free(info->write_list);
        info->write_list = NULL;
+       info->write_list_count = 0;
 
        char query[CAL_DB_SQL_MAX_LEN] = {0};
        int count = 0;
-       int ret = 0;
-       sqlite3_stmt *stmt;
-       int write_index = 0;
        snprintf(query, sizeof(query), "SELECT count(id) FROM %s WHERE deleted = 0 ", CAL_TABLE_CALENDAR);
        ret = cal_db_util_query_get_first_int_result(query, NULL, &count);
-       RETM_IF(CALENDAR_ERROR_NONE != ret, "cal_db_util_query_get_first_int_result() Fail(%d)", ret);
+       if (CALENDAR_ERROR_NONE != ret) {
+               ERR("cal_db_util_query_get_first_int_result() Fail(%d)", ret);
+               SECURE("query[%s]", query);
+               return;
+       }
 
        info->write_list = calloc(count +1, sizeof(int));
-       RETM_IF(NULL == info->write_list, "calloc() Fail");
-       info->write_list[0] = -1;
+       if (NULL == info->write_list) {
+               ERR("calloc() Fail");
+               return;
+       }
+       info->write_list_count = 0;
 
+       sqlite3_stmt *stmt = NULL;
        snprintf(query, sizeof(query), "SELECT id, mode, owner_label FROM %s WHERE deleted = 0 ", CAL_TABLE_CALENDAR);
        ret = cal_db_util_query_prepare(query, &stmt);
        if (CALENDAR_ERROR_NONE != ret) {
@@ -108,10 +120,15 @@ static void _cal_access_control_set_permission_info(calendar_permission_info_s *
                return;
        }
 
+       int write_index = 0;
        while (CAL_SQLITE_ROW == cal_db_util_stmt_step(stmt)) {
-               int id = sqlite3_column_int(stmt, 0);
-               int mode = sqlite3_column_int(stmt, 1);
-               char *temp = (char *)sqlite3_column_text(stmt, 2);
+               int id = 0;
+               int mode = 0;
+               char *temp = NULL;
+
+               id = sqlite3_column_int(stmt, 0);
+               mode = sqlite3_column_int(stmt, 1);
+               temp = (char *)sqlite3_column_text(stmt, 2);
 
                if (!smack_enabled) // smack disabled
                        info->write_list[write_index++] = id;
@@ -122,21 +139,19 @@ static void _cal_access_control_set_permission_info(calendar_permission_info_s *
                else if (CALENDAR_BOOK_MODE_NONE == mode)
                        info->write_list[write_index++] = id;
        }
-       info->write_list[write_index] = -1;
+       info->write_list_count = write_index;
        sqlite3_finalize(stmt);
 }
 
 void cal_access_control_set_client_info(pims_ipc_h ipc, const char *smack_label)
 {
-       unsigned int thread_id = 0;
-       calendar_permission_info_s *info = NULL;
+       unsigned int thread_id = (unsigned int)pthread_self();
+       cal_permission_info_s *info = NULL;
 
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
-
-       thread_id = (unsigned int)pthread_self();
        info = _cal_access_control_find_permission_info(thread_id);
        if (NULL == info) {
-               info = calloc(1, sizeof(calendar_permission_info_s));
+               info = calloc(1, sizeof(cal_permission_info_s));
                if (NULL == info) {
                        ERR("calloc() Fail");
                        cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
@@ -160,7 +175,7 @@ void cal_access_control_set_client_info(pims_ipc_h ipc, const char *smack_label)
 
 void cal_access_control_unset_client_info(void)
 {
-       calendar_permission_info_s *find = NULL;
+       cal_permission_info_s *find = NULL;
 
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
        find = _cal_access_control_find_permission_info(pthread_self());
@@ -176,7 +191,7 @@ void cal_access_control_unset_client_info(void)
 bool cal_access_control_have_permission(pims_ipc_h ipc, cal_permission_e permission)
 {
        have_smack = _cal_have_smack();
-       if (have_smack != 1) // smack disabled
+       if (CAL_SMACK_DISABLED == have_smack)
                return true;
 
        if (NULL == ipc) // calendar-service daemon
@@ -194,7 +209,7 @@ bool cal_access_control_have_permission(pims_ipc_h ipc, cal_permission_e permiss
 char* cal_access_control_get_label(void)
 {
        unsigned int thread_id = (unsigned int)pthread_self();
-       calendar_permission_info_s *info = NULL;
+       cal_permission_info_s *info = NULL;
 
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
        info = _cal_access_control_find_permission_info(thread_id);
@@ -212,7 +227,7 @@ void cal_access_control_reset(void)
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
        GList *cursor;
        for(cursor=__thread_list;cursor;cursor=cursor->next) {
-               calendar_permission_info_s *info = NULL;
+               cal_permission_info_s *info = NULL;
                info = cursor->data;
                if (info)
                        _cal_access_control_set_permission_info(info);
@@ -220,46 +235,45 @@ void cal_access_control_reset(void)
        cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
 }
 
-bool cal_access_control_have_write_permission(int calendarbook_id)
+bool cal_access_control_have_write_permission(int book_id)
 {
-       int i = 0;
-       calendar_permission_info_s *find = NULL;
+       cal_permission_info_s *info = NULL;
 
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
-       find = _cal_access_control_find_permission_info(pthread_self());
-       if (!find) {
+       unsigned int thread_id = pthread_self();
+       info = _cal_access_control_find_permission_info(thread_id);
+       if (NULL == info) {
                cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
-               ERR("can not found access info");
+               ERR("_cal_access_control_find_permission_info() Fail");
                return false;
        }
 
-       if (NULL == find->write_list) {
+       if (NULL == info->write_list) {
                cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
                ERR("there is no write access info");
                return false;
        }
 
-       while (1) {
-               if (find->write_list[i] == -1)
-                       break;
-               if (calendarbook_id == find->write_list[i]) {
+       int i = 0;
+       for (i = 0; i < info->write_list_count; i++) {
+               if (book_id == info->write_list[i]) {
                        cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
                        return true;
                }
-               i++;
        }
 
        cal_mutex_unlock(CAL_MUTEX_ACCESS_CONTROL);
+       ERR("thread(0x%x), No write permission of book_id(%d)", thread_id, book_id);
        return false;
 }
 
 static void _cal_access_control_disconnected_cb(pims_ipc_h ipc, void *user_data)
 {
        CAL_FN_CALL();
-       calendar_permission_info_s *info = NULL;
+       cal_permission_info_s *info = NULL;
 
        cal_mutex_lock(CAL_MUTEX_ACCESS_CONTROL);
-       info = (calendar_permission_info_s *)user_data;
+       info = (cal_permission_info_s *)user_data;
        if (info) {
                INFO("Thread(0x%x), info(%p)", info->thread_id, info);
                free(info->smack_label);
@@ -275,7 +289,7 @@ static void _cal_access_control_disconnected_cb(pims_ipc_h ipc, void *user_data)
        cal_service_internal_disconnect();
 }
 
-int cal_is_owner(int calendarbook_id)
+int cal_is_owner(int book_id)
 {
        int ret;
        sqlite3_stmt *stmt = NULL;
@@ -283,9 +297,8 @@ int cal_is_owner(int calendarbook_id)
        char *owner_label = NULL;
        char *saved_smack = NULL;
 
-       snprintf(query, sizeof(query),
-                       "SELECT owner_label FROM "CAL_TABLE_CALENDAR" "
-                       "WHERE id = %d", calendarbook_id);
+       snprintf(query, sizeof(query), "SELECT owner_label FROM %s WHERE id = %d",
+                       CAL_TABLE_CALENDAR, book_id);
        ret = cal_db_util_query_prepare(query, &stmt);
        if (CALENDAR_ERROR_NONE != ret) {
                ERR("cal_db_util_query_prepare() Fail(%d)", ret);

diff --git a/server/cal_access_control.h b/server/cal_access_control.h
index a656f3d..4ba8583 100644 (file)
--- a/server/cal_access_control.h
+++ b/server/cal_access_control.h
@@ -30,7 +30,7 @@ void cal_access_control_set_client_info(pims_ipc_h ipc, const char* smack_label)
 void cal_access_control_unset_client_info(void);
 char* cal_access_control_get_label(void);
 void cal_access_control_reset(void);  // reset read_list, write_list..
-bool cal_access_control_have_write_permission(int calendarbook_id);
-int cal_is_owner(int calendarbook_id);
+bool cal_access_control_have_write_permission(int book_id);
+int cal_is_owner(int book_id);
 
 #endif /*  __CALENDAR_SVC_ACCESS_CONTROL_H__ */

diff --git a/server/cal_server.c b/server/cal_server.c
index 6d9d926..67d3bef 100644 (file)
--- a/server/cal_server.c
+++ b/server/cal_server.c
@@ -94,65 +94,6 @@ static bool _cal_server_account_delete_cb(const char* event_type, int account_id
        return true;
 }
 
-#ifdef CAL_MEMORY_TEST
-static gboolean  _cal_server_ipc_destroy_idle(void* user_data)
-{
-       ERR();
-       g_main_loop_quit(main_loop);
-}
-
-void cal_server_ipc_destroy(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
-{
-       ERR();
-       int ret = CALENDAR_ERROR_NONE;
-
-       /* kill daemon destroy */
-       g_timeout_add_seconds(1, &_cal_server_ipc_destroy_idle, NULL);
-
-       if (outdata)
-       {
-               *outdata = pims_ipc_data_create(0);
-               if (!*outdata) {
-                       ERR("pims_ipc_data_create Fail");
-                       goto DATA_FREE;
-               }
-               if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0) {
-                       pims_ipc_data_destroy(*outdata);
-                       *outdata = NULL;
-                       ERR("pims_ipc_data_put Fail");
-                       goto DATA_FREE;
-               }
-
-       }
-       else {
-               ERR("outdata is NULL");
-       }
-       goto DATA_FREE;
-
-ERROR_RETURN:
-       if (outdata)
-       {
-               *outdata = pims_ipc_data_create(0);
-               if (!*outdata) {
-                       ERR("pims_ipc_data_create Fail");
-                       goto DATA_FREE;
-               }
-               if (pims_ipc_data_put(*outdata,(void*)&ret,sizeof(int)) != 0) {
-                       pims_ipc_data_destroy(*outdata);
-                       *outdata = NULL;
-                       ERR("pims_ipc_data_put Fail");
-                       goto DATA_FREE;
-               }
-       }
-       else {
-               ERR("outdata is NULL");
-       }
-DATA_FREE:
-
-       return;
-}
-#endif /* CAL_MEMORY_TEST */
-
 static void _cal_server_init(void)
 {
        int ret;
@@ -216,71 +157,25 @@ static void _cal_server_init(void)
        cal_server_calendar_delete_start();
 }
 
-static void _cal_server_fini(void)
+static void _cal_server_deinit(void)
 {
        cal_disconnect();
-//     contacts_disconnect();
-}
 
-static int _server_init_ipc(void)
-{
-       g_type_init();
+       if (cal_account_h) {
+               account_unsubscribe_notification(cal_account_h);
+               cal_account_h = NULL;
+       }
 
-       char sock_file[CAL_STR_MIDDLE_LEN] = {0};
-       snprintf(sock_file, sizeof(sock_file), CAL_SOCK_PATH"/.%s", getuid(), CAL_IPC_SERVICE);
-       pims_ipc_svc_init(sock_file,CAL_SECURITY_FILE_GROUP, 0777);
-
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_CONNECT, cal_server_ipc_connect, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DISCONNECT, cal_server_ipc_disconnect, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_CHECK_PERMISSION, cal_server_ipc_check_permission, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_RECORD, cal_server_ipc_db_insert_record, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORD, cal_server_ipc_db_get_record, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORD, cal_server_ipc_db_update_record, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORD, cal_server_ipc_db_delete_record, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_ALL_RECORDS, cal_server_ipc_db_get_all_records, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORDS_WITH_QUERY, cal_server_ipc_db_get_records_with_query, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CLEAN_AFTER_SYNC, cal_server_ipc_db_clean_after_sync, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT, cal_server_ipc_db_get_count, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT_WITH_QUERY, cal_server_ipc_db_get_count_with_query, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_RECORDS, cal_server_ipc_db_insert_records, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORDS, cal_server_ipc_db_update_records, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORDS, cal_server_ipc_db_delete_records, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CHANGES_BY_VERSION, cal_server_ipc_db_get_changes_by_version, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_CURRENT_VERSION, cal_server_ipc_db_get_current_version, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_VCALENDARS, cal_server_ipc_db_insert_vcalendars, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_VCALENDARS, cal_server_ipc_db_replace_vcalendars, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORD, cal_server_ipc_db_replace_record, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORDS, cal_server_ipc_db_replace_records, NULL) != 0, -1);
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CHANGES_EXCEPTION, cal_server_ipc_db_changes_exception, NULL) != 0, -1);
-#ifdef CAL_MEMORY_TEST
-       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DESTROY, cal_server_ipc_destroy, NULL) != 0, -1);
-#endif /* CAL_MEMORY_TEST */
-
-       /* for subscribe */
-       snprintf(sock_file, sizeof(sock_file), CAL_SOCK_PATH"/.%s_for_subscribe", getuid(), CAL_IPC_SERVICE);
-       pims_ipc_svc_init_for_publish(sock_file, CAL_SECURITY_FILE_GROUP, CAL_SECURITY_DEFAULT_PERMISSION);
-
-       return CALENDAR_ERROR_NONE;
+       cal_access_control_unset_client_info();
 }
 
-static int _server_main(void)
+static int _cal_server_main(void)
 {
        main_loop = g_main_loop_new(NULL, FALSE);
-       pims_ipc_svc_run_main_loop(main_loop);
-       g_main_loop_unref(main_loop);
-
-       cal_time_u_cleanup();
-       cal_inotify_finalize();
+       cal_server_ipc_run(main_loop);
 
-       if (cal_account_h) {
-               account_unsubscribe_notification(cal_account_h);
-               cal_account_h = NULL;
-       }
-
-       pims_ipc_svc_deinit_for_publish();
-       pims_ipc_svc_deinit();
+       g_main_loop_unref(main_loop);
 
-       cal_access_control_unset_client_info();
        return 0;
 }
 
@@ -342,12 +237,17 @@ int main(int argc, char *argv[])
        cal_server_alarm_init();
        cal_server_update();
        _cal_server_init();
+       cal_server_ipc_init();
+
+       _cal_server_main();
+
+       cal_time_u_cleanup();
 
-       _server_init_ipc();
-       _server_main();
+       cal_server_ipc_deinit();
+       _cal_server_deinit();
+       cal_server_alarm_deinit();
+       cal_inotify_deinit();
 
-       _cal_server_fini();
-       cal_server_alarm_fini();
        return 0;
 }
 

diff --git a/server/cal_server_alarm.c b/server/cal_server_alarm.c
index 452a134..d40cc91 100644 (file)
--- a/server/cal_server_alarm.c
+++ b/server/cal_server_alarm.c
@@ -963,7 +963,7 @@ void cal_server_alarm_register(void)
        cal_server_alarm_register_next_alarm(time(NULL));
 }
 
-void cal_server_alarm_fini(void)
+void cal_server_alarm_deinit(void)
 {
        alarmmgr_fini();
 }

diff --git a/server/cal_server_alarm.h b/server/cal_server_alarm.h
index 0dc9d32..37f2f08 100644 (file)
--- a/server/cal_server_alarm.h
+++ b/server/cal_server_alarm.h
@@ -21,7 +21,7 @@
 #define __CAL_SERVER_ALARM_H__
 
 void cal_server_alarm_init(void);
-void cal_server_alarm_fini(void);
+void cal_server_alarm_deinit(void);
 
 void cal_server_alarm_register(void);
 void cal_server_alarm_alert(time_t tt_alert);

diff --git a/server/cal_server_ipc.c b/server/cal_server_ipc.c
index d33566f..e853af7 100644 (file)
--- a/server/cal_server_ipc.c
+++ b/server/cal_server_ipc.c
@@ -21,11 +21,13 @@
 #include <malloc.h>
 #include <glib.h>
 #include <pims-ipc-data.h>
+#include <pims-ipc-svc.h>
 
 #include "calendar.h"
 #include "cal_typedef.h"
 #include "cal_internal.h"
 #include "cal_db_util.h"
+#include "cal_ipc.h"
 #include "cal_ipc_marshal.h"
 #include "cal_server_ipc.h"
 #include "cal_access_control.h"
@@ -116,11 +118,20 @@ void cal_server_ipc_check_permission(pims_ipc_h ipc, pims_ipc_data_h indata, pim
                return;
        }
 
+       calendar_h handle = NULL;
+       ret = cal_ipc_unmarshal_handle(indata, &handle);
+       if (CALENDAR_ERROR_NONE != ret) {
+               ERR("cal_ipc_unmarshal_handle() Fail(%d)", ret);
+               _cal_server_ipc_return(outdata, ret);
+               return;
+       }
+
        int permission = 0;
        ret = cal_ipc_unmarshal_int(indata, &permission);
        if (CALENDAR_ERROR_NONE != ret) {
                ERR("cal_ipc_unmarshal_int() Fail(%d)", ret);
                _cal_server_ipc_return(outdata, ret);
+               cal_handle_destroy(handle);
                return;
        }
 
@@ -134,6 +145,8 @@ void cal_server_ipc_check_permission(pims_ipc_h ipc, pims_ipc_data_h indata, pim
                ret = CALENDAR_ERROR_OUT_OF_MEMORY;
                _cal_server_ipc_return(outdata, ret);
        }
+
+       cal_handle_destroy(handle);
 }
 
 void cal_server_ipc_db_insert_record(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
@@ -1508,3 +1521,105 @@ void cal_server_ipc_db_changes_exception(pims_ipc_h ipc, pims_ipc_data_h indata,
        cal_handle_destroy(handle);
        cal_ondemand_start();
 }
+
+#ifdef CAL_MEMORY_TEST
+static gboolean  _cal_server_ipc_destroy_idle(void* user_data)
+{
+       g_main_loop_quit(main_loop);
+}
+void cal_server_ipc_destroy(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata)
+{
+       int ret = CALENDAR_ERROR_NONE;
+
+       /* kill daemon destroy */
+       g_timeout_add_seconds(1, &_cal_server_ipc_destroy_idle, NULL);
+
+       if (outdata) {
+               *outdata = pims_ipc_data_create(0);
+               if (!*outdata) {
+                       ERR("pims_ipc_data_create() Fail");
+                       goto DATA_FREE;
+               }
+               if (pims_ipc_data_put(*outdata, (void*)&ret, sizeof(int)) != 0) {
+                       pims_ipc_data_destroy(*outdata);
+                       *outdata = NULL;
+                       ERR("pims_ipc_data_put() Fail");
+                       goto DATA_FREE;
+               }
+
+       }
+       else {
+               ERR("outdata is NULL");
+       }
+       goto DATA_FREE;
+
+ERROR_RETURN:
+       if (outdata) {
+               *outdata = pims_ipc_data_create(0);
+               if (!*outdata) {
+                       ERR("pims_ipc_data_create() Fail");
+                       goto DATA_FREE;
+               }
+               if (pims_ipc_data_put(*outdata, (void*)&ret, sizeof(int)) != 0) {
+                       pims_ipc_data_destroy(*outdata);
+                       *outdata = NULL;
+                       ERR("pims_ipc_data_put() Fail");
+                       goto DATA_FREE;
+               }
+       }
+       else {
+               ERR("outdata is NULL");
+       }
+DATA_FREE:
+
+       return;
+}
+#endif /* CAL_MEMORY_TEST */
+
+int cal_server_ipc_init(void)
+{
+       g_type_init();
+
+       pims_ipc_svc_init(CAL_IPC_SOCKET_PATH, CAL_SECURITY_FILE_GROUP, 0777);
+
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_CONNECT, cal_server_ipc_connect, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DISCONNECT, cal_server_ipc_disconnect, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_CHECK_PERMISSION, cal_server_ipc_check_permission, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_RECORD, cal_server_ipc_db_insert_record, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORD, cal_server_ipc_db_get_record, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORD, cal_server_ipc_db_update_record, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORD, cal_server_ipc_db_delete_record, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_ALL_RECORDS, cal_server_ipc_db_get_all_records, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_RECORDS_WITH_QUERY, cal_server_ipc_db_get_records_with_query, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CLEAN_AFTER_SYNC, cal_server_ipc_db_clean_after_sync, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT, cal_server_ipc_db_get_count, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_COUNT_WITH_QUERY, cal_server_ipc_db_get_count_with_query, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_RECORDS, cal_server_ipc_db_insert_records, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_UPDATE_RECORDS, cal_server_ipc_db_update_records, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_DELETE_RECORDS, cal_server_ipc_db_delete_records, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CHANGES_BY_VERSION, cal_server_ipc_db_get_changes_by_version, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_GET_CURRENT_VERSION, cal_server_ipc_db_get_current_version, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_INSERT_VCALENDARS, cal_server_ipc_db_insert_vcalendars, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_VCALENDARS, cal_server_ipc_db_replace_vcalendars, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORD, cal_server_ipc_db_replace_record, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_REPLACE_RECORDS, cal_server_ipc_db_replace_records, NULL) != 0, -1);
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DB_CHANGES_EXCEPTION, cal_server_ipc_db_changes_exception, NULL) != 0, -1);
+#ifdef CAL_MEMORY_TEST
+       RETV_IF(pims_ipc_svc_register(CAL_IPC_MODULE, CAL_IPC_SERVER_DESTROY, cal_server_ipc_destroy, NULL) != 0, -1);
+#endif /* CAL_MEMORY_TEST */
+
+       /* for subscribe */
+       pims_ipc_svc_init_for_publish(CAL_IPC_SOCKET_PATH_FOR_SUBSCRIPTION, CAL_SECURITY_FILE_GROUP, CAL_SECURITY_DEFAULT_PERMISSION);
+       return CALENDAR_ERROR_NONE;
+}
+
+void cal_server_ipc_deinit(void)
+{
+       pims_ipc_svc_deinit_for_publish();
+       pims_ipc_svc_deinit();
+}
+
+void cal_server_ipc_run(GMainLoop *loop)
+{
+       pims_ipc_svc_run_main_loop(loop);
+}

diff --git a/server/cal_server_ipc.h b/server/cal_server_ipc.h
index 4a1af14..68d010d 100644 (file)
--- a/server/cal_server_ipc.h
+++ b/server/cal_server_ipc.h
@@ -47,4 +47,8 @@ void cal_server_ipc_db_replace_record(pims_ipc_h ipc, pims_ipc_data_h indata, pi
 void cal_server_ipc_db_replace_records(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata);
 void cal_server_ipc_db_changes_exception(pims_ipc_h ipc, pims_ipc_data_h indata, pims_ipc_data_h *outdata, void *userdata);
 
+int cal_server_ipc_init(void);
+void cal_server_ipc_deinit(void);
+void cal_server_ipc_run(GMainLoop *loop);
+
 #endif /* __CAL_SERVER_IPC_H__ */

diff --git a/server/cal_server_service.c b/server/cal_server_service.c
index 778dc74..452edef 100644 (file)
--- a/server/cal_server_service.c
+++ b/server/cal_server_service.c
@@ -38,9 +38,9 @@ int cal_connect(void)
        if (0 == cal_total_connection) {
                g_type_init();  // added for alarmmgr
                cal_view_initialize();
-               ret = cal_inotify_initialize();
+               ret = cal_inotify_init();
                if (CALENDAR_ERROR_NONE != ret) {
-                       ERR("cal_inotify_initialize() Fail(%d)", ret);
+                       ERR("cal_inotify_init() Fail(%d)", ret);
                        cal_mutex_unlock(CAL_MUTEX_CONNECTION);
                        return ret;
                }
@@ -80,7 +80,7 @@ int cal_disconnect(void)
        cal_thread_connection--;
 
        if (1 == cal_total_connection) {
-               cal_inotify_finalize();
+               cal_inotify_deinit();
                cal_view_finalize();
        }
        else if (1 < cal_total_connection) {