lib/eggdrop/script.c File Reference

#include <eggdrop/eggdrop.h>

Go to the source code of this file.

Data Structures
struct	journal_event_t
struct	script_dns_callback_data_t
Defines
#define	EVENT_VAR   1
#define	EVENT_CMD   2
Functions
static void *	journal_del (int event, void *key)
static void	journal_add (int event, void *data, void *key)
int	script_init (void)
int	script_shutdown (void)
int	script_remove_events_by_owner (egg_module_t *module, void *script)
	Delete all asyncronous events of a module or script.
int	script_register_module (script_module_t *module)
int	script_unregister_module (script_module_t *module)
int	script_playback (script_module_t *module)
int	script_linked_var_on_write (script_linked_var_t *var, script_var_t *newval)
static int	my_command_handler (void *client_data, script_args_t *args, script_var_t *retval)
int	script_load (char *filename)
int	script_link_vars (script_linked_var_t *table)
int	script_unlink_vars (script_linked_var_t *table)
int	script_create_raw_commands (script_raw_command_t *table)
int	script_delete_raw_commands (script_raw_command_t *table)
int	script_create_commands (script_command_t *table)
int	script_delete_commands (script_command_t *table)
int	script_get_arg (script_args_t *args, int num, script_var_t *var, int type)
script_var_t *	script_string (char *str, int len)
script_var_t *	script_dynamic_string (char *str, int len)
script_var_t *	script_copy_string (char *str, int len)
script_var_t *	script_int (int val)
script_var_t *	script_list (int nitems,...)
int	script_list_append (script_var_t *list, script_var_t *item)
static int	script_dns_delete (struct event_owner_b *event, void *client_data)
static int	script_dns_callback (void *client_data, const char *query, char **result)
int	script_dns_query (dns_function_t *function, const char *host, script_callback_t *callback, char *text, int len)
Variables
static const char	rcsid [] = "$Id: script.c,v 1.27 2007-04-14 15:21:12 sven Exp $"
static journal_event_t *	journal_events = NULL
static int	njournal_events = 0
static script_module_t **	script_modules = NULL
static int	nscript_modules = 0
static script_command_t	script_cmds []

---

Define Documentation

#define EVENT_CMD   2

Definition at line 27 of file script.c.

Referenced by script_create_commands(), script_create_raw_commands(), script_delete_commands(), script_delete_raw_commands(), and script_playback().

#define EVENT_VAR   1

Definition at line 26 of file script.c.

Referenced by script_link_vars(), script_playback(), and script_unlink_vars().

---

Function Documentation

static void journal_add	(	int	event,
		void *	data,
		void *	key
	)			[static]

Definition at line 163 of file script.c.

References journal_event_t::data, journal_event_t::event, journal_event_t::key, and njournal_events.

Referenced by script_create_commands(), script_create_raw_commands(), and script_link_vars().

{
  journal_events = realloc(journal_events, sizeof(*journal_events) * (njournal_events+1));
  journal_events[njournal_events].event = event;
  journal_events[njournal_events].data = data;
  journal_events[njournal_events].key = key;
  njournal_events++;
}

static void * journal_del	(	int	event,
		void *	key
	)			[static]

Definition at line 173 of file script.c.

References journal_event_t::data, njournal_events, and NULL.

Referenced by script_delete_commands(), script_delete_raw_commands(), script_shutdown(), and script_unlink_vars().

{
  int i;
  void *data = NULL;

  for (i = 0; i < njournal_events; i++) {
    if (journal_events[i].event == event && journal_events[i].key == key) break;
  }
  if (i < njournal_events) {
    data = journal_events[i].data;
    memmove(journal_events+i, journal_events+i+1, sizeof(*journal_events) * (njournal_events-i-1));
    njournal_events--;
  }

  return(data);
}

static int my_command_handler	(	void *	client_data,
		script_args_t *	args,
		script_var_t *	retval
	)			[static]

Definition at line 222 of file script.c.

References script_command_b::callback, script_command_b::client_data, cmd, script_command_b::flags, script_var_b::len, script_args_b::len, script_command_b::nargs, event_owner_b::on_delete, script_callback_b::owner, owner, script_command_b::retval_type, SCRIPT_CALLBACK, SCRIPT_ERROR, SCRIPT_FREE, script_get_arg(), SCRIPT_PASS_ARRAY, SCRIPT_PASS_CDATA, SCRIPT_PASS_COUNT, SCRIPT_PASS_RETVAL, SCRIPT_STRING, SCRIPT_VAR_ARGS, SCRIPT_VAR_FRONT, script_command_b::syntax, script_command_b::syntax_error, script_var_b::type, and script_var_b::value.

