Change privilege check function

diff --git a/src/clientlib/CMakeLists.txt b/src/clientlib/CMakeLists.txt
index 4daa3d3..0488ff3 100644 (file)
--- a/src/clientlib/CMakeLists.txt
+++ b/src/clientlib/CMakeLists.txt
@@ -55,7 +55,7 @@ ADD_DEFINITIONS("-DUSE_IPC_EPOLL -DUSE_EPOLL_TIMEOUT")
 ADD_DEFINITIONS("-DLLCP_MODE")
 ADD_DEFINITIONS("-DNFC_APP_SUPPORTED")
 ADD_DEFINITIONS("-DSAVE_TARGET_INFO_IN_CC")
-ADD_DEFINITIONS("-DSECURITY_SERVER")
+#ADD_DEFINITIONS("-DSECURITY_SERVER")
 #ADD_DEFINITIONS("-DG_MAIN_LOOP")
 #ADD_DEFINITIONS("-DUSE_ECORE_MAIN_LOOP")
 ADD_DEFINITIONS("-DUSE_GLIB_MAIN_LOOP")

diff --git a/src/commonlib/CMakeLists.txt b/src/commonlib/CMakeLists.txt
index 65e4b30..d77aab2 100644 (file)
--- a/src/commonlib/CMakeLists.txt
+++ b/src/commonlib/CMakeLists.txt
@@ -44,7 +44,7 @@ ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
 #ADD_DEFINITIONS("-DSLP_DEBUG")
 ADD_DEFINITIONS("-DNFC_DEBUG_USE_DLOG -D_GNU_SOURCE")
 #ADD_DEFINITIONS("-DUSE_UNIX_DOMAIN")
-ADD_DEFINITIONS("-DSECURITY_SERVER")
+#ADD_DEFINITIONS("-DSECURITY_SERVER")
 
 ADD_LIBRARY(${NFC_COMMON_LIB} SHARED ${COMMON_LIB_SRCS})
 SET_TARGET_PROPERTIES(${NFC_COMMON_LIB} PROPERTIES SOVERSION ${VERSION_MAJOR})

diff --git a/src/manager/CMakeLists.txt b/src/manager/CMakeLists.txt
index b1390b1..0572308 100644 (file)
--- a/src/manager/CMakeLists.txt
+++ b/src/manager/CMakeLists.txt
@@ -53,7 +53,7 @@ ADD_DEFINITIONS("-DLLCP_MODE")
 ADD_DEFINITIONS("-DNFC_APP_SUPPORTED")
 ADD_DEFINITIONS("-DBROADCAST_MESSAGE")
 ADD_DEFINITIONS("-DSAVE_TARGET_INFO_IN_CC")
-ADD_DEFINITIONS("-DSECURITY_SERVER")
+#ADD_DEFINITIONS("-DSECURITY_SERVER")
 #ADD_DEFINITIONS("-DG_MAIN_LOOP")
 #ADD_DEFINITIONS("-DUSE_ECORE_MAIN_LOOP")
 ADD_DEFINITIONS("-DUSE_GLIB_MAIN_LOOP")

diff --git a/src/manager/net_nfc_server_dispatcher.c b/src/manager/net_nfc_server_dispatcher.c
index 924e02f..ede8bd6 100644 (file)
--- a/src/manager/net_nfc_server_dispatcher.c
+++ b/src/manager/net_nfc_server_dispatcher.c
@@ -21,6 +21,7 @@
 #include <glib.h>
 
 #include "vconf.h"
+#include "security-server.h"
 
 #include "net_nfc_server_dispatcher_private.h"
 #include "net_nfc_typedef_private.h"
@@ -45,6 +46,9 @@ static pthread_mutex_t g_dispatcher_queue_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_t g_dispatcher_thread;
 
 static void *_net_nfc_dispatcher_thread_func(void *data);
+
+static bool _net_nfc_check_dispatcher_privilege(net_nfc_request_msg_t *msg);
+
 static net_nfc_request_msg_t *_net_nfc_dispatcher_queue_pop();
 
 static net_nfc_request_msg_t *_net_nfc_dispatcher_queue_pop()
