Update version.c for 0.30 release

Update nwipe.1 for 0.30 release
Update configure.ac for 0.30 release
2026-02-22 06:52:12 +00:00 · 2020-12-09 17:28:14 +00:00 · 2020-12-09 17:27:03 +00:00 · 2020-12-09 17:10:43 +00:00 · 2020-12-09 17:07:48 +00:00 · 2020-12-05 01:00:48 +00:00
23 changed files with 1903 additions and 442 deletions
--- a/.github/workflows/ci_formatting.yml
+++ b/.github/workflows/ci_formatting.yml
@@ -0,0 +1,21 @@
+name: ci_formatting
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: updating available system dependencies
+      run: sudo apt-get update
+    - name: installing system dependencies
+      run: sudo apt-get install -y build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode clang-format-7
+    - name: creating autoconf files
+      run: ./autogen.sh
+    - name: configuring
+      run: ./configure CFLAGS='-O0 -g -Wall -Wextra'
+    - name: verifying code style
+      run: make check-format
--- a/.github/workflows/ci_ubuntu_16.04.yml
+++ b/.github/workflows/ci_ubuntu_16.04.yml
@@ -12,13 +12,10 @@ jobs:
    - name: updating available system dependencies
      run: sudo apt-get update
    - name: installing system dependencies
-      run: sudo apt-get install -y build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode clang-format-5.0
+      run: sudo apt-get install -y build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode
    - name: creating autoconf files
-      run: ./init.sh
+      run: ./autogen.sh
    - name: configuring
      run: ./configure CFLAGS='-O0 -g -Wall -Wextra'
    - name: compiling
      run: make
-    # Changing the path should no longer be necessary when clang-format6 is installed.
-    - name: verifying code style
-      run: export PATH=$PATH:/usr/lib/llvm-5.0/bin && make check-format
--- a/.github/workflows/ci_ubuntu_latest.yml
+++ b/.github/workflows/ci_ubuntu_latest.yml
@@ -12,13 +12,10 @@ jobs:
    - name: updating available system dependencies
      run: sudo apt-get update
    - name: installing system dependencies
-      run: sudo apt-get install -y build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode clang-format-5.0
+      run: sudo apt-get install -y build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode
    - name: creating autoconf files
-      run: ./init.sh
+      run: ./autogen.sh
    - name: configuring
      run: ./configure CFLAGS='-O0 -g -Wall -Wextra'
    - name: compiling
      run: make
-    # Changing the path should no longer be necessary when clang-format6 is installed.
-    - name: verifying code style
-      run: export PATH=$PATH:/usr/lib/llvm-5.0/bin && make check-format
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,25 +1,52 @@
 RELEASE NOTES
 =============

