GDP

/* vim: set ai sw=4 sts=4 ts=4 :*/

#include <iostream>

#include <cstdint>

#include <map>

#include <vector>

#include <string>

#include <assert.h>

#include <fstream>

#include <unistd.h>

#include <dirent.h>

#include <libgen.h>

#include <limits.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include "GDPfs.pb.h"

#include "gdpfs.h"

extern "C" {

        #include <gdp/gdp.h>

        #include <ep/ep_dbg.h>

}

static EP_DBG Dbg = EP_DBG_INIT("gdpfs.util",

                                                "GDP FileSystem: tests/utilities");

// read len bytes to an append-only file, and read

// them back using a read-only file. Returns if the

// read data is equal to the data written.

GdpfsStatus rw_test(const char *logname, size_t len)

{

        char *buf;

        std::string sw, sr;

        bool result;

        uint64_t t1, t2, t3;

        float t_write, t_read;

        ep_dbg_cprintf(Dbg, 2, "performing R/W test with "

                                                        "logname %s, and length %zu\n",

                                                        logname, len);

        buf = new char[len];

        RandData(buf, len, true);

        sw.assign(buf, len);

        t1 =  TimeNS();

        // write data

        ep_dbg_cprintf(Dbg, 2, "Starting to write data.\n");

        GDPFileWO fw(logname);

        fw.Append(sw, true);

        t2 = TimeNS();

        // read data

        ep_dbg_cprintf(Dbg, 2, "Done writing data. Reading now.\n");

        GDPFileROMemMap fr(logname, true);

        sr.assign(fr.data(), fr.length());

        t3 = TimeNS();

        // compare data

        ep_dbg_cprintf(Dbg, 2, "Done reading data. Comparing now.\n");

        result = sw.compare(sr) == 0;

        ep_dbg_cprintf(Dbg, 2, "R/W test result: %d\n", result);

        // calculate timing statistics

        t_write = (t2-t1)/(1000*1000*1000.0);

        t_read = (t3-t2)/(1000*1000*1000.0);

        ep_dbg_cprintf(Dbg, 2, "Writing time: %f; Reading time: %f\n",

                                                                                        t_write, t_read);

        if (result)

                return kSuccess;

        else

                return kFailure;

}

/*

void write_dir(const char *logname, size_t num_entries,

                                                        char **names, char **logs)

{

        int i;

        GDPDir d(logname, GDP_MODE_RA);

        std::string s1, s2;

        for (i=0; i<num_entries; i++)

        {

                s1.clear();

                s2.clear();

                s1.assign(names[i]);

                s2.assign(logs[i]);

                d.add_file(s1, s2);

        }

}

bool dir_test(const char *logname)

{

        int entries = 100;

        char *namebufs[entries], *logs[entries];

        int i=0;

        for (i=0; i<entries; i++) {

                namebufs[i] = new char[9];

                logs[i] = new char[33];

                RandData(namebufs[i], 9);

                RandData(logs[i], 33);

        }

        write_dir(logname, entries, namebufs, logs);

        GDPDir d(logname, GDP_MODE_RO);

        std::map<std::string, std::string>::iterator it;

        for (it=d.dentries_.begin(); it!= d.dentries_.end(); it++)

        {

                std::cout<< it->first << ": " << it->second << "\n";

        }

}

*/

// Simply copy a file from local disk to a given logname.

// This assumes that the logname already exists (and is setup

// to be a file) [Initialized with NewFile]

GdpfsStatus copy_file_to_gdp(const std::string localpath,

                                                                const std::string logname)

{

        std::ifstream f(localpath.c_str(), std::ios::binary|std::ios::ate);

        if (f.fail())

        {

                std::cerr<<"Can't open file "<<localpath<<std::endl;

                return kFailure;

        }

        GDPFileWO g(logname.c_str());

        f.seekg(0, std::ios::end);

        std::streampos size = f.tellg();

        std::vector<char> buffer(size);

        f.seekg(0, std::ios::beg);

        f.read(buffer.data(), size);

        std::string alldata;

        alldata.assign(buffer.data(), size);

        g.Append(alldata, true);

        f.close();

        return kSuccess;

}

