Merge pull request #211 from PartialVolume/Release_0.28

Release 0.28

.clang-format

@@ -0,0 +1,80 @@
+---
+Language:        Cpp
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   false
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      true
+  AfterFunction:   true
+  AfterControlStatement: true
+  AfterEnum:       false
+  AfterNamespace:  true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     false
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: true
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+ContinuationIndentWidth: 4
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IndentCaseLabels: true
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    false
+SpaceAfterCStyleCast: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: Never
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: true
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never
+...
+

.github/workflows/ci_ubuntu_16.04.yml

@@ -0,0 +1,24 @@
+name: ci_ubuntu_16.04
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-16.04
+
+    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-5.0
+    - name: creating autoconf files
+      run: ./init.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

.github/workflows/ci_ubuntu_latest.yml

@@ -0,0 +1,24 @@
+name: ci_ubuntu_latest
+
+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-5.0
+    - name: creating autoconf files
+      run: ./init.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

.gitignore

@@ -0,0 +1,22 @@
+Makefile
+Makefile.in
+aclocal.m4
+autom4te.cache/
+compile
+config.h
+config.h.in
+config.log
+config.status
+configure
+depcomp
+install-sh
+man/Makefile
+man/Makefile.in
+missing
+src/**/.deps/
+src/**/.dirstamp
+*.o
+src/Makefile
+src/Makefile.in
+src/nwipe
+stamp-h1

CHANGELOG.md