+v0.30
+-----------------------
+- Add auto power off option on completion of wipe ( --autopoweroff ) (Thanks PartialVolume)
+- Fixed --nowait option that wasn't working. (Thanks PartialVolume)
+- Add verbose option. -v, --verbose.
+- Add a spinner to the GUI for each drive being wiped. When nwipe is syncing the percentage completion pauses, having a spinner gives a clear indication that the wipe is still running. Each devices spinner disappears on completion of a given devices wipe. (Thanks PartialVolume)
+- Make log messages, especially the ones with the tag 'notice' succinct and less than 80 characters including the timestamp. This is of more importance when nwipe is used on a 80x30 terminal (ALT-F2, Shredos etc) but generally makes the logs more readable. While doing this all information was still retained. (Thanks PartialVolume)
+- Add a summary table to the log that shows each drives status, i.e. erased or failed, throughput, duration of wipe, model, serial no etc. In particular it benefits those that wipe many drives simultaneously in rack servers. At a glance any failed drives can be seen without having to browse back through the log. (Thanks PartialVolume)
+- Add ETA to --nogui wipes status when SIGUSR1 (kill -s USR1 (nwipes PID) is issued on the command line.
+- Fixed misleading throughput calculation. Throughput now shows average throughput calculated from start of wipe.
+- Fixed system info not being displayed in Debian Sid. [#229](https://github.com/martijnvanbrummelen/nwipe/issues/229) (Thanks PartialVolume)
+- Add serial number display for USB to IDE/SATA adapters. This only works if the USB to IDE/SATA adapter supports ATA pass through. See [#149](https://github.com/martijnvanbrummelen/nwipe/issues/149) for further details (Thanks PartialVolume)
+- Fixed disk capacity nomenclature, width and padding on drive selection screen. See [#237](https://github.com/martijnvanbrummelen/nwipe/issues/237) (Thanks PartialVolume)
+- Add bus type, ATA or USB, amongst others to drive selection and wipe windows. (Thanks PartialVolume)
+- Add --nousb option. If you use the option --nousb, all USB devices will be ignored. They won't show up in the GUI and they won't be wiped if you use the --nogui --autonuke command. They will even be ignored if you specifically name them on the command line.
+- Miscellaneous GUI fixes, throughput display format, percentage display format to improve column alignment when wiping multiple discs. (Thanks PartialVolume)
+- Improve visibility of failure messages with red text on white background. (Thanks PartialVolume)
+- Add NVME and VIRT (loop etc) devices to device type table for display in GUI and logs. NVME devices now show up as NVME devices rather than UNK (Thanks PartialVolume)
+- Fixed very obscure segmentation fault going back to at least 0.24 in drive selection window when resizing terminal vertical axis while drive focus symbol '>' is pointing to the last drive of a multi drive selection window. See [#248](https://github.com/martijnvanbrummelen/nwipe/pull/248) for further details (Thanks PartialVolume)
+- Warn the user if they are incorrectly typing a lower case s to start a wipe, when they should be typing a capital S [#262](https://github.com/martijnvanbrummelen/nwipe/issues/262) (Thanks PartialVolume)
+- Warn the user if they are typing capital S in order to start a wipe but haven't yet selected any drives for wiping [#261](https://github.com/martijnvanbrummelen/nwipe/issues/261) (Thanks PartialVolume)
+- Add ctrl A that toggles drive selection, all drives selected for wipe or all drives deselected. [#266](https://github.com/martijnvanbrummelen/nwipe/issues/266)
+- Fixed compilation issue with NixOS with broken musl libc error due to missing header [#275](https://github.com/martijnvanbrummelen/nwipe/issues/275)
+- Fixed status bar message showing incorrect information [#287](https://github.com/martijnvanbrummelen/nwipe/issues/287)
+- Right Justify log labels to maintain column alignment [#280](https://github.com/martijnvanbrummelen/nwipe/issues/280)
+- Added nwipe version & OS info to log [#297](https://github.com/martijnvanbrummelen/nwipe/pull/297)
+
 v0.28
 -----------------------
- Fix premature exit when terminal resized on completion of wipes (Thanks PartialVolume)
- Fix GUI when terminal is resized, currently not handled correctly causing missing or incorrectly sized ncurses windows/panels (Thanks PartialVolume)
- Fix GUI screen flicker under various situations. [#200](https://github.com/martijnvanbrummelen/nwipe/pull/200) Fixes [#115](https://github.com/martijnvanbrummelen/nwipe/issues/115) (Thanks PartialVolume)
- Fix responsivness of screen during wipe when resized. Info is updated every 10th/sec. Key presses are more responsive. (Thanks PartialVolume)
- Fix compiler warning regarding buffer overflow. Fixes [#202](https://github.com/martijnvanbrummelen/nwipe/issues/202) (Thanks PartialVolume)
- Fix Man page (Thanks martijnvanbrummelen)
- Fix individual device throughput. On completion of a wipe instead of the throughput calculation stopping for a completed wipe, it would continue to calculate resulting in a particular drives throughtput slowly dropping until eventually it reached zero. The overall throughput was not affected. (Thanks PartialVolume)
+- Fixed premature exit when terminal resized on completion of wipes (Thanks PartialVolume)
+- Fixed GUI when terminal is resized, currently not handled correctly causing missing or incorrectly sized ncurses windows/panels (Thanks PartialVolume)
+- Fixed GUI screen flicker under various situations. [#200](https://github.com/martijnvanbrummelen/nwipe/pull/200) Fixes [#115](https://github.com/martijnvanbrummelen/nwipe/issues/115) (Thanks PartialVolume)
+- Fixed responsivness of screen during wipe when resized. Info is updated every 10th/sec. Key presses are more responsive. (Thanks PartialVolume)
+- Fixed compiler warning regarding buffer overflow. Fixes [#202](https://github.com/martijnvanbrummelen/nwipe/issues/202) (Thanks PartialVolume)
+- Fixed Man page (Thanks martijnvanbrummelen)
+- Fixed individual device throughput. On completion of a wipe instead of the throughput calculation stopping for a completed wipe, it would continue to calculate resulting in a particular drives throughtput slowly dropping until eventually it reached zero. The overall throughput was not affected. (Thanks PartialVolume)

 v0.27
 -----------------------
 - Add `verify` method to verify a disk is zero filled [#128](https://github.com/martijnvanbrummelen/nwipe/pull/128) (Thanks Legogizmo)
 - Add new HMG IS5 enhanced wipe method [#168](https://github.com/martijnvanbrummelen/nwipe/pull/168) (Thanks infrastation)
- Fix percentage progress and show on completion of wipe (Thanks PartialVolume)
+- Fixed percentage progress and show on completion of wipe (Thanks PartialVolume)
 - Implement clang-format support (Thanks louib)
 - Implement more frequent disk sync support (Thanks Legogizmo)
 - Format command line help to 80 character line length [#114](https://github.com/martijnvanbrummelen/nwipe/pull/114) (Thanks PartialVolume)
- Fix nwipe message log and missing messages that was causing segfaults under certain conditions (Thanks PartialVolume)
+- Fixed nwipe message log and missing messages that was causing segfaults under certain conditions (Thanks PartialVolume)
 - Add the Github build CI service and update Readme with build status labels (Thanks louib)
 - Miscellaneous smaller fixes

@@ -32,12 +59,12 @@ v0.26
 v0.25
 -----
 - Correct J=Up K=Down in footer (Thanks PartialVolume)
- Fix segfault initialize `nwipe_gui_thread` (Thanks PartialVolume)
- Fix memory leaks (Thanks PartialVolume)
+- Fixed segfault initialize `nwipe_gui_thread` (Thanks PartialVolume)
+- Fixed memory leaks (Thanks PartialVolume)
 - Check right pointer (Thanks PartialVolume)
- Fix casting problem (Thanks PartialVolume)
- Fix serial number
- Fixes uninitialized variable warning (Thanks PartialVolume)
+- Fixed casting problem (Thanks PartialVolume)
+- Fixed serial number
+- Fixed uninitialized variable warning (Thanks PartialVolume)

 v0.24
 -----
@@ -56,15 +83,15 @@ v0.22

 v0.21
 -----
- Fix ETA not updating properly and bad total throughput display. (Thanks Niels Bassler).
+- Fixed ETA not updating properly and bad total throughput display. (Thanks Niels Bassler).

 v0.20
 -----
- Fix build when panel header is not in `/usr/include` (Thanks Vincent Untz).
+- Fixed build when panel header is not in `/usr/include` (Thanks Vincent Untz).

 v0.19
 -----
- Fix building on Fedora(Unknown `off64_t`) bug #19.
+- Fixed building on Fedora(Unknown `off64_t`) bug #19.
 - Use PRNG instead of zero's bug #7. (Thanks xambroz).

 v0.18
@@ -81,11 +108,11 @@ v0.17
 - Remove control reaches end of non-void function" warnings (Thanks Vincent Untz).
 - Remove unused variables (Thanks Vincent Untz).
 - Change start key to 'S' instead of F10 (closes debian bug #755474).
- Fix problem with unusable device (Closes debian bug #755473).
+- Fixed problem with unusable device (Closes debian bug #755473).

 v0.16
 -----
- Fix problems building with clang compiler (Thanks Martijn van Brummelen)
+- Fixed problems building with clang compiler (Thanks Martijn van Brummelen)

 v0.15
 -----
--- a/README.md
+++ b/README.md
@@ -1,10 +1,11 @@
 # nwipe
 ![GitHub CI badge](https://github.com/martijnvanbrummelen/nwipe/workflows/ci_ubuntu_latest/badge.svg)
 ![GitHub CI badge](https://github.com/martijnvanbrummelen/nwipe/workflows/ci_ubuntu_16.04/badge.svg)
+[![GitHub release](https://img.shields.io/github/release/martijnvanbrummelen/nwipe)](https://github.com/martijnvanbrummelen/nwipe/releases/)

-nwipe is a program that will securely erase disks. It can operate as both a command line
-tool without a GUI or with an ncurses GUI as shown in the example below. It can wipe multiple
-disks simultaneously.
+nwipe is a program that will securely erase the entire contents of disks. It can operate as both a command line
+tool without a GUI or with a ncurses GUI as shown in the example below. It can wipe a single drive or multiple
+disks simultaneously. Nwipe can be found in many Linux distro repositories and the latest version of nwipe is available as a Bootable USB flash image from [here](https://github.com/PartialVolume/shredos.2020.02/blob/master/README.md#obtaining-and-writing-shredos-to-a-usb-flash-drive-the-easy-way-). This can be written to a USB flash drive in seconds, allowing you to boot straight into nwipe.

 The user can select from a variety of recognised secure erase methods which include:

@@ -22,13 +23,15 @@ It also includes the following pseudo random number generators:
 * ISAAC

 It is a fork of the dwipe command used by
-Darik's Boot and Nuke (dban).  nwipe is included with [partedmagic](https://partedmagic.com) and
-[ShredOS](https://github.com/nadenislamarre/shredos) if you want a quick and easy bootable CD or USB version.
+Darik's Boot and Nuke (dban).  nwipe is included with [partedmagic](https://partedmagic.com), [SystemRescueCD](http://www.system-rescue-cd) and
+[ShredOS](https://github.com/nadenislamarre/shredos)/[ShredOS 2020](https://github.com/PartialVolume/shredos.2020.02) if you want a quick and easy, bootable CD or USB version. If you want a bootable version of the very latest nwipe master that you can write to a USB stick, see [quick and easy bootable version of nwipe master](https://github.com/martijnvanbrummelen/nwipe#quick--easy-usb-bootable-version-of-nwipe-master-for-x86_64-systems)

 Nwipe was created out of a need to run the DBAN dwipe command outside
 of DBAN, in order to allow its use with any host distribution, thus
 giving better hardware support.

+The example below shows six drives being simultaneously erased. The video skips to the completion of all six wipes and shows five drives that were successfully erased and one drive that failed due to a I/O error. The drive that failed would then normally be physically destroyed. The five drives that were successfully wiped with zero errors or failures can then be redeployed.
+
 ![Example wipe](/images/example_wipe.gif)

 ## Compiling & Installing
@@ -39,6 +42,12 @@ giving better hardware support.
 * pthreads
 * parted

+and optionally, but recommended!, the following programs:
+
+* dmidecode
+* readlink
+* smartmontools
+
 ### Debian & Ubuntu prerequisites

 If you are compiling `nwipe` from source, the following libraries will need to be installed first:
@@ -51,7 +60,9 @@ sudo apt install \
  libncurses5-dev \
  autotools-dev \
  libparted-dev \
-  dmidecode
+  dmidecode \
+  coreutils \
+  smartmontools
 ```

 ### Fedora prerequisites
@@ -64,8 +75,22 @@ dnf groupinstall "C Development Tools and Libraries"
 yum install ncurses-devel
 yum install parted-devel
 yum install dmidecode
+yum install coreutils
+yum install smartmontools
 ```
-Note. dmidecode is optional, it provides SMBIOS/DMI host data to stdout or the log file.
+Note. The following programs are optionally installed although recommended. 1. dmidecode 2. readlink 3. smartmontools.
+
+#### dmidecode
+dmidecode provides SMBIOS/DMI host data to stdout or the log file. If you don't install it you won't see the SMBIOS/DMI host data at the beginning of nwipes log.
+
+#### coreutils (provides readlink) 
+readlink determines the bus type, i.e. ATA, USB etc. Without it the --nousb option won't work and bus type information will be missing from nwipes selection and wipe windows. The coreutils package is often automatically installed as default in most if not all distros.
+
+#### smartmontools
+smartmontools obtains serial number information for supported USB to IDE/SATA adapters. Without it, drives plugged into USB ports will not show serial number information.
+
+
+If you want a quick and easy way to keep your copy of nwipe running the latest master release of nwipe see this section [automating the download and compilation](https://github.com/martijnvanbrummelen/nwipe#automating-the-download-and-compilation-process-for-debian-based-distros)

 ### Compilation

@@ -73,7 +98,7 @@ For a development setup, see [the hacking section below](#Hacking).

 First create all the autoconf files:
 ```
-./init.sh
+./autogen.sh
 ```

 Then compile & install using the following standard commands:
@@ -123,6 +148,41 @@ with all the normal optimisations, using:
 ```
 ./configure --prefix=/usr && make && make install
 ```
+## Automating the download and compilation process for Debian based distros.
+
+Here's a script that will do just that!. It will create a directory in your home folder called 'nwipe_master'. It installs all the libraries required to compile the software (build-essential) and all the libraries that nwipe requires (libparted etc). It downloads the latest master copy of nwipe from github. It then compiles the software and then runs the latest nwipe. It doesn't write over the version of nwipe that's installed in the repository (If you had nwipe already installed). To run the latest master version of nwipe manually you would run it like this `sudo ~/nwipe_master/nwipe/src/nwipe`
+
+You can run the script multiple times, the first time it's run it will install all the libraries, subsequent times it will just say the the libraries are upto date. As it always downloads a fresh copy of the nwipe master from Github, you can always stay up to date. Just run it to get the latest version of nwipe. It takes all of 11 seconds on my I7.
+
+If you already have nwipe installed from the repository, you need to take care which version you are running. If you typed `nwipe` from any directory it will always run the original repository copy of nwipe. To run the latest nwipe you have to explicitly tell it where the new copy is, e.g in the directory `~/nwipe_master/nwipe/src` . That's why you would run it by typing `sudo ~/nwipe_master/nwipe/src/nwipe` alternatively you could cd to the directory and run it like this:
+
+```
+cd ~/nwipe_master/nwipe/src
+./nwipe
+```
+
+Note the ./, that means only look in the current directory for nwipe. if you forgot to type ./ the computer would run the older repository version of nwipe.
+
+Once you have copied the script below into a file called  buildnwipe, you need to give the file execute permissions `chmod +x buildnwipe` before you can run it. [Download script](
+https://drive.google.com/file/d/1-kKgvCvKYYuSH_UUBKrLwsI0Xf7fckGg/view?usp=sharing)
+```
+#!/bin/bash
+cd "$HOME"
+nwipe_directory="nwipe_master"
+mkdir $nwipe_directory
+cd $nwipe_directory
+sudo apt install build-essential pkg-config automake libncurses5-dev autotools-dev libparted-dev dmidecode readlink smartmontools git
+rm -rf nwipe
+git clone https://github.com/martijnvanbrummelen/nwipe.git
+cd "nwipe"
+./autogen.sh
+./configure
+make
+cd "src"
+sudo ./nwipe
+```
+## Quick & Easy, USB bootable version of Nwipe Master for x86_64 systems.
+If you want to just try out a bootable version of nwipe you can download the ShredOS image that's using the latest version of nwipe master and burn it to a USB stick. Instructions and download can be found [here](https://github.com/PartialVolume/shredos.2020.02/blob/master/README.md#obtaining-and-writing-shredos-to-a-usb-flash-drive-the-easy-way-)

 ## Bugs

--- a/autogen.sh
+++ b/autogen.sh
--- a/configure.ac
+++ b/configure.ac
@@ -2,7 +2,7 @@
 # Process this file with autoconf to produce a configure script.

 AC_PREREQ([2.64])
-AC_INIT([nwipe], [0.28], [git@brumit.nl])
+AC_INIT([nwipe], [0.30], [git@brumit.nl])
 AM_INIT_AUTOMAKE(foreign subdir-objects)
 AC_OUTPUT(Makefile src/Makefile man/Makefile)
 AC_CONFIG_SRCDIR([src/nwipe.c])
--- a/images/example_wipe.gif
+++ b/images/example_wipe.gif
--- a/man/nwipe.1
+++ b/man/nwipe.1
@@ -1,4 +1,4 @@
-.TH NWIPE "1" "March 2020" "nwipe version 0.28" "User Commands"
+.TH NWIPE "1" "December 2020" "nwipe version 0.30" "User Commands"
 .SH NAME
 nwipe \- securely erase disks
 .SH SYNOPSIS
@@ -34,6 +34,10 @@ If no devices have been specified on the command line, starts wiping all
 devices immediately. If devices have been specified, starts wiping only
 those specified devices immediately.
 .TP
+\fB\-\-autopoweroff\fR
+Power off system on completion of wipe delayed for for one minute. During
+this one minute delay you can abort the shutdown by typing sudo shutdown -c
+.TP
 \fB\-\-sync\fR
 Open devices in sync mode
 .TP
@@ -47,11 +51,18 @@ Do not wait for a key before exiting (default is to wait).
 \fB\-\-nosignals\fR
 Do not allow signals to interrupt a wipe (default is to allow).
 .TP
+\fB\-\-nousb\fR
+Do not show or wipe any USB devices, whether in GUI, --nogui or autonuke
+mode. (default is to allow USB devices to be shown and wiped).
+.TP
 \fB\-\-nogui\fR
 Do not show the GUI interface. Can only be used with the autonuke option.
 Nowait option is automatically invoked with the nogui option.
 SIGUSR1 can be used to retrieve the current wiping statistics.
 .TP
+\fB\-v\fR, \fB\-\-verbose\fR
+Log more messages, useful for debugging.
+.TP
 \fB\-\-verify\fR=\fITYPE\fR
 Whether to perform verification of erasure (default: last)
 .IP
--- a/src/context.h
+++ b/src/context.h
@@ -30,8 +30,11 @@ typedef enum nwipe_device_t_ {
    NWIPE_DEVICE_IDE,
    NWIPE_DEVICE_SCSI,
    NWIPE_DEVICE_COMPAQ,  // Unimplemented.
-    NWIPE_DEVICE_USB,  // Unimplemented.
-    NWIPE_DEVICE_IEEE1394  // Unimplemented.
+    NWIPE_DEVICE_USB,
+    NWIPE_DEVICE_IEEE1394,  // Unimplemented.
+    NWIPE_DEVICE_ATA,
+    NWIPE_DEVICE_NVME,
+    NWIPE_DEVICE_VIRT
 } nwipe_device_t;

 typedef enum nwipe_pass_t_ {
@@ -66,6 +69,7 @@ typedef struct nwipe_speedring_t_
 } nwipe_speedring_t;

 #define NWIPE_DEVICE_LABEL_LENGTH 200
+#define NWIPE_DEVICE_SIZE_TXT_LENGTH 7

 typedef struct nwipe_context_t_
 {
@@ -85,10 +89,12 @@ typedef struct nwipe_context_t_
    char* device_name;  // The device file name.
    long long device_size;  // The device size in bytes.
    char* device_size_text;  // The device size in a more (human)readable format.
+    char device_size_txt[NWIPE_DEVICE_SIZE_TXT_LENGTH];  // The device size in a more (human)readable format.
    char* device_model;  // The model of the device.
    char device_label[NWIPE_DEVICE_LABEL_LENGTH];  // The label (name, model, size and serial) of the device.
    struct stat device_stat;  // The device file state from fstat().
-    nwipe_device_t device_type;  // Indicates an IDE, SCSI, or Compaq SMART device.
+    nwipe_device_t device_type;  // Indicates an IDE, SCSI, or Compaq SMART device in enumerated form (int)
+    char device_type_str[14];  // Indicates an IDE, SCSI, USB etc as per nwipe_device_t but in ascii
    char device_serial_no[21];  // Serial number(processed, 20 characters plus null termination) of the device.
    int device_target;  // The device target.

@@ -118,6 +124,11 @@ typedef struct nwipe_context_t_
    u64 throughput;  // Average throughput in bytes per second.
    u64 verify_errors;  // The number of verification errors across all passes.
    int wipe_status;  // Wipe finished = 0, wipe in progress = 1, wipe yet to start = -1.
+    int spinner_idx;  // Index into the spinner character array
+    char spinner_character[1];  // The current spinner character
+    double duration;  // Duration of the wipe in seconds
+    time_t start_time;  // Start time of wipe
+    time_t end_time;  // End time of wipe
    /*
     * Identity contains the raw serial number of the drive
     * (where applicable), however, for use within nwipe use the
--- a/src/device.c
+++ b/src/device.c
@@ -20,10 +20,16 @@
 *
 */

+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+
+#include <stdio.h>
 #include <stdint.h>

 #include "nwipe.h"
 #include "context.h"
+#include "device.h"
 #include "method.h"
 #include "options.h"
 #include "logging.h"
@@ -41,6 +47,8 @@
 int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount );
 char* trim( char* str );

+extern int terminate_signal;
+
 int nwipe_device_scan( nwipe_context_t*** c )
 {
    /**
@@ -61,6 +69,13 @@ int nwipe_device_scan( nwipe_context_t*** c )
    {
        if( check_device( c, dev, dcount ) )
            dcount++;
+
+        /* Don't bother scanning drives if the terminate signal is active ! as in the case of
+         * the readlink program missing which is required if the --nousb option has been specified */
+        if( terminate_signal == 1 )
+        {
+            break;
+        }
    }

    /* Return the number of devices that were found. */
@@ -98,6 +113,13 @@ int nwipe_device_get( nwipe_context_t*** c, char** devnamelist, int ndevnames )

        if( check_device( c, dev, dcount ) )
            dcount++;
+
+        /* Don't bother scanning drives if the terminate signal is active ! as in the case of
+         * the readlink program missing which is required if the --nousb option has been specified */
+        if( terminate_signal == 1 )
+        {
+            break;
+        }
    }

    /* Return the number of devices that were found. */
@@ -111,6 +133,11 @@ int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )
    nwipe_context_t* next_device;
    int fd;
    int idx;
+    int r;
+    char tmp_serial[21];
+    nwipe_device_t bus;
+
+    bus = 0;

    /* Check whether this drive is on the excluded drive list ? */
    idx = 0;
@@ -123,6 +150,36 @@ int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )
        }
    }

+    /* Check whether the user has specified using the --nousb option
+     * that all USB devices should not be displayed or wiped whether
+     * in GUI, --nogui or --autonuke modes */
+
+    if( nwipe_options.nousb )
+    {
+        /* retrieve bus and drive serial number, HOWEVER we are only interested in the bus at this time */
+        r = nwipe_get_device_bus_type_and_serialno( dev->path, &bus, tmp_serial );
+
+        /* See nwipe_get_device_bus_type_and_serialno() function for meaning of these codes */
+        if( r == 0 || ( r >= 3 && r <= 6 ) )
+        {
+            if( bus == NWIPE_DEVICE_USB )
+            {
+                nwipe_log( NWIPE_LOG_NOTICE, "Device %s ignored as per command line option --nousb", dev->path );
+                return 0;
+            }
+        }
+        else
+        {
+            if( r == 2 )
+            {
+                nwipe_log(
+                    NWIPE_LOG_NOTICE, "--nousb requires the 'readlink' program, please install readlink", dev->path );
+                terminate_signal = 1;
+                return 0;
+            }
+        }
+    }
+
    /* Try opening the device to see if it's valid. Close on completion. */
    if( !ped_device_open( dev ) )
    {
@@ -149,9 +206,11 @@ int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )

    /* Get device information */
    next_device->device_model = dev->model;
+    remove_ATA_prefix( next_device->device_model );
    next_device->device_name = dev->path;
    next_device->device_size = dev->length * dev->sector_size;
-    next_device->device_size_text = ped_unit_format_byte( dev, dev->length * dev->sector_size );
+    Determine_C_B_nomenclature( next_device->device_size, next_device->device_size_txt, NWIPE_DEVICE_SIZE_TXT_LENGTH );
+    next_device->device_size_text = next_device->device_size_txt;
    next_device->result = -2;

    /* Attempt to get serial number of device. */
@@ -175,15 +234,70 @@ int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )

    // Terminate the string.
    next_device->device_serial_no[20] = 0;
+
    // Remove leading/trailing whitespace from serial number and left justify.
    trim( (char*) next_device->device_serial_no );

+    /* if we couldn't obtain serial number by using the above method .. try this */
+    r = nwipe_get_device_bus_type_and_serialno( next_device->device_name, &next_device->device_type, tmp_serial );
+
+    /* If serial number & bus retrieved (0) OR unsupported USB bus identified (5) */
+    if( r == 0 || r == 5 )
+    {
+        /* If the serial number hasn't already been populated */
+        if( next_device->device_serial_no[0] == 0 )
+        {
+            strcpy( next_device->device_serial_no, tmp_serial );
+        }
+    }
+
+    /* All device strings should be 4 characters, prefix with space if under 4 characters */
+    switch( next_device->device_type )
+    {
+        case NWIPE_DEVICE_UNKNOWN:
+            strcpy( next_device->device_type_str, " UNK" );
+            break;
+
+        case NWIPE_DEVICE_IDE:
+            strcpy( next_device->device_type_str, " IDE" );
+            break;
+
+        case NWIPE_DEVICE_SCSI:
+            strcpy( next_device->device_type_str, " SCSI" );
+            break;
+
+        case NWIPE_DEVICE_COMPAQ:
+            strcpy( next_device->device_type_str, " CPQ" );
+            break;
+
+        case NWIPE_DEVICE_USB:
+            strcpy( next_device->device_type_str, " USB" );
+            break;
+
+        case NWIPE_DEVICE_IEEE1394:
+            strcpy( next_device->device_type_str, "1394" );
+            break;
+
+        case NWIPE_DEVICE_ATA:
+            strcpy( next_device->device_type_str, " ATA" );
+            break;
+
+        case NWIPE_DEVICE_NVME:
+            strcpy( next_device->device_type_str, "NVME" );
+            break;
+
+        case NWIPE_DEVICE_VIRT:
+            strcpy( next_device->device_type_str, "VIRT" );
+            break;
+    }
+
    if( strlen( (const char*) next_device->device_serial_no ) )
    {
        snprintf( next_device->device_label,
                  NWIPE_DEVICE_LABEL_LENGTH,
-                  "%s (%s) - %s S/N:%s",
+                  "%s %s (%s) %s/%s",
                  next_device->device_name,
+                  next_device->device_type_str,
                  next_device->device_size_text,
                  next_device->device_model,
                  next_device->device_serial_no );
@@ -192,16 +306,18 @@ int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )
    {
        snprintf( next_device->device_label,
                  NWIPE_DEVICE_LABEL_LENGTH,
-                  "%s (%s) - %s",
+                  "%s %s (%s) %s",
                  next_device->device_name,
+                  next_device->device_type_str,
                  next_device->device_size_text,
                  next_device->device_model );
    }

-    nwipe_log( NWIPE_LOG_INFO,
-               "Found drive model=\"%s\", device path=\"%s\", size=\"%s\", serial number=\"%s\"",
-               next_device->device_model,
+    nwipe_log( NWIPE_LOG_NOTICE,
+               "Found %s, %s, %s, %s, S/N=%s",
               next_device->device_name,
+               next_device->device_type_str,
+               next_device->device_model,
               next_device->device_size_text,
               next_device->device_serial_no );

@@ -261,3 +377,328 @@ char* trim( char* str )
    }
    return str;
 }
+
+int nwipe_get_device_bus_type_and_serialno( char* device, nwipe_device_t* bus, char* serialnumber )
+{
+    /* The caller provides a string that contains the device, i.e. /dev/sdc, also a pointer
+     * to a integer (bus type) and thirdly a 21 byte
+     * character string which this function populates with the serial number (20 characters + null terminator).
+     *
+     * The function populates the bus integer and serial number strings for the given device.
+     * Results for bus would typically be ATA or USB see nwipe_device_t in context.h
+     *
+     * Return Values:
+     * 0 = Success
+     * 1 = popen failed to create stream for readlink
+     * 2 = readlink exit code not 0, see nwipe logs
+     * 3 = popen failed to create stream for smartctl
+     * 4 = smartctl command not found, install smartmontools
+     * 5 = smartctl detected un supported USB to IDE/SATA adapter
+     * 6 = All other errors !
+     *
+     */
+
+    FILE* fp;
+
+    int r;  // A result buffer.
+    int idx_src;
+    int idx_dest;
+    int device_len;
+    int set_return_value;
+    int exit_status;
+
+    char readlink_command[] = "readlink /sys/block/%s";
+    char readlink_command2[] = "/usr/bin/readlink /sys/block/%s";
+    char readlink_command3[] = "/sbin/readlink /sys/block/%s";
+    char smartctl_command[] = "smartctl -i %s";
+    char smartctl_command2[] = "/sbin/smartctl -i %s";
+    char smartctl_command3[] = "/usr/bin/smartctl -i %s";
+    char device_shortform[50];
+    char result[512];
+    char final_cmd_readlink[sizeof( readlink_command ) + sizeof( device_shortform )];
+    char final_cmd_smartctl[sizeof( smartctl_command ) + 256];
+
+    /* Initialise return value */
+    set_return_value = 0;
+
+    *bus = 0;
+
+    /* Scan device name and if device is for instance /dev/sdx then convert to sdx
+     * If already sdx then just copy. */
+
+    idx_dest = 0;
+    device_shortform[idx_dest] = 0;
+    device_len = strlen( device );
+    idx_src = device_len;
+
+    while( idx_src >= 0 )
+    {
+        if( device[idx_src] == '/' || idx_src == 0 )
+        {
+            idx_src++;
+
+            /* Now scan forwards copying the short form device i.e sdc */
+            while( idx_src < device_len )
+            {
+                device_shortform[idx_dest++] = device[idx_src++];
+            }
+            break;
+        }
+        else
+        {
+            idx_src--;
+        }
+    }
+    device_shortform[idx_dest] = 0;
+
+    final_cmd_readlink[0] = 0;
+
+    /* Determine whether we can access readlink, required if the PATH environment is not setup ! (Debian sid 'su' as
+     * opposed to 'su -' */
+    if( system( "which readlink > /dev/null 2>&1" ) )
+    {
+        if( system( "which /sbin/readlink > /dev/null 2>&1" ) )
+        {
+            if( system( "which /usr/bin/readlink > /dev/null 2>&1" ) )
+            {
+                nwipe_log( NWIPE_LOG_WARNING, "Command not found. Install readlink !" );
+                set_return_value = 2;
+
+                /* Return immediatley if --nousb specified. Readlink is a requirment for this option. */
+                if( nwipe_options.nousb )
+                {
+                    return set_return_value;
+                }
+            }
+            else
+            {
+                sprintf( final_cmd_readlink, readlink_command3, device_shortform );
+            }
+        }
+        else
+        {
+            sprintf( final_cmd_readlink, readlink_command2, device_shortform );
+        }
+    }
+    else
+    {
+        sprintf( final_cmd_readlink, readlink_command, device_shortform );
+    }
+
+    if( final_cmd_readlink[0] != 0 )
+    {
+
+        fp = popen( final_cmd_readlink, "r" );
+
+        if( fp == NULL )
+        {
+            nwipe_log( NWIPE_LOG_WARNING,
+                       "nwipe_get_device_bus_type_and_serialno: Failed to create stream to %s",
+                       readlink_command );
+
+            set_return_value = 1;
+        }
+
+        if( fp != NULL )
+        {
+            /* Read the output a line at a time - output it. */
+            if( fgets( result, sizeof( result ) - 1, fp ) != NULL )
+            {
+                if( nwipe_options.verbose )
+                {
+                    strip_CR_LF( result );
+                    nwipe_log( NWIPE_LOG_DEBUG, "Readlink: %s", result );
+                }
+
+                /* Scan the readlink results for bus types, i.e. USB or ATA
+                 * Example: readlink
+                 * /sys/block/sdd../devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.3/2-1.3:1.0/host6/target6:0:0/6:0:0:0/block/sdd
+                 */
+
+                if( strstr( result, "/usb" ) != 0 )
+                {
+                    *bus = NWIPE_DEVICE_USB;
+                }
+                else
+                {
+                    if( strstr( result, "/ata" ) != 0 )
+                    {
+                        *bus = NWIPE_DEVICE_ATA;
+                    }
+                    else
+                    {
+                        if( strstr( result, "/nvme/" ) != 0 )
+                        {
+                            *bus = NWIPE_DEVICE_NVME;
+                        }
+                        else
+                        {
+                            if( strstr( result, "/virtual/" ) != 0 )
+                            {
+                                *bus = NWIPE_DEVICE_VIRT;
+                            }
+                        }
+                    }
+                }
+            }
+            /* close */
+            r = pclose( fp );
+
+            if( r > 0 )
+            {
+                exit_status = WEXITSTATUS( r );
+                if( nwipe_options.verbose )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING,
+                               "nwipe_get_device_bus_type_and_serialno(): readlink failed, \"%s\" exit status = %u",
+                               final_cmd_readlink,
+                               exit_status );
+                }
+
+                if( exit_status == 127 )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING, "Command not found. Install Readlink recommended !" );
+                    set_return_value = 2;
+                    if( nwipe_options.nousb )
+                    {
+                        return set_return_value;
+                    }
+                }
+            }
+        }
+    }
+
+    /*
+     * Retrieve smartmontools drive information if USB bridge supports it, so we can retrieve the serial number of the
+     * drive that's on the other side of the USB bridge.. */
+
+    final_cmd_smartctl[0] = 0;
+
+    /* Determine whether we can access smartctl, required if the PATH environment is not setup ! (Debian sid 'su' as
+     * opposed to 'su -' */
+    if( system( "which smartctl > /dev/null 2>&1" ) )
+    {
+        if( system( "which /sbin/smartctl > /dev/null 2>&1" ) )
+        {
+            if( system( "which /usr/bin/smartctl > /dev/null 2>&1" ) )
+            {
+                nwipe_log( NWIPE_LOG_WARNING, "Command not found. Install smartmontools !" );
+            }
+            else
+            {
+                sprintf( final_cmd_smartctl, smartctl_command3, device );
+            }
+        }
+        else
+        {
+            sprintf( final_cmd_smartctl, smartctl_command2, device );
+        }
+    }
+    else
+    {
+        sprintf( final_cmd_smartctl, smartctl_command, device );
+    }
+
+    if( final_cmd_smartctl[0] != 0 )
+    {
+        fp = popen( final_cmd_smartctl, "r" );
+
+        if( fp == NULL )
+        {
+            nwipe_log( NWIPE_LOG_WARNING,
+                       "nwipe_get_device_bus_type_and_serialno(): Failed to create stream to %s",
+                       smartctl_command );
+
+            set_return_value = 3;
+        }
+        else
+        {
+            /* Read the output a line at a time - output it. */
+            while( fgets( result, sizeof( result ) - 1, fp ) != NULL )
+            {
+                if( nwipe_options.verbose && result[0] != 0x0A )
+                {
+                    strip_CR_LF( result );
+                    nwipe_log( NWIPE_LOG_DEBUG, "smartctl: %s", result );
+                }
+
+                if( strstr( result, "Serial Number:" ) != 0 )
+                {
+                    /* strip any leading or trailing spaces and left justify, +15 is the length of "Serial Number:" */
+                    trim( &result[15] );
+
+                    strncpy( serialnumber, &result[15], 20 );
+                }
+            }
+
+            /* close */
+            r = pclose( fp );
+
+            if( r > 0 )
+            {
+                exit_status = WEXITSTATUS( r );
+                if( nwipe_options.verbose && exit_status != 1 )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING,
+                               "nwipe_get_device_bus_type_and_serialno(): smartctl failed, \"%s\" exit status = %u",
+                               final_cmd_smartctl,
+                               exit_status );
+                }
+                set_return_value = 6;
+
+                if( exit_status == 127 )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING, "Command not found. Install Smartctl recommended !" );
+
+                    set_return_value = 4;
+                }
+
+                if( exit_status == 1 )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING, "%s USB bridge, no passthru support", device );
+
+                    if( *bus == NWIPE_DEVICE_USB )
+                    {
+                        strcpy( serialnumber, "(no ATA pass thru)" );
+                        set_return_value = 5;
+                    }
+                }
+            }
+        }
+    }
+
+    return set_return_value;
+}
+
+void strip_CR_LF( char* str )
+{
+    /* In the specified string, replace any CR or LF with a space */
+    int idx = 0;
+    int len = strlen( str );
+    while( idx < len )
+    {
+        if( str[idx] == 0x0A || str[idx] == 0x0D )
+        {
+            str[idx] = ' ';
+        }
+        idx++;
+    }
+}
+
+void remove_ATA_prefix( char* str )
+{
+    /* Remove "ATA " prefix if present in the model no. string, left justifing string */
+
+    int idx_pre = 4;
+    int idx_post = 0;
+
+    if( !strncmp( str, "ATA ", 4 ) )
+    {
+        while( str[idx_pre] != 0 )
+        {
+            str[idx_post++] = str[idx_pre++];
+        }
+
+        str[idx_post] = 0;
+    }
+}
--- a/src/device.h
+++ b/src/device.h
@@ -26,5 +26,9 @@
 void nwipe_device_identify( nwipe_context_t* c );  // Get hardware information about the device.
 int nwipe_device_scan( nwipe_context_t*** c );  // Find devices that we can wipe.
 int nwipe_device_get( nwipe_context_t*** c, char** devnamelist, int ndevnames );  // Get info about devices to wipe.
+int nwipe_get_device_bus_type_and_serialno( char*, nwipe_device_t*, char* );
+void strip_CR_LF( char* );
+void determine_disk_capacity_nomenclature( u64, char* );
+void remove_ATA_prefix( char* );

 #endif /* DEVICE_H_ */
--- a/src/gui.c
+++ b/src/gui.c
@@ -124,6 +124,10 @@ const char* stats_title = " Statistics ";

 /* Footer labels. */
 const char* main_window_footer = "S=Start M=Method P=PRNG V=Verify R=Rounds B=Blanking Space=Select Ctrl-C=Quit";
+const char* main_window_footer_warning_lower_case_s =
+    "  WARNING: To start the wipe press capital S, you pressed lower case s  ";
+const char* main_window_footer_warning_no_drive_selected =
+    "  No drives selected, use spacebar to select a drive, then press S to start  ";
 const char* selection_footer = "J=Down K=Up Space=Select Backspace=Cancel Ctrl-C=Quit";
 const char* end_wipe_footer = "B=Blank screen Ctrl-C=Quit";
 const char* rounds_footer = "Left=Erase Esc=Cancel Ctrl-C=Quit";
@@ -213,12 +217,21 @@ void nwipe_gui_init( void )
        /* Set white on green for success messages. */
        init_pair( 5, COLOR_WHITE, COLOR_GREEN );

-        /* Set white on green for failure messages. */
+        /* Set white on red for failure messages. */
        init_pair( 6, COLOR_WHITE, COLOR_RED );

        /* Set black on black for when hiding the display. */
        init_pair( 7, COLOR_BLACK, COLOR_BLACK );

+        /* Set green on blue for reverse bold messages */
+        init_pair( 8, COLOR_GREEN, COLOR_WHITE );
+
+        /* Set green on blue for reverse bold error messages */
+        init_pair( 9, COLOR_RED, COLOR_WHITE );
+
+        /* Set black on yellow for warning messages */
+        init_pair( 10, COLOR_BLACK, COLOR_YELLOW );
+
        /* Set the background style. */
        wbkgdset( stdscr, COLOR_PAIR( 1 ) | ' ' );
    }
@@ -517,7 +530,7 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
    int focus = 0;

    /* A generic loop variable. */
-    int i;
+    int i = 0;

    /* User input buffer. */
    int keystroke;
@@ -528,6 +541,12 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
    /* Flag, Valid key hit = 1, anything else = 0 */
    int validkeyhit;

+    /* counts number of drives and partitions that have been selected */
+    int number_of_selected_contexts = 0;
+
+    /* Control A toggle status -1=indefined, 0=all drives delected, 1=all drives selected */
+    int select_all_toggle_status = -1;
+
    /* Get the terminal size */
    getmaxyx( stdscr, stdscr_lines, stdscr_cols );

@@ -545,6 +564,38 @@ void nwipe_gui_select( int count, nwipe_context_t** c )

        /* Less two lines for the box and two lines for padding. */
        slots = wlines - 4;
+        if( slots < 0 )
+        {
+            slots = 0;
+        }
+
+        /* The code here adjusts the offset value, required when the terminal is resized vertically */
+        if( slots > count )
+        {
+            offset = 0;
+        }
+        else
+        {
+            if( focus >= count )
+            {
+                /* The focus is already at the last element. */
+                focus = count - 1;
+            }
+            if( focus < 0 )
+            {
+                /* The focus is already at the last element. */
+                focus = 0;
+            }
+        }
+
+        if( count >= slots && slots > 0 )
+        {
+            offset = focus + 1 - slots;
+            if( offset < 0 )
+            {
+                offset = 0;
+            }
+        }

        /* Clear the main window, necessary when switching selections such as method etc */
        werase( main_window );
@@ -595,42 +646,59 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
                waddch( main_window, ' ' );
            }

-            switch( c[i + offset]->select )
+            /* In the event of the offset value some how becoming invalid, this if statement will prevent a segfault
+             * and the else part will log the out of bounds values for debugging */
+            if( i + offset >= 0 && i + offset < count )
            {
-                case NWIPE_SELECT_TRUE:

-                    wprintw( main_window, " [wipe] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
-                    break;
+                switch( c[i + offset]->select )
+                {
+                    case NWIPE_SELECT_TRUE:

-                case NWIPE_SELECT_FALSE:
-                    /* Print an element that is not selected. */
-                    wprintw( main_window, " [    ] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
-                    break;
+                        wprintw( main_window, " [wipe] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
+                        break;

-                case NWIPE_SELECT_TRUE_PARENT:
+                    case NWIPE_SELECT_FALSE:
+                        /* Print an element that is not selected. */
+                        wprintw( main_window, " [    ] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
+                        break;

-                    /* This element will be wiped when its parent is wiped. */
-                    wprintw( main_window, " [****] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
-                    break;
+                    case NWIPE_SELECT_TRUE_PARENT:

-                case NWIPE_SELECT_FALSE_CHILD:
+                        /* This element will be wiped when its parent is wiped. */
+                        wprintw( main_window, " [****] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
+                        break;

-                    /* We can't wipe this element because it has a child that is being wiped. */
-                    wprintw( main_window, " [----] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
-                    break;
+                    case NWIPE_SELECT_FALSE_CHILD:

-                case NWIPE_SELECT_DISABLED:
+                        /* We can't wipe this element because it has a child that is being wiped. */
+                        wprintw( main_window, " [----] %i. %s", ( i + offset + 1 ), c[i + offset]->device_label );
+                        break;

-                    /* We don't know how to wipe this device. (Iomega Zip drives.) */
-                    wprintw( main_window, " [????] %s", "Unrecognized Device" );
-                    break;
+                    case NWIPE_SELECT_DISABLED:

-                default:
+                        /* We don't know how to wipe this device. (Iomega Zip drives.) */
+                        wprintw( main_window, " [????] %s", "Unrecognized Device" );
+                        break;

-                    /* TODO: Handle the sanity error. */
-                    break;
+                    default:

-            } /* switch select */
+                        /* TODO: Handle the sanity error. */
+                        break;
+
+                } /* switch select */
+            }
+            else
+            {
+                nwipe_log( NWIPE_LOG_DEBUG,
+                           "GUI.c,nwipe_gui_select(), scroll, array index out of bounds, i=%u, count=%u, slots=%u, "
+                           "focus=%u, offset=%u",
+                           i,
+                           count,
+                           slots,
+                           focus,
+                           offset );
+            }

        } /* for */

@@ -666,20 +734,27 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
         * which wastes CPU cycles.
         */

-        validkeyhit = 0;
-
        do
        {
+            validkeyhit = 0;
            timeout( 250 );  // block getch() for 250ms.
            keystroke = getch();  // Get user input.
            timeout( -1 );  // Switch back to blocking mode.

+            /* We don't necessarily use these but for future reference, here are some cntrl + key values
+             * ^W - 23, ^E - 5, ^R - 18, ^T - 20, ^Y - 25, ^U - 21, ^I - 9, ^O - 15, ^P - 16, ^A - 1, ^D - 4
+             * ^F - 6, ^G - 7, ^H - 8, ^K - 11, ^L - 12, ^X - 24, ^V - 22, ^B - 2, ^N - 14
+             * Use nwipe_log( NWIPE_LOG_DEBUG, "Key Name: %s - %u", keyname(keystroke),keystroke) to
+             * figure out what code is returned by what ever key combination */
+
            switch( keystroke )
            {
                case KEY_DOWN:
                case 'j':
                case 'J':

+                    validkeyhit = 1;
+
                    /* Increment the focus. */
                    focus += 1;

@@ -696,7 +771,6 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
                        offset += 1;
                        break;
                    }
-                    validkeyhit = 1;

                    break;

@@ -704,6 +778,8 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
                case 'k':
                case 'K':

+                    validkeyhit = 1;
+
                    /* Decrement the focus. */
                    focus -= 1;

@@ -720,7 +796,6 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
                        offset -= 1;
                        break;
                    }
-                    validkeyhit = 1;

                    break;

@@ -728,6 +803,8 @@ void nwipe_gui_select( int count, nwipe_context_t** c )
                case 10:
                case ' ':

+                    validkeyhit = 1;
+
                    /* TODO: This block should be made into a function. */

                    if( c[focus]->select == NWIPE_SELECT_TRUE )
@@ -794,8 +871,6 @@ void nwipe_gui_select( int count, nwipe_context_t** c )

                        } /* else super-enable */

-                        validkeyhit = 1;
-
                        break;

                    } /* if NWIPE_SELECT_TRUE */
@@ -842,60 +917,164 @@ void nwipe_gui_select( int count, nwipe_context_t** c )

                        } /* else super-deselect */

-                        validkeyhit = 1;
-
                        break;

                    } /* if NWIPE_SELECT_FALSE */

                    /* TODO: Explain to the user why they can't change this. */
-                    validkeyhit = 1;
                    break;

                case 'm':
                case 'M':

+                    validkeyhit = 1;
+
                    /*  Run the method dialog. */
                    nwipe_gui_method();
-                    validkeyhit = 1;
                    break;

                case 'p':
                case 'P':

+                    validkeyhit = 1;
+
                    /* Run the PRNG dialog. */
                    nwipe_gui_prng();
-                    validkeyhit = 1;
+
                    break;

                case 'r':
                case 'R':

+                    validkeyhit = 1;
+
                    /* Run the rounds dialog. */
                    nwipe_gui_rounds();
-                    validkeyhit = 1;
+
                    break;

                case 'v':
                case 'V':

+                    validkeyhit = 1;
+
                    /* Run the option dialog. */
                    nwipe_gui_verify();
-                    validkeyhit = 1;
                    break;

                case 'b':
                case 'B':

+                    validkeyhit = 1;
+
                    /* Run the noblank dialog. */
                    nwipe_gui_noblank();
-                    validkeyhit = 1;
                    break;

                case 'S':

-                    /* User want to start the wipe */
+                    /* User wants to start the wipe */
                    validkeyhit = 1;
+
+                    /* Have any drives have been selected ? */
+                    number_of_selected_contexts = 0;
+                    for( i = 0; i < count; i++ )
+                    {
+                        if( c[i]->select == NWIPE_SELECT_TRUE )
+                        {
+                            number_of_selected_contexts += 1;
+                        }
+                    }
+
+                    /* if no drives have been selected, print a warning on the footer */
+                    if( number_of_selected_contexts == 0 )
+                    {
+                        wattron( footer_window, COLOR_PAIR( 10 ) );
+                        nwipe_gui_amend_footer_window( main_window_footer_warning_no_drive_selected );
+                        doupdate();
+                        sleep( 3 );
+                        wattroff( footer_window, COLOR_PAIR( 10 ) );
+
+                        /* After the delay return footer text back to key help */
+                        nwipe_gui_amend_footer_window( main_window_footer );
+                        doupdate();
+
+                        /* Remove any repeated S key strokes, without this the gui would hang
+                         * for a period of time, i.e sleep above x number of repeated 's' keystrokes
+                         * which could run into minutes */
+                        do
+                        {
+                            timeout( 250 );  // block getch() for 250ms.
+                            keystroke = getch();  // Get user input.
+                            timeout( -1 );  // Switch back to blocking mode.
+                        } while( keystroke == 'S' );
+
+                        /* Remove the S from keystroke, which allows us to stay within the selection menu loop */
+                        keystroke = 0;
+                    }
+
+                    break;
+
+                case 's':
+
+                    /* user has mistakenly hit the lower case 's' instead of capital 'S' */
+                    validkeyhit = 1;
+
+                    /* Warn the user about their mistake */
+                    wattron( footer_window, COLOR_PAIR( 10 ) );
+                    nwipe_gui_amend_footer_window( main_window_footer_warning_lower_case_s );
+                    doupdate();
+                    sleep( 3 );
+                    wattroff( footer_window, COLOR_PAIR( 10 ) );
+
+                    /* After the delay return footer text back to key help */
+                    nwipe_gui_amend_footer_window( main_window_footer );
+                    doupdate();
+
+                    /* Remove any repeated s key strokes, without this the gui would hang
+                     * for a period of time, i.e sleep above x number of repeated 's' keystrokes
+                     * which could run into minutes */
+                    do
+                    {
+                        timeout( 250 );  // block getch() for 250ms.
+                        keystroke = getch();  // Get user input.
+                        timeout( -1 );  // Switch back to blocking mode.
+                    } while( keystroke == 's' );
+
+                    break;
+
+                case 1:
+
+                    /* Ctrl A - Toggle select/deselect all drives */
+                    validkeyhit = 1;
+
+                    if( select_all_toggle_status == -1 || select_all_toggle_status == 0 )
+                    {
+                        for( i = 0; i < count; i++ )
+                        {
+                            c[i]->select = NWIPE_SELECT_TRUE;
+                        }
+                        select_all_toggle_status = 1;
+                    }
+                    else
+                    {
+                        if( select_all_toggle_status == 1 )
+                        {
+                            for( i = 0; i < count; i++ )
+                            {
+                                c[i]->select = NWIPE_SELECT_FALSE;
+                            }
+                            select_all_toggle_status = 0;
+                        }
+                        else
+                        {
+                            nwipe_log(
+                                NWIPE_LOG_ERROR,
+                                "gui.c:nwipe_gui_select(), Invalid value in variable select_all_toggle_status = %d",
+                                select_all_toggle_status );
+                        }
+                    }
+
                    break;

            } /* keystroke switch */
@@ -910,6 +1089,14 @@ void nwipe_gui_select( int count, nwipe_context_t** c )

    } while( keystroke != 'S' && terminate_signal != 1 );

+    if( keystroke == 'S' )
+    {
+        /* If user has pressed S to start wipe change status line */
+        werase( footer_window );
+        nwipe_gui_title( footer_window, end_wipe_footer );
+        wnoutrefresh( footer_window );
+    }
+
 } /* nwipe_gui_select */

 void nwipe_gui_options( void )
@@ -2079,15 +2266,10 @@ void* nwipe_gui_status( void* ptr )
    nwipe_misc_thread_data = nwipe_thread_data_ptr->nwipe_misc_thread_data;
    count = nwipe_misc_thread_data->nwipe_selected;

-    /* Throughput print formats. */
-    char* nwipe_tera = "%llu TB/s";
-    char* nwipe_giga = "%llu GB/s";
-    char* nwipe_mega = "%llu MB/s";
-    char* nwipe_kilo = "%llu KB/s";
-    char* nwipe_unit = "%llu B/s";
+    char nomenclature_result_str[NOMENCLATURE_RESULT_STR_SIZE]; /* temporary usage */

-    /* The throughput format pointer. */
-    char* nwipe_format;
+    /* Spinner character */
+    char spinner_string[2];

    /* We count time from when this function is first called. */
    static time_t nwipe_time_start = 0;
@@ -2143,7 +2325,6 @@ void* nwipe_gui_status( void* ptr )

    /* Throughput variables */
    u64 nwipe_throughput;
-    u64 nwipe_throughput_stopped;

    /* The number of active wipe processes. */
    /* Set to 1 initially to start loop.    */
@@ -2317,7 +2498,7 @@ void* nwipe_gui_status( void* ptr )
                case 0x0a:

                    /* Check whether we have finished all wipes, if yes exit while loop if user pressed spacebar or
-                     * return */
+                     * return. */
                    if( !nwipe_active || terminate_signal == 1 )
                    {
                        loop_control = 0;
@@ -2333,11 +2514,21 @@ void* nwipe_gui_status( void* ptr )

        } /* keystroke */

+        /* if wipe has completed and user has specified auto poweroff or nowait then we can skip waiting for the user to
+         * press return */
+        if( !nwipe_active )
+        {
+            if( nwipe_options.autopoweroff || nwipe_options.nowait )
+            {
+                loop_control = 0;
+            }
+        }
+
        /* Update screen if not blanked. */
        if( nwipe_gui_blank == 0 )
        {

-            if( nwipe_active && terminate_signal != 1 )
+            if( terminate_signal != 1 )
            {
                nwipe_active = compute_stats( ptr );  // Returns number of active wipe threads
            }
@@ -2355,7 +2546,7 @@ void* nwipe_gui_status( void* ptr )
                    mvwprintw( main_window,
                               yy++,
                               4,
-                               "[%05.2f%%, round %i of %i, pass %i of %i] ",
+                               "[%5.2f%%, round %i of %i, pass %i of %i] ",
                               c[i]->round_percent,
                               c[i]->round_working,
                               c[i]->round_count,
@@ -2371,11 +2562,15 @@ void* nwipe_gui_status( void* ptr )
                    }
                    else if( c[i]->signal )
                    {
+                        wattron( main_window, COLOR_PAIR( 9 ) );
                        mvwprintw( main_window, yy++, 4, "(>>> FAILURE! <<<, signal %i) ", c[i]->signal );
+                        wattroff( main_window, COLOR_PAIR( 9 ) );
                    }
                    else
                    {
+                        wattron( main_window, COLOR_PAIR( 9 ) );
                        mvwprintw( main_window, yy++, 4, "(>>>FAILURE!<<<, code %i) ", c[i]->result );
+                        wattroff( main_window, COLOR_PAIR( 9 ) );
                    }

                } /* child returned */
@@ -2388,57 +2583,71 @@ void* nwipe_gui_status( void* ptr )
                {
                    wprintw( main_window, "[pass errors: %llu] ", c[i]->pass_errors );
                }
-
-                switch( c[i]->pass_type )
+                if( c[i]->wipe_status == 1 )
                {
-                    case NWIPE_PASS_FINAL_BLANK:
-                        wprintw( main_window, "[blanking] " );
-                        break;
+                    switch( c[i]->pass_type )
+                    {
+                        /* Each text field in square brackets should be the same number of characters
+                         * to retain output in columns */
+                        case NWIPE_PASS_FINAL_BLANK:
+                            if( !c[i]->sync_status )
+                            {
+                                wprintw( main_window, "[ blanking] " );
+                            }
+                            break;

-                    case NWIPE_PASS_FINAL_OPS2:
-                        wprintw( main_window, "[OPS-II final] " );
-                        break;
+                        case NWIPE_PASS_FINAL_OPS2:
+                            if( !c[i]->sync_status )
+                            {
+                                wprintw( main_window, "[OPS2final] " );
+                            }
+                            break;

-                    case NWIPE_PASS_WRITE:
-                        wprintw( main_window, "[writing] " );
-                        break;
+                        case NWIPE_PASS_WRITE:
+                            if( !c[i]->sync_status )
+                            {
+                                wprintw( main_window, "[ writing ] " );
+                            }
+                            break;

-                    case NWIPE_PASS_VERIFY:
-                        wprintw( main_window, "[verifying] " );
-                        break;
+                        case NWIPE_PASS_VERIFY:
+                            if( !c[i]->sync_status )
+                            {
+                                wprintw( main_window, "[verifying] " );
+                            }
+                            break;

-                    case NWIPE_PASS_NONE:
-                        break;
+                        case NWIPE_PASS_NONE:
+                            break;
+                    }
+
+                    if( c[i]->sync_status )
+                    {
+                        wprintw( main_window, "[ syncing ] " );
+                    }
                }

-                if( c[i]->sync_status )
-                {
-                    wprintw( main_window, "[syncing] " );
-                }
+                /* Determine throughput nomenclature for this drive and output drives throughput to GUI */
+                Determine_C_B_nomenclature( c[i]->throughput, nomenclature_result_str, NOMENCLATURE_RESULT_STR_SIZE );

-                if( c[i]->throughput >= INT64_C( 1000000000000 ) )
-                {
-                    wprintw( main_window, "[%llu TB/s] ", c[i]->throughput / INT64_C( 1000000000000 ) );
-                }
-                else if( c[i]->throughput >= INT64_C( 1000000000 ) )
-                {
-                    wprintw( main_window, "[%llu GB/s] ", c[i]->throughput / INT64_C( 1000000000 ) );
-                }
-                else if( c[i]->throughput >= INT64_C( 1000000 ) )
-                {
-                    wprintw( main_window, "[%llu MB/s] ", c[i]->throughput / INT64_C( 1000000 ) );
-                }
-                else if( c[i]->throughput >= INT64_C( 1000 ) )
-                {
-                    wprintw( main_window, "[%llu KB/s] ", c[i]->throughput / INT64_C( 1000 ) );
-                }
-                else
-                {
-                    wprintw( main_window, "[%llu B/s] ", c[i]->throughput / INT64_C( 1 ) );
-                }
+                wprintw( main_window, "[%s/s] ", nomenclature_result_str );

                /* Insert whitespace. */
                yy += 1;
+
+                /* Increment the next spinner character for this context if the thread is active */
+                if( c[i]->wipe_status == 1 )
+                {
+                    spinner( c, i );
+                    spinner_string[0] = c[i]->spinner_character[0];
+                }
+                else
+                {
+                    /* if the wipe thread is no longer active, replace the spinner with a space */
+                    spinner_string[0] = ' ';
+                }
+                spinner_string[1] = 0;
+                wprintw( main_window, " %s ", spinner_string );
            }

            if( offset > 0 )
@@ -2463,48 +2672,18 @@ void* nwipe_gui_status( void* ptr )
            if( nwipe_active && terminate_signal != 1 )
            {
                nwipe_gui_load();
-                nwipe_throughput = nwipe_misc_thread_data->throughput;
-                nwipe_throughput_stopped = nwipe_throughput;
-            }
-            else
-            {
-                nwipe_throughput = nwipe_throughput_stopped;
            }

-            if( nwipe_throughput >= INT64_C( 1000000000000 ) )
-            {
-                nwipe_throughput /= INT64_C( 1000000000000 );
-                nwipe_format = nwipe_tera;
-            }
-            else if( nwipe_throughput >= INT64_C( 1000000000 ) )
-            {
-                nwipe_throughput /= INT64_C( 1000000000 );
-                nwipe_format = nwipe_giga;
-            }
-            else if( nwipe_throughput >= INT64_C( 1000000 ) )
-            {
-                nwipe_throughput /= INT64_C( 1000000 );
-                nwipe_format = nwipe_mega;
-            }
-            else if( nwipe_throughput >= INT64_C( 1000 ) )
-            {
-                nwipe_throughput /= INT64_C( 1000 );
-                nwipe_format = nwipe_kilo;
-            }
-            else
-            {
-                nwipe_throughput /= INT64_C( 1 );
-                nwipe_format = nwipe_unit;
-            }
+            nwipe_throughput = nwipe_misc_thread_data->throughput;
+
+            /* Determine the nomenclature for the combined throughput */
+            Determine_C_B_nomenclature( nwipe_throughput, nomenclature_result_str, NOMENCLATURE_RESULT_STR_SIZE );

            /* Print the combined throughput. */
            mvwprintw( stats_window, NWIPE_GUI_STATS_THROUGHPUT_Y, NWIPE_GUI_STATS_THROUGHPUT_X, "Throughput:" );

-            if( nwipe_throughput > 0 )
-            {
-                mvwprintw(
-                    stats_window, NWIPE_GUI_STATS_THROUGHPUT_Y, NWIPE_GUI_STATS_TAB, nwipe_format, nwipe_throughput );
-            }
+            mvwprintw(
+                stats_window, NWIPE_GUI_STATS_THROUGHPUT_Y, NWIPE_GUI_STATS_TAB, "%s/s", nomenclature_result_str );

            /* Change the current time into a delta. */
            nwipe_time_now -= nwipe_time_start;
@@ -2551,7 +2730,7 @@ void* nwipe_gui_status( void* ptr )
            /* Print the error count. */
            mvwprintw( stats_window, NWIPE_GUI_STATS_ERRORS_Y, NWIPE_GUI_STATS_ERRORS_X, "Errors:" );
            mvwprintw(
-                stats_window, NWIPE_GUI_STATS_ERRORS_Y, NWIPE_GUI_STATS_TAB, "%llu", nwipe_misc_thread_data->errors );
+                stats_window, NWIPE_GUI_STATS_ERRORS_Y, NWIPE_GUI_STATS_TAB, "  %llu", nwipe_misc_thread_data->errors );

            /* Add a border. */
            box( stats_window, 0, 0 );
@@ -2616,37 +2795,43 @@ int compute_stats( void* ptr )
        {
            /* Increment the child counter. */
            nwipe_active += 1;
-        }

-        /* Even if the wipe has finished ALWAYS run the stats one last time so the final SUCCESS percentage value is
-         * correct. Maintain a rolling average of throughput. */
-        nwipe_update_speedring( &c[i]->speedring, c[i]->round_done, nwipe_time_now );
+            /* Even if the wipe has finished ALWAYS run the stats one last time so the final SUCCESS percentage value is
+             * correct. Maintain a rolling average of throughput. */
+            nwipe_update_speedring( &c[i]->speedring, c[i]->round_done, nwipe_time_now );

-        if( c[i]->speedring.timestotal > 0 && c[i]->wipe_status == 1 )
-        {
-            /* Update the current average throughput in bytes-per-second. */
-            c[i]->throughput = c[i]->speedring.bytestotal / c[i]->speedring.timestotal;
-
-            /* Update the estimated remaining runtime. */
-            /* Check that throughput is not zero (sometimes caused during a sync) */
-            if( c[i]->throughput == 0 )
+            if( c[i]->speedring.timestotal > 0 && c[i]->wipe_status == 1 )
            {
-                c[i]->throughput = 1;
+                /* Update the current average throughput in bytes-per-second. */
+                c[i]->throughput = c[i]->speedring.bytestotal / c[i]->speedring.timestotal;
+
+                /* Update the estimated remaining runtime. */
+                /* Check that throughput is not zero (sometimes caused during a sync) */
+                if( c[i]->throughput == 0 )
+                {
+                    c[i]->throughput = 1;
+                }
+
+                c[i]->eta = ( c[i]->round_size - c[i]->round_done ) / c[i]->throughput;
+
+                if( c[i]->eta > nwipe_misc_thread_data->maxeta )
+                {
+                    nwipe_misc_thread_data->maxeta = c[i]->eta;
+                }
            }

-            c[i]->eta = ( c[i]->round_size - c[i]->round_done ) / c[i]->throughput;
-
-            if( c[i]->eta > nwipe_misc_thread_data->maxeta )
-            {
-                nwipe_misc_thread_data->maxeta = c[i]->eta;
-            }
+            /* Calculate the average throughput */
+            c[i]->throughput = (double) c[i]->round_done / (double) difftime( nwipe_time_now, c[i]->start_time );
        }

        /* Update the percentage value. */
        c[i]->round_percent = (double) c[i]->round_done / (double) c[i]->round_size * 100;

-        /* Accumulate combined throughput. */
-        nwipe_misc_thread_data->throughput += c[i]->throughput;
+        if( c[i]->wipe_status == 1 )
+        {
+            /* Accumulate combined throughput. */
+            nwipe_misc_thread_data->throughput += c[i]->throughput;
+        }

        /* Accumulate the error count. */
        nwipe_misc_thread_data->errors += c[i]->pass_errors;
@@ -2694,3 +2879,30 @@ void nwipe_update_speedring( nwipe_speedring_t* speedring, u64 speedring_bytes,
        speedring->position = 0;
    }
 }
+
+int spinner( nwipe_context_t** ptr, int device_idx )
+{
+    nwipe_context_t** c;
+
+    c = ptr;
+
+    /* The spinner characters |/-\|/-\ */
+    char sc[9] = "|/-\\|/-\\/";
+
+    /* check sanity of index */
+    if( c[device_idx]->spinner_idx < 0 || c[device_idx]->spinner_idx > 7 )
+    {
+        return 1;
+    }
+
+    c[device_idx]->spinner_character[0] = sc[c[device_idx]->spinner_idx];
+
+    c[device_idx]->spinner_idx++;
+
+    if( c[device_idx]->spinner_idx > 7 )
+    {
+        c[device_idx]->spinner_idx = 0;
+    }
+
+    return 0;
+}
--- a/src/gui.h
+++ b/src/gui.h
@@ -40,8 +40,11 @@ void nwipe_gui_prng( void );  // Change the prng option.
 void nwipe_gui_rounds( void );  // Change the rounds option.
 void nwipe_gui_verify( void );  // Change the verify option.
 void nwipe_gui_noblank( void );  // Change the noblank option.
+int spinner( nwipe_context_t** ptr, int );  // Return the next spinner character

 int compute_stats( void* ptr );
 void nwipe_update_speedring( nwipe_speedring_t* speedring, u64 speedring_done, time_t speedring_now );

+#define NOMENCLATURE_RESULT_STR_SIZE 8
+
 #endif /* GUI_H_ */
--- a/src/logging.c
+++ b/src/logging.c
@@ -28,6 +28,7 @@

 #include "stdio.h"
 #include "stdlib.h"
+#include "string.h"
 #include "stdarg.h"
 #include "nwipe.h"
 #include "context.h"
@@ -77,16 +78,22 @@ void nwipe_log( nwipe_log_t level, const char* format, ... )
    /* Position of writing to current log string */
    int line_current_pos = 0;

+    /* initialise characters written */
+    chars_written = 0;
+
    /* Print the date. The rc script uses the same format. */
-    chars_written = snprintf( message_buffer,
-                              MAX_LOG_LINE_CHARS,
-                              "[%i/%02i/%02i %02i:%02i:%02i] nwipe: ",
-                              1900 + p->tm_year,
-                              1 + p->tm_mon,
-                              p->tm_mday,
-                              p->tm_hour,
-                              p->tm_min,
-                              p->tm_sec );
+    if( level != NWIPE_LOG_NOTIMESTAMP )
+    {
+        chars_written = snprintf( message_buffer,
+                                  MAX_LOG_LINE_CHARS,
+                                  "[%i/%02i/%02i %02i:%02i:%02i] ",
+                                  1900 + p->tm_year,
+                                  1 + p->tm_mon,
+                                  p->tm_mday,
+                                  p->tm_hour,
+                                  p->tm_min,
+                                  p->tm_sec );
+    }

    /*
     * Has the end of the buffer been reached ?, snprintf returns the number of characters that would have been
@@ -127,22 +134,28 @@ void nwipe_log( nwipe_log_t level, const char* format, ... )
        {

            case NWIPE_LOG_NONE:
+            case NWIPE_LOG_NOTIMESTAMP:
                /* Do nothing. */
                break;

+                /* NOTE! The debug labels, i.e. debug, info, notice etc should be left padded with spaces, in order
+                 * to maintain column alignment. Pad a label to achieve the length of whatever the longest label happens
+                 * to be. Important to know if you are thinking of adding another label.
+                 */
+
            case NWIPE_LOG_DEBUG:
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "debug: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "  debug: " );
                break;

            case NWIPE_LOG_INFO:
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "info: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "   info: " );
                break;

            case NWIPE_LOG_NOTICE:
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "notice: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, " notice: " );
                break;

            case NWIPE_LOG_WARNING:
@@ -152,18 +165,18 @@ void nwipe_log( nwipe_log_t level, const char* format, ... )

            case NWIPE_LOG_ERROR:
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "error: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "  error: " );
                break;

            case NWIPE_LOG_FATAL:
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "fatal: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "  fatal: " );
                break;

            case NWIPE_LOG_SANITY:
                /* TODO: Request that the user report the log. */
                chars_written =
-                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "sanity: " );
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, " sanity: " );
                break;

            default:
@@ -391,6 +404,88 @@ void nwipe_perror( int nwipe_errno, const char* f, const char* s )

 } /* nwipe_perror */

+void nwipe_log_OSinfo()
+{
+    /* Read /proc/version, format and write to the log */
+
+    FILE* fp = NULL;
+    char OS_info_temp[MAX_SIZE_OS_STRING + 1];
+    char OS_info[MAX_SIZE_OS_STRING + 1];
+    int idx;
+    int idx2;
+    int idx3;
+    int idx4;
+
+    /* initialise OS_info & OS_info_temp strings */
+    idx = 0;
+    while( idx < MAX_SIZE_OS_STRING + 1 )
+    {
+        OS_info_temp[idx] = 0;
+        OS_info[idx] = 0;
+        idx++;
+    }
+
+    /* Open a pipe to /proc/version for reading */
+    fp = popen( "cat /proc/version", "r" );
+    if( fp == NULL )
+    {
+        nwipe_log( NWIPE_LOG_WARNING, "Unable to create a pipe to /proc/version" );
+        return;
+    }
+
+    /* Read the OS info */
+    if( fgets( OS_info_temp, MAX_SIZE_OS_STRING, fp ) == NULL )
+    {
+        nwipe_log( NWIPE_LOG_WARNING, "fget failed to read /proc/version" );
+        fclose( fp );
+        return;
+    }
+
+    /* Format the string for the log, place on multiple lines as necessary,
+     * column aligned, left offset with n (OS_info_Line_offset) spaces */
+    idx = 0;
+    idx2 = 0;
+    idx3 = OS_info_Line_Length;
+
+    while( OS_info_temp[idx] != 0 )
+    {
+        while( idx2 < idx3 && idx2 < MAX_SIZE_OS_STRING )
+        {
+            /* remove newlines from the source */
+            if( OS_info_temp[idx] == 0x0a )
+            {
+                idx++;
+            }
+
+            /* copy the character */
+            OS_info[idx2++] = OS_info_temp[idx++];
+        }
+        if( OS_info_temp[idx] != 0 )
+        {
+            OS_info[idx2++] = 0x0a;
+            idx4 = 0;
+
+            /* left indent with spaces */
+            while( idx4 < OS_info_Line_offset && idx2 < MAX_SIZE_OS_STRING )
+            {
+                OS_info[idx2++] = ' ';
+                idx4++;
+            }
+
+            /* calculate idx3 ready for next line */
+            idx3 += OS_info_Line_offset + OS_info_Line_Length;
+        }
+        else
+        {
+            continue;
+        }
+    }
+
+    nwipe_log( NWIPE_LOG_INFO, "%s", OS_info );
+    fclose( fp );
+    return;
+}
+
 int nwipe_log_sysinfo()
 {
    FILE* fp;
@@ -429,45 +524,387 @@ int nwipe_log_sysinfo()
    };

    char dmidecode_command[] = "dmidecode -s %s";
+    char dmidecode_command2[] = "/sbin/dmidecode -s %s";
+    char dmidecode_command3[] = "/usr/bin/dmidecode -s %s";
+    char* p_dmidecode_command;

-    char cmd[sizeof( dmidecode_keywords ) + sizeof( dmidecode_command )];
+    char cmd[sizeof( dmidecode_keywords ) + sizeof( dmidecode_command2 )];

    unsigned int keywords_idx;

    keywords_idx = 0;

-    /* Run the dmidecode command to retrieve each dmidecode keyword, one at a time */
-    while( dmidecode_keywords[keywords_idx][0] != 0 )
+    p_dmidecode_command = 0;
+
+    if( system( "which dmidecode > /dev/null 2>&1" ) )
    {
-        sprintf( cmd, dmidecode_command, &dmidecode_keywords[keywords_idx][0] );
-        fp = popen( cmd, "r" );
-        if( fp == NULL )
+        if( system( "which /sbin/dmidecode > /dev/null 2>&1" ) )
        {
-            nwipe_log( NWIPE_LOG_INFO, "nwipe_log_sysinfo: Failed to create stream to %s", cmd );
-            return 1;
-        }
-        /* Read the output a line at a time - output it. */
-        while( fgets( path, sizeof( path ) - 1, fp ) != NULL )
-        {
-            /* Remove any trailing return from the string, as nwipe_log automatically adds a return */
-            len = strlen( path );
-            if( path[len - 1] == '\n' )
+            if( system( "which /usr/bin/dmidecode > /dev/null 2>&1" ) )
            {
-                path[len - 1] = 0;
+                nwipe_log( NWIPE_LOG_WARNING, "Command not found. Install dmidecode !" );
+            }
+            else
+            {
+                p_dmidecode_command = &dmidecode_command3[0];
            }
-            nwipe_log( NWIPE_LOG_INFO, "%s = %s", &dmidecode_keywords[keywords_idx][0], path );
        }
-        /* close */
-        r = pclose( fp );
-        if( r > 0 )
+        else
        {
-            nwipe_log( NWIPE_LOG_INFO,
-                       "nwipe_log_sysinfo(): dmidecode failed, \"%s\" exit status = %u",
-                       cmd,
-                       WEXITSTATUS( r ) );
-            return 1;
+            p_dmidecode_command = &dmidecode_command2[0];
+        }
+    }
+    else
+    {
+        p_dmidecode_command = &dmidecode_command[0];
+    }
+
+    if( p_dmidecode_command != 0 )
+    {
+
+        /* Run the dmidecode command to retrieve each dmidecode keyword, one at a time */
+        while( dmidecode_keywords[keywords_idx][0] != 0 )
+        {
+            sprintf( cmd, p_dmidecode_command, &dmidecode_keywords[keywords_idx][0] );
+            fp = popen( cmd, "r" );
+            if( fp == NULL )
+            {
+                nwipe_log( NWIPE_LOG_WARNING, "nwipe_log_sysinfo: Failed to create stream to %s", cmd );
+                return 1;
+            }
+            /* Read the output a line at a time - output it. */
+            while( fgets( path, sizeof( path ) - 1, fp ) != NULL )
+            {
+                /* Remove any trailing return from the string, as nwipe_log automatically adds a return */
+                len = strlen( path );
+                if( path[len - 1] == '\n' )
+                {
+                    path[len - 1] = 0;
+                }
+                nwipe_log( NWIPE_LOG_NOTICE, "%s = %s", &dmidecode_keywords[keywords_idx][0], path );
+            }
+            /* close */
+            r = pclose( fp );
+            if( r > 0 )
+            {
+                nwipe_log( NWIPE_LOG_WARNING,
+                           "nwipe_log_sysinfo(): dmidecode failed, \"%s\" exit status = %u",
+                           cmd,
+                           WEXITSTATUS( r ) );
+                return 1;
+            }
+            keywords_idx++;
        }
-        keywords_idx++;
    }
    return 0;
 }
+
+void nwipe_log_summary( nwipe_context_t** ptr, int nwipe_selected )
+{
+    int i;
+    int idx_src;
+    int idx_dest;
+    char device[7];
+    char status[9];
+    char throughput[13];
+    char total_throughput_string[13];
+    char summary_top_border[256];
+    char summary_top_column_titles[256];
+    char blank[3];
+    char verify[3];
+    // char duration[5];
+    char duration[314];
+    char model[18];
+    char serial_no[20];
+    char exclamation_flag[2];
+    int hours;
+    int minutes;
+    int seconds;
+    u64 total_duration_seconds;
+    u64 total_throughput;
+    nwipe_context_t** c;
+    c = ptr;
+
+    exclamation_flag[0] = 0;
+    device[0] = 0;
+    status[0] = 0;
+    throughput[0] = 0;
+    summary_top_border[0] = 0;
+    summary_top_column_titles[0] = 0;
+    blank[0] = 0;
+    verify[0] = 0;
+    duration[0] = 0;
+    model[0] = 0;
+    serial_no[0] = 0;
+    hours = 0;
+    minutes = 0;
+    seconds = 0;
+
+    /* A time buffer. */
+    time_t t;
+
+    /* A pointer to the system time struct. */
+    struct tm* p;
+
+    /* Nothing to do, user didn't select any devices */
+    if( nwipe_selected == 0 )
+    {
+        return;
+    }
+
+    /* initialise */
+    total_throughput = 0;
+
+    /* Get the current time. */
+    t = time( NULL );
+    p = localtime( &t );
+    /* IMPORTANT: Keep maximum columns (line length) to 80 characters for use with 80x30 terminals, Shredos, ALT-F2 etc
+     * --------------------------------01234567890123456789012345678901234567890123456789012345678901234567890123456789-*/
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP, "" );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+               "********************************************************************************" );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP, "! Device | Status | Thru-put | HH:MM:SS | Model/Serial Number" );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+               "--------------------------------------------------------------------------------" );
+    /* Example layout:
+     *                                "!    sdv |--FAIL--|  120MB/s | 01:22:01 | WD6788.8488YNHj/ZX677888388-N       "
+     * ); "     sdv | Erased |  120MB/s | 01:25:04 | WD6784.8488JKGG/ZX677888388-N       " ); "     sdv | Erased |
+     * 120MB/s | 01:19:07 | WD6788.848HHDDR/ZX677888388-N       " ); End of Example layout */
+
+    for( i = 0; i < nwipe_selected; i++ )
+    {
+        /* Device name, strip any prefixed /dev/.. leaving up to 6 right justified
+         * characters eg "   sda", prefixed with space to 6 characters, note that
+         * we are processing the strings right to left */
+
+        idx_dest = 6;
+        device[idx_dest--] = 0;
+        idx_src = strlen( c[i]->device_name );
+        idx_src--;
+
+        while( idx_dest >= 0 )
+        {
+            /* if the device name contains a / start prefixing spaces */
+            if( c[i]->device_name[idx_src] == '/' )
+            {
+                device[idx_dest--] = ' ';
+                continue;
+            }
+            if( idx_src >= 0 )
+            {
+                device[idx_dest--] = c[i]->device_name[idx_src--];
+            }
+        }
+        extern int user_abort;
+
+        /* Any errors ? if so set the exclamation_flag and fail message,
+         * All status messages should be eight characters EXACTLY !
+         */
+        if( c[i]->result < 0 )
+        {
+            strncpy( exclamation_flag, "!", 1 );
+            exclamation_flag[1] = 0;
+
+            strncpy( status, "-FAILED-", 8 );
+            status[8] = 0;
+        }
+        else
+        {
+
+            if( c[i]->pass_errors != 0 )
+            {
+                strncpy( exclamation_flag, "!", 1 );
+                exclamation_flag[1] = 0;
+
+                strncpy( status, "-FAILED-", 8 );
+                status[8] = 0;
+            }
+            else
+            {
+                if( user_abort == 1 )
+                {
+                    strncpy( exclamation_flag, "!", 1 );
+                    exclamation_flag[1] = 0;
+
+                    strncpy( status, "UABORTED", 8 );
+                    status[8] = 0;
+                }
+                else
+                {
+                    strncpy( exclamation_flag, " ", 1 );
+                    exclamation_flag[1] = 0;
+
+                    strncpy( status, " Erased ", 8 );
+                    status[8] = 0;
+                }
+            }
+        }
+
+        /* Determine the size of throughput so that the correct nomenclature can be used */
+        Determine_C_B_nomenclature( c[i]->throughput, throughput, 13 );
+
+        /* Add this devices throughput to the total throughput */
+        total_throughput += c[i]->throughput;
+
+        /* Retrieve the duration of the wipe in seconds and convert to hours and minutes and seconds */
+
+        if( c[i]->start_time != 0 && c[i]->end_time != 0 )
+        {
+            /* For a summary when the wipe has finished */
+            c[i]->duration = difftime( c[i]->end_time, c[i]->start_time );
+        }
+        else
+        {
+            if( c[i]->start_time != 0 && c[i]->end_time == 0 )
+            {
+                /* For a summary in the event of a system shutdown */
+                c[i]->duration = difftime( t, c[i]->start_time );
+            }
+        }
+
+        total_duration_seconds = (u64) c[i]->duration;
+
+        /* Convert binary seconds into three binary variables, hours, minutes and seconds */
+        convert_seconds_to_hours_minutes_seconds( total_duration_seconds, &hours, &minutes, &seconds );
+
+        /* Device Model */
+        strncpy( model, c[i]->device_model, 17 );
+        model[17] = 0;
+
+        /* Serial No. */
+        strncpy( serial_no, c[i]->device_serial_no, 20 );
+        model[17] = 0;
+
+        nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+                   "%s %s |%s| %s/s | %02i:%02i:%02i | %s/%s",
+                   exclamation_flag,
+                   device,
+                   status,
+                   throughput,
+                   hours,
+                   minutes,
+                   seconds,
+                   model,
+                   serial_no );
+    }
+
+    /* Determine the size of throughput so that the correct nomenclature can be used */
+    Determine_C_B_nomenclature( total_throughput, total_throughput_string, 13 );
+
+    /* Blank abreviations used in summary table B=blank, NB=no blank */
+    if( nwipe_options.noblank )
+    {
+        strcpy( blank, "NB" );
+    }
+    else
+    {
+        strcpy( blank, "B" );
+    }
+
+    /* Verify abreviations used in summary table */
+    switch( nwipe_options.verify )
+    {
+        case NWIPE_VERIFY_NONE:
+            strcpy( verify, "NV" );
+            break;
+
+        case NWIPE_VERIFY_LAST:
+            strcpy( verify, "VL" );
+            break;
+
+        case NWIPE_VERIFY_ALL:
+            strcpy( verify, "VA" );
+            break;
+    }
+
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+               "--------------------------------------------------------------------------------" );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+               "[%i/%02i/%02i %02i:%02i:%02i] Total Throughput %s/s, %s, %iR+%s+%s",
+               1900 + p->tm_year,
+               1 + p->tm_mon,
+               p->tm_mday,
+               p->tm_hour,
+               p->tm_min,
+               p->tm_sec,
+               total_throughput_string,
+               nwipe_method_label( nwipe_options.method ),
+               nwipe_options.rounds,
+               blank,
+               verify );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP,
+               "********************************************************************************" );
+    nwipe_log( NWIPE_LOG_NOTIMESTAMP, "" );
+}
+
+void Determine_C_B_nomenclature( u64 speed, char* result, int result_array_size )
+{
+
+    /* C_B ? Determine Capacity or Bandwidth nomenclature
+     *
+     * A pointer to a result character string with a minimum of 13 characters in length
+     * should be provided.
+     *
+     * Outputs a string of the form xxxTB/s, xxxGB/s, xxxMB/s, xxxKB/s B/s depending on the value of 'speed'
+     */
+
+    /* Initialise the output array */
+    int idx = 0;
+
+    while( idx < result_array_size )
+    {
+        result[idx++] = 0;
+    }
+
+    /* Determine the size of throughput so that the correct nomenclature can be used */
+    if( speed >= INT64_C( 1000000000000 ) )
+    {
+        snprintf( result, result_array_size, "%3llu TB", speed / INT64_C( 1000000000000 ) );
+    }
+    else if( speed >= INT64_C( 1000000000 ) )
+    {
+        snprintf( result, result_array_size, "%3llu GB", speed / INT64_C( 1000000000 ) );
+    }
+    else if( speed >= INT64_C( 1000000 ) )
+    {
+        snprintf( result, result_array_size, "%3llu MB", speed / INT64_C( 1000000 ) );
+    }
+    else if( speed >= INT64_C( 1000 ) )
+    {
+        snprintf( result, result_array_size, "%3llu KB", speed / INT64_C( 1000 ) );
+    }
+    else
+    {
+        snprintf( result, result_array_size, "%3llu B", speed / INT64_C( 1 ) );
+    }
+}
+
+void convert_seconds_to_hours_minutes_seconds( u64 total_seconds, int* hours, int* minutes, int* seconds )
+{
+    /* Convert binary seconds into binary hours, minutes and seconds */
+
+    if( total_seconds % 60 )
+    {
+        *minutes = total_seconds / 60;
+
+        *seconds = total_seconds - ( *minutes * 60 );
+    }
+    else
+    {
+        *minutes = total_seconds / 60;
+
+        *seconds = 0;
+    }
+    if( *minutes > 59 )
+    {
+        *hours = *minutes / 60;
+        if( *minutes % 60 )
+        {
+            *minutes = *minutes - ( *hours * 60 );
+        }
+        else
+        {
+            *minutes = 0;
+        }
+    }
+}
--- a/src/logging.h
+++ b/src/logging.h
@@ -24,6 +24,10 @@
 /* Maximum size of a log message */
 #define MAX_LOG_LINE_CHARS 512

