src/common/include/protocols.h

   1 /*
   2  *  Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Rafal Krypa <r.krypa@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18 /*
  19  * @file        protocols.h
  20  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  21  * @version     1.0
  22  * @brief       This file contains list of all protocols suported by security-manager.
  23  */
  24
  25 #ifndef _SECURITY_MANAGER_PROTOCOLS_
  26 #define _SECURITY_MANAGER_PROTOCOLS_
  27
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30 #include <vector>
  31 #include <string>
  32 #include <dpl/serialization.h>
  33 #include <security-manager.h>
  34
  35 /**
  36  * \name Return Codes
  37  * exported by the foundation API.
  38  * result codes begin with the start error code and extend into negative direction.
  39  * @{
  40 */
  41
  42 /*! \brief   indicating the result of the one specific API is successful */
  43 #define SECURITY_MANAGER_API_SUCCESS 0
  44
  45 /*! \brief   indicating the socket between client and Security Manager has been failed  */
  46 #define SECURITY_MANAGER_API_ERROR_SOCKET -1
  47
  48 /*! \brief   indicating the request to Security Manager is malformed */
  49 #define SECURITY_MANAGER_API_ERROR_BAD_REQUEST -2
  50
  51 /*! \brief   indicating the response from Security Manager is malformed */
  52 #define SECURITY_MANAGER_API_ERROR_BAD_RESPONSE -3
  53
  54 /*! \brief   indicating the requested service does not exist */
  55 #define SECURITY_MANAGER_API_ERROR_NO_SUCH_SERVICE -4
  56
  57 /*! \brief   indicating requesting object is not exist */
  58 #define SECURITY_MANAGER_API_ERROR_NO_SUCH_OBJECT -6
  59
  60 /*! \brief   indicating the authentication between client and server has been failed */
  61 #define SECURITY_MANAGER_API_ERROR_AUTHENTICATION_FAILED -7
  62
  63 /*! \brief   indicating the API's input parameter is malformed */
  64 #define SECURITY_MANAGER_API_ERROR_INPUT_PARAM -8
  65
  66 /*! \brief   indicating the output buffer size which is passed as parameter is too small */
  67 #define SECURITY_MANAGER_API_ERROR_BUFFER_TOO_SMALL -9
  68
  69 /*! \brief   indicating system  is running out of memory state */
  70 #define SECURITY_MANAGER_API_ERROR_OUT_OF_MEMORY -10
  71
  72 /*! \brief   indicating the access has been denied by Security Manager */
  73 #define SECURITY_MANAGER_API_ERROR_ACCESS_DENIED -11
  74
  75 /*! \brief   indicating Security Manager has been failed for some reason */
  76 #define SECURITY_MANAGER_API_ERROR_SERVER_ERROR -12
  77
  78 /*! \brief   indicating getting smack label from socket failed  */
  79 #define SECURITY_MANAGER_API_ERROR_GETTING_SOCKET_LABEL_FAILED -21
  80
  81 /*! \brief   indicating getting smack label from file failed  */
  82 #define SECURITY_MANAGER_API_ERROR_GETTING_FILE_LABEL_FAILED -22
  83
  84 /*! \brief   indicating setting smack label for file failed  */
  85 #define SECURITY_MANAGER_API_ERROR_SETTING_FILE_LABEL_FAILED -23
  86
  87 /*! \brief   indicating file already exists  */
  88 #define SECURITY_MANAGER_API_ERROR_FILE_EXIST -24
  89
  90 /*! \brief   indicating file does not exist  */
  91 #define SECURITY_MANAGER_API_ERROR_FILE_NOT_EXIST -25
  92
  93 /*! \brief   indicating file open error  */
  94 #define SECURITY_MANAGER_API_ERROR_FILE_OPEN_FAILED -26
  95
  96 /*! \brief   indicating file creation error  */
  97 #define SECURITY_MANAGER_API_ERROR_FILE_CREATION_FAILED -27
  98
  99 /*! \brief   indicating file deletion error  */
 100 #define SECURITY_MANAGER_API_ERROR_FILE_DELETION_FAILED -28
 101
 102 /*! \brief   indicating the error with unknown reason */
 103 #define SECURITY_MANAGER_API_ERROR_UNKNOWN -255
 104 /** @}*/
 105
 106
 107 struct app_inst_req {
 108     std::string appId;
 109     std::string pkgId;
 110     std::vector<std::string> privileges;
 111     std::vector<std::pair<std::string, int>> appPaths;
 112     uid_t uid;
 113 };
 114
 115 struct user_req {
 116     uid_t uid;
 117     int utype;
 118 };
 119
 120 namespace SecurityManager {
 121
 122 extern char const * const SERVICE_SOCKET;
 123
 124 enum class SecurityModuleCall
 125 {
 126     APP_INSTALL,
 127     APP_UNINSTALL,
 128     APP_GET_PKGID,
 129     APP_GET_GROUPS,
 130     USER_ADD,
 131     USER_DELETE,
 132     POLICY_UPDATE,
 133     GET_POLICY,
 134     GET_CONF_POLICY_ADMIN,
 135     GET_CONF_POLICY_SELF,
 136     POLICY_GET_DESCRIPTIONS,
 137     NOOP = 0x90,
 138 };
 139
 140 } // namespace SecurityManager
 141
 142 using namespace SecurityManager;
 143
 144 struct policy_entry : ISerializable {
 145     std::string user;           // uid converted to string
 146     std::string appId;          // application identifier
 147     std::string privilege;      // Cynara privilege
 148     std::string currentLevel;   // current level of privielege, or level asked to be set in privacy manager bucket
 149     std::string maxLevel;       // holds read maximum policy status or status to be set in admin bucket
 150
 151     policy_entry() : user(std::to_string(getuid())),
 152                     appId(SECURITY_MANAGER_ANY),
 153                     privilege(SECURITY_MANAGER_ANY),
 154                     currentLevel(""),
 155                     maxLevel("")
 156     {}
 157
 158     policy_entry(IStream &stream) {
 159         Deserialization::Deserialize(stream, user);
 160         Deserialization::Deserialize(stream, appId);
 161         Deserialization::Deserialize(stream, privilege);
 162         Deserialization::Deserialize(stream, currentLevel);
 163         Deserialization::Deserialize(stream, maxLevel);
 164     }
 165
 166     virtual void Serialize(IStream &stream) const {
 167         Serialization::Serialize(stream, user);
 168         Serialization::Serialize(stream, appId);
 169         Serialization::Serialize(stream, privilege);
 170         Serialization::Serialize(stream, currentLevel);
 171         Serialization::Serialize(stream, maxLevel);
 172     }
 173
 174 };
 175 typedef struct policy_entry policy_entry;
 176
 177
 178 struct policy_update_req {
 179     std::vector<const policy_entry *> units;
 180 };
 181
 182
 183 #endif // _SECURITY_MANAGER_PROTOCOLS_