1 /*
2 * Copyright (c) 2021-2022 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 "device_info_repository.h"
17
18 namespace OHOS {
19 namespace Security {
20 namespace AccessToken {
21 namespace {
22 std::recursive_mutex g_instanceMutex;
23 }
GetInstance()24 DeviceInfoRepository &DeviceInfoRepository::GetInstance()
25 {
26 static DeviceInfoRepository* instance = nullptr;
27 if (instance == nullptr) {
28 std::lock_guard<std::recursive_mutex> lock(g_instanceMutex);
29 if (instance == nullptr) {
30 instance = new DeviceInfoRepository();
31 }
32 }
33 return *instance;
34 }
35
ListDeviceInfo()36 std::vector<DeviceInfo> DeviceInfoRepository::ListDeviceInfo()
37 {
38 std::lock_guard<std::recursive_mutex> guard(stackLock_);
39 std::vector<DeviceInfo> deviceInfo;
40
41 std::map<std::string, DeviceInfo>::iterator it;
42 std::map<std::string, DeviceInfo>::iterator itEnd;
43 it = deviceInfoMap_.begin();
44 itEnd = deviceInfoMap_.end();
45 while (it != itEnd) {
46 deviceInfo.push_back(it->second);
47 ++it;
48 }
49 return deviceInfo;
50 }
51
FindDeviceInfo(const std::string & nodeId,DeviceIdType type,DeviceInfo & deviceInfo)52 bool DeviceInfoRepository::FindDeviceInfo(const std::string &nodeId, DeviceIdType type, DeviceInfo &deviceInfo)
53 {
54 std::lock_guard<std::recursive_mutex> guard(stackLock_);
55 DeviceId deviceId;
56 if (FindDeviceIdByNodeIdLocked(nodeId, type, deviceId)) {
57 return FindDeviceInfoByDeviceIdLocked(deviceId, deviceInfo);
58 }
59 return false;
60 }
61
FindDeviceIdByNodeIdLocked(const std::string & nodeId,const DeviceIdType type,DeviceId & deviceId) const62 bool DeviceInfoRepository::FindDeviceIdByNodeIdLocked(
63 const std::string &nodeId, const DeviceIdType type, DeviceId &deviceId) const
64 {
65 if (type == DeviceIdType::NETWORK_ID) {
66 return FindDeviceIdByNetworkIdLocked(nodeId, deviceId);
67 } else if (type == DeviceIdType::UNIVERSALLY_UNIQUE_ID) {
68 return FindDeviceIdByUniversallyUniqueIdLocked(nodeId, deviceId);
69 } else if (type == DeviceIdType::UNIQUE_DISABILITY_ID) {
70 return FindDeviceIdByUniqueDeviceIdLocked(nodeId, deviceId);
71 } else if (type == DeviceIdType::UNKNOWN) {
72 if (FindDeviceIdByNetworkIdLocked(nodeId, deviceId)) {
73 return true;
74 } else if (FindDeviceIdByUniversallyUniqueIdLocked(nodeId, deviceId)) {
75 return true;
76 } else if (FindDeviceIdByUniqueDeviceIdLocked(nodeId, deviceId)) {
77 return true;
78 }
79 return false;
80 } else {
81 return false;
82 }
83 }
84
FindDeviceInfoByDeviceIdLocked(const DeviceId deviceId,DeviceInfo & deviceInfo) const85 bool DeviceInfoRepository::FindDeviceInfoByDeviceIdLocked(const DeviceId deviceId, DeviceInfo &deviceInfo) const
86 {
87 std::string deviceInfoKey = deviceId.networkId + deviceId.universallyUniqueId + deviceId.uniqueDeviceId;
88 if (deviceInfoMap_.count(deviceInfoKey) > 0) {
89 deviceInfo = deviceInfoMap_.at(deviceInfoKey);
90 return true;
91 }
92 return false;
93 }
94
FindDeviceIdByNetworkIdLocked(const std::string & networkId,DeviceId & deviceId) const95 bool DeviceInfoRepository::FindDeviceIdByNetworkIdLocked(const std::string &networkId, DeviceId &deviceId) const
96 {
97 if (deviceIdMapByNetworkId_.count(networkId) > 0) {
98 deviceId = deviceIdMapByNetworkId_.at(networkId);
99 return true;
100 }
101 return false;
102 }
103
FindDeviceIdByUniversallyUniqueIdLocked(const std::string & universallyUniqueId,DeviceId & deviceId) const104 bool DeviceInfoRepository::FindDeviceIdByUniversallyUniqueIdLocked(
105 const std::string &universallyUniqueId, DeviceId &deviceId) const
106 {
107 if (deviceIdMapByUniversallyUniqueId_.count(universallyUniqueId) > 0) {
108 deviceId = deviceIdMapByUniversallyUniqueId_.at(universallyUniqueId);
109 return true;
110 }
111 return false;
112 }
113
FindDeviceIdByUniqueDeviceIdLocked(const std::string & uniqueDeviceId,DeviceId & deviceId) const114 bool DeviceInfoRepository::FindDeviceIdByUniqueDeviceIdLocked(
115 const std::string &uniqueDeviceId, DeviceId &deviceId) const
116 {
117 if (deviceIdMapByUniqueDeviceId_.count(uniqueDeviceId) > 0) {
118 deviceId = deviceIdMapByUniqueDeviceId_.at(uniqueDeviceId);
119 return true;
120 }
121 return false;
122 }
123
DeleteAllDeviceInfoExceptOne(const DeviceInfo deviceInfo)124 void DeviceInfoRepository::DeleteAllDeviceInfoExceptOne(const DeviceInfo deviceInfo)
125 {
126 std::lock_guard<std::recursive_mutex> guard(stackLock_);
127 deviceIdMapByNetworkId_.clear();
128 deviceIdMapByUniversallyUniqueId_.clear();
129 deviceIdMapByUniqueDeviceId_.clear();
130 deviceInfoMap_.clear();
131 SaveDeviceInfo(deviceInfo);
132 }
133
SaveDeviceInfo(const DeviceInfo deviceInfo)134 void DeviceInfoRepository::SaveDeviceInfo(const DeviceInfo deviceInfo)
135 {
136 SaveDeviceInfo(deviceInfo.deviceId, deviceInfo.deviceName, deviceInfo.deviceType);
137 }
138
SaveDeviceInfo(const DeviceId deviceId,const std::string & deviceName,const std::string & deviceType)139 void DeviceInfoRepository::SaveDeviceInfo(
140 const DeviceId deviceId, const std::string &deviceName, const std::string &deviceType)
141 {
142 SaveDeviceInfo(
143 deviceId.networkId, deviceId.universallyUniqueId, deviceId.uniqueDeviceId, deviceName, deviceType);
144 }
145
SaveDeviceInfo(const std::string & networkId,const std::string & universallyUniqueId,const std::string & uniqueDeviceId,const std::string & deviceName,const std::string & deviceType)146 void DeviceInfoRepository::SaveDeviceInfo(const std::string &networkId, const std::string &universallyUniqueId,
147 const std::string &uniqueDeviceId, const std::string &deviceName, const std::string &deviceType)
148 {
149 std::lock_guard<std::recursive_mutex> guard(stackLock_);
150
151 DeleteDeviceInfo(networkId, DeviceIdType::NETWORK_ID);
152 DeleteDeviceInfo(universallyUniqueId, DeviceIdType::UNIVERSALLY_UNIQUE_ID);
153 DeleteDeviceInfo(uniqueDeviceId, DeviceIdType::UNIQUE_DISABILITY_ID);
154
155 DeviceId deviceId;
156 deviceId.networkId = networkId;
157 deviceId.universallyUniqueId = universallyUniqueId;
158 deviceId.uniqueDeviceId = uniqueDeviceId;
159
160 DeviceInfo deviceInfo;
161 deviceInfo.deviceId = deviceId;
162 deviceInfo.deviceName = deviceName;
163 deviceInfo.deviceType = deviceType;
164
165 const std::string deviceInfoKey = networkId + universallyUniqueId + uniqueDeviceId;
166 deviceIdMapByNetworkId_.insert(std::pair<std::string, DeviceId>(networkId, deviceId));
167 deviceIdMapByUniversallyUniqueId_.insert(std::pair<std::string, DeviceId>(universallyUniqueId, deviceId));
168 deviceIdMapByUniqueDeviceId_.insert(std::pair<std::string, DeviceId>(uniqueDeviceId, deviceId));
169 deviceInfoMap_.insert(std::pair<std::string, DeviceInfo>(deviceInfoKey, deviceInfo));
170 }
171
DeleteDeviceInfo(const std::string & nodeId,const DeviceIdType type)172 void DeviceInfoRepository::DeleteDeviceInfo(const std::string &nodeId, const DeviceIdType type)
173 {
174 std::lock_guard<std::recursive_mutex> guard(stackLock_);
175 DeviceId deviceId;
176 if (FindDeviceIdByNodeIdLocked(nodeId, type, deviceId)) {
177 DeleteDeviceInfoByDeviceIdLocked(deviceId);
178 }
179 }
180
DeleteDeviceInfoByDeviceIdLocked(const DeviceId deviceId)181 void DeviceInfoRepository::DeleteDeviceInfoByDeviceIdLocked(const DeviceId deviceId)
182 {
183 deviceIdMapByNetworkId_.erase(deviceId.networkId);
184 deviceIdMapByUniversallyUniqueId_.erase(deviceId.universallyUniqueId);
185 deviceIdMapByUniqueDeviceId_.erase(deviceId.uniqueDeviceId);
186 const std::string deviceInfoKey = deviceId.networkId + deviceId.universallyUniqueId + deviceId.uniqueDeviceId;
187 deviceInfoMap_.erase(deviceInfoKey);
188 }
189
Clear()190 void DeviceInfoRepository::Clear()
191 {
192 std::lock_guard<std::recursive_mutex> guard(stackLock_);
193 deviceIdMapByNetworkId_.clear();
194 deviceIdMapByUniversallyUniqueId_.clear();
195 deviceIdMapByUniqueDeviceId_.clear();
196 deviceInfoMap_.clear();
197 }
198 } // namespace AccessToken
199 } // namespace Security
200 } // namespace OHOS
201