+#define MAX_SIZE_OS_STRING 512 /* Maximum size of acceptable OS string */
+#define OS_info_Line_offset 31 /* OS_info line offset in log */
+#define OS_info_Line_Length 48 /* OS_info line length */
+
 typedef enum nwipe_log_t_ {
    NWIPE_LOG_NONE = 0,
    NWIPE_LOG_DEBUG,  // TODO:  Very verbose logging.
@@ -32,11 +36,16 @@ typedef enum nwipe_log_t_ {
    NWIPE_LOG_WARNING,  // Things that the user should know about.
    NWIPE_LOG_ERROR,  // Non-fatal errors that result in failure.
    NWIPE_LOG_FATAL,  // Errors that cause the program to exit.
-    NWIPE_LOG_SANITY  // Programming errors.
+    NWIPE_LOG_SANITY,  // Programming errors.
+    NWIPE_LOG_NOTIMESTAMP  // logs the message without the timestamp
 } nwipe_log_t;

 void nwipe_log( nwipe_log_t level, const char* format, ... );
 void nwipe_perror( int nwipe_errno, const char* f, const char* s );
+void nwipe_log_OSinfo();
 int nwipe_log_sysinfo();
+void nwipe_log_summary( nwipe_context_t**, int );  // This produces the wipe status table on exit
+void Determine_C_B_nomenclature( u64, char*, int );
+void convert_seconds_to_hours_minutes_seconds( u64, int*, int*, int* );

 #endif /* LOGGING_H_ */
--- a/src/method.c
+++ b/src/method.c
@@ -123,6 +123,9 @@ void* nwipe_zero( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -138,6 +141,9 @@ void* nwipe_zero( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_zero */

@@ -150,6 +156,9 @@ void* nwipe_verify( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -162,6 +171,9 @@ void* nwipe_verify( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_verify */

@@ -175,6 +187,9 @@ void* nwipe_dod522022m( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -230,6 +245,9 @@ void* nwipe_dod522022m( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_dod522022m */

@@ -244,6 +262,9 @@ void* nwipe_dodshort( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -292,6 +313,9 @@ void* nwipe_dodshort( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_dodshort */

@@ -305,6 +329,9 @@ void* nwipe_gutmann( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -426,6 +453,9 @@ void* nwipe_gutmann( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_gutmann */

@@ -443,6 +473,9 @@ void* nwipe_ops2( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -588,12 +621,19 @@ void* nwipe_ops2( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_ops2 */

 void* nwipe_is5enh( void* ptr )
 {
    nwipe_context_t* c = (nwipe_context_t*) ptr;
+
+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    c->wipe_status = 1;

    char is5enh[3] = {'\x00', '\xFF', '\x00'};
@@ -604,6 +644,10 @@ void* nwipe_is5enh( void* ptr )
    c->result = nwipe_runmethod( c, patterns );

    c->wipe_status = 0;
+
+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_is5enh */

@@ -617,6 +661,9 @@ void* nwipe_random( void* ptr )
    nwipe_context_t* c;
    c = (nwipe_context_t*) ptr;

+    /* get current time at the start of the wipe  */
+    time( &c->start_time );
+
    /* set wipe in progress flag for GUI */
    c->wipe_status = 1;

@@ -629,6 +676,9 @@ void* nwipe_random( void* ptr )
    /* Finished. Set the wipe_status flag so that the GUI knows */
    c->wipe_status = 0;

+    /* get current time at the end of the wipe  */
+    time( &c->end_time );
+
    return NULL;
 } /* nwipe_random */

@@ -703,21 +753,16 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
    /* Initialize the working round counter. */
    c->round_working = 0;

-    nwipe_log( NWIPE_LOG_NOTICE,
-               "Invoking method '%s' on device '%s'.",
-               nwipe_method_label( nwipe_options.method ),
-               c->device_name );
+    nwipe_log(
+        NWIPE_LOG_NOTICE, "Invoking method '%s' on %s", nwipe_method_label( nwipe_options.method ), c->device_name );

    while( c->round_working < c->round_count )
    {
        /* Increment the round counter. */
        c->round_working += 1;

-        nwipe_log( NWIPE_LOG_NOTICE,
-                   "Starting round %i of %i on device '%s'.",
-                   c->round_working,
-                   c->round_count,
-                   c->device_name );
+        nwipe_log(
+            NWIPE_LOG_NOTICE, "Starting round %i of %i on %s", c->round_working, c->round_count, c->device_name );

        /* Initialize the working pass counter. */
        c->pass_working = 0;
@@ -738,7 +783,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
            }

            nwipe_log( NWIPE_LOG_NOTICE,
-                       "Starting pass %i of %i, round %i of %i, on device '%s'.",
+                       "Starting pass %i/%i, round %i/%i, on %s",
                       c->pass_working,
                       c->pass_count,
                       c->round_working,
@@ -761,7 +806,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                c->pass_type = NWIPE_PASS_NONE;

                /* Log number of bytes written to disk */
-                nwipe_log( NWIPE_LOG_NOTICE, "%llu bytes written to device '%s'.", c->pass_done, c->device_name );
+                nwipe_log( NWIPE_LOG_NOTICE, "%llu bytes written to %s", c->pass_done, c->device_name );

                /* Check for a fatal error. */
                if( r < 0 )
@@ -773,7 +818,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                {

                    nwipe_log( NWIPE_LOG_NOTICE,
-                               "Verifying pass %i of %i, round %i of %i, on device '%s'.",
+                               "Verifying pass %i of %i, round %i of %i, on %s",
                               c->pass_working,
                               c->pass_count,
                               c->round_working,
@@ -792,7 +837,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                    }

                    nwipe_log( NWIPE_LOG_NOTICE,
-                               "Verified pass %i of %i, round %i of %i, on device '%s'.",
+                               "Verified pass %i of %i, round %i of %i, on '%s'.",
                               c->pass_working,
                               c->pass_count,
                               c->round_working,
@@ -831,7 +876,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                c->pass_type = NWIPE_PASS_NONE;

                /* Log number of bytes written to disk */
-                nwipe_log( NWIPE_LOG_NOTICE, "%llu bytes written to device '%s'.", c->pass_done, c->device_name );
+                nwipe_log( NWIPE_LOG_NOTICE, "%llu bytes written to %s", c->pass_done, c->device_name );

                /* Check for a fatal error. */
                if( r < 0 )
@@ -845,7 +890,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                if( nwipe_options.verify == NWIPE_VERIFY_ALL || lastpass == 1 || nwipe_options.method == &nwipe_is5enh )
                {
                    nwipe_log( NWIPE_LOG_NOTICE,
-                               "Verifying pass %i of %i, round %i of %i, on device '%s'.",
+                               "Verifying pass %i of %i, round %i of %i, on %s",
                               c->pass_working,
                               c->pass_count,
                               c->round_working,
@@ -864,7 +909,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                    }

                    nwipe_log( NWIPE_LOG_NOTICE,
-                               "Verified pass %i of %i, round %i of %i, on device '%s'.",
+                               "Verified pass %i of %i, round %i of %i, on '%s'.",
                               c->pass_working,
                               c->pass_count,
                               c->round_working,
@@ -875,7 +920,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
            } /* random pass */

            nwipe_log( NWIPE_LOG_NOTICE,
-                       "Finished pass %i of %i, round %i of %i, on device '%s'.",
+                       "Finished pass %i/%i, round %i/%i, on %s",
                       c->pass_working,
                       c->pass_count,
                       c->round_working,
@@ -884,11 +929,19 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )

        } /* for passes */

-        nwipe_log( NWIPE_LOG_NOTICE,
-                   "Finished round %i of %i on device '%s'.",
-                   c->round_working,
-                   c->round_count,
-                   c->device_name );
+        if( c->round_working < c->round_count )
+        {
+            nwipe_log(
+                NWIPE_LOG_NOTICE, "Finished round %i of %i on %s", c->round_working, c->round_count, c->device_name );
+        }
+        else
+        {
+            nwipe_log( NWIPE_LOG_NOTICE,
+                       "Finished final round %i of %i on %s",
+                       c->round_working,
+                       c->round_count,
+                       c->device_name );
+        }

    } /* while rounds */

@@ -931,7 +984,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )

        if( nwipe_options.verify == NWIPE_VERIFY_LAST || nwipe_options.verify == NWIPE_VERIFY_ALL )
        {
-            nwipe_log( NWIPE_LOG_NOTICE, "Verifying the final random pattern on '%s' is empty.", c->device_name );
+            nwipe_log( NWIPE_LOG_NOTICE, "Verifying the final random pattern on %s is empty.", c->device_name );

            /* Verify the final zero pass. */
            r = nwipe_random_verify( c );
@@ -951,7 +1004,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )

    else if( nwipe_options.method == &nwipe_verify )
    {
-        nwipe_log( NWIPE_LOG_NOTICE, "Verifying that '%s' is empty.", c->device_name );
+        nwipe_log( NWIPE_LOG_NOTICE, "Verifying that %s is empty", c->device_name );

        /* Verify the final zero pass. */
        c->pass_type = NWIPE_PASS_VERIFY;
@@ -963,8 +1016,14 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
        {
            return r;
        }
-
-        nwipe_log( NWIPE_LOG_NOTICE, "Verified that '%s' is empty.", c->device_name );
+        if( c->verify_errors == 0 )
+        {
+            nwipe_log( NWIPE_LOG_NOTICE, "[SUCCESS] Verified that %s is empty.", c->device_name );
+        }
+        else
+        {
+            nwipe_log( NWIPE_LOG_ERROR, "[FAILURE] %s IS NOT empty.", c->device_name );
+        }

    } /* verify */

@@ -973,7 +1032,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
        /* Tell the user that we are on the final pass. */
        c->pass_type = NWIPE_PASS_FINAL_BLANK;

-        nwipe_log( NWIPE_LOG_NOTICE, "Blanking device '%s'.", c->device_name );
+        nwipe_log( NWIPE_LOG_NOTICE, "Blanking device %s", c->device_name );

        /* The final zero pass. */
        r = nwipe_static_pass( c, &pattern_zero );
@@ -986,7 +1045,7 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )

        if( nwipe_options.verify == NWIPE_VERIFY_LAST || nwipe_options.verify == NWIPE_VERIFY_ALL )
        {
-            nwipe_log( NWIPE_LOG_NOTICE, "Verifying that '%s' is empty.", c->device_name );
+            nwipe_log( NWIPE_LOG_NOTICE, "Verifying that %s is empty.", c->device_name );

            /* Verify the final zero pass. */
            r = nwipe_static_verify( c, &pattern_zero );
@@ -997,10 +1056,17 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
                return r;
            }

-            nwipe_log( NWIPE_LOG_NOTICE, "Verified that '%s' is empty.", c->device_name );
+            if( c->verify_errors == 0 )
+            {
+                nwipe_log( NWIPE_LOG_NOTICE, "[SUCCESS] Verified that %s is empty.", c->device_name );
+            }
+            else
+            {
+                nwipe_log( NWIPE_LOG_NOTICE, "[FAILURE] %s Verification errors, not empty", c->device_name );
+            }
        }

-        nwipe_log( NWIPE_LOG_NOTICE, "Blanked device '%s'.", c->device_name );
+        nwipe_log( NWIPE_LOG_NOTICE, "[SUCCESS] Blanked device %s", c->device_name );

    } /* final blank */

@@ -1014,13 +1080,13 @@ int nwipe_runmethod( nwipe_context_t* c, nwipe_pattern_t* patterns )
    if( c->verify_errors > 0 )
    {
        /* We finished, but with non-fatal verification errors. */
-        nwipe_log( NWIPE_LOG_ERROR, "%llu verification errors on device '%s'.", c->verify_errors, c->device_name );
+        nwipe_log( NWIPE_LOG_ERROR, "%llu verification errors on '%s'.", c->verify_errors, c->device_name );
    }

    if( c->pass_errors > 0 )
    {
        /* We finished, but with non-fatal wipe errors. */
-        nwipe_log( NWIPE_LOG_ERROR, "%llu wipe errors on device '%s'.", c->pass_errors, c->device_name );
+        nwipe_log( NWIPE_LOG_ERROR, "%llu wipe errors on '%s'.", c->pass_errors, c->device_name );
    }

    /* FIXME: The 'round_errors' context member is not being used. */
--- a/src/nwipe.c
+++ b/src/nwipe.c
@@ -19,6 +19,10 @@
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+
 #ifndef _POSIX_SOURCE
 #define _POSIX_SOURCE
 #endif
@@ -27,7 +31,7 @@
 #include <time.h>
 #include <signal.h>
 #include <pthread.h>
-#include <bits/pthreadtypes.h>
+#include <sys/types.h>
 #include <bits/sigthread.h>

 #include "nwipe.h"
@@ -45,8 +49,10 @@

 #include <parted/parted.h>
 #include <parted/debug.h>
+#include "version.h"

 int terminate_signal;
+int user_abort;

 int main( int argc, char** argv )
 {
@@ -67,9 +73,18 @@ int main( int argc, char** argv )
    /* The generic result buffer. */
    int r;

+    /* Log nwipes version */
+    nwipe_log( NWIPE_LOG_INFO, "%s", banner );
+
+    /* Log OS info */
+    nwipe_log_OSinfo();
+
    /* Initialise the termintaion signal, 1=terminate nwipe */
    terminate_signal = 0;

+    /* Initialise the user abort signal, 1=User aborted with CNTRL-C,SIGTERM, SIGQUIT, SIGINT etc.. */
+    user_abort = 0;
+
    /* nwipes return status value, set prior to exit at the end of nwipe, as no other exit points allowed */
    int return_status = 0;

@@ -81,6 +96,8 @@ int main( int argc, char** argv )
    /* Initialised and populated in device scan.     */
    nwipe_context_t** c1 = 0;

+    int wipe_threads_started = 0;
+
    /* Parse command line options. */
    nwipe_optind = nwipe_options_parse( argc, argv );
    if( nwipe_optind == argc )
@@ -90,7 +107,8 @@ int main( int argc, char** argv )

        if( nwipe_enumerated == 0 )
        {
-            nwipe_log( NWIPE_LOG_INFO, "Storage devices not found." );
+            nwipe_log( NWIPE_LOG_INFO,
+                       "Storage devices not found. Nwipe should be run as root or sudo/su, i.e sudo nwipe etc" );
            cleanup();
            return -1;
        }
@@ -108,12 +126,18 @@ int main( int argc, char** argv )
        if( nwipe_enumerated == 0 )
        {
            nwipe_log( NWIPE_LOG_ERROR, "Devices not found. Check you're not excluding drives unnecessarily." );
-            printf( "No drives found" );
+            printf( "No drives found\n" );
            cleanup();
            exit( 1 );
        }
    }

+    if( terminate_signal == 1 )
+    {
+        cleanup();
+        exit( 1 );
+    }
+
    /* Log the System information */
    nwipe_log_sysinfo();

@@ -129,6 +153,7 @@ int main( int argc, char** argv )
        nwipe_perror( errno, __FUNCTION__, "open" );
        nwipe_log( NWIPE_LOG_FATAL, "Unable to open entropy source %s.", NWIPE_KNOB_ENTROPY );
        cleanup();
+        free( c2 );
        return errno;
    }

@@ -255,150 +280,166 @@ int main( int argc, char** argv )
    }

    /* TODO: free c1 and c2 memory. */
-
-    for( i = 0; i < nwipe_selected; i++ )
+    if( user_abort == 0 )
    {
-        /* A result buffer for the BLKGETSIZE64 ioctl. */
-        u64 size64;
-
-        /* Initialise the wipe_status flag, -1 = wipe not yet started */
-        c2[i]->wipe_status = -1;
-
-        /* Open the file for reads and writes. */
-        c2[i]->device_fd = open( c2[i]->device_name, O_RDWR );
-
-        /* Check the open() result. */
-        if( c2[i]->device_fd < 0 )
+        for( i = 0; i < nwipe_selected; i++ )
        {
-            nwipe_perror( errno, __FUNCTION__, "open" );
-            nwipe_log( NWIPE_LOG_WARNING, "Unable to open device '%s'.", c2[i]->device_name );
-            c2[i]->select = NWIPE_SELECT_DISABLED;
-            continue;
-        }
+            /* A result buffer for the BLKGETSIZE64 ioctl. */
+            u64 size64;

-        /* Stat the file. */
-        if( fstat( c2[i]->device_fd, &c2[i]->device_stat ) != 0 )
-        {
-            nwipe_perror( errno, __FUNCTION__, "fstat" );
-            nwipe_log( NWIPE_LOG_ERROR, "Unable to stat file '%s'.", c2[i]->device_name );
-            nwipe_error++;
-            continue;
-        }
+            /* Initialise the spinner character index */
+            c2[i]->spinner_idx = 0;

-        /* Check that the file is a block device. */
-        if( !S_ISBLK( c2[i]->device_stat.st_mode ) )
-        {
-            nwipe_log( NWIPE_LOG_ERROR, "'%s' is not a block device.", c2[i]->device_name );
-            nwipe_error++;
-            continue;
-        }
+            /* Initialise the start and end time of the wipe */
+            c2[i]->start_time = 0;
+            c2[i]->end_time = 0;

-        /* TODO: Lock the file for exclusive access. */
-        /*
-        if( flock( c2[i]->device_fd, LOCK_EX | LOCK_NB ) != 0 )
-        {
-                nwipe_perror( errno, __FUNCTION__, "flock" );
-                nwipe_log( NWIPE_LOG_ERROR, "Unable to lock the '%s' file.", c2[i]->device_name );
+            /* Initialise the wipe_status flag, -1 = wipe not yet started */
+            c2[i]->wipe_status = -1;
+
+            /* Open the file for reads and writes. */
+            c2[i]->device_fd = open( c2[i]->device_name, O_RDWR );
+
+            /* Check the open() result. */
+            if( c2[i]->device_fd < 0 )
+            {
+                nwipe_perror( errno, __FUNCTION__, "open" );
+                nwipe_log( NWIPE_LOG_WARNING, "Unable to open device '%s'.", c2[i]->device_name );
+                c2[i]->select = NWIPE_SELECT_DISABLED;
+                continue;
+            }
+
+            /* Stat the file. */
+            if( fstat( c2[i]->device_fd, &c2[i]->device_stat ) != 0 )
+            {
+                nwipe_perror( errno, __FUNCTION__, "fstat" );
+                nwipe_log( NWIPE_LOG_ERROR, "Unable to stat file '%s'.", c2[i]->device_name );
                nwipe_error++;
                continue;
-        }
-        */
+            }

-        /* Print serial number of device if it exists. */
-        if( strlen( (const char*) c2[i]->device_serial_no ) )
-        {
-            nwipe_log( NWIPE_LOG_INFO, "Device %s has serial number %s", c2[i]->device_name, c2[i]->device_serial_no );
-        }
-
-        /* Do sector size and block size checking. */
-        if( ioctl( c2[i]->device_fd, BLKSSZGET, &c2[i]->device_sector_size ) == 0 )
-        {
-            nwipe_log(
-                NWIPE_LOG_INFO, "Device '%s' has sector size %i.", c2[i]->device_name, c2[i]->device_sector_size );
-
-            if( ioctl( c2[i]->device_fd, BLKBSZGET, &c2[i]->device_block_size ) == 0 )
+            /* Check that the file is a block device. */
+            if( !S_ISBLK( c2[i]->device_stat.st_mode ) )
            {
-                nwipe_log(
-                    NWIPE_LOG_INFO, "Device '%s' has block size %i.", c2[i]->device_name, c2[i]->device_block_size );
+                nwipe_log( NWIPE_LOG_ERROR, "'%s' is not a block device.", c2[i]->device_name );
+                nwipe_error++;
+                continue;
+            }
+
+            /* TODO: Lock the file for exclusive access. */
+            /*
+            if( flock( c2[i]->device_fd, LOCK_EX | LOCK_NB ) != 0 )
+            {
+                    nwipe_perror( errno, __FUNCTION__, "flock" );
+                    nwipe_log( NWIPE_LOG_ERROR, "Unable to lock the '%s' file.", c2[i]->device_name );
+                    nwipe_error++;
+                    continue;
+            }
+            */
+
+            /* Print serial number of device if it exists. */
+            if( strlen( (const char*) c2[i]->device_serial_no ) )
+            {
+                nwipe_log( NWIPE_LOG_NOTICE, "%s has serial number %s", c2[i]->device_name, c2[i]->device_serial_no );
+            }
+
+            /* Do sector size and block size checking. */
+            if( ioctl( c2[i]->device_fd, BLKSSZGET, &c2[i]->device_sector_size ) == 0 )
+            {
+
+                if( ioctl( c2[i]->device_fd, BLKBSZGET, &c2[i]->device_block_size ) != 0 )
+                {
+                    nwipe_log( NWIPE_LOG_WARNING, "Device '%s' failed BLKBSZGET ioctl.", c2[i]->device_name );
+                    c2[i]->device_block_size = 0;
+                }
            }
            else
            {
-                nwipe_log( NWIPE_LOG_WARNING, "Device '%s' failed BLKBSZGET ioctl.", c2[i]->device_name );
+                nwipe_log( NWIPE_LOG_WARNING, "Device '%s' failed BLKSSZGET ioctl.", c2[i]->device_name );
+                c2[i]->device_sector_size = 0;
                c2[i]->device_block_size = 0;
            }
-        }
-        else
-        {
-            nwipe_log( NWIPE_LOG_WARNING, "Device '%s' failed BLKSSZGET ioctl.", c2[i]->device_name );
-            c2[i]->device_sector_size = 0;
-            c2[i]->device_block_size = 0;
-        }

-        /* The st_size field is zero for block devices. */
-        /* ioctl( c2[i]->device_fd, BLKGETSIZE64, &c2[i]->device_size ); */
+            /* The st_size field is zero for block devices. */
+            /* ioctl( c2[i]->device_fd, BLKGETSIZE64, &c2[i]->device_size ); */

-        /* Seek to the end of the device to determine its size. */
-        c2[i]->device_size = lseek( c2[i]->device_fd, 0, SEEK_END );
+            /* Seek to the end of the device to determine its size. */
+            c2[i]->device_size = lseek( c2[i]->device_fd, 0, SEEK_END );

-        /* Also ask the driver for the device size. */
-        /* if( ioctl( c2[i]->device_fd, BLKGETSIZE64, &size64 ) ) */
-        if( ioctl( c2[i]->device_fd, _IOR( 0x12, 114, size_t ), &size64 ) )
-        {
-            /* The ioctl failed. */
-            fprintf( stderr, "Error: BLKGETSIZE64 failed  on '%s'.\n", c2[i]->device_name );
-            nwipe_log( NWIPE_LOG_ERROR, "BLKGETSIZE64 failed  on '%s'.\n", c2[i]->device_name );
-            nwipe_error++;
-        }
-        c2[i]->device_size = size64;
-
-        /* Check whether the two size values agree. */
-        if( c2[i]->device_size != size64 )
-        {
-            /* This could be caused by the linux last-odd-block problem. */
-            fprintf( stderr, "Error: Last-odd-block detected on '%s'.\n", c2[i]->device_name );
-            nwipe_log( NWIPE_LOG_ERROR, "Last-odd-block detected on '%s'.", c2[i]->device_name );
-            nwipe_error++;
-        }
-
-        if( c2[i]->device_size == (long long) -1 )
-        {
-            /* We cannot determine the size of this device. */
-            nwipe_perror( errno, __FUNCTION__, "lseek" );
-            nwipe_log( NWIPE_LOG_ERROR, "Unable to determine the size of '%s'.", c2[i]->device_name );
-            nwipe_error++;
-        }
-        else
-        {
-            /* Reset the file pointer. */
-            r = lseek( c2[i]->device_fd, 0, SEEK_SET );
-
-            if( r == (off64_t) -1 )
+            /* Also ask the driver for the device size. */
+            /* if( ioctl( c2[i]->device_fd, BLKGETSIZE64, &size64 ) ) */
+            if( ioctl( c2[i]->device_fd, _IOR( 0x12, 114, size_t ), &size64 ) )
            {
-                nwipe_perror( errno, __FUNCTION__, "lseek" );
-                nwipe_log( NWIPE_LOG_ERROR, "Unable to reset the '%s' file offset.", c2[i]->device_name );
+                /* The ioctl failed. */
+                fprintf( stderr, "Error: BLKGETSIZE64 failed  on '%s'.\n", c2[i]->device_name );
+                nwipe_log( NWIPE_LOG_ERROR, "BLKGETSIZE64 failed  on '%s'.\n", c2[i]->device_name );
                nwipe_error++;
            }
-        }
+            c2[i]->device_size = size64;

-        if( c2[i]->device_size == 0 )
-        {
-            nwipe_log( NWIPE_LOG_ERROR, "Device '%s' is size %llu.", c2[i]->device_name, c2[i]->device_size );
-            nwipe_error++;
-            continue;
-        }
-        else
-        {
-            nwipe_log( NWIPE_LOG_INFO, "Device '%s' is size %llu.", c2[i]->device_name, c2[i]->device_size );
-        }
+            /* Check whether the two size values agree. */
+            if( c2[i]->device_size != size64 )
+            {
+                /* This could be caused by the linux last-odd-block problem. */
+                fprintf( stderr, "Error: Last-odd-block detected on '%s'.\n", c2[i]->device_name );
+                nwipe_log( NWIPE_LOG_ERROR, "Last-odd-block detected on '%s'.", c2[i]->device_name );
+                nwipe_error++;
+            }

-        /* Fork a child process. */
-        errno = pthread_create( &c2[i]->thread, NULL, nwipe_options.method, (void*) c2[i] );
-        if( errno )
-        {
-            nwipe_perror( errno, __FUNCTION__, "pthread_create" );
-            if( !nwipe_options.nogui )
-                nwipe_gui_free();
-            return errno;
+            if( c2[i]->device_size == (long long) -1 )
+            {
+                /* We cannot determine the size of this device. */
+                nwipe_perror( errno, __FUNCTION__, "lseek" );
+                nwipe_log( NWIPE_LOG_ERROR, "Unable to determine the size of '%s'.", c2[i]->device_name );
+                nwipe_error++;
+            }
+            else
+            {
+                /* Reset the file pointer. */
+                r = lseek( c2[i]->device_fd, 0, SEEK_SET );
+
+                if( r == (off64_t) -1 )
+                {
+                    nwipe_perror( errno, __FUNCTION__, "lseek" );
+                    nwipe_log( NWIPE_LOG_ERROR, "Unable to reset the '%s' file offset.", c2[i]->device_name );
+                    nwipe_error++;
+                }
+            }
+
+            if( c2[i]->device_size == 0 )
+            {
+                nwipe_log( NWIPE_LOG_ERROR,
+                           "%s, sect/blk/dev %llu/%i/%llu",
+                           c2[i]->device_name,
+                           c2[i]->device_sector_size,
+                           c2[i]->device_block_size,
+                           c2[i]->device_size );
+                nwipe_error++;
+                continue;
+            }
+            else
+            {
+                nwipe_log( NWIPE_LOG_NOTICE,
+                           "%s, sect/blk/dev %llu/%i/%llu",
+                           c2[i]->device_name,
+                           c2[i]->device_sector_size,
+                           c2[i]->device_block_size,
+                           c2[i]->device_size );
+            }
+
+            /* Fork a child process. */
+            errno = pthread_create( &c2[i]->thread, NULL, nwipe_options.method, (void*) c2[i] );
+            if( errno )
+            {
+                nwipe_perror( errno, __FUNCTION__, "pthread_create" );
+                if( !nwipe_options.nogui )
+                    nwipe_gui_free();
+                return errno;
+            }
+            else
+            {
+                wipe_threads_started = 1;
+            }
        }
    }

@@ -419,6 +460,10 @@ int main( int argc, char** argv )
    }

    /* Wait for all the wiping threads to finish, but don't wait if we receive the terminate signal */
+
+    /* set getch delay to 2/10th second. */
+    halfdelay( 10 );
+
    i = 0;
    while( i < nwipe_selected && terminate_signal == 0 )
    {
@@ -436,33 +481,35 @@ int main( int argc, char** argv )
            i++;
            continue;
        }
-        sleep( 2 ); /* DO NOT REMOVE ! Stops the routine hogging CPU cycles */
+        sleep( 1 ); /* DO NOT REMOVE ! Stops the routine hogging CPU cycles */
    }

-    if( terminate_signal == 1 )
+    if( terminate_signal != 1 )
    {
-        nwipe_log( NWIPE_LOG_INFO, "Program interrupted" );
-    }
-    else
-    {
-        if( !nwipe_options.nowait )
+        if( !nwipe_options.nowait && !nwipe_options.autopoweroff )
        {
            do
            {
                sleep( 1 );
+
            } while( terminate_signal != 1 );
        }
    }
-    nwipe_log( NWIPE_LOG_INFO, "Exit in progress" );
-
+    if( nwipe_options.verbose )
+    {
+        nwipe_log( NWIPE_LOG_INFO, "Exit in progress" );
+    }
    /* Send a REQUEST for the wipe threads to be cancelled */
    for( i = 0; i < nwipe_selected; i++ )
    {

        if( c2[i]->thread )
        {
-            nwipe_log( NWIPE_LOG_INFO, "Requesting wipe thread cancellation for %s", c2[i]->device_name );
-            nwipe_log( NWIPE_LOG_INFO, "Please wait.." );
+            if( nwipe_options.verbose )
+            {
+                nwipe_log( NWIPE_LOG_INFO, "Requesting wipe thread cancellation for %s", c2[i]->device_name );
+                nwipe_log( NWIPE_LOG_INFO, "Please wait.." );
+            }
            pthread_cancel( c2[i]->thread );
        }
    }
@@ -470,7 +517,10 @@ int main( int argc, char** argv )
    /* Kill the GUI thread */
    if( nwipe_gui_thread )
    {
-        nwipe_log( NWIPE_LOG_INFO, "Cancelling the GUI thread." );
+        if( nwipe_options.verbose )
+        {
+            nwipe_log( NWIPE_LOG_INFO, "Cancelling the GUI thread." );
+        }

        /* We don't want to use pthread_cancel as our GUI thread is aware of the control-c
         *  signal and will exit itself we just join the GUI thread and wait for confirmation
@@ -480,7 +530,10 @@ int main( int argc, char** argv )
        {
            nwipe_log( NWIPE_LOG_WARNING, "main()>pthread_join():Error when waiting for GUI thread to cancel." );
        }
-        nwipe_log( NWIPE_LOG_INFO, "GUI compute_stats thread has been cancelled" );
+        if( nwipe_options.verbose )
+        {
+            nwipe_log( NWIPE_LOG_INFO, "GUI compute_stats thread has been cancelled" );
+        }
    }

    /* Release the gui. */
@@ -502,31 +555,51 @@ int main( int argc, char** argv )
                nwipe_log( NWIPE_LOG_WARNING, "main()>pthread_join():Error when waiting for wipe thread to cancel." );
            }
            c2[i]->thread = 0; /* Zero the thread so we know it's been cancelled */
-            nwipe_log( NWIPE_LOG_INFO, "Wipe thread for device %s has been cancelled", c2[i]->device_name );
+
+            if( nwipe_options.verbose )
+            {
+                nwipe_log( NWIPE_LOG_INFO, "Wipe thread for device %s has been cancelled", c2[i]->device_name );
+            }
+
            /* Close the device file descriptor. */
            close( c2[i]->device_fd );
        }
    }

-    for( i = 0; i < nwipe_selected; i++ )
+    /* if no wipe threads started then zero each selected drive result flag,
+     * as we don't need to report fatal/non fatal errors if no wipes were ever started ! */
+    if( wipe_threads_started == 0 )
    {
-        /* Check for non-fatal errors. */
-        if( c2[i]->result > 0 )
+        for( i = 0; i < nwipe_selected; i++ )
        {
-            nwipe_log( NWIPE_LOG_FATAL, "Nwipe exited with non fatal errors on device = %s\n", c2[i]->device_name );
-            return_status = 1;
+            c2[i]->result = 0;
+        }
+    }
+    else
+    {
+        for( i = 0; i < nwipe_selected; i++ )
+        {
+            /* Check for non-fatal errors. */
+            if( c2[i]->result > 0 )
+            {
+                nwipe_log( NWIPE_LOG_FATAL, "Nwipe exited with non fatal errors on device = %s\n", c2[i]->device_name );
+                return_status = 1;
+            }
+        }
+
+        for( i = 0; i < nwipe_selected; i++ )
+        {
+            /* Check for fatal errors. */
+            if( c2[i]->result < 0 )
+            {
+                nwipe_log( NWIPE_LOG_ERROR, "Nwipe exited with fatal errors on device = %s\n", c2[i]->device_name );
+                return_status = -1;
+            }
        }
    }

-    for( i = 0; i < nwipe_selected; i++ )
-    {
-        /* Check for fatal errors. */
-        if( c2[i]->result < 0 )
-        {
-            nwipe_log( NWIPE_LOG_ERROR, "Nwipe exited with fatal errors on device = %s\n", c2[i]->device_name );
-            return_status = -1;
-        }
-    }
+    /* Generate and send the drive status summary to the log */
+    nwipe_log_summary( c2, nwipe_selected );

    if( return_status == 0 )
    {
@@ -535,6 +608,8 @@ int main( int argc, char** argv )

    cleanup();

+    check_for_autopoweroff();
+
    /* Exit. */
    return return_status;
 }
@@ -542,6 +617,13 @@ int main( int argc, char** argv )
 void* signal_hand( void* ptr )
 {
    int sig;
+    int hours;
+    int minutes;
+    int seconds;
+
+    hours = 0;
+    minutes = 0;
+    seconds = 0;

    // Define signals that this handler should react to
    sigset_t sigset;
@@ -553,6 +635,7 @@ void* signal_hand( void* ptr )
    sigaddset( &sigset, SIGUSR1 );

    int i;
+    char eta[9];

    /* Set up the structs we will use for the data required. */
    nwipe_thread_data_ptr_t* nwipe_thread_data_ptr;
@@ -574,7 +657,6 @@ void* signal_hand( void* ptr )

            // Log current status. All values are automatically updated by the GUI
            case SIGUSR1:
-            {
                compute_stats( ptr );

                for( i = 0; i < nwipe_misc_thread_data->nwipe_selected; i++ )
@@ -608,14 +690,20 @@ void* signal_hand( void* ptr )
                        {
                            status = "[syncing]";
                        }
+
+                        convert_seconds_to_hours_minutes_seconds( c[i]->eta, &hours, &minutes, &seconds );
+
                        nwipe_log( NWIPE_LOG_INFO,
-                                   "%s: %05.2f%%, round %i of %i, pass %i of %i %s",
+                                   "%s: %05.2f%%, round %i of %i, pass %i of %i, eta %02i:%02i:%02i, %s",
                                   c[i]->device_name,
                                   c[i]->round_percent,
                                   c[i]->round_working,
                                   c[i]->round_count,
                                   c[i]->pass_working,
                                   c[i]->pass_count,
+                                   hours,
+                                   minutes,
+                                   seconds,
                                   status );
                    }
                    else
@@ -638,21 +726,21 @@ void* signal_hand( void* ptr )
                }

                break;
-            }

            case SIGHUP:
            case SIGINT:
            case SIGQUIT:
            case SIGTERM:
-            {
                /* Set termination flag for main() which will do housekeeping prior to exit */
                terminate_signal = 1;

+                /* Set the user abort flag */
+                user_abort = 1;
+
                /* Return control to the main thread, returning the signal received */
                return ( (void*) 0 );

                break;
-            }
        }
    }

@@ -688,3 +776,21 @@ int cleanup()

    return 0;
 }
