8.2.x/modules/m_svsmode.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 1999 Bahamut development team.
 *  Copyright (c) 2011-2016 ircd-hybrid development team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

/*! \file m_svsmode.c
 * \brief Includes required functions for processing the SVSMODE command.
 * \version $Id$
 */

#include "stdinc.h"
#include "client.h"
#include "ircd.h"
#include "send.h"
#include "channel_mode.h"
#include "parse.h"
#include "modules.h"
#include "irc_string.h"
#include "user.h"
#include "conf.h"


/*! \brief SVSMODE command handler
 *
 * \param source_p Pointer to allocated Client struct from which the message
 *                 originally comes from.  This can be a local or remote client.
 * \param parc     Integer holding the number of supplied arguments.
 * \param parv     Argument vector where parv[0] .. parv[parc-1] are non-NULL
 *                 pointers.
 * \note Valid arguments for this command are:
 *      - parv[0] = command
 *      - parv[1] = nickname
 *      - parv[2] = TS
 *      - parv[3] = mode
 *      - parv[4] = optional argument (services account, vhost)
 */
static int
ms_svsmode(struct Client *source_p, int parc, char *parv[])
{
  const struct user_modes *tab = NULL;
  struct Client *target_p = NULL;
  int what = MODE_ADD;
  unsigned int setmodes = 0;
  const char *modes = NULL, *extarg = NULL;

  if (!HasFlag(source_p, FLAGS_SERVICE))
    return 0;

  modes  = parv[3];
  extarg = (parc > 4) ? parv[4] : NULL;

  if ((target_p = find_person(source_p, parv[1])) == NULL)
    return 0;

  uintmax_t ts = strtoumax(parv[2], NULL, 10);
  if (ts && (ts != target_p->tsinfo))
    return 0;

  setmodes = target_p->umodes;

  for (const char *m = modes; *m; ++m)
  {
    switch (*m)
    {
      case '+':
        what = MODE_ADD;
        break;
      case '-':
        what = MODE_DEL;
        break;

      case 'd':
        if (!EmptyString(extarg))
        {
          strlcpy(target_p->account, extarg, sizeof(target_p->account));
          sendto_common_channels_local(target_p, 1, CAP_ACCOUNT_NOTIFY, 0, ":%s!%s@%s ACCOUNT %s",
                                       target_p->name, target_p->username,
                                       target_p->host, target_p->account);
        }

        break;

      case 'x':
        if (!EmptyString(extarg) && valid_hostname(extarg))
          user_set_hostmask(target_p, extarg, what);
        break;

      case 'o':
        if (what == MODE_DEL && HasUMode(target_p, UMODE_OPER))
        {
          ClearOper(target_p);
          --Count.oper;

          if (MyConnect(target_p))
          {
            dlink_node *node = NULL;

            detach_conf(target_p, CONF_OPER);
            ClrOFlag(target_p);
            DelUMode(target_p, ConfigGeneral.oper_only_umodes);

            if ((node = dlinkFindDelete(&oper_list, target_p)))
              free_dlink_node(node);
          }
        }

        break;

      case 'i':
        if (what == MODE_ADD && !HasUMode(target_p, UMODE_INVISIBLE))
        {
          AddUMode(target_p, UMODE_INVISIBLE);
          ++Count.invisi;
        }
        else if (what == MODE_DEL && HasUMode(target_p, UMODE_INVISIBLE))
        {
          DelUMode(target_p, UMODE_INVISIBLE);
          --Count.invisi;
        }

        break;

      case 'S':  /* Only servers may set +S in a burst */
      case 'W':  /* Only servers may set +W in a burst */
        break;

      default:
        if ((tab = umode_map[(unsigned char)*m]))
        {
          if (what == MODE_ADD)
            AddUMode(target_p, tab->flag);
          else
            DelUMode(target_p, tab->flag);
        }

        break;
    }
  }

  if (extarg)
    sendto_server(source_p, 0, 0, ":%s SVSMODE %s %ju %s %s",
                  source_p->id,
                  target_p->id, target_p->tsinfo, modes, extarg);
  else
    sendto_server(source_p, 0, 0, ":%s SVSMODE %s %ju %s",
                  source_p->id,
                  target_p->id, target_p->tsinfo, modes);

  if (MyConnect(target_p) && (setmodes != target_p->umodes))
  {
    char modebuf[IRCD_BUFSIZE] = "";

    send_umode(target_p, target_p, setmodes, modebuf);
  }

  return 0;
}

static struct Message svsmode_msgtab =
{
  .cmd = "SVSMODE",
  .args_min = 4,
  .args_max = MAXPARA,
  .handlers[UNREGISTERED_HANDLER] = m_ignore,
  .handlers[CLIENT_HANDLER] = m_ignore,
  .handlers[SERVER_HANDLER] = ms_svsmode,
  .handlers[ENCAP_HANDLER] = m_ignore,
  .handlers[OPER_HANDLER] = m_ignore
};

static void
module_init(void)
{
  mod_add_cmd(&svsmode_msgtab);
}

static void
module_exit(void)
{
  mod_del_cmd(&svsmode_msgtab);
}

