fs_wrapper.c

WiiFuse is a FUSE filesystem module for Linux and Mac OS X. It will let you mount a Wii disc ISO an

/*
 *  Copyright (C) 2008 dhewg, #wiidev efnet
 *
 *  this file is part of wiifuse
 *  http://wiibrew.org/index.php?title=Wiifuse
 *
 *  This program 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.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

#include <gctypes.h>
#include <gccore.h>
#include <ogcsys.h>

#include "../../shared.h"
#include "global.h"
#include "fs_nand.h"

bool wrapper_init (u8 **data, u16 *data_size) {
        return nand_init (data, data_size);
}

bool wrapper_deinit () {
        return nand_deinit ();
}

enum remote_result wrapper_access (struct client_request *request) {
        u8 mode;

        if (!request->data || request->data_size != 1)
                return RES_UNKNOWN;

        mode = request->data[0];

        LOG (2, "access %s 0x%02x", request->filename, mode);

        return nand_access (request->filename, mode);
}

enum remote_result wrapper_getattr (struct client_request *request, u8 **data,
                                    u16 *data_size) {
        enum remote_result res = RES_UNKNOWN;
        struct remote_attr attributes;

        LOG (2, "getattr %s", request->filename);

        memset (&attributes, 0, sizeof (struct remote_attr));

        res = nand_getattr (request->filename, &attributes);

        if (res == RES_OK) {
                *data_size = 17;
                *data = malloc (*data_size);
                memset (*data, 0, *data_size);
                *data[0] = attributes.is_dir;
                put_be32 (*data + 1, attributes.nlink);
                put_be32 (*data + 3, attributes.size);
                put_be32 (*data + 7, attributes.owner);
                put_be32 (*data + 11, attributes.group);
                put_be16 (*data + 15, attributes.perms);
        }

        return res;
}

enum remote_result wrapper_open (struct client_request *request) {
        LOG (2, "open %s", request->filename);

        return nand_open (request->filename);
}

enum remote_result wrapper_read (struct client_request *request, u8 **data,
                                 u16 *data_size) {
        enum remote_result res;
        u16 size;
        u64 offset;

        if (!request->data || request->data_size != 10)
                return RES_UNKNOWN;

        size = get_be16 (request->data);
        offset = get_be64 (&request->data[2]);

        LOG (2, "read %s off=0x%016llx size=0x%04x", request->filename, offset,
             size);

        *data = memalign (32, size);
        memset (*data, 0, size);

        res = nand_read (request->filename, offset, &size, *data);

        if (res == RES_OK)
                *data_size = size;
        else {
                free (*data);
                *data = NULL;
        }

        return res;
}

enum remote_result wrapper_opendir (struct client_request *request) {
        LOG (2, "opendir %s", request->filename);

        return nand_opendir (request->filename);
}

enum remote_result wrapper_readdir (struct client_request *request, u8 **data,
                                    u16 *data_size) {
        LOG (2, "readdir %s", request->filename);

        return nand_readdir (request->filename, data, data_size);
}

enum remote_result wrapper_mkdir (struct client_request *request) {
        u16 perms;

        if (!request->data || request->data_size != 2)
                return RES_UNKNOWN;

        perms = get_be16 (request->data);

        LOG (2, "mkdir %s 0%o", request->filename, perms);

        return nand_mkdir (request->filename, perms);
}

enum remote_result wrapper_rmdir (struct client_request *request) {
        LOG (2, "rmdir %s", request->filename);

        return nand_rmdir (request->filename);
}

enum remote_result wrapper_create (struct client_request *request) {
        u16 perms;

        if (!request->data || request->data_size != 2)
                return RES_UNKNOWN;

        perms = get_be16 (request->data);

        LOG (2, "create %s 0%o", request->filename, perms);

        return nand_create (request->filename, perms);
}

enum remote_result wrapper_write (struct client_request *request, u8 **data,
                                  u16 *data_size) {
        enum remote_result res;
        u16 size;
        u64 offset;

        if (!request->data || request->data_size < 10)
                return RES_UNKNOWN;

        size = get_be16 (request->data);
        offset = get_be64 (&request->data[2]);

        LOG (2, "write %s off=0x%016llx size=0x%04x", request->filename,
             offset, size);

        res = nand_write (request->filename, offset, &size, request->data + 10);

        if (res == RES_OK) {
                *data = malloc (8);
                put_be64 (*data, size);
                *data_size = 8;
        }

        return res;
}

enum remote_result wrapper_chown (struct client_request *request) {
        u32 uid, gid;

        if (!request->data || request->data_size != 8)
                return RES_UNKNOWN;

        uid = get_be32 (request->data);
        gid = get_be32 (&(request->data[4]));

        LOG (2, "chown %s uid %u gid %u", request->filename, uid, gid);

        return nand_chown (request->filename, uid, gid);
};

enum remote_result wrapper_chmod (struct client_request *request) {
        u16 perms;

        if (!request->data || request->data_size != 2)
                return RES_UNKNOWN;

        perms = get_be16 (request->data);

        LOG (2, "chmod %s 0%o", request->filename, perms);

        return nand_chmod (request->filename, perms);
}

enum remote_result wrapper_rename (struct client_request *request) {
        char *src, *dst;
        enum remote_result res;

        if (!request->data)
                return RES_UNKNOWN;

        src = memalign (32, strlen (request->filename) + 1);
        strcpy (src, request->filename);

        dst = memalign (32, request->data_size + 1);
        memcpy (dst, request->data, request->data_size);
        dst[request->data_size] = 0;

        LOG (2, "rename %s -> %s", src, dst);

        res = nand_rename (src, dst);

        free (src);
        free (dst);

        return res;
}

enum remote_result wrapper_unlink (struct client_request *request) {
        LOG (2, "unlink %s", request->filename);

        return nand_unlink (request->filename);
}

enum remote_result wrapper_statfs (struct client_request *request, u8 **data,
                                   u16 *data_size) {
        u64 bsize = 0;
        u64 blocks = 0;
        u64 bfree = 0;
        u64 files = 0;
        u64 ffree = 0;

        s32 res;
        u8 *p;

        LOG (2, "statfs %s", request->filename);

        res = nand_statfs (request->filename, &bsize, &blocks, &bfree, &files,
                           &ffree);

        if (res == RES_OK) {
                *data_size = 5 * 8;
                *data = malloc (*data_size);
                p = *data;
                put_be64 (p, bsize);
                p += 8;
                put_be64 (p, blocks);
                p += 8;
                put_be64 (p, bfree);
                p += 8;
                put_be64 (p, files);
                p += 8;
                put_be64 (p, ffree);
        }

        return RES_OK;
}