+void check_for_autopoweroff( void )
+{
+    char cmd[] = "shutdown -P +1 \"System going down in one minute\"";
+    FILE* fp;
+    int r;  // A result buffer.
+
+    /* User request auto power down ? */
+    if( nwipe_options.autopoweroff == 1 )
+    {
+        fp = popen( cmd, "r" );
+        if( fp == NULL )
+        {
+            nwipe_log( NWIPE_LOG_INFO, "Failed to autopoweroff to %s", cmd );
+            return;
+        }
+        r = pclose( fp );
+    }
+}
--- a/src/nwipe.h
+++ b/src/nwipe.h
@@ -25,6 +25,8 @@

 /* Function prototypes */
 int cleanup();
+void check_for_autopoweroff( void );
+void* signal_hand( void* );

 #ifndef _LARGEFILE64_SOURCE
 #define _LARGEFILE64_SOURCE
@@ -66,7 +68,7 @@ int cleanup();
 #include <time.h>
 #include <unistd.h>

-#include "config.h"
+/*#include "config.h"*/

 /* System errors. */
 extern int errno;
@@ -111,6 +113,4 @@ typedef unsigned char u8;
 /* This is required for ioctl FDFLUSH. */
 #include <linux/fd.h>

-void* signal_hand( void* );
-
 #endif /* NWIPE_H_ */
