- JOIN: Invite- und Ban-Lists werden nun beachtet.
[ngircd-alex.git] / src / ngircd / irc-channel.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
4  *
5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
6  * der GNU General Public License (GPL), wie von der Free Software Foundation
7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
10  * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
11  *
12  * $Id: irc-channel.c,v 1.8 2002/06/02 14:51:14 alex Exp $
13  *
14  * irc-channel.c: IRC-Channel-Befehle
15  */
16
17
18 #include "portab.h"
19
20 #include "imp.h"
21 #include <assert.h>
22 #include <string.h>
23
24 #include "defines.h"
25 #include "conn.h"
26 #include "client.h"
27 #include "channel.h"
28 #include "lists.h"
29 #include "log.h"
30 #include "messages.h"
31 #include "parse.h"
32 #include "irc.h"
33 #include "irc-write.h"
34
35 #include "exp.h"
36 #include "irc-channel.h"
37
38
39 GLOBAL BOOLEAN
40 IRC_JOIN( CLIENT *Client, REQUEST *Req )
41 {
42         CHAR *channame, *flags, *topic, modes[8];
43         BOOLEAN is_new_chan;
44         CLIENT *target;
45         CHANNEL *chan;
46
47         assert( Client != NULL );
48         assert( Req != NULL );
49
50         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
51
52         /* Falsche Anzahl Parameter? */
53         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
54
55         /* Wer ist der Absender? */
56         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
57         else target = Client;
58         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
59
60         /* Channel-Namen durchgehen */
61         chan = NULL;
62         channame = strtok( Req->argv[0], "," );
63         while( channame )
64         {
65                 chan = flags = NULL;
66
67                 /* wird der Channel neu angelegt? */
68                 if( Channel_Search( channame )) is_new_chan = FALSE;
69                 else is_new_chan = TRUE;
70
71                 /* Hat ein Server Channel-User-Modes uebergeben? */
72                 if( Client_Type( Client ) == CLIENT_SERVER )
73                 {
74                         /* Channel-Flags extrahieren */
75                         flags = strchr( channame, 0x7 );
76                         if( flags ) *flags++ = '\0';
77                 }
78
79                 /* Lokaler Client? */
80                 if( Client_Type( Client ) == CLIENT_USER )
81                 {
82                         /* Existiert der Channel bereits, oder wird er im Moment neu erzeugt? */
83                         if( is_new_chan )
84                         {
85                                 /* Erster User im Channel: Operator-Flag setzen */
86                                 flags = "o";
87                         }
88                         else
89                         {
90                                 /* Existierenden Channel suchen */
91                                 chan = Channel_Search( channame );
92                                 assert( chan != NULL );
93
94                                 /* Testen, ob Client gebanned ist */
95                                 if( Lists_CheckBanned( target, chan ))
96                                 {
97                                         /* Client ist gebanned: */
98                                         IRC_WriteStrClient( Client, ERR_BANNEDFROMCHAN_MSG, Client_ID( Client ), channame );
99
100                                         /* naechsten Namen ermitteln */
101                                         channame = strtok( NULL, "," );
102                                         continue;
103                                 }
104
105                                 /* Ist der Channel "invite-only"? */
106                                 if( strchr( Channel_Modes( chan ), 'i' ))
107                                 {
108                                         /* Wurde der Client invited? */
109                                         if( ! Lists_CheckInvited( target, chan ))
110                                         {
111                                                 /* Client wurde nicht invited: */
112                                                 IRC_WriteStrClient( Client, ERR_INVITEONLYCHAN_MSG, Client_ID( Client ), channame );
113
114                                                 /* naechsten Namen ermitteln */
115                                                 channame = strtok( NULL, "," );
116                                                 continue;
117                                         }
118                                 }
119                         }
120                 }
121
122                 /* Channel joinen (und ggf. anlegen) */
123                 if( ! Channel_Join( target, channame ))
124                 {
125                         /* naechsten Namen ermitteln */
126                         channame = strtok( NULL, "," );
127                         continue;
128                 }
129                 if( ! chan ) chan = Channel_Search( channame );
130                 assert( chan != NULL );
131
132                 /* Modes setzen (wenn vorhanden) */
133                 while( flags && *flags )
134                 {
135                         Channel_UserModeAdd( chan, target, *flags );
136                         flags++;
137                 }
138
139                 /* Wenn persistenter Channel und IRC-Operator: zum Channel-OP machen */
140                 if(( strchr( Channel_Modes( chan ), 'P' )) && ( strchr( Client_Modes( target ), 'o' ))) Channel_UserModeAdd( chan, target, 'o' );
141
142                 /* Muessen Modes an andere Server gemeldet werden? */
143                 strcpy( &modes[1], Channel_UserModes( chan, target ));
144                 if( modes[1] ) modes[0] = 0x7;
145                 else modes[0] = '\0';
146
147                 /* An andere Server weiterleiten */
148                 IRC_WriteStrServersPrefix( Client, target, "JOIN :%s%s", channame, modes );
149
150                 /* im Channel bekannt machen */
151                 IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "JOIN :%s", channame );
152                 if( modes[1] )
153                 {
154                         /* Modes im Channel bekannt machen */
155                         IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "MODE %s %s :%s", channame, modes, Client_ID( target ));
156                 }
157
158                 if( Client_Type( Client ) == CLIENT_USER )
159                 {
160                         /* an Client bestaetigen */
161                         IRC_WriteStrClientPrefix( Client, target, "JOIN :%s", channame );
162
163                         /* Topic an Client schicken */
164                         topic = Channel_Topic( chan );
165                         if( *topic ) IRC_WriteStrClient( Client, RPL_TOPIC_MSG, Client_ID( Client ), channame, topic );
166
167                         /* Mitglieder an Client Melden */
168                         IRC_Send_NAMES( Client, chan );
169                         IRC_WriteStrClient( Client, RPL_ENDOFNAMES_MSG, Client_ID( Client ), Channel_Name( chan ));
170                 }
171
172                 /* naechsten Namen ermitteln */
173                 channame = strtok( NULL, "," );
174         }
175         return CONNECTED;
176 } /* IRC_JOIN */
177
178
179 GLOBAL BOOLEAN
180 IRC_PART( CLIENT *Client, REQUEST *Req )
181 {
182         CLIENT *target;
183         CHAR *chan;
184
185         assert( Client != NULL );
186         assert( Req != NULL );
187
188         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
189
190         /* Falsche Anzahl Parameter? */
191         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
192
193         /* Wer ist der Absender? */
194         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
195         else target = Client;
196         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
197
198         /* Channel-Namen durchgehen */
199         chan = strtok( Req->argv[0], "," );
200         while( chan )
201         {
202                 if( ! Channel_Part( target, Client, chan, Req->argc > 1 ? Req->argv[1] : Client_ID( target )))
203                 {
204                         /* naechsten Namen ermitteln */
205                         chan = strtok( NULL, "," );
206                         continue;
207                 }
208
209                 /* naechsten Namen ermitteln */
210                 chan = strtok( NULL, "," );
211         }
212         return CONNECTED;
213 } /* IRC_PART */
214
215
216 GLOBAL BOOLEAN
217 IRC_TOPIC( CLIENT *Client, REQUEST *Req )
218 {
219         CHANNEL *chan;
220         CLIENT *from;
221         CHAR *topic;
222
223         assert( Client != NULL );
224         assert( Req != NULL );
225
226         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
227
228         /* Falsche Anzahl Parameter? */
229         if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
230
231         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
232         else from = Client;
233         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
234
235         /* Welcher Channel? */
236         chan = Channel_Search( Req->argv[0] );
237         if( ! chan ) return IRC_WriteStrClient( from, ERR_NOSUCHCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
238
239         /* Ist der User Mitglied in dem Channel? */
240         if( ! Channel_IsMemberOf( chan, from )) return IRC_WriteStrClient( from, ERR_NOTONCHANNEL_MSG, Client_ID( from ), Req->argv[0] );
241
242         if( Req->argc == 1 )
243         {
244                 /* Topic erfragen */
245                 topic = Channel_Topic( chan );
246                 if( *topic ) return IRC_WriteStrClient( from, RPL_TOPIC_MSG, Client_ID( from ), Channel_Name( chan ), topic );
247                 else return IRC_WriteStrClient( from, RPL_NOTOPIC_MSG, Client_ID( from ), Channel_Name( chan ));
248         }
249
250         if( strchr( Channel_Modes( chan ), 't' ))
251         {
252                 /* Topic Lock. Ist der User ein Channel Operator? */
253                 if( ! strchr( Channel_UserModes( chan, from ), 'o' )) return IRC_WriteStrClient( from, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( from ), Channel_Name( chan ));
254         }
255
256         /* Topic setzen */
257         Channel_SetTopic( chan, Req->argv[1] );
258         Log( LOG_DEBUG, "User \"%s\" set topic on \"%s\": %s", Client_Mask( from ), Channel_Name( chan ), Req->argv[1][0] ? Req->argv[1] : "<none>" );
259
260         /* im Channel bekannt machen und an Server weiterleiten */
261         IRC_WriteStrServersPrefix( Client, from, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
262         IRC_WriteStrChannelPrefix( Client, chan, from, FALSE, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
263
264         if( Client_Type( Client ) == CLIENT_USER ) return IRC_WriteStrClientPrefix( Client, Client, "TOPIC %s :%s", Req->argv[0], Req->argv[1] );
265         else return CONNECTED;
266 } /* IRC_TOPIC */
267
268
269 GLOBAL BOOLEAN
270 IRC_LIST( CLIENT *Client, REQUEST *Req )
271 {
272         CHAR *pattern;
273         CHANNEL *chan;
274
275         assert( Client != NULL );
276         assert( Req != NULL );
277
278         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
279
280         /* Falsche Anzahl Parameter? */
281         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
282
283         if( Req->argc > 0 ) pattern = strtok( Req->argv[0], "," );
284         else pattern = "*";
285         
286         while( pattern )
287         {
288                 /* alle Channel durchgehen */
289                 chan = Channel_First( );
290                 while( chan )
291                 {
292                         /* Passt die Suchmaske auf diesen Channel? Bisher werden hier
293                          * "regular expressions" aber noch nicht unterstuetzt ... */
294                         if(( strcasecmp( pattern, Channel_Name( chan )) == 0 ) || ( strcmp( pattern, "*" ) == 0 ))
295                         {
296                                 /* Treffer! */
297                                 if( ! IRC_WriteStrClient( Client, RPL_LIST_MSG, Client_ID( Client), Channel_Name( chan ), Channel_MemberCount( chan ), Channel_Topic( chan ))) return DISCONNECTED;
298                         }
299                         chan = Channel_Next( chan );
300                 }
301                 
302                 /* naechsten Namen ermitteln */
303                 if( Req->argc > 0 ) pattern = strtok( NULL, "," );
304                 else pattern = NULL;
305         }
306         
307         return IRC_WriteStrClient( Client, RPL_LISTEND_MSG, Client_ID( Client ));
308 } /* IRC_LIST */
309
310
311 /* -eof- */