[irc/quakenet/snircd.git] / ircd / uping.c

/*
 * IRC - Internet Relay Chat, ircd/uping.c
 * Copyright (C) 1994 Carlo Wood ( Run @ undernet.org )
 *
 * 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, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
/** @file
 * @brief UDP ping implementation.
 * @version $Id: uping.c,v 1.23.2.1 2006/03/14 03:45:52 entrope Exp $
 */
#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"
#include "match.h"
#include "msg.h"
#include "numeric.h"
#include "numnicks.h"
#include "s_bsd.h"    /* VirtualHost */
#include "s_conf.h"
#include "s_debug.h"
#include "s_misc.h"
#include "s_user.h"
#include "send.h"
#include "sys.h"

/* #include <assert.h> -- Now using assert in ircd_log.h */
#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

#define UPINGTIMEOUT 60   /**< Timeout waiting for ping responses */

static struct UPing* pingList = 0; /**< Linked list of UPing structs */
static struct Socket upingSock_v4; /**< Socket struct for IPv4 upings */
static struct Socket upingSock_v6; /**< Socket struct for IPv6 upings */

/** Start iteration of uping list.
 * @return Start of uping list.
 */
struct UPing* uping_begin(void)
{
  return pingList;
}

/** Removes \a p from uping list.
 * @param[in,out] p UPing to remove from list.
 */
static void uping_erase(struct UPing* p)
{
  struct UPing* it;
  struct UPing* last = 0;

  assert(0 != p);

  for (it = pingList; it; last = it, it = it->next) {
    if (p == it) {
      if (last)
        last->next = p->next;
      else
        pingList = p->next;
      break;
    }
  }
}

/** Callback for uping listener socket.
 * Reads a uping from the socket and respond, but not more than 10
 * times per second.
 * @param[in] ev I/O event for uping socket.
 */
static void uping_echo_callback(struct Event* ev)
{
  struct Socket      *sock;
  struct irc_sockaddr from;
  unsigned int       len = 0;
  static time_t      last = 0;
  static int         counter = 0;
  char               buf[BUFSIZE + 1];

  assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR);
  sock = ev_socket(ev);
  assert(sock == &upingSock_v4 || sock == &upingSock_v6);

  Debug((DEBUG_DEBUG, "UPING: uping_echo"));

  if (IO_SUCCESS != os_recvfrom_nonb(s_fd(sock), buf, BUFSIZE, &len, &from))
    return;
  /*
   * count em even if we're getting flooded so we can tell we're getting
   * flooded.
   */
  ++ServerStats->uping_recv;
  if (len < 19)
    return;
  else if (CurrentTime != last) {
    counter = 0;
    last = CurrentTime;
  } else if (++counter > 10)
    return;
  os_sendto_nonb(s_fd(sock), buf, len, NULL, 0, &from);
}

/** Initialize a UDP socket for upings.
 * @returns 0 on success, -1 on error.
 */
int uping_init(void)
{
  struct irc_sockaddr from;
  int fd;

  memcpy(&from, &VirtualHost_v4, sizeof(from));
  from.port = atoi(UDP_PORT);

  fd = os_socket(&from, SOCK_DGRAM, "IPv4 uping listener", AF_INET);
  if (fd < 0)
    return -1;
  if (!socket_add(&upingSock_v4, 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;
  }

#ifdef AF_INET6
  memcpy(&from, &VirtualHost_v6, sizeof(from));
  from.port = atoi(UDP_PORT);

  fd = os_socket(&from, SOCK_DGRAM, "IPv6 uping listener", AF_INET6);
  if (fd < 0)
    return -1;
  if (!socket_add(&upingSock_v6, 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;
  }
#endif

  return 0;
}


/** Callback for socket activity on an outbound uping socket.
 * @param[in] ev I/O event for socket.
 */
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 */
  }
}

