seven-zip 1.4.0

data/ext/p7zip/CPP/7zip/Archive/Tar/TarIn.cpp

@@ -0,0 +1,207 @@
+// TarIn.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "Common/StringToInt.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "TarIn.h"
+
+namespace NArchive {
+namespace NTar {
+ 
+static void MyStrNCpy(char *dest, const char *src, int size)
+{
+  for (int i = 0; i < size; i++)
+  {
+    char c = src[i];
+    dest[i] = c;
+    if (c == 0)
+      break;
+  }
+}
+
+static bool OctalToNumber(const char *srcString, int size, UInt64 &res)
+{
+  char sz[32];
+  MyStrNCpy(sz, srcString, size);
+  sz[size] = 0;
+  const char *end;
+  int i;
+  for (i = 0; sz[i] == ' '; i++);
+  res = ConvertOctStringToUInt64(sz + i, &end);
+  return (*end == ' ' || *end == 0);
+}
+
+static bool OctalToNumber32(const char *srcString, int size, UInt32 &res)
+{
+  UInt64 res64;
+  if (!OctalToNumber(srcString, size, res64))
+    return false;
+  res = (UInt32)res64;
+  return (res64 <= 0xFFFFFFFF);
+}
+
+#define RIF(x) { if (!(x)) return S_FALSE; }
+
+static bool IsRecordLast(const char *buf)
+{
+  for (int i = 0; i < NFileHeader::kRecordSize; i++)
+    if (buf[i] != 0)
+      return false;
+  return true;
+}
+
+static void ReadString(const char *s, int size, AString &result)
+{
+  char temp[NFileHeader::kRecordSize + 1];
+  MyStrNCpy(temp, s, size);
+  temp[size] = '\0';
+  result = temp;
+}
+
+static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemEx &item, AString &error)
+{
+  char buf[NFileHeader::kRecordSize];
+  char *p = buf;
+
+  error.Empty();
+  filled = false;
+
+  bool thereAreEmptyRecords = false;
+  for (;;)
+  {
+    size_t processedSize = NFileHeader::kRecordSize;
+    RINOK(ReadStream(stream, buf, &processedSize));
+    if (processedSize == 0)
+    {
+      if (!thereAreEmptyRecords )
+        error = "There are no trailing zero-filled records";
+      return S_OK;
+    }
+    if (processedSize != NFileHeader::kRecordSize)
+    {
+      error = "There is no correct record at the end of archive";
+      return S_OK;
+    }
+    item.HeaderSize += NFileHeader::kRecordSize;
+    if (!IsRecordLast(buf))
+      break;
+    thereAreEmptyRecords = true;
+  }
+  if (thereAreEmptyRecords)
+  {
+    error = "There are data after end of archive";
+    return S_OK;
+  }
+  
+  ReadString(p, NFileHeader::kNameSize, item.Name); p += NFileHeader::kNameSize;
+
+  RIF(OctalToNumber32(p, 8, item.Mode)); p += 8;
+
+  if (!OctalToNumber32(p, 8, item.UID)) item.UID = 0; p += 8;
+  if (!OctalToNumber32(p, 8, item.GID)) item.GID = 0; p += 8;
+
+  if (GetBe32(p) == (UInt32)1 << 31)
+  {
+    // GNU extension
+    item.Size = GetBe64(p + 4);
+  }
+  else
+  {
+    RIF(OctalToNumber(p, 12, item.Size));
+  }
+  p += 12;
+  RIF(OctalToNumber32(p, 12, item.MTime)); p += 12;
+  
+  UInt32 checkSum;
+  RIF(OctalToNumber32(p, 8, checkSum));
+  memcpy(p, NFileHeader::kCheckSumBlanks, 8); p += 8;
+
+  item.LinkFlag = *p++;
+
+  ReadString(p, NFileHeader::kNameSize, item.LinkName); p += NFileHeader::kNameSize;
+
+  memcpy(item.Magic, p, 8); p += 8;
+
+  ReadString(p, NFileHeader::kUserNameSize, item.User); p += NFileHeader::kUserNameSize;
+  ReadString(p, NFileHeader::kGroupNameSize, item.Group); p += NFileHeader::kGroupNameSize;
+
+  item.DeviceMajorDefined = (p[0] != 0); RIF(OctalToNumber32(p, 8, item.DeviceMajor)); p += 8;
+  item.DeviceMinorDefined = (p[0] != 0); RIF(OctalToNumber32(p, 8, item.DeviceMinor)); p += 8;
+
+  AString prefix;
+  ReadString(p, NFileHeader::kPrefixSize, prefix);
+  p += NFileHeader::kPrefixSize;
+  if (!prefix.IsEmpty() && item.IsMagic() &&
+      (item.LinkFlag != 'L' /* || prefix != "00000000000" */ ))
+    item.Name = prefix + AString('/') + item.Name;
+
+  if (item.LinkFlag == NFileHeader::NLinkFlag::kLink)
+    item.Size = 0;
+ 
+  UInt32 checkSumReal = 0;
+  for (int i = 0; i < NFileHeader::kRecordSize; i++)
+    checkSumReal += (Byte)buf[i];
+  
+  if (checkSumReal != checkSum)
+    return S_FALSE;
+
+  filled = true;
+  return S_OK;
+}
+
+HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &item, AString &error)
+{
+  item.HeaderSize = 0;
+  bool flagL = false;
+  bool flagK = false;
+  AString nameL;
+  AString nameK;
+  for (;;)
+  {
+    RINOK(GetNextItemReal(stream, filled, item, error));
+    if (!filled)
+      return S_OK;
+    if (item.LinkFlag == 'L' || // NEXT file has a long name
+        item.LinkFlag == 'K') // NEXT file has a long linkname
+    {
+      AString *name;
+      if (item.LinkFlag == 'L')
+        { if (flagL) return S_FALSE; flagL = true; name = &nameL; }
+      else
+        { if (flagK) return S_FALSE; flagK = true; name = &nameK; }
+
+      if (item.Name.Compare(NFileHeader::kLongLink) != 0 &&
+          item.Name.Compare(NFileHeader::kLongLink2) != 0)
+        return S_FALSE;
+      if (item.Size > (1 << 14))
+        return S_FALSE;
+      int packSize = (int)item.GetPackSize();
+      char *buf = name->GetBuffer(packSize);
+      RINOK(ReadStream_FALSE(stream, buf, packSize));
+      item.HeaderSize += packSize;
+      buf[(size_t)item.Size] = '\0';
+      name->ReleaseBuffer();
+      continue;
+    }
+    if (item.LinkFlag == 'g' || item.LinkFlag == 'x' || item.LinkFlag == 'X')
+    {
+      // pax Extended Header
+    }
+    else if (item.LinkFlag == NFileHeader::NLinkFlag::kDumpDir)
+    {
+      // GNU Extensions to the Archive Format
+    }
+    else if (item.LinkFlag > '7' || (item.LinkFlag < '0' && item.LinkFlag != 0))
+      return S_FALSE;
+    if (flagL) item.Name = nameL;
+    if (flagK) item.LinkName = nameK;
+    return S_OK;
+  }
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Tar/TarIn.h

@@ -0,0 +1,17 @@
+// TarIn.h
+
+#ifndef __ARCHIVE_TAR_IN_H
+#define __ARCHIVE_TAR_IN_H
+
+#include "../../IStream.h"
+
+#include "TarItem.h"
+
+namespace NArchive {
+namespace NTar {
+  
+HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &itemInfo, AString &error);
+
+}}
+  
+#endif

