modules/nickserv/set.C

/**
 * set.C: This file contains routines to handle the NickServ SET command.
 *
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are as documented in COPYING.
 *
 *
 * Portions of this file were derived from sources bearing the following license:
 * Copyright © 2006 William Pitcock, et al.
 * Rights to this code are documented in doc/pod/license.pod.
 *
 * $Id: set.C,v 1.9 2007-09-16 18:54:43 pippijn Exp $
 */

#include "atheme.h"
#include <util/numeric.h>
#include <libermyth.h>
#include <ermyth/module.h>
#include <account/myuser.h>

static char const rcsid[] = "$Id: set.C,v 1.9 2007-09-16 18:54:43 pippijn Exp $";

REGISTER_MODULE ("nickserv/set", false, "The Ermyth Team <http://ermyth.xinutec.org>");

static void ns_cmd_set (sourceinfo_t *si, int parc, char *parv[]);

E cmdvec ns_cmdtree;
E helpvec ns_helptree;

command_t const ns_set = { "SET", N_("Sets various control flags."), AC_NONE, 2, ns_cmd_set };

cmdvec ns_set_cmdtree;

/* HELP SET */
static void
ns_help_set (sourceinfo_t *si)
{
  command_success_nodata (si, _("Help for \2SET\2:"));
  command_success_nodata (si, " ");
  command_success_nodata (si, _("SET allows you to set various control flags"));
  if (nicksvs.no_nick_ownership)
    command_success_nodata (si, _("for accounts that change the way certain operations"));
  else
    command_success_nodata (si, _("for nicknames that change the way certain operations"));
  command_success_nodata (si, _("are performed on them."));
  command_success_nodata (si, " ");
  command_help (si, ns_set_cmdtree);
  command_success_nodata (si, " ");
  command_success_nodata (si, _("For more information, use \2/msg %s HELP SET \37command\37\2."), nicksvs.nick);
}

/* SET <setting> <parameters> */
static void
ns_cmd_set (sourceinfo_t *si, int parc, char *parv[])
{
  char *setting = parv[0];
  command_t const *c;

  if (si->smu == NULL)
    {
      command_fail (si, fault::noprivs, _("You are not logged in."));
      return;
    }

  if (setting == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "SET");
      command_fail (si, fault::needmoreparams, _("Syntax: SET <setting> <parameters>"));
      return;
    }

  /* take the command through the hash table */
  if ((c = ns_set_cmdtree.find (setting)))
    c->exec (si->service, si, parc - 1, parv + 1);
  else
    command_fail (si, fault::badparams, _("Invalid set command. Use \2/%s%s HELP SET\2 for a command listing."), (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.nick);
}

/* SET EMAIL <new address> */
static void
ns_cmd_setemail (sourceinfo_t *si, int parc, char *parv[])
{
  char *email = parv[0];

  if (si->smu == NULL)
    return;

  if (email == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "EMAIL");
      command_fail (si, fault::needmoreparams, _("Syntax: SET EMAIL <new e-mail>"));
      return;
    }

  if (strlen (email) >= EMAILLEN)
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "EMAIL");
      return;
    }

  if (si->smu->flags & MU_WAITAUTH)
    {
      command_fail (si, fault::noprivs, _("Please verify your original registration before changing your e-mail address."));
      return;
    }

  if (!validemail (email))
    {
      command_fail (si, fault::badparams, _("\2%s\2 is not a valid email address."), email);
      return;
    }

  if (!strcasecmp (si->smu->email, email))
    {
      command_fail (si, fault::nochange, _("The email address for \2%s\2 is already set to \2%s\2."), si->smu->name, si->smu->email);
      return;
    }

  snoop ("SET:EMAIL: \2%s\2 (\2%s\2 -> \2%s\2)", si->smu->name, si->smu->email, email);

  if (me.auth == AUTH_EMAIL)
    {
      unsigned long key = makekey ();

      si->smu->add_metadata ("private:verify:emailchg:key", itoa (key));
      si->smu->add_metadata ("private:verify:emailchg:newemail", email);
      si->smu->add_metadata ("private:verify:emailchg:timestamp", itoa (NOW));

      if (!sendemail (si->su != NULL ? si->su : si->service->me, EMAIL_SETEMAIL, si->smu, itoa (key)))
        {
          command_fail (si, fault::emailfail, _("Sending email failed, sorry! Your email address is unchanged."));
          si->smu->del_metadata ("private:verify:emailchg:key");
          si->smu->del_metadata ("private:verify:emailchg:newemail");
          si->smu->del_metadata ("private:verify:emailchg:timestamp");
          return;
        }

      logcommand (si, CMDLOG_SET, "SET EMAIL %s (awaiting verification)", email);
      command_success_nodata (si, _("An email containing email changing instructions has been sent to \2%s\2."), email);
      command_success_nodata (si, _("Your email address will not be changed until you follow these instructions."));

      return;
    }

  strlcpy (si->smu->email, email, EMAILLEN);

  logcommand (si, CMDLOG_SET, "SET EMAIL %s", email);
  command_success_nodata (si, _("The email address for \2%s\2 has been changed to \2%s\2."), si->smu->name, si->smu->email);
}

command_t const ns_set_email = { "EMAIL", N_("Changes your e-mail address."), AC_NONE, 1, ns_cmd_setemail };

