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     return HandleNormalSmsByType(smsBaseMessage);
119 }
120 
HandleAck(const std::shared_ptr<SmsBaseMessage> smsBaseMessage)121 int32_t GsmSmsReceiveHandler::HandleAck(const std::shared_ptr<SmsBaseMessage> smsBaseMessage)
122 {
123     if (smsBaseMessage == nullptr) {
124         TELEPHONY_LOGE("BaseMessage is null");
125         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
126     }
127     GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
128     if (message->IsSpecialMessage()) {
129         TELEPHONY_LOGI("GsmSmsReceiveHandler:: IsSpecialMessage");
130         return AckIncomeCause::SMS_ACK_RESULT_OK;
131     }
132     auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId_);
133     if (reliabilityHandler == nullptr) {
134         TELEPHONY_LOGE("reliabilityHandler nullptr");
135         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
136     }
137     if (!(reliabilityHandler->CheckSmsCapable())) {
138         TELEPHONY_LOGE("sms receive capable unSupport");
139         SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
140             SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "sms receive capable unsupported");
141         return AckIncomeCause::SMS_ACK_PROCESSED;
142     }
143     if (message->IsConcatMsg()) {
144         std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
145         if (smsConcat == nullptr) {
146             TELEPHONY_LOGE("Concat is null.");
147             return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
148         }
149     }
150     return AckIncomeCause::SMS_ACK_RESULT_OK;
151 }
152 
HandleRemainDataShare(const std::shared_ptr<SmsBaseMessage> smsBaseMessage)153 void GsmSmsReceiveHandler::HandleRemainDataShare(const std::shared_ptr<SmsBaseMessage> smsBaseMessage)
154 {
155     if (smsBaseMessage == nullptr) {
156         TELEPHONY_LOGE("BaseMessage is null");
157         return;
158     }
159     GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
160     auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId_);
161     if (reliabilityHandler != nullptr) {
162         if (!reliabilityHandler->DeleteExpireSmsFromDB()) {
163             TELEPHONY_LOGE("DeleteExpireSmsFromDB fail");
164         }
165     }
166     shared_ptr<SmsReceiveIndexer> indexer;
167     if (!message->IsConcatMsg()) {
168         indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
169             message->GetDestPort(), !message->GetGsm(), false, message->GetOriginatingAddress(),
170             message->GetVisibleOriginatingAddress(), message->GetVisibleMessageBody());
171     } else {
172         std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
173         if (smsConcat == nullptr) {
174             TELEPHONY_LOGE("Concat is null.");
175             return;
176         }
177         indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
178             message->GetDestPort(), !message->GetGsm(), message->GetOriginatingAddress(),
179             message->GetVisibleOriginatingAddress(), smsConcat->msgRef, smsConcat->seqNum, smsConcat->totalSeg,
180             false, message->GetVisibleMessageBody());
181     }
182     if (indexer == nullptr) {
183         return;
184     }
185     indexer->SetRawUserData(message->GetRawUserData());
186     indexer->SetRawWapPushUserData(message->GetRawWapPushUserData());
187     TELEPHONY_LOGI("received a gsm sms, the refid is %{public}d, this is %{public}d, a total of %{public}d",
188         indexer->GetMsgRefId(), indexer->GetMsgSeqId(), indexer->GetMsgCount());
189     if (indexer->GetIsText() && message->IsConcatMsg() && IsRepeatedMessagePart(indexer)) {
190         TELEPHONY_LOGE("Ack repeated error.");
191         SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
192             SmsMmsErrorCode::SMS_ERROR_REPEATED_ERROR, "gsm message repeated error");
193         return;
194     }
195     auto destPort = indexer->GetDestPort();
196     if (destPort == INVALID_SMS_PORT) {
197         TELEPHONY_LOGI("[invalid sms port]");
198     }
199     if (!AddMsgToDB(indexer)) {
200         return;
201     }
202     CombineMessagePart(indexer);
203 }
204 
CheckSmsSupport()205 int32_t GsmSmsReceiveHandler::CheckSmsSupport()
206 {
207     auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId_);
208     if (reliabilityHandler == nullptr) {
209         TELEPHONY_LOGE("reliabilityHandler nullptr");
210         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
211     }
212     if (!(reliabilityHandler->CheckSmsCapable())) {
213         TELEPHONY_LOGI("sms receive capable unSupport");
214         SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
215             SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "sms receive capable unsupported");
216         return AckIncomeCause::SMS_ACK_PROCESSED;
217     }
218     if (!reliabilityHandler->DeleteExpireSmsFromDB()) {
219         TELEPHONY_LOGE("DeleteExpireSmsFromDB fail");
220     }
221     return AckIncomeCause::SMS_ACK_RESULT_OK;
222 }
223 
HandleNormalSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)224 int32_t GsmSmsReceiveHandler::HandleNormalSmsByType(const shared_ptr<SmsBaseMessage> smsBaseMessage)
225 {
226     if (smsBaseMessage == nullptr) {
227         TELEPHONY_LOGE("BaseMessage is null.");
228         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
229     }
230     GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
231 
232     shared_ptr<SmsReceiveIndexer> indexer;
233     if (!message->IsConcatMsg()) {
234         indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
235             message->GetDestPort(), !message->GetGsm(), false, message->GetOriginatingAddress(),
236             message->GetVisibleOriginatingAddress(), message->GetVisibleMessageBody());
237     } else {
238         std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
239         if (smsConcat == nullptr) {
240             TELEPHONY_LOGE("Concat is null.");
241             return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
242         }
243         indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
244             message->GetDestPort(), !message->GetGsm(), message->GetOriginatingAddress(),
245             message->GetVisibleOriginatingAddress(), smsConcat->msgRef, smsConcat->seqNum, smsConcat->totalSeg,
246             false, message->GetVisibleMessageBody());
247     }
248     if (indexer == nullptr) {
249         TELEPHONY_LOGE("indexer is null.");
250         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
251     }
252     indexer->SetRawUserData(message->GetRawUserData());
253     indexer->SetRawWapPushUserData(message->GetRawWapPushUserData());
254 
255     TELEPHONY_LOGI("received a gsm sms, the refid is %{public}d, this is %{public}d, a total of %{public}d",
256         indexer->GetMsgRefId(), indexer->GetMsgSeqId(), indexer->GetMsgCount());
257     if (indexer->GetIsText() && message->IsConcatMsg() && IsRepeatedMessagePart(indexer)) {
258         TELEPHONY_LOGE("Ack repeated error.");
259         SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
260             SmsMmsErrorCode::SMS_ERROR_REPEATED_ERROR, "gsm message repeated error");
261         return AckIncomeCause::SMS_ACK_RESULT_OK;
262     }
263     auto destPort = indexer->GetDestPort();
264     if (destPort == INVALID_SMS_PORT) {
265         TELEPHONY_LOGI("[invalid sms port]");
266         return AckIncomeCause::SMS_ACK_RESULT_OK;
267     }
268     if (!AddMsgToDB(indexer)) {
269         return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
270     }
271     CombineMessagePart(indexer);
272     return AckIncomeCause::SMS_ACK_RESULT_OK;
273 }
274 
ReplySmsToSmsc(int result)275 bool GsmSmsReceiveHandler::ReplySmsToSmsc(int result)
276 {
277     TELEPHONY_LOGI("GsmSmsReceiveHandler::ReplySmsToSmsc ackResult %{public}d", result);
278     auto &satelliteSmsClient = SatelliteSmsClient::GetInstance();
279     if (satelliteSmsClient.IsSatelliteEnabled()) {
280         TELEPHONY_LOGI("send smsack through satellite");
281         satelliteSmsClient.SendSmsAck(
282             slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result);
283         return result == AckIncomeCause::SMS_ACK_RESULT_OK;
284     }
285     CoreManagerInner::GetInstance().SendSmsAck(
286         slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result, shared_from_this());
287     return result == AckIncomeCause::SMS_ACK_RESULT_OK;
288 }
289 
TransformMessageInfo(const shared_ptr<SmsMessageInfo> info)290 shared_ptr<SmsBaseMessage> GsmSmsReceiveHandler::TransformMessageInfo(const shared_ptr<SmsMessageInfo> info)
291 {
292     std::shared_ptr<SmsBaseMessage> baseMessage = nullptr;
293     if (info == nullptr) {
294         TELEPHONY_LOGE("MessageInfo is null.");
295         return baseMessage;
296     }
297     std::string pdu = StringUtils::StringToHex(info->pdu);
298     baseMessage = GsmSmsMessage::CreateMessage(pdu);
299     return baseMessage;
300 }
301 } // namespace Telephony
302 } // namespace OHOS
303