mirror of
https://github.com/Lennart1978/drinfo.git
synced 2026-10-01 05:02:31 +07:00
275 lines
8.4 KiB
C
275 lines
8.4 KiB
C
#define _GNU_SOURCE
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/statvfs.h>
|
|
#include <mntent.h>
|
|
#include <unistd.h>
|
|
#include <regex.h>
|
|
#include <sys/ioctl.h>
|
|
#include <termios.h>
|
|
#include <time.h>
|
|
#include <sys/stat.h>
|
|
|
|
char colorbuf[32]; // For bar colors
|
|
|
|
// Function to get terminal width
|
|
int get_terminal_width()
|
|
{
|
|
struct winsize w;
|
|
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0)
|
|
{
|
|
return w.ws_col;
|
|
}
|
|
return 80; // Fallback-Value
|
|
}
|
|
|
|
// Function to format bytes into human-readable sizes
|
|
void format_bytes(unsigned long long bytes, char *buffer, size_t buffer_size)
|
|
{
|
|
const char *units[] = {"B", "KB", "MB", "GB", "TB"};
|
|
int unit_index = 0;
|
|
double size = bytes;
|
|
|
|
while (size >= 1024.0 && unit_index < 4)
|
|
{
|
|
size /= 1024.0;
|
|
unit_index++;
|
|
}
|
|
|
|
if (unit_index == 0)
|
|
{
|
|
snprintf(buffer, buffer_size, "%.0f %s", size, units[unit_index]);
|
|
}
|
|
else
|
|
{
|
|
snprintf(buffer, buffer_size, "%.2f %s", size, units[unit_index]);
|
|
}
|
|
}
|
|
|
|
// Function to calculate usage percentage
|
|
double calculate_usage_percent(unsigned long long total, unsigned long long available)
|
|
{
|
|
if (total == 0)
|
|
return 0.0;
|
|
unsigned long long used = total - available;
|
|
return ((double)used / total) * 100.0;
|
|
}
|
|
|
|
int is_physical_device(const char *fsname)
|
|
{
|
|
// Check for /dev/sd*, /dev/nvme*, /dev/hd*
|
|
return (strncmp(fsname, "/dev/sd", 7) == 0 ||
|
|
strncmp(fsname, "/dev/nvme", 9) == 0 ||
|
|
strncmp(fsname, "/dev/hd", 7) == 0);
|
|
}
|
|
|
|
// Helper for true-color gradient (red-yellow-green)
|
|
void get_bar_color(int idx, int max, char *buffer, size_t size)
|
|
{
|
|
// New gradient: 0% = green (0,255,0), 50% = yellow (255,255,0), 100% = red (255,0,0)
|
|
float ratio = (float)idx / (float)(max - 1);
|
|
int r, g, b;
|
|
if (ratio < 0.5f)
|
|
{
|
|
// Green to Yellow
|
|
r = (int)(ratio * 2 * 255);
|
|
g = 255;
|
|
b = 0;
|
|
}
|
|
else
|
|
{
|
|
// Yellow to Red
|
|
r = 255;
|
|
g = (int)((1.0f - (ratio - 0.5f) * 2) * 255);
|
|
b = 0;
|
|
}
|
|
snprintf(buffer, size, "\033[38;2;%d;%d;%dm", r, g, b);
|
|
}
|
|
|
|
// Helper: visible length of a string without ANSI sequences
|
|
int visible_length(const char *s)
|
|
{
|
|
int len = 0;
|
|
int in_escape = 0;
|
|
for (; *s; ++s)
|
|
{
|
|
if (*s == '\033')
|
|
in_escape = 1;
|
|
else if (in_escape && *s == 'm')
|
|
in_escape = 0;
|
|
else if (!in_escape)
|
|
len++;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
// Adjusted: calculate max visible line length for block
|
|
int max_visible_line_length(const char *lines[], int n)
|
|
{
|
|
int max = 0;
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
int len = visible_length(lines[i]);
|
|
if (len > max)
|
|
max = len;
|
|
}
|
|
return max;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
printf("\n");
|
|
// Open the mount table
|
|
FILE *mtab = setmntent("/proc/mounts", "r");
|
|
if (mtab == NULL)
|
|
{
|
|
perror("Error opening mount table");
|
|
return 1;
|
|
}
|
|
|
|
struct mntent *entry;
|
|
int drive_count = 0;
|
|
|
|
// Loop through all mount points
|
|
while ((entry = getmntent(mtab)) != NULL)
|
|
{
|
|
// Skip special file systems
|
|
if (strcmp(entry->mnt_type, "proc") == 0 ||
|
|
strcmp(entry->mnt_type, "sysfs") == 0 ||
|
|
strcmp(entry->mnt_type, "devpts") == 0 ||
|
|
strcmp(entry->mnt_type, "tmpfs") == 0 ||
|
|
strcmp(entry->mnt_type, "devtmpfs") == 0 ||
|
|
strcmp(entry->mnt_type, "securityfs") == 0 ||
|
|
strcmp(entry->mnt_type, "cgroup") == 0 ||
|
|
strcmp(entry->mnt_type, "cgroup2") == 0 ||
|
|
strcmp(entry->mnt_type, "pstore") == 0 ||
|
|
strcmp(entry->mnt_type, "efivarfs") == 0 ||
|
|
strcmp(entry->mnt_type, "autofs") == 0 ||
|
|
strcmp(entry->mnt_type, "debugfs") == 0 ||
|
|
strcmp(entry->mnt_type, "tracefs") == 0 ||
|
|
strcmp(entry->mnt_type, "configfs") == 0 ||
|
|
strcmp(entry->mnt_type, "fusectl") == 0 ||
|
|
strcmp(entry->mnt_type, "fuse.gvfsd-fuse") == 0 ||
|
|
strcmp(entry->mnt_type, "binfmt_misc") == 0)
|
|
{
|
|
continue;
|
|
}
|
|
// Only show physical drives
|
|
if (!is_physical_device(entry->mnt_fsname))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Get file system information
|
|
struct statvfs fs_info;
|
|
if (statvfs(entry->mnt_dir, &fs_info) != 0)
|
|
{
|
|
continue; // Skip if no information available
|
|
}
|
|
|
|
// Calculate sizes
|
|
unsigned long long total_bytes = (unsigned long long)fs_info.f_blocks * fs_info.f_frsize;
|
|
unsigned long long available_bytes = (unsigned long long)fs_info.f_bavail * fs_info.f_frsize;
|
|
unsigned long long used_bytes = total_bytes - available_bytes;
|
|
|
|
// Format sizes for output
|
|
char total_str[64], used_str[64], available_str[64];
|
|
format_bytes(total_bytes, total_str, sizeof(total_str));
|
|
format_bytes(used_bytes, used_str, sizeof(used_str));
|
|
format_bytes(available_bytes, available_str, sizeof(available_str));
|
|
|
|
// Target width: 80% of terminal width or max. 120 characters
|
|
int terminal_width = get_terminal_width();
|
|
int box_width = terminal_width * 4 / 5;
|
|
if (box_width > 120)
|
|
box_width = 120;
|
|
if (box_width < 40)
|
|
box_width = 40;
|
|
int content_width = box_width - 4; // for frame
|
|
int bar_length = content_width - 2; // for [ and ]
|
|
if (bar_length < 10)
|
|
bar_length = 10;
|
|
|
|
// Calculate usage
|
|
double usage_percent = calculate_usage_percent(total_bytes, available_bytes);
|
|
int filled_length = (int)((usage_percent / 100.0) * bar_length);
|
|
char percent_text[16];
|
|
snprintf(percent_text, sizeof(percent_text), "%.1f%%", usage_percent);
|
|
int text_length = strlen(percent_text);
|
|
int text_start = filled_length > text_length ? (filled_length - text_length) / 2 : 0;
|
|
|
|
// Dynamically allocate progress bar
|
|
size_t bar_bufsize = bar_length * 64 + 1;
|
|
char *bar = malloc(bar_bufsize);
|
|
if (!bar)
|
|
{
|
|
perror("malloc");
|
|
exit(1);
|
|
}
|
|
bar[0] = '\0';
|
|
for (int i = 0; i < bar_length; i++)
|
|
{
|
|
if (i >= text_start && i < text_start + text_length && i < filled_length)
|
|
{
|
|
get_bar_color(i, bar_length, colorbuf, sizeof(colorbuf));
|
|
int r, g, b;
|
|
sscanf(colorbuf, "\033[38;2;%d;%d;%dm", &r, &g, &b);
|
|
char tmp[128];
|
|
snprintf(tmp, sizeof(tmp), "\033[48;2;%d;%d;%dm\033[38;2;0;0;255m%c\033[0m", r, g, b, percent_text[i - text_start]);
|
|
strncat(bar, tmp, bar_bufsize - strlen(bar) - 1);
|
|
}
|
|
else if (i < filled_length)
|
|
{
|
|
get_bar_color(i, bar_length, colorbuf, sizeof(colorbuf));
|
|
strncat(bar, colorbuf, bar_bufsize - strlen(bar) - 1);
|
|
strncat(bar, "█\033[0m", bar_bufsize - strlen(bar) - 1);
|
|
}
|
|
else
|
|
{
|
|
strncat(bar, "\033[48;2;64;64;64m\033[38;2;160;160;160m░\033[0m", bar_bufsize - strlen(bar) - 1);
|
|
}
|
|
}
|
|
size_t barline_bufsize = bar_bufsize + 16;
|
|
char *barline = malloc(barline_bufsize);
|
|
if (!barline)
|
|
{
|
|
perror("malloc");
|
|
free(bar);
|
|
exit(1);
|
|
}
|
|
snprintf(barline, barline_bufsize, "[%-*s]", bar_length, ""); // Placeholder for padding
|
|
snprintf(barline, barline_bufsize, "[%-*s]", bar_length, ""); // for padding
|
|
|
|
// Content
|
|
printf(" \033[1;33mDrive %d\033[0m\n", drive_count + 1);
|
|
printf(" Mount point: %s\n", entry->mnt_dir);
|
|
printf(" Filesystem: %s\n", entry->mnt_type);
|
|
printf(" Device: %s\n", entry->mnt_fsname);
|
|
printf(" Total size: %s\n", total_str);
|
|
printf(" Used: %s\n", used_str);
|
|
printf(" Available: %s\n", available_str);
|
|
// Progress bar
|
|
int bar_visible_len = visible_length(bar);
|
|
int bar_padding = content_width - bar_visible_len;
|
|
printf(" %s%*s\n", bar, bar_padding, "");
|
|
|
|
free(bar);
|
|
free(barline);
|
|
drive_count++;
|
|
}
|
|
|
|
endmntent(mtab);
|
|
|
|
if (drive_count == 0)
|
|
{
|
|
printf("No drives found.\n");
|
|
}
|
|
else
|
|
{
|
|
printf("A total of %d drives found.\n", drive_count);
|
|
}
|
|
|
|
return 0;
|
|
}
|