Some formatting updates (ran the code through indent)

 -Erik

1 files changed, 932 insertions, 925 deletions

diff --git a/tar.c b/tar.c
index 6496231ae..87b5d2176 100644
--- a/tar.c
+++ b/tar.c
@@ -1,3 +1,4 @@
+/* vi: set sw=4 ts=4: */
 /*
  * Mini tar implementation for busybox based on code taken from sash.
  *
@@ -40,27 +41,29 @@
 #include <utime.h>
 #include <sys/types.h>
 #include <sys/sysmacros.h>
-#include <sys/param.h>          /* for PATH_MAX */
+#include <sys/param.h>                  /* for PATH_MAX */
 
 
 #ifdef BB_FEATURE_TAR_CREATE
 
 static const char tar_usage[] =
-"tar -[cxtvOf] [tarFileName] [FILE] ...\n\n"
-"Create, extract, or list files from a tar file.\n\n"
-"Options:\n"
-"\tc=create, x=extract, t=list contents, v=verbose,\n"
-"\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
+        "tar -[cxtvOf] [tarFileName] [FILE] ...\n\n"
+        "Create, extract, or list files from a tar file.\n\n"
+        "Options:\n"
+
+        "\tc=create, x=extract, t=list contents, v=verbose,\n"
+        "\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
 
 #else
 
 static const char tar_usage[] =
-"tar -[xtvOf] [tarFileName] [FILE] ...\n\n"
-"Extract, or list files stored in a tar file.  This\n"
-"version of tar does not support creation of tar files.\n\n"
-"Options:\n"
-"\tx=extract, t=list contents, v=verbose,\n"
-"\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
+        "tar -[xtvOf] [tarFileName] [FILE] ...\n\n"
+        "Extract, or list files stored in a tar file.  This\n"
+        "version of tar does not support creation of tar files.\n\n"
+        "Options:\n"
+
+        "\tx=extract, t=list contents, v=verbose,\n"
+        "\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
 
 #endif
 
@@ -78,22 +81,22 @@ static const char tar_usage[] =
  * with zero padding.  We only process this information minimally.
  */
 typedef struct {
-    char name[TAR_NAME_SIZE];
-    char mode[8];
-    char uid[8];
-    char gid[8];
-    char size[12];
-    char mtime[12];
-    char checkSum[8];
-    char typeFlag;
-    char linkName[TAR_NAME_SIZE];
-    char magic[6];
-    char version[2];
-    char uname[32];
-    char gname[32];
-    char devMajor[8];
-    char devMinor[8];
-    char prefix[155];
+        char name[TAR_NAME_SIZE];
+        char mode[8];
+        char uid[8];
+        char gid[8];
+        char size[12];
+        char mtime[12];
+        char checkSum[8];
+        char typeFlag;
+        char linkName[TAR_NAME_SIZE];
+        char magic[6];
+        char version[2];
+        char uname[32];
+        char gname[32];
+        char devMajor[8];
+        char devMinor[8];
+        char prefix[155];
 } TarHeader;
 
 #define TAR_MAGIC       "ustar"
@@ -113,7 +116,7 @@ static int createFlag;
 static int verboseFlag;
 static int tostdoutFlag;
 
-static int inHeader; // <- check me
+static int inHeader;                    // <- check me
 static int badHeader;
 static int errorFlag;
 static int skipFileFlag;
@@ -140,141 +143,145 @@ static ino_t tarInode;
 /*
  * Local procedures to restore files from a tar file.
  */
-static void readTarFile (int fileCount, char **fileTable);
-static void readData (const char *cp, int count);
-static long getOctal (const char *cp, int len);
+static void readTarFile(int fileCount, char **fileTable);
+static void readData(const char *cp, int count);
+static long getOctal(const char *cp, int len);
+
+static void readHeader(const TarHeader * hp,
 
-static void readHeader (const TarHeader * hp,
-                        int fileCount, char **fileTable);
+                                           int fileCount, char **fileTable);
 
-static int wantFileName (const char *fileName,
-                         int fileCount, char **fileTable);
+static int wantFileName(const char *fileName,
+
+                                                int fileCount, char **fileTable);
 
 #ifdef BB_FEATURE_TAR_CREATE
 /*
  * Local procedures to save files into a tar file.
  */
-static void saveFile (const char *fileName, int seeLinks);
+static void saveFile(const char *fileName, int seeLinks);
+
+static void saveRegularFile(const char *fileName,
 
-static void saveRegularFile (const char *fileName,
-                             const struct stat *statbuf);
+                                                        const struct stat *statbuf);
 
-static void saveDirectory (const char *fileName,
-                           const struct stat *statbuf);
+static void saveDirectory(const char *fileName,
 
-static void writeHeader (const char *fileName, const struct stat *statbuf);
+                                                  const struct stat *statbuf);
 
-static void writeTarFile (int fileCount, char **fileTable);
-static void writeTarBlock (const char *buf, int len);
-static int putOctal (char *cp, int len, long value);
+static void writeHeader(const char *fileName, const struct stat *statbuf);
+
+static void writeTarFile(int fileCount, char **fileTable);
+static void writeTarBlock(const char *buf, int len);
+static int putOctal(char *cp, int len, long value);
 
 #endif
 
 
