using System;
using System.IO;
using ICSharpCode.SharpZipLib.Core;
using ICSharpCode.SharpZipLib.GZip;

/// <summary>
// Extracts the file contained within a GZip to the target dir.
// A GZip can contain only one file, which by default is named the same as the GZip except
// without the extension.
/// </summary>
public void ExtractGZipSample(string gzipFileName, string targetDir)
{
    // Use a 4K buffer. Any larger is a waste.    
    byte[ ] dataBuffer = new byte[4096];

    using (System.IO.Stream fs = new FileStream(gzipFileName, FileMode.Open, FileAccess.Read))
    {
        using (GZipInputStream gzipStream = new GZipInputStream(fs))
        {
            // Change this to your needs
            string fnOut = Path.Combine(targetDir, Path.GetFileNameWithoutExtension(gzipFileName));

            using (FileStream fsOut = File.Create(fnOut))
            {
                StreamUtils.Copy(gzipStream, fsOut, dataBuffer);
            }
        }
    }
}

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Tar;

public void ExtractTar(String tarFileName, String destFolder)
{
    Stream inStream = File.OpenRead(tarFileName);

    TarArchive tarArchive = TarArchive.CreateInputTarArchive(inStream);
    tarArchive.ExtractContents(destFolder);
    tarArchive.Close();

    inStream.Close();
}

using ICSharpCode.SharpZipLib.GZip;
using ICSharpCode.SharpZipLib.Tar;

// example: ExtractTGZ(@"c:\temp\test.tar.gz", @"C:\DestinationFolder")
public void ExtractTGZ(String gzArchiveName, String destFolder)
{
    Stream inStream = File.OpenRead(gzArchiveName);
    Stream gzipStream = new GZipInputStream(inStream);

    TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
    tarArchive.ExtractContents(destFolder);
    tarArchive.Close();

    gzipStream.Close();
    inStream.Close();
}

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Tar;

/// </summary>
// Iterates through each file entry within the supplied tar,
// extracting them to the nominated folder.
/// </summary>
public void ExtractTarByEntry(string tarFileName, string targetDir, bool asciiTranslate)
{
    using (FileStream fsIn = new FileStream(tarFileName, FileMode.Open, FileAccess.Read))
    {
        TarInputStream tarIn = new TarInputStream(fsIn);
        TarEntry tarEntry;
        while ((tarEntry = tarIn.GetNextEntry()) != null)
        {
            if (tarEntry.IsDirectory)
                continue;

            // Converts the unix forward slashes in the filenames to windows backslashes
            string name = tarEntry.Name.Replace('/', Path.DirectorySeparatorChar);

            // Remove any root e.g. '\' because a PathRooted filename defeats Path.Combine
            if (Path.IsPathRooted(name))
                name = name.Substring(Path.GetPathRoot(name).Length);

            // Apply further name transformations here as necessary
            string outName = Path.Combine(targetDir, name);

            string directoryName = Path.GetDirectoryName(outName);

            // Does nothing if directory exists
            Directory.CreateDirectory(directoryName);

            FileStream outStr = new FileStream(outName, FileMode.Create);

            if (asciiTranslate)
                CopyWithAsciiTranslate(tarIn, outStr);
            else
                tarIn.CopyEntryContents(outStr);

            outStr.Close();

            // Set the modification date/time. This approach seems to solve timezone issues.
            DateTime myDt = DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc);
            File.SetLastWriteTime(outName, myDt);
        }

        tarIn.Close();
    }
}

private void CopyWithAsciiTranslate(TarInputStream tarIn, Stream outStream)
{
    byte[ ] buffer = new byte[4096];
    bool isAscii = true;
    bool cr = false;

    int numRead = tarIn.Read(buffer, 0, buffer.Length);
    int maxCheck = Math.Min(200, numRead);
    for (int i = 0; i < maxCheck; i++)
    {
        byte b = buffer[i];
        if (b < 8 || (b > 13 && b < 32) || b == 255)
        {
            isAscii = false;
            break;
        }
    }

    while (numRead > 0)
    {
        if (isAscii)
        {
            // Convert LF without CR to CRLF. Handle CRLF split over buffers.
            for (int i = 0; i < numRead; i++)
            {
                byte b = buffer[i];     // assuming plain Ascii and not UTF-16
                if (b == 10 && !cr)     // LF without CR
                    outStream.WriteByte(13);
                cr = (b == 13);

                outStream.WriteByte(b);
            }
        }
        else
            outStream.Write(buffer, 0, numRead);

        numRead = tarIn.Read(buffer, 0, buffer.Length);
    }
}

