1 /************************************************************************
2 * IRC - Internet Relay Chat, src/s_auth.c
3 * Copyright (C) 1992 Darren Reed
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 1, or (at your option)
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * July 6, 1999 - Rewrote most of the code here. When a client connects
21 * to the server and passes initial socket validation checks, it
22 * is owned by this module (auth) which returns it to the rest of the
23 * server when dns and auth queries are finished. Until the client is
24 * released, the server does not know it exists and does not process
25 * any messages from it.
26 * --Bleep Thomas Helvey <tomh@inxpress.net>
28 * December 26, 2005 - Rewrite the flag handling and integrate that with
29 * an IRCnet-style IAuth protocol.
33 * @brief Implementation of DNS and ident lookups.
34 * @version $Id: s_auth.c,v 1.37.2.25 2007/08/09 03:46:20 entrope Exp $
43 #include "ircd_alloc.h"
44 #include "ircd_chattr.h"
45 #include "ircd_events.h"
46 #include "ircd_features.h"
48 #include "ircd_osdep.h"
49 #include "ircd_reply.h"
50 #include "ircd_snprintf.h"
51 #include "ircd_string.h"
53 #include "msg.h" /* for MAXPARA */
55 #include "querycmds.h"
70 #include <sys/socket.h>
71 #include <sys/ioctl.h>
73 /** Pending operations during registration. */
74 enum AuthRequestFlag
{
75 AR_AUTH_PENDING
, /**< ident connecting or waiting for response */
76 AR_DNS_PENDING
, /**< dns request sent, waiting for response */
77 AR_CAP_PENDING
, /**< in middle of CAP negotiations */
78 AR_NEEDS_PONG
, /**< user has not PONGed */
79 AR_NEEDS_USER
, /**< user must send USER command */
80 AR_NEEDS_NICK
, /**< user must send NICK command */
81 AR_LAST_SCAN
= AR_NEEDS_NICK
, /**< maximum flag to scan through */
82 AR_IAUTH_PENDING
, /**< iauth request sent, waiting for response */
83 AR_IAUTH_HURRY
, /**< we told iauth to hurry up */
84 AR_IAUTH_USERNAME
, /**< iauth sent a username (preferred or forced) */
85 AR_IAUTH_FUSERNAME
, /**< iauth sent a forced username */
86 AR_PASSWORD_CHECKED
, /**< client password already checked */
90 DECLARE_FLAGSET(AuthRequestFlags
, AR_NUM_FLAGS
);
92 /** Stores registration state of a client. */
94 struct AuthRequest
* next
; /**< linked list node ptr */
95 struct AuthRequest
* prev
; /**< linked list node ptr */
96 struct Client
* client
; /**< pointer to client struct for request */
97 struct irc_sockaddr local
; /**< local endpoint address */
98 struct irc_in_addr original
; /**< original client IP address */
99 struct Socket socket
; /**< socket descriptor for auth queries */
100 struct Timer timeout
; /**< timeout timer for ident and dns queries */
101 struct AuthRequestFlags flags
; /**< current state of request */
102 unsigned int cookie
; /**< cookie the user must PONG */
103 unsigned short port
; /**< client's remote port number */
106 /** Array of message text (with length) pairs for AUTH status
107 * messages. Indexed using #ReportType.
112 } HeaderMessages
[] = {
113 #define MSG(STR) { STR, sizeof(STR) - 1 }
114 MSG("NOTICE AUTH :*** Looking up your hostname\r\n"),
115 MSG("NOTICE AUTH :*** Found your hostname\r\n"),
116 MSG("NOTICE AUTH :*** Couldn't look up your hostname\r\n"),
117 MSG("NOTICE AUTH :*** Checking Ident\r\n"),
118 MSG("NOTICE AUTH :*** Got ident response\r\n"),
119 MSG("NOTICE AUTH :*** No ident response\r\n"),
120 MSG("NOTICE AUTH :*** \r\n"),
121 MSG("NOTICE AUTH :*** Your forward and reverse DNS do not match, "
122 "ignoring hostname.\r\n"),
123 MSG("NOTICE AUTH :*** Invalid hostname\r\n")
127 /** Enum used to index messages in the HeaderMessages[] array. */
140 /** Sends response \a r (from #ReportType) to client \a c. */
141 #define sendheader(c, r) \
142 send(cli_fd(c), HeaderMessages[(r)].message, HeaderMessages[(r)].length, 0)
144 /** Enumeration of IAuth connection flags. */
147 IAUTH_BLOCKED
, /**< socket buffer full */
148 IAUTH_CLOSING
, /**< candidate to be disposed */
149 /* The following flags are controlled by iauth's "O" options command. */
150 IAUTH_ADDLINFO
, /**< Send additional info
151 * (password and username). */
152 IAUTH_FIRST_OPTION
= IAUTH_ADDLINFO
, /**< First flag that is a policy option. */
153 IAUTH_REQUIRED
, /**< IAuth completion required for registration. */
154 IAUTH_TIMEOUT
, /**< Refuse new connections if IAuth is behind. */
155 IAUTH_EXTRAWAIT
, /**< Give IAuth extra time to answer. */
156 IAUTH_UNDERNET
, /**< Enable Undernet extensions. */
157 IAUTH_LAST_FLAG
/**< total number of flags */
159 /** Declare a bitset structure indexed by IAuthFlag. */
160 DECLARE_FLAGSET(IAuthFlags
, IAUTH_LAST_FLAG
);
162 /** Describes state of an IAuth connection. */
164 struct MsgQ i_sendQ
; /**< messages queued to send */
165 struct Socket i_socket
; /**< main socket to iauth */
166 struct Socket i_stderr
; /**< error socket for iauth */
167 struct IAuthFlags i_flags
; /**< connection state/status/flags */
168 uint64_t i_recvB
; /**< bytes received */
169 uint64_t i_sendB
; /**< bytes sent */
170 time_t started
; /**< time that this instance was started */
171 unsigned int i_recvM
; /**< messages received */
172 unsigned int i_sendM
; /**< messages sent */
173 unsigned int i_count
; /**< characters used in i_buffer */
174 unsigned int i_errcount
; /**< characters used in i_errbuf */
175 int i_debug
; /**< debug level */
176 char i_buffer
[BUFSIZE
+1]; /**< partial unprocessed line from server */
177 char i_errbuf
[BUFSIZE
+1]; /**< partial unprocessed error line */
178 char *i_version
; /**< iauth version string */
179 struct SLink
*i_config
; /**< configuration string list */
180 struct SLink
*i_stats
; /**< statistics string list */
181 char **i_argv
; /**< argument list */
184 /** Return whether flag \a flag is set on \a iauth. */
185 #define IAuthHas(iauth, flag) ((iauth) && FlagHas(&(iauth)->i_flags, flag))
186 /** Set flag \a flag on \a iauth. */
187 #define IAuthSet(iauth, flag) FlagSet(&(iauth)->i_flags, flag)
188 /** Clear flag \a flag from \a iauth. */
189 #define IAuthClr(iauth, flag) FlagClr(&(iauth)->i_flags, flag)
190 /** Get connected flag for \a iauth. */
191 #define i_GetConnected(iauth) ((iauth) && s_fd(i_socket(iauth)) > -1)
193 /** Return socket event generator for \a iauth. */
194 #define i_socket(iauth) (&(iauth)->i_socket)
195 /** Return stderr socket for \a iauth. */
196 #define i_stderr(iauth) (&(iauth)->i_stderr)
197 /** Return outbound message queue for \a iauth. */
198 #define i_sendQ(iauth) (&(iauth)->i_sendQ)
199 /** Return debug level for \a iauth. */
200 #define i_debug(iauth) ((iauth)->i_debug)
202 /** Active instance of IAuth. */
203 static struct IAuth
*iauth
;
204 /** Freelist of AuthRequest structures. */
205 static struct AuthRequest
*auth_freelist
;
207 static void iauth_sock_callback(struct Event
*ev
);
208 static void iauth_stderr_callback(struct Event
*ev
);
209 static int sendto_iauth(struct Client
*cptr
, const char *format
, ...);
210 static int preregister_user(struct Client
*cptr
);
211 typedef int (*iauth_cmd_handler
)(struct IAuth
*iauth
, struct Client
*cli
,
212 int parc
, char **params
);
214 /** Set username for user associated with \a auth.
215 * @param[in] auth Client authorization request to work on.
216 * @return Zero if client is kept, CPTR_KILLED if client rejected.
218 static int auth_set_username(struct AuthRequest
*auth
)
220 struct Client
*sptr
= auth
->client
;
221 struct User
*user
= cli_user(sptr
);
233 if (FlagHas(&auth
->flags
, AR_IAUTH_USERNAME
))
235 ircd_strncpy(cli_user(sptr
)->username
, cli_username(sptr
), USERLEN
);
239 /* Copy username from source to destination. Since they may be the
240 * same, and we may prefix with a '~', use a buffer character (ch)
241 * to hold the next character to copy.
243 s
= IsIdented(sptr
) ? cli_username(sptr
) : user
->username
;
246 if (HasFlag(sptr
, FLAG_DOID
) && !IsIdented(sptr
))
251 while (last
&& !IsCntrl(last
) && rlen
--)
254 *d
++ = IsUserChar(last
) ? last
: '_';
255 last
= (ch
!= '~') ? ch
: '_';
260 /* If username is empty or just ~, reject. */
261 if ((user
->username
[0] == '\0')
262 || ((user
->username
[0] == '~') && (user
->username
[1] == '\0')))
263 return exit_client(sptr
, sptr
, &me
, "USER: Bogus userid.");
265 /* Have to set up "realusername" before doing the gline check below */
266 ircd_strncpy(user
->realusername
, user
->username
, USERLEN
);
268 /* Check for K- or G-line. */
269 killreason
= find_kill(sptr
, 1);
271 ServerStats
->is_ref
++;
272 return exit_client(sptr
, sptr
, &me
,
273 (killreason
== -1 ? "K-lined" : "G-lined"));
276 if (!FlagHas(&auth
->flags
, AR_IAUTH_FUSERNAME
))
278 /* Check for mixed case usernames, meaning probably hacked. Jon2 3-94
279 * Explanations of rules moved to where it is checked Entrope 2-06
281 s
= d
= user
->username
+ (user
->username
[0] == '~');
286 if (IsLower(ch
) || IsUpper(ch
))
290 else if (IsDigit(ch
))
294 else if (ch
== '-' || ch
== '_' || ch
== '.')
297 /* If -_. exist at start, consecutively, or more than twice, reject. */
298 if (pos
== 0 || last
== '-' || last
== '_' || last
== '.' || other
> 2)
301 else /* All other punctuation is rejected. */
305 /* Must have at least one letter. */
313 /* If we confirmed their username, and it is what they claimed,
315 if (IsIdented(sptr
) && !strcmp(cli_username(sptr
), user
->username
))
318 ServerStats
->is_ref
++;
319 send_reply(sptr
, SND_EXPLICIT
| ERR_INVALIDUSERNAME
,
320 ":Your username is invalid.");
321 send_reply(sptr
, SND_EXPLICIT
| ERR_INVALIDUSERNAME
,
322 ":Connect with your real username, in lowercase.");
323 send_reply(sptr
, SND_EXPLICIT
| ERR_INVALIDUSERNAME
,
324 ":If your mail address were foo@bar.com, your username "
326 return exit_client(sptr
, sptr
, &me
, "USER: Bad username");
329 /** Check whether an authorization request is complete.
330 * This means that no flags from 0 to #AR_LAST_SCAN are set on \a auth.
331 * If #AR_IAUTH_PENDING is set, optionally go into "hurry" state. If
332 * 0 through #AR_LAST_SCAN and #AR_IAUTH_PENDING are all clear,
333 * destroy \a auth, clear the password, set the username, and register
335 * @param[in] auth Authorization request to check.
336 * @return Zero if client is kept, CPTR_KILLED if client rejected.
338 static int check_auth_finished(struct AuthRequest
*auth
)
340 enum AuthRequestFlag flag
;
343 /* Check non-iauth registration blocking flags. */
344 for (flag
= 0; flag
<= AR_LAST_SCAN
; ++flag
)
345 if (FlagHas(&auth
->flags
, flag
))
347 Debug((DEBUG_INFO
, "Auth %p [%d] still has flag %d", auth
,
348 cli_fd(auth
->client
), flag
));
352 /* If appropriate, do preliminary assignment to connection class. */
353 if (IsUserPort(auth
->client
)
354 && !FlagHas(&auth
->flags
, AR_IAUTH_HURRY
)
355 && preregister_user(auth
->client
))
358 /* If we have not done so, check client password. Do this as soon
359 * as possible so that iauth's challenge/response (which uses PASS
360 * for responses) is not confused with the client's password.
362 if (IsUserPort(auth
->client
)
363 && !FlagHas(&auth
->flags
, AR_PASSWORD_CHECKED
))
365 struct ConfItem
*aconf
;
367 aconf
= cli_confs(auth
->client
)->value
.aconf
;
369 && !EmptyString(aconf
->passwd
)
370 && strcmp(cli_passwd(auth
->client
), aconf
->passwd
))
372 ServerStats
->is_ref
++;
373 send_reply(auth
->client
, ERR_PASSWDMISMATCH
);
374 return exit_client(auth
->client
, auth
->client
, &me
, "Bad Password");
376 FlagSet(&auth
->flags
, AR_PASSWORD_CHECKED
);
379 /* Check if iauth is done. */
380 if (FlagHas(&auth
->flags
, AR_IAUTH_PENDING
))
382 /* Switch auth request to hurry-up state. */
383 if (!FlagHas(&auth
->flags
, AR_IAUTH_HURRY
))
385 /* Set "hurry" flag in auth request. */
386 FlagSet(&auth
->flags
, AR_IAUTH_HURRY
);
388 /* If iauth wants it, send notification. */
389 if (IAuthHas(iauth
, IAUTH_UNDERNET
))
390 sendto_iauth(auth
->client
, "H %s", get_client_class(auth
->client
));
392 /* If iauth wants it, give client more time. */
393 if (IAuthHas(iauth
, IAUTH_EXTRAWAIT
))
394 cli_firsttime(auth
->client
) = CurrentTime
;
397 Debug((DEBUG_INFO
, "Auth %p [%d] still has flag %d", auth
,
398 cli_fd(auth
->client
), AR_IAUTH_PENDING
));
402 FlagSet(&auth
->flags
, AR_IAUTH_HURRY
);
404 if (IsUserPort(auth
->client
))
406 memset(cli_passwd(auth
->client
), 0, sizeof(cli_passwd(auth
->client
)));
407 res
= auth_set_username(auth
);
409 res
= register_user(auth
->client
, auth
->client
);
414 destroy_auth_request(auth
);
418 /** Verify that a hostname is valid, i.e., only contains characters
419 * valid for a hostname and that a hostname is not too long.
420 * @param host Hostname to check.
421 * @param maxlen Maximum length of hostname, not including NUL terminator.
422 * @return Non-zero if the hostname is valid.
425 auth_verify_hostname(const char *host
, int maxlen
)
429 /* Walk through the host name */
430 for (i
= 0; host
[i
]; i
++)
431 /* If it's not a hostname character or if it's too long, return false */
432 if (!IsHostChar(host
[i
]) || i
>= maxlen
)
435 return 1; /* it's a valid hostname */
438 /** Assign a client to a connection class.
439 * @param[in] cptr Client to assign to a class.
440 * @return Zero if client is kept, CPTR_KILLED if rejected.
442 static int preregister_user(struct Client
*cptr
)
444 static time_t last_too_many1
;
445 static time_t last_too_many2
;
447 ircd_strncpy(cli_user(cptr
)->host
, cli_sockhost(cptr
), HOSTLEN
);
448 ircd_strncpy(cli_user(cptr
)->realhost
, cli_sockhost(cptr
), HOSTLEN
);
450 switch (conf_check_client(cptr
))
454 case ACR_NO_AUTHORIZATION
:
455 sendto_opmask_butone(0, SNO_UNAUTH
, "Unauthorized connection from %s.",
456 get_client_name(cptr
, HIDE_IP
));
457 ++ServerStats
->is_ref
;
458 return exit_client(cptr
, cptr
, &me
,
459 "No Authorization - use another server");
460 case ACR_TOO_MANY_IN_CLASS
:
461 sendto_opmask_butone_ratelimited(0, SNO_TOOMANY
, &last_too_many1
,
462 "Too many connections in class %s for %s.",
463 get_client_class(cptr
),
464 get_client_name(cptr
, SHOW_IP
));
465 ++ServerStats
->is_ref
;
466 return exit_client(cptr
, cptr
, &me
,
467 "Sorry, your connection class is full - try "
468 "again later or try another server");
469 case ACR_TOO_MANY_FROM_IP
:
470 sendto_opmask_butone_ratelimited(0, SNO_TOOMANY
, &last_too_many2
,
471 "Too many connections from same IP for %s.",
472 get_client_name(cptr
, SHOW_IP
));
473 ++ServerStats
->is_ref
;
474 return exit_client(cptr
, cptr
, &me
,
475 "Too many connections from your host");
476 case ACR_ALREADY_AUTHORIZED
:
477 /* Can this ever happen? */
479 ++ServerStats
->is_ref
;
480 IPcheck_connect_fail(cptr
);
481 return exit_client(cptr
, cptr
, &me
, "Unknown error -- Try again");
486 /** Send the ident server a query giving "theirport , ourport". The
487 * write is only attempted *once* so it is deemed to be a fail if the
488 * entire write doesn't write all the data given. This shouldn't be a
489 * problem since the socket should have a write buffer far greater
490 * than this message to store it in should problems arise. -avalon
491 * @param[in] auth The request to send.
493 static void send_auth_query(struct AuthRequest
* auth
)
500 ircd_snprintf(0, authbuf
, sizeof(authbuf
), "%hu , %hu\r\n",
501 auth
->port
, auth
->local
.port
);
503 if (IO_SUCCESS
!= os_send_nonb(s_fd(&auth
->socket
), authbuf
, strlen(authbuf
), &count
)) {
504 close(s_fd(&auth
->socket
));
505 socket_del(&auth
->socket
);
506 s_fd(&auth
->socket
) = -1;
507 ++ServerStats
->is_abad
;
508 if (IsUserPort(auth
->client
))
509 sendheader(auth
->client
, REPORT_FAIL_ID
);
510 FlagClr(&auth
->flags
, AR_AUTH_PENDING
);
511 check_auth_finished(auth
);
515 /** Enum used to index ident reply fields in a human-readable way. */
516 enum IdentReplyFields
{
524 /** Parse an ident reply line and extract the userid from it.
525 * @param[in] reply The ident reply line.
526 * @return The userid, or NULL on parse failure.
528 static char* check_ident_reply(char* reply
)
532 char* vector
[USERID_TOKEN_COUNT
];
533 int count
= token_vector(reply
, ':', vector
, USERID_TOKEN_COUNT
);
535 if (USERID_TOKEN_COUNT
!= count
)
538 * second token is the reply type
540 token
= vector
[IDENT_REPLY_TYPE
];
541 if (EmptyString(token
))
544 while (IsSpace(*token
))
547 if (0 != strncmp(token
, "USERID", 6))
551 * third token is the os type
553 token
= vector
[IDENT_OS_TYPE
];
554 if (EmptyString(token
))
556 while (IsSpace(*token
))
560 * Unless "OTHER" is specified as the operating system
561 * type, the server is expected to return the "normal"
562 * user identification of the owner of this connection.
563 * "Normal" in this context may be taken to mean a string
564 * of characters which uniquely identifies the connection
565 * owner such as a user identifier assigned by the system
566 * administrator and used by such user as a mail
567 * identifier, or as the "user" part of a user/password
568 * pair used to gain access to system resources. When an
569 * operating system is specified (e.g., anything but
570 * "OTHER"), the user identifier is expected to be in a
571 * more or less immediately useful form - e.g., something
572 * that could be used as an argument to "finger" or as a
575 if (0 == strncmp(token
, "OTHER", 5))
578 * fourth token is the username
580 token
= vector
[IDENT_INFO
];
581 if (EmptyString(token
))
583 while (IsSpace(*token
))
586 * look for the end of the username, terminators are '\0, @, <SPACE>, :'
588 for (end
= token
; *end
; ++end
) {
589 if (IsSpace(*end
) || '@' == *end
|| ':' == *end
)
596 /** Read the reply (if any) from the ident server we connected to. We
597 * only give it one shot, if the reply isn't good the first time fail
598 * the authentication entirely. --Bleep
599 * @param[in] auth The request to read.
601 static void read_auth_reply(struct AuthRequest
* auth
)
606 * rfc1453 sez we MUST accept 512 bytes
608 char buf
[BUFSIZE
+ 1];
611 assert(0 != auth
->client
);
612 assert(auth
== cli_auth(auth
->client
));
614 if (IO_SUCCESS
== os_recv_nonb(s_fd(&auth
->socket
), buf
, BUFSIZE
, &len
)) {
616 Debug((DEBUG_INFO
, "Auth %p [%d] reply: %s", auth
, cli_fd(auth
->client
), buf
));
617 username
= check_ident_reply(buf
);
618 Debug((DEBUG_INFO
, "Username: %s", username
));
621 Debug((DEBUG_INFO
, "Deleting auth [%d] socket %p", auth
, cli_fd(auth
->client
)));
622 close(s_fd(&auth
->socket
));
623 socket_del(&auth
->socket
);
624 s_fd(&auth
->socket
) = -1;
626 if (EmptyString(username
)) {
627 if (IsUserPort(auth
->client
))
628 sendheader(auth
->client
, REPORT_FAIL_ID
);
629 ++ServerStats
->is_abad
;
631 if (IsUserPort(auth
->client
))
632 sendheader(auth
->client
, REPORT_FIN_ID
);
633 ++ServerStats
->is_asuc
;
634 if (!FlagHas(&auth
->flags
, AR_IAUTH_USERNAME
)) {
635 ircd_strncpy(cli_username(auth
->client
), username
, USERLEN
);
636 SetGotId(auth
->client
);
638 if (IAuthHas(iauth
, IAUTH_UNDERNET
))
639 sendto_iauth(auth
->client
, "u %s", username
);
642 FlagClr(&auth
->flags
, AR_AUTH_PENDING
);
643 check_auth_finished(auth
);
646 /** Handle socket I/O activity.
647 * @param[in] ev A socket event whos associated data is the active
648 * struct AuthRequest.
650 static void auth_sock_callback(struct Event
* ev
)
652 struct AuthRequest
* auth
;
654 assert(0 != ev_socket(ev
));
655 assert(0 != s_data(ev_socket(ev
)));
657 auth
= (struct AuthRequest
*) s_data(ev_socket(ev
));
659 switch (ev_type(ev
)) {
660 case ET_DESTROY
: /* being destroyed */
663 case ET_CONNECT
: /* socket connection completed */
664 Debug((DEBUG_INFO
, "Connection completed for auth %p [%d]; sending query",
665 auth
, cli_fd(auth
->client
)));
666 socket_state(&auth
->socket
, SS_CONNECTED
);
667 send_auth_query(auth
);
670 case ET_READ
: /* socket is readable */
671 case ET_EOF
: /* end of file on socket */
672 case ET_ERROR
: /* error on socket */
673 Debug((DEBUG_INFO
, "Auth socket %p [%p] readable", auth
, ev_socket(ev
)));
674 read_auth_reply(auth
);
678 assert(0 && "Unrecognized event in auth_socket_callback().");
683 /** Stop an auth request completely.
684 * @param[in] auth The struct AuthRequest to cancel.
686 void destroy_auth_request(struct AuthRequest
* auth
)
688 Debug((DEBUG_INFO
, "Deleting auth request for %p", auth
->client
));
690 if (FlagHas(&auth
->flags
, AR_DNS_PENDING
)) {
691 delete_resolver_queries(auth
);
694 if (-1 < s_fd(&auth
->socket
)) {
695 close(s_fd(&auth
->socket
));
696 socket_del(&auth
->socket
);
697 s_fd(&auth
->socket
) = -1;
700 if (t_active(&auth
->timeout
))
701 timer_del(&auth
->timeout
);
703 cli_auth(auth
->client
) = NULL
;
704 auth
->next
= auth_freelist
;
705 auth_freelist
= auth
;
708 /** Handle a 'ping' (authorization) timeout for a client.
709 * @param[in] cptr The client whose session authorization has timed out.
710 * @return Zero if client is kept, CPTR_KILLED if client rejected.
712 int auth_ping_timeout(struct Client
*cptr
)
714 struct AuthRequest
*auth
;
715 enum AuthRequestFlag flag
;
717 auth
= cli_auth(cptr
);
719 /* Check whether the auth request is gone (more likely, it never
720 * existed, as in an outbound server connection). */
722 return exit_client_msg(cptr
, cptr
, &me
, "Registration Timeout");
724 /* Check for a user-controlled timeout. */
725 for (flag
= 0; flag
<= AR_LAST_SCAN
; ++flag
) {
726 if (FlagHas(&auth
->flags
, flag
)) {
727 /* Display message if they have sent a NICK and a USER but no
730 if (*(cli_name(cptr
)) && cli_user(cptr
) && *(cli_user(cptr
))->username
) {
731 send_reply(cptr
, SND_EXPLICIT
| ERR_BADPING
,
732 ":Your client may not be compatible with this server.");
733 send_reply(cptr
, SND_EXPLICIT
| ERR_BADPING
,
734 ":Compatible clients are available at %s",
735 feature_str(FEAT_URL_CLIENTS
));
737 return exit_client_msg(cptr
, cptr
, &me
, "Registration Timeout");
741 /* Check for iauth timeout. */
742 if (FlagHas(&auth
->flags
, AR_IAUTH_PENDING
)) {
743 sendto_iauth(cptr
, "T");
744 if (IAuthHas(iauth
, IAUTH_REQUIRED
)) {
745 sendheader(cptr
, REPORT_FAIL_IAUTH
);
746 return exit_client_msg(cptr
, cptr
, &me
, "Authorization Timeout");
748 FlagClr(&auth
->flags
, AR_IAUTH_PENDING
);
749 return check_auth_finished(auth
);
752 assert(0 && "Unexpectedly reached end of auth_ping_timeout()");
756 /** Timeout a given auth request.
757 * @param[in] ev A timer event whose associated data is the expired
758 * struct AuthRequest.
760 static void auth_timeout_callback(struct Event
* ev
)
762 struct AuthRequest
* auth
;
764 assert(0 != ev_timer(ev
));
765 assert(0 != t_data(ev_timer(ev
)));
767 auth
= (struct AuthRequest
*) t_data(ev_timer(ev
));
769 if (ev_type(ev
) == ET_EXPIRE
) {
770 /* Report the timeout in the log. */
771 log_write(LS_RESOLVER
, L_INFO
, 0, "Registration timeout %s",
772 get_client_name(auth
->client
, HIDE_IP
));
774 /* Notify client if ident lookup failed. */
775 if (FlagHas(&auth
->flags
, AR_AUTH_PENDING
)) {
776 FlagClr(&auth
->flags
, AR_AUTH_PENDING
);
777 if (IsUserPort(auth
->client
))
778 sendheader(auth
->client
, REPORT_FAIL_ID
);
781 /* Likewise if dns lookup failed. */
782 if (FlagHas(&auth
->flags
, AR_DNS_PENDING
)) {
783 FlagClr(&auth
->flags
, AR_DNS_PENDING
);
784 delete_resolver_queries(auth
);
785 if (IsUserPort(auth
->client
))
786 sendheader(auth
->client
, REPORT_FAIL_DNS
);
789 /* Try to register the client. */
790 check_auth_finished(auth
);
794 /** Handle a complete DNS lookup. Send the client on it's way to a
795 * connection completion, regardless of success or failure -- unless
796 * there was a mismatch and KILL_IPMISMATCH is set.
797 * @param[in] vptr The pending struct AuthRequest.
798 * @param[in] addr IP address being resolved.
799 * @param[in] h_name Resolved name, or NULL if lookup failed.
801 static void auth_dns_callback(void* vptr
, const struct irc_in_addr
*addr
, const char *h_name
)
803 struct AuthRequest
* auth
= (struct AuthRequest
*) vptr
;
806 FlagClr(&auth
->flags
, AR_DNS_PENDING
);
808 /* DNS entry was missing for the IP. */
809 if (IsUserPort(auth
->client
))
810 sendheader(auth
->client
, REPORT_FAIL_DNS
);
811 sendto_iauth(auth
->client
, "d");
812 } else if (!irc_in_addr_valid(addr
)
813 || (irc_in_addr_cmp(&cli_ip(auth
->client
), addr
)
814 && irc_in_addr_cmp(&auth
->original
, addr
))) {
815 /* IP for hostname did not match client's IP. */
816 sendto_opmask_butone(0, SNO_IPMISMATCH
, "IP# Mismatch: %s != %s[%s]",
817 cli_sock_ip(auth
->client
), h_name
,
819 if (IsUserPort(auth
->client
))
820 sendheader(auth
->client
, REPORT_IP_MISMATCH
);
821 if (feature_bool(FEAT_KILL_IPMISMATCH
)) {
822 exit_client(auth
->client
, auth
->client
, &me
, "IP mismatch");
825 } else if (!auth_verify_hostname(h_name
, HOSTLEN
)) {
826 /* Hostname did not look valid. */
827 if (IsUserPort(auth
->client
))
828 sendheader(auth
->client
, REPORT_INVAL_DNS
);
829 sendto_iauth(auth
->client
, "d");
831 /* Hostname and mappings checked out. */
832 if (IsUserPort(auth
->client
))
833 sendheader(auth
->client
, REPORT_FIN_DNS
);
834 ircd_strncpy(cli_sockhost(auth
->client
), h_name
, HOSTLEN
);
835 sendto_iauth(auth
->client
, "N %s", h_name
);
837 check_auth_finished(auth
);
840 /** Flag the client to show an attempt to contact the ident server on
841 * the client's host. Should the connect or any later phase of the
842 * identifying process fail, it is aborted and the user is given a
843 * username of "unknown".
844 * @param[in] auth The request for which to start the ident lookup.
846 static void start_auth_query(struct AuthRequest
* auth
)
848 struct irc_sockaddr remote_addr
;
849 struct irc_sockaddr local_addr
;
854 assert(0 != auth
->client
);
857 * get the local address of the client and bind to that to
858 * make the auth request. This used to be done only for
859 * ifdef VIRTUAL_HOST, but needs to be done for all clients
860 * since the ident request must originate from that same address--
861 * and machines with multiple IP addresses are common now
863 memcpy(&local_addr
, &auth
->local
, sizeof(local_addr
));
865 memcpy(&remote_addr
.addr
, &cli_ip(auth
->client
), sizeof(remote_addr
.addr
));
866 remote_addr
.port
= 113;
867 fd
= os_socket(&local_addr
, SOCK_STREAM
, "auth query", 0);
869 ++ServerStats
->is_abad
;
870 if (IsUserPort(auth
->client
))
871 sendheader(auth
->client
, REPORT_FAIL_ID
);
874 if (IsUserPort(auth
->client
))
875 sendheader(auth
->client
, REPORT_DO_ID
);
877 if ((result
= os_connect_nonb(fd
, &remote_addr
)) == IO_FAILURE
||
878 !socket_add(&auth
->socket
, auth_sock_callback
, (void*) auth
,
879 result
== IO_SUCCESS
? SS_CONNECTED
: SS_CONNECTING
,
880 SOCK_EVENT_READABLE
, fd
)) {
881 ++ServerStats
->is_abad
;
882 if (IsUserPort(auth
->client
))
883 sendheader(auth
->client
, REPORT_FAIL_ID
);
888 FlagSet(&auth
->flags
, AR_AUTH_PENDING
);
889 if (result
== IO_SUCCESS
)
890 send_auth_query(auth
);
893 /** Initiate DNS lookup for a client.
894 * @param[in] auth The auth request for which to start the DNS lookup.
896 static void start_dns_query(struct AuthRequest
*auth
)
898 if (feature_bool(FEAT_NODNS
)) {
899 sendto_iauth(auth
->client
, "d");
903 if (irc_in_addr_is_loopback(&cli_ip(auth
->client
))) {
904 strcpy(cli_sockhost(auth
->client
), cli_name(&me
));
905 sendto_iauth(auth
->client
, "N %s", cli_sockhost(auth
->client
));
909 if (IsUserPort(auth
->client
))
910 sendheader(auth
->client
, REPORT_DO_DNS
);
912 FlagSet(&auth
->flags
, AR_DNS_PENDING
);
913 gethost_byaddr(&cli_ip(auth
->client
), auth_dns_callback
, auth
);
916 /** Initiate IAuth check for a client.
917 * @param[in] auth The auth request for which to star the IAuth check.
919 static void start_iauth_query(struct AuthRequest
*auth
)
921 FlagSet(&auth
->flags
, AR_IAUTH_PENDING
);
922 if (!sendto_iauth(auth
->client
, "C %s %hu %s %hu",
923 cli_sock_ip(auth
->client
), auth
->port
,
924 ircd_ntoa(&auth
->local
.addr
), auth
->local
.port
))
925 FlagClr(&auth
->flags
, AR_IAUTH_PENDING
);
928 /** Starts auth (identd) and dns queries for a client.
929 * @param[in] client The client for which to start queries.
931 void start_auth(struct Client
* client
)
933 struct irc_sockaddr remote
;
934 struct AuthRequest
* auth
;
937 Debug((DEBUG_INFO
, "Beginning auth request on client %p", client
));
939 /* Register with event handlers. */
940 cli_lasttime(client
) = CurrentTime
;
941 cli_since(client
) = CurrentTime
;
942 if (cli_fd(client
) > HighestFd
)
943 HighestFd
= cli_fd(client
);
944 LocalClientArray
[cli_fd(client
)] = client
;
945 socket_events(&(cli_socket(client
)), SOCK_ACTION_SET
| SOCK_EVENT_READABLE
);
947 /* Allocate the AuthRequest. */
948 auth
= auth_freelist
;
950 auth_freelist
= auth
->next
;
952 auth
= MyMalloc(sizeof(*auth
));
954 memset(auth
, 0, sizeof(*auth
));
955 auth
->client
= client
;
956 cli_auth(client
) = auth
;
957 s_fd(&auth
->socket
) = -1;
958 timer_add(timer_init(&auth
->timeout
), auth_timeout_callback
, (void*) auth
,
959 TT_RELATIVE
, feature_int(FEAT_AUTH_TIMEOUT
));
961 /* Try to get socket endpoint addresses. */
962 if (!os_get_sockname(cli_fd(client
), &auth
->local
)
963 || !os_get_peername(cli_fd(client
), &remote
)) {
964 ++ServerStats
->is_abad
;
965 if (IsUserPort(auth
->client
))
966 sendheader(auth
->client
, REPORT_FAIL_ID
);
967 exit_client(auth
->client
, auth
->client
, &me
, "Socket local/peer lookup failed");
970 auth
->port
= remote
.port
;
972 /* Try to start DNS lookup. */
973 start_dns_query(auth
);
975 /* Try to start ident lookup. */
976 start_auth_query(auth
);
978 /* Set required client inputs for users. */
979 if (IsUserPort(client
)) {
980 cli_user(client
) = make_user(client
);
981 cli_user(client
)->server
= &me
;
982 FlagSet(&auth
->flags
, AR_NEEDS_USER
);
983 FlagSet(&auth
->flags
, AR_NEEDS_NICK
);
985 /* Try to start iauth lookup. */
986 start_iauth_query(auth
);
989 /* Add client to GlobalClientList. */
990 add_client_to_list(client
);
992 /* Check which auth events remain pending. */
993 check_auth_finished(auth
);
996 /** Mark that a user has PONGed while unregistered.
997 * @param[in] auth Authorization request for client.
998 * @param[in] cookie PONG cookie value sent by client.
999 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1001 int auth_set_pong(struct AuthRequest
*auth
, unsigned int cookie
)
1003 assert(auth
!= NULL
);
1004 if (!FlagHas(&auth
->flags
, AR_NEEDS_PONG
))
1006 if (cookie
!= auth
->cookie
)
1008 send_reply(auth
->client
, SND_EXPLICIT
| ERR_BADPING
,
1009 ":To connect, type /QUOTE PONG %u", auth
->cookie
);
1012 cli_lasttime(auth
->client
) = CurrentTime
;
1013 FlagClr(&auth
->flags
, AR_NEEDS_PONG
);
1014 return check_auth_finished(auth
);
1017 /** Record a user's claimed username and userinfo.
1018 * @param[in] auth Authorization request for client.
1019 * @param[in] username Client's asserted username.
1020 * @param[in] hostname Third argument of USER command (client's
1021 * hostname, per RFC 1459).
1022 * @param[in] servername Fourth argument of USER command (server's
1023 * name, per RFC 1459).
1024 * @param[in] userinfo Client's asserted self-description.
1025 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1027 int auth_set_user(struct AuthRequest
*auth
, const char *username
, const char *hostname
, const char *servername
, const char *userinfo
)
1029 struct Client
*cptr
;
1031 assert(auth
!= NULL
);
1032 if (FlagHas(&auth
->flags
, AR_IAUTH_HURRY
))
1034 FlagClr(&auth
->flags
, AR_NEEDS_USER
);
1035 cptr
= auth
->client
;
1036 ircd_strncpy(cli_info(cptr
), userinfo
, REALLEN
);
1037 ircd_strncpy(cli_user(cptr
)->username
, username
, USERLEN
);
1038 ircd_strncpy(cli_user(cptr
)->host
, cli_sockhost(cptr
), HOSTLEN
);
1039 if (IAuthHas(iauth
, IAUTH_UNDERNET
))
1040 sendto_iauth(cptr
, "U %s %s %s :%s", username
, hostname
, servername
, userinfo
);
1041 else if (IAuthHas(iauth
, IAUTH_ADDLINFO
))
1042 sendto_iauth(cptr
, "U %s", username
);
1043 return check_auth_finished(auth
);
1046 /** Handle authorization-related aspects of initial nickname selection.
1047 * This is called after verifying that the nickname is available.
1048 * @param[in] auth Authorization request for client.
1049 * @param[in] nickname Client's requested nickname.
1050 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1052 int auth_set_nick(struct AuthRequest
*auth
, const char *nickname
)
1054 assert(auth
!= NULL
);
1055 FlagClr(&auth
->flags
, AR_NEEDS_NICK
);
1057 * If the client hasn't gotten a cookie-ping yet,
1058 * choose a cookie and send it. -record!jegelhof@cloud9.net
1060 if (!auth
->cookie
) {
1062 auth
->cookie
= ircrandom();
1063 } while (!auth
->cookie
);
1064 sendrawto_one(auth
->client
, "PING :%u", auth
->cookie
);
1065 FlagSet(&auth
->flags
, AR_NEEDS_PONG
);
1067 if (IAuthHas(iauth
, IAUTH_UNDERNET
))
1068 sendto_iauth(auth
->client
, "n %s", nickname
);
1069 return check_auth_finished(auth
);
1072 /** Record a user's password.
1073 * @param[in] auth Authorization request for client.
1074 * @param[in] password Client's password.
1075 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1077 int auth_set_password(struct AuthRequest
*auth
, const char *password
)
1079 assert(auth
!= NULL
);
1080 if (IAuthHas(iauth
, IAUTH_ADDLINFO
))
1081 sendto_iauth(auth
->client
, "P :%s", password
);
1085 /** Send exit notification for \a cptr to iauth.
1086 * @param[in] cptr Client who is exiting.
1088 void auth_send_exit(struct Client
*cptr
)
1090 sendto_iauth(cptr
, "D");
1093 /** Mark that a user has started capabilities negotiation.
1094 * This blocks authorization until auth_cap_done() is called.
1095 * @param[in] auth Authorization request for client.
1096 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1098 int auth_cap_start(struct AuthRequest
*auth
)
1100 assert(auth
!= NULL
);
1101 FlagSet(&auth
->flags
, AR_CAP_PENDING
);
1105 /** Mark that a user has completed capabilities negotiation.
1106 * This unblocks authorization if auth_cap_start() was called.
1107 * @param[in] auth Authorization request for client.
1108 * @return Zero if client should be kept, CPTR_KILLED if rejected.
1110 int auth_cap_done(struct AuthRequest
*auth
)
1112 assert(auth
!= NULL
);
1113 FlagClr(&auth
->flags
, AR_CAP_PENDING
);
1114 return check_auth_finished(auth
);
1117 /** Attempt to spawn the process for an IAuth instance.
1118 * @param[in] iauth IAuth descriptor.
1119 * @param[in] automatic If non-zero, apply sanity checks against
1120 * excessive automatic restarts.
1121 * @return 0 on success, non-zero on failure.
1123 int iauth_do_spawn(struct IAuth
*iauth
, int automatic
)
1130 if (automatic
&& CurrentTime
- iauth
->started
< 5)
1132 sendto_opmask_butone(NULL
, SNO_AUTH
, "IAuth crashed fast, leaving it dead.");
1136 /* Record time we tried to spawn the iauth process. */
1137 iauth
->started
= CurrentTime
;
1139 /* Attempt to allocate a pair of sockets. */
1140 res
= os_socketpair(s_io
);
1144 /* Mark the parent's side of the pair (element 0) as non-blocking. */
1145 res
= os_set_nonblocking(s_io
[0]);
1153 /* Initialize the socket structure to talk to the child. */
1154 res
= socket_add(i_socket(iauth
), iauth_sock_callback
, iauth
,
1155 SS_CONNECTED
, SOCK_EVENT_READABLE
, s_io
[0]);
1163 /* Allocate another pair for stderr. */
1164 res
= os_socketpair(s_err
);
1167 socket_del(i_socket(iauth
));
1173 /* Mark parent side of this pair non-blocking, too. */
1174 res
= os_set_nonblocking(s_err
[0]);
1179 socket_del(i_socket(iauth
));
1185 /* And set up i_stderr(iauth). */
1186 res
= socket_add(i_stderr(iauth
), iauth_stderr_callback
, iauth
,
1187 SS_CONNECTED
, SOCK_EVENT_READABLE
, s_err
[0]);
1192 socket_del(i_socket(iauth
));
1198 /* Attempt to fork a child process. */
1201 /* Error forking the child, still in parent. */
1203 socket_del(i_stderr(iauth
));
1206 socket_del(i_socket(iauth
));
1213 /* We are the parent process. Close the child's sockets. */
1216 /* Send our server name (supposedly for proxy checking purposes)
1217 * and maximum number of connections (for allocation hints).
1218 * Need to use conf_get_local() since &me may not be fully
1219 * initialized the first time we run.
1221 sendto_iauth(NULL
, "M %s %d", conf_get_local()->name
, MAXCONNECTIONS
);
1222 /* Indicate success (until the child dies). */
1226 /* We are the child process.
1227 * Duplicate our end of the socket to stdin, stdout and stderr.
1228 * Then close all the higher-numbered FDs and exec the process.
1230 if (dup2(s_io
[1], 0) == 0
1231 && dup2(s_io
[1], 1) == 1
1232 && dup2(s_err
[1], 2) == 2) {
1233 close_connections(0);
1234 execvp(iauth
->i_argv
[0], iauth
->i_argv
);
1237 /* If we got here, something was seriously wrong. */
1241 /** See if an %IAuth program must be spawned.
1242 * If a process is already running with the specified options, keep it.
1243 * Otherwise spawn a new child process to perform the %IAuth function.
1244 * @param[in] argc Number of parameters to use when starting process.
1245 * @param[in] argv Array of parameters to start process.
1246 * @return 0 on failure, 1 on new process, 2 on reuse of existing process.
1248 int auth_spawn(int argc
, char *argv
[])
1255 /* Check that incoming arguments all match pre-existing arguments. */
1256 for (ii
= 0; same
&& (ii
< argc
); ++ii
) {
1257 if (NULL
== iauth
->i_argv
[ii
]
1258 || 0 != strcmp(iauth
->i_argv
[ii
], argv
[ii
]))
1261 /* Check that we have no more pre-existing arguments. */
1262 if (iauth
->i_argv
[ii
])
1264 /* If they are the same and still connected, clear the "closing" flag and exit.*/
1265 if (same
&& i_GetConnected(iauth
)) {
1266 IAuthClr(iauth
, IAUTH_CLOSING
);
1269 /* Deallocate old argv elements. */
1270 for (ii
= 0; iauth
->i_argv
[ii
]; ++ii
)
1271 MyFree(iauth
->i_argv
[ii
]);
1272 MyFree(iauth
->i_argv
);
1275 /* Need to initialize a new connection. */
1276 iauth
= MyCalloc(1, sizeof(*iauth
));
1277 msgq_init(i_sendQ(iauth
));
1278 /* Populate iauth's argv array. */
1279 iauth
->i_argv
= MyCalloc(argc
+ 1, sizeof(iauth
->i_argv
[0]));
1280 for (ii
= 0; ii
< argc
; ++ii
)
1281 DupString(iauth
->i_argv
[ii
], argv
[ii
]);
1282 iauth
->i_argv
[ii
] = NULL
;
1283 /* Try to spawn it, and handle the results. */
1284 if (iauth_do_spawn(iauth
, 0))
1286 IAuthClr(iauth
, IAUTH_CLOSING
);
1290 /** Mark all %IAuth connections as closing. */
1291 void auth_mark_closing(void)
1294 IAuthSet(iauth
, IAUTH_CLOSING
);
1297 /** Complete disconnection of an %IAuth connection.
1298 * @param[in] iauth %Connection to fully close.
1300 static void iauth_disconnect(struct IAuth
*iauth
)
1302 if (!i_GetConnected(iauth
))
1305 /* Close main socket. */
1306 close(s_fd(i_socket(iauth
)));
1307 socket_del(i_socket(iauth
));
1308 s_fd(i_socket(iauth
)) = -1;
1310 /* Close error socket. */
1311 close(s_fd(i_stderr(iauth
)));
1312 socket_del(i_stderr(iauth
));
1313 s_fd(i_stderr(iauth
)) = -1;
1316 /** Close all %IAuth connections marked as closing. */
1317 void auth_close_unused(void)
1319 if (IAuthHas(iauth
, IAUTH_CLOSING
)) {
1321 iauth_disconnect(iauth
);
1322 if (iauth
->i_argv
) {
1323 for (ii
= 0; iauth
->i_argv
[ii
]; ++ii
)
1324 MyFree(iauth
->i_argv
[ii
]);
1325 MyFree(iauth
->i_argv
);
1331 /** Send queued output to \a iauth.
1332 * @param[in] iauth Writable connection with queued data.
1334 static void iauth_write(struct IAuth
*iauth
)
1336 unsigned int bytes_tried
, bytes_sent
;
1339 if (IAuthHas(iauth
, IAUTH_BLOCKED
))
1341 while (MsgQLength(i_sendQ(iauth
)) > 0) {
1342 iores
= os_sendv_nonb(s_fd(i_socket(iauth
)), i_sendQ(iauth
), &bytes_tried
, &bytes_sent
);
1345 msgq_delete(i_sendQ(iauth
), bytes_sent
);
1346 iauth
->i_sendB
+= bytes_sent
;
1347 if (bytes_tried
== bytes_sent
)
1349 /* If bytes_sent < bytes_tried, fall through to IO_BLOCKED. */
1351 IAuthSet(iauth
, IAUTH_BLOCKED
);
1352 socket_events(i_socket(iauth
), SOCK_ACTION_ADD
| SOCK_EVENT_WRITABLE
);
1355 iauth_disconnect(iauth
);
1359 /* We were able to flush all events, so remove notification. */
1360 socket_events(i_socket(iauth
), SOCK_ACTION_DEL
| SOCK_EVENT_WRITABLE
);
1363 /** Send a message to iauth.
1364 * @param[in] cptr Optional client context for message.
1365 * @param[in] format Format string for message.
1366 * @return Non-zero on successful send or buffering, zero on failure.
1368 static int sendto_iauth(struct Client
*cptr
, const char *format
, ...)
1373 /* Do not send requests when we have no iauth. */
1374 if (!i_GetConnected(iauth
))
1376 /* Do not send for clients in the NORMAL state. */
1378 && (format
[0] != 'D')
1379 && (!cli_auth(cptr
) || !FlagHas(&cli_auth(cptr
)->flags
, AR_IAUTH_PENDING
)))
1382 /* Build the message buffer. */
1383 vd
.vd_format
= format
;
1384 va_start(vd
.vd_args
, format
);
1386 mb
= msgq_make(NULL
, "-1 %v", &vd
);
1388 mb
= msgq_make(NULL
, "%d %v", cli_fd(cptr
), &vd
);
1391 /* Tack it onto the iauth sendq and try to write it. */
1393 msgq_add(i_sendQ(iauth
), mb
, 0);
1399 /** Send text to interested operators (SNO_AUTH server notice).
1400 * @param[in] iauth Active IAuth session.
1401 * @param[in] cli Client referenced by command.
1402 * @param[in] parc Number of parameters (1).
1403 * @param[in] params Text to send.
1406 static int iauth_cmd_snotice(struct IAuth
*iauth
, struct Client
*cli
,
1407 int parc
, char **params
)
1409 sendto_opmask_butone(NULL
, SNO_AUTH
, "%s", params
[0]);
1413 /** Set the debug level for the session.
1414 * @param[in] iauth Active IAuth session.
1415 * @param[in] cli Client referenced by command.
1416 * @param[in] parc Number of parameters (1).
1417 * @param[in] params String starting with an integer.
1420 static int iauth_cmd_debuglevel(struct IAuth
*iauth
, struct Client
*cli
,
1421 int parc
, char **params
)
1425 new_level
= parc
> 0 ? atoi(params
[0]) : 0;
1426 if (i_debug(iauth
) > 0 || new_level
> 0) {
1427 /* The "ia_dbg" name is borrowed from (IRCnet) ircd. */
1428 sendto_opmask_butone(NULL
, SNO_AUTH
, "ia_dbg = %d", new_level
);
1430 i_debug(iauth
) = new_level
;
1434 /** Set policy options for the session.
1435 * Old policy is forgotten, and any of the following characters in \a
1436 * params enable the corresponding policy:
1437 * \li A IAUTH_ADDLINFO
1438 * \li R IAUTH_REQUIRED
1439 * \li T IAUTH_TIMEOUT
1440 * \li W IAUTH_EXTRAWAIT
1441 * \li U IAUTH_UNDERNET
1443 * @param[in] iauth Active IAuth session.
1444 * @param[in] cli Client referenced by command.
1445 * @param[in] parc Number of parameters (1).
1446 * @param[in] params Zero or more policy options.
1449 static int iauth_cmd_policy(struct IAuth
*iauth
, struct Client
*cli
,
1450 int parc
, char **params
)
1452 enum IAuthFlag flag
;
1455 /* Erase old policy first. */
1456 for (flag
= IAUTH_FIRST_OPTION
; flag
< IAUTH_LAST_FLAG
; ++flag
)
1457 IAuthClr(iauth
, flag
);
1459 if (parc
> 0) /* only try to parse if we were given a policy string */
1460 /* Parse new policy set. */
1461 for (p
= params
[0]; *p
; p
++) switch (*p
) {
1462 case 'A': IAuthSet(iauth
, IAUTH_ADDLINFO
); break;
1463 case 'R': IAuthSet(iauth
, IAUTH_REQUIRED
); break;
1464 case 'T': IAuthSet(iauth
, IAUTH_TIMEOUT
); break;
1465 case 'W': IAuthSet(iauth
, IAUTH_EXTRAWAIT
); break;
1466 case 'U': IAuthSet(iauth
, IAUTH_UNDERNET
); break;
1469 /* Optionally notify operators. */
1470 if (i_debug(iauth
) > 0)
1471 sendto_opmask_butone(NULL
, SNO_AUTH
, "iauth options: %s", params
[0]);
1475 /** Set the iauth program version number.
1476 * @param[in] iauth Active IAuth session.
1477 * @param[in] cli Client referenced by command.
1478 * @param[in] parc Number of parameters (1).
1479 * @param[in] params Version number or name.
1482 static int iauth_cmd_version(struct IAuth
*iauth
, struct Client
*cli
,
1483 int parc
, char **params
)
1485 MyFree(iauth
->i_version
);
1486 DupString(iauth
->i_version
, parc
> 0 ? params
[0] : "<NONE>");
1487 sendto_opmask_butone(NULL
, SNO_AUTH
, "iauth version %s running.",
1492 /** Paste a parameter list together into a single string.
1493 * @param[in] parc Number of parameters.
1494 * @param[in] params Parameter list to paste together.
1495 * @return Pasted parameter list.
1497 static char *paste_params(int parc
, char **params
)
1500 int len
= 0, lengths
[MAXPARA
], i
;
1502 /* Compute the length... */
1503 for (i
= 0; i
< parc
; i
++)
1504 len
+= lengths
[i
] = strlen(params
[i
]);
1506 /* Allocate memory, accounting for string lengths, spaces (parc - 1), a
1507 * sentinel, and the trailing \0
1509 str
= MyMalloc(len
+ parc
+ 1);
1511 /* Build the pasted string */
1512 for (tmp
= str
, i
= 0; i
< parc
; i
++) {
1513 if (i
) /* add space separator... */
1515 if (i
== parc
- 1) /* add colon sentinel */
1518 /* Copy string component... */
1519 memcpy(tmp
, params
[i
], lengths
[i
]);
1520 tmp
+= lengths
[i
]; /* move to end of string */
1523 /* terminate the string... */
1526 return str
; /* return the pasted string */
1529 /** Clear cached iauth configuration information.
1530 * @param[in] iauth Active IAuth session.
1531 * @param[in] cli Client referenced by command.
1532 * @param[in] parc Number of parameters (0).
1533 * @param[in] params Parameter list (ignored).
1536 static int iauth_cmd_newconfig(struct IAuth
*iauth
, struct Client
*cli
,
1537 int parc
, char **params
)
1542 head
= iauth
->i_config
;
1543 iauth
->i_config
= NULL
;
1544 for (; head
; head
= next
) {
1546 MyFree(head
->value
.cp
);
1549 sendto_opmask_butone(NULL
, SNO_AUTH
, "New iauth configuration.");
1553 /** Append iauth configuration information.
1554 * @param[in] iauth Active IAuth session.
1555 * @param[in] cli Client referenced by command.
1556 * @param[in] parc Number of parameters.
1557 * @param[in] params Description of configuration element.
1560 static int iauth_cmd_config(struct IAuth
*iauth
, struct Client
*cli
,
1561 int parc
, char **params
)
1565 if (iauth
->i_config
) {
1566 for (node
= iauth
->i_config
; node
->next
; node
= node
->next
) ;
1567 node
= node
->next
= make_link();
1569 node
= iauth
->i_config
= make_link();
1571 node
->value
.cp
= paste_params(parc
, params
);
1572 node
->next
= 0; /* must be explicitly cleared */
1576 /** Clear cached iauth configuration information.
1577 * @param[in] iauth Active IAuth session.
1578 * @param[in] cli Client referenced by command.
1579 * @param[in] parc Number of parameters (0).
1580 * @param[in] params Parameter list (ignored).
1583 static int iauth_cmd_newstats(struct IAuth
*iauth
, struct Client
*cli
,
1584 int parc
, char **params
)
1589 head
= iauth
->i_stats
;
1590 iauth
->i_stats
= NULL
;
1591 for (; head
; head
= next
) {
1593 MyFree(head
->value
.cp
);
1596 sendto_opmask_butone(NULL
, SNO_AUTH
, "New iauth statistics.");
1600 /** Append iauth statistics information.
1601 * @param[in] iauth Active IAuth session.
1602 * @param[in] cli Client referenced by command.
1603 * @param[in] parc Number of parameters.
1604 * @param[in] params Statistics element.
1607 static int iauth_cmd_stats(struct IAuth
*iauth
, struct Client
*cli
,
1608 int parc
, char **params
)
1611 if (iauth
->i_stats
) {
1612 for (node
= iauth
->i_stats
; node
->next
; node
= node
->next
) ;
1613 node
= node
->next
= make_link();
1615 node
= iauth
->i_stats
= make_link();
1617 node
->value
.cp
= paste_params(parc
, params
);
1618 node
->next
= 0; /* must be explicitly cleared */
1622 /** Set client's username to a trusted string even if it breaks the rules.
1623 * @param[in] iauth Active IAuth session.
1624 * @param[in] cli Client referenced by command.
1625 * @param[in] parc Number of parameters (1).
1626 * @param[in] params Forced username.
1629 static int iauth_cmd_username_forced(struct IAuth
*iauth
, struct Client
*cli
,
1630 int parc
, char **params
)
1632 assert(cli_auth(cli
) != NULL
);
1633 FlagClr(&cli_auth(cli
)->flags
, AR_AUTH_PENDING
);
1634 if (!EmptyString(params
[0])) {
1635 ircd_strncpy(cli_username(cli
), params
[0], USERLEN
);
1637 FlagSet(&cli_auth(cli
)->flags
, AR_IAUTH_USERNAME
);
1638 FlagSet(&cli_auth(cli
)->flags
, AR_IAUTH_FUSERNAME
);
1643 /** Set client's username to a trusted string.
1644 * @param[in] iauth Active IAuth session.
1645 * @param[in] cli Client referenced by command.
1646 * @param[in] parc Number of parameters (1).
1647 * @param[in] params Trusted username.
1650 static int iauth_cmd_username_good(struct IAuth
*iauth
, struct Client
*cli
,
1651 int parc
, char **params
)
1653 assert(cli_auth(cli
) != NULL
);
1654 FlagClr(&cli_auth(cli
)->flags
, AR_AUTH_PENDING
);
1655 if (!EmptyString(params
[0])) {
1656 ircd_strncpy(cli_username(cli
), params
[0], USERLEN
);
1658 FlagSet(&cli_auth(cli
)->flags
, AR_IAUTH_USERNAME
);
1663 /** Set client's username to an untrusted string.
1664 * @param[in] iauth Active IAuth session.
1665 * @param[in] cli Client referenced by command.
1666 * @param[in] parc Number of parameters (1).
1667 * @param[in] params Untrusted username.
1670 static int iauth_cmd_username_bad(struct IAuth
*iauth
, struct Client
*cli
,
1671 int parc
, char **params
)
1673 assert(cli_auth(cli
) != NULL
);
1674 FlagClr(&cli_auth(cli
)->flags
, AR_AUTH_PENDING
);
1675 if (!EmptyString(params
[0]))
1676 ircd_strncpy(cli_user(cli
)->username
, params
[0], USERLEN
);
1680 /** Set client's hostname.
1681 * @param[in] iauth Active IAuth session.
1682 * @param[in] cli Client referenced by command.
1683 * @param[in] parc Number of parameters (1).
1684 * @param[in] params New hostname for client.
1685 * @return Non-zero if \a cli authorization should be checked for completion.
1687 static int iauth_cmd_hostname(struct IAuth
*iauth
, struct Client
*cli
,
1688 int parc
, char **params
)
1690 struct AuthRequest
*auth
;
1692 if (EmptyString(params
[0])) {
1693 sendto_iauth(cli
, "E Missing :Missing hostname parameter");
1697 auth
= cli_auth(cli
);
1698 assert(auth
!= NULL
);
1700 /* If a DNS request is pending, abort it. */
1701 if (FlagHas(&auth
->flags
, AR_DNS_PENDING
)) {
1702 FlagClr(&auth
->flags
, AR_DNS_PENDING
);
1703 delete_resolver_queries(auth
);
1704 if (IsUserPort(cli
))
1705 sendheader(cli
, REPORT_FIN_DNS
);
1707 /* Set hostname from params. */
1708 ircd_strncpy(cli_sockhost(cli
), params
[0], HOSTLEN
);
1712 /** Set client's IP address.
1713 * @param[in] iauth Active IAuth session.
1714 * @param[in] cli Client referenced by command.
1715 * @param[in] parc Number of parameters (1).
1716 * @param[in] params New IP address for client in dotted quad or
1717 * standard IPv6 format.
1720 static int iauth_cmd_ip_address(struct IAuth
*iauth
, struct Client
*cli
,
1721 int parc
, char **params
)
1723 struct irc_in_addr addr
;
1724 struct AuthRequest
*auth
;
1726 if (EmptyString(params
[0])) {
1727 sendto_iauth(cli
, "E Missing :Missing IP address parameter");
1731 /* Get AuthRequest for client. */
1732 auth
= cli_auth(cli
);
1733 assert(auth
!= NULL
);
1735 /* Parse the client's new IP address. */
1736 if (!ircd_aton(&addr
, params
[0])) {
1737 sendto_iauth(cli
, "E Invalid :Unable to parse IP address [%s]", params
[0]);
1741 /* If this is the first IP override, save the client's original
1742 * address in case we get a DNS response later.
1744 if (!irc_in_addr_valid(&auth
->original
))
1745 memcpy(&auth
->original
, &cli_ip(cli
), sizeof(auth
->original
));
1747 /* Undo original IP connection in IPcheck. */
1748 IPcheck_connect_fail(cli
);
1749 ClearIPChecked(cli
);
1751 /* Update the IP and charge them as a remote connect. */
1752 memcpy(&cli_ip(cli
), &addr
, sizeof(cli_ip(cli
)));
1753 IPcheck_remote_connect(cli
, 0);
1758 /** Find a ConfItem structure for a named connection class.
1759 * @param[in] class_name Name of configuration class to find.
1760 * @return A ConfItem of type CONF_CLIENT for the class, or NULL on failure.
1762 static struct ConfItem
*auth_find_class_conf(const char *class_name
)
1764 static struct ConfItem
*aconf_list
;
1765 struct ConnectionClass
*class;
1766 struct ConfItem
*aconf
;
1768 /* Make sure the configuration class is valid. */
1769 class = find_class(class_name
);
1773 /* Look for an existing ConfItem for the class. */
1774 for (aconf
= aconf_list
; aconf
; aconf
= aconf
->next
)
1775 if (aconf
->conn_class
== class)
1778 /* If no ConfItem, create one. */
1780 aconf
= make_conf(CONF_CLIENT
);
1782 sendto_opmask_butone(NULL
, SNO_AUTH
,
1783 "Unable to allocate ConfItem for class %s!",
1787 aconf
->conn_class
= class;
1788 aconf
->next
= aconf_list
;
1795 /** Accept a client in IAuth.
1796 * @param[in] iauth Active IAuth session.
1797 * @param[in] cli Client referenced by command.
1798 * @param[in] parc Number of parameters.
1799 * @param[in] params Optional class name for client.
1802 static int iauth_cmd_done_client(struct IAuth
*iauth
, struct Client
*cli
,
1803 int parc
, char **params
)
1805 static time_t warn_time
;
1807 /* Clear iauth pending flag. */
1808 assert(cli_auth(cli
) != NULL
);
1809 FlagClr(&cli_auth(cli
)->flags
, AR_IAUTH_PENDING
);
1811 /* If a connection class was specified (and usable), assign the client to it. */
1812 if (!EmptyString(params
[0])) {
1813 struct ConfItem
*aconf
;
1815 aconf
= auth_find_class_conf(params
[0]);
1817 attach_conf(cli
, aconf
);
1819 sendto_opmask_butone_ratelimited(NULL
, SNO_AUTH
, &warn_time
,
1820 "iauth tried to use undefined class [%s]",
1827 /** Accept a client in IAuth and assign them to an account.
1828 * @param[in] iauth Active IAuth session.
1829 * @param[in] cli Client referenced by command.
1830 * @param[in] parc Number of parameters.
1831 * @param[in] params Account name and optional class name for client.
1832 * @return Non-zero if \a cli authorization should be checked for completion.
1834 static int iauth_cmd_done_account(struct IAuth
*iauth
, struct Client
*cli
,
1835 int parc
, char **params
)
1840 if (EmptyString(params
[0])) {
1841 sendto_iauth(cli
, "E Missing :Missing account parameter");
1844 /* Check length of account name. */
1845 len
= strcspn(params
[0], ": ");
1846 if (len
> ACCOUNTLEN
) {
1847 sendto_iauth(cli
, "E Invalid :Account parameter too long");
1850 /* If account has a creation timestamp, use it. */
1851 assert(cli_user(cli
) != NULL
);
1852 if (params
[0][len
] == ':') {
1854 cli_user(cli
)->acc_create
= strtoul(params
[0] + len
+ 1, &end
, 10);
1856 cli_user(cli
)->acc_id
= strtoul(end
+ 1, NULL
, 10);
1859 /* Copy account name to User structure. */
1860 ircd_strncpy(cli_user(cli
)->account
, params
[0], ACCOUNTLEN
);
1863 /* Fall through to the normal "done" handler. */
1864 return iauth_cmd_done_client(iauth
, cli
, parc
- 1, params
+ 1);
1867 /** Reject a client's connection.
1868 * @param[in] iauth Active IAuth session.
1869 * @param[in] cli Client referenced by command.
1870 * @param[in] parc Number of parameters (1).
1871 * @param[in] params Optional kill message.
1874 static int iauth_cmd_kill(struct IAuth
*iauth
, struct Client
*cli
,
1875 int parc
, char **params
)
1878 FlagClr(&cli_auth(cli
)->flags
, AR_IAUTH_PENDING
);
1879 if (EmptyString(params
[0]))
1880 params
[0] = "Access denied";
1881 exit_client(cli
, cli
, &me
, params
[0]);
1885 /** Change a client's usermode.
1886 * @param[in] iauth Active IAuth session.
1887 * @param[in] cli Client referenced by command.
1888 * @param[in] parc Number of parameters (at least one).
1889 * @param[in] params Usermode arguments for client (with the first
1890 * starting with '+').
1893 static int iauth_cmd_usermode(struct IAuth
*iauth
, struct Client
*cli
,
1894 int parc
, char **params
)
1896 if (params
[0][0] == '+')
1898 set_user_mode(cli
, cli
, parc
+ 2, params
- 2, ALLOWMODES_ANY
);
1904 /** Send a challenge string to the client.
1905 * @param[in] iauth Active IAuth session.
1906 * @param[in] cli Client referenced by command.
1907 * @param[in] parc Number of parameters (1).
1908 * @param[in] params Challenge message for client.
1911 static int iauth_cmd_challenge(struct IAuth
*iauth
, struct Client
*cli
,
1912 int parc
, char **params
)
1914 if (!EmptyString(params
[0]))
1915 sendrawto_one(cli
, "NOTICE AUTH :*** %s", params
[0]);
1919 /** Parse a \a message from \a iauth.
1920 * @param[in] iauth Active IAuth session.
1921 * @param[in] message Message to be parsed.
1923 static void iauth_parse(struct IAuth
*iauth
, char *message
)
1925 char *params
[MAXPARA
+ 1]; /* leave space for NULL */
1927 iauth_cmd_handler handler
;
1928 struct AuthRequest
*auth
;
1933 /* Find command handler... */
1934 switch (*(message
++)) {
1935 case '>': handler
= iauth_cmd_snotice
; has_cli
= 0; break;
1936 case 'G': handler
= iauth_cmd_debuglevel
; has_cli
= 0; break;
1937 case 'O': handler
= iauth_cmd_policy
; has_cli
= 0; break;
1938 case 'V': handler
= iauth_cmd_version
; has_cli
= 0; break;
1939 case 'a': handler
= iauth_cmd_newconfig
; has_cli
= 0; break;
1940 case 'A': handler
= iauth_cmd_config
; has_cli
= 0; break;
1941 case 's': handler
= iauth_cmd_newstats
; has_cli
= 0; break;
1942 case 'S': handler
= iauth_cmd_stats
; has_cli
= 0; break;
1943 case 'o': handler
= iauth_cmd_username_forced
; has_cli
= 1; break;
1944 case 'U': handler
= iauth_cmd_username_good
; has_cli
= 1; break;
1945 case 'u': handler
= iauth_cmd_username_bad
; has_cli
= 1; break;
1946 case 'N': handler
= iauth_cmd_hostname
; has_cli
= 1; break;
1947 case 'I': handler
= iauth_cmd_ip_address
; has_cli
= 1; break;
1948 case 'M': handler
= iauth_cmd_usermode
; has_cli
= 1; break;
1949 case 'C': handler
= iauth_cmd_challenge
; has_cli
= 1; break;
1950 case 'D': handler
= iauth_cmd_done_client
; has_cli
= 1; break;
1951 case 'R': handler
= iauth_cmd_done_account
; has_cli
= 1; break;
1952 case 'k': /* The 'k' command indicates the user should be booted
1953 * off without telling opers. There is no way to
1954 * signal that to exit_client(), so we fall through to
1955 * the case that we do implement.
1957 case 'K': handler
= iauth_cmd_kill
; has_cli
= 2; break;
1958 case 'r': /* we handle termination directly */ return;
1959 default: sendto_iauth(NULL
, "E Garbage :[%s]", message
); return;
1962 while (parc
< MAXPARA
) {
1963 while (IsSpace(*message
)) /* skip leading whitespace */
1966 if (!*message
) /* hit the end of the string, break out */
1969 if (*message
== ':') { /* found sentinel... */
1970 params
[parc
++] = message
+ 1;
1971 break; /* it's the last parameter anyway */
1974 params
[parc
++] = message
; /* save the parameter */
1975 while (*message
&& !IsSpace(*message
))
1976 message
++; /* find the end of the parameter */
1978 if (*message
) /* terminate the parameter */
1979 *(message
++) = '\0';
1982 params
[parc
] = NULL
; /* terminate the parameter list */
1984 /* Check to see if the command specifies a client... */
1986 /* Handler does not need a client. */
1987 handler(iauth
, NULL
, parc
, params
);
1989 /* Try to find the client associated with the request. */
1990 id
= strtol(params
[0], NULL
, 10);
1992 sendto_iauth(NULL
, "E Missing :Need <id> <ip> <port>");
1993 else if (id
< 0 || id
> HighestFd
|| !(cli
= LocalClientArray
[id
]))
1994 /* Client no longer exists (or never existed). */
1995 sendto_iauth(NULL
, "E Gone :[%s %s %s]", params
[0], params
[1],
1997 else if ((!(auth
= cli_auth(cli
)) ||
1998 !FlagHas(&auth
->flags
, AR_IAUTH_PENDING
)) &&
2000 /* Client is done with IAuth checks. */
2001 sendto_iauth(cli
, "E Done :[%s %s %s]", params
[0], params
[1], params
[2]);
2003 struct irc_sockaddr addr
;
2006 /* Parse IP address and port number from parameters */
2007 res
= ipmask_parse(params
[1], &addr
.addr
, NULL
);
2008 addr
.port
= strtol(params
[2], NULL
, 10);
2010 /* Check IP address and port number against expected. */
2012 irc_in_addr_cmp(&addr
.addr
, &cli_ip(cli
)) ||
2013 (auth
&& addr
.port
!= auth
->port
))
2014 /* Report mismatch to iauth. */
2015 sendto_iauth(cli
, "E Mismatch :[%s] != [%s]", params
[1],
2016 ircd_ntoa(&cli_ip(cli
)));
2017 else if (handler(iauth
, cli
, parc
- 3, params
+ 3))
2018 /* Handler indicated a possible state change. */
2019 check_auth_finished(auth
);
2024 /** Read input from \a iauth.
2025 * Reads up to SERVER_TCP_WINDOW bytes per pass.
2026 * @param[in] iauth Readable connection.
2028 static void iauth_read(struct IAuth
*iauth
)
2030 static char readbuf
[SERVER_TCP_WINDOW
];
2031 unsigned int length
, count
;
2035 /* Copy partial data to readbuf, append new data. */
2036 length
= iauth
->i_count
;
2037 memcpy(readbuf
, iauth
->i_buffer
, length
);
2038 if (IO_SUCCESS
!= os_recv_nonb(s_fd(i_socket(iauth
)),
2040 sizeof(readbuf
) - length
- 1,
2043 readbuf
[length
+= count
] = '\0';
2045 /* Parse each complete line. */
2046 for (sol
= readbuf
; (eol
= strchr(sol
, '\n')) != NULL
; sol
= eol
+ 1) {
2048 if (*(eol
- 1) == '\r') /* take out carriage returns, too... */
2051 /* If spammy debug, send the message to opers. */
2052 if (i_debug(iauth
) > 1)
2053 sendto_opmask_butone(NULL
, SNO_AUTH
, "Parsing: \"%s\"", sol
);
2055 /* Parse the line... */
2056 iauth_parse(iauth
, sol
);
2059 /* Put unused data back into connection's buffer. */
2060 iauth
->i_count
= strlen(sol
);
2061 if (iauth
->i_count
> BUFSIZE
)
2062 iauth
->i_count
= BUFSIZE
;
2063 memcpy(iauth
->i_buffer
, sol
, iauth
->i_count
);
2066 /** Handle socket activity for an %IAuth connection.
2067 * @param[in] ev &Socket event; the IAuth connection is the user data
2068 * pointer for the socket.
2070 static void iauth_sock_callback(struct Event
*ev
)
2072 struct IAuth
*iauth
;
2074 assert(0 != ev_socket(ev
));
2075 iauth
= (struct IAuth
*) s_data(ev_socket(ev
));
2078 switch (ev_type(ev
)) {
2080 /* Hm, what happened here? */
2081 if (!IAuthHas(iauth
, IAUTH_CLOSING
))
2082 iauth_do_spawn(iauth
, 1);
2088 IAuthClr(iauth
, IAUTH_BLOCKED
);
2092 log_write(LS_IAUTH
, L_ERROR
, 0, "IAuth socket error: %s", strerror(ev_data(ev
)));
2093 /* and fall through to the ET_EOF case */
2095 iauth_disconnect(iauth
);
2098 assert(0 && "Unrecognized event type");
2103 /** Read error input from \a iauth.
2104 * @param[in] iauth Readable connection.
2106 static void iauth_read_stderr(struct IAuth
*iauth
)
2108 static char readbuf
[SERVER_TCP_WINDOW
];
2109 unsigned int length
, count
;
2113 /* Copy partial data to readbuf, append new data. */
2114 length
= iauth
->i_errcount
;
2115 memcpy(readbuf
, iauth
->i_errbuf
, length
);
2116 if (IO_SUCCESS
!= os_recv_nonb(s_fd(i_stderr(iauth
)),
2118 sizeof(readbuf
) - length
- 1,
2121 readbuf
[length
+= count
] = '\0';
2123 /* Send each complete line to SNO_AUTH. */
2124 for (sol
= readbuf
; (eol
= strchr(sol
, '\n')) != NULL
; sol
= eol
+ 1) {
2126 if (*(eol
- 1) == '\r') /* take out carriage returns, too... */
2128 Debug((DEBUG_ERROR
, "IAuth error: %s", sol
));
2129 log_write(LS_IAUTH
, L_ERROR
, 0, "IAuth error: %s", sol
);
2130 sendto_opmask_butone(NULL
, SNO_AUTH
, "%s", sol
);
2133 /* Put unused data back into connection's buffer. */
2134 iauth
->i_errcount
= strlen(sol
);
2135 if (iauth
->i_errcount
> BUFSIZE
)
2136 iauth
->i_errcount
= BUFSIZE
;
2137 memcpy(iauth
->i_errbuf
, sol
, iauth
->i_errcount
);
2140 /** Handle error socket activity for an %IAuth connection.
2141 * @param[in] ev &Socket event; the IAuth connection is the user data
2142 * pointer for the socket.
2144 static void iauth_stderr_callback(struct Event
*ev
)
2146 struct IAuth
*iauth
;
2148 assert(0 != ev_socket(ev
));
2149 iauth
= (struct IAuth
*) s_data(ev_socket(ev
));
2152 switch (ev_type(ev
)) {
2154 iauth_read_stderr(iauth
);
2157 log_write(LS_IAUTH
, L_ERROR
, 0, "IAuth stderr error: %s", strerror(ev_data(ev
)));
2158 /* and fall through to the ET_EOF/ET_DESTROY case */
2163 assert(0 && "Unrecognized event type");
2168 /** Report active iauth's configuration to \a cptr.
2169 * @param[in] cptr Client requesting statistics.
2170 * @param[in] sd Stats descriptor for request.
2171 * @param[in] param Extra parameter from user (may be NULL).
2173 void report_iauth_conf(struct Client
*cptr
, const struct StatDesc
*sd
, char *param
)
2177 if (iauth
) for (link
= iauth
->i_config
; link
; link
= link
->next
)
2179 send_reply(cptr
, SND_EXPLICIT
| RPL_STATSDEBUG
, ":%s",
2184 /** Report active iauth's statistics to \a cptr.
2185 * @param[in] cptr Client requesting statistics.
2186 * @param[in] sd Stats descriptor for request.
2187 * @param[in] param Extra parameter from user (may be NULL).
2189 void report_iauth_stats(struct Client
*cptr
, const struct StatDesc
*sd
, char *param
)
2193 if (iauth
) for (link
= iauth
->i_stats
; link
; link
= link
->next
)
2195 send_reply(cptr
, SND_EXPLICIT
| RPL_STATSDEBUG
, ":%s",