Csdrhrt

Old question, but I was struggling with it today so here's my 2c. The 7zip commandline tool "7z.exe" (I have v9.22 installed) can write to stdout and read from stdin so you can do without the intermediate tar file by using a pipe:

7z x "somename.tar.gz" -so | 7z x -aoa -si -ttar -o"somename"

Where:

x     = Extract with full paths command

-so   = write to stdout switch

-si   = read from stdin switch

-aoa  = Overwrite all existing files without prompt.

-ttar = Treat the stdin byte stream as a TAR file

-o    = output directory

See the help file (7-zip.chm) in the install directory for more info on the command line commands and switches.

You can create a context menu entry for .tar.gz/.tgz files that calls the above command using regedit or a 3rd party tool like stexbar.

Starting with 7-zip 9.04 there is a command-line option to do the combined extraction without using intermediate storage for the plain .tar file:

7z x -tgzip -so theinputfile.tgz | 7z x -si -ttar

-tgzip is needed if the input file is named .tgz instead of .tar.gz.

You're using Windows XP, so you should have Windows Scripting Host installed by default. With that being said, here's a WSH JScript script to do what you need. Just copy the code to a file name xtract.bat or something along those lines (Can be whatever as long as it has the extension .bat), and run:

xtract.bat example.tar.gz

By default, the script will check the folder of the script, as well as your system's PATH environment variable for 7z.exe. If you want to change how it looks for stuff, you can change the SevenZipExe variable at the top of the script to whatever you want the executable name to be. (For instance, 7za.exe or 7z-real.exe) You can also set a default directory for the executable by changing SevenZipDir. So if 7z.exe is at C:Windowssystem327z.exe, you'd put:

var SevenZipDir = "C:\Windows\system32";

Anyways, here's the script:

@set @junk=1 /* vim:set ft=javascript:

@echo off

cscript //nologo //e:jscript "%~dpn0.bat" %*

goto :eof

*/

/* Settings */

var SevenZipDir = undefined;

var SevenZipExe = "7z.exe";

var ArchiveExts = ["zip", "tar", "gz", "bzip", "bz", "tgz", "z", "7z", "bz2", "rar"]



/* Multi-use instances */

var WSH = new ActiveXObject("WScript.Shell");

var FSO = new ActiveXObject("Scripting.FileSystemObject");

var __file__ = WScript.ScriptFullName;

var __dir__ = FSO.GetParentFolderName(__file__);

var PWD = WSH.CurrentDirectory;



/* Prototypes */

(function(obj) {

    obj.has = function object_has(key) {

        return defined(this[key]);

    };

    return obj;

})(this.Object.prototype);



(function(str) {

    str.trim = function str_trim() {

        return this.replace(/^ss*/, '').replace(/ss*$/, '');

    };

})(this.String.prototype);



(function(arr) {

    arr.contains = function arr_contains(needle) {

        for (var i in this) {

            if (this[i] == needle) {

                return true;

            }

        }

        return false;

    }

})(this.Array.prototype);



/* Utility functions */

function defined(obj)

{

    return typeof(obj) != "undefined";

}



function emptyStr(obj)

{

    return !(defined(obj) && String(obj).length);

}



/* WSH-specific Utility Functions */

function echo()

{

    if(!arguments.length) return;

    var msg = "";

    for (var n = 0; n < arguments.length; n++) {

        msg += arguments[n];

        msg += " ";

    }

    if(!emptyStr(msg))

        WScript.Echo(msg);

}



function fatal(msg)

{

    echo("Fatal Error:", msg);

    WScript.Quit(1);

}



function findExecutable()

{

    // This function searches the directories in;

    // the PATH array for the specified file name;

    var dirTest = emptyStr(SevenZipDir) ? __dir__ : SevenZipDir;

    var exec = SevenZipExe;

    var strTestPath = FSO.BuildPath(dirTest, exec);

    if (FSO.FileExists(strTestPath))

        return FSO.GetAbsolutePathName(strTestPath);



    var arrPath = String(

            dirTest + ";" + 

            WSH.ExpandEnvironmentStrings("%PATH%")

        ).split(";");



    for(var i in arrPath) {

        // Skip empty directory values, caused by the PATH;

        // variable being terminated with a semicolon;

        if (arrPath[i] == "")

            continue;



        // Build a fully qualified path of the file to test for;

        strTestPath = FSO.BuildPath(arrPath[i], exec);



        // Check if (that file exists;

        if (FSO.FileExists(strTestPath))

            return FSO.GetAbsolutePathName(strTestPath);

    }

    return "";

}



function readall(oExec)