/* SET HIDEMAIL [ON|OFF] */
static void
ns_cmd_sethidemail (sourceinfo_t *si, int parc, char *parv[])
{
  char *params = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (params == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "HIDEMAIL");
      return;
    }

  if (!strcasecmp ("ON", params))
    {
      if (MU_HIDEMAIL & si->smu->flags)
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "HIDEMAIL", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET HIDEMAIL ON");

      si->smu->flags |= MU_HIDEMAIL;

      command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "HIDEMAIL", si->smu->name);

      return;
    }
  else if (!strcasecmp ("OFF", params))
    {
      if (!(MU_HIDEMAIL & si->smu->flags))
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "HIDEMAIL", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET HIDEMAIL OFF");

      si->smu->flags &= ~MU_HIDEMAIL;

      command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "HIDEMAIL", si->smu->name);

      return;
    }
  else
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "HIDEMAIL");
      return;
    }
}

command_t const ns_set_hidemail = { "HIDEMAIL", N_("Hides your e-mail address."), AC_NONE, 1, ns_cmd_sethidemail };

static void
ns_cmd_setemailmemos (sourceinfo_t *si, int parc, char *parv[])
{
  char *params = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (si->smu->flags & MU_WAITAUTH)
    {
      command_fail (si, fault::noprivs, _("You have to verify your email address before you can enable emailing memos."));
      return;
    }

  if (params == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "EMAILMEMOS");
      return;
    }

  if (!strcasecmp ("ON", params))
    {
      if (me.mta == NULL)
        {
          command_fail (si, fault::emailfail, _("Sending email is administratively disabled."));
          return;
        }
      if (MU_EMAILMEMOS & si->smu->flags)
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "EMAILMEMOS", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET EMAILMEMOS ON");
      si->smu->flags |= MU_EMAILMEMOS;
      command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "EMAILMEMOS", si->smu->name);
      return;
    }

  else if (!strcasecmp ("OFF", params))
    {
      if (!(MU_EMAILMEMOS & si->smu->flags))
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "EMAILMEMOS", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET EMAILMEMOS OFF");
      si->smu->flags &= ~MU_EMAILMEMOS;
      command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "EMAILMEMOS", si->smu->name);
      return;
    }
  else
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "EMAILMEMOS");
      return;
    }
}

command_t const ns_set_emailmemos = { "EMAILMEMOS", N_("Forwards incoming memos to your e-mail address."), AC_NONE, 1, ns_cmd_setemailmemos };

static void
ns_cmd_setnomemo (sourceinfo_t *si, int parc, char *parv[])
{
  char *params = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (params == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NOMEMO");
      return;
    }

  if (!strcasecmp ("ON", params))
    {
      if (MU_NOMEMO & si->smu->flags)
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NOMEMO", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NOMEMO ON");
      si->smu->flags |= MU_NOMEMO;
      command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NOMEMO", si->smu->name);
      return;
    }

  else if (!strcasecmp ("OFF", params))
    {
      if (!(MU_NOMEMO & si->smu->flags))
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NOMEMO", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NOMEMO OFF");
      si->smu->flags &= ~MU_NOMEMO;
      command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NOMEMO", si->smu->name);
      return;
    }
  else
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NOMEMO");
      return;
    }
}

command_t const ns_set_nomemo = { "NOMEMO", N_("Disables the ability to recieve memos."), AC_NONE, 1, ns_cmd_setnomemo };

static void
ns_cmd_setneverop (sourceinfo_t *si, int parc, char *parv[])
{
  char *params = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (params == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NEVEROP");
      return;
    }

  if (!strcasecmp ("ON", params))
    {
      if (MU_NEVEROP & si->smu->flags)
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NEVEROP", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NEVEROP ON");

      si->smu->flags |= MU_NEVEROP;

      command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NEVEROP", si->smu->name);

      return;
    }

  else if (!strcasecmp ("OFF", params))
    {
      if (!(MU_NEVEROP & si->smu->flags))
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NEVEROP", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NEVEROP OFF");

      si->smu->flags &= ~MU_NEVEROP;

      command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NEVEROP", si->smu->name);

      return;
    }

  else
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NEVEROP");
      return;
    }
}

command_t const ns_set_neverop = { "NEVEROP", N_("Prevents you from being added to access lists."), AC_NONE, 1, ns_cmd_setneverop };

static void
ns_cmd_setnoop (sourceinfo_t *si, int parc, char *parv[])
{
  char *params = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (params == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NOOP");
      return;
    }

  if (!strcasecmp ("ON", params))
    {
      if (MU_NOOP & si->smu->flags)
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NOOP", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NOOP ON");

      si->smu->flags |= MU_NOOP;

      command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NOOP", si->smu->name);

      return;
    }
  else if (!strcasecmp ("OFF", params))
    {
      if (!(MU_NOOP & si->smu->flags))
        {
          command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NOOP", si->smu->name);
          return;
        }

      logcommand (si, CMDLOG_SET, "SET NOOP OFF");

      si->smu->flags &= ~MU_NOOP;

      command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NOOP", si->smu->name);

      return;
    }

  else
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NOOP");
      return;
    }
}

command_t const ns_set_noop = { "NOOP", N_("Prevents services from setting modes upon you automatically."), AC_NONE, 1, ns_cmd_setnoop };