data/ext/p7zip/CPP/7zip/Archive/Tar/TarItem.h

@@ -0,0 +1,72 @@
+// TarItem.h
+
+#ifndef __ARCHIVE_TAR_ITEM_H
+#define __ARCHIVE_TAR_ITEM_H
+
+#include "../Common/ItemNameUtils.h"
+
+#include "TarHeader.h"
+
+namespace NArchive {
+namespace NTar {
+
+struct CItem
+{
+  AString Name;
+  UInt64 Size;
+
+  UInt32 Mode;
+  UInt32 UID;
+  UInt32 GID;
+  UInt32 MTime;
+  UInt32 DeviceMajor;
+  UInt32 DeviceMinor;
+
+  AString LinkName;
+  AString User;
+  AString Group;
+
+  char Magic[8];
+  char LinkFlag;
+  bool DeviceMajorDefined;
+  bool DeviceMinorDefined;
+
+  bool IsLink() const { return LinkFlag == NFileHeader::NLinkFlag::kSymbolicLink && (Size == 0); }
+  UInt64 GetUnpackSize() const { return IsLink() ? LinkName.Length() : Size; }
+
+  bool IsDir() const
+  {
+    switch(LinkFlag)
+    {
+      case NFileHeader::NLinkFlag::kDirectory:
+      case NFileHeader::NLinkFlag::kDumpDir:
+        return true;
+      case NFileHeader::NLinkFlag::kOldNormal:
+      case NFileHeader::NLinkFlag::kNormal:
+        return NItemName::HasTailSlash(Name, CP_OEMCP);
+    }
+    return false;
+  }
+
+  bool IsMagic() const
+  {
+    for (int i = 0; i < 5; i++)
+      if (Magic[i] != NFileHeader::NMagic::kUsTar[i])
+        return false;
+    return true;
+  }
+
+  UInt64 GetPackSize() const { return (Size + 0x1FF) & (~((UInt64)0x1FF)); }
+};
+
+struct CItemEx: public CItem
+{
+  UInt64 HeaderPos;
+  unsigned HeaderSize;
+  UInt64 GetDataPosition() const { return HeaderPos + HeaderSize; }
+  UInt64 GetFullSize() const { return HeaderSize + Size; }
+};
+
+}}
+
+#endif

