mirror of
https://github.com/moparisthebest/hexchat
synced 2024-12-24 08:38:54 -05:00
1883 lines
46 KiB
C
1883 lines
46 KiB
C
/*
|
|
* X-Chat 2.0 LUA Plugin
|
|
*
|
|
* Copyright (c) 2007 Hanno Hecker
|
|
* 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; version 2 of the License.
|
|
*
|
|
* 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: lua.c 91 2007-06-09 18:44:03Z vetinari $
|
|
* $Revision: 91 $
|
|
* $Date: 2007-06-09 20:44:03 +0200 (Szo, 09 jún. 2007) $
|
|
*/
|
|
/*
|
|
* TODO:
|
|
* * compile (was OK)/run on IRIX
|
|
* ? localize error msgs? ... maybe later
|
|
* ? make xchat.print() like print() which does an tostring() on
|
|
* everything it gets?
|
|
* ? add /LUA -s <code>? ... add a new script from cmdline... this state
|
|
* is not removed after the pcall(), but prints a name, which may
|
|
* be used to unload this virtual script. ... no xchat_register(),
|
|
* xchat_init() should be needed
|
|
* ... don't disable xchat.hook_* for this
|
|
* ? timer name per state/script and not per plugin?
|
|
*/
|
|
#define LXC_NAME "Lua"
|
|
#define LXC_DESC "Lua scripting interface"
|
|
#define LXC_VERSION "0.7 (r91)"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include "../../src/common/dirent.h"
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
|
|
#ifdef _WIN32
|
|
#include <direct.h> /* for getcwd */
|
|
#endif
|
|
|
|
#if !( defined(_WIN32) || defined(LXC_XCHAT_GETTEXT) )
|
|
# include <libintl.h>
|
|
#endif
|
|
|
|
#ifndef PATH_MAX /* hurd */
|
|
# define PATH_MAX 1024
|
|
#endif
|
|
|
|
#include <lua.h>
|
|
#include <lauxlib.h>
|
|
#include <lualib.h>
|
|
|
|
#define lua_pop(L,n) lua_settop(L, -(n)-1)
|
|
|
|
#include "xchat-plugin.h"
|
|
|
|
static xchat_plugin *ph; /* plugin handle */
|
|
|
|
#define LXC_STRIP_COLOR 1
|
|
#define LXC_STRIP_ATTR 2
|
|
#define LXC_STRIP_ALL (LXC_STRIP_COLOR|LXC_STRIP_ATTR)
|
|
|
|
/* registered hooks */
|
|
struct lxc_hooks {
|
|
const char *name;
|
|
xchat_hook *hook;
|
|
struct lxc_hooks *next;
|
|
};
|
|
|
|
/* single linked list of all lua states^Wscripts ;-) */
|
|
struct lxc_States {
|
|
lua_State *state; /* the lua state of the script */
|
|
char file[PATH_MAX+1]; /* the file name of the script */
|
|
struct lxc_hooks *hooks; /* all hooks this script registered */
|
|
void *gui; /* the gui entry in windows->plugins and scripts... */
|
|
struct lxc_States *next;
|
|
};
|
|
|
|
static struct lxc_States *lxc_states = NULL;
|
|
|
|
/* user/script supplied data for a callback */
|
|
struct lxc_userdata {
|
|
int idx; /* table index */
|
|
int type; /* lua type: */
|
|
const char *string; /* only strings, ... */
|
|
double num; /* numbers and booleans are supported */
|
|
struct lxc_userdata *next;
|
|
};
|
|
|
|
/* callback data */
|
|
struct lxc_cbdata {
|
|
lua_State *state;
|
|
const char *func;
|
|
xchat_hook *hook; /* timer ... */
|
|
struct lxc_userdata *data;
|
|
};
|
|
|
|
static char lxc_event_name[1024] = "\0";
|
|
|
|
static int lxc_run_hook(char *word[], char *word_eol[], void *data);
|
|
static int lxc_run_print(char *word[], void *data);
|
|
static int lxc_run_timer(void *data);
|
|
|
|
static int lxc_hook_command(lua_State *L);
|
|
static int lxc_hook_server(lua_State *L);
|
|
static int lxc_hook_print(lua_State *L);
|
|
static int lxc_event(lua_State *L);
|
|
static int lxc_hook_timer(lua_State *L);
|
|
static int lxc_unhook(lua_State *L);
|
|
|
|
static int lxc_command(lua_State *L);
|
|
static int lxc_print(lua_State *L);
|
|
static int lxc_emit_print(lua_State *L);
|
|
static int lxc_send_modes(lua_State *L);
|
|
static int lxc_find_context(lua_State *L);
|
|
static int lxc_get_context(lua_State *L);
|
|
static int lxc_get_info(lua_State *L);
|
|
static int lxc_get_prefs(lua_State *L);
|
|
static int lxc_set_context(lua_State *L);
|
|
static int lxc_nickcmp(lua_State *L);
|
|
|
|
static int lxc_list_get(lua_State *L);
|
|
static int lxc_list_fields(lua_State *L);
|
|
static int lxc_gettext(lua_State *L);
|
|
|
|
static int lxc_bits(lua_State *L);
|
|
|
|
static luaL_reg lxc_functions[] = {
|
|
{"hook_command", lxc_hook_command },
|
|
/* TODO:
|
|
{"hook_fd", lxc_hook_fd },
|
|
*/
|
|
{"hook_print", lxc_hook_print },
|
|
{"hook_server", lxc_hook_server },
|
|
{"hook_timer", lxc_hook_timer },
|
|
{"unhook", lxc_unhook },
|
|
|
|
{"event", lxc_event },
|
|
|
|
{"command", lxc_command },
|
|
{"print", lxc_print },
|
|
{"emit_print", lxc_emit_print },
|
|
{"send_modes", lxc_send_modes },
|
|
{"find_context", lxc_find_context },
|
|
{"get_context", lxc_get_context },
|
|
{"get_info", lxc_get_info },
|
|
{"get_prefs", lxc_get_prefs },
|
|
{"set_context", lxc_set_context },
|
|
|
|
{"nickcmp", lxc_nickcmp },
|
|
|
|
{"list_get", lxc_list_get },
|
|
{"list_fields", lxc_list_fields },
|
|
|
|
{"gettext", lxc_gettext},
|
|
/* helper function for bit flags */
|
|
{"bits", lxc_bits },
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static struct {
|
|
const char *name;
|
|
long value;
|
|
} lxc_consts[] = {
|
|
{"EAT_NONE", XCHAT_EAT_NONE},
|
|
{"EAT_XCHAT", XCHAT_EAT_XCHAT},
|
|
{"EAT_PLUGIN", XCHAT_EAT_PLUGIN},
|
|
{"EAT_ALL", XCHAT_EAT_ALL},
|
|
|
|
/* unused until hook_fd is done
|
|
{"FD_READ", XCHAT_FD_READ},
|
|
{"FD_WRITE", XCHAT_FD_WRITE},
|
|
{"FD_EXCEPTION", XCHAT_FD_EXCEPTION},
|
|
{"FD_NOTSOCKET", XCHAT_FD_NOTSOCKET},
|
|
*/
|
|
|
|
{"PRI_HIGHEST", XCHAT_PRI_HIGHEST},
|
|
{"PRI_HIGH", XCHAT_PRI_HIGH},
|
|
{"PRI_NORM", XCHAT_PRI_NORM},
|
|
{"PRI_LOW", XCHAT_PRI_LOW},
|
|
{"PRI_LOWEST", XCHAT_PRI_LOWEST},
|
|
|
|
/* for: clean = xchat.strip(dirty, xchat.STRIP_ALL) */
|
|
{"STRIP_COLOR", LXC_STRIP_COLOR},
|
|
{"STRIP_ATTR", LXC_STRIP_ATTR},
|
|
{"STRIP_ALL", LXC_STRIP_ALL},
|
|
|
|
/* for xchat.commandf("GUI COLOR %d", xchat.TAB_HILIGHT) */
|
|
{"TAB_DEFAULT", 0},
|
|
{"TAB_NEWDATA", 1},
|
|
{"TAB_NEWMSG", 2},
|
|
{"TAB_HILIGHT", 3},
|
|
|
|
{NULL, 0}
|
|
};
|
|
|
|
|
|
#ifdef DEBUG
|
|
static void stackDump (lua_State *L, const char *msg) {
|
|
int i, t;
|
|
int top = lua_gettop(L);
|
|
|
|
fprintf(stderr, "%s\n", msg);
|
|
for (i = 1; i <= top; i++) { /* repeat for each level */
|
|
t = lua_type(L, i);
|
|
switch (t) {
|
|
|
|
case LUA_TSTRING: /* strings */
|
|
fprintf(stderr, "`%s'", lua_tostring(L, i));
|
|
break;
|
|
|
|
case LUA_TBOOLEAN: /* booleans */
|
|
fprintf(stderr, lua_toboolean(L, i) ? "true" : "false");
|
|
break;
|
|
|
|
case LUA_TNUMBER: /* numbers */
|
|
fprintf(stderr, "%g", lua_tonumber(L, i));
|
|
break;
|
|
|
|
default: /* other values */
|
|
fprintf(stderr, "%s", lua_typename(L, t));
|
|
break;
|
|
|
|
}
|
|
fprintf(stderr, " "); /* put a separator */
|
|
}
|
|
fprintf(stderr, "\n"); /* end the listing */
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
static int lxc__newindex(lua_State *L)
|
|
{
|
|
int i;
|
|
const char *name = lua_tostring(L, 2);
|
|
|
|
luaL_getmetatable(L, "xchat"); /* 4 */
|
|
|
|
lua_pushnil(L); /* 5 */
|
|
while (lua_next(L, 4) != 0) {
|
|
if ((lua_type(L, -2) == LUA_TSTRING)
|
|
&& strcmp("__index", lua_tostring(L, -2)) == 0)
|
|
break; /* now __index is 5, table 6 */
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
lua_pushnil(L);
|
|
while (lua_next(L, 6) != 0) {
|
|
if ((lua_type(L, -2) == LUA_TSTRING)
|
|
&& strcmp(name, lua_tostring(L, -2)) == 0) {
|
|
for (i=0; lxc_consts[i].name; i++) {
|
|
if (strcmp(name, lxc_consts[i].name) == 0) {
|
|
luaL_error(L,
|
|
"`xchat.%s' is a readonly constant", lua_tostring(L, 2));
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
lua_pushvalue(L, 2);
|
|
lua_pushvalue(L, 3);
|
|
lua_rawset(L, 6);
|
|
|
|
lua_settop(L, 1);
|
|
return 0;
|
|
}
|
|
|
|
static int luaopen_xchat(lua_State *L)
|
|
{
|
|
int i;
|
|
/*
|
|
* wrappers for xchat.printf() and xchat.commandf()
|
|
* ... xchat.strip
|
|
*/
|
|
#define LXC_WRAPPERS "function xchat.printf(...)\n" \
|
|
" xchat.print(string.format(unpack(arg)))\n" \
|
|
"end\n" \
|
|
"function xchat.commandf(...)\n" \
|
|
" xchat.command(string.format(unpack(arg)))\n" \
|
|
"end\n" \
|
|
"function xchat.strip(str, flags)\n" \
|
|
" if flags == nil then\n" \
|
|
" flags = xchat.STRIP_ALL\n" \
|
|
" end\n" \
|
|
" local bits = xchat.bits(flags)\n" \
|
|
" if bits[1] then\n" \
|
|
" str = string.gsub(\n" \
|
|
" string.gsub(str, \"\\3%d%d?,%d%d?\", \"\"),\n" \
|
|
" \"\\3%d%d?\", \"\")\n" \
|
|
" end\n" \
|
|
" if bits[2] then\n" \
|
|
" -- bold, beep, reset, reverse, underline\n" \
|
|
" str = string.gsub(str,\n" \
|
|
" \"[\\2\\7\\15\\22\\31]\", \"\")\n" \
|
|
" end\n" \
|
|
" return str\n" \
|
|
"end\n"
|
|
|
|
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
|
|
luaL_register(L, "xchat", lxc_functions);
|
|
(void)luaL_dostring(L, LXC_WRAPPERS);
|
|
#else
|
|
luaL_openlib(L, "xchat", lxc_functions, 0);
|
|
lua_dostring(L, LXC_WRAPPERS);
|
|
#endif
|
|
|
|
luaL_newmetatable(L, "xchat");
|
|
|
|
lua_pushliteral(L, "__index");
|
|
lua_newtable(L);
|
|
|
|
lua_pushstring(L, "ARCH");
|
|
#ifdef _WIN32
|
|
lua_pushstring(L, "Windows");
|
|
#else
|
|
lua_pushstring(L, "Unix");
|
|
#endif
|
|
lua_settable(L, -3); /* add to table __index */
|
|
|
|
for (i=0; lxc_consts[i].name; i++) {
|
|
lua_pushstring(L, lxc_consts[i].name);
|
|
lua_pushnumber(L, lxc_consts[i].value);
|
|
lua_settable(L, -3); /* add to table __index */
|
|
}
|
|
lua_settable(L, -3); /* add to metatable */
|
|
|
|
lua_pushliteral(L, "__newindex");
|
|
lua_pushcfunction(L, lxc__newindex);
|
|
lua_settable(L, -3);
|
|
/*
|
|
lua_pushliteral(L, "__metatable");
|
|
lua_pushstring(L, "nothing to see here, move along");
|
|
lua_settable(L, -3);
|
|
*/
|
|
lua_setmetatable(L, -2);
|
|
lua_pop(L, 1);
|
|
return 1;
|
|
}
|
|
|
|
lua_State *lxc_new_state()
|
|
{
|
|
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
|
|
lua_State *L = luaL_newstate(); /* opens Lua */
|
|
luaL_openlibs(L);
|
|
#else
|
|
lua_State *L = lua_open(); /* opens Lua */
|
|
luaopen_base(L); /* opens the basic library */
|
|
luaopen_table(L); /* opens the table library */
|
|
luaopen_io(L); /* opens the I/O library */
|
|
luaopen_string(L); /* opens the string lib. */
|
|
luaopen_math(L); /* opens the math lib. */
|
|
#endif
|
|
|
|
luaopen_xchat(L);
|
|
return L;
|
|
}
|
|
|
|
static int
|
|
lxc_load_file(const char *script)
|
|
{
|
|
lua_State *L;
|
|
struct lxc_States *state; /* pointer to lua states list */
|
|
struct lxc_States *st; /* pointer to lua states list */
|
|
|
|
L = lxc_new_state();
|
|
state = malloc(sizeof(struct lxc_States));
|
|
if (state == NULL) {
|
|
xchat_printf(ph, "malloc() failed: %s\n", strerror(errno));
|
|
lua_close(L);
|
|
return 0;
|
|
}
|
|
|
|
state->state = L;
|
|
snprintf(state->file, PATH_MAX, script);
|
|
state->next = NULL;
|
|
state->hooks = NULL;
|
|
state->gui = NULL;
|
|
|
|
if (luaL_loadfile(L, script) || lua_pcall(L, 0, 0, 0)) {
|
|
xchat_printf(ph, "Lua plugin: error loading script %s",
|
|
lua_tostring(L, -1));
|
|
lua_close(L);
|
|
free(state);
|
|
return 0;
|
|
}
|
|
|
|
if (!lxc_states)
|
|
lxc_states = state;
|
|
else {
|
|
st = lxc_states;
|
|
while (st->next)
|
|
st = st->next;
|
|
st->next = state;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
lxc_autoload_from_path(const char *path)
|
|
{
|
|
DIR *dir;
|
|
struct dirent *ent;
|
|
char *file;
|
|
int len;
|
|
/* xchat_printf(ph, "loading from %s\n", path); */
|
|
dir = opendir(path);
|
|
if (dir) {
|
|
while ((ent = readdir(dir))) {
|
|
len = strlen(ent->d_name);
|
|
if (len > 4 && strcasecmp(".lua", ent->d_name + len - 4) == 0) {
|
|
file = malloc(len + strlen(path) + 2);
|
|
if (file == NULL) {
|
|
xchat_printf(ph, "lxc_autoload_from_path(): malloc failed: %s",
|
|
strerror(errno));
|
|
break;
|
|
}
|
|
sprintf(file, "%s/%s", path, ent->d_name);
|
|
(void)lxc_load_file((const char *)file);
|
|
free(file);
|
|
}
|
|
}
|
|
closedir(dir);
|
|
}
|
|
}
|
|
|
|
void lxc_unload_script(struct lxc_States *state)
|
|
{
|
|
struct lxc_hooks *hooks, *h;
|
|
struct lxc_cbdata *cb;
|
|
struct lxc_userdata *ud, *u;
|
|
lua_State *L = state->state;
|
|
|
|
lua_pushstring(L, "xchat_unload");
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
if (lua_type(L, -1) == LUA_TFUNCTION) {
|
|
if (lua_pcall(L, 0, 0, 0)) {
|
|
xchat_printf(ph, "Lua plugin: error while unloading script %s",
|
|
lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
}
|
|
}
|
|
|
|
if (state->gui)
|
|
xchat_plugingui_remove(ph, state->gui);
|
|
state->gui = NULL;
|
|
|
|
hooks = state->hooks;
|
|
while (hooks) {
|
|
h = hooks;
|
|
hooks = hooks->next;
|
|
|
|
cb = xchat_unhook(ph, h->hook);
|
|
if (cb) {
|
|
ud = cb->data;
|
|
while (ud) {
|
|
u = ud;
|
|
ud = ud->next;
|
|
free(u);
|
|
}
|
|
free(cb);
|
|
}
|
|
|
|
free(h);
|
|
}
|
|
lua_close(state->state);
|
|
}
|
|
|
|
|
|
static int lxc_cb_load(char *word[], char *word_eol[], void *userdata)
|
|
{
|
|
int len;
|
|
struct lxc_States *state;
|
|
lua_State *L;
|
|
const char *name, *desc, *vers;
|
|
const char *xdir = "";
|
|
char *buf;
|
|
char file[PATH_MAX+1];
|
|
struct stat *st;
|
|
|
|
if (word_eol[2][0] == 0)
|
|
return XCHAT_EAT_NONE;
|
|
|
|
buf = malloc(PATH_MAX + 1);
|
|
if (!buf) {
|
|
xchat_printf(ph, "malloc() failed: %s\n", strerror(errno));
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
st = malloc(sizeof(struct stat));
|
|
if (!st) {
|
|
xchat_printf(ph, "malloc() failed: %s\n", strerror(errno));
|
|
free(buf);
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
len = strlen(word[2]);
|
|
if (len > 4 && strcasecmp (".lua", word[2] + len - 4) == 0) {
|
|
#ifdef WIN32
|
|
if (strrchr(word[2], '\\') != NULL)
|
|
#else
|
|
if (strrchr(word[2], '/') != NULL)
|
|
#endif
|
|
strncpy(file, word[2], PATH_MAX);
|
|
else {
|
|
if (stat(word[2], st) == 0)
|
|
xdir = getcwd(buf, PATH_MAX);
|
|
else {
|
|
xdir = xchat_get_info(ph, "xchatdirfs");
|
|
if (!xdir) /* xchatdirfs is new for 2.0.9, will fail on older */
|
|
xdir = xchat_get_info (ph, "xchatdir");
|
|
}
|
|
snprintf(file, PATH_MAX, "%s/%s", xdir, word[2]);
|
|
}
|
|
|
|
if (lxc_load_file((const char *)file) == 0) {
|
|
free(st);
|
|
free(buf);
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
|
|
state = lxc_states;
|
|
while (state) {
|
|
if (state->next == NULL) {
|
|
L = state->state;
|
|
|
|
lua_pushstring(L, "xchat_register");
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
if (lua_pcall(L, 0, 3, 0)) {
|
|
xchat_printf(ph, "Lua plugin: error registering script %s",
|
|
lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
free(st);
|
|
free(buf);
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
|
|
name = lua_tostring(L, -3);
|
|
desc = lua_tostring(L, -2);
|
|
vers = lua_tostring(L, -1);
|
|
lua_pop(L, 4); /* func + 3 ret value */
|
|
state->gui = xchat_plugingui_add(ph, state->file,
|
|
name, desc, vers, NULL
|
|
);
|
|
|
|
lua_pushstring(L, "xchat_init");
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
if (lua_type(L, -1) != LUA_TFUNCTION)
|
|
lua_pop(L, 1);
|
|
else {
|
|
if (lua_pcall(L, 0, 0, 0)) {
|
|
xchat_printf(ph,
|
|
"Lua plugin: error calling xchat_init() %s",
|
|
lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
}
|
|
}
|
|
free(st);
|
|
free(buf);
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
state = state->next;
|
|
}
|
|
}
|
|
free(st);
|
|
free(buf);
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
static int lxc_cb_unload(char *word[], char *word_eol[], void *userdata)
|
|
{
|
|
int len;
|
|
struct lxc_States *state;
|
|
struct lxc_States *prev = NULL;
|
|
char *file;
|
|
|
|
if (word_eol[2][0] == 0)
|
|
return XCHAT_EAT_NONE;
|
|
|
|
len = strlen(word[2]);
|
|
if (len > 4 && strcasecmp(".lua", word[2] + len - 4) == 0) {
|
|
state = lxc_states;
|
|
while (state) {
|
|
/*
|
|
* state->file is the full or relative path, always with a '/' inside,
|
|
* even if loaded via '/LOAD script.lua'. So strrchr() will never
|
|
* be NULL.
|
|
* ... we just inspect the script name w/o path to see if it's the
|
|
* right one to unload
|
|
*/
|
|
file = strrchr(state->file, '/') + 1;
|
|
if ((strcmp(state->file, word[2]) == 0)
|
|
|| (strcasecmp(file, word[2]) == 0)) {
|
|
lxc_unload_script(state);
|
|
if (prev)
|
|
prev->next = state->next;
|
|
else
|
|
lxc_states = state->next;
|
|
xchat_printf(ph, "Lua script %s unloaded", file);
|
|
free(state);
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
prev = state;
|
|
state = state->next;
|
|
}
|
|
}
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
static int lxc_cb_lua(char *word[], char *word_eol[], void *userdata)
|
|
{
|
|
lua_State *L = lxc_new_state();
|
|
if (word[2][0] == '\0') {
|
|
xchat_printf(ph, "LUA: Usage: /LUA LUA_CODE... execute LUA_CODE");
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
if (luaL_loadbuffer(L, word_eol[2], strlen(word_eol[2]), "/LUA")) {
|
|
xchat_printf(ph, "LUA: error loading line %s", lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
#define LXC_HOOK_DISABLE "xchat.hook_command = nil\n" \
|
|
"xchat.hook_server = nil\n" \
|
|
"xchat.hook_print = nil\n" \
|
|
"xchat.hook_timer = nil\n"
|
|
|
|
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
|
|
(void)luaL_dostring(L, LXC_HOOK_DISABLE);
|
|
#else
|
|
lua_dostring(L, LXC_HOOK_DISABLE);
|
|
#endif
|
|
|
|
if (lua_pcall(L, 0, 0, 0)) {
|
|
xchat_printf(ph, "LUA: error executing line %s", lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
}
|
|
|
|
lua_close(L);
|
|
return XCHAT_EAT_ALL;
|
|
}
|
|
|
|
int xchat_plugin_init(xchat_plugin *plugin_handle,
|
|
char **plugin_name,
|
|
char **plugin_desc,
|
|
char **plugin_version,
|
|
char *arg)
|
|
{
|
|
struct lxc_States *state;
|
|
lua_State *L;
|
|
const char *xdir;
|
|
const char *name, *desc, *vers;
|
|
/* we need to save this for use with any xchat_* functions */
|
|
ph = plugin_handle;
|
|
|
|
/* tell xchat our info */
|
|
*plugin_name = LXC_NAME;
|
|
*plugin_desc = LXC_DESC;
|
|
*plugin_version = LXC_VERSION;
|
|
|
|
xchat_hook_command(ph, "LOAD", XCHAT_PRI_NORM, lxc_cb_load, NULL, NULL);
|
|
xchat_hook_command(ph, "UNLOAD", XCHAT_PRI_NORM, lxc_cb_unload, NULL, NULL);
|
|
xchat_hook_command(ph, "LUA", XCHAT_PRI_NORM, lxc_cb_lua, "Usage: LUA <code>, executes <code> in a new lua state", NULL);
|
|
|
|
xdir = xchat_get_info(ph, "xchatdirfs");
|
|
if (!xdir) /* xchatdirfs is new for 2.0.9, will fail on older */
|
|
xdir = xchat_get_info (ph, "xchatdir");
|
|
|
|
lxc_autoload_from_path(xdir);
|
|
|
|
if (!lxc_states) /* no scripts loaded */
|
|
return 1;
|
|
|
|
state = lxc_states;
|
|
while (state) {
|
|
L = state->state;
|
|
lua_pushstring(L, "xchat_register");
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
if (lua_pcall(L, 0, 3, 0)) {
|
|
xchat_printf(ph, "Lua plugin: error registering script %s",
|
|
lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
state = state->next;
|
|
continue;
|
|
}
|
|
|
|
name = lua_tostring(L, -3);
|
|
desc = lua_tostring(L, -2);
|
|
vers = lua_tostring(L, -1);
|
|
lua_pop(L, 4); /* func + 3 ret value */
|
|
state->gui = xchat_plugingui_add(ph, state->file, name, desc, vers, NULL);
|
|
|
|
lua_pushstring(L, "xchat_init");
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
if (lua_type(L, -1) != LUA_TFUNCTION)
|
|
lua_pop(L, 1);
|
|
else {
|
|
if (lua_pcall(L, 0, 0, 0)) {
|
|
xchat_printf(ph, "Lua plugin: error calling xchat_init() %s",
|
|
lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
}
|
|
}
|
|
state = state->next;
|
|
}
|
|
xchat_printf(ph, "Lua interface (v%s) loaded", LXC_VERSION);
|
|
return 1;
|
|
}
|
|
|
|
int xchat_plugin_deinit(xchat_plugin *plug_handle)
|
|
{
|
|
struct lxc_States *state, *st;
|
|
|
|
state = lxc_states;
|
|
while (state) {
|
|
lxc_unload_script(state);
|
|
xchat_printf(ph, "Lua script %s unloaded", state->file);
|
|
st = state;
|
|
state = state->next;
|
|
free(st);
|
|
}
|
|
xchat_printf(plug_handle, "Lua plugin v%s removed", LXC_VERSION);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: func_name(word, word_eol, data)
|
|
* desc: your previously hooked callback function for hook_command() and
|
|
* hook_server(), you must return one of the xchat.EAT_* constants
|
|
* ret: none
|
|
* args:
|
|
* * word (table): the incoming line split into words (max 32)
|
|
* * word_eol (table):
|
|
* for both see
|
|
* http://xchat.org/docs/plugin20.html#word
|
|
* * data (table): the data table you passed to the hook_command() /
|
|
* hook_server() as 5th arg
|
|
*/
|
|
static int lxc_run_hook(char *word[], char *word_eol[], void *data)
|
|
{
|
|
struct lxc_cbdata *cb = data;
|
|
lua_State *L = cb->state;
|
|
struct lxc_userdata *ud = cb->data;
|
|
struct lxc_userdata *u;
|
|
int i;
|
|
lua_pushstring(L, cb->func);
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
|
|
strcpy(lxc_event_name, word[0]);
|
|
lua_newtable(L);
|
|
for (i=1; i<=31 && word[i][0]; i++) {
|
|
lua_pushnumber(L, i);
|
|
lua_pushstring(L, word[i]);
|
|
lua_settable(L, -3);
|
|
}
|
|
|
|
lua_newtable(L);
|
|
for (i=1; i<=31 && word_eol[i][0]; i++) {
|
|
lua_pushnumber(L, i);
|
|
lua_pushstring(L, word_eol[i]);
|
|
lua_settable(L, -3);
|
|
}
|
|
|
|
lua_newtable(L);
|
|
u = ud;
|
|
while (u) {
|
|
lua_pushnumber(L, u->idx);
|
|
switch (u->type) {
|
|
case LUA_TSTRING:
|
|
lua_pushstring(L, u->string);
|
|
break;
|
|
case LUA_TNUMBER:
|
|
lua_pushnumber(L, u->num);
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
lua_pushboolean(L, (((int)u->num == 0) ? 0 : 1));
|
|
break;
|
|
default: /* LUA_TNIL or others */
|
|
lua_pushnil(L);
|
|
break;
|
|
}
|
|
lua_settable(L, -3);
|
|
u = u->next;
|
|
}
|
|
|
|
if (lua_pcall(L, 3, 1, 0)) {
|
|
xchat_printf(ph, "failed to call callback for '%s': %s",
|
|
word[1], lua_tostring(L, -1)
|
|
);
|
|
lua_pop(L, 1);
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
if (lua_type(L, -1) != LUA_TNUMBER) {
|
|
xchat_printf(ph, "callback for '%s' did not return number...", word[1]);
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
|
|
i = (int)lua_tonumber(L, -1);
|
|
lua_pop(L, 1);
|
|
return i;
|
|
}
|
|
|
|
static int lxc_get_userdata(int pos, struct lxc_cbdata *cb)
|
|
{
|
|
struct lxc_userdata *ud, *u;
|
|
lua_State *L = cb->state;
|
|
int i, t;
|
|
|
|
t = lua_type(L, pos);
|
|
if (t == LUA_TNIL)
|
|
return 1;
|
|
if (t != LUA_TTABLE)
|
|
return 0;
|
|
|
|
i = 1;
|
|
while (1) {
|
|
lua_pushnumber(L, i);
|
|
lua_gettable(L, -2);
|
|
|
|
t = lua_type(L, -1);
|
|
if (t == LUA_TNIL) {
|
|
lua_pop(L, 1);
|
|
break;
|
|
}
|
|
|
|
ud = malloc(sizeof(struct lxc_userdata));
|
|
if (!ud) {
|
|
xchat_printf(ph, "lxc_get_userdata(): failed to malloc: %s",
|
|
strerror(errno));
|
|
if (cb->data != NULL) {
|
|
ud = cb->data;
|
|
while (ud) {
|
|
u = ud;
|
|
ud = ud->next;
|
|
free(u);
|
|
}
|
|
}
|
|
/* free(cb); NO! */
|
|
lua_pushnil(L);
|
|
return 0;
|
|
}
|
|
ud->idx = i;
|
|
ud->next = NULL;
|
|
switch (t) {
|
|
case LUA_TSTRING:
|
|
ud->string = lua_tostring(L, -1);
|
|
ud->type = LUA_TSTRING;
|
|
break;
|
|
case LUA_TNUMBER:
|
|
ud->num = lua_tonumber(L, -1);
|
|
ud->type = LUA_TNUMBER;
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
ud->num = (double)lua_toboolean(L, -1);
|
|
ud->type = LUA_TBOOLEAN;
|
|
break;
|
|
default:
|
|
ud->type = LUA_TNIL;
|
|
break;
|
|
}
|
|
lua_pop(L, 1);
|
|
|
|
if (cb->data == NULL)
|
|
cb->data = ud;
|
|
else {
|
|
u = cb->data;
|
|
while (u->next)
|
|
u = u->next;
|
|
u->next = ud;
|
|
}
|
|
i++;
|
|
} /* END while (1) */
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.hook_command(name, func_name, prio, help_str, data)
|
|
* desc: Adds a new /command. This allows your program to handle commands
|
|
* entered at the input box. To capture text without a "/" at the start
|
|
* (non-commands), you may hook a special name of "". i.e
|
|
* xchat.hook_command( "", ...)
|
|
* Starting from version 2.6.8, commands hooked that begin with a
|
|
* period ('.') will be hidden in /HELP and /HELP -l.
|
|
* ret: true... or false if something went wrong while registering hook
|
|
* args:
|
|
* * name (string): the name of the new command
|
|
* * func_name (string): the lua function to be called when command is
|
|
* entered
|
|
* * prio (number): use one of the xchat.PRIO_*
|
|
* * help_str (string): help for the new command... use nil for no help
|
|
* * data (table): table with strings, numbers and booleans, which will
|
|
* be passed to func_name as last argument.
|
|
*/
|
|
static int lxc_hook_command(lua_State *L)
|
|
{
|
|
xchat_hook *hook;
|
|
const char *help, *command, *func;
|
|
double prio;
|
|
struct lxc_hooks *hooks, *h;
|
|
struct lxc_States *st;
|
|
struct lxc_cbdata *cb;
|
|
|
|
|
|
if (lua_gettop(L) < 5) /* expand to five args if necessary */
|
|
lua_settop(L, 5);
|
|
|
|
cb = malloc(sizeof(struct lxc_cbdata));
|
|
if (!cb) {
|
|
xchat_printf(ph, "lxc_hook_command(): failed to malloc: %s",
|
|
strerror(errno));
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
|
|
cb->state = L;
|
|
cb->data = NULL;
|
|
|
|
command = luaL_checkstring(L, 1);
|
|
func = luaL_checkstring(L, 2);
|
|
cb->func = func;
|
|
cb->hook = NULL;
|
|
|
|
if (lua_type(L, 3) == LUA_TNIL)
|
|
prio = XCHAT_PRI_NORM;
|
|
else
|
|
prio = luaL_checknumber(L, 3);
|
|
|
|
if (lua_type(L, 4) == LUA_TSTRING) {
|
|
help = luaL_checkstring(L, 4);
|
|
if (strlen(help) == 0)
|
|
help = NULL;
|
|
}
|
|
else
|
|
help = NULL;
|
|
|
|
if (lxc_get_userdata(5, cb) == 0)
|
|
lua_pushboolean(L, 0);
|
|
else {
|
|
h = malloc(sizeof(struct lxc_hooks));
|
|
if (!h) {
|
|
xchat_printf(ph, "lxc_hook_command(): failed to malloc: %s",
|
|
strerror(errno));
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
hook = xchat_hook_command(ph, command, prio, lxc_run_hook, help, cb);
|
|
h->hook = hook;
|
|
h->name = command;
|
|
h->next = NULL;
|
|
st = lxc_states;
|
|
while (st) {
|
|
if (st->state == L) {
|
|
if (!st->hooks)
|
|
st->hooks = h;
|
|
else {
|
|
hooks = st->hooks;
|
|
while (hooks->next)
|
|
hooks = hooks->next;
|
|
hooks->next = h;
|
|
}
|
|
break;
|
|
}
|
|
st = st->next;
|
|
}
|
|
lua_pushboolean(L, 1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: func_name(word, data)
|
|
* desc: your previously hooked callback function for hook_print(),
|
|
* you must return one of the xchat.EAT_* constants
|
|
* ret: none
|
|
* args:
|
|
* * word (table): the incoming line split into words (max 32)
|
|
* (see http://xchat.org/docs/plugin20.html#word)
|
|
* * data (table): the data table you passed to the hook_print() /
|
|
* as 4th arg
|
|
*/
|
|
static int lxc_run_print(char *word[], void *data)
|
|
{
|
|
struct lxc_cbdata *cb = data;
|
|
lua_State *L = cb->state;
|
|
int i;
|
|
|
|
lua_pushstring(L, cb->func);
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
|
|
strcpy(lxc_event_name, word[0]);
|
|
lua_newtable(L);
|
|
for (i=1; i<=31 && word[i][0]; i++) {
|
|
lua_pushnumber(L, i);
|
|
lua_pushstring(L, word[i]);
|
|
lua_settable(L, -3);
|
|
}
|
|
|
|
if (lua_pcall(L, 1, 1, 0)) {
|
|
xchat_printf(ph, "failed to call callback for '%s': %s",
|
|
word[1], lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
return 0;
|
|
}
|
|
|
|
if (lua_type(L, -1) != LUA_TNUMBER) {
|
|
xchat_printf(ph, "callback for '%s' didn't return number...", word[1]);
|
|
return XCHAT_EAT_NONE;
|
|
}
|
|
i = (int)lua_tonumber(L, -1);
|
|
lua_pop(L, 1);
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.hook_print(name, func_name, prio, data)
|
|
* desc: Registers a function to trap any print events. The event names may
|
|
* be any available in the "Advanced > Text Events" window. There are
|
|
* also some extra "special" events you may hook using this function,
|
|
* see: http://xchat.org/docs/plugin20.html#xchat_hook_print
|
|
* ret: true... or false if something went wrong while registering hook
|
|
* args:
|
|
* * name (string): the name of the new command
|
|
* * prio (number): use one of the xchat.PRIO_*
|
|
* * func_name (string): the lua function to be called when command is
|
|
* entered
|
|
* * data (table): table with strings, numbers and booleans, which will
|
|
* be passed to func_name as last argument.
|
|
*/
|
|
static int lxc_hook_print(lua_State *L)
|
|
{
|
|
xchat_hook *hook;
|
|
struct lxc_hooks *hooks, *h;
|
|
struct lxc_States *st;
|
|
struct lxc_cbdata *cb = malloc(sizeof(struct lxc_cbdata));
|
|
const char *name, *func;
|
|
double prio;
|
|
|
|
if (!cb) {
|
|
luaL_error(L, "lxc_hook_print(): failed to malloc: %s", strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
if (lua_gettop(L) < 4) /* expand to 4 args if necessary */
|
|
lua_settop(L, 4);
|
|
|
|
name = luaL_checkstring(L, 1);
|
|
func = luaL_checkstring(L, 2);
|
|
if (lua_type(L, 3) == LUA_TNIL)
|
|
prio = XCHAT_PRI_NORM;
|
|
else
|
|
prio = luaL_checknumber(L, 3);
|
|
|
|
cb->state = L;
|
|
cb->func = func;
|
|
cb->data = NULL;
|
|
cb->hook = NULL;
|
|
|
|
if (lxc_get_userdata(4, cb) == 0)
|
|
lua_pushboolean(L, 0);
|
|
else {
|
|
h = malloc(sizeof(struct lxc_hooks));
|
|
if (!h) {
|
|
xchat_printf(ph, "lxc_hook_print(): failed to malloc: %s",
|
|
strerror(errno));
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
hook = xchat_hook_print(ph, name, prio, lxc_run_print, cb);
|
|
h->hook = hook;
|
|
h->name = name;
|
|
h->next = NULL;
|
|
st = lxc_states;
|
|
while (st) {
|
|
if (st->state == L) {
|
|
if (!st->hooks)
|
|
st->hooks = h;
|
|
else {
|
|
hooks = st->hooks;
|
|
while (hooks->next)
|
|
hooks = hooks->next;
|
|
hooks->next = h;
|
|
}
|
|
break;
|
|
}
|
|
st = st->next;
|
|
}
|
|
lua_pushboolean(L, 1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.hook_server(name, func_name, prio, data)
|
|
* desc: Registers a function to be called when a certain server event
|
|
* occurs. You can use this to trap PRIVMSG, NOTICE, PART, a server
|
|
* numeric etc... If you want to hook every line that comes from the
|
|
* IRC server, you may use the special name of "RAW LINE".
|
|
* ret: true... or false if something went wrong while registering
|
|
* args:
|
|
* * name (string): the event name / numeric (yes, also as a string)
|
|
* * prio (number): one of the xchat.PRIO_* constants
|
|
* * func_name (string): the function to be called, when the event
|
|
* happens
|
|
* * data (table)... see xchat.hook_command()
|
|
*/
|
|
static int lxc_hook_server(lua_State *L)
|
|
{
|
|
xchat_hook *hook;
|
|
struct lxc_hooks *hooks, *h;
|
|
struct lxc_States *st;
|
|
const char *name, *func;
|
|
double prio;
|
|
|
|
struct lxc_cbdata *cb = malloc(sizeof(struct lxc_cbdata));
|
|
if (!cb) {
|
|
xchat_printf(ph, "lxc_hook_server(): failed to malloc: %s",
|
|
strerror(errno));
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
if (lua_gettop(L) < 4) /* expand to 4 args if necessary */
|
|
lua_settop(L, 4);
|
|
|
|
name = luaL_checkstring(L, 1);
|
|
func = luaL_checkstring(L, 2);
|
|
if (lua_type(L, 3) == LUA_TNIL)
|
|
prio = XCHAT_PRI_NORM;
|
|
else
|
|
prio = luaL_checknumber(L, 3);
|
|
|
|
cb->state = L;
|
|
cb->func = func;
|
|
cb->data = NULL;
|
|
cb->hook = NULL;
|
|
|
|
if (lxc_get_userdata(4, cb) == 0)
|
|
lua_pushboolean(L, 0);
|
|
else {
|
|
h = malloc(sizeof(struct lxc_hooks));
|
|
if (!h) {
|
|
xchat_printf(ph, "lxc_hook_server(): failed to malloc: %s",
|
|
strerror(errno));
|
|
lua_pushboolean(L, 0);
|
|
return 1;
|
|
}
|
|
hook = xchat_hook_server(ph, name, prio, lxc_run_hook, cb);
|
|
h->hook = hook;
|
|
h->name = name;
|
|
h->next = NULL;
|
|
st = lxc_states;
|
|
while (st) {
|
|
if (st->state == L) {
|
|
if (!st->hooks)
|
|
st->hooks = h;
|
|
else {
|
|
hooks = st->hooks;
|
|
while (hooks->next)
|
|
hooks = hooks->next;
|
|
hooks->next = h;
|
|
}
|
|
break;
|
|
}
|
|
st = st->next;
|
|
}
|
|
lua_pushboolean(L, 1);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.hook_timer(timeout, func_name, data)
|
|
* desc: Registers a function to be called every "timeout" milliseconds.
|
|
* ret: true (or false on error while registering)
|
|
* args:
|
|
* * timeout (number): Timeout in milliseconds (1000 is 1 second).
|
|
* * func_name (string): Callback function. This will be called
|
|
* every "timeout" milliseconds.
|
|
* * data (table): see xchat.hook_command()
|
|
*/
|
|
|
|
static unsigned long long lxc_timer_count = 0;
|
|
|
|
static int lxc_hook_timer(lua_State *L)
|
|
{
|
|
xchat_hook *hook;
|
|
struct lxc_hooks *hooks, *h;
|
|
struct lxc_States *st;
|
|
double timeout;
|
|
const char *func;
|
|
char name[32];
|
|
|
|
struct lxc_cbdata *cb = malloc(sizeof(struct lxc_cbdata));
|
|
if (!cb) {
|
|
luaL_error(L, "lxc_hook_timer(): failed to malloc: %s", strerror(errno));
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
if (lua_gettop(L) < 3) /* expand to 3 args if necessary */
|
|
lua_settop(L, 3);
|
|
|
|
timeout = luaL_checknumber(L, 1);
|
|
func = luaL_checkstring(L, 2);
|
|
|
|
cb->state = L;
|
|
cb->func = func;
|
|
cb->data = NULL;
|
|
|
|
if (lxc_get_userdata(3, cb) == 0)
|
|
lua_pushnil(L);
|
|
else {
|
|
h = malloc(sizeof(struct lxc_hooks));
|
|
if (!h) {
|
|
luaL_error(L, "lxc_hook_timer(): failed to malloc: %s",
|
|
strerror(errno));
|
|
return 0;
|
|
}
|
|
hook = xchat_hook_timer(ph, timeout, lxc_run_timer, cb);
|
|
cb->hook = hook;
|
|
h->hook = hook;
|
|
h->next = NULL;
|
|
snprintf(name, 31, "timer%llu", lxc_timer_count++);
|
|
h->name = name;
|
|
lua_pushstring(L, name);
|
|
|
|
st = lxc_states;
|
|
while (st) {
|
|
if (st->state == L) {
|
|
if (!st->hooks)
|
|
st->hooks = h;
|
|
else {
|
|
hooks = st->hooks;
|
|
while (hooks->next)
|
|
hooks = hooks->next;
|
|
hooks->next = h;
|
|
}
|
|
break;
|
|
}
|
|
st = st->next;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void lxc_unhook_timer(lua_State *L, xchat_hook *hook)
|
|
{
|
|
struct lxc_States *state;
|
|
struct lxc_hooks *hooks, *h, *prev_hook;
|
|
struct lxc_cbdata *cb;
|
|
struct lxc_userdata *ud, *u;
|
|
|
|
prev_hook = NULL;
|
|
state = lxc_states;
|
|
while (state) {
|
|
if (state->state == L) {
|
|
hooks = state->hooks;
|
|
while (hooks) {
|
|
if (hooks->hook == hook) {
|
|
h = hooks;
|
|
if (prev_hook)
|
|
prev_hook->next = hooks->next;
|
|
else
|
|
state->hooks = hooks->next;
|
|
|
|
cb = xchat_unhook(ph, h->hook);
|
|
if (cb) {
|
|
ud = cb->data;
|
|
while (ud) {
|
|
u = ud;
|
|
ud = ud->next;
|
|
free(u);
|
|
}
|
|
free(cb);
|
|
}
|
|
|
|
free(h);
|
|
return;
|
|
}
|
|
prev_hook = hooks;
|
|
hooks = hooks->next;
|
|
}
|
|
break;
|
|
}
|
|
state = state->next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* lua: func_name(data)
|
|
* desc: the callback function for the registered timer hook, return
|
|
* true to keep this timer going, false to stop it
|
|
* ret: none
|
|
* args:
|
|
* * data (table): the table you gave the hook_timer() as last
|
|
* argument
|
|
*/
|
|
static int lxc_run_timer(void *data)
|
|
{
|
|
int ret;
|
|
struct lxc_cbdata *cb = data;
|
|
xchat_hook *hook = cb->hook;
|
|
lua_State *L = cb->state;
|
|
|
|
lua_pushstring(L, cb->func);
|
|
lua_gettable(L, LUA_GLOBALSINDEX);
|
|
|
|
if (lua_pcall(L, 0, 1, 0)) {
|
|
xchat_printf(ph, "failed to call timer callback for '%s': %s",
|
|
cb->func, lua_tostring(L, -1));
|
|
lua_pop(L, 1);
|
|
lxc_unhook_timer(L, hook);
|
|
return 0;
|
|
}
|
|
|
|
if (lua_type(L, -1) != LUA_TBOOLEAN) {
|
|
xchat_printf(ph,
|
|
"timer callback for '%s' didn't return a boolean", cb->func);
|
|
lua_pop(L, 1);
|
|
lxc_unhook_timer(L, hook);
|
|
return 0;
|
|
}
|
|
|
|
ret = (lua_toboolean(L, -1) == 0) ? 0 : 1;
|
|
lua_pop(L, 1);
|
|
|
|
if (ret == 0)
|
|
lxc_unhook_timer(L, hook);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.unhook(name)
|
|
* desc: unhooks a previously hooked hook
|
|
* ret: true if the hook existed, else false..
|
|
* args:
|
|
* * name (string): name of a registered hook (e.g. with
|
|
* xchat.hook_command("whois", ... ) you would unhook "whois"
|
|
* ... see timer warnings... there's currently just one "timer"
|
|
* to unhook
|
|
*/
|
|
static int lxc_unhook(lua_State *L)
|
|
{
|
|
struct lxc_States *state;
|
|
struct lxc_hooks *hooks, *h, *prev_hook;
|
|
struct lxc_cbdata *cb;
|
|
struct lxc_userdata *ud, *u;
|
|
int done = 0;
|
|
const char *name = luaL_checkstring(L, 1);
|
|
|
|
prev_hook = NULL;
|
|
state = lxc_states;
|
|
while (state) {
|
|
if (state->state == L) {
|
|
hooks = state->hooks;
|
|
while (hooks) {
|
|
if (strcasecmp(hooks->name, name) == 0) {
|
|
h = hooks;
|
|
if (prev_hook)
|
|
prev_hook->next = hooks->next;
|
|
else
|
|
state->hooks = hooks->next;
|
|
|
|
cb = xchat_unhook(ph, h->hook);
|
|
if (cb) {
|
|
ud = cb->data;
|
|
while (ud) {
|
|
u = ud;
|
|
ud = ud->next;
|
|
free(u);
|
|
}
|
|
free(cb);
|
|
}
|
|
|
|
free(h);
|
|
done = 1;
|
|
break;
|
|
}
|
|
prev_hook = hooks;
|
|
hooks = hooks->next;
|
|
}
|
|
break;
|
|
}
|
|
state = state->next;
|
|
}
|
|
lua_pushboolean(L, done);
|
|
return 1;
|
|
}
|
|
|
|
static int lxc_event(lua_State *L)
|
|
{
|
|
lua_pushstring(L, lxc_event_name);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.command(command)
|
|
* desc: executes a command as if it were typed in xchat's input box.
|
|
* ret: none
|
|
* args:
|
|
* * command (string): command to execute, without the forward slash "/".
|
|
*/
|
|
static int lxc_command(lua_State *L)
|
|
{
|
|
const char *command = luaL_checkstring(L, 1);
|
|
xchat_command(ph, command);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.print(text)
|
|
* desc: Prints some text to the current tab/window.
|
|
* ret: none
|
|
* args:
|
|
* * text (string): the text to print
|
|
*/
|
|
static int lxc_print(lua_State *L)
|
|
{
|
|
const char *txt = luaL_checkstring(L, 1);
|
|
// FIXME? const char *txt = lua_tostring(L, 1);
|
|
xchat_print(ph, txt);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.emit_print(event, text, [text2, ...])
|
|
* desc: Generates a print event. This can be any event found in the
|
|
* Preferences > Advanced > Text Events window. The vararg parameter
|
|
* list MUST be no longer than four (4) parameters.
|
|
* Special care should be taken when calling this function inside a
|
|
* print callback (from xchat.hook_print()), as not to cause endless
|
|
* recursion.
|
|
* ret: true on success, false on error
|
|
* args:
|
|
* * event (string): the event name from the references > Advanced >
|
|
* Text Events window
|
|
* * text (string)
|
|
* text2 (string)
|
|
* ... (string(s)):
|
|
* parameters for the given event
|
|
*/
|
|
static int lxc_emit_print(lua_State *L)
|
|
{
|
|
|
|
int n = lua_gettop(L);
|
|
const char *text[5];
|
|
const char *event;
|
|
int i = 2;
|
|
|
|
if (n > 6)
|
|
luaL_error(L, "too many arguments to xchat.emit_print()");
|
|
|
|
event = luaL_checkstring(L, 1);
|
|
while (i <= n) {
|
|
text[i-2] = luaL_checkstring(L, i);
|
|
i++;
|
|
}
|
|
switch (n-1) {
|
|
case 0:
|
|
i = xchat_emit_print(ph, event, NULL);
|
|
break;
|
|
case 1:
|
|
i = xchat_emit_print(ph, event, text[0], NULL);
|
|
break;
|
|
case 2:
|
|
i = xchat_emit_print(ph, event, text[0], text[1], NULL);
|
|
break;
|
|
case 3:
|
|
i = xchat_emit_print(ph, event, text[0], text[1], text[2], NULL);
|
|
break;
|
|
case 4:
|
|
i = xchat_emit_print(ph, event, text[0], text[1], text[2], text[3], NULL);
|
|
break;
|
|
}
|
|
lua_pushboolean(L, (i == 0) ? 0 : 1);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.send_modes(targets, sign, mode [, modes_per_line])
|
|
* desc: Sends a number of channel mode changes to the current channel.
|
|
* For example, you can Op a whole group of people in one go. It may
|
|
* send multiple MODE lines if the request doesn't fit on one. Pass 0
|
|
* for modes_per_line to use the current server's maximum possible.
|
|
* This function should only be called while in a channel context.
|
|
* ret: none
|
|
* args:
|
|
* * targets (table): list of names
|
|
* * sign (string): mode sign, i.e. "+" or "-", only the first char of
|
|
* this is used (currently unchecked if it's really "+" or "-")
|
|
* * mode (string): mode char, i.e. "o" for opping, only the first
|
|
* char of this is used (currently unchecked, what char)
|
|
* * modes_per_line (number): [optional] number of modes per line
|
|
*/
|
|
static int lxc_send_modes(lua_State *L)
|
|
{
|
|
int i = 1;
|
|
const char *name, *mode, *sign;
|
|
const char *targets[4096];
|
|
int num = 0; /* modes per line */
|
|
|
|
if (!lua_istable(L, 1)) {
|
|
luaL_error(L,
|
|
"xchat.send_modes(): first argument is not a table: %s",
|
|
lua_typename(L, lua_type(L, 1)));
|
|
return 0;
|
|
}
|
|
|
|
while (1) {
|
|
lua_pushnumber(L, i); /* push index on stack */
|
|
lua_gettable(L, 1); /* and get the element @ index */
|
|
if (lua_isnil(L, -1)) { /* end of table */
|
|
lua_pop(L, 1);
|
|
break;
|
|
}
|
|
|
|
if (lua_type(L, -1) != LUA_TSTRING) { /* oops, something wrong */
|
|
luaL_error(L,
|
|
"lua: xchat.send_modes(): table element #%d not a string: %s",
|
|
i, lua_typename(L, lua_type(L, -1)));
|
|
lua_pop(L, 1);
|
|
return 0;
|
|
}
|
|
|
|
name = lua_tostring(L, -1);
|
|
if (name == NULL) { /* this should not happen, but... */
|
|
lua_pop(L, 1);
|
|
break;
|
|
}
|
|
|
|
targets[i-1] = name;
|
|
lua_pop(L, 1); /* take index from stack */
|
|
++i;
|
|
}
|
|
|
|
sign = luaL_checkstring(L, 2);
|
|
if (sign[0] == '\0' || sign[1] != '\0') {
|
|
luaL_error(L, "argument #2 (mode sign) does not have length 1");
|
|
return 0;
|
|
}
|
|
if ((sign[0] != '+') && (sign[0] != '-')) {
|
|
luaL_error(L, "argument #2 (mode sign) is not '+' or '-'");
|
|
return 0;
|
|
}
|
|
|
|
mode = luaL_checkstring(L, 3);
|
|
if (mode[0] == '\0' || mode[1] != '\0') {
|
|
luaL_error(L, "argument #3 (mode char) does not have length 1");
|
|
return 0;
|
|
}
|
|
if (!isalpha((int)mode[0]) || !isascii((int)mode[0])) {
|
|
luaL_error(L, "argument #3 is not a valid mode character");
|
|
return 0;
|
|
}
|
|
|
|
if (lua_gettop(L) == 4)
|
|
num = luaL_checknumber(L, 4);
|
|
|
|
xchat_send_modes(ph, targets, i-1, num, sign[0], mode[0]);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.find_context(srv, chan)
|
|
* desc: Finds a context based on a channel and servername. If servname is nil,
|
|
* it finds any channel (or query) by the given name. If channel is nil,
|
|
* it finds the front-most tab/window of the given servname. If nil is
|
|
* given for both arguments, the currently focused tab/window will be
|
|
* returned.
|
|
* Changed in 2.6.1. If servname is nil, it finds the channel (or query)
|
|
* by the given name in the same server group as the current context.
|
|
* If that doesn't exists then find any by the given name.
|
|
* ret: context number (DON'T modify)
|
|
* args:
|
|
* * srv (string or nil): server name
|
|
* * chan (string or nil): channel / query name
|
|
*/
|
|
static int lxc_find_context(lua_State *L)
|
|
{
|
|
const char *srv, *chan;
|
|
long ctx;
|
|
xchat_context *ptr;
|
|
|
|
if (lua_type(L, 1) == LUA_TSTRING) {
|
|
srv = lua_tostring(L, 1);
|
|
if (srv[0] == '\0')
|
|
srv = NULL;
|
|
}
|
|
else
|
|
srv = NULL;
|
|
|
|
if (lua_type(L, 2) == LUA_TSTRING) {
|
|
chan = lua_tostring(L, 2);
|
|
if (chan[0] == '\0')
|
|
chan = NULL;
|
|
}
|
|
else
|
|
chan = NULL;
|
|
|
|
ptr = xchat_find_context(ph, srv, chan);
|
|
ctx = (long)ptr;
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "find_context(): %#lx\n", (long)ptr);
|
|
#endif
|
|
lua_pushnumber(L, (double)ctx);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.get_context()
|
|
* desc: Returns the current context for your plugin. You can use this later
|
|
* with xchat_set_context.
|
|
* ret: context number ... DON'T modifiy
|
|
* args: none
|
|
*/
|
|
static int lxc_get_context(lua_State *L)
|
|
{
|
|
long ptr;
|
|
xchat_context *ctx = xchat_get_context(ph);
|
|
ptr = (long)ctx;
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "get_context(): %#lx\n", ptr);
|
|
#endif
|
|
lua_pushnumber(L, (double)ptr);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.get_info(id)
|
|
* desc: Returns information based on your current context.
|
|
* ret: the requested string or nil on error
|
|
* args:
|
|
* * id (string): the wanted information
|
|
*/
|
|
static int lxc_get_info(lua_State *L)
|
|
{
|
|
const char *id = luaL_checkstring(L, 1);
|
|
const char *value = xchat_get_info(ph, id);
|
|
if (value == NULL)
|
|
lua_pushnil(L);
|
|
else
|
|
lua_pushstring(L, value);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.get_prefs(name)
|
|
* desc: Provides xchat's setting information (that which is available
|
|
* through the /set command). A few extra bits of information are
|
|
* available that don't appear in the /set list, currently they are:
|
|
* * state_cursor: Current input-box cursor position (characters,
|
|
* not bytes). Since 2.4.2.
|
|
* *id: Unique server id. Since 2.6.1.
|
|
* ret: returns the string/number/boolean for the given config var
|
|
* or nil on error
|
|
* args:
|
|
* * name (string): the wanted setting's name
|
|
*/
|
|
static int lxc_get_prefs(lua_State *L)
|
|
{
|
|
int i;
|
|
const char *str;
|
|
const char *name = luaL_checkstring(L, 1);
|
|
/*
|
|
* luckily we can store anything in a lua var... this makes the
|
|
* xchat lua api more user friendly ;-)
|
|
*/
|
|
switch (xchat_get_prefs(ph, name, &str, &i)) {
|
|
case 0: /* request failed */
|
|
lua_pushnil(L);
|
|
break;
|
|
case 1:
|
|
lua_pushstring(L, str);
|
|
break;
|
|
case 2:
|
|
lua_pushnumber(L, (double)i);
|
|
break;
|
|
case 3:
|
|
lua_pushboolean(L, i);
|
|
break;
|
|
default: /* doesn't happen if xchat's C-API doesn't change ;-) */
|
|
lua_pushnil(L);
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.set_context(ctx)
|
|
* desc: Changes your current context to the one given.
|
|
* ret: true or false
|
|
* args:
|
|
* * ctx (number): the context (e.g. from xchat.get_context())
|
|
*/
|
|
static int lxc_set_context(lua_State *L)
|
|
{
|
|
double ctx = luaL_checknumber(L, 1);
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "set_context(): %#lx\n", (long)ctx);
|
|
#endif
|
|
xchat_context *xc = (void *)(long)ctx;
|
|
lua_pushboolean(L, xchat_set_context(ph, xc));
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.nickcmp(name1, name2)
|
|
* desc: Performs a nick name comparision, based on the current server
|
|
* connection. This might be a RFC1459 compliant string compare, or
|
|
* plain ascii (in the case of DALNet). Use this to compare channels
|
|
* and nicknames. The function works the same way as strcasecmp.
|
|
* ret: number ess than, equal to, or greater than zero if name1 is found,
|
|
* respectively, to be less than, to match, or be greater than name2.
|
|
* args:
|
|
* * name1 (string): nick or channel name
|
|
* * name2 (string): nick or channel name
|
|
*/
|
|
static int lxc_nickcmp(lua_State *L)
|
|
{
|
|
const char *n1 = luaL_checkstring(L, 1);
|
|
const char *n2 = luaL_checkstring(L, 2);
|
|
lua_pushnumber(L, (double)xchat_nickcmp(ph, n1, n2));
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.list_get(name)
|
|
* desc: http://xchat.org/docs/plugin20.html#lists :)
|
|
* time_t values are stored as number => e.g.
|
|
* os.date("%Y-%m-%d, %H:%M:%S", time_t_value)
|
|
* pointers (channel -> context) as number... untested if this works
|
|
* ret: table with tables with all keys=Name, value=(Type)... or nil on error
|
|
* args:
|
|
* * name (string): the wanted list
|
|
*/
|
|
static int lxc_list_get(lua_State *L)
|
|
{
|
|
const char *name = luaL_checkstring(L, 1);
|
|
int i; /* item index */
|
|
int l; /* list index */
|
|
const char *str;
|
|
double num;
|
|
time_t date;
|
|
long ptr;
|
|
const char *const *fields = xchat_list_fields(ph, name);
|
|
xchat_list *list = xchat_list_get(ph, name);
|
|
|
|
if (!list) {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
lua_newtable(L);
|
|
/* this is like the perl plugin does it ;-) */
|
|
l = 1;
|
|
while (xchat_list_next(ph, list)) {
|
|
i = 0;
|
|
lua_pushnumber(L, l);
|
|
lua_newtable(L);
|
|
while (fields[i] != NULL) {
|
|
switch (fields[i][0]) {
|
|
case 's':
|
|
str = xchat_list_str(ph, list, fields [i] + 1);
|
|
lua_pushstring(L, fields[i]+1);
|
|
if (str != NULL)
|
|
lua_pushstring(L, str);
|
|
else
|
|
lua_pushnil(L);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case 'p':
|
|
ptr = (long)xchat_list_str(ph, list, fields [i] + 1);
|
|
num = (double)ptr;
|
|
lua_pushstring(L, fields[i]+1);
|
|
lua_pushnumber(L, num);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case 'i':
|
|
num = (double)xchat_list_int(ph, list, fields[i] + 1);
|
|
lua_pushstring(L, fields[i]+1);
|
|
lua_pushnumber(L, num);
|
|
lua_settable(L, -3);
|
|
break;
|
|
case 't':
|
|
date = xchat_list_time(ph, list, fields[i] + 1);
|
|
lua_pushstring(L, fields[i]+1);
|
|
lua_pushnumber(L, (double)date);
|
|
lua_settable(L, -3);
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
lua_settable(L, -3);
|
|
l++;
|
|
}
|
|
xchat_list_free(ph, list);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.list_fields(name)
|
|
* desc: returns the possible keys for name as table
|
|
* ret: table ;->
|
|
* args:
|
|
* * name (string): name of the wanted list ("channels", "dcc",
|
|
* "ignore", "notify", "users")
|
|
*/
|
|
static int lxc_list_fields(lua_State *L)
|
|
{
|
|
const char *name = luaL_checkstring(L, 1);
|
|
const char *const *fields = xchat_list_fields(ph, name);
|
|
int i;
|
|
|
|
lua_newtable(L);
|
|
i = 0;
|
|
while (fields[i] != NULL) {
|
|
lua_pushnumber(L, i);
|
|
/* first char is the type ... */
|
|
lua_pushstring(L, fields[i]+1);
|
|
lua_settable(L, -3);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.gettext(str)
|
|
* desc:
|
|
*/
|
|
static int lxc_gettext(lua_State *L)
|
|
{
|
|
#if defined(_WIN32) || defined(LXC_XCHAT_GETTEXT)
|
|
lua_pushstring(L, xchat_gettext(ph, luaL_checkstring(L, 1)));
|
|
#else
|
|
const char *dom;
|
|
const char *msgid = luaL_checkstring(L, 1);
|
|
if (lua_type(L,2) == LUA_TSTRING)
|
|
dom = lua_tostring(L, 2);
|
|
else
|
|
dom = "xchat";
|
|
lua_pushstring(L, dgettext(dom, msgid));
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* lua: xchat.bits(flags)
|
|
* desc: returns a table of booleans if the bit at index (err... index-1) is
|
|
* set
|
|
* ret: table of booleans
|
|
* args:
|
|
* * flags (number)
|
|
*/
|
|
static int lxc_bits(lua_State *L)
|
|
{
|
|
int flags = luaL_checknumber(L, 1);
|
|
int i;
|
|
lua_pop(L, 1);
|
|
lua_newtable(L);
|
|
for (i=0; i<16; i++) { /* at time of writing, the highest index was 9 ... */
|
|
lua_pushnumber(L, i+1);
|
|
lua_pushboolean(L, ((1<<i) & flags) == 0 ? 0 : 1);
|
|
lua_settable(L, -3);
|
|
}
|
|
return 1;
|
|
}
|
|
/*
|
|
* vim: ts=3 noexpandtab
|
|
*/
|