struct module module_entry =
{
  .version = "$Revision$",
  .modinit = module_init,
  .modexit = module_exit,
};
1	/*
2	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	*
4	* Copyright (c) 1999 Bahamut development team.
5	* Copyright (c) 2011-2016 ircd-hybrid development team
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
20	* USA
21	*/
22
23	/*! \file m_svsmode.c
24	* \brief Includes required functions for processing the SVSMODE command.
25	* \version $Id$
26	*/
27
28	#include "stdinc.h"
29	#include "client.h"
30	#include "ircd.h"
31	#include "send.h"
32	#include "channel_mode.h"
33	#include "parse.h"
34	#include "modules.h"
35	#include "irc_string.h"
36	#include "user.h"
37	#include "conf.h"
38
39
40	/*! \brief SVSMODE command handler
41	*
42	* \param source_p Pointer to allocated Client struct from which the message
43	* originally comes from. This can be a local or remote client.
44	* \param parc Integer holding the number of supplied arguments.
45	* \param parv Argument vector where parv[0] .. parv[parc-1] are non-NULL
46	* pointers.
47	* \note Valid arguments for this command are:
48	* - parv[0] = command
49	* - parv[1] = nickname
50	* - parv[2] = TS
51	* - parv[3] = mode
52	* - parv[4] = optional argument (services account, vhost)
53	*/
54	static int
55	ms_svsmode(struct Client source_p, int parc, char parv[])
56	{
57	const struct user_modes *tab = NULL;
58	struct Client *target_p = NULL;
59	int what = MODE_ADD;
60	unsigned int setmodes = 0;
61	const char modes = NULL, extarg = NULL;
62
63	if (!HasFlag(source_p, FLAGS_SERVICE))
64	return 0;
65
66	modes = parv[3];
67	extarg = (parc > 4) ? parv[4] : NULL;
68
69	if ((target_p = find_person(source_p, parv[1])) == NULL)
70	return 0;
71
72	uintmax_t ts = strtoumax(parv[2], NULL, 10);
73	if (ts && (ts != target_p->tsinfo))
74	return 0;
75
76	setmodes = target_p->umodes;
77
78	for (const char m = modes; m; ++m)
79	{
80	switch (*m)
81	{
82	case '+':
83	what = MODE_ADD;
84	break;
85	case '-':
86	what = MODE_DEL;
87	break;
88
89	case 'd':
90	if (!EmptyString(extarg))
91	{
92	strlcpy(target_p->account, extarg, sizeof(target_p->account));
93	sendto_common_channels_local(target_p, 1, CAP_ACCOUNT_NOTIFY, 0, ":%s!%s@%s ACCOUNT %s",
94	target_p->name, target_p->username,
95	target_p->host, target_p->account);
96	}
97
98	break;
99
100	case 'x':
101	if (!EmptyString(extarg) && valid_hostname(extarg))
102	user_set_hostmask(target_p, extarg, what);
103	break;
104
105	case 'o':
106	if (what == MODE_DEL && HasUMode(target_p, UMODE_OPER))
107	{
108	ClearOper(target_p);
109	--Count.oper;
110
111	if (MyConnect(target_p))
112	{
113	dlink_node *node = NULL;
114
115	detach_conf(target_p, CONF_OPER);
116	ClrOFlag(target_p);
117	DelUMode(target_p, ConfigGeneral.oper_only_umodes);
118
119	if ((node = dlinkFindDelete(&oper_list, target_p)))
120	free_dlink_node(node);
121	}
122	}
123
124	break;
125
126	case 'i':
127	if (what == MODE_ADD && !HasUMode(target_p, UMODE_INVISIBLE))
128	{
129	AddUMode(target_p, UMODE_INVISIBLE);
130	++Count.invisi;
131	}
132	else if (what == MODE_DEL && HasUMode(target_p, UMODE_INVISIBLE))
133	{
134	DelUMode(target_p, UMODE_INVISIBLE);
135	--Count.invisi;
136	}
137
138	break;
139
140	case 'S': /* Only servers may set +S in a burst */
141	case 'W': /* Only servers may set +W in a burst */
142	break;
143
144	default:
145	if ((tab = umode_map[(unsigned char)*m]))
146	{
147	if (what == MODE_ADD)
148	AddUMode(target_p, tab->flag);
149	else
150	DelUMode(target_p, tab->flag);
151	}
152
153	break;
154	}
155	}
156
157	if (extarg)
158	sendto_server(source_p, 0, 0, ":%s SVSMODE %s %ju %s %s",
159	source_p->id,
160	target_p->id, target_p->tsinfo, modes, extarg);
161	else
162	sendto_server(source_p, 0, 0, ":%s SVSMODE %s %ju %s",
163	source_p->id,
164	target_p->id, target_p->tsinfo, modes);
165
166	if (MyConnect(target_p) && (setmodes != target_p->umodes))
167	{
168	char modebuf[IRCD_BUFSIZE] = "";
169
170	send_umode(target_p, target_p, setmodes, modebuf);
171	}
172
173	return 0;
174	}
175
176	static struct Message svsmode_msgtab =
177	{
178	.cmd = "SVSMODE",
179	.args_min = 4,
180	.args_max = MAXPARA,
181	.handlers[UNREGISTERED_HANDLER] = m_ignore,
182	.handlers[CLIENT_HANDLER] = m_ignore,
183	.handlers[SERVER_HANDLER] = ms_svsmode,
184	.handlers[ENCAP_HANDLER] = m_ignore,
185	.handlers[OPER_HANDLER] = m_ignore
186	};
187
188	static void
189	module_init(void)
190	{
191	mod_add_cmd(&svsmode_msgtab);
192	}
193
194	static void
195	module_exit(void)
196	{
197	mod_del_cmd(&svsmode_msgtab);
198	}
199
200	struct module module_entry =
201	{
202	.version = "$Revision$",
203	.modinit = module_init,
204	.modexit = module_exit,
205	};
svnadmin@ircd-hybrid.org	ViewVC Help
Powered by ViewVC 1.1.28