/** Timer callback to send another outbound uping.
 * @param[in] ev Event for uping timer.
 */
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));
  }
}

/** Timer callback to stop upings.
 * @param[in] ev Event for uping expiration.
 */
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 a uping.
 * This sets up the timers, UPing flags, and sends a notice to the
 * requesting client.
 */
static void uping_start(struct UPing* pptr)
{
  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->active = 1;
}

/** Send a uping to another server.
 * @param[in] pptr Descriptor for uping.
 */
void uping_send(struct UPing* pptr)
{
  struct timeval tv;
  char buf[BUFSIZE + 1];

  assert(0 != pptr);
  if (pptr->sent == pptr->count)
    return;
  memset(buf, 0, sizeof(buf));

  gettimeofday(&tv, NULL);
  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(&pptr->addr.addr), pptr->addr.port,
	  pptr->fd));

  if (os_sendto_nonb(pptr->fd, buf, BUFSIZE, NULL, 0, &pptr->addr) != IO_SUCCESS)
  {
    const char* msg = strerror(errno);
    if (!msg)
      msg = "Unknown error";
    if (pptr->client)
      sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: send failed: "
		    "%s", pptr->client, msg);
    Debug((DEBUG_DEBUG, "UPING: send_ping: sendto failed on %d: %s", pptr->fd, msg));
    uping_end(pptr);
    return;
  }
  ++pptr->sent;
}

/** Read the response from an outbound uping.
 * @param[in] pptr UPing to check.
 */
void uping_read(struct UPing* pptr)
{
  struct irc_sockaddr sin;
  struct timeval     tv;
  unsigned int       len;
  unsigned int       pingtime;
  char*              s;
  char               buf[BUFSIZE + 1];
  IOResult           ior;

  assert(0 != pptr);

  gettimeofday(&tv, NULL);

  ior = os_recvfrom_nonb(pptr->fd, buf, BUFSIZE, &len, &sin);
  if (IO_BLOCKED == ior)
    return;
  else if (IO_FAILURE == ior) {
    const char* msg = strerror(errno);
    if (!msg)
      msg = "Unknown error";
    sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: receive error: "
		  "%s", pptr->client, msg);
    uping_end(pptr);
    return;
  }

  if (len < 19)
    return;			/* Broken packet */

  ++pptr->received;

  buf[len] = 0;
  pingtime = (tv.tv_sec - atol(&buf[1])) * 1000
             + (tv.tv_usec - atol(buf + strlen(buf) + 1)) / 1000;

  pptr->ms_ave += pingtime;
  if (!pptr->ms_min || pptr->ms_min > pingtime)
    pptr->ms_min = pingtime;
  if (pingtime > pptr->ms_max)
    pptr->ms_max = pingtime;

  timer_chg(&pptr->killer, TT_RELATIVE, UPINGTIMEOUT);

  s = pptr->buf + strlen(pptr->buf);
  sprintf(s, " %u", pingtime);

  if (pptr->received == pptr->count)
    uping_end(pptr);
  return;
}

/** Start sending upings to a server.
 * @param[in] sptr Client requesting the upings.
 * @param[in] aconf ConfItem containing the address to ping.
 * @param[in] port Port number to ping.
 * @param[in] count Number of times to ping (should be at least 20).
 * @return Zero.
 */
int uping_server(struct Client* sptr, struct ConfItem* aconf, int port, int count)
{
  int fd;
  int family = 0;
  struct UPing* pptr;
  struct irc_sockaddr *local;

  assert(0 != sptr);
  assert(0 != aconf);

  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 (irc_in_addr_is_ipv4(&aconf->address.addr)) {
    local = &VirtualHost_v4;
    family = AF_INET;
  } else {
    local = &VirtualHost_v6;
  }
  fd = os_socket(local, SOCK_DGRAM, "Outbound uping socket", family);
  if (fd < 0)
    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;
  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->freeable            = UPING_PENDING_SOCKET;
  strcpy(pptr->name, aconf->name);

  pptr->next = pingList;
  pingList   = pptr;

  SetUPing(sptr);
  uping_start(pptr);
  return 0;
}

