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 3354 2007-04-03 09:21:31Z 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
;
59 static int comm_max_connections
= 0;
62 comm_locate_fd(int fd
)
64 int bucket
= fd
% FD_HASH_SIZE
;
65 dlink_list
*list
= &fd_table
[bucket
];
68 DLINK_FOREACH(n
, list
->head
)
70 fde_t
*F
= (fde_t
*) n
->data
;
82 fde_t
*F
= comm_locate_fd(fd
);
88 F
= calloc(sizeof(fde_t
), 1);
90 list
= &fd_table
[fd
% FD_HASH_SIZE
];
91 dlinkAdd(F
, &F
->node
, list
);
97 comm_remove_fd(int fd
)
99 int bucket
= fd
% FD_HASH_SIZE
;
101 dlink_list
*list
= &fd_table
[bucket
];
103 F
= comm_locate_fd(fd
);
107 dlinkDelete(&F
->node
, list
);
111 /* 32bit solaris is kinda slow and stdio only supports fds < 256
112 * so we got to do this crap below.
113 * (BTW Fuck you Sun, I hate your guts and I hope you go bankrupt soon)
114 * XXX: this is no longer needed in Solaris 10. --nenolod
116 #if defined (__SVR4) && defined (__sun)
117 static void comm_fd_hack(int *fd
)
120 if(*fd
> 256 || *fd
< 0)
122 if((newfd
= fcntl(*fd
, F_DUPFD
, 256)) != -1)
130 #define comm_fd_hack(fd)
134 /* close_all_connections() can be used *before* the system come up! */
145 * we start at 4 to avoid giving fds where malloc messages
146 * could be written --nenolod
148 for (i
= 4; i
< comm_max_connections
; ++i
)
150 fde_t
*F
= comm_locate_fd(i
);
152 if(F
!= NULL
&& F
->flags
.open
)
158 /* XXX should his hack be done in all cases? */
160 /* fugly hack to reserve fd == 2 */
162 fd
= open("stderr.log", O_WRONLY
| O_CREAT
| O_APPEND
, 0644);
172 * get_sockerr - get the error value from the socket or the current errno
174 * Get the *real* error from the socket (well try to anyway..).
175 * This may only work when SO_DEBUG is enabled but its worth the
179 comm_get_sockerr(int fd
)
184 socklen_t len
= sizeof(err
);
186 if(-1 < fd
&& !getsockopt(fd
, SOL_SOCKET
, SO_ERROR
, (char *) &err
, (socklen_t
*) & len
))
197 * set_sock_buffers - set send and receive buffers for socket
199 * inputs - fd file descriptor
201 * output - returns true (1) if successful, false (0) otherwise
205 comm_set_buffers(int fd
, int size
)
208 (fd
, SOL_SOCKET
, SO_RCVBUF
, (char *) &size
, sizeof(size
))
209 || setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, (char *) &size
, sizeof(size
)))
215 * set_non_blocking - Set the client connection into non-blocking mode.
217 * inputs - fd to set into non blocking mode
218 * output - 1 if successful 0 if not
219 * side effects - use POSIX compliant non blocking and
227 fde_t
*F
= comm_locate_fd(fd
);
230 res
= fcntl(fd
, F_GETFL
, 0);
231 if(-1 == res
|| fcntl(fd
, F_SETFL
, res
| nonb
) == -1)
235 F
->flags
.nonblocking
= 1;
242 * stolen from squid - its a neat (but overused! :) routine which we
243 * can use to see whether we can ignore this errno or not. It is
244 * generally useful for non-blocking network IO related errnos.
248 ignoreErrno(int ierrno
)
254 #if EAGAIN != EWOULDBLOCK
270 * comm_settimeout() - set the socket timeout
272 * Set the timeout for the fd
275 comm_settimeout(int fd
, time_t timeout
, PF
* callback
, void *cbdata
)
279 F
= comm_locate_fd(fd
);
280 s_assert(F
->flags
.open
);
282 F
->timeout
= CurrentTime
+ (timeout
/ 1000);
283 F
->timeout_handler
= callback
;
284 F
->timeout_data
= cbdata
;
289 * comm_setflush() - set a flush function
291 * A flush function is simply a function called if found during
292 * comm_timeouts(). Its basically a second timeout, except in this case
293 * I'm too lazy to implement multiple timeout functions! :-)
294 * its kinda nice to have it seperate, since this is designed for
295 * flush functions, and when comm_close() is implemented correctly
296 * with close functions, we _actually_ don't call comm_close() here ..
299 comm_setflush(int fd
, time_t timeout
, PF
* callback
, void *cbdata
)
303 F
= comm_locate_fd(fd
);
304 s_assert(F
->flags
.open
);
306 F
->flush_timeout
= CurrentTime
+ (timeout
/ 1000);
307 F
->flush_handler
= callback
;
308 F
->flush_data
= cbdata
;
313 * comm_checktimeouts() - check the socket timeouts
315 * All this routine does is call the given callback/cbdata, without closing
316 * down the file descriptor. When close handlers have been implemented,
320 comm_checktimeouts(void *notused
)
329 for (i
= 0; i
<= FD_HASH_SIZE
; i
++)
331 bucket
= &fd_table
[i
];
333 if (dlink_list_length(bucket
) <= 0)
336 DLINK_FOREACH_SAFE(n
, n2
, bucket
->head
)
338 F
= (fde_t
*) n
->data
;
347 /* check flush functions */
348 if(F
->flush_handler
&&
349 F
->flush_timeout
> 0 && F
->flush_timeout
< CurrentTime
)
351 hdl
= F
->flush_handler
;
352 data
= F
->flush_data
;
353 comm_setflush(F
->fd
, 0, NULL
, NULL
);
358 if(F
->timeout_handler
&&
359 F
->timeout
> 0 && F
->timeout
< CurrentTime
)
361 /* Call timeout handler */
362 hdl
= F
->timeout_handler
;
363 data
= F
->timeout_data
;
364 comm_settimeout(F
->fd
, 0, NULL
, NULL
);
372 * void comm_connect_tcp(int fd, const char *host, u_short port,
373 * struct sockaddr *clocal, int socklen,
374 * CNCB *callback, void *data, int aftype, int timeout)
375 * Input: An fd to connect with, a host and port to connect to,
376 * a local sockaddr to connect from + length(or NULL to use the
377 * default), a callback, the data to pass into the callback, the
380 * Side-effects: A non-blocking connection to the host is started, and
381 * if necessary, set up for selection. The callback given
382 * may be called now, or it may be called later.
385 comm_connect_tcp(int fd
, const char *host
, u_short port
,
386 struct sockaddr
*clocal
, int socklen
, CNCB
* callback
,
387 void *data
, int aftype
, int timeout
)
392 F
= comm_locate_fd(fd
);
393 F
->flags
.called_connect
= 1;
395 F
->connect
.callback
= callback
;
396 F
->connect
.data
= data
;
398 memset(&F
->connect
.hostaddr
, 0, sizeof(F
->connect
.hostaddr
));
400 if(aftype
== AF_INET6
)
402 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)&F
->connect
.hostaddr
;
403 SET_SS_LEN(F
->connect
.hostaddr
, sizeof(struct sockaddr_in6
));
404 in6
->sin6_port
= htons(port
);
405 in6
->sin6_family
= AF_INET6
;
406 ipptr
= &in6
->sin6_addr
;
410 struct sockaddr_in
*in
= (struct sockaddr_in
*)&F
->connect
.hostaddr
;
411 SET_SS_LEN(F
->connect
.hostaddr
, sizeof(struct sockaddr_in
));
412 in
->sin_port
= htons(port
);
413 in
->sin_family
= AF_INET
;
414 ipptr
= &in
->sin_addr
;
417 /* Note that we're using a passed sockaddr here. This is because
418 * generally you'll be bind()ing to a sockaddr grabbed from
419 * getsockname(), so this makes things easier.
420 * XXX If NULL is passed as local, we should later on bind() to the
421 * virtual host IP, for completeness.
424 if((clocal
!= NULL
) && (bind(F
->fd
, clocal
, socklen
) < 0))
426 /* Failure, call the callback with COMM_ERR_BIND */
427 comm_connect_callback(F
->fd
, COMM_ERR_BIND
);
432 /* Next, if we have been given an IP, get the addr and skip the
433 * DNS check (and head direct to comm_connect_tryconnect().
435 if(inetpton(aftype
, host
, ipptr
) <= 0)
437 /* Send the DNS request, for the next level */
438 F
->dns_query
= MyMalloc(sizeof(struct DNSQuery
));
439 F
->dns_query
->ptr
= F
;
440 F
->dns_query
->callback
= comm_connect_dns_callback
;
442 if (aftype
== AF_INET6
)
443 gethost_byname_type(host
, F
->dns_query
, T_AAAA
);
446 gethost_byname_type(host
, F
->dns_query
, T_A
);
450 /* We have a valid IP, so we just call tryconnect */
451 /* Make sure we actually set the timeout here .. */
452 comm_settimeout(F
->fd
, timeout
* 1000, comm_connect_timeout
, NULL
);
453 comm_connect_tryconnect(F
->fd
, NULL
);
458 * comm_connect_callback() - call the callback, and continue with life
461 comm_connect_callback(int fd
, int status
)
464 fde_t
*F
= comm_locate_fd(fd
);
466 /* This check is gross..but probably necessary */
467 if(F
== NULL
|| F
->connect
.callback
== NULL
)
470 /* Clear the connect flag + handler */
471 hdl
= F
->connect
.callback
;
472 F
->connect
.callback
= NULL
;
473 F
->flags
.called_connect
= 0;
475 /* Clear the timeout handler */
476 comm_settimeout(F
->fd
, 0, NULL
, NULL
);
478 /* Call the handler */
479 hdl(F
->fd
, status
, F
->connect
.data
);
484 * comm_connect_timeout() - this gets called when the socket connection
485 * times out. This *only* can be called once connect() is initially
489 comm_connect_timeout(int fd
, void *notused
)
492 comm_connect_callback(fd
, COMM_ERR_TIMEOUT
);
497 * comm_connect_dns_callback() - called at the completion of the DNS request
499 * The DNS request has completed, so if we've got an error, return it,
500 * otherwise we initiate the connect()
503 comm_connect_dns_callback(void *vptr
, struct DNSReply
*reply
)
507 /* Free dns_query now to avoid double reslist free -- jilles */
508 MyFree(F
->dns_query
);
513 comm_connect_callback(F
->fd
, COMM_ERR_DNS
);
517 /* No error, set a 10 second timeout */
518 comm_settimeout(F
->fd
, 30 * 1000, comm_connect_timeout
, NULL
);
520 /* Copy over the DNS reply info so we can use it in the connect() */
522 if(reply
->addr
.ss_family
== AF_INET6
)
524 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)&F
->connect
.hostaddr
;
525 memcpy(&in6
->sin6_addr
, &((struct sockaddr_in6
*)&reply
->addr
)->sin6_addr
, sizeof(struct in6_addr
));
530 struct sockaddr_in
*in
= (struct sockaddr_in
*)&F
->connect
.hostaddr
;
531 in
->sin_addr
.s_addr
= ((struct sockaddr_in
*)&reply
->addr
)->sin_addr
.s_addr
;
534 /* Now, call the tryconnect() routine to try a connect() */
535 comm_connect_tryconnect(F
->fd
, NULL
);
539 /* static void comm_connect_tryconnect(int fd, void *notused)
540 * Input: The fd, the handler data(unused).
542 * Side-effects: Try and connect with pending connect data for the FD. If
543 * we succeed or get a fatal error, call the callback.
544 * Otherwise, it is still blocking or something, so register
545 * to select for a write event on this FD.
548 comm_connect_tryconnect(int fd
, void *notused
)
551 fde_t
*F
= comm_locate_fd(fd
);
553 if(F
->connect
.callback
== NULL
)
555 /* Try the connect() */
556 retval
= connect(fd
, (struct sockaddr
*) &F
->connect
.hostaddr
,
557 GET_SS_LEN(F
->connect
.hostaddr
));
562 * If we get EISCONN, then we've already connect()ed the socket,
563 * which is a good thing.
567 comm_connect_callback(F
->fd
, COMM_OK
);
568 else if(ignoreErrno(errno
))
569 /* Ignore error? Reschedule */
570 comm_setselect(F
->fd
, FDLIST_SERVER
, COMM_SELECT_WRITE
|COMM_SELECT_RETRY
,
571 comm_connect_tryconnect
, NULL
, 0);
573 /* Error? Fail with COMM_ERR_CONNECT */
574 comm_connect_callback(F
->fd
, COMM_ERR_CONNECT
);
577 /* If we get here, we've suceeded, so call with COMM_OK */
578 comm_connect_callback(F
->fd
, COMM_OK
);
582 * comm_error_str() - return an error string for the given error condition
585 comm_errstr(int error
)
587 if(error
< 0 || error
>= COMM_ERR_MAX
)
588 return "Invalid error number!";
589 return comm_err_str
[error
];
594 * comm_socket() - open a socket
596 * This is a highly highly cut down version of squid's comm_open() which
597 * for the most part emulates socket(), *EXCEPT* it fails if we're about
598 * to run out of file descriptors.
601 comm_socket(int family
, int sock_type
, int proto
, const char *note
)
604 /* First, make sure we aren't going to run out of file descriptors */
605 if(number_fd
>= comm_max_connections
)
612 * Next, we try to open the socket. We *should* drop the reserved FD
613 * limit if/when we get an error, but we can deal with that later.
616 fd
= socket(family
, sock_type
, proto
);
619 return -1; /* errno will be passed through, yay.. */
621 #if defined(IPV6) && defined(IPV6_V6ONLY)
623 * Make sure we can take both IPv4 and IPv6 connections
624 * on an AF_INET6 socket
626 if(family
== AF_INET6
)
629 if(setsockopt(fd
, IPPROTO_IPV6
, IPV6_V6ONLY
, &off
, sizeof(off
)) == -1)
631 libcharybdis_log("comm_socket: Could not set IPV6_V6ONLY option to 1 on FD %d: %s",
632 fd
, strerror(errno
));
639 /* Set the socket non-blocking, and other wonderful bits */
642 libcharybdis_log("comm_open: Couldn't set FD %d non blocking: %s", fd
, strerror(errno
));
647 /* Next, update things in our fd tracking */
648 comm_open(fd
, FD_SOCKET
, note
);
654 * comm_accept() - accept an incoming connection
656 * This is a simple wrapper for accept() which enforces FD limits like
660 comm_accept(int fd
, struct sockaddr
*pn
, socklen_t
*addrlen
)
663 if(number_fd
>= comm_max_connections
)
670 * Next, do the accept(). if we get an error, we should drop the
671 * reserved fd limit, but we can deal with that when comm_open()
672 * also does it. XXX -- adrian
674 newfd
= accept(fd
, (struct sockaddr
*) pn
, addrlen
);
675 comm_fd_hack(&newfd
);
680 /* Set the socket non-blocking, and other wonderful bits */
681 if(!comm_set_nb(newfd
))
683 libcharybdis_log("comm_accept: Couldn't set FD %d non blocking!", newfd
);
688 /* Next, tag the FD as an incoming connection */
689 comm_open(newfd
, FD_SOCKET
, "Incoming connection");
696 * If a sockaddr_storage is AF_INET6 but is a mapped IPv4
697 * socket manged the sockaddr.
699 #ifndef mangle_mapped_sockaddr
701 mangle_mapped_sockaddr(struct sockaddr
*in
)
703 struct sockaddr_in6
*in6
= (struct sockaddr_in6
*)in
;
705 if(in
->sa_family
== AF_INET
)
708 if(in
->sa_family
== AF_INET6
&& IN6_IS_ADDR_V4MAPPED(&in6
->sin6_addr
))
710 struct sockaddr_in in4
;
711 memset(&in4
, 0, sizeof(struct sockaddr_in
));
712 in4
.sin_family
= AF_INET
;
713 in4
.sin_port
= in6
->sin6_port
;
714 in4
.sin_addr
.s_addr
= ((uint32_t *)&in6
->sin6_addr
)[3];
715 memcpy(in
, &in4
, sizeof(struct sockaddr_in
));
723 fdlist_update_biggest(int fd
, int opening
)
727 s_assert(fd
< comm_max_connections
);
732 * s_assert that we are not closing a FD bigger than
733 * our known biggest FD
739 /* if we are here, then fd == Biggest_FD */
741 * s_assert that we are closing the biggest FD; we can't be
745 while (highest_fd
>= 0 && comm_locate_fd(fd
) != NULL
)
753 static int initialized
= 0;
758 memset(&fd_table
, '\0', sizeof(dlink_list
) * FD_HASH_SIZE
);
760 /* set up comm_max_connections. */
761 if(!getrlimit(RLIMIT_NOFILE
, &limit
))
762 comm_max_connections
= limit
.rlim_cur
;
768 /* Called to open a given filedescriptor */
770 comm_open(int fd
, unsigned int type
, const char *desc
)
772 fde_t
*F
= comm_add_fd(fd
);
779 s_assert(!F
->flags
.open
);
786 F
->defer
.handler
= NULL
;
788 fdlist_update_biggest(fd
, 1);
790 F
->list
= FDLIST_NONE
;
792 strlcpy(F
->desc
, desc
, sizeof(F
->desc
));
797 /* Called to close a given filedescriptor */
801 fde_t
*F
= comm_locate_fd(fd
);
802 s_assert(F
->flags
.open
);
803 /* All disk fd's MUST go through file_close() ! */
804 s_assert(F
->type
!= FD_FILE
);
805 if(F
->type
== FD_FILE
)
807 s_assert(F
->read_handler
== NULL
);
808 s_assert(F
->write_handler
== NULL
);
810 comm_setselect(F
->fd
, FDLIST_NONE
, COMM_SELECT_WRITE
| COMM_SELECT_READ
, NULL
, NULL
, 0);
811 comm_setflush(F
->fd
, 0, NULL
, NULL
);
814 if (F
->dns_query
!= NULL
)
816 delete_resolver_queries(F
->dns_query
);
817 MyFree(F
->dns_query
);
822 fdlist_update_biggest(fd
, 0);
826 /* Unlike squid, we're actually closing the FD here! -- adrian */
831 * comm_dump() - dump the list of active filedescriptors
834 comm_dump(struct Client
*source_p
)
838 for (i
= 0; i
<= FD_HASH_SIZE
; i
++)
842 if (dlink_list_length(&fd_table
[i
]) <= 0)
845 DLINK_FOREACH(n
, fd_table
[i
].head
)
847 fde_t
*F
= (fde_t
*) n
->data
;
849 if(F
== NULL
|| !F
->flags
.open
)
852 sendto_one_numeric(source_p
, RPL_STATSDEBUG
,
853 "F :fd %-3d bucket %-3d desc '%s'",
860 * comm_note() - set the fd note
862 * Note: must be careful not to overflow fd_table[fd].desc when
866 comm_note(int fd
, const char *format
, ...)
869 fde_t
*F
= comm_add_fd(fd
); /* XXX: epoll, kqueue. */
873 va_start(args
, format
);
874 ircvsnprintf(F
->desc
, FD_DESC_SZ
, format
, args
);
882 comm_get_maxconnections(void)
886 return comm_max_connections
;