Version v0.3.35 - Convert to decimal units (1000-based) to match system tools, add posix_fallocate for guaranteed space allocation, use f_bavail for accurate space reporting, add drive info to Pad Management header

Makefile

@@ -11,11 +11,13 @@ OBJS = $(SOURCES:.c=.o)
 $(TARGET): $(OBJS)
 	@mkdir -p build
 	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LIBS)
+	@rm -f $(OBJS)
 
 # Static linking target
 static: $(OBJS)
 	@mkdir -p build
 	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LIBS_STATIC)
+	@rm -f $(OBJS)
 
 %.o: %.c
 	$(CC) $(CFLAGS) -c $< -o $@

README.md

@@ -1,9 +1,8 @@
 # OTP Cipher - One Time Pad Implementation
 
-
 ## Introduction
 
-A secure one-time pad (OTP) cipher implementation in C.
+A secure one-time pad (OTP) cipher implementation in C99.
 
 ## Why One-Time Pads
 
@@ -41,8 +40,6 @@ To address this problem, we can use Nostr to share among devices the place in th
 One-time pads can be trivially encrypted and decrypted using pencil and paper, making them accessible even without electronic devices.
 
 
-
-
 ## Features
 
 - **Perfect Security**: Implements true one-time pad encryption with information-theoretic security
@@ -57,106 +54,134 @@ One-time pads can be trivially encrypted and decrypted using pencil and paper, m
 - **Cross-Platform**: Works on Linux and other UNIX-like systems
 
 
-## Building
+## Quick Start
+
+### Download Pre-Built Binaries
+
+**[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.34/otp-v0.3.34-linux-x86_64)**
+
+**[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.34/otp-v0.3.34-linux-arm64)**
+
+After downloading:
+```bash
+# Rename for convenience, then make executable
+mv otp-v0.3.34-linux-x86_64 otp
+chmod +x otp
+
+# Run it
+./otp
+```
+### First Steps
+
+1. **Generate your first pad:**
+   ```bash
+   ./otp generate 1GB
+   ```
+
+2. **Encrypt a message:**
+   ```bash
+   ./otp encrypt
+   # Follow the interactive prompts
+   ```
+
+3. **Decrypt a message:**
+   ```bash
+   ./otp decrypt
+   # Paste the encrypted message
+   ```
+
+
+
+## Building from Source
 
 ### Prerequisites
 
 - GCC compiler
-- Git (for version tracking)
 - Make
 
-
-
 ### Build Commands
 
-Use the included build script for automatic versioning:
-
 ```bash
-# Standard build (default)
-./build.sh build
-
-# Static linking build
-./build.sh static
-
-# Clean build artifacts
-./build.sh clean
-
-# Generate version files only
-./build.sh version
-
-# Install to system
-./build.sh install
-
-# Remove from system
-./build.sh uninstall
-
-# Show usage
-./build.sh help
+make            # Build for current architecture
+make static     # Static linking (standalone binary)
+make clean      # Clean build artifacts
+make install    # Install to /usr/local/bin/otp
+make uninstall  # Remove from system
 ```
 
-### Traditional Make
-
-You can also use make directly (without automatic versioning):
+Output: `build/otp-$(ARCH)` (e.g., `build/otp-x86_64`)
 
+After building, run with:
 ```bash
-make            # Standard build
-make static     # Static linking
-make clean      # Clean artifacts
-make install    # Install to /usr/local/bin/
-make uninstall  # Remove from system
+./build/otp-x86_64
 ```
 
 ## Usage
 
+The OTP Cipher operates in two modes:
+
+**Interactive Mode**: Run without arguments to access a menu-driven interface. Best for exploring features, managing pads, and performing operations step-by-step with prompts and guidance.
+
+**Command Line Mode**: Provide arguments to execute specific operations directly. Ideal for scripting, automation, and quick one-off tasks.
+
 ### Interactive Mode
+
+Launch the menu-driven interface:
+
 ```bash
 ./otp
 ```
 
+Navigate through menus to generate pads, encrypt/decrypt messages, manage pads, and configure settings.
+
 ### Command Line Mode
