Version v0.2.67 - Enhanced UI - added Q for quit and improved pad generation flow

otp.c

@@ -39,15 +39,21 @@ 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
 
+// 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[]);
 
+// 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);
 char* get_preferred_file_manager(void);
@@ -109,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 {
@@ -117,41 +132,42 @@ 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)) {
+        if (!fgets(input, sizeof(input), stdin)) {
-            char choice = toupper(input[0]);
+            printf("Goodbye!\n");
-            
+            break;
-            switch (choice) {
+        }
-                case 'T':
+        
-                    handle_text_encrypt();
+        char choice = toupper(input[0]);
-                    break;
+        
-                case 'F':
+        switch (choice) {
-                    handle_file_encrypt();
+            case 'T':
-                    break;
+                handle_text_encrypt();
-                case 'D':
+                break;
-                    handle_decrypt_menu();
+            case 'F':
-                    break;
+                handle_file_encrypt();
-                case 'P':
+                break;
-                    handle_pads_menu();
+            case 'D':
-                    break;
+                handle_decrypt_menu();
-                case 'X':
+                break;
-                case 'Q':
+            case 'P':
-                    printf("Goodbye!\n");
+                handle_pads_menu();
-                    return 0;
+                break;
-                default:
+            case 'X':
-                    printf("Invalid option. Please select T, F, D, P, or X.\n");
+            case 'Q':
-                    continue;
+                printf("Goodbye!\n");
-            }
+                return 0;
-        } else {
+            default:
-            printf("Error reading input. Please try again.\n");
+                printf("Invalid choice. Please try again.\n");
-            continue;
+                break;
         }
-        printf("\n");
     }
