|
|
|
|
@@ -43,9 +43,9 @@ int show_pad_info(const char* chksum) {
|
|
|
|
|
printf("ChkSum: %s\n", chksum);
|
|
|
|
|
printf("File: %s\n", pad_filename);
|
|
|
|
|
|
|
|
|
|
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double used_gb = (double)used_bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double remaining_gb = (double)(st.st_size - used_bytes) / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double remaining_gb = (double)(st.st_size - used_bytes) / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
|
|
|
|
|
printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size);
|
|
|
|
|
printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes);
|
|
|
|
|
@@ -89,18 +89,18 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
|
|
|
|
|
const char* pads_dir = get_current_pads_dir();
|
|
|
|
|
struct statvfs stat;
|
|
|
|
|
if (statvfs(pads_dir, &stat) == 0) {
|
|
|
|
|
// Use f_bfree (total free blocks) instead of f_bavail (available to non-root)
|
|
|
|
|
// This gives the actual free space on the filesystem, which is more accurate
|
|
|
|
|
// for removable media and user-owned directories
|
|
|
|
|
uint64_t available_bytes = stat.f_bfree * stat.f_frsize;
|
|
|
|
|
double available_gb = (double)available_bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double required_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
// Use f_bavail (available to non-root users) for accurate space reporting
|
|
|
|
|
// This accounts for filesystem reserved space (e.g., 5% on ext4)
|
|
|
|
|
uint64_t available_bytes = stat.f_bavail * stat.f_frsize;
|
|
|
|
|
double available_gb = (double)available_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double required_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
|
|
|
|
|
if (available_bytes < size_bytes) {
|
|
|
|
|
printf("\n⚠ WARNING: Insufficient disk space!\n");
|
|
|
|
|
printf(" Required: %.2f GB\n", required_gb);
|
|
|
|
|
printf(" Available: %.2f GB\n", available_gb);
|
|
|
|
|
printf(" Required: %.2f GB (%lu bytes)\n", required_gb, size_bytes);
|
|
|
|
|
printf(" Available: %.2f GB (%lu bytes)\n", available_gb, available_bytes);
|
|
|
|
|
printf(" Shortfall: %.2f GB\n", required_gb - available_gb);
|
|
|
|
|
printf(" Location: %s\n", pads_dir);
|
|
|
|
|
printf("\nContinue anyway? (y/N): ");
|
|
|
|
|
|
|
|
|
|
char response[10];
|
|
|
|
|
@@ -129,11 +129,54 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
|
|
|
|
|
|
|
|
|
|
FILE* pad_file = fopen(temp_filename, "wb");
|
|
|
|
|
if (!pad_file) {
|
|
|
|
|
printf("Error: Cannot create temporary pad file %s\n", temp_filename);
|
|
|
|
|
printf("Error: Cannot create temporary pad file '%s': %s (errno %d)\n",
|
|
|
|
|
temp_filename, strerror(errno), errno);
|
|
|
|
|
fclose(urandom);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Preallocate full file size using posix_fallocate for guaranteed space reservation
|
|
|
|
|
// This actually allocates disk blocks (unlike ftruncate which creates sparse files)
|
|
|
|
|
int fd = fileno(pad_file);
|
|
|
|
|
double size_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
|
|
|
|
|
if (display_progress) {
|
|
|
|
|
printf("Allocating %.2f GB on disk...\n", size_gb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int alloc_result = posix_fallocate(fd, 0, (off_t)size_bytes);
|
|
|
|
|
if (alloc_result != 0) {
|
|
|
|
|
printf("Error: Failed to allocate %.2f GB temp file: %s (errno %d)\n",
|
|
|
|
|
size_gb, strerror(alloc_result), alloc_result);
|
|
|
|
|
printf(" Temp file: %s\n", temp_filename);
|
|
|
|
|
printf(" Location: %s\n", pads_dir);
|
|
|
|
|
|
|
|
|
|
if (alloc_result == ENOSPC) {
|
|
|
|
|
printf(" Cause: No space left on device\n");
|
|
|
|
|
printf(" This means the actual available space is less than reported\n");
|
|
|
|
|
} else if (alloc_result == EOPNOTSUPP) {
|
|
|
|
|
printf(" Cause: Filesystem doesn't support posix_fallocate\n");
|
|
|
|
|
printf(" Falling back to ftruncate (sparse file)...\n");
|
|
|
|
|
if (ftruncate(fd, (off_t)size_bytes) != 0) {
|
|
|
|
|
printf(" Fallback failed: %s\n", strerror(errno));
|
|
|
|
|
fclose(pad_file);
|
|
|
|
|
fclose(urandom);
|
|
|
|
|
unlink(temp_filename);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
printf(" Possible causes: quota limits, filesystem restrictions\n");
|
|
|
|
|
fclose(pad_file);
|
|
|
|
|
fclose(urandom);
|
|
|
|
|
unlink(temp_filename);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (display_progress && alloc_result == 0) {
|
|
|
|
|
printf("✓ Allocated %.2f GB on disk (guaranteed space)\n", size_gb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned char buffer[64 * 1024]; // 64KB buffer
|
|
|
|
|
uint64_t bytes_written = 0;
|
|
|
|
|
time_t start_time = time(NULL);
|
|
|
|
|
@@ -149,7 +192,8 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fread(buffer, 1, (size_t)chunk_size, urandom) != (size_t)chunk_size) {
|
|
|
|
|
printf("Error: Failed to read from /dev/urandom\n");
|
|
|
|
|
printf("Error: Failed to read %lu bytes from /dev/urandom at position %lu: %s (errno %d)\n",
|
|
|
|
|
chunk_size, bytes_written, strerror(errno), errno);
|
|
|
|
|
fclose(urandom);
|
|
|
|
|
fclose(pad_file);
|
|
|
|
|
unlink(temp_filename);
|
|
|
|
|
@@ -157,7 +201,11 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fwrite(buffer, 1, (size_t)chunk_size, pad_file) != (size_t)chunk_size) {
|
|
|
|
|
printf("Error: Failed to write to pad file\n");
|
|
|
|
|
printf("Error: fwrite failed for %lu bytes at position %lu/%lu (%.1f%%): %s (errno %d)\n",
|
|
|
|
|
chunk_size, bytes_written, size_bytes,
|
|
|
|
|
(double)bytes_written / size_bytes * 100.0, strerror(errno), errno);
|
|
|
|
|
printf(" Temp file: %s\n", temp_filename);
|
|
|
|
|
printf(" Disk space was checked - possible causes: fragmentation, I/O timeout, quota\n");
|
|
|
|
|
fclose(urandom);
|
|
|
|
|
fclose(pad_file);
|
|
|
|
|
unlink(temp_filename);
|
|
|
|
|
@@ -216,8 +264,10 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
double size_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
printf("Generated pad: %s (%.2f GB)\n", pad_path, size_gb);
|
|
|
|
|
if (display_progress) {
|
|
|
|
|
double final_size_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
printf("Generated pad: %s (%.2f GB)\n", pad_path, final_size_gb);
|
|
|
|
|
}
|
|
|
|
|
printf("Pad checksum: %s\n", chksum_hex);
|
|
|
|
|
printf("State file: %s\n", state_path);
|
|
|
|
|
printf("Pad file set to read-only\n");
|
|
|
|
|
@@ -384,25 +434,25 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Format total size
|
|
|
|
|
if (st.st_size < 1024) {
|
|
|
|
|
if (st.st_size < 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
|
|
|
|
|
} else if (st.st_size < 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1024.0);
|
|
|
|
|
} else if (st.st_size < 1024 * 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1024.0 * 1024.0));
|
|
|
|
|
} else if (st.st_size < 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1000.0);
|
|
|
|
|
} else if (st.st_size < 1000 * 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1000.0 * 1000.0));
|
|
|
|
|
} else {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0));
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1000.0 * 1000.0 * 1000.0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Format used size
|
|
|
|
|
if (used_bytes < 1024) {
|
|
|
|
|
if (used_bytes < 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes);
|
|
|
|
|
} else if (used_bytes < 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1024.0);
|
|
|
|
|
} else if (used_bytes < 1024 * 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1024.0 * 1024.0));
|
|
|
|
|
} else if (used_bytes < 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1000.0);
|
|
|
|
|
} else if (used_bytes < 1000 * 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1000.0 * 1000.0));
|
|
|
|
|
} else {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0));
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1000.0 * 1000.0 * 1000.0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Calculate percentage
|
|
|
|
|
@@ -584,6 +634,27 @@ int handle_pads_menu(void) {
|
|
|
|
|
|
|
|
|
|
// Get list of pads from current directory
|
|
|
|
|
const char* pads_dir = get_current_pads_dir();
|
|
|
|
|
|
|
|
|
|
// Display directory and space information
|
|
|
|
|
printf("Pads Directory: %s\n", pads_dir);
|
|
|
|
|
|
|
|
|
|
// Get filesystem space information
|
|
|
|
|
struct statvfs vfs_stat;
|
|
|
|
|
if (statvfs(pads_dir, &vfs_stat) == 0) {
|
|
|
|
|
uint64_t total_bytes = vfs_stat.f_blocks * vfs_stat.f_frsize;
|
|
|
|
|
uint64_t available_bytes = vfs_stat.f_bavail * vfs_stat.f_frsize;
|
|
|
|
|
uint64_t used_bytes = total_bytes - (vfs_stat.f_bfree * vfs_stat.f_frsize);
|
|
|
|
|
|
|
|
|
|
double total_gb = (double)total_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double available_gb = (double)available_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double used_percent = (double)used_bytes / total_bytes * 100.0;
|
|
|
|
|
|
|
|
|
|
printf("Drive Space: %.2f GB total, %.2f GB used (%.1f%%), %.2f GB available\n",
|
|
|
|
|
total_gb, used_gb, used_percent, available_gb);
|
|
|
|
|
}
|
|
|
|
|
printf("\n");
|
|
|
|
|
|
|
|
|
|
DIR* dir = opendir(pads_dir);
|
|
|
|
|
if (!dir) {
|
|
|
|
|
printf("Error: Cannot open pads directory %s\n", pads_dir);
|
|
|
|
|
@@ -619,25 +690,25 @@ int handle_pads_menu(void) {
|
|
|
|
|
read_state_offset(pads[pad_count].chksum, &used_bytes);
|
|
|
|
|
|
|
|
|
|
// Format total size
|
|
|
|
|
if (st.st_size < 1024) {
|
|
|
|
|
if (st.st_size < 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
|
|
|
|
|
} else if (st.st_size < 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1024.0);
|
|
|
|
|
} else if (st.st_size < 1024 * 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1024.0 * 1024.0));
|
|
|
|
|
} else if (st.st_size < 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1000.0);
|
|
|
|
|
} else if (st.st_size < 1000 * 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1000.0 * 1000.0));
|
|
|
|
|
} else {
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0));
|
|
|
|
|
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1000.0 * 1000.0 * 1000.0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Format used size
|
|
|
|
|
if (used_bytes < 1024) {
|
|
|
|
|
if (used_bytes < 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes);
|
|
|
|
|
} else if (used_bytes < 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1024.0);
|
|
|
|
|
} else if (used_bytes < 1024 * 1024 * 1024) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1024.0 * 1024.0));
|
|
|
|
|
} else if (used_bytes < 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1000.0);
|
|
|
|
|
} else if (used_bytes < 1000 * 1000 * 1000) {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1000.0 * 1000.0));
|
|
|
|
|
} else {
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0));
|
|
|
|
|
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1000.0 * 1000.0 * 1000.0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Calculate percentage
|
|
|
|
|
@@ -949,9 +1020,9 @@ int handle_verify_pad(const char* chksum) {
|
|
|
|
|
printf("ChkSum: %s\n", chksum);
|
|
|
|
|
printf("File: %s\n", pad_filename);
|
|
|
|
|
|
|
|
|
|
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double used_gb = (double)used_bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double remaining_gb = (double)(st.st_size - used_bytes) / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
double remaining_gb = (double)(st.st_size - used_bytes) / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
|
|
|
|
|
printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size);
|
|
|
|
|
printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes);
|
|
|
|
|
@@ -1017,7 +1088,7 @@ int handle_delete_pad(const char* chksum) {
|
|
|
|
|
uint64_t used_bytes;
|
|
|
|
|
read_state_offset(chksum, &used_bytes);
|
|
|
|
|
|
|
|
|
|
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
|
double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
|
|
|
|
|
printf("\nPad to delete:\n");
|
|
|
|
|
printf("Checksum: %s\n", chksum);
|
|
|
|
|
printf("Size: %.2f GB\n", size_gb);
|
|
|
|
|
@@ -1205,7 +1276,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
|
|
|
|
|
target_bytes = (size_t)pad_stat.st_size;
|
|
|
|
|
printf("\nHardware RNG selected - will enhance entire pad with hardware entropy\n");
|
|
|
|
|
printf("Pad size: %.2f GB (%zu bytes)\n",
|
|
|
|
|
(double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes);
|
|
|
|
|
(double)target_bytes / (1000.0 * 1000.0 * 1000.0), target_bytes);
|
|
|
|
|
} else if (entropy_source == ENTROPY_SOURCE_FILE) {
|
|
|
|
|
// Special handling for file entropy - ask for file path first
|
|
|
|
|
char file_path[512];
|
|
|
|
|
@@ -1227,7 +1298,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
|
|
|
|
|
printf("\nFile vs Pad Size Analysis:\n");
|
|
|
|
|
printf(" Entropy file: %zu bytes\n", file_size);
|
|
|
|
|
printf(" Target pad: %.2f GB (%lu bytes)\n",
|
|
|
|
|
(double)pad_size / (1024.0 * 1024.0 * 1024.0), pad_size);
|
|
|
|
|
(double)pad_size / (1000.0 * 1000.0 * 1000.0), pad_size);
|
|
|
|
|
|
|
|
|
|
// Smart method selection based on file size vs pad size
|
|
|
|
|
if (file_size >= pad_size) {
|
|
|
|
|
@@ -1411,10 +1482,10 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
|
|
|
|
|
|
|
|
|
|
printf("✓ Device test successful!\n");
|
|
|
|
|
printf(" Test collected: %zu bytes in %.1f seconds\n", test_collected, test_time);
|
|
|
|
|
printf(" Speed: %.1f KB/s (%.1f MB/s)\n", bytes_per_second / 1024.0, bytes_per_second / (1024.0 * 1024.0));
|
|
|
|
|
printf(" Speed: %.1f KB/s (%.1f MB/s)\n", bytes_per_second / 1000.0, bytes_per_second / (1000.0 * 1000.0));
|
|
|
|
|
|
|
|
|
|
printf("\nPad enhancement estimate:\n");
|
|
|
|
|
printf(" Pad size: %.2f GB (%zu bytes)\n", (double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes);
|
|
|
|
|
printf(" Pad size: %.2f GB (%zu bytes)\n", (double)target_bytes / (1000.0 * 1000.0 * 1000.0), target_bytes);
|
|
|
|
|
|
|
|
|
|
if (estimated_hours >= 1.0) {
|
|
|
|
|
printf(" Estimated time: %.1f hours\n", estimated_hours);
|
|
|
|
|
|
