xref: /illumos-gate/usr/src/cmd/fs.d/smbclnt/fksmbcl/fksmbcl_main.c (revision 8509e9ca)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2018 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * Test & debug program for the SMB client
 *
 * This implements a simple command reader which accepts
 * commands to simulate system calls into the file system.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/dirent.h>
#include <sys/strlog.h>		/* SL_NOTE */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <unistd.h>

#include <sys/fs/smbfs_mount.h>
#include <netsmb/smb_lib.h>
#include <libfknsmb/common/libfknsmb.h>
#include <libfksmbfs/common/libfksmbfs.h>

#if _FILE_OFFSET_BITS != 64
#error "This calls (fake) VFS code which requires 64-bit off_t"
#endif

extern int list_shares(struct smb_ctx *);

#define	MAXARG	10

struct cmd_tbl_ent {
	void (*ce_func)(int, char **);
	const char *ce_name;
	const char *ce_argdesc;
};
static struct cmd_tbl_ent cmd_tbl[];

static struct smb_ctx *ctx = NULL;
static char *server = NULL;

static vfs_t *vfsp = NULL;

static void show_dents(vnode_t *, offset_t *, char *, int);
static void run_cli(void);

#define	TBUFSZ 8192
static char tbuf[TBUFSZ];

static void
fksmbcl_usage(void)
{
	printf("usage: fksmbcl //user@server (like smbutil)\n");
	exit(1);
}

int
main(int argc, char *argv[])
{
	int error, opt;

	/*
	 * Initializations
	 */
	nsmb_drv_load();
	nsmb_drv_init();
	fksmbfs_init();

	while ((opt = getopt(argc, argv, "dv")) != -1) {
		switch (opt) {
		case 'd':
			smb_debug++;
			break;
		case 'v':
			smb_verbose++;
			break;
		case '?':
			fksmbcl_usage();
			break;
		}
	}
	if (optind >= argc)
		fksmbcl_usage();
	server = argv[optind];

	/*
	 * Setup the libsmbfs context
	 */
	error = smb_ctx_alloc(&ctx);
	if (error) {
		fprintf(stderr, "%s: smb_ctx_alloc failed (%d)\n",
		    argv[0], error);
		return (1);
	}

	error = smb_ctx_scan_argv(ctx, argc, argv,
	    SMBL_SERVER, SMBL_SERVER, USE_WILDCARD);
	if (error) {
		fprintf(stderr, "logon: smb_ctx_scan_argv, error %d\n", error);
		return (1);
	}
	error = smb_ctx_readrc(ctx);
	if (error) {
		fprintf(stderr, "logon: smb_ctx_readrc, error %d\n", error);
		return (1);
	}

	/* Do smb_ctx_setshare later, and smb_ctx_resolve. */

	/*
	 * Next would be smb_ctx_get_ssn() but don't do that until
	 * the "logon" command so one can set breakpoints etc.
	 */

	/*
	 * Run the CLI
	 */
	run_cli();

	/*
	 * Cleanup
	 */
	fksmbfs_fini();
	nsmb_drv_fini();

	return (0);
}

static void
run_cli()
{
	static char cmdbuf[100];
	int argc, i;
	char *argv[MAXARG];
	char *cmd;
	char *savep = NULL;
	char *sep = " \t\n";
	char *prompt = NULL;
	struct cmd_tbl_ent *ce;

	if (isatty(0)) {
		fputs("# Start with:\n"
		    "> logon [user [dom [pw]]]\n"
		    "> shares\n"
		    "> mount {share}\n\n",
		    stdout);
		prompt = "> ";
	}

	for (;;) {
		if (prompt) {
			fputs(prompt, stdout);
			fflush(stdout);
		}

		cmd = fgets(cmdbuf, sizeof (cmdbuf), stdin);
		if (cmd == NULL)
			break;
		if (cmd[0] == '#')
			continue;

		if (prompt == NULL) {
			/* Put commands in the output too. */
			fprintf(stdout, "+ %s", cmdbuf);
		}

		argv[0] = strtok_r(cmd, sep, &savep);
		if (argv[0] == NULL)
			continue;
		for (argc = 1; argc < MAXARG; argc++) {
			argv[argc] = strtok_r(NULL, sep, &savep);
			if (argv[argc] == NULL)
				break;
		}
		for (i = argc; i < MAXARG; i++)
			argv[i++] = NULL;

		for (ce = cmd_tbl; ce->ce_name != NULL; ce++)
			if (strcmp(ce->ce_name, argv[0]) == 0)
				break;
		if (ce->ce_name != NULL) {
			ce->ce_func(argc, argv);
		} else {
			fprintf(stderr, "%s unknown command. Try help\n",
			    argv[0]);
		}
	}
}

