ggf.d

import core.sys.windows.windows;
import core.stdc.stdio : printf, puts;
import core.stdc.string : strcmp;

__gshared:
extern (C):

int putchar(int c);

enum PROJECT_VER  = "0.2.2";

enum : ubyte {
	FEATURE_DEFAULT,	// sizes/usage
	FEATURE_POURCENTAGE,	// usage%
	FEATURE_FEATURES,	// features
	FEATURE_MISC	// serial+max path
}

enum
	FILE_SUPPORTS_HARD_LINKS = 0x00400000,
	FILE_SUPPORTS_EXTENDED_ATTRIBUTES = 0x00800000,
	FILE_SUPPORTS_OPEN_BY_FILE_ID = 0x01000000,
	FILE_SUPPORTS_USN_JOURNAL = 0x02000000,
	FILE_DAX_VOLUME = 0x20000000;

void help() {
    puts(
`Get disk(s) information.
  Usage: ggf [OPTIONS] [DRIVE]
         ggf {-h|-v|-?}

By default, view disk usage by size.

OPTIONS
-P	View usage by progress-bar style
-F	View features
-M	View misc. features (serial, MAX_PATH)
-b	Use base10 size formatting
-n	Remove header`
	);
}

void version_() {
	printf(
`ggf v` ~ PROJECT_VER~ `  (` ~ __TIMESTAMP__ ~ `)
MIT License: Copyright (c) 2017-2020 dd86k
Project page: </~https://github.com/dd86k/ggf>
Compiled `~__FILE__~` with `~__VENDOR__~" v%d\n",
		cast(uint)__VERSION__
	);
}