Referenced by my_create_command(), and script_create_commands().

{
  script_command_t *cmd = client_data;
  void *static_argstack[20], *static_free_args[20];
  void **argstack, **free_args;
  script_callback_t **callbacks, *static_callbacks[20];
  int argstack_len, nfree_args, ncallbacks;
  char *syntax;
  int i, skip, nopts, err;
  void *simple_retval;
  script_var_t var;
  void *(*callback)();

  /* Check if there is an argument count error. */
  if (cmd->flags & SCRIPT_VAR_ARGS) err = (cmd->nargs > args->len);
  else err = (cmd->nargs != args->len);

  if (err) {
    retval->type = SCRIPT_STRING | SCRIPT_ERROR;
    retval->value = cmd->syntax_error;
    return(-1);
  }

  /* Get space for the argument conversion.
    We'll try to use stack space instead of a calloc(). */
  if (args->len+3 > 20) {
    argstack = calloc(args->len+3, sizeof(void *));
    free_args = calloc(args->len, sizeof(void *));
    callbacks = calloc(args->len, sizeof(*callbacks));
  }
  else {
    memset(static_argstack, 0, sizeof(static_argstack));
    argstack = static_argstack;
    free_args = static_free_args;
    callbacks = static_callbacks;
  }
  argstack_len = 3;
  nfree_args = 0;
  ncallbacks = 0;

  /* Figure out how many args to skip. */
  syntax = cmd->syntax;
  if (cmd->flags & SCRIPT_VAR_FRONT) {
    skip = strlen(syntax) - args->len;
    if (skip < 0) skip = 0;
    argstack_len += skip;
    syntax += skip;
  }
  else skip = 0;

  /* Now start converting arguments according to the command's syntax
    string. */
  for (i = 0; i < args->len; i++) {
    err = script_get_arg(args, i, &var, *syntax);
    if (err) {
      retval->value = cmd->syntax_error;
      retval->type = SCRIPT_STRING | SCRIPT_ERROR;
      goto cleanup_args;
    }
    if (var.type & SCRIPT_FREE) free_args[nfree_args++] = var.value;
    else if (*syntax == SCRIPT_CALLBACK) callbacks[ncallbacks++] = var.value;
    argstack[argstack_len++] = var.value;
    syntax++;
  }

  /* Calculate the optional args we want for the callback.
    This is why we saved space for 3 args earlier on. */
  nopts = 3;
  if (cmd->flags & SCRIPT_PASS_COUNT) {
    nopts--;
    argstack[nopts] = (void *)(argstack_len - 3 - skip);
  }
  if (cmd->flags & SCRIPT_PASS_RETVAL) {
    nopts--;
    argstack[nopts] = retval;
  }
  if (cmd->flags & SCRIPT_PASS_CDATA) {
    nopts--;
    argstack[nopts] = cmd->client_data;
  }

  /* Adjust the base of the argument stack. */
  argstack += nopts;
  argstack_len -= nopts;

  /* Execute the callback. */
  callback = (void *(*)())cmd->callback;
  if (cmd->flags & SCRIPT_PASS_ARRAY) {
    simple_retval = callback(argstack_len, argstack);
  }
  else {
    simple_retval = callback(argstack[0], argstack[1],
      argstack[2], argstack[3], argstack[4], argstack[5],
      argstack[6], argstack[7], argstack[8], argstack[9]);
  }

  argstack -= nopts;
  argstack_len += nopts;

  /* Process the return value. */
  if (!(cmd->flags & SCRIPT_PASS_RETVAL)) {
    retval->type = cmd->retval_type;
    retval->len = -1;
    retval->value = simple_retval;
  }

cleanup_args:
  for (i = 0; i < nfree_args; i++) {
    if (free_args[i]) free(free_args[i]);
  }
  if (err) {
    for (i = 0; i < ncallbacks; i++) {
      if (callbacks[i] && callbacks[i]->owner && callbacks[i]->owner->on_delete) callbacks[i]->owner->on_delete(callbacks[i]->owner, callbacks[i]);
    }
  }
  if (argstack != static_argstack) {
    free(argstack);
    free(free_args);
    free(callbacks);
  }

  return(0);
}

script_var_t* script_copy_string	(	char *	str,
		int	len
	)

