1 /*
2 * Copyright (C) 2022 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 #include "mtp_packet_tools.h"
16 #include <codecvt>
17 #include <cctype>
18 #include <cinttypes>
19 #include <cstdlib>
20 #include <locale>
21 #include "media_log.h"
22 #include "mtp_packet.h"
23 #include "securec.h"
24 namespace OHOS {
25 namespace Media {
26 namespace {
27 // these numbers are defined by protocol, have no exact meaning
28 static const int BUF_07 = 0x07;
29 static const int BUF_0F = 0x0F;
30
31 static const int BEGIN_YEAR = 1900;
32 static const int DUMP_HEXBUF_MAX = 128;
33 static const int DUMP_TXTBUF_MAX = 32;
34 static const int MAX_LENGTH = 255;
35 static const int TIME_LENGTH = 20;
36 static const std::string BLANK_STR = " ";
37 static const std::string INDENT_BLANKSTR = " ";
38 static const int INDENT_SIZE = INDENT_BLANKSTR.length();
39 static const std::string DATE_TIME_INIT = "19700101T080000";
40 static const std::string UNKNOWN_STR = "Unknown";
41 static const char *UTF16_CERROR = "__CONVERSION_ERROR__";
42 static const char16_t *UTF8_CERROR = u"__CONVERSION_ERROR__";
43 static const std::map<uint32_t, std::string> AssociationMap = {
44 { MTP_ASSOCIATION_TYPE_UNDEFINED_CODE, "MTP_ASSOCIATION_TYPE_UNDEFINED" },
45 { MTP_ASSOCIATION_TYPE_GENERIC_FOLDER_CODE, "MTP_ASSOCIATION_TYPE_GENERIC_FOLDER" },
46 };
47
48 static const std::map<uint32_t, std::string> OperationMap = {
49 { MTP_OPERATION_GET_DEVICE_INFO_CODE, "MTP_OPERATION_GET_DEVICE_INFO" },
50 { MTP_OPERATION_OPEN_SESSION_CODE, "MTP_OPERATION_OPEN_SESSION" },
51 { MTP_OPERATION_CLOSE_SESSION_CODE, "MTP_OPERATION_CLOSE_SESSION" },
52 { MTP_OPERATION_GET_STORAGE_IDS_CODE, "MTP_OPERATION_GET_STORAGE_IDS" },
53 { MTP_OPERATION_GET_STORAGE_INFO_CODE, "MTP_OPERATION_GET_STORAGE_INFO" },
54 { MTP_OPERATION_GET_NUM_OBJECTS_CODE, "MTP_OPERATION_GET_NUM_OBJECTS" },
55 { MTP_OPERATION_GET_OBJECT_HANDLES_CODE, "MTP_OPERATION_GET_OBJECT_HANDLES" },
56 { MTP_OPERATION_GET_OBJECT_INFO_CODE, "MTP_OPERATION_GET_OBJECT_INFO" },
57 { MTP_OPERATION_GET_OBJECT_CODE, "MTP_OPERATION_GET_OBJECT" },
58 { MTP_OPERATION_GET_THUMB_CODE, "MTP_OPERATION_GET_THUMB" },
59 { MTP_OPERATION_DELETE_OBJECT_CODE, "MTP_OPERATION_DELETE_OBJECT" },
60 { MTP_OPERATION_SEND_OBJECT_INFO_CODE, "MTP_OPERATION_SEND_OBJECT_INFO" },
61 { MTP_OPERATION_SEND_OBJECT_CODE, "MTP_OPERATION_SEND_OBJECT" },
62 { MTP_OPERATION_INITIATE_CAPTURE_CODE, "MTP_OPERATION_INITIATE_CAPTURE" },
63 { MTP_OPERATION_FORMAT_STORE_CODE, "MTP_OPERATION_FORMAT_STORE" },
64 { MTP_OPERATION_RESET_DEVICE_CODE, "MTP_OPERATION_RESET_DEVICE" },
65 { MTP_OPERATION_SELF_TEST_CODE, "MTP_OPERATION_SELF_TEST" },
66 { MTP_OPERATION_SET_OBJECT_PROTECTION_CODE, "MTP_OPERATION_SET_OBJECT_PROTECTION" },
67 { MTP_OPERATION_POWER_DOWN_CODE, "MTP_OPERATION_POWER_DOWN" },
68 { MTP_OPERATION_GET_DEVICE_PROP_DESC_CODE, "MTP_OPERATION_GET_DEVICE_PROP_DESC" },
69 { MTP_OPERATION_GET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_GET_DEVICE_PROP_VALUE" },
70 { MTP_OPERATION_SET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_SET_DEVICE_PROP_VALUE" },
71 { MTP_OPERATION_RESET_DEVICE_PROP_VALUE_CODE, "MTP_OPERATION_RESET_DEVICE_PROP_VALUE" },
72 { MTP_OPERATION_TERMINATE_OPEN_CAPTURE_CODE, "MTP_OPERATION_TERMINATE_OPEN_CAPTURE" },
73 { MTP_OPERATION_MOVE_OBJECT_CODE, "MTP_OPERATION_MOVE_OBJECT" },
74 { MTP_OPERATION_COPY_OBJECT_CODE, "MTP_OPERATION_COPY_OBJECT" },
75 { MTP_OPERATION_GET_PARTIAL_OBJECT_CODE, "MTP_OPERATION_GET_PARTIAL_OBJECT" },
76 { MTP_OPERATION_INITIATE_OPEN_CAPTURE_CODE, "MTP_OPERATION_INITIATE_OPEN_CAPTURE" },
77 { MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED_CODE, "MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED" },
78 { MTP_OPERATION_GET_OBJECT_PROP_DESC_CODE, "MTP_OPERATION_GET_OBJECT_PROP_DESC" },
79 { MTP_OPERATION_GET_OBJECT_PROP_VALUE_CODE, "MTP_OPERATION_GET_OBJECT_PROP_VALUE" },
80 { MTP_OPERATION_SET_OBJECT_PROP_VALUE_CODE, "MTP_OPERATION_SET_OBJECT_PROP_VALUE" },
81 { MTP_OPERATION_GET_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_GET_OBJECT_PROP_LIST" },
82 { MTP_OPERATION_SET_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_SET_OBJECT_PROP_LIST" },
83 { MTP_OPERATION_GET_INTERDEPENDENT_PROPDESC_CODE, "MTP_OPERATION_GET_INTERDEPENDENT_PROP_DESC" },
84 { MTP_OPERATION_SEND_OBJECT_PROP_LIST_CODE, "MTP_OPERATION_SEND_OBJECT_PROP_LIST" },
85 { MTP_OPERATION_GET_OBJECT_REFERENCES_CODE, "MTP_OPERATION_GET_OBJECT_REFERENCES" },
86 { MTP_OPERATION_SET_OBJECT_REFERENCES_CODE, "MTP_OPERATION_SET_OBJECT_REFERENCES" },
87 { MTP_OPERATION_SKIP_CODE, "MTP_OPERATION_SKIP" },
88 };
89
90 static const std::map<uint32_t, std::string> FormatMap = {
91 { MTP_FORMAT_UNDEFINED_CODE, "MTP_FORMAT_UNDEFINED" },
92 { MTP_FORMAT_ASSOCIATION_CODE, "MTP_FORMAT_ASSOCIATION" },
93 { MTP_FORMAT_SCRIPT_CODE, "MTP_FORMAT_SCRIPT" },
94 { MTP_FORMAT_EXECUTABLE_CODE, "MTP_FORMAT_EXECUTABLE" },
95 { MTP_FORMAT_TEXT_CODE, "MTP_FORMAT_TEXT" },
96 { MTP_FORMAT_HTML_CODE, "MTP_FORMAT_HTML" },
97 { MTP_FORMAT_DPOF_CODE, "MTP_FORMAT_DPOF" },
98 { MTP_FORMAT_AIFF_CODE, "MTP_FORMAT_AIFF" },
99 { MTP_FORMAT_WAV_CODE, "MTP_FORMAT_WAV" },
100 { MTP_FORMAT_MP3_CODE, "MTP_FORMAT_MP3" },
101 { MTP_FORMAT_AVI_CODE, "MTP_FORMAT_AVI" },
102 { MTP_FORMAT_MPEG_CODE, "MTP_FORMAT_MPEG" },
103 { MTP_FORMAT_ASF_CODE, "MTP_FORMAT_ASF" },
104 { MTP_FORMAT_DEFINED_CODE, "MTP_FORMAT_DEFINED" },
105 { MTP_FORMAT_EXIF_JPEG_CODE, "MTP_FORMAT_EXIF_JPEG" },
106 { MTP_FORMAT_TIFF_EP_CODE, "MTP_FORMAT_TIFF_EP" },
107 { MTP_FORMAT_FLASHPIX_CODE, "MTP_FORMAT_FLASHPIX" },
108 { MTP_FORMAT_BMP_CODE, "MTP_FORMAT_BMP" },
109 { MTP_FORMAT_CIFF_CODE, "MTP_FORMAT_CIFF" },
110 { MTP_FORMAT_GIF_CODE, "MTP_FORMAT_GIF" },
111 { MTP_FORMAT_JFIF_CODE, "MTP_FORMAT_JFIF" },
112 { MTP_FORMAT_CD_CODE, "MTP_FORMAT_CD" },
113 { MTP_FORMAT_PICT_CODE, "MTP_FORMAT_PICT" },
114 { MTP_FORMAT_PNG_CODE, "MTP_FORMAT_PNG" },
115 { MTP_FORMAT_TIFF_CODE, "MTP_FORMAT_TIFF" },
116 { MTP_FORMAT_TIFF_IT_CODE, "MTP_FORMAT_TIFF_IT" },
117 { MTP_FORMAT_JP2_CODE, "MTP_FORMAT_JP2" },
118 { MTP_FORMAT_JPX_CODE, "MTP_FORMAT_JPX" },
119 { MTP_FORMAT_UNDEFINED_FIRMWARE_CODE, "MTP_FORMAT_UNDEFINED_FIRMWARE" },
120 { MTP_FORMAT_WINDOWS_IMAGE_FORMAT_CODE, "MTP_FORMAT_WINDOWS_IMAGE_FORMAT" },
121 { MTP_FORMAT_UNDEFINED_AUDIO_CODE, "MTP_FORMAT_UNDEFINED_AUDIO" },
122 { MTP_FORMAT_WMA_CODE, "MTP_FORMAT_WMA" },
123 { MTP_FORMAT_OGG_CODE, "MTP_FORMAT_OGG" },
124 { MTP_FORMAT_AAC_CODE, "MTP_FORMAT_AAC" },
125 { MTP_FORMAT_AUDIBLE_CODE, "MTP_FORMAT_AUDIBLE" },
126 { MTP_FORMAT_FLAC_CODE, "MTP_FORMAT_FLAC" },
127 { MTP_FORMAT_UNDEFINED_VIDEO_CODE, "MTP_FORMAT_UNDEFINED_VIDEO" },
128 { MTP_FORMAT_WMV_CODE, "MTP_FORMAT_WMV" },
129 { MTP_FORMAT_MP4_CONTAINER_CODE, "MTP_FORMAT_MP4_CONTAINER" },
130 { MTP_FORMAT_MP2_CODE, "MTP_FORMAT_MP2" },
131 { MTP_FORMAT_3GP_CONTAINER_CODE, "MTP_FORMAT_3GP_CONTAINER" },
132 { MTP_FORMAT_UNDEFINED_COLLECTION_CODE, "MTP_FORMAT_UNDEFINED_COLLECTION" },
133 { MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM" },
134 { MTP_FORMAT_ABSTRACT_IMAGE_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_IMAGE_ALBUM" },
135 { MTP_FORMAT_ABSTRACT_AUDIO_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_ALBUM" },
136 { MTP_FORMAT_ABSTRACT_VIDEO_ALBUM_CODE, "MTP_FORMAT_ABSTRACT_VIDEO_ALBUM" },
137 { MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_VIDEO_PLAYLIST" },
138 { MTP_FORMAT_ABSTRACT_CONTACT_GROUP_CODE, "MTP_FORMAT_ABSTRACT_CONTACT_GROUP" },
139 { MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER_CODE, "MTP_FORMAT_ABSTRACT_MESSAGE_FOLDER" },
140 { MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION_CODE, "MTP_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION" },
141 { MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_AUDIO_PLAYLIST" },
142 { MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST_CODE, "MTP_FORMAT_ABSTRACT_VIDEO_PLAYLIST" },
143 { MTP_FORMAT_ABSTRACT_MEDIACAST_CODE, "MTP_FORMAT_ABSTRACT_MEDIACAST" },
144 { MTP_FORMAT_WPL_PLAYLIST_CODE, "MTP_FORMAT_WPL_PLAYLIST" },
145 { MTP_FORMAT_M3U_PLAYLIST_CODE, "MTP_FORMAT_M3U_PLAYLIST" },
146 { MTP_FORMAT_MPL_PLAYLIST_CODE, "MTP_FORMAT_MPL_PLAYLIST" },
147 { MTP_FORMAT_ASX_PLAYLIST_CODE, "MTP_FORMAT_ASX_PLAYLIST" },
148 { MTP_FORMAT_PLS_PLAYLIST_CODE, "MTP_FORMAT_PLS_PLAYLIST" },
149 { MTP_FORMAT_UNDEFINED_DOCUMENT_CODE, "MTP_FORMAT_UNDEFINED_DOCUMENT" },
150 { MTP_FORMAT_ABSTRACT_DOCUMENT_CODE, "MTP_FORMAT_ABSTRACT_DOCUMENT" },
151 { MTP_FORMAT_XML_DOCUMENT_CODE, "MTP_FORMAT_XML_DOCUMENT" },
152 { MTP_FORMAT_MICROSOFT_WORD_DOCUMENT_CODE, "MTP_FORMAT_MICROSOFT_WORD_DOCUMENT" },
153 { MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT_CODE, "MTP_FORMAT_MHT_COMPILED_HTML_DOCUMENT" },
154 { MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET_CODE, "MTP_FORMAT_MICROSOFT_EXCEL_SPREADSHEET" },
155 { MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION_CODE, "MTP_FORMAT_MICROSOFT_POWERPOINT_PRESENTATION" },
156 { MTP_FORMAT_UNDEFINED_MESSAGE_CODE, "MTP_FORMAT_UNDEFINED_MESSAGE" },
157 { MTP_FORMAT_ABSTRACT_MESSAGE_CODE, "MTP_FORMAT_ABSTRACT_MESSAGE" },
158 { MTP_FORMAT_UNDEFINED_CONTACT_CODE, "MTP_FORMAT_UNDEFINED_CONTACT" },
159 { MTP_FORMAT_ABSTRACT_CONTACT_CODE, "MTP_FORMAT_ABSTRACT_CONTACT" },
160 { MTP_FORMAT_VCARD_2_CODE, "MTP_FORMAT_VCARD_2" },
161 };
162
163 static const std::map<uint32_t, std::string> ObjectPropMap = {
164 { MTP_PROPERTY_STORAGE_ID_CODE, "MTP_PROPERTY_STORAGE_ID" },
165 { MTP_PROPERTY_OBJECT_FORMAT_CODE, "MTP_PROPERTY_OBJECT_FORMAT" },
166 { MTP_PROPERTY_PROTECTION_STATUS_CODE, "MTP_PROPERTY_PROTECTION_STATUS" },
167 { MTP_PROPERTY_OBJECT_SIZE_CODE, "MTP_PROPERTY_OBJECT_SIZE" },
168 { MTP_PROPERTY_ASSOCIATION_TYPE_CODE, "MTP_PROPERTY_ASSOCIATION_TYPE" },
169 { MTP_PROPERTY_ASSOCIATION_DESC_CODE, "MTP_PROPERTY_ASSOCIATION_DESC" },
170 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, "MTP_PROPERTY_OBJECT_FILE_NAME" },
171 { MTP_PROPERTY_DATE_CREATED_CODE, "MTP_PROPERTY_DATE_CREATED" },
172 { MTP_PROPERTY_DATE_MODIFIED_CODE, "MTP_PROPERTY_DATE_MODIFIED" },
173 { MTP_PROPERTY_KEYWORDS_CODE, "MTP_PROPERTY_KEYWORDS" },
174 { MTP_PROPERTY_PARENT_OBJECT_CODE, "MTP_PROPERTY_PARENT_OBJECT" },
175 { MTP_PROPERTY_ALLOWED_FOLDER_CONTENTS_CODE, "MTP_PROPERTY_ALLOWED_FOLDER_CONTENTS" },
176 { MTP_PROPERTY_HIDDEN_CODE, "MTP_PROPERTY_HIDDEN" },
177 { MTP_PROPERTY_SYSTEM_OBJECT_CODE, "MTP_PROPERTY_SYSTEM_OBJECT" },
178 { MTP_PROPERTY_PERSISTENT_UID_CODE, "MTP_PROPERTY_PERSISTENT_UID" },
179 { MTP_PROPERTY_SYNCID_CODE, "MTP_PROPERTY_SYNCID" },
180 { MTP_PROPERTY_PROPERTY_BAG_CODE, "MTP_PROPERTY_PROPERTY_BAG" },
181 { MTP_PROPERTY_NAME_CODE, "MTP_PROPERTY_NAME" },
182 { MTP_PROPERTY_CREATED_BY_CODE, "MTP_PROPERTY_CREATED_BY" },
183 { MTP_PROPERTY_ARTIST_CODE, "MTP_PROPERTY_ARTIST" },
184 { MTP_PROPERTY_DATE_AUTHORED_CODE, "MTP_PROPERTY_DATE_AUTHORED" },
185 { MTP_PROPERTY_DESCRIPTION_CODE, "MTP_PROPERTY_DESCRIPTION" },
186 { MTP_PROPERTY_URL_REFERENCE_CODE, "MTP_PROPERTY_URL_REFERENCE" },
187 { MTP_PROPERTY_LANGUAG_LOCALE_CODE, "MTP_PROPERTY_LANGUAG_LOCALE" },
188 { MTP_PROPERTY_COPYRIGHT_INFORMATION_CODE, "MTP_PROPERTY_COPYRIGHT_INFORMATION" },
189 { MTP_PROPERTY_SOURCE_CODE, "MTP_PROPERTY_SOURCE" },
190 { MTP_PROPERTY_ORIGIN_LOCATION_CODE, "MTP_PROPERTY_ORIGIN_LOCATION" },
191 { MTP_PROPERTY_DATE_ADDED_CODE, "MTP_PROPERTY_DATE_ADDED" },
192 { MTP_PROPERTY_NO_CONSUMABLE_CODE, "MTP_PROPERTY_NO_CONSUMABLE" },
193 { MTP_PROPERTY_CORRUP_UNPLAYABLE_CODE, "MTP_PROPERTY_CORRUP_UNPLAYABLE" },
194 { MTP_PROPERTY_PRODUCERSERIALNUMBER_CODE, "MTP_PROPERTY_PRODUCERSERIALNUMBER" },
195 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_FORMAT_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_FORMAT" },
196 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_SIZE_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_SIZE" },
197 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_HEIGHT_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_HEIGHT" },
198 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_WIDTH_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_WIDTH" },
199 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DURATION_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DURATION" },
200 { MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DATA_CODE, "MTP_PROPERTY_REPRESENTATIVE_SAMPLE_DATA" },
201 { MTP_PROPERTY_WIDTH_CODE, "MTP_PROPERTY_WIDTH" },
202 { MTP_PROPERTY_HEIGHT_CODE, "MTP_PROPERTY_HEIGHT" },
203 { MTP_PROPERTY_DURATION_CODE, "MTP_PROPERTY_DURATION" },
204 { MTP_PROPERTY_RATING_CODE, "MTP_PROPERTY_RATING" },
205 { MTP_PROPERTY_TRACK_CODE, "MTP_PROPERTY_TRACK" },
206 { MTP_PROPERTY_GENRE_CODE, "MTP_PROPERTY_GENRE" },
207 { MTP_PROPERTY_CREDITS_CODE, "MTP_PROPERTY_CREDITS" },
208 { MTP_PROPERTY_LYRICS_CODE, "MTP_PROPERTY_LYRICS" },
209 { MTP_PROPERTY_SUBSCRIPTION_CONTENT_ID_CODE, "MTP_PROPERTY_SUBSCRIPTION_CONTENT_ID" },
210 { MTP_PROPERTY_PRODUCED_BY_CODE, "MTP_PROPERTY_PRODUCED_BY" },
211 { MTP_PROPERTY_USE_COUNT_CODE, "MTP_PROPERTY_USE_COUNT" },
212 { MTP_PROPERTY_SKIP_COUNT_CODE, "MTP_PROPERTY_SKIP_COUNT" },
213 { MTP_PROPERTY_LAST_ACCESSED_CODE, "MTP_PROPERTY_LAST_ACCESSED" },
214 { MTP_PROPERTY_PARENTAL_RATING_CODE, "MTP_PROPERTY_PARENTAL_RATING" },
215 { MTP_PROPERTY_META_GENRE_CODE, "MTP_PROPERTY_META_GENRE" },
216 { MTP_PROPERTY_COMPOSER_CODE, "MTP_PROPERTY_COMPOSER" },
217 { MTP_PROPERTY_EFFECTIVE_RATING_CODE, "MTP_PROPERTY_EFFECTIVE_RATING" },
218 { MTP_PROPERTY_SUBTITLE_CODE, "MTP_PROPERTY_SUBTITLE" },
219 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE_CODE, "MTP_PROPERTY_ORIGINAL_RELEASE_DATE" },
220 { MTP_PROPERTY_ALBUM_NAME_CODE, "MTP_PROPERTY_ALBUM_NAME" },
221 { MTP_PROPERTY_ALBUM_ARTIST_CODE, "MTP_PROPERTY_ALBUM_ARTIST" },
222 { MTP_PROPERTY_MOOD_CODE, "MTP_PROPERTY_MOOD" },
223 { MTP_PROPERTY_DRM_STATUS_CODE, "MTP_PROPERTY_DRM_STATUS" },
224 { MTP_PROPERTY_SUB_DESCRIPTION_CODE, "MTP_PROPERTY_SUB_DESCRIPTION" },
225 { MTP_PROPERTY_IS_CROPPED_CODE, "MTP_PROPERTY_IS_CROPPED" },
226 { MTP_PROPERTY_IS_COLOUR_CORRECTED_CODE, "MTP_PROPERTY_IS_COLOUR_CORRECTED" },
227 { MTP_PROPERTY_IMAGE_BIT_DEPTH_CODE, "MTP_PROPERTY_IMAGE_BIT_DEPTH" },
228 { MTP_PROPERTY_FNUMBER_CODE, "MTP_PROPERTY_FNUMBER" },
229 { MTP_PROPERTY_EXPOSURE_TIME_CODE, "MTP_PROPERTY_EXPOSURE_TIME" },
230 { MTP_PROPERTY_EXPOSURE_INDEX_CODE, "MTP_PROPERTY_EXPOSURE_INDEX" },
231 { MTP_PROPERTY_TOTAL_BITRATE_CODE, "MTP_PROPERTY_TOTAL_BITRATE" },
232 { MTP_PROPERTY_BITRATE_TYPE_CODE, "MTP_PROPERTY_BITRATE_TYPE" },
233 { MTP_PROPERTY_SAMPLE_RATE_CODE, "MTP_PROPERTY_SAMPLE_RATE" },
234 { MTP_PROPERTY_NUMBER_OF_CHANNELS_CODE, "MTP_PROPERTY_NUMBER_OF_CHANNELS" },
235 { MTP_PROPERTY_AUDIO_BITDEPTH_CODE, "MTP_PROPERTY_AUDIO_BITDEPTH" },
236 { MTP_PROPERTY_SCAN_TYPE_CODE, "MTP_PROPERTY_SCAN_TYPE" },
237 { MTP_PROPERTY_AUDIO_WAVE_CODEC_CODE, "MTP_PROPERTY_AUDIO_WAVE_CODEC" },
238 { MTP_PROPERTY_AUDIO_BITRATE_CODE, "MTP_PROPERTY_AUDIO_BITRATE" },
239 { MTP_PROPERTY_VIDEO_FOURCC_CODEC_CODE, "MTP_PROPERTY_VIDEO_FOURCC_CODEC" },
240 { MTP_PROPERTY_VIDEO_BITRATE_CODE, "MTP_PROPERTY_VIDEO_BITRATE" },
241 { MTP_PROPERTY_FRAMES_PER_THOUSAND_SECONDS_CODE, "MTP_PROPERTY_FRAMES_PER_THOUSAND_SECONDS" },
242 { MTP_PROPERTY_KEYFRAME_DISTANCE_CODE, "MTP_PROPERTY_KEYFRAME_DISTANCE" },
243 { MTP_PROPERTY_BUFFER_SIZE_CODE, "MTP_PROPERTY_BUFFER_SIZE" },
244 { MTP_PROPERTY_ENCODING_QUALITY_CODE, "MTP_PROPERTY_ENCODING_QUALITY" },
245 { MTP_PROPERTY_ENCODING_PROFILE_CODE, "MTP_PROPERTY_ENCODING_PROFILE" },
246 { MTP_PROPERTY_DISPLAY_NAME_CODE, "MTP_PROPERTY_DISPLAY_NAME" },
247 { MTP_PROPERTY_BODY_TEXT_CODE, "MTP_PROPERTY_BODY_TEXT" },
248 { MTP_PROPERTY_SUBJECT_CODE, "MTP_PROPERTY_SUBJECT" },
249 { MTP_PROPERTY_PRIORITY_CODE, "MTP_PROPERTY_PRIORITY" },
250 { MTP_PROPERTY_GIVEN_NAME_CODE, "MTP_PROPERTY_GIVEN_NAME" },
251 { MTP_PROPERTY_MIDDLE_NAMES_CODE, "MTP_PROPERTY_MIDDLE_NAMES" },
252 { MTP_PROPERTY_FAMILY_NAME_CODE, "MTP_PROPERTY_FAMILY_NAME" },
253 { MTP_PROPERTY_PREFIX_CODE, "MTP_PROPERTY_PREFIX" },
254 { MTP_PROPERTY_SUFFIX_CODE, "MTP_PROPERTY_SUFFIX" },
255 { MTP_PROPERTY_PHONETIC_GIVEN_NAME_CODE, "MTP_PROPERTY_PHONETIC_GIVEN_NAME" },
256 { MTP_PROPERTY_PHONETIC_FAMILY_NAME_CODE, "MTP_PROPERTY_PHONETIC_FAMILY_NAME" },
257 { MTP_PROPERTY_EMAIL_PRIMARY_CODE, "MTP_PROPERTY_EMAIL_PRIMARY" },
258 { MTP_PROPERTY_EMAIL_PERSONAL_1_CODE, "MTP_PROPERTY_EMAIL_PERSONAL_1" },
259 { MTP_PROPERTY_EMAIL_PERSONAL_2_CODE, "MTP_PROPERTY_EMAIL_PERSONAL_2" },
260 { MTP_PROPERTY_EMAIL_BUSINESS_1_CODE, "MTP_PROPERTY_EMAIL_BUSINESS_1" },
261 { MTP_PROPERTY_EMAIL_BUSINESS_2_CODE, "MTP_PROPERTY_EMAIL_BUSINESS_2" },
262 { MTP_PROPERTY_EMAIL_OTHERS_CODE, "MTP_PROPERTY_EMAIL_OTHERS" },
263 { MTP_PROPERTY_PHONE_NUMBER_PRIMARY_CODE, "MTP_PROPERTY_PHONE_NUMBER_PRIMARY" },
264 { MTP_PROPERTY_PHONE_NUMBER_PERSONAL_CODE, "MTP_PROPERTY_PHONE_NUMBER_PERSONAL" },
265 { MTP_PROPERTY_PHONE_NUMBER_PERSONAL_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_PERSONAL_2" },
266 { MTP_PROPERTY_PHONE_NUMBER_BUSINESS_CODE, "MTP_PROPERTY_PHONE_NUMBER_BUSINESS" },
267 { MTP_PROPERTY_PHONE_NUMBER_BUSINESS_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_BUSINESS_2" },
268 { MTP_PROPERTY_PHONE_NUMBER_MOBILE_CODE, "MTP_PROPERTY_PHONE_NUMBER_MOBILE" },
269 { MTP_PROPERTY_PHONE_NUMBER_MOBILE_2_CODE, "MTP_PROPERTY_PHONE_NUMBER_MOBILE_2" },
270 { MTP_PROPERTY_FAX_NUMBER_PRIMARY_CODE, "MTP_PROPERTY_FAX_NUMBER_PRIMARY" },
271 { MTP_PROPERTY_FAX_NUMBER_PERSONAL_CODE, "MTP_PROPERTY_FAX_NUMBER_PERSONAL" },
272 { MTP_PROPERTY_FAX_NUMBER_BUSINESS_CODE, "MTP_PROPERTY_FAX_NUMBER_BUSINESS" },
273 { MTP_PROPERTY_PAGER_NUMBER_CODE, "MTP_PROPERTY_PAGER_NUMBER" },
274 { MTP_PROPERTY_PHONE_NUMBER_OTHERS_CODE, "MTP_PROPERTY_PHONE_NUMBER_OTHERS" },
275 { MTP_PROPERTY_PRIMARY_WEB_ADDRESS_CODE, "MTP_PROPERTY_PRIMARY_WEB_ADDRESS" },
276 { MTP_PROPERTY_PERSONAL_WEB_ADDRESS_CODE, "MTP_PROPERTY_PERSONAL_WEB_ADDRESS" },
277 { MTP_PROPERTY_BUSINESS_WEB_ADDRESS_CODE, "MTP_PROPERTY_BUSINESS_WEB_ADDRESS" },
278 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS" },
279 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_2_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_2" },
280 { MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_3_CODE, "MTP_PROPERTY_INSTANT_MESSENGER_ADDRESS_3" },
281 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_FULL" },
282 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_1" },
283 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_LINE_2" },
284 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_CITY" },
285 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_REGION" },
286 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_POSTAL" },
287 { MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_PERSONAL_COUNTRY" },
288 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_FULL" },
289 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_1" },
290 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_LINE_2" },
291 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_CITY" },
292 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_REGION" },
293 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_POSTAL" },
294 { MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_BUSINESS_COUNTRY" },
295 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_FULL_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_FULL" },
296 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_1_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_1" },
297 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_2_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_LINE_2" },
298 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_CITY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_CITY" },
299 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_REGION_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_REGION" },
300 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_POSTAL_CODE_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_POSTAL" },
301 { MTP_PROPERTY_POSTAL_ADDRESS_OTHER_COUNTRY_CODE, "MTP_PROPERTY_POSTAL_ADDRESS_OTHER_COUNTRY" },
302 { MTP_PROPERTY_ORGANIZATION_NAME_CODE, "MTP_PROPERTY_ORGANIZATION_NAME" },
303 { MTP_PROPERTY_PHONETIC_ORGANIZATION_NAME_CODE, "MTP_PROPERTY_PHONETIC_ORGANIZATION_NAME" },
304 { MTP_PROPERTY_ROLE_CODE, "MTP_PROPERTY_ROLE" },
305 { MTP_PROPERTY_BIRTHDATE_CODE, "MTP_PROPERTY_BIRTHDATE" },
306 { MTP_PROPERTY_MESSAGE_TO_CODE, "MTP_PROPERTY_MESSAGE_TO" },
307 { MTP_PROPERTY_MESSAGE_CC_CODE, "MTP_PROPERTY_MESSAGE_CC" },
308 { MTP_PROPERTY_MESSAGE_BCC_CODE, "MTP_PROPERTY_MESSAGE_BCC" },
309 { MTP_PROPERTY_MESSAGE_READ_CODE, "MTP_PROPERTY_MESSAGE_READ" },
310 { MTP_PROPERTY_MESSAGE_RECEIVED_TIME_CODE, "MTP_PROPERTY_MESSAGE_RECEIVED_TIME" },
311 { MTP_PROPERTY_MESSAGE_SENDER_CODE, "MTP_PROPERTY_MESSAGE_SENDER" },
312 { MTP_PROPERTY_ACTIVITY_BEGIN_TIME_CODE, "MTP_PROPERTY_ACTIVITY_BEGIN_TIME" },
313 { MTP_PROPERTY_ACTIVITY_END_TIME_CODE, "MTP_PROPERTY_ACTIVITY_END_TIME" },
314 { MTP_PROPERTY_ACTIVITY_LOCATION_CODE, "MTP_PROPERTY_ACTIVITY_LOCATION" },
315 { MTP_PROPERTY_ACTIVITY_REQUIRED_ATTENDEES_CODE, "MTP_PROPERTY_ACTIVITY_REQUIRED_ATTENDEES" },
316 { MTP_PROPERTY_ACTIVITY_OPTIONAL_ATTENDEES_CODE, "MTP_PROPERTY_ACTIVITY_OPTIONAL_ATTENDEES" },
317 { MTP_PROPERTY_ACTIVITY_RESOURCES_CODE, "MTP_PROPERTY_ACTIVITY_RESOURCES" },
318 { MTP_PROPERTY_ACTIVITY_ACCEPTED_CODE, "MTP_PROPERTY_ACTIVITY_ACCEPTED" },
319 { MTP_PROPERTY_ACTIVITY_TENTATIVE_CODE, "MTP_PROPERTY_ACTIVITY_TENTATIVE" },
320 { MTP_PROPERTY_ACTIVITY_DECLINED_CODE, "MTP_PROPERTY_ACTIVITY_DECLINED" },
321 { MTP_PROPERTY_ACTIVITY_REMINDER_TIME_CODE, "MTP_PROPERTY_ACTIVITY_REMINDER_TIME" },
322 { MTP_PROPERTY_ACTIVITY_OWNER_CODE, "MTP_PROPERTY_ACTIVITY_OWNER" },
323 { MTP_PROPERTY_ACTIVITY_STATUS_CODE, "MTP_PROPERTY_ACTIVITY_STATUS" },
324 { MTP_PROPERTY_OWNER_CODE, "MTP_PROPERTY_OWNER" },
325 { MTP_PROPERTY_EDITOR_CODE, "MTP_PROPERTY_EDITOR" },
326 { MTP_PROPERTY_WEBMASTER_CODE, "MTP_PROPERTY_WEBMASTER" },
327 { MTP_PROPERTY_URL_SOURCE_CODE, "MTP_PROPERTY_URL_SOURCE" },
328 { MTP_PROPERTY_URL_DESTINATION_CODE, "MTP_PROPERTY_URL_DESTINATION" },
329 { MTP_PROPERTY_TIME_BOOKMARK_CODE, "MTP_PROPERTY_TIME_BOOKMARK" },
330 { MTP_PROPERTY_OBJECT_BOOKMARK_CODE, "MTP_PROPERTY_OBJECT_BOOKMARK" },
331 { MTP_PROPERTY_BYTE_BOOKMARK_CODE, "MTP_PROPERTY_BYTE_BOOKMARK" },
332 { MTP_PROPERTY_LAST_BUILD_DATE_CODE, "MTP_PROPERTY_LAST_BUILD_DATE" },
333 { MTP_PROPERTY_TIME_TO_LIVE_CODE, "MTP_PROPERTY_TIME_TO_LIVE" },
334 { MTP_PROPERTY_MEDIA_GUID_CODE, "MTP_PROPERTY_MEDIA_GUID" },
335 };
336
337 static const std::map<int, std::string> DataTypeMap = {
338 { MTP_TYPE_UNDEFINED_CODE, "MTP_TYPE_UNDEFINED" },
339 { MTP_TYPE_INT8_CODE, "MTP_TYPE_INT8" },
340 { MTP_TYPE_UINT8_CODE, "MTP_TYPE_UINT8" },
341 { MTP_TYPE_INT16_CODE, "MTP_TYPE_INT16" },
342 { MTP_TYPE_UINT16_CODE, "MTP_TYPE_UINT16" },
343 { MTP_TYPE_INT32_CODE, "MTP_TYPE_INT32" },
344 { MTP_TYPE_UINT32_CODE, "MTP_TYPE_UINT32" },
345 { MTP_TYPE_INT64_CODE, "MTP_TYPE_INT64" },
346 { MTP_TYPE_UINT64_CODE, "MTP_TYPE_UINT64" },
347 { MTP_TYPE_INT128_CODE, "MTP_TYPE_INT128" },
348 { MTP_TYPE_UINT128_CODE, "MTP_TYPE_UINT128" },
349 { MTP_TYPE_AINT8_CODE, "MTP_TYPE_AINT8" },
350 { MTP_TYPE_AUINT8_CODE, "MTP_TYPE_AUINT8" },
351 { MTP_TYPE_AINT16_CODE, "MTP_TYPE_AINT16" },
352 { MTP_TYPE_AUINT16_CODE, "MTP_TYPE_AUINT16" },
353 { MTP_TYPE_AINT32_CODE, "MTP_TYPE_AINT32" },
354 { MTP_TYPE_AUINT32_CODE, "MTP_TYPE_AUINT32" },
355 { MTP_TYPE_AINT64_CODE, "MTP_TYPE_AINT64" },
356 { MTP_TYPE_AUINT64_CODE, "MTP_TYPE_AUINT64" },
357 { MTP_TYPE_AINT128_CODE, "MTP_TYPE_AINT128" },
358 { MTP_TYPE_AUINT128_CODE, "MTP_TYPE_AUINT128" },
359 { MTP_TYPE_STRING_CODE, "MTP_TYPE_STRING" },
360 };
361
362 static const std::map<uint32_t, std::string> EventMap = {
363 { MTP_EVENT_UNDEFINED_CODE, "MTP_EVENT_UNDEFINED" },
364 { MTP_EVENT_CANCEL_TRANSACTION_CODE, "MTP_EVENT_CANCEL_TRANSACTION" },
365 { MTP_EVENT_OBJECT_ADDED_CODE, "MTP_EVENT_OBJECT_ADDED" },
366 { MTP_EVENT_OBJECT_REMOVED_CODE, "MTP_EVENT_OBJECT_REMOVED" },
367 { MTP_EVENT_STORE_ADDED_CODE, "MTP_EVENT_STORE_ADDED" },
368 { MTP_EVENT_STORE_REMOVED_CODE, "MTP_EVENT_STORE_REMOVED" },
369 { MTP_EVENT_DEVICE_PROP_CHANGED_CODE, "MTP_EVENT_DEVICE_PROP_CHANGED" },
370 { MTP_EVENT_OBJECT_INFO_CHANGED_CODE, "MTP_EVENT_OBJECT_INFO_CHANGED" },
371 { MTP_EVENT_DEVICE_INFO_CHANGED_CODE, "MTP_EVENT_DEVICE_INFO_CHANGED" },
372 { MTP_EVENT_REQUEST_OBJECT_TRANSFER_CODE, "MTP_EVENT_REQUEST_OBJECT_TRANSFER" },
373 { MTP_EVENT_STORE_FULL_CODE, "MTP_EVENT_STORE_FULL" },
374 { MTP_EVENT_DEVICE_RESET_CODE, "MTP_EVENT_DEVICE_RESET" },
375 { MTP_EVENT_STORAGE_INFO_CHANGED_CODE, "MTP_EVENT_STORAGE_INFO_CHANGED" },
376 { MTP_EVENT_CAPTURE_COMPLETE_CODE, "MTP_EVENT_CAPTURE_COMPLETE" },
377 { MTP_EVENT_UNREPORTED_STATUS_CODE, "MTP_EVENT_UNREPORTED_STATUS" },
378 { MTP_EVENT_OBJECT_PROP_CHANGED_CODE, "MTP_EVENT_OBJECT_PROP_CHANGED" },
379 { MTP_EVENT_OBJECT_PROP_DESC_CHANGED_CODE, "MTP_EVENT_OBJECT_PROP_DESC_CHANGED" },
380 { MTP_EVENT_OBJECT_REFERENCES_CHANGED_CODE, "MTP_EVENT_OBJECT_REFERENCES_CHANGED" },
381 };
382
383 static const std::map<uint16_t, int> ObjectPropTypeMap = {
384 { MTP_PROPERTY_STORAGE_ID_CODE, MTP_TYPE_UINT32_CODE },
385 { MTP_PROPERTY_OBJECT_FORMAT_CODE, MTP_TYPE_UINT16_CODE },
386 { MTP_PROPERTY_PROTECTION_STATUS_CODE, MTP_TYPE_UINT16_CODE },
387 { MTP_PROPERTY_OBJECT_SIZE_CODE, MTP_TYPE_UINT64_CODE },
388 { MTP_PROPERTY_OBJECT_FILE_NAME_CODE, MTP_TYPE_STRING_CODE },
389 { MTP_PROPERTY_DATE_MODIFIED_CODE, MTP_TYPE_STRING_CODE },
390 { MTP_PROPERTY_PARENT_OBJECT_CODE, MTP_TYPE_UINT32_CODE },
391 { MTP_PROPERTY_PERSISTENT_UID_CODE, MTP_TYPE_UINT128_CODE },
392 { MTP_PROPERTY_NAME_CODE, MTP_TYPE_STRING_CODE },
393 { MTP_PROPERTY_DISPLAY_NAME_CODE, MTP_TYPE_STRING_CODE },
394 { MTP_PROPERTY_DATE_ADDED_CODE, MTP_TYPE_STRING_CODE },
395 { MTP_PROPERTY_ARTIST_CODE, MTP_TYPE_STRING_CODE },
396 { MTP_PROPERTY_ALBUM_NAME_CODE, MTP_TYPE_STRING_CODE },
397 { MTP_PROPERTY_ALBUM_ARTIST_CODE, MTP_TYPE_STRING_CODE },
398 { MTP_PROPERTY_TRACK_CODE, MTP_TYPE_UINT16_CODE },
399 { MTP_PROPERTY_ORIGINAL_RELEASE_DATE_CODE, MTP_TYPE_STRING_CODE },
400 { MTP_PROPERTY_GENRE_CODE, MTP_TYPE_STRING_CODE },
401 { MTP_PROPERTY_COMPOSER_CODE, MTP_TYPE_STRING_CODE },
402 { MTP_PROPERTY_DURATION_CODE, MTP_TYPE_UINT32_CODE },
403 { MTP_PROPERTY_DESCRIPTION_CODE, MTP_TYPE_STRING_CODE },
404 { MTP_PROPERTY_AUDIO_WAVE_CODEC_CODE, MTP_TYPE_UINT32_CODE },
405 { MTP_PROPERTY_BITRATE_TYPE_CODE, MTP_TYPE_UINT16_CODE },
406 { MTP_PROPERTY_AUDIO_BITRATE_CODE, MTP_TYPE_UINT32_CODE },
407 { MTP_PROPERTY_NUMBER_OF_CHANNELS_CODE, MTP_TYPE_UINT16_CODE },
408 { MTP_PROPERTY_SAMPLE_RATE_CODE, MTP_TYPE_UINT32_CODE },
409 };
410 }
411
MtpPacketTool()412 MtpPacketTool::MtpPacketTool()
413 {
414 }
415
~MtpPacketTool()416 MtpPacketTool::~MtpPacketTool()
417 {
418 }
419
GetUInt16(uint8_t numFirst,uint8_t numSecond)420 uint16_t MtpPacketTool::GetUInt16(uint8_t numFirst, uint8_t numSecond)
421 {
422 return ((uint16_t)numSecond << BIT_8) | (uint16_t)numFirst;
423 }
424
GetUInt32(uint8_t numFirst,uint8_t numSecond,uint8_t numThird,uint8_t numFourth)425 uint32_t MtpPacketTool::GetUInt32(uint8_t numFirst, uint8_t numSecond, uint8_t numThird, uint8_t numFourth)
426 {
427 return ((uint32_t)numFourth << BIT_24) | ((uint32_t)numThird << BIT_16) | ((uint32_t)numSecond << BIT_8) |
428 (uint32_t)numFirst;
429 }
430
PutUInt8(std::vector<uint8_t> & outBuffer,uint16_t value)431 void MtpPacketTool::PutUInt8(std::vector<uint8_t> &outBuffer, uint16_t value)
432 {
433 outBuffer.push_back((uint8_t)(value & 0xFF));
434 }
435
PutUInt16(std::vector<uint8_t> & outBuffer,uint16_t value)436 void MtpPacketTool::PutUInt16(std::vector<uint8_t> &outBuffer, uint16_t value)
437 {
438 outBuffer.push_back((uint8_t)(value & 0xFF));
439 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
440 }
441
PutUInt32(std::vector<uint8_t> & outBuffer,uint32_t value)442 void MtpPacketTool::PutUInt32(std::vector<uint8_t> &outBuffer, uint32_t value)
443 {
444 outBuffer.push_back((uint8_t)(value & 0xFF));
445 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
446 outBuffer.push_back((uint8_t)((value >> BIT_16) & 0xFF));
447 outBuffer.push_back((uint8_t)((value >> BIT_24) & 0xFF));
448 }
449
PutUInt64(std::vector<uint8_t> & outBuffer,uint64_t value)450 void MtpPacketTool::PutUInt64(std::vector<uint8_t> &outBuffer, uint64_t value)
451 {
452 outBuffer.push_back((uint8_t)(value & 0xFF));
453 outBuffer.push_back((uint8_t)((value >> BIT_8) & 0xFF));
454 outBuffer.push_back((uint8_t)((value >> BIT_16) & 0xFF));
455 outBuffer.push_back((uint8_t)((value >> BIT_24) & 0xFF));
456 outBuffer.push_back((uint8_t)((value >> BIT_32) & 0xFF));
457 outBuffer.push_back((uint8_t)((value >> BIT_40) & 0xFF));
458 outBuffer.push_back((uint8_t)((value >> BIT_48) & 0xFF));
459 outBuffer.push_back((uint8_t)((value >> BIT_56) & 0xFF));
460 }
461
PutUInt128(std::vector<uint8_t> & outBuffer,uint64_t value)462 void MtpPacketTool::PutUInt128(std::vector<uint8_t> &outBuffer, uint64_t value)
463 {
464 PutUInt64(outBuffer, value);
465 PutUInt64(outBuffer, 0);
466 }
467
PutUInt128(std::vector<uint8_t> & outBuffer,const uint128_t value)468 void MtpPacketTool::PutUInt128(std::vector<uint8_t> &outBuffer, const uint128_t value)
469 {
470 PutUInt32(outBuffer, value[OFFSET_0]);
471 PutUInt32(outBuffer, value[OFFSET_1]);
472 PutUInt32(outBuffer, value[OFFSET_2]);
473 PutUInt32(outBuffer, value[OFFSET_3]);
474 }
475
PutAUInt16(std::vector<uint8_t> & outBuffer,const uint16_t * values,int count)476 void MtpPacketTool::PutAUInt16(std::vector<uint8_t> &outBuffer, const uint16_t *values, int count)
477 {
478 PutUInt32(outBuffer, count);
479 for (int i = 0; i < count; i++) {
480 PutUInt16(outBuffer, *values++);
481 }
482 }
483
PutAUInt32(std::vector<uint8_t> & outBuffer,const uint32_t * values,int count)484 void MtpPacketTool::PutAUInt32(std::vector<uint8_t> &outBuffer, const uint32_t *values, int count)
485 {
486 PutUInt32(outBuffer, count);
487 for (int i = 0; i < count; i++) {
488 PutUInt32(outBuffer, *values++);
489 }
490 }
491
PutInt8(std::vector<uint8_t> & outBuffer,int8_t value)492 void MtpPacketTool::PutInt8(std::vector<uint8_t> &outBuffer, int8_t value)
493 {
494 outBuffer.push_back(static_cast<uint8_t>(value));
495 }
496
PutInt16(std::vector<uint8_t> & outBuffer,int16_t value)497 void MtpPacketTool::PutInt16(std::vector<uint8_t> &outBuffer, int16_t value)
498 {
499 PutUInt16(outBuffer, static_cast<uint16_t>(value));
500 }
501
PutInt32(std::vector<uint8_t> & outBuffer,int32_t value)502 void MtpPacketTool::PutInt32(std::vector<uint8_t> &outBuffer, int32_t value)
503 {
504 PutUInt32(outBuffer, static_cast<uint32_t>(value));
505 }
506
PutInt64(std::vector<uint8_t> & outBuffer,int64_t value)507 void MtpPacketTool::PutInt64(std::vector<uint8_t> &outBuffer, int64_t value)
508 {
509 PutUInt64(outBuffer, static_cast<uint64_t>(value));
510 }
511
PutInt128(std::vector<uint8_t> & outBuffer,int64_t value)512 void MtpPacketTool::PutInt128(std::vector<uint8_t> &outBuffer, int64_t value)
513 {
514 PutUInt64(outBuffer, static_cast<uint64_t>(value));
515 PutUInt64(outBuffer, static_cast<uint64_t>(value < 0 ? -1 : 0));
516 }
517
PutInt128(std::vector<uint8_t> & outBuffer,const int128_t value)518 void MtpPacketTool::PutInt128(std::vector<uint8_t> &outBuffer, const int128_t value)
519 {
520 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_0]));
521 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_1]));
522 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_2]));
523 PutUInt32(outBuffer, static_cast<uint32_t>(value[OFFSET_3]));
524 }
525
PutString(std::vector<uint8_t> & outBuffer,const std::string & string)526 void MtpPacketTool::PutString(std::vector<uint8_t> &outBuffer, const std::string &string)
527 {
528 std::u16string src16 = Utf8ToUtf16(string);
529
530 uint16_t count = src16.length();
531 if (count == 0) {
532 PutUInt8(outBuffer, 0);
533 return;
534 }
535 PutUInt8(outBuffer, std::min(count + 1, MAX_LENGTH));
536
537 int i = 0;
538 for (char16_t &c : src16) {
539 if (i == MAX_LENGTH - 1) {
540 break;
541 }
542 PutUInt16(outBuffer, c);
543 i++;
544 }
545 PutUInt16(outBuffer, 0);
546 }
547
548 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> gConvert(UTF16_CERROR, UTF8_CERROR);
549
Utf8ToUtf16(const std::string & inputStr)550 std::u16string MtpPacketTool::Utf8ToUtf16(const std::string &inputStr)
551 {
552 std::u16string conversion = gConvert.from_bytes(inputStr);
553 if (conversion == UTF8_CERROR) {
554 return u"";
555 } else {
556 return conversion;
557 }
558 }
559
Utf16ToUtf8(const std::u16string & inputStr)560 std::string MtpPacketTool::Utf16ToUtf8(const std::u16string &inputStr)
561 {
562 std::string conversion = gConvert.to_bytes(inputStr);
563 if (conversion == UTF16_CERROR) {
564 return "";
565 } else {
566 return conversion;
567 }
568 }
569
GetUInt8(const std::vector<uint8_t> & buffer,size_t & offset)570 uint8_t MtpPacketTool::GetUInt8(const std::vector<uint8_t> &buffer, size_t &offset)
571 {
572 uint8_t value = (uint16_t)buffer[offset];
573 offset += sizeof(uint8_t);
574 return value;
575 }
576
GetUInt16(const std::vector<uint8_t> & buffer,size_t & offset)577 uint16_t MtpPacketTool::GetUInt16(const std::vector<uint8_t> &buffer, size_t &offset)
578 {
579 uint16_t value = (uint16_t)buffer[offset] | ((uint16_t)buffer[offset + OFFSET_1] << BIT_8);
580 offset += sizeof(uint16_t);
581 return value;
582 }
583
GetUInt32(const std::vector<uint8_t> & buffer,size_t & offset)584 uint32_t MtpPacketTool::GetUInt32(const std::vector<uint8_t> &buffer, size_t &offset)
585 {
586 uint32_t value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8) |
587 ((uint32_t)buffer[offset + OFFSET_2] << BIT_16) | ((uint32_t)buffer[offset + OFFSET_3] << BIT_24);
588 offset += sizeof(uint32_t);
589 return value;
590 }
591
GetUInt8(const std::vector<uint8_t> & buffer,size_t & offset,uint8_t & value)592 bool MtpPacketTool::GetUInt8(const std::vector<uint8_t> &buffer, size_t &offset, uint8_t &value)
593 {
594 if (buffer.size() < sizeof(uint8_t) + offset) {
595 MEDIA_ERR_LOG("MtpPacketTool::GetUInt8, size incorrect");
596 return false;
597 }
598
599 value = buffer[offset];
600 offset += sizeof(uint8_t);
601 return true;
602 }
603
GetUInt16(const std::vector<uint8_t> & buffer,size_t & offset,uint16_t & value)604 bool MtpPacketTool::GetUInt16(const std::vector<uint8_t> &buffer, size_t &offset, uint16_t &value)
605 {
606 if (buffer.size() < sizeof(uint16_t) + offset) {
607 MEDIA_ERR_LOG("MtpPacketTool::GetUInt16, size incorrect");
608 return false;
609 }
610
611 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8);
612 offset += sizeof(uint16_t);
613 return true;
614 }
615
GetUInt32(const std::vector<uint8_t> & buffer,size_t & offset,uint32_t & value)616 bool MtpPacketTool::GetUInt32(const std::vector<uint8_t> &buffer, size_t &offset, uint32_t &value)
617 {
618 if (buffer.size() < sizeof(uint32_t) + offset) {
619 MEDIA_ERR_LOG("MtpPacketTool::GetUInt32, size incorrect");
620 return false;
621 }
622
623 value = (uint32_t)buffer[offset] | ((uint32_t)buffer[offset + OFFSET_1] << BIT_8) |
624 ((uint32_t)buffer[offset + OFFSET_2] << BIT_16) | ((uint32_t)buffer[offset + OFFSET_3] << BIT_24);
625 offset += sizeof(uint32_t);
626 return true;
627 }
628
GetUInt64(const std::vector<uint8_t> & buffer,size_t & offset,uint64_t & value)629 bool MtpPacketTool::GetUInt64(const std::vector<uint8_t> &buffer, size_t &offset, uint64_t &value)
630 {
631 if (buffer.size() < sizeof(uint64_t) + offset) {
632 MEDIA_ERR_LOG("MtpPacketTool::GetUInt64, size incorrect");
633 return false;
634 }
635
636 value = buffer[offset] | (buffer[offset + OFFSET_1] << BIT_8) | (buffer[offset + OFFSET_2] << BIT_16) |
637 (buffer[offset + OFFSET_3] << BIT_24) | (static_cast<uint64_t>(buffer[offset + OFFSET_4]) << BIT_32) |
638 (static_cast<uint64_t>(buffer[offset + OFFSET_5]) << BIT_40) |
639 (static_cast<uint64_t>(buffer[offset + OFFSET_6]) << BIT_48) |
640 (static_cast<uint64_t>(buffer[offset + OFFSET_7]) << BIT_56);
641 offset += sizeof(uint64_t);
642 return true;
643 }
644
GetUInt128(const std::vector<uint8_t> & buffer,size_t & offset,uint128_t & value)645 bool MtpPacketTool::GetUInt128(const std::vector<uint8_t> &buffer, size_t &offset, uint128_t &value)
646 {
647 if (!GetUInt32(buffer, offset, value[OFFSET_0]) || !GetUInt32(buffer, offset, value[OFFSET_1]) ||
648 !GetUInt32(buffer, offset, value[OFFSET_2]) || !GetUInt32(buffer, offset, value[OFFSET_3])) {
649 return false;
650 }
651 return true;
652 }
653
GetInt8(const std::vector<uint8_t> & buffer,size_t & offset,int8_t & value)654 bool MtpPacketTool::GetInt8(const std::vector<uint8_t> &buffer, size_t &offset, int8_t &value)
655 {
656 uint8_t uValue = 0;
657 if (!GetUInt8(buffer, offset, uValue)) {
658 return false;
659 }
660 value = static_cast<int8_t>(uValue);
661 return true;
662 }
663
GetInt16(const std::vector<uint8_t> & buffer,size_t & offset,int16_t & value)664 bool MtpPacketTool::GetInt16(const std::vector<uint8_t> &buffer, size_t &offset, int16_t &value)
665 {
666 uint16_t uValue = 0;
667 if (!GetUInt16(buffer, offset, uValue)) {
668 return false;
669 }
670 value = static_cast<int16_t>(uValue);
671 return true;
672 }
673
GetInt32(const std::vector<uint8_t> & buffer,size_t & offset,int32_t & value)674 bool MtpPacketTool::GetInt32(const std::vector<uint8_t> &buffer, size_t &offset, int32_t &value)
675 {
676 uint32_t uValue = 0;
677 if (!GetUInt32(buffer, offset, uValue)) {
678 return false;
679 }
680 value = static_cast<int32_t>(uValue);
681 return true;
682 }
GetInt64(const std::vector<uint8_t> & buffer,size_t & offset,int64_t & value)683 bool MtpPacketTool::GetInt64(const std::vector<uint8_t> &buffer, size_t &offset, int64_t &value)
684 {
685 uint64_t uValue = 0;
686 if (!GetUInt64(buffer, offset, uValue)) {
687 return false;
688 }
689 value = static_cast<int64_t>(uValue);
690 return true;
691 }
692
GetInt128(const std::vector<uint8_t> & buffer,size_t & offset,int128_t & value)693 bool MtpPacketTool::GetInt128(const std::vector<uint8_t> &buffer, size_t &offset, int128_t &value)
694 {
695 uint128_t uValue = {0};
696 if (!GetUInt32(buffer, offset, uValue[OFFSET_0]) || !GetUInt32(buffer, offset, uValue[OFFSET_1]) ||
697 !GetUInt32(buffer, offset, uValue[OFFSET_2]) || !GetUInt32(buffer, offset, uValue[OFFSET_3])) {
698 return false;
699 }
700 value[OFFSET_0] = static_cast<int32_t>(uValue[OFFSET_0]);
701 value[OFFSET_1] = static_cast<int32_t>(uValue[OFFSET_1]);
702 value[OFFSET_2] = static_cast<int32_t>(uValue[OFFSET_2]);
703 value[OFFSET_3] = static_cast<int32_t>(uValue[OFFSET_3]);
704 return true;
705 }
706
GetAUInt16(const std::vector<uint8_t> & buffer,size_t & offset)707 std::shared_ptr<UInt16List> MtpPacketTool::GetAUInt16(const std::vector<uint8_t> &buffer, size_t &offset)
708 {
709 std::shared_ptr<UInt16List> result = std::make_shared<UInt16List>();
710
711 uint32_t count = GetUInt32(buffer, offset);
712 uint16_t value = 0;
713 for (uint32_t i = 0; i < count; i++) {
714 if (!GetUInt16(buffer, offset, value)) {
715 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt16, count=%{public}d, i=%{public}d", count, i);
716 break;
717 }
718 result->push_back(value);
719 }
720
721 return result;
722 }
723
GetAUInt32(const std::vector<uint8_t> & buffer,size_t & offset)724 std::shared_ptr<UInt32List> MtpPacketTool::GetAUInt32(const std::vector<uint8_t> &buffer, size_t &offset)
725 {
726 std::shared_ptr<UInt32List> result = std::make_shared<UInt32List>();
727
728 uint32_t count = GetUInt32(buffer, offset);
729 uint32_t value = 0;
730 for (uint32_t i = 0; i < count; i++) {
731 if (!GetUInt32(buffer, offset, value)) {
732 MEDIA_ERR_LOG("MtpPacketTool::GetAUInt32, count=%{public}d, i=%{public}d", count, i);
733 break;
734 }
735 result->push_back(value);
736 }
737
738 return result;
739 }
740
GetString(const std::vector<uint8_t> & buffer,size_t & offset)741 std::string MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset)
742 {
743 uint8_t count = GetUInt8(buffer, offset);
744 if (count < 1) {
745 return std::string();
746 }
747 std::vector<char16_t> tmpbuf(count);
748 uint16_t ch = 0;
749 for (int i = 0; i < count; i++) {
750 ch = GetUInt16(buffer, offset);
751 tmpbuf[i] = ch;
752 }
753 std::string String = Utf16ToUtf8(std::u16string(tmpbuf.data()));
754 return String;
755 }
756
GetString(const std::vector<uint8_t> & buffer,size_t & offset,std::string & str)757 bool MtpPacketTool::GetString(const std::vector<uint8_t> &buffer, size_t &offset, std::string &str)
758 {
759 uint8_t count = 0;
760 if (!GetUInt8(buffer, offset, count)) {
761 return false;
762 }
763
764 if (count < 1) {
765 str = std::string();
766 return true;
767 }
768
769 std::vector<char16_t> tmpbuf(count);
770 uint16_t ch = 0;
771 for (int i = 0; ((i < count) && ((offset + sizeof(uint16_t) - 1) < buffer.size())); i++) {
772 if (!GetUInt16(buffer, offset, ch)) {
773 return false;
774 }
775 tmpbuf[i] = ch;
776 }
777
778 str = Utf16ToUtf8(std::u16string(tmpbuf.data()));
779 return true;
780 }
781
FormatDateTime(time_t sec)782 std::string MtpPacketTool::FormatDateTime(time_t sec)
783 {
784 struct tm tm;
785 char buffer[TIME_LENGTH] = {0};
786 localtime_r(&sec, &tm);
787 if (sprintf_s(buffer, sizeof(buffer), "%04d%02d%02dT%02d%02d%02d", tm.tm_year + BEGIN_YEAR, tm.tm_mon + 1,
788 tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec) == -1) {
789 return "";
790 }
791 return std::string(buffer);
792 }
793
GetOperationName(uint16_t code)794 const std::string &MtpPacketTool::GetOperationName(uint16_t code)
795 {
796 return CodeToStrByMap(code, OperationMap);
797 }
798
GetFormatName(uint16_t code)799 const std::string &MtpPacketTool::GetFormatName(uint16_t code)
800 {
801 return CodeToStrByMap(code, FormatMap);
802 }
803
GetObjectPropName(uint16_t code)804 const std::string &MtpPacketTool::GetObjectPropName(uint16_t code)
805 {
806 return CodeToStrByMap(code, ObjectPropMap);
807 }
808
GetDataTypeName(int type)809 const std::string &MtpPacketTool::GetDataTypeName(int type)
810 {
811 return CodeToStrByMap(type, DataTypeMap);
812 }
813
GetEventName(uint16_t code)814 const std::string &MtpPacketTool::GetEventName(uint16_t code)
815 {
816 return CodeToStrByMap(code, EventMap);
817 }
818
GetAssociationName(int type)819 const std::string &MtpPacketTool::GetAssociationName(int type)
820 {
821 return CodeToStrByMap(type, AssociationMap);
822 }
823
CodeToStrByMap(int type,const std::map<int,std::string> & theMap)824 const std::string &MtpPacketTool::CodeToStrByMap(int type, const std::map<int, std::string> &theMap)
825 {
826 auto codeSearch = theMap.find(type);
827 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
828 }
829
CodeToStrByMap(uint32_t code,const std::map<uint32_t,std::string> & theMap)830 const std::string &MtpPacketTool::CodeToStrByMap(uint32_t code, const std::map<uint32_t, std::string> &theMap)
831 {
832 auto codeSearch = theMap.find(code);
833 return (codeSearch != theMap.end()) ? codeSearch->second : UNKNOWN_STR;
834 }
835
GetObjectPropTypeByPropCode(uint16_t propCode)836 int MtpPacketTool::GetObjectPropTypeByPropCode(uint16_t propCode)
837 {
838 auto propCodeSearch = ObjectPropTypeMap.find(propCode);
839 return (propCodeSearch != ObjectPropTypeMap.end()) ? propCodeSearch->second : MTP_TYPE_UNDEFINED_CODE;
840 }
841
Int8ToString(const int8_t & value,std::string & outStr)842 bool MtpPacketTool::Int8ToString(const int8_t &value, std::string &outStr)
843 {
844 char tmpbuf[BIT_32] = {0};
845 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%d", value, value) == -1) {
846 return false;
847 }
848 outStr.assign(tmpbuf);
849 return true;
850 }
851
UInt8ToString(const uint8_t & value,std::string & outStr)852 bool MtpPacketTool::UInt8ToString(const uint8_t &value, std::string &outStr)
853 {
854 char tmpbuf[BIT_32] = {0};
855 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%02x, dec=%u", value, value) == -1) {
856 return false;
857 }
858 outStr.assign(tmpbuf);
859 return true;
860 }
861
Int16ToString(const int16_t & value,std::string & outStr)862 bool MtpPacketTool::Int16ToString(const int16_t &value, std::string &outStr)
863 {
864 char tmpbuf[BIT_32] = {0};
865 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%d", value, value) == -1) {
866 return false;
867 }
868 outStr.assign(tmpbuf);
869 return true;
870 }
871
UInt16ToString(const uint16_t & value,std::string & outStr)872 bool MtpPacketTool::UInt16ToString(const uint16_t &value, std::string &outStr)
873 {
874 char tmpbuf[BIT_32] = {0};
875 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%04x, dec=%u", value, value) == -1) {
876 return false;
877 }
878 outStr.assign(tmpbuf);
879 return true;
880 }
881
Int32ToString(const int32_t & value,std::string & outStr)882 bool MtpPacketTool::Int32ToString(const int32_t &value, std::string &outStr)
883 {
884 char tmpbuf[BIT_64] = {0};
885 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%d", value, value) == -1) {
886 return false;
887 }
888 outStr.assign(tmpbuf);
889 return true;
890 }
891
UInt32ToString(const uint32_t & value,std::string & outStr)892 bool MtpPacketTool::UInt32ToString(const uint32_t &value, std::string &outStr)
893 {
894 char tmpbuf[BIT_64] = {0};
895 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%08x, dec=%u", value, value) == -1) {
896 return false;
897 }
898 outStr.assign(tmpbuf);
899 return true;
900 }
901
Int64ToString(const int64_t & value,std::string & outStr)902 bool MtpPacketTool::Int64ToString(const int64_t &value, std::string &outStr)
903 {
904 char tmpbuf[BIT_64] = {0};
905 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIi64 "", value, value) == -1) {
906 return false;
907 }
908 outStr.assign(tmpbuf);
909 return true;
910 }
911
UInt64ToString(const uint64_t & value,std::string & outStr)912 bool MtpPacketTool::UInt64ToString(const uint64_t &value, std::string &outStr)
913 {
914 char tmpbuf[BIT_64] = {0};
915 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=%016" PRIx64 ", dec=%" PRIu64 "", value, value) == -1) {
916 return false;
917 }
918 outStr.assign(tmpbuf);
919 return true;
920 }
921
Int128ToString(const int128_t & value,std::string & outStr)922 bool MtpPacketTool::Int128ToString(const int128_t &value, std::string &outStr)
923 {
924 char tmpbuf[BIT_128] = {0};
925 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%d,%d,%d,%d)", value[OFFSET_0],
926 value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1], value[OFFSET_2],
927 value[OFFSET_3]) == -1) {
928 return false;
929 }
930 outStr.assign(tmpbuf);
931 return true;
932 }
933
UInt128ToString(const uint128_t & value,std::string & outStr)934 bool MtpPacketTool::UInt128ToString(const uint128_t &value, std::string &outStr)
935 {
936 char tmpbuf[BIT_128] = {0};
937 if (sprintf_s(tmpbuf, sizeof(tmpbuf), "hex=(%08x,%08x,%08x,%08x), dec=(%u,%u,%u,%u)", value[OFFSET_0],
938 value[OFFSET_1], value[OFFSET_2], value[OFFSET_3], value[OFFSET_0], value[OFFSET_1], value[OFFSET_2],
939 value[OFFSET_3]) == -1) {
940 return false;
941 }
942 outStr.assign(tmpbuf);
943 return true;
944 }
945
StrToString(const std::string & value)946 std::string MtpPacketTool::StrToString(const std::string &value)
947 {
948 std::string str;
949 str.append("length:");
950 str.append(std::to_string(value.length()));
951 str.append(", content:[");
952 str.append(value);
953 str.append("]");
954 return str;
955 }
956
GetIndentBlank()957 const std::string &MtpPacketTool::GetIndentBlank()
958 {
959 return INDENT_BLANKSTR;
960 }
961
GetIndentBlank(size_t indent)962 std::string MtpPacketTool::GetIndentBlank(size_t indent)
963 {
964 size_t maxNum = BLANK_STR.length();
965 size_t num = indent * INDENT_SIZE;
966
967 std::string indentStr = BLANK_STR.substr(0, ((num > maxNum) ? maxNum : num));
968 return indentStr;
969 }
970
Dump(const std::vector<uint8_t> & data,uint32_t offset,uint32_t sum)971 void MtpPacketTool::Dump(const std::vector<uint8_t> &data, uint32_t offset, uint32_t sum)
972 {
973 std::unique_ptr<char[]> hexBuf = std::make_unique<char[]>(DUMP_HEXBUF_MAX);
974 std::unique_ptr<char[]> txtBuf = std::make_unique<char[]>(DUMP_TXTBUF_MAX);
975 if (!DumpClear(offset, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
976 return;
977 }
978 const size_t datasize = data.size();
979 for (size_t loc = 0, cur = offset; ((loc < sum) && (cur < datasize)); loc++, cur++) {
980 if (!DumpChar(data[cur], hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
981 return;
982 }
983 size_t idx = (loc & BUF_0F);
984 if (strcat_s(hexBuf.get(), DUMP_HEXBUF_MAX, ((idx != BUF_07) ? " " : "-")) != EOK) {
985 return;
986 }
987 if (idx != BUF_0F) {
988 continue;
989 }
990 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
991 if (!DumpClear(loc + 1, hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX)) {
992 return;
993 }
994 }
995 DumpShow(hexBuf, DUMP_HEXBUF_MAX, txtBuf, DUMP_TXTBUF_MAX);
996 }
997
DumpClear(size_t loc,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)998 bool MtpPacketTool::DumpClear(size_t loc, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
999 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1000 {
1001 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1002 return false;
1003 }
1004
1005 if (sprintf_s(hexBuf.get(), hexBufSize, "%08X : ", static_cast<uint32_t>(loc)) == -1) {
1006 return false;
1007 }
1008 if (sprintf_s(txtBuf.get(), txtBufSize, "%s", "") == -1) {
1009 return false;
1010 }
1011 return true;
1012 }
1013
DumpChar(uint8_t u8,std::unique_ptr<char[]> & hexBuf,int hexBufSize,std::unique_ptr<char[]> & txtBuf,int txtBufSize)1014 bool MtpPacketTool::DumpChar(uint8_t u8, std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1015 std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1016 {
1017 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1018 return false;
1019 }
1020
1021 char hexTmp[BIT_4] = {0};
1022 if (sprintf_s(hexTmp, sizeof(hexTmp), "%02X", u8) == -1) {
1023 return false;
1024 }
1025
1026 int intData = static_cast<int>(u8);
1027 char txtTmp[BIT_4] = {0};
1028 if (isprint(intData)) {
1029 if (sprintf_s(txtTmp, sizeof(txtTmp), "%d", intData) == -1) {
1030 return false;
1031 }
1032 } else {
1033 if (sprintf_s(txtTmp, sizeof(txtTmp), "%c", '.') == -1) {
1034 return false;
1035 }
1036 }
1037
1038 if (strcat_s(hexBuf.get(), hexBufSize, hexTmp) != EOK) {
1039 return false;
1040 }
1041 if (strcat_s(txtBuf.get(), txtBufSize, txtTmp) != EOK) {
1042 return false;
1043 }
1044 return true;
1045 }
1046
DumpShow(const std::unique_ptr<char[]> & hexBuf,int hexBufSize,const std::unique_ptr<char[]> & txtBuf,int txtBufSize)1047 void MtpPacketTool::DumpShow(const std::unique_ptr<char[]> &hexBuf, int hexBufSize,
1048 const std::unique_ptr<char[]> &txtBuf, int txtBufSize)
1049 {
1050 if ((hexBuf == nullptr) || (txtBuf == nullptr)) {
1051 return;
1052 }
1053 if ((hexBuf[OFFSET_0] == '\0') || (txtBuf[OFFSET_0] == '\0')) {
1054 return;
1055 }
1056
1057 MEDIA_DEBUG_LOG("%-60s %s", hexBuf.get(), txtBuf.get());
1058 }
1059 } // namespace Media
1060 } // namespace OHOS