@@ -187,6 +191,14 @@ static void *_net_nfc_dispatcher_thread_func(void *data)
 
 //             DEBUG_SERVER_MSG("net_nfc_controller get command = [%d]", req_msg->request_type);
 
+#if 1
+               if (!_net_nfc_check_dispatcher_privilege(req_msg))
+               {
+//                     _net_nfc_util_free_mem(req_msg);
+//                     continue;
+               }
+#endif
+
                switch (req_msg->request_type)
                {
                case NET_NFC_MESSAGE_SERVICE_CLEANER :
@@ -900,3 +912,216 @@ static void *_net_nfc_dispatcher_thread_func(void *data)
 
        return (void *)NULL;
 }
+
+/* return true to authentication success; false to fail to authenticate */
+bool _net_nfc_check_dispatcher_privilege(net_nfc_request_msg_t *request_msg)
+{
+       int client_fd_request = request_msg->client_fd;
+       int ret_value;
+       
+       DEBUG_SERVER_MSG("enter check privilege function");
+       switch(request_msg->request_type)
+       {
+#if 0
+               case NET_NFC_MESSAGE_SERVICE_ACTIVATE:
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_SERVICE_ACTIVATE...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::admin","w");
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+
+                               if (net_nfc_server_check_client_is_running(client_fd_request)){
+                                       net_nfc_response_test_t resp = { 0, };
+                                       resp.length = sizeof(net_nfc_response_test_t);
+                                       resp.flags = request_msg->flags;
+                                       resp.result = NET_NFC_SECURITY_FAIL;
+                                       resp.trans_param = (void *)request_msg->user_param;
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type,(void *)&resp, sizeof(net_nfc_response_test_t), NULL);
+
+                               }
+                               return false;
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+#endif
+               case NET_NFC_MESSAGE_TRANSCEIVE:
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_TRANSCEIVE...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::tag","w");
+
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+#if 0
+
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_transceive_t *detail = (net_nfc_request_transceive_t *)request_msg;
+                                       net_nfc_response_transceive_t resp = { 0, };
+
+                                       resp.length = sizeof(net_nfc_response_transceive_t);
+                                       resp.flags = detail->flags;
+                                       resp.trans_param = detail->trans_param;
+                                       resp.result = NET_NFC_SECURITY_FAIL;
+
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type, (void *)&resp, sizeof(net_nfc_response_transceive_t), NULL);
+
+                               }
+                               return false;
+#endif
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+               case NET_NFC_MESSAGE_READ_NDEF:
+
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_READ_NDEF...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::tag","w");
+
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+#if 0
+
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_read_ndef_t *detail = (net_nfc_request_read_ndef_t *)request_msg;
+                                       net_nfc_response_write_ndef_t resp = { 0, };
+
+                                       resp.length = sizeof(net_nfc_response_read_ndef_t);
+                                       resp.flags = detail->flags;
+                                       resp.trans_param = detail->trans_param;
+                                       resp.result = NET_NFC_SECURITY_FAIL;
+
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type, (void *)&resp, sizeof(net_nfc_response_write_ndef_t), NULL);
+
+                               }
+                               return false;
+#endif
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+               case NET_NFC_MESSAGE_WRITE_NDEF:
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_WRITE_NDEF...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::tag","w");
+
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+#if 0
+
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_write_ndef_t *detail = (net_nfc_request_write_ndef_t *)request_msg;
+                                       net_nfc_response_write_ndef_t resp = { 0, };
+
+                                       resp.length = sizeof(net_nfc_response_write_ndef_t);
+                                       resp.flags = detail->flags;
+                                       resp.trans_param = detail->trans_param;
+                                       resp.result = NET_NFC_SECURITY_FAIL;
+
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type, (void *)&resp, sizeof(net_nfc_response_write_ndef_t), NULL);
+
+                               }
+                               return false;
+#endif
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+               case NET_NFC_MESSAGE_P2P_SEND:
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_P2P_SEND...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::p2p","w");
+
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+#if 0
+
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_p2p_send_t *exchanger = (net_nfc_request_p2p_send_t *)request_msg;
+
+                                       net_nfc_response_p2p_send_t resp_msg = { 0, };
+
+                                       resp_msg.length = sizeof(resp_msg);
+                                       resp_msg.response_type = NET_NFC_MESSAGE_P2P_SEND;
+                                       resp_msg.handle = exchanger->handle;
+                                       resp_msg.result = NET_NFC_SECURITY_FAIL;
+                                       resp_msg.trans_param = (void *)exchanger->user_param;
+
+                                       net_nfc_send_response_msg(request_msg->client_fd,NET_NFC_MESSAGE_P2P_SEND, &resp_msg,sizeof(resp_msg), NULL);
+
+                               }
+                               return false;
+#endif
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+#if 0
+               case NET_NFC_MESSAGE_SNEP_START_SERVER :
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_SNEP_START_SERVER...");
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::p2p","rw");
+
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_listen_socket_t *msg = (net_nfc_request_listen_socket_t *)request_msg;
+                                       net_nfc_response_receive_socket_t resp = { 0 };
+                                       resp.length = sizeof(resp);
+                                       resp.response_type = NET_NFC_MESSAGE_SNEP_START_SERVER;
+                                       resp.user_param = msg->user_param;
+                                       resp.result = NET_NFC_SECURITY_FAIL;
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type, (void *)&resp, sizeof(net_nfc_response_receive_socket_t), NULL);
+                               }
+                               return false;
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+#endif
+#if 0
+               case NET_NFC_MESSAGE_SNEP_START_CLIENT :
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_SNEP_START_CLIENT...");
+
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::p2p","rw");
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking failed, and then send response to client");
+                               if (net_nfc_server_check_client_is_running(client_fd_request))
+                               {
+                                       net_nfc_request_snep_client_t *msg =(net_nfc_request_snep_client_t *)request_msg;
+                                       net_nfc_response_receive_socket_t resp_msg = { 0, };
+                                       resp_msg.length = sizeof(resp_msg);
+                                       resp_msg.response_type = NET_NFC_MESSAGE_SNEP_START_CLIENT;
+                                       resp_msg.user_param = msg->user_param;
+                                       resp_msg.result = NET_NFC_SECURITY_FAIL;
+                                       net_nfc_send_response_msg(request_msg->client_fd, request_msg->request_type, (void *)&resp_msg, sizeof(net_nfc_response_receive_socket_t), NULL);
+                               }
+                               return false;
+                       }
+                       DEBUG_SERVER_MSG("checking success");
+                       break;
+
+#endif
+#if 0
+               case NET_NFC_MESSAGE_SNEP_STOP_SERVICE :
+                       ret_value = security_server_check_privilege_by_sockfd(client_fd_request,"nfc-manager::p2p","rw");
+                       if (ret_value == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               return false;
+
+                       }
+                       break;
+
+#endif
+               default :
+                       return true;
+       }
+
+       return true;
+}

