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 "gsm_sms_receive_handler.h"
17
18 #include "core_manager_inner.h"
19 #include "gsm_sms_message.h"
20 #include "radio_event.h"
21 #include "sms_common.h"
22 #include "satellite_sms_client.h"
23 #include "sms_hisysevent.h"
24 #include "sms_persist_helper.h"
25 #include "sms_receive_reliability_handler.h"
26 #include "telephony_log_wrapper.h"
27
28 namespace OHOS {
29 namespace Telephony {
30 using namespace std;
31 static constexpr int16_t INVALID_SMS_PORT = 0x157b;
32
GsmSmsReceiveHandler(int32_t slotId)33 GsmSmsReceiveHandler::GsmSmsReceiveHandler(int32_t slotId) : SmsReceiveHandler(slotId) {}
34
~GsmSmsReceiveHandler()35 GsmSmsReceiveHandler::~GsmSmsReceiveHandler()
36 {
37 if (smsCbHandler_ != nullptr) {
38 smsCbHandler_->UnRegisterHandler();
39 }
40 }
41
Init()42 void GsmSmsReceiveHandler::Init()
43 {
44 if (!RegisterHandler()) {
45 TELEPHONY_LOGI("GsmSmsSender::Init Register RADIO_SMS_STATUS fail.");
46 }
47 smsCbHandler_ = std::make_shared<GsmSmsCbHandler>(slotId_);
48 if (smsCbHandler_ == nullptr) {
49 TELEPHONY_LOGE("failed to create GsmSmsCbHandler");
50 return;
51 }
52 smsCbHandler_->Init();
53 TELEPHONY_LOGI("smsCbHandler_->Run().");
54 }
55
RegisterHandler()56 bool GsmSmsReceiveHandler::RegisterHandler()
57 {
58 TELEPHONY_LOGI("GsmSmsReceiveHandler::RegisteHandler Register RADIO_GSM_SMS ok.");
59 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
60 if (satelliteSmsClient.GetSatelliteSupported()) {
61 TELEPHONY_LOGI("satellite is supported.");
62 satelliteSmsClient.AddReceiveHandler(slotId_, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
63 }
64 CoreManagerInner::GetInstance().RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_GSM_SMS, nullptr);
65
66 return true;
67 }
68
UnRegisterHandler()69 void GsmSmsReceiveHandler::UnRegisterHandler()
70 {
71 TELEPHONY_LOGI("SmsReceiveHandler::UnRegisterHandler::slotId= %{public}d", slotId_);
72 CoreManagerInner::GetInstance().UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_GSM_SMS);
73 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
74 if (satelliteSmsClient.GetSatelliteSupported() && satelliteCallback_ != nullptr) {
75 TELEPHONY_LOGI("satellite is supported.");
76 satelliteSmsClient.UnRegisterSmsNotify(slotId_, RadioEvent::RADIO_GSM_SMS);
77 satelliteSmsClient.UnRegisterSmsNotify(slotId_, SMS_EVENT_NEW_SMS_REPLY);
78 }
79 }
80
RegisterSatelliteCallback()81 void GsmSmsReceiveHandler::RegisterSatelliteCallback()
82 {
83 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
84 if (satelliteSmsClient.GetSatelliteSupported()) {
85 TELEPHONY_LOGI("gsm receiver register satellite notify");
86 satelliteCallback_ =
87 std::make_unique<SatelliteSmsCallback>(std::static_pointer_cast<TelEventHandler>(shared_from_this()))
88 .release();
89 satelliteSmsClient.RegisterSmsNotify(slotId_, RadioEvent::RADIO_GSM_SMS, satelliteCallback_);
90 satelliteSmsClient.RegisterSmsNotify(slotId_, SMS_EVENT_NEW_SMS_REPLY, satelliteCallback_);
91 }
92 }
93
UnregisterSatelliteCallback()94 void GsmSmsReceiveHandler::UnregisterSatelliteCallback()
95 {
96 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
97 if (satelliteSmsClient.GetSatelliteSupported()) {
98 TELEPHONY_LOGI("gsm receiver unregister satellite notify");
99 satelliteCallback_ = nullptr;
100 }
101 }
102
HandleSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)103 int32_t GsmSmsReceiveHandler::HandleSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)
104 {
105 if (smsBaseMessage == nullptr) {
106 TELEPHONY_LOGE("BaseMessage is null.");
107 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
108 }
109 GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
110 if (message->IsSpecialMessage()) {
111 TELEPHONY_LOGI("GsmSmsReceiveHandler:: IsSpecialMessage");
112 return AckIncomeCause::SMS_ACK_RESULT_OK;
113 }
114 int ret = CheckSmsSupport();
115 if (ret != AckIncomeCause::SMS_ACK_RESULT_OK) {
116 return ret;
117 }
118 bool block = DelayedSingleton<SmsPersistHelper>::GetInstance()->QueryBlockPhoneNumber(
119 smsBaseMessage->GetOriginatingAddress());
120 if (block) {
121 TELEPHONY_LOGE("sms address is blocked");
122 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
123 SmsMmsErrorCode::SMS_ERROR_ADDRESS_BLOCKED, "The SMS address is blocked");
124 return AckIncomeCause::SMS_ACK_RESULT_OK;
125 }
126 return HandleNormalSmsByType(smsBaseMessage);
127 }
128
CheckSmsSupport()129 int32_t GsmSmsReceiveHandler::CheckSmsSupport()
130 {
131 auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId_);
132 if (reliabilityHandler == nullptr) {
133 TELEPHONY_LOGE("reliabilityHandler nullptr");
134 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
135 }
136 if (!(reliabilityHandler->CheckSmsCapable())) {
137 TELEPHONY_LOGI("sms receive capable unSupport");
138 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
139 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "sms receive capable unsupported");
140 return AckIncomeCause::SMS_ACK_PROCESSED;
141 }
142 if (!reliabilityHandler->DeleteExpireSmsFromDB()) {
143 TELEPHONY_LOGE("DeleteExpireSmsFromDB fail");
144 }
145 return AckIncomeCause::SMS_ACK_RESULT_OK;
146 }
147
HandleNormalSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)148 int32_t GsmSmsReceiveHandler::HandleNormalSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)
149 {
150 if (smsBaseMessage == nullptr) {
151 TELEPHONY_LOGE("BaseMessage is null.");
152 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
153 }
154 GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
155
156 shared_ptr<SmsReceiveIndexer> indexer;
157 if (!message->IsConcatMsg()) {
158 indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
159 message->GetDestPort(), !message->GetGsm(), false, message->GetOriginatingAddress(),
160 message->GetVisibleOriginatingAddress(), message->GetVisibleMessageBody());
161 } else {
162 std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
163 if (smsConcat == nullptr) {
164 TELEPHONY_LOGE("Concat is null.");
165 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
166 }
167 indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
168 message->GetDestPort(), !message->GetGsm(), message->GetOriginatingAddress(),
169 message->GetVisibleOriginatingAddress(), smsConcat->msgRef, smsConcat->seqNum, smsConcat->totalSeg,
170 false, message->GetVisibleMessageBody());
171 }
172 if (indexer == nullptr) {
173 TELEPHONY_LOGE("indexer is null.");
174 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
175 }
176 indexer->SetRawUserData(message->GetRawUserData());
177 indexer->SetRawWapPushUserData(message->GetRawWapPushUserData());
178
179 TELEPHONY_LOGI("received a gsm sms, this is %{public}d, a total of %{public}d", indexer->GetMsgSeqId(),
180 indexer->GetMsgCount());
181 if (indexer->GetIsText() && message->IsConcatMsg() && IsRepeatedMessagePart(indexer)) {
182 TELEPHONY_LOGE("Ack repeated error.");
183 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
184 SmsMmsErrorCode::SMS_ERROR_REPEATED_ERROR, "gsm message repeated error");
185 return AckIncomeCause::SMS_ACK_REPEATED_ERROR;
186 }
187 auto destPort = indexer->GetDestPort();
188 if (destPort == INVALID_SMS_PORT) {
189 TELEPHONY_LOGI("[invalid sms port] =%{public}s", StringUtils::StringToHex(message->GetRawPdu()).c_str());
190 return AckIncomeCause::SMS_ACK_RESULT_OK;
191 }
192 if (!AddMsgToDB(indexer)) {
193 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
194 }
195 CombineMessagePart(indexer);
196 return AckIncomeCause::SMS_ACK_RESULT_OK;
197 }
198
ReplySmsToSmsc(int result,const shared_ptr<SmsBaseMessage> response)199 void GsmSmsReceiveHandler::ReplySmsToSmsc(int result, const shared_ptr<SmsBaseMessage> response)
200 {
201 TELEPHONY_LOGI("GsmSmsReceiveHandler::ReplySmsToSmsc ackResult %{public}d", result);
202 auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
203 if (satelliteSmsClient.GetSatelliteCapability() > 0 && satelliteSmsClient.IsSatelliteEnabled()) {
204 TELEPHONY_LOGI("send smsack through satellite");
205 satelliteSmsClient.SendSmsAck(
206 slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result);
207 return;
208 }
209 CoreManagerInner::GetInstance().SendSmsAck(
210 slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result, shared_from_this());
211 }
212
TransformMessageInfo(const shared_ptr<SmsMessageInfo> info)213 shared_ptr<SmsBaseMessage> GsmSmsReceiveHandler::TransformMessageInfo(const shared_ptr<SmsMessageInfo> info)
214 {
215 std::shared_ptr<SmsBaseMessage> baseMessage = nullptr;
216 if (info == nullptr) {
217 TELEPHONY_LOGE("MessageInfo is null.");
218 return baseMessage;
219 }
220 std::string pdu = StringUtils::StringToHex(info->pdu);
221 baseMessage = GsmSmsMessage::CreateMessage(pdu);
222 return baseMessage;
223 }
224 } // namespace Telephony
225 } // namespace OHOS
226