Definition at line 514 of file script.c.

References script_dynamic_string().

{
  char *copy;

  if (!str) {
    str = "";
    len = 0;
  }
  else if (len < 0) len = strlen(str);
  copy = malloc(len+1);
  memcpy(copy, str, len);
  copy[len] = 0;
  return script_dynamic_string(copy, len);
}

int script_create_commands

(

script_command_t *

table

)

Definition at line 445 of file script.c.

References script_raw_command_t::callback, script_raw_command_t::class, script_command_b::class, script_raw_command_t::client_data, cmd, script_module_b::create_command, EVENT_CMD, journal_add(), my_command_handler(), script_raw_command_t::name, script_command_b::name, and nscript_modules.

Referenced by logfile_init(), script_export(), script_init(), script_LTX_start(), server_script_init(), and start().

{
  int i;
  script_raw_command_t *cmd;

  while (table->class && table->name) {
    cmd = malloc(sizeof(*cmd));
    cmd->class = table->class;
    cmd->name = table->name;
    cmd->callback = my_command_handler;
    cmd->client_data = table;

    journal_add(EVENT_CMD, cmd, table);
    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->create_command(script_modules[i]->client_data, cmd);
    }
    table++;
  }
  return(0);
}

int script_create_raw_commands

(

script_raw_command_t *

table

)

Definition at line 417 of file script.c.

References script_raw_command_t::class, script_module_b::create_command, EVENT_CMD, journal_add(), script_raw_command_t::name, and nscript_modules.

{
  int i;

  while (table->class && table->name) {
    journal_add(EVENT_CMD, table, table);
    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->create_command(script_modules[i]->client_data, table);
    }
    table++;
  }
  return(0);
}

int script_delete_commands

(

script_command_t *

table

)

Definition at line 466 of file script.c.

References script_command_b::class, cmd, script_module_b::delete_command, EVENT_CMD, journal_del(), script_command_b::name, and nscript_modules.

Referenced by channels_close(), logfile_shutdown(), script_shutdown(), and server_script_destroy().

{
  int i;
  script_raw_command_t *cmd;

  for (; table->class && table->name; table++) {
    cmd = journal_del(EVENT_CMD, table);
    if (!cmd)
      continue;

    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->delete_command(script_modules[i]->client_data, cmd);
    }

    free(cmd);
  }
  return(0);
}

int script_delete_raw_commands

(

script_raw_command_t *

table

)

Definition at line 431 of file script.c.

References script_raw_command_t::class, script_module_b::delete_command, EVENT_CMD, journal_del(), script_raw_command_t::name, and nscript_modules.

{
  int i;

  while (table->class && table->name) {
    journal_del(EVENT_CMD, table);
    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->delete_command(script_modules[i]->client_data, table);
    }
    table++;
  }
  return(0);
}

static int script_dns_callback	(	void *	client_data,
		const char *	query,
		char **	result
	)			[static]

Definition at line 573 of file script.c.

References byte_array_b::bytes, script_callback_b::callback, script_dns_callback_data_t::callback, byte_array_b::do_free, script_dns_callback_data_t::id, script_dns_callback_data_t::len, byte_array_b::len, and script_dns_callback_data_t::text.

Referenced by script_dns_query().

{
  static unsigned char no_data = 0;
  byte_array_t bytes;
  script_dns_callback_data_t *data = client_data;

  bytes.bytes = data->text;
  bytes.len = data->len;
  bytes.do_free = 0;

  if (!bytes.bytes) bytes.bytes = &no_data;
  if (bytes.len <= 0) bytes.len = strlen((char *) bytes.bytes);

  data->callback->callback(data->callback, data->id, query, result, &bytes);

  return 0; /* what exactly should this function return? the return value is always ignored */
}

static int script_dns_delete	(	struct event_owner_b *	event,
		void *	client_data
	)			[static]

Definition at line 560 of file script.c.

References script_dns_callback_data_t::callback, event_owner_b::on_delete, script_callback_b::owner, and script_dns_callback_data_t::text.

Referenced by script_dns_query().

{
  script_dns_callback_data_t *data = client_data;

  if (data->callback->owner && data->callback->owner->on_delete) data->callback->owner->on_delete(data->callback->owner, data->callback);
  if (data->text) free(data->text);
  free(data);

  free(event);

  return 51896; /* Why do these callbacks have to return something? */
}

int script_dns_query	(	dns_function_t *	function,
		const char *	host,
		script_callback_t *	callback,
		char *	text,
		int	len
	)

