modules/core/m_mode.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  m_mode.c: Sets a user or channel mode.
 *
 *  Copyright (C) 2002 by the past and present ircd coders, and others.
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id$
 */

#include "stdinc.h"
#include "list.h"
#include "handlers.h"
#include "channel.h"
#include "channel_mode.h"
#include "client.h"
#include "hash.h"
#include "irc_string.h"
#include "sprintf_irc.h"
#include "ircd.h"
#include "numeric.h"
#include "s_user.h"
#include "s_conf.h"
#include "s_serv.h"
#include "send.h"
#include "msg.h"
#include "parse.h"
#include "modules.h"
#include "packet.h"

static void m_mode(struct Client *, struct Client *, int, char *[]);
static void ms_tmode(struct Client *, struct Client *, int, char *[]);
static void ms_bmask(struct Client *, struct Client *, int, char *[]);

struct Message mode_msgtab = {
  "MODE", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
  {m_unregistered, m_mode, m_mode, m_ignore, m_mode, m_ignore}
};

struct Message tmode_msgtab = { 
  "TMODE", 0, 0, 4, MAXPARA, MFLG_SLOW, 0,
  {m_ignore, m_ignore, ms_tmode, m_ignore, m_ignore, m_ignore}
};

struct Message bmask_msgtab = {
  "BMASK", 0, 0, 5, MAXPARA, MFLG_SLOW, 0,
  {m_ignore, m_ignore, ms_bmask, m_ignore, m_ignore, m_ignore}
};

void
_modinit(void)
{
  mod_add_cmd(&mode_msgtab);
  mod_add_cmd(&tmode_msgtab);
  mod_add_cmd(&bmask_msgtab);
}

void
_moddeinit(void)
{
  mod_del_cmd(&mode_msgtab);
  mod_del_cmd(&tmode_msgtab);
  mod_del_cmd(&bmask_msgtab);
}

const char *_version = "$Revision$";

/*
 * m_mode - MODE command handler
 * parv[0] - sender
 * parv[1] - channel
 */
static void
m_mode(struct Client *client_p, struct Client *source_p,
       int parc, char *parv[])
{
  struct Channel *chptr = NULL;
  struct Membership *member;
  static char modebuf[MODEBUFLEN];
  static char parabuf[MODEBUFLEN];

  if (EmptyString(parv[1]))
  {
    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
               me.name, source_p->name, "MODE");
    return;
  }

  /* Now, try to find the channel in question */
  if (!IsChanPrefix(*parv[1]))
  {
    /* if here, it has to be a non-channel name */
    set_user_mode(client_p, source_p, parc, parv);
    return;
  }

  if ((chptr = hash_find_channel(parv[1])) == NULL)
  {
    sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
               ID_or_name(&me, source_p->from),
               ID_or_name(source_p, source_p->from),
               parv[1]);
    return;
  }

  /* Now known the channel exists */
  if (parc < 3)
  {
    channel_modes(chptr, source_p, modebuf, parabuf);
    sendto_one(source_p, form_str(RPL_CHANNELMODEIS),
               me.name, source_p->name, chptr->chname, modebuf, parabuf);
    sendto_one(source_p, form_str(RPL_CREATIONTIME),
               me.name, source_p->name, chptr->chname, chptr->channelts);
  }
  /* bounce all modes from people we deop on sjoin
   * servers have always gotten away with murder,
   * including telnet servers *g* - Dianora
   *
   * XXX Is it worth the bother to make an ms_mode() ? - Dianora
   */
  else if (IsServer(source_p))
  {
    set_channel_mode(client_p, source_p, chptr, NULL, parc - 2, parv + 2,
                     chptr->chname);
  }
  else
  {
    member = find_channel_link(source_p, chptr);

    if (!has_member_flags(member, CHFL_DEOPPED))
    {
      /* Finish the flood grace period... */
      if (MyClient(source_p) && !IsFloodDone(source_p))
      {
        if (!((parc == 3) && (parv[2][0] == 'b') && (parv[2][1] == '\0')))
          flood_endgrace(source_p);
      }

      set_channel_mode(client_p, source_p, chptr, member, parc - 2, parv + 2,
                       chptr->chname);
    }
  }
}

/*
 * ms_tmode()
 *
 * inputs       - parv[0] = UID
 *                parv[1] = TS
 *                parv[2] = channel name
 *                parv[3] = modestring
 */
static void
ms_tmode(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
  struct Channel *chptr = NULL;
  struct Membership *member = NULL;

  if ((chptr = hash_find_channel(parv[2])) == NULL)
  {
    sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
               ID_or_name(&me, client_p), ID_or_name(source_p, client_p), parv[2]);
    return;
  }

  if (atol(parv[1]) > chptr->channelts)
    return;

  if (IsServer(source_p))
    set_channel_mode(client_p, source_p, chptr, NULL, parc - 3, parv + 3, chptr->chname);
  else
  {
    member = find_channel_link(source_p, chptr);

    /* XXX are we sure we just want to bail here? */
    if (has_member_flags(member, CHFL_DEOPPED))
      return;

    set_channel_mode(client_p, source_p, chptr, member, parc - 3, parv + 3, chptr->chname);
  }
}