/** Clean up a UPing structure, reporting results to the requester.
 * @param[in,out] pptr UPing results.
 */
void uping_end(struct UPing* pptr)
{
  Debug((DEBUG_DEBUG, "uping_end: %p", pptr));

  if (pptr->client) {
    if (pptr->lastsent) {
      if (0 < pptr->received) {
	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING %s%s",
		      pptr->client, pptr->name, pptr->buf);
	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING Stats: "
		      "sent %d recvd %d ; min/avg/max = %u/%u/%u ms",
		      pptr->client, pptr->sent, pptr->received, pptr->ms_min,
		      (2 * pptr->ms_ave) / (2 * pptr->received), pptr->ms_max);
      } else
	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: no response "
		      "from %s within %d seconds", pptr->client, pptr->name,
		      UPINGTIMEOUT);
    } else
      sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: Could not "
		    "start ping to %s", pptr->client, pptr->name);
  }

  close(pptr->fd);
  pptr->fd = -1;
  uping_erase(pptr);
  if (pptr->client)
    ClearUPing(pptr->client);
  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);
}

/** Change notifications for any upings by \a sptr.
 * @param[in] sptr Client to stop notifying.
 * @param[in] acptr New client to notify (or NULL).
 */
void uping_cancel(struct Client *sptr, struct Client* acptr)
{
  struct UPing* ping;
  struct UPing* ping_next;

  Debug((DEBUG_DEBUG, "UPING: canceling uping for %s", cli_name(sptr)));
  for (ping = pingList; ping; ping = ping_next) {
    ping_next = ping->next;
    if (sptr == ping->client) {
      ping->client = acptr;
      uping_end(ping);
    }
  }
  ClearUPing(sptr);
}
Commit	Line	Data
189935b1	1	/*
	2	* IRC - Internet Relay Chat, ircd/uping.c
	3	* Copyright (C) 1994 Carlo Wood ( Run @ undernet.org )
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2, or (at your option)
	8	* any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	18	*/
	19	/** @file
	20	* @brief UDP ping implementation.
9f8856e9	21	* @version $Id: uping.c,v 1.23.2.1 2006/03/14 03:45:52 entrope Exp $
189935b1	22	*/
	23	#include "config.h"
	24
	25	#include "uping.h"
	26	#include "client.h"
	27	#include "ircd.h"
	28	#include "ircd_alloc.h"
	29	#include "ircd_events.h"
	30	#include "ircd_log.h"
	31	#include "ircd_osdep.h"
	32	#include "ircd_string.h"
	33	#include "match.h"
	34	#include "msg.h"
	35	#include "numeric.h"
	36	#include "numnicks.h"
	37	#include "s_bsd.h" /* VirtualHost */
	38	#include "s_conf.h"
	39	#include "s_debug.h"
	40	#include "s_misc.h"
	41	#include "s_user.h"
	42	#include "send.h"
	43	#include "sys.h"
	44
	45	/* #include <assert.h> -- Now using assert in ircd_log.h */
	46	#include <errno.h>
	47	#include <netdb.h>
	48	#include <stdio.h>
	49	#include <stdlib.h>
	50	#include <string.h>
	51	#include <sys/socket.h>
	52	#include <sys/time.h>
	53	#include <unistd.h>
	54
	55	#define UPINGTIMEOUT 60 /*< Timeout waiting for ping responses /
	56
	57	static struct UPing* pingList = 0; /*< Linked list of UPing structs /
	58	static struct Socket upingSock_v4; /*< Socket struct for IPv4 upings /
	59	static struct Socket upingSock_v6; /*< Socket struct for IPv6 upings /
	60
	61	/** Start iteration of uping list.
	62	* @return Start of uping list.
	63	*/
	64	struct UPing* uping_begin(void)
	65	{
	66	return pingList;
	67	}
	68
	69	/** Removes \a p from uping list.
	70	* @param[in,out] p UPing to remove from list.
	71	*/
	72	static void uping_erase(struct UPing* p)
	73	{
	74	struct UPing* it;
	75	struct UPing* last = 0;
	76
	77	assert(0 != p);
	78
	79	for (it = pingList; it; last = it, it = it->next) {
	80	if (p == it) {
	81	if (last)
	82	last->next = p->next;
	83	else
	84	pingList = p->next;
	85	break;
86	}
87	}
88	}
89
90	/** Callback for uping listener socket.
91	* Reads a uping from the socket and respond, but not more than 10
92	* times per second.
93	* @param[in] ev I/O event for uping socket.
94	*/
95	static void uping_echo_callback(struct Event* ev)
96	{
97	struct Socket *sock;
98	struct irc_sockaddr from;
99	unsigned int len = 0;
100	static time_t last = 0;
101	static int counter = 0;
102	char buf[BUFSIZE + 1];
103
104	assert(ev_type(ev) == ET_READ \|\| ev_type(ev) == ET_ERROR);
105	sock = ev_socket(ev);
106	assert(sock == &upingSock_v4 \|\| sock == &upingSock_v6);
107
108	Debug((DEBUG_DEBUG, "UPING: uping_echo"));
109
110	if (IO_SUCCESS != os_recvfrom_nonb(s_fd(sock), buf, BUFSIZE, &len, &from))
111	return;
112	/*
113	* count em even if we're getting flooded so we can tell we're getting
114	* flooded.
115	*/
116	++ServerStats->uping_recv;
117	if (len < 19)
118	return;
119	else if (CurrentTime != last) {
120	counter = 0;
121	last = CurrentTime;
122	} else if (++counter > 10)
123	return;
124	os_sendto_nonb(s_fd(sock), buf, len, NULL, 0, &from);
125	}
126
127	/** Initialize a UDP socket for upings.
128	* @returns 0 on success, -1 on error.
129	*/
130	int uping_init(void)
131	{
132	struct irc_sockaddr from;
133	int fd;
134
135	memcpy(&from, &VirtualHost_v4, sizeof(from));
136	from.port = atoi(UDP_PORT);
137
9f8856e9	138	fd = os_socket(&from, SOCK_DGRAM, "IPv4 uping listener", AF_INET);
189935b1	139	if (fd < 0)
	140	return -1;
	141	if (!socket_add(&upingSock_v4, uping_echo_callback, 0, SS_DATAGRAM,
	142	SOCK_EVENT_READABLE, fd)) {
	143	Debug((DEBUG_ERROR, "UPING: Unable to queue fd to event system"));
	144	close(fd);
	145	return -1;
	146	}
	147
9f8856e9	148	#ifdef AF_INET6
189935b1	149	memcpy(&from, &VirtualHost_v6, sizeof(from));
	150	from.port = atoi(UDP_PORT);
	151
9f8856e9	152	fd = os_socket(&from, SOCK_DGRAM, "IPv6 uping listener", AF_INET6);
189935b1	153	if (fd < 0)
	154	return -1;
	155	if (!socket_add(&upingSock_v6, uping_echo_callback, 0, SS_DATAGRAM,
	156	SOCK_EVENT_READABLE, fd)) {
	157	Debug((DEBUG_ERROR, "UPING: Unable to queue fd to event system"));
	158	close(fd);
	159	return -1;
	160	}
9f8856e9	161	#endif
189935b1	162
	163	return 0;
	164	}
	165
	166
	167	/** Callback for socket activity on an outbound uping socket.
	168	* @param[in] ev I/O event for socket.
	169	*/
	170	static void uping_read_callback(struct Event* ev)
	171	{
	172	struct UPing *pptr;
	173
	174	assert(0 != ev_socket(ev));
	175	assert(0 != s_data(ev_socket(ev)));
	176
	177	pptr = (struct UPing*) s_data(ev_socket(ev));
	178
	179	Debug((DEBUG_SEND, "uping_read_callback called, %p (%d)", pptr,
	180	ev_type(ev)));
	181
	182	if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
	183	pptr->freeable &= ~UPING_PENDING_SOCKET;
	184
	185	if (!pptr->freeable)
	186	MyFree(pptr); /* done with it, finally */
	187	} else {
	188	assert(ev_type(ev) == ET_READ \|\| ev_type(ev) == ET_ERROR);
	189
	190	uping_read(pptr); /* read uping response */
	191	}
	192	}
	193
	194	/** Timer callback to send another outbound uping.
	195	* @param[in] ev Event for uping timer.
	196	*/
	197	static void uping_sender_callback(struct Event* ev)
	198	{
	199	struct UPing *pptr;
	200
	201	assert(0 != ev_timer(ev));
	202	assert(0 != t_data(ev_timer(ev)));
	203
	204	pptr = (struct UPing*) t_data(ev_timer(ev));
	205
	206	Debug((DEBUG_SEND, "uping_sender_callback called, %p (%d)", pptr,
	207	ev_type(ev)));
	208
	209	if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
	210	pptr->freeable &= ~UPING_PENDING_SENDER;
	211
	212	if (!pptr->freeable)
	213	MyFree(pptr); /* done with it, finally */
	214	} else {
	215	assert(ev_type(ev) == ET_EXPIRE);
	216
	217	pptr->lastsent = CurrentTime; /* store last ping time */
	218	uping_send(pptr); /* send a ping */
	219
	220	if (pptr->sent == pptr->count) /* done sending pings, don't send more */
	221	timer_del(ev_timer(ev));
	222	}
	223	}
	224
	225	/** Timer callback to stop upings.
226	* @param[in] ev Event for uping expiration.
227	*/
228	static void uping_killer_callback(struct Event* ev)
229	{
230	struct UPing *pptr;
231
232	assert(0 != ev_timer(ev));
233	assert(0 != t_data(ev_timer(ev)));
234
235	pptr = (struct UPing*) t_data(ev_timer(ev));
236
237	Debug((DEBUG_SEND, "uping_killer_callback called, %p (%d)", pptr,
238	ev_type(ev)));
239
240	if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
241	pptr->freeable &= ~UPING_PENDING_KILLER;
242
243	if (!pptr->freeable)
244	MyFree(pptr); /* done with it, finally */
245	} else {
246	assert(ev_type(ev) == ET_EXPIRE);
247
248	uping_end(pptr); /* <FUDD>kill the uping, kill the uping!</FUDD> */
249	}
250	}
251
252	/** Start a uping.
253	* This sets up the timers, UPing flags, and sends a notice to the
254	* requesting client.
255	*/
256	static void uping_start(struct UPing* pptr)
257	{
258	assert(0 != pptr);
259
260	timer_add(timer_init(&pptr->sender), uping_sender_callback, (void*) pptr,
261	TT_PERIODIC, 1);
262	timer_add(timer_init(&pptr->killer), uping_killer_callback, (void*) pptr,
263	TT_RELATIVE, UPINGTIMEOUT);
264	pptr->freeable \|= UPING_PENDING_SENDER \| UPING_PENDING_KILLER;
265
266	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :Sending %d ping%s to %s",
267	pptr->client, pptr->count, (pptr->count == 1) ? "" : "s",
268	pptr->name);
269	pptr->active = 1;
270	}
271
272	/** Send a uping to another server.
273	* @param[in] pptr Descriptor for uping.
274	*/
275	void uping_send(struct UPing* pptr)
276	{
277	struct timeval tv;
278	char buf[BUFSIZE + 1];
279
280	assert(0 != pptr);
281	if (pptr->sent == pptr->count)
282	return;
283	memset(buf, 0, sizeof(buf));
284
285	gettimeofday(&tv, NULL);
286	sprintf(buf, " %10lu%c%6lu", (unsigned long)tv.tv_sec, '\0', (unsigned long)tv.tv_usec);
287
288	Debug((DEBUG_SEND, "send_ping: sending [%s %s] to %s.%d on %d",
289	buf, &buf[12],
290	ircd_ntoa(&pptr->addr.addr), pptr->addr.port,
291	pptr->fd));
292
293	if (os_sendto_nonb(pptr->fd, buf, BUFSIZE, NULL, 0, &pptr->addr) != IO_SUCCESS)
294	{
295	const char* msg = strerror(errno);
296	if (!msg)
297	msg = "Unknown error";
298	if (pptr->client)
299	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: send failed: "
300	"%s", pptr->client, msg);
301	Debug((DEBUG_DEBUG, "UPING: send_ping: sendto failed on %d: %s", pptr->fd, msg));
302	uping_end(pptr);
303	return;
304	}
305	++pptr->sent;
306	}
307
308	/** Read the response from an outbound uping.
309	* @param[in] pptr UPing to check.
310	*/
311	void uping_read(struct UPing* pptr)
312	{
313	struct irc_sockaddr sin;
314	struct timeval tv;
315	unsigned int len;
316	unsigned int pingtime;
317	char* s;
318	char buf[BUFSIZE + 1];
319	IOResult ior;
320
321	assert(0 != pptr);
322
323	gettimeofday(&tv, NULL);
324
325	ior = os_recvfrom_nonb(pptr->fd, buf, BUFSIZE, &len, &sin);
326	if (IO_BLOCKED == ior)
327	return;
328	else if (IO_FAILURE == ior) {
329	const char* msg = strerror(errno);
330	if (!msg)
331	msg = "Unknown error";
332	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: receive error: "
333	"%s", pptr->client, msg);
334	uping_end(pptr);
335	return;
336	}
337
338	if (len < 19)
339	return; /* Broken packet */
340
341	++pptr->received;
342
343	buf[len] = 0;
344	pingtime = (tv.tv_sec - atol(&buf[1])) * 1000
345	+ (tv.tv_usec - atol(buf + strlen(buf) + 1)) / 1000;
346
347	pptr->ms_ave += pingtime;
348	if (!pptr->ms_min \|\| pptr->ms_min > pingtime)
349	pptr->ms_min = pingtime;
350	if (pingtime > pptr->ms_max)
351	pptr->ms_max = pingtime;
352
353	timer_chg(&pptr->killer, TT_RELATIVE, UPINGTIMEOUT);
354
355	s = pptr->buf + strlen(pptr->buf);
356	sprintf(s, " %u", pingtime);
357
358	if (pptr->received == pptr->count)
359	uping_end(pptr);
360	return;
361	}
362
363	/** Start sending upings to a server.
364	* @param[in] sptr Client requesting the upings.
365	* @param[in] aconf ConfItem containing the address to ping.
366	* @param[in] port Port number to ping.
367	* @param[in] count Number of times to ping (should be at least 20).
368	* @return Zero.
369	*/
370	int uping_server(struct Client* sptr, struct ConfItem* aconf, int port, int count)
371	{
372	int fd;
9f8856e9	373	int family = 0;
189935b1	374	struct UPing* pptr;
	375	struct irc_sockaddr *local;
	376
	377	assert(0 != sptr);
	378	assert(0 != aconf);
	379
	380	if (!irc_in_addr_valid(&aconf->address.addr)) {
	381	sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Host lookup failed for "
	382	"%s", sptr, aconf->name);
	383	return 0;
	384	}
	385
	386	if (IsUPing(sptr))
	387	uping_cancel(sptr, sptr); /* Cancel previous ping request */
	388
