public bool Write(InternalWriteArchiveEntry _entry, string destFolder)
{
string fileName = InternalWriteArchiveEntry.GetFileName(_entry.FileName);
string fullPathToFile = Path.Combine(destFolder, fileName);
string root = Path.GetDirectoryName(fullPathToFile);
if (Directory.CreateDirectory(root) != null)
{
using (FileStream fs = new FileStream(fullPathToFile, FileMode.Create))
{
if (_entry.Data != null)
{
var data = _entry.Data.Where(g => g != '\0').ToArray();
fs.Write(data, 0, data.Length);
}
}
if ((_entry.ExtractFlags & (uint)ExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
File.SetLastWriteTimeUtc(fullPathToFile, _entry.mTime);
}
return true;
}
return false;
}
public override void ReadMetadataEntry()
{
_archiveEntry.Dev = _entry.c_dev.ToString();
_archiveEntry.INode = _entry.c_ino.ToString();
// Type, Permission
long mode = _entry.c_mode;
_archiveEntry.ArchiveType = InternalWriteArchiveEntry.GetArchiveEntryType(mode);
_archiveEntry.Permission = InternalWriteArchiveEntry.GetPermission(mode);
_archiveEntry.Uid = _entry.c_uid;
_archiveEntry.Gid = _entry.c_gid;
unsafe
{
fixed(ushort *pointer = _entry.c_mtime)
{
byte[] array = GetByteArrayFromFixedArray(pointer, 2);
_archiveEntry.mTime = ((long)BitConverter.ToInt32(array, 0)).ToUnixTime();
}
}
_archiveEntry.nLink = _entry.c_nlink;
// rDev
_archiveEntry.rDev = _entry.c_rdev;
_archiveEntry.ExtractFlags = _extractFlags;
}
public override bool Write(string destFolder)
{
string fileName = InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName);
string fullPathToFile = Path.Combine(destFolder, fileName);
string root = Path.GetDirectoryName(fullPathToFile);
if (Directory.CreateDirectory(root) != null)
{
using (FileStream fs = new FileStream(fullPathToFile, FileMode.Create))
{
if (_internalEntry.Data != null)
{
var data = _internalEntry.Data.Where(g => g != '\0').ToArray();
fs.Write(data, 0, data.Length);
}
}
if ((_internalEntry.ExtractFlags & (uint)CpioExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
File.SetLastWriteTimeUtc(fullPathToFile, _internalEntry.mTime);
}
return(true);
}
return(false);
}
string IArchiveEntryWriter.PostExtractEntryToDisk(string destFolder, List <IReadableCPIOArchiveEntry> entries)
{
if (_internalEntry.nLink > 0 && !_internalEntry.IsExtractToDisk)
{
if (IsPostExtractEntry())
{
switch (_internalEntry.ArchiveType)
{
case ArchiveEntryType.FILE:
{
var hardLinkFiles = entries.Where(a => a.INode == _readableArchiveEntry.INode);
ExtractHardlinkFiles(destFolder, hardLinkFiles.ToList());
}
break;
case ArchiveEntryType.SYMBOLIC_LINK:
{
_readableArchiveEntry.Writer.WriteEntryToDisk(destFolder);
}
break;
default:
throw new Exception("Not expected type of entry");
}
}
else
{
throw new Exception("The entry must be saved to disk already!");
}
}
return(InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName));
}
public override bool Write(string destFolder)
{
string fileName = InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName);
string fullPathToFile = Path.Combine(destFolder, fileName);
string root = Path.GetDirectoryName(fullPathToFile);
if (Directory.CreateDirectory(root) != null)
{
string targetFile = InternalWriteArchiveEntry.GetTargetFileToLink(_internalEntry.Data);
string fullPathToTargetFile = Path.Combine(destFolder, targetFile);
if (WindowsNativeLibrary.CreateSymbolicLink(fullPathToFile, fullPathToTargetFile, SYMBOLIC_LINK_FLAG.File))
{
if ((_internalEntry.ExtractFlags & (uint)CpioExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
SetSymLinkLastWriteTime(fullPathToFile, _internalEntry.mTime);
}
return(true);
}
else
{
throw new Exception(string.Format("Symbolic link for file {0} no created. Win32Error: {1}", fullPathToFile, Marshal.GetLastWin32Error()));
}
}
return(false);
}
public bool Write(InternalWriteArchiveEntry entry, string destFolder)
{
string fileName = InternalWriteArchiveEntry.GetFileName(entry.FileName);
string fullPathToFile = Path.Combine(destFolder, fileName);
string root = Path.GetDirectoryName(fullPathToFile);
if (Directory.CreateDirectory(root) != null)
{
string targetFile = InternalWriteArchiveEntry.GetTargetFileToLink(entry.Data);
string fullPathToTargetFile = Path.Combine(destFolder, targetFile);
if (WindowsNativeLibrary.CreateSymbolicLink(fullPathToFile, fullPathToTargetFile, 0))
{
if ((entry.ExtractFlags & (uint)ExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
SetSymLinkLastWriteTime(fullPathToFile, entry.mTime);
}
return true;
}
else
{
Console.WriteLine("Symbolic link for file {0} no created. Win32Error: {1}", fullPathToFile, Marshal.GetLastWin32Error());
return false;
}
}
return false;
}
/// <summary>
/// extract hardlink files
/// </summary>
/// <param name="destFolder"></param>
/// <param name="archiveEntries"></param>
/// <returns></returns>
private void ExtractHardlinkFiles(string destFolder, List <IReadableCPIOArchiveEntry> archiveEntries)
{
var originalEntry = archiveEntries.FirstOrDefault(a => a.DataSize > 0);
if (originalEntry == null)
{
throw new Exception("Not found file with data for creating hardlink file");
}
originalEntry.Writer.WriteEntryToDisk(destFolder);
archiveEntries.Remove(originalEntry);
foreach (var entry in archiveEntries)
{
(entry.Writer as HardLinkEntryWriter).OriginalFilePath = InternalWriteArchiveEntry.GetFileName(originalEntry.FileName);
entry.Writer.WriteEntryToDisk(destFolder);
}
}
string IArchiveEntryWriter.ExtractEntryToDisk(string destFolder)
{
if (_internalEntry.nLink > 0 && !_internalEntry.IsExtractToDisk)
{
if (IsPostExtractEntry())
{
return(InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName));
}
else
{
return(_readableArchiveEntry.Writer.WriteEntryToDisk(destFolder));
}
}
else
{
return(null);
}
}
public override bool Write(string destFolder)
{
string fileName = InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName);
string fullPathToFile = Path.Combine(destFolder, fileName);
string root = Path.GetDirectoryName(fullPathToFile);
if (Directory.CreateDirectory(root) != null)
{
if (OriginalFilePath == null)
{
// write as simple file
using (FileStream fs = new FileStream(fullPathToFile, FileMode.Create))
{
if (_internalEntry.Data != null)
{
var data = _internalEntry.Data.Where(g => g != '\0').ToArray();
fs.Write(data, 0, data.Length);
}
}
return(true);
}
else
{
string fullPathToTargetFile = Path.Combine(destFolder, OriginalFilePath);
if (WindowsNativeLibrary.CreateHardLink(fullPathToFile, fullPathToTargetFile, IntPtr.Zero))
{
if ((_internalEntry.ExtractFlags & (uint)CpioExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
File.SetLastWriteTimeUtc(fullPathToFile, _internalEntry.mTime);
}
return(true);
}
else
{
throw new Exception(string.Format("Hardlink for file {0} no created. Win32Error: {1}", fullPathToFile, Marshal.GetLastWin32Error()));
}
}
}
return(false);
}
public override bool Write(string destFolder)
{
string dir = InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName);
var d = Directory.GetParent(dir);
string fullPathToDir = Path.Combine(destFolder, dir);
if (Directory.CreateDirectory(fullPathToDir) != null)
{
if ((_internalEntry.ExtractFlags & (uint)CpioExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
string currentDir = fullPathToDir;
string _dir = dir;
do
{
Directory.SetLastWriteTimeUtc(currentDir, _internalEntry.mTime);
_dir = Path.GetDirectoryName(_dir);
currentDir = Path.GetDirectoryName(currentDir);
}while (!string.IsNullOrEmpty(_dir) && _dir != ".");
}
return(true);
}
return(false);
}
public bool Write(InternalWriteArchiveEntry _entry, string destFolder)
{
string dir = InternalWriteArchiveEntry.GetFileName(_entry.FileName);
var d = Directory.GetParent(dir);
string fullPathToDir = Path.Combine(destFolder, dir);
if (Directory.CreateDirectory(fullPathToDir) != null)
{
if ((_entry.ExtractFlags & (uint)ExtractFlags.ARCHIVE_EXTRACT_TIME) > 0)
{
string currentDir = fullPathToDir;
string _dir = dir;
do
{
Directory.SetLastWriteTimeUtc(currentDir, _entry.mTime);
_dir = Path.GetDirectoryName(_dir);
currentDir = Path.GetDirectoryName(currentDir);
}
while (!string.IsNullOrEmpty(_dir) && _dir != ".");
}
return true;
}
return false;
}
public override void ReadMetadataEntry()
{
unsafe
{
byte[] majorBuffer;
// Dev
fixed(byte *pointer = _entry.c_dev)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.Dev = GetValueFromOctalValue(majorBuffer).ToString();
// Ino
fixed(byte *pointer = _entry.c_ino)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.INode = GetValueFromOctalValue(majorBuffer).ToString();
// Type, Permission
fixed(byte *pointer = _entry.c_mode)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
long mode = (long)GetValueFromOctalValue(majorBuffer);
_archiveEntry.ArchiveType = InternalWriteArchiveEntry.GetArchiveEntryType(mode);
_archiveEntry.Permission = InternalWriteArchiveEntry.GetPermission(mode);
// Uid
fixed(byte *pointer = _entry.c_uid)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.Uid = (int)GetValueFromOctalValue(majorBuffer);
// Gid
fixed(byte *pointer = _entry.c_gid)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.Gid = (int)GetValueFromOctalValue(majorBuffer);
// mTime
fixed(byte *pointer = _entry.c_mtime)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 11);
}
_archiveEntry.mTime = ((long)(GetValueFromOctalValue(majorBuffer))).ToUnixTime();
// nLink
fixed(byte *pointer = _entry.c_nlink)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.nLink = (long)GetValueFromOctalValue(majorBuffer);
// rDev
fixed(byte *pointer = _entry.c_rdev)
{
majorBuffer = GetByteArrayFromFixedArray(pointer, 6);
}
_archiveEntry.rDev = (int)GetValueFromOctalValue(majorBuffer);
_archiveEntry.ExtractFlags = _extractFlags;
}
}
public DirectoryEntryWriter(InternalWriteArchiveEntry internalEntry, IReadableCPIOArchiveEntry readableArchiveEntry)
: base(internalEntry, readableArchiveEntry)
{
}
public SymbolicLinkEntryWriter(InternalWriteArchiveEntry internalEntry, IReadableCPIOArchiveEntry readableArchiveEntry)
: base(internalEntry, readableArchiveEntry)
{
}
public bool IsPostExtractEntry(InternalWriteArchiveEntry _entry)
{
return true;
}
string IArchiveEntryWriter.WriteEntryToDisk(string destFolder)
{
_internalEntry.IsExtractToDisk = Write(destFolder);
return(_internalEntry.IsExtractToDisk ? InternalWriteArchiveEntry.GetFileName(_internalEntry.FileName) : null);
}
public AbstractArchiveEntryWriter(InternalWriteArchiveEntry internalEntry, IReadableCPIOArchiveEntry readableArchiveEntry)
{
_internalEntry = internalEntry;
_readableArchiveEntry = readableArchiveEntry;
}