--- a/src/options.c
+++ b/src/options.c
@@ -53,13 +53,16 @@ int nwipe_options_parse( int argc, char** argv )
    int i;

    /* The list of acceptable short options. */
-    char nwipe_options_short[] = "Vhl:m:p:r:e:";
+    char nwipe_options_short[] = "Vvhl:m:p:r:e:";

    /* The list of acceptable long options. */
    static struct option nwipe_options_long[] = {
        /* Set when the user wants to wipe without a confirmation prompt. */
        {"autonuke", no_argument, 0, 0},

+        /* Set when the user wants to have the system powerdown on completion of wipe. */
+        {"autopoweroff", no_argument, 0, 0},
+
        /* A GNU standard option. Corresponds to the 'h' short option. */
        {"help", no_argument, 0, 'h'},

@@ -81,6 +84,9 @@ int nwipe_options_parse( int argc, char** argv )
        /* Whether to blank the disk after wiping. */
        {"noblank", no_argument, 0, 0},

+        /* Whether to ignore all USB devices. */
+        {"nousb", no_argument, 0, 0},
+
        /* Whether to exit after wiping or wait for a keypress. */
        {"nowait", no_argument, 0, 0},

@@ -96,6 +102,9 @@ int nwipe_options_parse( int argc, char** argv )
        /* Verify that wipe patterns are being written to the device. */
        {"verify", required_argument, 0, 0},

+        /* Display program version. */
+        {"verbose", no_argument, 0, 'v'},
+
        /* Display program version. */
        {"version", no_argument, 0, 'V'},

@@ -104,14 +113,17 @@ int nwipe_options_parse( int argc, char** argv )

    /* Set default options. */
    nwipe_options.autonuke = 0;
+    nwipe_options.autopoweroff = 0;
    nwipe_options.method = &nwipe_dodshort;
    nwipe_options.prng = &nwipe_twister;
    nwipe_options.rounds = 1;
    nwipe_options.noblank = 0;
+    nwipe_options.nousb = 0;
    nwipe_options.nowait = 0;
    nwipe_options.nosignals = 0;
    nwipe_options.nogui = 0;
-    nwipe_options.sync = 100000;
+    nwipe_options.sync = DEFAULT_SYNC_RATE;
+    nwipe_options.verbose = 0;
    nwipe_options.verify = NWIPE_VERIFY_LAST;
    memset( nwipe_options.logfile, '\0', sizeof( nwipe_options.logfile ) );

@@ -143,12 +155,24 @@ int nwipe_options_parse( int argc, char** argv )
                    break;
                }

