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 "gsm_user_data_decode.h"
17
18 #include "gsm_pdu_hex_value.h"
19 #include "gsm_sms_common_utils.h"
20 #include "securec.h"
21 #include "telephony_log_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
25 using namespace std;
26 static constexpr uint8_t GSM_USER_DATA_LEN = 160;
27 static constexpr uint8_t NORMAL_BYTE_BITS = 8;
28 static constexpr uint8_t GSM_ENCODE_BITS = 7;
29 static constexpr uint8_t SLIDE_DATA_STEP = 2;
30 static constexpr uint8_t UCS2_USER_DATA_LEN = 140;
31 static constexpr uint8_t WAP_PUSH_USER_DATA_HEAD_LEN = 7;
32
GsmUserDataDecode(std::shared_ptr<GsmUserDataPdu> data)33 GsmUserDataDecode::GsmUserDataDecode(std::shared_ptr<GsmUserDataPdu> data)
34 {
35 userData_ = data;
36 }
37
~GsmUserDataDecode()38 GsmUserDataDecode::~GsmUserDataDecode() {}
39
DecodeGsmPdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD)40 bool GsmUserDataDecode::DecodeGsmPdu(
41 SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, struct SmsTpud *pTPUD)
42 {
43 uint8_t udl = 0;
44 uint8_t fillBits = 0;
45 if (!DecodeGsmHeadPdu(buffer, bHeaderInd, userData, pTPUD, udl, fillBits)) {
46 TELEPHONY_LOGE("decode gsm head error");
47 return false;
48 }
49 return DecodeGsmBodyPdu(buffer, bHeaderInd, userData, pTPUD, udl, fillBits);
50 }
51
DecodeGsmHeadPdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD,uint8_t & udl,uint8_t & fillBits)52 bool GsmUserDataDecode::DecodeGsmHeadPdu(SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData,
53 struct SmsTpud *pTPUD, uint8_t &udl, uint8_t &fillBits)
54 {
55 if (userData == nullptr) {
56 TELEPHONY_LOGE("nullptr error");
57 return false;
58 }
59
60 /* UDL */
61 if (!buffer.ReadByte(udl)) {
62 TELEPHONY_LOGE("get data error.");
63 return false;
64 }
65 if (udl > GSM_USER_DATA_LEN) {
66 userData->length = 0;
67 userData->headerCnt = 0;
68 TELEPHONY_LOGE("udl error.");
69 return false;
70 }
71
72 /* Setting for Wap Push */
73 if (pTPUD != nullptr && udl > 0) {
74 pTPUD->udl = udl;
75 if (udl > sizeof(pTPUD->ud)) {
76 TELEPHONY_LOGE("udl length error");
77 return false;
78 }
79 uint8_t len = udl;
80 if (buffer.GetIndex() + udl >= buffer.GetSize()) {
81 len = buffer.GetSize() - buffer.GetIndex();
82 }
83 if (buffer.data_ == nullptr) {
84 TELEPHONY_LOGE("buffer error.");
85 return false;
86 }
87 if (memcpy_s(pTPUD->ud, sizeof(pTPUD->ud), buffer.data_.get() + buffer.GetIndex(), len) != EOK) {
88 TELEPHONY_LOGE("memcpy_s error");
89 return false;
90 }
91 pTPUD->ud[len] = '\0';
92 }
93 return DecodeGsmHeadPduPartData(buffer, bHeaderInd, userData, udl, fillBits);
94 }
95
DecodeGsmHeadPduPartData(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,uint8_t & udl,uint8_t & fillBits)96 bool GsmUserDataDecode::DecodeGsmHeadPduPartData(
97 SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, uint8_t &udl, uint8_t &fillBits)
98 {
99 if (userData_ == nullptr) {
100 TELEPHONY_LOGE("nullptr error.");
101 return false;
102 }
103 uint8_t udhl = 0;
104 /* Decode User Data Header */
105 if (bHeaderInd) {
106 /* UDHL */
107 if (!buffer.ReadByte(udhl)) {
108 TELEPHONY_LOGE("get data error.");
109 return false;
110 }
111 userData->headerCnt = 0;
112 uint8_t current = buffer.GetIndex();
113 for (int i = 0; buffer.GetIndex() < current + udhl && i < MAX_UD_HEADER_NUM; i++) {
114 uint16_t headerLen = 0;
115 if (!userData_->DecodeHeader(buffer, userData->header[i], headerLen)) {
116 TELEPHONY_LOGE("DecodeHeader error");
117 return false;
118 }
119 if (headerLen == 0) {
120 userData_->ResetUserData(*userData);
121 TELEPHONY_LOGE("headerLen error");
122 return false;
123 }
124 if (buffer.GetIndex() >= buffer.GetSize()) {
125 TELEPHONY_LOGE("data buffer error)");
126 userData_->ResetUserData(*userData);
127 return false;
128 }
129 userData->headerCnt++;
130 }
131 } else {
132 userData->headerCnt = 0;
133 }
134
135 if (udhl > 0) {
136 fillBits = ((udl * GSM_ENCODE_BITS) - ((udhl + 1) * NORMAL_BYTE_BITS)) % GSM_ENCODE_BITS;
137 udl = ((udl * GSM_ENCODE_BITS) - ((udhl + 1) * NORMAL_BYTE_BITS)) / GSM_ENCODE_BITS;
138 }
139 return true;
140 }
141
DecodeGsmBodyPdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD,uint8_t & udl,uint8_t fillBits)142 bool GsmUserDataDecode::DecodeGsmBodyPdu(SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData,
143 struct SmsTpud *pTPUD, uint8_t &udl, uint8_t fillBits)
144 {
145 if (userData == nullptr) {
146 TELEPHONY_LOGE("nullptr error.");
147 return false;
148 }
149
150 GsmSmsCommonUtils utils;
151 uint8_t length = 0;
152 bool ret = utils.Unpack7bitChar(
153 buffer, udl, fillBits, reinterpret_cast<uint8_t *>(userData->data), MAX_USER_DATA_LEN + 1, length);
154 if (ret) {
155 userData->length = length;
156 }
157 TELEPHONY_LOGI("decode gsm body result:%{public}d", ret);
158 return ret;
159 }
160
Decode8bitPdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD)161 bool GsmUserDataDecode::Decode8bitPdu(
162 SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, struct SmsTpud *pTPUD)
163 {
164 if (userData == nullptr) {
165 TELEPHONY_LOGE("nullptr error.");
166 return false;
167 }
168 /* UDL */
169 uint8_t udl = 0;
170 if (!buffer.ReadByte(udl)) {
171 TELEPHONY_LOGE("get data error.");
172 return false;
173 }
174 TELEPHONY_LOGI("udl:%{public}d", udl);
175 uint16_t current = buffer.GetIndex();
176
177 if (udl > UCS2_USER_DATA_LEN) {
178 userData->length = 0;
179 TELEPHONY_LOGE("udl length error");
180 return false;
181 }
182
183 /* Setting for Wap Push */
184 if (pTPUD != nullptr && udl > WAP_PUSH_USER_DATA_HEAD_LEN) {
185 pTPUD->udl = udl - WAP_PUSH_USER_DATA_HEAD_LEN;
186 if (pTPUD->udl > sizeof(pTPUD->ud)) {
187 TELEPHONY_LOGE("udl length error");
188 return false;
189 }
190
191 if (buffer.data_ == nullptr || (buffer.GetIndex() + pTPUD->udl > buffer.GetSize())) {
192 TELEPHONY_LOGE("buffer error.");
193 return false;
194 }
195 if (memcpy_s(pTPUD->ud, sizeof(pTPUD->ud), buffer.data_.get() + buffer.GetIndex() + WAP_PUSH_USER_DATA_HEAD_LEN,
196 pTPUD->udl) != EOK) {
197 TELEPHONY_LOGE("memcpy_s error.");
198 return false;
199 }
200 pTPUD->ud[pTPUD->udl] = '\0';
201 }
202 return Decode8bitPduPartData(buffer, bHeaderInd, userData, pTPUD, current, udl);
203 }
204
Decode8bitPduPartData(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD,uint16_t current,uint8_t udl)205 bool GsmUserDataDecode::Decode8bitPduPartData(SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData,
206 struct SmsTpud *pTPUD, uint16_t current, uint8_t udl)
207 {
208 if (userData_ == nullptr) {
209 TELEPHONY_LOGE("nullptr error.");
210 return false;
211 }
212
213 uint8_t udhl = 0;
214 /* Decode User Data Header */
215 if (bHeaderInd) {
216 /* UDHL */
217 if (!buffer.ReadByte(udhl)) {
218 TELEPHONY_LOGE("get data error.");
219 return false;
220 }
221 userData->headerCnt = 0;
222 current = buffer.GetIndex();
223 for (uint8_t i = 0; (buffer.GetIndex() - current) < udhl && i < MAX_UD_HEADER_NUM; i++) {
224 if (!userData_->GetHeaderCnt(buffer, userData, udhl, i)) {
225 TELEPHONY_LOGI("data error");
226 return false;
227 }
228 }
229 } else {
230 userData->headerCnt = 0;
231 }
232
233 if (udhl > 0 && udl > udhl + 1) {
234 userData->length = (udl) - (udhl + 1);
235 buffer.MoveForward(HEX_VALUE_01);
236 } else {
237 userData->length = udl;
238 }
239 if (udl > sizeof(pTPUD->ud)) {
240 TELEPHONY_LOGE("udl length error");
241 return false;
242 }
243
244 if (buffer.data_ == nullptr || (buffer.GetIndex() + userData->length) > buffer.GetSize() + 1) {
245 TELEPHONY_LOGE("buffer error.");
246 return false;
247 }
248
249 if (memcpy_s(userData->data, sizeof(userData->data), buffer.data_.get() + buffer.GetIndex(), userData->length) !=
250 EOK) {
251 TELEPHONY_LOGE("memcpy_s error");
252 return false;
253 }
254 buffer.MoveForward(userData->length);
255 return true;
256 }
257
DecodeUcs2Pdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD)258 bool GsmUserDataDecode::DecodeUcs2Pdu(
259 SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, struct SmsTpud *pTPUD)
260 {
261 if (userData == nullptr) {
262 TELEPHONY_LOGE("nullptr error.");
263 return false;
264 }
265 uint16_t current = buffer.GetIndex();
266
267 /* UDL */
268 uint8_t udl = 0;
269 if (!buffer.ReadByte(udl)) {
270 TELEPHONY_LOGE("get data error.");
271 return false;
272 }
273 if (udl > UCS2_USER_DATA_LEN || (udl + buffer.GetIndex() - 1) > buffer.GetSize()) {
274 TELEPHONY_LOGE("udl error.");
275 userData->length = 0;
276 userData->headerCnt = 0;
277 return false;
278 }
279 if (buffer.data_ == nullptr) {
280 TELEPHONY_LOGE("buffer error.");
281 return false;
282 }
283 /* Setting for Wap Push */
284 if (pTPUD != nullptr) {
285 pTPUD->udl = udl;
286 if (memcpy_s(pTPUD->ud, sizeof(pTPUD->ud), buffer.data_.get() + buffer.GetIndex(), udl) != EOK) {
287 TELEPHONY_LOGE("memcpy_s error.");
288 return false;
289 }
290 pTPUD->ud[udl] = '\0';
291 }
292
293 return DecodeUcs2PduPartData(buffer, bHeaderInd, userData, current, udl);
294 }
295
DecodeUcs2PduPartData(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,uint16_t current,uint8_t udl)296 bool GsmUserDataDecode::DecodeUcs2PduPartData(
297 SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, uint16_t current, uint8_t udl)
298 {
299 if (userData_ == nullptr) {
300 TELEPHONY_LOGE("nullptr error.");
301 return false;
302 }
303 uint8_t udhl = 0;
304 /* Decode User Data Header */
305 if (bHeaderInd == true) {
306 /* UDHL */
307 if (!buffer.ReadByte(udhl)) {
308 TELEPHONY_LOGE("get data error.");
309 return false;
310 }
311 userData->headerCnt = 0;
312 for (uint8_t i = 0; buffer.GetIndex() < udhl + current && i < MAX_UD_HEADER_NUM; i++) {
313 uint16_t headerLen;
314 if (!userData_->DecodeHeader(buffer, userData->header[i], headerLen)) {
315 TELEPHONY_LOGE("DecodeHeader error");
316 return false;
317 }
318 if (headerLen == 0 || buffer.GetIndex() > (current + udhl + SLIDE_DATA_STEP)) {
319 TELEPHONY_LOGI("data error");
320 userData_->ResetUserData(*userData);
321 return false;
322 }
323 userData->headerCnt++;
324 }
325 } else {
326 userData->headerCnt = 0;
327 }
328
329 if (udhl > 0 && udl > udhl + 1) {
330 userData->length = (udl) - (udhl + 1);
331 } else {
332 userData->length = udl;
333 }
334
335 if (buffer.data_ == nullptr || (buffer.GetIndex() + userData->length > buffer.GetSize() + 1)) {
336 TELEPHONY_LOGE("buffer error.");
337 return false;
338 }
339 if (memcpy_s(userData->data, sizeof(userData->data), buffer.data_.get() + buffer.GetIndex(), userData->length) !=
340 EOK) {
341 TELEPHONY_LOGE("memcpy_s error.");
342 return false;
343 }
344
345 buffer.MoveForward(userData->length);
346 userData->data[userData->length] = 0;
347 return true;
348 }
349 } // namespace Telephony
350 } // namespace OHOS