X-Git-Url: https://git.wh0rd.org/?p=home.git;a=blobdiff_plain;f=ddnuke.c;h=1712d16b6f0e0c4ab49a3cf59aef9d9d0f12d1b2;hp=8e0abdbaaa5c371e1aab3a15eb0e41a738351310;hb=HEAD;hpb=64f2ae36a6d0138fa8dd651bdc9555bd86fc1d0b

diff --git a/ddnuke.c b/ddnuke.c
index 8e0abdb..02c6c21 100644
--- a/ddnuke.c
+++ b/ddnuke.c
@@ -11,10 +11,13 @@
 #define _LARGEFILE64_SOURCE
 #define _GNU_SOURCE
 
+#include <ctype.h>
+#include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <locale.h>
+#include <spawn.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,14 +27,10 @@
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 #include <linux/fs.h>
 
-#define errp(msg, args...) \
-	do { \
-		printf("%s: " msg ": %m\n", program_invocation_short_name, ## args); \
-		exit(1); \
-	} while (0)
-
 static unsigned long long mbps(struct timespec *stime, struct timespec *etime, off_t len)
 {
 	uint64_t dtime;
@@ -46,7 +45,7 @@ static off_t get_blk_size(int fd)
 {
 	uint64_t size;
 	if (ioctl(fd, BLKGETSIZE64, &size))
-		errp("ioctl(BLKGETSIZE64) failed");
+		err(EX_DATAERR, "ioctl(BLKGETSIZE64) failed");
 	return size;
 }
 
@@ -55,7 +54,7 @@ static off_t get_size(int fd)
 	struct stat st;
 
 	if (fstat(fd, &st))
-		errp("could not stat %i", fd);
+		err(EX_DATAERR, "could not stat %i", fd);
 
 	if (S_ISREG(st.st_mode))
 		return st.st_size;
@@ -63,18 +62,18 @@ static off_t get_size(int fd)
 		return get_blk_size(fd);
 
 	errno = EINVAL;
-	errp("unknown type of file");
+	err(EX_DATAERR, "unknown type of file");
 }
 
-static void nuke(int fd, off_t offset, off_t max_size, unsigned char pattern)
+static void nuke(int fd, off_t block_size, off_t offset, off_t max_size, off_t flush_count, unsigned char pattern)
 {
-	static char mem[1024 * 1024];
+	char mem[block_size];
 	memset(mem, pattern, sizeof(mem));
 	if (pattern)
 		printf("Writing 0x%X to the output\n", pattern);
 
 	if (lseek(fd, offset, SEEK_SET) != offset)
-		errp("lseek(%"PRIu64"u) failed", offset);
+		err(EX_DATAERR, "lseek(%"PRIu64"u) failed", offset);
 
 	unsigned long long speed = 0;
 	struct timespec stime, etime, itime;
@@ -88,17 +87,19 @@ static void nuke(int fd, off_t offset, off_t max_size, unsigned char pattern)
 		/* This will round up to sizeof(mem) ... */
 		ret = write(fd, mem, sizeof(mem));
 		pos += ret;
-		if (ret != sizeof(mem)) {
+		if (ret != block_size) {
 			if (pos != max_size)
 				printf("\nread() returned %zi (wanted %zu)\n%'llu MB/s over entire run\n",
 					ret, sizeof(mem), mbps(&itime, &etime, pos));
 			return;
 		}
 
-		printf("%'llu bytes %u%% (%'llu MB/s)%20s\r", (unsigned long long)pos,
-			(unsigned)((pos * 100) / max_size), speed, "");
+		unsigned long long eta = speed ? (max_size - pos) / (speed * 1000 * 1000) : 0;
+		printf("\r%'llu bytes %u%% (%'llu MB/s) (ETA ~%llum%llus)\e[K",
+			(unsigned long long)pos, (unsigned)((pos * 100) / max_size), speed,
+			eta / 60, eta % 60);
 
-		if ((++fsync_pos % 32) == 0) {
+		if ((++fsync_pos % flush_count) == 0) {
 			speed = mbps(&stime, &etime, pos - last_pos);
 			last_pos = pos;
 			fflush(stdout);
@@ -116,6 +117,10 @@ static void usage(int status)
 		"Usage: ddnuke [options] <dev>\n"
 		"\n"
 		"Options:\n"
+		" -q            Run quietly\n"
+		" -y            Assume yes to all prompts\n"
+		" -b <size>     How many bytes to write at once. (default: 1Mib)\n"
+		" -f <count>    How many blocks to write before flush (stdout & disk). (default: 32)\n"
 		" -o <offset>   Position to start writing\n"
 		" -r            Write three times: 0x00, then 0xaa, then 0x55\n"
 	);
@@ -124,23 +129,43 @@ static void usage(int status)
 
 int main(int argc, char *argv[])
 {
+	off_t block_size = 1024 * 1024;
+	off_t flush_count = 32;
 	off_t offset = 0;
 	const char *file;
+	bool quiet = false;
 	bool random = false;
+	bool yes = false;
 	int o;
 
 	setlocale(LC_NUMERIC, "en_US");
 
-	while ((o = getopt(argc, argv, "ho:r")) != -1) {
+	while ((o = getopt(argc, argv, "hb:f:o:qry")) != -1) {
 		switch (o) {
+		case 'b':
+			block_size = atoll(optarg);
+			break;
+		case 'f':
+			flush_count = atoll(optarg);
+			break;
 		case 'o':
 			offset = atoll(optarg);
 			break;
+		case 'q':
+			quiet = true;
+			break;
 		case 'r':
 			random = true;
 			break;
-		case 'h': usage(EX_OK);
-		default:  usage(EX_USAGE);
+		case 'y':
+			yes = true;
+			break;
+		case 'h':
+			usage(EX_OK);
+			break;
+		default:
+			usage(EX_USAGE);
+			break;
 		}
 	}
 	if (argc != optind + 1)
@@ -149,14 +174,32 @@ int main(int argc, char *argv[])
 
 	int fd = open(file, O_WRONLY|O_CLOEXEC);
 	if (fd == -1)
-		errp("open(%s) failed", file);
+		err(EX_NOINPUT, "open(%s) failed", file);
+
+	if (!quiet) {
+		pid_t pid;
+		const char *argv[] = {"fdisk", "-l", file, NULL};
+		if (posix_spawnp(&pid, argv[0], NULL, NULL, (char *const *)argv, NULL))
+			err(EX_OSERR, "spawn(%s %s) failed", argv[0], file);
+		waitpid(pid, NULL, 0);
+		printf("\n");
+	}
+
+	if (!yes) {
+		printf("Do you want to wipe '%s'? (y/N) ", file);
+		fflush(stdout);
+		char c = 0;
+		if (fread(&c, 1, 1, stdin)) {/* don't care */}
+		if (tolower(c) != 'y')
+			errx(EX_UNAVAILABLE, "User decided not to wipe");
+	}
 
 	off_t max_size = get_size(fd);
 
-	nuke(fd, offset, max_size, 0x00);
+	nuke(fd, block_size, offset, max_size, flush_count, 0x00);
 	if (random) {
-		nuke(fd, offset, max_size, 0xaa);
-		nuke(fd, offset, max_size, 0x55);
+		nuke(fd, block_size, offset, max_size, flush_count, 0xaa);
+		nuke(fd, block_size, offset, max_size, flush_count, 0x55);
 	}
 
 	return EX_OK;