Move man page sane-umax_pp.5 back to libsane-common

10 files changed, 2165 insertions, 7 deletions

diff --git a/.pc/.quilt_patches b/.pc/.quilt_patches
new file mode 100644
index 0000000..6857a8d
--- /dev/null
+++ b/.pc/.quilt_patches
@@ -0,0 +1 @@
+debian/patches
diff --git a/.pc/.quilt_series b/.pc/.quilt_series
new file mode 100644
index 0000000..c206706
--- /dev/null
+++ b/.pc/.quilt_series
@@ -0,0 +1 @@
+series
diff --git a/debian/changelog b/debian/changelog
index c0b6e1e..e977760 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -9,6 +9,14 @@ sane-backends (1.1.1-3) UNRELEASED; urgency=medium
     - Don't remove group scanner (Closes: #1005737).
   * debian/control:
     - Add Recommends: sane-airscan to libsane1 (Closes: 1005817).
+  * Move man page sane-umax_pp.5 back to libsane-common (Closes: #1005736):
+    - debian/rules: 
+      - Remove delete manpage vom libsane-common.
+    - New debian/sane-utils.preinst to remove man page and sysmlink.
+    - debian/sane-utils.link:
+      - Remove create link from sane-umax_pp.5
+    - debian/control:
+      - Add new Breaks and Replace.
 
  -- Jörg Frings-Fürst <debian@jff.email>  Mon, 14 Feb 2022 21:28:17 +0100
 
diff --git a/debian/control b/debian/control
index f6277ff..a7b9e87 100644
--- a/debian/control
+++ b/debian/control
@@ -43,8 +43,7 @@ Depends:
  ${shlibs:Depends}
 Pre-Depends:
  ${misc:Pre-Depends}
-Breaks: libsane-common (<<1.0.27-1~)
-Replaces: libsane-common (<<1.0.27-1~)
+Breaks: libsane-common (<<1.1.1-3~)
 Suggests: avahi-daemon, unpaper
 Description: API library for scanners -- utilities
  SANE stands for "Scanner Access Now Easy" and is an application
@@ -67,7 +66,8 @@ Multi-Arch: foreign
 Pre-Depends:
  dpkg (>= 1.15.7.2)
 Depends: ${misc:Depends}
-Breaks: sane-utils (<<1.0.27-1~)
+Breaks: sane-utils (<<1.1.1-3~)
+Replaces: sane-utils (<<1.1.1-3~)
 Description: API library for scanners -- documentation and support files
  SANE stands for "Scanner Access Now Easy" and is an application
  programming interface (API) that provides standardized access to any
@@ -97,7 +97,7 @@ Depends:
  ${misc:Depends},
  ${shlibs:Depends}
 Recommends:
- sane-airscan
+ sane-airscan,
  sane-utils (>= ${binary:Version}),
  ipp-usb
 Suggests: avahi-daemon, hplip
diff --git a/debian/rules b/debian/rules
index d0e1664..ef8e976 100755
--- a/debian/rules
+++ b/debian/rules
@@ -106,7 +106,6 @@ override_dh_installman-indep:
 	$(RM) $(CURDIR)/debian/libsane-common/usr/share/man/man1/sane-find-scanner.1
 	$(RM) $(CURDIR)/debian/libsane-common/usr/share/man/man1/scanimage.1
 	$(RM) $(CURDIR)/debian/libsane-common/usr/share/man/man1/sane-config.1
-	$(RM) $(CURDIR)/debian/libsane-common/usr/share/man/man5/sane-umax_pp.5
 	$(RM) -r $(CURDIR)/debian/libsane-common/usr/share/man/man8/
 	$(RM) -r $(CURDIR)/debian/libsane-common/usr/share/man/man1/
         # remove manpages for not build libs
diff --git a/debian/sane-utils.links b/debian/sane-utils.links
index dacfe5d..50ffd0e 100644
--- a/debian/sane-utils.links
+++ b/debian/sane-utils.links
@@ -1,2 +1 @@
 /dev/null  /lib/systemd/system/saned.service
-/usr/share/man/man5/sane-umax_pp.5 /usr/share/man/man5/umax_pp.5
diff --git a/debian/sane-utils.manpages b/debian/sane-utils.manpages
index 6a2c010..357020f 100644
--- a/debian/sane-utils.manpages
+++ b/debian/sane-utils.manpages
@@ -1,3 +1,2 @@
 usr/share/man/man8/*.8
 usr/share/man/man1/*.1
-/usr/share/man/man5/sane-umax_pp.5
diff --git a/debian/sane-utils.preinst b/debian/sane-utils.preinst
new file mode 100644
index 0000000..1a7f24b
--- /dev/null
+++ b/debian/sane-utils.preinst
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -e
+
+MANPAGE=/usr/share/man/man5/sane-umax_pp.5.gz
+MANLINK=/usr/share/man/man5/umax_pp.5.gz
+
+
+if [ -f "$MANLINK" ] && [ -L "$MANLINK" ]; then
+    # Remove old directory and files that are now provided by xsane-common
+    rm -rf "$MANLINK"
+fi
+
+
+if [ -f "$MANPAGE" ]; then
+    # Remove old directory and files that are now provided by xsane-common
+    rm -rf "$MANPAGE"
+fi
+
+
+#DEBHELPER#
diff --git a/tools/sane-find-scanner.c.orig b/tools/sane-find-scanner.c.orig
new file mode 100644
index 0000000..25e5954
--- /dev/null
+++ b/tools/sane-find-scanner.c.orig
@@ -0,0 +1,2108 @@
+/* sane-find-scanner.c
+
+   Copyright (C) 1997-2013 Oliver Rauch, Henning Meier-Geinitz, and others.
+
+   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, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "../include/sane/config.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+
+#if defined (HAVE_DDK_NTDDSCSI_H) || defined (HAVE_NTDDSCSI_H)
+# define WIN32_SCSI
+# include <windows.h>
+# if defined (HAVE_DDK_NTDDSCSI_H)
+#  include <ddk/scsi.h>
+#  include <ddk/ntddscsi.h>
+# elif defined (HAVE_NTDDSCSI_H)
+#  include <ntddscsi.h>
+# endif
+#endif
+
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_scsi.h"
+#include "../include/sane/sanei_pa4s2.h"
+#include "../include/sane/sanei_config.h"
+
+#ifdef HAVE_LIBUSB_LEGACY
+#ifdef HAVE_LUSB0_USB_H
+#include <lusb0_usb.h>
+#else
+#include <usb.h>
+#endif
+extern char * check_usb_chip (struct usb_device *dev, int verbosity, SANE_Bool from_file);
+#endif
+
+#ifdef HAVE_LIBUSB
+#include <libusb.h>
+extern char * check_usb_chip (int verbosity,
+			      struct libusb_device_descriptor desc,
+			      libusb_device_handle *hdl,
+			      struct libusb_config_descriptor *config0);
+#endif
+
+#include "../include/sane/sanei_usb.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX 1024
+#endif
+
+static const char *prog_name;
+static int verbose = 1;
+static SANE_Bool force = SANE_FALSE;
+static SANE_Bool device_found = SANE_FALSE;
+static SANE_Bool libusb_device_found = SANE_FALSE;
+static SANE_Bool unknown_found = SANE_FALSE;
+
+#ifdef HAVE_LIBUSB
+libusb_context *sfs_usb_ctx;
+#endif
+
+typedef struct
+{
+  unsigned char *cmd;
+  size_t size;
+}
+scsiblk;
+
+#define INQUIRY					0x12
+#define set_inquiry_return_size(icb,val)	icb[0x04]=val
+#define IN_periph_devtype_cpu			0x03
+#define IN_periph_devtype_scanner		0x06
+#define get_scsi_inquiry_vendor(in, buf)	strncpy(buf, in + 0x08, 0x08)
+#define get_scsi_inquiry_product(in, buf)	strncpy(buf, in + 0x10, 0x010)
+#define get_scsi_inquiry_version(in, buf)	strncpy(buf, in + 0x20, 0x04)
+#define get_scsi_inquiry_periph_devtype(in)	(in[0] & 0x1f)
+#define get_scsi_inquiry_additional_length(in)	in[0x04]
+#define set_scsi_inquiry_length(out,n)		out[0x04]=n-5
+
+static unsigned char inquiryC[] = {
+  INQUIRY, 0x00, 0x00, 0x00, 0xff, 0x00
+};
+static scsiblk inquiry = {
+  inquiryC, sizeof (inquiryC)
+};
+
+static void
+usage (char *msg)
+{
+  fprintf (stderr, "Usage: %s [-hvqf] [devname ...]\n", prog_name);
+  fprintf (stderr, "\t-h: print this help message\n");
+  fprintf (stderr, "\t-v: be more verbose (can be used multiple times)\n");
+  fprintf (stderr, "\t-q: be quiet (print only devices, no comments)\n");
+  fprintf (stderr, "\t-f: force opening devname as SCSI even if it looks "
+	   "like USB\n");
+  fprintf (stderr, "\t-p: enable scanning for parallel port devices\n");
+#ifdef HAVE_LIBUSB_LEGACY
+  fprintf (stderr, "\t-F file: try to detect chipset from given "
+	   "/proc/bus/usb/devices file\n");
+#endif
+  if (msg)
+    fprintf (stderr, "\t%s\n", msg);
+}
+
+/* if SCSI generic is optional on your OS, and there is a software test
+   which will determine if it is included, add it here. If you are sure
+   that SCSI generic was found, return 1. If SCSI generic is always
+   available in your OS, return 1 */
+
+static int
+check_sg (void)
+{
+#if defined(__linux__)
+  /* Assumption: /proc/devices lines are shorter than 256 characters */
+  char line[256], driver[256] = "";
+  FILE *stream;
+
+  stream = fopen ("/proc/devices", "r");
+  /* Likely reason for failure, no /proc => probably no SG either */
+  if (stream == NULL)
+    return 0;
+
+  while (fgets (line, sizeof (line) - 1, stream))
+    {
+      if (sscanf (line, " %*d %s\n", driver) > 0 && !strcmp (driver, "sg"))
+	break;
+    }
+  fclose (stream);
+
+  if (strcmp (driver, "sg"))
+    {
+      return 0;
+    }
+  else
+    {
+      return 1;
+    }
+#endif
+  return 1;			/* Give up, and assume yes to avoid false negatives */
+}
+
+/* Display a buffer in the log. Display by lines of 16 bytes. */
+static void
+hexdump (const char *comment, unsigned char *buf, const int length)
+{
+  int i;
+  char line[128];
+  char *ptr;
+  char asc_buf[17];
+  char *asc_ptr;
+
+  printf ("  %s\n", comment);
+
+  i = 0;
+  goto start;
+
+  do
+    {
+      if (i < length)
+	{
+	  ptr += sprintf (ptr, " %2.2x", *buf);
+
+	  if (*buf >= 32 && *buf <= 127)
+	    {
+	      asc_ptr += sprintf (asc_ptr, "%c", *buf);
+	    }
+	  else
+	    {
+	      asc_ptr += sprintf (asc_ptr, ".");
+	    }
+	}
+      else
+	{
+	  /* After the length; do nothing. */
+	  ptr += sprintf (ptr, "   ");
+	}
+
+      i++;
+      buf++;
+
+      if ((i % 16) == 0)
+	{
+	  /* It's a new line */
+	  printf ("  %s    %s\n", line, asc_buf);
+
+	start:
+	  ptr = line;
+	  *ptr = '\0';
+	  asc_ptr = asc_buf;
+	  *asc_ptr = '\0';
+
+	  ptr += sprintf (ptr, "  %3.3d:", i);
+	}
+
+    }
+  while (i < ((length + 15) & ~15));
+}
+
+static SANE_Status
+scanner_do_scsi_inquiry (unsigned char *buffer, int sfd)
+{
+  size_t size;
+  SANE_Status status;
+
+  memset (buffer, '\0', 256);	/* clear buffer */
+
+  size = 5;			/* first get only 5 bytes to get size of
+				   inquiry_return_block */
+  set_inquiry_return_size (inquiry.cmd, size);
+  status = sanei_scsi_cmd (sfd, inquiry.cmd, inquiry.size, buffer, &size);
+
+  if (status != SANE_STATUS_GOOD)
+    return (status);
+
+  size = get_scsi_inquiry_additional_length (buffer) + 5;
+
+  /* then get inquiry with actual size */
+  set_inquiry_return_size (inquiry.cmd, size);
+  status = sanei_scsi_cmd (sfd, inquiry.cmd, inquiry.size, buffer, &size);
+
+  return (status);
+}
+
+static void
+scanner_identify_scsi_scanner (unsigned char *buffer, int sfd,
+			       char *devicename)
+{
+  unsigned char vendor[9];
+  unsigned char product[17];
+  unsigned char version[5];
+  unsigned char *pp;
+  unsigned int devtype;
+  SANE_Status status;
+  static char *devtypes[] = {
+    "disk", "tape", "printer", "processor", "CD-writer",
+    "CD-drive", "scanner", "optical-drive", "jukebox",
+    "communicator"
+  };
+  status = scanner_do_scsi_inquiry (buffer, sfd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      if (verbose > 1)
+	printf ("inquiry for device %s failed (%s)\n",
+		devicename, sane_strstatus (status));
+      return;
+    }
+
+  if (verbose > 2)
+    hexdump ("Inquiry for device:", buffer,
+	     get_scsi_inquiry_additional_length (buffer) + 5);
+
+  devtype = get_scsi_inquiry_periph_devtype (buffer);
+  if (verbose <= 1 && devtype != IN_periph_devtype_scanner
+      /* old HP scanners use the CPU id ... */
+      && devtype != IN_periph_devtype_cpu)
+    return;			/* no, continue searching */
+
+  get_scsi_inquiry_vendor ((char *) buffer, (char *) vendor);
+  get_scsi_inquiry_product ((char *) buffer, (char *) product);
+  get_scsi_inquiry_version ((char *) buffer, (char *) version);
+
+  pp = &vendor[7];
+  vendor[8] = '\0';
+  while (pp >= vendor && (*pp == ' ' || *pp >= 127))
+    *pp-- = '\0';
+
+  pp = &product[15];
+  product[16] = '\0';
+  while (pp >= product && (*pp == ' ' || *pp >= 127))
+    *pp-- = '\0';
+
+  pp = &version[3];
+  version[4] = '\0';
+  while (pp >= version && (*pp == ' ' || *(pp - 1) >= 127))
+    *pp-- = '\0';
+
+  device_found = SANE_TRUE;
+  printf ("found SCSI %s \"%s %s %s\" at %s\n",
+	  devtype < NELEMS (devtypes) ? devtypes[devtype] : "unknown device",
+	  vendor, product, version, devicename);
+  return;
+}
+
+static void
+check_scsi_file (char *file_name)
+{
+  int result;
+  int sfd;
+  unsigned char buffer[16384];
+
+  if (strstr (file_name, "usb")
+      || strstr (file_name, "uscanner") || strstr (file_name, "ugen"))
+    {
+      if (force)
+	{
+	  if (verbose > 1)
+	    printf ("checking %s even though it looks like a USB device...",
+		    file_name);
+	}
+      else
+	{
+	  if (verbose > 1)
+	    printf ("ignored %s (not a SCSI device)\n", file_name);
+	  return;
+	}
+    }
+  else if (verbose > 1)
+    printf ("checking %s...", file_name);
+
+  result = sanei_scsi_open (file_name, &sfd, NULL, NULL);
+
+  if (verbose > 1)
+    {
+      if (result != 0)
+	printf (" failed to open (%s)\n", sane_strstatus (result));
+      else
+	printf (" open ok\n");
+    }
+
+  if (result == SANE_STATUS_GOOD)
+    {
+      scanner_identify_scsi_scanner (buffer, sfd, file_name);
+      sanei_scsi_close (sfd);
+    }
+  return;
+}
+
+static void
+check_usb_file (char *file_name)
+{
+  SANE_Status result;
+  SANE_Word vendor, product;
+  SANE_Int fd;
+
+  if (!strstr (file_name, "usb")
+      && !strstr (file_name, "uscanner") && !strstr (file_name, "ugen"))
+    {
+      if (force)
+	{
+	  if (verbose > 1)
+	    printf ("checking %s even though doesn't look like a "
+		    "USB device...", file_name);
+	}
+      else
+	{
+	  if (verbose > 1)
+	    printf ("ignored %s (not a USB device)\n", file_name);
+	  return;
+	}
+    }
+  else if (verbose > 1)
+    printf ("checking %s...", file_name);
+
+  result = sanei_usb_open (file_name, &fd);
+
+  if (result != SANE_STATUS_GOOD)
+    {
+      if (verbose > 1)
+	printf (" failed to open (%s)\n", sane_strstatus (result));
+    }
+  else
+    {
+      result = sanei_usb_get_vendor_product (fd, &vendor, &product);
+      if (result == SANE_STATUS_GOOD)
+	{
+	  if (verbose > 1)
+	    printf (" open ok, vendor and product ids were identified\n");
+	  printf ("found USB scanner (vendor=0x%04x, "
+		  "product=0x%04x) at %s\n", vendor, product, file_name);
+	}
+      else
+	{
+	  if (verbose > 1)
+	    printf (" open ok, but vendor and product could NOT be "
+		    "identified\n");
+	  printf ("found USB scanner (UNKNOWN vendor and product) "
+		  "at device %s\n", file_name);
+	  unknown_found = SANE_TRUE;
+	}
+      device_found = SANE_TRUE;
+      sanei_usb_close (fd);
+    }
+}
+
+#ifdef HAVE_LIBUSB_LEGACY
+
+static char *
+get_libusb_string_descriptor (struct usb_device *dev, int index)
+{
+  usb_dev_handle *handle;
+  char *buffer, short_buffer[2];
+  struct usb_string_descriptor *sd;
+  int size = 2;
+  int i;
+
+  if (!index)
+    return 0;
+
+  handle = usb_open (dev);
+  if (!handle)
+    return 0;
+
+  sd = (struct usb_string_descriptor *) short_buffer;
+
+  if (usb_control_msg (handle,
+		       USB_ENDPOINT_IN + USB_TYPE_STANDARD + USB_RECIP_DEVICE,
+		       USB_REQ_GET_DESCRIPTOR,
+		       (USB_DT_STRING << 8) + index, 0, short_buffer,
+		       size, 1000) < 0)
+    {
+      usb_close (handle);
+      return 0;
+    }
+
+  if (sd->bLength < 2
+      || sd->bDescriptorType != USB_DT_STRING)
+    {
+      usb_close (handle);
+      return 0;
+    }
+
+  size = sd->bLength;
+
+  buffer = calloc (1, size + 1);
+  if (!buffer)
+    return 0;
+
+  sd = (struct usb_string_descriptor *) buffer;
+
+  if (usb_control_msg (handle,
+		       USB_ENDPOINT_IN + USB_TYPE_STANDARD + USB_RECIP_DEVICE,
+		       USB_REQ_GET_DESCRIPTOR,
+		       (USB_DT_STRING << 8) + index, 0, buffer,
+		       size, 1000) < 0)
+    {
+      usb_close (handle);
+      free (buffer);
+      return 0;
+    }
+
+  if (sd->bLength < 2 || sd->bLength > size
+      || sd->bDescriptorType != USB_DT_STRING)
+    {
+      usb_close (handle);
+      free (buffer);
+      return 0;
+    }
+  size = sd->bLength - 2;
+  for (i = 0; i < (size / 2); i++)
+    buffer[i] = buffer[2 + 2 * i];
+  buffer[i] = 0;
+
+  usb_close (handle);
+  return buffer;
+}
+
+static char *
+get_libusb_vendor (struct usb_device *dev)
+{
+  return get_libusb_string_descriptor (dev, dev->descriptor.iManufacturer);
+}
+
+static char *
+get_libusb_product (struct usb_device *dev)
+{
+  return get_libusb_string_descriptor (dev, dev->descriptor.iProduct);
+}
+
+static void
+check_libusb_device (struct usb_device *dev, SANE_Bool from_file)
+{
+  int is_scanner = 0;
+  char *vendor;
+  char *product;
+  int interface_nr;
+
+  if (!dev->config)
+    {
+      if (verbose > 1)
+	printf ("device 0x%04x/0x%04x is not configured\n",
+		dev->descriptor.idVendor, dev->descriptor.idProduct);
+      return;
+    }
+
+  vendor = get_libusb_vendor (dev);
+  product = get_libusb_product (dev);
+
+  if (verbose > 2)
+    {
+      /* print everything we know about the device */
+      char *buf;
+      int config_nr;
+      struct usb_device_descriptor *d = &dev->descriptor;
+
+      printf ("\n");
+      printf ("<device descriptor of 0x%04x/0x%04x at %s:%s",
+	      d->idVendor, d->idProduct, dev->bus->dirname, dev->filename);
+      if (vendor || product)
+	{
+	  printf (" (%s%s%s)", vendor ? vendor : "",
+		  (vendor && product) ? " " : "", product ? product : "");
+	}
+      printf (">\n");
+      printf ("bLength               %d\n", d->bLength);
+      printf ("bDescriptorType       %d\n", d->bDescriptorType);
+      printf ("bcdUSB                %d.%d%d\n", d->bcdUSB >> 8,
+	      (d->bcdUSB >> 4) & 15, d->bcdUSB & 15);
+      printf ("bDeviceClass          %d\n", d->bDeviceClass);
+      printf ("bDeviceSubClass       %d\n", d->bDeviceSubClass);
+      printf ("bDeviceProtocol       %d\n", d->bDeviceProtocol);
+      printf ("bMaxPacketSize0       %d\n", d->bMaxPacketSize0);
+      printf ("idVendor              0x%04X\n", d->idVendor);
+      printf ("idProduct             0x%04X\n", d->idProduct);
+      printf ("bcdDevice             %d.%d%d\n", d->bcdDevice >> 8,
+	      (d->bcdDevice >> 4) & 15, d->bcdDevice & 15);
+      printf ("iManufacturer         %d (%s)\n", d->iManufacturer,
+	      (vendor) ? vendor : "");
+      printf ("iProduct              %d (%s)\n", d->iProduct,
+	      (product) ? product : "");
+
+      buf = get_libusb_string_descriptor (dev, d->iSerialNumber);
+      printf ("iSerialNumber         %d (%s)\n", d->iSerialNumber,
+	      (buf) ? buf : "");
+      if (buf)
+	free (buf);
+      printf ("bNumConfigurations    %d\n", d->bNumConfigurations);
+
+      for (config_nr = 0; config_nr < d->bNumConfigurations; config_nr++)
+	{
+	  struct usb_config_descriptor *c = &dev->config[config_nr];
+	  int interface_nr;
+
+	  printf (" <configuration %d>\n", config_nr);
+	  printf (" bLength              %d\n", c->bLength);
+	  printf (" bDescriptorType      %d\n", c->bDescriptorType);
+	  printf (" wTotalLength         %d\n", c->wTotalLength);
+	  printf (" bNumInterfaces       %d\n", c->bNumInterfaces);
+	  printf (" bConfigurationValue  %d\n", c->bConfigurationValue);
+	  buf = get_libusb_string_descriptor (dev, c->iConfiguration);
+	  printf (" iConfiguration       %d (%s)\n", c->iConfiguration,
+		  (buf) ? buf : "");
+	  if (buf)
+	    free (buf);
+	  printf (" bmAttributes         %d (%s%s)\n", c->bmAttributes,
+		  c->bmAttributes & 64 ? "Self-powered" : "",
+		  c->bmAttributes & 32 ? "Remote Wakeup" : "");
+	  printf (" MaxPower             %d mA\n", c->MaxPower * 2);
+
+	  for (interface_nr = 0; interface_nr < c->bNumInterfaces;
+	       interface_nr++)
+	    {
+	      struct usb_interface *interface = &c->interface[interface_nr];
+	      int alt_setting_nr;
+
+	      printf ("  <interface %d>\n", interface_nr);
+	      for (alt_setting_nr = 0;
+		   alt_setting_nr < interface->num_altsetting;
+		   alt_setting_nr++)
+		{
+		  struct usb_interface_descriptor *i
+		    = &interface->altsetting[alt_setting_nr];
+		  int ep_nr;
+		  printf ("   <altsetting %d>\n", alt_setting_nr);
+		  printf ("   bLength            %d\n", i->bLength);
+		  printf ("   bDescriptorType    %d\n", i->bDescriptorType);
+		  printf ("   bInterfaceNumber   %d\n", i->bInterfaceNumber);
+		  printf ("   bAlternateSetting  %d\n", i->bAlternateSetting);
+		  printf ("   bNumEndpoints      %d\n", i->bNumEndpoints);
+		  printf ("   bInterfaceClass    %d\n", i->bInterfaceClass);
+		  printf ("   bInterfaceSubClass %d\n",
+			  i->bInterfaceSubClass);
+		  printf ("   bInterfaceProtocol %d\n",
+			  i->bInterfaceProtocol);
+		  buf = get_libusb_string_descriptor (dev, i->iInterface);
+		  printf ("   iInterface         %d (%s)\n", i->iInterface,
+			  (buf) ? buf : "");
+		  if (buf)
+		    free (buf);
+
+		  for (ep_nr = 0; ep_nr < i->bNumEndpoints; ep_nr++)
+		    {
+		      struct usb_endpoint_descriptor *e = &i->endpoint[ep_nr];
+		      char *ep_type;
+
+		      switch (e->bmAttributes & USB_ENDPOINT_TYPE_MASK)
+			{
+			case USB_ENDPOINT_TYPE_CONTROL:
+			  ep_type = "control";
+			  break;
+			case USB_ENDPOINT_TYPE_ISOCHRONOUS:
+			  ep_type = "isochronous";
+			  break;
+			case USB_ENDPOINT_TYPE_BULK:
+			  ep_type = "bulk";
+			  break;
+			case USB_ENDPOINT_TYPE_INTERRUPT:
+			  ep_type = "interrupt";
+			  break;
+			default:
+			  ep_type = "unknown";
+			  break;
+			}
+		      printf ("    <endpoint %d>\n", ep_nr);
+		      printf ("    bLength           %d\n", e->bLength);
+		      printf ("    bDescriptorType   %d\n",
+			      e->bDescriptorType);
+		      printf ("    bEndpointAddress  0x%02X (%s 0x%02X)\n",
+			      e->bEndpointAddress,
+			      e->bEndpointAddress & USB_ENDPOINT_DIR_MASK ?
+			      "in" : "out",
+			      e->
+			      bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK);
+		      printf ("    bmAttributes      %d (%s)\n",
+			      e->bmAttributes, ep_type);
+		      printf ("    wMaxPacketSize    %d\n",
+			      e->wMaxPacketSize);
+		      printf ("    bInterval         %d ms\n", e->bInterval);
+		      printf ("    bRefresh          %d\n", e->bRefresh);
+		      printf ("    bSynchAddress     %d\n", e->bSynchAddress);
+		    }
+		}
+	    }
+	}
+
+    }
+
+  /* Some heuristics, which device may be a scanner */
+  if (dev->descriptor.idVendor == 0)	/* hub */
+    --is_scanner;
+  if (dev->descriptor.idProduct == 0)	/* hub */
+    --is_scanner;
+
+  for (interface_nr = 0; interface_nr < dev->config[0].bNumInterfaces && is_scanner <= 0; interface_nr++)
+    {
+      switch (dev->descriptor.bDeviceClass)
+	{
+	case USB_CLASS_VENDOR_SPEC:
+	  ++is_scanner;
+	  break;
+	case USB_CLASS_PER_INTERFACE:
+	  if (dev->config[0].interface[interface_nr].num_altsetting == 0 ||
+	      !dev->config[0].interface[interface_nr].altsetting)
+	    break;
+	  switch (dev->config[0].interface[interface_nr].altsetting[0].bInterfaceClass)
+	    {
+	    case USB_CLASS_VENDOR_SPEC:
+	    case USB_CLASS_PER_INTERFACE:
+	    case 16:                /* data? */
+	      ++is_scanner;
+	      break;
+	    }
+	  break;
+	}
+    }
+
+  if (is_scanner > 0)
+    {
+      char * chipset = check_usb_chip (dev, verbose, from_file);
+
+      printf ("found USB scanner (vendor=0x%04x", dev->descriptor.idVendor);
+      if (vendor)
+	printf (" [%s]", vendor);
+      printf (", product=0x%04x", dev->descriptor.idProduct);
+      if (product)
+	printf (" [%s]", product);
+      if (chipset)
+	printf (", chip=%s", chipset);
+      if (from_file)
+	printf (")\n");
+      else
+	printf (") at libusb:%s:%s\n", dev->bus->dirname, dev->filename);
+
+      libusb_device_found = SANE_TRUE;
+      device_found = SANE_TRUE;
+    }
+
+  if (vendor)
+    free (vendor);
+
+  if (product)
+    free (product);
+}
+#endif /* HAVE_LIBUSB_LEGACY */
+
+
+#ifdef HAVE_LIBUSB
+static char *
+sfs_libusb_strerror (int errcode)
+{
+  /* Error codes & descriptions from the libusb-1.0 documentation */
+
+  switch (errcode)
+    {
+      case LIBUSB_SUCCESS:
+	return "Success (no error)";
+
+      case LIBUSB_ERROR_IO:
+	return "Input/output error";
+
+      case LIBUSB_ERROR_INVALID_PARAM:
+	return "Invalid parameter";
+
+      case LIBUSB_ERROR_ACCESS:
+	return "Access denied (insufficient permissions)";
+
+      case LIBUSB_ERROR_NO_DEVICE:
+	return "No such device (it may have been disconnected)";
+
+      case LIBUSB_ERROR_NOT_FOUND:
+	return "Entity not found";
+
+      case LIBUSB_ERROR_BUSY:
+	return "Resource busy";
+
+      case LIBUSB_ERROR_TIMEOUT:
+	return "Operation timed out";
+
+      case LIBUSB_ERROR_OVERFLOW:
+	return "Overflow";
+
+      case LIBUSB_ERROR_PIPE:
+	return "Pipe error";
+
+      case LIBUSB_ERROR_INTERRUPTED:
+	return "System call interrupted (perhaps due to signal)";
+
+      case LIBUSB_ERROR_NO_MEM:
+	return "Insufficient memory";
+
+      case LIBUSB_ERROR_NOT_SUPPORTED:
+	return "Operation not supported or unimplemented on this platform";
+
+      case LIBUSB_ERROR_OTHER:
+	return "Other error";
+
+      default:
+	return "Unknown libusb-1.0 error code";
+    }
+}
+
+static char *
+get_libusb_string_descriptor (libusb_device_handle *hdl, int index)
+{
+  unsigned char *buffer, short_buffer[2];
+  int size;
+  int ret;
+  int i;
+
+  if (!index)
+    return NULL;
+
+  ret = libusb_get_descriptor (hdl, LIBUSB_DT_STRING, index,
+			       short_buffer, sizeof (short_buffer));
+  if (ret < 0)
+    {
+      printf ("could not fetch string descriptor: %s\n",
+	      sfs_libusb_strerror (ret));
+      return NULL;
+    }
+
+  if ((short_buffer[0] < 2) /* descriptor length */
+      || (short_buffer[1] != LIBUSB_DT_STRING)) /* descriptor type */
+    return NULL;
+
+  size = short_buffer[0];
+
+  buffer = calloc (1, size + 1);
+  if (!buffer)
+    return NULL;
+
+  ret = libusb_get_descriptor (hdl, LIBUSB_DT_STRING, index,
+			       buffer, size);
+  if (ret < 0)
+    {
+      printf ("could not fetch string descriptor (again): %s\n",
+	      sfs_libusb_strerror (ret));
+      free (buffer);
+      return NULL;
+    }
+
+  if ((buffer[0] < 2) || (buffer[0] > size) /* descriptor length */
+      || (buffer[1] != LIBUSB_DT_STRING)) /* descriptor type */
+    {
+      free (buffer);
+      return NULL;
+    }
+
+  size = buffer[0] - 2;
+  for (i = 0; i < (size / 2); i++)
+    buffer[i] = buffer[2 + 2 * i];
+  buffer[i] = '\0';
+
+  return (char *) buffer;
+}
+
+static void
+check_libusb_device (libusb_device *dev, SANE_Bool from_file)
+{
+  libusb_device_handle *hdl;
+  struct libusb_device_descriptor desc;
+  struct libusb_config_descriptor *config0;
+
+  int is_scanner = 0;
+  char *vendor;
+  char *product;
+  unsigned short vid, pid;
+  unsigned char busno, address;
+  int config;
+  int intf;
+  int ret;
+
+  busno = libusb_get_bus_number (dev);
+  address = libusb_get_device_address (dev);
+
+  ret = libusb_get_device_descriptor (dev, &desc);
+  if (ret < 0)
+    {
+      printf ("could not get device descriptor for device at %03d:%03d: %s\n",
+	      busno, address, sfs_libusb_strerror (ret));
+      return;
+    }
+
+  vid = desc.idVendor;
+  pid = desc.idProduct;
+
+  ret = libusb_open (dev, &hdl);
+  if (ret < 0)
+    {
+      printf ("could not open USB device 0x%04x/0x%04x at %03d:%03d: %s\n",
+	      vid, pid, busno, address, sfs_libusb_strerror (ret));
+      return;
+    }
+
+  ret = libusb_get_configuration (hdl, &config);
+  if (ret < 0)
+    {
+      printf ("could not get configuration for device 0x%04x/0x%04x at %03d:%03d: %s\n",
+	      vid, pid, busno, address, sfs_libusb_strerror (ret));
+      libusb_close (hdl);
+      return;
+    }
+
+  if (config == 0)
+    {
+      if (verbose > 1)
+	printf ("device 0x%04x/0x%04x at %03d:%03d is not configured\n",
+		vid, pid, busno, address);
+      libusb_close (hdl);
+      return;
+    }
+
+  vendor = get_libusb_string_descriptor (hdl, desc.iManufacturer);
+  product = get_libusb_string_descriptor (hdl, desc.iProduct);
+
+  if (verbose > 2)
+    {
+      /* print everything we know about the device */
+      char *buf;
+      int config_nr;
+
+      printf ("\n");
+      printf ("<device descriptor of 0x%04x/0x%04x at %03d:%03d",
+	      vid, pid, busno, address);
+      if (vendor || product)
+	{
+	  printf (" (%s%s%s)", (vendor) ? vendor : "",
+		  (vendor && product) ? " " : "", (product) ? product : "");
+	}
+      printf (">\n");
+      printf ("bLength               %d\n", desc.bLength);
+      printf ("bDescriptorType       %d\n", desc.bDescriptorType);
+      printf ("bcdUSB                %d.%d%d\n", desc.bcdUSB >> 8,
+	      (desc.bcdUSB >> 4) & 15, desc.bcdUSB & 15);
+      printf ("bDeviceClass          %d\n", desc.bDeviceClass);
+      printf ("bDeviceSubClass       %d\n", desc.bDeviceSubClass);
+      printf ("bDeviceProtocol       %d\n", desc.bDeviceProtocol);
+      printf ("bMaxPacketSize0       %d\n", desc.bMaxPacketSize0);
+      printf ("idVendor              0x%04X\n", desc.idVendor);
+      printf ("idProduct             0x%04X\n", desc.idProduct);
+      printf ("bcdDevice             %d.%d%d\n", desc.bcdDevice >> 8,
+	      (desc.bcdDevice >> 4) & 15, desc.bcdDevice & 15);
+      printf ("iManufacturer         %d (%s)\n", desc.iManufacturer,
+	      (vendor) ? vendor : "");
+      printf ("iProduct              %d (%s)\n", desc.iProduct,
+	      (product) ? product : "");
+      buf = get_libusb_string_descriptor (hdl, desc.iSerialNumber);
+      printf ("iSerialNumber         %d (%s)\n", desc.iSerialNumber,
+	      (buf) ? buf : "");
+      if (buf)
+	free (buf);
+      printf ("bNumConfigurations    %d\n", desc.bNumConfigurations);
+
+      for (config_nr = 0; config_nr < desc.bNumConfigurations; config_nr++)
+	{
+	  struct libusb_config_descriptor *c;
+
+	  ret = libusb_get_config_descriptor (dev, config_nr, &c);
+	  if (ret < 0)
+	    {
+	      printf ("could not get configuration descriptor %d: %s\n",
+		      config_nr, sfs_libusb_strerror (ret));
+	      continue;
+	    }
+
+	  printf (" <configuration %d>\n", config_nr);
+	  printf (" bLength              %d\n", c->bLength);
+	  printf (" bDescriptorType      %d\n", c->bDescriptorType);
+	  printf (" wTotalLength         %d\n", c->wTotalLength);
+	  printf (" bNumInterfaces       %d\n", c->bNumInterfaces);
+	  printf (" bConfigurationValue  %d\n", c->bConfigurationValue);
+
+	  buf = get_libusb_string_descriptor (hdl, c->iConfiguration);
+	  printf (" iConfiguration       %d (%s)\n", c->iConfiguration,
+		  (buf) ? buf : "");
+	  free (buf);
+
+	  printf (" bmAttributes         %d (%s%s)\n", c->bmAttributes,
+		  c->bmAttributes & 64 ? "Self-powered" : "",
+		  c->bmAttributes & 32 ? "Remote Wakeup" : "");
+	  printf (" MaxPower             %d mA\n", c->MaxPower * 2);
+
+	  for (intf = 0; intf < c->bNumInterfaces; intf++)
+	    {
+	      const struct libusb_interface *interface;
+	      int alt_setting_nr;
+
+	      interface = &c->interface[intf];
+
+	      printf ("  <interface %d>\n", intf);
+	      for (alt_setting_nr = 0;
+		   alt_setting_nr < interface->num_altsetting;
+		   alt_setting_nr++)
+		{
+		  const struct libusb_interface_descriptor *i;
+		  int ep_nr;
+
+		  i = &interface->altsetting[alt_setting_nr];
+
+		  printf ("   <altsetting %d>\n", alt_setting_nr);
+		  printf ("   bLength            %d\n", i->bLength);
+		  printf ("   bDescriptorType    %d\n", i->bDescriptorType);
+		  printf ("   bInterfaceNumber   %d\n", i->bInterfaceNumber);
+		  printf ("   bAlternateSetting  %d\n", i->bAlternateSetting);
+		  printf ("   bNumEndpoints      %d\n", i->bNumEndpoints);
+		  printf ("   bInterfaceClass    %d\n", i->bInterfaceClass);
+		  printf ("   bInterfaceSubClass %d\n",
+			  i->bInterfaceSubClass);
+		  printf ("   bInterfaceProtocol %d\n",
+			  i->bInterfaceProtocol);
+
+		  buf = NULL;
+		  buf = get_libusb_string_descriptor (hdl, i->iInterface);
+		  printf ("   iInterface         %d (%s)\n", i->iInterface,
+			  (buf) ? buf : "");
+		  free (buf);
+		  for (ep_nr = 0; ep_nr < i->bNumEndpoints; ep_nr++)
+		    {
+		      const struct libusb_endpoint_descriptor *e;
+		      char *ep_type;
+
+		      e = &i->endpoint[ep_nr];
+
+		      switch (e->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK)
+			{
+			  case LIBUSB_TRANSFER_TYPE_CONTROL:
+			    ep_type = "control";
+			    break;
+			  case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
+			    ep_type = "isochronous";
+			    break;
+			  case LIBUSB_TRANSFER_TYPE_BULK:
+			    ep_type = "bulk";
+			    break;
+			  case LIBUSB_TRANSFER_TYPE_INTERRUPT:
+			    ep_type = "interrupt";
+			    break;
+			  default:
+			    ep_type = "unknown";
+			    break;
+			}
+		      printf ("    <endpoint %d>\n", ep_nr);
+		      printf ("    bLength           %d\n", e->bLength);
+		      printf ("    bDescriptorType   %d\n",
+			      e->bDescriptorType);
+		      printf ("    bEndpointAddress  0x%02X (%s 0x%02X)\n",
+			      e->bEndpointAddress,
+			      e->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK ?
+			      "in" : "out",
+			      e->
+			      bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK);
+		      printf ("    bmAttributes      %d (%s)\n",
+			      e->bmAttributes, ep_type);
+		      printf ("    wMaxPacketSize    %d\n",
+			      e->wMaxPacketSize);
+		      printf ("    bInterval         %d ms\n", e->bInterval);
+		      printf ("    bRefresh          %d\n", e->bRefresh);
+		      printf ("    bSynchAddress     %d\n", e->bSynchAddress);
+		    }
+		}
+	    }
+	}
+    }
+
+
+  /* Some heuristics, which device may be a scanner */
+  if (desc.idVendor == 0)	/* hub */
+    --is_scanner;
+  if (desc.idProduct == 0)	/* hub */
+    --is_scanner;
+
+  ret = libusb_get_config_descriptor (dev, 0, &config0);
+  if (ret < 0)
+    {
+      printf ("could not get config[0] descriptor: %s\n",
+	      sfs_libusb_strerror (ret));
+
+      goto out_free;
+    }
+
+  for (intf = 0; (intf < config0->bNumInterfaces) && (is_scanner <= 0); intf++)
+    {
+      switch (desc.bDeviceClass)
+	{
+	  case USB_CLASS_VENDOR_SPEC:
+	    ++is_scanner;
+	    break;
+	  case USB_CLASS_PER_INTERFACE:
+	    if ((config0->interface[intf].num_altsetting == 0)
+		|| !config0->interface[intf].altsetting)
+	      break;
+	    switch (config0->interface[intf].altsetting[0].bInterfaceClass)
+	      {
+	        case USB_CLASS_VENDOR_SPEC:
+	        case USB_CLASS_PER_INTERFACE:
+	        case 16:                /* data? */
+		  ++is_scanner;
+		  break;
+	      }
+	    break;
+	}
+    }
+
+  if (is_scanner > 0)
+    {
+      char *chipset = NULL;
+
+      if(!from_file)
+        chipset = check_usb_chip (verbose, desc, hdl, config0);
+
+      printf ("found USB scanner (vendor=0x%04x", vid);
+      if (vendor)
+	printf (" [%s]", vendor);
+      printf (", product=0x%04x", pid);
+      if (product)
+	printf (" [%s]", product);
+      if (chipset)
+	printf (", chip=%s", chipset);
+      if (from_file)
+	printf (")\n");
+      else
+	printf (") at libusb:%03d:%03d\n", busno, address);
+
+      libusb_device_found = SANE_TRUE;
+      device_found = SANE_TRUE;
+    }
+
+  libusb_free_config_descriptor (config0);
+
+ out_free:
+  libusb_close (hdl);
+  if (vendor)
+    free (vendor);
+
+  if (product)
+    free (product);
+}
+#endif /* HAVE_LIBUSB */
+
+
+static DIR *
+scan_directory (char *dir_name)
+{
+  struct stat stat_buf;
+  DIR *dir;
+
+  if (verbose > 2)
+    printf ("scanning directory %s\n", dir_name);
+
+  if (stat (dir_name, &stat_buf) < 0)
+    {
+      if (verbose > 1)
+	printf ("cannot stat `%s' (%s)\n", dir_name, strerror (errno));
+      return 0;
+    }
+  if (!S_ISDIR (stat_buf.st_mode))
+    {
+      if (verbose > 1)
+	printf ("`%s' is not a directory\n", dir_name);
+      return 0;
+    }
+  if ((dir = opendir (dir_name)) == 0)
+    {
+      if (verbose > 1)
+	printf ("cannot read directory `%s' (%s)\n", dir_name,
+		strerror (errno));
+      return 0;
+    }
+  return dir;
+}
+
+static char *
+get_next_file (char *dir_name, DIR * dir)
+{
+  struct dirent *dir_entry;
+  static char file_name[PATH_MAX];
+
+  do
+    {
+      dir_entry = readdir (dir);
+      if (!dir_entry)
+	return 0;
+    }
+  while (strcmp (dir_entry->d_name, ".") == 0
+	 || strcmp (dir_entry->d_name, "..") == 0);
+
+  if (strlen (dir_name) + strlen (dir_entry->d_name) + 1 > PATH_MAX)
+    {
+      if (verbose > 1)
+	printf ("filename too long\n");
+      return 0;
+    }
+  sprintf (file_name, "%s%s", dir_name, dir_entry->d_name);
+  return file_name;
+}
+
+#if defined(WIN32_SCSI)
+/* Return a list of potential scanners. There's a lot of hardcoded values here that might break on a system with lots of scsi devices. */
+static char **build_scsi_dev_list(void)
+{
+	char **dev_list;
+	int dev_list_index;
+	int hca;
+	HANDLE fd;
+	char scsi_hca_name[20];
+	char buffer[4096];
+	DWORD BytesReturned;
+	BOOL ret;
+	size_t dev_list_size;
+	PSCSI_ADAPTER_BUS_INFO adapter;
+	PSCSI_INQUIRY_DATA inquiry;
+	int i;
+
+	/* Allocate room for about 100 scanners. That should be enough. */
+	dev_list_size = 100;
+	dev_list_index = 0;
+	dev_list = calloc(1, dev_list_size * sizeof(char *));
+
+	hca = 0;
+
+	for(hca = 0; ; hca++) {
+
+		/* Open the adapter */
+		snprintf(scsi_hca_name, 20, "\\\\.\\Scsi%d:", hca);
+		fd = CreateFile(scsi_hca_name, GENERIC_READ | GENERIC_WRITE,
+						FILE_SHARE_READ | FILE_SHARE_WRITE,
+						NULL, OPEN_EXISTING,
+						FILE_FLAG_RANDOM_ACCESS, NULL );
+
+		if (fd == INVALID_HANDLE_VALUE) {
+			/* Assume there is no more adapter. This is wrong in the case
+			 * of hot-plug stuff, but I have yet to see it on a user
+			 * machine. */
+			break;
+		}
+
+		/* Get the inquiry info for the devices on that hca. */
+        ret = DeviceIoControl(fd,
+							  IOCTL_SCSI_GET_INQUIRY_DATA,
+							  NULL,
+							  0,
+							  buffer,
+							  sizeof(buffer),
+							  &BytesReturned,
+							  FALSE);
+
+        if(ret == 0)
+			{
+				CloseHandle(fd);
+				continue;
+			}
+
+		adapter = (PSCSI_ADAPTER_BUS_INFO)buffer;
+
+		for(i = 0; i < adapter->NumberOfBuses; i++) {
+
+			if (adapter->BusData[i].InquiryDataOffset == 0) {
+				/* No device here */
+				continue;
+			}
+
+			inquiry = (PSCSI_INQUIRY_DATA) (buffer +
+											adapter->BusData[i].InquiryDataOffset);
+			while(1) {
+				/* Check if it is a scanner or a processor
+				 * device. Ignore the other
+				 * device types. */
+				if (inquiry->InquiryDataLength >= 5 &&
+					((inquiry->InquiryData[0] & 0x1f) == 3 ||
+					 (inquiry->InquiryData[0] & 0x1f) == 6)) {
+					char device_name[20];
+					sprintf(device_name, "h%db%dt%dl%d", hca, inquiry->PathId, inquiry->TargetId, inquiry->Lun);
+					dev_list[dev_list_index] = strdup(device_name);
+					dev_list_index++;
+				}
+
+				if (inquiry->NextInquiryDataOffset == 0) {
+					/* No device here */
+					break;
+				} else {
+					inquiry =  (PSCSI_INQUIRY_DATA) (buffer +
+													 inquiry->NextInquiryDataOffset);
+				}
+			}
+	    }
+
+		CloseHandle(fd);
+
+	}
+
+	return dev_list;
+
+}
+#endif
+
+#if defined (HAVE_IOKIT_CDB_IOSCSILIB_H) || \
+    defined (HAVE_IOKIT_SCSI_SCSICOMMANDOPERATIONCODES_H) || \
+    defined (HAVE_IOKIT_SCSI_COMMANDS_SCSICOMMANDOPERATIONCODES_H)
+char **scsi_dev_list;
+int scsi_dev_list_index;
+
+static SANE_Status AddToSCSIDeviceList (const char *dev) {
+  if (scsi_dev_list_index < 99) {
+    scsi_dev_list [scsi_dev_list_index] = strdup (dev);
+    scsi_dev_list_index++;
+    return SANE_STATUS_GOOD;
+  }
+  else
+    return SANE_STATUS_NO_MEM;
+}
+
+static char **build_scsi_dev_list(void)
+{
+  scsi_dev_list_index = 0;
+  scsi_dev_list = malloc (100 * sizeof(char *));
+  sanei_scsi_find_devices (NULL, NULL, NULL, -1, -1, -1, -1,
+			   AddToSCSIDeviceList);
+  scsi_dev_list [scsi_dev_list_index] = NULL;
+  return scsi_dev_list;
+}
+#endif
+
+static int
+check_mustek_pp_device (void)
+{
+  const char **devices;
+  int ctr = 0, found = 0, scsi = 0;
+
+  if (verbose > 1)
+    printf ("searching for Mustek parallel port scanners:\n");
+
+  devices = sanei_pa4s2_devices ();
+
+  while (devices[ctr] != NULL) {
+    int fd;
+    SANE_Status result;
+
+    /* ordinary parallel port scanner type */
+    if (verbose > 1)
+      printf ("checking %s...", devices[ctr]);
+
+    result = sanei_pa4s2_open (devices[ctr], &fd);
+
+    if (verbose > 1)
+      {
+        if (result != 0)
+  	  printf (" failed to open (%s)\n", sane_strstatus (result));
+        else
+	  printf (" open ok\n");
+      }
+
+    if (result == 0) {
+      printf ("found possible Mustek parallel port scanner at \"%s\"\n",
+              devices[ctr]);
+      found++;
+      sanei_pa4s2_close(fd);
+    }
+
+    /* trying scsi over pp devices */
+    if (verbose > 1)
+      printf ("checking %s (SCSI emulation)...", devices[ctr]);
+
+    result = sanei_pa4s2_scsi_pp_open (devices[ctr], &fd);
+
+    if (verbose > 1)
+      {
+        if (result != 0)
+  	  printf (" failed to open (%s)\n", sane_strstatus (result));
+        else
+	  printf (" open ok\n");
+      }
+
+    if (result == 0) {
+      printf ("found possible Mustek SCSI over PP scanner at \"%s\"\n",
+              devices[ctr]);
+      scsi++;
+      sanei_pa4s2_close(fd);
+    }
+
+    ctr++;
+  }
+
+  free(devices);
+
+  if (found > 0 && verbose > 0)
+    printf("\n  # Your Mustek parallel port scanner was detected.  It may or\n"
+           "  # may not be supported by SANE.  Please read the sane-mustek_pp\n"
+	   "  # man-page for setup instructions.\n");
+
+  if (scsi > 0 && verbose > 0)
+    printf("\n  # Your Mustek parallel port scanner was detected.  It may or\n"
+           "  # may not be supported by SANE.  Please read the sane-mustek_pp\n"
+	   "  # man-page for setup instructions.\n");
+
+  return (found > 0 || scsi > 0);
+}
+
+#ifdef HAVE_LIBUSB_LEGACY
+static SANE_Bool
+parse_num (char* search, const char* line, int base, long int * number)
+{
+  char* start_number;
+
+  start_number = strstr (line, search);
+  if (start_number == NULL)
+    return SANE_FALSE;
+  start_number += strlen (search);
+
+  *number = strtol (start_number, NULL, base);
+  if (verbose > 2)
+    printf ("Found %s%ld\n", search, *number);
+  return SANE_TRUE;
+}
+
+static SANE_Bool
+parse_bcd (char* search, const char* line, long int * number)
+{
+  char* start_number;
+  char* end_number;
+  int first_part;
+  int second_part;
+
+  start_number = strstr (line, search);
+  if (start_number == NULL)
+    return SANE_FALSE;
+  start_number += strlen (search);
+
+  first_part = strtol (start_number, &end_number, 10);
+  start_number = end_number + 1; /* skip colon */
+  second_part = strtol (start_number, NULL, 10);
+  *number = ((first_part / 10) << 12) + ((first_part % 10) << 8)
+    + ((second_part / 10) << 4) + (second_part % 10);
+  if (verbose > 2)
+    printf ("Found %s%ld\n", search, *number);
+  return SANE_TRUE;
+}
+
+static void
+parse_file (char *filename)
+{
+  FILE * parsefile;
+  char line [PATH_MAX], *token;
+  const char * p;
+  struct usb_device *dev = 0;
+  long int number = 0;
+  int current_config = 1;
+  int current_if = -1;
+  int current_as = -1;
+  int current_ep = -1;
+
+  if (verbose > 1)
+    printf ("trying to open %s\n", filename);
+  parsefile = fopen (filename, "r");
+
+  if (parsefile == NULL)
+    {
+      if (verbose > 0)
+	printf ("opening %s failed: %s\n", filename, strerror (errno));
+      return;
+    }
+
+  while (sanei_config_read (line, PATH_MAX, parsefile))
+    {
+      if (verbose > 2)
+	printf ("parsing line: `%s'\n", line);
+      p = sanei_config_get_string (line, &token);
+      if (!token || !p || token[0] == '\0')
+	continue;
+      if (token[1] != ':')
+	{
+	  if (verbose > 2)
+	    printf ("missing `:'?\n");
+	  continue;
+	}
+      switch (token[0])
+	{
+	case 'T':
+	  if (dev)
+	    check_libusb_device (dev, SANE_TRUE);
+	  dev = calloc (1, sizeof (struct usb_device));
+	  dev->bus = calloc (1, sizeof (struct usb_bus));
+	  current_config = 1;
+	  current_if = -1;
+	  current_as = -1;
+	  current_ep = -1;
+	  break;
+	case 'D':
+	  if (parse_bcd ("Ver=", line, &number))
+	    dev->descriptor.bcdUSB = number;
+	  if (parse_num ("Cls=", line, 16, &number))
+	    dev->descriptor.bDeviceClass = number;
+	  if (parse_num ("Sub=", line, 16, &number))
+	    dev->descriptor.bDeviceSubClass = number;
+	  if (parse_num ("Prot=", line, 16, &number))
+	    dev->descriptor.bDeviceProtocol = number;
+	  if (parse_num ("MxPS=", line, 10, &number))
+	    dev->descriptor.bMaxPacketSize0 = number;
+	  if (parse_num ("#Cfgs=", line, 10, &number))
+	    dev->descriptor.bNumConfigurations = number;
+	  dev->config = calloc (number, sizeof (struct usb_config_descriptor));
+	  break;
+	case 'P':
+	  if (parse_num ("Vendor=", line, 16, &number))
+	    dev->descriptor.idVendor = number;
+	  if (parse_num ("ProdID=", line, 16, &number))
+	    dev->descriptor.idProduct = number;
+	  if (parse_bcd ("Rev=", line, &number))
+	    dev->descriptor.bcdDevice = number;
+	  break;
+	case 'C':
+	  current_if = -1;
+	  current_as = -1;
+	  current_ep = -1;
+	  if (parse_num ("Cfg#=", line, 10, &number))
+	    {
+	      current_config = number - 1;
+	      dev->config[current_config].bConfigurationValue = number;
+	    }
+	  if (parse_num ("Ifs=", line, 10, &number))
+	    dev->config[current_config].bNumInterfaces = number;
+	  dev->config[current_config].interface
+	    = calloc (number, sizeof (struct usb_interface));
+	  if (parse_num ("Atr=", line, 16, &number))
+	    dev->config[current_config].bmAttributes = number;
+	  if (parse_num ("MxPwr=", line, 10, &number))
+	    dev->config[current_config].MaxPower = number / 2;
+	  break;
+	case 'I':
+	  current_ep = -1;
+	  if (parse_num ("If#=", line, 10, &number))
+	    {
+	      if (current_if != number)
+		{
+		  current_if = number;
+		  current_as = -1;
+		  dev->config[current_config].interface[current_if].altsetting
+		    = calloc (20, sizeof (struct usb_interface_descriptor));
+		  /* Can't read number of altsettings */
+		  dev->config[current_config].interface[current_if].num_altsetting = 1;
+		}
+	      else
+		dev->config[current_config].interface[current_if].num_altsetting++;
+	    }
+	  if (parse_num ("Alt=", line, 10, &number))
+	    {
+	      current_as = number;
+	      dev->config[current_config].interface[current_if].altsetting[current_as].bInterfaceNumber
+		= current_if;
+	      dev->config[current_config].interface[current_if].altsetting[current_as].bAlternateSetting
+		= current_as;
+	    }
+	  if (parse_num ("#EPs=", line, 10, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as].bNumEndpoints
+	      = number;
+	  dev->config[current_config].interface[current_if].altsetting[current_as].endpoint
+	    = calloc (number, sizeof (struct usb_endpoint_descriptor));
+	  if (parse_num ("Cls=", line, 16, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as].bInterfaceClass
+	      = number;
+	  if (parse_num ("Sub=", line, 16, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as].bInterfaceSubClass
+	      = number;
+	  if (parse_num ("Prot=", line, 16, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as].bInterfaceProtocol
+	      = number;
+	  break;
+	case 'E':
+	  current_ep++;
+	  if (parse_num ("Ad=", line, 16, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as]
+	      .endpoint[current_ep].bEndpointAddress = number;
+	  if (parse_num ("Atr=", line, 16, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as]
+	      .endpoint[current_ep].bmAttributes = number;
+	  if (parse_num ("MxPS=", line, 10, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as]
+	      .endpoint[current_ep].wMaxPacketSize = number;
+	  if (parse_num ("Ivl=", line, 10, &number))
+	    dev->config[current_config].interface[current_if].altsetting[current_as]
+	      .endpoint[current_ep].bInterval = number;
+	  break;
+	case 'S':
+	case 'B':
+	  continue;
+	default:
+	  if (verbose > 1)
+	    printf ("ignoring unknown line identifier: %c\n", token[0]);
+	  continue;
+	}
+      free (token);
+    }
+  if (dev)
+    check_libusb_device (dev, SANE_TRUE);
+  fclose (parsefile);
+  return;
+}
+#endif
+
+int
+main (int argc, char **argv)
+{
+  char **dev_list, **usb_dev_list, *dev_name, **ap;
+  int enable_pp_checks = SANE_FALSE;
+
+  prog_name = strrchr (argv[0], '/');
+  if (prog_name)
+    ++prog_name;
+  else
+    prog_name = argv[0];
+
+  for (ap = argv + 1; ap < argv + argc; ++ap)
+    {
+      if ((*ap)[0] != '-')
+	break;
+      switch ((*ap)[1])
+	{
+	case '?':
+	case 'h':
+	  usage (0);
+	  exit (0);
+
+	case 'v':
+	  ++verbose;
+	  break;
+
+	case 'q':
+	  --verbose;
+	  break;
+
+	case 'f':
+	  force = SANE_TRUE;
+	  break;
+
+	case 'p':
+	  enable_pp_checks = SANE_TRUE;
+	  break;
+
+	case 'F':
+#ifdef HAVE_LIBUSB_LEGACY
+	  parse_file ((char *) (*(++ap)));
+#elif defined(HAVE_LIBUSB)
+	  printf ("option -F not implemented with libusb-1.0\n");
+#else
+	  printf ("libusb not available: option -F can't be used\n");
+#endif
+	  exit (0);
+
+	case '-':
+	  if (!strcmp((*ap), "--help"))
+	    {
+	      usage (0);
+	      exit (0);
+	    }
+          // fall through
+	default:
+	  printf ("unknown option: -%c, try -h for help\n", (*ap)[1]);
+	  exit (0);
+	}
+    }
+  if (ap < argv + argc)
+    {
+      dev_list = ap;
+      usb_dev_list = ap;
+    }
+  else
+    {
+      static char *default_dev_list[] = {
+#if defined(__sgi)
+	"/dev/scsi/sc0d1l0", "/dev/scsi/sc0d2l0",
+	"/dev/scsi/sc0d3l0", "/dev/scsi/sc0d4l0",
+	"/dev/scsi/sc0d5l0", "/dev/scsi/sc0d6l0",
+	"/dev/scsi/sc0d7l0", "/dev/scsi/sc0d8l0",
+	"/dev/scsi/sc0d9l0", "/dev/scsi/sc0d10l0",
+	"/dev/scsi/sc0d11l0", "/dev/scsi/sc0d12l0",
+	"/dev/scsi/sc0d13l0", "/dev/scsi/sc0d14l0",
+	"/dev/scsi/sc0d15l0",
+	"/dev/scsi/sc1d1l0", "/dev/scsi/sc1d2l0",
+	"/dev/scsi/sc1d3l0", "/dev/scsi/sc1d4l0",
+	"/dev/scsi/sc1d5l0", "/dev/scsi/sc1d6l0",
+	"/dev/scsi/sc1d7l0", "/dev/scsi/sc1d8l0",
+	"/dev/scsi/sc1d9l0", "/dev/scsi/sc1d10l0",
+	"/dev/scsi/sc1d11l0", "/dev/scsi/sc1d12l0",
+	"/dev/scsi/sc1d13l0", "/dev/scsi/sc1d14l0",
+	"/dev/scsi/sc1d15l0",
+	"/dev/scsi/sc2d1l0", "/dev/scsi/sc2d2l0",
+	"/dev/scsi/sc2d3l0", "/dev/scsi/sc2d4l0",
+	"/dev/scsi/sc2d5l0", "/dev/scsi/sc2d6l0",
+	"/dev/scsi/sc2d7l0", "/dev/scsi/sc2d8l0",
+	"/dev/scsi/sc2d9l0", "/dev/scsi/sc2d10l0",
+	"/dev/scsi/sc2d11l0", "/dev/scsi/sc2d12l0",
+	"/dev/scsi/sc2d13l0", "/dev/scsi/sc2d14l0",
+	"/dev/scsi/sc2d15l0",
+	"/dev/scsi/sc3d1l0", "/dev/scsi/sc3d2l0",
+	"/dev/scsi/sc3d3l0", "/dev/scsi/sc3d4l0",
+	"/dev/scsi/sc3d5l0", "/dev/scsi/sc3d6l0",
+	"/dev/scsi/sc3d7l0", "/dev/scsi/sc3d8l0",
+	"/dev/scsi/sc3d9l0", "/dev/scsi/sc3d10l0",
+	"/dev/scsi/sc3d11l0", "/dev/scsi/sc3d12l0",
+	"/dev/scsi/sc3d13l0", "/dev/scsi/sc3d14l0",
+	"/dev/scsi/sc3d15l0",
+	"/dev/scsi/sc4d1l0", "/dev/scsi/sc4d2l0",
+	"/dev/scsi/sc4d3l0", "/dev/scsi/sc4d4l0",
+	"/dev/scsi/sc4d5l0", "/dev/scsi/sc4d6l0",
+	"/dev/scsi/sc4d7l0", "/dev/scsi/sc4d8l0",
+	"/dev/scsi/sc4d9l0", "/dev/scsi/sc4d10l0",
+	"/dev/scsi/sc4d11l0", "/dev/scsi/sc4d12l0",
+	"/dev/scsi/sc4d13l0", "/dev/scsi/sc4d14l0",
+	"/dev/scsi/sc4d15l0",
+	"/dev/scsi/sc5d1l0", "/dev/scsi/sc5d2l0",
+	"/dev/scsi/sc5d3l0", "/dev/scsi/sc5d4l0",
+	"/dev/scsi/sc5d5l0", "/dev/scsi/sc5d6l0",
+	"/dev/scsi/sc5d7l0", "/dev/scsi/sc5d8l0",
+	"/dev/scsi/sc5d9l0", "/dev/scsi/sc5d10l0",
+	"/dev/scsi/sc5d11l0", "/dev/scsi/sc5d12l0",
+	"/dev/scsi/sc5d13l0", "/dev/scsi/sc5d14l0",
+	"/dev/scsi/sc5d15l0",
+	"/dev/scsi/sc6d1l0", "/dev/scsi/sc6d2l0",
+	"/dev/scsi/sc6d3l0", "/dev/scsi/sc6d4l0",
+	"/dev/scsi/sc6d5l0", "/dev/scsi/sc6d6l0",
+	"/dev/scsi/sc6d7l0", "/dev/scsi/sc6d8l0",
+	"/dev/scsi/sc6d9l0", "/dev/scsi/sc6d10l0",
+	"/dev/scsi/sc6d11l0", "/dev/scsi/sc6d12l0",
+	"/dev/scsi/sc6d13l0", "/dev/scsi/sc6d14l0",
+	"/dev/scsi/sc6d15l0",
+	"/dev/scsi/sc7d1l0", "/dev/scsi/sc7d2l0",
+	"/dev/scsi/sc7d3l0", "/dev/scsi/sc7d4l0",
+	"/dev/scsi/sc7d5l0", "/dev/scsi/sc7d6l0",
+	"/dev/scsi/sc7d7l0", "/dev/scsi/sc7d8l0",
+	"/dev/scsi/sc7d9l0", "/dev/scsi/sc7d10l0",
+	"/dev/scsi/sc7d11l0", "/dev/scsi/sc7d12l0",
+	"/dev/scsi/sc7d13l0", "/dev/scsi/sc7d14l0",
+	"/dev/scsi/sc7d15l0",
+	"/dev/scsi/sc8d1l0", "/dev/scsi/sc8d2l0",
+	"/dev/scsi/sc8d3l0", "/dev/scsi/sc8d4l0",
+	"/dev/scsi/sc8d5l0", "/dev/scsi/sc8d6l0",
+	"/dev/scsi/sc8d7l0", "/dev/scsi/sc8d8l0",
+	"/dev/scsi/sc8d9l0", "/dev/scsi/sc8d10l0",
+	"/dev/scsi/sc8d11l0", "/dev/scsi/sc8d12l0",
+	"/dev/scsi/sc8d13l0", "/dev/scsi/sc8d14l0",
+	"/dev/scsi/sc8d15l0",
+	"/dev/scsi/sc9d1l0", "/dev/scsi/sc9d2l0",
+	"/dev/scsi/sc9d3l0", "/dev/scsi/sc9d4l0",
+	"/dev/scsi/sc9d5l0", "/dev/scsi/sc9d6l0",
+	"/dev/scsi/sc9d7l0", "/dev/scsi/sc9d8l0",
+	"/dev/scsi/sc9d9l0", "/dev/scsi/sc9d10l0",
+	"/dev/scsi/sc9d11l0", "/dev/scsi/sc9d12l0",
+	"/dev/scsi/sc9d13l0", "/dev/scsi/sc9d14l0",
+	"/dev/scsi/sc9d15l0",
+	"/dev/scsi/sc10d1l0", "/dev/scsi/sc10d2l0",
+	"/dev/scsi/sc10d3l0", "/dev/scsi/sc10d4l0",
+	"/dev/scsi/sc10d5l0", "/dev/scsi/sc10d6l0",
+	"/dev/scsi/sc10d7l0", "/dev/scsi/sc10d8l0",
+	"/dev/scsi/sc10d9l0", "/dev/scsi/sc10d10l0",
+	"/dev/scsi/sc10d11l0", "/dev/scsi/sc10d12l0",
+	"/dev/scsi/sc10d13l0", "/dev/scsi/sc10d14l0",
+	"/dev/scsi/sc10d15l0",
+	"/dev/scsi/sc11d1l0", "/dev/scsi/sc11d2l0",
+	"/dev/scsi/sc11d3l0", "/dev/scsi/sc11d4l0",
+	"/dev/scsi/sc11d5l0", "/dev/scsi/sc11d6l0",
+	"/dev/scsi/sc11d7l0", "/dev/scsi/sc11d8l0",
+	"/dev/scsi/sc11d9l0", "/dev/scsi/sc11d10l0",
+	"/dev/scsi/sc11d11l0", "/dev/scsi/sc11d12l0",
+	"/dev/scsi/sc11d13l0", "/dev/scsi/sc11d14l0",
+	"/dev/scsi/sc11d15l0",
+	"/dev/scsi/sc12d1l0", "/dev/scsi/sc12d2l0",
+	"/dev/scsi/sc12d3l0", "/dev/scsi/sc12d4l0",
+	"/dev/scsi/sc12d5l0", "/dev/scsi/sc12d6l0",
+	"/dev/scsi/sc12d7l0", "/dev/scsi/sc12d8l0",
+	"/dev/scsi/sc12d9l0", "/dev/scsi/sc12d10l0",
+	"/dev/scsi/sc12d11l0", "/dev/scsi/sc12d12l0",
+	"/dev/scsi/sc12d13l0", "/dev/scsi/sc12d14l0",
+	"/dev/scsi/sc12d15l0",
+	"/dev/scsi/sc13d1l0", "/dev/scsi/sc13d2l0",
+	"/dev/scsi/sc13d3l0", "/dev/scsi/sc13d4l0",
+	"/dev/scsi/sc13d5l0", "/dev/scsi/sc13d6l0",
+	"/dev/scsi/sc13d7l0", "/dev/scsi/sc13d8l0",
+	"/dev/scsi/sc13d9l0", "/dev/scsi/sc13d10l0",
+	"/dev/scsi/sc13d11l0", "/dev/scsi/sc13d12l0",
+	"/dev/scsi/sc13d13l0", "/dev/scsi/sc13d14l0",
+	"/dev/scsi/sc13d15l0",
+	"/dev/scsi/sc14d1l0", "/dev/scsi/sc14d2l0",
+	"/dev/scsi/sc14d3l0", "/dev/scsi/sc14d4l0",
+	"/dev/scsi/sc14d5l0", "/dev/scsi/sc14d6l0",
+	"/dev/scsi/sc14d7l0", "/dev/scsi/sc14d8l0",
+	"/dev/scsi/sc14d9l0", "/dev/scsi/sc14d10l0",
+	"/dev/scsi/sc14d11l0", "/dev/scsi/sc14d12l0",
+	"/dev/scsi/sc14d13l0", "/dev/scsi/sc14d14l0",
+	"/dev/scsi/sc14d15l0",
+	"/dev/scsi/sc15d1l0", "/dev/scsi/sc15d2l0",
+	"/dev/scsi/sc15d3l0", "/dev/scsi/sc15d4l0",
+	"/dev/scsi/sc15d5l0", "/dev/scsi/sc15d6l0",
+	"/dev/scsi/sc15d7l0", "/dev/scsi/sc15d8l0",
+	"/dev/scsi/sc15d9l0", "/dev/scsi/sc15d10l0",
+	"/dev/scsi/sc15d11l0", "/dev/scsi/sc15d12l0",
+	"/dev/scsi/sc15d13l0", "/dev/scsi/sc15d14l0",
+	"/dev/scsi/sc15d15l0",
+#elif defined(__EMX__)
+	"b0t0l0", "b0t1l0", "b0t2l0", "b0t3l0",
+	"b0t4l0", "b0t5l0", "b0t6l0", "b0t7l0",
+	"b1t0l0", "b1t1l0", "b1t2l0", "b1t3l0",
+	"b1t4l0", "b1t5l0", "b1t6l0", "b1t7l0",
+	"b2t0l0", "b2t1l0", "b2t2l0", "b2t3l0",
+	"b2t4l0", "b2t5l0", "b2t6l0", "b2t7l0",
+	"b3t0l0", "b3t1l0", "b3t2l0", "b3t3l0",
+	"b3t4l0", "b3t5l0", "b3t6l0", "b3t7l0",
+#elif defined(__linux__)
+	"/dev/scanner",
+	"/dev/sg0", "/dev/sg1", "/dev/sg2", "/dev/sg3",
+	"/dev/sg4", "/dev/sg5", "/dev/sg6", "/dev/sg7",
+	"/dev/sg8", "/dev/sg9",
+	"/dev/sga", "/dev/sgb", "/dev/sgc", "/dev/sgd",
+	"/dev/sge", "/dev/sgf", "/dev/sgg", "/dev/sgh",
+	"/dev/sgi", "/dev/sgj", "/dev/sgk", "/dev/sgl",
+	"/dev/sgm", "/dev/sgn", "/dev/sgo", "/dev/sgp",
+	"/dev/sgq", "/dev/sgr", "/dev/sgs", "/dev/sgt",
+	"/dev/sgu", "/dev/sgv", "/dev/sgw", "/dev/sgx",
+	"/dev/sgy", "/dev/sgz",
+#elif defined(__NeXT__)
+	"/dev/sg0a", "/dev/sg0b", "/dev/sg0c", "/dev/sg0d",
+	"/dev/sg0e", "/dev/sg0f", "/dev/sg0g", "/dev/sg0h",
+	"/dev/sg1a", "/dev/sg1b", "/dev/sg1c", "/dev/sg1d",
+	"/dev/sg1e", "/dev/sg1f", "/dev/sg1g", "/dev/sg1h",
+	"/dev/sg2a", "/dev/sg2b", "/dev/sg2c", "/dev/sg2d",
+	"/dev/sg2e", "/dev/sg2f", "/dev/sg2g", "/dev/sg2h",
+	"/dev/sg3a", "/dev/sg3b", "/dev/sg3c", "/dev/sg3d",
+	"/dev/sg3e", "/dev/sg3f", "/dev/sg3g", "/dev/sg3h",
+#elif defined(_AIX)
+	"/dev/scanner",
+	"/dev/gsc0", "/dev/gsc1", "/dev/gsc2", "/dev/gsc3",
+	"/dev/gsc4", "/dev/gsc5", "/dev/gsc6", "/dev/gsc7",
+	"/dev/gsc8", "/dev/gsc9", "/dev/gsc10", "/dev/gsc11",
+	"/dev/gsc12", "/dev/gsc13", "/dev/gsc14", "/dev/gsc15",
+#elif defined(__sun)
+	"/dev/scg0a", "/dev/scg0b", "/dev/scg0c", "/dev/scg0d",
+	"/dev/scg0e", "/dev/scg0f", "/dev/scg0g",
+	"/dev/scg1a", "/dev/scg1b", "/dev/scg1c", "/dev/scg1d",
+	"/dev/scg1e", "/dev/scg1f", "/dev/scg1g",
+	"/dev/scg2a", "/dev/scg2b", "/dev/scg2c", "/dev/scg2d",
+	"/dev/scg2e", "/dev/scg2f", "/dev/scg2g",
+	"/dev/sg/0", "/dev/sg/1", "/dev/sg/2", "/dev/sg/3",
+	"/dev/sg/4", "/dev/sg/5", "/dev/sg/6",
+	"/dev/scsi/scanner/", "/dev/scsi/processor/",
+#elif defined(HAVE_CAMLIB_H)
+	"/dev/scanner", "/dev/scanner0", "/dev/scanner1",
+	"/dev/pass0", "/dev/pass1", "/dev/pass2", "/dev/pass3",
+	"/dev/pass4", "/dev/pass5", "/dev/pass6", "/dev/pass7",
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
+	"/dev/uk0", "/dev/uk1", "/dev/uk2", "/dev/uk3", "/dev/uk4",
+	"/dev/uk5", "/dev/uk6",
+#elif defined(__NetBSD__)
+	"/dev/uk0", "/dev/uk1", "/dev/uk2", "/dev/uk3", "/dev/uk4",
+	"/dev/uk5", "/dev/uk6",
+	"/dev/ss0",
+#elif defined(__OpenBSD__)
+	"/dev/uk0", "/dev/uk1", "/dev/uk2", "/dev/uk3", "/dev/uk4",
+	"/dev/uk5", "/dev/uk6",
+#elif defined(__hpux)
+	"/dev/rscsi/",
+#endif
+	0
+      };
+      static char *usb_default_dev_list[] = {
+#if defined(__linux__)
+	"/dev/usb/scanner",
+	"/dev/usb/scanner0", "/dev/usb/scanner1",
+	"/dev/usb/scanner2", "/dev/usb/scanner3",
+	"/dev/usb/scanner4", "/dev/usb/scanner5",
+	"/dev/usb/scanner5", "/dev/usb/scanner7",
+	"/dev/usb/scanner8", "/dev/usb/scanner9",
+	"/dev/usb/scanner10", "/dev/usb/scanner11",
+	"/dev/usb/scanner12", "/dev/usb/scanner13",
+	"/dev/usb/scanner14", "/dev/usb/scanner15",
+	"/dev/usbscanner",
+	"/dev/usbscanner0", "/dev/usbscanner1",
+	"/dev/usbscanner2", "/dev/usbscanner3",
+	"/dev/usbscanner4", "/dev/usbscanner5",
+	"/dev/usbscanner6", "/dev/usbscanner7",
+	"/dev/usbscanner8", "/dev/usbscanner9",
+	"/dev/usbscanner10", "/dev/usbscanner11",
+	"/dev/usbscanner12", "/dev/usbscanner13",
+	"/dev/usbscanner14", "/dev/usbscanner15",
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+	"/dev/uscanner",
+	"/dev/uscanner0", "/dev/uscanner1",
+	"/dev/uscanner2", "/dev/uscanner3",
+	"/dev/uscanner4", "/dev/uscanner5",
+	"/dev/uscanner6", "/dev/uscanner7",
+	"/dev/uscanner8", "/dev/uscanner9",
+	"/dev/uscanner10", "/dev/uscanner11",
+	"/dev/uscanner12", "/dev/uscanner13",
+	"/dev/uscanner14", "/dev/uscanner15",
+#endif
+	0
+      };
+
+#if defined (WIN32_SCSI) || \
+    defined (HAVE_IOKIT_CDB_IOSCSILIB_H) || \
+    defined (HAVE_IOKIT_SCSI_SCSICOMMANDOPERATIONCODES_H) || \
+    defined (HAVE_IOKIT_SCSI_COMMANDS_SCSICOMMANDOPERATIONCODES_H)
+   /* Build a list of valid of possible scanners found */
+      dev_list = build_scsi_dev_list();
+#else
+      dev_list = default_dev_list;
+#endif
+
+      usb_dev_list = usb_default_dev_list;
+    }
+  if (verbose > 1)
+    printf ("This is sane-find-scanner from %s\n", PACKAGE_STRING);
+
+  if (verbose > 0)
+    printf ("\n  # sane-find-scanner will now attempt to detect your scanner. If the"
+	    "\n  # result is different from what you expected, first make sure your"
+	    "\n  # scanner is powered up and properly connected to your computer.\n\n");
+
+  if (verbose > 1)
+    printf ("searching for SCSI scanners:\n");
+
+  while ((dev_name = *dev_list++))
+    {
+      if (strlen (dev_name) == 0)
+	continue;		/* Empty device names ... */
+
+      if (dev_name[strlen (dev_name) - 1] == '/')
+	{
+	  /* check whole directories */
+	  DIR *dir;
+	  char *file_name;
+
+	  dir = scan_directory (dev_name);
+	  if (!dir)
+	    continue;
+
+	  while ((file_name = get_next_file (dev_name, dir)))
+	    check_scsi_file (file_name);
+	}
+      else
+	{
+	  /* check device files */
+	  check_scsi_file (dev_name);
+	}
+    }
+  if (device_found)
+    {
+      if (verbose > 0)
+	printf
+	  ("  # Your SCSI scanner was detected. It may or may not be "
+	   "supported by SANE. Try\n  # scanimage -L and read the backend's "
+	   "manpage.\n");
+    }
+  else
+    {
+      if (verbose > 0)
+	printf
+	  ("  # No SCSI scanners found. If you expected something different, "
+	   "make sure that\n  # you have loaded a kernel SCSI driver for your SCSI "
+	   "adapter.\n");
+      if (!check_sg ())
+	{
+	  if (verbose > 0)
+	    printf
+	      ("  # Also you need support for SCSI Generic (sg) in your "
+	       "operating system.\n  # If using Linux, try \"modprobe "
+	       "sg\".\n");
+	}
+    }
+  if (verbose > 0)
+    printf ("\n");
+  device_found = SANE_FALSE;
+  sanei_usb_init ();
+  if (verbose > 1)
+    printf ("searching for USB scanners:\n");
+
+  while ((dev_name = *usb_dev_list++))
+    {
+      if (strlen (dev_name) == 0)
+	continue;		/* Empty device names ... */
+
+      if (dev_name[strlen (dev_name) - 1] == '/')
+	{
+	  /* check whole directories */
+	  DIR *dir;
+	  char *file_name;
+
+	  dir = scan_directory (dev_name);
+	  if (!dir)
+	    continue;
+
+	  while ((file_name = get_next_file (dev_name, dir)))
+	    check_usb_file (file_name);
+	}
+      else
+	{
+	  /* check device files */
+	  check_usb_file (dev_name);
+	}
+    }
+#ifdef HAVE_LIBUSB_LEGACY
+  /* Now the libusb devices */
+  {
+    struct usb_bus *bus;
+    struct usb_device *dev;
+
+    if (ap < argv + argc)
+      {
+	/* user-specified devices not useful for libusb */
+	if (verbose > 1)
+	  printf ("ignoring libusb devices\n");
+      }
+    else
+      {
+	if (verbose > 2)
+	  printf ("trying libusb:\n");
+	for (bus = usb_get_busses (); bus; bus = bus->next)
+	  {
+	    for (dev = bus->devices; dev; dev = dev->next)
+	      {
+		check_libusb_device (dev, SANE_FALSE);
+	      }			/* for (dev) */
+	  }			/* for (bus) */
+      }
+  }
+#elif defined(HAVE_LIBUSB)
+  /* Now the libusb-1.0 devices */
+  {
+    if (ap < argv + argc)
+      {
+	/* user-specified devices not useful for libusb */
+	if (verbose > 1)
+	  printf ("ignoring libusb devices\n");
+      }
+    else
+      {
+	libusb_device **devlist;
+	ssize_t devcnt;
+	int i;
+	int ret;
+
+	if (verbose > 2)
+	  printf ("trying libusb:\n");
+
+	ret = libusb_init (&sfs_usb_ctx);
+	if (ret < 0)
+	  {
+	    printf ("# Could not initialize libusb-1.0, error %d\n", ret);
+	    printf ("# Skipping libusb devices\n");
+
+	    goto failed_libusb_1_0;
+	  }
+
+	if (verbose > 3)
+#if LIBUSB_API_VERSION >= 0x01000106
+          libusb_set_option (sfs_usb_ctx, LIBUSB_OPTION_LOG_LEVEL,
+                             LIBUSB_LOG_LEVEL_INFO);
+#else
+	  libusb_set_debug (sfs_usb_ctx, 3);
+#endif
+
+	devcnt = libusb_get_device_list (sfs_usb_ctx, &devlist);
+	if (devcnt < 0)
+	  {
+	    printf ("# Could not get device list, error %d\n", ret);
+
+	    goto deinit_libusb_1_0;
+	  }
+
+	for (i = 0; i < devcnt; i++)
+	  {
+	    check_libusb_device (devlist[i], SANE_FALSE);
+	  }
+
+	libusb_free_device_list (devlist, 1);
+
+      deinit_libusb_1_0:
+	libusb_exit (sfs_usb_ctx);
+
+      failed_libusb_1_0:
+	; /* init failed, jumping here */
+      }
+  }
+#else /* not HAVE_LIBUSB_LEGACY && not HAVE_LIBUSB */
+  if (verbose > 1)
+    printf ("libusb not available\n");
+#endif /* not HAVE_LIBUSB_LEGACY && not HAVE_LIBUSB */
+
+  if (device_found)
+    {
+      if (libusb_device_found)
+	{
+	  if (verbose > 0)
+	    printf
+	      ("  # Your USB scanner was (probably) detected. It "
+	       "may or may not be supported by\n  # SANE. Try scanimage "
+	       "-L and read the backend's manpage.\n");
+	}
+      else if (verbose > 0)
+	printf
+	  ("  # Your USB scanner was detected. It may or may not "
+	   "be supported by\n  # SANE. Try scanimage -L and read the "
+	   "backend's manpage.\n");
+      if (unknown_found && verbose > 0)
+	printf
+	  ("  # `UNKNOWN vendor and product' means that there seems to be a "
+	   "scanner at this\n  # device file but the vendor and product ids "
+	   "couldn't be identified.\n  # Currently identification only works "
+	   "with Linux versions >= 2.4.8. You may\n  # need to configure your "
+	   "backend manually, see the backend's manpage.\n");
+    }
+  else
+    {
+      if (verbose > 0)
+	printf
+	  ("  # No USB scanners found. If you expected something different, "
+	   "make sure that\n  # you have loaded a kernel driver for your USB host "
+	   "controller and have setup\n  # the USB system correctly. "
+	   "See man sane-usb for details.\n");
+#if !defined(HAVE_LIBUSB_LEGACY) && !defined(HAVE_LIBUSB)
+      if (verbose > 0)
+	printf ("  # SANE has been built without libusb support. This may be a "
+		"reason\n  # for not detecting USB scanners. Read README for "
+		"more details.\n");
+#endif
+    }
+  if (enable_pp_checks == SANE_TRUE)
+    {
+      if (!check_mustek_pp_device() && verbose > 0)
+        printf ("\n  # No Mustek parallel port scanners found. If you expected"
+                " something\n  # different, make sure the scanner is correctly"
+	        " connected to your computer\n  # and you have appropriate"
+	        " access rights.\n");
+    }
+  else if (verbose > 0)
+    printf ("\n  # Not checking for parallel port scanners.\n");
+  if (verbose > 0)
+    printf ("\n  # Most Scanners connected to the parallel port or other "
+	    "proprietary ports\n  # can't be detected by this program.\n");
+#ifdef HAVE_GETUID
+  if (getuid ())
+    if (verbose > 0)
+      printf
+	("\n  # You may want to run this program as root to find all devices. "
+	 "Once you\n  # found the scanner devices, be sure to adjust access "
+	 "permissions as\n  # necessary.\n");
+#endif
+
+  if (verbose > 1)
+    printf ("done\n");
+
+  return 0;
+}
diff --git a/tools/sane-find-scanner.c.rej b/tools/sane-find-scanner.c.rej
new file mode 100644
index 0000000..719a906
--- /dev/null
+++ b/tools/sane-find-scanner.c.rej
@@ -0,0 +1,22 @@
+--- tools/sane-find-scanner.c
++++ tools/sane-find-scanner.c
+@@ -384,7 +384,7 @@ check_usb_file (char *file_name)
+    {
+      if (verbose > 1)
+        printf (" open ok, vendor and product ids were identified\n");
+-	  printf ("found USB scanner (vendor=0x%04x, "
++	  printf ("found possible USB scanner (vendor=0x%04x, "
+ 	  "product=0x%04x) at %s\n", vendor, product, file_name);
+    }
+       else
+@@ -392,8 +392,8 @@ check_usb_file (char *file_name)
+      if (verbose > 1)
+        printf (" open ok, but vendor and product could NOT be "
+ 	    "identified\n");
+-	  printf ("found USB scanner (UNKNOWN vendor and product) "
+-		  "at device %s\n", file_name);
++	  printf ("found possible USB scanner (UNKNOWN vendor and "
++		  "product) at %s\n", file_name);
+      unknown_found = SANE_TRUE;
+    }
+       device_found = SANE_TRUE;