Service implementation.
[platform/core/security/key-manager.git] / src / manager / client / client-manager-impl.cpp
1 /* Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
2  *
3  *  Licensed under the Apache License, Version 2.0 (the "License");
4  *  you may not use this file except in compliance with the License.
5  *  You may obtain a copy of the License at
6  *
7  *      http://www.apache.org/licenses/LICENSE-2.0
8  *
9  *  Unless required by applicable law or agreed to in writing, software
10  *  distributed under the License is distributed on an "AS IS" BASIS,
11  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  *  See the License for the specific language governing permissions and
13  *  limitations under the License
14  *
15  *
16  * @file        client-manager-impl.cpp
17  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
18  * @version     1.0
19  * @brief       Manager implementation.
20  */
21 #include <dpl/serialization.h>
22
23 #include <client-manager-impl.h>
24 #include <client-common.h>
25 #include <client-key-impl.h>
26 #include <message-buffer.h>
27 #include <protocols.h>
28
29 namespace CKM {
30
31 int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
32     m_counter++;
33
34     return try_catch([&] {
35         if (alias.empty() || key.empty())
36             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
37
38         MessageBuffer send, recv;
39         Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
40         Serialization::Serialize(send, m_counter);
41         Serialization::Serialize(send, static_cast<int>(toDBDataType(key.getType())));
42         Serialization::Serialize(send, alias);
43         Serialization::Serialize(send, key.getKey());
44         Serialization::Serialize(send, PolicySerializable(policy));
45
46         int retCode = sendToServer(
47             SERVICE_SOCKET_CKM_STORAGE,
48             send.Pop(),
49             recv);
50
51         if (KEY_MANAGER_API_SUCCESS != retCode) {
52             return retCode;
53         }
54
55         int command;
56         int counter;
57         int opType;
58         Deserialization::Deserialize(recv, command);
59         Deserialization::Deserialize(recv, counter);
60         Deserialization::Deserialize(recv, opType);
61         Deserialization::Deserialize(recv, retCode);
62
63         if (counter != m_counter) {
64             return KEY_MANAGER_API_ERROR_UNKNOWN;
65         }
66
67         return retCode;
68     });
69 }
70
71 int Manager::ManagerImpl::removeKey(const Alias &alias) {
72     return try_catch([&] {
73         if (alias.empty())
74             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
75
76         MessageBuffer send, recv;
77         Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
78         Serialization::Serialize(send, m_counter);
79         Serialization::Serialize(send, static_cast<int>(DBDataType::KEY_RSA_PUBLIC));
80         Serialization::Serialize(send, alias);
81
82         int retCode = sendToServer(
83             SERVICE_SOCKET_CKM_STORAGE,
84             send.Pop(),
85             recv);
86
87         if (KEY_MANAGER_API_SUCCESS != retCode) {
88             return retCode;
89         }
90
91         int command;
92         int counter;
93         int opType;
94         Deserialization::Deserialize(recv, command);
95         Deserialization::Deserialize(recv, counter);
96         Deserialization::Deserialize(recv, opType);
97         Deserialization::Deserialize(recv, retCode);
98
99         if (counter != m_counter) {
100             return KEY_MANAGER_API_ERROR_UNKNOWN;
101         }
102
103         return retCode;
104     });
105 }
106
107 int Manager::ManagerImpl::getBinaryData(
108     const Alias &alias,
109     DBDataType sendDataType,
110     const RawData &password,
111     DBDataType &recvDataType,
112     RawData &rawData)
113 {
114     return try_catch([&] {
115         if (alias.empty())
116             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
117
118         MessageBuffer send, recv;
119         Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
120         Serialization::Serialize(send, m_counter);
121         Serialization::Serialize(send, static_cast<int>(sendDataType));
122         Serialization::Serialize(send, alias);
123         Serialization::Serialize(send, password);
124
125         int retCode = sendToServer(
126             SERVICE_SOCKET_CKM_STORAGE,
127             send.Pop(),
128             recv);
129
130         if (KEY_MANAGER_API_SUCCESS != retCode) {
131             return retCode;
132         }
133
134         int command;
135         int counter;
136         int opType;
137         Deserialization::Deserialize(recv, command);
138         Deserialization::Deserialize(recv, counter);
139         Deserialization::Deserialize(recv, opType);
140         Deserialization::Deserialize(recv, retCode);
141
142         if (retCode == KEY_MANAGER_API_SUCCESS) {
143             int tmpDataType;
144             Deserialization::Deserialize(recv, tmpDataType);
145             Deserialization::Deserialize(recv, rawData);
146             recvDataType = static_cast<DBDataType>(tmpDataType);
147         }
148
149         if (counter != m_counter) {
150             return KEY_MANAGER_API_ERROR_UNKNOWN;
151         }
152
153         return retCode;
154     });
155 }
156
157 int Manager::ManagerImpl::getKey(const Alias &alias, const RawData &password, Key &key) {
158     DBDataType recvDataType;
159     RawData rawData;
160
161     int retCode = getBinaryData(
162         alias,
163         DBDataType::KEY_RSA_PUBLIC,
164         password,
165         recvDataType,
166         rawData);
167
168     if (retCode != KEY_MANAGER_API_SUCCESS)
169         return retCode;
170
171     Key keyParsed(rawData, toKeyType(recvDataType));
172
173     if (keyParsed.empty())
174         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
175
176     key = keyParsed;
177
178     return KEY_MANAGER_API_SUCCESS;
179 }
180
181 } // namespace CKM
182