#include <security-manager.h>
-IMPLEMENT_SAFE_SINGLETON(SecurityServer::Log::LogSystem);
+IMPLEMENT_SAFE_SINGLETON(SecurityManager::Log::LogSystem);
namespace {
const int POLL_TIMEOUT = 2000;
void securityClientEnableLogSystem(void) {
- SecurityServer::Singleton<SecurityServer::Log::LogSystem>::Instance().SetTag("SECURITY_SERVER_CLIENT");
+ SecurityManager::Singleton<SecurityManager::Log::LogSystem>::Instance().SetTag("SECURITY_MANAGER_CLIENT");
}
int waitForSocket(int sock, int event, int timeout) {
} // namespace anonymous
-namespace SecurityServer {
+namespace SecurityManager {
int sendToServer(char const * const interface, const RawBuffer &send, MessageBuffer &recv) {
try {
return func();
} catch (MessageBuffer::Exception::Base &e) {
- LogError("SecurityServer::MessageBuffer::Exception " << e.DumpToString());
+ LogError("SecurityManager::MessageBuffer::Exception " << e.DumpToString());
} catch (std::exception &e) {
LogError("STD exception " << e.what());
} catch (...) {
return SECURITY_MANAGER_API_ERROR_UNKNOWN;
}
-} // namespace SecurityServer
+} // namespace SecurityMANAGER
static void init_lib(void) __attribute__ ((constructor));
static void init_lib(void)
struct msghdr;
}
-namespace SecurityServer {
+namespace SecurityManager {
typedef std::vector<unsigned char> RawBuffer;
*/
int try_catch(const std::function<int()>& func);
-} // namespace SecuritySever
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_CLIENT_
SECURITY_MANAGER_API
int security_manager_app_install(const app_inst_req *p_req)
{
- using namespace SecurityServer;
+ using namespace SecurityManager;
MessageBuffer send, recv;
LogDebug("app_install() called");
SECURITY_MANAGER_API
int security_manager_app_uninstall(const app_inst_req *p_req)
{
- using namespace SecurityServer;
+ using namespace SecurityManager;
MessageBuffer send, recv;
LogDebug("app_uninstall() called");
#include <generic-socket-manager.h>
#include <message-buffer.h>
-namespace SecurityServer
+namespace SecurityManager
{
struct ConnectionInfo {
InterfaceID interfaceID;
};
typedef std::map<int, ConnectionInfo> ConnectionInfoMap;
-} //namespace SecurityServer
+} //namespace SecurityManager
#endif //_CONNECTION_INFO_H_
#include <dpl/log/log.h>
-namespace SecurityServer {
+namespace SecurityManager {
void MessageBuffer::Push(const RawBuffer &data) {
m_buffer.AppendCopy(&data[0], data.size());
m_buffer.AppendCopy(bytes, num);
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <dpl/exception.h>
#include <dpl/serialization.h>
-namespace SecurityServer {
+namespace SecurityManager {
typedef std::vector<unsigned char> RawBuffer;
-class MessageBuffer : public SecurityServer::IStream {
+class MessageBuffer : public SecurityManager::IStream {
public:
class Exception
{
public:
- DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(SecurityManager::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OutOfData)
};
}
size_t m_bytesLeft;
- SecurityServer::BinaryQueue m_buffer;
+ SecurityManager::BinaryQueue m_buffer;
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_SOCKET_BUFFER_
#include <cstddef>
-namespace SecurityServer {
+namespace SecurityManager {
#define SOCKET_PATH_PREFIX "/run/"
#define SOCKET_PATH_PREFIX_SECURITY_MANAGER SOCKET_PATH_PREFIX "security-manager/"
char const * const SERVICE_SOCKET_INSTALLER =
SOCKET_PATH_PREFIX_SECURITY_MANAGER "security-manager-installer.socket";
-} // namespace SecurityServer
+} // namespace SecurityManager
std::vector<std::pair<std::string, int>> appPaths;
};
-namespace SecurityServer {
+namespace SecurityManager {
extern char const * const SERVICE_SOCKET_INSTALLER;
APP_UNINSTALL
};
-} // namespace SecuritySever
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_PROTOCOLS_
#include <dpl/log/log.h>
-namespace SecurityServer {
+namespace SecurityManager {
int smack_runtime_check(void)
{
#endif
}
-} // namespace SecurityServer
+} // namespace SecurityManager
/*
- * security-server
+ * security-manager
*
* Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
*
#ifndef _SMACK_CHECK_H_
#define _SMACK_CHECK_H_
-namespace SecurityServer {
+namespace SecurityManager {
/*
* A very simple runtime check for SMACK on the platform
*/
int smack_check(void);
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SMACK_CHECK_H_
#include <dpl/noreturn.h>
-namespace SecurityServer {
+namespace SecurityManager {
// Assertion handler procedure
// Do not call directly
// Always use Assert macro
const char *file,
int line,
const char *function);
-} // namespace SecurityServer
+} // namespace SecurityManager
-#define Assert(Condition) do { if (!(Condition)) { SecurityServer::AssertProc(#Condition, \
+#define Assert(Condition) do { if (!(Condition)) { SecurityManager::AssertProc(#Condition, \
__FILE__, \
__LINE__, \
__FUNCTION__); \
#include <memory>
#include <list>
-namespace SecurityServer {
+namespace SecurityManager {
/**
* Binary queue auto pointer
*/
class Exception
{
public:
- DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(SecurityManager::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OutOfData)
};
virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize);
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITY_SERVER_BINARY_QUEUE_H
#ifndef SECURITY_SERVER_COLORS_H
#define SECURITY_SERVER_COLORS_H
-namespace SecurityServer {
+namespace SecurityManager {
namespace Colors {
namespace Text {
extern const char* BOLD_GREEN_BEGIN;
extern const char* BOLD_WHITE_END;
} //namespace Html
} //namespace Colors
-} //namespace SecurityServer
+} //namespace SecurityManager
#endif /* SECURITY_SERVER_COLORS_H */
#include <cstdlib>
#include <sstream>
-namespace SecurityServer {
+namespace SecurityManager {
void LogUnhandledException(const std::string &str);
void LogUnhandledException(const std::string &str,
const char *filename,
const char *function);
}
-namespace SecurityServer {
+namespace SecurityManager {
class Exception
{
private:
return m_className;
}
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#define Try try
Class(const char *path, \
const char *function, \
int line, \
- const SecurityServer::Exception & reason, \
+ const SecurityManager::Exception & reason, \
const std::string & message = std::string()) : \
BaseClass(path, function, line, reason, message) \
{ \
#define UNHANDLED_EXCEPTION_HANDLER_BEGIN try
#define UNHANDLED_EXCEPTION_HANDLER_END \
- catch (const SecurityServer::Exception &exception) \
+ catch (const SecurityManager::Exception &exception) \
{ \
std::ostringstream msg; \
- msg << SecurityServer::Exception::KnownExceptionToString(exception); \
- SecurityServer::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
+ msg << SecurityManager::Exception::KnownExceptionToString(exception); \
+ SecurityManager::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
abort(); \
} \
catch (std::exception& e) \
std::ostringstream msg; \
msg << e.what(); \
msg << "\n"; \
- msg << SecurityServer::Exception::UnknownExceptionToString(); \
- SecurityServer::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
+ msg << SecurityManager::Exception::UnknownExceptionToString(); \
+ SecurityManager::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
abort(); \
} \
catch (...) \
{ \
std::ostringstream msg; \
- msg << SecurityServer::Exception::UnknownExceptionToString(); \
- SecurityServer::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
+ msg << SecurityManager::Exception::UnknownExceptionToString(); \
+ SecurityManager::LogUnhandledException(msg.str(), __FILE__, __LINE__, __FUNCTION__); \
abort(); \
}
-namespace SecurityServer {
+namespace SecurityManager {
namespace CommonException {
/**
* Internal exception definitions
#ifndef SECURITYSERVER_NONCOPYABLE_H
#define SECURITYSERVER_NONCOPYABLE_H
-namespace SecurityServer {
+namespace SecurityManager {
class Noncopyable
{
private:
Noncopyable();
virtual ~Noncopyable();
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITYSERVER_NONCOPYABLE_H
#include <map>
#include <memory>
-namespace SecurityServer {
+namespace SecurityManager {
// Abstract data stream buffer
class IStream
{
Deserialize(stream, *map);
}
}; // struct Deserialization
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SERIALIZATION_H
#ifndef SECURITYSERVER_SINGLETON_H
#define SECURITYSERVER_SINGLETON_H
-namespace SecurityServer {
+namespace SecurityManager {
template<typename Class>
class Singleton :
private Class
static Class &Instance();
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITYSERVER_SINGLETON_H
* singleton_safe_impl.h if possible.
*/
-namespace SecurityServer {
+namespace SecurityManager {
template<typename Class>
Singleton<Class>& Singleton<Class>::InternalInstance()
{
Singleton<Class>& instance = Singleton<Class>::InternalInstance();
return instance;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#define IMPLEMENT_SINGLETON(Type) \
- template SecurityServer::Singleton<Type>&SecurityServer::Singleton<Type>::InternalInstance(); \
- template Type & SecurityServer::Singleton<Type>::Instance(); \
+ template SecurityManager::Singleton<Type>&SecurityManager::Singleton<Type>::InternalInstance(); \
+ template Type & SecurityManager::Singleton<Type>::Instance(); \
#endif // SECURITYSERVER_SINGLETON_IMPL_H
#define SECURITYSERVER_SINGLETON_SAFE_IMPL_H
#define IMPLEMENT_SAFE_SINGLETON(Class) \
- namespace SecurityServer { \
+ namespace SecurityManager { \
template<> \
Singleton<Class>&Singleton<Class>::InternalInstance() \
{ \
\
template Singleton<Class>&Singleton<Class>::InternalInstance(); \
template Class & Singleton<Class>::Instance(); \
- } // namespace SecurityServer
+ } // namespace SecurityManager
#endif // SECURITYSERVER_SINGLETON_SAFE_IMPL_H
#include <dpl/exception.h>
#include <cstdlib>
-namespace SecurityServer {
+namespace SecurityManager {
void AssertProc(const char *condition,
const char *file,
int line,
{ \
std::ostringstream platformLog; \
platformLog << message; \
- SecurityServer::Log::LogSystemSingleton::Instance().Pedantic( \
+ SecurityManager::Log::LogSystemSingleton::Instance().Pedantic( \
platformLog.str().c_str(), \
__FILE__, __LINE__, __FUNCTION__); \
} \
// Fail with c-library abort
abort();
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <cstring>
#include <new>
-namespace SecurityServer {
+namespace SecurityManager {
BinaryQueue::BinaryQueue() :
m_size(0)
{}
AppendCopyFrom(buffer);
return bufferSize;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <stddef.h>
#include <dpl/colors.h>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Colors {
namespace Text {
const char* BOLD_GREEN_BEGIN = "\033[1;32m";
const char* BOLD_WHITE_END = "</b></font>";
} //namespace Html
} //namespace Colors
-} //namespace SecurityServer
+} //namespace SecurityManager
#include <dpl/log/log.h>
#include <cstdio>
-namespace SecurityServer {
+namespace SecurityManager {
Exception* Exception::m_lastException = NULL;
unsigned int Exception::m_exceptionCount = 0;
void (*Exception::m_terminateHandler)() = NULL;
printf("%s\n", msg.str().c_str());
// Logging to dlog
- SecurityServer::Log::LogSystemSingleton::Instance().Error(
+ SecurityManager::Log::LogSystemSingleton::Instance().Error(
str.c_str(), filename, line, function);
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <stddef.h>
#include <dpl/noncopyable.h>
-namespace SecurityServer {
+namespace SecurityManager {
Noncopyable::Noncopyable()
{}
Noncopyable::~Noncopyable()
{}
-} // namespace SecurityServer
+} // namespace SecurityManager
#ifndef SECURITYSERVER_ABSTRACT_LOG_PROVIDER_H
#define SECURITYSERVER_ABSTRACT_LOG_PROVIDER_H
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
class AbstractLogProvider
{
static const char *LocateSourceFileName(const char *filename);
};
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITYSERVER_ABSTRACT_LOG_PROVIDER_H
#include <memory>
#include <functional>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
class AuditSmackLog :
};
} // namespace Log
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _AUDIT_SMACK_LOG_
#include <memory>
#include <string>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
class DLOGLogProvider :
public AbstractLogProvider
};
} // namespace Log
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITYSERVER_DLOG_LOG_PROVIDER_H
#include <sstream>
#include <list>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
/**
* SecurityServer log system
*/
typedef Singleton<LogSystem> LogSystemSingleton;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
//
// Log support
/* avoid warnings about unused variables */
#define DPL_MACRO_DUMMY_LOGGING(message, function) \
do { \
- SecurityServer::Log::NullStream ns; \
+ SecurityManager::Log::NullStream ns; \
ns << message; \
} while (0)
#define DPL_MACRO_FOR_LOGGING(message, function) \
do \
{ \
- if (SecurityServer::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) \
+ if (SecurityManager::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) \
{ \
std::ostringstream platformLog; \
platformLog << message; \
- SecurityServer::Log::LogSystemSingleton::Instance().function( \
+ SecurityManager::Log::LogSystemSingleton::Instance().function( \
platformLog.str().c_str(), \
__FILE__, __LINE__, __FUNCTION__); \
} \
#include <dpl/log/abstract_log_provider.h>
#include <string>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
class OldStyleLogProvider :
public AbstractLogProvider
const char *function);
};
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // SECURITYSERVER_OLD_STYLE_LOG_PROVIDER_H
#define UNUSED __attribute__((unused))
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
void AbstractLogProvider::SetTag(const char *tag UNUSED) {}
} // namespace anonymous
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
AuditSmackLog::AuditSmackLog()
}
} // namespace Log
-} // namespace SecurityServer
+} // namespace SecurityManager
#define UNUSED __attribute__((unused))
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
std::string DLOGLogProvider::FormatMessage(const char *message,
const char *filename,
}
} // nemespace Log
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <dpl/log/old_style_log_provider.h>
#include <dpl/log/audit-smack-log.h>
-IMPLEMENT_SINGLETON(SecurityServer::Log::LogSystem)
+IMPLEMENT_SINGLETON(SecurityManager::Log::LogSystem)
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
namespace // anonymous
{
}
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <unistd.h>
#include <dlog.h>
-namespace SecurityServer {
+namespace SecurityManager {
namespace Log {
namespace // anonymous
{
-using namespace SecurityServer::Colors::Text;
+using namespace SecurityManager::Colors::Text;
const char *DEBUG_BEGIN = GREEN_BEGIN;
const char *DEBUG_END = GREEN_END;
const char *INFO_BEGIN = CYAN_BEGIN;
}
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#ifndef _SECURITY_SERVER_GENERIC_EVENT_
#define _SECURITY_SERVER_GENERIC_EVENT_
-namespace SecurityServer {
+namespace SecurityManager {
struct GenericEvent {
virtual ~GenericEvent(){}
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_GENERIC_EVENT_
#include <generic-socket-manager.h>
-namespace SecurityServer {
+namespace SecurityManager {
class SendMsgData::Internal {
public:
return m_flags;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
struct msghdr;
} // extern "C"
-namespace SecurityServer {
+namespace SecurityManager {
typedef int InterfaceID;
virtual ~GenericSocketManager(){}
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_GENERIC_SERVICE_MANAGER_
const size_t SIZE_T_MAX = std::numeric_limits<size_t>::max();
} // namespace anonymous
-namespace SecurityServer {
+namespace SecurityManager {
int util_smack_label_is_valid(const char *smack_label)
{
return exe;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <sys/types.h>
-namespace SecurityServer {
+namespace SecurityManager {
int util_smack_label_is_valid(const char *smack_label);
char *read_exe_path_from_proc(pid_t pid);
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif /*SECURITY_SERVER_UTIL_H*/
#include <installer.h>
-IMPLEMENT_SAFE_SINGLETON(SecurityServer::Log::LogSystem);
+IMPLEMENT_SAFE_SINGLETON(SecurityManager::Log::LogSystem);
#define REGISTER_SOCKET_SERVICE(manager, service) \
registerSocketService<service>(manager, #service)
template<typename T>
-void registerSocketService(SecurityServer::SocketManager &manager, const std::string& serviceName)
+void registerSocketService(SecurityManager::SocketManager &manager, const std::string& serviceName)
{
T *service = NULL;
try {
service->Create();
manager.RegisterSocketService(service);
service = NULL;
- } catch (const SecurityServer::Exception &exception) {
+ } catch (const SecurityManager::Exception &exception) {
LogError("Error in creating service " << serviceName <<
", details:\n" << exception.DumpToString());
} catch (const std::exception& e) {
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
- SecurityServer::Singleton<SecurityServer::Log::LogSystem>::Instance().SetTag("SECURITY_SERVER");
+ SecurityManager::Singleton<SecurityManager::Log::LogSystem>::Instance().SetTag("SECURITY_MANAGER");
// This provider may be used in security-server only.
// If we add it inside LogSystem constructor it also
// will be used by security-server-client library.
- SecurityServer::Log::AuditSmackLog *smackLog = new SecurityServer::Log::AuditSmackLog;
+ SecurityManager::Log::AuditSmackLog *smackLog = new SecurityManager::Log::AuditSmackLog;
if (smackLog->Fail())
delete smackLog;
else
- SecurityServer::Singleton<SecurityServer::Log::LogSystem>::Instance().AddProvider(smackLog);
+ SecurityManager::Singleton<SecurityManager::Log::LogSystem>::Instance().AddProvider(smackLog);
sigset_t mask;
sigemptyset(&mask);
}
LogInfo("Start!");
- SecurityServer::SocketManager manager;
+ SecurityManager::SocketManager manager;
- REGISTER_SOCKET_SERVICE(manager, SecurityServer::InstallerService);
+ REGISTER_SOCKET_SERVICE(manager, SecurityManager::InstallerService);
manager.MainLoop();
}
#define DEFINE_THREAD_EVENT(eventType) \
void Event(const eventType &event) { \
- SecurityServer::ServiceThread<ParentClassName>:: \
+ SecurityManager::ServiceThread<ParentClassName>:: \
Event(event, \
this, \
&ParentClassName::EventInternal##eventType); \
#define DECLARE_THREAD_EVENT(eventType, methodName) \
void Event(const eventType &event) { \
- SecurityServer::ServiceThread<ParentClassName>:: \
+ SecurityManager::ServiceThread<ParentClassName>:: \
Event(event, \
this, \
&ParentClassName::methodName); \
}
-namespace SecurityServer {
+namespace SecurityManager {
template <class Service>
class ServiceThread {
bool m_quit;
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_SERVICE_THREAD_
} // namespace anonymous
-namespace SecurityServer {
+namespace SecurityManager {
struct DummyService : public GenericSocketService {
ServiceDescriptionVector GetServiceDescription() {
FD_CLR(sock, &m_writeSet);
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <generic-socket-manager.h>
-namespace SecurityServer {
+namespace SecurityManager {
class SocketManager : public GenericSocketManager {
public:
class Exception {
public:
- DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(SecurityManager::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, InitFailed)
};
SocketManager();
std::priority_queue<Timeout> m_timeoutQueue;
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_SOCKET_MANAGER_
#include "smack-rules.h"
#include "security-manager-common.h"
-namespace SecurityServer {
+namespace SecurityManager {
namespace {
return true;
}
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <message-buffer.h>
#include <connection-info.h>
-namespace SecurityServer {
+namespace SecurityManager {
class InstallerException
{
public:
- DECLARE_EXCEPTION_TYPE(SecurityServer::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(SecurityManager::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, InvalidAction)
};
class InstallerService :
- public SecurityServer::GenericSocketService,
- public SecurityServer::ServiceThread<InstallerService>
+ public SecurityManager::GenericSocketService,
+ public SecurityManager::ServiceThread<InstallerService>
{
public:
InstallerService();
bool processAppUninstall(MessageBuffer &buffer, MessageBuffer &send);
};
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif // _SECURITY_SERVER_INSTALLER_
#include <smack-check.h>
-namespace SecurityServer {
+namespace SecurityManager {
int get_smack_label_from_process(pid_t pid, char *smack_label)
{
-} // namespace SecurityServer
+} // namespace SecurityManager
#include <sys/types.h>
-namespace SecurityServer {
+namespace SecurityManager {
int get_smack_label_from_process(pid_t pid, char *smack_label);
int smack_pid_have_access(pid_t pid, const char *object, const char *access_type);
-} // namespace SecurityServer
+} // namespace SecurityManager
#endif