fxsdk/fxlink/main.c

#include "config.h"
#include "fxlink.h"
#include "util.h"
#include "properties.h"
#include "filter.h"
#include "usb.h"

#include <libusb.h>
#include <getopt.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>


int main_test(libusb_device *device, libusb_context *context);

static const char *help_string =
"usage: %1$s -l [options...]\n"
"       %1$s -b [options...]\n"
"       %1$s -s [options...] <FILES...>\n"
"       %1$s --test\n"
"\n"
"fxlink interacts with CASIO calculators of the fx-9860G and fx-CG 50 series\n"
"over the USB port, through mass storage and custom USB protocols. Depending\n"
"on the mode, fxlink uses libusb (for discovery and USB communication)or\n"
"the UDisks2 library (to mount and use Mass Storage devices).\n"
"\n"
"Operating modes:\n"
"  -l, --list          List detected calculators on the USB ports (libusb)\n"
"  -b, --blocks        List detected Mass Storage filesystems (udisks2)\n"
"  -s, --send          Send a file to a Mass Storage calculator (udisks2)\n"
"  -i, --interactive   Interactive messaging with a gint add-in (libusb)\n"
"\n"
"General options:\n"
"  -w DELAY            Wait up to this many seconds for a calculator to\n"
"                      connect. If DELAY is unspecified, wait indefinitely.\n"
"  -f FILTER           Filter which calculators can be detected and used\n"
"  --libusb-log=LEVEL  libusb log level: NONE, ERROR, WARNING, INFO, DEBUG\n"
"  --fxlink-log=file   Log text data into a logfile called file. If file is\n"
"                      missing, a generic filename will be created.\n"
"  -q, --quiet         Activate quiet mode, i.e. minimum verbosity and very\n"
"                      limited decorations (no extra messages).\n"
"  -u, --unmount       Force unmount disk at the end of operations, even if\n"
"                      not mounted here\n"
"\n"
"Device filters:\n"
"  A device filter is a comma-separated list of properties that a device has\n"
"  to match in order to be listed or used, such as 'p7,serial=00000001'.\n"
"  Several filters can be separated with a semicolon, in which case a device\n"
"  will be considered as long as it matches one of the filters. For example,\n"
"  'p7 ; mass_storage,serial=IGQcGRe9'.\n"
"\n"
"  The following properties are defined; the libraries in which each can be\n"
"  detected and used is indicated in brackets.\n"
"    p7                Matches Protocol 7 calculators (all the FX models\n"
"                      except the G-III). [libusb, udisks2]\n"
"    mass_storage      Matches Mass Storage calculators (the CG series and\n"
"                      the G-III). [libusb, udisks2]\n"
"    series_cg         Matches CG-series calculators. [udisks2]\n"
"    series_g3         Matches G-III series calculators. [udisks2]\n"
"    serial_number=ID  Matches this specific serial number. Requires write\n"
"                      access to the device in libusb. [libusb, udisks2]\n";

bool silentmode = false;
bool loginfile = false;
char *userlogfilename = NULL;
bool forceunmount = false;

