Version v0.2.65 - Improved USB drive directory display with USB: prefix and proper drive name

otp.c

@@ -39,29 +39,20 @@ static const int base64_decode_table[256] = {
 #define MAX_LINE_LENGTH 1024
 #define MAX_HASH_LENGTH 65
 #define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
-#define PADS_DIR "pads"
+#define DEFAULT_PADS_DIR "pads"
 #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
-};
+// Global variable for current pads directory (can be local or OTP thumb drive)
+static char current_pads_dir[512] = DEFAULT_PADS_DIR;
 
 // 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);
+// OTP thumb drive detection function
+int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size);
 
 // Editor and file manager functions
 char* get_preferred_editor(void);
@@ -124,6 +115,15 @@ void get_directory_display(const char* file_path, char* result, size_t result_si
 void print_usage(const char* program_name);
 
 int main(int argc, char* argv[]) {
+    // Check for OTP thumb drive on startup
+    char otp_drive_path[512];
+    if (detect_otp_thumb_drive(otp_drive_path, sizeof(otp_drive_path))) {
+        printf("Detected OTP thumb drive: %s\n", otp_drive_path);
+        printf("Using as default pads directory for this session.\n\n");
+        strncpy(current_pads_dir, otp_drive_path, sizeof(current_pads_dir) - 1);
+        current_pads_dir[sizeof(current_pads_dir) - 1] = '\0';
+    }
+    
     if (argc == 1) {
         return interactive_mode();
     } else {
@@ -132,41 +132,41 @@ int main(int argc, char* argv[]) {
 }
 
 int interactive_mode(void) {
-    // printf("\n\n\n\n=== OTP Cipher %s ===\n\n", get_version());
+    char input[10];
     
     while (1) {
         show_main_menu();
-        char input[10];
-        if (fgets(input, sizeof(input), stdin)) {
-            char choice = toupper(input[0]);
         
-            switch (choice) {
-                case 'T':
-                    handle_text_encrypt();
-                    break;
-                case 'F':
-                    handle_file_encrypt();
-                    break;
-                case 'D':
-                    handle_decrypt_menu();
-                    break;
-                case 'P':
-                    handle_pads_menu();
-                    break;
-                case 'X':
-                case 'Q':
-                    printf("Goodbye!\n");
-                    return 0;
-                default:
-                    printf("Invalid option. Please select T, F, D, P, or X.\n");
-                    continue;
-            }
-        } else {
-            printf("Error reading input. Please try again.\n");
-            continue;
+        if (!fgets(input, sizeof(input), stdin)) {
+            printf("Goodbye!\n");
+            break;
+        }
+        
+        char choice = toupper(input[0]);
+        
+        switch (choice) {
+            case 'T':
+                handle_text_encrypt();
+                break;
+            case 'F':
+                handle_file_encrypt();
+                break;
+            case 'D':
+                handle_decrypt_menu();
+                break;
+            case 'P':
+                handle_pads_menu();
+                break;
+            case 'X':
+                printf("Goodbye!\n");
+                return 0;
+            default:
+                printf("Invalid choice. Please try again.\n");
+                break;
         }
-        printf("\n");
     }
+    
+    return 0;
 }
 
 int command_line_mode(int argc, char* argv[]) {
@@ -647,25 +647,19 @@ 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);
+    DIR* dir = opendir(current_pads_dir);
     if (!dir) {
-        printf("Error: Cannot open pads directory\n");
-        free_usb_pads(usb_pads, usb_count);
+        printf("Error: Cannot open pads directory %s\n", current_pads_dir);
         return NULL;
     }
     
     struct dirent* entry;
-    char* matches[200];  // Store up to 200 matches (local + USB)
+    char* matches[100];  // Store up to 100 matches
     int match_count = 0;
     
-    // Always try hex prefix matching first on local pads
+    // Always try hex prefix matching first
     size_t prefix_len = strlen(prefix);
-    while ((entry = readdir(dir)) != NULL && match_count < 200) {
+    while ((entry = readdir(dir)) != NULL && match_count < 100) {
         // Skip . and .. entries, and only process .pad files
         if (entry->d_name[0] == '.') continue;
         if (!strstr(entry->d_name, ".pad")) continue;
@@ -680,35 +674,13 @@ 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 <= 200) {
-            // It's a number, find the nth pad (counting local + USB)
+        if (*endptr == '\0' && selection > 0 && selection <= 100) {
+            // It's a number, find the nth pad
             int current = 0;
-            
-            // Count local pads first
             rewinddir(dir);
             while ((entry = readdir(dir)) != NULL) {
                 if (entry->d_name[0] == '.') continue;
@@ -724,45 +696,10 @@ 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);
@@ -809,9 +746,9 @@ char* find_pad_by_prefix(const char* prefix) {
 }
 
 int list_available_pads(void) {
-    DIR* dir = opendir(PADS_DIR);
+    DIR* dir = opendir(current_pads_dir);
     if (!dir) {
-        printf("Error: Cannot open pads directory\n");
+        printf("Error: Cannot open pads directory %s\n", current_pads_dir);
         return 0;
     }
     
@@ -830,8 +767,8 @@ int list_available_pads(void) {
             chksum[64] = '\0';
             
             // Get pad file size
-            char full_path[300]; // Increased buffer size to accommodate longer paths
-            snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
+            char full_path[1024]; // Increased buffer size to accommodate longer paths
+            snprintf(full_path, sizeof(full_path), "%s/%s", current_pads_dir, entry->d_name);
             struct stat st;
             if (stat(full_path, &st) == 0) {
                 // Get used bytes from state
@@ -2158,8 +2095,8 @@ int decrypt_ascii_file(const char* input_file, const char* output_file) {
 }
 
 int read_state_offset(const char* pad_chksum, uint64_t* offset) {
-    char state_filename[MAX_HASH_LENGTH + 20];
-    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
+    char state_filename[1024];
+    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
     
     FILE* state_file = fopen(state_filename, "rb");
     if (!state_file) {
@@ -2178,8 +2115,8 @@ int read_state_offset(const char* pad_chksum, uint64_t* offset) {
 }
 
 int write_state_offset(const char* pad_chksum, uint64_t offset) {
-    char state_filename[MAX_HASH_LENGTH + 20];
-    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
+    char state_filename[1024];
+    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
     
     FILE* state_file = fopen(state_filename, "wb");
     if (!state_file) {
@@ -2320,8 +2257,8 @@ int collect_keyboard_entropy(unsigned char* entropy_buffer, size_t max_size, siz
 // Directory management functions
 int ensure_pads_directory(void) {
     struct stat st = {0};
-    if (stat(PADS_DIR, &st) == -1) {
-        if (mkdir(PADS_DIR, 0755) != 0) {
+    if (stat(current_pads_dir, &st) == -1) {
+        if (mkdir(current_pads_dir, 0755) != 0) {
             return 1;
         }
     }
@@ -2352,196 +2289,101 @@ void get_default_file_path(const char* filename, char* result_path, size_t resul
 }
 
 void get_pad_path(const char* chksum, char* pad_path, char* state_path) {
-    snprintf(pad_path, MAX_HASH_LENGTH + 20, "%s/%s.pad", PADS_DIR, chksum);
-    snprintf(state_path, MAX_HASH_LENGTH + 20, "%s/%s.state", PADS_DIR, chksum);
+    snprintf(pad_path, 1024, "%s/%s.pad", current_pads_dir, chksum);
+    snprintf(state_path, 1024, "%s/%s.state", current_pads_dir, chksum);
 }
 
-// USB drive detection functions implementation
-int scan_usb_drives_for_pads(struct USBPadInfo** usb_pads, int* usb_count) {
+// OTP thumb drive detection function implementation
+int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size) {
     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) {
+        while ((mount_entry = readdir(mount_dir)) != NULL) {
             if (mount_entry->d_name[0] == '.') continue;
             
-            char mount_path[1024];
+            char mount_path[512];
             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) {
+            // For /media, we need to go one level deeper (user directories)
+            if (strcmp(mount_dirs[mount_idx], "/media") == 0) {
+                // This is /media/[username] - look inside for drives
                 DIR* user_dir = opendir(mount_path);
                 if (!user_dir) continue;
                 
                 struct dirent* user_entry;
-                while ((user_entry = readdir(user_dir)) != NULL && count < 100) {
+                while ((user_entry = readdir(user_dir)) != NULL) {
                     if (user_entry->d_name[0] == '.') continue;
                     
-                    char user_mount_path[1024];
+                    // Check if drive name starts with "OTP"
+                    if (strncmp(user_entry->d_name, "OTP", 3) != 0) continue;
+                    
+                    char user_mount_path[512];
                     snprintf(user_mount_path, sizeof(user_mount_path), "%s/%s", mount_path, user_entry->d_name);
                     
-                    // Scan this mount point for pads
+                    // Check if this is a readable directory
                     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++;
-                            }
-                        }
+                    if (drive_dir) {
+                        closedir(drive_dir);
+                        strncpy(otp_drive_path, user_mount_path, path_size - 1);
+                        otp_drive_path[path_size - 1] = '\0';
+                        closedir(user_dir);
+                        closedir(mount_dir);
+                        return 1; // Found OTP drive
+                    }
+                }
+                closedir(user_dir);
+            } else if (strcmp(mount_dirs[mount_idx], "/run/media") == 0) {
+                // For /run/media, we need to go one level deeper (skip username)
+                DIR* user_dir = opendir(mount_path);
+                if (!user_dir) continue;
+                
+                struct dirent* user_entry;
+                while ((user_entry = readdir(user_dir)) != NULL) {
+                    if (user_entry->d_name[0] == '.') continue;
+                    
+                    // Check if drive name starts with "OTP"
+                    if (strncmp(user_entry->d_name, "OTP", 3) != 0) continue;
+                    
+                    char user_mount_path[512];
+                    snprintf(user_mount_path, sizeof(user_mount_path), "%s/%s", mount_path, user_entry->d_name);
+                    
+                    // Check if this is a readable directory
+                    DIR* drive_dir = opendir(user_mount_path);
+                    if (drive_dir) {
+                        closedir(drive_dir);
+                        strncpy(otp_drive_path, user_mount_path, path_size - 1);
+                        otp_drive_path[path_size - 1] = '\0';
+                        closedir(user_dir);
+                        closedir(mount_dir);
+                        return 1; // Found OTP drive
                     }
-                    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[512], state_path[512];
-                        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++;
-                        }
+                // Direct mount point (like /mnt/OTP_DRIVE)
+                // Check if drive name starts with "OTP"
+                if (strncmp(mount_entry->d_name, "OTP", 3) == 0) {
+                    DIR* drive_dir = opendir(mount_path);
+                    if (drive_dir) {
+                        closedir(drive_dir);
+                        strncpy(otp_drive_path, mount_path, path_size - 1);
+                        otp_drive_path[path_size - 1] = '\0';
+                        closedir(mount_dir);
+                        return 1; // Found OTP drive
                     }
                 }
-                closedir(drive_dir);
             }
         }
         closedir(mount_dir);
     }
     
-    *usb_pads = pads;
-    *usb_count = count;
-    return 0;
+    return 0; // No OTP drive found
 }
 
-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) {
-    uint64_t max_offset = local_offset;
-    int conflicts_found = 0;
-    char local_path[512];
-    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);
-    }
-}
 
 
 
@@ -3095,59 +2937,42 @@ 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);
+    // Get list of pads from current directory
+    DIR* dir = opendir(current_pads_dir);
     if (!dir) {
-        printf("Error: Cannot open pads directory\n");
-        free_usb_pads(usb_pads, usb_count);
+        printf("Error: Cannot open pads directory %s\n", current_pads_dir);
         return 1;
     }
     
-    // Structure to store combined pad information
+    // Structure to store 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
+        char location[256];  // Store location info
     };
     
-    struct PadInfo pads[200];  // Support up to 200 total pads (local + USB)
+    struct PadInfo pads[100];  // Support up to 100 pads
     int pad_count = 0;
     
-    // First, collect all local pad information
+    // Collect all pad information
     struct dirent* entry;
-    while ((entry = readdir(dir)) != NULL && pad_count < 200) {
+    while ((entry = readdir(dir)) != NULL && pad_count < 100) {
         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);
+            char full_path[512];
+            snprintf(full_path, sizeof(full_path), "%s/%s", current_pads_dir, entry->d_name);
             struct stat st;
             if (stat(full_path, &st) == 0) {
-                // Get used bytes from state (check for conflicts with USB)
+                // Get used bytes from state
                 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);
@@ -3173,9 +2998,8 @@ int handle_pads_menu(void) {
                 // 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;
+                // Set location info using directory display
+                get_directory_display(full_path, pads[pad_count].location, sizeof(pads[pad_count].location));
                 
                 pad_count++;
             }
@@ -3183,59 +3007,6 @@ int handle_pads_menu(void) {
     }
     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");
@@ -3404,8 +3175,15 @@ void get_directory_display(const char* file_path, char* result, size_t result_si
             if (path_after_media) {
                 path_after_media++; // Skip the slash
                 
+                // For /media/user/LABEL pattern, skip the username to get to the drive label
+                if (strstr(media_start, "/media/")) {
+                    char* next_slash = strchr(path_after_media, '/');
+                    if (next_slash) {
+                        path_after_media = next_slash + 1;
+                    }
+                }
                 // For /run/media/user/LABEL pattern, skip the username
-                if (strstr(media_start, "/run/media/")) {
+                else if (strstr(media_start, "/run/media/")) {
                     char* next_slash = strchr(path_after_media, '/');
                     if (next_slash) {
                         path_after_media = next_slash + 1;
@@ -3414,15 +3192,23 @@ void get_directory_display(const char* file_path, char* result, size_t result_si
                 
                 // Extract just the USB label (up to next slash or end)
                 char* label_end = strchr(path_after_media, '/');
+                char usb_label[32];
                 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';
+                    if (label_len > sizeof(usb_label) - 1) label_len = sizeof(usb_label) - 1;
+                    strncpy(usb_label, path_after_media, label_len);
+                    usb_label[label_len] = '\0';
                 } else {
                     // USB label is the last part
-                    strncpy(result, path_after_media, result_size - 1);
-                    result[result_size - 1] = '\0';
+                    strncpy(usb_label, path_after_media, sizeof(usb_label) - 1);
+                    usb_label[sizeof(usb_label) - 1] = '\0';
+                }
+                
+                // Format with USB: prefix, limiting total length to fit in result
+                snprintf(result, result_size, "USB:%s", usb_label);
+                // Truncate if too long
+                if (strlen(result) > 11) {
+                    result[11] = '\0';
                 }
                 return;
             }
@@ -3455,7 +3241,7 @@ void get_directory_display(const char* file_path, char* result, size_t result_si
     }
     
     // Current working directory
-    if (strcmp(dir_path, ".") == 0 || strcmp(dir_path, PADS_DIR) == 0) {
+    if (strcmp(dir_path, ".") == 0 || strcmp(dir_path, current_pads_dir) == 0) {
         strncpy(result, "pads", result_size - 1);
         result[result_size - 1] = '\0';
         return;