1 /*
2 * Copyright (c) 2024 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 #define LOG_TAG "DataProviderConfig"
16 
17 #include "data_provider_config.h"
18 
19 #include <vector>
20 
21 #include "accesstoken_kit.h"
22 #include "account/account_delegate.h"
23 #include "datashare_errno.h"
24 #include "hap_token_info.h"
25 #include "log_print.h"
26 #include "strategies/general/load_config_common_strategy.h"
27 #include "uri_utils.h"
28 #include "utils/anonymous.h"
29 
30 namespace OHOS::DataShare {
31 using namespace OHOS::DistributedData;
DataProviderConfig(const std::string & uri,uint32_t callerTokenId)32 DataProviderConfig::DataProviderConfig(const std::string &uri, uint32_t callerTokenId)
33 {
34     providerInfo_.uri = uri;
35     providerInfo_.currentUserId = DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(callerTokenId);
36     URIUtils::GetAppIndexFromProxyURI(providerInfo_.uri, providerInfo_.appIndex);
37     if (providerInfo_.currentUserId == 0) {
38         LoadConfigCommonStrategy::GetInfoFromProxyURI(providerInfo_.uri, providerInfo_.currentUserId,
39             callerTokenId, providerInfo_.bundleName);
40         URIUtils::FormatUri(providerInfo_.uri);
41     }
42     uriConfig_ = URIUtils::GetUriConfig(providerInfo_.uri);
43 }
44 
GetBundleInfo()45 std::pair<int, BundleConfig> DataProviderConfig::GetBundleInfo()
46 {
47     BundleConfig bundleInfo;
48     providerInfo_.bundleName = uriConfig_.authority;
49     if (providerInfo_.bundleName.empty()) {
50         if (uriConfig_.pathSegments.empty()) {
51             return std::make_pair(E_URI_NOT_EXIST, bundleInfo);
52         }
53         providerInfo_.bundleName = uriConfig_.pathSegments[0];
54     }
55     auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
56         providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo, providerInfo_.appIndex);
57     return std::make_pair(ret, bundleInfo);
58 }
59 
GetFromProxyData()60 int DataProviderConfig::GetFromProxyData()
61 {
62     auto [errCode, bundleInfo] = GetBundleInfo();
63     if (errCode != E_OK) {
64         ZLOGE("Get bundleInfo failed! bundleName:%{public}s, userId:%{public}d, uri:%{public}s",
65             providerInfo_.bundleName.c_str(), providerInfo_.currentUserId,
66             URIUtils::Anonymous(providerInfo_.uri).c_str());
67         return errCode;
68     }
69     providerInfo_.singleton = bundleInfo.singleton;
70     for (auto &item : bundleInfo.extensionInfos) {
71         if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
72             continue;
73         }
74         providerInfo_.hasExtension = true;
75         break;
76     }
77     for (auto &hapModuleInfo : bundleInfo.hapModuleInfos) {
78         auto &proxyDatas = hapModuleInfo.proxyDatas;
79         std::sort(proxyDatas.begin(), proxyDatas.end(), [](const ProxyData &curr,
80             const ProxyData &prev) {
81             return curr.uri.length() > prev.uri.length();
82         });
83         for (auto &data : proxyDatas) {
84             if (data.uri.length() > uriConfig_.formatUri.length() ||
85                 uriConfig_.formatUri.compare(0, data.uri.length(), data.uri) != 0) {
86                 continue;
87             }
88             providerInfo_.readPermission = std::move(data.requiredReadPermission);
89             providerInfo_.writePermission = std::move(data.requiredWritePermission);
90             auto profileInfo = data.profileInfo;
91             if (profileInfo.resultCode == NOT_FOUND) {
92                 return E_OK;
93             }
94             if (profileInfo.resultCode == ERROR) {
95                 ZLOGE("Profile unmarshall error.uri: %{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
96                 return E_ERROR;
97             }
98             return GetFromDataProperties(profileInfo.profile, hapModuleInfo.moduleName);
99         }
100     }
101     return E_URI_NOT_EXIST;
102 }
103 
GetFromDataProperties(const ProfileInfo & profileInfo,const std::string & moduleName)104 int DataProviderConfig::GetFromDataProperties(const ProfileInfo &profileInfo,
105     const std::string &moduleName)
106 {
107     if (profileInfo.scope == MODULE_SCOPE) {
108         providerInfo_.moduleName = moduleName;
109     }
110     providerInfo_.storeName = profileInfo.storeName;
111     providerInfo_.tableName = profileInfo.tableName;
112     providerInfo_.type = profileInfo.type;
113     providerInfo_.storeMetaDataFromUri = profileInfo.storeMetaDataFromUri;
114     providerInfo_.backup = profileInfo.backup;
115     providerInfo_.extensionUri = profileInfo.extUri;
116     if (profileInfo.tableConfig.empty()) {
117         return E_OK;
118     }
119     return GetFromExtensionProperties(profileInfo, moduleName);
120 }
121 
GetFromExtensionProperties(const ProfileInfo & profileInfo,const std::string & moduleName)122 int DataProviderConfig::GetFromExtensionProperties(const ProfileInfo &profileInfo,
123     const std::string &moduleName)
124 {
125     std::string storeUri = URIUtils::DATA_SHARE_SCHEMA + providerInfo_.bundleName + URIUtils::URI_SEPARATOR +
126             moduleName + URIUtils::URI_SEPARATOR + providerInfo_.storeName;
127     std::string tableUri = storeUri + URIUtils::URI_SEPARATOR + providerInfo_.tableName;
128     providerInfo_.accessCrossMode = DataShareProfileConfig::GetAccessCrossMode(profileInfo, tableUri, storeUri);
129     if (providerInfo_.singleton && providerInfo_.accessCrossMode == AccessCrossMode::USER_UNDEFINED) {
130         ZLOGE("Single app must config user cross mode,bundleName:%{public}s, uri:%{public}s",
131             providerInfo_.bundleName.c_str(), URIUtils::Anonymous(providerInfo_.uri).c_str());
132         return E_ERROR;
133     }
134     if (providerInfo_.singleton && providerInfo_.accessCrossMode == AccessCrossMode::USER_SINGLE) {
135         providerInfo_.tableName.append("_").append(std::to_string(providerInfo_.currentUserId));
136     }
137     return E_OK;
138 }
139 
GetFromExtension()140 int DataProviderConfig::GetFromExtension()
141 {
142     if (!GetFromUriPath()) {
143         ZLOGE("Uri path failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
144         return E_URI_NOT_EXIST;
145     }
146     BundleConfig bundleInfo;
147     auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMS(
148         providerInfo_.bundleName, providerInfo_.currentUserId, bundleInfo, providerInfo_.appIndex);
149     if (ret != E_OK) {
150         ZLOGE("BundleInfo failed! bundleName: %{public}s", providerInfo_.bundleName.c_str());
151         return ret;
152     }
153     providerInfo_.singleton = bundleInfo.singleton;
154     providerInfo_.allowEmptyPermission = true;
155     for (auto &item : bundleInfo.extensionInfos) {
156         if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
157             continue;
158         }
159         providerInfo_.hasExtension = true;
160         providerInfo_.readPermission = std::move(item.readPermission);
161         providerInfo_.writePermission = std::move(item.writePermission);
162         auto profileInfo = item.profileInfo;
163         if (profileInfo.resultCode == NOT_FOUND) {
164             return E_OK;
165         }
166         if (profileInfo.resultCode == ERROR) {
167             ZLOGE("Profile Unmarshall failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
168             return E_ERROR;
169         }
170         return GetFromExtensionProperties(profileInfo.profile, providerInfo_.moduleName);
171     }
172     return E_URI_NOT_EXIST;
173 }
174 
GetFromUriPath()175 bool DataProviderConfig::GetFromUriPath()
176 {
177     auto& pathSegments = uriConfig_.pathSegments;
178     if (pathSegments.size() < static_cast<std::size_t>(PATH_PARAM::PARAM_SIZE) ||
179         pathSegments[static_cast<std::size_t>(PATH_PARAM::BUNDLE_NAME)].empty() ||
180         pathSegments[static_cast<std::size_t>(PATH_PARAM::MODULE_NAME)].empty() ||
181         pathSegments[static_cast<std::size_t>(PATH_PARAM::STORE_NAME)].empty() ||
182         pathSegments[static_cast<std::size_t>(PATH_PARAM::TABLE_NAME)].empty()) {
183         ZLOGE("Invalid uri ! uri: %{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
184         return false;
185     }
186     providerInfo_.bundleName = pathSegments[static_cast<std::size_t>(PATH_PARAM::BUNDLE_NAME)];
187     providerInfo_.moduleName = pathSegments[static_cast<std::size_t>(PATH_PARAM::MODULE_NAME)];
188     providerInfo_.storeName = pathSegments[static_cast<std::size_t>(PATH_PARAM::STORE_NAME)];
189     providerInfo_.tableName = pathSegments[static_cast<std::size_t>(PATH_PARAM::TABLE_NAME)];
190     return true;
191 }
192 
GetMetaDataFromUri()193 void DataProviderConfig::GetMetaDataFromUri()
194 {
195     if (!providerInfo_.storeMetaDataFromUri) {
196         return;
197     }
198     if (!GetFromUriPath()) {
199         ZLOGE("Uri path failed, not change metaData from uri! uri:%{public}s",
200             URIUtils::Anonymous(providerInfo_.uri).c_str());
201     }
202 }
203 
GetProviderInfo()204 std::pair<int, DataProviderConfig::ProviderInfo> DataProviderConfig::GetProviderInfo()
205 {
206     if (providerInfo_.appIndex == -1) {
207         return std::make_pair(E_APPINDEX_INVALID, providerInfo_);
208     }
209     auto ret = GetFromProxyData();
210     if (ret == E_OK) {
211         GetMetaDataFromUri();
212         return std::make_pair(ret, providerInfo_);
213     }
214     ret = GetFromExtension();
215     if (ret != E_OK) {
216         ZLOGE("Get providerInfo failed! ret: %{public}d, uri: %{public}s",
217             ret, URIUtils::Anonymous(providerInfo_.uri).c_str());
218     }
219     return std::make_pair(ret, providerInfo_);
220 }
221 } // namespace OHOS::DataShare
222