1 : /* ***** BEGIN LICENSE BLOCK *****
2 : * Version: MPL 1.1/GPL 2.0/LGPL 2.1
3 : *
4 : * The contents of this file are subject to the Mozilla Public License Version
5 : * 1.1 (the "License"); you may not use this file except in compliance with
6 : * the License. You may obtain a copy of the License at
7 : * http://www.mozilla.org/MPL/
8 : *
9 : * Software distributed under the License is distributed on an "AS IS" basis,
10 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11 : * for the specific language governing rights and limitations under the
12 : * License.
13 : *
14 : * The Original Code is Zip Writer Component.
15 : *
16 : * The Initial Developer of the Original Code is
17 : * Dave Townsend <dtownsend@oxymoronical.com>.
18 : *
19 : * Portions created by the Initial Developer are Copyright (C) 2007
20 : * the Initial Developer. All Rights Reserved.
21 : *
22 : * Contributor(s):
23 : *
24 : * Alternatively, the contents of this file may be used under the terms of
25 : * either the GNU General Public License Version 2 or later (the "GPL"), or
26 : * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 : * in which case the provisions of the GPL or the LGPL are applicable instead
28 : * of those above. If you wish to allow use of your version of this file only
29 : * under the terms of either the GPL or the LGPL, and not to allow others to
30 : * use your version of this file under the terms of the MPL, indicate your
31 : * decision by deleting the provisions above and replace them with the notice
32 : * and other provisions required by the GPL or the LGPL. If you do not delete
33 : * the provisions above, a recipient may use your version of this file under
34 : * the terms of any one of the MPL, the GPL or the LGPL.
35 : *
36 : * ***** END LICENSE BLOCK *****
37 : */
38 :
39 : #include "StreamFunctions.h"
40 : #include "nsZipHeader.h"
41 : #include "nsMemory.h"
42 :
43 : #define ZIP_FILE_HEADER_SIGNATURE 0x04034b50
44 : #define ZIP_FILE_HEADER_SIZE 30
45 : #define ZIP_CDS_HEADER_SIGNATURE 0x02014b50
46 : #define ZIP_CDS_HEADER_SIZE 46
47 :
48 : #define FLAGS_IS_UTF8 0x800
49 :
50 : #define ZIP_EXTENDED_TIMESTAMP_FIELD 0x5455
51 : #define ZIP_EXTENDED_TIMESTAMP_MODTIME 0x01
52 :
53 : /**
54 : * nsZipHeader represents an entry from a zip file.
55 : */
56 40323 : NS_IMPL_ISUPPORTS1(nsZipHeader, nsIZipEntry)
57 :
58 : /* readonly attribute unsigned short compression; */
59 7 : NS_IMETHODIMP nsZipHeader::GetCompression(PRUint16 *aCompression)
60 : {
61 7 : NS_ASSERTION(mInited, "Not initalised");
62 :
63 7 : *aCompression = mMethod;
64 7 : return NS_OK;
65 : }
66 :
67 : /* readonly attribute unsigned long size; */
68 2 : NS_IMETHODIMP nsZipHeader::GetSize(PRUint32 *aSize)
69 : {
70 2 : NS_ASSERTION(mInited, "Not initalised");
71 :
72 2 : *aSize = mCSize;
73 2 : return NS_OK;
74 : }
75 :
76 : /* readonly attribute unsigned long realSize; */
77 11 : NS_IMETHODIMP nsZipHeader::GetRealSize(PRUint32 *aRealSize)
78 : {
79 11 : NS_ASSERTION(mInited, "Not initalised");
80 :
81 11 : *aRealSize = mUSize;
82 11 : return NS_OK;
83 : }
84 :
85 : /* readonly attribute unsigned long CRC32; */
86 9 : NS_IMETHODIMP nsZipHeader::GetCRC32(PRUint32 *aCRC32)
87 : {
88 9 : NS_ASSERTION(mInited, "Not initalised");
89 :
90 9 : *aCRC32 = mCRC;
91 9 : return NS_OK;
92 : }
93 :
94 : /* readonly attribute boolean isDirectory; */
95 8 : NS_IMETHODIMP nsZipHeader::GetIsDirectory(bool *aIsDirectory)
96 : {
97 8 : NS_ASSERTION(mInited, "Not initalised");
98 :
99 8 : if (mName.Last() == '/')
100 2 : *aIsDirectory = true;
101 : else
102 6 : *aIsDirectory = false;
103 8 : return NS_OK;
104 : }
105 :
106 : /* readonly attribute PRTime lastModifiedTime; */
107 7 : NS_IMETHODIMP nsZipHeader::GetLastModifiedTime(PRTime *aLastModifiedTime)
108 : {
109 7 : NS_ASSERTION(mInited, "Not initalised");
110 :
111 : // Try to read timestamp from extra field
112 : PRUint16 blocksize;
113 7 : const PRUint8 *tsField = GetExtraField(ZIP_EXTENDED_TIMESTAMP_FIELD, false, &blocksize);
114 7 : if (tsField && blocksize >= 5) {
115 7 : PRUint32 pos = 4;
116 : PRUint8 flags;
117 7 : flags = READ8(tsField, &pos);
118 7 : if (flags & ZIP_EXTENDED_TIMESTAMP_MODTIME) {
119 7 : *aLastModifiedTime = (PRTime)(READ32(tsField, &pos))
120 7 : * PR_USEC_PER_SEC;
121 7 : return NS_OK;
122 : }
123 : }
124 :
125 : // Use DOS date/time fields
126 : // Note that on DST shift we can't handle correctly the hour that is valid
127 : // in both DST zones
128 : PRExplodedTime time;
129 :
130 0 : time.tm_usec = 0;
131 :
132 0 : time.tm_hour = (mTime >> 11) & 0x1F;
133 0 : time.tm_min = (mTime >> 5) & 0x3F;
134 0 : time.tm_sec = (mTime & 0x1F) * 2;
135 :
136 0 : time.tm_year = (mDate >> 9) + 1980;
137 0 : time.tm_month = ((mDate >> 5) & 0x0F) - 1;
138 0 : time.tm_mday = mDate & 0x1F;
139 :
140 0 : time.tm_params.tp_gmt_offset = 0;
141 0 : time.tm_params.tp_dst_offset = 0;
142 :
143 0 : PR_NormalizeTime(&time, PR_GMTParameters);
144 0 : time.tm_params.tp_gmt_offset = PR_LocalTimeParameters(&time).tp_gmt_offset;
145 0 : PR_NormalizeTime(&time, PR_GMTParameters);
146 0 : time.tm_params.tp_dst_offset = PR_LocalTimeParameters(&time).tp_dst_offset;
147 :
148 0 : *aLastModifiedTime = PR_ImplodeTime(&time);
149 :
150 0 : return NS_OK;
151 : }
152 :
153 : /* readonly attribute boolean isSynthetic; */
154 0 : NS_IMETHODIMP nsZipHeader::GetIsSynthetic(bool *aIsSynthetic)
155 : {
156 0 : NS_ASSERTION(mInited, "Not initalised");
157 :
158 0 : *aIsSynthetic = false;
159 0 : return NS_OK;
160 : }
161 :
162 5736 : void nsZipHeader::Init(const nsACString & aPath, PRTime aDate, PRUint32 aAttr,
163 : PRUint32 aOffset)
164 : {
165 5736 : NS_ASSERTION(!mInited, "Already initalised");
166 :
167 : PRExplodedTime time;
168 5736 : PR_ExplodeTime(aDate, PR_LocalTimeParameters, &time);
169 :
170 5736 : mTime = time.tm_sec / 2 + (time.tm_min << 5) + (time.tm_hour << 11);
171 : mDate = time.tm_mday + ((time.tm_month + 1) << 5) +
172 5736 : ((time.tm_year - 1980) << 9);
173 :
174 : // Store modification timestamp as extra field
175 : // First fill CDS extra field
176 5736 : mFieldLength = 9;
177 11472 : mExtraField = new PRUint8[mFieldLength];
178 5736 : if (!mExtraField) {
179 0 : mFieldLength = 0;
180 : } else {
181 5736 : PRUint32 pos = 0;
182 5736 : WRITE16(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_FIELD);
183 5736 : WRITE16(mExtraField.get(), &pos, 5);
184 5736 : WRITE8(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_MODTIME);
185 5736 : WRITE32(mExtraField.get(), &pos, aDate / PR_USEC_PER_SEC);
186 :
187 : // Fill local extra field
188 11472 : mLocalExtraField = new PRUint8[mFieldLength];
189 5736 : if (mLocalExtraField) {
190 5736 : mLocalFieldLength = mFieldLength;
191 5736 : memcpy(mLocalExtraField.get(), mExtraField.get(), mLocalFieldLength);
192 : }
193 : }
194 :
195 5736 : mEAttr = aAttr;
196 5736 : mOffset = aOffset;
197 5736 : mName = aPath;
198 5736 : mComment = NS_LITERAL_CSTRING("");
199 : // Claim a UTF-8 path in case it needs it.
200 5736 : mFlags |= FLAGS_IS_UTF8;
201 5736 : mInited = true;
202 5736 : }
203 :
204 11467 : PRUint32 nsZipHeader::GetFileHeaderLength()
205 : {
206 11467 : return ZIP_FILE_HEADER_SIZE + mName.Length() + mLocalFieldLength;
207 : }
208 :
209 11465 : nsresult nsZipHeader::WriteFileHeader(nsIOutputStream *aStream)
210 : {
211 11465 : NS_ASSERTION(mInited, "Not initalised");
212 :
213 : PRUint8 buf[ZIP_FILE_HEADER_SIZE];
214 11465 : PRUint32 pos = 0;
215 11465 : WRITE32(buf, &pos, ZIP_FILE_HEADER_SIGNATURE);
216 11465 : WRITE16(buf, &pos, mVersionNeeded);
217 11465 : WRITE16(buf, &pos, mFlags);
218 11465 : WRITE16(buf, &pos, mMethod);
219 11465 : WRITE16(buf, &pos, mTime);
220 11465 : WRITE16(buf, &pos, mDate);
221 11465 : WRITE32(buf, &pos, mCRC);
222 11465 : WRITE32(buf, &pos, mCSize);
223 11465 : WRITE32(buf, &pos, mUSize);
224 11465 : WRITE16(buf, &pos, mName.Length());
225 11465 : WRITE16(buf, &pos, mLocalFieldLength);
226 :
227 11465 : nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
228 11465 : NS_ENSURE_SUCCESS(rv, rv);
229 :
230 11465 : rv = ZW_WriteData(aStream, mName.get(), mName.Length());
231 11465 : NS_ENSURE_SUCCESS(rv, rv);
232 :
233 11465 : if (mLocalFieldLength)
234 : {
235 11465 : rv = ZW_WriteData(aStream, (const char *)mLocalExtraField.get(), mLocalFieldLength);
236 11465 : NS_ENSURE_SUCCESS(rv, rv);
237 : }
238 :
239 11465 : return NS_OK;
240 : }
241 :
242 5736 : PRUint32 nsZipHeader::GetCDSHeaderLength()
243 : {
244 5736 : return ZIP_CDS_HEADER_SIZE + mName.Length() + mComment.Length() +
245 5736 : mFieldLength;
246 : }
247 :
248 5736 : nsresult nsZipHeader::WriteCDSHeader(nsIOutputStream *aStream)
249 : {
250 5736 : NS_ASSERTION(mInited, "Not initalised");
251 :
252 : PRUint8 buf[ZIP_CDS_HEADER_SIZE];
253 5736 : PRUint32 pos = 0;
254 5736 : WRITE32(buf, &pos, ZIP_CDS_HEADER_SIGNATURE);
255 5736 : WRITE16(buf, &pos, mVersionMade);
256 5736 : WRITE16(buf, &pos, mVersionNeeded);
257 5736 : WRITE16(buf, &pos, mFlags);
258 5736 : WRITE16(buf, &pos, mMethod);
259 5736 : WRITE16(buf, &pos, mTime);
260 5736 : WRITE16(buf, &pos, mDate);
261 5736 : WRITE32(buf, &pos, mCRC);
262 5736 : WRITE32(buf, &pos, mCSize);
263 5736 : WRITE32(buf, &pos, mUSize);
264 5736 : WRITE16(buf, &pos, mName.Length());
265 5736 : WRITE16(buf, &pos, mFieldLength);
266 5736 : WRITE16(buf, &pos, mComment.Length());
267 5736 : WRITE16(buf, &pos, mDisk);
268 5736 : WRITE16(buf, &pos, mIAttr);
269 5736 : WRITE32(buf, &pos, mEAttr);
270 5736 : WRITE32(buf, &pos, mOffset);
271 :
272 5736 : nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
273 5736 : NS_ENSURE_SUCCESS(rv, rv);
274 :
275 5736 : rv = ZW_WriteData(aStream, mName.get(), mName.Length());
276 5736 : NS_ENSURE_SUCCESS(rv, rv);
277 5736 : if (mExtraField) {
278 5736 : rv = ZW_WriteData(aStream, (const char *)mExtraField.get(), mFieldLength);
279 5736 : NS_ENSURE_SUCCESS(rv, rv);
280 : }
281 5736 : return ZW_WriteData(aStream, mComment.get(), mComment.Length());
282 : }
283 :
284 9 : nsresult nsZipHeader::ReadCDSHeader(nsIInputStream *stream)
285 : {
286 9 : NS_ASSERTION(!mInited, "Already initalised");
287 :
288 : PRUint8 buf[ZIP_CDS_HEADER_SIZE];
289 :
290 9 : nsresult rv = ZW_ReadData(stream, (char *)buf, ZIP_CDS_HEADER_SIZE);
291 9 : NS_ENSURE_SUCCESS(rv, rv);
292 :
293 9 : PRUint32 pos = 0;
294 9 : PRUint32 signature = READ32(buf, &pos);
295 9 : if (signature != ZIP_CDS_HEADER_SIGNATURE)
296 0 : return NS_ERROR_FILE_CORRUPTED;
297 :
298 9 : mVersionMade = READ16(buf, &pos);
299 9 : mVersionNeeded = READ16(buf, &pos);
300 9 : mFlags = READ16(buf, &pos);
301 9 : mMethod = READ16(buf, &pos);
302 9 : mTime = READ16(buf, &pos);
303 9 : mDate = READ16(buf, &pos);
304 9 : mCRC = READ32(buf, &pos);
305 9 : mCSize = READ32(buf, &pos);
306 9 : mUSize = READ32(buf, &pos);
307 9 : PRUint16 namelength = READ16(buf, &pos);
308 9 : mFieldLength = READ16(buf, &pos);
309 9 : PRUint16 commentlength = READ16(buf, &pos);
310 9 : mDisk = READ16(buf, &pos);
311 9 : mIAttr = READ16(buf, &pos);
312 9 : mEAttr = READ32(buf, &pos);
313 9 : mOffset = READ32(buf, &pos);
314 :
315 9 : if (namelength > 0) {
316 27 : nsAutoArrayPtr<char> field(new char[namelength]);
317 9 : NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
318 9 : rv = ZW_ReadData(stream, field.get(), namelength);
319 9 : NS_ENSURE_SUCCESS(rv, rv);
320 18 : mName.Assign(field, namelength);
321 : }
322 : else
323 0 : mName = NS_LITERAL_CSTRING("");
324 :
325 9 : if (mFieldLength > 0) {
326 18 : mExtraField = new PRUint8[mFieldLength];
327 9 : NS_ENSURE_TRUE(mExtraField, NS_ERROR_OUT_OF_MEMORY);
328 9 : rv = ZW_ReadData(stream, (char *)mExtraField.get(), mFieldLength);
329 9 : NS_ENSURE_SUCCESS(rv, rv);
330 : }
331 :
332 9 : if (commentlength > 0) {
333 0 : nsAutoArrayPtr<char> field(new char[commentlength]);
334 0 : NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
335 0 : rv = ZW_ReadData(stream, field.get(), commentlength);
336 0 : NS_ENSURE_SUCCESS(rv, rv);
337 0 : mComment.Assign(field, commentlength);
338 : }
339 : else
340 9 : mComment = NS_LITERAL_CSTRING("");
341 :
342 9 : mInited = true;
343 9 : return NS_OK;
344 : }
345 :
346 7 : const PRUint8 * nsZipHeader::GetExtraField(PRUint16 aTag, bool aLocal, PRUint16 *aBlockSize)
347 : {
348 7 : const PRUint8 *buf = aLocal ? mLocalExtraField : mExtraField;
349 7 : PRUint32 buflen = aLocal ? mLocalFieldLength : mFieldLength;
350 7 : PRUint32 pos = 0;
351 : PRUint16 tag, blocksize;
352 :
353 14 : while (buf && (pos + 4) <= buflen) {
354 7 : tag = READ16(buf, &pos);
355 7 : blocksize = READ16(buf, &pos);
356 :
357 7 : if (aTag == tag && (pos + blocksize) <= buflen) {
358 7 : *aBlockSize = blocksize;
359 7 : return buf + pos - 4;
360 : }
361 :
362 0 : pos += blocksize;
363 : }
364 :
365 0 : return NULL;
366 : }
|