Line data Source code
1 : /* This Source Code Form is subject to the terms of the Mozilla Public
2 : * License, v. 2.0. If a copy of the MPL was not distributed with this
3 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
4 : */
5 :
6 : #include "StreamFunctions.h"
7 : #include "nsZipHeader.h"
8 : #include "nsMemory.h"
9 : #include "prtime.h"
10 :
11 : #define ZIP_FILE_HEADER_SIGNATURE 0x04034b50
12 : #define ZIP_FILE_HEADER_SIZE 30
13 : #define ZIP_CDS_HEADER_SIGNATURE 0x02014b50
14 : #define ZIP_CDS_HEADER_SIZE 46
15 :
16 : #define FLAGS_IS_UTF8 0x800
17 :
18 : #define ZIP_EXTENDED_TIMESTAMP_FIELD 0x5455
19 : #define ZIP_EXTENDED_TIMESTAMP_MODTIME 0x01
20 :
21 : using namespace mozilla;
22 :
23 : /**
24 : * nsZipHeader represents an entry from a zip file.
25 : */
26 0 : NS_IMPL_ISUPPORTS(nsZipHeader, nsIZipEntry)
27 :
28 0 : NS_IMETHODIMP nsZipHeader::GetCompression(uint16_t *aCompression)
29 : {
30 0 : NS_ASSERTION(mInited, "Not initalised");
31 :
32 0 : *aCompression = mMethod;
33 0 : return NS_OK;
34 : }
35 :
36 0 : NS_IMETHODIMP nsZipHeader::GetSize(uint32_t *aSize)
37 : {
38 0 : NS_ASSERTION(mInited, "Not initalised");
39 :
40 0 : *aSize = mCSize;
41 0 : return NS_OK;
42 : }
43 :
44 0 : NS_IMETHODIMP nsZipHeader::GetRealSize(uint32_t *aRealSize)
45 : {
46 0 : NS_ASSERTION(mInited, "Not initalised");
47 :
48 0 : *aRealSize = mUSize;
49 0 : return NS_OK;
50 : }
51 :
52 0 : NS_IMETHODIMP nsZipHeader::GetCRC32(uint32_t *aCRC32)
53 : {
54 0 : NS_ASSERTION(mInited, "Not initalised");
55 :
56 0 : *aCRC32 = mCRC;
57 0 : return NS_OK;
58 : }
59 :
60 0 : NS_IMETHODIMP nsZipHeader::GetIsDirectory(bool *aIsDirectory)
61 : {
62 0 : NS_ASSERTION(mInited, "Not initalised");
63 :
64 0 : if (mName.Last() == '/')
65 0 : *aIsDirectory = true;
66 : else
67 0 : *aIsDirectory = false;
68 0 : return NS_OK;
69 : }
70 :
71 0 : NS_IMETHODIMP nsZipHeader::GetLastModifiedTime(PRTime *aLastModifiedTime)
72 : {
73 0 : NS_ASSERTION(mInited, "Not initalised");
74 :
75 : // Try to read timestamp from extra field
76 : uint16_t blocksize;
77 0 : const uint8_t *tsField = GetExtraField(ZIP_EXTENDED_TIMESTAMP_FIELD, false, &blocksize);
78 0 : if (tsField && blocksize >= 5) {
79 0 : uint32_t pos = 4;
80 : uint8_t flags;
81 0 : flags = READ8(tsField, &pos);
82 0 : if (flags & ZIP_EXTENDED_TIMESTAMP_MODTIME) {
83 0 : *aLastModifiedTime = (PRTime)(READ32(tsField, &pos))
84 0 : * PR_USEC_PER_SEC;
85 0 : return NS_OK;
86 : }
87 : }
88 :
89 : // Use DOS date/time fields
90 : // Note that on DST shift we can't handle correctly the hour that is valid
91 : // in both DST zones
92 : PRExplodedTime time;
93 :
94 0 : time.tm_usec = 0;
95 :
96 0 : time.tm_hour = (mTime >> 11) & 0x1F;
97 0 : time.tm_min = (mTime >> 5) & 0x3F;
98 0 : time.tm_sec = (mTime & 0x1F) * 2;
99 :
100 0 : time.tm_year = (mDate >> 9) + 1980;
101 0 : time.tm_month = ((mDate >> 5) & 0x0F) - 1;
102 0 : time.tm_mday = mDate & 0x1F;
103 :
104 0 : time.tm_params.tp_gmt_offset = 0;
105 0 : time.tm_params.tp_dst_offset = 0;
106 :
107 0 : PR_NormalizeTime(&time, PR_GMTParameters);
108 0 : time.tm_params.tp_gmt_offset = PR_LocalTimeParameters(&time).tp_gmt_offset;
109 0 : PR_NormalizeTime(&time, PR_GMTParameters);
110 0 : time.tm_params.tp_dst_offset = PR_LocalTimeParameters(&time).tp_dst_offset;
111 :
112 0 : *aLastModifiedTime = PR_ImplodeTime(&time);
113 :
114 0 : return NS_OK;
115 : }
116 :
117 0 : NS_IMETHODIMP nsZipHeader::GetIsSynthetic(bool *aIsSynthetic)
118 : {
119 0 : NS_ASSERTION(mInited, "Not initalised");
120 :
121 0 : *aIsSynthetic = false;
122 0 : return NS_OK;
123 : }
124 :
125 0 : NS_IMETHODIMP nsZipHeader::GetPermissions(uint32_t *aPermissions)
126 : {
127 0 : NS_ASSERTION(mInited, "Not initalised");
128 :
129 : // Always give user read access at least, this matches nsIZipReader's behaviour
130 0 : *aPermissions = ((mEAttr >> 16) & 0xfff) | 0x100;
131 0 : return NS_OK;
132 : }
133 :
134 0 : void nsZipHeader::Init(const nsACString & aPath, PRTime aDate, uint32_t aAttr,
135 : uint32_t aOffset)
136 : {
137 0 : NS_ASSERTION(!mInited, "Already initalised");
138 :
139 : PRExplodedTime time;
140 0 : PR_ExplodeTime(aDate, PR_LocalTimeParameters, &time);
141 :
142 0 : mTime = time.tm_sec / 2 + (time.tm_min << 5) + (time.tm_hour << 11);
143 0 : mDate = time.tm_mday + ((time.tm_month + 1) << 5) +
144 0 : ((time.tm_year - 1980) << 9);
145 :
146 : // Store modification timestamp as extra field
147 : // First fill CDS extra field
148 0 : mFieldLength = 9;
149 0 : mExtraField = MakeUnique<uint8_t[]>(mFieldLength);
150 0 : if (!mExtraField) {
151 0 : mFieldLength = 0;
152 : } else {
153 0 : uint32_t pos = 0;
154 0 : WRITE16(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_FIELD);
155 0 : WRITE16(mExtraField.get(), &pos, 5);
156 0 : WRITE8(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_MODTIME);
157 0 : WRITE32(mExtraField.get(), &pos, aDate / PR_USEC_PER_SEC);
158 :
159 : // Fill local extra field
160 0 : mLocalExtraField = MakeUnique<uint8_t[]>(mFieldLength);
161 0 : if (mLocalExtraField) {
162 0 : mLocalFieldLength = mFieldLength;
163 0 : memcpy(mLocalExtraField.get(), mExtraField.get(), mLocalFieldLength);
164 : }
165 : }
166 :
167 0 : mEAttr = aAttr;
168 0 : mOffset = aOffset;
169 0 : mName = aPath;
170 0 : mComment = NS_LITERAL_CSTRING("");
171 : // Claim a UTF-8 path in case it needs it.
172 0 : mFlags |= FLAGS_IS_UTF8;
173 0 : mInited = true;
174 0 : }
175 :
176 0 : uint32_t nsZipHeader::GetFileHeaderLength()
177 : {
178 0 : return ZIP_FILE_HEADER_SIZE + mName.Length() + mLocalFieldLength;
179 : }
180 :
181 0 : nsresult nsZipHeader::WriteFileHeader(nsIOutputStream *aStream)
182 : {
183 0 : NS_ASSERTION(mInited, "Not initalised");
184 :
185 : uint8_t buf[ZIP_FILE_HEADER_SIZE];
186 0 : uint32_t pos = 0;
187 0 : WRITE32(buf, &pos, ZIP_FILE_HEADER_SIGNATURE);
188 0 : WRITE16(buf, &pos, mVersionNeeded);
189 0 : WRITE16(buf, &pos, mFlags);
190 0 : WRITE16(buf, &pos, mMethod);
191 0 : WRITE16(buf, &pos, mTime);
192 0 : WRITE16(buf, &pos, mDate);
193 0 : WRITE32(buf, &pos, mCRC);
194 0 : WRITE32(buf, &pos, mCSize);
195 0 : WRITE32(buf, &pos, mUSize);
196 0 : WRITE16(buf, &pos, mName.Length());
197 0 : WRITE16(buf, &pos, mLocalFieldLength);
198 :
199 0 : nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
200 0 : NS_ENSURE_SUCCESS(rv, rv);
201 :
202 0 : rv = ZW_WriteData(aStream, mName.get(), mName.Length());
203 0 : NS_ENSURE_SUCCESS(rv, rv);
204 :
205 0 : if (mLocalFieldLength)
206 : {
207 0 : rv = ZW_WriteData(aStream, (const char *)mLocalExtraField.get(), mLocalFieldLength);
208 0 : NS_ENSURE_SUCCESS(rv, rv);
209 : }
210 :
211 0 : return NS_OK;
212 : }
213 :
214 0 : uint32_t nsZipHeader::GetCDSHeaderLength()
215 : {
216 0 : return ZIP_CDS_HEADER_SIZE + mName.Length() + mComment.Length() +
217 0 : mFieldLength;
218 : }
219 :
220 0 : nsresult nsZipHeader::WriteCDSHeader(nsIOutputStream *aStream)
221 : {
222 0 : NS_ASSERTION(mInited, "Not initalised");
223 :
224 : uint8_t buf[ZIP_CDS_HEADER_SIZE];
225 0 : uint32_t pos = 0;
226 0 : WRITE32(buf, &pos, ZIP_CDS_HEADER_SIGNATURE);
227 0 : WRITE16(buf, &pos, mVersionMade);
228 0 : WRITE16(buf, &pos, mVersionNeeded);
229 0 : WRITE16(buf, &pos, mFlags);
230 0 : WRITE16(buf, &pos, mMethod);
231 0 : WRITE16(buf, &pos, mTime);
232 0 : WRITE16(buf, &pos, mDate);
233 0 : WRITE32(buf, &pos, mCRC);
234 0 : WRITE32(buf, &pos, mCSize);
235 0 : WRITE32(buf, &pos, mUSize);
236 0 : WRITE16(buf, &pos, mName.Length());
237 0 : WRITE16(buf, &pos, mFieldLength);
238 0 : WRITE16(buf, &pos, mComment.Length());
239 0 : WRITE16(buf, &pos, mDisk);
240 0 : WRITE16(buf, &pos, mIAttr);
241 0 : WRITE32(buf, &pos, mEAttr);
242 0 : WRITE32(buf, &pos, mOffset);
243 :
244 0 : nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
245 0 : NS_ENSURE_SUCCESS(rv, rv);
246 :
247 0 : rv = ZW_WriteData(aStream, mName.get(), mName.Length());
248 0 : NS_ENSURE_SUCCESS(rv, rv);
249 0 : if (mExtraField) {
250 0 : rv = ZW_WriteData(aStream, (const char *)mExtraField.get(), mFieldLength);
251 0 : NS_ENSURE_SUCCESS(rv, rv);
252 : }
253 0 : return ZW_WriteData(aStream, mComment.get(), mComment.Length());
254 : }
255 :
256 0 : nsresult nsZipHeader::ReadCDSHeader(nsIInputStream *stream)
257 : {
258 0 : NS_ASSERTION(!mInited, "Already initalised");
259 :
260 : uint8_t buf[ZIP_CDS_HEADER_SIZE];
261 :
262 0 : nsresult rv = ZW_ReadData(stream, (char *)buf, ZIP_CDS_HEADER_SIZE);
263 0 : NS_ENSURE_SUCCESS(rv, rv);
264 :
265 0 : uint32_t pos = 0;
266 0 : uint32_t signature = READ32(buf, &pos);
267 0 : if (signature != ZIP_CDS_HEADER_SIGNATURE)
268 0 : return NS_ERROR_FILE_CORRUPTED;
269 :
270 0 : mVersionMade = READ16(buf, &pos);
271 0 : mVersionNeeded = READ16(buf, &pos);
272 0 : mFlags = READ16(buf, &pos);
273 0 : mMethod = READ16(buf, &pos);
274 0 : mTime = READ16(buf, &pos);
275 0 : mDate = READ16(buf, &pos);
276 0 : mCRC = READ32(buf, &pos);
277 0 : mCSize = READ32(buf, &pos);
278 0 : mUSize = READ32(buf, &pos);
279 0 : uint16_t namelength = READ16(buf, &pos);
280 0 : mFieldLength = READ16(buf, &pos);
281 0 : uint16_t commentlength = READ16(buf, &pos);
282 0 : mDisk = READ16(buf, &pos);
283 0 : mIAttr = READ16(buf, &pos);
284 0 : mEAttr = READ32(buf, &pos);
285 0 : mOffset = READ32(buf, &pos);
286 :
287 0 : if (namelength > 0) {
288 0 : auto field = MakeUnique<char[]>(namelength);
289 0 : NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
290 0 : rv = ZW_ReadData(stream, field.get(), namelength);
291 0 : NS_ENSURE_SUCCESS(rv, rv);
292 0 : mName.Assign(field.get(), namelength);
293 : }
294 : else
295 0 : mName = NS_LITERAL_CSTRING("");
296 :
297 0 : if (mFieldLength > 0) {
298 0 : mExtraField = MakeUnique<uint8_t[]>(mFieldLength);
299 0 : NS_ENSURE_TRUE(mExtraField, NS_ERROR_OUT_OF_MEMORY);
300 0 : rv = ZW_ReadData(stream, (char *)mExtraField.get(), mFieldLength);
301 0 : NS_ENSURE_SUCCESS(rv, rv);
302 : }
303 :
304 0 : if (commentlength > 0) {
305 0 : auto field = MakeUnique<char[]>(commentlength);
306 0 : NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
307 0 : rv = ZW_ReadData(stream, field.get(), commentlength);
308 0 : NS_ENSURE_SUCCESS(rv, rv);
309 0 : mComment.Assign(field.get(), commentlength);
310 : }
311 : else
312 0 : mComment = NS_LITERAL_CSTRING("");
313 :
314 0 : mInited = true;
315 0 : return NS_OK;
316 : }
317 :
318 0 : const uint8_t * nsZipHeader::GetExtraField(uint16_t aTag, bool aLocal, uint16_t *aBlockSize)
319 : {
320 0 : const uint8_t *buf = aLocal ? mLocalExtraField.get() : mExtraField.get();
321 0 : uint32_t buflen = aLocal ? mLocalFieldLength : mFieldLength;
322 0 : uint32_t pos = 0;
323 : uint16_t tag, blocksize;
324 :
325 0 : while (buf && (pos + 4) <= buflen) {
326 0 : tag = READ16(buf, &pos);
327 0 : blocksize = READ16(buf, &pos);
328 :
329 0 : if (aTag == tag && (pos + blocksize) <= buflen) {
330 0 : *aBlockSize = blocksize;
331 0 : return buf + pos - 4;
332 : }
333 :
334 0 : pos += blocksize;
335 : }
336 :
337 0 : return nullptr;
338 : }
339 :
340 : /*
341 : * Pad extra field to align data starting position to specified size.
342 : */
343 0 : nsresult nsZipHeader::PadExtraField(uint32_t aOffset, uint16_t aAlignSize)
344 : {
345 : uint32_t pad_size;
346 : uint32_t pa_offset;
347 : uint32_t pa_end;
348 :
349 : // Check for range and power of 2.
350 0 : if (aAlignSize < 2 || aAlignSize > 32768 ||
351 0 : (aAlignSize & (aAlignSize - 1)) != 0) {
352 0 : return NS_ERROR_INVALID_ARG;
353 : }
354 :
355 : // Point to current starting data position.
356 0 : aOffset += ZIP_FILE_HEADER_SIZE + mName.Length() + mLocalFieldLength;
357 :
358 : // Calculate aligned offset.
359 0 : pa_offset = aOffset & ~(aAlignSize - 1);
360 0 : pa_end = pa_offset + aAlignSize;
361 0 : pad_size = pa_end - aOffset;
362 0 : if (pad_size == 0) {
363 0 : return NS_OK;
364 : }
365 :
366 : // Leave enough room(at least 4 bytes) for valid values in extra field.
367 0 : while (pad_size < 4) {
368 0 : pad_size += aAlignSize;
369 : }
370 : // Extra field length is 2 bytes.
371 0 : if (mLocalFieldLength + pad_size > 65535) {
372 0 : return NS_ERROR_FAILURE;
373 : }
374 :
375 0 : UniquePtr<uint8_t[]> field = Move(mLocalExtraField);
376 0 : uint32_t pos = mLocalFieldLength;
377 :
378 0 : mLocalExtraField = MakeUnique<uint8_t[]>(mLocalFieldLength + pad_size);
379 0 : memcpy(mLocalExtraField.get(), field.get(), mLocalFieldLength);
380 : // Use 0xFFFF as tag ID to avoid conflict with other IDs.
381 : // For more information, please read "Extensible data fields" section in:
382 : // http://www.pkware.com/documents/casestudies/APPNOTE.TXT
383 0 : WRITE16(mLocalExtraField.get(), &pos, 0xFFFF);
384 0 : WRITE16(mLocalExtraField.get(), &pos, pad_size - 4);
385 0 : memset(mLocalExtraField.get() + pos, 0, pad_size - 4);
386 0 : mLocalFieldLength += pad_size;
387 :
388 0 : return NS_OK;
389 : }
|