data/ext/p7zip/CPP/7zip/Archive/Tar/TarOut.cpp

@@ -0,0 +1,187 @@
+// TarOut.cpp
+
+#include "StdAfx.h"
+
+#include "Common/IntToString.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "TarOut.h"
+
+namespace NArchive {
+namespace NTar {
+
+HRESULT COutArchive::WriteBytes(const void *buffer, UInt32 size)
+{
+  return WriteStream(m_Stream, buffer, size);
+}
+
+void COutArchive::Create(ISequentialOutStream *outStream)
+{
+  m_Stream = outStream;
+}
+
+static AString MakeOctalString(UInt64 value)
+{
+  char s[32];
+  ConvertUInt64ToString(value, s, 8);
+  return AString(s) + ' ';
+}
+
+static void MyStrNCpy(char *dest, const char *src, int size)
+{
+  for (int i = 0; i < size; i++)
+  {
+    char c = src[i];
+    dest[i] = c;
+    if (c == 0)
+      break;
+  }
+}
+
+static bool MakeOctalString8(char *s, UInt32 value)
+{
+  AString tempString = MakeOctalString(value);
+
+  const int kMaxSize = 8;
+  if (tempString.Length() >= kMaxSize)
+    return false;
+  int numSpaces = kMaxSize - (tempString.Length() + 1);
+  for(int i = 0; i < numSpaces; i++)
+    s[i] = ' ';
+  MyStringCopy(s + numSpaces, (const char *)tempString);
+  return true;
+}
+
+static void MakeOctalString12(char *s, UInt64 value)
+{
+  AString tempString  = MakeOctalString(value);
+  const int kMaxSize = 12;
+  if (tempString.Length() > kMaxSize)
+  {
+    // GNU extension;
+    s[0] = (char)(Byte)0x80;
+    s[1] = s[2] = s[3] = 0;
+    for (int i = 0; i < 8; i++, value <<= 8)
+      s[4 + i] = (char)(value >> 56);
+    return;
+  }
+  int numSpaces = kMaxSize - tempString.Length();
+  for(int i = 0; i < numSpaces; i++)
+    s[i] = ' ';
+  memmove(s + numSpaces, (const char *)tempString, tempString.Length());
+}
+
+static bool CopyString(char *dest, const AString &src, int maxSize)
+{
+  if (src.Length() >= maxSize)
+    return false;
+  MyStringCopy(dest, (const char *)src);
+  return true;
+}
+
+#define RETURN_IF_NOT_TRUE(x) { if (!(x)) return E_FAIL; }
+
+HRESULT COutArchive::WriteHeaderReal(const CItem &item)
+{
+  char record[NFileHeader::kRecordSize];
+  char *cur = record;
+  int i;
+  for (i = 0; i < NFileHeader::kRecordSize; i++)
+    record[i] = 0;
+
+  // RETURN_IF_NOT_TRUE(CopyString(header.Name, item.Name, NFileHeader::kNameSize));
+  if (item.Name.Length() > NFileHeader::kNameSize)
+    return E_FAIL;
+  MyStrNCpy(cur, item.Name, NFileHeader::kNameSize);
+  cur += NFileHeader::kNameSize;
+
+  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.Mode)); cur += 8;
+  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.UID)); cur += 8;
+  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.GID)); cur += 8;
+
+  MakeOctalString12(cur, item.Size); cur += 12;
+  MakeOctalString12(cur, item.MTime); cur += 12;
+  
+  memmove(cur, NFileHeader::kCheckSumBlanks, 8);
+  cur += 8;
+
+  *cur++ = item.LinkFlag;
+
+  RETURN_IF_NOT_TRUE(CopyString(cur, item.LinkName, NFileHeader::kNameSize));
+  cur += NFileHeader::kNameSize;
+
+  memmove(cur, item.Magic, 8);
+  cur += 8;
+
+  RETURN_IF_NOT_TRUE(CopyString(cur, item.User, NFileHeader::kUserNameSize));
+  cur += NFileHeader::kUserNameSize;
+  RETURN_IF_NOT_TRUE(CopyString(cur, item.Group, NFileHeader::kGroupNameSize));
+  cur += NFileHeader::kGroupNameSize;
+
+
+  if (item.DeviceMajorDefined)
+    RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.DeviceMajor));
+  cur += 8;
+
+  if (item.DeviceMinorDefined)
+    RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.DeviceMinor));
+  cur += 8;
+
+
+  UInt32 checkSumReal = 0;
+  for(i = 0; i < NFileHeader::kRecordSize; i++)
+    checkSumReal += Byte(record[i]);
+
+  RETURN_IF_NOT_TRUE(MakeOctalString8(record + 148, checkSumReal));
+
+  return WriteBytes(record, NFileHeader::kRecordSize);
+}
+
+HRESULT COutArchive::WriteHeader(const CItem &item)
+{
+  int nameSize = item.Name.Length();
+  if (nameSize < NFileHeader::kNameSize)
+    return WriteHeaderReal(item);
+
+  CItem modifiedItem = item;
+  int nameStreamSize = nameSize + 1;
+  modifiedItem.Size = nameStreamSize;
+  modifiedItem.LinkFlag = 'L';
+  modifiedItem.Name = NFileHeader::kLongLink;
+  modifiedItem.LinkName.Empty();
+  RINOK(WriteHeaderReal(modifiedItem));
+  RINOK(WriteBytes(item.Name, nameStreamSize));
+  RINOK(FillDataResidual(nameStreamSize));
+
+  modifiedItem = item;
+  modifiedItem.Name = item.Name.Left(NFileHeader::kNameSize - 1);
+  return WriteHeaderReal(modifiedItem);
+}
+
+HRESULT COutArchive::FillDataResidual(UInt64 dataSize)
+{
+  UInt32 lastRecordSize = UInt32(dataSize & (NFileHeader::kRecordSize - 1));
+  if (lastRecordSize == 0)
+    return S_OK;
+  UInt32 residualSize = NFileHeader::kRecordSize - lastRecordSize;
+  Byte residualBytes[NFileHeader::kRecordSize];
+  for (UInt32 i = 0; i < residualSize; i++)
+    residualBytes[i] = 0;
+  return WriteBytes(residualBytes, residualSize);
+}
+
+HRESULT COutArchive::WriteFinishHeader()
+{
+  Byte record[NFileHeader::kRecordSize];
+  int i;
+  for (i = 0; i < NFileHeader::kRecordSize; i++)
+    record[i] = 0;
+  for (i = 0; i < 2; i++)
+  {
+    RINOK(WriteBytes(record, NFileHeader::kRecordSize));
+  }
+  return S_OK;
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Tar/TarOut.h

@@ -0,0 +1,28 @@
+// Archive/TarOut.h
+
+#ifndef __ARCHIVE_TAR_OUT_H
+#define __ARCHIVE_TAR_OUT_H
+
+#include "TarItem.h"
+
+#include "Common/MyCom.h"
+#include "../../IStream.h"
+
+namespace NArchive {
+namespace NTar {
+
+class COutArchive
+{
+  CMyComPtr<ISequentialOutStream> m_Stream;
+  HRESULT WriteBytes(const void *buffer, UInt32 size);
+public:
+  void Create(ISequentialOutStream *outStream);
+  HRESULT WriteHeaderReal(const CItem &item);
+  HRESULT WriteHeader(const CItem &item);
+  HRESULT FillDataResidual(UInt64 dataSize);
+  HRESULT WriteFinishHeader();
+};
+
+}}
+
+#endif

data/ext/p7zip/CPP/7zip/Archive/Tar/TarRegister.cpp

@@ -0,0 +1,18 @@
+// TarRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "TarHandler.h"
+static IInArchive *CreateArc() { return new NArchive::NTar::CHandler; }
+#ifndef EXTRACT_ONLY
+static IOutArchive *CreateArcOut() { return new NArchive::NTar::CHandler; }
+#else
+#define CreateArcOut 0
+#endif
+
+static CArcInfo g_ArcInfo =
+{ L"tar", L"tar", 0, 0xEE, { 'u', 's', 't', 'a', 'r' }, 5, false, CreateArc, CreateArcOut };
+
+REGISTER_ARC(Tar)

data/ext/p7zip/CPP/7zip/Archive/Tar/TarUpdate.cpp

@@ -0,0 +1,139 @@
+// TarUpdate.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "TarOut.h"
+#include "TarUpdate.h"
+
+namespace NArchive {
+namespace NTar {
+
+HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
+    const CObjectVector<NArchive::NTar::CItemEx> &inputItems,
+    const CObjectVector<CUpdateItem> &updateItems,
+    IArchiveUpdateCallback *updateCallback)
+{
+  COutArchive outArchive;
+  outArchive.Create(outStream);
+
+  UInt64 complexity = 0;
+
+  int i;
+  for(i = 0; i < updateItems.Size(); i++)
+  {
+    const CUpdateItem &ui = updateItems[i];
+    if (ui.NewData)
+      complexity += ui.Size;
+    else
+      complexity += inputItems[ui.IndexInArchive].GetFullSize();
+  }
+
+  RINOK(updateCallback->SetTotal(complexity));
+
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(updateCallback, true);
+
+  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<CLimitedSequentialInStream> inStreamLimited(streamSpec);
+  streamSpec->SetStream(inStream);
+
+  complexity = 0;
+
+  for(i = 0; i < updateItems.Size(); i++)
+  {
+    lps->InSize = lps->OutSize = complexity;
+    RINOK(lps->SetCur());
+
+    const CUpdateItem &ui = updateItems[i];
+    CItem item;
+    if (ui.NewProps)
+    {
+      item.Mode = ui.Mode;
+      item.Name = ui.Name;
+      item.User = ui.User;
+      item.Group = ui.Group;
+      if (ui.IsDir)
+      {
+        item.LinkFlag = NFileHeader::NLinkFlag::kDirectory;
+        item.Size = 0;
+      }
+      else
+      {
+        item.LinkFlag = NFileHeader::NLinkFlag::kNormal;
+        item.Size = ui.Size;
+      }
+      item.MTime = ui.Time;
+      item.DeviceMajorDefined = false;
+      item.DeviceMinorDefined = false;
+      item.UID = 0;
+      item.GID = 0;
+      memmove(item.Magic, NFileHeader::NMagic::kEmpty, 8);
+    }
+    else
+      item = inputItems[ui.IndexInArchive];
+
+    if (ui.NewData)
+    {
+      item.Size = ui.Size;
+      if (item.Size == (UInt64)(Int64)-1)
+        return E_INVALIDARG;
+    }
+    else
+      item.Size = inputItems[ui.IndexInArchive].Size;
+  
+    if (ui.NewData)
+    {
+      CMyComPtr<ISequentialInStream> fileInStream;
+      HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
+      if (res != S_FALSE)
+      {
+        RINOK(res);
+        RINOK(outArchive.WriteHeader(item));
+        if (!ui.IsDir)
+        {
+          RINOK(copyCoder->Code(fileInStream, outStream, NULL, NULL, progress));
+          if (copyCoderSpec->TotalSize != item.Size)
+            return E_FAIL;
+          RINOK(outArchive.FillDataResidual(item.Size));
+        }
+      }
+      complexity += ui.Size;
+      RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
+    }
+    else
+    {
+      const CItemEx &existItem = inputItems[ui.IndexInArchive];
+      UInt64 size;
+      if (ui.NewProps)
+      {
+        RINOK(outArchive.WriteHeader(item));
+        RINOK(inStream->Seek(existItem.GetDataPosition(), STREAM_SEEK_SET, NULL));
+        size = existItem.Size;
+      }
+      else
+      {
+        RINOK(inStream->Seek(existItem.HeaderPos, STREAM_SEEK_SET, NULL));
+        size = existItem.GetFullSize();
+      }
+      streamSpec->Init(size);
+
+      RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress));
+      if (copyCoderSpec->TotalSize != size)
+        return E_FAIL;
+      RINOK(outArchive.FillDataResidual(existItem.Size));
+      complexity += size;
+    }
+  }
+  return outArchive.WriteFinishHeader();
+}
+
+}}

data/ext/p7zip/CPP/7zip/Archive/Tar/TarUpdate.h

@@ -0,0 +1,34 @@
+// TarUpdate.h
+
+#ifndef __TAR_UPDATE_H
+#define __TAR_UPDATE_H
+
+#include "../IArchive.h"
+#include "TarItem.h"
+
+namespace NArchive {
+namespace NTar {
+
+struct CUpdateItem
+{
+  int IndexInArchive;
+  int IndexInClient;
+  UInt32 Time;
+  UInt32 Mode;
+  UInt64 Size;
+  AString Name;
+  AString User;
+  AString Group;
+  bool NewData;
+  bool NewProps;
+  bool IsDir;
+};
+
+HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
+    const CObjectVector<CItemEx> &inputItems,
+    const CObjectVector<CUpdateItem> &updateItems,
+    IArchiveUpdateCallback *updateCallback);
+
+}}
+
+#endif