---

drivers.c

/*
 *  drivers.c - Loading and managing the driver plugins.
 *              This file is part of the FreeLCD package.
 *
 *  $Id: drivers_8c-source.html,v 1.1 2003/02/16 22:50:41 unicorn Exp $
 *
 *  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
 *
 *  Copyright (c) 2002, 2003, Jeroen van den Berg <unicorn@hippie.nu>
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>

#include <common/xmalloc.h>
#include <common/xmlt.h>
#include <drivers/backend.h>

#include "ltdl.h"
#include "drivers.h"

#ifndef FLCDD_MODULE_PATH_ENV
#  define FLCDD_MODULE_PATH_ENV "FLCDD_MODULE_PATH"
#endif

typedef enum { DRIVER = 0, BACKEND = 1 } tag_idx;
typedef enum { NAME = 0 } attr_idx;

static tag_idx tag_array[] = { DRIVER, BACKEND };
static attr_idx attr_array[] = { NAME };

static dict_pair tag_translate[] = {
    { "backend", &tag_array[BACKEND] },
    { "driver", &tag_array[DRIVER] }
};

static dict_pair attr_translate[] = {
    { "name", &attr_array[NAME] }
};

static dictionary tag_dict = { tag_translate, 2 };
static dictionary attr_dict = { attr_translate, 1 };

typedef struct
{
  void        *drv_handle;
  void        *backend_handle;
  void        (*destroy_handle)(void *handle);
  const char *(*get_info)(const char *field);
  void        (*process_canvas)(void *handle, void *canvas);
}
driver_info;


static int
_ltdl_error ()
{
  syslog (LOG_ERR, "libtool init failed: %s\n", lt_dlerror ());

  return -1;
}

static void *
_module_error ()
{
  syslog (LOG_ERR, "loading plug-in failed: %s\n", lt_dlerror ());

  return 0;
}

static void *
_create_failed (void *backend)
{
  backend_free_handle (backend);
  return 0;
}

int
drivers_init ()
{
  static int initialized = 0;
  const char *path = 0;

  if (initialized)
    return 0;

  /* Tell libtool to use our xmalloc() for allocating memory */
  lt_dlmalloc = (lt_ptr(*)(size_t)) xmalloc;

  /* Preload anything, if necessary */
  /* LTDL_SET_PRELOADED_SYMBOLS(); */

  if (lt_dlinit () != 0)
    return _ltdl_error ();

  path = getenv (FLCDD_MODULE_PATH_ENV);
  if (path && lt_dlsetsearchpath (path) != 0)
    return _ltdl_error ();

  lt_dladdsearchdir (MODULE_PATH);
  initialized = 1;

  return 0;
}

void *
drivers_create_output (xml_node *config)
{
  typedef void*(ch_func)(xml_node *);
  typedef void(bb_func)(void *, void *);
  typedef void(dh_func)(void *);
  typedef const char *(gi_func)(const char *);

  driver_info *info = xmalloc (sizeof (driver_info));
  ch_func*   create_handle;
  bb_func*   bind_backend;

  void       *backend;
  void       *driver;
  const char *backend_name;
  const char *driver_name;
  xml_node   *found;
  lt_dlhandle module;

  xmlt_rescan_document (config, &tag_dict, &attr_dict);
  
  found = xmlt_find (config, 0, BACKEND);
  if (!found)
    return 0;

  backend_name = xmlt_get_attrib (found, NAME);
  backend = backend_create_handle (found, backend_name);
  if (!backend)
    return 0;

  found = xmlt_find (config, 0, DRIVER);
  if (!found)
    return _create_failed (backend);

  driver_name = xmlt_get_attrib (found, NAME);
  if (!driver_name)
    return _create_failed (backend);

  module = lt_dlopenext (driver_name);
  if (!module)
    return _module_error ();
  
  create_handle = (ch_func*)lt_dlsym (module, "drv_create_handle");
  if (!create_handle)
    return _module_error();

  bind_backend   = (bb_func*)lt_dlsym (module, "drv_bind_backend");
  if (!bind_backend)
    return _module_error();
  
  driver = create_handle (found);
  if (!driver)
    return _create_failed (backend);

  info->drv_handle  = driver;
  info->backend_handle = backend;
  info->destroy_handle = (dh_func*)lt_dlsym (module, "drv_destroy_handle");
  info->get_info       = (gi_func*)lt_dlsym (module, "drv_get_info");
  info->process_canvas = (bb_func*)lt_dlsym (module, "drv_process_canvas");

  bind_backend (driver, backend);

  return info;  
}

void
drivers_process_canvas (void *info_, cc_canvas *canvas)
{
  driver_info *info = info_;

  info->process_canvas (info->drv_handle, canvas);
}

---