xref: /src/usr.bin/utoppya/utoppya.c

/*	$NetBSD: utoppya.c,v 1.2 2006/04/03 13:30:24 martin Exp $	*/

/*-
 * Copyright (c) 2006 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Steve C. Woodford.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <sysexits.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <time.h>
#include <inttypes.h>

#include <dev/usb/utoppy.h>

#define	GLOBAL
#include "progressbar.h"

#define	_PATH_DEV_UTOPPY	"/dev/utoppy0"

/*
 * This looks weird for a reason. The toppy protocol allows for data to be
 * transferred in 65535-byte chunks only. Anything more than this has to be
 * split within the driver. The following value leaves enough space for the
 * packet header plus some alignmnent slop.
 */
#define	TOPPY_IO_SIZE	0xffec

static int toppy_fd;

static void cmd_df(int, char **);
static void cmd_ls(int, char **);
static void cmd_rm(int, char **);
static void cmd_mkdir(int, char **);
static void cmd_rename(int, char **);
static void cmd_get(int, char **);
static void cmd_put(int, char **);

static struct toppy_command {
	const char *tc_cmd;
	void (*tc_handler)(int, char **);
} toppy_commands[] = {
	{"df",		cmd_df},
	{"ls",		cmd_ls},
	{"get",		cmd_get},
	{"mkdir",	cmd_mkdir},
	{"put",		cmd_put},
	{"rename",	cmd_rename},
	{"rm",		cmd_rm},
	{NULL,		NULL}
};

static void
usage(void)
{

	fprintf(stderr, "usage: %s [-f <path>] <cmd> ...\n",
	    getprogname());

	exit(EX_USAGE);
}

