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 16 #include "auth_request_state.h" 17 18 #include "dm_auth_manager.h" 19 #include "dm_constants.h" 20 21 namespace OHOS { 22 namespace DistributedHardware { Leave()23int32_t AuthRequestState::Leave() 24 { 25 return DM_OK; 26 } 27 SetAuthManager(std::shared_ptr<DmAuthManager> authManager)28int32_t AuthRequestState::SetAuthManager(std::shared_ptr<DmAuthManager> authManager) 29 { 30 authManager_ = std::move(authManager); 31 return DM_OK; 32 } 33 SetAuthContext(std::shared_ptr<DmAuthRequestContext> context)34int32_t AuthRequestState::SetAuthContext(std::shared_ptr<DmAuthRequestContext> context) 35 { 36 context_ = std::move(context); 37 return DM_OK; 38 } 39 GetAuthContext()40std::shared_ptr<DmAuthRequestContext> AuthRequestState::GetAuthContext() 41 { 42 return context_; 43 } 44 TransitionTo(std::shared_ptr<AuthRequestState> state)45int32_t AuthRequestState::TransitionTo(std::shared_ptr<AuthRequestState> state) 46 { 47 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 48 if (stateAuthManager == nullptr) { 49 LOGE("AuthRequestState::authManager_ null"); 50 return ERR_DM_FAILED; 51 } 52 if (state == nullptr) { 53 LOGE("AuthRequestState::state null"); 54 return ERR_DM_FAILED; 55 } 56 if (context_ == nullptr) { 57 LOGE("AuthRequestState::Enter context_ is null"); 58 return ERR_DM_FAILED; 59 } 60 state->SetAuthManager(stateAuthManager); 61 stateAuthManager->SetAuthRequestState(state); 62 state->SetAuthContext(context_); 63 this->Leave(); 64 state->Enter(); 65 return DM_OK; 66 } 67 GetStateType()68int32_t AuthRequestInitState::GetStateType() 69 { 70 return AuthState::AUTH_REQUEST_INIT; 71 } 72 Enter()73int32_t AuthRequestInitState::Enter() 74 { 75 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 76 if (stateAuthManager == nullptr) { 77 LOGE("AuthRequestInitState::Enter authManager_ is null"); 78 return ERR_DM_FAILED; 79 } 80 if (context_ == nullptr) { 81 LOGE("AuthRequestInitState::Enter context_ is null"); 82 return ERR_DM_FAILED; 83 } 84 stateAuthManager->EstablishAuthChannel(context_->deviceId); 85 return DM_OK; 86 } 87 GetStateType()88int32_t AuthRequestNegotiateState::GetStateType() 89 { 90 return AuthState::AUTH_REQUEST_NEGOTIATE; 91 } 92 Enter()93int32_t AuthRequestNegotiateState::Enter() 94 { 95 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 96 if (stateAuthManager == nullptr) { 97 LOGE("AuthRequestNegotiateState::Enter authManager_ is null"); 98 return ERR_DM_FAILED; 99 } 100 if (context_ == nullptr) { 101 LOGE("AuthRequestNegotiateState::Enter context_ is null"); 102 return ERR_DM_FAILED; 103 } 104 stateAuthManager->StartNegotiate(context_->sessionId); 105 return DM_OK; 106 } 107 GetStateType()108int32_t AuthRequestNegotiateDoneState::GetStateType() 109 { 110 return AuthState::AUTH_REQUEST_NEGOTIATE_DONE; 111 } 112 Enter()113int32_t AuthRequestNegotiateDoneState::Enter() 114 { 115 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 116 if (stateAuthManager == nullptr) { 117 LOGE("AuthRequestNegotiateDoneState::Enter authManager_ is null"); 118 return ERR_DM_FAILED; 119 } 120 if (context_ == nullptr) { 121 LOGE("AuthRequestNegotiateDoneState::Enter context_ is null"); 122 return ERR_DM_FAILED; 123 } 124 stateAuthManager->SendAuthRequest(context_->sessionId); 125 return DM_OK; 126 } 127 GetStateType()128int32_t AuthRequestReplyState::GetStateType() 129 { 130 return AuthState::AUTH_REQUEST_REPLY; 131 } 132 Enter()133int32_t AuthRequestReplyState::Enter() 134 { 135 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 136 if (stateAuthManager == nullptr) { 137 LOGE("AuthRequestReplyState::Enter authManager_ is null"); 138 return ERR_DM_FAILED; 139 } 140 stateAuthManager->StartRespAuthProcess(); 141 return DM_OK; 142 } 143 GetStateType()144int32_t AuthRequestJoinState::GetStateType() 145 { 146 return AuthState::AUTH_REQUEST_JOIN; 147 } 148 Enter()149int32_t AuthRequestJoinState::Enter() 150 { 151 LOGI("DmAuthManager::AuthRequestJoinState"); 152 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 153 if (stateAuthManager == nullptr) { 154 LOGE("AuthRequestJoinState::Enter authManager_ is null"); 155 return ERR_DM_FAILED; 156 } 157 if (context_ == nullptr) { 158 LOGE("AuthRequestJoinState::Enter context_ is null"); 159 return ERR_DM_FAILED; 160 } 161 stateAuthManager->AddMember(context_->deviceId); 162 return DM_OK; 163 } 164 GetStateType()165int32_t AuthRequestNetworkState::GetStateType() 166 { 167 return AuthState::AUTH_REQUEST_NETWORK; 168 } 169 Enter()170int32_t AuthRequestNetworkState::Enter() 171 { 172 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 173 if (stateAuthManager == nullptr) { 174 LOGE("AuthRequestNetworkState::Enter authManager_ is null"); 175 return ERR_DM_FAILED; 176 } 177 stateAuthManager->JoinNetwork(); 178 return DM_OK; 179 } 180 GetStateType()181int32_t AuthRequestFinishState::GetStateType() 182 { 183 return AuthState::AUTH_REQUEST_FINISH; 184 } 185 Enter()186int32_t AuthRequestFinishState::Enter() 187 { 188 std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock(); 189 if (stateAuthManager == nullptr) { 190 LOGE("AuthRequestFinishState::Enter authManager_ is null"); 191 return ERR_DM_FAILED; 192 } 193 stateAuthManager->AuthenticateFinish(); 194 return DM_OK; 195 } 196 } // namespace DistributedHardware 197 } // namespace OHOS 198