diff options
Diffstat (limited to 'backend/net.c')
| -rw-r--r-- | backend/net.c | 2378 |
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; +} |