// Simply copy a file from a remote log to a local file name

GdpfsStatus copy_file_from_gdp(const std::string logname,

                                                                const std::string localpath)

{

        std::ofstream f(localpath.c_str(), std::ios::binary);

        if (f.fail())

        {

                std::cerr<<"Can't open file "<<localpath<<std::endl;

                return kFailure;

        }

        GDPFileROMemMap g(logname.c_str());

        f.write(g.data(), g.length());

        f.close();

        return kSuccess;

}

// Returns a list of all directories in the vectors "dirs" and

// list of all files in "files"

GdpfsStatus ftw_list_dirs(const std::string path, 

                                                                std::vector<std::string>*dirs,

                                                                std::vector<std::string>*files)

{

        struct stat dir_stat;

        DIR *dp;

        struct dirent *ep;

        stat(path.c_str(), &dir_stat);

        if (!S_ISDIR(dir_stat.st_mode))

        {

                files->push_back(path);

                // early return if this is not a directory.

                return kSuccess;

        }

        else

        {

                dirs->push_back(path);

        }

        dp = opendir(path.c_str());

        if (dp == NULL)

                return kFailure;

        while (ep = readdir(dp))

        {

                if (strcmp(ep->d_name, ".")==0 || strcmp(ep->d_name, "..")==0)

                        continue;

                std::string newname;

                newname.assign(path);

                newname.append("/");

                newname.append(ep->d_name);

                // XXX: error checking.

                ftw_list_dirs(newname, dirs, files);

        }

        // XXX: error checking.

        return kSuccess;

}

// XXX: This needs to be cleaned up. Working with band-aids right now

GdpfsStatus copy_to_gdp(const std::string localpath,

                                                const std::string gdppath, bool recursive=false)

{

        std::string rootlog, path, logname;

        std::string remote, full_remote;

        std::string full_localpath;

        assert (ParsePath(gdppath, &rootlog, &path) == kSuccess);

        GDPDir root(rootlog.c_str(), GDP_MODE_RA);

        char *_tmp = realpath(localpath.c_str(), NULL);

        full_localpath.assign(_tmp);

        char *localpath_copy = strdup(full_localpath.c_str());

        char *localpath_basename = basename(localpath_copy);

        char *localpath_dirname = dirname(localpath_copy);

        // make a copy of path into remote

        remote.assign(path);

        if (gdppath[gdppath.length()-1] == '/')

        {

                // remote destination is a directory, since it ends with a '/'.

                // We need to take this into account

                remote.append("/");

                remote.append(localpath_basename);

        }

        if (root.NameExists(remote))

        {

                ep_dbg_cprintf(Dbg, 2, "Path exists!!!\n");

                return kFailure;

        }

        // check if the source is a file or directory

        struct stat localpath_stat;

        stat(full_localpath.c_str(), &localpath_stat);

        if (S_ISDIR(localpath_stat.st_mode))

        {

                if (!recursive)

                {

                        std::cerr<<"Need recursive option for directories"<<std::endl;

                        return kFailure;

                }

                // First, create the directory

                root.CreateDir(remote);

                // We can't use the available FTW because it does not

                // support passing user-supplied data to the callback

                // function. We really need to pass the GDPDir root to

                // such a callback :(

                // Thus, we are stuck with implementing it on our own.

                std::vector <std::string> dirlist;

                std::vector <std::string> filelist;

                std::vector <std::string>::iterator it;

                ftw_list_dirs(full_localpath, &dirlist, &filelist);

                // some debugging output

                if (ep_dbg_test(Dbg, 23))

                {

                        for (it=dirlist.begin(); it!=dirlist.end(); it++)

                                ep_dbg_printf("Directory: %s\n", it->c_str());

                        for (it=filelist.begin(); it!=filelist.end(); it++)

                                ep_dbg_printf("File: %s\n", it->c_str());

                }

                // Create directories

                for (it=dirlist.begin(); it!=dirlist.end(); it++)

                {

                        full_remote.assign(remote);

                        // full_remote.append("/");

                        full_remote.append(it->substr(full_localpath.length()));

                        ep_dbg_cprintf(Dbg, 11, "Creating directory: %s\n",

                                                                                                        full_remote.c_str());

                        root.CreateDir(full_remote);

                }

                // copy files

                for (it=filelist.begin(); it!=filelist.end(); it++)

                {

                        full_remote.assign(remote);

                        // full_remote.append("/");

                        full_remote.append(it->substr(full_localpath.length()));

                        ep_dbg_cprintf(Dbg, 11, "Copying file %s to %s\n", 

                                                                                        it->c_str(), full_remote.c_str());

                        root.NewFile(full_remote, &logname);

                        copy_file_to_gdp(*it, logname);

                }

        }

        else

        {

                root.NewFile(remote, &logname);

                return copy_file_to_gdp(full_localpath, logname);

        }

}

