seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,25 @@
+// Archive/Tar/Header.h
+
+#include "StdAfx.h"
+
+#include "TarHeader.h"
+
+namespace NArchive {
+namespace NTar {
+namespace NFileHeader {
+
+  // The checksum field is filled with this while the checksum is computed.
+  const char *kCheckSumBlanks = "        ";   // 8 blanks, no null
+
+  const char *kLongLink = "././@LongLink";
+  const char *kLongLink2 = "@LongLink";
+
+  // The magic field is filled with this if uname and gname are valid.
+  namespace NMagic
+  {
+    const char *kUsTar  = "ustar"; // 5 chars
+    const char *kGNUTar = "GNUtar "; // 7 chars and a null
+    const char *kEmpty = "\0\0\0\0\0\0\0\0"; // 7 chars and a null
+  }
+
+}}}

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

@@ -0,0 +1,108 @@
+// Archive/Tar/Header.h
+
+#ifndef __ARCHIVE_TAR_HEADER_H
+#define __ARCHIVE_TAR_HEADER_H
+
+#include "Common/Types.h"
+
+namespace NArchive {
+namespace NTar {
+
+namespace NFileHeader
+{
+  const int kRecordSize = 512;
+  const int kNameSize = 100;
+  const int kUserNameSize = 32;
+  const int kGroupNameSize = 32;
+  const int kPrefixSize = 155;
+
+  /*
+  struct CHeader
+  {
+    char Name[kNameSize];
+    char Mode[8];
+    char UID[8];
+    char GID[8];
+    char Size[12];
+    char ModificationTime[12];
+    char CheckSum[8];
+    char LinkFlag;
+    char LinkName[kNameSize];
+    char Magic[8];
+    char UserName[kUserNameSize];
+    char GroupName[kGroupNameSize];
+    char DeviceMajor[8];
+    char DeviceMinor[8];
+    char Prefix[155];
+  };
+  union CRecord
+  {
+    CHeader Header;
+    Byte Padding[kRecordSize];
+  };
+  */
+
+  namespace NMode
+  {
+    const int kSetUID   = 04000;  // Set UID on execution
+    const int kSetGID   = 02000;  // Set GID on execution
+    const int kSaveText = 01000;  // Save text (sticky bit)
+  }
+
+  namespace NFilePermissions
+  {
+    const int kUserRead     = 00400;  // read by owner
+    const int kUserWrite    = 00200;  // write by owner
+    const int kUserExecute  = 00100;  // execute/search by owner
+    const int kGroupRead    = 00040;  // read by group
+    const int kGroupWrite   = 00020;  // write by group
+    const int kGroupExecute = 00010;  // execute/search by group
+    const int kOtherRead    = 00004;  // read by other
+    const int kOtherWrite   = 00002;  // write by other
+    const int kOtherExecute = 00001;  // execute/search by other
+  }
+
+
+  // The linkflag defines the type of file
+  namespace NLinkFlag
+  {
+    const char kOldNormal    = '\0'; // Normal disk file, Unix compatible
+    const char kNormal       = '0'; // Normal disk file
+    const char kLink         = '1'; // Link to previously dumped file
+    const char kSymbolicLink = '2'; // Symbolic link
+    const char kCharacter    = '3'; // Character special file
+    const char kBlock        = '4'; // Block special file
+    const char kDirectory    = '5'; // Directory
+    const char kFIFO         = '6'; // FIFO special file
+    const char kContiguous   = '7'; // Contiguous file
+
+    const char kDumpDir       = 'D'; /* GNUTYPE_DUMPDIR.
+      data: list of files created by the --incremental (-G) option
+      Each file name is preceded by either
+        - 'Y' (file should be in this archive)
+        - 'N' (file is a directory, or is not stored in the archive.)
+        Each file name is terminated by a null + an additional null after
+        the last file name. */
+
+  }
+  // Further link types may be defined later.
+
+  // The checksum field is filled with this while the checksum is computed.
+  extern const char *kCheckSumBlanks;//   = "        ";   // 8 blanks, no null
+
+  extern const char *kLongLink;  //   = "././@LongLink";
+  extern const char *kLongLink2; //   = "@LongLink";
+
+  // The magic field is filled with this if uname and gname are valid.
+  namespace NMagic
+  {
+    extern const char *kUsTar; //   = "ustar"; // 5 chars
+    extern const char *kGNUTar; //  = "GNUtar "; // 7 chars and a null
+    extern const char *kEmpty; //  = "GNUtar "; // 7 chars and a null
+  }
+
+}
+
+}}
+
+#endif

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;
+}
+
+}}