patched source

src/scanbuttond-0.2.3/ChangeLog

+0.2.3, released Feb 17, 2006
+----------------------------
+  * fixed snapscan backend (protocol sync)
+  * added mustek and plustek_umax backends
+  * support for some new scanners
+  * Switched to autoconf/automake
+  * Changed directory/file layout
+
+
+0.2.2, released Jun 6, 2005
+---------------------------
+  * added snapscan backend
+  * added niash backend
+  * support for scanner initialization script
+  * lots of bugs fixed
+  * command line option support
+  * libusb wrapper moved into own dynamic library
+  * scanbuttond now uses dynamic backend loading
+
+
+0.2.1, released Mar 14, 2005
+----------------------------
+  * added plustek and meta backend
+  * added support for more scanners to the epson backend
+  * SIGSEGV bug fixed, scanner hotplugging seems to work now
+  * using /etc/scanbuttond as config file directory
+
+
+0.2, released Dec 31, 2004
+--------------------------
+  * new, modular architecture
+  * support for multiple scanners
+  * several bugfixes
+
+
+0.1, released Oct 17, 2004
+--------------------------
+  * first public version

src/scanbuttond-0.2.3/INSTALL

+Basic Installation
+==================
+
+   These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, a file
+`config.cache' that saves the results of its tests to speed up
+reconfiguring, and a file `config.log' containing compiler output
+(useful mainly for debugging `configure').
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If at some point `config.cache'
+contains results you don't want to keep, you may remove or edit it.
+
+   The file `configure.in' is used to create `configure' by a program
+called `autoconf'.  You only need `configure.in' if you want to change
+it or regenerate `configure' using a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes awhile.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  You can give `configure'
+initial values for variables by setting them in the environment.  Using
+a Bourne-compatible shell, you can do that on the command line like
+this:
+     CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
+
+Or on systems that have the `env' program, you can do it like this:
+     env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not supports the `VPATH'
+variable, you have to compile the package for one architecture at a time
+in the source code directory.  After you have installed the package for
+one architecture, use `make distclean' before reconfiguring for another
+architecture.
+
+Installation Names
+==================
+
+   By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=PATH' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' can not figure out
+automatically, but needs to determine by the type of host the package
+will run on.  Usually `configure' can figure that out, but if it prints
+a message saying it can not guess the host type, give it the
+`--host=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name with three fields:
+     CPU-COMPANY-SYSTEM
+
+See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the host type.
+
+   If you are building compiler tools for cross-compiling, you can also
+use the `--target=TYPE' option to select the type of system they will
+produce code for and the `--build=TYPE' option to select the type of
+system on which you are compiling the package.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Operation Controls
+==================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--cache-file=FILE'
+     Use and save the results of the tests in FILE instead of
+     `./config.cache'.  Set FILE to `/dev/null' to disable caching, for
+     debugging `configure'.
+
+`--help'
+     Print a summary of the options to `configure', and exit.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--version'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`configure' also accepts some other, not widely useful, options.

src/scanbuttond-0.2.3/Makefile.am

+SUBDIRS = contrib interface backends scripts .
+
+pkgsysconfdir = $(sysconfdir)/$(PACKAGE)
+
+bin_PROGRAMS = scanbuttond
+scanbuttond_SOURCES = scanbuttond.c lib/loader.c include/scanbuttond/backend.h include/scanbuttond/scanbuttond.h include/scanbuttond/common.h
+scanbuttond_LDFLAGS = -ldl
+
+INCLUDES = $(all_includes) -I$(top_builddir)/include -I.

src/scanbuttond-0.2.3/README

+Scanner Button Daemon (scanbuttond), Version 0.2.3
+==================================================
+
+
+First things first
+------------------
+
+This software is in its very early stages of development. Although this daemon
+seems to work for most people, there may still be lots of critical bugs.
+Be prepared for the worst!
+
+
+Introduction
+------------
+
+Modern scanners usually have several front panel buttons which are intended to
+trigger certain actions like copying, faxing or mailing the scanned document.
+This daemon monitors the scanner's buttons and runs a shell script whenever one
+of these buttons has been pressed. Because it is accessing the scanner directly
+via libusb, there should be no conflicts with SANE or other scanner drivers:
+scanbuttond simply won't touch the scanner hardware while you are using SANE.
+
+
+Requirements
+------------
+
+ * Scanner: see "supported scanners" below
+ * Operating system: Linux (and perhaps other Unix-like systems)
+ * Connection: USB (using libusb, the scanner kernel module is currently
+   unsupported)
+
+
+Compilation & Installation
+--------------------------
+
+Since version 0.2.3, scanbuttond uses the GNU autotools for compilation &
+installation. Please see the file INSTALL for generic instructions on using
+them.
+
+If you are using a CVS version instead of a release, you may have to bootstrap
+the package. This can be done by running:
+"aclocal; autoconf; autoheader; automake -a; libtoolize". 
+You should now be able to run ./configure and make.
+
+After you have installed scanbuttond, you should run "ldconfig" to update the
+cache of the dynamic linker. If you forget to do that, scanbuttond probably
+won't be able to load the backend modules or resolve the dependencies between
+them!
+
+
+Usage
+-----
+
+If you just want to try out scanbuttond, type
+> scanbuttond
+
+If everyhing works, scanbuttond will fork() to background. To see what
+scanbuttond is doing, you can have a look at your system log, for example
+/var/log/everything/current (for Gentoo Linux systems running metalog).
+
+To terminate scanbuttond, type
+> killall scanbuttond
+That should do the job. Scanbuttond installs a signal handler which should
+ensure a clean shutdown even when it's killed.
+
+If you intend to use scanbuttond seriously, you would probably want to write a
+distribution-specific init-script for starting and stopping the daemon.
+
+
+Supported scanners
+------------------
+
+Supported by the epson backend (via libusb):
+* Epson Expression 1600 (expected to work)
+* Epson Expression 1680 (expected to work)
+* Epson Perfection 610 (expected to work)
+* Epson Perfection 636U (expected to work)
+* Epson Perfection 640 (expected to work)
+* Epson Perfection 1200U (expected to work)
+* Epson Perfection 1240 (expected to work)
+* Epson Perfection 1640 (expected to work)
+* Epson Perfection 1650 (working, tested)
+* Epson Perfection 1660 (working, tested)
+* Epson Perfection 2400 (working, tested)
+* Epson Perfection 2450 (expected to work)
+* Epson Perfection 3200 (expected to work)
+* Epson CX3200 (working, tested)
+
+Supported by the mustek backend (via libusb):
+* Mustek BearPaw 2448TA (experimental)
+
+Supported by the niash backend (via libusb):
+* Agfa Snapscan Touch (expected to work)
+* HP Scanjet 3300c (expected to work)
+* HP Scanjet 3400c (expected to work)
+* HP Scanjet 4300c (expected to work)
+
+Supported by the plustek backend (via libusb):
+* Canon CanoScan N1220U (expected to work)
+* Canon CanoScan D660U (expected to work)
+* Canon CanoScan N650U (expected to work)
+* Canon CanoScan LiDE 20 (experimental)
+* Canon CanoScan LiDE 25 (experimental)
+* Canon CanoScan LiDE 30 (experimental)
+* Epson Perfection 1260 (experimental)
+* Hewlett-Packard ScanJet 2200c (experimental)
+
+Supported by the plustek_umax backend (via libusb):
+* UMAX Astra 3400/3450 (experimental)
+
+Supported by the snapscan backend (via libusb):
+* Epson Perfection 2480 (expected to work)
+* Epson Perfection 2580 (expected to work)
+* Epson Perfection 1670 (working, tested)
+
+Note: the mustek, niash, plustek, plustek_umax and snapscan backends were
+implemented using information gathered by "sniffing" the communication between
+the Windows driver and the scanner, because there is no technical documentation
+available for these devices! This means that there may be some weird issues
+(e.g. button press events reported twice).
+
+
+How to link actions to buttons
+------------------------------
+
+Whenever a scanner button has been pressed, scanbuttond starts a shell script
+and passes it the button number and the SANE scanner name as command line
+arguments. By default, this shell script is installed as
+"/usr/local/etc/scanbuttond/buttonpressed.sh". Please modify it to fit your
+purposes.
+
+
+Scanner initialization
+----------------------
+
+Note: this only applies to some scanners supported by the non-epson backends.
+All scanners supported by the epson backend do not need special initialization.
+
+Some scanners require a special initialization procedure (firmware uploading,
+for example) before they can be used by scanbuttond. Since the scanbuttond
+backend modules cannot yet handle such operations, the initialization has to be
+performed by external programs, for example by "scanimage" which is part of
+SANE. You can customize the initialization procedure by editing the scanner
+initialization script, which is by default installed at
+"/usr/local/etc/scanbuttond/initscanner.sh". This script will be executed
+whenever a new device has to be initialized. In most cases, it should be
+sufficient to put something like "scanimage -n" into this script.
+
+
+How to contribute to this project
+---------------------------------
+
+The development of scanbuttond should not be dependent on one single person, 
+but a community effort.
+You could help by ...
+
+ * adding or enhancing a scanner backend
+ * adding or enhancing a connection interface
+ * doing some extensive testing
+ * sending patches
+ * sending bug reports
+ * mailing ideas how to enhance scanbuttond
+ * ...
+
+If you want to help, please send me an email (see below).
+
+
+Contact
+-------
+
+Any suggestions, criticism, bug reports/fixes, patches, ... are appreciated.
+Feel free to contact me via email:
+
+Bernhard Stiftner <root84@users.sourceforge.net>
+

src/scanbuttond-0.2.3/backends/Makefile.am

+lib_LTLIBRARIES = 	libscanbtnd-backend_epson.la \
+			libscanbtnd-backend_meta.la \
+			libscanbtnd-backend_mustek.la \
+			libscanbtnd-backend_niash.la \
+			libscanbtnd-backend_plustek.la \
+			libscanbtnd-backend_plustek_umax.la \
+			libscanbtnd-backend_snapscan.la
+
+libscanbtnd_backend_epson_la_SOURCES = epson.c epson.h
+libscanbtnd_backend_epson_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_epson_la_LDFLAGS = -version-info 1:0:0
+libscanbtnd_backend_meta_la_SOURCES = meta.c meta.h ../lib/loader.c ../include/scanbuttond/loader.h ../include/scanbuttond/common.h
+libscanbtnd_backend_meta_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_meta_la_LDFLAGS = -version-info 1:0:0 -ldl
+libscanbtnd_backend_mustek_la_SOURCES = mustek.c mustek.h
+libscanbtnd_backend_mustek_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_mustek_la_LDFLAGS = -version-info 1:0:0
+libscanbtnd_backend_niash_la_SOURCES = niash.c niash.h
+libscanbtnd_backend_niash_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_niash_la_LDFLAGS = -version-info 1:0:0
+libscanbtnd_backend_plustek_la_SOURCES = plustek.c plustek.h
+libscanbtnd_backend_plustek_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_plustek_la_LDFLAGS = -version-info 1:0:0
+libscanbtnd_backend_plustek_umax_la_SOURCES = plustek_umax.c plustek_umax.h
+libscanbtnd_backend_plustek_umax_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_plustek_umax_la_LDFLAGS = -version-info 1:0:0
+libscanbtnd_backend_snapscan_la_SOURCES = snapscan.c snapscan.h
+libscanbtnd_backend_snapscan_la_LIBADD = ../interface/libscanbtnd-interface_usb.la
+libscanbtnd_backend_snapscan_la_LDFLAGS = -version-info 1:0:0
+
+pkgsysconfdir = $(sysconfdir)/$(PACKAGE)
+pkgsysconf_DATA = meta.conf
+
+EXTRA_DIST = $(pkgsysconf_DATA)
+
+INCLUDES = $(all_includes) -I$(top_builddir)/include -I.

src/scanbuttond-0.2.3/backends/epson.c

+// epson.c: Epson ESC/I device backend
+// This file is part of scanbuttond.
+// Copyleft )c( 2004-2006 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+// Thanks to:
+//  - James Gilliland (Epson CX3200 support)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <syslog.h>
+#include "scanbuttond/scanbuttond.h"
+#include "scanbuttond/libusbi.h"
+#include "epson.h"
+
+#define	ESC        	0x1B		/* ASCII value for ESC */
+
+static char* backend_name = "Epson USB";
+
+#define NUM_SUPPORTED_USB_DEVICES 14
+
+static int supported_usb_devices[NUM_SUPPORTED_USB_DEVICES][3] = {
+	// vendor, product, num_buttons
+	{ 0x04B8, 0x0107, 1 },	// Epson Expression 1600
+	{ 0x04B8, 0x010E, 1 },	// Epson Expression 1680
+	{ 0x04B8, 0x0103, 1 },	// Epson Perfection 610
+	{ 0x04B8, 0x0101, 3 },	// Epson Perfection 636U
+	{ 0x04B8, 0x010C, 3 },	// Epson Perfection 640
+	{ 0x04B8, 0x0104, 1 },	// Epson Perfection 1200U
+	{ 0x04B8, 0x010B, 3 },	// Epson Perfection 1240
+	{ 0x04B8, 0x010A, 1 },	// Epson Perfection 1640
+	{ 0x04B8, 0x0110, 4 },	// Epson Perfection 1650
+	{ 0x04B8, 0x011E, 4 },	// Epson Perfection 1660
+	{ 0x04B8, 0x011B, 4 },	// Epson Perfection 2400
+	{ 0x04B8, 0x0112, 1 },	// Epson Perfection 2450
+	{ 0x04B8, 0x011C, 1 },	// Epson Perfection 3200
+	{ 0x04B8, 0x0802, 1 }	// Epson CX3200 (note: is the button number
+				// really correct?)
+};
+
+static char* usb_device_descriptions[NUM_SUPPORTED_USB_DEVICES][2] = {
+	{ "Epson", "Expression 1600"},
+	{ "Epson", "Expression 1680"},
+	{ "Epson", "Perfection 610"},
+	{ "Epson", "Perfection 636U"},
+	{ "Epson", "Perfection 640"},
+	{ "Epson", "Perfection 1200U"},
+	{ "Epson", "Perfection 1240"},
+	{ "Epson", "Perfection 1640"},
+	{ "Epson", "Perfection 1650"},
+	{ "Epson", "Perfection 1660"},
+	{ "Epson", "Perfection 2400"},
+	{ "Epson", "Perfection 2450"},
+	{ "Epson", "Perfection 3200"},
+	{ "Epson", "Stylus CX3200"}
+};
+
+
+libusb_handle_t* libusb_handle;
+scanner_t* epson_scanners = NULL;
+
+
+// returns -1 if the scanner is unsupported, or the index of the
+// corresponding vendor-product pair in the supported_usb_devices array.
+int epson_match_libusb_scanner(libusb_device_t* device)
+{
+	int index;
+	for (index = 0; index < NUM_SUPPORTED_USB_DEVICES; index++) {
+		if (supported_usb_devices[index][0] == device->vendorID &&
+				  supported_usb_devices[index][1] == device->productID) {
+			break;
+		}
+	}
+	if (index >= NUM_SUPPORTED_USB_DEVICES) return -1;
+	return index;
+}
+
+
+void epson_attach_libusb_scanner(libusb_device_t* device)
+{
+	const char* descriptor_prefix = "epson:libusb:";
+	int index = epson_match_libusb_scanner(device);
+	if (index < 0) return; // unsupported
+	scanner_t* scanner = (scanner_t*)malloc(sizeof(scanner_t));
+	scanner->vendor = usb_device_descriptions[index][0];
+	scanner->product = usb_device_descriptions[index][1];
+	scanner->connection = CONNECTION_LIBUSB;
+	scanner->internal_dev_ptr = (void*)device;
+	scanner->lastbutton = 0;
+	scanner->sane_device = (char*)malloc(strlen(device->location) + 
+		strlen(descriptor_prefix) + 1);
+	strcpy(scanner->sane_device, descriptor_prefix);
+	strcat(scanner->sane_device, device->location);
+	scanner->num_buttons = supported_usb_devices[index][2];
+	scanner->is_open = 0;
+	scanner->next = epson_scanners;
+	epson_scanners = scanner;
+}
+
+
+void epson_detach_scanners(void)
+{
+	scanner_t* next;
+	while (epson_scanners != NULL) {
+		next = epson_scanners->next;
+		free(epson_scanners->sane_device);
+		free(epson_scanners);
+		epson_scanners = next;
+	}
+}
+
+
+void epson_scan_devices(libusb_device_t* devices)
+{
+	int index;
+	libusb_device_t* device = devices;
+	while (device != NULL) {
+		index = epson_match_libusb_scanner(device);
+		if (index >= 0)
+			epson_attach_libusb_scanner(device);
+		device = device->next;
+	}
+}
+
+
+int epson_init_libusb(void)
+{
+	libusb_device_t* devices;
+
+	libusb_handle = libusb_init();
+	devices = libusb_get_devices(libusb_handle);
+	epson_scan_devices(devices);
+	return 0;
+}
+
+
+const char* scanbtnd_get_backend_name(void)
+{
+	return backend_name;
+}
+
+
+int scanbtnd_init(void)
+{
+	epson_scanners = NULL;
+
+	syslog(LOG_INFO, "epson-backend: init");
+	return epson_init_libusb();
+}
+
+
+int scanbtnd_rescan(void)
+{
+	libusb_device_t *devices;
+
+	epson_detach_scanners();
+	epson_scanners = NULL;
+	libusb_rescan(libusb_handle);
+	devices = libusb_get_devices(libusb_handle);
+	epson_scan_devices(devices);
+	return 0;
+}
+
+
+const scanner_t* scanbtnd_get_supported_devices(void)
+{
+	return epson_scanners;
+}
+
+
+int scanbtnd_open(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			// if devices have been added/removed, return -ENODEV to
+			// make scanbuttond update its device list
+			if (libusb_get_changed_device_count() != 0)
+				return -ENODEV;
+			result = libusb_open((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 1;
+	return result;
+}
+
+
+int scanbtnd_close(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (!scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			result = libusb_close((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 0;
+	return result;
+}
+
+
+int epson_read(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_read((libusb_device_t*)scanner->internal_dev_ptr, 
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+int epson_write(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_write((libusb_device_t*)scanner->internal_dev_ptr, 
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+void epson_flush(scanner_t* scanner)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			libusb_flush((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+}
+
+
+int scanbtnd_get_button(scanner_t* scanner)
+{
+	unsigned char bytes[255];
+	int rcv_len;
+	int num_bytes;
+
+	bytes[0] = ESC;
+	bytes[1] = '!';
+	bytes[2] = '\0';
+
+	if (!scanner->is_open)
+		return -EINVAL;
+
+	num_bytes = epson_write(scanner, (void*)bytes, 2);
+	if (num_bytes != 2) {
+		epson_flush(scanner); 
+		return 0;
+	}
+	num_bytes = epson_read(scanner, (void*)bytes, 4);
+	if (num_bytes != 4) {
+		epson_flush(scanner);
+		return 0;
+	}
+	rcv_len = bytes[3] << 8 | bytes[2];
+	num_bytes = epson_read(scanner, (void*)bytes, rcv_len);
+	if (num_bytes != rcv_len) {
+		epson_flush(scanner);
+		return 0;
+	}
+	return bytes[0];
+}
+
+
+const char* scanbtnd_get_sane_device_descriptor(scanner_t* scanner)
+{
+	return scanner->sane_device;
+}
+
+
+int scanbtnd_exit(void)
+{
+	syslog(LOG_INFO, "epson-backend: exit");
+	epson_detach_scanners();
+	libusb_exit(libusb_handle);
+	return 0;
+}
+

src/scanbuttond-0.2.3/backends/epson.h

+// epson.h: Epson ESC/I device backend
+// This file is part of scanbuttond.
+// Copyleft )c( 2004-2005 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#ifndef __EPSON_H_INCLUDED
+#define __EPSON_H_INCLUDED
+
+#include "scanbuttond/backend.h"
+
+#endif

src/scanbuttond-0.2.3/backends/meta.c

+// meta.c: meta backend ("dynamic backend loader")
+// This file is part of scanbuttond.
+// Copyleft )c( 2005-2006 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include "scanbuttond/common.h"
+#include "scanbuttond/scanbuttond.h"
+#include "scanbuttond/libusbi.h"
+#include "meta.h"
+
+#define MAX_CONFIG_LINE 255
+#define MAX_SCANNERS_PER_BACKEND 16
+
+static char* backend_name = "Dynamic Module Loader";
+static char* config_file = STRINGIFY(CFG_DIR) "/meta.conf";
+static char* lib_dir = STRINGIFY(LIB_DIR);
+
+libusb_handle_t* libusb_handle;
+scanner_t* meta_scanners = NULL;
+backend_t* meta_backends = NULL;
+
+
+const char* scanbtnd_get_backend_name(void)
+{
+	return backend_name;
+}
+
+
+void meta_attach_scanner(scanner_t* scanner, backend_t* backend)
+{
+	scanner_t* dev = (scanner_t*)malloc(sizeof(scanner_t));
+	dev->vendor = scanner->vendor;
+	dev->product = scanner->product;
+	dev->connection = scanner->connection;
+	dev->internal_dev_ptr = scanner->internal_dev_ptr;
+	dev->sane_device = scanner->sane_device;
+	dev->meta_info = (void*)backend;
+	dev->lastbutton = scanner->lastbutton;
+	dev->num_buttons = scanner->num_buttons;
+	dev->is_open = scanner->is_open;
+	dev->next = meta_scanners;
+	meta_scanners = dev;
+	syslog(LOG_INFO, "meta-backend: attached scanner \"%s %s\"",
+		   scanner->vendor, scanner->product);
+}
+
+
+void meta_attach_scanners(scanner_t* devices, backend_t* backend)
+{
+	scanner_t* dev = devices;
+	int count = 0;
+	while (dev != NULL) {
+		if (count >= MAX_SCANNERS_PER_BACKEND) {
+			syslog(LOG_WARNING, "meta-backend: refusing to attach scanner \"%s %s\": Too many scanners!",
+				   dev->vendor, dev->product);
+			return;
+		}
+		meta_attach_scanner(dev, backend);
+		dev = dev->next;
+		count++;
+	}
+}
+
+
+void meta_detach_scanner(scanner_t* scanner, scanner_t* prev_scanner)
+{
+	syslog(LOG_INFO, "meta-backend: detaching scanner: \"%s %s\"",
+		   scanner->vendor, scanner->product);
+	if (prev_scanner != NULL)
+		prev_scanner->next = scanner->next;
+	else if (scanner == meta_scanners)
+		meta_scanners = scanner->next;
+	else
+		syslog(LOG_WARNING, "meta-backend: detach scanner: invalid arguments!");
+	free(scanner);
+}
+
+
+void meta_detach_scanners(void)
+{
+	while (meta_scanners != NULL) {
+		meta_detach_scanner(meta_scanners, NULL);
+	}
+}
+
+
+int meta_attach_backend(backend_t* backend)
+{
+  // don't load another meta backend
+	if (strcmp(backend->scanbtnd_get_backend_name(), scanbtnd_get_backend_name())==0) {
+		syslog(LOG_WARNING, "meta-backend: refusing to load another meta backend!");
+		return -1;
+	}
+	syslog(LOG_INFO, "meta-backend: attaching backend: %s",
+		   backend->scanbtnd_get_backend_name());
+	backend->next = meta_backends;
+	meta_backends = backend;
+	backend->scanbtnd_init();
+	return 0;
+}
+
+
+void meta_detach_backend(backend_t* backend, backend_t* prev_backend)
+{
+	if (prev_backend != NULL)
+		prev_backend->next = backend->next;
+	else if (backend == meta_backends)
+		meta_backends = backend->next;
+	else
+		syslog(LOG_WARNING, "meta-backend: detach backend: invalid arguments!");
+	backend->scanbtnd_exit();
+	unload_backend(backend);
+}
+
+
+void meta_detach_backends(void)
+{
+	while (meta_backends != NULL) {
+		meta_detach_backend(meta_backends, NULL);
+	}
+}
+
+
+backend_t* meta_lookup_backend(scanner_t* scanner)
+{
+	return (backend_t*)scanner->meta_info;
+}
+
+
+void meta_strip_newline(char* str)
+{
+	int len = strlen(str);
+	if (len == 0) return;
+	if (str[len-1] != '\n') return;
+	str[len-1] = 0;
+}
+
+
+int scanbtnd_init(void)
+{
+	meta_scanners = NULL;
+	meta_backends = NULL;
+
+	syslog(LOG_INFO, "meta-backend: init");
+	libusb_handle = libusb_init();
+
+	// read config file
+	char lib[MAX_CONFIG_LINE];
+	backend_t* backend;
+	FILE* f = fopen(config_file, "r");
+	if (f == NULL) {
+		syslog(LOG_ERR, "meta-backend: config file \"%s\" not found.",
+			   config_file);
+		return -1;
+	}
+	while (fgets(lib, MAX_CONFIG_LINE, f)) {
+		meta_strip_newline(lib);
+		if (strlen(lib)==0) continue;
+		char* libpath = (char*)malloc(strlen(lib) + strlen(lib_dir) + 2);
+		strcpy(libpath, lib_dir);
+		strcat(libpath, "/");
+		strcat(libpath, lib);
+		backend = load_backend(libpath);
+		free(libpath);
+		if (backend != NULL && meta_attach_backend(backend)==0) {
+			meta_attach_scanners(backend->scanbtnd_get_supported_devices(),
+				backend);
+		}
+	}
+	fclose(f);
+
+	return 0;
+}
+
+
+int scanbtnd_rescan(void)
+{
+	backend_t* backend;
+
+	meta_detach_scanners();
+	meta_scanners = NULL;
+
+	backend = meta_backends;
+	while (backend != NULL) {
+		backend->scanbtnd_rescan();
+		meta_attach_scanners(backend->scanbtnd_get_supported_devices(),
+							 backend);
+		backend = backend->next;
+	}
+
+	return 0;
+}
+
+
+const scanner_t* scanbtnd_get_supported_devices(void)
+{
+	return meta_scanners;
+}
+
+
+int scanbtnd_open(scanner_t* scanner)
+{
+  // if devices have been added/removed, return -ENODEV to
+  // make scanbuttond update its device list
+	if (libusb_get_changed_device_count() != 0) {
+		return -ENODEV;
+	}
+	backend_t* backend = meta_lookup_backend(scanner);
+	if (backend == NULL) return -1;
+	return backend->scanbtnd_open(scanner);
+}
+
+
+int scanbtnd_close(scanner_t* scanner)
+{
+	backend_t* backend = meta_lookup_backend(scanner);
+	if (backend == NULL) return -1;
+	return backend->scanbtnd_close(scanner);
+}
+
+
+int scanbtnd_get_button(scanner_t* scanner)
+{
+	backend_t* backend = meta_lookup_backend(scanner);
+	if (backend == NULL) return 0;
+	return backend->scanbtnd_get_button(scanner);
+}
+
+
+const char* scanbtnd_get_sane_device_descriptor(scanner_t* scanner)
+{
+	backend_t* backend = meta_lookup_backend(scanner);
+	if (backend == NULL) return NULL;
+	return backend->scanbtnd_get_sane_device_descriptor(scanner);
+}
+
+
+int scanbtnd_exit(void)
+{
+	syslog(LOG_INFO, "meta-backend: exit");
+	meta_detach_scanners();
+	meta_detach_backends();
+	libusb_exit(libusb_handle);
+	return 0;
+}
+

src/scanbuttond-0.2.3/backends/meta.conf

+libscanbtnd-backend_epson.so
+libscanbtnd-backend_plustek.so
+libscanbtnd-backend_plustek_umax.so
+libscanbtnd-backend_snapscan.so
+libscanbtnd-backend_niash.so
+libscanbtnd-backend_mustek.so

src/scanbuttond-0.2.3/backends/meta.h

+// meta.h: meta backend ("dynamic backend loader")
+// This file is part of scanbuttond.
+// Copyleft )c( 2005 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#ifndef __META_H_INCLUDED
+#define __META_H_INCLUDED
+
+#include "scanbuttond/backend.h"
+#include "scanbuttond/loader.h"
+
+#endif

src/scanbuttond-0.2.3/backends/mustek.c

+// mustek.c : scanbuttond backend for mustek/gt68xx devices
+// This file is part of scanbuttond.
+// Copyleft )c( 2006 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <syslog.h>
+#include "scanbuttond/scanbuttond.h"
+#include "scanbuttond/libusbi.h"
+#include "mustek.h"
+
+static char* backend_name = "Mustek USB";
+
+#define NUM_SUPPORTED_USB_DEVICES 1
+
+static int supported_usb_devices[NUM_SUPPORTED_USB_DEVICES][3] = {
+	// vendor, product, num_buttons
+	{ 0x055f, 0x0409, 5 } // Mustek BearPaw 2448TA
+};
+
+static char* usb_device_descriptions[NUM_SUPPORTED_USB_DEVICES][2] = {
+	{ "Mustek", "BearPaw 2448TA"}
+};
+
+
+libusb_handle_t* libusb_handle;
+scanner_t* mustek_scanners = NULL;
+
+
+// returns -1 if the scanner is unsupported, or the index of the
+// corresponding vendor-product pair in the supported_usb_devices array.
+int mustek_match_libusb_scanner(libusb_device_t* device)
+{
+	int index;
+	for (index = 0; index < NUM_SUPPORTED_USB_DEVICES; index++) {
+		if (supported_usb_devices[index][0] == device->vendorID &&
+				  supported_usb_devices[index][1] == device->productID) {
+			break;
+		}
+	}
+	if (index >= NUM_SUPPORTED_USB_DEVICES) return -1;
+	return index;
+}
+
+
+void mustek_attach_libusb_scanner(libusb_device_t* device)
+{
+	const char* descriptor_prefix = "mustek:libusb:";
+	int index = mustek_match_libusb_scanner(device);
+	if (index < 0) return; // unsupported
+	scanner_t* scanner = (scanner_t*)malloc(sizeof(scanner_t));
+	scanner->vendor = usb_device_descriptions[index][0];
+	scanner->product = usb_device_descriptions[index][1];
+	scanner->connection = CONNECTION_LIBUSB;
+	scanner->internal_dev_ptr = (void*)device;
+	scanner->lastbutton = 0;
+	scanner->sane_device = (char*)malloc(strlen(device->location) + 
+		strlen(descriptor_prefix) + 1);
+	strcpy(scanner->sane_device, descriptor_prefix);
+	strcat(scanner->sane_device, device->location);
+	scanner->num_buttons = supported_usb_devices[index][2];
+	scanner->is_open = 0;
+	scanner->next = mustek_scanners;
+	mustek_scanners = scanner;
+}
+
+
+void mustek_detach_scanners(void)
+{
+	scanner_t* next;
+	while (mustek_scanners != NULL) {
+		next = mustek_scanners->next;
+		free(mustek_scanners->sane_device);
+		free(mustek_scanners);
+		mustek_scanners = next;
+	}
+}
+
+
+void mustek_scan_devices(libusb_device_t* devices)
+{
+	int index;
+	libusb_device_t* device = devices;
+	while (device != NULL) {
+		index = mustek_match_libusb_scanner(device);
+		if (index >= 0)
+			mustek_attach_libusb_scanner(device);
+		device = device->next;
+	}
+}
+
+
+int mustek_init_libusb(void)
+{
+	libusb_device_t* devices;
+
+	libusb_handle = libusb_init();
+	devices = libusb_get_devices(libusb_handle);
+	mustek_scan_devices(devices);
+	return 0;
+}
+
+
+const char* scanbtnd_get_backend_name(void)
+{
+	return backend_name;
+}
+
+
+int scanbtnd_init(void)
+{
+	mustek_scanners = NULL;
+
+	syslog(LOG_INFO, "mustek-backend: init");
+	return mustek_init_libusb();
+}
+
+
+int scanbtnd_rescan(void)
+{
+	libusb_device_t *devices;
+
+	mustek_detach_scanners();
+	mustek_scanners = NULL;
+	libusb_rescan(libusb_handle);
+	devices = libusb_get_devices(libusb_handle);
+	mustek_scan_devices(devices);
+	return 0;
+}
+
+
+const scanner_t* scanbtnd_get_supported_devices(void)
+{
+	return mustek_scanners;
+}
+
+
+int scanbtnd_open(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			// if devices have been added/removed, return -ENODEV to
+			// make scanbuttond update its device list
+			if (libusb_get_changed_device_count() != 0)
+				return -ENODEV;
+			result = libusb_open((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 1;
+	return result;
+}
+
+
+int scanbtnd_close(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (!scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			result = libusb_close((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 0;
+	return result;
+}
+
+
+int mustek_read(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_read((libusb_device_t*)scanner->internal_dev_ptr, 
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+int mustek_write(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_write((libusb_device_t*)scanner->internal_dev_ptr, 
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+void mustek_flush(scanner_t* scanner)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			libusb_flush((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+}                    
+
+ 
+int scanbtnd_get_button(scanner_t* scanner)
+{
+	unsigned char bytes[255];
+	int num_bytes;
+
+	bytes[0] = 0x74; // check function key
+
+	if (!scanner->is_open)
+		return -EINVAL;
+
+	num_bytes = mustek_write(scanner, (void*)bytes, 1);
+	if (num_bytes != 1) {
+		mustek_flush(scanner);
+		return 0;
+	}
+	num_bytes = mustek_read(scanner, (void*)bytes, 4);
+	if (num_bytes != 4) {
+		mustek_flush(scanner);
+		return 0;
+	}
+	switch (bytes[2]) {
+	case 0x10: // scan button
+		return 1;
+	case 0x14: // copy
+		return 2;
+	case 0x12: // fax
+		return 3;
+	case 0x18: // email
+		return 4;
+	case 0x11: // panel
+		return 5;
+	}
+	return 0;
+}
+
+
+const char* scanbtnd_get_sane_device_descriptor(scanner_t* scanner)
+{
+	return scanner->sane_device;
+}
+
+
+int scanbtnd_exit(void)
+{
+	syslog(LOG_INFO, "mustek-backend: exit");
+	mustek_detach_scanners();
+	libusb_exit(libusb_handle);
+	return 0;
+}
+

src/scanbuttond-0.2.3/backends/mustek.h

+// mustek.h : scanbuttond backend for mustek/gt68xx devices
+// This file is part of scanbuttond.
+// Copyleft )c( 2006 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#ifndef __MUSTEK_H_INCLUDED
+#define __MUSTEK_H_INCLUDED
+
+#include "scanbuttond/backend.h"
+
+#endif

src/scanbuttond-0.2.3/backends/niash.c

+// niash.c: Niash device backend
+// This file is part of scanbuttond.
+// Copyleft )c( 2005 by Bernhard Stiftner
+// Copyleft )c( 2005 by Dirk Wriedt
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <syslog.h>
+#include "scanbuttond/scanbuttond.h"
+#include "scanbuttond/libusbi.h"
+#include "niash.h"
+
+static char* backend_name = "Niash USB";
+
+#define NUM_SUPPORTED_USB_DEVICES 4
+
+static int supported_usb_devices[NUM_SUPPORTED_USB_DEVICES][3] = {
+	// vendor, product, num_buttons
+	{ 0x06bd, 0x0100, 4 },	// Agfa Snapscan Touch
+	{ 0x03f0, 0x0205, 2 },	// HP Scanjet 3300c
+	{ 0x03f0, 0x0405, 3 },	// HP Scanjet 3400c
+	{ 0x03f0, 0x0305, 3 }	// HP Scanjet 4300c
+};
+
+// TODO: check if this backend really works on the Epson 2580 too...
+static char* usb_device_descriptions[NUM_SUPPORTED_USB_DEVICES][2] = {
+	{ "Agfa", "Snapscan Touch" },
+	{ "Hewlett-Packard", "Scanjet 3300c" },
+	{ "Hewlett-Packard", "Scanjet 3400c" },
+	{ "Hewlett-Packard", "Scanjet 4300c" }
+};
+
+
+libusb_handle_t* libusb_handle;
+scanner_t* niash_scanners = NULL;
+
+
+// returns -1 if the scanner is unsupported, or the index of the
+// corresponding vendor-product pair in the supported_usb_devices array.
+int niash_match_libusb_scanner(libusb_device_t* device)
+{
+	int index;
+	for (index = 0; index < NUM_SUPPORTED_USB_DEVICES; index++) {
+		if (supported_usb_devices[index][0] == device->vendorID &&
+				  supported_usb_devices[index][1] == device->productID) {
+			break;
+		}
+	}
+	if (index >= NUM_SUPPORTED_USB_DEVICES) return -1;
+	return index;
+}
+
+
+// TODO: check if the descriptor matches the SANE device name!
+void niash_attach_libusb_scanner(libusb_device_t* device)
+{
+	const char* descriptor_prefix = "niash:libusb:";
+	int index = niash_match_libusb_scanner(device);
+	if (index < 0) return; // unsupported
+	scanner_t* scanner = (scanner_t*)malloc(sizeof(scanner_t));
+	scanner->vendor = usb_device_descriptions[index][0];
+	scanner->product = usb_device_descriptions[index][1];
+	scanner->connection = CONNECTION_LIBUSB;
+	scanner->internal_dev_ptr = (void*)device;
+	scanner->lastbutton = 0;
+	scanner->sane_device = (char*)malloc(strlen(device->location) + 
+		strlen(descriptor_prefix) + 1);
+	strcpy(scanner->sane_device, descriptor_prefix);
+	strcat(scanner->sane_device, device->location);
+	scanner->num_buttons = supported_usb_devices[index][2];
+	scanner->is_open = 0;
+	scanner->next = niash_scanners;
+	niash_scanners = scanner;
+}
+
+
+void niash_detach_scanners(void)
+{
+	scanner_t* next;
+	while (niash_scanners != NULL) {
+		next = niash_scanners->next;
+		free(niash_scanners->sane_device);
+		free(niash_scanners);
+		niash_scanners = next;
+	}
+}
+
+
+void niash_scan_devices(libusb_device_t* devices)
+{
+	int index;
+	libusb_device_t* device = devices;
+	while (device != NULL) {
+		index = niash_match_libusb_scanner(device);
+		if (index >= 0) 
+			niash_attach_libusb_scanner(device);
+		device = device->next;
+	}
+}
+
+
+int niash_init_libusb(void)
+{
+	libusb_device_t* devices;
+
+	libusb_handle = libusb_init();
+	devices = libusb_get_devices(libusb_handle);
+	niash_scan_devices(devices);
+	return 0;
+}
+
+
+const char* scanbtnd_get_backend_name(void)
+{
+	return backend_name;
+}
+
+
+int scanbtnd_init(void)
+{
+	niash_scanners = NULL;
+
+	syslog(LOG_INFO, "niash-backend: init");
+	return niash_init_libusb();
+}
+
+
+int scanbtnd_rescan(void)
+{
+	libusb_device_t* devices;
+
+	niash_detach_scanners();
+	niash_scanners = NULL;
+	libusb_rescan(libusb_handle);
+	devices = libusb_get_devices(libusb_handle);
+	niash_scan_devices(devices);
+	return 0;
+}
+
+
+const scanner_t* scanbtnd_get_supported_devices(void)
+{
+	return niash_scanners;
+}
+
+
+int scanbtnd_open(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			// if devices have been added/removed, return -ENODEV to
+			// make scanbuttond update its device list
+			if (libusb_get_changed_device_count() != 0)
+				return -ENODEV;
+			result = libusb_open((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 1;
+	return result;
+}
+
+
+int scanbtnd_close(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (!scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			result = libusb_close((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 0;
+	return result;
+}
+
+
+int niash_control_msg(scanner_t* scanner, int requesttype, int request,
+					  int value, int index, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_control_msg((libusb_device_t*)scanner->internal_dev_ptr,
+									   requesttype, request, value, index, buffer,
+									   bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+int scanbtnd_get_button(scanner_t* scanner)
+{
+	unsigned char bytes[255];
+	int value[255];
+	int requesttype[255];
+	int num_bytes;
+	int button;
+	int i;
+
+	if (!scanner->is_open)
+		return -EINVAL;
+
+	/*
+	The button status seems to be held in Register 0x2e of the
+	scanner's USB - IEEE1284 bridge
+	I checked the usb sniffer logs against hp3300c_xfer.h (hp3300 sane backend)
+	and learned that the requests being submitted by the windows driver for
+	my Agfa Snapscan Touch seem to follow this schema:
+
+	request value                data   datasize
+	0x40    SPP_CONTROL   (0x87) 0x14        1
+	0x40    EPP_ADDR      (0x83) 0x2e        1
+	0x40    SPP_CONTROL   (0x87) 0x34        1
+	0xc0    EPP_DATA_READ (0x84) returned    1
+	0x40    SPP_CONTROL   (0x87) 0x14        1
+
+	The register can be read by setting the address with an EPP_ADDR call,
+	then issuing an EPP_DATA_READ call.
+	I don't know what the last request is for.
+	*/
+
+	requesttype[0]=0x40; bytes[0] = 0x14; value[0]=0x87; /* SPP_CONTROL */
+	requesttype[1]=0x40; bytes[1] = 0x2e; value[1]=0x83; /* EPP_ADDR */
+	requesttype[2]=0x40; bytes[2] = 0x34; value[2]=0x87; /* SPP_CONTROL */
+	requesttype[3]=0xc0; bytes[3] = 0xff; value[3]=0x84; /* EPP_DATA_READ */
+	requesttype[4]=0x40; bytes[4] = 0x14; value[4]=0x87; /* SPP_CONTROL */
+	for(i=0;i<5;i++) {
+		num_bytes=niash_control_msg(scanner, requesttype[i], 0x0c, value[i], 0, (void*)&bytes + i, 0x01);
+		if (num_bytes < 0 ) return 0;
+	}
+	switch (bytes[3]) {
+		case 0x02: button = 1; break;
+		case 0x04: button = 2; break;
+		case 0x08: button = 3; break;
+		case 0x10: button = 4; break;
+		default: button = 0; break;
+	};
+
+	return button;
+}
+
+
+const char* scanbtnd_get_sane_device_descriptor(scanner_t* scanner)
+{
+	return scanner->sane_device;
+}
+
+
+int scanbtnd_exit(void)
+{
+	syslog(LOG_INFO, "niash-backend: exit");
+	niash_detach_scanners();
+	libusb_exit(libusb_handle);
+	return 0;
+}
+

src/scanbuttond-0.2.3/backends/niash.h

+// niash.h: Niash device backend
+// This file is part of scanbuttond.
+// This file is part of scanbuttond.
+// Copyleft )c( 2005 by Bernhard Stiftner
+// Copyleft )c( 2005 by Dirk Wriedt
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#ifndef __NIASH_H_INCLUDED
+#define __NIASH_H_INCLUDED
+
+#include "scanbuttond/backend.h"
+
+#endif

src/scanbuttond-0.2.3/backends/plustek.c

+// plustek.c: Plustek device backend
+// This file is part of scanbuttond.
+// Copyleft )c( 2005 by Hans Verkuil
+// Copyleft )c( 2005-2006 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <syslog.h>
+#include "scanbuttond/scanbuttond.h"
+#include "scanbuttond/libusbi.h"
+#include "plustek.h"
+
+static char* backend_name = "Plustek USB";
+
+#define NUM_SUPPORTED_USB_DEVICES 8
+
+static int supported_usb_devices[NUM_SUPPORTED_USB_DEVICES][3] = {
+	// vendor, product, num_buttons
+	{ 0x04a9, 0x2207, 1 },	// CanoScan N1220U
+	{ 0x04a9, 0x2208, 1 },	// CanoScan CanoScan D660U
+	{ 0x04a9, 0x2206, 1 },	// CanoScan N650U
+	{ 0x04a9, 0x220d, 3 },	// CanoScan LiDE 20
+	{ 0x04a9, 0x2220, 3 },  // CanoScan LiDE 25
+	{ 0x04a9, 0x220e, 3 },	// CanoScan LiDE 30
+	{ 0x04b8, 0x011d, 4 },  // Epson Perfection 1260
+	{ 0x03f0, 0x0605, 2 }   // HP ScanJet 2200c (maybe only 1 button?)
+};
+
+static char* usb_device_descriptions[NUM_SUPPORTED_USB_DEVICES][2] = {
+	{ "Canon", "CanoScan N1220U" },
+	{ "Canon", "CanoScan D660U"  },
+	{ "Canon", "CanoScan N650U" },
+	{ "Canon", "CanoScan LiDE 20" },
+	{ "Canon", "CanoScan LiDE 25" },
+	{ "Canon", "CanoScan LiDE 30" },
+	{ "Epson", "Perfection 1260" },
+	{ "Hewlett-Packard", "ScanJet 2200c" }
+};
+
+
+libusb_handle_t* libusb_handle;
+scanner_t* plustek_scanners = NULL;
+
+
+// returns -1 if the scanner is unsupported, or the index of the
+// corresponding vendor-product pair in the supported_usb_devices array.
+int plustek_match_libusb_scanner(libusb_device_t* device)
+{
+	int index;
+	for (index = 0; index < NUM_SUPPORTED_USB_DEVICES; index++) {
+		if (supported_usb_devices[index][0] == device->vendorID &&
+				  supported_usb_devices[index][1] == device->productID) {
+			break;
+		}
+	}
+	if (index >= NUM_SUPPORTED_USB_DEVICES) return -1;
+	return index;
+}
+
+
+void plustek_attach_libusb_scanner(libusb_device_t* device)
+{
+	const char* descriptor_prefix = "plustek:libusb:";
+	int index = plustek_match_libusb_scanner(device);
+	if (index < 0) return; // unsupported
+	scanner_t* scanner = (scanner_t*)malloc(sizeof(scanner_t));
+	scanner->vendor = usb_device_descriptions[index][0];
+	scanner->product = usb_device_descriptions[index][1];
+	scanner->connection = CONNECTION_LIBUSB;
+	scanner->internal_dev_ptr = (void*)device;
+	scanner->lastbutton = 0;
+	scanner->sane_device = (char*)malloc(strlen(device->location) +
+		strlen(descriptor_prefix) + 1);
+	strcpy(scanner->sane_device, descriptor_prefix);
+	strcat(scanner->sane_device, device->location);
+	scanner->num_buttons = supported_usb_devices[index][2];
+	scanner->is_open = 0;
+	scanner->next = plustek_scanners;
+	plustek_scanners = scanner;
+}
+
+
+void plustek_detach_scanners(void)
+{
+	scanner_t* next;
+	while (plustek_scanners != NULL) {
+		next = plustek_scanners->next;
+		free(plustek_scanners->sane_device);
+		free(plustek_scanners);
+		plustek_scanners = next;
+	}
+}
+
+
+void plustek_scan_devices(libusb_device_t* devices)
+{
+	int index;
+	libusb_device_t* device = devices;
+	while (device != NULL) {
+		index = plustek_match_libusb_scanner(device);
+		if (index >= 0) 
+			plustek_attach_libusb_scanner(device);
+		device = device->next;
+	}
+}
+
+
+int plustek_init_libusb(void)
+{
+	libusb_device_t* devices;
+
+	libusb_handle = libusb_init();
+	devices = libusb_get_devices(libusb_handle);
+	plustek_scan_devices(devices);
+	return 0;
+}
+
+
+const char* scanbtnd_get_backend_name(void)
+{
+	return backend_name;
+}
+
+
+int scanbtnd_init(void)
+{
+	plustek_scanners = NULL;
+
+	syslog(LOG_INFO, "plustek-backend: init");
+	return plustek_init_libusb();
+}
+
+
+int scanbtnd_rescan(void)
+{
+	libusb_device_t* devices;
+
+	plustek_detach_scanners();
+	plustek_scanners = NULL;
+	libusb_rescan(libusb_handle);
+	devices = libusb_get_devices(libusb_handle);
+	plustek_scan_devices(devices);
+	return 0;
+}
+
+
+const scanner_t* scanbtnd_get_supported_devices(void)
+{
+	return plustek_scanners;
+}
+
+
+int scanbtnd_open(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			// if devices have been added/removed, return -ENODEV to
+			// make scanbuttond update its device list
+			if (libusb_get_changed_device_count() != 0)
+				return -ENODEV;
+			result = libusb_open((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 1;
+	return result;
+}
+
+
+int scanbtnd_close(scanner_t* scanner)
+{
+	int result = -ENOSYS;
+	if (!scanner->is_open)
+		return -EINVAL;
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			result = libusb_close((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+	if (result == 0)
+		scanner->is_open = 0;
+	return result;
+}
+
+
+int plustek_read(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_read((libusb_device_t*)scanner->internal_dev_ptr,
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+
+int plustek_write(scanner_t* scanner, void* buffer, int bytecount)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			return libusb_write((libusb_device_t*)scanner->internal_dev_ptr,
+				buffer, bytecount);
+			break;
+	}
+	return -1;
+}
+
+void plustek_flush(scanner_t* scanner)
+{
+	switch (scanner->connection) {
+		case CONNECTION_LIBUSB:
+			libusb_flush((libusb_device_t*)scanner->internal_dev_ptr);
+			break;
+	}
+}
+
+
+int scanbtnd_get_button(scanner_t* scanner)
+{
+	/*
+	Note 1: I strongly suspect that the command 0x01 0x69 0x00 0x01 will return
+	a button bitmask. For my Canon N1220U it returns 0x04, which happens to
+	be the bit I have to test against to see if the scanner button was pressed.
+	However, this has to be tested on other scanners to see if this is true.
+	UPDATE by BS: The LIDE 20 also returns 0x04, but it has three buttons!
+	So this guess is probably wrong. (Thanks to Christian Bucher for this info)
+	
+	Note 2: This works on my Canon N1220U. Whether this is Canon specific or
+	if it works for all 'plustek usb' type scanners is something I don't know.
+
+	Note 3: You must have run sane-find-scanner once. Sane apparently initializes
+	something on the scanner allowing this to work. Otherwise all you get is 0x00.
+	
+	Note 4: by /cbx
+	On my CanoScan LIDE20, the default value is $62 and the bits for the
+	buttons are as follows:
+	Scan: $72 ==> 0x10
+	Copy: $6a ==> 0x08
+	Mail: $66 ==> 0x04
+	*/
+
+	unsigned char bytes[255];
+	int num_bytes;
+	int button = 0;
+	
+	bytes[0] = 1;
+	bytes[1] = 2;
+	bytes[2] = 0;
+	bytes[3] = 1;
+	
+	if (!scanner->is_open)
+		return -EINVAL;
+
+	num_bytes = plustek_write(scanner, (void*)bytes, 4);
+	if (num_bytes != 4) {
+		plustek_flush(scanner);
+		return 0;
+	}
+	num_bytes = plustek_read(scanner, (void*)bytes, 1);
+	if (num_bytes != 1) {
+		plustek_flush(scanner);
+		return 0;
+	}
+	
+	// by BS: This is my first attempt to get rid of the 
+	// hardcoded button bitmask. Note that I do not own any device
+	// supported by this backend, so this code is based on guessing.
+	// Tested on the LIDE 20, should work for 1-button devices, too.
+	switch (scanner->num_buttons) {
+	case 1:
+		if ((bytes[0] & 0x04) != 0) button = 1;
+		break;
+	case 2:
+		if ((bytes[0] & 0x08) != 0) button = 1;
+		if ((bytes[0] & 0x04) != 0) button = 2;
+		break;
+	case 3: 
+		if ((bytes[0] & 0x10) != 0) button = 1;
+		if ((bytes[0] & 0x08) != 0) button = 2;
+		if ((bytes[0] & 0x04) != 0) button = 3;
+		break;	
+	case 4: // only tested for the Epson Perfection 1260...
+		// seems to be a bit odd compared to the other cases...
+		if ((bytes[0] & 0x08) != 0) button = 1;
+		if ((bytes[0] & 0x10) != 0) button = 2;
+		if ((bytes[0] & 0x20) != 0) button = 3;
+		if ((bytes[0] & 0x40) != 0) button = 4;
+		break;
+	}
+	return button;
+}
+
+
+const char* scanbtnd_get_sane_device_descriptor(scanner_t* scanner)
+{
+	return scanner->sane_device;
+}
+
+
+int scanbtnd_exit(void)
+{
+	syslog(LOG_INFO, "plustek-backend: exit");
+	plustek_detach_scanners();
+	libusb_exit(libusb_handle);
+	return 0;
+}
+

src/scanbuttond-0.2.3/backends/plustek.h

+// plustek.h: Plustek device backend
+// This file is part of scanbuttond.
+// Copyleft )c( 2005 by Hans Verkuil
+// Copyleft )c( 2005 by Bernhard Stiftner
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+#ifndef __PLUSTEK_H_INCLUDED
+#define __PLUSTEK_H_INCLUDED
+
+#include "scanbuttond/backend.h"
+
+#endif