// XXX: This needs to be cleaned up. Working with band-aids right now

GdpfsStatus copy_from_gdp(const std::string gdppath,

                                        const std::string localpath, bool recursive=false)

{

        std::string rootlog, path, logname;

        std::string basename_, dirname_;

        std::string local, full_local;

        assert (ParsePath(gdppath, &rootlog, &path) == kSuccess);

        GDPDir root(rootlog.c_str(), GDP_MODE_RO);

        // we will need this later to figure out the localpath

        BaseDirName(path, &dirname_, &basename_);

        // make a copy of localpath into local

        local.assign(localpath);

        if (localpath[localpath.length()-1] == '/')

        {

                // local destination is a directory, since it ends with a '/'.

                // We need to take this into account

                local.append(basename_);

        }

        // check if name exists

        if (!root.NameExists(path))

        {

                std::cerr<<"Doesn't exist"<<std::endl;

                return kFailure;

        }

        if (root.GetEntryType(path) == GDPfs::DIR)

        {

                if (!recursive)

                {

                        std::cerr<<"Need recursive option for directories"<<std::endl;

                        return kFailure;

                }

                // Make the local directory first.

                mkdir(local.c_str(), 0777);

                // need to list down all the children. We use GetMatchingPaths

                // instead of GetChildren as a shortcut.

                std::vector<std::string> children;

                std::vector<std::string>::iterator it;

                root.GetMatchingPaths(path, &children);

                for (it=children.begin(); it!=children.end(); it++)

                {

                        full_local.assign(local);

                        //full_local.append("/");

                        full_local.append(it->substr(path.length()));

                        ep_dbg_cprintf(Dbg, 10, "Creating  %s\n", full_local.c_str());

                        if (root.GetEntryType(*it) == GDPfs::DIR)

                        {

                                mkdir(full_local.c_str(), 0777);

                        }

                        else

                        {

                                root.GetEntryLogname(*it, &logname);

                                copy_file_from_gdp(logname, full_local);

                        }

                }

        }

        else

        {

                root.GetEntryLogname(path, &logname);

                return copy_file_from_gdp(logname, local);

        }

}

// XXX: This needs to be cleaned up. Working with band-aids right now

GdpfsStatus ls(const std::string gdpdir, bool fancy=false)

{

        std::string rootlog, path;

        assert (ParsePath(gdpdir, &rootlog, &path) == kSuccess);

        GDPDir root(rootlog.c_str(), GDP_MODE_RO);

        std::vector<std::string> children;

        std::vector<std::string>::iterator it;

        std::string logname, tmp;

        if (path.size()>0 && !root.NameExists(path))

        {

                std::cout<<"No such file"<<std::endl;

                return kInvalidArg;

        }

        root.GetMatchingPaths(path, &children);

        for (it = children.begin(); it != children.end(); it++)

        {

                root.GetEntryLogname(*it, &logname);

                tmp = *it;

                // make sure we really have the correct stuff to show

                assert (tmp.find(path) == 0);

                if (children.size()>1)

                {

                        // now remove the initial parts of our result. This is

                        // to make sure if the user asks `ls gdp://X/1/2`, then

                        // we don't show them 1/2/3/4, but 3/4 instead.

                        // This behavior is somewhat similar to unix `ls`.

                        tmp.erase(0, path.size());

                }

                if (logname.empty())

                {

                        logname.assign("[DIRECTORY]");

                        tmp.append("/");

                }

                if (fancy)

                        std::cout<< "[*] " << tmp << " => " << logname << std::endl;

                else

                        std::cout<< tmp << std::endl;

        }

        return kSuccess;

}