@@ -0,0 +1,171 @@
+RELEASE NOTES
+=============
+
+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)
+
+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)
+- 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)
+- Add the Github build CI service and update Readme with build status labels (Thanks louib)
+- Miscellaneous smaller fixes
+
+
+v0.26
+-----
+- Add exclude drive option (Thanks PartialVolume)
+- Log hardware (Thanks PartialVolume)
+
+v0.25
+-----
+- Correct J=Up K=Down in footer (Thanks PartialVolume)
+- Fix segfault initialize `nwipe_gui_thread` (Thanks PartialVolume)
+- Fix memory leaks (Thanks PartialVolume)
+- Check right pointer (Thanks PartialVolume)
+- Fix casting problem (Thanks PartialVolume)
+- Fix serial number
+- Fixes uninitialized variable warning (Thanks PartialVolume)
+
+v0.24
+-----
+- use include values for version 0.17
+- display throughput value more friendly (Thanks Kelderek)
+
+v0.23
+-----
+- make serial visible again on 32Bit machines
+
+v0.22
+-----
+- Update manpage
+- use long long for device size
+- Use `ped_unit_format_byte` function to display(friendly) size of device
+
+v0.21
+-----
+- Fix 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).
+
+v0.19
+-----
+- Fix building on Fedora(Unknown `off64_t`) bug #19.
+- Use PRNG instead of zero's bug #7. (Thanks xambroz).
+
+v0.18
+-----
+- Fixed grammar.
+- Move from `loff_t` to `off64_t` for musl libc support.
+- Add `--nosignals` option.
+- Automake needs the `dist_` prefix to include man pages in `make dist`.
+- Remove more compiler warnings.
+- Add libintl, libuuid dependencies to allow parted static link
+
+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).
+
+v0.16
+-----
+- Fix problems building with clang compiler (Thanks Martijn van Brummelen)
+
+v0.15
+-----
+- Add more detailed information to status page when wiping
+- Add ability to send SIGUSR1 to print wiping current status to log
+- Fixed problem with status bar disappearing on narrow windows (Github issue #1)
+
+v0.14
+-----
+- Added explicit check for ncurses (required for Fedora). See bug 3604008.
+
+v0.13
+-----
+- Added nowait option (patch 3601259 - thanks David Shaw).
+- Added nogui option.
+- Updated man page and help command for above options and autonuke.
+- Added pkg-config check for ncurses (patch 3603140 - thanks Alon Bar-Lev).
+
+v0.12
+-----
+- Added ability to specify device on command line (patch 3587144).
+- Fixed segfault for -p option (patch 3587132).
+
+v0.11
+-----
+- Fixed bug 3568750. Not closing devices after initial scan.
+
+v0.10
+-----
+- Fixed bug 3553851. Not exiting on terminal kill. Fixed for all areas of
+  program including wiping.
+
+v0.09
+-----
+- Added feature #3545971. Display device name.
+- Added feature #3496858. Option to not perform a final blanking pass.
+
+v0.08
+-----
+- Fixed bug #3501746 whereby "wipe finished" was displayed too early
+
+v0.07
+-----
+- Added threading synchronisation for logging
+- Fixed bug #3486927 (incorrect Sourceforge URL)
+
+v0.06
+-----
+- Added man page (thanks Michal Ambroz <rebus@seznam.cz>)
+- Updated GPL licence and FSF address (thanks Michal Ambroz <rebus@seznam.cz>)
+
+v0.05
+-----
+- Added sequence number to disk selection
+- Added check for ncurses header files in subdir
+- Fixed screen corruption bug introduced in 0.04
+- Fixed occasional seg fault on start
+- Introduced dynamic array allocation for devices, with no hard limit
+- Minor updates to configure.ac
+
+v0.04
+-----
+- Removed references to DBAN in options.c
+- Added log file name option (-l|--logfile)
+- If no log file specified all messages go to STDOUT
+- Incorrect success message after an interruption fixed
+- Improved labelling of disks with no partition table
+- Added help command
+- Added version command
+- Added command 'b' to blank screen during wipe
+- Compilation needs to include panel library
+
+KNOWN BUG - display sometimes becomes corrupted after starting wipe
+
+v0.03
+-----
+- Added quit option label (ctrl-c)
+- Removed further references to DWIPE
+- Added GPL V2 licence file (COPYING)
+
+v0.02
+-----
+- Fixed segfault that happened during multiple disk wipes

Makefile.am

@@ -1,2 +1,9 @@
-AUTOMAKE_OPTIONS = foreign
 SUBDIRS = src man
+
+# The set of files to be formatted.
+FORMATSOURCES = src/*.c src/*.h
+format:
+	clang-format -i -style=file $(FORMATSOURCES)
+
+check-format:
+	clang-format -i -style=file $(FORMATSOURCES) && git diff --exit-code

README

@@ -1,102 +0,0 @@
-Installation
-============
-First bootstrap the source tree:
-./init.sh
-
-The install using the standard:
-./configure
-make
-make install
-
-The ncurses, pthreads and parted libraries are required for compiling.
-For any problems, please use the Github page:
-https://github.com/abeverley/nwipe
-
-Andy Beverley
-
-
-RELEASE NOTES
-=============
-
-v0.15
-=====
-- Add more detailed information to status page when wiping
-- Add ability to send SIGUSR1 to print wiping current status to log
-- Fixed problem with status bar disappearing on narrow windows (Github issue #1)
-
-v0.14
-=====
-- Added explicit check for ncurses (required for Fedora). See bug 3604008.
-
-v0.13
-=====
-- Added nowait option (patch 3601259 - thanks David Shaw).        
-- Added nogui option.
-- Updated man page and help command for above options and autonuke.
-- Added pkg-config check for ncurses (patch 3603140 - thanks Alon Bar-Lev).
-
-v0.12
-=====
-- Added ability to specify device on command line (patch 3587144).
-- Fixed segfault for -p option (patch 3587132).
-
-v0.11
-=====
-- Fixed bug 3568750. Not closing devices after initial scan.
-
-v0.10
-=====
-- Fixed bug 3553851. Not exiting on terminal kill. Fixed for all areas of
-  program including wiping.
-
-v0.09
-=====
-- Added feature #3545971. Display device name.
-- Added feature #3496858. Option to not perform a final blanking pass.
-
-v0.08
-=====
-- Fixed bug #3501746 whereby "wipe finished" was displayed too early
-
-v0.07
-=====
-- Added threading synchronisation for logging 
-- Fixed bug #3486927 (incorrect Sourceforge URL)
-
-v0.06
-=====
-- Added man page (thanks Michal Ambroz <rebus@seznam.cz>)
-- Updated GPL licence and FSF address (thanks Michal Ambroz <rebus@seznam.cz>)
-
-v0.05
-=====
-- Added sequence number to disk selection
-- Added check for ncurses header files in subdir
-- Fixed screen corruption bug introduced in 0.04
-- Fixed occasional seg fault on start
-- Introduced dynamic array allocation for devices, with no hard limit
-- Minor updates to configure.ac
-
-v0.04
-=====
-- Removed references to DBAN in options.c
-- Added log file name option (-l|--logfile)
-- If no log file specified all messages go to STDOUT
-- Incorrect success message after an interruption fixed
-- Improved labelling of disks with no partition table
-- Added help command
-- Added version command
-- Added command 'b' to blank screen during wipe
-- Compilation needs to include panel library
-
-KNOWN BUG - display sometimes becomes corrupted after starting wipe
-
-v0.03
-=====
-- Added quit option label (ctrl-c)
-- Removed further references to DWIPE
-- Added GPL V2 licence file (COPYING)
-
-v0.02
-=====
-- Fixed segfault that happened during multiple disk wipes

README.md

@@ -1,15 +1,134 @@
-nwipe is a command that will securely erase disks using a variety of
-recognised methods.  It is a fork of the dwipe command used by
-Darik's Boot and Nuke (dban).  nwipe is included with partedmagic if
-want a quick and easy bootable CD version.  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.
+# 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)
 
-To use from the git repository, first create all the autoconf files with
+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.
+
+The user can select from a variety of recognised secure erase methods which include:
+
+* Zero Fill          - Fills the device with zeros, one round only.
+* RCMP TSSIT OPS-II  - Royal Candian Mounted Police Technical Security Standard, OPS-II
+* DoD Short          - The American Department of Defense 5220.22-M short 3 pass wipe (passes 1, 2 & 7).
+* DoD 5220.22M       - The American Department of Defense 5220.22-M full 7 pass wipe.
+* Gutmann Wipe       - Peter Gutmann's method (Secure Deletion of Data from Magnetic and Solid-State Memory).
+* PRNG Stream        - Fills the device with a stream from the PRNG.
+* Verify only        - This method only reads the device and checks that it is all zero.
+* HMG IS5 enhanced   - Secure Sanitisation of Protectively Marked Information or Sensitive Information
+
+It also includes the following pseudo random number generators:
+* Mersenne Twister
+* 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.
+
+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.
+
+![Example wipe](/images/example_wipe.gif)
+
+## Compiling & Installing
+
+`nwipe` requires the following libraries to be installed:
+
+* ncurses
+* pthreads
+* parted
+
+### Debian & Ubuntu prerequisites
+
+If you are compiling `nwipe` from source, the following libraries will need to be installed first:
+
+```bash
+sudo apt install \
+  build-essential \
+  pkg-config \
+  automake \
+  libncurses5-dev \
+  autotools-dev \
+  libparted-dev \
+  dmidecode
+```
+
+### Fedora prerequisites
+
+```bash
+sudo bash
+dnf update
+dnf groupinstall "Development Tools"
+dnf groupinstall "C Development Tools and Libraries"
+yum install ncurses-devel
+yum install parted-devel
+yum install dmidecode
+```
+Note. dmidecode is optional, it provides SMBIOS/DMI host data to stdout or the log file.
+
+### Compilation
+
+For a development setup, see [the hacking section below](#Hacking).
+
+First create all the autoconf files:
+```
 ./init.sh
+```
 
-Then do the standard ./configure --prefix=/usr && make && make install
+Then compile & install using the following standard commands:
+```
+./configure
+make
+make install
+```
 
-For release notes please see the [README file](README)
+Then run nwipe !
+```
+cd src
+sudo ./nwipe
+```
+or
+```
+sudo nwipe
+```
 
+### Hacking
+
+If you wish to submit pull requests to this code we would prefer you enable all warnings when compiling.
+This can be done using the following compile commands:
+
+```
+./configure --prefix=/usr CFLAGS='-O0 -g -Wall -Wextra'
+make
+make install
+```
+
+The `-O0 -g` flags disable optimisations. This is required if you're debugging with
+`gdb` in an IDE such as Kdevelop. With these optimisations enabled you won't be
+able to see the values of many variables in nwipe, not to mention the IDE won't step
+through the code properly.
+
+The `-Wall` and `-Wextra` flags enable all compiler warnings. Please submit code with zero warnings.
+
+Also make sure that your changes are consistent with the coding style defined in the `.clang-format` file, using:
+```
+make format
+```
+You will need `clang-format` installed to use the `format` command.
+
+
+Once done with your coding then the released/patch/fixed code can be compiled,
+with all the normal optimisations, using:
+```
+./configure --prefix=/usr && make && make install
+```
+
+## Bugs
+
+Bugs can be reported on GitHub:
+https://github.com/martijnvanbrummelen/nwipe
+
+## License
+
+GNU General Public License v2.0

configure.ac

@@ -2,8 +2,8 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ([2.64])
-AC_INIT(nwipe, 0.15, andy@andybev.com)
-AM_INIT_AUTOMAKE(nwipe, 0.15)
+AC_INIT([nwipe], [0.28], [git@brumit.nl])
+AM_INIT_AUTOMAKE(foreign subdir-objects)
 AC_OUTPUT(Makefile src/Makefile man/Makefile)
 AC_CONFIG_SRCDIR([src/nwipe.c])
 AC_CONFIG_HEADERS([config.h])
@@ -21,7 +21,14 @@ PKG_CHECK_MODULES(
 		CFLAGS="${CFLAGS} ${PANEL_CFLAGS}"
 		LIBS="${LIBS} ${PANEL_LIBS}"
 	],
-	[AC_CHECK_LIB([panel], [main], ,[AC_MSG_ERROR([ncurses panel library not found])])]
+	[AC_CHECK_LIB([panel], [main], [
+		LIBS="-lpanel $LIBS"
+		AC_CHECK_HEADERS(panel.h,, [
+		    AC_CHECK_HEADERS(ncurses/panel.h, [
+			AC_DEFINE([PANEL_IN_SUBDIR], [ncurses/], [Look for ncurses headers in subdir])
+			], [AC_MSG_ERROR([ncurses panel headers not found])])
+		])
+	    ], [AC_MSG_ERROR([ncurses panel library not found])])]
 )
 
 PKG_CHECK_MODULES(
@@ -42,7 +49,9 @@ PKG_CHECK_MODULES(
 	)]
 )
 
-AC_CHECK_LIB([parted], [ped_device_probe_all], ,[AC_MSG_ERROR([parted development library not found])])
+AC_CHECK_LIB([intl], [libintl_dgettext]) # needed to statically link libparted, but not given in its pkgconfig file
+AC_CHECK_LIB([uuid], [uuid_generate])    # needed to statically link libparted, but not given in its pkgconfig file
+PKG_CHECK_MODULES([PARTED], [libparted])
 AC_CHECK_LIB([pthread], [main], ,[AC_MSG_ERROR([pthread development library not found])])
 
 # Checks for header files.

man/Makefile.am

@@ -1 +1 @@
-man_MANS = nwipe.1
+dist_man_MANS = nwipe.1

man/nwipe.1

@@ -1,4 +1,4 @@
-.TH NWIPE "1" "March 2014" "nwipe version 0.15" "User Commands"
+.TH NWIPE "1" "March 2020" "nwipe version 0.28" "User Commands"
 .SH NAME
 nwipe \- securely erase disks
 .SH SYNOPSIS
@@ -7,7 +7,7 @@ nwipe \- securely erase disks
 .SH DESCRIPTION
 nwipe is a command that will securely erase disks using a variety of
 recognised methods.  It is a fork of the dwipe command used by Darik's Boot
-and Nuke (dban).  nwipe is included with partedmagic if want a quick and
+and Nuke (dban).  nwipe is included with partedmagic if you want a quick and
 easy bootable CD version.  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.  It is essentially the
@@ -37,9 +37,16 @@ those specified devices immediately.
 \fB\-\-sync\fR
 Open devices in sync mode
 .TP
+\fB\-\-noblank\fR
+Do not perform the final blanking pass after the wipe (default is to blank,
+except when the method is RCMP TSSIT OPS\-II).
+.TP
 \fB\-\-nowait\fR
 Do not wait for a key before exiting (default is to wait).
 .TP
+\fB\-\-nosignals\fR
+Do not allow signals to interrupt a wipe (default is to allow).
+.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.
@@ -47,9 +54,15 @@ SIGUSR1 can be used to retrieve the current wiping statistics.
 .TP
 \fB\-\-verify\fR=\fITYPE\fR
 Whether to perform verification of erasure (default: last)
+.IP
 off   \- Do not verify
+.IP
 last  \- Verify after the last pass
+.IP
 all   \- Verify every pass
+.IP
+Please mind that HMG IS5 enhanced always verifies the last (PRNG) pass
+regardless of this option.
 .TP
 \fB\-m\fR, \fB\-\-method\fR=\fIMETHOD\fR
 The wiping method (default: dodshort).
@@ -65,6 +78,10 @@ ops2                   \- RCMP TSSIT OPS\-II
 random / prng / stream \- PRNG Stream
 .IP
 zero / quick           \- Overwrite with zeros
+.IP
+verify                 \- Verifies disk is zero filled
+.IP
+is5enh                 \- HMG IS5 enhanced
 .TP
 \fB\-l\fR, \fB\-\-logfile\fR=\fIFILE\fR
 Filename to log to. Default is STDOUT
@@ -74,12 +91,16 @@ PRNG option (mersenne|twister|isaac)
 .TP
 \fB\-r\fR, \fB\-\-rounds\fR=\fINUM\fR
 Number of times to wipe the device using the selected method (default: 1)
+.TP
+\fB\-e\fR, \fB\-\-exclude\fR=\fIDEVICES\fR
+Up to ten comma separated devices to be excluded, examples:
+ --exclude=/dev/sdc
+ --exclude=/dev/sdc,/dev/sdd
 .SH BUGS
-Please see the sourceforge site for the latest list
-(http://nwipe.sourceforge.net)
+Please see the GitHub site for the latest list
+(https://github.com/martijnvanbrummelen/nwipe/issues)
 .SH AUTHOR
-Nwipe was released  by Andy Beverley <andy@andybev.com>
-as modified version of dwipe from DBAN by Darik Horn <dajhorn-dban@vanadac.com>.
+Nwipe is developed by Martijn van Brummelen <github@brumit.nl>
 .SH "SEE ALSO"
 .BR shred (1),
 .BR dwipe (1),

src/Makefile.am

@@ -6,4 +6,6 @@ AM_LDFLAGS =
 # this lists the binaries to produce, the (non-PHONY, binary) targets in
 # the previous manual Makefile
 bin_PROGRAMS = nwipe
-nwipe_SOURCES = context.h isaac_rand.c logging.h options.h prng.h nwipe.c gui.c isaac_rand.h method.h pass.c device.c gui.h isaac_standard.h mt19937ar-cok.c nwipe.h mt19937ar-cok.h pass.h device.h logging.c method.c options.c prng.c version.c version.h
+nwipe_SOURCES = context.h isaac_rand/isaac_rand.c logging.h options.h prng.h nwipe.c gui.c isaac_rand/isaac_rand.h method.h pass.c device.c gui.h isaac_rand/isaac_standard.h mt19937ar-cok/mt19937ar-cok.c nwipe.h mt19937ar-cok/mt19937ar-cok.h pass.h device.h logging.c method.c options.c prng.c version.c version.h
+nwipe_CFLAGS = $(PARTED_CFLAGS)
+nwipe_LDADD = $(PARTED_LIBS)

src/context.h

@@ -2,7 +2,7 @@
  *  context.h: The internal state representation of nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
@@ -25,120 +25,130 @@
 
 #include "prng.h"
 
-typedef enum nwipe_device_t_
-{
-	NWIPE_DEVICE_UNKNOWN = 0,   /* Unknown device. */
-	NWIPE_DEVICE_IDE,
-	NWIPE_DEVICE_SCSI,
-	NWIPE_DEVICE_COMPAQ,        /* Unimplemented.  */
-	NWIPE_DEVICE_USB,           /* Unimplemented.  */
-	NWIPE_DEVICE_IEEE1394       /* Unimplemented.  */
+typedef enum nwipe_device_t_ {
+    NWIPE_DEVICE_UNKNOWN = 0,  // Unknown device.
+    NWIPE_DEVICE_IDE,
+    NWIPE_DEVICE_SCSI,
+    NWIPE_DEVICE_COMPAQ,  // Unimplemented.
+    NWIPE_DEVICE_USB,  // Unimplemented.
+    NWIPE_DEVICE_IEEE1394  // Unimplemented.
 } nwipe_device_t;
 
-typedef enum nwipe_pass_t_
-{
-	NWIPE_PASS_NONE = 0,     /* Not running.                     */
-	NWIPE_PASS_WRITE,        /* Writing patterns to the device.  */
-	NWIPE_PASS_VERIFY,       /* Verifying a pass.                */
-	NWIPE_PASS_FINAL_BLANK,  /* Filling the device with zeros.   */
-	NWIPE_PASS_FINAL_OPS2    /* Special case for nwipe_ops2.     */
+typedef enum nwipe_pass_t_ {
+    NWIPE_PASS_NONE = 0,  // Not running.
+    NWIPE_PASS_WRITE,  // Writing patterns to the device.
+    NWIPE_PASS_VERIFY,  // Verifying a pass.
+    NWIPE_PASS_FINAL_BLANK,  // Filling the device with zeros.
+    NWIPE_PASS_FINAL_OPS2  // Special case for nwipe_ops2.
 } nwipe_pass_t;
 
-typedef enum nwipe_select_t_
-{
-	NWIPE_SELECT_NONE = 0,     /* Unused.                                                                  */
-	NWIPE_SELECT_TRUE,         /* Wipe this device.                                                        */
-	NWIPE_SELECT_TRUE_PARENT,  /* A parent of this device has been selected, so the wipe is implied.       */
-	NWIPE_SELECT_FALSE,        /* Do not wipe this device.                                                 */
-	NWIPE_SELECT_FALSE_CHILD,  /* A child of this device has been selected, so we can't wipe this device.  */
-	NWIPE_SELECT_DISABLED      /* Do not wipe this device and do not allow it to be selected.              */
+typedef enum nwipe_select_t_ {
+    NWIPE_SELECT_NONE = 0,  // Unused.
+    NWIPE_SELECT_TRUE,  // Wipe this device.
+    NWIPE_SELECT_TRUE_PARENT,  // A parent of this device has been selected, so the wipe is implied.
+    NWIPE_SELECT_FALSE,  // Do not wipe this device.
+    NWIPE_SELECT_FALSE_CHILD,  // A child of this device has been selected, so we can't wipe this device.
+    NWIPE_SELECT_DISABLED  // Do not wipe this device and do not allow it to be selected.
 } nwipe_select_t;
 
-
-#define NWIPE_KNOB_SPEEDRING_SIZE         30
-#define NWIPE_KNOB_SPEEDRING_GRANULARITY  10
+#define NWIPE_KNOB_SPEEDRING_SIZE 30
+#define NWIPE_KNOB_SPEEDRING_GRANULARITY 10
 
 typedef struct nwipe_speedring_t_
 {
-	u64    bytes[NWIPE_KNOB_SPEEDRING_SIZE];
-	u64    bytestotal;
-	u64    byteslast;
-	time_t times[NWIPE_KNOB_SPEEDRING_SIZE];
-	time_t timestotal;
-	time_t timeslast;
-	u32    position;
+    u64 bytes[NWIPE_KNOB_SPEEDRING_SIZE];
+    u64 bytestotal;
+    u64 byteslast;
+    time_t times[NWIPE_KNOB_SPEEDRING_SIZE];
+    time_t timestotal;
+    time_t timeslast;
+    u32 position;
 } nwipe_speedring_t;
 
+#define NWIPE_DEVICE_LABEL_LENGTH 200
 
 typedef struct nwipe_context_t_
 {
-	int               block_size;    /* The soft block size reported the device.                       */
-	int               device_bus;    /* The device bus number.                                         */
-	int               device_fd;     /* The file descriptor of the device file being wiped.            */
-	int               device_host;   /* The host number.                                               */
-	struct hd_driveid device_id;     /* The WIN_IDENTIFY data for IDE drives.                          */
-	int               device_lun;    /* The device logical unit number.                                */
-	int               device_major;  /* The major device number.                                       */
-	int               device_minor;  /* The minor device number.                                       */
-	int               device_part;   /* The device partition or slice number.                          */
-	char*             device_name;   /* The device file name.                                          */
-	loff_t            device_size;   /* The device size in bytes.                                      */
-	struct stat       device_stat;   /* The device file state from fstat().                            */
-	nwipe_device_t    device_type;   /* Indicates an IDE, SCSI, or Compaq SMART device.                */
-	int               device_target; /* The device target.                                             */
-	u64               eta;           /* The estimated number of seconds until method completion.       */
-	int               entropy_fd;    /* The entropy source. Usually /dev/urandom.                      */
-	char*             label;         /* The string that we will show the user.                         */
-	int               pass_count;    /* The number of passes performed by the working wipe method.     */
-	u64               pass_done;     /* The number of bytes that have already been i/o'd in this pass. */
-	u64               pass_errors;   /* The number of errors across all passes.                        */
-	u64               pass_size;     /* The total number of i/o bytes across all passes.               */
-	nwipe_pass_t      pass_type;     /* The type of the current working pass.                          */
-	int               pass_working;  /* The current working pass.                                      */
-	nwipe_prng_t*     prng;          /* The PRNG implementation.                                       */
-	nwipe_entropy_t   prng_seed;     /* The random data that is used to seed the PRNG.                 */
-	void*             prng_state;    /* The private internal state of the PRNG.                        */
-	int               result;        /* The process return value.                                      */
-	int               round_count;   /* The number of rounds performed by the working wipe method.     */
-	u64               round_done;    /* The number of bytes that have already been i/o'd.              */
-	u64               round_errors;  /* The number of errors across all rounds.                        */
-	u64               round_size;    /* The total number of i/o bytes across all rounds.               */
-	double            round_percent; /* The percentage complete across all rounds.                     */
-	int               round_working; /* The current working round.                                     */
-	int               sector_size;   /* The hard sector size reported by the device.                   */
-	nwipe_select_t    select;        /* Indicates whether this device should be wiped.                 */
-	int               signal;        /* Set when the child is killed by a signal.                      */
-	nwipe_speedring_t speedring;     /* Ring buffer for computing the rolling throughput average.      */
-	short             sync_status;   /* A flag to indicate when the method is syncing.                 */
-	pthread_t         thread;        /* The ID of the thread.                                          */
-	u64               throughput;    /* Average throughput in bytes per second.                        */
-	u64               verify_errors; /* The number of verification errors across all passes.           */
-	struct hd_driveid  identity;	 /* The serial number of the drive (where applicable)              */
+    /*
+     * Device fields
+     */
+    int device_block_size;  // The soft block size reported by the device.
+    int device_sector_size;  // The hard sector size reported by the device.
+    int device_bus;  // The device bus number.
+    int device_fd;  // The file descriptor of the device file being wiped.
+    int device_host;  // The host number.
+    struct hd_driveid device_id;  // The WIN_IDENTIFY data for IDE drives.
+    int device_lun;  // The device logical unit number.
+    int device_major;  // The major device number.
+    int device_minor;  // The minor device number.
+    int device_part;  // The device partition or slice number.
+    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_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.
+    char device_serial_no[21];  // Serial number(processed, 20 characters plus null termination) of the device.
+    int device_target;  // The device target.
+
+    u64 eta;  // The estimated number of seconds until method completion.
+    int entropy_fd;  // The entropy source. Usually /dev/urandom.
+    int pass_count;  // The number of passes performed by the working wipe method.
+    u64 pass_done;  // The number of bytes that have already been i/o'd in this pass.
+    u64 pass_errors;  // The number of errors across all passes.
+    u64 pass_size;  // The total number of i/o bytes across all passes.
+    nwipe_pass_t pass_type;  // The type of the current working pass.
+    int pass_working;  // The current working pass.
+    nwipe_prng_t* prng;  // The PRNG implementation.
+    nwipe_entropy_t prng_seed;  // The random data that is used to seed the PRNG.
+    void* prng_state;  // The private internal state of the PRNG.
+    int result;  // The process return value.
+    int round_count;  // The number of rounds performed by the working wipe method.
+    u64 round_done;  // The number of bytes that have already been i/o'd.
+    u64 round_errors;  // The number of errors across all rounds.
+    u64 round_size;  // The total number of i/o bytes across all rounds.
+    double round_percent;  // The percentage complete across all rounds.
+    int round_working;  // The current working round.
+    nwipe_select_t select;  // Indicates whether this device should be wiped.
+    int signal;  // Set when the child is killed by a signal.
+    nwipe_speedring_t speedring;  // Ring buffer for computing the rolling throughput average.
+    short sync_status;  // A flag to indicate when the method is syncing.
+    pthread_t thread;  // The ID of the thread.
+    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.
+    /*
+     * Identity contains the raw serial number of the drive
+     * (where applicable), however, for use within nwipe use the
+     * processed serial_no[21] string above. To access serial no. use
+     * c[i]->serial_no) and not c[i]->identity.serial_no);
+     */
+    struct hd_driveid identity;
 } nwipe_context_t;
 
-
-/* We use 2 data structs to pass data between threads. */
-
-/* The first contains any required values:                                      */
-/* Values cannot form part of the second array below, hence the need for this.  */
+/*
+ * We use 2 data structs to pass data between threads.
+ * The first contains any required values.
+ * Values cannot form part of the second array below, hence the need for this.
+ */
 typedef struct
 {
-        int       nwipe_enumerated;  /* The number of devices available.                */
-        int       nwipe_selected;    /* The number of devices being wiped.              */
-        time_t    maxeta;            /* The estimated runtime of the slowest device.    */
-        u64       throughput;        /* Total throughput                                */
-        u64       errors;            /* The combined number of errors of all processes. */
-        pthread_t *gui_thread;       /* The ID of GUI thread.                           */
+    int nwipe_enumerated;  // The number of devices available.
+    int nwipe_selected;  // The number of devices being wiped.
+    time_t maxeta;  // The estimated runtime of the slowest device.
+    u64 throughput;  // Total throughput.
+    u64 errors;  // The combined number of errors of all processes.
+    pthread_t* gui_thread;  // The ID of GUI thread.
 } nwipe_misc_thread_data_t;
 
-/* The second points to the first structure, as well as the structure of all the devices   */
-typedef struct 
+/*
+ * The second points to the first structure, as well as the structure of all the devices
+ */
+typedef struct
 {
-        nwipe_context_t **c;                                 /* Pointer to the nwipe context structure.           */
-        nwipe_misc_thread_data_t *nwipe_misc_thread_data;    /* Pointer to the misc structure above.              */
+    nwipe_context_t** c;  // Pointer to the nwipe context structure.
+    nwipe_misc_thread_data_t* nwipe_misc_thread_data;  // Pointer to the misc structure above.
 } nwipe_thread_data_ptr_t;
 
-
 #endif /* CONTEXT_H_ */
-
-/* eof */

src/device.c

@@ -2,9 +2,9 @@
  *  device.c:  Device routines for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
- *  
+ *
  *  This program is free software; you can redistribute it and/or modify it under
  *  the terms of the GNU General Public License as published by the Free Software
  *  Foundation, version 2.
@@ -16,120 +16,248 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-/* Why is this needed? Segfaults without it */
-#include <netinet/in.h>
+#include <stdint.h>
 
 #include "nwipe.h"
 #include "context.h"
 #include "method.h"
 #include "options.h"
 #include "logging.h"
+#include <sys/ioctl.h>
+#include <linux/hdreg.h>  // Drive specific defs
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <ctype.h>
 
 #include <parted/parted.h>
-#include <parted/debug.h> 
+#include <parted/debug.h>
 
 int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount );
+char* trim( char* str );
 
 int nwipe_device_scan( nwipe_context_t*** c )
 {
-	/**
-	 * Scans the the filesystem for storage device names.
-	 *
-	 * @parameter device_names  A reference to a null array pointer.
-	 * @modifies  device_names  Populates device_names with an array of nwipe_contect_t
-	 * @returns                 The number of strings in the device_names array.
-	 *
-	 */
+    /**
+     * Scans the filesystem for storage device names.
+     *
+     * @parameter device_names  A reference to a null array pointer.
+     * @modifies  device_names  Populates device_names with an array of nwipe_contect_t
+     * @returns                 The number of strings in the device_names array.
+     *
+     */
 
-	PedDevice* dev = NULL;
-        ped_device_probe_all();
-	
-	int dcount = 0;
+    PedDevice* dev = NULL;
+    ped_device_probe_all();
 
-        while ((dev = ped_device_get_next (dev)))
-        {
-                if (check_device(c, dev, dcount))
-                        dcount++;
-	}
+    int dcount = 0;
 
-	/* Return the number of devices that were found. */
-	return dcount;
+    while( ( dev = ped_device_get_next( dev ) ) )
+    {
+        if( check_device( c, dev, dcount ) )
+            dcount++;
+    }
+
+    /* Return the number of devices that were found. */
+    return dcount;
 
 } /* nwipe_device_scan */
 
-int nwipe_device_get( nwipe_context_t*** c, char **devnamelist, int ndevnames )
+int nwipe_device_get( nwipe_context_t*** c, char** devnamelist, int ndevnames )
 {
-	/**
-	 * Gets information about devices
-	 *
-	 * @parameter device_names  A reference to a null array pointer.
-	 * @parameter devnamelist   An array of string pointers to the device names
-	 * @parameter ndevnames     Number of elements in devnamelist
-	 * @modifies  device_names  Populates device_names with an array of nwipe_contect_t
-	 * @returns                 The number of strings in the device_names array.
-	 *
-	 */
+    /**
+     * Gets information about devices
+     *
+     * @parameter device_names  A reference to a null array pointer.
+     * @parameter devnamelist   An array of string pointers to the device names
+     * @parameter ndevnames     Number of elements in devnamelist
+     * @modifies  device_names  Populates device_names with an array of nwipe_contect_t
+     * @returns                 The number of strings in the device_names array.
+     *
+     */
 
-	PedDevice* dev = NULL;
-	
-	int i;
-	int dcount = 0;
+    PedDevice* dev = NULL;
 
-	for(i = 0; i < ndevnames; i++) {
+    int i;
+    int dcount = 0;
 
-		dev = ped_device_get(devnamelist[i]);
-		if (!dev)
-			break;
+    for( i = 0; i < ndevnames; i++ )
+    {
 
-                if (check_device(c, dev, dcount))
-                        dcount++;
-	}
+        dev = ped_device_get( devnamelist[i] );
+        if( !dev )
+        {
+            nwipe_log( NWIPE_LOG_WARNING, "Device %s not found", devnamelist[i] );
+            continue;
+        }
 
-	/* Return the number of devices that were found. */
-	return dcount;
+        if( check_device( c, dev, dcount ) )
+            dcount++;
+    }
+
+    /* Return the number of devices that were found. */
+    return dcount;
 
 } /* nwipe_device_get */
 
 int check_device( nwipe_context_t*** c, PedDevice* dev, int dcount )
 {
-	/* Populate this struct, then assign it to overall array of structs. */
-	nwipe_context_t* next_device;
+    /* Populate this struct, then assign it to overall array of structs. */
+    nwipe_context_t* next_device;
+    int fd;
+    int idx;
 
-        /* Try opening the device to see if it's valid. Close on completion. */
-        if (!ped_device_open(dev))
-                return 0;
-        ped_device_close(dev);
-        
-        /* New device, reallocate memory for additional struct pointer */
-        *c = realloc (*c, (dcount+1) * sizeof(nwipe_context_t *));
-        
-        next_device = malloc (sizeof(nwipe_context_t)); 
-
-        /* Check the allocation. */
-        if( ! next_device )
+    /* Check whether this drive is on the excluded drive list ? */
+    idx = 0;
+    while( idx < 10 )
+    {
+        if( !strcmp( dev->path, nwipe_options.exclude[idx++] ) )
         {
-                nwipe_perror( errno, __FUNCTION__, "malloc" );
-                nwipe_log( NWIPE_LOG_FATAL, "Unable to create the array of enumeration contexts." );
-                return 0;
+            nwipe_log( NWIPE_LOG_NOTICE, "Device %s excluded as per command line option -e", dev->path );
+            return 0;
         }
+    }
 
-        /* Zero the allocation. */
-        memset( next_device , 0, sizeof( nwipe_context_t ) );
+    /* Try opening the device to see if it's valid. Close on completion. */
+    if( !ped_device_open( dev ) )
+    {
+        nwipe_log( NWIPE_LOG_FATAL, "Unable to open device" );
+        return 0;
+    }
+    ped_device_close( dev );
 
-        /* Get device information */
-        next_device->label = dev->model;
-        next_device->device_name = dev->path;
-        next_device->device_size = dev->length * dev->sector_size;
-        /* Attempt to get serial number of device. */
-        ioctl(next_device->device_fd, HDIO_GET_IDENTITY, &next_device->identity);
+    /* New device, reallocate memory for additional struct pointer */
+    *c = realloc( *c, ( dcount + 1 ) * sizeof( nwipe_context_t* ) );
 
-        (*c)[dcount] = next_device;
-        
-        return 1;
+    next_device = malloc( sizeof( nwipe_context_t ) );
+
+    /* Check the allocation. */
+    if( !next_device )
+    {
+        nwipe_perror( errno, __FUNCTION__, "malloc" );
+        nwipe_log( NWIPE_LOG_FATAL, "Unable to create the array of enumeration contexts." );
+        return 0;
+    }
+
+    /* Zero the allocation. */
+    memset( next_device, 0, sizeof( nwipe_context_t ) );
+
+    /* Get device information */
+    next_device->device_model = dev->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 );
+    next_device->result = -2;
+
+    /* Attempt to get serial number of device. */
+    if( ( fd = open( next_device->device_name = dev->path, O_RDONLY ) ) == ERR )
+    {
+        nwipe_log( NWIPE_LOG_WARNING, "Unable to open device %s to obtain serial number", next_device->device_name );
+    }
+
+    /*
+     * We don't check the ioctl return status because there are plenty of situations where a serial number may not be
+     * returned by ioctl such as USB drives, logical volumes, encryted volumes, so the log file would have multiple
+     * benign ioctl errors reported which isn't necessarily a problem.
+     */
+    ioctl( fd, HDIO_GET_IDENTITY, &next_device->identity );
+    close( fd );
+
+    for( idx = 0; idx < 20; idx++ )
+    {
+        next_device->device_serial_no[idx] = next_device->identity.serial_no[idx];
+    }
+
+    // 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( strlen( (const char*) next_device->device_serial_no ) )
+    {
+        snprintf( next_device->device_label,
+                  NWIPE_DEVICE_LABEL_LENGTH,
+                  "%s (%s) - %s S/N:%s",
+                  next_device->device_name,
+                  next_device->device_size_text,
+                  next_device->device_model,
+                  next_device->device_serial_no );
+    }
+    else
+    {
+        snprintf( next_device->device_label,
+                  NWIPE_DEVICE_LABEL_LENGTH,
+                  "%s (%s) - %s",
+                  next_device->device_name,
+                  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,
+               next_device->device_name,
+               next_device->device_size_text,
+               next_device->device_serial_no );
+
+    ( *c )[dcount] = next_device;
+    return 1;
 }
 
-/* eof */
+/* Remove leading/training whitespace from a string and left justify result */
+char* trim( char* str )
+{
+    size_t len = 0;
+    char* frontp = str;
+    char* endp = NULL;
+
+    if( str == NULL )
+    {
+        return NULL;
+    }
+    if( str[0] == '\0' )
+    {
+        return str;
+    }
+    len = strlen( str );
+    endp = str + len;
+
+    /*
+     * Move the front and back pointers to address the first non-whitespace
+     * characters from each end.
+     */
+    while( isspace( (unsigned char) *frontp ) )
+    {
+        ++frontp;
+    }
+    if( endp != frontp )
+    {
+        while( isspace( (unsigned char) *( --endp ) ) && endp != frontp )
+        {
+        }
+    }
+    if( str + len - 1 != endp )
+        *( endp + 1 ) = '\0';
+    else if( frontp != str && endp == frontp )
+        *str = '\0';
+    /*
+     * Shift the string so that it starts at str so that if it's dynamically
+     * allocated, we can still free it on the returned pointer.  Note the reuse
+     * of endp to mean the front of the string buffer now.
+     */
+    endp = str;
+    if( frontp != str )
+    {
+        while( *frontp )
+        {
+            *endp++ = *frontp++;
+        }
+        *endp = '\0';
+    }
+    return str;
+}

src/device.h

@@ -2,7 +2,7 @@
  *  device.h:  Device routines for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,18 +16,15 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #ifndef DEVICE_H_
 #define DEVICE_H_
 
-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 */
+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.
 
 #endif /* DEVICE_H_ */
-
-/* eof */

src/gui.h

@@ -2,7 +2,7 @@
  *  gui.h: An ncurses GUI for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,29 +16,32 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #ifndef GUI_H_
 #define GUI_H_
 
-void nwipe_gui_free( void );                             /* Stop the GUI.              */
-void nwipe_gui_init( void );                             /* Start the GUI.             */
-void nwipe_gui_select( int count, nwipe_context_t** c ); /* Select devices to wipe.    */
-void *nwipe_gui_status( void *ptr );                     /* Update operation progress. */
-void nwipe_gui_method( void );                           /* Change the method option.  */
-void nwipe_gui_options( void );                          /* Update the options window. */
-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. */
+void nwipe_gui_free( void );  // Stop the GUI.
+void nwipe_gui_init( void );  // Start the GUI.
+void nwipe_gui_create_main_window( void );  // Create the main window
+void nwipe_gui_create_header_window( void );  // Create the header window
+void nwipe_gui_create_footer_window( const char* );  // Create the footer window and write text
+void nwipe_gui_create_options_window( void );  // Create the options window
+void nwipe_gui_create_stats_window( void );  // Create the stats window
+void nwipe_gui_create_all_windows_on_terminal_resize(
+    const char* footer_text );  // If terminal is resized recreate all windows
+void nwipe_gui_select( int count, nwipe_context_t** c );  // Select devices to wipe.
+void* nwipe_gui_status( void* ptr );  // Update operation progress.
+void nwipe_gui_method( void );  // Change the method option.
+void nwipe_gui_options( void );  // Update the options window.
+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 compute_stats(void *ptr);
+int compute_stats( void* ptr );
 void nwipe_update_speedring( nwipe_speedring_t* speedring, u64 speedring_done, time_t speedring_now );
 
-
 #endif /* GUI_H_ */
-
-/* eof */

src/isaac_rand/isaac_rand.c

@@ -29,8 +29,10 @@ void     isaac(ctx)
 randctx *ctx;
 {
    register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
-   mm=ctx->randmem; r=ctx->randrsl;
-   a = ctx->randa; b = ctx->randb + (++ctx->randc);
+   mm=ctx->randmem; 
+   r=ctx->randrsl;
+   a = ctx->randa; 
+   b = ctx->randb + (++ctx->randc);
    for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
    {
       rngstep( a<<13, a, b, mm, m, m2, r, x);
@@ -84,20 +86,44 @@ word     flag;
      /* initialize using the contents of r[] as the seed */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=r[i  ]; b+=r[i+1]; c+=r[i+2]; d+=r[i+3];
-       e+=r[i+4]; f+=r[i+5]; g+=r[i+6]; h+=r[i+7];
+       a+=r[i  ]; 
+       b+=r[i+1];
+       c+=r[i+2]; 
+       d+=r[i+3];
+       e+=r[i+4]; 
+       f+=r[i+5]; 
+       g+=r[i+6]; 
+       h+=r[i+7];
        mix(a,b,c,d,e,f,g,h);
-       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
-       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+       m[i  ]=a; 
+       m[i+1]=b; 
+       m[i+2]=c; 
+       m[i+3]=d;
+       m[i+4]=e; 
+       m[i+5]=f; 
+       m[i+6]=g; 
+       m[i+7]=h;
      }
      /* do a second pass to make all of the seed affect all of m */
      for (i=0; i<RANDSIZ; i+=8)
      {
-       a+=m[i  ]; b+=m[i+1]; c+=m[i+2]; d+=m[i+3];
-       e+=m[i+4]; f+=m[i+5]; g+=m[i+6]; h+=m[i+7];
+       a+=m[i  ]; 
+       b+=m[i+1]; 
+       c+=m[i+2]; 
+       d+=m[i+3];
+       e+=m[i+4]; 
+       f+=m[i+5]; 
+       g+=m[i+6]; 
+       h+=m[i+7];
        mix(a,b,c,d,e,f,g,h);
-       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
-       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+       m[i  ]=a; 
+       m[i+1]=b; 
+       m[i+2]=c; 
+       m[i+3]=d;
+       m[i+4]=e; 
+       m[i+5]=f; 
+       m[i+6]=g; 
+       m[i+7]=h;
      }
    }
    else
@@ -106,8 +132,14 @@ word     flag;
      for (i=0; i<RANDSIZ; i+=8)
      {
        mix(a,b,c,d,e,f,g,h);
-       m[i  ]=a; m[i+1]=b; m[i+2]=c; m[i+3]=d;
-       m[i+4]=e; m[i+5]=f; m[i+6]=g; m[i+7]=h;
+       m[i  ]=a; 
+       m[i+1]=b; 
+       m[i+2]=c; 
+       m[i+3]=d;
+       m[i+4]=e; 
+       m[i+5]=f; 
+       m[i+6]=g; 
+       m[i+7]=h;
      }
    }
 

src/logging.c

@@ -2,7 +2,7 @@
  *  logging.c:  Logging facilities for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  This program is free software; you can redistribute it and/or modify it under
  *  the terms of the GNU General Public License as published by the Free Software
  *  Foundation, version 2.
@@ -14,11 +14,21 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
 
+#ifndef _POSIX_SOURCE
+#define _POSIX_SOURCE
+#endif
+
+#include "stdio.h"
+#include "stdlib.h"
+#include "stdarg.h"
 #include "nwipe.h"
 #include "context.h"
 #include "method.h"
@@ -26,197 +36,438 @@
 #include "options.h"
 #include "logging.h"
 
-int const MAX_LOG_LINE_CHARS = 512;
-
 /* Global array to hold log values to print when logging to STDOUT */
-char **log_lines;
+char** log_lines;
 int log_current_element = 0;
 int log_elements_allocated = 0;
+int log_elements_displayed = 0;
 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
 
 void nwipe_log( nwipe_log_t level, const char* format, ... )
 {
-/**
- *  Writes a message to the program log file.
- *
- */
+    /**
+     *  Writes a message to the program log file.
+     *
+     */
 
+    char** result;
+    char* malloc_result;
+    char message_buffer[MAX_LOG_LINE_CHARS * sizeof( char )];
+    int chars_written;
 
-	/* A time buffer. */
-	time_t t;
+    int message_buffer_length;
+    int r; /* result buffer */
 
-	/* A pointer to the system time struct. */
-	struct tm* p;
+    /* A time buffer. */
+    time_t t;
 
-	/* Get the current time. */
-	t = time( NULL );
-	p = gmtime( &t );
+    /* A pointer to the system time struct. */
+    struct tm* p;
+    r = pthread_mutex_lock( &mutex1 );
+    if( r != 0 )
+    {
+        fprintf( stderr, "nwipe_log: pthread_mutex_lock failed. Code %i \n", r );
+        return;
+    }
 
-	pthread_mutex_lock( &mutex1 );
+    /* Get the current time. */
+    t = time( NULL );
+    p = localtime( &t );
 
-	/* Increase the current log element pointer - we will write here */
-	if (log_current_element == log_elements_allocated) {
-		log_elements_allocated++;
-		log_lines = (char **) realloc (log_lines, (log_elements_allocated) * sizeof(char *));
-		log_lines[log_current_element] = malloc(MAX_LOG_LINE_CHARS * sizeof(char));
-	}
+    /* Position of writing to current log string */
+    int line_current_pos = 0;
 
-	/* Position of writing to current log string */
-	int line_current_pos = 0;
-	
-	/* Print the date. The rc script uses the same format. */
-	line_current_pos = snprintf( log_lines[log_current_element], 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 );
+    /* 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 );
 
-	switch( level )
-	{
+    /*
+     * Has the end of the buffer been reached ?, snprintf returns the number of characters that would have been
+     * written if MAX_LOG_LINE_CHARS had not been reached, it does not return the actual characters written in
+     * all circumstances, hence why we need to check whether it's greater than MAX_LOG_LINE_CHARS and if so set
+     * it to MAX_LOG_LINE_CHARS, preventing a buffer overrun further down this function.
+     */
 
-		case NWIPE_LOG_NONE:
-			/* Do nothing. */
-			break;
+    /* check if there was a complete failure to write this part of the message, in which case return */
+    if( chars_written < 0 )
+    {
+        fprintf( stderr, "nwipe_log: snprintf error when writing log line to memory.\n" );
+        r = pthread_mutex_unlock( &mutex1 );
+        if( r != 0 )
+        {
+            fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+            return;
+        }
+    }
+    else
+    {
+        if( ( line_current_pos + chars_written ) > MAX_LOG_LINE_CHARS )
+        {
+            fprintf( stderr,
+                     "nwipe_log: Warning! The log line has been truncated as it exceeded %i characters\n",
+                     MAX_LOG_LINE_CHARS );
+            line_current_pos = MAX_LOG_LINE_CHARS;
+        }
+        else
+        {
+            line_current_pos += chars_written;
+        }
+    }
 
-		case NWIPE_LOG_DEBUG:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "debug: " );
-			break;
+    if( line_current_pos < MAX_LOG_LINE_CHARS )
+    {
+        switch( level )
+        {
 
-		case NWIPE_LOG_INFO:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "info: " );
-			break;
+            case NWIPE_LOG_NONE:
+                /* Do nothing. */
+                break;
 
-		case NWIPE_LOG_NOTICE:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "notice: " );
-			break;
+            case NWIPE_LOG_DEBUG:
+                chars_written =
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "debug: " );
+                break;
 