+
+Execute operations directly with arguments:
+
 ```bash
 # Generate a new pad
 ./otp generate 1GB
 
-# Encrypt text (interactive input)
+# Encrypt text (will prompt for input)
 ./otp encrypt <pad_hash_or_prefix>
 
-# Decrypt message (interactive input)  
+# Decrypt message (will prompt for input)
 ./otp decrypt <pad_hash_or_prefix>
 
 # List available pads
 ./otp list
 ```
 
-## Version System Details
+## Version System
+
+### Centralized Version Management
+Version is defined in a single location: `src/main.h`
+```c
+#define OTP_VERSION "v0.3.24"
+```
+
+All code references this constant, ensuring consistency across:
+- Main menu display
+- ASCII armor output
+- Help/usage text
 
 ### Automatic Version Increment
-Every build automatically increments the patch version:
-- v0.1.0 → v0.1.1 → v0.1.2, etc.
-- Creates git tags for each version
-- Embeds detailed build information
+The `build.sh` script automatically:
+1. Increments patch version (v0.3.24 → v0.3.25)
+2. Updates `OTP_VERSION` in `src/main.h`
+3. Creates git commit and tag
+4. Pushes to remote repository
 
 ### Manual Version Control
 For major/minor releases, create tags manually:
 ```bash
 # Feature release (minor bump)
-git tag v0.2.0    # Next build: v0.2.1
+git tag v0.4.0    # Next build: v0.4.1
 
 # Breaking change (major bump)
 git tag v1.0.0    # Next build: v1.0.1
 ```
 
-### Version Information Available
-- Version number (major.minor.patch)
-- Git commit hash and branch
-- Build date and time
-- Full version display with metadata
-
-### Generated Files
-The build system automatically manages Git versioning by incrementing tags.
-
-These files are excluded from git (.gitignore) and regenerated on each build.
-
 ## Security Features
 
 - Uses `/dev/urandom` for cryptographically secure random number generation
@@ -166,28 +191,32 @@ These files are excluded from git (.gitignore) and regenerated on each build.
 - State tracking to prevent pad reuse
 - **Zero external crypto dependencies** - completely self-contained implementation
 
-## File Structure
+## Project Structure
 
 ```
 otp/
-├── build.sh          # Build script with automatic versioning
-├── Makefile         # Traditional make build system
-├── otp.c            # Legacy compatibility and global definitions
-├── README.md        # This file
-├── .gitignore       # Git ignore rules
-├── include/
-│   └── otp.h        # Public API header with all function prototypes
+├── build.sh              # Build script with automatic versioning
+├── Makefile             # Traditional make build system
+├── README.md            # This file
+├── .gitignore           # Git ignore rules
 ├── src/
-│   ├── main.c       # Main application entry point and command line handling
-│   ├── ui.c         # Interactive user interface and menu system
-│   ├── state.c      # Global state management (pads directory, terminal dimensions)
-│   ├── crypto.c     # Core cryptographic operations (XOR, ChaCha20)
-│   ├── pads.c       # Pad management and file operations
-│   ├── entropy.c    # Entropy collection from various sources
-│   ├── trng.c       # Hardware RNG device detection and entropy collection
-│   └── util.c       # Utility functions and helpers
-├── pads/            # OTP pad storage directory (created at runtime)
-└── VERSION          # Plain text version (generated)
+│   ├── main.h           # Main header with all prototypes and OTP_VERSION
+│   ├── main.c           # Application entry point and command line handling
+│   ├── ui.c             # Interactive user interface and menu system
+│   ├── state.c          # Global state management (pads directory, preferences)
+│   ├── crypto.c         # Core cryptographic operations (XOR, base64)
+│   ├── pads.c           # Pad management and file operations
+│   ├── entropy.c        # Entropy collection from various sources
+│   ├── trng.c           # Hardware RNG device detection and collection
+│   ├── util.c           # Utility functions and helpers
+│   ├── nostr_chacha20.c # ChaCha20 implementation for entropy expansion
+│   └── nostr_chacha20.h # ChaCha20 header
+├── build/
+│   ├── otp-x86_64       # Native x86_64 binary (created by build)
+│   └── otp-arm64        # ARM64 binary (created by cross-compilation)
+├── pads/                # OTP pad storage directory (created at runtime)
+├── files/               # Encrypted file storage (created at runtime)
+└── tests/               # Test scripts and utilities
 ```
 
 ## Architecture
