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 "network/devsl_dispatcher.h"
17 #include "ipc/i_daemon.h"
18 #include "utils_log.h"
19
20 namespace OHOS {
21 namespace Storage {
22 namespace DistributedFile {
23 std::map<std::string, std::vector<std::weak_ptr<KernelTalker>>> DevslDispatcher::talkersMap_;
24 std::map<std::string, std::string> DevslDispatcher::idMap_;
25 std::mutex DevslDispatcher::mutex;
26
Start()27 int32_t DevslDispatcher::Start()
28 {
29 int32_t status = DATASL_OnStart();
30 if (status != 0) {
31 LOGE("devsl dispatcher start error %{public}d", status);
32 }
33
34 return status;
35 }
36
Stop()37 void DevslDispatcher::Stop()
38 {
39 DATASL_OnStop();
40 }
41
MakeDevslQueryParams(const std::string & udid)42 DEVSLQueryParams DevslDispatcher::MakeDevslQueryParams(const std::string &udid)
43 {
44 DEVSLQueryParams queryParams;
45 if (memcpy_s(queryParams.udid, MAX_UDID_LENGTH, udid.c_str(), udid.size())) {
46 LOGE("devsl dispatcher memcpy error");
47 }
48 queryParams.udidLen = udid.size();
49
50 return queryParams;
51 }
52
DevslGetRegister(const std::string & cid,std::weak_ptr<KernelTalker> talker)53 uint32_t DevslDispatcher::DevslGetRegister(const std::string &cid, std::weak_ptr<KernelTalker> talker)
54 {
55 std::string udid;
56 auto &deviceManager = DistributedHardware::DeviceManager::GetInstance();
57 deviceManager.GetUdidByNetworkId(IDaemon::SERVICE_NAME, cid, udid);
58
59 std::lock_guard<std::mutex> lock(mutex);
60 DEVSLQueryParams queryParams = MakeDevslQueryParams(udid);
61 int status = DATASL_GetHighestSecLevelAsync(&queryParams, &DevslDispatcher::DevslGottonCallback);
62 if (status != 0) {
63 LOGE("devsl dispatcher register callback error %{public}d", status);
64 return 0;
65 }
66
67 idMap_[udid] = cid;
68 auto iter = talkersMap_.find(udid);
69 if (iter == talkersMap_.end()) {
70 std::vector<std::weak_ptr<KernelTalker>> talkers;
71 talkers.push_back(talker);
72 talkersMap_.emplace(udid, talkers);
73 } else {
74 iter->second.push_back(talker);
75 }
76
77 return 0;
78 }
79
DevslGottonCallbackAsync(const std::string udid,uint32_t devsl)80 void DevslDispatcher::DevslGottonCallbackAsync(const std::string udid, uint32_t devsl)
81 {
82 std::lock_guard<std::mutex> lock(mutex);
83
84 auto it = talkersMap_.find(udid);
85 if (it == talkersMap_.end()) {
86 LOGE("devsl dispatcher callback, there is no talker");
87 return;
88 }
89
90 for (auto talker : it->second) {
91 auto realTalker = talker.lock();
92 if (!realTalker) {
93 continue;
94 }
95
96 auto iter = idMap_.find(udid);
97 if (iter != idMap_.end()) {
98 realTalker->SinkDevslTokernel(iter->second, devsl);
99 }
100 }
101
102 talkersMap_.erase(it);
103 }
104
DevslGottonCallback(DEVSLQueryParams * queryParams,int32_t result,uint32_t levelInfo)105 void DevslDispatcher::DevslGottonCallback(DEVSLQueryParams *queryParams, int32_t result, uint32_t levelInfo)
106 {
107 LOGI("devsl dispatcher callback");
108 if (result != 0) {
109 levelInfo = DATA_SEC_LEVEL1;
110 LOGE("devsl dispatcher dsl get callback result : %{public}d", result);
111 }
112
113 std::string udid(reinterpret_cast<char*>(queryParams->udid), queryParams->udidLen);
114 std::thread callbackThread = std::thread(DevslDispatcher::DevslGottonCallbackAsync, udid, levelInfo);
115 callbackThread.detach();
116 }
117 } // namespace DistributedFile
118 } // namespace Storage
119 } // namespace OHOS
120