1 /* 2 * Copyright (c) 2021-2023 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 "app_account_stub.h" 17 18 #include "account_error_no.h" 19 #include "account_log_wrapper.h" 20 #include "app_account_constants.h" 21 #include "account_constants.h" 22 #include "ipc_skeleton.h" 23 #include "memory_guard.h" 24 #ifdef HICOLLIE_ENABLE 25 #include "xcollie/xcollie.h" 26 #endif // HICOLLIE_ENABLE 27 28 namespace OHOS { 29 namespace AccountSA { 30 #define RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(str, reply) \ 31 if (CheckSpecialCharacters(str) != ERR_OK) { \ 32 ACCOUNT_LOGE("fail to check special characters"); \ 33 if (!(reply).WriteInt32(ERR_ACCOUNT_COMMON_INVALID_PARAMETER)) { \ 34 ACCOUNT_LOGE("failed to write reply"); \ 35 return IPC_STUB_WRITE_PARCEL_ERR; \ 36 } \ 37 return ERR_NONE; \ 38 } \ 39 40 #define RETURN_IF_STRING_IS_OVERSIZE(str, maxSize, msg, reply) \ 41 if ((str).size() > (maxSize)) { \ 42 ACCOUNT_LOGE("%{public}s, input size: %{public}zu, max size: %{public}zu", msg, (str).size(), maxSize); \ 43 if (!(reply).WriteInt32(ERR_ACCOUNT_COMMON_INVALID_PARAMETER)) { \ 44 ACCOUNT_LOGE("failed to write reply"); \ 45 return IPC_STUB_WRITE_PARCEL_ERR; \ 46 } \ 47 return ERR_NONE; \ 48 } \ 49 50 #define RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(str, maxSize, msg, reply) \ 51 if ((str).empty() || ((str).size() > (maxSize))) { \ 52 ACCOUNT_LOGE("%{public}s, input size: %{public}zu, max size: %{public}zu", msg, (str).size(), maxSize); \ 53 if (!(reply).WriteInt32(ERR_ACCOUNT_COMMON_INVALID_PARAMETER)) { \ 54 ACCOUNT_LOGE("failed to write reply"); \ 55 return IPC_STUB_WRITE_PARCEL_ERR; \ 56 } \ 57 return ERR_NONE; \ 58 } \ 59 60 const std::map<uint32_t, AppAccountStub::MessageProcFunction> messageProcMap = { 61 { 62 static_cast<uint32_t>(AppAccountInterfaceCode::ADD_ACCOUNT), __anon506252a80102() 63 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 64 return ptr->ProcAddAccount(code, data, reply); } 65 }, 66 { 67 static_cast<uint32_t>(AppAccountInterfaceCode::ADD_ACCOUNT_IMPLICITLY), __anon506252a80202() 68 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 69 return ptr->ProcAddAccountImplicitly(code, data, reply); } 70 }, 71 { 72 static_cast<uint32_t>(AppAccountInterfaceCode::CREATE_ACCOUNT), __anon506252a80302() 73 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 74 return ptr->ProcCreateAccount(code, data, reply); } 75 }, 76 { 77 static_cast<uint32_t>(AppAccountInterfaceCode::CREATE_ACCOUNT_IMPLICITLY), __anon506252a80402() 78 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 79 return ptr->ProcCreateAccountImplicitly(code, data, reply); } 80 }, 81 { 82 static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_ACCOUNT), __anon506252a80502() 83 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 84 return ptr->ProcDeleteAccount(code, data, reply); } 85 }, 86 { 87 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ACCOUNT_EXTRA_INFO), __anon506252a80602() 88 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 89 return ptr->ProcGetAccountExtraInfo(code, data, reply); } 90 }, 91 { 92 static_cast<uint32_t>(AppAccountInterfaceCode::SET_ACCOUNT_EXTRA_INFO), __anon506252a80702() 93 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 94 return ptr->ProcSetAccountExtraInfo(code, data, reply); } 95 }, 96 { 97 static_cast<uint32_t>(AppAccountInterfaceCode::ENABLE_APP_ACCESS), __anon506252a80802() 98 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 99 return ptr->ProcSetAppAccess(code, data, reply); } 100 }, 101 { 102 static_cast<uint32_t>(AppAccountInterfaceCode::DISABLE_APP_ACCESS), __anon506252a80902() 103 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 104 return ptr->ProcSetAppAccess(code, data, reply); } 105 }, 106 { 107 static_cast<uint32_t>(AppAccountInterfaceCode::SET_APP_ACCESS), __anon506252a80a02() 108 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 109 return ptr->ProcSetAppAccess(code, data, reply); } 110 }, 111 { 112 static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_APP_ACCESS), __anon506252a80b02() 113 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 114 return ptr->ProcCheckAppAccess(code, data, reply); } 115 }, 116 { 117 static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_APP_ACCOUNT_SYNC_ENABLE), __anon506252a80c02() 118 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 119 return ptr->ProcCheckAppAccountSyncEnable(code, data, reply); } 120 }, 121 { 122 static_cast<uint32_t>(AppAccountInterfaceCode::SET_APP_ACCOUNT_SYNC_ENABLE), __anon506252a80d02() 123 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 124 return ptr->ProcSetAppAccountSyncEnable(code, data, reply); } 125 }, 126 { 127 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ASSOCIATED_DATA), __anon506252a80e02() 128 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 129 return ptr->ProcGetAssociatedData(code, data, reply); } 130 }, 131 { 132 static_cast<uint32_t>(AppAccountInterfaceCode::SET_ASSOCIATED_DATA), __anon506252a80f02() 133 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 134 return ptr->ProcSetAssociatedData(code, data, reply); } 135 }, 136 { 137 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ACCOUNT_CREDENTIAL), __anon506252a81002() 138 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 139 return ptr->ProcGetAccountCredential(code, data, reply); } 140 }, 141 { 142 static_cast<uint32_t>(AppAccountInterfaceCode::SET_ACCOUNT_CREDENTIAL), __anon506252a81102() 143 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 144 return ptr->ProcSetAccountCredential(code, data, reply); } 145 }, 146 { 147 static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_ACCOUNT_CREDENTIAL), __anon506252a81202() 148 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 149 return ptr->ProcDeleteAccountCredential(code, data, reply); } 150 }, 151 { 152 static_cast<uint32_t>(AppAccountInterfaceCode::AUTHENTICATE), __anon506252a81302() 153 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 154 return ptr->ProcAuthenticate(code, data, reply); } 155 }, 156 { 157 static_cast<uint32_t>(AppAccountInterfaceCode::GET_OAUTH_TOKEN), __anon506252a81402() 158 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 159 return ptr->ProcGetAuthToken(code, data, reply); } 160 }, 161 { 162 static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTH_TOKEN), __anon506252a81502() 163 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 164 return ptr->ProcGetAuthToken(code, data, reply); } 165 }, 166 { 167 static_cast<uint32_t>(AppAccountInterfaceCode::SET_OAUTH_TOKEN), __anon506252a81602() 168 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 169 return ptr->ProcSetOAuthToken(code, data, reply); } 170 }, 171 { 172 static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_OAUTH_TOKEN), __anon506252a81702() 173 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 174 return ptr->ProcDeleteAuthToken(code, data, reply); } 175 }, 176 { 177 static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_AUTH_TOKEN), __anon506252a81802() 178 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 179 return ptr->ProcDeleteAuthToken(code, data, reply); } 180 }, 181 { 182 static_cast<uint32_t>(AppAccountInterfaceCode::SET_OAUTH_TOKEN_VISIBILITY), __anon506252a81902() 183 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 184 return ptr->ProcSetAuthTokenVisibility(code, data, reply); } 185 }, 186 { 187 static_cast<uint32_t>(AppAccountInterfaceCode::SET_AUTH_TOKEN_VISIBILITY), __anon506252a81a02() 188 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 189 return ptr->ProcSetAuthTokenVisibility(code, data, reply); } 190 }, 191 { 192 static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_OAUTH_TOKEN_VISIBILITY), __anon506252a81b02() 193 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 194 return ptr->ProcCheckAuthTokenVisibility(code, data, reply); } 195 }, 196 { 197 static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_AUTH_TOKEN_VISIBILITY), __anon506252a81c02() 198 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 199 return ptr->ProcCheckAuthTokenVisibility(code, data, reply); } 200 }, 201 { 202 static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTHENTICATOR_CALLBACK), __anon506252a81d02() 203 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 204 return ptr->ProcGetAuthenticatorCallback(code, data, reply); } 205 }, 206 { 207 static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTHENTICATOR_INFO), __anon506252a81e02() 208 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 209 return ptr->ProcGetAuthenticatorInfo(code, data, reply); } 210 }, 211 { 212 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ALL_OAUTH_TOKENS), __anon506252a81f02() 213 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 214 return ptr->ProcGetAllOAuthTokens(code, data, reply); } 215 }, 216 { 217 static_cast<uint32_t>(AppAccountInterfaceCode::GET_OAUTH_LIST), __anon506252a82002() 218 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 219 return ptr->ProcGetAuthList(code, data, reply); } 220 }, 221 { 222 static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTH_LIST), __anon506252a82102() 223 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 224 return ptr->ProcGetAuthList(code, data, reply); } 225 }, 226 { 227 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ALL_ACCOUNTS), __anon506252a82202() 228 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 229 return ptr->ProcGetAllAccounts(code, data, reply); } 230 }, 231 { 232 static_cast<uint32_t>(AppAccountInterfaceCode::GET_ALL_ACCESSIBLE_ACCOUNTS), __anon506252a82302() 233 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 234 return ptr->ProcGetAllAccessibleAccounts(code, data, reply); } 235 }, 236 { 237 static_cast<uint32_t>(AppAccountInterfaceCode::QUERY_ALL_ACCESSIBLE_ACCOUNTS), __anon506252a82402() 238 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 239 return ptr->ProcGetAllAccessibleAccounts(code, data, reply); } 240 }, 241 { 242 static_cast<uint32_t>(AppAccountInterfaceCode::SELECT_ACCOUNTS_BY_OPTIONS), __anon506252a82502() 243 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 244 return ptr->ProcSelectAccountsByOptions(code, data, reply); } 245 }, 246 { 247 static_cast<uint32_t>(AppAccountInterfaceCode::VERIFY_CREDENTIAL), __anon506252a82602() 248 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 249 return ptr->ProcVerifyCredential(code, data, reply); } 250 }, 251 { 252 static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_ACCOUNT_LABELS), __anon506252a82702() 253 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 254 return ptr->ProcCheckAccountLabels(code, data, reply); } 255 }, 256 { 257 static_cast<uint32_t>(AppAccountInterfaceCode::SET_AUTHENTICATOR_PROPERTIES), __anon506252a82802() 258 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 259 return ptr->ProcSetAuthenticatorProperties(code, data, reply); } 260 }, 261 { 262 static_cast<uint32_t>(AppAccountInterfaceCode::SUBSCRIBE_ACCOUNT), __anon506252a82902() 263 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 264 return ptr->ProcSubscribeAccount(code, data, reply); } 265 }, 266 { 267 static_cast<uint32_t>(AppAccountInterfaceCode::UNSUBSCRIBE_ACCOUNT), __anon506252a82a02() 268 [] (AppAccountStub *ptr, uint32_t code, MessageParcel &data, MessageParcel &reply) { 269 return ptr->ProcUnsubscribeAccount(code, data, reply); } 270 }, 271 }; 272 AppAccountStub()273 AppAccountStub::AppAccountStub() 274 { 275 messageProcMap_ = messageProcMap; 276 } 277 ~AppAccountStub()278 AppAccountStub::~AppAccountStub() 279 {} 280 OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)281 int AppAccountStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 282 { 283 ACCOUNT_LOGD("Received stub message: %{public}d, callingUid: %{public}d", code, IPCSkeleton::GetCallingUid()); 284 MemoryGuard cacheGuard; 285 if (data.ReadInterfaceToken() != GetDescriptor()) { 286 ACCOUNT_LOGE("failed to check descriptor! code %{public}u.", code); 287 return ERR_ACCOUNT_COMMON_CHECK_DESCRIPTOR_ERROR; 288 } 289 290 #ifdef HICOLLIE_ENABLE 291 int timerId = 292 HiviewDFX::XCollie::GetInstance().SetTimer(TIMER_NAME, TIMEOUT, nullptr, nullptr, HiviewDFX::XCOLLIE_FLAG_LOG); 293 #endif // HICOLLIE_ENABLE 294 295 auto messageProc = messageProcMap_.find(code); 296 if (messageProc != messageProcMap_.end()) { 297 auto messageProcFunction = messageProc->second; 298 if (messageProcFunction != nullptr) { 299 int ret = (messageProcFunction)(this, code, data, reply); 300 #ifdef HICOLLIE_ENABLE 301 HiviewDFX::XCollie::GetInstance().CancelTimer(timerId); 302 #endif // HICOLLIE_ENABLE 303 return ret; 304 } 305 } 306 307 ACCOUNT_LOGD("end, code = %{public}u, flags = %{public}u", code, option.GetFlags()); 308 #ifdef HICOLLIE_ENABLE 309 HiviewDFX::XCollie::GetInstance().CancelTimer(timerId); 310 #endif // HICOLLIE_ENABLE 311 312 return IPCObjectStub::OnRemoteRequest(code, data, reply, option); 313 } 314 315 template<typename T> WriteParcelableVector(const std::vector<T> & parcelableVector,MessageParcel & data)316 bool AppAccountStub::WriteParcelableVector(const std::vector<T> &parcelableVector, MessageParcel &data) 317 { 318 if (!data.WriteUint32(parcelableVector.size())) { 319 ACCOUNT_LOGE("failed to WriteInt32 for parcelableVector.size()"); 320 return false; 321 } 322 323 for (const auto &parcelable : parcelableVector) { 324 if (!data.WriteParcelable(&parcelable)) { 325 ACCOUNT_LOGE("failed to WriteParcelable for parcelable"); 326 return false; 327 } 328 } 329 330 return true; 331 } 332 CheckSpecialCharacters(const std::string & str)333 static ErrCode CheckSpecialCharacters(const std::string &str) 334 { 335 for (auto specialCharacter : Constants::SPECIAL_CHARACTERS) { 336 std::size_t found = str.find(specialCharacter); 337 if (found != std::string::npos) { 338 ACCOUNT_LOGE("found a special character, specialCharacter = %{public}c", specialCharacter); 339 return ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 340 } 341 } 342 return ERR_OK; 343 } 344 ProcAddAccount(uint32_t code,MessageParcel & data,MessageParcel & reply)345 ErrCode AppAccountStub::ProcAddAccount(uint32_t code, MessageParcel &data, MessageParcel &reply) 346 { 347 std::string name = data.ReadString(); 348 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 349 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 350 std::string extraInfo = data.ReadString(); 351 RETURN_IF_STRING_IS_OVERSIZE(extraInfo, Constants::EXTRA_INFO_MAX_SIZE, "extraInfo is oversize", reply); 352 ErrCode result = AddAccount(name, extraInfo); 353 if (!reply.WriteInt32(result)) { 354 ACCOUNT_LOGE("failed to write reply"); 355 return IPC_STUB_WRITE_PARCEL_ERR; 356 } 357 return ERR_NONE; 358 } 359 ProcAddAccountImplicitly(uint32_t code,MessageParcel & data,MessageParcel & reply)360 ErrCode AppAccountStub::ProcAddAccountImplicitly(uint32_t code, MessageParcel &data, MessageParcel &reply) 361 { 362 std::string owner = data.ReadString(); 363 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 364 std::string authType = data.ReadString(); 365 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 366 std::shared_ptr<AAFwk::Want> options(data.ReadParcelable<AAFwk::Want>()); 367 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 368 ErrCode result = ERR_OK; 369 if ((options == nullptr) || (callback == nullptr)) { 370 ACCOUNT_LOGE("invalid options"); 371 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 372 } else { 373 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(options->GetStringParam(Constants::KEY_CALLER_ABILITY_NAME), 374 Constants::ABILITY_NAME_MAX_SIZE, "abilityName is empty or oversize", reply); 375 result = AddAccountImplicitly(owner, authType, *options, callback); 376 } 377 if (!reply.WriteInt32(result)) { 378 ACCOUNT_LOGE("failed to write reply"); 379 return IPC_STUB_WRITE_PARCEL_ERR; 380 } 381 return ERR_NONE; 382 } 383 ProcCreateAccount(uint32_t code,MessageParcel & data,MessageParcel & reply)384 ErrCode AppAccountStub::ProcCreateAccount(uint32_t code, MessageParcel &data, MessageParcel &reply) 385 { 386 std::string name = data.ReadString(); 387 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 388 sptr<CreateAccountOptions> options = data.ReadParcelable<CreateAccountOptions>(); 389 ErrCode result = ERR_OK; 390 if (options == nullptr) { 391 ACCOUNT_LOGE("invalid options"); 392 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 393 } else { 394 RETURN_IF_STRING_IS_OVERSIZE( 395 options->customData, Constants::MAX_CUSTOM_DATA_SIZE, "customData is oversize", reply); 396 for (const auto &it : options->customData) { 397 RETURN_IF_STRING_IS_OVERSIZE( 398 it.first, Constants::ASSOCIATED_KEY_MAX_SIZE, "customData key is oversize", reply); 399 RETURN_IF_STRING_IS_OVERSIZE( 400 it.second, Constants::ASSOCIATED_VALUE_MAX_SIZE, "customData value is oversize", reply); 401 } 402 result = CreateAccount(name, *options); 403 } 404 if (!reply.WriteInt32(result)) { 405 ACCOUNT_LOGE("failed to write reply"); 406 return IPC_STUB_WRITE_PARCEL_ERR; 407 } 408 return ERR_NONE; 409 } 410 ProcCreateAccountImplicitly(uint32_t code,MessageParcel & data,MessageParcel & reply)411 ErrCode AppAccountStub::ProcCreateAccountImplicitly(uint32_t code, MessageParcel &data, MessageParcel &reply) 412 { 413 std::string owner = data.ReadString(); 414 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 415 sptr<CreateAccountImplicitlyOptions> options = data.ReadParcelable<CreateAccountImplicitlyOptions>(); 416 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 417 ErrCode result = ERR_OK; 418 if ((options == nullptr) || (callback == nullptr)) { 419 ACCOUNT_LOGE("invalid options"); 420 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 421 } else { 422 RETURN_IF_STRING_IS_OVERSIZE( 423 options->authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is empty or oversize", reply); 424 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(options->parameters.GetStringParam(Constants::KEY_CALLER_ABILITY_NAME), 425 Constants::ABILITY_NAME_MAX_SIZE, "abilityName is empty or oversize", reply); 426 RETURN_IF_STRING_IS_OVERSIZE(options->requiredLabels, 427 Constants::MAX_ALLOWED_ARRAY_SIZE_INPUT, "requiredLabels array is oversize", reply); 428 result = CreateAccountImplicitly(owner, *options, callback); 429 } 430 if (!reply.WriteInt32(result)) { 431 ACCOUNT_LOGE("failed to write reply"); 432 return IPC_STUB_WRITE_PARCEL_ERR; 433 } 434 return ERR_NONE; 435 } 436 ProcDeleteAccount(uint32_t code,MessageParcel & data,MessageParcel & reply)437 ErrCode AppAccountStub::ProcDeleteAccount(uint32_t code, MessageParcel &data, MessageParcel &reply) 438 { 439 std::string name = data.ReadString(); 440 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 441 ErrCode result = DeleteAccount(name); 442 if (!reply.WriteInt32(result)) { 443 ACCOUNT_LOGE("failed to write reply"); 444 return IPC_STUB_WRITE_PARCEL_ERR; 445 } 446 447 return ERR_NONE; 448 } 449 ProcGetAccountExtraInfo(uint32_t code,MessageParcel & data,MessageParcel & reply)450 ErrCode AppAccountStub::ProcGetAccountExtraInfo(uint32_t code, MessageParcel &data, MessageParcel &reply) 451 { 452 std::string name = data.ReadString(); 453 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 454 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 455 std::string extraInfo; 456 ErrCode result = GetAccountExtraInfo(name, extraInfo); 457 if (!reply.WriteInt32(result)) { 458 ACCOUNT_LOGE("failed to write reply"); 459 return IPC_STUB_WRITE_PARCEL_ERR; 460 } 461 if (!reply.WriteString(extraInfo)) { 462 ACCOUNT_LOGE("failed to write string for extra info"); 463 return IPC_STUB_WRITE_PARCEL_ERR; 464 } 465 return ERR_NONE; 466 } 467 ProcSetAccountExtraInfo(uint32_t code,MessageParcel & data,MessageParcel & reply)468 ErrCode AppAccountStub::ProcSetAccountExtraInfo(uint32_t code, MessageParcel &data, MessageParcel &reply) 469 { 470 std::string name = data.ReadString(); 471 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 472 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 473 std::string extraInfo = data.ReadString(); 474 RETURN_IF_STRING_IS_OVERSIZE(extraInfo, Constants::EXTRA_INFO_MAX_SIZE, "extraInfo is oversize", reply); 475 ErrCode result = SetAccountExtraInfo(name, extraInfo); 476 if (!reply.WriteInt32(result)) { 477 ACCOUNT_LOGE("failed to write reply"); 478 return IPC_STUB_WRITE_PARCEL_ERR; 479 } 480 return ERR_NONE; 481 } 482 ProcSetAppAccess(uint32_t code,MessageParcel & data,MessageParcel & reply)483 ErrCode AppAccountStub::ProcSetAppAccess(uint32_t code, MessageParcel &data, MessageParcel &reply) 484 { 485 std::string name = data.ReadString(); 486 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 487 if (code != static_cast<uint32_t>(AppAccountInterfaceCode::SET_APP_ACCESS)) { 488 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 489 } 490 491 std::string authorizedApp = data.ReadString(); 492 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(authorizedApp, Constants::BUNDLE_NAME_MAX_SIZE, 493 "bundleName is empty or oversize", reply); 494 495 ErrCode result = ERR_OK; 496 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::ENABLE_APP_ACCESS)) { 497 result = EnableAppAccess(name, authorizedApp); 498 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::DISABLE_APP_ACCESS)) { 499 result = DisableAppAccess(name, authorizedApp); 500 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::SET_APP_ACCESS)) { 501 bool isAccessible = data.ReadBool(); 502 result = SetAppAccess(name, authorizedApp, isAccessible); 503 } else { 504 return IPC_INVOKER_ERR; 505 } 506 507 if (!reply.WriteInt32(result)) { 508 ACCOUNT_LOGE("failed to write result"); 509 return IPC_STUB_WRITE_PARCEL_ERR; 510 } 511 return ERR_NONE; 512 } 513 ProcCheckAppAccountSyncEnable(uint32_t code,MessageParcel & data,MessageParcel & reply)514 ErrCode AppAccountStub::ProcCheckAppAccountSyncEnable(uint32_t code, MessageParcel &data, MessageParcel &reply) 515 { 516 std::string name = data.ReadString(); 517 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 518 bool syncEnable = false; 519 ErrCode result = CheckAppAccountSyncEnable(name, syncEnable); 520 if (!reply.WriteInt32(result)) { 521 ACCOUNT_LOGE("failed to write reply"); 522 return IPC_STUB_WRITE_PARCEL_ERR; 523 } 524 if (!reply.WriteBool(syncEnable)) { 525 ACCOUNT_LOGE("failed to write bool for syncEnable"); 526 return IPC_STUB_WRITE_PARCEL_ERR; 527 } 528 return ERR_NONE; 529 } 530 ProcSetAppAccountSyncEnable(uint32_t code,MessageParcel & data,MessageParcel & reply)531 ErrCode AppAccountStub::ProcSetAppAccountSyncEnable(uint32_t code, MessageParcel &data, MessageParcel &reply) 532 { 533 std::string name = data.ReadString(); 534 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 535 bool syncEnable = data.ReadBool(); 536 ErrCode result = SetAppAccountSyncEnable(name, syncEnable); 537 if (!reply.WriteInt32(result)) { 538 ACCOUNT_LOGE("failed to write reply"); 539 return IPC_STUB_WRITE_PARCEL_ERR; 540 } 541 return ERR_NONE; 542 } 543 ProcGetAssociatedData(uint32_t code,MessageParcel & data,MessageParcel & reply)544 ErrCode AppAccountStub::ProcGetAssociatedData(uint32_t code, MessageParcel &data, MessageParcel &reply) 545 { 546 std::string name = data.ReadString(); 547 std::string key = data.ReadString(); 548 std::string value; 549 ErrCode result = GetAssociatedData(name, key, value); 550 if (!reply.WriteInt32(result)) { 551 ACCOUNT_LOGE("failed to write reply"); 552 return IPC_STUB_WRITE_PARCEL_ERR; 553 } 554 if (!reply.WriteString(value)) { 555 ACCOUNT_LOGE("failed to write string for value"); 556 return IPC_STUB_WRITE_PARCEL_ERR; 557 } 558 return ERR_NONE; 559 } 560 ProcSetAssociatedData(uint32_t code,MessageParcel & data,MessageParcel & reply)561 ErrCode AppAccountStub::ProcSetAssociatedData(uint32_t code, MessageParcel &data, MessageParcel &reply) 562 { 563 std::string name = data.ReadString(); 564 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 565 std::string key = data.ReadString(); 566 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(key, Constants::ASSOCIATED_KEY_MAX_SIZE, "key is empty or oversize", reply); 567 std::string value = data.ReadString(); 568 RETURN_IF_STRING_IS_OVERSIZE(value, Constants::ASSOCIATED_VALUE_MAX_SIZE, "value is oversize", reply); 569 ErrCode result = SetAssociatedData(name, key, value); 570 if (!reply.WriteInt32(result)) { 571 ACCOUNT_LOGE("failed to write reply"); 572 return IPC_STUB_WRITE_PARCEL_ERR; 573 } 574 return ERR_NONE; 575 } 576 ProcGetAccountCredential(uint32_t code,MessageParcel & data,MessageParcel & reply)577 ErrCode AppAccountStub::ProcGetAccountCredential(uint32_t code, MessageParcel &data, MessageParcel &reply) 578 { 579 std::string name = data.ReadString(); 580 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 581 std::string credentialType = data.ReadString(); 582 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(credentialType, Constants::CREDENTIAL_TYPE_MAX_SIZE, 583 "credentialType is empty or oversize", reply); 584 std::string credential; 585 ErrCode result = GetAccountCredential(name, credentialType, credential); 586 if (!reply.WriteInt32(result)) { 587 ACCOUNT_LOGE("failed to write reply"); 588 return IPC_STUB_WRITE_PARCEL_ERR; 589 } 590 if (!reply.WriteString(credential)) { 591 ACCOUNT_LOGE("failed to write string for credential"); 592 return IPC_STUB_WRITE_PARCEL_ERR; 593 } 594 return ERR_NONE; 595 } 596 ProcSetAccountCredential(uint32_t code,MessageParcel & data,MessageParcel & reply)597 ErrCode AppAccountStub::ProcSetAccountCredential(uint32_t code, MessageParcel &data, MessageParcel &reply) 598 { 599 std::string name = data.ReadString(); 600 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 601 std::string credentialType = data.ReadString(); 602 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(credentialType, Constants::CREDENTIAL_TYPE_MAX_SIZE, 603 "credentialType is empty or oversize", reply); 604 std::string credential = data.ReadString(); 605 RETURN_IF_STRING_IS_OVERSIZE(credential, Constants::CREDENTIAL_MAX_SIZE, "credential is oversize", reply); 606 ErrCode result = SetAccountCredential(name, credentialType, credential); 607 if (!reply.WriteInt32(result)) { 608 ACCOUNT_LOGE("failed to write reply"); 609 return IPC_STUB_WRITE_PARCEL_ERR; 610 } 611 return ERR_NONE; 612 } 613 ProcAuthenticate(uint32_t code,MessageParcel & data,MessageParcel & reply)614 ErrCode AppAccountStub::ProcAuthenticate(uint32_t code, MessageParcel &data, MessageParcel &reply) 615 { 616 std::string name = data.ReadString(); 617 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 618 std::string owner = data.ReadString(); 619 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 620 std::string authType = data.ReadString(); 621 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 622 std::shared_ptr<AAFwk::Want> options(data.ReadParcelable<AAFwk::Want>()); 623 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 624 ErrCode result = ERR_OK; 625 if ((options == nullptr) || (callback == nullptr)) { 626 ACCOUNT_LOGE("invalid options"); 627 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 628 } else { 629 RETURN_IF_STRING_IS_OVERSIZE(options->GetStringParam(Constants::KEY_CALLER_ABILITY_NAME), 630 Constants::ABILITY_NAME_MAX_SIZE, "abilityName is empty or oversize", reply); 631 result = Authenticate(name, owner, authType, *options, callback); 632 } 633 if (!reply.WriteInt32(result)) { 634 ACCOUNT_LOGE("failed to write reply"); 635 return IPC_STUB_WRITE_PARCEL_ERR; 636 } 637 return ERR_NONE; 638 } 639 ProcGetAuthToken(uint32_t code,MessageParcel & data,MessageParcel & reply)640 ErrCode AppAccountStub::ProcGetAuthToken(uint32_t code, MessageParcel &data, MessageParcel &reply) 641 { 642 std::string name = data.ReadString(); 643 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 644 std::string owner = data.ReadString(); 645 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 646 std::string authType = data.ReadString(); 647 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 648 std::string token; 649 ErrCode result = ERR_OK; 650 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::GET_OAUTH_TOKEN)) { 651 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 652 result = GetOAuthToken(name, owner, authType, token); 653 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTH_TOKEN)) { 654 result = GetAuthToken(name, owner, authType, token); 655 } else { 656 ACCOUNT_LOGE("stub code is invalid"); 657 return IPC_INVOKER_ERR; 658 } 659 if ((!reply.WriteInt32(result)) || (!reply.WriteString(token))) { 660 ACCOUNT_LOGE("failed to write reply"); 661 return IPC_STUB_WRITE_PARCEL_ERR; 662 } 663 return ERR_NONE; 664 } 665 ProcSetOAuthToken(uint32_t code,MessageParcel & data,MessageParcel & reply)666 ErrCode AppAccountStub::ProcSetOAuthToken(uint32_t code, MessageParcel &data, MessageParcel &reply) 667 { 668 std::string name = data.ReadString(); 669 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 670 std::string authType = data.ReadString(); 671 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 672 std::string token = data.ReadString(); 673 RETURN_IF_STRING_IS_OVERSIZE(token, Constants::TOKEN_MAX_SIZE, "token is oversize", reply); 674 ErrCode result = SetOAuthToken(name, authType, token); 675 if (!reply.WriteInt32(result)) { 676 ACCOUNT_LOGE("failed to write reply"); 677 return IPC_STUB_WRITE_PARCEL_ERR; 678 } 679 return ERR_NONE; 680 } 681 ProcDeleteAuthToken(uint32_t code,MessageParcel & data,MessageParcel & reply)682 ErrCode AppAccountStub::ProcDeleteAuthToken(uint32_t code, MessageParcel &data, MessageParcel &reply) 683 { 684 std::string name = data.ReadString(); 685 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 686 std::string owner = data.ReadString(); 687 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 688 std::string authType = data.ReadString(); 689 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 690 std::string token = data.ReadString(); 691 RETURN_IF_STRING_IS_OVERSIZE(token, Constants::TOKEN_MAX_SIZE, "token is oversize", reply); 692 693 ErrCode result = ERR_OK; 694 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_OAUTH_TOKEN)) { 695 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 696 result = DeleteOAuthToken(name, owner, authType, token); 697 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::DELETE_AUTH_TOKEN)) { 698 result = DeleteAuthToken(name, owner, authType, token); 699 } else { 700 return IPC_INVOKER_ERR; 701 } 702 703 if (!reply.WriteInt32(result)) { 704 ACCOUNT_LOGE("failed to write result"); 705 return IPC_STUB_WRITE_PARCEL_ERR; 706 } 707 return ERR_NONE; 708 } 709 ProcSetAuthTokenVisibility(uint32_t code,MessageParcel & data,MessageParcel & reply)710 ErrCode AppAccountStub::ProcSetAuthTokenVisibility(uint32_t code, MessageParcel &data, MessageParcel &reply) 711 { 712 std::string name = data.ReadString(); 713 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 714 std::string authType = data.ReadString(); 715 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 716 std::string bundleName = data.ReadString(); 717 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(bundleName, Constants::BUNDLE_NAME_MAX_SIZE, 718 "bundleName is empty or oversize", reply); 719 bool isVisible = data.ReadBool(); 720 ErrCode result = ERR_OK; 721 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::SET_OAUTH_TOKEN_VISIBILITY)) { 722 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 723 result = SetOAuthTokenVisibility(name, authType, bundleName, isVisible); 724 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::SET_AUTH_TOKEN_VISIBILITY)) { 725 result = SetAuthTokenVisibility(name, authType, bundleName, isVisible); 726 } else { 727 return IPC_INVOKER_ERR; 728 } 729 730 if (!reply.WriteInt32(result)) { 731 ACCOUNT_LOGE("failed to write result"); 732 return IPC_STUB_WRITE_PARCEL_ERR; 733 } 734 return ERR_NONE; 735 } 736 ProcCheckAuthTokenVisibility(uint32_t code,MessageParcel & data,MessageParcel & reply)737 ErrCode AppAccountStub::ProcCheckAuthTokenVisibility(uint32_t code, MessageParcel &data, MessageParcel &reply) 738 { 739 std::string name = data.ReadString(); 740 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 741 std::string authType = data.ReadString(); 742 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::AUTH_TYPE_MAX_SIZE, "authType is oversize", reply); 743 std::string bundleName = data.ReadString(); 744 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(bundleName, Constants::BUNDLE_NAME_MAX_SIZE, 745 "bundleName is empty or oversize", reply); 746 bool isVisible = false; 747 ErrCode result = ERR_OK; 748 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_OAUTH_TOKEN_VISIBILITY)) { 749 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 750 result = CheckOAuthTokenVisibility(name, authType, bundleName, isVisible); 751 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::CHECK_AUTH_TOKEN_VISIBILITY)) { 752 result = CheckAuthTokenVisibility(name, authType, bundleName, isVisible); 753 } else { 754 ACCOUNT_LOGE("stub code is invalid"); 755 return IPC_INVOKER_ERR; 756 } 757 758 if ((!reply.WriteInt32(result)) || (!reply.WriteBool(isVisible))) { 759 ACCOUNT_LOGE("failed to write reply"); 760 return IPC_STUB_WRITE_PARCEL_ERR; 761 } 762 return ERR_NONE; 763 } 764 ProcGetAuthenticatorInfo(uint32_t code,MessageParcel & data,MessageParcel & reply)765 ErrCode AppAccountStub::ProcGetAuthenticatorInfo(uint32_t code, MessageParcel &data, MessageParcel &reply) 766 { 767 std::string owner = data.ReadString(); 768 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 769 AuthenticatorInfo info; 770 ErrCode result = GetAuthenticatorInfo(owner, info); 771 if ((!reply.WriteInt32(result)) || (!reply.WriteString(info.owner)) || 772 (!reply.WriteInt32(info.iconId)) || (!reply.WriteInt32(info.labelId))) { 773 ACCOUNT_LOGE("failed to write reply"); 774 return IPC_STUB_WRITE_PARCEL_ERR; 775 } 776 return ERR_NONE; 777 } 778 ProcGetAllOAuthTokens(uint32_t code,MessageParcel & data,MessageParcel & reply)779 ErrCode AppAccountStub::ProcGetAllOAuthTokens(uint32_t code, MessageParcel &data, MessageParcel &reply) 780 { 781 std::string name = data.ReadString(); 782 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 783 std::string owner = data.ReadString(); 784 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 785 std::vector<OAuthTokenInfo> tokenInfos; 786 ErrCode result = GetAllOAuthTokens(name, owner, tokenInfos); 787 if ((!reply.WriteInt32(result)) || (!reply.WriteUint32(tokenInfos.size()))) { 788 ACCOUNT_LOGE("failed to write reply"); 789 return IPC_STUB_WRITE_PARCEL_ERR; 790 } 791 for (auto tokenInfo : tokenInfos) { 792 if ((!reply.WriteString(tokenInfo.token)) || (!reply.WriteString(tokenInfo.authType))) { 793 ACCOUNT_LOGE("failed to write reply"); 794 return IPC_STUB_WRITE_PARCEL_ERR; 795 } 796 } 797 return ERR_NONE; 798 } 799 ProcGetAuthList(uint32_t code,MessageParcel & data,MessageParcel & reply)800 ErrCode AppAccountStub::ProcGetAuthList(uint32_t code, MessageParcel &data, MessageParcel &reply) 801 { 802 std::string name = data.ReadString(); 803 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 804 std::string authType = data.ReadString(); 805 RETURN_IF_STRING_IS_OVERSIZE(authType, Constants::OWNER_MAX_SIZE, "authType is oversize", reply); 806 std::set<std::string> oauthList; 807 ErrCode result = ERR_OK; 808 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::GET_OAUTH_LIST)) { 809 RETURN_IF_STRING_CONTAINS_SPECIAL_CHAR(name, reply); 810 result = GetOAuthList(name, authType, oauthList); 811 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::GET_AUTH_LIST)) { 812 result = GetAuthList(name, authType, oauthList); 813 } else { 814 ACCOUNT_LOGE("stub code is invalid"); 815 return IPC_INVOKER_ERR; 816 } 817 if ((!reply.WriteInt32(result)) || (!reply.WriteUint32(oauthList.size()))) { 818 ACCOUNT_LOGE("failed to write reply"); 819 return IPC_STUB_WRITE_PARCEL_ERR; 820 } 821 for (auto bundleName : oauthList) { 822 if (!reply.WriteString(bundleName)) { 823 ACCOUNT_LOGE("failed to WriteString for bundleName"); 824 return IPC_STUB_WRITE_PARCEL_ERR; 825 } 826 } 827 return ERR_NONE; 828 } 829 ProcGetAuthenticatorCallback(uint32_t code,MessageParcel & data,MessageParcel & reply)830 ErrCode AppAccountStub::ProcGetAuthenticatorCallback(uint32_t code, MessageParcel &data, MessageParcel &reply) 831 { 832 std::string sessionId = data.ReadString(); 833 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(sessionId, Constants::SESSION_ID_MAX_SIZE, 834 "sessionId is empty or oversize", reply); 835 sptr<IRemoteObject> callback; 836 ErrCode result = GetAuthenticatorCallback(sessionId, callback); 837 if ((!reply.WriteInt32(result)) || (!reply.WriteRemoteObject(callback))) { 838 ACCOUNT_LOGE("failed to write reply"); 839 return IPC_STUB_WRITE_PARCEL_ERR; 840 } 841 return ERR_NONE; 842 } 843 ProcGetAllAccounts(uint32_t code,MessageParcel & data,MessageParcel & reply)844 ErrCode AppAccountStub::ProcGetAllAccounts(uint32_t code, MessageParcel &data, MessageParcel &reply) 845 { 846 std::string owner = data.ReadString(); 847 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 848 std::vector<AppAccountInfo> appAccounts; 849 ErrCode result = GetAllAccounts(owner, appAccounts); 850 if (!reply.WriteInt32(result)) { 851 ACCOUNT_LOGE("failed to write reply"); 852 return IPC_STUB_WRITE_PARCEL_ERR; 853 } 854 if (!WriteParcelableVector(appAccounts, reply)) { 855 ACCOUNT_LOGE("failed to write accounts"); 856 return IPC_STUB_WRITE_PARCEL_ERR; 857 } 858 return ERR_NONE; 859 } 860 ProcGetAllAccessibleAccounts(uint32_t code,MessageParcel & data,MessageParcel & reply)861 ErrCode AppAccountStub::ProcGetAllAccessibleAccounts(uint32_t code, MessageParcel &data, MessageParcel &reply) 862 { 863 std::vector<AppAccountInfo> appAccounts; 864 ErrCode result = ERR_OK; 865 if (code == static_cast<uint32_t>(AppAccountInterfaceCode::GET_ALL_ACCESSIBLE_ACCOUNTS)) { 866 result = GetAllAccessibleAccounts(appAccounts); 867 } else if (code == static_cast<uint32_t>(AppAccountInterfaceCode::QUERY_ALL_ACCESSIBLE_ACCOUNTS)) { 868 std::string owner = data.ReadString(); 869 RETURN_IF_STRING_IS_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is or oversize", reply); 870 result = QueryAllAccessibleAccounts(owner, appAccounts); 871 } else { 872 return IPC_INVOKER_ERR; 873 } 874 if (!reply.WriteInt32(result)) { 875 ACCOUNT_LOGE("failed to write result"); 876 return IPC_STUB_WRITE_PARCEL_ERR; 877 } 878 if (!WriteParcelableVector(appAccounts, reply)) { 879 ACCOUNT_LOGE("failed to write accessible accounts"); 880 return IPC_STUB_WRITE_PARCEL_ERR; 881 } 882 return ERR_NONE; 883 } 884 ProcCheckAppAccess(uint32_t code,MessageParcel & data,MessageParcel & reply)885 ErrCode AppAccountStub::ProcCheckAppAccess(uint32_t code, MessageParcel &data, MessageParcel &reply) 886 { 887 std::string name = data.ReadString(); 888 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 889 std::string bundleName = data.ReadString(); 890 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(bundleName, Constants::BUNDLE_NAME_MAX_SIZE, 891 "bundleName is empty or oversize", reply); 892 bool isAccessible = false; 893 ErrCode result = CheckAppAccess(name, bundleName, isAccessible); 894 if ((!reply.WriteInt32(result)) || (!reply.WriteBool(isAccessible))) { 895 ACCOUNT_LOGE("failed to write reply"); 896 return IPC_STUB_WRITE_PARCEL_ERR; 897 } 898 return ERR_NONE; 899 } 900 ProcDeleteAccountCredential(uint32_t code,MessageParcel & data,MessageParcel & reply)901 ErrCode AppAccountStub::ProcDeleteAccountCredential(uint32_t code, MessageParcel &data, MessageParcel &reply) 902 { 903 std::string name = data.ReadString(); 904 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 905 std::string credentialType = data.ReadString(); 906 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(credentialType, Constants::CREDENTIAL_TYPE_MAX_SIZE, 907 "credentialType is empty or oversize", reply); 908 ErrCode result = DeleteAccountCredential(name, credentialType); 909 if (!reply.WriteInt32(result)) { 910 ACCOUNT_LOGE("failed to write reply"); 911 return IPC_STUB_WRITE_PARCEL_ERR; 912 } 913 return ERR_NONE; 914 } 915 ProcSelectAccountsByOptions(uint32_t code,MessageParcel & data,MessageParcel & reply)916 ErrCode AppAccountStub::ProcSelectAccountsByOptions(uint32_t code, MessageParcel &data, MessageParcel &reply) 917 { 918 std::shared_ptr<SelectAccountsOptions> options(data.ReadParcelable<SelectAccountsOptions>()); 919 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 920 ErrCode result = ERR_OK; 921 if ((options == nullptr) || (callback == nullptr)) { 922 ACCOUNT_LOGE("invalid parameters"); 923 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 924 } else { 925 RETURN_IF_STRING_IS_OVERSIZE(options->allowedAccounts, 926 Constants::MAX_ALLOWED_ARRAY_SIZE_INPUT, "allowedAccounts array is oversize", reply); 927 RETURN_IF_STRING_IS_OVERSIZE(options->allowedOwners, 928 Constants::MAX_ALLOWED_ARRAY_SIZE_INPUT, "allowedOwners array is oversize", reply); 929 RETURN_IF_STRING_IS_OVERSIZE(options->requiredLabels, 930 Constants::MAX_ALLOWED_ARRAY_SIZE_INPUT, "requiredLabels array is oversize", reply); 931 result = SelectAccountsByOptions(*options, callback); 932 } 933 if (!reply.WriteInt32(result)) { 934 ACCOUNT_LOGE("failed to write reply"); 935 return IPC_STUB_WRITE_PARCEL_ERR; 936 } 937 return ERR_NONE; 938 } 939 ProcVerifyCredential(uint32_t code,MessageParcel & data,MessageParcel & reply)940 ErrCode AppAccountStub::ProcVerifyCredential(uint32_t code, MessageParcel &data, MessageParcel &reply) 941 { 942 std::string name = data.ReadString(); 943 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 944 std::string owner = data.ReadString(); 945 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 946 std::shared_ptr<VerifyCredentialOptions> options(data.ReadParcelable<VerifyCredentialOptions>()); 947 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 948 ErrCode result = ERR_OK; 949 if ((options == nullptr) || (callback == nullptr)) { 950 ACCOUNT_LOGE("invalid parameters"); 951 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 952 } else { 953 RETURN_IF_STRING_IS_OVERSIZE( 954 options->credentialType, Constants::CREDENTIAL_TYPE_MAX_SIZE, "the credential type is oversize", reply); 955 RETURN_IF_STRING_IS_OVERSIZE( 956 options->credential, Constants::CREDENTIAL_MAX_SIZE, "the credential is oversize", reply); 957 result = VerifyCredential(name, owner, *options, callback); 958 } 959 if (!reply.WriteInt32(result)) { 960 ACCOUNT_LOGE("failed to write reply"); 961 return IPC_STUB_WRITE_PARCEL_ERR; 962 } 963 return ERR_NONE; 964 } 965 ProcCheckAccountLabels(uint32_t code,MessageParcel & data,MessageParcel & reply)966 ErrCode AppAccountStub::ProcCheckAccountLabels(uint32_t code, MessageParcel &data, MessageParcel &reply) 967 { 968 std::string name = data.ReadString(); 969 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(name, Constants::NAME_MAX_SIZE, "name is empty or oversize", reply); 970 std::string owner = data.ReadString(); 971 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 972 std::vector<std::string> labels; 973 data.ReadStringVector(&labels); 974 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE( 975 labels, Constants::MAX_ALLOWED_ARRAY_SIZE_INPUT, "labels array is empty or oversize", reply); 976 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 977 ErrCode result = ERR_OK; 978 if (callback == nullptr) { 979 ACCOUNT_LOGE("invalid options"); 980 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 981 } else { 982 result = CheckAccountLabels(name, owner, labels, callback); 983 } 984 if (!reply.WriteInt32(result)) { 985 ACCOUNT_LOGE("failed to write reply"); 986 return IPC_STUB_WRITE_PARCEL_ERR; 987 } 988 return ERR_NONE; 989 } 990 ProcSetAuthenticatorProperties(uint32_t code,MessageParcel & data,MessageParcel & reply)991 ErrCode AppAccountStub::ProcSetAuthenticatorProperties(uint32_t code, MessageParcel &data, MessageParcel &reply) 992 { 993 std::string owner = data.ReadString(); 994 RETURN_IF_STRING_IS_EMPTY_OR_OVERSIZE(owner, Constants::OWNER_MAX_SIZE, "owner is empty or oversize", reply); 995 std::shared_ptr<SetPropertiesOptions> options(data.ReadParcelable<SetPropertiesOptions>()); 996 auto callback = iface_cast<IAppAccountAuthenticatorCallback>(data.ReadRemoteObject()); 997 ErrCode result = ERR_OK; 998 if ((options == nullptr) || (callback == nullptr)) { 999 ACCOUNT_LOGE("invalid parameters"); 1000 result = ERR_ACCOUNT_COMMON_INVALID_PARAMETER; 1001 } else { 1002 result = SetAuthenticatorProperties(owner, *options, callback); 1003 } 1004 if (!reply.WriteInt32(result)) { 1005 ACCOUNT_LOGE("failed to write reply"); 1006 return IPC_STUB_WRITE_PARCEL_ERR; 1007 } 1008 return ERR_NONE; 1009 } 1010 ProcSubscribeAccount(uint32_t code,MessageParcel & data,MessageParcel & reply)1011 ErrCode AppAccountStub::ProcSubscribeAccount(uint32_t code, MessageParcel &data, MessageParcel &reply) 1012 { 1013 std::unique_ptr<AppAccountSubscribeInfo> subscribeInfo(data.ReadParcelable<AppAccountSubscribeInfo>()); 1014 if (!subscribeInfo) { 1015 ACCOUNT_LOGE("failed to read parcelable for subscribeInfo"); 1016 return IPC_STUB_INVALID_DATA_ERR; 1017 } 1018 sptr<IRemoteObject> eventListener = data.ReadRemoteObject(); 1019 if (eventListener == nullptr) { 1020 ACCOUNT_LOGE("failed to read remote object for eventListener"); 1021 return IPC_STUB_INVALID_DATA_ERR; 1022 } 1023 ErrCode result = SubscribeAppAccount(*subscribeInfo, eventListener); 1024 if (!reply.WriteInt32(result)) { 1025 ACCOUNT_LOGE("failed to write reply"); 1026 return IPC_STUB_WRITE_PARCEL_ERR; 1027 } 1028 return ERR_NONE; 1029 } 1030 ProcUnsubscribeAccount(uint32_t code,MessageParcel & data,MessageParcel & reply)1031 ErrCode AppAccountStub::ProcUnsubscribeAccount(uint32_t code, MessageParcel &data, MessageParcel &reply) 1032 { 1033 sptr<IRemoteObject> eventListener = data.ReadRemoteObject(); 1034 if (eventListener == nullptr) { 1035 ACCOUNT_LOGE("failed to read remote object for eventListener"); 1036 return IPC_STUB_INVALID_DATA_ERR; 1037 } 1038 ErrCode result = UnsubscribeAppAccount(eventListener); 1039 if (!reply.WriteInt32(result)) { 1040 ACCOUNT_LOGE("failed to write reply"); 1041 return IPC_STUB_WRITE_PARCEL_ERR; 1042 } 1043 return ERR_NONE; 1044 } 1045 } // namespace AccountSA 1046 } // namespace OHOS 1047