int
main(int argc, char *argv[])
{
	struct toppy_command *tc;
	const char *devpath;
	int ch;

	setprogname(argv[0]);
	devpath = _PATH_DEV_UTOPPY;

	while ((ch = getopt(argc, argv, "f:")) != -1) {
		switch (ch) {
		case 'f':
			devpath = optarg;
			break;

		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (argc == 0)
		usage();

	for (tc = toppy_commands; tc->tc_cmd != NULL; tc++)
		if (strcasecmp(argv[0], tc->tc_cmd) == 0)
			break;

	if (tc->tc_cmd == NULL)
		errx(EX_USAGE, "'%s' is not a valid command", argv[0]);

	if ((toppy_fd = open(devpath, O_RDWR)) < 0)
		err(EX_OSERR, "open(%s)", devpath);

	(*tc->tc_handler)(argc, argv);

	close(toppy_fd);

	return (0);
}

static int
find_toppy_dirent(const char *path, struct utoppy_dirent *udp)
{
	struct utoppy_dirent ud;
	char *d, *b, dir[FILENAME_MAX];
	ssize_t l;

	strncpy(dir, path, sizeof(dir));
	b = basename(dir);
	d = dirname(dir);
	if (strcmp(b, "/") == 0 || strcmp(b, ".") == 0 || strcmp(d, ".") == 0)
		errx(EX_USAGE, "'%s' is not a valid Toppy pathname", path);

	if (ioctl(toppy_fd, UTOPPYIOREADDIR, &d) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOREADDIR, %s)", d);

	if (udp == NULL)
		udp = &ud;

	while ((l = read(toppy_fd, udp, sizeof(*udp))) == sizeof(*udp)) {
		if (strcmp(b, udp->ud_path) == 0)
			break;
	}

	if (l < 0)
		err(EX_OSERR, "read(TOPPYDIR, %s)", d);

	if (l == 0)
		return (0);

	while (read(toppy_fd, &ud, sizeof(ud)) > 0)
		;

	return (1);
}

static void
cmd_df(int argc, char **argv)
{
	struct utoppy_stats us;

	if (ioctl(toppy_fd, UTOPPYIOSTATS, &us) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOSTATS)");

	printf("Hard Disk Size: %" PRId64 " MB\n", us.us_hdd_size / (1024 * 1024));
	printf("Hard Disk Free: %" PRId64 " MB\n", us.us_hdd_free / (1024 * 1024));
}

static void
cmd_ls(int argc, char **argv)
{
	struct utoppy_dirent ud;
	struct tm *tm;
	char *dir, *ext, dirbuf[2], ex, ft, tmbuf[32];
	ssize_t l;

	if (argc == 1) {
		dirbuf[0] = '/';
		dirbuf[1] = '\0';
		dir = dirbuf;
	} else
	if (argc == 2)
		dir = argv[1];
	else
		errx(EX_USAGE, "usage: ls [toppy-pathname]");

	if (ioctl(toppy_fd, UTOPPYIOREADDIR, &dir) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOREADDIR, %s)", dir);

	while ((l = read(toppy_fd, &ud, sizeof(ud))) == sizeof(ud)) {
		switch (ud.ud_type) {
		default:
			ft = '?';
			break;

		case UTOPPY_DIRENT_DIRECTORY:
			ft = 'd';
			break;

		case UTOPPY_DIRENT_FILE:
			ft = '-';
			break;
		}

		if ((ext = strrchr(ud.ud_path, '.')) != NULL &&
		    strcasecmp(ext, ".tap") == 0)
			ex = 'x';
		else
			ex = '-';

		tm = localtime(&ud.ud_mtime);
		strftime(tmbuf, sizeof(tmbuf), "%b %e %G %R", tm);

		printf("%crw%c %11lld %s %s\n", ft, ex, (long long)ud.ud_size,
		    tmbuf, ud.ud_path);
	}

	if (l < 0)
		err(EX_OSERR, "read(utoppy_dirent)");
}

static void
cmd_rm(int argc, char **argv)
{
	char *path;

	if (argc != 2)
		errx(EX_USAGE, "usage: rm <toppy-pathname>");

	path = argv[1];

	if (ioctl(toppy_fd, UTOPPYIODELETE, &path) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIODELETE, %s)", path);
}

static void
cmd_mkdir(int argc, char **argv)
{
	char *path;

	if (argc != 2)
		errx(EX_USAGE, "usage: mkdir <toppy-pathname>");

	path = argv[1];

	if (find_toppy_dirent(path, NULL))
		errx(EX_DATAERR, "'%s' already exists", path);

	if (ioctl(toppy_fd, UTOPPYIOMKDIR, &path) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOMKDIR, %s)", path);
}

static void
cmd_rename(int argc, char **argv)
{
	struct utoppy_dirent ud;
	struct utoppy_rename ur;
	char *oldpath, *newpath, *o, *n;

	if (argc != 3)
		errx(EX_USAGE, "usage: rename <from> <to>");

	o = oldpath = argv[1];
	n = newpath = argv[2];

	for (o = oldpath; *o != '\0'; o++)
		if (*o == '\\')
			*o = '/';
	for (n = newpath; *n != '\0'; n++)
		if (*n == '\\')
			*n = '/';

	for (o = oldpath; *o && *o == '\\'; o++)
		;
	for (n = newpath; *n && *n == '\\'; n++)
		;

	if (strcmp(n, o) == 0)
		errx(EX_DATAERR, "'%s' and '%s' refer to the same file\n",
		    oldpath, newpath);

	if (find_toppy_dirent(oldpath, &ud) == 0)
		errx(EX_DATAERR, "'%s' does not exist on the Toppy", oldpath);

	if (ud.ud_type != UTOPPY_DIRENT_FILE)
		errx(EX_DATAERR, "%s: not a regular file", oldpath);

	if (find_toppy_dirent(newpath, &ud))
		errx(EX_DATAERR, "'%s' already exists", newpath);

	ur.ur_old_path = o;
	ur.ur_new_path = n;

	if (ioctl(toppy_fd, UTOPPYIORENAME, &ur) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIORENAME, %s, %s)", oldpath,
		    newpath);
}


static void
init_progress(FILE *to, char *f, off_t fsize, off_t restart)
{
	struct ttysize ts;

	if (ioctl(fileno(to), TIOCGSIZE, &ts) == -1)
		ttywidth = 80;
	else
		ttywidth = ts.ts_cols;

	ttyout = to;
	progress = 1;
	bytes = 0;
	filesize = fsize;
	restart_point = restart;
	prefix = f;
}

static void
cmd_get(int argc, char **argv)
{
	struct utoppy_readfile ur;
	struct utoppy_dirent ud;
	struct stat st;
	char *dst, dstbuf[FILENAME_MAX];
	uint8_t *buf;
	ssize_t l;
	size_t rv;
	int ch, turbo_mode = 0, reget = 0, progbar = 0;
	FILE *ofp, *to;

	optind = 1;
	optreset = 1;

	while ((ch = getopt(argc, argv, "prt")) != -1) {
		switch (ch) {
		case 'p':
			progbar = 1;
			break;
		case 'r':
			reget = 1;
			break;
		case 't':
			turbo_mode = 1;
			break;
		default:
 get_usage:
			errx(EX_USAGE, "usage: get [-prt] <toppy-pathname> "
			    "[file | directory]");
		}
	}
	argc -= optind;
	argv += optind;

	if (argc == 1)
		dst = basename(argv[0]);
	else
	if (argc == 2) {
		dst = argv[1];
		if (stat(dst, &st) == 0 && S_ISDIR(st.st_mode)) {
			snprintf(dstbuf, sizeof(dstbuf), "%s/%s", dst,
			    basename(argv[0]));
			dst = dstbuf;
		}
	} else
		goto get_usage;

	ur.ur_path = argv[0];
	ur.ur_offset = 0;

	if ((buf = malloc(TOPPY_IO_SIZE)) == NULL)
		err(EX_OSERR, "malloc(TOPPY_IO_SIZE)");

	if (strcmp(dst, "-") == 0) {
		ofp = stdout;
		to = stderr;
		if (reget)
			warnx("Ignoring -r option in combination with stdout");
	} else {
		to = stdout;

		if (reget) {
			if (stat(dst, &st) < 0) {
				if (errno != ENOENT)
					err(EX_OSERR, "stat(%s)", dst);
			} else
			if (!S_ISREG(st.st_mode))
				errx(EX_DATAERR, "-r only works with regular "
				    "files");
			else
				ur.ur_offset = st.st_size;
		}

		if ((ofp = fopen(dst, reget ? "a" : "w")) == NULL)
			err(EX_OSERR, "fopen(%s)", dst);
	}

	if (progbar) {
		if (find_toppy_dirent(ur.ur_path, &ud) == 0)
			ud.ud_size = 0;
		init_progress(to, dst, ud.ud_size, ur.ur_offset);
	}

	if (ioctl(toppy_fd, UTOPPYIOTURBO, &turbo_mode) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOTURBO, %d)", turbo_mode);

	if (ioctl(toppy_fd, UTOPPYIOREADFILE, &ur) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOREADFILE, %s)", ur.ur_path);

	if (progbar)
		progressmeter(-1);

	for (;;) {
		while ((l = read(toppy_fd, buf, TOPPY_IO_SIZE)) < 0 &&
		    errno == EINTR)
			;

		if (l <= 0)
			break;

		rv = fwrite(buf, 1, l, ofp);

		if (rv != l) {
			if (ofp != stdout)
				fclose(ofp);
			progressmeter(1);
			err(EX_OSERR, "fwrite(%s)", dst);
		}
		bytes += l;
	}

	if (progbar)
		progressmeter(1);

	if (ofp != stdout)
		fclose(ofp);

	if (l < 0)
		err(EX_OSERR, "read(TOPPY: ur.ur_path)");

	free(buf);
}

static void
cmd_put(int argc, char **argv)
{
	struct utoppy_writefile uw;
	struct utoppy_dirent ud;
	struct stat st;
	char dstbuf[FILENAME_MAX];
	char *src;
	void *buf;
	ssize_t rv;
	size_t l;
	int ch, turbo_mode = 0, reput = 0, progbar = 0;
	FILE *ifp;

	optind = 1;
	optreset = 1;

	while ((ch = getopt(argc, argv, "prt")) != -1) {
		switch (ch) {
		case 'p':
			progbar = 1;
			break;
		case 'r':
			reput = 1;
			break;
		case 't':
			turbo_mode = 1;
			break;
		default:
 put_usage:
			errx(EX_USAGE, "usage: put [-prt] <local-pathname> "
			    "<toppy-pathname>");
		}
	}
	argc -= optind;
	argv += optind;

	if (argc != 2)
		goto put_usage;

	src = argv[0];
	uw.uw_path = argv[1];

	if (stat(src, &st) < 0)
		err(EX_OSERR, "%s", src);

	if (!S_ISREG(st.st_mode))
		errx(EX_DATAERR, "'%s' is not a regular file", src);

	uw.uw_size = st.st_size;
	uw.uw_mtime = st.st_mtime;
	uw.uw_offset = 0;

	if (find_toppy_dirent(uw.uw_path, &ud)) {
		if (ud.ud_type == UTOPPY_DIRENT_DIRECTORY) {
			snprintf(dstbuf, sizeof(dstbuf), "%s/%s", uw.uw_path,
			    basename(src));
			uw.uw_path = dstbuf;
		} else
		if (ud.ud_type != UTOPPY_DIRENT_FILE)
			errx(EX_DATAERR, "'%s' is not a regular file.",
			    uw.uw_path);
		else
		if (reput) {
			if (ud.ud_size > uw.uw_size)
				errx(EX_DATAERR, "'%s' is already larger than "
				    "'%s'", uw.uw_path, src);

			uw.uw_size -= ud.ud_size;
			uw.uw_offset = ud.ud_size;
		}
	}

	if ((buf = malloc(TOPPY_IO_SIZE)) == NULL)
		err(EX_OSERR, "malloc(TOPPY_IO_SIZE)");

	if ((ifp = fopen(src, "r")) == NULL)
		err(EX_OSERR, "fopen(%s)", src);

	if (ioctl(toppy_fd, UTOPPYIOTURBO, &turbo_mode) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOTURBO, %d)", turbo_mode);

	if (ioctl(toppy_fd, UTOPPYIOWRITEFILE, &uw) < 0)
		err(EX_OSERR, "ioctl(UTOPPYIOWRITEFILE, %s)", uw.uw_path);

	if (progbar)
		init_progress(stdout, src, st.st_size, uw.uw_offset);

	if (progbar)
		progressmeter(-1);

	while ((l = fread(buf, 1, TOPPY_IO_SIZE, ifp)) > 0) {
		rv = write(toppy_fd, buf, l);
		if (rv != l) {
			fclose(ifp);
			if (progbar)
				progressmeter(1);
			err(EX_OSERR, "write(TOPPY: %s)", uw.uw_path);
		}
		bytes += l;
	}

	if (progbar)
		progressmeter(1);

	if (ferror(ifp))
		err(EX_OSERR, "fread(%s)", src);

	fclose(ifp);
	free(buf);
}