diff --git a/src/manager/net_nfc_server_ipc.c b/src/manager/net_nfc_server_ipc.c
index 5832598..d7920e9 100755 (executable)
--- a/src/manager/net_nfc_server_ipc.c
+++ b/src/manager/net_nfc_server_ipc.c
@@ -29,9 +29,7 @@
 #include <errno.h>
 
 #include "vconf.h"
-#ifdef SECURITY_SERVER
 #include "security-server.h"
-#endif
 
 #include "net_nfc_typedef_private.h"
 #include "net_nfc_debug_private.h"
@@ -599,6 +597,17 @@ bool net_nfc_server_read_client_request(int client_sock_fd, net_nfc_error_e *res
 
        case NET_NFC_MESSAGE_SERVICE_SET_LAUNCH_STATE :
                {
+                       DEBUG_SERVER_MSG("checking NET_NFC_MESSAGE_SERVICE_SET_LAUNCH_STATE...");
+#if 1
+                       int ret = security_server_check_privilege_by_sockfd(req_msg->client_fd,"nfc-manager::common","w");
+
+                       if (ret == SECURITY_SERVER_API_ERROR_ACCESS_DENIED)
+                       {
+                               DEBUG_SERVER_MSG("checking faile and return...");
+//                             return false;
+                       }
+#endif
+
                        net_nfc_request_set_launch_state_t *detail = (net_nfc_request_set_launch_state_t *)req_msg;
 
                        net_nfc_server_set_launch_state(client_sock_fd, detail->set_launch_popup);