FlippyPass/project/backend/manager.c

// Header
#include "manager.h"

// Functions - Private
void manager_loadnames(Manager* manager){
    // Loading the names of all passwords
    char* data = secure_storage_load(manager->secure_storage, Store_File_Path_Data, "Data");

    // Do we not have any passwords?
    if (!data) {
        // DEBUG
        FURI_LOG_D(TAG, "No passwords found.");

        // Creating names
        manager->names = malloc(sizeof(char*));

        // Returning
        return;
    }

    // Splitting string
    int count = 0;
    char** split = split_string(data, F_DELIMITER, &count);

    // Freeing data
    free(data);

    // Passwords
    /* 
        Doing some risky bitshifting in order to divide by 4 
        This little ARMv7 processor would hate division
    */
    int num_of_passwords = count >> 2;

    // Allocating memory for names array
    manager->names = malloc(num_of_passwords * sizeof(char*));

    // Going through split string
    for (int i = 0; i < count; i++) {
        // Checking if it's the 4th number
        if (i % 4 == 0) {
            // Adding it to the array!
            manager->names[manager->count] = split[i];

            // It's another password!
            manager->count++;
        }
    }

    // Cleanup
    free(split);
}

// Constructors
Manager* manager_init(char* key) {
    // Creating result in memory
    Manager* result = malloc(sizeof(Manager));

    // Setting variables
    result->secure_storage = secure_storage_init(key);
    result->count = 0;

    // Loading all names on start
    manager_loadnames(result);

    // Returning manager
    return result;
}

// Functions
void manager_savepass(Manager* manager, Password* pass) {
    // Our resulting string
    char* result = secure_storage_load(manager->secure_storage, Store_File_Path_Data, "Data");

    // Is the result empty?
    if(!result) {
        // Allocating result
        FuriString* n_result = furi_string_alloc();

        // Setting stuff
        furi_string_printf(n_result, "%s%c%s%c%s%c0", 
            pass->name, F_DELIMITER, 
            pass->user, F_DELIMITER, 
            pass->phrase, F_DELIMITER);

        // Saving the data
        char* data = malloc(sizeof(char) * furi_string_size(n_result));
        strcpy(data, furi_string_get_cstr(n_result));
        secure_storage_save(manager->secure_storage, Store_File_Path_Data, "Data", data);

        // Cleanup
        furi_string_free(n_result);
        free(data);
    } else {
        // New result
        FuriString* new_result = furi_string_alloc();

        // Appending addon to result
        furi_string_printf(new_result, "%s%c%s%c%s%c%s%c0", 
            result, F_DELIMITER,
            pass->name, F_DELIMITER,
            pass->user, F_DELIMITER,
            pass->phrase, F_DELIMITER);

        // Saving the data
        char* data = malloc(sizeof(char) * furi_string_size(new_result));
        strcpy(data, furi_string_get_cstr(new_result));
        secure_storage_save(manager->secure_storage, Store_File_Path_Data, "Data", data);

        // Cleanup
        furi_string_free(new_result);
        free(result);
        free(data);
    }

    // Freeing password
    pass_free(pass);
}
void manager_loadpass(Manager* manager, char* name) {
    // Freeing previous password
    if (manager->current != NULL) {
        free(manager->current);
    }

    // DEBUG
    FURI_LOG_D(TAG, "Loading password of name %s", name);

    // Loading password string
    char* data = secure_storage_load(manager->secure_storage, Store_File_Path_Data, "Data");

    // Splitting string
    int count = 0;
    char** split = split_string(data, F_DELIMITER, &count);

    // Unloading data
    free(data);

    // Going through string to grab data
    for(int i = 0; i < count; i++) {
        // Is it a multiple of four?
        if (i % 4 == 0) {
            // Does the password name match?
            if (!strcmp(name, split[i])) {
                // Setting the new current password
                manager->current = pass_init(
                    name, 
                    split[i+1], 
                    split[i+2], 
                    0);

                // Break!
                break;
            }
        }
    }

    // Cleanup
    free(split);
}
void manager_free(Manager* manager) {
    for(int i = 0; i < manager->count; i++) {
        free(manager->names[i]);
    }

    free(manager->current);
    free(manager->new);
    free(manager);
}