static void
ns_cmd_setproperty (sourceinfo_t *si, int parc, char *parv[])
{
  char *tok[2] = { 0 };
  sjtoken (parv[0], ' ', tok, 2);
  char *property = tok[0];
  char *value = tok[1];

  if (si->smu == NULL)
    return;

  if (!property)
    {
      command_fail (si, fault::needmoreparams, _("Syntax: SET PROPERTY <property> [value]"));
      return;
    }

  if (strchr (property, ':') && !has_priv (si, PRIV_METADATA))
    {
      command_fail (si, fault::badparams, _("Invalid property name."));
      return;
    }

  if (strchr (property, ':'))
    snoop ("SET:PROPERTY: \2%s\2: \2%s\2/\2%s\2", si->smu->name, property, value);

  if (si->smu->mdmap.size () >= me.mdlimit)
    {
      command_fail (si, fault::toomany, _("Cannot add \2%s\2 to \2%s\2 metadata table, it is full."), property, si->smu->name);
      return;
    }

  if (!value)
    {
      metadata *md = si->smu->find_metadata (property);

      if (!md)
        {
          command_fail (si, fault::nosuch_target, _("Metadata entry \2%s\2 was not set."), property);
          return;
        }

      si->smu->del_metadata (property);
      logcommand (si, CMDLOG_SET, "SET PROPERTY %s (deleted)", property);
      command_success_nodata (si, _("Metadata entry \2%s\2 has been deleted."), property);
      return;
    }

  if (strlen (property) > 32 || strlen (value) > 300)
    {
      command_fail (si, fault::badparams, _("Parameters are too long. Aborting."));
      return;
    }

  si->smu->add_metadata (property, value);
  logcommand (si, CMDLOG_SET, "SET PROPERTY %s to %s", property, value);
  command_success_nodata (si, _("Metadata entry \2%s\2 added."), property);
}

command_t const ns_set_property = { "PROPERTY", N_("Manipulates metadata entries associated with a nickname."), AC_NONE, 2, ns_cmd_setproperty };

static void
ns_cmd_setqproperty (sourceinfo_t *si, int parc, char *parv[])
{
  char *property = strtok (parv[0], " ");
  char *value = strtok (NULL, "");

  if (si->smu == NULL)
    return;

  if (!property)
    {
      command_fail (si, fault::needmoreparams, _("Syntax: SET PROPERTY <property> [value]"));
      return;
    }

  if (strchr (property, ':') && !has_priv (si, PRIV_METADATA))
    {
      command_fail (si, fault::badparams, _("Invalid property name."));
      return;
    }

  if (strchr (property, ':'))
    snoop ("SET:PROPERTY: \2%s\2: \2%s\2/\2%s\2", si->smu->name, property, value);

  if (si->smu->mdmap.size () >= me.mdlimit)
    {
      command_fail (si, fault::toomany, _("Cannot add \2%s\2 to \2%s\2 metadata table, it is full."), property, si->smu->name);
      return;
    }

  if (!value)
    {
      metadata *md = si->smu->find_metadata (property);

      if (!md)
        {
          command_fail (si, fault::nosuch_target, _("Metadata entry \2%s\2 was not set."), property);
          return;
        }

      si->smu->del_metadata (property);
      logcommand (si, CMDLOG_SET, "SET PROPERTY %s (deleted)", property);
      return;
    }

  if (strlen (property) > 32 || strlen (value) > 300)
    return;

  si->smu->add_metadata (property, value);
  logcommand (si, CMDLOG_SET, "SET QPROPERTY %s to %s", property, value);
}

command_t const ns_set_qproperty = { "QPROPERTY", N_("Quietly manipulates metadata entries associated with a nickname."), AC_NONE, 2, ns_cmd_setqproperty };

static void
ns_cmd_setpassword (sourceinfo_t *si, int parc, char *parv[])
{
  char *password = strtok (parv[0], " ");

  if (si->smu == NULL)
    return;

  if (password == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "PASSWORD");
      return;
    }

  if (strlen (password) > 32)
    {
      command_fail (si, fault::badparams, STR_INVALID_PARAMS, "PASSWORD");
      return;
    }

  if (!strcasecmp (password, si->smu->name))
    {
      command_fail (si, fault::badparams, _("You cannot use your nickname as a password."));
      command_fail (si, fault::badparams, _("Syntax: SET PASSWORD <new password>"));
      return;
    }

  /*snoop("SET:PASSWORD: \2%s\2 as \2%s\2 for \2%s\2", si->su->user, si->smu->name, si->smu->name); */
  logcommand (si, CMDLOG_SET, "SET PASSWORD");

  si->smu->set_password (password);

  command_success_nodata (si, _("The password for \2%s\2 has been changed to \2%s\2. Please write this down for future reference."), si->smu->name, password);

  return;
}

command_t const ns_set_password = { "PASSWORD", N_("Changes the password associated with your nickname."), AC_NONE, 1, ns_cmd_setpassword };

static void
ns_cmd_setwhois (sourceinfo_t *si, int parc, char *parv[])
{
  char const * const value = parv[0];

  if (si->smu == NULL)
    return;

  if (value == NULL)
    {
      command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "WHOIS");
      return;
    }
  else if (!strcasecmp (value, "UNSET"))
    {
      phandler->mdchange (si->su->nick, "swhois", "");
      si->smu->del_metadata ("private:swhois");
      command_success_nodata (si, _("Your description has been removed."));
      return;
    }

  phandler->mdchange (si->su->nick, "swhois", value);
  si->smu->add_metadata ("private:swhois", value);

  command_success_nodata (si, _("Your description is now set to: \2%s\2"), value);

  return;
}

