]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/zipstrm.h
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Escape underscores
[wxWidgets.git] / include / wx / zipstrm.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: zipstrm.h
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#ifndef _WX_WXZIPSTREAM_H__
11#define _WX_WXZIPSTREAM_H__
12
13#include "wx/defs.h"
14
15#if wxUSE_ZLIB && wxUSE_STREAMS && wxUSE_ZIPSTREAM
16
17#include "wx/archive.h"
18#include "wx/hashmap.h"
19#include "wx/filename.h"
20
21// some methods from wxZipInputStream and wxZipOutputStream stream do not get
22// exported/imported when compiled with Mingw versions before 3.4.2. So they
23// are imported/exported individually as a workaround
24#if (defined(__GNUWIN32__) || defined(__MINGW32__)) \
25 && (!defined __GNUC__ \
26 || !defined __GNUC_MINOR__ \
27 || !defined __GNUC_PATCHLEVEL__ \
28 || __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 30402)
29#define WXZIPFIX WXDLLIMPEXP_BASE
30#else
31#define WXZIPFIX
32#endif
33
34/////////////////////////////////////////////////////////////////////////////
35// constants
36
37// Compression Method, only 0 (store) and 8 (deflate) are supported here
38//
39enum wxZipMethod
40{
41 wxZIP_METHOD_STORE,
42 wxZIP_METHOD_SHRINK,
43 wxZIP_METHOD_REDUCE1,
44 wxZIP_METHOD_REDUCE2,
45 wxZIP_METHOD_REDUCE3,
46 wxZIP_METHOD_REDUCE4,
47 wxZIP_METHOD_IMPLODE,
48 wxZIP_METHOD_TOKENIZE,
49 wxZIP_METHOD_DEFLATE,
50 wxZIP_METHOD_DEFLATE64,
51 wxZIP_METHOD_BZIP2 = 12,
52 wxZIP_METHOD_DEFAULT = 0xffff
53};
54
55// Originating File-System.
56//
57// These are Pkware's values. Note that Info-zip disagree on some of them,
58// most notably NTFS.
59//
60enum wxZipSystem
61{
62 wxZIP_SYSTEM_MSDOS,
63 wxZIP_SYSTEM_AMIGA,
64 wxZIP_SYSTEM_OPENVMS,
65 wxZIP_SYSTEM_UNIX,
66 wxZIP_SYSTEM_VM_CMS,
67 wxZIP_SYSTEM_ATARI_ST,
68 wxZIP_SYSTEM_OS2_HPFS,
69 wxZIP_SYSTEM_MACINTOSH,
70 wxZIP_SYSTEM_Z_SYSTEM,
71 wxZIP_SYSTEM_CPM,
72 wxZIP_SYSTEM_WINDOWS_NTFS,
73 wxZIP_SYSTEM_MVS,
74 wxZIP_SYSTEM_VSE,
75 wxZIP_SYSTEM_ACORN_RISC,
76 wxZIP_SYSTEM_VFAT,
77 wxZIP_SYSTEM_ALTERNATE_MVS,
78 wxZIP_SYSTEM_BEOS,
79 wxZIP_SYSTEM_TANDEM,
80 wxZIP_SYSTEM_OS_400
81};
82
83// Dos/Win file attributes
84//
85enum wxZipAttributes
86{
87 wxZIP_A_RDONLY = 0x01,
88 wxZIP_A_HIDDEN = 0x02,
89 wxZIP_A_SYSTEM = 0x04,
90 wxZIP_A_SUBDIR = 0x10,
91 wxZIP_A_ARCH = 0x20,
92
93 wxZIP_A_MASK = 0x37
94};
95
96// Values for the flags field in the zip headers
97//
98enum wxZipFlags
99{
100 wxZIP_ENCRYPTED = 0x0001,
101 wxZIP_DEFLATE_NORMAL = 0x0000, // normal compression
102 wxZIP_DEFLATE_EXTRA = 0x0002, // extra compression
103 wxZIP_DEFLATE_FAST = 0x0004, // fast compression
104 wxZIP_DEFLATE_SUPERFAST = 0x0006, // superfast compression
105 wxZIP_DEFLATE_MASK = 0x0006,
106 wxZIP_SUMS_FOLLOW = 0x0008, // crc and sizes come after the data
107 wxZIP_ENHANCED = 0x0010,
108 wxZIP_PATCH = 0x0020,
109 wxZIP_STRONG_ENC = 0x0040,
110 wxZIP_UNUSED = 0x0F80,
111 wxZIP_RESERVED = 0xF000
112};
113
114// Forward decls
115//
116class WXDLLIMPEXP_BASE wxZipEntry;
117class WXDLLIMPEXP_BASE wxZipInputStream;
118
119
120/////////////////////////////////////////////////////////////////////////////
121// wxZipNotifier
122
123class WXDLLIMPEXP_BASE wxZipNotifier
124{
125public:
126 virtual ~wxZipNotifier() { }
127
128 virtual void OnEntryUpdated(wxZipEntry& entry) = 0;
129};
130
131
132/////////////////////////////////////////////////////////////////////////////
133// Zip Entry - holds the meta data for a file in the zip
134
135class WXDLLIMPEXP_BASE wxZipEntry : public wxArchiveEntry
136{
137public:
138 wxZipEntry(const wxString& name = wxEmptyString,
139 const wxDateTime& dt = wxDateTime::Now(),
140 wxFileOffset size = wxInvalidOffset);
141 virtual ~wxZipEntry();
142
143 wxZipEntry(const wxZipEntry& entry);
144 wxZipEntry& operator=(const wxZipEntry& entry);
145
146 // Get accessors
147 wxDateTime GetDateTime() const { return m_DateTime; }
148 wxFileOffset GetSize() const { return m_Size; }
149 wxFileOffset GetOffset() const { return m_Offset; }
150 wxString GetInternalName() const { return m_Name; }
151 int GetMethod() const { return m_Method; }
152 int GetFlags() const { return m_Flags; }
153 wxUint32 GetCrc() const { return m_Crc; }
154 wxFileOffset GetCompressedSize() const { return m_CompressedSize; }
155 int GetSystemMadeBy() const { return m_SystemMadeBy; }
156 wxString GetComment() const { return m_Comment; }
157 wxUint32 GetExternalAttributes() const { return m_ExternalAttributes; }
158 wxPathFormat GetInternalFormat() const { return wxPATH_UNIX; }
159 int GetMode() const;
160 const char *GetLocalExtra() const;
161 size_t GetLocalExtraLen() const;
162 const char *GetExtra() const;
163 size_t GetExtraLen() const;
164 wxString GetName(wxPathFormat format = wxPATH_NATIVE) const;
165
166 // is accessors
167 inline bool IsDir() const;
168 inline bool IsText() const;
169 inline bool IsReadOnly() const;
170 inline bool IsMadeByUnix() const;
171
172 // set accessors
173 void SetDateTime(const wxDateTime& dt) { m_DateTime = dt; }
174 void SetSize(wxFileOffset size) { m_Size = size; }
175 void SetMethod(int method) { m_Method = (wxUint16)method; }
176 void SetComment(const wxString& comment) { m_Comment = comment; }
177 void SetExternalAttributes(wxUint32 attr ) { m_ExternalAttributes = attr; }
178 void SetSystemMadeBy(int system);
179 void SetMode(int mode);
180 void SetExtra(const char *extra, size_t len);
181 void SetLocalExtra(const char *extra, size_t len);
182
183 inline void SetName(const wxString& name,
184 wxPathFormat format = wxPATH_NATIVE);
185
186 static wxString GetInternalName(const wxString& name,
187 wxPathFormat format = wxPATH_NATIVE,
188 bool *pIsDir = NULL);
189
190 // set is accessors
191 void SetIsDir(bool isDir = true);
192 inline void SetIsReadOnly(bool isReadOnly = true);
193 inline void SetIsText(bool isText = true);
194
195 wxZipEntry *Clone() const { return ZipClone(); }
196
197 void SetNotifier(wxZipNotifier& notifier);
198 void UnsetNotifier();
199
200protected:
201 // Internal attributes
202 enum { TEXT_ATTR = 1 };
203
204 // protected Get accessors
205 int GetVersionNeeded() const { return m_VersionNeeded; }
206 wxFileOffset GetKey() const { return m_Key; }
207 int GetVersionMadeBy() const { return m_VersionMadeBy; }
208 int GetDiskStart() const { return m_DiskStart; }
209 int GetInternalAttributes() const { return m_InternalAttributes; }
210
211 void SetVersionNeeded(int version) { m_VersionNeeded = (wxUint16)version; }
212 void SetOffset(wxFileOffset offset) { m_Offset = offset; }
213 void SetFlags(int flags) { m_Flags = (wxUint16)flags; }
214 void SetVersionMadeBy(int version) { m_VersionMadeBy = (wxUint8)version; }
215 void SetCrc(wxUint32 crc) { m_Crc = crc; }
216 void SetCompressedSize(wxFileOffset size) { m_CompressedSize = size; }
217 void SetKey(wxFileOffset offset) { m_Key = offset; }
218 void SetDiskStart(int start) { m_DiskStart = (wxUint16)start; }
219 void SetInternalAttributes(int attr) { m_InternalAttributes = (wxUint16)attr; }
220
221 virtual wxZipEntry *ZipClone() const { return new wxZipEntry(*this); }
222
223 void Notify();
224
225private:
226 wxArchiveEntry* DoClone() const { return ZipClone(); }
227
228 size_t ReadLocal(wxInputStream& stream, wxMBConv& conv);
229 size_t WriteLocal(wxOutputStream& stream, wxMBConv& conv) const;
230
231 size_t ReadCentral(wxInputStream& stream, wxMBConv& conv);
232 size_t WriteCentral(wxOutputStream& stream, wxMBConv& conv) const;
233
234 size_t ReadDescriptor(wxInputStream& stream);
235 size_t WriteDescriptor(wxOutputStream& stream, wxUint32 crc,
236 wxFileOffset compressedSize, wxFileOffset size);
237
238 wxUint8 m_SystemMadeBy; // one of enum wxZipSystem
239 wxUint8 m_VersionMadeBy; // major * 10 + minor
240
241 wxUint16 m_VersionNeeded; // ver needed to extract (20 i.e. v2.0)
242 wxUint16 m_Flags;
243 wxUint16 m_Method; // compression method (one of wxZipMethod)
244 wxDateTime m_DateTime;
245 wxUint32 m_Crc;
246 wxFileOffset m_CompressedSize;
247 wxFileOffset m_Size;
248 wxString m_Name; // in internal format
249 wxFileOffset m_Key; // the original offset for copied entries
250 wxFileOffset m_Offset; // file offset of the entry
251
252 wxString m_Comment;
253 wxUint16 m_DiskStart; // for multidisk archives, not unsupported
254 wxUint16 m_InternalAttributes; // bit 0 set for text files
255 wxUint32 m_ExternalAttributes; // system specific depends on SystemMadeBy
256
257 class wxZipMemory *m_Extra;
258 class wxZipMemory *m_LocalExtra;
259
260 wxZipNotifier *m_zipnotifier;
261 class wxZipWeakLinks *m_backlink;
262
263 friend class wxZipInputStream;
264 friend class wxZipOutputStream;
265
266 DECLARE_DYNAMIC_CLASS(wxZipEntry)
267};
268
269
270/////////////////////////////////////////////////////////////////////////////
271// wxZipOutputStream
272
273WX_DECLARE_LIST_WITH_DECL(wxZipEntry, wx__ZipEntryList, class WXDLLIMPEXP_BASE);
274
275class WXDLLIMPEXP_BASE wxZipOutputStream : public wxArchiveOutputStream
276{
277public:
278 wxZipOutputStream(wxOutputStream& stream,
279 int level = -1,
280 wxMBConv& conv = wxConvLocal);
281 virtual WXZIPFIX ~wxZipOutputStream();
282
283 bool PutNextEntry(wxZipEntry *entry) { return DoCreate(entry); }
284
285 bool WXZIPFIX PutNextEntry(const wxString& name,
286 const wxDateTime& dt = wxDateTime::Now(),
287 wxFileOffset size = wxInvalidOffset);
288
289 bool WXZIPFIX PutNextDirEntry(const wxString& name,
290 const wxDateTime& dt = wxDateTime::Now());
291
292 bool WXZIPFIX CopyEntry(wxZipEntry *entry, wxZipInputStream& inputStream);
293 bool WXZIPFIX CopyArchiveMetaData(wxZipInputStream& inputStream);
294
295 void WXZIPFIX Sync();
296 bool WXZIPFIX CloseEntry();
297 bool WXZIPFIX Close();
298
299 void SetComment(const wxString& comment) { m_Comment = comment; }
300
301 int GetLevel() const { return m_level; }
302 void WXZIPFIX SetLevel(int level);
303
304protected:
305 virtual size_t WXZIPFIX OnSysWrite(const void *buffer, size_t size);
306 virtual wxFileOffset OnSysTell() const { return m_entrySize; }
307
308 // this protected interface isn't yet finalised
309 struct Buffer { const char *m_data; size_t m_size; };
310 virtual wxOutputStream* WXZIPFIX OpenCompressor(wxOutputStream& stream,
311 wxZipEntry& entry,
312 const Buffer bufs[]);
313 virtual bool WXZIPFIX CloseCompressor(wxOutputStream *comp);
314
315 bool IsParentSeekable() const
316 { return m_offsetAdjustment != wxInvalidOffset; }
317
318private:
319 bool WXZIPFIX PutNextEntry(wxArchiveEntry *entry);
320 bool WXZIPFIX CopyEntry(wxArchiveEntry *entry, wxArchiveInputStream& stream);
321 bool WXZIPFIX CopyArchiveMetaData(wxArchiveInputStream& stream);
322
323 bool IsOpened() const { return m_comp || m_pending; }
324
325 bool DoCreate(wxZipEntry *entry, bool raw = false);
326 void CreatePendingEntry(const void *buffer, size_t size);
327 void CreatePendingEntry();
328
329 class wxStoredOutputStream *m_store;
330 class wxZlibOutputStream2 *m_deflate;
331 class wxZipStreamLink *m_backlink;
332 wx__ZipEntryList m_entries;
333 char *m_initialData;
334 size_t m_initialSize;
335 wxZipEntry *m_pending;
336 bool m_raw;
337 wxFileOffset m_headerOffset;
338 size_t m_headerSize;
339 wxFileOffset m_entrySize;
340 wxUint32 m_crcAccumulator;
341 wxOutputStream *m_comp;
342 int m_level;
343 wxFileOffset m_offsetAdjustment;
344 wxString m_Comment;
345
346 DECLARE_NO_COPY_CLASS(wxZipOutputStream)
347};
348
349
350/////////////////////////////////////////////////////////////////////////////
351// wxZipInputStream
352
353class WXDLLIMPEXP_BASE wxZipInputStream : public wxArchiveInputStream
354{
355public:
356 typedef wxZipEntry entry_type;
357
358 wxZipInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal);
359
360#if 1 //WXWIN_COMPATIBILITY_2_6
361 wxZipInputStream(const wxString& archive, const wxString& file)
362 : wxArchiveInputStream(OpenFile(archive), wxConvLocal) { Init(file); }
363#endif
364
365 virtual WXZIPFIX ~wxZipInputStream();
366
367 bool OpenEntry(wxZipEntry& entry) { return DoOpen(&entry); }
368 bool WXZIPFIX CloseEntry();
369
370 wxZipEntry *GetNextEntry();
371
372 wxString WXZIPFIX GetComment();
373 int WXZIPFIX GetTotalEntries();
374
375 virtual wxFileOffset GetLength() const { return m_entry.GetSize(); }
376
377protected:
378 size_t WXZIPFIX OnSysRead(void *buffer, size_t size);
379 wxFileOffset OnSysTell() const { return m_decomp ? m_decomp->TellI() : 0; }
380
381#if 1 //WXWIN_COMPATIBILITY_2_6
382 wxFileOffset WXZIPFIX OnSysSeek(wxFileOffset seek, wxSeekMode mode);
383#endif
384
385 // this protected interface isn't yet finalised
386 virtual wxInputStream* WXZIPFIX OpenDecompressor(wxInputStream& stream);
387 virtual bool WXZIPFIX CloseDecompressor(wxInputStream *decomp);
388
389private:
390 void Init();
391 void Init(const wxString& file);
392 wxInputStream& OpenFile(const wxString& archive);
393
394 wxArchiveEntry *DoGetNextEntry() { return GetNextEntry(); }
395
396 bool WXZIPFIX OpenEntry(wxArchiveEntry& entry);
397
398 wxStreamError ReadLocal(bool readEndRec = false);
399 wxStreamError ReadCentral();
400
401 wxUint32 ReadSignature();
402 bool FindEndRecord();
403 bool LoadEndRecord();
404
405 bool AtHeader() const { return m_headerSize == 0; }
406 bool AfterHeader() const { return m_headerSize > 0 && !m_decomp; }
407 bool IsOpened() const { return m_decomp != NULL; }
408
409 wxZipStreamLink *MakeLink(wxZipOutputStream *out);
410
411 bool DoOpen(wxZipEntry *entry = NULL, bool raw = false);
412 bool OpenDecompressor(bool raw = false);
413
414 class wxStoredInputStream *m_store;
415 class wxZlibInputStream2 *m_inflate;
416 class wxRawInputStream *m_rawin;
417 class wxFFileInputStream *m_ffile;
418 wxZipEntry m_entry;
419 bool m_raw;
420 size_t m_headerSize;
421 wxUint32 m_crcAccumulator;
422 wxInputStream *m_decomp;
423 bool m_parentSeekable;
424 class wxZipWeakLinks *m_weaklinks;
425 class wxZipStreamLink *m_streamlink;
426 wxFileOffset m_offsetAdjustment;
427 wxFileOffset m_position;
428 wxUint32 m_signature;
429 size_t m_TotalEntries;
430 wxString m_Comment;
431
432 friend bool wxZipOutputStream::CopyEntry(
433 wxZipEntry *entry, wxZipInputStream& inputStream);
434 friend bool wxZipOutputStream::CopyArchiveMetaData(
435 wxZipInputStream& inputStream);
436
437#if 1 //WXWIN_COMPATIBILITY_2_6
438 bool m_allowSeeking;
439 friend class wxZipFSInputStream;
440#endif
441
442 DECLARE_NO_COPY_CLASS(wxZipInputStream)
443};
444
445
446/////////////////////////////////////////////////////////////////////////////
447// Iterators
448
449#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
450typedef wxArchiveIterator<wxZipInputStream> wxZipIter;
451typedef wxArchiveIterator<wxZipInputStream,
452 std::pair<wxString, wxZipEntry*> > wxZipPairIter;
453#endif
454
455
456/////////////////////////////////////////////////////////////////////////////
457// wxZipClassFactory
458
459class WXDLLIMPEXP_BASE wxZipClassFactory : public wxArchiveClassFactory
460{
461public:
462 typedef wxZipEntry entry_type;
463 typedef wxZipInputStream instream_type;
464 typedef wxZipOutputStream outstream_type;
465 typedef wxZipNotifier notifier_type;
466#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
467 typedef wxZipIter iter_type;
468 typedef wxZipPairIter pairiter_type;
469#endif
470
471 wxZipEntry *NewEntry() const
472 { return new wxZipEntry; }
473 wxZipInputStream *NewStream(wxInputStream& stream) const
474 { return new wxZipInputStream(stream, GetConv()); }
475 wxZipOutputStream *NewStream(wxOutputStream& stream) const
476 { return new wxZipOutputStream(stream, -1, GetConv()); }
477
478 wxString GetInternalName(const wxString& name,
479 wxPathFormat format = wxPATH_NATIVE) const
480 { return wxZipEntry::GetInternalName(name, format); }
481
482protected:
483 wxArchiveEntry *DoNewEntry() const
484 { return NewEntry(); }
485 wxArchiveInputStream *DoNewStream(wxInputStream& stream) const
486 { return NewStream(stream); }
487 wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const
488 { return NewStream(stream); }
489
490private:
491 DECLARE_DYNAMIC_CLASS(wxZipClassFactory)
492};
493
494
495/////////////////////////////////////////////////////////////////////////////
496// wxZipEntry inlines
497
498inline bool wxZipEntry::IsText() const
499{
500 return (m_InternalAttributes & TEXT_ATTR) != 0;
501}
502
503inline bool wxZipEntry::IsDir() const
504{
505 return (m_ExternalAttributes & wxZIP_A_SUBDIR) != 0;
506}
507
508inline bool wxZipEntry::IsReadOnly() const
509{
510 return (m_ExternalAttributes & wxZIP_A_RDONLY) != 0;
511}
512
513inline bool wxZipEntry::IsMadeByUnix() const
514{
515 const int pattern =
516 (1 << wxZIP_SYSTEM_OPENVMS) |
517 (1 << wxZIP_SYSTEM_UNIX) |
518 (1 << wxZIP_SYSTEM_ATARI_ST) |
519 (1 << wxZIP_SYSTEM_ACORN_RISC) |
520 (1 << wxZIP_SYSTEM_BEOS) | (1 << wxZIP_SYSTEM_TANDEM);
521
522 // note: some unix zippers put madeby = dos
523 return (m_SystemMadeBy == wxZIP_SYSTEM_MSDOS
524 && (m_ExternalAttributes & ~0xFFFF))
525 || ((pattern >> m_SystemMadeBy) & 1);
526}
527
528inline void wxZipEntry::SetIsText(bool isText)
529{
530 if (isText)
531 m_InternalAttributes |= TEXT_ATTR;
532 else
533 m_InternalAttributes &= ~TEXT_ATTR;
534}
535
536inline void wxZipEntry::SetIsReadOnly(bool isReadOnly)
537{
538 if (isReadOnly)
539 SetMode(GetMode() & ~0222);
540 else
541 SetMode(GetMode() | 0200);
542}
543
544inline void wxZipEntry::SetName(const wxString& name,
545 wxPathFormat format /*=wxPATH_NATIVE*/)
546{
547 bool isDir;
548 m_Name = GetInternalName(name, format, &isDir);
549 SetIsDir(isDir);
550}
551
552
553#endif // wxUSE_ZLIB && wxUSE_STREAMS && wxUSE_ZIPSTREAM
554
555#endif // _WX_WXZIPSTREAM_H__
wxWidgets (Impactor)