-extern int tar_main (int argc, char **argv)
+extern int tar_main(int argc, char **argv)
 {
-    const char *options;
-
-    argc--;
-    argv++;
-
-    if (argc < 1)
-        usage( tar_usage);
-
-
-    errorFlag = FALSE;
-    extractFlag = FALSE;
-    createFlag = FALSE;
-    listFlag = FALSE;
-    verboseFlag = FALSE;
-    tostdoutFlag = FALSE;
-    tarName = NULL;
-    tarDev = 0;
-    tarInode = 0;
-    tarFd = -1;
-
-    /* 
-     * Parse the options.
-     */
-    if (**argv == '-')
-        options = (*argv++) + 1;
-    else 
-        options = (*argv++);
-    argc--;
-
-    for (; *options; options++) {
-        switch (*options) {
-        case 'f':
-            if (tarName != NULL) {
-                fprintf (stderr, "Only one 'f' option allowed\n");
-
-                exit (FALSE);
-            }
-
-            tarName = *argv++;
-            argc--;
-
-            break;
-
-        case 't':
-            if (extractFlag == TRUE || createFlag == TRUE )
-                goto flagError;
-            listFlag = TRUE;
-            break;
-
-        case 'x':
-            if (listFlag == TRUE || createFlag == TRUE )
-                goto flagError;
-            extractFlag = TRUE;
-            break;
-        case 'c':
-            if (extractFlag == TRUE || listFlag == TRUE)
-                goto flagError;
-            createFlag = TRUE;
-            break;
-
-        case 'v':
-            verboseFlag = TRUE;
-            break;
-
-        case 'O':
-            tostdoutFlag = TRUE;
-            break;
-
-        case '-':
-            usage( tar_usage);
-            break;
-
-        default:
-            fprintf (stderr, "Unknown tar flag '%c'\n"
-                    "Try `tar --help' for more information\n", 
-                    *options);
-            exit (FALSE);
+        const char *options;
+
+        argc--;
+        argv++;
+
+        if (argc < 1)
+                usage(tar_usage);
+
+
+        errorFlag = FALSE;
+        extractFlag = FALSE;
+        createFlag = FALSE;
+        listFlag = FALSE;
+        verboseFlag = FALSE;
+        tostdoutFlag = FALSE;
+        tarName = NULL;
+        tarDev = 0;
+        tarInode = 0;
+        tarFd = -1;
+
+        /* 
+         * Parse the options.
+         */
+        if (**argv == '-')
+                options = (*argv++) + 1;
+        else
+                options = (*argv++);
+        argc--;
+
+        for (; *options; options++) {
+                switch (*options) {
+                case 'f':
+                        if (tarName != NULL) {
+                                fprintf(stderr, "Only one 'f' option allowed\n");
+
+                                exit(FALSE);
+                        }
+
+                        tarName = *argv++;
+                        argc--;
+
+                        break;
+
+                case 't':
+                        if (extractFlag == TRUE || createFlag == TRUE)
+                                goto flagError;
+                        listFlag = TRUE;
+                        break;
+
+                case 'x':
+                        if (listFlag == TRUE || createFlag == TRUE)
+                                goto flagError;
+                        extractFlag = TRUE;
+                        break;
+                case 'c':
+                        if (extractFlag == TRUE || listFlag == TRUE)
+                                goto flagError;
+                        createFlag = TRUE;
+                        break;
+
+                case 'v':
+                        verboseFlag = TRUE;
+                        break;
+
+                case 'O':
+                        tostdoutFlag = TRUE;
+                        break;
+
+                case '-':
+                        usage(tar_usage);
+                        break;
+
+                default:
+                        fprintf(stderr, "Unknown tar flag '%c'\n"
+                                        "Try `tar --help' for more information\n", *options);
+                        exit(FALSE);
+                }
         }
-    }
 
-    /* 
-     * Do the correct type of action supplying the rest of the
-     * command line arguments as the list of files to process.
-     */
-    if (createFlag==TRUE) {
+        /* 
+         * Do the correct type of action supplying the rest of the
+         * command line arguments as the list of files to process.
+         */
+        if (createFlag == TRUE) {
 #ifndef BB_FEATURE_TAR_CREATE
-        fprintf (stderr, "This version of tar was not compiled with tar creation support.\n" );
-        exit (FALSE);
+                fprintf(stderr,
+                                "This version of tar was not compiled with tar creation support.\n");
+                exit(FALSE);
 #else
-        writeTarFile (argc, argv);
-#endif 
-    } else {
-        readTarFile (argc, argv);
-    }
-    if (errorFlag==TRUE) {
-        fprintf (stderr, "\n");
-    }
-    exit (!errorFlag);
-
-flagError:
-    fprintf (stderr, "Exactly one of 'c', 'x' or 't' must be specified\n");
-    exit (FALSE);
+                writeTarFile(argc, argv);
+#endif
+        } else {
+                readTarFile(argc, argv);
+        }
+        if (errorFlag == TRUE) {
+                fprintf(stderr, "\n");
+        }
+        exit(!errorFlag);
+
+  flagError:
+        fprintf(stderr, "Exactly one of 'c', 'x' or 't' must be specified\n");
+        exit(FALSE);
 }
 
 
@@ -282,120 +289,120 @@ flagError:
  * Read a tar file and extract or list the specified files within it.
  * If the list is empty than all files are extracted or listed.
  */
-static void readTarFile (int fileCount, char **fileTable)
+static void readTarFile(int fileCount, char **fileTable)
 {
-    const char *cp;
-    int cc;
-    int inCc;
-    int blockSize;
-    char buf[BUF_SIZE];
-
-    skipFileFlag = FALSE;
-    badHeader = FALSE;
-    warnedRoot = FALSE;
-    eofFlag = FALSE;
-    inHeader = TRUE;
-    inCc = 0;
-    dataCc = 0;
-    outFd = -1;
-    blockSize = sizeof (buf);
-    cp = buf;
-
-    /* 
-     * Open the tar file for reading.
-     */
-    if ((tarName == NULL) || !strcmp (tarName, "-")) {
-        tarFd = fileno(stdin);
-    } else
-        tarFd = open (tarName, O_RDONLY);
-
-    if (tarFd < 0) {
-        perror (tarName);
-        errorFlag = TRUE;
-        return;
-    }
-
-    /* 
-     * Read blocks from the file until an end of file header block
-     * has been seen.  (A real end of file from a read is an error.)
-     */
-    while (eofFlag==FALSE) {
+        const char *cp;
+        int cc;
+        int inCc;
+        int blockSize;
+        char buf[BUF_SIZE];
+
+        skipFileFlag = FALSE;
+        badHeader = FALSE;
+        warnedRoot = FALSE;
+        eofFlag = FALSE;
+        inHeader = TRUE;
+        inCc = 0;
+        dataCc = 0;
+        outFd = -1;
+        blockSize = sizeof(buf);
+        cp = buf;
+
         /* 
-         * Read the next block of data if necessary.
-         * This will be a large block if possible, which we will
-         * then process in the small tar blocks.
+         * Open the tar file for reading.
          */
-        if (inCc <= 0) {
-            cp = buf;
-            inCc = fullRead (tarFd, buf, blockSize);
-
-            if (inCc < 0) {
-                perror (tarName);
-                errorFlag = TRUE;
-                goto done;
-            }
+        if ((tarName == NULL) || !strcmp(tarName, "-")) {
+                tarFd = fileno(stdin);
+        } else
+                tarFd = open(tarName, O_RDONLY);
 
-            if (inCc == 0) {
-                fprintf (stderr,
-                         "Unexpected end of file from \"%s\"", tarName);
+        if (tarFd < 0) {
+                perror(tarName);
                 errorFlag = TRUE;
-                goto done;
-            }
+                return;
         }
 
         /* 
-         * If we are expecting a header block then examine it.
+         * Read blocks from the file until an end of file header block
+         * has been seen.  (A real end of file from a read is an error.)
          */
-        if (inHeader==TRUE) {
-            readHeader ((const TarHeader *) cp, fileCount, fileTable);
-
-            cp += TAR_BLOCK_SIZE;
-            inCc -= TAR_BLOCK_SIZE;
-
-            continue;
+        while (eofFlag == FALSE) {
+                /* 
+                 * Read the next block of data if necessary.
+                 * This will be a large block if possible, which we will
+                 * then process in the small tar blocks.
+                 */
+                if (inCc <= 0) {
+                        cp = buf;
+                        inCc = fullRead(tarFd, buf, blockSize);
+
+                        if (inCc < 0) {
+                                perror(tarName);
+                                errorFlag = TRUE;
+                                goto done;
+                        }
+
+                        if (inCc == 0) {
+                                fprintf(stderr,
+                                                "Unexpected end of file from \"%s\"", tarName);
+                                errorFlag = TRUE;
+                                goto done;
+                        }
+                }
+
+                /* 
+                 * If we are expecting a header block then examine it.
+                 */
+                if (inHeader == TRUE) {
+                        readHeader((const TarHeader *) cp, fileCount, fileTable);
+
+                        cp += TAR_BLOCK_SIZE;
+                        inCc -= TAR_BLOCK_SIZE;
+
+                        continue;
+                }
+
+                /* 
+                 * We are currently handling the data for a file.
+                 * Process the minimum of the amount of data we have available
+                 * and the amount left to be processed for the file.
+                 */
+                cc = inCc;
+
+                if (cc > dataCc)
+                        cc = dataCc;
+
+                readData(cp, cc);
+
+                /* 
+                 * If the amount left isn't an exact multiple of the tar block
+                 * size then round it up to the next block boundary since there
+                 * is padding at the end of the file.
+                 */
+                if (cc % TAR_BLOCK_SIZE)
+                        cc += TAR_BLOCK_SIZE - (cc % TAR_BLOCK_SIZE);
+
+                cp += cc;
+                inCc -= cc;
         }
 
+  done:
         /* 
-         * We are currently handling the data for a file.
-         * Process the minimum of the amount of data we have available
-         * and the amount left to be processed for the file.
+         * Close the tar file if needed.
          */
-        cc = inCc;
-
-        if (cc > dataCc)
-            cc = dataCc;
-
-        readData (cp, cc);
+        if ((tarFd >= 0) && (close(tarFd) < 0))
+                perror(tarName);
 
         /* 
-         * If the amount left isn't an exact multiple of the tar block
-         * size then round it up to the next block boundary since there
-         * is padding at the end of the file.
+         * Close the output file if needed.
+         * This is only done here on a previous error and so no
+         * message is required on errors.
          */
-        if (cc % TAR_BLOCK_SIZE)
-            cc += TAR_BLOCK_SIZE - (cc % TAR_BLOCK_SIZE);
-
-        cp += cc;
-        inCc -= cc;
-    }
-
-  done:
-    /* 
-     * Close the tar file if needed.
-     */
-    if ((tarFd >= 0) && (close (tarFd) < 0))
-        perror (tarName);
-
-    /* 
-     * Close the output file if needed.
-     * This is only done here on a previous error and so no
-     * message is required on errors.
-     */
-    if (tostdoutFlag == FALSE) {
-        if (outFd >= 0) {
-            close (outFd);
+        if (tostdoutFlag == FALSE) {
+                if (outFd >= 0) {
+                        close(outFd);
+                }
         }
-    }
 }
 
 
@@ -405,304 +412,305 @@ static void readTarFile (int fileCount, char **fileTable)
  * the end of the tar file.
  */
 static void
-readHeader (const TarHeader * hp, int fileCount, char **fileTable)
+readHeader(const TarHeader * hp, int fileCount, char **fileTable)
 {
-    int checkSum;
-    int cc;
-    int hardLink;
-    int softLink;
-    int devFileFlag;
-    unsigned int major;
-    unsigned int minor;
-    long size;
-    struct utimbuf utb;
-
-    /* 
-     * If the block is completely empty, then this is the end of the
-     * archive file.  If the name is null, then just skip this header.
-     */
-    outName = hp->name;
-
-    if (*outName == '\0') {
-        for (cc = TAR_BLOCK_SIZE; cc > 0; cc--) {
-            if (*outName++)
+        int checkSum;
+        int cc;
+        int hardLink;
+        int softLink;
+        int devFileFlag;
+        unsigned int major;
+        unsigned int minor;
+        long size;
+        struct utimbuf utb;
+
+        /* 
+         * If the block is completely empty, then this is the end of the
+         * archive file.  If the name is null, then just skip this header.
+         */
+        outName = hp->name;
+
+        if (*outName == '\0') {
+                for (cc = TAR_BLOCK_SIZE; cc > 0; cc--) {
+                        if (*outName++)
+                                return;
+                }
+
+                eofFlag = TRUE;
+
                 return;
         }
 
-        eofFlag = TRUE;
-
-        return;
-    }
-
-    /* 
-     * There is another file in the archive to examine.
-     * Extract the encoded information and check it.
-     */
-    mode = getOctal (hp->mode, sizeof (hp->mode));
-    uid = getOctal (hp->uid, sizeof (hp->uid));
-    gid = getOctal (hp->gid, sizeof (hp->gid));
-    size = getOctal (hp->size, sizeof (hp->size));
-    mtime = getOctal (hp->mtime, sizeof (hp->mtime));
-    checkSum = getOctal (hp->checkSum, sizeof (hp->checkSum));
-    major = getOctal (hp->devMajor, sizeof (hp->devMajor));
-    minor = getOctal (hp->devMinor, sizeof (hp->devMinor));
-
-    if ((mode < 0) || (uid < 0) || (gid < 0) || (size < 0)) {
-        if (badHeader==FALSE)
-            fprintf (stderr, "Bad tar header, skipping\n");
-
-        badHeader = TRUE;
-
-        return;
-    }
-
-    badHeader = FALSE;
-    skipFileFlag = FALSE;
-    devFileFlag = FALSE;
-
-    /* 
-     * Check for the file modes.
-     */
-    hardLink = ((hp->typeFlag == TAR_TYPE_HARD_LINK) ||
-                (hp->typeFlag == TAR_TYPE_HARD_LINK - '0'));
-
-    softLink = ((hp->typeFlag == TAR_TYPE_SOFT_LINK) ||
-                (hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
-
-    /* 
-     * Check for a directory.
-     */
-    if (outName[strlen (outName) - 1] == '/')
-        mode |= S_IFDIR;
-
-    /* 
-     * Check for absolute paths in the file.
-     * If we find any, then warn the user and make them relative.
-     */
-    if (*outName == '/') {
-        while (*outName == '/')
-            outName++;
-
-        if (warnedRoot==FALSE) {
-            fprintf (stderr,
-                     "Absolute path detected, removing leading slashes\n");
-        }
+        /* 
+         * There is another file in the archive to examine.
+         * Extract the encoded information and check it.
+         */
+        mode = getOctal(hp->mode, sizeof(hp->mode));
+        uid = getOctal(hp->uid, sizeof(hp->uid));
+        gid = getOctal(hp->gid, sizeof(hp->gid));
+        size = getOctal(hp->size, sizeof(hp->size));
+        mtime = getOctal(hp->mtime, sizeof(hp->mtime));
+        checkSum = getOctal(hp->checkSum, sizeof(hp->checkSum));
+        major = getOctal(hp->devMajor, sizeof(hp->devMajor));
+        minor = getOctal(hp->devMinor, sizeof(hp->devMinor));
 
-        warnedRoot = TRUE;
-    }
-
-    /* 
-     * See if we want this file to be restored.
-     * If not, then set up to skip it.
-     */
-    if (wantFileName (outName, fileCount, fileTable) == FALSE) {
-        if ( !hardLink && !softLink && (S_ISREG (mode) || S_ISCHR (mode)
-                    || S_ISBLK (mode) || S_ISSOCK(mode) || S_ISFIFO(mode) ) ) {
-            inHeader = (size == 0)? TRUE : FALSE;
-            dataCc = size;
-        }
+        if ((mode < 0) || (uid < 0) || (gid < 0) || (size < 0)) {
+                if (badHeader == FALSE)
+                        fprintf(stderr, "Bad tar header, skipping\n");
 
-        skipFileFlag = TRUE;
-
-        return;
-    }
-
-    /* 
-     * This file is to be handled.
-     * If we aren't extracting then just list information about the file.
-     */
-    if (extractFlag==FALSE) {
-        if (verboseFlag==TRUE) {
-            printf ("%s %3d/%-d ", modeString (mode), uid, gid);
-            if( S_ISCHR (mode) || S_ISBLK (mode) )
-                printf ("%4d,%4d %s ", major,minor, timeString (mtime));
-            else
-                printf ("%9ld %s ", size, timeString (mtime));
-        }
-        printf ("%s", outName);
-
-        if (hardLink)
-            printf (" (link to \"%s\")", hp->linkName);
-        else if (softLink)
-            printf (" (symlink to \"%s\")", hp->linkName);
-        else if (S_ISREG (mode) || S_ISCHR (mode) || S_ISBLK (mode) || 
-                S_ISSOCK(mode) || S_ISFIFO(mode) ) {
-            inHeader = (size == 0)? TRUE : FALSE;
-            dataCc = size;
+                badHeader = TRUE;
+
+                return;
         }
 
-        printf ("\n");
+        badHeader = FALSE;
+        skipFileFlag = FALSE;
+        devFileFlag = FALSE;
 
-        return;
-    }
+        /* 
+         * Check for the file modes.
+         */
+        hardLink = ((hp->typeFlag == TAR_TYPE_HARD_LINK) ||
+                                (hp->typeFlag == TAR_TYPE_HARD_LINK - '0'));
+
+        softLink = ((hp->typeFlag == TAR_TYPE_SOFT_LINK) ||
+                                (hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
+
+        /* 
+         * Check for a directory.
+         */
+        if (outName[strlen(outName) - 1] == '/')
+                mode |= S_IFDIR;
+
+        /* 
+         * Check for absolute paths in the file.
+         * If we find any, then warn the user and make them relative.
+         */
+        if (*outName == '/') {
+                while (*outName == '/')
+                        outName++;
 
-    /* 
-     * We really want to extract the file.
-     */
-    if (verboseFlag==TRUE)
-        printf ("x %s\n", outName);
+                if (warnedRoot == FALSE) {
+                        fprintf(stderr,
+                                        "Absolute path detected, removing leading slashes\n");
+                }
 
-    if (hardLink) {
-        if (link (hp->linkName, outName) < 0) {
-            perror (outName);
-            return;
+                warnedRoot = TRUE;
         }
-        /* Set the file time */
-        utb.actime = mtime;
-        utb.modtime = mtime;
-        utime (outName, &utb);
-        /* Set the file permissions */
-        chown(outName, uid, gid);
-        chmod(outName, mode);
-        return;
-    }
-
-    if (softLink) {
-#ifdef  S_ISLNK
-        if (symlink (hp->linkName, outName) < 0) {
-            perror (outName);
-            return;
+
+        /* 
+         * See if we want this file to be restored.
+         * If not, then set up to skip it.
+         */
+        if (wantFileName(outName, fileCount, fileTable) == FALSE) {
+                if (!hardLink && !softLink && (S_ISREG(mode) || S_ISCHR(mode)
+                                                                           || S_ISBLK(mode) || S_ISSOCK(mode)
+                                                                           || S_ISFIFO(mode))) {
+                        inHeader = (size == 0) ? TRUE : FALSE;
+                        dataCc = size;
+                }
+
+                skipFileFlag = TRUE;
+
+                return;
         }
-        /* Try to change ownership of the symlink.
-         * If libs doesn't support that, don't bother.
-         * Changing the pointed-to file is the Wrong Thing(tm).
+
+        /* 
+         * This file is to be handled.
+         * If we aren't extracting then just list information about the file.
          */
+        if (extractFlag == FALSE) {
+                if (verboseFlag == TRUE) {
+                        printf("%s %3d/%-d ", modeString(mode), uid, gid);
+                        if (S_ISCHR(mode) || S_ISBLK(mode))
+                                printf("%4d,%4d %s ", major, minor, timeString(mtime));
+                        else
+                                printf("%9ld %s ", size, timeString(mtime));
+                }
+                printf("%s", outName);
+
+                if (hardLink)
+                        printf(" (link to \"%s\")", hp->linkName);
+                else if (softLink)
+                        printf(" (symlink to \"%s\")", hp->linkName);
+                else if (S_ISREG(mode) || S_ISCHR(mode) || S_ISBLK(mode) ||
+                                 S_ISSOCK(mode) || S_ISFIFO(mode)) {
+                        inHeader = (size == 0) ? TRUE : FALSE;
+                        dataCc = size;
+                }
+
+                printf("\n");
+
+                return;
+        }
+
+        /* 
+         * We really want to extract the file.
+         */
+        if (verboseFlag == TRUE)
+                printf("x %s\n", outName);
+
+        if (hardLink) {
+                if (link(hp->linkName, outName) < 0) {
+                        perror(outName);
+                        return;
+                }
+                /* Set the file time */
+                utb.actime = mtime;
+                utb.modtime = mtime;
+                utime(outName, &utb);
+                /* Set the file permissions */
+                chown(outName, uid, gid);
+                chmod(outName, mode);
+                return;
+        }
+
+        if (softLink) {
+#ifdef  S_ISLNK
+                if (symlink(hp->linkName, outName) < 0) {
+                        perror(outName);
+                        return;
+                }
+                /* Try to change ownership of the symlink.
+                 * If libs doesn't support that, don't bother.
+                 * Changing the pointed-to file is the Wrong Thing(tm).
+                 */
 #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
-        lchown(outName, uid, gid);
+                lchown(outName, uid, gid);
 #endif
 
-        /* Do not change permissions or date on symlink,
-         * since it changes the pointed to file instead.  duh. */
+                /* Do not change permissions or date on symlink,
+                 * since it changes the pointed to file instead.  duh. */
 #else
-        fprintf (stderr, "Cannot create symbolic links\n");
+                fprintf(stderr, "Cannot create symbolic links\n");
 #endif
-        return;
-    }
-
-    /* Set the umask for this process so it doesn't 
-     * screw things up. */
-    umask(0);
-
-    /* 
-     * If the file is a directory, then just create the path.
-     */
-    if (S_ISDIR (mode)) {
-        if (createPath (outName, mode)==TRUE) { 
-            /* Set the file time */
-            utb.actime = mtime;
-            utb.modtime = mtime;
-            utime (outName, &utb);
-            /* Set the file permissions */
-            chown(outName, uid, gid);
-            chmod(outName, mode);
-            return;
+                return;
         }
-        return;
-    }
-
-    /* 
-     * There is a file to write.
-     * First create the path to it if necessary with default permissions.
-     */
-    createPath (outName, 0777);
-
-    inHeader = (size == 0)? TRUE : FALSE;
-    dataCc = size;
-
-    /* 
-     * Start the output file.
-     */
-    if (tostdoutFlag == TRUE)
-        outFd = fileno(stdout);
-    else {
-        if ( S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode) ) {
-            devFileFlag = TRUE;
-            outFd = mknod (outName, mode, makedev(major, minor) );
+
+        /* Set the umask for this process so it doesn't 
+         * screw things up. */
+        umask(0);
+
+        /* 
+         * If the file is a directory, then just create the path.
+         */
+        if (S_ISDIR(mode)) {
+                if (createPath(outName, mode) == TRUE) {
+                        /* Set the file time */
+                        utb.actime = mtime;
+                        utb.modtime = mtime;
+                        utime(outName, &utb);
+                        /* Set the file permissions */
+                        chown(outName, uid, gid);
+                        chmod(outName, mode);
+                        return;
+                }
+                return;
         }
-        else if (S_ISFIFO(mode) ) {
-            devFileFlag = TRUE;
-            outFd = mkfifo(outName, mode);
-        } else {
-            outFd = open (outName, O_WRONLY | O_CREAT | O_TRUNC, mode);
+
+        /* 
+         * There is a file to write.
+         * First create the path to it if necessary with default permissions.
+         */
+        createPath(outName, 0777);
+
+        inHeader = (size == 0) ? TRUE : FALSE;
+        dataCc = size;
+
+        /* 
+         * Start the output file.
+         */
+        if (tostdoutFlag == TRUE)
+                outFd = fileno(stdout);
+        else {
+                if (S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode)) {
+                        devFileFlag = TRUE;
+                        outFd = mknod(outName, mode, makedev(major, minor));
+                } else if (S_ISFIFO(mode)) {
+                        devFileFlag = TRUE;
+                        outFd = mkfifo(outName, mode);
+                } else {
+                        outFd = open(outName, O_WRONLY | O_CREAT | O_TRUNC, mode);
+                }
+                if (outFd < 0) {
+                        perror(outName);
+                        skipFileFlag = TRUE;
+                        return;
+                }
+                /* Set the file time */
+                utb.actime = mtime;
+                utb.modtime = mtime;
+                utime(outName, &utb);
+                /* Set the file permissions */
+                chown(outName, uid, gid);
+                chmod(outName, mode);
         }
-        if (outFd < 0) {
-            perror (outName);
-            skipFileFlag = TRUE;
-            return;
+
+
+        /* 
+         * If the file is empty, then that's all we need to do.
+         */
+        if (size == 0 && (tostdoutFlag == FALSE) && (devFileFlag == FALSE)) {
+                close(outFd);
+                outFd = -1;
         }
-        /* Set the file time */
-        utb.actime = mtime;
-        utb.modtime = mtime;
-        utime (outName, &utb);
-        /* Set the file permissions */
-        chown(outName, uid, gid);
-        chmod(outName, mode);
-    }
-
-
-    /* 
-     * If the file is empty, then that's all we need to do.
-     */
-    if (size == 0 && (tostdoutFlag == FALSE) && (devFileFlag == FALSE)) {
-        close (outFd);
-        outFd = -1;
-    }
 }
 
 
 /*
  * Handle a data block of some specified size that was read.
  */
-static void readData (const char *cp, int count)
+static void readData(const char *cp, int count)
 {
-    /* 
-     * Reduce the amount of data left in this file.
-     * If there is no more data left, then we need to read
-     * the header again.
-     */
-    dataCc -= count;
-
-    if (dataCc <= 0)
-        inHeader = TRUE;
+        /* 
+         * Reduce the amount of data left in this file.
+         * If there is no more data left, then we need to read
+         * the header again.
+         */
+        dataCc -= count;
 
-    /* 
-     * If we aren't extracting files or this file is being
-     * skipped then do nothing more.
-     */
-    if (extractFlag==FALSE || skipFileFlag==TRUE)
-        return;
-
-    /* 
-     * Write the data to the output file.
-     */
-    if (fullWrite (outFd, cp, count) < 0) {
-        perror (outName);
-        if (tostdoutFlag == FALSE) {
-            close (outFd);
-            outFd = -1;
+        if (dataCc <= 0)
+                inHeader = TRUE;
+
+        /* 
+         * If we aren't extracting files or this file is being
+         * skipped then do nothing more.
+         */
+        if (extractFlag == FALSE || skipFileFlag == TRUE)
+                return;
+
+        /* 
+         * Write the data to the output file.
+         */
+        if (fullWrite(outFd, cp, count) < 0) {
+                perror(outName);
+                if (tostdoutFlag == FALSE) {
+                        close(outFd);
+                        outFd = -1;
+                }
+                skipFileFlag = TRUE;
+                return;
         }
-        skipFileFlag = TRUE;
-        return;
-    }
-
-    /* 
-     * Check if we are done writing to the file now.
-     */
-    if (dataCc <= 0 && tostdoutFlag == FALSE) {
-        struct utimbuf utb;
-        if (close (outFd))
-            perror (outName);
 
-        /* Set the file time */
-        utb.actime = mtime;
-        utb.modtime = mtime;
-        utime (outName, &utb);
-        /* Set the file permissions */
-        chown(outName, uid, gid);
-        chmod(outName, mode);
+        /* 
+         * Check if we are done writing to the file now.
+         */
+        if (dataCc <= 0 && tostdoutFlag == FALSE) {
+                struct utimbuf utb;
+
+                if (close(outFd))
+                        perror(outName);
 
-        outFd = -1;
-    }
+                /* Set the file time */
+                utb.actime = mtime;
+                utb.modtime = mtime;
+                utime(outName, &utb);
+                /* Set the file permissions */
+                chown(outName, uid, gid);
+                chmod(outName, mode);
+
+                outFd = -1;
+        }
 }
 
 
@@ -712,40 +720,40 @@ static void readData (const char *cp, int count)
  * Returns TRUE if the file is selected.
  */
 static int
-wantFileName (const char *fileName, int fileCount, char **fileTable)
+wantFileName(const char *fileName, int fileCount, char **fileTable)
 {
-    const char *pathName;
-    int fileLength;
-    int pathLength;
-
-    /* 
-     * If there are no files in the list, then the file is wanted.
-     */
-    if (fileCount == 0)
-        return TRUE;
+        const char *pathName;
+        int fileLength;
+        int pathLength;
+
+        /* 
+         * If there are no files in the list, then the file is wanted.
+         */
+        if (fileCount == 0)
+                return TRUE;
 
-    fileLength = strlen (fileName);
+        fileLength = strlen(fileName);
 
-    /* 
-     * Check each of the test paths.
-     */
-    while (fileCount-- > 0) {
-        pathName = *fileTable++;
+        /* 
+         * Check each of the test paths.
+         */
+        while (fileCount-- > 0) {
+                pathName = *fileTable++;
 
-        pathLength = strlen (pathName);
+                pathLength = strlen(pathName);
 
-        if (fileLength < pathLength)
-            continue;
+                if (fileLength < pathLength)
+                        continue;
 
-        if (memcmp (fileName, pathName, pathLength) != 0)
-            continue;
+                if (memcmp(fileName, pathName, pathLength) != 0)
+                        continue;
 
-        if ((fileLength == pathLength) || (fileName[pathLength] == '/')) {
-            return TRUE;
+                if ((fileLength == pathLength) || (fileName[pathLength] == '/')) {
+                        return TRUE;
+                }
         }
-    }
 
-    return FALSE;
+        return FALSE;
 }
 
 /*
@@ -753,34 +761,34 @@ wantFileName (const char *fileName, int fileCount, char **fileTable)
  * spaces on both sides of the number and with an optional null character
  * at the end.  Returns -1 on an illegal format.
  */
-static long getOctal (const char *cp, int len)
+static long getOctal(const char *cp, int len)
 {
-    long val;
+        long val;
 
-    while ((len > 0) && (*cp == ' ')) {
-        cp++;
-        len--;
-    }
+        while ((len > 0) && (*cp == ' ')) {
+                cp++;
+                len--;
+        }
 
-    if ((len == 0) || !isOctal (*cp))
-        return -1;
+        if ((len == 0) || !isOctal(*cp))
+                return -1;
 
-    val = 0;
+        val = 0;
 
-    while ((len > 0) && isOctal (*cp)) {
-        val = val * 8 + *cp++ - '0';
-        len--;
-    }
+        while ((len > 0) && isOctal(*cp)) {
+                val = val * 8 + *cp++ - '0';
+                len--;
+        }
 
-    while ((len > 0) && (*cp == ' ')) {
-        cp++;
-        len--;
-    }
+        while ((len > 0) && (*cp == ' ')) {
+                cp++;
+                len--;
+        }
 
-    if ((len > 0) && *cp)
-        return -1;
+        if ((len > 0) && *cp)
+                return -1;
 
-    return val;
+        return val;
 }
 
 
@@ -795,65 +803,65 @@ static long getOctal (const char *cp, int len)
 /*
  * Write a tar file containing the specified files.
  */
-static void writeTarFile (int fileCount, char **fileTable)
+static void writeTarFile(int fileCount, char **fileTable)
 {
-    struct stat statbuf;
-
-    /* 
-     * Make sure there is at least one file specified.
-     */
-    if (fileCount <= 0) {
-        fprintf (stderr, "No files specified to be saved\n");
-        errorFlag = TRUE;
-    }
-
-    /* 
-     * Create the tar file for writing.
-     */
-    if ((tarName == NULL) || !strcmp (tarName, "-")) {
-        tostdoutFlag = TRUE;
-        tarFd = fileno(stdout);
-    } else
-        tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
-
-    if (tarFd < 0) {
-        perror (tarName);
-        errorFlag = TRUE;
-        return;
-    }
-
-    /* 
-     * Get the device and inode of the tar file for checking later.
-     */
-    if (fstat (tarFd, &statbuf) < 0) {
-        perror (tarName);
-        errorFlag = TRUE;
-        goto done;
-    }
-
-    tarDev = statbuf.st_dev;
-    tarInode = statbuf.st_ino;
-                
-    /* 
-     * Append each file name into the archive file.
-     * Follow symbolic links for these top level file names.
-     */
-    while (errorFlag==FALSE && (fileCount-- > 0)) {
-        saveFile (*fileTable++, FALSE);
-    }
-
-    /* 
-     * Now write an empty block of zeroes to end the archive.
-     */
-    writeTarBlock ("", 1);
+        struct stat statbuf;
+
+        /* 
+         * Make sure there is at least one file specified.
+         */
+        if (fileCount <= 0) {
+                fprintf(stderr, "No files specified to be saved\n");
+                errorFlag = TRUE;
+        }
+
+        /* 
+         * Create the tar file for writing.
+         */
+        if ((tarName == NULL) || !strcmp(tarName, "-")) {
+                tostdoutFlag = TRUE;
+                tarFd = fileno(stdout);
+        } else
+                tarFd = open(tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+
+        if (tarFd < 0) {
+                perror(tarName);
+                errorFlag = TRUE;
+                return;
+        }
+
+        /* 
+         * Get the device and inode of the tar file for checking later.
+         */
+        if (fstat(tarFd, &statbuf) < 0) {
+                perror(tarName);
+                errorFlag = TRUE;
+                goto done;
+        }
+
+        tarDev = statbuf.st_dev;
+        tarInode = statbuf.st_ino;
+
+        /* 
+         * Append each file name into the archive file.
+         * Follow symbolic links for these top level file names.
+         */
+        while (errorFlag == FALSE && (fileCount-- > 0)) {
+                saveFile(*fileTable++, FALSE);
+        }
+
+        /* 
+         * Now write an empty block of zeroes to end the archive.
+         */
+        writeTarBlock("", 1);
 
 
   done:
-    /* 
-     * Close the tar file and check for errors if it was opened.
-     */
-    if ((tostdoutFlag == FALSE) && (tarFd >= 0) && (close (tarFd) < 0))
-        perror (tarName);
+        /* 
+         * Close the tar file and check for errors if it was opened.
+         */
+        if ((tostdoutFlag == FALSE) && (tarFd >= 0) && (close(tarFd) < 0))
+                perror(tarName);
 }
 
 /*
@@ -863,73 +871,73 @@ static void writeTarFile (int fileCount, char **fileTable)
  * flag indicates whether or not we want to see symbolic links as
  * they really are, instead of blindly following them.
  */
-static void saveFile (const char *fileName, int seeLinks)
+static void saveFile(const char *fileName, int seeLinks)
 {
-    int status;
-    struct stat statbuf;
+        int status;
+        struct stat statbuf;
 
-    if (verboseFlag==TRUE)
-        printf ("a %s\n", fileName);
+        if (verboseFlag == TRUE)
+                printf("a %s\n", fileName);
 
-    /* 
-     * Check that the file name will fit in the header.
-     */
-    if (strlen (fileName) >= TAR_NAME_SIZE) {
-        fprintf (stderr, "%s: File name is too long\n", fileName);
+        /* 
+         * Check that the file name will fit in the header.
+         */
+        if (strlen(fileName) >= TAR_NAME_SIZE) {
+                fprintf(stderr, "%s: File name is too long\n", fileName);
 
-        return;
-    }
+                return;
+        }
 
-    /* 
-     * Find out about the file.
-     */
+        /* 
+         * Find out about the file.
+         */
 #ifdef  S_ISLNK
-    if (seeLinks==TRUE)
-        status = lstat (fileName, &statbuf);
-    else
+        if (seeLinks == TRUE)
+                status = lstat(fileName, &statbuf);
+        else
 #endif
-        status = stat (fileName, &statbuf);
+                status = stat(fileName, &statbuf);
 
-    if (status < 0) {
-        perror (fileName);
+        if (status < 0) {
+                perror(fileName);
+
+                return;
+        }
 
-        return;
-    }
+        /* 
+         * Make sure we aren't trying to save our file into itself.
+         */
+        if ((statbuf.st_dev == tarDev) && (statbuf.st_ino == tarInode)) {
+                fprintf(stderr, "Skipping saving of archive file itself\n");
 
-    /* 
-     * Make sure we aren't trying to save our file into itself.
-     */
-    if ((statbuf.st_dev == tarDev) && (statbuf.st_ino == tarInode)) {
-        fprintf (stderr, "Skipping saving of archive file itself\n");
+                return;
+        }
 
-        return;
-    }
+        /* 
+         * Check the type of file.
+         */
+        mode = statbuf.st_mode;
 
-    /* 
-     * Check the type of file.
-     */
-    mode = statbuf.st_mode;
+        if (S_ISDIR(mode)) {
+                saveDirectory(fileName, &statbuf);
 
-    if (S_ISDIR (mode)) {
-        saveDirectory (fileName, &statbuf);
+                return;
+        }
+        if (S_ISREG(mode)) {
+                saveRegularFile(fileName, &statbuf);
 
-        return;
-    }
-    if (S_ISREG (mode)) {
-        saveRegularFile (fileName, &statbuf);
+                return;
+        }
 
-        return;
-    }
-    
-    /* Some day add support for tarring these up... but not today. :) */
+        /* Some day add support for tarring these up... but not today. :) */
 //  if (S_ISLNK(mode) || S_ISFIFO(mode) || S_ISBLK(mode) || S_ISCHR (mode) ) {
-//      fprintf (stderr, "%s: This version of tar can't store this type of file\n", fileName);
+//  fprintf (stderr, "%s: This version of tar can't store this type of file\n", fileName);
 //  }
 
-    /* 
-     * The file is a strange type of file, ignore it.
-     */
-    fprintf (stderr, "%s: not a directory or regular file\n", fileName);
+        /* 
+         * The file is a strange type of file, ignore it.
+         */
+        fprintf(stderr, "%s: not a directory or regular file\n", fileName);
 }
 
 
@@ -937,173 +945,172 @@ static void saveFile (const char *fileName, int seeLinks)
  * Save a regular file to the tar file.
  */
 static void
-saveRegularFile (const char *fileName, const struct stat *statbuf)
+saveRegularFile(const char *fileName, const struct stat *statbuf)
 {
-    int sawEof;
-    int fileFd;
-    int cc;
-    int dataCount;
-    long fullDataCount;
-    char data[TAR_BLOCK_SIZE * 16];
-
-    /* 
-     * Open the file for reading.
-     */
-    fileFd = open (fileName, O_RDONLY);
-
-    if (fileFd < 0) {
-        perror (fileName);
-
-        return;
-    }
-
-    /* 
-     * Write out the header for the file.
-     */
-    writeHeader (fileName, statbuf);
-
-    /* 
-     * Write the data blocks of the file.
-     * We must be careful to write the amount of data that the stat
-     * buffer indicated, even if the file has changed size.  Otherwise
-     * the tar file will be incorrect.
-     */
-    fullDataCount = statbuf->st_size;
-    sawEof = FALSE;
-
-    while (fullDataCount > 0) {
-        /* 
-         * Get the amount to write this iteration which is
-         * the minumum of the amount left to write and the
-         * buffer size.
-         */
-        dataCount = sizeof (data);
-
-        if (dataCount > fullDataCount)
-            dataCount = (int) fullDataCount;
+        int sawEof;
+        int fileFd;
+        int cc;
+        int dataCount;
+        long fullDataCount;
+        char data[TAR_BLOCK_SIZE * 16];
 
         /* 
-         * Read the data from the file if we haven't seen the
-         * end of file yet.
+         * Open the file for reading.
          */
-        cc = 0;
-
-        if (sawEof==FALSE) {
-            cc = fullRead (fileFd, data, dataCount);
+        fileFd = open(fileName, O_RDONLY);
 
-            if (cc < 0) {
-                perror (fileName);
-
-                (void) close (fileFd);
-                errorFlag = TRUE;
+        if (fileFd < 0) {
+                perror(fileName);
 
                 return;
-            }
-
-            /* 
-             * If the file ended too soon, complain and set
-             * a flag so we will zero fill the rest of it.
-             */
-            if (cc < dataCount) {
-                fprintf (stderr,
-                         "%s: Short read - zero filling", fileName);
-
-                sawEof = TRUE;
-            }
         }
 
         /* 
-         * Zero fill the rest of the data if necessary.
+         * Write out the header for the file.
          */
-        if (cc < dataCount)
-            memset (data + cc, 0, dataCount - cc);
+        writeHeader(fileName, statbuf);
 
         /* 
-         * Write the buffer to the TAR file.
+         * Write the data blocks of the file.
+         * We must be careful to write the amount of data that the stat
+         * buffer indicated, even if the file has changed size.  Otherwise
+         * the tar file will be incorrect.
          */
-        writeTarBlock (data, dataCount);
-
-        fullDataCount -= dataCount;
-    }
+        fullDataCount = statbuf->st_size;
+        sawEof = FALSE;
+
+        while (fullDataCount > 0) {
+                /* 
+                 * Get the amount to write this iteration which is
+                 * the minumum of the amount left to write and the
+                 * buffer size.
+                 */
+                dataCount = sizeof(data);
+
+                if (dataCount > fullDataCount)
+                        dataCount = (int) fullDataCount;
+
+                /* 
+                 * Read the data from the file if we haven't seen the
+                 * end of file yet.
+                 */
+                cc = 0;
+
+                if (sawEof == FALSE) {
+                        cc = fullRead(fileFd, data, dataCount);
+
+                        if (cc < 0) {
+                                perror(fileName);
+
+                                (void) close(fileFd);
+                                errorFlag = TRUE;
+
+                                return;
+                        }
+
+                        /* 
+                         * If the file ended too soon, complain and set
+                         * a flag so we will zero fill the rest of it.
+                         */
+                        if (cc < dataCount) {
+                                fprintf(stderr, "%s: Short read - zero filling", fileName);
+
+                                sawEof = TRUE;
+                        }
+                }
+
+                /* 
+                 * Zero fill the rest of the data if necessary.
+                 */
+                if (cc < dataCount)
+                        memset(data + cc, 0, dataCount - cc);
+
+                /* 
+                 * Write the buffer to the TAR file.
+                 */
+                writeTarBlock(data, dataCount);
+
+                fullDataCount -= dataCount;
+        }
 
-    /* 
-     * Close the file.
-     */
-    if ((tostdoutFlag == FALSE) && close (fileFd) < 0)
-        fprintf (stderr, "%s: close: %s\n", fileName, strerror (errno));
+        /* 
+         * Close the file.
+         */
+        if ((tostdoutFlag == FALSE) && close(fileFd) < 0)
+                fprintf(stderr, "%s: close: %s\n", fileName, strerror(errno));
 }
 
 
 /*
  * Save a directory and all of its files to the tar file.
  */
-static void saveDirectory (const char *dirName, const struct stat *statbuf)
+static void saveDirectory(const char *dirName, const struct stat *statbuf)
 {
-    DIR *dir;
-    struct dirent *entry;
-    int needSlash;
-    char fullName[PATH_MAX + 1];
-
-    /* 
-     * Construct the directory name as used in the tar file by appending
-     * a slash character to it.
-     */
-    strcpy (fullName, dirName);
-    strcat (fullName, "/");
-
-    /* 
-     * Write out the header for the directory entry.
-     */
-    writeHeader (fullName, statbuf);
-
-    /* 
-     * Open the directory.
-     */
-    dir = opendir (dirName);
-
-    if (dir == NULL) {
-        fprintf (stderr, "Cannot read directory \"%s\": %s\n",
-                 dirName, strerror (errno));
-
-        return;
-    }
-
-    /* 
-     * See if a slash is needed.
-     */
-    needSlash = (*dirName && (dirName[strlen (dirName) - 1] != '/'));
-
-    /* 
-     * Read all of the directory entries and check them,
-     * except for the current and parent directory entries.
-     */
-    while (errorFlag==FALSE && ((entry = readdir (dir)) != NULL)) {
-        if ((strcmp (entry->d_name, ".") == 0) ||
-            (strcmp (entry->d_name, "..") == 0)) {
-            continue;
-        }
+        DIR *dir;
+        struct dirent *entry;
+        int needSlash;
+        char fullName[PATH_MAX + 1];
+
+        /* 
+         * Construct the directory name as used in the tar file by appending
+         * a slash character to it.
+         */
+        strcpy(fullName, dirName);
+        strcat(fullName, "/");
+
+        /* 
+         * Write out the header for the directory entry.
+         */
+        writeHeader(fullName, statbuf);
 
         /* 
-         * Build the full path name to the file.
+         * Open the directory.
          */
-        strcpy (fullName, dirName);
+        dir = opendir(dirName);
+
+        if (dir == NULL) {
+                fprintf(stderr, "Cannot read directory \"%s\": %s\n",
+                                dirName, strerror(errno));
 
-        if (needSlash)
-            strcat (fullName, "/");
+                return;
+        }
 
-        strcat (fullName, entry->d_name);
+        /* 
+         * See if a slash is needed.
+         */
+        needSlash = (*dirName && (dirName[strlen(dirName) - 1] != '/'));
 
         /* 
-         * Write this file to the tar file, noticing whether or not
-         * the file is a symbolic link.
+         * Read all of the directory entries and check them,
+         * except for the current and parent directory entries.
          */
-        saveFile (fullName, TRUE);
-    }
+        while (errorFlag == FALSE && ((entry = readdir(dir)) != NULL)) {
+                if ((strcmp(entry->d_name, ".") == 0) ||
+                        (strcmp(entry->d_name, "..") == 0)) {
+                        continue;
+                }
+
+                /* 
+                 * Build the full path name to the file.
+                 */
+                strcpy(fullName, dirName);
+
+                if (needSlash)
+                        strcat(fullName, "/");
+
+                strcat(fullName, entry->d_name);
+
+                /* 
+                 * Write this file to the tar file, noticing whether or not
+                 * the file is a symbolic link.
+                 */
+                saveFile(fullName, TRUE);
+        }
 
-    /* 
-     * All done, close the directory.
-     */
-    closedir (dir);
+        /* 
+         * All done, close the directory.
+         */
+        closedir(dir);
 }
 
 
@@ -1111,54 +1118,54 @@ static void saveDirectory (const char *dirName, const struct stat *statbuf)
  * Write a tar header for the specified file name and status.
  * It is assumed that the file name fits.
  */
-static void writeHeader (const char *fileName, const struct stat *statbuf)
+static void writeHeader(const char *fileName, const struct stat *statbuf)
 {
-    long checkSum;
-    const unsigned char *cp;
-    int len;
-    TarHeader header;
-
-    /* 
-     * Zero the header block in preparation for filling it in.
-     */
-    memset ((char *) &header, 0, sizeof (header));
-
-    /* 
-     * Fill in the header.
-     */
-    strcpy (header.name, fileName);
-
-    strncpy (header.magic, TAR_MAGIC, sizeof (header.magic));
-    strncpy (header.version, TAR_VERSION, sizeof (header.version));
-
-    putOctal (header.mode, sizeof (header.mode), statbuf->st_mode & 0777);
-    putOctal (header.uid, sizeof (header.uid), statbuf->st_uid);
-    putOctal (header.gid, sizeof (header.gid), statbuf->st_gid);
-    putOctal (header.size, sizeof (header.size), statbuf->st_size);
-    putOctal (header.mtime, sizeof (header.mtime), statbuf->st_mtime);
-
-    header.typeFlag = TAR_TYPE_REGULAR;
-
-    /* 
-     * Calculate and store the checksum.
-     * This is the sum of all of the bytes of the header,
-     * with the checksum field itself treated as blanks.
-     */
-    memset (header.checkSum, ' ', sizeof (header.checkSum));
-
-    cp = (const unsigned char *) &header;
-    len = sizeof (header);
-    checkSum = 0;
-
-    while (len-- > 0)
-        checkSum += *cp++;
-
-    putOctal (header.checkSum, sizeof (header.checkSum), checkSum);
-
-    /* 
-     * Write the tar header.
-     */
-    writeTarBlock ((const char *) &header, sizeof (header));
+        long checkSum;
+        const unsigned char *cp;
+        int len;
+        TarHeader header;
+
+        /* 
+         * Zero the header block in preparation for filling it in.
+         */
+        memset((char *) &header, 0, sizeof(header));
+
+        /* 
+         * Fill in the header.
+         */
+        strcpy(header.name, fileName);
+
+        strncpy(header.magic, TAR_MAGIC, sizeof(header.magic));
+        strncpy(header.version, TAR_VERSION, sizeof(header.version));
+
+        putOctal(header.mode, sizeof(header.mode), statbuf->st_mode & 0777);
+        putOctal(header.uid, sizeof(header.uid), statbuf->st_uid);
+        putOctal(header.gid, sizeof(header.gid), statbuf->st_gid);
+        putOctal(header.size, sizeof(header.size), statbuf->st_size);
+        putOctal(header.mtime, sizeof(header.mtime), statbuf->st_mtime);
+
+        header.typeFlag = TAR_TYPE_REGULAR;
+
+        /* 
+         * Calculate and store the checksum.
+         * This is the sum of all of the bytes of the header,
+         * with the checksum field itself treated as blanks.
+         */
+        memset(header.checkSum, ' ', sizeof(header.checkSum));
+
+        cp = (const unsigned char *) &header;
+        len = sizeof(header);
+        checkSum = 0;
+
+        while (len-- > 0)
+                checkSum += *cp++;
+
+        putOctal(header.checkSum, sizeof(header.checkSum), checkSum);
+
+        /* 
+         * Write the tar header.
+         */
+        writeTarBlock((const char *) &header, sizeof(header));
 }
 
 
@@ -1167,56 +1174,56 @@ static void writeHeader (const char *fileName, const struct stat *statbuf)
  * The data is always padded out to a multiple of TAR_BLOCK_SIZE.
  * The errorFlag static variable is set on an error.
  */
-static void writeTarBlock (const char *buf, int len)
+static void writeTarBlock(const char *buf, int len)
 {
-    int partialLength;
-    int completeLength;
-    char fullBlock[TAR_BLOCK_SIZE];
-
-    /* 
-     * If we had a write error before, then do nothing more.
-     */
-    if (errorFlag==TRUE)
-        return;
-
-    /* 
-     * Get the amount of complete and partial blocks.
-     */
-    partialLength = len % TAR_BLOCK_SIZE;
-    completeLength = len - partialLength;
-
-    /* 
-     * Write all of the complete blocks.
-     */
-    if ((completeLength > 0) && !fullWrite (tarFd, buf, completeLength)) {
-        perror (tarName);
-
-        errorFlag = TRUE;
-
-        return;
-    }
-
-    /* 
-     * If there are no partial blocks left, we are done.
-     */
-    if (partialLength == 0)
-        return;
-
-    /* 
-     * Copy the partial data into a complete block, and pad the rest
-     * of it with zeroes.
-     */
-    memcpy (fullBlock, buf + completeLength, partialLength);
-    memset (fullBlock + partialLength, 0, TAR_BLOCK_SIZE - partialLength);
-
-    /* 
-     * Write the last complete block.
-     */
-    if (!fullWrite (tarFd, fullBlock, TAR_BLOCK_SIZE)) {
-        perror (tarName);
-
-        errorFlag = TRUE;
-    }
+        int partialLength;
+        int completeLength;
+        char fullBlock[TAR_BLOCK_SIZE];
+
+        /* 
+         * If we had a write error before, then do nothing more.
+         */
+        if (errorFlag == TRUE)
+                return;
+
+        /* 
+         * Get the amount of complete and partial blocks.
+         */
+        partialLength = len % TAR_BLOCK_SIZE;
+        completeLength = len - partialLength;
+
+        /* 
+         * Write all of the complete blocks.
+         */
+        if ((completeLength > 0) && !fullWrite(tarFd, buf, completeLength)) {
+                perror(tarName);
+
+                errorFlag = TRUE;
+
+                return;
+        }
+
+        /* 
+         * If there are no partial blocks left, we are done.
+         */
+        if (partialLength == 0)
+                return;
+
+        /* 
+         * Copy the partial data into a complete block, and pad the rest
+         * of it with zeroes.
+         */
+        memcpy(fullBlock, buf + completeLength, partialLength);
+        memset(fullBlock + partialLength, 0, TAR_BLOCK_SIZE - partialLength);
+
+        /* 
+         * Write the last complete block.
+         */
+        if (!fullWrite(tarFd, fullBlock, TAR_BLOCK_SIZE)) {
+                perror(tarName);
+
+                errorFlag = TRUE;
+        }
 }
 
 
@@ -1225,48 +1232,48 @@ static void writeTarBlock (const char *buf, int len)
  * The number is zero and space padded and possibly null padded.
  * Returns TRUE if successful.
  */
-static int putOctal (char *cp, int len, long value)
+static int putOctal(char *cp, int len, long value)
 {
-    int tempLength;
-    char *tempString;
-    char tempBuffer[32];
-
-    /* 
-     * Create a string of the specified length with an initial space,
-     * leading zeroes and the octal number, and a trailing null.
-     */
-    tempString = tempBuffer;
-
-    sprintf (tempString, " %0*lo", len - 2, value);
-
-    tempLength = strlen (tempString) + 1;
-
-    /* 
-     * If the string is too large, suppress the leading space.
-     */
-    if (tempLength > len) {
-        tempLength--;
-        tempString++;
-    }
-
-    /* 
-     * If the string is still too large, suppress the trailing null.
-     */
-    if (tempLength > len)
-        tempLength--;
-
-    /* 
-     * If the string is still too large, fail.
-     */
-    if (tempLength > len)
-        return FALSE;
+        int tempLength;
+        char *tempString;
+        char tempBuffer[32];
 
-    /* 
-     * Copy the string to the field.
-     */
-    memcpy (cp, tempString, len);
+        /* 
+         * Create a string of the specified length with an initial space,
+         * leading zeroes and the octal number, and a trailing null.
+         */
+        tempString = tempBuffer;
 
-    return TRUE;
+        sprintf(tempString, " %0*lo", len - 2, value);
+
+        tempLength = strlen(tempString) + 1;
+
+        /* 
+         * If the string is too large, suppress the leading space.
+         */
+        if (tempLength > len) {
+                tempLength--;
+                tempString++;
+        }
+
+        /* 
+         * If the string is still too large, suppress the trailing null.
+         */
+        if (tempLength > len)
+                tempLength--;
+
+        /* 
+         * If the string is still too large, fail.
+         */
+        if (tempLength > len)
+                return FALSE;
+
+        /* 
+         * Copy the string to the field.
+         */
+        memcpy(cp, tempString, len);
+
+        return TRUE;
 }
 #endif