-		case NWIPE_LOG_WARNING:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "warning: " );
-			break;
+            case NWIPE_LOG_INFO:
+                chars_written =
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "info: " );
+                break;
 
-		case NWIPE_LOG_ERROR:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "error: " );
-			break;
+            case NWIPE_LOG_NOTICE:
+                chars_written =
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "notice: " );
+                break;
 
-		case NWIPE_LOG_FATAL:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "fatal: " );
-			break;
+            case NWIPE_LOG_WARNING:
+                chars_written =
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "warning: " );
+                break;
 
-		case NWIPE_LOG_SANITY:
-			/* TODO: Request that the user report the log. */
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "sanity: " );
-			break;
+            case NWIPE_LOG_ERROR:
+                chars_written =
+                    snprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "error: " );
+                break;
 
-		default:
-			line_current_pos += snprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, "level %i: ", level );
+            case NWIPE_LOG_FATAL:
+                chars_written =
+                    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: " );
+                break;
 
-	/* The variable argument pointer. */
-	va_list ap;
+            default:
+                chars_written = snprintf(
+                    message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos, "level %i: ", level );
+        }
 
-	/* Fetch the argument list. */
-	va_start( ap, format );
+        /*
+         * Has the end of the buffer been reached ?
+         */
+        if( chars_written < 0 )
+        {
+            fprintf( stderr, "nwipe_log: snprintf error when writing log line to memory.\n" );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+                return;
+            }
+        }
+        else
+        {
+            if( ( line_current_pos + chars_written ) > MAX_LOG_LINE_CHARS )
+            {
+                fprintf( stderr,
+                         "nwipe_log: Warning! The log line has been truncated as it exceeded %i characters\n",
+                         MAX_LOG_LINE_CHARS );
+                line_current_pos = MAX_LOG_LINE_CHARS;
+            }
+            else
+            {
+                line_current_pos += chars_written;
+            }
+        }
+    }
 