/*
 * Command handlers
 */

static void
do_exit(int argc, char **argv)
{
	exit(0);
}

static void
do_help(int argc, char **argv)
{
	struct cmd_tbl_ent *ce;

	printf("Commands:\n");
	for (ce = cmd_tbl; ce->ce_func != NULL; ce++)
		printf("%s %s\n", ce->ce_name, ce->ce_argdesc);
}

static void
do_logon(int argc, char **argv)
{
	int error;

	if (argc > 1) {
		if (argv[1][0] == '-') {
			smb_ctx_setuser(ctx, "", B_TRUE);
			ctx->ct_flags |= SMBCF_NOPWD;
		} else {
			smb_ctx_setuser(ctx, argv[1], B_TRUE);
		}
	}
	if (argc > 2)
		smb_ctx_setdomain(ctx, argv[2], B_TRUE);
	if (argc > 3)
		smb_ctx_setpassword(ctx, argv[3], 0);

	/*
	 * Resolve the server address, setup derived defaults.
	 */
	error = smb_ctx_resolve(ctx);
	if (error) {
		fprintf(stderr, "logon: smb_ctx_resolve, error %d\n", error);
		return;
	}

	/*
	 * Have server, share, etc. now.
	 * Get the logon session.
	 */
again:
	error = smb_ctx_get_ssn(ctx);
	if (error == EAUTH) {
		int err2;
		err2 = smb_get_authentication(ctx);
		if (err2 == 0)
			goto again;
	}
	if (error) {
		fprintf(stderr, "//%s: login failed, error %d\n",
		    ctx->ct_fullserver, error);
	}
}

/*
 * Drop session created by the "logon" command.
 */
static void
do_logoff(int argc, char **argv)
{

	(void) nsmb_ioctl(ctx->ct_dev_fd, SMBIOC_SSN_RELE, NULL);
	if (argc > 1) {
		smb_ctx_done(ctx);
		(void) smb_ctx_init(ctx);
	}
}

/*
 * List shares
 */
static void
do_shares(int argc, char **argv)
{
	int error;

	smb_ctx_setshare(ctx, "IPC$", USE_IPC);
	error = smb_ctx_get_tree(ctx);
	if (error) {
		fprintf(stderr, "shares, tcon IPC$, error=%d\n", error);
		return;
	}

	error = list_shares(ctx);
	if (error) {
		fprintf(stderr, "shares, enum, error=%d\n", error);
	}

	(void) nsmb_ioctl(ctx->ct_dev_fd, SMBIOC_TREE_RELE, NULL);
}

char mnt_opt_buf[MAX_MNTOPT_STR];
char mnt_resource[MAXPATHLEN];

/*
 * Minimal excerpt from vfs.c:domount()
 */
void
do_mount(int argc, char **argv)
{
	struct smbfs_args mdata;
	struct mounta ma;
	char *shrname;
	int error;

	if (vfsp != NULL) {
		fprintf(stderr, "Already mounted\n");
		return;
	}

	if (argc < 2) {
		fprintf(stderr, "%s: missing share name\n", argv[0]);
		return;
	}
	shrname = argv[1];
	if (argc > 2)
		strlcpy(mnt_opt_buf, argv[2], sizeof (mnt_opt_buf));
	else
		memset(mnt_opt_buf, 0, sizeof (mnt_opt_buf));

	smb_ctx_setshare(ctx, shrname, USE_DISKDEV);
	error = smb_ctx_get_tree(ctx);
	if (error) {
		fprintf(stderr, "//%s/%s: tree connect failed, %d\n",
		    server, shrname, error);
		return;
	}

	(void) snprintf(mnt_resource, sizeof (mnt_resource),
	    "//%s/%s", ctx->ct_fullserver, shrname);

	bzero(&mdata, sizeof (mdata));
	mdata.version = SMBFS_VERSION;		/* smbfs mount version */
	mdata.file_mode = S_IRWXU;
	mdata.dir_mode = S_IRWXU;
	mdata.devfd = ctx->ct_dev_fd;

	/* Build mount args */
	bzero(&ma, sizeof (ma));
	ma.spec = mnt_resource;
	ma.dir = "/";
	ma.flags =  MS_DATA | MS_OPTIONSTR | MS_NOSPLICE | MS_NOSUID;
	ma.fstype = "smbfs";
	ma.dataptr = (void *) &mdata;
	ma.datalen = sizeof (mdata);
	ma.optptr = mnt_opt_buf;
	ma.optlen = sizeof (mnt_opt_buf);

	error = fake_domount("smbfs", &ma, &vfsp);
	if (error != 0) {
		fprintf(stderr, "domount error=%d\n", error);
	}

	/* Mount takes a ref, so always rele here. */
	(void) nsmb_ioctl(ctx->ct_dev_fd, SMBIOC_TREE_RELE, NULL);
}

