diff options
Diffstat (limited to 'backend/dll.c')
| -rw-r--r-- | backend/dll.c | 1305 |
1 files changed, 1305 insertions, 0 deletions
diff --git a/backend/dll.c b/backend/dll.c new file mode 100644 index 0000000..619ee55 --- /dev/null +++ b/backend/dll.c @@ -0,0 +1,1305 @@ +/* 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. */ + +/* Please increase version number with every change + (don't forget to update dll.desc) */ +#define DLL_VERSION "1.0.13" + +#ifdef _AIX +# include "lalloca.h" /* MUST come first for AIX! */ +#endif + +#ifdef __BEOS__ +#include <kernel/OS.h> +#include <storage/FindDirectory.h> +#include <kernel/image.h> +#include <posix/dirent.h> +#endif + +#include "../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 + +/* Mac OS X/Darwin support */ +#if defined (HAVE_NSLINKMODULE) && defined(HAVE_MACH_O_DYLD_H) +# include <mach-o/dyld.h> +# define HAVE_DLL +#endif + +#include <sys/types.h> +#include <sys/stat.h> +#include <dirent.h> + +#include "../include/sane/sane.h" +#include "../include/sane/sanei.h" + +#define BACKEND_NAME dll +#include "../include/sane/sanei_backend.h" + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + +#if defined(_WIN32) || defined(HAVE_OS2_H) +# define DIR_SEP ";" +#else +# define DIR_SEP ":" +#endif + + +#include "../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 +}; + +typedef SANE_Status (*op_init_t) (SANE_Int *, SANE_Auth_Callback); +typedef void (*op_exit_t) (void); +typedef SANE_Status (*op_get_devs_t) (const SANE_Device ***, SANE_Bool); +typedef SANE_Status (*op_open_t) (SANE_String_Const, SANE_Handle *); +typedef void (*op_close_t) (SANE_Handle); +typedef const SANE_Option_Descriptor * (*op_get_option_desc_t) (SANE_Handle, + SANE_Int); +typedef SANE_Status (*op_ctl_option_t) (SANE_Handle, SANE_Int, SANE_Action, + void *, SANE_Int *); +typedef SANE_Status (*op_get_params_t) (SANE_Handle, SANE_Parameters *); +typedef SANE_Status (*op_start_t) (SANE_Handle); +typedef SANE_Status (*op_read_t) (SANE_Handle, SANE_Byte *, SANE_Int, + SANE_Int *); +typedef void (*op_cancel_t) (SANE_Handle); +typedef SANE_Status (*op_set_io_mode_t) (SANE_Handle, SANE_Bool); +typedef SANE_Status (*op_get_select_fd_t) (SANE_Handle, SANE_Int *); + +struct backend +{ + struct backend *next; + 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]) (void); +}; + +#define BE_ENTRY(be,func) sane_##be##_##func + +#define PRELOAD_DECL(name) \ + extern SANE_Status BE_ENTRY(name,init) (SANE_Int *, SANE_Auth_Callback); \ + extern void BE_ENTRY(name,exit) (void); \ + extern SANE_Status BE_ENTRY(name,get_devices) (const SANE_Device ***, SANE_Bool); \ + extern SANE_Status BE_ENTRY(name,open) (SANE_String_Const, SANE_Handle *); \ + extern void BE_ENTRY(name,close) (SANE_Handle); \ + extern const SANE_Option_Descriptor *BE_ENTRY(name,get_option_descriptor) (SANE_Handle, SANE_Int); \ + extern SANE_Status BE_ENTRY(name,control_option) (SANE_Handle, SANE_Int, SANE_Action, void *, SANE_Int *); \ + extern SANE_Status BE_ENTRY(name,get_parameters) (SANE_Handle, SANE_Parameters *); \ + extern SANE_Status BE_ENTRY(name,start) (SANE_Handle); \ + extern SANE_Status BE_ENTRY(name,read) (SANE_Handle, SANE_Byte *, SANE_Int, SANE_Int *); \ + extern void BE_ENTRY(name,cancel) (SANE_Handle); \ + extern SANE_Status BE_ENTRY(name,set_io_mode) (SANE_Handle, SANE_Bool); \ + extern SANE_Status BE_ENTRY(name,get_select_fd) (SANE_Handle, SANE_Int *); + +#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) \ + } \ +} + +#ifndef __BEOS__ +#ifdef ENABLE_PRELOAD +#include "dll-preload.h" +#else +static struct backend preloaded_backends[] = { + { 0, 0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }} +}; +#endif +#endif + +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 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; + +#ifndef __BEOS__ +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" +}; +#else +static const char *op_name[] = { + "sane_init", "sane_exit", "sane_get_devices", "sane_open", "sane_close", "sane_get_option_descriptor", + "sane_control_option", "sane_get_parameters", "sane_start", "sane_read", "sane_cancel", + "sane_set_io_mode", "sane_get_select_fd" +}; +#endif /* __BEOS__ */ + +static void * +op_unsupported (void) +{ + DBG (1, "op_unsupported: 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 (3, "add_backend: adding backend `%s'\n", name); + + if (strcmp (name, "dll") == 0) + { + DBG (0, "add_backend: 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, "add_backend: `%s' is already there\n", name); + /* 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; +} + +#if defined(HAVE_NSLINKMODULE) +static const char *dyld_get_error_str (); + +static const char * +dyld_get_error_str () +{ + NSLinkEditErrors c; + int errorNumber; + const char *fileName; + const char *errorString; + + NSLinkEditError (&c, &errorNumber, &fileName, &errorString); + return errorString; +} +#endif + +#ifdef __BEOS__ +#include <FindDirectory.h> + +static SANE_Status +load (struct backend *be) +{ + /* use BeOS kernel function to load scanner addons from ~/config/add-ons/SANE */ + char path[PATH_MAX]; + image_id id = -1; + int i, w; + directory_which which[3] = { B_USER_ADDONS_DIRECTORY, B_COMMON_ADDONS_DIRECTORY, B_BEOS_ADDONS_DIRECTORY }; + + /* look for config files in SANE/conf */ + for (w = 0; (w < 3) && (id < 0) && (find_directory(which[w],0,true,path,PATH_MAX) == 0); w++) + { + strcat(path,"/SANE/"); + strcat(path,be->name); + 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; + DBG(2, "dlopen()ing `%s'\n", path); + id=load_add_on(path); + if (id < 0) + { + continue; /* try next path */ + } + be->handle=(void *)id; + + for (i = 0; i < NUM_OPS; ++i) + { + void *(*op) (); + op = NULL; + /* Look for the symbol */ + if ((get_image_symbol(id, op_name[i],B_SYMBOL_TYPE_TEXT,(void **)&op) < 0) || !op) + DBG(2, "unable to find %s\n", op_name[i]); + else be->op[i]=op; + } + } + if (id < 0) + { + DBG(2, "load: couldn't find %s\n",path); + return SANE_STATUS_INVAL; + } + return SANE_STATUS_GOOD; +} + +#else +static SANE_Status +load (struct backend *be) +{ +#ifdef HAVE_DLL + int mode = 0; + char *funcname, *src, *orig_src = 0, *dir, *path = 0; + char libname[PATH_MAX]; + int i; + int src_len; + FILE *fp = 0; + +#if defined(HAVE_DLOPEN) +# define PREFIX "libsane-" +# ifdef __hpux +# define POSTFIX ".sl.%u" +# define ALT_POSTFIX ".so.%u" +# elif defined (HAVE_WINDOWS_H) +# undef PREFIX +# define PREFIX "cygsane-" +# define POSTFIX "-%u.dll" +# elif defined (HAVE_OS2_H) +# undef PREFIX +# define PREFIX "" +# define POSTFIX ".dll" +# elif defined (__APPLE__) && defined (__MACH__) +# define POSTFIX ".%u.so" +# else +# define POSTFIX ".so.%u" +# endif + mode = getenv ("LD_BIND_NOW") ? RTLD_NOW : RTLD_LAZY; +#elif defined(HAVE_SHL_LOAD) +# define PREFIX "libsane-" +# define POSTFIX ".sl.%u" + mode = BIND_DEFERRED; +#elif defined(HAVE_NSLINKMODULE) +# define PREFIX "libsane-" +# define POSTFIX ".%u.so" + mode = NSLINKMODULE_OPTION_RETURN_ON_ERROR + NSLINKMODULE_OPTION_PRIVATE; +#else +# error "Tried to compile unsupported DLL." +#endif /* HAVE_DLOPEN */ + + /* 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; + + path = getenv ("LD_LIBRARY_PATH"); + if (!path) + path = getenv ("SHLIB_PATH"); /* for HP-UX */ + if (!path) + path = getenv ("LIBPATH"); /* for AIX */ + + if (path) + { + src_len = strlen (path) + strlen (STRINGIFY (LIBDIR)) + 1 + 1; + src = malloc (src_len); + if (!src) + { + DBG (1, "load: malloc failed: %s\n", strerror (errno)); + return SANE_STATUS_NO_MEM; + } + orig_src = src; + snprintf (src, src_len, "%s:%s", path, STRINGIFY (LIBDIR)); + } + else + { + src = STRINGIFY (LIBDIR); + src = strdup (src); + if (!src) + { + DBG (1, "load: strdup failed: %s\n", strerror (errno)); + return SANE_STATUS_NO_MEM; + } + } + DBG (3, "load: searching backend `%s' in `%s'\n", be->name, src); + + dir = strsep (&src, DIR_SEP); + + while (dir) + { +#ifdef HAVE_OS2_H /* only max 7.3 names work with dlopen() for DLLs on OS/2 */ + snprintf (libname, sizeof (libname), "%s/" PREFIX "%.2s%.5s" POSTFIX, + dir, be->name, strlen(be->name)>7 ? (be->name)+strlen(be->name)-5 : + (be->name)+2, V_MAJOR); +#else + snprintf (libname, sizeof (libname), "%s/" PREFIX "%s" POSTFIX, + dir, be->name, V_MAJOR); +#endif + DBG (4, "load: trying to load `%s'\n", libname); + fp = fopen (libname, "r"); + if (fp) + break; + DBG (4, "load: couldn't open `%s' (%s)\n", libname, strerror (errno)); + +#ifdef ALT_POSTFIX + /* Some platforms have two ways of storing their libraries, try both + postfixes */ + snprintf (libname, sizeof (libname), "%s/" PREFIX "%s" ALT_POSTFIX, + dir, be->name, V_MAJOR); + DBG (4, "load: trying to load `%s'\n", libname); + fp = fopen (libname, "r"); + if (fp) + break; + DBG (4, "load: couldn't open `%s' (%s)\n", libname, strerror (errno)); +#endif + + dir = strsep (&src, DIR_SEP); + } + if (orig_src) + free (orig_src); + if (!fp) + { + DBG (1, "load: couldn't find backend `%s' (%s)\n", + be->name, strerror (errno)); + return SANE_STATUS_INVAL; + } + fclose (fp); + DBG (3, "load: 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); +#elif defined(HAVE_NSLINKMODULE) + { + NSObjectFileImage objectfile_img = NULL; + if (NSCreateObjectFileImageFromFile (libname, &objectfile_img) + == NSObjectFileImageSuccess) + { + be->handle = NSLinkModule (objectfile_img, libname, mode); + NSDestroyObjectFileImage (objectfile_img); + } + } +#else +# error "Tried to compile unsupported DLL." +#endif /* HAVE_DLOPEN */ + if (!be->handle) + { +#ifdef HAVE_DLOPEN + DBG (1, "load: dlopen() failed (%s)\n", dlerror ()); +#elif defined(HAVE_NSLINKMODULE) + DBG (1, "load: dyld error (%s)\n", dyld_get_error_str ()); +#else + DBG (1, "load: 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) (void); + + 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 *(*)(void)) dlsym (be->handle, funcname + 1); +#elif defined(HAVE_SHL_LOAD) + shl_findsym ((shl_t *) & (be->handle), funcname + 1, TYPE_UNDEFINED, + &op); +#elif defined(HAVE_NSLINKMODULE) + { + NSSymbol *nssym = NSLookupSymbolInModule (be->handle, funcname); + if (!nssym) + { + DBG (15, "dyld error: %s\n", dyld_get_error_str ()); + } + else + { + op = (void *(*)(void)) NSAddressOfSymbol (nssym); + } + } +#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 *(*)(void)) dlsym (be->handle, funcname); +#elif defined(HAVE_SHL_LOAD) + shl_findsym (be->handle, funcname, TYPE_UNDEFINED, &op); +#elif defined(HAVE_NSLINKMODULE) + { + NSSymbol *nssym = NSLookupSymbolInModule (be->handle, funcname); + if (!nssym) + { + DBG (15, "dyld error: %s\n", dyld_get_error_str ()); + } + else + { + op = (void *(*)(void)) NSAddressOfSymbol (nssym); + } + } +#else +# error "Tried to compile unsupported DLL." +#endif /* HAVE_DLOPEN */ + if (op) + be->op[i] = op; + } + if (NULL == op) + DBG (1, "load: 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 */ +} +#endif /* __BEOS__ */ + +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 = (*(op_init_t)be->op[OP_INIT]) (&version, auth_callback); + if (status != SANE_STATUS_GOOD) + return status; + + if (SANE_VERSION_MAJOR (version) != SANE_CURRENT_MAJOR) + { + DBG (1, + "init: backend `%s' has a wrong major version (%d instead of %d)\n", + be->name, SANE_VERSION_MAJOR (version), SANE_CURRENT_MAJOR); + return SANE_STATUS_INVAL; + } + DBG (4, "init: backend `%s' is version %d.%d.%d\n", be->name, + SANE_VERSION_MAJOR (version), SANE_VERSION_MINOR (version), + SANE_VERSION_BUILD (version)); + + be->inited = 1; + + return SANE_STATUS_GOOD; +} + + +static void +add_alias (const char *line_param) +{ +#ifndef __BEOS__ + const char *command; + enum + { CMD_ALIAS, CMD_HIDE } + cmd; + const char *oldname, *oldend, *newname; + size_t oldlen, newlen; + struct alias *alias; + char *line; + + command = sanei_config_skip_whitespace (line_param); + if (!*command) + return; + + line = strchr (command, '#'); + if (line) + *line = '\0'; + + 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) + { + char *newend; + + 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; +#endif +} + + +static void +read_config (const char *conffile) +{ + FILE *fp; + char config_line[PATH_MAX]; + char *backend_name; + + fp = sanei_config_open (conffile); + if (!fp) + { + DBG (1, "sane_init/read_config: Couldn't open config file (%s): %s\n", + conffile, strerror (errno)); + return; /* don't insist on config file */ + } + + DBG (5, "sane_init/read_config: reading %s\n", conffile); + while (sanei_config_read (config_line, sizeof (config_line), fp)) + { + char *comment; + SANE_String_Const cp; + + cp = sanei_config_get_string (config_line, &backend_name); + /* ignore empty lines */ + if (!backend_name || cp == config_line) + { + if (backend_name) + free (backend_name); + continue; + } + /* ignore line comments */ + if (backend_name[0] == '#') + { + free (backend_name); + continue; + } + /* ignore comments after backend names */ + comment = strchr (backend_name, '#'); + if (comment) + *comment = '\0'; + add_backend (backend_name, 0); + free (backend_name); + } + fclose (fp); +} + +static void +read_dlld (void) +{ + DIR *dlld; + struct dirent *dllconf; + struct stat st; + char conffile[PATH_MAX], dlldir[PATH_MAX]; + size_t len, plen; + const char *dir_list; + char *copy, *next, *dir; + + dir_list = sanei_config_get_paths (); + if (!dir_list) + { + DBG(2, "sane_init/read_dlld: Unable to detect configuration directories\n"); + return; + } + + copy = strdup (dir_list); + + for (next = copy; (dir = strsep (&next, DIR_SEP)) != NULL;) + { + snprintf (dlldir, sizeof (dlldir), "%s%s", dir, "/dll.d"); + + DBG(4, "sane_init/read_dlld: attempting to open directory `%s'\n", dlldir); + + dlld = opendir (dlldir); + if (dlld) + { + /* length of path to parent dir of dll.d/ */ + plen = strlen (dir) + 1; + + DBG(3, "sane_init/read_dlld: using config directory `%s'\n", dlldir); + break; + } + } + free (copy); + + if (dlld == NULL) + { + DBG (1, "sane_init/read_dlld: opendir failed: %s\n", + strerror (errno)); + return; + } + + while ((dllconf = readdir (dlld)) != NULL) + { + /* dotfile (or directory) */ + if (dllconf->d_name[0] == '.') + continue; + + len = strlen (dllconf->d_name); + + /* backup files */ + if ((dllconf->d_name[len-1] == '~') + || (dllconf->d_name[len-1] == '#')) + continue; + + snprintf (conffile, PATH_MAX, "%s/%s", dlldir, dllconf->d_name); + + DBG (5, "sane_init/read_dlld: considering %s\n", conffile); + + if (stat (conffile, &st) != 0) + continue; + + if (!S_ISREG (st.st_mode)) + continue; + + /* expects a path relative to PATH_SANE_CONFIG_DIR */ + read_config (conffile+plen); + } + + closedir (dlld); + + DBG (5, "sane_init/read_dlld: done.\n"); +} + +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ +#ifndef __BEOS__ + char config_line[PATH_MAX]; + size_t len; + FILE *fp; + int i; +#else + DIR *dir; + struct dirent *dirent; + char path[1024]; + directory_which which[3] = { B_USER_ADDONS_DIRECTORY, B_COMMON_ADDONS_DIRECTORY, B_BEOS_ADDONS_DIRECTORY }; + int i; +#endif + + DBG_INIT (); + + auth_callback = authorize; + + DBG (1, "sane_init: SANE dll backend version %s from %s\n", DLL_VERSION, + PACKAGE_STRING); + +#ifndef __BEOS__ + /* chain preloaded backends together: */ + for (i = 0; i < NELEMS (preloaded_backends); ++i) + { + if (!preloaded_backends[i].name) + continue; + DBG (3, "sane_init: adding backend `%s' (preloaded)\n", preloaded_backends[i].name); + preloaded_backends[i].next = first_backend; + first_backend = &preloaded_backends[i]; + } + + /* 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); + + /* + * Read dll.conf & dll.d + * Read dll.d first, so that the extras backends will be tried last + */ + read_dlld (); + read_config (DLL_CONFIG_FILE); + + fp = sanei_config_open (DLL_ALIASES_FILE); + if (!fp) + return SANE_STATUS_GOOD; /* don't insist on aliases file */ + + DBG (5, "sane_init: reading %s\n", DLL_ALIASES_FILE); + while (sanei_config_read (config_line, sizeof (config_line), fp)) + { + if (config_line[0] == '#') /* ignore line comments */ + continue; + + len = strlen (config_line); + if (!len) + continue; /* ignore empty lines */ + + add_alias (config_line); + } + fclose (fp); + +#else + /* no ugly config files, just get scanners from their ~/config/add-ons/SANE */ + /* look for drivers */ + for (i = 0; i < 3; i++) + { + if (find_directory(which[i],0,true,path,1024) < B_OK) + continue; + strcat(path,"/SANE/"); + dir=opendir(path); + if(!dir) continue; + + while((dirent=readdir(dir))) + { + if((strcmp(dirent->d_name,".")==0) || (strcmp(dirent->d_name,"..")==0)) continue; + if((strcmp(dirent->d_name,"dll")==0)) continue; + add_backend(dirent->d_name,0); + } + closedir(dir); + } +#endif /* __BEOS__ */ + + return SANE_STATUS_GOOD; +} + +void +sane_exit (void) +{ + struct backend *be, *next; + struct alias *alias; + + DBG (2, "sane_exit: exiting\n"); + + for (be = first_backend; be; be = next) + { + next = be->next; + if (be->loaded) + { + if (be->inited) + { + DBG (3, "sane_exit: calling backend `%s's exit function\n", + be->name); + (*(op_exit_t)be->op[OP_EXIT]) (); + } +#ifdef __BEOS__ + /* use BeOS kernel functions to unload add-ons */ + if(be->handle) unload_add_on((image_id)be->handle); +#else +#ifdef HAVE_DLL + +#ifdef HAVE_DLOPEN + if (be->handle) + dlclose (be->handle); +#elif defined(HAVE_SHL_LOAD) + if (be->handle) + shl_unload (be->handle); +#elif defined(HAVE_NSLINKMODULE) + if (be->handle) + NSUnLinkModule (be->handle, NSUNLINKMODULE_OPTION_NONE +# ifdef __ppc__ + | NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES +# endif + ); +#else +# error "Tried to compile unsupported DLL." +#endif /* HAVE_DLOPEN */ + +#endif /* HAVE_DLL */ +#endif /* __BEOS__ */ + } + if (!be->permanent) + { + if (be->name) + free ((void *) be->name); + free (be); + } + else + { + be->inited = 0; + } + } + 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; + } + DBG (3, "sane_exit: finished\n"); +} + +/* 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; \ + } \ + } + + DBG (3, "sane_get_devices\n"); + + 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 = (*(op_get_devs_t)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 = (const SANE_Device **) devlist; + DBG (3, "sane_get_devices: found %d devices\n", devlist_len - 1); + 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; + + DBG (3, "sane_open: trying to open `%s'\n", full_name); + + 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 = (*(op_open_t)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; + + DBG (3, "sane_open: open successful\n"); + return SANE_STATUS_GOOD; +} + +void +sane_close (SANE_Handle handle) +{ + struct meta_scanner *s = handle; + + DBG (3, "sane_close(handle=%p)\n", handle); + (*(op_close_t)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, "sane_get_option_descriptor(handle=%p,option=%d)\n", handle, + option); + return (*(op_get_option_desc_t)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, + "sane_control_option(handle=%p,option=%d,action=%d,value=%p,info=%p)\n", + handle, option, action, value, (void *) info); + return (*(op_ctl_option_t)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, "sane_get_parameters(handle=%p,params=%p)\n", handle, (void *) params); + return (*(op_get_params_t)s->be->op[OP_GET_PARAMS]) (s->handle, params); +} + +SANE_Status +sane_start (SANE_Handle handle) +{ + struct meta_scanner *s = handle; + + DBG (3, "sane_start(handle=%p)\n", handle); + return (*(op_start_t)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, "sane_read(handle=%p,data=%p,maxlen=%d,lenp=%p)\n", + handle, data, max_length, (void *) length); + return (*(op_read_t)s->be->op[OP_READ]) (s->handle, data, max_length, length); +} + +void +sane_cancel (SANE_Handle handle) +{ + struct meta_scanner *s = handle; + + DBG (3, "sane_cancel(handle=%p)\n", handle); + (*(op_cancel_t)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, "sane_set_io_mode(handle=%p,nonblocking=%d)\n", handle, + non_blocking); + return (*(op_set_io_mode_t)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, "sane_get_select_fd(handle=%p,fdp=%p)\n", handle, (void *) fd); + return (*(op_get_select_fd_t)s->be->op[OP_GET_SELECT_FD]) (s->handle, fd); +} |