using System;
using System.IO;
using ICSharpCode.SharpZipLib.GZip;
using ICSharpCode.SharpZipLib.Tar;

//  example: CreateTarGZ(@"c:\temp\gzip-test.tar.gz", @"c:\data");
private void CreateTarGZ(string tgzFilename, string sourceDirectory)
{
    Stream outStream = File.Create(tgzFilename);
    Stream gzoStream = new GZipOutputStream(outStream);
    TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzoStream);

    // Note that the RootPath is currently case sensitive and must be forward slashes e.g. "c:/temp"
    // and must not end with a slash, otherwise cuts off first char of filename
    // This is scheduled for fix in next release
    tarArchive.RootPath = sourceDirectory.Replace('\\', '/');
    if (tarArchive.RootPath.EndsWith("/"))
        tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1);

    AddDirectoryFilesToTar(tarArchive, sourceDirectory, true);

    tarArchive.Close();
}

private void AddDirectoryFilesToTar(TarArchive tarArchive, string sourceDirectory, bool recurse)
{
    // Optionally, write an entry for the directory itself.
    // Specify false for recursion here if we will add the directory's files individually.
    TarEntry tarEntry = TarEntry.CreateEntryFromFile(sourceDirectory);
    tarArchive.WriteEntry(tarEntry, false);

    // Write each file to the tar.
    string[] filenames = Directory.GetFiles(sourceDirectory);
    foreach (string filename in filenames)
    {
        tarEntry = TarEntry.CreateEntryFromFile(filename);
        tarArchive.WriteEntry(tarEntry, true);
    }

    if (recurse)
    {
        string[] directories = Directory.GetDirectories(sourceDirectory);
        foreach (string directory in directories)
            AddDirectoryFilesToTar(tarArchive, directory, recurse);
    }
}

using System;
using System.IO;
using ICSharpCode.SharpZipLib.Tar;

public void TarCreateFromStream()
{
    // Create an output stream. Does not have to be disk, could be MemoryStream etc.
    string tarOutFn = @"c:\temp\test.tar";
    Stream outStream = File.Create(tarOutFn);

    // If you wish to create a .Tar.GZ (.tgz):
    // - set the filename above to a ".tar.gz",
    // - create a GZipOutputStream here
    // - change "new TarOutputStream(outStream)" to "new TarOutputStream(gzoStream)"
    // Stream gzoStream = new GZipOutputStream(outStream);
    // gzoStream.SetLevel(3); // 1 - 9, 1 is best speed, 9 is best compression

    TarOutputStream tarOutputStream = new TarOutputStream(outStream);

    CreateTarManually(tarOutputStream, @"c:\temp\debug");

    // Closing the archive also closes the underlying stream.
    // If you don't want this (e.g. writing to memorystream), set tarOutputStream.IsStreamOwner = false
    tarOutputStream.Close();
}

private void CreateTarManually(TarOutputStream tarOutputStream, string sourceDirectory)
{
    // Optionally, write an entry for the directory itself.
    TarEntry tarEntry = TarEntry.CreateEntryFromFile(sourceDirectory);
    tarOutputStream.PutNextEntry(tarEntry);

    // Write each file to the tar.
    string[] filenames = Directory.GetFiles(sourceDirectory);

    foreach (string filename in filenames)
    {
        // You might replace these 3 lines with your own stream code

        using (Stream inputStream = File.OpenRead(filename))
        {
            string tarName = filename.Substring(3); // strip off "C:\"

            long fileSize = inputStream.Length;

            // Create a tar entry named as appropriate. You can set the name to anything,
            // but avoid names starting with drive or UNC.
            TarEntry entry = TarEntry.CreateTarEntry(tarName);

            // Must set size, otherwise TarOutputStream will fail when output exceeds.
            entry.Size = fileSize;

            // Add the entry to the tar stream, before writing the data.
            tarOutputStream.PutNextEntry(entry);

            // this is copied from TarArchive.WriteEntryCore
            byte[] localBuffer = new byte[32 * 1024];
            while (true)
            {
                int numRead = inputStream.Read(localBuffer, 0, localBuffer.Length);
                if (numRead <= 0)
                    break;

                tarOutputStream.Write(localBuffer, 0, numRead);
            }
        }
        tarOutputStream.CloseEntry();
    }

    // Recurse. Delete this if unwanted.

    string[] directories = Directory.GetDirectories(sourceDirectory);
    foreach (string directory in directories)
        CreateTarManually(tarOutputStream, directory);
}