command_t const ns_set_whois = { "WHOIS", N_("Sets your WHOIS description."), AC_NONE, 1, ns_cmd_setwhois };

static void
whois_on_identify (user_t *u)
{
  metadata *md;

  if ((md = u->myuser->find_metadata ("private:swhois")) != NULL)
    phandler->mdchange (u->nick, "swhois", md->value);
}

command_t const *ns_set_commands[] = {
  &ns_set_email,
  &ns_set_emailmemos,
  &ns_set_hidemail,
  &ns_set_nomemo,
  &ns_set_noop,
  &ns_set_neverop,
  &ns_set_password,
  &ns_set_property,
  &ns_set_qproperty,
  &ns_set_whois,
  NULL
};

bool
_modinit (module *m)
{
  user_t::callback.identify.attach (whois_on_identify);

  ns_cmdtree << ns_set;

  help_addentry (ns_helptree, "SET", NULL, ns_help_set);
  help_addentry (ns_helptree, "SET EMAIL", "help/nickserv/set_email", NULL);
  help_addentry (ns_helptree, "SET EMAILMEMOS", "help/nickserv/set_emailmemos", NULL);
  help_addentry (ns_helptree, "SET HIDEMAIL", "help/nickserv/set_hidemail", NULL);
  help_addentry (ns_helptree, "SET NOMEMO", "help/nickserv/set_nomemo", NULL);
  help_addentry (ns_helptree, "SET NEVEROP", "help/nickserv/set_neverop", NULL);
  help_addentry (ns_helptree, "SET NOOP", "help/nickserv/set_noop", NULL);
  help_addentry (ns_helptree, "SET PASSWORD", "help/nickserv/set_password", NULL);
  help_addentry (ns_helptree, "SET PROPERTY", "help/nickserv/set_property", NULL);
  help_addentry (ns_helptree, "SET WHOIS", "help/nickserv/set_whois", NULL);

  /* populate ns_set_cmdtree */
  ns_set_cmdtree << ns_set_commands;

  return true;
}

