#ifndef _GNU_SOURCE

#define _GNU_SOURCE

#endif

#define DBG if (0)

#include <errno.h>

#include <fcntl.h>

#include <ctype.h>

#include <getopt.h>

#include <mntent.h>

#include <pwd.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mount.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <mntent.h>

#include <limits.h>

#include <iconv.h>

#include "vbsfmount.h"

#define CT_ASSERT(a) \

do { \

switch(0) { case 0: case (a): ; } \

} while (0)

#define PANIC_ATTR __attribute ((noreturn, __format__ (__printf__, 1, 2)))

static void PANIC_ATTR

panic(const char *fmt, ...)

{

va_list ap;

va_start(ap, fmt);

vfprintf(stderr, fmt, ap);

va_end(ap);

exit(EXIT_FAILURE);

}

static void PANIC_ATTR

panic_err(const char *fmt, ...)

{

va_list ap;

int errno_code = errno;

va_start(ap, fmt);

vfprintf(stderr, fmt, ap);

va_end(ap);

fprintf(stderr, ": %s\n", strerror(errno_code));

exit(EXIT_FAILURE);

}

static int

safe_atoi(const char *s, size_t size, int base)

{

char *endptr;

long long int val = strtoll(s, &endptr, base);

if (val < INT_MIN || val > INT_MAX || endptr < s + size)

{

errno = ERANGE;

panic_err("could not convert %.*s to integer, result = %d",

(int)size, s, (int) val);

}

return (int)val;

}

static void

process_mount_opts(const char *s, struct vbsf_mount_opts *opts)

{

const char *next = s;

size_t len;

typedef enum handler_opt

{

HORW,

HORO,

HOUID,

HOGID,

HOTTL,

HODMODE,

HOFMODE,

HOUMASK,

HODMASK,

HOFMASK,

HOIOCHARSET,

HOCONVERTCP,

HONOEXEC,

HOEXEC,

HONODEV,

HODEV,

HONOSUID,

HOSUID,

HOREMOUNT,

HONOAUTO,

HONIGNORE

} handler_opt;

struct

{

const char *name;

handler_opt opt;

int has_arg;

const char *desc;

} handlers[]

=

{

{"rw", HORW, 0, "mount read write (default)"},

{"ro", HORO, 0, "mount read only"},

{"uid", HOUID, 1, "default file owner user id"},

{"gid", HOGID, 1, "default file owner group id"},

{"ttl", HOTTL, 1, "time to live for dentry"},

{"iocharset", HOIOCHARSET, 1, "i/o charset (default utf8)"},

{"convertcp", HOCONVERTCP, 1, "convert share name from given charset to utf8"},

{"dmode", HODMODE, 1, "mode of all directories"},

{"fmode", HOFMODE, 1, "mode of all regular files"},

{"umask", HOUMASK, 1, "umask of directories and regular files"},

{"dmask", HODMASK, 1, "umask of directories"},

{"fmask", HOFMASK, 1, "umask of regular files"},

{"noexec", HONOEXEC, 0, 0 }, /* don't document these options directly here */

{"exec", HOEXEC, 0, 0 }, /* as they are well known and described in the */

{"nodev", HONODEV, 0, 0 }, /* usual manpages */

{"dev", HODEV, 0, 0 },

{"nosuid", HONOSUID, 0, 0 },

{"suid", HOSUID, 0, 0 },

{"remount", HOREMOUNT, 0, 0 },

{"noauto", HONOAUTO, 0, 0 },

{"_netdev", HONIGNORE, 0, 0 },

{NULL, 0, 0, NULL}

}, *handler;

while (next)

{

const char *val;

size_t key_len, val_len;

s = next;

next = strchr(s, ',');

if (!next)

{

len = strlen(s);

}

else

{

len = next - s;

next += 1;

if (!*next)

next = 0;

}

val = NULL;

val_len = 0;

for (key_len = 0; key_len < len; ++key_len)

{

if (s[key_len] == '=')

{

if (key_len + 1 < len)

{

val = s + key_len + 1;

val_len = len - key_len - 1;

}

break;

}

}

for (handler = handlers; handler->name; ++handler)

{

size_t j;

for (j = 0; j < key_len && handler->name[j] == s[j]; ++j)

;

if (j == key_len && !handler->name[j])

{

if (handler->has_arg)

{

if (!(val && *val))

{

panic("%.*s requires an argument (i.e. %.*s=<arg>)\n",

(int)len, s, (int)len, s);

}

}

switch(handler->opt)

{

case HORW:

opts->ronly = 0;

break;

case HORO:

opts->ronly = 1;

break;

case HONOEXEC:

opts->noexec = 1;

break;

case HOEXEC:

opts->noexec = 0;

break;

case HONODEV:

opts->nodev = 1;

break;

case HODEV:

opts->nodev = 0;

break;

case HONOSUID:

opts->nosuid = 1;

break;

case HOSUID:

opts->nosuid = 0;

break;

case HOREMOUNT:

opts->remount = 1;

break;

case HOUID:

/** @todo convert string to id. */

opts->uid = safe_atoi(val, val_len, 10);

break;

case HOGID:

/** @todo convert string to id. */

opts->gid = safe_atoi(val, val_len, 10);

break;

case HOTTL:

opts->ttl = safe_atoi(val, val_len, 10);

break;

case HODMODE:

opts->dmode = safe_atoi(val, val_len, 8);

break;

case HOFMODE:

opts->fmode = safe_atoi(val, val_len, 8);

break;

case HOUMASK:

opts->dmask = opts->fmask = safe_atoi(val, val_len, 8);

break;

case HODMASK:

opts->dmask = safe_atoi(val, val_len, 8);

break;

case HOFMASK:

opts->fmask = safe_atoi(val, val_len, 8);

break;

case HOIOCHARSET:

if (val_len + 1 > sizeof(opts->nls_name))

{

panic("iocharset name too long\n");

}

memcpy(opts->nls_name, val, val_len);

opts->nls_name[val_len] = 0;

break;

case HOCONVERTCP:

opts->convertcp = malloc(val_len + 1);

if (!opts->convertcp)

{

panic_err("could not allocate memory");

}

memcpy(opts->convertcp, val, val_len);

opts->convertcp[val_len] = 0;

break;

case HONOAUTO:

case HONIGNORE:

break;

}

break;

}

continue;

}

if (!handler->name)

{

fprintf(stderr, "unknown mount option `%.*s'\n", (int)len, s);

fprintf(stderr, "valid options:\n");

for (handler = handlers; handler->name; ++handler)

{

if (handler->desc)

fprintf(stderr, " %-10s%s %s\n", handler->name,

handler->has_arg ? "=<arg>" : "", handler->desc);

}

exit(EXIT_FAILURE);

}

}

}

