Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2065 insertions, 0 deletions

diff --git a/backend/dell1600n_net.c b/backend/dell1600n_net.c
new file mode 100644
index 0000000..d19059b
--- /dev/null
+++ b/backend/dell1600n_net.c
@@ -0,0 +1,2065 @@
+/*
+  sane - Scanner Access Now Easy.
+  Copyright (C) 2006 Jon Chambers <jon@jon.demon.co.uk>
+ 
+  This file is part of the SANE package.
+ 
+  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., 59 Temple Place - Suite 330, Boston,
+  MA 02111-1307, USA.
+ 
+  As a special exception, the authors of SANE give permission for
+  additional uses of the libraries contained in this release of SANE.
+ 
+  The exception is that, if you link a SANE library with other files
+  to produce an executable, this does not by itself cause the
+  resulting executable to be covered by the GNU General Public
+  License.  Your use of that executable is in no way restricted on
+  account of linking the SANE library code into it.
+ 
+  This exception does not, however, invalidate any other reasons why
+  the executable file might be covered by the GNU General Public
+  License.
+ 
+  If you submit changes to SANE to the maintainers to be included in
+  a subsequent release, you agree by submitting the changes that
+  those changes may be distributed with this exception intact.
+ 
+  If you write modifications of your own for SANE, it is your choice
+  whether to permit this exception to apply to your modifications.
+  If you do not wish that, delete this exception notice.
+ 
+  Dell 1600n network scan driver for SANE.
+   
+  To debug:
+  SANE_DEBUG_DELL1600N_NET=255 scanimage --verbose 2>scan.errs 1>scan.png
+*/
+
+/***********************************************************
+ * INCLUDES
+ ***********************************************************/
+
+#include "../include/sane/config.h"
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+
+#define BACKEND_NAME    dell1600n_net
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <unistd.h>
+
+/* :NOTE: these are likely to be platform-specific! */
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+#include <jpeglib.h>
+#include <tiffio.h>
+
+/* OS/2... */
+#ifndef SHUT_RDWR
+#define SHUT_RDWR 2
+#endif
+
+
+/***********************************************************
+ * DEFINITIONS
+ ***********************************************************/
+
+/* Maximum number of scanners */
+#define MAX_SCANNERS 32
+
+/* version number */
+#define DRIVER_VERSION SANE_VERSION_CODE( SANE_CURRENT_MAJOR, V_MINOR, 0 )
+
+/* size of buffer for socket communication */
+#define SOCK_BUF_SIZE 2048
+
+/* size of registation name */
+#define REG_NAME_SIZE 64
+
+struct DeviceRecord
+{
+  SANE_Device m_device;
+  char * m_pName;        /* storage of name */
+  char * m_pModel;       /* storage of model */
+};
+
+/* a buffer struct to store "stuff" */
+struct ComBuf
+{
+  size_t m_capacity;		/* current allocated size in bytes */
+  size_t m_used;		/* current used size in bytes */
+  unsigned char *m_pBuf;	/* storage (or NULL if none allocated) */
+};
+
+/* state data for a single scanner connection */
+struct ScannerState
+{
+  int m_udpFd;			/* file descriptor to UDP socket */
+  int m_tcpFd;			/* file descriptor to TCP socket */
+  struct sockaddr_in m_sockAddr;	/* printer address */
+  struct ComBuf m_buf;		/* buffer for network data */
+  struct ComBuf m_imageData;	/* storage for decoded image data */
+  int m_numPages;	        /* number of complete pages (host byte order) */
+  struct ComBuf m_pageInfo;	/* "array" of numPages PageInfo structs */
+  int m_bFinish;		/* set non-0 to signal that we are finished */
+  int m_bCancelled;		/* set non-0 that bFinish state arose from cancelation */
+  char m_regName[REG_NAME_SIZE];	/* name with which to register */
+  unsigned short m_xres;	/* x resolution (network byte order) */
+  unsigned short m_yres;	/* y resolution (network byte order) */
+  unsigned int m_composition;	/* composition (0x01=>TIFF/PDF,0x40=>JPEG) (network byte order) */
+  unsigned char m_brightness;	/* brightness */
+  unsigned int m_compression;	/* compression (0x08=>CCIT Group 4,0x20=>JPEG) (network byte order) */
+  unsigned int m_fileType;	/* file type (2=>TIFF,4=>PDF,8=>JPEG)(network byte order) */
+  unsigned int m_pixelWidth;	/* width in pixels (network byte order) */
+  unsigned int m_pixelHeight;	/* height in pixels (network byte order) */
+  unsigned int m_bytesRead;	/* bytes read by SANE (host byte order) */
+  unsigned int m_currentPageBytes;/* number of bytes of current page read (host byte order) */
+};
+
+/* state data for a single page 
+   NOTE: all ints are in host byte order 
+*/
+struct PageInfo
+{
+  int m_width;                 /* pixel width */
+  int m_height;                /* pixel height */
+  int m_totalSize;             /* total page size (bytes) */
+  int m_bytesRemaining;        /* number of bytes not yet passed to SANE client */
+};
+
+/* struct for in-memory jpeg decompression */
+struct JpegDataDecompState
+{
+  struct jpeg_decompress_struct m_cinfo;	/* base struct */
+  unsigned char *m_pData;	/* data pointer */
+  unsigned int m_bytesRemaining;	/* amount of unprocessed data */
+};
+
+/* initial ComBuf allocation */
+#define INITIAL_COM_BUF_SIZE 1024
+
+/***********************************************************
+ * FUNCTION PROTOTYPES
+ ***********************************************************/
+
+/* print hex buffer to stdout */
+static void HexDump (int debugLevel, const unsigned char *buf,
+		     size_t bufSize);
+
+/* clears gKnownDevices array */
+static void ClearKnownDevices (void);
+
+/* initialise a ComBuf struct */
+static int InitComBuf (struct ComBuf *pBuf);
+
+/* free a ComBuf struct */
+static void FreeComBuf (struct ComBuf *pBuf);
+
+/* add data to a ComBuf struct */
+static int AppendToComBuf (struct ComBuf *pBuf, const unsigned char *pData,
+			   size_t datSize);
+
+/* remove data from the front of a ComBuf struct */
+static int PopFromComBuf (struct ComBuf *pBuf, size_t datSize);
+
+/* initialise a packet */
+static int InitPacket (struct ComBuf *pBuf, char type);
+
+/* append message to a packet */
+static int AppendMessageToPacket (struct ComBuf *pBuf,
+				  char messageType,
+				  char *messageName,
+				  char valueType,
+				  void *pValue, size_t valueLen);
+
+/* write length data to packet header */
+static void FinalisePacket (struct ComBuf *pBuf);
+
+/* \return 1 if message is complete, 0 otherwise */
+static int MessageIsComplete (unsigned char *pData, size_t size);
+
+/* process a registration broadcast response
+   \return DeviceRecord pointer on success (caller frees), NULL on failure 
+*/
+static struct DeviceRecord *ProcessFindResponse (unsigned char *pData, size_t size);
+
+/* frees a scanner state struct stored in gOpenScanners */
+static void FreeScannerState (int iHandle);
+
+/* \return 1 if iHandle is a valid member of gOpenScanners, 0 otherwise */
+static int ValidScannerNumber (int iHandle);
+
+/* process UDP responses, \return 0 in success, >0 otherwise */
+static int ProcessUdpResponse (unsigned char *pData, size_t size,
+			       struct ScannerState *pState);
+
+/* process TCP responses, \return 0 in success, >0 otherwise */
+static int ProcessTcpResponse (struct ScannerState *pState,
+			       struct ComBuf *pTcpBufBuf);
+
+/* Process the data from a single scanned page, \return 0 in success, >0 otherwise */
+static int ProcessPageData (struct ScannerState *pState);
+
+/* Libjpeg decompression interface */
+static void JpegDecompInitSource (j_decompress_ptr cinfo);
+static boolean JpegDecompFillInputBuffer (j_decompress_ptr cinfo);
+static void JpegDecompSkipInputData (j_decompress_ptr cinfo, long numBytes);
+static void JpegDecompTermSource (j_decompress_ptr cinfo);
+
+/***********************************************************
+ * GLOBALS
+ ***********************************************************/
+
+/* Results of last call to sane_get_devices */
+static struct DeviceRecord *gKnownDevices[MAX_SCANNERS];
+
+/* Array of open scanner device states.
+   :NOTE: (int)SANE_Handle is an offset into this array */
+static struct ScannerState *gOpenScanners[MAX_SCANNERS];
+
+/* scanner port */
+static unsigned short gScannerPort = 1124;
+
+/* ms to wait for registration replies */
+static unsigned short gRegReplyWaitMs = 300;
+
+/***********************************************************
+ * FUNCTION IMPLEMENTATIONS
+ ***********************************************************/
+
+SANE_Status
+sane_init (SANE_Int * version_code,
+	   SANE_Auth_Callback __sane_unused__ authorize)
+{
+
+  /* init globals */
+  memset (gKnownDevices, 0, sizeof (gKnownDevices));
+  memset (gOpenScanners, 0, sizeof (gOpenScanners));
+
+  /* report version */
+  *version_code = DRIVER_VERSION;
+
+  /* init debug */
+  DBG_INIT ();
+
+  return SANE_STATUS_GOOD;
+
+} /* sane_init */
+
+/***********************************************************/
+
+void
+sane_exit (void)
+{
+
+  int iHandle;
+
+  /* clean up */
+  ClearKnownDevices ();
+
+  for (iHandle = 0; iHandle < MAX_SCANNERS; ++iHandle)
+    {
+      if (gOpenScanners[iHandle])
+	FreeScannerState (iHandle);
+    }
+
+} /* sane_exit */
+
+/***********************************************************/
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list,
+		  SANE_Bool __sane_unused__ local_only)
+{
+
+  int ret;
+  unsigned char sockBuf[SOCK_BUF_SIZE];
+  int sock, optYes;
+  struct DeviceRecord *pDevice;
+  struct ComBuf queryPacket;
+  struct sockaddr_in remoteAddr;
+  unsigned char ucVal;
+  fd_set readFds;
+  struct timeval selTimeVal;
+  int nread, iNextDevice;
+  FILE *fConfig;
+  char configBuf[ 256 ];
+  const char *pVal;
+  int valLen;
+
+  /* init variables */
+  ret = SANE_STATUS_GOOD;
+  sock = 0;
+  pDevice = NULL;
+  optYes = 1;
+  InitComBuf (&queryPacket);
+
+  /* clear previous results */
+  ClearKnownDevices ();
+  iNextDevice = 0;
+
+  /* look for a config file */
+  fConfig = sanei_config_open( "dell1600n_net.conf" );
+  if ( fConfig )
+    {
+      while ( ! feof( fConfig ) )
+        {
+          if ( ! sanei_config_read ( configBuf, sizeof( configBuf ), fConfig ) ) break;
+
+          /* skip whitespace */
+          pVal = sanei_config_skip_whitespace ( configBuf );
+
+          /* skip comments */
+          if ( *pVal == '#' ) continue;
+
+          /* process named_scanner */
+          valLen = strlen( "named_scanner:" );
+          if ( ! strncmp( pVal, "extra_scanner:", valLen ) ){
+
+            pVal = sanei_config_skip_whitespace ( pVal + valLen );
+
+            pDevice = malloc (sizeof (struct DeviceRecord));
+            if (!pDevice)
+              {
+                DBG (1, "sane_get_devices: memory allocation failure\n");
+                break;
+              }
+
+            pDevice->m_pName = strdup (pVal);
+            pDevice->m_device.vendor = "Dell";
+            pDevice->m_pModel = strdup( "1600n" );
+            pDevice->m_device.type = "multi-function peripheral";
+
+            pDevice->m_device.name = pDevice->m_pName;
+            pDevice->m_device.model = pDevice->m_pModel;
+
+            /* add to list */
+            gKnownDevices[iNextDevice++] = pDevice;
+
+            continue;
+          } /* if */
+
+        } /* while */
+
+      /* Close the file */
+      fclose( fConfig );
+    }
+
+  /* open UDP socket */
+  sock = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+  if (sock == -1)
+    {
+      DBG (1, "Error creating socket\n");
+      ret = SANE_STATUS_NO_MEM;
+      goto cleanup;
+    }
+  setsockopt (sock, SOL_SOCKET, SO_BROADCAST, &optYes, sizeof (optYes));
+
+  /* prepare select mask */
+  FD_ZERO (&readFds);
+  FD_SET (sock, &readFds);
+  selTimeVal.tv_sec = 0;
+  selTimeVal.tv_usec = gRegReplyWaitMs * 1000;
+
+  /* init a packet */
+  InitPacket (&queryPacket, 0x01);
+
+  /* add query */
+  ucVal = 0;
+  AppendMessageToPacket (&queryPacket, 0x25, "std-scan-discovery-all",
+			 0x02, &ucVal, sizeof (ucVal));
+
+  FinalisePacket (&queryPacket);
+
+  DBG (10, "Sending:\n");
+  HexDump (10, queryPacket.m_pBuf, queryPacket.m_used);
+
+
+  remoteAddr.sin_family = AF_INET;
+  remoteAddr.sin_port = htons (gScannerPort);
+  remoteAddr.sin_addr.s_addr = 0xFFFFFFFF;	/* broadcast */
+
+  if (sendto (sock, queryPacket.m_pBuf, queryPacket.m_used, 0,
+    &remoteAddr, sizeof (remoteAddr)) == -1)
+    {
+      DBG (1, "Error sending broadcast packet\n");
+      ret = SANE_STATUS_NO_MEM;
+      goto cleanup;
+    }
+
+  /* process replies */
+  while (select (sock + 1, &readFds, NULL, NULL, &selTimeVal))
+    {
+
+      /* break if we've got no more storage space in array */
+      if (iNextDevice >= MAX_SCANNERS)
+        {
+          DBG (1, "sane_get_devices: more than %d devices, ignoring\n",
+            MAX_SCANNERS);
+          break;
+        }
+
+      nread = read (sock, sockBuf, sizeof (sockBuf));
+      DBG (5, "Got a broadcast response, (%d bytes)\n", nread);
+
+      if (nread <= 0)
+        break;
+
+      HexDump (10, sockBuf, nread);
+
+      /* process response (skipping bad ones) */
+      if (!(pDevice = ProcessFindResponse (sockBuf, nread))) continue;
+
+      /* add to list */
+      gKnownDevices[iNextDevice++] = pDevice;
+
+    } /* while */
+
+  /* report our finds */
+  *device_list = (const SANE_Device **) gKnownDevices;
+
+cleanup:
+
+  if (sock)
+    close (sock);
+  FreeComBuf (&queryPacket);
+
+  return ret;
+
+} /* sane_get_devices */
+
+/***********************************************************/
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+
+  int iHandle = -1, i;
+  SANE_Status status = SANE_STATUS_GOOD;
+  struct hostent *pHostent;
+  char *pDot;
+
+  DBG( 5, "sane_open: %s\n", devicename );
+
+  /* find the next available scanner pointer in gOpenScanners */
+  for (i = 0; i < MAX_SCANNERS; ++i)
+    {
+
+      if (gOpenScanners[i]) continue;
+
+      iHandle = i;
+      break;
+
+    } /* for */
+  if (iHandle == -1)
+    {
+      DBG (1, "sane_open: no space left in gOpenScanners array\n");
+      status = SANE_STATUS_NO_MEM;
+      goto cleanup;
+    }
+
+  /* allocate some space */
+  if (!(gOpenScanners[iHandle] = malloc (sizeof (struct ScannerState))))
+    {
+      status = SANE_STATUS_NO_MEM;
+      goto cleanup;
+    }
+
+  /* init data */
+  memset (gOpenScanners[iHandle], 0, sizeof (struct ScannerState));
+  InitComBuf (&gOpenScanners[iHandle]->m_buf);
+  InitComBuf (&gOpenScanners[iHandle]->m_imageData);
+  InitComBuf (&gOpenScanners[iHandle]->m_pageInfo);
+  gOpenScanners[iHandle]->m_xres = ntohs (200);
+  gOpenScanners[iHandle]->m_yres = ntohs (200);
+  gOpenScanners[iHandle]->m_composition = ntohl (0x01);
+  gOpenScanners[iHandle]->m_brightness = 0x80;
+  gOpenScanners[iHandle]->m_compression = ntohl (0x08);
+  gOpenScanners[iHandle]->m_fileType = ntohl (0x02);
+
+
+  /* look up scanner name */
+  pHostent = gethostbyname (devicename);
+  if ((!pHostent) || (!pHostent->h_addr_list))
+    {
+      DBG (1, "sane_open: error looking up scanner name %s\n", devicename);
+      status = SANE_STATUS_INVAL;
+      goto cleanup;
+    }
+
+  /* open a UDP socket */
+  if (!(gOpenScanners[iHandle]->m_udpFd =
+    socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)))
+    {
+      DBG (1, "sane_open: error opening socket\n");
+      status = SANE_STATUS_IO_ERROR;
+      goto cleanup;
+    }
+
+  /* connect to the scanner */
+  memset (&gOpenScanners[iHandle]->m_sockAddr, 0,
+    sizeof (gOpenScanners[iHandle]->m_sockAddr));
+  gOpenScanners[iHandle]->m_sockAddr.sin_family = AF_INET;
+  gOpenScanners[iHandle]->m_sockAddr.sin_port = htons (gScannerPort);
+  memcpy (&gOpenScanners[iHandle]->m_sockAddr.sin_addr,
+    pHostent->h_addr_list[0], pHostent->h_length);
+  if (connect (gOpenScanners[iHandle]->m_udpFd,
+    (struct sockaddr *) &gOpenScanners[iHandle]->m_sockAddr,
+    sizeof (gOpenScanners[iHandle]->m_sockAddr)))
+    {
+      DBG (1, "sane_open: error connecting to %s:%d\n", devicename,
+        gScannerPort);
+      status = SANE_STATUS_IO_ERROR;
+      goto cleanup;
+    }
+
+  /* set fallback registration name */
+  sprintf (gOpenScanners[iHandle]->m_regName, "Sane");
+
+  /* try to fill in hostname */
+  gethostname (gOpenScanners[iHandle]->m_regName, REG_NAME_SIZE);
+
+  /* just in case... */
+  gOpenScanners[iHandle]->m_regName[REG_NAME_SIZE - 1] = 0;
+
+  /* chop off any domain (if any) */
+  if ((pDot = strchr (gOpenScanners[iHandle]->m_regName, '.')))
+    *pDot = 0;
+
+  DBG (5, "sane_open: connected to %s:%d as %s\n", devicename, gScannerPort,
+       gOpenScanners[iHandle]->m_regName);
+
+
+  /* set the handle */
+  *handle = (SANE_Handle) (unsigned long)iHandle;
+
+  return status;
+
+cleanup:
+
+  if (iHandle != -1)
+    FreeScannerState (iHandle);
+
+  return status;
+
+} /* sane_open */
+
+/***********************************************************/
+
+void
+sane_close (SANE_Handle handle)
+{
+
+  DBG( 5, "sane_close: %lx\n", (unsigned long)handle );
+
+  FreeScannerState ((unsigned long) handle);
+
+} /* sane_close */
+
+/***********************************************************/
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle __sane_unused__ handle,
+			    SANE_Int option)
+{
+
+  static SANE_Option_Descriptor numOptions = {
+    "num_options",
+    "Number of options",
+    "Number of options",
+    SANE_TYPE_INT,
+    SANE_UNIT_NONE,
+    1,
+    0,
+    0,
+    {0}
+  };
+
+  if (option == 0)
+    return &numOptions;
+  else
+    return NULL;
+
+} /* sane_get_option_descriptor */
+
+/***********************************************************/
+
+SANE_Status
+sane_control_option (SANE_Handle __sane_unused__ handle, SANE_Int option,
+		     SANE_Action action, void *value,
+		     SANE_Int __sane_unused__ * info)
+{
+
+  static int numOptions = 1;
+
+  if (action == SANE_ACTION_GET_VALUE && option == 0)
+    *(int *) value = numOptions;
+
+  return SANE_STATUS_GOOD;
+
+} /* sane_control_option  */
+
+/***********************************************************/
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  int iHandle = (int) (unsigned long)handle;
+  unsigned int width, height, imageSize;
+  struct PageInfo pageInfo;
+
+  if (!gOpenScanners[iHandle])
+    return SANE_STATUS_INVAL;
+
+  /* fetch page info */
+  memcpy( & pageInfo, gOpenScanners[iHandle]->m_pageInfo.m_pBuf, sizeof( pageInfo ) );
+
+  width = pageInfo.m_width;
+  height = pageInfo.m_height;
+  imageSize = width * height * 3;
+
+  DBG( 5, "sane_get_parameters: bytes remaining on this page: %d, num pages: %d, size: %dx%d\n", 
+       pageInfo.m_bytesRemaining,
+       gOpenScanners[iHandle]->m_numPages,
+       width,
+       height );
+
+  DBG (5,
+       "sane_get_parameters: handle %x: bytes outstanding: %lu, image size: %d\n",
+       iHandle, (unsigned long)gOpenScanners[iHandle]->m_imageData.m_used, imageSize);
+
+  /* check for enough data */
+  /*
+  if (gOpenScanners[iHandle]->m_imageData.m_used < imageSize)
+    {
+      DBG (1, "sane_get_parameters: handle %d: not enough data: %d < %d\n",
+	   iHandle, gOpenScanners[iHandle]->m_imageData.m_used, imageSize);
+      return SANE_STATUS_INVAL;
+    }
+  */
+
+
+  params->format = SANE_FRAME_RGB;
+  params->last_frame = SANE_TRUE;
+  params->lines = height;
+  params->depth = 8;
+  params->pixels_per_line = width;
+  params->bytes_per_line = width * 3;
+
+  return SANE_STATUS_GOOD;
+
+} /* sane_get_parameters  */
+
+/***********************************************************/
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+
+  SANE_Status status = SANE_STATUS_GOOD;
+  struct ComBuf buf;
+  unsigned char sockBuf[SOCK_BUF_SIZE];
+  int iHandle, nread;
+  int errorCheck = 0;
+  struct sockaddr_in myAddr;
+  socklen_t addrSize;
+  fd_set readFds;
+  struct timeval selTimeVal;
+
+  iHandle = (int) (unsigned long)handle;
+
+  DBG( 5, "sane_start: %x\n", iHandle );
+
+  /* fetch and check scanner index */
+  if (!ValidScannerNumber (iHandle))
+    return SANE_STATUS_INVAL;
+
+  /* check if we still have oustanding pages of data on this handle */
+  if (gOpenScanners[iHandle]->m_imageData.m_used){
+
+    /* remove empty page */
+    PopFromComBuf ( & gOpenScanners[iHandle]->m_pageInfo, sizeof( struct PageInfo ) );
+    return SANE_STATUS_GOOD;
+
+  }
+
+  /* determine local IP address */
+  addrSize = sizeof (myAddr);
+  if (getsockname (gOpenScanners[iHandle]->m_udpFd, &myAddr, &addrSize))
+    {
+      DBG (1, "sane_start: Error getting own IP address\n");
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  /* init a buffer for our registration message */
+  errorCheck |= InitComBuf (&buf);
+
+  /* build packet */
+  errorCheck |= InitPacket (&buf, 1);
+  errorCheck |=
+    AppendMessageToPacket (&buf, 0x22, "std-scan-subscribe-user-name", 0x0b,
+      gOpenScanners[iHandle]->m_regName,
+      strlen (gOpenScanners[iHandle]->m_regName));
+  errorCheck |=
+    AppendMessageToPacket (&buf, 0x22, "std-scan-subscribe-ip-address", 0x0a,
+      &myAddr.sin_addr, 4);
+  FinalisePacket (&buf);
+
+  /* check nothing went wrong along the way */
+  if (errorCheck)
+    {
+      status = SANE_STATUS_NO_MEM;
+      goto cleanup;
+    }
+
+  /* send the packet */
+  send (gOpenScanners[iHandle]->m_udpFd, buf.m_pBuf, buf.m_used, 0);
+
+
+  /* loop until done */
+  gOpenScanners[iHandle]->m_bFinish = 0;
+  while (!gOpenScanners[iHandle]->m_bFinish)
+    {
+
+      /* prepare select mask */
+      FD_ZERO (&readFds);
+      FD_SET (gOpenScanners[iHandle]->m_udpFd, &readFds);
+      selTimeVal.tv_sec = 1;
+      selTimeVal.tv_usec = 0;
+
+
+
+      DBG (5, "sane_start: waiting for scan signal\n");
+
+      /* wait again if nothing received */
+      if (!select (gOpenScanners[iHandle]->m_udpFd + 1,
+        &readFds, NULL, NULL, &selTimeVal))
+        continue;
+
+      /* read from socket */
+      nread =
+        read (gOpenScanners[iHandle]->m_udpFd, sockBuf, sizeof (sockBuf));
+
+      if (nread <= 0)
+        {
+          DBG (1, "sane_start: read returned %d\n", nread);
+          break;
+        }
+
+      /* process the response */
+      if (ProcessUdpResponse (sockBuf, nread, gOpenScanners[iHandle]))
+        {
+          status = SANE_STATUS_IO_ERROR;
+          goto cleanup;
+        }
+
+    } /* while */
+
+  /* check whether we were cancelled */
+  if ( gOpenScanners[iHandle]->m_bCancelled ) status = SANE_STATUS_CANCELLED;
+
+cleanup:
+
+  FreeComBuf (&buf);
+  
+  return status;
+
+} /* sane_start */
+
+/***********************************************************/
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * data,
+	   SANE_Int max_length, SANE_Int * length)
+{
+
+  int iHandle = (int) (unsigned long)handle;
+  int dataSize;
+  struct PageInfo pageInfo;
+
+  DBG( 5, "sane_read: %x (max_length=%d)\n", iHandle, max_length );
+
+  *length = 0;
+
+  if (!gOpenScanners[iHandle])
+    return SANE_STATUS_INVAL;
+
+  /* check for end of data (no further pages) */
+  if ( ( ! gOpenScanners[iHandle]->m_imageData.m_used ) 
+       || ( ! gOpenScanners[iHandle]->m_numPages ) )
+    {
+      /* remove empty page if there are no more cached pages */
+      PopFromComBuf ( & gOpenScanners[iHandle]->m_pageInfo, sizeof( struct PageInfo ) );
+
+      return SANE_STATUS_EOF;
+    }
+
+  /* fetch page info */
+  memcpy( & pageInfo, gOpenScanners[iHandle]->m_pageInfo.m_pBuf, sizeof( pageInfo ) );
+
+  /* check for end of page data (we still have further cached pages) */
+  if ( pageInfo.m_bytesRemaining < 1 ) return SANE_STATUS_EOF;
+
+  /*  send the remainder of the current image */
+  dataSize = pageInfo.m_bytesRemaining;
+
+  /* unless there's not enough room in the output buffer */
+  if (dataSize > max_length)
+    dataSize = max_length;
+
+  /* update the data sent counters */
+  gOpenScanners[iHandle]->m_bytesRead += dataSize;
+  pageInfo.m_bytesRemaining -= dataSize;
+
+  /* update counter */
+  memcpy( gOpenScanners[iHandle]->m_pageInfo.m_pBuf, & pageInfo, sizeof( pageInfo ) );
+
+  /* check for end of page */
+  if ( pageInfo.m_bytesRemaining < 1 ){
+
+    /* yes, so remove page info */
+    gOpenScanners[iHandle]->m_numPages--;
+
+  } /* if */
+
+  DBG (5,
+       "sane_read: sending %d bytes, image total %d, %d page bytes remaining, %lu total remaining, image: %dx%d\n",
+       dataSize, gOpenScanners[iHandle]->m_bytesRead, pageInfo.m_bytesRemaining ,
+       (unsigned long)(gOpenScanners[iHandle]->m_imageData.m_used - dataSize), 
+       pageInfo.m_width,
+       pageInfo.m_height);
+
+  /* copy the data */
+  memcpy (data, gOpenScanners[iHandle]->m_imageData.m_pBuf, dataSize);
+  if (PopFromComBuf (&gOpenScanners[iHandle]->m_imageData, dataSize))
+    return SANE_STATUS_NO_MEM;
+
+  *length = dataSize;
+
+  return SANE_STATUS_GOOD;
+
+} /* sane_read */
+
+/***********************************************************/
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  int iHandle = (int) (unsigned long)handle;
+
+  DBG( 5, "sane_cancel: %x\n", iHandle );
+
+  /* signal that bad things are afoot */
+  gOpenScanners[iHandle]->m_bFinish = 1;
+  gOpenScanners[iHandle]->m_bCancelled = 1;
+
+} /* sane_cancel */
+
+/***********************************************************/
+
+SANE_Status
+sane_set_io_mode (SANE_Handle __sane_unused__ handle,
+		  SANE_Bool __sane_unused__ non_blocking)
+{
+
+  return SANE_STATUS_UNSUPPORTED;
+
+} /* sane_set_io_mode */
+
+/***********************************************************/
+
+SANE_Status
+sane_get_select_fd (SANE_Handle __sane_unused__ handle,
+		    SANE_Int __sane_unused__ * fd)
+{
+
+  return SANE_STATUS_UNSUPPORTED;
+
+} /* sane_get_select_fd */
+
+/***********************************************************/
+
+/* Clears the contents of gKnownDevices and zeros it */
+void
+ClearKnownDevices ()
+{
+
+  int i;
+
+  for (i = 0; i < MAX_SCANNERS; ++i)
+    {
+
+      if (gKnownDevices[i])
+        {
+          if (gKnownDevices[i]->m_pName) free ( gKnownDevices[i]->m_pName );
+          if (gKnownDevices[i]->m_pModel) free ( gKnownDevices[i]->m_pModel );
+          free ( gKnownDevices[i] );
+        }
+      gKnownDevices[i] = NULL;
+
+    }
+
+} /* ClearKnownDevices */
+
+/***********************************************************/
+
+/* print hex buffer to debug output */
+void
+HexDump (int debugLevel, const unsigned char *buf, size_t bufSize)
+{
+
+  unsigned int i, j;
+
+  char itemBuf[16] = { 0 }, lineBuf[256] = { 0 };
+
+  if (DBG_LEVEL < debugLevel)
+    return;
+
+  for (i = 0; i < bufSize; ++i)
+    {
+
+      if (!(i % 16))
+        sprintf (lineBuf, "%p: ", (buf + i));
+
+      sprintf (itemBuf, "%02x ", (const unsigned int) buf[i]);
+
+      strncat (lineBuf, itemBuf, sizeof (lineBuf));
+
+      if ((i + 1) % 16)
+        continue;
+
+      /* print string equivalent */
+      for (j = i - 15; j <= i; ++j)
+        {
+
+      if ((buf[j] >= 0x20) && (!(buf[j] & 0x80)))
+        {
+          sprintf (itemBuf, "%c", buf[j]);
+        }
+      else
+        {
+          sprintf (itemBuf, ".");
+        }
+    strncat (lineBuf, itemBuf, sizeof (lineBuf));
+
+    } /* for j */
+
+      DBG (debugLevel, "%s\n", lineBuf);
+      lineBuf[0] = 0;
+
+    } /* for i */
+
+  if (i % 16)
+    {
+
+      for (j = (i % 16); j < 16; ++j)
+        {
+          strncat (lineBuf, "   ", sizeof (lineBuf));
+        }
+      for (j = 1 + i - ((i + 1) % 16); j < i; ++j)
+        {
+          if ((buf[j] >= 0x20) && (!(buf[j] & 0x80)))
+            {
+              sprintf (itemBuf, "%c", buf[j]);
+            }
+          else
+            {
+              strcpy (itemBuf, ".");
+            }
+          strncat (lineBuf, itemBuf, sizeof (lineBuf));
+        }
+      DBG (debugLevel, "%s\n", lineBuf);
+    }
+} /* HexDump */
+
+/***********************************************************/
+
+/* initialise a ComBuf struct
+   \return 0 on success, >0 on failure
+*/
+int
+InitComBuf (struct ComBuf *pBuf)
+{
+
+  memset (pBuf, 0, sizeof (struct ComBuf));
+
+  pBuf->m_pBuf = malloc (INITIAL_COM_BUF_SIZE);
+  if (!pBuf->m_pBuf)
+    return 1;
+
+  pBuf->m_capacity = INITIAL_COM_BUF_SIZE;
+  pBuf->m_used = 0;
+
+  return 0;
+
+} /* InitComBuf */
+
+/***********************************************************/
+
+/* free a ComBuf struct */
+void
+FreeComBuf (struct ComBuf *pBuf)
+{
+
+  if (pBuf->m_pBuf)
+    free (pBuf->m_pBuf);
+  memset (pBuf, 0, sizeof (struct ComBuf));
+
+} /* FreeComBuf */
+
+/***********************************************************/
+
+/* add data to a ComBuf struct
+   \return 0 on success, >0 on failure
+   \note If pData is NULL then buffer size will be increased but no copying will take place
+   \note In case of failure pBuf will be released using FreeComBuf 
+*/
+int
+AppendToComBuf (struct ComBuf *pBuf, const unsigned char *pData,
+		size_t datSize)
+{
+
+  size_t newSize;
+
+  /* check we have enough space */
+  if (pBuf->m_used + datSize > pBuf->m_capacity)
+    {
+      /* nope - allocate some more */
+      newSize = pBuf->m_used + datSize + INITIAL_COM_BUF_SIZE;
+      pBuf->m_pBuf = realloc (pBuf->m_pBuf, newSize);
+      if (!pBuf->m_pBuf)
+        {
+          DBG (1, "AppendToComBuf: memory allocation error");
+          FreeComBuf (pBuf);
+          return (1);
+        }
+      pBuf->m_capacity = newSize;
+    } /* if */
+
+  /* add data */
+  if (pData)
+    memcpy (pBuf->m_pBuf + pBuf->m_used, pData, datSize);
+  pBuf->m_used += datSize;
+
+  return 0;
+
+} /* AppendToComBuf */
+
+/***********************************************************/
+
+/* append message to a packet
+   \return 0 if  ok, 1 if bad */
+int
+AppendMessageToPacket (struct ComBuf *pBuf,	/* packet to which to append */
+		       char messageType,	/* type of message */
+		       char *messageName,	/* name of message */
+		       char valueType,	        /* type of value */
+		       void *pValue,	        /* pointer to value */
+		       size_t valueLen	        /* length of value (bytes) */
+  )
+{
+
+  unsigned short slen;
+
+  /* message type */
+  AppendToComBuf (pBuf, (void *) &messageType, 1);
+
+  /* message length */
+  slen = htons (strlen (messageName));
+  AppendToComBuf (pBuf, (void *) &slen, 2);
+
+  /* and name */
+  AppendToComBuf (pBuf, (void *) messageName, strlen (messageName));
+
+  /* and value type */
+  AppendToComBuf (pBuf, (void *) &valueType, 1);
+
+  /* value length */
+  slen = htons (valueLen);
+  AppendToComBuf (pBuf, (void *) &slen, 2);
+
+  /* and value */
+  return (AppendToComBuf (pBuf, (void *) pValue, valueLen));
+
+} /* AppendMessageToPacket */
+
+/***********************************************************/
+
+/* Initialise a packet
+   \param pBuf : An initialise ComBuf
+   \param type : either 0x01 ("normal" ) or 0x02 ("reply" )
+   \return 0 on success, >0 otherwise
+*/
+int
+InitPacket (struct ComBuf *pBuf, char type)
+{
+
+  char header[8] = { 2, 0, 0, 2, 0, 0, 0, 0 };
+
+  header[2] = type;
+
+  /* reset size */
+  pBuf->m_used = 0;
+
+  /* add header */
+  return (AppendToComBuf (pBuf, (void *) &header, 8));
+
+} /* InitPacket */
+
+/***********************************************************/
+
+/* write length data to packet header
+*/
+void
+FinalisePacket (struct ComBuf *pBuf)
+{
+
+  /* sanity check */
+  if (pBuf->m_used < 8)
+    return;
+
+  /* set the size */
+  *((unsigned short *) (pBuf->m_pBuf + 6)) = htons (pBuf->m_used - 8);
+
+  DBG (20, "FinalisePacket: outgoing packet:\n");
+  HexDump (20, pBuf->m_pBuf, pBuf->m_used);
+
+} /* FinalisePacket */
+
+/***********************************************************/
+
+/* \return 1 if message is complete, 0 otherwise */
+int
+MessageIsComplete (unsigned char *pData, size_t size)
+{
+  unsigned short dataSize;
+
+  /* sanity check */
+  if (size < 8)
+    return 0;
+
+  /* :NOTE: we can't just cast to a short as data may not be aligned */
+  dataSize = (((unsigned short) pData[6]) << 8) | pData[7];
+
+  DBG (20, "MessageIsComplete: data size = %d\n", dataSize);
+
+  if (size >= (size_t) (dataSize + 8))
+    return 1;
+  else
+    return 0;
+
+} /* MessageIsComplete */
+
+/***********************************************************/
+
+/* process a registration broadcast response
+   \return struct DeviceRecord pointer on success (caller frees), NULL on failure 
+*/
+struct DeviceRecord *
+ProcessFindResponse (unsigned char *pData, size_t size)
+{
+
+  struct DeviceRecord *pDevice = NULL;
+  unsigned short messageSize, nameSize, valueSize;
+  unsigned char *pItem, *pEnd, *pValue;
+  char printerName[256] = { 0 };
+  char printerModel[256] = "1600n";
+  char *pModel, *pName;
+
+
+  DBG (10, "ProcessFindResponse: processing %lu bytes, pData=%p\n",
+       (unsigned long)size, pData);
+
+  /* check we have a complete packet */
+  if (!MessageIsComplete (pData, size))
+    {
+      DBG (1, "ProcessFindResponse: Ignoring incomplete packet\n");
+      return NULL;
+    }
+
+  /* extract data size */
+  messageSize = (((unsigned short) (pData[6])) << 8) | pData[7];
+
+  /* loop through items in message */
+  pItem = pData + 8;
+  pEnd = pItem + messageSize;
+  while (pItem < pEnd)
+    {
+
+      pItem++;
+      nameSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+      pName = (char *) pItem;
+
+      pItem += nameSize;
+
+      pItem++;
+      valueSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+
+      pValue = pItem;
+
+      pItem += valueSize;
+
+      /* process the item */
+      if (!strncmp ("std-scan-discovery-ip", pName, nameSize))
+        {
+
+          snprintf (printerName, sizeof (printerName), "%d.%d.%d.%d",
+            (int) pValue[0],
+            (int) pValue[1], (int) pValue[2], (int) pValue[3]);
+          DBG (2, "%s\n", printerName);
+
+        }
+      else if (!strncmp ("std-scan-discovery-model-name", pName, nameSize))
+        {
+
+          memset (printerModel, 0, sizeof (printerModel));
+          if (valueSize > (sizeof (printerModel) - 1))
+            valueSize = sizeof (printerModel) - 1;
+          memcpy (printerModel, pValue, valueSize);
+          DBG (2, "std-scan-discovery-model-name: %s\n", printerModel);
+
+        }
+
+    } /* while pItem */
+
+  /* just in case nothing sensible was found */
+  if ( ! strlen( printerName ) ) return NULL;
+
+  pDevice = malloc (sizeof (struct DeviceRecord));
+  if (!pDevice)
+    {
+      DBG (1, "ProcessFindResponse: memory allocation failure\n");
+      return NULL;
+    }
+
+  /* knock off "Dell " from start of model name */
+  pModel = printerModel;
+  if ( ! strncmp( pModel, "Dell ", 5 ) )
+    pModel += 5;
+
+  pDevice->m_pName = strdup( printerName );
+  pDevice->m_device.vendor = "Dell";
+  pDevice->m_pModel = strdup (pModel);
+  pDevice->m_device.type = "multi-function peripheral";
+
+  pDevice->m_device.name = pDevice->m_pName;
+  pDevice->m_device.model = pDevice->m_pModel;
+
+  return pDevice;
+
+} /* ProcessFindResponse */
+
+/***********************************************************/
+
+/* frees a scanner state struct stored in gOpenScanners */
+void
+FreeScannerState (int iHandle)
+{
+
+  /* check range etc */
+  if (!ValidScannerNumber (iHandle))
+    return;
+
+  /* close UDP handle */
+  if (gOpenScanners[iHandle]->m_udpFd)
+    close (gOpenScanners[iHandle]->m_udpFd);
+
+  /* free m_buf */
+  FreeComBuf (&gOpenScanners[iHandle]->m_buf);
+
+  /* free m_imageData */
+  FreeComBuf (&gOpenScanners[iHandle]->m_imageData);
+
+  /* free the struct */
+  free (gOpenScanners[iHandle]);
+
+  /* set pointer to NULL */
+  gOpenScanners[iHandle] = NULL;
+
+} /* FreeScannerState */
+
+/***********************************************************/
+
+/* \return 1 if iHandle is a valid member of gOpenScanners, 0 otherwise */
+int
+ValidScannerNumber (int iHandle)
+{
+  /* check range */
+  if ((iHandle < 0) || (iHandle >= MAX_SCANNERS))
+    {
+      DBG (1, "ValidScannerNumber: invalid scanner index %d", iHandle);
+      return 0;
+    }
+
+  /* check non-NULL pointer */
+  if (!gOpenScanners[iHandle])
+    {
+      DBG (1, "ValidScannerNumber: NULL scanner struct %d", iHandle);
+      return 0;
+    }
+
+  /* OK */
+  return 1;
+
+} /* ValidScannerNumber */
+
+/***********************************************************/
+
+/* process UDP responses
+   \return 0 in success, >0 otherwise */
+static int
+ProcessUdpResponse (unsigned char *pData, size_t size,
+		    struct ScannerState *pState)
+{
+
+  unsigned short messageSize, nameSize, valueSize;
+  unsigned char *pItem, *pEnd, *pValue;
+  char sockBuf[SOCK_BUF_SIZE], *pName;
+  struct ComBuf tcpBuf;
+  int nread;
+  unsigned int numUsed;
+
+  HexDump (15, pData, size);
+
+  DBG (10, "ProcessUdpResponse: processing %lu bytes, pData=%p\n",
+       (unsigned long)size, pData);
+
+  /* check we have a complete packet */
+  if (!MessageIsComplete (pData, size))
+    {
+      DBG (1, "ProcessUdpResponse: Ignoring incomplete packet\n");
+      return 1;
+    }
+
+  /* init a com buf for use in tcp communication */
+  InitComBuf (&tcpBuf);
+
+  /* extract data size */
+  messageSize = (((unsigned short) (pData[6])) << 8) | pData[7];
+
+  /* loop through items in message */
+  pItem = pData + 8;
+  pEnd = pItem + messageSize;
+  while (pItem < pEnd)
+    {
+
+      pItem++;
+      nameSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+      pName = (char *) pItem;
+
+      pItem += nameSize;
+
+      pItem++;
+      valueSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+
+      pValue = pItem;
+
+      pItem += valueSize;
+
+      /* process the item */
+      if (!strncmp ("std-scan-request-tcp-connection", pName, nameSize))
+        {
+
+          /* open TCP socket to scanner */
+          if (!(pState->m_tcpFd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP)))
+            {
+              DBG (1, "ProcessUdpResponse: error opening TCP socket\n");
+              return 2;
+            }
+          if (connect (pState->m_tcpFd,
+                       (struct sockaddr *) &pState->m_sockAddr,
+                       sizeof (pState->m_sockAddr)))
+            {
+              DBG (1,
+                   "ProcessUdpResponse: error connecting to scanner TCP port\n");
+              goto cleanup;
+            }
+
+          DBG (1, "ProcessUdpResponse: opened TCP connection to scanner\n");
+
+          /* clear read buf */
+          tcpBuf.m_used = 0;
+
+          /* TCP read loop */
+          while (1)
+            {
+
+              nread = read (pState->m_tcpFd, sockBuf, sizeof (sockBuf));
+
+              if (nread <= 0)
+                {
+                  DBG (1, "ProcessUdpResponse: TCP read returned %d\n",
+                       nread);
+                  break;
+                }
+
+              /* append message to buffer */
+              if (AppendToComBuf (&tcpBuf, (unsigned char *) sockBuf, nread))
+                goto cleanup;
+
+              /* process all available responses */
+              while (tcpBuf.m_used)
+                {
+
+                  /* note the buffer size before the call */
+                  numUsed = tcpBuf.m_used;
+
+                  /* process the response */
+                  if (ProcessTcpResponse (pState, &tcpBuf))
+                    goto cleanup;
+
+                  /* if the buffer size has not changed then assume no more processing is possible */
+                  if (numUsed == tcpBuf.m_used)
+                    break;
+
+                } /* while */
+
+            } /* while */
+
+          close (pState->m_tcpFd);
+          DBG (1, "ProcessUdpResponse: closed TCP connection to scanner\n");
+
+          /* signal end of session */
+          pState->m_bFinish = 1;
+
+        } /* if */
+
+    } /* while pItem */
+
+  return 0;
+
+cleanup:
+
+  FreeComBuf (&tcpBuf);
+  close (pState->m_tcpFd);
+  return 3;
+
+} /* ProcessUdpResponse */
+
+/***********************************************************/
+
+/* process TCP responses, \return 0 in success, >0 otherwise */
+int
+ProcessTcpResponse (struct ScannerState *pState, struct ComBuf *pTcpBuf)
+{
+
+  struct ComBuf buf;
+  unsigned short messageSize = 0, nameSize, valueSize, dataChunkSize;
+  unsigned char *pItem, *pEnd, *pValue;
+  unsigned char *pData = pTcpBuf->m_pBuf;
+  char *pName;
+  unsigned int uiVal;
+  int errorCheck = 0;
+  int bProcessImage = 0;
+
+  DBG (10, "ProcessTcpResponse: processing %lu bytes, pData=%p\n",
+       (unsigned long)pTcpBuf->m_used, pData);
+  HexDump (15, pData, pTcpBuf->m_used);
+
+  /* if message not complete then wait for more to arrive */
+  if (!MessageIsComplete (pData, pTcpBuf->m_used))
+    {
+      DBG (10, "ProcessTcpResponse: incomplete message, returning\n");
+      return 0;
+    }
+
+  /* init a buffer for our outbound messages */
+  if (InitComBuf (&buf))
+    {
+      errorCheck |= 1;
+      goto cleanup;
+    }
+
+  /* extract data size */
+  messageSize = (((unsigned short) (pData[6])) << 8) | pData[7];
+
+  /* loop through items in message */
+  pItem = pData + 8;
+  pEnd = pItem + messageSize;
+  while (pItem < pEnd)
+    {
+
+      pItem++;
+      nameSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+      pName = (char *) pItem;
+
+      pItem += nameSize;
+
+      pItem++;
+      valueSize = (((unsigned short) pItem[0]) << 8) | pItem[1];
+      pItem += 2;
+
+      pValue = pItem;
+
+      pItem += valueSize;
+
+      /* process the item */
+      if (!strncmp ("std-scan-session-open", pName, nameSize))
+        {
+
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-session-open-response", 0x05,
+                                   &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+
+        }
+      else if (!strncmp ("std-scan-getclientpref", pName, nameSize))
+        {
+
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-getclientpref-x1",
+                                   0x05, &uiVal, sizeof (uiVal));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-getclientpref-x2",
+                                   0x05, &uiVal, sizeof (uiVal));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-getclientpref-y1",
+                                   0x05, &uiVal, sizeof (uiVal));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-getclientpref-y2",
+                                   0x05, &uiVal, sizeof (uiVal));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-xresolution", 0x04,
+                                   &pState->m_xres, sizeof (pState->m_xres));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-yresolution", 0x04,
+                                   &pState->m_yres, sizeof (pState->m_yres));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-image-composition",
+                                   0x06, &pState->m_composition,
+                                   sizeof (pState->m_composition));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-brightness", 0x02,
+                                   &pState->m_brightness,
+                                   sizeof (pState->m_brightness));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-image-compression",
+                                   0x06, &pState->m_compression,
+                                   sizeof (pState->m_compression));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-file-type", 0x06,
+                                   &pState->m_fileType,
+                                   sizeof (pState->m_fileType));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-paper-size-detect",
+                                   0x06, &uiVal, sizeof (uiVal));
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-getclientpref-paper-scanner-type",
+                                   0x06, &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+
+        }
+      else if (!strncmp ("std-scan-document-start", pName, nameSize))
+        {
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-document-start-response", 0x05,
+                                   &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+        }
+      else if (!strncmp ("std-scan-document-file-type", pName, nameSize))
+        {
+          memcpy (&pState->m_fileType, pValue, sizeof (pState->m_fileType));
+          DBG (5, "File type: %x\n", ntohl (pState->m_fileType));
+        }
+      else
+        if (!strncmp ("std-scan-document-image-compression", pName, nameSize))
+        {
+          memcpy (&pState->m_compression, pValue,
+                  sizeof (pState->m_compression));
+          DBG (5, "Compression: %x\n", ntohl (pState->m_compression));
+
+        }
+      else if (!strncmp ("std-scan-document-xresolution", pName, nameSize))
+        {
+          memcpy (&pState->m_xres, pValue, sizeof (pState->m_xres));
+          DBG (5, "X resolution: %d\n", ntohs (pState->m_xres));
+        }
+      else if (!strncmp ("std-scan-document-yresolution", pName, nameSize))
+        {
+          memcpy (&pState->m_yres, pValue, sizeof (pState->m_yres));
+          DBG (5, "Y resolution: %d\n", ntohs (pState->m_yres));
+        }
+      else if (!strncmp ("std-scan-page-widthpixel", pName, nameSize))
+        {
+          if (1 || !pState->m_pixelWidth)
+            {
+              memcpy (&pState->m_pixelWidth, pValue,
+                      sizeof (pState->m_pixelWidth));
+              DBG (5, "Width: %d\n", ntohl (pState->m_pixelWidth));
+            }
+          else
+            {
+              DBG (5, "Ignoring width (already have a value)\n");
+            }
+        }
+      else if (!strncmp ("std-scan-page-heightpixel", pName, nameSize))
+        {
+          if (1 || !pState->m_pixelHeight)
+            {
+              memcpy (&pState->m_pixelHeight, pValue,
+                      sizeof (pState->m_pixelHeight));
+              DBG (5, "Height: %d\n", ntohl (pState->m_pixelHeight));
+            }
+          else
+            {
+              DBG (5, "Ignoring height (already have a value)\n");
+            }
+        }
+      else if (!strncmp ("std-scan-page-start", pName, nameSize))
+        {
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-page-start-response",
+                                   0x05, &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+
+          /* reset the data buffer ready to store a new page */
+          pState->m_buf.m_used = 0;
+
+          /* init current page size */
+          pState->m_currentPageBytes = 0;
+
+          pState->m_pixelWidth = 0;
+          pState->m_pixelHeight = 0;
+        }
+      else if (!strncmp ("std-scan-page-end", pName, nameSize))
+        {
+          bProcessImage = 1;
+
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22, "std-scan-page-end-response",
+                                   0x05, &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+        }
+      else if (!strncmp ("std-scan-document-end", pName, nameSize))
+        {
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-document-end-response", 0x05,
+                                   &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+
+          /* reset the data buffer ready to store a new page */
+          pState->m_buf.m_used = 0;
+        }
+      else if (!strncmp ("std-scan-session-end", pName, nameSize))
+        {
+          errorCheck |= InitPacket (&buf, 0x02);
+          uiVal = 0;
+          errorCheck |=
+            AppendMessageToPacket (&buf, 0x22,
+                                   "std-scan-session-end-response", 0x05,
+                                   &uiVal, sizeof (uiVal));
+          FinalisePacket (&buf);
+          send (pState->m_tcpFd, buf.m_pBuf, buf.m_used, 0);
+
+          /* initialise a shutodwn of the socket */
+          shutdown (pState->m_tcpFd, SHUT_RDWR);
+        }
+      else if (!strncmp ("std-scan-scandata-error", pName, nameSize))
+        {
+          /* determine the size of data in this chunk */
+          dataChunkSize = (pItem[6] << 8) + pItem[7];
+
+          pItem += 8;
+
+          DBG (10, "Reading %d bytes of scan data\n", dataChunkSize);
+
+          /* append message to buffer */
+          errorCheck |= AppendToComBuf (&pState->m_buf, pItem, dataChunkSize);
+
+          pItem += dataChunkSize;
+
+          DBG (10, "Accumulated %lu bytes of scan data so far\n",
+               (unsigned long)pState->m_buf.m_used);
+        } /* if */
+    } /* while */
+
+  /* process page data if required */ 
+  if ( bProcessImage ) errorCheck |= ProcessPageData (pState);
+
+cleanup:
+
+  /* remove processed data (including 8 byte header) from start of tcp buffer */
+  PopFromComBuf (pTcpBuf, messageSize + 8);
+
+  /* free com buf */
+  FreeComBuf (&buf);
+
+  return errorCheck;
+
+} /* ProcessTcpResponse */
+
+/***********************************************************/
+
+/* remove data from the front of a ComBuf struct
+   \return 0 if sucessful, >0 otherwise
+*/
+int
+PopFromComBuf (struct ComBuf *pBuf, size_t datSize)
+{
+
+  /* check if we're trying to remove more data than is present */
+  if (datSize > pBuf->m_used)
+    {
+      pBuf->m_used = 0;
+      return 1;
+    }
+
+  /* check easy cases */
+  if ((!datSize) || (datSize == pBuf->m_used))
+    {
+      pBuf->m_used -= datSize;
+      return 0;
+    }
+
+  /* move remaining memory contents to start */
+  memmove (pBuf->m_pBuf, pBuf->m_pBuf + datSize, pBuf->m_used - datSize);
+
+  pBuf->m_used -= datSize;
+  return 0;
+
+} /* PopFromComBuf */
+
+/***********************************************************/
+
+/* Process the data from a single scanned page, \return 0 in success, >0 otherwise */
+int
+ProcessPageData (struct ScannerState *pState)
+{
+
+  FILE *fTmp;
+  int fdTmp;
+  struct jpeg_source_mgr jpegSrcMgr;
+  struct JpegDataDecompState jpegCinfo;
+  struct jpeg_error_mgr jpegErr;
+  int numPixels, iPixel, width, height, scanLineSize, imageBytes;
+  int ret = 0;
+  struct PageInfo pageInfo;
+
+  JSAMPLE *pJpegLine = NULL;
+  uint32 *pTiffRgba = NULL;
+  unsigned char *pOut;
+  char tiffErrBuf[1024];
+
+  TIFF *pTiff = NULL;
+
+  /* If there's no data then there's nothing to write */
+  if (!pState->m_buf.m_used)
+    return 0;
+
+  DBG (1, "ProcessPageData: Got compression %x\n",
+       ntohl (pState->m_compression));
+
+  switch (ntohl (pState->m_compression))
+    {
+
+    case 0x20:
+      /* decode as JPEG if appropriate */
+      {
+
+        jpegSrcMgr.resync_to_restart = jpeg_resync_to_restart;
+        jpegSrcMgr.init_source = JpegDecompInitSource;
+        jpegSrcMgr.fill_input_buffer = JpegDecompFillInputBuffer;
+        jpegSrcMgr.skip_input_data = JpegDecompSkipInputData;
+        jpegSrcMgr.term_source = JpegDecompTermSource;
+
+        jpegCinfo.m_cinfo.err = jpeg_std_error (&jpegErr);
+        jpeg_create_decompress (&jpegCinfo.m_cinfo);
+        jpegCinfo.m_cinfo.src = &jpegSrcMgr;
+        jpegCinfo.m_bytesRemaining = pState->m_buf.m_used;
+        jpegCinfo.m_pData = pState->m_buf.m_pBuf;
+        
+        jpeg_read_header (&jpegCinfo.m_cinfo, TRUE);
+        jpeg_start_decompress (&jpegCinfo.m_cinfo);
+        
+        /* allocate space for a single scanline */
+        scanLineSize = jpegCinfo.m_cinfo.output_width
+          * jpegCinfo.m_cinfo.output_components;
+        DBG (1, "ProcessPageData: image dimensions: %d x %d, line size: %d\n",
+        jpegCinfo.m_cinfo.output_width,
+        jpegCinfo.m_cinfo.output_height, scanLineSize);
+
+        pJpegLine = calloc (scanLineSize, sizeof (JSAMPLE));
+        if (!pJpegLine)
+          {
+            DBG (1, "ProcessPageData: memory allocation error\n");
+            ret = 1;
+            goto JPEG_CLEANUP;
+          } /* if */
+
+        /* note dimensions - may be different from those previously reported */
+        pState->m_pixelWidth = htonl (jpegCinfo.m_cinfo.output_width);
+        pState->m_pixelHeight = htonl (jpegCinfo.m_cinfo.output_height);
+
+        /* decode scanlines */
+        while (jpegCinfo.m_cinfo.output_scanline
+               < jpegCinfo.m_cinfo.output_height)
+          {
+            DBG (20, "Reading scanline %d of %d\n",
+                 jpegCinfo.m_cinfo.output_scanline,
+                 jpegCinfo.m_cinfo.output_height);
+
+            /* read scanline */
+            jpeg_read_scanlines (&jpegCinfo.m_cinfo, &pJpegLine, 1);
+
+            /* append to output buffer */
+            ret |= AppendToComBuf (&pState->m_imageData,
+                                   pJpegLine, scanLineSize);
+
+          } /* while */
+
+        /* update info for this page */
+        pageInfo.m_width = jpegCinfo.m_cinfo.output_width;
+        pageInfo.m_height = jpegCinfo.m_cinfo.output_height;
+        pageInfo.m_totalSize = pageInfo.m_width * pageInfo.m_height * 3;
+        pageInfo.m_bytesRemaining = pageInfo.m_totalSize;
+
+        DBG( 1, "Process page data: page %d: JPEG image: %d x %d, %d bytes\n",
+             pState->m_numPages, pageInfo.m_width, pageInfo.m_height, pageInfo.m_totalSize );
+
+        ret |= AppendToComBuf( & pState->m_pageInfo, (unsigned char*)& pageInfo, sizeof( pageInfo ) );
+        ++( pState->m_numPages );
+
+      JPEG_CLEANUP:
+        jpeg_finish_decompress (&jpegCinfo.m_cinfo);
+        jpeg_destroy_decompress (&jpegCinfo.m_cinfo);
+
+        if (pJpegLine)
+          free (pJpegLine);
+
+        return ret;
+      } /* case JPEG */
+
+    case 0x08:
+      /* CCITT Group 4 Fax data */
+      {
+        /* get a temp file
+           :TODO: 2006-04-18: Use TIFFClientOpen and do everything in RAM
+         */
+        fTmp = tmpfile ();
+        fdTmp = fileno (fTmp);
+
+        pTiff = TIFFFdOpen (fdTmp, "tempfile", "w");
+        if (!pTiff)
+          {
+            DBG (1, "ProcessPageData: Error opening temp TIFF file");
+            ret = SANE_STATUS_IO_ERROR;
+            goto TIFF_CLEANUP;
+          }
+
+        /* create a TIFF file */
+        width = ntohl (pState->m_pixelWidth);
+        height = ntohl (pState->m_pixelHeight);
+        TIFFSetField (pTiff, TIFFTAG_IMAGEWIDTH, width);
+        TIFFSetField (pTiff, TIFFTAG_IMAGELENGTH, height);
+        TIFFSetField (pTiff, TIFFTAG_BITSPERSAMPLE, 1);
+        TIFFSetField (pTiff, TIFFTAG_PHOTOMETRIC, 0);        /* 0 is white */
+        TIFFSetField (pTiff, TIFFTAG_COMPRESSION, 4);        /* CCITT Group 4 */
+        TIFFSetField (pTiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+
+        TIFFWriteRawStrip (pTiff, 0, pState->m_buf.m_pBuf,
+                           pState->m_buf.m_used);
+
+        if (0 > TIFFRGBAImageOK (pTiff, tiffErrBuf))
+          {
+            DBG (1, "ProcessPageData: %s\n", tiffErrBuf);
+            ret = SANE_STATUS_IO_ERROR;
+            goto TIFF_CLEANUP;
+          }
+
+        /* allocate space for RGBA representation of image */
+        numPixels = height * width;
+        DBG (20, "ProcessPageData: num TIFF RGBA pixels: %d\n", numPixels);
+        if (!(pTiffRgba = calloc (numPixels, sizeof (u_long))))
+          {
+            ret = SANE_STATUS_NO_MEM;
+            goto TIFF_CLEANUP;
+          }
+
+        /* make space in image buffer to store the results */
+        imageBytes = width * height * 3;
+        ret |= AppendToComBuf (&pState->m_imageData, NULL, imageBytes);
+        if (ret)
+          goto TIFF_CLEANUP;
+
+        /* get a pointer to the start of the output data */
+        pOut = pState->m_imageData.m_pBuf
+          + pState->m_imageData.m_used - imageBytes;
+
+        /* read RGBA image */
+        DBG (20, "ProcessPageData: setting up read buffer\n");
+        TIFFReadBufferSetup (pTiff, NULL, width * height * sizeof (u_long));
+        DBG (20, "ProcessPageData: reading RGBA data\n");
+        TIFFReadRGBAImageOriented (pTiff, width, height, pTiffRgba,
+                                   ORIENTATION_TOPLEFT, 0);
+
+        /* loop over pixels */
+        for (iPixel = 0; iPixel < numPixels; ++iPixel)
+          {
+
+            *(pOut++) = TIFFGetR (pTiffRgba[iPixel]);
+            *(pOut++) = TIFFGetG (pTiffRgba[iPixel]);
+            *(pOut++) = TIFFGetB (pTiffRgba[iPixel]);
+
+          } /* for iRow */
+
+
+
+        /* update info for this page */
+        pageInfo.m_width = width;
+        pageInfo.m_height = height;
+        pageInfo.m_totalSize = pageInfo.m_width * pageInfo.m_height * 3;
+        pageInfo.m_bytesRemaining = pageInfo.m_totalSize;
+
+        DBG( 1, "Process page data: page %d: TIFF image: %d x %d, %d bytes\n",
+             pState->m_numPages, width, height, pageInfo.m_totalSize );
+
+        ret |= AppendToComBuf( & pState->m_pageInfo, (unsigned char*)& pageInfo, sizeof( pageInfo ) );
+        ++( pState->m_numPages );
+
+      TIFF_CLEANUP:
+        if (pTiff)
+          TIFFClose (pTiff);
+        if (fTmp)
+          fclose (fTmp);
+        if (pTiffRgba)
+          free (pTiffRgba);
+        return ret;
+
+      } /* case CCITT */
+    default:
+      /* this is not expected or very useful */
+      {
+        DBG (1, "ProcessPageData: Unexpected compression flag %d\n", ntohl (pState->m_compression));
+        ret = SANE_STATUS_IO_ERROR;
+      }
+    } /* switch */
+
+  return ret;
+} /* ProcessPageData */
+
+/***********************************************************/
+
+void
+JpegDecompInitSource (j_decompress_ptr cinfo)
+/* Libjpeg decompression interface */
+{
+  cinfo->src->bytes_in_buffer = 0;
+
+} /* JpegDecompInitSource */
+
+/***********************************************************/
+
+boolean
+JpegDecompFillInputBuffer (j_decompress_ptr cinfo)
+/* Libjpeg decompression interface */
+{
+  struct JpegDataDecompState *pState = (struct JpegDataDecompState *) cinfo;
+  static const unsigned char eoiByte[] = {
+    0xFF, JPEG_EOI
+  };
+
+  DBG (10, "JpegDecompFillInputBuffer: bytes remaining: %d\n",
+       pState->m_bytesRemaining);
+
+  if (!pState->m_bytesRemaining)
+    {
+
+      /* no input data available so return dummy data */
+      cinfo->src->bytes_in_buffer = 2;
+      cinfo->src->next_input_byte = (const JOCTET *) eoiByte;
+
+    }
+  else
+    {
+
+      /* point to data */
+      cinfo->src->bytes_in_buffer = pState->m_bytesRemaining;
+      cinfo->src->next_input_byte = (const JOCTET *) pState->m_pData;
+
+      /* note that data is now gone */
+      pState->m_bytesRemaining = 0;
+
+    } /* if */
+
+  return TRUE;
+
+} /* JpegDecompFillInputBuffer */
+
+/***********************************************************/
+
+void
+JpegDecompSkipInputData (j_decompress_ptr cinfo, long numBytes)
+/* Libjpeg decompression interface */
+{
+  DBG (10, "JpegDecompSkipInputData: skipping %ld bytes\n", numBytes);
+
+  cinfo->src->bytes_in_buffer -= numBytes;
+  cinfo->src->next_input_byte += numBytes;
+
+} /* JpegDecompSkipInputData */
+
+/***********************************************************/
+
+void
+JpegDecompTermSource (j_decompress_ptr __sane_unused__ cinfo)
+/* Libjpeg decompression interface */
+{
+  /* nothing to do */
+
+} /* JpegDecompTermSource */
+
+/***********************************************************/