// XXX: This needs to be cleaned up. Working with band-aids right now

GdpfsStatus mkdir_(const std::string gdpdir)

{

        std::string rootlog, path;

        assert (ParsePath(gdpdir, &rootlog, &path) == kSuccess);

        assert (path.length() != 0);

        GDPDir root(rootlog.c_str(), GDP_MODE_RA);

        root.CreateDir(path);

        return kSuccess;

}

// XXX: This needs to be cleaned up. Working with band-aids right now

GdpfsStatus rm(const std::string gdppath, bool recursive=false)

{

        std::string rootlog, path;

        assert (ParsePath(gdppath, &rootlog, &path) == kSuccess);

        assert (path.length() != 0);        // can't delete topdirectory

        GDPDir root(rootlog.c_str(), GDP_MODE_RA);

        // check if name exists

        if (!root.NameExists(path))

        {

                std::cerr<<"Doesn't exist"<<std::endl;

                return kFailure;

        }

        // make sure we aren't deleting non-empty directories, even

        // though the concept of a directory is fuzzy.

        if (root.GetEntryType(path) == GDPfs::DIR)

        {

                std::vector<std::string> children;

                root.GetChildren(path, &children);

                if (children.size() != 0 && !recursive)

                {

                        std::cerr<<"Can't delete non-empty directory"<<std::endl;

                        return kFailure;

                }

                if (!recursive)

                {

                        ep_dbg_cprintf(Dbg, 10, "Deleting %s\n", path.c_str());

                        root.DeleteDir(path);

                }

                else

                {

                        // need to list down all the children. We use GetMatchingPaths

                        // instead of GetChildren as a shortcut.

                        std::vector<std::string> children;

                        std::vector<std::string>::iterator it;

                        root.GetMatchingPaths(path, &children);

                        for (it=children.begin(); it!=children.end(); it++)

                        {

                                ep_dbg_cprintf(Dbg, 10, "Deleting %s\n", it->c_str());

                                if (root.GetEntryType(*it) == GDPfs::DIR)

                                        root.DeleteDir(*it);

                                else

                                        root.DeleteFile(*it);

                        }

                }

        }

        else

        {

                root.DeleteFile(path);

        }

        // FIXME check return status of Delete*

        return kSuccess;

}

// creates a signature key and stores the private part in the

// given filename. Note that the key is not protected at all.

// Thus, one must be careful in making sure that the appropriate

// file system permissions are set

GdpfsStatus keygen(const std::string filename)

{

        EP_CRYPTO_KEY *key;

        int keytype;

        const char *curve;

        EP_STAT estat;

        keytype = ep_crypto_keytype_byname("ec");

        curve = ep_adm_getstrparam("swarm.gdp.crypto.ec.curve", NULL);

        key = ep_crypto_key_create(keytype, 0, 0, curve);

        if (key == NULL)

        {

                ep_app_error("Could not create new key");

                return kFailure;

        }

        int fd;

        FILE *fp;

        if ((fd = open(filename.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0400)) < 0 ||

                        (fp = fdopen(fd, "w")) == NULL)

        {

                ep_app_error("Cannot create %s", filename.c_str());

                return kFailure;

        }

        estat = ep_crypto_key_write_fp(key, fp, EP_CRYPTO_KEYFORM_PEM,

                                                0, NULL, EP_CRYPTO_F_SECRET);

        // TODO: should really clear the fp buffer memory here to

        //                 avoid exposing any secret key information after free

        fclose(fp);

}

// initializes the "root directory" in the file system implemented

// in the GDP.

GdpfsStatus gdpfs_mkfs(const std::string rootdir)

{

        std::string rootlog, path;

        GdpfsStatus gstat;

        assert (ParsePath(rootdir, &rootlog, &path) == kSuccess);

        assert (path.length() == 0);

        gstat = GDPfsMkfs(rootlog);

        return gstat;

}

/////////////////// argument processing and handling below ///////////////

// returns the usage string