static void

convertcp(char *in_codeset, char *host_name, struct vbsf_mount_info_new *info)

{

char *i = host_name;

char *o = info->name;

size_t ib = strlen(host_name);

size_t ob = sizeof(info->name) - 1;

iconv_t cd;

cd = iconv_open("UTF-8", in_codeset);

if (cd == (iconv_t) -1)

{

panic_err("could not convert share name, iconv_open `%s' failed",

in_codeset);

}

while (ib)

{

size_t c = iconv(cd, &i, &ib, &o, &ob);

if (c == (size_t) -1)

{

panic_err("could not convert share name(%s) at %d",

host_name, (int)(strlen (host_name) - ib));

}

}

*o = 0;

}

static void __attribute ((noreturn)) usage(char *name)

{

printf("Usage: %s [OPTIONS] NAME MOUNTPOINT\n"

"Mount the VirtualBox shared folder NAME from the host system to MOUNTPOINT.\n"

"\n"

" -w mount the shared folder writable (the default)\n"

" -r mount the shared folder read-only\n"

" -n do not create an mtab entry\n"

" -o OPTION[,OPTION...] use the mount options specified\n"

"\n", name);

printf("Available mount options are:\n"

" rw mount writable (the default)\n"

" ro mount read only\n"

" uid=UID set the default file owner user id to UID\n"

" gid=GID set the default file owner group id to GID\n"

" ttl=TTL set the \"time to live\" to TID for the dentry\n");

printf(" dmode=MODE override the mode of all directories to (octal) MODE\n"

" fmode=MODE override the mode of all regular files to (octal) MODE\n"

" umask=UMASK set the umask to (octal) UMASK\n");

printf(" dmask=UMASK set the umask applied to directories only\n"

" fmask=UMASK set the umask applied to regular files only\n"

" iocharset CHARSET use the character set CHARSET for I/O operations\n"

" (default set is utf8)\n"

" convertcp CHARSET convert the folder name from CHARSET to utf8\n"

"\n");

printf("Less common used options:\n"

" noexec,exec,nodev,dev,nosuid,suid\n");

exit(1);

}

main (int argc, char **argv)

