summaryrefslogtreecommitdiff
path: root/backend/net.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/net.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/net.c')
-rw-r--r--backend/net.c2378
1 files changed, 2378 insertions, 0 deletions
diff --git a/backend/net.c b/backend/net.c
new file mode 100644
index 0000000..16fba2f
--- /dev/null
+++ b/backend/net.c
@@ -0,0 +1,2378 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 1997 David Mosberger-Tang
+ Copyright (C) 2003, 2008 Julien BLACHE <jb@jblache.org>
+ AF-independent code + IPv6, Avahi support
+
+ 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.
+
+ This file implements a SANE network-based meta backend. */
+
+#ifdef _AIX
+# include "../include/lalloca.h" /* MUST come first for AIX! */
+#endif
+
+#include "../include/sane/config.h"
+#include "../include/lalloca.h"
+#include "../include/_stdint.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#ifdef HAVE_LIBC_H
+# include <libc.h> /* NeXTStep/OpenStep */
+#endif
+
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <netinet/in.h>
+#include <netdb.h> /* OS/2 needs this _after_ <netinet/in.h>, grrr... */
+
+#ifdef WITH_AVAHI
+# include <avahi-client/client.h>
+# include <avahi-client/lookup.h>
+
+# include <avahi-common/thread-watch.h>
+# include <avahi-common/malloc.h>
+# include <avahi-common/error.h>
+
+# define SANED_SERVICE_DNS "_sane-port._tcp"
+
+static AvahiClient *avahi_client = NULL;
+static AvahiThreadedPoll *avahi_thread = NULL;
+static AvahiServiceBrowser *avahi_browser = NULL;
+#endif /* WITH_AVAHI */
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_net.h"
+#include "../include/sane/sanei_codec_bin.h"
+#include "net.h"
+
+#define BACKEND_NAME net
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX 1024
+#endif
+
+#include "../include/sane/sanei_config.h"
+#define NET_CONFIG_FILE "net.conf"
+
+/* Please increase version number with every change
+ (don't forget to update net.desc) */
+
+/* define the version string depending on which network code is used */
+#if defined (HAVE_GETADDRINFO) && defined (HAVE_GETNAMEINFO)
+# define NET_USES_AF_INDEP
+# ifdef ENABLE_IPV6
+# define NET_VERSION "1.0.14 (AF-indep+IPv6)"
+# else
+# define NET_VERSION "1.0.14 (AF-indep)"
+# endif /* ENABLE_IPV6 */
+#else
+# undef ENABLE_IPV6
+# define NET_VERSION "1.0.14"
+#endif /* HAVE_GETADDRINFO && HAVE_GETNAMEINFO */
+
+static SANE_Auth_Callback auth_callback;
+static Net_Device *first_device;
+static Net_Scanner *first_handle;
+static const SANE_Device **devlist;
+static int client_big_endian; /* 1 == big endian; 0 == little endian */
+static int server_big_endian; /* 1 == big endian; 0 == little endian */
+static int depth; /* bits per pixel */
+static int connect_timeout = -1; /* timeout for connection to saned */
+
+#ifndef NET_USES_AF_INDEP
+static int saned_port;
+#endif /* !NET_USES_AF_INDEP */
+
+/* This variable is only needed, if the depth is 16bit/channel and
+ client/server have different endianness. A value of -1 means, that there's
+ no hang over; otherwise the value has to be casted to SANE_Byte. hang_over
+ means, that there is a remaining byte from a previous call to sane_read,
+ which could not be byte-swapped, e.g. because the frontend requested an odd
+ number of bytes.
+*/
+static int hang_over;
+
+/* This variable is only needed, if the depth is 16bit/channel and
+ client/server have different endianness. A value of -1 means, that there's
+ no left over; otherwise the value has to be casted to SANE_Byte. left_over
+ means, that there is a remaining byte from a previous call to sane_read,
+ which already is in the the correct byte order, but could not be returned,
+ e.g. because the frontend requested only one byte per call.
+*/
+static int left_over;
+
+
+#ifdef NET_USES_AF_INDEP
+static SANE_Status
+add_device (const char *name, Net_Device ** ndp)
+{
+ struct addrinfo hints;
+ struct addrinfo *res;
+ struct addrinfo *resp;
+ struct sockaddr_in *sin;
+#ifdef ENABLE_IPV6
+ struct sockaddr_in6 *sin6;
+#endif /* ENABLE_IPV6 */
+
+ Net_Device *nd = NULL;
+
+ int error;
+ short sane_port = htons (6566);
+
+ DBG (1, "add_device: adding backend %s\n", name);
+
+ for (nd = first_device; nd; nd = nd->next)
+ if (strcmp (nd->name, name) == 0)
+ {
+ DBG (1, "add_device: already in list\n");
+
+ if (ndp)
+ *ndp = nd;
+
+ return SANE_STATUS_GOOD;
+ }
+
+ memset (&hints, 0, sizeof(hints));
+
+# ifdef ENABLE_IPV6
+ hints.ai_family = PF_UNSPEC;
+# else
+ hints.ai_family = PF_INET;
+# endif /* ENABLE_IPV6 */
+
+ error = getaddrinfo (name, "sane-port", &hints, &res);
+ if (error)
+ {
+ error = getaddrinfo (name, NULL, &hints, &res);
+ if (error)
+ {
+ DBG (1, "add_device: error while getting address of host %s: %s\n",
+ name, gai_strerror (error));
+
+ return SANE_STATUS_IO_ERROR;
+ }
+ else
+ {
+ for (resp = res; resp != NULL; resp = resp->ai_next)
+ {
+ switch (resp->ai_family)
+ {
+ case AF_INET:
+ sin = (struct sockaddr_in *) resp->ai_addr;
+ sin->sin_port = sane_port;
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ sin6 = (struct sockaddr_in6 *) resp->ai_addr;
+ sin6->sin6_port = sane_port;
+ break;
+#endif /* ENABLE_IPV6 */
+ }
+ }
+ }
+ }
+
+ nd = malloc (sizeof (Net_Device));
+ if (!nd)
+ {
+ DBG (1, "add_device: not enough memory for Net_Device struct\n");
+
+ freeaddrinfo (res);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ memset (nd, 0, sizeof (Net_Device));
+ nd->name = strdup (name);
+ if (!nd->name)
+ {
+ DBG (1, "add_device: not enough memory to duplicate name\n");
+ free(nd);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ nd->addr = res;
+ nd->ctl = -1;
+
+ nd->next = first_device;
+
+ first_device = nd;
+
+ if (ndp)
+ *ndp = nd;
+ DBG (2, "add_device: backend %s added\n", name);
+ return SANE_STATUS_GOOD;
+}
+
+#else /* !NET_USES_AF_INDEP */
+
+static SANE_Status
+add_device (const char *name, Net_Device ** ndp)
+{
+ struct hostent *he;
+ Net_Device *nd;
+ struct sockaddr_in *sin;
+
+ DBG (1, "add_device: adding backend %s\n", name);
+
+ for (nd = first_device; nd; nd = nd->next)
+ if (strcmp (nd->name, name) == 0)
+ {
+ DBG (1, "add_device: already in list\n");
+
+ if (ndp)
+ *ndp = nd;
+
+ return SANE_STATUS_GOOD;
+ }
+
+ he = gethostbyname (name);
+ if (!he)
+ {
+ DBG (1, "add_device: can't get address of host %s\n", name);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ if (he->h_addrtype != AF_INET)
+ {
+ DBG (1, "add_device: don't know how to deal with addr family %d\n",
+ he->h_addrtype);
+ return SANE_STATUS_INVAL;
+ }
+
+ nd = malloc (sizeof (*nd));
+ if (!nd)
+ {
+ DBG (1, "add_device: not enough memory for Net_Device struct\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ memset (nd, 0, sizeof (*nd));
+ nd->name = strdup (name);
+ if (!nd->name)
+ {
+ DBG (1, "add_device: not enough memory to duplicate name\n");
+ free (nd);
+ return SANE_STATUS_NO_MEM;
+ }
+ nd->addr.sa_family = he->h_addrtype;
+
+ sin = (struct sockaddr_in *) &nd->addr;
+ memcpy (&sin->sin_addr, he->h_addr_list[0], he->h_length);
+
+ nd->ctl = -1;
+ nd->next = first_device;
+ first_device = nd;
+ if (ndp)
+ *ndp = nd;
+ DBG (2, "add_device: backend %s added\n", name);
+ return SANE_STATUS_GOOD;
+}
+#endif /* NET_USES_AF_INDEP */
+
+
+#ifdef NET_USES_AF_INDEP
+static SANE_Status
+connect_dev (Net_Device * dev)
+{
+ struct addrinfo *addrp;
+
+ SANE_Word version_code;
+ SANE_Init_Reply reply;
+ SANE_Status status = SANE_STATUS_IO_ERROR;
+ SANE_Init_Req req;
+ SANE_Bool connected = SANE_FALSE;
+#ifdef TCP_NODELAY
+ int on = 1;
+ int level = -1;
+#endif
+ struct timeval tv;
+
+ int i;
+
+ DBG (2, "connect_dev: trying to connect to %s\n", dev->name);
+
+ for (addrp = dev->addr, i = 0; (addrp != NULL) && (connected == SANE_FALSE); addrp = addrp->ai_next, i++)
+ {
+# ifdef ENABLE_IPV6
+ if ((addrp->ai_family != AF_INET) && (addrp->ai_family != AF_INET6))
+# else /* !ENABLE_IPV6 */
+ if (addrp->ai_family != AF_INET)
+# endif /* ENABLE_IPV6 */
+ {
+ DBG (1, "connect_dev: [%d] don't know how to deal with addr family %d\n",
+ i, addrp->ai_family);
+ continue;
+ }
+
+ dev->ctl = socket (addrp->ai_family, SOCK_STREAM, 0);
+ if (dev->ctl < 0)
+ {
+ DBG (1, "connect_dev: [%d] failed to obtain socket (%s)\n",
+ i, strerror (errno));
+ dev->ctl = -1;
+ continue;
+ }
+
+ /* Set SO_SNDTIMEO for the connection to saned */
+ if (connect_timeout > 0)
+ {
+ tv.tv_sec = connect_timeout;
+ tv.tv_usec = 0;
+
+ if (setsockopt (dev->ctl, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
+ {
+ DBG (1, "connect_dev: [%d] failed to set SO_SNDTIMEO (%s)\n", i, strerror (errno));
+ }
+ }
+
+ if (connect (dev->ctl, addrp->ai_addr, addrp->ai_addrlen) < 0)
+ {
+ DBG (1, "connect_dev: [%d] failed to connect (%s)\n", i, strerror (errno));
+ dev->ctl = -1;
+ continue;
+ }
+ DBG (3, "connect_dev: [%d] connection succeeded (%s)\n", i, (addrp->ai_family == AF_INET6) ? "IPv6" : "IPv4");
+ dev->addr_used = addrp;
+ connected = SANE_TRUE;
+ }
+
+ if (connected != SANE_TRUE)
+ {
+ DBG (1, "connect_dev: couldn't connect to host (see messages above)\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+
+#else /* !NET_USES_AF_INDEP */
+
+static SANE_Status
+connect_dev (Net_Device * dev)
+{
+ struct sockaddr_in *sin;
+ SANE_Word version_code;
+ SANE_Init_Reply reply;
+ SANE_Status status = SANE_STATUS_IO_ERROR;
+ SANE_Init_Req req;
+#ifdef TCP_NODELAY
+ int on = 1;
+ int level = -1;
+#endif
+ struct timeval tv;
+
+ DBG (2, "connect_dev: trying to connect to %s\n", dev->name);
+
+ if (dev->addr.sa_family != AF_INET)
+ {
+ DBG (1, "connect_dev: don't know how to deal with addr family %d\n",
+ dev->addr.sa_family);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ dev->ctl = socket (dev->addr.sa_family, SOCK_STREAM, 0);
+ if (dev->ctl < 0)
+ {
+ DBG (1, "connect_dev: failed to obtain socket (%s)\n",
+ strerror (errno));
+ dev->ctl = -1;
+ return SANE_STATUS_IO_ERROR;
+ }
+ sin = (struct sockaddr_in *) &dev->addr;
+ sin->sin_port = saned_port;
+
+
+ /* Set SO_SNDTIMEO for the connection to saned */
+ if (connect_timeout > 0)
+ {
+ tv.tv_sec = connect_timeout;
+ tv.tv_usec = 0;
+
+ if (setsockopt (dev->ctl, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
+ {
+ DBG (1, "connect_dev: failed to set SO_SNDTIMEO (%s)\n", strerror (errno));
+ }
+ }
+
+ if (connect (dev->ctl, &dev->addr, sizeof (dev->addr)) < 0)
+ {
+ DBG (1, "connect_dev: failed to connect (%s)\n", strerror (errno));
+ dev->ctl = -1;
+ return SANE_STATUS_IO_ERROR;
+ }
+ DBG (3, "connect_dev: connection succeeded\n");
+#endif /* NET_USES_AF_INDEP */
+
+ /* We're connected now, so reset SO_SNDTIMEO to the default value of 0 */
+ if (connect_timeout > 0)
+ {
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+
+ if (setsockopt (dev->ctl, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
+ {
+ DBG (1, "connect_dev: failed to reset SO_SNDTIMEO (%s)\n", strerror (errno));
+ }
+ }
+
+#ifdef TCP_NODELAY
+# ifdef SOL_TCP
+ level = SOL_TCP;
+# else /* !SOL_TCP */
+ /* Look up the protocol level in the protocols database. */
+ {
+ struct protoent *p;
+ p = getprotobyname ("tcp");
+ if (p == 0)
+ DBG (1, "connect_dev: cannot look up `tcp' protocol number");
+ else
+ level = p->p_proto;
+ }
+# endif /* SOL_TCP */
+
+ if (level == -1 ||
+ setsockopt (dev->ctl, level, TCP_NODELAY, &on, sizeof (on)))
+ DBG (1, "connect_dev: failed to put send socket in TCP_NODELAY mode (%s)",
+ strerror (errno));
+#endif /* !TCP_NODELAY */
+
+ DBG (2, "connect_dev: sanei_w_init\n");
+ sanei_w_init (&dev->wire, sanei_codec_bin_init);
+ dev->wire.io.fd = dev->ctl;
+ dev->wire.io.read = read;
+ dev->wire.io.write = write;
+
+ /* exchange version codes with the server: */
+ req.version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR,
+ SANEI_NET_PROTOCOL_VERSION);
+ req.username = getlogin ();
+ DBG (2, "connect_dev: net_init (user=%s, local version=%d.%d.%d)\n",
+ req.username, V_MAJOR, V_MINOR, SANEI_NET_PROTOCOL_VERSION);
+ sanei_w_call (&dev->wire, SANE_NET_INIT,
+ (WireCodecFunc) sanei_w_init_req, &req,
+ (WireCodecFunc) sanei_w_init_reply, &reply);
+
+ if (dev->wire.status != 0)
+ {
+ DBG (1, "connect_dev: argument marshalling error (%s)\n",
+ strerror (dev->wire.status));
+ status = SANE_STATUS_IO_ERROR;
+ goto fail;
+ }
+
+ status = reply.status;
+ version_code = reply.version_code;
+ DBG (2, "connect_dev: freeing init reply (status=%s, remote "
+ "version=%d.%d.%d)\n", sane_strstatus (status),
+ SANE_VERSION_MAJOR (version_code),
+ SANE_VERSION_MINOR (version_code), SANE_VERSION_BUILD (version_code));
+ sanei_w_free (&dev->wire, (WireCodecFunc) sanei_w_init_reply, &reply);
+
+ if (status != 0)
+ {
+ DBG (1, "connect_dev: access to %s denied\n", dev->name);
+ goto fail;
+ }
+ if (SANE_VERSION_MAJOR (version_code) != V_MAJOR)
+ {
+ DBG (1, "connect_dev: major version mismatch: got %d, expected %d\n",
+ SANE_VERSION_MAJOR (version_code), V_MAJOR);
+ status = SANE_STATUS_IO_ERROR;
+ goto fail;
+ }
+ if (SANE_VERSION_BUILD (version_code) != SANEI_NET_PROTOCOL_VERSION
+ && SANE_VERSION_BUILD (version_code) != 2)
+ {
+ DBG (1, "connect_dev: network protocol version mismatch: "
+ "got %d, expected %d\n",
+ SANE_VERSION_BUILD (version_code), SANEI_NET_PROTOCOL_VERSION);
+ status = SANE_STATUS_IO_ERROR;
+ goto fail;
+ }
+ dev->wire.version = SANE_VERSION_BUILD (version_code);
+ DBG (4, "connect_dev: done\n");
+ return SANE_STATUS_GOOD;
+
+fail:
+ DBG (2, "connect_dev: closing connection to %s\n", dev->name);
+ close (dev->ctl);
+ dev->ctl = -1;
+ return status;
+}
+
+
+static SANE_Status
+fetch_options (Net_Scanner * s)
+{
+ int option_number;
+ DBG (3, "fetch_options: %p\n", (void *) s);
+
+ if (s->opt.num_options)
+ {
+ DBG (2, "fetch_options: %d option descriptors cached... freeing\n",
+ s->opt.num_options);
+ sanei_w_set_dir (&s->hw->wire, WIRE_FREE);
+ s->hw->wire.status = 0;
+ sanei_w_option_descriptor_array (&s->hw->wire, &s->opt);
+ if (s->hw->wire.status)
+ {
+ DBG (1, "fetch_options: failed to free old list (%s)\n",
+ strerror (s->hw->wire.status));
+ return SANE_STATUS_IO_ERROR;
+ }
+ }
+ DBG (3, "fetch_options: get_option_descriptors\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_GET_OPTION_DESCRIPTORS,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_option_descriptor_array, &s->opt);
+ if (s->hw->wire.status)
+ {
+ DBG (1, "fetch_options: failed to get option descriptors (%s)\n",
+ strerror (s->hw->wire.status));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ if (s->local_opt.num_options == 0)
+ {
+ DBG (3, "fetch_options: creating %d local option descriptors\n",
+ s->opt.num_options);
+ s->local_opt.desc =
+ malloc (s->opt.num_options * sizeof (s->local_opt.desc));
+ if (!s->local_opt.desc)
+ {
+ DBG (1, "fetch_options: couldn't malloc s->local_opt.desc\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ for (option_number = 0;
+ option_number < s->opt.num_options;
+ option_number++)
+ {
+ s->local_opt.desc[option_number] =
+ malloc (sizeof (SANE_Option_Descriptor));
+ if (!s->local_opt.desc[option_number])
+ {
+ DBG (1, "fetch_options: couldn't malloc "
+ "s->local_opt.desc[%d]\n", option_number);
+ return SANE_STATUS_NO_MEM;
+ }
+ }
+ s->local_opt.num_options = s->opt.num_options;
+ }
+ else if (s->local_opt.num_options != s->opt.num_options)
+ {
+ DBG (1, "fetch_options: option number count changed during runtime?\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG (3, "fetch_options: copying %d option descriptors\n",
+ s->opt.num_options);
+
+ for (option_number = 0; option_number < s->opt.num_options; option_number++)
+ {
+ memcpy (s->local_opt.desc[option_number], s->opt.desc[option_number],
+ sizeof (SANE_Option_Descriptor));
+ }
+
+ s->options_valid = 1;
+ DBG (3, "fetch_options: %d options fetched\n", s->opt.num_options);
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+do_cancel (Net_Scanner * s)
+{
+ DBG (2, "do_cancel: %p\n", (void *) s);
+ s->hw->auth_active = 0;
+ if (s->data >= 0)
+ {
+ DBG (3, "do_cancel: closing data pipe\n");
+ close (s->data);
+ s->data = -1;
+ }
+ return SANE_STATUS_CANCELLED;
+}
+
+static void
+do_authorization (Net_Device * dev, SANE_String resource)
+{
+ SANE_Authorization_Req req;
+ SANE_Char username[SANE_MAX_USERNAME_LEN];
+ SANE_Char password[SANE_MAX_PASSWORD_LEN];
+ char *net_resource;
+
+ DBG (2, "do_authorization: dev=%p resource=%s\n", (void *) dev, resource);
+
+ dev->auth_active = 1;
+
+ memset (&req, 0, sizeof (req));
+ memset (username, 0, sizeof (SANE_Char) * SANE_MAX_USERNAME_LEN);
+ memset (password, 0, sizeof (SANE_Char) * SANE_MAX_PASSWORD_LEN);
+
+ net_resource = malloc (strlen (resource) + 6 + strlen (dev->name));
+
+ if (net_resource != NULL)
+ {
+ sprintf (net_resource, "net:%s:%s", dev->name, resource);
+ if (auth_callback)
+ {
+ DBG (2, "do_authorization: invoking auth_callback, resource = %s\n",
+ net_resource);
+ (*auth_callback) (net_resource, username, password);
+ }
+ else
+ DBG (1, "do_authorization: no auth_callback present\n");
+ free (net_resource);
+ }
+ else /* Is this necessary? If we don't have these few bytes we will get
+ in trouble later anyway */
+ {
+ DBG (1, "do_authorization: not enough memory for net_resource\n");
+ if (auth_callback)
+ {
+ DBG (2, "do_authorization: invoking auth_callback, resource = %s\n",
+ resource);
+ (*auth_callback) (resource, username, password);
+ }
+ else
+ DBG (1, "do_authorization: no auth_callback present\n");
+ }
+
+ if (dev->auth_active)
+ {
+ SANE_Word ack;
+
+ req.resource = resource;
+ req.username = username;
+ req.password = password;
+ DBG (2, "do_authorization: relaying authentication data\n");
+ sanei_w_call (&dev->wire, SANE_NET_AUTHORIZE,
+ (WireCodecFunc) sanei_w_authorization_req, &req,
+ (WireCodecFunc) sanei_w_word, &ack);
+ }
+ else
+ DBG (1, "do_authorization: auth_active is false... strange\n");
+}
+
+
+#ifdef WITH_AVAHI
+static void
+net_avahi_resolve_callback (AvahiServiceResolver *r, AvahiIfIndex interface, AvahiProtocol protocol,
+ AvahiResolverEvent event, const char *name, const char *type,
+ const char *domain, const char *host_name, const AvahiAddress *address,
+ uint16_t port, AvahiStringList *txt, AvahiLookupResultFlags flags,
+ void *userdata)
+{
+ char a[AVAHI_ADDRESS_STR_MAX];
+ char *t;
+
+ /* unused */
+ interface = interface;
+ protocol = protocol;
+ userdata = userdata;
+
+ if (!r)
+ return;
+
+ switch (event)
+ {
+ case AVAHI_RESOLVER_FAILURE:
+ DBG (1, "net_avahi_resolve_callback: failed to resolve service '%s' of type '%s' in domain '%s': %s\n",
+ name, type, domain, avahi_strerror (avahi_client_errno (avahi_service_resolver_get_client (r))));
+ break;
+
+ case AVAHI_RESOLVER_FOUND:
+ DBG (3, "net_avahi_resolve_callback: service '%s' of type '%s' in domain '%s':\n", name, type, domain);
+
+ avahi_address_snprint(a, sizeof (a), address);
+ t = avahi_string_list_to_string (txt);
+
+ DBG (3, "\t%s:%u (%s)\n\tTXT=%s\n\tcookie is %u\n\tis_local: %i\n\tour_own: %i\n"
+ "\twide_area: %i\n\tmulticast: %i\n\tcached: %i\n",
+ host_name, port, a, t, avahi_string_list_get_service_cookie (txt),
+ !!(flags & AVAHI_LOOKUP_RESULT_LOCAL), !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
+ !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA), !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
+ !!(flags & AVAHI_LOOKUP_RESULT_CACHED));
+
+ /* TODO: evaluate TXT record */
+
+ /* Try first with the name */
+ if (add_device (host_name, NULL) != SANE_STATUS_GOOD)
+ {
+ DBG (1, "net_avahi_resolve_callback: couldn't add backend with name %s\n", host_name);
+
+ /* Then try the raw IP address */
+ if (add_device (t, NULL) != SANE_STATUS_GOOD)
+ DBG (1, "net_avahi_resolve_callback: couldn't add backend with IP address %s either\n", t);
+ }
+
+ avahi_free (t);
+ break;
+ }
+
+ avahi_service_resolver_free(r);
+}
+
+static void
+net_avahi_browse_callback (AvahiServiceBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol,
+ AvahiBrowserEvent event, const char *name, const char *type,
+ const char *domain, AvahiLookupResultFlags flags, void *userdata)
+{
+ AvahiProtocol proto;
+
+ /* unused */
+ flags = flags;
+ userdata = userdata;
+
+ if (!b)
+ return;
+
+ switch (event)
+ {
+ case AVAHI_BROWSER_FAILURE:
+ DBG (1, "net_avahi_browse_callback: %s\n", avahi_strerror (avahi_client_errno (avahi_service_browser_get_client (b))));
+ avahi_threaded_poll_quit (avahi_thread);
+ return;
+
+ case AVAHI_BROWSER_NEW:
+ DBG (3, "net_avahi_browse_callback: NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+
+ /* The server will actually be added to our list in the resolver callback */
+
+ /* The resolver object will be freed in the resolver callback, or by
+ * the server if it terminates before the callback is called.
+ */
+#ifdef ENABLE_IPV6
+ proto = AVAHI_PROTO_UNSPEC;
+#else
+ proto = AVAHI_PROTO_INET;
+#endif /* ENABLE_IPV6 */
+ if (!(avahi_service_resolver_new (avahi_client, interface, protocol, name, type, domain, proto, 0, net_avahi_resolve_callback, NULL)))
+ DBG (2, "net_avahi_browse_callback: failed to resolve service '%s': %s\n", name, avahi_strerror (avahi_client_errno (avahi_client)));
+ break;
+
+ case AVAHI_BROWSER_REMOVE:
+ DBG (3, "net_avahi_browse_callback: REMOVE: service '%s' of type '%s' in domain '%s'\n", name, type, domain);
+ /* With the current architecture, we cannot safely remove a server from the list */
+ break;
+
+ case AVAHI_BROWSER_ALL_FOR_NOW:
+ case AVAHI_BROWSER_CACHE_EXHAUSTED:
+ DBG (3, "net_avahi_browse_callback: %s\n", event == AVAHI_BROWSER_CACHE_EXHAUSTED ? "CACHE_EXHAUSTED" : "ALL_FOR_NOW");
+ break;
+ }
+}
+
+static void
+net_avahi_callback (AvahiClient *c, AvahiClientState state, void * userdata)
+{
+ AvahiProtocol proto;
+ int error;
+
+ /* unused */
+ userdata = userdata;
+
+ if (!c)
+ return;
+
+ switch (state)
+ {
+ case AVAHI_CLIENT_CONNECTING:
+ break;
+
+ case AVAHI_CLIENT_S_COLLISION:
+ case AVAHI_CLIENT_S_REGISTERING:
+ case AVAHI_CLIENT_S_RUNNING:
+ if (avahi_browser)
+ return;
+
+#ifdef ENABLE_IPV6
+ proto = AVAHI_PROTO_UNSPEC;
+#else
+ proto = AVAHI_PROTO_INET;
+#endif /* ENABLE_IPV6 */
+
+ avahi_browser = avahi_service_browser_new (c, AVAHI_IF_UNSPEC, proto, SANED_SERVICE_DNS, NULL, 0, net_avahi_browse_callback, NULL);
+ if (avahi_browser == NULL)
+ {
+ DBG (1, "net_avahi_callback: could not create service browser: %s\n", avahi_strerror (avahi_client_errno (c)));
+ avahi_threaded_poll_quit (avahi_thread);
+ }
+ break;
+
+ case AVAHI_CLIENT_FAILURE:
+ error = avahi_client_errno (c);
+
+ if (error == AVAHI_ERR_DISCONNECTED)
+ {
+ /* Server disappeared - try to reconnect */
+ avahi_client_free (avahi_client);
+ avahi_client = NULL;
+
+ if (avahi_browser)
+ {
+ avahi_service_browser_free (avahi_browser);
+ avahi_browser = NULL;
+ }
+
+ avahi_client = avahi_client_new (avahi_threaded_poll_get (avahi_thread), AVAHI_CLIENT_NO_FAIL, net_avahi_callback, NULL, &error);
+ if (avahi_client == NULL)
+ {
+ DBG (1, "net_avahi_init: could not create Avahi client: %s\n", avahi_strerror (error));
+ avahi_threaded_poll_quit (avahi_thread);
+ }
+ }
+ else
+ {
+ /* Another error happened - game over */
+ DBG (1, "net_avahi_callback: server connection failure: %s\n", avahi_strerror (error));
+ avahi_threaded_poll_quit (avahi_thread);
+ }
+ break;
+ }
+}
+
+
+static void
+net_avahi_init (void)
+{
+ int error;
+
+ avahi_thread = avahi_threaded_poll_new ();
+ if (avahi_thread == NULL)
+ {
+ DBG (1, "net_avahi_init: could not create threaded poll object\n");
+ goto fail;
+ }
+
+ avahi_client = avahi_client_new (avahi_threaded_poll_get (avahi_thread), AVAHI_CLIENT_NO_FAIL, net_avahi_callback, NULL, &error);
+ if (avahi_client == NULL)
+ {
+ DBG (1, "net_avahi_init: could not create Avahi client: %s\n", avahi_strerror (error));
+ goto fail;
+ }
+
+ if (avahi_threaded_poll_start (avahi_thread) < 0)
+ {
+ DBG (1, "net_avahi_init: Avahi thread failed to start\n");
+ goto fail;
+ }
+
+ /* All done */
+ return;
+
+ fail:
+ DBG (1, "net_avahi_init: Avahi init failed, support disabled\n");
+
+ if (avahi_client)
+ {
+ avahi_client_free (avahi_client);
+ avahi_client = NULL;
+ }
+
+ if (avahi_thread)
+ {
+ avahi_threaded_poll_free (avahi_thread);
+ avahi_thread = NULL;
+ }
+}
+
+static void
+net_avahi_cleanup (void)
+{
+ if (!avahi_thread)
+ return;
+
+ DBG (1, "net_avahi_cleanup: stopping thread\n");
+
+ avahi_threaded_poll_stop (avahi_thread);
+
+ if (avahi_browser)
+ avahi_service_browser_free (avahi_browser);
+
+ if (avahi_client)
+ avahi_client_free (avahi_client);
+
+ avahi_threaded_poll_free (avahi_thread);
+
+ DBG (1, "net_avahi_cleanup: done\n");
+}
+#endif /* WITH_AVAHI */
+
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+ char device_name[PATH_MAX];
+ const char *optval;
+ const char *env;
+ size_t len;
+ FILE *fp;
+ short ns = 0x1234;
+ unsigned char *p = (unsigned char *)(&ns);
+
+#ifndef NET_USES_AF_INDEP
+ struct servent *serv;
+#endif /* !NET_USES_AF_INDEP */
+
+ DBG_INIT ();
+
+ DBG (2, "sane_init: authorize %s null, version_code %s null\n", (authorize) ? "!=" : "==",
+ (version_code) ? "!=" : "==");
+
+ devlist = NULL;
+ first_device = NULL;
+ first_handle = NULL;
+
+#ifdef WITH_AVAHI
+ net_avahi_init ();
+#endif /* WITH_AVAHI */
+
+ auth_callback = authorize;
+
+ /* Return the version number of the sane-backends package to allow
+ the frontend to print them. This is done only for net and dll,
+ because these backends are usually called by the frontend. */
+ if (version_code)
+ *version_code = SANE_VERSION_CODE (SANE_DLL_V_MAJOR, SANE_DLL_V_MINOR,
+ SANE_DLL_V_BUILD);
+
+ DBG (1, "sane_init: SANE net backend version %s from %s\n", NET_VERSION,
+ PACKAGE_STRING);
+
+ /* determine (client) machine byte order */
+ if (*p == 0x12)
+ {
+ client_big_endian = 1;
+ DBG (3, "sane_init: Client has big endian byte order\n");
+ }
+ else
+ {
+ client_big_endian = 0;
+ DBG (3, "sane_init: Client has little endian byte order\n");
+ }
+
+#ifndef NET_USES_AF_INDEP
+ DBG (2, "sane_init: determining sane service port\n");
+ serv = getservbyname ("sane-port", "tcp");
+
+ if (serv)
+ {
+ DBG (2, "sane_init: found port %d\n", ntohs (serv->s_port));
+ saned_port = serv->s_port;
+ }
+ else
+ {
+ saned_port = htons (6566);
+ DBG (1, "sane_init: could not find `sane-port' service (%s); using default "
+ "port %d\n", strerror (errno), ntohs (saned_port));
+ }
+#endif /* !NET_USES_AF_INDEP */
+
+ DBG (2, "sane_init: searching for config file\n");
+ fp = sanei_config_open (NET_CONFIG_FILE);
+ if (fp)
+ {
+ while (sanei_config_read (device_name, sizeof (device_name), fp))
+ {
+ if (device_name[0] == '#') /* ignore line comments */
+ continue;
+ len = strlen (device_name);
+
+ if (!len)
+ continue; /* ignore empty lines */
+
+ /*
+ * Check for net backend options.
+ * Anything that isn't an option is a saned host.
+ */
+ if (strstr(device_name, "connect_timeout") != NULL)
+ {
+ /* Look for the = sign; if it's not there, error out */
+ optval = strchr(device_name, '=');
+
+ if (!optval)
+ continue;
+
+ optval = sanei_config_skip_whitespace (++optval);
+ if ((optval != NULL) && (*optval != '\0'))
+ {
+ connect_timeout = atoi(optval);
+
+ DBG (2, "sane_init: connect timeout set to %d seconds\n", connect_timeout);
+ }
+
+ continue;
+ }
+
+ DBG (2, "sane_init: trying to add %s\n", device_name);
+ add_device (device_name, 0);
+ }
+
+ fclose (fp);
+ DBG (2, "sane_init: done reading config\n");
+ }
+ else
+ DBG (1, "sane_init: could not open config file (%s): %s\n",
+ NET_CONFIG_FILE, strerror (errno));
+
+ DBG (2, "sane_init: evaluating environment variable SANE_NET_HOSTS\n");
+ env = getenv ("SANE_NET_HOSTS");
+ if (env)
+ {
+ char *copy, *next, *host;
+ if ((copy = strdup (env)) != NULL)
+ {
+ next = copy;
+ while ((host = strsep (&next, ":")))
+ {
+#ifdef ENABLE_IPV6
+ if (host[0] == '[')
+ {
+ /* skip '[' (host[0]) */
+ host++;
+ /* get the rest of the IPv6 addr (we're screwed if ] is missing)
+ * Is it worth checking for the matching ] ? Not for now. */
+ strsep (&next, "]");
+ /* add back the ":" that got removed by the strsep() */
+ host[strlen (host)] = ':';
+ /* host now holds the IPv6 address */
+
+ /* skip the ':' that could be after ] (avoids a call to strsep() */
+ if (next[0] == ':')
+ next++;
+ }
+
+ /*
+ * if the IPv6 is last in the list, the strsep() call in the while()
+ * will return a string with the first char being '\0'. Skip it.
+ */
+ if (host[0] == '\0')
+ continue;
+#endif /* ENABLE_IPV6 */
+ DBG (2, "sane_init: trying to add %s\n", host);
+ add_device (host, 0);
+ }
+ free (copy);
+ }
+ else
+ DBG (1, "sane_init: not enough memory to duplicate "
+ "environment variable\n");
+ }
+
+ DBG (2, "sane_init: evaluating environment variable SANE_NET_TIMEOUT\n");
+ env = getenv ("SANE_NET_TIMEOUT");
+ if (env)
+ {
+ connect_timeout = atoi(env);
+ DBG (2, "sane_init: connect timeout set to %d seconds from env\n", connect_timeout);
+ }
+
+ DBG (2, "sane_init: done\n");
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+ Net_Scanner *handle, *next_handle;
+ Net_Device *dev, *next_device;
+ int i;
+
+ DBG (1, "sane_exit: exiting\n");
+
+#ifdef WITH_AVAHI
+ net_avahi_cleanup ();
+#endif /* WITH_AVAHI */
+
+ /* first, close all handles: */
+ for (handle = first_handle; handle; handle = next_handle)
+ {
+ next_handle = handle->next;
+ sane_close (handle);
+ }
+ first_handle = 0;
+
+ /* now close all devices: */
+ for (dev = first_device; dev; dev = next_device)
+ {
+ next_device = dev->next;
+
+ DBG (2, "sane_exit: closing dev %p, ctl=%d\n", (void *) dev, dev->ctl);
+
+ if (dev->ctl >= 0)
+ {
+ sanei_w_call (&dev->wire, SANE_NET_EXIT,
+ (WireCodecFunc) sanei_w_void, 0,
+ (WireCodecFunc) sanei_w_void, 0);
+ sanei_w_exit (&dev->wire);
+ close (dev->ctl);
+ }
+ if (dev->name)
+ free ((void *) dev->name);
+
+#ifdef NET_USES_AF_INDEP
+ if (dev->addr)
+ freeaddrinfo(dev->addr);
+#endif /* NET_USES_AF_INDEP */
+
+ free (dev);
+ }
+ if (devlist)
+ {
+ for (i = 0; devlist[i]; ++i)
+ {
+ if (devlist[i]->vendor)
+ free ((void *) devlist[i]->vendor);
+ if (devlist[i]->model)
+ free ((void *) devlist[i]->model);
+ if (devlist[i]->type)
+ free ((void *) devlist[i]->type);
+ free ((void *) devlist[i]);
+ }
+ free (devlist);
+ }
+ DBG (3, "sane_exit: finished.\n");
+}
+
+/* Note that a call to get_devices() implies that we'll have to
+ connect to all remote hosts. To avoid this, you can call
+ sane_open() directly (assuming you know the name of the
+ backend/device). This is appropriate for the command-line
+ interface of SANE, for example.
+ */
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+ static int devlist_size = 0, devlist_len = 0;
+ static const SANE_Device *empty_devlist[1] = { 0 };
+ SANE_Get_Devices_Reply reply;
+ SANE_Status status;
+ Net_Device *dev;
+ char *full_name;
+ int i, num_devs;
+ size_t len;
+#define ASSERT_SPACE(n) \
+ { \
+ if (devlist_len + (n) > devlist_size) \
+ { \
+ devlist_size += (n) + 15; \
+ if (devlist) \
+ devlist = realloc (devlist, devlist_size * sizeof (devlist[0])); \
+ else \
+ devlist = malloc (devlist_size * sizeof (devlist[0])); \
+ if (!devlist) \
+ { \
+ DBG (1, "sane_get_devices: not enough memory\n"); \
+ return SANE_STATUS_NO_MEM; \
+ } \
+ } \
+ }
+
+ DBG (3, "sane_get_devices: local_only = %d\n", local_only);
+
+ if (local_only)
+ {
+ *device_list = empty_devlist;
+ return SANE_STATUS_GOOD;
+ }
+
+ if (devlist)
+ {
+ DBG (2, "sane_get_devices: freeing devlist\n");
+ for (i = 0; devlist[i]; ++i)
+ {
+ if (devlist[i]->vendor)
+ free ((void *) devlist[i]->vendor);
+ if (devlist[i]->model)
+ free ((void *) devlist[i]->model);
+ if (devlist[i]->type)
+ free ((void *) devlist[i]->type);
+ free ((void *) devlist[i]);
+ }
+ free (devlist);
+ devlist = 0;
+ }
+ devlist_len = 0;
+ devlist_size = 0;
+
+ for (dev = first_device; dev; dev = dev->next)
+ {
+ if (dev->ctl < 0)
+ {
+ status = connect_dev (dev);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_get_devices: ignoring failure to connect to %s\n",
+ dev->name);
+ continue;
+ }
+ }
+ sanei_w_call (&dev->wire, SANE_NET_GET_DEVICES,
+ (WireCodecFunc) sanei_w_void, 0,
+ (WireCodecFunc) sanei_w_get_devices_reply, &reply);
+ if (reply.status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_get_devices: ignoring rpc-returned status %s\n",
+ sane_strstatus (reply.status));
+ sanei_w_free (&dev->wire,
+ (WireCodecFunc) sanei_w_get_devices_reply, &reply);
+ continue;
+ }
+
+ /* count the number of devices for this backend: */
+ for (num_devs = 0; reply.device_list[num_devs]; ++num_devs);
+
+ ASSERT_SPACE (num_devs);
+
+ for (i = 0; i < num_devs; ++i)
+ {
+ SANE_Device *rdev;
+ char *mem;
+#ifdef ENABLE_IPV6
+ SANE_Bool IPv6 = SANE_FALSE;
+#endif /* ENABLE_IPV6 */
+
+ /* create a new device entry with a device name that is the
+ sum of the backend name a colon and the backend's device
+ name: */
+ len = strlen (dev->name) + 1 + strlen (reply.device_list[i]->name);
+
+#ifdef ENABLE_IPV6
+ if (strchr (dev->name, ':') != NULL)
+ {
+ len += 2;
+ IPv6 = SANE_TRUE;
+ }
+#endif /* ENABLE_IPV6 */
+
+ mem = malloc (sizeof (*dev) + len + 1);
+ if (!mem)
+ {
+ DBG (1, "sane_get_devices: not enough free memory\n");
+ sanei_w_free (&dev->wire,
+ (WireCodecFunc) sanei_w_get_devices_reply,
+ &reply);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ memset (mem, 0, sizeof (*dev) + len);
+ full_name = mem + sizeof (*dev);
+
+#ifdef ENABLE_IPV6
+ if (IPv6 == SANE_TRUE)
+ strcat (full_name, "[");
+#endif /* ENABLE_IPV6 */
+
+ strcat (full_name, dev->name);
+
+#ifdef ENABLE_IPV6
+ if (IPv6 == SANE_TRUE)
+ strcat (full_name, "]");
+#endif /* ENABLE_IPV6 */
+
+ strcat (full_name, ":");
+ strcat (full_name, reply.device_list[i]->name);
+ DBG (3, "sane_get_devices: got %s\n", full_name);
+
+ rdev = (SANE_Device *) mem;
+ rdev->name = full_name;
+ rdev->vendor = strdup (reply.device_list[i]->vendor);
+ rdev->model = strdup (reply.device_list[i]->model);
+ rdev->type = strdup (reply.device_list[i]->type);
+
+ if ((!rdev->vendor) || (!rdev->model) || (!rdev->type))
+ {
+ DBG (1, "sane_get_devices: not enough free memory\n");
+ if (rdev->vendor)
+ free ((void *) rdev->vendor);
+ if (rdev->model)
+ free ((void *) rdev->model);
+ if (rdev->type)
+ free ((void *) rdev->type);
+ free (rdev);
+ sanei_w_free (&dev->wire,
+ (WireCodecFunc) sanei_w_get_devices_reply,
+ &reply);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ devlist[devlist_len++] = rdev;
+ }
+ /* now free up the rpc return value: */
+ sanei_w_free (&dev->wire,
+ (WireCodecFunc) sanei_w_get_devices_reply, &reply);
+ }
+
+ /* terminate device list with NULL entry: */
+ ASSERT_SPACE (1);
+ devlist[devlist_len++] = 0;
+
+ *device_list = devlist;
+ DBG (2, "sane_get_devices: finished (%d devices)\n", devlist_len - 1);
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const full_name, SANE_Handle * meta_handle)
+{
+ SANE_Open_Reply reply;
+ const char *dev_name;
+#ifdef ENABLE_IPV6
+ const char *tmp_name;
+ SANE_Bool v6addr = SANE_FALSE;
+#endif /* ENABLE_IPV6 */
+ SANE_String nd_name;
+ SANE_Status status;
+ SANE_Word handle;
+ SANE_Word ack;
+ Net_Device *dev;
+ Net_Scanner *s;
+ int need_auth;
+
+ DBG (3, "sane_open(\"%s\")\n", full_name);
+
+#ifdef ENABLE_IPV6
+ /*
+ * Check whether a numerical IPv6 host was specified
+ * [2001:42:42::12] <== check for '[' as full_name[0]
+ * ex: [2001:42:42::12]:test:0 (syntax taken from Apache 2)
+ */
+ if (full_name[0] == '[')
+ {
+ v6addr = SANE_TRUE;
+ tmp_name = strchr (full_name, ']');
+ if (!tmp_name)
+ {
+ DBG (1, "sane_open: incorrect host address: missing matching ']'\n");
+ return SANE_STATUS_INVAL;
+ }
+ }
+ else
+ tmp_name = full_name;
+
+ dev_name = strchr (tmp_name, ':');
+#else /* !ENABLE_IPV6 */
+
+ dev_name = strchr (full_name, ':');
+#endif /* ENABLE_IPV6 */
+
+ if (dev_name)
+ {
+#ifdef strndupa
+# ifdef ENABLE_IPV6
+ if (v6addr == SANE_TRUE)
+ nd_name = strndupa (full_name + 1, dev_name - full_name - 2);
+ else
+ nd_name = strndupa (full_name, dev_name - full_name);
+
+# else /* !ENABLE_IPV6 */
+
+ nd_name = strndupa (full_name, dev_name - full_name);
+# endif /* ENABLE_IPV6 */
+
+ if (!nd_name)
+ {
+ DBG (1, "sane_open: not enough free memory\n");
+ return SANE_STATUS_NO_MEM;
+ }
+#else
+ char *tmp;
+
+# ifdef ENABLE_IPV6
+ if (v6addr == SANE_TRUE)
+ tmp = alloca (dev_name - full_name - 2 + 1);
+ else
+ tmp = alloca (dev_name - full_name + 1);
+
+# else /* !ENABLE_IPV6 */
+
+ tmp = alloca (dev_name - full_name + 1);
+# endif /* ENABLE_IPV6 */
+
+ if (!tmp)
+ {
+ DBG (1, "sane_open: not enough free memory\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+# ifdef ENABLE_IPV6
+ if (v6addr == SANE_TRUE)
+ {
+ memcpy (tmp, full_name + 1, dev_name - full_name - 2);
+ tmp[dev_name - full_name - 2] = '\0';
+ }
+ else
+ {
+ memcpy (tmp, full_name, dev_name - full_name);
+ tmp[dev_name - full_name] = '\0';
+ }
+
+# else /* !ENABLE_IPV6 */
+
+ memcpy (tmp, full_name, dev_name - full_name);
+ tmp[dev_name - full_name] = '\0';
+# endif /* ENABLE_IPV6 */
+
+ nd_name = tmp;
+#endif
+ ++dev_name; /* skip colon */
+ }
+ else
+ {
+ /* if no colon interpret full_name as the host name; an empty
+ device name will cause us to open the first device of that
+ host. */
+#ifdef ENABLE_IPV6
+ if (v6addr == SANE_TRUE)
+ {
+ nd_name = alloca (strlen (full_name) - 2 + 1);
+ if (!nd_name)
+ {
+ DBG (1, "sane_open: not enough free memory\n");
+ return SANE_STATUS_NO_MEM;
+ }
+ memcpy (nd_name, full_name + 1, strlen (full_name) - 2);
+ nd_name[strlen (full_name) - 2] = '\0';
+ }
+ else
+ nd_name = (char *) full_name;
+
+#else /* !ENABLE_IPV6 */
+
+ nd_name = (char *) full_name;
+#endif /* ENABLE_IPV6 */
+
+ dev_name = "";
+ }
+ DBG (2, "sane_open: host = %s, device = %s\n", nd_name, dev_name);
+
+ if (!nd_name[0])
+ {
+ /* Unlike other backends, we never allow an empty backend-name.
+ Otherwise, it's possible that sane_open("") will result in
+ endless looping (consider the case where NET is the first
+ backend...) */
+
+ DBG (1, "sane_open: empty backend name is not allowed\n");
+ return SANE_STATUS_INVAL;
+ }
+ else
+ for (dev = first_device; dev; dev = dev->next)
+ if (strcmp (dev->name, nd_name) == 0)
+ break;
+
+ if (!dev)
+ {
+ DBG (1,
+ "sane_open: device %s not found, trying to register it anyway\n",
+ nd_name);
+ status = add_device (nd_name, &dev);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_open: could not open device\n");
+ return status;
+ }
+ }
+ else
+ DBG (2, "sane_open: device found in list\n");
+
+ if (dev->ctl < 0)
+ {
+ DBG (2, "sane_open: device not connected yet...\n");
+ status = connect_dev (dev);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_open: could not connect to device\n");
+ return status;
+ }
+ }
+
+ DBG (3, "sane_open: net_open\n");
+ sanei_w_call (&dev->wire, SANE_NET_OPEN,
+ (WireCodecFunc) sanei_w_string, &dev_name,
+ (WireCodecFunc) sanei_w_open_reply, &reply);
+ do
+ {
+ if (dev->wire.status != 0)
+ {
+ DBG (1, "sane_open: open rpc call failed (%s)\n",
+ strerror (dev->wire.status));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ status = reply.status;
+ handle = reply.handle;
+ need_auth = (reply.resource_to_authorize != 0);
+
+ if (need_auth)
+ {
+ DBG (3, "sane_open: authorization required\n");
+ do_authorization (dev, reply.resource_to_authorize);
+
+ sanei_w_free (&dev->wire, (WireCodecFunc) sanei_w_open_reply,
+ &reply);
+
+ if (dev->wire.direction != WIRE_DECODE)
+ sanei_w_set_dir (&dev->wire, WIRE_DECODE);
+ sanei_w_open_reply (&dev->wire, &reply);
+
+ continue;
+ }
+ else
+ sanei_w_free (&dev->wire, (WireCodecFunc) sanei_w_open_reply, &reply);
+
+ if (need_auth && !dev->auth_active)
+ {
+ DBG (2, "sane_open: open cancelled\n");
+ return SANE_STATUS_CANCELLED;
+ }
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_open: remote open failed\n");
+ return reply.status;
+ }
+ }
+ while (need_auth);
+
+ s = malloc (sizeof (*s));
+ if (!s)
+ {
+ DBG (1, "sane_open: not enough free memory\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ memset (s, 0, sizeof (*s));
+ s->hw = dev;
+ s->handle = handle;
+ s->data = -1;
+ s->next = first_handle;
+ s->local_opt.desc = 0;
+ s->local_opt.num_options = 0;
+
+ DBG (3, "sane_open: getting option descriptors\n");
+ status = fetch_options (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_open: fetch_options failed (%s), closing device again\n",
+ sane_strstatus (status));
+
+ sanei_w_call (&s->hw->wire, SANE_NET_CLOSE,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_word, &ack);
+
+ free (s);
+
+ return status;
+ }
+
+ first_handle = s;
+ *meta_handle = s;
+
+ DBG (3, "sane_open: success\n");
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+ Net_Scanner *prev, *s;
+ SANE_Word ack;
+ int option_number;
+
+ DBG (3, "sane_close: handle %p\n", handle);
+
+ prev = 0;
+ for (s = first_handle; s; s = s->next)
+ {
+ if (s == handle)
+ break;
+ prev = s;
+ }
+ if (!s)
+ {
+ DBG (1, "sane_close: invalid handle %p\n", handle);
+ return; /* oops, not a handle we know about */
+ }
+ if (prev)
+ prev->next = s->next;
+ else
+ first_handle = s->next;
+
+ if (s->opt.num_options)
+ {
+ DBG (2, "sane_close: removing cached option descriptors\n");
+ sanei_w_set_dir (&s->hw->wire, WIRE_FREE);
+ s->hw->wire.status = 0;
+ sanei_w_option_descriptor_array (&s->hw->wire, &s->opt);
+ if (s->hw->wire.status)
+ DBG (1, "sane_close: couldn't free sanei_w_option_descriptor_array "
+ "(%s)\n", sane_strstatus (s->hw->wire.status));
+ }
+
+ DBG (2, "sane_close: removing local option descriptors\n");
+ for (option_number = 0; option_number < s->local_opt.num_options;
+ option_number++)
+ free (s->local_opt.desc[option_number]);
+ if (s->local_opt.desc)
+ free (s->local_opt.desc);
+
+ DBG (2, "sane_close: net_close\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_CLOSE,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_word, &ack);
+ if (s->data >= 0)
+ {
+ DBG (2, "sane_close: closing data pipe\n");
+ close (s->data);
+ }
+ free (s);
+ DBG (2, "sane_close: done\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ Net_Scanner *s = handle;
+ SANE_Status status;
+
+ DBG (3, "sane_get_option_descriptor: option %d\n", option);
+
+ if (!s->options_valid)
+ {
+ DBG (3, "sane_get_option_descriptor: getting option descriptors\n");
+ status = fetch_options (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_get_option_descriptor: fetch_options failed (%s)\n",
+ sane_strstatus (status));
+ return 0;
+ }
+ }
+
+ if (((SANE_Word) option >= s->opt.num_options) || (option < 0))
+ {
+ DBG (2, "sane_get_option_descriptor: invalid option number\n");
+ return 0;
+ }
+ return s->local_opt.desc[option];
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *value, SANE_Word * info)
+{
+ Net_Scanner *s = handle;
+ SANE_Control_Option_Req req;
+ SANE_Control_Option_Reply reply;
+ SANE_Status status;
+ size_t value_size;
+ int need_auth;
+ SANE_Word local_info;
+
+ DBG (3, "sane_control_option: option %d, action %d\n", option, action);
+
+ if (!s->options_valid)
+ {
+ DBG (1, "sane_control_option: FRONTEND BUG: option descriptors reload needed\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ if (((SANE_Word) option >= s->opt.num_options) || (option < 0))
+ {
+ DBG (1, "sane_control_option: invalid option number\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ switch (s->opt.desc[option]->type)
+ {
+ case SANE_TYPE_BUTTON:
+ case SANE_TYPE_GROUP: /* shouldn't happen... */
+ /* the SANE standard defines that the option size of a BUTTON or
+ GROUP is IGNORED. */
+ value_size = 0;
+ break;
+ case SANE_TYPE_STRING: /* strings can be smaller than size */
+ value_size = s->opt.desc[option]->size;
+ if ((action == SANE_ACTION_SET_VALUE)
+ && (((SANE_Int) strlen ((SANE_String) value) + 1)
+ < s->opt.desc[option]->size))
+ value_size = strlen ((SANE_String) value) + 1;
+ break;
+ default:
+ value_size = s->opt.desc[option]->size;
+ break;
+ }
+
+ /* Avoid leaking memory bits */
+ if (value && (action != SANE_ACTION_SET_VALUE))
+ memset (value, 0, value_size);
+
+ /* for SET_AUTO the parameter ``value'' is ignored */
+ if (action == SANE_ACTION_SET_AUTO)
+ value_size = 0;
+
+ req.handle = s->handle;
+ req.option = option;
+ req.action = action;
+ req.value_type = s->opt.desc[option]->type;
+ req.value_size = value_size;
+ req.value = value;
+
+ local_info = 0;
+
+ DBG (3, "sane_control_option: remote control option\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_CONTROL_OPTION,
+ (WireCodecFunc) sanei_w_control_option_req, &req,
+ (WireCodecFunc) sanei_w_control_option_reply, &reply);
+
+ do
+ {
+ status = reply.status;
+ need_auth = (reply.resource_to_authorize != 0);
+ if (need_auth)
+ {
+ DBG (3, "sane_control_option: auth required\n");
+ do_authorization (s->hw, reply.resource_to_authorize);
+ sanei_w_free (&s->hw->wire,
+ (WireCodecFunc) sanei_w_control_option_reply, &reply);
+
+ sanei_w_set_dir (&s->hw->wire, WIRE_DECODE);
+
+ sanei_w_control_option_reply (&s->hw->wire, &reply);
+ continue;
+
+ }
+ else if (status == SANE_STATUS_GOOD)
+ {
+ local_info = reply.info;
+
+ if (info)
+ *info = reply.info;
+ if (value_size > 0)
+ {
+ if ((SANE_Word) value_size == reply.value_size)
+ memcpy (value, reply.value, reply.value_size);
+ else
+ DBG (1, "sane_control_option: size changed from %d to %d\n",
+ s->opt.desc[option]->size, reply.value_size);
+ }
+
+ if (reply.info & SANE_INFO_RELOAD_OPTIONS)
+ s->options_valid = 0;
+ }
+ sanei_w_free (&s->hw->wire,
+ (WireCodecFunc) sanei_w_control_option_reply, &reply);
+ if (need_auth && !s->hw->auth_active)
+ return SANE_STATUS_CANCELLED;
+ }
+ while (need_auth);
+
+ DBG (2, "sane_control_option: remote done (%s, info %x)\n", sane_strstatus (status), local_info);
+
+ if ((status == SANE_STATUS_GOOD) && (info == NULL) && (local_info & SANE_INFO_RELOAD_OPTIONS))
+ {
+ DBG (2, "sane_control_option: reloading options as frontend does not care\n");
+
+ status = fetch_options (s);
+
+ DBG (2, "sane_control_option: reload done (%s)\n", sane_strstatus (status));
+ }
+
+ DBG (2, "sane_control_option: done (%s, info %x)\n", sane_strstatus (status), local_info);
+
+ return status;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+ Net_Scanner *s = handle;
+ SANE_Get_Parameters_Reply reply;
+ SANE_Status status;
+
+ DBG (3, "sane_get_parameters\n");
+
+ if (!params)
+ {
+ DBG (1, "sane_get_parameters: parameter params not supplied\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG (3, "sane_get_parameters: remote get parameters\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_GET_PARAMETERS,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_get_parameters_reply, &reply);
+
+ status = reply.status;
+ *params = reply.params;
+ depth = reply.params.depth;
+ sanei_w_free (&s->hw->wire,
+ (WireCodecFunc) sanei_w_get_parameters_reply, &reply);
+
+ DBG (3, "sane_get_parameters: returned status %s\n",
+ sane_strstatus (status));
+ return status;
+}
+
+#ifdef NET_USES_AF_INDEP
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ Net_Scanner *s = handle;
+ SANE_Start_Reply reply;
+ struct sockaddr_in sin;
+ struct sockaddr *sa;
+#ifdef ENABLE_IPV6
+ struct sockaddr_in6 sin6;
+#endif /* ENABLE_IPV6 */
+ SANE_Status status;
+ int fd, need_auth;
+ socklen_t len;
+ uint16_t port; /* Internet-specific */
+
+
+ DBG (3, "sane_start\n");
+
+ hang_over = -1;
+ left_over = -1;
+
+ if (s->data >= 0)
+ {
+ DBG (2, "sane_start: data pipe already exists\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* Do this ahead of time so in case anything fails, we can
+ recover gracefully (without hanging our server). */
+
+ switch (s->hw->addr_used->ai_family)
+ {
+ case AF_INET:
+ len = sizeof (sin);
+ sa = (struct sockaddr *) &sin;
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ len = sizeof (sin6);
+ sa = (struct sockaddr *) &sin6;
+ break;
+#endif /* ENABLE_IPV6 */
+ default:
+ DBG (1, "sane_start: unknown address family : %d\n",
+ s->hw->addr_used->ai_family);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (getpeername (s->hw->ctl, sa, &len) < 0)
+ {
+ DBG (1, "sane_start: getpeername() failed (%s)\n", strerror (errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ fd = socket (s->hw->addr_used->ai_family, SOCK_STREAM, 0);
+ if (fd < 0)
+ {
+ DBG (1, "sane_start: socket() failed (%s)\n", strerror (errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ DBG (3, "sane_start: remote start\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_START,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_start_reply, &reply);
+ do
+ {
+ status = reply.status;
+ port = reply.port;
+ if (reply.byte_order == 0x1234)
+ {
+ server_big_endian = 0;
+ DBG (1, "sane_start: server has little endian byte order\n");
+ }
+ else
+ {
+ server_big_endian = 1;
+ DBG (1, "sane_start: server has big endian byte order\n");
+ }
+
+ need_auth = (reply.resource_to_authorize != 0);
+ if (need_auth)
+ {
+ DBG (3, "sane_start: auth required\n");
+ do_authorization (s->hw, reply.resource_to_authorize);
+
+ sanei_w_free (&s->hw->wire,
+ (WireCodecFunc) sanei_w_start_reply, &reply);
+
+ sanei_w_set_dir (&s->hw->wire, WIRE_DECODE);
+
+ sanei_w_start_reply (&s->hw->wire, &reply);
+
+ continue;
+ }
+ sanei_w_free (&s->hw->wire, (WireCodecFunc) sanei_w_start_reply,
+ &reply);
+ if (need_auth && !s->hw->auth_active)
+ return SANE_STATUS_CANCELLED;
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_start: remote start failed (%s)\n",
+ sane_strstatus (status));
+ close (fd);
+ return status;
+ }
+ }
+ while (need_auth);
+ DBG (3, "sane_start: remote start finished, data at port %hu\n", port);
+
+ switch (s->hw->addr_used->ai_family)
+ {
+ case AF_INET:
+ sin.sin_port = htons (port);
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ sin6.sin6_port = htons (port);
+ break;
+#endif /* ENABLE_IPV6 */
+ }
+
+ if (connect (fd, sa, len) < 0)
+ {
+ DBG (1, "sane_start: connect() failed (%s)\n", strerror (errno));
+ close (fd);
+ return SANE_STATUS_IO_ERROR;
+ }
+ shutdown (fd, 1);
+ s->data = fd;
+ s->reclen_buf_offset = 0;
+ s->bytes_remaining = 0;
+ DBG (3, "sane_start: done (%s)\n", sane_strstatus (status));
+ return status;
+}
+
+#else /* !NET_USES_AF_INDEP */
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ Net_Scanner *s = handle;
+ SANE_Start_Reply reply;
+ struct sockaddr_in sin;
+ SANE_Status status;
+ int fd, need_auth;
+ socklen_t len;
+ uint16_t port; /* Internet-specific */
+
+
+ DBG (3, "sane_start\n");
+
+ hang_over = -1;
+ left_over = -1;
+
+ if (s->data >= 0)
+ {
+ DBG (2, "sane_start: data pipe already exists\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* Do this ahead of time so in case anything fails, we can
+ recover gracefully (without hanging our server). */
+ len = sizeof (sin);
+ if (getpeername (s->hw->ctl, (struct sockaddr *) &sin, &len) < 0)
+ {
+ DBG (1, "sane_start: getpeername() failed (%s)\n", strerror (errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ fd = socket (s->hw->addr.sa_family, SOCK_STREAM, 0);
+ if (fd < 0)
+ {
+ DBG (1, "sane_start: socket() failed (%s)\n", strerror (errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ DBG (3, "sane_start: remote start\n");
+ sanei_w_call (&s->hw->wire, SANE_NET_START,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_start_reply, &reply);
+ do
+ {
+
+ status = reply.status;
+ port = reply.port;
+ if (reply.byte_order == 0x1234)
+ {
+ server_big_endian = 0;
+ DBG (1, "sane_start: server has little endian byte order\n");
+ }
+ else
+ {
+ server_big_endian = 1;
+ DBG (1, "sane_start: server has big endian byte order\n");
+ }
+
+ need_auth = (reply.resource_to_authorize != 0);
+ if (need_auth)
+ {
+ DBG (3, "sane_start: auth required\n");
+ do_authorization (s->hw, reply.resource_to_authorize);
+
+ sanei_w_free (&s->hw->wire,
+ (WireCodecFunc) sanei_w_start_reply, &reply);
+
+ sanei_w_set_dir (&s->hw->wire, WIRE_DECODE);
+
+ sanei_w_start_reply (&s->hw->wire, &reply);
+
+ continue;
+ }
+ sanei_w_free (&s->hw->wire, (WireCodecFunc) sanei_w_start_reply,
+ &reply);
+ if (need_auth && !s->hw->auth_active)
+ return SANE_STATUS_CANCELLED;
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (1, "sane_start: remote start failed (%s)\n",
+ sane_strstatus (status));
+ close (fd);
+ return status;
+ }
+ }
+ while (need_auth);
+ DBG (3, "sane_start: remote start finished, data at port %hu\n", port);
+ sin.sin_port = htons (port);
+
+ if (connect (fd, (struct sockaddr *) &sin, len) < 0)
+ {
+ DBG (1, "sane_start: connect() failed (%s)\n", strerror (errno));
+ close (fd);
+ return SANE_STATUS_IO_ERROR;
+ }
+ shutdown (fd, 1);
+ s->data = fd;
+ s->reclen_buf_offset = 0;
+ s->bytes_remaining = 0;
+ DBG (3, "sane_start: done (%s)\n", sane_strstatus (status));
+ return status;
+}
+#endif /* NET_USES_AF_INDEP */
+
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * data, SANE_Int max_length,
+ SANE_Int * length)
+{
+ Net_Scanner *s = handle;
+ ssize_t nread;
+ SANE_Int cnt;
+ SANE_Int start_cnt;
+ SANE_Int end_cnt;
+ SANE_Byte swap_buf;
+ SANE_Byte temp_hang_over;
+ int is_even;
+
+ DBG (3, "sane_read: handle=%p, data=%p, max_length=%d, length=%p\n",
+ handle, data, max_length, (void *) length);
+ if (!length)
+ {
+ DBG (1, "sane_read: length == NULL\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ is_even = 1;
+ *length = 0;
+
+ /* If there's a left over, i.e. a byte already in the correct byte order,
+ return it immediately; otherwise read may fail with a SANE_STATUS_EOF and
+ the caller never can read the last byte */
+ if ((depth == 16) && (server_big_endian != client_big_endian))
+ {
+ if (left_over > -1)
+ {
+ DBG (3, "sane_read: left_over from previous call, return "
+ "immediately\n");
+ /* return the byte, we've currently scanned; hang_over becomes
+ left_over */
+ *data = (SANE_Byte) left_over;
+ left_over = -1;
+ *length = 1;
+ return SANE_STATUS_GOOD;
+ }
+ }
+
+ if (s->data < 0)
+ {
+ DBG (1, "sane_read: data pipe doesn't exist, scan cancelled?\n");
+ return SANE_STATUS_CANCELLED;
+ }
+
+ if (s->bytes_remaining == 0)
+ {
+ /* boy, is this painful or what? */
+
+ DBG (4, "sane_read: reading packet length\n");
+ nread = read (s->data, s->reclen_buf + s->reclen_buf_offset,
+ 4 - s->reclen_buf_offset);
+ if (nread < 0)
+ {
+ DBG (3, "sane_read: read failed (%s)\n", strerror (errno));
+ if (errno == EAGAIN)
+ {
+ DBG (3, "sane_read: try again later\n");
+ return SANE_STATUS_GOOD;
+ }
+ else
+ {
+ DBG (1, "sane_read: cancelling read\n");
+ do_cancel (s);
+ return SANE_STATUS_IO_ERROR;
+ }
+ }
+ DBG (4, "sane_read: read %lu bytes, %d from 4 total\n", (u_long) nread,
+ s->reclen_buf_offset);
+ s->reclen_buf_offset += nread;
+ if (s->reclen_buf_offset < 4)
+ {
+ DBG (4, "sane_read: enough for now\n");
+ return SANE_STATUS_GOOD;
+ }
+
+ s->reclen_buf_offset = 0;
+ s->bytes_remaining = (((u_long) s->reclen_buf[0] << 24)
+ | ((u_long) s->reclen_buf[1] << 16)
+ | ((u_long) s->reclen_buf[2] << 8)
+ | ((u_long) s->reclen_buf[3] << 0));
+ DBG (3, "sane_read: next record length=%ld bytes\n",
+ (long) s->bytes_remaining);
+ if (s->bytes_remaining == 0xffffffff)
+ {
+ char ch;
+
+ DBG (2, "sane_read: received error signal\n");
+
+ /* turn off non-blocking I/O (s->data will be closed anyhow): */
+ fcntl (s->data, F_SETFL, 0);
+
+ /* read the status byte: */
+ if (read (s->data, &ch, sizeof (ch)) != 1)
+ {
+ DBG (1, "sane_read: failed to read error code\n");
+ ch = SANE_STATUS_IO_ERROR;
+ }
+ DBG (1, "sane_read: error code %s\n",
+ sane_strstatus ((SANE_Status) ch));
+ do_cancel (s);
+ return (SANE_Status) ch;
+ }
+ }
+
+ if (max_length > (SANE_Int) s->bytes_remaining)
+ max_length = s->bytes_remaining;
+
+ nread = read (s->data, data, max_length);
+
+ if (nread < 0)
+ {
+ DBG (2, "sane_read: error code %s\n", strerror (errno));
+ if (errno == EAGAIN)
+ return SANE_STATUS_GOOD;
+ else
+ {
+ DBG (1, "sane_read: cancelling scan\n");
+ do_cancel (s);
+ return SANE_STATUS_IO_ERROR;
+ }
+ }
+
+ s->bytes_remaining -= nread;
+
+ *length = nread;
+ /* Check whether we are scanning with a depth of 16 bits/pixel and whether
+ server and client have different byte order. If this is true, then it's
+ neccessary to check whether read returned an odd number. If an odd number
+ has been returned, we must save the last byte.
+ */
+ if ((depth == 16) && (server_big_endian != client_big_endian))
+ {
+ DBG (1,"sane_read: client/server have different byte order; "
+ "must swap\n");
+ /* special case: 1 byte scanned and hang_over */
+ if ((nread == 1) && (hang_over > -1))
+ {
+ /* return the byte, we've currently scanned; hang_over becomes
+ left_over */
+ left_over = hang_over;
+ hang_over = -1;
+ return SANE_STATUS_GOOD;
+ }
+ /* check whether an even or an odd number of bytes has been scanned */
+ if ((nread % 2) == 0)
+ is_even = 1;
+ else
+ is_even = 0;
+ /* check, whether there's a hang over from a previous call;
+ in this case we memcopy the data up one byte */
+ if ((nread > 1) && (hang_over > -1))
+ {
+ /* store last byte */
+ temp_hang_over = *(data + nread - 1);
+ memmove (data + 1, data, nread - 1);
+ *data = (SANE_Byte) hang_over;
+ /* what happens with the last byte depends on whether the number
+ of bytes is even or odd */
+ if (is_even == 1)
+ {
+ /* number of bytes is even; no new hang_over, exchange last
+ byte with hang over; last byte becomes left_over */
+ left_over = *(data + nread - 1);
+ *(data + nread - 1) = temp_hang_over;
+ hang_over = -1;
+ start_cnt = 0;
+ /* last byte already swapped */
+ end_cnt = nread - 2;
+ }
+ else
+ {
+ /* number of bytes is odd; last byte becomes new hang_over */
+ hang_over = temp_hang_over;
+ left_over = -1;
+ start_cnt = 0;
+ end_cnt = nread - 1;
+ }
+ }
+ else if (nread == 1)
+ {
+ /* if only one byte has been read, save it as hang_over and return
+ length=0 */
+ hang_over = (int) *data;
+ *length = 0;
+ return SANE_STATUS_GOOD;
+ }
+ else
+ {
+ /* no hang_over; test for even or odd byte number */
+ if(is_even == 1)
+ {
+ start_cnt = 0;
+ end_cnt = *length;
+ }
+ else
+ {
+ start_cnt = 0;
+ hang_over = *(data + *length - 1);
+ *length -= 1;
+ end_cnt = *length;
+ }
+ }
+ /* swap the bytes */
+ for (cnt = start_cnt; cnt < end_cnt - 1; cnt += 2)
+ {
+ swap_buf = *(data + cnt);
+ *(data + cnt) = *(data + cnt + 1);
+ *(data + cnt + 1) = swap_buf;
+ }
+ }
+ DBG (3, "sane_read: %lu bytes read, %lu remaining\n", (u_long) nread,
+ (u_long) s->bytes_remaining);
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+ Net_Scanner *s = handle;
+ SANE_Word ack;
+
+ DBG (3, "sane_cancel: sending net_cancel\n");
+
+ sanei_w_call (&s->hw->wire, SANE_NET_CANCEL,
+ (WireCodecFunc) sanei_w_word, &s->handle,
+ (WireCodecFunc) sanei_w_word, &ack);
+ do_cancel (s);
+ DBG (4, "sane_cancel: done\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+ Net_Scanner *s = handle;
+
+ DBG (3, "sane_set_io_mode: non_blocking = %d\n", non_blocking);
+ if (s->data < 0)
+ {
+ DBG (1, "sane_set_io_mode: pipe doesn't exist\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ if (fcntl (s->data, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0)
+ {
+ DBG (1, "sane_set_io_mode: fcntl failed (%s)\n", strerror (errno));
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+ Net_Scanner *s = handle;
+
+ DBG (3, "sane_get_select_fd\n");
+
+ if (s->data < 0)
+ {
+ DBG (1, "sane_get_select_fd: pipe doesn't exist\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ *fd = s->data;
+ DBG (3, "sane_get_select_fd: done; *fd = %d\n", *fd);
+ return SANE_STATUS_GOOD;
+}