+                if( strcmp( nwipe_options_long[i].name, "autopoweroff" ) == 0 )
+                {
+                    nwipe_options.autopoweroff = 1;
+                    break;
+                }
+
                if( strcmp( nwipe_options_long[i].name, "noblank" ) == 0 )
                {
                    nwipe_options.noblank = 1;
                    break;
                }

+                if( strcmp( nwipe_options_long[i].name, "nousb" ) == 0 )
+                {
+                    nwipe_options.nousb = 1;
+                    break;
+                }
+
                if( strcmp( nwipe_options_long[i].name, "nowait" ) == 0 )
                {
                    nwipe_options.nowait = 1;
@@ -168,11 +192,17 @@ int nwipe_options_parse( int argc, char** argv )
                    break;
                }

+                if( strcmp( nwipe_options_long[i].name, "verbose" ) == 0 )
+                {
+                    nwipe_options.verbose = 1;
+                    break;
+                }
+
                if( strcmp( nwipe_options_long[i].name, "sync" ) == 0 )
                {
-                    if( sscanf( optarg, " %i", &nwipe_options.sync ) != 1 || nwipe_options.sync < 1 )
+                    if( sscanf( optarg, " %i", &nwipe_options.sync ) != 1 || nwipe_options.sync < 0 )
                    {
-                        fprintf( stderr, "Error: The sync argument must be a positive integer.\n" );
+                        fprintf( stderr, "Error: The sync argument must be a positive integer or zero.\n" );
                        exit( EINVAL );
                    }
                    break;
@@ -343,6 +373,11 @@ int nwipe_options_parse( int argc, char** argv )

                break;

+            case 'v': /* verbose */
+
+                nwipe_options.verbose = 1;
+                break;
+
            case 'V': /* Version option. */

                printf( "%s version %s\n", program_name, version_string );
@@ -379,6 +414,15 @@ void nwipe_options_log( void )
        nwipe_log( NWIPE_LOG_NOTICE, "  autonuke = %i (off)", nwipe_options.autonuke );
    }