Definition at line 591 of file script.c.

References script_dns_callback_data_t::callback, function, script_dns_callback_data_t::id, script_dns_callback_data_t::len, script_callback_b::owner, script_dns_callback(), script_dns_delete(), script_callback_b::syntax, and script_dns_callback_data_t::text.

Referenced by script_dns_lookup(), and script_dns_reverse().

{
  int id;
  event_owner_t *event;
  script_dns_callback_data_t *data;

  event = malloc(sizeof(*event));
  memcpy(event, callback->owner, sizeof(*event));
  event->on_delete = script_dns_delete;

  callback->syntax = strdup("isSb");
  data = malloc(sizeof(*data));
  data->callback = callback;
  data->id = -1;
  data->text = text;
  data->len = len;
  id = function(host, -1, script_dns_callback, data, event);
  if (id == -1) {
    /* the query was cached, the callback has already been called and data has been freed */
    return -1;
  }
  data->id = id;
  return id;
}

script_var_t* script_dynamic_string	(	char *	str,
		int	len
	)

Definition at line 508 of file script.c.

References SCRIPT_FREE, script_string(), and script_var_b::type.

Referenced by script_copy_string().

{ script_var_t *var = script_string(str, len);
  var->type |= SCRIPT_FREE;
  return(var);
}

int script_get_arg	(	script_args_t *	args,
		int	num,
		script_var_t *	var,
		int	type
	)

Definition at line 485 of file script.c.

References script_module_b::client_data, script_module_b::get_arg, and script_args_b::module.

Referenced by my_command_handler().

{
  script_module_t *module;

  module = args->module;
  return module->get_arg(module->client_data, args, num, var, type);
}

int script_init

(

void

)

Definition at line 56 of file script.c.

References script_create_commands().

Referenced by eggdrop_init().

{
  script_create_commands(script_cmds);

  return(0);
}

script_var_t* script_int

(

int

val

)

Definition at line 529 of file script.c.

References SCRIPT_FREE_VAR, SCRIPT_INTEGER, script_var_b::type, and script_var_b::value.

Referenced by script_channel_mask_list(), script_channel_topic(), script_listmask(), script_net_info(), script_net_listen(), script_server_list(), and script_timer_info().

{
  script_var_t *var = malloc(sizeof(*var));
  var->type = SCRIPT_INTEGER | SCRIPT_FREE_VAR;
  var->value = (void *)val;
  return(var);
}

int script_link_vars

(

script_linked_var_t *

table

)

Definition at line 389 of file script.c.

References script_linked_var_b::class, EVENT_VAR, journal_add(), script_module_b::link_var, script_linked_var_b::name, and nscript_modules.

Referenced by server_script_init().

{
  int i;

  while (table->class && table->name) {
    journal_add(EVENT_VAR, table, table);
    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->link_var(script_modules[i]->client_data, table);
    }
    table++;
  }
  return(0);
}

int script_linked_var_on_write	(	script_linked_var_t *	var,
		script_var_t *	newval
	)

Definition at line 192 of file script.c.

References script_linked_var_b::callbacks, script_var_callbacks_b::on_write, SCRIPT_FREE, SCRIPT_INTEGER, SCRIPT_STRING, SCRIPT_TYPE_MASK, SCRIPT_UNSIGNED, script_var_b::type, script_linked_var_b::type, script_var_b::value, and script_linked_var_b::value.

Referenced by my_eggvar_set(), my_trace_callback(), and SetVar().

{
  int r;
  char **charptr;

  /* See if the owner provides a write callback. */
  if (var->callbacks && var->callbacks->on_write) {
    r = (var->callbacks->on_write)(var, newval);
    return(r);
  }

  /* Provide default handling for strings and ints. */
  switch (var->type & SCRIPT_TYPE_MASK) {
    case SCRIPT_UNSIGNED:
    case SCRIPT_INTEGER:
      *(int *)(var->value) = (int) newval->value;
      break;
    case SCRIPT_STRING:
      charptr = (char **)var->value;
      if (*charptr) free(*charptr);
      if (newval->type & SCRIPT_FREE) *charptr = newval->value;
      else *charptr = strdup(newval->value);
      break;
  }
  return(0);
}

script_var_t* script_list	(	int	nitems,
			...
	)

Definition at line 537 of file script.c.

References script_var_b::len, NULL, SCRIPT_ARRAY, SCRIPT_FREE, SCRIPT_FREE_VAR, SCRIPT_VAR, script_var_b::type, and script_var_b::value.