9f8856e9	389	if (irc_in_addr_is_ipv4(&aconf->address.addr)) {
	390	local = &VirtualHost_v4;
	391	family = AF_INET;
	392	} else {
	393	local = &VirtualHost_v6;
	394	}
	395	fd = os_socket(local, SOCK_DGRAM, "Outbound uping socket", family);
189935b1	396	if (fd < 0)
	397	return 0;
	398
	399	pptr = (struct UPing*) MyMalloc(sizeof(struct UPing));
	400	assert(0 != pptr);
	401	memset(pptr, 0, sizeof(struct UPing));
	402
	403	if (!socket_add(&pptr->socket, uping_read_callback, (void*) pptr,
	404	SS_DATAGRAM, SOCK_EVENT_READABLE, fd)) {
	405	sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't queue fd for "
	406	"reading", sptr);
	407	close(fd);
	408	MyFree(pptr);
	409	return 0;
	410	}
	411
	412	pptr->fd = fd;
	413	memcpy(&pptr->addr.addr, &aconf->address.addr, sizeof(pptr->addr.addr));
	414	pptr->addr.port = port;
	415	pptr->count = IRCD_MIN(20, count);
	416	pptr->client = sptr;
	417	pptr->freeable = UPING_PENDING_SOCKET;
	418	strcpy(pptr->name, aconf->name);
	419
	420	pptr->next = pingList;
	421	pingList = pptr;
	422
	423	SetUPing(sptr);
	424	uping_start(pptr);
	425	return 0;
	426	}
	427
	428	/** Clean up a UPing structure, reporting results to the requester.
	429	* @param[in,out] pptr UPing results.
	430	*/
	431	void uping_end(struct UPing* pptr)
	432	{
	433	Debug((DEBUG_DEBUG, "uping_end: %p", pptr));
	434
	435	if (pptr->client) {
	436	if (pptr->lastsent) {
	437	if (0 < pptr->received) {
	438	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING %s%s",
	439	pptr->client, pptr->name, pptr->buf);
	440	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING Stats: "
9f8856e9	441	"sent %d recvd %d ; min/avg/max = %u/%u/%u ms",
189935b1	442	pptr->client, pptr->sent, pptr->received, pptr->ms_min,
	443	(2 * pptr->ms_ave) / (2 * pptr->received), pptr->ms_max);
	444	} else
	445	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: no response "
	446	"from %s within %d seconds", pptr->client, pptr->name,
	447	UPINGTIMEOUT);
	448	} else
	449	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: Could not "
	450	"start ping to %s", pptr->client, pptr->name);
	451	}
	452
	453	close(pptr->fd);
	454	pptr->fd = -1;
	455	uping_erase(pptr);
	456	if (pptr->client)
	457	ClearUPing(pptr->client);
	458	if (pptr->freeable & UPING_PENDING_SOCKET)
	459	socket_del(&pptr->socket);
	460	if (pptr->freeable & UPING_PENDING_SENDER)
	461	timer_del(&pptr->sender);
	462	if (pptr->freeable & UPING_PENDING_KILLER)
	463	timer_del(&pptr->killer);
	464	}
	465
	466	/** Change notifications for any upings by \a sptr.
	467	* @param[in] sptr Client to stop notifying.
	468	* @param[in] acptr New client to notify (or NULL).
	469	*/
	470	void uping_cancel(struct Client sptr, struct Client acptr)
	471	{
	472	struct UPing* ping;
	473	struct UPing* ping_next;
	474
	475	Debug((DEBUG_DEBUG, "UPING: canceling uping for %s", cli_name(sptr)));
	476	for (ping = pingList; ping; ping = ping_next) {
	477	ping_next = ping->next;
	478	if (sptr == ping->client) {
	479	ping->client = acptr;
	480	uping_end(ping);
	481	}
	482	}
	483	ClearUPing(sptr);
	484	}