2 * ircd-ratbox: A slightly useful ircd.
3 * commio.c: Network/file related functions
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2002-2005 ircd-ratbox development team
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 * $Id: commio.c 3247 2007-03-05 18:42:24Z nenolod $
27 #include "libcharybdis.h"
29 #ifndef IN_LOOPBACKNET
30 #define IN_LOOPBACKNET 0x7f
34 #define INADDR_NONE ((unsigned int) 0xffffffff)
37 const char *const NONB_ERROR_MSG
= "set_non_blocking failed for %s:%s";
38 const char *const SETBUF_ERROR_MSG
= "set_sock_buffers failed for server %s:%s";
40 static const char *comm_err_str
[] = { "Comm OK", "Error during bind()",
41 "Error during DNS lookup", "connect timeout",
42 "Error during connect()",
46 #define FD_HASH_SIZE 128
47 static dlink_list fd_table
[FD_HASH_SIZE
];
49 static void fdlist_update_biggest(int fd
, int opening
);
51 /* Highest FD and number of open FDs .. */
52 int highest_fd
= -1; /* Its -1 because we haven't started yet -- adrian */
55 static void comm_connect_callback(int fd
, int status
);
56 static PF comm_connect_timeout
;
57 static void comm_connect_dns_callback(void *vptr
, struct DNSReply
*reply
);
58 static PF comm_connect_tryconnect
;
61 comm_locate_fd(int fd
)
63 int bucket
= fd
% FD_HASH_SIZE
;
64 dlink_list
*list
= &fd_table
[bucket
];
67 DLINK_FOREACH(n
, list
->head
)
69 fde_t
*F
= (fde_t
*) n
->data
;
81 fde_t
*F
= comm_locate_fd(fd
);
87 F
= calloc(sizeof(fde_t
), 1);
89 list
= &fd_table
[fd
% FD_HASH_SIZE
];
90 dlinkAdd(F
, &F
->node
, list
);
96 comm_remove_fd(int fd
)
98 int bucket
= fd
% FD_HASH_SIZE
;
100 dlink_list
*list
= &fd_table
[bucket
];
102 F
= comm_locate_fd(fd
);
106 dlinkDelete(&F
->node
, list
);
110 /* 32bit solaris is kinda slow and stdio only supports fds < 256
111 * so we got to do this crap below.
112 * (BTW Fuck you Sun, I hate your guts and I hope you go bankrupt soon)
113 * XXX: this is no longer needed in Solaris 10. --nenolod
115 #if defined (__SVR4) && defined (__sun)
116 static void comm_fd_hack(int *fd
)
119 if(*fd
> 256 || *fd
< 0)
121 if((newfd
= fcntl(*fd
, F_DUPFD
, 256)) != -1)
129 #define comm_fd_hack(fd)
133 /* close_all_connections() can be used *before* the system come up! */
143 /* XXX someone tell me why we care about 4 fd's ? */
144 /* XXX btw, fd 3 is used for profiler ! */
146 for (i
= 4; i
< MAXCONNECTIONS
; ++i
)
148 fde_t
*F
= comm_locate_fd(i
);
150 if(F
!= NULL
&& F
->flags
.open
)
156 /* XXX should his hack be done in all cases? */
158 /* fugly hack to reserve fd == 2 */
160 fd
= open("stderr.log", O_WRONLY
| O_CREAT
| O_APPEND
, 0644);
170 * get_sockerr - get the error value from the socket or the current errno
172 * Get the *real* error from the socket (well try to anyway..).
173 * This may only work when SO_DEBUG is enabled but its worth the
177 comm_get_sockerr(int fd
)
182 socklen_t len
= sizeof(err
);
184 if(-1 < fd
&& !getsockopt(fd
, SOL_SOCKET
, SO_ERROR
, (char *) &err
, (socklen_t
*) & len
))
195 * set_sock_buffers - set send and receive buffers for socket
197 * inputs - fd file descriptor
199 * output - returns true (1) if successful, false (0) otherwise
203 comm_set_buffers(int fd
, int size
)
206 (fd
, SOL_SOCKET
, SO_RCVBUF
, (char *) &size
, sizeof(size
))
207 || setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, (char *) &size
, sizeof(size
)))
213 * set_non_blocking - Set the client connection into non-blocking mode.
215 * inputs - fd to set into non blocking mode
216 * output - 1 if successful 0 if not
217 * side effects - use POSIX compliant non blocking and
225 fde_t
*F
= comm_locate_fd(fd
);
228 res
= fcntl(fd
, F_GETFL
, 0);
229 if(-1 == res
|| fcntl(fd
, F_SETFL
, res
| nonb
) == -1)
233 F
->flags
.nonblocking
= 1;
240 * stolen from squid - its a neat (but overused! :) routine which we
241 * can use to see whether we can ignore this errno or not. It is
242 * generally useful for non-blocking network IO related errnos.
246 ignoreErrno(int ierrno
)
252 #if EAGAIN != EWOULDBLOCK
268 * comm_settimeout() - set the socket timeout
270 * Set the timeout for the fd
273 comm_settimeout(int fd
, time_t timeout
, PF
* callback
, void *cbdata
)
277 F
= comm_locate_fd(fd
);
278 s_assert(F
->flags
.open
);
280 F
->timeout
= CurrentTime
+ (timeout
/ 1000);
281 F
->timeout_handler
= callback
;
282 F
->timeout_data
= cbdata
;
287 * comm_setflush() - set a flush function
289 * A flush function is simply a function called if found during
290 * comm_timeouts(). Its basically a second timeout, except in this case
291 * I'm too lazy to implement multiple timeout functions! :-)
292 * its kinda nice to have it seperate, since this is designed for
293 * flush functions, and when comm_close() is implemented correctly
294 * with close functions, we _actually_ don't call comm_close() here ..
297 comm_setflush(int fd
, time_t timeout
, PF
* callback
, void *cbdata
)
301 F
= comm_locate_fd(fd
);
302 s_assert(F
->flags
.open
);
304 F
->flush_timeout
= CurrentTime
+ (timeout
/ 1000);
305 F
->flush_handler
= callback
;
306 F
->flush_data
= cbdata
;
311 * comm_checktimeouts() - check the socket timeouts
313 * All this routine does is call the given callback/cbdata, without closing
314 * down the file descriptor. When close handlers have been implemented,
318 comm_checktimeouts(void *notused
)
327 for (i
= 0; i
<= FD_HASH_SIZE
; i
++)
329 bucket
= &fd_table
[i
];
331 if (dlink_list_length(bucket
) <= 0)
334 DLINK_FOREACH_SAFE(n
, n2
, bucket
->head
)
336 F
= (fde_t
*) n
->data
;
345 /* check flush functions */
346 if(F
->flush_handler
&&
347 F
->flush_timeout
> 0 && F
->flush_timeout
< CurrentTime
)
349 hdl
= F
->flush_handler
;
350 data
= F
->flush_data
;
351 comm_setflush(F
->fd
, 0, NULL
, NULL
);
356 if(F
->timeout_handler
&&
357 F
->timeout
> 0 && F
->timeout
< CurrentTime
)
359 /* Call timeout handler */
360 hdl
= F
->timeout_handler
;
361 data
= F
->timeout_data
;
362 comm_settimeout(F
->fd
, 0, NULL
, NULL
);
370 * void comm_connect_tcp(int fd, const char *host, u_short port,
371 * struct sockaddr *clocal, int socklen,
372 * CNCB *callback, void *data, int aftype, int timeout)
373 * Input: An fd to connect with, a host and port to connect to,
374 * a local sockaddr to connect from + length(or NULL to use the
375 * default), a callback, the data to pass into the callback, the
378 * Side-effects: A non-blocking connection to the host is started, and
379 * if necessary, set up for selection. The callback given
380 * may be called now, or it may be called later.
383 comm_connect_tcp(int fd
, const char *host
, u_short port
,
384 struct sockaddr
*clocal
, int socklen
, CNCB
* callback
,
385 void *data
, int aftype
, int timeout
)
390 F
= comm_locate_fd(fd
);
391 F
->flags
.called_connect
= 1;
393 F
->connect
.callback
= callback
;
394 F
->connect
.data
= data
;
396 memset(&F
->connect
.hostaddr
, 0, sizeof(F
->connect
.hostaddr
));
398 if(aftype
== AF_INET6
)
400 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)&F
->connect
.hostaddr
;
401 SET_SS_LEN(F
->connect
.hostaddr
, sizeof(struct sockaddr_in6
));
402 in6
->sin6_port
= htons(port
);
403 in6
->sin6_family
= AF_INET6
;
404 ipptr
= &in6
->sin6_addr
;
408 struct sockaddr_in
*in
= (struct sockaddr_in
*)&F
->connect
.hostaddr
;
409 SET_SS_LEN(F
->connect
.hostaddr
, sizeof(struct sockaddr_in
));
410 in
->sin_port
= htons(port
);
411 in
->sin_family
= AF_INET
;
412 ipptr
= &in
->sin_addr
;
415 /* Note that we're using a passed sockaddr here. This is because
416 * generally you'll be bind()ing to a sockaddr grabbed from
417 * getsockname(), so this makes things easier.
418 * XXX If NULL is passed as local, we should later on bind() to the
419 * virtual host IP, for completeness.
422 if((clocal
!= NULL
) && (bind(F
->fd
, clocal
, socklen
) < 0))
424 /* Failure, call the callback with COMM_ERR_BIND */
425 comm_connect_callback(F
->fd
, COMM_ERR_BIND
);
430 /* Next, if we have been given an IP, get the addr and skip the
431 * DNS check (and head direct to comm_connect_tryconnect().
433 if(inetpton(aftype
, host
, ipptr
) <= 0)
435 /* Send the DNS request, for the next level */
436 F
->dns_query
= MyMalloc(sizeof(struct DNSQuery
));
437 F
->dns_query
->ptr
= F
;
438 F
->dns_query
->callback
= comm_connect_dns_callback
;
440 if (aftype
== AF_INET6
)
441 gethost_byname_type(host
, F
->dns_query
, T_AAAA
);
444 gethost_byname_type(host
, F
->dns_query
, T_A
);
448 /* We have a valid IP, so we just call tryconnect */
449 /* Make sure we actually set the timeout here .. */
450 comm_settimeout(F
->fd
, timeout
* 1000, comm_connect_timeout
, NULL
);
451 comm_connect_tryconnect(F
->fd
, NULL
);
456 * comm_connect_callback() - call the callback, and continue with life
459 comm_connect_callback(int fd
, int status
)
462 fde_t
*F
= comm_locate_fd(fd
);
464 /* This check is gross..but probably necessary */
465 if(F
== NULL
|| F
->connect
.callback
== NULL
)
468 /* Clear the connect flag + handler */
469 hdl
= F
->connect
.callback
;
470 F
->connect
.callback
= NULL
;
471 F
->flags
.called_connect
= 0;
473 /* Clear the timeout handler */
474 comm_settimeout(F
->fd
, 0, NULL
, NULL
);
476 /* Call the handler */
477 hdl(F
->fd
, status
, F
->connect
.data
);
482 * comm_connect_timeout() - this gets called when the socket connection
483 * times out. This *only* can be called once connect() is initially
487 comm_connect_timeout(int fd
, void *notused
)
490 comm_connect_callback(fd
, COMM_ERR_TIMEOUT
);
495 * comm_connect_dns_callback() - called at the completion of the DNS request
497 * The DNS request has completed, so if we've got an error, return it,
498 * otherwise we initiate the connect()
501 comm_connect_dns_callback(void *vptr
, struct DNSReply
*reply
)
505 /* Free dns_query now to avoid double reslist free -- jilles */
506 MyFree(F
->dns_query
);
511 comm_connect_callback(F
->fd
, COMM_ERR_DNS
);
515 /* No error, set a 10 second timeout */
516 comm_settimeout(F
->fd
, 30 * 1000, comm_connect_timeout
, NULL
);
518 /* Copy over the DNS reply info so we can use it in the connect() */
520 if(reply
->addr
.ss_family
== AF_INET6
)
522 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)&F
->connect
.hostaddr
;
523 memcpy(&in6
->sin6_addr
, &((struct sockaddr_in6
*)&reply
->addr
)->sin6_addr
, sizeof(struct in6_addr
));
528 struct sockaddr_in
*in
= (struct sockaddr_in
*)&F
->connect
.hostaddr
;
529 in
->sin_addr
.s_addr
= ((struct sockaddr_in
*)&reply
->addr
)->sin_addr
.s_addr
;
532 /* Now, call the tryconnect() routine to try a connect() */
533 comm_connect_tryconnect(F
->fd
, NULL
);
537 /* static void comm_connect_tryconnect(int fd, void *notused)
538 * Input: The fd, the handler data(unused).
540 * Side-effects: Try and connect with pending connect data for the FD. If
541 * we succeed or get a fatal error, call the callback.
542 * Otherwise, it is still blocking or something, so register
543 * to select for a write event on this FD.
546 comm_connect_tryconnect(int fd
, void *notused
)
549 fde_t
*F
= comm_locate_fd(fd
);
551 if(F
->connect
.callback
== NULL
)
553 /* Try the connect() */
554 retval
= connect(fd
, (struct sockaddr
*) &F
->connect
.hostaddr
,
555 GET_SS_LEN(F
->connect
.hostaddr
));
560 * If we get EISCONN, then we've already connect()ed the socket,
561 * which is a good thing.
565 comm_connect_callback(F
->fd
, COMM_OK
);
566 else if(ignoreErrno(errno
))
567 /* Ignore error? Reschedule */
568 comm_setselect(F
->fd
, FDLIST_SERVER
, COMM_SELECT_WRITE
|COMM_SELECT_RETRY
,
569 comm_connect_tryconnect
, NULL
, 0);
571 /* Error? Fail with COMM_ERR_CONNECT */
572 comm_connect_callback(F
->fd
, COMM_ERR_CONNECT
);
575 /* If we get here, we've suceeded, so call with COMM_OK */
576 comm_connect_callback(F
->fd
, COMM_OK
);
580 * comm_error_str() - return an error string for the given error condition
583 comm_errstr(int error
)
585 if(error
< 0 || error
>= COMM_ERR_MAX
)
586 return "Invalid error number!";
587 return comm_err_str
[error
];
592 * comm_socket() - open a socket
594 * This is a highly highly cut down version of squid's comm_open() which
595 * for the most part emulates socket(), *EXCEPT* it fails if we're about
596 * to run out of file descriptors.
599 comm_socket(int family
, int sock_type
, int proto
, const char *note
)
602 /* First, make sure we aren't going to run out of file descriptors */
603 if(number_fd
>= MASTER_MAX
)
610 * Next, we try to open the socket. We *should* drop the reserved FD
611 * limit if/when we get an error, but we can deal with that later.
614 fd
= socket(family
, sock_type
, proto
);
617 return -1; /* errno will be passed through, yay.. */
619 #if defined(IPV6) && defined(IPV6_V6ONLY)
621 * Make sure we can take both IPv4 and IPv6 connections
622 * on an AF_INET6 socket
624 if(family
== AF_INET6
)
627 if(setsockopt(fd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &off
, sizeof(off
)) == -1)
629 libcharybdis_log("comm_socket: Could not set IPV6_V6ONLY option to 1 on FD %d: %s",
630 fd
, strerror(errno
));
637 /* Set the socket non-blocking, and other wonderful bits */
640 libcharybdis_log("comm_open: Couldn't set FD %d non blocking: %s", fd
, strerror(errno
));
645 /* Next, update things in our fd tracking */
646 comm_open(fd
, FD_SOCKET
, note
);
652 * comm_accept() - accept an incoming connection
654 * This is a simple wrapper for accept() which enforces FD limits like
658 comm_accept(int fd
, struct sockaddr
*pn
, socklen_t
*addrlen
)
661 if(number_fd
>= MASTER_MAX
)
668 * Next, do the accept(). if we get an error, we should drop the
669 * reserved fd limit, but we can deal with that when comm_open()
670 * also does it. XXX -- adrian
672 newfd
= accept(fd
, (struct sockaddr
*) pn
, addrlen
);
673 comm_fd_hack(&newfd
);
678 /* Set the socket non-blocking, and other wonderful bits */
679 if(!comm_set_nb(newfd
))
681 libcharybdis_log("comm_accept: Couldn't set FD %d non blocking!", newfd
);
686 /* Next, tag the FD as an incoming connection */
687 comm_open(newfd
, FD_SOCKET
, "Incoming connection");
694 * If a sockaddr_storage is AF_INET6 but is a mapped IPv4
695 * socket manged the sockaddr.
697 #ifndef mangle_mapped_sockaddr
699 mangle_mapped_sockaddr(struct sockaddr
*in
)
701 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)in
;
703 if(in
->sa_family
== AF_INET
)
706 if(in
->sa_family
== AF_INET6
&& IN6_IS_ADDR_V4MAPPED(&in6
->sin6_addr
))
708 struct sockaddr_in in4
;
709 memset(&in4
, 0, sizeof(struct sockaddr_in
));
710 in4
.sin_family
= AF_INET
;
711 in4
.sin_port
= in6
->sin6_port
;
712 in4
.sin_addr
.s_addr
= ((uint32_t *)&in6
->sin6_addr
)[3];
713 memcpy(in
, &in4
, sizeof(struct sockaddr_in
));
721 fdlist_update_biggest(int fd
, int opening
)
725 s_assert(fd
< MAXCONNECTIONS
);
730 * s_assert that we are not closing a FD bigger than
731 * our known biggest FD
737 /* if we are here, then fd == Biggest_FD */
739 * s_assert that we are closing the biggest FD; we can't be
743 while (highest_fd
>= 0 && comm_locate_fd(fd
) != NULL
)
751 static int initialized
= 0;
755 memset(&fd_table
, '\0', sizeof(dlink_list
) * FD_HASH_SIZE
);
760 /* Called to open a given filedescriptor */
762 comm_open(int fd
, unsigned int type
, const char *desc
)
764 fde_t
*F
= comm_add_fd(fd
);
771 s_assert(!F
->flags
.open
);
778 F
->defer
.handler
= NULL
;
780 fdlist_update_biggest(fd
, 1);
782 F
->list
= FDLIST_NONE
;
784 strlcpy(F
->desc
, desc
, sizeof(F
->desc
));
789 /* Called to close a given filedescriptor */
793 fde_t
*F
= comm_locate_fd(fd
);
794 s_assert(F
->flags
.open
);
795 /* All disk fd's MUST go through file_close() ! */
796 s_assert(F
->type
!= FD_FILE
);
797 if(F
->type
== FD_FILE
)
799 s_assert(F
->read_handler
== NULL
);
800 s_assert(F
->write_handler
== NULL
);
802 comm_setselect(F
->fd
, FDLIST_NONE
, COMM_SELECT_WRITE
| COMM_SELECT_READ
, NULL
, NULL
, 0);
803 comm_setflush(F
->fd
, 0, NULL
, NULL
);
806 if (F
->dns_query
!= NULL
)
808 delete_resolver_queries(F
->dns_query
);
809 MyFree(F
->dns_query
);
814 fdlist_update_biggest(fd
, 0);
818 /* Unlike squid, we're actually closing the FD here! -- adrian */
823 * comm_dump() - dump the list of active filedescriptors
826 comm_dump(struct Client
*source_p
)
830 for (i
= 0; i
<= FD_HASH_SIZE
; i
++)
834 if (dlink_list_length(&fd_table
[i
]) <= 0)
837 DLINK_FOREACH(n
, fd_table
[i
].head
)
839 fde_t
*F
= (fde_t
*) n
->data
;
841 if(F
== NULL
|| !F
->flags
.open
)
844 sendto_one_numeric(source_p
, RPL_STATSDEBUG
,
845 "F :fd %-3d bucket %-3d desc '%s'",
852 * comm_note() - set the fd note
854 * Note: must be careful not to overflow fd_table[fd].desc when
858 comm_note(int fd
, const char *format
, ...)
861 fde_t
*F
= comm_add_fd(fd
); /* XXX: epoll, kqueue. */
865 va_start(args
, format
);
866 ircvsnprintf(F
->desc
, FD_DESC_SZ
, format
, args
);