void
do_unmount(int argc, char **argv)
{
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "Not mounted\n");
		return;
	}

	error = fake_dounmount(vfsp, 0);
	if (error != 0) {
		fprintf(stderr, "dounmount error=%d\n", error);
		return;
	}
	vfsp = NULL;
}

void
do_statfs(int argc, char **argv)
{
	statvfs64_t st;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "Not mounted\n");
		return;
	}

	error = fsop_statfs(vfsp, &st);
	if (error != 0) {
		fprintf(stderr, "df error=%d\n", error);
		return;
	}
	printf("bsize=%ld\n", st.f_bsize);
	printf("frsize=%ld\n", st.f_frsize);
	printf("blocks=%" PRIu64 "\n", st.f_blocks);
	printf(" bfree=%" PRIu64 "\n", st.f_bfree);
	printf("bavail=%" PRIu64 "\n", st.f_bavail);
}

void
do_dir(int argc, char **argv)
{
	char *rdir;
	vnode_t *vp = NULL;
	offset_t off;
	int cnt;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc > 1)
		rdir = argv[1];
	else
		rdir = "";

	error = vn_open(rdir, 0, FREAD, 0, &vp, 0, 0);
	if (error != 0) {
		fprintf(stderr, "do_dir, vn_open error=%d\n", error);
		return;
	}

	off = 0;
	do {
		cnt = fake_getdents(vp, &off, tbuf, TBUFSZ);
		if (cnt < 0) {
			fprintf(stderr, "do_dir, getdents %d\n", -cnt);
			break;
		}
		show_dents(vp, &off, tbuf, cnt);
	} while (cnt > 0);

	if (vp != NULL)
		vn_close_rele(vp, 0);
}

void
do_dirx(int argc, char **argv)
{
	char *rdir;
	vnode_t *vp = NULL;
	offset_t off;
	int cnt;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc > 1)
		rdir = argv[1];
	else
		rdir = "";

	error = vn_open(rdir, 0, FREAD|FXATTRDIROPEN, 0, &vp, 0, 0);
	if (error != 0) {
		fprintf(stderr, "do_dirx, vn_open error=%d\n", error);
		return;
	}

	off = 0;
	do {
		cnt = fake_getdents(vp, &off, tbuf, TBUFSZ);
		if (cnt < 0) {
			fprintf(stderr, "do_dirx, getdents %d\n", -cnt);
			break;
		}
		show_dents(vp, &off, tbuf, cnt);
	} while (cnt > 0);

	if (vp != NULL)
		vn_close_rele(vp, 0);
}

static void
show_dents(vnode_t *dvp, offset_t *offp, char *buf, int cnt)
{
	char time_buf[40];
	struct stat64 st;
	vnode_t *vp;
	char *p;
	dirent_t *d;
	offset_t offset = (offset_t)-1L;
	int error;
	uint_t mode;
	char type;

	p = buf;
	while (p < (buf + cnt)) {
		d = (dirent_t *)(void *)p;
		p += d->d_reclen;
		offset = d->d_off;

		error = fake_lookup(dvp, d->d_name, &vp);
		if (error != 0) {
			fprintf(stderr, "%s: lookup error=%d\n",
			    d->d_name, error);
			continue;
		}
		error = fake_stat(vp, &st, 0);
		vn_rele(vp);
		if (error != 0) {
			fprintf(stderr, "%s: stat error=%d\n",
			    d->d_name, error);
			continue;
		}

		/*
		 * Print type, mode, size, name
		 * First mode (only dir, file expected here)
		 */
		if (S_ISDIR(st.st_mode)) {
			type = 'd';
		} else if (S_ISREG(st.st_mode)) {
			type = ' ';
		} else {
			type = '?';
		}
		mode = st.st_mode & 0777;
		(void) strftime(time_buf, sizeof (time_buf),
		    "%b %e %T %Y", localtime(&st.st_mtime));

		printf("%c 0%3o %9" PRIu64 "  %s  %s\n",
		    type, mode,
		    (uint64_t)st.st_size,
		    time_buf,
		    d->d_name);
	}
	*offp = offset;
}

/*
 * get rname [lname]
 */
