event_init.c

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** 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
**
** @(#)$Id: event_init.c,v 1.28 2005/12/18 00:15:11 klmitch Exp $
*/
#include "engines_int.h"

#include <ltdl.h>
#include <stdio.h>
#include <string.h>

RCSTAG("@(#)$Id: event_init.c,v 1.28 2005/12/18 00:15:11 klmitch Exp $");

#define FNAME_BUF       1024

#define MODULE_INIT     "engine_mod_init"

#define MODULE_ENGINE   "engine_module"

#define VAR_MODULES     PACKAGE_TARNAME ".modules"

#define VAR_LIBPATH     PACKAGE_TARNAME ".libpath"

#define VAR_MODLIST     PACKAGE_TARNAME ".modlist"

#define confdir(fname)  SYSCONFDIR "/" PACKAGE_TARNAME "/" fname ".tc"

#define homedir(fname)  "~/." fname ".tc"

static _ev_attr_t const _ev__defattr = {
  EV_ATTR_MAGIC, /* magic number */

  /* default path */
  (confdir(PACKAGE_TARNAME) ":" homedir(PACKAGE_TARNAME) ":"
   confdir("%p") ":" homedir("%p")),

  /* default library search path */
  PKGLIBDIR,

  /* default library module list */
  "select", /* XXX need to figure this one out...configure test? */

  0, 0, 0 /* initialize varlist, ovars, and application engine lists... */
};
const _ev_attr_t const *_ev_defattr = &_ev__defattr;

static int
new_modvar(treeconf_ctx_t *ctx, treeconf_node_t *parent, treeconf_str_t *name,
           int elements)
{
  /* exactly two remaining elements... */
  return !(tn_type(parent) & TC_NODETYPE_IMPLICIT) && elements == 2;
}

static ev_err_t
engine_load(ev_ctx_t *ctx, treeconf_str_t *path, int path_cnt,
            treeconf_str_t *module, ev_flags_t *flag_p)
{
  ev_err_t err = 0;
  ev_engine_t *eng;
  ev_flags_t init_flags = 0;
  const char *mname, *fls = 0;
  int mname_len, fl_len = 0, cmp;

  ev_trace();

  /* First, let's process the name */
  mname = ts_string(module, 0);
  for (mname_len = ts_length(module, 0); mname_len; mname_len--)
    if (mname[mname_len - 1] == ':') { /* there are flags */
      fls = mname + mname_len; /* remember them and bail out */
      fl_len = ts_length(module, 0) - mname_len;
      break;
    }

  if (mname_len) /* If we found a set of flags... */
    mname_len--; /* update the module name length */
  else /* otherwise, reset it */
    mname_len = ts_length(module, 0);

  /* OK, we have the module name and its flags; now, process the flags */
  if (fls)
    while (fl_len--)
      switch (*fls++) {
      case 's': /* Use socket component */
        init_flags |= EV_ENGINE_SOCKET;
        break;
      case 'i': /* Use signal component */
        init_flags |= EV_ENGINE_SIGNAL;
        break;
      case 't': /* Use timer component */
        init_flags |= EV_ENGINE_TIMER;
        break;
      default:
        break; /* Just ignore unknown flags */
      }
  else /* Use all three engine components */
    init_flags = EV_ENGINE_COMPMASK;

  init_flags &= ~*flag_p; /* mask out components we already have */

  if (!init_flags) /* if there's no components to try, bail out */
    ev_return(0);

  /* Now try to find the engine in the list we've developed so far */
  for (eng = ctx->ec_engine; eng; eng = eng->eng_list.el_next)
    if (!(cmp = strncmp(eng->eng_name, mname, mname_len)) &&
        strlen(eng->eng_name) == mname_len)
      break; /* we've found it! */
    else if (cmp >= 0) { /* have we gone too far? */
      eng = 0; /* got to zero the engine so we go searching for it... */
      break;
    }

  if (eng && (eng->eng_runfl & EV_ENGINE_RUNNING)) /* engine running? */
    ev_return(0); /* just skip it... */
  else if (!eng) { /* engine's not already registered... */
    ev_modinit_t modinit;
    lt_dlhandle handle = 0;
    char fname[FNAME_BUF];
    int i;

    for (i = 0; i < path_cnt; i++) { /* go through all the path elements */
      if (ts_length(path, i) + mname_len + 2 > FNAME_BUF)
        continue; /* would be too long; skip it... */

      sprintf(fname, "%.*s/%.*s", ts_length(path, i), ts_string(path, i),
              mname_len, mname); /* build the file name... */

      _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func,
                "Attempting to load engine module %s...", fname);

      /* try to load the module */
      if (!(handle = lt_dlopenext(fname))) {
        _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func,
                  "Can't load %s: %s", fname, lt_dlerror());
        continue; /* not there, try somewhere else... */
      }

      /* All right, we now have a loadable module.  Does it have a
       * module initialization function?
       */
      if ((modinit = (ev_modinit_t)lt_dlsym(handle, MODULE_INIT))) {
        if ((eng = (modinit)(ctx)) && /* initialize module... */
            (eng->eng_runfl & EV_ENGINE_REGISTERED))
          break; /* excellent, we have an engine! */

        /* No module initialization function, try for the engine variable */
      } else if ((eng = (ev_engine_t *)lt_dlsym(handle, MODULE_ENGINE)) &&
                 !engine_register(ctx, eng)) /* register the engine... */
        break; /* found an engine descriptor! */

      /* Couldn't find an engine descriptor; close this one and try again */
      lt_dlclose(handle);
    }

    if (!eng) /* Guess we couldn't find a module for that engine */
      ev_return(0); /* Silent failure, try the next engine module */

    ev_assert(handle); /* handle must be set by now... */

    eng->eng_handle = (void *)handle; /* remember the handle */
  }

  ev_assert(eng); /* we should now have an engine... */
  ev_assert(eng->eng_runfl & EV_ENGINE_REGISTERED); /* must be registered */

  /* Modify init flags with components module handles */
  init_flags &= eng->eng_flags;

  /* Now, try to initialize the engine... */
  if (!init_flags || (err = eng_init(ctx, eng, &init_flags))) {
    /* Failed to initialize engine... */

    if (eng->eng_handle) { /* Was it a loaded module? */
      if (eng->eng_list.el_next) /* clip it out of the engine list... */
        eng->eng_list.el_next->eng_list.el_prev = eng->eng_list.el_prev;
      if (eng->eng_list.el_prev)
        eng->eng_list.el_prev->eng_list.el_next = eng->eng_list.el_next;
      else
        ctx->ec_engine = eng->eng_list.el_next;

      lt_dlclose((lt_dlhandle)eng->eng_handle); /* and unload the module */
    }

    if (init_flags) /* eng_init() was called, but failed... */
      _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func,
                "eng_init() failure initializing engine %s: %u",
                eng->eng_name, err);

    ev_return(0); /* try next engine... */
  }

  *flag_p |= init_flags; /* mark which components have been initialized */

  ev_return(0); /* all done! */
}