{

int c;

int err;

int nomtab = 0;

unsigned long flags = MS_NODEV;

char *host_name;

char *mount_point;

struct vbsf_mount_info_new mntinf;

struct vbsf_mount_opts opts =

{

0, /* uid */

0, /* gid */

0, /* ttl */

~0U, /* dmode */

~0U, /* fmode*/

0, /* dmask */

0, /* fmask */

0, /* ronly */

0, /* noexec */

0, /* nodev */

0, /* nosuid */

0, /* remount */

"\0", /* nls_name */

NULL, /* convertcp */

};

mntinf.nullchar = '\0';

mntinf.signature[0] = VBSF_MOUNT_SIGNATURE_BYTE_0;

mntinf.signature[1] = VBSF_MOUNT_SIGNATURE_BYTE_1;

mntinf.signature[2] = VBSF_MOUNT_SIGNATURE_BYTE_2;

mntinf.length = sizeof(mntinf);

if (getuid())

panic("Only root can mount shared folders from the host.\n");

if (!argv[0])

argv[0] = "mount.vboxsf";

/* Compile-time assertions */

CT_ASSERT(sizeof(uid_t) == sizeof(int));

CT_ASSERT(sizeof(gid_t) == sizeof(int));

while ((c = getopt(argc, argv, "rwno:h")) != -1)

{

switch (c)

{

default:

fprintf(stderr, "unknown option `%c:%#x'\n", c, c);

case '?':

case 'h':

usage(argv[0]);

case 'r':

opts.ronly = 1;

break;

case 'w':

opts.ronly = 0;

case 'o':

process_mount_opts(optarg, &opts);

break;

case 'n':

nomtab = 1;

break;

}

}

if (argc - optind < 2)

usage(argv[0]);

host_name = argv[optind];

mount_point = argv[optind + 1];

if (opts.convertcp)

convertcp(opts.convertcp, host_name, &mntinf);

else

{

if (strlen(host_name) > MAX_HOST_NAME - 1)

panic("host name is too big\n");

strcpy(mntinf.name, host_name);

}

if (strlen(opts.nls_name) > MAX_NLS_NAME - 1)

panic("%s: the character set name for I/O is too long.\n", argv[0]);

strcpy(mntinf.nls_name, opts.nls_name);

if (opts.ronly)

flags |= MS_RDONLY;

if (opts.noexec)

flags |= MS_NOEXEC;

if (opts.nodev)

flags |= MS_NODEV;

if (opts.remount)

flags |= MS_REMOUNT;

mntinf.uid = opts.uid;

mntinf.gid = opts.gid;

mntinf.ttl = opts.ttl;

mntinf.dmode = opts.dmode;

mntinf.fmode = opts.fmode;

mntinf.dmask = opts.dmask;

mntinf.fmask = opts.fmask;

/*

err = mount(NULL, mount_point, "vboxsf", flags, &mntinf);

if (err == -1 && errno == EPROTO)

{

/* Sometimes the mount utility messes up the share name. Try to

char szCWD[4096];

size_t cchCWD;

if (!getcwd(szCWD, sizeof(szCWD)))

panic_err("%s: failed to get the current working directory", argv[0]);

cchCWD = strlen(szCWD);

if (!strncmp(host_name, szCWD, cchCWD))

{

while (host_name[cchCWD] == '/')

++cchCWD;

/* We checked before that we have enough space */

strcpy(mntinf.name, host_name + cchCWD);

}

err = mount(NULL, mount_point, "vboxsf", flags, &mntinf);

}

if (err == -1 && errno == EPROTO)

{

/* New mount tool with old vboxsf module? Try again using the old

struct vbsf_mount_info_old mntinf_old;

memcpy(&mntinf_old.name, &mntinf.name, MAX_HOST_NAME);

memcpy(&mntinf_old.nls_name, mntinf.nls_name, MAX_NLS_NAME);

mntinf_old.uid = mntinf.uid;

mntinf_old.gid = mntinf.gid;

mntinf_old.ttl = mntinf.ttl;

err = mount(NULL, mount_point, "vboxsf", flags, &mntinf_old);

}

if (err)

panic_err("%s: mounting failed with the error", argv[0]);

if (!nomtab)

{

err = vbsfmount_complete(host_name, mount_point, flags, &opts);

switch (err)

{

case 0: /* Success. */

break;

case 1:

panic_err("%s: Could not update mount table (failed to create memstream).", argv[0]);

break;

case 2:

panic_err("%s: Could not open mount table for update.", argv[0]);

break;

case 3:

/* panic_err("%s: Could not add an entry to the mount table.", argv[0]); */

break;

default:

panic_err("%s: Unknown error while completing mount operation: %d", argv[0], err);

break;

}

}

exit(EXIT_SUCCESS);

}