-	/* Print the event. */
-	line_current_pos += vsnprintf( log_lines[log_current_element] + line_current_pos, MAX_LOG_LINE_CHARS, format, ap );
+    /* The variable argument pointer. */
+    va_list ap;
 
-/*
-	if( level >= NWIPE_LOG_WARNING )
-	{
-		vfprintf( stderr, format, ap );
-	}
-*/
+    /* Fetch the argument list. */
+    va_start( ap, format );
 
-	/* Release the argument list. */
-	va_end( ap );
+    /* Print the event. */
+    if( line_current_pos < MAX_LOG_LINE_CHARS )
+    {
+        chars_written =
+            vsnprintf( message_buffer + line_current_pos, MAX_LOG_LINE_CHARS - line_current_pos - 1, format, ap );
 
-/*
-	if( level >= NWIPE_LOG_WARNING )
-	{
-		fprintf( stderr, "\n" );
-	}
-*/
+        if( chars_written < 0 )
+        {
+            fprintf( stderr, "nwipe_log: snprintf error when writing log line to memory.\n" );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+                va_end( ap );
+                return;
+            }
+        }
+        else
+        {
+            if( ( line_current_pos + chars_written ) > MAX_LOG_LINE_CHARS )
+            {
+                fprintf( stderr,
+                         "nwipe_log: Warning! The log line has been truncated as it exceeded %i characters\n",
+                         MAX_LOG_LINE_CHARS );
+                line_current_pos = MAX_LOG_LINE_CHARS;
+            }
+            else
+            {
+                line_current_pos += chars_written;
+            }
+        }
+    }
 
-	/* A result buffer. */
-	int r;
+    fflush( stdout );
+    /* Increase the current log element pointer - we will write here, deallocation is done in cleanup() in nwipe.c */
+    if( log_current_element == log_elements_allocated )
+    {
+        log_elements_allocated++;
+        result = realloc( log_lines, ( log_elements_allocated ) * sizeof( char* ) );
+        if( result == NULL )
+        {
+            fprintf( stderr, "nwipe_log: realloc failed when adding a log line.\n" );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+                va_end( ap );
+                return;
+            }
+        }
+        log_lines = result;
 
-	/* The log file pointer. */
-	FILE* fp;
+        /* Allocate memory for storing a single log message, deallocation is done in cleanup() in nwipe.c */
+        message_buffer_length = strlen( message_buffer ) * sizeof( char );
+        malloc_result = malloc( ( message_buffer_length + 1 ) * sizeof( char ) );
+        if( malloc_result == NULL )
+        {
+            fprintf( stderr, "nwipe_log: malloc failed when adding a log line.\n" );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+                va_end( ap );
+                return;
+            }
+        }
+        log_lines[log_current_element] = malloc_result;
+    }
 
-	/* The log file descriptor. */
-	int fd;
+    strcpy( log_lines[log_current_element], message_buffer );
 
+    /*
+        if( level >= NWIPE_LOG_WARNING )
+        {
+            vfprintf( stderr, format, ap );
+        }
+    */
 
