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_UDHL = 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 || len > sizeof(pTPUD->ud)) {
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_UDHL) {
185         pTPUD->udl = udl - WAP_PUSH_UDHL;
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 + WAP_PUSH_UDHL > 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_UDHL,
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) || buffer.GetIndex() >= buffer.GetSize()) {
240         TELEPHONY_LOGE("udl length or buffer error");
241         return false;
242     }
243     uint8_t remain = buffer.GetSize() - buffer.GetIndex();
244     uint8_t len = userData->length < remain ? userData->length : remain;
245     if (buffer.data_ == nullptr || len > sizeof(userData->data)) {
246         TELEPHONY_LOGE("buffer error.");
247         return false;
248     }
249     if (memcpy_s(userData->data, sizeof(userData->data), buffer.data_.get() + buffer.GetIndex(), len) != EOK) {
250         TELEPHONY_LOGE("memcpy_s error");
251         return false;
252     }
253     buffer.MoveForward(userData->length);
254     return true;
255 }
256 
DecodeUcs2Pdu(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,struct SmsTpud * pTPUD)257 bool GsmUserDataDecode::DecodeUcs2Pdu(
258     SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, struct SmsTpud *pTPUD)
259 {
260     if (userData == nullptr) {
261         TELEPHONY_LOGE("nullptr error.");
262         return false;
263     }
264     uint16_t current = buffer.GetIndex();
265 
266     /* UDL */
267     uint8_t udl = 0;
268     if (!buffer.ReadByte(udl)) {
269         TELEPHONY_LOGE("get data error.");
270         return false;
271     }
272     if (udl > UCS2_USER_DATA_LEN || (udl + buffer.GetIndex() - 1) > buffer.GetSize()) {
273         TELEPHONY_LOGE("udl error.");
274         userData->length = 0;
275         userData->headerCnt = 0;
276         return false;
277     }
278     if (buffer.data_ == nullptr) {
279         TELEPHONY_LOGE("buffer error.");
280         return false;
281     }
282     /* Setting for Wap Push */
283     if (pTPUD != nullptr) {
284         pTPUD->udl = udl;
285         if (udl > sizeof(pTPUD->ud) || (buffer.GetIndex() + udl) > buffer.GetSize()) {
286             TELEPHONY_LOGE("udl error.");
287             return false;
288         }
289         if (memcpy_s(pTPUD->ud, sizeof(pTPUD->ud), buffer.data_.get() + buffer.GetIndex(), udl) != EOK) {
290             TELEPHONY_LOGE("memcpy_s error.");
291             return false;
292         }
293         pTPUD->ud[udl] = '\0';
294     }
295     return DecodeUcs2PduPartData(buffer, bHeaderInd, userData, current, udl);
296 }
297 
DecodeUcs2PduPartData(SmsReadBuffer & buffer,bool bHeaderInd,struct SmsUDPackage * userData,uint16_t current,uint8_t udl)298 bool GsmUserDataDecode::DecodeUcs2PduPartData(
299     SmsReadBuffer &buffer, bool bHeaderInd, struct SmsUDPackage *userData, uint16_t current, uint8_t udl)
300 {
301     if (userData_ == nullptr) {
302         TELEPHONY_LOGE("nullptr error.");
303         return false;
304     }
305     uint8_t udhl = 0;
306     userData->headerCnt = 0;
307     /* Decode User Data Header */
308     if (bHeaderInd == true) {
309         /* UDHL */
310         if (!buffer.ReadByte(udhl)) {
311             TELEPHONY_LOGE("get data error.");
312             return false;
313         }
314         for (uint8_t i = 0; buffer.GetIndex() < udhl + current && i < MAX_UD_HEADER_NUM; i++) {
315             uint16_t headerLen;
316             if (!userData_->DecodeHeader(buffer, userData->header[i], headerLen)) {
317                 TELEPHONY_LOGE("DecodeHeader error");
318                 return false;
319             }
320             if (headerLen == 0 || buffer.GetIndex() > (current + udhl + SLIDE_DATA_STEP)) {
321                 TELEPHONY_LOGI("data error");
322                 userData_->ResetUserData(*userData);
323                 return false;
324             }
325             userData->headerCnt++;
326         }
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.GetIndex() >= buffer.GetSize()) {
336         TELEPHONY_LOGE("udl length or buffer error");
337         return false;
338     }
339     uint8_t remain = buffer.GetSize() - buffer.GetIndex();
340     uint8_t len = userData->length < remain ? userData->length : remain;
341     if (buffer.data_ == nullptr || len > sizeof(userData->data)) {
342         TELEPHONY_LOGE("buffer error.");
343         return false;
344     }
345     if (memcpy_s(userData->data, sizeof(userData->data), buffer.data_.get() + buffer.GetIndex(), len) != EOK) {
346         TELEPHONY_LOGE("memcpy_s error.");
347         return false;
348     }
349 
350     buffer.MoveForward(userData->length);
351     uint8_t index = userData->length >= sizeof(userData->data) ? sizeof(userData->data) - 1 : userData->length;
352     userData->data[index] = 0;
353     return true;
354 }
355 } // namespace Telephony
356 } // namespace OHOS