void
do_get(int argc, char **argv)
{
	struct stat64 st;
	char *rname;
	char *lname;
	vnode_t *vp = NULL;
	offset_t off;
	ssize_t cnt, x;
	int oflg = O_RDWR | O_CREAT;
	int lfd = -1;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 2) {
		fprintf(stderr, "rname required\n");
		return;
	}
	rname = argv[1];
	if (argc > 2) {
		lname = argv[2];
		/*
		 * When local name is specified, overwrite.
		 * Convenient for scripts etc.
		 */
		oflg |= O_TRUNC;
	} else {
		lname = rname;
		/* Local file should not exist. */
		oflg |= O_EXCL;
	}

	lfd = open(lname, oflg, 0644);
	if (lfd < 0) {
		perror(lname);
		return;
	}

	error = vn_open(rname, 0, FREAD, 0, &vp, 0, 0);
	if (error != 0) {
		fprintf(stderr, "do_get, vn_open error=%d\n", error);
		goto out;
	}
	error = fake_stat(vp, &st, 0);
	if (error != 0) {
		fprintf(stderr, "do_get, stat error=%d\n", error);
		goto out;
	}

	off = 0;
	do {
		cnt = fake_pread(vp, tbuf, TBUFSZ, off);
		if (cnt < 0) {
			fprintf(stderr, "do_get, read %d\n", -cnt);
			goto out;
		}
		x = write(lfd, tbuf, cnt);
		if (x < 0) {
			fprintf(stderr, "do_get, write %d\n", errno);
			goto out;
		}
		off += x;
	} while (off < st.st_size);

out:
	if (vp != NULL)
		vn_close_rele(vp, 0);
	if (lfd != -1)
		close(lfd);
}

/*
 * put lname [rname]
 */
void
do_put(int argc, char **argv)
{
	struct stat64 rst;
	struct stat st;
	char *rname;
	char *lname;
	vnode_t *vp = NULL;
	offset_t off;
	ssize_t cnt, x;
	int oflg = FREAD|FWRITE|FCREAT;
	int lfd = -1;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 2) {
		fprintf(stderr, "lname required\n");
		return;
	}
	lname = argv[1];
	if (argc > 2) {
		rname = argv[2];
		/*
		 * When remote name is specified, overwrite.
		 * Convenient for scripts etc.
		 */
		oflg |= FTRUNC;
	} else {
		rname = lname;
		/* Remote file should not exist. */
		oflg |= FEXCL;
	}

	lfd = open(lname, O_RDONLY, 0);
	if (lfd < 0) {
		perror(lname);
		return;
	}
	error = fstat(lfd, &st);
	if (error != 0) {
		fprintf(stderr, "do_put, stat error=%d\n", error);
		goto out;
	}

	error = vn_open(rname, 0, oflg, 0, &vp, 0, 0);
	if (error != 0) {
		fprintf(stderr, "do_put, vn_open error=%d\n", error);
		goto out;
	}

	off = 0;
	do {
		cnt = pread(lfd, tbuf, TBUFSZ, off);
		if (cnt < 0) {
			fprintf(stderr, "do_put, read %d\n", errno);
			goto out;
		}
		x = fake_pwrite(vp, tbuf, cnt, off);
		if (x < 0) {
			fprintf(stderr, "do_put, write %d\n", -x);
			goto out;
		}
		off += cnt;
	} while (off < st.st_size);

	/* This getattr should go OtW. */
	error = fake_stat(vp, &rst, 0);
	if (error != 0) {
		fprintf(stderr, "do_put, stat error=%d\n", error);
		goto out;
	}
	if (rst.st_size != st.st_size) {
		fprintf(stderr, "do_put, wrong size?\n");
	}

out:
	if (vp != NULL)
		vn_close_rele(vp, 0);
	if (lfd != -1)
		close(lfd);
}

/*
 * rm rname
 */
void
do_rm(int argc, char **argv)
{
	char *rname;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 2) {
		fprintf(stderr, "rname required\n");
		return;
	}
	rname = argv[1];

	error = fake_unlink(rname, 0);
	if (error != 0) {
		fprintf(stderr, "do_rm, unlink error=%d\n", error);
	}
}

/*
 * mv fromname toname
 */
void
do_mv(int argc, char **argv)
{
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 3) {
		fprintf(stderr, "from_name to_name required\n");
		return;
	}

	error = fake_rename(argv[1], argv[2]);
	if (error != 0) {
		fprintf(stderr, "do_mv, rename error=%d\n", error);
	}
}

/*
 * mkdir rname
 */
