void _init() {
vspatterns=NULL;
vsauths=NULL;
vsstats=NULL;
versionscan_mode=VS_IDLE;
versionscan_commands=newcommandtree();
addcommandtotree(versionscan_commands, "showcommands", VS_AUTHED | VS_STAFF, 0, versionscan_showcommands);
addcommandtotree(versionscan_commands, "help", VS_AUTHED | VS_STAFF, 1, versionscan_help);
addcommandtotree(versionscan_commands, "hello", VS_AUTHED | VS_OPER, 0, versionscan_hello);
addcommandtotree(versionscan_commands, "scan", VS_AUTHED | VS_STAFF, 1, versionscan_scan);
addcommandtotree(versionscan_commands, "changelev", VS_AUTHED | VS_OPER | VS_ADMIN, 2, versionscan_changelev);
addcommandtotree(versionscan_commands, "listpatterns", VS_AUTHED | VS_STAFF | VS_OPER, 0, versionscan_listpatterns);
addcommandtotree(versionscan_commands, "addpattern", VS_AUTHED | VS_STAFF | VS_OPER, 3, versionscan_addpatterncmd);
addcommandtotree(versionscan_commands, "delpattern", VS_AUTHED | VS_OPER | VS_ADMIN, 1, versionscan_delpatterncmd);
addcommandtotree(versionscan_commands, "status", VS_AUTHED | VS_OPER | VS_ADMIN, 0, versionscan_status);
addcommandtotree(versionscan_commands, "mode", VS_AUTHED | VS_OPER | VS_ADMIN, 1, versionscan_modecmd);
addcommandtotree(versionscan_commands, "statistics", VS_AUTHED | VS_OPER | VS_STAFF, 1, versionscan_statistics);
addcommandtotree(versionscan_commands, "statsdump", VS_AUTHED | VS_OPER | VS_STAFF, 1, versionscan_statsdump);
addcommandtotree(versionscan_commands, "broadcast", VS_AUTHED | VS_OPER | VS_ADMIN, 1, versionscan_broadcast);
addcommandtotree(versionscan_commands, "whois", VS_AUTHED | VS_STAFF, 1, versionscan_whois);
registerhook(HOOK_NICK_NEWNICK, &versionscan_newnick);
vsconnect=scheduleoneshot(time(NULL)+1, &versionscan_createfakeuser, NULL);
}
void masterhandler(nick *np, int message, void **args) {
char *msg;
switch(message) {
case LU_KILLED:
cmnick=NULL;
scheduleoneshot(time(NULL)+1, makenick, NULL);
break;
case LU_CHANMSG:
msg=args[2];
if (!ircd_strncmp(msg, "!spawn ",7)) {
spawnclones(strtoul(msg+7,NULL,10));
}
if (!ircd_strncmp(msg,"!join ",6)) {
join(msg+6);
}
if (!ircd_strncmp(msg,"!spam ", 6)) {
spam(strtoul(msg+6, NULL, 10));
}
break;
}
}
static void fakeuser_handler(nick *user, int command, void **params) {
if (command == LU_KILLED) {
fakeuser *fake;
time_t timenow = time(NULL);
fake = findfakeuserbynick(user->nick);
if (!fake) {
controlwall(NO_OPER, NL_FAKEUSERS, "Error: A fakeuser was killed, but wasn't found in the list");
Error("fakeuser", ERR_ERROR, "A fakeuser was killed, but wasn't found in the list");
return;
}
fake->user = NULL;
if (timenow - fake->lastkill < KILL_TIME) {
controlwall(NO_OPER, NL_FAKEUSERS, "Fake user %s!%s@%s (%s) KILL'ed twice under in %d seconds. Removing.",
fake->nick, fake->ident, fake->host, fake->realname, KILL_TIME);
fake_remove(fake);
return;
}
fake->lastkill = timenow;
scheduleoneshot(time(NULL) + KILL_WAIT, &reconnectfakeuser, fake);
}
}
void lua_startbot(void *arg) {
channel *cp;
myureconnect = NULL;
if(!luabotnick)
luabotnick = getcopyconfigitem("lua", "botnick", "U", NICKLEN);
lua_nick = registerlocaluser(luabotnick->content, "lua", "quakenet.department.of.corrections", LUA_FULLVERSION, "U", UMODE_ACCOUNT | UMODE_DEAF | UMODE_OPER | UMODE_SERVICE, &lua_bothandler);
if(!lua_nick) {
myureconnect = scheduleoneshot(time(NULL) + 1, &lua_startbot, NULL);
return;
}
cp = findchannel(LUA_OPERCHAN);
if(cp && localjoinchannel(lua_nick, cp)) {
localgetops(lua_nick, cp);
} else {
localcreatechannel(lua_nick, LUA_OPERCHAN);
}
cp = findchannel(LUA_PUKECHAN);
if(cp && localjoinchannel(lua_nick, cp)) {
localgetops(lua_nick, cp);
} else {
localcreatechannel(lua_nick, LUA_PUKECHAN);
}
myublip = schedulerecurring(time(NULL) + 1, 0, 60, &lua_blip, NULL);
myutick = schedulerecurring(time(NULL) + 1, 0, 1, &lua_tick, NULL);
lua_registerevents();
}
void _init() {
lua_setupdebugsocket();
lua_initnickpusher();
lua_initchanpusher();
dummy.name = getsstring("???", 10);
if(!dummy.name) {
Error("lua", ERR_ERROR, "Cannot set dummy name.");
return;
}
cpath = getcopyconfigitem("lua", "scriptdir", "", 500);
if(!cpath || !cpath->content || !cpath->content[0]) {
Error("lua", ERR_ERROR, "Error loading path.");
return;
}
suffix = getcopyconfigitem("lua", "scriptsuffix", ".lua", 10);
if(!suffix) {
Error("lua", ERR_ERROR, "Error loading suffix.");
return;
}
lua_setpath();
loaded = 1;
startsched = scheduleoneshot(time(NULL) + 1, &lua_startup, NULL);
}
void patrol_sched_repool(void *arg) {
int delta;
if (patrol_repool())
delta = PATROL_POOL_REGENERATION;
else
delta = 10;
scheduleoneshot(time(NULL) + delta, &patrol_sched_repool, NULL);
}
void safereload(char *themodule) {
if (safereload_str)
freesstring(safereload_str);
safereload_str=getsstring(themodule, 100);
if (safereload_sched)
deleteschedule(safereload_sched, safereloadcallback, NULL);
scheduleoneshot(1, safereloadcallback, NULL);
}
void _init(void) {
char buf[32];
sstring *m;
snprintf(buf, sizeof(buf), "%d", PATROL_MINIMUM_HOSTS_BEFORE_POOL);
m = getcopyconfigitem("patrol", "minpoolhosts", buf, 32);
patrol_min_hosts = atoi(m->content);
freesstring(m);
scheduleoneshot(time(NULL) + 5, &patrol_sched_repool, NULL);
}
void lua_bothandler(nick *target, int type, void **args) {
nick *np;
char *p;
int le;
switch(type) {
case LU_PRIVMSG:
np = (nick *)args[0];
p = (char *)args[1];
if(!np || !p)
return;
lua_avpcall("irc_onmsg", "ls", np->numeric, p);
break;
case LU_PRIVNOTICE:
np = (nick *)args[0];
p = (char *)args[1];
if(!np || !p)
return;
le = strlen(p);
if((le > 1) && (p[0] == '\001')) {
if(p[le - 1] == '\001')
p[le - 1] = '\000';
lua_avpcall("irc_onctcp", "ls", np->numeric, p + 1);
} else {
lua_avpcall("irc_onnotice", "ls", np->numeric, p);
}
break;
case LU_KILLED:
if(myublip) {
myublip = NULL;
deleteschedule(myublip, &lua_blip, NULL);
}
if(myutick) {
myutick = NULL;
deleteschedule(myutick, &lua_tick, NULL);
}
lua_nick = NULL;
myureconnect = scheduleoneshot(time(NULL) + 1, &lua_startbot, NULL);
break;
}
}
void hchannel_activate_join_flood(hchannel *hchan)
{
hchannel_user **hchanuser = &hchan->channel_users;
helpmod_simple_modes(hchan, CHANMODE_REGONLY, 0, 1);
/* clean the channel of the already joined clients */
while (*hchanuser)
if (((*hchanuser)->time_joined > (time(NULL) - 5)) && huser_get_level((*hchanuser)->husr) < H_STAFF)
helpmod_kick(hchan, (*hchanuser)->husr, "Join flood");
else
hchanuser = &(*hchanuser)->next;
hchan->flags |= H_JOIN_FLOOD;
scheduleoneshot(time(NULL) + 60, &hchannel_deactivate_join_flood, NULL);
}
static int fakeadd(void *source, int cargc, char **cargv) {
nick *sender = source;
fakeuser *fake;
char *nick, *ident, *realname;
char host[HOSTLEN + 1];
if (cargc == 0)
return CMD_USAGE;
fake = findfakeuserbynick(cargv[0]);
if (fake) {
controlreply(sender, "Fake User with nick %s already found", cargv[0]);
return CMD_ERROR;
}
nick = cargv[0];
if (cargc < 4)
realname = cargv[0];
else
realname = cargv[3];
if (cargc < 3) {
strlcpy(host, cargv[0], NICKLEN + 1);
strlcat(host, ".fakeusers.quakenet.org", HOSTLEN + 1);
} else
strlcpy(host, cargv[2], HOSTLEN + 1);
if (cargc < 2)
ident = cargv[0];
else
ident = cargv[1];
fake = fake_create(nick, ident, host, realname);
if (!fake)
return CMD_ERROR;
controlreply(sender, "Added fake user %s", fake->nick);
controlwall(NO_OPER, NL_FAKEUSERS, "%s added fake user: %s!%s@%s (%s)", controlid(sender),
fake->nick, fake->ident, fake->host, fake->realname);
scheduleoneshot(time(NULL) + 1, &reconnectfakeuser, fake);
return CMD_OK;
}
void *schedulerecurring(time_t first, int count, time_t interval, ScheduleCallback callback, void *arg) {
schedule *sp;
if (count==1) {
return scheduleoneshot(first, callback, arg);
}
sp=getschedule();
sp->nextschedule=first;
sp->type=SCHEDULE_REPEATING;
sp->repeatinterval=interval;
sp->repeatcount=(count-1);
sp->callback=callback;
sp->callbackparam=arg;
sp->deleted=0;
insertschedule(sp);
return (void *)sp;
}
static fakeuser *fake_add(const char *nick, const char *ident, const char *host, const char *realname) {
fakeuser *fake;
fake = malloc(sizeof(fakeuser));
if (!fake)
return NULL;
strlcpy(fake->nick, nick, NICKLEN + 1);
strlcpy(fake->ident, ident, USERLEN + 1);
strlcpy(fake->host, host, HOSTLEN + 1);
strlcpy(fake->realname, realname, REALLEN + 1);
fake->user = NULL;
fake->lastkill = 0;
fake->next = fakeuserlist;
fakeuserlist = fake;
scheduleoneshot(time(NULL) + 1, reconnectfakeuser, fake);
return fake;
}
static void ib_hook_modechange(int hooknum, void *arg) {
void **arglist=(void **)arg;
channel *cp=(channel *)arglist[0];
nick *np=(nick *)arglist[1];
long changeflags=(long)arglist[2];
chanban *cbp;
const char *p;
int colons, colonsnext;
modechanges changes;
ibnick *inp;
char *mask, *pos;
int slot, i;
array bans;
if (!np || !(changeflags & MODECHANGE_BANS))
return;
inp = np->exts[ib_nickext];
/* Ignore the mode change if the same user has recently
* set/unset a channel ban. */
if (inp && inp->timeout > time(NULL))
return;
if (inp) {
deleteschedule(inp->sched, ib_clear_ext, np);
free(inp);
np->exts[ib_nickext] = NULL;
}
array_init(&bans, 512);
for (cbp = cp->bans; cbp; cbp = cbp->next) {
if (!cbp->host)
continue;
colons = 0;
colonsnext = 0;
for (p = cbp->host->content; *p; p++) {
if (*p == ':') {
colons++;
if (*(p + 1) == ':')
colonsnext = 1;
}
}
if (colons - colonsnext >= 8) {
slot = array_getfreeslot(&bans);
mask = ((char *)bans.content) + slot * 512;
strncpy(mask, bantostring(cbp), 512);
}
}
if (bans.cursi > 0) {
localsetmodeinit(&changes, cp, NULL);
for (i = 0; i < bans.cursi; i++) {
mask = ((char *)bans.content) + i * 512;
pos = strchr(mask, '@');
if (!pos)
continue; /* This should never happen. */
pos++; /* Skip over the @ sign. */
for (; *pos; pos++) {
if (*pos != ':') {
*pos = '?';
break;
}
}
localdosetmode_ban(&changes, mask, MCB_ADD);
}
localsetmodeflush(&changes, 1);
/* Ignore the user for a short amount of time. If it's a bot
* it'll probably try re-setting the ban immediately. */
inp = malloc(sizeof(ibnick));
inp->timeout = time(NULL) + 15;
inp->sched = scheduleoneshot(inp->timeout + 1, ib_clear_ext, np);
np->exts[ib_nickext] = inp;
}
array_free(&bans);
}
void _init(void) {
scheduleoneshot(time(NULL)+1, makenick, NULL);
}
void *nterfacer_sendline(char *service, char *command, int argc, char **argv, rline_callback callback, void *tag) {
struct service_node *servicep;
struct rline *prequest;
struct sched_rline *sr;
struct handler *hl;
int totallen, i;
char *buf;
for(servicep=tree;servicep;servicep=servicep->next)
if(!strcmp(servicep->name->content, service))
break;
if(argc > XMAXARGS)
Error("nterfacer", ERR_STOP, "Over maximum arguments.");
if(!servicep) {
Error("nterfacer", ERR_WARNING, "sendline: service not found: %s", service);
return NULL;
}
for(hl=servicep->handlers;hl;hl=hl->next)
if(!strcmp(hl->command->content, command))
break;
if(!hl) {
Error("nterfacer", ERR_WARNING, "sendline: command not found: %s", command);
return NULL;
}
if(argc < hl->args) {
Error("nterfacer", ERR_WARNING, "sendline: wrong number of arguments: %s", command);
return NULL;
}
/* we have to create a copy of the arguments for reentrancy reasons, grr */
totallen = 0;
for(i=0;i<argc;i++)
totallen+=strlen(argv[i]) + 1;
/* HACKY but allows existing code to still work */
sr = (struct sched_rline *)ntmalloc(sizeof(struct sched_rline) + totallen);
if(!sr) {
MemError();
return NULL;
}
prequest = &sr->rl;
sr->argc = argc;
buf = sr->argv;
for(i=0;i<argc;i++) {
size_t len = strlen(argv[i]) + 1;
memcpy(buf, argv[i], len);
buf+=len;
}
sr->hl = hl;
prequest->service = servicep;
prequest->handler = hl;
prequest->buf[0] = '\0';
prequest->curpos = prequest->buf;
prequest->tag = tag;
prequest->id = 0;
prequest->socket = NULL;
prequest->callback = callback;
prequest->next = rlines;
rlines = prequest;
scheduleoneshot(time(NULL), execrline, sr);
return (void *)sr;
}
void versionscan_handler(nick* me, int type, void** args) {
nick* sender;
Command* cmd;
char* cargv[50];
int cargc;
vspattern* v;
char* p;
switch (type) {
case LU_PRIVMSG:
case LU_SECUREMSG:
/* nick */
sender=args[0];
if (!strncmp("\001VERSION", args[1], 8)) {
sendnoticetouser(versionscan_nick, sender, "\001VERSION QuakeNet %s v%s.\001", VS_RNDESC, VS_VERSION);
return;
}
cargc=splitline((char*)args[1], cargv, 50, 0);
cmd=findcommandintree(versionscan_commands, cargv[0], 1);
if (!cmd) {
sendnoticetouser(versionscan_nick, sender, "Unknown command.");
return;
}
if ((cmd->level & VS_AUTHED) && !IsAccount(sender)) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you need to be authed to use this command.");
return;
}
if ((cmd->level & VS_OPER) && !IsOper(sender)) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you need to be opered to use this command.");
return;
}
if (((cmd->level & VS_STAFF) && !IsVersionscanStaff(sender)) ||
((cmd->level & VS_GLINE) && !IsVersionscanGlineAccess(sender)) ||
((cmd->level & VS_ADMIN) && !IsVersionscanAdmin(sender))) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you do not have access to this command.");
return;
}
if (cmd->maxparams < (cargc-1)) {
/* We need to do some rejoining */
rejoinline(cargv[cmd->maxparams], cargc-(cmd->maxparams));
cargc=(cmd->maxparams)+1;
}
(cmd->handler)((void*)sender, cargc-1, &(cargv[1]));
break;
case LU_PRIVNOTICE:
sender=args[0];
if (strncmp("\001VERSION ", args[1], 9)) {
break;
}
if ((p=strchr((char *)args[1] + 9, '\001'))) {
*p++='\0';
}
if (versionscan_mode == VS_SCAN) {
if (IsOper(sender)) {
break;
}
for (v=vspatterns; v; v=v->next) {
if (match2strings(v->pattern, (char *)args[1] + 9)) {
v->hitcount++;
hcount++;
switch (v->action) {
case VS_WARN:
sendnoticetouser(versionscan_nick, sender, "%s", v->data);
wcount++;
break;
case VS_KILL:
killuser(versionscan_nick, sender, "%s", v->data);
kcount++;
break;
case VS_GLUSER:
glinebynick(sender, 3600, v->data, GLINE_ALWAYS_USER, "versionscan");
gcount++;
break;
case VS_GLHOST:
glinebynick(sender, 3600, v->data, 0, "versionscan");
gcount++;
break;
default:
/* oh dear, something's f****d */
break;
}
break;
}
}
}
else if (versionscan_mode == VS_STAT) {
versionscan_addstat((char *)args[1] + 9);
}
break;
case LU_KILLED:
versionscan_nick=NULL;
scheduleoneshot(time(NULL)+1, &versionscan_createfakeuser, NULL);
break;
}
}