Referenced by script_channel_mask_list(), script_listmask(), and script_server_list().

{
  script_var_t *list;

  list = malloc(sizeof(*list));
  list->type = SCRIPT_ARRAY | SCRIPT_FREE | SCRIPT_VAR | SCRIPT_FREE_VAR;
  list->len = nitems;
  if (nitems > 0) {
    list->value = malloc(nitems * sizeof(script_var_t *));
    memmove(list->value, &nitems + 1, nitems * sizeof(script_var_t *));
  }
  else list->value = NULL;
  return(list);
}

int script_list_append	(	script_var_t *	list,
		script_var_t *	item
	)

Definition at line 552 of file script.c.

References script_var_b::len, and script_var_b::value.

Referenced by script_channel_info(), script_channel_list(), script_channel_mask_list(), script_channel_members(), script_channel_topic(), script_channels(), script_listmask(), script_net_info(), script_net_listen(), script_server_list(), and script_timer_info().

{
  list->value = realloc(list->value, sizeof(item) * (list->len+1));
  ((script_var_t **)list->value)[list->len] = item;
  list->len++;
  return(0);
}

int script_load

(

char *

filename

)

Definition at line 347 of file script.c.

References _, egg_assert_val, script_module_b::load_script, LOG_MISC, nscript_modules, NULL, putlog(), SCRIPT_ERR_CODE, SCRIPT_ERR_NOT_RESPONSIBLE, and SCRIPT_OK.

Referenced by core_init().

{
  int i, ret;

  egg_assert_val (filename != NULL, 0);

  /* check if we have at least one script module loaded. */
  if (nscript_modules == 0) {
    putlog (LOG_MISC, "*", _("Failed to load script '%s': no script modules loaded."),
      filename);
    return 0;
  }

  for (i = 0; i < nscript_modules; i++) {
    ret = script_modules[i]->load_script(script_modules[i]->client_data, filename);

    switch (ret) {

      /* The current module was responsible and everything worked fine
       */
      case (SCRIPT_OK):
        putlog (LOG_MISC, "*", _("Script loaded: %s"), filename);
        return 1;
  
      /* The current module is not responsible for this type of
       * script. */
      case (SCRIPT_ERR_NOT_RESPONSIBLE):
        break;

      /* Code error, script implementation (hopefully) put a log
       * message for a detailed error description. */
      case (SCRIPT_ERR_CODE):
        return 0;

    }
  }

  putlog (LOG_MISC, "*", _("Failed to load script '%s': no appropiate script module."), filename);
  
  return 0;
}

int script_playback

(

script_module_t *

module

)

Definition at line 145 of file script.c.

References script_module_b::client_data, script_module_b::create_command, journal_event_t::data, EVENT_CMD, EVENT_VAR, script_module_b::link_var, and njournal_events.

Referenced by javascript_LTX_start(), perlscript_LTX_start(), pythonscript_LTX_start(), and tclscript_LTX_start().

{
  int i;

  for (i = 0; i < njournal_events; i++) {
    switch (journal_events[i].event) {
      case EVENT_VAR:
        module->link_var(module->client_data, journal_events[i].data);
        break;
      case EVENT_CMD:
        module->create_command(module->client_data, journal_events[i].data);
        break;
    }
  }
  return(0);
}

int script_register_module

(

script_module_t *

module

)

Definition at line 121 of file script.c.

References nscript_modules.

Referenced by javascript_LTX_start(), perlscript_LTX_start(), pythonscript_LTX_start(), and tclscript_LTX_start().

{
  script_modules = realloc(script_modules, sizeof(*script_modules) * (nscript_modules+1));
  script_modules[nscript_modules] = module;
  nscript_modules++;
  return(0);
}

int script_remove_events_by_owner	(	egg_module_t *	module,
		void *	script
	)

Delete all asyncronous events of a module or script.

This functions kills all asyncronous events of a given module or script by calling the *_delete_by_owner() functions of all event types.

Parameters:

	module	The module whose bots should be deleted.
	script	The script whose bots should be deleted. NULL matches everything.

Returns:

The number of deleted events.

Bug:

Not all event types have a *_delete_by_owner() function yet. sockets, socketfilters and scripting functions are missing.

Definition at line 107 of file script.c.

References botnet_delete_by_owner(), egg_dns_cancel_by_owner(), egg_ident_cancel_by_owner(), kill_binds_by_owner(), partymember_delete_by_owner(), and timer_destroy_by_owner().