{

    if (!oExec.StdOut.AtEndOfStream)

      return oExec.StdOut.ReadAll();



    if (!oExec.StdErr.AtEndOfStream)

      return oExec.StdErr.ReadAll();



    return -1;

}



function xtract(exec, archive)

{

    var splitExt = /^(.+).(w+)$/;

    var strTmp = FSO.GetFileName(archive);

    WSH.CurrentDirectory = FSO.GetParentFolderName(archive);

    while(true) {

        var pathParts = splitExt.exec(strTmp);

        if(!pathParts) {

            echo("No extension detected for", strTmp + ".", "Skipping..");

            break;

        }



        var ext = pathParts[2].toLowerCase();

        if(!ArchiveExts.contains(ext)) {

            echo("Extension", ext, "not recognized. Skipping.");

            break;

        }



        echo("Extracting", strTmp + "..");

        var oExec = WSH.Exec('"' + exec + '" x -bd "' + strTmp + '"');

        var allInput = "";

        var tryCount = 0;



        while (true)

        {

            var input = readall(oExec);

            if (-1 == input) {

                if (tryCount++ > 10 && oExec.Status == 1)

                    break;

                WScript.Sleep(100);

             } else {

                  allInput += input;

                  tryCount = 0;

            }

        }



        if(oExec. ExitCode!= 0) {

            echo("Non-zero return code detected.");

            break;

        }



        WScript.Echo(allInput);



        strTmp = pathParts[1];

        if(!FSO.FileExists(strTmp))

            break;

    }

    WSH.CurrentDirectory = PWD;

}



function printUsage()

{

    echo("Usage:rn", __file__, "archive1 [archive2] ...");

    WScript.Quit(0);

}



function main(args)

{

    var exe = findExecutable();

    if(emptyStr(exe))

        fatal("Could not find 7zip executable.");



    if(!args.length || args(0) == "-h" || args(0) == "--help" || args(0) == "/?")

        printUsage();



    for (var i = 0; i < args.length; i++) {

        var archive = FSO.GetAbsolutePathName(args(i));

        if(!FSO.FileExists(archive)) {

            echo("File", archive, "does not exist. Skipping..");

            continue;

        }

        xtract(exe, archive);

    }

    echo("rnDone.");

}



main(WScript.Arguments.Unnamed);

As you can see 7-Zip is not very good at this. People have been asking for
tarball atomic operation since 2009. Here is a small program
(490 KB) in Go that can do it, I compiled it for you.

package main

import (

  "archive/tar"

  "compress/gzip"

  "flag"

  "fmt"

  "io"

  "os"

  "strings"

 )



func main() {

  flag.Parse() // get the arguments from command line

  sourcefile := flag.Arg(0)

  if sourcefile == "" {

    fmt.Println("Usage : go-untar sourcefile.tar.gz")

    os.Exit(1)

  }

  file, err := os.Open(sourcefile)

  if err != nil {

    fmt.Println(err)

    os.Exit(1)

  }

  defer file.Close()

  var fileReader io.ReadCloser = file

  // just in case we are reading a tar.gz file,

  // add a filter to handle gzipped file

  if strings.HasSuffix(sourcefile, ".gz") {

    if fileReader, err = gzip.NewReader(file); err != nil {

      fmt.Println(err)

      os.Exit(1)

    }

    defer fileReader.Close()

  }

  tarBallReader := tar.NewReader(fileReader)

  // Extracting tarred files

  for {

    header, err := tarBallReader.Next()

    if err != nil {

      if err == io.EOF {

        break

      }

      fmt.Println(err)

      os.Exit(1)

    }

    // get the individual filename and extract to the current directory

    filename := header.Name

    switch header.Typeflag {

    case tar.TypeDir:

      // handle directory

      fmt.Println("Creating directory :", filename)

      // or use 0755 if you prefer

      err = os.MkdirAll(filename, os.FileMode(header.Mode))

      if err != nil {

        fmt.Println(err)

        os.Exit(1)

      }

    case tar.TypeReg:

      // handle normal file

      fmt.Println("Untarring :", filename)

      writer, err := os.Create(filename)

      if err != nil {

        fmt.Println(err)

        os.Exit(1)

      }

      io.Copy(writer, tarBallReader)

      err = os.Chmod(filename, os.FileMode(header.Mode))

      if err != nil {

        fmt.Println(err)

        os.Exit(1)

      }

      writer.Close()

    default:

      fmt.Printf("Unable to untar type : %c in file %s", header.Typeflag,

      filename)

    }

  }

}

7za is work properly as below:

7za.exe x D:pkg-tempProd-Rtx-Service.tgz -so | 7za.exe x -si -ttar -oD:pkg-tempProd-Rtx-Service