/* static void comm_connect_tryconnect(int fd, void *notused)
* Input: The fd, the handler data(unused).
* Output: None.
* Side-effects: Try and connect with pending connect data for the FD. If
* we succeed or get a fatal error, call the callback.
* Otherwise, it is still blocking or something, so register
* to select for a write event on this FD.
*/
static void
comm_connect_tryconnect(int fd, void *notused)
{
int retval;
fde_t *F = &fd_table[fd];
if(F->connect.callback == NULL)
return;
/* Try the connect() */
retval = connect(fd,
(struct sockaddr *) &fd_table[fd].connect.hostaddr,
GET_SS_LEN(fd_table[fd].connect.hostaddr));
/* Error? */
if(retval < 0)
{
/*
* If we get EISCONN, then we've already connect()ed the socket,
* which is a good thing.
* -- adrian
*/
if(errno == EISCONN)
comm_connect_callback(F->fd, COMM_OK);
else if(ignoreErrno(errno))
/* Ignore error? Reschedule */
comm_setselect(F->fd, FDLIST_SERVER, COMM_SELECT_WRITE|COMM_SELECT_RETRY,
comm_connect_tryconnect, NULL, 0);
else
/* Error? Fail with COMM_ERR_CONNECT */
comm_connect_callback(F->fd, COMM_ERR_CONNECT);
return;
}
/* If we get here, we've suceeded, so call with COMM_OK */
comm_connect_callback(F->fd, COMM_OK);
}
/*
* comm_connect_dns_callback() - called at the completion of the DNS request
*
* The DNS request has completed, so if we've got an error, return it,
* otherwise we initiate the connect()
*/
static void
comm_connect_dns_callback(void *vptr, struct DNSReply *reply)
{
fde_t *F = vptr;
if (reply == NULL)
{
MyFree(F->dns_query);
F->dns_query = NULL;
comm_connect_callback(F, COMM_ERR_DNS);
return;
}
/* No error, set a 10 second timeout */
comm_settimeout(F, 30*1000, comm_connect_timeout, NULL);
/* Copy over the DNS reply info so we can use it in the connect() */
/*
* Note we don't fudge the refcount here, because we aren't keeping
* the DNS record around, and the DNS cache is gone anyway..
* -- adrian
*/
memcpy(&F->connect.hostaddr, &reply->addr, reply->addr.ss_len);
/* The cast is hacky, but safe - port offset is same on v4 and v6 */
((struct sockaddr_in *) &F->connect.hostaddr)->sin_port =
F->connect.hostaddr.ss_port;
F->connect.hostaddr.ss_len = reply->addr.ss_len;
/* Now, call the tryconnect() routine to try a connect() */
MyFree(F->dns_query);
F->dns_query = NULL;
comm_connect_tryconnect(F, NULL);
}
/*
* comm_connect_dns_callback() - called at the completion of the DNS request
*
* The DNS request has completed, so if we've got an error, return it,
* otherwise we initiate the connect()
*/
static void
comm_connect_dns_callback(void *vptr, struct DNSReply *reply)
{
fde_t *F = vptr;
/* Free dns_query now to avoid double reslist free -- jilles */
MyFree(F->dns_query);
F->dns_query = NULL;
if(!reply)
{
comm_connect_callback(F->fd, COMM_ERR_DNS);
return;
}
/* No error, set a 10 second timeout */
comm_settimeout(F->fd, 30 * 1000, comm_connect_timeout, NULL);
/* Copy over the DNS reply info so we can use it in the connect() */
#ifdef IPV6
if(reply->addr.ss_family == AF_INET6)
{
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&F->connect.hostaddr;
memcpy(&in6->sin6_addr, &((struct sockaddr_in6 *)&reply->addr)->sin6_addr, sizeof(struct in6_addr));
}
else
#endif
{
struct sockaddr_in *in = (struct sockaddr_in *)&F->connect.hostaddr;
in->sin_addr.s_addr = ((struct sockaddr_in *)&reply->addr)->sin_addr.s_addr;
}
/* Now, call the tryconnect() routine to try a connect() */
comm_connect_tryconnect(F->fd, NULL);
}
/*
* comm_connect_dns_callback() - called at the completion of the DNS request
*
* The DNS request has completed, so if we've got an error, return it,
* otherwise we initiate the connect()
*/
static void
comm_connect_dns_callback(void *vptr, adns_answer * reply)
{
fde_t *F = vptr;
if(!reply)
{
comm_connect_callback(F->fd, COMM_ERR_DNS);
return;
}
if(reply->status != adns_s_ok)
{
/* Yes, callback + return */
comm_connect_callback(F->fd, COMM_ERR_DNS);
MyFree(reply);
MyFree(F->dns_query);
F->dns_query = NULL;
return;
}
/* No error, set a 10 second timeout */
comm_settimeout(F->fd, 30 * 1000, comm_connect_timeout, NULL);
/* Copy over the DNS reply info so we can use it in the connect() */
/*
* Note we don't fudge the refcount here, because we aren't keeping
* the DNS record around, and the DNS cache is gone anyway..
* -- adrian
*/
#ifdef IPV6
if(reply->rrs.addr->addr.sa.sa_family == AF_INET6)
{
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&F->connect.hostaddr;
memcpy(&in6->sin6_addr, &reply->rrs.addr->addr.inet6.sin6_addr, sizeof(struct in6_addr));
}
else
#endif
{
struct sockaddr_in *in = (struct sockaddr_in *)&F->connect.hostaddr;
in->sin_addr.s_addr = reply->rrs.addr->addr.inet.sin_addr.s_addr;
}
/* Now, call the tryconnect() routine to try a connect() */
MyFree(reply);
comm_connect_tryconnect(F->fd, NULL);
}
/* static void comm_connect_tryconnect(int fd, void *notused)
* Input: The fd, the handler data(unused).
* Output: None.
* Side-effects: Try and connect with pending connect data for the FD. If
* we succeed or get a fatal error, call the callback.
* Otherwise, it is still blocking or something, so register
* to select for a write event on this FD.
*/
static void
comm_connect_tryconnect(fde_t *fd, void *notused)
{
int retval;
/* This check is needed or re-entrant s_bsd_* like sigio break it. */
if (fd->connect.callback == NULL)
return;
/* Try the connect() */
retval = connect(fd->fd, (struct sockaddr *) &fd->connect.hostaddr,
fd->connect.hostaddr.ss_len);
/* Error? */
if (retval < 0)
{
#ifdef _WIN32
errno = WSAGetLastError();
#endif
/*
* If we get EISCONN, then we've already connect()ed the socket,
* which is a good thing.
* -- adrian
*/
if (errno == EISCONN)
comm_connect_callback(fd, COMM_OK);
else if (ignoreErrno(errno))
/* Ignore error? Reschedule */
comm_setselect(fd, COMM_SELECT_WRITE, comm_connect_tryconnect,
NULL, 0);
else
/* Error? Fail with COMM_ERR_CONNECT */
comm_connect_callback(fd, COMM_ERR_CONNECT);
return;
}
/* If we get here, we've suceeded, so call with COMM_OK */
comm_connect_callback(fd, COMM_OK);
}
/*
* comm_connect_timeout() - this gets called when the socket connection
* times out. This *only* can be called once connect() is initially
* called ..
*/
static void
comm_connect_timeout(int fd, void *notused)
{
/* error! */
comm_connect_callback(fd, COMM_ERR_TIMEOUT);
}
/*
* void comm_connect_tcp(int fd, const char *host, u_short port,
* struct sockaddr *clocal, int socklen,
* CNCB *callback, void *data, int aftype, int timeout)
* Input: An fd to connect with, a host and port to connect to,
* a local sockaddr to connect from + length(or NULL to use the
* default), a callback, the data to pass into the callback, the
* address family.
* Output: None.
* Side-effects: A non-blocking connection to the host is started, and
* if necessary, set up for selection. The callback given
* may be called now, or it may be called later.
*/
void
comm_connect_tcp(int fd, const char *host, u_short port,
struct sockaddr *clocal, int socklen, CNCB * callback,
void *data, int aftype, int timeout)
{
void *ipptr = NULL;
fde_t *F;
s_assert(fd >= 0);
F = &fd_table[fd];
F->flags.called_connect = 1;
s_assert(callback);
F->connect.callback = callback;
F->connect.data = data;
memset(&F->connect.hostaddr, 0, sizeof(F->connect.hostaddr));
#ifdef IPV6
if(aftype == AF_INET6)
{
struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&F->connect.hostaddr;
SET_SS_LEN(F->connect.hostaddr, sizeof(struct sockaddr_in6));
in6->sin6_port = htons(port);
in6->sin6_family = AF_INET6;
ipptr = &in6->sin6_addr;
} else
#endif
{
struct sockaddr_in *in = (struct sockaddr_in *)&F->connect.hostaddr;
SET_SS_LEN(F->connect.hostaddr, sizeof(struct sockaddr_in));
in->sin_port = htons(port);
in->sin_family = AF_INET;
ipptr = &in->sin_addr;
}
/* Note that we're using a passed sockaddr here. This is because
* generally you'll be bind()ing to a sockaddr grabbed from
* getsockname(), so this makes things easier.
* XXX If NULL is passed as local, we should later on bind() to the
* virtual host IP, for completeness.
* -- adrian
*/
if((clocal != NULL) && (bind(F->fd, clocal, socklen) < 0))
{
/* Failure, call the callback with COMM_ERR_BIND */
comm_connect_callback(F->fd, COMM_ERR_BIND);
/* ... and quit */
return;
}
/* Next, if we have been given an IP, get the addr and skip the
* DNS check (and head direct to comm_connect_tryconnect().
*/
if(inetpton(aftype, host, ipptr) <= 0)
{
/* Send the DNS request, for the next level */
F->dns_query = MyMalloc(sizeof(struct DNSQuery));
F->dns_query->ptr = F;
F->dns_query->callback = comm_connect_dns_callback;
adns_gethost(host, aftype, F->dns_query);
}
else
{
/* We have a valid IP, so we just call tryconnect */
/* Make sure we actually set the timeout here .. */
comm_settimeout(F->fd, timeout * 1000, comm_connect_timeout, NULL);
comm_connect_tryconnect(F->fd, NULL);
}
}
/*
* void comm_connect_tcp(int fd, const char *host, unsigned short port,
* struct sockaddr *clocal, int socklen,
* CNCB *callback, void *data, int aftype, int timeout)
* Input: An fd to connect with, a host and port to connect to,
* a local sockaddr to connect from + length(or NULL to use the
* default), a callback, the data to pass into the callback, the
* address family.
* Output: None.
* Side-effects: A non-blocking connection to the host is started, and
* if necessary, set up for selection. The callback given
* may be called now, or it may be called later.
*/
void
comm_connect_tcp(fde_t *fd, const char *host, unsigned short port,
struct sockaddr *clocal, int socklen, CNCB *callback,
void *data, int aftype, int timeout)
{
struct addrinfo hints, *res;
char portname[PORTNAMELEN+1];
assert(callback);
fd->connect.callback = callback;
fd->connect.data = data;
fd->connect.hostaddr.ss.ss_family = aftype;
fd->connect.hostaddr.ss_port = htons(port);
/* Note that we're using a passed sockaddr here. This is because
* generally you'll be bind()ing to a sockaddr grabbed from
* getsockname(), so this makes things easier.
* XXX If NULL is passed as local, we should later on bind() to the
* virtual host IP, for completeness.
* -- adrian
*/
if ((clocal != NULL) && (bind(fd->fd, clocal, socklen) < 0))
{
/* Failure, call the callback with COMM_ERR_BIND */
comm_connect_callback(fd, COMM_ERR_BIND);
/* ... and quit */
return;
}
/* Next, if we have been given an IP, get the addr and skip the
* DNS check (and head direct to comm_connect_tryconnect().
*/
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
snprintf(portname, PORTNAMELEN, "%d", port);
if (irc_getaddrinfo(host, portname, &hints, &res))
{
/* Send the DNS request, for the next level */
fd->dns_query = MyMalloc(sizeof(struct DNSQuery));
fd->dns_query->ptr = fd;
fd->dns_query->callback = comm_connect_dns_callback;
if (aftype == AF_INET6)
gethost_byname_type(host, fd->dns_query, T_AAAA);
else
gethost_byname_type(host, fd->dns_query, T_A);
}
else
{
/* We have a valid IP, so we just call tryconnect */
/* Make sure we actually set the timeout here .. */
assert(res != NULL);
memcpy(&fd->connect.hostaddr, res->ai_addr, res->ai_addrlen);
fd->connect.hostaddr.ss_len = res->ai_addrlen;
fd->connect.hostaddr.ss.ss_family = res->ai_family;
irc_freeaddrinfo(res);
comm_settimeout(fd, timeout*1000, comm_connect_timeout, NULL);
comm_connect_tryconnect(fd, NULL);
}
}
