1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Copyright (C) 2014 Samsung Electronics Co., Ltd. All rights reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "cdma_sms_pdu_codec.h"
18
19 #include "gsm_sms_udata_codec.h"
20 #include "securec.h"
21 #include "sms_common_utils.h"
22 #include "telephony_log_wrapper.h"
23
24 namespace OHOS {
25 namespace Telephony {
26 static constexpr uint8_t MSG_UDID_PARAM_LEN = 3;
27 static constexpr uint8_t BYTE_BITS = 8;
28 static constexpr uint8_t SHIFT_1BITS = 1;
29 static constexpr uint8_t SHIFT_2BITS = 2;
30 static constexpr uint8_t SHIFT_3BITS = 3;
31 static constexpr uint8_t SHIFT_4BITS = 4;
32 static constexpr uint8_t SHIFT_5BITS = 5;
33 static constexpr uint8_t SHIFT_6BITS = 6;
34 static constexpr uint8_t SHIFT_7BITS = 7;
35 static constexpr uint8_t SHIFT_8BITS = 8;
36
37 static constexpr uint8_t BYTE_STEP = 1;
38 static constexpr uint8_t MIN_PDU_LEN = 2;
39 static constexpr uint8_t HEX_BYTE_STEP = 2;
40 static constexpr uint8_t MAX_MSG_ID_LEN = 5;
41 static constexpr uint8_t DECIMAL_NUM = 10;
42 static constexpr uint8_t ENCODE_GSM_BIT = 7;
43 static constexpr uint8_t ENCODE_BYTE_BIT = 7;
44 static constexpr uint8_t BYTE_BIT = 8;
45 static constexpr uint8_t MAX_TPDU_DATA_LEN = 255;
46
ShiftNBit(unsigned char * src,unsigned int nBytes,unsigned int nShiftBit)47 void CdmaSmsPduCodec::ShiftNBit(unsigned char *src, unsigned int nBytes, unsigned int nShiftBit)
48 {
49 if (src == nullptr) {
50 TELEPHONY_LOGE("Source is null!");
51 return;
52 }
53
54 for (unsigned int index = 1; index < nBytes; index++) {
55 if (BYTE_BITS < nShiftBit) {
56 TELEPHONY_LOGE("ShiftNBit BYTE_BITS less than nShiftBit");
57 return;
58 }
59 unsigned char temp = src[index] >> (BYTE_BITS - nShiftBit);
60 src[index - 1] |= temp;
61 src[index] = (unsigned int)src[index] << nShiftBit;
62 }
63 }
64
ShiftRNBit(unsigned char * src,unsigned int nBytes,unsigned int nShiftBit)65 void CdmaSmsPduCodec::ShiftRNBit(unsigned char *src, unsigned int nBytes, unsigned int nShiftBit)
66 {
67 unsigned char bit = 0x00;
68 if (src == nullptr) {
69 TELEPHONY_LOGE("Source is null!");
70 return;
71 }
72 for (unsigned int index = 0; index <= nBytes; index++) {
73 unsigned char temp = src[index] >> (nShiftBit);
74 temp |= bit;
75 if (BYTE_BITS < nShiftBit) {
76 TELEPHONY_LOGE("ShiftRNBit BYTE_BITS less than nShiftBit");
77 return;
78 }
79 bit = ((unsigned int)src[index] << (BYTE_BITS - nShiftBit));
80 src[index] = temp;
81 }
82 }
83
ShiftNBitForDecode(unsigned char * src,unsigned int nBytes,unsigned int nShiftBit)84 void CdmaSmsPduCodec::ShiftNBitForDecode(unsigned char *src, unsigned int nBytes, unsigned int nShiftBit)
85 {
86 if (src == nullptr) {
87 TELEPHONY_LOGE("Source is null!");
88 return;
89 }
90
91 for (unsigned int index = 0; index < nBytes; index++) {
92 (src[index]) <<= nShiftBit;
93 if (BYTE_BITS < nShiftBit) {
94 TELEPHONY_LOGE("ShiftNBitForDecode BYTE_BITS less than nShiftBit");
95 return;
96 }
97 src[index] |= (src[index + 1] >> (BYTE_BITS - nShiftBit));
98 }
99 }
100
ConvertToBCD(const unsigned char val)101 unsigned char CdmaSmsPduCodec::ConvertToBCD(const unsigned char val)
102 {
103 return static_cast<unsigned char>((val / DECIMAL_NUM) << SHIFT_4BITS) | (val % DECIMAL_NUM);
104 }
105
DecodeDigitModeNumberType(const unsigned char val,bool isNumber)106 unsigned char CdmaSmsPduCodec::DecodeDigitModeNumberType(const unsigned char val, bool isNumber)
107 {
108 unsigned char temp = (val >> SHIFT_5BITS);
109 if (isNumber) {
110 if (temp >= SMS_TRANS_DNET_UNKNOWN && temp <= SMS_TRANS_DNET_RESERVED) {
111 return temp;
112 } else {
113 return SMS_TRANS_DNET_RESERVED;
114 }
115 } else {
116 if (temp >= SMS_NUMBER_TYPE_UNKNOWN && temp <= SMS_NUMBER_TYPE_RESERVED_7) {
117 return temp;
118 }
119 return SMS_NUMBER_TYPE_UNKNOWN;
120 }
121 }
122
DecodeDigitModeNumberPlan(const unsigned char val)123 unsigned char CdmaSmsPduCodec::DecodeDigitModeNumberPlan(const unsigned char val)
124 {
125 unsigned char numberPlan = 0;
126 switch (val) {
127 case SMS_NPI_UNKNOWN:
128 numberPlan = SMS_NPI_UNKNOWN;
129 break;
130 case SMS_NPI_ISDN:
131 numberPlan = SMS_NPI_ISDN;
132 break;
133 case SMS_NPI_DATA:
134 numberPlan = SMS_NPI_DATA;
135 break;
136 case SMS_NPI_TELEX:
137 numberPlan = SMS_NPI_TELEX;
138 break;
139 case SMS_NPI_PRIVATE:
140 numberPlan = SMS_NPI_PRIVATE;
141 break;
142 case SMS_NPI_RESERVED:
143 default:
144 numberPlan = SMS_NPI_RESERVED;
145 break;
146 }
147 return numberPlan;
148 }
149
CheckInvalidPDU(const std::vector<unsigned char> & pduStr)150 bool CdmaSmsPduCodec::CheckInvalidPDU(const std::vector<unsigned char> &pduStr)
151 {
152 std::size_t offset = 0;
153 if (pduStr.size() < MIN_PDU_LEN) {
154 TELEPHONY_LOGE("Invalid PDU : pdu size less than 2 is invalid");
155 return false;
156 }
157 if (!(pduStr[offset] == SMS_TRANS_P2P_MSG || pduStr[offset] == SMS_TRANS_BROADCAST_MSG ||
158 pduStr[offset] == SMS_TRANS_ACK_MSG)) {
159 TELEPHONY_LOGE("Invalid PDU : Message Type [%{public}2x]", pduStr[offset]);
160 return false;
161 }
162 offset++;
163 while (offset < pduStr.size()) {
164 if (pduStr[offset] >= 0 && pduStr[offset] <= 0x08) {
165 offset += (pduStr[offset + 1] + HEX_BYTE_STEP);
166 } else {
167 TELEPHONY_LOGE("Invalid PDU : Parameter ID [%{public}2x]", pduStr[offset]);
168 return false;
169 }
170 }
171 if (offset != pduStr.size()) {
172 TELEPHONY_LOGE("Invalid PDU !");
173 return false;
174 }
175 return true;
176 }
177
EncodeMsg(const struct SmsTransMsg & transMsg,unsigned char * pduStr,size_t pduStrLen)178 int CdmaSmsPduCodec::EncodeMsg(const struct SmsTransMsg &transMsg, unsigned char *pduStr, size_t pduStrLen)
179 {
180 int encodeSize = 0;
181 switch (transMsg.type) {
182 case SMS_TRANS_P2P_MSG:
183 encodeSize = EncodeP2PMsg(transMsg.data.p2pMsg, pduStr);
184 break;
185 case SMS_TRANS_BROADCAST_MSG:
186 encodeSize = EncodeCBMsg(transMsg.data.cbMsg, pduStr);
187 break;
188 case SMS_TRANS_ACK_MSG:
189 encodeSize = EncodeAckMsg(transMsg.data.ackMsg, pduStr);
190 break;
191 default:
192 break;
193 }
194 if (static_cast<size_t>(encodeSize) > pduStrLen) {
195 TELEPHONY_LOGE("encodeSize should not more than pduStrLen");
196 return 0;
197 }
198
199 return encodeSize;
200 }
201
EncodeP2PMsg(const struct SmsTransP2PMsg & p2pMsg,unsigned char * pduStr)202 int CdmaSmsPduCodec::EncodeP2PMsg(const struct SmsTransP2PMsg &p2pMsg, unsigned char *pduStr)
203 {
204 int offset = 0;
205 int encodeSize = 0;
206 int index = 0;
207 if (pduStr == nullptr) {
208 TELEPHONY_LOGE("PDU is null!");
209 return offset;
210 }
211
212 pduStr[offset++] = SMS_TRANS_P2P_MSG;
213 /* 1. teleservice id */
214 pduStr[offset++] = SMS_TRANS_PARAM_TELESVC_IDENTIFIER;
215 pduStr[offset++] = 0x02;
216 pduStr[offset++] = (0xff00 & p2pMsg.transTelesvcId) >> SHIFT_8BITS;
217 pduStr[offset++] = (0x00ff & p2pMsg.transTelesvcId);
218 /* 2. Service category */
219 if (p2pMsg.transSvcCtg < SMS_TRANS_SVC_CTG_UNDEFINED) {
220 pduStr[offset++] = SMS_TRANS_PARAM_SERVICE_CATEGORY;
221 pduStr[offset++] = 0x02;
222 pduStr[offset++] = (0xff00 & p2pMsg.transSvcCtg) >> SHIFT_8BITS;
223 pduStr[offset++] = (0x00ff & p2pMsg.transSvcCtg);
224 }
225 /* 3. Address */
226 offset += EncodeAddress(p2pMsg.address, &pduStr[offset]);
227 /* 4. Sub address (optional) */
228 offset += EncodeSubAddress(p2pMsg.subAddress, &pduStr[offset]);
229 /* 5. Bearer reply option (optional) */
230 if (p2pMsg.transReplySeq > 0) {
231 pduStr[offset++] = SMS_TRANS_PARAM_BEARER_REPLY_OPTION;
232 pduStr[offset++] = 0x01;
233 pduStr[offset++] = (p2pMsg.transReplySeq << SHIFT_2BITS);
234 TELEPHONY_LOGI("Reply sequnce number = [%{public}d]", p2pMsg.transReplySeq);
235 }
236 /* 6. Bearer data */
237 pduStr[offset++] = SMS_TRANS_PARAM_BEARER_DATA;
238 /* PARAMETER_LEN field should be filled at the last part. */
239 index = offset++;
240 encodeSize = EncodeTelesvcMsg(p2pMsg.telesvcMsg, &pduStr[offset]);
241 /* PARAMETER_LEN */
242 pduStr[index] = encodeSize;
243 offset += encodeSize;
244 return offset;
245 }
246
EncodeCBMsg(const struct SmsTransBroadCastMsg & cbMsg,unsigned char * pduStr)247 int CdmaSmsPduCodec::EncodeCBMsg(const struct SmsTransBroadCastMsg &cbMsg, unsigned char *pduStr)
248 {
249 int offset = 0;
250 int encodeSize = 0;
251 int lenIndex = 0;
252
253 if (pduStr == nullptr) {
254 TELEPHONY_LOGE("PDU is null!");
255 return offset;
256 }
257 /* 1. Service Category(Mandatory) */
258 pduStr[offset++] = SMS_TRANS_PARAM_SERVICE_CATEGORY;
259 pduStr[offset++] = 0x02;
260
261 pduStr[offset++] = (0xff00 & cbMsg.transSvcCtg) >> SHIFT_8BITS;
262 pduStr[offset++] = (0x00ff & cbMsg.transSvcCtg);
263
264 /* 2. Bearer Data(Optional) */
265 pduStr[offset++] = SMS_TRANS_PARAM_BEARER_DATA;
266 /* PARAMETER_LEN field should be filled at the last part. */
267 lenIndex = offset++;
268 encodeSize = EncodeTelesvcMsg(cbMsg.telesvcMsg, &pduStr[offset]);
269 /* PARAMETER_LEN */
270 pduStr[lenIndex] = encodeSize;
271 offset += encodeSize;
272 return offset;
273 }
274
EncodeAckMsg(const struct SmsTransAckMsg & ackMsg,unsigned char * pduStr)275 int CdmaSmsPduCodec::EncodeAckMsg(const struct SmsTransAckMsg &ackMsg, unsigned char *pduStr)
276 {
277 int offset = 0;
278 int index = 0;
279 if (pduStr == nullptr) {
280 return offset;
281 }
282 /* 1. Address */
283 offset += EncodeAddress(ackMsg.address, &pduStr[offset]);
284 /* 2. Sub address */
285 offset += EncodeSubAddress(ackMsg.subAddress, &pduStr[offset]);
286 /* 3. Cause code */
287 pduStr[offset++] = SMS_TRANS_PARAM_CAUSE_CODES;
288 index = offset++;
289 pduStr[offset] |= ackMsg.causeCode.transReplySeq << SHIFT_2BITS;
290 pduStr[offset] |= static_cast<unsigned char>(ackMsg.causeCode.errorClass);
291 if (ackMsg.causeCode.errorClass != 0x0) {
292 pduStr[++offset] = ackMsg.causeCode.causeCode;
293 }
294 pduStr[index] = offset - index;
295 return offset;
296 }
297
EncodeTelesvcMsg(const struct SmsTeleSvcMsg & svcMsg,unsigned char * pduStr)298 int CdmaSmsPduCodec::EncodeTelesvcMsg(const struct SmsTeleSvcMsg &svcMsg, unsigned char *pduStr)
299 {
300 int encodeSize = 0;
301 TELEPHONY_LOGI("Teleservice msg type = [%{public}d]", svcMsg.type);
302 switch (svcMsg.type) {
303 case SMS_TYPE_SUBMIT:
304 encodeSize = EncodeTelesvcSubmitMsg(svcMsg.data.submit, pduStr);
305 break;
306 case SMS_TYPE_CANCEL:
307 encodeSize = EncodeTelesvcCancelMsg(svcMsg.data.cancel, pduStr);
308 break;
309 case SMS_TYPE_DELIVER_REPORT:
310 encodeSize = EncodeTelesvcDeliverReportMsg(svcMsg.data.report, pduStr);
311 break;
312 case SMS_TYPE_DELIVER:
313 case SMS_TYPE_USER_ACK:
314 case SMS_TYPE_READ_ACK:
315 default:
316 TELEPHONY_LOGI("No matching type for [%{public}d]", svcMsg.type);
317 break;
318 }
319 return encodeSize;
320 }
321
EncodeTelesvcDeliverReportMsg(const struct SmsTeleSvcDeliverReport & dRMsg,unsigned char * pduStr)322 int CdmaSmsPduCodec::EncodeTelesvcDeliverReportMsg(
323 const struct SmsTeleSvcDeliverReport &dRMsg, unsigned char *pduStr)
324 {
325 int offset = 0;
326 if (pduStr == nullptr) {
327 TELEPHONY_LOGE("PDU is null!");
328 return offset;
329 }
330 /* 1. Message Identifier (Mandatory) */
331 offset += EncodeMsgId(dRMsg.msgId, SMS_TYPE_DELIVER_REPORT, pduStr);
332 /* 2. TP-Failure Cause (Conditional) */
333 if (dRMsg.tpFailCause >= 0x80) {
334 pduStr[offset++] = SMS_BEARER_TP_FAILURE_CAUSE;
335 pduStr[offset++] = 0x01;
336 pduStr[offset++] = dRMsg.tpFailCause;
337 }
338 /* 3. User Data (Optional) */
339 offset += EncodeBearerUserData(dRMsg.userData, &pduStr[offset]);
340 return offset;
341 }
342
EncodeTelesvcCancelMsg(const struct SmsTeleSvcCancel & cancelMsg,unsigned char * pduStr)343 int CdmaSmsPduCodec::EncodeTelesvcCancelMsg(const struct SmsTeleSvcCancel &cancelMsg, unsigned char *pduStr)
344 {
345 return EncodeMsgId(cancelMsg.msgId, SMS_TYPE_CANCEL, pduStr);
346 }
347
EncodeTelesvcSubmitMsg(const struct SmsTeleSvcSubmit & sbMsg,unsigned char * pduStr)348 int CdmaSmsPduCodec::EncodeTelesvcSubmitMsg(const struct SmsTeleSvcSubmit &sbMsg, unsigned char *pduStr)
349 {
350 int offset = 0;
351 if (pduStr == nullptr) {
352 TELEPHONY_LOGE("PDU is null!");
353 return offset;
354 }
355
356 /* 1. Message Identifier */
357 offset += EncodeMsgId(sbMsg.msgId, SMS_TYPE_SUBMIT, &pduStr[offset]);
358 /* 2. User Data */
359 offset += EncodeBearerUserData(sbMsg.userData, &pduStr[offset]);
360 /* 3. Deferred Delivery Time */
361 if (sbMsg.deferValPeriod.format == SMS_TIME_RELATIVE) {
362 pduStr[offset++] = SMS_BEARER_DEFERRED_DELIVERY_TIME_RELATIVE;
363 pduStr[offset++] = 0x01;
364 pduStr[offset++] = sbMsg.deferValPeriod.time.relTime.time;
365 } else if (sbMsg.deferValPeriod.format == SMS_TIME_ABSOLUTE) {
366 std::vector<unsigned char> temp;
367 pduStr[offset++] = SMS_BEARER_DEFERRED_DELIVERY_TIME_ABSOLUTE;
368 pduStr[offset++] = EncodeAbsTime(sbMsg.deferValPeriod.time.absTime, temp);
369 for (std::size_t i = 0; i < temp.size(); i++) {
370 pduStr[offset++] = temp[i];
371 }
372 }
373 /* 5. Priority Indicator */
374 if (sbMsg.priority >= SMS_PRIORITY_NORMAL && sbMsg.priority <= SMS_PRIORITY_EMERGENCY) {
375 pduStr[offset++] = SMS_BEARER_PRIORITY_INDICATOR;
376 pduStr[offset++] = 0x01;
377 pduStr[offset++] = sbMsg.priority << SHIFT_6BITS;
378 }
379 /* 7. Reply Option */
380 if (sbMsg.replyOpt.userAckReq | sbMsg.replyOpt.deliverAckReq | sbMsg.replyOpt.readAckReq |
381 sbMsg.replyOpt.reportReq) {
382 pduStr[offset++] = SMS_BEARER_REPLY_OPTION;
383 pduStr[offset++] = 0x01;
384 pduStr[offset] |= sbMsg.replyOpt.userAckReq << SHIFT_7BITS;
385 pduStr[offset] |= sbMsg.replyOpt.deliverAckReq << SHIFT_6BITS;
386 pduStr[offset] |= (unsigned int)(sbMsg.replyOpt.readAckReq) << SHIFT_5BITS;
387 pduStr[offset++] |= sbMsg.replyOpt.reportReq << SHIFT_4BITS;
388 }
389
390 if (sbMsg.callbackNumber.addrLen > 0) {
391 std::vector<unsigned char> temp;
392 pduStr[offset++] = SMS_BEARER_CALLBACK_NUMBER;
393 pduStr[offset++] = EncodeCbNumber(sbMsg.callbackNumber, temp);
394 for (std::size_t i = 0; i < temp.size(); i++) {
395 pduStr[offset++] = temp[i];
396 }
397 }
398
399 return offset;
400 }
401
EncodeCbNumber(const SmsTeleSvcAddr & cbNumber,std::vector<unsigned char> & pdustr)402 int CdmaSmsPduCodec::EncodeCbNumber(const SmsTeleSvcAddr &cbNumber, std::vector<unsigned char> &pdustr)
403 {
404 unsigned char temp = cbNumber.digitMode ? 0x80 : 0x00;
405 if (cbNumber.digitMode == false) {
406 temp |= (cbNumber.addrLen & 0xfe) >> SHIFT_1BITS;
407 pdustr.push_back(temp);
408
409 int offset = 0;
410 unsigned char cbData[SMS_TRANS_ADDRESS_MAX_LEN] = { 0 };
411 cbData[offset] |= (cbNumber.addrLen & 0x01) << SHIFT_7BITS;
412 int addrLen =
413 SmsCommonUtils::ConvertDigitToDTMF(cbNumber.szData, cbNumber.addrLen, SHIFT_1BITS, cbData + offset);
414 pdustr.insert(pdustr.end(), cbData, cbData + addrLen);
415 } else if (cbNumber.digitMode == true) {
416 temp |= cbNumber.numberType << SHIFT_6BITS;
417 temp |= cbNumber.numberPlan;
418 pdustr.push_back(temp);
419 pdustr.push_back(cbNumber.addrLen);
420 pdustr.insert(pdustr.end(), cbNumber.szData, cbNumber.szData + cbNumber.addrLen);
421 }
422 return static_cast<int>(pdustr.size());
423 }
424
EncodeAbsTime(const SmsTimeAbs & absTime,std::vector<unsigned char> & pdustr)425 int CdmaSmsPduCodec::EncodeAbsTime(const SmsTimeAbs &absTime, std::vector<unsigned char> &pdustr)
426 {
427 pdustr.push_back(ConvertToBCD(absTime.year));
428 pdustr.push_back(ConvertToBCD(absTime.month));
429 pdustr.push_back(ConvertToBCD(absTime.day));
430 pdustr.push_back(ConvertToBCD(absTime.hour));
431 pdustr.push_back(ConvertToBCD(absTime.minute));
432 pdustr.push_back(ConvertToBCD(absTime.second));
433 return static_cast<int>(pdustr.size());
434 }
435
EncodeMsgId(const SmsTransMsgId & msgId,const SmsMessageType & type,unsigned char * pduStr)436 int CdmaSmsPduCodec::EncodeMsgId(const SmsTransMsgId &msgId, const SmsMessageType &type, unsigned char *pduStr)
437 {
438 int offset = 0;
439 if (pduStr == nullptr) {
440 return offset;
441 }
442 pduStr[offset++] = SMS_BEARER_MESSAGE_IDENTIFIER;
443 pduStr[offset++] = 0x03;
444 pduStr[offset++] = ((unsigned int)type << SHIFT_4BITS) | ((msgId.msgId & 0xf000) >> (BYTE_BITS + SHIFT_4BITS));
445 pduStr[offset++] = (msgId.msgId & 0x0ff0) >> (SHIFT_4BITS);
446 pduStr[offset++] = ((msgId.msgId & 0x000f) << (SHIFT_4BITS)) | (msgId.headerInd ? 0x08 : 0x00);
447 return offset;
448 }
449
EncodeSubAddress(const struct SmsTransSubAddr & address,unsigned char * pduStr)450 int CdmaSmsPduCodec::EncodeSubAddress(const struct SmsTransSubAddr &address, unsigned char *pduStr)
451 {
452 unsigned int index = 0;
453 unsigned int offset = 0;
454 if (pduStr == nullptr || address.addrLen == 0) {
455 TELEPHONY_LOGE("PDU is null!");
456 return offset;
457 }
458 pduStr[offset++] = SMS_TRANS_PARAM_ORG_SUB_ADDRESS;
459 pduStr[offset] = address.addrLen + 0x02;
460 index = offset++;
461 pduStr[offset] |= static_cast<unsigned char>(address.type) << SHIFT_5BITS;
462 pduStr[offset++] |= (address.odd ? 0x10 : 0x00);
463 pduStr[offset++] = address.addrLen;
464 if (memcpy_s(pduStr + offset, address.addrLen, address.szData, address.addrLen) != EOK) {
465 TELEPHONY_LOGE("EncodeSubAddress memcpy_s err.");
466 return offset;
467 }
468 offset += address.addrLen;
469 ShiftNBit(&pduStr[index], offset - index + 1, SHIFT_4BITS);
470 return offset;
471 }
472
EncodeAddress(const SmsTransAddr & address,unsigned char * pduStr)473 int CdmaSmsPduCodec::EncodeAddress(const SmsTransAddr &address, unsigned char *pduStr)
474 {
475 unsigned int index = 0;
476 unsigned int offset = 0;
477 unsigned int lenIndex = 0;
478 if (pduStr == nullptr) {
479 TELEPHONY_LOGE("PDU is null!");
480 return offset;
481 }
482
483 pduStr[offset++] = SMS_TRANS_PARAM_DEST_ADDRESS; /* Will be set to param length */
484 lenIndex = offset++; // then lenIndex 1
485
486 pduStr[offset] = (address.digitMode ? 0x80 : 0x00);
487 pduStr[offset] |= (address.numberMode ? 0x40 : 0x00);
488 if (address.digitMode) {
489 pduStr[offset] |= address.numberType << SHIFT_3BITS;
490 }
491
492 if (address.digitMode) {
493 if (address.numberMode) {
494 index = offset++;
495 pduStr[offset++] = address.addrLen;
496 if (memcpy_s(pduStr + offset, address.addrLen, address.szData, address.addrLen) != EOK) {
497 TELEPHONY_LOGE("EncodeAddress numberMode memcpy_s fail.");
498 return offset;
499 }
500 offset += address.addrLen;
501 ShiftNBit(&pduStr[index], offset - index + 1, SHIFT_3BITS);
502 } else {
503 pduStr[offset++] |= address.numberPlan >> SHIFT_1BITS;
504 pduStr[offset++] |= address.numberPlan << SHIFT_7BITS;
505 index = offset - 1;
506 pduStr[offset++] = address.addrLen;
507 if (memcpy_s(pduStr + offset, address.addrLen, address.szData, address.addrLen) != EOK) {
508 TELEPHONY_LOGE("EncodeAddress mecpy_s fail.");
509 return offset;
510 }
511 offset += address.addrLen;
512 ShiftNBit(&pduStr[index], offset - index + 1, SHIFT_7BITS);
513 }
514 } else {
515 index = offset++;
516 pduStr[offset++] = address.addrLen;
517 int addrLen = SmsCommonUtils::ConvertDigitToDTMF(address.szData, address.addrLen, 0, pduStr + offset);
518 offset += addrLen;
519 ShiftNBit(&pduStr[index], offset - index + 1, SHIFT_6BITS);
520 }
521 pduStr[lenIndex] = offset - lenIndex - 1;
522 TELEPHONY_LOGI("Address subparam length field = [%{public}d]", pduStr[lenIndex]);
523 return offset;
524 }
525
EncodeBearerUserData(const struct SmsTeleSvcUserData & userData,unsigned char * pduStr)526 int CdmaSmsPduCodec::EncodeBearerUserData(const struct SmsTeleSvcUserData &userData, unsigned char *pduStr)
527 {
528 int offset = 0;
529 int lenIndex = 0;
530 int encodeSize = 0;
531 if (pduStr == nullptr || userData.userData.length == 0) {
532 TELEPHONY_LOGE("PDU is null!");
533 return offset;
534 }
535
536 pduStr[offset++] = SMS_BEARER_USER_DATA;
537 lenIndex = offset;
538 offset++;
539 pduStr[offset++] = static_cast<unsigned char>(userData.encodeType) << SHIFT_3BITS;
540 if (userData.encodeType == SMS_ENCODE_EPM || userData.encodeType == SMS_ENCODE_GSMDCS) {
541 pduStr[offset++] = userData.msgType;
542 }
543
544 int remainBits = 0;
545 switch (userData.encodeType) {
546 case SMS_ENCODE_7BIT_ASCII: {
547 encodeSize = Encode7BitASCIIData(userData.userData, &pduStr[offset], remainBits);
548 TELEPHONY_LOGI("Encode7BitASCIIData remainBits %{public}d offset %{public}d", remainBits, offset);
549 offset += encodeSize;
550 break;
551 }
552 case SMS_ENCODE_GSM7BIT: {
553 encodeSize = Encode7BitGSMData(userData.userData, &pduStr[offset], remainBits);
554 TELEPHONY_LOGI("Encode7BitGSMData remainBits %{public}d offset %{public}d", remainBits, offset);
555 offset += encodeSize;
556 break;
557 }
558 case SMS_ENCODE_UNICODE: {
559 encodeSize = EncodeUCS2Data(userData.userData, &pduStr[offset], remainBits);
560 TELEPHONY_LOGI("EncodeUCS2Data remainBits %{public}d offset %{public}d", remainBits, offset);
561 offset += encodeSize;
562 break;
563 }
564 default: {
565 pduStr[offset++] = userData.userData.length;
566 if (memcpy_s(pduStr + offset, userData.userData.length, userData.userData.data,
567 userData.userData.length) == EOK) {
568 offset += userData.userData.length;
569 }
570 break;
571 }
572 }
573
574 ShiftNBit(&pduStr[lenIndex + 1], offset - lenIndex - 1, SHIFT_3BITS);
575
576 int padding = 0;
577 padding = (remainBits > 0) ? (BYTE_BITS - remainBits) : 0;
578 if (padding >= SHIFT_3BITS) {
579 offset--;
580 }
581 pduStr[lenIndex] = offset - lenIndex - 1;
582 return offset;
583 }
584
DecodeMsg(const unsigned char * pduStr,int pduLen,struct SmsTransMsg & transMsg)585 int CdmaSmsPduCodec::DecodeMsg(const unsigned char *pduStr, int pduLen, struct SmsTransMsg &transMsg)
586 {
587 int decodelen = 0;
588 int offset = 0;
589 if (pduStr == nullptr) {
590 TELEPHONY_LOGE("PDU is null!");
591 return decodelen;
592 }
593
594 char mti = pduStr[offset++] & 0xff;
595 if (pduLen < offset) {
596 return decodelen;
597 }
598 switch (mti) {
599 case SMS_TRANS_P2P_MSG:
600 transMsg.type = SMS_TRANS_P2P_MSG;
601 decodelen = DecodeP2PMsg(&pduStr[offset], pduLen - offset, transMsg.data.p2pMsg);
602 break;
603 case SMS_TRANS_BROADCAST_MSG:
604 transMsg.type = SMS_TRANS_BROADCAST_MSG;
605 decodelen = DecodeCBMsg(&pduStr[offset], pduLen - offset, transMsg.data.cbMsg);
606 break;
607 case SMS_TRANS_ACK_MSG:
608 transMsg.type = SMS_TRANS_ACK_MSG;
609 decodelen = DecodeAckMsg(&pduStr[offset], pduLen - offset, transMsg.data.ackMsg);
610 break;
611 default:
612 transMsg.type = SMS_TRANS_TYPE_RESERVED;
613 break;
614 }
615 return decodelen + offset;
616 }
617
DecodeP2PMsg(const unsigned char * pduStr,int pduLen,struct SmsTransP2PMsg & p2pMsg)618 int CdmaSmsPduCodec::DecodeP2PMsg(const unsigned char *pduStr, int pduLen, struct SmsTransP2PMsg &p2pMsg)
619 {
620 int offset = 0;
621 int tmpLen = 0;
622 if (pduStr == nullptr) {
623 TELEPHONY_LOGE("PDU is null!");
624 return offset;
625 }
626 while (offset < pduLen) {
627 switch (pduStr[offset]) {
628 case SMS_TRANS_PARAM_TELESVC_IDENTIFIER:
629 offset += DecodeTeleId(&pduStr[offset], pduLen - offset, p2pMsg.transTelesvcId);
630 break;
631 case SMS_TRANS_PARAM_SERVICE_CATEGORY:
632 offset += DecodeSvcCtg(&pduStr[offset], pduLen - offset, p2pMsg.transSvcCtg);
633 break;
634 case SMS_TRANS_PARAM_ORG_ADDRESS:
635 case SMS_TRANS_PARAM_DEST_ADDRESS:
636 offset += DecodeAddress(&pduStr[offset], pduLen - offset, p2pMsg.address);
637 break;
638 case SMS_TRANS_PARAM_ORG_SUB_ADDRESS:
639 case SMS_TRANS_PARAM_DEST_SUB_ADDRESS:
640 offset += DecodeSubAddress(&pduStr[offset], pduLen - offset, p2pMsg.subAddress);
641 break;
642 case SMS_TRANS_PARAM_BEARER_REPLY_OPTION:
643 offset += HEX_BYTE_STEP;
644 p2pMsg.transReplySeq = (pduStr[offset] >> SHIFT_2BITS);
645 offset++;
646 break;
647 case SMS_TRANS_PARAM_BEARER_DATA:
648 offset++;
649 tmpLen = pduStr[offset++];
650 DecodeP2PTelesvcMsg(&pduStr[offset], tmpLen, p2pMsg.telesvcMsg);
651 offset += (tmpLen + 1);
652 break;
653 default:
654 return offset;
655 }
656 }
657 return offset;
658 }
659
DecodeCBMsg(const unsigned char * pduStr,int pduLen,struct SmsTransBroadCastMsg & cbMsg)660 int CdmaSmsPduCodec::DecodeCBMsg(const unsigned char *pduStr, int pduLen, struct SmsTransBroadCastMsg &cbMsg)
661 {
662 int offset = 0;
663 int tempLen = 0;
664 if (pduStr == nullptr) {
665 TELEPHONY_LOGE("PDU is null!");
666 return offset;
667 }
668
669 while (offset < pduLen) {
670 switch (pduStr[offset]) {
671 case SMS_TRANS_PARAM_SERVICE_CATEGORY:
672 offset += DecodeTeleId(pduStr + offset, pduLen, cbMsg.transSvcCtg);
673 break;
674 case SMS_TRANS_PARAM_BEARER_DATA:
675 tempLen = pduStr[++offset];
676 offset++;
677 if (cbMsg.transSvcCtg >= SMS_TRANS_SVC_CTG_CMAS_PRESIDENTIAL &&
678 cbMsg.transSvcCtg <= SMS_TRANS_SVC_CTG_CMAS_TEST) {
679 DecodeCBBearerData(pduStr + offset, tempLen, cbMsg.telesvcMsg, true);
680 } else {
681 DecodeCBBearerData(pduStr + offset, tempLen, cbMsg.telesvcMsg, false);
682 }
683 offset += (tempLen + 1);
684 break;
685 default:
686 return offset;
687 }
688 }
689 return offset;
690 }
691
DecodeAckMsg(const unsigned char * pduStr,int pduLen,struct SmsTransAckMsg & ackMsg)692 int CdmaSmsPduCodec::DecodeAckMsg(const unsigned char *pduStr, int pduLen, struct SmsTransAckMsg &ackMsg)
693 {
694 int offset = 0;
695 if (pduStr == nullptr) {
696 TELEPHONY_LOGE("PDU is null!");
697 return offset;
698 }
699
700 while (offset < pduLen) {
701 switch (pduStr[offset]) {
702 case SMS_TRANS_PARAM_DEST_ADDRESS:
703 offset += DecodeAddress(pduStr + offset, pduLen, ackMsg.address);
704 break;
705 case SMS_TRANS_PARAM_DEST_SUB_ADDRESS:
706 offset += DecodeSubAddress(pduStr + offset, pduLen, ackMsg.subAddress);
707 break;
708 case SMS_TRANS_PARAM_CAUSE_CODES:
709 offset += HEX_BYTE_STEP;
710 ackMsg.causeCode.transReplySeq = pduStr[offset] >> SHIFT_2BITS;
711 if ((pduStr[offset++] & 0x03) == 0x00) {
712 ackMsg.causeCode.errorClass = SMS_TRANS_ERR_CLASS_NONE;
713 } else {
714 ackMsg.causeCode.causeCode = static_cast<enum SmsTransCauseCodeType>(pduStr[offset++]);
715 }
716 break;
717 default:
718 return offset;
719 }
720 }
721 return offset;
722 }
723
DecodeP2PTelesvcMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcMsg & svcMsg)724 void CdmaSmsPduCodec::DecodeP2PTelesvcMsg(const unsigned char *pduStr, int pduLen, struct SmsTeleSvcMsg &svcMsg)
725 {
726 if (pduStr == nullptr) {
727 TELEPHONY_LOGE("PDU is null!");
728 return;
729 }
730
731 std::vector<unsigned char> tempPdu(pduStr, pduStr + pduLen);
732 svcMsg.type = FindMsgType(tempPdu);
733 TELEPHONY_LOGI("Msg Type = [%{public}d]", svcMsg.type);
734 switch (svcMsg.type) {
735 case SMS_TYPE_DELIVER:
736 DecodeP2PDeliverMsg(pduStr, pduLen, svcMsg.data.deliver);
737 break;
738 case SMS_TYPE_SUBMIT:
739 DecodeP2PSubmitMsg(pduStr, pduLen, svcMsg.data.submit);
740 break;
741 case SMS_TYPE_DELIVERY_ACK:
742 DecodeP2PDeliveryAckMsg(pduStr, pduLen, svcMsg.data.deliveryAck);
743 break;
744 case SMS_TYPE_USER_ACK:
745 DecodeP2PUserAckMsg(pduStr, pduLen, svcMsg.data.userAck);
746 break;
747 case SMS_TYPE_READ_ACK:
748 DecodeP2PReadAckMsg(pduStr, pduLen, svcMsg.data.readAck);
749 break;
750 case SMS_TYPE_SUBMIT_REPORT:
751 default:
752 break;
753 }
754 }
755
DecodeP2PDeliverMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcDeliver & delMsg)756 void CdmaSmsPduCodec::DecodeP2PDeliverMsg(const unsigned char *pduStr, int pduLen, struct SmsTeleSvcDeliver &delMsg)
757 {
758 int offset = 0;
759 int tempLen;
760 int error = EOK;
761 unsigned char tempStr[pduLen + 1];
762 if (pduStr == nullptr) {
763 TELEPHONY_LOGE("PDU is null!");
764 return;
765 }
766
767 while (offset < pduLen) {
768 TELEPHONY_LOGI("current offset = [%{public}d] [%{public}x]", offset, pduStr[offset]);
769 switch (pduStr[offset]) {
770 case SMS_BEARER_MESSAGE_IDENTIFIER:
771 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, delMsg.msgId);
772 break;
773 case SMS_BEARER_USER_DATA:
774 offset += HEX_BYTE_STEP;
775 tempLen = pduStr[offset - 1];
776 if (tempLen > pduLen + 1) {
777 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
778 break;
779 }
780 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
781 if (error != EOK) {
782 TELEPHONY_LOGE("SMS_BEARER_USER_DATA memset_s err.");
783 break;
784 }
785 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) == EOK) {
786 bool headerInd = delMsg.msgId.headerInd;
787 DecodeUserData(tempStr, tempLen, delMsg.userData, headerInd);
788 offset += tempLen;
789 }
790 break;
791 case SMS_BEARER_MSG_CENTER_TIME_STAMP:
792 offset += HEX_BYTE_STEP;
793 offset += DecodeAbsTime(pduStr + offset, delMsg.timeStamp);
794 break;
795 case SMS_BEARER_VALIDITY_PERIOD_ABSOLUTE:
796 offset += HEX_BYTE_STEP;
797 delMsg.valPeriod.format = SMS_TIME_ABSOLUTE;
798 offset += DecodeAbsTime(pduStr + offset, delMsg.valPeriod.time.absTime);
799 break;
800 case SMS_BEARER_VALIDITY_PERIOD_RELATIVE:
801 offset += HEX_BYTE_STEP;
802 delMsg.valPeriod.format = SMS_TIME_RELATIVE;
803 delMsg.valPeriod.time.relTime.time = static_cast<enum SmsRelativeTime>(pduStr[offset++]);
804 break;
805 case SMS_BEARER_PRIORITY_INDICATOR:
806 offset += HEX_BYTE_STEP;
807 delMsg.priority = static_cast<enum SmsPriorityIndicator>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
808 break;
809 case SMS_BEARER_PRIVACY_INDICATOR:
810 offset += HEX_BYTE_STEP;
811 delMsg.privacy = static_cast<enum SmsPrivacyIndicator>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
812 break;
813 case SMS_BEARER_REPLY_OPTION:
814 offset += HEX_BYTE_STEP;
815 delMsg.replyOpt.userAckReq = (pduStr[offset] & 0x80) ? true : false;
816 delMsg.replyOpt.deliverAckReq = (pduStr[offset] & 0x40) ? true : false;
817 delMsg.replyOpt.readAckReq = (pduStr[offset] & 0x20) ? true : false;
818 delMsg.replyOpt.reportReq = (pduStr[offset] & 0x10) ? true : false;
819 offset++;
820 break;
821 case SMS_BEARER_NUMBER_OF_MESSAGES:
822 offset += HEX_BYTE_STEP;
823 delMsg.numMsg = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
824 offset++;
825 break;
826 case SMS_BEARER_ALERT_ON_MSG_DELIVERY:
827 offset += HEX_BYTE_STEP;
828 tempLen = pduStr[offset - 1];
829 if (tempLen > 0) {
830 delMsg.alertPriority =
831 static_cast<enum SmsAlertPriority>((pduStr[offset] & 0xc0) >> SHIFT_6BITS);
832 }
833 offset += tempLen;
834 break;
835 case SMS_BEARER_LANGUAGE_INDICATOR:
836 offset += HEX_BYTE_STEP;
837 delMsg.language = static_cast<enum SmsLanguageType>(pduStr[offset++]);
838 break;
839 case SMS_BEARER_CALLBACK_NUMBER:
840 offset += HEX_BYTE_STEP;
841 tempLen = pduStr[offset - 1];
842 DecodeCallBackNum(&pduStr[offset], tempLen, delMsg.callbackNumber);
843 offset += tempLen;
844 break;
845 case SMS_BEARER_MSG_DISPLAY_MODE:
846 offset += HEX_BYTE_STEP;
847 delMsg.displayMode = static_cast<enum SmsDisplayMode>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
848 break;
849 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
850 offset += HEX_BYTE_STEP;
851 tempLen = pduStr[offset - 1];
852 offset += tempLen;
853 break;
854 case SMS_BEARER_MSG_DEPOSIT_INDEX:
855 offset += HEX_BYTE_STEP;
856 delMsg.depositId = pduStr[offset++];
857 delMsg.depositId = (delMsg.depositId << SHIFT_8BITS) + pduStr[offset++];
858 break;
859 case SMS_BEARER_ENHANCED_VMN:
860 DecodeP2PEnhancedVmn(pduStr, pduLen, delMsg.enhancedVmn);
861 break;
862 case SMS_BEARER_ENHANCED_VMN_ACK:
863 DecodeP2PDeliverVmnAck(pduStr, pduLen, delMsg.enhancedVmnAck);
864 break;
865 default: /* skip unrecognized sub parameters */
866 offset++;
867 tempLen = pduStr[offset++];
868 offset += tempLen;
869 break;
870 }
871 }
872 }
873
DecodeP2PEnhancedVmn(const unsigned char * pduStr,int pduLen,struct SmsEnhancedVmn & enhancedVmn)874 void CdmaSmsPduCodec::DecodeP2PEnhancedVmn(
875 const unsigned char *pduStr, int pduLen, struct SmsEnhancedVmn &enhancedVmn)
876 {
877 int ret = 0;
878 int offset = 1;
879 int tempOff = 0;
880 offset++;
881 unsigned char tempStr[pduLen + 1];
882 offset++;
883 int tempLen = pduStr[offset++];
884 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
885 if (error != EOK) {
886 TELEPHONY_LOGE("DecodeP2PEnhancedVmn memset_s err.");
887 return;
888 }
889 if (tempLen > pduLen + 1) {
890 TELEPHONY_LOGE("data length invalid tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
891 return;
892 }
893 ret = memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen);
894 if (ret != EOK) {
895 TELEPHONY_LOGE("DecodeP2PEnhancedVmn memcpy_s");
896 return;
897 }
898 enhancedVmn.priority = (enum SmsPriorityIndicator)(pduStr[offset] >> SHIFT_6BITS);
899 enhancedVmn.passwordReq = (pduStr[offset] & 0x20) ? true : false;
900 enhancedVmn.setupReq = (pduStr[offset] & 0x10) ? true : false;
901 enhancedVmn.pwChangeReq = (pduStr[offset] & 0x08) ? true : false;
902
903 ShiftNBitForDecode(tempStr, tempLen, SHIFT_5BITS);
904 if (enhancedVmn.setupReq || enhancedVmn.pwChangeReq) {
905 enhancedVmn.minPwLen = tempStr[tempOff] >> SHIFT_4BITS;
906 enhancedVmn.maxPwLen = tempStr[tempOff++] & 0x0f;
907 }
908
909 enhancedVmn.vmNumUnheardMsg = tempStr[tempOff++];
910 enhancedVmn.vmMailboxAlmFull = (tempStr[tempOff] & 0x80) ? true : false;
911 enhancedVmn.vmMailboxFull = (tempStr[tempOff] & 0x40) ? true : false;
912 enhancedVmn.replyAllowed = (tempStr[tempOff] & 0x20) ? true : false;
913 enhancedVmn.faxIncluded = (tempStr[tempOff] & 0x10) ? true : false;
914 enhancedVmn.vmLen = (tempStr[tempOff] << SHIFT_8BITS) | tempStr[tempOff + 1];
915 tempOff += HEX_BYTE_STEP;
916 enhancedVmn.vmRetDay = tempStr[tempOff] >> SHIFT_1BITS;
917 ShiftNBitForDecode(tempStr, tempLen, SHIFT_7BITS);
918 enhancedVmn.vmMsgId = (tempStr[tempOff] << SHIFT_8BITS) | tempStr[tempOff + 1];
919 tempOff += HEX_BYTE_STEP;
920 enhancedVmn.vmMailboxId = (tempStr[tempOff] << SHIFT_8BITS) | tempStr[tempOff + 1];
921 tempOff += HEX_BYTE_STEP;
922
923 enhancedVmn.anDigitMode = (tempStr[tempOff] & 0x80) ? true : false;
924 enhancedVmn.anNumberType = (tempStr[tempOff] & 0x70) >> SHIFT_4BITS;
925 if (enhancedVmn.anDigitMode) {
926 enhancedVmn.anNumberPlan = tempStr[tempOff++] & 0x0f;
927 enhancedVmn.anNumField = tempStr[tempOff++];
928
929 int bcdLen = enhancedVmn.anNumField / HEX_BYTE_STEP;
930 bcdLen = (enhancedVmn.anNumField % HEX_BYTE_STEP == 0) ? bcdLen : bcdLen + 1;
931 SmsCommonUtils::BcdToDigitCdma(&(tempStr[tempOff]), bcdLen, reinterpret_cast<char *>(enhancedVmn.anChar));
932 enhancedVmn.anChar[enhancedVmn.anNumField] = '\0';
933 } else {
934 ShiftNBitForDecode(tempStr, tempLen, SHIFT_4BITS);
935 enhancedVmn.anNumField = tempStr[tempOff++];
936 ret = memset_s(enhancedVmn.anChar, sizeof(enhancedVmn.anChar), 0x00, sizeof(enhancedVmn.anChar));
937 if (ret != EOK) {
938 TELEPHONY_LOGE("enhancedVmn memset_s err.");
939 return;
940 }
941 if (static_cast<unsigned long>(enhancedVmn.anNumField) > sizeof(enhancedVmn.anChar)) {
942 TELEPHONY_LOGE("enhancedVmn memcpy_s data length invalid.");
943 return;
944 }
945 ret = memcpy_s(enhancedVmn.anChar, sizeof(enhancedVmn.anChar), tempStr + tempOff, enhancedVmn.anNumField);
946 if (ret != EOK) {
947 TELEPHONY_LOGE("enhancedVmn memcpy_s err.");
948 return;
949 }
950 tempOff += enhancedVmn.anNumField;
951 }
952
953 enhancedVmn.cliDigitMode = (tempStr[offset] & 0x80) ? true : false;
954 enhancedVmn.cliNumberType = (tempStr[offset] & 0x70) >> SHIFT_4BITS;
955 if (enhancedVmn.cliDigitMode) {
956 enhancedVmn.cliNumberPlan = tempStr[tempOff++] & 0x0f;
957 enhancedVmn.cliNumField = tempStr[tempOff++];
958
959 int bcdLen = tempStr[tempOff++] / HEX_BYTE_STEP;
960 bcdLen = (enhancedVmn.cliNumField % HEX_BYTE_STEP == 0) ? bcdLen : bcdLen + 1;
961 enhancedVmn.cliNumField =
962 SmsCommonUtils::BcdToDigitCdma(&(tempStr[tempOff]), bcdLen, reinterpret_cast<char *>(enhancedVmn.anChar));
963 enhancedVmn.anChar[enhancedVmn.cliNumField] = '\0';
964 } else {
965 ShiftNBitForDecode(tempStr, tempLen, SHIFT_4BITS);
966 enhancedVmn.cliNumField = tempStr[tempOff++];
967 (void)memset_s(enhancedVmn.cliChar, sizeof(enhancedVmn.cliChar), 0x00, sizeof(enhancedVmn.cliChar));
968 if (static_cast<unsigned long>(enhancedVmn.cliNumField) > sizeof(enhancedVmn.cliChar)) {
969 TELEPHONY_LOGE("enhancedVmn memcpy_s data length invalid.");
970 return;
971 }
972 ret = memcpy_s(enhancedVmn.cliChar, sizeof(enhancedVmn.cliChar), tempStr + tempOff, enhancedVmn.cliNumField);
973 if (ret != EOK) {
974 TELEPHONY_LOGE("enhancedVmn cliChar memcpy_s fail.");
975 return;
976 }
977 }
978 }
979
DecodeP2PDeliverVmnAck(const unsigned char * pduStr,int pduLen,struct SmsEnhancedVmnAck & enhancedVmnAck)980 void CdmaSmsPduCodec::DecodeP2PDeliverVmnAck(
981 const unsigned char *pduStr, int pduLen, struct SmsEnhancedVmnAck &enhancedVmnAck)
982 {
983 int offset = 1;
984 if (pduStr == nullptr) {
985 return;
986 }
987
988 int tempLen = pduStr[offset++];
989 unsigned char tempStr[pduLen + 1];
990 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
991 if (error != EOK) {
992 TELEPHONY_LOGE("DeliverVmnAck memset_s err.");
993 return;
994 }
995 if (tempLen > pduLen + 1) {
996 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
997 return;
998 }
999 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) != EOK) {
1000 TELEPHONY_LOGE("DecodeP2PDeliverVmnAck memcpy_s error.");
1001 return;
1002 }
1003 enhancedVmnAck.vmMailboxId = (tempStr[offset] << SHIFT_8BITS) | tempStr[offset + 1];
1004 offset += HEX_BYTE_STEP;
1005 enhancedVmnAck.vmNumUnheardMsg = tempStr[offset++];
1006 enhancedVmnAck.numDeleteAck = tempStr[offset] >> SHIFT_5BITS;
1007 enhancedVmnAck.numPlayAck = (tempStr[offset] & 0x1c) >> SHIFT_2BITS;
1008 ShiftNBitForDecode(tempStr, tempLen, SHIFT_6BITS);
1009 for (int i = 0; i < enhancedVmnAck.numDeleteAck; i++) {
1010 enhancedVmnAck.daVmMsgId[i] = (tempStr[offset] << SHIFT_8BITS) | tempStr[offset + 1];
1011 offset += HEX_BYTE_STEP;
1012 }
1013 for (int i = 0; i < enhancedVmnAck.numPlayAck; i++) {
1014 enhancedVmnAck.paVmMsgId[i] = (tempStr[offset] << SHIFT_8BITS) | tempStr[offset + 1];
1015 offset += HEX_BYTE_STEP;
1016 }
1017 }
1018
DecodeP2PSubmitMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcSubmit & subMsg)1019 void CdmaSmsPduCodec::DecodeP2PSubmitMsg(const unsigned char *pduStr, int pduLen, struct SmsTeleSvcSubmit &subMsg)
1020 {
1021 int offset = 0;
1022 int tempLen;
1023 unsigned char tempStr[pduLen + 1];
1024 while (offset < pduLen) {
1025 switch (pduStr[offset]) {
1026 case SMS_BEARER_MESSAGE_IDENTIFIER:
1027 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, subMsg.msgId);
1028 break;
1029 case SMS_BEARER_USER_DATA:
1030 offset += HEX_BYTE_STEP;
1031 tempLen = pduStr[offset - 1];
1032 if (tempLen > pduLen + 1) {
1033 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1034 break;
1035 }
1036 (void)memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1037 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) == EOK) {
1038 bool headerInd = subMsg.msgId.headerInd;
1039 DecodeUserData(tempStr, tempLen, subMsg.userData, headerInd);
1040 offset += tempLen;
1041 }
1042 break;
1043 case SMS_BEARER_VALIDITY_PERIOD_ABSOLUTE:
1044 offset += HEX_BYTE_STEP;
1045 subMsg.valPeriod.format = SMS_TIME_ABSOLUTE;
1046 offset += DecodeAbsTime(pduStr + offset, subMsg.valPeriod.time.absTime);
1047 break;
1048 case SMS_BEARER_VALIDITY_PERIOD_RELATIVE:
1049 offset += HEX_BYTE_STEP;
1050 subMsg.valPeriod.format = SMS_TIME_RELATIVE;
1051 subMsg.valPeriod.time.relTime.time = static_cast<enum SmsRelativeTime>(pduStr[offset++]);
1052 break;
1053 case SMS_BEARER_DEFERRED_DELIVERY_TIME_ABSOLUTE:
1054 offset += HEX_BYTE_STEP;
1055 subMsg.deferValPeriod.format = SMS_TIME_ABSOLUTE;
1056 offset += DecodeAbsTime(pduStr + offset, subMsg.deferValPeriod.time.absTime);
1057 break;
1058 case SMS_BEARER_DEFERRED_DELIVERY_TIME_RELATIVE:
1059 offset += HEX_BYTE_STEP;
1060 subMsg.deferValPeriod.format = SMS_TIME_RELATIVE;
1061 subMsg.deferValPeriod.time.relTime.time = static_cast<enum SmsRelativeTime>(pduStr[offset++]);
1062 break;
1063 case SMS_BEARER_PRIORITY_INDICATOR:
1064 offset += HEX_BYTE_STEP;
1065 subMsg.priority = static_cast<enum SmsPriorityIndicator>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1066 break;
1067 case SMS_BEARER_PRIVACY_INDICATOR:
1068 offset += HEX_BYTE_STEP;
1069 subMsg.privacy = static_cast<enum SmsPrivacyIndicator>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1070 break;
1071 case SMS_BEARER_REPLY_OPTION:
1072 offset += HEX_BYTE_STEP;
1073 subMsg.replyOpt.userAckReq = (pduStr[offset] & 0x80) ? true : false;
1074 subMsg.replyOpt.deliverAckReq = (pduStr[offset] & 0x40) ? true : false;
1075 subMsg.replyOpt.readAckReq = (pduStr[offset] & 0x20) ? true : false;
1076 subMsg.replyOpt.reportReq = (pduStr[offset] & 0x10) ? true : false;
1077 offset++;
1078 break;
1079 case SMS_BEARER_ALERT_ON_MSG_DELIVERY:
1080 offset += HEX_BYTE_STEP;
1081 subMsg.alertPriority = static_cast<enum SmsAlertPriority>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1082 break;
1083 case SMS_BEARER_LANGUAGE_INDICATOR:
1084 offset += HEX_BYTE_STEP;
1085 subMsg.language = static_cast<enum SmsLanguageType>(pduStr[offset++]);
1086 break;
1087 case SMS_BEARER_CALLBACK_NUMBER:
1088 offset += HEX_BYTE_STEP;
1089 tempLen = pduStr[offset - 1];
1090 DecodeCallBackNum(&pduStr[offset], tempLen, subMsg.callbackNumber);
1091 offset += tempLen;
1092 break;
1093 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1094 offset += HEX_BYTE_STEP;
1095 tempLen = pduStr[offset - 1];
1096 offset += tempLen;
1097 break;
1098 case SMS_BEARER_MSG_DEPOSIT_INDEX:
1099 offset += HEX_BYTE_STEP;
1100 subMsg.depositId = pduStr[offset++];
1101 subMsg.depositId = (subMsg.depositId << SHIFT_8BITS) + pduStr[offset++];
1102 break;
1103 default:
1104 return;
1105 }
1106 }
1107 }
1108
DecodeP2PUserAckMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcUserAck & userAck)1109 void CdmaSmsPduCodec::DecodeP2PUserAckMsg(
1110 const unsigned char *pduStr, int pduLen, struct SmsTeleSvcUserAck &userAck)
1111 {
1112 int offset = 0;
1113 int tempLen;
1114 int error = EOK;
1115 unsigned char tempStr[pduLen + 1];
1116 while (offset < pduLen) {
1117 switch (pduStr[offset]) {
1118 case SMS_BEARER_MESSAGE_IDENTIFIER:
1119 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, userAck.msgId);
1120 break;
1121 case SMS_BEARER_USER_DATA:
1122 offset += HEX_BYTE_STEP;
1123 tempLen = pduStr[offset - 1];
1124 if (tempLen > pduLen + 1) {
1125 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1126 break;
1127 }
1128 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1129 if (error != EOK) {
1130 TELEPHONY_LOGE("UserAckMsg memset_s err.");
1131 break;
1132 }
1133 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) == EOK) {
1134 bool headerInd = userAck.msgId.headerInd;
1135 DecodeUserData(tempStr, tempLen, userAck.userData, headerInd);
1136 offset += tempLen;
1137 }
1138 break;
1139 case SMS_BEARER_USER_RESPONSE_CODE:
1140 offset += HEX_BYTE_STEP;
1141 userAck.respCode = pduStr[offset++];
1142 break;
1143 case SMS_BEARER_MSG_CENTER_TIME_STAMP:
1144 offset += HEX_BYTE_STEP;
1145 offset += DecodeAbsTime(pduStr + offset, userAck.timeStamp);
1146 break;
1147 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1148 offset += HEX_BYTE_STEP;
1149 tempLen = pduStr[offset - 1];
1150 offset += tempLen;
1151 break;
1152 case SMS_BEARER_MSG_DEPOSIT_INDEX:
1153 offset += HEX_BYTE_STEP;
1154 userAck.depositId = pduStr[++offset]; // the hight byte
1155 offset++;
1156 break;
1157 default:
1158 return;
1159 }
1160 }
1161 }
1162
DecodeP2PReadAckMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcReadAck & readAck)1163 void CdmaSmsPduCodec::DecodeP2PReadAckMsg(
1164 const unsigned char *pduStr, int pduLen, struct SmsTeleSvcReadAck &readAck)
1165 {
1166 int offset = 0;
1167 int tempLen;
1168 int error = EOK;
1169 unsigned char tempStr[pduLen + 1];
1170 while (offset < pduLen) {
1171 switch (pduStr[offset]) {
1172 case SMS_BEARER_MESSAGE_IDENTIFIER:
1173 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, readAck.msgId);
1174 break;
1175 case SMS_BEARER_USER_DATA:
1176 offset += HEX_BYTE_STEP;
1177 tempLen = pduStr[offset - 1];
1178 if (tempLen > pduLen + 1) {
1179 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1180 break;
1181 }
1182 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1183 if (error != EOK) {
1184 TELEPHONY_LOGE("ReadAckMsg memset_s err.");
1185 break;
1186 }
1187 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) == EOK) {
1188 bool headerInd = readAck.msgId.headerInd;
1189 DecodeUserData(tempStr, tempLen, readAck.userData, headerInd);
1190 offset += tempLen;
1191 }
1192 break;
1193 case SMS_BEARER_MSG_CENTER_TIME_STAMP:
1194 offset += HEX_BYTE_STEP;
1195 offset += DecodeAbsTime(pduStr + offset, readAck.timeStamp);
1196 break;
1197 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1198 offset += HEX_BYTE_STEP;
1199 tempLen = pduStr[offset - 1];
1200 offset += tempLen;
1201 break;
1202 case SMS_BEARER_MSG_DEPOSIT_INDEX:
1203 /* Message Deposit Index */
1204 offset += HEX_BYTE_STEP;
1205 readAck.depositId = pduStr[++offset]; // the hight byte
1206 offset++;
1207 break;
1208 default:
1209 return;
1210 }
1211 }
1212 }
1213
DecodeP2PSubmitReportMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcDeliverReport & subReport)1214 void CdmaSmsPduCodec::DecodeP2PSubmitReportMsg(
1215 const unsigned char *pduStr, int pduLen, struct SmsTeleSvcDeliverReport &subReport)
1216 {
1217 int offset = 0;
1218 int tempLen;
1219 int error = EOK;
1220 unsigned char tempStr[pduLen + 1];
1221 while (offset < pduLen) {
1222 switch (pduStr[offset]) {
1223 case SMS_BEARER_MESSAGE_IDENTIFIER:
1224 offset += DecodeMsgId(&pduStr[offset], MAX_MSG_ID_LEN, subReport.msgId);
1225 break;
1226 case SMS_BEARER_USER_DATA:
1227 offset += HEX_BYTE_STEP;
1228 tempLen = pduStr[offset - 1];
1229 if (tempLen > pduLen + 1) {
1230 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1231 break;
1232 }
1233 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1234 if (error != EOK) {
1235 TELEPHONY_LOGE("SubmitReportMsg memset_s err.");
1236 break;
1237 }
1238 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) == EOK) {
1239 bool headerInd = subReport.msgId.headerInd;
1240 DecodeUserData(tempStr, tempLen, subReport.userData, headerInd);
1241 offset += tempLen;
1242 }
1243 break;
1244 case SMS_BEARER_LANGUAGE_INDICATOR:
1245 offset += HEX_BYTE_STEP;
1246 subReport.language = static_cast<enum SmsLanguageType>(pduStr[offset++]);
1247 break;
1248 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1249 offset += HEX_BYTE_STEP;
1250 tempLen = pduStr[offset - 1];
1251 offset += tempLen;
1252 break;
1253 case SMS_BEARER_TP_FAILURE_CAUSE:
1254 offset += HEX_BYTE_STEP;
1255 subReport.tpFailCause = pduStr[offset++];
1256 break;
1257 default:
1258 return;
1259 }
1260 }
1261 }
1262
DecodeP2PDeliveryAckMsg(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcDeliverAck & delAckMsg)1263 void CdmaSmsPduCodec::DecodeP2PDeliveryAckMsg(
1264 const unsigned char *pduStr, int pduLen, struct SmsTeleSvcDeliverAck &delAckMsg)
1265 {
1266 int offset = 0;
1267 int tmpLen;
1268 int error = EOK;
1269 unsigned char tempStr[pduLen + 1];
1270 while (offset < pduLen) {
1271 switch (pduStr[offset]) {
1272 case SMS_BEARER_MESSAGE_IDENTIFIER:
1273 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, delAckMsg.msgId);
1274 break;
1275 case SMS_BEARER_USER_DATA:
1276 offset += HEX_BYTE_STEP;
1277 tmpLen = pduStr[offset - 1];
1278 if (tmpLen > pduLen + 1) {
1279 TELEPHONY_LOGE("length err tmpLen:%{public}d, pduLen:%{public}d.", tmpLen, pduLen);
1280 break;
1281 }
1282 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1283 if (error != EOK) {
1284 TELEPHONY_LOGE("DeliveryAckMsg memset_s err.");
1285 break;
1286 }
1287 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tmpLen) == EOK) {
1288 bool headerInd = delAckMsg.msgId.headerInd;
1289 DecodeUserData(tempStr, tmpLen, delAckMsg.userData, headerInd);
1290 offset += tmpLen;
1291 }
1292 break;
1293 case SMS_BEARER_MSG_CENTER_TIME_STAMP:
1294 offset += HEX_BYTE_STEP;
1295 offset += DecodeAbsTime(pduStr + offset, delAckMsg.timeStamp);
1296 break;
1297 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1298 offset += HEX_BYTE_STEP;
1299 tmpLen = pduStr[offset - 1];
1300 offset += tmpLen;
1301 break;
1302 case SMS_BEARER_MESSAGE_STATUS:
1303 offset += HEX_BYTE_STEP;
1304 delAckMsg.msgStatus = static_cast<enum SmsStatusCode>(pduStr[offset++]);
1305 break;
1306 default:
1307 return;
1308 }
1309 }
1310 }
1311
DecodeCBBearerData(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcMsg & telesvc,bool isCMAS)1312 void CdmaSmsPduCodec::DecodeCBBearerData(
1313 const unsigned char *pduStr, int pduLen, struct SmsTeleSvcMsg &telesvc, bool isCMAS)
1314 {
1315 int offset = 0;
1316 int tempLen;
1317 int error = EOK;
1318 unsigned char tempStr[pduLen + 1];
1319 while (offset < pduLen) {
1320 switch (pduStr[offset]) {
1321 case SMS_BEARER_MESSAGE_IDENTIFIER:
1322 telesvc.type = SMS_TYPE_DELIVER;
1323 offset += DecodeMsgId(pduStr + offset, MAX_MSG_ID_LEN, telesvc.data.deliver.msgId);
1324 break;
1325 case SMS_BEARER_USER_DATA:
1326 offset += HEX_BYTE_STEP;
1327 tempLen = pduStr[offset - 1];
1328 if (tempLen > pduLen + 1) {
1329 TELEPHONY_LOGE("length err tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1330 break;
1331 }
1332 error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1333 if (error != EOK) {
1334 TELEPHONY_LOGE("BearerData memset_s err.");
1335 break;
1336 }
1337 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) != EOK) {
1338 TELEPHONY_LOGE("DecodeCBBearerData memcpy_s fail.");
1339 break;
1340 }
1341 if (isCMAS) {
1342 DecodeCMASData(tempStr, tempLen, telesvc.data.deliver.cmasData);
1343 } else {
1344 bool headerInd = telesvc.data.deliver.msgId.headerInd;
1345 DecodeUserData(tempStr, tempLen, telesvc.data.deliver.userData, headerInd);
1346 }
1347 offset += tempLen;
1348 break;
1349 case SMS_BEARER_MSG_CENTER_TIME_STAMP:
1350 offset += HEX_BYTE_STEP;
1351 offset += DecodeAbsTime(pduStr + offset, telesvc.data.deliver.timeStamp);
1352 break;
1353 case SMS_BEARER_VALIDITY_PERIOD_ABSOLUTE:
1354 offset += HEX_BYTE_STEP;
1355 telesvc.data.deliver.valPeriod.format = SMS_TIME_ABSOLUTE;
1356 offset += DecodeAbsTime(pduStr + offset, telesvc.data.deliver.valPeriod.time.absTime);
1357 break;
1358 case SMS_BEARER_VALIDITY_PERIOD_RELATIVE:
1359 offset += HEX_BYTE_STEP;
1360 telesvc.data.deliver.valPeriod.format = SMS_TIME_RELATIVE;
1361 telesvc.data.deliver.valPeriod.time.relTime.time =
1362 static_cast<enum SmsRelativeTime>(pduStr[offset++]);
1363 break;
1364 case SMS_BEARER_PRIORITY_INDICATOR:
1365 offset += HEX_BYTE_STEP;
1366 telesvc.data.deliver.priority =
1367 static_cast<enum SmsPriorityIndicator>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1368 break;
1369 case SMS_BEARER_ALERT_ON_MSG_DELIVERY:
1370 offset += HEX_BYTE_STEP;
1371 telesvc.data.deliver.alertPriority =
1372 static_cast<enum SmsAlertPriority>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1373 break;
1374 case SMS_BEARER_LANGUAGE_INDICATOR:
1375 offset += HEX_BYTE_STEP;
1376 telesvc.data.deliver.language = static_cast<enum SmsLanguageType>(pduStr[offset++]);
1377 break;
1378 case SMS_BEARER_CALLBACK_NUMBER:
1379 offset += HEX_BYTE_STEP;
1380 tempLen = pduStr[offset - 1];
1381 DecodeCallBackNum(&pduStr[offset], tempLen, telesvc.data.deliver.callbackNumber);
1382 offset += tempLen;
1383 break;
1384 case SMS_BEARER_MSG_DISPLAY_MODE:
1385 offset += HEX_BYTE_STEP;
1386 telesvc.data.deliver.displayMode =
1387 static_cast<enum SmsDisplayMode>((pduStr[offset++] & 0xc0) >> SHIFT_6BITS);
1388 break;
1389 case SMS_BEARER_MULTI_ENCODING_USER_DATA:
1390 offset += HEX_BYTE_STEP;
1391 tempLen = pduStr[offset - 1];
1392 offset += tempLen;
1393 break;
1394 default:
1395 return;
1396 }
1397 }
1398 }
1399
DecodeTeleId(const unsigned char * pduStr,int pduLen,unsigned short & teleSvcId)1400 int CdmaSmsPduCodec::DecodeTeleId(const unsigned char *pduStr, int pduLen, unsigned short &teleSvcId)
1401 {
1402 int offset = 0;
1403 unsigned short tempParam;
1404 offset += HEX_BYTE_STEP;
1405 tempParam = pduStr[offset++];
1406 tempParam = (tempParam << SHIFT_8BITS) + pduStr[offset++];
1407 switch (tempParam) {
1408 case SMS_TRANS_TELESVC_CMT_91:
1409 teleSvcId = SMS_TRANS_TELESVC_CMT_91;
1410 break;
1411 case SMS_TRANS_TELESVC_CPT_95:
1412 teleSvcId = SMS_TRANS_TELESVC_CPT_95;
1413 break;
1414 case SMS_TRANS_TELESVC_CMT_95:
1415 teleSvcId = SMS_TRANS_TELESVC_CMT_95;
1416 break;
1417 case SMS_TRANS_TELESVC_VMN_95:
1418 teleSvcId = SMS_TRANS_TELESVC_VMN_95;
1419 break;
1420 case SMS_TRANS_TELESVC_WAP:
1421 teleSvcId = SMS_TRANS_TELESVC_WAP;
1422 break;
1423 case SMS_TRANS_TELESVC_WEMT:
1424 teleSvcId = SMS_TRANS_TELESVC_WEMT;
1425 break;
1426 case SMS_TRANS_TELESVC_SCPT:
1427 teleSvcId = SMS_TRANS_TELESVC_SCPT;
1428 break;
1429 case SMS_TRANS_TELESVC_CATPT:
1430 teleSvcId = SMS_TRANS_TELESVC_CATPT;
1431 break;
1432 default:
1433 teleSvcId = SMS_TRANS_TELESVC_RESERVED;
1434 break;
1435 }
1436
1437 return offset;
1438 }
1439
DecodeSvcCtg(const unsigned char * pduStr,int pduLen,unsigned short & transSvcCtg)1440 int CdmaSmsPduCodec::DecodeSvcCtg(const unsigned char *pduStr, int pduLen, unsigned short &transSvcCtg)
1441 {
1442 int offset = 0;
1443 unsigned short tempParam;
1444 offset += HEX_BYTE_STEP;
1445 tempParam = pduStr[offset++];
1446 tempParam = (tempParam << SHIFT_8BITS) + pduStr[offset++];
1447 if ((tempParam >= SMS_TRANS_SVC_CTG_UNKNOWN && tempParam <= SMS_TRANS_SVC_CTG_KDDI_CORP_MAX1) ||
1448 (tempParam >= SMS_TRANS_SVC_CTG_KDDI_CORP_MIN2 && tempParam <= SMS_TRANS_SVC_CTG_KDDI_CORP_MAX2) ||
1449 (tempParam >= SMS_TRANS_SVC_CTG_KDDI_CORP_MIN3 && tempParam <= SMS_TRANS_SVC_CTG_KDDI_CORP_MAX3)) {
1450 transSvcCtg = tempParam;
1451 } else {
1452 transSvcCtg = SMS_TRANS_SVC_CTG_RESERVED;
1453 }
1454 return offset;
1455 }
1456
DecodeAddress(const unsigned char * pduStr,int pduLen,struct SmsTransAddr & transAddr)1457 int CdmaSmsPduCodec::DecodeAddress(const unsigned char *pduStr, int pduLen, struct SmsTransAddr &transAddr)
1458 {
1459 int offset = 1;
1460 unsigned char tempStr[pduLen + 1];
1461 int tempLen = pduStr[offset++];
1462 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1463 if (error != EOK) {
1464 TELEPHONY_LOGE("DecodeAddress memset_s err.");
1465 return offset;
1466 }
1467 if (tempLen > pduLen + 1) {
1468 TELEPHONY_LOGE("data length invalid tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1469 return offset;
1470 }
1471 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) != EOK) {
1472 TELEPHONY_LOGE("DecodeAddress pduStr memcpy_s err.");
1473 return offset;
1474 }
1475
1476 if (memset_s(&transAddr, sizeof(SmsTransAddr), 0x00, sizeof(SmsTransAddr)) != EOK) {
1477 TELEPHONY_LOGE("SmsTransAddr memcpy_s err.");
1478 return offset;
1479 }
1480
1481 offset += tempLen;
1482 transAddr.digitMode = (tempStr[0] & 0x80) ? true : false;
1483 transAddr.numberMode = (tempStr[0] & 0x40) ? true : false;
1484 TELEPHONY_LOGI("digitMode %{public}d numberMode %{public}d", transAddr.digitMode, transAddr.numberMode);
1485 ShiftNBitForDecode(tempStr, tempLen, SHIFT_2BITS);
1486 if (transAddr.digitMode) {
1487 if (transAddr.numberMode) {
1488 /* digit mode 1, number mode 1 */
1489 transAddr.numberType = DecodeDigitModeNumberType(tempStr[0] & 0xe0, true);
1490 ShiftNBitForDecode(tempStr, tempLen, SHIFT_3BITS);
1491 } else {
1492 /* digit mode 1, number mode 0 */
1493 transAddr.numberType = DecodeDigitModeNumberType(tempStr[0] & 0xe0, false);
1494 ShiftNBitForDecode(tempStr, tempLen, SHIFT_3BITS);
1495 transAddr.numberPlan = DecodeDigitModeNumberPlan((tempStr[0] >> SHIFT_4BITS) & 0x0f);
1496 ShiftNBitForDecode(tempStr, tempLen, SHIFT_4BITS);
1497 }
1498 transAddr.addrLen = tempStr[0];
1499 if (transAddr.addrLen > sizeof(transAddr.szData)) {
1500 TELEPHONY_LOGE("data length invalid.");
1501 }
1502 if (memcpy_s(transAddr.szData, sizeof(transAddr.szData), &tempStr[1], transAddr.addrLen) != EOK) {
1503 TELEPHONY_LOGE("DecodeAddress memcpy_s error.");
1504 }
1505 } else {
1506 transAddr.addrLen = tempStr[0];
1507 int bcdLen = (transAddr.addrLen % HEX_BYTE_STEP == 0) ? transAddr.addrLen : transAddr.addrLen + 1;
1508
1509 SmsCommonUtils::BcdToDigitCdma(&(tempStr[1]), bcdLen, transAddr.szData);
1510 transAddr.szData[transAddr.addrLen] = '\0';
1511 }
1512 return offset;
1513 }
1514
DecodeSubAddress(const unsigned char * pduStr,int pduLen,struct SmsTransSubAddr & subAddr)1515 int CdmaSmsPduCodec::DecodeSubAddress(const unsigned char *pduStr, int pduLen, struct SmsTransSubAddr &subAddr)
1516 {
1517 int offset = 0;
1518 int tempOffset = 0;
1519 int tempLen = 0;
1520 unsigned char tempStr[pduLen + 1];
1521 if (pduStr == nullptr) {
1522 TELEPHONY_LOGE("PDU is null!");
1523 return offset;
1524 }
1525
1526 offset++;
1527 tempLen = pduStr[offset++];
1528 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1529 if (error != EOK) {
1530 TELEPHONY_LOGE("DecodeSubAddress memset_s err.");
1531 return offset;
1532 }
1533 if (tempLen > pduLen + 1) {
1534 TELEPHONY_LOGE("data length invalid tempLen:%{public}d, pduLen:%{public}d.", tempLen, pduLen);
1535 return offset;
1536 }
1537 if (memcpy_s(tempStr, sizeof(tempStr), &pduStr[offset], tempLen) != EOK) {
1538 TELEPHONY_LOGE("DecodeSubAddress memcpy_s err.");
1539 return offset;
1540 }
1541
1542 offset += tempLen;
1543 switch (tempStr[tempOffset] & 0xe0) {
1544 case 0x00:
1545 subAddr.type = SMS_TRANS_SUB_ADDR_NSAP;
1546 break;
1547 case 0x20:
1548 subAddr.type = SMS_TRANS_SUB_ADDR_USER;
1549 break;
1550 default:
1551 subAddr.type = SMS_TRANS_SUB_ADDR_RESERVED;
1552 break;
1553 }
1554 subAddr.odd = (tempStr[tempOffset] & 0x10) ? true : false;
1555 ShiftNBitForDecode(tempStr, tempLen, SHIFT_4BITS);
1556
1557 int numfeilds = tempStr[tempOffset++];
1558 (void)memset_s(subAddr.szData, sizeof(subAddr.szData), 0x00, sizeof(subAddr.szData));
1559 if (static_cast<unsigned long>(numfeilds) > sizeof(subAddr.szData)) {
1560 TELEPHONY_LOGE("data length invalid.");
1561 }
1562 if (memcpy_s(subAddr.szData, sizeof(subAddr.szData), tempStr + tempOffset, numfeilds) != EOK) {
1563 TELEPHONY_LOGE("DecodeSubAddress memcpy_s szdata error.");
1564 }
1565 return offset;
1566 }
1567
DecodeMsgId(const unsigned char * pduStr,int pduLen,struct SmsTransMsgId & smgId)1568 int CdmaSmsPduCodec::DecodeMsgId(const unsigned char *pduStr, int pduLen, struct SmsTransMsgId &smgId)
1569 {
1570 int ret;
1571 int offset = 0;
1572 unsigned char tempStr[pduLen + 1];
1573
1574 ret = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1575 if (ret != EOK) {
1576 TELEPHONY_LOGE("DecodeMsgId memset_s fail.");
1577 return offset;
1578 }
1579 if (MSG_UDID_PARAM_LEN > static_cast<uint8_t>(pduLen + 1)) {
1580 TELEPHONY_LOGE("data length invalid.");
1581 return offset;
1582 }
1583 ret = memcpy_s(tempStr, sizeof(tempStr), &pduStr[offset + HEX_BYTE_STEP], MSG_UDID_PARAM_LEN);
1584 if (ret != EOK) {
1585 TELEPHONY_LOGE("DecodeMsgId memcpy_s fail.");
1586 return offset;
1587 }
1588
1589 ShiftNBitForDecode(tempStr, MSG_UDID_PARAM_LEN, SHIFT_4BITS);
1590 smgId.msgId = tempStr[offset++];
1591 smgId.msgId = (smgId.msgId << SHIFT_8BITS) + tempStr[offset++];
1592 smgId.headerInd = (tempStr[offset++] & 0x80) ? true : false;
1593 offset += HEX_BYTE_STEP;
1594 return offset;
1595 }
1596
DecodeCallBackNum(const unsigned char * pduStr,int pduLen,struct SmsTeleSvcAddr & svcAddr)1597 void CdmaSmsPduCodec::DecodeCallBackNum(const unsigned char *pduStr, int pduLen, struct SmsTeleSvcAddr &svcAddr)
1598 {
1599 int offset = 0;
1600 unsigned char tempStr[pduLen + 1];
1601 (void)memset_s(&svcAddr, sizeof(SmsTeleSvcAddr), 0x00, sizeof(SmsTeleSvcAddr));
1602
1603 if (pduStr[offset] & 0x80) {
1604 svcAddr.digitMode = true;
1605 svcAddr.numberType = DecodeDigitModeNumberType((pduStr[offset] << SHIFT_1BITS) & 0x70, false);
1606 svcAddr.numberPlan = DecodeDigitModeNumberPlan(pduStr[offset++] & 0x0f);
1607 svcAddr.addrLen = pduStr[offset++];
1608 if (svcAddr.addrLen > sizeof(svcAddr.szData)) {
1609 TELEPHONY_LOGE("DecodeCallBackNum data length invalid.");
1610 return;
1611 }
1612 if (svcAddr.numberType == SMS_NUMBER_TYPE_INTERNATIONAL) {
1613 if (memcpy_s(&(svcAddr.szData[1]), sizeof(svcAddr.szData) - 1, pduStr + offset, svcAddr.addrLen) != EOK) {
1614 TELEPHONY_LOGE("DecodeCallBackNum pduStr memcpy_s err.");
1615 return;
1616 }
1617
1618 if (svcAddr.szData[1] != '\0') {
1619 svcAddr.szData[0] = '+';
1620 }
1621 } else {
1622 if (memcpy_s(svcAddr.szData, sizeof(svcAddr.szData), pduStr + offset, svcAddr.addrLen) != EOK) {
1623 TELEPHONY_LOGE("DecodeCallBackNum memcpy_s fail.");
1624 }
1625 }
1626 } else {
1627 svcAddr.digitMode = false;
1628 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1629 if (error != EOK) {
1630 TELEPHONY_LOGE("DecodeCallBackNum memset_s err.");
1631 return;
1632 }
1633 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, pduLen) == EOK) {
1634 ShiftNBitForDecode(tempStr, pduLen, SHIFT_1BITS);
1635 svcAddr.addrLen = tempStr[0];
1636 int bcdLen = svcAddr.addrLen / HEX_BYTE_STEP;
1637 bcdLen = (svcAddr.addrLen % HEX_BYTE_STEP == 0) ? bcdLen : bcdLen + 1;
1638 SmsCommonUtils::BcdToDigitCdma(&(tempStr[1]), bcdLen, svcAddr.szData);
1639 svcAddr.szData[svcAddr.addrLen] = '\0';
1640 }
1641 }
1642 }
1643
DecodeAbsTime(const unsigned char * pduStr,struct SmsTimeAbs & timeAbs)1644 int CdmaSmsPduCodec::DecodeAbsTime(const unsigned char *pduStr, struct SmsTimeAbs &timeAbs)
1645 {
1646 int offset = 0;
1647 if (pduStr == nullptr) {
1648 TELEPHONY_LOGE("PDU is null!");
1649 return offset;
1650 }
1651 timeAbs.year = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1652 offset++;
1653 timeAbs.month = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1654 offset++;
1655 timeAbs.day = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1656 offset++;
1657 timeAbs.hour = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1658 offset++;
1659 timeAbs.minute = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1660 offset++;
1661 timeAbs.second = (((pduStr[offset] & 0xf0) >> SHIFT_4BITS) * DECIMAL_NUM) + (pduStr[offset] & 0x0f);
1662 offset++;
1663 return offset;
1664 }
1665
Encode7BitASCIIData(const struct SmsUserData & userData,unsigned char * dest,int & remainBits)1666 int CdmaSmsPduCodec::Encode7BitASCIIData(const struct SmsUserData &userData, unsigned char *dest, int &remainBits)
1667 {
1668 int shift = 0;
1669 int offset = 0;
1670 int fillBits = 0;
1671 unsigned char udhl = 0x00;
1672 offset = (userData.headerCnt > 0) ? HEX_BYTE_STEP : 1;
1673 for (int i = 0; i < userData.headerCnt; i++) {
1674 int headerLen = GsmSmsUDataCodec::EncodeHeader(userData.header[i], (char *)(&(dest[offset])));
1675 TELEPHONY_LOGI("headerLen [%{public}d]", headerLen);
1676 udhl += headerLen;
1677 offset += headerLen;
1678 }
1679 if (udhl > 0) {
1680 fillBits = ((udhl + 1) * BYTE_BITS) % ENCODE_BYTE_BIT; /* + UDHL */
1681 }
1682 if (fillBits > 0) {
1683 fillBits = ENCODE_BYTE_BIT - fillBits;
1684 remainBits = BYTE_BIT - fillBits;
1685 }
1686 TELEPHONY_LOGI("fillBits [%{public}d] udhl [%{public}d]", fillBits, udhl);
1687 /* Set UDL, UDHL */
1688 dest[0] = (udhl > 0) ? (udhl + 1 + userData.length) : userData.length;
1689
1690 unsigned char *temp = static_cast<unsigned char *>(calloc(BYTE_STEP, userData.length + 0x01));
1691 if (temp == nullptr) {
1692 TELEPHONY_LOGE("SmsUserData is null!");
1693 return shift;
1694 }
1695 for (int i = 0; i < userData.length; i++) {
1696 temp[i] = static_cast<unsigned char>(userData.data[i]) << SHIFT_1BITS;
1697 }
1698
1699 int j = 0;
1700 for (int i = 0; i < userData.length; i++) {
1701 shift = j % ENCODE_GSM_BIT;
1702 dest[offset + j] = (temp[i] << shift) + (temp[i + 0x01] >> (ENCODE_GSM_BIT - shift));
1703 j++;
1704 if (shift == 0x06) {
1705 i++;
1706 }
1707 }
1708 if (temp) {
1709 free(temp);
1710 temp = nullptr;
1711 }
1712
1713 if (fillBits > 0) {
1714 ShiftRNBit(&dest[offset], j, fillBits);
1715 ++j;
1716 }
1717 return j + offset;
1718 }
1719
Encode7BitGSMData(const struct SmsUserData & userData,unsigned char * dest,int & remainBits)1720 int CdmaSmsPduCodec::Encode7BitGSMData(const struct SmsUserData &userData, unsigned char *dest, int &remainBits)
1721 {
1722 int offset = 0;
1723 int fillBits = 0;
1724 int packSize = 0;
1725 int encodeLen = 0;
1726
1727 unsigned char udhl = 0x00;
1728 offset = (userData.headerCnt > 0) ? HEX_BYTE_STEP : 1;
1729
1730 for (int i = 0; i < userData.headerCnt; i++) {
1731 int headerLen = GsmSmsUDataCodec::EncodeHeader(userData.header[i], (char *)&(dest[offset]));
1732 TELEPHONY_LOGI("headerLen [%{public}d]", headerLen);
1733 udhl += headerLen;
1734 offset += headerLen;
1735 }
1736 TELEPHONY_LOGI("udhl [%{public}u]", udhl);
1737 if (udhl > 0) {
1738 fillBits = ((udhl + 1) * BYTE_BIT) % ENCODE_BYTE_BIT; /* + UDHL */
1739 }
1740 if (fillBits > 0) {
1741 fillBits = ENCODE_BYTE_BIT - fillBits;
1742 remainBits = BYTE_BIT - fillBits;
1743 }
1744 TELEPHONY_LOGI("fillBits [%{public}d] dataLen [%{public}d]", fillBits, userData.length);
1745 /* Set UDL, UDHL */
1746 if (udhl > 0) {
1747 dest[0] = udhl + 1 + userData.length;
1748 dest[1] = udhl;
1749 } else {
1750 dest[0] = userData.length;
1751 }
1752
1753 packSize = SmsCommonUtils::Pack7bitChar(
1754 reinterpret_cast<const unsigned char *>(userData.data), userData.length, fillBits, &dest[offset]);
1755 encodeLen = offset + packSize;
1756 TELEPHONY_LOGI("packSize [%{public}d] encodeLen [%{public}d]", packSize, encodeLen);
1757 if (fillBits > 0) {
1758 int offsetIndex = 0;
1759 ShiftRNBit(&dest[offsetIndex], packSize, fillBits);
1760 ++encodeLen;
1761 }
1762 return encodeLen;
1763 }
1764
EncodeUCS2Data(const struct SmsUserData & userData,unsigned char * dest,int & remainBits)1765 int CdmaSmsPduCodec::EncodeUCS2Data(const struct SmsUserData &userData, unsigned char *dest, int &remainBits)
1766 {
1767 int offset = 0;
1768 int encodeLen = 0;
1769
1770 unsigned char udhl = 0x00;
1771 offset = (userData.headerCnt > 0) ? HEX_BYTE_STEP : 1;
1772
1773 for (int i = 0; i < userData.headerCnt; i++) {
1774 int headerLen = GsmSmsUDataCodec::EncodeHeader(userData.header[i], (char *)&(dest[offset]));
1775 TELEPHONY_LOGI("headerLen [%{public}d]", headerLen);
1776 udhl += headerLen;
1777 }
1778 TELEPHONY_LOGI("udhl [%{public}u]", udhl);
1779 /* Set UDL, UDHL */
1780 if (udhl > 0) {
1781 unsigned char udhBytes = udhl + 1;
1782 unsigned char udhCodeUnits = (udhBytes + 1) / HEX_BYTE_STEP;
1783 unsigned char udCodeUnits = userData.length / HEX_BYTE_STEP;
1784 dest[0] = udhCodeUnits + udCodeUnits;
1785 dest[1] = udhl;
1786 offset += udhCodeUnits * HEX_BYTE_STEP - 1;
1787 } else {
1788 dest[0] = (char)userData.length / HEX_BYTE_STEP;
1789 }
1790
1791 if (userData.length > static_cast<int>(MAX_TPDU_DATA_LEN - offset)) {
1792 TELEPHONY_LOGE("data length invalid.");
1793 return encodeLen;
1794 }
1795 if (memcpy_s(&dest[offset], MAX_TPDU_DATA_LEN - offset, userData.data, userData.length) != EOK) {
1796 TELEPHONY_LOGE("EncodeUCS2Data memcpy_s error");
1797 return encodeLen;
1798 }
1799 remainBits = 0;
1800 encodeLen = offset + userData.length;
1801 return encodeLen;
1802 }
1803
DecodeCMASData(unsigned char * pduStr,int pduLen,struct SmsTeleSvcCmasData & cmasData)1804 void CdmaSmsPduCodec::DecodeCMASData(unsigned char *pduStr, int pduLen, struct SmsTeleSvcCmasData &cmasData)
1805 {
1806 int offset = 0;
1807 if (memset_s(&cmasData, sizeof(SmsTeleSvcCmasData), 0x00, sizeof(SmsTeleSvcCmasData)) != EOK) {
1808 TELEPHONY_LOGE("DecodeCMASData memset_s fail.");
1809 return;
1810 }
1811 if ((pduStr[offset] & 0xf8) != 0x00) {
1812 TELEPHONY_LOGE("Wrong Encode Type = [%{public}d]!! must be 0", (pduStr[offset] & 0xf8) >> SHIFT_3BITS);
1813 return;
1814 }
1815 ShiftNBitForDecode(pduStr, pduLen, SHIFT_5BITS);
1816 offset++;
1817 if (pduStr[offset++] != 0x00) {
1818 TELEPHONY_LOGE("Wrong protocol version = [%{public}d]!! must be 0", pduStr[offset - 1]);
1819 cmasData.isWrongRecodeType = true;
1820 return;
1821 }
1822 while (offset < pduLen - 1) {
1823 if (pduStr[offset] == 0x00) {
1824 offset++;
1825 offset += DecodeCMASType0Data(&pduStr[offset], pduLen - offset, cmasData);
1826 } else if (pduStr[offset] == 0x01) {
1827 offset += HEX_BYTE_STEP;
1828 TELEPHONY_LOGI("Type 1 length = [%{public}d]", pduStr[offset - 1]);
1829 cmasData.category = static_cast<enum SmsCmaeCategory>(pduStr[offset++]);
1830 cmasData.responseType = static_cast<enum SmsCmaeResponseType>(pduStr[offset++]);
1831 cmasData.severity = static_cast<enum SmsCmaeSeverity>(pduStr[offset] >> SHIFT_4BITS);
1832 cmasData.urgency = static_cast<enum SmsCmaeUrgency>(pduStr[offset++] & 0x0f);
1833 cmasData.certainty = static_cast<enum SmsCmaeCertainty>(pduStr[offset++] >> SHIFT_4BITS);
1834 } else if (pduStr[offset] == 0x02) {
1835 offset += HEX_BYTE_STEP;
1836 TELEPHONY_LOGI("Type 2 length = [%{public}d]", pduStr[offset - 1]);
1837 cmasData.id = pduStr[offset++];
1838 cmasData.id = (cmasData.id << SHIFT_8BITS) + pduStr[offset++];
1839 cmasData.alertHandle = static_cast<enum SmsCmaeAlertHandle>(pduStr[offset++]);
1840 offset += DecodeAbsTime(pduStr + offset, cmasData.expires);
1841 cmasData.language = static_cast<enum SmsLanguageType>(pduStr[offset++]);
1842 } else {
1843 offset++;
1844 }
1845 TELEPHONY_LOGI("offset = [%{public}d], pduLen = [%{public}d]", offset, pduLen);
1846 }
1847 }
1848
DecodeCMASType0Data(unsigned char * pduStr,int pduLen,struct SmsTeleSvcCmasData & cmasData)1849 int CdmaSmsPduCodec::DecodeCMASType0Data(unsigned char *pduStr, int pduLen, struct SmsTeleSvcCmasData &cmasData)
1850 {
1851 int offset = 0;
1852 size_t tempLen = 0;
1853 unsigned char tempStr[pduLen + 1];
1854 tempLen = pduStr[offset++];
1855 TELEPHONY_LOGI("Type 0 length = [%{public}zu]", tempLen);
1856 int error = memset_s(tempStr, sizeof(tempStr), 0x00, sizeof(tempStr));
1857 if (error != EOK) {
1858 TELEPHONY_LOGE("DecodeCMASType0Data memset_s err.");
1859 return offset;
1860 }
1861 if (tempLen > static_cast<size_t>(pduLen + 1)) {
1862 TELEPHONY_LOGE("data length invalid tempLen:%{public}zu, pduLen:%{public}d.", tempLen, pduLen);
1863 return offset;
1864 }
1865 if (memcpy_s(tempStr, sizeof(tempStr), pduStr + offset, tempLen) != EOK) {
1866 cmasData.encodeType = FindMsgEncodeType(tempStr[0] & 0xf8);
1867 ShiftNBitForDecode(tempStr, tempLen, SHIFT_5BITS);
1868 switch (cmasData.encodeType) {
1869 case SMS_ENCODE_7BIT_ASCII:
1870 case SMS_ENCODE_IA5:
1871 case SMS_ENCODE_GSM7BIT:
1872 cmasData.dataLen = (tempLen * BYTE_BITS - SHIFT_5BITS) / ENCODE_GSM_BIT;
1873 for (unsigned int i = 0; i < cmasData.dataLen; i++) {
1874 cmasData.alertText[i] = tempStr[0] >> SHIFT_1BITS;
1875 ShiftNBitForDecode(tempStr, tempLen, SHIFT_7BITS);
1876 }
1877 break;
1878 case SMS_ENCODE_EPM:
1879 case SMS_ENCODE_GSMDCS:
1880 break;
1881 default:
1882 cmasData.dataLen = (tempLen == 0) ? 0 : (tempLen - 1);
1883 if (tempLen - 1 > sizeof(cmasData.alertText)) {
1884 TELEPHONY_LOGE("data length invalid.");
1885 return offset;
1886 }
1887 if (memcpy_s(cmasData.alertText, sizeof(cmasData.alertText), tempStr + offset, tempLen - 1) != EOK) {
1888 TELEPHONY_LOGE("cmasData alertText memcpy_s fail.");
1889 }
1890 break;
1891 }
1892 }
1893 offset += tempLen;
1894 return offset;
1895 }
1896
DecodeUserData(unsigned char * pduStr,int pduLen,struct SmsTeleSvcUserData & userData,bool headerInd)1897 void CdmaSmsPduCodec::DecodeUserData(
1898 unsigned char *pduStr, int pduLen, struct SmsTeleSvcUserData &userData, bool headerInd)
1899 {
1900 int offset = 0;
1901 if (pduStr == nullptr) {
1902 return;
1903 }
1904
1905 userData.encodeType = FindMsgEncodeType(pduStr[offset] & 0xf8);
1906 ShiftNBitForDecode(pduStr, pduLen, SHIFT_5BITS);
1907 if (userData.encodeType == SMS_ENCODE_EPM || userData.encodeType == SMS_ENCODE_GSMDCS) {
1908 userData.msgType = pduStr[offset];
1909 ShiftNBitForDecode(pduStr, pduLen, SHIFT_8BITS);
1910 }
1911
1912 if (memset_s(userData.userData.data, sizeof(userData.userData.data), 0x00, sizeof(userData.userData.data)) !=
1913 EOK) {
1914 TELEPHONY_LOGE("DecodeUserData memset_s err.");
1915 return;
1916 }
1917
1918 unsigned char fillBits;
1919 unsigned char numFields = pduStr[offset++];
1920 unsigned char udhlBytes = headerInd ? pduStr[offset++] : 0;
1921 TELEPHONY_LOGI("numFields %{public}d udhlBytes %{public}d", numFields, udhlBytes);
1922 Decode7BitHeader(&pduStr[offset], udhlBytes, userData.userData);
1923 offset += udhlBytes;
1924
1925 switch (userData.encodeType) {
1926 case SMS_ENCODE_7BIT_ASCII:
1927 case SMS_ENCODE_IA5:
1928 fillBits = headerInd ? ((udhlBytes + 1) * BYTE_BIT) % ENCODE_BYTE_BIT : 0;
1929 fillBits = fillBits > 0 ? ENCODE_BYTE_BIT - fillBits : 0;
1930 if (pduLen < offset) {
1931 TELEPHONY_LOGE("data length error, pduLen %{public}d offset %{public}d", pduLen, offset);
1932 return;
1933 }
1934 ShiftNBitForDecode(&pduStr[offset], (unsigned int)(pduLen - offset), fillBits);
1935
1936 userData.userData.length = headerInd ? (numFields - udhlBytes - 1) : numFields;
1937 for (int i = 0; i < userData.userData.length; i++) {
1938 userData.userData.data[i] = pduStr[offset] >> SHIFT_1BITS;
1939 ShiftNBitForDecode(&pduStr[offset], pduLen, SHIFT_7BITS);
1940 }
1941 break;
1942 case SMS_ENCODE_GSM7BIT:
1943 fillBits = headerInd ? ((udhlBytes + 1) * BYTE_BIT) % ENCODE_BYTE_BIT : 0;
1944 fillBits = fillBits > 0 ? ENCODE_BYTE_BIT - fillBits : 0;
1945 if (pduLen < offset) {
1946 TELEPHONY_LOGE("data length error, pduLen %{public}d offset %{public}d", pduLen, offset);
1947 return;
1948 }
1949 ShiftNBitForDecode(&pduStr[offset], (unsigned int)(pduLen - offset), fillBits);
1950
1951 userData.userData.length = headerInd ? (numFields - udhlBytes - 1) : numFields;
1952 SmsCommonUtils::Unpack7bitChar(&(pduStr[offset]), userData.userData.length, 0x00,
1953 reinterpret_cast<unsigned char *>(userData.userData.data), MAX_USER_DATA_LEN + 1);
1954 break;
1955 case SMS_ENCODE_EPM:
1956 case SMS_ENCODE_GSMDCS:
1957 break;
1958 case SMS_ENCODE_UNICODE:
1959 if (headerInd) {
1960 fillBits = ((udhlBytes + 1) % HEX_BYTE_STEP == 0) ? 0 : 0x08;
1961 offset += (fillBits > 0) ? 1 : 0;
1962 userData.userData.length = numFields * HEX_BYTE_STEP - (udhlBytes + 1);
1963 } else {
1964 userData.userData.length = numFields * HEX_BYTE_STEP;
1965 }
1966 if (static_cast<unsigned long>(userData.userData.length) > sizeof(userData.userData.data)) {
1967 TELEPHONY_LOGE("data length error.");
1968 return;
1969 }
1970 if (memcpy_s(userData.userData.data, sizeof(userData.userData.data), pduStr + offset,
1971 userData.userData.length) != EOK) {
1972 TELEPHONY_LOGE("SMS_ENCODE_UNICODE memcpy_s err.");
1973 }
1974 break;
1975 default:
1976 if (static_cast<unsigned long>(userData.userData.length) > sizeof(userData.userData.data)) {
1977 TELEPHONY_LOGE("data length error.");
1978 return;
1979 }
1980 if (memcpy_s(userData.userData.data, sizeof(userData.userData.data), pduStr + offset,
1981 userData.userData.length) != EOK) {
1982 TELEPHONY_LOGE("unkown encodeType memcpy_s err.");
1983 }
1984 break;
1985 }
1986 }
1987
1988 /**
1989 * @brief Decode7BitHeader
1990 * Decode User Data Header
1991 * @param pduStr
1992 * @param udhlBytes
1993 * @param userData
1994 */
Decode7BitHeader(const unsigned char * pduStr,unsigned char udhlBytes,struct SmsUserData & userData)1995 void CdmaSmsPduCodec::Decode7BitHeader(
1996 const unsigned char *pduStr, unsigned char udhlBytes, struct SmsUserData &userData)
1997 {
1998 if (udhlBytes > 0) {
1999 int offset = 0;
2000 userData.headerCnt = 0;
2001 for (int i = 0; offset < udhlBytes; i++) {
2002 int headerLen = GsmSmsUDataCodec::DecodeHeader(&(pduStr[offset]), &(userData.header[i]));
2003 if (headerLen <= 0) {
2004 TELEPHONY_LOGI("Error to Header. headerLen [%{public}d]", headerLen);
2005 GsmSmsUDataCodec::ResetUserData(userData);
2006 return;
2007 }
2008 offset += headerLen;
2009 if (offset > (udhlBytes + HEX_BYTE_STEP)) {
2010 TELEPHONY_LOGI("Error to Header. offset [%{public}d] > (udhl [%{public}d] + 2)", offset, udhlBytes);
2011 GsmSmsUDataCodec::ResetUserData(userData);
2012 return;
2013 }
2014 userData.headerCnt++;
2015 }
2016 } else {
2017 userData.headerCnt = 0;
2018 }
2019 }
2020
FindMsgType(const std::vector<unsigned char> & pduStr)2021 enum SmsMessageType CdmaSmsPduCodec::FindMsgType(const std::vector<unsigned char> &pduStr)
2022 {
2023 std::size_t offset = 0;
2024 while (offset < pduStr.size()) {
2025 if (pduStr[offset] == 0x00) {
2026 return static_cast<enum SmsMessageType>((pduStr[offset + HEX_BYTE_STEP] & 0xf0) >> SHIFT_4BITS);
2027 }
2028 offset += (pduStr[offset + 1] + HEX_BYTE_STEP);
2029 }
2030 return SMS_TYPE_MAX_VALUE;
2031 }
2032
FindMsgEncodeType(const unsigned char value)2033 enum SmsEncodingType CdmaSmsPduCodec::FindMsgEncodeType(const unsigned char value)
2034 {
2035 enum SmsEncodingType encodeType = SMS_ENCODE_RESERVED;
2036 unsigned char temp = (value >> SHIFT_3BITS);
2037 if (temp >= SMS_ENCODE_OCTET && temp <= SMS_ENCODE_GSMDCS) {
2038 encodeType = static_cast<SmsEncodingType>(temp);
2039 }
2040 if (temp == SMS_ENCODE_EUCKR) {
2041 return SMS_ENCODE_EUCKR;
2042 }
2043 return encodeType;
2044 }
2045 } // namespace Telephony
2046 } // namespace OHOS