![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to irc-login.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd|
Return to irc-login.c CVS log | Up to [local] / ircnowd / src / ngircd |
1.1 tomglok 1: /*
2: * ngIRCd -- The Next Generation IRC Daemon
3: * Copyright (c)2001-2018 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: * Login and logout
17: */
18:
19: #include <assert.h>
20: #include <ctype.h>
21: #include <stdlib.h>
22: #include <string.h>
23: #include <strings.h>
24: #include <time.h>
25:
26: #include "conn-func.h"
27: #include "conf.h"
28: #include "channel.h"
29: #include "log.h"
30: #include "login.h"
31: #include "messages.h"
32: #include "parse.h"
33: #include "irc.h"
34: #include "irc-macros.h"
35: #include "irc-write.h"
36:
37: #include "irc-login.h"
38:
39: static void Change_Nick PARAMS((CLIENT * Origin, CLIENT * Target, char *NewNick,
40: bool InformClient));
41:
42: /**
43: * Handler for the IRC "PASS" command.
44: *
45: * @param Client The client from which this command has been received.
46: * @param Req Request structure with prefix and all parameters.
47: * @return CONNECTED or DISCONNECTED.
48: */
49: GLOBAL bool
50: IRC_PASS( CLIENT *Client, REQUEST *Req )
51: {
52: char *type, *orig_flags;
53: int protohigh, protolow;
54:
55: assert( Client != NULL );
56: assert( Req != NULL );
57:
58: /* Return an error if this is not a local client */
59: if (Client_Conn(Client) <= NONE)
60: return IRC_WriteErrClient(Client, ERR_UNKNOWNCOMMAND_MSG,
61: Client_ID(Client), Req->command);
62:
63: if (Client_Type(Client) == CLIENT_UNKNOWN && Req->argc == 1) {
64: /* Not yet registered "unknown" connection, PASS with one
65: * argument: either a regular client, service, or server
66: * using the old RFC 1459 section 4.1.1 syntax. */
67: LogDebug("Connection %d: got PASS command (RFC 1459) ...",
68: Client_Conn(Client));
69: } else if ((Client_Type(Client) == CLIENT_UNKNOWN ||
70: Client_Type(Client) == CLIENT_UNKNOWNSERVER) &&
71: (Req->argc == 3 || Req->argc == 4)) {
72: /* Not yet registered "unknown" connection or outgoing server
73: * link, PASS with three or four argument: server using the
74: * RFC 2813 section 4.1.1 syntax. */
75: LogDebug("Connection %d: got PASS command (RFC 2813, new server link) ...",
76: Client_Conn(Client));
77: } else if (Client_Type(Client) == CLIENT_UNKNOWN ||
78: Client_Type(Client) == CLIENT_UNKNOWNSERVER) {
79: /* Unregistered connection, but wrong number of arguments: */
80: return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
81: Client_ID(Client), Req->command);
82: } else {
83: /* Registered connection, PASS command is not allowed! */
84: return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
85: Client_ID(Client));
86: }
87:
88: Conn_SetPassword(Client_Conn(Client), Req->argv[0]);
89:
90: /* Protocol version */
91: if (Req->argc >= 2 && strlen(Req->argv[1]) >= 4) {
92: char c2, c4;
93:
94: c2 = Req->argv[1][2];
95: c4 = Req->argv[1][4];
96:
97: Req->argv[1][4] = '\0';
98: protolow = atoi(&Req->argv[1][2]);
99: Req->argv[1][2] = '\0';
100: protohigh = atoi(Req->argv[1]);
101:
102: Req->argv[1][2] = c2;
103: Req->argv[1][4] = c4;
104:
105: Client_SetType(Client, CLIENT_GOTPASS_2813);
106: } else {
107: protohigh = protolow = 0;
108: Client_SetType(Client, CLIENT_GOTPASS);
109: }
110:
111: /* Protocol type, see doc/Protocol.txt */
112: if (Req->argc >= 2 && strlen(Req->argv[1]) > 4)
113: type = &Req->argv[1][4];
114: else
115: type = NULL;
116:
117: /* Protocol flags/options */
118: if (Req->argc >= 4)
119: orig_flags = Req->argv[3];
120: else
121: orig_flags = "";
122:
123: /* Implementation, version and IRC+ flags */
124: if (Req->argc >= 3) {
125: char *impl, *ptr, *serverver, *flags;
126:
127: impl = Req->argv[2];
128: ptr = strchr(impl, '|');
129: if (ptr)
130: *ptr = '\0';
131:
132: if (type && strcmp(type, PROTOIRCPLUS) == 0) {
133: /* The peer seems to be a server which supports the
134: * IRC+ protocol (see doc/Protocol.txt). */
135: serverver = ptr ? ptr + 1 : "?";
136: flags = strchr(ptr ? serverver : impl, ':');
137: if (flags) {
138: *flags = '\0';
139: flags++;
140: } else
141: flags = "";
142: Log(LOG_INFO,
143: "Peer on connection %d announces itself as %s-%s using protocol %d.%d/IRC+ (flags: \"%s\").",
144: Client_Conn(Client), impl, serverver,
145: protohigh, protolow, flags);
146: } else {
147: /* The peer seems to be a server supporting the
148: * "original" IRC protocol (RFC 2813). */
149: if (strchr(orig_flags, 'Z'))
150: flags = "Z";
151: else
152: flags = "";
153: Log(LOG_INFO,
154: "Peer on connection %d announces itself as \"%s\" using protocol %d.%d (flags: \"%s\").",
155: Client_Conn(Client), impl,
156: protohigh, protolow, flags);
157: }
158: Client_SetFlags(Client, flags);
159: }
160:
161: return CONNECTED;
162: } /* IRC_PASS */
163:
164: /**
165: * Handler for the IRC "NICK" command.
166: *
167: * @param Client The client from which this command has been received.
168: * @param Req Request structure with prefix and all parameters.
169: * @return CONNECTED or DISCONNECTED.
170: */
171: GLOBAL bool
172: IRC_NICK( CLIENT *Client, REQUEST *Req )
173: {
174: CLIENT *intr_c, *target, *c;
175: CHANNEL *chan;
176: char *nick, *user, *hostname, *modes, *info;
177: int token, hops;
178:
179: assert( Client != NULL );
180: assert( Req != NULL );
181:
182: /* Some IRC clients, for example BitchX, send the NICK and USER
183: * commands in the wrong order ... */
184: if(Client_Type(Client) == CLIENT_UNKNOWN
185: || Client_Type(Client) == CLIENT_GOTPASS
186: || Client_Type(Client) == CLIENT_GOTNICK
187: #ifndef STRICT_RFC
188: || Client_Type(Client) == CLIENT_GOTUSER
189: #endif
190: || Client_Type(Client) == CLIENT_USER
191: || Client_Type(Client) == CLIENT_SERVICE
192: || (Client_Type(Client) == CLIENT_SERVER && Req->argc == 1))
193: {
194: /* User registration or change of nickname */
195: _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 1)
196:
197: /* Search "target" client */
198: if (Client_Type(Client) == CLIENT_SERVER) {
199: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
200: target = Client_Search(Req->prefix);
201: if (!target)
202: return IRC_WriteErrClient(Client,
203: ERR_NOSUCHNICK_MSG,
204: Client_ID(Client),
205: Req->argv[0]);
206: } else {
207: /* Is this a restricted client? */
208: if (Client_HasMode(Client, 'r'))
209: return IRC_WriteErrClient(Client,
210: ERR_RESTRICTED_MSG,
211: Client_ID(Client));
212: target = Client;
213: }
214:
215: #ifndef STRICT_RFC
216: /* If the clients tries to change to its own nickname we won't
217: * do anything. This is how the original ircd behaves and some
218: * clients (for example Snak) expect it to be like this.
219: * But I doubt that this is "really the right thing" ... */
220: if (strcmp(Client_ID(target), Req->argv[0]) == 0)
221: return CONNECTED;
222: #endif
223:
224: /* Check that the new nickname is available. Special case:
225: * the client only changes from/to upper to lower case. */
226: if (strcasecmp(Client_ID(target), Req->argv[0]) != 0) {
227: if (!Client_CheckNick(target, Req->argv[0]))
228: return CONNECTED;
229: }
230:
231: if (Client_Type(target) != CLIENT_USER &&
232: Client_Type(target) != CLIENT_SERVICE &&
233: Client_Type(target) != CLIENT_SERVER) {
234: /* New client */
235: LogDebug("Connection %d: got valid NICK command ...",
236: Client_Conn( Client ));
237:
238: /* Register new nickname of this client */
239: Client_SetID( target, Req->argv[0] );
240:
241: #ifndef STRICT_RFC
242: if (Conf_AuthPing) {
243: #ifdef HAVE_ARC4RANDOM
244: Conn_SetAuthPing(Client_Conn(Client), arc4random());
245: #else
246: Conn_SetAuthPing(Client_Conn(Client), rand());
247: #endif
248: Conn_WriteStr(Client_Conn(Client), "PING :%ld",
249: Conn_GetAuthPing(Client_Conn(Client)));
250: LogDebug("Connection %d: sent AUTH PING %ld ...",
251: Client_Conn(Client),
252: Conn_GetAuthPing(Client_Conn(Client)));
253: }
254: #endif
255:
256: /* If we received a valid USER command already then
257: * register the new client! */
258: if( Client_Type( Client ) == CLIENT_GOTUSER )
259: return Login_User( Client );
260: else
261: Client_SetType( Client, CLIENT_GOTNICK );
262: } else {
263: /* Nickname change */
264:
265: /* Check that the user isn't on any channels set +N */
266: if(Client_Type(Client) == CLIENT_USER &&
267: !Client_HasMode(Client, 'o')) {
268: chan = Channel_First();
269: while (chan) {
270: if(Channel_HasMode(chan, 'N') &&
271: Channel_IsMemberOf(chan, Client))
272: return IRC_WriteErrClient(Client,
273: ERR_NONICKCHANGE_MSG,
274: Client_ID(Client),
275: Channel_Name(chan));
276: chan = Channel_Next(chan);
277: }
278: }
279:
280: Change_Nick(Client, target, Req->argv[0],
281: Client_Type(Client) == CLIENT_USER ? true : false);
282: IRC_SetPenalty(target, 2);
283: }
284:
285: return CONNECTED;
286: } else if(Client_Type(Client) == CLIENT_SERVER ||
287: Client_Type(Client) == CLIENT_SERVICE) {
288: /* Server or service introduces new client */
289:
290: /* Bad number of parameters? */
291: if (Req->argc != 2 && Req->argc != 7)
292: return IRC_WriteErrClient(Client, ERR_NEEDMOREPARAMS_MSG,
293: Client_ID(Client), Req->command);
294:
295: if (Req->argc >= 7) {
296: /* RFC 2813 compatible syntax */
297: nick = Req->argv[0];
298: hops = atoi(Req->argv[1]);
299: user = Req->argv[2];
300: hostname = Req->argv[3];
301: token = atoi(Req->argv[4]);
302: modes = Req->argv[5] + 1;
303: info = Req->argv[6];
304: } else {
305: /* RFC 1459 compatible syntax */
306: nick = Req->argv[0];
307: hops = 1;
308: user = Req->argv[0];
309: hostname = Client_ID(Client);
310: token = atoi(Req->argv[1]);
311: modes = "";
312: info = Req->argv[0];
313: }
314:
315: c = Client_Search(nick);
316: if(c) {
317: /*
318: * the new nick is already present on this server:
319: * the new and the old one have to be disconnected now.
320: */
321: Log(LOG_ERR,
322: "Server %s introduces already registered nick \"%s\"!",
323: Client_ID(Client), Req->argv[0]);
324: return IRC_KillClient(Client, NULL, Req->argv[0],
325: "Nick collision");
326: }
327:
328: /* Find the Server this client is connected to */
329: intr_c = Client_GetFromToken(Client, token);
330: if (!intr_c) {
331: Log(LOG_ERR,
332: "Server %s introduces nick \"%s\" on unknown server!?",
333: Client_ID(Client), Req->argv[0]);
334: return IRC_KillClient(Client, NULL, Req->argv[0],
335: "Unknown server");
336: }
337:
338: c = Client_NewRemoteUser(intr_c, nick, hops, user, hostname,
339: token, modes, info, true);
340: if (!c) {
341: /* Out of memory, we need to disconnect client to keep
342: * network state consistent! */
343: Log(LOG_ALERT,
344: "Can't create client structure! (on connection %d)",
345: Client_Conn(Client));
346: return IRC_KillClient(Client, NULL, Req->argv[0],
347: "Server error");
348: }
349:
350: /* RFC 2813: client is now fully registered, inform all the
351: * other servers about the new user.
352: * RFC 1459: announce the new client only after receiving the
353: * USER command, first we need more information! */
354: if (Req->argc < 7) {
355: LogDebug("Client \"%s\" is being registered (RFC 1459) ...",
356: Client_Mask(c));
357: Client_SetType(c, CLIENT_GOTNICK);
358: } else
359: Client_Introduce(Client, c, CLIENT_USER);
360:
361: return CONNECTED;
362: }
363: else
364: return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
365: Client_ID(Client));
366: } /* IRC_NICK */
367:
368: /**
369: * Handler for the IRC "SVSNICK" command.
370: *
371: * @param Client The client from which this command has been received.
372: * @param Req Request structure with prefix and all parameters.
373: * @return CONNECTED or DISCONNECTED.
374: */
375: GLOBAL bool
376: IRC_SVSNICK(CLIENT *Client, REQUEST *Req)
377: {
378: CLIENT *from, *target;
379:
380: assert(Client != NULL);
381: assert(Req != NULL);
382:
383: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
384:
385: /* Search the originator */
386: from = Client_Search(Req->prefix);
387: if (!from)
388: from = Client;
389:
390: /* Search the target */
391: target = Client_Search(Req->argv[0]);
392: if (!target || Client_Type(target) != CLIENT_USER)
393: return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
394: Client_ID(Client), Req->argv[0]);
395:
396: if (Client_Conn(target) <= NONE) {
397: /* We have to forward the message to the server handling
398: * this user; this is required to make sure all servers
399: * in the network do follow the nick name change! */
400: return IRC_WriteStrClientPrefix(Client_NextHop(target), from,
401: "SVSNICK %s %s",
402: Req->argv[0], Req->argv[1]);
403: }
404:
405: /* Make sure that the new nickname is valid */
406: if (!Client_CheckNick(from, Req->argv[1]))
407: return CONNECTED;
408:
409: Change_Nick(from, target, Req->argv[1], true);
410: return CONNECTED;
411: }
412:
413: /**
414: * Handler for the IRC "USER" command.
415: *
416: * @param Client The client from which this command has been received.
417: * @param Req Request structure with prefix and all parameters.
418: * @return CONNECTED or DISCONNECTED.
419: */
420: GLOBAL bool
421: IRC_USER(CLIENT * Client, REQUEST * Req)
422: {
423: CLIENT *c;
424: char *ptr;
425:
426: assert(Client != NULL);
427: assert(Req != NULL);
428:
429: if (Client_Type(Client) == CLIENT_GOTNICK ||
430: #ifndef STRICT_RFC
431: Client_Type(Client) == CLIENT_UNKNOWN ||
432: #endif
433: Client_Type(Client) == CLIENT_GOTPASS)
434: {
435: /* New connection */
436: _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 4)
437:
438: /* User name: only alphanumeric characters and limited
439: punctuation is allowed.*/
440: ptr = Req->argv[0];
441: while (*ptr) {
442: if (!isalnum((int)*ptr) &&
443: *ptr != '+' && *ptr != '-' && *ptr != '@' &&
444: *ptr != '.' && *ptr != '_') {
445: Conn_Close(Client_Conn(Client), NULL,
446: "Invalid user name", true);
447: return DISCONNECTED;
448: }
449: ptr++;
450: }
451:
452: /* Save the received username for authentication, and use
453: * it up to the first '@' as default user name (like ircd2.11,
454: * bahamut, ircd-seven, ...), prefixed with '~', if needed: */
455: Client_SetOrigUser(Client, Req->argv[0]);
456: ptr = strchr(Req->argv[0], '@');
457: if (ptr)
458: *ptr = '\0';
459: #ifdef IDENTAUTH
460: ptr = Client_User(Client);
461: if (!ptr || !*ptr || *ptr == '~')
462: Client_SetUser(Client, Req->argv[0], false);
463: #else
464: Client_SetUser(Client, Req->argv[0], false);
465: #endif
466:
467: /* "Real name" or user info text: Don't set it to the empty
468: * string, the original ircd can't deal with such "real names"
469: * (e. g. "USER user * * :") ... */
470: if (*Req->argv[3])
471: Client_SetInfo(Client, Req->argv[3]);
472: else
473: Client_SetInfo(Client, "-");
474:
475: LogDebug("Connection %d: got valid USER command ...",
476: Client_Conn(Client));
477: if (Client_Type(Client) == CLIENT_GOTNICK)
478: return Login_User(Client);
479: else
480: Client_SetType(Client, CLIENT_GOTUSER);
481: return CONNECTED;
482:
483: } else if (Client_Type(Client) == CLIENT_SERVER ||
484: Client_Type(Client) == CLIENT_SERVICE) {
485: /* Server/service updating an user */
486: _IRC_ARGC_EQ_OR_RETURN_(Client, Req, 4)
487: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
488:
489: c = Client_Search(Req->prefix);
490: if (!c)
491: return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
492: Client_ID(Client),
493: Req->prefix);
494:
495: Client_SetUser(c, Req->argv[0], true);
496: Client_SetOrigUser(c, Req->argv[0]);
497: Client_SetHostname(c, Req->argv[1]);
498: Client_SetInfo(c, Req->argv[3]);
499:
500: LogDebug("Connection %d: got valid USER command for \"%s\".",
501: Client_Conn(Client), Client_Mask(c));
502:
503: /* RFC 1459 style user registration?
504: * Introduce client to network: */
505: if (Client_Type(c) == CLIENT_GOTNICK)
506: Client_Introduce(Client, c, CLIENT_USER);
507:
508: return CONNECTED;
509: } else if (Client_Type(Client) == CLIENT_USER) {
510: /* Already registered connection */
511: return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
512: Client_ID(Client));
513: } else {
514: /* Unexpected/invalid connection state? */
515: return IRC_WriteErrClient(Client, ERR_NOTREGISTERED_MSG,
516: Client_ID(Client));
517: }
518: } /* IRC_USER */
519:
520: /**
521: * Handler for the IRC "SERVICE" command.
522: *
523: * At the moment ngIRCd doesn't support directly linked services, so this
524: * function returns ERR_ERRONEUSNICKNAME when the SERVICE command has not been
525: * received from a peer server.
526: *
527: * @param Client The client from which this command has been received.
528: * @param Req Request structure with prefix and all parameters.
529: * @return CONNECTED or DISCONNECTED.
530: */
531: GLOBAL bool
532: IRC_SERVICE(CLIENT *Client, REQUEST *Req)
533: {
534: CLIENT *c, *intr_c;
535: char *nick, *user, *host, *info, *modes, *ptr;
536: int token, hops;
537:
538: assert(Client != NULL);
539: assert(Req != NULL);
540:
541: if (Client_Type(Client) != CLIENT_GOTPASS &&
542: Client_Type(Client) != CLIENT_SERVER)
543: return IRC_WriteErrClient(Client, ERR_ALREADYREGISTRED_MSG,
544: Client_ID(Client));
545:
546: if (Client_Type(Client) != CLIENT_SERVER)
547: return IRC_WriteErrClient(Client, ERR_ERRONEUSNICKNAME_MSG,
548: Client_ID(Client), Req->argv[0]);
549:
550: nick = Req->argv[0];
551: user = NULL; host = NULL;
552: token = atoi(Req->argv[1]);
553: hops = atoi(Req->argv[4]);
554: info = Req->argv[5];
555:
556: /* Validate service name ("nickname") */
557: c = Client_Search(nick);
558: if(c) {
559: /* Nickname collision: disconnect (KILL) both clients! */
560: Log(LOG_ERR,
561: "Server %s introduces already registered service \"%s\"!",
562: Client_ID(Client), nick);
563: return IRC_KillClient(Client, NULL, nick, "Nick collision");
564: }
565:
566: /* Get the server to which the service is connected */
567: intr_c = Client_GetFromToken(Client, token);
568: if (! intr_c) {
569: Log(LOG_ERR,
570: "Server %s introduces service \"%s\" on unknown server!?",
571: Client_ID(Client), nick);
572: return IRC_KillClient(Client, NULL, nick, "Unknown server");
573: }
574:
575: /* Get user and host name */
576: ptr = strchr(nick, '@');
577: if (ptr) {
578: *ptr = '\0';
579: host = ++ptr;
580: }
581: if (!host)
582: host = Client_Hostname(intr_c);
583: ptr = strchr(nick, '!');
584: if (ptr) {
585: *ptr = '\0';
586: user = ++ptr;
587: }
588: if (!user)
589: user = nick;
590:
591: /* According to RFC 2812/2813 parameter 4 <type> "is currently reserved
592: * for future usage"; but we use it to transfer the modes and check
593: * that the first character is a '+' sign and ignore it otherwise. */
594: modes = (Req->argv[3][0] == '+') ? ++Req->argv[3] : "";
595:
596: c = Client_NewRemoteUser(intr_c, nick, hops, user, host,
597: token, modes, info, true);
598: if (! c) {
599: /* Couldn't create client structure, so KILL the service to
600: * keep network status consistent ... */
601: Log(LOG_ALERT,
602: "Can't create client structure! (on connection %d)",
603: Client_Conn(Client));
604: return IRC_KillClient(Client, NULL, nick, "Server error");
605: }
606:
607: Client_Introduce(Client, c, CLIENT_SERVICE);
608: return CONNECTED;
609: } /* IRC_SERVICE */
610:
611: /**
612: * Handler for the IRC "WEBIRC" command.
613: *
614: * @param Client The client from which this command has been received.
615: * @param Req Request structure with prefix and all parameters.
616: * @return CONNECTED or DISCONNECTED.
617: */
618: GLOBAL bool
619: IRC_WEBIRC(CLIENT *Client, REQUEST *Req)
620: {
621: if (!Conf_WebircPwd[0] || strcmp(Req->argv[0], Conf_WebircPwd) != 0)
622: return IRC_WriteErrClient(Client, ERR_PASSWDMISMATCH_MSG,
623: Client_ID(Client));
624:
625: LogDebug("Connection %d: got valid WEBIRC command: user=%s, host=%s, ip=%s",
626: Client_Conn(Client), Req->argv[1], Req->argv[2], Req->argv[3]);
627:
628: Client_SetUser(Client, Req->argv[1], true);
629: Client_SetOrigUser(Client, Req->argv[1]);
630: if (Conf_DNS)
631: Client_SetHostname(Client, Req->argv[2]);
632: else
633: Client_SetHostname(Client, Req->argv[3]);
634: Client_SetIPAText(Client, Req->argv[3]);
635:
636: return CONNECTED;
637: } /* IRC_WEBIRC */
638:
639: /**
640: * Handler for the IRC "QUIT" command.
641: *
642: * @param Client The client from which this command has been received.
643: * @param Req Request structure with prefix and all parameters.
644: * @return CONNECTED or DISCONNECTED.
645: */
646: GLOBAL bool
647: IRC_QUIT( CLIENT *Client, REQUEST *Req )
648: {
649: CLIENT *target;
650: char quitmsg[COMMAND_LEN];
651:
652: assert(Client != NULL);
653: assert(Req != NULL);
654:
655: if (Req->argc == 1)
656: strlcpy(quitmsg, Req->argv[0], sizeof quitmsg);
657:
658: if (Client_Type(Client) == CLIENT_SERVER) {
659: /* Server */
660: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
661:
662: target = Client_Search(Req->prefix);
663: if (!target) {
664: Log(LOG_WARNING,
665: "Got QUIT from %s for unknown client!?",
666: Client_ID(Client));
667: return CONNECTED;
668: }
669:
670: if (target != Client) {
671: Client_Destroy(target, "Got QUIT command",
672: Req->argc == 1 ? quitmsg : NULL, true);
673: return CONNECTED;
674: } else {
675: Conn_Close(Client_Conn(Client), "Got QUIT command",
676: Req->argc == 1 ? quitmsg : NULL, true);
677: return DISCONNECTED;
678: }
679: } else {
680: if (Req->argc == 1 && quitmsg[0] != '\"') {
681: /* " " to avoid confusion */
682: strlcpy(quitmsg, "\"", sizeof quitmsg);
683: strlcat(quitmsg, Req->argv[0], sizeof quitmsg-1);
684: strlcat(quitmsg, "\"", sizeof quitmsg );
685: }
686:
687: /* User, Service, or not yet registered */
688: Conn_Close(Client_Conn(Client), "Got QUIT command",
689: Req->argc == 1 ? quitmsg : NULL, true);
690:
691: return DISCONNECTED;
692: }
693: } /* IRC_QUIT */
694:
695: #ifndef STRICT_RFC
696:
697: /**
698: * Handler for HTTP command, e.g. GET and POST
699: *
700: * We handle these commands here to avoid the quite long timeout when
701: * some user tries to access this IRC daemon using an web browser ...
702: *
703: * @param Client The client from which this command has been received.
704: * @param Req Request structure with prefix and all parameters.
705: * @return CONNECTED or DISCONNECTED.
706: */
707: GLOBAL bool
708: IRC_QUIT_HTTP( CLIENT *Client, REQUEST *Req )
709: {
710: Req->argc = 1;
711: Req->argv[0] = "Oops, HTTP request received? This is IRC!";
712: return IRC_QUIT(Client, Req);
713: } /* IRC_QUIT_HTTP */
714:
715: #endif
716:
717: /**
718: * Handler for the IRC "PING" command.
719: *
720: * @param Client The client from which this command has been received.
721: * @param Req Request structure with prefix and all parameters.
722: * @return CONNECTED or DISCONNECTED.
723: */
724: GLOBAL bool
725: IRC_PING(CLIENT *Client, REQUEST *Req)
726: {
727: CLIENT *target, *from;
728:
729: assert(Client != NULL);
730: assert(Req != NULL);
731:
732: if (Req->argc < 1)
733: return IRC_WriteErrClient(Client, ERR_NOORIGIN_MSG,
734: Client_ID(Client));
735: #ifdef STRICT_RFC
736: /* Don't ignore additional arguments when in "strict" mode */
737: _IRC_ARGC_LE_OR_RETURN_(Client, Req, 2)
738: #endif
739:
740: if (Req->argc > 1) {
741: /* A target has been specified ... */
742: target = Client_Search(Req->argv[1]);
743:
744: if (!target || Client_Type(target) != CLIENT_SERVER)
745: return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
746: Client_ID(Client), Req->argv[1]);
747:
748: if (target != Client_ThisServer()) {
749: /* Ok, we have to forward the PING */
750: if (Client_Type(Client) == CLIENT_SERVER) {
751: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
752: from = Client_Search(Req->prefix);
753: } else
754: from = Client;
755: if (!from)
756: return IRC_WriteErrClient(Client,
757: ERR_NOSUCHSERVER_MSG,
758: Client_ID(Client), Req->prefix);
759:
760: return IRC_WriteStrClientPrefix(target, from,
761: "PING %s :%s", Req->argv[0],
762: Req->argv[1] );
763: }
764: }
765:
766: if (Client_Type(Client) == CLIENT_SERVER) {
767: if (Req->prefix)
768: from = Client_Search(Req->prefix);
769: else
770: from = Client;
771: } else
772: from = Client_ThisServer();
773: if (!from)
774: return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
775: Client_ID(Client), Req->prefix);
776:
777: Log(LOG_DEBUG, "Connection %d: got PING, sending PONG ...",
778: Client_Conn(Client));
779:
780: #ifdef STRICT_RFC
781: return IRC_WriteStrClient(Client, "PONG %s :%s",
782: Client_ID(from), Client_ID(Client));
783: #else
784: /* Some clients depend on the argument being returned in the PONG
785: * reply (not mentioned in any RFC, though) */
786: return IRC_WriteStrClient(Client, "PONG %s :%s",
787: Client_ID(from), Req->argv[0]);
788: #endif
789: } /* IRC_PING */
790:
791: /**
792: * Handler for the IRC "PONG" command.
793: *
794: * @param Client The client from which this command has been received.
795: * @param Req Request structure with prefix and all parameters.
796: * @return CONNECTED or DISCONNECTED.
797: */
798: GLOBAL bool
799: IRC_PONG(CLIENT *Client, REQUEST *Req)
800: {
801: CLIENT *target, *from;
802: CONN_ID conn;
803: #ifndef STRICT_RFC
804: long auth_ping;
805: #endif
806: char *s;
807:
808: assert(Client != NULL);
809: assert(Req != NULL);
810:
811: /* Wrong number of arguments? */
812: if (Req->argc < 1) {
813: if (Client_Type(Client) == CLIENT_USER)
814: return IRC_WriteErrClient(Client, ERR_NOORIGIN_MSG,
815: Client_ID(Client));
816: else
817: return CONNECTED;
818: }
819: if (Client_Type(Client) == CLIENT_USER) {
820: _IRC_ARGC_LE_OR_RETURN_(Client, Req, 2)
821: }
822:
823: /* Forward? */
824: if (Req->argc == 2 && Client_Type(Client) == CLIENT_SERVER) {
825: _IRC_REQUIRE_PREFIX_OR_RETURN_(Client, Req)
826:
827: target = Client_Search(Req->argv[0]);
828: if (!target)
829: return IRC_WriteErrClient(Client, ERR_NOSUCHSERVER_MSG,
830: Client_ID(Client), Req->argv[0]);
831:
832: from = Client_Search(Req->prefix);
833:
834: if (target != Client_ThisServer() && target != from) {
835: /* Ok, we have to forward the message. */
836: if (!from)
837: return IRC_WriteErrClient(Client,
838: ERR_NOSUCHSERVER_MSG,
839: Client_ID(Client), Req->prefix);
840:
841: if (Client_Type(Client_NextHop(target)) != CLIENT_SERVER)
842: s = Client_ID(from);
843: else
844: s = Req->argv[0];
845: return IRC_WriteStrClientPrefix(target, from,
846: "PONG %s :%s", s, Req->argv[1]);
847: }
848: }
849:
850: /* The connection timestamp has already been updated when the data has
851: * been read from so socket, so we don't need to update it here. */
852:
853: conn = Client_Conn(Client);
854:
855: #ifndef STRICT_RFC
856: /* Check authentication PING-PONG ... */
857: auth_ping = Conn_GetAuthPing(conn);
858: if (auth_ping) {
859: LogDebug("AUTH PONG: waiting for token \"%ld\", got \"%s\" ...",
860: auth_ping, Req->argv[0]);
861: if (auth_ping == atol(Req->argv[0])) {
862: Conn_SetAuthPing(conn, 0);
863: if (Client_Type(Client) == CLIENT_WAITAUTHPING)
864: Login_User(Client);
865: } else
866: if (!IRC_WriteStrClient(Client,
867: "NOTICE %s :To connect, type /QUOTE PONG %ld",
868: Client_ID(Client), auth_ping))
869: return DISCONNECTED;
870: }
871: #endif
872:
873: if (Client_Type(Client) == CLIENT_SERVER && Conn_LastPing(conn) == 0) {
874: Log(LOG_INFO,
875: "Synchronization with \"%s\" done (connection %d): %ld second%s [%ld users, %ld channels].",
876: Client_ID(Client), conn,
877: (long)(time(NULL) - Conn_GetSignon(conn)),
878: time(NULL) - Conn_GetSignon(conn) == 1 ? "" : "s",
879: Client_UserCount(), Channel_CountVisible(NULL));
880: }
881: #ifdef DEBUG
882: else {
883: if (Conn_LastPing(conn) > 1)
884: LogDebug("Connection %d: received PONG. Lag: %ld seconds.",
885: conn, (long)(time(NULL) - Conn_LastPing(conn)));
886: else
887: LogDebug("Got unexpected PONG on connection %d. Ignored.",
888: conn);
889: }
890: #endif
891:
892: /* We got a PONG, so signal that none is pending on this connection. */
893: Conn_UpdatePing(conn, 1);
894: return CONNECTED;
895: } /* IRC_PONG */
896:
897: /**
898: * Change the nickname of a client.
899: *
900: * @param Origin The client which caused the nickname change.
901: * @param Target The client of which the nickname should be changed.
902: * @param NewNick The new nickname.
903: */
904: static void
905: Change_Nick(CLIENT *Origin, CLIENT *Target, char *NewNick, bool InformClient)
906: {
907: if (Client_Conn(Target) > NONE) {
908: /* Local client */
909: Log(LOG_INFO,
910: "%s \"%s\" changed nick (connection %d): \"%s\" -> \"%s\".",
911: Client_TypeText(Target), Client_Mask(Target),
912: Client_Conn(Target), Client_ID(Target), NewNick);
913: Conn_UpdateIdle(Client_Conn(Target));
914: } else {
915: /* Remote client */
916: LogDebug("%s \"%s\" changed nick: \"%s\" -> \"%s\".",
917: Client_TypeText(Target),
918: Client_Mask(Target), Client_ID(Target), NewNick);
919: }
920:
921: /* Inform all servers and users (which have to know) of the new name */
922: if (InformClient) {
923: IRC_WriteStrClientPrefix(Target, Target, "NICK :%s", NewNick);
924: IRC_WriteStrServersPrefix(NULL, Target, "NICK :%s", NewNick);
925: } else
926: IRC_WriteStrServersPrefix(Origin, Target, "NICK :%s", NewNick);
927: IRC_WriteStrRelatedPrefix(Target, Target, false, "NICK :%s", NewNick);
928:
929: /* Register old nickname for WHOWAS queries */
930: Client_RegisterWhowas(Target);
931:
932: /* Save new nickname */
933: Client_SetID(Target, NewNick);
934: }
935:
936: /* -eof- */