-	if (nwipe_options.logfile[0] == '\0')
-	{
-		if (nwipe_options.nogui)
-		{
-			printf( "%s\n", log_lines[log_current_element] );
-		}
-		else
-		{
-			log_current_element++;
-		}
-	} else
-	{
-		/* Open the log file for appending. */
-		fp = fopen( nwipe_options.logfile, "a" );
+    /* Release the argument list. */
+    va_end( ap );
 
-		if( fp == NULL )
-		{
-			fprintf( stderr, "nwipe_log: Unable to open '%s' for logging.\n", nwipe_options.logfile );
-			return;
-		}
-		
-		/* Get the file descriptor of the log file. */
-		fd = fileno( fp );
+    /*
+        if( level >= NWIPE_LOG_WARNING )
+        {
+            fprintf( stderr, "\n" );
+        }
+    */
 
-		/* Block and lock. */
-		r = flock( fd, LOCK_EX );
+    /* The log file pointer. */
+    FILE* fp;
 
-		if( r != 0 )
-		{
-			perror( "nwipe_log: flock:" );
-			fprintf( stderr, "nwipe_log: Unable to lock '%s' for logging.\n", nwipe_options.logfile );
-			return;
-		}
+    /* The log file descriptor. */
+    int fd;
 
-		fprintf( fp, "%s\n", log_lines[log_current_element] );
+    if( nwipe_options.logfile[0] == '\0' )
+    {
+        if( nwipe_options.nogui )
+        {
+            printf( "%s\n", log_lines[log_current_element] );
+            log_elements_displayed++;
+        }
+    }
+    else
+    {
+        /* Open the log file for appending. */
+        fp = fopen( nwipe_options.logfile, "a" );
 
-		/* Unlock the file. */
-		r = flock( fd, LOCK_UN );
+        if( fp == NULL )
+        {
+            fprintf( stderr, "nwipe_log: Unable to open '%s' for logging.\n", nwipe_options.logfile );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+                return;
+            }
+        }
 
-		if( r != 0 )
-		{
-			perror( "nwipe_log: flock:" );
-			fprintf( stderr, "Error: Unable to unlock '%s' after logging.\n", nwipe_options.logfile );
-		}
+        /* Get the file descriptor of the log file. */
+        fd = fileno( fp );
 
-		/* Close the stream. */
-		r = fclose( fp );
+        /* Block and lock. */
+        r = flock( fd, LOCK_EX );
 
-		if( r != 0 )
-		{
-			perror( "nwipe_log: fclose:" );
-			fprintf( stderr, "Error: Unable to close '%s' after logging.\n", nwipe_options.logfile );
-		}
-	}
-	
-	pthread_mutex_unlock( &mutex1 );
-	
+        if( r != 0 )
+        {
+            perror( "nwipe_log: flock:" );
+            fprintf( stderr, "nwipe_log: Unable to lock '%s' for logging.\n", nwipe_options.logfile );
+            r = pthread_mutex_unlock( &mutex1 );
+            if( r != 0 )
+            {
+                fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+
+                /* Unlock the file. */
+                r = flock( fd, LOCK_UN );
+                fclose( fp );
+                return;
+            }
+        }
+
+        fprintf( fp, "%s\n", log_lines[log_current_element] );
+
+        /* Unlock the file. */
+        r = flock( fd, LOCK_UN );
+
+        if( r != 0 )
+        {
+            perror( "nwipe_log: flock:" );
+            fprintf( stderr, "Error: Unable to unlock '%s' after logging.\n", nwipe_options.logfile );
+        }
+
+        /* Close the stream. */
+        r = fclose( fp );
+
+        if( r != 0 )
+        {
+            perror( "nwipe_log: fclose:" );
+            fprintf( stderr, "Error: Unable to close '%s' after logging.\n", nwipe_options.logfile );
+        }
+    }
+
+    log_current_element++;
+
+    r = pthread_mutex_unlock( &mutex1 );
+    if( r != 0 )
+    {
+        fprintf( stderr, "nwipe_log: pthread_mutex_unlock failed. Code %i \n", r );
+    }
+    return;
 
 } /* nwipe_log */
 
-
 void nwipe_perror( int nwipe_errno, const char* f, const char* s )
 {
-/**
- * Wrapper for perror().
- *
- * We may wish to tweak or squelch this later. 
- *
- */
+    /**
+     * Wrapper for perror().
+     *
+     * We may wish to tweak or squelch this later.
+     *
+     */
 
-	nwipe_log( NWIPE_LOG_ERROR, "%s: %s: %s", f, s, strerror( nwipe_errno ) );
+    nwipe_log( NWIPE_LOG_ERROR, "%s: %s: %s", f, s, strerror( nwipe_errno ) );
 
 } /* nwipe_perror */
 
-/* eof */
+int nwipe_log_sysinfo()
+{
+    FILE* fp;
+    char path[256];
+    int len;
+    int r;  // A result buffer.
+
+    /*
+     * Remove or add keywords to be searched, depending on what information is to
+     * be logged, making sure the last entry in the array is a NULL string. To remove
+     * an entry simply comment out the keyword with //
+     */
+    char dmidecode_keywords[][24] = {
+        "bios-version",
+        "bios-release-date",
+        "system-manufacturer",
+        "system-product-name",
+        "system-version",
+        "system-serial-number",
+        "system-uuid",
+        "baseboard-manufacturer",
+        "baseboard-product-name",
+        "baseboard-version",
+        "baseboard-serial-number",
+        "baseboard-asset-tag",
+        "chassis-manufacturer",
+        "chassis-type",
+        "chassis-version",
+        "chassis-serial-number",
+        "chassis-asset-tag",
+        "processor-family",
+        "processor-manufacturer",
+        "processor-version",
+        "processor-frequency",
+        ""  // terminates the keyword array. DO NOT REMOVE
+    };
+
+    char dmidecode_command[] = "dmidecode -s %s";
+
+    char cmd[sizeof( dmidecode_keywords ) + sizeof( dmidecode_command )];
+
+    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 )
+    {
+        sprintf( cmd, dmidecode_command, &dmidecode_keywords[keywords_idx][0] );
+        fp = popen( cmd, "r" );
+        if( fp == NULL )
+        {
+            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' )
+            {
+                path[len - 1] = 0;
+            }
+            nwipe_log( NWIPE_LOG_INFO, "%s = %s", &dmidecode_keywords[keywords_idx][0], path );
+        }
+        /* close */
+        r = pclose( fp );
+        if( r > 0 )
+        {
+            nwipe_log( NWIPE_LOG_INFO,
+                       "nwipe_log_sysinfo(): dmidecode failed, \"%s\" exit status = %u",
+                       cmd,
+                       WEXITSTATUS( r ) );
+            return 1;
+        }
+        keywords_idx++;
+    }
+    return 0;
+}

src/logging.h

@@ -14,34 +14,29 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #ifndef LOGGING_H_
 #define LOGGING_H_
 
