]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/zipstrm.cpp | |
3 | // Purpose: Streams for Zip files | |
4 | // Author: Mike Wetherell | |
5 | // RCS-ID: $Id$ | |
6 | // Copyright: (c) Mike Wetherell | |
7 | // Licence: wxWindows licence | |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | // For compilers that support precompilation, includes "wx.h". | |
11 | #include "wx/wxprec.h" | |
12 | ||
13 | #ifdef __BORLANDC__ | |
14 | #pragma hdrstop | |
15 | #endif | |
16 | ||
17 | #if wxUSE_ZIPSTREAM | |
18 | ||
19 | #include "wx/zipstrm.h" | |
20 | ||
21 | #ifndef WX_PRECOMP | |
22 | #include "wx/hashmap.h" | |
23 | #include "wx/intl.h" | |
24 | #include "wx/log.h" | |
25 | #include "wx/utils.h" | |
26 | #endif | |
27 | ||
28 | #include "wx/datstrm.h" | |
29 | #include "wx/zstream.h" | |
30 | #include "wx/mstream.h" | |
31 | #include "wx/scopedptr.h" | |
32 | #include "wx/wfstream.h" | |
33 | #include "zlib.h" | |
34 | ||
35 | // value for the 'version needed to extract' field (20 means 2.0) | |
36 | enum { | |
37 | VERSION_NEEDED_TO_EXTRACT = 20 | |
38 | }; | |
39 | ||
40 | // signatures for the various records (PKxx) | |
41 | enum { | |
42 | CENTRAL_MAGIC = 0x02014b50, // central directory record | |
43 | LOCAL_MAGIC = 0x04034b50, // local header | |
44 | END_MAGIC = 0x06054b50, // end of central directory record | |
45 | SUMS_MAGIC = 0x08074b50 // data descriptor (info-zip) | |
46 | }; | |
47 | ||
48 | // unix file attributes. zip stores them in the high 16 bits of the | |
49 | // 'external attributes' field, hence the extra zeros. | |
50 | enum { | |
51 | wxZIP_S_IFMT = 0xF0000000, | |
52 | wxZIP_S_IFDIR = 0x40000000, | |
53 | wxZIP_S_IFREG = 0x80000000 | |
54 | }; | |
55 | ||
56 | // minimum sizes for the various records | |
57 | enum { | |
58 | CENTRAL_SIZE = 46, | |
59 | LOCAL_SIZE = 30, | |
60 | END_SIZE = 22, | |
61 | SUMS_SIZE = 12 | |
62 | }; | |
63 | ||
64 | // The number of bytes that must be written to an wxZipOutputStream before | |
65 | // a zip entry is created. The purpose of this latency is so that | |
66 | // OpenCompressor() can see a little data before deciding which compressor | |
67 | // it should use. | |
68 | enum { | |
69 | OUTPUT_LATENCY = 4096 | |
70 | }; | |
71 | ||
72 | // Some offsets into the local header | |
73 | enum { | |
74 | SUMS_OFFSET = 14 | |
75 | }; | |
76 | ||
77 | IMPLEMENT_DYNAMIC_CLASS(wxZipEntry, wxArchiveEntry) | |
78 | IMPLEMENT_DYNAMIC_CLASS(wxZipClassFactory, wxArchiveClassFactory) | |
79 | ||
80 | ||
81 | ///////////////////////////////////////////////////////////////////////////// | |
82 | // Helpers | |
83 | ||
84 | // read a string of a given length | |
85 | // | |
86 | static wxString ReadString(wxInputStream& stream, wxUint16 len, wxMBConv& conv) | |
87 | { | |
88 | if (len == 0) | |
89 | return wxEmptyString; | |
90 | ||
91 | #if wxUSE_UNICODE | |
92 | wxCharBuffer buf(len); | |
93 | stream.Read(buf.data(), len); | |
94 | wxString str(buf, conv); | |
95 | #else | |
96 | wxString str; | |
97 | (void)conv; | |
98 | { | |
99 | wxStringBuffer buf(str, len); | |
100 | stream.Read(buf, len); | |
101 | } | |
102 | #endif | |
103 | ||
104 | return str; | |
105 | } | |
106 | ||
107 | // Decode a little endian wxUint32 number from a character array | |
108 | // | |
109 | static inline wxUint32 CrackUint32(const char *m) | |
110 | { | |
111 | const unsigned char *n = (const unsigned char*)m; | |
112 | return (n[3] << 24) | (n[2] << 16) | (n[1] << 8) | n[0]; | |
113 | } | |
114 | ||
115 | // Decode a little endian wxUint16 number from a character array | |
116 | // | |
117 | static inline wxUint16 CrackUint16(const char *m) | |
118 | { | |
119 | const unsigned char *n = (const unsigned char*)m; | |
120 | return (n[1] << 8) | n[0]; | |
121 | } | |
122 | ||
123 | // Temporarily lower the logging level in debug mode to avoid a warning | |
124 | // from SeekI about seeking on a stream with data written back to it. | |
125 | // | |
126 | static wxFileOffset QuietSeek(wxInputStream& stream, wxFileOffset pos) | |
127 | { | |
128 | #if wxUSE_LOG | |
129 | wxLogLevel level = wxLog::GetLogLevel(); | |
130 | wxLog::SetLogLevel(wxLOG_Debug - 1); | |
131 | wxFileOffset result = stream.SeekI(pos); | |
132 | wxLog::SetLogLevel(level); | |
133 | return result; | |
134 | #else | |
135 | return stream.SeekI(pos); | |
136 | #endif | |
137 | } | |
138 | ||
139 | ||
140 | ///////////////////////////////////////////////////////////////////////////// | |
141 | // Class factory | |
142 | ||
143 | static wxZipClassFactory g_wxZipClassFactory; | |
144 | ||
145 | wxZipClassFactory::wxZipClassFactory() | |
146 | { | |
147 | if (this == &g_wxZipClassFactory) | |
148 | PushFront(); | |
149 | } | |
150 | ||
151 | const wxChar * const * | |
152 | wxZipClassFactory::GetProtocols(wxStreamProtocolType type) const | |
153 | { | |
154 | static const wxChar *protocols[] = { _T("zip"), NULL }; | |
155 | static const wxChar *mimetypes[] = { _T("application/zip"), NULL }; | |
156 | static const wxChar *fileexts[] = { _T(".zip"), _T(".htb"), NULL }; | |
157 | static const wxChar *empty[] = { NULL }; | |
158 | ||
159 | switch (type) { | |
160 | case wxSTREAM_PROTOCOL: return protocols; | |
161 | case wxSTREAM_MIMETYPE: return mimetypes; | |
162 | case wxSTREAM_FILEEXT: return fileexts; | |
163 | default: return empty; | |
164 | } | |
165 | } | |
166 | ||
167 | ||
168 | ///////////////////////////////////////////////////////////////////////////// | |
169 | // Read a zip header | |
170 | ||
171 | class wxZipHeader | |
172 | { | |
173 | public: | |
174 | wxZipHeader(wxInputStream& stream, size_t size); | |
175 | ||
176 | inline wxUint8 Read8(); | |
177 | inline wxUint16 Read16(); | |
178 | inline wxUint32 Read32(); | |
179 | ||
180 | const char *GetData() const { return m_data; } | |
181 | size_t GetSize() const { return m_size; } | |
182 | operator bool() const { return m_ok; } | |
183 | ||
184 | size_t Seek(size_t pos) { m_pos = pos; return m_pos; } | |
185 | size_t Skip(size_t size) { m_pos += size; return m_pos; } | |
186 | ||
187 | wxZipHeader& operator>>(wxUint8& n) { n = Read8(); return *this; } | |
188 | wxZipHeader& operator>>(wxUint16& n) { n = Read16(); return *this; } | |
189 | wxZipHeader& operator>>(wxUint32& n) { n = Read32(); return *this; } | |
190 | ||
191 | private: | |
192 | char m_data[64]; | |
193 | size_t m_size; | |
194 | size_t m_pos; | |
195 | bool m_ok; | |
196 | }; | |
197 | ||
198 | wxZipHeader::wxZipHeader(wxInputStream& stream, size_t size) | |
199 | : m_size(0), | |
200 | m_pos(0), | |
201 | m_ok(false) | |
202 | { | |
203 | wxCHECK_RET(size <= sizeof(m_data), _T("buffer too small")); | |
204 | m_size = stream.Read(m_data, size).LastRead(); | |
205 | m_ok = m_size == size; | |
206 | } | |
207 | ||
208 | inline wxUint8 wxZipHeader::Read8() | |
209 | { | |
210 | wxASSERT(m_pos < m_size); | |
211 | return m_data[m_pos++]; | |
212 | } | |
213 | ||
214 | inline wxUint16 wxZipHeader::Read16() | |
215 | { | |
216 | wxASSERT(m_pos + 2 <= m_size); | |
217 | wxUint16 n = CrackUint16(m_data + m_pos); | |
218 | m_pos += 2; | |
219 | return n; | |
220 | } | |
221 | ||
222 | inline wxUint32 wxZipHeader::Read32() | |
223 | { | |
224 | wxASSERT(m_pos + 4 <= m_size); | |
225 | wxUint32 n = CrackUint32(m_data + m_pos); | |
226 | m_pos += 4; | |
227 | return n; | |
228 | } | |
229 | ||
230 | ||
231 | ///////////////////////////////////////////////////////////////////////////// | |
232 | // Stored input stream | |
233 | // Trival decompressor for files which are 'stored' in the zip file. | |
234 | ||
235 | class wxStoredInputStream : public wxFilterInputStream | |
236 | { | |
237 | public: | |
238 | wxStoredInputStream(wxInputStream& stream); | |
239 | ||
240 | void Open(wxFileOffset len) { Close(); m_len = len; } | |
241 | void Close() { m_pos = 0; m_lasterror = wxSTREAM_NO_ERROR; } | |
242 | ||
243 | virtual char Peek() { return wxInputStream::Peek(); } | |
244 | virtual wxFileOffset GetLength() const { return m_len; } | |
245 | ||
246 | protected: | |
247 | virtual size_t OnSysRead(void *buffer, size_t size); | |
248 | virtual wxFileOffset OnSysTell() const { return m_pos; } | |
249 | ||
250 | private: | |
251 | wxFileOffset m_pos; | |
252 | wxFileOffset m_len; | |
253 | ||
254 | wxDECLARE_NO_COPY_CLASS(wxStoredInputStream); | |
255 | }; | |
256 | ||
257 | wxStoredInputStream::wxStoredInputStream(wxInputStream& stream) | |
258 | : wxFilterInputStream(stream), | |
259 | m_pos(0), | |
260 | m_len(0) | |
261 | { | |
262 | } | |
263 | ||
264 | size_t wxStoredInputStream::OnSysRead(void *buffer, size_t size) | |
265 | { | |
266 | size_t count = wx_truncate_cast(size_t, | |
267 | wxMin(size + wxFileOffset(0), m_len - m_pos + size_t(0))); | |
268 | count = m_parent_i_stream->Read(buffer, count).LastRead(); | |
269 | m_pos += count; | |
270 | ||
271 | if (count < size) | |
272 | m_lasterror = m_pos == m_len ? wxSTREAM_EOF : wxSTREAM_READ_ERROR; | |
273 | ||
274 | return count; | |
275 | } | |
276 | ||
277 | ||
278 | ///////////////////////////////////////////////////////////////////////////// | |
279 | // Stored output stream | |
280 | // Trival compressor for files which are 'stored' in the zip file. | |
281 | ||
282 | class wxStoredOutputStream : public wxFilterOutputStream | |
283 | { | |
284 | public: | |
285 | wxStoredOutputStream(wxOutputStream& stream) : | |
286 | wxFilterOutputStream(stream), m_pos(0) { } | |
287 | ||
288 | bool Close() { | |
289 | m_pos = 0; | |
290 | m_lasterror = wxSTREAM_NO_ERROR; | |
291 | return true; | |
292 | } | |
293 | ||
294 | protected: | |
295 | virtual size_t OnSysWrite(const void *buffer, size_t size); | |
296 | virtual wxFileOffset OnSysTell() const { return m_pos; } | |
297 | ||
298 | private: | |
299 | wxFileOffset m_pos; | |
300 | wxDECLARE_NO_COPY_CLASS(wxStoredOutputStream); | |
301 | }; | |
302 | ||
303 | size_t wxStoredOutputStream::OnSysWrite(const void *buffer, size_t size) | |
304 | { | |
305 | if (!IsOk() || !size) | |
306 | return 0; | |
307 | size_t count = m_parent_o_stream->Write(buffer, size).LastWrite(); | |
308 | if (count != size) | |
309 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
310 | m_pos += count; | |
311 | return count; | |
312 | } | |
313 | ||
314 | ||
315 | ///////////////////////////////////////////////////////////////////////////// | |
316 | // wxRawInputStream | |
317 | // | |
318 | // Used to handle the unusal case of raw copying an entry of unknown | |
319 | // length. This can only happen when the zip being copied from is being | |
320 | // read from a non-seekable stream, and also was original written to a | |
321 | // non-seekable stream. | |
322 | // | |
323 | // In this case there's no option but to decompress the stream to find | |
324 | // it's length, but we can still write the raw compressed data to avoid the | |
325 | // compression overhead (which is the greater one). | |
326 | // | |
327 | // Usage is like this: | |
328 | // m_rawin = new wxRawInputStream(*m_parent_i_stream); | |
329 | // m_decomp = m_rawin->Open(OpenDecompressor(m_rawin->GetTee())); | |
330 | // | |
331 | // The wxRawInputStream owns a wxTeeInputStream object, the role of which | |
332 | // is something like the unix 'tee' command; it is a transparent filter, but | |
333 | // allows the data read to be read a second time via an extra method 'GetData'. | |
334 | // | |
335 | // The wxRawInputStream then draws data through the tee using a decompressor | |
336 | // then instead of returning the decompressed data, retuns the raw data | |
337 | // from wxTeeInputStream::GetData(). | |
338 | ||
339 | class wxTeeInputStream : public wxFilterInputStream | |
340 | { | |
341 | public: | |
342 | wxTeeInputStream(wxInputStream& stream); | |
343 | ||
344 | size_t GetCount() const { return m_end - m_start; } | |
345 | size_t GetData(char *buffer, size_t size); | |
346 | ||
347 | void Open(); | |
348 | bool Final(); | |
349 | ||
350 | wxInputStream& Read(void *buffer, size_t size); | |
351 | ||
352 | protected: | |
353 | virtual size_t OnSysRead(void *buffer, size_t size); | |
354 | virtual wxFileOffset OnSysTell() const { return m_pos; } | |
355 | ||
356 | private: | |
357 | wxFileOffset m_pos; | |
358 | wxMemoryBuffer m_buf; | |
359 | size_t m_start; | |
360 | size_t m_end; | |
361 | ||
362 | wxDECLARE_NO_COPY_CLASS(wxTeeInputStream); | |
363 | }; | |
364 | ||
365 | wxTeeInputStream::wxTeeInputStream(wxInputStream& stream) | |
366 | : wxFilterInputStream(stream), | |
367 | m_pos(0), m_buf(8192), m_start(0), m_end(0) | |
368 | { | |
369 | } | |
370 | ||
371 | void wxTeeInputStream::Open() | |
372 | { | |
373 | m_pos = m_start = m_end = 0; | |
374 | m_lasterror = wxSTREAM_NO_ERROR; | |
375 | } | |
376 | ||
377 | bool wxTeeInputStream::Final() | |
378 | { | |
379 | bool final = m_end == m_buf.GetDataLen(); | |
380 | m_end = m_buf.GetDataLen(); | |
381 | return final; | |
382 | } | |
383 | ||
384 | wxInputStream& wxTeeInputStream::Read(void *buffer, size_t size) | |
385 | { | |
386 | size_t count = wxInputStream::Read(buffer, size).LastRead(); | |
387 | m_end = m_buf.GetDataLen(); | |
388 | m_buf.AppendData(buffer, count); | |
389 | return *this; | |
390 | } | |
391 | ||
392 | size_t wxTeeInputStream::OnSysRead(void *buffer, size_t size) | |
393 | { | |
394 | size_t count = m_parent_i_stream->Read(buffer, size).LastRead(); | |
395 | if (count < size) | |
396 | m_lasterror = m_parent_i_stream->GetLastError(); | |
397 | return count; | |
398 | } | |
399 | ||
400 | size_t wxTeeInputStream::GetData(char *buffer, size_t size) | |
401 | { | |
402 | if (m_wbacksize) { | |
403 | size_t len = m_buf.GetDataLen(); | |
404 | len = len > m_wbacksize ? len - m_wbacksize : 0; | |
405 | m_buf.SetDataLen(len); | |
406 | if (m_end > len) { | |
407 | wxFAIL; // we've already returned data that's now being ungot | |
408 | m_end = len; | |
409 | } | |
410 | m_parent_i_stream->Reset(); | |
411 | m_parent_i_stream->Ungetch(m_wback, m_wbacksize); | |
412 | free(m_wback); | |
413 | m_wback = NULL; | |
414 | m_wbacksize = 0; | |
415 | m_wbackcur = 0; | |
416 | } | |
417 | ||
418 | if (size > GetCount()) | |
419 | size = GetCount(); | |
420 | if (size) { | |
421 | memcpy(buffer, m_buf + m_start, size); | |
422 | m_start += size; | |
423 | wxASSERT(m_start <= m_end); | |
424 | } | |
425 | ||
426 | if (m_start == m_end && m_start > 0 && m_buf.GetDataLen() > 0) { | |
427 | size_t len = m_buf.GetDataLen(); | |
428 | char *buf = (char*)m_buf.GetWriteBuf(len); | |
429 | len -= m_end; | |
430 | memmove(buf, buf + m_end, len); | |
431 | m_buf.UngetWriteBuf(len); | |
432 | m_start = m_end = 0; | |
433 | } | |
434 | ||
435 | return size; | |
436 | } | |
437 | ||
438 | class wxRawInputStream : public wxFilterInputStream | |
439 | { | |
440 | public: | |
441 | wxRawInputStream(wxInputStream& stream); | |
442 | virtual ~wxRawInputStream() { delete m_tee; } | |
443 | ||
444 | wxInputStream* Open(wxInputStream *decomp); | |
445 | wxInputStream& GetTee() const { return *m_tee; } | |
446 | ||
447 | protected: | |
448 | virtual size_t OnSysRead(void *buffer, size_t size); | |
449 | virtual wxFileOffset OnSysTell() const { return m_pos; } | |
450 | ||
451 | private: | |
452 | wxFileOffset m_pos; | |
453 | wxTeeInputStream *m_tee; | |
454 | ||
455 | enum { BUFSIZE = 8192 }; | |
456 | wxCharBuffer m_dummy; | |
457 | ||
458 | wxDECLARE_NO_COPY_CLASS(wxRawInputStream); | |
459 | }; | |
460 | ||
461 | wxRawInputStream::wxRawInputStream(wxInputStream& stream) | |
462 | : wxFilterInputStream(stream), | |
463 | m_pos(0), | |
464 | m_tee(new wxTeeInputStream(stream)), | |
465 | m_dummy(BUFSIZE) | |
466 | { | |
467 | } | |
468 | ||
469 | wxInputStream *wxRawInputStream::Open(wxInputStream *decomp) | |
470 | { | |
471 | if (decomp) { | |
472 | m_parent_i_stream = decomp; | |
473 | m_pos = 0; | |
474 | m_lasterror = wxSTREAM_NO_ERROR; | |
475 | m_tee->Open(); | |
476 | return this; | |
477 | } else { | |
478 | return NULL; | |
479 | } | |
480 | } | |
481 | ||
482 | size_t wxRawInputStream::OnSysRead(void *buffer, size_t size) | |
483 | { | |
484 | char *buf = (char*)buffer; | |
485 | size_t count = 0; | |
486 | ||
487 | while (count < size && IsOk()) | |
488 | { | |
489 | while (m_parent_i_stream->IsOk() && m_tee->GetCount() == 0) | |
490 | m_parent_i_stream->Read(m_dummy.data(), BUFSIZE); | |
491 | ||
492 | size_t n = m_tee->GetData(buf + count, size - count); | |
493 | count += n; | |
494 | ||
495 | if (n == 0 && m_tee->Final()) | |
496 | m_lasterror = m_parent_i_stream->GetLastError(); | |
497 | } | |
498 | ||
499 | m_pos += count; | |
500 | return count; | |
501 | } | |
502 | ||
503 | ||
504 | ///////////////////////////////////////////////////////////////////////////// | |
505 | // Zlib streams than can be reused without recreating. | |
506 | ||
507 | class wxZlibOutputStream2 : public wxZlibOutputStream | |
508 | { | |
509 | public: | |
510 | wxZlibOutputStream2(wxOutputStream& stream, int level) : | |
511 | wxZlibOutputStream(stream, level, wxZLIB_NO_HEADER) { } | |
512 | ||
513 | bool Open(wxOutputStream& stream); | |
514 | bool Close() { DoFlush(true); m_pos = wxInvalidOffset; return IsOk(); } | |
515 | }; | |
516 | ||
517 | bool wxZlibOutputStream2::Open(wxOutputStream& stream) | |
518 | { | |
519 | wxCHECK(m_pos == wxInvalidOffset, false); | |
520 | ||
521 | m_deflate->next_out = m_z_buffer; | |
522 | m_deflate->avail_out = m_z_size; | |
523 | m_pos = 0; | |
524 | m_lasterror = wxSTREAM_NO_ERROR; | |
525 | m_parent_o_stream = &stream; | |
526 | ||
527 | if (deflateReset(m_deflate) != Z_OK) { | |
528 | wxLogError(_("can't re-initialize zlib deflate stream")); | |
529 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
530 | return false; | |
531 | } | |
532 | ||
533 | return true; | |
534 | } | |
535 | ||
536 | class wxZlibInputStream2 : public wxZlibInputStream | |
537 | { | |
538 | public: | |
539 | wxZlibInputStream2(wxInputStream& stream) : | |
540 | wxZlibInputStream(stream, wxZLIB_NO_HEADER) { } | |
541 | ||
542 | bool Open(wxInputStream& stream); | |
543 | }; | |
544 | ||
545 | bool wxZlibInputStream2::Open(wxInputStream& stream) | |
546 | { | |
547 | m_inflate->avail_in = 0; | |
548 | m_pos = 0; | |
549 | m_lasterror = wxSTREAM_NO_ERROR; | |
550 | m_parent_i_stream = &stream; | |
551 | ||
552 | if (inflateReset(m_inflate) != Z_OK) { | |
553 | wxLogError(_("can't re-initialize zlib inflate stream")); | |
554 | m_lasterror = wxSTREAM_READ_ERROR; | |
555 | return false; | |
556 | } | |
557 | ||
558 | return true; | |
559 | } | |
560 | ||
561 | ||
562 | ///////////////////////////////////////////////////////////////////////////// | |
563 | // Class to hold wxZipEntry's Extra and LocalExtra fields | |
564 | ||
565 | class wxZipMemory | |
566 | { | |
567 | public: | |
568 | wxZipMemory() : m_data(NULL), m_size(0), m_capacity(0), m_ref(1) { } | |
569 | ||
570 | wxZipMemory *AddRef() { m_ref++; return this; } | |
571 | void Release() { if (--m_ref == 0) delete this; } | |
572 | ||
573 | char *GetData() const { return m_data; } | |
574 | size_t GetSize() const { return m_size; } | |
575 | size_t GetCapacity() const { return m_capacity; } | |
576 | ||
577 | wxZipMemory *Unique(size_t size); | |
578 | ||
579 | private: | |
580 | ~wxZipMemory() { delete [] m_data; } | |
581 | ||
582 | char *m_data; | |
583 | size_t m_size; | |
584 | size_t m_capacity; | |
585 | int m_ref; | |
586 | ||
587 | wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(wxZipMemory) | |
588 | }; | |
589 | ||
590 | wxZipMemory *wxZipMemory::Unique(size_t size) | |
591 | { | |
592 | wxZipMemory *zm; | |
593 | ||
594 | if (m_ref > 1) { | |
595 | --m_ref; | |
596 | zm = new wxZipMemory; | |
597 | } else { | |
598 | zm = this; | |
599 | } | |
600 | ||
601 | if (zm->m_capacity < size) { | |
602 | delete [] zm->m_data; | |
603 | zm->m_data = new char[size]; | |
604 | zm->m_capacity = size; | |
605 | } | |
606 | ||
607 | zm->m_size = size; | |
608 | return zm; | |
609 | } | |
610 | ||
611 | static inline wxZipMemory *AddRef(wxZipMemory *zm) | |
612 | { | |
613 | if (zm) | |
614 | zm->AddRef(); | |
615 | return zm; | |
616 | } | |
617 | ||
618 | static inline void Release(wxZipMemory *zm) | |
619 | { | |
620 | if (zm) | |
621 | zm->Release(); | |
622 | } | |
623 | ||
624 | static void Copy(wxZipMemory*& dest, wxZipMemory *src) | |
625 | { | |
626 | Release(dest); | |
627 | dest = AddRef(src); | |
628 | } | |
629 | ||
630 | static void Unique(wxZipMemory*& zm, size_t size) | |
631 | { | |
632 | if (!zm && size) | |
633 | zm = new wxZipMemory; | |
634 | if (zm) | |
635 | zm = zm->Unique(size); | |
636 | } | |
637 | ||
638 | ||
639 | ///////////////////////////////////////////////////////////////////////////// | |
640 | // Collection of weak references to entries | |
641 | ||
642 | WX_DECLARE_HASH_MAP(long, wxZipEntry*, wxIntegerHash, | |
643 | wxIntegerEqual, wxOffsetZipEntryMap_); | |
644 | ||
645 | class wxZipWeakLinks | |
646 | { | |
647 | public: | |
648 | wxZipWeakLinks() : m_ref(1) { } | |
649 | ||
650 | void Release(const wxZipInputStream* WXUNUSED(x)) | |
651 | { if (--m_ref == 0) delete this; } | |
652 | void Release(wxFileOffset key) | |
653 | { RemoveEntry(key); if (--m_ref == 0) delete this; } | |
654 | ||
655 | wxZipWeakLinks *AddEntry(wxZipEntry *entry, wxFileOffset key); | |
656 | void RemoveEntry(wxFileOffset key) | |
657 | { m_entries.erase(wx_truncate_cast(key_type, key)); } | |
658 | wxZipEntry *GetEntry(wxFileOffset key) const; | |
659 | bool IsEmpty() const { return m_entries.empty(); } | |
660 | ||
661 | private: | |
662 | ~wxZipWeakLinks() { wxASSERT(IsEmpty()); } | |
663 | ||
664 | typedef wxOffsetZipEntryMap_::key_type key_type; | |
665 | ||
666 | int m_ref; | |
667 | wxOffsetZipEntryMap_ m_entries; | |
668 | ||
669 | wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(wxZipWeakLinks) | |
670 | }; | |
671 | ||
672 | wxZipWeakLinks *wxZipWeakLinks::AddEntry(wxZipEntry *entry, wxFileOffset key) | |
673 | { | |
674 | m_entries[wx_truncate_cast(key_type, key)] = entry; | |
675 | m_ref++; | |
676 | return this; | |
677 | } | |
678 | ||
679 | wxZipEntry *wxZipWeakLinks::GetEntry(wxFileOffset key) const | |
680 | { | |
681 | wxOffsetZipEntryMap_::const_iterator it = | |
682 | m_entries.find(wx_truncate_cast(key_type, key)); | |
683 | return it != m_entries.end() ? it->second : NULL; | |
684 | } | |
685 | ||
686 | ||
687 | ///////////////////////////////////////////////////////////////////////////// | |
688 | // ZipEntry | |
689 | ||
690 | wxZipEntry::wxZipEntry( | |
691 | const wxString& name /*=wxEmptyString*/, | |
692 | const wxDateTime& dt /*=wxDateTime::Now()*/, | |
693 | wxFileOffset size /*=wxInvalidOffset*/) | |
694 | : | |
695 | m_SystemMadeBy(wxZIP_SYSTEM_MSDOS), | |
696 | m_VersionMadeBy(wxMAJOR_VERSION * 10 + wxMINOR_VERSION), | |
697 | m_VersionNeeded(VERSION_NEEDED_TO_EXTRACT), | |
698 | m_Flags(0), | |
699 | m_Method(wxZIP_METHOD_DEFAULT), | |
700 | m_DateTime(dt), | |
701 | m_Crc(0), | |
702 | m_CompressedSize(wxInvalidOffset), | |
703 | m_Size(size), | |
704 | m_Key(wxInvalidOffset), | |
705 | m_Offset(wxInvalidOffset), | |
706 | m_DiskStart(0), | |
707 | m_InternalAttributes(0), | |
708 | m_ExternalAttributes(0), | |
709 | m_Extra(NULL), | |
710 | m_LocalExtra(NULL), | |
711 | m_zipnotifier(NULL), | |
712 | m_backlink(NULL) | |
713 | { | |
714 | if (!name.empty()) | |
715 | SetName(name); | |
716 | } | |
717 | ||
718 | wxZipEntry::~wxZipEntry() | |
719 | { | |
720 | if (m_backlink) | |
721 | m_backlink->Release(m_Key); | |
722 | Release(m_Extra); | |
723 | Release(m_LocalExtra); | |
724 | } | |
725 | ||
726 | wxZipEntry::wxZipEntry(const wxZipEntry& e) | |
727 | : wxArchiveEntry(e), | |
728 | m_SystemMadeBy(e.m_SystemMadeBy), | |
729 | m_VersionMadeBy(e.m_VersionMadeBy), | |
730 | m_VersionNeeded(e.m_VersionNeeded), | |
731 | m_Flags(e.m_Flags), | |
732 | m_Method(e.m_Method), | |
733 | m_DateTime(e.m_DateTime), | |
734 | m_Crc(e.m_Crc), | |
735 | m_CompressedSize(e.m_CompressedSize), | |
736 | m_Size(e.m_Size), | |
737 | m_Name(e.m_Name), | |
738 | m_Key(e.m_Key), | |
739 | m_Offset(e.m_Offset), | |
740 | m_Comment(e.m_Comment), | |
741 | m_DiskStart(e.m_DiskStart), | |
742 | m_InternalAttributes(e.m_InternalAttributes), | |
743 | m_ExternalAttributes(e.m_ExternalAttributes), | |
744 | m_Extra(AddRef(e.m_Extra)), | |
745 | m_LocalExtra(AddRef(e.m_LocalExtra)), | |
746 | m_zipnotifier(NULL), | |
747 | m_backlink(NULL) | |
748 | { | |
749 | } | |
750 | ||
751 | wxZipEntry& wxZipEntry::operator=(const wxZipEntry& e) | |
752 | { | |
753 | if (&e != this) { | |
754 | m_SystemMadeBy = e.m_SystemMadeBy; | |
755 | m_VersionMadeBy = e.m_VersionMadeBy; | |
756 | m_VersionNeeded = e.m_VersionNeeded; | |
757 | m_Flags = e.m_Flags; | |
758 | m_Method = e.m_Method; | |
759 | m_DateTime = e.m_DateTime; | |
760 | m_Crc = e.m_Crc; | |
761 | m_CompressedSize = e.m_CompressedSize; | |
762 | m_Size = e.m_Size; | |
763 | m_Name = e.m_Name; | |
764 | m_Key = e.m_Key; | |
765 | m_Offset = e.m_Offset; | |
766 | m_Comment = e.m_Comment; | |
767 | m_DiskStart = e.m_DiskStart; | |
768 | m_InternalAttributes = e.m_InternalAttributes; | |
769 | m_ExternalAttributes = e.m_ExternalAttributes; | |
770 | Copy(m_Extra, e.m_Extra); | |
771 | Copy(m_LocalExtra, e.m_LocalExtra); | |
772 | m_zipnotifier = NULL; | |
773 | if (m_backlink) { | |
774 | m_backlink->Release(m_Key); | |
775 | m_backlink = NULL; | |
776 | } | |
777 | } | |
778 | return *this; | |
779 | } | |
780 | ||
781 | wxString wxZipEntry::GetName(wxPathFormat format /*=wxPATH_NATIVE*/) const | |
782 | { | |
783 | bool isDir = IsDir() && !m_Name.empty(); | |
784 | ||
785 | // optimisations for common (and easy) cases | |
786 | switch (wxFileName::GetFormat(format)) { | |
787 | case wxPATH_DOS: | |
788 | { | |
789 | wxString name(isDir ? m_Name + _T("\\") : m_Name); | |
790 | for (size_t i = 0; i < name.length(); i++) | |
791 | if (name[i] == _T('/')) | |
792 | name[i] = _T('\\'); | |
793 | return name; | |
794 | } | |
795 | ||
796 | case wxPATH_UNIX: | |
797 | return isDir ? m_Name + _T("/") : m_Name; | |
798 | ||
799 | default: | |
800 | ; | |
801 | } | |
802 | ||
803 | wxFileName fn; | |
804 | ||
805 | if (isDir) | |
806 | fn.AssignDir(m_Name, wxPATH_UNIX); | |
807 | else | |
808 | fn.Assign(m_Name, wxPATH_UNIX); | |
809 | ||
810 | return fn.GetFullPath(format); | |
811 | } | |
812 | ||
813 | // Static - Internally tars and zips use forward slashes for the path | |
814 | // separator, absolute paths aren't allowed, and directory names have a | |
815 | // trailing slash. This function converts a path into this internal format, | |
816 | // but without a trailing slash for a directory. | |
817 | // | |
818 | wxString wxZipEntry::GetInternalName(const wxString& name, | |
819 | wxPathFormat format /*=wxPATH_NATIVE*/, | |
820 | bool *pIsDir /*=NULL*/) | |
821 | { | |
822 | wxString internal; | |
823 | ||
824 | if (wxFileName::GetFormat(format) != wxPATH_UNIX) | |
825 | internal = wxFileName(name, format).GetFullPath(wxPATH_UNIX); | |
826 | else | |
827 | internal = name; | |
828 | ||
829 | bool isDir = !internal.empty() && internal.Last() == '/'; | |
830 | if (pIsDir) | |
831 | *pIsDir = isDir; | |
832 | if (isDir) | |
833 | internal.erase(internal.length() - 1); | |
834 | ||
835 | while (!internal.empty() && *internal.begin() == '/') | |
836 | internal.erase(0, 1); | |
837 | while (!internal.empty() && internal.compare(0, 2, _T("./")) == 0) | |
838 | internal.erase(0, 2); | |
839 | if (internal == _T(".") || internal == _T("..")) | |
840 | internal = wxEmptyString; | |
841 | ||
842 | return internal; | |
843 | } | |
844 | ||
845 | void wxZipEntry::SetSystemMadeBy(int system) | |
846 | { | |
847 | int mode = GetMode(); | |
848 | bool wasUnix = IsMadeByUnix(); | |
849 | ||
850 | m_SystemMadeBy = (wxUint8)system; | |
851 | ||
852 | if (!wasUnix && IsMadeByUnix()) { | |
853 | SetIsDir(IsDir()); | |
854 | SetMode(mode); | |
855 | } else if (wasUnix && !IsMadeByUnix()) { | |
856 | m_ExternalAttributes &= 0xffff; | |
857 | } | |
858 | } | |
859 | ||
860 | void wxZipEntry::SetIsDir(bool isDir /*=true*/) | |
861 | { | |
862 | if (isDir) | |
863 | m_ExternalAttributes |= wxZIP_A_SUBDIR; | |
864 | else | |
865 | m_ExternalAttributes &= ~wxZIP_A_SUBDIR; | |
866 | ||
867 | if (IsMadeByUnix()) { | |
868 | m_ExternalAttributes &= ~wxZIP_S_IFMT; | |
869 | if (isDir) | |
870 | m_ExternalAttributes |= wxZIP_S_IFDIR; | |
871 | else | |
872 | m_ExternalAttributes |= wxZIP_S_IFREG; | |
873 | } | |
874 | } | |
875 | ||
876 | // Return unix style permission bits | |
877 | // | |
878 | int wxZipEntry::GetMode() const | |
879 | { | |
880 | // return unix permissions if present | |
881 | if (IsMadeByUnix()) | |
882 | return (m_ExternalAttributes >> 16) & 0777; | |
883 | ||
884 | // otherwise synthesize from the dos attribs | |
885 | int mode = 0644; | |
886 | if (m_ExternalAttributes & wxZIP_A_RDONLY) | |
887 | mode &= ~0200; | |
888 | if (m_ExternalAttributes & wxZIP_A_SUBDIR) | |
889 | mode |= 0111; | |
890 | ||
891 | return mode; | |
892 | } | |
893 | ||
894 | // Set unix permissions | |
895 | // | |
896 | void wxZipEntry::SetMode(int mode) | |
897 | { | |
898 | // Set dos attrib bits to be compatible | |
899 | if (mode & 0222) | |
900 | m_ExternalAttributes &= ~wxZIP_A_RDONLY; | |
901 | else | |
902 | m_ExternalAttributes |= wxZIP_A_RDONLY; | |
903 | ||
904 | // set the actual unix permission bits if the system type allows | |
905 | if (IsMadeByUnix()) { | |
906 | m_ExternalAttributes &= ~(0777L << 16); | |
907 | m_ExternalAttributes |= (mode & 0777L) << 16; | |
908 | } | |
909 | } | |
910 | ||
911 | const char *wxZipEntry::GetExtra() const | |
912 | { | |
913 | return m_Extra ? m_Extra->GetData() : NULL; | |
914 | } | |
915 | ||
916 | size_t wxZipEntry::GetExtraLen() const | |
917 | { | |
918 | return m_Extra ? m_Extra->GetSize() : 0; | |
919 | } | |
920 | ||
921 | void wxZipEntry::SetExtra(const char *extra, size_t len) | |
922 | { | |
923 | Unique(m_Extra, len); | |
924 | if (len) | |
925 | memcpy(m_Extra->GetData(), extra, len); | |
926 | } | |
927 | ||
928 | const char *wxZipEntry::GetLocalExtra() const | |
929 | { | |
930 | return m_LocalExtra ? m_LocalExtra->GetData() : NULL; | |
931 | } | |
932 | ||
933 | size_t wxZipEntry::GetLocalExtraLen() const | |
934 | { | |
935 | return m_LocalExtra ? m_LocalExtra->GetSize() : 0; | |
936 | } | |
937 | ||
938 | void wxZipEntry::SetLocalExtra(const char *extra, size_t len) | |
939 | { | |
940 | Unique(m_LocalExtra, len); | |
941 | if (len) | |
942 | memcpy(m_LocalExtra->GetData(), extra, len); | |
943 | } | |
944 | ||
945 | void wxZipEntry::SetNotifier(wxZipNotifier& notifier) | |
946 | { | |
947 | wxArchiveEntry::UnsetNotifier(); | |
948 | m_zipnotifier = ¬ifier; | |
949 | m_zipnotifier->OnEntryUpdated(*this); | |
950 | } | |
951 | ||
952 | void wxZipEntry::Notify() | |
953 | { | |
954 | if (m_zipnotifier) | |
955 | m_zipnotifier->OnEntryUpdated(*this); | |
956 | else if (GetNotifier()) | |
957 | GetNotifier()->OnEntryUpdated(*this); | |
958 | } | |
959 | ||
960 | void wxZipEntry::UnsetNotifier() | |
961 | { | |
962 | wxArchiveEntry::UnsetNotifier(); | |
963 | m_zipnotifier = NULL; | |
964 | } | |
965 | ||
966 | size_t wxZipEntry::ReadLocal(wxInputStream& stream, wxMBConv& conv) | |
967 | { | |
968 | wxUint16 nameLen, extraLen; | |
969 | wxUint32 compressedSize, size, crc; | |
970 | ||
971 | wxZipHeader ds(stream, LOCAL_SIZE - 4); | |
972 | if (!ds) | |
973 | return 0; | |
974 | ||
975 | ds >> m_VersionNeeded >> m_Flags >> m_Method; | |
976 | SetDateTime(wxDateTime().SetFromDOS(ds.Read32())); | |
977 | ds >> crc >> compressedSize >> size >> nameLen >> extraLen; | |
978 | ||
979 | bool sumsValid = (m_Flags & wxZIP_SUMS_FOLLOW) == 0; | |
980 | ||
981 | if (sumsValid || crc) | |
982 | m_Crc = crc; | |
983 | if ((sumsValid || compressedSize) || m_Method == wxZIP_METHOD_STORE) | |
984 | m_CompressedSize = compressedSize; | |
985 | if ((sumsValid || size) || m_Method == wxZIP_METHOD_STORE) | |
986 | m_Size = size; | |
987 | ||
988 | SetName(ReadString(stream, nameLen, conv), wxPATH_UNIX); | |
989 | if (stream.LastRead() != nameLen + 0u) | |
990 | return 0; | |
991 | ||
992 | if (extraLen || GetLocalExtraLen()) { | |
993 | Unique(m_LocalExtra, extraLen); | |
994 | if (extraLen) { | |
995 | stream.Read(m_LocalExtra->GetData(), extraLen); | |
996 | if (stream.LastRead() != extraLen + 0u) | |
997 | return 0; | |
998 | } | |
999 | } | |
1000 | ||
1001 | return LOCAL_SIZE + nameLen + extraLen; | |
1002 | } | |
1003 | ||
1004 | size_t wxZipEntry::WriteLocal(wxOutputStream& stream, wxMBConv& conv) const | |
1005 | { | |
1006 | wxString unixName = GetName(wxPATH_UNIX); | |
1007 | const wxWX2MBbuf name_buf = unixName.mb_str(conv); | |
1008 | const char *name = name_buf; | |
1009 | if (!name) name = ""; | |
1010 | wxUint16 nameLen = wx_truncate_cast(wxUint16, strlen(name)); | |
1011 | ||
1012 | wxDataOutputStream ds(stream); | |
1013 | ||
1014 | ds << m_VersionNeeded << m_Flags << m_Method; | |
1015 | ds.Write32(GetDateTime().GetAsDOS()); | |
1016 | ||
1017 | ds.Write32(m_Crc); | |
1018 | ds.Write32(m_CompressedSize != wxInvalidOffset ? | |
1019 | wx_truncate_cast(wxUint32, m_CompressedSize) : 0); | |
1020 | ds.Write32(m_Size != wxInvalidOffset ? | |
1021 | wx_truncate_cast(wxUint32, m_Size) : 0); | |
1022 | ||
1023 | ds << nameLen; | |
1024 | wxUint16 extraLen = wx_truncate_cast(wxUint16, GetLocalExtraLen()); | |
1025 | ds.Write16(extraLen); | |
1026 | ||
1027 | stream.Write(name, nameLen); | |
1028 | if (extraLen) | |
1029 | stream.Write(m_LocalExtra->GetData(), extraLen); | |
1030 | ||
1031 | return LOCAL_SIZE + nameLen + extraLen; | |
1032 | } | |
1033 | ||
1034 | size_t wxZipEntry::ReadCentral(wxInputStream& stream, wxMBConv& conv) | |
1035 | { | |
1036 | wxUint16 nameLen, extraLen, commentLen; | |
1037 | ||
1038 | wxZipHeader ds(stream, CENTRAL_SIZE - 4); | |
1039 | if (!ds) | |
1040 | return 0; | |
1041 | ||
1042 | ds >> m_VersionMadeBy >> m_SystemMadeBy; | |
1043 | ||
1044 | SetVersionNeeded(ds.Read16()); | |
1045 | SetFlags(ds.Read16()); | |
1046 | SetMethod(ds.Read16()); | |
1047 | SetDateTime(wxDateTime().SetFromDOS(ds.Read32())); | |
1048 | SetCrc(ds.Read32()); | |
1049 | SetCompressedSize(ds.Read32()); | |
1050 | SetSize(ds.Read32()); | |
1051 | ||
1052 | ds >> nameLen >> extraLen >> commentLen | |
1053 | >> m_DiskStart >> m_InternalAttributes >> m_ExternalAttributes; | |
1054 | SetOffset(ds.Read32()); | |
1055 | ||
1056 | SetName(ReadString(stream, nameLen, conv), wxPATH_UNIX); | |
1057 | if (stream.LastRead() != nameLen + 0u) | |
1058 | return 0; | |
1059 | ||
1060 | if (extraLen || GetExtraLen()) { | |
1061 | Unique(m_Extra, extraLen); | |
1062 | if (extraLen) { | |
1063 | stream.Read(m_Extra->GetData(), extraLen); | |
1064 | if (stream.LastRead() != extraLen + 0u) | |
1065 | return 0; | |
1066 | } | |
1067 | } | |
1068 | ||
1069 | if (commentLen) { | |
1070 | m_Comment = ReadString(stream, commentLen, conv); | |
1071 | if (stream.LastRead() != commentLen + 0u) | |
1072 | return 0; | |
1073 | } else { | |
1074 | m_Comment.clear(); | |
1075 | } | |
1076 | ||
1077 | return CENTRAL_SIZE + nameLen + extraLen + commentLen; | |
1078 | } | |
1079 | ||
1080 | size_t wxZipEntry::WriteCentral(wxOutputStream& stream, wxMBConv& conv) const | |
1081 | { | |
1082 | wxString unixName = GetName(wxPATH_UNIX); | |
1083 | const wxWX2MBbuf name_buf = unixName.mb_str(conv); | |
1084 | const char *name = name_buf; | |
1085 | if (!name) name = ""; | |
1086 | wxUint16 nameLen = wx_truncate_cast(wxUint16, strlen(name)); | |
1087 | ||
1088 | const wxWX2MBbuf comment_buf = m_Comment.mb_str(conv); | |
1089 | const char *comment = comment_buf; | |
1090 | if (!comment) comment = ""; | |
1091 | wxUint16 commentLen = wx_truncate_cast(wxUint16, strlen(comment)); | |
1092 | ||
1093 | wxUint16 extraLen = wx_truncate_cast(wxUint16, GetExtraLen()); | |
1094 | ||
1095 | wxDataOutputStream ds(stream); | |
1096 | ||
1097 | ds << CENTRAL_MAGIC << m_VersionMadeBy << m_SystemMadeBy; | |
1098 | ||
1099 | ds.Write16(wx_truncate_cast(wxUint16, GetVersionNeeded())); | |
1100 | ds.Write16(wx_truncate_cast(wxUint16, GetFlags())); | |
1101 | ds.Write16(wx_truncate_cast(wxUint16, GetMethod())); | |
1102 | ds.Write32(GetDateTime().GetAsDOS()); | |
1103 | ds.Write32(GetCrc()); | |
1104 | ds.Write32(wx_truncate_cast(wxUint32, GetCompressedSize())); | |
1105 | ds.Write32(wx_truncate_cast(wxUint32, GetSize())); | |
1106 | ds.Write16(nameLen); | |
1107 | ds.Write16(extraLen); | |
1108 | ||
1109 | ds << commentLen << m_DiskStart << m_InternalAttributes | |
1110 | << m_ExternalAttributes << wx_truncate_cast(wxUint32, GetOffset()); | |
1111 | ||
1112 | stream.Write(name, nameLen); | |
1113 | if (extraLen) | |
1114 | stream.Write(GetExtra(), extraLen); | |
1115 | stream.Write(comment, commentLen); | |
1116 | ||
1117 | return CENTRAL_SIZE + nameLen + extraLen + commentLen; | |
1118 | } | |
1119 | ||
1120 | // Info-zip prefixes this record with a signature, but pkzip doesn't. So if | |
1121 | // the 1st value is the signature then it is probably an info-zip record, | |
1122 | // though there is a small chance that it is in fact a pkzip record which | |
1123 | // happens to have the signature as it's CRC. | |
1124 | // | |
1125 | size_t wxZipEntry::ReadDescriptor(wxInputStream& stream) | |
1126 | { | |
1127 | wxZipHeader ds(stream, SUMS_SIZE); | |
1128 | if (!ds) | |
1129 | return 0; | |
1130 | ||
1131 | m_Crc = ds.Read32(); | |
1132 | m_CompressedSize = ds.Read32(); | |
1133 | m_Size = ds.Read32(); | |
1134 | ||
1135 | // if 1st value is the signature then this is probably an info-zip record | |
1136 | if (m_Crc == SUMS_MAGIC) | |
1137 | { | |
1138 | wxZipHeader buf(stream, 8); | |
1139 | wxUint32 u1 = buf.GetSize() >= 4 ? buf.Read32() : (wxUint32)LOCAL_MAGIC; | |
1140 | wxUint32 u2 = buf.GetSize() == 8 ? buf.Read32() : 0; | |
1141 | ||
1142 | // look for the signature of the following record to decide which | |
1143 | if ((u1 == LOCAL_MAGIC || u1 == CENTRAL_MAGIC) && | |
1144 | (u2 != LOCAL_MAGIC && u2 != CENTRAL_MAGIC)) | |
1145 | { | |
1146 | // it's a pkzip style record after all! | |
1147 | if (buf.GetSize() > 0) | |
1148 | stream.Ungetch(buf.GetData(), buf.GetSize()); | |
1149 | } | |
1150 | else | |
1151 | { | |
1152 | // it's an info-zip record as expected | |
1153 | if (buf.GetSize() > 4) | |
1154 | stream.Ungetch(buf.GetData() + 4, buf.GetSize() - 4); | |
1155 | m_Crc = wx_truncate_cast(wxUint32, m_CompressedSize); | |
1156 | m_CompressedSize = m_Size; | |
1157 | m_Size = u1; | |
1158 | return SUMS_SIZE + 4; | |
1159 | } | |
1160 | } | |
1161 | ||
1162 | return SUMS_SIZE; | |
1163 | } | |
1164 | ||
1165 | size_t wxZipEntry::WriteDescriptor(wxOutputStream& stream, wxUint32 crc, | |
1166 | wxFileOffset compressedSize, wxFileOffset size) | |
1167 | { | |
1168 | m_Crc = crc; | |
1169 | m_CompressedSize = compressedSize; | |
1170 | m_Size = size; | |
1171 | ||
1172 | wxDataOutputStream ds(stream); | |
1173 | ||
1174 | ds.Write32(crc); | |
1175 | ds.Write32(wx_truncate_cast(wxUint32, compressedSize)); | |
1176 | ds.Write32(wx_truncate_cast(wxUint32, size)); | |
1177 | ||
1178 | return SUMS_SIZE; | |
1179 | } | |
1180 | ||
1181 | ||
1182 | ///////////////////////////////////////////////////////////////////////////// | |
1183 | // wxZipEndRec - holds the end of central directory record | |
1184 | ||
1185 | class wxZipEndRec | |
1186 | { | |
1187 | public: | |
1188 | wxZipEndRec(); | |
1189 | ||
1190 | int GetDiskNumber() const { return m_DiskNumber; } | |
1191 | int GetStartDisk() const { return m_StartDisk; } | |
1192 | int GetEntriesHere() const { return m_EntriesHere; } | |
1193 | int GetTotalEntries() const { return m_TotalEntries; } | |
1194 | wxFileOffset GetSize() const { return m_Size; } | |
1195 | wxFileOffset GetOffset() const { return m_Offset; } | |
1196 | wxString GetComment() const { return m_Comment; } | |
1197 | ||
1198 | void SetDiskNumber(int num) | |
1199 | { m_DiskNumber = wx_truncate_cast(wxUint16, num); } | |
1200 | void SetStartDisk(int num) | |
1201 | { m_StartDisk = wx_truncate_cast(wxUint16, num); } | |
1202 | void SetEntriesHere(int num) | |
1203 | { m_EntriesHere = wx_truncate_cast(wxUint16, num); } | |
1204 | void SetTotalEntries(int num) | |
1205 | { m_TotalEntries = wx_truncate_cast(wxUint16, num); } | |
1206 | void SetSize(wxFileOffset size) | |
1207 | { m_Size = wx_truncate_cast(wxUint32, size); } | |
1208 | void SetOffset(wxFileOffset offset) | |
1209 | { m_Offset = wx_truncate_cast(wxUint32, offset); } | |
1210 | void SetComment(const wxString& comment) | |
1211 | { m_Comment = comment; } | |
1212 | ||
1213 | bool Read(wxInputStream& stream, wxMBConv& conv); | |
1214 | bool Write(wxOutputStream& stream, wxMBConv& conv) const; | |
1215 | ||
1216 | private: | |
1217 | wxUint16 m_DiskNumber; | |
1218 | wxUint16 m_StartDisk; | |
1219 | wxUint16 m_EntriesHere; | |
1220 | wxUint16 m_TotalEntries; | |
1221 | wxUint32 m_Size; | |
1222 | wxUint32 m_Offset; | |
1223 | wxString m_Comment; | |
1224 | }; | |
1225 | ||
1226 | wxZipEndRec::wxZipEndRec() | |
1227 | : m_DiskNumber(0), | |
1228 | m_StartDisk(0), | |
1229 | m_EntriesHere(0), | |
1230 | m_TotalEntries(0), | |
1231 | m_Size(0), | |
1232 | m_Offset(0) | |
1233 | { | |
1234 | } | |
1235 | ||
1236 | bool wxZipEndRec::Write(wxOutputStream& stream, wxMBConv& conv) const | |
1237 | { | |
1238 | const wxWX2MBbuf comment_buf = m_Comment.mb_str(conv); | |
1239 | const char *comment = comment_buf; | |
1240 | if (!comment) comment = ""; | |
1241 | wxUint16 commentLen = (wxUint16)strlen(comment); | |
1242 | ||
1243 | wxDataOutputStream ds(stream); | |
1244 | ||
1245 | ds << END_MAGIC << m_DiskNumber << m_StartDisk << m_EntriesHere | |
1246 | << m_TotalEntries << m_Size << m_Offset << commentLen; | |
1247 | ||
1248 | stream.Write(comment, commentLen); | |
1249 | ||
1250 | return stream.IsOk(); | |
1251 | } | |
1252 | ||
1253 | bool wxZipEndRec::Read(wxInputStream& stream, wxMBConv& conv) | |
1254 | { | |
1255 | wxZipHeader ds(stream, END_SIZE - 4); | |
1256 | if (!ds) | |
1257 | return false; | |
1258 | ||
1259 | wxUint16 commentLen; | |
1260 | ||
1261 | ds >> m_DiskNumber >> m_StartDisk >> m_EntriesHere | |
1262 | >> m_TotalEntries >> m_Size >> m_Offset >> commentLen; | |
1263 | ||
1264 | if (commentLen) { | |
1265 | m_Comment = ReadString(stream, commentLen, conv); | |
1266 | if (stream.LastRead() != commentLen + 0u) | |
1267 | return false; | |
1268 | } | |
1269 | ||
1270 | if (m_DiskNumber != 0 || m_StartDisk != 0 || | |
1271 | m_EntriesHere != m_TotalEntries) | |
1272 | wxLogWarning(_("assuming this is a multi-part zip concatenated")); | |
1273 | ||
1274 | return true; | |
1275 | } | |
1276 | ||
1277 | ||
1278 | ///////////////////////////////////////////////////////////////////////////// | |
1279 | // A weak link from an input stream to an output stream | |
1280 | ||
1281 | class wxZipStreamLink | |
1282 | { | |
1283 | public: | |
1284 | wxZipStreamLink(wxZipOutputStream *stream) : m_ref(1), m_stream(stream) { } | |
1285 | ||
1286 | wxZipStreamLink *AddRef() { m_ref++; return this; } | |
1287 | wxZipOutputStream *GetOutputStream() const { return m_stream; } | |
1288 | ||
1289 | void Release(class wxZipInputStream *WXUNUSED(s)) | |
1290 | { if (--m_ref == 0) delete this; } | |
1291 | void Release(class wxZipOutputStream *WXUNUSED(s)) | |
1292 | { m_stream = NULL; if (--m_ref == 0) delete this; } | |
1293 | ||
1294 | private: | |
1295 | ~wxZipStreamLink() { } | |
1296 | ||
1297 | int m_ref; | |
1298 | wxZipOutputStream *m_stream; | |
1299 | ||
1300 | wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(wxZipStreamLink) | |
1301 | }; | |
1302 | ||
1303 | ||
1304 | ///////////////////////////////////////////////////////////////////////////// | |
1305 | // Input stream | |
1306 | ||
1307 | // leave the default wxZipEntryPtr free for users | |
1308 | wxDECLARE_SCOPED_PTR(wxZipEntry, wxZipEntryPtr_) | |
1309 | wxDEFINE_SCOPED_PTR (wxZipEntry, wxZipEntryPtr_) | |
1310 | ||
1311 | // constructor | |
1312 | // | |
1313 | wxZipInputStream::wxZipInputStream(wxInputStream& stream, | |
1314 | wxMBConv& conv /*=wxConvLocal*/) | |
1315 | : wxArchiveInputStream(stream, conv) | |
1316 | { | |
1317 | Init(); | |
1318 | } | |
1319 | ||
1320 | wxZipInputStream::wxZipInputStream(wxInputStream *stream, | |
1321 | wxMBConv& conv /*=wxConvLocal*/) | |
1322 | : wxArchiveInputStream(stream, conv) | |
1323 | { | |
1324 | Init(); | |
1325 | } | |
1326 | ||
1327 | #if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE | |
1328 | ||
1329 | // Part of the compatibility constructor, which has been made inline to | |
1330 | // avoid a problem with it not being exported by mingw 3.2.3 | |
1331 | // | |
1332 | void wxZipInputStream::Init(const wxString& file) | |
1333 | { | |
1334 | // no error messages | |
1335 | wxLogNull nolog; | |
1336 | Init(); | |
1337 | m_allowSeeking = true; | |
1338 | wxFFileInputStream *ffile; | |
1339 | ffile = static_cast<wxFFileInputStream*>(m_parent_i_stream); | |
1340 | wxZipEntryPtr_ entry; | |
1341 | ||
1342 | if (ffile->Ok()) { | |
1343 | do { | |
1344 | entry.reset(GetNextEntry()); | |
1345 | } | |
1346 | while (entry.get() != NULL && entry->GetInternalName() != file); | |
1347 | } | |
1348 | ||
1349 | if (entry.get() == NULL) | |
1350 | m_lasterror = wxSTREAM_READ_ERROR; | |
1351 | } | |
1352 | ||
1353 | wxInputStream* wxZipInputStream::OpenFile(const wxString& archive) | |
1354 | { | |
1355 | wxLogNull nolog; | |
1356 | return new wxFFileInputStream(archive); | |
1357 | } | |
1358 | ||
1359 | #endif // WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE | |
1360 | ||
1361 | void wxZipInputStream::Init() | |
1362 | { | |
1363 | m_store = new wxStoredInputStream(*m_parent_i_stream); | |
1364 | m_inflate = NULL; | |
1365 | m_rawin = NULL; | |
1366 | m_raw = false; | |
1367 | m_headerSize = 0; | |
1368 | m_decomp = NULL; | |
1369 | m_parentSeekable = false; | |
1370 | m_weaklinks = new wxZipWeakLinks; | |
1371 | m_streamlink = NULL; | |
1372 | m_offsetAdjustment = 0; | |
1373 | m_position = wxInvalidOffset; | |
1374 | m_signature = 0; | |
1375 | m_TotalEntries = 0; | |
1376 | m_lasterror = m_parent_i_stream->GetLastError(); | |
1377 | #if WXWIN_COMPATIBILITY_2_6 | |
1378 | m_allowSeeking = false; | |
1379 | #endif | |
1380 | } | |
1381 | ||
1382 | wxZipInputStream::~wxZipInputStream() | |
1383 | { | |
1384 | CloseDecompressor(m_decomp); | |
1385 | ||
1386 | delete m_store; | |
1387 | delete m_inflate; | |
1388 | delete m_rawin; | |
1389 | ||
1390 | m_weaklinks->Release(this); | |
1391 | ||
1392 | if (m_streamlink) | |
1393 | m_streamlink->Release(this); | |
1394 | } | |
1395 | ||
1396 | wxString wxZipInputStream::GetComment() | |
1397 | { | |
1398 | if (m_position == wxInvalidOffset) | |
1399 | if (!LoadEndRecord()) | |
1400 | return wxEmptyString; | |
1401 | ||
1402 | if (!m_parentSeekable && Eof() && m_signature) { | |
1403 | m_lasterror = wxSTREAM_NO_ERROR; | |
1404 | m_lasterror = ReadLocal(true); | |
1405 | } | |
1406 | ||
1407 | return m_Comment; | |
1408 | } | |
1409 | ||
1410 | int wxZipInputStream::GetTotalEntries() | |
1411 | { | |
1412 | if (m_position == wxInvalidOffset) | |
1413 | LoadEndRecord(); | |
1414 | return m_TotalEntries; | |
1415 | } | |
1416 | ||
1417 | wxZipStreamLink *wxZipInputStream::MakeLink(wxZipOutputStream *out) | |
1418 | { | |
1419 | wxZipStreamLink *link = NULL; | |
1420 | ||
1421 | if (!m_parentSeekable && (IsOpened() || !Eof())) { | |
1422 | link = new wxZipStreamLink(out); | |
1423 | if (m_streamlink) | |
1424 | m_streamlink->Release(this); | |
1425 | m_streamlink = link->AddRef(); | |
1426 | } | |
1427 | ||
1428 | return link; | |
1429 | } | |
1430 | ||
1431 | bool wxZipInputStream::LoadEndRecord() | |
1432 | { | |
1433 | wxCHECK(m_position == wxInvalidOffset, false); | |
1434 | if (!IsOk()) | |
1435 | return false; | |
1436 | ||
1437 | m_position = 0; | |
1438 | ||
1439 | // First find the end-of-central-directory record. | |
1440 | if (!FindEndRecord()) { | |
1441 | // failed, so either this is a non-seekable stream (ok), or not a zip | |
1442 | if (m_parentSeekable) { | |
1443 | m_lasterror = wxSTREAM_READ_ERROR; | |
1444 | wxLogError(_("invalid zip file")); | |
1445 | return false; | |
1446 | } | |
1447 | else { | |
1448 | wxLogNull nolog; | |
1449 | wxFileOffset pos = m_parent_i_stream->TellI(); | |
1450 | if (pos != wxInvalidOffset) | |
1451 | m_offsetAdjustment = m_position = pos; | |
1452 | return true; | |
1453 | } | |
1454 | } | |
1455 | ||
1456 | wxZipEndRec endrec; | |
1457 | ||
1458 | // Read in the end record | |
1459 | wxFileOffset endPos = m_parent_i_stream->TellI() - 4; | |
1460 | if (!endrec.Read(*m_parent_i_stream, GetConv())) | |
1461 | return false; | |
1462 | ||
1463 | m_TotalEntries = endrec.GetTotalEntries(); | |
1464 | m_Comment = endrec.GetComment(); | |
1465 | ||
1466 | wxUint32 magic = m_TotalEntries ? CENTRAL_MAGIC : END_MAGIC; | |
1467 | ||
1468 | // Now find the central-directory. we have the file offset of | |
1469 | // the CD, so look there first. | |
1470 | if (m_parent_i_stream->SeekI(endrec.GetOffset()) != wxInvalidOffset && | |
1471 | ReadSignature() == magic) { | |
1472 | m_signature = magic; | |
1473 | m_position = endrec.GetOffset(); | |
1474 | m_offsetAdjustment = 0; | |
1475 | return true; | |
1476 | } | |
1477 | ||
1478 | // If it's not there, then it could be that the zip has been appended | |
1479 | // to a self extractor, so take the CD size (also in endrec), subtract | |
1480 | // it from the file offset of the end-central-directory and look there. | |
1481 | if (m_parent_i_stream->SeekI(endPos - endrec.GetSize()) | |
1482 | != wxInvalidOffset && ReadSignature() == magic) { | |
1483 | m_signature = magic; | |
1484 | m_position = endPos - endrec.GetSize(); | |
1485 | m_offsetAdjustment = m_position - endrec.GetOffset(); | |
1486 | return true; | |
1487 | } | |
1488 | ||
1489 | wxLogError(_("can't find central directory in zip")); | |
1490 | m_lasterror = wxSTREAM_READ_ERROR; | |
1491 | return false; | |
1492 | } | |
1493 | ||
1494 | // Find the end-of-central-directory record. | |
1495 | // If found the stream will be positioned just past the 4 signature bytes. | |
1496 | // | |
1497 | bool wxZipInputStream::FindEndRecord() | |
1498 | { | |
1499 | if (!m_parent_i_stream->IsSeekable()) | |
1500 | return false; | |
1501 | ||
1502 | // usually it's 22 bytes in size and the last thing in the file | |
1503 | { | |
1504 | wxLogNull nolog; | |
1505 | if (m_parent_i_stream->SeekI(-END_SIZE, wxFromEnd) == wxInvalidOffset) | |
1506 | return false; | |
1507 | } | |
1508 | ||
1509 | m_parentSeekable = true; | |
1510 | m_signature = 0; | |
1511 | char magic[4]; | |
1512 | if (m_parent_i_stream->Read(magic, 4).LastRead() != 4) | |
1513 | return false; | |
1514 | if ((m_signature = CrackUint32(magic)) == END_MAGIC) | |
1515 | return true; | |
1516 | ||
1517 | // unfortunately, the record has a comment field that can be up to 65535 | |
1518 | // bytes in length, so if the signature not found then search backwards. | |
1519 | wxFileOffset pos = m_parent_i_stream->TellI(); | |
1520 | const int BUFSIZE = 1024; | |
1521 | wxCharBuffer buf(BUFSIZE); | |
1522 | ||
1523 | memcpy(buf.data(), magic, 3); | |
1524 | wxFileOffset minpos = wxMax(pos - 65535L, 0); | |
1525 | ||
1526 | while (pos > minpos) { | |
1527 | size_t len = wx_truncate_cast(size_t, | |
1528 | pos - wxMax(pos - (BUFSIZE - 3), minpos)); | |
1529 | memcpy(buf.data() + len, buf, 3); | |
1530 | pos -= len; | |
1531 | ||
1532 | if (m_parent_i_stream->SeekI(pos, wxFromStart) == wxInvalidOffset || | |
1533 | m_parent_i_stream->Read(buf.data(), len).LastRead() != len) | |
1534 | return false; | |
1535 | ||
1536 | char *p = buf.data() + len; | |
1537 | ||
1538 | while (p-- > buf.data()) { | |
1539 | if ((m_signature = CrackUint32(p)) == END_MAGIC) { | |
1540 | size_t remainder = buf.data() + len - p; | |
1541 | if (remainder > 4) | |
1542 | m_parent_i_stream->Ungetch(p + 4, remainder - 4); | |
1543 | return true; | |
1544 | } | |
1545 | } | |
1546 | } | |
1547 | ||
1548 | return false; | |
1549 | } | |
1550 | ||
1551 | wxZipEntry *wxZipInputStream::GetNextEntry() | |
1552 | { | |
1553 | if (m_position == wxInvalidOffset) | |
1554 | if (!LoadEndRecord()) | |
1555 | return NULL; | |
1556 | ||
1557 | m_lasterror = m_parentSeekable ? ReadCentral() : ReadLocal(); | |
1558 | if (!IsOk()) | |
1559 | return NULL; | |
1560 | ||
1561 | wxZipEntryPtr_ entry(new wxZipEntry(m_entry)); | |
1562 | entry->m_backlink = m_weaklinks->AddEntry(entry.get(), entry->GetKey()); | |
1563 | return entry.release(); | |
1564 | } | |
1565 | ||
1566 | wxStreamError wxZipInputStream::ReadCentral() | |
1567 | { | |
1568 | if (!AtHeader()) | |
1569 | CloseEntry(); | |
1570 | ||
1571 | if (m_signature == END_MAGIC) | |
1572 | return wxSTREAM_EOF; | |
1573 | ||
1574 | if (m_signature != CENTRAL_MAGIC) { | |
1575 | wxLogError(_("error reading zip central directory")); | |
1576 | return wxSTREAM_READ_ERROR; | |
1577 | } | |
1578 | ||
1579 | if (QuietSeek(*m_parent_i_stream, m_position + 4) == wxInvalidOffset) | |
1580 | return wxSTREAM_READ_ERROR; | |
1581 | ||
1582 | size_t size = m_entry.ReadCentral(*m_parent_i_stream, GetConv()); | |
1583 | if (!size) { | |
1584 | m_signature = 0; | |
1585 | return wxSTREAM_READ_ERROR; | |
1586 | } | |
1587 | ||
1588 | m_position += size; | |
1589 | m_signature = ReadSignature(); | |
1590 | ||
1591 | if (m_offsetAdjustment) | |
1592 | m_entry.SetOffset(m_entry.GetOffset() + m_offsetAdjustment); | |
1593 | m_entry.SetKey(m_entry.GetOffset()); | |
1594 | ||
1595 | return wxSTREAM_NO_ERROR; | |
1596 | } | |
1597 | ||
1598 | wxStreamError wxZipInputStream::ReadLocal(bool readEndRec /*=false*/) | |
1599 | { | |
1600 | if (!AtHeader()) | |
1601 | CloseEntry(); | |
1602 | ||
1603 | if (!m_signature) | |
1604 | m_signature = ReadSignature(); | |
1605 | ||
1606 | if (m_signature == CENTRAL_MAGIC || m_signature == END_MAGIC) { | |
1607 | if (m_streamlink && !m_streamlink->GetOutputStream()) { | |
1608 | m_streamlink->Release(this); | |
1609 | m_streamlink = NULL; | |
1610 | } | |
1611 | } | |
1612 | ||
1613 | while (m_signature == CENTRAL_MAGIC) { | |
1614 | if (m_weaklinks->IsEmpty() && m_streamlink == NULL) | |
1615 | return wxSTREAM_EOF; | |
1616 | ||
1617 | size_t size = m_entry.ReadCentral(*m_parent_i_stream, GetConv()); | |
1618 | m_position += size; | |
1619 | m_signature = 0; | |
1620 | if (!size) | |
1621 | return wxSTREAM_READ_ERROR; | |
1622 | ||
1623 | wxZipEntry *entry = m_weaklinks->GetEntry(m_entry.GetOffset()); | |
1624 | if (entry) { | |
1625 | entry->SetSystemMadeBy(m_entry.GetSystemMadeBy()); | |
1626 | entry->SetVersionMadeBy(m_entry.GetVersionMadeBy()); | |
1627 | entry->SetComment(m_entry.GetComment()); | |
1628 | entry->SetDiskStart(m_entry.GetDiskStart()); | |
1629 | entry->SetInternalAttributes(m_entry.GetInternalAttributes()); | |
1630 | entry->SetExternalAttributes(m_entry.GetExternalAttributes()); | |
1631 | Copy(entry->m_Extra, m_entry.m_Extra); | |
1632 | entry->Notify(); | |
1633 | m_weaklinks->RemoveEntry(entry->GetOffset()); | |
1634 | } | |
1635 | ||
1636 | m_signature = ReadSignature(); | |
1637 | } | |
1638 | ||
1639 | if (m_signature == END_MAGIC) { | |
1640 | if (readEndRec || m_streamlink) { | |
1641 | wxZipEndRec endrec; | |
1642 | endrec.Read(*m_parent_i_stream, GetConv()); | |
1643 | m_Comment = endrec.GetComment(); | |
1644 | m_signature = 0; | |
1645 | if (m_streamlink) { | |
1646 | m_streamlink->GetOutputStream()->SetComment(endrec.GetComment()); | |
1647 | m_streamlink->Release(this); | |
1648 | m_streamlink = NULL; | |
1649 | } | |
1650 | } | |
1651 | return wxSTREAM_EOF; | |
1652 | } | |
1653 | ||
1654 | if (m_signature == LOCAL_MAGIC) { | |
1655 | m_headerSize = m_entry.ReadLocal(*m_parent_i_stream, GetConv()); | |
1656 | m_signature = 0; | |
1657 | m_entry.SetOffset(m_position); | |
1658 | m_entry.SetKey(m_position); | |
1659 | ||
1660 | if (m_headerSize) { | |
1661 | m_TotalEntries++; | |
1662 | return wxSTREAM_NO_ERROR; | |
1663 | } | |
1664 | } | |
1665 | ||
1666 | wxLogError(_("error reading zip local header")); | |
1667 | return wxSTREAM_READ_ERROR; | |
1668 | } | |
1669 | ||
1670 | wxUint32 wxZipInputStream::ReadSignature() | |
1671 | { | |
1672 | char magic[4]; | |
1673 | m_parent_i_stream->Read(magic, 4); | |
1674 | return m_parent_i_stream->LastRead() == 4 ? CrackUint32(magic) : 0; | |
1675 | } | |
1676 | ||
1677 | bool wxZipInputStream::OpenEntry(wxArchiveEntry& entry) | |
1678 | { | |
1679 | wxZipEntry *zipEntry = wxStaticCast(&entry, wxZipEntry); | |
1680 | return zipEntry ? OpenEntry(*zipEntry) : false; | |
1681 | } | |
1682 | ||
1683 | // Open an entry | |
1684 | // | |
1685 | bool wxZipInputStream::DoOpen(wxZipEntry *entry, bool raw) | |
1686 | { | |
1687 | if (m_position == wxInvalidOffset) | |
1688 | if (!LoadEndRecord()) | |
1689 | return false; | |
1690 | if (m_lasterror == wxSTREAM_READ_ERROR) | |
1691 | return false; | |
1692 | if (IsOpened()) | |
1693 | CloseEntry(); | |
1694 | ||
1695 | m_raw = raw; | |
1696 | ||
1697 | if (entry) { | |
1698 | if (AfterHeader() && entry->GetKey() == m_entry.GetOffset()) | |
1699 | return true; | |
1700 | // can only open the current entry on a non-seekable stream | |
1701 | wxCHECK(m_parentSeekable, false); | |
1702 | } | |
1703 | ||
1704 | m_lasterror = wxSTREAM_READ_ERROR; | |
1705 | ||
1706 | if (entry) | |
1707 | m_entry = *entry; | |
1708 | ||
1709 | if (m_parentSeekable) { | |
1710 | if (QuietSeek(*m_parent_i_stream, m_entry.GetOffset()) | |
1711 | == wxInvalidOffset) | |
1712 | return false; | |
1713 | if (ReadSignature() != LOCAL_MAGIC) { | |
1714 | wxLogError(_("bad zipfile offset to entry")); | |
1715 | return false; | |
1716 | } | |
1717 | } | |
1718 | ||
1719 | if (m_parentSeekable || AtHeader()) { | |
1720 | m_headerSize = m_entry.ReadLocal(*m_parent_i_stream, GetConv()); | |
1721 | if (m_headerSize && m_parentSeekable) { | |
1722 | wxZipEntry *ref = m_weaklinks->GetEntry(m_entry.GetKey()); | |
1723 | if (ref) { | |
1724 | Copy(ref->m_LocalExtra, m_entry.m_LocalExtra); | |
1725 | ref->Notify(); | |
1726 | m_weaklinks->RemoveEntry(ref->GetKey()); | |
1727 | } | |
1728 | if (entry && entry != ref) { | |
1729 | Copy(entry->m_LocalExtra, m_entry.m_LocalExtra); | |
1730 | entry->Notify(); | |
1731 | } | |
1732 | } | |
1733 | } | |
1734 | ||
1735 | if (m_headerSize) | |
1736 | m_lasterror = wxSTREAM_NO_ERROR; | |
1737 | return IsOk(); | |
1738 | } | |
1739 | ||
1740 | bool wxZipInputStream::OpenDecompressor(bool raw /*=false*/) | |
1741 | { | |
1742 | wxASSERT(AfterHeader()); | |
1743 | ||
1744 | wxFileOffset compressedSize = m_entry.GetCompressedSize(); | |
1745 | ||
1746 | if (raw) | |
1747 | m_raw = true; | |
1748 | ||
1749 | if (m_raw) { | |
1750 | if (compressedSize != wxInvalidOffset) { | |
1751 | m_store->Open(compressedSize); | |
1752 | m_decomp = m_store; | |
1753 | } else { | |
1754 | if (!m_rawin) | |
1755 | m_rawin = new wxRawInputStream(*m_parent_i_stream); | |
1756 | m_decomp = m_rawin->Open(OpenDecompressor(m_rawin->GetTee())); | |
1757 | } | |
1758 | } else { | |
1759 | if (compressedSize != wxInvalidOffset && | |
1760 | (m_entry.GetMethod() != wxZIP_METHOD_DEFLATE || | |
1761 | wxZlibInputStream::CanHandleGZip())) { | |
1762 | m_store->Open(compressedSize); | |
1763 | m_decomp = OpenDecompressor(*m_store); | |
1764 | } else { | |
1765 | m_decomp = OpenDecompressor(*m_parent_i_stream); | |
1766 | } | |
1767 | } | |
1768 | ||
1769 | m_crcAccumulator = crc32(0, Z_NULL, 0); | |
1770 | m_lasterror = m_decomp ? m_decomp->GetLastError() : wxSTREAM_READ_ERROR; | |
1771 | return IsOk(); | |
1772 | } | |
1773 | ||
1774 | // Can be overriden to add support for additional decompression methods | |
1775 | // | |
1776 | wxInputStream *wxZipInputStream::OpenDecompressor(wxInputStream& stream) | |
1777 | { | |
1778 | switch (m_entry.GetMethod()) { | |
1779 | case wxZIP_METHOD_STORE: | |
1780 | if (m_entry.GetSize() == wxInvalidOffset) { | |
1781 | wxLogError(_("stored file length not in Zip header")); | |
1782 | break; | |
1783 | } | |
1784 | m_store->Open(m_entry.GetSize()); | |
1785 | return m_store; | |
1786 | ||
1787 | case wxZIP_METHOD_DEFLATE: | |
1788 | if (!m_inflate) | |
1789 | m_inflate = new wxZlibInputStream2(stream); | |
1790 | else | |
1791 | m_inflate->Open(stream); | |
1792 | return m_inflate; | |
1793 | ||
1794 | default: | |
1795 | wxLogError(_("unsupported Zip compression method")); | |
1796 | } | |
1797 | ||
1798 | return NULL; | |
1799 | } | |
1800 | ||
1801 | bool wxZipInputStream::CloseDecompressor(wxInputStream *decomp) | |
1802 | { | |
1803 | if (decomp && decomp == m_rawin) | |
1804 | return CloseDecompressor(m_rawin->GetFilterInputStream()); | |
1805 | if (decomp != m_store && decomp != m_inflate) | |
1806 | delete decomp; | |
1807 | return true; | |
1808 | } | |
1809 | ||
1810 | // Closes the current entry and positions the underlying stream at the start | |
1811 | // of the next entry | |
1812 | // | |
1813 | bool wxZipInputStream::CloseEntry() | |
1814 | { | |
1815 | if (AtHeader()) | |
1816 | return true; | |
1817 | if (m_lasterror == wxSTREAM_READ_ERROR) | |
1818 | return false; | |
1819 | ||
1820 | if (!m_parentSeekable) { | |
1821 | if (!IsOpened() && !OpenDecompressor(true)) | |
1822 | return false; | |
1823 | ||
1824 | const int BUFSIZE = 8192; | |
1825 | wxCharBuffer buf(BUFSIZE); | |
1826 | while (IsOk()) | |
1827 | Read(buf.data(), BUFSIZE); | |
1828 | ||
1829 | m_position += m_headerSize + m_entry.GetCompressedSize(); | |
1830 | } | |
1831 | ||
1832 | if (m_lasterror == wxSTREAM_EOF) | |
1833 | m_lasterror = wxSTREAM_NO_ERROR; | |
1834 | ||
1835 | CloseDecompressor(m_decomp); | |
1836 | m_decomp = NULL; | |
1837 | m_entry = wxZipEntry(); | |
1838 | m_headerSize = 0; | |
1839 | m_raw = false; | |
1840 | ||
1841 | return IsOk(); | |
1842 | } | |
1843 | ||
1844 | size_t wxZipInputStream::OnSysRead(void *buffer, size_t size) | |
1845 | { | |
1846 | if (!IsOpened()) | |
1847 | if ((AtHeader() && !DoOpen()) || !OpenDecompressor()) | |
1848 | m_lasterror = wxSTREAM_READ_ERROR; | |
1849 | if (!IsOk() || !size) | |
1850 | return 0; | |
1851 | ||
1852 | size_t count = m_decomp->Read(buffer, size).LastRead(); | |
1853 | if (!m_raw) | |
1854 | m_crcAccumulator = crc32(m_crcAccumulator, (Byte*)buffer, count); | |
1855 | if (count < size) | |
1856 | m_lasterror = m_decomp->GetLastError(); | |
1857 | ||
1858 | if (Eof()) { | |
1859 | if ((m_entry.GetFlags() & wxZIP_SUMS_FOLLOW) != 0) { | |
1860 | m_headerSize += m_entry.ReadDescriptor(*m_parent_i_stream); | |
1861 | wxZipEntry *entry = m_weaklinks->GetEntry(m_entry.GetKey()); | |
1862 | ||
1863 | if (entry) { | |
1864 | entry->SetCrc(m_entry.GetCrc()); | |
1865 | entry->SetCompressedSize(m_entry.GetCompressedSize()); | |
1866 | entry->SetSize(m_entry.GetSize()); | |
1867 | entry->Notify(); | |
1868 | } | |
1869 | } | |
1870 | ||
1871 | if (!m_raw) { | |
1872 | m_lasterror = wxSTREAM_READ_ERROR; | |
1873 | ||
1874 | if (m_entry.GetSize() != TellI()) | |
1875 | wxLogError(_("reading zip stream (entry %s): bad length"), | |
1876 | m_entry.GetName().c_str()); | |
1877 | else if (m_crcAccumulator != m_entry.GetCrc()) | |
1878 | wxLogError(_("reading zip stream (entry %s): bad crc"), | |
1879 | m_entry.GetName().c_str()); | |
1880 | else | |
1881 | m_lasterror = wxSTREAM_EOF; | |
1882 | } | |
1883 | } | |
1884 | ||
1885 | return count; | |
1886 | } | |
1887 | ||
1888 | #if WXWIN_COMPATIBILITY_2_6 | |
1889 | ||
1890 | // Borrowed from VS's zip stream (c) 1999 Vaclav Slavik | |
1891 | // | |
1892 | wxFileOffset wxZipInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode) | |
1893 | { | |
1894 | // seeking works when the stream is created with the compatibility | |
1895 | // constructor | |
1896 | if (!m_allowSeeking) | |
1897 | return wxInvalidOffset; | |
1898 | if (!IsOpened()) | |
1899 | if ((AtHeader() && !DoOpen()) || !OpenDecompressor()) | |
1900 | m_lasterror = wxSTREAM_READ_ERROR; | |
1901 | if (!IsOk()) | |
1902 | return wxInvalidOffset; | |
1903 | ||
1904 | // NB: since ZIP files don't natively support seeking, we have to | |
1905 | // implement a brute force workaround -- reading all the data | |
1906 | // between current and the new position (or between beginning of | |
1907 | // the file and new position...) | |
1908 | ||
1909 | wxFileOffset nextpos; | |
1910 | wxFileOffset pos = TellI(); | |
1911 | ||
1912 | switch ( mode ) | |
1913 | { | |
1914 | case wxFromCurrent : nextpos = seek + pos; break; | |
1915 | case wxFromStart : nextpos = seek; break; | |
1916 | case wxFromEnd : nextpos = GetLength() + seek; break; | |
1917 | default : nextpos = pos; break; /* just to fool compiler, never happens */ | |
1918 | } | |
1919 | ||
1920 | wxFileOffset toskip wxDUMMY_INITIALIZE(0); | |
1921 | if ( nextpos >= pos ) | |
1922 | { | |
1923 | toskip = nextpos - pos; | |
1924 | } | |
1925 | else | |
1926 | { | |
1927 | wxZipEntry current(m_entry); | |
1928 | if (!OpenEntry(current)) | |
1929 | { | |
1930 | m_lasterror = wxSTREAM_READ_ERROR; | |
1931 | return pos; | |
1932 | } | |
1933 | toskip = nextpos; | |
1934 | } | |
1935 | ||
1936 | if ( toskip > 0 ) | |
1937 | { | |
1938 | const int BUFSIZE = 4096; | |
1939 | size_t sz; | |
1940 | char buffer[BUFSIZE]; | |
1941 | while ( toskip > 0 ) | |
1942 | { | |
1943 | sz = wx_truncate_cast(size_t, wxMin(toskip, BUFSIZE)); | |
1944 | Read(buffer, sz); | |
1945 | toskip -= sz; | |
1946 | } | |
1947 | } | |
1948 | ||
1949 | pos = nextpos; | |
1950 | return pos; | |
1951 | } | |
1952 | ||
1953 | #endif // WXWIN_COMPATIBILITY_2_6 | |
1954 | ||
1955 | ||
1956 | ///////////////////////////////////////////////////////////////////////////// | |
1957 | // Output stream | |
1958 | ||
1959 | #include "wx/listimpl.cpp" | |
1960 | WX_DEFINE_LIST(wxZipEntryList_) | |
1961 | ||
1962 | wxZipOutputStream::wxZipOutputStream(wxOutputStream& stream, | |
1963 | int level /*=-1*/, | |
1964 | wxMBConv& conv /*=wxConvLocal*/) | |
1965 | : wxArchiveOutputStream(stream, conv) | |
1966 | { | |
1967 | Init(level); | |
1968 | } | |
1969 | ||
1970 | wxZipOutputStream::wxZipOutputStream(wxOutputStream *stream, | |
1971 | int level /*=-1*/, | |
1972 | wxMBConv& conv /*=wxConvLocal*/) | |
1973 | : wxArchiveOutputStream(stream, conv) | |
1974 | { | |
1975 | Init(level); | |
1976 | } | |
1977 | ||
1978 | void wxZipOutputStream::Init(int level) | |
1979 | { | |
1980 | m_store = new wxStoredOutputStream(*m_parent_o_stream); | |
1981 | m_deflate = NULL; | |
1982 | m_backlink = NULL; | |
1983 | m_initialData = new char[OUTPUT_LATENCY]; | |
1984 | m_initialSize = 0; | |
1985 | m_pending = NULL; | |
1986 | m_raw = false; | |
1987 | m_headerOffset = 0; | |
1988 | m_headerSize = 0; | |
1989 | m_entrySize = 0; | |
1990 | m_comp = NULL; | |
1991 | m_level = level; | |
1992 | m_offsetAdjustment = wxInvalidOffset; | |
1993 | m_endrecWritten = false; | |
1994 | } | |
1995 | ||
1996 | wxZipOutputStream::~wxZipOutputStream() | |
1997 | { | |
1998 | Close(); | |
1999 | WX_CLEAR_LIST(wxZipEntryList_, m_entries); | |
2000 | delete m_store; | |
2001 | delete m_deflate; | |
2002 | delete m_pending; | |
2003 | delete [] m_initialData; | |
2004 | if (m_backlink) | |
2005 | m_backlink->Release(this); | |
2006 | } | |
2007 | ||
2008 | bool wxZipOutputStream::PutNextEntry( | |
2009 | const wxString& name, | |
2010 | const wxDateTime& dt /*=wxDateTime::Now()*/, | |
2011 | wxFileOffset size /*=wxInvalidOffset*/) | |
2012 | { | |
2013 | return PutNextEntry(new wxZipEntry(name, dt, size)); | |
2014 | } | |
2015 | ||
2016 | bool wxZipOutputStream::PutNextDirEntry( | |
2017 | const wxString& name, | |
2018 | const wxDateTime& dt /*=wxDateTime::Now()*/) | |
2019 | { | |
2020 | wxZipEntry *entry = new wxZipEntry(name, dt); | |
2021 | entry->SetIsDir(); | |
2022 | return PutNextEntry(entry); | |
2023 | } | |
2024 | ||
2025 | bool wxZipOutputStream::CopyEntry(wxZipEntry *entry, | |
2026 | wxZipInputStream& inputStream) | |
2027 | { | |
2028 | wxZipEntryPtr_ e(entry); | |
2029 | ||
2030 | return | |
2031 | inputStream.DoOpen(e.get(), true) && | |
2032 | DoCreate(e.release(), true) && | |
2033 | Write(inputStream).IsOk() && inputStream.Eof(); | |
2034 | } | |
2035 | ||
2036 | bool wxZipOutputStream::PutNextEntry(wxArchiveEntry *entry) | |
2037 | { | |
2038 | wxZipEntry *zipEntry = wxStaticCast(entry, wxZipEntry); | |
2039 | if (!zipEntry) | |
2040 | delete entry; | |
2041 | return PutNextEntry(zipEntry); | |
2042 | } | |
2043 | ||
2044 | bool wxZipOutputStream::CopyEntry(wxArchiveEntry *entry, | |
2045 | wxArchiveInputStream& stream) | |
2046 | { | |
2047 | wxZipEntry *zipEntry = wxStaticCast(entry, wxZipEntry); | |
2048 | ||
2049 | if (!zipEntry || !stream.OpenEntry(*zipEntry)) { | |
2050 | delete entry; | |
2051 | return false; | |
2052 | } | |
2053 | ||
2054 | return CopyEntry(zipEntry, static_cast<wxZipInputStream&>(stream)); | |
2055 | } | |
2056 | ||
2057 | bool wxZipOutputStream::CopyArchiveMetaData(wxZipInputStream& inputStream) | |
2058 | { | |
2059 | m_Comment = inputStream.GetComment(); | |
2060 | if (m_backlink) | |
2061 | m_backlink->Release(this); | |
2062 | m_backlink = inputStream.MakeLink(this); | |
2063 | return true; | |
2064 | } | |
2065 | ||
2066 | bool wxZipOutputStream::CopyArchiveMetaData(wxArchiveInputStream& stream) | |
2067 | { | |
2068 | return CopyArchiveMetaData(static_cast<wxZipInputStream&>(stream)); | |
2069 | } | |
2070 | ||
2071 | void wxZipOutputStream::SetLevel(int level) | |
2072 | { | |
2073 | if (level != m_level) { | |
2074 | if (m_comp != m_deflate) | |
2075 | delete m_deflate; | |
2076 | m_deflate = NULL; | |
2077 | m_level = level; | |
2078 | } | |
2079 | } | |
2080 | ||
2081 | bool wxZipOutputStream::DoCreate(wxZipEntry *entry, bool raw /*=false*/) | |
2082 | { | |
2083 | CloseEntry(); | |
2084 | ||
2085 | m_pending = entry; | |
2086 | if (!m_pending) | |
2087 | return false; | |
2088 | ||
2089 | // write the signature bytes right away | |
2090 | wxDataOutputStream ds(*m_parent_o_stream); | |
2091 | ds << LOCAL_MAGIC; | |
2092 | ||
2093 | // and if this is the first entry test for seekability | |
2094 | if (m_headerOffset == 0 && m_parent_o_stream->IsSeekable()) { | |
2095 | #if wxUSE_LOG | |
2096 | bool logging = wxLog::IsEnabled(); | |
2097 | wxLogNull nolog; | |
2098 | #endif // wxUSE_LOG | |
2099 | wxFileOffset here = m_parent_o_stream->TellO(); | |
2100 | ||
2101 | if (here != wxInvalidOffset && here >= 4) { | |
2102 | if (m_parent_o_stream->SeekO(here - 4) == here - 4) { | |
2103 | m_offsetAdjustment = here - 4; | |
2104 | #if wxUSE_LOG | |
2105 | wxLog::EnableLogging(logging); | |
2106 | #endif // wxUSE_LOG | |
2107 | m_parent_o_stream->SeekO(here); | |
2108 | } | |
2109 | } | |
2110 | } | |
2111 | ||
2112 | m_pending->SetOffset(m_headerOffset); | |
2113 | ||
2114 | m_crcAccumulator = crc32(0, Z_NULL, 0); | |
2115 | ||
2116 | if (raw) | |
2117 | m_raw = true; | |
2118 | ||
2119 | m_lasterror = wxSTREAM_NO_ERROR; | |
2120 | return true; | |
2121 | } | |
2122 | ||
2123 | // Can be overriden to add support for additional compression methods | |
2124 | // | |
2125 | wxOutputStream *wxZipOutputStream::OpenCompressor( | |
2126 | wxOutputStream& stream, | |
2127 | wxZipEntry& entry, | |
2128 | const Buffer bufs[]) | |
2129 | { | |
2130 | if (entry.GetMethod() == wxZIP_METHOD_DEFAULT) { | |
2131 | if (GetLevel() == 0 | |
2132 | && (IsParentSeekable() | |
2133 | || entry.GetCompressedSize() != wxInvalidOffset | |
2134 | || entry.GetSize() != wxInvalidOffset)) { | |
2135 | entry.SetMethod(wxZIP_METHOD_STORE); | |
2136 | } else { | |
2137 | int size = 0; | |
2138 | for (int i = 0; bufs[i].m_data; ++i) | |
2139 | size += bufs[i].m_size; | |
2140 | entry.SetMethod(size <= 6 ? | |
2141 | wxZIP_METHOD_STORE : wxZIP_METHOD_DEFLATE); | |
2142 | } | |
2143 | } | |
2144 | ||
2145 | switch (entry.GetMethod()) { | |
2146 | case wxZIP_METHOD_STORE: | |
2147 | if (entry.GetCompressedSize() == wxInvalidOffset) | |
2148 | entry.SetCompressedSize(entry.GetSize()); | |
2149 | return m_store; | |
2150 | ||
2151 | case wxZIP_METHOD_DEFLATE: | |
2152 | { | |
2153 | int defbits = wxZIP_DEFLATE_NORMAL; | |
2154 | switch (GetLevel()) { | |
2155 | case 0: case 1: | |
2156 | defbits = wxZIP_DEFLATE_SUPERFAST; | |
2157 | break; | |
2158 | case 2: case 3: case 4: | |
2159 | defbits = wxZIP_DEFLATE_FAST; | |
2160 | break; | |
2161 | case 8: case 9: | |
2162 | defbits = wxZIP_DEFLATE_EXTRA; | |
2163 | break; | |
2164 | } | |
2165 | entry.SetFlags((entry.GetFlags() & ~wxZIP_DEFLATE_MASK) | | |
2166 | defbits | wxZIP_SUMS_FOLLOW); | |
2167 | ||
2168 | if (!m_deflate) | |
2169 | m_deflate = new wxZlibOutputStream2(stream, GetLevel()); | |
2170 | else | |
2171 | m_deflate->Open(stream); | |
2172 | ||
2173 | return m_deflate; | |
2174 | } | |
2175 | ||
2176 | default: | |
2177 | wxLogError(_("unsupported Zip compression method")); | |
2178 | } | |
2179 | ||
2180 | return NULL; | |
2181 | } | |
2182 | ||
2183 | bool wxZipOutputStream::CloseCompressor(wxOutputStream *comp) | |
2184 | { | |
2185 | if (comp == m_deflate) | |
2186 | m_deflate->Close(); | |
2187 | else if (comp != m_store) | |
2188 | delete comp; | |
2189 | return true; | |
2190 | } | |
2191 | ||
2192 | // This is called when OUPUT_LATENCY bytes has been written to the | |
2193 | // wxZipOutputStream to actually create the zip entry. | |
2194 | // | |
2195 | void wxZipOutputStream::CreatePendingEntry(const void *buffer, size_t size) | |
2196 | { | |
2197 | wxASSERT(IsOk() && m_pending && !m_comp); | |
2198 | wxZipEntryPtr_ spPending(m_pending); | |
2199 | m_pending = NULL; | |
2200 | ||
2201 | Buffer bufs[] = { | |
2202 | { m_initialData, m_initialSize }, | |
2203 | { (const char*)buffer, size }, | |
2204 | { NULL, 0 } | |
2205 | }; | |
2206 | ||
2207 | if (m_raw) | |
2208 | m_comp = m_store; | |
2209 | else | |
2210 | m_comp = OpenCompressor(*m_store, *spPending, | |
2211 | m_initialSize ? bufs : bufs + 1); | |
2212 | ||
2213 | if (IsParentSeekable() | |
2214 | || (spPending->m_Crc | |
2215 | && spPending->m_CompressedSize != wxInvalidOffset | |
2216 | && spPending->m_Size != wxInvalidOffset)) | |
2217 | spPending->m_Flags &= ~wxZIP_SUMS_FOLLOW; | |
2218 | else | |
2219 | if (spPending->m_CompressedSize != wxInvalidOffset) | |
2220 | spPending->m_Flags |= wxZIP_SUMS_FOLLOW; | |
2221 | ||
2222 | m_headerSize = spPending->WriteLocal(*m_parent_o_stream, GetConv()); | |
2223 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2224 | ||
2225 | if (IsOk()) { | |
2226 | m_entries.push_back(spPending.release()); | |
2227 | OnSysWrite(m_initialData, m_initialSize); | |
2228 | } | |
2229 | ||
2230 | m_initialSize = 0; | |
2231 | } | |
2232 | ||
2233 | // This is called to write out the zip entry when Close has been called | |
2234 | // before OUTPUT_LATENCY bytes has been written to the wxZipOutputStream. | |
2235 | // | |
2236 | void wxZipOutputStream::CreatePendingEntry() | |
2237 | { | |
2238 | wxASSERT(IsOk() && m_pending && !m_comp); | |
2239 | wxZipEntryPtr_ spPending(m_pending); | |
2240 | m_pending = NULL; | |
2241 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
2242 | ||
2243 | if (!m_raw) { | |
2244 | // Initially compresses the data to memory, then fall back to 'store' | |
2245 | // if the compressor makes the data larger rather than smaller. | |
2246 | wxMemoryOutputStream mem; | |
2247 | Buffer bufs[] = { { m_initialData, m_initialSize }, { NULL, 0 } }; | |
2248 | wxOutputStream *comp = OpenCompressor(mem, *spPending, bufs); | |
2249 | ||
2250 | if (!comp) | |
2251 | return; | |
2252 | if (comp != m_store) { | |
2253 | bool ok = comp->Write(m_initialData, m_initialSize).IsOk(); | |
2254 | CloseCompressor(comp); | |
2255 | if (!ok) | |
2256 | return; | |
2257 | } | |
2258 | ||
2259 | m_entrySize = m_initialSize; | |
2260 | m_crcAccumulator = crc32(0, (Byte*)m_initialData, m_initialSize); | |
2261 | ||
2262 | if (mem.GetSize() > 0 && mem.GetSize() < m_initialSize) { | |
2263 | m_initialSize = mem.GetSize(); | |
2264 | mem.CopyTo(m_initialData, m_initialSize); | |
2265 | } else { | |
2266 | spPending->SetMethod(wxZIP_METHOD_STORE); | |
2267 | } | |
2268 | ||
2269 | spPending->SetSize(m_entrySize); | |
2270 | spPending->SetCrc(m_crcAccumulator); | |
2271 | spPending->SetCompressedSize(m_initialSize); | |
2272 | } | |
2273 | ||
2274 | spPending->m_Flags &= ~wxZIP_SUMS_FOLLOW; | |
2275 | m_headerSize = spPending->WriteLocal(*m_parent_o_stream, GetConv()); | |
2276 | ||
2277 | if (m_parent_o_stream->IsOk()) { | |
2278 | m_entries.push_back(spPending.release()); | |
2279 | m_comp = m_store; | |
2280 | m_store->Write(m_initialData, m_initialSize); | |
2281 | } | |
2282 | ||
2283 | m_initialSize = 0; | |
2284 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2285 | } | |
2286 | ||
2287 | // Write the 'central directory' and the 'end-central-directory' records. | |
2288 | // | |
2289 | bool wxZipOutputStream::Close() | |
2290 | { | |
2291 | CloseEntry(); | |
2292 | ||
2293 | if (m_lasterror == wxSTREAM_WRITE_ERROR | |
2294 | || (m_entries.size() == 0 && m_endrecWritten)) | |
2295 | { | |
2296 | wxFilterOutputStream::Close(); | |
2297 | return false; | |
2298 | } | |
2299 | ||
2300 | wxZipEndRec endrec; | |
2301 | ||
2302 | endrec.SetEntriesHere(m_entries.size()); | |
2303 | endrec.SetTotalEntries(m_entries.size()); | |
2304 | endrec.SetOffset(m_headerOffset); | |
2305 | endrec.SetComment(m_Comment); | |
2306 | ||
2307 | wxZipEntryList_::iterator it; | |
2308 | wxFileOffset size = 0; | |
2309 | ||
2310 | for (it = m_entries.begin(); it != m_entries.end(); ++it) { | |
2311 | size += (*it)->WriteCentral(*m_parent_o_stream, GetConv()); | |
2312 | delete *it; | |
2313 | } | |
2314 | m_entries.clear(); | |
2315 | ||
2316 | endrec.SetSize(size); | |
2317 | endrec.Write(*m_parent_o_stream, GetConv()); | |
2318 | ||
2319 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2320 | m_endrecWritten = true; | |
2321 | ||
2322 | if (!wxFilterOutputStream::Close() || !IsOk()) | |
2323 | return false; | |
2324 | m_lasterror = wxSTREAM_EOF; | |
2325 | return true; | |
2326 | } | |
2327 | ||
2328 | // Finish writing the current entry | |
2329 | // | |
2330 | bool wxZipOutputStream::CloseEntry() | |
2331 | { | |
2332 | if (IsOk() && m_pending) | |
2333 | CreatePendingEntry(); | |
2334 | if (!IsOk()) | |
2335 | return false; | |
2336 | if (!m_comp) | |
2337 | return true; | |
2338 | ||
2339 | CloseCompressor(m_comp); | |
2340 | m_comp = NULL; | |
2341 | ||
2342 | wxFileOffset compressedSize = m_store->TellO(); | |
2343 | ||
2344 | wxZipEntry& entry = *m_entries.back(); | |
2345 | ||
2346 | // When writing raw the crc and size can't be checked | |
2347 | if (m_raw) { | |
2348 | m_crcAccumulator = entry.GetCrc(); | |
2349 | m_entrySize = entry.GetSize(); | |
2350 | } | |
2351 | ||
2352 | // Write the sums in the trailing 'data descriptor' if necessary | |
2353 | if (entry.m_Flags & wxZIP_SUMS_FOLLOW) { | |
2354 | wxASSERT(!IsParentSeekable()); | |
2355 | m_headerOffset += | |
2356 | entry.WriteDescriptor(*m_parent_o_stream, m_crcAccumulator, | |
2357 | compressedSize, m_entrySize); | |
2358 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2359 | } | |
2360 | ||
2361 | // If the local header didn't have the correct crc and size written to | |
2362 | // it then seek back and fix it | |
2363 | else if (m_crcAccumulator != entry.GetCrc() | |
2364 | || m_entrySize != entry.GetSize() | |
2365 | || compressedSize != entry.GetCompressedSize()) | |
2366 | { | |
2367 | if (IsParentSeekable()) { | |
2368 | wxFileOffset here = m_parent_o_stream->TellO(); | |
2369 | wxFileOffset headerOffset = m_headerOffset + m_offsetAdjustment; | |
2370 | m_parent_o_stream->SeekO(headerOffset + SUMS_OFFSET); | |
2371 | entry.WriteDescriptor(*m_parent_o_stream, m_crcAccumulator, | |
2372 | compressedSize, m_entrySize); | |
2373 | m_parent_o_stream->SeekO(here); | |
2374 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2375 | } else { | |
2376 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
2377 | } | |
2378 | } | |
2379 | ||
2380 | m_headerOffset += m_headerSize + compressedSize; | |
2381 | m_headerSize = 0; | |
2382 | m_entrySize = 0; | |
2383 | m_store->Close(); | |
2384 | m_raw = false; | |
2385 | ||
2386 | if (IsOk()) | |
2387 | m_lasterror = m_parent_o_stream->GetLastError(); | |
2388 | else | |
2389 | wxLogError(_("error writing zip entry '%s': bad crc or length"), | |
2390 | entry.GetName().c_str()); | |
2391 | return IsOk(); | |
2392 | } | |
2393 | ||
2394 | void wxZipOutputStream::Sync() | |
2395 | { | |
2396 | if (IsOk() && m_pending) | |
2397 | CreatePendingEntry(NULL, 0); | |
2398 | if (!m_comp) | |
2399 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
2400 | if (IsOk()) { | |
2401 | m_comp->Sync(); | |
2402 | m_lasterror = m_comp->GetLastError(); | |
2403 | } | |
2404 | } | |
2405 | ||
2406 | size_t wxZipOutputStream::OnSysWrite(const void *buffer, size_t size) | |
2407 | { | |
2408 | if (IsOk() && m_pending) { | |
2409 | if (m_initialSize + size < OUTPUT_LATENCY) { | |
2410 | memcpy(m_initialData + m_initialSize, buffer, size); | |
2411 | m_initialSize += size; | |
2412 | return size; | |
2413 | } else { | |
2414 | CreatePendingEntry(buffer, size); | |
2415 | } | |
2416 | } | |
2417 | ||
2418 | if (!m_comp) | |
2419 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
2420 | if (!IsOk() || !size) | |
2421 | return 0; | |
2422 | ||
2423 | if (m_comp->Write(buffer, size).LastWrite() != size) | |
2424 | m_lasterror = wxSTREAM_WRITE_ERROR; | |
2425 | m_crcAccumulator = crc32(m_crcAccumulator, (Byte*)buffer, size); | |
2426 | m_entrySize += m_comp->LastWrite(); | |
2427 | ||
2428 | return m_comp->LastWrite(); | |
2429 | } | |
2430 | ||
2431 | #endif // wxUSE_ZIPSTREAM |