int main(int argc, char **argv)
{
	int rc=1, mode=0, error=0, option=0, loglevel=LIBUSB_LOG_LEVEL_ERROR;
	delay_t delay = delay_seconds(0);
	filter_t *filter = NULL;

	//---
	// Command-line argument parsing
	//---

	enum { LIBUSB_LOG=1 };
	enum { LOG_IN_FILE=2 };
	const struct option longs[] = {
		{ "help",        no_argument,       NULL,       'h' },
		{ "list",        no_argument,       NULL,       'l' },
		{ "blocks",      no_argument,       NULL,       'b' },
		{ "send",        no_argument,       NULL,       's' },
		{ "interactive", no_argument,       NULL,       'i' },
		{ "libusb-log",  required_argument, NULL, LIBUSB_LOG },
		{ "quiet", 	 no_argument,       NULL,       'q' },
		{ "fxlink-log",  optional_argument, NULL, LOG_IN_FILE },
		{ "unmount",     no_argument,	     NULL,       'u' },
	};

	while(option >= 0 && option != '?')
	switch((option = getopt_long(argc, argv, "hlbsiquf:w::", longs, NULL)))
	{
	case 'h':
		fprintf(stderr, help_string, argv[0]);
		return 0;
	case 'l':
	case 'b':
	case 's':
	case 'i':
		mode = option;
		break;
	case LIBUSB_LOG:
		if(!strcmp(optarg, "NONE"))
			loglevel = LIBUSB_LOG_LEVEL_NONE;
		else if(!strcmp(optarg, "ERROR"))
			loglevel = LIBUSB_LOG_LEVEL_ERROR;
		else if(!strcmp(optarg, "WARNING"))
			loglevel = LIBUSB_LOG_LEVEL_WARNING;
		else if(!strcmp(optarg, "INFO"))
			loglevel = LIBUSB_LOG_LEVEL_INFO;
		else if(!strcmp(optarg, "DEBUG"))
			loglevel = LIBUSB_LOG_LEVEL_DEBUG;
		else fprintf(stderr, "warning: ignoring log level '%s'; should be "
				"NONE, ERROR, WARNING, INFO or DEBUG\n", optarg);
		break;
	case 'q':
		printf("Enabling quiet mode (i.e. minimum verbosity)\n");
		silentmode = true;
		break;
	case 'u':
		printf("Force unmount the disk at the end.\n");
		forceunmount = true;
		break;
	case LOG_IN_FILE:
		printf("Enabling Log in File Mode\n");
		loginfile = true;
		if (optarg) {
			asprintf( &userlogfilename, "%s", optarg );
		}
		else {
			time_t time_raw;
			struct tm time_bd;
			time(&time_raw);
			localtime_r(&time_raw, &time_bd);
			asprintf( &userlogfilename, "./fxlink-logfile-%04d.%02d.%02d-%02dh%02d.log",
			 time_bd.tm_year + 1900, time_bd.tm_mon + 1, time_bd.tm_mday,
			 time_bd.tm_hour, time_bd.tm_min );
		}
		printf("Log File will be : %s \n", userlogfilename );
		break;
	case 'w':
		if(!optarg) {
			delay = delay_infinite();
			break;
		}
		char *end;
		int seconds = strtol(optarg, &end, 10);
		if(seconds < 0 || *end != 0) {
			error = err("invalid delay '%s'\n", optarg);
			break;
		}
		delay = delay_seconds(seconds);
		break;
	case 'f':
		filter = filter_parse(optarg);
		break;
	case '?':
		error = 1;
	}

	if(mode == 's' && optind == argc)
		error = err("send mode requires additional arguments (file names)");

	/* No arguments or bad arguments */
	if(error)
		return 1;
	if(!mode) {
		fprintf(stderr, help_string, argv[0]);
		return 1;
	}

	//---
	// libusb initialization
	//---

	libusb_context *context = NULL;

	/* Initialize libusb for corresponding modes */
	if(mode == 'l' || mode == 'i') {
		if((rc = libusb_init(&context)))
			return libusb_err(rc, "error initializing libusb");
		libusb_set_option(context, LIBUSB_OPTION_LOG_LEVEL, loglevel);
	}

	//---
	// Main functions
	//---

	if(mode == 'l') {
		rc = main_list(filter, &delay, context);
	}
	else if(mode == 'b') {
		#ifndef FXLINK_DISABLE_UDISKS2
		rc = main_blocks(filter, &delay);
		#else
		rc = err("this fxlink was built without UDisks2; -b is disabled");
		#endif
	}
	else if(mode == 's') {
		#ifndef FXLINK_DISABLE_UDISKS2
		rc = main_send(filter, &delay, argv + optind);
		#else
		rc = err("this fxlink was built without UDisks2; -s is disabled");
		#endif
	}
	else if(mode == 'i') {
		rc = main_interactive(filter, &delay, context);
	}

	if(context) libusb_exit(context);
	return rc;
}

//---
// Device list
//---

int main_list(filter_t *filter, delay_t *delay, libusb_context *context)
{
	/* Wait for a device to be connected */
	filter_clean_libusb(filter);
	usb_unique_wait(filter, delay, context, NULL);

	int total_devices = 0;
	bool error;

	for_libusb_devices(it, context, &error) {
		if(!filter_match(&it.props, filter)) continue;

		if(total_devices > 0) printf("\n");

		if(it.dc.idProduct == 0x6101)
			printf("fx-9860G series (Protocol 7) calculator\n");
		else if(it.dc.idProduct == 0x6102)
			printf("fx-CG or G-III series (USB Mass Storage) calculator\n");
		else
			printf("Unknown calculator (idProduct: %04x)\n", it.dc.idProduct);

		printf("     Device location:  Bus %d, Port %d, Device %d\n",
			libusb_get_bus_number(it.dev),
			libusb_get_port_number(it.dev),
			libusb_get_device_address(it.dev));
		printf("      Identification:  idVendor: %04x, idProduct: %04x\n",
			it.dc.idVendor, it.dc.idProduct);
		/* FIXME: This assumes a short path (no hub or dual-device) */
		printf("  Guessed sysfs path:  /sys/bus/usb/devices/%d-%d/\n",
			libusb_get_bus_number(it.dev),
			libusb_get_port_number(it.dev));

		char *serial = it.dh ? usb_serial_number(it.dh) : NULL;
		if(serial)
			printf("       Serial number:  %s\n", serial);
		free(serial);

		printf("          Properties:  ");
		properties_print(stdout, &it.props);
		printf("\n");

		total_devices++;
	}

	if(!error && !total_devices)
		printf("No%s device found.\n", filter ? " matching" : "");
	return 0;
}

//---
// libudev tests; work but not useful yet
//---

#if 0
#include <libudev.h>
int main_udev_test(libusb_device *dev)
{
	struct udev *udev = NULL;
	struct udev_device *udev_device = NULL;

	udev = udev_new();
	if(!udev) return err("cannot create udev context");

	static char sys_path[128];
	sprintf(sys_path, "/sys/bus/usb/devices/%d-%d",
		libusb_get_bus_number(dev),
		libusb_get_port_number(dev));

	udev_device = udev_device_new_from_syspath(udev, sys_path);
	if(!udev_device) {
		udev_unref(udev);
		return err("cannot get udev device for %s", sys_path);
	}

	printf("Device number: %ld\n", udev_device_get_devnum(udev_device));
	printf("Device devnode: %s\n", udev_device_get_devnode(udev_device));

	if(udev) udev_unref(udev);
	return 0;
}
#endif