-typedef enum nwipe_log_t_
-{
-	NWIPE_LOG_NONE = 0,
-	NWIPE_LOG_DEBUG,     /* TODO:  Very verbose logging.             */
-	NWIPE_LOG_INFO,      /* TODO:  Verbose logging.                  */
-	NWIPE_LOG_NOTICE,    /* Most logging happens at this level.      */
-	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.                      */
+/* Maximum size of a log message */
+#define MAX_LOG_LINE_CHARS 512
+
+typedef enum nwipe_log_t_ {
+    NWIPE_LOG_NONE = 0,
+    NWIPE_LOG_DEBUG,  // TODO:  Very verbose logging.
+    NWIPE_LOG_INFO,  // TODO:  Verbose logging.
+    NWIPE_LOG_NOTICE,  // Most logging happens at this level.
+    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_t;
 
 void nwipe_log( nwipe_log_t level, const char* format, ... );
 void nwipe_perror( int nwipe_errno, const char* f, const char* s );
-
-/* Global array to hold log values to print when logging to STDOUT */
-//extern char **log_lines;
-//extern int log_current_element;    
-//extern int log_elements_allocated;
+int nwipe_log_sysinfo();
 
 #endif /* LOGGING_H_ */
-
-/* eof */

src/method.h

@@ -2,7 +2,7 @@
  *  methods.c: Method implementations for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,43 +16,43 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #ifndef METHOD_H_
 #define METHOD_H_
 
 /* The argument list for nwipe methods. */
 #define NWIPE_METHOD_SIGNATURE nwipe_context_t* c
 
-typedef enum nwipe_verify_t_
-{
-	NWIPE_VERIFY_NONE = 0,  /* Do not read anything back from the device. */
-	NWIPE_VERIFY_LAST,      /* Check the last pass.                       */
-	NWIPE_VERIFY_ALL,       /* Check all passes.                          */
+typedef enum nwipe_verify_t_ {
+    NWIPE_VERIFY_NONE = 0,  // Do not read anything back from the device.
+    NWIPE_VERIFY_LAST,  // Check the last pass.
+    NWIPE_VERIFY_ALL,  // Check all passes.
 } nwipe_verify_t;
 
 /* The typedef of the function that will do the wipe. */
-typedef int(*nwipe_method_t)( void *ptr );
+typedef int ( *nwipe_method_t )( void* ptr );
 
-typedef struct /* nwipe_pattern_t */
+typedef struct
 {
-	int   length;  /* Length of the pattern in bytes, -1 means random.  */
-	char* s;       /* The actual bytes of the pattern.                  */
+    int length;  // Length of the pattern in bytes, -1 means random.
+    char* s;  // The actual bytes of the pattern.
 } nwipe_pattern_t;
 
 const char* nwipe_method_label( void* method );
 int nwipe_runmethod( NWIPE_METHOD_SIGNATURE, nwipe_pattern_t* patterns );
 
-void *nwipe_dod522022m( void *ptr );
-void *nwipe_dodshort( void *ptr );
-void *nwipe_gutmann( void *ptr );
-void *nwipe_ops2( void *ptr );
-void *nwipe_random( void *ptr );
-void *nwipe_zero( void *ptr );
+void* nwipe_dod522022m( void* ptr );
+void* nwipe_dodshort( void* ptr );
+void* nwipe_gutmann( void* ptr );
+void* nwipe_ops2( void* ptr );
+void* nwipe_is5enh( void* ptr );
+void* nwipe_random( void* ptr );
+void* nwipe_zero( void* ptr );
+void* nwipe_verify( void* ptr );
+
+void calculate_round_size( nwipe_context_t* );
 
 #endif /* METHOD_H_ */
-
-/* eof */

src/nwipe.h

@@ -1,8 +1,8 @@
-/*
+/*.
  *  nwipe.h: The header file of the nwipe program.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,13 +16,16 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
 #ifndef NWIPE_H_
 #define NWIPE_H_
 
+/* Function prototypes */
+int cleanup();
+
 #ifndef _LARGEFILE64_SOURCE
 #define _LARGEFILE64_SOURCE
 #endif
@@ -31,6 +34,15 @@
 #define _FILE_OFFSET_BITS 64
 #endif
 
+/* workaround for Fedora */
+#ifndef off64_t
+#ifndef off_t
+#define off64_t int64_t
+#else
+#define off64_t off_t
+#endif
+#endif
+
 /* Busybox headers. */
 #ifdef BB_VER
 #include "busybox.h"
@@ -60,18 +72,22 @@
 extern int errno;
 
 /* Global array to hold log values to print when logging to STDOUT */
-extern char **log_lines;
-extern int log_current_element;
-extern int log_elements_allocated;
-extern pthread_mutex_t mutex1;
+/* char **log_lines;
+int log_current_element = 0;
+int log_elements_allocated = 0;
+int log_elements_displayed = 0;
+pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; */
 
-/* Ncurses headers. Assume panel.h is in same place.*/
+/* Ncurses headers. */
 #ifdef NCURSES_IN_SUBDIR
-    #include <ncurses/ncurses.h>
-    #include <ncurses/panel.h>
+#include <ncurses/ncurses.h>
 #else
-    #include <ncurses.h>
-    #include <panel.h>
+#include <ncurses.h>
+#endif
+#ifdef PANEL_IN_SUBDIR
+#include <ncurses/panel.h>
+#else
+#include <panel.h>
 #endif
 
 /* Kernel device headers. */
@@ -79,24 +95,22 @@ extern pthread_mutex_t mutex1;
 
 /* These types are usually defined in <asm/types.h> for __KERNEL__ code. */
 typedef unsigned long long u64;
-typedef unsigned long      u32;
-typedef unsigned short     u16;
-typedef unsigned char      u8;
+typedef unsigned long u32;
+typedef unsigned short u16;
+typedef unsigned char u8;
 
 /* This is required for ioctl BLKGETSIZE64, but it conflicts with <wait.h>. */
 /* #include <linux/fs.h> */
 
 /* Define ioctls that cannot be included. */
-#define BLKSSZGET    _IO(0x12,104)
-#define BLKBSZGET    _IOR(0x12,112,size_t)
-#define BLKBSZSET    _IOW(0x12,113,size_t)
-#define BLKGETSIZE64 _IOR(0x12,114,sizeof(u64))
+#define BLKSSZGET _IO( 0x12, 104 )
+#define BLKBSZGET _IOR( 0x12, 112, size_t )
+#define BLKBSZSET _IOW( 0x12, 113, size_t )
+#define BLKGETSIZE64 _IOR( 0x12, 114, sizeof( u64 ) )
 
 /* This is required for ioctl FDFLUSH. */
 #include <linux/fd.h>
 
-void *signal_hand(void *);
+void* signal_hand( void* );
 
 #endif /* NWIPE_H_ */
-
-/* eof */

src/options.c

@@ -1,10 +1,10 @@
 /*
- *  options.c:  Command line processing routines for nwipe. 
+ *  options.c:  Command line processing routines for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
- *  
+ *
  *  This program is free software; you can redistribute it and/or modify it under
  *  the terms of the GNU General Public License as published by the Free Software
  *  Foundation, version 2.
@@ -16,11 +16,10 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #include "nwipe.h"
 #include "context.h"
 #include "method.h"
@@ -34,370 +33,448 @@ nwipe_options_t nwipe_options;
 
 int nwipe_options_parse( int argc, char** argv )
 {
-	extern char* optarg;  /* The working getopt option argument. */
-	extern int   optind;  /* The working getopt index into argv. */
-	extern int   optopt;  /* The last unhandled getopt option.   */
-	extern int   opterr;  /* The last getopt error number.       */
+    extern char* optarg;  // The working getopt option argument.
+    extern int optind;  // The working getopt index into argv.
+    extern int optopt;  // The last unhandled getopt option.
+    extern int opterr;  // The last getopt error number.
 
-	extern nwipe_prng_t nwipe_twister;
-	extern nwipe_prng_t nwipe_isaac;
-
-	/* The maximum banner size, including the null. */
-	const int nwipe_banner_size = 81;
-
-	/* The getopt() result holder. */
-	int nwipe_opt;
-
-	/* Array index variable. */
-	int i;
-
-	/* The list of acceptable short options. */
-	char nwipe_options_short [] = "Vhl:hm:p:r:";
-
-	/* 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 },
-
-		/* A GNU standard option. Corresponds to the 'h' short option. */
-		{ "help", no_argument, 0, 'h' },
-
-		/* The wipe method. Corresponds to the 'm' short option. */
-		{ "method", required_argument, 0, 'm' },
-
-		/* Log file. Corresponds to the 'l' short option. */
-		{ "logfile", required_argument, 0, 'l' },
-
-		/* The Pseudo Random Number Generator. */
-		{ "prng", required_argument, 0, 'p' },
-
-		/* The number of times to run the method. */
-		{ "rounds", required_argument, 0, 'r' },
-
-		/* Whether to blank the disk after wiping. */
-		{ "noblank", no_argument, 0, 0 },
-
-		/* Whether to exit after wiping or wait for a keypress. */
-		{ "nowait", no_argument, 0, 0 },
-
-		/* Whether to exit after wiping or wait for a keypress. */
-		{ "nogui", no_argument, 0, 0 },
-
-		/* A flag to indicate whether the devices whould be opened in sync mode. */
-		{ "sync", no_argument, 0, 0 },
-
-		/* Verify that wipe patterns are being written to the device. */
-		{ "verify", required_argument, 0, 0 },
-
-		/* Display program version. */
-		{ "version", no_argument, 0, 'V' },
-
-		/* Requisite padding for getopt(). */
-		{ 0, 0, 0, 0 }
-	};
-
-	/* Note that COLS isn't available until ncurses is initialized. */
-	nwipe_options.banner = malloc( nwipe_banner_size );
-
-	/* Set the default product banner. */
-	/* TODO: Add version constant.     */
-	strncpy ( nwipe_options.banner, program_name, nwipe_banner_size);
-	strncat ( nwipe_options.banner, " ", nwipe_banner_size - strlen (nwipe_options.banner) - 1);
-	strncat ( nwipe_options.banner, version_string, nwipe_banner_size - strlen (nwipe_options.banner) - 1);
-	strncat ( nwipe_options.banner, " (based on DBAN's dwipe - Darik's Wipe)", nwipe_banner_size - strlen (nwipe_options.banner) - 1);
-
-	/* Set default options. */
-	nwipe_options.autonuke = 0;
-	nwipe_options.method   = &nwipe_dodshort;
-	nwipe_options.prng     = &nwipe_twister;
-	nwipe_options.rounds   = 1;
-	nwipe_options.noblank  = 0;
-	nwipe_options.nowait   = 0;
-	nwipe_options.nogui    = 0;
-	nwipe_options.sync     = 0;
-	nwipe_options.verify   = NWIPE_VERIFY_LAST;
-	memset( nwipe_options.logfile, '\0', sizeof(nwipe_options.logfile) );
-
-
-	/* Parse command line options. */
-	while( 1 )
-	{
-		/* Get the next command line option with (3)getopt. */
-		nwipe_opt = getopt_long( argc, argv, nwipe_options_short, nwipe_options_long, &i );
-
-		/* Break when we have processed all of the given options. */
-		if( nwipe_opt < 0 ) { break; }
-
-		switch( nwipe_opt )
-		{
-			case 0: /* Long options without short counterparts. */
-
-				if( strcmp( nwipe_options_long[i].name, "autonuke" ) == 0 )
-				{
-					nwipe_options.autonuke = 1;
-					break;
-				}
-
-				if( strcmp( nwipe_options_long[i].name, "noblank" ) == 0 )
-				{
-					nwipe_options.noblank = 1;
-					break;
-				}
-
-				if( strcmp( nwipe_options_long[i].name, "nowait" ) == 0 )
-				{
-					nwipe_options.nowait = 1;
-					break;
-				}
-
-				if( strcmp( nwipe_options_long[i].name, "nogui" ) == 0 )
-				{
-					nwipe_options.nogui = 1;
-					nwipe_options.nowait = 1;
-					break;
-				}
-
-				if( strcmp( nwipe_options_long[i].name, "sync" ) == 0 )
-				{
-					nwipe_options.sync = 1;
-					break;
-				}
-
-				if( strcmp( nwipe_options_long[i].name, "verify" ) == 0 )
-				{
-
-					if( strcmp( optarg, "0" ) == 0 || strcmp( optarg, "off" ) == 0 )
-					{
-						nwipe_options.verify = NWIPE_VERIFY_NONE;
-						break;
-					}
-
-					if( strcmp( optarg, "1" ) == 0 || strcmp( optarg, "last" ) == 0 )
-					{
-						nwipe_options.verify = NWIPE_VERIFY_LAST;
-						break;
-					}
-
-					if( strcmp( optarg, "2" ) == 0 || strcmp( optarg, "all" ) == 0 )
-					{
-						nwipe_options.verify = NWIPE_VERIFY_ALL;
-						break;
-					}
-
-					/* Else we do not know this verification level. */
-					fprintf( stderr, "Error: Unknown verification level '%s'.\n", optarg );
-					exit( EINVAL );
-
-				}
-
-
-			case 'm':  /* Method option. */
-
-				if( strcmp( optarg, "dod522022m" ) == 0 || strcmp( optarg, "dod" ) == 0 )
-				{
-					nwipe_options.method = &nwipe_dod522022m;
-					break;
-				}
-
-				if( strcmp( optarg, "dodshort" ) == 0 || strcmp( optarg, "dod3pass" ) == 0 )
-				{
-					nwipe_options.method = &nwipe_dodshort;
-					break;
-				}
-
-				if( strcmp( optarg, "gutmann" ) == 0 )
-				{
-					nwipe_options.method = &nwipe_gutmann;
-					break;
-				}
-
-				if( strcmp( optarg, "ops2" ) == 0 )
-				{
-					nwipe_options.method = &nwipe_ops2;
-					break;
-				}
-
-				if(  strcmp( optarg, "random" ) == 0
-				  || strcmp( optarg, "prng"   ) == 0
-				  || strcmp( optarg, "stream" ) == 0
-				  )
-				{
-					nwipe_options.method= &nwipe_random;
-					break;
-				}
-
-				if( strcmp( optarg, "zero" ) == 0 || strcmp( optarg, "quick" ) == 0 )
-				{
-					nwipe_options.method = &nwipe_zero;
-					break;
-				}
-
-				/* Else we do not know this wipe method. */
-				fprintf( stderr, "Error: Unknown wipe method '%s'.\n", optarg );
-				exit( EINVAL );
-
-
-			case 'l':  /* Log file option. */
-				
-				nwipe_options.logfile[strlen(optarg)] = '\0';
-				strncpy(nwipe_options.logfile, optarg, sizeof(nwipe_options.logfile));
-				break;
-
-			case 'h':  /* Display help. */
-
-				display_help();
-				break;
-
-			case 'p':  /* PRNG option. */
-
-				if(  strcmp( optarg, "mersenne" ) == 0
-				  || strcmp( optarg, "twister"  ) == 0
-				  )
-				{
-					nwipe_options.prng = &nwipe_twister;
-					break;
-				}
-
-				if( strcmp( optarg, "isaac" ) == 0 )
-				{
-					nwipe_options.prng = &nwipe_isaac;
-					break;
-				}
-
-				/* Else we do not know this PRNG. */
-				fprintf( stderr, "Error: Unknown prng '%s'.\n", optarg );
-				exit( EINVAL );
-
-
-			case 'r':  /* Rounds option. */
-
-				if( sscanf( optarg, " %i", &nwipe_options.rounds ) != 1 \
-				    || nwipe_options.rounds < 1
-				  )
-				{
-					fprintf( stderr, "Error: The rounds argument must be a postive integer.\n" );
-					exit( EINVAL );
-				}
-
-				break;
-
-			case 'V':  /* Rounds option. */
-
-				printf ( "%s version %s\n", program_name, version_string );
-				exit( EXIT_SUCCESS );
-
-			default:
-
-				/* Bogus command line argument. */
-				display_help();
-				exit( EINVAL );
-			
-		} /* method */
-
-	} /* command line options */
-
-	/* Return the number of options that were processed. */
-	return optind;
-
-} /* nwipe_options_parse */
+    extern nwipe_prng_t nwipe_twister;
+    extern nwipe_prng_t nwipe_isaac;
+
+    /* The getopt() result holder. */
+    int nwipe_opt;
 
+    /* Excluded drive indexes */
+    int idx_drive_chr;
+    int idx_optarg;
+    int idx_drive;
+
+    /* Array index variable. */
+    int i;
+
+    /* The list of acceptable short options. */
+    char nwipe_options_short[] = "Vhl: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},
+
+        /* A GNU standard option. Corresponds to the 'h' short option. */
+        {"help", no_argument, 0, 'h'},
+
+        /* The wipe method. Corresponds to the 'm' short option. */
+        {"method", required_argument, 0, 'm'},
+
+        /* Log file. Corresponds to the 'l' short option. */
+        {"logfile", required_argument, 0, 'l'},
+
+        /* Exclude devices, comma separated list */
+        {"exclude", required_argument, 0, 'e'},
+
+        /* The Pseudo Random Number Generator. */
+        {"prng", required_argument, 0, 'p'},
+
+        /* The number of times to run the method. */
+        {"rounds", required_argument, 0, 'r'},
+
+        /* Whether to blank the disk after wiping. */
+        {"noblank", no_argument, 0, 0},
+
+        /* Whether to exit after wiping or wait for a keypress. */
+        {"nowait", no_argument, 0, 0},
+
+        /* Whether to allow signals to interrupt a wipe. */
+        {"nosignals", no_argument, 0, 0},
+
+        /* Whether to exit after wiping or wait for a keypress. */
+        {"nogui", no_argument, 0, 0},
+
+        /* A flag to indicate whether the devices whould be opened in sync mode. */
+        {"sync", required_argument, 0, 0},
+
+        /* Verify that wipe patterns are being written to the device. */
+        {"verify", required_argument, 0, 0},
+
+        /* Display program version. */
+        {"version", no_argument, 0, 'V'},
+
+        /* Requisite padding for getopt(). */
+        {0, 0, 0, 0}};
+
+    /* Set default options. */
+    nwipe_options.autonuke = 0;
+    nwipe_options.method = &nwipe_dodshort;
+    nwipe_options.prng = &nwipe_twister;
+    nwipe_options.rounds = 1;
+    nwipe_options.noblank = 0;
+    nwipe_options.nowait = 0;
+    nwipe_options.nosignals = 0;
+    nwipe_options.nogui = 0;
+    nwipe_options.sync = 100000;
+    nwipe_options.verify = NWIPE_VERIFY_LAST;
+    memset( nwipe_options.logfile, '\0', sizeof( nwipe_options.logfile ) );
+
+    /* Initialise each of the strings in the excluded drives array */
+    for( i = 0; i < MAX_NUMBER_EXCLUDED_DRIVES; i++ )
+    {
+        nwipe_options.exclude[i][0] = 0;
+    }
+
+    /* Parse command line options. */
+    while( 1 )
+    {
+        /* Get the next command line option with (3)getopt. */
+        nwipe_opt = getopt_long( argc, argv, nwipe_options_short, nwipe_options_long, &i );
+
+        /* Break when we have processed all of the given options. */
+        if( nwipe_opt < 0 )
+        {
+            break;
+        }
+
+        switch( nwipe_opt )
+        {
+            case 0: /* Long options without short counterparts. */
+
+                if( strcmp( nwipe_options_long[i].name, "autonuke" ) == 0 )
+                {
+                    nwipe_options.autonuke = 1;
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "noblank" ) == 0 )
+                {
+                    nwipe_options.noblank = 1;
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "nowait" ) == 0 )
+                {
+                    nwipe_options.nowait = 1;
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "nosignals" ) == 0 )
+                {
+                    nwipe_options.nosignals = 1;
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "nogui" ) == 0 )
+                {
+                    nwipe_options.nogui = 1;
+                    nwipe_options.nowait = 1;
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "sync" ) == 0 )
+                {
+                    if( sscanf( optarg, " %i", &nwipe_options.sync ) != 1 || nwipe_options.sync < 1 )
+                    {
+                        fprintf( stderr, "Error: The sync argument must be a positive integer.\n" );
+                        exit( EINVAL );
+                    }
+                    break;
+                }
+
+                if( strcmp( nwipe_options_long[i].name, "verify" ) == 0 )
+                {
+
+                    if( strcmp( optarg, "0" ) == 0 || strcmp( optarg, "off" ) == 0 )
+                    {
+                        nwipe_options.verify = NWIPE_VERIFY_NONE;
+                        break;
+                    }
+
+                    if( strcmp( optarg, "1" ) == 0 || strcmp( optarg, "last" ) == 0 )
+                    {
+                        nwipe_options.verify = NWIPE_VERIFY_LAST;
+                        break;
+                    }
+
+                    if( strcmp( optarg, "2" ) == 0 || strcmp( optarg, "all" ) == 0 )
+                    {
+                        nwipe_options.verify = NWIPE_VERIFY_ALL;
+                        break;
+                    }
+
+                    /* Else we do not know this verification level. */
+                    fprintf( stderr, "Error: Unknown verification level '%s'.\n", optarg );
+                    exit( EINVAL );
+                }
+
+                /* getopt_long should raise on invalid option, so we should never get here. */
+                exit( EINVAL );
+
+            case 'm': /* Method option. */
+
+                if( strcmp( optarg, "dod522022m" ) == 0 || strcmp( optarg, "dod" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_dod522022m;
+                    break;
+                }
+
+                if( strcmp( optarg, "dodshort" ) == 0 || strcmp( optarg, "dod3pass" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_dodshort;
+                    break;
+                }
+
+                if( strcmp( optarg, "gutmann" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_gutmann;
+                    break;
+                }
+
+                if( strcmp( optarg, "ops2" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_ops2;
+                    break;
+                }
+
+                if( strcmp( optarg, "random" ) == 0 || strcmp( optarg, "prng" ) == 0
+                    || strcmp( optarg, "stream" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_random;
+                    break;
+                }
+
+                if( strcmp( optarg, "zero" ) == 0 || strcmp( optarg, "quick" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_zero;
+                    break;
+                }
+
+                if( strcmp( optarg, "verify" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_verify;
+                    break;
+                }
+
+                if( strcmp( optarg, "is5enh" ) == 0 )
+                {
+                    nwipe_options.method = &nwipe_is5enh;
+                    break;
+                }
+
+                /* Else we do not know this wipe method. */
+                fprintf( stderr, "Error: Unknown wipe method '%s'.\n", optarg );
+                exit( EINVAL );
+
+            case 'l': /* Log file option. */
+
+                nwipe_options.logfile[strlen( optarg )] = '\0';
+                strncpy( nwipe_options.logfile, optarg, sizeof( nwipe_options.logfile ) );
+                break;
+
+            case 'e': /* exclude drives option */
+
+                idx_drive_chr = 0;
+                idx_optarg = 0;
+                idx_drive = 0;
+
+                /* Create an array of excluded drives from the comma separated string */
+                while( optarg[idx_optarg] != 0 && idx_drive < MAX_NUMBER_EXCLUDED_DRIVES )
+                {
+                    /* drop the leading '=' character if used */
+                    if( optarg[idx_optarg] == '=' && idx_optarg == 0 )
+                    {
+                        idx_optarg++;
+                        continue;
+                    }
+
+                    if( optarg[idx_optarg] == ',' )
+                    {
+                        /* terminate string and move onto next drive */
+                        nwipe_options.exclude[idx_drive++][idx_drive_chr] = 0;
+                        idx_drive_chr = 0;
+                        idx_optarg++;
+                    }
+                    else
+                    {
+                        if( idx_drive_chr < MAX_DRIVE_PATH_LENGTH )
+                        {
+                            nwipe_options.exclude[idx_drive][idx_drive_chr++] = optarg[idx_optarg++];
+                        }
+                        else
+                        {
+                            /* This section deals with file names that exceed MAX_DRIVE_PATH_LENGTH */
+                            nwipe_options.exclude[idx_drive][idx_drive_chr] = 0;
+                            while( optarg[idx_optarg] != 0 && optarg[idx_optarg] != ',' )
+                            {
+                                idx_optarg++;
+                            }
+                        }
+                    }
+                }
+                break;
+
+            case 'h': /* Display help. */
+
+                display_help();
+                break;
+
+            case 'p': /* PRNG option. */
+
+                if( strcmp( optarg, "mersenne" ) == 0 || strcmp( optarg, "twister" ) == 0 )
+                {
+                    nwipe_options.prng = &nwipe_twister;
+                    break;
+                }
+
+                if( strcmp( optarg, "isaac" ) == 0 )
+                {
+                    nwipe_options.prng = &nwipe_isaac;
+                    break;
+                }
+
+                /* Else we do not know this PRNG. */
+                fprintf( stderr, "Error: Unknown prng '%s'.\n", optarg );
+                exit( EINVAL );
+
+            case 'r': /* Rounds option. */
+
+                if( sscanf( optarg, " %i", &nwipe_options.rounds ) != 1 || nwipe_options.rounds < 1 )
+                {
+                    fprintf( stderr, "Error: The rounds argument must be a positive integer.\n" );
+                    exit( EINVAL );
+                }
+
+                break;
+
+            case 'V': /* Version option. */
+
+                printf( "%s version %s\n", program_name, version_string );
+                exit( EXIT_SUCCESS );
+
+            default:
+
+                /* Bogus command line argument. */
+                display_help();
+                exit( EINVAL );
+
+        } /* method */
+
+    } /* command line options */
+
+    /* Return the number of options that were processed. */
+    return optind;
+}
 
 void nwipe_options_log( void )
 {
-/**
- *  Prints a manifest of options to the log.
- *
- */
+    /**
+     *  Prints a manifest of options to the log.
+     */
 
-	nwipe_log( NWIPE_LOG_NOTICE, "Program options are set as follows..." );
+    nwipe_log( NWIPE_LOG_NOTICE, "Program options are set as follows..." );
 
-	if( nwipe_options.autonuke )
-	{
-		nwipe_log( NWIPE_LOG_NOTICE, "  autonuke = %i (on)", nwipe_options.autonuke );
-	}
+    if( nwipe_options.autonuke )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  autonuke = %i (on)", nwipe_options.autonuke );
+    }
+    else
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  autonuke = %i (off)", nwipe_options.autonuke );
+    }
 
-	else
-	{
-		nwipe_log( NWIPE_LOG_NOTICE, "  autonuke = %i (off)", nwipe_options.autonuke );
-	}
+    if( nwipe_options.noblank )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  do not perform a final blank pass" );
+    }
 
-	if( nwipe_options.noblank )
-	{
-		nwipe_log( NWIPE_LOG_NOTICE, "  do not perform a final blank pass" );
-	}
+    if( nwipe_options.nowait )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  do not wait for a key before exiting" );
+    }
 
-	if( nwipe_options.nowait )
-	{
-		nwipe_log( NWIPE_LOG_NOTICE, "  do not wait for a key before exiting" );
-	}
+    if( nwipe_options.nosignals )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  do not allow signals to interrupt a wipe" );
+    }
 
