*
* $Id$
*/
+#include "config.h"
+
#include "uping.h"
#include "client.h"
#include "ircd.h"
#include "ircd_alloc.h"
+#include "ircd_events.h"
#include "ircd_log.h"
#include "ircd_osdep.h"
#include "ircd_string.h"
#define UPINGTIMEOUT 60 /* Timeout waiting for ping responses */
-#ifndef INADDR_NONE
-#define INADDR_NONE 0xffffffff
-#endif
-
static struct UPing* pingList = 0;
int UPingFileDescriptor = -1; /* UDP listener socket for upings */
+static struct Socket upingSock;
+
/*
* pings_begin - iterator function for ping list
*/
}
}
+/* Called when the event engine detects activity on the UPing socket */
+static void uping_echo_callback(struct Event* ev)
+{
+ assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR);
+
+ uping_echo();
+}
+
/*
* Setup a UDP socket and listen for incoming packets
*/
int uping_init(void)
{
- struct sockaddr_in from = { 0 };
+ struct irc_sockaddr from;
int fd;
- memset(&from, 0, sizeof(from));
- from.sin_addr = VirtualHost.sin_addr;
- from.sin_port = htons(atoi(UDP_PORT));
- from.sin_family = AF_INET;
+ memcpy(&from, &VirtualHost, sizeof(from));
+ from.port = atoi(UDP_PORT);
- if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
- Debug((DEBUG_ERROR, "UPING: UDP listener socket call failed: %s",
- (strerror(errno)) ? strerror(errno) : "Unknown error"));
+ fd = os_socket(&from, SOCK_DGRAM, "UDP listener socket");
+ if (fd < 0)
return -1;
- }
- if (!os_set_reuseaddr(fd)) {
- log_write(LS_SOCKET, L_ERROR, 0,
- "UPING: set reuseaddr on UDP listener failed: %m (fd %d)", fd);
- Debug((DEBUG_ERROR, "UPING: set reuseaddr on UDP listener failed: %s",
- (strerror(errno)) ? strerror(errno) : "Unknown error"));
- close(fd);
- return -1;
- }
- if (bind(fd, (struct sockaddr*) &from, sizeof(from)) == -1) {
- log_write(LS_SOCKET, L_ERROR, 0,
- "UPING: bind on UDP listener (%d fd %d) failed: %m",
- htons(from.sin_port), fd);
- Debug((DEBUG_ERROR, "UPING: bind on UDP listener failed : %s",
- (strerror(errno)) ? strerror(errno) : "Unknown error"));
- close(fd);
- return -1;
- }
- if (!os_set_nonblocking(fd)) {
- Debug((DEBUG_ERROR, "UPING: set non-blocking: %s",
- (strerror(errno)) ? strerror(errno) : "Unknown error"));
+ if (!socket_add(&upingSock, uping_echo_callback, 0, SS_DATAGRAM,
+ SOCK_EVENT_READABLE, fd)) {
+ Debug((DEBUG_ERROR, "UPING: Unable to queue fd to event system"));
close(fd);
return -1;
}
*/
void uping_echo()
{
- struct sockaddr_in from = { 0 };
+ struct irc_sockaddr from;
unsigned int len = 0;
static time_t last = 0;
static int counter = 0;
}
if (len < 19)
return;
- sendto(UPingFileDescriptor, buf, len, 0, (struct sockaddr*) &from, sizeof(from));
+ os_sendto_nonb(UPingFileDescriptor, buf, len, NULL, 0, &from);
}
+/* Callback when socket has data to read */
+static void uping_read_callback(struct Event* ev)
+{
+ struct UPing *pptr;
+
+ assert(0 != ev_socket(ev));
+ assert(0 != s_data(ev_socket(ev)));
+
+ pptr = (struct UPing*) s_data(ev_socket(ev));
+
+ Debug((DEBUG_SEND, "uping_read_callback called, %p (%d)", pptr,
+ ev_type(ev)));
+
+ if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
+ pptr->freeable &= ~UPING_PENDING_SOCKET;
+
+ if (!pptr->freeable)
+ MyFree(pptr); /* done with it, finally */
+ } else {
+ assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR);
+
+ uping_read(pptr); /* read uping response */
+ }
+}
+
+/* Callback to send another ping */
+static void uping_sender_callback(struct Event* ev)
+{
+ struct UPing *pptr;
+
+ assert(0 != ev_timer(ev));
+ assert(0 != t_data(ev_timer(ev)));
+
+ pptr = (struct UPing*) t_data(ev_timer(ev));
+
+ Debug((DEBUG_SEND, "uping_sender_callback called, %p (%d)", pptr,
+ ev_type(ev)));
+
+ if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
+ pptr->freeable &= ~UPING_PENDING_SENDER;
+
+ if (!pptr->freeable)
+ MyFree(pptr); /* done with it, finally */
+ } else {
+ assert(ev_type(ev) == ET_EXPIRE);
+
+ pptr->lastsent = CurrentTime; /* store last ping time */
+ uping_send(pptr); /* send a ping */
+
+ if (pptr->sent == pptr->count) /* done sending pings, don't send more */
+ timer_del(ev_timer(ev));
+ }
+}
+
+/* Callback to kill a ping */
+static void uping_killer_callback(struct Event* ev)
+{
+ struct UPing *pptr;
+
+ assert(0 != ev_timer(ev));
+ assert(0 != t_data(ev_timer(ev)));
+
+ pptr = (struct UPing*) t_data(ev_timer(ev));
+
+ Debug((DEBUG_SEND, "uping_killer_callback called, %p (%d)", pptr,
+ ev_type(ev)));
+
+ if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
+ pptr->freeable &= ~UPING_PENDING_KILLER;
+
+ if (!pptr->freeable)
+ MyFree(pptr); /* done with it, finally */
+ } else {
+ assert(ev_type(ev) == ET_EXPIRE);
+
+ uping_end(pptr); /* <FUDD>kill the uping, kill the uping!</FUDD> */
+ }
+}
+
/*
* start_ping
*/
{
assert(0 != pptr);
+ timer_add(timer_init(&pptr->sender), uping_sender_callback, (void*) pptr,
+ TT_PERIODIC, 1);
+ timer_add(timer_init(&pptr->killer), uping_killer_callback, (void*) pptr,
+ TT_RELATIVE, UPINGTIMEOUT);
+ pptr->freeable |= UPING_PENDING_SENDER | UPING_PENDING_KILLER;
+
sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :Sending %d ping%s to %s",
pptr->client, pptr->count, (pptr->count == 1) ? "" : "s",
pptr->name);
- pptr->timeout = CurrentTime + UPINGTIMEOUT;
pptr->active = 1;
}
memset(buf, 0, sizeof(buf));
gettimeofday(&tv, NULL);
- sprintf(buf, " %10lu%c%6lu", tv.tv_sec, '\0', tv.tv_usec);
+ sprintf(buf, " %10lu%c%6lu", (unsigned long)tv.tv_sec, '\0', (unsigned long)tv.tv_usec);
Debug((DEBUG_SEND, "send_ping: sending [%s %s] to %s.%d on %d",
buf, &buf[12],
- ircd_ntoa((const char*) &pptr->sin.sin_addr), ntohs(pptr->sin.sin_port),
+ ircd_ntoa(&pptr->addr.addr), pptr->addr.port,
pptr->fd));
- if (sendto(pptr->fd, buf, BUFSIZE, 0, (struct sockaddr*) &pptr->sin,
- sizeof(struct sockaddr_in)) != BUFSIZE)
+ if (os_sendto_nonb(pptr->fd, buf, BUFSIZE, NULL, 0, &pptr->addr) != IO_SUCCESS)
{
const char* msg = strerror(errno);
if (!msg)
*/
void uping_read(struct UPing* pptr)
{
- struct sockaddr_in sin;
+ struct irc_sockaddr sin;
struct timeval tv;
unsigned int len;
unsigned int pingtime;
"%s", pptr->client, msg);
uping_end(pptr);
return;
- }
+ }
if (len < 19)
return; /* Broken packet */
-
+
++pptr->received;
buf[len] = 0;
pptr->ms_min = pingtime;
if (pingtime > pptr->ms_max)
pptr->ms_max = pingtime;
-
- pptr->timeout = CurrentTime + UPINGTIMEOUT;
- Debug((DEBUG_SEND, "read_ping: %d bytes, ti %lu: [%s %s] %lu ms",
- len, pptr->timeout, buf, (buf + strlen(buf) + 1), pingtime));
+ timer_chg(&pptr->killer, TT_RELATIVE, UPINGTIMEOUT);
s = pptr->buf + strlen(pptr->buf);
sprintf(s, " %u", pingtime);
assert(0 != sptr);
assert(0 != aconf);
- if (INADDR_NONE == aconf->ipnum.s_addr) {
+ if (!irc_in_addr_valid(&aconf->address.addr)) {
sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Host lookup failed for "
"%s", sptr, aconf->name);
return 0;
if (IsUPing(sptr))
uping_cancel(sptr, sptr); /* Cancel previous ping request */
- if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
- sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Unable to create udp "
- "ping socket", sptr);
+ fd = os_socket(NULL, SOCK_DGRAM, "UDP ping socket");
+ if (fd < 0)
return 0;
- }
- if (!os_set_nonblocking(fd)) {
- sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't set fd non-"
- "blocking", sptr);
- close(fd);
- return 0;
- }
pptr = (struct UPing*) MyMalloc(sizeof(struct UPing));
assert(0 != pptr);
memset(pptr, 0, sizeof(struct UPing));
+ if (!socket_add(&pptr->socket, uping_read_callback, (void*) pptr,
+ SS_DATAGRAM, SOCK_EVENT_READABLE, fd)) {
+ sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't queue fd for "
+ "reading", sptr);
+ close(fd);
+ MyFree(pptr);
+ return 0;
+ }
+
pptr->fd = fd;
- pptr->sin.sin_port = htons(port);
- pptr->sin.sin_addr.s_addr = aconf->ipnum.s_addr;
- pptr->sin.sin_family = AF_INET;
+ memcpy(&pptr->addr.addr, &aconf->address.addr, sizeof(pptr->addr.addr));
+ pptr->addr.port = port;
pptr->count = IRCD_MIN(20, count);
pptr->client = sptr;
pptr->index = -1;
+ pptr->freeable = UPING_PENDING_SOCKET;
strcpy(pptr->name, aconf->name);
pptr->next = pingList;
uping_erase(pptr);
if (pptr->client)
ClearUPing(pptr->client);
- MyFree(pptr);
+ if (pptr->freeable & UPING_PENDING_SOCKET)
+ socket_del(&pptr->socket);
+ if (pptr->freeable & UPING_PENDING_SENDER)
+ timer_del(&pptr->sender);
+ if (pptr->freeable & UPING_PENDING_KILLER)
+ timer_del(&pptr->killer);
}
void uping_cancel(struct Client *sptr, struct Client* acptr)
projects / ircu2.10.12-pk.git / blobdiff