/*

 * main.cpp

 * 

 * This is the shadowfuse main startup file.

 *

 * Autor: Oliver Maurhart, <oliver.maurhart@ait.ac.at>

 *

 * Copyright (C) 2013 AIT Austrian Institute of Technology

 * AIT Austrian Institute of Technology GmbH

 * Donau-City-Strasse 1 | 1220 Vienna | Austria

 * http://www.ait.ac.at

 *

 * 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 version 2.

 * 

 * 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., 51 Franklin Street, Fifth Floor, 

 * Boston, MA  02110-1301, USA.

 */

// ------------------------------------------------------------

// incs

#include "baseinc.h"

// ------------------------------------------------------------

// defs

/**

 * shadowfuse version

 */

#define SHADOWFUSE_VERSION  "0.1"

// ------------------------------------------------------------

// vars

/**

 * keys for FUSE_OPT_ options 

 */

enum {

   KEY_VERSION,

   KEY_HELP,

};

/**

 * array of options we know

 */

static struct fuse_opt shadowfuse_opts[] = {

    FUSE_OPT_KEY("-V",             KEY_VERSION),

    FUSE_OPT_KEY("--version",      KEY_VERSION),

    FUSE_OPT_KEY("-h",             KEY_HELP),

    FUSE_OPT_KEY("--help",         KEY_HELP),

    FUSE_OPT_END

};

/**

 * configuration of shadowfuse

 */

static struct shadowfuse_config {

    std::string sShadowedPath;

    std::string sMountPoint;

    /**

     * check for paths been set

     */

    inline bool is_paths_set() const { return !(sShadowedPath.empty() || sMountPoint.empty()); };

} g_cShadowFuseConfig;

// ------------------------------------------------------------

// fwd

static int option_processor(void * cData, const char * sArg, int nKey, struct fuse_args * cOutArgs);

static void usage(const char * sProgName);

// ------------------------------------------------------------

// code

/** 

 * get file attributes.

 */

static int shadow_getattr(const char * sPath, struct stat * cFileStat) {

    // open the shadow file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Getting file attributes of " << sShadow << std::endl;

    memset(cFileStat, 0, sizeof(struct stat));

    if (stat(sShadow.c_str(), cFileStat) == -1) return -errno;

    return 0;

}

/** 

 * create a directory 

 */

static int shadow_mkdir(const char * sPath, mode_t cMode) {

    // create directory

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Create directory " << sShadow << std::endl;

    if (mkdir(sShadow.c_str(), cMode) == -1) return -errno;

    return 0;

}

/** 

 * create a file

 */

static int shadow_mknod(const char * sPath, mode_t cMode, dev_t cDev) {

    // create file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Create file " << sShadow << std::endl;

    if (mknod(sShadow.c_str(), cMode, cDev) == -1) return -errno;

    return 0;

}

/**

 * open file

 */

static int shadow_open(const char * sPath, struct fuse_file_info * cFileInfo) {

    // open the shadow file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Opening file " << sShadow << std::endl;

    if (open(sShadow.c_str(), cFileInfo->flags) == -1) return -errno;

    return 0;

}

/**

 * read from file

 */

static int shadow_read(const char * sPath, char * cBuffer, size_t nSize, off_t nOffset, UNUSED struct fuse_file_info * cFileInfo) {

    // read from shadow file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Reading file " << sShadow << " [offset=" << nOffset << ", fetch max bytes=" << nSize << "]" << std::endl;

    // open, pick bytes, close & out

    int fd = open(sShadow.c_str(), O_RDONLY);

    if (fd == -1) return -errno;

    int res = pread(fd, cBuffer, nSize, nOffset);

    if (res == -1) res = -errno;

    close(fd);

    return res;

}

/**

 * read directory

 */

static int shadow_readdir(const char * sPath, void * cBuffer, fuse_fill_dir_t fFiller, UNUSED off_t nOffset, UNUSED struct fuse_file_info * cFileInfo) {

    DIR * cDIR;

    struct dirent * cDirEntry;

    int res = 0;

    // open the shadow folder

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Reading content of " << sShadow << std::endl;

    cDIR = opendir(sShadow.c_str());

    if (!cDIR) return -errno;

    // walk over the entries

    while ((cDirEntry = readdir(cDIR)) != NULL) {

        // pick file stat as well

        struct stat cFileStat;

        stat(sShadow.c_str(), &cFileStat);

        res = fFiller(cBuffer, cDirEntry->d_name, &cFileStat, 0);

         if (res != 0) break;

    }

    // free directory

    closedir(cDIR);

    return res;

}

/**

 * move file

 */

static int shadow_rename(const char * sFromPath, const char * sToPath) {

    // move file

    std::string sShadowFrom = g_cShadowFuseConfig.sShadowedPath + sFromPath;

    std::string sShadowTo = g_cShadowFuseConfig.sShadowedPath + sToPath;

std::cerr << "=== INSERT HOOK HERE. Moving file from " << sShadowFrom << " to " << sShadowTo << std::endl;

    if (rename(sShadowFrom.c_str(), sShadowTo.c_str()) == -1) return -errno;

    return 0;

}

/**

 * delete a folder

 */

