Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #ifndef LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_ |
| 18 | #define LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_ |
| 19 | |
Elliott Hughes | 53039d6 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 20 | #include "android-base/macros.h" |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 21 | |
| 22 | #include <inttypes.h> |
| 23 | |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 24 | #include <optional> |
| 25 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 26 | // The "end of central directory" (EOCD) record. Each archive |
| 27 | // contains exactly once such record which appears at the end of |
| 28 | // the archive. It contains archive wide information like the |
| 29 | // number of entries in the archive and the offset to the central |
| 30 | // directory of the offset. |
| 31 | struct EocdRecord { |
| 32 | static const uint32_t kSignature = 0x06054b50; |
| 33 | |
| 34 | // End of central directory signature, should always be |
| 35 | // |kSignature|. |
| 36 | uint32_t eocd_signature; |
| 37 | // The number of the current "disk", i.e, the "disk" that this |
| 38 | // central directory is on. |
| 39 | // |
| 40 | // This implementation assumes that each archive spans a single |
| 41 | // disk only. i.e, that disk_num == 1. |
| 42 | uint16_t disk_num; |
| 43 | // The disk where the central directory starts. |
| 44 | // |
| 45 | // This implementation assumes that each archive spans a single |
| 46 | // disk only. i.e, that cd_start_disk == 1. |
| 47 | uint16_t cd_start_disk; |
| 48 | // The number of central directory records on this disk. |
| 49 | // |
| 50 | // This implementation assumes that each archive spans a single |
| 51 | // disk only. i.e, that num_records_on_disk == num_records. |
| 52 | uint16_t num_records_on_disk; |
| 53 | // The total number of central directory records. |
| 54 | uint16_t num_records; |
| 55 | // The size of the central directory (in bytes). |
| 56 | uint32_t cd_size; |
| 57 | // The offset of the start of the central directory, relative |
| 58 | // to the start of the file. |
| 59 | uint32_t cd_start_offset; |
| 60 | // Length of the central directory comment. |
| 61 | uint16_t comment_length; |
Jiyong Park | 6821cc8 | 2017-06-30 17:23:33 +0900 | [diff] [blame] | 62 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 63 | EocdRecord() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 64 | |
| 65 | private: |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 66 | DISALLOW_COPY_AND_ASSIGN(EocdRecord); |
| 67 | } __attribute__((packed)); |
| 68 | |
| 69 | // A structure representing the fixed length fields for a single |
| 70 | // record in the central directory of the archive. In addition to |
| 71 | // the fixed length fields listed here, each central directory |
| 72 | // record contains a variable length "file_name" and "extra_field" |
| 73 | // whose lengths are given by |file_name_length| and |extra_field_length| |
| 74 | // respectively. |
| 75 | struct CentralDirectoryRecord { |
| 76 | static const uint32_t kSignature = 0x02014b50; |
| 77 | |
| 78 | // The start of record signature. Must be |kSignature|. |
| 79 | uint32_t record_signature; |
Elliott Hughes | 6702cef | 2017-05-28 22:59:04 -0700 | [diff] [blame] | 80 | // Source tool version. Top byte gives source OS. |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 81 | uint16_t version_made_by; |
| 82 | // Tool version. Ignored by this implementation. |
| 83 | uint16_t version_needed; |
| 84 | // The "general purpose bit flags" for this entry. The only |
| 85 | // flag value that we currently check for is the "data descriptor" |
| 86 | // flag. |
| 87 | uint16_t gpb_flags; |
| 88 | // The compression method for this entry, one of |kCompressStored| |
| 89 | // and |kCompressDeflated|. |
| 90 | uint16_t compression_method; |
| 91 | // The file modification time and date for this entry. |
| 92 | uint16_t last_mod_time; |
| 93 | uint16_t last_mod_date; |
| 94 | // The CRC-32 checksum for this entry. |
| 95 | uint32_t crc32; |
| 96 | // The compressed size (in bytes) of this entry. |
| 97 | uint32_t compressed_size; |
| 98 | // The uncompressed size (in bytes) of this entry. |
| 99 | uint32_t uncompressed_size; |
| 100 | // The length of the entry file name in bytes. The file name |
| 101 | // will appear immediately after this record. |
| 102 | uint16_t file_name_length; |
| 103 | // The length of the extra field info (in bytes). This data |
| 104 | // will appear immediately after the entry file name. |
| 105 | uint16_t extra_field_length; |
| 106 | // The length of the entry comment (in bytes). This data will |
| 107 | // appear immediately after the extra field. |
| 108 | uint16_t comment_length; |
| 109 | // The start disk for this entry. Ignored by this implementation). |
| 110 | uint16_t file_start_disk; |
| 111 | // File attributes. Ignored by this implementation. |
| 112 | uint16_t internal_file_attributes; |
Elliott Hughes | 6702cef | 2017-05-28 22:59:04 -0700 | [diff] [blame] | 113 | // File attributes. For archives created on Unix, the top bits are the mode. |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 114 | uint32_t external_file_attributes; |
| 115 | // The offset to the local file header for this entry, from the |
| 116 | // beginning of this archive. |
| 117 | uint32_t local_file_header_offset; |
Jiyong Park | 6821cc8 | 2017-06-30 17:23:33 +0900 | [diff] [blame] | 118 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 119 | CentralDirectoryRecord() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 120 | |
| 121 | private: |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 122 | DISALLOW_COPY_AND_ASSIGN(CentralDirectoryRecord); |
| 123 | } __attribute__((packed)); |
| 124 | |
| 125 | // The local file header for a given entry. This duplicates information |
| 126 | // present in the central directory of the archive. It is an error for |
| 127 | // the information here to be different from the central directory |
| 128 | // information for a given entry. |
| 129 | struct LocalFileHeader { |
| 130 | static const uint32_t kSignature = 0x04034b50; |
| 131 | |
| 132 | // The local file header signature, must be |kSignature|. |
| 133 | uint32_t lfh_signature; |
| 134 | // Tool version. Ignored by this implementation. |
| 135 | uint16_t version_needed; |
| 136 | // The "general purpose bit flags" for this entry. The only |
| 137 | // flag value that we currently check for is the "data descriptor" |
| 138 | // flag. |
| 139 | uint16_t gpb_flags; |
| 140 | // The compression method for this entry, one of |kCompressStored| |
| 141 | // and |kCompressDeflated|. |
| 142 | uint16_t compression_method; |
| 143 | // The file modification time and date for this entry. |
| 144 | uint16_t last_mod_time; |
| 145 | uint16_t last_mod_date; |
| 146 | // The CRC-32 checksum for this entry. |
| 147 | uint32_t crc32; |
| 148 | // The compressed size (in bytes) of this entry. |
| 149 | uint32_t compressed_size; |
| 150 | // The uncompressed size (in bytes) of this entry. |
| 151 | uint32_t uncompressed_size; |
| 152 | // The length of the entry file name in bytes. The file name |
| 153 | // will appear immediately after this record. |
| 154 | uint16_t file_name_length; |
| 155 | // The length of the extra field info (in bytes). This data |
| 156 | // will appear immediately after the entry file name. |
| 157 | uint16_t extra_field_length; |
Jiyong Park | 6821cc8 | 2017-06-30 17:23:33 +0900 | [diff] [blame] | 158 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 159 | LocalFileHeader() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 160 | |
| 161 | private: |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 162 | DISALLOW_COPY_AND_ASSIGN(LocalFileHeader); |
| 163 | } __attribute__((packed)); |
| 164 | |
| 165 | struct DataDescriptor { |
| 166 | // The *optional* data descriptor start signature. |
| 167 | static const uint32_t kOptSignature = 0x08074b50; |
| 168 | |
| 169 | // CRC-32 checksum of the entry. |
| 170 | uint32_t crc32; |
Tianjie | cc92463 | 2020-03-26 12:34:44 -0700 | [diff] [blame] | 171 | |
| 172 | // For ZIP64 format archives, the compressed and uncompressed sizes are 8 |
| 173 | // bytes each. Also, the ZIP64 format MAY be used regardless of the size |
| 174 | // of a file. When extracting, if the zip64 extended information extra field |
| 175 | // is present for the file the compressed and uncompressed sizes will be 8 |
| 176 | // byte values. |
| 177 | |
| 178 | // Compressed size of the entry, the field can be either 4 bytes or 8 bytes |
| 179 | // in the zip file. |
| 180 | uint64_t compressed_size; |
| 181 | // Uncompressed size of the entry, the field can be either 4 bytes or 8 bytes |
| 182 | // in the zip file. |
| 183 | uint64_t uncompressed_size; |
Jiyong Park | 6821cc8 | 2017-06-30 17:23:33 +0900 | [diff] [blame] | 184 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 185 | DataDescriptor() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 186 | |
| 187 | private: |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 188 | DISALLOW_COPY_AND_ASSIGN(DataDescriptor); |
Tianjie | cc92463 | 2020-03-26 12:34:44 -0700 | [diff] [blame] | 189 | }; |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 190 | |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 191 | // The zip64 end of central directory locator helps to find the zip64 EOCD. |
| 192 | struct Zip64EocdLocator { |
| 193 | static constexpr uint32_t kSignature = 0x07064b50; |
| 194 | |
| 195 | // The signature of zip64 eocd locator, must be |kSignature| |
| 196 | uint32_t locator_signature; |
| 197 | // The start disk of the zip64 eocd. This implementation assumes that each |
| 198 | // archive spans a single disk only. |
| 199 | uint32_t eocd_start_disk; |
| 200 | // The offset offset of the zip64 end of central directory record. |
| 201 | uint64_t zip64_eocd_offset; |
| 202 | // The total number of disks. This implementation assumes that each archive |
| 203 | // spans a single disk only. |
| 204 | uint32_t num_of_disks; |
| 205 | |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 206 | Zip64EocdLocator() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 207 | |
| 208 | private: |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 209 | DISALLOW_COPY_AND_ASSIGN(Zip64EocdLocator); |
| 210 | } __attribute__((packed)); |
| 211 | |
| 212 | // The optional zip64 EOCD. If one of the fields in the end of central directory |
| 213 | // record is too small to hold required data, the field SHOULD be set to -1 |
| 214 | // (0xFFFF or 0xFFFFFFFF) and the ZIP64 format record SHOULD be created. |
| 215 | struct Zip64EocdRecord { |
| 216 | static constexpr uint32_t kSignature = 0x06064b50; |
| 217 | |
| 218 | // The signature of zip64 eocd record, must be |kSignature| |
| 219 | uint32_t record_signature; |
| 220 | // Size of zip64 end of central directory record. It SHOULD be the size of the |
| 221 | // remaining record and SHOULD NOT include the leading 12 bytes. |
| 222 | uint64_t record_size; |
| 223 | // The version of the tool that make this archive. |
| 224 | uint16_t version_made_by; |
| 225 | // Tool version needed to extract this archive. |
| 226 | uint16_t version_needed; |
| 227 | // Number of this disk. |
| 228 | uint32_t disk_num; |
| 229 | // Number of the disk with the start of the central directory. |
| 230 | uint32_t cd_start_disk; |
| 231 | // Total number of entries in the central directory on this disk. |
| 232 | // This implementation assumes that each archive spans a single |
| 233 | // disk only. i.e, that num_records_on_disk == num_records. |
| 234 | uint64_t num_records_on_disk; |
| 235 | // The total number of central directory records. |
| 236 | uint64_t num_records; |
| 237 | // The size of the central directory in bytes. |
| 238 | uint64_t cd_size; |
| 239 | // The offset of the start of the central directory, relative to the start of |
| 240 | // the file. |
| 241 | uint64_t cd_start_offset; |
| 242 | |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 243 | Zip64EocdRecord() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 244 | |
| 245 | private: |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 246 | DISALLOW_COPY_AND_ASSIGN(Zip64EocdRecord); |
| 247 | } __attribute__((packed)); |
| 248 | |
| 249 | // The possible contents of the Zip64 Extended Information Extra Field. It may appear in |
| 250 | // the 'extra' field of a central directory record or local file header. The order of |
| 251 | // the fields in the zip64 extended information record is fixed, but the fields MUST |
| 252 | // only appear if the corresponding local or central directory record field is set to |
| 253 | // 0xFFFF or 0xFFFFFFFF. And this entry in the Local header MUST include BOTH original |
| 254 | // and compressed file size fields. |
| 255 | struct Zip64ExtendedInfo { |
| 256 | static constexpr uint16_t kHeaderId = 0x0001; |
| 257 | // The header tag for this 'extra' block, should be |kHeaderId|. |
| 258 | uint16_t header_id; |
| 259 | // The size in bytes of the remaining data (excluding the top 4 bytes). |
| 260 | uint16_t data_size; |
| 261 | // Size in bytes of the uncompressed file. |
| 262 | std::optional<uint64_t> uncompressed_file_size; |
| 263 | // Size in bytes of the compressed file. |
| 264 | std::optional<uint64_t> compressed_file_size; |
| 265 | // Local file header offset relative to the start of the zip file. |
| 266 | std::optional<uint64_t> local_header_offset; |
| 267 | |
| 268 | // This implementation assumes that each archive spans a single disk only. So |
| 269 | // the disk_number is not used. |
| 270 | // uint32_t disk_num; |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 271 | Zip64ExtendedInfo() = default; |
Yurii Zubrytskyi | 3c793c4 | 2021-02-22 16:22:01 -0800 | [diff] [blame] | 272 | |
| 273 | private: |
Tianjie Xu | 53a7ca0 | 2020-03-11 11:59:10 -0700 | [diff] [blame] | 274 | DISALLOW_COPY_AND_ASSIGN(Zip64ExtendedInfo); |
| 275 | }; |
| 276 | |
Adam Lesinski | 622f304 | 2015-10-05 18:16:18 -0700 | [diff] [blame] | 277 | // mask value that signifies that the entry has a DD |
| 278 | static const uint32_t kGPBDDFlagMask = 0x0008; |
| 279 | |
| 280 | // The maximum size of a central directory or a file |
| 281 | // comment in bytes. |
| 282 | static const uint32_t kMaxCommentLen = 65535; |
| 283 | |
| 284 | #endif /* LIBZIPARCHIVE_ZIPARCHIVECOMMON_H_ */ |