]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * IRC - Internet Relay Chat, ircd/m_join.c | |
3 | * Copyright (C) 1990 Jarkko Oikarinen and | |
4 | * University of Oulu, Computing Center | |
5 | * | |
6 | * See file AUTHORS in IRC package for additional names of | |
7 | * the programmers. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 1, or (at your option) | |
12 | * any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
22 | * | |
23 | * $Id: m_join.c,v 1.34.2.9 2006/02/05 00:50:22 entrope Exp $ | |
24 | */ | |
25 | ||
26 | #include "config.h" | |
27 | ||
28 | #include "channel.h" | |
29 | #include "client.h" | |
30 | #include "gline.h" | |
31 | #include "hash.h" | |
32 | #include "ircd.h" | |
33 | #include "ircd_chattr.h" | |
34 | #include "ircd_features.h" | |
35 | #include "ircd_log.h" | |
36 | #include "ircd_reply.h" | |
37 | #include "ircd_string.h" | |
38 | #include "msg.h" | |
39 | #include "numeric.h" | |
40 | #include "numnicks.h" | |
41 | #include "s_debug.h" | |
42 | #include "s_user.h" | |
43 | #include "send.h" | |
44 | #include "sys.h" | |
45 | ||
46 | /* #include <assert.h> -- Now using assert in ircd_log.h */ | |
47 | #include <stdlib.h> | |
48 | #include <string.h> | |
49 | ||
50 | /** Searches for and handles a 0 in a join list. | |
51 | * @param[in] cptr Client that sent us the message. | |
52 | * @param[in] sptr Original source of message. | |
53 | * @param[in] chanlist List of channels to join. | |
54 | * @return First token in \a chanlist after the final 0 entry, which | |
55 | * may be its nul terminator (if the final entry is a 0 entry). | |
56 | */ | |
57 | static char * | |
58 | last0(struct Client *cptr, struct Client *sptr, char *chanlist) | |
59 | { | |
60 | char *p; | |
61 | int join0 = 0; | |
62 | ||
63 | for (p = chanlist; p[0]; p++) /* find last "JOIN 0" */ | |
64 | if (p[0] == '0' && (p[1] == ',' || p[1] == '\0')) { | |
65 | if (p[1] == ',') | |
66 | p++; | |
67 | chanlist = p + 1; | |
68 | join0 = 1; | |
69 | } else { | |
70 | while (p[0] != ',' && p[0] != '\0') /* skip past channel name */ | |
71 | p++; | |
72 | ||
73 | if (!p[0]) /* hit the end */ | |
74 | break; | |
75 | } | |
76 | ||
77 | if (join0) { | |
78 | struct JoinBuf part; | |
79 | struct Membership *member; | |
80 | ||
81 | joinbuf_init(&part, sptr, cptr, JOINBUF_TYPE_PARTALL, | |
82 | "Left all channels", 0); | |
83 | ||
84 | joinbuf_join(&part, 0, 0); | |
85 | ||
86 | while ((member = cli_user(sptr)->channel)) | |
87 | joinbuf_join(&part, member->channel, | |
88 | IsZombie(member) ? CHFL_ZOMBIE : | |
89 | IsDelayedJoin(member) ? CHFL_DELAYED : | |
90 | 0); | |
91 | ||
92 | joinbuf_flush(&part); | |
93 | } | |
94 | ||
95 | return chanlist; | |
96 | } | |
97 | ||
98 | /** Handle a JOIN message from a client connection. | |
99 | * See @ref m_functions for discussion of the arguments. | |
100 | * @param[in] cptr Client that sent us the message. | |
101 | * @param[in] sptr Original source of message. | |
102 | * @param[in] parc Number of arguments. | |
103 | * @param[in] parv Argument vector. | |
104 | */ | |
105 | int m_join(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) | |
106 | { | |
107 | struct Channel *chptr; | |
108 | struct JoinBuf join; | |
109 | struct JoinBuf create; | |
110 | struct Gline *gline; | |
111 | char *p = 0; | |
112 | char *chanlist; | |
113 | char *name; | |
114 | char *keys; | |
115 | ||
116 | if (parc < 2 || *parv[1] == '\0') | |
117 | return need_more_params(sptr, "JOIN"); | |
118 | ||
119 | joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0); | |
120 | joinbuf_init(&create, sptr, cptr, JOINBUF_TYPE_CREATE, 0, TStime()); | |
121 | ||
122 | chanlist = last0(cptr, sptr, parv[1]); /* find last "JOIN 0" */ | |
123 | ||
124 | keys = parv[2]; /* remember where keys are */ | |
125 | ||
126 | for (name = ircd_strtok(&p, chanlist, ","); name; | |
127 | name = ircd_strtok(&p, 0, ",")) { | |
128 | char *key = 0; | |
129 | ||
130 | /* If we have any more keys, take the first for this channel. */ | |
131 | if (!BadPtr(keys) | |
132 | && (keys = strchr(key = keys, ','))) | |
133 | *keys++ = '\0'; | |
134 | ||
135 | /* Empty keys are the same as no keys. */ | |
136 | if (key && !key[0]) | |
137 | key = 0; | |
138 | ||
139 | if (!IsChannelName(name) || !strIsIrcCh(name)) | |
140 | { | |
141 | /* bad channel name */ | |
142 | send_reply(sptr, ERR_NOSUCHCHANNEL, name); | |
143 | continue; | |
144 | } | |
145 | ||
146 | if (cli_user(sptr)->joined >= feature_int(FEAT_MAXCHANNELSPERUSER) | |
147 | && !HasPriv(sptr, PRIV_CHAN_LIMIT)) { | |
148 | send_reply(sptr, ERR_TOOMANYCHANNELS, name); | |
149 | break; /* no point processing the other channels */ | |
150 | } | |
151 | ||
152 | /* BADCHANed channel */ | |
153 | if (!IsAnOper(sptr) | |
154 | && (gline = gline_lookup_badchan(name, GLINE_BADCHAN))) { | |
155 | send_reply(sptr, ERR_BADCHANNAME, name, gline->gl_reason); | |
156 | continue; | |
157 | } | |
158 | ||
159 | if (!(chptr = FindChannel(name))) { | |
160 | if (((name[0] == '&') && !feature_bool(FEAT_LOCAL_CHANNELS)) | |
161 | || strlen(name) >= IRCD_MIN(CHANNELLEN, feature_int(FEAT_CHANNELLEN))) { | |
162 | send_reply(sptr, ERR_NOSUCHCHANNEL, name); | |
163 | continue; | |
164 | } | |
165 | ||
166 | if (!(chptr = get_channel(sptr, name, CGT_CREATE))) | |
167 | continue; | |
168 | ||
169 | /* Try to add the new channel as a recent target for the user. */ | |
170 | if (check_target_limit(sptr, chptr, chptr->chname, 0)) { | |
171 | chptr->members = 0; | |
172 | destruct_channel(chptr); | |
173 | continue; | |
174 | } | |
175 | ||
176 | joinbuf_join(&create, chptr, CHFL_CHANOP | CHFL_CHANNEL_MANAGER); | |
177 | if (feature_bool(FEAT_AUTOCHANMODES) && feature_str(FEAT_AUTOCHANMODES_LIST) && strlen(feature_str(FEAT_AUTOCHANMODES_LIST)) > 0) | |
178 | SetAutoChanModes(chptr); | |
179 | } else if (find_member_link(chptr, sptr)) { | |
180 | continue; /* already on channel */ | |
181 | } else if (check_target_limit(sptr, chptr, chptr->chname, 0)) { | |
182 | continue; | |
183 | } else { | |
184 | int flags = CHFL_DEOPPED; | |
185 | int err = 0; | |
186 | ||
187 | /* Check Apass/Upass -- since we only ever look at a single | |
188 | * "key" per channel now, this hampers brute force attacks. */ | |
189 | if (key && !strcmp(key, chptr->mode.apass)) | |
190 | flags = CHFL_CHANOP | CHFL_CHANNEL_MANAGER; | |
191 | else if (key && !strcmp(key, chptr->mode.upass)) | |
192 | flags = CHFL_CHANOP; | |
193 | else if (chptr->users == 0 && !chptr->mode.apass[0]) { | |
194 | /* Joining a zombie channel (zannel): give ops and increment TS. */ | |
195 | flags = CHFL_CHANOP; | |
196 | chptr->creationtime++; | |
197 | } else if (IsInvited(sptr, chptr)) { | |
198 | /* Invites bypass these other checks. */ | |
199 | } else if (chptr->mode.mode & MODE_INVITEONLY) | |
200 | err = ERR_INVITEONLYCHAN; | |
201 | else if (chptr->mode.limit && (chptr->users >= chptr->mode.limit)) | |
202 | err = ERR_CHANNELISFULL; | |
203 | else if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr)) | |
204 | err = ERR_NEEDREGGEDNICK; | |
205 | else if (find_ban(sptr, chptr->banlist)) | |
206 | err = ERR_BANNEDFROMCHAN; | |
207 | else if (*chptr->mode.key && (!key || strcmp(key, chptr->mode.key))) | |
208 | err = ERR_BADCHANNELKEY; | |
209 | ||
210 | /* | |
211 | * ASUKA_X: | |
212 | * Allow XtraOpers to join all channels. | |
213 | * --Bigfoot | |
214 | */ | |
215 | if (IsXtraOp(sptr)) | |
216 | err = 0; | |
217 | ||
218 | /* An oper with WALK_LCHAN privilege can join a local channel | |
219 | * he otherwise could not join by using "OVERRIDE" as the key. | |
220 | * This will generate a HACK(4) notice, but fails if the oper | |
221 | * could normally join the channel. */ | |
222 | if (IsLocalChannel(chptr->chname) | |
223 | && HasPriv(sptr, PRIV_WALK_LCHAN) | |
224 | && !(flags & CHFL_CHANOP) | |
225 | && key && !strcmp(key, "OVERRIDE")) | |
226 | { | |
227 | switch (err) { | |
228 | case 0: | |
229 | if (strcmp(chptr->mode.key, "OVERRIDE") | |
230 | && strcmp(chptr->mode.apass, "OVERRIDE") | |
231 | && strcmp(chptr->mode.upass, "OVERRIDE")) { | |
232 | send_reply(sptr, ERR_DONTCHEAT, chptr->chname); | |
233 | continue; | |
234 | } | |
235 | break; | |
236 | case ERR_INVITEONLYCHAN: err = 'i'; break; | |
237 | case ERR_CHANNELISFULL: err = 'l'; break; | |
238 | case ERR_BANNEDFROMCHAN: err = 'b'; break; | |
239 | case ERR_BADCHANNELKEY: err = 'k'; break; | |
240 | case ERR_NEEDREGGEDNICK: err = 'r'; break; | |
241 | default: err = '?'; break; | |
242 | } | |
243 | /* send accountability notice */ | |
244 | if (err) | |
245 | sendto_opmask_butone(0, SNO_HACK4, "OPER JOIN: %C JOIN %H " | |
246 | "(overriding +%c)", sptr, chptr, err); | |
247 | err = 0; | |
248 | } | |
249 | ||
250 | /* Is there some reason the user may not join? */ | |
251 | if (err) { | |
252 | send_reply(sptr, err, chptr->chname); | |
253 | continue; | |
254 | } | |
255 | ||
256 | joinbuf_join(&join, chptr, flags); | |
257 | if (flags & CHFL_CHANOP) { | |
258 | struct ModeBuf mbuf; | |
259 | /* Always let the server op him: this is needed on a net with older servers | |
260 | because they 'destruct' channels immediately when they become empty without | |
261 | sending out a DESTRUCT message. As a result, they would always bounce a mode | |
262 | (as HACK(2)) when the user ops himself. | |
263 | (There is also no particularly good reason to have the user op himself.) | |
264 | */ | |
265 | modebuf_init(&mbuf, &me, cptr, chptr, MODEBUF_DEST_SERVER); | |
266 | modebuf_mode_client(&mbuf, MODE_ADD | MODE_CHANOP, sptr, | |
267 | chptr->mode.apass[0] ? ((flags & CHFL_CHANNEL_MANAGER) ? 0 : 1) : MAXOPLEVEL); | |
268 | modebuf_flush(&mbuf); | |
269 | } | |
270 | } | |
271 | ||
272 | del_invite(sptr, chptr); | |
273 | ||
274 | if (chptr->topic[0]) { | |
275 | send_reply(sptr, RPL_TOPIC, chptr->chname, chptr->topic); | |
276 | send_reply(sptr, RPL_TOPICWHOTIME, chptr->chname, chptr->topic_nick, | |
277 | chptr->topic_time); | |
278 | } | |
279 | ||
280 | do_names(sptr, chptr, NAMES_ALL|NAMES_EON); /* send /names list */ | |
281 | } | |
282 | ||
283 | joinbuf_flush(&join); /* must be first, if there's a JOIN 0 */ | |
284 | joinbuf_flush(&create); | |
285 | ||
286 | return 0; | |
287 | } | |
288 | ||
289 | /** Handle a JOIN message from a server connection. | |
290 | * See @ref m_functions for discussion of the arguments. | |
291 | * @param[in] cptr Client that sent us the message. | |
292 | * @param[in] sptr Original source of message. | |
293 | * @param[in] parc Number of arguments. | |
294 | * @param[in] parv Argument vector. | |
295 | */ | |
296 | int ms_join(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) | |
297 | { | |
298 | struct Membership *member; | |
299 | struct Channel *chptr; | |
300 | struct JoinBuf join; | |
301 | unsigned int flags; | |
302 | time_t creation = 0; | |
303 | char *p = 0; | |
304 | char *chanlist; | |
305 | char *name; | |
306 | ||
307 | if (IsServer(sptr)) | |
308 | { | |
309 | return protocol_violation(cptr, | |
310 | "%s tried to JOIN %s, duh!", | |
311 | cli_name(sptr), | |
312 | (parc < 2 || *parv[1] == '\0') ? "a channel" : | |
313 | parv[1] | |
314 | ); | |
315 | } | |
316 | ||
317 | if (parc < 2 || *parv[1] == '\0') | |
318 | return need_more_params(sptr, "JOIN"); | |
319 | ||
320 | if (parc > 2 && parv[2]) | |
321 | creation = atoi(parv[2]); | |
322 | ||
323 | joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0); | |
324 | ||
325 | chanlist = last0(cptr, sptr, parv[1]); /* find last "JOIN 0" */ | |
326 | ||
327 | for (name = ircd_strtok(&p, chanlist, ","); name; | |
328 | name = ircd_strtok(&p, 0, ",")) { | |
329 | ||
330 | flags = CHFL_DEOPPED; | |
331 | ||
332 | if (IsLocalChannel(name) || !IsChannelName(name)) | |
333 | { | |
334 | protocol_violation(cptr, "%s tried to join %s", cli_name(sptr), name); | |
335 | continue; | |
336 | } | |
337 | ||
338 | if (!(chptr = FindChannel(name))) | |
339 | { | |
340 | /* No channel exists, so create one */ | |
341 | if (!(chptr = get_channel(sptr, name, CGT_CREATE))) | |
342 | { | |
343 | protocol_violation(sptr,"couldn't get channel %s for %s", | |
344 | name,cli_name(sptr)); | |
345 | continue; | |
346 | } | |
347 | flags |= HasFlag(sptr, FLAG_TS8) ? CHFL_SERVOPOK : 0; | |
348 | ||
349 | chptr->creationtime = creation; | |
350 | } | |
351 | else { /* We have a valid channel? */ | |
352 | if ((member = find_member_link(chptr, sptr))) | |
353 | { | |
354 | /* It is impossible to get here --Run */ | |
355 | if (!IsZombie(member)) /* already on channel */ | |
356 | continue; | |
357 | ||
358 | flags = member->status & (CHFL_DEOPPED | CHFL_SERVOPOK); | |
359 | remove_user_from_channel(sptr, chptr); | |
360 | chptr = FindChannel(name); | |
361 | } | |
362 | else | |
363 | flags |= HasFlag(sptr, FLAG_TS8) ? CHFL_SERVOPOK : 0; | |
364 | /* Always copy the timestamp when it is older, that is the only way to | |
365 | ensure network-wide synchronization of creation times. | |
366 | We now also copy a creation time that only 1 second younger... | |
367 | this is needed because the timestamp must be incremented | |
368 | by one when someone joins an existing, but empty, channel. | |
369 | However, this is only necessary when the channel is still | |
370 | empty (also here) and when this channel doesn't have +A set. | |
371 | ||
372 | To prevent this from allowing net-rides on the channel, we | |
373 | clear all modes from the channel. | |
374 | ||
375 | (Scenario for a net ride: c1 - s1 - s2 - c2, with c1 the only | |
376 | user in the channel; c1 parts and rejoins, gaining ops. | |
377 | Before s2 sees c1's part, c2 joins the channel and parts | |
378 | immediately. s1 sees c1 part, c1 create, c2 join, c2 part; | |
379 | c2's join resets the timestamp. s2 sees c2 join, c2 part, c1 | |
380 | part, c1 create; but since s2 sees the channel as a zannel or | |
381 | non-existent, it does not bounce the create with the newer | |
382 | timestamp.) | |
383 | */ | |
384 | if (creation && (creation < chptr->creationtime || | |
385 | (!chptr->mode.apass[0] && chptr->users == 0))) { | |
386 | struct Membership *member; | |
387 | struct ModeBuf mbuf; | |
388 | ||
389 | chptr->creationtime = creation; | |
390 | /* Wipe out the current modes on the channel. */ | |
391 | modebuf_init(&mbuf, sptr, cptr, chptr, MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK3); | |
392 | ||
393 | modebuf_mode(&mbuf, MODE_DEL | chptr->mode.mode); | |
394 | chptr->mode.mode &= MODE_BURSTADDED | MODE_WASDELJOINS; | |
395 | ||
396 | if (chptr->mode.limit) { | |
397 | modebuf_mode_uint(&mbuf, MODE_DEL | MODE_LIMIT, chptr->mode.limit); | |
398 | chptr->mode.limit = 0; | |
399 | } | |
400 | ||
401 | if (chptr->mode.key[0]) { | |
402 | modebuf_mode_string(&mbuf, MODE_DEL | MODE_KEY, chptr->mode.key, 0); | |
403 | chptr->mode.key[0] = '\0'; | |
404 | } | |
405 | ||
406 | if (chptr->mode.upass[0]) { | |
407 | modebuf_mode_string(&mbuf, MODE_DEL | MODE_UPASS, chptr->mode.upass, 0); | |
408 | chptr->mode.upass[0] = '\0'; | |
409 | } | |
410 | ||
411 | if (chptr->mode.apass[0]) { | |
412 | modebuf_mode_string(&mbuf, MODE_DEL | MODE_APASS, chptr->mode.apass, 0); | |
413 | chptr->mode.apass[0] = '\0'; | |
414 | } | |
415 | ||
416 | for (member = chptr->members; member; member = member->next_member) | |
417 | { | |
418 | if (IsChanOp(member)) { | |
419 | modebuf_mode_client(&mbuf, MODE_DEL | MODE_CHANOP, member->user, OpLevel(member)); | |
420 | member->status &= ~CHFL_CHANOP; | |
421 | } | |
422 | if (HasVoice(member)) { | |
423 | modebuf_mode_client(&mbuf, MODE_DEL | MODE_VOICE, member->user, OpLevel(member)); | |
424 | member->status &= ~CHFL_VOICE; | |
425 | } | |
426 | } | |
427 | modebuf_flush(&mbuf); | |
428 | } | |
429 | } | |
430 | ||
431 | joinbuf_join(&join, chptr, flags); | |
432 | } | |
433 | ||
434 | joinbuf_flush(&join); /* flush joins... */ | |
435 | ||
436 | return 0; | |
437 | } |