static void cs_cmd_set_keeptopic(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET KEEPTOPIC");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this command."));
return;
}
if (!strcasecmp("ON", parv[1]))
{
if (MC_KEEPTOPIC & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "KEEPTOPIC", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:KEEPTOPIC:ON: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 enabled the KEEPTOPIC flag"), get_source_name(si));
mc->flags |= MC_KEEPTOPIC;
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "KEEPTOPIC", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
if (!(MC_KEEPTOPIC & mc->flags))
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "KEEPTOPIC", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:KEEPTOPIC:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the KEEPTOPIC flag"), get_source_name(si));
mc->flags &= ~(MC_KEEPTOPIC | MC_TOPICLOCK);
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "KEEPTOPIC", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "KEEPTOPIC");
return;
}
}
static void cs_cmd_set_restricted(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET RESTRICTED");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
if (!strcasecmp("ON", parv[1]))
{
if (MC_RESTRICTED & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "RESTRICTED", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:RESTRICTED:ON: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 enabled the RESTRICTED flag"), get_source_name(si));
mc->flags |= MC_RESTRICTED;
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "RESTRICTED", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
if (!(MC_RESTRICTED & mc->flags))
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "RESTRICTED", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:RESTRICTED:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the RESTRICTED flag"), get_source_name(si));
mc->flags &= ~MC_RESTRICTED;
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "RESTRICTED", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "RESTRICTED");
return;
}
}
static void cs_cmd_devoice(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
if (!chan)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DEVOICE");
command_fail(si, fault_needmoreparams, _("Syntax: DEVOICE <#channel> [nickname]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_VOICE))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
/* figure out who we're going to devoice */
if (!nick)
tu = si->su;
else
{
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
return;
}
}
if (is_internal_client(tu))
return;
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
return;
}
modestack_mode_param(chansvs.nick, mc->chan, MTYPE_DEL, 'v', CLIENT_NAME(tu));
cu->modes &= ~CSTATUS_VOICE;
if (si->c == NULL && tu != si->su)
change_notify(chansvs.nick, tu, "You have been devoiced on %s by %s", mc->name, get_source_name(si));
logcommand(si, CMDLOG_DO, "DEVOICE: \2%s!%s@%s\2 on \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (!chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been devoiced on \2%s\2."), tu->nick, mc->name);
}
static void cs_cmd_set_url(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
char *url = parv[1];
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!(chanacs_source_has_flag(mc, si, CA_SET) || chanacs_source_has_flag(mc, si, CA_FOUNDER)))
{
command_fail(si, fault_noprivs, _("You are not authorized to execute this command."));
return;
}
if (!url || !strcasecmp("OFF", url) || !strcasecmp("NONE", url))
{
/* not in a namespace to allow more natural use of SET PROPERTY.
* they may be able to introduce spaces, though. c'est la vie.
*/
if (metadata_find(mc, "url"))
{
metadata_delete(mc, "url");
logcommand(si, CMDLOG_SET, "SET:URL:NONE: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 cleared the channel URL."), get_source_name(si));
command_success_nodata(si, _("The URL for \2%s\2 has been cleared."), mc->name);
notify_channel_set_change(si, si->smu, mc, "URL", "Cleared");
return;
}
command_fail(si, fault_nochange, _("The URL for \2%s\2 was not set."), mc->name);
return;
}
/* we'll overwrite any existing metadata */
metadata_add(mc, "url", url);
logcommand(si, CMDLOG_SET, "SET:URL: \2%s\2 \2%s\2", mc->name, url);
verbose(mc, _("\2%s\2 set the channel URL to \2%s\2"), get_source_name(si), url);
command_success_nodata(si, _("The URL of \2%s\2 has been set to: \2%s\2"), mc->name, url);
notify_channel_set_change(si, si->smu, mc, "URL", url);
}
static void cs_cmd_set_entrymsg(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to execute this command."));
return;
}
if (!parv[1] || !strcasecmp("OFF", parv[1]) || !strcasecmp("NONE", parv[1]))
{
/* entrymsg is private because users won't see it if they're AKICKED,
* if the channel is +i, or if the channel is RESTRICTED
*/
if (metadata_find(mc, "private:entrymsg"))
{
metadata_delete(mc, "private:entrymsg");
logcommand(si, CMDLOG_SET, "SET:ENTRYMSG:NONE: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 cleared the entry message"), get_source_name(si));
command_success_nodata(si, _("The entry message for \2%s\2 has been cleared."), parv[0]);
return;
}
command_fail(si, fault_nochange, _("The entry message for \2%s\2 was not set."), parv[0]);
return;
}
/* we'll overwrite any existing metadata.
* Why is/was this even private? There are no size/content sanity checks
* and even users with no channel access can see it. --jdhore
*/
metadata_add(mc, "private:entrymsg", parv[1]);
logcommand(si, CMDLOG_SET, "SET:ENTRYMSG: \2%s\2 \2%s\2", mc->name, parv[1]);
verbose(mc, _("\2%s\2 set the entry message for the channel to \2%s\2"), get_source_name(si), parv[1]);
command_success_nodata(si, _("The entry message for \2%s\2 has been set to \2%s\2"), parv[0], parv[1]);
}
static void
cs_cmd_set_prefix(struct sourceinfo *si, int parc, char *parv[])
{
struct mychan *mc;
char *prefix = parv[1];
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to execute this command."));
return;
}
if (!prefix || !strcasecmp(prefix, "DEFAULT"))
{
metadata_delete(mc, "private:prefix");
logcommand(si, CMDLOG_SET, "SET:PREFIX: \2%s\2 reset", mc->name);
verbose(mc, _("The fantasy prefix for the channel has been reset by \2%s\2"), get_source_name(si));
command_success_nodata(si, _("The fantasy prefix for channel \2%s\2 has been reset."), parv[0]);
return;
}
if (!goodprefix(prefix))
{
command_fail(si, fault_badparams, _("Prefix '%s' is invalid. The prefix may "
"contain only printable characters, and must contain at least "
"one non-space character."), prefix);
return;
}
metadata_add(mc, "private:prefix", prefix);
logcommand(si, CMDLOG_SET, "SET:PREFIX: \2%s\2 \2%s\2", mc->name, prefix);
verbose(mc, _("\2%s\2 set the fantasy prefix to \2%s\2"), get_source_name(si), prefix);
command_success_nodata(si, _("The fantasy prefix for channel \2%s\2 has been set to \2%s\2."),
parv[0], prefix);
}
static void helpserv_cmd_helpme(sourceinfo_t *si, int parc, char *parv[])
{
char *topic = parv[0];
if ((unsigned int)(CURRTIME - ratelimit_firsttime) > config_options.ratelimit_period)
ratelimit_count = 0, ratelimit_firsttime = CURRTIME;
if (ratelimit_count > config_options.ratelimit_uses && !has_priv(si, PRIV_FLOOD))
{
command_fail(si, fault_toomany, _("The system is currently too busy to process your help request, please try again later."));
slog(LG_INFO, "HELPME:THROTTLED: %s", si->su->nick);
return;
}
if (si->smu != NULL && metadata_find(si->smu, "private:restrict:setter"))
{
command_fail(si, fault_noprivs, _("You have been restricted from requesting help by network staff."));
return;
}
command_add_flood(si, FLOOD_HEAVY);
if (topic)
{
logcommand(si, CMDLOG_ADMIN, "HELPME: \2%s\2", topic);
wallops("\2%s\2 has requested help about \2%s\2", get_source_name(si), topic);
}
else
{
logcommand(si, CMDLOG_ADMIN, "HELPME");
wallops("\2%s\2 has requested help.", get_source_name(si));
}
command_success_nodata(si, "The network staff has been notified that you need help and will be with you shortly.");
if (config_options.ratelimit_uses && config_options.ratelimit_period)
ratelimit_count++;
return;
}
static void
hs_cmd_drop(struct sourceinfo *si, int parc, char *parv[])
{
struct mynick *mn;
struct metadata *md;
char buf[BUFSIZE];
// This is only because we need a nick to copy from.
if (si->su == NULL)
{
command_fail(si, fault_noprivs, _("\2%s\2 can only be executed via IRC."), "DROP");
return;
}
mn = mynick_find(si->su->nick);
if (mn == NULL)
{
command_fail(si, fault_nosuch_target, _("Nick \2%s\2 is not registered."), si->su->nick);
return;
}
if (mn->owner != si->smu)
{
command_fail(si, fault_noprivs, _("Nick \2%s\2 is not registered to your account."), mn->nick);
return;
}
snprintf(buf, BUFSIZE, "%s:%s", "private:usercloak", mn->nick);
md = metadata_find(si->smu, buf);
if (md == NULL)
md = metadata_find(si->smu, "private:usercloak");
if (md == NULL)
{
command_success_nodata(si, _("There is not a vhost assigned to this nick."));
return;
}
hs_sethost_all(si->smu, NULL, get_source_name(si));
command_success_nodata(si, _("Dropped all vhosts for \2%s\2."), get_source_name(si));
logcommand(si, CMDLOG_ADMIN, "VHOST:DROP: \2%s\2", get_source_name(si));
do_sethost_all(si->smu, NULL); // restore user vhost from user host
}
inline void unlocked_recompile()
{
std::string source = env.get_source();
env.clear_changed();
// build
const GLchar *source_array[] =
{
source.data(),
};
glGetError();
glShaderSource(shader_id, sizeof(source_array) / sizeof(source_array[0]), source_array, nullptr);
failed = true;
throw_on_glerror<shader_exception>(get_source_name() + ": unable to set the shader source (glShaderSource)", __FILE__, __LINE__);
failed = false;
glCompileShader(shader_id);
GLint status;
glGetShaderiv(shader_id, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
failed = true;
constexpr size_t max_len = 8192;
char *message = new char[max_len];
message[0] = 0;
if (::opengl_version::debug)
glGetShaderInfoLog(shader_id, max_len, &status, message);
neam::cr::out.error() << LOGGER_INFO_TPL(ShaderSource::get_source_name(), 0) << "could not compile shader" << (::opengl_version::debug ? ":" : "") << message << std::endl;
return;
}
#ifndef YAGGLER_NO_MESSAGES
if (::opengl_version::debug)
{
constexpr size_t max_len = 8192;
char *message = new char[max_len];
message[0] = 0;
glGetShaderInfoLog(shader_id, max_len, &status, message);
if (message[0])
neam::cr::out.log() << LOGGER_INFO_TPL(ShaderSource::get_source_name(), 0) << "compiled shader:" << cr::newline << message << std::endl;
else
neam::cr::out.debug() << LOGGER_INFO_TPL(ShaderSource::get_source_name(), 0) << "compiled shader" << std::endl;
}
#endif
failed = false;
}
static void
cs_cmd_set_email(struct sourceinfo *si, int parc, char *parv[])
{
struct mychan *mc;
char *mail = parv[1];
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to execute this command."));
return;
}
if (!mail || !strcasecmp(mail, "NONE") || !strcasecmp(mail, "OFF"))
{
if (metadata_find(mc, "email"))
{
metadata_delete(mc, "email");
command_success_nodata(si, _("The e-mail address for channel \2%s\2 was deleted."), mc->name);
logcommand(si, CMDLOG_SET, "SET:EMAIL:NONE: \2%s\2", mc->name);
return;
}
command_fail(si, fault_nochange, _("The e-mail address for channel \2%s\2 was not set."), mc->name);
return;
}
if (!validemail(mail))
{
command_fail(si, fault_badparams, _("\2%s\2 is not a valid e-mail address."), mail);
return;
}
// we'll overwrite any existing metadata
metadata_add(mc, "email", mail);
logcommand(si, CMDLOG_SET, "SET:EMAIL: \2%s\2 \2%s\2", mc->name, mail);
verbose(mc, _("\2%s\2 set the e-mail address for the channel to \2%s\2"), get_source_name(si), mail);
command_success_nodata(si, _("The e-mail address for channel \2%s\2 has been set to \2%s\2."), parv[0], mail);
}
/* I don't like this here, but it works --jdhore */
static void create_challenge(sourceinfo_t *si, const char *name, int v, char *dest)
{
char buf[256];
int digest[4];
md5_state_t ctx;
snprintf(buf, sizeof buf, "%lu:%s:%s",
(unsigned long)(CURRTIME / 300) - v,
get_source_name(si),
name);
md5_init(&ctx);
md5_append(&ctx, (unsigned char *)buf, strlen(buf));
md5_finish(&ctx, (unsigned char *)digest);
/* note: this depends on byte order, but that's ok because
* it's only going to work in the same atheme instance anyway
*/
snprintf(dest, 80, "%x:%x", digest[0], digest[1]);
}
//-----------------------------------------------------------------------------------------
// TSL读取TALLY和源名系统 传参 文件描述符，设备输入口，MT500硬件连接口，端口协议
//-----------------------------------------------------------------------------------------
int tsl_tally_name(int serial_fd, int ionum, int port, int num, int pro)
{
int value = 0, count = 0;
int i = 0, j = 0, k = 0;
char sck = 0;
char save_buf[64];
char read_buf[64];
char name_buf[16];
while(1)
{
count = 0;
value = read(serial_fd, read_buf, 64);
if((read_buf[0] > 0x80 && read_buf[0] < 0x80+ionum) && value > 0)
{
memcpy(save_buf+count, read_buf, value);
count += value;
switch(port)
{
case 1:
while(1)
{
value = read(serial_fd, read_buf, 64);
if(value > 0)
{
memcpy(save_buf+count, read_buf, value);
count += value;
}
if(count > 17)
break;
}
if(pro == 2 && count == 18)
{
get_source_name(name_buf, save_buf, count);
/*
for(i = 2; i < count; i += 1)
{
if(save_buf[i] == 0x20)
break;
}
memset(name_buf, 0, 16);
memcpy(name_buf, save_buf+2, i-2);
printf("%d==============>>%s\n", count, name_buf);
*/
}
break;
case 2 :
case 3 :
break;
case 4:
break;
default :
break;
}
}
if(count > 17)
break;
}
/*for(i = 0; i < count; i += 1)
{
printf("%02x ", save_buf[i]);
}
printf("\n");*/
/*switch(port)
{
case 1:
memcpy(save_buf+count, read_buf, value);
count += value;
value = read(serial_fd, read_buf, 64);
if(value > 0)
{
printf("qwertyuiop!!! %d \n", value);
memcpy(save_buf+count, read_buf, value);
count += value;
}
printf("======================%d\n", count);
if(pro == 2 && count == 18)
{
for(i = 0; i < count; i += 1)
{
if(save_buf[i] == 0x20)
break;
}
memset(name_buf, 0, 16);
memcpy(name_buf, save_buf+2, i-2);
printf("%d==============>>%s\n", save_buf[1], name_buf);
}
else if(pro == 3 && count > 18)
{
for(k = 0; k < 18; k += 1)
sck += (save_buf[k] & 0xff);
if(sck == save_buf[18])
{
for(i = 0; i < count; i += 1)
{
if(save_buf[i] == 0x20)
break;
}
memset(name_buf, 0, 16);
memcpy(name_buf, save_buf+2, i-2);
printf("%d=======##########=======>>%s", save_buf[1], name_buf);
}
else
return -num;
}
else
return -num;
break;
case 2:
case 3:
break;
case 4:
break;
default :
break;
}
*/
return num;
}
static void cs_cmd_halfop(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
if (!ircd->uses_halfops)
{
command_fail(si, fault_noprivs, _("Your IRC server does not support halfops."));
return;
}
if (!chan)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "HALFOP");
command_fail(si, fault_needmoreparams, _("Syntax: HALFOP <#channel> [nickname]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_HALFOP))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
/* figure out who we're going to halfop */
if (!nick)
tu = si->su;
else
{
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
return;
}
}
if (is_internal_client(tu))
return;
/* SECURE check; we can skip this if sender == target, because we already verified */
if ((si->su != tu) && (mc->flags & MC_SECURE) && !chanacs_user_has_flag(mc, tu, CA_HALFOP) && !chanacs_user_has_flag(mc, tu, CA_AUTOHALFOP))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
command_fail(si, fault_noprivs, _("\2%s\2 has the SECURE option enabled, and \2%s\2 does not have appropriate access."), mc->name, tu->nick);
return;
}
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
return;
}
modestack_mode_param(chansvs.nick, mc->chan, MTYPE_ADD, 'h', CLIENT_NAME(tu));
cu->modes |= ircd->halfops_mode;
if (si->c == NULL && tu != si->su)
change_notify(chansvs.nick, tu, "You have been halfopped on %s by %s", mc->name, get_source_name(si));
logcommand(si, CMDLOG_DO, "HALFOP: \2%s!%s@%s\2 on \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (!chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been halfopped on \2%s\2."), tu->nick, mc->name);
}
static void cs_cmd_set_private(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (metadata_find(mc, "private:frozen:freezer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is frozen."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET PRIVATE");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this command."));
return;
}
if (chanacs_source_has_flag(mc, si, CA_SUSPENDED))
{
command_fail(si, fault_noprivs, _("Your access in %s is \2suspended\2."), parv[0]);
return;
}
if (!strcasecmp("ON", parv[1]))
{
if (MC_PRIVATE & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for \2%s\2."), "PRIVATE", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:PRIVATE:ON: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 enabled the PRIVATE flag"), get_source_name(si));
mc->flags |= MC_PRIVATE;
command_success_nodata(si, _("The \2%s\2 flag has been set for \2%s\2."), "PRIVATE", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
if (!(MC_PRIVATE & mc->flags))
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for \2%s\2."), "PRIVATE", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:PRIVATE:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the PRIVATE flag"), get_source_name(si));
mc->flags &= ~MC_PRIVATE;
command_success_nodata(si, _("The \2%s\2 flag has been removed for \2%s\2."), "PRIVATE", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "PRIVATE");
return;
}
}
static void
cs_cmd_set_mlock(struct sourceinfo *si, int parc, char *parv[])
{
struct mychan *mc;
char modebuf[32], *end, c;
int dir = MTYPE_NUL;
int newlock_on = 0, newlock_off = 0, newlock_limit = 0, flag = 0;
unsigned int mask, changed;
bool mask_ext;
char newlock_key[KEYLEN + 1];
char newlock_ext[ignore_mode_list_size][512];
bool newlock_ext_off[ignore_mode_list_size];
char newext[512];
char ext_plus[ignore_mode_list_size + 1];
char ext_minus[ignore_mode_list_size + 1];
size_t i;
char *letters = strtok(parv[1], " ");
char *arg;
struct metadata *md;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, STR_IS_NOT_REGISTERED, parv[0]);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
if (ircd->oper_only_modes == 0 ||
!has_priv(si, PRIV_CHAN_CMODES) ||
!has_priv(si, PRIV_CHAN_ADMIN))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
mask = ~ircd->oper_only_modes;
mask_ext = true;
}
else
{
mask = has_priv(si, PRIV_CHAN_CMODES) ? 0 : ircd->oper_only_modes;
mask_ext = false;
}
for (i = 0; i < ignore_mode_list_size; i++)
{
newlock_ext[i][0] = '\0';
newlock_ext_off[i] = false;
}
newlock_key[0] = '\0';
while (letters && *letters)
{
if (*letters != '+' && *letters != '-' && dir == MTYPE_NUL)
{
letters++;
continue;
}
switch ((c = *letters++))
{
case '+':
dir = MTYPE_ADD;
break;
case '-':
dir = MTYPE_DEL;
break;
case 'k':
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if (!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), 'k');
return;
}
else if (strlen(arg) > KEYLEN)
{
command_fail(si, fault_badparams, _("MLOCK key is too long (%zu > %u)."), strlen(arg), KEYLEN);
return;
}
else if (strchr(arg, ',') || arg[0] == ':')
{
command_fail(si, fault_badparams, _("MLOCK key contains invalid characters."));
return;
}
mowgli_strlcpy(newlock_key, arg, sizeof newlock_key);
newlock_off &= ~CMODE_KEY;
}
else
{
newlock_key[0] = '\0';
newlock_off |= CMODE_KEY;
}
break;
case 'l':
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if(!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), 'l');
return;
}
if (atol(arg) <= 0)
{
command_fail(si, fault_badparams, _("You must specify a positive integer for limit."));
return;
}
newlock_limit = atol(arg);
newlock_off &= ~CMODE_LIMIT;
}
else
{
newlock_limit = 0;
newlock_off |= CMODE_LIMIT;
}
break;
default:
flag = mode_to_flag(c);
if (flag)
{
if (dir == MTYPE_ADD)
{
newlock_on |= flag;
newlock_off &= ~flag;
}
else
{
newlock_off |= flag;
newlock_on &= ~flag;
}
break;
}
for (i = 0; ignore_mode_list[i].mode != '\0'; i++)
{
if (c == ignore_mode_list[i].mode)
{
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if(!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), c);
return;
}
if (strlen(arg) > 350)
{
command_fail(si, fault_badparams, _("Invalid value \2%s\2 for mode +%c."), arg, c);
return;
}
if ((mc->chan == NULL || mc->chan->extmodes[i] == NULL || strcmp(mc->chan->extmodes[i], arg)) && !ignore_mode_list[i].check(arg, mc->chan, mc, si->su, si->smu))
{
command_fail(si, fault_badparams, _("Invalid value \2%s\2 for mode +%c."), arg, c);
return;
}
mowgli_strlcpy(newlock_ext[i], arg, sizeof newlock_ext[i]);
newlock_ext_off[i] = false;
}
else
{
newlock_ext[i][0] = '\0';
newlock_ext_off[i] = true;
}
}
}
}
}
// note: the following does not treat +lk and extmodes correctly
changed = ((newlock_on ^ mc->mlock_on) | (newlock_off ^ mc->mlock_off));
changed &= ~mask;
/* if they're only allowed to alter oper only modes, require
* them to actually change such modes -- jilles */
if (!changed && mask_ext)
{
command_fail(si, fault_noprivs, _("You may only alter \2+%s\2 modes."), flags_to_string(~mask));
return;
}
// save it to mychan, leave the modes in mask unchanged -- jilles
mc->mlock_on = (newlock_on & ~mask) | (mc->mlock_on & mask);
mc->mlock_off = (newlock_off & ~mask) | (mc->mlock_off & mask);
if (!(mask & CMODE_LIMIT))
mc->mlock_limit = newlock_limit;
if (!(mask & CMODE_KEY))
{
sfree(mc->mlock_key);
mc->mlock_key = *newlock_key != '\0' ? sstrdup(newlock_key) : NULL;
}
ext_plus[0] = '\0';
ext_minus[0] = '\0';
if (mask_ext)
{
md = metadata_find(mc, "private:mlockext");
if (md != NULL)
{
arg = md->value;
while (*arg != '\0')
{
modebuf[0] = *arg;
modebuf[1] = '\0';
mowgli_strlcat(arg[1] == ' ' || arg[1] == '\0' ? ext_minus : ext_plus, modebuf, ignore_mode_list_size + 1);
arg++;
while (*arg != ' ' && *arg != '\0')
arg++;
while (*arg == ' ')
arg++;
}
}
}
else
{
newext[0] = '\0';
for (i = 0; i < ignore_mode_list_size; i++)
{
if (newlock_ext[i][0] != '\0' || newlock_ext_off[i])
{
if (*newext != '\0')
{
modebuf[0] = ' ';
modebuf[1] = '\0';
mowgli_strlcat(newext, modebuf, sizeof newext);
}
modebuf[0] = ignore_mode_list[i].mode;
modebuf[1] = '\0';
mowgli_strlcat(newext, modebuf, sizeof newext);
mowgli_strlcat(newlock_ext_off[i] ? ext_minus : ext_plus,
modebuf, ignore_mode_list_size + 1);
if (!newlock_ext_off[i])
mowgli_strlcat(newext, newlock_ext[i], sizeof newext);
}
}
if (newext[0] != '\0')
metadata_add(mc, "private:mlockext", newext);
else
metadata_delete(mc, "private:mlockext");
}
end = modebuf;
*end = 0;
if (mc->mlock_on || mc->mlock_key || mc->mlock_limit || *ext_plus)
end += snprintf(end, sizeof(modebuf) - (end - modebuf), "+%s%s%s%s", flags_to_string(mc->mlock_on), mc->mlock_key ? "k" : "", mc->mlock_limit ? "l" : "", ext_plus);
if (mc->mlock_off || *ext_minus)
end += snprintf(end, sizeof(modebuf) - (end - modebuf), "-%s%s%s%s", flags_to_string(mc->mlock_off), mc->mlock_off & CMODE_KEY ? "k" : "", mc->mlock_off & CMODE_LIMIT ? "l" : "", ext_minus);
if (*modebuf)
{
command_success_nodata(si, _("The MLOCK for \2%s\2 has been set to \2%s\2."), mc->name, modebuf);
logcommand(si, CMDLOG_SET, "SET:MLOCK: \2%s\2 to \2%s\2", mc->name, modebuf);
verbose(mc, "\2%s\2 set the mode lock to \2%s\2", get_source_name(si), modebuf);
}
else
{
command_success_nodata(si, _("The MLOCK for \2%s\2 has been removed."), mc->name);
logcommand(si, CMDLOG_SET, "SET:MLOCK:NONE: \2%s\2", mc->name);
}
if (changed & ircd->oper_only_modes)
logcommand(si, CMDLOG_SET, "SET:MLOCK: \2%s\2 to \2%s\2 by \2%s\2", mc->name, *modebuf != '\0' ? modebuf : "+", get_oper_name(si));
check_modes(mc, true);
if (mc->chan != NULL)
mlock_sts(mc->chan);
return;
}
/// \brief preload the source code of the shader
/// \note marked as advanced
void _preload()
{
env.on_change(ShaderSource::get_source_string(), get_source_name());
}
static void cs_cmd_set_gameserv(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
const char *val;
metadata_t *md;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET GAMESERV");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
if (!strcasecmp("ALL", parv[1]))
val = "ALL";
else if (!strcasecmp("VOICE", parv[1]) || !strcasecmp("VOICES", parv[1]))
val = "VOICE";
else if (!strcasecmp("OP", parv[1]) || !strcasecmp("OPS", parv[1]))
val = "OP";
else if (!strcasecmp("OFF", parv[1]))
val = NULL;
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "GAMESERV");
return;
}
md = metadata_find(mc, "gameserv");
if (val != NULL)
{
if (md != NULL && !strcasecmp(md->value, val))
{
command_fail(si, fault_nochange, _("\2%s\2 is already set to %s for \2%s\2."), "GAMESERV", val, mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:GAMESERV: \2%s\2 to \2%s\2", mc->name, val);
verbose(mc, _("\2%s\2 set the GAMESERV flag to \2%s\2"), get_source_name(si), val);
metadata_add(mc, "gameserv", val);
command_success_nodata(si, _("\2%s\2 has been set to \2%s\2 for \2%s\2."), "GAMESERV", val, mc->name);
return;
}
else
{
if (md == NULL)
{
command_fail(si, fault_nochange, _("\2%s\2 was not set for \2%s\2."), "GAMESERV", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:GAMESERV:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the GAMESERV flag"), get_source_name(si));
metadata_delete(mc, "gameserv");
command_success_nodata(si, _("\2%s\2 has been disabled for \2%s\2."), "GAMESERV", mc->name);
}
}
static void
cs_cmd_set_fantasy(struct sourceinfo *si, int parc, char *parv[])
{
struct mychan *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, STR_IS_NOT_REGISTERED, parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET FANTASY");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
if (!strcasecmp("ON", parv[1]))
{
struct metadata *md = metadata_find(mc, "disable_fantasy");
if (!md)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
metadata_delete(mc, "disable_fantasy");
logcommand(si, CMDLOG_SET, "SET:FANTASY:ON: \2%s\2", mc->name);
verbose(mc, "\2%s\2 enabled the FANTASY flag", get_source_name(si));
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
struct metadata *md = metadata_find(mc, "disable_fantasy");
if (md)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
metadata_add(mc, "disable_fantasy", "on");
logcommand(si, CMDLOG_SET, "SET:FANTASY:OFF: \2%s\2", mc->name);
verbose(mc, "\2%s\2 disabled the FANTASY flag", get_source_name(si));
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "FANTASY", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "SET FANTASY");
return;
}
}
static void cs_cmd_set_fantasy(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET FANTASY");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this command."));
return;
}
if (!strcasecmp("ON", parv[1]))
{
metadata_t *md = metadata_find(mc, "disable_fantasy");
if (!md)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
metadata_delete(mc, "disable_fantasy");
logcommand(si, CMDLOG_SET, "SET:FANTASY:ON: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 enabled the FANTASY flag"), get_source_name(si));
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
metadata_t *md = metadata_find(mc, "disable_fantasy");
if (md)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "FANTASY", mc->name);
return;
}
metadata_add(mc, "disable_fantasy", "on");
logcommand(si, CMDLOG_SET, "SET:FANTASY:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the FANTASY flag"), get_source_name(si));
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "FANTASY", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "FANTASY");
return;
}
}
static void cs_cmd_deowner(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
if (ircd->uses_owner == false)
{
command_fail(si, fault_noprivs, _("The IRCd software you are running does not support this feature."));
return;
}
if (!chan)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DEOWNER");
command_fail(si, fault_needmoreparams, _("Syntax: DEOWNER <#channel> [nickname]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_USEOWNER))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
/* figure out who we're going to deop */
if (!nick)
tu = si->su;
else
{
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
return;
}
}
if (is_internal_client(tu))
return;
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
return;
}
modestack_mode_param(chansvs.nick, mc->chan, MTYPE_DEL, ircd->owner_mchar[1], CLIENT_NAME(tu));
cu->modes &= ~CSTATUS_OWNER;
if (si->c == NULL && tu != si->su)
change_notify(chansvs.nick, tu, "You have been unset as owner on %s by %s", mc->name, get_source_name(si));
logcommand(si, CMDLOG_DO, "DEOWNER: \2%s!%s@%s\2 on \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (si->su == NULL || !chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been unset as owner on \2%s\2."), tu->nick, mc->name);
}
static void cs_cmd_owner(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
char *nicklist;
char *strtokctx;
if (ircd->uses_owner == false)
{
command_fail(si, fault_noprivs, _("The IRCd software you are running does not support this feature."));
return;
}
if (!chan)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "OWNER");
command_fail(si, fault_needmoreparams, _("Syntax: OWNER <#channel> [nickname] [...]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_USEOWNER))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
nicklist = (!nick ? strdup(si->su->nick) : strdup(nick));
nick = strtok_r(nicklist, " ", &strtokctx);
do
{
if (invert_purpose(si, parc, chan, &nick, '-', &cs_cmd_deowner))
continue;
/* figure out who we're going to op */
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
continue;
}
if (is_internal_client(tu))
continue;
/* SECURE check; we can skip this if sender == target, because we already verified */
if ((si->su != tu) && (mc->flags & MC_SECURE) && !chanacs_user_has_flag(mc, tu, CA_OP) && !chanacs_user_has_flag(mc, tu, CA_AUTOOP))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
command_fail(si, fault_noprivs, _("\2%s\2 has the SECURE option enabled, and \2%s\2 does not have appropriate access."), mc->name, tu->nick);
continue;
}
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
continue;
}
modestack_mode_param(chansvs.nick, mc->chan, MTYPE_ADD, ircd->owner_mchar[1], CLIENT_NAME(tu));
cu->modes |= CSTATUS_OWNER;
if (si->c == NULL && tu != si->su)
change_notify(chansvs.nick, tu, "You have been set as owner on %s by %s", mc->name, get_source_name(si));
logcommand(si, CMDLOG_DO, "OWNER: \2%s!%s@%s\2 on \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (si->su == NULL || !chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been set as owner on \2%s\2."), tu->nick, mc->name);
} while ((nick = strtok_r(NULL, " ", &strtokctx)) != NULL);
free(nicklist);
}
static void cs_cmd_set_guard(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET GUARD");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this command."));
return;
}
if (!strcasecmp("ON", parv[1]))
{
if (MC_GUARD & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "GUARD", mc->name);
return;
}
if (metadata_find(mc, "private:botserv:bot-assigned") &&
module_find_published("botserv/main"))
{
command_fail(si, fault_noprivs, _("Channel \2%s\2 already has a BotServ bot assigned to it. You need to unassign it first."), mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:GUARD:ON: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 enabled the GUARD flag"), get_source_name(si));
mc->flags |= MC_GUARD;
if (!(mc->flags & MC_INHABIT))
join(mc->name, chansvs.nick);
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "GUARD", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
if (!(MC_GUARD & mc->flags))
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "GUARD", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:GUARD:OFF: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 disabled the GUARD flag"), get_source_name(si));
mc->flags &= ~MC_GUARD;
if (mc->chan != NULL && !(mc->flags & MC_INHABIT) && !(mc->chan->flags & CHAN_LOG))
part(mc->name, chansvs.nick);
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "GUARD", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "GUARD");
return;
}
}
static void ns_cmd_register(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
mynick_t *mn = NULL;
mowgli_node_t *n;
const char *account;
const char *pass;
const char *email;
char lau[BUFSIZE], lao[BUFSIZE];
hook_user_register_check_t hdata;
hook_user_req_t req;
if (si->smu)
{
command_fail(si, fault_already_authed, _("You are already logged in as \2%s\2."), entity(si->smu)->name);
if (si->su != NULL && !mynick_find(si->su->nick) &&
command_find(si->service->commands, "GROUP"))
command_fail(si, fault_already_authed, _("Use %s to register %s to your account."), "GROUP", si->su->nick);
return;
}
if (nicksvs.no_nick_ownership || si->su == NULL)
account = parv[0], pass = parv[1], email = parv[2];
else
account = si->su->nick, pass = parv[0], email = parv[1];
if (!account || !pass || !email)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "REGISTER");
if (nicksvs.no_nick_ownership || si->su == NULL)
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <account> <password> <email>"));
else
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <password> <email>"));
return;
}
if (strlen(pass) >= PASSLEN)
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "REGISTER");
command_fail(si, fault_badparams, _("Registration passwords may not be longer than \2%d\2 characters."), PASSLEN - 1);
return;
}
if (!nicksvs.no_nick_ownership && si->su == NULL && user_find_named(account))
{
command_fail(si, fault_noprivs, _("A user matching this account is already on IRC."));
return;
}
if (!nicksvs.no_nick_ownership && IsDigit(*account))
{
command_fail(si, fault_badparams, _("For security reasons, you can't register your UID."));
command_fail(si, fault_badparams, _("Please change to a real nickname, and try again."));
return;
}
if (nicksvs.no_nick_ownership || si->su == NULL)
{
if (strchr(account, ' ') || strchr(account, '\n') || strchr(account, '\r') || account[0] == '=' || account[0] == '#' || account[0] == '@' || account[0] == '+' || account[0] == '%' || account[0] == '!' || strchr(account, ','))
{
command_fail(si, fault_badparams, _("The account name \2%s\2 is invalid."), account);
return;
}
}
if (strlen(account) >= NICKLEN)
{
command_fail(si, fault_badparams, _("The account name \2%s\2 is invalid."), account);
return;
}
if ((si->su != NULL && !strcasecmp(pass, si->su->nick)) || !strcasecmp(pass, account))
{
command_fail(si, fault_badparams, _("You cannot use your nickname as a password."));
if (nicksvs.no_nick_ownership || si->su == NULL)
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <account> <password> <email>"));
else
command_fail(si, fault_needmoreparams, _("Syntax: REGISTER <password> <email>"));
return;
}
/* make sure it isn't registered already */
if (nicksvs.no_nick_ownership ? myuser_find(account) != NULL : mynick_find(account) != NULL)
{
command_fail(si, fault_alreadyexists, _("\2%s\2 is already registered."), account);
return;
}
if ((unsigned int)(CURRTIME - ratelimit_firsttime) > config_options.ratelimit_period)
ratelimit_count = 0, ratelimit_firsttime = CURRTIME;
/* Still do flood priv checking because the user may be in the ircop operclass */
if (ratelimit_count > config_options.ratelimit_uses && !has_priv(si, PRIV_FLOOD))
{
command_fail(si, fault_toomany, _("The system is currently too busy to process your registration, please try again later."));
slog(LG_INFO, "NICKSERV:REGISTER:THROTTLED: \2%s\2 by \2%s\2", account, si->su != NULL ? si->su->nick : get_source_name(si));
return;
}
hdata.si = si;
hdata.account = account;
hdata.email = email;
hdata.password = pass;
hdata.approved = 0;
hook_call_user_can_register(&hdata);
if (hdata.approved != 0)
return;
if (!nicksvs.no_nick_ownership)
{
hook_call_nick_can_register(&hdata);
if (hdata.approved != 0)
return;
}
if (!validemail(email))
{
command_fail(si, fault_badparams, _("\2%s\2 is not a valid email address."), email);
return;
}
if (!email_within_limits(email))
{
command_fail(si, fault_toomany, _("\2%s\2 has too many accounts registered."), email);
return;
}
mu = myuser_add(account, auth_module_loaded ? "*" : pass, email, config_options.defuflags | MU_NOBURSTLOGIN | (auth_module_loaded ? MU_CRYPTPASS : 0));
mu->registered = CURRTIME;
mu->lastlogin = CURRTIME;
if (!nicksvs.no_nick_ownership)
{
mn = mynick_add(mu, entity(mu)->name);
mn->registered = CURRTIME;
mn->lastseen = CURRTIME;
}
if (config_options.ratelimit_uses && config_options.ratelimit_period)
ratelimit_count++;
if (auth_module_loaded)
{
if (!verify_password(mu, pass))
{
command_fail(si, fault_authfail, _("Invalid password for \2%s\2."), entity(mu)->name);
bad_password(si, mu);
object_unref(mu);
return;
}
}
if (me.auth == AUTH_EMAIL)
{
char *key = random_string(12);
mu->flags |= MU_WAITAUTH;
metadata_add(mu, "private:verify:register:key", key);
metadata_add(mu, "private:verify:register:timestamp", number_to_string(time(NULL)));
if (!sendemail(si->su != NULL ? si->su : si->service->me, mu, EMAIL_REGISTER, mu->email, key))
{
command_fail(si, fault_emailfail, _("Sending email failed, sorry! Registration aborted."));
object_unref(mu);
free(key);
return;
}
command_success_nodata(si, _("An email containing nickname activation instructions has been sent to \2%s\2."), mu->email);
command_success_nodata(si, _("If you do not complete registration within one day, your nickname will expire."));
free(key);
}
if (si->su != NULL)
{
si->su->myuser = mu;
n = mowgli_node_create();
mowgli_node_add(si->su, n, &mu->logins);
if (!(mu->flags & MU_WAITAUTH))
/* only grant ircd registered status if it's verified */
ircd_on_login(si->su, mu, NULL);
}
command_add_flood(si, FLOOD_MODERATE);
if (!nicksvs.no_nick_ownership && si->su != NULL)
logcommand(si, CMDLOG_REGISTER, "REGISTER: \2%s\2 to \2%s\2", account, email);
else
logcommand(si, CMDLOG_REGISTER, "REGISTER: \2%s\2 to \2%s\2 by \2%s\2", account, email, si->su != NULL ? si->su->nick : get_source_name(si));
if (is_soper(mu))
{
wallops("%s registered the nick \2%s\2 and gained services operator privileges.", get_oper_name(si), entity(mu)->name);
logcommand(si, CMDLOG_ADMIN, "SOPER: \2%s\2 as \2%s\2", get_oper_name(si), entity(mu)->name);
}
command_success_nodata(si, _("\2%s\2 is now registered to \2%s\2, with the password \2%s\2."), entity(mu)->name, mu->email, pass);
hook_call_user_register(mu);
if (si->su != NULL)
{
snprintf(lau, BUFSIZE, "%s@%s", si->su->user, si->su->vhost);
metadata_add(mu, "private:host:vhost", lau);
snprintf(lao, BUFSIZE, "%s@%s", si->su->user, si->su->host);
metadata_add(mu, "private:host:actual", lao);
}
if (!(mu->flags & MU_WAITAUTH))
{
req.si = si;
req.mu = mu;
req.mn = mn;
hook_call_user_verify_register(&req);
}
}
static void cs_cmd_drop(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
char *name = parv[0];
char *key = parv[1];
char fullcmd[512];
char key0[80], key1[80];
if (!name)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DROP");
command_fail(si, fault_needmoreparams, _("Syntax: DROP <#channel>"));
return;
}
if (*name != '#')
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "DROP");
command_fail(si, fault_badparams, _("Syntax: DROP <#channel>"));
return;
}
if (!(mc = mychan_find(name)))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), name);
return;
}
if (si->c != NULL)
{
command_fail(si, fault_noprivs, _("For security reasons, you may not drop a channel registration with a fantasy command."));
return;
}
if (!is_founder(mc, entity(si->smu)))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
if (metadata_find(mc, "private:close:closer"))
{
logcommand(si, CMDLOG_REGISTER, "DROP: \2%s\2 failed to drop (closed)", mc->name);
command_fail(si, fault_noprivs, _("The channel \2%s\2 is closed; it cannot be dropped."), mc->name);
return;
}
if (mc->flags & MC_HOLD)
{
command_fail(si, fault_noprivs, _("The channel \2%s\2 is held; it cannot be dropped."), mc->name);
return;
}
if (si->su != NULL)
{
if (!key)
{
create_challenge(si, mc->name, 0, key0);
snprintf(fullcmd, sizeof fullcmd, "/%s%s DROP %s %s",
(ircd->uses_rcommand == false) ? "msg " : "",
chansvs.me->disp, mc->name, key0);
command_success_nodata(si, _("To avoid accidental use of this command, this operation has to be confirmed. Please confirm by replying with \2%s\2"),
fullcmd);
return;
}
/* accept current and previous key */
create_challenge(si, mc->name, 0, key0);
create_challenge(si, mc->name, 1, key1);
if (strcmp(key, key0) && strcmp(key, key1))
{
command_fail(si, fault_badparams, _("Invalid key for %s."), "DROP");
return;
}
}
logcommand(si, CMDLOG_REGISTER, "DROP: \2%s\2", mc->name);
verbose(mc, _("\2%s\2 dropped the channel"), get_source_name(si));
hook_call_channel_drop(mc);
if (mc->chan != NULL && !(mc->chan->flags & CHAN_LOG))
part(mc->name, chansvs.nick);
object_unref(mc);
command_success_nodata(si, _("The channel \2%s\2 has been dropped."), name);
return;
}
static void cs_cmd_kick(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
char *reason = parv[2];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
char reasonbuf[BUFSIZE];
if (!chan || !nick)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "KICK");
command_fail(si, fault_needmoreparams, _("Syntax: KICK <#channel> <nickname> [reason]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_REMOVE))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
return;
}
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
/* figure out who we're going to kick */
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
return;
}
/* if target is a service, bail. --nenolod */
if (is_internal_client(tu))
return;
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
return;
}
if (cu->modes & CSTATUS_OWNER || cu->modes & CSTATUS_PROTECT)
{
command_fail(si, fault_noprivs, _("\2%s\2 is protected from kicks; you cannot kick them."), tu->nick);
return;
}
snprintf(reasonbuf, BUFSIZE, "(%s) %s", get_source_name(si), reason ? reason : "No reason given");
try_kick(chansvs.me->me, mc->chan, tu, reasonbuf);
logcommand(si, CMDLOG_DO, "KICK: \2%s!%s@%s\2 from \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (si->su != tu && !chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been kicked from \2%s\2."), tu->nick, mc->name);
}
static void cs_cmd_set_verbose(sourceinfo_t *si, int parc, char *parv[])
{
mychan_t *mc;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), parv[0]);
return;
}
if (metadata_find(mc, "private:frozen:freezer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is frozen."), parv[0]);
return;
}
if (!parv[1])
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "SET VERBOSE");
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this command."));
return;
}
if (!strcasecmp("ON", parv[1]) || !strcasecmp("ALL", parv[1]))
{
if (MC_VERBOSE & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "VERBOSE", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:VERBOSE:ON: \2%s\2", mc->name);
mc->flags &= ~MC_VERBOSE_OPS;
mc->flags |= MC_VERBOSE;
verbose(mc, "\2%s\2 enabled the VERBOSE flag", get_source_name(si));
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "VERBOSE", mc->name);
return;
}
else if (!strcasecmp("OPS", parv[1]))
{
if (MC_VERBOSE_OPS & mc->flags)
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is already set for channel \2%s\2."), "VERBOSE_OPS", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:VERBOSE:OPS: \2%s\2", mc->name);
if (mc->flags & MC_VERBOSE)
{
verbose(mc, "\2%s\2 restricted VERBOSE to chanops", get_source_name(si));
mc->flags &= ~MC_VERBOSE;
mc->flags |= MC_VERBOSE_OPS;
}
else
{
mc->flags |= MC_VERBOSE_OPS;
verbose(mc, "\2%s\2 enabled the VERBOSE_OPS flag", get_source_name(si));
}
command_success_nodata(si, _("The \2%s\2 flag has been set for channel \2%s\2."), "VERBOSE_OPS", mc->name);
return;
}
else if (!strcasecmp("OFF", parv[1]))
{
if (!((MC_VERBOSE | MC_VERBOSE_OPS) & mc->flags))
{
command_fail(si, fault_nochange, _("The \2%s\2 flag is not set for channel \2%s\2."), "VERBOSE", mc->name);
return;
}
logcommand(si, CMDLOG_SET, "SET:VERBOSE:OFF: \2%s\2", mc->name);
if (mc->flags & MC_VERBOSE)
verbose(mc, "\2%s\2 disabled the VERBOSE flag", get_source_name(si));
else
verbose(mc, "\2%s\2 disabled the VERBOSE_OPS flag", get_source_name(si));
mc->flags &= ~(MC_VERBOSE | MC_VERBOSE_OPS);
command_success_nodata(si, _("The \2%s\2 flag has been removed for channel \2%s\2."), "VERBOSE", mc->name);
return;
}
else
{
command_fail(si, fault_badparams, STR_INVALID_PARAMS, "VERBOSE");
return;
}
}
/* FFLAGS <channel> <user> <flags> */
static void cs_cmd_fflags(sourceinfo_t *si, int parc, char *parv[])
{
char *channel = parv[0];
char *target = parv[1];
char *flagstr = parv[2];
mychan_t *mc;
myuser_t *tmu;
unsigned int addflags, removeflags;
if (parc < 3)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "FFLAGS");
command_fail(si, fault_needmoreparams, _("Syntax: FFLAGS <channel> <target> <flags>"));
return;
}
mc = mychan_find(channel);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), channel);
return;
}
if (*flagstr == '+' || *flagstr == '-' || *flagstr == '=')
{
flags_make_bitmasks(flagstr, chanacs_flags, &addflags, &removeflags);
if (addflags == 0 && removeflags == 0)
{
command_fail(si, fault_badparams, _("No valid flags given, use /%s%s HELP FLAGS for a list"), ircd->uses_rcommand ? "" : "msg ", chansvs.me->disp);
return;
}
}
else
{
addflags = get_template_flags(mc, flagstr);
if (addflags == 0)
{
/* Hack -- jilles */
if (*target == '+' || *target == '-' || *target == '=')
command_fail(si, fault_badparams, _("Usage: FFLAGS %s <target> <flags>"), mc->name);
else
command_fail(si, fault_badparams, _("Invalid template name given, use /%s%s TEMPLATE %s for a list"), ircd->uses_rcommand ? "" : "msg ", chansvs.me->disp, mc->name);
return;
}
removeflags = ca_all & ~addflags;
}
if (!validhostmask(target))
{
if (!(tmu = myuser_find_ext(target)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), target);
return;
}
target = tmu->name;
/* XXX this should be more like flags.c */
if (removeflags & CA_FLAGS)
removeflags |= CA_FOUNDER, addflags &= ~CA_FOUNDER;
else if (addflags & CA_FOUNDER)
addflags |= CA_FLAGS, removeflags &= ~CA_FLAGS;
if (is_founder(mc, tmu) && removeflags & CA_FOUNDER && mychan_num_founders(mc) == 1)
{
command_fail(si, fault_noprivs, _("You may not remove the last founder."));
return;
}
if (!chanacs_change(mc, tmu, NULL, &addflags, &removeflags, ca_all))
{
/* this shouldn't happen */
command_fail(si, fault_noprivs, _("You are not allowed to set \2%s\2 on \2%s\2 in \2%s\2."), bitmask_to_flags2(addflags, removeflags, chanacs_flags), tmu->name, mc->name);
return;
}
}
else
{
if (addflags & CA_FOUNDER)
{
command_fail(si, fault_badparams, _("You may not set founder status on a hostmask."));
return;
}
if (!chanacs_change(mc, NULL, target, &addflags, &removeflags, ca_all))
{
/* this shouldn't happen */
command_fail(si, fault_noprivs, _("You are not allowed to set \2%s\2 on \2%s\2 in \2%s\2."), bitmask_to_flags2(addflags, removeflags, chanacs_flags), target, mc->name);
return;
}
}
if ((addflags | removeflags) == 0)
{
command_fail(si, fault_nochange, _("Channel access to \2%s\2 for \2%s\2 unchanged."), channel, target);
return;
}
flagstr = bitmask_to_flags2(addflags, removeflags, chanacs_flags);
wallops("\2%s\2 is forcing flags change \2%s\2 on \2%s\2 in \2%s\2.", get_oper_name(si), flagstr, target, mc->name);
snoop("FFLAGS: \2%s\2 \2%s\2 \2%s\2 by \2%s\2", channel, target, flagstr, get_oper_name(si));
command_success_nodata(si, _("Flags \2%s\2 were set on \2%s\2 in \2%s\2."), flagstr, target, channel);
logcommand(si, CMDLOG_ADMIN, "%s FFLAGS %s %s", mc->name, target, flagstr);
verbose(mc, "\2%s\2 forced flags change \2%s\2 on \2%s\2.", get_source_name(si), flagstr, target);
}
static void os_cmd_specs(sourceinfo_t *si, int parc, char *parv[])
{
user_t *tu = NULL;
operclass_t *cl = NULL;
const char *targettype = parv[0];
const char *target = parv[1];
unsigned int i;
int j, n;
if (!has_any_privs(si))
{
command_fail(si, fault_noprivs, _("You are not authorized to use %s."), si->service->nick);
return;
}
if (targettype != NULL)
{
if (!has_priv(si, PRIV_VIEWPRIVS))
{
command_fail(si, fault_noprivs, STR_NO_PRIVILEGE, PRIV_VIEWPRIVS);
return;
}
if (target == NULL)
target = "?";
if (!strcasecmp(targettype, "USER"))
{
tu = user_find_named(target);
if (tu == NULL)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on IRC."), target);
return;
}
if (!has_any_privs_user(tu))
{
command_success_nodata(si, _("\2%s\2 is unprivileged."), tu->nick);
return;
}
if (is_internal_client(tu))
{
command_fail(si, fault_noprivs, _("\2%s\2 is an internal client."), tu->nick);
return;
}
}
else if (!strcasecmp(targettype, "OPERCLASS") || !strcasecmp(targettype, "CLASS"))
{
cl = operclass_find(target);
if (cl == NULL)
{
command_fail(si, fault_nosuch_target, _("No such oper class \2%s\2."), target);
return;
}
}
else
{
command_fail(si, fault_badparams, _("Valid target types: USER, OPERCLASS."));
return;
}
}
else
tu = si->su;
if (targettype == NULL)
command_success_nodata(si, _("Privileges for \2%s\2:"), get_source_name(si));
else if (tu)
command_success_nodata(si, _("Privileges for \2%s\2:"), tu->nick);
else
command_success_nodata(si, _("Privileges for oper class \2%s\2:"), cl->name);
for (i = 0; i < ARRAY_SIZE(priv_categories); i++)
{
struct priv_category *cat = priv_categories[i];
command_success_nodata(si, "\2%s\2:", _(cat->name));
for (j = n = 0; cat->privs[j].priv != NULL; j++)
{
if (targettype == NULL ? has_priv(si, cat->privs[j].priv) : (tu ? has_priv_user(tu, cat->privs[j].priv) : has_priv_operclass(cl, cat->privs[j].priv)))
{
command_success_nodata(si, " %s (%s)", cat->privs[j].priv, _(cat->privs[j].desc));
++n;
}
}
if (!n)
command_success_nodata(si, " %s", _("(no privileges held)"));
}
command_success_nodata(si, _("End of privileges"));
if (targettype == NULL)
logcommand(si, CMDLOG_ADMIN, "SPECS");
else if (tu)
logcommand(si, CMDLOG_ADMIN, "SPECS:USER: \2%s!%s@%s\2", tu->nick, tu->user, tu->vhost);
else
logcommand(si, CMDLOG_ADMIN, "SPECS:OPERCLASS: \2%s\2", cl->name);
}
static void ns_cmd_drop(sourceinfo_t *si, int parc, char *parv[])
{
myuser_t *mu;
mynick_t *mn;
char *acc = parv[0];
char *pass = parv[1];
if (!acc || !pass)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "DROP");
command_fail(si, fault_needmoreparams, _("Syntax: DROP <account> <password>"));
return;
}
if (!(mu = myuser_find(acc)))
{
if (!nicksvs.no_nick_ownership)
{
mn = mynick_find(acc);
if (mn != NULL && command_find(si->service->cmdtree, "UNGROUP"))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is a grouped nick, use %s to remove it."), acc, "UNGROUP");
return;
}
}
command_fail(si, fault_nosuch_target, _("\2%s\2 is not registered."), acc);
return;
}
if (metadata_find(mu, "private:freeze:freezer"))
{
command_fail(si, fault_authfail, nicksvs.no_nick_ownership ? "You cannot login as \2%s\2 because the account has been frozen." : "You cannot identify to \2%s\2 because the nickname has been frozen.", mu->name);
return;
}
if (!verify_password(mu, pass))
{
command_fail(si, fault_authfail, _("Authentication failed. Invalid password for \2%s\2."), mu->name);
bad_password(si, mu);
return;
}
if (!nicksvs.no_nick_ownership &&
LIST_LENGTH(&mu->nicks) > 1 &&
command_find(si->service->cmdtree, "UNGROUP"))
{
command_fail(si, fault_noprivs, _("Account \2%s\2 has %d other nick(s) grouped to it, remove those first."),
mu->name, LIST_LENGTH(&mu->nicks) - 1);
return;
}
if (is_soper(mu))
{
command_fail(si, fault_noprivs, _("The nickname \2%s\2 belongs to a services operator; it cannot be dropped."), acc);
return;
}
if (mu->flags & MU_HOLD)
{
command_fail(si, fault_noprivs, _("The account \2%s\2 is held; it cannot be dropped."), acc);
return;
}
snoop("DROP: \2%s\2 by \2%s\2", mu->name, get_source_name(si));
command_add_flood(si, FLOOD_MODERATE);
logcommand(si, CMDLOG_REGISTER, "DROP %s", mu->name);
hook_call_user_drop(mu);
command_success_nodata(si, _("The account \2%s\2 has been dropped."), mu->name);
object_unref(mu);
}
static void cs_cmd_voice(sourceinfo_t *si, int parc, char *parv[])
{
char *chan = parv[0];
char *nick = parv[1];
mychan_t *mc;
user_t *tu;
chanuser_t *cu;
char *nicklist;
char *strtokctx;
if (!chan)
{
command_fail(si, fault_needmoreparams, STR_INSUFFICIENT_PARAMS, "VOICE");
command_fail(si, fault_needmoreparams, _("Syntax: VOICE <#channel> [nickname] [...]"));
return;
}
mc = mychan_find(chan);
if (!mc)
{
command_fail(si, fault_nosuch_target, _("Channel \2%s\2 is not registered."), chan);
return;
}
if (metadata_find(mc, "private:close:closer"))
{
command_fail(si, fault_noprivs, _("\2%s\2 is closed."), chan);
return;
}
nicklist = (!nick ? strdup(si->su->nick) : strdup(nick));
nick = strtok_r(nicklist, " ", &strtokctx);
do
{
if (invert_purpose(si, parc, chan, &nick, '-', &cs_cmd_devoice))
continue;
/* figure out who we're going to voice */
if (!(tu = user_find_named(nick)))
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not online."), nick);
continue;
}
if (!chanacs_source_has_flag(mc, si, CA_VOICE) && (tu != si->su ||
!chanacs_source_has_flag(mc, si, CA_AUTOVOICE)))
{
command_fail(si, fault_noprivs, _("You are not authorized to perform this operation."));
continue;
}
if (is_internal_client(tu))
continue;
cu = chanuser_find(mc->chan, tu);
if (!cu)
{
command_fail(si, fault_nosuch_target, _("\2%s\2 is not on \2%s\2."), tu->nick, mc->name);
continue;
}
modestack_mode_param(chansvs.nick, mc->chan, MTYPE_ADD, 'v', CLIENT_NAME(tu));
cu->modes |= CSTATUS_VOICE;
if (si->c == NULL && tu != si->su)
change_notify(chansvs.nick, tu, "You have been voiced on %s by %s", mc->name, get_source_name(si));
logcommand(si, CMDLOG_DO, "VOICE: \2%s!%s@%s\2 on \2%s\2", tu->nick, tu->user, tu->vhost, mc->name);
if (si->su == NULL || !chanuser_find(mc->chan, si->su))
command_success_nodata(si, _("\2%s\2 has been voiced on \2%s\2."), tu->nick, mc->name);
} while ((nick = strtok_r(NULL, " ", &strtokctx)) != NULL);
free(nicklist);
}
