diff options
Diffstat (limited to 'backend/magicolor.c')
| -rw-r--r-- | backend/magicolor.c | 3006 |
1 files changed, 3006 insertions, 0 deletions
diff --git a/backend/magicolor.c b/backend/magicolor.c new file mode 100644 index 0000000..e3cd80d --- /dev/null +++ b/backend/magicolor.c @@ -0,0 +1,3006 @@ +/* + * magicolor.c - SANE library for Magicolor scanners. + * + * (C) 2010 Reinhold Kainhofer <reinhold@kainhofer.com> + * + * Based on the epson2 sane backend: + * Based on Kazuhiro Sasayama previous + * Work on epson.[ch] file from the SANE package. + * Please see those files for additional copyrights. + * Copyright (C) 2006-10 Tower Technologies + * Author: Alessandro Zummo <a.zummo@towertech.it> + * + * 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, version 2. + */ + +#define MAGICOLOR_VERSION 0 +#define MAGICOLOR_REVISION 0 +#define MAGICOLOR_BUILD 1 + +/* debugging levels: + * + * 127 mc_recv buffer + * 125 mc_send buffer + * 35 fine-grained status and progress + * 30 sane_read + * 25 setvalue, getvalue, control_option + * 20 low-level (I/O) mc_* functions + * 15 mid-level mc_* functions + * 10 high-level cmd_* functions + * 7 open/close/attach + * 6 print_params + * 5 basic functions + * 3 status info and progress + * 2 scanner info and capabilities + * 1 errors & warnings + */ + +#include "sane/config.h" + +#include <limits.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <ctype.h> +#include <fcntl.h> +#include <unistd.h> +#include <errno.h> +#include <sys/time.h> +#include <math.h> +#include <poll.h> +#include <sys/types.h> +#ifdef HAVE_SYS_SOCKET_H +#include <sys/socket.h> +#endif + + +#if HAVE_LIBSNMP +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/library/snmp_transport.h> +#include <arpa/inet.h> +#endif + +#include "../include/sane/saneopts.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/sanei_tcp.h" +#include "../include/sane/sanei_udp.h" +#include "../include/sane/sanei_config.h" +#include "../include/sane/sanei_backend.h" + +#include "magicolor.h" + + +#define min(x,y) (((x)<(y))?(x):(y)) + + + +/**************************************************************************** + * Devices supported by this backend + ****************************************************************************/ + + + +/* Scanner command type + * | Start scan + * | | Poll for error + * | | | Stop scan? + * | | | | Query image parameters + * | | | | | set scan parameters + * | | | | | | Get status? + * | | | | | | | Read scanned data + * | | | | | | | | Unknown + * | | | | | | | | | Unknown + * | | | | | | | | | | Net wrapper command type + * | | | | | | | | | | | Net Welcome + * | | | | | | | | | | | | Net Lock + * | | | | | | | | | | | | | Net Lock ACK + * | | | | | | | | | | | | | | Net Unlock + * | | | | | | | | | | | | | | | +*/ +static struct MagicolorCmd magicolor_cmd[] = { + {"mc1690mf", CMD, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x12, NET, 0x00, 0x01, 0x02, 0x03} +}; + +static SANE_Int magicolor_default_resolutions[] = {150, 300, 600}; +static SANE_Int magicolor_default_depths[] = {1,8}; + +static struct MagicolorCap magicolor_cap[] = { + + /* KONICA MINOLTA magicolor 1690MF, USB ID 0x123b:2089 */ + { + 0x2089, "mc1690mf", "KONICA MINOLTA magicolor 1690MF", "1.3.6.1.4.1.183341.1.1.2.1.32.3.2", + -1, 0x85, + 600, {150, 600, 0}, magicolor_default_resolutions, 3, /* 600 dpi max, 3 resolutions */ + 8, magicolor_default_depths, /* color depth 8 default, 1 and 8 possible */ + {1, 9, 0}, /* brightness ranges (TODO!) */ + {0, SANE_FIX(0x13f8 * MM_PER_INCH / 600), 0}, {0, SANE_FIX(0x1b9c * MM_PER_INCH / 600), 0}, /* FBF x/y ranges (TODO!) */ + SANE_TRUE, SANE_FALSE, /* non-duplex ADF, x/y ranges (TODO!) */ + {0, SANE_FIX(0x1390 * MM_PER_INCH / 600), 0}, {0, SANE_FIX(0x20dc * MM_PER_INCH / 600), 0}, + } + +}; + +static int MC_SNMP_Timeout = 2500; +static int MC_Scan_Data_Timeout = 15000; +static int MC_Request_Timeout = 5000; + + + +/**************************************************************************** + * General configuration parameter definitions + ****************************************************************************/ + + +/* + * Definition of the mode_param struct, that is used to + * specify the valid parameters for the different scan modes. + * + * The depth variable gets updated when the bit depth is modified. + */ + +static struct mode_param mode_params[] = { + {0x00, 1, 1}, /* Lineart, 1 color, 1 bit */ + {0x02, 1, 24}, /* Grayscale, 1 color, 24 bit */ + {0x03, 3, 24} /* Color, 3 colors, 24 bit */ +}; + +static SANE_String_Const mode_list[] = { + SANE_VALUE_SCAN_MODE_LINEART, + SANE_VALUE_SCAN_MODE_GRAY, + SANE_VALUE_SCAN_MODE_COLOR, + NULL +}; + +static const SANE_String_Const adf_mode_list[] = { + SANE_I18N("Simplex"), + SANE_I18N("Duplex"), + NULL +}; + +/* Define the different scan sources */ + +#define FBF_STR SANE_I18N("Flatbed") +#define ADF_STR SANE_I18N("Automatic Document Feeder") + +/* + * source list need one dummy entry (save device settings is crashing). + * NOTE: no const - this list gets created while exploring the capabilities + * of the scanner. + */ + +static SANE_String_Const source_list[] = { + FBF_STR, + NULL, + NULL, + NULL +}; + +/* Some utility functions */ + +static size_t +max_string_size(const SANE_String_Const strings[]) +{ + size_t size, max_size = 0; + int i; + + for (i = 0; strings[i]; i++) { + size = strlen(strings[i]) + 1; + if (size > max_size) + max_size = size; + } + return max_size; +} + +static SANE_Status attach_one_usb(SANE_String_Const devname); +static SANE_Status attach_one_net(SANE_String_Const devname, unsigned int device); + +static void +print_params(const SANE_Parameters params) +{ + DBG(6, "params.format = %d\n", params.format); + DBG(6, "params.last_frame = %d\n", params.last_frame); + DBG(6, "params.bytes_per_line = %d\n", params.bytes_per_line); + DBG(6, "params.pixels_per_line = %d\n", params.pixels_per_line); + DBG(6, "params.lines = %d\n", params.lines); + DBG(6, "params.depth = %d\n", params.depth); +} + + + +/**************************************************************************** + * Low-level Network communication functions + ****************************************************************************/ + + +#define MAGICOLOR_SNMP_SYSDESCR_OID ".1.3.6.1.2.1.1.1.0" +#define MAGICOLOR_SNMP_SYSOBJECT_OID ".1.3.6.1.2.1.1.2.0" +#define MAGICOLOR_SNMP_MAC_OID ".1.3.6.1.2.1.2.2.1.6.1" +#define MAGICOLOR_SNMP_DEVICE_TREE ".1.3.6.1.4.1.18334.1.1.1.1.1" + + +/* We don't have a packet wrapper, which holds packet size etc., so we + don't have to use a *read_raw and a *_read function... */ +static int +sanei_magicolor_net_read(struct Magicolor_Scanner *s, unsigned char *buf, size_t wanted, + SANE_Status * status) +{ + size_t size, read = 0; + struct pollfd fds[1]; + + *status = SANE_STATUS_GOOD; + + /* poll for data-to-be-read (using a 5 seconds timeout) */ + fds[0].fd = s->fd; + fds[0].events = POLLIN; + if (poll (fds, 1, MC_Request_Timeout) <= 0) { + *status = SANE_STATUS_IO_ERROR; + return read; + } + + while (read < wanted) { + size = sanei_tcp_read(s->fd, buf + read, wanted - read); + + if (size == 0) + break; + + read += size; + } + + if (read < wanted) + *status = SANE_STATUS_IO_ERROR; + + return read; +} + +/* We need to optionally pad the buffer with 0x00 to send 64-byte chunks. + On the other hand, the 0x04 commands don't need this, so we need two + functions, one *_write function that pads the buffer and then calls + *_write_raw */ +static int +sanei_magicolor_net_write_raw(struct Magicolor_Scanner *s, + const unsigned char *buf, size_t buf_size, + SANE_Status *status) +{ + sanei_tcp_write(s->fd, buf, buf_size); + /* TODO: Check whether sending failed... */ + + *status = SANE_STATUS_GOOD; + return buf_size; +} + +static int +sanei_magicolor_net_write(struct Magicolor_Scanner *s, + const unsigned char *buf, size_t buf_size, + SANE_Status *status) +{ + size_t len = 64; + unsigned char *new_buf = malloc(len); + if (!new_buf) { + *status = SANE_STATUS_NO_MEM; + return 0; + } + memset(new_buf, 0x00, len); + if (buf_size > len) + buf_size = len; + if (buf_size) + memcpy(new_buf, buf, buf_size); + return sanei_magicolor_net_write_raw (s, new_buf, len, status); +} + +static SANE_Status +sanei_magicolor_net_open(struct Magicolor_Scanner *s) +{ + SANE_Status status; + unsigned char buf[5]; + + ssize_t read; + struct timeval tv; + struct MagicolorCmd *cmd = s->hw->cmd; + + tv.tv_sec = 5; + tv.tv_usec = 0; + + setsockopt(s->fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)); + + DBG(1, "%s\n", __func__); + + /* the scanner sends a kind of welcome msg */ + read = sanei_magicolor_net_read(s, buf, 3, &status); + if (read != 3) + return SANE_STATUS_IO_ERROR; + if (buf[0] != cmd->net_wrapper_cmd || buf[1] != cmd->net_welcome) { + DBG (32, "Invalid welcome message received, Expected 0x%02x %02x 00, but got 0x%02x %02x %02x\n", + cmd->net_wrapper_cmd, cmd->net_welcome, buf[0], buf[1], buf[2]); + return SANE_STATUS_IO_ERROR; + } else if (buf[2] != 0x00) { + /* TODO: Handle response "04 00 01", indicating an error! */ + DBG (32, "Welcome message received, busy status %02x\n", buf[2]); + /* TODO: Return a human-readable error message (Unable to connect to scanner, scanner is not ready) */ + return SANE_STATUS_DEVICE_BUSY; + } + + buf[0] = cmd->net_wrapper_cmd; + buf[1] = cmd->net_lock; + buf[2] = 0x00; + /* Copy the device's USB id to bytes 3-4: */ + buf[3] = s->hw->cap->id & 0xff; + buf[4] = (s->hw->cap->id >> 8) & 0xff; + + DBG(32, "Proper welcome message received, locking the scanner...\n"); + sanei_magicolor_net_write_raw(s, buf, 5, &status); + + read = sanei_magicolor_net_read(s, buf, 3, &status); + if (read != 3) + return SANE_STATUS_IO_ERROR; + if (buf[0] != cmd->net_wrapper_cmd || buf[1] != cmd->net_lock_ack || buf[2] != 0x00) { + DBG (32, "Welcome message received, Expected 0x%x %x 00, but got 0x%x %x %x\n", + cmd->net_wrapper_cmd, cmd->net_lock_ack, buf[0], buf[1], buf[2]); + return SANE_STATUS_IO_ERROR; + } + + DBG(32, "scanner locked\n"); + + return status; +} + +static SANE_Status +sanei_magicolor_net_close(struct Magicolor_Scanner *s) +{ + SANE_Status status; + struct MagicolorCmd *cmd = s->hw->cmd; + unsigned char buf[3]; + + DBG(1, "%s\n", __func__); + buf[0] = cmd->net_wrapper_cmd; + buf[1] = cmd->net_unlock; + buf[2] = 0x00; + sanei_magicolor_net_write_raw(s, buf, 3, &status); + return status; +} + + + +/**************************************************************************** + * Low-level USB communication functions + ****************************************************************************/ + +#define SANE_MAGICOLOR_VENDOR_ID (0x132b) + +SANE_Word sanei_magicolor_usb_product_ids[] = { + 0x2089, /* magicolor 1690MF */ + 0 /* last entry - this is used for devices that are specified + in the config file as "usb <vendor> <product>" */ +}; + +static int +sanei_magicolor_getNumberOfUSBProductIds (void) +{ + return sizeof (sanei_magicolor_usb_product_ids) / sizeof (SANE_Word); +} + + + + +/**************************************************************************** + * Magicolor low-level communication commands + ****************************************************************************/ + +static void dump_hex_buffer_dense (int level, const unsigned char *buf, size_t buf_size) +{ + size_t k; + char msg[1024], fmt_buf[1024]; + memset (&msg[0], 0x00, 1024); + memset (&fmt_buf[0], 0x00, 1024); + for (k = 0; k < min(buf_size, 80); k++) { + if (k % 16 == 0) { + if (k>0) { + DBG (level, "%s\n", msg); + memset (&msg[0], 0x00, 1024); + } + sprintf (fmt_buf, " 0x%04lx ", (unsigned long)k); + strcat (msg, fmt_buf); + } + if (k % 8 == 0) { + strcat (msg, " "); + } + sprintf (fmt_buf, " %02x" , buf[k]); + strcat (msg, fmt_buf); + } + if (msg[0] != 0 ) { + DBG (level, "%s\n", msg); + } +} + +/* Create buffers containing the command and arguments. Length of reserved + * buffer is returned. It's the caller's job to free the buffer! */ +static int mc_create_buffer (Magicolor_Scanner *s, unsigned char cmd_type, unsigned char cmd, + unsigned char **buf, unsigned char* arg1, size_t len1, + SANE_Status *status) +{ + unsigned char* b = NULL; + size_t buf_len = 2+4+len1+4; + NOT_USED (s); + if (len1 <= 0) + buf_len = 6; /* no args, just cmd + final 0x00 00 00 00 */ + *buf = b = malloc (buf_len); + memset (b, 0x00, buf_len); + if (!b) { + *status = SANE_STATUS_NO_MEM; + return 0; + } + b[0] = cmd_type; + b[1] = cmd; + if (len1>0) { + b[2] = len1 & 0xff; + b[3] = (len1 >> 8) & 0xff; + b[4] = (len1 >> 16) & 0xff; + b[5] = (len1 >> 24) & 0xff; + if (arg1) + memcpy(b+6, arg1, len1); + } + /* Writing the final 0x00 00 00 00 is not necessary, they are 0x00 already */ + *status = SANE_STATUS_GOOD; + return buf_len; +} + +static int mc_create_buffer2 (Magicolor_Scanner *s, unsigned char cmd_type, unsigned char cmd, + unsigned char **buf, unsigned char* arg1, size_t len1, + unsigned char* arg2, size_t len2, SANE_Status *status) +{ + unsigned char* b = NULL; + size_t buf_len = 2+4+len1+4+len2+4; + /* If any of the two args has size 0, use the simpler mc_create_buffer */ + if (len1<=0) + return mc_create_buffer (s, cmd_type, cmd, buf, arg2, len2, status); + else if (len2<=0) + return mc_create_buffer (s, cmd_type, cmd, buf, arg1, len1, status); + /* Allocate memory and copy over args and their lengths */ + *buf = b = malloc (buf_len); + if (!b) { + *status = SANE_STATUS_NO_MEM; + return 0; + } + memset (b, 0x00, buf_len); + b[0] = cmd_type; + b[1] = cmd; + /* copy over the argument length in lower endian */ + b[2] = len1 & 0xff; + b[3] = (len1 >> 8) & 0xff; + b[4] = (len1 >> 16) & 0xff; + b[5] = (len1 >> 24) & 0xff; + if (arg1) { + /* Copy the arguments */ + memcpy(b+6, arg1, len1); + } + /* copy over the second argument length in little endian */ + b[6+len1] = len2 & 0xff; + b[7+len1] = (len2 >> 8) & 0xff; + b[8+len1] = (len2 >> 16) & 0xff; + b[9+len1] = (len2 >> 24) & 0xff; + if (arg2) { + memcpy(b+10+len1, arg2, len2); + } + *status = SANE_STATUS_GOOD; + return buf_len; +} + +static int +mc_send(Magicolor_Scanner * s, void *buf, size_t buf_size, SANE_Status * status) +{ + DBG(15, "%s: size = %lu\n", __func__, (u_long) buf_size); + + if (DBG_LEVEL >= 125) { + const unsigned char *s = buf; + DBG(125, "Cmd: 0x%02x %02x, complete buffer:\n", s[0], s[1]); + dump_hex_buffer_dense (125, s, buf_size); + } + + if (s->hw->connection == SANE_MAGICOLOR_NET) { + return sanei_magicolor_net_write(s, buf, buf_size, status); + } else if (s->hw->connection == SANE_MAGICOLOR_USB) { + size_t n; + n = buf_size; + *status = sanei_usb_write_bulk(s->fd, buf, &n); + DBG(125, "USB: wrote %lu bytes, status: %s\n", (unsigned long)n, sane_strstatus(*status)); + return n; + } + + *status = SANE_STATUS_INVAL; + return 0; + /* never reached */ +} + +static ssize_t +mc_recv(Magicolor_Scanner * s, void *buf, ssize_t buf_size, + SANE_Status * status) +{ + ssize_t n = 0; + + DBG(15, "%s: size = %ld, buf = %p\n", __func__, (long) buf_size, buf); + + if (s->hw->connection == SANE_MAGICOLOR_NET) { + n = sanei_magicolor_net_read(s, buf, buf_size, status); + } else if (s->hw->connection == SANE_MAGICOLOR_USB) { + /* !!! only report an error if we don't read anything */ + n = buf_size; /* buf_size gets overwritten */ + *status = + sanei_usb_read_bulk(s->fd, (SANE_Byte *) buf, + (size_t *) & n); + + if (n > 0) + *status = SANE_STATUS_GOOD; + } + + if (n < buf_size) { + DBG(1, "%s: expected = %lu, got = %ld\n", __func__, + (u_long) buf_size, (long) n); + *status = SANE_STATUS_IO_ERROR; + } + + /* dump buffer if appropriate */ + if (DBG_LEVEL >= 127 && n > 0) { + const unsigned char* b=buf; + dump_hex_buffer_dense (125, b, buf_size); + } + + return n; +} + +/* Simple function to exchange a fixed amount of + * data with the scanner + */ +static SANE_Status +mc_txrx(Magicolor_Scanner * s, unsigned char *txbuf, size_t txlen, + unsigned char *rxbuf, size_t rxlen) +{ + SANE_Status status; + + mc_send(s, txbuf, txlen, &status); + if (status != SANE_STATUS_GOOD) { + DBG(1, "%s: tx err, %s\n", __func__, sane_strstatus(status)); + return status; + } + + mc_recv(s, rxbuf, rxlen, &status); + if (status != SANE_STATUS_GOOD) { + DBG(1, "%s: rx err, %s\n", __func__, sane_strstatus(status)); + } + + return status; +} + + + + + +/**************************************************************************** + * Magicolor high-level communication commands + ****************************************************************************/ + + +/** 0x03 09 01 - Request last error + * <- Information block (0x00 for OK, 0x01 for ERROR) + */ +static SANE_Status +cmd_request_error (SANE_Handle handle) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char params[1]; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + + if (s->hw->cmd->request_status == 0) + return SANE_STATUS_UNSUPPORTED; + + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->request_error, + &buf, NULL, 1, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + status = mc_txrx (s, buf, buflen, params, 1); + free(buf); + if (status != SANE_STATUS_GOOD) + return status; + + DBG(1, "status: %02x\n", params[0]); + + switch (params[0]) { + case STATUS_READY: + DBG(1, " ready\n"); + break; + case STATUS_ADF_JAM: + DBG(1, " paper jam in ADF\n"); + return SANE_STATUS_JAMMED; + break; + case STATUS_OPEN: + DBG(1, " printer door open or waiting for button press\n"); + return SANE_STATUS_COVER_OPEN; + break; + case STATUS_NOT_READY: + DBG(1, " scanner not ready (in use on another interface or warming up)\n"); + return SANE_STATUS_DEVICE_BUSY; + break; + default: + DBG(1, " unknown status 0x%x\n", params[0]); + } + return status; +} + +/** 0x03 0d - Request status command */ +static SANE_Status +cmd_request_status(SANE_Handle handle, unsigned char *b) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + if (!b) { + DBG(1, "%s called with NULL buffer\n", __func__); + return SANE_STATUS_INVAL; + } + memset (b, 0x00, 0x0b); /* initialize all 0x0b bytes with 0 */ + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->request_status, + &buf, NULL, 0x0b, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + status = mc_txrx (s, buf, buflen, b, 0x0b); + free (buf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Status NOT successfully retrieved\n", __func__); + else { + DBG(8, "%s: Status successfully retrieved:\n", __func__); + /* TODO: debug output of the returned parameters... */ + DBG (11, " ADF status: 0x%02x", b[1]); + if (b[1] & ADF_LOADED) { + DBG (11, " loaded\n"); + } else { + DBG (11, " not loaded\n"); + } + } + return status; +} + + +/** 0x03 08 - Start scan command */ +static SANE_Status +cmd_start_scan (SANE_Handle handle, size_t value) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char params1[4], params2[1]; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + /* Copy params to buffers */ + /* arg1 is expected returned bytes per line, 4-byte little endian */ + /* arg2 is unknown, seems to be always 0x00 */ + params1[0] = value & 0xff; + params1[1] = (value >> 8) & 0xff; + params1[2] = (value >> 16) & 0xff; + params1[3] = (value >> 24) & 0xff; + + params2[0] = 0x00; + buflen = mc_create_buffer2 (s, s->hw->cmd->scanner_cmd, s->hw->cmd->start_scanning, + &buf, params1, 4, params2, 1, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + mc_send(s, buf, buflen, &status); + free (buf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Data NOT successfully sent\n", __func__); + else + DBG(8, "%s: Data successfully sent\n", __func__); + return status; +} + +/** 0x03 0a - Cancel(?) Scan command */ +/* TODO: Does this command really mean CANCEL??? */ +static SANE_Status +cmd_cancel_scan (SANE_Handle handle) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->stop_scanning, + &buf, NULL, 0, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + mc_send(s, buf, buflen, &status); + free (buf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Data NOT successfully sent\n", __func__); + else + DBG(8, "%s: Data successfully sent\n", __func__); + return status; +} + +/** 0x03 12 - Finish(?) scan command */ +/* TODO: Does this command really mean FINISH??? */ +static SANE_Status +cmd_finish_scan (SANE_Handle handle) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *buf, returned[0x0b]; + size_t buflen; + + DBG(8, "%s\n", __func__); + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->unknown2, + &buf, NULL, 0x0b, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + memset (&returned[0], 0x00, 0x0b); + + status = mc_txrx (s, buf, buflen, returned, 0x0b); + free (buf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Data NOT successfully sent\n", __func__); + else + DBG(8, "%s: Data successfully sent\n", __func__); + return status; +} + +/** 0x03 0b - Get scanning parameters command + * input buffer seems to be 0x00 always */ +static SANE_Status +cmd_get_scanning_parameters(SANE_Handle handle, + SANE_Frame *format, SANE_Int *depth, + SANE_Int *data_pixels, SANE_Int *pixels_per_line, + SANE_Int *lines) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *txbuf, rxbuf[8]; + size_t buflen; + NOT_USED (format); + NOT_USED (depth); + + DBG(8, "%s\n", __func__); + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, + s->hw->cmd->request_scan_parameters, + &txbuf, NULL, 8, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + status = mc_txrx (s, txbuf, buflen, rxbuf, 8); + free (txbuf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Parameters NOT successfully retrieved\n", __func__); + else { + DBG(8, "%s: Parameters successfully retrieved\n", __func__); + + /* Assign px_per_line and lines. Bytes 7-8 must match 3-4 */ + if (rxbuf[2]!=rxbuf[6] || rxbuf[3]!=rxbuf[7]) { + DBG (1, "%s: ERROR: Returned image parameters indicate an " + "unsupported device: Bytes 3-4 do not match " + "bytes 7-8! Trying to continue with bytes 3-4.\n", + __func__); + dump_hex_buffer_dense (1, rxbuf, 8); + } + /* Read returned values, encoded in 2-byte little endian */ + *data_pixels = rxbuf[1] * 0x100 + rxbuf[0]; + *lines = rxbuf[3] * 0x100 + rxbuf[2]; + *pixels_per_line = rxbuf[5] * 0x100 + rxbuf[4]; + DBG (8, "%s: data_pixels = 0x%x (%u), lines = 0x%x (%u), " + "pixels_per_line = 0x%x (%u)\n", __func__, + *data_pixels, *data_pixels, + *lines, *lines, + *pixels_per_line, *pixels_per_line); + } + + return status; +} + +/** 0x03 0c - Set scanning parameters command */ +static SANE_Status +cmd_set_scanning_parameters(SANE_Handle handle, + unsigned char resolution, unsigned char color_mode, + unsigned char brightness, unsigned char contrast, + int tl_x, int tl_y, int width, int height, unsigned char source) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char param[0x11]; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + /* Copy over the params to the param byte array */ + /* Byte structure: + * byte 0: resolution + * byte 1: color mode + * byte 2: brightness + * byte 3: 0xff + * byte 4-5: x-start + * byte 6-7: y-start + * byte 8-9: x-extent + * byte 10-11: y-extent + * byte 12: source (ADF/FBF) + **/ + memset (¶m[0], 0x00, 0x11); + param[0] = resolution; + param[1] = color_mode; + param[2] = brightness; + param[3] = contrast | 0xff; /* TODO: Always 0xff? What about contrast? */ + /* Image coordinates are encoded 2-byte little endian: */ + param[4] = tl_x & 0xff; + param[5] = (tl_x >> 8) & 0xff; + param[6] = tl_y & 0xff; + param[7] = (tl_y >> 8) & 0xff; + param[8] = width & 0xff; + param[9] = (width >> 8) & 0xff; + param[10] = height & 0xff; + param[11] = (height >> 8) & 0xff; + + param[12] = source; + + /* dump buffer if appropriate */ + DBG (127, " Scanning parameter buffer:"); + dump_hex_buffer_dense (127, param, 0x11); + + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->set_scan_parameters, + &buf, param, 0x11, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + mc_send(s, buf, buflen, &status); + free (buf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Data NOT successfully sent\n", __func__); + else + DBG(8, "%s: Data successfully sent\n", __func__); + return status; +} + +/** 0x03 ?? - Request push button status command */ +#if 0 +static SANE_Status +cmd_request_push_button_status(SANE_Handle handle, unsigned char *bstatus) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *buf; + size_t buflen; + + DBG(8, "%s\n", __func__); + + + if (s->hw->cmd->unknown1 == 0) + return SANE_STATUS_UNSUPPORTED; + + DBG(8, "%s: Supported\n", __func__); + memset (bstatus, 0x00, 1); + buflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->unknown1, + &buf, bstatus, 1, &status); + if (buflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + status = mc_txrx (s, buf, buflen, bstatus, 1); + free(buf); + if (status != SANE_STATUS_GOOD) + return status; + + DBG(1, "push button status: %02x ", bstatus[0]); + switch (bstatus[0]) { + /* TODO: What's the response code for button pressed??? */ + default: + DBG(1, " unknown\n"); + status = SANE_STATUS_UNSUPPORTED; + } + return status; +} +#endif + +/** 0x03 0e - Read data command */ +static SANE_Status +cmd_read_data (SANE_Handle handle, unsigned char *buf, size_t len) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + unsigned char *txbuf; + unsigned char param[4]; + size_t txbuflen; + int oldtimeout = MC_Request_Timeout; + + DBG(8, "%s\n", __func__); + param[0] = len & 0xff; + param[1] = (len >> 8) & 0xff; + param[2] = (len >> 16) & 0xff; + param[3] = (len >> 24) & 0xff; + + txbuflen = mc_create_buffer (s, s->hw->cmd->scanner_cmd, s->hw->cmd->request_data, + &txbuf, param, 4, &status); + if (txbuflen <= 0 ) { + return SANE_STATUS_NO_MEM; + } else if (status != SANE_STATUS_GOOD) { + return status; + } + + /* Temporarily set the poll timeout to 10 seconds instead of 2, + * because a color scan needs >5 seconds to initialize. */ + MC_Request_Timeout = MC_Scan_Data_Timeout; + status = mc_txrx (s, txbuf, txbuflen, buf, len); + MC_Request_Timeout = oldtimeout; + free (txbuf); + if (status != SANE_STATUS_GOOD) + DBG(8, "%s: Image data NOT successfully retrieved\n", __func__); + else { + DBG(8, "%s: Image data successfully retrieved\n", __func__); + } + + return status; +} + + + +/* TODO: 0x03 0f command (unknown), 0x03 10 command (set button wait) */ + + + + +/**************************************************************************** + * Magicolor backend high-level operations + ****************************************************************************/ + + +static void +mc_dev_init(Magicolor_Device *dev, const char *devname, int conntype) +{ + DBG(5, "%s\n", __func__); + + dev->name = NULL; + dev->model = NULL; + dev->connection = conntype; + dev->sane.name = devname; + dev->sane.model = NULL; + dev->sane.type = "flatbed scanner"; + dev->sane.vendor = "Magicolor"; + dev->cap = &magicolor_cap[MAGICOLOR_CAP_DEFAULT]; + dev->cmd = &magicolor_cmd[MAGICOLOR_LEVEL_DEFAULT]; + /* Change default level when using a network connection */ + if (dev->connection == SANE_MAGICOLOR_NET) + dev->cmd = &magicolor_cmd[MAGICOLOR_LEVEL_NET]; +} + +static SANE_Status +mc_dev_post_init(struct Magicolor_Device *dev) +{ + DBG(5, "%s\n", __func__); + NOT_USED (dev); + /* Correct device parameters if needed */ + return SANE_STATUS_GOOD; +} + +static SANE_Status +mc_set_model(Magicolor_Scanner * s, const char *model, size_t len) +{ + unsigned char *buf; + unsigned char *p; + struct Magicolor_Device *dev = s->hw; + + buf = malloc(len + 1); + if (buf == NULL) + return SANE_STATUS_NO_MEM; + + memcpy(buf, model, len); + buf[len] = '\0'; + + p = &buf[len - 1]; + + while (*p == ' ') { + *p = '\0'; + p--; + } + + if (dev->model) + free(dev->model); + + dev->model = strndup((const char *) buf, len); + dev->sane.model = dev->model; + DBG(10, "%s: model is '%s'\n", __func__, dev->model); + + free(buf); + + return SANE_STATUS_GOOD; +} + +static void +mc_set_device (SANE_Handle handle, unsigned int device) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + Magicolor_Device *dev = s->hw; + const char* cmd_level; + int n; + + DBG(1, "%s: 0x%x\n", __func__, device); + + for (n = 0; n < NELEMS (magicolor_cap); n++) { + if (magicolor_cap[n].id == device) + break; + } + if (n < NELEMS(magicolor_cap)) { + dev->cap = &magicolor_cap[n]; + } else { + dev->cap = &magicolor_cap[MAGICOLOR_CAP_DEFAULT]; + DBG(1, " unknown device 0x%x, using default %s\n", + device, dev->cap->model); + } + mc_set_model (s, dev->cap->model, strlen (dev->cap->model)); + + cmd_level = dev->cap->cmds; + /* set command type and level */ + for (n = 0; n < NELEMS(magicolor_cmd); n++) { + if (!strcmp(cmd_level, magicolor_cmd[n].level)) + break; + } + + if (n < NELEMS(magicolor_cmd)) { + dev->cmd = &magicolor_cmd[n]; + } else { + dev->cmd = &magicolor_cmd[MAGICOLOR_LEVEL_DEFAULT]; + DBG(1, " unknown command level %s, using %s\n", + cmd_level, dev->cmd->level); + } +} + +static SANE_Status +mc_discover_capabilities(Magicolor_Scanner *s) +{ + SANE_Status status; + Magicolor_Device *dev = s->hw; + + SANE_String_Const *source_list_add = source_list; + + DBG(5, "%s\n", __func__); + + /* always add flatbed */ + *source_list_add++ = FBF_STR; + /* TODO: How can I check for existence of an ADF??? */ + if (dev->cap->ADF) + *source_list_add++ = ADF_STR; + + /* TODO: Is there any capability that we can extract from the + * device by some scanne command? So far, it looks like + * the device does not support any reporting. I don't even + * see a way to determine which device we are talking to! + */ + + + /* request error status */ + status = cmd_request_error(s); + if (status != SANE_STATUS_GOOD) + return status; + + dev->x_range = &dev->cap->fbf_x_range; + dev->y_range = &dev->cap->fbf_y_range; + + DBG(5, " x-range: %f %f\n", SANE_UNFIX(dev->x_range->min), SANE_UNFIX(dev->x_range->max)); + DBG(5, " y-range: %f %f\n", SANE_UNFIX(dev->y_range->min), SANE_UNFIX(dev->y_range->max)); + + DBG(5, "End of %s, status:%s\n", __func__, sane_strstatus(status)); + *source_list_add = NULL; /* add end marker to source list */ + return status; +} + +static SANE_Status +mc_setup_block_mode (Magicolor_Scanner *s) +{ + /* block_len should always be a multiple of bytes_per_line, so + * we retrieve only whole lines at once */ + s->block_len = (int)(0xff00/s->scan_bytes_per_line) * s->scan_bytes_per_line; + s->blocks = s->data_len / s->block_len; + s->last_len = s->data_len - (s->blocks * s->block_len); + if (s->last_len>0) + s->blocks++; + DBG(5, "%s: block_len=0x%x, last_len=0x%0x, blocks=%d\n", __func__, s->block_len, s->last_len, s->blocks); + s->counter = 0; + s->bytes_read_in_line = 0; + if (s->line_buffer) + free(s->line_buffer); + s->line_buffer = malloc(s->scan_bytes_per_line); + if (s->line_buffer == NULL) { + DBG(1, "out of memory (line %d)\n", __LINE__); + return SANE_STATUS_NO_MEM; + } + + + DBG (5, " %s: Setup block mode - scan_bytes_per_line=%d, pixels_per_line=%d, depth=%d, data_len=%x, block_len=%x, blocks=%d, last_len=%x\n", + __func__, s->scan_bytes_per_line, s->params.pixels_per_line, s->params.depth, s->data_len, s->block_len, s->blocks, s->last_len); + return SANE_STATUS_GOOD; +} + +/* Call the 0x03 0c command to set scanning parameters from the s->opt list */ +static SANE_Status +mc_set_scanning_parameters(Magicolor_Scanner * s) +{ + SANE_Status status; + unsigned char rs, source, brightness; + struct mode_param *mparam = &mode_params[s->val[OPT_MODE].w]; + SANE_Int scan_pixels_per_line = 0; + + DBG(1, "%s\n", __func__); + + /* Find the resolution in the res list and assign the index to buf[1] */ + for (rs=0; rs < s->hw->cap->res_list_size; rs++ ) { + if ( s->val[OPT_RESOLUTION].w == s->hw->cap->res_list[rs] ) + break; + } + + if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_BRIGHTNESS].cap)) { + brightness = s->val[OPT_BRIGHTNESS].w; + } else { + brightness = 5; + } + + /* ADF used? */ + if (strcmp(source_list[s->val[OPT_SOURCE].w], ADF_STR) == 0) { + /* Use ADF */ + source = 0x01; + } else { + source = 0x00; + } + + /* TODO: Any way to set PREVIEW??? */ + + /* Remaining bytes unused */ + status = cmd_set_scanning_parameters(s, + rs, mparam->flags, /* res, color mode */ + brightness, 0xff, /* brightness, contrast? */ + s->left, s->top, /* top/left start */ + s->width, s->height, /* extent */ + source); /* source */ + + if (status != SANE_STATUS_GOOD) + DBG (2, "%s: Command cmd_set_scanning_parameters failed, %s\n", + __func__, sane_strstatus(status)); + + /* Now query the scanner for the current image parameters */ + status = cmd_get_scanning_parameters (s, + &s->params.format, &s->params.depth, + &scan_pixels_per_line, + &s->params.pixels_per_line, &s->params.lines); + if (status != SANE_STATUS_GOOD) { + DBG (2, "%s: Command cmd_get_scanning_parameters failed, %s\n", + __func__, sane_strstatus(status)); + return status; + } + + /* Calculate how many bytes are really used per line */ + s->params.bytes_per_line = ceil (s->params.pixels_per_line * s->params.depth / 8.0); + if (s->val[OPT_MODE].w == MODE_COLOR) + s->params.bytes_per_line *= 3; + + /* Calculate how many bytes per line will be returned by the scanner. + * The values needed for this are returned by get_scannign_parameters */ + s->scan_bytes_per_line = ceil (scan_pixels_per_line * s->params.depth / 8.0); + if (s->val[OPT_MODE].w == MODE_COLOR) { + s->scan_bytes_per_line *= 3; + } + s->data_len = s->params.lines * s->scan_bytes_per_line; + + status = mc_setup_block_mode (s); + if (status != SANE_STATUS_GOOD) + DBG (2, "%s: Command mc_setup_block_mode failed, %s\n", + __func__, sane_strstatus(status)); + + DBG (1, "%s: bytes_read in line: %d\n", __func__, s->bytes_read_in_line); + + return status; +} + +static SANE_Status +mc_check_adf(Magicolor_Scanner * s) +{ + SANE_Status status; + unsigned char buf[0x0b]; + + DBG(5, "%s\n", __func__); + + status = cmd_request_status(s, buf); + if (status != SANE_STATUS_GOOD) + return status; + + if (!(buf[1] & ADF_LOADED)) + return SANE_STATUS_NO_DOCS; + + /* TODO: Check for jam in ADF */ + return SANE_STATUS_GOOD; +} + +static SANE_Status +mc_scan_finish(Magicolor_Scanner * s) +{ + SANE_Status status; + DBG(5, "%s\n", __func__); + + /* If we have not yet read all data, cancel the scan */ + if (s->buf && !s->eof) + status = cmd_cancel_scan (s); + + if (s->line_buffer) + free (s->line_buffer); + s->line_buffer = NULL; + free(s->buf); + s->buf = s->end = s->ptr = NULL; + + /* TODO: Any magicolor command for "scan finished"? */ + status = cmd_finish_scan (s); + + status = cmd_request_error(s); + if (status != SANE_STATUS_GOOD) + cmd_cancel_scan (s); + return status; + + /* XXX required? */ + /* TODO: cmd_reset(s);*/ + return SANE_STATUS_GOOD; +} + +static void +mc_copy_image_data(Magicolor_Scanner * s, SANE_Byte * data, SANE_Int max_length, + SANE_Int * length) +{ + DBG (1, "%s: bytes_read in line: %d\n", __func__, s->bytes_read_in_line); + if (s->params.format == SANE_FRAME_RGB) { + SANE_Int bytes_available, scan_pixels_per_line = s->scan_bytes_per_line/3; + *length = 0; + + while ((max_length >= s->params.bytes_per_line) && (s->ptr < s->end)) { + SANE_Int bytes_to_copy = s->scan_bytes_per_line - s->bytes_read_in_line; + /* First, fill the line buffer for the current line: */ + bytes_available = (s->end - s->ptr); + /* Don't copy more than we have buffer and available */ + if (bytes_to_copy > bytes_available) + bytes_to_copy = bytes_available; + + if (bytes_to_copy > 0) { + memcpy (s->line_buffer + s->bytes_read_in_line, s->ptr, bytes_to_copy); + s->ptr += bytes_to_copy; + s->bytes_read_in_line += bytes_to_copy; + } + + /* We have filled as much as possible of the current line + * with data from the scanner. If we have a complete line, + * copy it over. */ + if ((s->bytes_read_in_line >= s->scan_bytes_per_line) && + (s->params.bytes_per_line <= max_length)) + { + SANE_Int i; + SANE_Byte *line = s->line_buffer; + *length += s->params.bytes_per_line; + for (i=0; i< s->params.pixels_per_line; ++i) { + *data++ = line[0]; + *data++ = line[scan_pixels_per_line]; + *data++ = line[2 * scan_pixels_per_line]; + line++; + } + max_length -= s->params.bytes_per_line; + s->bytes_read_in_line -= s->scan_bytes_per_line; + } + } + + } else { + /* B/W and Grayscale use the same structure, so we use the same code */ + SANE_Int bytes_available; + *length = 0; + + while ((max_length != 0) && (s->ptr < s->end)) { + SANE_Int bytes_to_skip, bytes_to_copy; + bytes_available = (s->end - s->ptr); + bytes_to_copy = s->params.bytes_per_line - s->bytes_read_in_line; + bytes_to_skip = s->scan_bytes_per_line - s->bytes_read_in_line; + + /* Don't copy more than we have buffer */ + if (bytes_to_copy > max_length) { + bytes_to_copy = max_length; + bytes_to_skip = max_length; + } + + /* Don't copy/skip more bytes than we have read in */ + if (bytes_to_copy > bytes_available) + bytes_to_copy = bytes_available; + if (bytes_to_skip > bytes_available) + bytes_to_skip = bytes_available; + + if (bytes_to_copy > 0) { + /* we have not yet copied all pixels of the line */ + memcpy (data, s->ptr, bytes_to_copy); + max_length -= bytes_to_copy; + *length += bytes_to_copy; + data += bytes_to_copy; + } + if (bytes_to_skip > 0) { + s->ptr += bytes_to_skip; + s->bytes_read_in_line += bytes_to_skip; + } + if (s->bytes_read_in_line >= s->scan_bytes_per_line) + s->bytes_read_in_line -= s->scan_bytes_per_line; + + } + } +} + +static SANE_Status +mc_init_parameters(Magicolor_Scanner * s) +{ + int dpi, optres; + struct mode_param *mparam; + + DBG(5, "%s\n", __func__); + + memset(&s->params, 0, sizeof(SANE_Parameters)); + + dpi = s->val[OPT_RESOLUTION].w; + optres = s->hw->cap->optical_res; + + mparam = &mode_params[s->val[OPT_MODE].w]; + + if (SANE_UNFIX(s->val[OPT_BR_Y].w) == 0 || + SANE_UNFIX(s->val[OPT_BR_X].w) == 0) + return SANE_STATUS_INVAL; + + /* TODO: Use OPT_RESOLUTION or fixed 600dpi for left/top/width/height? */ + s->left = ((SANE_UNFIX(s->val[OPT_TL_X].w) / MM_PER_INCH) * optres) + 0.5; + + s->top = ((SANE_UNFIX(s->val[OPT_TL_Y].w) / MM_PER_INCH) * optres) + 0.5; + + s->width = + ((SANE_UNFIX(s->val[OPT_BR_X].w - + s->val[OPT_TL_X].w) / MM_PER_INCH) * optres) + 0.5; + + s->height = + ((SANE_UNFIX(s->val[OPT_BR_Y].w - + s->val[OPT_TL_Y].w) / MM_PER_INCH) * optres) + 0.5; + + s->params.pixels_per_line = s->width * dpi / optres + 0.5; + s->params.lines = s->height * dpi / optres + 0.5; + + + DBG(1, "%s: resolution = %d, preview = %d\n", + __func__, dpi, s->val[OPT_PREVIEW].w); + + DBG(1, "%s: %p %p tlx %f tly %f brx %f bry %f [mm]\n", + __func__, (void *) s, (void *) s->val, + SANE_UNFIX(s->val[OPT_TL_X].w), SANE_UNFIX(s->val[OPT_TL_Y].w), + SANE_UNFIX(s->val[OPT_BR_X].w), SANE_UNFIX(s->val[OPT_BR_Y].w)); + + /* + * The default color depth is stored in mode_params.depth: + */ + DBG(1, " %s, vor depth\n", __func__); + + if (mode_params[s->val[OPT_MODE].w].depth == 1) + s->params.depth = 1; + else + s->params.depth = s->val[OPT_BIT_DEPTH].w; + + s->params.last_frame = SANE_TRUE; + + s->params.bytes_per_line = ceil (s->params.depth * s->params.pixels_per_line / 8.0); + + switch (s->val[OPT_MODE].w) { + case MODE_BINARY: + case MODE_GRAY: + s->params.format = SANE_FRAME_GRAY; + break; + case MODE_COLOR: + s->params.format = SANE_FRAME_RGB; + s->params.bytes_per_line *= 3; + break; + } + + + DBG(1, "%s: Parameters are format=%d, bytes_per_line=%d, lines=%d\n", __func__, s->params.format, s->params.bytes_per_line, s->params.lines); + return (s->params.lines > 0) ? SANE_STATUS_GOOD : SANE_STATUS_INVAL; +} + +static SANE_Status +mc_start_scan(Magicolor_Scanner * s) +{ + SANE_Status status = cmd_start_scan (s, s->data_len); + if (status != SANE_STATUS_GOOD ) { + DBG (1, "%s: starting the scan failed (%s)\n", __func__, sane_strstatus(status)); + } + return status; +} + +static SANE_Status +mc_read(struct Magicolor_Scanner *s) +{ + SANE_Status status = SANE_STATUS_GOOD; + ssize_t buf_len = 0; + + /* did we passed everything we read to sane? */ + if (s->ptr == s->end) { + + if (s->eof) + return SANE_STATUS_EOF; + + s->counter++; + buf_len = s->block_len; + + if (s->counter == s->blocks && s->last_len) + buf_len = s->last_len; + + DBG(18, "%s: block %d/%d, size %lu\n", __func__, + s->counter, s->blocks, + (unsigned long) buf_len); + + /* receive image data + error code */ + status = cmd_read_data (s, s->buf, buf_len); + if (status != SANE_STATUS_GOOD) { + DBG (1, "%s: Receiving image data failed (%s)\n", + __func__, sane_strstatus(status)); + cmd_cancel_scan(s); + return status; + } + + DBG(18, "%s: successfully read %lu bytes\n", __func__, (unsigned long) buf_len); + + if (s->counter < s->blocks) { + if (s->canceling) { + cmd_cancel_scan(s); + return SANE_STATUS_CANCELLED; + } + } else + s->eof = SANE_TRUE; + + s->end = s->buf + buf_len; + s->ptr = s->buf; + } + + return status; +} + + + + +/**************************************************************************** + * SANE API implementation (high-level functions) + ****************************************************************************/ + + +static struct MagicolorCap * +mc_get_device_from_identification (const char*ident) +{ + int n; + for (n = 0; n < NELEMS (magicolor_cap); n++) { + if (strcmp (magicolor_cap[n].model, ident) || strcmp (magicolor_cap[n].OID, ident)) + return &magicolor_cap[n]; + } + return NULL; +} + + +/* + * close_scanner() + * + * Close the open scanner. Depending on the connection method, a different + * close function is called. + */ +static void +close_scanner(Magicolor_Scanner *s) +{ + DBG(7, "%s: fd = %d\n", __func__, s->fd); + + if (s->fd == -1) + return; + + mc_scan_finish(s); + if (s->hw->connection == SANE_MAGICOLOR_NET) { + sanei_magicolor_net_close(s); + sanei_tcp_close(s->fd); + } else if (s->hw->connection == SANE_MAGICOLOR_USB) { + sanei_usb_close(s->fd); + } + + s->fd = -1; +} + +static SANE_Bool +split_scanner_name (const char *name, char * IP, unsigned int *model) +{ + const char *device = name; + const char *qm; + *model = 0; + /* cut off leading net: */ + if (strncmp(device, "net:", 4) == 0) + device = &device[4]; + + qm = strchr(device, '?'); + if (qm != NULL) { + size_t len = qm-device; + strncpy (IP, device, len); + IP[len] = '\0'; + qm++; + if (strncmp(qm, "model=", 6) == 0) { + qm += 6; + if (!sscanf(qm, "0x%x", model)) + sscanf(qm, "%x", model); + } + } else { + strcpy (IP, device); + } + return SANE_TRUE; +} + +/* + * open_scanner() + * + * Open the scanner device. Depending on the connection method, + * different open functions are called. + */ + +static SANE_Status +open_scanner(Magicolor_Scanner *s) +{ + SANE_Status status = 0; + + DBG(7, "%s: %s\n", __func__, s->hw->sane.name); + + if (s->fd != -1) { + DBG(7, "scanner is already open: fd = %d\n", s->fd); + return SANE_STATUS_GOOD; /* no need to open the scanner */ + } + + if (s->hw->connection == SANE_MAGICOLOR_NET) { + /* device name has the form net:ipaddr?model=... */ + char IP[1024]; + unsigned int model = 0; + if (!split_scanner_name (s->hw->sane.name, IP, &model)) + return SANE_STATUS_INVAL; + status = sanei_tcp_open(IP, 4567, &s->fd); + if (model>0) + mc_set_device (s, model); + if (status == SANE_STATUS_GOOD) { + DBG(7, "awaiting welcome message\n"); + status = sanei_magicolor_net_open (s); + } + + } else if (s->hw->connection == SANE_MAGICOLOR_USB) { + status = sanei_usb_open(s->hw->sane.name, &s->fd); + if (s->hw->cap->out_ep>0) + sanei_usb_set_endpoint (s->fd, + USB_DIR_OUT | USB_ENDPOINT_TYPE_BULK, s->hw->cap->out_ep); + if (s->hw->cap->in_ep>0) + sanei_usb_set_endpoint (s->fd, + USB_DIR_IN | USB_ENDPOINT_TYPE_BULK, s->hw->cap->in_ep); + } + + if (status == SANE_STATUS_ACCESS_DENIED) { + DBG(1, "please check that you have permissions on the device.\n"); + DBG(1, "if this is a multi-function device with a printer,\n"); + DBG(1, "disable any conflicting driver (like usblp).\n"); + } + + if (status != SANE_STATUS_GOOD) + DBG(1, "%s open failed: %s\n", s->hw->sane.name, + sane_strstatus(status)); + else + DBG(3, "scanner opened\n"); + + return status; +} + +static SANE_Status +detect_usb(struct Magicolor_Scanner *s) +{ + SANE_Status status; + int vendor, product; + int i, numIds; + SANE_Bool is_valid; + + /* if the sanei_usb_get_vendor_product call is not supported, + * then we just ignore this and rely on the user to config + * the correct device. + */ + + status = sanei_usb_get_vendor_product(s->fd, &vendor, &product); + if (status != SANE_STATUS_GOOD) { + DBG(1, "the device cannot be verified - will continue\n"); + return SANE_STATUS_GOOD; + } + + /* check the vendor ID to see if we are dealing with an MAGICOLOR device */ + if (vendor != SANE_MAGICOLOR_VENDOR_ID) { + /* this is not a supported vendor ID */ + DBG(1, "not an Magicolor device at %s (vendor id=0x%x)\n", + s->hw->sane.name, vendor); + return SANE_STATUS_INVAL; + } + + numIds = sanei_magicolor_getNumberOfUSBProductIds(); + is_valid = SANE_FALSE; + i = 0; + + /* check all known product IDs to verify that we know + * about the device */ + while (i != numIds && !is_valid) { + if (product == sanei_magicolor_usb_product_ids[i]) + is_valid = SANE_TRUE; + i++; + } + + if (is_valid == SANE_FALSE) { + DBG(1, "the device at %s is not a supported (product id=0x%x)\n", + s->hw->sane.name, product); + return SANE_STATUS_INVAL; + } + + DBG(2, "found valid Magicolor scanner: 0x%x/0x%x (vendorID/productID)\n", + vendor, product); + + return SANE_STATUS_GOOD; +} + +/* + * used by attach* and sane_get_devices + * a ptr to a single-linked list of Magicolor_Device structs + * a ptr to a null term array of ptrs to SANE_Device structs + */ +static int num_devices; /* number of scanners attached to backend */ +static Magicolor_Device *first_dev; /* first MAGICOLOR scanner in list */ +static const SANE_Device **devlist = NULL; + +static struct Magicolor_Scanner * +scanner_create(struct Magicolor_Device *dev, SANE_Status *status) +{ + struct Magicolor_Scanner *s; + + s = malloc(sizeof(struct Magicolor_Scanner)); + if (s == NULL) { + *status = SANE_STATUS_NO_MEM; + return NULL; + } + + memset(s, 0x00, sizeof(struct Magicolor_Scanner)); + + s->fd = -1; + s->hw = dev; + + return s; +} + +static struct Magicolor_Scanner * +device_detect(const char *name, int type, SANE_Status *status) +{ + struct Magicolor_Scanner *s; + struct Magicolor_Device *dev; + + /* try to find the device in our list */ + for (dev = first_dev; dev; dev = dev->next) { + if (strcmp(dev->sane.name, name) == 0) { + dev->missing = 0; + DBG (10, "%s: Device %s already attached!\n", __func__, + name); + return scanner_create(dev, status); + } + } + + if (type == SANE_MAGICOLOR_NODEV) { + *status = SANE_STATUS_INVAL; + return NULL; + } + + /* alloc and clear our device structure */ + dev = malloc(sizeof(*dev)); + if (!dev) { + *status = SANE_STATUS_NO_MEM; + return NULL; + } + memset(dev, 0x00, sizeof(struct Magicolor_Device)); + + s = scanner_create(dev, status); + if (s == NULL) + return NULL; + + mc_dev_init(dev, name, type); + + *status = open_scanner(s); + if (*status != SANE_STATUS_GOOD) { + free(s); + return NULL; + } + + /* from now on, close_scanner() must be called */ + + /* USB requires special care */ + if (dev->connection == SANE_MAGICOLOR_USB) { + *status = detect_usb(s); + } + + if (*status != SANE_STATUS_GOOD) + goto close; + + /* set name and model (if not already set) */ + if (dev->model == NULL) + mc_set_model(s, "generic", 7); + + dev->name = strdup(name); + dev->sane.name = dev->name; + + *status = mc_discover_capabilities(s); + if (*status != SANE_STATUS_GOOD) + goto close; + + if (source_list[0] == NULL || dev->cap->dpi_range.min == 0) { + DBG(1, "something is wrong in the discovery process, aborting.\n"); + *status = SANE_STATUS_IO_ERROR; + goto close; + } + + mc_dev_post_init(dev); + + /* add this scanner to the device list */ + num_devices++; + dev->missing = 0; + dev->next = first_dev; + first_dev = dev; + + return s; + + close: + close_scanner(s); + free(s); + return NULL; +} + +#if HAVE_LIBSNMP + +/* Keep a linked list of already observed IP addresses */ +/* typedef struct snmp_ip SNMP_IP; */ +typedef struct snmp_ip { + char ip_addr[1024]; + struct snmp_ip*next; +} snmp_ip; + +typedef struct { + int nr; + snmp_ip*handled; + snmp_ip*detected; +} snmp_discovery_data; + + +/** Handle one SNMP response (whether received sync or async) and if describes + * a magicolor device, attach it. Returns the number of attached devices (0 + * or 1) */ +static int +mc_network_discovery_handle (struct snmp_pdu *pdu, snmp_discovery_data *magic) +{ + netsnmp_variable_list *varlist = pdu->variables, *vp; + oid anOID[MAX_OID_LEN]; + size_t anOID_len = MAX_OID_LEN; + /* Device information variables */ + char ip_addr[1024]; + char model[1024]; + char device[1024]; + /* remote IP detection variables */ + netsnmp_indexed_addr_pair *responder = (netsnmp_indexed_addr_pair *) pdu->transport_data; + struct sockaddr_in *remote = NULL; + struct MagicolorCap *cap; + snmp_ip *ip = NULL; + + DBG(5, "%s: Handling SNMP response \n", __func__); + + if (responder == NULL || pdu->transport_data_length != sizeof(netsnmp_indexed_addr_pair )) { + DBG(1, "%s: Unable to extract IP address from SNMP response.\n", + __func__); + return 0; + } + remote = (struct sockaddr_in *) &(responder->remote_addr); + if (remote == NULL) { + DBG(1, "%s: Unable to extract IP address from SNMP response.\n", + __func__); + return 0; + } + snprintf(ip_addr, sizeof(ip_addr), "%s", inet_ntoa(remote->sin_addr)); + DBG(35, "%s: IP Address of responder is %s\n", __func__, ip_addr); + if (magic) + ip = magic->handled; + while (ip) { + if (strcmp (ip->ip_addr, ip_addr) == 0) { + DBG (5, "%s: Already handled device %s, skipping\n", __func__, ip_addr); + return 0; + } + ip = ip->next; + } + if (magic) { + snmp_ip *new_handled = malloc(sizeof(snmp_ip)); + strcpy (&new_handled->ip_addr[0], ip_addr); + new_handled->next = magic->handled; + magic->handled = new_handled; + } + + /* System Object ID (Unique OID identifying model) + * This determines whether we really have a magicolor device */ + anOID_len = MAX_OID_LEN; + read_objid(MAGICOLOR_SNMP_SYSOBJECT_OID, anOID, &anOID_len); + vp = find_varbind_in_list (varlist, anOID, anOID_len); + if (vp) { + size_t value_len = vp->val_len/sizeof(oid); + if (vp->type != ASN_OBJECT_ID) { + DBG (3, "%s: SystemObjectID does not return an OID, device is not a magicolor device\n", __func__); + return 0; + } + snprint_objid (device, sizeof(device), vp->val.objid, value_len); + DBG (5, "%s: Device object ID is '%s'\n", __func__, device); + + anOID_len = MAX_OID_LEN; + read_objid (MAGICOLOR_SNMP_DEVICE_TREE, anOID, &anOID_len); + if (netsnmp_oid_is_subtree (anOID, anOID_len, + vp->val.objid, value_len) == 0) { + DBG (5, "%s: Device appears to be a magicolor device (OID=%s)\n", __func__, device); + } else { + DBG (5, "%s: Device is not a Magicolor device\n", __func__); + return 0; + } + } + + /* Retrieve sysDescr (i.e. model name) */ + anOID_len = MAX_OID_LEN; + read_objid(MAGICOLOR_SNMP_SYSDESCR_OID, anOID, &anOID_len); + vp = find_varbind_in_list (varlist, anOID, anOID_len); + if (vp) { + memcpy(model,vp->val.string,vp->val_len); + model[vp->val_len] = '\0'; + DBG (5, "%s: Found model: %s\n", __func__, model); + } + + DBG (1, "%s: Detected device '%s' on IP %s\n", + __func__, model, ip_addr); + + vp = pdu->variables; + /* TODO: attach the IP with attach_one_net(ip) */ + cap = mc_get_device_from_identification (device); + if (cap) { + DBG(1, "%s: Found autodiscovered device: %s (type 0x%x)\n", __func__, cap->model, cap->id); + attach_one_net (ip_addr, cap->id); + if (magic) { + snmp_ip *new_detected = malloc(sizeof(snmp_ip)); + strcpy (&new_detected->ip_addr[0], ip_addr); + new_detected->next = magic->detected; + magic->detected = new_detected; + } + return 1; + } + return 0; +} + +static int +mc_network_discovery_cb (int operation, struct snmp_session *sp, int reqid, + struct snmp_pdu *pdu, void *magic) +{ + NOT_USED (reqid); + NOT_USED (sp); + DBG(5, "%s: Received broadcast response \n", __func__); + + if (operation == NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE) { + snmp_discovery_data *m = (snmp_discovery_data*)magic; + int nr = mc_network_discovery_handle (pdu, m); + m->nr += nr; + DBG(5, "%s: Added %d discovered host(s) for SNMP response.\n", __func__, nr); + } + + return 0; +} +#endif + +/* Use SNMP for automatic network discovery. If host is given, try to detect + * that one host (using sync SNMP, otherwise send an SNMP broadcast (async). + */ +static int +mc_network_discovery(const char*host) +{ +#if HAVE_LIBSNMP + netsnmp_session session, *ss; + netsnmp_pdu *pdu; + oid anOID[MAX_OID_LEN]; + size_t anOID_len = MAX_OID_LEN; + snmp_discovery_data magic; + magic.nr = 0; + magic.handled = 0; + magic.detected = 0; + + DBG(1, "%s: running network discovery \n", __func__); + + /* Win32: init winsock */ + SOCK_STARTUP; + init_snmp("sane-magicolor-backend"); + snmp_sess_init (&session); + session.version = SNMP_VERSION_2c; + session.community = "public"; + session.community_len = strlen (session.community); + if (host) { + session.peername = host; + } else { + /* Do a network discovery via a broadcast */ + session.peername = "255.255.255.255"; + session.flags |= SNMP_FLAGS_UDP_BROADCAST; + session.callback = mc_network_discovery_cb; + session.callback_magic = &magic; + } + + ss = snmp_open (&session); /* establish the session */ + if (!ss) { + snmp_sess_perror ("ack", &session); + SOCK_CLEANUP; + return 0; + } + + /* Create the PDU for the data for our request and add the three + * desired OIDs to the PDU */ + pdu = snmp_pdu_create (SNMP_MSG_GET); + + /* SNMPv2-MIB::sysDescr.0 */ + anOID_len = MAX_OID_LEN; + if (read_objid(MAGICOLOR_SNMP_SYSDESCR_OID, anOID, &anOID_len)) { + snmp_add_null_var (pdu, anOID, anOID_len); + } + /* SNMPv2-MIB::sysObjectID.0 */ + anOID_len = MAX_OID_LEN; + if (read_objid(MAGICOLOR_SNMP_SYSOBJECT_OID, anOID, &anOID_len)) { + snmp_add_null_var (pdu, anOID, anOID_len); + } + /* IF-MIB::ifPhysAddress.1 */ + anOID_len = MAX_OID_LEN; + if (read_objid(MAGICOLOR_SNMP_MAC_OID, anOID, &anOID_len)) { + snmp_add_null_var (pdu, anOID, anOID_len); + } + /* TODO: Add more interesting OIDs, in particular vendor OIDs */ + + /* Now send out the request and wait for responses for some time. + * If we get a response, connect to that device (in the callback), + * otherwise we probably don't have a magicolor device in the + * LAN (or SNMP is turned off, in which case we have no way to detect + * it. + */ + DBG(100, "%s: Sending SNMP packet\n", __func__); + if (host) { + /* sync request to given hostname, immediately read the reply */ + netsnmp_pdu *response = 0; + int status = snmp_synch_response(ss, pdu, &response); + if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) { + magic.nr = mc_network_discovery_handle (response, &magic); + } + if (response) + snmp_free_pdu(response); + + + } else { + /* No hostname, so do a broadcast */ + struct timeval nowtime, endtime; /* end time for SNMP scan */ + struct timeval timeout; + int i=0; + + if (!snmp_send(ss, pdu)) { + snmp_free_pdu(pdu); + DBG(100, "%s: Sending SNMP packet NOT successful\n", __func__); + return 0; + } + /* listen for responses for MC_AutoDetectionTimeout milliseconds: */ + /* First get the final timeout time */ + gettimeofday (&nowtime, NULL); + timeout.tv_sec = MC_SNMP_Timeout / 1000; + timeout.tv_usec = (MC_SNMP_Timeout % 1000) * 1000; + timeradd (&nowtime, &timeout, &endtime); + + while (timercmp(&nowtime, &endtime, <)) { + int fds = 0, block = 0; + fd_set fdset; + DBG(1, " loop=%d\n", i++); + timeout.tv_sec = 0; + /* Use a 125ms timeout for select. If we get a response, + * the loop will be entered earlier again, anyway */ + timeout.tv_usec = 125000; + FD_ZERO (&fdset); + snmp_select_info (&fds, &fdset, &timeout, &block); + fds = select (fds, &fdset, NULL, NULL, /*block?NULL:*/&timeout); + if (fds) snmp_read(&fdset); + else snmp_timeout(); + gettimeofday(&nowtime, NULL); + } + /* Clean up the data in magic */ + while (magic.handled) { + snmp_ip *tmp = magic.handled->next; + free (magic.handled); + magic.handled = tmp; + } + while (magic.detected) { + snmp_ip *tmp = magic.detected->next; + free (magic.detected); + magic.detected = tmp; + } + } + + /* Clean up */ + snmp_close(ss); + SOCK_CLEANUP; + DBG (5, "%s: Discovered %d host(s)\n", __func__, magic.nr); + return magic.nr; + +#else + DBG (1, "%s: net-snmp library not enabled, auto-detecting network scanners not supported.\n", __func__); + NOT_USED (host); + return 0; +#endif +} + +static SANE_Status +attach(const char *name, int type) +{ + SANE_Status status; + Magicolor_Scanner *s; + + DBG(7, "%s: devname = %s, type = %d\n", __func__, name, type); + + s = device_detect(name, type, &status); + if(s == NULL) + return status; + + close_scanner(s); + free(s); + return status; +} + +SANE_Status +attach_one_usb(const char *dev) +{ + DBG(7, "%s: dev = %s\n", __func__, dev); + return attach(dev, SANE_MAGICOLOR_USB); +} + +static SANE_Status +attach_one_net(const char *dev, unsigned int model) +{ + char name[1024]; + + DBG(7, "%s: dev = %s\n", __func__, dev); + if (model > 0) { + snprintf(name, 1024, "net:%s?model=0x%x", dev, model); + } else { + snprintf(name, 1024, "net:%s", dev); + } + + return attach(name, SANE_MAGICOLOR_NET); +} + +static SANE_Status +attach_one_config(SANEI_Config __sane_unused__ *config, const char *line) +{ + int vendor, product, timeout; + + int len = strlen(line); + + DBG(7, "%s: len = %d, line = %s\n", __func__, len, line); + + if (sscanf(line, "usb %i %i", &vendor, &product) == 2) { + /* add the vendor and product IDs to the list of + * known devices before we call the attach function */ + + int numIds = sanei_magicolor_getNumberOfUSBProductIds(); + + if (vendor != SANE_MAGICOLOR_VENDOR_ID) + return SANE_STATUS_INVAL; /* this is not a KONICA MINOLTA device */ + + sanei_magicolor_usb_product_ids[numIds - 1] = product; + sanei_usb_attach_matching_devices(line, attach_one_usb); + + } else if (strncmp(line, "usb", 3) == 0 && len == 3) { + int i, numIds; + + numIds = sanei_magicolor_getNumberOfUSBProductIds(); + + for (i = 0; i < numIds; i++) { + sanei_usb_find_devices(SANE_MAGICOLOR_VENDOR_ID, + sanei_magicolor_usb_product_ids[i], attach_one_usb); + } + + } else if (strncmp(line, "net", 3) == 0) { + + /* remove the "net" sub string */ + const char *name = sanei_config_skip_whitespace(line + 3); + char IP[1024]; + unsigned int model = 0; + + if (strncmp(name, "autodiscovery", 13) == 0) { + DBG (50, "%s: Initiating network autodiscovervy via SNMP\n", __func__); + mc_network_discovery(NULL); + } else if (sscanf(name, "%s %x", IP, &model) == 2) { + DBG(50, "%s: Using network device on IP %s, forcing model 0x%x\n", __func__, IP, model); + attach_one_net(IP, model); + } else { + /* use SNMP to detect the type. If not successful, + * add the host with model type 0 */ + DBG(50, "%s: Using network device on IP %s, trying to autodetect model\n", __func__, IP); + if (mc_network_discovery(name)==0) { + DBG(1, "%s: Autodetecting device model failed, using default model\n", __func__); + attach_one_net(name, 0); + } + } + + } else if (sscanf(line, "snmp-timeout %i\n", &timeout)) { + /* Timeout for SNMP network discovery */ + DBG(50, "%s: SNMP timeout set to %d\n", __func__, timeout); + MC_SNMP_Timeout = timeout; + + } else if (sscanf(line, "scan-data-timeout %i\n", &timeout)) { + /* Timeout for scan data requests */ + DBG(50, "%s: Scan data timeout set to %d\n", __func__, timeout); + MC_Scan_Data_Timeout = timeout; + + } else if (sscanf(line, "request-timeout %i\n", &timeout)) { + /* Timeout for all other read requests */ + DBG(50, "%s: Request timeout set to %d\n", __func__, timeout); + MC_Request_Timeout = timeout; + + } else { + /* TODO: Warning about unparsable line! */ + } + + return SANE_STATUS_GOOD; +} + +static void +free_devices(void) +{ + Magicolor_Device *dev, *next; + + DBG(5, "%s\n", __func__); + + for (dev = first_dev; dev; dev = next) { + next = dev->next; + free(dev->name); + free(dev->model); + free(dev); + } + + if (devlist) + free(devlist); + devlist = NULL; + first_dev = NULL; +} + +SANE_Status +sane_init(SANE_Int *version_code, SANE_Auth_Callback __sane_unused__ authorize) +{ + DBG_INIT(); + DBG(2, "%s: " PACKAGE " " VERSION "\n", __func__); + + DBG(1, "magicolor backend, version %i.%i.%i\n", + MAGICOLOR_VERSION, MAGICOLOR_REVISION, MAGICOLOR_BUILD); + + if (version_code != NULL) + *version_code = SANE_VERSION_CODE(SANE_CURRENT_MAJOR, V_MINOR, + MAGICOLOR_BUILD); + + sanei_usb_init(); + + return SANE_STATUS_GOOD; +} + +/* Clean up the list of attached scanners. */ +void +sane_exit(void) +{ + DBG(5, "%s\n", __func__); + free_devices(); +} + +SANE_Status +sane_get_devices(const SANE_Device ***device_list, SANE_Bool __sane_unused__ local_only) +{ + Magicolor_Device *dev, *s, *prev=0; + int i; + + DBG(5, "%s\n", __func__); + + sanei_usb_init(); + + /* mark all existing scanners as missing, attach_one will remove mark */ + for (s = first_dev; s; s = s->next) { + s->missing = 1; + } + + /* Read the config, mark each device as found, possibly add new devs */ + sanei_configure_attach(MAGICOLOR_CONFIG_FILE, NULL, + attach_one_config); + + /*delete missing scanners from list*/ + for (s = first_dev; s;) { + if (s->missing) { + DBG (5, "%s: missing scanner %s\n", __func__, s->name); + + /*splice s out of list by changing pointer in prev to next*/ + if (prev) { + prev->next = s->next; + free (s); + s = prev->next; + num_devices--; + } else { + /*remove s from head of list */ + first_dev = s->next; + free(s); + s = first_dev; + prev=NULL; + num_devices--; + } + } else { + prev = s; + s = prev->next; + } + } + + DBG (15, "%s: found %d scanner(s)\n", __func__, num_devices); + for (s = first_dev; s; s=s->next) { + DBG (15, "%s: found scanner %s\n", __func__, s->name); + } + + if (devlist) + free (devlist); + + devlist = malloc((num_devices + 1) * sizeof(devlist[0])); + if (!devlist) { + DBG(1, "out of memory (line %d)\n", __LINE__); + return SANE_STATUS_NO_MEM; + } + + DBG(5, "%s - results:\n", __func__); + + for (i = 0, dev = first_dev; i < num_devices && dev; dev = dev->next, i++) { + DBG(1, " %d (%d): %s\n", i, dev->connection, dev->model); + devlist[i] = &dev->sane; + } + + devlist[i] = NULL; + + if(device_list){ + *device_list = devlist; + } + + return SANE_STATUS_GOOD; +} + +static SANE_Status +init_options(Magicolor_Scanner *s) +{ + int i; + SANE_Word *res_list; + + for (i = 0; i < NUM_OPTIONS; i++) { + s->opt[i].size = sizeof(SANE_Word); + s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; + s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; + s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; + s->val[OPT_NUM_OPTS].w = NUM_OPTIONS; + + /* "Scan Mode" group: */ + + s->opt[OPT_MODE_GROUP].name = SANE_NAME_STANDARD; + s->opt[OPT_MODE_GROUP].title = SANE_TITLE_STANDARD; + s->opt[OPT_MODE_GROUP].desc = SANE_DESC_STANDARD; + s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; + s->opt[OPT_MODE_GROUP].cap = 0; + + /* scan mode */ + s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; + s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; + s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; + s->opt[OPT_MODE].type = SANE_TYPE_STRING; + s->opt[OPT_MODE].size = max_string_size(mode_list); + s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + s->opt[OPT_MODE].constraint.string_list = mode_list; + s->val[OPT_MODE].w = 0; /* Binary */ + + /* bit depth */ + s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH; + s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH; + s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH; + s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT; + s->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_NONE; + s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST; + s->opt[OPT_BIT_DEPTH].constraint.word_list = s->hw->cap->depth_list; + s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE; + s->val[OPT_BIT_DEPTH].w = s->hw->cap->depth_list[1]; /* the first "real" element is the default */ + + if (s->hw->cap->depth_list[0] == 1) /* only one element in the list -> hide the option */ + s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE; + + + /* brightness */ + s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; + s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; + s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; + s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; + s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; + s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_BRIGHTNESS].constraint.range = &s->hw->cap->brightness; + s->val[OPT_BRIGHTNESS].w = 5; /* Normal */ + + /* resolution */ + s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; + s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; + s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; + s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; + s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; + s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; + res_list = malloc((s->hw->cap->res_list_size + 1) * sizeof(SANE_Word)); + if (res_list == NULL) { + return SANE_STATUS_NO_MEM; + } + *(res_list) = s->hw->cap->res_list_size; + memcpy(&(res_list[1]), s->hw->cap->res_list, s->hw->cap->res_list_size * sizeof(SANE_Word)); + s->opt[OPT_RESOLUTION].constraint.word_list = res_list; + s->val[OPT_RESOLUTION].w = s->hw->cap->dpi_range.min; + + + /* preview */ + s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; + s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; + s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; + s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; + s->val[OPT_PREVIEW].w = SANE_FALSE; + + /* source */ + s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE; + s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE; + s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE; + s->opt[OPT_SOURCE].type = SANE_TYPE_STRING; + s->opt[OPT_SOURCE].size = max_string_size(source_list); + s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + s->opt[OPT_SOURCE].constraint.string_list = source_list; + s->val[OPT_SOURCE].w = 0; /* always use Flatbed as default */ + + s->opt[OPT_ADF_MODE].name = "adf-mode"; + s->opt[OPT_ADF_MODE].title = SANE_I18N("ADF Mode"); + s->opt[OPT_ADF_MODE].desc = + SANE_I18N("Selects the ADF mode (simplex/duplex)"); + s->opt[OPT_ADF_MODE].type = SANE_TYPE_STRING; + s->opt[OPT_ADF_MODE].size = max_string_size(adf_mode_list); + s->opt[OPT_ADF_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; + s->opt[OPT_ADF_MODE].constraint.string_list = adf_mode_list; + s->val[OPT_ADF_MODE].w = 0; /* simplex */ + if ((!s->hw->cap->ADF) || (s->hw->cap->adf_duplex == SANE_FALSE)) + s->opt[OPT_ADF_MODE].cap |= SANE_CAP_INACTIVE; + + + /* "Geometry" group: */ + s->opt[OPT_GEOMETRY_GROUP].name = SANE_NAME_GEOMETRY; + s->opt[OPT_GEOMETRY_GROUP].title = SANE_TITLE_GEOMETRY; + s->opt[OPT_GEOMETRY_GROUP].desc = SANE_DESC_GEOMETRY; + s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; + s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED; + + /* top-left x */ + s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; + s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; + s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; + s->opt[OPT_TL_X].type = SANE_TYPE_FIXED; + s->opt[OPT_TL_X].unit = SANE_UNIT_MM; + s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_TL_X].constraint.range = s->hw->x_range; + s->val[OPT_TL_X].w = 0; + + /* top-left y */ + s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; + s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; + s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; + s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; + s->opt[OPT_TL_Y].unit = SANE_UNIT_MM; + s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_TL_Y].constraint.range = s->hw->y_range; + s->val[OPT_TL_Y].w = 0; + + /* bottom-right x */ + s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; + s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; + s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; + s->opt[OPT_BR_X].type = SANE_TYPE_FIXED; + s->opt[OPT_BR_X].unit = SANE_UNIT_MM; + s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_BR_X].constraint.range = s->hw->x_range; + s->val[OPT_BR_X].w = s->hw->x_range->max; + + /* bottom-right y */ + s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; + s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; + s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; + s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; + s->opt[OPT_BR_Y].unit = SANE_UNIT_MM; + s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; + s->opt[OPT_BR_Y].constraint.range = s->hw->y_range; + s->val[OPT_BR_Y].w = s->hw->y_range->max; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_open(SANE_String_Const name, SANE_Handle *handle) +{ + SANE_Status status; + Magicolor_Scanner *s = NULL; + + int l = strlen(name); + + DBG(7, "%s: name = %s\n", __func__, name); + + /* probe if empty device name provided */ + if (l == 0) { + + status = sane_get_devices(NULL,0); + if (status != SANE_STATUS_GOOD) { + return status; + } + + if (first_dev == NULL) { + DBG(1, "no device detected\n"); + return SANE_STATUS_INVAL; + } + + s = device_detect(first_dev->sane.name, first_dev->connection, + &status); + if (s == NULL) { + DBG(1, "cannot open a perfectly valid device (%s)," + " please report to the authors\n", name); + return SANE_STATUS_INVAL; + } + + } else { + + if (strncmp(name, "net:", 4) == 0) { + s = device_detect(name, SANE_MAGICOLOR_NET, &status); + if (s == NULL) + return status; + } else if (strncmp(name, "libusb:", 7) == 0) { + s = device_detect(name, SANE_MAGICOLOR_USB, &status); + if (s == NULL) + return status; + } else { + + /* as a last resort, check for a match + * in the device list. This should handle platforms without libusb. + */ + if (first_dev == NULL) { + status = sane_get_devices(NULL,0); + if (status != SANE_STATUS_GOOD) { + return status; + } + } + + s = device_detect(name, SANE_MAGICOLOR_NODEV, &status); + if (s == NULL) { + DBG(1, "invalid device name: %s\n", name); + return SANE_STATUS_INVAL; + } + } + } + + + /* s is always valid here */ + + DBG(1, "handle obtained\n"); + + init_options(s); + + *handle = (SANE_Handle) s; + + status = open_scanner(s); + if (status != SANE_STATUS_GOOD) { + free(s); + return status; + } + + return status; +} + +void +sane_close(SANE_Handle handle) +{ + Magicolor_Scanner *s; + + /* + * XXX Test if there is still data pending from + * the scanner. If so, then do a cancel + */ + + s = (Magicolor_Scanner *) handle; + + if (s->fd != -1) + close_scanner(s); + + free(s); +} + +const SANE_Option_Descriptor * +sane_get_option_descriptor(SANE_Handle handle, SANE_Int option) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + + if (option < 0 || option >= NUM_OPTIONS) + return NULL; + + return s->opt + option; +} + +static const SANE_String_Const * +search_string_list(const SANE_String_Const *list, SANE_String value) +{ + while (*list != NULL && strcmp(value, *list) != 0) + list++; + + return ((*list == NULL) ? NULL : list); +} + +/* + Activate, deactivate an option. Subroutines so we can add + debugging info if we want. The change flag is set to TRUE + if we changed an option. If we did not change an option, + then the value of the changed flag is not modified. +*/ + +static void +activateOption(Magicolor_Scanner *s, SANE_Int option, SANE_Bool *change) +{ + if (!SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) { + s->opt[option].cap &= ~SANE_CAP_INACTIVE; + *change = SANE_TRUE; + } +} + +static void +deactivateOption(Magicolor_Scanner *s, SANE_Int option, SANE_Bool *change) +{ + if (SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) { + s->opt[option].cap |= SANE_CAP_INACTIVE; + *change = SANE_TRUE; + } +} + +static SANE_Status +getvalue(SANE_Handle handle, SANE_Int option, void *value) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Option_Descriptor *sopt = &(s->opt[option]); + Option_Value *sval = &(s->val[option]); + + DBG(17, "%s: option = %d\n", __func__, option); + + switch (option) { + + case OPT_NUM_OPTS: + case OPT_BIT_DEPTH: + case OPT_BRIGHTNESS: + case OPT_RESOLUTION: + case OPT_PREVIEW: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + *((SANE_Word *) value) = sval->w; + break; + + case OPT_MODE: + case OPT_SOURCE: + case OPT_ADF_MODE: + strcpy((char *) value, sopt->constraint.string_list[sval->w]); + break; + + default: + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_GOOD; +} + + +/* + * Handles setting the source (flatbed, or auto document feeder (ADF)). + * + */ + +static void +change_source(Magicolor_Scanner *s, SANE_Int optindex, char *value) +{ + int force_max = SANE_FALSE; + SANE_Bool dummy; + + DBG(1, "%s: optindex = %d, source = '%s'\n", __func__, optindex, + value); + + if (s->val[OPT_SOURCE].w == optindex) + return; + + s->val[OPT_SOURCE].w = optindex; + + if (s->val[OPT_TL_X].w == s->hw->x_range->min + && s->val[OPT_TL_Y].w == s->hw->y_range->min + && s->val[OPT_BR_X].w == s->hw->x_range->max + && s->val[OPT_BR_Y].w == s->hw->y_range->max) { + force_max = SANE_TRUE; + } + + if (strcmp(ADF_STR, value) == 0) { + s->hw->x_range = &s->hw->cap->adf_x_range; + s->hw->y_range = &s->hw->cap->adf_y_range; + if (s->hw->cap->adf_duplex) { + activateOption(s, OPT_ADF_MODE, &dummy); + } else { + deactivateOption(s, OPT_ADF_MODE, &dummy); + s->val[OPT_ADF_MODE].w = 0; + } + + DBG(1, "adf activated (%d)\n",s->hw->cap->adf_duplex); + + } else { + /* ADF not active */ + s->hw->x_range = &s->hw->cap->fbf_x_range; + s->hw->y_range = &s->hw->cap->fbf_y_range; + + deactivateOption(s, OPT_ADF_MODE, &dummy); + } + + s->opt[OPT_BR_X].constraint.range = s->hw->x_range; + s->opt[OPT_BR_Y].constraint.range = s->hw->y_range; + + if (s->val[OPT_TL_X].w < s->hw->x_range->min || force_max) + s->val[OPT_TL_X].w = s->hw->x_range->min; + + if (s->val[OPT_TL_Y].w < s->hw->y_range->min || force_max) + s->val[OPT_TL_Y].w = s->hw->y_range->min; + + if (s->val[OPT_BR_X].w > s->hw->x_range->max || force_max) + s->val[OPT_BR_X].w = s->hw->x_range->max; + + if (s->val[OPT_BR_Y].w > s->hw->y_range->max || force_max) + s->val[OPT_BR_Y].w = s->hw->y_range->max; + +} + +static SANE_Status +setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Option_Descriptor *sopt = &(s->opt[option]); + Option_Value *sval = &(s->val[option]); + + SANE_Status status; + const SANE_String_Const *optval = NULL; + int optindex = 0; + SANE_Bool reload = SANE_FALSE; + + DBG(17, "%s: option = %d, value = %p, as word: %d\n", __func__, option, value, *(SANE_Word *) value); + + status = sanei_constrain_value(sopt, value, info); + if (status != SANE_STATUS_GOOD) + return status; + + if (info && value && (*info & SANE_INFO_INEXACT) + && sopt->type == SANE_TYPE_INT) + DBG(17, "%s: constrained val = %d\n", __func__, + *(SANE_Word *) value); + + if (sopt->constraint_type == SANE_CONSTRAINT_STRING_LIST) { + optval = search_string_list(sopt->constraint.string_list, + (char *) value); + if (optval == NULL) + return SANE_STATUS_INVAL; + optindex = optval - sopt->constraint.string_list; + } + + switch (option) { + + case OPT_MODE: + { + sval->w = optindex; + /* if binary, then disable the bit depth selection */ + if (optindex == 0) { + s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE; + } else { + if (s->hw->cap->depth_list[0] == 1) + s->opt[OPT_BIT_DEPTH].cap |= + SANE_CAP_INACTIVE; + else { + s->opt[OPT_BIT_DEPTH].cap &= + ~SANE_CAP_INACTIVE; + s->val[OPT_BIT_DEPTH].w = + mode_params[optindex].depth; + } + } + reload = SANE_TRUE; + break; + } + + case OPT_BIT_DEPTH: + sval->w = *((SANE_Word *) value); + mode_params[s->val[OPT_MODE].w].depth = sval->w; + reload = SANE_TRUE; + break; + + case OPT_RESOLUTION: + sval->w = *((SANE_Word *) value); + DBG(17, "setting resolution to %d\n", sval->w); + reload = SANE_TRUE; + break; + + case OPT_BR_X: + case OPT_BR_Y: + sval->w = *((SANE_Word *) value); + if (SANE_UNFIX(sval->w) == 0) { + DBG(17, "invalid br-x or br-y\n"); + return SANE_STATUS_INVAL; + } + /* passthru */ + case OPT_TL_X: + case OPT_TL_Y: + sval->w = *((SANE_Word *) value); + DBG(17, "setting size to %f\n", SANE_UNFIX(sval->w)); + if (NULL != info) + *info |= SANE_INFO_RELOAD_PARAMS; + break; + + case OPT_SOURCE: + change_source(s, optindex, (char *) value); + reload = SANE_TRUE; + break; + + case OPT_ADF_MODE: + sval->w = optindex; /* Simple lists */ + break; + + case OPT_BRIGHTNESS: + case OPT_PREVIEW: /* needed? */ + sval->w = *((SANE_Word *) value); + break; + + default: + return SANE_STATUS_INVAL; + } + + if (reload && info != NULL) + *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; + + DBG(17, "%s: end\n", __func__); + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action, + void *value, SANE_Int *info) +{ + DBG(17, "%s: action = %x, option = %d\n", __func__, action, option); + + if (option < 0 || option >= NUM_OPTIONS) + return SANE_STATUS_INVAL; + + if (info != NULL) + *info = 0; + + switch (action) { + case SANE_ACTION_GET_VALUE: + return getvalue(handle, option, value); + + case SANE_ACTION_SET_VALUE: + return setvalue(handle, option, value, info); + + default: + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_INVAL; +} + +SANE_Status +sane_get_parameters(SANE_Handle handle, SANE_Parameters *params) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + + DBG(5, "%s\n", __func__); + + if (params == NULL) + DBG(1, "%s: params is NULL\n", __func__); + + /* + * If sane_start was already called, then just retrieve the parameters + * from the scanner data structure + */ + + if (!s->eof && s->ptr != NULL) { + DBG(5, "scan in progress, returning saved params structure\n"); + } else { + /* otherwise initialize the params structure and gather the data */ + mc_init_parameters(s); + } + + if (params != NULL) + *params = s->params; + + print_params(s->params); + + return SANE_STATUS_GOOD; +} + +/* + * This function is part of the SANE API and gets called from the front end to + * start the scan process. + */ + +SANE_Status +sane_start(SANE_Handle handle) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + SANE_Status status; + + DBG(5, "%s\n", __func__); + + /* calc scanning parameters */ + status = mc_init_parameters(s); + if (status != SANE_STATUS_GOOD) + return status; + + print_params(s->params); + + /* set scanning parameters; also query the current image + * parameters from the sanner and save + * them to s->params */ + status = mc_set_scanning_parameters(s); + + if (status != SANE_STATUS_GOOD) + return status; + + /* if we scan from ADF, check if it is loaded */ + if (strcmp(source_list[s->val[OPT_SOURCE].w], ADF_STR) == 0) { + status = mc_check_adf(s); + if (status != SANE_STATUS_GOOD) + return status; + } + + /* prepare buffer here so that a memory allocation failure + * will leave the scanner in a sane state. + */ + s->buf = realloc(s->buf, s->block_len); + if (s->buf == NULL) + return SANE_STATUS_NO_MEM; + + s->eof = SANE_FALSE; + s->ptr = s->end = s->buf; + s->canceling = SANE_FALSE; + + /* start scanning */ + DBG(1, "%s: scanning...\n", __func__); + + status = mc_start_scan(s); + + if (status != SANE_STATUS_GOOD) { + DBG(1, "%s: start failed: %s\n", __func__, + sane_strstatus(status)); + + return status; + } + + return status; +} + +/* this moves data from our buffers to SANE */ + +SANE_Status +sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length, + SANE_Int *length) +{ + SANE_Status status; + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + + if (s->buf == NULL || s->canceling) + return SANE_STATUS_CANCELLED; + + *length = 0; + + status = mc_read(s); + + if (status == SANE_STATUS_CANCELLED) { + mc_scan_finish(s); + return status; + } + + DBG(18, "moving data %p %p, %d (%d lines)\n", + s->ptr, s->end, + max_length, max_length / s->params.bytes_per_line); + + mc_copy_image_data(s, data, max_length, length); + + DBG(18, "%d lines read, status: %d\n", + *length / s->params.bytes_per_line, status); + + /* continue reading if appropriate */ + if (status == SANE_STATUS_GOOD) + return status; + + mc_scan_finish(s); + + return status; +} + +/* + * void sane_cancel(SANE_Handle handle) + * + * Set the cancel flag to true. The next time the backend requests data + * from the scanner the CAN message will be sent. + */ + +void +sane_cancel(SANE_Handle handle) +{ + Magicolor_Scanner *s = (Magicolor_Scanner *) handle; + + s->canceling = SANE_TRUE; +} + +/* + * SANE_Status sane_set_io_mode() + * + * not supported - for asynchronous I/O + */ + +SANE_Status +sane_set_io_mode(SANE_Handle __sane_unused__ handle, + SANE_Bool __sane_unused__ non_blocking) +{ + return SANE_STATUS_UNSUPPORTED; +} + +/* + * SANE_Status sane_get_select_fd() + * + * not supported - for asynchronous I/O + */ + +SANE_Status +sane_get_select_fd(SANE_Handle __sane_unused__ handle, + SANE_Int __sane_unused__ *fd) +{ + return SANE_STATUS_UNSUPPORTED; +} |