+    
+    return 0;
 }
 
 int command_line_mode(int argc, char* argv[]) {
@@ -632,9 +648,9 @@ uint64_t parse_size_string(const char* size_str) {
 }
 
 char* find_pad_by_prefix(const char* prefix) {
-    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 NULL;
     }
     
@@ -668,10 +684,9 @@ char* find_pad_by_prefix(const char* prefix) {
             int current = 0;
             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) {
@@ -732,9 +747,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;
     }
     
@@ -753,8 +768,8 @@ int list_available_pads(void) {
             chksum[64] = '\0';
             
             // Get pad file size
-            char full_path[300]; // Increased buffer size to accommodate longer paths
+            char full_path[1024]; // Increased buffer size to accommodate longer paths
-            snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
+            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
@@ -1113,10 +1128,39 @@ int generate_pad_with_entropy(uint64_t size_bytes, int display_progress, int use
     // Get final paths in pads directory
     get_pad_path(chksum_hex, pad_path, state_path);
     
+    // Try rename first (works for same filesystem)
     if (rename(temp_filename, pad_path) != 0) {
-        printf("Error: Cannot move pad file to pads directory\n");
+        // If rename fails, try copy and delete (works across filesystems)
+        FILE* temp_file = fopen(temp_filename, "rb");
+        FILE* dest_file = fopen(pad_path, "wb");
+        
+        if (!temp_file || !dest_file) {
+            printf("Error: Cannot copy pad file to pads directory\n");
+            if (temp_file) fclose(temp_file);
+            if (dest_file) fclose(dest_file);
+            unlink(temp_filename);
+            return 1;
+        }
+        
+        // Copy file in chunks
+        unsigned char copy_buffer[64 * 1024];
+        size_t bytes_read;
+        while ((bytes_read = fread(copy_buffer, 1, sizeof(copy_buffer), temp_file)) > 0) {
+            if (fwrite(copy_buffer, 1, bytes_read, dest_file) != bytes_read) {
+                printf("Error: Failed to copy pad file to pads directory\n");
+                fclose(temp_file);
+                fclose(dest_file);
+                unlink(temp_filename);
+                unlink(pad_path);
+                return 1;
+            }
+        }
+        
+        fclose(temp_file);
+        fclose(dest_file);
+        
+        // Remove temporary file after successful copy
         unlink(temp_filename);
-        return 1;
     }
     
     // Set pad file to read-only
@@ -2081,8 +2125,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];
+    char state_filename[1024];
-    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
+    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
     
     FILE* state_file = fopen(state_filename, "rb");
     if (!state_file) {
@@ -2101,8 +2145,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];
+    char state_filename[1024];
-    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", PADS_DIR, pad_chksum);
+    snprintf(state_filename, sizeof(state_filename), "%s/%s.state", current_pads_dir, pad_chksum);
     
     FILE* state_file = fopen(state_filename, "wb");
     if (!state_file) {
@@ -2243,8 +2287,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 (stat(current_pads_dir, &st) == -1) {
-        if (mkdir(PADS_DIR, 0755) != 0) {
+        if (mkdir(current_pads_dir, 0755) != 0) {
             return 1;
         }
     }
@@ -2275,10 +2319,102 @@ 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(pad_path, 1024, "%s/%s.pad", current_pads_dir, chksum);
-    snprintf(state_path, MAX_HASH_LENGTH + 20, "%s/%s.state", PADS_DIR, chksum);
+    snprintf(state_path, 1024, "%s/%s.state", current_pads_dir, chksum);
 }
 
+// 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};
+    
+    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) {
+            if (mount_entry->d_name[0] == '.') continue;
+            
+            char mount_path[512];
+            snprintf(mount_path, sizeof(mount_path), "%s/%s", mount_dirs[mount_idx], mount_entry->d_name);
+            
+            // 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) {
+                    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(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(user_dir);
+            } else {
+                // 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(mount_dir);
+    }
+    
+    return 0; // No OTP drive found
+}
+
+
 
 
 // Custom base64 encode function
@@ -2832,10 +2968,10 @@ int handle_file_encrypt(void) {
 int handle_pads_menu(void) {
     printf("\n=== Pad Management ===\n");
     
-    // Get list of all pads
+    // Get list of pads from current directory
-    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 1;
     }
     
@@ -2845,6 +2981,7 @@ int handle_pads_menu(void) {
         char size_str[32];
         char used_str[32];
         double percentage;
+        char location[256];  // Store location info
     };
     
     struct PadInfo pads[100];  // Support up to 100 pads
@@ -2858,8 +2995,8 @@ int handle_pads_menu(void) {
             pads[pad_count].chksum[64] = '\0';
             
             // Get pad file size and usage info
-            char full_path[300];
+            char full_path[512];
-            snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name);
+            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
@@ -2891,6 +3028,9 @@ int handle_pads_menu(void) {
                 // Calculate percentage
                 pads[pad_count].percentage = (double)used_bytes / st.st_size * 100.0;
                 
+                // Set location info using directory display
+                get_directory_display(full_path, pads[pad_count].location, sizeof(pads[pad_count].location));
+                
                 pad_count++;
             }
         }
@@ -2906,10 +3046,15 @@ int handle_pads_menu(void) {
         
         char input[10];
         if (fgets(input, sizeof(input), stdin)) {
-            char choice = toupper(input[0]);
+        char choice = toupper(input[0]);
-            if (choice == 'G') {
+        if (choice == 'G') {
-                return handle_generate_menu();
+            int result = handle_generate_menu();
+            if (result == 0) {
+                // After successful pad generation, return to pads menu
+                return handle_pads_menu();
             }
+            return result;
+        }
         }
         return 0;
     }
@@ -2950,17 +3095,15 @@ int handle_pads_menu(void) {
     printf("%-8s %-12s %-12s %-12s %-8s\n", "--------", "------------", "----------", "----------", "------");
     
     for (int i = 0; i < pad_count; i++) {
-        // Get directory information for this pad
-        char full_path[300];
-        snprintf(full_path, sizeof(full_path), "%s/%s.pad", PADS_DIR, pads[i].chksum);
-        char dir_display[13]; // 12 chars + null terminator
-        get_directory_display(full_path, dir_display, sizeof(dir_display));
-        
         // Display first 8 characters of checksum with prefix underlined
-        printf("\033[4m%.*s\033[0m%-*s %-12s %-12s %-12s %.1f%%\n",
+        char checksum_8char[9];
-               prefix_lengths[i], pads[i].chksum,  // Underlined prefix
+        strncpy(checksum_8char, pads[i].chksum, 8);
-               8 - prefix_lengths[i], pads[i].chksum + prefix_lengths[i], // Rest of 8-char checksum
+        checksum_8char[8] = '\0';
-               dir_display,
+        
+        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);
@@ -2980,7 +3123,12 @@ int handle_pads_menu(void) {
     
     // Handle actions first
     if (toupper(input[0]) == 'G') {
-        return handle_generate_menu();
+        int result = handle_generate_menu();
+        if (result == 0) {
+            // After successful pad generation, return to pads menu
+            return handle_pads_menu();
+        }
+        return result;
     } else if (toupper(input[0]) == 'B') {
         return 0; // Back to main menu
     }
@@ -3067,8 +3215,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;
@@ -3077,15 +3232,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
+                    if (label_len > sizeof(usb_label) - 1) label_len = sizeof(usb_label) - 1;
-                    strncpy(result, path_after_media, label_len);
+                    strncpy(usb_label, path_after_media, label_len);
-                    result[label_len] = '\0';
+                    usb_label[label_len] = '\0';
                 } else {
                     // USB label is the last part
-                    strncpy(result, path_after_media, result_size - 1);
+                    strncpy(usb_label, path_after_media, sizeof(usb_label) - 1);
-                    result[result_size - 1] = '\0';
+                    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;
             }
@@ -3118,7 +3281,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;