include/wx/tarstrm.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/tarstrm.h
   3 // Purpose:     Streams for Tar files
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Mike Wetherell
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifndef _WX_WXTARSTREAM_H__
  11 #define _WX_WXTARSTREAM_H__
  12
  13 #include "wx/defs.h"
  14
  15 #if wxUSE_TARSTREAM
  16
  17 #include "wx/archive.h"
  18 #include "wx/hashmap.h"
  19
  20
  21 /////////////////////////////////////////////////////////////////////////////
  22 // Constants
  23
  24 // TypeFlag values
  25 enum wxTarType
  26 {
  27     wxTAR_REGTYPE   = '0',      // regular file
  28     wxTAR_LNKTYPE   = '1',      // hard link
  29     wxTAR_SYMTYPE   = '2',      // symbolic link
  30     wxTAR_CHRTYPE   = '3',      // character special
  31     wxTAR_BLKTYPE   = '4',      // block special
  32     wxTAR_DIRTYPE   = '5',      // directory
  33     wxTAR_FIFOTYPE  = '6',      // named pipe
  34     wxTAR_CONTTYPE  = '7'       // contiguous file
  35 };
  36
  37 // Archive Formats (use wxTAR_PAX, it's backward compatible)
  38 enum wxTarFormat
  39 {
  40     wxTAR_USTAR,                // POSIX.1-1990 tar format
  41     wxTAR_PAX                   // POSIX.1-2001 tar format
  42 };
  43
  44
  45 /////////////////////////////////////////////////////////////////////////////
  46 // wxTarNotifier
  47
  48 class WXDLLIMPEXP_BASE wxTarNotifier
  49 {
  50 public:
  51     virtual ~wxTarNotifier() { }
  52
  53     virtual void OnEntryUpdated(class wxTarEntry& entry) = 0;
  54 };
  55
  56
  57 /////////////////////////////////////////////////////////////////////////////
  58 // Tar Entry - hold the meta data for a file in the tar
  59
  60 class WXDLLIMPEXP_BASE wxTarEntry : public wxArchiveEntry
  61 {
  62 public:
  63     wxTarEntry(const wxString& name = wxEmptyString,
  64                const wxDateTime& dt = wxDateTime::Now(),
  65                wxFileOffset size = wxInvalidOffset);
  66     virtual ~wxTarEntry();
  67
  68     wxTarEntry(const wxTarEntry& entry);
  69     wxTarEntry& operator=(const wxTarEntry& entry);
  70
  71     // Get accessors
  72     wxString     GetName(wxPathFormat format = wxPATH_NATIVE) const;
  73     wxString     GetInternalName() const        { return m_Name; }
  74     wxPathFormat GetInternalFormat() const      { return wxPATH_UNIX; }
  75     int          GetMode() const;
  76     int          GetUserId() const              { return m_UserId; }
  77     int          GetGroupId() const             { return m_GroupId; }
  78     wxFileOffset GetSize() const                { return m_Size; }
  79     wxFileOffset GetOffset() const              { return m_Offset; }
  80     wxDateTime   GetDateTime() const            { return m_ModifyTime; }
  81     wxDateTime   GetAccessTime() const          { return m_AccessTime; }
  82     wxDateTime   GetCreateTime() const          { return m_CreateTime; }
  83     int          GetTypeFlag() const            { return m_TypeFlag; }
  84     wxString     GetLinkName() const            { return m_LinkName; }
  85     wxString     GetUserName() const            { return m_UserName; }
  86     wxString     GetGroupName() const           { return m_GroupName; }
  87     int          GetDevMajor() const            { return m_DevMajor; }
  88     int          GetDevMinor() const            { return m_DevMinor; }
  89
  90     // is accessors
  91     bool IsDir() const;
  92     bool IsReadOnly() const                     { return !(m_Mode & 0222); }
  93
  94     // set accessors
  95     void SetName(const wxString& name, wxPathFormat format = wxPATH_NATIVE);
  96     void SetUserId(int id)                      { m_UserId = id; }
  97     void SetGroupId(int id)                     { m_GroupId = id; }
  98     void SetMode(int mode);
  99     void SetSize(wxFileOffset size)             { m_Size = size; }
 100     void SetDateTime(const wxDateTime& dt)      { m_ModifyTime = dt; }
 101     void SetAccessTime(const wxDateTime& dt)    { m_AccessTime = dt; }
 102     void SetCreateTime(const wxDateTime& dt)    { m_CreateTime = dt; }
 103     void SetTypeFlag(int type)                  { m_TypeFlag = type; }
 104     void SetLinkName(const wxString& link)      { m_LinkName = link; }
 105     void SetUserName(const wxString& user)      { m_UserName = user; }
 106     void SetGroupName(const wxString& group)    { m_GroupName = group; }
 107     void SetDevMajor(int dev)                   { m_DevMajor = dev; }
 108     void SetDevMinor(int dev)                   { m_DevMinor = dev; }
 109
 110     // set is accessors
 111     void SetIsDir(bool isDir = true);
 112     void SetIsReadOnly(bool isReadOnly = true);
 113
 114     static wxString GetInternalName(const wxString& name,
 115                                     wxPathFormat format = wxPATH_NATIVE,
 116                                     bool *pIsDir = NULL);
 117
 118     wxTarEntry *Clone() const { return new wxTarEntry(*this); }
 119
 120     void SetNotifier(wxTarNotifier& WXUNUSED(notifier)) { }
 121
 122 private:
 123     void SetOffset(wxFileOffset offset)         { m_Offset = offset; }
 124
 125     virtual wxArchiveEntry* DoClone() const     { return Clone(); }
 126
 127     wxString     m_Name;
 128     int          m_Mode;
 129     bool         m_IsModeSet;
 130     int          m_UserId;
 131     int          m_GroupId;
 132     wxFileOffset m_Size;
 133     wxFileOffset m_Offset;
 134     wxDateTime   m_ModifyTime;
 135     wxDateTime   m_AccessTime;
 136     wxDateTime   m_CreateTime;
 137     int          m_TypeFlag;
 138     wxString     m_LinkName;
 139     wxString     m_UserName;
 140     wxString     m_GroupName;
 141     int          m_DevMajor;
 142     int          m_DevMinor;
 143
 144     friend class wxTarInputStream;
 145
 146     DECLARE_DYNAMIC_CLASS(wxTarEntry)
 147 };
 148
 149
 150 /////////////////////////////////////////////////////////////////////////////
 151 // wxTarInputStream
 152
 153 WX_DECLARE_STRING_HASH_MAP(wxString, wxTarHeaderRecords);
 154
 155 class WXDLLIMPEXP_BASE wxTarInputStream : public wxArchiveInputStream
 156 {
 157 public:
 158     typedef wxTarEntry entry_type;
 159
 160     wxTarInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal);
 161     wxTarInputStream(wxInputStream *stream, wxMBConv& conv = wxConvLocal);
 162     virtual ~wxTarInputStream();
 163
 164     bool OpenEntry(wxTarEntry& entry);
 165     bool CloseEntry();
 166
 167     wxTarEntry *GetNextEntry();
 168
 169     wxFileOffset GetLength() const      { return m_size; }
 170     bool IsSeekable() const { return m_parent_i_stream->IsSeekable(); }
 171
 172 protected:
 173     size_t OnSysRead(void *buffer, size_t size);
 174     wxFileOffset OnSysTell() const      { return m_pos; }
 175     wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode);
 176
 177 private:
 178     void Init();
 179
 180     wxArchiveEntry *DoGetNextEntry()    { return GetNextEntry(); }
 181     bool OpenEntry(wxArchiveEntry& entry);
 182     bool IsOpened() const               { return m_pos != wxInvalidOffset; }
 183
 184     wxStreamError ReadHeaders();
 185     bool ReadExtendedHeader(wxTarHeaderRecords*& recs);
 186
 187     wxString GetExtendedHeader(const wxString& key) const;
 188     wxString GetHeaderPath() const;
 189     wxFileOffset GetHeaderNumber(int id) const;
 190     wxString GetHeaderString(int id) const;
 191     wxDateTime GetHeaderDate(const wxString& key) const;
 192
 193     wxFileOffset m_pos;     // position within the current entry
 194     wxFileOffset m_offset;  // offset to the start of the entry's data
 195     wxFileOffset m_size;    // size of the current entry's data
 196
 197     int m_sumType;
 198     int m_tarType;
 199     class wxTarHeaderBlock *m_hdr;
 200     wxTarHeaderRecords *m_HeaderRecs;
 201     wxTarHeaderRecords *m_GlobalHeaderRecs;
 202
 203     DECLARE_NO_COPY_CLASS(wxTarInputStream)
 204 };
 205
 206
 207 /////////////////////////////////////////////////////////////////////////////
 208 // wxTarOutputStream
 209
 210 class WXDLLIMPEXP_BASE wxTarOutputStream : public wxArchiveOutputStream
 211 {
 212 public:
 213     wxTarOutputStream(wxOutputStream& stream,
 214                       wxTarFormat format = wxTAR_PAX,
 215                       wxMBConv& conv = wxConvLocal);
 216     wxTarOutputStream(wxOutputStream *stream,
 217                       wxTarFormat format = wxTAR_PAX,
 218                       wxMBConv& conv = wxConvLocal);
 219     virtual ~wxTarOutputStream();
 220
 221     bool PutNextEntry(wxTarEntry *entry);
 222
 223     bool PutNextEntry(const wxString& name,
 224                       const wxDateTime& dt = wxDateTime::Now(),
 225                       wxFileOffset size = wxInvalidOffset);
 226
 227     bool PutNextDirEntry(const wxString& name,
 228                          const wxDateTime& dt = wxDateTime::Now());
 229
 230     bool CopyEntry(wxTarEntry *entry, wxTarInputStream& inputStream);
 231     bool CopyArchiveMetaData(wxTarInputStream& WXUNUSED(s)) { return true; }
 232
 233     void Sync();
 234     bool CloseEntry();
 235     bool Close();
 236
 237     bool IsSeekable() const { return m_parent_o_stream->IsSeekable(); }
 238
 239     void SetBlockingFactor(int factor)  { m_BlockingFactor = factor; }
 240     int GetBlockingFactor() const       { return m_BlockingFactor; }
 241
 242 protected:
 243     size_t OnSysWrite(const void *buffer, size_t size);
 244     wxFileOffset OnSysTell() const      { return m_pos; }
 245     wxFileOffset OnSysSeek(wxFileOffset pos, wxSeekMode mode);
 246
 247 private:
 248     void Init(wxTarFormat format);
 249
 250     bool PutNextEntry(wxArchiveEntry *entry);
 251     bool CopyEntry(wxArchiveEntry *entry, wxArchiveInputStream& stream);
 252     bool CopyArchiveMetaData(wxArchiveInputStream& WXUNUSED(s)) { return true; }
 253     bool IsOpened() const               { return m_pos != wxInvalidOffset; }
 254
 255     bool WriteHeaders(wxTarEntry& entry);
 256     bool ModifyHeader();
 257     wxString PaxHeaderPath(const wxString& format, const wxString& path);
 258
 259     void SetExtendedHeader(const wxString& key, const wxString& value);
 260     void SetHeaderPath(const wxString& name);
 261     bool SetHeaderNumber(int id, wxFileOffset n);
 262     void SetHeaderString(int id, const wxString& str);
 263     void SetHeaderDate(const wxString& key, const wxDateTime& datetime);
 264
 265     wxFileOffset m_pos;     // position within the current entry
 266     wxFileOffset m_maxpos;  // max pos written
 267     wxFileOffset m_size;    // expected entry size
 268
 269     wxFileOffset m_headpos; // offset within the file to the entry's header
 270     wxFileOffset m_datapos; // offset within the file to the entry's data
 271
 272     wxFileOffset m_tarstart;// offset within the file to the tar
 273     wxFileOffset m_tarsize; // size of tar so far
 274
 275     bool m_pax;
 276     int m_BlockingFactor;
 277     wxUint32 m_chksum;
 278     bool m_large;
 279     class wxTarHeaderBlock *m_hdr;
 280     class wxTarHeaderBlock *m_hdr2;
 281     char *m_extendedHdr;
 282     size_t m_extendedSize;
 283     wxString m_badfit;
 284     bool m_endrecWritten;
 285
 286     DECLARE_NO_COPY_CLASS(wxTarOutputStream)
 287 };
 288
 289
 290 /////////////////////////////////////////////////////////////////////////////
 291 // Iterators
 292
 293 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
 294 typedef wxArchiveIterator<wxTarInputStream> wxTarIter;
 295 typedef wxArchiveIterator<wxTarInputStream,
 296          std::pair<wxString, wxTarEntry*> > wxTarPairIter;
 297 #endif
 298
 299
 300 /////////////////////////////////////////////////////////////////////////////
 301 // wxTarClassFactory
 302
 303 class WXDLLIMPEXP_BASE wxTarClassFactory : public wxArchiveClassFactory
 304 {
 305 public:
 306     typedef wxTarEntry        entry_type;
 307     typedef wxTarInputStream  instream_type;
 308     typedef wxTarOutputStream outstream_type;
 309     typedef wxTarNotifier     notifier_type;
 310 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
 311     typedef wxTarIter         iter_type;
 312     typedef wxTarPairIter     pairiter_type;
 313 #endif
 314
 315     wxTarClassFactory();
 316
 317     wxTarEntry *NewEntry() const
 318         { return new wxTarEntry; }
 319     wxTarInputStream *NewStream(wxInputStream& stream) const
 320         { return new wxTarInputStream(stream, GetConv()); }
 321     wxTarOutputStream *NewStream(wxOutputStream& stream) const
 322         { return new wxTarOutputStream(stream, wxTAR_PAX, GetConv()); }
 323     wxTarInputStream *NewStream(wxInputStream *stream) const
 324         { return new wxTarInputStream(stream, GetConv()); }
 325     wxTarOutputStream *NewStream(wxOutputStream *stream) const
 326         { return new wxTarOutputStream(stream, wxTAR_PAX, GetConv()); }
 327
 328     wxString GetInternalName(const wxString& name,
 329                              wxPathFormat format = wxPATH_NATIVE) const
 330         { return wxTarEntry::GetInternalName(name, format); }
 331
 332     const wxChar * const *GetProtocols(wxStreamProtocolType type
 333                                        = wxSTREAM_PROTOCOL) const;
 334
 335 protected:
 336     wxArchiveEntry *DoNewEntry() const
 337         { return NewEntry(); }
 338     wxArchiveInputStream *DoNewStream(wxInputStream& stream) const
 339         { return NewStream(stream); }
 340     wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const
 341         { return NewStream(stream); }
 342     wxArchiveInputStream *DoNewStream(wxInputStream *stream) const
 343         { return NewStream(stream); }
 344     wxArchiveOutputStream *DoNewStream(wxOutputStream *stream) const
 345         { return NewStream(stream); }
 346
 347 private:
 348     DECLARE_DYNAMIC_CLASS(wxTarClassFactory)
 349 };
 350
 351
 352 #endif // wxUSE_TARSTREAM
 353
 354 #endif // _WX_WXTARSTREAM_H__