@@ -197,13 +226,14 @@ The OTP cipher uses a modular architecture with clean separation of concerns:
 - **main.c**: Application entry point, command line parsing, and mode selection
 - **ui.c**: Interactive user interface, menus, and terminal management
 - **state.c**: Global state management (pads directory, terminal dimensions, preferences)
-- **crypto.c**: Core cryptographic operations (XOR encryption, ChaCha20 entropy mixing)
+- **crypto.c**: Core cryptographic operations (XOR encryption, base64 encoding)
 - **pads.c**: Pad file management, checksums, and state tracking
-- **entropy.c**: Entropy collection from keyboard, dice, and other sources
+- **entropy.c**: Entropy collection from keyboard, dice, files, and hardware RNG
 - **trng.c**: Hardware RNG device detection and entropy collection from USB devices
 - **util.c**: Utility functions, file operations, and helper routines
+- **nostr_chacha20.c**: ChaCha20 stream cipher for entropy expansion
 
-All modules share a common header (`include/otp.h`) that defines the public API and data structures.
+All modules share a common header (`src/main.h`) that defines the public API, data structures, and version constant.
 
 ## Hardware RNG Device Support
 
@@ -405,9 +435,22 @@ No.  ChkSum (first 16 chars) Size         Used         % Used
 
 This project includes automatic versioning system based on the Generic Automatic Version Increment System.
 
+## State Files
+
+Pad state files (`.state`) use a human-readable text format:
+```
+offset=1234567890
+```
+
+This tracks how many bytes of each pad have been used. The format is:
+- **Human-readable**: Can inspect with `cat checksum.state`
+- **Backward compatible**: Automatically reads old binary format
+- **Easy to debug**: Can manually edit if needed
+
 ## Contributing
 
 When contributing:
-1. The version will automatically increment on builds
-2. For major features, consider manually creating minor version tags
-3. Generated version files (`src/version.*`, `VERSION`) should not be committed
+1. The version will automatically increment on builds via `build.sh`
+2. Version is centralized in `src/main.h` as `OTP_VERSION`
+3. For major features, manually create minor/major version tags
+4. Build artifacts in `build/` and object files are auto-cleaned

build.sh

