/*
  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;
  size_t lineBufFree;

  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]);

      lineBufFree = sizeof (lineBuf) - strlen (lineBuf) - 1;
      strncat (lineBuf, itemBuf, lineBufFree);

      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, ".");
        }
      lineBufFree = sizeof (lineBuf) - strlen (lineBuf) - 1;
      strncat (lineBuf, itemBuf, lineBufFree);

    } /* for j */

      DBG (debugLevel, "%s\n", lineBuf);
      lineBuf[0] = 0;

    } /* for i */

  if (i % 16)
    {

      for (j = (i % 16); j < 16; ++j)
        {
          lineBufFree = sizeof (lineBuf) - strlen (lineBuf) - 1;
          strncat (lineBuf, "   ", lineBufFree);
        }
      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, ".");
            }
          lineBufFree = sizeof (lineBuf) - strlen (lineBuf) - 1;
          strncat (lineBuf, itemBuf, lineBufFree);
        }
      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;
  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;

      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 */

/***********************************************************/