Subversion Repositories freemyipod

//
//
//    Copyright 2013 user890104
//
//
//    This file is part of emCORE.
//
//    emCORE is free software: you can redistribute it and/or
//    modify it under the terms of the GNU General Public License as
//    published by the Free Software Foundation, either version 2 of the
//    License, or (at your option) any later version.
//
//    emCORE is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//    See the GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.
//
//

#include "global.h"

#include "cache.h"
#include "emcore.h"
#include "util.h"

struct emcore_dir_entry *emcore_dir_entry_cache = NULL;
size_t emcore_dir_cache_length = 0;

void cache_init(void) {
    int32_t datetime = unix_ts_to_fat_time(time(NULL));
#ifdef DEBUG
    fprintf(stderr, "Init cache...\n");
#endif
    emcore_dir_entry_cache = calloc(sizeof(*emcore_dir_entry_cache), 1);

    emcore_dir_entry_cache->name = strdup("/");
    emcore_dir_entry_cache->attributes = 0x10;
    emcore_dir_entry_cache->size = 0x1000;
    emcore_dir_entry_cache->wrtdate = datetime >> 0x10;
    emcore_dir_entry_cache->wrttime = datetime & 0xffff;

    emcore_dir_cache_length = 1;
#ifdef DEBUG
    fprintf(stderr, "Cache init done!\n");
#endif
}

struct emcore_dir_entry *cache_get(const char *name) {
    size_t i;

    for (i = 0; i < emcore_dir_cache_length; ++i) {
#ifdef DEBUG2
        fprintf(stderr, "cache_get: strcmp([%s], [%s]) == %d\n", name, emcore_dir_entry_cache[i].name, strcmp(name, emcore_dir_entry_cache[i].name));
#endif
        if (strcmp(name, emcore_dir_entry_cache[i].name) == 0) {
            return &emcore_dir_entry_cache[i];
        }
    }

    return NULL;
}

void cache_insert(const char *dir_name, const struct emcore_dir_entry *entry) {
#ifdef DEBUG2
    fprintf(stderr, "CACHE INSERT: dir=[%s], entry=[%s]\n", dir_name, entry->name);
#endif
    void *new_ptr;
    struct emcore_dir_entry *cache_entry;
    char *new_name;
    size_t new_name_len = 1;
    
    if (strcmp(entry->name, ".") == 0 || strcmp(entry->name, "..") == 0) {
        return;
    }
    
    new_name_len += strlen(dir_name) + strlen(entry->name);

    if (strcmp(dir_name, "/") != 0) {
        ++new_name_len;
    }

    new_name = calloc(sizeof(char), new_name_len);
    strcat(new_name, dir_name);

    if (strcmp(dir_name, "/") != 0) {
        strcat(new_name, "/");
    }

    strcat(new_name, entry->name);

    if (cache_get(new_name)) {
        free(new_name);
        return;
    }

    new_ptr = realloc(emcore_dir_entry_cache,
        sizeof(*emcore_dir_entry_cache) * (emcore_dir_cache_length + 1));

    if (!new_ptr) {
        free(new_name);
        return;
    }

    emcore_dir_entry_cache = new_ptr;

    cache_entry = malloc(sizeof(*cache_entry));

    if (!cache_entry) {
        free(new_name);
        return;
    }

    memcpy(cache_entry, entry, sizeof(*entry));

    cache_entry->name = new_name;

    memcpy(emcore_dir_entry_cache + emcore_dir_cache_length, cache_entry, sizeof(*cache_entry));
    free(cache_entry);

#ifdef DEBUG
    fprintf(stderr, "Inserting [%s] to cache\n", emcore_dir_entry_cache[emcore_dir_cache_length].name);
#endif
    ++emcore_dir_cache_length;
}

void cache_remove(const char *name) {
    size_t i;
    void *new_ptr;
    
    for (i = 0; i < emcore_dir_cache_length; ++i) {
#ifdef DEBUG2
        fprintf(stderr, "cache_remove: strcmp([%s], [%s]) == %d\n", name, emcore_dir_entry_cache[i].name, strcmp(name, emcore_dir_entry_cache[i].name));
#endif
        if (strcmp(name, emcore_dir_entry_cache[i].name) == 0) {
#ifdef DEBUG2
            fprintf(stderr, "CACHE REMOVE: [%s]\n", name);
#endif
            free(emcore_dir_entry_cache[i].name);
            
            if (i < emcore_dir_cache_length - 1) {
                memcpy(emcore_dir_entry_cache + i, emcore_dir_entry_cache + i + 1, (emcore_dir_cache_length - i - 1) * sizeof(*emcore_dir_entry_cache));
            }
            
            --emcore_dir_cache_length;
            
            new_ptr = realloc(emcore_dir_entry_cache,
                sizeof(*emcore_dir_entry_cache) * (emcore_dir_cache_length));

            if (!new_ptr) {
                return;
            }

            emcore_dir_entry_cache = new_ptr;
        }
    }
}

void cache_destroy(void) {
#ifdef DEBUG
    fprintf(stderr, "Destroying cache...\n");
#endif
    while (emcore_dir_cache_length) {
        free(emcore_dir_entry_cache[--emcore_dir_cache_length].name);
    }

    free(emcore_dir_entry_cache);
#ifdef DEBUG
    fprintf(stderr, "Cache destroyed!\n");
#endif
}

#ifdef DEBUG2
void cache_dump(void) {
    size_t i;

    for (i = 0; i < emcore_dir_cache_length; ++i) {
        fprintf(stderr, "cache_dump: [%s] / attr: 0x%08x / size: %d / startcluster: %d / ts: %lu\n", emcore_dir_entry_cache[i].name, emcore_dir_entry_cache[i].attributes, emcore_dir_entry_cache[i].size, emcore_dir_entry_cache[i].startcluster, fat_time_to_unix_ts(emcore_dir_entry_cache[i].wrttime, emcore_dir_entry_cache[i].wrtdate));
    }
}
#endif