update the latest source
[platform/core/connectivity/smartcard-service.git] / common / Message.cpp
1 /*
2 * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18 /* standard library header */
19 #include <stdio.h>
20 #include <string.h>
21
22 /* SLP library header */
23
24 /* local header */
25 #include "Debug.h"
26 #include "Message.h"
27
28 namespace smartcard_service_api
29 {
30         Message::Message()
31         {
32                 message = 0;
33                 param1 = 0;
34                 param2 = 0;
35                 error = 0;
36                 caller = NULL;
37                 callback = NULL;
38                 userParam = NULL;
39         }
40
41         Message::~Message()
42         {
43         }
44
45         ByteArray Message::serialize()
46         {
47                 ByteArray result;
48                 unsigned int length = 0;
49                 unsigned int dataLength = 0;
50                 unsigned char *buffer = NULL;
51
52                 length = sizeof(message) + sizeof(param1) + sizeof(param2) + sizeof(error) + sizeof(caller) + sizeof(callback) + sizeof(userParam);
53                 if (data.getLength() > 0)
54                 {
55                         dataLength = data.getLength();
56                         length += sizeof(dataLength) + data.getLength();
57                 }
58
59                 buffer = new unsigned char[length];
60                 if (buffer != NULL)
61                 {
62                         unsigned int current = 0;
63
64                         memset(buffer, 0, length);
65
66                         memcpy(buffer + current, &message, sizeof(message));
67                         current += sizeof(message);
68
69                         memcpy(buffer + current, &param1, sizeof(param1));
70                         current += sizeof(param1);
71
72                         memcpy(buffer + current, &param2, sizeof(param2));
73                         current += sizeof(param2);
74
75                         memcpy(buffer + current, &error, sizeof(error));
76                         current += sizeof(error);
77
78                         memcpy(buffer + current, &caller, sizeof(caller));
79                         current += sizeof(caller);
80
81                         memcpy(buffer + current, &callback, sizeof(callback));
82                         current += sizeof(callback);
83
84                         memcpy(buffer + current, &userParam, sizeof(userParam));
85                         current += sizeof(userParam);
86
87                         if (data.getLength() > 0)
88                         {
89                                 memcpy(buffer + current, &dataLength, sizeof(dataLength));
90                                 current += sizeof(dataLength);
91
92                                 memcpy(buffer + current, data.getBuffer(), dataLength);
93                                 current += data.getLength();
94                         }
95
96                         result.setBuffer(buffer, length);
97
98                         delete []buffer;
99                 }
100                 else
101                 {
102                         SCARD_DEBUG_ERR("allocation failed");
103                 }
104
105                 return result;
106         }
107
108         void Message::deserialize(ByteArray buffer)
109         {
110                 deserialize(buffer.getBuffer(), buffer.getLength());
111         }
112
113         void Message::deserialize(unsigned char *buffer, unsigned int length)
114         {
115                 unsigned int current = 0;
116                 unsigned int dataLength = 0;
117
118 //              SCARD_DEBUG("buffer [%p], length [%d]", buffer, length);
119
120                 memcpy(&message, buffer + current, sizeof(message));
121                 current += sizeof(message);
122
123 //              SCARD_DEBUG("message [%d]", message);
124
125                 memcpy(&param1, buffer + current, sizeof(param1));
126                 current += sizeof(param1);
127
128 //              SCARD_DEBUG("param1 [%d]", param1);
129
130                 memcpy(&param2, buffer + current, sizeof(param2));
131                 current += sizeof(param2);
132
133 //              SCARD_DEBUG("param2 [%d]", param2);
134
135                 memcpy(&error, buffer + current, sizeof(error));
136                 current += sizeof(error);
137
138                 memcpy(&caller, buffer + current, sizeof(caller));
139                 current += sizeof(caller);
140
141                 memcpy(&callback, buffer + current, sizeof(callback));
142                 current += sizeof(callback);
143
144                 memcpy(&userParam, buffer + current, sizeof(userParam));
145                 current += sizeof(userParam);
146
147 //              SCARD_DEBUG("userContext [%p]", userContext);
148
149                 if (current + sizeof(dataLength) < length)
150                 {
151                         memcpy(&dataLength, buffer + current, sizeof(dataLength));
152                         current += sizeof(dataLength);
153
154 //                      SCARD_DEBUG("dataLength [%d]", dataLength);
155
156                         data.setBuffer(buffer + current, dataLength);
157                         current += dataLength;
158                 }
159         }
160
161         const char *Message::toString()
162         {
163                 const char *msg = NULL;
164
165                 memset(&text, 0, sizeof(text));
166
167                 switch (message)
168                 {
169                 case MSG_REQUEST_READERS :
170                         msg = "MSG_REQUEST_READERS";
171                         break;
172
173 //              case MSG_REQUEST_READER_NAME :
174 //                      msg = "MSG_REQUEST_READER_NAME";
175 //                      break;
176 //
177                 case MSG_REQUEST_OPEN_SESSION :
178                         msg = "MSG_REQUEST_OPEN_SESSION";
179                         break;
180
181                 case MSG_REQUEST_CLOSE_SESSION :
182                         msg = "MSG_REQUEST_CLOSE_CHANNEL";
183                         break;
184
185                 case MSG_REQUEST_OPEN_CHANNEL :
186                         msg = "MSG_REQUEST_OPEN_CHANNEL";
187                         break;
188
189                 case MSG_REQUEST_CLOSE_CHANNEL :
190                         msg = "MSG_REQUEST_CLOSE_CHANNEL";
191                         break;
192
193                 case MSG_REQUEST_GET_ATR :
194                         msg = "MSG_REQUEST_GET_ATR";
195                         break;
196
197                 case MSG_REQUEST_TRANSMIT :
198                         msg = "MSG_REQUEST_TRANSMIT";
199                         break;
200
201                 case MSG_REQUEST_GET_CHANNEL_COUNT :
202                         msg = "MSG_REQUEST_GET_CHANNEL_COUNT";
203                         break;
204
205                 default :
206                         msg = "Unknown";
207                         break;
208                 }
209
210                 snprintf(text, sizeof(text), "Message [%s, %d], param1 [%d], param2 [%d], error [%d], caller [%p], callback [%p], userParam [%p], data length [%d]", msg, message, param1, param2, error, caller, callback, userParam, data.getLength());
211
212                 return (const char *)text;
213         }
214
215 } /* namespace smartcard_service_api */