void
mount_ext2fs_parseargs(int argc, char *argv[],
struct ufs_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
int ch;
mntoptparse_t mp;
memset(args, 0, sizeof(*args));
*mntflags = 0;
optind = optreset = 1; /* Reset for parse of new argv. */
while ((ch = getopt(argc, argv, "o:")) != -1)
switch (ch) {
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case '?':
default:
ext2fs_usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
ext2fs_usage();
pathadj(argv[0], canon_dev);
args->fspec = canon_dev;
pathadj(argv[1], canon_dir);
}
int
mount_null(int argc, char *argv[])
{
struct null_args args;
int ch, mntflags;
char target[MAXPATHLEN], canon_dir[MAXPATHLEN];
mntoptparse_t mp;
mntflags = 0;
while ((ch = getopt(argc, argv, "o:")) != -1)
switch(ch) {
case 'o':
mp = getmntopts(optarg, mopts, &mntflags, 0);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
if (realpath(argv[0], target) == NULL) /* Check device path */
err(1, "realpath %s", argv[0]);
if (strncmp(argv[0], target, MAXPATHLEN)) {
warnx("\"%s\" is a relative path.", argv[0]);
warnx("using \"%s\" instead.", target);
}
if (realpath(argv[1], canon_dir) == NULL) /* Check mounton path */
err(1, "realpath %s", argv[1]);
if (strncmp(argv[1], canon_dir, MAXPATHLEN)) {
warnx("\"%s\" is a relative path.", argv[1]);
warnx("using \"%s\" instead.", canon_dir);
}
if (strcmp(target, canon_dir) == 0)
errx(1, "%s (%s) and %s (%s) are identical paths",
argv[0], target, argv[1], canon_dir);
args.la.target = target;
if (mount(MOUNT_NULL, canon_dir, mntflags, &args, sizeof args) == -1)
err(1, "%s on %s", target, canon_dir);
exit(0);
}
int
mount_procfs(int argc, char *argv[])
{
int ch, mntflags, altflags;
struct procfs_args args;
char canon_dir[MAXPATHLEN];
mntoptparse_t mp;
mntflags = 0;
altflags = PROCFSMNT_LINUXCOMPAT;
while ((ch = getopt(argc, argv, "o:")) != -1)
switch (ch) {
case 'o':
mp = getmntopts(optarg, mopts, &mntflags, &altflags);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
if (realpath(argv[1], canon_dir) == NULL) /* Check mounton path */
err(1, "realpath %s", argv[1]);
if (strncmp(argv[1], canon_dir, MAXPATHLEN)) {
warnx("\"%s\" is a relative path.", argv[1]);
warnx("using \"%s\" instead.", canon_dir);
}
args.version = PROCFS_ARGSVERSION;
args.flags = altflags;
if (mount(MOUNT_PROCFS, canon_dir, mntflags, &args, sizeof args) == -1)
err(1, "procfs on %s", canon_dir);
if (mntflags & MNT_GETARGS) {
char buf[1024];
(void)snprintb(buf, sizeof(buf), PROCFSMNT_BITS, args.flags);
printf("version=%d, flags=%s\n", args.version, buf);
}
exit(0);
}
void
mount_v7fs_parseargs(int argc, char **argv, struct v7fs_args *args,
int *mntflags, char *canon_dev, char *canon_dir)
{
int ch;
mntoptparse_t mp;
int endian = _BYTE_ORDER;
*mntflags = 0;
optind = optreset = 1; /* Reset for parse of new argv. */
while ((ch = getopt(argc, argv, "o:B:")) != -1)
switch (ch) {
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case 'B':
switch (optarg[0]) {
case 'l':
endian = _LITTLE_ENDIAN;
break;
case 'b':
endian = _BIG_ENDIAN;
break;
case 'p':
endian = _PDP_ENDIAN;
break;
}
break;
case '?':
default:
v7fs_usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
v7fs_usage();
pathadj(argv[0], canon_dev);
args->endian = endian;
args->fspec = canon_dev;
pathadj(argv[1], canon_dir);
}
void
mount_kernfs_parseargs(int argc, char *argv[], void *dummy, int *mntflags,
char *canon_dev, char *canon_dir)
{
int ch;
mntoptparse_t mp;
*mntflags = 0;
while ((ch = getopt(argc, argv, "o:")) != -1)
switch (ch) {
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/* not supported, fail silently */
if (*mntflags & MNT_GETARGS)
exit(0);
strlcpy(canon_dev, argv[0], MAXPATHLEN);
if (realpath(argv[1], canon_dir) == NULL) /* Check mounton path */
err(1, "realpath %s", argv[1]);
if (strncmp(argv[1], canon_dir, MAXPATHLEN)) {
warnx("\"%s\" is a relative path.", argv[1]);
warnx("using \"%s\" instead.", canon_dir);
}
}
void
mount_tmpfs_parseargs(int argc, char *argv[],
struct tmpfs_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
int gidset, modeset, uidset; /* Ought to be 'bool'. */
int ch;
gid_t gid;
uid_t uid;
mode_t mode;
int64_t tmpnumber;
mntoptparse_t mp;
struct stat sb;
/* Set default values for mount point arguments. */
memset(args, 0, sizeof(*args));
args->ta_version = TMPFS_ARGS_VERSION;
args->ta_size_max = 0;
args->ta_nodes_max = 0;
*mntflags = 0;
gidset = 0; gid = 0;
uidset = 0; uid = 0;
modeset = 0; mode = 0;
optind = optreset = 1;
while ((ch = getopt(argc, argv, "g:m:n:o:s:u:")) != -1 ) {
switch (ch) {
case 'g':
gid = a_gid(optarg);
gidset = 1;
break;
case 'm':
mode = a_mask(optarg);
modeset = 1;
break;
case 'n':
if (dehumanize_number(optarg, &tmpnumber) == -1)
err(EXIT_FAILURE, "failed to parse nodes `%s'",
optarg);
args->ta_nodes_max = tmpnumber;
break;
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL)
err(EXIT_FAILURE, "getmntopts");
freemntopts(mp);
break;
case 's':
if (dehumanize_number(optarg, &tmpnumber) == -1)
err(EXIT_FAILURE, "failed to parse size `%s'",
optarg);
args->ta_size_max = tmpnumber;
break;
case 'u':
uid = a_uid(optarg);
uidset = 1;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
strlcpy(canon_dev, argv[0], MAXPATHLEN);
pathadj(argv[1], canon_dir);
if (stat(canon_dir, &sb) == -1)
err(EXIT_FAILURE, "cannot stat `%s'", canon_dir);
args->ta_root_uid = uidset ? uid : sb.st_uid;
args->ta_root_gid = gidset ? gid : sb.st_gid;
args->ta_root_mode = modeset ? mode : sb.st_mode;
}
int main(int argc, char *argv[])
{
SMBHANDLE serverConnection = NULL;
uint64_t options = kSMBOptionSessionOnly;
uint64_t mntOptions = 0;
int altflags = SMBFS_MNT_STREAMS_ON;
mode_t fileMode = 0, dirMode = 0;
int mntflags = 0;
NTSTATUS status;
char mountPoint[MAXPATHLEN];
struct stat st;
char *next;
int opt;
const char * url = NULL;
int version = SMBFrameworkVersion();
while ((opt = getopt(argc, argv, "Nvhd:f:o:")) != -1) {
switch (opt) {
case 'd':
errno = 0;
dirMode = strtol(optarg, &next, 8);
if (errno || *next != 0)
errx(EX_DATAERR, "invalid value for directory mode");
break;
case 'f':
errno = 0;
fileMode = strtol(optarg, &next, 8);
if (errno || *next != 0)
errx(EX_DATAERR, "invalid value for file mode");
break;
case 'N':
options |= kSMBOptionNoPrompt;
break;
case 'o': {
mntoptparse_t mp = getmntopts(optarg, mopts, &mntflags, &altflags);
if (mp == NULL)
err(1, NULL);
freemntopts(mp);
break;
}
case 'v':
errx(EX_OK, "version %d.%d.%d",
version / 100000, (version % 10000) / 1000, (version % 1000) / 100);
break;
case '?':
case 'h':
default:
usage();
break;
}
}
if (optind >= argc)
usage();
argc -= optind;
/* At this point we should only have a url and a mount point */
if (argc != 2)
usage();
url = argv[optind];
optind++;
realpath(unpercent(argv[optind]), mountPoint);
if (stat(mountPoint, &st) == -1)
err(EX_OSERR, "could not find mount point %s", mountPoint);
if (!S_ISDIR(st.st_mode)) {
errno = ENOTDIR;
err(EX_OSERR, "can't mount on %s", mountPoint);
}
if (mntflags & MNT_AUTOMOUNTED) {
/* Automount volume, don't look in the user home directory */
options |= kSMBOptionNoUserPreferences;
}
if ((altflags & SMBFS_MNT_STREAMS_ON) != SMBFS_MNT_STREAMS_ON) {
/* They told us to turn of named streams */
mntOptions |= kSMBMntOptionNoStreams;
}
if ((altflags & SMBFS_MNT_NOTIFY_OFF) == SMBFS_MNT_NOTIFY_OFF) {
/* They told us to turn off remote notifications */
mntOptions |= kSMBMntOptionNoNotifcations;
}
if ((altflags & SMBFS_MNT_SOFT) == SMBFS_MNT_SOFT) {
/* Make this a soft mount */
mntOptions |= kSMBMntOptionSoftMount;
}
if ((altflags & SMBFS_MNT_TIME_MACHINE) == SMBFS_MNT_TIME_MACHINE) {
/* Make this a tm mount */
mntOptions |= kSMBReservedTMMount;
}
status = SMBOpenServerEx(url, &serverConnection, options);
if (NT_SUCCESS(status)) {
status = SMBMountShareEx(serverConnection, NULL, mountPoint, mntflags,
mntOptions, fileMode, dirMode, setNetworkAccountSID, NULL);
}
/*
* SMBOpenServerEx now sets errno, so err will work correctly. We change
* the string based on the NTSTATUS Error.
*/
if (!NT_SUCCESS(status)) {
switch (status) {
case STATUS_NO_SUCH_DEVICE:
err(EX_UNAVAILABLE, "failed to intitialize the smb library");
break;
case STATUS_LOGON_FAILURE:
err(EX_NOPERM, "server rejected the connection");
break;
case STATUS_CONNECTION_REFUSED:
err(EX_NOHOST, "server connection failed");
break;
case STATUS_INVALID_HANDLE:
case STATUS_NO_MEMORY:
err(EX_UNAVAILABLE, "internal error");
break;
case STATUS_UNSUCCESSFUL:
err(EX_USAGE, "mount error: %s", mountPoint);
break;
case STATUS_INVALID_PARAMETER:
err(EX_USAGE, "URL parsing failed, please correct the URL and try again");
break;
case STATUS_BAD_NETWORK_NAME:
err(EX_NOHOST, "share connection failed");
break;
default:
err(EX_OSERR, "unknown status %d", status);
break;
}
}
/* We are done clean up anything left around */
if (serverConnection)
SMBReleaseServer(serverConnection);
return 0;
}
int
main(int argc, char *argv[])
{
struct puffs_usermount *pu;
struct puffs_ops *pops;
mntoptparse_t mp;
int mntflags, pflags;
int detach;
int ch;
setprogname(argv[0]);
if (argc < 2)
usage();
mntflags = pflags = 0;
detach = 1;
while ((ch = getopt(argc, argv, "o:rs")) != -1) {
switch (ch) {
case 'o':
mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
if (mp == NULL)
err(EXIT_FAILURE, "getmntopts");
freemntopts(mp);
break;
case 'r':
rflag = 1;
break;
case 's':
detach = 0;
break;
}
}
argv += optind;
argc -= optind;
pflags |= PUFFS_FLAG_BUILDPATH | PUFFS_KFLAG_NOCACHE;
if (pflags & PUFFS_FLAG_OPDUMP)
detach = 0;
if (argc != 2)
usage();
PUFFSOP_INIT(pops);
PUFFSOP_SETFSNOP(pops, unmount);
PUFFSOP_SETFSNOP(pops, sync);
PUFFSOP_SETFSNOP(pops, statvfs);
PUFFSOP_SET(pops, sysctlfs, fs, nodetofh);
PUFFSOP_SET(pops, sysctlfs, fs, fhtonode);
PUFFSOP_SET(pops, sysctlfs, node, lookup);
PUFFSOP_SET(pops, sysctlfs, node, getattr);
PUFFSOP_SET(pops, sysctlfs, node, setattr);
PUFFSOP_SET(pops, sysctlfs, node, readdir);
PUFFSOP_SET(pops, sysctlfs, node, read);
PUFFSOP_SET(pops, sysctlfs, node, write);
PUFFSOP_SET(pops, puffs_genfs, node, reclaim);
pu = puffs_init(pops, _PATH_PUFFS, "sysctlfs", NULL, pflags);
if (pu == NULL)
err(EXIT_FAILURE, "puffs_init");
puffs_set_pathbuild(pu, sysctlfs_pathbuild);
puffs_set_pathtransform(pu, sysctlfs_pathtransform);
puffs_set_pathcmp(pu, sysctlfs_pathcmp);
puffs_set_pathfree(pu, sysctlfs_pathfree);
puffs_setfhsize(pu, sizeof(struct sfsfid), PUFFS_FHFLAG_NFSV3);
if (sysctlfs_domount(pu) != 0)
errx(EXIT_FAILURE, "domount");
if (detach)
if (puffs_daemon(pu, 1, 1) == -1)
err(EXIT_FAILURE, "puffs_daemon");
#ifdef RUMP_ACTION
{
extern int puffs_fakecc;
puffs_fakecc = 1;
rump_init();
}
#endif
if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
err(EXIT_FAILURE, "puffs_mount");
if (puffs_mainloop(pu) == -1)
err(EXIT_FAILURE, "mainloop");
return 0;
}
void
mount_ntfs_parseargs(int argc, char **argv,
struct ntfs_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
struct stat sb;
int c, set_gid, set_uid, set_mask;
char *dev, *dir;
mntoptparse_t mp;
*mntflags = set_gid = set_uid = set_mask = 0;
(void)memset(args, '\0', sizeof(*args));
while ((c = getopt(argc, argv, "aiu:g:m:o:")) != -1) {
switch (c) {
case 'u':
args->uid = a_uid(optarg);
set_uid = 1;
break;
case 'g':
args->gid = a_gid(optarg);
set_gid = 1;
break;
case 'm':
args->mode = a_mask(optarg);
set_mask = 1;
break;
case 'i':
args->flag |= NTFS_MFLAG_CASEINS;
break;
case 'a':
args->flag |= NTFS_MFLAG_ALLNAMES;
break;
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case '?':
default:
usage();
break;
}
}
if (optind + 2 != argc)
usage();
dev = argv[optind];
dir = argv[optind + 1];
pathadj(dev, canon_dev);
pathadj(dir, canon_dir);
args->fspec = dev;
if (!set_gid || !set_uid || !set_mask) {
if (stat(dir, &sb) == -1)
err(EX_OSERR, "stat %s", dir);
if (!set_uid)
args->uid = sb.st_uid;
if (!set_gid)
args->gid = sb.st_gid;
if (!set_mask)
args->mode = sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
}
/* main routine */
int
mount_udf_parseargs(int argc, char **argv,
struct udf_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
uid_t anon_uid, nobody_uid;
gid_t anon_gid, nobody_gid;
int ch, set_gmtoff;
uint32_t sector_size;
mntoptparse_t mp;
/* initialise */
(void)memset(args, 0, sizeof(*args));
set_gmtoff = *mntflags = 0;
sector_size = 0;
/* get nobody */
nobody_uid = anon_uid = a_uid("nobody");
nobody_gid = anon_gid = a_gid("nobody");
while ((ch = getopt(argc, argv, "cg:o:s:t:u:")) != -1) {
switch (ch) {
#ifdef notyet
case 'c' :
args->udfmflags |= UDFMNT_CLOSESESSION;
break;
#endif
case 'g' :
/* convert groupname or numeric equiv. */
anon_gid = a_gid(optarg);
break;
case 'u' :
/* convert username or numeric equiv. */
anon_uid = a_uid(optarg);
break;
case 'o' :
/* process generic mount options */
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL) {
warn("getmntopts");
return 1;
}
freemntopts(mp);
break;
case 's' :
args->sessionnr = a_num(optarg, "session number");
break;
case 't' :
args->gmtoff = a_num(optarg, "gmtoff");
set_gmtoff = 1;
break;
default :
return 1;
/* NOTREACHED */
}
}
if (optind + 2 != argc)
return 1;
if (!set_gmtoff) {
#ifdef HAVE_STRUCT_TM_TM_GMTOFF
time_t now;
struct tm *tm;
/* use user's time zone as default */
(void)time(&now);
tm = localtime(&now);
args->gmtoff = tm->tm_gmtoff;
#else
args->gmtoff = 0;
#endif
}
/* get device and directory specifier */
pathadj(argv[optind], canon_dev);
pathadj(argv[optind+1], canon_dir);
args->version = UDFMNT_VERSION;
args->fspec = canon_dev;
args->anon_uid = anon_uid;
args->anon_gid = anon_gid;
args->nobody_uid = nobody_uid;
args->nobody_gid = nobody_gid;
args->sector_size = sector_size; /* invalid */
return 0;
}
int
main(int argc, char *argv[])
{
struct vfsconf vfc;
mntoptparse_t mp;
struct stat st;
char *name, *srv, *p;
char *port, *asrv, *aport;
char mntpath[MAXPATHLEN];
char pass[NAMELEN], akey[DESKEYLEN];
int mntflags, altflags, noauth, c;
getmnt_silent = 0;
mntflags = 0;
altflags = 0;
pass[0] = '\0';
port = "564";
asrv = NULL;
aport = "567";
noauth = 0;
while ((c=getopt(argc, argv, "ho:")) != -1) {
switch(c) {
case 'o':
altflags = 0;
mp = getmntopts(optarg, mopts, &mntflags, &altflags);
if (mp == NULL)
err(EX_USAGE, "getmntopts: %s", optarg);
if (altflags & ALTF_UNAME)
args.uname = egetmntoptstr(mp, "uname");
if (altflags & ALTF_ANAME)
args.aname = egetmntoptstr(mp, "aname");
if (altflags & ALTF_VOLUME)
args.volume = egetmntoptstr(mp, "volume");
if (altflags & ALTF_PASS) {
p = egetmntoptstr(mp, "pass");
strlcpy(pass, p, NAMELEN);
}
if (altflags & ALTF_PORT)
port = egetmntoptstr(mp, "port");
if (altflags & ALTF_ASRV)
asrv = egetmntoptstr(mp, "asrv");
if (altflags & ALTF_APORT)
aport = egetmntoptstr(mp, "aport");
if (altflags & ALTF_NOAUTH)
noauth = 1;
/* flags */
if (altflags & ALTF_CHATTY9P)
args.flags |= FLAG_CHATTY9P;
if (altflags & ALTF_DSSTORE)
args.flags &= ~FLAG_DSSTORE;
if (altflags & ALTF_DOTU)
args.flags |= FLAG_DOTU;
freemntopts(mp);
break;
default:
Usage:
fprintf(stderr, "Usage: mount_%s [-o options] srv node\n", VFS9PNAME);
exit(EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc != 2)
goto Usage;
srv = *argv++;
name = *argv;
// check path
if (!realpath(name, mntpath) || stat(mntpath, &st)<0)
err(EX_USAGE, "%s", mntpath);
if (!S_ISDIR(st.st_mode)) {
errno = ENOTDIR;
err(EX_USAGE, "%s", mntpath);
}
if (*srv == '/')
noauth++;
getaddr(&args.addr, &args.addrlen, srv, port);
if (!noauth) {
if (asrv == NULL)
asrv = srv;
getaddr(&args.authaddr, &args.authaddrlen, asrv, aport);
if (*pass == '\0') {
if (!readpassphrase("Password: "******"USER");
if (!args.uname)
args.uname = "none";
args.spec = srv;
if (getvfsbyname(VFS9PNAME, &vfc) < 0) {
if (load9p() < 0)
err(1, NULL);
if (getvfsbyname(VFS9PNAME, &vfc) < 0)
errx(EX_UNAVAILABLE, "%s filesystem is not available", VFS9PNAME);
}
if (mount(vfc.vfc_name, mntpath, mntflags, &args) < 0)
err(1, "mount %s %s", srv, mntpath);
return 0;
}
int
main(int argc, char *argv[])
{
struct psshfs_ctx pctx;
struct puffs_usermount *pu;
struct puffs_ops *pops;
struct psshfs_node *root = &pctx.psn_root;
struct puffs_node *pn_root;
puffs_framev_fdnotify_fn notfn;
struct vattr *rva;
mntoptparse_t mp;
char **sshargs;
char *user;
char *host;
char *path;
int mntflags, pflags, ch;
int detach;
int exportfs, refreshival, numconnections;
int nargs;
setprogname(argv[0]);
puffs_unmountonsignal(SIGINT, true);
puffs_unmountonsignal(SIGTERM, true);
if (argc < 3)
usage();
memset(&pctx, 0, sizeof(pctx));
mntflags = pflags = exportfs = nargs = 0;
numconnections = 1;
detach = 1;
refreshival = DEFAULTREFRESH;
notfn = puffs_framev_unmountonclose;
sshargs = NULL;
add_ssharg(&sshargs, &nargs, SSH_PATH);
add_ssharg(&sshargs, &nargs, "-axs");
add_ssharg(&sshargs, &nargs, "-oClearAllForwardings=yes");
while ((ch = getopt(argc, argv, "c:eF:g:o:O:pr:st:u:")) != -1) {
switch (ch) {
case 'c':
numconnections = atoi(optarg);
if (numconnections < 1 || numconnections > 2) {
fprintf(stderr, "%s: only 1 or 2 connections "
"permitted currently\n", getprogname());
usage();
/*NOTREACHED*/
}
break;
case 'e':
exportfs = 1;
break;
case 'F':
add_ssharg(&sshargs, &nargs, "-F");
add_ssharg(&sshargs, &nargs, optarg);
break;
case 'g':
pctx.domanglegid = 1;
pctx.manglegid = atoi(optarg);
if (pctx.manglegid == (gid_t)-1)
errx(1, "-1 not allowed for -g");
pctx.mygid = getegid();
break;
case 'O':
add_ssharg(&sshargs, &nargs, "-o");
add_ssharg(&sshargs, &nargs, optarg);
break;
case 'o':
mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case 'p':
notfn = psshfs_notify;
break;
case 'r':
max_reads = atoi(optarg);
break;
case 's':
detach = 0;
break;
case 't':
refreshival = atoi(optarg);
if (refreshival < 0 && refreshival != -1)
errx(1, "invalid timeout %d", refreshival);
break;
case 'u':
pctx.domangleuid = 1;
pctx.mangleuid = atoi(optarg);
if (pctx.mangleuid == (uid_t)-1)
errx(1, "-1 not allowed for -u");
pctx.myuid = geteuid();
break;
default:
usage();
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (pflags & PUFFS_FLAG_OPDUMP)
detach = 0;
pflags |= PUFFS_FLAG_BUILDPATH;
pflags |= PUFFS_KFLAG_WTCACHE | PUFFS_KFLAG_IAONDEMAND;
if (argc != 2)
usage();
PUFFSOP_INIT(pops);
PUFFSOP_SET(pops, psshfs, fs, unmount);
PUFFSOP_SETFSNOP(pops, sync); /* XXX */
PUFFSOP_SET(pops, psshfs, fs, statvfs);
PUFFSOP_SET(pops, psshfs, fs, nodetofh);
PUFFSOP_SET(pops, psshfs, fs, fhtonode);
PUFFSOP_SET(pops, psshfs, node, lookup);
PUFFSOP_SET(pops, psshfs, node, create);
PUFFSOP_SET(pops, psshfs, node, open);
PUFFSOP_SET(pops, psshfs, node, inactive);
PUFFSOP_SET(pops, psshfs, node, readdir);
PUFFSOP_SET(pops, psshfs, node, getattr);
PUFFSOP_SET(pops, psshfs, node, setattr);
PUFFSOP_SET(pops, psshfs, node, mkdir);
PUFFSOP_SET(pops, psshfs, node, remove);
PUFFSOP_SET(pops, psshfs, node, readlink);
PUFFSOP_SET(pops, psshfs, node, rmdir);
PUFFSOP_SET(pops, psshfs, node, symlink);
PUFFSOP_SET(pops, psshfs, node, rename);
PUFFSOP_SET(pops, psshfs, node, read);
PUFFSOP_SET(pops, psshfs, node, write);
PUFFSOP_SET(pops, psshfs, node, reclaim);
pu = puffs_init(pops, argv[0], "psshfs", &pctx, pflags);
if (pu == NULL)
err(1, "puffs_init");
pctx.mounttime = time(NULL);
pctx.refreshival = refreshival;
pctx.numconnections = numconnections;
user = strdup(argv[0]);
if ((host = strrchr(user, '@')) == NULL) {
host = user;
} else {
*host++ = '\0'; /* break at the '@' */
if (user[0] == '\0') {
fprintf(stderr, "Missing username\n");
usage();
}
add_ssharg(&sshargs, &nargs, "-l");
add_ssharg(&sshargs, &nargs, user);
}
if ((path = colon(host)) != NULL) {
*path++ = '\0'; /* break at the ':' */
pctx.mountpath = path;
} else {
pctx.mountpath = ".";
}
host = cleanhostname(host);
if (host[0] == '\0') {
fprintf(stderr, "Missing hostname\n");
usage();
}
add_ssharg(&sshargs, &nargs, host);
add_ssharg(&sshargs, &nargs, "sftp");
pctx.sshargs = sshargs;
pctx.nextino = 2;
memset(root, 0, sizeof(struct psshfs_node));
TAILQ_INIT(&root->pw);
pn_root = puffs_pn_new(pu, root);
if (pn_root == NULL)
return errno;
puffs_setroot(pu, pn_root);
puffs_framev_init(pu, psbuf_read, psbuf_write, psbuf_cmp, NULL, notfn);
signal(SIGHUP, takehup);
puffs_ml_setloopfn(pu, psshfs_loopfn);
if (pssh_connect(pu, PSSHFD_META) == -1)
err(1, "can't connect meta");
if (puffs_framev_addfd(pu, pctx.sshfd,
PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
err(1, "framebuf addfd meta");
if (numconnections == 2) {
if (pssh_connect(pu, PSSHFD_DATA) == -1)
err(1, "can't connect data");
if (puffs_framev_addfd(pu, pctx.sshfd_data,
PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
err(1, "framebuf addfd data");
} else {
pctx.sshfd_data = pctx.sshfd;
}
if (exportfs)
puffs_setfhsize(pu, sizeof(struct psshfs_fid),
PUFFS_FHFLAG_NFSV2 | PUFFS_FHFLAG_NFSV3);
rva = &pn_root->pn_va;
rva->va_fileid = pctx.nextino++;
/*
* For root link count, just guess something ridiculously high.
* Guessing too high has no known adverse effects, but fts(3)
* doesn't like too low values. This guess will be replaced
* with the real value when readdir is first called for
* the root directory.
*/
rva->va_nlink = 8811;
if (detach)
if (puffs_daemon(pu, 1, 1) == -1)
err(1, "puffs_daemon");
if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
err(1, "puffs_mount");
if (puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK) == -1)
err(1, "setblockingmode");
if (puffs_mainloop(pu) == -1)
err(1, "mainloop");
puffs_exit(pu, 1);
return 0;
}
void
mount_cd9660_parseargs(int argc, char **argv,
struct iso_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
int ch, opts;
mntoptparse_t mp;
char *dev, *dir;
*mntflags = opts = 0;
memset(args, 0, sizeof(*args));
while ((ch = getopt(argc, argv, "egijo:r")) != -1)
switch (ch) {
case 'e':
/* obsolete, retained for compatibility only, use
* -o extatt */
opts |= ISOFSMNT_EXTATT;
break;
case 'g':
/* obsolete, retained for compatibility only, use
* -o gens */
opts |= ISOFSMNT_GENS;
break;
case 'j':
/* obsolete, retained fo compatibility only, use
* -o nojoliet */
opts |= ISOFSMNT_NOJOLIET;
break;
case 'o':
mp = getmntopts(optarg, mopts, mntflags, &opts);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case 'r':
/* obsolete, retained for compatibility only, use
* -o norrip */
opts |= ISOFSMNT_NORRIP;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
dev = argv[0];
dir = argv[1];
pathadj(dev, canon_dev);
pathadj(dir, canon_dir);
#define DEFAULT_ROOTUID -2
/*
* ISO 9660 filesystems are not writable.
*/
*mntflags |= MNT_RDONLY;
args->fspec = dev;
args->flags = opts;
}
int
main(int argc, char **argv)
{
int c;
int usenetauth = 0;
mntoptparse_t mp;
int flags, altflags;
CFURLRef URL;
CFStringRef mountdir_CFString;
CFMutableDictionaryRef open_options, mount_options;
CFDictionaryRef mount_info;
int res;
flags = altflags = 0;
getmnt_silent = 1;
while ((c = getopt(argc, argv, "no:rw")) != -1) {
switch (c) {
case 'n':
usenetauth = 1;
break;
case 'o':
/*
* OK, parse these options, and update the flags.
*/
mp = getmntopts(optarg, mopts_std, &flags, &altflags);
freemntopts(mp);
break;
case 'r':
flags |= MNT_RDONLY;
break;
case 'w':
flags &= ~MNT_RDONLY;
break;
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
/*
* Nothing can stop the Duke of...
*/
URL = CFURLCreateWithBytes(kCFAllocatorDefault, (const UInt8 *)argv[0],
strlen(argv[0]), kCFStringEncodingUTF8, NULL);
if (URL == NULL)
exit(ENOMEM);
mountdir_CFString = CFStringCreateWithCString(kCFAllocatorDefault,
argv[1], kCFStringEncodingUTF8);
if (mountdir_CFString == NULL)
exit(ENOMEM);
open_options = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (open_options == NULL)
exit(ENOMEM);
/*
* It's OK to use an existing session.
*/
CFDictionaryAddValue(open_options, kNetFSForceNewSessionKey,
kCFBooleanFalse);
/*
* And it's OK to mount something from ourselves.
*/
CFDictionaryAddValue(open_options, kNetFSAllowLoopbackKey,
kCFBooleanTrue);
/*
* This could be mounting a home directory, so we don't want
* the mount to look at user preferences in the home directory.
*/
CFDictionaryAddValue(open_options, kNetFSNoUserPreferencesKey,
kCFBooleanTrue);
/*
* We don't want any UI popped up for the mount.
*/
CFDictionaryAddValue(open_options, kUIOptionKey, kUIOptionNoUI);
mount_options = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (mount_options == NULL)
exit(ENOMEM);
/*
* It's OK to use an existing session.
*/
CFDictionaryAddValue(mount_options, kNetFSForceNewSessionKey,
kCFBooleanFalse);
/*
* We want the URL mounted exactly where we specify.
*/
CFDictionaryAddValue(mount_options, kNetFSMountAtMountDirKey,
kCFBooleanTrue);
/*
* This could be mounting a home directory, so we don't want
* the mount to look at user preferences in the home directory.
*/
CFDictionaryAddValue(mount_options, kNetFSNoUserPreferencesKey,
kCFBooleanTrue);
/*
* We want to allow the URL to specify a directory underneath
* a share point for file systems that support the notion of
* shares.
*/
CFDictionaryAddValue(mount_options, kNetFSAllowSubMountsKey,
kCFBooleanTrue);
/*
* Add the mount flags.
*/
CFDictionaryAddValue(mount_options, kNetFSMountFlagsKey,
CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
&flags));
/*
* Add the soft mount flag.
*/
CFDictionaryAddValue(mount_options, kNetFSSoftMountKey,
(altflags & ALT_SOFT) ? kCFBooleanTrue : kCFBooleanFalse);
/*
* We don't want any UI popped up for the mount.
*/
CFDictionaryAddValue(mount_options, kUIOptionKey, kUIOptionNoUI);
if (usenetauth)
res = NAConnectToServerSync(URL, mountdir_CFString,
open_options, mount_options, &mount_info);
else
res = do_mount_direct(URL, mountdir_CFString, open_options,
mount_options, &mount_info);
/*
* 0 means "no error", EEXIST means "that's already mounted, and
* mountinfo says where it's mounted". In those cases, a
* directory of mount information was returned; release it.
*/
if (res == 0 || res == EEXIST)
CFRelease(mount_info);
CFRelease(mount_options);
CFRelease(open_options);
CFRelease(mountdir_CFString);
CFRelease(URL);
if (res != 0) {
/*
* Report any failure status that doesn't fit in the
* 8 bits of a UN*X exit status, and map it to EIO
* by default and EAUTH for ENETFS errors.
*/
if ((res & 0xFFFFFF00) != 0) {
syslog(LOG_ERR,
"mount_url: Mount of %s on %s gives status %d",
argv[0], argv[1], res);
switch (res) {
case ENETFSACCOUNTRESTRICTED:
case ENETFSPWDNEEDSCHANGE:
case ENETFSPWDPOLICY:
res = EAUTH;
break;
default:
res = EIO;
break;
}
}
}
return res;
}
int
main(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
struct puffs_usermount *pu;
struct puffs_pathobj *po_root;
struct puffs_ops *pops;
struct timespec ts;
const char *typename;
char *rtstr;
mntoptparse_t mp;
int pflags, detach, mntflags;
int ch;
int khashbuckets;
int maxreqsize;
setprogname(argv[0]);
rtstr = NULL;
detach = 1;
mntflags = 0;
khashbuckets = 256;
pflags = PUFFS_KFLAG_IAONDEMAND;
typename = FSNAME;
maxreqsize = MAXREQMAGIC;
gdtm.dtm_allowprot = VM_PROT_ALL;
while ((ch = getopt(argc, argv, "bc:dfilm:n:o:p:r:st")) != -1) {
switch (ch) {
case 'b': /* build paths, for debugging the feature */
pflags |= PUFFS_FLAG_BUILDPATH;
break;
case 'c':
khashbuckets = atoi(optarg);
break;
case 'd':
dynamicfh = 1;
break;
case 'f':
pflags |= PUFFS_KFLAG_LOOKUP_FULLPNBUF;
break;
case 'i':
pflags &= ~PUFFS_KFLAG_IAONDEMAND;
break;
case 'l':
straightflush = 1;
break;
case 'm':
maxreqsize = atoi(optarg);
break;
case 'n':
typename = optarg;
break;
case 'o':
mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
if (mp == NULL)
err(1, "getmntopts");
freemntopts(mp);
break;
case 'p':
gdtm.dtm_allowprot = atoi(optarg);
if ((gdtm.dtm_allowprot | VM_PROT_ALL) != VM_PROT_ALL)
usage();
break;
case 'r':
rtstr = optarg;
break;
case 's': /* stay on top */
detach = 0;
break;
case 't':
pflags |= PUFFS_KFLAG_WTCACHE;
break;
default:
usage();
/*NOTREACHED*/
}
}
if (pflags & PUFFS_FLAG_OPDUMP)
detach = 0;
argc -= optind;
argv += optind;
if (argc != 2)
usage();
PUFFSOP_INIT(pops);
PUFFSOP_SET(pops, dtfs, fs, statvfs);
PUFFSOP_SET(pops, dtfs, fs, unmount);
PUFFSOP_SETFSNOP(pops, sync);
PUFFSOP_SET(pops, dtfs, fs, fhtonode);
PUFFSOP_SET(pops, dtfs, fs, nodetofh);
PUFFSOP_SET(pops, dtfs, node, lookup);
PUFFSOP_SET(pops, dtfs, node, access);
PUFFSOP_SET(pops, puffs_genfs, node, getattr);
PUFFSOP_SET(pops, dtfs, node, setattr);
PUFFSOP_SET(pops, dtfs, node, create);
PUFFSOP_SET(pops, dtfs, node, remove);
PUFFSOP_SET(pops, dtfs, node, readdir);
PUFFSOP_SET(pops, dtfs, node, poll);
PUFFSOP_SET(pops, dtfs, node, mmap);
PUFFSOP_SET(pops, dtfs, node, mkdir);
PUFFSOP_SET(pops, dtfs, node, rmdir);
PUFFSOP_SET(pops, dtfs, node, rename);
PUFFSOP_SET(pops, dtfs, node, read);
PUFFSOP_SET(pops, dtfs, node, write);
PUFFSOP_SET(pops, dtfs, node, link);
PUFFSOP_SET(pops, dtfs, node, symlink);
PUFFSOP_SET(pops, dtfs, node, readlink);
PUFFSOP_SET(pops, dtfs, node, mknod);
PUFFSOP_SET(pops, dtfs, node, inactive);
PUFFSOP_SET(pops, dtfs, node, pathconf);
PUFFSOP_SET(pops, dtfs, node, reclaim);
srandom(time(NULL)); /* for random generation numbers */
pu = puffs_init(pops, _PATH_PUFFS, typename, &gdtm, pflags);
if (pu == NULL)
err(1, "init");
gpu = pu;
puffs_setfhsize(pu, sizeof(struct dtfs_fid),
PUFFS_FHFLAG_NFSV2 | PUFFS_FHFLAG_NFSV3
| (dynamicfh ? PUFFS_FHFLAG_DYNAMIC : 0));
puffs_setncookiehash(pu, khashbuckets);
if (signal(SIGALRM, wipe_the_sleep_out_of_my_eyes) == SIG_ERR)
warn("cannot set alarm sighandler");
/* init */
if (dtfs_domount(pu, rtstr) != 0)
errx(1, "dtfs_domount failed");
po_root = puffs_getrootpathobj(pu);
po_root->po_path = argv[0];
po_root->po_len = strlen(argv[0]);
/* often enough for testing poll */
ts.tv_sec = 1;
ts.tv_nsec = 0;
puffs_ml_setloopfn(pu, loopfun);
puffs_ml_settimeout(pu, &ts);
if (maxreqsize != MAXREQMAGIC)
puffs_setmaxreqlen(pu, maxreqsize);
puffs_set_errnotify(pu, puffs_kernerr_abort);
if (detach)
if (puffs_daemon(pu, 1, 1) == -1)
err(1, "puffs_daemon");
if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
err(1, "mount");
if (puffs_mainloop(pu) == -1)
err(1, "mainloop");
return 0;
}
int
mount_msdos_parseargs(int argc, char **argv,
struct msdosfs_args *args, int *mntflags,
char *canon_dev, char *canon_dir)
{
struct stat sb;
int c, set_gid, set_uid, set_mask, set_dirmask, set_gmtoff;
char *dev, *dir;
mntoptparse_t mp;
*mntflags = set_gid = set_uid = set_mask = set_dirmask = set_gmtoff = 0;
(void)memset(args, '\0', sizeof(*args));
while ((c = getopt(argc, argv, "Gsl9u:g:m:M:o:t:")) != -1) {
switch (c) {
case 'G':
args->flags |= MSDOSFSMNT_GEMDOSFS;
break;
case 's':
args->flags |= MSDOSFSMNT_SHORTNAME;
break;
case 'l':
args->flags |= MSDOSFSMNT_LONGNAME;
break;
case '9':
args->flags |= MSDOSFSMNT_NOWIN95;
break;
case 'u':
args->uid = a_uid(optarg);
set_uid = 1;
break;
case 'g':
args->gid = a_gid(optarg);
set_gid = 1;
break;
case 'm':
args->mask = a_mask(optarg);
set_mask = 1;
break;
case 'M':
args->dirmask = a_mask(optarg);
set_dirmask = 1;
break;
case 'o':
mp = getmntopts(optarg, mopts, mntflags, 0);
if (mp == NULL) {
warn("getmntopts");
return 1;
}
freemntopts(mp);
break;
case 't':
args->gmtoff = atoi(optarg);
set_gmtoff = 1;
break;
case '?':
default:
return 1;
}
}
if (optind + 2 != argc) {
return 1;
}
if (set_mask && !set_dirmask) {
args->dirmask = args->mask;
} else if (set_dirmask && !set_mask) {
args->mask = args->dirmask;
set_mask = 1;
}
dev = argv[optind];
dir = argv[optind + 1];
pathadj(dev, canon_dev);
pathadj(dir, canon_dir);
args->fspec = dev;
if (!set_gid || !set_uid || !set_mask) {
if (stat(dir, &sb) == -1) {
warn("stat %s", dir);
return 1;
}
if (!set_uid)
args->uid = sb.st_uid;
if (!set_gid)
args->gid = sb.st_gid;
if (!set_mask) {
args->mask = args->dirmask =
sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
}
if (!set_gmtoff) {
#ifdef HAVE_STRUCT_TM_TM_GMTOFF
time_t now;
struct tm *tm;
/* use user's time zone as default */
time(&now);
tm = localtime(&now);
args->gmtoff = tm->tm_gmtoff;
#else
args->gmtoff = 0;
#endif
}
args->flags |= MSDOSFSMNT_VERSIONED;
args->version = MSDOSFSMNT_VERSION;
return 0;
}