int main(int argc, char** argv) {
	bool base10; /// Use base10 notation
	bool header = true;
	ubyte feature; // FEATURE_DEFAULT
	int drive;

	while (--argc >= 1) {
		const char c = argv[argc][0];
		if (c == '-') {
			char* a = argv[argc];
			while (*++a != '\0') {
				switch (*a) {
				case 'h', '?': help; return 0;
				case 'v': version_; return 0;
				case 'b': base10 = 1; break;
				case 'n': header = 0; break;
				case 'F': feature = FEATURE_FEATURES; break;
				case 'P': feature = FEATURE_POURCENTAGE; break;
				case 'M': feature = FEATURE_MISC; break;
				default:
					printf("ERROR: Unknown parameter: %c\n", *a);
					return 1;
				}
			}
		} else if (c >= 'a' && c <= 'z') {
			drive = c - 32;
		} else if (c >= 'A' && c <= 'Z') {
			drive = c;
		}
	}

	// Empty optical drives in XP shows a windows when an error occurs
	SetErrorMode(SEM_FAILCRITICALERRORS);

	DWORD drives = void;
	uint disk_mask = void; /// bit mask to use against drives
	uint disk_count = void; /// disk disk_count, avoids using big switches

	if (drive) {
		disk_mask = drives = getMask(drive);
		disk_count = drive - 0x41;
	} else {
		disk_mask = 1; disk_count = 0;
		drives = GetLogicalDrives();
		if (drives == 0) {
			puts("ERROR: No drives found.");
			return 2;
		}
	}

	int scr_width = void;	/// screen width for %

	if (feature == FEATURE_POURCENTAGE) {
		CONSOLE_SCREEN_BUFFER_INFO csbi = void;
		HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
		GetConsoleScreenBufferInfo(hOut, &csbi);
		scr_width = csbi.srWindow.Right - csbi.srWindow.Left - 14;
	}

	if (header) {
		switch (feature) {
		case FEATURE_DEFAULT:
			puts("DRIVE  TYPE            USED       FREE      TOTAL  TYPE    NAME");
			break;
		case FEATURE_MISC:
			puts("DRIVE  SERIAL     MAX PATH");
			break;
		case FEATURE_FEATURES:
			puts("DRIVE  FEATURES");
			break;
		case FEATURE_POURCENTAGE:
			puts("DRIVE  USAGE");
			break;
		default:
			puts("Unknown feature selected");
			return 1;
		}
	}

	char [4]cd = ` :\`; // buffer
	char *cdp = cast(char*)cd;

	for (; disk_mask <= drives; disk_mask <<= 1, ++disk_count) {
		const uint n = drives & disk_mask;

		if (n == 0) continue;

		const char c = getDrive(disk_count);
		cd[0] = c;
		printf("%c:     ", c);

		switch (feature) {
		case FEATURE_DEFAULT:
			switch (GetDriveTypeA(cdp)) { // Lazy alert
			case 2: printf("Removable"); break;
			case 3: printf("Fixed    "); break;
			case 4: printf("Network  "); break;
			case 5: printf("Optical  "); break;
			case 6: printf("RAMDISK  "); break;
			default: puts("UNKNOWN  "); continue; // 0+1
			}

			ULARGE_INTEGER dfb = void, dtotal = void, dfree = void;
			if (GetDiskFreeSpaceExA(cdp, &dfb, &dtotal, &dfree)) {
				_printfd(dtotal.QuadPart - dfree.QuadPart, base10);
				_printfd(dfree.QuadPart, base10);
				_printfd(dtotal.QuadPart, base10);
			}

			ubyte [256]vol, fs; // inits to 0, char inits to 0xFF
			if (GetVolumeInformationA(cdp,
				cast(char*)vol, vol.length,
				NULL, NULL, NULL,
				cast(char*)fs, fs.length)) {
				printf("  %-7s %s\n",
					cast(char*)fs, cast(char*)vol);
			} else putchar('\n');
			continue;
		case FEATURE_FEATURES:
			DWORD flags = void;
			if (GetVolumeInformationA(cdp, cast(char*)0, 0, NULL,
				NULL, &flags, NULL, 0) == 0) goto FEATURES_END;
			if (flags & FILE_CASE_SENSITIVE_SEARCH)
				printf("CASE_SENSITIVE_SEARCH ");
			if (flags & FILE_CASE_PRESERVED_NAMES)
				printf("CASE_PRESERVED_NAMES ");
			if (flags & FILE_PERSISTENT_ACLS)
				printf("PERSISTENT_ACLS ");
			if (flags & FILE_READ_ONLY_VOLUME)
				printf("READ_ONLY ");
			if (flags & FILE_NAMED_STREAMS)
				printf("NAMED_STREAMS ");
			if (flags & FILE_SEQUENTIAL_WRITE_ONCE)
				printf("SEQ_WRITE_ONCE ");
			if (flags & FILE_SUPPORTS_EXTENDED_ATTRIBUTES)
				printf("EXTENDED_ATTRIBUTES ");
			if (flags & FILE_SUPPORTS_ENCRYPTION)
				printf("ENCRYPTION ");
			if (flags & FILE_SUPPORTS_HARD_LINKS)
				printf("HARD_LINKS ");
			if (flags & FILE_SUPPORTS_OBJECT_IDS)
				printf("OBJECT_ID ");
			if (flags & FILE_SUPPORTS_OPEN_BY_FILE_ID)
				printf("OPEN_BY_FILE_ID ");
			if (flags & FILE_SUPPORTS_REPARSE_POINTS)
				printf("REPARSE_POINTS ");
			if (flags & FILE_SUPPORTS_SPARSE_FILES)
				printf("SPARSE_FILES ");
			if (flags & FILE_SUPPORTS_TRANSACTIONS)
				printf("TRANSACTIONS ");
			if (flags & FILE_SUPPORTS_USN_JOURNAL)
				printf("USN_JOURNAL ");
			if (flags & FILE_UNICODE_ON_DISK)
				printf("UNICODE ");
			if (flags & FILE_FILE_COMPRESSION) {
				printf(flags & FILE_VOLUME_IS_COMPRESSED ?
					"COMPRESSED " : "COMPRESSION ");
			}
			if (flags & FILE_VOLUME_QUOTAS)
				printf("QUOTAS ");
			if (flags & FILE_DAX_VOLUME) // Added in Windows 10
				printf("DAX ");
FEATURES_END:
			putchar('\n');
			continue;
		case FEATURE_POURCENTAGE:
			ULARGE_INTEGER fb = void, total = void, free = void;
			if (GetDiskFreeSpaceExA(cdp, &fb, &total, &free)) {
				const ulong used = total.QuadPart - free.QuadPart;
				ushort p_ub = cast(ushort) // used
					((used * scr_width) / total.QuadPart);
				ushort p_fb = cast(ushort) // free
					((free.QuadPart * scr_width) /
					total.QuadPart);
				putchar('[');
				while (--p_ub) putchar('=');
				while (--p_fb) putchar(' ');
				printf("] %4.1f%%\n",
					((cast(float)used * 100) / total.QuadPart));
			} else putchar('\n');
			continue;
		case FEATURE_MISC:
			ushort[2] serial = void;
			DWORD maxpath = void;
			if (GetVolumeInformationA(cdp, NULL, 0,
				cast(uint*)serial, &maxpath, NULL, NULL, 0)) {
				printf("%04X-%04X  %8d\n", serial[1], serial[0], maxpath);
			} else putchar('\n');
			continue;
		default:
		} // switch feature
	} // for

	return 0;
}

enum : float { // for _printfd function
	KB = 1024,
	MB = KB * 1024,
	GB = MB * 1024,
	TB = GB * 1024,
	KiB = 1000,
	MiB = KiB * 1000,
	GiB = MiB * 1000,
	TiB = GiB * 1000,
}

// lazy formatter with spacing
private void _printfd(ulong l, bool base10 = false) {
	const float f = l;
	if (base10) {
		if (l >= TiB) {
			printf("%8.2f Ti", f / TiB);
		} else if (l >= GiB) {
			printf("%8.2f Gi", f / GiB);
		} else if (l >= MiB) {
			printf("%8.2f Mi", f / MiB);
		} else if (l >= KiB) {
			printf("%8.2f Ki", f / KiB);
		} else
			printf("%9llu B", l);
	} else {
		if (l >= TB) {
			printf("%9.2f T", f / TB);
		} else if (l >= GB) {
			printf("%9.2f G", f / GB);
		} else if (l >= MB) {
			printf("%9.2f M", f / MB);
		} else if (l >= KB) {
			printf("%9.2f K", f / KB);
		} else
			printf("%9llu B", l);
	}
}

/**
 * Converts a drive number to a drive letter
 * Params: d = driver number (starting at 0)
 * Returns: drive letter
 */
char getDrive(int d) pure {
	return cast(char)(d + 0x41);
}

/**
 * Converts a drive letter to a mask
 * Params: d = Drive letter ('A' to 'Z')
 * Returns: Windows drive mask, e.g. 'C' returns 4
 */
int getMask(int d)  {
	return 1 << (d - 0x41);
}