niko
690 lines
16 KiB
C#
690 lines
16 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace ICSharpCode.SharpZipLib.Tar
|
|
{
|
|
// Token: 0x02000034 RID: 52
|
|
public class TarArchive : IDisposable
|
|
{
|
|
// Token: 0x14000001 RID: 1
|
|
// (add) Token: 0x0600017C RID: 380 RVA: 0x000099AD File Offset: 0x000089AD
|
|
// (remove) Token: 0x0600017D RID: 381 RVA: 0x000099C6 File Offset: 0x000089C6
|
|
public event ProgressMessageHandler ProgressMessageEvent;
|
|
|
|
// Token: 0x0600017E RID: 382 RVA: 0x000099E0 File Offset: 0x000089E0
|
|
protected virtual void OnProgressMessageEvent(TarEntry entry, string message)
|
|
{
|
|
ProgressMessageHandler progressMessageEvent = this.ProgressMessageEvent;
|
|
if (progressMessageEvent != null)
|
|
{
|
|
progressMessageEvent(this, entry, message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017F RID: 383 RVA: 0x00009A00 File Offset: 0x00008A00
|
|
protected TarArchive()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000180 RID: 384 RVA: 0x00009A1E File Offset: 0x00008A1E
|
|
protected TarArchive(TarInputStream stream)
|
|
{
|
|
if (stream == null)
|
|
{
|
|
throw new ArgumentNullException("stream");
|
|
}
|
|
this.tarIn = stream;
|
|
}
|
|
|
|
// Token: 0x06000181 RID: 385 RVA: 0x00009A51 File Offset: 0x00008A51
|
|
protected TarArchive(TarOutputStream stream)
|
|
{
|
|
if (stream == null)
|
|
{
|
|
throw new ArgumentNullException("stream");
|
|
}
|
|
this.tarOut = stream;
|
|
}
|
|
|
|
// Token: 0x06000182 RID: 386 RVA: 0x00009A84 File Offset: 0x00008A84
|
|
public static TarArchive CreateInputTarArchive(Stream inputStream)
|
|
{
|
|
if (inputStream == null)
|
|
{
|
|
throw new ArgumentNullException("inputStream");
|
|
}
|
|
TarInputStream tarInputStream = inputStream as TarInputStream;
|
|
TarArchive tarArchive;
|
|
if (tarInputStream != null)
|
|
{
|
|
tarArchive = new TarArchive(tarInputStream);
|
|
}
|
|
else
|
|
{
|
|
tarArchive = TarArchive.CreateInputTarArchive(inputStream, 20);
|
|
}
|
|
return tarArchive;
|
|
}
|
|
|
|
// Token: 0x06000183 RID: 387 RVA: 0x00009ABC File Offset: 0x00008ABC
|
|
public static TarArchive CreateInputTarArchive(Stream inputStream, int blockFactor)
|
|
{
|
|
if (inputStream == null)
|
|
{
|
|
throw new ArgumentNullException("inputStream");
|
|
}
|
|
if (inputStream is TarInputStream)
|
|
{
|
|
throw new ArgumentException("TarInputStream not valid");
|
|
}
|
|
return new TarArchive(new TarInputStream(inputStream, blockFactor));
|
|
}
|
|
|
|
// Token: 0x06000184 RID: 388 RVA: 0x00009AEC File Offset: 0x00008AEC
|
|
public static TarArchive CreateOutputTarArchive(Stream outputStream)
|
|
{
|
|
if (outputStream == null)
|
|
{
|
|
throw new ArgumentNullException("outputStream");
|
|
}
|
|
TarOutputStream tarOutputStream = outputStream as TarOutputStream;
|
|
TarArchive tarArchive;
|
|
if (tarOutputStream != null)
|
|
{
|
|
tarArchive = new TarArchive(tarOutputStream);
|
|
}
|
|
else
|
|
{
|
|
tarArchive = TarArchive.CreateOutputTarArchive(outputStream, 20);
|
|
}
|
|
return tarArchive;
|
|
}
|
|
|
|
// Token: 0x06000185 RID: 389 RVA: 0x00009B24 File Offset: 0x00008B24
|
|
public static TarArchive CreateOutputTarArchive(Stream outputStream, int blockFactor)
|
|
{
|
|
if (outputStream == null)
|
|
{
|
|
throw new ArgumentNullException("outputStream");
|
|
}
|
|
if (outputStream is TarOutputStream)
|
|
{
|
|
throw new ArgumentException("TarOutputStream is not valid");
|
|
}
|
|
return new TarArchive(new TarOutputStream(outputStream, blockFactor));
|
|
}
|
|
|
|
// Token: 0x06000186 RID: 390 RVA: 0x00009B53 File Offset: 0x00008B53
|
|
public void SetKeepOldFiles(bool keepExistingFiles)
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.keepOldFiles = keepExistingFiles;
|
|
}
|
|
|
|
// Token: 0x17000049 RID: 73
|
|
// (get) Token: 0x06000187 RID: 391 RVA: 0x00009B6F File Offset: 0x00008B6F
|
|
// (set) Token: 0x06000188 RID: 392 RVA: 0x00009B8A File Offset: 0x00008B8A
|
|
public bool AsciiTranslate
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.asciiTranslate;
|
|
}
|
|
set
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.asciiTranslate = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000189 RID: 393 RVA: 0x00009BA6 File Offset: 0x00008BA6
|
|
[Obsolete("Use the AsciiTranslate property")]
|
|
public void SetAsciiTranslation(bool translateAsciiFiles)
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.asciiTranslate = translateAsciiFiles;
|
|
}
|
|
|
|
// Token: 0x1700004A RID: 74
|
|
// (get) Token: 0x0600018A RID: 394 RVA: 0x00009BC2 File Offset: 0x00008BC2
|
|
// (set) Token: 0x0600018B RID: 395 RVA: 0x00009BDD File Offset: 0x00008BDD
|
|
public string PathPrefix
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.pathPrefix;
|
|
}
|
|
set
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.pathPrefix = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004B RID: 75
|
|
// (get) Token: 0x0600018C RID: 396 RVA: 0x00009BF9 File Offset: 0x00008BF9
|
|
// (set) Token: 0x0600018D RID: 397 RVA: 0x00009C14 File Offset: 0x00008C14
|
|
public string RootPath
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.rootPath;
|
|
}
|
|
set
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.rootPath = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600018E RID: 398 RVA: 0x00009C30 File Offset: 0x00008C30
|
|
public void SetUserInfo(int userId, string userName, int groupId, string groupName)
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.userId = userId;
|
|
this.userName = userName;
|
|
this.groupId = groupId;
|
|
this.groupName = groupName;
|
|
this.applyUserInfoOverrides = true;
|
|
}
|
|
|
|
// Token: 0x1700004C RID: 76
|
|
// (get) Token: 0x0600018F RID: 399 RVA: 0x00009C69 File Offset: 0x00008C69
|
|
// (set) Token: 0x06000190 RID: 400 RVA: 0x00009C84 File Offset: 0x00008C84
|
|
public bool ApplyUserInfoOverrides
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.applyUserInfoOverrides;
|
|
}
|
|
set
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
this.applyUserInfoOverrides = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004D RID: 77
|
|
// (get) Token: 0x06000191 RID: 401 RVA: 0x00009CA0 File Offset: 0x00008CA0
|
|
public int UserId
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.userId;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004E RID: 78
|
|
// (get) Token: 0x06000192 RID: 402 RVA: 0x00009CBB File Offset: 0x00008CBB
|
|
public string UserName
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.userName;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004F RID: 79
|
|
// (get) Token: 0x06000193 RID: 403 RVA: 0x00009CD6 File Offset: 0x00008CD6
|
|
public int GroupId
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.groupId;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000050 RID: 80
|
|
// (get) Token: 0x06000194 RID: 404 RVA: 0x00009CF1 File Offset: 0x00008CF1
|
|
public string GroupName
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
return this.groupName;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000051 RID: 81
|
|
// (get) Token: 0x06000195 RID: 405 RVA: 0x00009D0C File Offset: 0x00008D0C
|
|
public int RecordSize
|
|
{
|
|
get
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
if (this.tarIn != null)
|
|
{
|
|
return this.tarIn.RecordSize;
|
|
}
|
|
if (this.tarOut != null)
|
|
{
|
|
return this.tarOut.RecordSize;
|
|
}
|
|
return 10240;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000052 RID: 82
|
|
// (set) Token: 0x06000196 RID: 406 RVA: 0x00009D59 File Offset: 0x00008D59
|
|
public bool IsStreamOwner
|
|
{
|
|
set
|
|
{
|
|
if (this.tarIn != null)
|
|
{
|
|
this.tarIn.IsStreamOwner = value;
|
|
return;
|
|
}
|
|
this.tarOut.IsStreamOwner = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000197 RID: 407 RVA: 0x00009D7C File Offset: 0x00008D7C
|
|
[Obsolete("Use Close instead")]
|
|
public void CloseArchive()
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
// Token: 0x06000198 RID: 408 RVA: 0x00009D84 File Offset: 0x00008D84
|
|
public void ListContents()
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
for (;;)
|
|
{
|
|
TarEntry nextEntry = this.tarIn.GetNextEntry();
|
|
if (nextEntry == null)
|
|
{
|
|
break;
|
|
}
|
|
this.OnProgressMessageEvent(nextEntry, null);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000199 RID: 409 RVA: 0x00009DC0 File Offset: 0x00008DC0
|
|
public void ExtractContents(string destinationDirectory)
|
|
{
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
for (;;)
|
|
{
|
|
TarEntry nextEntry = this.tarIn.GetNextEntry();
|
|
if (nextEntry == null)
|
|
{
|
|
break;
|
|
}
|
|
this.ExtractEntry(destinationDirectory, nextEntry);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019A RID: 410 RVA: 0x00009DFC File Offset: 0x00008DFC
|
|
private void ExtractEntry(string destDir, TarEntry entry)
|
|
{
|
|
this.OnProgressMessageEvent(entry, null);
|
|
string text = entry.Name;
|
|
if (Path.IsPathRooted(text))
|
|
{
|
|
text = text.Substring(Path.GetPathRoot(text).Length);
|
|
}
|
|
text = text.Replace('/', Path.DirectorySeparatorChar);
|
|
string text2 = Path.Combine(destDir, text);
|
|
if (entry.IsDirectory)
|
|
{
|
|
TarArchive.EnsureDirectoryExists(text2);
|
|
return;
|
|
}
|
|
string directoryName = Path.GetDirectoryName(text2);
|
|
TarArchive.EnsureDirectoryExists(directoryName);
|
|
bool flag = true;
|
|
FileInfo fileInfo = new FileInfo(text2);
|
|
if (fileInfo.Exists)
|
|
{
|
|
if (this.keepOldFiles)
|
|
{
|
|
this.OnProgressMessageEvent(entry, "Destination file already exists");
|
|
flag = false;
|
|
}
|
|
else if ((fileInfo.Attributes & FileAttributes.ReadOnly) != (FileAttributes)0)
|
|
{
|
|
this.OnProgressMessageEvent(entry, "Destination file already exists, and is read-only");
|
|
flag = false;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
bool flag2 = false;
|
|
Stream stream = File.Create(text2);
|
|
if (this.asciiTranslate)
|
|
{
|
|
flag2 = !TarArchive.IsBinary(text2);
|
|
}
|
|
StreamWriter streamWriter = null;
|
|
if (flag2)
|
|
{
|
|
streamWriter = new StreamWriter(stream);
|
|
}
|
|
byte[] array = new byte[32768];
|
|
for (;;)
|
|
{
|
|
int num = this.tarIn.Read(array, 0, array.Length);
|
|
if (num <= 0)
|
|
{
|
|
break;
|
|
}
|
|
if (flag2)
|
|
{
|
|
int num2 = 0;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
if (array[i] == 10)
|
|
{
|
|
string @string = Encoding.ASCII.GetString(array, num2, i - num2);
|
|
streamWriter.WriteLine(@string);
|
|
num2 = i + 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stream.Write(array, 0, num);
|
|
}
|
|
}
|
|
if (flag2)
|
|
{
|
|
streamWriter.Close();
|
|
return;
|
|
}
|
|
stream.Close();
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019B RID: 411 RVA: 0x00009F6C File Offset: 0x00008F6C
|
|
public void WriteEntry(TarEntry sourceEntry, bool recurse)
|
|
{
|
|
if (sourceEntry == null)
|
|
{
|
|
throw new ArgumentNullException("sourceEntry");
|
|
}
|
|
if (this.isDisposed)
|
|
{
|
|
throw new ObjectDisposedException("TarArchive");
|
|
}
|
|
try
|
|
{
|
|
if (recurse)
|
|
{
|
|
TarHeader.SetValueDefaults(sourceEntry.UserId, sourceEntry.UserName, sourceEntry.GroupId, sourceEntry.GroupName);
|
|
}
|
|
this.WriteEntryCore(sourceEntry, recurse);
|
|
}
|
|
finally
|
|
{
|
|
if (recurse)
|
|
{
|
|
TarHeader.RestoreSetValues();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019C RID: 412 RVA: 0x00009FE0 File Offset: 0x00008FE0
|
|
private void WriteEntryCore(TarEntry sourceEntry, bool recurse)
|
|
{
|
|
string text = null;
|
|
string text2 = sourceEntry.File;
|
|
TarEntry tarEntry = (TarEntry)sourceEntry.Clone();
|
|
if (this.applyUserInfoOverrides)
|
|
{
|
|
tarEntry.GroupId = this.groupId;
|
|
tarEntry.GroupName = this.groupName;
|
|
tarEntry.UserId = this.userId;
|
|
tarEntry.UserName = this.userName;
|
|
}
|
|
this.OnProgressMessageEvent(tarEntry, null);
|
|
if (this.asciiTranslate && !tarEntry.IsDirectory && !TarArchive.IsBinary(text2))
|
|
{
|
|
text = Path.GetTempFileName();
|
|
using (StreamReader streamReader = File.OpenText(text2))
|
|
{
|
|
using (Stream stream = File.Create(text))
|
|
{
|
|
for (;;)
|
|
{
|
|
string text3 = streamReader.ReadLine();
|
|
if (text3 == null)
|
|
{
|
|
break;
|
|
}
|
|
byte[] bytes = Encoding.ASCII.GetBytes(text3);
|
|
stream.Write(bytes, 0, bytes.Length);
|
|
stream.WriteByte(10);
|
|
}
|
|
stream.Flush();
|
|
}
|
|
}
|
|
tarEntry.Size = new FileInfo(text).Length;
|
|
text2 = text;
|
|
}
|
|
string text4 = null;
|
|
if (this.rootPath != null && tarEntry.Name.StartsWith(this.rootPath))
|
|
{
|
|
text4 = tarEntry.Name.Substring(this.rootPath.Length + 1);
|
|
}
|
|
if (this.pathPrefix != null)
|
|
{
|
|
text4 = ((text4 == null) ? (this.pathPrefix + "/" + tarEntry.Name) : (this.pathPrefix + "/" + text4));
|
|
}
|
|
if (text4 != null)
|
|
{
|
|
tarEntry.Name = text4;
|
|
}
|
|
this.tarOut.PutNextEntry(tarEntry);
|
|
if (tarEntry.IsDirectory)
|
|
{
|
|
if (recurse)
|
|
{
|
|
TarEntry[] directoryEntries = tarEntry.GetDirectoryEntries();
|
|
for (int i = 0; i < directoryEntries.Length; i++)
|
|
{
|
|
this.WriteEntryCore(directoryEntries[i], recurse);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (Stream stream2 = File.OpenRead(text2))
|
|
{
|
|
byte[] array = new byte[32768];
|
|
for (;;)
|
|
{
|
|
int num = stream2.Read(array, 0, array.Length);
|
|
if (num <= 0)
|
|
{
|
|
break;
|
|
}
|
|
this.tarOut.Write(array, 0, num);
|
|
}
|
|
}
|
|
if (text != null && text.Length > 0)
|
|
{
|
|
File.Delete(text);
|
|
}
|
|
this.tarOut.CloseEntry();
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019D RID: 413 RVA: 0x0000A228 File Offset: 0x00009228
|
|
public void Dispose()
|
|
{
|
|
this.Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
// Token: 0x0600019E RID: 414 RVA: 0x0000A238 File Offset: 0x00009238
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!this.isDisposed)
|
|
{
|
|
this.isDisposed = true;
|
|
if (disposing)
|
|
{
|
|
if (this.tarOut != null)
|
|
{
|
|
this.tarOut.Flush();
|
|
this.tarOut.Close();
|
|
}
|
|
if (this.tarIn != null)
|
|
{
|
|
this.tarIn.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019F RID: 415 RVA: 0x0000A288 File Offset: 0x00009288
|
|
public virtual void Close()
|
|
{
|
|
this.Dispose(true);
|
|
}
|
|
|
|
// Token: 0x060001A0 RID: 416 RVA: 0x0000A294 File Offset: 0x00009294
|
|
~TarArchive()
|
|
{
|
|
this.Dispose(false);
|
|
}
|
|
|
|
// Token: 0x060001A1 RID: 417 RVA: 0x0000A2C4 File Offset: 0x000092C4
|
|
private static void EnsureDirectoryExists(string directoryName)
|
|
{
|
|
if (!Directory.Exists(directoryName))
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(directoryName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new TarException("Exception creating directory '" + directoryName + "', " + ex.Message, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001A2 RID: 418 RVA: 0x0000A310 File Offset: 0x00009310
|
|
private static bool IsBinary(string filename)
|
|
{
|
|
using (FileStream fileStream = File.OpenRead(filename))
|
|
{
|
|
int num = Math.Min(4096, (int)fileStream.Length);
|
|
byte[] array = new byte[num];
|
|
int num2 = fileStream.Read(array, 0, num);
|
|
for (int i = 0; i < num2; i++)
|
|
{
|
|
byte b = array[i];
|
|
if (b < 8 || (b > 13 && b < 32) || b == 255)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x040000E1 RID: 225
|
|
private bool keepOldFiles;
|
|
|
|
// Token: 0x040000E2 RID: 226
|
|
private bool asciiTranslate;
|
|
|
|
// Token: 0x040000E3 RID: 227
|
|
private int userId;
|
|
|
|
// Token: 0x040000E4 RID: 228
|
|
private string userName = string.Empty;
|
|
|
|
// Token: 0x040000E5 RID: 229
|
|
private int groupId;
|
|
|
|
// Token: 0x040000E6 RID: 230
|
|
private string groupName = string.Empty;
|
|
|
|
// Token: 0x040000E7 RID: 231
|
|
private string rootPath;
|
|
|
|
// Token: 0x040000E8 RID: 232
|
|
private string pathPrefix;
|
|
|
|
// Token: 0x040000E9 RID: 233
|
|
private bool applyUserInfoOverrides;
|
|
|
|
// Token: 0x040000EA RID: 234
|
|
private TarInputStream tarIn;
|
|
|
|
// Token: 0x040000EB RID: 235
|
|
private TarOutputStream tarOut;
|
|
|
|
// Token: 0x040000EC RID: 236
|
|
private bool isDisposed;
|
|
}
|
|
}
|