Rework check for number of parameters
[ngircd-alex.git] / src / ngircd / irc-server.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001-2013 Alexander Barton (alex@barton.de) and Contributors.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  * Please read the file COPYING, README and AUTHORS for more information.
10  */
11
12 #include "portab.h"
13
14 /**
15  * @file
16  * IRC commands for server links
17  */
18
19 #include "imp.h"
20 #include <assert.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <strings.h>
25
26 #include "defines.h"
27 #include "conn.h"
28 #include "conn-func.h"
29 #include "conn-zip.h"
30 #include "conf.h"
31 #include "channel.h"
32 #include "lists.h"
33 #include "log.h"
34 #include "messages.h"
35 #include "parse.h"
36 #include "numeric.h"
37 #include "ngircd.h"
38 #include "irc-info.h"
39 #include "irc-macros.h"
40 #include "irc-write.h"
41 #include "op.h"
42
43 #include "exp.h"
44 #include "irc-server.h"
45
46 /**
47  * Handler for the IRC "SERVER" command.
48  *
49  * @param Client The client from which this command has been received.
50  * @param Req Request structure with prefix and all parameters.
51  * @return CONNECTED or DISCONNECTED.
52  */
53 GLOBAL bool
54 IRC_SERVER( CLIENT *Client, REQUEST *Req )
55 {
56         char str[LINE_LEN];
57         CLIENT *from, *c;
58         int i;
59
60         assert( Client != NULL );
61         assert( Req != NULL );
62
63         /* Return an error if this is not a local client */
64         if (Client_Conn(Client) <= NONE)
65                 return IRC_WriteErrClient(Client, ERR_UNKNOWNCOMMAND_MSG,
66                                           Client_ID(Client), Req->command);
67
68         if (Client_Type(Client) == CLIENT_GOTPASS ||
69             Client_Type(Client) == CLIENT_GOTPASS_2813) {
70                 /* We got a PASS command from the peer, and now a SERVER
71                  * command: the peer tries to register itself as a server. */
72                 LogDebug("Connection %d: got SERVER command (new server link) ...",
73                         Client_Conn(Client));
74
75                 if (Req->argc != 2 && Req->argc != 3)
76                         return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
77                                                   Client_ID(Client),
78                                                   Req->command);
79
80                 /* Get configuration index of new remote server ... */
81                 for (i = 0; i < MAX_SERVERS; i++)
82                         if (strcasecmp(Req->argv[0], Conf_Server[i].name) == 0)
83                                 break;
84
85                 /* Make sure the remote server is configured here */
86                 if (i >= MAX_SERVERS) {
87                         Log(LOG_ERR,
88                             "Connection %d: Server \"%s\" not configured here!",
89                             Client_Conn(Client), Req->argv[0]);
90                         Conn_Close(Client_Conn(Client), NULL,
91                                    "Server not configured here", true);
92                         return DISCONNECTED;
93                 }
94
95                 /* Check server password */
96                 if (strcmp(Conn_Password(Client_Conn(Client)),
97                     Conf_Server[i].pwd_in) != 0) {
98                         Log(LOG_ERR,
99                             "Connection %d: Got bad password from server \"%s\"!",
100                             Client_Conn(Client), Req->argv[0]);
101                         Conn_Close(Client_Conn(Client), NULL,
102                                    "Bad password", true);
103                         return DISCONNECTED;
104                 }
105
106                 /* Is there a registered server with this ID? */
107                 if (!Client_CheckID(Client, Req->argv[0]))
108                         return DISCONNECTED;
109
110                 /* Mark this connection as belonging to an configured server */
111                 if (!Conf_SetServer(i, Client_Conn(Client)))
112                         return DISCONNECTED;
113
114                 Client_SetID( Client, Req->argv[0] );
115                 Client_SetHops( Client, 1 );
116                 Client_SetInfo( Client, Req->argv[Req->argc - 1] );
117
118                 /* Is this server registering on our side, or are we connecting to
119                  * a remote server? */
120                 if (Client_Token(Client) != TOKEN_OUTBOUND) {
121                         /* Incoming connection, send user/pass */
122                         if (!IRC_WriteStrClient(Client, "PASS %s %s",
123                                                 Conf_Server[i].pwd_out,
124                                                 NGIRCd_ProtoID)
125                             || !IRC_WriteStrClient(Client, "SERVER %s 1 :%s",
126                                                    Conf_ServerName,
127                                                    Conf_ServerInfo)) {
128                                     Conn_Close(Client_Conn(Client),
129                                                "Unexpected server behavior!",
130                                                NULL, false);
131                                     return DISCONNECTED;
132                         }
133                         Client_SetIntroducer(Client, Client);
134                         Client_SetToken(Client, 1);
135                 } else {
136                         /* outgoing connect, we already sent a SERVER and PASS
137                          * command to the peer */
138                         Client_SetToken(Client, atoi(Req->argv[1]));
139                 }
140
141                 /* Check protocol level */
142                 if (Client_Type(Client) == CLIENT_GOTPASS) {
143                         /* We got a "simple" PASS command, so the peer is
144                          * using the protocol as defined in RFC 1459. */
145                         if (! (Conn_Options(Client_Conn(Client)) & CONN_RFC1459))
146                                 Log(LOG_INFO,
147                                     "Switching connection %d (\"%s\") to RFC 1459 compatibility mode.",
148                                     Client_Conn(Client), Client_ID(Client));
149                         Conn_SetOption(Client_Conn(Client), CONN_RFC1459);
150                 }
151
152                 Client_SetType(Client, CLIENT_UNKNOWNSERVER);
153
154 #ifdef ZLIB
155                 if (Client_HasFlag(Client, 'Z')
156                     && !Zip_InitConn(Client_Conn(Client))) {
157                         Conn_Close(Client_Conn(Client),
158                                    "Can't initialize compression (zlib)!",
159                                    NULL, false );
160                         return DISCONNECTED;
161                 }
162 #endif
163
164 #ifdef IRCPLUS
165                 if (Client_HasFlag(Client, 'H')) {
166                         LogDebug("Peer supports IRC+ extended server handshake ...");
167                         if (!IRC_Send_ISUPPORT(Client))
168                                 return DISCONNECTED;
169                         return IRC_WriteStrClient(Client, RPL_ENDOFMOTD_MSG,
170                                                   Client_ID(Client));
171                 } else {
172 #endif
173                         if (Conf_MaxNickLength != CLIENT_NICK_LEN_DEFAULT)
174                                 Log(LOG_CRIT,
175                                     "Attention: this server uses a non-standard nick length, but the peer doesn't support the IRC+ extended server handshake!");
176 #ifdef IRCPLUS
177                 }
178 #endif
179
180                 return IRC_Num_ENDOFMOTD(Client, Req);
181         }
182         else if( Client_Type( Client ) == CLIENT_SERVER )
183         {
184                 /* New server is being introduced to the network */
185
186                 if (Req->argc != 4)
187                         return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
188                                                   Client_ID(Client), Req->command);
189
190                 /* check for existing server with same ID */
191                 if (!Client_CheckID(Client, Req->argv[0]))
192                         return DISCONNECTED;
193
194                 from = Client_Search( Req->prefix );
195                 if (! from) {
196                         /* Uh, Server, that introduced the new server is unknown?! */
197                         Log(LOG_ALERT,
198                             "Unknown ID in prefix of SERVER: \"%s\"! (on connection %d)",
199                             Req->prefix, Client_Conn(Client));
200                         Conn_Close(Client_Conn(Client), NULL,
201                                    "Unknown ID in prefix of SERVER", true);
202                         return DISCONNECTED;
203                 }
204
205                 c = Client_NewRemoteServer(Client, Req->argv[0], from,
206                                            atoi(Req->argv[1]), atoi(Req->argv[2]),
207                                            Req->argv[3], true);
208                 if (!c) {
209                         Log(LOG_ALERT,
210                             "Can't create client structure for server! (on connection %d)",
211                             Client_Conn(Client));
212                         Conn_Close(Client_Conn(Client), NULL,
213                                    "Can't allocate client structure for remote server",
214                                    true);
215                         return DISCONNECTED;
216                 }
217
218                 if (Client_Hops(c) > 1 && Req->prefix[0])
219                         snprintf(str, sizeof(str), "connected to %s, ",
220                                  Client_ID(from));
221                 else
222                         strcpy(str, "");
223                 Log(LOG_NOTICE|LOG_snotice,
224                     "Server \"%s\" registered (via %s, %s%d hop%s).",
225                     Client_ID(c), Client_ID(Client), str, Client_Hops(c),
226                     Client_Hops(c) > 1 ? "s": "" );
227
228                 /* notify other servers */
229                 IRC_WriteStrServersPrefix(Client, from, "SERVER %s %d %d :%s",
230                                           Client_ID(c), Client_Hops(c) + 1,
231                                           Client_MyToken(c), Client_Info(c));
232
233                 return CONNECTED;
234         } else
235                 return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
236                                           Client_ID(Client), Req->command);
237 } /* IRC_SERVER */
238
239 /*
240  * Handler for the IRC "NJOIN" command.
241  *
242  * @param Client The client from which this command has been received.
243  * @param Req Request structure with prefix and all parameters.
244  * @return CONNECTED or DISCONNECTED.
245  */
246 GLOBAL bool
247 IRC_NJOIN( CLIENT *Client, REQUEST *Req )
248 {
249         char nick_in[COMMAND_LEN], nick_out[COMMAND_LEN], *channame, *ptr, modes[8];
250         bool is_owner, is_chanadmin, is_op, is_halfop, is_voiced;
251         CHANNEL *chan;
252         CLIENT *c;
253
254         assert( Client != NULL );
255         assert( Req != NULL );
256
257         strlcpy( nick_in, Req->argv[1], sizeof( nick_in ));
258         strcpy( nick_out, "" );
259
260         channame = Req->argv[0];
261         ptr = strtok( nick_in, "," );
262         while( ptr )
263         {
264                 is_owner = is_chanadmin = is_op = is_halfop = is_voiced = false;
265
266                 /* cut off prefixes */
267                 while(( *ptr == '~') || ( *ptr == '&' ) || ( *ptr == '@' ) ||
268                         ( *ptr == '%') || ( *ptr == '+' ))
269                 {
270                         if( *ptr == '~' ) is_owner = true;
271                         if( *ptr == '&' ) is_chanadmin = true;
272                         if( *ptr == '@' ) is_op = true;
273                         if( *ptr == 'h' ) is_halfop = true;
274                         if( *ptr == '+' ) is_voiced = true;
275                         ptr++;
276                 }
277
278                 c = Client_Search( ptr );
279                 if( c )
280                 {
281                         Channel_Join( c, channame );
282                         chan = Channel_Search( channame );
283                         assert( chan != NULL );
284
285                         if( is_owner ) Channel_UserModeAdd( chan, c, 'q' );
286                         if( is_chanadmin ) Channel_UserModeAdd( chan, c, 'a' );
287                         if( is_op ) Channel_UserModeAdd( chan, c, 'o' );
288                         if( is_halfop ) Channel_UserModeAdd( chan, c, 'h' );
289                         if( is_voiced ) Channel_UserModeAdd( chan, c, 'v' );
290
291                         /* announce to channel... */
292                         IRC_WriteStrChannelPrefix( Client, chan, c, false, "JOIN :%s", channame );
293
294                         /* set Channel-User-Modes */
295                         strlcpy( modes, Channel_UserModes( chan, c ), sizeof( modes ));
296                         if( modes[0] )
297                         {
298                                 /* send modes to channel */
299                                 IRC_WriteStrChannelPrefix( Client, chan, Client, false, "MODE %s +%s %s", channame, modes, Client_ID( c ));
300                         }
301
302                         if( nick_out[0] != '\0' ) strlcat( nick_out, ",", sizeof( nick_out ));
303                         if( is_owner ) strlcat( nick_out, "~", sizeof( nick_out ));
304                         if( is_chanadmin ) strlcat( nick_out, "&", sizeof( nick_out ));
305                         if( is_op ) strlcat( nick_out, "@", sizeof( nick_out ));
306                         if( is_halfop ) strlcat( nick_out, "%", sizeof( nick_out ));
307                         if( is_voiced ) strlcat( nick_out, "+", sizeof( nick_out ));
308                         strlcat( nick_out, ptr, sizeof( nick_out ));
309                 }
310                 else Log( LOG_ERR, "Got NJOIN for unknown nick \"%s\" for channel \"%s\"!", ptr, channame );
311
312                 /* search for next Nick */
313                 ptr = strtok( NULL, "," );
314         }
315
316         /* forward to other servers */
317         if (nick_out[0] != '\0')
318                 IRC_WriteStrServersPrefix(Client, Client_ThisServer(),
319                                           "NJOIN %s :%s", Req->argv[0], nick_out);
320
321         return CONNECTED;
322 } /* IRC_NJOIN */
323
324 /**
325  * Handler for the IRC "SQUIT" command.
326  *
327  * @param Client The client from which this command has been received.
328  * @param Req Request structure with prefix and all parameters.
329  * @return CONNECTED or DISCONNECTED.
330  */
331 GLOBAL bool
332 IRC_SQUIT(CLIENT * Client, REQUEST * Req)
333 {
334         char msg[COMMAND_LEN], logmsg[COMMAND_LEN];
335         CLIENT *from, *target;
336         CONN_ID con;
337         int loglevel;
338
339         assert(Client != NULL);
340         assert(Req != NULL);
341
342         if (Client_Type(Client) != CLIENT_SERVER
343             && !Client_HasMode(Client, 'o'))
344                 return Op_NoPrivileges(Client, Req);
345
346         if (Client_Type(Client) == CLIENT_SERVER && Req->prefix) {
347                 from = Client_Search(Req->prefix);
348                 if (Client_Type(from) != CLIENT_SERVER
349                     && !Op_Check(Client, Req))
350                         return Op_NoPrivileges(Client, Req);
351         } else
352                 from = Client;
353         if (!from)
354                 return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
355                                           Client_ID(Client), Req->prefix);
356
357         if (Client_Type(Client) == CLIENT_USER)
358                 loglevel = LOG_NOTICE | LOG_snotice;
359         else
360                 loglevel = LOG_DEBUG;
361         Log(loglevel, "Got SQUIT from %s for \"%s\": \"%s\" ...",
362             Client_ID(from), Req->argv[0], Req->argv[1]);
363
364         target = Client_Search(Req->argv[0]);
365         if (Client_Type(Client) != CLIENT_SERVER &&
366             target == Client_ThisServer())
367                 return Op_NoPrivileges(Client, Req);
368         if (!target) {
369                 /* The server is (already) unknown */
370                 Log(LOG_WARNING,
371                     "Got SQUIT from %s for unknown server \"%s\"!?",
372                     Client_ID(Client), Req->argv[0]);
373                 return CONNECTED;
374         }
375
376         con = Client_Conn(target);
377
378         if (Req->argv[1][0])
379                 if (Client_NextHop(from) != Client || con > NONE)
380                         snprintf(msg, sizeof(msg), "\"%s\" (SQUIT from %s)",
381                                  Req->argv[1], Client_ID(from));
382                 else
383                         strlcpy(msg, Req->argv[1], sizeof(msg));
384         else
385                 snprintf(msg, sizeof(msg), "Got SQUIT from %s",
386                          Client_ID(from));
387
388         if (con > NONE) {
389                 /* We are directly connected to the target server, so we
390                  * have to tear down the connection and to inform all the
391                  * other remaining servers in the network */
392                 IRC_SendWallops(Client_ThisServer(), Client_ThisServer(),
393                                 "Received SQUIT %s from %s: %s",
394                                 Req->argv[0], Client_ID(from),
395                                 Req->argv[1][0] ? Req->argv[1] : "-");
396                 Conn_Close(con, NULL, msg, true);
397                 if (con == Client_Conn(Client))
398                         return DISCONNECTED;
399         } else {
400                 /* This server is not directly connected, so the SQUIT must
401                  * be forwarded ... */
402                 if (Client_Type(from) != CLIENT_SERVER) {
403                         /* The origin is not an IRC server, so don't evaluate
404                          * this SQUIT but simply forward it */
405                         IRC_WriteStrClientPrefix(Client_NextHop(target),
406                             from, "SQUIT %s :%s", Req->argv[0], Req->argv[1]);
407                 } else {
408                         /* SQUIT has been generated by another server, so
409                          * remove the target server from the network! */
410                         logmsg[0] = '\0';
411                         if (!strchr(msg, '('))
412                                 snprintf(logmsg, sizeof(logmsg),
413                                          "\"%s\" (SQUIT from %s)", Req->argv[1],
414                                          Client_ID(from));
415                         Client_Destroy(target, logmsg[0] ? logmsg : msg,
416                                        msg, false);
417                 }
418         }
419         return CONNECTED;
420 } /* IRC_SQUIT */
421
422 /* -eof- */