diff options
Diffstat (limited to 'backend/dell1600n_net.c')
| -rw-r--r-- | backend/dell1600n_net.c | 2065 |
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 */ + +/***********************************************************/ |