@@ -146,20 +146,53 @@ increment_version() {
 update_source_version() {
     local NEW_VERSION="$1"
     
-    print_status "Updating version strings in source code..."
+    print_status "Updating version constant in source code..."
     
-    # Replace hardcoded version strings in src/otp.c with the current git tag
-    if [ -f "src/otp.c" ]; then
-        # Update main menu version
-        sed -i "s/OTP v[0-9]\+\.[0-9]\+\.[0-9]\+/OTP $NEW_VERSION/g" src/otp.c
-        # Update ASCII output version
-        sed -i "s/Version: v[0-9]\+\.[0-9]\+\.[0-9]\+/Version: $NEW_VERSION/g" src/otp.c
-        # Update usage/help text version
-        sed -i "s/Implementation v[0-9]\+\.[0-9]\+\.[0-9]\+/Implementation $NEW_VERSION/g" src/otp.c
-        
-        print_success "Updated version strings in src/otp.c to $NEW_VERSION"
+    # Update OTP_VERSION constant in src/main.h
+    if [ -f "src/main.h" ]; then
+        sed -i "s/#define OTP_VERSION \"v[0-9]\+\.[0-9]\+\.[0-9]\+\"/#define OTP_VERSION \"$NEW_VERSION\"/g" src/main.h
+        print_success "Updated OTP_VERSION in src/main.h to $NEW_VERSION"
     else
-        print_warning "src/otp.c not found - skipping version string updates"
+        print_warning "src/main.h not found - skipping version update"
+    fi
+    
+    # Update README.md with direct download links
+    if [ -f "README.md" ]; then
+        print_status "Updating README.md with download links for $NEW_VERSION..."
+        
+        # Create the new download section with direct download links
+        local NEW_DOWNLOAD_SECTION="### Download Pre-Built Binaries
+
+**[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/${NEW_VERSION}/otp-${NEW_VERSION}-linux-x86_64)**
+
+**[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/${NEW_VERSION}/otp-${NEW_VERSION}-linux-arm64)**
+
+After downloading:
+\`\`\`bash
+# Rename for convenience, then make executable
+mv otp-${NEW_VERSION}-linux-x86_64 otp
+chmod +x otp
+
+# Run it
+./otp
+\`\`\`"
+        
+        # Use awk to replace the section between "### Download Pre-Built Binaries" and "### First Steps"
+        awk -v new_section="$NEW_DOWNLOAD_SECTION" '
+            /^### Download Pre-Built Binaries/ {
+                print new_section
+                skip=1
+                next
+            }
+            /^### First Steps/ {
+                skip=0
+            }
+            !skip
+        ' README.md > README.md.tmp && mv README.md.tmp README.md
+        
+        print_success "Updated README.md with download links for $NEW_VERSION"
+    else
+        print_warning "README.md not found - skipping README update"
     fi
 }
 
@@ -289,6 +322,10 @@ build_project() {
         fi
     fi
     
+    # Clean up object files after successful build
+    print_status "Cleaning up object files..."
+    rm -f src/*.o
+    
     # Create Gitea release with binaries
     if [ -f "$HOME/.gitea_token" ]; then
         create_gitea_release "$NEW_VERSION"

otp

@@ -0,0 +1 @@
+./build/otp-x86_64

src/crypto.c

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <unistd.h>
-#include "otp.h"
+#include "main.h"
 
 #define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
 
@@ -198,7 +198,7 @@ int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned cha
     strcpy(*ascii_output, "-----BEGIN OTP MESSAGE-----\n");
     
     char temp_line[256];
-    snprintf(temp_line, sizeof(temp_line), "Version: v0.3.16\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: %s\n", OTP_VERSION);
     strcat(*ascii_output, temp_line);
     
     snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);

src/entropy.c

@@ -16,7 +16,7 @@
 #include <fcntl.h>
 #include <math.h>
 #include "nostr_chacha20.h"
-#include "otp.h"
+#include "main.h"
 
 
 // In-place pad entropy addition using Chacha20 or direct XOR
@@ -82,7 +82,7 @@ int add_entropy_direct_xor(const char* pad_chksum, const unsigned char* entropy_
 
     if (display_progress) {
         printf("Adding entropy to pad using direct XOR...\n");
-        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size);
+        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
         printf("Entropy size: %zu bytes\n", entropy_size);
     }
 
@@ -212,7 +212,7 @@ int add_entropy_chacha20(const char* pad_chksum, const unsigned char* entropy_da
 
     if (display_progress) {
         printf("Adding entropy to pad using Chacha20...\n");
-        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size);
+        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
     }
 
     // Process pad in chunks
@@ -593,8 +593,8 @@ int add_file_entropy_streaming(const char* pad_chksum, const char* file_path, si
 
     if (display_progress) {
         printf("Adding entropy to pad using streaming direct XOR...\n");
-        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size);
-        printf("Entropy file: %.2f GB (%zu bytes)\n", (double)file_size / (1024.0*1024.0*1024.0), file_size);
+        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
+        printf("Entropy file: %.2f GB (%zu bytes)\n", (double)file_size / (1000.0*1000.0*1000.0), file_size);
     }
 
     // Process in chunks

src/main.c

@@ -15,7 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
-#include "otp.h"
+#include "main.h"
 
 int main(int argc, char* argv[]) {
     // Initialize terminal dimensions first
@@ -241,7 +241,7 @@ int command_line_mode(int argc, char* argv[]) {
 }
 
 void print_usage(const char* program_name) {
-    printf("OTP Cipher - One Time Pad Implementation v0.3.16\n");
+    printf("OTP Cipher - One Time Pad Implementation %s\n", OTP_VERSION);
     printf("Built for testing entropy system\n");
     printf("Usage:\n");
     printf("  %s                                         - Interactive mode\n", program_name);

src/main.h

@@ -1,12 +1,12 @@
-#ifndef OTP_H
-#define OTP_H
+#ifndef MAIN_H
+#define MAIN_H
 
 ////////////////////////////////////////////////////////////////////////////////
-//      OTP CIPHER - FUNCTION PROTOTYPES HEADER
-//      One Time Pad Implementation v0.2.109
+//      OTP CIPHER - MAIN HEADER FILE
+//      One Time Pad Implementation
 //
-//      This header file contains all function prototypes extracted from otp.c
-//      Organized by functional categories for better maintainability
+//      This header file contains all function prototypes and type definitions
+//      for the OTP Cipher project
 ////////////////////////////////////////////////////////////////////////////////
 
 #include <stdio.h>
@@ -22,6 +22,9 @@
 #include <string.h>
 #include <ctype.h>
 
+// Version - Updated automatically by build.sh
+#define OTP_VERSION "v0.3.34"
+
 // Constants
 #define MAX_INPUT_SIZE 4096
 #define MAX_LINE_LENGTH 1024
@@ -335,4 +338,4 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
 // Help and usage display
 void print_usage(const char* program_name);
 
-#endif // OTP_H
+#endif // MAIN_H

src/otp.c

@@ -1,35 +0,0 @@
-#define _POSIX_C_SOURCE 200809L
-#define _DEFAULT_SOURCE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <sys/statvfs.h>
-#include <sys/ioctl.h>
-#include <dirent.h>
-#include <time.h>
-#include <ctype.h>
-#include <termios.h>
-#include <fcntl.h>
-#include <math.h>
-#include "nostr_chacha20.h"
-#include "otp.h"
-
-
-#define MAX_INPUT_SIZE 4096
-#define MAX_LINE_LENGTH 1024
-#define MAX_HASH_LENGTH 65
-#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
-#define DEFAULT_PADS_DIR "pads"
-#define FILES_DIR "files"
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-//      GLOBAL VARIABLES
-///////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-char current_pads_dir[512] = DEFAULT_PADS_DIR;

src/pads.c

@@ -16,7 +16,7 @@
 #include <fcntl.h>
 #include <math.h>
 #include <errno.h>
-#include "otp.h"
+#include "main.h"
 
 
 // Extracted pad management functions from otp.c
@@ -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,15 +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_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 / (1024.0 * 1024.0 * 1024.0);
-        double required_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0);
+        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];
@@ -126,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);
@@ -146,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);
@@ -154,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);
@@ -213,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");
@@ -233,19 +286,41 @@ int read_state_offset(const char* pad_chksum, uint64_t* offset) {
     const char* pads_dir = get_current_pads_dir();
     snprintf(state_filename, sizeof(state_filename), "%s/%s.state", pads_dir, pad_chksum);
 
-    FILE* state_file = fopen(state_filename, "rb");
+    FILE* state_file = fopen(state_filename, "r");
     if (!state_file) {
         *offset = 0;
         return 0;
     }
 
-    if (fread(offset, sizeof(uint64_t), 1, state_file) != 1) {
+    // Try to read as text format first (new format)
+    char line[128];
+    if (fgets(line, sizeof(line), state_file)) {
+        // Check if it's text format (starts with "offset=")
+        if (strncmp(line, "offset=", 7) == 0) {
+            *offset = strtoull(line + 7, NULL, 10);
+            fclose(state_file);
+            return 0;
+        }
+        
+        // Not text format, try binary format (legacy)
+        fclose(state_file);
+        state_file = fopen(state_filename, "rb");
+        if (!state_file) {
+            *offset = 0;
+            return 0;
+        }
+        
+        if (fread(offset, sizeof(uint64_t), 1, state_file) != 1) {
+            fclose(state_file);
+            *offset = 0;
+            return 0;
+        }
         fclose(state_file);
-        *offset = 0;
         return 0;
     }
 
     fclose(state_file);
+    *offset = 0;
     return 0;
 }
 
@@ -254,12 +329,13 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
     const char* pads_dir = get_current_pads_dir();
     snprintf(state_filename, sizeof(state_filename), "%s/%s.state", pads_dir, pad_chksum);
 
-    FILE* state_file = fopen(state_filename, "wb");
+    FILE* state_file = fopen(state_filename, "w");
     if (!state_file) {
         return 1;
     }
 
-    if (fwrite(&offset, sizeof(uint64_t), 1, state_file) != 1) {
+    // Write in text format for human readability
+    if (fprintf(state_file, "offset=%lu\n", offset) < 0) {
         fclose(state_file);
         return 1;
     }
@@ -358,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
@@ -558,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);
@@ -593,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
@@ -923,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);
@@ -991,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);
@@ -1179,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];
@@ -1201,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) {
@@ -1385,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);

src/state.c

@@ -1,6 +1,6 @@
 #include <string.h>
 #include <stdlib.h>
-#include "otp.h"
+#include "main.h"
 
 // Global state variables
 static char current_pads_dir[512] = DEFAULT_PADS_DIR;

src/trng.c

@@ -17,7 +17,7 @@
 #include <math.h>
 #include <errno.h>
 #include "nostr_chacha20.h"
-#include "otp.h"
+#include "main.h"
 
 // Basic TrueRNG entropy collection function
 int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress) {
@@ -153,7 +153,7 @@ int collect_truerng_entropy_streaming_from_device(const hardware_rng_device_t* d
 
     if (display_progress) {
         printf("Streaming entropy from %s to pad...\n", device->friendly_name);
-        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size);
+        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
         printf("Enhancing entire pad with hardware entropy\n");
     }
 

src/ui.c

@@ -15,7 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
-#include "otp.h"
+#include "main.h"
 
 // Initialize terminal dimensions
 void init_terminal_dimensions(void) {
@@ -120,7 +120,9 @@ int interactive_mode(void) {
 
 void show_main_menu(void) {
     printf("\n");
-    print_centered_header("Main Menu - OTP v0.3.16", 0);
+    char header[64];
+    snprintf(header, sizeof(header), "Main Menu - OTP %s", OTP_VERSION);
+    print_centered_header(header, 0);
     printf("\n");
 
     printf(" \033[4mT\033[0mext encrypt\n");    //TEXT ENCRYPT
@@ -150,7 +152,7 @@ int handle_generate_menu(void) {
         return 1;
     }
 
-    double size_gb = (double)size / (1024.0 * 1024.0 * 1024.0);
+    double size_gb = (double)size / (1000.0 * 1000.0 * 1000.0);
     printf("Generating %.2f GB pad...\n", size_gb);
     printf("Note: Use 'Add entropy' in Pads menu to enhance randomness after creation.\n");
 

src/util.c

@@ -15,7 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
-#include "otp.h"
+#include "main.h"
 
 // Global variables for preferences
 static char default_pad_path[1024] = "";
@@ -519,13 +519,13 @@ uint64_t parse_size_string(const char* size_str) {
         }
 
         if (strcmp(unit, "K") == 0 || strcmp(unit, "KB") == 0) {
-            multiplier = 1024ULL;
+            multiplier = 1000ULL;
         } else if (strcmp(unit, "M") == 0 || strcmp(unit, "MB") == 0) {
-            multiplier = 1024ULL * 1024ULL;
+            multiplier = 1000ULL * 1000ULL;
         } else if (strcmp(unit, "G") == 0 || strcmp(unit, "GB") == 0) {
-            multiplier = 1024ULL * 1024ULL * 1024ULL;
+            multiplier = 1000ULL * 1000ULL * 1000ULL;
         } else if (strcmp(unit, "T") == 0 || strcmp(unit, "TB") == 0) {
-            multiplier = 1024ULL * 1024ULL * 1024ULL * 1024ULL;
+            multiplier = 1000ULL * 1000ULL * 1000ULL * 1000ULL;
         } else {
             return 0; // Invalid unit
         }