-	if( nwipe_options.nogui )
-	{
-		nwipe_log( NWIPE_LOG_NOTICE, "  do not show GUI interface" );
-	}
+    if( nwipe_options.nogui )
+    {
+        nwipe_log( NWIPE_LOG_NOTICE, "  do not show GUI interface" );
+    }
 
-	nwipe_log( NWIPE_LOG_NOTICE, "  banner   = %s", nwipe_options.banner );
-	nwipe_log( NWIPE_LOG_NOTICE, "  method   = %s", nwipe_method_label( nwipe_options.method ) );
-	nwipe_log( NWIPE_LOG_NOTICE, "  rounds   = %i", nwipe_options.rounds );
-	nwipe_log( NWIPE_LOG_NOTICE, "  sync     = %i", nwipe_options.sync );
+    nwipe_log( NWIPE_LOG_NOTICE, "  banner   = %s", banner );
+    nwipe_log( NWIPE_LOG_NOTICE, "  method   = %s", nwipe_method_label( nwipe_options.method ) );
+    nwipe_log( NWIPE_LOG_NOTICE, "  rounds   = %i", nwipe_options.rounds );
+    nwipe_log( NWIPE_LOG_NOTICE, "  sync     = %i", nwipe_options.sync );
 
-	switch( nwipe_options.verify )
-	{
-		case NWIPE_VERIFY_NONE:
-			nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (off)", nwipe_options.verify );
-			break;
+    switch( nwipe_options.verify )
+    {
+        case NWIPE_VERIFY_NONE:
+            nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (off)", nwipe_options.verify );
+            break;
 
-		case NWIPE_VERIFY_LAST:
-			nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (last pass)", nwipe_options.verify );
-			break;
+        case NWIPE_VERIFY_LAST:
+            nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (last pass)", nwipe_options.verify );
+            break;
 
-		case NWIPE_VERIFY_ALL:
-			nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (all passes)", nwipe_options.verify );
-			break;
+        case NWIPE_VERIFY_ALL:
+            nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i (all passes)", nwipe_options.verify );
+            break;
 
-		default:
-			nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i", nwipe_options.verify );
-			break;
-	}
-
-} /* nwipe_options_log */
-
-/**
- * display_help 
- * displays the help section to STDOUT and exits
- */  
-void 
-display_help()
-{
-  printf("Usage: %s [options] [device1] [device2] ...\n", program_name);
-  printf("Options:\n"                    );
-  puts("  -V, --version           Prints the version number");
-  puts("  -h, --help              Prints this help");
-  puts("      --autonuke          If no devices have been specified on the command line, starts wiping all");
-  puts("                          devices immediately. If devices have been specified, starts wiping only");
-  puts("                          those specified devices immediately.");
-  puts("      --sync              Open devices in sync mode");
-  puts("      --verify=TYPE       Whether to perform verification of erasure (default: last)");
-  puts("                          off   - Do not verify");
-  puts("                          last  - Verify after the last pass");
-  puts("                          all   - Verify every pass");  
-  puts("  -m, --method=METHOD     The wiping method (default: dodshort). See man page for more details.");
-  puts("                          dod522022m / dod       - 7 pass DOD 5220.22-M method");
-  puts("                          dodshort / dod3pass    - 3 pass DOD method");
-  puts("                          gutmann                - Peter Gutmann's Algorithm");
-  puts("                          ops2                   - RCMP TSSIT OPS-II");
-  puts("                          random / prng / stream - PRNG Stream");
-  puts("                          zero / quick           - Overwrite with zeros");
-  puts("  -l, --logfile=FILE      Filename to log to. Default is STDOUT");
-  puts("  -p, --prng=METHOD       PRNG option (mersenne|twister|isaac)" );
-  puts("  -r, --rounds=NUM        Number of times to wipe the device using the selected method (default: 1)" );
-  puts("      --noblank           Do not blank disk after wipe (default is to complete a final blank pass)" );
-  puts("      --nowait            Do not wait for a key before exiting (default is to wait)" );
-  puts("      --nogui             Do not show the GUI interface. Automatically invokes the nowait option" );
-  puts("                          Must be used with --autonuke option. Send SIGUSR1 to log current stats");
-  puts("");
-  exit( EXIT_SUCCESS );
+        default:
+            nwipe_log( NWIPE_LOG_NOTICE, "  verify   = %i", nwipe_options.verify );
+            break;
+    }
 }
 