void
_moddeinit ()
{
  user_t::callback.identify.detach (whois_on_identify);

  ns_cmdtree >> ns_set;

  help_delentry (ns_helptree, "SET");
  help_delentry (ns_helptree, "SET EMAIL");
  help_delentry (ns_helptree, "SET EMAILMEMOS");
  help_delentry (ns_helptree, "SET HIDEMAIL");
  help_delentry (ns_helptree, "SET NOMEMO");
  help_delentry (ns_helptree, "SET NEVEROP");
  help_delentry (ns_helptree, "SET NOOP");
  help_delentry (ns_helptree, "SET PASSWORD");
  help_delentry (ns_helptree, "SET PROPERTY");
  help_delentry (ns_helptree, "SET WHOIS");

  /* clear ns_set_cmdtree */
  ns_set_cmdtree >> ns_set_commands;
}
Revision:	1.10
Committed:	Sat Sep 22 14:27:28 2007 UTC (16 years, 8 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.9:	+5 -3 lines
Log Message:	split up ermyth into ermyth-modules, libermyth (currently just ermyth-util) and ermyth-core
#	Content
1	/**
2	* set.C: This file contains routines to handle the NickServ SET command.
3	*
4	* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
5	* Rights to this code are as documented in COPYING.
6	*
7	*
8	* Portions of this file were derived from sources bearing the following license:
9	* Copyright © 2006 William Pitcock, et al.
10	* Rights to this code are documented in doc/pod/license.pod.
11	*
12	* $Id: set.C,v 1.9 2007-09-16 18:54:43 pippijn Exp $
13	*/
14
15	#include "atheme.h"
16	#include <util/numeric.h>
17	#include <libermyth.h>
18	#include <ermyth/module.h>
19	#include <account/myuser.h>
20
21	static char const rcsid[] = "$Id: set.C,v 1.9 2007-09-16 18:54:43 pippijn Exp $";
22
23	REGISTER_MODULE ("nickserv/set", false, "The Ermyth Team <http://ermyth.xinutec.org>");
24
25	static void ns_cmd_set (sourceinfo_t si, int parc, char parv[]);
26
27	E cmdvec ns_cmdtree;
28	E helpvec ns_helptree;
29
30	command_t const ns_set = { "SET", N_("Sets various control flags."), AC_NONE, 2, ns_cmd_set };
31
32	cmdvec ns_set_cmdtree;
33
34	/* HELP SET */
35	static void
36	ns_help_set (sourceinfo_t *si)
37	{
38	command_success_nodata (si, _("Help for \2SET\2:"));
39	command_success_nodata (si, " ");
40	command_success_nodata (si, _("SET allows you to set various control flags"));
41	if (nicksvs.no_nick_ownership)
42	command_success_nodata (si, _("for accounts that change the way certain operations"));
43	else
44	command_success_nodata (si, _("for nicknames that change the way certain operations"));
45	command_success_nodata (si, _("are performed on them."));
46	command_success_nodata (si, " ");
47	command_help (si, ns_set_cmdtree);
48	command_success_nodata (si, " ");
49	command_success_nodata (si, _("For more information, use \2/msg %s HELP SET \37command\37\2."), nicksvs.nick);
50	}
51
52	/* SET <setting> <parameters> */
53	static void
54	ns_cmd_set (sourceinfo_t si, int parc, char parv[])
55	{
56	char *setting = parv[0];
57	command_t const *c;
58
59	if (si->smu == NULL)
60	{
61	command_fail (si, fault::noprivs, _("You are not logged in."));
62	return;
63	}
64
65	if (setting == NULL)
66	{
67	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "SET");
68	command_fail (si, fault::needmoreparams, _("Syntax: SET <setting> <parameters>"));
69	return;
70	}
71
72	/* take the command through the hash table */
73	if ((c = ns_set_cmdtree.find (setting)))
74	c->exec (si->service, si, parc - 1, parv + 1);
75	else
76	command_fail (si, fault::badparams, _("Invalid set command. Use \2/%s%s HELP SET\2 for a command listing."), (ircd->uses_rcommand == false) ? "msg " : "", nicksvs.nick);
77	}
78
79	/* SET EMAIL <new address> */
80	static void
81	ns_cmd_setemail (sourceinfo_t si, int parc, char parv[])
82	{
83	char *email = parv[0];
84
85	if (si->smu == NULL)
86	return;
87
88	if (email == NULL)
89	{
90	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "EMAIL");
91	command_fail (si, fault::needmoreparams, _("Syntax: SET EMAIL <new e-mail>"));
92	return;
93	}
94
95	if (strlen (email) >= EMAILLEN)
96	{
97	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "EMAIL");
98	return;
99	}
100
101	if (si->smu->flags & MU_WAITAUTH)
102	{
103	command_fail (si, fault::noprivs, _("Please verify your original registration before changing your e-mail address."));
104	return;
105	}
106
107	if (!validemail (email))
108	{
109	command_fail (si, fault::badparams, _("\2%s\2 is not a valid email address."), email);
110	return;
111	}
112
113	if (!strcasecmp (si->smu->email, email))
114	{
115	command_fail (si, fault::nochange, _("The email address for \2%s\2 is already set to \2%s\2."), si->smu->name, si->smu->email);
116	return;
117	}
118
119	snoop ("SET:EMAIL: \2%s\2 (\2%s\2 -> \2%s\2)", si->smu->name, si->smu->email, email);
120
121	if (me.auth == AUTH_EMAIL)
122	{
123	unsigned long key = makekey ();
124
125	si->smu->add_metadata ("private:verify:emailchg:key", itoa (key));
126	si->smu->add_metadata ("private:verify:emailchg:newemail", email);
127	si->smu->add_metadata ("private:verify:emailchg:timestamp", itoa (NOW));
128
129	if (!sendemail (si->su != NULL ? si->su : si->service->me, EMAIL_SETEMAIL, si->smu, itoa (key)))
130	{
131	command_fail (si, fault::emailfail, _("Sending email failed, sorry! Your email address is unchanged."));
132	si->smu->del_metadata ("private:verify:emailchg:key");
133	si->smu->del_metadata ("private:verify:emailchg:newemail");
134	si->smu->del_metadata ("private:verify:emailchg:timestamp");
135	return;
136	}
137
138	logcommand (si, CMDLOG_SET, "SET EMAIL %s (awaiting verification)", email);
139	command_success_nodata (si, _("An email containing email changing instructions has been sent to \2%s\2."), email);
140	command_success_nodata (si, _("Your email address will not be changed until you follow these instructions."));
141
142	return;
143	}
144
145	strlcpy (si->smu->email, email, EMAILLEN);
146
147	logcommand (si, CMDLOG_SET, "SET EMAIL %s", email);
148	command_success_nodata (si, _("The email address for \2%s\2 has been changed to \2%s\2."), si->smu->name, si->smu->email);
149	}
150
151	command_t const ns_set_email = { "EMAIL", N_("Changes your e-mail address."), AC_NONE, 1, ns_cmd_setemail };
152
153	/* SET HIDEMAIL [ON\|OFF] */
154	static void
155	ns_cmd_sethidemail (sourceinfo_t si, int parc, char parv[])
156	{
157	char *params = strtok (parv[0], " ");
158
159	if (si->smu == NULL)
160	return;
161
162	if (params == NULL)
163	{
164	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "HIDEMAIL");
165	return;
166	}
167
168	if (!strcasecmp ("ON", params))
169	{
170	if (MU_HIDEMAIL & si->smu->flags)
171	{
172	command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "HIDEMAIL", si->smu->name);
173	return;
174	}
175
176	logcommand (si, CMDLOG_SET, "SET HIDEMAIL ON");
177
178	si->smu->flags \|= MU_HIDEMAIL;
179
180	command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "HIDEMAIL", si->smu->name);
181
182	return;
183	}
184	else if (!strcasecmp ("OFF", params))
185	{
186	if (!(MU_HIDEMAIL & si->smu->flags))
187	{
188	command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "HIDEMAIL", si->smu->name);
189	return;
190	}
191
192	logcommand (si, CMDLOG_SET, "SET HIDEMAIL OFF");
193
194	si->smu->flags &= ~MU_HIDEMAIL;
195
196	command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "HIDEMAIL", si->smu->name);
197
198	return;
199	}
200	else
201	{
202	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "HIDEMAIL");
203	return;
204	}
205	}
206
207	command_t const ns_set_hidemail = { "HIDEMAIL", N_("Hides your e-mail address."), AC_NONE, 1, ns_cmd_sethidemail };
208
209	static void
210	ns_cmd_setemailmemos (sourceinfo_t si, int parc, char parv[])
211	{
212	char *params = strtok (parv[0], " ");
213
214	if (si->smu == NULL)
215	return;
216
217	if (si->smu->flags & MU_WAITAUTH)
218	{
219	command_fail (si, fault::noprivs, _("You have to verify your email address before you can enable emailing memos."));
220	return;
221	}
222
223	if (params == NULL)
224	{
225	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "EMAILMEMOS");
226	return;
227	}
228
229	if (!strcasecmp ("ON", params))
230	{
231	if (me.mta == NULL)
232	{
233	command_fail (si, fault::emailfail, _("Sending email is administratively disabled."));
234	return;
235	}
236	if (MU_EMAILMEMOS & si->smu->flags)
237	{
238	command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "EMAILMEMOS", si->smu->name);
239	return;
240	}
241
242	logcommand (si, CMDLOG_SET, "SET EMAILMEMOS ON");
243	si->smu->flags \|= MU_EMAILMEMOS;
244	command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "EMAILMEMOS", si->smu->name);
245	return;
246	}
247
248	else if (!strcasecmp ("OFF", params))
249	{
250	if (!(MU_EMAILMEMOS & si->smu->flags))
251	{
252	command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "EMAILMEMOS", si->smu->name);
253	return;
254	}
255
256	logcommand (si, CMDLOG_SET, "SET EMAILMEMOS OFF");
257	si->smu->flags &= ~MU_EMAILMEMOS;
258	command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "EMAILMEMOS", si->smu->name);
259	return;
260	}
261	else
262	{
263	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "EMAILMEMOS");
264	return;
265	}
266	}
267
268	command_t const ns_set_emailmemos = { "EMAILMEMOS", N_("Forwards incoming memos to your e-mail address."), AC_NONE, 1, ns_cmd_setemailmemos };
269
270	static void
271	ns_cmd_setnomemo (sourceinfo_t si, int parc, char parv[])
272	{
273	char *params = strtok (parv[0], " ");
274
275	if (si->smu == NULL)
276	return;
277
278	if (params == NULL)
279	{
280	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NOMEMO");
281	return;
282	}
283
284	if (!strcasecmp ("ON", params))
285	{
286	if (MU_NOMEMO & si->smu->flags)
287	{
288	command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NOMEMO", si->smu->name);
289	return;
290	}
291
292	logcommand (si, CMDLOG_SET, "SET NOMEMO ON");
293	si->smu->flags \|= MU_NOMEMO;
294	command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NOMEMO", si->smu->name);
295	return;
296	}
297
298	else if (!strcasecmp ("OFF", params))
299	{
300	if (!(MU_NOMEMO & si->smu->flags))
301	{
302	command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NOMEMO", si->smu->name);
303	return;
304	}
305
306	logcommand (si, CMDLOG_SET, "SET NOMEMO OFF");
307	si->smu->flags &= ~MU_NOMEMO;
308	command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NOMEMO", si->smu->name);
309	return;
310	}
311	else
312	{
313	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NOMEMO");
314	return;
315	}
316	}
317
318	command_t const ns_set_nomemo = { "NOMEMO", N_("Disables the ability to recieve memos."), AC_NONE, 1, ns_cmd_setnomemo };
319
320	static void
321	ns_cmd_setneverop (sourceinfo_t si, int parc, char parv[])
322	{
323	char *params = strtok (parv[0], " ");
324
325	if (si->smu == NULL)
326	return;
327
328	if (params == NULL)
329	{
330	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NEVEROP");
331	return;
332	}
333
334	if (!strcasecmp ("ON", params))
335	{
336	if (MU_NEVEROP & si->smu->flags)
337	{
338	command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NEVEROP", si->smu->name);
339	return;
340	}
341
342	logcommand (si, CMDLOG_SET, "SET NEVEROP ON");
343
344	si->smu->flags \|= MU_NEVEROP;
345
346	command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NEVEROP", si->smu->name);
347
348	return;
349	}
350
351	else if (!strcasecmp ("OFF", params))
352	{
353	if (!(MU_NEVEROP & si->smu->flags))
354	{
355	command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NEVEROP", si->smu->name);
356	return;
357	}
358
359	logcommand (si, CMDLOG_SET, "SET NEVEROP OFF");
360
361	si->smu->flags &= ~MU_NEVEROP;
362
363	command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NEVEROP", si->smu->name);
364
365	return;
366	}
367
368	else
369	{
370	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NEVEROP");
371	return;
372	}
373	}
374
375	command_t const ns_set_neverop = { "NEVEROP", N_("Prevents you from being added to access lists."), AC_NONE, 1, ns_cmd_setneverop };
376
377	static void
378	ns_cmd_setnoop (sourceinfo_t si, int parc, char parv[])
379	{
380	char *params = strtok (parv[0], " ");
381
382	if (si->smu == NULL)
383	return;
384
385	if (params == NULL)
386	{
387	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "NOOP");
388	return;
389	}
390
391	if (!strcasecmp ("ON", params))
392	{
393	if (MU_NOOP & si->smu->flags)
394	{
395	command_fail (si, fault::nochange, _("The \2%s\2 flag is already set for \2%s\2."), "NOOP", si->smu->name);
396	return;
397	}
398
399	logcommand (si, CMDLOG_SET, "SET NOOP ON");
400
401	si->smu->flags \|= MU_NOOP;
402
403	command_success_nodata (si, _("The \2%s\2 flag has been set for \2%s\2."), "NOOP", si->smu->name);
404
405	return;
406	}
407	else if (!strcasecmp ("OFF", params))
408	{
409	if (!(MU_NOOP & si->smu->flags))
410	{
411	command_fail (si, fault::nochange, _("The \2%s\2 flag is not set for \2%s\2."), "NOOP", si->smu->name);
412	return;
413	}
414
415	logcommand (si, CMDLOG_SET, "SET NOOP OFF");
416
417	si->smu->flags &= ~MU_NOOP;
418
419	command_success_nodata (si, _("The \2%s\2 flag has been removed for \2%s\2."), "NOOP", si->smu->name);
420
421	return;
422	}
423
424	else
425	{
426	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "NOOP");
427	return;
428	}
429	}
430
431	command_t const ns_set_noop = { "NOOP", N_("Prevents services from setting modes upon you automatically."), AC_NONE, 1, ns_cmd_setnoop };
432
433	static void
434	ns_cmd_setproperty (sourceinfo_t si, int parc, char parv[])
435	{
436	char *tok[2] = { 0 };
437	sjtoken (parv[0], ' ', tok, 2);
438	char *property = tok[0];
439	char *value = tok[1];
440
441	if (si->smu == NULL)
442	return;
443
444	if (!property)
445	{
446	command_fail (si, fault::needmoreparams, _("Syntax: SET PROPERTY <property> [value]"));
447	return;
448	}
449
450	if (strchr (property, ':') && !has_priv (si, PRIV_METADATA))
451	{
452	command_fail (si, fault::badparams, _("Invalid property name."));
453	return;
454	}
455
456	if (strchr (property, ':'))
457	snoop ("SET:PROPERTY: \2%s\2: \2%s\2/\2%s\2", si->smu->name, property, value);
458
459	if (si->smu->mdmap.size () >= me.mdlimit)
460	{
461	command_fail (si, fault::toomany, _("Cannot add \2%s\2 to \2%s\2 metadata table, it is full."), property, si->smu->name);
462	return;
463	}
464
465	if (!value)
466	{
467	metadata *md = si->smu->find_metadata (property);
468
469	if (!md)
470	{
471	command_fail (si, fault::nosuch_target, _("Metadata entry \2%s\2 was not set."), property);
472	return;
473	}
474
475	si->smu->del_metadata (property);
476	logcommand (si, CMDLOG_SET, "SET PROPERTY %s (deleted)", property);
477	command_success_nodata (si, _("Metadata entry \2%s\2 has been deleted."), property);
478	return;
479	}
480
481	if (strlen (property) > 32 \|\| strlen (value) > 300)
482	{
483	command_fail (si, fault::badparams, _("Parameters are too long. Aborting."));
484	return;
485	}
486
487	si->smu->add_metadata (property, value);
488	logcommand (si, CMDLOG_SET, "SET PROPERTY %s to %s", property, value);
489	command_success_nodata (si, _("Metadata entry \2%s\2 added."), property);
490	}
491
492	command_t const ns_set_property = { "PROPERTY", N_("Manipulates metadata entries associated with a nickname."), AC_NONE, 2, ns_cmd_setproperty };
493
494	static void
495	ns_cmd_setqproperty (sourceinfo_t si, int parc, char parv[])
496	{
497	char *property = strtok (parv[0], " ");
498	char *value = strtok (NULL, "");
499
500	if (si->smu == NULL)
501	return;
502
503	if (!property)
504	{
505	command_fail (si, fault::needmoreparams, _("Syntax: SET PROPERTY <property> [value]"));
506	return;
507	}
508
509	if (strchr (property, ':') && !has_priv (si, PRIV_METADATA))
510	{
511	command_fail (si, fault::badparams, _("Invalid property name."));
512	return;
513	}
514
515	if (strchr (property, ':'))
516	snoop ("SET:PROPERTY: \2%s\2: \2%s\2/\2%s\2", si->smu->name, property, value);
517
518	if (si->smu->mdmap.size () >= me.mdlimit)
519	{
520	command_fail (si, fault::toomany, _("Cannot add \2%s\2 to \2%s\2 metadata table, it is full."), property, si->smu->name);
521	return;
522	}
523
524	if (!value)
525	{
526	metadata *md = si->smu->find_metadata (property);
527
528	if (!md)
529	{
530	command_fail (si, fault::nosuch_target, _("Metadata entry \2%s\2 was not set."), property);
531	return;
532	}
533
534	si->smu->del_metadata (property);
535	logcommand (si, CMDLOG_SET, "SET PROPERTY %s (deleted)", property);
536	return;
537	}
538
539	if (strlen (property) > 32 \|\| strlen (value) > 300)
540	return;
541
542	si->smu->add_metadata (property, value);
543	logcommand (si, CMDLOG_SET, "SET QPROPERTY %s to %s", property, value);
544	}
545
546	command_t const ns_set_qproperty = { "QPROPERTY", N_("Quietly manipulates metadata entries associated with a nickname."), AC_NONE, 2, ns_cmd_setqproperty };
547
548	static void
549	ns_cmd_setpassword (sourceinfo_t si, int parc, char parv[])
550	{
551	char *password = strtok (parv[0], " ");
552
553	if (si->smu == NULL)
554	return;
555
556	if (password == NULL)
557	{
558	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "PASSWORD");
559	return;
560	}
561
562	if (strlen (password) > 32)
563	{
564	command_fail (si, fault::badparams, STR_INVALID_PARAMS, "PASSWORD");
565	return;
566	}
567
568	if (!strcasecmp (password, si->smu->name))
569	{
570	command_fail (si, fault::badparams, _("You cannot use your nickname as a password."));
571	command_fail (si, fault::badparams, _("Syntax: SET PASSWORD <new password>"));
572	return;
573	}
574
575	/snoop("SET:PASSWORD: \2%s\2 as \2%s\2 for \2%s\2", si->su->user, si->smu->name, si->smu->name); /
576	logcommand (si, CMDLOG_SET, "SET PASSWORD");
577
578	si->smu->set_password (password);
579
580	command_success_nodata (si, _("The password for \2%s\2 has been changed to \2%s\2. Please write this down for future reference."), si->smu->name, password);
581
582	return;
583	}
584
585	command_t const ns_set_password = { "PASSWORD", N_("Changes the password associated with your nickname."), AC_NONE, 1, ns_cmd_setpassword };
586
587	static void
588	ns_cmd_setwhois (sourceinfo_t si, int parc, char parv[])
589	{
590	char const * const value = parv[0];
591
592	if (si->smu == NULL)
593	return;
594
595	if (value == NULL)
596	{
597	command_fail (si, fault::needmoreparams, STR_INSUFFICIENT_PARAMS, "WHOIS");
598	return;
599	}
600	else if (!strcasecmp (value, "UNSET"))
601	{
602	phandler->mdchange (si->su->nick, "swhois", "");
603	si->smu->del_metadata ("private:swhois");
604	command_success_nodata (si, _("Your description has been removed."));
605	return;
606	}
607
608	phandler->mdchange (si->su->nick, "swhois", value);
609	si->smu->add_metadata ("private:swhois", value);
610
611	command_success_nodata (si, _("Your description is now set to: \2%s\2"), value);
612
613	return;
614	}
615
616	command_t const ns_set_whois = { "WHOIS", N_("Sets your WHOIS description."), AC_NONE, 1, ns_cmd_setwhois };
617
618	static void
619	whois_on_identify (user_t *u)
620	{
621	metadata *md;
622
623	if ((md = u->myuser->find_metadata ("private:swhois")) != NULL)
624	phandler->mdchange (u->nick, "swhois", md->value);
625	}
626
627	command_t const *ns_set_commands[] = {
628	&ns_set_email,
629	&ns_set_emailmemos,
630	&ns_set_hidemail,
631	&ns_set_nomemo,
632	&ns_set_noop,
633	&ns_set_neverop,
634	&ns_set_password,
635	&ns_set_property,
636	&ns_set_qproperty,
637	&ns_set_whois,
638	NULL
639	};
640
641	bool
642	_modinit (module *m)
643	{
644	user_t::callback.identify.attach (whois_on_identify);
645
646	ns_cmdtree << ns_set;
647
648	help_addentry (ns_helptree, "SET", NULL, ns_help_set);
649	help_addentry (ns_helptree, "SET EMAIL", "help/nickserv/set_email", NULL);
650	help_addentry (ns_helptree, "SET EMAILMEMOS", "help/nickserv/set_emailmemos", NULL);
651	help_addentry (ns_helptree, "SET HIDEMAIL", "help/nickserv/set_hidemail", NULL);
652	help_addentry (ns_helptree, "SET NOMEMO", "help/nickserv/set_nomemo", NULL);
653	help_addentry (ns_helptree, "SET NEVEROP", "help/nickserv/set_neverop", NULL);
654	help_addentry (ns_helptree, "SET NOOP", "help/nickserv/set_noop", NULL);
655	help_addentry (ns_helptree, "SET PASSWORD", "help/nickserv/set_password", NULL);
656	help_addentry (ns_helptree, "SET PROPERTY", "help/nickserv/set_property", NULL);
657	help_addentry (ns_helptree, "SET WHOIS", "help/nickserv/set_whois", NULL);
658
659	/* populate ns_set_cmdtree */
660	ns_set_cmdtree << ns_set_commands;
661
662	return true;
663	}
664
665	void
666	_moddeinit ()
667	{
668	user_t::callback.identify.detach (whois_on_identify);
669
670	ns_cmdtree >> ns_set;
671
672	help_delentry (ns_helptree, "SET");
673	help_delentry (ns_helptree, "SET EMAIL");
674	help_delentry (ns_helptree, "SET EMAILMEMOS");
675	help_delentry (ns_helptree, "SET HIDEMAIL");
676	help_delentry (ns_helptree, "SET NOMEMO");
677	help_delentry (ns_helptree, "SET NEVEROP");
678	help_delentry (ns_helptree, "SET NOOP");
679	help_delentry (ns_helptree, "SET PASSWORD");
680	help_delentry (ns_helptree, "SET PROPERTY");
681	help_delentry (ns_helptree, "SET WHOIS");
682
683	/* clear ns_set_cmdtree */
684	ns_set_cmdtree >> ns_set_commands;
685	}