internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
: base(archiveEncoding)
{
ReadAndValidateGzipHeader(stream);
EntryStartPosition = stream.Position;
_stream = stream;
}
private string ReadZeroTerminatedString(Stream stream)
{
byte[] buf1 = new byte[1];
var list = new List <byte>();
bool done = false;
do
{
// workitem 7740
int n = stream.Read(buf1, 0, 1);
if (n != 1)
{
throw new ZlibException("Unexpected EOF reading GZIP header.");
}
if (buf1[0] == 0)
{
done = true;
}
else
{
list.Add(buf1[0]);
}
}while (!done);
byte[] buffer = list.ToArray();
return(ArchiveEncoding.Decode(buffer));
}
public void Tar_Japanese_Name(int length)
{
using (var mstm = new MemoryStream())
{
var enc = new ArchiveEncoding()
{
Default = Encoding.UTF8
};
var twopt = new TarWriterOptions(CompressionType.None, true);
twopt.ArchiveEncoding = enc;
var fname = new string((char)0x3042, length);
using (var tw = new TarWriter(mstm, twopt))
using (var input = new MemoryStream(new byte[32]))
{
tw.Write(fname, input, null);
}
using (var inputMemory = new MemoryStream(mstm.ToArray()))
{
var tropt = new ReaderOptions()
{
ArchiveEncoding = enc
};
using (var tr = TarReader.Open(inputMemory, tropt))
{
while (tr.MoveToNextEntry())
{
Assert.Equal(fname, tr.Entry.Key);
}
}
}
}
}
public ZipCentralDirectoryEntry(ZipCompressionMethod compression, string fileName, ulong headerOffset, ArchiveEncoding archiveEncoding)
{
this.compression = compression;
this.fileName = fileName;
HeaderOffset = headerOffset;
this.archiveEncoding = archiveEncoding;
}
public ChardetReaderOptions()
{
ArchiveEncoding = new ArchiveEncoding
{
CustomDecoder = Chardet
};
}
internal override void Read(BinaryReader reader)
{
Version = reader.ReadUInt16();
Flags = (HeaderFlags)reader.ReadUInt16();
CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
LastModifiedTime = reader.ReadUInt16();
LastModifiedDate = reader.ReadUInt16();
Crc = reader.ReadUInt32();
CompressedSize = reader.ReadUInt32();
UncompressedSize = reader.ReadUInt32();
ushort nameLength = reader.ReadUInt16();
ushort extraLength = reader.ReadUInt16();
byte[] name = reader.ReadBytes(nameLength);
byte[] extra = reader.ReadBytes(extraLength);
// According to .ZIP File Format Specification
//
// For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
//
// Bit 11: Language encoding flag (EFS). If this bit is set,
// the filename and comment fields for this file
// MUST be encoded using UTF-8. (see APPENDIX D)
if (Flags.HasFlag(HeaderFlags.Efs))
{
Name = ArchiveEncoding.DecodeUTF8(name);
}
else
{
Name = ArchiveEncoding.Decode(name);
}
LoadExtra(extra);
var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
if (unicodePathExtra != null)
{
Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
}
var zip64ExtraData = Extra.OfType <Zip64ExtendedInformationExtraField>().FirstOrDefault();
if (zip64ExtraData != null)
{
zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
if (CompressedSize == uint.MaxValue)
{
CompressedSize = zip64ExtraData.CompressedSize;
}
if (UncompressedSize == uint.MaxValue)
{
UncompressedSize = zip64ExtraData.UncompressedSize;
}
}
}
internal override void Read(BinaryReader reader)
{
Version = reader.ReadUInt16();
VersionNeededToExtract = reader.ReadUInt16();
Flags = (HeaderFlags)reader.ReadUInt16();
CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
LastModifiedTime = reader.ReadUInt16();
LastModifiedDate = reader.ReadUInt16();
Crc = reader.ReadUInt32();
CompressedSize = reader.ReadUInt32();
UncompressedSize = reader.ReadUInt32();
ushort nameLength = reader.ReadUInt16();
ushort extraLength = reader.ReadUInt16();
ushort commentLength = reader.ReadUInt16();
DiskNumberStart = reader.ReadUInt16();
InternalFileAttributes = reader.ReadUInt16();
ExternalFileAttributes = reader.ReadUInt32();
RelativeOffsetOfEntryHeader = reader.ReadUInt32();
byte[] name = reader.ReadBytes(nameLength);
Name = ArchiveEncoding.Decode(name);
byte[] extra = reader.ReadBytes(extraLength);
byte[] comment = reader.ReadBytes(commentLength);
Comment = ArchiveEncoding.Decode(comment);
LoadExtra(extra);
var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
if (unicodePathExtra != null)
{
Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
}
var zip64ExtraData = Extra.OfType <Zip64ExtendedInformationExtraField>().FirstOrDefault();
if (zip64ExtraData != null)
{
if (CompressedSize == uint.MaxValue)
{
CompressedSize = zip64ExtraData.CompressedSize;
}
if (UncompressedSize == uint.MaxValue)
{
UncompressedSize = zip64ExtraData.UncompressedSize;
}
if (RelativeOffsetOfEntryHeader == uint.MaxValue)
{
RelativeOffsetOfEntryHeader = zip64ExtraData.RelativeOffsetOfEntryHeader;
}
}
}
internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
: base(archiveEncoding)
{
_stream = stream;
ReadAndValidateGzipHeader();
if (stream.CanSeek)
{
long position = stream.Position;
stream.Position = stream.Length - 8;
ReadTrailer();
stream.Position = position;
}
EntryStartPosition = stream.Position;
}
public static Encoding GetEncoding(this ArchiveEncoding encodingEnum)
{
switch (encodingEnum)
{
case ArchiveEncoding.UTF8:
return(Encoding.UTF8);
case ArchiveEncoding.UTF16:
return(Encoding.Unicode);
default:
throw new ArgumentException(nameof(encodingEnum));
}
}
internal override void Read(BinaryReader reader)
{
Version = reader.ReadUInt16();
Flags = (HeaderFlags)reader.ReadUInt16();
CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
LastModifiedTime = reader.ReadUInt16();
LastModifiedDate = reader.ReadUInt16();
Crc = reader.ReadUInt32();
CompressedSize = reader.ReadUInt32();
UncompressedSize = reader.ReadUInt32();
ushort nameLength = reader.ReadUInt16();
ushort extraLength = reader.ReadUInt16();
byte[] name = reader.ReadBytes(nameLength);
byte[] extra = reader.ReadBytes(extraLength);
if (Flags.HasFlag(HeaderFlags.Efs))
{
Name = ArchiveEncoding.Decode(name);
}
else
{
// Use IBM Code Page 437 (IBM PC character encoding set)
Name = ArchiveEncoding.Decode437(name);
}
LoadExtra(extra);
var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
if (unicodePathExtra != null)
{
Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
}
var zip64ExtraData = Extra.OfType <Zip64ExtendedInformationExtraField>().FirstOrDefault();
if (zip64ExtraData != null)
{
if (CompressedSize == uint.MaxValue)
{
CompressedSize = zip64ExtraData.CompressedSize;
}
if (UncompressedSize == uint.MaxValue)
{
UncompressedSize = zip64ExtraData.UncompressedSize;
}
}
}
/// <summary>
/// Compress entrie[file or directorie] to dest zip file.
/// </summary>
/// <param name="entries">Target entrie[files or directories].</param>
/// <param name="destFile">The dest file.</param>
/// <param name="encoding">Encoding for zip file.</param>
/// <param name="directoryPathInArchive">Directory path in archive of zip file [Not supported this version].</param>
/// <param name="clearBefor">Clear origin file(if exists) befor compress.</param>
/// <param name="progressCallback">Progress callback.</param>
/// <param name="finishedCallback">Finished callback.</param>
public virtual void Compress(IEnumerable <string> entries, string destFile,
Encoding encoding, string directoryPathInArchive = null, bool clearBefor = true,
Action <float> progressCallback = null, Action <bool, string, Exception> finishedCallback = null)
{
try
{
if (clearBefor && File.Exists(destFile))
{
File.Delete(destFile);
}
using (var archive = ZipArchive.Create())
{
var index = 0f;
var count = new List <string>(entries).Count;
foreach (var entry in entries)
{
archive.AddAllFromDirectory(entry);
index++;
var progress = (index / count) * 0.75f;
progressCallback?.Invoke(progress);
}
using (var stream = File.OpenWrite(destFile))
{
var archiveEncoding = new ArchiveEncoding {
Default = encoding
};
var options = new WriterOptions(CompressionType.Deflate)
{
ArchiveEncoding = archiveEncoding
};
archive.SaveTo(stream, options);
}
}
progressCallback?.Invoke(1.0f);
finishedCallback?.Invoke(true, destFile, null);
}
catch (Exception ex)
{
finishedCallback?.Invoke(false, null, ex);
}
}
internal static RarHeader Create(RarCrcBinaryReader reader, ArchiveEncoding archiveEncoding)
{
try
{
RarHeader header = new RarHeader();
header.ArchiveEncoding = archiveEncoding;
reader.Mark();
header.ReadStartFromReader(reader);
header.ReadBytes += reader.CurrentReadByteCount;
return header;
}
catch (EndOfStreamException)
{
return null;
}
}
/// <summary>
/// 压缩文件夹
/// </summary>
/// <param name="sourceFolderPath">待压缩的文件夹路径</param>
/// <param name="targetFilePath">压缩后的文件路径，格式为.zip</param>
public static void ZipFolders(string sourceFolderPath, string targetFilePath)
{
ArchiveEncoding ArchiveEncoding = new ArchiveEncoding();
ArchiveEncoding.Default = Encoding.GetEncoding("utf-8");
WriterOptions zipOptions = new WriterOptions(CompressionType.Deflate);
zipOptions.ArchiveEncoding = ArchiveEncoding;
using (var archive = ZipArchive.Create())
{
archive.AddAllFromDirectory(sourceFolderPath);
using (var zipStream = File.OpenWrite(targetFilePath))
{
archive.SaveTo(zipStream, zipOptions);
}
}
}
public void Tar_Read_One_At_A_Time()
{
var archiveEncoding = new ArchiveEncoding {
Default = Encoding.UTF8,
};
var tarWriterOptions = new TarWriterOptions(CompressionType.None, true)
{
ArchiveEncoding = archiveEncoding,
};
var testBytes = Encoding.UTF8.GetBytes("This is a test.");
using (var memoryStream = new MemoryStream())
{
using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions))
using (var testFileStream = new MemoryStream(testBytes))
{
tarWriter.Write("test1.txt", testFileStream);
testFileStream.Position = 0;
tarWriter.Write("test2.txt", testFileStream);
}
memoryStream.Position = 0;
var numberOfEntries = 0;
using (var archiveFactory = TarArchive.Open(memoryStream))
{
foreach (var entry in archiveFactory.Entries)
{
++numberOfEntries;
using (var tarEntryStream = entry.OpenEntryStream())
using (var testFileStream = new MemoryStream())
{
tarEntryStream.CopyTo(testFileStream);
Assert.Equal(testBytes.Length, testFileStream.Length);
}
}
}
Assert.Equal(2, numberOfEntries);
}
}
/// <summary>
/// 压缩文件
/// </summary>
/// <param name="sourceFilePaths">待压缩的文件路径，可包含单个或多个文件</param>
/// <param name="targetFilePath">压缩后的文件路径，格式为.zip</param>
public static void ZipFiles(IList <string> sourceFilePaths, string targetFilePath)
{
ArchiveEncoding ArchiveEncoding = new ArchiveEncoding();
ArchiveEncoding.Default = Encoding.GetEncoding("utf-8");
WriterOptions zipOptions = new WriterOptions(CompressionType.Deflate);
zipOptions.ArchiveEncoding = ArchiveEncoding;
using (var archive = ZipArchive.Create())
{
foreach (var sourceFilePath in sourceFilePaths)
{
var sourceFile = new FileInfo(sourceFilePath);
archive.AddEntry(sourceFile.Name, sourceFile.OpenRead());
}
using (var zipStream = File.OpenWrite(targetFilePath))
{
archive.SaveTo(zipStream, zipOptions);
}
}
}
private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
{
_headerType = HeaderType.Null;
_isRar5 = isRar5;
ArchiveEncoding = archiveEncoding;
if (IsRar5)
{
HeaderCrc = reader.ReadUInt32();
reader.ResetCrc();
HeaderSize = (int)reader.ReadRarVIntUInt32(3);
reader.Mark();
HeaderCode = reader.ReadRarVIntByte();
HeaderFlags = reader.ReadRarVIntUInt16(2);
if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
{
ExtraSize = reader.ReadRarVIntUInt32();
}
if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
{
AdditionalDataSize = (long)reader.ReadRarVInt();
}
}
else
{
reader.Mark();
HeaderCrc = reader.ReadUInt16();
reader.ResetCrc();
HeaderCode = reader.ReadByte();
HeaderFlags = reader.ReadUInt16();
HeaderSize = reader.ReadInt16();
if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
{
AdditionalDataSize = reader.ReadUInt32();
}
}
}
private IEnumerable <ArchiveEncoding> GetEncodingByMode(ReadFileEncodingType encodingMode)
{
var encList = new List <ArchiveEncoding>();
if (encodingMode == ReadFileEncodingType.S_JIS)
{
var tEnc = new ArchiveEncoding()
{
Default = Encoding.GetEncoding("shift-jis")
};
encList.Add(tEnc);
}
else if (encodingMode == ReadFileEncodingType.UTF_8)
{
var tEnc = new ArchiveEncoding()
{
Default = new UTF8Encoding(false)
};
encList.Add(tEnc);
}
else if (encodingMode == ReadFileEncodingType.UTF_8AndS_JIS)
{
var tEnc = new ArchiveEncoding()
{
Default = new UTF8Encoding(false)
};
encList.Add(tEnc);
tEnc = new ArchiveEncoding()
{
Default = Encoding.GetEncoding("shift-jis")
};
encList.Add(tEnc);
}
return(encList);
}
internal SeekableZipHeaderFactory(string password, ArchiveEncoding archiveEncoding)
: base(StreamingMode.Seekable, password, archiveEncoding)
{
}
private PkwareTraditionalEncryptionData(string password, ArchiveEncoding archiveEncoding)
{
_archiveEncoding = archiveEncoding;
Initialize(password);
}
protected ZipHeaderFactory(StreamingMode mode, string password, ArchiveEncoding archiveEncoding)
{
this._mode = mode;
this._password = password;
this._archiveEncoding = archiveEncoding;
}
internal static RarHeader?TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
{
try
{
return(new RarHeader(reader, isRar5, archiveEncoding));
}
catch (EndOfStreamException)
{
return(null);
}
}
internal static IEnumerable <TarHeader?> ReadHeader(StreamingMode mode, Stream stream, ArchiveEncoding archiveEncoding)
{
while (true)
{
TarHeader?header = null;
try
{
BinaryReader reader = new BinaryReader(stream);
header = new TarHeader(archiveEncoding);
if (!header.Read(reader))
{
yield break;
}
switch (mode)
{
case StreamingMode.Seekable:
{
header.DataStartPosition = reader.BaseStream.Position;
//skip to nearest 512
reader.BaseStream.Position += PadTo512(header.Size);
}
break;
case StreamingMode.Streaming:
{
header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
}
catch
{
header = null;
}
yield return(header);
}
}
public DirectoryEntryHeader(ArchiveEncoding archiveEncoding)
: base(ZipHeaderType.DirectoryEntry, archiveEncoding)
{
}
protected ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
: base(type)
{
Extra = new List <ExtraData>();
ArchiveEncoding = archiveEncoding;
}
internal static IEnumerable <TarEntry> GetEntries(StreamingMode mode, Stream stream,
CompressionType compressionType, ArchiveEncoding archiveEncoding)
{
foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
{
if (h != null)
{
if (mode == StreamingMode.Seekable)
{
yield return(new TarEntry(new TarFilePart(h, stream), compressionType));
}
else
{
yield return(new TarEntry(new TarFilePart(h, null), compressionType));
}
}
}
}
public static void ExportWord(string outputPath, string outputFile, IEnumerable <Datas> datases)
{
//先确定文件数
//根据测区来分文件
var files = datases.GroupBy(a => a.Regionalcode);
var datetime = DateTime.Now;
string date = datetime.Year.ToString() + datetime.Month.ToString("00") + datetime.Day.ToString("00");
List <string> outFiles = new List <string>();
foreach (var f in files)
{
string filename = string.Format("{0}-加密锁授权申请表-{1}-{2}.doc", date, f.ElementAt(0).Compname, f.ElementAt(0).Regionalname);
var destFile = Path.Combine(outputPath, filename);
outFiles.Add(destFile); //将输出文件路径存放
File.Copy(modelDoc, destFile, true); //复制文件
var datas = f.ElementAt(0).Clone() as Datas;
//合并软件名称
string softs = string.Empty;
var gp = f.GroupBy(a => a.Softwarename);
foreach (var g in gp)
{
softs += g.Key + ",";
}
softs = softs.TrimEnd(',');
datas.Softwarename = softs;
Document doc = new Document(destFile);
DocumentBuilder db = new DocumentBuilder(doc);
WriteDoc(doc, db, datas);
//锁编号
string dogCode = string.Empty;
foreach (var d in f)
{
dogCode += d.Dogcode + "；";
}
dogCode = dogCode.TrimEnd('；');
db.MoveToBookmark("dogcode");
var run = new Run(doc, dogCode);
run.Font.Size = 14;
run.Font.Color = System.Drawing.Color.Blue;
db.InsertNode(run);
//备注
string remark = string.Empty;
//区分新领取和非新领取的
var newget = f.Where(p => p.Servicetype.Contains("新领取"));
var oldget = f.Except(newget);
//处理新领取的情况
var services = newget.GroupBy(a => a.Servicetype);
foreach (var s in services)
{
var softtypes = s.GroupBy(a => a.Softwarename);
foreach (var st in softtypes)
{
var dogt = st.GroupBy(a => a.Dogtype);
foreach (var d in dogt)
{
remark += string.Format("{0}{1}{2}个({3})；", s.Key, d.Key, d.Count(), st.Key);
}
}
}
var dt = oldget.GroupBy(a => a.Dogtype);
foreach (var d in dt)
{
var st = d.GroupBy(a => a.Servicetype);
foreach (var s in st)
{
remark += string.Format("{0}{1}{2}个；", d.Key, s.Key, s.Count());
}
}
remark = remark.TrimEnd('；');
db.MoveToBookmark("remark");
db.InsertNode(new Run(doc, remark));
doc.Save(destFile, Aspose.Words.SaveFormat.Doc);
}
//将文件压缩
string output = Path.Combine(outputPath, outputFile);
Stream dst = new FileStream(output, FileMode.Create);
//解决中文乱码问题
ArchiveEncoding ArchiveEncoding = new ArchiveEncoding();
ArchiveEncoding.Default = Encoding.GetEncoding("utf-8");
SharpCompress.Writers.WriterOptions options = new SharpCompress.Writers.WriterOptions(CompressionType.Deflate);
options.ArchiveEncoding = ArchiveEncoding;
using (var archive = ZipArchive.Create())
{
foreach (var f in outFiles)
{
FileInfo fi = new FileInfo(f);
archive.AddEntry(fi.Name, fi.OpenRead(), true);
}
archive.SaveTo(dst, options);
dst.Close();
}
dst.Dispose();
//删除生成的单个文件
foreach (var f in outFiles)
{
File.Delete(f);
}
}
internal SevenZipFilePart(Stream stream, ArchiveDatabase database, int index, CFileItem fileEntry, ArchiveEncoding archiveEncoding)
: base(archiveEncoding)
{
_stream = stream;
_database = database;
Index = index;
Header = fileEntry;
if (Header.HasStream)
{
Folder = database._folders[database._fileIndexToFolderIndexMap[index]];
}
}
private void ReadFromReaderV4(MarkingBinaryReader reader)
{
Flags = HeaderFlags;
IsSolid = HasFlag(FileFlagsV4.SOLID);
WindowSize = IsDirectory ? 0U : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
uint lowUncompressedSize = reader.ReadUInt32();
HostOs = reader.ReadByte();
FileCrc = reader.ReadUInt32();
FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadUInt32());
CompressionAlgorithm = reader.ReadByte();
CompressionMethod = (byte)(reader.ReadByte() - 0x30);
short nameSize = reader.ReadInt16();
FileAttributes = reader.ReadUInt32();
uint highCompressedSize = 0;
uint highUncompressedkSize = 0;
if (HasFlag(FileFlagsV4.LARGE))
{
highCompressedSize = reader.ReadUInt32();
highUncompressedkSize = reader.ReadUInt32();
}
else
{
if (lowUncompressedSize == 0xffffffff)
{
lowUncompressedSize = 0xffffffff;
highUncompressedkSize = int.MaxValue;
}
}
CompressedSize = UInt32To64(highCompressedSize, checked ((uint)AdditionalDataSize));
UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
byte[] fileNameBytes = reader.ReadBytes(nameSize);
const int saltSize = 8;
const int newLhdSize = 32;
switch (HeaderCode)
{
case HeaderCodeV.RAR4_FILE_HEADER:
{
if (HasFlag(FileFlagsV4.UNICODE))
{
int length = 0;
while (length < fileNameBytes.Length &&
fileNameBytes[length] != 0)
{
length++;
}
if (length != nameSize)
{
length++;
FileName = FileNameDecoder.Decode(fileNameBytes, length);
}
else
{
FileName = ArchiveEncoding.Decode(fileNameBytes);
}
}
else
{
FileName = ArchiveEncoding.Decode(fileNameBytes);
}
FileName = ConvertPathV4(FileName);
}
break;
case HeaderCodeV.RAR4_NEW_SUB_HEADER:
{
int datasize = HeaderSize - newLhdSize - nameSize;
if (HasFlag(FileFlagsV4.SALT))
{
datasize -= saltSize;
}
if (datasize > 0)
{
SubData = reader.ReadBytes(datasize);
}
if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
{
RecoverySectors = SubData[8] + (SubData[9] << 8)
+ (SubData[10] << 16) + (SubData[11] << 24);
}
}
break;
}
if (HasFlag(FileFlagsV4.SALT))
{
R4Salt = reader.ReadBytes(saltSize);
}
if (HasFlag(FileFlagsV4.EXT_TIME))
{
// verify that the end of the header hasn't been reached before reading the Extended Time.
// some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
if (RemainingHeaderBytes(reader) >= 2)
{
ushort extendedFlags = reader.ReadUInt16();
FileLastModifiedTime = ProcessExtendedTimeV4(extendedFlags, FileLastModifiedTime, reader, 0);
FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
}
}
}
public TarHeader(ArchiveEncoding archiveEncoding)
{
ArchiveEncoding = archiveEncoding;
}
public LocalEntryHeader(ArchiveEncoding archiveEncoding)
: base(ZipHeaderType.LocalEntry, archiveEncoding)
{
}
