src/common/tarstrm.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        tarstrm.cpp
   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 // 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_TARSTREAM
  18
  19 #include "wx/tarstrm.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/intl.h"
  23     #include "wx/log.h"
  24     #include "wx/utils.h"
  25 #endif
  26
  27 #include "wx/buffer.h"
  28 #include "wx/datetime.h"
  29 #include "wx/scopedptr.h"
  30 #include "wx/filename.h"
  31 #include "wx/thread.h"
  32
  33 #include <ctype.h>
  34
  35 #ifdef __UNIX__
  36 #include <pwd.h>
  37 #include <grp.h>
  38 #endif
  39
  40
  41 /////////////////////////////////////////////////////////////////////////////
  42 // constants
  43
  44 enum {
  45     TAR_NAME,
  46     TAR_MODE,
  47     TAR_UID,
  48     TAR_GID,
  49     TAR_SIZE,
  50     TAR_MTIME,
  51     TAR_CHKSUM,
  52     TAR_TYPEFLAG,
  53     TAR_LINKNAME,
  54     TAR_MAGIC,
  55     TAR_VERSION,
  56     TAR_UNAME,
  57     TAR_GNAME,
  58     TAR_DEVMAJOR,
  59     TAR_DEVMINOR,
  60     TAR_PREFIX,
  61     TAR_UNUSED,
  62     TAR_NUMFIELDS
  63 };
  64
  65 enum {
  66     TAR_BLOCKSIZE = 512
  67 };
  68
  69 // checksum type
  70 enum {
  71     SUM_UNKNOWN,
  72     SUM_UNSIGNED,
  73     SUM_SIGNED
  74 };
  75
  76 // type of input tar
  77 enum {
  78     TYPE_OLDTAR,    // fields after TAR_LINKNAME are invalid
  79     TYPE_GNUTAR,    // all fields except TAR_PREFIX are valid
  80     TYPE_USTAR      // all fields are valid
  81 };
  82
  83 // signatures
  84 static const char *USTAR_MAGIC   = "ustar";
  85 static const char *USTAR_VERSION = "00";
  86 static const char *GNU_MAGIC     = "ustar ";
  87 static const char *GNU_VERION    = " ";
  88
  89 IMPLEMENT_DYNAMIC_CLASS(wxTarEntry, wxArchiveEntry)
  90 IMPLEMENT_DYNAMIC_CLASS(wxTarClassFactory, wxArchiveClassFactory)
  91
  92
  93 /////////////////////////////////////////////////////////////////////////////
  94 // Class factory
  95
  96 static wxTarClassFactory g_wxTarClassFactory;
  97
  98 wxTarClassFactory::wxTarClassFactory()
  99 {
 100     if (this == &g_wxTarClassFactory)
 101         PushFront();
 102 }
 103
 104 const wxChar * const *
 105 wxTarClassFactory::GetProtocols(wxStreamProtocolType type) const
 106 {
 107     static const wxChar *protocols[] = { _T("tar"), NULL };
 108     static const wxChar *mimetypes[] = { _T("application/x-tar"), NULL };
 109     static const wxChar *fileexts[]  = { _T(".tar"), NULL };
 110     static const wxChar *empty[]     = { NULL };
 111
 112     switch (type) {
 113         case wxSTREAM_PROTOCOL: return protocols;
 114         case wxSTREAM_MIMETYPE: return mimetypes;
 115         case wxSTREAM_FILEEXT:  return fileexts;
 116         default:                return empty;
 117     }
 118 }
 119
 120
 121 /////////////////////////////////////////////////////////////////////////////
 122 // tar header block
 123
 124 typedef wxFileOffset wxTarNumber;
 125
 126 struct wxTarField { const wxChar *name; int pos; };
 127
 128 class wxTarHeaderBlock
 129 {
 130 public:
 131     wxTarHeaderBlock()
 132         { memset(data, 0, sizeof(data)); }
 133     wxTarHeaderBlock(const wxTarHeaderBlock& hb)
 134         { memcpy(data, hb.data, sizeof(data)); }
 135
 136     bool Read(wxInputStream& in);
 137     bool Write(wxOutputStream& out);
 138     inline bool WriteField(wxOutputStream& out, int id);
 139
 140     bool IsAllZeros() const;
 141     wxUint32 Sum(bool SignedSum = false);
 142     wxUint32 SumField(int id);
 143
 144     char *Get(int id) { return data + fields[id].pos + id; }
 145     static size_t Len(int id) { return fields[id + 1].pos - fields[id].pos; }
 146     static const wxChar *Name(int id) { return fields[id].name; }
 147     static size_t Offset(int id) { return fields[id].pos; }
 148
 149     bool SetOctal(int id, wxTarNumber n);
 150     wxTarNumber GetOctal(int id);
 151     bool SetPath(const wxString& name, wxMBConv& conv);
 152
 153 private:
 154     char data[TAR_BLOCKSIZE + TAR_NUMFIELDS];
 155     static const wxTarField fields[];
 156     static void check();
 157 };
 158
 159 wxDEFINE_SCOPED_PTR_TYPE(wxTarHeaderBlock)
 160
 161 // A table giving the field names and offsets in a tar header block
 162 const wxTarField wxTarHeaderBlock::fields[] =
 163 {
 164     { _T("name"), 0 },       // 100
 165     { _T("mode"), 100 },     // 8
 166     { _T("uid"), 108 },      // 8
 167     { _T("gid"), 116 },      // 8
 168     { _T("size"), 124 },     // 12
 169     { _T("mtime"), 136 },    // 12
 170     { _T("chksum"), 148 },   // 8
 171     { _T("typeflag"), 156 }, // 1
 172     { _T("linkname"), 157 }, // 100
 173     { _T("magic"), 257 },    // 6
 174     { _T("version"), 263 },  // 2
 175     { _T("uname"), 265 },    // 32
 176     { _T("gname"), 297 },    // 32
 177     { _T("devmajor"), 329 }, // 8
 178     { _T("devminor"), 337 }, // 8
 179     { _T("prefix"), 345 },   // 155
 180     { _T("unused"), 500 },   // 12
 181     { NULL, TAR_BLOCKSIZE }
 182 };
 183
 184 void wxTarHeaderBlock::check()
 185 {
 186 #if 0
 187     wxCOMPILE_TIME_ASSERT(
 188         WXSIZEOF(fields) == TAR_NUMFIELDS + 1,
 189         Wrong_number_of_elements_in_fields_table
 190     );
 191 #endif
 192 }
 193
 194 bool wxTarHeaderBlock::IsAllZeros() const
 195 {
 196     const char *p = data;
 197     for (size_t i = 0; i < sizeof(data); i++)
 198         if (p[i])
 199             return false;
 200     return true;
 201 }
 202
 203 wxUint32 wxTarHeaderBlock::Sum(bool SignedSum /*=false*/)
 204 {
 205     // the chksum field itself should be blanks during the calculation
 206     memset(Get(TAR_CHKSUM), ' ', Len(TAR_CHKSUM));
 207     const char *p = data;
 208     wxUint32 n = 0;
 209
 210     if (SignedSum)
 211         for (size_t i = 0; i < sizeof(data); i++)
 212             n += (signed char)p[i];
 213     else
 214         for (size_t i = 0; i < sizeof(data); i++)
 215             n += (unsigned char)p[i];
 216
 217     return n;
 218 }
 219
 220 wxUint32 wxTarHeaderBlock::SumField(int id)
 221 {
 222     unsigned char *p = (unsigned char*)Get(id);
 223     unsigned char *q = p + Len(id);
 224     wxUint32 n = 0;
 225
 226     while (p < q)
 227         n += *p++;
 228
 229     return n;
 230 }
 231
 232 bool wxTarHeaderBlock::Read(wxInputStream& in)
 233 {
 234     bool ok = true;
 235
 236     for (int id = 0; id < TAR_NUMFIELDS && ok; id++)
 237         ok = in.Read(Get(id), Len(id)).LastRead() == Len(id);
 238
 239     return ok;
 240 }
 241
 242 bool wxTarHeaderBlock::Write(wxOutputStream& out)
 243 {
 244     bool ok = true;
 245
 246     for (int id = 0; id < TAR_NUMFIELDS && ok; id++)
 247         ok = WriteField(out, id);
 248
 249     return ok;
 250 }
 251
 252 inline bool wxTarHeaderBlock::WriteField(wxOutputStream& out, int id)
 253 {
 254     return out.Write(Get(id), Len(id)).LastWrite() == Len(id);
 255 }
 256
 257 wxTarNumber wxTarHeaderBlock::GetOctal(int id)
 258 {
 259     wxTarNumber n = 0;
 260     const char *p = Get(id);
 261     while (*p == ' ')
 262         p++;
 263     while (*p >= '0' && *p < '8')
 264         n = (n << 3) | (*p++ - '0');
 265     return n;
 266 }
 267
 268 bool wxTarHeaderBlock::SetOctal(int id, wxTarNumber n)
 269 {
 270     // set an octal field, return true if the number fits
 271     char *field = Get(id);
 272     char *p = field + Len(id);
 273     *--p = 0;
 274     while (p > field) {
 275         *--p = char('0' + (n & 7));
 276         n >>= 3;
 277     }
 278     return n == 0;
 279 }
 280
 281 bool wxTarHeaderBlock::SetPath(const wxString& name, wxMBConv& conv)
 282 {
 283     bool badconv = false;
 284
 285 #if wxUSE_UNICODE
 286     wxCharBuffer nameBuf = name.mb_str(conv);
 287
 288     // if the conversion fails make an approximation
 289     if (!nameBuf) {
 290         badconv = true;
 291         size_t len = name.length();
 292         wxCharBuffer approx(len);
 293         for (size_t i = 0; i < len; i++)
 294         {
 295             wxChar c = name[i];
 296             approx.data()[i] = c & ~0x7F ? '_' : c;
 297         }
 298         nameBuf = approx;
 299     }
 300
 301     const char *mbName = nameBuf;
 302 #else
 303     const char *mbName = name.c_str();
 304     (void)conv;
 305 #endif
 306
 307     bool fits;
 308     bool notGoingToFit = false;
 309     size_t len = strlen(mbName);
 310     size_t maxname = Len(TAR_NAME);
 311     size_t maxprefix = Len(TAR_PREFIX);
 312     size_t i = 0;
 313     size_t nexti = 0;
 314
 315     for (;;) {
 316         fits = i < maxprefix && len - i <= maxname;
 317
 318         if (!fits) {
 319             const char *p = strchr(mbName + i, '/');
 320             if (p)
 321                 nexti = p - mbName + 1;
 322             if (!p || nexti - 1 > maxprefix)
 323                 notGoingToFit = true;
 324         }
 325
 326         if (fits || notGoingToFit) {
 327             strncpy(Get(TAR_NAME), mbName + i, maxname);
 328             if (i > 0)
 329                 strncpy(Get(TAR_PREFIX), mbName, i - 1);
 330             break;
 331         }
 332
 333         i = nexti;
 334     }
 335
 336     return fits && !badconv;
 337 }
 338
 339
 340 /////////////////////////////////////////////////////////////////////////////
 341 // Some helpers
 342
 343 static wxFileOffset RoundUpSize(wxFileOffset size, int factor = 1)
 344 {
 345     wxFileOffset chunk = TAR_BLOCKSIZE * factor;
 346     return ((size + chunk - 1) / chunk) * chunk;
 347 }
 348
 349 #ifdef __UNIX__
 350
 351 static wxString wxTarUserName(int uid)
 352 {
 353     struct passwd *ppw;
 354
 355 #ifdef HAVE_GETPWUID_R
 356 #if defined HAVE_SYSCONF && defined _SC_GETPW_R_SIZE_MAX
 357     long pwsize = sysconf(_SC_GETPW_R_SIZE_MAX);
 358     size_t bufsize(wxMin(wxMax(1024l, pwsize), 32768l));
 359 #else
 360     size_t bufsize = 1024;
 361 #endif
 362     wxCharBuffer buf(bufsize);
 363     struct passwd pw;
 364
 365     memset(&pw, 0, sizeof(pw));
 366     if (getpwuid_r(uid, &pw, buf.data(), bufsize, &ppw) == 0 && pw.pw_name)
 367         return wxString(pw.pw_name, wxConvLibc);
 368 #else
 369     if ((ppw = getpwuid(uid)) != NULL)
 370         return wxString(ppw->pw_name, wxConvLibc);
 371 #endif
 372     return _("unknown");
 373 }
 374
 375 static wxString wxTarGroupName(int gid)
 376 {
 377     struct group *pgr;
 378 #ifdef HAVE_GETGRGID_R
 379 #if defined HAVE_SYSCONF && defined _SC_GETGR_R_SIZE_MAX
 380     long grsize = sysconf(_SC_GETGR_R_SIZE_MAX);
 381     size_t bufsize(wxMin(wxMax(1024l, grsize), 32768l));
 382 #else
 383     size_t bufsize = 1024;
 384 #endif
 385     wxCharBuffer buf(bufsize);
 386     struct group gr;
 387
 388     memset(&gr, 0, sizeof(gr));
 389     if (getgrgid_r(gid, &gr, buf.data(), bufsize, &pgr) == 0 && gr.gr_name)
 390         return wxString(gr.gr_name, wxConvLibc);
 391 #else
 392     if ((pgr = getgrgid(gid)) != NULL)
 393         return wxString(pgr->gr_name, wxConvLibc);
 394 #endif
 395     return _("unknown");
 396 }
 397
 398 #endif  // __UNIX__
 399
 400 // Cache the user and group names since getting them can be expensive,
 401 // get both names and ids at the same time.
 402 //
 403 struct wxTarUser
 404 {
 405     wxTarUser();
 406     ~wxTarUser() { delete [] uname; delete [] gname; }
 407
 408     int uid;
 409     int gid;
 410
 411     wxChar *uname;
 412     wxChar *gname;
 413 };
 414
 415 wxTarUser::wxTarUser()
 416 {
 417 #ifdef __UNIX__
 418     uid = getuid();
 419     gid = getgid();
 420     wxString usr = wxTarUserName(uid);
 421     wxString grp = wxTarGroupName(gid);
 422 #else
 423     uid = 0;
 424     gid = 0;
 425     wxString usr = wxGetUserId();
 426     wxString grp = _("unknown");
 427 #endif
 428
 429     uname = new wxChar[usr.length() + 1];
 430     wxStrcpy(uname, usr.c_str());
 431
 432     gname = new wxChar[grp.length() + 1];
 433     wxStrcpy(gname, grp.c_str());
 434 }
 435
 436 static const wxTarUser& wxGetTarUser()
 437 {
 438 #if wxUSE_THREADS
 439     static wxCriticalSection cs;
 440     wxCriticalSectionLocker lock(cs);
 441 #endif
 442     static wxTarUser tu;
 443     return tu;
 444 }
 445
 446 // ignore the size field for entry types 3, 4, 5 and 6
 447 //
 448 static inline wxFileOffset GetDataSize(const wxTarEntry& entry)
 449 {
 450     switch (entry.GetTypeFlag()) {
 451         case wxTAR_CHRTYPE:
 452         case wxTAR_BLKTYPE:
 453         case wxTAR_DIRTYPE:
 454         case wxTAR_FIFOTYPE:
 455             return 0;
 456         default:
 457             return entry.GetSize();
 458     }
 459 }
 460
 461
 462 /////////////////////////////////////////////////////////////////////////////
 463 // Tar Entry
 464 // Holds all the meta-data for a file in the tar
 465
 466 wxTarEntry::wxTarEntry(const wxString& name /*=wxEmptyString*/,
 467                        const wxDateTime& dt /*=wxDateTime::Now()*/,
 468                        wxFileOffset size    /*=0*/)
 469   : m_Mode(0644),
 470     m_IsModeSet(false),
 471     m_UserId(wxGetTarUser().uid),
 472     m_GroupId(wxGetTarUser().gid),
 473     m_Size(size),
 474     m_Offset(wxInvalidOffset),
 475     m_ModifyTime(dt),
 476     m_TypeFlag(wxTAR_REGTYPE),
 477     m_UserName(wxGetTarUser().uname),
 478     m_GroupName(wxGetTarUser().gname),
 479     m_DevMajor(~0),
 480     m_DevMinor(~0)
 481 {
 482     if (!name.empty())
 483         SetName(name);
 484 }
 485
 486 wxTarEntry::~wxTarEntry()
 487 {
 488 }
 489
 490 wxTarEntry::wxTarEntry(const wxTarEntry& e)
 491   : wxArchiveEntry(),
 492     m_Name(e.m_Name),
 493     m_Mode(e.m_Mode),
 494     m_IsModeSet(e.m_IsModeSet),
 495     m_UserId(e.m_UserId),
 496     m_GroupId(e.m_GroupId),
 497     m_Size(e.m_Size),
 498     m_Offset(e.m_Offset),
 499     m_ModifyTime(e.m_ModifyTime),
 500     m_AccessTime(e.m_AccessTime),
 501     m_CreateTime(e.m_CreateTime),
 502     m_TypeFlag(e.m_TypeFlag),
 503     m_LinkName(e.m_LinkName),
 504     m_UserName(e.m_UserName),
 505     m_GroupName(e.m_GroupName),
 506     m_DevMajor(e.m_DevMajor),
 507     m_DevMinor(e.m_DevMinor)
 508 {
 509 }
 510
 511 wxTarEntry& wxTarEntry::operator=(const wxTarEntry& e)
 512 {
 513     if (&e != this) {
 514         m_Name = e.m_Name;
 515         m_Mode = e.m_Mode;
 516         m_IsModeSet = e.m_IsModeSet;
 517         m_UserId = e.m_UserId;
 518         m_GroupId = e.m_GroupId;
 519         m_Size = e.m_Size;
 520         m_Offset = e.m_Offset;
 521         m_ModifyTime = e.m_ModifyTime;
 522         m_AccessTime = e.m_AccessTime;
 523         m_CreateTime = e.m_CreateTime;
 524         m_TypeFlag = e.m_TypeFlag;
 525         m_LinkName = e.m_LinkName;
 526         m_UserName = e.m_UserName;
 527         m_GroupName = e.m_GroupName;
 528         m_DevMajor = e.m_DevMajor;
 529         m_DevMinor = e.m_DevMinor;
 530     }
 531     return *this;
 532 }
 533
 534 wxString wxTarEntry::GetName(wxPathFormat format /*=wxPATH_NATIVE*/) const
 535 {
 536     bool isDir = IsDir() && !m_Name.empty();
 537
 538     // optimisations for common (and easy) cases
 539     switch (wxFileName::GetFormat(format)) {
 540         case wxPATH_DOS:
 541         {
 542             wxString name(isDir ? m_Name + _T("\\") : m_Name);
 543             for (size_t i = 0; i < name.length(); i++)
 544                 if (name[i] == _T('/'))
 545                     name[i] = _T('\\');
 546             return name;
 547         }
 548
 549         case wxPATH_UNIX:
 550             return isDir ? m_Name + _T("/") : m_Name;
 551
 552         default:
 553             ;
 554     }
 555
 556     wxFileName fn;
 557
 558     if (isDir)
 559         fn.AssignDir(m_Name, wxPATH_UNIX);
 560     else
 561         fn.Assign(m_Name, wxPATH_UNIX);
 562
 563     return fn.GetFullPath(format);
 564 }
 565
 566 void wxTarEntry::SetName(const wxString& name, wxPathFormat format)
 567 {
 568     bool isDir;
 569     m_Name = GetInternalName(name, format, &isDir);
 570     SetIsDir(isDir);
 571 }
 572
 573 // Static - Internally tars and zips use forward slashes for the path
 574 // separator, absolute paths aren't allowed, and directory names have a
 575 // trailing slash.  This function converts a path into this internal format,
 576 // but without a trailing slash for a directory.
 577 //
 578 wxString wxTarEntry::GetInternalName(const wxString& name,
 579                                      wxPathFormat format /*=wxPATH_NATIVE*/,
 580                                      bool *pIsDir        /*=NULL*/)
 581 {
 582     wxString internal;
 583
 584     if (wxFileName::GetFormat(format) != wxPATH_UNIX)
 585         internal = wxFileName(name, format).GetFullPath(wxPATH_UNIX);
 586     else
 587         internal = name;
 588
 589     bool isDir = !internal.empty() && internal.Last() == '/';
 590     if (pIsDir)
 591         *pIsDir = isDir;
 592     if (isDir)
 593         internal.erase(internal.length() - 1);
 594
 595     while (!internal.empty() && *internal.begin() == '/')
 596         internal.erase(0, 1);
 597     while (!internal.empty() && internal.compare(0, 2, _T("./")) == 0)
 598         internal.erase(0, 2);
 599     if (internal == _T(".") || internal == _T(".."))
 600         internal = wxEmptyString;
 601
 602     return internal;
 603 }
 604
 605 bool wxTarEntry::IsDir() const
 606 {
 607     return m_TypeFlag == wxTAR_DIRTYPE;
 608 }
 609
 610 void wxTarEntry::SetIsDir(bool isDir)
 611 {
 612     if (isDir)
 613         m_TypeFlag = wxTAR_DIRTYPE;
 614     else if (m_TypeFlag == wxTAR_DIRTYPE)
 615         m_TypeFlag = wxTAR_REGTYPE;
 616 }
 617
 618 void wxTarEntry::SetIsReadOnly(bool isReadOnly)
 619 {
 620     if (isReadOnly)
 621         m_Mode &= ~0222;
 622     else
 623         m_Mode |= 0200;
 624 }
 625
 626 int wxTarEntry::GetMode() const
 627 {
 628     if (m_IsModeSet || !IsDir())
 629         return m_Mode;
 630     else
 631         return m_Mode | 0111;
 632
 633 }
 634
 635 void wxTarEntry::SetMode(int mode)
 636 {
 637     m_Mode = mode & 07777;
 638     m_IsModeSet = true;
 639 }
 640
 641
 642 /////////////////////////////////////////////////////////////////////////////
 643 // Input stream
 644
 645 wxDECLARE_SCOPED_PTR(wxTarEntry, wxTarEntryPtr_)
 646 wxDEFINE_SCOPED_PTR (wxTarEntry, wxTarEntryPtr_)
 647
 648 wxTarInputStream::wxTarInputStream(wxInputStream& stream,
 649                                    wxMBConv& conv /*=wxConvLocal*/)
 650  :  wxArchiveInputStream(stream, conv)
 651 {
 652     Init();
 653 }
 654
 655 wxTarInputStream::wxTarInputStream(wxInputStream *stream,
 656                                    wxMBConv& conv /*=wxConvLocal*/)
 657  :  wxArchiveInputStream(stream, conv)
 658 {
 659     Init();
 660 }
 661
 662 void wxTarInputStream::Init()
 663 {
 664     m_pos = wxInvalidOffset;
 665     m_offset = 0;
 666     m_size = wxInvalidOffset;
 667     m_sumType = SUM_UNKNOWN;
 668     m_tarType = TYPE_USTAR;
 669     m_hdr = new wxTarHeaderBlock;
 670     m_HeaderRecs = NULL;
 671     m_GlobalHeaderRecs = NULL;
 672     m_lasterror = m_parent_i_stream->GetLastError();
 673 }
 674
 675 wxTarInputStream::~wxTarInputStream()
 676 {
 677     delete m_hdr;
 678     delete m_HeaderRecs;
 679     delete m_GlobalHeaderRecs;
 680 }
 681
 682 wxTarEntry *wxTarInputStream::GetNextEntry()
 683 {
 684     m_lasterror = ReadHeaders();
 685
 686     if (!IsOk())
 687         return NULL;
 688
 689     wxTarEntryPtr_ entry(new wxTarEntry);
 690
 691     entry->SetMode(GetHeaderNumber(TAR_MODE));
 692     entry->SetUserId(GetHeaderNumber(TAR_UID));
 693     entry->SetGroupId(GetHeaderNumber(TAR_UID));
 694     entry->SetSize(GetHeaderNumber(TAR_SIZE));
 695
 696     entry->SetOffset(m_offset);
 697
 698     entry->SetDateTime(GetHeaderDate(_T("mtime")));
 699     entry->SetAccessTime(GetHeaderDate(_T("atime")));
 700     entry->SetCreateTime(GetHeaderDate(_T("ctime")));
 701
 702     entry->SetTypeFlag(*m_hdr->Get(TAR_TYPEFLAG));
 703     bool isDir = entry->IsDir();
 704
 705     entry->SetLinkName(GetHeaderString(TAR_LINKNAME));
 706
 707     if (m_tarType != TYPE_OLDTAR) {
 708         entry->SetUserName(GetHeaderString(TAR_UNAME));
 709         entry->SetGroupName(GetHeaderString(TAR_GNAME));
 710
 711         entry->SetDevMajor(GetHeaderNumber(TAR_DEVMAJOR));
 712         entry->SetDevMinor(GetHeaderNumber(TAR_DEVMINOR));
 713     }
 714
 715     entry->SetName(GetHeaderPath(), wxPATH_UNIX);
 716     if (isDir)
 717         entry->SetIsDir();
 718
 719     if (m_HeaderRecs)
 720         m_HeaderRecs->clear();
 721
 722     m_size = GetDataSize(*entry);
 723     m_pos = 0;
 724
 725     return entry.release();
 726 }
 727
 728 bool wxTarInputStream::OpenEntry(wxTarEntry& entry)
 729 {
 730     wxFileOffset offset = entry.GetOffset();
 731
 732     if (GetLastError() != wxSTREAM_READ_ERROR
 733             && m_parent_i_stream->IsSeekable()
 734             && m_parent_i_stream->SeekI(offset) == offset)
 735     {
 736         m_offset = offset;
 737         m_size = GetDataSize(entry);
 738         m_pos = 0;
 739         m_lasterror = wxSTREAM_NO_ERROR;
 740         return true;
 741     } else {
 742         m_lasterror = wxSTREAM_READ_ERROR;
 743         return false;
 744     }
 745 }
 746
 747 bool wxTarInputStream::OpenEntry(wxArchiveEntry& entry)
 748 {
 749     wxTarEntry *tarEntry = wxStaticCast(&entry, wxTarEntry);
 750     return tarEntry ? OpenEntry(*tarEntry) : false;
 751 }
 752
 753 bool wxTarInputStream::CloseEntry()
 754 {
 755     if (m_lasterror == wxSTREAM_READ_ERROR)
 756         return false;
 757     if (!IsOpened())
 758         return true;
 759
 760     wxFileOffset size = RoundUpSize(m_size);
 761     wxFileOffset remainder = size - m_pos;
 762
 763     if (remainder && m_parent_i_stream->IsSeekable()) {
 764         wxLogNull nolog;
 765         if (m_parent_i_stream->SeekI(remainder, wxFromCurrent)
 766                 != wxInvalidOffset)
 767             remainder = 0;
 768     }
 769
 770     if (remainder) {
 771         const int BUFSIZE = 8192;
 772         wxCharBuffer buf(BUFSIZE);
 773
 774         while (remainder > 0 && m_parent_i_stream->IsOk())
 775             remainder -= m_parent_i_stream->Read(
 776                     buf.data(), wxMin(BUFSIZE, remainder)).LastRead();
 777     }
 778
 779     m_pos = wxInvalidOffset;
 780     m_offset += size;
 781     m_lasterror = m_parent_i_stream->GetLastError();
 782
 783     return IsOk();
 784 }
 785
 786 wxStreamError wxTarInputStream::ReadHeaders()
 787 {
 788     if (!CloseEntry())
 789         return wxSTREAM_READ_ERROR;
 790
 791     bool done = false;
 792
 793     while (!done) {
 794         m_hdr->Read(*m_parent_i_stream);
 795         if (m_parent_i_stream->Eof())
 796             wxLogError(_("incomplete header block in tar"));
 797         if (!*m_parent_i_stream)
 798             return wxSTREAM_READ_ERROR;
 799         m_offset += TAR_BLOCKSIZE;
 800
 801         // an all-zero header marks the end of the tar
 802         if (m_hdr->IsAllZeros())
 803             return wxSTREAM_EOF;
 804
 805         // the checksum is supposed to be the unsigned sum of the header bytes,
 806         // but there have been versions of tar that used the signed sum, so
 807         // accept that too, but only if used throughout.
 808         wxUint32 chksum = m_hdr->GetOctal(TAR_CHKSUM);
 809         bool ok = false;
 810
 811         if (m_sumType != SUM_SIGNED) {
 812             ok = chksum == m_hdr->Sum();
 813             if (m_sumType == SUM_UNKNOWN)
 814                 m_sumType = ok ? SUM_UNSIGNED : SUM_SIGNED;
 815         }
 816         if (m_sumType == SUM_SIGNED)
 817             ok = chksum == m_hdr->Sum(true);
 818         if (!ok) {
 819             wxLogError(_("checksum failure reading tar header block"));
 820             return wxSTREAM_READ_ERROR;
 821         }
 822
 823         if (strcmp(m_hdr->Get(TAR_MAGIC), USTAR_MAGIC) == 0)
 824             m_tarType = TYPE_USTAR;
 825         else if (strcmp(m_hdr->Get(TAR_MAGIC), GNU_MAGIC) == 0 &&
 826                  strcmp(m_hdr->Get(TAR_VERSION), GNU_VERION) == 0)
 827             m_tarType = TYPE_GNUTAR;
 828         else
 829             m_tarType = TYPE_OLDTAR;
 830
 831         if (m_tarType != TYPE_USTAR)
 832             break;
 833
 834         switch (*m_hdr->Get(TAR_TYPEFLAG)) {
 835             case 'g': ReadExtendedHeader(m_GlobalHeaderRecs); break;
 836             case 'x': ReadExtendedHeader(m_HeaderRecs); break;
 837             default:  done = true;
 838         }
 839     }
 840
 841     return wxSTREAM_NO_ERROR;
 842 }
 843
 844 wxString wxTarInputStream::GetExtendedHeader(const wxString& key) const
 845 {
 846     wxTarHeaderRecords::iterator it;
 847
 848     // look at normal extended header records first
 849     if (m_HeaderRecs) {
 850         it = m_HeaderRecs->find(key);
 851         if (it != m_HeaderRecs->end())
 852             return wxString(it->second.wc_str(wxConvUTF8), GetConv());
 853     }
 854
 855     // if not found, look at the global header records
 856     if (m_GlobalHeaderRecs) {
 857         it = m_GlobalHeaderRecs->find(key);
 858         if (it != m_GlobalHeaderRecs->end())
 859             return wxString(it->second.wc_str(wxConvUTF8), GetConv());
 860     }
 861
 862     return wxEmptyString;
 863 }
 864
 865 wxString wxTarInputStream::GetHeaderPath() const
 866 {
 867     wxString path;
 868
 869     if ((path = GetExtendedHeader(_T("path"))) != wxEmptyString)
 870         return path;
 871
 872     path = wxString(m_hdr->Get(TAR_NAME), GetConv());
 873     if (m_tarType != TYPE_USTAR)
 874         return path;
 875
 876     const char *prefix = m_hdr->Get(TAR_PREFIX);
 877     return *prefix ? wxString(prefix, GetConv()) + _T("/") + path : path;
 878 }
 879
 880 wxDateTime wxTarInputStream::GetHeaderDate(const wxString& key) const
 881 {
 882     wxString value;
 883
 884     // try extended header, stored as decimal seconds since the epoch
 885     if ((value = GetExtendedHeader(key)) != wxEmptyString) {
 886         wxLongLong ll;
 887         ll.Assign(wxAtof(value) * 1000.0);
 888         return ll;
 889     }
 890
 891     if (key == _T("mtime"))
 892         return wxLongLong(m_hdr->GetOctal(TAR_MTIME)) * 1000L;
 893
 894     return wxDateTime();
 895 }
 896
 897 wxTarNumber wxTarInputStream::GetHeaderNumber(int id) const
 898 {
 899     wxString value;
 900
 901     if ((value = GetExtendedHeader(m_hdr->Name(id))) != wxEmptyString) {
 902         wxTarNumber n = 0;
 903         wxString::const_iterator p = value.begin();
 904         while (*p == ' ' && p != value.end())
 905             p++;
 906         while (isdigit(*p))
 907             n = n * 10 + (*p++ - '0');
 908         return n;
 909     } else {
 910         return m_hdr->GetOctal(id);
 911     }
 912 }
 913
 914 wxString wxTarInputStream::GetHeaderString(int id) const
 915 {
 916     wxString value;
 917
 918     if ((value = GetExtendedHeader(m_hdr->Name(id))) != wxEmptyString)
 919         return value;
 920
 921     return wxString(m_hdr->Get(id), GetConv());
 922 }
 923
 924 // An extended header consists of one or more records, each constructed:
 925 // "%d %s=%s\n", <length>, <keyword>, <value>
 926 // <length> is the byte length, <keyword> and <value> are UTF-8
 927
 928 bool wxTarInputStream::ReadExtendedHeader(wxTarHeaderRecords*& recs)
 929 {
 930     if (!recs)
 931         recs = new wxTarHeaderRecords;
 932
 933     // round length up to a whole number of blocks
 934     size_t len = m_hdr->GetOctal(TAR_SIZE);
 935     size_t size = RoundUpSize(len);
 936
 937     // read in the whole header since it should be small
 938     wxCharBuffer buf(size);
 939     size_t lastread = m_parent_i_stream->Read(buf.data(), size).LastRead();
 940     if (lastread < len)
 941         len = lastread;
 942     buf.data()[len] = 0;
 943     m_offset += lastread;
 944
 945     size_t recPos, recSize;
 946     bool ok = true;
 947
 948     for (recPos = 0; recPos < len && ok; recPos += recSize) {
 949         char *pRec = buf.data() + recPos;
 950         char *p = pRec;
 951
 952         // read the record size (byte count in ascii decimal)
 953         recSize = 0;
 954         while (isdigit((unsigned char) *p))
 955             recSize = recSize * 10 + *p++ - '0';
 956
 957         // validity checks
 958         if (recPos + recSize > len)
 959             break;
 960         if (recSize < p - pRec + (size_t)3 || *p != ' '
 961                 || pRec[recSize - 1] != '\012') {
 962             ok = false;
 963             continue;
 964         }
 965
 966         // replace the final '\n' with a nul, to terminate value
 967         pRec[recSize - 1] = 0;
 968         // the key is here, following the space
 969         char *pKey = ++p;
 970
 971         // look forward for the '=', the value follows
 972         while (*p && *p != '=')
 973             p++;
 974         if (!*p) {
 975             ok = false;
 976             continue;
 977         }
 978         // replace the '=' with a nul, to terminate the key
 979         *p++ = 0;
 980
 981         wxString key(wxConvUTF8.cMB2WC(pKey), GetConv());
 982         wxString value(wxConvUTF8.cMB2WC(p), GetConv());
 983
 984         // an empty value unsets a previously given value
 985         if (value.empty())
 986             recs->erase(key);
 987         else
 988             (*recs)[key] = value;
 989     }
 990
 991     if (!ok || recPos < len || size != lastread) {
 992         wxLogWarning(_("invalid data in extended tar header"));
 993         return false;
 994     }
 995
 996     return true;
 997 }
 998
 999 wxFileOffset wxTarInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
