Version v0.2.54 - Final fix for remaining compile warning by increasing user_mount_path buffer to 2048 bytes

files/o2.txt

@@ -0,0 +1 @@
+Hello, this is a test file for encryption!

otp.c

@@ -43,11 +43,26 @@ static const int base64_decode_table[256] = {
 #define FILES_DIR "files"
 #define MAX_ENTROPY_BUFFER 32768  // 32KB entropy buffer
 
+// USB Pad structure for external drive detection
+struct USBPadInfo {
+    char chksum[65];           // 64-char checksum + null terminator
+    char pad_path[1024];       // Full path to .pad file
+    char state_path[1024];     // Full path to .state file
+    char mount_point[1024];    // USB mount point for display
+    uint64_t state_offset;     // Current state offset
+};
+
 // Function prototypes
 int main(int argc, char* argv[]);
 int interactive_mode(void);
 int command_line_mode(int argc, char* argv[]);
 
+// USB drive detection functions
+int scan_usb_drives_for_pads(struct USBPadInfo** usb_pads, int* usb_count);
+int resolve_state_conflicts(const char* chksum, struct USBPadInfo* usb_pads, int usb_count, 
+                            uint64_t local_offset, uint64_t* resolved_offset, char** authoritative_path);
+void free_usb_pads(struct USBPadInfo* usb_pads, int count);
+
 // Editor and file manager functions
 char* get_preferred_editor(void);
 char* get_preferred_file_manager(void);
@@ -73,7 +88,6 @@ void simple_entropy_mix(unsigned char* urandom_buffer, size_t buffer_size,
 
 // Directory management
 int ensure_pads_directory(void);
-int ensure_files_directory(void);
 void get_pad_path(const char* chksum, char* pad_path, char* state_path);
 const char* get_files_directory(void);
 void get_default_file_path(const char* filename, char* result_path, size_t result_size);
@@ -83,14 +97,12 @@ uint64_t parse_size_string(const char* size_str);
 char* find_pad_by_prefix(const char* prefix);
 int list_available_pads(void);
 int show_pad_info(const char* chksum);
-int get_user_choice(int min, int max);
 void show_progress(uint64_t current, uint64_t total, time_t start_time);
 
 // File operations
 int read_state_offset(const char* pad_chksum, uint64_t* offset);
 int write_state_offset(const char* pad_chksum, uint64_t offset);
 int calculate_checksum(const char* filename, char* checksum_hex);
-void xor_checksum_256(const unsigned char* data, size_t len, unsigned char checksum[32]);
 char* custom_base64_encode(const unsigned char* input, int length);
 unsigned char* custom_base64_decode(const char* input, int* output_length);
 
@@ -99,12 +111,16 @@ void show_main_menu(void);
 int handle_generate_menu(void);
 int handle_encrypt_menu(void);
 int handle_decrypt_menu(void);
+int handle_pads_menu(void);
 int handle_text_encrypt(void);
 int handle_file_encrypt(void);
 
 // Enhanced input functions
 int get_filename_with_default(const char* prompt, const char* default_path, char* result, size_t result_size);
 
+// Directory display functions
+void get_directory_display(const char* file_path, char* result, size_t result_size);
+
 void print_usage(const char* program_name);
 
 int main(int argc, char* argv[]) {
@@ -134,31 +150,15 @@ int interactive_mode(void) {
                 case 'D':
                     handle_decrypt_menu();
                     break;
-                case 'G':
+                case 'P':
-                    handle_generate_menu();
+                    handle_pads_menu();
                     break;
-                case 'L':
-                    list_available_pads();
-                    break;
-                case 'S': {
-                    printf("Enter pad checksum (or prefix): ");
-                    char input[MAX_HASH_LENGTH];
-                    if (fgets(input, sizeof(input), stdin)) {
-                        input[strcspn(input, "\n")] = 0;
-                        char* chksum = find_pad_by_prefix(input);
-                        if (chksum) {
-                            show_pad_info(chksum);
-                            free(chksum);
-                        }
-                    }
-                    break;
-                }
                 case 'X':
                 case 'Q':
                     printf("Goodbye!\n");
                     return 0;
                 default:
-                    printf("Invalid option. Please select T, F, D, G, L, S, or X.\n");
+                    printf("Invalid option. Please select T, F, D, P, or X.\n");
                     continue;
             }
         } else {
@@ -280,9 +280,7 @@ void show_main_menu(void) {
     printf(" \033[4mT\033[0mext encrypt\n");
     printf(" \033[4mF\033[0mile encrypt\n");
     printf(" \033[4mD\033[0mecrypt\n");
-    printf(" \033[4mG\033[0menerate new pad\n");
+    printf(" \033[4mP\033[0mads\n");
-    printf(" \033[4mL\033[0mist available pads\n");
-    printf(" \033[4mS\033[0mhow pad information\n");
     printf(" E\033[4mx\033[0mit\n");
     printf("\nSelect option: ");
 }
@@ -649,19 +647,25 @@ uint64_t parse_size_string(const char* size_str) {
 }
 
 char* find_pad_by_prefix(const char* prefix) {
+    // First scan for USB pads
+    struct USBPadInfo* usb_pads = NULL;
+    int usb_count = 0;
+    scan_usb_drives_for_pads(&usb_pads, &usb_count);
+    
     DIR* dir = opendir(PADS_DIR);
     if (!dir) {
         printf("Error: Cannot open pads directory\n");
+        free_usb_pads(usb_pads, usb_count);
         return NULL;
     }
     
     struct dirent* entry;
-    char* matches[100];  // Store up to 100 matches
+    char* matches[200];  // Store up to 200 matches (local + USB)
     int match_count = 0;
     
-    // Always try hex prefix matching first
+    // Always try hex prefix matching first on local pads
     size_t prefix_len = strlen(prefix);
-    while ((entry = readdir(dir)) != NULL && match_count < 100) {
+    while ((entry = readdir(dir)) != NULL && match_count < 200) {
         // Skip . and .. entries, and only process .pad files
         if (entry->d_name[0] == '.') continue;
         if (!strstr(entry->d_name, ".pad")) continue;
@@ -676,19 +680,40 @@ char* find_pad_by_prefix(const char* prefix) {
         }
     }
     
+    // Also check USB pads for prefix matches
+    for (int i = 0; i < usb_count && match_count < 200; i++) {
+        if (strncmp(usb_pads[i].chksum, prefix, prefix_len) == 0) {
+            // Check if we already have this checksum from local pads
+            int is_duplicate = 0;
+            for (int j = 0; j < match_count; j++) {
+                if (strcmp(matches[j], usb_pads[i].chksum) == 0) {
+                    is_duplicate = 1;
+                    break;
+                }
+            }
+            if (!is_duplicate) {
+                matches[match_count] = malloc(65);
+                strncpy(matches[match_count], usb_pads[i].chksum, 64);
+                matches[match_count][64] = '\0';
+                match_count++;
+            }
+        }
+    }
+    
     // If no hex prefix matches and it looks like a small number, try number selection
     if (match_count == 0) {
         char* endptr;
         int selection = strtol(prefix, &endptr, 10);
-        if (*endptr == '\0' && selection > 0 && selection <= 100) {
+        if (*endptr == '\0' && selection > 0 && selection <= 200) {
-            // It's a number, find the nth pad
+            // It's a number, find the nth pad (counting local + USB)
             int current = 0;
+            
+            // Count local pads first
             rewinddir(dir);
             while ((entry = readdir(dir)) != NULL) {
-                // Skip . and .. entries, and only process .pad files
                 if (entry->d_name[0] == '.') continue;
                 if (!strstr(entry->d_name, ".pad")) continue;
-                if (strlen(entry->d_name) != 68) continue; // 64 char chksum + ".pad"
+                if (strlen(entry->d_name) != 68) continue;
                 
                 current++;
                 if (current == selection) {
@@ -699,10 +724,45 @@ char* find_pad_by_prefix(const char* prefix) {
                     break;
                 }
             }
+            
+            // If not found in local pads, check USB pads
+            if (match_count == 0) {
+                for (int i = 0; i < usb_count; i++) {
+                    // Skip if this USB pad is already counted in local pads
+                    int is_local = 0;
+                    rewinddir(dir);
+                    while ((entry = readdir(dir)) != NULL) {
+                        if (entry->d_name[0] == '.') continue;
+                        if (!strstr(entry->d_name, ".pad")) continue;
+                        if (strlen(entry->d_name) != 68) continue;
+                        
+                        char local_chksum[65];
+                        strncpy(local_chksum, entry->d_name, 64);
+                        local_chksum[64] = '\0';
+                        
+                        if (strcmp(local_chksum, usb_pads[i].chksum) == 0) {
+                            is_local = 1;
+                            break;
+                        }
+                    }
+                    
+                    if (!is_local) {
+                        current++;
+                        if (current == selection) {
+                            matches[match_count] = malloc(65);
+                            strncpy(matches[match_count], usb_pads[i].chksum, 64);
+                            matches[match_count][64] = '\0';
+                            match_count = 1;
+                            break;
+                        }
+                    }
+                }
+            }
         }
     }
     
     closedir(dir);
+    free_usb_pads(usb_pads, usb_count);
     
     if (match_count == 0) {
         printf("No pads found matching '%s'\n", prefix);
@@ -758,8 +818,8 @@ int list_available_pads(void) {
     struct dirent* entry;
     int count = 0;
     
-    printf("Available pads:\n");
+    printf("\nAvailable pads:\n");
-    printf("%-4s %-20s %-12s %-12s %-8s\n", "No.", "ChkSum (first 16 chars)", "Size", "Used", "% Used");
+    printf("%-4s %-20s %-12s %-12s %-8s\n", "No.", "ChkSum", "Size", "Used", "% Used");
     printf("%-4s %-20s %-12s %-12s %-8s\n", "---", "-------------------", "----------", "----------", "------");
     
     while ((entry = readdir(dir)) != NULL) {
@@ -852,20 +912,6 @@ int show_pad_info(const char* chksum) {
     return 0;
 }
 
-int get_user_choice(int min, int max) {
-    char input[64];
-    int choice;
-    
-    while (1) {
-        if (fgets(input, sizeof(input), stdin)) {
-            choice = atoi(input);
-            if (choice >= min && choice <= max) {
-                return choice;
-            }
-        }
-        printf("Please enter a number between %d and %d: ", min, max);
-    }
-}
 
 void show_progress(uint64_t current, uint64_t total, time_t start_time) {
     time_t now = time(NULL);
@@ -2282,15 +2328,6 @@ int ensure_pads_directory(void) {
     return 0;
 }
 
-int ensure_files_directory(void) {
-    struct stat st = {0};
-    if (stat(FILES_DIR, &st) == -1) {
-        if (mkdir(FILES_DIR, 0755) != 0) {
-            return 1;
-        }
-    }
-    return 0;
-}
 
 const char* get_files_directory(void) {
     struct stat st = {0};
@@ -2319,16 +2356,195 @@ void get_pad_path(const char* chksum, char* pad_path, char* state_path) {
     snprintf(state_path, MAX_HASH_LENGTH + 20, "%s/%s.state", PADS_DIR, chksum);
 }
 
+// USB drive detection functions implementation
+int scan_usb_drives_for_pads(struct USBPadInfo** usb_pads, int* usb_count) {
+    const char* mount_dirs[] = {"/media", "/run/media", "/mnt", NULL};
+    struct USBPadInfo* pads = malloc(100 * sizeof(struct USBPadInfo)); // Support up to 100 USB pads
+    int count = 0;
+    
+    if (!pads) {
+        *usb_pads = NULL;
+        *usb_count = 0;
+        return 1;
+    }
+    
+    for (int mount_idx = 0; mount_dirs[mount_idx] != NULL; mount_idx++) {
+        DIR* mount_dir = opendir(mount_dirs[mount_idx]);
+        if (!mount_dir) continue;
+        
+        struct dirent* mount_entry;
+        while ((mount_entry = readdir(mount_dir)) != NULL && count < 100) {
+            if (mount_entry->d_name[0] == '.') continue;
+            
+            char mount_path[1024];
+            snprintf(mount_path, sizeof(mount_path), "%s/%s", mount_dirs[mount_idx], mount_entry->d_name);
+            
+            // For /run/media, we need to go one level deeper (skip username)
+            if (strcmp(mount_dirs[mount_idx], "/run/media") == 0) {
+                DIR* user_dir = opendir(mount_path);
+                if (!user_dir) continue;
+                
+                struct dirent* user_entry;
+                while ((user_entry = readdir(user_dir)) != NULL && count < 100) {
+                    if (user_entry->d_name[0] == '.') continue;
+                    
+                    char user_mount_path[2048];
+                    snprintf(user_mount_path, sizeof(user_mount_path), "%s/%s", mount_path, user_entry->d_name);
+                    
+                    // Scan this mount point for pads
+                    DIR* drive_dir = opendir(user_mount_path);
+                    if (!drive_dir) continue;
+                    
+                    struct dirent* drive_entry;
+                    while ((drive_entry = readdir(drive_dir)) != NULL && count < 100) {
+                        // Look for .pad files in root of drive
+                        if (strstr(drive_entry->d_name, ".pad") && strlen(drive_entry->d_name) == 68) {
+                            char pad_path[2048], state_path[2048];
+                            snprintf(pad_path, sizeof(pad_path), "%s/%s", user_mount_path, drive_entry->d_name);
+                            
+                            // Extract checksum from filename
+                            strncpy(pads[count].chksum, drive_entry->d_name, 64);
+                            pads[count].chksum[64] = '\0';
+                            
+                            // Check if corresponding .state file exists
+                            snprintf(state_path, sizeof(state_path), "%s/%s.state", user_mount_path, pads[count].chksum);
+                            if (access(state_path, R_OK) == 0) {
+                                // Valid pad found
+                                strncpy(pads[count].pad_path, pad_path, sizeof(pads[count].pad_path) - 1);
+                                strncpy(pads[count].state_path, state_path, sizeof(pads[count].state_path) - 1);
+                                strncpy(pads[count].mount_point, user_mount_path, sizeof(pads[count].mount_point) - 1);
+                                
+                                // Read state offset
+                                FILE* state_file = fopen(state_path, "rb");
+                                if (state_file) {
+                                    if (fread(&pads[count].state_offset, sizeof(uint64_t), 1, state_file) != 1) {
+                                        pads[count].state_offset = 0;
+                                    }
+                                    fclose(state_file);
+                                } else {
+                                    pads[count].state_offset = 0;
+                                }
+                                
+                                count++;
+                            }
+                        }
+                    }
+                    closedir(drive_dir);
+                }
+                closedir(user_dir);
+            } else {
+                // Direct mount point (like /media/DRIVE_NAME or /mnt/DRIVE_NAME)
+                DIR* drive_dir = opendir(mount_path);
+                if (!drive_dir) continue;
+                
+                struct dirent* drive_entry;
+                while ((drive_entry = readdir(drive_dir)) != NULL && count < 100) {
+                    // Look for .pad files in root of drive
+                    if (strstr(drive_entry->d_name, ".pad") && strlen(drive_entry->d_name) == 68) {
+                        char pad_path[2048], state_path[2048];
+                        snprintf(pad_path, sizeof(pad_path), "%s/%s", mount_path, drive_entry->d_name);
+                        
+                        // Extract checksum from filename
+                        strncpy(pads[count].chksum, drive_entry->d_name, 64);
+                        pads[count].chksum[64] = '\0';
+                        
+                        // Check if corresponding .state file exists
+                        snprintf(state_path, sizeof(state_path), "%s/%s.state", mount_path, pads[count].chksum);
+                        if (access(state_path, R_OK) == 0) {
+                            // Valid pad found
+                            strncpy(pads[count].pad_path, pad_path, sizeof(pads[count].pad_path) - 1);
+                            strncpy(pads[count].state_path, state_path, sizeof(pads[count].state_path) - 1);
+                            strncpy(pads[count].mount_point, mount_path, sizeof(pads[count].mount_point) - 1);
+                            
+                            // Read state offset
+                            FILE* state_file = fopen(state_path, "rb");
+                            if (state_file) {
+                                if (fread(&pads[count].state_offset, sizeof(uint64_t), 1, state_file) != 1) {
+                                    pads[count].state_offset = 0;
+                                }
+                                fclose(state_file);
+                            } else {
+                                pads[count].state_offset = 0;
+                            }
+                            
+                            count++;
+                        }
+                    }
+                }
+                closedir(drive_dir);
+            }
+        }
+        closedir(mount_dir);
+    }
+    
+    *usb_pads = pads;
+    *usb_count = count;
+    return 0;
+}
 
-// Custom XOR checksum function
+int resolve_state_conflicts(const char* chksum, struct USBPadInfo* usb_pads, int usb_count, 
-void xor_checksum_256(const unsigned char* data, size_t len, unsigned char checksum[32]) {
+                            uint64_t local_offset, uint64_t* resolved_offset, char** authoritative_path) {
-    memset(checksum, 0, 32);
+    uint64_t max_offset = local_offset;
-    for (size_t i = 0; i < len; i++) {
+    int conflicts_found = 0;
-        unsigned char bucket = i % 32;
+    char local_path[512];
-        checksum[bucket] ^= data[i] ^ ((i >> 8) & 0xFF) ^ ((i >> 16) & 0xFF) ^ ((i >> 24) & 0xFF);
+    snprintf(local_path, sizeof(local_path), "%s/%s.state", PADS_DIR, chksum);
+    
+    // Initially assume local is authoritative
+    *authoritative_path = strdup(local_path);
+    
+    // Check all USB pads with same checksum
+    for (int i = 0; i < usb_count; i++) {
+        if (strcmp(usb_pads[i].chksum, chksum) == 0) {
+            if (usb_pads[i].state_offset != local_offset) {
+                conflicts_found = 1;
+                if (usb_pads[i].state_offset > max_offset) {
+                    max_offset = usb_pads[i].state_offset;
+                    free(*authoritative_path);
+                    *authoritative_path = strdup(usb_pads[i].state_path);
+                }
+            }
+        }
+    }
+    
+    if (conflicts_found) {
+        printf("Warning: State conflict detected for pad %s\n", chksum);
+        printf("Multiple state files found with different offsets. Using highest offset: %lu\n", max_offset);
+        
+        // Update all state files to use the maximum offset
+        // Update local state file
+        FILE* local_state = fopen(local_path, "wb");
+        if (local_state) {
+            fwrite(&max_offset, sizeof(uint64_t), 1, local_state);
+            fclose(local_state);
+        }
+        
+        // Update USB state files
+        for (int i = 0; i < usb_count; i++) {
+            if (strcmp(usb_pads[i].chksum, chksum) == 0) {
+                FILE* usb_state = fopen(usb_pads[i].state_path, "wb");
+                if (usb_state) {
+                    fwrite(&max_offset, sizeof(uint64_t), 1, usb_state);
+                    fclose(usb_state);
+                }
+                // Update the cached offset
+                usb_pads[i].state_offset = max_offset;
+            }
+        }
+    }
+    
+    *resolved_offset = max_offset;
+    return conflicts_found ? 1 : 0;
+}
+
+void free_usb_pads(struct USBPadInfo* usb_pads, int count) {
+    (void)count; // Suppress unused parameter warning
+    if (usb_pads) {
+        free(usb_pads);
     }
 }
 
+
+
 // Custom base64 encode function
 char* custom_base64_encode(const unsigned char* input, int length) {
     int output_length = 4 * ((length + 2) / 3);
@@ -2877,6 +3093,394 @@ int handle_file_encrypt(void) {
 }
 
 
+int handle_pads_menu(void) {
+    printf("\n=== Pad Management ===\n");
+    printf("Scanning for USB drives...\n");
+    
+    // Scan for USB pads first
+    struct USBPadInfo* usb_pads = NULL;
+    int usb_count = 0;
+    scan_usb_drives_for_pads(&usb_pads, &usb_count);
+    
+    // Get list of local pads
+    DIR* dir = opendir(PADS_DIR);
+    if (!dir) {
+        printf("Error: Cannot open pads directory\n");
+        free_usb_pads(usb_pads, usb_count);
+        return 1;
+    }
+    
+    // Structure to store combined pad information
+    struct PadInfo {
+        char chksum[65];
+        char size_str[32];
+        char used_str[32];
+        double percentage;
+        char location[256];  // Store location info (local/USB)
+        int is_usb;         // Flag to indicate USB pad
+    };
+    
+    struct PadInfo pads[200];  // Support up to 200 total pads (local + USB)
+    int pad_count = 0;
+    
+    // First, collect all local pad information
+    struct dirent* entry;
+    while ((entry = readdir(dir)) != NULL && pad_count < 200) {
+        if (strstr(entry->d_name, ".pad") && strlen(entry->d_name) == 68) {
+            strncpy(pads[pad_count].chksum, entry->d_name, 64);
+            pads[pad_count].chksum[64] = '\0';
+            
+            // Get pad file size and usage info
+            char full_path[300];
+            snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
+            struct stat st;
+            if (stat(full_path, &st) == 0) {
+                // Get used bytes from state (check for conflicts with USB)
+                uint64_t used_bytes;
+                read_state_offset(pads[pad_count].chksum, &used_bytes);
+                
+                // Check for state conflicts with USB pads
+                uint64_t resolved_offset;
+                char* authoritative_path;
+                if (resolve_state_conflicts(pads[pad_count].chksum, usb_pads, usb_count, 
+                                          used_bytes, &resolved_offset, &authoritative_path) == 1) {
+                    used_bytes = resolved_offset;
+                }
+                free(authoritative_path);
+                
+                // Format total size
+                if (st.st_size < 1024) {
+                    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 {
+                    snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0));
+                }
+                
+                // Format used size
+                if (used_bytes < 1024) {
+                    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 {
+                    snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0));
+                }
+                
+                // Calculate percentage
+                pads[pad_count].percentage = (double)used_bytes / st.st_size * 100.0;
+                
+                // Set location info
+                strcpy(pads[pad_count].location, "pads");
+                pads[pad_count].is_usb = 0;
+                
+                pad_count++;
+            }
+        }
+    }
+    closedir(dir);
+    
+    // Then, add USB pads (avoiding duplicates)
+    for (int i = 0; i < usb_count && pad_count < 200; i++) {
+        // Check if this USB pad is already in local pads
+        int is_duplicate = 0;
+        for (int j = 0; j < pad_count; j++) {
+            if (strcmp(pads[j].chksum, usb_pads[i].chksum) == 0) {
+                is_duplicate = 1;
+                break;
+            }
+        }
+        
+        if (!is_duplicate) {
+            // Add USB pad
+            strcpy(pads[pad_count].chksum, usb_pads[i].chksum);
+            
+            // Get pad file size
+            struct stat st;
+            if (stat(usb_pads[i].pad_path, &st) == 0) {
+                // Format total size
+                if (st.st_size < 1024) {
+                    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 {
+                    snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0));
+                }
+                
+                // Format used size (already resolved)
+                uint64_t used_bytes = usb_pads[i].state_offset;
+                if (used_bytes < 1024) {
+                    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 {
+                    snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0));
+                }
+                
+                // Calculate percentage
+                pads[pad_count].percentage = (double)used_bytes / st.st_size * 100.0;
+                
+                // Set USB location info
+                get_directory_display(usb_pads[i].pad_path, pads[pad_count].location, sizeof(pads[pad_count].location));
+                pads[pad_count].is_usb = 1;
+                
+                pad_count++;
+            }
+        }
+    }
+    
+    if (pad_count == 0) {
+        printf("No pads found.\n");
+        printf("\nOptions:\n");
+        printf(" \033[4mG\033[0menerate new pad\n");
+        printf(" \033[4mB\033[0mack to main menu\n");
+        printf("\nSelect option: ");
+        
+        char input[10];
+        if (fgets(input, sizeof(input), stdin)) {
+            char choice = toupper(input[0]);
+            if (choice == 'G') {
+                return handle_generate_menu();
+            }
+        }
+        return 0;
+    }
+    
+    // Calculate minimal unique prefixes for each pad
+    char prefixes[100][65];  // Store the minimal prefix for each pad
+    int prefix_lengths[100]; // Length of minimal prefix for each pad
+    
+    for (int i = 0; i < pad_count; i++) {
+        prefix_lengths[i] = 1;
+        
+        // Find minimal unique prefix
+        while (prefix_lengths[i] <= 64) {
+            int unique = 1;
+            
+            // Check if current prefix is unique among all other pads
+            for (int j = 0; j < pad_count; j++) {
+                if (i != j && strncmp(pads[i].chksum, pads[j].chksum, prefix_lengths[i]) == 0) {
+                    unique = 0;
+                    break;
+                }
+            }
+            
+            if (unique) {
+                break;
+            }
+            prefix_lengths[i]++;
+        }
+        
+        // Store the minimal prefix
+        strncpy(prefixes[i], pads[i].chksum, prefix_lengths[i]);
+        prefixes[i][prefix_lengths[i]] = '\0';
+    }
+    
+    // Display pads with minimal prefixes underlined
+    printf("\nAvailable pads:\n");
+    printf("%-8s %-12s %-12s %-12s %-8s\n", "ChkSum", "Dir", "Size", "Used", "% Used");
+    printf("%-8s %-12s %-12s %-12s %-8s\n", "--------", "------------", "----------", "----------", "------");
+    
+    for (int i = 0; i < pad_count; i++) {
+        // Display first 8 characters of checksum with prefix underlined
+        char checksum_8char[9];
+        strncpy(checksum_8char, pads[i].chksum, 8);
+        checksum_8char[8] = '\0';
+        
+        printf("\033[4m%.*s\033[0m%s %-12s %-12s %-12s %.1f%%\n",
+               prefix_lengths[i], checksum_8char,  // Underlined prefix
+               checksum_8char + prefix_lengths[i], // Rest of 8-char checksum
+               pads[i].location,                   // Use the stored location info
+               pads[i].size_str,
+               pads[i].used_str,
+               pads[i].percentage);
+    }
+    
+    printf("\nActions:\n");
+    printf(" \033[4mG\033[0menerate new pad\n");
+    printf(" \033[4mB\033[0mack to main menu\n");
+    printf("\nSelect pad (by prefix) or action: ");
+    
+    char input[MAX_HASH_LENGTH];
+    if (!fgets(input, sizeof(input), stdin)) {
+        printf("Error: Failed to read input\n");
+        return 1;
+    }
+    input[strcspn(input, "\n")] = 0;
+    
+    // Handle actions first
+    if (toupper(input[0]) == 'G') {
+        return handle_generate_menu();
+    } else if (toupper(input[0]) == 'B') {
+        return 0; // Back to main menu
+    }
+    
+    // Find matching pad by prefix
+    int selected_pad = -1;
+    for (int i = 0; i < pad_count; i++) {
+        if (strncmp(input, pads[i].chksum, strlen(input)) == 0) {
+            if (selected_pad == -1) {
+                selected_pad = i;
+            } else {
+                // Multiple matches - ambiguous
+                printf("Ambiguous prefix. Multiple matches found.\n");
+                return 1;
+            }
+        }
+    }
+    
+    if (selected_pad == -1) {
+        printf("No pad found matching prefix '%s'\n", input);
+        return 1;
+    }
+    
+    // Show selected pad actions
+    printf("\n=== Pad: %.16s... ===\n", pads[selected_pad].chksum);
+    printf("Size: %s\n", pads[selected_pad].size_str);
+    printf("Used: %s (%.1f%%)\n", pads[selected_pad].used_str, pads[selected_pad].percentage);
+    
+    printf("\nPad Actions:\n");
+    printf(" \033[4mI\033[0mnfo - Show detailed pad information\n");
+    printf(" \033[4mB\033[0mack to pad list\n");
+    printf("\nSelect action: ");
+    
+    char action[10];
+    if (!fgets(action, sizeof(action), stdin)) {
+        printf("Error: Failed to read input\n");
+        return 1;
+    }
+    
+    char action_choice = toupper(action[0]);
+    if (action_choice == 'I') {
+        return show_pad_info(pads[selected_pad].chksum);
+    }
+    
+    // Default: back to pad list (recursive call)
+    return handle_pads_menu();
+}
+
+void get_directory_display(const char* file_path, char* result, size_t result_size) {
+    // Extract directory path from full file path
+    char dir_path[512];
+    char* last_slash = strrchr(file_path, '/');
+    
+    if (last_slash) {
+        size_t dir_len = last_slash - file_path;
+        if (dir_len >= sizeof(dir_path)) {
+            dir_len = sizeof(dir_path) - 1;
+        }
+        strncpy(dir_path, file_path, dir_len);
+        dir_path[dir_len] = '\0';
+    } else {
+        // No directory separator, assume current directory
+        strcpy(dir_path, ".");
+    }
+    
+    // USB Drive Detection and Smart Shortening
+    char* home_dir = getenv("HOME");
+    
+    // Check for USB/removable media mount patterns
+    if (strstr(dir_path, "/media/") || strstr(dir_path, "/run/media/") || strstr(dir_path, "/mnt/")) {
+        // Extract USB label/name
+        char* media_start = NULL;
+        if (strstr(dir_path, "/media/")) {
+            media_start = strstr(dir_path, "/media/");
+        } else if (strstr(dir_path, "/run/media/")) {
+            media_start = strstr(dir_path, "/run/media/");
+        } else if (strstr(dir_path, "/mnt/")) {
+            media_start = strstr(dir_path, "/mnt/");
+        }
+        
+        if (media_start) {
+            // Find the USB label part
+            char* path_after_media = strchr(media_start + 1, '/');
+            if (path_after_media) {
+                path_after_media++; // Skip the slash
+                
+                // For /run/media/user/LABEL pattern, skip the username
+                if (strstr(media_start, "/run/media/")) {
+                    char* next_slash = strchr(path_after_media, '/');
+                    if (next_slash) {
+                        path_after_media = next_slash + 1;
+                    }
+                }
+                
+                // Extract just the USB label (up to next slash or end)
+                char* label_end = strchr(path_after_media, '/');
+                if (label_end) {
+                    size_t label_len = label_end - path_after_media;
+                    if (label_len > 11) label_len = 11; // Max 11 chars for display
+                    strncpy(result, path_after_media, label_len);
+                    result[label_len] = '\0';
+                } else {
+                    // USB label is the last part
+                    strncpy(result, path_after_media, result_size - 1);
+                    result[result_size - 1] = '\0';
+                }
+                return;
+            }
+        }
+    }
+    
+    // Home directory shortening
+    if (home_dir && strncmp(dir_path, home_dir, strlen(home_dir)) == 0) {
+        if (dir_path[strlen(home_dir)] == '/' || dir_path[strlen(home_dir)] == '\0') {
+            // Replace home directory with ~
+            char temp[512];
+            snprintf(temp, sizeof(temp), "~%s", dir_path + strlen(home_dir));
+            
+            // If result is too long, truncate intelligently
+            if (strlen(temp) > 11) {
+                // Show ~/...end_part
+                char* last_part = strrchr(temp, '/');
+                if (last_part && strlen(last_part) < 8) {
+                    snprintf(result, result_size, "~...%s", last_part);
+                } else {
+                    strncpy(result, temp, 11);
+                    result[11] = '\0';
+                }
+            } else {
+                strncpy(result, temp, result_size - 1);
+                result[result_size - 1] = '\0';
+            }
+            return;
+        }
+    }
+    
+    // Current working directory
+    if (strcmp(dir_path, ".") == 0 || strcmp(dir_path, PADS_DIR) == 0) {
+        strncpy(result, "pads", result_size - 1);
+        result[result_size - 1] = '\0';
+        return;
+    }
+    
+    // System/other paths - smart truncation with ellipsis
+    if (strlen(dir_path) > 11) {
+        // Try to show the most meaningful part
+        char* last_part = strrchr(dir_path, '/');
+        if (last_part && strlen(last_part) < 9) {
+            // Show .../last_part
+            snprintf(result, result_size, "...%s", last_part);
+        } else {
+            // Show first part with ellipsis
+            strncpy(result, dir_path, 8);
+            strncpy(result + 8, "...", result_size - 8 - 1);
+            result[result_size - 1] = '\0';
+        }
+    } else {
+        // Short enough, use as-is
+        strncpy(result, dir_path, result_size - 1);
+        result[result_size - 1] = '\0';
+    }
+}
+
 void print_usage(const char* program_name) {
     printf("OTP Cipher - One Time Pad Implementation %s\n", get_version());
     printf("%s\n", get_build_info());