1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
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 #include "map_mse_server.h"
17 #include <algorithm>
18 #include <atomic>
19 #include <codecvt>
20 #include <ctime>
21 #include <iomanip>
22 #include <locale>
23 #include <sstream>
24 #include "adapter_config.h"
25 #include "data_access.h"
26 #include "map_mse_instance.h"
27
28 namespace OHOS {
29 namespace bluetooth {
30 const uint8_t MapMseServer::MAS_TARGET[TARGET_SIZE] = {
31 0xbb, 0x58, 0x2b, 0x40, 0x42, 0x0c, 0x11, 0xdb, 0xb0, 0xde, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
32 };
33 const std::string MapMseServer::HEADER_TYPE_GET_FOLDER_LISTING = "x-obex/folder-listing";
34 const std::string MapMseServer::HEADER_TYPE_GET_MESSAGE_LISTING = "x-bt/MAP-msg-listing";
35 const std::string MapMseServer::HEADER_TYPE_GET_CONVO_LISTING = "x-bt/MAP-convo-listing";
36 const std::string MapMseServer::HEADER_TYPE_MESSAGE = "x-bt/message";
37 const std::string MapMseServer::HEADER_TYPE_SET_MESSAGE_STATUS = "x-bt/messageStatus";
38 const std::string MapMseServer::HEADER_TYPE_SET_NOTIFICATION_REGISTRATION = "x-bt/MAP-NotificationRegistration";
39 const std::string MapMseServer::HEADER_TYPE_MESSAGE_UPDATE = "x-bt/MAP-messageUpdate";
40 const std::string MapMseServer::HEADER_TYPE_GET_MAS_INSTANCE_INFORMATION = "x-bt/MASInstanceInformation";
41 const std::string MapMseServer::HEADER_TYPE_OWNER_STATUS = "x-bt/ownerStatus";
42 const std::string MapMseServer::HEADER_TYPE_SET_NOTIFICATION_FILTER = "x-bt/MAP-notification-filter";
43
MapMseServer(MapMseResource & content,utility::Dispatcher & dispatcher,MseObserver & observer,MapMseInstance & instance,uint8_t rfcommNo,uint16_t l2capPsm,std::string serviceName,const MapAccountItem & accountItem,bool smsSupport)44 MapMseServer::MapMseServer(MapMseResource &content, utility::Dispatcher &dispatcher, MseObserver &observer,
45 MapMseInstance &instance, uint8_t rfcommNo, uint16_t l2capPsm, std::string serviceName,
46 const MapAccountItem &accountItem, bool smsSupport)
47 : content_(content),
48 dispatcher_(dispatcher),
49 observer_(observer),
50 instance_(instance),
51 rfcommNo_(rfcommNo),
52 goepL2capPsm_(l2capPsm),
53 serviceName_(serviceName),
54 accountItem_(accountItem),
55 smsSupport_(smsSupport)
56 {
57 MSE_LOG_INFO("%{public}s Create", __PRETTY_FUNCTION__);
58
59 mseObexServer_ = std::make_unique<MseObexServer>(*this);
60 CreateFolder();
61 supportedFeatureMask_ = MAP_SUPPORTED_FEATURES_DEFAULT;
62 connectId_ = ATOMIC_VAR_INIT();
63 }
64
CreateFolder(void)65 void MapMseServer::CreateFolder(void)
66 {
67 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
68
69 rootFolder_ = std::make_unique<MapMseFolder>("root");
70 MapMseFolder *telecom = rootFolder_->SetFolder("telecom");
71 MapMseFolder *msg = telecom->SetFolder("msg");
72 InitDefaultFolder(*msg);
73 if (smsSupport_) {
74 InitSmsMmsFolder(*msg);
75 }
76 if (MessageType::EMAIL == accountItem_.msgType_) {
77 InitEmailFolder(*msg);
78 } else if (MessageType::IM == accountItem_.msgType_) {
79 InitImFolder(*msg);
80 }
81 currentFolder_ = rootFolder_.get();
82 }
83
InitDefaultFolder(MapMseFolder & root)84 void MapMseServer::InitDefaultFolder(MapMseFolder &root)
85 {
86 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
87 root.SetFolder(MAP_MSE_FOLDER_NAME_INBOX);
88 root.SetFolder(MAP_MSE_FOLDER_NAME_SENT);
89 root.SetFolder(MAP_MSE_FOLDER_NAME_OUTBOX);
90 root.SetFolder(MAP_MSE_FOLDER_NAME_DELETED);
91 }
92
InitSmsMmsFolder(MapMseFolder & root)93 void MapMseServer::InitSmsMmsFolder(MapMseFolder &root)
94 {
95 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
96 root.SetSmsMmsFolder(MAP_MSE_FOLDER_NAME_INBOX);
97 root.SetSmsMmsFolder(MAP_MSE_FOLDER_NAME_SENT);
98 root.SetSmsMmsFolder(MAP_MSE_FOLDER_NAME_DRAFT);
99 root.SetSmsMmsFolder(MAP_MSE_FOLDER_NAME_OUTBOX);
100 root.SetSmsMmsFolder(MAP_MSE_FOLDER_NAME_DELETED);
101 }
102
InitEmailFolder(MapMseFolder & parentFolder,int depth)103 void MapMseServer::InitEmailFolder(MapMseFolder &parentFolder, int depth)
104 {
105 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
106
107 auto dataProvider = DataAccess::GetConnection(DEFAULT_MAP_MSE_DB_FILE);
108 if (!dataProvider) {
109 return;
110 }
111
112 std::unordered_map<int, std::string> data = GetEmailInfo(dataProvider, parentFolder);
113 for (auto &fd : data) {
114 MapMseFolder *ff = parentFolder.GetSubFolder(fd.second);
115 if (ff == nullptr) {
116 continue;
117 }
118 auto secondData = GetEmailInfo(dataProvider, *ff);
119 for (auto &sd : secondData) {
120 MapMseFolder *sf = parentFolder.GetSubFolder(sd.second);
121 if (sf == nullptr) {
122 continue;
123 }
124 GetEmailInfo(dataProvider, *sf);
125 }
126 }
127 }
128
GetEmailInfo(std::unique_ptr<DataAccess> & dataAccess,MapMseFolder & parent)129 std::unordered_map<int, std::string> MapMseServer::GetEmailInfo(
130 std::unique_ptr<DataAccess> &dataAccess, MapMseFolder &parent)
131 {
132 std::unordered_map<int, std::string> result {};
133 std::string sql = "select id, name from Folder where parent_id = ? ";
134 auto stmt = dataAccess->CreateStatement(sql);
135 stmt->SetParamInt(1, parent.GetFolderId());
136 auto dataResult = stmt->Query();
137 while (dataResult->Next()) {
138 int id = dataResult->GetInt(0);
139 std::string name = dataResult->GetString(1);
140 result[id] = name;
141 parent.SetEmailFolder(id, name);
142 }
143 return result;
144 }
145
InitImFolder(MapMseFolder & root)146 void MapMseServer::InitImFolder(MapMseFolder &root)
147 {
148 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
149
150 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_OTHER, MAP_MSE_FOLDER_NAME_OTHER);
151 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_INBOX, MAP_MSE_FOLDER_NAME_INBOX);
152 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_SENT, MAP_MSE_FOLDER_NAME_SENT);
153 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_DRAFT, MAP_MSE_FOLDER_NAME_DRAFT);
154 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_OUTBOX, MAP_MSE_FOLDER_NAME_OUTBOX);
155 root.SetImFolder(ImFolderId::MAP_MSE_FOLDER_ID_DELETED, MAP_MSE_FOLDER_NAME_DELETED);
156 }
157
~MapMseServer()158 MapMseServer::~MapMseServer()
159 {
160 MSE_LOG_INFO("%{public}s Delete", __PRETTY_FUNCTION__);
161
162 currentFolder_ = nullptr;
163 }
164
MseObexServer(MapMseServer & mseServer)165 MapMseServer::MseObexServer::MseObexServer(MapMseServer &mseServer) : mseServer_(&mseServer)
166 {
167 MSE_LOG_INFO("%{public}s Create", __PRETTY_FUNCTION__);
168 }
169
~MseObexServer()170 MapMseServer::MseObexServer::~MseObexServer()
171 {
172 MSE_LOG_INFO("%{public}s Delete", __PRETTY_FUNCTION__);
173 }
174
OnConnect(ObexServerSession & session,const ObexHeader & req)175 void MapMseServer::MseObexServer::OnConnect(ObexServerSession &session, const ObexHeader &req)
176 {
177 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
178
179 if (!req.GetItemTarget()) {
180 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
181 return;
182 }
183 if (req.GetItemTarget()->GetHeaderDataSize() != TARGET_SIZE) {
184 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
185 return;
186 }
187 if (req.GetItemAppParams()) {
188 if (req.GetItemAppParams()->GetTlvtriplet(MapMseParams::PARAM_MAP_SUPPORTED_FEATURES)) {
189 mseServer_->supportedFeatureMask_ =
190 req.GetItemAppParams()->GetTlvtriplet(MapMseParams::PARAM_MAP_SUPPORTED_FEATURES)->GetUint32();
191 }
192 }
193 std::unique_ptr<uint8_t[]> masTarget = req.GetItemTarget()->GetBytes();
194 for (int i = 0; i < TARGET_SIZE; i++) {
195 if (masTarget[i] != MAS_TARGET[i]) {
196 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE, true));
197 return;
198 }
199 }
200 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS, true);
201 mseServer_->connectId_++;
202 resHeader->AppendItemConnectionId(mseServer_->connectId_.load());
203 resHeader->AppendItemWho(MAS_TARGET, TARGET_SIZE);
204 session.SendResponse(*resHeader);
205 mseServer_->observer_.OnConnected(session);
206 }
207
OnTransportConnect(ObexIncomingConnect & incomingConnect)208 void MapMseServer::MseObexServer::OnTransportConnect(ObexIncomingConnect &incomingConnect)
209 {
210 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
211
212 mseServer_->observer_.OnIncomingConnect(incomingConnect);
213 }
214
OnTransportDisconnected(const std::string & btAddr)215 void MapMseServer::MseObexServer::OnTransportDisconnected(const std::string &btAddr)
216 {
217 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
218
219 RawAddress remoteAddr(btAddr);
220 mseServer_->observer_.OnTransportDisconnected(remoteAddr);
221 }
222
OnTransportError(const std::string & btAddr,int errCd,const std::string & msg)223 void MapMseServer::MseObexServer::OnTransportError(const std::string &btAddr, int errCd, const std::string &msg)
224 {
225 MSE_LOG_ERROR("%{public}s Enter", __PRETTY_FUNCTION__);
226 }
227
OnError(const int errCd,const std::string & msg)228 void MapMseServer::MseObexServer::OnError(const int errCd, const std::string &msg)
229 {
230 MSE_LOG_ERROR("%{public}s Enter", __PRETTY_FUNCTION__);
231 }
232
OnDisconnect(ObexServerSession & session,const ObexHeader & req)233 void MapMseServer::MseObexServer::OnDisconnect(ObexServerSession &session, const ObexHeader &req)
234 {
235 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
236
237 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS, false);
238 session.SendResponse(*resHeader);
239 mseServer_->observer_.OnDisconnect(session.GetRemoteAddr());
240 }
241
OnPut(ObexServerSession & session,const ObexHeader & req)242 void MapMseServer::MseObexServer::OnPut(ObexServerSession &session, const ObexHeader &req)
243 {
244 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
245 if (!req.GetItemType()) {
246 MSE_LOG_ERROR("Item Type of Obex header is error.");
247 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
248 return;
249 }
250 OnBusy(session, true);
251 auto msgType = req.GetItemType()->GetString();
252 if (HEADER_TYPE_MESSAGE == msgType) {
253 mseServer_->PushMessageResponse(session, req);
254 } else if (HEADER_TYPE_SET_NOTIFICATION_REGISTRATION == msgType) {
255 mseServer_->SetNotificationRegistration(session, req);
256 } else if (HEADER_TYPE_SET_NOTIFICATION_FILTER == msgType) {
257 mseServer_->SetNotificationFilter(session, req);
258 } else if (HEADER_TYPE_SET_MESSAGE_STATUS == msgType) {
259 if (!req.GetItemName()) {
260 MSE_LOG_ERROR("Item Name of Obex header is error.");
261 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
262 return;
263 }
264 mseServer_->SetMessageStatus(session, req);
265 } else if (HEADER_TYPE_MESSAGE_UPDATE == msgType) {
266 mseServer_->UpdateInbox(session, req);
267 } else if (HEADER_TYPE_OWNER_STATUS == msgType) {
268 mseServer_->SetOwnerStatus(session, req);
269 }
270 OnBusy(session, false);
271 }
272
OnGet(ObexServerSession & session,const ObexHeader & req)273 void MapMseServer::MseObexServer::OnGet(ObexServerSession &session, const ObexHeader &req)
274 {
275 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
276
277 if (!req.GetItemType()) {
278 MSE_LOG_ERROR("Item Type of Obex header is error.");
279 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
280 return;
281 }
282 OnBusy(session, true);
283 auto msgType = req.GetItemType()->GetString();
284 if (HEADER_TYPE_MESSAGE == msgType) {
285 mseServer_->GetMessageResponse(session, req);
286 } else if (HEADER_TYPE_GET_MESSAGE_LISTING == msgType) {
287 if (!req.GetItemName()) {
288 MSE_LOG_ERROR("Item Name of Obex header is error.");
289 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
290 OnBusy(session, false);
291 return;
292 }
293 mseServer_->GetMessageListing(session, req);
294 } else if (HEADER_TYPE_GET_CONVO_LISTING == msgType) {
295 mseServer_->GetConversationListing(session, req);
296 } else if (HEADER_TYPE_GET_FOLDER_LISTING == msgType) {
297 mseServer_->GetFolderListing(session, req);
298 } else if (HEADER_TYPE_OWNER_STATUS == msgType) {
299 mseServer_->GetOwnerStatus(session, req);
300 } else if (HEADER_TYPE_GET_MAS_INSTANCE_INFORMATION == msgType) {
301 mseServer_->GetMASInstanceInformation(session, req);
302 }
303 OnBusy(session, false);
304 }
305
OnAbort(ObexServerSession & session,const ObexHeader & req)306 void MapMseServer::MseObexServer::OnAbort(ObexServerSession &session, const ObexHeader &req)
307 {
308 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
309 }
310
OnBusy(ObexServerSession & session,bool isBusy) const311 void MapMseServer::MseObexServer::OnBusy(ObexServerSession &session, bool isBusy) const
312 {
313 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
314
315 const RawAddress &remoteAddr = session.GetRemoteAddr();
316 mseServer_->observer_.OnBusy(remoteAddr, isBusy);
317 }
318
OnSetPath(ObexServerSession & session,const ObexHeader & req)319 void MapMseServer::MseObexServer::OnSetPath(ObexServerSession &session, const ObexHeader &req)
320 {
321 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
322
323 std::string folderName;
324 if (req.GetItemName() != nullptr) {
325 if (req.GetItemName()->GetUnicodeText().size() != 0) {
326 folderName = mseServer_->ToUtf8String(req.GetItemName()->GetUnicodeText());
327 std::transform(folderName.begin(), folderName.end(), folderName.begin(), ::tolower);
328 }
329 }
330 uint8_t flages = *req.GetFieldFlags();
331 if ((flages & 0x02) != 0x02) {
332 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
333 return;
334 }
335 MSE_LOG_INFO("MapMseServer::MseObexServer::OnSetPath folderName : %{public}s flages : %u ",
336 folderName.c_str(), flages);
337 MapMseFolder *tempFolder = nullptr;
338 if (folderName.size() == 0) {
339 if (flages == 0x03) {
340 tempFolder = mseServer_->currentFolder_->GetParent();
341 } else {
342 tempFolder = mseServer_->rootFolder_.get();
343 }
344 } else {
345 if (flages == 0x03) {
346 tempFolder = mseServer_->currentFolder_->GetParent();
347 if (tempFolder == nullptr) {
348 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_FOUND));
349 return;
350 }
351 }
352 tempFolder = mseServer_->currentFolder_->GetSubFolder(folderName);
353 }
354 if (tempFolder == nullptr) {
355 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_FOUND));
356 return;
357 }
358 mseServer_->currentFolder_ = tempFolder;
359 MSE_LOG_INFO("Current Folder : %{public}s ", mseServer_->currentFolder_->GetName().c_str());
360 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
361 session.SendResponse(*resHeader);
362 }
363
Enable(void)364 int MapMseServer::Enable(void)
365 {
366 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
367 LoadAdapterConfig();
368 ObexServerConfig obexSrvConfig = {
369 .useRfcomm_ = true,
370 .rfcommScn_ = rfcommNo_,
371 .rfcommMtu_ = static_cast<uint16_t>(rfcommMtu_),
372 #ifdef MAP_MSE_L2CAP_ENABLE
373 .useL2cap_ = true,
374 #else
375 .useL2cap_ = false,
376 #endif
377 .l2capPsm_ = goepL2capPsm_,
378 .l2capMtu_ = static_cast<uint16_t>(l2capMtu_),
379 .isSupportSrm_ = srmEnable_,
380 .isSupportReliableSession_ = false
381 };
382 obexServer_ = std::make_unique<ObexMpServer>(serviceName_, obexSrvConfig, *mseObexServer_, dispatcher_);
383 return !obexServer_->Startup() ? Result::SUCCEED : Result::FAIL;
384 }
385
Disable(void)386 void MapMseServer::Disable(void)
387 {
388 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
389
390 return obexServer_->Shutdown();
391 }
392
SetRemoteFeatureMask(uint32_t features)393 void MapMseServer::SetRemoteFeatureMask(uint32_t features)
394 {
395 if (supportedFeatureMask_ == MAP_SUPPORTED_FEATURES_DEFAULT) {
396 supportedFeatureMask_ = features;
397 } else {
398 supportedFeatureMask_ = supportedFeatureMask_ & features;
399 }
400 content_.SetRemoteFeatureMask(supportedFeatureMask_);
401 messageVersion_ = MAP_V10;
402 messageListingVersion_ = MAP_V10;
403 if ((supportedFeatureMask_ & MAP_FEATURE_MESSAGE_FORMAT_V11_BIT) > 0) {
404 messageVersion_ = MAP_V11;
405 }
406 if ((supportedFeatureMask_ & MAP_FEATURE_MESSAGE_LISTING_FORMAT_V11_BIT) > 0) {
407 messageListingVersion_ = MAP_V11;
408 }
409 }
410
CreateBMessage(ObexServerSession & session,const ObexHeader & req,const uint8_t charset,std::string & folderName)411 int MapMseServer::CreateBMessage(
412 ObexServerSession &session, const ObexHeader &req, const uint8_t charset, std::string &folderName)
413 {
414 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
415
416 if (currentFolder_ == nullptr || req.GetItemName() == nullptr) {
417 return RET_BAD_PARAM;
418 } else {
419 if (req.GetItemName()->GetUnicodeText().size() != 0) {
420 std::string subFolderName = ToUtf8String(req.GetItemName()->GetUnicodeText());
421 std::transform(subFolderName.begin(), subFolderName.end(), subFolderName.begin(), ::tolower);
422 folderName = currentFolder_->GetSubFolder(subFolderName)->GetName();
423 } else {
424 folderName = currentFolder_->GetName();
425 }
426 }
427 if (MAP_MSE_FOLDER_NAME_OUTBOX != folderName && MAP_MSE_FOLDER_NAME_DRAFT != folderName) {
428 return RET_BAD_STATUS;
429 }
430 auto body = req.GetExtendBodyObject();
431 uint8_t buf[READ_BODY_BUFF_SIZE];
432 size_t cnt = 0;
433 std::vector<uint8_t> results;
434 while ((cnt = body->Read(buf, READ_BODY_BUFF_SIZE)) > 0) {
435 results.insert(results.end(), buf, buf + cnt);
436 }
437 std::string data(results.begin(), results.end());
438 MSE_LOG_INFO("body data: %{public}s", data.c_str());
439 bMessage_ = std::make_unique<MapMseBmsg>();
440 bMessage_->SetVersion(messageVersion_);
441 if (bMessage_->Init(data, charset) != BT_SUCCESS) {
442 return RET_BAD_STATUS;
443 }
444 if (MessageType::SMS_GSM == bMessage_->GetType() || MessageType::SMS_CDMA == bMessage_->GetType()) {
445 if (stub::PhoneType::SMS_GSM == stub::MapService::GetInstance()->GetSystemTelephonyService().phoneType) {
446 bMessage_->SetType(MessageType::SMS_GSM);
447 } else if (stub::PhoneType::SMS_CDMA ==
448 stub::MapService::GetInstance()->GetSystemTelephonyService().phoneType) {
449 bMessage_->SetType(MessageType::SMS_CDMA);
450 }
451 }
452 return BT_SUCCESS;
453 }
454
PushMessageResponse(ObexServerSession & session,const ObexHeader & req)455 void MapMseServer::PushMessageResponse(ObexServerSession &session, const ObexHeader &req)
456 {
457 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
458
459 std::unique_ptr<MapMseParams> appParams = nullptr;
460 if (req.GetItemAppParams()) {
461 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
462 } else {
463 appParams = std::make_unique<MapMseParams>();
464 }
465 if (!appParams->charSet_) {
466 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
467 return;
468 }
469 std::string folderName = "";
470 auto ret = CreateBMessage(session, req, *appParams->charSet_, folderName);
471 if (ret == RET_BAD_PARAM) {
472 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
473 return;
474 } else if (ret == RET_BAD_STATUS) {
475 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::BAD_REQUEST));
476 return;
477 }
478 std::string handle;
479 if (appParams->messageHandle_ != "") {
480 if (((supportedFeatureMask_ & MAP_FEATURE_MESSAGE_FORWARDING_BIT) == 0) || !appParams->attachment_ ||
481 !appParams->modifyText_) {
482 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
483 return;
484 }
485 content_.SentOrForwardedMessage(*bMessage_, *appParams, appParams->messageHandle_);
486 handle = appParams->messageHandle_;
487 } else if (appParams->conversationId_ != "") {
488 handle = content_.SentConversationMessage(*bMessage_, *appParams, folderName);
489 } else {
490 handle = content_.SentNewMessage(*bMessage_, folderName, *appParams);
491 }
492 if (handle == "") {
493 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
494 return;
495 }
496 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
497 resHeader->AppendItemName(ToU16String(handle));
498 session.SendResponse(*resHeader);
499 }
500
GetMessageResponse(ObexServerSession & session,const ObexHeader & req)501 void MapMseServer::GetMessageResponse(ObexServerSession &session, const ObexHeader &req)
502 {
503 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
504
505 if (!req.GetItemName()) {
506 MSE_LOG_ERROR("Item Name of Obex header is error.");
507 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
508 return;
509 }
510 std::unique_ptr<MapMseParams> appParams = nullptr;
511 if (req.GetItemAppParams()) {
512 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
513 } else {
514 appParams = std::make_unique<MapMseParams>();
515 }
516 std::string name;
517 if (req.GetItemName()->GetUnicodeText().size() != 0) {
518 name = ToUtf8String(req.GetItemName()->GetUnicodeText());
519 } else {
520 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
521 return;
522 }
523 std::string body = content_.GetMessage(name, *appParams, messageVersion_);
524 auto bodyObj = std::make_shared<ObexArrayBodyObject>();
525 bodyObj->Write((uint8_t *)body.data(), body.size());
526 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
527 uint64_t handle = std::atol(name.c_str());
528 if ((MessageType::EMAIL == ParseHandle(handle) || MessageType::IM == ParseHandle(handle)) &&
529 !appParams->fractionRequest_) {
530 ObexTlvParamters obexAppPrarams;
531 uint8_t fractionDeliver = static_cast<uint8_t>(FractionDeliver::LAST);
532 TlvTriplet tlvItem(MapMseParams::PARAM_FRACTION_DELIVER, fractionDeliver);
533 obexAppPrarams.AppendTlvtriplet(tlvItem);
534 resHeader->AppendItemAppParams(obexAppPrarams);
535 }
536 session.SendGetResponse(req, *resHeader, bodyObj);
537 }
538
GetMessageListing(ObexServerSession & session,const ObexHeader & req)539 void MapMseServer::GetMessageListing(ObexServerSession &session, const ObexHeader &req)
540 {
541 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
542
543 std::unique_ptr<MapMseParams> appParams = nullptr;
544 MapMseFolder *folder = currentFolder_;
545 if (req.GetItemAppParams()) {
546 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
547 if (appParams->filterMessageHandle_.size() != 0 || appParams->conversationId_.size() != 0) {
548 folder = rootFolder_.get();
549 folder->SetIgnore(true);
550 } else {
551 std::string folderName;
552 if (req.GetItemName() && req.GetItemName()->GetUnicodeText().size() != 0) {
553 folderName = ToUtf8String(req.GetItemName()->GetUnicodeText());
554 MSE_LOG_INFO("folderName : %{public}s Enter", folderName.c_str());
555 std::transform(folderName.begin(), folderName.end(), folderName.begin(), ::tolower);
556 folder = currentFolder_->GetSubFolder(folderName);
557 } else {
558 folder = currentFolder_;
559 }
560 if (folder == nullptr) {
561 MSE_LOG_INFO("currentFolder_ is nullptr.");
562 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_FOUND));
563 return;
564 }
565 }
566 } else {
567 if (appParams == nullptr)
568 appParams = std::make_unique<MapMseParams>();
569 }
570 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
571 std::shared_ptr<ObexBodyObject> bodyObj = nullptr;
572 uint8_t unMessage = 0;
573 uint16_t listingSize = 0;
574 auto name = folder->IsIgnore() ? "" : folder->GetName();
575 if (appParams->maxListCount_ == 0x0) {
576 content_.GetListingSize(name, *appParams, listingSize, unMessage);
577 } else {
578 auto body = content_.GetBodyXml(name, *appParams, messageListingVersion_, listingSize, unMessage);
579 MSE_LOG_INFO("body : %{public}s ", body.c_str());
580 if (body != "") {
581 bodyObj = std::make_shared<ObexArrayBodyObject>();
582 bodyObj->Write((uint8_t *)body.data(), body.size());
583 }
584 }
585 ObexTlvParamters obexAppPrarams;
586 CreateOutputAppPrarams(obexAppPrarams, listingSize, unMessage);
587 resHeader->AppendItemAppParams(obexAppPrarams);
588 session.SendGetResponse(req, *resHeader, bodyObj);
589 }
590
CreateOutputAppPrarams(ObexTlvParamters & obexAppPrarams,const uint16_t & listSize,const uint8_t & unRead)591 void MapMseServer::CreateOutputAppPrarams(
592 ObexTlvParamters &obexAppPrarams, const uint16_t &listSize, const uint8_t &unRead)
593 {
594 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_LISTING_SIZE, listSize));
595 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_NEW_MESSAGE, unRead));
596 if ((supportedFeatureMask_ & MAP_FEATURE_DATABASE_INDENTIFIER_BIT) == MAP_FEATURE_DATABASE_INDENTIFIER_BIT) {
597 auto value = std::to_string(instance_.GetDatabaseIdentifier());
598 obexAppPrarams.AppendTlvtriplet(
599 TlvTriplet(MapMseParams::PARAM_DATABASE_IDENTIFIER, static_cast<uint8_t>(value.size() + 1),
600 reinterpret_cast<uint8_t *>(value.data())));
601 }
602 if ((supportedFeatureMask_ & MAP_FEATURE_FOLDER_VERSION_COUNTER_BIT) == MAP_FEATURE_FOLDER_VERSION_COUNTER_BIT) {
603 auto value = std::to_string(instance_.GetFolderVersionCounter());
604 obexAppPrarams.AppendTlvtriplet(TlvTriplet(
605 MapMseParams::PARAM_FOLDER_VERSION_COUNTER, static_cast<uint8_t>(value.size() + 1),
606 reinterpret_cast<uint8_t *>(value.data())));
607 }
608 std::string mseTime = GetMseTime();
609 obexAppPrarams.AppendTlvtriplet(
610 TlvTriplet(MapMseParams::PARAM_MSE_TIME, mseTime.size(),
611 reinterpret_cast<uint8_t *>(const_cast<char *>(mseTime.c_str()))));
612 }
613
GetConversationListing(ObexServerSession & session,const ObexHeader & req)614 void MapMseServer::GetConversationListing(ObexServerSession &session, const ObexHeader &req)
615 {
616 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
617
618 std::unique_ptr<MapMseParams> appParams = nullptr;
619 if (req.GetItemAppParams()) {
620 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
621 } else {
622 appParams = std::make_unique<MapMseParams>();
623 }
624 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
625 ObexTlvParamters obexAppPrarams;
626 uint16_t listingSize = 0;
627 std::shared_ptr<ObexBodyObject> bodyObj = nullptr;
628 if (appParams->maxListCount_ == 0x0) {
629 listingSize = content_.GetConvoLstCount(*appParams);
630 if ((supportedFeatureMask_ & MAP_FEATURE_CONVERSATION_VERSION_COUNTER_BIT) > 0) {
631 auto value = std::to_string(instance_.GetConversationVersionCounter());
632 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_CONVERSATION_LISTING_VERSION_COUNTER,
633 static_cast<uint8_t>(value.size() + 1),
634 reinterpret_cast<uint8_t *>(value.data())));
635 }
636 } else {
637 auto bodyData = content_.GetCvslistBodyXml(*appParams, listingSize);
638 MSE_LOG_INFO("Body : %{public}s ", bodyData.c_str());
639 bodyObj = std::make_shared<ObexArrayBodyObject>();
640 bodyObj->Write((uint8_t *)bodyData.data(), bodyData.size());
641 }
642 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_LISTING_SIZE, listingSize));
643 if ((supportedFeatureMask_ & MAP_FEATURE_DATABASE_INDENTIFIER_BIT) > 0) {
644 auto value = std::to_string(instance_.GetDatabaseIdentifier());
645 obexAppPrarams.AppendTlvtriplet(
646 TlvTriplet(MapMseParams::PARAM_DATABASE_IDENTIFIER, static_cast<uint8_t>(value.size() + 1),
647 reinterpret_cast<uint8_t *>(value.data())));
648 }
649 std::string mseTime = GetMseTime();
650 obexAppPrarams.AppendTlvtriplet(
651 TlvTriplet(MapMseParams::PARAM_MSE_TIME, static_cast<uint8_t>(mseTime.size()),
652 reinterpret_cast<uint8_t *>(const_cast<char *>(mseTime.c_str()))));
653 resHeader->AppendItemAppParams(obexAppPrarams);
654 session.SendGetResponse(req, *resHeader, bodyObj);
655 }
656
GetFolderListing(ObexServerSession & session,const ObexHeader & req)657 void MapMseServer::GetFolderListing(ObexServerSession &session, const ObexHeader &req)
658 {
659 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
660
661 std::unique_ptr<MapMseParams> appParams = nullptr;
662 if (req.GetItemAppParams()) {
663 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
664 } else {
665 appParams = std::make_unique<MapMseParams>();
666 }
667 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
668 ObexTlvParamters obexAppPrarams;
669 std::shared_ptr<ObexBodyObject> bodyObj = nullptr;
670 if (appParams->maxListCount_ == 0x00) {
671 uint16_t listingSize = currentFolder_->GetSubFolderSize();
672 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_LISTING_SIZE, listingSize));
673 // no body to seting
674 } else {
675 auto folderData = currentFolder_->GetData(appParams->listStartOffSet_, appParams->maxListCount_);
676 if (folderData.size() == 0) {
677 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
678 return;
679 }
680 bodyObj = std::make_shared<ObexArrayBodyObject>();
681 bodyObj->Write((uint8_t *)folderData.data(), folderData.size());
682 MSE_LOG_INFO("Body : %{public}s ", folderData.c_str());
683 }
684 resHeader->AppendItemAppParams(obexAppPrarams);
685 session.SendGetResponse(req, *resHeader, bodyObj);
686 }
687
GetOwnerStatus(const ObexServerSession & session,const ObexHeader & req)688 void MapMseServer::GetOwnerStatus(const ObexServerSession &session, const ObexHeader &req)
689 {
690 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
691
692 std::unique_ptr<MapMseParams> appParams = nullptr;
693 if (req.GetItemAppParams()) {
694 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
695 } else {
696 appParams = std::make_unique<MapMseParams>();
697 }
698 if (accountItem_.msgType_ == MessageType::IM) {
699 if (!CheckConversationId(appParams->conversationId_)) {
700 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_FOUND));
701 return;
702 }
703 auto result = stub::MapService::GetInstance()->GetOwnerStatus(appParams->conversationId_);
704 ObexTlvParamters obexAppPrarams;
705 uint8_t presenceAvlt = result.presenceAvailability;
706 std::string presenceText = result.presenceText;
707 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_PRESENCE_AVAILABILITY, presenceAvlt));
708 obexAppPrarams.AppendTlvtriplet(
709 TlvTriplet(MapMseParams::PARAM_PRESENCE_TEXT, presenceText.size(),
710 reinterpret_cast<uint8_t *>(const_cast<char *>(presenceText.c_str()))));
711 if (appParams->conversationId_.size() > 0) {
712 std::string lastActivity = result.lastActivity;
713 uint8_t chatState = result.chatState;
714 obexAppPrarams.AppendTlvtriplet(TlvTriplet(
715 MapMseParams::PARAM_LAST_ACTIVITY, static_cast<uint8_t>(lastActivity.size()),
716 reinterpret_cast<uint8_t *>(const_cast<char *>(lastActivity.c_str()))));
717 obexAppPrarams.AppendTlvtriplet(TlvTriplet(MapMseParams::PARAM_CHAT_STATE, chatState));
718 }
719 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
720 resHeader->AppendItemAppParams(obexAppPrarams);
721 session.SendResponse(*resHeader);
722 return;
723 }
724 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
725 }
726
GetMASInstanceInformation(ObexServerSession & session,const ObexHeader & req)727 void MapMseServer::GetMASInstanceInformation(ObexServerSession &session, const ObexHeader &req)
728 {
729 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
730
731 std::unique_ptr<MapMseParams> appParams = nullptr;
732 if (req.GetItemAppParams()) {
733 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
734 } else {
735 appParams = std::make_unique<MapMseParams>();
736 }
737 if (instance_.GetMasId() == *appParams->masInstanceId_) {
738 std::string masStr;
739 std::string ownerUci;
740 GetImEmailMasInfo(masStr, ownerUci);
741 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
742 if (masStr.size() > MAP_MAS_INSTANCE_INFORMATION_LENGTH) {
743 masStr = masStr.substr(0, MAP_MAS_INSTANCE_INFORMATION_LENGTH);
744 }
745 auto bodyObj = std::make_shared<ObexArrayBodyObject>();
746 bodyObj->Write((uint8_t *)masStr.data(), masStr.size());
747 ObexTlvParamters obexAppPrarams;
748 obexAppPrarams.AppendTlvtriplet(
749 TlvTriplet(MapMseParams::PARAM_OWNER_UCI, static_cast<uint8_t>(ownerUci.size()),
750 reinterpret_cast<uint8_t *>(ownerUci.data())));
751 resHeader->AppendItemAppParams(obexAppPrarams);
752 session.SendGetResponse(req, *resHeader, bodyObj);
753 return;
754 } else {
755 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::BAD_REQUEST));
756 return;
757 }
758 }
759
GetImEmailMasInfo(std::string & masStr,std::string & ownerUci)760 void MapMseServer::GetImEmailMasInfo(std::string &masStr, std::string &ownerUci)
761 {
762 if (accountItem_.id_ != "") {
763 if (MessageType::EMAIL == accountItem_.msgType_) {
764 if (accountItem_.name_ != "") {
765 masStr = accountItem_.name_;
766 } else {
767 masStr = EMAIL_NAME;
768 }
769 } else if (MessageType::IM == accountItem_.msgType_) {
770 masStr = accountItem_.GetUciFullName();
771 if (masStr == "") {
772 std::stringstream ss;
773 ss << std::setw(0x3) << static_cast<int>(instance_.GetMasId());
774 masStr = "un" + ss.str() + accountItem_.uci_;
775 }
776 }
777 ownerUci = accountItem_.GetUciFullName();
778 } else {
779 masStr.append(SMS_MMS_NAME + "_TEL_");
780 masStr.append(stub::MapService::GetInstance()->GetSystemTelephonyService().phoneNumber);
781 ownerUci = stub::MapService::GetInstance()->GetSystemTelephonyService().phoneNumber;
782 }
783 }
784
SetNotificationRegistration(const ObexServerSession & session,const ObexHeader & req)785 void MapMseServer::SetNotificationRegistration(const ObexServerSession &session, const ObexHeader &req)
786 {
787 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
788
789 std::unique_ptr<MapMseParams> appParams = nullptr;
790 if (req.GetItemAppParams()) {
791 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
792 } else {
793 appParams = std::make_unique<MapMseParams>();
794 }
795 if (!appParams->notificationStatus_) {
796 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
797 return;
798 }
799 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SUCCESS));
800 content_.SetNotificationRegistration(session.GetRemoteAddr(), *appParams->notificationStatus_);
801 }
802
SetNotificationFilter(const ObexServerSession & session,const ObexHeader & req)803 void MapMseServer::SetNotificationFilter(const ObexServerSession &session, const ObexHeader &req)
804 {
805 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
806
807 std::unique_ptr<MapMseParams> appParams = nullptr;
808 if (req.GetItemAppParams()) {
809 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
810 } else {
811 appParams = std::make_unique<MapMseParams>();
812 }
813 if (appParams->notificationFilterMask_ == -1) {
814 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
815 return;
816 }
817 auto const &remoteAddr = session.GetRemoteAddr();
818 content_.SetNotificationFilter(remoteAddr, appParams->notificationFilterMask_);
819 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
820 session.SendResponse(*resHeader);
821 }
822
SetMessageStatus(const ObexServerSession & session,const ObexHeader & req)823 void MapMseServer::SetMessageStatus(const ObexServerSession &session, const ObexHeader &req)
824 {
825 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
826
827 std::string name;
828 if (req.GetItemName()->GetUnicodeText().size() != 0) {
829 name = ToUtf8String(req.GetItemName()->GetUnicodeText());
830 } else {
831 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_ACCEPTABLE));
832 return;
833 }
834 std::unique_ptr<MapMseParams> appParams = nullptr;
835 if (req.GetItemAppParams()) {
836 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
837 } else {
838 appParams = std::make_unique<MapMseParams>();
839 }
840 if (appParams->extendedData_ != "") {
841 if (!content_.SetExtendedData(name, appParams->extendedData_)) {
842 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
843 return;
844 }
845 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SUCCESS));
846 return;
847 }
848 if (!appParams->statusIndicator_ || !appParams->statusValue_) {
849 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
850 return;
851 }
852 if (static_cast<uint8_t>(StatusIndicator::SET_EXTENDED_DATA) == *appParams->statusIndicator_ &&
853 appParams->extendedData_.size() == 0) {
854 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
855 return;
856 }
857 MessageType messageType = ParseHandle(std::atol(name.c_str()));
858 if (static_cast<uint8_t>(StatusIndicator::READ_STATUS) == *appParams->statusIndicator_) {
859 if (!content_.SetMessageStatusRead(
860 name, messageType, currentFolder_->GetFullPath(), *appParams->statusValue_)) {
861 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
862 return;
863 }
864 } else if (static_cast<uint8_t>(StatusIndicator::DELETED_STATUS) == *appParams->statusIndicator_) {
865 if (!content_.SetMessageStatusDeleted(
866 name, messageType, currentFolder_->GetFullPath(), *appParams->statusValue_)) {
867 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
868 return;
869 }
870 }
871 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SUCCESS));
872 }
873
UpdateInbox(const ObexServerSession & session,const ObexHeader & req)874 void MapMseServer::UpdateInbox(const ObexServerSession &session, const ObexHeader &req)
875 {
876 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
877
878 if (accountItem_.id_.size() != 0) {
879 std::string name = MAP_MSE_FOLDER_NAME_INBOX;
880 if (req.GetItemName() != nullptr) {
881 if (req.GetItemName()->GetUnicodeText().size() != 0) {
882 name = ToUtf8String(req.GetItemName()->GetUnicodeText());
883 }
884 }
885 MapMseFolder *inboxFolder = currentFolder_->GetFolderByName(name);
886 if (inboxFolder == nullptr) {
887 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_IMPLEMENTED));
888 return;
889 }
890 if (accountItem_.pAuthority_.size() != 0) {
891 if (stub::MapService::GetInstance()->UpdateFolder(
892 accountItem_.id_, std::to_string(inboxFolder->GetFolderId()), instance_.GetMasId())) {
893 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SUCCESS));
894 return;
895 }
896 }
897 }
898 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_IMPLEMENTED));
899 }
900
SetStatusParam(const MapMseParams & appParams,stub::OwnerStatusParam & statusParam)901 int MapMseServer::SetStatusParam(const MapMseParams &appParams, stub::OwnerStatusParam &statusParam)
902 {
903 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
904
905 if (appParams.conversationId_.size() == 0 && appParams.presenceAvailability_ == nullptr &&
906 appParams.presenceText_.size() == 0 && appParams.lastActivity_.size() == 0 && appParams.chatState_ == nullptr) {
907 return RET_BAD_STATUS;
908 } else {
909 if (appParams.conversationId_ != "") {
910 if (!CheckConversationId(appParams.conversationId_)) {
911 return RET_NO_SUPPORT;
912 }
913 statusParam.conversationId = appParams.conversationId_;
914 }
915 if (appParams.presenceAvailability_) {
916 statusParam.presenceAvailability = *appParams.presenceAvailability_;
917 }
918 if (appParams.lastActivity_ != "") {
919 statusParam.lastActivity = appParams.lastActivity_;
920 }
921 if (appParams.chatState_) {
922 statusParam.chatState = *appParams.chatState_;
923 }
924 }
925 return BT_SUCCESS;
926 }
927
SetOwnerStatus(const ObexServerSession & session,const ObexHeader & req)928 void MapMseServer::SetOwnerStatus(const ObexServerSession &session, const ObexHeader &req)
929 {
930 MSE_LOG_INFO("%{public}s Enter", __PRETTY_FUNCTION__);
931
932 if (accountItem_.msgType_ == MessageType::IM) {
933 std::unique_ptr<MapMseParams> appParams = nullptr;
934 if (req.GetItemAppParams()) {
935 appParams = std::make_unique<MapMseParams>(*req.GetItemAppParams()->GetTlvParamters());
936 } else {
937 appParams = std::make_unique<MapMseParams>();
938 }
939 stub::OwnerStatusParam statusParam {};
940 auto ret = SetStatusParam(*appParams, statusParam);
941 if (ret == RET_BAD_STATUS) {
942 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::PRECONDITION_FAILED));
943 return;
944 } else if (ret == RET_NO_SUPPORT) {
945 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_FOUND));
946 return;
947 }
948
949 if (stub::MapService::GetInstance()->SetOwnerStatus(statusParam, instance_.GetMasId())) {
950 auto resHeader = ObexHeader::CreateResponse(ObexRspCode::SUCCESS);
951 session.SendResponse(*resHeader);
952 return;
953 } else {
954 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::NOT_IMPLEMENTED));
955 return;
956 }
957 }
958 session.SendResponse(*ObexHeader::CreateResponse(ObexRspCode::SERVICE_UNAVAILABLE));
959 }
960
ToUtf8String(std::u16string u16str)961 std::string MapMseServer::ToUtf8String(std::u16string u16str)
962 {
963 return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.to_bytes(u16str);
964 }
965
ToU16String(std::string str)966 std::u16string MapMseServer::ToU16String(std::string str)
967 {
968 return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> {}.from_bytes(str);
969 }
970
GetMseTime(void)971 std::string MapMseServer::GetMseTime(void)
972 {
973 time_t currTime;
974 time(&currTime);
975 struct tm utctm;
976 gmtime_r(&currTime, &utctm);
977 char buff[16];
978 strftime(buff, sizeof(buff), "%Y%m%{public}dT%H%M%{public}s", &utctm);
979 return std::string(buff);
980 }
981
ParseHandle(uint64_t handle)982 MessageType MapMseServer::ParseHandle(uint64_t handle)
983 {
984 if ((handle & MESSAGE_HANDLE_MMS_MASK) != 0) {
985 return MessageType::MMS;
986 }
987 if ((handle & MESSAGE_HANDLE_EMAIL_MASK) != 0) {
988 return MessageType::EMAIL;
989 }
990 if ((handle & MESSAGE_HANDLE_SMS_GSM_MASK) != 0) {
991 return MessageType::SMS_GSM;
992 }
993 if ((handle & MESSAGE_HANDLE_SMS_CDMA_MASK) != 0) {
994 return MessageType::SMS_CDMA;
995 }
996 if ((handle & MESSAGE_HANDLE_IM_MASK) != 0) {
997 return MessageType::IM;
998 }
999 return MessageType::NONE;
1000 }
1001
CheckConversationId(std::string id)1002 bool MapMseServer::CheckConversationId(std::string id)
1003 {
1004 auto dataProvider = DataAccess::GetConnection(DEFAULT_MAP_MSE_DB_FILE);
1005 std::string sql = "select id from Conversation where convo_id = ? ";
1006 auto stmt = dataProvider->CreateStatement(sql);
1007 stmt->SetParamString(1, id);
1008 auto dataResult = stmt->Query();
1009 return dataResult->Next();
1010 }
1011
LoadAdapterConfig()1012 void MapMseServer::LoadAdapterConfig()
1013 {
1014 IAdapterConfig *adpterConfig = AdapterConfig::GetInstance();
1015 if (!adpterConfig->GetValue(SECTION_MAP_MSE_SERVICE, PROPERTY_SRM_ENABLE, srmEnable_)) {
1016 MSE_LOG_INFO("Load config %{public}s failure", PROPERTY_SRM_ENABLE.c_str());
1017 srmEnable_ = true;
1018 }
1019 if (!adpterConfig->GetValue(SECTION_MAP_MSE_SERVICE, PROPERTY_RFCOMM_MTU, rfcommMtu_)) {
1020 MSE_LOG_INFO("Load config %{public}s failure", PROPERTY_RFCOMM_MTU.c_str());
1021 rfcommMtu_ = OBEX_DEFAULT_MTU;
1022 }
1023 if (!adpterConfig->GetValue(SECTION_MAP_MSE_SERVICE, PROPERTY_L2CAP_MTU, l2capMtu_)) {
1024 MSE_LOG_INFO("Load config %{public}s failure", PROPERTY_L2CAP_MTU.c_str());
1025 l2capMtu_ = OBEX_DEFAULT_MTU;
1026 }
1027 }
1028 } // namespace bluetooth
1029 } // namespace OHOS