std::string usage_string()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] <cmd> [<args>]\n"

        "\n"

        "Available commands are:\n"

        "  ls        List file/dirs with extended info. Use: `ls <GDP-path>`\n"

        "  mkdir     Make dirs. Use: `mkdir <GDP-directory>`\n"

        "  to_gdp    Copy files to GDP. Use: `to_gdp <local-path> <GDP-path>`\n"

        "  from_gdp  Copy file from GDP. Use: `from_gdp <GDP-path> <local-path>`\n"

        "  rm        Delete file/dir. Use: `rm <GDP-path>\n" 

        "  keygen    Create a signature key. Use: `keygen <output-file>\n"

        "\n"

        "GDP-path: a full filepath that starts with 'gdp://'";

        return s;

}

std::string usage_string_ls()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] ls [OPTION]... PATH\n"

        "\n"

        "Available options are:\n"

        "  -1        List files for programmatic use and supress extended info.\n"

        "  -h        Show this message.\n"

        "\n"

        "PATH: a full filepath that starts with 'gdp://'";

        return s;

}

std::string usage_string_rm()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] rm [OPTION]... PATH\n"

        "\n"

        "Available options are:\n"

        "  -r        Delete recursively (only makes sense for directories).\n"

        "  -h        Show this message.\n"

        "\n"

        "PATH: a full filepath that starts with 'gdp://'";

        return s;

}

std::string usage_string_from_gdp()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] "

                                                "from_gdp [OPTION]... PATH LOCALPATH\n"

        "\n"

        "Available options are:\n"

        "  -r        Copy recursively (only makes sense for directories).\n"

        "  -h        Show this message.\n"

        "\n"

        "PATH: a full filepath that starts with 'gdp://'\n"

        "LOCALPATH: a local filesystem path.";

        return s;

}

std::string usage_string_to_gdp()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] "

                                                "to_gdp [OPTION]... LOCALPATH PATH\n"

        "\n"

        "Available options are:\n"

        "  -r        Copy recursively (only makes sense for directories).\n"

        "  -h        Show this message.\n"

        "\n"

        "PATH: a full filepath that starts with 'gdp://'\n"

        "LOCALPATH: a local filesystem path.";

        return s;

}

std::string usage_string_keygen()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] keygen LOCALPATH\n"

        "\n"

        "Available options are:\n"

        "  -h        Show this message.\n"

        "\n"

        "LOCALPATH: a local filename where the *private* key should be stored";

        return s;

}

std::string usage_string_mkfs()

{

        std::string s = "Basic Usage: gdpfs_cmd [-D dbgspec] mkfs ROOTDIR\n"

        "\n"

        "ROOTDIR: the name of the GDP-based root directory.";

        return s;

}

////////////////// main function below /////////////////////////

int main(int argc, char **argv)

