1 /*
2  * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "sms_send_manager.h"
17 
18 #include <functional>
19 #include <memory.h>
20 
21 #include "cdma_sms_message.h"
22 #include "gsm_sms_message.h"
23 #include "gsm_sms_tpdu_codec.h"
24 #include "i_sms_service_interface.h"
25 #include "sms_hisysevent.h"
26 #include "sms_receive_manager.h"
27 #include "telephony_errors.h"
28 #include "telephony_log_wrapper.h"
29 
30 namespace OHOS {
31 namespace Telephony {
32 static constexpr const char *NET_TYPE_GSM_STRING = "3gpp";
33 static constexpr const char *NET_TYPE_CDMA_STRING = "3gpp2";
34 static constexpr const char *NET_TYPE_UNKNOWN_STRING = "unknown";
35 
36 using namespace std;
SmsSendManager(int32_t slotId)37 SmsSendManager::SmsSendManager(int32_t slotId) : slotId_(slotId) {}
38 
~SmsSendManager()39 SmsSendManager::~SmsSendManager()
40 {
41     if (gsmSmsSender_ != nullptr && networkManager_ != nullptr) {
42         if (auto id = gsmSmsSender_->GetNetworkId(); id.has_value()) {
43             networkManager_->NetworkUnregister(id.value());
44         }
45     }
46     if (cdmaSmsSender_ != nullptr && networkManager_ != nullptr) {
47         if (auto id = cdmaSmsSender_->GetNetworkId(); id.has_value()) {
48             networkManager_->NetworkUnregister(id.value());
49         }
50     }
51     if (networkManager_ != nullptr) {
52         networkManager_->UnRegisterHandler();
53     }
54 }
55 
Init()56 void SmsSendManager::Init()
57 {
58     gsmSmsSender_ =
59         std::make_shared<GsmSmsSender>(slotId_, bind(&SmsSendManager::RetriedSmsDelivery, this, placeholders::_1));
60     if (gsmSmsSender_ == nullptr) {
61         TELEPHONY_LOGE("failed to create GsmSmsSender");
62         return;
63     }
64     gsmSmsSender_->Init();
65 
66     cdmaSmsSender_ =
67         std::make_shared<CdmaSmsSender>(slotId_, bind(&SmsSendManager::RetriedSmsDelivery, this, placeholders::_1));
68     if (cdmaSmsSender_ == nullptr) {
69         TELEPHONY_LOGE("failed to create CdmaSmsSender");
70         return;
71     }
72     cdmaSmsSender_->Init();
73     InitNetworkHandle();
74 }
75 
InitNetworkHandle()76 void SmsSendManager::InitNetworkHandle()
77 {
78     networkManager_ = std::make_shared<SmsNetworkPolicyManager>(slotId_);
79     if (networkManager_ == nullptr) {
80         TELEPHONY_LOGE("failed to create networkManager");
81         return;
82     }
83     networkManager_->Init();
84     if (auto ret = networkManager_->NetworkRegister([this](bool isImsNetDomain, int32_t voiceServiceState) {
85         this->gsmSmsSender_->SetNetworkState(isImsNetDomain, voiceServiceState);
86     });
87         ret.has_value()) {
88         gsmSmsSender_->SetNetworkId(ret);
89     } else {
90         TELEPHONY_LOGE("gsm failed to register networkManager");
91     }
92     if (auto ret = networkManager_->NetworkRegister([this](bool isImsNetDomain, int32_t voiceServiceState) {
93         this->cdmaSmsSender_->SetNetworkState(isImsNetDomain, voiceServiceState);
94     });
95         ret.has_value()) {
96         cdmaSmsSender_->SetNetworkId(ret);
97     } else {
98         TELEPHONY_LOGE("cdma failed to register networkManager");
99     }
100 }
101 
TextBasedSmsDelivery(const string & desAddr,const string & scAddr,const string & text,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)102 void SmsSendManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,
103     const sptr<ISendShortMessageCallback> &sendCallback,
104     const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
105 {
106     if (desAddr.empty() || text.empty()) {
107         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
108         TELEPHONY_LOGE("TextBasedSmsDelivery::param Set Error.");
109         return;
110     }
111     if (networkManager_ == nullptr) {
112         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
113         TELEPHONY_LOGE("TextBasedSmsDelivery::networkManager nullptr error.");
114         return;
115     }
116     if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr) {
117         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
118         TELEPHONY_LOGE("gsmSmsSender or cdmaSmsSender nullptr error.");
119         return;
120     }
121 
122     NetWorkType netWorkType = networkManager_->GetNetWorkType();
123     TELEPHONY_LOGI("netWorkType = %{public}d.", netWorkType);
124     if (netWorkType == NetWorkType::NET_TYPE_GSM) {
125         gsmSmsSender_->RegisterImsHandler();
126         gsmSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
127     } else if (netWorkType == NetWorkType::NET_TYPE_CDMA) {
128         cdmaSmsSender_->RegisterImsHandler();
129         cdmaSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
130     } else {
131         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
132         SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
133             SmsMmsErrorCode::SMS_ERROR_UNKNOWN_NETWORK_TYPE, "text sms network unknown send error");
134         TELEPHONY_LOGI("network unknown send error.");
135     }
136 }
137 
DataBasedSmsDelivery(const string & desAddr,const string & scAddr,uint16_t port,const uint8_t * data,uint16_t dataLen,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)138 void SmsSendManager::DataBasedSmsDelivery(const string &desAddr, const string &scAddr, uint16_t port,
139     const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
140     const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
141 {
142     if (desAddr.empty() || data == nullptr) {
143         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
144         TELEPHONY_LOGE("DataBasedSmsDelivery::param Set Error.");
145         return;
146     }
147     if (networkManager_ == nullptr) {
148         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
149         TELEPHONY_LOGE("DataBasedSmsDelivery::networkManager nullptr error.");
150         return;
151     }
152     if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr) {
153         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
154         TELEPHONY_LOGE("gsmSmsSender or cdmaSmsSender nullptr error.");
155         return;
156     }
157 
158     NetWorkType netWorkType = networkManager_->GetNetWorkType();
159     if (netWorkType == NetWorkType::NET_TYPE_GSM) {
160         gsmSmsSender_->RegisterImsHandler();
161         gsmSmsSender_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
162     } else if (netWorkType == NetWorkType::NET_TYPE_CDMA) {
163         cdmaSmsSender_->RegisterImsHandler();
164         cdmaSmsSender_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
165     } else {
166         SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
167         SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
168             SmsMmsErrorCode::SMS_ERROR_UNKNOWN_NETWORK_TYPE, "data sms network unknown send error");
169         TELEPHONY_LOGI("network unknown send error.");
170     }
171 }
172 
RetriedSmsDelivery(const shared_ptr<SmsSendIndexer> smsIndexer)173 void SmsSendManager::RetriedSmsDelivery(const shared_ptr<SmsSendIndexer> smsIndexer)
174 {
175     if (smsIndexer == nullptr) {
176         TELEPHONY_LOGI("RetriedSmsDelivery::smsIndexer is nullptr error.");
177         return;
178     }
179     if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
180         TELEPHONY_LOGE("Sender or network nullptr error.");
181         return;
182     }
183 
184     NetWorkType oldNetWorkType = smsIndexer->GetNetWorkType();
185     NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
186     if (oldNetWorkType != newNetWorkType) {
187         smsIndexer->SetNetWorkType(newNetWorkType);
188         shared_ptr<SmsSendIndexer> indexer = smsIndexer;
189         switch (newNetWorkType) {
190             case NetWorkType::NET_TYPE_CDMA:
191                 if (smsIndexer->GetIsText()) {
192                     cdmaSmsSender_->ResendTextDelivery(indexer);
193                 } else {
194                     cdmaSmsSender_->ResendDataDelivery(indexer);
195                 }
196                 break;
197             case NetWorkType::NET_TYPE_GSM:
198                 if (smsIndexer->GetIsText()) {
199                     gsmSmsSender_->ResendTextDelivery(indexer);
200                 } else {
201                     gsmSmsSender_->ResendDataDelivery(indexer);
202                 }
203                 break;
204             default:
205                 SmsSender::SendResultCallBack(
206                     smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
207                 TELEPHONY_LOGI("network unknown send error.");
208                 break;
209         }
210         return;
211     }
212 
213     if (newNetWorkType == NetWorkType::NET_TYPE_GSM) {
214         gsmSmsSender_->SendSmsToRil(smsIndexer);
215     } else if (newNetWorkType == NetWorkType::NET_TYPE_CDMA) {
216         cdmaSmsSender_->SendSmsToRil(smsIndexer);
217     } else {
218         SmsSender::SendResultCallBack(smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
219         TELEPHONY_LOGI("Network Unknown.");
220     }
221 }
222 
SplitMessage(const std::string & message,std::vector<std::u16string> & splitMessage)223 int32_t SmsSendManager::SplitMessage(const std::string &message, std::vector<std::u16string> &splitMessage)
224 {
225     if (networkManager_ == nullptr) {
226         TELEPHONY_LOGE("SmsSendManager::SplitMessage networkManager nullptr Error.");
227         return TELEPHONY_ERR_LOCAL_PTR_NULL;
228     }
229 
230     DataCodingScheme codingType;
231     std::vector<struct SplitInfo> cellsInfos;
232     NetWorkType netWorkType = networkManager_->GetNetWorkType();
233     std::string addr;
234     switch (netWorkType) {
235         case NetWorkType::NET_TYPE_CDMA: {
236             GsmSmsMessage gsmSmsMessage;
237             gsmSmsMessage.SetSmsCodingNationalType(SmsSender::GetSmsCodingNationalType(slotId_));
238             gsmSmsMessage.SplitMessage(cellsInfos, message, false, codingType, false, addr);
239             break;
240         }
241         case NetWorkType::NET_TYPE_GSM: {
242             CdmaSmsMessage cdmaSmsMessage;
243             cdmaSmsMessage.SplitMessage(cellsInfos, message, false, codingType, false, addr);
244             break;
245         }
246         default:
247             TELEPHONY_LOGE("netWorkType is NET_TYPE_UNKNOWN");
248             break;
249     }
250 
251     for (auto &item : cellsInfos) {
252         splitMessage.emplace_back(StringUtils::ToUtf16(item.text));
253     }
254     return TELEPHONY_ERR_SUCCESS;
255 }
256 
GetSmsSegmentsInfo(const std::string & message,bool force7BitCode,LengthInfo & lenInfo)257 int32_t SmsSendManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &lenInfo)
258 {
259     if (networkManager_ == nullptr) {
260         TELEPHONY_LOGE("GetSmsSegmentsInfo networkManager_ Nullptr Error.");
261         return TELEPHONY_ERR_LOCAL_PTR_NULL;
262     }
263     NetWorkType netWorkType = networkManager_->GetNetWorkType();
264     switch (netWorkType) {
265         case NetWorkType::NET_TYPE_CDMA: {
266             CdmaSmsMessage cdmaSmsMessage;
267             return cdmaSmsMessage.GetSmsSegmentsInfo(message, force7BitCode, lenInfo);
268         }
269         case NetWorkType::NET_TYPE_GSM: {
270             GsmSmsMessage gsmSmsMessage;
271             return gsmSmsMessage.GetSmsSegmentsInfo(message, force7BitCode, lenInfo);
272         }
273         default:
274             TELEPHONY_LOGE("netWorkType is NET_TYPE_UNKNOWN");
275             break;
276     }
277     return TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE;
278 }
279 
GetCdmaSmsSender() const280 std::shared_ptr<SmsSender> SmsSendManager::GetCdmaSmsSender() const
281 {
282     return cdmaSmsSender_;
283 }
284 
IsImsSmsSupported(int32_t slotId,bool & isSupported)285 int32_t SmsSendManager::IsImsSmsSupported(int32_t slotId, bool &isSupported)
286 {
287     if (networkManager_ == nullptr) {
288         TELEPHONY_LOGE("networkManager is nullptr error.");
289         return TELEPHONY_ERR_LOCAL_PTR_NULL;
290     }
291 
292     if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
293         TELEPHONY_LOGE("Sender or network nullptr error.");
294         return TELEPHONY_ERR_LOCAL_PTR_NULL;
295     }
296 
297     NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
298     switch (newNetWorkType) {
299         case NetWorkType::NET_TYPE_GSM:
300             return gsmSmsSender_->IsImsSmsSupported(slotId, isSupported);
301         case NetWorkType::NET_TYPE_CDMA:
302             return cdmaSmsSender_->IsImsSmsSupported(slotId, isSupported);
303         default:
304             TELEPHONY_LOGE("network unknown send error.");
305             return TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE;
306     }
307 }
308 
SetImsSmsConfig(int32_t slotId,int32_t enable)309 bool SmsSendManager::SetImsSmsConfig(int32_t slotId, int32_t enable)
310 {
311     bool result = false;
312     if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
313         TELEPHONY_LOGE("Sender or network nullptr error.");
314         return result;
315     }
316     NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
317 
318     switch (newNetWorkType) {
319         case NetWorkType::NET_TYPE_GSM:
320             result = gsmSmsSender_->SetImsSmsConfig(slotId, enable);
321             break;
322         case NetWorkType::NET_TYPE_CDMA:
323             result = cdmaSmsSender_->SetImsSmsConfig(slotId, enable);
324             break;
325         default:
326             TELEPHONY_LOGE("network unknown send error.");
327             break;
328     }
329     return result;
330 }
331 
GetImsShortMessageFormat(std::u16string & format)332 int32_t SmsSendManager::GetImsShortMessageFormat(std::u16string &format)
333 {
334     format = StringUtils::ToUtf16(NET_TYPE_UNKNOWN_STRING);
335     if (networkManager_ == nullptr) {
336         TELEPHONY_LOGE("networkManager is nullptr error.");
337         return TELEPHONY_ERR_LOCAL_PTR_NULL;
338     }
339     switch (networkManager_->GetNetWorkType()) {
340         case NetWorkType::NET_TYPE_GSM:
341             format = StringUtils::ToUtf16(NET_TYPE_GSM_STRING);
342             break;
343         case NetWorkType::NET_TYPE_CDMA:
344             format = StringUtils::ToUtf16(NET_TYPE_CDMA_STRING);
345             break;
346         default:
347             break;
348     }
349     return TELEPHONY_ERR_SUCCESS;
350 }
351 
OnRilAdapterHostDied()352 void SmsSendManager::OnRilAdapterHostDied()
353 {
354     if (gsmSmsSender_ != nullptr) {
355         gsmSmsSender_->OnRilAdapterHostDied();
356     }
357     if (cdmaSmsSender_ != nullptr) {
358         cdmaSmsSender_->OnRilAdapterHostDied();
359     }
360 }
361 } // namespace Telephony
362 } // namespace OHOS
363