mirror of
https://github.com/Xevion/easy7zip.git
synced 2025-12-12 22:11:35 -06:00
4.20
This commit is contained in:
Igor Pavlov
committed by
Kornel Lesiński
Kornel Lesiński
parent
8c1b5c7b7e
commit
3c510ba80b
@@ -11,13 +11,42 @@
|
||||
namespace NArchive {
|
||||
namespace NCpio {
|
||||
|
||||
HRESULT CInArchive::ReadBytes(void *data, UINT32 size, UINT32 &processedSize)
|
||||
HRESULT CInArchive::ReadBytes(void *data, UInt32 size, UInt32 &processedSize)
|
||||
{
|
||||
RINOK(m_Stream->Read(data, size, &processedSize));
|
||||
m_Position += processedSize;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
Byte CInArchive::ReadByte()
|
||||
{
|
||||
if (_blockPos >= _blockSize)
|
||||
throw "Incorrect cpio archive";
|
||||
return _block[_blockPos++];
|
||||
}
|
||||
|
||||
UInt16 CInArchive::ReadUInt16()
|
||||
{
|
||||
UInt16 value = 0;
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
Byte b = ReadByte();
|
||||
value |= (UInt16(b) << (8 * i));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
UInt32 CInArchive::ReadUInt32()
|
||||
{
|
||||
UInt32 value = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
Byte b = ReadByte();
|
||||
value |= (UInt32(b) << (8 * i));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
HRESULT CInArchive::Open(IInStream *inStream)
|
||||
{
|
||||
RINOK(inStream->Seek(0, STREAM_SEEK_CUR, &m_Position));
|
||||
@@ -25,12 +54,12 @@ HRESULT CInArchive::Open(IInStream *inStream)
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static bool HexStringToNumber(const char *s, UINT32 &resultValue)
|
||||
bool CInArchive::ReadNumber(UInt32 &resultValue)
|
||||
{
|
||||
resultValue = 0;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
char c = s[i];
|
||||
char c = char(ReadByte());
|
||||
int d;
|
||||
if (c >= '0' && c <= '9')
|
||||
d = c - '0';
|
||||
@@ -46,9 +75,23 @@ static bool HexStringToNumber(const char *s, UINT32 &resultValue)
|
||||
return true;
|
||||
}
|
||||
|
||||
#define GetFromHex(x, y) { if (!HexStringToNumber((x), (y))) return E_FAIL; }
|
||||
bool CInArchive::ReadOctNumber(int size, UInt32 &resultValue)
|
||||
{
|
||||
char s[32];
|
||||
int i;
|
||||
for (i = 0; i < size && i < 32; i++)
|
||||
s[i] = char(ReadByte());
|
||||
s[i] = 0;
|
||||
char *endPtr;
|
||||
resultValue = strtoul(s, &endPtr, 8);
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline unsigned short ConvertValue(
|
||||
#define GetFromHex(y) { if (!ReadNumber(y)) return E_FAIL; }
|
||||
#define GetFromOct6(y) { if (!ReadOctNumber(6, y)) return E_FAIL; }
|
||||
#define GetFromOct11(y) { if (!ReadOctNumber(11, y)) return E_FAIL; }
|
||||
|
||||
static unsigned short ConvertValue(
|
||||
unsigned short value, bool convert)
|
||||
{
|
||||
if (!convert)
|
||||
@@ -56,83 +99,135 @@ static inline unsigned short ConvertValue(
|
||||
return (((unsigned short)(value & 0xFF)) << 8) | (value >> 8);
|
||||
}
|
||||
|
||||
static UInt32 GetAlignedSize(UInt32 size, UInt32 align)
|
||||
{
|
||||
while ((size & (align - 1)) != 0)
|
||||
size++;
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
|
||||
{
|
||||
/*
|
||||
union
|
||||
{
|
||||
NFileHeader::CRecord record;
|
||||
NFileHeader::CRecord2 record2;
|
||||
};
|
||||
*/
|
||||
filled = false;
|
||||
|
||||
UINT32 processedSize;
|
||||
UInt32 processedSize;
|
||||
item.HeaderPosition = m_Position;
|
||||
|
||||
RINOK(ReadBytes(&record2, 2, processedSize));
|
||||
_blockSize = kMaxBlockSize;
|
||||
RINOK(ReadBytes(_block, 2, processedSize));
|
||||
if (processedSize != 2)
|
||||
return S_FALSE;
|
||||
_blockPos = 0;
|
||||
|
||||
UINT32 nameSize;
|
||||
UInt32 nameSize;
|
||||
|
||||
unsigned short signature = *(unsigned short *)&record;
|
||||
bool oldBE = (signature == NFileHeader::NMagic::kMagicForRecord2BE);
|
||||
bool oldBE =
|
||||
_block[0] == NFileHeader::NMagic::kMagicForRecord2[1] &&
|
||||
_block[1] == NFileHeader::NMagic::kMagicForRecord2[0];
|
||||
|
||||
if (signature == NFileHeader::NMagic::kMagicForRecord2 || oldBE)
|
||||
bool binMode = (_block[0] == NFileHeader::NMagic::kMagicForRecord2[0] &&
|
||||
_block[1] == NFileHeader::NMagic::kMagicForRecord2[1]) ||
|
||||
oldBE;
|
||||
|
||||
if (binMode)
|
||||
{
|
||||
RINOK(ReadBytes((BYTE *)(&record2) + 2,
|
||||
sizeof(record2) - 2, processedSize));
|
||||
if (processedSize != sizeof(record2) - 2)
|
||||
RINOK(ReadBytes(_block + 2, NFileHeader::kRecord2Size - 2, processedSize));
|
||||
if (processedSize != NFileHeader::kRecord2Size - 2)
|
||||
return S_FALSE;
|
||||
|
||||
item.inode = ConvertValue(record2.c_ino, oldBE);
|
||||
item.Mode = ConvertValue(record2.c_mode, oldBE);
|
||||
item.UID = ConvertValue(record2.c_uid, oldBE);
|
||||
item.GID = ConvertValue(record2.c_gid, oldBE);
|
||||
item.Size =
|
||||
(UINT32(ConvertValue(record2.c_filesizes[0], oldBE)) << 16)
|
||||
+ ConvertValue(record2.c_filesizes[1], oldBE);
|
||||
item.ModificationTime =
|
||||
(UINT32(ConvertValue(record2.c_mtimes[0], oldBE)) << 16) +
|
||||
ConvertValue(record2.c_mtimes[1], oldBE);
|
||||
item.NumLinks = ConvertValue(record2.c_nlink, oldBE);
|
||||
item.Align = 2;
|
||||
_blockPos = 2;
|
||||
item.DevMajor = 0;
|
||||
item.DevMinor = ConvertValue(record2.c_dev, oldBE);
|
||||
item.DevMinor = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.inode = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.Mode = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.UID = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.GID = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.NumLinks = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.RDevMajor =0;
|
||||
item.RDevMinor = ConvertValue(record2.c_rdev, oldBE);
|
||||
item.RDevMinor = ConvertValue(ReadUInt16(), oldBE);
|
||||
UInt16 timeHigh = ConvertValue(ReadUInt16(), oldBE);
|
||||
UInt16 timeLow = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.ModificationTime = (UInt32(timeHigh) << 16) + timeLow;
|
||||
nameSize = ConvertValue(ReadUInt16(), oldBE);
|
||||
UInt16 sizeHigh = ConvertValue(ReadUInt16(), oldBE);
|
||||
UInt16 sizeLow = ConvertValue(ReadUInt16(), oldBE);
|
||||
item.Size = (UInt32(sizeHigh) << 16) + sizeLow;
|
||||
|
||||
item.ChkSum = 0;
|
||||
nameSize = ConvertValue(record2.c_namesize, oldBE);
|
||||
item.HeaderSize =
|
||||
(((nameSize + sizeof(NFileHeader::CRecord2) - 1) / 2) + 1) * 2; /* 4 byte padding for ("new cpio header" + "filename") */
|
||||
// nameSize + sizeof(NFileHeader::CRecord2);
|
||||
nameSize = item.HeaderSize - sizeof(NFileHeader::CRecord2);
|
||||
item.OldHeader = true;
|
||||
item.HeaderSize = GetAlignedSize(
|
||||
nameSize + NFileHeader::kRecord2Size, item.Align);
|
||||
nameSize = item.HeaderSize - NFileHeader::kRecord2Size;
|
||||
}
|
||||
else
|
||||
{
|
||||
RINOK(ReadBytes((BYTE *)(&record) + 2, sizeof(record) - 2, processedSize));
|
||||
if (processedSize != sizeof(record) - 2)
|
||||
RINOK(ReadBytes(_block + 2, 4, processedSize));
|
||||
if (processedSize != 4)
|
||||
return S_FALSE;
|
||||
|
||||
if (!record.CheckMagic())
|
||||
return S_FALSE;
|
||||
|
||||
GetFromHex(record.inode, item.inode);
|
||||
GetFromHex(record.Mode, item.Mode);
|
||||
GetFromHex(record.UID, item.UID);
|
||||
GetFromHex(record.GID, item.GID);
|
||||
GetFromHex(record.nlink, item.NumLinks);
|
||||
GetFromHex(record.mtime, *(UINT32 *)&item.ModificationTime);
|
||||
GetFromHex(record.Size, item.Size);
|
||||
GetFromHex(record.DevMajor, item.DevMajor);
|
||||
GetFromHex(record.DevMinor, item.DevMinor);
|
||||
GetFromHex(record.RDevMajor, item.RDevMajor);
|
||||
GetFromHex(record.RDevMinor, item.RDevMinor);
|
||||
GetFromHex(record.ChkSum, item.ChkSum);
|
||||
GetFromHex(record.NameSize, nameSize)
|
||||
item.HeaderSize =
|
||||
(((nameSize + sizeof(NFileHeader::CRecord) - 1) / 4) + 1) * 4; /* 4 byte padding for ("new cpio header" + "filename") */
|
||||
nameSize = item.HeaderSize - sizeof(NFileHeader::CRecord);
|
||||
item.OldHeader = false;
|
||||
|
||||
bool magicOK =
|
||||
memcmp(_block, NFileHeader::NMagic::kMagic1, 6) == 0 ||
|
||||
memcmp(_block, NFileHeader::NMagic::kMagic2, 6) == 0;
|
||||
_blockPos = 6;
|
||||
if (magicOK)
|
||||
{
|
||||
RINOK(ReadBytes(_block + 6, NFileHeader::kRecordSize - 6, processedSize));
|
||||
if (processedSize != NFileHeader::kRecordSize - 6)
|
||||
return S_FALSE;
|
||||
item.Align = 4;
|
||||
|
||||
GetFromHex(item.inode);
|
||||
GetFromHex(item.Mode);
|
||||
GetFromHex(item.UID);
|
||||
GetFromHex(item.GID);
|
||||
GetFromHex(item.NumLinks);
|
||||
UInt32 modificationTime;
|
||||
GetFromHex(modificationTime);
|
||||
item.ModificationTime = modificationTime;
|
||||
GetFromHex(item.Size);
|
||||
GetFromHex(item.DevMajor);
|
||||
GetFromHex(item.DevMinor);
|
||||
GetFromHex(item.RDevMajor);
|
||||
GetFromHex(item.RDevMinor);
|
||||
GetFromHex(nameSize);
|
||||
GetFromHex(item.ChkSum);
|
||||
item.HeaderSize = GetAlignedSize(
|
||||
nameSize + NFileHeader::kRecordSize, item.Align);
|
||||
nameSize = item.HeaderSize - NFileHeader::kRecordSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!memcmp(_block, NFileHeader::NMagic::kMagic3, 6) == 0)
|
||||
return S_FALSE;
|
||||
RINOK(ReadBytes(_block + 6, NFileHeader::kOctRecordSize - 6, processedSize));
|
||||
if (processedSize != NFileHeader::kOctRecordSize - 6)
|
||||
return S_FALSE;
|
||||
item.Align = 1;
|
||||
item.DevMajor = 0;
|
||||
GetFromOct6(item.DevMinor);
|
||||
GetFromOct6(item.inode);
|
||||
GetFromOct6(item.Mode);
|
||||
GetFromOct6(item.UID);
|
||||
GetFromOct6(item.GID);
|
||||
GetFromOct6(item.NumLinks);
|
||||
item.RDevMajor = 0;
|
||||
GetFromOct6(item.RDevMinor);
|
||||
UInt32 modificationTime;
|
||||
GetFromOct11(modificationTime);
|
||||
item.ModificationTime = modificationTime;
|
||||
GetFromOct6(nameSize);
|
||||
GetFromOct11(item.Size); // ?????
|
||||
item.HeaderSize = GetAlignedSize(
|
||||
nameSize + NFileHeader::kOctRecordSize, item.Align);
|
||||
nameSize = item.HeaderSize - NFileHeader::kOctRecordSize;
|
||||
}
|
||||
}
|
||||
if (nameSize == 0 || nameSize >= (1 << 27))
|
||||
return E_FAIL;
|
||||
@@ -141,27 +236,27 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
|
||||
if (processedSize != nameSize)
|
||||
return E_FAIL;
|
||||
item.Name.ReleaseBuffer();
|
||||
if (item.Name == NFileHeader::NMagic::kEndName)
|
||||
if (strcmp(item.Name, NFileHeader::NMagic::kEndName) == 0)
|
||||
return S_OK;
|
||||
filled = true;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
HRESULT CInArchive::Skeep(UINT64 aNumBytes)
|
||||
HRESULT CInArchive::Skeep(UInt64 numBytes)
|
||||
{
|
||||
UINT64 aNewPostion;
|
||||
RINOK(m_Stream->Seek(aNumBytes, STREAM_SEEK_CUR, &aNewPostion));
|
||||
m_Position += aNumBytes;
|
||||
if (m_Position != aNewPostion)
|
||||
UInt64 newPostion;
|
||||
RINOK(m_Stream->Seek(numBytes, STREAM_SEEK_CUR, &newPostion));
|
||||
m_Position += numBytes;
|
||||
if (m_Position != newPostion)
|
||||
return E_FAIL;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
HRESULT CInArchive::SkeepDataRecords(UINT64 aDataSize, bool OldHeader)
|
||||
HRESULT CInArchive::SkeepDataRecords(UInt64 dataSize, UInt32 align)
|
||||
{
|
||||
if (OldHeader)
|
||||
return Skeep((aDataSize + 1) & 0xFFFFFFFFFFFFFFFE);
|
||||
return Skeep((aDataSize + 3) & 0xFFFFFFFFFFFFFFFC);
|
||||
while ((dataSize & (align - 1)) != 0)
|
||||
dataSize++;
|
||||
return Skeep(dataSize);
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
Reference in New Issue
Block a user