ev_err_t
event_init(ev_ctx_t *ctx, const ev_attr_t *attr, ev_flags_t flags,
           const char *prog, const char *envpath)
{
  ev_err_t err = 0;
  treeconf_subst_t substs[] = {
    TC_SUBST_INIT('n', 0, TC_SUBST_INSECURE), /* username */
    TC_SUBST_INIT('p', 0, 0) /* program name */
  };
  treeconf_str_t *path = 0, *modules = 0;
  int path_cnt, mod_cnt, i;
  const char *val;
  ev_varlist_t *vlist;
  ev_overvars_t *ovlist;
  ev_engine_t *eng, *eng_next;
  ev_flags_t comps = 0;

  ev_init(); /* make sure library is initialized... */

  if (!ctx || (attr && !ea_verify(attr)))
    ev_return(EINVAL); /* sanity check arguments */

  if (!attr) /* set default attributes... */
    attr = (const ev_attr_t *)&_ev_defattr;

  if (prog) /* prepare substitutions... */
    tu_value(&substs[1]) = prog; /* substitute program name... */
  else
    tu_flags(&substs[1]) |= TC_SUBST_IGNORE; /* must ignore substitution */

  tc_init(ec_conf(ctx)); /* initialize the treeconf... */

  /* set context flags... */
  ctx->ec_flags = (flags & EV_INIT_SECURE) ? EV_CTX_SECURE : 0;
  ctx->ec_prog = prog; /* remember program name... */

  ctx->ec_maxgen = 0; /* clear list of generators */
  ctx->ec_gens = 0;

  ctx->ec_timtree.tt_root = 0; /* clear the timer tree */
  ctx->ec_timtree.tt_insert = 0;

  ctx->ec_engine = 0; /* clear engine lists */

  ctx->ec_socket.el_first = ctx->ec_socket.el_last = 0;
  ctx->ec_signal.el_first = ctx->ec_signal.el_last = 0;
  ctx->ec_timer.el_first = ctx->ec_timer.el_last = 0;

  ctx->ec_evcnt = 0; /* clear event freelist */
  ctx->ec_evs = 0;

  /* Set magic number now so we can use event_destroy() on error... */
  ctx->ec_magic = EV_CTX_MAGIC;

  /* Register library configuration variables */
  if ((err = tc_register(ec_conf(ctx), VAR_MODULES, 0, 0, new_modvar, 0, 0)) ||
      (err = tc_register(ec_conf(ctx), VAR_LIBPATH, ea_libpath(attr),
                         0, 0, 0, 0)) ||
      (err = tc_register(ec_conf(ctx), VAR_MODLIST, ea_modlist(attr),
                         0, 0, 0, 0)))
    goto error;

  /* Walk through all the application-registered treeconf variables and
   * register them.
   */
  for (vlist = ea_varlist(attr); vlist; vlist = vlist->vl_next)
    if ((err = tc_register(ec_conf(ctx), vlist->vl_name, vlist->vl_default, 0,
                           vlist->vl_nodown, vlist->vl_change,
                           vlist->vl_assoc)))
      goto error;

  /* search for and load configuration files */
  if ((err = tc_path((flags & EV_INIT_SECURE) ? 0 : envpath, ea_confpath(attr),
                     substs, sizeof(substs) / sizeof(treeconf_subst_t),
                     ((flags & EV_INIT_SECURE) ? TC_PATH_SECURE : 0) |
                     TC_PATH_ALL, tc_load, ec_conf(ctx))))
    goto error;

  /* Now set up all the application-overridden values */
  for (ovlist = ea_ovars(attr); ovlist; ovlist = ovlist->ov_next)
    if ((err = tc_set(ec_conf(ctx), ovlist->ov_name, ovlist->ov_value, 0)))
      goto error;

  /* Register initial generators */
  if ((err = event_gen_register(ctx, EGT_SOCKET, EV_SOCK_MAGIC,
                                sizeof(ev_sock_t), 0)) ||
      (err = event_gen_register(ctx, EGT_SIGNAL, EV_SIG_MAGIC,
                                sizeof(ev_sig_t), 0)) ||
      (err = event_gen_register(ctx, EGT_TIMER, EV_TIM_MAGIC,
                                sizeof(ev_tim_t), 0)))
    goto error;

  /* Let's now register application-specified engines... */
  for (eng = ea_engines(attr); eng; eng = eng_next) {
    eng_next = eng->eng_list.el_next; /* remember what's next in list... */
    englink_clr(&eng->eng_list); /* clear link for engine_register() */
    if ((err = engine_register(ctx, eng))) /* register the engine */
      goto error;
  }

  /* Let's split up the path list and the module list */
  if ((err = tc_get(ec_conf(ctx), VAR_LIBPATH, &val, 0)) ||
      (err = tc_break(&path, &path_cnt, val, ":")) ||
      (err = tc_get(ec_conf(ctx), VAR_MODLIST, &val, 0)) ||
      (err = tc_break(&modules, &mod_cnt, val, " \t")))
    goto error;

  /* OK, try to initialize libltdl... */
  if (lt_dlinit()) {
    err = EV_ERR_LIBLTDL;
    goto error;
  } else /* mark that we've initialized libltdl */
    ctx->ec_flags |= EV_CTX_LTDLINIT;

  /* Now walk through the module list and try to initialize... */
  for (i = 0; i < mod_cnt && (comps ^ EV_ENGINE_COMPMASK); i++)
    if ((err = engine_load(ctx, path, path_cnt, modules + i, &comps)))
      goto error;

  /* Did we get all the components? */
  if ((comps ^ EV_ENGINE_COMPMASK) || !ctx->ec_socket.el_first ||
      !ctx->ec_signal.el_first || !ctx->ec_timer.el_first)
    err = EV_ERR_NOENGINE;

  /* We are now all done.  All that remains is cleaning up temporary data
   * and returning!
   */

 error:
  if (modules) /* an error occurred, let's clean up after ourselves */
    free(modules);
  if (path)
    free(path);
  if (err)
    event_destroy(ctx);

  ev_return(err);
}

---