1 /*
2 * Copyright (C) 2021 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 "cdma_sms_message.h"
17
18 #include "securec.h"
19 #include "string_utils.h"
20 #include "sms_common_utils.h"
21 #include "telephony_log_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
CreateSubmitTransMsg(const std::string & dest,const std::string & sc,const std::string & text,bool bStatusReport,const SmsCodingScheme codingScheme)25 std::unique_ptr<SmsTransMsg> CdmaSmsMessage::CreateSubmitTransMsg(const std::string &dest, const std::string &sc,
26 const std::string &text, bool bStatusReport, const SmsCodingScheme codingScheme)
27 {
28 std::unique_ptr<SmsTransMsg> transMsg = GreateTransMsg();
29 if (transMsg == nullptr) {
30 TELEPHONY_LOGE("CreateMessage message transMsg nullptr");
31 return nullptr;
32 }
33 scAddress_ = sc;
34 originatingAddress_ = dest;
35 visibleMessageBody_ = text;
36 bStatusReportMessage_ = bStatusReport;
37 transMsg->data.p2pMsg.telesvcMsg.data.submit.userData.encodeType = CovertEncodingType(codingScheme);
38 /* Set Reply option */
39 transMsg->data.p2pMsg.telesvcMsg.data.submit.replyOpt.deliverAckReq = bStatusReport;
40 /* Convert Address values */
41 transMsg->data.p2pMsg.address.digitMode = SMS_DIGIT_4BIT_DTMF;
42 transMsg->data.p2pMsg.address.numberMode = SMS_NUMBER_MODE_NONE_DATANETWORK;
43 transMsg->data.p2pMsg.address.numberPlan = SMS_NPI_UNKNOWN;
44 transMsg->data.p2pMsg.address.addrLen = dest.length();
45 if (strncpy_s(transMsg->data.p2pMsg.address.szData, sizeof(transMsg->data.p2pMsg.address.szData), dest.c_str(),
46 dest.length()) != EOK) {
47 transMsg->data.p2pMsg.address.addrLen = sizeof(transMsg->data.p2pMsg.address.szData) - 1;
48 transMsg->data.p2pMsg.address.szData[transMsg->data.p2pMsg.address.addrLen] = '\0';
49 }
50 if (dest.at(0) == '+') {
51 transMsg->data.p2pMsg.address.digitMode = SMS_DIGIT_8BIT;
52 transMsg->data.p2pMsg.address.numberType = SMS_NUMBER_TYPE_INTERNATIONAL;
53 } else {
54 transMsg->data.p2pMsg.address.numberType = SMS_NUMBER_TYPE_NATIONAL;
55 }
56 return transMsg;
57 }
58
CreateSubmitTransMsg(const std::string & dest,const std::string & sc,int32_t port,const uint8_t * data,uint32_t dataLen,bool bStatusReport)59 std::unique_ptr<SmsTransMsg> CdmaSmsMessage::CreateSubmitTransMsg(const std::string &dest, const std::string &sc,
60 int32_t port, const uint8_t *data, uint32_t dataLen, bool bStatusReport)
61 {
62 std::unique_ptr<SmsTransMsg> transMsg = GreateTransMsg();
63 if (transMsg == nullptr) {
64 TELEPHONY_LOGE("CreateMessage message transMsg nullptr");
65 return nullptr;
66 }
67
68 scAddress_ = sc;
69 destPort_ = port;
70 originatingAddress_ = dest;
71 bStatusReportMessage_ = bStatusReport;
72 /* Set Reply option */
73 transMsg->data.p2pMsg.telesvcMsg.data.submit.replyOpt.deliverAckReq = bStatusReport;
74 /* Convert Address values */
75 transMsg->data.p2pMsg.address.digitMode = SMS_DIGIT_4BIT_DTMF;
76 transMsg->data.p2pMsg.address.numberMode = SMS_NUMBER_MODE_NONE_DATANETWORK;
77 transMsg->data.p2pMsg.address.numberPlan = SMS_NPI_UNKNOWN;
78 transMsg->data.p2pMsg.address.addrLen = dest.length();
79 if (strncpy_s(transMsg->data.p2pMsg.address.szData, sizeof(transMsg->data.p2pMsg.address.szData), dest.c_str(),
80 dest.length()) != EOK) {
81 transMsg->data.p2pMsg.address.addrLen = sizeof(transMsg->data.p2pMsg.address.szData) - 1;
82 transMsg->data.p2pMsg.address.szData[transMsg->data.p2pMsg.address.addrLen] = '\0';
83 }
84 if (dest.at(0) == '+') {
85 transMsg->data.p2pMsg.address.digitMode = SMS_DIGIT_8BIT;
86 transMsg->data.p2pMsg.address.numberType = SMS_NUMBER_TYPE_INTERNATIONAL;
87 } else {
88 transMsg->data.p2pMsg.address.numberType = SMS_NUMBER_TYPE_NATIONAL;
89 }
90 return transMsg;
91 }
92
GreateTransMsg()93 std::unique_ptr<struct SmsTransMsg> CdmaSmsMessage::GreateTransMsg()
94 {
95 std::unique_ptr<SmsTransMsg> transMsg = std::make_unique<SmsTransMsg>();
96 if (transMsg == nullptr) {
97 TELEPHONY_LOGE("CreateMessage message transMsg nullptr");
98 return nullptr;
99 }
100 (void)memset_s(transMsg.get(), sizeof(SmsTransMsg), 0x00, sizeof(SmsTransMsg));
101 transMsg->type = (SmsTransMsgType)SMS_TRANS_P2P_MSG;
102 transMsg->data.p2pMsg.telesvcMsg.type = (SmsMessageType)SMS_TYPE_SUBMIT;
103 /* 1. Set Teleservice ID */
104 transMsg->data.p2pMsg.transTelesvcId = SMS_TRANS_TELESVC_CMT_95;
105 /* 2. Set Service category */
106 transMsg->data.p2pMsg.transSvcCtg = SMS_TRANS_SVC_CTG_UNDEFINED;
107
108 /* 3. Set Valid period */
109 transMsg->data.p2pMsg.telesvcMsg.data.submit.valPeriod.format = SMS_TIME_RELATIVE;
110 transMsg->data.p2pMsg.telesvcMsg.data.submit.valPeriod.time.relTime.time = SMS_REL_TIME_INDEFINITE;
111 /* 4. Set Priority */
112 transMsg->data.p2pMsg.telesvcMsg.data.submit.priority = SMS_PRIORITY_NORMAL;
113 /* 5. Set Privacy */
114 transMsg->data.p2pMsg.telesvcMsg.data.submit.privacy = SMS_PRIVACY_NOT_RESTRICTED;
115 /* 6. Set Alert priority */
116 transMsg->data.p2pMsg.telesvcMsg.data.submit.alertPriority = SMS_ALERT_MOBILE_DEFAULT;
117 /* 7. Set Language */
118 transMsg->data.p2pMsg.telesvcMsg.data.submit.language = SMS_LAN_UNKNOWN;
119 return transMsg;
120 }
121
CovertEncodingType(const SmsCodingScheme & codingScheme)122 SmsEncodingType CdmaSmsMessage::CovertEncodingType(const SmsCodingScheme &codingScheme)
123 {
124 SmsEncodingType encodingType = SMS_ENCODE_7BIT_ASCII;
125 switch (codingScheme) {
126 case SMS_CODING_7BIT:
127 encodingType = SMS_ENCODE_GSM7BIT;
128 break;
129 case SMS_CODING_ASCII7BIT:
130 encodingType = SMS_ENCODE_7BIT_ASCII;
131 break;
132 case SMS_CODING_8BIT:
133 encodingType = SMS_ENCODE_OCTET;
134 break;
135 case SMS_CODING_UCS2:
136 default:
137 encodingType = SMS_ENCODE_UNICODE;
138 break;
139 }
140 return encodingType;
141 }
142
CreateMessage(const std::string & pdu)143 std::shared_ptr<CdmaSmsMessage> CdmaSmsMessage::CreateMessage(const std::string &pdu)
144 {
145 std::shared_ptr<CdmaSmsMessage> message = std::make_shared<CdmaSmsMessage>();
146 if (message == nullptr) {
147 TELEPHONY_LOGE("CreateMessage message nullptr");
148 return nullptr;
149 }
150 message->transMsg_ = std::make_unique<struct SmsTransMsg>();
151 if (message->transMsg_ == nullptr) {
152 TELEPHONY_LOGE("CreateMessage message transMsg_ nullptr");
153 return nullptr;
154 }
155
156 (void)memset_s(message->transMsg_.get(), sizeof(struct SmsTransMsg), 0x00, sizeof(struct SmsTransMsg));
157 if (message->PduAnalysis(pdu)) {
158 return message;
159 }
160 return nullptr;
161 }
162
PduAnalysis(const std::string & pduHex)163 bool CdmaSmsMessage::PduAnalysis(const std::string &pduHex)
164 {
165 if (transMsg_ == nullptr || pduHex.empty()) {
166 TELEPHONY_LOGE("PduAnalysis is unInvalid param!");
167 return false;
168 }
169
170 rawPdu_ = StringUtils::HexToByteVector(pduHex);
171 if (!CdmaSmsPduCodec::CheckInvalidPDU(rawPdu_)) {
172 TELEPHONY_LOGE("PduAnalysis is unInvalid pdu data!");
173 return false;
174 }
175
176 int decodeLen = 0;
177 std::string pdu = StringUtils::HexToString(pduHex);
178 decodeLen =
179 CdmaSmsPduCodec::DecodeMsg(reinterpret_cast<const unsigned char *>(pdu.c_str()), pdu.length(), *transMsg_);
180 if (decodeLen <= 0) {
181 TELEPHONY_LOGE("Pdu DecodeMsg has failure.");
182 return false;
183 }
184 if (transMsg_->type == SMS_TRANS_BROADCAST_MSG) {
185 if (transMsg_->data.cbMsg.telesvcMsg.data.deliver.cmasData.isWrongRecodeType) {
186 TELEPHONY_LOGE("Invalid CMAS Record Type");
187 return false;
188 }
189 SmsEncodingType encodeType = transMsg_->data.cbMsg.telesvcMsg.data.deliver.cmasData.encodeType;
190 if ((encodeType == SMS_ENCODE_KOREAN) || (encodeType == SMS_ENCODE_GSMDCS)) {
191 TELEPHONY_LOGE("This encode type is not supported [%{public}d]", encodeType);
192 return false;
193 }
194 }
195 switch (transMsg_->type) {
196 case SMS_TRANS_P2P_MSG:
197 AnalysisP2pMsg(transMsg_->data.p2pMsg);
198 break;
199 case SMS_TRANS_BROADCAST_MSG:
200 AnalysisCbMsg(transMsg_->data.cbMsg);
201 break;
202 case SMS_TRANS_ACK_MSG:
203 AnalsisAckMsg(transMsg_->data.ackMsg);
204 break;
205 default:
206 return false;
207 }
208 return true;
209 }
210
AnalysisP2pMsg(const SmsTransP2PMsg & p2pMsg)211 void CdmaSmsMessage::AnalysisP2pMsg(const SmsTransP2PMsg &p2pMsg)
212 {
213 if (p2pMsg.transTelesvcId == SMS_TRANS_TELESVC_RESERVED) {
214 TELEPHONY_LOGE("this Incoming Message has Unknown Teleservice ID");
215 return;
216 }
217
218 address_ = std::make_unique<struct SmsTransAddr>();
219 if (address_ == nullptr) {
220 TELEPHONY_LOGE("AnalysisP2pMsg make address == nullptr");
221 return;
222 }
223
224 if (memcpy_s(address_.get(), sizeof(SmsTransAddr), &p2pMsg.address, sizeof(SmsTransAddr)) != EOK) {
225 TELEPHONY_LOGE("AnalysisP2pMsg address memcpy_s error.");
226 return;
227 }
228
229 originatingAddress_ = address_->szData;
230 switch (p2pMsg.telesvcMsg.type) {
231 case SmsMessageType::SMS_TYPE_DELIVER:
232 AnalsisDeliverMwi(p2pMsg);
233 AnalsisDeliverMsg(p2pMsg.telesvcMsg.data.deliver);
234 break;
235 case SmsMessageType::SMS_TYPE_DELIVERY_ACK:
236 AnalsisDeliverAck(p2pMsg.telesvcMsg.data.deliveryAck);
237 break;
238 case SmsMessageType::SMS_TYPE_USER_ACK:
239 case SmsMessageType::SMS_TYPE_READ_ACK:
240 break;
241 case SmsMessageType::SMS_TYPE_SUBMIT_REPORT:
242 AnalsisSubmitReport(p2pMsg.telesvcMsg.data.report);
243 break;
244 case SmsMessageType::SMS_TYPE_SUBMIT:
245 AnalsisSubmitMsg(p2pMsg.telesvcMsg.data.submit);
246 break;
247 default:
248 TELEPHONY_LOGI("AnalysisP2pMsg unkown type =%{public}d", p2pMsg.telesvcMsg.type);
249 break;
250 }
251 }
252
AnalsisDeliverMwi(const SmsTransP2PMsg & p2pMsg)253 void CdmaSmsMessage::AnalsisDeliverMwi(const SmsTransP2PMsg &p2pMsg)
254 {
255 specialSmsInd_ = nullptr;
256 if (p2pMsg.transTelesvcId == SMS_TRANS_TELESVC_VMN_95) {
257 specialSmsInd_ = std::make_shared<SpecialSmsIndication>();
258 if (specialSmsInd_ == nullptr) {
259 TELEPHONY_LOGE("SpecialSmsIndication is null!");
260 return;
261 }
262
263 specialSmsInd_->msgInd = SMS_VOICE_INDICATOR;
264 if (p2pMsg.telesvcMsg.data.deliver.enhancedVmn.faxIncluded) {
265 specialSmsInd_->msgInd = SMS_FAX_INDICATOR;
266 }
267
268 if (p2pMsg.telesvcMsg.data.deliver.numMsg < 0) {
269 specialSmsInd_->waitMsgNum = 0;
270 bMwiClear_ = true;
271 bMwiSet_ = false;
272 } else {
273 specialSmsInd_->waitMsgNum = p2pMsg.telesvcMsg.data.deliver.numMsg;
274 bMwiClear_ = false;
275 bMwiSet_ = true;
276 }
277
278 bMwiNotStore_ = false;
279 if (bMwiSet_ && (p2pMsg.telesvcMsg.data.deliver.userData.userData.length == 0)) {
280 bMwiNotStore_ = true;
281 }
282 }
283 }
284
AnalsisDeliverMsg(const SmsTeleSvcDeliver & deliver)285 void CdmaSmsMessage::AnalsisDeliverMsg(const SmsTeleSvcDeliver &deliver)
286 {
287 isCmas_ = false;
288 msgClass_ = SMS_CLASS_UNKNOWN;
289 if (deliver.displayMode == SMS_DISPLAY_IMMEDIATE) {
290 msgClass_ = SMS_INSTANT_MESSAGE;
291 }
292
293 msgRef_ = deliver.msgId.msgId;
294 bHeaderInd_ = deliver.msgId.headerInd;
295 scTimestamp_ = SmsCommonUtils::ConvertTime(deliver.timeStamp);
296 AnalsisUserData(deliver.userData);
297 }
298
AnalsisDeliverAck(const SmsTeleSvcDeliverAck & deliverAck)299 void CdmaSmsMessage::AnalsisDeliverAck(const SmsTeleSvcDeliverAck &deliverAck)
300 {
301 bStatusReportMessage_ = true;
302 scTimestamp_ = SmsCommonUtils::ConvertTime(deliverAck.timeStamp);
303 AnalsisUserData(deliverAck.userData);
304 }
305
AnalsisSubmitReport(const SmsTeleSvcDeliverReport & report)306 void CdmaSmsMessage::AnalsisSubmitReport(const SmsTeleSvcDeliverReport &report)
307 {
308 AnalsisUserData(report.userData);
309 }
310
AnalsisSubmitMsg(const SmsTeleSvcSubmit & submit)311 void CdmaSmsMessage::AnalsisSubmitMsg(const SmsTeleSvcSubmit &submit)
312 {
313 msgRef_ = submit.msgId.msgId;
314 bHeaderInd_ = submit.msgId.headerInd;
315 scTimestamp_ = SmsCommonUtils::ConvertTime(submit.valPeriod.time.absTime);
316 AnalsisUserData(submit.userData);
317 }
318
AnalsisUserData(const SmsTeleSvcUserData & userData)319 void CdmaSmsMessage::AnalsisUserData(const SmsTeleSvcUserData &userData)
320 {
321 int dataSize = 0;
322 MsgLangInfo langinfo = {
323 0,
324 };
325 AnalsisHeader(userData);
326 MsgTextConvert *textCvt = MsgTextConvert::Instance();
327 if (textCvt == nullptr) {
328 return;
329 }
330 unsigned char buff[MAX_MSG_TEXT_LEN + 1] = {0};
331 switch (userData.encodeType) {
332 case SMS_ENCODE_GSM7BIT: {
333 dataSize = textCvt->ConvertGSM7bitToUTF8(
334 buff, MAX_MSG_TEXT_LEN, (unsigned char *)&userData.userData, userData.userData.length, &langinfo);
335 break;
336 }
337 case SMS_ENCODE_KOREAN:
338 case SMS_ENCODE_EUCKR: {
339 dataSize = textCvt->ConvertEUCKRToUTF8(
340 buff, MAX_MSG_TEXT_LEN, (unsigned char *)&userData.userData, userData.userData.length);
341 break;
342 }
343 case SMS_ENCODE_IA5:
344 case SMS_ENCODE_7BIT_ASCII:
345 case SMS_ENCODE_LATIN_HEBREW:
346 case SMS_ENCODE_LATIN:
347 case SMS_ENCODE_OCTET: {
348 if (memcpy_s(buff, sizeof(buff), userData.userData.data, userData.userData.length) != EOK) {
349 TELEPHONY_LOGE("AnalsisDeliverMsg memcpy_s fail.");
350 return;
351 }
352 dataSize = userData.userData.length;
353 buff[dataSize] = '\0';
354 break;
355 }
356 case SMS_ENCODE_SHIFT_JIS: {
357 dataSize = textCvt->ConvertSHIFTJISToUTF8(
358 buff, MAX_MSG_TEXT_LEN, (unsigned char *)&userData.userData.data, userData.userData.length);
359 break;
360 }
361 default: {
362 dataSize = textCvt->ConvertUCS2ToUTF8(
363 buff, MAX_MSG_TEXT_LEN, (unsigned char *)&userData.userData.data, userData.userData.length);
364 break;
365 }
366 }
367 visibleMessageBody_.insert(0, (char *)buff, dataSize);
368 TELEPHONY_LOGI("AnalsisDeliverMsg userData == %{public}s", visibleMessageBody_.c_str());
369 }
370
AnalsisCMASMsg(const SmsTeleSvcDeliver & deliver)371 void CdmaSmsMessage::AnalsisCMASMsg(const SmsTeleSvcDeliver &deliver)
372 {
373 isCmas_ = true;
374 category_ = deliver.cmasData.category;
375 responseType_ = deliver.cmasData.responseType;
376 severity_ = deliver.cmasData.severity;
377 urgency_ = deliver.cmasData.urgency;
378 certainty_ = deliver.cmasData.certainty;
379 messageClass_ = deliver.cmasData.alertHandle;
380 msgClass_ = SMS_CLASS_UNKNOWN;
381 scTimestamp_ = SmsCommonUtils::ConvertTime(deliver.timeStamp);
382 SmsTeleSvcUserData userData;
383 (void)memset_s(&userData, sizeof(SmsTeleSvcUserData), 0x00, sizeof(SmsTeleSvcUserData));
384 userData.userData.length = deliver.cmasData.dataLen;
385 userData.encodeType = deliver.cmasData.encodeType;
386 if (memcpy_s(userData.userData.data, sizeof(userData.userData.data), deliver.cmasData.alertText,
387 deliver.cmasData.dataLen) == EOK) {
388 AnalsisUserData(userData);
389 }
390 }
391
AnalysisCbMsg(const SmsTransBroadCastMsg & cbMsg)392 void CdmaSmsMessage::AnalysisCbMsg(const SmsTransBroadCastMsg &cbMsg)
393 {
394 serviceCategory_ = cbMsg.transSvcCtg;
395 if (cbMsg.telesvcMsg.type != SmsMessageType::SMS_TYPE_DELIVER) {
396 TELEPHONY_LOGE("No matching type = [%{public}d]", cbMsg.telesvcMsg.type);
397 return;
398 }
399 messageId_ = cbMsg.telesvcMsg.data.deliver.msgId.msgId;
400 priority_ = cbMsg.telesvcMsg.data.deliver.priority;
401 language_ = cbMsg.telesvcMsg.data.deliver.language;
402 TELEPHONY_LOGI("analysisCbMsg transSvcCtg %{public}d", cbMsg.transSvcCtg);
403 if ((cbMsg.transSvcCtg >= SMS_TRANS_SVC_CTG_CMAS_PRESIDENTIAL) &&
404 (cbMsg.transSvcCtg <= SMS_TRANS_SVC_CTG_CMAS_TEST)) {
405 AnalsisCMASMsg(cbMsg.telesvcMsg.data.deliver);
406 } else {
407 AnalsisDeliverMsg(cbMsg.telesvcMsg.data.deliver);
408 }
409 }
410
AnalsisAckMsg(const SmsTransAckMsg & ackMsg)411 void CdmaSmsMessage::AnalsisAckMsg(const SmsTransAckMsg &ackMsg)
412 {
413 originatingAddress_ = ackMsg.address.szData;
414 }
415
AddUserDataHeader(const struct SmsUDH & header)416 bool CdmaSmsMessage::AddUserDataHeader(const struct SmsUDH &header)
417 {
418 if (userHeaders_.size() >= CDMA_MAX_UD_HEADER_NUM) {
419 return false;
420 }
421
422 userHeaders_.push_back(header);
423 return true;
424 }
425
AnalsisHeader(const SmsTeleSvcUserData & userData)426 void CdmaSmsMessage::AnalsisHeader(const SmsTeleSvcUserData &userData)
427 {
428 if (memset_s(&smsUserData_, sizeof(SmsUserData), 0x00, sizeof(SmsUserData)) != EOK) {
429 return;
430 }
431 headerDataLen_ = userData.userData.length;
432 if (memcpy_s(&smsUserData_, sizeof(SmsUserData), &(userData.userData), sizeof(SmsUserData)) != EOK) {
433 return;
434 }
435
436 if (bHeaderInd_ && userData.userData.headerCnt > 0) {
437 userHeaders_.clear();
438 for (int i = 0; i < userData.userData.headerCnt; i++) {
439 userHeaders_.push_back(userData.userData.header[i]);
440 }
441 }
442 }
443
444 /**
445 * @brief GetTransMsgType
446 * 0x00 is point to point message
447 * 0x01 is broadcast message
448 * 0x02 is ack message
449 * 0x03 is unkown message
450 * @return int
451 */
GetTransMsgType() const452 int CdmaSmsMessage::GetTransMsgType() const
453 {
454 if (transMsg_ == nullptr) {
455 TELEPHONY_LOGE("Trans message type unkown!");
456 return SMS_TRANS_TYPE_RESERVED;
457 }
458
459 return transMsg_->type;
460 }
461
462 /**
463 * @brief Get the Trans Tele Service object
464 * 0x1000 IS-91 Extended Protocol Enhanced Services
465 * 0x1001 Wireless Paging Teleservice
466 * 0x1002 Wireless Messaging Teleservice
467 * 0x1003 Voice Mail Notification
468 * 0x1004 Wireless Application Protocol
469 * 0x1005 Wireless Enhanced Messaging Teleservice
470 * 0x1006 Service Category Programming Teleservice
471 * 0x1007 Card Application Toolkit Protocol Teleservice
472 * 0xffff
473 * @return int
474 */
GetTransTeleService() const475 int CdmaSmsMessage::GetTransTeleService() const
476 {
477 if ((transMsg_ == nullptr) || (transMsg_->type != SMS_TRANS_P2P_MSG)) {
478 TELEPHONY_LOGE("Trans Tele Service is error");
479 return SMS_TRANS_TELESVC_RESERVED;
480 }
481
482 return transMsg_->data.p2pMsg.transTelesvcId;
483 }
484
GetProtocolId() const485 int CdmaSmsMessage::GetProtocolId() const
486 {
487 return 0;
488 }
489
IsReplaceMessage()490 bool CdmaSmsMessage::IsReplaceMessage()
491 {
492 return false;
493 }
494
IsCphsMwi() const495 bool CdmaSmsMessage::IsCphsMwi() const
496 {
497 return false;
498 }
499
IsWapPushMsg()500 bool CdmaSmsMessage::IsWapPushMsg()
501 {
502 if (transMsg_ == nullptr) {
503 return false;
504 }
505
506 if (transMsg_->type == SMS_TRANS_P2P_MSG) {
507 return (transMsg_->data.p2pMsg.transTelesvcId == SMS_TRANS_TELESVC_WAP);
508 }
509 return false;
510 }
511
GetSpecialSmsInd()512 std::shared_ptr<SpecialSmsIndication> CdmaSmsMessage::GetSpecialSmsInd()
513 {
514 return specialSmsInd_;
515 }
516
IsStatusReport() const517 bool CdmaSmsMessage::IsStatusReport() const
518 {
519 return (transMsg_->data.p2pMsg.telesvcMsg.type == SMS_TYPE_DELIVERY_ACK);
520 }
521
GetDestPort() const522 int16_t CdmaSmsMessage::GetDestPort() const
523 {
524 return destPort_;
525 }
526
IsBroadcastMsg() const527 bool CdmaSmsMessage::IsBroadcastMsg() const
528 {
529 return GetTransMsgType() == SMS_TRANS_BROADCAST_MSG;
530 }
531
DecodeMessage(unsigned char * decodeData,SmsCodingScheme & codingType,const std::string & msgText,bool & bAbnormal,MSG_LANGUAGE_ID_T & langId)532 int CdmaSmsMessage::DecodeMessage(unsigned char *decodeData, SmsCodingScheme &codingType,
533 const std::string &msgText, bool &bAbnormal, MSG_LANGUAGE_ID_T &langId)
534 {
535 int decodeLen = 0;
536 int dataLen = msgText.length();
537 const int maxDecodeLen = (MAX_GSM_7BIT_DATA_LEN * MAX_SEGMENT_NUM) + 1;
538 const unsigned char *pMsgText = (const unsigned char *)msgText.c_str();
539
540 MsgTextConvert *textCvt = MsgTextConvert::Instance();
541 if (textCvt == nullptr) {
542 TELEPHONY_LOGE("MsgTextConvert Instance is nullptr");
543 return decodeLen;
544 }
545 if (msgText.empty()) {
546 TELEPHONY_LOGE("MsgText is empty!");
547 return decodeLen;
548 }
549
550 switch (codingType) {
551 case SMS_CODING_7BIT: {
552 if (memcpy_s(decodeData, maxDecodeLen, pMsgText, dataLen) != EOK) {
553 TELEPHONY_LOGE("SplitMessage SMS_CHARSET_8BIT memcpy_s error!");
554 return decodeLen;
555 }
556 decodeLen = dataLen;
557 codingType = SMS_CODING_ASCII7BIT;
558 break;
559 }
560 case SMS_CODING_8BIT: {
561 if (memcpy_s(decodeData, maxDecodeLen, pMsgText, dataLen) != EOK) {
562 TELEPHONY_LOGE("SplitMessage SMS_CHARSET_8BIT memcpy_s error!");
563 return decodeLen;
564 }
565 decodeLen = dataLen;
566 break;
567 }
568 case SMS_CODING_UCS2: {
569 decodeLen = textCvt->ConvertUTF8ToUCS2(decodeData, maxDecodeLen, pMsgText, dataLen);
570 break;
571 }
572 case SMS_CODING_AUTO:
573 default: {
574 decodeLen = textCvt->ConvertCdmaUTF8ToAuto(decodeData, maxDecodeLen, pMsgText, dataLen, &codingType);
575 break;
576 }
577 }
578 return decodeLen;
579 }
580
GetCMASCategory() const581 int8_t CdmaSmsMessage::GetCMASCategory() const
582 {
583 return category_;
584 }
585
GetCMASResponseType() const586 int8_t CdmaSmsMessage::GetCMASResponseType() const
587 {
588 return responseType_;
589 }
590
GetCMASSeverity() const591 int8_t CdmaSmsMessage::GetCMASSeverity() const
592 {
593 return severity_;
594 }
595
GetCMASUrgency() const596 int8_t CdmaSmsMessage::GetCMASUrgency() const
597 {
598 return urgency_;
599 }
600
GetCMASCertainty() const601 int8_t CdmaSmsMessage::GetCMASCertainty() const
602 {
603 return certainty_;
604 }
605
GetCMASMessageClass() const606 int8_t CdmaSmsMessage::GetCMASMessageClass() const
607 {
608 return messageClass_;
609 }
610
IsCMAS() const611 bool CdmaSmsMessage::IsCMAS() const
612 {
613 return isCmas_;
614 }
615
GetMessageId() const616 uint16_t CdmaSmsMessage::GetMessageId() const
617 {
618 return messageId_;
619 }
620
GetFormat() const621 int8_t CdmaSmsMessage::GetFormat() const
622 {
623 constexpr int8_t FORMAT_3GPP2 = 2;
624 return FORMAT_3GPP2;
625 }
626
GetLanguage() const627 int8_t CdmaSmsMessage::GetLanguage() const
628 {
629 return language_;
630 }
631
GetCbInfo() const632 std::string CdmaSmsMessage::GetCbInfo() const
633 {
634 std::string info;
635 info.append("isCmas:")
636 .append(isCmas_ ? "true":"false")
637 .append("\n")
638 .append("format:")
639 .append(std::to_string(GetFormat()))
640 .append("\n")
641 .append("messageId:")
642 .append(std::to_string(messageId_))
643 .append("\n")
644 .append("serviceCategory:")
645 .append(std::to_string(category_))
646 .append("\n")
647 .append("language:")
648 .append(std::to_string(language_))
649 .append("\n")
650 .append("body:")
651 .append(visibleMessageBody_)
652 .append("\n")
653 .append("priority:")
654 .append(std::to_string(priority_))
655 .append("\n")
656 .append("responseType:")
657 .append(std::to_string(responseType_))
658 .append("\n")
659 .append("severity:")
660 .append(std::to_string(severity_))
661 .append("\n")
662 .append("urgency:")
663 .append(std::to_string(urgency_))
664 .append("\n")
665 .append("certainty:")
666 .append(std::to_string(certainty_))
667 .append("\n")
668 .append("messageClass:")
669 .append(std::to_string(messageClass_))
670 .append("\n")
671 .append("serviceCategory:")
672 .append(std::to_string(serviceCategory_));
673 return info;
674 }
675
GetPriority() const676 int8_t CdmaSmsMessage::GetPriority() const
677 {
678 return priority_;
679 }
680
IsEmergencyMsg() const681 bool CdmaSmsMessage::IsEmergencyMsg() const
682 {
683 return priority_ == SMS_PRIORITY_EMERGENCY;
684 }
685
GetServiceCategoty() const686 uint16_t CdmaSmsMessage::GetServiceCategoty() const
687 {
688 return serviceCategory_;
689 }
690
GetGeoScope() const691 uint8_t CdmaSmsMessage::GetGeoScope() const
692 {
693 const uint8_t scopePlmnWide = 1;
694 return scopePlmnWide;
695 }
696
GetReceTime() const697 long CdmaSmsMessage::GetReceTime() const
698 {
699 return scTimestamp_;
700 }
701 } // namespace Telephony
702 } // namespace OHOS