core.*
.autobuild.mk
.configure.log
+*.orig
[control]
nick=N3
+#ident=control
+#hostname=your.hostname.here
+#realname=NewServ Control Service
+#authname=C
auth
~~~
Implements gline commands and general gline functionality that is used by other
modules.
+geoip
+~~~~
+
+Provides geo-location services for other modules.
+
+Configuration:
+
+[geoip]
+#db=GeoIP.dat
+
helpmod2
~~~~~~~
Implements rping and various other status query commands.
+Configuration:
+
+[miscreply]
+#admin1=Located at the Union Aerospace Corp. facility, Stroggos
+#admin2=Network IRC Service
+#admin3=No administrative info available
+
+patricia, patricianick, patriciasearch
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Implements finding nicks based on CIDR prefixes.
+
proxyscan
~~~~~~~~
request
~~~~~~
-This is QuakeNet's channel service request bot (R). Some of the module
-parameters are not configurable - instead you will have to modify the
-request/request.h header file and recompile the module.
+This is QuakeNet's channel service request bot (R).
+
+Configuration:
+
+[request]
+#nick=R
+#user=request
+#host=request.quakenet.org
+#real=Service Request v0.23
+#snick=S
+#sserver=spamscan.quakenet.org
+#qnick=Q
+#qserver=cserve.quakenet.org
serverlist
~~~~~~~~~
~~~~~
Implements connection limits. Supports the TRUST protocol which is used
-by quakenet-iauthd to determine whether to allow users on the network.
+by quakenet-iauthd to determine whether to allow users to connect to the
+network.
-You will need to load the trusts_master module on one of your newserv
+You will need to load the trusts_master module on exactly one of your newserv
instances. All other instances should load the trusts_slave module in order
to receive replication updates from the trusts master:
http://hg.quakenet.org/iauthd/ to enforce connection limits using IAuth rather
than g:lines.
-whowas
-~~~~~
+whowas, whowas_channels
+~~~~~~~~~~~~~~~~~~~~~~
Keeps track of historical user records. Used by the glines module to chase
nicks and by newsearch.
+The whowas_channels module optionally keeps track of which channels users
+were on.
+
xsb
~~
cs_log(source, "SPEWEMAIL %s", cargv[0]);
tree = NSASTNode(match_parse, NSASTNode(qemail_parse), NSASTLiteral(cargv[0]));
- return ast_usersearch(&tree, chanservmessagewrapper, source, chanservwallwrapper, printauth, showheader, (void *)QM_SPEWHEADER, 2000);
+ return ast_usersearch(&tree, chanservmessagewrapper, source, chanservwallwrapper, printauth, showheader, (void *)QM_SPEWHEADER, 2000, NULL);
}
int cs_dospewdb(void *source, int cargc, char **cargv) {
NSASTNode(match_parse, NSASTNode(qemail_parse), NSASTLiteral(cargv[0])),
NSASTNode(match_parse, NSASTNode(qlasthost_parse), NSASTLiteral(cargv[0])),
);
- return ast_usersearch(&tree, chanservmessagewrapper, source, chanservwallwrapper, printauth, showheader, (void *)QM_SPEWHEADER, 2000);
+ return ast_usersearch(&tree, chanservmessagewrapper, source, chanservwallwrapper, printauth, showheader, (void *)QM_SPEWHEADER, 2000, NULL);
}
include ../build.mk
.PHONY: all
-all: control.so
+all: control.so control_commands.so control_management.so
control-lite.so: control-lite.o
-control.so: control.o
+control.so: control.o control_db.o control_policy.o
+
+control_commands.so: control_commands.o
+
+control_management.so: control_management.o
#include "../lib/version.h"
#include "../lib/irc_string.h"
#include "control.h"
+#include "control_policy.h"
#include <stdio.h>
#include <string.h>
nick *mynick;
CommandTree *controlcmds;
-ControlMsg controlreply;
-ControlWall controlwall;
-ControlPermitted controlpermitted;
DestroyExt controldestroyext;
+int noperserv_ext;
+
+const flag no_commandflags[] = {
+ { 'o', __NO_OPER },
+ { 't', __NO_TRUST },
+ { 's', __NO_STAFF },
+ { 'S', __NO_SEC },
+ { 'd', __NO_DEVELOPER },
+ { 'L', __NO_LEGACY },
+ { 'O', __NO_OPERED },
+ { 'r', __NO_AUTHED },
+ { 'R', __NO_ACCOUNT },
+ { 'Y', __NO_RELAY },
+ { '\0', 0 }
+ };
+
+const flag no_userflags[] = {
+ { 'o', __NO_OPER },
+ { 't', __NO_TRUST },
+ { 's', __NO_STAFF },
+ { 'S', __NO_SEC },
+ { 'd', __NO_DEVELOPER },
+ { 'Y', __NO_RELAY },
+ { '\0', 0 }
+ };
+
+const flag no_noticeflags[] = {
+ { 'm', NL_MANAGEMENT }, /* hello, password, userflags, noticeflags */
+ { 't', NL_TRUSTS }, /* trust stuff... */
+ { 'k', NL_KICKKILLS }, /* KICK/KILL commands */
+ { 'I', NL_MISC }, /* misc commands */
+ { 'g', NL_GLINES }, /* GLINE commands */
+ { 'G', NL_GLINES_AUTO }, /* automated gline messages */
+ { 'h', NL_HITS }, /* Where a gline or kill is set automatically by the bot */
+ { 'c', NL_CLONING }, /* Clone detection */
+ { 'C', NL_CLEARCHAN }, /* When someone clearchans */
+ { 'f', NL_FAKEUSERS }, /* Fakeuser addition */
+ { 'b', NL_BROADCASTS }, /* Broadcast/mbroadcast/sbroadcast */
+ { 'o', NL_OPERATIONS }, /* insmod/rmmod/etc */
+ { 'O', NL_OPERING }, /* when someone opers */
+ { 'n', NL_NOTICES }, /* turn off to receive notices instead of privmsgs */
+ { 'A', NL_ALL_COMMANDS }, /* all commands sent */
+ { '\0', 0 }
+ };
void controldestroycmdext(void *ext);
void handlemessages(nick *target, int messagetype, void **args);
int controlstatus(void *sender, int cargc, char **cargv);
void controlconnect(void *arg);
int controlwhois(void *sender, int cargc, char **cargv);
+int controllistusers(void *sender, int cargc, char **cargv);
int controlchannel(void *sender, int cargc, char **cargv);
int relink(void *sender, int cargc, char **cargv);
int die(void *sender, int cargc, char **cargv);
void controlnoticeopers(flag_t permissionlevel, flag_t noticelevel, char *format, ...);
int controlcheckpermitted(flag_t level, nick *user);
void handlesignal(int hooknum, void *arg);
+void noperserv_oper_detection(int hooknum, void *arg);
+void noperserv_whois_handler(int hooknum, void *arg);
+void noperserv_whois_account_handler(int hooknum, void *arg);
+
+#define HOOK_CONTROL_WHOISREQUEST_AUTHNAME -1
+#define HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER -2
+
+static int init;
void _init() {
+ if(!noperserv_load_db())
+ return;
+
controlcmds=newcommandtree();
- controlreply=&controlmessage;
- controlwall=&controlnoticeopers;
- controlpermitted=&controlcheckpermitted;
controldestroyext=&controldestroycmdext;
registercontrolhelpcmd("status",NO_DEVELOPER,1,&controlstatus,"Usage: status ?level?\nDisplays status information, increasing level gives more verbose information.");
registercontrolhelpcmd("whois",NO_OPERED,1,&controlwhois,"Usage: whois <nickname|#numeric>\nDisplays lots of information about the specified nickname or numeric.");
+ registercontrolhelpcmd("listusers", NO_OPERED | NO_ACCOUNT, 2, &controllistusers, "Syntax: LISTUSERS\nLists all accounts.");
registercontrolhelpcmd("channel",NO_OPER,1,&controlchannel,"Usage: channel <#channel>\nDisplays channel information.");
registercontrolhelpcmd("relink",NO_DEVELOPER,1,&relink,"Usage: relink\nRelinks service to the network.");
registercontrolhelpcmd("die",NO_DEVELOPER,1,&die,"Usage: die <reason>\nTerminates the service.");
registerhook(HOOK_CORE_REHASH, &handlesignal);
registerhook(HOOK_CORE_SIGINT, &handlesignal);
+ registerhook(HOOK_NICK_MODEOPER, &noperserv_oper_detection);
+ registerhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
+
+ noperserv_ext = registerauthnameext("noperserv", 1);
+
scheduleoneshot(time(NULL)+1,&controlconnect,NULL);
+
+ init = 1;
}
void _fini() {
+ if (!init)
+ return;
+
deleteallschedules(&controlconnect);
if (mynick) {
deregisterlocaluser(mynick,"Leaving");
deregistercontrolcmd("status",&controlstatus);
deregistercontrolcmd("whois",&controlwhois);
+ deregistercontrolcmd("listusers", &controllistusers);
deregistercontrolcmd("channel",&controlchannel);
deregistercontrolcmd("relink",&relink);
deregistercontrolcmd("die",&die);
deregisterhook(HOOK_CORE_REHASH, &handlesignal);
deregisterhook(HOOK_CORE_SIGINT, &handlesignal);
+ deregisterhook(HOOK_NICK_MODEOPER, &noperserv_oper_detection);
+ deregisterhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
+
+ releaseauthnameext(noperserv_ext);
+
+ noperserv_cleanup_db();
}
void registercontrolhelpcmd(const char *name, int level, int maxparams, CommandHandler handler, char *helpstr) {
controlreply(hooknick,"%s",(char *)arg);
}
-int controlwhois(void *sender, int cargc, char **cargv) {
+static int controlwhois_plain(void *sender, int cargc, char **cargv) {
nick *target;
channel **channels;
char buf[BUFSIZE];
return CMD_OK;
}
+int controlwhois(void *sender, int cargc, char **cargv) {
+ authname *an;
+ no_autheduser *au;
+ nick *np = (nick *)sender;
+
+ if(cargc < 1)
+ return controlwhois_plain(sender, cargc, cargv);
+
+ if(cargv[0][0] != '#') {
+ if(cargv[0][0] == '*')
+ cargv[0][0] = '#';
+ return controlwhois_plain(sender, cargc, cargv);
+ }
+
+ an = findauthnamebyname(cargv[0] + 1);
+ if(!an) {
+ controlreply(np, "Account not registered.");
+ return CMD_OK;
+ }
+
+ au = noperserv_get_autheduser(an);
+ if(!au) {
+ controlreply(np, "User does not have a NOperserv account.");
+ return CMD_OK;
+ }
+
+ controlreply(np, "Account : %s", au->authname->name);
+
+ hooknick = np;
+
+ registerhook(HOOK_CONTROL_WHOISREPLY, &handlewhois);
+ noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
+ deregisterhook(HOOK_CONTROL_WHOISREPLY, &handlewhois);
+
+ controlreply(np, "Flags : %s", printflags(NOGetAuthLevel(au), no_userflags));
+
+ return CMD_OK;
+}
+
+void noperserv_whois_handler(int hooknum, void *arg) {
+ char message[100];
+ nick *np = (nick *)arg;
+ no_autheduser *au;
+ if(!np)
+ return;
+
+ if(IsAccount(np)) {
+ au = NOGetAuthedUser(np);
+ if(au) {
+ snprintf(message, sizeof(message), "Flags : %s", printflags(NOGetAuthLevel(au), no_userflags));
+ noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
+ } else {
+ snprintf(message, sizeof(message), "Flags : (user not known)");
+ noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHNAME, (void *)np->authname);
+ }
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ }
+}
+
+/* mmm, hacky */
+void noperserv_whois_account_handler(int hooknum, void *arg) {
+ int count = 0, found = 0;
+ char nickbuffer[(NICKLEN + 2) * NO_NICKS_PER_WHOIS_LINE - 1]; /* since we don't need space or comma for the first item we're fine NULL wise */
+ char accountspace[NICKLEN + 3]; /* space, comma, null */
+ char message[1024];
+ nick *np;
+
+ nickbuffer[0] = '\0';
+ if(hooknum == HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER) {
+ /* we can just read out the authed user linked list */
+ no_autheduser *au = (void *)arg;
+
+ if(au->authname->nicks)
+ found = 1;
+
+ for(np=au->authname->nicks;np;np=np->nextbyauthname) {
+ snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", np->nick);
+ strncat(nickbuffer, accountspace, sizeof(nickbuffer));
+ nickbuffer[sizeof(nickbuffer) - 1] = '\0';
+
+ if(count >= NO_NICKS_PER_WHOIS_LINE) {
+ snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ nickbuffer[0] = '\0';
+ count = 0;
+ }
+ }
+ } else {
+ /* inefficient way */
+ char *authname = (char *)arg;
+ int i = 0;
+ nick *sp;
+
+ for(;i<NICKHASHSIZE;i++)
+ for(sp=nicktable[i];sp;sp=sp->next)
+ if(IsAccount(sp) && !ircd_strcmp(sp->authname, authname)) {
+ found = 1;
+
+ snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", sp->nick);
+ strncat(nickbuffer, accountspace, sizeof(nickbuffer));
+ nickbuffer[sizeof(nickbuffer) - 1] = '\0';
+
+ if(count >= NO_NICKS_PER_WHOIS_LINE) {
+ snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ nickbuffer[0] = '\0';
+ count = 0;
+ }
+ }
+ }
+
+ if(!found) {
+ snprintf(message, sizeof(message), "Authed : (no nicks authed)");
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ } else if(nickbuffer[0]) {
+ snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
+ triggerhook(HOOK_CONTROL_WHOISREPLY, message);
+ }
+}
+
+int controllistusers(void *sender, int cargc, char **cargv) {
+ nick *np = (nick *)sender;
+ int i, count = 0;
+ authname *anp;
+ no_autheduser *au;
+
+ hooknick = np;
+
+ registerhook(HOOK_CONTROL_WHOISREPLY, &handlewhois);
+
+ for (i=0;i<AUTHNAMEHASHSIZE;i++) {
+ for (anp=authnametable[i];anp;anp=anp->next) {
+ au = noperserv_get_autheduser(anp);
+ if(!au)
+ continue;
+
+ if (count > 0)
+ controlreply(np, "---");
+
+ controlreply(np, "Account : %s", au->authname->name);
+ noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
+ controlreply(np, "Flags : %s", printflags(NOGetAuthLevel(au), no_userflags));
+
+ count++;
+ }
+ }
+
+ deregisterhook(HOOK_CONTROL_WHOISREPLY, &handlewhois);
+
+ controlreply(np, "--- Found %d users.", count);
+
+ return CMD_OK;
+}
+
int controlinsmod(void *sender, int cargc, char **cargv) {
if (cargc<1)
return CMD_USAGE;
}
int controlshowcommands(void *sender, int cargc, char **cargv) {
- nick *np=(nick *)sender;
+ nick *np = (nick *)sender;
Command *cmdlist[100];
- int i,n;
-
- n=getcommandlist(controlcmds,cmdlist,100);
-
- controlreply(np,"The following commands are registered at present:");
-
- for(i=0;i<n;i++) {
- controlreply(np,"%s",cmdlist[i]->command->content);
- }
+ int i, n;
+
+ n = getcommandlist(controlcmds, cmdlist, 100);
+
+ controlreply(np, "The following commands are registered at present:");
- controlreply(np,"End of list.");
+ for(i=0;i<n;i++)
+ if(noperserv_policy_command_permitted(cmdlist[i]->level, np))
+ controlreply(np, " %-25s %s", cmdlist[i]->command->content, printflags(cmdlist[i]->level, no_commandflags));
+
+ controlreply(np, "End of list.");
return CMD_OK;
}
case LU_PRIVMSG:
case LU_SECUREMSG:
/* If it's a message, first arg is nick and second is message */
- sender=(nick *)args[0];
+ sender = (nick *)args[0];
- Error("control",ERR_INFO,"From: %s!%s@%s: %s",sender->nick,sender->ident,sender->host->name->content, (char *)args[1]);
+ controlwall(NO_DEVELOPER, NL_ALL_COMMANDS, "From: %s!%s@%s%s%s: %s", sender->nick, sender->ident, sender->host->name->content, IsAccount(sender)?"/":"", IsAccount(sender)?sender->authname:"", (char *)args[1]);
/* Split the line into params */
- cargc=splitline((char *)args[1],cargv,50,0);
+ cargc = splitline((char *)args[1], cargv, 50, 0);
- if (!cargc) {
- /* Blank line */
+ if(!cargc) /* Blank line */
return;
- }
- cmd=findcommandintree(controlcmds,cargv[0],1);
- if (cmd==NULL) {
- controlreply(sender,"Unknown command.");
- return;
- }
-
- if (cmd->level>0 && !IsOper(sender)) {
- controlreply(sender,"You need to be opered to use this command.");
+ cmd = findcommandintree(controlcmds,cargv[0],1);
+ if(!cmd || !noperserv_policy_command_permitted(cmd->level, sender)) {
+ controlreply(sender, "Unknown command or access denied.");
return;
}
- /* If we were doing "authed user tracking" here we'd put a check in for authlevel */
-
/* Check the maxargs */
if (cmd->maxparams<(cargc-1)) {
/* We need to do some rejoining */
if((cmd->handler)((void *)sender,cargc-1,&(cargv[1])) == CMD_USAGE)
controlhelp(sender, cmd);
+
break;
case LU_KILLED:
scheduleoneshot(time(NULL)+1,&controlconnect,NULL);
mynick=NULL;
triggerhook(HOOK_CONTROL_REGISTERED, NULL);
+
break;
default:
sendnoticetouser(mynick,target,"%s",buf);
}
+void controlreply(nick *np, char *format, ...) {
+ char buf[512];
+ va_list va;
+ no_autheduser *au = NOGetAuthedUser(np);
+
+ va_start(va, format);
+ vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+
+ if(au && !(NOGetNoticeLevel(au) & NL_NOTICES)) {
+ controlmessage(np, "%s", buf);
+ } else {
+ controlnotice(np, "%s", buf);
+ }
+}
+
+void controlwall(flag_t permissionlevel, flag_t noticelevel, char *format, ...) {
+ char buf[512];
+ va_list va;
+ char *flags = printflags(noticelevel, no_noticeflags) + 1;
+ int i;
+ authname *anp;
+ no_autheduser *au;
+ nick *np;
+
+ va_start(va, format);
+ vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+
+ Error("noperserv", ERR_INFO, "$%s$ %s", flags, buf);
+
+ for (i=0;i<AUTHNAMEHASHSIZE;i++) {
+ for (anp=authnametable[i];anp;anp=anp->next) {
+ au = noperserv_get_autheduser(anp);
+ if(!au)
+ continue;
+ if((NOGetNoticeLevel(au) & noticelevel) && !(NOGetAuthLevel(au) & __NO_RELAY)) {
+ for(np=anp->nicks;np;np=np->nextbyauthname)
+ if(noperserv_policy_command_permitted(permissionlevel, np))
+ controlreply(np, "$%s$ %s", flags, buf);
+ }
+ }
+ }
+}
+
void controlspecialrmmod(void *arg) {
struct specialsched *a = (struct specialsched *)arg;
sstring *froo = a->modulename;
Command *cmd;
nick *np = (nick *)sender;
- if (cargc<1)
+ if(cargc < 1)
return CMD_USAGE;
- cmd=findcommandintree(controlcmds,cargv[0],1);
- if (cmd==NULL) {
- controlreply(np,"Unknown command.");
+ cmd = findcommandintree(controlcmds, cargv[0], 1);
+ if(!cmd || !noperserv_policy_command_permitted(cmd->level, np)) {
+ controlreply(np, "Unknown command or access denied.");
return CMD_ERROR;
}
controlwall(NO_OPER, noticelevel, "%s", broadcast);
}
-int controlcheckpermitted(flag_t level, nick *user) {
- return 1;
+int controlpermitted(flag_t level, nick *user) {
+ return noperserv_policy_command_permitted(level, user);
}
void handlesignal(int hooknum, void *arg) {
return buf;
}
+void noperserv_oper_detection(int hooknum, void *arg) {
+ nick *np = (nick *)arg;
+
+ if(np->umodes & UMODE_OPER) {
+ if(np->opername && strcmp(np->opername->content, "-")) {
+ controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just OPERed as %s", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"", np->opername->content);
+ } else {
+ controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just OPERed", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"");
+ }
+ } else {
+ controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just DEOPERed", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"");
+ }
+}
+
#ifndef __CONTROL_H
#define __CONTROL_H
+#include "control_db.h"
+#include "../lib/flags.h"
#include "../parser/parser.h"
#include "../nick/nick.h"
#include "../channel/channel.h"
#define registercontrolcmd(a, b, c, d) registercontrolhelpcmd(a, b, c, d, NULL)
-typedef void (*ControlMsg)(nick *, char *, ... );
-typedef void (*ControlWall)(flag_t, flag_t, char *, ...);
-typedef int (*ControlPermitted)(flag_t, nick *);
-
-extern ControlMsg controlreply;
-extern ControlWall controlwall;
-extern ControlPermitted controlpermitted;
+void controlreply(nick *, char *, ...);
+void controlwall(flag_t, flag_t, char *, ...);
+int controlpermitted(flag_t, nick *);
extern nick *mynick;
#define NL_ALL_COMMANDS 0x2000 /* every single command sent */
#define NL_GLINES_AUTO 0x4000 /* automated gline messages */
+extern int noperserv_ext;
+
+extern const flag no_userflags[];
+extern const flag no_noticeflags[];
+extern const flag no_commandflags[];
+
+#define NO_NICKS_PER_WHOIS_LINE 3
+
+#define NOGetAuthedUser(user) (no_autheduser *)(user->auth ? user->auth->exts[noperserv_ext] : NULL)
+#define NOGetAuthLevel(user) user->authlevel
+#define NOGetNoticeLevel(user) user->noticelevel
+#define NOMax(a, b) (a>b?a:b)
+#define NOMin(a, b) (a<b?b:a)
+
#endif
return CMD_USAGE;
tree = NSASTNode(match_parse, NSASTNode(hostmask_parse), NSASTLiteral(cargv[0]));
- return ast_nicksearch(&tree, controlreply, sender, controlnswall, printnick, NULL, NULL, 500);
+ return ast_nicksearch(&tree, controlreply, sender, controlnswall, printnick, NULL, NULL, 500, NULL);
}
int controlspewchan(void *sender, int cargc, char **cargv) {
return CMD_USAGE;
tree = NSASTNode(match_parse, NSASTNode(name_parse), NSASTLiteral(cargv[0]));
- return ast_chansearch(&tree, controlreply, sender, controlnswall, printchannel, NULL, NULL, 500);
+ return ast_chansearch(&tree, controlreply, sender, controlnswall, printchannel, NULL, NULL, 500, NULL);
}
int controlcompare(void *sender, int cargc, char **cargv) {
}
tree = NSASTManualNode(and_parse, cargc, nodes);
- return (execfn)(&tree, controlreply, sender, controlnswall, displayfn, NULL, NULL, 500);
+ return (execfn)(&tree, controlreply, sender, controlnswall, displayfn, NULL, NULL, 500, NULL);
}
int controlbroadcast(void *sender, int cargc, char **cargv) {
snprintf(message, sizeof(message), "(oBroadcast) %s", cargv[0]);
tree = NSASTNode(and_parse, NSASTNode(modes_parse, NSASTLiteral("+o")), NSASTNode(notice_parse, NSASTLiteral(message)));
- if((ret=ast_nicksearch(&tree, controlreply, sender, controlnswall, NULL, NULL, NULL, -1)) == CMD_OK) {
+ if((ret=ast_nicksearch(&tree, controlreply, sender, controlnswall, NULL, NULL, NULL, -1, NULL)) == CMD_OK) {
controlwall(NO_OPER, NL_BROADCASTS, "%s/%s sent an obroadcast: %s", np->nick, np->authname, cargv[0]);
controlreply(np, "Message obroadcasted.");
} else {
snprintf(message, sizeof(message), "(cBroadcast) %s", cargv[1]);
tree = NSASTNode(and_parse, NSASTNode(country_parse, NSASTLiteral(cargv[0])), NSASTNode(notice_parse, NSASTLiteral(message)));
- if((ret=ast_nicksearch(&tree, controlreply, sender, controlnswall, NULL, NULL, NULL, -1)) == CMD_OK) {
+ if((ret=ast_nicksearch(&tree, controlreply, sender, controlnswall, NULL, NULL, NULL, -1, NULL)) == CMD_OK) {
controlwall(NO_OPER, NL_BROADCASTS, "%s/%s sent a cbroadcast %s: %s", np->nick, np->authname, cargv[0], cargv[1]);
controlreply(np, "Message cbroadcasted.");
} else {
--- /dev/null
+/*
+ * NOperserv v0.01
+ *
+ * A replacement for Germania's ageing Operservice2
+ * DB functions
+ *
+ * Copyright (C) 2005 Chris Porter.
+ */
+
+#include "../nick/nick.h"
+#include "../core/error.h"
+#include "../lib/irc_string.h"
+#include "../core/schedule.h"
+#include "../dbapi2/dbapi2.h"
+
+#include "control.h"
+
+#include <stdlib.h>
+
+int db_loaded = 0;
+unsigned long loadedusers = 0;
+
+void noperserv_create_tables(void);
+
+void noperserv_free_user(no_autheduser *au);
+void noperserv_load_users(const DBAPIResult *res, void *arg);
+
+static DBAPIConn *nodb;
+
+int noperserv_load_db(void) {
+ if(!nodb) {
+ nodb = dbapi2open(DBAPI2_DEFAULT, "noperserv");
+ if(!nodb) {
+ Error("noperserv", ERR_STOP, "Could not connect to database.");
+ return 0;
+ }
+ }
+
+ db_loaded = 1;
+
+ noperserv_create_tables();
+
+ nodb->query(nodb, noperserv_load_users, NULL,
+ "SELECT userid, authname, flags, noticelevel FROM ?", "T", "users");
+
+ return 1;
+}
+
+void noperserv_load_users(const DBAPIResult *res, void *arg) {
+ no_autheduser *nu;
+
+ if(!res)
+ Error("control", ERR_STOP, "Failed to load noperserv database. Your database might be corrupted or the schema is incompatible.");
+
+ if(!res->success) {
+ Error("noperserv", ERR_ERROR, "Error loading user list.");
+ res->clear(res);
+ return;
+ }
+
+ while(res->next(res)) {
+ nu = noperserv_new_autheduser(strtoul(res->get(res, 0), NULL, 10), res->get(res, 1));
+ if(!nu)
+ continue;
+
+ nu->authlevel = strtoul(res->get(res, 2), NULL, 10);
+ nu->noticelevel = strtoul(res->get(res, 3), NULL, 10);
+ nu->newuser = 0;
+ }
+
+ Error("noperserv", ERR_INFO, "Loaded %lu users", loadedusers);
+
+ res->clear(res);
+}
+
+void noperserv_create_tables(void) {
+ nodb->createtable(nodb, NULL, NULL,
+ "CREATE TABLE ? ("
+ "userid INT NOT NULL,"
+ "authname VARCHAR(?) NOT NULL,"
+ "flags INT NOT NULL,"
+ "noticelevel INT NOT NULL,"
+ "PRIMARY KEY (userid))", "Td", "users", ACCOUNTLEN);
+}
+
+void noperserv_cleanup_db(void) {
+ int i;
+ authname *anp, *next;
+ no_autheduser *au;
+
+ for (i=0;i<AUTHNAMEHASHSIZE;i++) {
+ for (anp=authnametable[i];anp;) {
+ next = anp->next;
+
+ au = anp->exts[noperserv_ext];
+ if(au)
+ noperserv_free_user(au);
+
+ anp = next;
+ }
+ }
+
+ nodb->close(nodb);
+ nodb = NULL;
+}
+
+no_autheduser *noperserv_new_autheduser(unsigned long userid, char *name) {
+ authname *anp;
+ no_autheduser *au;
+
+ anp = findorcreateauthname(userid, name);
+ if(!anp)
+ return NULL;
+
+ au = malloc(sizeof(no_autheduser));
+ if(!au)
+ return NULL;
+
+ au->authname = anp;
+
+ loadedusers++;
+ au->newuser = 1;
+
+ anp->exts[noperserv_ext] = au;
+
+ return au;
+}
+
+void noperserv_delete_autheduser(no_autheduser *au) {
+ if(!au->newuser)
+ nodb->squery(nodb, "DELETE FROM ? WHERE userid = ?", "Tu", "users", au->authname->userid);
+
+ noperserv_free_user(au);
+}
+
+void noperserv_update_autheduser(no_autheduser *au) {
+ if(au->newuser) {
+ nodb->squery(nodb, "INSERT INTO ? (userid, authname, flags, noticelevel) VALUES (?,?,?,?)", "Tusuu", "users", au->authname->userid, au->authname->name, NOGetAuthLevel(au), NOGetNoticeLevel(au));
+ au->newuser = 0;
+ } else {
+ nodb->squery(nodb, "UPDATE ? SET flags = ?, noticelevel = ? WHERE userid = ?", "Tuuu", "users", NOGetAuthLevel(au), NOGetNoticeLevel(au), au->authname->userid);
+ }
+}
+
+void noperserv_free_user(no_autheduser *au) {
+ authname *anp = au->authname;
+ anp->exts[noperserv_ext] = NULL;
+ releaseauthname(anp);
+ free(au);
+
+ loadedusers--;
+}
+
+no_autheduser *noperserv_get_autheduser(authname *anp) {
+ if (!anp)
+ return NULL;
+
+ return anp->exts[noperserv_ext];
+}
+
+unsigned long noperserv_get_autheduser_count(void) {
+ return loadedusers;
+}
+
#ifndef __NOPERSERV_STRUCTS_H
#define __NOPERSERV_STRUCTS_H
-typedef unsigned long no_tableid;
+#include "../authext/authext.h"
-typedef struct no_nicklist {
- nick *nick;
- struct no_nicklist *next;
-} no_nicklist;
+typedef unsigned long no_tableid;
typedef struct no_autheduser {
unsigned newuser: 1;
- sstring *authname;
+ authname *authname;
flag_t authlevel;
flag_t noticelevel;
- no_tableid id;
- struct no_autheduser *next;
- no_nicklist *nick;
} no_autheduser;
int noperserv_load_db(void);
void noperserv_cleanup_db(void);
-extern no_autheduser *authedusers;
-
void noperserv_delete_autheduser(no_autheduser *au);
-no_autheduser *noperserv_new_autheduser(char *authname);
-no_autheduser *noperserv_get_autheduser(char *authname);
+no_autheduser *noperserv_new_autheduser(unsigned long userid, char *ame);
+no_autheduser *noperserv_get_autheduser(authname *an);
void noperserv_update_autheduser(no_autheduser *au);
-void noperserv_add_to_autheduser(nick *np, no_autheduser *au);
unsigned long noperserv_get_autheduser_count(void);
-unsigned long noperserv_next_autheduser_id(void);
#endif
#include "../lib/strlfunc.h"
#include "../lib/version.h"
#include "../authext/authext.h"
-#include "noperserv.h"
-#include "noperserv_db.h"
-#include "noperserv_hooks.h"
-#include "noperserv_policy.h"
+#include "../control/control.h"
+#include "../control/control_db.h"
+#include "../control/control_policy.h"
#include <stdio.h>
#include <string.h>
#define NO_FOUND_NICKNAME 1
#define NO_FOUND_AUTHNAME 2
-int noperserv_ext;
-
-const flag no_commandflags[] = {
- { 'o', __NO_OPER },
- { 't', __NO_TRUST },
- { 's', __NO_STAFF },
- { 'S', __NO_SEC },
- { 'd', __NO_DEVELOPER },
- { 'L', __NO_LEGACY },
- { 'O', __NO_OPERED },
- { 'r', __NO_AUTHED },
- { 'R', __NO_ACCOUNT },
- { 'Y', __NO_RELAY },
- { '\0', 0 }
- };
-
-const flag no_userflags[] = {
- { 'o', __NO_OPER },
- { 't', __NO_TRUST },
- { 's', __NO_STAFF },
- { 'S', __NO_SEC },
- { 'd', __NO_DEVELOPER },
- { 'Y', __NO_RELAY },
- { '\0', 0 }
- };
-
-const flag no_noticeflags[] = {
- { 'm', NL_MANAGEMENT }, /* hello, password, userflags, noticeflags */
- { 't', NL_TRUSTS }, /* trust stuff... */
- { 'k', NL_KICKKILLS }, /* KICK/KILL commands */
- { 'I', NL_MISC }, /* misc commands */
- { 'g', NL_GLINES }, /* GLINE commands */
- { 'G', NL_GLINES_AUTO }, /* automated gline messages */
- { 'h', NL_HITS }, /* Where a gline or kill is set automatically by the bot */
- { 'c', NL_CLONING }, /* Clone detection */
- { 'C', NL_CLEARCHAN }, /* When someone clearchans */
- { 'f', NL_FAKEUSERS }, /* Fakeuser addition */
- { 'b', NL_BROADCASTS }, /* Broadcast/mbroadcast/sbroadcast */
- { 'o', NL_OPERATIONS }, /* insmod/rmmod/etc */
- { 'O', NL_OPERING }, /* when someone opers */
- { 'n', NL_NOTICES }, /* turn off to receive notices instead of privmsgs */
- { 'A', NL_ALL_COMMANDS }, /* all commands sent */
- { '\0', 0 }
- };
-
-int noperserv_hello(void *sender, int cargc, char **cargv);
-int noperserv_noticeflags(void *sender, int cargc, char **cargv);
-int noperserv_userflags(void *sender, int cargc, char **cargv);
-int noperserv_deluser(void *sender, int cargc, char **cargv);
-void noperserv_oper_detection(int hooknum, void *arg);
-void noperserv_reply(nick *np, char *format, ...) __attribute__ ((format (printf, 2, 3)));
-
-int init = 0;
-
-void _init() {
- if(!noperserv_load_db())
- return;
-
- noperserv_ext = registernickext("noperserv");
-
- noperserv_setup_hooks();
-
- registercontrolhelpcmd("hello", NO_OPERED | NO_AUTHED, 1, &noperserv_hello, "Syntax: HELLO ?nickname|#authname?\nCreates an account on the service for the specified nick, or if one isn't supplied, your nickname.");
- registercontrolhelpcmd("userflags", NO_ACCOUNT, 2, &noperserv_userflags,
- "Syntax: USERFLAGS <nickname|#authname> ?modifications?\n"
- " Views and modifies user permissions.\n"
- " If no nickname or authname is supplied, you are substituted for it.\n"
- " If no flags are supplied, flags are just displayed instead of modified."
- " Flags:\n"
- " +o: Operator\n"
- " +s: Staff member\n"
- " +S: Security team member\n"
- " +d: NOperserv developer\n"
- " +t: Trust queue worker\n"
- " +Y: Relay\n"
- " Additional flags may show up in SHOWCOMMANDS but are not userflags as such:\n"
- " +r: Authed user\n"
- " +R: Registered NOperserv user\n"
- " +O: Must be /OPER'ed\n"
- " +L: Legacy command\n"
- );
- registercontrolhelpcmd("noticeflags", NO_ACCOUNT, 1, &noperserv_noticeflags,
- "Syntax: NOTICEFLAGS ?(nickname|#authname)|flags?\n"
- " This command can view and modify your own notice flags, and view that of other users.\n"
- " Flags:\n"
- " +m: Management (hello, password, userflags, noticeflags)\n"
- " +t: Trusts\n"
- " +k: KICK/KILL commands\n"
- " +g: GLINE commands\n"
- " +G: automated gline messages\n"
- " +h: Shows when glines are set by code (hits)\n"
- " +c: Clone information\n"
- " +C: CLEARCHAN command\n"
- " +f: FAKEUSER commands\n"
- " +b: BROADCAST commands\n"
- " +o: Operation commands, such as insmod, rmmod, die, etc\n"
- " +O: /OPER\n"
- " +I: Misc commands (resync, etc)\n"
- " +n: Sends notices instead of privmsgs\n"
- " +A: Every single command sent to the service (spammy)\n"
- );
-
- registercontrolhelpcmd("deluser", NO_OPERED | NO_ACCOUNT, 2, &noperserv_deluser, "Syntax: DELUSER <nickname|#authname>\nDeletes the specified user.");
- registerhook(HOOK_NICK_MODEOPER, &noperserv_oper_detection);
-
- init = 1;
-}
-
-#ifdef BROKEN_DLCLOSE
-void __fini() {
-#else
-void _fini() {
-#endif
- if(!init)
- return;
-
- deregisterhook(HOOK_NICK_MODEOPER, &noperserv_oper_detection);
-
- deregistercontrolcmd("noticeflags", &noperserv_noticeflags);
- deregistercontrolcmd("userflags", &noperserv_userflags);
- deregistercontrolcmd("noticeflags", &noperserv_noticeflags);
- deregistercontrolcmd("hello", &noperserv_hello);
- deregistercontrolcmd("deluser", &noperserv_deluser);
-
- noperserv_cleanup_hooks();
-
- noperserv_cleanup_db();
-
- releasenickext(noperserv_ext);
-}
-
/* @test */
-int noperserv_hello(void *sender, int cargc, char **cargv) {
- char *newaccount = NULL;
+static int noperserv_hello(void *sender, int cargc, char **cargv) {
+ authname *newaccount = NULL;
no_autheduser *au;
- int i;
nick *np = (nick *)sender, *np2, *target = NULL;
if(cargc == 0) {
- newaccount = np->authname;
+ newaccount = np->auth;
} else {
if(cargv[0][0] == '#') {
authname *a = getauthbyname(cargv[0] + 1);
controlreply(np, "Cannot find anyone with that authname on the network.");
return CMD_ERROR;
}
- newaccount = a->name;
+ newaccount = a;
} else {
target = getnickbynick(cargv[0]);
if(!target) {
controlreply(np, "Supplied nickname is not on the network.");
return CMD_ERROR;
}
- if(!IsAccount(target)) {
- controlreply(np, "Supplied user is not authed with the network.");
- return CMD_ERROR;
- }
- newaccount = target->authname;
+ newaccount = target->auth;
}
}
+ if(!newaccount) {
+ controlreply(np, "Supplied user is not authed with the network.");
+ return CMD_ERROR;
+ }
au = noperserv_get_autheduser(newaccount);
if(au) {
controlreply(np, "Authname already registered.");
return CMD_ERROR;
}
- au = noperserv_new_autheduser(newaccount);
+ au = noperserv_new_autheduser(newaccount->userid, newaccount->name);
if(!au) {
controlreply(np, "Memory allocation error.");
return CMD_ERROR;
au->noticelevel = NO_DEFAULT_NOTICELEVEL;
}
- au->id = noperserv_next_autheduser_id();
noperserv_update_autheduser(au);
- for(i=0;i<NICKHASHSIZE;i++)
- for(np2=nicktable[i];np2;np2=np2->next)
- if(IsAccount(np2) && !ircd_strcmp(newaccount, np2->authname)) {
- noperserv_add_to_autheduser(np2, au);
- controlreply(np2, "An account has been created for you (auth %s).", au->authname->content);
- if(NOGetAuthLevel(au))
- controlreply(np2, "User flags: %s", printflags(NOGetAuthLevel(au), no_userflags));
- controlreply(np2, "Notice flags: %s", printflags(NOGetNoticeLevel(au), no_noticeflags));
- }
+ for(np2=newaccount->nicks;np2;np2=np2->nextbyauthname) {
+ controlreply(np2, "An account has been created for you (auth %s).", au->authname->name);
+ if(NOGetAuthLevel(au))
+ controlreply(np2, "User flags: %s", printflags(NOGetAuthLevel(au), no_userflags));
+ controlreply(np2, "Notice flags: %s", printflags(NOGetNoticeLevel(au), no_noticeflags));
+ }
- if(ircd_strcmp(np->authname, newaccount)) { /* send a message to the person who HELLO'ed if we haven't already been told */
- controlreply(np, "Account created for auth %s.", au->authname->content);
+ if(np->auth==newaccount) { /* send a message to the person who HELLO'ed if we haven't already been told */
+ controlreply(np, "Account created for auth %s.", au->authname->name);
if(NOGetAuthLevel(au))
controlreply(np, "User flags: %s", printflags(NOGetAuthLevel(au), no_userflags));
controlreply(np, "Notice flags: %s", printflags(NOGetNoticeLevel(au), no_noticeflags));
controlreply(np, "Instructions sent to all authed users.");
- } else if(au->nick && au->nick->next) { /* if we have already been told, tell the user it was sent to more than themselves */
+ } else if(newaccount->nicks && newaccount->nicks->next) { /* if we have already been told, tell the user it was sent to more than themselves */
controlreply(np, "Instructions sent to all authed users.");
}
- controlwall(NO_OPERED, NL_MANAGEMENT, "%s/%s just HELLO'ed: %s", np->nick, np->authname, au->authname->content);
+ controlwall(NO_OPERED, NL_MANAGEMENT, "%s/%s just HELLO'ed: %s", np->nick, np->authname, au->authname->name);
return CMD_OK;
}
-no_autheduser *noperserv_autheduser_from_command(nick *np, char *command, int *typefound, char **returned) {
+static no_autheduser *noperserv_autheduser_from_command(nick *np, char *command, int *typefound, char **returned) {
no_autheduser *au;
+ authname *anp;
if(command[0] == '#') {
- au = noperserv_get_autheduser(command + 1);
+ anp = findauthnamebyname(command + 1);
+ if(!anp) {
+ controlreply(np, "Authname not found.");
+ return NULL;
+ }
+ au = noperserv_get_autheduser(anp);
if(!au) {
controlreply(np, "Authname not found.");
} else {
*typefound = NO_FOUND_AUTHNAME;
- *returned = au->authname->content;
+ *returned = au->authname->name;
return au;
}
} else {
nick *np2 = getnickbynick(command);
if(!np2) {
controlreply(np, "Nickname not on the network.");
- return CMD_OK;
+ return NULL;
}
if(!IsAccount(np2)) {
controlreply(np, "User is not authed with the network.");
- return CMD_OK;
+ return NULL;
}
au = NOGetAuthedUser(np2);
if(!au) {
return NULL;
}
-int noperserv_noticeflags(void *sender, int cargc, char **cargv) {
- nick *np = (nick *)sender;
+static int noperserv_noticeflags(void *sender, int cargc, char **cargv) {
+ nick *np2, *np = (nick *)sender;
no_autheduser *au;
if(cargc == 1) {
controlreply(np, "No changes made to existing flags.");
} else {
char ourflags[FLAGBUFLEN], ournoticeflags[FLAGBUFLEN], diff[FLAGBUFLEN * 2 + 1], finalflags[FLAGBUFLEN];
- no_nicklist *nl = au->nick;
noperserv_update_autheduser(au);
controlreply(np, "Flag alterations complete.");
controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) successfully used NOTICEFLAGS (%s): %s", np->nick, np->authname, ourflags, ournoticeflags, diff);
strlcpy(finalflags, printflags(NOGetNoticeLevel(au), no_noticeflags), sizeof(finalflags));
- for(;nl;nl=nl->next)
- if(nl->nick != np) {
- controlreply(nl->nick, "!!! %s just used NOTICEFLAGS (%s): %s", np->nick, ournoticeflags, diff);
- controlreply(nl->nick, "Your notice flags are %s", finalflags);
+ for(np2=au->authname->nicks;np2;np2=np2->nextbyauthname)
+ if(np2 != np) {
+ controlreply(np2, "!!! %s just used NOTICEFLAGS (%s): %s", np->nick, ournoticeflags, diff);
+ controlreply(np2, "Your notice flags are %s", finalflags);
}
}
}
}
/* @test */
-int noperserv_deluser(void *sender, int cargc, char **cargv) {
- nick *np = (nick *)sender;
+static int noperserv_deluser(void *sender, int cargc, char **cargv) {
+ nick *np2, *np = (nick *)sender;
no_autheduser *target /* target user */, *au = NOGetAuthedUser(np); /* user executing command */
char *userreturned = NULL; /* nickname or authname of the target, pulled from the db */
int typefound; /* whether it was an authname or a username */
- no_nicklist *nl;
char targetflags[FLAGBUFLEN], ourflags[FLAGBUFLEN], deleteduser[NOMax(ACCOUNTLEN, NICKLEN) + 1];
if(cargc != 1)
to modify, if we have no flags we won't be able to delete ourselves */
if((target != au) && !noperserv_policy_permitted_modifications(au, target)) {
controlreply(np, "Deletion denied.");
- controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) attempted to DELUSER %s (%s)", np->nick, np->authname, ourflags, target->authname->content, targetflags);
+ controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) attempted to DELUSER %s (%s)", np->nick, np->authname, ourflags, target->authname->name, targetflags);
return CMD_ERROR;
}
- for(nl=target->nick;nl;nl=nl->next)
- if(nl->nick != np)
- controlreply(nl->nick, "!!! %s/%s (%s) just DELUSERed you.", np->nick, np->authname, ourflags);
+ for(np2=target->authname->nicks;np2;np2=np2->nextbyauthname)
+ if(np2 != np)
+ controlreply(np2, "!!! %s/%s (%s) just DELUSERed you.", np->nick, np->authname, ourflags);
noperserv_delete_autheduser(target);
- controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) successfully used DELUSER on %s (%s)", np->nick, np->authname, ourflags, target->authname->content, targetflags);
+ controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) successfully used DELUSER on %s (%s)", np->nick, np->authname, ourflags, deleteduser, targetflags);
if(target == au) {
controlreply(np, "You have been deleted.");
/* @test */
/* this command needs LOTS of checking */
-int noperserv_userflags(void *sender, int cargc, char **cargv) {
- nick *np = (nick *)sender;
+static int noperserv_userflags(void *sender, int cargc, char **cargv) {
+ nick *np2, *np = (nick *)sender;
no_autheduser *au = NOGetAuthedUser(np), *target = NULL;
char *flags = NULL, *nicktarget = NULL;
int typefound;
strlcpy(targetflags, printflags(fwas, no_userflags), sizeof(targetflags));
strlcpy(ourflags, printflags(fours, no_userflags), sizeof(ourflags));
- controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) attempted to use USERFLAGS on %s (%s): %s", np->nick, np->authname, ourflags, target->authname->content, targetflags, printflagdiff(fwas, fnow, no_userflags));
+ controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) attempted to use USERFLAGS on %s (%s): %s", np->nick, np->authname, ourflags, target->authname->name, targetflags, printflagdiff(fwas, fnow, no_userflags));
return CMD_ERROR;
}
} else if(ret == REJECT_NONE) {
controlreply(np, "No changes made to existing flags.");
} else {
char targetflags[FLAGBUFLEN], ourflags[FLAGBUFLEN], finalflags[FLAGBUFLEN];
- no_nicklist *nl = target->nick;
noperserv_policy_update_noticeflags(fwas, target);
noperserv_update_autheduser(target);
strlcpy(targetflags, printflags(fwas, no_userflags), sizeof(targetflags));
strlcpy(ourflags, printflags(fours, no_userflags), sizeof(ourflags));
- controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) successfully used USERFLAGS on %s (%s): %s", np->nick, np->authname, ourflags, target->authname->content, targetflags, printflagdiff(fwas, NOGetAuthLevel(target), no_userflags));
+ controlwall(NO_OPER, NL_MANAGEMENT, "%s/%s (%s) successfully used USERFLAGS on %s (%s): %s", np->nick, np->authname, ourflags, target->authname->name, targetflags, printflagdiff(fwas, NOGetAuthLevel(target), no_userflags));
strlcpy(finalflags, printflags(NOGetAuthLevel(target), no_userflags), sizeof(finalflags));
- for(;nl;nl=nl->next)
- if(nl->nick != np) {
- controlreply(nl->nick, "!!! %s/%s (%s) just used USERFLAGS on you (%s): %s", np->nick, np->authname, ourflags, targetflags, printflagdiff(fwas, NOGetAuthLevel(target), no_userflags));
- controlreply(nl->nick, "Your user flags are now: %s", finalflags);
- controlreply(nl->nick, "Your notice flags are now: %s", printflags(target->noticelevel, no_noticeflags));
+ for(np2=target->authname->nicks;np2;np2=np2->nextbyauthname)
+ if(np2 != np) {
+ controlreply(np2, "!!! %s/%s (%s) just used USERFLAGS on you (%s): %s", np->nick, np->authname, ourflags, targetflags, printflagdiff(fwas, NOGetAuthLevel(target), no_userflags));
+ controlreply(np2, "Your user flags are now: %s", finalflags);
+ controlreply(np2, "Your notice flags are now: %s", printflags(target->noticelevel, no_noticeflags));
}
}
}
return CMD_OK;
}
-void noperserv_oper_detection(int hooknum, void *arg) {
- nick *np = (nick *)arg;
+void _init() {
+ registercontrolhelpcmd("hello", NO_OPERED | NO_AUTHED, 1, &noperserv_hello, "Syntax: HELLO ?nickname|#authname?\nCreates an account on the service for the specified nick, or if one isn't supplied, your nickname.");
+ registercontrolhelpcmd("userflags", NO_ACCOUNT, 2, &noperserv_userflags,
+ "Syntax: USERFLAGS <nickname|#authname> ?modifications?\n"
+ " Views and modifies user permissions.\n"
+ " If no nickname or authname is supplied, you are substituted for it.\n"
+ " If no flags are supplied, flags are just displayed instead of modified."
+ " Flags:\n"
+ " +o: Operator\n"
+ " +s: Staff member\n"
+ " +S: Security team member\n"
+ " +d: NOperserv developer\n"
+ " +t: Trust queue worker\n"
+ " +Y: Relay\n"
+ " Additional flags may show up in SHOWCOMMANDS but are not userflags as such:\n"
+ " +r: Authed user\n"
+ " +R: Registered NOperserv user\n"
+ " +O: Must be /OPER'ed\n"
+ " +L: Legacy command\n"
+ );
+ registercontrolhelpcmd("noticeflags", NO_ACCOUNT, 1, &noperserv_noticeflags,
+ "Syntax: NOTICEFLAGS ?(nickname|#authname)|flags?\n"
+ " This command can view and modify your own notice flags, and view that of other users.\n"
+ " Flags:\n"
+ " +m: Management (hello, password, userflags, noticeflags)\n"
+ " +t: Trusts\n"
+ " +k: KICK/KILL commands\n"
+ " +g: GLINE commands\n"
+ " +G: automated gline messages\n"
+ " +h: Shows when glines are set by code (hits)\n"
+ " +c: Clone information\n"
+ " +C: CLEARCHAN command\n"
+ " +f: FAKEUSER commands\n"
+ " +b: BROADCAST commands\n"
+ " +o: Operation commands, such as insmod, rmmod, die, etc\n"
+ " +O: /OPER\n"
+ " +I: Misc commands (resync, etc)\n"
+ " +n: Sends notices instead of privmsgs\n"
+ " +A: Every single command sent to the service (spammy)\n"
+ );
+
+ registercontrolhelpcmd("deluser", NO_OPERED | NO_ACCOUNT, 2, &noperserv_deluser, "Syntax: DELUSER <nickname|#authname>\nDeletes the specified user.");
+}
- if(np->umodes & UMODE_OPER) {
- if(np->opername && strcmp(np->opername->content, "-")) {
- controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just OPERed as %s", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"", np->opername->content);
- } else {
- controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just OPERed", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"");
- }
- } else {
- controlwall(NO_OPER, NL_OPERING, "%s!%s@%s%s%s just DEOPERed", np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"");
- }
+void _fini() {
+ deregistercontrolcmd("noticeflags", &noperserv_noticeflags);
+ deregistercontrolcmd("userflags", &noperserv_userflags);
+ deregistercontrolcmd("noticeflags", &noperserv_noticeflags);
+ deregistercontrolcmd("hello", &noperserv_hello);
+ deregistercontrolcmd("deluser", &noperserv_deluser);
}
+
-#include "../control/control.h"
-#include "noperserv.h"
-#include "noperserv_db.h"
-#include "noperserv_policy.h"
+#include "control.h"
+#include "control_db.h"
+#include "control_policy.h"
/* command access */
int noperserv_policy_command_permitted(flag_t level, nick *user) {
#include <string.h>
#include <time.h>
#include <sys/time.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <errno.h>
#include <signal.h>
#include <unistd.h>
initconfig(config);
+ /* modules can rely on this directory always being there */
+ if (mkdir("data", 0700) < 0 && errno != EEXIST) {
+ perror("mkdir");
+ return 1;
+ }
+
/* Loading the modules will bring in the bulk of the code */
initmodules();
signal(SIGINT, siginthandler);
* Prints out which flags are currently set in a flag block
*/
char *printflags(flag_t inflags, const flag *flaglist) {
- static char buf[18];
+ static char buf[34];
int i;
char *ch=buf;
*ch++='+';
- for (i=0;flaglist[i].flagchar!='\0' && i<16;i++) {
+ for (i=0;flaglist[i].flagchar!='\0' && i<32;i++) {
if (inflags&flaglist[i].flagbit) {
*ch++=flaglist[i].flagchar;
}
* Prints out which flags are currently set in a flag block, or return "none"
*/
char *printflagsornone(flag_t inflags, const flag *flaglist) {
- static char buf[18];
+ static char buf[34];
int i;
char *ch=buf;
*ch++='+';
- for (i=0;flaglist[i].flagchar!='\0' && i<16;i++) {
+ for (i=0;flaglist[i].flagchar!='\0' && i<32;i++) {
if (inflags&flaglist[i].flagbit) {
*ch++=flaglist[i].flagchar;
}
/* ugh */
char *printflags_noprefix(flag_t inflags, const flag *flaglist) {
- static char buf[18];
+ static char buf[34];
int i;
char *ch=buf;
- for (i=0;flaglist[i].flagchar!='\0' && i<16;i++) {
+ for (i=0;flaglist[i].flagchar!='\0' && i<32;i++) {
if (inflags&flaglist[i].flagbit) {
*ch++=flaglist[i].flagchar;
}
*/
char *printflagdiff(flag_t oldflags, flag_t newflags, const flag *flaglist) {
- static char buf[30];
+ static char buf[40];
int i;
char *ch=buf;
int chd=0;
/* Removes first */
- for (i=0;flaglist[i].flagchar!='\0' && i<16;i++) {
+ for (i=0;flaglist[i].flagchar!='\0' && i<32;i++) {
if ((oldflags & flaglist[i].flagbit) && !(newflags & flaglist[i].flagbit)) {
if (chd==0) {
chd=1;
/* Now adds */
chd=0;
- for (i=0;flaglist[i].flagchar!='\0' && i<16;i++) {
+ for (i=0;flaglist[i].flagchar!='\0' && i<32;i++) {
if (!(oldflags & flaglist[i].flagbit) && (newflags & flaglist[i].flagbit)) {
if (chd==0) {
chd=1;
return CMD_OK;
}
-void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *np, void *displayfn, int limit) {
+void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *np, void *displayfn, int limit, void *target) {
memset(ctx, 0, sizeof(searchCtx));
ctx->reply = replyfn;
ctx->searchcmd = cmd;
ctx->sender = np;
ctx->limit = limit;
+ ctx->target = target;
ctx->displayfn = displayfn;
}
return CMD_ERROR;
}
- ast_nicksearch(tree->root, reply, sender, wall, display, NULL, NULL, limit);
+ ast_nicksearch(tree->root, reply, sender, wall, display, NULL, NULL, limit, NULL);
parse_free(tree);
search=coerceNode(ctx, search, RETURNTYPE_BOOL);
for (i=0;i<NICKHASHSIZE;i++) {
- for (np=nicktable[i];np;np=np->next) {
+ for (np=ctx->target ? ctx->target : nicktable[i];np;np=np->next) {
if ((search->exe)(ctx, search, np)) {
/* Add total channels */
tchans += np->channels->cursi;
ctx->reply(sender, "--- More than %d matches, skipping the rest",limit);
matches++;
}
+
+ if (ctx->target)
+ goto done;
}
}
+done:
ctx->reply(sender,"--- End of list: %d matches; users were on %u channels (%u unique, %.1f average clones)",
matches, tchans, uchans, (float)tchans/uchans);
}
return CMD_ERROR;
}
- ast_whowassearch(tree->root, reply, sender, wall, display, NULL, NULL, limit);
+ ast_whowassearch(tree->root, reply, sender, wall, display, NULL, NULL, limit, NULL);
parse_free(tree);
search=coerceNode(ctx, search, RETURNTYPE_BOOL);
for (i = whowasoffset; i < whowasoffset + WW_MAXENTRIES; i++) {
- ww = &whowasrecs[i % WW_MAXENTRIES];
+ if (ctx->target) {
+ ww = ctx->target;
+ } else {
+ ww = &whowasrecs[i % WW_MAXENTRIES];
- if (ww->type == WHOWAS_UNUSED)
- continue;
+ if (ww->type == WHOWAS_UNUSED)
+ continue;
+ }
/* Note: We're passing the nick to the filter function. The original
* whowas record is in the nick's ->next field. */
ctx->reply(sender, "--- More than %d matches, skipping the rest",limit);
matches++;
}
+
+ if (ctx->target)
+ break;
}
ctx->reply(sender,"--- End of list: %d matches", matches);
return CMD_ERROR;
}
- ast_chansearch(tree->root, reply, sender, wall, display, NULL, NULL, limit);
+ ast_chansearch(tree->root, reply, sender, wall, display, NULL, NULL, limit, NULL);
parse_free(tree);
search=coerceNode(ctx, search, RETURNTYPE_BOOL);
for (i=0;i<CHANNELHASHSIZE;i++) {
- for (cip=chantable[i];cip;cip=cip->next) {
+ for (cip=ctx->target ? ctx->target : chantable[i];cip;cip=cip->next) {
if ((search->exe)(ctx, search, cip)) {
if (matches<limit)
display(ctx, sender, cip);
if (matches==limit)
ctx->reply(sender, "--- More than %d matches, skipping the rest",limit);
matches++;
+
+ if (ctx->target)
+ goto done;
}
}
}
+done:
ctx->reply(sender,"--- End of list: %d matches", matches);
}
return CMD_ERROR;
}
- ast_usersearch(tree->root, reply, sender, wall, display, NULL, NULL, limit);
+ ast_usersearch(tree->root, reply, sender, wall, display, NULL, NULL, limit, NULL);
parse_free(tree);
search=coerceNode(ctx, search, RETURNTYPE_BOOL);
for (i=0;i<AUTHNAMEHASHSIZE;i++) {
- for (aup=authnametable[i];aup;aup=aup->next) {
+ for (aup=ctx->target ? ctx->target : authnametable[i];aup;aup=aup->next) {
if ((search->exe)(ctx, search, aup)) {
if (matches<limit)
display(ctx, sender, aup);
ctx->reply(sender, "--- More than %d matches, skipping the rest",limit);
matches++;
}
+
+ if (ctx->target)
+ goto done;
}
}
+done:
ctx->reply(sender,"--- End of list: %d matches", matches);
}
struct searchCmd *searchcmd;
nick *sender;
int limit;
+ void *target;
void *displayfn;
} searchCtx;
searchNode *var_get(searchCtx *ctx, char *arg);
void var_setstr(struct searchVariable *v, char *data);
-void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *sender, void *displayfn, int limit);
+void newsearch_ctxinit(searchCtx *ctx, searchParseFunc searchfn, replyFunc replyfn, wallFunc wallfn, void *arg, searchCmd *cmd, nick *sender, void *displayfn, int limit, void *target);
/* AST functions */
searchNode *search_astparse(searchCtx *, char *);
-int ast_nicksearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NickDisplayFunc display, HeaderFunc header, void *headerarg, int limit);
-int ast_chansearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, ChanDisplayFunc display, HeaderFunc header, void *headerarg, int limit);
-int ast_usersearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, UserDisplayFunc display, HeaderFunc header, void *headerarg, int limit);
-int ast_whowassearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, WhowasDisplayFunc display, HeaderFunc header, void *headerarg, int limit);
+int ast_nicksearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NickDisplayFunc display, HeaderFunc header, void *headerarg, int limit, nick *);
+int ast_chansearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, ChanDisplayFunc display, HeaderFunc header, void *headerarg, int limit, chanindex *);
+int ast_usersearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, UserDisplayFunc display, HeaderFunc header, void *headerarg, int limit, authname *);
+int ast_whowassearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, WhowasDisplayFunc display, HeaderFunc header, void *headerarg, int limit, whowas *);
char *ast_printtree(char *buf, size_t bufsize, searchASTExpr *expr, searchCmd *cmd);
int parseopts(int cargc, char **cargv, int *arg, int *limit, void **subset, void *display, CommandTree *sl, replyFunc reply, void *sender);
-typedef int (*ASTFunc)(searchASTExpr *, replyFunc, void *, wallFunc, void *, HeaderFunc, void *, int limit);
+typedef int (*ASTFunc)(searchASTExpr *, replyFunc, void *, wallFunc, void *, HeaderFunc, void *, int limit, void *target);
/* erk */
extern searchList *globalterms;
}
}
-int ast_nicksearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NickDisplayFunc display, HeaderFunc header, void *headerarg, int limit) {
+int ast_nicksearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NickDisplayFunc display, HeaderFunc header, void *headerarg, int limit, nick *target) {
searchCtx ctx;
searchASTCache cache;
searchNode *search;
memset(&cache, 0, sizeof(cache));
cache.tree = tree;
- newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nicksearch, sender, display, limit);
+ newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nicksearch, sender, display, limit, target);
buf[0] = '\0';
reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_nicksearch));
return CMD_OK;
}
-int ast_whowassearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, WhowasDisplayFunc display, HeaderFunc header, void *headerarg, int limit) {
+int ast_whowassearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, WhowasDisplayFunc display, HeaderFunc header, void *headerarg, int limit, whowas *target) {
searchCtx ctx;
searchASTCache cache;
searchNode *search;
memset(&cache, 0, sizeof(cache));
cache.tree = tree;
- newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_whowassearch, sender, display, limit);
+ newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_whowassearch, sender, display, limit, target);
buf[0] = '\0';
reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_whowassearch));
return CMD_OK;
}
-int ast_chansearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, ChanDisplayFunc display, HeaderFunc header, void *headerarg, int limit) {
+int ast_chansearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, ChanDisplayFunc display, HeaderFunc header, void *headerarg, int limit, chanindex *target) {
searchCtx ctx;
searchASTCache cache;
searchNode *search;
char buf[1024];
- newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_chansearch, sender, display, limit);
+ newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_chansearch, sender, display, limit, target);
memset(&cache, 0, sizeof(cache));
cache.tree = tree;
return CMD_OK;
}
-int ast_usersearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, UserDisplayFunc display, HeaderFunc header, void *headerarg, int limit) {
+int ast_usersearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, UserDisplayFunc display, HeaderFunc header, void *headerarg, int limit, authname *target) {
searchCtx ctx;
searchASTCache cache;
searchNode *search;
memset(&cache, 0, sizeof(cache));
cache.tree = tree;
- newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_usersearch, sender, display, limit);
+ newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_usersearch, sender, display, limit, target);
buf[0] = '\0';
reply(sender, "Parsing: %s", ast_printtree(buf, sizeof(buf), tree, reg_usersearch));
{ 'R', UMODE_REGPRIV },
{ 'I', UMODE_HIDEIDLE },
{ 'P', UMODE_PARANOID },
+ { 'q', UMODE_COMCHANS },
+ { 'Q', UMODE_COMCHANSRESTR },
{ 'C', UMODE_CLOAKED },
{ '\0', 0 } };
#define UMODE_HIDEIDLE 0x1000
#define UMODE_PARANOID 0x2000
#define UMODE_CLOAKED 0x4000
+#define UMODE_COMCHANS 0x8000
+#define UMODE_COMCHANSRESTR 0x10000
-#define UMODE_ALL 0x7FFF
+#define UMODE_ALL 0x1FFFF
#define AFLAG_STAFF 0x0001
#define AFLAG_SUPPORT 0x0002
#define AFLAG_ALL 0x001F
-#define IsInvisible(x) ((x)->umodes & UMODE_INV)
-#define IsWallops(x) ((x)->umodes & UMODE_WALLOPS)
-#define IsDebug(x) ((x)->umodes & UMODE_DEBUG)
-#define IsOper(x) ((x)->umodes & UMODE_OPER)
-#define IsService(x) ((x)->umodes & UMODE_SERVICE)
-#define IsXOper(x) ((x)->umodes & UMODE_XOPER)
-#define IsDeaf(x) ((x)->umodes & UMODE_DEAF)
-#define IsAccount(x) ((x)->umodes & UMODE_ACCOUNT)
-#define IsHideChan(x) ((x)->umodes & UMODE_HIDECHAN)
-#define IsHideHost(x) ((x)->umodes & UMODE_HIDEHOST)
-#define IsSetHost(x) ((x)->umodes & UMODE_SETHOST)
-#define IsRegPriv(x) ((x)->umodes & UMODE_REGPRIV)
-#define IsHideIdle(x) ((x)->umodes & UMODE_HIDEIDLE)
-#define IsParanoid(x) ((x)->umodes & UMODE_PARANOID)
-#define IsCloaked(x) ((x)->umodes & UMODE_CLOAKED)
-
-#define SetInvisible(x) ((x)->umodes |= UMODE_INV)
-#define SetWallops(x) ((x)->umodes |= UMODE_WALLOPS)
-#define SetDebug(x) ((x)->umodes |= UMODE_DEBUG)
-#define SetOper(x) ((x)->umodes |= UMODE_OPER)
-#define SetService(x) ((x)->umodes |= UMODE_SERVICE)
-#define SetXOper(x) ((x)->umodes |= UMODE_XOPER)
-#define SetDeaf(x) ((x)->umodes |= UMODE_DEAF)
-#define SetAccount(x) ((x)->umodes |= UMODE_ACCOUNT)
-#define SetHideChan(x) ((x)->umodes |= UMODE_HIDECHAN)
-#define SetHideHost(x) ((x)->umodes |= UMODE_HIDEHOST)
-#define SetSetHost(x) ((x)->umodes |= UMODE_SETHOST)
-#define SetRegPriv(x) ((x)->umodes |= UMODE_REGPRIV)
-#define SetHideIdle(x) ((x)->umodes |= UMODE_HIDEIDLE)
-#define SetParanoid(x) ((x)->umodes |= UMODE_PARANOID)
-#define SetCloaked(x) ((x)->umodes |= UMODE_CLOAKED)
-
-#define ClearInvisible(x) ((x)->umodes &= ~UMODE_INV)
-#define ClearWallops(x) ((x)->umodes &= ~UMODE_WALLOPS)
-#define ClearDebug(x) ((x)->umodes &= ~UMODE_DEBUG)
-#define ClearOper(x) ((x)->umodes &= ~UMODE_OPER)
-#define ClearService(x) ((x)->umodes &= ~UMODE_SERVICE)
-#define ClearXOper(x) ((x)->umodes &= ~UMODE_XOPER)
-#define ClearDeaf(x) ((x)->umodes &= ~UMODE_DEAF)
-#define ClearAccount(x) ((x)->umodes &= ~UMODE_ACCOUNT)
-#define ClearHideChan(x) ((x)->umodes &= ~UMODE_HIDECHAN)
-#define ClearHideHost(x) ((x)->umodes &= ~UMODE_HIDEHOST)
-#define ClearSetHost(x) ((x)->umodes &= ~UMODE_SETHOST)
-#define ClearRegPriv(x) ((x)->umodes &= ~UMODE_REGPRIV)
-#define ClearHideIdle(x) ((x)->umodes &= ~UMODE_HIDEIDLE)
-#define ClearParanoid(x) ((x)->umodes &= ~UMODE_PARANOID)
-#define ClearCloaked(x) ((x)->umodes &= ~UMODE_CLOAKED)
-
-#define IsStaff(x) ((x)->flags & AFLAG_STAFF)
-#define IsDeveloper(x) ((x)->flags & AFLAG_DEVELOPER)
-#define IsSupport(x) ((x)->flags & AFLAG_SUPPORT)
-#define IsAdmin(x) ((x)->flags & AFLAG_ADMIN)
-#define IsOperFlag(x) ((x)->flags & AFLAG_OPER)
-
-#define SetStaff(x) ((x)->flags |= AFLAG_STAFF)
-#define SetDeveloper(x) ((x)->flags |= AFLAG_DEVELOPER)
-#define SetSupport(x) ((x)->flags |= AFLAG_SUPPORT)
-#define SetAdmin(x) ((x)->flags |= AFLAG_ADMIN)
-#define SetOperFlag(x) ((x)->flags |= AFLAG_OPER)
-
-#define ClearStaff(x) ((x)->flags &= ~AFLAG_STAFF)
-#define ClearDeveloper(x) ((x)->flags &= ~AFLAG_DEVELOPER)
-#define ClearSupport(x) ((x)->flags &= ~AFLAG_SUPPORT)
-#define ClearAdmin(x) ((x)->flags &= ~AFLAG_ADMIN)
-#define ClearOperFlag(x) ((x)->flags &= ~AFLAG_OPER)
+#define IsInvisible(x) ((x)->umodes & UMODE_INV)
+#define IsWallops(x) ((x)->umodes & UMODE_WALLOPS)
+#define IsDebug(x) ((x)->umodes & UMODE_DEBUG)
+#define IsOper(x) ((x)->umodes & UMODE_OPER)
+#define IsService(x) ((x)->umodes & UMODE_SERVICE)
+#define IsXOper(x) ((x)->umodes & UMODE_XOPER)
+#define IsDeaf(x) ((x)->umodes & UMODE_DEAF)
+#define IsAccount(x) ((x)->umodes & UMODE_ACCOUNT)
+#define IsHideChan(x) ((x)->umodes & UMODE_HIDECHAN)
+#define IsHideHost(x) ((x)->umodes & UMODE_HIDEHOST)
+#define IsSetHost(x) ((x)->umodes & UMODE_SETHOST)
+#define IsRegPriv(x) ((x)->umodes & UMODE_REGPRIV)
+#define IsHideIdle(x) ((x)->umodes & UMODE_HIDEIDLE)
+#define IsParanoid(x) ((x)->umodes & UMODE_PARANOID)
+#define IsComChans(x) ((x)->umodes & UMODE_COMCHANS)
+#define IsComChansRestr(x) ((x)->umodes & UMODE_COMCHANSRESTR)
+#define IsCloaked(x) ((x)->umodes & UMODE_CLOAKED)
+
+#define SetInvisible(x) ((x)->umodes |= UMODE_INV)
+#define SetWallops(x) ((x)->umodes |= UMODE_WALLOPS)
+#define SetDebug(x) ((x)->umodes |= UMODE_DEBUG)
+#define SetOper(x) ((x)->umodes |= UMODE_OPER)
+#define SetService(x) ((x)->umodes |= UMODE_SERVICE)
+#define SetXOper(x) ((x)->umodes |= UMODE_XOPER)
+#define SetDeaf(x) ((x)->umodes |= UMODE_DEAF)
+#define SetAccount(x) ((x)->umodes |= UMODE_ACCOUNT)
+#define SetHideChan(x) ((x)->umodes |= UMODE_HIDECHAN)
+#define SetHideHost(x) ((x)->umodes |= UMODE_HIDEHOST)
+#define SetSetHost(x) ((x)->umodes |= UMODE_SETHOST)
+#define SetRegPriv(x) ((x)->umodes |= UMODE_REGPRIV)
+#define SetHideIdle(x) ((x)->umodes |= UMODE_HIDEIDLE)
+#define SetParanoid(x) ((x)->umodes |= UMODE_PARANOID)
+#define SetComChans(x) ((x)->umodes |= UMODE_COMCHANS)
+#define SetComChansRestr(x) ((x)->umodes |= UMODE_COMCHANSRESTR)
+#define SetCloaked(x) ((x)->umodes |= UMODE_CLOAKED)
+
+#define ClearInvisible(x) ((x)->umodes &= ~UMODE_INV)
+#define ClearWallops(x) ((x)->umodes &= ~UMODE_WALLOPS)
+#define ClearDebug(x) ((x)->umodes &= ~UMODE_DEBUG)
+#define ClearOper(x) ((x)->umodes &= ~UMODE_OPER)
+#define ClearService(x) ((x)->umodes &= ~UMODE_SERVICE)
+#define ClearXOper(x) ((x)->umodes &= ~UMODE_XOPER)
+#define ClearDeaf(x) ((x)->umodes &= ~UMODE_DEAF)
+#define ClearAccount(x) ((x)->umodes &= ~UMODE_ACCOUNT)
+#define ClearHideChan(x) ((x)->umodes &= ~UMODE_HIDECHAN)
+#define ClearHideHost(x) ((x)->umodes &= ~UMODE_HIDEHOST)
+#define ClearSetHost(x) ((x)->umodes &= ~UMODE_SETHOST)
+#define ClearRegPriv(x) ((x)->umodes &= ~UMODE_REGPRIV)
+#define ClearHideIdle(x) ((x)->umodes &= ~UMODE_HIDEIDLE)
+#define ClearParanoid(x) ((x)->umodes &= ~UMODE_PARANOID)
+#define ClearComChans(x) ((x)->umodes &= ~UMODE_COMCHANS)
+#define ClearComChansRestr(x) ((x)->umodes &= ~UMODE_COMCHANSRESTR)
+#define ClearCloaked(x) ((x)->umodes &= ~UMODE_CLOAKED)
+
+#define IsStaff(x) ((x)->flags & AFLAG_STAFF)
+#define IsDeveloper(x) ((x)->flags & AFLAG_DEVELOPER)
+#define IsSupport(x) ((x)->flags & AFLAG_SUPPORT)
+#define IsAdmin(x) ((x)->flags & AFLAG_ADMIN)
+#define IsOperFlag(x) ((x)->flags & AFLAG_OPER)
+
+#define SetStaff(x) ((x)->flags |= AFLAG_STAFF)
+#define SetDeveloper(x) ((x)->flags |= AFLAG_DEVELOPER)
+#define SetSupport(x) ((x)->flags |= AFLAG_SUPPORT)
+#define SetAdmin(x) ((x)->flags |= AFLAG_ADMIN)
+#define SetOperFlag(x) ((x)->flags |= AFLAG_OPER)
+
+#define ClearStaff(x) ((x)->flags &= ~AFLAG_STAFF)
+#define ClearDeveloper(x) ((x)->flags &= ~AFLAG_DEVELOPER)
+#define ClearSupport(x) ((x)->flags &= ~AFLAG_SUPPORT)
+#define ClearAdmin(x) ((x)->flags &= ~AFLAG_ADMIN)
+#define ClearOperFlag(x) ((x)->flags &= ~AFLAG_OPER)
#define NickOnServiceServer(target) SIsService(&serverlist[homeserver((target)->numeric)])
--- /dev/null
+include ../build.mk
+.PHONY: all
+all: nickwatch.so
+
+nickwatch.so: nickwatch.o
--- /dev/null
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include "../core/schedule.h"
+#include "../control/control.h"
+#include "../newsearch/newsearch.h"
+#include "../newsearch/parser.h"
+
+typedef struct nickwatch {
+ int id;
+
+ char createdby[64];
+ int hits;
+ char term[512];
+ parsertree *tree;
+
+ struct nickwatch *next;
+} nickwatch;
+
+typedef struct nickwatchevent {
+ char description[128];
+ long numeric;
+} nickwatchevent;
+
+static nickwatch *nickwatches;
+static int nextnickwatch = 1;
+
+static void nw_dummyreply(nick *np, char *format, ...) { }
+
+static void nw_dummywall(int level, char *format, ...) { }
+
+static nickwatch *nw_currentwatch;
+static nickwatchevent *nw_currentevent;
+
+static void nw_printnick(searchCtx *ctx, nick *sender, nick *np) {
+ char hostbuf[HOSTLEN+NICKLEN+USERLEN+4];
+
+ nw_currentwatch->hits++;
+
+ controlwall(NO_OPER, NL_HITS, "nickwatch(#%d, %s): %s [%s] (%s) (%s)", nw_currentwatch->id, nw_currentevent->description, visiblehostmask(np,hostbuf),
+ IPtostr(np->ipaddress), printflags(np->umodes, umodeflags), np->realname->name->content);
+}
+
+static nickwatchevent *nwe_new(nick *np, const char *format, ...) {
+ nickwatchevent *nwe;
+ va_list va;
+
+ nwe = malloc(sizeof(nickwatchevent));
+ nwe->numeric = np->numeric;
+
+ va_start(va, format);
+ vsnprintf(nwe->description, sizeof(nwe->description), format, va);
+ va_end(va);
+
+ return nwe;
+}
+
+static void nwe_free(nickwatchevent *nwe) {
+ free(nwe);
+}
+
+static void nw_sched_processevent(void *arg) {
+ nickwatchevent *nwe = arg;
+ nick *np;
+ nickwatch *nw;
+
+ np = getnickbynumeric(nwe->numeric);
+
+ if (!np) {
+ nwe_free(nwe);
+ return;
+ }
+ nw_currentevent = nwe;
+
+ for (nw = nickwatches; nw; nw = nw->next) {
+ nw_currentwatch = nw;
+ ast_nicksearch(nw->tree->root, &nw_dummyreply, mynick, &nw_dummywall, &nw_printnick, NULL, NULL, 10, np);
+ }
+
+ nwe_free(nwe);
+}
+
+static void nw_hook_newnick(int hooknum, void *arg) {
+ nick *np = arg;
+ nickwatchevent *nwe = nwe_new(np, "new user");
+ scheduleoneshot(0, nw_sched_processevent, nwe);
+}
+
+static void nw_hook_rename(int hooknum, void *arg) {
+ void **args = arg;
+ nick *np = args[0];
+ char *oldnick = args[1];
+ nickwatchevent *nwe = nwe_new(np, "renamed from %s", oldnick);
+ scheduleoneshot(0, nw_sched_processevent, nwe);
+}
+
+static void nw_hook_joinchannel(int hooknum, void *arg) {
+ void **args = arg;
+ channel *cp = args[0];
+ nick *np = args[1];
+ nickwatchevent *nwe = nwe_new(np, "join channel %s", cp->index->name->content);
+ scheduleoneshot(0, nw_sched_processevent, nwe);
+}
+
+static int nw_cmd_nickwatch(void *source, int cargc, char **cargv) {
+ nick *sender = source;
+ nickwatch *nw;
+ parsertree *tree;
+
+ if (cargc < 1)
+ return CMD_USAGE;
+
+ tree = parse_string(reg_nicksearch, cargv[0]);
+ if (!tree) {
+ displaystrerror(controlreply, sender, cargv[0]);
+ return CMD_ERROR;
+ }
+
+ nw = malloc(sizeof(nickwatch));
+ nw->id = nextnickwatch++;
+ snprintf(nw->createdby, sizeof(nw->createdby), "#%s", sender->authname);
+ nw->hits = 0;
+ strncpy(nw->term, cargv[0], sizeof(nw->term));
+ nw->tree = parse_string(reg_nicksearch, cargv[0]);
+ nw->next = nickwatches;
+ nickwatches = nw;
+
+ controlreply(sender, "Done.");
+
+ return CMD_OK;
+}
+
+static int nw_cmd_nickunwatch(void *source, int cargc, char **cargv) {
+ nick *sender = source;
+ nickwatch **pnext, *nw;
+ int id;
+
+ if (cargc < 1)
+ return CMD_USAGE;
+
+ id = atoi(cargv[0]);
+
+ for (pnext = &nickwatches; *pnext; pnext = &((*pnext)->next)) {
+ nw = *pnext;
+
+ if (nw->id == id) {
+ parse_free(nw->tree);
+ *pnext = nw->next;
+ free(nw);
+
+ controlreply(sender, "Done.");
+ return CMD_OK;
+ }
+ }
+
+ controlreply(sender, "Nickwatch #%d not found.", id);
+
+ return CMD_ERROR;
+}
+
+static int nw_cmd_nickwatches(void *source, int cargc, char **cargv) {
+ nick *sender = source;
+ nickwatch *nw;
+
+ controlreply(sender, "ID Created By Hits Term");
+
+ for (nw = nickwatches; nw; nw = nw->next)
+ controlreply(sender, "%-5d %-15s %-7d %s", nw->id, nw->createdby, nw->hits, nw->term);
+
+ controlreply(sender, "--- End of nickwatches.");
+
+ return CMD_OK;
+}
+
+void _init(void) {
+ registercontrolhelpcmd("nickwatch", NO_OPER, 1, &nw_cmd_nickwatch, "Usage: nickwatch <nicksearch term>\nAdds a nickwatch entry.");
+ registercontrolhelpcmd("nickunwatch", NO_OPER, 1, &nw_cmd_nickunwatch, "Usage: nickunwatch <#id>\nRemoves a nickwatch entry.");
+ registercontrolhelpcmd("nickwatches", NO_OPER, 0, &nw_cmd_nickwatches, "Usage: nickwatches\nLists nickwatches.");
+
+ registerhook(HOOK_NICK_NEWNICK, &nw_hook_newnick);
+ registerhook(HOOK_NICK_RENAME, &nw_hook_rename);
+ registerhook(HOOK_CHANNEL_CREATE, &nw_hook_joinchannel);
+ registerhook(HOOK_CHANNEL_JOIN, &nw_hook_joinchannel);
+}
+
+void _fini(void) {
+ nickwatch *nw, *next;
+
+ deregistercontrolcmd("nickwatch", &nw_cmd_nickwatch);
+ deregistercontrolcmd("nickunwatch", &nw_cmd_nickunwatch);
+ deregistercontrolcmd("nickwatches", &nw_cmd_nickwatches);
+
+ deregisterhook(HOOK_NICK_NEWNICK, &nw_hook_newnick);
+ deregisterhook(HOOK_NICK_RENAME, &nw_hook_rename);
+ deregisterhook(HOOK_CHANNEL_CREATE, &nw_hook_joinchannel);
+ deregisterhook(HOOK_CHANNEL_JOIN, &nw_hook_joinchannel);
+
+ for (nw = nickwatches; nw; nw = next) {
+ next = nw->next;
+
+ parse_free(nw->tree);
+ free(nw);
+ }
+}
+++ /dev/null
-include ../build.mk
-
-CFLAGS+=$(INCDBAPI)
-LDFLAGS+=$(LIBDBAPI)
-
-.PHONY: all
-all: noperserv.so noperserv_commands.so noperserv_raw.so
-
-noperserv.so: noperserv.o noperserv_db.o noperserv_hooks.o noperserv_policy.o
-
-noperserv_commands.so: noperserv_commands.o
-
-noperserv_raw.so: noperserv_raw.o
+++ /dev/null
-#ifndef __NOPERSERV_H
-#define __NOPERSERV_H
-
-#include "../control/control.h"
-#include "../noperserv/noperserv_db.h"
-#include "../lib/flags.h"
-
-extern int noperserv_ext;
-
-extern const flag no_userflags[];
-extern const flag no_noticeflags[];
-extern const flag no_commandflags[];
-
-#define NO_NICKS_PER_WHOIS_LINE 3
-
-#define NOGetAuthedUser(user) (no_autheduser *)(user->exts[noperserv_ext])
-#define NOGetAuthLevel(user) user->authlevel
-#define NOGetNoticeLevel(user) user->noticelevel
-#define NOMax(a, b) (a>b?a:b)
-#define NOMin(a, b) (a<b?b:a)
-
-#endif
+++ /dev/null
-/*
- * NOperserv v0.01
- *
- * A replacement for Germania's ageing Operservice2
- * DB functions
- *
- * Copyright (C) 2005 Chris Porter.
- */
-
-#include "../nick/nick.h"
-#include "../core/error.h"
-#include "../lib/irc_string.h"
-#include "../core/schedule.h"
-#include "../dbapi2/dbapi2.h"
-
-#include "noperserv.h"
-#include "noperserv_db.h"
-
-#include <stdlib.h>
-
-int db_loaded = 0;
-unsigned long loadedusers = 0;
-
-unsigned long lastuserid;
-
-no_autheduser *authedusers = NULL;
-
-void noperserv_create_tables(void);
-
-void noperserv_free_user(no_autheduser *au);
-void noperserv_load_users(const DBAPIResult *res, void *arg);
-
-void noperserv_check_nick(nick *np);
-void noperserv_nick_account(int hooknum, void *arg);
-void noperserv_quit_account(int hooknum, void *arg);
-
-void nopserserv_delete_from_autheduser(nick *np, no_autheduser *au);
-
-static DBAPIConn *nodb;
-
-int noperserv_load_db(void) {
- if(!nodb) {
- nodb = dbapi2open(DBAPI2_DEFAULT, "noperserv");
- if(!nodb) {
- Error("noperserv", ERR_STOP, "Could not connect to database.");
- return 0;
- }
- }
-
- db_loaded = 1;
-
- authedusers = NULL;
-
- noperserv_create_tables();
-
- nodb->query(nodb, noperserv_load_users, NULL,
- "SELECT ID, authname, flags, noticelevel FROM ?", "T", "users");
-
- return 1;
-}
-
-void noperserv_load_users(const DBAPIResult *res, void *arg) {
- no_autheduser *nu;
- nick *np;
- int i;
-
- if(!res)
- return;
-
- if(!res->success) {
- Error("noperserv", ERR_ERROR, "Error loading user list.");
- res->clear(res);
- return;
- }
-
- lastuserid = 0;
-
- while(res->next(res)) {
- nu = noperserv_new_autheduser(res->get(res, 1));
- if(!nu)
- continue;
-
- nu->id = strtoul(res->get(res, 0), NULL, 10);
- nu->authlevel = strtoul(res->get(res, 2), NULL, 10);
- nu->noticelevel = strtoul(res->get(res, 3), NULL, 10);
- nu->newuser = 0;
- if(nu->id > lastuserid)
- lastuserid = nu->id;
- }
-
- Error("noperserv", ERR_INFO, "Loaded %lu users", loadedusers);
-
- for(i=0;i<NICKHASHSIZE;i++)
- for(np=nicktable[i];np;np=np->next)
- if(IsAccount(np))
- noperserv_check_nick(np);
-
- registerhook(HOOK_NICK_ACCOUNT, &noperserv_nick_account);
- registerhook(HOOK_NICK_NEWNICK, &noperserv_nick_account);
- registerhook(HOOK_NICK_LOSTNICK, &noperserv_quit_account);
-
- res->clear(res);
-}
-
-void noperserv_create_tables(void) {
- nodb->createtable(nodb, NULL, NULL,
- "CREATE TABLE ? ("
- "ID INT NOT NULL,"
- "authname VARCHAR(?) NOT NULL,"
- "flags INT NOT NULL,"
- "noticelevel INT NOT NULL,"
- "PRIMARY KEY (ID))", "Td", "users", ACCOUNTLEN);
-}
-
-void noperserv_cleanup_db(void) {
- no_autheduser *ap, *np;
-
- deregisterhook(HOOK_NICK_LOSTNICK, &noperserv_quit_account);
- deregisterhook(HOOK_NICK_NEWNICK, &noperserv_nick_account);
- deregisterhook(HOOK_NICK_ACCOUNT, &noperserv_nick_account);
-
- ap = authedusers;
- while(ap) {
- np = ap->next;
- noperserv_free_user(ap);
- ap = np;
- }
-
- nodb->close(nodb);
- nodb = NULL;
-}
-
-no_autheduser *noperserv_new_autheduser(char *authname) {
- no_autheduser *au = (no_autheduser *)malloc(sizeof(no_autheduser));
- if(!au)
- return NULL;
-
- au->authname = getsstring(authname, ACCOUNTLEN);
- if(!au->authname) {
- free(au);
- return NULL;
- }
-
- loadedusers++;
- au->newuser = 1;
- au->nick = NULL;
-
- au->next = authedusers;
- authedusers = au;
-
- return au;
-}
-
-void noperserv_delete_autheduser(no_autheduser *au) {
- no_autheduser *ap = authedusers, *lp = NULL;
-
- if(!au->newuser)
- nodb->squery(nodb, "DELETE FROM ? WHERE id = ?", "Tu", "users", au->id);
-
- for(;ap;lp=ap,ap=ap->next) {
- if(ap == au) {
- if(lp) {
- lp->next = ap->next;
- } else {
- authedusers = ap->next;
- }
- noperserv_free_user(ap);
- return;
- }
- }
-}
-
-void noperserv_update_autheduser(no_autheduser *au) {
- if(au->newuser) {
- nodb->squery(nodb, "INSERT INTO ? (id, authname, flags, noticelevel) VALUES (?,?,?,?)", "Tusuu", "users", au->id, au->authname->content, NOGetAuthLevel(au), NOGetNoticeLevel(au));
- au->newuser = 0;
- } else {
- nodb->squery(nodb, "UPDATE ? SET flags = ?, noticelevel = ? WHERE id = ?", "Tuuu", "users", NOGetAuthLevel(au), NOGetNoticeLevel(au), au->id);
- }
-}
-
-void noperserv_free_user(no_autheduser *au) {
- no_nicklist *cp = au->nick, *np;
-
- while(cp) {
- cp->nick->exts[noperserv_ext] = NULL;
- np = cp->next;
- free(cp);
- cp = np;
- }
-
- freesstring(au->authname);
- free(au);
-
- loadedusers--;
-}
-
-void noperserv_check_nick(nick *np) {
- no_autheduser *au = noperserv_get_autheduser(np->authname);
- if(au)
- noperserv_add_to_autheduser(np, au);
-}
-
-void noperserv_nick_account(int hooknum, void *arg) {
- noperserv_check_nick((nick *)arg);
-}
-
-void noperserv_quit_account(int hooknum, void *arg) {
- nick *np = (void *)arg;
- no_autheduser *au = NOGetAuthedUser(np);
- no_nicklist *nl, *ln = NULL;
- if(!au)
- return;
-
- for(nl=au->nick;nl;ln=nl,nl=nl->next)
- if(nl->nick == np) {
- if(ln) {
- ln->next = nl->next;
- } else {
- au->nick = nl->next;
- }
- free(nl);
- break;
- }
-}
-
-no_autheduser *noperserv_get_autheduser(char *authname) {
- no_autheduser *au = authedusers;
-
- for(;au;au=au->next)
- if(!ircd_strcmp(authname, au->authname->content))
- return au;
-
- return NULL;
-}
-
-unsigned long noperserv_get_autheduser_count(void) {
- return loadedusers;
-}
-
-unsigned long noperserv_next_autheduser_id(void) {
- return ++lastuserid;
-}
-
-void noperserv_add_to_autheduser(nick *np, no_autheduser *au) {
- no_nicklist *nl = (no_nicklist *)malloc(sizeof(no_nicklist));
- if(!nl)
- return;
-
- np->exts[noperserv_ext] = au;
-
- nl->nick = np;
-
- nl->next = au->nick;
- au->nick = nl;
-}
-
-void nopserserv_delete_from_autheduser(nick *np, no_autheduser *au) {
- no_nicklist *cp = au->nick, *lp = NULL;
-
- for(;cp;lp=cp,cp=cp->next)
- if(cp->nick == np) {
- if(lp) {
- lp->next = cp->next;
- } else {
- au->nick = cp->next;
- }
- free(cp);
- break;
- }
-}
+++ /dev/null
-#include "../control/control.h"
-#include "../localuser/localuser.h"
-#include "../core/schedule.h"
-#include "../core/modules.h"
-#include "../lib/splitline.h"
-#include "../lib/flags.h"
-#include "../lib/irc_string.h"
-#include "../lib/strlfunc.h"
-
-#include "noperserv.h"
-#include "noperserv_db.h"
-#include "noperserv_hooks.h"
-#include "noperserv_policy.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-
-struct storedhook {
- CommandHandler old;
- sstring *name;
- cmdhelp *oldhelp;
- cmdhelp *newhelp;
- struct storedhook *next;
-} storedhook;
-
-struct storedhook *storedhooks = NULL;
-
-int firsttime = 0;
-nick *replynick = NULL;
-
-UserMessageHandler oldhandler;
-ControlMsg oldreply;
-ControlWall oldwall;
-ControlPermitted oldpermitted;
-
-void noperserv_trap_registration(int hooknum, void *arg);
-int noperserv_showcommands(void *sender, int cargc, char **cargv);
-int noperserv_rmmod(void *sender, int cargc, char **cargv);
-int noperserv_reload(void *sender, int cargc, char **cargv);
-int noperserv_whois(void *sender, int cargc, char **cargv);
-int noperserv_help(void *sender, int cargc, char **cargv);
-void noperserv_whois_handler(int hooknum, void *arg);
-void noperserv_whois_account_handler(int hooknum, void *arg);
-void noperserv_handle_messages(nick *target, int messagetype, void **args);
-void noperserv_reply(nick *np, char *format, ...) __attribute__ ((format (printf, 2, 3)));
-void noperserv_wall(flag_t permissionlevel, flag_t noticelevel, char *format, ...);
-
-struct specialsched special;
-
-#define HOOK_CONTROL_WHOISREQUEST_AUTHNAME -1
-#define HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER -2
-
-void noperserv_setup_hooks(void) {
- oldreply = controlreply;
- controlreply = &noperserv_reply;
-
- oldwall = controlwall;
- controlwall = &noperserv_wall;
-
- oldpermitted = controlpermitted;
- controlpermitted = &noperserv_policy_command_permitted;
-
- memset(&special, 0, sizeof(struct specialsched));
-
- if(!mynick) {
- registerhook(HOOK_CONTROL_REGISTERED, &noperserv_trap_registration);
- } else {
- noperserv_trap_registration(0, (void *)mynick);
- }
-
- registerhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
-}
-
-int noperserv_hook_command(char *command, CommandHandler newcommand, char *newhelp) {
- struct storedhook *newhook;
- Command *fetchcommand = findcommandintree(controlcmds, command, 1);
-
- if(!fetchcommand)
- return 1;
-
- newhook = (struct storedhook *)malloc(sizeof(struct storedhook));
- if(!newhook)
- return 1;
-
- newhook->name = getsstring(command, strlen(command));
- if(!newhook->name) {
- free(newhook);
- return 1;
- }
-
- newhook->old = fetchcommand->handler;
- if(newhelp) {
- newhook->newhelp = (cmdhelp *)malloc(sizeof(cmdhelp));
- memset(newhook->newhelp,0,sizeof(cmdhelp));
- if(!newhook->newhelp) {
- freesstring(newhook->name);
- free(newhook);
- } else {
- int len = strlen(newhelp) + 1;
- newhook->newhelp->helpstr = (char *)malloc(len);
- if (newhook->newhelp->helpstr) {
- strlcpy(newhook->newhelp->helpstr, newhelp, len);
- }
- newhook->oldhelp = fetchcommand->ext;
- fetchcommand->ext = newhook->newhelp;
- }
- } else {
- newhook->newhelp = NULL;
- }
-
- newhook->next = storedhooks;
- storedhooks = newhook;
-
- fetchcommand->handler = newcommand;
-
- return 0;
-}
-
-void noperserv_unhook_all_commands(void) {
- struct storedhook *nh, *ch = storedhooks;
- Command *fetchcommand;
-
- while(ch) {
- if(ch->old && (fetchcommand = findcommandintree(controlcmds, ch->name->content, 1))) {
- fetchcommand->handler = ch->old;
- if(ch->newhelp) {
- fetchcommand->ext = ch->oldhelp;
- if ( ((cmdhelp *)ch->newhelp)->helpstr)
- free( ((cmdhelp *)ch->newhelp)->helpstr);
- free(ch->newhelp);
- }
- }
- nh = ch->next;
- freesstring(ch->name);
- free(ch);
- ch = nh;
- }
-}
-
-void noperserv_cleanup_hooks(void) {
- deregisterhook(HOOK_CONTROL_WHOISREQUEST, &noperserv_whois_handler);
- deregisterhook(HOOK_CONTROL_REGISTERED, &noperserv_trap_registration);
-
- if(firsttime) {
- noperserv_unhook_all_commands();
- firsttime = 0;
- }
-
- if(oldhandler && mynick)
- hooklocaluserhandler(mynick, oldhandler);
-
- controlwall = oldwall;
- controlreply = oldreply;
- controlpermitted = oldpermitted;
-}
-
-void noperserv_trap_registration(int hooknum, void *arg) {
- nick *np = (nick *)arg;
- if(!np)
- return;
-
- oldhandler = hooklocaluserhandler((nick *)arg, &noperserv_handle_messages);
- if(!oldhandler)
- return;
-
- if(!firsttime) {
- firsttime = 1;
- noperserv_hook_command("rmmod", &noperserv_rmmod, NULL);
- noperserv_hook_command("reload", &noperserv_reload, NULL);
- noperserv_hook_command("showcommands", &noperserv_showcommands, NULL);
- noperserv_hook_command("whois", &noperserv_whois, "Usage: whois <nickname|#authname|*numeric>\nDisplays lots of information about the specified nickname, auth name or numeric.");
- noperserv_hook_command("help", &noperserv_help, NULL);
- }
-}
-
-CommandHandler noperserv_find_hook(char *command) {
- struct storedhook *hh = storedhooks;
- for(;hh;hh=hh->next)
- if(!ircd_strcmp(hh->name->content, command))
- return hh->old;
-
- return NULL;
-}
-
-int noperserv_modules_loaded(char *mask) {
- int i;
- char *ptr;
-
- for(i=0,ptr=lsmod(i,NULL,NULL,NULL);ptr;ptr=lsmod(++i,NULL,NULL,NULL))
- if(match2strings(mask, ptr))
- return 1;
-
- return 0;
-}
-
-int noperserv_specialmod(nick *np, char *command, ScheduleCallback reloadhandler, int cargc, char **cargv) {
- CommandHandler oldcommand = noperserv_find_hook(command);
- if(cargc < 1) {
- if(oldcommand)
- return oldcommand(np, cargc, cargv);
- return CMD_ERROR;
- }
-
- if(!strcmp(cargv[0], "noperserv")) {
- if(special.schedule) {
- controlreply(np, "Previous attempt at un/reload still in progress.");
- return CMD_OK;
- } else {
- special.modulename = getsstring(cargv[0], strlen(cargv[0]));
- if(!special.modulename) {
- controlreply(np, "Unable to copy module name. Seek cow herd to trample on server.");
- return CMD_ERROR;
- } else {
- special.schedule = scheduleoneshot(time(NULL) + 1, reloadhandler, &special);
- if(!special.schedule) {
- freesstring(special.modulename);
- special.modulename = NULL;
- controlreply(np, "Unable to allocate schedule. Seek cow herd to trample on server.");
- return CMD_ERROR;
- }
- controlreply(np, "Special case un/reload in <1 second, no response will be sent, standby. . .");
- return CMD_OK;
- }
- }
- } else {
- if(oldcommand)
- return oldcommand(np, cargc, cargv);
- return CMD_ERROR;
- }
-}
-
-int noperserv_rmmod(void *sender, int cargc, char **cargv) {
- return noperserv_specialmod(sender, "rmmod", &controlspecialrmmod, cargc, cargv);
-}
-
-int noperserv_reload(void *sender, int cargc, char **cargv) {
- return noperserv_specialmod(sender, "reload", &controlspecialreloadmod, cargc, cargv);
-}
-
-void noperserv_whois_hook(int hooknum, void *arg) {
- controlreply(replynick, "%s", (char *)arg);
-}
-
-int noperserv_whois(void *sender, int cargc, char **cargv) {
- no_autheduser *au;
- nick *np = (nick *)sender;
- CommandHandler oldwhois = noperserv_find_hook("whois");
-
- if(cargc < 1) {
- if(oldwhois)
- return oldwhois(sender, cargc, cargv);
- return CMD_ERROR;
- }
-
- if(cargv[0][0] != '#') {
- if(cargv[0][0] == '*')
- cargv[0][0] = '#';
- if(oldwhois)
- return oldwhois(sender, cargc, cargv);
- return CMD_ERROR;
- }
-
- au = noperserv_get_autheduser(cargv[0] + 1);
- if(!au) {
- controlreply(np, "Account not registered.");
- return CMD_OK;
- }
-
- controlreply(np, "Account : %s", au->authname->content);
-
- replynick = np;
-
- registerhook(HOOK_CONTROL_WHOISREPLY, &noperserv_whois_hook);
- noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
- deregisterhook(HOOK_CONTROL_WHOISREPLY, &noperserv_whois_hook);
-
- controlreply(np, "Flags : %s", printflags(NOGetAuthLevel(au), no_userflags));
-
- return CMD_OK;
-}
-
-int noperserv_showcommands(void *sender, int cargc, char **cargv) {
- nick *np = (nick *)sender;
- Command *cmdlist[100];
- int i, n;
-
- n = getcommandlist(controlcmds, cmdlist, 100);
-
- controlreply(np, "The following commands are registered at present:");
-
- for(i=0;i<n;i++)
- if(noperserv_policy_command_permitted(cmdlist[i]->level, np))
- controlreply(np, " %-25s %s", cmdlist[i]->command->content, printflags(cmdlist[i]->level, no_commandflags));
-
- controlreply(np, "End of list.");
- return CMD_OK;
-}
-
-void noperserv_whois_handler(int hooknum, void *arg) {
- char message[100];
- nick *np = (nick *)arg;
- no_autheduser *au;
- if(!np)
- return;
-
- if(IsAccount(np)) {
- au = NOGetAuthedUser(np);
- if(au) {
- snprintf(message, sizeof(message), "Flags : %s", printflags(NOGetAuthLevel(au), no_userflags));
- noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER, (void *)au);
- } else {
- snprintf(message, sizeof(message), "Flags : (user not known)");
- noperserv_whois_account_handler(HOOK_CONTROL_WHOISREQUEST_AUTHNAME, (void *)np->authname);
- }
- triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- }
-}
-
-/* mmm, hacky */
-void noperserv_whois_account_handler(int hooknum, void *arg) {
- int count = 0, found = 0;
- char nickbuffer[(NICKLEN + 2) * NO_NICKS_PER_WHOIS_LINE - 1]; /* since we don't need space or comma for the first item we're fine NULL wise */
- char accountspace[NICKLEN + 3]; /* space, comma, null */
- char message[1024];
-
- nickbuffer[0] = '\0';
- if(hooknum == HOOK_CONTROL_WHOISREQUEST_AUTHEDUSER) {
- /* we can just read out the authed user linked list */
- no_autheduser *au = (void *)arg;
- no_nicklist *nl = au->nick;
-
- if(nl)
- found = 1;
-
- for(;nl;nl=nl->next) {
- snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", nl->nick->nick);
- strlcat(nickbuffer, accountspace, sizeof(nickbuffer));
-
- if(count >= NO_NICKS_PER_WHOIS_LINE) {
- snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
- triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- nickbuffer[0] = '\0';
- count = 0;
- }
- }
- } else {
- /* inefficient way */
- char *authname = (char *)arg;
- int i = 0;
- nick *sp;
-
- for(;i<NICKHASHSIZE;i++)
- for(sp=nicktable[i];sp;sp=sp->next)
- if(IsAccount(sp) && !ircd_strcmp(sp->authname, authname)) {
- found = 1;
-
- snprintf(accountspace, sizeof(accountspace), "%s%s", count++?", ":"", sp->nick);
- strlcat(nickbuffer, accountspace, sizeof(nickbuffer));
-
- if(count >= NO_NICKS_PER_WHOIS_LINE) {
- snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
- triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- nickbuffer[0] = '\0';
- count = 0;
- }
- }
- }
-
- if(!found) {
- snprintf(message, sizeof(message), "Authed : (no nicks authed)");
- triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- } else if(nickbuffer[0]) {
- snprintf(message, sizeof(message), "Authed : %s", nickbuffer);
- triggerhook(HOOK_CONTROL_WHOISREPLY, message);
- }
-}
-
-/* Obviously pinched from control.c */
-void noperserv_handle_messages(nick *target, int messagetype, void **args) {
- Command *cmd;
- char *cargv[50];
- int cargc;
- nick *sender;
-
- switch(messagetype) {
- case LU_PRIVMSG: /* override these two commands only */
- case LU_SECUREMSG:
- /* If it's a message, first arg is nick and second is message */
- sender = (nick *)args[0];
-
- controlwall(NO_DEVELOPER, NL_ALL_COMMANDS, "From: %s!%s@%s%s%s: %s", sender->nick, sender->ident, sender->host->name->content, IsAccount(sender)?"/":"", IsAccount(sender)?sender->authname:"", (char *)args[1]);
-
- /* Split the line into params */
- cargc = splitline((char *)args[1], cargv, 50, 0);
-
- if(!cargc) /* Blank line */
- return;
-
- cmd = findcommandintree(controlcmds,cargv[0],1);
- if(!cmd) {
- controlreply(sender, "Unknown command or access denied.");
- return;
- }
-
- /* If we were doing "authed user tracking" here we'd put a check in for authlevel */
- /* Here it is! */
- if (!noperserv_policy_command_permitted(cmd->level, sender)) {
- controlreply(sender, "Unknown command or access denied.");
- return;
- }
-
- /* Check the maxargs */
- if(cmd->maxparams < (cargc - 1)) {
- /* We need to do some rejoining */
- rejoinline(cargv[cmd->maxparams], cargc - (cmd->maxparams));
- cargc = (cmd->maxparams) + 1;
- }
-
- if((cmd->handler)((void *)sender,cargc-1,&(cargv[1])) == CMD_USAGE)
- controlhelp(sender, cmd);
-
- break;
- default:
- if(oldhandler)
- oldhandler(target, messagetype, args);
- break;
- }
-}
-
-void noperserv_reply(nick *np, char *format, ...) {
- char buf[512];
- va_list va;
- no_autheduser *au = NOGetAuthedUser(np);
-
- va_start(va, format);
- vsnprintf(buf, sizeof(buf), format, va);
- va_end(va);
-
- if(au && !(NOGetNoticeLevel(au) & NL_NOTICES)) {
- controlmessage(np, "%s", buf);
- } else {
- controlnotice(np, "%s", buf);
- }
-}
-
-int noperserv_help(void *sender, int cargc, char **cargv) {
- Command *cmd;
- nick *np = (nick *)sender;
-
- if(cargc < 1)
- return CMD_USAGE;
-
- cmd = findcommandintree(controlcmds, cargv[0], 1);
- if(!cmd || !noperserv_policy_command_permitted(cmd->level, np)) {
- controlreply(np, "Unknown command or access denied.");
- return CMD_ERROR;
- }
-
- controlhelp(np, cmd);
- return CMD_OK;
-}
-
-void noperserv_wall(flag_t permissionlevel, flag_t noticelevel, char *format, ...) {
- char buf[512];
- va_list va;
- no_autheduser *au = authedusers;
- no_nicklist *nl;
- char *flags = printflags(noticelevel, no_noticeflags) + 1;
-
- va_start(va, format);
- vsnprintf(buf, sizeof(buf), format, va);
- va_end(va);
-
- Error("noperserv", ERR_INFO, "$%s$ %s", flags, buf);
-
- for(;au;au=au->next) {
- if((NOGetNoticeLevel(au) & noticelevel) && !(NOGetAuthLevel(au) & __NO_RELAY)) {
- for(nl=au->nick;nl;nl=nl->next)
- if(noperserv_policy_command_permitted(permissionlevel, nl->nick))
- controlreply(nl->nick, "$%s$ %s", flags, buf);
- }
- }
-}
+++ /dev/null
-void noperserv_setup_hooks(void);\r
-void noperserv_cleanup_hooks(void);\r
#include <string.h>
#include "patriciasearch.h"
-int ast_nodesearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NodeDisplayFunc display, HeaderFunc header, void *headerarg, int limit) {
+int ast_nodesearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NodeDisplayFunc display, HeaderFunc header, void *headerarg, int limit, patricia_node_t *target) {
searchCtx ctx;
searchASTCache cache;
searchNode *search;
char buf[1024];
- newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nodesearch, sender, display, limit);
+ newsearch_ctxinit(&ctx, search_astparse, reply, wall, &cache, reg_nodesearch, sender, display, limit, target);
memset(&cache, 0, sizeof(cache));
cache.tree = tree;
return CMD_ERROR;
}
- ast_nodesearch(tree->root, reply, sender, wall, display, NULL, NULL, limit);
+ ast_nodesearch(tree->root, reply, sender, wall, display, NULL, NULL, limit, NULL);
parse_free(tree);
int do_pnodesearch_real(replyFunc reply, wallFunc wall, void *source, int cargc, char **cargv);
-int ast_nodesearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NodeDisplayFunc display, HeaderFunc header, void *headerarg, int limit);
+int ast_nodesearch(searchASTExpr *tree, replyFunc reply, void *sender, wallFunc wall, NodeDisplayFunc display, HeaderFunc header, void *headerarg, int limit, patricia_node_t *target);
void regpnodedisp(const char *name, NodeDisplayFunc handler);
void unregpnodedisp(const char *name, NodeDisplayFunc handler);
--- /dev/null
+include ../build.mk
+
+.PHONY: all
+all: raw.so
+
+raw.so: raw.o
/* treat blocked users as if they're out of targets */
if(rq_findblock(np->authname) || !rq_tryfasttrack(np)) {
sendnoticetouser(svc, np, "Sorry, you may not request %s for another "
- "channel at this time. Please try again in an hour.", RQ_QNICK);
+ "channel at this time. Please try again in an hour.", rq_qnick->content);
lr_notargets++;
sendnoticetouser(svc, np, "Success! %s has been added to '%s' "
"(contact #help if you require further assistance).",
- RQ_QNICK, cp->index->name->content);
+ rq_qnick->content, cp->index->name->content);
return RQ_OK;
}
#include <string.h>
#include "../localuser/localuser.h"
#include "../localuser/localuserchannel.h"
+#include "../core/config.h"
#include "../core/schedule.h"
#include "../lib/irc_string.h"
#include "../lib/splitline.h"
/* log fd */
FILE *rq_logfd;
+/* config */
+sstring *rq_qserver, *rq_qnick, *rq_sserver, *rq_snick;
+sstring *rq_nick, *rq_user, *rq_host, *rq_real, *rq_auth;
+int rq_authid;
+
static int extloaded = 0;
void _init(void) {
+ sstring *m;
+
if(!rq_initblocks())
return;
extloaded = 1;
+ rq_nick = getcopyconfigitem("request", "nick", "R", BUFSIZE);
+ rq_user = getcopyconfigitem("request", "user", "request", BUFSIZE);
+ rq_host = getcopyconfigitem("request", "host", "request.quakenet.org", BUFSIZE);
+ rq_real = getcopyconfigitem("request", "real", "Service Request v0.23", BUFSIZE);
+ rq_auth = getcopyconfigitem("request", "auth", "R", BUFSIZE);
+ rq_qnick = getcopyconfigitem("request", "qnick", "Q", BUFSIZE);
+ rq_qserver = getcopyconfigitem("request", "qserver", "CServe.quakenet.org", BUFSIZE);
+ rq_snick = getcopyconfigitem("request", "snick", "S", BUFSIZE);
+ rq_sserver = getcopyconfigitem("request", "sserver", "services2.uk.quakenet.org", BUFSIZE);
+
+ m = getconfigitem("request", "authid");
+ if (!m)
+ rq_authid = 1780711;
+ else
+ rq_authid = atoi(m->content);
+
rqcommands = newcommandtree();
addcommandtotree(rqcommands, "showcommands", RQU_ANY, 1, &rqcmd_showcommands);
qr_initrequest();
- rq_logfd = fopen(RQ_LOGFILE, "a");
+ rq_logfd = fopen("logs/request.log", "a");
scheduleoneshot(time(NULL) + 1, (ScheduleCallback)&rq_registeruser, NULL);
}
rq_finifasttrack();
qr_finirequest();
+ freesstring(rq_nick);
+ freesstring(rq_user);
+ freesstring(rq_host);
+ freesstring(rq_real);
+ freesstring(rq_auth);
+
if (rq_logfd != NULL)
fclose(rq_logfd);
void rq_registeruser(void) {
channel *cp;
- rqnick = registerlocaluserflags(RQ_REQUEST_NICK, RQ_REQUEST_USER, RQ_REQUEST_HOST,
- RQ_REQUEST_REAL, RQ_REQUEST_AUTH, RQ_REQUEST_AUTHID, 0,
+ rqnick = registerlocaluserflags(rq_nick->content, rq_user->content, rq_host->content,
+ rq_real->content, rq_auth->content, rq_authid, 0,
UMODE_ACCOUNT | UMODE_SERVICE | UMODE_OPER,
rq_handler);
- cp = findchannel(RQ_TLZ);
+ cp = findchannel("#twilightzone");
if (cp == NULL)
- localcreatechannel(rqnick, RQ_TLZ);
+ localcreatechannel(rqnick, "#twilightzone");
else
localjoinchannel(rqnick, cp);
}
return RQ_ERROR;
}
- *qnick = getnickbynick(RQ_QNICK);
+ *qnick = getnickbynick(rq_qnick->content);
- if (*qnick == NULL || findserver(RQ_QSERVER) < 0) {
+ if (*qnick == NULL || findserver(rq_qserver->content) < 0) {
sendnoticetouser(rqnick, np, "Error: %s does not seem to be online. "
- "Please try again later.", RQ_QNICK);
+ "Please try again later.", rq_qnick->content);
return RQ_ERROR;
}
qhand = getnumerichandlefromchanhash(cp->users, qnick->numeric);
if (qhand != NULL) {
- sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", RQ_QNICK);
+ sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", rq_qnick->content);
rq_failed++;
strftime(now, sizeof(now), "%c", localtime(&now_ts));
fprintf(rq_logfd, "%s: request (%s) for %s from %s!%s@%s%s%s: Request was %s.\n",
- now, RQ_QNICK, cp->index->name->content,
+ now, rq_qnick->content, cp->index->name->content,
np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"",
(retval == RQ_OK) ? "accepted" : "denied");
fflush(rq_logfd);
return RQ_ERROR;
}
- snick = getnickbynick(RQ_SNICK);
+ snick = getnickbynick(rq_snick->content);
- if (snick == NULL || findserver(RQ_SSERVER) < 0) {
+ if (snick == NULL || findserver(rq_sserver->content) < 0) {
sendnoticetouser(rqnick, np, "Error: %s does not seem to be online. "
- "Please try again later.", RQ_SNICK);
+ "Please try again later.", rq_snick->content);
rq_failed++;
shand = getnumerichandlefromchanhash(cp->users, snick->numeric);
if (shand != NULL) {
- sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", RQ_SNICK);
+ sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", rq_snick->content);
rq_failed++;
/* channel apparently doesn't have Q */
sendnoticetouser(rqnick, np, "Error: You need %s in order to be "
- "able to request %s.", RQ_QNICK, RQ_SNICK);
+ "able to request %s.", rq_qnick->content, rq_snick->content);
rq_failed++;
-#define RQ_TLZ "#twilightzone"
-
-#define RQ_QSERVER "CServe.quakenet.org"
-#define RQ_QNICK "Q"
-
-#define RQ_SSERVER "services2.uk.quakenet.org"
-#define RQ_SNICK "S"
-
-#define RQ_REQUEST_NICK "R"
-#define RQ_REQUEST_USER "request"
-#define RQ_REQUEST_HOST "request.quakenet.org"
-#define RQ_REQUEST_REAL "Service Request v0.23"
-#define RQ_REQUEST_AUTH "R"
-#define RQ_REQUEST_AUTHID 1780711
+#include "../lib/sstring.h"
#define RQU_ANY 0
#define RQU_OPER 1
-#define RQ_LOGFILE "logs/request.log"
-
#define RQ_OK 0
#define RQ_ERROR 1
#define RQ_UNKNOWN 2
extern FILE *rq_logfd;
+/* config */
+extern sstring *rq_qserver, *rq_qnick, *rq_sserver, *rq_snick;
+extern sstring *rq_nick, *rq_user, *rq_host, *rq_real, *rq_auth;
+extern int rq_authid;
+
char *rq_longtoduration(unsigned long interval);
strftime(now, sizeof(now), "%c", localtime(&now_ts));
fprintf(rq_logfd, "%s: request (%s) for %s (%d unique users, "
"%d total users) from %s!%s@%s%s%s: Request was %s (%c).\n", now,
- (req->what == QR_CSERVE) ? RQ_QNICK : RQ_SNICK,
+ (req->what == QR_CSERVE) ? rq_qnick->content : rq_snick->content,
req->cip->name->content, unique, total,
tnp->nick, tnp->ident, tnp->host->name->content, IsAccount(tnp)?"/":"", IsAccount(tnp)?tnp->authname:"",
(outcome == QR_OK) ? "accepted" : "denied", failcode);
if (req->what == QR_SPAMSCAN) {
/* Add S */
- if (!(snp=getnickbynick(RQ_SNICK))) {
+ if (!(snp=getnickbynick(rq_snick->content))) {
sendnoticetouser(rqnick, tnp,
"Cannot find %s on the network. "
- "Please try your request again later.", RQ_SNICK);
+ "Please try your request again later.", rq_snick->content);
free(req);
return;
sendnoticetouser(rqnick, tnp, "Success! %s has been added to '%s' "
"(contact #help if you require further assistance).",
- RQ_SNICK, req->cip->name->content);
+ rq_snick->content, req->cip->name->content);
/* auth */
user = (sstring *)getcopyconfigitem("request", "user", "R", 30);
/* make sure we can actually add Q */
if (what == QR_CSERVE) {
- qbot = getnickbynick(RQ_QNICK);
+ qbot = getnickbynick(rq_qnick->content);
if (!qbot)
return 0;
int delrequest = 0, state, who;
requestrec *nextreq;
- if (!ircd_strcmp(sender->nick, RQ_QNICK) && nextqreq) {
+ if (!ircd_strcmp(sender->nick, rq_qnick->content) && nextqreq) {
/* Message from Q */
if (!ircd_strcmp(message,"Done.")) {
/* Q added the channel: delete from L and tell the user. */
}
}
- if (!ircd_strcmp(sender->nick, RQ_QNICK)) {
+ if (!ircd_strcmp(sender->nick, rq_qnick->content)) {
who = QR_Q;
state = (who == QR_Q) ? rqstate : rlstate;
nextreq = (who == QR_Q) ? nextreqq : nextreql;
qr_result(nextreq, QR_OK, '-', "OK");
} else {
qr_result(nextreq, QR_FAILED, failcode,
- "Error: Sorry, Your channel '%s' does not require %s. Please try again in a few days.", nextreq->cip->name->content, RQ_SNICK);
+ "Error: Sorry, Your channel '%s' does not require %s. Please try again in a few days.", nextreq->cip->name->content, rq_snick->content);
qr_toosmall++;
}
sendnoticetouser(rqnick, sender,
"Checking your %s access in '%s'. "
"This may take a while, please be patient...",
- RQ_QNICK, cip->name->content);
+ rq_qnick->content, cip->name->content);
return RQ_UNKNOWN;
}
return CMD_USAGE;
tree = NSASTNode(tgroup_parse, NSASTLiteral(cargv[0]));
- return ast_nicksearch(&tree, controlreply, sender, NULL, printnick_channels, NULL, NULL, 2000);
+ return ast_nicksearch(&tree, controlreply, sender, NULL, printnick_channels, NULL, NULL, 2000, NULL);
}
static int commandsregistered;
#include "../core/schedule.h"
#include "../irc/irc.h"
#include "../lib/stringbuf.h"
-#include "../noperserv/noperserv.h"
-#include "../noperserv/noperserv_policy.h"
+#include "../control/control.h"
+#include "../control/control_policy.h"
#include "trusts.h"
MODULE_VERSION("");
projects / irc / quakenet / newserv.git / commitdiff
