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 "message_parcel_utils.h"
17
18 #include "edm_log.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace EDM {
23 #ifdef WIFI_EDM_ENABLE
WriteWifiDeviceConfig(Wifi::WifiDeviceConfig & config,MessageParcel & data,WifiPassword & pwd)24 void MessageParcelUtils::WriteWifiDeviceConfig(Wifi::WifiDeviceConfig &config, MessageParcel &data,
25 WifiPassword &pwd)
26 {
27 data.WriteInt32(config.networkId);
28 data.WriteString(config.bssid);
29 data.WriteString(config.ssid);
30 data.WriteInt32(config.band);
31 data.WriteInt32(config.channel);
32 data.WriteInt32(config.frequency);
33 data.WriteInt32(config.level);
34 data.WriteBool(config.isPasspoint);
35 data.WriteBool(config.isEphemeral);
36 WriteCString(data, pwd.preSharedKey);
37 data.WriteString(config.keyMgmt);
38 WriteCString(data, pwd.wepKey);
39 data.WriteInt32(config.wepTxKeyIndex);
40 data.WriteInt32(config.priority);
41 data.WriteBool(config.hiddenSSID);
42 data.WriteInt32(static_cast<int32_t>(config.wifiIpConfig.assignMethod));
43 WriteIpAddress(data, config.wifiIpConfig.staticIpAddress.ipAddress.address);
44 data.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.prefixLength);
45 data.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.flags);
46 data.WriteInt32(config.wifiIpConfig.staticIpAddress.ipAddress.scope);
47 WriteIpAddress(data, config.wifiIpConfig.staticIpAddress.gateway);
48 WriteIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer1);
49 WriteIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer2);
50 data.WriteString(config.wifiIpConfig.staticIpAddress.domains);
51 data.WriteString(config.wifiEapConfig.eap);
52 data.WriteString(config.wifiEapConfig.identity);
53 WriteCString(data, pwd.password);
54 data.WriteString(config.wifiEapConfig.clientCert);
55 data.WriteString(config.wifiEapConfig.privateKey);
56 data.WriteUInt8Vector(config.wifiEapConfig.certEntry);
57 data.WriteCString(config.wifiEapConfig.certPassword);
58 memset_s(config.wifiEapConfig.certPassword, sizeof(config.wifiEapConfig.certPassword), 0,
59 sizeof(config.wifiEapConfig.certPassword));
60 data.WriteInt32(static_cast<int32_t>(config.wifiEapConfig.phase2Method));
61 data.WriteInt32(static_cast<int32_t>(config.wifiProxyconfig.configureMethod));
62 data.WriteString(config.wifiProxyconfig.autoProxyConfig.pacWebAddress);
63 data.WriteString(config.wifiProxyconfig.manualProxyConfig.serverHostName);
64 data.WriteInt32(config.wifiProxyconfig.manualProxyConfig.serverPort);
65 data.WriteString(config.wifiProxyconfig.manualProxyConfig.exclusionObjectList);
66 data.WriteInt32(static_cast<int32_t>(config.wifiPrivacySetting));
67 }
68
WriteIpAddress(MessageParcel & data,const Wifi::WifiIpAddress & address)69 void MessageParcelUtils::WriteIpAddress(MessageParcel &data, const Wifi::WifiIpAddress &address)
70 {
71 data.WriteInt32(address.family);
72 data.WriteUint32(address.addressIpv4);
73 size_t size = address.addressIpv6.size();
74 data.WriteUint32(size);
75 for (size_t i = 0; i < size; i++) {
76 data.WriteUint8(address.addressIpv6[i]);
77 }
78 }
79
ReadWifiDeviceConfig(MessageParcel & data,Wifi::WifiDeviceConfig & config)80 void MessageParcelUtils::ReadWifiDeviceConfig(MessageParcel &data, Wifi::WifiDeviceConfig &config)
81 {
82 config.networkId = data.ReadInt32();
83 config.bssid = data.ReadString();
84 config.ssid = data.ReadString();
85 config.band = data.ReadInt32();
86 config.channel = data.ReadInt32();
87 config.frequency = data.ReadInt32();
88 config.level = data.ReadInt32();
89 config.isPasspoint = data.ReadBool();
90 config.isEphemeral = data.ReadBool();
91 std::string preSharedKey(ReadCString(data));
92 config.preSharedKey = preSharedKey;
93 EdmUtils::ClearString(preSharedKey);
94 config.keyMgmt = data.ReadString();
95 if (sizeof(config.wepKeys) / sizeof(std::string) > 0) {
96 std::string wepKey(ReadCString(data));
97 config.wepKeys[0] = wepKey;
98 EdmUtils::ClearString(wepKey);
99 }
100 config.wepTxKeyIndex = data.ReadInt32();
101 config.priority = data.ReadInt32();
102 config.hiddenSSID = data.ReadBool();
103 ProcessAssignIpMethod(data.ReadInt32(), config.wifiIpConfig);
104 ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.ipAddress.address);
105 config.wifiIpConfig.staticIpAddress.ipAddress.prefixLength = data.ReadInt32();
106 config.wifiIpConfig.staticIpAddress.ipAddress.flags = data.ReadInt32();
107 config.wifiIpConfig.staticIpAddress.ipAddress.scope = data.ReadInt32();
108 ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.gateway);
109 ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer1);
110 ReadIpAddress(data, config.wifiIpConfig.staticIpAddress.dnsServer2);
111 config.wifiIpConfig.staticIpAddress.domains = data.ReadString();
112 config.wifiEapConfig.eap = data.ReadString();
113 config.wifiEapConfig.identity = data.ReadString();
114 std::string password(ReadCString(data));
115 config.wifiEapConfig.password = password;
116 EdmUtils::ClearString(password);
117 config.wifiEapConfig.clientCert = data.ReadString();
118 config.wifiEapConfig.privateKey = data.ReadString();
119 data.ReadUInt8Vector(&config.wifiEapConfig.certEntry);
120 strncpy_s(config.wifiEapConfig.certPassword, sizeof(config.wifiEapConfig.certPassword), ReadCString(data),
121 sizeof(config.wifiEapConfig.certPassword) - 1);
122 ProcessPhase2Method(data.ReadInt32(), config.wifiEapConfig);
123 ProcessConfigureProxyMethod(data.ReadInt32(), config.wifiProxyconfig);
124 config.wifiProxyconfig.autoProxyConfig.pacWebAddress = data.ReadString();
125 config.wifiProxyconfig.manualProxyConfig.serverHostName = data.ReadString();
126 config.wifiProxyconfig.manualProxyConfig.serverPort = data.ReadInt32();
127 config.wifiProxyconfig.manualProxyConfig.exclusionObjectList = data.ReadString();
128 ProcessPrivacyConfig(data.ReadInt32(), config);
129 }
130
ProcessAssignIpMethod(int32_t ipMethod,Wifi::WifiIpConfig & ipConfig)131 void MessageParcelUtils::ProcessAssignIpMethod(int32_t ipMethod, Wifi::WifiIpConfig &ipConfig)
132 {
133 switch (ipMethod) {
134 case static_cast<int32_t>(Wifi::AssignIpMethod::DHCP):
135 ipConfig.assignMethod = Wifi::AssignIpMethod::DHCP;
136 break;
137 case static_cast<int32_t>(Wifi::AssignIpMethod::STATIC):
138 ipConfig.assignMethod = Wifi::AssignIpMethod::STATIC;
139 break;
140 default:
141 ipConfig.assignMethod = Wifi::AssignIpMethod::UNASSIGNED;
142 break;
143 }
144 }
145
ProcessPhase2Method(int32_t phase2,Wifi::WifiEapConfig & eapConfig)146 void MessageParcelUtils::ProcessPhase2Method(int32_t phase2, Wifi::WifiEapConfig &eapConfig)
147 {
148 switch (phase2) {
149 case static_cast<int32_t>(Wifi::Phase2Method::PAP):
150 eapConfig.phase2Method = Wifi::Phase2Method::PAP;
151 break;
152 case static_cast<int32_t>(Wifi::Phase2Method::MSCHAP):
153 eapConfig.phase2Method = Wifi::Phase2Method::MSCHAP;
154 break;
155 case static_cast<int32_t>(Wifi::Phase2Method::MSCHAPV2):
156 eapConfig.phase2Method = Wifi::Phase2Method::MSCHAPV2;
157 break;
158 case static_cast<int32_t>(Wifi::Phase2Method::GTC):
159 eapConfig.phase2Method = Wifi::Phase2Method::GTC;
160 break;
161 case static_cast<int32_t>(Wifi::Phase2Method::SIM):
162 eapConfig.phase2Method = Wifi::Phase2Method::SIM;
163 break;
164 case static_cast<int32_t>(Wifi::Phase2Method::AKA):
165 eapConfig.phase2Method = Wifi::Phase2Method::AKA;
166 break;
167 case static_cast<int32_t>(Wifi::Phase2Method::AKA_PRIME):
168 eapConfig.phase2Method = Wifi::Phase2Method::AKA_PRIME;
169 break;
170 default:
171 eapConfig.phase2Method = Wifi::Phase2Method::NONE;
172 break;
173 }
174 }
175
ProcessConfigureProxyMethod(int32_t proxyMethod,Wifi::WifiProxyConfig & proxyConfig)176 void MessageParcelUtils::ProcessConfigureProxyMethod(int32_t proxyMethod, Wifi::WifiProxyConfig &proxyConfig)
177 {
178 switch (proxyMethod) {
179 case static_cast<int32_t>(Wifi::ConfigureProxyMethod::AUTOCONFIGUE):
180 proxyConfig.configureMethod = Wifi::ConfigureProxyMethod::AUTOCONFIGUE;
181 break;
182 case static_cast<int32_t>(Wifi::ConfigureProxyMethod::MANUALCONFIGUE):
183 proxyConfig.configureMethod = Wifi::ConfigureProxyMethod::MANUALCONFIGUE;
184 break;
185 default:
186 proxyConfig.configureMethod = Wifi::ConfigureProxyMethod::CLOSED;
187 break;
188 }
189 }
190
ProcessPrivacyConfig(int32_t privacyConfig,Wifi::WifiDeviceConfig & config)191 void MessageParcelUtils::ProcessPrivacyConfig(int32_t privacyConfig, Wifi::WifiDeviceConfig &config)
192 {
193 if (privacyConfig == static_cast<int32_t>(Wifi::WifiPrivacyConfig::RANDOMMAC)) {
194 config.wifiPrivacySetting = Wifi::WifiPrivacyConfig::RANDOMMAC;
195 } else {
196 config.wifiPrivacySetting = Wifi::WifiPrivacyConfig::DEVICEMAC;
197 }
198 }
199
ReadIpAddress(MessageParcel & data,Wifi::WifiIpAddress & address)200 void MessageParcelUtils::ReadIpAddress(MessageParcel &data, Wifi::WifiIpAddress &address)
201 {
202 constexpr int MAX_LIMIT_SIZE = 1024;
203 address.family = data.ReadInt32();
204 address.addressIpv4 = data.ReadUint32();
205 size_t size = data.ReadUint32();
206 if (size > MAX_LIMIT_SIZE) {
207 EDMLOGE("Read ip address parameter error: %{public}zu", size);
208 return;
209 }
210 for (size_t i = 0; i < size; i++) {
211 address.addressIpv6.push_back(data.ReadUint8());
212 }
213 }
214
WriteCString(MessageParcel & data,char * cStr)215 void MessageParcelUtils::WriteCString(MessageParcel &data, char* cStr)
216 {
217 if (cStr != nullptr) {
218 data.WriteCString(cStr);
219 } else {
220 char temp[1]{'\0'};
221 data.WriteCString(temp);
222 }
223 }
224
ReadCString(MessageParcel & data)225 const char* MessageParcelUtils::ReadCString(MessageParcel &data)
226 {
227 const char* value = data.ReadCString();
228 if (value == nullptr) {
229 const char* temp = "";
230 return temp;
231 }
232 return value;
233 }
234 #endif
235
WriteInstallParam(const AppExecFwk::InstallParam & installParam,MessageParcel & data)236 void MessageParcelUtils::WriteInstallParam(const AppExecFwk::InstallParam &installParam, MessageParcel &data)
237 {
238 data.WriteInt32(installParam.userId);
239 data.WriteInt32(static_cast<int>(installParam.installFlag));
240 std::vector<std::string> keys;
241 std::vector<std::string> values;
242 for (const auto &pair : installParam.parameters) {
243 keys.push_back(pair.first);
244 values.push_back(pair.second);
245 }
246 data.WriteStringVector(keys);
247 data.WriteStringVector(values);
248 }
249
WriteOperateDeviceParam(const OperateDeviceParam & param,MessageParcel & data)250 void MessageParcelUtils::WriteOperateDeviceParam(const OperateDeviceParam ¶m, MessageParcel &data)
251 {
252 data.WriteString(param.operate);
253 data.WriteString(param.addition);
254 data.WriteInt32(param.userId);
255 }
256
ReadOperateDeviceParam(MessageParcel & data,OperateDeviceParam & param)257 void MessageParcelUtils::ReadOperateDeviceParam(MessageParcel &data, OperateDeviceParam ¶m)
258 {
259 param.operate = data.ReadString();
260 param.addition = data.ReadString();
261 param.userId = data.ReadInt32();
262 }
263
WriteClearUpApplicationDataParam(const ClearUpApplicationDataParam & param,MessageParcel & data)264 void MessageParcelUtils::WriteClearUpApplicationDataParam(const ClearUpApplicationDataParam ¶m, MessageParcel &data)
265 {
266 data.WriteString(param.bundleName);
267 data.WriteInt32(param.appIndex);
268 data.WriteInt32(param.userId);
269 }
270
ReadClearUpApplicationDataParam(MessageParcel & data,ClearUpApplicationDataParam & param)271 void MessageParcelUtils::ReadClearUpApplicationDataParam(MessageParcel &data, ClearUpApplicationDataParam ¶m)
272 {
273 param.bundleName = data.ReadString();
274 param.appIndex = data.ReadInt32();
275 param.userId = data.ReadInt32();
276 }
277
278 } // namespace EDM
279 } // namespace OHOS