void
do_mkdir(int argc, char **argv)
{
	char *rname;
	vnode_t *vp = NULL;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 2) {
		fprintf(stderr, "rname required\n");
		return;
	}
	rname = argv[1];

	error = vn_open(rname, 0, FCREAT, 0, &vp, CRMKDIR, 0);
	if (error != 0) {
		fprintf(stderr, "do_mkdir, vn_open error=%d\n", error);
	}

	if (vp != NULL)
		vn_close_rele(vp, 0);
}

/*
 * rmdir rname
 */
void
do_rmdir(int argc, char **argv)
{
	char *rname;
	int error;

	if (vfsp == NULL) {
		fprintf(stderr, "mnt required first\n");
		return;
	}
	if (argc < 2) {
		fprintf(stderr, "rname required\n");
		return;
	}
	rname = argv[1];

	error = fake_unlink(rname, AT_REMOVEDIR);
	if (error != 0) {
		fprintf(stderr, "do_rmdir, unlink error=%d\n", error);
	}
}

/*
 * Simple option setting
 *
 * Each arg is handled as one line in .nsmbrc [default]
 */
void
do_opt(int argc, char **argv)
{
	static char template[20] = "/tmp/fksmbclXXXXXX";
	static char rcname[30];
	char *tdname;
	char *save_home;
	FILE *fp;
	int err, i;

	if (argc < 2) {
		fprintf(stderr, "opt {key}[=value]\n");
		return;
	}

	tdname = mkdtemp(template);
	if (tdname == NULL) {
		perror("mkdtemp");
		return;
	}
	(void) snprintf(rcname, sizeof (rcname),
	    "%s/.nsmbrc", tdname);

	fp = fopen(rcname, "w");
	if (fp == NULL) {
		perror(rcname);
		goto out;
	}
	fprintf(fp, "[default]\n");
	for (i = 1; i < argc; i++)
		fprintf(fp, "%s\n", argv[i]);
	fclose(fp);

	save_home = ctx->ct_home;
	ctx->ct_home = tdname;
	err = smb_ctx_readrc(ctx);
	ctx->ct_home = save_home;

	if (err != 0)
		fprintf(stderr, "readrc, err=%d\n", err);

out:
	(void) unlink(rcname);
	(void) rmdir(tdname);
}

/*
 * Command table
 */
static struct cmd_tbl_ent
cmd_tbl[] = {
	{ do_help,	"help", "" },
	{ do_exit,	"exit", "" },
	{ do_logon,	"logon", "[user [dom [pass]]]" },
	{ do_logoff,	"logoff", "[close-driver]" },
	{ do_shares,	"shares", "" },
	{ do_mount,	"mount",  "{share} [optstr]" },
	{ do_unmount,	"umount", "" },
	{ do_unmount,	"unmount", "" },
	{ do_statfs,	"statfs", "" },
	{ do_dir,	"dir",  "{rdir} [lfile]" },
	{ do_dirx,	"dirx", "{rdir} [lfile]" },
	{ do_get,	"get",  "{rfile} [lfile]" },
	{ do_put,	"put",  "{lfile} [rfile]" },
	{ do_mv,	"mv",   "{from} {to}" },
	{ do_rm,	"rm",   "{rfile}" },
	{ do_mkdir,	"mkdir", "{rfile}" },
	{ do_rmdir,	"rmdir", "{rfile}" },
	{ do_opt,	"opt",   "{option}" },
	{ NULL, NULL, NULL }
};

/*
 * Provide a real function (one that prints something) to replace
 * the stub in libfakekernel.  This prints cmn_err() messages.
 */
void
fakekernel_putlog(char *msg, size_t len, int flags)
{

	/*
	 * [CE_CONT, CE_NOTE, CE_WARN, CE_PANIC] maps to
	 * [SL_NOTE, SL_NOTE, SL_WARN, SL_FATAL]
	 */
	if (smb_debug == 0 && (flags & SL_NOTE))
		return;
	(void) fwrite(msg, 1, len, stdout);
	(void) fflush(stdout);
}

/*
 * Print nsmb debug messages via driver smb_debugmsg()
 */
void
smb_debugmsg(const char *func, char *msg)
{
	if (smb_debug < 2)
		return;
	printf("[kmod] %s: %s\n", func, msg);
}

/*
 * Enable libumem debugging
 */
const char *
_umem_debug_init(void)
{
	return ("default,verbose"); /* $UMEM_DEBUG setting */
}

const char *
_umem_logging_init(void)
{
	return ("fail,contents"); /* $UMEM_LOGGING setting */
}