/*
 * ms_bmask()
 *
 * inputs       - parv[0] = SID
 *                parv[1] = TS
 *                parv[2] = channel name
 *                parv[3] = type of ban to add ('b' 'I' or 'e')
 *                parv[4] = space delimited list of masks to add
 * outputs      - none
 * side effects - propagates unchanged bmask line to CAP_TS6 servers,
 *                sends plain modes to the others.  nothing is sent
 *                to the server the issuing server is connected through
 */
static void
ms_bmask(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
  static char modebuf[IRCD_BUFSIZE];
  static char parabuf[IRCD_BUFSIZE];
  static char banbuf[IRCD_BUFSIZE];
  struct Channel *chptr;
  char *s, *t, *mbuf, *pbuf;
  long mode_type;
  int mlen, tlen;
  int modecount = 0;
  int needcap = NOCAPS;

  if ((chptr = hash_find_channel(parv[2])) == NULL)
    return;

  /* TS is higher, drop it. */
  if (atol(parv[1]) > chptr->channelts)
    return;

  switch (*parv[3])
  {
    case 'b':
      mode_type = CHFL_BAN;
      break;

    case 'e':
      mode_type = CHFL_EXCEPTION;
      needcap = CAP_EX;
      break;

    case 'I':
      mode_type = CHFL_INVEX;
      needcap = CAP_IE;
      break;

    /* maybe we should just blindly propagate this? */
    default:
      return; 
  }

  parabuf[0] = '\0';
  s = banbuf;
  strlcpy(s, parv[4], sizeof(banbuf));

  /* only need to construct one buffer, for non-ts6 servers */
  mlen = ircsprintf(modebuf, ":%s MODE %s +",
                    source_p->name, chptr->chname);
  mbuf = modebuf + mlen;
  pbuf = parabuf;

  do {
    if ((t = strchr(s, ' ')) != NULL)
      *t++ = '\0';
    tlen = strlen(s);

    /* I dont even want to begin parsing this.. */
    if (tlen > MODEBUFLEN)
      break;

    if (tlen && *s != ':' && add_id(source_p, chptr, s, mode_type))
    {
      /* this new one wont fit.. */
      if (mbuf - modebuf + 2 + pbuf - parabuf + tlen > IRCD_BUFSIZE - 2 ||
          modecount >= MAXMODEPARAMS)
      {
        *mbuf = '\0';
        *(pbuf - 1) = '\0';

        sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s",
                             modebuf, parabuf);
        sendto_server(client_p, chptr, needcap, CAP_TS6,
                      "%s %s", modebuf, parabuf);

        mbuf = modebuf + mlen;
        pbuf = parabuf;
        modecount = 0;
      }

      *mbuf++ = parv[3][0];
      pbuf += ircsprintf(pbuf, "%s ", s);
      modecount++;
    }

    s = t;
  } while (s != NULL);

  if (modecount)
  {
    *mbuf = *(pbuf - 1) = '\0';
    sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s", modebuf, parabuf);
    sendto_server(client_p, chptr, needcap, CAP_TS6,
                  "%s %s", modebuf, parabuf);
  }

  /* assumption here is that since the server sent BMASK, they are TS6, so they have an ID */
  sendto_server(client_p, chptr, CAP_TS6|needcap, NOCAPS,
                ":%s BMASK %lu %s %s :%s",
                source_p->id, (unsigned long)chptr->channelts, chptr->chname,
                parv[3], parv[4]);
}
Revision:	1178
Committed:	Mon Aug 15 08:11:31 2011 UTC (14 years ago) by michael
Content type:	text/x-csrc
Original Path:	*ircd-hybrid-8/modules/core/m_mode.c*
File size:	8245 byte(s)
Log Message:	- Cleanup and restore older parts of the irc-command parser. Gives back ability to specify maximum amount of parameters that are processed within a command.
#	User	Rev	Content
1	adx	30	/*
2			* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3			* m_mode.c: Sets a user or channel mode.
4			*
5			* Copyright (C) 2002 by the past and present ircd coders, and others.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20			* USA
21			*
22	knight	31	* $Id$
23	adx	30	*/
24
25			#include "stdinc.h"
26	michael	1011	#include "list.h"
27	adx	30	#include "handlers.h"
28			#include "channel.h"
29			#include "channel_mode.h"
30			#include "client.h"
31			#include "hash.h"
32			#include "irc_string.h"
33			#include "sprintf_irc.h"
34			#include "ircd.h"
35			#include "numeric.h"
36			#include "s_user.h"
37			#include "s_conf.h"
38			#include "s_serv.h"
39			#include "send.h"
40			#include "msg.h"
41			#include "parse.h"
42			#include "modules.h"
43			#include "packet.h"
44
45			static void m_mode(struct Client , struct Client , int, char *[]);
46			static void ms_tmode(struct Client , struct Client , int, char *[]);
47			static void ms_bmask(struct Client , struct Client , int, char *[]);
48
49			struct Message mode_msgtab = {
50	michael	1178	"MODE", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
51	adx	30	{m_unregistered, m_mode, m_mode, m_ignore, m_mode, m_ignore}
52			};
53
54			struct Message tmode_msgtab = {
55	michael	1178	"TMODE", 0, 0, 4, MAXPARA, MFLG_SLOW, 0,
56	adx	30	{m_ignore, m_ignore, ms_tmode, m_ignore, m_ignore, m_ignore}
57			};
58
59			struct Message bmask_msgtab = {
60	michael	1178	"BMASK", 0, 0, 5, MAXPARA, MFLG_SLOW, 0,
61	adx	30	{m_ignore, m_ignore, ms_bmask, m_ignore, m_ignore, m_ignore}
62			};
63
64			void
65			_modinit(void)
66			{
67			mod_add_cmd(&mode_msgtab);
68			mod_add_cmd(&tmode_msgtab);
69			mod_add_cmd(&bmask_msgtab);
70			}
71
72			void
73			_moddeinit(void)
74			{
75			mod_del_cmd(&mode_msgtab);
76			mod_del_cmd(&tmode_msgtab);
77			mod_del_cmd(&bmask_msgtab);
78			}
79
80	knight	31	const char *_version = "$Revision$";
81	adx	30
82			/*
83			* m_mode - MODE command handler
84			* parv[0] - sender
85			* parv[1] - channel
86			*/
87			static void
88			m_mode(struct Client client_p, struct Client source_p,
89			int parc, char *parv[])
90			{
91			struct Channel *chptr = NULL;
92			struct Membership *member;
93			static char modebuf[MODEBUFLEN];
94			static char parabuf[MODEBUFLEN];
95
96	michael	885	if (EmptyString(parv[1]))
97	adx	30	{
98			sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
99			me.name, source_p->name, "MODE");
100			return;
101			}
102
103			/* Now, try to find the channel in question */
104			if (!IsChanPrefix(*parv[1]))
105			{
106			/* if here, it has to be a non-channel name */
107			set_user_mode(client_p, source_p, parc, parv);
108			return;
109			}
110
111	michael	885	if ((chptr = hash_find_channel(parv[1])) == NULL)
112	adx	30	{
113	db	848	sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
114			ID_or_name(&me, source_p->from),
115			ID_or_name(source_p, source_p->from),
116			parv[1]);
117			return;
118			}
119	adx	30
120			/* Now known the channel exists */
121			if (parc < 3)
122			{
123			channel_modes(chptr, source_p, modebuf, parabuf);
124			sendto_one(source_p, form_str(RPL_CHANNELMODEIS),
125			me.name, source_p->name, chptr->chname, modebuf, parabuf);
126			sendto_one(source_p, form_str(RPL_CREATIONTIME),
127			me.name, source_p->name, chptr->chname, chptr->channelts);
128			}
129			/* bounce all modes from people we deop on sjoin
130			* servers have always gotten away with murder,
131			* including telnet servers g - Dianora
132			*
133			* XXX Is it worth the bother to make an ms_mode() ? - Dianora
134			*/
135			else if (IsServer(source_p))
136			{
137			set_channel_mode(client_p, source_p, chptr, NULL, parc - 2, parv + 2,
138			chptr->chname);
139			}
140			else
141			{
142			member = find_channel_link(source_p, chptr);
143
144			if (!has_member_flags(member, CHFL_DEOPPED))
145			{
146			/* Finish the flood grace period... */
147			if (MyClient(source_p) && !IsFloodDone(source_p))
148			{
149			if (!((parc == 3) && (parv[2][0] == 'b') && (parv[2][1] == '\0')))
150			flood_endgrace(source_p);
151			}
152
153			set_channel_mode(client_p, source_p, chptr, member, parc - 2, parv + 2,
154			chptr->chname);
155			}
156			}
157			}
158
159			/*
160			* ms_tmode()
161			*
162			* inputs - parv[0] = UID
163			* parv[1] = TS
164			* parv[2] = channel name
165			* parv[3] = modestring
166			*/
167			static void
168			ms_tmode(struct Client client_p, struct Client source_p, int parc, char *parv[])
169			{
170			struct Channel *chptr = NULL;
171			struct Membership *member = NULL;
172
173			if ((chptr = hash_find_channel(parv[2])) == NULL)
174			{
175			sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
176			ID_or_name(&me, client_p), ID_or_name(source_p, client_p), parv[2]);
177			return;
178			}
179
180			if (atol(parv[1]) > chptr->channelts)
181			return;
182
183			if (IsServer(source_p))
184			set_channel_mode(client_p, source_p, chptr, NULL, parc - 3, parv + 3, chptr->chname);
185			else
186			{
187			member = find_channel_link(source_p, chptr);
188
189			/* XXX are we sure we just want to bail here? */
190			if (has_member_flags(member, CHFL_DEOPPED))
191			return;
192
193			set_channel_mode(client_p, source_p, chptr, member, parc - 3, parv + 3, chptr->chname);
194			}
195			}
196
197			/*
198			* ms_bmask()
199			*
200			* inputs - parv[0] = SID
201			* parv[1] = TS
202			* parv[2] = channel name
203			* parv[3] = type of ban to add ('b' 'I' or 'e')
204			* parv[4] = space delimited list of masks to add
205			* outputs - none
206			* side effects - propagates unchanged bmask line to CAP_TS6 servers,
207			* sends plain modes to the others. nothing is sent
208			* to the server the issuing server is connected through
209			*/
210			static void
211			ms_bmask(struct Client client_p, struct Client source_p, int parc, char *parv[])
212			{
213			static char modebuf[IRCD_BUFSIZE];
214			static char parabuf[IRCD_BUFSIZE];
215			static char banbuf[IRCD_BUFSIZE];
216			struct Channel *chptr;
217			char s, t, mbuf, pbuf;
218			long mode_type;
219			int mlen, tlen;
220			int modecount = 0;
221			int needcap = NOCAPS;
222
223			if ((chptr = hash_find_channel(parv[2])) == NULL)
224			return;
225
226			/* TS is higher, drop it. */
227			if (atol(parv[1]) > chptr->channelts)
228			return;
229
230			switch (*parv[3])
231			{
232			case 'b':
233			mode_type = CHFL_BAN;
234			break;
235
236			case 'e':
237			mode_type = CHFL_EXCEPTION;
238			needcap = CAP_EX;
239			break;
240
241			case 'I':
242			mode_type = CHFL_INVEX;
243			needcap = CAP_IE;
244			break;
245
246			/* maybe we should just blindly propagate this? */
247			default:
248			return;
249			}
250
251			parabuf[0] = '\0';
252			s = banbuf;
253			strlcpy(s, parv[4], sizeof(banbuf));
254
255			/* only need to construct one buffer, for non-ts6 servers */
256			mlen = ircsprintf(modebuf, ":%s MODE %s +",
257			source_p->name, chptr->chname);
258			mbuf = modebuf + mlen;
259			pbuf = parabuf;
260
261			do {
262			if ((t = strchr(s, ' ')) != NULL)
263			*t++ = '\0';
264			tlen = strlen(s);
265
266			/* I dont even want to begin parsing this.. */
267			if (tlen > MODEBUFLEN)
268			break;
269
270			if (tlen && *s != ':' && add_id(source_p, chptr, s, mode_type))
271			{
272			/* this new one wont fit.. */
273			if (mbuf - modebuf + 2 + pbuf - parabuf + tlen > IRCD_BUFSIZE - 2 \|\|
274			modecount >= MAXMODEPARAMS)
275			{
276			*mbuf = '\0';
277			*(pbuf - 1) = '\0';
278
279	michael	1011	sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s",
280	adx	30	modebuf, parabuf);
281	michael	885	sendto_server(client_p, chptr, needcap, CAP_TS6,
282	adx	30	"%s %s", modebuf, parabuf);
283
284			mbuf = modebuf + mlen;
285			pbuf = parabuf;
286			modecount = 0;
287			}
288
289			*mbuf++ = parv[3][0];
290			pbuf += ircsprintf(pbuf, "%s ", s);
291			modecount++;
292			}
293
294			s = t;
295			} while (s != NULL);
296
297			if (modecount)
298			{
299			mbuf = (pbuf - 1) = '\0';
300	michael	1011	sendto_channel_local(ALL_MEMBERS, 0, chptr, "%s %s", modebuf, parabuf);
301	michael	885	sendto_server(client_p, chptr, needcap, CAP_TS6,
302	adx	30	"%s %s", modebuf, parabuf);
303			}
304
305			/* assumption here is that since the server sent BMASK, they are TS6, so they have an ID */
306	michael	885	sendto_server(client_p, chptr, CAP_TS6\|needcap, NOCAPS,
307	adx	30	":%s BMASK %lu %s %s :%s",
308			source_p->id, (unsigned long)chptr->channelts, chptr->chname,
309			parv[3], parv[4]);
310			}