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