+    if( nwipe_options.autopoweroff )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  autopoweroff = %i (on)", nwipe_options.autopoweroff );
+    }
+    else
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  autopoweroff = %i (off)", nwipe_options.autopoweroff );
+    }
+
    if( nwipe_options.noblank )
    {
        nwipe_log( NWIPE_LOG_NOTICE, "  do not perform a final blank pass" );
@@ -435,15 +479,23 @@ void display_help()
    /* Limit line length to a maximum of 80 characters so it looks good in 80x25 terminals i.e shredos */
    /*  ___12345678901234567890123456789012345678901234567890123456789012345678901234567890< Do not exceed */
    puts( "  -V, --version           Prints the version number\n" );
+    puts( "  -v, --verbose           Prints more messages to the log\n" );
    puts( "  -h, --help              Prints this help\n" );
    puts( "      --autonuke          If no devices have been specified on the command line," );
    puts( "                          starts wiping all devices immediately. If devices have" );
    puts( "                          been specified, starts wiping only those specified" );
    puts( "                          devices immediately.\n" );
-    puts( "      --sync=NUM          Will perform a sync after NUM writes (default: 0)" );
+    puts( "      --autopoweroff      Power off system on completion of wipe delayed for" );
+    puts( "                          for one minute. During this one minute delay you can" );
+    puts( "                          abort the shutdown by typing sudo shutdown -c\n" );
+    printf( "      --sync=NUM          Will perform a sync after NUM writes (default: %d)\n", DEFAULT_SYNC_RATE );
    puts( "                          0 - fdatasync after the disk is completely written" );
+    puts( "                              fdatasync errors not detected until completion." );
+    puts( "                              0 is not recommended as disk errors may cause nwipe" );
+    puts( "                              to appear to hang" );
    puts( "                          1 - fdatasync after every write" );
-    puts( "                          1000000 - fdatasync after 1000000 writes ect." );
+    puts( "                              Warning: Lower values will reduce wipe speeds." );
+    puts( "                          1000000 - fdatasync after 1000000 writes etc.)\n" );
    puts( "      --verify=TYPE       Whether to perform verification of erasure" );
    puts( "                          (default: last)" );
    puts( "                          off   - Do not verify" );
@@ -471,6 +523,8 @@ void display_help()
    puts( "      --nogui             Do not show the GUI interface. Automatically invokes" );
    puts( "                          the nowait option. Must be used with the --autonuke" );
    puts( "                          option. Send SIGUSR1 to log current stats\n" );
+    puts( "      --nousb             Do show or wipe any USB devices whether in GUI" );
+    puts( "                          mode, --nogui or --autonuke modes.\n" );
    puts( "  -e, --exclude=DEVICES   Up to ten comma separated devices to be excluded" );
    puts( "                          --exclude=/dev/sdc" );
    puts( "                          --exclude=/dev/sdc,/dev/sdd" );
--- a/src/options.h
+++ b/src/options.h
@@ -37,6 +37,7 @@
 #define NWIPE_KNOB_STAT "/proc/stat"
 #define MAX_NUMBER_EXCLUDED_DRIVES 10
 #define MAX_DRIVE_PATH_LENGTH 200  // e.g. /dev/sda is only 8 characters long, so 200 should be plenty.
+#define DEFAULT_SYNC_RATE 100000

 /* Function prototypes for loading options from the environment and command line. */
 int nwipe_options_parse( int argc, char** argv );
@@ -48,7 +49,9 @@ void display_help();
 typedef struct
 {
    int autonuke;  // Do not prompt the user for confirmation when set.
+    int autopoweroff;  // Power off on completion of wipe
    int noblank;  // Do not perform a final blanking pass.
+    int nousb;  // Do not show or wipe any USB devices.
    int nowait;  // Do not wait for a final key before exiting.
    int nosignals;  // Do not allow signals to interrupt a wipe.
    int nogui;  // Do not show the GUI.
@@ -59,6 +62,7 @@ typedef struct
    nwipe_prng_t* prng;  // The pseudo random number generator implementation.
    int rounds;  // The number of times that the wipe method should be called.
    int sync;  // A flag to indicate whether and how often writes should be sync'd.
+    int verbose;  // Make log more verbose
    nwipe_verify_t verify;  // A flag to indicate whether writes should be verified.
 } nwipe_options_t;

--- a/src/prng.c
+++ b/src/prng.c
@@ -19,6 +19,7 @@

 #include "nwipe.h"
 #include "prng.h"
+#include "context.h"
 #include "logging.h"

 #include "mt19937ar-cok/mt19937ar-cok.h"
--- a/src/version.c
+++ b/src/version.c
@@ -4,7 +4,7 @@
 * used by configure to dynamically assign those values
 * to documentation files.
 */
-const char* version_string = "0.28";
+const char* version_string = "0.30";
 const char* program_name = "nwipe";
 const char* author_name = "Martijn van Brummelen";
 const char* email_address = "git@brumit.nl";
@@ -14,4 +14,4 @@ Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>\n\
 This is free software; see the source for copying conditions.\n\
 There is NO warranty; not even for MERCHANTABILITY or FITNESS\n\
 FOR A PARTICULAR PURPOSE.\n";
-const char* banner = "nwipe 0.28";
+const char* banner = "nwipe 0.30";