/* * Copyright (C) 1997 Robey Pointer * Copyright (C) 1999 - 2002 Eggheads Development Team * Copyright (C) 2002 - 2010 Bryan Drewery * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* * net.c -- handles: * all raw network i/o * */ #include #include "common.h" #include "net.h" #include "socket.h" #include "misc.h" #include "main.h" #include "debug.h" #include "dccutil.h" #include "enclink.h" #include "egg_timer.h" #include "traffic.h" #include "adns.h" #include #include #include #include #include #include #include #include #include #if HAVE_SYS_SELECT_H # include #endif /* HAVE_SYS_SELECT_H */ #include #include #include #include #if HAVE_UNISTD_H # include #endif /* HAVE_UNITSTD_H */ extern egg_traffic_t traffic; union sockaddr_union cached_myip4_so; #ifdef USE_IPV6 union sockaddr_union cached_myip6_so; #endif /* USE_IPV6 */ bool cached_ip = 0; /* Set to 1 after cache_my_ip is called */ bool identd_hack = 0; /* identd_open() won't work on most servers, dont even bother warning. */ char botuser[21] = ""; /* Username of the user running the bot */ int socks_total = 0; /* total number of sockets */ sock_list *socklist = NULL; /* Enough to be safe */ int MAXSOCKS = 0; jmp_buf alarmret; /* Env buffer for alarm() returns */ /* This *MUST* be an ip */ char firewall[121] = ""; /* Socks server for firewall */ port_t firewallport = 1080; /* Default port of Sock4/5 firewalls */ /* Types of proxy */ #define PROXY_SOCKS 1 #define PROXY_SUN 2 #define PROXY_HTTP 3 /* I need an UNSIGNED long for dcc type stuff */ unsigned long my_atoul(const char *s) { unsigned long ret = 0; while ((*s >= '0') && (*s <= '9')) { ret *= 10; ret += ((*s) - '0'); ++s; } return ret; } /* get the protocol used on a socket */ int sockprotocol(int sock) { struct sockaddr sa; socklen_t socklen = sizeof(sa); bzero(&sa, socklen); if (getsockname(sock, &sa, &socklen)) return -1; else return sa.sa_family; } /* AF_INET-independent resolving routine */ static int get_ip(char *hostname, union sockaddr_union *so, int dns_type) { if (!hostname || (hostname && !hostname[0])) return 1; memset(so, 0, sizeof(union sockaddr_union)); debug1("get_ip(%s)", hostname); bd::Array hosts = dns_lookup_block(hostname, 10, dns_type); if (hosts.length() == 0) return -1; my_addr_t addr; get_addr(bd::String(hosts[0]).c_str(), &addr); if (addr.family == AF_INET) { so->sin.sin_family = AF_INET; memcpy(&so->sin.sin_addr, &addr.u.addr, sizeof(addr.u.addr)); #ifdef USE_IPV6 } else if (addr.family == AF_INET6) { so->sin6.sin6_family = AF_INET6; memcpy(&so->sin6.sin6_addr, &addr.u.addr6, sizeof(addr.u.addr6)); #endif } return 0; } /* Initialize the socklist */ void init_net() { MAXSOCKS = max_dcc + 10; if (socklist) socklist = (sock_list *) my_realloc((void *) socklist, sizeof(sock_list) * MAXSOCKS); else socklist = (sock_list *) my_calloc(1, sizeof(sock_list) * MAXSOCKS); for (int i = 0; i < MAXSOCKS; i++) { bzero(&socklist[i], sizeof(socklist[i])); socklist[i].flags = SOCK_UNUSED; #ifdef EGG_SSL_EXT socklist[i].ssl = NULL; #endif socklist[i].sock = -1; } } /* Get my ipv? ip */ char *myipstr(int af_type) { if (cached_ip) { #ifdef USE_IPV6 if (af_type == AF_INET6) { static char s[UHOSTLEN + 1] = ""; inet_ntop(AF_INET6, &cached_myip6_so.sin6.sin6_addr, s, 119); s[120] = 0; return s; } else #endif /* USE_IPV6 */ if (af_type == AF_INET) { static char s[UHOSTLEN + 1] = ""; inet_ntop(AF_INET, &cached_myip4_so.sin.sin_addr, s, 119); s[120] = 0; return s; } } return ""; } /* Get my ip number */ in_addr_t getmyip() { return cached_myip4_so.sin.sin_addr.s_addr; } /* see if it's necessary to set inaddr_any... because if we can't resolve, we die anyway */ void cache_my_ip() { #ifdef no cached_myip6_so.sin6.sin6_family = AF_INET6; cached_myip6_so.sin6.sin6_addr = in6addr_any; cached_myip4_so.sin.sin_family = AF_INET; cached_myip4_so.sin.sin_addr.s_addr = INADDR_ANY; #endif int error = 0; debug0("cache_my_ip()"); memset(&cached_myip4_so, 0, sizeof(union sockaddr_union)); #ifdef USE_IPV6 bool any = 0; memset(&cached_myip6_so, 0, sizeof(union sockaddr_union)); if (conf.bot->net.ip6) { if (get_ip(conf.bot->net.ip6, &cached_myip6_so, DNS_LOOKUP_AAAA)) any = 1; } else if (conf.bot->net.host6) { if (get_ip(conf.bot->net.host6, &cached_myip6_so, DNS_LOOKUP_AAAA)) any = 1; } else any = 1; if (any) { cached_myip6_so.sin6.sin6_family = AF_INET6; cached_myip6_so.sin6.sin6_addr = in6addr_any; } #endif /* USE_IPV6 */ if (conf.bot->net.ip) { if (get_ip(conf.bot->net.ip, &cached_myip4_so, DNS_LOOKUP_A)) error = 1; } else if (conf.bot->net.host) { if (get_ip(conf.bot->net.host, &cached_myip4_so, DNS_LOOKUP_A)) error = 2; } else { /* char s[121] = ""; gethostname(s, sizeof(s)); if (get_ip(s, &cached_myip4_so)) { */ /* error = 3; */ cached_myip4_so.sin.sin_family = AF_INET; cached_myip4_so.sin.sin_addr.s_addr = INADDR_ANY; // } } if (error) { putlog(LOG_DEBUG, "*", "Hostname self-lookup error: %d", error); fatal("Hostname self-lookup failed.", 0); } cached_ip = 1; } /* Sets/Unsets options for a specific socket. * * Returns: 0 - on success * -1 - socket not found * -2 - illegal operation */ int sockoptions(int sock, int operation, int sock_options) { int i = -1; if ((i = findanysnum(sock)) != -1) { if (operation == EGG_OPTION_SET) socklist[i].flags |= sock_options; else if (operation == EGG_OPTION_UNSET) socklist[i].flags &= ~sock_options; else return -2; return 0; } return -1; } int sock_read(bd::Stream& stream) { int fd = -1; bd::String buf, type; while (stream.tell() < stream.length()) { buf = stream.getline().chomp(); if (buf == STR("+sock")) return fd; type = newsplit(buf); if (type == STR("sock")) { int sock = atoi(newsplit(buf).c_str()), options = atoi(newsplit(buf).c_str()); fd = allocsock(sock, options); } if (fd >= 0) { #ifdef USE_IPV6 if (type == STR("af")) socklist[fd].af = atoi(buf.c_str()); #endif if (type == STR("host")) socklist[fd].host = strdup(buf.c_str()); if (type == STR("port")) socklist[fd].port = atoi(buf.c_str()); } } return -1; } void sock_write(bd::Stream &stream, int fd) { if (socklist[fd].sock > 0) { bd::String buf; stream << bd::String::printf(STR("-sock\n")); stream << bd::String::printf(STR("sock %d %d\n"), socklist[fd].sock, socklist[fd].flags); #ifdef USE_IPV6 stream << bd::String::printf(STR("af %u\n"), socklist[fd].af); #endif if (socklist[fd].host) stream << bd::String::printf(STR("host %s\n"), socklist[fd].host); if (socklist[fd].port) stream << bd::String::printf(STR("port %d\n"), socklist[fd].port); stream << bd::String::printf(STR("+sock\n")); } } /* Return a free entry in the socket entry */ int allocsock(int sock, int options) { for (int i = 0; i < MAXSOCKS; i++) { if (socklist[i].flags & SOCK_UNUSED) { /* yay! there is table space */ socklist[i].inbuf = NULL; socklist[i].outbuf = NULL; socklist[i].flags = options; socklist[i].sock = sock; socklist[i].encstatus = 0; socklist[i].enclink = -1; socklist[i].gz = 0; bzero(&(socklist[i].okey), ENC_KEY_LEN + 1); bzero(&(socklist[i].ikey), ENC_KEY_LEN + 1); socks_total++; sdprintf("allocsock(%d) = %d", i, sock); return i; } } fatal("Socket table is full!", 0); return -1; /* Never reached */ } /* Request a normal socket for i/o */ void setsock(int sock, int options) { int i = allocsock(sock, options); bool parm; if (((sock != STDOUT) || backgrd) && !(socklist[i].flags & SOCK_NONSOCK)) { parm = 1; setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *) &parm, sizeof(int)); parm = 0; setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *) &parm, sizeof(int)); } if (options & SOCK_LISTEN) { /* Tris says this lets us grab the same port again next time */ parm = 1; setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &parm, sizeof(int)); } /* Yay async i/o ! */ fcntl(sock, F_SETFL, O_NONBLOCK); } #ifdef USE_IPV6 int real_getsock(int options, int af_def, const char *fname, int line) { #else int real_getsock(int options, const char *fname, int line) { int af_def = AF_INET; #endif /* USE_IPV6 */ int sock = -1; if (!af_def) af_def = AF_INET; sock = socket(af_def, SOCK_STREAM, 0); if (sock >= 0) setsock(sock, options); else if (!identd_hack) putlog(LOG_WARNING, "*", "Warning: Can't create new socket! (%s:%d): %s", fname, line, strerror(errno)); else if (identd_hack) identd_hack = 0; return sock; } /* Done with a socket */ void real_killsock(register int sock, const char *file, int line) { if (sock < 0) { putlog(LOG_ERRORS, "*", "Attempt to kill socket -1 %s:%d", file, line); return; } int i = -1; if ((i = findanysnum(sock)) != -1) { #ifdef EGG_SSL_EXT if (socklist[i].ssl) { SSL_shutdown(socklist[i].ssl); SSL_free(socklist[i].ssl); socklist[i].ssl = NULL; } #endif close(socklist[i].sock); if (socklist[i].inbuf != NULL) { delete socklist[i].inbuf; socklist[i].inbuf = NULL; } if (socklist[i].outbuf != NULL) { delete socklist[i].outbuf; socklist[i].outbuf = NULL; } if (socklist[i].host) free(socklist[i].host); bzero(&socklist[i], sizeof(socklist[i])); socklist[i].flags = SOCK_UNUSED; socks_total--; sdprintf("killsock(%d, %s, %d) (socklist: %d)", sock, file, line, i); return; } putlog(LOG_MISC, "*", "Attempt to kill un-allocated socket %d %s:%d !!", sock, file, line); } /* Send connection request to proxy */ static int proxy_connect(int sock, const char *ip, port_t port, int proxy_type) { sdprintf("proxy_connect(%d, %s, %d, %d)", sock, ip, port, proxy_type); #ifdef USE_IPV6 unsigned char x[32] = ""; int af_ty = sockprotocol(sock); #else unsigned char x[10] = ""; #endif /* USE_IPV6 */ char s[256] = ""; /* socks proxy */ if (proxy_type == PROXY_SOCKS) { /* numeric IP? */ if (is_dotted_ip(ip)) { in_addr_t ipaddr = ((in_addr_t) inet_addr(ip)); memcpy(x, &ipaddr, 4); } else { /* if not resolved, resolve it with blocking calls.. (shouldn't happen ever) */ return -1; } int i = -1; if ((i = findanysnum(sock)) != -1) socklist[i].flags |= SOCK_PROXYWAIT; #ifdef USE_IPV6 if (af_ty == AF_INET6) simple_snprintf(s, sizeof s, "\004\001%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%s", (port >> 8) % 256, (port % 256), x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[9], x[9], x[10], x[11], x[12], x[13], x[14], x[15], botuser); else #endif /* USE_IPV6 */ simple_snprintf(s, sizeof s, "\004\001%c%c%c%c%c%c%s", (port >> 8) % 256, (port % 256), x[0], x[1], x[2], x[3], botuser); tputs(sock, s, strlen(botuser) + 9); } else if (proxy_type == PROXY_SUN) { size_t len = simple_snprintf(s, sizeof s, "%s %d\n", ip, port); tputs(sock, s, len); } else if (proxy_type == PROXY_HTTP) { size_t len = simple_snprintf(s, sizeof s, "CONNECT %s:%d\n\n", ip, port); tputs(sock, s, len); } return sock; } /* FIXME: REPLACE WITH SOCK_NAME() */ void initialize_sockaddr(int af_type, const char *host, port_t port, union sockaddr_union *so) { bzero(so, sizeof(*so)); so->sa.sa_family = af_type; if (af_type == AF_INET) { so->sin.sin_family = AF_INET; if (host) { inet_pton(AF_INET, host, &so->sin.sin_addr); so->sin.sin_port = htons(port); } else { so->sin.sin_addr.s_addr = getmyip(); } #ifdef USE_IPV6 } else { so->sin6.sin6_family = AF_INET6; if (host) { inet_pton(AF_INET6, host, &so->sin6.sin6_addr); so->sin6.sin6_port = htons(port); } else { memcpy(&so->sin6.sin6_addr, &cached_myip6_so.sin6.sin6_addr, 16); } #endif /* USE_IPV6 */ } } /* Starts a connection attempt to a socket * * If given a normal hostname, this will be resolved to the corresponding * IP address first. PLEASE try to use the non-blocking dns functions * instead and then call this function with the IP address to avoid blocking. * * returns <0 if connection refused: * -1 strerror()/errno type error * -2 can't resolve hostname */ int open_telnet_raw(int sock, const char *ipIn, port_t sport, bool proxy_on, int identd) { static port_t port = 0; union sockaddr_union so; char ip[121] = ""; int is_resolved = 0; volatile int proxy_type = 0, proxy = proxy_on; /* firewall? use socks */ if (proxy) { switch (firewall[0]) { case '!': proxy_type = PROXY_SUN; strlcpy(ip, &firewall[1], sizeof(ip)); break; case '@': proxy_type = PROXY_HTTP; strlcpy(ip, &firewall[1], sizeof(ip)); break; default: proxy_type = PROXY_SOCKS; strlcpy(ip, firewall, sizeof(ip)); break; } port = firewallport; } else { proxy_type = 0; strlcpy(ip, ipIn, sizeof(ip)); port = sport; } socklen_t socklen; if (sport) { /* figure out which ip to bind to locally (v4 or v6) based on what the host ip is .. */ if ((is_resolved = is_dotted_ip(ip))) { /* already resolved */ /* bind to our cached ip for v4/v6 depending on what the ip is */ initialize_sockaddr(is_resolved, NULL, 0, &so); if (bind(sock, &so.sa, SIZEOF_SOCKADDR(so)) < 0) { putlog(LOG_DEBUG, "*", "Failed to bind to socket %d: %s", sock, strerror(errno)); killsock(sock); return -1; } /* initialize so for connect using the host/port */ initialize_sockaddr(is_resolved, ip, port, &so); } else { /* if not resolved, resolve it with blocking calls.. (shouldn't happen ever) */ sdprintf("WARNING: open_telnet_raw(%s,%d) was passed an unresolved hostname.", ip, port); killsock(sock); return -1; } socklen = SIZEOF_SOCKADDR(so); } else { // Unix domain socket so.sock_un.sun_family = AF_UNIX; strcpy(so.sock_un.sun_path, ip); socklen = SUN_LEN(&so.sock_un); } int i = -1; if ((i = findanysnum(sock)) != -1) { socklist[i].flags = (socklist[i].flags & ~SOCK_VIRTUAL) | SOCK_CONNECT; socklist[i].host = strdup(ipIn); socklist[i].port = port; } if (identd && sport) //Only open identd if not a unix domain socket identd_open(myipstr(is_resolved), ipIn, identd); int rc = -1; /* make the connect attempt */ rc = connect(sock, (struct sockaddr *)&so.sa, socklen); if (rc < 0) { if (errno == EINPROGRESS) { debug3("net: connect(%d, %s, %d)", sock, ipIn, sport); /* Firewall? announce connect attempt to proxy */ if (proxy) return proxy_connect(sock, ipIn, sport, proxy_type); return sock; /* async success! */ } else { sdprintf("connect(%d, %s, %d) failed: %s", sock, ip, sport, strerror(errno)); killsock(sock); return -1; } } /* Synchronous? :/ */ debug3("net: (BLOCKING) connect(%d, %s, %d)", sock, ipIn, sport); if (proxy) return proxy_connect(sock, ipIn, sport, proxy_type); return sock; } #ifdef EGG_SSL_EXT int net_switch_to_ssl(int sock) { int i = 0; debug0("net_switch_to_ssl()"); sleep(3); // Give some time to let the connect() go through. i = findanysnum(sock); if (i == MAXSOCKS) { debug0("Error while swithing to SSL - sock not found in list"); return 0; } if (socklist[i].ssl) { debug0("Error while swithing to SSL - already in ssl"); return 0; } socklist[i].ssl = SSL_new(ssl_ctx); if (!socklist[i].ssl) { debug0("Error while swithing to SSL - SSL_new() error"); return 0; } SSL_set_fd(socklist[i].ssl, socklist[i].sock); int err = 0, timeout = 0; while ((err = SSL_connect(socklist[i].ssl)) <= 0) { if (timeout++ > 500) { err = 0; break; } int errs = SSL_get_error(socklist[i].ssl,err); if ((errs != SSL_ERROR_WANT_READ) && (errs != SSL_ERROR_WANT_WRITE) && (errs != SSL_ERROR_WANT_X509_LOOKUP)) { putlog(LOG_DEBUG, "*", "SSL_connect() = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); goto error; } usleep(1000); } if (err == 1) { debug0("SSL_connect() success"); return 1; } error: debug0("Error while SSL_connect()"); SSL_shutdown(socklist[i].ssl); SSL_free(socklist[i].ssl); socklist[i].ssl = NULL; return 0; } #endif /* Ordinary non-binary connection attempt */ int open_telnet(const char *ip, port_t port, bool proxy, int identd) { int sock = -1; #ifdef USE_IPV6 sock = getsock(0, is_dotted_ip(ip)); #else sock = getsock(0); #endif /* USE_IPV6 */ if (sock >= 0) return open_telnet_raw(sock, ip, port, proxy, identd); return -1; } /* Returns a socket number for a listening socket that will accept any * connection on a certain address -- port # is returned in port * * 'addr' is ignored if af_def is AF_INET6 -poptix (02/03/03) */ #ifdef USE_IPV6 int open_address_listen(const char* ip, int af_def, port_t *port) { #else int open_address_listen(const char* ip, port_t *port) { int af_def = AF_INET; #endif /* USE_IPV6 */ // if (firewall[0]) { // /* FIXME: can't do listen port thru firewall yet */ // putlog(LOG_MISC, "*", "!! Cant open a listen port (you are using a firewall)"); // return -1; // } int sock = 0; socklen_t addrlen; union sockaddr_union name; #ifdef USE_IPV6 if (af_def == AF_INET6) { struct sockaddr_in6 name6; sock = getsock(SOCK_LISTEN, af_def); if (sock < 0) return -1; debug2("Opening listen socket on port %d with AF_INET6, sock: %d", *port, sock); bzero((char *) &name6, sizeof(name6)); name6.sin6_family = af_def; name6.sin6_port = htons(*port); /* 0 = just assign us a port */ /* memcpy(&name6.sin6_addr, &in6addr_any, 16); */ /* this is the only way to get ipv6+ipv4 in 1 socket */ memcpy(&name6.sin6_addr, &cached_myip6_so.sin6.sin6_addr, 16); if (bind(sock, (struct sockaddr *) &name6, sizeof(name6)) < 0) { if (!(identd_hack && *port == 113)) putlog(LOG_DEBUG, "*", "Failed to bind to socket %d for listen on port %d: %s", sock, *port, strerror(errno)); killsock(sock); return -1; } addrlen = sizeof(name6); if (getsockname(sock, (struct sockaddr *) &name6, &addrlen) < 0) { if (!(identd_hack && *port == 113)) putlog(LOG_DEBUG, "*", "Failed to getsockname on socket %d for listen on port %d: %s", sock, *port, strerror(errno)); killsock(sock); return -1; } *port = ntohs(name6.sin6_port); if (listen(sock, 1) < 0) { if (!(identd_hack && *port == 113)) putlog(LOG_DEBUG, "*", "Failed to listen on socket %d for listen on port %d: %s", sock, *port, strerror(errno)); killsock(sock); return -1; } } else { sock = getsock(SOCK_LISTEN, af_def); #else sock = getsock(SOCK_LISTEN); #endif /* USE_IPV6 */ if (sock < 0) return -1; if (af_def == AF_UNIX) debug2("Opening listen socket on %s, sock: %d", ip, sock); else debug3("Opening listen socket on %s:%d with AF_INET, sock: %d", ip, *port, sock); bzero((char *) &name, sizeof(struct sockaddr *)); if (af_def == AF_UNIX) { name.sock_un.sun_family = AF_UNIX; strcpy(name.sock_un.sun_path, ip); unlink(name.sock_un.sun_path); addrlen = SUN_LEN(&name.sock_un); } else { name.sin.sin_family = af_def; name.sin.sin_port = htons(*port); /* 0 = just assign us a port */ name.sin.sin_addr.s_addr = inet_addr(ip); addrlen = sizeof(struct sockaddr_in); } if (bind(sock, (struct sockaddr *) &name, addrlen) < 0) { if (!(identd_hack && *port == 113)) { if (af_def == AF_UNIX) putlog(LOG_DEBUG, "*", "Failed to bind to socket %d for listen on %s: %s", sock, ip, strerror(errno)); else putlog(LOG_DEBUG, "*", "Failed to bind to socket %d for listen on %s:%d: %s", sock, ip, *port, strerror(errno)); } killsock(sock); return -1; } if (af_def != AF_UNIX) { /* what port are we on? */ if (getsockname(sock, (struct sockaddr *) &name, &addrlen) < 0) { if (!(identd_hack && *port == 113)) putlog(LOG_DEBUG, "*", "Failed to getsockname on socket %d for listen on port %d: %s", sock, *port, strerror(errno)); killsock(sock); return -1; } *port = ntohs(name.sin.sin_port); } if (listen(sock, 1) < 0) { if (!(identd_hack && *port == 113) && af_def != AF_UNIX) putlog(LOG_DEBUG, "*", "Failed to listen on socket %d for on port %d: %s", sock, *port, strerror(errno)); killsock(sock); return -1; } #ifdef USE_IPV6 } #endif /* USE_IPV6 */ if (af_def == AF_UNIX) debug2("Opened listen socket on %s, sock: %d", ip, sock); else debug3("Opened listen socket on %s:%d with AF_INET, sock: %d", ip, *port, sock); return sock; } /* Returns a socket number for a listening socket that will accept any * connection -- port # is returned in port */ int open_listen(port_t *port) { #ifdef USE_IPV6 return open_address_listen(iptostr(getmyip()), AF_INET, port); #else return open_address_listen(iptostr(getmyip()), port); #endif /* USE_IPV6 */ } /* Same as above, except this one can be called with an AF_ type * the above is being left in for compatibility, and should NOT LONGER BE USED IN THE CORE CODE. */ int open_listen_by_af(port_t *port, int af_def) { #ifdef USE_IPV6 return open_address_listen(iptostr(getmyip()), af_def, port); #else return -1; #endif /* USE_IPV6 */ } int open_listen_addr_by_af(const char *ip, port_t *port, int af_def) { if (!ip) ip = iptostr(getmyip()); #ifdef USE_IPV6 return open_address_listen(ip, af_def, port); #else return -1; #endif /* USE_IPV6 */ } /* Returns the given network byte order IP address in the * dotted format - "##.##.##.##" */ char *iptostr(in_addr_t ip) { static char ipbuf[32]; struct in_addr a; a.s_addr = ip; return (char *) inet_ntop(AF_INET, &a, ipbuf, sizeof(ipbuf)); } /* Short routine to answer a connect received on a socket made previously * by open_listen ... returns hostname of the caller & the new socket * does NOT dispose of old "public" socket! */ int answer(int sock, char *caller, in_addr_t *ip, port_t *port, int binary) { int new_sock; socklen_t addrlen; struct sockaddr_in from; int af_ty = sockprotocol(sock); #ifdef USE_IPV6 struct sockaddr_in6 from6; bzero(&from6, sizeof(struct sockaddr_in6)); if (af_ty == AF_INET6) { addrlen = sizeof(from6); new_sock = accept(sock, (struct sockaddr *) &from6, &addrlen); } else { #endif /* USE_IPV6 */ addrlen = sizeof(struct sockaddr); new_sock = accept(sock, (struct sockaddr *) &from, &addrlen); #ifdef USE_IPV6 } #endif /* USE_IPV6 */ if (new_sock < 0) return -1; if (ip != NULL) { #ifdef USE_IPV6 /* Detect IPv4 in IPv6 mapped address .... */ if (af_ty == AF_INET6 && (!IN6_IS_ADDR_V4MAPPED(&from6.sin6_addr))) { inet_ntop(AF_INET6, &from6.sin6_addr, caller, 119); caller[120] = 0; *ip = 0L; } else if (IN6_IS_ADDR_V4MAPPED(&from6.sin6_addr)) { /* ...and convert it to plain (AF_INET) IPv4 address (openssh) */ struct sockaddr_in *from4 = (struct sockaddr_in *)&from6; struct in_addr addr; memcpy(&addr, ((char *)&from6.sin6_addr) + 12, sizeof(addr)); memset(&from, 0, sizeof(from)); from4->sin_family = AF_INET; addrlen = sizeof(*from4); memcpy(&from4->sin_addr, &addr, sizeof(addr)); *ip = from4->sin_addr.s_addr; strlcpy(caller, iptostr(*ip), 121); *ip = ntohl(*ip); } else { #endif /* USE_IPV6 */ if (af_ty == AF_UNIX) { struct sockaddr_un sock_un; socklen_t socklen = sizeof(sock_un); bzero(&sock_un, socklen); getsockname(sock, (struct sockaddr*) &sock_un, &socklen); strcpy(caller, sock_un.sun_path); *port = 0; } else { *ip = from.sin_addr.s_addr; strlcpy(caller, iptostr(*ip), 121); *ip = ntohl(*ip); } #ifdef USE_IPV6 } #endif /* USE_IPV6 */ } if (port != NULL) { #ifdef USE_IPV6 if (af_ty == AF_INET6) *port = ntohs(from6.sin6_port); else if (af_ty == AF_INET) #endif /* USE_IPV6 */ *port = ntohs(from.sin_port); } /* Set up all the normal socket crap */ setsock(new_sock, (binary ? SOCK_BINARY : 0)); sdprintf("Answered socket %d: %s", new_sock, caller); return new_sock; } /* Like open_telnet, but uses ip & port specifications of dcc Take a longip and make into dotted form */ int open_telnet_dcc(int sock, char *ip, char *port) { port_t p; unsigned long addr; char sv[100] = ""; unsigned char c[4] = ""; #ifdef DEBUG_IPV6 debug1("open_telnet_dcc %s", ip); #endif /* DEBUG_IPV6 */ if (port != NULL) p = atoi(port); else p = 2000; #ifdef USE_IPV6 if (sockprotocol(sock) == AF_INET6) { # ifdef DEBUG_IPV6 debug0("open_telnet_dcc, af_inet6!"); # endif /* DEBUG_IPV6 */ strlcpy(sv, ip, sizeof(sv)); } else { #endif /* USE_IPV6 */ if (ip != NULL) addr = my_atoul(ip); else addr = 0L; if (addr < (1 << 24)) return -3; /* fake address */ c[0] = (addr >> 24) & 0xff; c[1] = (addr >> 16) & 0xff; c[2] = (addr >> 8) & 0xff; c[3] = addr & 0xff; simple_snprintf(sv, sizeof(sv), "%u.%u.%u.%u", c[0], c[1], c[2], c[3]); #ifdef USE_IPV6 } /* strcpy(sv,hostnamefromip(addr)); */ # ifdef DEBUG_IPV6 debug3("open_telnet_raw %s %d %d", sv, sock, p); # endif /* DEBUG_IPV6 */ #endif /* USE_IPV6 */ return open_telnet_raw(sock, sv, p, 0); } /* Attempts to read from all the sockets in socklist * fills s with up to 511 bytes if available, and returns the array index * * on EOF: returns -1, with socket in len * on socket error: returns -2 * if nothing is ready: returns -3 */ static int sockread(char *s, int *len) { fd_set fd; int fds = 0, i, fdtmp, x; struct timeval t; int grab = SGRAB + 1; egg_timeval_t howlong; if (unlikely(timer_get_shortest(&howlong))) { /* No timer, default to 1 second. */ t.tv_sec = 1; t.tv_usec = 0; } else { t.tv_sec = howlong.sec; t.tv_usec = howlong.usec; } FD_ZERO(&fd); for (i = 0; i < MAXSOCKS; i++) { if (!(socklist[i].flags & (SOCK_UNUSED | SOCK_VIRTUAL))) { if (unlikely((socklist[i].sock == STDOUT) && !backgrd)) fdtmp = STDIN; else fdtmp = socklist[i].sock; if (fdtmp > fds) fds = fdtmp; FD_SET(fdtmp, &fd); } } fds++; x = select(fds, &fd, NULL, NULL, &t); if (x > 0) { /* Something happened */ for (i = 0; i < MAXSOCKS; i++) { if ((!(socklist[i].flags & SOCK_UNUSED)) && ((FD_ISSET(socklist[i].sock, &fd)) || #ifdef EGG_SSL_EXT ((socklist[i].ssl) && (SSL_pending(socklist[i].ssl))) || #endif ((socklist[i].sock == STDOUT) && (!backgrd) && (FD_ISSET(STDIN, &fd))))) { if (socklist[i].flags & (SOCK_LISTEN | SOCK_CONNECT)) { /* Listening socket -- don't read, just return activity */ /* Same for connection attempt */ /* (for strong connections, require a read to succeed first) */ if (socklist[i].flags & SOCK_PROXYWAIT) { /* drummer */ /* Hang around to get the return code from proxy */ grab = 10; } else if (!(socklist[i].flags & SOCK_STRONGCONN)) { debug1("net: connect! sock %d", socklist[i].sock); s[0] = 0; *len = 0; return i; } } else if (socklist[i].flags & SOCK_PASS) { s[0] = 0; *len = 0; return i; } errno = 0; if (unlikely((socklist[i].sock == STDOUT) && !backgrd)) { x = read(STDIN, s, grab); #ifdef EGG_SSL_EXT } else if (socklist[i].ssl) { x = SSL_read(socklist[i].ssl,s,grab); if (x <= 0) { int err = SSL_get_error(socklist[i].ssl, x); x = -1; switch (err) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_X509_LOOKUP: errno = EAGAIN; break; case SSL_ERROR_SYSCALL: switch (ERR_get_error()) { case 0: // EOF break; case -1: // I/O error putlog(LOG_DEBUG, "*", "SSL_read() [IO] = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; default: putlog(LOG_DEBUG, "*", "SSL_read() unknown error: %s", strerror(errno)); break; } break; case SSL_ERROR_SSL: putlog(LOG_DEBUG, "*", "SSL_read() = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; } } #endif } else x = read(socklist[i].sock, s, grab); if (x <= 0) { /* eof */ if (errno != EAGAIN) { /* EAGAIN happens when the operation would block on a non-blocking socket, if the socket is going to die, it will die later, otherwise it will connect */ *len = socklist[i].sock; socklist[i].flags &= ~SOCK_CONNECT; debug1("net: eof!(read) socket %d", socklist[i].sock); return -1; } else { debug3("sockread EAGAIN: %d %d (%s)", socklist[i].sock, errno, strerror(errno)); continue; /* EAGAIN */ } } s[x] = 0; *len = x; if (socklist[i].flags & SOCK_PROXYWAIT) { debug2("net: socket: %d proxy errno: %d", socklist[i].sock, s[1]); socklist[i].flags &= ~(SOCK_CONNECT | SOCK_PROXYWAIT); switch (s[1]) { case 90: /* Success */ s[0] = 0; *len = 0; return i; case 91: /* Failed */ errno = ECONNREFUSED; break; case 92: /* No identd */ case 93: /* Identd said wrong username */ /* A better error message would be "socks misconfigured" * or "identd not working" but this is simplest. */ errno = ENETUNREACH; break; } *len = socklist[i].sock; return -1; } return i; } } } else if (x == -1) return -2; /* socket error */ else { s[0] = 0; *len = 0; } return -3; } /* sockgets: buffer and read from sockets * * Attempts to read from all registered sockets for up to one second. if * after one second, no complete data has been received from any of the * sockets, 's' will be empty, 'len' will be 0, and sockgets will return -3. * if there is returnable data received from a socket, the data will be * in 's' (null-terminated if non-binary), the length will be returned * in len, and the socket number will be returned. * normal sockets have their input buffered, and each call to sockgets * will return one line terminated with a '\n'. binary sockets are not * buffered and return whatever coems in as soon as it arrives. * listening sockets will return an empty string when a connection comes in. * connecting sockets will return an empty string on a successful connect, * or EOF on a failed connect. * if an EOF is detected from any of the sockets, that socket number will be * put in len, and -1 will be returned. * the maximum length of the string returned is 512 (including null) * * Returns -4 if we handled something that shouldn't be handled by the * dcc functions. Simply ignore it. */ int sockgets(char *s, int *len) { char xx[SGRAB + 4] = "", *p = NULL; int ret; size_t newline_index = size_t(-1); bool was_crlf = 0; for (int i = 0; i < MAXSOCKS; i++) { /* Check for stored-up data waiting to be processed */ if (!(socklist[i].flags & SOCK_UNUSED) && !(socklist[i].flags & SOCK_BUFFER) && (socklist[i].inbuf != NULL)) { if (!(socklist[i].flags & SOCK_BINARY)) { /* Find EOL */ newline_index = socklist[i].inbuf->find('\n'); if (newline_index != size_t(-1) && newline_index != 0 && socklist[i].inbuf->charAt(newline_index - 1) == '\r') { --newline_index; was_crlf = 1; } if (newline_index != size_t(-1)) { // Split off a line bd::String line(socklist[i].inbuf->substring(0, newline_index)); strlcpy(s, line.c_str(), SGRAB + 1); *(socklist[i].inbuf) += newline_index + 1; if (was_crlf) *(socklist[i].inbuf) += static_cast(1); if (s[0] && socklist[i].encstatus) link_read(i, s, (size_t *) len); *len = strlen(s); return socklist[i].sock; } } else { if (!socklist[i].inbuf) socklist[i].inbuf = new bd::String(); /* i dont think any of this is *ever* called */ /* Handling buffered binary data (must have been SOCK_BUFFER before). */ if (socklist[i].inbuf->length() <= SGRAB) { *len = socklist[i].inbuf->length(); memcpy(s, socklist[i].inbuf->data(), socklist[i].inbuf->length()); delete socklist[i].inbuf; socklist[i].inbuf = NULL; } else { /* Split up into chunks of SGRAB bytes. */ *len = SGRAB; memcpy(s, socklist[i].inbuf->data(), *len); *(socklist[i].inbuf) += static_cast(*len); } return socklist[i].sock; } } /* Also check any sockets that might have EOF'd during write */ if (!(socklist[i].flags & SOCK_UNUSED) && (socklist[i].flags & SOCK_EOFD)) { s[0] = 0; *len = socklist[i].sock; return -1; } } /* No pent-up data of any worth -- down to business */ *len = 0; ret = sockread(xx, len); if (ret < 0) { s[0] = 0; return ret; } /* Binary, listening and passed on sockets don't get buffered. */ if (socklist[ret].flags & SOCK_CONNECT) { if (socklist[ret].flags & SOCK_STRONGCONN) { socklist[ret].flags &= ~SOCK_STRONGCONN; /* Buffer any data that came in, for future read. */ socklist[ret].inbuf = new bd::String(xx, *len); } socklist[ret].flags &= ~SOCK_CONNECT; s[0] = 0; return socklist[ret].sock; } if (socklist[ret].flags & SOCK_BINARY) { memcpy(s, xx, *len); return socklist[ret].sock; } if ((socklist[ret].flags & SOCK_LISTEN) || (socklist[ret].flags & SOCK_PASS)) return socklist[ret].sock; if (socklist[ret].flags & SOCK_BUFFER) { if (!socklist[ret].inbuf) socklist[ret].inbuf = new bd::String(xx, *len); else *(socklist[ret].inbuf) += bd::String(xx, *len); return -4; /* Ignore this one. */ } /* Might be necessary to prepend stored-up data! */ if (socklist[ret].inbuf != NULL) { *(socklist[ret].inbuf) += bd::String(xx); if (socklist[ret].inbuf->length() < (SGRAB + 2)) { strlcpy(xx, socklist[ret].inbuf->c_str(), sizeof(xx)); delete socklist[ret].inbuf; socklist[ret].inbuf = NULL; } else { // Take out an SGRAB sized chunk and advance the buffer strlcpy(xx, socklist[ret].inbuf->c_str(), SGRAB + 1); *(socklist[ret].inbuf) += static_cast(SGRAB); /* (leave the rest to be post-pended later) */ } } bool data = 0; /* Look for EOL marker; if it's there, i have something to show */ p = strchr(xx, '\n'); if (p == NULL) p = strchr(xx, '\r'); if (p != NULL) { *p = 0; strlcpy(s, xx, SGRAB + 10); //buf@main.c memmove(xx, p + 1, strlen(p + 1) + 1); /* if (s[0] && strlen(s) && (s[strlen(s) - 1] == '\r')) */ if (strlen(s) && s[strlen(s) - 1] == '\r') s[strlen(s) - 1] = 0; data = 1; /* DCC_CHAT may now need to process a blank line */ /* NO! */ /* if (!s[0]) strcpy(s," "); */ } else { s[0] = 0; if (strlen(xx) >= SGRAB) { /* String is too long, so just insert fake \n */ strlcpy(s, xx, SGRAB + 10); //buf@main.c xx[0] = 0; data = 1; } } if (s[0] && socklist[ret].encstatus) link_read(ret, s, (size_t *) len); *len = strlen(s); /* Anything left that needs to be saved? */ if (!xx[0]) { if (data) return socklist[ret].sock; else return -3; } /* Prepend old data back */ if (socklist[ret].inbuf != NULL) { socklist[ret].inbuf->insert(0, xx); } else { socklist[ret].inbuf = new bd::String(xx); } if (data) { return socklist[ret].sock; } else { return -3; } } /* Dump something to a socket * * NOTE: Do NOT put Contexts in here if you want DEBUG to be meaningful!! */ void tputs(register int z, const char *s, size_t len) { if (z < 0) /* um... HELLO?! sanity check please! */ return; if (((z == STDOUT) || (z == STDERR)) && (!backgrd || use_stderr)) { if (write(z, s, len) == -1) { ; } return; } register int x, idx; int i = -1; if ((i = findanysnum(z)) != -1) { if ((idx = findanyidx(z)) != -1 && dcc[idx].type->name) { if (!strncmp(dcc[idx].type->name, "BOT", 3)) traffic.out_today.bn += len; else if (!strcmp(dcc[idx].type->name, "SERVER")) traffic.out_today.irc += len; else if (!strncmp(dcc[idx].type->name, "CHAT", 4)) traffic.out_today.dcc += len; else if (!strncmp(dcc[idx].type->name, "FILES", 5)) traffic.out_today.filesys += len; else if (!strcmp(dcc[idx].type->name, "SEND")) traffic.out_today.trans += len; else if (!strncmp(dcc[idx].type->name, "GET", 3)) traffic.out_today.trans += len; else traffic.out_today.unknown += len; } if (len && socklist[i].encstatus) s = link_write(i, s, &len); #ifdef HAVE_ZLIB_H /* if (socklist[i].gz) { FILE *fp; fp = gzdopen(z, "wb0"); x = gzwrite(fp, s, len); } else */ #endif /* HAVE_ZLIB_H */ if (socklist[i].outbuf != NULL) { /* Already queueing: just add it */ *(socklist[i].outbuf) += bd::String(s, len); return; } #ifdef EGG_SSL_EXT if (socklist[i].ssl) { x = SSL_write(socklist[i].ssl,s,len); if (x <= 0) { int err = SSL_get_error(socklist[i].ssl, x); x = -1; switch (err) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_X509_LOOKUP: errno = EAGAIN; break; case SSL_ERROR_SYSCALL: switch (ERR_get_error()) { case 0: // EOF break; case -1: // I/O error putlog(LOG_DEBUG, "*", "SSL_write() [IO] = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; default: putlog(LOG_DEBUG, "*", "SSL_write() unknown error: %s", strerror(errno)); break; } break; case SSL_ERROR_SSL: putlog(LOG_DEBUG, "*", "SSL_write() = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; } } } else #endif /* Try. */ x = write(z, s, len); if (x == -1) x = 0; if ((size_t) x < len) { /* Socket is full, queue it */ socklist[i].outbuf = new bd::String(&s[x], len - x); } // if (socklist[i].encstatus && s) // free(s); return; } /* Make sure we don't cause a crash by looping here */ static int inhere = 0; if (unlikely(!inhere)) { inhere = 1; putlog(LOG_MISC, "*", "!!! writing to nonexistent socket: %d", z); if (strlen(s)) { char *tmp = strdup(s); /* To null-terminate */ putlog(LOG_MISC, "*", "!-> '%s'", tmp); free(tmp); } inhere = 0; } /* if (socklist[i].encstatus > 0) free(s); */ } int findanysnum(register int sock) { register int i = 0; if (sock != -1) for (i = 0; i < MAXSOCKS; i++) if ((socklist[i].sock == sock) && !(socklist[i].flags & SOCK_UNUSED)) return i; return -1; } int findanyidx(int sock) { if (sock != -1) for (int idx = 0; idx < dcc_total; ++idx) if (dcc[idx].type && dcc[idx].sock == sock) return idx; return -1; } /* tputs might queue data for sockets, let's dump as much of it as * possible. */ void dequeue_sockets() { int i, x, z = 0, fds = 0; fd_set wfds; struct timeval tv; /* ^-- start poptix test code, this should avoid writes to sockets not ready to be written to. */ FD_ZERO(&wfds); tv.tv_sec = 0; tv.tv_usec = 0; /* we only want to see if it's ready for writing, no need to actually wait.. */ for (i = 0; i < MAXSOCKS; i++) { if (!(socklist[i].flags & SOCK_UNUSED) && socklist[i].outbuf != NULL) { FD_SET(socklist[i].sock, &wfds); if (socklist[i].sock > fds) fds = socklist[i].sock; z = 1; } } if (!z) return; /* nothing to write */ fds++; select(fds, NULL, &wfds, NULL, &tv); /* end poptix */ for (i = 0; i < MAXSOCKS; i++) { if (!(socklist[i].flags & SOCK_UNUSED) && (socklist[i].outbuf != NULL) && (FD_ISSET(socklist[i].sock, &wfds))) { /* Trick tputs into doing the work */ errno = 0; #ifdef EGG_SSL_EXT if (socklist[i].ssl) { x = SSL_write(socklist[i].ssl, socklist[i].outbuf->data(), socklist[i].outbuf->length()); if (x <= 0) { int err = SSL_get_error(socklist[i].ssl, x); x = -1; switch (err) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_X509_LOOKUP: errno = EAGAIN; break; case SSL_ERROR_SYSCALL: switch (ERR_get_error()) { case 0: // EOF break; case -1: // I/O error putlog(LOG_DEBUG, "*", "SSL_write()/dequeue_sockets() [IO] = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; default: putlog(LOG_DEBUG, "*", "SSL_write() unknown error: %s", strerror(errno)); break; } break; case SSL_ERROR_SSL: putlog(LOG_DEBUG, "*", "SSL_write()/dequeue_sockets() = %d, %s", err, (char *)ERR_error_string(ERR_get_error(), NULL)); break; } } } else #endif x = write(socklist[i].sock, socklist[i].outbuf->data(), socklist[i].outbuf->length()); if ((x < 0) && (errno != EAGAIN) #ifdef EBADSLT && (errno != EBADSLT) #endif /* EBADSLT */ #ifdef ENOTCONN && (errno != ENOTCONN) #endif /* EBADSLT */ ) { /* This detects an EOF during writing */ debug3("net: eof!(write) socket %d (%s,%d)", socklist[i].sock, strerror(errno), errno); socklist[i].flags |= SOCK_EOFD; } else if ((size_t) x == socklist[i].outbuf->length()) { /* If the whole buffer was sent, nuke it */ delete socklist[i].outbuf; socklist[i].outbuf = NULL; } else if (x > 0) { *(socklist[i].outbuf) += static_cast(x); } else { debug3("dequeue_sockets(): errno = %d (%s) on %d", errno, strerror(errno), socklist[i].sock); } /* All queued data was sent. Call handler if one exists and the * dcc entry wants it. */ if (!socklist[i].outbuf) { int idx = findanyidx(socklist[i].sock); if (idx >= 0 && dcc[idx].type && dcc[idx].type->outdone) dcc[idx].type->outdone(idx); } } } } /* * Debugging stuff */ void tell_netdebug(int idx) { char s[80] = ""; dprintf(idx, "Open sockets:"); for (int i = 0; i < MAXSOCKS; i++) { if (!(socklist[i].flags & SOCK_UNUSED)) { simple_snprintf(s, sizeof(s), " %d", socklist[i].sock); if (socklist[i].flags & SOCK_BINARY) strlcat(s, " (binary)", sizeof(s)); if (socklist[i].flags & SOCK_LISTEN) strlcat(s, " (listen)", sizeof(s)); if (socklist[i].flags & SOCK_PASS) strlcat(s, " (passed on)", sizeof(s)); if (socklist[i].flags & SOCK_CONNECT) strlcat(s, " (connecting)", sizeof(s)); if (socklist[i].flags & SOCK_STRONGCONN) strlcat(s, " (strong)", sizeof(s)); if (socklist[i].flags & SOCK_NONSOCK) strlcat(s, " (file)", sizeof(s)); if (socklist[i].inbuf != NULL) simple_sprintf(&s[strlen(s)], " (inbuf: %zu)", socklist[i].inbuf ? socklist[i].inbuf->length() : 0); if (socklist[i].outbuf != NULL) simple_sprintf(&s[strlen(s)], " (outbuf: %zu)", socklist[i].outbuf ? socklist[i].outbuf->length() : 0); if (socklist[i].host) simple_sprintf(&s[strlen(s)], " (%s:%d)", socklist[i].host, socklist[i].port); strlcat(s, ",", sizeof(s)); dprintf(idx, "%s", s); } } dprintf(idx, " done.\n"); } /* Checks wether the referenced socket has data queued. * * Returns true if the incoming/outgoing (depending on 'type') queues * contain data, otherwise false. */ bool sock_has_data(int type, int sock) { bool ret = 0; int i = -1; if ((i = findanysnum(sock)) != -1) { switch (type) { case SOCK_DATA_OUTGOING: ret = (socklist[i].outbuf != NULL); break; case SOCK_DATA_INCOMING: ret = (socklist[i].inbuf != NULL); break; } } else debug1("sock_has_data: could not find socket #%d, returning false.", sock); return ret; } bool socket_run() { static int socket_cleanup = 0; char buf[SGRAB + 10] = ""; int i = 0, idx = 0; /* Only do this every so often. */ if (!socket_cleanup) { socket_cleanup = 5; /* Check for server or dcc activity. */ dequeue_sockets(); } else --socket_cleanup; int xx = sockgets(buf, &i); if (xx >= 0) { /* Non-error */ if ((idx = findanyidx(xx)) != -1) { if (likely(dcc[idx].type->activity)) { /* Traffic stats */ if (dcc[idx].type->name) { ContextNote(dcc[idx].type->name, buf); if (!strncmp(dcc[idx].type->name, "BOT", 3)) traffic.in_today.bn += i + 1; else if (!strcmp(dcc[idx].type->name, "SERVER")) traffic.in_today.irc += i + 1; else if (!strncmp(dcc[idx].type->name, "CHAT", 4)) traffic.in_today.dcc += i + 1; else if (!strncmp(dcc[idx].type->name, "FILES", 5)) traffic.in_today.dcc += i + 1; else if (!strcmp(dcc[idx].type->name, "SEND")) traffic.in_today.trans += i + 1; else if (!strncmp(dcc[idx].type->name, "GET", 3)) traffic.in_today.trans += i + 1; else traffic.in_today.unknown += i + 1; } dcc[idx].type->activity(idx, buf, (size_t) i); } else putlog(LOG_MISC, "*", STR("!!! untrapped dcc activity: type %s, sock %d"), dcc[idx].type->name, dcc[idx].sock); } } else if (unlikely(xx == -1)) { /* EOF from someone */ if (unlikely(i == STDOUT && !backgrd)) fatal(STR("END OF FILE ON TERMINAL"), 0); if ((idx = findanyidx(i)) != -1) { sdprintf(STR("EOF on '%s' idx: %d"), dcc[idx].type ? dcc[idx].type->name : "unknown", idx); if (likely(dcc[idx].type->eof)) dcc[idx].type->eof(idx); else { putlog(LOG_MISC, "*", STR("*** ATTENTION: DEAD SOCKET (%d) OF TYPE %s UNTRAPPED"), i, dcc[idx].type ? dcc[idx].type->name : "*UNKNOWN*"); killsock(i); lostdcc(idx); } } else if (unlikely(idx == -1)) { putlog(LOG_MISC, "*", STR("(@) EOF socket %d, not a dcc socket, not anything."), i); close(i); killsock(i); } } else if (unlikely(xx == -2 && errno != EINTR)) { /* select() error */ putlog(LOG_MISC, "*", STR("* Socket error #%d; recovering."), errno); for (i = 0; i < dcc_total; i++) { if (dcc[i].type && dcc[i].sock != -1 && (fcntl(dcc[i].sock, F_GETFD, 0) == -1) && (errno = EBADF)) { putlog(LOG_MISC, "*", STR("DCC socket %d (type %s, name '%s') expired -- pfft"), dcc[i].sock, dcc[i].type->name, dcc[i].nick); killsock(dcc[i].sock); lostdcc(i); i--; } } } else if (xx == -3) { /* Idle */ socket_cleanup = 0; /* If we've been idle, cleanup & flush */ return 1; } return 0; }