Subversion Repositories freemyipod

//

//

//    Copyright 2011 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 "fuse.h"

#include "util.h"

#include "cache.h"

#include "emcore.h"

int emcorefs_getattr(const char* path, struct stat* stbuf)

{

    int res = 0;

    struct emcore_dir_entry *entry = NULL, curr_entry;

    uint32_t dir_handle;

    char *parent, *filename;

    memset(stbuf, 0, sizeof(*stbuf));

    entry = cache_get(path);

    if (NULL == entry)

    {

        parent = strdup(path);

        dirname(parent);

        filename = basename((char*)path);

        res = emcore_dir_open(&dir_handle, parent);

        if (EMCORE_SUCCESS == res)

        {

            while (1)

            {

                res = emcore_dir_read(&curr_entry, dir_handle);

                if (EMCORE_ERROR_NO_MORE_ENTRIES == res)

                {

                    break;

                }

                if (EMCORE_SUCCESS != res)

                {

                    break;

                }

                cache_insert(parent, &curr_entry);

                if (0 == strcmp(filename, curr_entry.name))

                {

                    entry = malloc(sizeof(*entry));

                    memcpy(entry, &curr_entry, sizeof(curr_entry));

                    break;

                }

            };

            emcore_dir_close(dir_handle);

        }

        free(parent);

    }

    if (NULL == entry) {

        if (EMCORE_ERROR_NO_MORE_ENTRIES == res)

        {

            return -ENOENT;

        }

        return -EIO;

    }

    else

    {

        stbuf->st_uid = getuid();

        stbuf->st_gid = getgid();

        stbuf->st_mtime = fat_time_to_unix_ts(entry->wrttime, entry->wrtdate);

        if (entry->attributes & 0x10)

        {

            stbuf->st_mode = S_IFDIR | 0755;

            stbuf->st_nlink = 2;

            stbuf->st_size = 0x1000;

        }

        else

        {

            stbuf->st_mode = S_IFREG | 0644;

            stbuf->st_nlink = 1;

            stbuf->st_size = entry->size;

        }

    }

    return 0;

}

int emcorefs_opendir(const char* path, struct fuse_file_info* fi)

{

    int res;

    uint32_t handle;

    res = emcore_dir_open(&handle, path);

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    fi->fh = handle;

    return 0;

}

int emcorefs_readdir(const char* path, void* buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* fi)

{

    int res;

    struct emcore_dir_entry entry;

    (void) offset;

    (void) fi;

    if (strcmp(path, "/") == 0)

    {

        filler(buf, ".", NULL, 0);

        filler(buf, "..", NULL, 0);

    }

    while (1)

    {

        res = emcore_dir_read(&entry, fi->fh);

        if (EMCORE_ERROR_NO_MORE_ENTRIES == res)

        {

            break;

        }

        if (EMCORE_SUCCESS != res)

        {

            return -EIO;

        }

        cache_insert(path, &entry);

        filler(buf, entry.name, NULL, 0);

    }

    return 0;

}

int emcorefs_releasedir(const char* path, struct fuse_file_info* fi)

{

    int res;

    uint32_t emcore_errno_value;

    (void)path;

    res = emcore_dir_close(fi->fh);

    if (EMCORE_ERROR_IO == res)

    {

        res = emcore_errno(&emcore_errno_value);

        if (EMCORE_SUCCESS != res)

        {

            return -EIO;

        }

        if (EMCORE_SUCCESS != emcore_errno_value)

        {

            return -emcore_errno_value;

        }

    }

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    return 0;

}

int emcorefs_open(const char* path, struct fuse_file_info* fi)

{

    int res;

    uint32_t handle, emcore_errno_value;

    res = emcore_file_open(&handle, path, fi->flags);

    if (EMCORE_ERROR_IO == res)

    {

        res = emcore_errno(&emcore_errno_value);

        if (EMCORE_SUCCESS != res)

        {

            return -EIO;

        }

        if (EMCORE_SUCCESS != emcore_errno_value)

        {

            return -emcore_errno_value;

        }

    }

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    fi->fh = handle;

    return 0;

}

int emcorefs_read(const char* path, char* buf, uint32_t size, off_t offset, struct fuse_file_info* fi) {

    fprintf(stderr, "FUSE_READ: path=[%s] size=[%d] offset=[%jd] fi->flags=[%d]\n", path, size, offset, fi->flags);

    int res;

    uint32_t emcore_errno_value, addr, nread = size;

    if (!fi->fh)

    {

        return -EIO;

    }

    res = emcore_malloc(&addr, size);

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    do {

        if (offset) {

            res = emcore_file_seek(fi->fh, offset, SEEK_SET);

            if (EMCORE_ERROR_IO == res)

            {

                res = emcore_errno(&emcore_errno_value);

                if (EMCORE_SUCCESS != res)

                {

                    nread = -EIO;

                    break;

                }

                if (EMCORE_SUCCESS != emcore_errno_value)

                {

                    nread = -emcore_errno_value;

                    break;

                }

            }

            if (EMCORE_SUCCESS != res)

            {

                nread = -EIO;

                break;

            }

        }

        res = emcore_file_read(&nread, fi->fh, addr, size);

        if (EMCORE_ERROR_IO == res)

        {

            res = emcore_errno(&emcore_errno_value);

            if (EMCORE_SUCCESS != res)

            {

                nread = -EIO;

                break;

            }

            if (EMCORE_SUCCESS != emcore_errno_value)

            {

                nread = -emcore_errno_value;

                break;

            }

        }

        if (EMCORE_SUCCESS != res)

        {

            nread = -EIO;

            break;

        }

        res = emcore_read(buf, addr, nread);

        if (EMCORE_SUCCESS != res)

        {

            nread = -EIO;

        }

    }

    while(0);

    res = emcore_free(addr);

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    return nread;

}

int emcorefs_release(const char* path, struct fuse_file_info* fi)

{

    int res;

    uint32_t emcore_errno_value;

    (void)path;

    if (!fi->fh)

    {

        return -EIO;

    }

    res = emcore_file_close(fi->fh);

    if (EMCORE_ERROR_IO == res)

    {

        res = emcore_errno(&emcore_errno_value);

        if (EMCORE_SUCCESS != res)

        {

            return -EIO;

        }

        if (EMCORE_SUCCESS != emcore_errno_value)

        {

            return -emcore_errno_value;

        }

    }

    if (EMCORE_SUCCESS != res)

    {

        return -EIO;

    }

    return 0;

}