472 lines
7.1 KiB
Plaintext
472 lines
7.1 KiB
Plaintext
7z Format description (2.30 Beta 25)
|
|
-----------------------------------
|
|
|
|
This file contains description of 7z archive format.
|
|
7z archive can contain files compressed with any method.
|
|
See "Methods.txt" for description for defined compressing methods.
|
|
|
|
|
|
Format structure Overview
|
|
-------------------------
|
|
|
|
Some fields can be optional.
|
|
|
|
Archive structure
|
|
~~~~~~~~~~~~~~~~~
|
|
SignatureHeader
|
|
[PackedStreams]
|
|
[PackedStreamsForHeaders]
|
|
[
|
|
Header
|
|
or
|
|
{
|
|
Packed Header
|
|
HeaderInfo
|
|
}
|
|
]
|
|
|
|
|
|
|
|
Header structure
|
|
~~~~~~~~~~~~~~~~
|
|
{
|
|
ArchiveProperties
|
|
AdditionalStreams
|
|
{
|
|
PackInfo
|
|
{
|
|
PackPos
|
|
NumPackStreams
|
|
Sizes[NumPackStreams]
|
|
CRCs[NumPackStreams]
|
|
}
|
|
CodersInfo
|
|
{
|
|
NumFolders
|
|
Folders[NumFolders]
|
|
{
|
|
NumCoders
|
|
CodersInfo[NumCoders]
|
|
{
|
|
ID
|
|
NumInStreams;
|
|
NumOutStreams;
|
|
PropertiesSize
|
|
Properties[PropertiesSize]
|
|
}
|
|
NumBindPairs
|
|
BindPairsInfo[NumBindPairs]
|
|
{
|
|
InIndex;
|
|
OutIndex;
|
|
}
|
|
PackedIndices
|
|
}
|
|
UnPackSize[Folders][Folders.NumOutstreams]
|
|
CRCs[NumFolders]
|
|
}
|
|
SubStreamsInfo
|
|
{
|
|
NumUnPackStreamsInFolders[NumFolders];
|
|
UnPackSizes[]
|
|
CRCs[]
|
|
}
|
|
}
|
|
MainStreamsInfo
|
|
{
|
|
(Same as in AdditionalStreams)
|
|
}
|
|
FilesInfo
|
|
{
|
|
NumFiles
|
|
Properties[]
|
|
{
|
|
ID
|
|
Size
|
|
Data
|
|
}
|
|
}
|
|
}
|
|
|
|
HeaderInfo structure
|
|
~~~~~~~~~~~~~~~~~~~~
|
|
{
|
|
(Same as in AdditionalStreams)
|
|
}
|
|
|
|
|
|
|
|
Notes about Notation and encoding
|
|
---------------------------------
|
|
|
|
7z uses little endian encoding.
|
|
|
|
7z archive format has optional headers that are marked as
|
|
[]
|
|
Header
|
|
[]
|
|
|
|
REAL_UINT64 means real UINT64.
|
|
|
|
UINT64 means real UINT64 encoded with the following scheme:
|
|
|
|
Size of encoding sequence depends from first byte:
|
|
First_Byte Extra_Bytes Value
|
|
(binary)
|
|
0xxxxxxx : ( xxxxxxx )
|
|
10xxxxxx BYTE y[1] : ( xxxxxx << (8 * 1)) + y
|
|
110xxxxx BYTE y[2] : ( xxxxx << (8 * 2)) + y
|
|
...
|
|
1111110x BYTE y[6] : ( x << (8 * 6)) + y
|
|
11111110 BYTE y[7] : y
|
|
11111111 BYTE y[8] : y
|
|
|
|
|
|
|
|
Property IDs
|
|
------------
|
|
|
|
0x00 = kEnd,
|
|
|
|
0x01 = kHeader,
|
|
|
|
0x02 = kArchiveProperties,
|
|
|
|
0x03 = kAdditionalStreamsInfo,
|
|
0x04 = kMainStreamsInfo,
|
|
0x05 = kFilesInfo,
|
|
|
|
0x06 = kPackInfo,
|
|
0x07 = kUnPackInfo,
|
|
0x08 = kSubStreamsInfo,
|
|
|
|
0x09 = kSize,
|
|
0x0A = kCRC,
|
|
|
|
0x0B = kFolder,
|
|
|
|
0x0C = kCodersUnPackSize,
|
|
0x0D = kNumUnPackStream,
|
|
|
|
0x0E = kEmptyStream,
|
|
0x0F = kEmptyFile,
|
|
0x10 = kAnti,
|
|
|
|
0x11 = kName,
|
|
0x12 = kCreationTime,
|
|
0x13 = kLastAccessTime,
|
|
0x14 = kLastWriteTime,
|
|
0x15 = kWinAttributes,
|
|
0x16 = kComment,
|
|
|
|
0x17 = kEncodedHeader,
|
|
|
|
|
|
7z format headers
|
|
-----------------
|
|
|
|
SignatureHeader
|
|
~~~~~~~~~~~~~~~
|
|
BYTE kSignature[6] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
|
|
|
|
ArchiveVersion
|
|
{
|
|
BYTE Major; // now = 0
|
|
BYTE Minor; // now = 2
|
|
};
|
|
|
|
UINT32 StartHeaderCRC;
|
|
|
|
StartHeader
|
|
{
|
|
REAL_UINT64 NextHeaderOffset
|
|
REAL_UINT64 NextHeaderSize
|
|
UINT32 NextHeaderCRC
|
|
}
|
|
|
|
|
|
...........................
|
|
|
|
|
|
ArchiveProperties
|
|
~~~~~~~~~~~~~~~~~
|
|
BYTE NID::kArchiveProperties (0x02)
|
|
for (;;)
|
|
{
|
|
BYTE PropertyType;
|
|
if (aType == 0)
|
|
break;
|
|
UINT64 PropertySize;
|
|
BYTE PropertyData[PropertySize];
|
|
}
|
|
|
|
|
|
Digests (NumStreams)
|
|
~~~~~~~~~~~~~~~~~~~~~
|
|
BYTE AllAreDefined
|
|
if (AllAreDefined == 0)
|
|
{
|
|
for(NumStreams)
|
|
BIT Defined
|
|
}
|
|
UINT32 CRCs[NumDefined]
|
|
|
|
|
|
PackInfo
|
|
~~~~~~~~~~~~
|
|
BYTE NID::kPackInfo (0x06)
|
|
UINT64 PackPos
|
|
UINT64 NumPackStreams
|
|
|
|
[]
|
|
BYTE NID::kSize (0x09)
|
|
UINT64 PackSizes[NumPackStreams]
|
|
[]
|
|
|
|
[]
|
|
BYTE NID::kCRC (0x0A)
|
|
PackStreamDigests[NumPackStreams]
|
|
[]
|
|
|
|
BYTE NID::kEnd
|
|
|
|
|
|
Folder
|
|
~~~~~~
|
|
UINT64 NumCoders;
|
|
for (NumCoders)
|
|
{
|
|
BYTE
|
|
{
|
|
0:3 DecompressionMethod.IDSize
|
|
4:
|
|
0 - IsSimple
|
|
1 - Is not simple
|
|
5:
|
|
0 - No Attributes
|
|
1 - There Are Attributes
|
|
7:
|
|
0 - Last Method in Alternative_Method_List
|
|
1 - There are more alternative methods
|
|
}
|
|
BYTE DecompressionMethod.ID[DecompressionMethod.IDSize]
|
|
if (!IsSimple)
|
|
{
|
|
UINT64 NumInStreams;
|
|
UINT64 NumOutStreams;
|
|
}
|
|
if (DecompressionMethod[0] != 0)
|
|
{
|
|
UINT64 PropertiesSize
|
|
BYTE Properties[PropertiesSize]
|
|
}
|
|
}
|
|
|
|
NumBindPairs = NumOutStreamsTotal - 1;
|
|
|
|
for (NumBindPairs)
|
|
{
|
|
UINT64 InIndex;
|
|
UINT64 OutIndex;
|
|
}
|
|
|
|
NumPackedStreams = NumInStreamsTotal - NumBindPairs;
|
|
if (NumPackedStreams > 1)
|
|
for(NumPackedStreams)
|
|
{
|
|
UINT64 Index;
|
|
};
|
|
|
|
|
|
|
|
|
|
Coders Info
|
|
~~~~~~~~~~~
|
|
|
|
BYTE NID::kUnPackInfo (0x07)
|
|
|
|
|
|
BYTE NID::kFolder (0x0B)
|
|
UINT64 NumFolders
|
|
BYTE External
|
|
switch(External)
|
|
{
|
|
case 0:
|
|
Folders[NumFolders]
|
|
case 1:
|
|
UINT64 DataStreamIndex
|
|
}
|
|
|
|
|
|
BYTE ID::kCodersUnPackSize (0x0C)
|
|
for(Folders)
|
|
for(Folder.NumOutStreams)
|
|
UINT64 UnPackSize;
|
|
|
|
|
|
[]
|
|
BYTE NID::kCRC (0x0A)
|
|
UnPackDigests[NumFolders]
|
|
[]
|
|
|
|
|
|
|
|
BYTE NID::kEnd
|
|
|
|
|
|
|
|
SubStreams Info
|
|
~~~~~~~~~~~~~~
|
|
BYTE NID::kSubStreamsInfo; (0x08)
|
|
|
|
[]
|
|
BYTE NID::kNumUnPackStream; (0x0D)
|
|
UINT64 NumUnPackStreamsInFolders[NumFolders];
|
|
[]
|
|
|
|
|
|
[]
|
|
BYTE NID::kSize (0x09)
|
|
UINT64 UnPackSizes[]
|
|
[]
|
|
|
|
|
|
[]
|
|
BYTE NID::kCRC (0x0A)
|
|
Digests[Number of streams with unknown CRC]
|
|
[]
|
|
|
|
|
|
BYTE NID::kEnd
|
|
|
|
|
|
Streams Info
|
|
~~~~~~~~~~~~
|
|
|
|
[]
|
|
PackInfo
|
|
[]
|
|
|
|
|
|
[]
|
|
CodersInfo
|
|
[]
|
|
|
|
|
|
[]
|
|
SubStreamsInfo
|
|
[]
|
|
|
|
BYTE NID::kEnd
|
|
|
|
|
|
FilesInfo
|
|
~~~~~~~~~
|
|
BYTE NID::kFilesInfo; (0x05)
|
|
UINT64 NumFiles
|
|
|
|
for (;;)
|
|
{
|
|
BYTE PropertyType;
|
|
if (aType == 0)
|
|
break;
|
|
|
|
UINT64 Size;
|
|
|
|
switch(PropertyType)
|
|
{
|
|
kEmptyStream: (0x0E)
|
|
for(NumFiles)
|
|
BIT IsEmptyStream
|
|
|
|
kEmptyFile: (0x0F)
|
|
for(EmptyStreams)
|
|
BIT IsEmptyFile
|
|
|
|
kAnti: (0x10)
|
|
for(EmptyStreams)
|
|
BIT IsAntiFile
|
|
|
|
case kCreationTime: (0x12)
|
|
case kLastAccessTime: (0x13)
|
|
case kLastWriteTime: (0x14)
|
|
BYTE AllAreDefined
|
|
if (AllAreDefined == 0)
|
|
{
|
|
for(NumFiles)
|
|
BIT TimeDefined
|
|
}
|
|
BYTE External;
|
|
if(External != 0)
|
|
UINT64 DataIndex
|
|
[]
|
|
for(Definded Items)
|
|
UINT32 Time
|
|
[]
|
|
|
|
kNames: (0x11)
|
|
BYTE External;
|
|
if(External != 0)
|
|
UINT64 DataIndex
|
|
[]
|
|
for(Files)
|
|
{
|
|
wchar_t Names[NameSize];
|
|
wchar_t 0;
|
|
}
|
|
[]
|
|
|
|
kAttributes: (0x15)
|
|
BYTE AllAreDefined
|
|
if (AllAreDefined == 0)
|
|
{
|
|
for(NumFiles)
|
|
BIT AttributesAreDefined
|
|
}
|
|
BYTE External;
|
|
if(External != 0)
|
|
UINT64 DataIndex
|
|
[]
|
|
for(Definded Attributes)
|
|
UINT32 Attributes
|
|
[]
|
|
}
|
|
}
|
|
|
|
|
|
Header
|
|
~~~~~~
|
|
BYTE NID::kHeader (0x01)
|
|
|
|
[]
|
|
ArchiveProperties
|
|
[]
|
|
|
|
[]
|
|
BYTE NID::kAdditionalStreamsInfo; (0x03)
|
|
StreamsInfo
|
|
[]
|
|
|
|
[]
|
|
BYTE NID::kMainStreamsInfo; (0x04)
|
|
StreamsInfo
|
|
[]
|
|
|
|
[]
|
|
FilesInfo
|
|
[]
|
|
|
|
BYTE NID::kEnd
|
|
|
|
|
|
HeaderInfo
|
|
~~~~~~~~~~
|
|
[]
|
|
BYTE NID::kEncodedHeader; (0x17)
|
|
StreamsInfo for Encoded Header
|
|
[]
|
|
|
|
|
|
---
|
|
End of document
|