/* 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>

  /* This works around a pedantic GCC compiler warning.  The ISO C
     standard says that the behaviour of converting an object pointer
     like the void * returned by dlsym() to a function pointer like
     void *(*)() is implementation defined.  POSIX though guarantees
     that this works fine.

     Workaround based on http://stackoverflow.com/a/36385690.  Turns
     off pedantic warnings for the duration of the definition only.
   */
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wpedantic"
typedef void *(*func_ptr)(void);

func_ptr
posix_dlsym (void *handle, const char *func)
{
  return dlsym (handle, func);
}
# pragma GCC diagnostic pop

  /* 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 (DIR_SEP) + strlen(LIBDIR) + 1;
      src = malloc (src_len);
      if (!src)
	{
	  DBG (1, "load: malloc failed: %s\n", strerror (errno));
	  return SANE_STATUS_NO_MEM;
	}
      if (orig_src)
        free (orig_src);
      orig_src = src;
      snprintf (src, src_len, "%s%s%s", path, DIR_SEP, LIBDIR);
    }
  else
    {
      src = 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 = posix_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 = posix_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);
}