1000 {
1001     if (!IsOpened()) {
1002         wxLogError(_("tar entry not open"));
1003         m_lasterror = wxSTREAM_READ_ERROR;
1004     }
1005     if (!IsOk())
1006         return wxInvalidOffset;
1007
1008     switch (mode) {
1009         case wxFromStart:   break;
1010         case wxFromCurrent: pos += m_pos; break;
1011         case wxFromEnd:     pos += m_size; break;
1012     }
1013
1014     if (pos < 0 || m_parent_i_stream->SeekI(m_offset + pos) == wxInvalidOffset)
1015         return wxInvalidOffset;
1016
1017     m_pos = pos;
1018     return m_pos;
1019 }
1020
1021 size_t wxTarInputStream::OnSysRead(void *buffer, size_t size)
1022 {
1023     if (!IsOpened()) {
1024         wxLogError(_("tar entry not open"));
1025         m_lasterror = wxSTREAM_READ_ERROR;
1026     }
1027     if (!IsOk() || !size)
1028         return 0;
1029
1030     if (m_pos >= m_size)
1031         size = 0;
1032     else if (m_pos + size > m_size + (size_t)0)
1033         size = m_size - m_pos;
1034
1035     size_t lastread = m_parent_i_stream->Read(buffer, size).LastRead();
1036     m_pos += lastread;
1037
1038     if (m_pos >= m_size) {
1039         m_lasterror = wxSTREAM_EOF;
1040     } else if (!m_parent_i_stream->IsOk()) {
1041         // any other error will have been reported by the underlying stream
1042         if (m_parent_i_stream->Eof())
1043             wxLogError(_("unexpected end of file"));
1044         m_lasterror = wxSTREAM_READ_ERROR;
1045     }
1046
1047     return lastread;
1048 }
1049
1050
1051 /////////////////////////////////////////////////////////////////////////////
1052 // Output stream
1053
1054 wxTarOutputStream::wxTarOutputStream(wxOutputStream& stream,
1055                                      wxTarFormat format /*=wxTAR_PAX*/,
1056                                      wxMBConv& conv     /*=wxConvLocal*/)
1057  :  wxArchiveOutputStream(stream, conv)
1058 {
1059     Init(format);
1060 }
1061
1062 wxTarOutputStream::wxTarOutputStream(wxOutputStream *stream,
1063                                      wxTarFormat format /*=wxTAR_PAX*/,
1064                                      wxMBConv& conv     /*=wxConvLocal*/)
1065  :  wxArchiveOutputStream(stream, conv)
1066 {
1067     Init(format);
1068 }
1069
1070 void wxTarOutputStream::Init(wxTarFormat format)
1071 {
1072     m_pos = wxInvalidOffset;
1073     m_maxpos = wxInvalidOffset;
1074     m_size = wxInvalidOffset;
1075     m_headpos = wxInvalidOffset;
1076     m_datapos = wxInvalidOffset;
1077     m_tarstart = wxInvalidOffset;
1078     m_tarsize = 0;
1079     m_pax = format == wxTAR_PAX;
1080     m_BlockingFactor = m_pax ? 10 : 20;
1081     m_chksum = 0;
1082     m_large = false;
1083     m_hdr = new wxTarHeaderBlock;
1084     m_hdr2 = NULL;
1085     m_extendedHdr = NULL;
1086     m_extendedSize = 0;
1087     m_lasterror = m_parent_o_stream->GetLastError();
1088     m_endrecWritten = false;
1089 }
1090
1091 wxTarOutputStream::~wxTarOutputStream()
1092 {
1093     Close();
1094     delete m_hdr;
1095     delete m_hdr2;
1096     delete [] m_extendedHdr;
1097 }
1098
1099 bool wxTarOutputStream::PutNextEntry(wxTarEntry *entry)
1100 {
1101     wxTarEntryPtr_ e(entry);
1102
1103     if (!CloseEntry())
1104         return false;
1105
1106     if (!m_tarsize) {
1107         wxLogNull nolog;
1108         m_tarstart = m_parent_o_stream->TellO();
1109     }
1110
1111     if (m_tarstart != wxInvalidOffset)
1112         m_headpos = m_tarstart + m_tarsize;
1113
1114     if (WriteHeaders(*e)) {
1115         m_pos = 0;
1116         m_maxpos = 0;
1117         m_size = GetDataSize(*e);
1118         if (m_tarstart != wxInvalidOffset)
1119             m_datapos = m_tarstart + m_tarsize;
1120
1121         // types that are not allowd any data
1122         const char nodata[] = {
1123             wxTAR_LNKTYPE, wxTAR_SYMTYPE, wxTAR_CHRTYPE, wxTAR_BLKTYPE,
1124             wxTAR_DIRTYPE, wxTAR_FIFOTYPE, 0
1125         };
1126         int typeflag = e->GetTypeFlag();
1127
1128         // pax does now allow data for wxTAR_LNKTYPE
1129         if (!m_pax || typeflag != wxTAR_LNKTYPE)
1130             if (strchr(nodata, typeflag) != NULL)
1131                 CloseEntry();
1132     }
1133
1134     return IsOk();
1135 }
1136
1137 bool wxTarOutputStream::PutNextEntry(const wxString& name,
1138                                      const wxDateTime& dt,
1139                                      wxFileOffset size)
1140 {
1141     return PutNextEntry(new wxTarEntry(name, dt, size));
1142 }
1143
1144 bool wxTarOutputStream::PutNextDirEntry(const wxString& name,
1145                                         const wxDateTime& dt)
1146 {
1147     wxTarEntry *entry = new wxTarEntry(name, dt);
1148     entry->SetIsDir();
1149     return PutNextEntry(entry);
1150 }
1151
1152 bool wxTarOutputStream::PutNextEntry(wxArchiveEntry *entry)
1153 {
1154     wxTarEntry *tarEntry = wxStaticCast(entry, wxTarEntry);
1155     if (!tarEntry)
1156         delete entry;
1157     return PutNextEntry(tarEntry);
1158 }
1159
1160 bool wxTarOutputStream::CopyEntry(wxTarEntry *entry,
1161                                   wxTarInputStream& inputStream)
1162 {
1163     if (PutNextEntry(entry))
1164         Write(inputStream);
1165     return IsOk() && inputStream.Eof();
1166 }
1167
1168 bool wxTarOutputStream::CopyEntry(wxArchiveEntry *entry,
1169                                   wxArchiveInputStream& inputStream)
1170 {
1171     if (PutNextEntry(entry))
1172         Write(inputStream);
1173     return IsOk() && inputStream.Eof();
1174 }
1175
1176 bool wxTarOutputStream::CloseEntry()
1177 {
1178     if (!IsOpened())
1179         return true;
1180
1181     if (m_pos < m_maxpos) {
1182         wxASSERT(m_parent_o_stream->IsSeekable());
1183         m_parent_o_stream->SeekO(m_datapos + m_maxpos);
1184         m_lasterror = m_parent_o_stream->GetLastError();
1185         m_pos = m_maxpos;
1186     }
1187
1188     if (IsOk()) {
1189         wxFileOffset size = RoundUpSize(m_pos);
1190         if (size > m_pos) {
1191             memset(m_hdr, 0, size - m_pos);
1192             m_parent_o_stream->Write(m_hdr, size - m_pos);
1193             m_lasterror = m_parent_o_stream->GetLastError();
1194         }
1195         m_tarsize += size;
1196     }
1197
1198     if (IsOk() && m_pos != m_size)
1199         ModifyHeader();
1200
1201     m_pos = wxInvalidOffset;
1202     m_maxpos = wxInvalidOffset;
1203     m_size = wxInvalidOffset;
1204     m_headpos = wxInvalidOffset;
1205     m_datapos = wxInvalidOffset;
1206
1207     return IsOk();
1208 }
1209
1210 bool wxTarOutputStream::Close()
1211 {
1212     if (!CloseEntry() || (m_tarsize == 0 && m_endrecWritten))
1213         return false;
1214
1215     memset(m_hdr, 0, sizeof(*m_hdr));
1216     int count = (RoundUpSize(m_tarsize + 2 * TAR_BLOCKSIZE, m_BlockingFactor)
1217                     - m_tarsize) / TAR_BLOCKSIZE;
1218     while (count--)
1219         m_parent_o_stream->Write(m_hdr, TAR_BLOCKSIZE);
1220
1221     m_tarsize = 0;
1222     m_tarstart = wxInvalidOffset;
1223     m_lasterror = m_parent_o_stream->GetLastError();
1224     m_endrecWritten = true;
1225     return IsOk();
1226 }
1227
1228 bool wxTarOutputStream::WriteHeaders(wxTarEntry& entry)
1229 {
1230     memset(m_hdr, 0, sizeof(*m_hdr));
1231
1232     SetHeaderPath(entry.GetName(wxPATH_UNIX));
1233
1234     SetHeaderNumber(TAR_MODE, entry.GetMode());
1235     SetHeaderNumber(TAR_UID, entry.GetUserId());
1236     SetHeaderNumber(TAR_GID, entry.GetGroupId());
1237
1238     if (entry.GetSize() == wxInvalidOffset)
1239         entry.SetSize(0);
1240     m_large = !SetHeaderNumber(TAR_SIZE, entry.GetSize());
1241
1242     SetHeaderDate(_T("mtime"), entry.GetDateTime());
1243     if (entry.GetAccessTime().IsValid())
1244         SetHeaderDate(_T("atime"), entry.GetAccessTime());
1245     if (entry.GetCreateTime().IsValid())
1246         SetHeaderDate(_T("ctime"), entry.GetCreateTime());
1247
1248     *m_hdr->Get(TAR_TYPEFLAG) = char(entry.GetTypeFlag());
1249
1250     strcpy(m_hdr->Get(TAR_MAGIC), USTAR_MAGIC);
1251     strcpy(m_hdr->Get(TAR_VERSION), USTAR_VERSION);
1252
1253     SetHeaderString(TAR_LINKNAME, entry.GetLinkName());
1254     SetHeaderString(TAR_UNAME, entry.GetUserName());
1255     SetHeaderString(TAR_GNAME, entry.GetGroupName());
1256
1257     if (~entry.GetDevMajor())
1258         SetHeaderNumber(TAR_DEVMAJOR, entry.GetDevMajor());
1259     if (~entry.GetDevMinor())
1260         SetHeaderNumber(TAR_DEVMINOR, entry.GetDevMinor());
1261
1262     m_chksum = m_hdr->Sum();
1263     m_hdr->SetOctal(TAR_CHKSUM, m_chksum);
1264     if (!m_large)
1265         m_chksum -= m_hdr->SumField(TAR_SIZE);
1266
1267     // The main header is now fully prepared so we know what extended headers
1268     // (if any) will be needed. Output any extended headers before writing
1269     // the main header.
1270     if (m_extendedHdr && *m_extendedHdr) {
1271         wxASSERT(m_pax);
1272         // the extended headers are written to the tar as a file entry,
1273         // so prepare a regular header block for the pseudo-file.
1274         if (!m_hdr2)
1275             m_hdr2 = new wxTarHeaderBlock;
1276         memset(m_hdr2, 0, sizeof(*m_hdr2));
1277
1278         // an old tar that doesn't understand extended headers will
1279         // extract it as a file, so give these fields reasonable values
1280         // so that the user will have access to read and remove it.
1281         m_hdr2->SetPath(PaxHeaderPath(_T("%d/PaxHeaders.%p/%f"),
1282                                       entry.GetName(wxPATH_UNIX)), GetConv());
1283         m_hdr2->SetOctal(TAR_MODE, 0600);
1284         strcpy(m_hdr2->Get(TAR_UID), m_hdr->Get(TAR_UID));
1285         strcpy(m_hdr2->Get(TAR_GID), m_hdr->Get(TAR_GID));
1286         size_t length = strlen(m_extendedHdr);
1287         m_hdr2->SetOctal(TAR_SIZE, length);
1288         strcpy(m_hdr2->Get(TAR_MTIME), m_hdr->Get(TAR_MTIME));
1289         *m_hdr2->Get(TAR_TYPEFLAG) = 'x';
1290         strcpy(m_hdr2->Get(TAR_MAGIC), USTAR_MAGIC);
1291         strcpy(m_hdr2->Get(TAR_VERSION), USTAR_VERSION);
1292         strcpy(m_hdr2->Get(TAR_UNAME), m_hdr->Get(TAR_UNAME));
1293         strcpy(m_hdr2->Get(TAR_GNAME), m_hdr->Get(TAR_GNAME));
1294
1295         m_hdr2->SetOctal(TAR_CHKSUM, m_hdr2->Sum());
1296
1297         m_hdr2->Write(*m_parent_o_stream);
1298         m_tarsize += TAR_BLOCKSIZE;
1299
1300         size_t rounded = RoundUpSize(length);
1301         memset(m_extendedHdr + length, 0, rounded - length);
1302         m_parent_o_stream->Write(m_extendedHdr, rounded);
1303         m_tarsize += rounded;
1304
1305         *m_extendedHdr = 0;
1306     }
1307
1308     // if don't have extended headers just report error
1309     if (!m_badfit.empty()) {
1310         wxASSERT(!m_pax);
1311         wxLogWarning(_("%s did not fit the tar header for entry '%s'"),
1312                      m_badfit.c_str(), entry.GetName().c_str());
1313         m_badfit.clear();
1314     }
1315
1316     m_hdr->Write(*m_parent_o_stream);
1317     m_tarsize += TAR_BLOCKSIZE;
1318     m_lasterror = m_parent_o_stream->GetLastError();
1319
1320     return IsOk();
1321 }
1322
1323 wxString wxTarOutputStream::PaxHeaderPath(const wxString& format,
1324                                           const wxString& path)
1325 {
1326     wxString d = path.BeforeLast(_T('/'));
1327     wxString f = path.AfterLast(_T('/'));
1328     wxString ret;
1329
1330     if (d.empty())
1331         d = _T(".");
1332
1333     ret.reserve(format.length() + path.length() + 16);
1334
1335     size_t begin = 0;
1336     size_t end;
1337
1338     for (;;) {
1339         end = format.find('%', begin);
1340         if (end == wxString::npos || end + 1 >= format.length())
1341             break;
1342         ret << format.substr(begin, end - begin);
1343         switch ( format[end + 1].GetValue() ) {
1344             case 'd': ret << d; break;
1345             case 'f': ret << f; break;
1346             case 'p': ret << wxGetProcessId(); break;
1347             case '%': ret << _T("%"); break;
1348         }
1349         begin = end + 2;
1350     }
1351
1352     ret << format.substr(begin);
1353
1354     return ret;
1355 }
1356
1357 bool wxTarOutputStream::ModifyHeader()
1358 {
1359     wxFileOffset originalPos = wxInvalidOffset;
1360     wxFileOffset sizePos = wxInvalidOffset;
1361
1362     if (!m_large && m_headpos != wxInvalidOffset
1363             && m_parent_o_stream->IsSeekable())
1364     {
1365         wxLogNull nolog;
1366         originalPos = m_parent_o_stream->TellO();
1367         if (originalPos != wxInvalidOffset)
1368             sizePos =
1369                 m_parent_o_stream->SeekO(m_headpos + m_hdr->Offset(TAR_SIZE));
1370     }
1371
1372     if (sizePos == wxInvalidOffset || !m_hdr->SetOctal(TAR_SIZE, m_pos)) {
1373         wxLogError(_("incorrect size given for tar entry"));
1374         m_lasterror = wxSTREAM_WRITE_ERROR;
1375         return false;
1376     }
1377
1378     m_chksum += m_hdr->SumField(TAR_SIZE);
1379     m_hdr->SetOctal(TAR_CHKSUM, m_chksum);
1380     wxFileOffset sumPos = m_headpos + m_hdr->Offset(TAR_CHKSUM);
1381
1382     return
1383         m_hdr->WriteField(*m_parent_o_stream, TAR_SIZE) &&
1384         m_parent_o_stream->SeekO(sumPos) == sumPos &&
1385         m_hdr->WriteField(*m_parent_o_stream, TAR_CHKSUM) &&
1386         m_parent_o_stream->SeekO(originalPos) == originalPos;
1387 }
1388
1389 void wxTarOutputStream::SetHeaderPath(const wxString& name)
1390 {
1391     if (!m_hdr->SetPath(name, GetConv()) || (m_pax && !name.IsAscii()))
1392         SetExtendedHeader(_T("path"), name);
1393 }
1394
1395 bool wxTarOutputStream::SetHeaderNumber(int id, wxTarNumber n)
1396 {
1397     if (m_hdr->SetOctal(id, n)) {
1398         return true;
1399     } else {
1400         SetExtendedHeader(m_hdr->Name(id), wxLongLong(n).ToString());
1401         return false;
1402     }
1403 }
1404
1405 void wxTarOutputStream::SetHeaderString(int id, const wxString& str)
1406 {
1407     strncpy(m_hdr->Get(id), str.mb_str(GetConv()), m_hdr->Len(id));
1408     if (str.length() > m_hdr->Len(id))
1409         SetExtendedHeader(m_hdr->Name(id), str);
1410 }
1411
1412 void wxTarOutputStream::SetHeaderDate(const wxString& key,
1413                                       const wxDateTime& datetime)
1414 {
1415     wxLongLong ll = datetime.IsValid() ? datetime.GetValue() : wxLongLong(0);
1416     wxLongLong secs = ll / 1000L;
1417
1418     if (key != _T("mtime")
1419         || !m_hdr->SetOctal(TAR_MTIME, wxTarNumber(secs.GetValue()))
1420         || secs <= 0 || secs >= 0x7fffffff)
1421     {
1422         wxString str;
1423         if (ll >= LONG_MIN && ll <= LONG_MAX) {
1424             str.Printf(_T("%g"), ll.ToLong() / 1000.0);
1425         } else {
1426             str = ll.ToString();
1427             str.insert(str.end() - 3, '.');
1428         }
1429         SetExtendedHeader(key, str);
1430     }
1431 }
1432
1433 void wxTarOutputStream::SetExtendedHeader(const wxString& key,
1434                                           const wxString& value)
1435 {
1436     if (m_pax) {
1437 #if wxUSE_UNICODE
1438         const wxCharBuffer utf_key = key.utf8_str();
1439         const wxCharBuffer utf_value = value.utf8_str();
1440 #else
1441         const wxWX2WCbuf wide_key = key.wc_str(GetConv());
1442         const wxCharBuffer utf_key = wxConvUTF8.cWC2MB(wide_key);
1443
1444         const wxWX2WCbuf wide_value = value.wc_str(GetConv());
1445         const wxCharBuffer utf_value = wxConvUTF8.cWC2MB(wide_value);
1446 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1447
1448         // a small buffer to format the length field in
1449         char buf[32];
1450         // length of "99<space><key>=<value>\n"
1451         unsigned long length = strlen(utf_value) + strlen(utf_key) + 5;
1452         sprintf(buf, "%lu", length);
1453         // the length includes itself
1454         size_t lenlen = strlen(buf);
1455         if (lenlen != 2) {
1456             length += lenlen - 2;
1457             sprintf(buf, "%lu", length);
1458             if (strlen(buf) > lenlen)
1459                 sprintf(buf, "%lu", ++length);
1460         }
1461
1462         // reallocate m_extendedHdr if it's not big enough
1463         if (m_extendedSize < length) {
1464             size_t rounded = RoundUpSize(length);
1465             m_extendedSize <<= 1;
1466             if (rounded > m_extendedSize)
1467                 m_extendedSize = rounded;
1468             char *oldHdr = m_extendedHdr;
1469             m_extendedHdr = new char[m_extendedSize];
1470             if (oldHdr) {
1471                 strcpy(m_extendedHdr, oldHdr);
1472                 delete oldHdr;
1473             } else {
1474                 *m_extendedHdr = 0;
1475             }
1476         }
1477
1478         // append the new record
1479         char *append = strchr(m_extendedHdr, 0);
1480         sprintf(append, "%s %s=%s\012", buf,
1481                 (const char*)utf_key, (const char*)utf_value);
1482     }
1483     else {
1484         // if not pax then make a list of fields to report as errors
1485         if (!m_badfit.empty())
1486             m_badfit += _T(", ");
1487         m_badfit += key;
1488     }
1489 }
1490
1491 void wxTarOutputStream::Sync()
1492 {
1493     m_parent_o_stream->Sync();
1494 }
1495
1496 wxFileOffset wxTarOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
1497 {
1498     if (!IsOpened()) {
1499         wxLogError(_("tar entry not open"));
1500         m_lasterror = wxSTREAM_WRITE_ERROR;
1501     }
1502     if (!IsOk() || m_datapos == wxInvalidOffset)
1503         return wxInvalidOffset;
1504
1505     switch (mode) {
1506         case wxFromStart:   break;
1507         case wxFromCurrent: pos += m_pos; break;
1508         case wxFromEnd:     pos += m_maxpos; break;
1509     }
1510
1511     if (pos < 0 || m_parent_o_stream->SeekO(m_datapos + pos) == wxInvalidOffset)
1512         return wxInvalidOffset;
1513
1514     m_pos = pos;
1515     return m_pos;
1516 }
1517
1518 size_t wxTarOutputStream::OnSysWrite(const void *buffer, size_t size)
1519 {
1520     if (!IsOpened()) {
1521         wxLogError(_("tar entry not open"));
1522         m_lasterror = wxSTREAM_WRITE_ERROR;
1523     }
1524     if (!IsOk() || !size)
1525         return 0;
1526
1527     size_t lastwrite = m_parent_o_stream->Write(buffer, size).LastWrite();
1528     m_pos += lastwrite;
1529     if (m_pos > m_maxpos)
1530         m_maxpos = m_pos;
1531
1532     if (lastwrite != size)
1533         m_lasterror = wxSTREAM_WRITE_ERROR;
1534
1535     return lastwrite;
1536 }
1537
1538 #endif // wxUSE_TARSTREAM