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