1 /*
2  * Copyright (c) 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 "accesstoken_kit.h"
17 #include "i18n_hilog.h"
18 #include "ipc_skeleton.h"
19 #include "mem_mgr_client.h"
20 #include "mem_mgr_proxy.h"
21 #include "system_ability_definition.h"
22 #include "tokenid_kit.h"
23 #include "i18n_service_ability_stub.h"
24 
25 namespace OHOS {
26 namespace Global {
27 namespace I18n {
I18nServiceAbilityStub(bool serialInvokeFlag)28 I18nServiceAbilityStub::I18nServiceAbilityStub(bool serialInvokeFlag)
29     : IRemoteStub<II18nServiceAbility>(serialInvokeFlag)
30 {
31     HILOG_INFO_I18N("I18nServiceAbilityStub object init success.");
32 }
33 
~I18nServiceAbilityStub()34 I18nServiceAbilityStub::~I18nServiceAbilityStub()
35 {
36     HILOG_INFO_I18N("I18nServiceAbilityStub object release.");
37 }
38 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)39 int32_t I18nServiceAbilityStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
40     MessageOption &option)
41 {
42     HILOG_INFO_I18N("I18nServiceAbilityStub::OnRemoteRequest process request for code=%{public}u", code);
43     // check whether request's descriptor is consistent with sa's descriptor
44     std::u16string descriptor = GetDescriptor();
45     std::u16string remoteDescriptor = data.ReadInterfaceToken();
46     if (descriptor != remoteDescriptor) {
47         HILOG_ERROR_I18N("I18nServiceAbilityStub client and server's descriptor are inconsistent.");
48         reply.WriteInt32(I18nErrorCode::INCONSISTENT_DESCRIPTOR);
49         return 0;
50     }
51     // map request code to corresponding process function.
52     int32_t ret = InvokeInnerFunc(code, data, reply);
53     bool hasMappedInnerFunc = ret > -1;
54     if (!hasMappedInnerFunc) {
55         HILOG_INFO_I18N("I18nServiceAbilityStub::OnRemoteRequest invalid request code=%{public}u", code);
56         ret = IPCObjectStub::OnRemoteRequest(code, data, reply, option);
57     }
58     // trigger release i18n service after one request finished.
59     UnloadI18nServiceAbility();
60     return ret;
61 }
62 
InvokeInnerFunc(uint32_t code,MessageParcel & data,MessageParcel & reply)63 int32_t I18nServiceAbilityStub::InvokeInnerFunc(uint32_t code, MessageParcel &data, MessageParcel &reply)
64 {
65     switch (code) {
66         case static_cast<uint32_t>(ILocaleConfigAbilityCode::SET_SYSTEM_LANGUAGE): {
67             return I18nServiceAbilityStub::SetSystemLanguageInner(data, reply);
68         }
69         case static_cast<uint32_t>(ILocaleConfigAbilityCode::SET_SYSTEM_REGION): {
70             return I18nServiceAbilityStub::SetSystemRegionInner(data, reply);
71         }
72         case static_cast<uint32_t>(ILocaleConfigAbilityCode::SET_SYSTEM_LOCALE): {
73             return I18nServiceAbilityStub::SetSystemLocaleInner(data, reply);
74         }
75         case static_cast<uint32_t>(ILocaleConfigAbilityCode::SET_24_HOUR_CLOCK): {
76             return I18nServiceAbilityStub::Set24HourClockInner(data, reply);
77         }
78         case static_cast<uint32_t>(ILocaleConfigAbilityCode::SET_USING_LOCAL_DIGIT): {
79             return I18nServiceAbilityStub::SetUsingLocalDigitInner(data, reply);
80         }
81         case static_cast<uint32_t>(ILocaleConfigAbilityCode::ADD_PREFERRED_LANGUAGE): {
82             return I18nServiceAbilityStub::AddPreferredLanguageInner(data, reply);
83         }
84         case static_cast<uint32_t>(ILocaleConfigAbilityCode::REMOVE_PREFERRED_LANGUAGE): {
85             return I18nServiceAbilityStub::RemovePreferredLanguageInner(data, reply);
86         }
87         default:
88             break;
89     }
90     return -1;
91 }
92 
93 /**
94  * check whether request process has correct tokenType and permission.
95  */
CheckPermission()96 I18nErrorCode I18nServiceAbilityStub::CheckPermission()
97 {
98     uint64_t callerFullToken = IPCSkeleton::GetCallingFullTokenID();
99     uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
100     bool isSystemApp = Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(callerFullToken);
101     Security::AccessToken::ATokenTypeEnum tokenType =
102         Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken);
103     bool isShell = tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL;
104     bool isNative = tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE;
105     if (!isSystemApp && !isShell && !isNative) {
106         HILOG_ERROR_I18N("I18nServiceAbilityStub caller process is not System app, Shell or Native.");
107         return I18nErrorCode::NO_PERMISSION;
108     }
109     int result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
110         "ohos.permission.UPDATE_CONFIGURATION");
111     if (result != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
112         HILOG_ERROR_I18N("I18nServiceAbilityStub caller process doesn't have UPDATE_CONFIGURATION permission.");
113         return I18nErrorCode::NO_PERMISSION;
114     }
115     return I18nErrorCode::SUCCESS;
116 }
117 
SetSystemLanguageInner(MessageParcel & data,MessageParcel & reply)118 int32_t I18nServiceAbilityStub::SetSystemLanguageInner(MessageParcel &data, MessageParcel &reply)
119 {
120     int pid = getpid();
121     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
122     I18nErrorCode err = CheckPermission();
123     if (err != I18nErrorCode::SUCCESS) {
124         reply.WriteInt32(static_cast<int32_t>(err));
125         return 0;
126     }
127     std::string language = data.ReadString();
128     err = SetSystemLanguage(language);
129     if (err != I18nErrorCode::SUCCESS) {
130         HILOG_ERROR_I18N("I18nServiceAbilityStub::SetSystemLanguageInner failed with errorCode=%{public}d",
131             static_cast<int32_t>(err));
132     }
133     reply.WriteInt32(static_cast<int32_t>(err));
134     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
135     return 0;
136 }
137 
SetSystemRegionInner(MessageParcel & data,MessageParcel & reply)138 int32_t I18nServiceAbilityStub::SetSystemRegionInner(MessageParcel &data, MessageParcel &reply)
139 {
140     int pid = getpid();
141     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
142     I18nErrorCode err = CheckPermission();
143     if (err != I18nErrorCode::SUCCESS) {
144         reply.WriteInt32(static_cast<int32_t>(err));
145         return 0;
146     }
147     std::string region = data.ReadString();
148     err = SetSystemRegion(region);
149     if (err != I18nErrorCode::SUCCESS) {
150         HILOG_ERROR_I18N("I18nServiceAbilityStub::SetSystemRegionInner failed with errorCode=%{public}d",
151             static_cast<int32_t>(err));
152     }
153     reply.WriteInt32(static_cast<int32_t>(err));
154     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
155     return 0;
156 }
157 
SetSystemLocaleInner(MessageParcel & data,MessageParcel & reply)158 int32_t I18nServiceAbilityStub::SetSystemLocaleInner(MessageParcel &data, MessageParcel &reply)
159 {
160     int pid = getpid();
161     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
162     I18nErrorCode err = CheckPermission();
163     if (err != I18nErrorCode::SUCCESS) {
164         reply.WriteInt32(static_cast<int32_t>(err));
165         return 0;
166     }
167     std::string locale = data.ReadString();
168     err = SetSystemLocale(locale);
169     if (err != I18nErrorCode::SUCCESS) {
170         HILOG_ERROR_I18N("I18nServiceAbilityStub::SetSystemLocaleInner failed with errorCode=%{public}d",
171             static_cast<int32_t>(err));
172     }
173     reply.WriteInt32(static_cast<int32_t>(err));
174     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
175     return 0;
176 }
177 
Set24HourClockInner(MessageParcel & data,MessageParcel & reply)178 int32_t I18nServiceAbilityStub::Set24HourClockInner(MessageParcel &data, MessageParcel &reply)
179 {
180     int pid = getpid();
181     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
182     I18nErrorCode err = CheckPermission();
183     if (err != I18nErrorCode::SUCCESS) {
184         reply.WriteInt32(static_cast<int32_t>(err));
185         return 0;
186     }
187     std::string flag = data.ReadString();
188     err = Set24HourClock(flag);
189     if (err != I18nErrorCode::SUCCESS) {
190         HILOG_ERROR_I18N("I18nServiceAbilityStub::Set24HourClockInner failed with errorCode=%{public}d",
191             static_cast<int32_t>(err));
192     }
193     reply.WriteInt32(static_cast<int32_t>(err));
194     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
195     return 0;
196 }
197 
SetUsingLocalDigitInner(MessageParcel & data,MessageParcel & reply)198 int32_t I18nServiceAbilityStub::SetUsingLocalDigitInner(MessageParcel &data, MessageParcel &reply)
199 {
200     int pid = getpid();
201     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
202     I18nErrorCode err = CheckPermission();
203     if (err != I18nErrorCode::SUCCESS) {
204         reply.WriteInt32(static_cast<int32_t>(err));
205         return 0;
206     }
207     bool flag = data.ReadBool();
208     err = SetUsingLocalDigit(flag);
209     if (err != I18nErrorCode::SUCCESS) {
210         HILOG_ERROR_I18N("I18nServiceAbilityStub::SetUsingLocalDigitInner failed with errorCode=%{public}d",
211             static_cast<int32_t>(err));
212     }
213     reply.WriteInt32(static_cast<int32_t>(err));
214     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
215     return 0;
216 }
217 
AddPreferredLanguageInner(MessageParcel & data,MessageParcel & reply)218 int32_t I18nServiceAbilityStub::AddPreferredLanguageInner(MessageParcel &data, MessageParcel &reply)
219 {
220     int pid = getpid();
221     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
222     I18nErrorCode err = CheckPermission();
223     if (err != I18nErrorCode::SUCCESS) {
224         reply.WriteInt32(static_cast<int32_t>(err));
225         return 0;
226     }
227     std::string language = data.ReadString();
228     int32_t index = data.ReadInt32();
229     err = AddPreferredLanguage(language, index);
230     if (err != I18nErrorCode::SUCCESS) {
231         HILOG_ERROR_I18N("I18nServiceAbilityStub::AddPreferredLanguageInner failed with errorCode=%{public}d",
232             static_cast<int32_t>(err));
233     }
234     reply.WriteInt32(static_cast<int32_t>(err));
235     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
236     return 0;
237 }
238 
RemovePreferredLanguageInner(MessageParcel & data,MessageParcel & reply)239 int32_t I18nServiceAbilityStub::RemovePreferredLanguageInner(MessageParcel &data, MessageParcel &reply)
240 {
241     int pid = getpid();
242     Memory::MemMgrClient::GetInstance().SetCritical(pid, true, I18N_SA_ID);
243     I18nErrorCode err = CheckPermission();
244     if (err != I18nErrorCode::SUCCESS) {
245         reply.WriteInt32(static_cast<int32_t>(err));
246         return 0;
247     }
248     int32_t index = data.ReadInt32();
249     err = RemovePreferredLanguage(index);
250     if (err != I18nErrorCode::SUCCESS) {
251         HILOG_ERROR_I18N("I18nServiceAbilityStub::RemovePreferredLanguageInner failed with errorCode=%{public}d",
252             static_cast<int32_t>(err));
253     }
254     reply.WriteInt32(static_cast<int32_t>(err));
255     Memory::MemMgrClient::GetInstance().SetCritical(pid, false, I18N_SA_ID);
256     return 0;
257 }
258 } // namespace I18n
259 } // namespace Global
260 } // namespace OHOS