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 "mms_header.h"
17 
18 #include <chrono>
19 #include <cinttypes>
20 #include <iostream>
21 #include <utility>
22 #include <random>
23 
24 #include "telephony_log_wrapper.h"
25 #include "mms_charset.h"
26 
27 namespace OHOS {
28 namespace Telephony {
29 using namespace std;
MmsHeader()30 MmsHeader::MmsHeader()
31 {
32     InitOctetHandleFun();
33     InitLongHandleFun();
34     InitStringHandleFun();
35     InitTextStringHandleFun();
36 }
37 
InitOctetHandleFun()38 void MmsHeader::InitOctetHandleFun()
39 {
40     auto func = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
41         return DecodeFieldOctetValue(fieldId, buff, len);
42     };
43     memberFuncMap_[MMS_DELIVERY_REPORT] = func; // MmsBoolType
44     memberFuncMap_[MMS_READ_REPORT] = func;
45     memberFuncMap_[MMS_REPORT_ALLOWED] = func;
46     memberFuncMap_[MMS_STORE] = func;
47     memberFuncMap_[MMS_STORED] = func;
48     memberFuncMap_[MMS_TOTALS] = func;
49     memberFuncMap_[MMS_QUOTAS] = func;
50     memberFuncMap_[MMS_DISTRIBUTION_INDICATOR] = func;
51     memberFuncMap_[MMS_ADAPTATION_ALLOWED] = func;
52     memberFuncMap_[MMS_MESSAGE_CLASS] = func;
53     memberFuncMap_[MMS_PRIORITY] = func; // MmsPriority
54     memberFuncMap_[MMS_RESPONSE_STATUS] = func; // MmsResponseStatus
55     memberFuncMap_[MMS_SENDER_VISIBILITY] = func; // MmsSenderVisibilityType
56     memberFuncMap_[MMS_STATUS] = func; // MmsStatus
57     memberFuncMap_[MMS_RETRIEVE_STATUS] = func; // MmsRetrieveStatus
58     memberFuncMap_[MMS_READ_STATUS] = func; // MmsReadStatus
59     memberFuncMap_[MMS_REPLY_CHARGING] = func; // MmsReplyCharging
60     memberFuncMap_[MMS_MM_STATE] = func; // MmsMmState
61     memberFuncMap_[MMS_MM_FLAGS] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
62         return DecodeFieldMMFlag(fieldId, buff, len);
63     }; // MmsMmFlags
64     memberFuncMap_[MMS_STORE_STATUS] = func; // MmsStoreStatus
65     memberFuncMap_[MMS_MBOX_TOTALS] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
66         return DecodeFieldMBox(fieldId, buff, len);
67     }; // MmsMboxTotals
68     memberFuncMap_[MMS_MBOX_QUOTAS] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
69         return DecodeFieldMBox(fieldId, buff, len);
70     }; // MmsMboxQuotas
71     memberFuncMap_[MMS_RECOMMENDED_RETRIEVAL_MODE] = func; // MmsRecommendedRetrievalMode
72     memberFuncMap_[MMS_CONTENT_CLASS] = func; // MmsContentClass
73     memberFuncMap_[MMS_CANCEL_STATUS] = func; // MmsCancelStatus
74     memberFuncMap_[MMS_MESSAGE_TYPE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
75         return DecodeMmsMsgType(fieldId, buff, len);
76     };
77     memberFuncMap_[MMS_ATTRIBUTES] = func;
78     memberFuncMap_[MMS_DRM_CONTENT] = func;
79 }
80 
InitLongHandleFun()81 void MmsHeader::InitLongHandleFun()
82 {
83     memberFuncMap_[MMS_CONTENT_TYPE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
84         return DecodeMmsContentType(fieldId, buff, len);
85     };
86     memberFuncMap_[MMS_ELEMENT_DESCRIPTOR] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
87         return DecodeMmsContentType(fieldId, buff, len);
88     };
89     memberFuncMap_[MMS_DATE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
90         return DecodeFieldLongValue(fieldId, buff, len);
91     };
92     memberFuncMap_[MMS_REPLY_CHARGING_SIZE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
93         return DecodeFieldLongValue(fieldId, buff, len);
94     };
95     memberFuncMap_[MMS_MESSAGE_SIZE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
96         return DecodeFieldLongValue(fieldId, buff, len);
97     };
98 
99     memberFuncMap_[MMS_MESSAGE_COUNT] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
100         return DecodeFieldIntegerValue(fieldId, buff, len);
101     };
102     memberFuncMap_[MMS_START] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
103         return DecodeFieldIntegerValue(fieldId, buff, len);
104     };
105     memberFuncMap_[MMS_LIMIT] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
106         return DecodeFieldIntegerValue(fieldId, buff, len);
107     };
108     memberFuncMap_[MMS_MMS_VERSION] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
109         return DecodeFieldIntegerValue(fieldId, buff, len);
110     };
111 
112     memberFuncMap_[MMS_DELIVERY_TIME] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
113         return DecodeFieldDate(fieldId, buff, len);
114     };
115     memberFuncMap_[MMS_EXPIRY] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
116         return DecodeFieldDate(fieldId, buff, len);
117     };
118     memberFuncMap_[MMS_REPLY_CHARGING_DEADLINE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
119         return DecodeFieldDate(fieldId, buff, len);
120     }; // MmsReplyChargingDeadline
121     memberFuncMap_[MMS_PREVIOUSLY_SENT_DATE] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
122         return DecodeFieldPreviouslySentDate(fieldId, buff, len);
123     };
124 }
125 
InitStringHandleFun()126 void MmsHeader::InitStringHandleFun()
127 {
128     auto func = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
129         return DecodeFieldEncodedStringValue(fieldId, buff, len);
130     };
131     memberFuncMap_[MMS_RESPONSE_TEXT] = func;
132     memberFuncMap_[MMS_SUBJECT] = func;
133     memberFuncMap_[MMS_RETRIEVE_TEXT] = func;
134     memberFuncMap_[MMS_PREVIOUSLY_SENT_BY] = func;
135 
136     memberFuncMap_[MMS_STORE_STATUS_TEXT] = func;
137     memberFuncMap_[MMS_RECOMMENDED_RETRIEVAL_MODE_TEXT] = func;
138     memberFuncMap_[MMS_STATUS_TEXT] = func;
139 
140     memberFuncMap_[MMS_BCC] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
141         return DecodeFieldAddressModelValue(fieldId, buff, len);
142     };
143     memberFuncMap_[MMS_CC] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
144         return DecodeFieldAddressModelValue(fieldId, buff, len);
145     };
146     memberFuncMap_[MMS_TO] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
147         return DecodeFieldAddressModelValue(fieldId, buff, len);
148     };
149 
150     memberFuncMap_[MMS_FROM] = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
151         return DecodeFromValue(fieldId, buff, len);
152     };
153 }
154 
InitTextStringHandleFun()155 void MmsHeader::InitTextStringHandleFun()
156 {
157     auto func = [this](uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len) {
158         return DecodeFieldTextStringValue(fieldId, buff, len);
159     };
160     memberFuncMap_[MMS_CONTENT_LOCATION] = func;
161     memberFuncMap_[MMS_TRANSACTION_ID] = func;
162     memberFuncMap_[MMS_MESSAGE_ID] = func;
163     memberFuncMap_[MMS_REPLACE_ID] = func;
164     memberFuncMap_[MMS_CANCEL_ID] = func;
165     memberFuncMap_[MMS_APPLIC_ID] = func;
166     memberFuncMap_[MMS_REPLY_APPLIC_ID] = func;
167     memberFuncMap_[MMS_REPLY_CHARGING_ID] = func;
168     memberFuncMap_[MMS_AUX_APPLIC_INFO] = func;
169 }
170 
DumpMmsHeader()171 void MmsHeader::DumpMmsHeader()
172 {
173     bool find = false;
174     std::string fieldName;
175     for (auto it = octetValueMap_.begin(); it != octetValueMap_.end(); it++) {
176         find = FindHeaderFieldName(it->first, fieldName);
177         TELEPHONY_LOGI("%{private}s : 0x%{private}02X", find ? fieldName.c_str() : "unkown field", it->second);
178     }
179 
180     for (auto it = longValueMap_.begin(); it != longValueMap_.end(); it++) {
181         find = FindHeaderFieldName(it->first, fieldName);
182         TELEPHONY_LOGI("%{private}s : %{private}" PRId64 "", find ? fieldName.c_str() : "unkown field", it->second);
183     }
184 
185     for (auto it = textValueMap_.begin(); it != textValueMap_.end(); it++) {
186         find = FindHeaderFieldName(it->first, fieldName);
187         TELEPHONY_LOGI("%{private}s : %{private}s", find ? fieldName.c_str() : "unkown field", it->second.c_str());
188     }
189 
190     for (auto it = encodeStringsMap_.begin(); it != encodeStringsMap_.end(); it++) {
191         find = FindHeaderFieldName(it->first, fieldName);
192         std::string enString;
193         if (find) {
194             it->second.GetEncodeString(enString);
195         }
196         TELEPHONY_LOGI("%{private}s : %{private}s", find ? fieldName.c_str() : "unkown field", enString.c_str());
197     }
198 
199     for (auto it = addressMap_.begin(); it != addressMap_.end(); it++) {
200         find = FindHeaderFieldName(it->first, fieldName);
201         std::vector<MmsAddress> address = it->second;
202         for (auto itAddress : address) {
203             std::string enString = itAddress.GetAddressString();
204             TELEPHONY_LOGI("%{private}s : %{private}s", find ? fieldName.c_str() : "unkown field", enString.c_str());
205         }
206     }
207 }
208 
DecodeMmsHeader(MmsDecodeBuffer & decodeBuffer)209 bool MmsHeader::DecodeMmsHeader(MmsDecodeBuffer &decodeBuffer)
210 {
211     const uint8_t setHighestBitOne = 0x80;
212     uint8_t fieldCode = 0xff;
213     uint8_t oneByte = 0;
214     int32_t len = 0;
215     while (decodeBuffer.GetOneByte(oneByte)) {
216         fieldCode = (oneByte | setHighestBitOne);
217         auto decodeFunc = memberFuncMap_.find(fieldCode);
218         if (decodeFunc != memberFuncMap_.end()) {
219             auto fun = decodeFunc->second;
220             if (fun != nullptr && !fun(fieldCode, decodeBuffer, len)) {
221                 TELEPHONY_LOGE("The fieldId[%{public}d] decode header fail.", fieldCode);
222                 return false;
223             }
224             if (fieldCode == MMS_CONTENT_TYPE) {
225                 break;
226             }
227         } else {
228             TELEPHONY_LOGI("DecodeMmsMsgUnKnownField:%{public}02X", fieldCode);
229             decodeBuffer.GetPdu();
230             DecodeMmsMsgUnKnownField(decodeBuffer);
231         }
232     }
233     return true;
234 }
235 
EncodeMmsHeader(MmsEncodeBuffer & encodeBuffer)236 bool MmsHeader::EncodeMmsHeader(MmsEncodeBuffer &encodeBuffer)
237 {
238     uint8_t messageType = 0;
239     const uint8_t defTranScactionIdLen = 24;
240     const int64_t defVersion = static_cast<int64_t>(MmsVersionType::MMS_VERSION_1_3);
241     if (!GetOctetValue(MMS_MESSAGE_TYPE, messageType)) {
242         TELEPHONY_LOGE("Not Set Mms Message Type Error.");
243         return false;
244     }
245 
246     std::string transactionId = "";
247     if (!GetStringValue(MMS_TRANSACTION_ID, transactionId) && IsHaveTransactionId(messageType)) {
248         SetTextValue(MMS_TRANSACTION_ID, MakeTransactionId(defTranScactionIdLen));
249     }
250 
251     int64_t mmsVersion = 0;
252     if (!GetLongValue(MMS_MMS_VERSION, mmsVersion)) {
253         mmsVersion = defVersion;
254         SetLongValue(MMS_MMS_VERSION, mmsVersion);
255     }
256     if (mmsVersion < static_cast<int64_t>(MmsVersionType::MMS_VERSION_1_0) ||
257         mmsVersion > static_cast<int64_t>(MmsVersionType::MMS_VERSION_1_3)) {
258         SetLongValue(MMS_MMS_VERSION, defVersion);
259     }
260 
261     if (!EncodeCommontFieldValue(encodeBuffer)) {
262         TELEPHONY_LOGE("Encode Commont Header Field Err.");
263         return false;
264     }
265     switch (messageType) {
266         case MMS_MSGTYPE_SEND_REQ:
267             return EncodeMmsSendReq(encodeBuffer);
268         case MMS_MSGTYPE_SEND_CONF:
269             return EncodeMmsSendConf(encodeBuffer);
270         case MMS_MSGTYPE_NOTIFICATION_IND:
271             return EncodeMmsNotificationInd(encodeBuffer);
272         case MMS_MSGTYPE_NOTIFYRESP_IND:
273             return EnocdeMmsNotifyRespInd(encodeBuffer);
274         case MMS_MSGTYPE_RETRIEVE_CONF:
275             return EnocdeMmsRetrieveConf(encodeBuffer);
276         case MMS_MSGTYPE_ACKNOWLEDGE_IND:
277             return EnocdeMmsAcknowledgeInd(encodeBuffer);
278         case MMS_MSGTYPE_DELIVERY_IND:
279             return EnocdeMmsDeliveryInd(encodeBuffer);
280         case MMS_MSGTYPE_READ_REC_IND:
281             return EncodeMmsReadRecInd(encodeBuffer);
282         case MMS_MSGTYPE_READ_ORIG_IND:
283             return EncodeMmsReadOrigInd(encodeBuffer);
284         default:
285             TELEPHONY_LOGE("Mms Message Type unSupported Err.");
286             return false;
287     }
288 }
289 
GetOctetValue(uint8_t fieldId,uint8_t & value) const290 bool MmsHeader::GetOctetValue(uint8_t fieldId, uint8_t &value) const
291 {
292     value = 0;
293     auto it = octetValueMap_.find(fieldId);
294     if (it != octetValueMap_.end()) {
295         value = it->second;
296         return true;
297     }
298     return false;
299 }
300 
SetOctetValue(uint8_t fieldId,uint8_t value)301 bool MmsHeader::SetOctetValue(uint8_t fieldId, uint8_t value)
302 {
303     if (mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_OCTET_TYPE) {
304         TELEPHONY_LOGE("The fieldId[%{public}02X] is not belong to octet.", fieldId);
305         return false;
306     }
307     if (CheckBooleanValue(fieldId, value)) {
308         return true;
309     }
310     bool match = false;
311     if (!SetOctetValuePartData(fieldId, value, match)) {
312         TELEPHONY_LOGE("The fieldId[%{public}02X] value invalid.", fieldId);
313         return false;
314     }
315 
316     switch (fieldId) {
317         case MMS_CONTENT_CLASS:
318             if (value < static_cast<uint8_t>(MmsContentClass::MMS_TEXT) ||
319                 value > static_cast<uint8_t>(MmsContentClass::MMS_CONTENT_RICH)) {
320                 TELEPHONY_LOGE("The MMS_CONTENT_CLASS value invalid.");
321                 return false;
322             }
323             break;
324         case MMS_CANCEL_STATUS:
325             if (value < static_cast<uint8_t>(MmsCancelStatus::MMS_CANCEL_REQUEST_SUCCESSFULLY_RECEIVED) ||
326                 value > static_cast<uint8_t>(MmsCancelStatus::MMS_CANCEL_REQUEST_CORRUPTED)) {
327                 TELEPHONY_LOGE("The MMS_CANCEL_STATUS value invalid.");
328                 return false;
329             }
330             break;
331         case MMS_MESSAGE_CLASS:
332             if (value < static_cast<uint8_t>(MmsMessageClass::PERSONAL) ||
333                 value > static_cast<uint8_t>(MmsMessageClass::AUTO)) {
334                 TELEPHONY_LOGE("The MMS_MESSAGE_CLASS value invalid.");
335                 return false;
336             }
337             break;
338         default:
339             if (!match) {
340                 TELEPHONY_LOGE("The 111fieldId[%{public}02X] value invalid.", fieldId);
341                 return false;
342             }
343     }
344     auto ret = octetValueMap_.emplace(fieldId, value);
345     return ret.second;
346 }
347 
SetOctetValuePartData(uint8_t fieldId,uint8_t value,bool & match)348 bool MmsHeader::SetOctetValuePartData(uint8_t fieldId, uint8_t value, bool &match)
349 {
350     if (!SetOctetValuePortionData(fieldId, value, match)) {
351         return false;
352     }
353     if (match) {
354         return match;
355     }
356     switch (fieldId) {
357         case MMS_READ_STATUS:
358             if (value < static_cast<uint8_t>(MmsReadStatus::MMS_READ) ||
359                 value > static_cast<uint8_t>(MmsReadStatus::MMS_DELETED_WITHOUT_BEING_READ)) {
360                 TELEPHONY_LOGE("The MMS_READ_STATUS value invalid.");
361                 return false;
362             }
363             break;
364         case MMS_REPLY_CHARGING:
365             if (value < static_cast<uint8_t>(MmsReplyCharging::MMS_REQUESTED) ||
366                 value > static_cast<uint8_t>(MmsReplyCharging::MMS_ACCEPTED_TEXT_ONLY)) {
367                 TELEPHONY_LOGE("The MMS_REPLY_CHARGING value invalid.");
368                 return false;
369             }
370             break;
371         case MMS_MM_STATE:
372             if (value < static_cast<uint8_t>(MmsMmState::MMS_MM_STATE_DRAFT) ||
373                 value > static_cast<uint8_t>(MmsMmState::MMS_MM_STATE_FORWARDED)) {
374                 TELEPHONY_LOGE("The MMS_MM_STATE value invalid.");
375                 return false;
376             }
377             break;
378         case MMS_MM_FLAGS:
379             if (value < static_cast<uint8_t>(MmsMmFlags::MMS_ADD_TOKEN) ||
380                 value > static_cast<uint8_t>(MmsMmFlags::MMS_FILTER_TOKEN)) {
381                 TELEPHONY_LOGE("The MMS_MM_FLAGS value invalid.");
382                 return false;
383             }
384             break;
385         case MMS_STORE_STATUS:
386             if (!CheckStoreStatus(value)) {
387                 TELEPHONY_LOGE("The MMS_STORE_STATUS value invalid.");
388                 return false;
389             }
390             break;
391         default:
392             match = false;
393             return true;
394     }
395     return true;
396 }
397 
SetOctetValuePortionData(uint8_t fieldId,uint8_t value,bool & match)398 bool MmsHeader::SetOctetValuePortionData(uint8_t fieldId, uint8_t value, bool &match)
399 {
400     match = true;
401     switch (fieldId) {
402         case MMS_MESSAGE_TYPE:
403             if (value < static_cast<uint8_t>(MmsMsgType::MMS_MSGTYPE_SEND_REQ) ||
404                 value > static_cast<uint8_t>(MmsMsgType::MMS_MSGTYPE_FORWARD_CONF)) {
405                 TELEPHONY_LOGE("The MMS_MESSAGE_TYPE value invalid.");
406                 return false;
407             }
408             break;
409         case MMS_PRIORITY:
410             if (value < static_cast<uint8_t>(MmsPriority::MMS_LOW) ||
411                 value > static_cast<uint8_t>(MmsPriority::MMS_HIGH)) {
412                 TELEPHONY_LOGE("The MMS_PRIORITY value invalid.");
413                 return false;
414             }
415             break;
416         case MMS_RESPONSE_STATUS:
417             if (!CheckResponseStatus(value)) {
418                 TELEPHONY_LOGE("The MMS_RESPONSE_STATUS value invalid.");
419                 return false;
420             }
421             break;
422         case MMS_SENDER_VISIBILITY:
423             if (value < static_cast<uint8_t>(MmsSenderVisibility::MMS_HIDE) ||
424                 value > static_cast<uint8_t>(MmsSenderVisibility::MMS_SHOW)) {
425                 TELEPHONY_LOGE("The MMS_SENDER_VISIBILITY value invalid.");
426                 return false;
427             }
428             break;
429         case MMS_STATUS:
430             if (value < static_cast<uint8_t>(MmsStatus::MMS_EXPIRED) ||
431                 value > static_cast<uint8_t>(MmsStatus::MMS_UNREACHABLE)) {
432                 TELEPHONY_LOGE("The MMS_STATUS value invalid.");
433                 return false;
434             }
435             break;
436         case MMS_RETRIEVE_STATUS:
437             if (!CheckRetrieveStatus(value)) {
438                 TELEPHONY_LOGE("The MMS_RETRIEVE_STATUS value invalid.");
439                 return false;
440             }
441             break;
442         default:
443             match = false;
444             return true;
445     }
446     return true;
447 }
448 
GetLongValue(uint8_t fieldId,int64_t & value) const449 bool MmsHeader::GetLongValue(uint8_t fieldId, int64_t &value) const
450 {
451     value = 0;
452     auto it = longValueMap_.find(fieldId);
453     if (it != longValueMap_.end()) {
454         value = it->second;
455         return true;
456     }
457     return false;
458 }
459 
SetLongValue(uint8_t fieldId,int64_t value)460 bool MmsHeader::SetLongValue(uint8_t fieldId, int64_t value)
461 {
462     if (mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_INTEGER_TYPE &&
463         mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_LONG_TYPE) {
464         TELEPHONY_LOGE("The fieldId[%{public}02X] value is not belong to LongValue.", fieldId);
465         return false;
466     }
467     auto ret = longValueMap_.emplace(fieldId, value);
468     return ret.second;
469 }
470 
GetTextValue(uint8_t fieldId,std::string & value) const471 bool MmsHeader::GetTextValue(uint8_t fieldId, std::string &value) const
472 {
473     value.clear();
474     auto it = textValueMap_.find(fieldId);
475     if (it != textValueMap_.end()) {
476         value.assign(it->second);
477         return true;
478     }
479     return false;
480 }
481 
SetTextValue(uint8_t fieldId,std::string value)482 bool MmsHeader::SetTextValue(uint8_t fieldId, std::string value)
483 {
484     if (value.empty()) {
485         TELEPHONY_LOGE("fieldId[%{public}d] The Value Is Empty Error.", fieldId);
486         return false;
487     }
488     if (mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_TEXT_TYPE) {
489         TELEPHONY_LOGE("The fieldId[%{public}02X] value is not belong to TextValue.", fieldId);
490         return false;
491     }
492     auto ret = textValueMap_.emplace(fieldId, value);
493     return ret.second;
494 }
495 
GetEncodeStringValue(uint8_t fieldId,MmsEncodeString & value) const496 bool MmsHeader::GetEncodeStringValue(uint8_t fieldId, MmsEncodeString &value) const
497 {
498     auto it = encodeStringsMap_.find(fieldId);
499     if (it != encodeStringsMap_.end()) {
500         value = it->second;
501         return true;
502     }
503     return false;
504 }
505 
SetEncodeStringValue(uint8_t fieldId,uint32_t charset,const std::string & value)506 bool MmsHeader::SetEncodeStringValue(uint8_t fieldId, uint32_t charset, const std::string &value)
507 {
508     if (value.empty()) {
509         TELEPHONY_LOGE("fieldId[%{public}d] The Value Is Empty Error.", fieldId);
510         return false;
511     }
512     if (mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_ENCODE_TEXT_TYPE) {
513         TELEPHONY_LOGE("The fieldId[%{public}02X] value is not belong to EncodeString.", fieldId);
514         return false;
515     }
516     MmsEncodeString encodeString;
517     if (!encodeString.SetEncodeString(charset, value)) {
518         TELEPHONY_LOGE("MmsHeader SetEncodeString fail.");
519         return false;
520     }
521     auto ret = encodeStringsMap_.emplace(fieldId, encodeString);
522     return ret.second;
523 }
524 
AddHeaderAddressValue(uint8_t fieldId,MmsAddress & address)525 bool MmsHeader::AddHeaderAddressValue(uint8_t fieldId, MmsAddress &address)
526 {
527     std::string strAddress = address.GetAddressString();
528     if (strAddress.empty() && fieldId != MMS_FROM) {
529         TELEPHONY_LOGE("Address is empty error.");
530         return false;
531     }
532     if (mmsHaderCateg_.FindFieldDes(fieldId) != MmsFieldValueType::MMS_FIELD_ENCODE_ADDR_TYPE) {
533         TELEPHONY_LOGE("The fieldId[%{public}02X] value is not belong to EncodeString.", fieldId);
534         return false;
535     }
536     auto it = addressMap_.find(fieldId);
537     if (it != addressMap_.end()) {
538         it->second.push_back(address);
539         return true;
540     } else {
541         std::vector<MmsAddress> addressValue;
542         addressValue.push_back(address);
543         auto ret = addressMap_.emplace(fieldId, addressValue);
544         return ret.second;
545     }
546 }
547 
GetHeaderAllAddressValue(uint8_t fieldId,std::vector<MmsAddress> & addressValue)548 bool MmsHeader::GetHeaderAllAddressValue(uint8_t fieldId, std::vector<MmsAddress> &addressValue)
549 {
550     addressValue.clear();
551     auto it = addressMap_.find(fieldId);
552     if (it != addressMap_.end()) {
553         addressValue.assign(it->second.begin(), it->second.end());
554         return true;
555     }
556     return false;
557 }
558 
GetStringValue(uint8_t fieldId,std::string & value) const559 bool MmsHeader::GetStringValue(uint8_t fieldId, std::string &value) const
560 {
561     if (GetTextValue(fieldId, value)) {
562         return true;
563     } else {
564         value.clear();
565         MmsEncodeString eValue;
566         if (!GetEncodeStringValue(fieldId, eValue)) {
567             TELEPHONY_LOGE("The fieldId[%{public}d] GetEncodeStringValue fail.", fieldId);
568             return false;
569         }
570         eValue.GetEncodeString(value);
571     }
572     return true;
573 }
574 
GetHeaderContentType()575 MmsContentType &MmsHeader::GetHeaderContentType()
576 {
577     return mmsContentType_;
578 }
579 
FindHeaderFieldName(const uint8_t fieldId,std::string & fieldName)580 bool MmsHeader::FindHeaderFieldName(const uint8_t fieldId, std::string &fieldName)
581 {
582     for (unsigned int i = 0; i < sizeof(mmsHeaderNames) / sizeof(mmsHeaderNames[0]); i++) {
583         if (fieldId == mmsHeaderNames[i].key) {
584             fieldName.clear();
585             fieldName.append(mmsHeaderNames[i].value);
586             return true;
587         }
588     }
589     return false;
590 }
591 
DecodeMmsMsgType(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)592 bool MmsHeader::DecodeMmsMsgType(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
593 {
594     std::string fieldName;
595     if (!FindHeaderFieldName(fieldId, fieldName)) {
596         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader FindHeaderFieldName fail.", fieldId);
597         return false;
598     }
599 
600     uint8_t oneByte = 0;
601     if (!buff.GetOneByte(oneByte)) {
602         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
603         return false;
604     }
605     if (oneByte < MMS_MSGTYPE_SEND_REQ || oneByte > MMS_MSGTYPE_CANCEL_CONF) {
606         TELEPHONY_LOGE("MmsHeader message type not support.");
607         return false;
608     }
609     octetValueMap_.emplace(fieldId, oneByte);
610     return true;
611 }
612 
613 /**
614  * @brief DecodeFieldAddressModelValue
615  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.21 From Field
616  * From-value = Value-length (Address-present-token Encoded-string-value | Insert-address-token)
617  * Address-present-token = <Octet 128>
618  * Insert-address-token = <Octet 129>
619  * @param fieldId
620  * @param buff
621  * @param len
622  * @return true
623  * @return false
624  */
DecodeFieldAddressModelValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)625 bool MmsHeader::DecodeFieldAddressModelValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
626 {
627     std::string fieldName;
628     if (!FindHeaderFieldName(fieldId, fieldName)) {
629         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader FindHeaderFieldName fail.", fieldId);
630         return false;
631     }
632 
633     MmsEncodeString encodeString;
634     encodeString.DecodeEncodeString(buff);
635 
636     std::string encodeAddress;
637     encodeString.GetEncodeString(encodeAddress);
638     MmsAddress address(encodeAddress);
639 
640     std::vector<MmsAddress> vecAddress;
641     auto it = addressMap_.find(fieldId);
642     if (it != addressMap_.end()) {
643         vecAddress = it->second;
644         it->second.push_back(address);
645     } else {
646         vecAddress.push_back(address);
647         addressMap_.emplace(fieldId, vecAddress);
648     }
649     return true;
650 }
651 
DecodeFieldOctetValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)652 bool MmsHeader::DecodeFieldOctetValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
653 {
654     std::string fieldName;
655     if (!FindHeaderFieldName(fieldId, fieldName)) {
656         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader FindHeaderFieldName fail.", fieldId);
657         return false;
658     }
659     uint8_t oneByte = 0;
660     if (!buff.GetOneByte(oneByte)) {
661         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
662         return false;
663     }
664     octetValueMap_.emplace(fieldId, oneByte);
665     return true;
666 }
667 
DecodeFieldLongValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)668 bool MmsHeader::DecodeFieldLongValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
669 {
670     std::string fieldName;
671     if (!FindHeaderFieldName(fieldId, fieldName)) {
672         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
673         return false;
674     }
675 
676     uint64_t value = 0;
677     if (!buff.DecodeLongInteger(value)) {
678         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeLongInteger fail.", fieldId);
679         return false;
680     }
681     auto ret = longValueMap_.emplace(fieldId, value);
682     return ret.second;
683 }
684 
MakeTransactionId(uint32_t len)685 std::string MmsHeader::MakeTransactionId(uint32_t len)
686 {
687     const uint32_t englishLettersNum = 25;
688     const uint32_t digitalNum = 9;
689     const uint32_t typeNum = 2;
690 
691     std::default_random_engine e;
692     std::string transactionId = "";
693     std::uniform_int_distribution<unsigned> typeNumRandom(0, typeNum);
694     std::uniform_int_distribution<unsigned> digitalNumRandom(0, digitalNum);
695     std::uniform_int_distribution<unsigned> englishLettersNumRandom(0, englishLettersNum);
696     for (uint16_t i = 0; i < len; i++) {
697         switch (typeNumRandom(e)) {
698             case 0:
699                 transactionId += 'A' + (englishLettersNumRandom(e));
700                 break;
701             case 1:
702                 transactionId += '0' + (digitalNumRandom(e));
703                 break;
704             default:
705                 transactionId += 'a' + (englishLettersNumRandom(e));
706         }
707     }
708     return transactionId;
709 }
710 
DecodeFieldTextStringValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)711 bool MmsHeader::DecodeFieldTextStringValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
712 {
713     std::string fieldName;
714     if (!FindHeaderFieldName(fieldId, fieldName)) {
715         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
716         return false;
717     }
718 
719     std::string tempString;
720     uint32_t tempLen = 0;
721     if (!buff.DecodeText(tempString, tempLen)) {
722         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeText fail.", fieldId);
723         return false;
724     }
725 
726     len = (int32_t)tempLen;
727     textValueMap_.emplace(fieldId, tempString);
728     return true;
729 }
730 
DecodeFieldEncodedStringValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)731 bool MmsHeader::DecodeFieldEncodedStringValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
732 {
733     std::string fieldName;
734     if (!FindHeaderFieldName(fieldId, fieldName)) {
735         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
736         return false;
737     }
738 
739     MmsEncodeString encodeString;
740     if (!encodeString.DecodeEncodeString(buff)) {
741         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeEncodeString fail.", fieldId);
742         return false;
743     }
744     encodeStringsMap_.emplace(fieldId, encodeString);
745     return true;
746 }
747 
748 /**
749  * @brief DecodeFromValue
750  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.21 From Field
751  * From-value = Value-length (Address-present-token Encoded-string-value | Insert-address-token)
752  * Address-present-token = <Octet 128>
753  * Insert-address-token = <Octet 129>
754  * @param fieldId
755  * @param buff
756  * @param len
757  * @return true
758  * @return false
759  */
DecodeFromValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)760 bool MmsHeader::DecodeFromValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
761 {
762     // Value-length (Address-present-token Encoded-string-value | Insert-address-token)
763     const int addressPresentToken = 128;
764     const int insertAddressToken = 129;
765     std::string fieldName;
766     if (!FindHeaderFieldName(fieldId, fieldName)) {
767         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
768         return false;
769     }
770 
771     uint32_t valueLength = 0;
772     if (!buff.DecodeValueLength(valueLength)) {
773         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeValueLength fail.", fieldId);
774         return false;
775     }
776 
777     uint8_t oneByte = 0;
778     if (!buff.GetOneByte(oneByte)) {
779         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
780         return false;
781     }
782 
783     if (oneByte == addressPresentToken) {
784         // Address-present-token
785         MmsEncodeString encodeString;
786         encodeString.DecodeEncodeString(buff);
787 
788         std::string encodeAddress;
789         encodeString.GetEncodeString(encodeAddress);
790         if (encodeAddress.empty()) {
791             encodeAddress = encodeString.GetStrEncodeString();
792         }
793         MmsAddress address(encodeAddress);
794 
795         std::vector<MmsAddress> vecAddress;
796         vecAddress.push_back(address);
797         addressMap_.emplace(fieldId, vecAddress);
798         return true;
799     } else if (oneByte == insertAddressToken) {
800         // Insert-address-token
801         MmsAddress address("Insert-address-token");
802         std::vector<MmsAddress> vecAddress;
803         vecAddress.push_back(address);
804         addressMap_.emplace(fieldId, vecAddress);
805         return true;
806     }
807     return false;
808 }
809 
TrimString(std::string & str)810 void MmsHeader::TrimString(std::string &str)
811 {
812     const unsigned char minStringLen = 2;
813     if (str.length() < minStringLen) {
814         return;
815     }
816     if (str.at(0) != '<' || str.at(str.length() - 1) != '>') {
817         return;
818     }
819     str.erase(0, 1);
820     str.erase(str.length() - 1, str.length());
821     return;
822 }
823 
GetSmilFileName(std::string & smileFileName)824 bool MmsHeader::GetSmilFileName(std::string &smileFileName)
825 {
826     smileFileName = "";
827     const uint8_t startValue = static_cast<uint8_t>(ContentParam::CT_P_START_VALUE);
828     const uint8_t paramStart = static_cast<uint8_t>(ContentParam::CT_P_START);
829     uint8_t fieldIds[] = {startValue, paramStart};
830 
831     for (unsigned int i = 0; i < sizeof(fieldIds); i++) {
832         auto start = mmsContentType_.GetContentParam().GetParamMap().find(fieldIds[i]);
833         if (start != mmsContentType_.GetContentParam().GetParamMap().end()) {
834             smileFileName = start->second;
835             return true;
836         }
837     }
838     return true;
839 }
840 
DecodeMmsContentType(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)841 bool MmsHeader::DecodeMmsContentType(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
842 {
843     std::string fieldName;
844     if (!FindHeaderFieldName(fieldId, fieldName)) {
845         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader FindHeaderFieldName fail.", fieldId);
846         return false;
847     }
848     if (mmsContentType_.DecodeMmsContentType(buff, len)) {
849         return true;
850     }
851     return false;
852 }
853 
DecodeMmsMsgUnKnownField(MmsDecodeBuffer & decodeBuffer)854 bool MmsHeader::DecodeMmsMsgUnKnownField(MmsDecodeBuffer &decodeBuffer)
855 {
856     const uint8_t minFieldValue = 0x80;
857     uint8_t oneByte = 0;
858     while (oneByte < minFieldValue) {
859         if (!decodeBuffer.GetOneByte(oneByte)) {
860             TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
861             return false;
862         }
863     }
864     decodeBuffer.DecreasePointer(1);
865     return true;
866 }
867 
DecodeFieldIntegerValue(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)868 bool MmsHeader::DecodeFieldIntegerValue(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
869 {
870     std::string fieldName;
871     if (!FindHeaderFieldName(fieldId, fieldName)) {
872         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
873         return false;
874     }
875 
876     uint64_t value = 0;
877     if (!buff.DecodeInteger(value)) {
878         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeInteger fail.", fieldId);
879         return false;
880     }
881     auto ret = longValueMap_.emplace(fieldId, value);
882     return ret.second;
883 }
884 
885 /**
886  * @brief DecodeFieldDate
887  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.14
888  * Value-length (Absolute-token Date-value | Relative-token Delta-seconds-value)
889  * Absolute-token = <Octet 128>
890  * Relative-token = <Octet 129>
891  * @param fieldId
892  * @param buff
893  * @param len
894  * @return true
895  * @return false
896  */
DecodeFieldDate(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)897 bool MmsHeader::DecodeFieldDate(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
898 {
899     std::string fieldName;
900     if (!FindHeaderFieldName(fieldId, fieldName)) {
901         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
902         return false;
903     }
904 
905     const uint8_t relativeToken = 0x81;
906     uint32_t length = 0;
907     if (!buff.DecodeValueLength(length)) {
908         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeValueLength fail.", fieldId);
909         return false;
910     }
911     /* Absolute-token or Relative-token */
912     uint8_t token = 0;
913     if (!buff.GetOneByte(token)) {
914         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
915         return false;
916     }
917     /* Date-value or Delta-seconds-value */
918     uint64_t timeValue = 0;
919     if (!buff.DecodeLongInteger(timeValue)) {
920         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeLongInteger fail.", fieldId);
921         return false;
922     }
923     if (relativeToken == token) {
924         /* need to convert the Delta-seconds-value
925          * into Date-value */
926         chrono::system_clock::duration timePoint = chrono::system_clock::now().time_since_epoch();
927         long timeStamp = chrono::duration_cast<chrono::seconds>(timePoint).count();
928         timeValue += static_cast<uint64_t>(timeStamp);
929     }
930     auto ret = longValueMap_.emplace(fieldId, timeValue);
931     return ret.second;
932 }
933 
934 /**
935  * @brief DecodeFieldPreviouslySentDate
936  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.24 X-Mms-Previously-Sent-Date Field
937  * Previously-sent-date-value = Value-length Forwarded-count-value Date-value
938  * Forwarded-count-value = Integer-value
939  * Date-value = Long-integer
940  * @param fieldId
941  * @param buff
942  * @param len
943  * @return true
944  * @return false
945  */
DecodeFieldPreviouslySentDate(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)946 bool MmsHeader::DecodeFieldPreviouslySentDate(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
947 {
948     std::string fieldName;
949     if (!FindHeaderFieldName(fieldId, fieldName)) {
950         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
951         return false;
952     }
953 
954     /* Previously-sent-date-value =
955      * Value-length Forwarded-count-value Date-value */
956     /* parse value-length */
957     uint32_t length = 0;
958     uint64_t count = 0;
959     uint64_t perviouslySentDate = 0;
960     if (!buff.DecodeValueLength(length)) {
961         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeValueLength fail.", fieldId);
962         return false;
963     }
964     /* parse Forwarded-count-value */
965     if (!buff.DecodeInteger(count)) {
966         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeInteger fail.", fieldId);
967         return false;
968     }
969     if (!buff.DecodeLongInteger(perviouslySentDate)) {
970         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeLongInteger fail.", fieldId);
971         return false;
972     }
973     auto ret = longValueMap_.emplace(fieldId, perviouslySentDate);
974     return ret.second;
975 }
976 
977 /**
978  * @brief DecodeFieldMBox
979  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.25
980  * Value-length (Message-quota-token | Size-quota-token) Integer-Value
981  * Message-quota-token = <Octet 128>
982  * Size-quota-token = <Octet 129>
983  * @param fieldId
984  * @param buff
985  * @param len
986  * @return true
987  * @return false
988  */
DecodeFieldMBox(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)989 bool MmsHeader::DecodeFieldMBox(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
990 {
991     std::string fieldName;
992     if (!FindHeaderFieldName(fieldId, fieldName)) {
993         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
994         return false;
995     }
996 
997     /* Value-length
998      * (Message-total-token | Size-total-token) Integer-Value */
999     uint32_t length = 0;
1000     if (!buff.DecodeValueLength(length)) {
1001         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeValueLength fail.", fieldId);
1002         return false;
1003     }
1004     uint8_t token = 0;
1005     if (!buff.GetOneByte(token)) {
1006         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
1007         return false;
1008     }
1009     uint64_t value = 0;
1010     if (!buff.DecodeInteger(value)) {
1011         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeInteger fail.", fieldId);
1012         return false;
1013     }
1014     return true;
1015 }
1016 
1017 /**
1018  * @brief DecodeFieldMMFlag
1019  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.32 X-Mms-MM-Flags Field
1020  * Value-length ( Add-token | Remove-token | Filter-token ) Encoded-string-value
1021  * Add-token = <Octet 128>
1022  * Remove-token = <Octet 129>
1023  * Filter-token = <Octet 130>
1024  * @param fieldId
1025  * @param buff
1026  * @param len
1027  * @return true
1028  * @return false
1029  */
DecodeFieldMMFlag(uint8_t fieldId,MmsDecodeBuffer & buff,int32_t & len)1030 bool MmsHeader::DecodeFieldMMFlag(uint8_t fieldId, MmsDecodeBuffer &buff, int32_t &len)
1031 {
1032     std::string fieldName;
1033     if (!FindHeaderFieldName(fieldId, fieldName)) {
1034         TELEPHONY_LOGE("MmsHeader FindHeaderFieldName fail.");
1035         return false;
1036     }
1037 
1038     uint32_t length = 0;
1039     if (!buff.DecodeValueLength(length)) {
1040         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeValueLength fail.", fieldId);
1041         return false;
1042     }
1043     uint8_t token = 0;
1044     if (!buff.GetOneByte(token)) {
1045         TELEPHONY_LOGE("MmsHeader GetOneByte fail.");
1046         return false;
1047     }
1048     MmsEncodeString encodeString;
1049     if (!encodeString.DecodeEncodeString(buff)) {
1050         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader DecodeEncodeString fail.", fieldId);
1051         return false;
1052     }
1053     return true;
1054 }
1055 
IsHaveBody()1056 bool MmsHeader::IsHaveBody()
1057 {
1058     uint8_t msgType = 0;
1059     GetOctetValue(MMS_MESSAGE_TYPE, msgType);
1060     if (msgType == MMS_MSGTYPE_SEND_REQ || msgType == MMS_MSGTYPE_RETRIEVE_CONF) {
1061         return true;
1062     }
1063     return false;
1064 }
1065 
EncodeOctetValue(MmsEncodeBuffer & buff,uint8_t fieldId,uint8_t value)1066 bool MmsHeader::EncodeOctetValue(MmsEncodeBuffer &buff, uint8_t fieldId, uint8_t value)
1067 {
1068     if (!buff.WriteByte(fieldId)) {
1069         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1070         return false;
1071     }
1072     if (!buff.WriteByte(value)) {
1073         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1074         return false;
1075     }
1076     return true;
1077 }
1078 
EncodeShortIntegerValue(MmsEncodeBuffer & buff,uint8_t fieldId,int64_t value)1079 bool MmsHeader::EncodeShortIntegerValue(MmsEncodeBuffer &buff, uint8_t fieldId, int64_t value)
1080 {
1081     if (!buff.WriteByte(fieldId)) {
1082         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1083         return false;
1084     }
1085     if (!buff.EncodeShortInteger(value)) {
1086         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeShortInteger fail.", fieldId);
1087         return false;
1088     }
1089     return true;
1090 }
1091 
EncodeTextStringValue(MmsEncodeBuffer & buff,uint8_t fieldId,std::string value)1092 bool MmsHeader::EncodeTextStringValue(MmsEncodeBuffer &buff, uint8_t fieldId, std::string value)
1093 {
1094     if (value.empty()) {
1095         TELEPHONY_LOGE("fieldId[%{public}d] EncodeTextStringValue Value Empty fail.", fieldId);
1096         return false;
1097     }
1098     if (!buff.WriteByte(fieldId)) {
1099         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1100         return false;
1101     }
1102     if (!buff.EncodeText(value)) {
1103         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeText fail.", fieldId);
1104         return false;
1105     }
1106     return true;
1107 }
1108 
EncodeEncodeStringValue(MmsEncodeBuffer & buff,uint8_t fieldId,MmsEncodeString value)1109 bool MmsHeader::EncodeEncodeStringValue(MmsEncodeBuffer &buff, uint8_t fieldId, MmsEncodeString value)
1110 {
1111     std::string valueUtf8;
1112     if (!value.GetEncodeString(valueUtf8)) {
1113         TELEPHONY_LOGE("fieldId[%{public}d] GetEncodeString Error", fieldId);
1114         return false;
1115     }
1116     if (valueUtf8.empty()) {
1117         TELEPHONY_LOGE("fieldId[%{public}d] GetEncodeString Empty Error", fieldId);
1118         return false;
1119     }
1120 
1121     if (!buff.WriteByte(fieldId)) {
1122         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1123         return false;
1124     }
1125     if (!value.EncodeEncodeString(buff)) {
1126         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeEncodeString fail.", fieldId);
1127         return false;
1128     }
1129     return true;
1130 }
1131 
EncodeLongIntergerValue(MmsEncodeBuffer & buff,uint8_t fieldId,int64_t value)1132 bool MmsHeader::EncodeLongIntergerValue(MmsEncodeBuffer &buff, uint8_t fieldId, int64_t value)
1133 {
1134     if (!buff.WriteByte(fieldId)) {
1135         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1136         return false;
1137     }
1138     if (!buff.EncodeLongInteger(value)) {
1139         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeLongInteger fail.", fieldId);
1140         return false;
1141     }
1142     return true;
1143 }
1144 
EncodeOctetValueFromMap(MmsEncodeBuffer & buff,uint8_t fieldId)1145 bool MmsHeader::EncodeOctetValueFromMap(MmsEncodeBuffer &buff, uint8_t fieldId)
1146 {
1147     uint8_t value = 0;
1148     if (!GetOctetValue(fieldId, value)) {
1149         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1150         return false;
1151     }
1152     if (!EncodeOctetValue(buff, fieldId, value)) {
1153         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeOctetValue fail.", fieldId);
1154         return false;
1155     }
1156     return true;
1157 }
1158 
EncodeTextStringValueFromMap(MmsEncodeBuffer & buff,uint8_t fieldId)1159 bool MmsHeader::EncodeTextStringValueFromMap(MmsEncodeBuffer &buff, uint8_t fieldId)
1160 {
1161     std::string value = "";
1162     if (!GetTextValue(fieldId, value)) {
1163         TELEPHONY_LOGE("The fieldId[%{public}d] GetTextValue fail.", fieldId);
1164         return false;
1165     }
1166     if (!EncodeTextStringValue(buff, fieldId, value)) {
1167         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeTextStringValue fail.", fieldId);
1168         return false;
1169     }
1170     return true;
1171 }
1172 
EnocdeEncodeStringValueFromMap(MmsEncodeBuffer & buff,uint8_t fieldId)1173 bool MmsHeader::EnocdeEncodeStringValueFromMap(MmsEncodeBuffer &buff, uint8_t fieldId)
1174 {
1175     MmsEncodeString value;
1176     if (!GetEncodeStringValue(fieldId, value)) {
1177         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader GetEncodeStringValue fail.", fieldId);
1178         return false;
1179     }
1180     if (!EncodeEncodeStringValue(buff, fieldId, value)) {
1181         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeEncodeStringValue fail.", fieldId);
1182         return false;
1183     }
1184     return true;
1185 }
1186 
EnocdeShortIntegerValueFromMap(MmsEncodeBuffer & buff,uint8_t fieldId)1187 bool MmsHeader::EnocdeShortIntegerValueFromMap(MmsEncodeBuffer &buff, uint8_t fieldId)
1188 {
1189     int64_t value = 0;
1190     if (!GetLongValue(fieldId, value)) {
1191         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader GetLongValue fail.", fieldId);
1192         return false;
1193     }
1194     if (!EncodeShortIntegerValue(buff, fieldId, value)) {
1195         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeShortIntegerValue fail.", fieldId);
1196         return false;
1197     }
1198     return true;
1199 }
1200 
EncodeLongIntergerValueFromMap(MmsEncodeBuffer & buff,uint8_t fieldId)1201 bool MmsHeader::EncodeLongIntergerValueFromMap(MmsEncodeBuffer &buff, uint8_t fieldId)
1202 {
1203     int64_t value = 0;
1204     if (!GetLongValue(fieldId, value)) {
1205         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader GetLongValue fail.", fieldId);
1206         return false;
1207     }
1208     if (!EncodeLongIntergerValue(buff, fieldId, value)) {
1209         TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeLongIntergerValue fail.", fieldId);
1210         return false;
1211     }
1212     return true;
1213 }
1214 
EncodeFieldExpriyValue(MmsEncodeBuffer & buff,int64_t value)1215 bool MmsHeader::EncodeFieldExpriyValue(MmsEncodeBuffer &buff, int64_t value)
1216 {
1217     if (!buff.WriteByte(MMS_EXPIRY)) {
1218         TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1219         return false;
1220     }
1221 
1222     const uint8_t relativeToken = 129;
1223     MmsEncodeBuffer tempBuf;
1224     if (!tempBuf.EncodeOctet(relativeToken)) {
1225         TELEPHONY_LOGE("MmsHeader EncodeOctet fail.");
1226         return false;
1227     }
1228     if (!tempBuf.EncodeLongInteger(value)) {
1229         TELEPHONY_LOGE("MmsHeader EncodeLongInteger fail.");
1230         return false;
1231     }
1232     if (!buff.EncodeValueLength(tempBuf.GetCurPosition())) {
1233         TELEPHONY_LOGE("MmsHeader EncodeValueLength fail.");
1234         return false;
1235     }
1236     if (!buff.WriteBuffer(tempBuf)) {
1237         TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1238         return false;
1239     }
1240     return true;
1241 }
1242 
1243 /**
1244  * @brief EncodeFieldFromValue
1245  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:7.3.21 From Field
1246  * From-value = Value-length (Address-present-token Encoded-string-value | Insert-address-token)
1247  * Address-present-token = <Octet 128>
1248  * Insert-address-token = <Octet 129>
1249  * @param buff
1250  * @param addr
1251  * @return true
1252  * @return false
1253  */
EncodeFieldFromValue(MmsEncodeBuffer & buff,std::vector<MmsAddress> & addr)1254 bool MmsHeader::EncodeFieldFromValue(MmsEncodeBuffer &buff, std::vector<MmsAddress> &addr)
1255 {
1256     auto it = addressMap_.find(MMS_FROM);
1257     if (it != addressMap_.end()) {
1258         if (!buff.WriteByte(MMS_FROM)) {
1259             TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1260             return false;
1261         }
1262         // Value-length (Address-present-token Encoded-string-value | Insert-address-token)
1263         const uint8_t addressPresentToken = 128;
1264         const uint8_t insertAddressToken = 129;
1265         MmsEncodeBuffer tempBuff;
1266         if (addr.empty() || addr[0].GetAddressString().empty()) {
1267             if (!tempBuff.WriteByte(insertAddressToken)) {
1268                 TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1269                 return false;
1270             }
1271         } else {
1272             if (!tempBuff.WriteByte(addressPresentToken)) {
1273                 TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1274                 return false;
1275             }
1276 
1277             MmsEncodeString encodeString;
1278             encodeString.SetAddressString(addr[0]);
1279             if (!encodeString.EncodeEncodeString(tempBuff)) {
1280                 TELEPHONY_LOGE("MmsHeader EncodeEncodeString fail.");
1281                 return false;
1282             }
1283         }
1284         if (!buff.EncodeValueLength(tempBuff.GetCurPosition())) {
1285             TELEPHONY_LOGE("MmsHeader EncodeValueLength fail.");
1286             return false;
1287         }
1288         if (!buff.WriteBuffer(tempBuff)) {
1289             TELEPHONY_LOGE("MmsHeader WriteByte fail.");
1290             return false;
1291         }
1292         addressMap_.erase(it);
1293     }
1294     return true;
1295 }
1296 
EncodeMultipleAddressValue(MmsEncodeBuffer & buff,uint8_t fieldId,std::vector<MmsAddress> & addrs)1297 bool MmsHeader::EncodeMultipleAddressValue(MmsEncodeBuffer &buff, uint8_t fieldId, std::vector<MmsAddress> &addrs)
1298 {
1299     if (addrs.empty()) {
1300         TELEPHONY_LOGE("MmsHeader address is invalid.");
1301         return false;
1302     }
1303 
1304     for (auto addr : addrs) {
1305         if (!buff.WriteByte(fieldId)) {
1306             TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader WriteByte fail.", fieldId);
1307             return false;
1308         }
1309         MmsEncodeString encodeString;
1310         encodeString.SetAddressString(addr);
1311         if (!encodeString.EncodeEncodeString(buff)) {
1312             TELEPHONY_LOGE("The fieldId[%{public}d] MmsHeader EncodeEncodeString fail.", fieldId);
1313             return false;
1314         }
1315     }
1316     return true;
1317 }
1318 
EcondeFieldMessageClassValue(MmsEncodeBuffer & buff)1319 bool MmsHeader::EcondeFieldMessageClassValue(MmsEncodeBuffer &buff)
1320 {
1321     uint8_t valueOctet = 0;
1322     if (GetOctetValue(MMS_MESSAGE_CLASS, valueOctet)) {
1323         return EncodeOctetValue(buff, MMS_MESSAGE_CLASS, valueOctet);
1324     }
1325 
1326     std::string strValue = "";
1327     if (GetTextValue(MMS_MESSAGE_CLASS, strValue)) {
1328         if (strValue == "personal") {
1329             valueOctet = static_cast<uint8_t>(MmsMessageClass::PERSONAL);
1330         } else if (strValue == "advertisement") {
1331             valueOctet = static_cast<uint8_t>(MmsMessageClass::ADVERTISEMENT);
1332         } else if (strValue == "informational") {
1333             valueOctet = static_cast<uint8_t>(MmsMessageClass::INFORMATIONAL);
1334         } else if (strValue == "auto") {
1335             valueOctet = static_cast<uint8_t>(MmsMessageClass::AUTO);
1336         }
1337 
1338         if (valueOctet != 0) {
1339             return EncodeOctetValue(buff, MMS_MESSAGE_CLASS, valueOctet);
1340         }
1341         return EncodeTextStringValue(buff, MMS_MESSAGE_CLASS, strValue);
1342     }
1343     return false;
1344 }
1345 
EncodeCommontFieldValue(MmsEncodeBuffer & buff)1346 bool MmsHeader::EncodeCommontFieldValue(MmsEncodeBuffer &buff)
1347 {
1348     uint8_t messageType = 0;
1349     GetOctetValue(MMS_MESSAGE_TYPE, messageType);
1350     if (!EncodeOctetValue(buff, MMS_MESSAGE_TYPE, messageType)) {
1351         TELEPHONY_LOGE("MmsHeader EncodeOctetValue fail.");
1352         return false;
1353     }
1354 
1355     std::string transactionId = "";
1356     if (GetTextValue(MMS_TRANSACTION_ID, transactionId)) {
1357         if (!EncodeTextStringValue(buff, MMS_TRANSACTION_ID, transactionId)) {
1358             TELEPHONY_LOGE("MmsHeader EncodeTextStringValue fail.");
1359             return false;
1360         }
1361     }
1362 
1363     int64_t version = 0;
1364     GetLongValue(MMS_MMS_VERSION, version); // 8bit shortInteger
1365     if (!EncodeShortIntegerValue(buff, MMS_MMS_VERSION, version)) {
1366         TELEPHONY_LOGE("MmsHeader EncodeShortIntegerValue fail.");
1367         return false;
1368     }
1369     return true;
1370 }
1371 
1372 /**
1373  * @brief EncodeMmsSendReq
1374  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.1.1 Send Request
1375  * @param buff
1376  * @return true
1377  * @return false
1378  */
EncodeMmsSendReq(MmsEncodeBuffer & buff)1379 bool MmsHeader::EncodeMmsSendReq(MmsEncodeBuffer &buff)
1380 {
1381     // FROM
1382     std::vector<MmsAddress> fromAddress;
1383     GetHeaderAllAddressValue(MMS_FROM, fromAddress);
1384     if (!EncodeFieldFromValue(buff, fromAddress)) {
1385         TELEPHONY_LOGE("encode mandatory from field error.");
1386         return false;
1387     }
1388     // Optional
1389     int64_t mmsExpriy = 0;
1390     if (GetLongValue(MMS_EXPIRY, mmsExpriy)) {
1391         EncodeFieldExpriyValue(buff, mmsExpriy);
1392     }
1393     // CC BCC TO
1394     for (auto it = addressMap_.begin(); it != addressMap_.end(); it++) {
1395         EncodeMultipleAddressValue(buff, it->first, it->second);
1396     }
1397 
1398     EcondeFieldMessageClassValue(buff); // MMS_MESSAGE_CLASS
1399     EncodeLongIntergerValueFromMap(buff, MMS_DATE);
1400     EnocdeEncodeStringValueFromMap(buff, MMS_SUBJECT);
1401     EncodeTextStringValueFromMap(buff, MMS_MESSAGE_CLASS);
1402     EncodeOctetValueFromMap(buff, MMS_PRIORITY);
1403     EncodeOctetValueFromMap(buff, MMS_SENDER_VISIBILITY);
1404     EncodeOctetValueFromMap(buff, MMS_DELIVERY_REPORT);
1405     EncodeOctetValueFromMap(buff, MMS_READ_REPORT);
1406     return true;
1407 }
1408 
1409 /**
1410  * @brief EncodeMmsSendConf
1411  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.1.2 Send Confirmationt
1412  * @param buff
1413  * @return true
1414  * @return false
1415  */
EncodeMmsSendConf(MmsEncodeBuffer & buff)1416 bool MmsHeader::EncodeMmsSendConf(MmsEncodeBuffer &buff)
1417 {
1418     // Mandatory
1419     if (!EncodeOctetValueFromMap(buff, MMS_RESPONSE_STATUS)) {
1420         TELEPHONY_LOGE("encode mandatory response status field error.");
1421         return false;
1422     }
1423     // Optional
1424     EncodeTextStringValueFromMap(buff, MMS_MESSAGE_ID);
1425     return true;
1426 }
1427 
1428 /**
1429  * @brief EncodeMmsNotificationInd
1430  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.2 Multimedia Message Notification
1431  * @param buff
1432  * @return true
1433  * @return false
1434  */
EncodeMmsNotificationInd(MmsEncodeBuffer & buff)1435 bool MmsHeader::EncodeMmsNotificationInd(MmsEncodeBuffer &buff)
1436 {
1437     // Mandatory
1438     if (!EncodeTextStringValueFromMap(buff, MMS_CONTENT_LOCATION)) {
1439         TELEPHONY_LOGE("encode mandatory content location field error.");
1440         return false;
1441     }
1442     if (!EncodeLongIntergerValueFromMap(buff, MMS_MESSAGE_SIZE)) {
1443         TELEPHONY_LOGE("encode mandatory message size field error.");
1444         return false;
1445     }
1446     int64_t mmsExpriy = 0;
1447     if (!GetLongValue(MMS_EXPIRY, mmsExpriy)) {
1448         TELEPHONY_LOGE("get mandatory expriy field no set error.");
1449         return false;
1450     }
1451     if (!EncodeFieldExpriyValue(buff, mmsExpriy)) {
1452         TELEPHONY_LOGE("encode mandatory expriy field error.");
1453         return false;
1454     }
1455     if (!EcondeFieldMessageClassValue(buff)) { // MMS_MESSAGE_CLASS
1456         TELEPHONY_LOGE("encode mandatory message class field error.");
1457         return false;
1458     }
1459 
1460     // Optional
1461     std::vector<MmsAddress> fromAddress;
1462     if (GetHeaderAllAddressValue(MMS_FROM, fromAddress)) {
1463         EncodeFieldFromValue(buff, fromAddress);
1464     }
1465     EncodeOctetValueFromMap(buff, MMS_CONTENT_CLASS);
1466     EnocdeEncodeStringValueFromMap(buff, MMS_SUBJECT);
1467     EncodeOctetValueFromMap(buff, MMS_DELIVERY_REPORT);
1468     return true;
1469 }
1470 
1471 /**
1472  * @brief EnocdeMmsNotifyRespInd
1473  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.2 Multimedia Message Notification
1474  * @param buff
1475  * @return true
1476  * @return false
1477  */
EnocdeMmsNotifyRespInd(MmsEncodeBuffer & buff)1478 bool MmsHeader::EnocdeMmsNotifyRespInd(MmsEncodeBuffer &buff)
1479 {
1480     // Mandatory
1481     if (!EncodeOctetValueFromMap(buff, MMS_STATUS)) {
1482         TELEPHONY_LOGE("encode mandatory mms status field error.");
1483         return false;
1484     }
1485     // Optional
1486     EncodeOctetValueFromMap(buff, MMS_REPORT_ALLOWED);
1487     return true;
1488 }
1489 
1490 /**
1491  * @brief EnocdeMmsRetrieveConf
1492  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.3 Retrieval of Multimedia Message
1493  * @param buff
1494  * @return true
1495  * @return false
1496  */
EnocdeMmsRetrieveConf(MmsEncodeBuffer & buff)1497 bool MmsHeader::EnocdeMmsRetrieveConf(MmsEncodeBuffer &buff)
1498 {
1499     // Mandatory
1500     if (!EncodeLongIntergerValueFromMap(buff, MMS_DATE)) {
1501         TELEPHONY_LOGE("encode mandatory mms date field error.");
1502         return false;
1503     }
1504 
1505     // Optional
1506     EncodeTextStringValueFromMap(buff, MMS_MESSAGE_ID); // Conditional
1507     std::vector<MmsAddress> fromAddress;
1508     if (GetHeaderAllAddressValue(MMS_FROM, fromAddress)) {
1509         EncodeFieldFromValue(buff, fromAddress);
1510     }
1511     std::vector<MmsAddress> toAddress;
1512     if (GetHeaderAllAddressValue(MMS_TO, toAddress)) {
1513         if (!EncodeMultipleAddressValue(buff, MMS_TO, toAddress)) {
1514             TELEPHONY_LOGE("MmsHeader EncodeMultipleAddressValue fail.");
1515             return false;
1516         }
1517     }
1518     std::vector<MmsAddress> ccAddress;
1519     if (GetHeaderAllAddressValue(MMS_CC, ccAddress)) {
1520         if (!EncodeMultipleAddressValue(buff, MMS_CC, ccAddress)) {
1521             TELEPHONY_LOGE("MmsHeader EncodeMultipleAddressValue fail.");
1522             return false;
1523         }
1524     }
1525     EcondeFieldMessageClassValue(buff); // MMS_MESSAGE_CLASS
1526     EnocdeEncodeStringValueFromMap(buff, MMS_SUBJECT);
1527     EncodeOctetValueFromMap(buff, MMS_PRIORITY);
1528     EncodeOctetValueFromMap(buff, MMS_DELIVERY_REPORT);
1529     EncodeOctetValueFromMap(buff, MMS_READ_REPORT);
1530     EncodeOctetValueFromMap(buff, MMS_RETRIEVE_STATUS);
1531     EnocdeEncodeStringValueFromMap(buff, MMS_RETRIEVE_TEXT);
1532     // MMS_PREVIOUSLY_SENT_BY unSupported
1533     // MMS_PREVIOUSLY_SENT_DATE unSupported
1534     // MMS_MM_STATE unSupported
1535     // MMS_MM_FLAGS unSupported
1536     // MMS_REPLY_CHARGING unSupported
1537     // MMS_REPLY_CHARGING_DEADLINE unSupported
1538     // MMS_REPLY_CHARGING_SIZE unSupported
1539     // MMS_REPLY_CHARGING_ID unSupported
1540     // MMS_DISTRIBUTION_INDICATOR unSupported
1541     // MMS_APPLIC_ID unSupported
1542     // MMS_REPLY_APPLIC_ID unSupported
1543     // MMS_AUX_APPLIC_INFO unSupported
1544     // MMS_CONTENT_CLASS unSupported
1545     // MMS_DRM_CONTENT unSupported
1546     // MMS_REPLACE_ID unSupported
1547     return true;
1548 }
1549 
1550 /**
1551  * @brief EnocdeMmsAcknowledgeInd
1552  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.4 Delivery Acknowledgement
1553  * @param buff
1554  * @return true
1555  * @return false
1556  */
EnocdeMmsAcknowledgeInd(MmsEncodeBuffer & buff)1557 bool MmsHeader::EnocdeMmsAcknowledgeInd(MmsEncodeBuffer &buff)
1558 {
1559     // Optional
1560     EncodeOctetValueFromMap(buff, MMS_REPORT_ALLOWED);
1561     return true;
1562 }
1563 
1564 /**
1565  * @brief EnocdeMmsDeliveryInd
1566  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.6 Delivery Reporting
1567  * @param buff
1568  * @return true
1569  * @return false
1570  */
EnocdeMmsDeliveryInd(MmsEncodeBuffer & buff)1571 bool MmsHeader::EnocdeMmsDeliveryInd(MmsEncodeBuffer &buff)
1572 {
1573     // Mandatory
1574     std::vector<MmsAddress> toAddress;
1575     if (!GetHeaderAllAddressValue(MMS_TO, toAddress)) {
1576         TELEPHONY_LOGE("get mandatory mms to field no set error.");
1577         return false;
1578     }
1579     if (!EncodeMultipleAddressValue(buff, MMS_TO, toAddress)) {
1580         TELEPHONY_LOGE("encode mandatory mms to field error.");
1581         return false;
1582     }
1583     if (!EncodeTextStringValueFromMap(buff, MMS_MESSAGE_ID)) {
1584         TELEPHONY_LOGE("encode mandatory mms message id field error.");
1585         return false;
1586     }
1587     if (!EncodeLongIntergerValueFromMap(buff, MMS_DATE)) {
1588         TELEPHONY_LOGE("encode mandatory mms date field error.");
1589         return false;
1590     }
1591     if (!EncodeOctetValueFromMap(buff, MMS_STATUS)) {
1592         TELEPHONY_LOGE("encode mandatory mms status field error.");
1593         return false;
1594     }
1595     // Optional
1596     return true;
1597 }
1598 
1599 /**
1600  * @brief EncodeMmsReadRecInd
1601  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.7.2 PDU Read Report
1602  * @param buff
1603  * @return true
1604  * @return false
1605  */
EncodeMmsReadRecInd(MmsEncodeBuffer & buff)1606 bool MmsHeader::EncodeMmsReadRecInd(MmsEncodeBuffer &buff)
1607 {
1608     // Mandatory
1609     if (!EncodeTextStringValueFromMap(buff, MMS_MESSAGE_ID)) {
1610         TELEPHONY_LOGE("encode mandatory mms message id field error.");
1611         return false;
1612     }
1613     std::vector<MmsAddress> toAddress;
1614     if (!GetHeaderAllAddressValue(MMS_TO, toAddress)) {
1615         TELEPHONY_LOGE("get mandatory mms to field no set error.");
1616         return false;
1617     }
1618     if (!EncodeMultipleAddressValue(buff, MMS_TO, toAddress)) {
1619         TELEPHONY_LOGE("encode mandatory mms to field error.");
1620         return false;
1621     }
1622 
1623     std::vector<MmsAddress> fromAddress;
1624     GetHeaderAllAddressValue(MMS_FROM, fromAddress);
1625     if (!EncodeFieldFromValue(buff, fromAddress)) {
1626         TELEPHONY_LOGE("encode mandatory mms from field error.");
1627         return false;
1628     }
1629 
1630     if (!EncodeOctetValueFromMap(buff, MMS_READ_STATUS)) {
1631         TELEPHONY_LOGE("encode mandatory mms read status field error.");
1632         return false;
1633     }
1634     // Optional
1635     EncodeLongIntergerValueFromMap(buff, MMS_DATE);
1636     // MMS_APPLIC_ID unSupported
1637     // MMS_REPLY_APPLIC_ID unSupported
1638     // MMS_AUX_APPLIC_INFO unSupported
1639     return true;
1640 }
1641 
1642 /**
1643  * @brief EncodeMmsReadOrigInd
1644  * OMA-TS-MMS_ENC-V1_3-20110913-A   section:6.7.2 PDU Read Report
1645  * @param buff
1646  * @return true
1647  * @return false
1648  */
EncodeMmsReadOrigInd(MmsEncodeBuffer & buff)1649 bool MmsHeader::EncodeMmsReadOrigInd(MmsEncodeBuffer &buff)
1650 {
1651     // Mandatory
1652     if (!EncodeTextStringValueFromMap(buff, MMS_MESSAGE_ID)) {
1653         TELEPHONY_LOGE("encode mandatory mms message id field error.");
1654         return false;
1655     }
1656     std::vector<MmsAddress> toAddress;
1657     if (!GetHeaderAllAddressValue(MMS_TO, toAddress)) {
1658         TELEPHONY_LOGE("get mandatory mms to field no set error.");
1659         return false;
1660     }
1661     if (!EncodeMultipleAddressValue(buff, MMS_TO, toAddress)) {
1662         TELEPHONY_LOGE("encode mandatory mms to field error.");
1663         return false;
1664     }
1665 
1666     std::vector<MmsAddress> fromAddress;
1667     GetHeaderAllAddressValue(MMS_FROM, fromAddress);
1668     if (!EncodeFieldFromValue(buff, fromAddress)) {
1669         TELEPHONY_LOGE("encode mandatory mms from field error.");
1670         return false;
1671     }
1672 
1673     if (!EncodeOctetValueFromMap(buff, MMS_READ_STATUS)) {
1674         TELEPHONY_LOGE("encode mandatory mms read status field error.");
1675         return false;
1676     }
1677     if (!EncodeLongIntergerValueFromMap(buff, MMS_DATE)) {
1678         TELEPHONY_LOGE("encode mandatory mms date field error.");
1679         return false;
1680     }
1681     // Optional
1682     // MMS_APPLIC_ID unSupported
1683     // MMS_REPLY_APPLIC_ID unSupported
1684     // MMS_AUX_APPLIC_INFO unSupported
1685     return true;
1686 }
1687 
IsHaveTransactionId(uint8_t messageType)1688 bool MmsHeader::IsHaveTransactionId(uint8_t messageType)
1689 {
1690     if (messageType == MMS_MSGTYPE_SEND_REQ || messageType == MMS_MSGTYPE_SEND_CONF ||
1691         messageType == MMS_MSGTYPE_NOTIFICATION_IND || messageType == MMS_MSGTYPE_NOTIFYRESP_IND ||
1692         messageType == MMS_MSGTYPE_RETRIEVE_CONF || messageType == MMS_MSGTYPE_ACKNOWLEDGE_IND) {
1693         return true;
1694     }
1695     return false;
1696 }
1697 
CheckResponseStatus(uint8_t value)1698 bool MmsHeader::CheckResponseStatus(uint8_t value)
1699 {
1700     if (value >= static_cast<uint8_t>(MmsResponseStatus::MMS_OK) &&
1701         value <= static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_UNSUPPORTED_MESSAGE)) {
1702         return true;
1703     }
1704     if (value >= static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_TRANSIENT_FAILURE) &&
1705         value <= static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_TRANSIENT_PARTIAL_SUCCESS)) {
1706         return true;
1707     }
1708     if (value >= static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_FAILURE) &&
1709         value <= static_cast<uint8_t>(MmsResponseStatus::MMS_ERROR_PERMANENT_LACK_OF_PREPAID)) {
1710         return true;
1711     }
1712     return false;
1713 }
1714 
CheckRetrieveStatus(uint8_t value)1715 bool MmsHeader::CheckRetrieveStatus(uint8_t value)
1716 {
1717     if (value == static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_OK)) {
1718         return true;
1719     }
1720     if (value >= static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE) &&
1721         value <= static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM)) {
1722         return true;
1723     }
1724     if (value >= static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE) &&
1725         value <= static_cast<uint8_t>(MmsRetrieveStatus::MMS_RETRIEVE_STATUS_ERROR_PERMANENT_CONTENT_UNSUPPORTED)) {
1726         return true;
1727     }
1728     return false;
1729 }
1730 
CheckStoreStatus(uint8_t value)1731 bool MmsHeader::CheckStoreStatus(uint8_t value)
1732 {
1733     if (value == static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_SUCCESS)) {
1734         return true;
1735     }
1736     if (value >= static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_FAILURE) &&
1737         value <= static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM)) {
1738         return true;
1739     }
1740     if (value >= static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_FAILURE) &&
1741         value <= static_cast<uint8_t>(MmsStoreStatus::MMS_STORE_STATUS_ERROR_PERMANENT_MMBOX_FULL)) {
1742         return true;
1743     }
1744     return false;
1745 }
1746 
CheckBooleanValue(uint8_t fieldId,uint8_t value)1747 bool MmsHeader::CheckBooleanValue(uint8_t fieldId, uint8_t value)
1748 {
1749     switch (fieldId) {
1750         case MMS_DELIVERY_REPORT:
1751         case MMS_READ_REPORT:
1752         case MMS_REPORT_ALLOWED:
1753         case MMS_STORE:
1754         case MMS_STORED:
1755         case MMS_TOTALS:
1756         case MMS_QUOTAS:
1757         case MMS_DISTRIBUTION_INDICATOR:
1758         case MMS_DRM_CONTENT:
1759         case MMS_ADAPTATION_ALLOWED:
1760             if (value < static_cast<uint8_t>(MmsBoolType::MMS_YES) ||
1761                 value > static_cast<uint8_t>(MmsBoolType::MMS_NO)) {
1762                 return false;
1763             }
1764             break;
1765         default:
1766             return false;
1767     }
1768 
1769     auto ret = octetValueMap_.emplace(fieldId, value);
1770     return ret.second;
1771 }
1772 } // namespace Telephony
1773 } // namespace OHOS
1774