1 /*
2 * Copyright (c) 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 #include "schedule_node_builder.h"
16
17 #include <mutex>
18
19 #include "nocopyable.h"
20
21 #include "iam_logger.h"
22 #include "iam_ptr.h"
23 #include "iam_common_defines.h"
24
25 #define LOG_LABEL UserIam::Common::LABEL_USER_AUTH_SA
26
27 namespace OHOS {
28 namespace UserIam {
29 namespace UserAuth {
30 using Builder = ScheduleNode::Builder;
31
ScheduleNodeBuilder(const std::shared_ptr<ResourceNode> & collector,const std::shared_ptr<ResourceNode> & verifier)32 ScheduleNodeBuilder::ScheduleNodeBuilder(const std::shared_ptr<ResourceNode> &collector,
33 const std::shared_ptr<ResourceNode> &verifier)
34 : collector_(collector),
35 verifier_(verifier)
36 {
37 if (collector) {
38 info_.authType = collector->GetAuthType();
39 }
40 }
41
SetScheduleId(uint64_t scheduleId)42 std::shared_ptr<Builder> ScheduleNodeBuilder::SetScheduleId(uint64_t scheduleId)
43 {
44 info_.scheduleId = scheduleId;
45 return shared_from_this();
46 }
47
SetAccessTokenId(uint32_t tokenId)48 std::shared_ptr<Builder> ScheduleNodeBuilder::SetAccessTokenId(uint32_t tokenId)
49 {
50 info_.tokenId = tokenId;
51 return shared_from_this();
52 }
53
SetPinSubType(PinSubType pinSubType)54 std::shared_ptr<Builder> ScheduleNodeBuilder::SetPinSubType(PinSubType pinSubType)
55 {
56 info_.pinSubType = pinSubType;
57 return shared_from_this();
58 }
59
SetTemplateIdList(const std::vector<uint64_t> & templateIdList)60 std::shared_ptr<Builder> ScheduleNodeBuilder::SetTemplateIdList(const std::vector<uint64_t> &templateIdList)
61 {
62 info_.templateIdList = templateIdList;
63 return shared_from_this();
64 }
65
SetAuthType(AuthType authType)66 std::shared_ptr<Builder> ScheduleNodeBuilder::SetAuthType(AuthType authType)
67 {
68 info_.authType = authType;
69 return shared_from_this();
70 }
71
SetExecutorMatcher(uint32_t executorMatcher)72 std::shared_ptr<Builder> ScheduleNodeBuilder::SetExecutorMatcher(uint32_t executorMatcher)
73 {
74 info_.executorMatcher = executorMatcher;
75 return shared_from_this();
76 }
77
SetScheduleMode(ScheduleMode scheduleMode)78 std::shared_ptr<Builder> ScheduleNodeBuilder::SetScheduleMode(ScheduleMode scheduleMode)
79 {
80 info_.scheduleMode = scheduleMode;
81 return shared_from_this();
82 }
83
SetScheduleCallback(const std::shared_ptr<ScheduleNodeCallback> & callback)84 std::shared_ptr<Builder> ScheduleNodeBuilder::SetScheduleCallback(const std::shared_ptr<ScheduleNodeCallback> &callback)
85 {
86 info_.callback = callback;
87 return shared_from_this();
88 }
89
SetExpiredTime(uint32_t ms)90 std::shared_ptr<Builder> ScheduleNodeBuilder::SetExpiredTime(uint32_t ms)
91 {
92 info_.expiredTime = ms;
93 return shared_from_this();
94 }
95
SetParametersAttributes(const std::shared_ptr<Attributes> & parameters)96 std::shared_ptr<Builder> ScheduleNodeBuilder::SetParametersAttributes(const std::shared_ptr<Attributes> ¶meters)
97 {
98 info_.parameters = parameters;
99 return shared_from_this();
100 }
101
SetThreadHandler(const std::shared_ptr<ThreadHandler> & threadHandler)102 std::shared_ptr<Builder> ScheduleNodeBuilder::SetThreadHandler(const std::shared_ptr<ThreadHandler> &threadHandler)
103 {
104 info_.threadHandler = threadHandler;
105 return shared_from_this();
106 }
107
Build()108 std::shared_ptr<ScheduleNode> ScheduleNodeBuilder::Build()
109 {
110 if (!CheckParameters()) {
111 IAM_LOGE("checkParameters error");
112 return nullptr;
113 }
114 IAM_LOGI("scheduleNode builder start to build");
115 info_.collector = collector_;
116 info_.verifier = verifier_;
117 return Common::MakeShared<ScheduleNodeImpl>(info_);
118 }
119
CheckParameters() const120 bool ScheduleNodeBuilder::CheckParameters() const
121 {
122 if (collector_ && collector_->GetAuthType() != info_.authType) {
123 IAM_LOGE("authType mismatch");
124 return false;
125 }
126 return true;
127 }
128
CheckExecutors(const std::shared_ptr<ResourceNode> & collector,const std::shared_ptr<ResourceNode> & verifier)129 bool ScheduleNodeBuilder::CheckExecutors(const std::shared_ptr<ResourceNode> &collector,
130 const std::shared_ptr<ResourceNode> &verifier)
131 {
132 if (!collector) {
133 IAM_LOGE("collector not set");
134 return false;
135 }
136
137 if (!verifier) {
138 IAM_LOGE("verifier not set");
139 return false;
140 }
141
142 if (collector->GetAuthType() != verifier->GetAuthType()) {
143 IAM_LOGE("collector_ && verifier authtype mismatch");
144 return false;
145 }
146
147 if (collector->GetExecutorMatcher() != verifier->GetExecutorMatcher()) {
148 IAM_LOGE("executorType mismatch");
149 return false;
150 }
151
152 // all in one
153 if (collector == verifier && collector->GetExecutorRole() == ALL_IN_ONE) {
154 return true;
155 }
156
157 if (collector->GetExecutorRole() == COLLECTOR && verifier->GetExecutorRole() == VERIFIER) {
158 return true;
159 }
160
161 IAM_LOGE("executor role type mismatch");
162 return false;
163 }
164
New(const std::shared_ptr<ResourceNode> & collector,const std::shared_ptr<ResourceNode> & verifier)165 std::shared_ptr<Builder> Builder::New(const std::shared_ptr<ResourceNode> &collector,
166 const std::shared_ptr<ResourceNode> &verifier)
167 {
168 auto result = ScheduleNodeBuilder::CheckExecutors(collector, verifier);
169 if (!result) {
170 IAM_LOGE("checkExecutors failed");
171 return nullptr;
172 }
173
174 return Common::MakeShared<ScheduleNodeBuilder>(collector, verifier);
175 }
176 } // namespace UserAuth
177 } // namespace UserIam
178 } // namespace OHOS
179