int ca_carrot(void *source, int cargc, char **cargv) {
nick *sender=(nick *)source;
nick *victim;
channel *cp;
if (cargc<1)
return CMD_USAGE;
if ((victim=getnickbynick(cargv[0]))!=NULL) {
controlreply(victim,"%cACTION ger %s en morot%c",1,victim->nick,1);
controlreply(sender,"Gave %s a carrot.",victim->nick);
} else if ((cp=findchannel(cargv[0]))!=NULL) {
if (cargc>1) {
controlchanmsg(cp,"%cACTION ger %s en morot%c",1,cargv[1],1);
} else {
controlchanmsg(cp,"%cACTION waves a carrot around menacingly.%c",1,1);
}
controlreply(sender,"Used carrot in %s.",cp->index->name->content);
} else {
controlreply(sender,"Couldn't find %s.",cargv[0]);
}
return CMD_OK;
}
int handle_countrywhois(struct rline *li, int argc, char **argv) {
int result;
char *longcountry, *shortcountry, *shortcountry3;
nick *np = getnickbynick(argv[0]);
if(!np)
return ri_error(li, ERR_TARGET_NOT_FOUND, "User not online");
result = (int)((long)np->exts[country_nickext]);
if((result < COUNTRY_MIN) || (result > COUNTRY_MAX))
result = -1;
if(!GeoIP_country_info_by_id(result, &shortcountry, &shortcountry3, &longcountry))
result = -1;
ri_append(li, "%d", result);
if(result == -1) {
ri_append(li, "%s", "!!");
ri_append(li, "%s", "!!");
ri_append(li, "%s", "Error");
} else {
ri_append(li, "%s", shortcountry);
ri_append(li, "%s", shortcountry3);
ri_append(li, "%s", longcountry);
}
return ri_final(li);
}
struct searchNode *nick_parse(searchCtx *ctx, int argc, char **argv) {
struct nick_localdata *localdata;
struct searchNode *thenode;
if (!(localdata=(struct nick_localdata *)malloc(sizeof(struct nick_localdata)))) {
parseError = "malloc: could not allocate memory for this search.";
return NULL;
}
if (ctx->searchcmd == reg_chansearch) {
struct searchNode *nickname;
char *p;
if (argc!=1) {
parseError="nick: usage: (nick target)";
free(localdata);
return NULL;
}
if (!(nickname=argtoconststr("nick", ctx, argv[0], &p))) {
free(localdata);
return NULL;
}
localdata->np=getnickbynick(p);
(nickname->free)(ctx, nickname);
if (localdata->np==NULL) {
parseError="nick: unknown nickname";
free(localdata);
return NULL;
}
} else {
if (argc) {
parseError="nick: usage: (match (nick) target)";
free(localdata);
return NULL;
}
localdata->np = NULL;
}
if (!(thenode=(struct searchNode *)malloc(sizeof(struct searchNode)))) {
/* couldn't malloc() memory for thenode, so free localdata to avoid leakage */
parseError = "malloc: could not allocate memory for this search.";
free(localdata);
return NULL;
}
if (ctx->searchcmd == reg_chansearch)
thenode->returntype = RETURNTYPE_BOOL;
else
thenode->returntype = RETURNTYPE_STRING;
thenode->localdata = localdata;
thenode->exe = nick_exe;
thenode->free = nick_free;
return thenode;
}
int hchannel_highlight_detection(hchannel *hchan, const char *message)
{
char buffer[512], *buffer_ptr = buffer, *ptr = buffer;
int i, matches = 0;
strcpy(buffer, message);
/* remove commas */
for (i=0;i<512 && buffer[i] != '\0';i++)
if (buffer[i] == ',')
buffer[i] = ' ';
/* reset i for loop */
i = 0;
do
{
nick *tmp;
huser *tmp_huser;
huser_channel *tmp_huserchan;
if (i++ > 6)
break;
while (*buffer_ptr && isspace(*buffer_ptr))
buffer_ptr++;
if (*buffer_ptr == '@')
buffer_ptr++;
if (*buffer_ptr)
{
ptr = strchr(buffer_ptr, ' ');
if (ptr)
{
*ptr = '\0';
ptr++;
}
if ((tmp = getnickbynick(buffer_ptr)))
if ((tmp_huser = huser_get(tmp)))
if ((tmp_huserchan = huser_on_channel(tmp_huser, hchan)))
if ((tmp_huserchan->flags & HCUMODE_OP) && strlen(huser_get_nick(tmp_huser)) > 1)
matches++;
}
if (ptr == NULL)
break;
else
buffer_ptr = ptr;
} while (*ptr);
if (matches > 2)
return 1;
else
return 0;
}
void patrol_nickchange(nick *np) {
char c_nick[NICKLEN + 1];
int loops = 0;
/* PPA: unlikely to be infinite */
do {
if ((loops++ < 10) && patrol_hostmode) {
patrol_generatenick(c_nick, NICKLEN);
} else {
patrol_gennick(c_nick, patrol_minmaxrand(7, PATROL_MMIN(13, NICKLEN)));
}
} while (c_nick[0] && (getnickbynick(c_nick) != NULL));
renamelocaluser(np, c_nick);
}
static void reconnectfakeuser(void *arg) {
fakeuser *fake = arg;
nick *user;
if (fake->user)
return;
if ((user = getnickbynick(fake->nick)) && (IsOper(user) || IsService(user) || IsXOper(user))) {
fake_remove(fake);
return;
}
fake->user = registerlocaluser(fake->nick, fake->ident, fake->host, fake->realname,
NULL, UMODE_INV | UMODE_DEAF, &fakeuser_handler);
}
int versionscan_scan(void* sender, int cargc, char** cargv) {
nick* np=(nick*)sender;
nick* n;
channel* cp;
if (cargc < 1) {
sendnoticetouser(versionscan_nick, np, "Syntax: scan <target>");
return CMD_ERROR;
}
if (versionscan_mode != VS_SCAN) {
sendnoticetouser(versionscan_nick, np, "Scanning of users is currently disabled.");
return CMD_ERROR;
}
if (cargv[0][0] == '#') {
if ((cp=findchannel(cargv[0]))) {
sendmessagetochannel(versionscan_nick, cp, "\001VERSION\001");
sendnoticetouser(versionscan_nick, np, "Done.");
}
else {
sendnoticetouser(versionscan_nick, np, "No such channel.");
return CMD_ERROR;
}
}
else {
if ((n=getnickbynick(cargv[0]))) {
if (IsOper(n)) {
sendnoticetouser(versionscan_nick, np, "Cannot scan IRC Operators.");
return CMD_ERROR;
}
sendmessagetouser(versionscan_nick, n, "\001VERSION\001");
sendnoticetouser(versionscan_nick, np, "Done.");
}
else {
sendnoticetouser(versionscan_nick, np, "No such nick.");
return CMD_ERROR;
}
}
return CMD_OK;
}
nick *patrol_generateclone(int extraumodes, UserMessageHandler handler) {
int loops = 0, modes = UMODE_XOPER | UMODE_INV | extraumodes;
char c_nick[NICKLEN + 1], c_ident[USERLEN + 1], c_host[HOSTLEN + 1], c_real[REALLEN + 1];
struct irc_in_addr ipaddress;
/* PPA: unlikely to be infinite */
do {
c_nick[0] = '\0';
if (!loops && patrol_hostmode) /* only have one go at this */
patrol_generatenick(c_nick, NICKLEN);
if (!c_nick[0])
patrol_gennick(c_nick, patrol_minmaxrand(7, PATROL_MMIN(13, NICKLEN)));
loops++;
} while ((getnickbynick(c_nick) != NULL));
patrol_generateident(c_ident, USERLEN);
if (!c_ident[0])
patrol_genident(c_ident, patrol_minmaxrand(4, PATROL_MMIN(8, USERLEN)));
if (patrol_hostmode) {
patrol_generatehost(c_host, HOSTLEN, &ipaddress);
if (!c_host[0])
patrol_genhost(c_host, HOSTLEN, &ipaddress);
} else {
patrol_genhost(c_host, HOSTLEN, &ipaddress);
}
patrol_generaterealname(c_real, REALLEN);
if (!c_real[0])
patrol_genreal(c_real, patrol_minmaxrand(15, PATROL_MMIN(50, REALLEN)));
return registerlocaluserflagsip(c_nick, c_ident, c_host, c_real, NULL, 0, 0, modes, &ipaddress, handler);
}
int versionscan_whois(void* sender, int cargc, char** cargv) {
nick* np=(nick*)sender;
nick* target;
vsauthdata* v;
if (cargc < 1) {
sendnoticetouser(versionscan_nick, np, "Syntax: whois <nickname>");
return CMD_ERROR;
}
if (!(target=getnickbynick(cargv[0]))) {
sendnoticetouser(versionscan_nick, np, "No such nick.");
return CMD_ERROR;
}
if (!IsAccount(target)) {
sendnoticetouser(versionscan_nick, np, "%s is not authed with the network.", target->nick);
return CMD_ERROR;
}
if (!(v=versionscan_getauthbyauth(target->authname))) {
sendnoticetouser(versionscan_nick, np, "User %s is not in my database.", target->nick);
return CMD_ERROR;
}
sendnoticetouser(versionscan_nick, np, "%s is authed as %s, with flags: %s", target->nick, target->authname, versionscan_flagstochar(v->flags));
return CMD_OK;
}
int dofsck(void *source, int cargc, char **cargv) {
int i,j;
nick *sender=source, *np, *np2;
host *hp;
realname *rnp;
unsigned int nickmarker;
int errors=0;
unsigned int nummask,mnum;
/* Start off with strict nick consistency checks.. */
controlreply(sender,"- Performing nickname checks");
nickmarker=nextnickmarker();
for(i=0;i<HOSTHASHSIZE;i++)
for(hp=hosttable[i];hp;hp=hp->next)
hp->marker=0;
for(i=0;i<REALNAMEHASHSIZE;i++)
for(rnp=realnametable[i];rnp;rnp=rnp->next)
rnp->marker=0;
controlreply(sender," - Scanning nick hash table");
for (i=0;i<NICKHASHSIZE;i++) {
for(np=nicktable[i];np;np=np->next) {
if (np->marker==nickmarker) {
controlreply(sender, "ERROR: bumped into the same nick %s/%s twice in hash table.",longtonumeric(np->numeric,5),np->nick);
errors++;
}
/* Mark this nick so we can check we found them all */
np->marker=nickmarker;
/* Check that we can find this nick with the lookup functions */
if (getnickbynick(np->nick) != np) {
controlreply(sender, "ERROR: can't find %s/%s using getnickbynick().",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (getnickbynumeric(np->numeric) != np) {
controlreply(sender, "ERROR: can't find %s/%s using getnickbynumeric().",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
/* Check that the nick appears in the list of nicks using its host */
if (findhost(np->host->name->content) != np->host) {
controlreply(sender, "ERROR: can't find %s/%s's host (%s) using findhost().",
longtonumeric(np->numeric,5),np->nick,np->host->name->content);
errors++;
}
for(np2=np->host->nicks;np2;np2=np2->nextbyhost)
if (np2==np)
break;
if (!np2) {
controlreply(sender, "ERROR: can't find %s/%s (host=%s) on the host users list.",
longtonumeric(np->numeric,5),np->nick,np->host->name->content);
errors++;
}
np->host->marker++;
/* Same for realnames */
if (findrealname(np->realname->name->content) != np->realname) {
controlreply(sender, "ERROR: can't find %s/%s's realname (%s) using findrealname().",
longtonumeric(np->numeric,5),np->nick,np->realname->name->content);
errors++;
}
for(np2=np->realname->nicks;np2;np2=np2->nextbyrealname)
if (np2==np)
break;
if (!np2) {
controlreply(sender,
"ERROR: can't find %s/%s (realname=%s) on the realname users list.",
longtonumeric(np->numeric,5),np->nick,np->realname->name->content);
errors++;
}
np->realname->marker++;
if (IsAccount(np) && !np->authname[0]) {
controlreply(sender, "ERROR: nick %s/%s is +r but no authname stored.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
/*
if (!IsAccount(np) && np->authname[0]) {
controlreply(sender, "ERROR: nick %s/%s is -r but carries authname '%s'.",
longtonumeric(np->numeric,5),np->nick,np->authname);
errors++;
}
*/
if (IsSetHost(np) && (!np->sethost || !np->shident)) {
controlreply(sender, "ERROR: nick %s/%s is +h but nick or hostname not set.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (!IsSetHost(np) && (np->sethost || np->shident)) {
controlreply(sender, "ERROR: nick %s/%s is -h but has nick or hostname set.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
}
}
controlreply(sender," - Scanning server user tables");
for(i=0;i<MAXSERVERS;i++) {
if (serverlist[i].linkstate != LS_INVALID) {
nummask=((MAXSERVERS-1)<<18) | serverlist[i].maxusernum;
for (j=0;j<=serverlist[i].maxusernum;j++) {
if ((np=servernicks[i][j])) {
mnum=(i<<18) | j;
if ((np->numeric & nummask) != mnum) {
controlreply(sender, "ERROR: nick %s/%s has wrong masked numeric.",longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (np->marker != nickmarker) {
controlreply(sender, "ERROR: nick %s/%s in server user table but not hash!",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
np->marker=0;
}
}
}
}
controlreply(sender," - Scanning host and realname tables");
for (i=0;i<HOSTHASHSIZE;i++) {
for (hp=hosttable[i];hp;hp=hp->next) {
/* Check that the user counts match up */
if (hp->clonecount != hp->marker) {
controlreply(sender,
"ERROR: host %s has inconsistent clone count (stored=%d, measured=%u)",
hp->name->content,hp->clonecount,hp->marker);
errors++;
}
for (np=hp->nicks;np;np=np->nextbyhost) {
if (np->host != hp) {
controlreply(sender,
"ERROR: nick %s/%s is in list for wrong host "
"(in list for %s, actual host %s).",
longtonumeric(np->numeric,5),np->nick,hp->name->content,
np->host->name->content);
errors++;
}
}
hp->marker=0;
}
}
for (i=0;i<REALNAMEHASHSIZE;i++) {
for (rnp=realnametable[i];rnp;rnp=rnp->next) {
if (rnp->usercount != rnp->marker) {
controlreply(sender,
"ERROR: realname '%s' has inconsistent clone count "
"(stored=%d, measured=%d).",
rnp->name->content,rnp->usercount,rnp->marker);
errors++;
}
for (np=rnp->nicks;np;np=np->nextbyrealname) {
if (np->realname != rnp) {
controlreply(sender,
"ERROR: nick %s/%s is in list for wrong realname "
"(in list for '%s', actual realname '%s').",
longtonumeric(np->numeric,5),np->nick,
rnp->name->content, np->realname->name->content);
errors++;
}
}
rnp->marker=0;
}
}
if (errors)
controlreply(sender,"All checks complete. %d errors found.",errors);
else
controlreply(sender,"All checks complete. No errors found.");
return CMD_OK;
}
int versionscan_changelev(void* sender, int cargc, char** cargv) {
nick* np=(nick*)sender;
vsauthdata* v;
nick* target;
unsigned char flags=0;
int i; int plus=1;
if (cargc < 2) {
sendnoticetouser(versionscan_nick, np, "Syntax: changelev <nick> [+|-]<level>");
return CMD_ERROR;
}
if (!(target=getnickbynick(cargv[0]))) {
sendnoticetouser(versionscan_nick, np, "No such nick.");
return CMD_ERROR;
}
if (!IsAccount(target)) {
sendnoticetouser(versionscan_nick, np, "%s is not authed.", target->nick);
return CMD_ERROR;
}
if ((v=versionscan_getauthbyauth(target->authname))) {
i=0;
if ((cargv[1][0] == '+') || (cargv[1][0] =='-')) {
plus=(cargv[1][0] == '+')?1:0;
i++;
flags=v->flags;
}
for (; cargv[1][i]; i++) {
switch (cargv[1][i]) {
case 'a':
flags=(plus)?flags | VS_ADMIN:flags & (~VS_ADMIN);
break;
case 'g':
flags=(plus)?flags | VS_GLINE:flags & (~VS_GLINE);
break;
case 's':
flags=(plus)?flags | VS_STAFF:flags & (~VS_STAFF);
break;
default:
sendnoticetouser(versionscan_nick, np, "Invalid level '%c'.", cargv[1][i]);
return CMD_ERROR;
break;
}
}
if (!flags) {
vsauthdata* pv, *prevv;
prevv=0;
for (pv=vsauths; pv; pv++) {
if (pv == v) {
if (prevv) {
prevv->next=pv->next;
free(pv);
}
else {
vsauths=pv->next;
free(pv);
}
break;
}
prevv=pv;
}
}
else {
v->flags=flags;
}
sendnoticetouser(versionscan_nick, np, "Done.");
return CMD_OK;
}
else {
i=0;
if ((cargv[1][0] == '+') || (cargv[1][0] =='-')) {
plus=(cargv[1][0] == '+')?1:0;
i++;
}
for (; cargv[1][i]; i++) {
switch (cargv[1][i]) {
case 'a':
flags=(plus)?flags | VS_ADMIN:flags & (~VS_ADMIN);
break;
case 'g':
flags=(plus)?flags | VS_GLINE:flags & (~VS_GLINE);
break;
case 's':
flags=(plus)?flags | VS_STAFF:flags & (~VS_STAFF);
break;
default:
sendnoticetouser(versionscan_nick, np, "Invalid level '%c'.", cargv[1][i]);
return CMD_ERROR;
break;
}
}
if (flags) {
for (v=vsauths; v; v=v->next) {
if (!v->next) {
v->next=(vsauthdata*)malloc(sizeof(vsauthdata));
strncpy(v->next->account, target->authname, ACCOUNTLEN);
v->next->flags=flags;
v->next->next=0;
sendnoticetouser(versionscan_nick, np, "Done.");
return CMD_OK;
}
}
sendnoticetouser(versionscan_nick, np, "Error adding user to database.");
}
else {
sendnoticetouser(versionscan_nick, np, "No level specified.");
}
}
return CMD_ERROR;
}
/* handle remote trace request
*
* <source numeric> TRACE/TR <target> <target server numeric>
*
* cargv[0] = target
* as given by source, can be a nick or a server (may contain wildcards)
* cargv[1] = target server numeric
*
*/
int handletracemsg(void *source, int cargc, char **cargv) {
nick *snick; /* struct nick for source nick */
nick *tnick; /* struct nick for target nick */
nick **lnick; /* struct nick for looping local users */
int c; /* loop variable */
int opers = 0; /* number of operators */
int users = 0; /* number of users */
int servers = 0; /* number of servers */
int doall, wilds, dow; /* determine what to show */
char *sourcenum = (char *)source; /* source user numeric */
char *target; /* target parameter - as given by the source user */
/* check parameters */
if (cargc < 2) {
miscreply_needmoreparams(sourcenum, "TRACE");
return CMD_OK;
}
/* get the parameters */
target = cargv[0];
/* find source user */
if (!(snick = miscreply_finduser(sourcenum, "TRACE")))
return CMD_OK;
/* doall, wilds, dow */
doall = match2strings(target, myserver->content);
wilds = strchr(target, '*') || strchr(target, '?');
dow = wilds || doall;
/* find target user */
if ((tnick = getnickbynick(target))) {
/* my user */
if (mylongnum == homeserver(tnick->numeric))
trace_user(sourcenum, tnick);
}
/* source user is an operator */
else if (IsOper(snick)) {
/* show servers */
servers = trace_server(sourcenum, target, doall);
/* do all or wilds */
if (dow) {
/* loop over all local users */
lnick = servernicks[mylongnum];
for (c = 0; c < serverlist[mylongnum].maxusernum; c++) {
if (lnick[c] == NULL) /* no user */
continue;
/* target is invisible (mode +i), target is not an operator */
if (IsInvisible(lnick[c]) && dow && !IsOper(lnick[c]))
continue;
/* dont show all, do wildcards and no match */
if (!doall && wilds && !match2strings(target, lnick[c]->nick))
continue;
if (IsOper(lnick[c]))
opers++;
else
users++;
trace_user(sourcenum, lnick[c]);
}
/*
* class has no meaning here,
* but showing the total count for users/opers/servers might be useful anyway
*
* 209 RPL_TRACECLASS "source 209 target Class class count"
* "irc.netsplit.net 209 foobar Class users 2"
*/
if (users)
irc_send("%s 209 %s Class users %d", getmynumeric(), sourcenum, users);
if (opers)
irc_send("%s 209 %s Class opers %d", getmynumeric(), sourcenum, opers);
if (servers)
irc_send("%s 209 %s Class servers %d", getmynumeric(), sourcenum, servers);
}
}
/*
* 262 RPL_TRACEEND "source 262 target :End of TRACE"
* "irc.netsplit.net 262 foobar :End of TRACE"
*/
irc_send("%s 262 %s :End of TRACE", getmynumeric(), sourcenum);
return CMD_OK;
}
void helpmod_queue_handler (huser *sender, channel* returntype, hchannel *hchan, int hqueue_action, char* ostr, int argc, char *argv[])
{
if (hchan == NULL)
{
helpmod_reply(sender, returntype, "Can not handle queue: Channel not defined or not found");
return;
}
switch (hqueue_action) /* easy ones */
{
case HQ_ON:
if (hchan->flags & H_QUEUE)
helpmod_reply(sender, returntype, "Can not activate queue: Queue is already active on channel %s", hchannel_get_name(hchan));
else
{
hchan->flags |= H_QUEUE;
helpmod_reply(sender, returntype, "Queue activated for channel %s", hchannel_get_name(hchan));
hchannel_conf_change(hchan, hchan->flags & ~(H_QUEUE));
hchan->autoqueue = 0;
}
return;
case HQ_OFF:
if (!(hchan->flags & H_QUEUE))
helpmod_reply(sender, returntype, "Can not deactive queue: Queue is not active on %s", hchannel_get_name(hchan));
else
{
hchan->flags &= ~H_QUEUE;
helpmod_reply(sender, returntype, "Queue deactivated for channel %s", hchannel_get_name(hchan));
hchannel_conf_change(hchan, hchan->flags | H_QUEUE);
hchan->autoqueue = 0;
{ /* devoice all users of level H_PEON */
hchannel_user *hchanuser;
huser_channel *huserchan;
for (hchanuser = hchan->channel_users;hchanuser != NULL;hchanuser = hchanuser->next)
{
huserchan = huser_on_channel(hchanuser->husr, hchan);
if (huser_get_level(hchanuser->husr) == H_PEON && huserchan->flags & HCUMODE_VOICE)
helpmod_channick_modes(hchanuser->husr, hchan, MC_DEVOICE, HLAZY);
}
}
}
return;
}
if (!(hchan->flags & H_QUEUE))
{
helpmod_reply(sender, returntype, "Can not handle queue: Queue not active on channel %s", hchannel_get_name(hchan));
return;
}
/* now to the real deal */
switch (hqueue_action)
{
case HQ_DONE:
{
int i;
if (argc == 0)
{
helpmod_reply(sender, returntype, "Can not advance queue: User not specified");
return;
}
if (argc > H_CMD_MAX_ARGS)
argc = H_CMD_MAX_ARGS;
for (i=0;i<argc;i++)
{
huser *husr = huser_get(getnickbynick(argv[i]));
if (husr == NULL)
{
helpmod_reply(sender, returntype, "Can not advance queue: User %s not found", argv[i]);
continue;
}
helpmod_channick_modes(husr, hchan, MC_DEVOICE, HLAZY);
}
hqueue_handle_queue(hchan, sender);
}
return;
case HQ_NEXT:
{
int nnext = 1;
if (argc > 0)
{
if (!sscanf(argv[0], "%d", &nnext) || nnext <= 0 || nnext > 25 /* magic number */)
{
helpmod_reply(sender, returntype, "Can not advance queue: Integer [1, 25] expected");
return;
}
}
hqueue_advance(hchan, sender, nnext);
}
return;
case HQ_MAINTAIN:
{
int tmp;
if (argc == 0)
{
helpmod_reply(sender, returntype, "Autoqueue for channel %s is currently %d (%s)", hchannel_get_name(hchan), hchan->autoqueue, hchannel_get_state(hchan, H_QUEUE_MAINTAIN));
return;
}
if (!sscanf(argv[0], "%d", &tmp) || tmp < 0 || tmp > 25)
{
helpmod_reply(sender, returntype, "Can not set auto queue: Integer [0, 20] expected");
return;
}
hchan->autoqueue = tmp;
if (tmp == 0)
{
if (hchan->flags & H_QUEUE_MAINTAIN)
{
hchan->flags &= ~(H_QUEUE_MAINTAIN);
helpmod_reply(sender, returntype, "Autoqueue is now disabled for channel %s", hchannel_get_name(hchan));
}
else
helpmod_reply(sender, returntype, "Autoqueue is not enabled for channel %s", hchannel_get_name(hchan));
}
else if (!(hchan->flags & H_QUEUE_MAINTAIN))
{
hchan->flags |= H_QUEUE_MAINTAIN;
helpmod_reply(sender, returntype, "Autoqueue for channel %s activated and set to %d succesfully", hchannel_get_name(hchan), hchan->autoqueue);
}
else
helpmod_reply(sender, returntype, "Autoqueue for channel %s set to %d succesfully", hchannel_get_name(hchan), hchan->autoqueue);
hqueue_handle_queue(hchan, sender);
}
return;
case HQ_LIST:
{
int count = hqueue_count_in_queue(hchan);
hqueue_entry *hqueue = hqueue_get_next(hchan);
char buffer[512];
buffer[0] = '\0';
helpmod_reply(sender, returntype, "Channel %s has following users in queue (%d user%s total):", hchannel_get_name(hchan), count, (count==1)?"":"s");
for (;hqueue;hqueue = hqueue_get_next(NULL))
{
if (strlen(buffer) >= 250)
{
helpmod_reply(sender, returntype, "%s", buffer);
buffer[0] = '\0';
}
if (hqueue_on_queue(hqueue))
sprintf(buffer+strlen(buffer) /* :) */, "%s (%s@%s) [%s] ", huser_get_nick(hqueue->hchanuser->husr), huser_get_ident(hqueue->hchanuser->husr), huser_get_host(hqueue->hchanuser->husr), helpmod_strtime(time(NULL) - hqueue->hchanuser->time_joined));
}
if (buffer[0])
helpmod_reply(sender, returntype, "%s", buffer);
}
return;
case HQ_NONE: /* if no parameters are given print the summary */
case HQ_SUMMARY:
{
int count_on = hqueue_count_in_queue(hchan);
int count_off = hqueue_count_off_queue(hchan);
int average = hqueue_average_time(hchan);
helpmod_reply(sender, returntype, "Channel %s has %d user%s in queue, %d user%s being helped, average time in queue %s", hchannel_get_name(hchan), count_on, (count_on==1)?"":"s", count_off, (count_off==1)?"":"s", helpmod_strtime(average));
}
return;
case HQ_RESET:
{
hchannel_user *hchanuser = hchan->channel_users;
for (;hchanuser;hchanuser = hchanuser->next)
{
if (huser_get_level(hchanuser->husr) == H_PEON)
{
huser_channel *huserchan = huser_on_channel(hchanuser->husr, hchan);
assert (huserchan != NULL);
if (huserchan->flags & HCUMODE_VOICE)
helpmod_channick_modes(hchanuser->husr, hchan, MC_DEVOICE, HLAZY);
huserchan->flags &= ~(HQUEUE_DONE | H_IDLE_WARNING);
}
}
if (!IsModerated(hchan->real_channel))
helpmod_simple_modes(hchan, CHANMODE_MODERATE, 0, 0);
helpmod_message_channel(hchan, "Channel queue has been reset");
helpmod_reply(sender, returntype, "Queue for channel %s has been reset", hchannel_get_name(hchan));
}
return;
}
}