static int shadow_rmdir(const char * sPath) {

    // delete the shadow folder

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Delete folder " << sShadow << std::endl;

    if (rmdir(sShadow.c_str()) == -1) return -errno;

    return 0;

}

/**

 * delete a file

 */

static int shadow_unlink(const char * sPath) {

    // delete the shadow file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Delete file " << sShadow << std::endl;

    if (unlink(sShadow.c_str()) == -1) return -errno;

    return 0;

}

/**

 * write int file

 */

static int shadow_write(const char * sPath, const char * cBuffer, size_t nSize, off_t nOffset, UNUSED struct fuse_file_info * cFileInfo) {

    // write into file

    std::string sShadow = g_cShadowFuseConfig.sShadowedPath + sPath;

std::cerr << "=== INSERT HOOK HERE. Write into file " << sShadow << std::endl;

    // open, push bytes, close & out

    int fd = open(sShadow.c_str(), O_WRONLY);

    if (fd == -1) return -errno;

    int res = pwrite(fd, cBuffer, nSize, nOffset);

    if (res == -1) res = -errno;

    close(fd);

    return res;

}

/**

 * the shadowfuse function table

 */

static struct fuse_operations shadowfuse_operations {

    shadow_getattr,     // getattr

    nullptr,            // readlink

    nullptr,            // getdir

    shadow_mknod,       // mknod

    shadow_mkdir,       // mkdir

    shadow_unlink,      // unlink

    shadow_rmdir,       // rmdir

    nullptr,            // symlink

    shadow_rename,      // rename

    nullptr,            // link

    nullptr,            // chmod

    nullptr,            // chown

    nullptr,            // truncate

    nullptr,            // utime

    shadow_open,        // open

    shadow_read,        // read

    shadow_write,       // write

    nullptr,            // statfs

    nullptr,            // flush

    nullptr,            // release

    nullptr,            // fsync

    nullptr,            // setxattr

    nullptr,            // getxattr

    nullptr,            // listxattr

    nullptr,            // removexattr

    nullptr,            // opendir

    shadow_readdir,     // readdir

    nullptr,            // releasedir

    nullptr,            // fsyncdir

    nullptr,            // init

    nullptr,            // destroy

    nullptr,            // access

    nullptr,            // create

    nullptr,            // ftruncate

    nullptr,            // fgetattr

    nullptr,            // lock

    nullptr,            // utimens

    nullptr,            // bmap

    0,                  // flag_nullpath_ok

    0,                  // flag_nopath

    0,                  // flag_utime_omit_ok

    0,                  // flag_reserved

    nullptr,            // ioctl

    nullptr,            // poll

    nullptr,            // write_buf

    nullptr,            // read_buf

    nullptr,            // flock

    nullptr             // fallocate

};

/**

 * start

 * 

 * @param   argc        as usual

 * @param   argv        as usual

 * @return  as usual

 */

int main(int argc, char ** argv) {

    // option parsing

    struct fuse_args cFUSEArgs = FUSE_ARGS_INIT(argc, argv);

    if (fuse_opt_parse(&cFUSEArgs, NULL, shadowfuse_opts, option_processor) == -1) {

        return -1;

    }

    // test if our config is setup ok

    if (!g_cShadowFuseConfig.is_paths_set()) {

        std::cerr << "sourcefolder and/or mount point not given" << std::endl;

        exit(1);

    }

    // do FUSE

    int ret = fuse_main(cFUSEArgs.argc, cFUSEArgs.argv, &shadowfuse_operations, NULL);

    if (ret) printf("\n");

    fuse_opt_free_args(&cFUSEArgs);

    return ret;

}

/**

 * option parser processor

 * 

 * @param   cData       is the user data passed to the fuse_opt_parse() function

 * @param   sArg        is the whole argument or option

 * @param   nKey        determines why the processing function was called

 * @param   cOutArgs    the current output argument list

 * @return  -1 on error, 0 if arg is to be discarded, 1 if arg should be kept

 */

static int option_processor(UNUSED void * cData, UNUSED const char * sArg, int nKey, struct fuse_args * cOutArgs) {

    // select by key

    switch (nKey) {

    case FUSE_OPT_KEY_OPT:

        return 1;

    case FUSE_OPT_KEY_NONOPT:

        // the non-options

        if (g_cShadowFuseConfig.sShadowedPath.empty()) {

            // first non-option is the path to be shadowed

            g_cShadowFuseConfig.sShadowedPath = sArg;

            return 0;

        }

        else

        if (g_cShadowFuseConfig.sMountPoint.empty()) {

            // the mount point

            g_cShadowFuseConfig.sMountPoint = sArg;

            return 1;

        }

        return 1;

    case KEY_HELP:

        usage(cOutArgs->argv[0]);

        exit(1);

    case KEY_VERSION:

        printf("shadowfuse version %s\n", SHADOWFUSE_VERSION);

        exit(0);

    default:

        fprintf(stderr, "internal error\n");

        abort();

    }

}

/**

 * print usage

 * 

 * @param   sProgName       name of the current program

 */

static void usage(const char * sProgName) {

    printf(

"usage: %s sourcefolder mountpoint\n"

"\n"

"general options:\n"

"    -f                     foreground\n"

"    -d   -odebug           foreground, but keep the debug option\n"

"    -h   --help            print help\n"

"    -V   --version         print version\n"

"\n", sProgName);

}