1 /*
2 * Copyright (C) 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 "gsm_sms_param_encode.h"
17
18 #include "gsm_pdu_hex_value.h"
19 #include "gsm_sms_common_utils.h"
20 #include "gsm_user_data_pdu.h"
21 #include "securec.h"
22 #include "sms_common_utils.h"
23 #include "telephony_log_wrapper.h"
24 #include "text_coder.h"
25
26 namespace OHOS {
27 namespace Telephony {
28 static constexpr uint8_t MAX_ADD_PARAM_LEN = 12;
29 static constexpr uint8_t MAX_SMSC_LEN = 20;
30 static constexpr uint8_t SLIDE_DATA_STEP = 2;
31 static constexpr uint8_t DIGIT_TEN = 10;
32 static constexpr uint8_t REL_TIME_LEN = 1;
33 static constexpr uint8_t MIN_SMSC_LEN = 2;
34
EncodeAddressPdu(const struct AddressNumber * num,std::string & resultNum)35 bool GsmSmsParamEncode::EncodeAddressPdu(const struct AddressNumber *num, std::string &resultNum)
36 {
37 if (num == nullptr) {
38 TELEPHONY_LOGE("nullptr error!");
39 return false;
40 }
41 const char *temp = static_cast<const char *>(num->address);
42 size_t tempLen = strlen(temp);
43 if (tempLen > MAX_SMSC_LEN) {
44 TELEPHONY_LOGE("temp over size!");
45 return false;
46 }
47 unsigned char ton = 0;
48 if (temp[0] == '+') {
49 resultNum.push_back(tempLen - 1);
50 temp++;
51 tempLen--;
52 ton = TYPE_INTERNATIONAL;
53 } else {
54 resultNum.push_back(tempLen);
55 ton = num->ton;
56 }
57
58 /* Set TON, NPI */
59 resultNum.push_back(HEX_VALUE_80 + (ton << HEX_VALUE_04) + num->npi);
60 GsmSmsCommonUtils utils;
61 uint8_t length = 0;
62 uint8_t bcd[MAX_ADD_PARAM_LEN] = { 0 };
63 if (!utils.DigitToBcd(temp, tempLen, bcd, MAX_ADD_PARAM_LEN, length)) {
64 TELEPHONY_LOGE("DigitToBcd fail!");
65 return false;
66 }
67 if (resultNum.size() + length > MAX_ADD_PARAM_LEN) {
68 TELEPHONY_LOGE("length over size.");
69 return false;
70 }
71 for (uint8_t index = 0; index < length; index++) {
72 resultNum.push_back(static_cast<char>(bcd[index]));
73 }
74 return true;
75 }
76
EncodeSmscPdu(const char * num,uint8_t * resultNum)77 uint8_t GsmSmsParamEncode::EncodeSmscPdu(const char *num, uint8_t *resultNum)
78 {
79 if (num == nullptr || resultNum == nullptr) {
80 TELEPHONY_LOGE("Address or EncodeAddr is null.");
81 return 0;
82 }
83
84 char newNum[MAX_SMSC_LEN + 1];
85 if (memset_s(newNum, sizeof(newNum), 0x00, sizeof(newNum)) != EOK) {
86 TELEPHONY_LOGE("memset_s error!");
87 return 0;
88 }
89 int32_t ret = 0;
90 if (num[0] == '+') {
91 ret = strncpy_s(newNum, sizeof(newNum), num + 1, MAX_SMSC_LEN);
92 } else {
93 ret = strncpy_s(newNum, sizeof(newNum), num, MAX_SMSC_LEN);
94 }
95 if (ret != EOK) {
96 TELEPHONY_LOGE("EncodeSmscPdu error!");
97 return 0;
98 }
99 /* Set Address */
100 uint8_t encodeLen = 0;
101 GsmSmsCommonUtils utils;
102 if (!utils.DigitToBcd(newNum, strlen(newNum), resultNum, MAX_SMSC_LEN, encodeLen)) {
103 TELEPHONY_LOGE("digit to bcd error!");
104 return 0;
105 }
106 if (encodeLen < 0 || encodeLen >= MAX_SMSC_LEN) {
107 TELEPHONY_LOGE("encodeLen error!");
108 return 0;
109 }
110 resultNum[encodeLen] = '\0';
111 return encodeLen;
112 }
113
EncodeSmscPdu(const struct AddressNumber * num,uint8_t * smscNum,uint8_t smscLen)114 uint8_t GsmSmsParamEncode::EncodeSmscPdu(const struct AddressNumber *num, uint8_t *smscNum, uint8_t smscLen)
115 {
116 if (num == nullptr || smscNum == nullptr) {
117 TELEPHONY_LOGE("nullptr error.");
118 return 0;
119 }
120
121 char newNum[MAX_SMSC_LEN + 1];
122 if (memset_s(newNum, sizeof(newNum), 0x00, sizeof(newNum)) != EOK) {
123 TELEPHONY_LOGE("memset_s error!");
124 return 0;
125 }
126
127 int32_t ret = 0;
128 if (num->address[0] == '+') {
129 ret = memcpy_s(newNum, sizeof(newNum), num->address + 1, strlen(num->address) - 1);
130 } else {
131 ret = memcpy_s(newNum, sizeof(newNum), num->address, strlen(num->address));
132 }
133 if (ret != EOK) {
134 TELEPHONY_LOGE("memory copy error!");
135 return 0;
136 }
137 uint8_t addrLen = strlen(newNum);
138 uint8_t dataSize = 0;
139 if (addrLen % SLIDE_DATA_STEP == 0) {
140 dataSize = SLIDE_DATA_STEP + (addrLen / SLIDE_DATA_STEP);
141 } else {
142 dataSize = SLIDE_DATA_STEP + (addrLen / SLIDE_DATA_STEP) + 1;
143 }
144 if (dataSize > MAX_SMSC_LEN || dataSize >= smscLen || dataSize <= 1 || smscLen <= HEX_VALUE_02) {
145 TELEPHONY_LOGE("DataSize error!");
146 return 0;
147 }
148
149 smscNum[0] = static_cast<char>(dataSize - 1);
150 smscNum[1] = HEX_VALUE_80 + (static_cast<unsigned char>(num->ton << HEX_VALUE_04)) + num->npi;
151 GsmSmsCommonUtils utils;
152 uint8_t len = 0;
153 if (smscLen > MIN_SMSC_LEN &&
154 !utils.DigitToBcd(newNum, addrLen, &(smscNum[MIN_SMSC_LEN]), smscLen - MIN_SMSC_LEN, len)) {
155 TELEPHONY_LOGE("digit to bcd error!");
156 return 0;
157 }
158 smscNum[dataSize] = '\0';
159 return dataSize;
160 }
161
EncodeDCS(const struct SmsDcs * dcsData,std::string & returnValue)162 void GsmSmsParamEncode::EncodeDCS(const struct SmsDcs *dcsData, std::string &returnValue)
163 {
164 if (dcsData == nullptr) {
165 TELEPHONY_LOGE("dcsData is null.");
166 return;
167 }
168 switch (dcsData->codingGroup) {
169 case CODING_DELETION_GROUP:
170 case CODING_DISCARD_GROUP:
171 case CODING_STORE_GROUP:
172 /* not supported */
173 break;
174 case CODING_GENERAL_GROUP:
175 if (dcsData->msgClass != SMS_CLASS_UNKNOWN) {
176 returnValue.push_back(HEX_VALUE_10 + dcsData->msgClass);
177 }
178 if (dcsData->bCompressed) {
179 char value = returnValue.front();
180 returnValue.pop_back();
181 returnValue.push_back(value | HEX_VALUE_20);
182 }
183 break;
184 case SMS_CLASS_GROUP:
185 returnValue.push_back(HEX_VALUE_F0 + dcsData->msgClass);
186 break;
187 default:
188 return;
189 }
190
191 char value = returnValue.front();
192 returnValue.pop_back();
193 switch (dcsData->codingScheme) {
194 case DATA_CODING_7BIT:
195 break;
196 case DATA_CODING_UCS2:
197 returnValue.push_back(value | HEX_VALUE_08);
198 break;
199 case DATA_CODING_8BIT:
200 returnValue.push_back(value | HEX_VALUE_04);
201 break;
202 default:
203 break;
204 }
205 }
206
EncodeTimePdu(const struct SmsTimeStamp * timeStamp,std::string & resultValue)207 void GsmSmsParamEncode::EncodeTimePdu(const struct SmsTimeStamp *timeStamp, std::string &resultValue)
208 {
209 if (timeStamp == nullptr) {
210 TELEPHONY_LOGE("TimeStamp is null.");
211 return;
212 }
213 if (timeStamp->format == SMS_TIME_ABSOLUTE) {
214 int32_t timeZone = timeStamp->time.absolute.timeZone;
215 resultValue.push_back(((timeStamp->time.absolute.year % DIGIT_TEN) << HEX_VALUE_04) +
216 (timeStamp->time.absolute.year / DIGIT_TEN));
217 resultValue.push_back(((timeStamp->time.absolute.month % DIGIT_TEN) << HEX_VALUE_04) +
218 (timeStamp->time.absolute.month / DIGIT_TEN));
219 resultValue.push_back(
220 ((timeStamp->time.absolute.day % DIGIT_TEN) << HEX_VALUE_04) + (timeStamp->time.absolute.day / DIGIT_TEN));
221 resultValue.push_back(((timeStamp->time.absolute.hour % DIGIT_TEN) << HEX_VALUE_04) +
222 (timeStamp->time.absolute.hour / DIGIT_TEN));
223 resultValue.push_back(((timeStamp->time.absolute.minute % DIGIT_TEN) << HEX_VALUE_04) +
224 (timeStamp->time.absolute.minute / DIGIT_TEN));
225 resultValue.push_back(((timeStamp->time.absolute.second % DIGIT_TEN) << HEX_VALUE_04) +
226 (timeStamp->time.absolute.second / DIGIT_TEN));
227
228 if (timeZone < 0) {
229 resultValue.push_back(HEX_VALUE_08);
230 }
231 char value = (static_cast<uint8_t>(timeStamp->time.absolute.timeZone % DIGIT_TEN) << HEX_VALUE_04) +
232 (timeStamp->time.absolute.timeZone / DIGIT_TEN) + resultValue.front();
233 resultValue.pop_back();
234 resultValue.push_back(value);
235 return;
236 } else if (timeStamp->format == SMS_TIME_RELATIVE) {
237 std::string tempStr(REL_TIME_LEN + 1, '\0');
238 int ret = memcpy_s(tempStr.data(), REL_TIME_LEN + 1, &(timeStamp->time.relative.time), REL_TIME_LEN);
239 if (ret != EOK) {
240 TELEPHONY_LOGE("memcpy_s error!");
241 }
242 resultValue = tempStr;
243 }
244 }
245 } // namespace Telephony
246 } // namespace OHOS
247