diff --git a/otp.c b/otp.c index fca9fdd..6071361 100644 --- a/otp.c +++ b/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[512]; // Full path to .pad file + char state_path[512]; // Full path to .state file + char mount_point[256]; // 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); @@ -632,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; @@ -659,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) { - // It's a number, find the nth pad + if (*endptr == '\0' && selection > 0 && selection <= 200) { + // 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) { @@ -682,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); @@ -2279,6 +2356,193 @@ 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[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) { + 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[512]; + 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[512], state_path[512]; + 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[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++; + } + } + } + closedir(drive_dir); + } + } + closedir(mount_dir); + } + + *usb_pads = pads; + *usb_count = count; + return 0; +} + +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); + } +} + // Custom base64 encode function @@ -2831,28 +3095,37 @@ int handle_file_encrypt(void) { int handle_pads_menu(void) { printf("\n=== Pad Management ===\n"); + printf("Scanning for USB drives...\n"); - // Get list of all pads + // 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 pad information + // 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[100]; // Support up to 100 pads + struct PadInfo pads[200]; // Support up to 200 total pads (local + USB) int pad_count = 0; - // Collect all pad information + // First, collect all local pad information struct dirent* entry; - while ((entry = readdir(dir)) != NULL && pad_count < 100) { + 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'; @@ -2862,10 +3135,19 @@ int handle_pads_menu(void) { 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 + // 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); @@ -2891,12 +3173,69 @@ 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; + 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"); @@ -2950,12 +3289,6 @@ 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 char checksum_8char[9]; strncpy(checksum_8char, pads[i].chksum, 8); @@ -2964,7 +3297,7 @@ int handle_pads_menu(void) { 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 - dir_display, + pads[i].location, // Use the stored location info pads[i].size_str, pads[i].used_str, pads[i].percentage);