// TarIn.cpp

#include "StdAfx.h"

#include "CpuArch.h"

#include "Common/StringToInt.h"

#include "7zip/Common/StreamUtils.h"

#include "7zip/Archive/IArchive.h"

#include "7zip/Archive/Tar/TarIn.h"

namespace NArchive {
namespace NTar {
 
static void MyStrNCpy(char *dest, const char *src, unsigned size)
{
  for (unsigned i = 0; i < size; i++)
  {
    char c = src[i];
    dest[i] = c;
    if (c == 0)
      break;
  }
}

static bool OctalToNumber(const char *srcString, unsigned size, UInt64 &res)
{
  char sz[32];
  MyStrNCpy(sz, srcString, size);
  sz[size] = 0;
  const char *end;
  unsigned i;
  for (i = 0; sz[i] == ' '; i++);
  res = ConvertOctStringToUInt64(sz + i, &end);
  if (end == sz + i)
    return false;
  return (*end == ' ' || *end == 0);
}

static bool OctalToNumber32(const char *srcString, unsigned 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_OK; }

/*
static bool IsEmptyData(const char *buf, size_t size)
{
  for (unsigned i = 0; i < size; i++)
    if (buf[i] != 0)
      return false;
  return true;
}
*/

static bool IsRecordLast(const char *buf)
{
  for (unsigned i = 0; i < NFileHeader::kRecordSize; i++)
    if (buf[i] != 0)
      return false;
  return true;
}

static void ReadString(const char *s, unsigned size, AString &result)
{
  char temp[NFileHeader::kRecordSize + 1];
  MyStrNCpy(temp, s, size);
  temp[size] = '\0';
  result = temp;
}

static bool ParseInt64(const char *p, Int64 &val)
{
  UInt32 h = GetBe32(p);
  val = GetBe64(p + 4);
  if (h == (UInt32)1 << 31)
    return ((val >> 63) & 1) == 0;
  if (h == (UInt32)(Int32)-1)
    return ((val >> 63) & 1) != 0;
  UInt64 uv;
  bool res = OctalToNumber(p, 12, uv);
  val = uv;
  return res;
}

static bool ParseSize(const char *p, UInt64 &val)
{
  if (GetBe32(p) == (UInt32)1 << 31)
  {
    // GNU extension
    val = GetBe64(p + 4);
    return ((val >> 63) & 1) == 0;
  }
  return OctalToNumber(p, 12, val);
}

#define CHECK(x) { if (!(x)) return k_IsArc_Res_NO; }

API_FUNC_IsArc IsArc_Tar(const Byte *p2, size_t size)
{
  if (size < NFileHeader::kRecordSize)
    return k_IsArc_Res_NEED_MORE;

  const char *p = (const char *)p2;
  p += NFileHeader::kNameSize;

  UInt32 mode;
  CHECK(OctalToNumber32(p, 8, 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;

  UInt64 packSize;
  Int64 time;
  UInt32 checkSum;
  CHECK(ParseSize(p, packSize)); p += 12;
  CHECK(ParseInt64(p, time)); p += 12;
  CHECK(OctalToNumber32(p, 8, checkSum));
  return k_IsArc_Res_YES;
}

static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemEx &item, EErrorType &error)
{
  char buf[NFileHeader::kRecordSize];
  char *p = buf;

  error = k_ErrorType_OK;
  filled = false;

  bool thereAreEmptyRecords = false;
  for (;;)
  {
    size_t processedSize = NFileHeader::kRecordSize;
    RINOK(ReadStream(stream, buf, &processedSize));
    if (processedSize == 0)
    {
      if (!thereAreEmptyRecords)
        error = k_ErrorType_UnexpectedEnd; // "There are no trailing zero-filled records";
      return S_OK;
    }
    if (processedSize != NFileHeader::kRecordSize)
    {
      if (!thereAreEmptyRecords)
        error = k_ErrorType_UnexpectedEnd; // error = "There is no correct record at the end of archive";
      else
      {
        /*
        if (IsEmptyData(buf, processedSize))
          error = k_ErrorType_UnexpectedEnd;
        else
        {
          // extraReadSize = processedSize;
          // error = k_ErrorType_Corrupted; // some data after the end tail zeros
        }
        */
      }

      return S_OK;
    }
    if (!IsRecordLast(buf))
      break;
    item.HeaderSize += NFileHeader::kRecordSize;
    thereAreEmptyRecords = true;
  }
  if (thereAreEmptyRecords)
  {
    // error = "There are data after end of archive";
    return S_OK;
  }
  
  error = k_ErrorType_Corrupted;
  ReadString(p, NFileHeader::kNameSize, item.Name); p += NFileHeader::kNameSize;
  item.NameCouldBeReduced =
      (item.Name.Len() == NFileHeader::kNameSize ||
       item.Name.Len() == NFileHeader::kNameSize - 1);

  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;

  RIF(ParseSize(p, item.PackSize));
  item.Size = item.PackSize;
  p += 12;
  RIF(ParseInt64(p, item.MTime)); p += 12;
  
  UInt32 checkSum;
  RIF(OctalToNumber32(p, 8, checkSum));
  memset(p, ' ', 8); p += 8;

  item.LinkFlag = *p++;

  ReadString(p, NFileHeader::kNameSize, item.LinkName); p += NFileHeader::kNameSize;
  item.LinkNameCouldBeReduced =
      (item.LinkName.Len() == NFileHeader::kNameSize ||
       item.LinkName.Len() == NFileHeader::kNameSize - 1);

  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); if (item.DeviceMajorDefined) { RIF(OctalToNumber32(p, 8, item.DeviceMajor)); } p += 8;
  item.DeviceMinorDefined = (p[0] != 0); if (item.DeviceMinorDefined) { RIF(OctalToNumber32(p, 8, item.DeviceMinor)); } p += 8;

  if (p[0] != 0)
  {
    AString prefix;
    ReadString(p, NFileHeader::kPrefixSize, prefix);
    if (!prefix.IsEmpty()
        && item.IsUstarMagic()
        && (item.LinkFlag != 'L' /* || prefix != "00000000000" */ ))
      item.Name = prefix + '/' + item.Name;
  }

  p += NFileHeader::kPrefixSize;

  if (item.LinkFlag == NFileHeader::NLinkFlag::kHardLink)
  {
    item.PackSize = 0;
    item.Size = 0;
  }
  /*
    TAR standard requires sum of unsigned byte values.
    But some TAR programs use sum of signed byte values.
    So we check both values.
  */
  UInt32 checkSumReal = 0;
  Int32 checkSumReal_Signed = 0;
  for (unsigned i = 0; i < NFileHeader::kRecordSize; i++)
  {
    char c = buf[i];
    checkSumReal_Signed += (signed char)c;
    checkSumReal += (Byte)buf[i];
  }
  
  if (checkSumReal != checkSum)
  {
    if ((UInt32)checkSumReal_Signed != checkSum)
      return S_OK;
  }

  item.HeaderSize += NFileHeader::kRecordSize;

  if (item.LinkFlag == NFileHeader::NLinkFlag::kSparse)
  {
    Byte isExtended = buf[482];
    if (isExtended != 0 && isExtended != 1)
      return S_OK;
    RIF(ParseSize(buf + 483, item.Size));
    UInt64 min = 0;
    for (unsigned i = 0; i < 4; i++)
    {
      p = buf + 386 + 24 * i;
      if (GetBe32(p) == 0)
      {
        if (isExtended != 0)
          return S_OK;
        break;
      }
      CSparseBlock sb;
      RIF(ParseSize(p, sb.Offset));
      RIF(ParseSize(p + 12, sb.Size));
      item.SparseBlocks.Add(sb);
      if (sb.Offset < min || sb.Offset > item.Size)
        return S_OK;
      if ((sb.Offset & 0x1FF) != 0 || (sb.Size & 0x1FF) != 0)
        return S_OK;
      min = sb.Offset + sb.Size;
      if (min < sb.Offset)
        return S_OK;
    }
    if (min > item.Size)
      return S_OK;

    while (isExtended != 0)
    {
      size_t processedSize = NFileHeader::kRecordSize;
      RINOK(ReadStream(stream, buf, &processedSize));
      if (processedSize != NFileHeader::kRecordSize)
      {
        error = k_ErrorType_UnexpectedEnd;
        return S_OK;
      }

      item.HeaderSize += NFileHeader::kRecordSize;
      isExtended = buf[21 * 24];
      if (isExtended != 0 && isExtended != 1)
        return S_OK;
      for (unsigned i = 0; i < 21; i++)
      {
        p = buf + 24 * i;
        if (GetBe32(p) == 0)
        {
          if (isExtended != 0)
            return S_OK;
          break;
        }
        CSparseBlock sb;
        RIF(ParseSize(p, sb.Offset));
        RIF(ParseSize(p + 12, sb.Size));
        item.SparseBlocks.Add(sb);
        if (sb.Offset < min || sb.Offset > item.Size)
          return S_OK;
        if ((sb.Offset & 0x1FF) != 0 || (sb.Size & 0x1FF) != 0)
          return S_OK;
        min = sb.Offset + sb.Size;
        if (min < sb.Offset)
          return S_OK;
      }
    }
    if (min > item.Size)
      return S_OK;
  }
 
  filled = true;
  error = k_ErrorType_OK;
  return S_OK;
}

HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &item, EErrorType &error)
{
  item.HeaderSize = 0;
  bool flagL = false;
  bool flagK = false;
  AString nameL;
  AString nameK;
  
  for (;;)
  {
    RINOK(GetNextItemReal(stream, filled, item, error));
    if (!filled)
    {
      if (error == k_ErrorType_OK && (flagL || flagK))
        error = k_ErrorType_Corrupted;
      return S_OK;
    }
    
    if (error != k_ErrorType_OK)
      return S_OK;
    
    if (item.LinkFlag == NFileHeader::NLinkFlag::kGnu_LongName || // file contains a long name
        item.LinkFlag == NFileHeader::NLinkFlag::kGnu_LongLink)   // file contains a long linkname
    {
      AString *name;
      if (item.LinkFlag == NFileHeader::NLinkFlag::kGnu_LongName)
        { if (flagL) return S_OK; flagL = true; name = &nameL; }
      else
        { if (flagK) return S_OK; flagK = true; name = &nameK; }

      if (item.Name != NFileHeader::kLongLink &&
          item.Name != NFileHeader::kLongLink2)
        return S_OK;
      if (item.PackSize > (1 << 14))
        return S_OK;
      unsigned packSize = (unsigned)item.GetPackSizeAligned();
      char *buf = name->GetBuf(packSize);
      size_t processedSize = packSize;
      HRESULT res = ReadStream(stream, buf, &processedSize);
      item.HeaderSize += (unsigned)processedSize;
      name->ReleaseBuf_CalcLen((unsigned)item.PackSize);
      RINOK(res);
      if (processedSize != packSize)
      {
        error = k_ErrorType_UnexpectedEnd;
        return S_OK;
      }
      continue;
    }

    switch (item.LinkFlag)
    {
      case 'g':
      case 'x':
      case 'X':
      {
        // pax Extended Header
        break;
      }
      case NFileHeader::NLinkFlag::kDumpDir:
      {
        break;
        // GNU Extensions to the Archive Format
      }
      case NFileHeader::NLinkFlag::kSparse:
      {
        break;
        // GNU Extensions to the Archive Format
      }
      default:
        if (item.LinkFlag > '7' || (item.LinkFlag < '0' && item.LinkFlag != 0))
          return S_OK;
    }
    
    if (flagL)
    {
      item.Name = nameL;
      item.NameCouldBeReduced = false;
    }
    
    if (flagK)
    {
      item.LinkName = nameK;
      item.LinkNameCouldBeReduced = false;
    }

    error = k_ErrorType_OK;
    return S_OK;
  }
}

}}
