kopia lustrzana https://gitlab.com/sane-project/backends
887 wiersze
23 KiB
C
887 wiersze
23 KiB
C
/* sane - Scanner Access Now Easy.
|
|
Copyright (C) 1996, 1997 David Mosberger-Tang
|
|
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 dynamic linking based SANE meta backend. It
|
|
allows managing an arbitrary number of SANE backends by using
|
|
dynamic linking to load backends on demand. */
|
|
|
|
#ifdef _AIX
|
|
# include "lalloca.h" /* MUST come first for AIX! */
|
|
#endif
|
|
|
|
#include "sane/config.h"
|
|
#include "lalloca.h"
|
|
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#if defined(HAVE_DLOPEN) && defined(HAVE_DLFCN_H)
|
|
# include <dlfcn.h>
|
|
|
|
/* Older versions of dlopen() don't define RTLD_NOW and RTLD_LAZY.
|
|
They all seem to use a mode of 1 to indicate RTLD_NOW and some do
|
|
not support RTLD_LAZY at all. Hence, unless defined, we define
|
|
both macros as 1 to play it safe. */
|
|
# ifndef RTLD_NOW
|
|
# define RTLD_NOW 1
|
|
# endif
|
|
# ifndef RTLD_LAZY
|
|
# define RTLD_LAZY 1
|
|
# endif
|
|
# define HAVE_DLL
|
|
#endif
|
|
|
|
/* HP/UX DLL support */
|
|
#if defined (HAVE_SHL_LOAD) && defined(HAVE_DL_H)
|
|
# include <dl.h>
|
|
# define HAVE_DLL
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include "sane/sane.h"
|
|
#include "sane/sanei.h"
|
|
|
|
#define BACKEND_NAME dll
|
|
#include "sane/sanei_backend.h"
|
|
|
|
#ifndef PATH_MAX
|
|
# define PATH_MAX 1024
|
|
#endif
|
|
|
|
#include "sane/sanei_config.h"
|
|
#define DLL_CONFIG_FILE "dll.conf"
|
|
#define DLL_ALIASES_FILE "dll.aliases"
|
|
|
|
enum SANE_Ops
|
|
{
|
|
OP_INIT = 0,
|
|
OP_EXIT,
|
|
OP_GET_DEVS,
|
|
OP_OPEN,
|
|
OP_CLOSE,
|
|
OP_GET_OPTION_DESC,
|
|
OP_CTL_OPTION,
|
|
OP_GET_PARAMS,
|
|
OP_START,
|
|
OP_READ,
|
|
OP_CANCEL,
|
|
OP_SET_IO_MODE,
|
|
OP_GET_SELECT_FD,
|
|
NUM_OPS
|
|
};
|
|
|
|
struct backend
|
|
{
|
|
struct backend *next;
|
|
const char *name;
|
|
u_int permanent : 1; /* is the backend preloaded? */
|
|
u_int loaded : 1; /* are the functions available? */
|
|
u_int inited : 1; /* has the backend been initialized? */
|
|
void *handle; /* handle returned by dlopen() */
|
|
void *(*op[NUM_OPS]) ();
|
|
};
|
|
|
|
#define BE_ENTRY(be,func) sane_##be##_##func
|
|
|
|
#define PRELOAD_DECL(name) \
|
|
extern void *BE_ENTRY(name,init) (); \
|
|
extern void *BE_ENTRY(name,exit) (); \
|
|
extern void *BE_ENTRY(name,get_devices) (); \
|
|
extern void *BE_ENTRY(name,open) (); \
|
|
extern void *BE_ENTRY(name,close) (); \
|
|
extern void *BE_ENTRY(name,get_option_descriptor) (); \
|
|
extern void *BE_ENTRY(name,control_option) (); \
|
|
extern void *BE_ENTRY(name,get_parameters) (); \
|
|
extern void *BE_ENTRY(name,start) (); \
|
|
extern void *BE_ENTRY(name,read) (); \
|
|
extern void *BE_ENTRY(name,cancel) (); \
|
|
extern void *BE_ENTRY(name,set_io_mode) (); \
|
|
extern void *BE_ENTRY(name,get_select_fd) ();
|
|
|
|
#define PRELOAD_DEFN(name) \
|
|
{ \
|
|
0 /* next */, #name, \
|
|
1 /* permanent */, \
|
|
1 /* loaded */, \
|
|
0 /* inited */, \
|
|
0 /* handle */, \
|
|
{ \
|
|
BE_ENTRY(name,init), \
|
|
BE_ENTRY(name,exit), \
|
|
BE_ENTRY(name,get_devices), \
|
|
BE_ENTRY(name,open), \
|
|
BE_ENTRY(name,close), \
|
|
BE_ENTRY(name,get_option_descriptor), \
|
|
BE_ENTRY(name,control_option), \
|
|
BE_ENTRY(name,get_parameters), \
|
|
BE_ENTRY(name,start), \
|
|
BE_ENTRY(name,read), \
|
|
BE_ENTRY(name,cancel), \
|
|
BE_ENTRY(name,set_io_mode), \
|
|
BE_ENTRY(name,get_select_fd) \
|
|
} \
|
|
}
|
|
|
|
#include "dll-preload.c"
|
|
|
|
struct meta_scanner
|
|
{
|
|
struct backend *be;
|
|
SANE_Handle handle;
|
|
};
|
|
|
|
struct alias
|
|
{
|
|
struct alias *next;
|
|
char *oldname;
|
|
char *newname;
|
|
};
|
|
|
|
/*
|
|
* List of available devices, allocated by sane_get_devices, released
|
|
* by sane_exit()
|
|
*/
|
|
static const SANE_Device **devlist = NULL;
|
|
static int devlist_size = 0, devlist_len = 0;
|
|
|
|
static struct alias *first_alias;
|
|
static SANE_Auth_Callback auth_callback;
|
|
static struct backend *first_backend;
|
|
static const char *op_name[] =
|
|
{
|
|
"init", "exit", "get_devices", "open", "close", "get_option_descriptor",
|
|
"control_option", "get_parameters", "start", "read", "cancel",
|
|
"set_io_mode", "get_select_fd"
|
|
};
|
|
|
|
static void *
|
|
op_unsupported (void)
|
|
{
|
|
DBG(1, "call to unsupported backend operation\n");
|
|
return (void *) (long) SANE_STATUS_UNSUPPORTED;
|
|
}
|
|
|
|
|
|
static SANE_Status
|
|
add_backend (const char *name, struct backend **bep)
|
|
{
|
|
struct backend *be, *prev;
|
|
|
|
DBG(1, "adding backend %s\n", name);
|
|
|
|
if (strcmp(name,"dll") == 0)
|
|
{
|
|
DBG( 0, "remove the dll-backend from your dll.conf !!!\n");
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
for (prev = 0, be = first_backend; be; prev = be, be = be->next)
|
|
if (strcmp (be->name, name) == 0)
|
|
{
|
|
DBG(1, "...already there\n");
|
|
/* move to front so we preserve order that we'd get with
|
|
dynamic loading: */
|
|
if (prev)
|
|
{
|
|
prev->next = be->next;
|
|
be->next = first_backend;
|
|
first_backend = be;
|
|
}
|
|
if (bep)
|
|
*bep = be;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
be = calloc (1, sizeof (*be));
|
|
if (!be)
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
be->name = strdup (name);
|
|
if (!be->name)
|
|
return SANE_STATUS_NO_MEM;
|
|
be->next = first_backend;
|
|
first_backend = be;
|
|
if (bep)
|
|
*bep = be;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
static SANE_Status
|
|
load (struct backend *be)
|
|
{
|
|
#ifdef HAVE_DLL
|
|
int mode = 0;
|
|
char *funcname, *src, *dir, *path = 0;
|
|
char libname[PATH_MAX];
|
|
int i;
|
|
FILE *fp = 0;
|
|
|
|
#if defined(HAVE_DLOPEN)
|
|
# define PREFIX "libsane-"
|
|
# define POSTFIX ".so.%u"
|
|
mode = getenv ("LD_BIND_NOW") ? RTLD_NOW : RTLD_LAZY;
|
|
#elif defined(HAVE_SHL_LOAD)
|
|
# define PREFIX "libsane-"
|
|
# define POSTFIX ".sl.%u"
|
|
mode = BIND_DEFERRED;
|
|
#else
|
|
# error "Tried to compile unsupported DLL."
|
|
#endif /* HAVE_DLOPEN */
|
|
|
|
DBG(1, "loading backend %s\n", be->name);
|
|
|
|
/* initialize all ops to "unsupported" so we can "use" the backend
|
|
even if the stuff later in this function fails */
|
|
be->loaded = 1;
|
|
be->handle = 0;
|
|
for (i = 0; i < NUM_OPS; ++i)
|
|
be->op[i] = op_unsupported;
|
|
|
|
dir = STRINGIFY(LIBDIR);
|
|
while (dir)
|
|
{
|
|
snprintf (libname, sizeof (libname), "%s/"PREFIX"%s"POSTFIX,
|
|
dir, be->name, V_MAJOR);
|
|
fp = fopen (libname, "r");
|
|
if (fp)
|
|
break;
|
|
|
|
if (!path)
|
|
{
|
|
path = getenv ("LD_LIBRARY_PATH");
|
|
if (!path)
|
|
{
|
|
path = getenv ("SHLIB_PATH"); /* for HP-UX */
|
|
if (!path)
|
|
path = getenv ("LIBPATH"); /* for AIX */
|
|
}
|
|
if (!path)
|
|
break;
|
|
|
|
path = strdup (path);
|
|
src = path;
|
|
}
|
|
dir = strsep (&src, ":");
|
|
}
|
|
if (path)
|
|
free (path);
|
|
if (!fp)
|
|
{
|
|
DBG(2, "load: couldn't find %s (%s)\n",
|
|
libname, strerror (errno));
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
DBG(2, "dlopen()ing `%s'\n", libname);
|
|
|
|
#ifdef HAVE_DLOPEN
|
|
be->handle = dlopen (libname, mode);
|
|
#elif defined(HAVE_SHL_LOAD)
|
|
be->handle = (shl_t)shl_load (libname, mode, 0L);
|
|
#else
|
|
# error "Tried to compile unsupported DLL."
|
|
#endif /* HAVE_DLOPEN */
|
|
if (!be->handle)
|
|
{
|
|
#ifdef HAVE_DLOPEN
|
|
DBG(2, "dlopen() failed (%s)\n", dlerror());
|
|
#else
|
|
DBG(2, "dlopen() failed (%s)\n", strerror (errno));
|
|
#endif
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
/* all is dandy---lookup and fill in backend ops: */
|
|
funcname = alloca (strlen (be->name) + 64);
|
|
for (i = 0; i < NUM_OPS; ++i)
|
|
{
|
|
void *(*op) ();
|
|
|
|
sprintf (funcname, "_sane_%s_%s", be->name, op_name[i]);
|
|
|
|
/* First try looking up the symbol without a leading underscore. */
|
|
#ifdef HAVE_DLOPEN
|
|
op = (void *(*)()) dlsym (be->handle, funcname + 1);
|
|
#elif defined(HAVE_SHL_LOAD)
|
|
shl_findsym ((shl_t*)&(be->handle), funcname + 1, TYPE_UNDEFINED, &op);
|
|
#else
|
|
# error "Tried to compile unsupported DLL."
|
|
#endif /* HAVE_DLOPEN */
|
|
if (op)
|
|
be->op[i] = op;
|
|
else
|
|
{
|
|
/* Try again, with an underscore prepended. */
|
|
#ifdef HAVE_DLOPEN
|
|
op = (void *(*)()) dlsym (be->handle, funcname);
|
|
#elif defined(HAVE_SHL_LOAD)
|
|
shl_findsym (be->handle, funcname, TYPE_UNDEFINED, &op);
|
|
#else
|
|
# error "Tried to compile unsupported DLL."
|
|
#endif /* HAVE_DLOPEN */
|
|
if (op)
|
|
be->op[i] = op;
|
|
}
|
|
if (NULL == op)
|
|
DBG(2, "unable to find %s\n", funcname);
|
|
}
|
|
|
|
return SANE_STATUS_GOOD;
|
|
|
|
# undef PREFIX
|
|
# undef POSTFIX
|
|
#else /* HAVE_DLL */
|
|
DBG(1, "load: ignoring attempt to load `%s'; compiled without dl support\n",
|
|
be->name);
|
|
return SANE_STATUS_UNSUPPORTED;
|
|
#endif /* HAVE_DLL */
|
|
}
|
|
|
|
static SANE_Status
|
|
init (struct backend *be)
|
|
{
|
|
SANE_Status status;
|
|
SANE_Int version;
|
|
|
|
if (!be->loaded)
|
|
{
|
|
status = load (be);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
}
|
|
|
|
DBG(3, "init: initializing backend `%s'\n", be->name);
|
|
|
|
status = (long) (*be->op[OP_INIT]) (&version, auth_callback);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
|
|
if (SANE_VERSION_MAJOR (version) != V_MAJOR)
|
|
return SANE_STATUS_INVAL;
|
|
|
|
be->inited = 1;
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
|
|
static void
|
|
add_alias (char *line)
|
|
{
|
|
const char *command;
|
|
enum { CMD_ALIAS, CMD_HIDE } cmd;
|
|
const char *oldname, *oldend, *newname, *newend;
|
|
size_t oldlen, newlen;
|
|
struct alias *alias;
|
|
|
|
command = sanei_config_skip_whitespace(line);
|
|
if( !*command )
|
|
return;
|
|
line = strpbrk(command, " \t");
|
|
if( !line )
|
|
return;
|
|
*line++ = '\0';
|
|
|
|
if( strcmp(command, "alias") == 0 )
|
|
cmd = CMD_ALIAS;
|
|
else
|
|
if( strcmp(command, "hide") == 0 )
|
|
cmd = CMD_HIDE;
|
|
else
|
|
return;
|
|
|
|
newlen = 0;
|
|
newname = NULL;
|
|
if( cmd == CMD_ALIAS )
|
|
{
|
|
newname = sanei_config_skip_whitespace(line);
|
|
if( !*newname )
|
|
return;
|
|
if( *newname == '\"' )
|
|
{
|
|
++newname;
|
|
newend = strchr(newname, '\"');
|
|
}
|
|
else
|
|
newend = strpbrk(newname, " \t");
|
|
if( !newend )
|
|
return;
|
|
|
|
newlen = newend - newname;
|
|
line = (char*)(newend+1);
|
|
}
|
|
|
|
oldname = sanei_config_skip_whitespace(line);
|
|
if( !*oldname )
|
|
return;
|
|
oldend = oldname + strcspn(oldname, " \t");
|
|
|
|
oldlen = oldend - oldname;
|
|
|
|
alias = malloc(sizeof(struct alias));
|
|
if( alias )
|
|
{
|
|
alias->oldname = malloc(oldlen + newlen + 2);
|
|
if( alias->oldname )
|
|
{
|
|
strncpy(alias->oldname, oldname, oldlen);
|
|
alias->oldname[oldlen] = '\0';
|
|
if( cmd == CMD_ALIAS )
|
|
{
|
|
alias->newname = alias->oldname + oldlen + 1;
|
|
strncpy(alias->newname, newname, newlen);
|
|
alias->newname[newlen] = '\0';
|
|
}
|
|
else
|
|
alias->newname = NULL;
|
|
|
|
alias->next = first_alias;
|
|
first_alias = alias;
|
|
return;
|
|
}
|
|
free(alias);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
SANE_Status
|
|
sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
|
|
{
|
|
char backend_name[PATH_MAX];
|
|
size_t len;
|
|
FILE *fp;
|
|
int i;
|
|
|
|
DBG_INIT();
|
|
|
|
auth_callback = authorize;
|
|
|
|
/* chain preloaded backends together: */
|
|
for (i = 0; i < NELEMS(preloaded_backends); ++i)
|
|
{
|
|
if (!preloaded_backends[i].name)
|
|
continue;
|
|
preloaded_backends[i].next = first_backend;
|
|
first_backend = &preloaded_backends[i];
|
|
}
|
|
|
|
if (version_code)
|
|
*version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, 0);
|
|
|
|
fp = sanei_config_open (DLL_CONFIG_FILE);
|
|
if (!fp)
|
|
return SANE_STATUS_GOOD; /* don't insist on config file */
|
|
|
|
while (sanei_config_read (backend_name, sizeof (backend_name), fp))
|
|
{
|
|
if (backend_name[0] == '#') /* ignore line comments */
|
|
continue;
|
|
len = strlen (backend_name);
|
|
if (backend_name[len - 1] == '\n')
|
|
backend_name[--len] = '\0';
|
|
|
|
if (!len)
|
|
continue; /* ignore empty lines */
|
|
|
|
add_backend (backend_name, 0);
|
|
}
|
|
fclose (fp);
|
|
|
|
fp = sanei_config_open (DLL_ALIASES_FILE);
|
|
if (!fp)
|
|
return SANE_STATUS_GOOD; /* don't insist on aliases file */
|
|
|
|
while (sanei_config_read (backend_name, sizeof (backend_name), fp))
|
|
{
|
|
if (backend_name[0] == '#') /* ignore line comments */
|
|
continue;
|
|
len = strlen (backend_name);
|
|
|
|
if (!len)
|
|
continue; /* ignore empty lines */
|
|
|
|
add_alias (backend_name);
|
|
}
|
|
fclose (fp);
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
void
|
|
sane_exit (void)
|
|
{
|
|
struct backend *be, *next;
|
|
struct alias *alias;
|
|
|
|
DBG(1, "exiting\n");
|
|
|
|
for (be = first_backend; be; be = next)
|
|
{
|
|
next = be->next;
|
|
if (be->loaded)
|
|
{
|
|
DBG(2, "calling backend `%s's exit function\n", be->name);
|
|
(*be->op[OP_EXIT]) ();
|
|
#ifdef HAVE_DLL
|
|
|
|
#ifdef HAVE_DLOPEN
|
|
if (be->handle)
|
|
dlclose (be->handle);
|
|
#elif defined(HAVE_SHL_LOAD)
|
|
if (be->handle)
|
|
shl_unload(be->handle);
|
|
#else
|
|
# error "Tried to compile unsupported DLL."
|
|
#endif /* HAVE_DLOPEN */
|
|
|
|
#endif /* HAVE_DLL */
|
|
}
|
|
if (!be->permanent)
|
|
{
|
|
if (be->name)
|
|
free ((void *) be->name);
|
|
free (be);
|
|
}
|
|
}
|
|
first_backend = 0;
|
|
|
|
while( (alias = first_alias) != NULL )
|
|
{
|
|
first_alias = first_alias->next;
|
|
free(alias->oldname);
|
|
free(alias);
|
|
}
|
|
|
|
if (NULL != devlist)
|
|
{ /* Release memory allocated by sane_get_devices(). */
|
|
int i = 0;
|
|
while (devlist[i])
|
|
free(devlist[i++]);
|
|
free(devlist);
|
|
|
|
devlist = NULL;
|
|
devlist_size = 0;
|
|
devlist_len = 0;
|
|
}
|
|
}
|
|
|
|
/* Note that a call to get_devices() implies that we'll have to load
|
|
all backends. 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)
|
|
{
|
|
const SANE_Device **be_list;
|
|
struct backend *be;
|
|
SANE_Status status;
|
|
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) \
|
|
return SANE_STATUS_NO_MEM; \
|
|
} \
|
|
}
|
|
|
|
if (devlist)
|
|
for (i = 0; i < devlist_len; ++i)
|
|
free ((void *) devlist[i]);
|
|
devlist_len = 0;
|
|
|
|
for (be = first_backend; be; be = be->next)
|
|
{
|
|
if (!be->inited)
|
|
if (init (be) != SANE_STATUS_GOOD)
|
|
continue;
|
|
|
|
status = (long) (*be->op[OP_GET_DEVS]) (&be_list, local_only);
|
|
if (status != SANE_STATUS_GOOD || !be_list)
|
|
continue;
|
|
|
|
/* count the number of devices for this backend: */
|
|
for (num_devs = 0; be_list[num_devs]; ++num_devs);
|
|
|
|
ASSERT_SPACE (num_devs);
|
|
|
|
for (i = 0; i < num_devs; ++i)
|
|
{
|
|
SANE_Device *dev;
|
|
char *mem;
|
|
struct alias *alias;
|
|
|
|
for(alias = first_alias; alias != NULL; alias = alias->next)
|
|
{
|
|
len = strlen(be->name);
|
|
if( strlen(alias->oldname) <= len )
|
|
continue;
|
|
if( strncmp(alias->oldname, be->name, len) == 0
|
|
&& alias->oldname[len] == ':'
|
|
&& strcmp(&alias->oldname[len+1], be_list[i]->name) == 0 )
|
|
break;
|
|
}
|
|
|
|
if( alias )
|
|
{
|
|
if( !alias->newname ) /* hidden device */
|
|
continue;
|
|
|
|
len = strlen(alias->newname);
|
|
mem = malloc(sizeof(*dev) + len + 1);
|
|
if( !mem )
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
full_name = mem + sizeof(*dev);
|
|
strcpy(full_name, alias->newname);
|
|
}
|
|
else
|
|
{
|
|
/* 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 (be->name) + 1 + strlen (be_list[i]->name);
|
|
mem = malloc (sizeof (*dev) + len + 1);
|
|
if (!mem)
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
full_name = mem + sizeof (*dev);
|
|
strcpy (full_name, be->name);
|
|
strcat (full_name, ":");
|
|
strcat (full_name, be_list[i]->name);
|
|
}
|
|
|
|
dev = (SANE_Device *) mem;
|
|
dev->name = full_name;
|
|
dev->vendor = be_list[i]->vendor;
|
|
dev->model = be_list[i]->model;
|
|
dev->type = be_list[i]->type;
|
|
|
|
devlist[devlist_len++] = dev;
|
|
}
|
|
}
|
|
|
|
/* terminate device list with NULL entry: */
|
|
ASSERT_SPACE (1);
|
|
devlist[devlist_len++] = 0;
|
|
|
|
*device_list = devlist;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
SANE_Status
|
|
sane_open (SANE_String_Const full_name, SANE_Handle * meta_handle)
|
|
{
|
|
const char *be_name, *dev_name;
|
|
struct meta_scanner *s;
|
|
SANE_Handle *handle;
|
|
struct backend *be;
|
|
SANE_Status status;
|
|
struct alias *alias;
|
|
|
|
for( alias = first_alias; alias != NULL; alias = alias->next )
|
|
{
|
|
if( !alias->newname )
|
|
continue;
|
|
if( strcmp(alias->newname, full_name) == 0 )
|
|
{
|
|
full_name = alias->oldname;
|
|
break;
|
|
}
|
|
}
|
|
|
|
dev_name = strchr (full_name, ':');
|
|
if (dev_name)
|
|
{
|
|
#ifdef strndupa
|
|
be_name = strndupa (full_name, dev_name - full_name);
|
|
#else
|
|
char *tmp;
|
|
|
|
tmp = alloca (dev_name - full_name + 1);
|
|
memcpy (tmp, full_name, dev_name - full_name);
|
|
tmp[dev_name - full_name] = '\0';
|
|
be_name = tmp;
|
|
#endif
|
|
++dev_name; /* skip colon */
|
|
}
|
|
else
|
|
{
|
|
/* if no colon interpret full_name as the backend name; an empty
|
|
backend device name will cause us to open the first device of
|
|
that backend. */
|
|
be_name = full_name;
|
|
dev_name = "";
|
|
}
|
|
|
|
if (!be_name[0])
|
|
be = first_backend;
|
|
else
|
|
for (be = first_backend; be; be = be->next)
|
|
if (strcmp (be->name, be_name) == 0)
|
|
break;
|
|
|
|
if (!be)
|
|
{
|
|
status = add_backend (be_name, &be);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
}
|
|
|
|
if (!be->inited)
|
|
{
|
|
status = init (be);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
}
|
|
|
|
status = (long) (*be->op[OP_OPEN]) (dev_name, &handle);
|
|
if (status != SANE_STATUS_GOOD)
|
|
return status;
|
|
|
|
s = calloc (1, sizeof (*s));
|
|
if (!s)
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
s->be = be;
|
|
s->handle = handle;
|
|
*meta_handle = s;
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
void
|
|
sane_close (SANE_Handle handle)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "close(handle=%p)\n", handle);
|
|
(*s->be->op[OP_CLOSE]) (s->handle);
|
|
free (s);
|
|
}
|
|
|
|
const SANE_Option_Descriptor *
|
|
sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "get_option_descriptor(handle=%p,option=%d)\n", handle, option);
|
|
return (*s->be->op[OP_GET_OPTION_DESC]) (s->handle, option);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_control_option (SANE_Handle handle, SANE_Int option,
|
|
SANE_Action action, void *value, SANE_Word * info)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "control_option(handle=%p,option=%d,action=%d,value=%p,info=%p)\n",
|
|
handle, option, action, value, info);
|
|
return (long) (*s->be->op[OP_CTL_OPTION]) (s->handle, option, action,
|
|
value, info);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "get_parameters(handle=%p,params=%p)\n", handle, params);
|
|
return (long) (*s->be->op[OP_GET_PARAMS]) (s->handle, params);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_start (SANE_Handle handle)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "start(handle=%p)\n", handle);
|
|
return (long) (*s->be->op[OP_START]) (s->handle);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_read (SANE_Handle handle, SANE_Byte * data, SANE_Int max_length,
|
|
SANE_Int * length)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "read(handle=%p,data=%p,maxlen=%d,lenp=%p)\n",
|
|
handle, data, max_length, length);
|
|
return (long) (*s->be->op[OP_READ]) (s->handle, data, max_length, length);
|
|
}
|
|
|
|
void
|
|
sane_cancel (SANE_Handle handle)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "cancel(handle=%p)\n", handle);
|
|
(*s->be->op[OP_CANCEL]) (s->handle);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "set_io_mode(handle=%p,nonblocking=%d)\n", handle, non_blocking);
|
|
return (long) (*s->be->op[OP_SET_IO_MODE]) (s->handle, non_blocking);
|
|
}
|
|
|
|
SANE_Status
|
|
sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
|
|
{
|
|
struct meta_scanner *s = handle;
|
|
|
|
DBG(3, "get_select_fd(handle=%p,fdp=%p)\n", handle, fd);
|
|
return (long) (*s->be->op[OP_GET_SELECT_FD]) (s->handle, fd);
|
|
}
|