Referenced by Cleanup(), and module_really_unload().

{
  int removed = 0;

  removed += botnet_delete_by_owner(module, script);
  removed += partymember_delete_by_owner(module, script);
  removed += kill_binds_by_owner(module, script);
  removed += timer_destroy_by_owner(module, script);
  removed += egg_dns_cancel_by_owner(module, script);
  removed += egg_ident_cancel_by_owner(module, script);
  return removed;
}

int script_shutdown

(

void

)

Definition at line 63 of file script.c.

References journal_del(), njournal_events, nscript_modules, NULL, script_delete_commands(), and script_unregister_module().

Referenced by eggdrop_shutdown().

{
  int i;

  script_delete_commands(script_cmds);

  /* XXX: this may be the wrong place. This should be handled by module
   * XXX: dependencies. E.g. if someone unloads "script", e.g. "tclscript" 
   * XXX: should be magicly unloaded too */
  if (nscript_modules > 0) {
    for (i = nscript_modules - 1; i >= 0; i--) {
      script_unregister_module(script_modules[i]);
    }
  }
  if (script_modules) free(script_modules); script_modules = NULL;

  /* XXX: this shouldn't be necessary too if everything gets unloaded. */
  if (njournal_events > 0) {
    for (i = njournal_events - 1; i >= 0; i--) {
      journal_del(
        journal_events[i].event,
        journal_events[i].key);
    }
  }
  if (journal_events) free(journal_events); journal_events = NULL;

  return (0);
}

script_var_t* script_string	(	char *	str,
		int	len
	)

Definition at line 493 of file script.c.

References script_var_b::len, SCRIPT_FREE_VAR, SCRIPT_STRING, script_var_b::type, and script_var_b::value.

Referenced by script_channel_info(), script_channel_list(), script_channel_mask_list(), script_channel_members(), script_channel_topic(), script_channels(), script_dynamic_string(), script_listmask(), script_server_list(), and script_timer_info().

{
  script_var_t *var = malloc(sizeof(*var));

  var->type = SCRIPT_STRING | SCRIPT_FREE_VAR;
  if (!str) {
    str = "";
    len = 0;
  }
  else if (len < 0) len = strlen(str);
  var->value = str;
  var->len = len;
  return(var);
}

int script_unlink_vars

(

script_linked_var_t *

table

)

Definition at line 403 of file script.c.

References script_linked_var_b::class, EVENT_VAR, journal_del(), script_linked_var_b::name, nscript_modules, and script_module_b::unlink_var.

Referenced by server_script_destroy().

{
  int i;

  while (table->class && table->name) {
    journal_del(EVENT_VAR, table);
    for (i = 0; i < nscript_modules; i++) {
      script_modules[i]->unlink_var(script_modules[i]->client_data, table);
    }
    table++;
  }
  return(0);
}

int script_unregister_module

(

script_module_t *

module

)

Definition at line 130 of file script.c.

References nscript_modules.

Referenced by javascript_close(), perlscript_close(), pythonscript_close(), script_shutdown(), and tclscript_close().

{
  int i;

  for (i = 0; i < nscript_modules; i++) {
    if (script_modules[i] == module) break;
  }
  if (i == nscript_modules) return(-1);
  memmove(script_modules+i, script_modules+i+1, sizeof(script_module_t) * (nscript_modules-i-1));
  nscript_modules--;
  return(0);
}

---

Variable Documentation

journal_event_t* journal_events = NULL [static]

Definition at line 42 of file script.c.

int njournal_events = 0 [static]

Definition at line 43 of file script.c.

Referenced by journal_add(), journal_del(), script_playback(), and script_shutdown().

int nscript_modules = 0 [static]

Definition at line 46 of file script.c.

Referenced by script_create_commands(), script_create_raw_commands(), script_delete_commands(), script_delete_raw_commands(), script_link_vars(), script_load(), script_register_module(), script_shutdown(), script_unlink_vars(), and script_unregister_module().

const char rcsid[] = "$Id: script.c,v 1.27 2007-04-14 15:21:12 sven Exp $" [static]

Definition at line 21 of file script.c.

script_command_t script_cmds[] [static]

Initial value:

 {
  {"", "loadscript", script_load, NULL, 1, "s", "filename", SCRIPT_INTEGER, 0},
  {0}
}

Definition at line 51 of file script.c.

script_module_t** script_modules = NULL [static]

Definition at line 45 of file script.c.