-/* eof */
+void display_help()
+{
+    /**
+     * displays the help section to STDOUT and exits.
+     */
+
+    printf( "Usage: %s [options] [device1] [device2] ...\n", program_name );
+    printf( "Options:\n" );
+    /* 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( "  -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( "                          0 - fdatasync after the disk is completely written" );
+    puts( "                          1 - fdatasync after every write" );
+    puts( "                          1000000 - fdatasync after 1000000 writes ect." );
+    puts( "      --verify=TYPE       Whether to perform verification of erasure" );
+    puts( "                          (default: last)" );
+    puts( "                          off   - Do not verify" );
+    puts( "                          last  - Verify after the last pass" );
+    puts( "                          all   - Verify every pass\n" );
+    puts( "  -m, --method=METHOD     The wiping method. See man page for more details." );
+    puts( "                          (default: dodshort)" );
+    puts( "                          dod522022m / dod       - 7 pass DOD 5220.22-M method" );
+    puts( "                          dodshort / dod3pass    - 3 pass DOD method" );
+    puts( "                          gutmann                - Peter Gutmann's Algorithm" );
+    puts( "                          ops2                   - RCMP TSSIT OPS-II" );
+    puts( "                          random / prng / stream - PRNG Stream" );
+    puts( "                          zero / quick           - Overwrite with zeros" );
+    puts( "                          verify                 - Verifies disk is zero filled\n" );
+    puts( "  -l, --logfile=FILE      Filename to log to. Default is STDOUT\n" );
+    puts( "  -p, --prng=METHOD       PRNG option (mersenne|twister|isaac)\n" );
+    puts( "  -r, --rounds=NUM        Number of times to wipe the device using the selected" );
+    puts( "                          method (default: 1)\n" );
+    puts( "      --noblank           Do not blank disk after wipe" );
+    puts( "                          (default is to complete a final blank pass)\n" );
+    puts( "      --nowait            Do not wait for a key before exiting" );
+    puts( "                          (default is to wait)\n" );
+    puts( "      --nosignals         Do not allow signals to interrupt a wipe" );
+    puts( "                          (default is to allow)\n" );
+    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( "  -e, --exclude=DEVICES   Up to ten comma separated devices to be excluded" );
+    puts( "                          --exclude=/dev/sdc" );
+    puts( "                          --exclude=/dev/sdc,/dev/sdd" );
+    puts( "                          --exclude=/dev/sdc,/dev/sdd,/dev/mapper/cryptswap1\n" );
+    puts( "" );
+    exit( EXIT_SUCCESS );
+}

src/options.h

@@ -2,7 +2,7 @@
  *  options.h: Command line processing routines for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,26 +16,27 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
-
 #ifndef OPTIONS_H_
 #define OPTIONS_H_
 
 /* Program knobs. */
-#define NWIPE_KNOB_ENTROPY                "/dev/urandom"
-#define NWIPE_KNOB_IDENTITY_SIZE          512
-#define NWIPE_KNOB_LABEL_SIZE             128
-#define NWIPE_KNOB_LOADAVG                "/proc/loadavg"
-#define NWIPE_KNOB_LOG_BUFFERSIZE         1024                /* Maximum length of a log event. */
-#define NWIPE_KNOB_PARTITIONS             "/proc/partitions"
-#define NWIPE_KNOB_PARTITIONS_PREFIX      "/dev/"
-#define NWIPE_KNOB_PRNG_STATE_LENGTH      512                 /* 128 words */
-#define NWIPE_KNOB_SCSI                   "/proc/scsi/scsi"
-#define NWIPE_KNOB_SLEEP                  1
-#define NWIPE_KNOB_STAT                   "/proc/stat"
+#define NWIPE_KNOB_ENTROPY "/dev/urandom"
+#define NWIPE_KNOB_IDENTITY_SIZE 512
+#define NWIPE_KNOB_LABEL_SIZE 128
+#define NWIPE_KNOB_LOADAVG "/proc/loadavg"
+#define NWIPE_KNOB_LOG_BUFFERSIZE 1024  // Maximum length of a log event.
+#define NWIPE_KNOB_PARTITIONS "/proc/partitions"
+#define NWIPE_KNOB_PARTITIONS_PREFIX "/dev/"
+#define NWIPE_KNOB_PRNG_STATE_LENGTH 512  // 128 words
+#define NWIPE_KNOB_SCSI "/proc/scsi/scsi"
+#define NWIPE_KNOB_SLEEP 1
+#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.
 
 /* Function prototypes for loading options from the environment and command line. */
 int nwipe_options_parse( int argc, char** argv );
@@ -44,24 +45,23 @@ void nwipe_options_log( void );
 /* Function to display help text */
 void display_help();
 
-typedef struct /* nwipe_options_t */
+typedef struct
 {
-	int            autonuke;  /* Do not prompt the user for confirmation when set.          */
-	int            noblank;   /* Do not perform a final blanking pass.                      */
-        int            nowait;    /* Do not wait for a final key before exiting.                */
-        int            nogui ;    /* Do not show the GUI.                                       */
-	char*          banner;    /* The product banner shown on the top line of the screen.    */
-//	nwipe_method_t method;    /* A function pointer to the wipe method that will be used.   */
-	void*          method;    /* A function pointer to the wipe method that will be used.   */
-	char           logfile[FILENAME_MAX];   /* The filename to log the output to            */
-	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 writes should be sync'd.        */
-	nwipe_verify_t verify;    /* A flag to indicate whether writes should be verified.      */
+    int autonuke;  // Do not prompt the user for confirmation when set.
+    int noblank;  // Do not perform a final blanking pass.
+    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.
+    char* banner;  // The product banner shown on the top line of the screen.
+    void* method;  // A function pointer to the wipe method that will be used.
+    char logfile[FILENAME_MAX];  // The filename to log the output to.
+    char exclude[MAX_NUMBER_EXCLUDED_DRIVES][MAX_DRIVE_PATH_LENGTH];  // Drives excluded from the search.
+    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.
+    nwipe_verify_t verify;  // A flag to indicate whether writes should be verified.
 } nwipe_options_t;
 
 extern nwipe_options_t nwipe_options;
 
 #endif /* OPTIONS_H_ */
-
-/* eof */

src/pass.h

@@ -2,7 +2,7 @@
  *  pass.h: Routines that read and write patterns to block devices.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  Modifications to original dwipe Copyright Andy Beverley <andy@andybev.com>
  *
  *  This program is free software; you can redistribute it and/or modify it under
@@ -16,20 +16,18 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
 #ifndef PASS_H_
 #define PASS_H_
 
-int nwipe_random_pass  ( nwipe_context_t* c );
+int nwipe_random_pass( nwipe_context_t* c );
 int nwipe_random_verify( nwipe_context_t* c );
-int nwipe_static_pass  ( nwipe_context_t* c, nwipe_pattern_t* pattern );
+int nwipe_static_pass( nwipe_context_t* c, nwipe_pattern_t* pattern );
 int nwipe_static_verify( nwipe_context_t* c, nwipe_pattern_t* pattern );
 
 void test_functionn( int count, nwipe_context_t** c );
 
 #endif /* PASS_H_ */
-
-/* eof */

src/prng.c

@@ -2,7 +2,7 @@
  *  prng.c: Pseudo Random Number Generator abstractions for nwipe.
  *
  *  Copyright Darik Horn <dajhorn-dban@vanadac.com>.
- *  
+ *
  *  This program is free software; you can redistribute it and/or modify it under
  *  the terms of the GNU General Public License as published by the Free Software
  *  Foundation, version 2.
@@ -14,120 +14,139 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-
 #include "nwipe.h"
 #include "prng.h"
 #include "logging.h"
 
-#include "mt19937ar-cok.h"
-#include "isaac_rand.h"
+#include "mt19937ar-cok/mt19937ar-cok.h"
+#include "isaac_rand/isaac_rand.h"
 
-nwipe_prng_t nwipe_twister =
+nwipe_prng_t nwipe_twister = {"Mersenne Twister (mt19937ar-cok)", nwipe_twister_init, nwipe_twister_read};
+
+nwipe_prng_t nwipe_isaac = {"ISAAC (rand.c 20010626)", nwipe_isaac_init, nwipe_isaac_read};
+
+int nwipe_u32tobuffer( u8* buffer, u32 rand, int len )
 {
-	"Mersenne Twister (mt19937ar-cok)",
-	nwipe_twister_init,
-	nwipe_twister_read
-};
-
-nwipe_prng_t nwipe_isaac =
-{
-	"ISAAC (rand.c 20010626)",
-	nwipe_isaac_init,
-	nwipe_isaac_read
-};
-
+    /*
+     * Print given number of bytes from unsigned integer number to a byte stream buffer starting with low-endian.
+     */
+    int i;
+    u8 c;  // single char
+    if( len > sizeof( u32 ) )
+    {
+        nwipe_log( NWIPE_LOG_FATAL, "Tried to print longer number than the value passed." );
+        len = sizeof( u32 );
+    }
 
+    for( i = 0; i < len; i++ )
+    {
+        c = rand & 0xFFUL;
+        rand = rand >> 8;
+        buffer[i] = c;
+    }
+    return 0;
+}
 
 int nwipe_twister_init( NWIPE_PRNG_INIT_SIGNATURE )
 {
-	if( *state == NULL )
-	{
-		/* This is the first time that we have been called. */
-		*state = malloc( sizeof( twister_state_t ) );
-	}
-	twister_init( (twister_state_t*)*state, (u32*)( seed->s ), seed->length / sizeof( u32 ) );
-	return 0;
+    if( *state == NULL )
+    {
+        /* This is the first time that we have been called. */
+        *state = malloc( sizeof( twister_state_t ) );
+    }
+    twister_init( (twister_state_t*) *state, (u32*) ( seed->s ), seed->length / sizeof( u32 ) );
+    return 0;
 }
 
 int nwipe_twister_read( NWIPE_PRNG_READ_SIGNATURE )
 {
-	u32 ii;
-	u32 words = count / sizeof( u32 );
-	u32 remain = count % sizeof( u32 );
+    u32 i = 0;
+    u32 ii;
+    u32 words = count / SIZE_OF_TWISTER;  // the values of twister_genrand_int32 is strictly 4 bytes
+    u32 remain = count % SIZE_OF_TWISTER;  // the values of twister_genrand_int32 is strictly 4 bytes
 
-	/* Twister returns 4-bytes per call, so cast the buffer into words. */
-	for( ii = 0; ii < words; ++ii )
-	{
-		((u32*)buffer)[ii] = twister_genrand_int32( (twister_state_t*)*state );
-	}
+    /* Twister returns 4-bytes per call, so progress by 4 bytes. */
+    for( ii = 0; ii < words; ++ii )
+    {
+        nwipe_u32tobuffer( (u8*) ( buffer + i ), twister_genrand_int32( (twister_state_t*) *state ), SIZE_OF_TWISTER );
+        i = i + SIZE_OF_TWISTER;
+    }
 
-	/* Fill the buffer tail if the count is not evenly divided by the size of u32. */
-	for( ii = 1; ii <= remain; ++ii )
-	{
-		/* Notice how three bytes are discarded by doing this. */
-		((u8*)buffer)[count-ii] = twister_genrand_int32( (twister_state_t*)*state );
-	}
-	 
-	return 0;
+    /* If there is some remainder copy only relevant number of bytes to not
+     * overflow the buffer. */
+    if( remain > 0 )
+    {
+        nwipe_u32tobuffer( (u8*) ( buffer + i ), twister_genrand_int32( (twister_state_t*) *state ), remain );
+    }
+
+    return 0;
 }
 
-
-
 int nwipe_isaac_init( NWIPE_PRNG_INIT_SIGNATURE )
 {
-	int count;
-	randctx* isaac_state = *state;
+    int count;
+    randctx* isaac_state = *state;
 
-	if( *state == NULL )
-	{
-		/* This is the first time that we have been called. */
-		*state = malloc( sizeof( randctx ) );
-		isaac_state = *state;
+    if( *state == NULL )
+    {
+        /* This is the first time that we have been called. */
+        *state = malloc( sizeof( randctx ) );
+        isaac_state = *state;
 
-		/* Check the memory allocation. */
-		if( isaac_state == 0 )
-		{
-				nwipe_perror( errno, __FUNCTION__, "malloc" );
-				nwipe_log( NWIPE_LOG_FATAL, "Unable to allocate memory for the isaac state." );
-				return -1;
-		}
-	}
+        /* Check the memory allocation. */
+        if( isaac_state == 0 )
+        {
+            nwipe_perror( errno, __FUNCTION__, "malloc" );
+            nwipe_log( NWIPE_LOG_FATAL, "Unable to allocate memory for the isaac state." );
+            return -1;
+        }
+    }
 
+    /* Take the minimum of the isaac seed size and available entropy. */
+    if( sizeof( isaac_state->randrsl ) < seed->length )
+    {
+        count = sizeof( isaac_state->randrsl );
+    }
+    else
+    {
+        memset( isaac_state->randrsl, 0, sizeof( isaac_state->randrsl ) );
+        count = seed->length;
+    }
 
-	/* Take the minimum of the isaac seed size and available entropy. */
-	if( sizeof( isaac_state->randrsl ) < seed->length ) 
-	{
-		count = sizeof( isaac_state->randrsl );	
-	}
-	else
-	{
-		memset( isaac_state->randrsl, 0, sizeof( isaac_state->randrsl ) );
-		count = seed->length;
-	}
+    if( count == 0 )
+    {
+        /* Start ISACC without a seed. */
+        randinit( isaac_state, 0 );
+    }
+    else
+    {
+        /* Seed the ISAAC state with entropy. */
+        memcpy( isaac_state->randrsl, seed->s, count );
 
-	if( count == 0 )
-	{
-		/* Start ISACC without a seed. */
-		randinit( isaac_state, 0 );
-	}
-	else
-	{
-		/* Seed the ISAAC state with entropy. */
-		memcpy( isaac_state->randrsl, seed->s, count );
+        /* The second parameter indicates that randrsl is non-empty. */
+        randinit( isaac_state, 1 );
+    }
 
-		/* The second parameter indicates that randrsl is non-empty. */
-		randinit( isaac_state, 1 );
-	}
-
-	return 0;
+    return 0;
 }
 
 int nwipe_isaac_read( NWIPE_PRNG_READ_SIGNATURE )
 {
-	return 0;
-}
+    /* The purpose of this function is unclear, as it does not do anything except immediately return !
+     * Because the variables in the macro NWIPE_PRNG_READ_SIGNATURE were then unused this throws
+     * up a handful of compiler warnings, related to variables being unused. To stop the compiler warnings
+     * I've simply put in a (void) var so that compiler sees the variable are supposed to be unused.
+     *
+     * As this code works, I thought it best not to remove this function, just in case it serves
+     * some purpose or is there for future use.
+     */
 
-/* eof */
+    (void) state;
+    (void) buffer;
+    (void) count;
+
+    return 0;
+}

src/prng.h

@@ -14,7 +14,7 @@
  *
  *  You should have received a copy of the GNU General Public License along with
  *  this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
@@ -22,25 +22,25 @@
 #define PRNG_H_
 
 /* A chunk of random data. */
-typedef struct /* nwipe_entropy_t */
+typedef struct
 {
-	size_t  length;  /* Length of the entropy string in bytes.  */
-	u8*     s;       /* The actual bytes of the entropy string. */
+    size_t length;  // Length of the entropy string in bytes.
+    u8* s;  // The actual bytes of the entropy string.
 } nwipe_entropy_t;
 
-#define NWIPE_PRNG_INIT_SIGNATURE void** state, nwipe_entropy_t* seed
-#define NWIPE_PRNG_READ_SIGNATURE void** state, void* buffer, size_t count
+#define NWIPE_PRNG_INIT_SIGNATURE void **state, nwipe_entropy_t *seed
+#define NWIPE_PRNG_READ_SIGNATURE void **state, void *buffer, size_t count
 
 /* Function pointers for PRNG actions. */
-typedef int(*nwipe_prng_init_t)( NWIPE_PRNG_INIT_SIGNATURE );
-typedef int(*nwipe_prng_read_t)( NWIPE_PRNG_READ_SIGNATURE );
+typedef int ( *nwipe_prng_init_t )( NWIPE_PRNG_INIT_SIGNATURE );
+typedef int ( *nwipe_prng_read_t )( NWIPE_PRNG_READ_SIGNATURE );
 
 /* The generic PRNG definition. */
-typedef struct /* nwipe_prng_t */
+typedef struct
 {
-	const char*       label;  /* The name of the pseudo random number generator. */
-	nwipe_prng_init_t init;   /* Inialize the prng state with the seed.          */
-	nwipe_prng_read_t read;   /* Read data from the prng.                        */
+    const char* label;  // The name of the pseudo random number generator.
+    nwipe_prng_init_t init;  // Inialize the prng state with the seed.
+    nwipe_prng_read_t read;  // Read data from the prng.
 } nwipe_prng_t;
 
 /* Mersenne Twister prototypes. */
@@ -51,6 +51,7 @@ int nwipe_twister_read( NWIPE_PRNG_READ_SIGNATURE );
 int nwipe_isaac_init( NWIPE_PRNG_INIT_SIGNATURE );
 int nwipe_isaac_read( NWIPE_PRNG_READ_SIGNATURE );
 
-#endif /* PRNG_H_ */
+/* Size of the twister is not derived from the architecture, but it is strictly 4 bytes */
+#define SIZE_OF_TWISTER 4
 
-/* eof */
+#endif /* PRNG_H_ */

src/version.c

@@ -1,16 +1,17 @@
 /**
  * version_string and program_name are used by siege
- * and configure; author_name and email_address are 
- * used by configure to dynamically assign those values 
+ * and configure; author_name and email_address are
+ * used by configure to dynamically assign those values
  * to documentation files.
  */
-const char *version_string = "0.15";
-const char *program_name   = "nwipe";
-const char *author_name    = "Andy Beverley";
-const char *email_address  = "andy@andybev.com";
-const char *years          = "2012";
-const char *copyright      = "Copyright Darik Horn <dajhorn-dban@vanadac.com>\n\
+const char* version_string = "0.28";
+const char* program_name = "nwipe";
+const char* author_name = "Martijn van Brummelen";
+const char* email_address = "git@brumit.nl";
+const char* years = "2020";
+const char* copyright = "Copyright Darik Horn <dajhorn-dban@vanadac.com>\n\
 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";

src/version.h

@@ -1,10 +1,11 @@
 #ifndef __VERSION_H
 #define __VERSION_H
 
-extern char *version_string;
-extern char *program_name; 
-extern char *author_name;
-extern char *email_address; 
-extern char *copyright;
+extern char* version_string;
+extern char* program_name;
+extern char* author_name;
+extern char* email_address;
+extern char* copyright;
+extern char* banner;
 
-#endif/*__VERSION_H*/
+#endif /*__VERSION_H*/