{

        int opt;

        bool show_usage = false;

        char *debug_setting = (char*) "*=0";

        while ((opt = getopt(argc, argv, "+D:")) > 0)

        {

                switch (opt)

                {

                        case 'D':

                                debug_setting = optarg;

                                break;

                        default:

                                show_usage = true;

                                break;

                }

        }

        argc -= optind;

        argv += optind;

        if (show_usage || argc == 0)

        {

                std::cerr<<usage_string()<<std::endl;

                return (int) kInvalidArg;

        }

        EP_STAT estat = gdp_init(NULL);

        if (!EP_STAT_ISOK(estat))

        {

                char ebuf[100];

                ep_app_fatal("gdp_init failed: %s",

                                ep_stat_tostr(estat, ebuf, sizeof ebuf));

        }

        // read the per-app configuration files.

        ep_adm_readparams("gdpfs");

        // set the debugging parameters for the GDP library

        // as well as for the gdpfs library. Config file settings

        // can be overridden by debug_setting.

        if (debug_setting == NULL)

        {

                ep_dbg_set(ep_adm_getstrparam("swarm.gdp.debug", NULL));

                ep_dbg_set(ep_adm_getstrparam("swarm.gdpfs.debug", NULL));

        }

        else

        {

                ep_dbg_set(debug_setting);

        }

        if (strcmp(argv[0], "to_gdp")==0)

        {

                bool recursive = false;

                bool show_usage_local = false;

                optind = 0;

                while ((opt = getopt(argc, argv, "+rh")) > 0)

                {

                        switch (opt)

                        {

                                case 'r':

                                        recursive = true;

                                        break;

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc == 0)

                {

                        std::cerr<<usage_string_to_gdp()<<std::endl;

                        return (int) kInvalidArg;

                }

                GDPfsInit(GDP_MODE_RA, debug_setting);

                return (int) copy_to_gdp(argv[0], argv[1], recursive);

        }

        if (strcmp(argv[0], "from_gdp")==0)

        {

                bool recursive = false;

                bool show_usage_local = false;

                optind = 0;

                while ((opt = getopt(argc, argv, "+rh")) > 0)

                {

                        switch (opt)

                        {

                                case 'r':

                                        recursive = true;

                                        break;

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc == 0)

                {

                        std::cerr<<usage_string_from_gdp()<<std::endl;

                        return (int) kInvalidArg;

                }

                GDPfsInit(GDP_MODE_RO, debug_setting);

                return (int) copy_from_gdp(argv[0], argv[1], recursive);

        }

        if (strcmp(argv[0], "ls")==0)

        {

                bool fancy = true;

                bool show_usage_local = false;

                optind = 0;

                while ((opt = getopt(argc, argv, "+1h")) > 0)

                {

                        switch (opt)

                        {

                                case '1':

                                        fancy = false;

                                        break;

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc == 0)

                {

                        std::cerr<<usage_string_ls()<<std::endl;

                        return (int) kInvalidArg;

                }

                GDPfsInit(GDP_MODE_RO, debug_setting);

                return (int) ls(argv[0], fancy);

        }

        if (strcmp(argv[0], "mkdir")==0)

        {

                GDPfsInit(GDP_MODE_RA, debug_setting);

                return (int) mkdir_(argv[1]);

        }

        if (strcmp(argv[0], "rm") == 0)

        {

                bool recursive = false;

                bool show_usage_local = false;

                optind = 0;

                while ((opt = getopt(argc, argv, "+rh")) > 0)

                {

                        switch (opt)

                        {

                                case 'r':

                                        recursive = true;

                                        break;

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc == 0)

                {

                        std::cerr<<usage_string_rm()<<std::endl;

                        return (int) kInvalidArg;

                }

                GDPfsInit(GDP_MODE_RA, debug_setting);

                return (int) rm(argv[0], recursive);

        }

        if (strcmp(argv[0], "keygen")==0)

        {

                bool show_usage_local = false;

                optind = 0;

                while ((opt = getopt(argc, argv, "+h")) > 0)

                {

                        switch (opt)

                        {

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc == 0)

                {

                        std::cerr<<usage_string_keygen()<<std::endl;

                        return (int) kInvalidArg;

                }

                GDPfsInit(GDP_MODE_RA, debug_setting);

                return (int) keygen(argv[0]);

        }

        if (strcmp(argv[0], "io_test")==0)

        {

                // this is intentionally undocumented

                GDPfsInit(GDP_MODE_RA, debug_setting);

                int len = atoi(argv[1]);

                GdpfsStatus res = rw_test(argv[2], len*1024*1024);

                return (int) res;

        }

        if (strcmp(argv[0], "mkfs")==0)

        {

                bool show_usage_local = false;

                optind = 0;

                GDPfsInit(GDP_MODE_RA, debug_setting);

                while ((opt = getopt(argc, argv, "+h")) > 0)

                {

                        switch (opt)

                        {

                                case 'h':

                                default:

                                        show_usage_local = true;

                        }

                }

                argc -= optind;

                argv += optind;

                if (show_usage_local || argc != 1)

                {

                        std::cerr<<usage_string_mkfs()<<std::endl;

                        return (int) kInvalidArg;

                }

                ep_dbg_cprintf(Dbg, 10, "mkfs(%s)\n", argv[0]);

                return (int) gdpfs_mkfs(argv[0]);

        }

        // if we reach here, that's a bad sign

        std::cerr<<usage_string()<<std::endl;

        return (int) kInvalidArg;

}