404 lines
10 KiB
C
404 lines
10 KiB
C
/*****************************************************************************
|
|
*
|
|
* Purpose ...............: mbtask - ping functions
|
|
*
|
|
*****************************************************************************
|
|
* Copyright (C) 1997-2011
|
|
*
|
|
* Michiel Broek FIDO: 2:280/2802
|
|
* Beekmansbos 10
|
|
* 1971 BV IJmuiden
|
|
* the Netherlands
|
|
*
|
|
* This file is part of MBSE BBS.
|
|
*
|
|
* This BBS 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.
|
|
*
|
|
* MBSE BBS 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 MBSE BBS; see the file COPYING. If not, write to the Free
|
|
* Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*****************************************************************************/
|
|
|
|
#include "../config.h"
|
|
#include "../lib/mbselib.h"
|
|
#include "taskstat.h"
|
|
#include "taskutil.h"
|
|
#include "ping.h"
|
|
|
|
|
|
|
|
/*
|
|
* Global variables
|
|
*/
|
|
extern struct taskrec TCFG; /* Task config record */
|
|
int ping_isocket = -1; /* Ping socket */
|
|
int icmp_errs = 0; /* ICMP error counter */
|
|
extern int internet; /* Internet is down */
|
|
extern int rescan; /* Master rescan flag */
|
|
struct in_addr paddr; /* Current ping address */
|
|
int pingnr = 2; /* Ping number */
|
|
int pingresult[2]; /* Results of pings */
|
|
time_t ping_rcvd; /* Time ping received */
|
|
time_t ping_sent; /* Time ping sent */
|
|
time_t ping_next; /* Time to sent next */
|
|
char pingaddress[41]; /* Last pingaddress */
|
|
|
|
|
|
|
|
/*
|
|
* Internal prototypes
|
|
*/
|
|
static int icmp4_errcmp(char *, int, struct in_addr *, char *, int, int);
|
|
unsigned short get_rand16(void);
|
|
int ping_send(struct in_addr);
|
|
|
|
|
|
/*
|
|
* different names, same thing... be careful, as these are macros...
|
|
*/
|
|
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
# define icmphdr icmp
|
|
# define iphdr ip
|
|
# define ip_saddr ip_src.s_addr
|
|
# define ip_daddr ip_dst.s_addr
|
|
#else
|
|
# define ip_saddr saddr
|
|
# define ip_daddr daddr
|
|
# define ip_hl ihl
|
|
# define ip_p protocol
|
|
#endif
|
|
|
|
|
|
#ifdef __linux__
|
|
# define icmp_type type
|
|
# define icmp_code code
|
|
# define icmp_cksum checksum
|
|
# ifdef icmp_id
|
|
# undef icmp_id
|
|
# endif
|
|
# define icmp_id un.echo.id
|
|
# ifdef icmp_seq
|
|
# undef icmp_seq
|
|
# endif
|
|
# define icmp_seq un.echo.sequence
|
|
#endif
|
|
|
|
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
# define ICMP_DEST_UNREACH ICMP_UNREACH
|
|
# define ICMP_TIME_EXCEEDED ICMP_TIMXCEED
|
|
#endif
|
|
|
|
#define ICMP_BASEHDR_LEN 8
|
|
#define ICMP4_ECHO_LEN ICMP_BASEHDR_LEN
|
|
|
|
|
|
short p_sequence = 10;
|
|
unsigned short id;
|
|
struct icmphdr icmpd;
|
|
struct sockaddr_in to;
|
|
|
|
|
|
|
|
/*
|
|
* Takes a packet as send out and a recieved ICMP packet and looks whether the ICMP packet is
|
|
* an error reply on the sent-out one. packet is only the packet (without IP header).
|
|
* errmsg includes an IP header.
|
|
* to is the destination address of the original packet (the only thing that is actually
|
|
* compared of the IP header). The RFC sais that we get at least 8 bytes of the offending packet.
|
|
* We do not compare more, as this is all we need.
|
|
*/
|
|
static int icmp4_errcmp(char *packet, int plen, struct in_addr *too, char *errmsg, int elen, int errtype)
|
|
{
|
|
struct iphdr iph;
|
|
struct icmphdr icmph;
|
|
struct iphdr eiph;
|
|
char *data;
|
|
|
|
/*
|
|
* lots of memcpy to avoid unaligned accesses on alpha
|
|
*/
|
|
if (elen < sizeof(struct iphdr))
|
|
return 0;
|
|
|
|
memcpy(&iph, errmsg, sizeof(iph));
|
|
if (iph.ip_p != IPPROTO_ICMP || elen < iph.ip_hl * 4 + ICMP_BASEHDR_LEN + sizeof(eiph))
|
|
return 0;
|
|
|
|
memcpy(&icmph, errmsg + iph.ip_hl * 4, ICMP_BASEHDR_LEN);
|
|
memcpy(&eiph, errmsg + iph.ip_hl * 4 + ICMP_BASEHDR_LEN, sizeof(eiph));
|
|
if (elen < iph.ip_hl * 4 + ICMP_BASEHDR_LEN + eiph.ip_hl * 4 + 8)
|
|
return 0;
|
|
|
|
data = errmsg + iph.ip_hl * 4 + ICMP_BASEHDR_LEN + eiph.ip_hl * 4;
|
|
return icmph.icmp_type == errtype && memcmp(&too->s_addr, &eiph.ip_daddr, sizeof(too->s_addr)) == 0 &&
|
|
memcmp(data, packet, plen < 8 ?plen:8) == 0;
|
|
}
|
|
|
|
|
|
|
|
unsigned short get_rand16(void)
|
|
{
|
|
return random()&0xffff;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* IPv4/ICMPv4 ping. Called from ping (see below)
|
|
*/
|
|
int ping_send(struct in_addr addr)
|
|
{
|
|
int len, sentlen;
|
|
#ifdef __linux__
|
|
struct icmp_filter f;
|
|
#else
|
|
struct protoent *pe;
|
|
int SOL_IP;
|
|
#endif
|
|
unsigned int sum;
|
|
unsigned short *ptr;
|
|
|
|
#ifndef __linux__
|
|
if (!(pe = getprotobyname("ip"))) {
|
|
Syslog('?', "icmp ping: getprotobyname() failed: %s", strerror(errno));
|
|
return -1;
|
|
}
|
|
SOL_IP = pe->p_proto;
|
|
#endif
|
|
|
|
id = (unsigned short)get_rand16(); /* randomize a ping id */
|
|
|
|
#ifdef __linux__
|
|
/*
|
|
* Fancy ICMP filering -- only on Linux (as far is I know)
|
|
*
|
|
* In fact, there should be macros for treating icmp_filter, but I haven't found them in Linux 2.2.15.
|
|
* So, set it manually and unportable ;-)
|
|
* This filter lets ECHO_REPLY (0), DEST_UNREACH(3) and TIME_EXCEEDED(11) pass.
|
|
* !(0000 1000 0000 1001) = 0xff ff f7 f6
|
|
*/
|
|
f.data=0xfffff7f6;
|
|
if (setsockopt(ping_isocket, SOL_RAW, ICMP_FILTER, &f, sizeof(f)) == -1) {
|
|
if (icmp_errs < ICMP_MAX_ERRS)
|
|
Syslog('?', "$icmp ping: setsockopt() failed %d", ping_isocket);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
icmpd.icmp_type = ICMP_ECHO;
|
|
icmpd.icmp_code = 0;
|
|
icmpd.icmp_cksum = 0;
|
|
icmpd.icmp_id = htons((short)id);
|
|
icmpd.icmp_seq = htons(p_sequence);
|
|
|
|
/* Checksumming - Algorithm taken from nmap. Thanks... */
|
|
|
|
ptr = (unsigned short *)&icmpd;
|
|
sum = 0;
|
|
|
|
for (len = 0; len < 4; len++) {
|
|
sum += *ptr++;
|
|
}
|
|
sum = (sum >> 16) + (sum & 0xffff);
|
|
sum += (sum >> 16);
|
|
icmpd.icmp_cksum = ~sum;
|
|
|
|
memset(&to, 0, sizeof(to));
|
|
to.sin_family = AF_INET;
|
|
to.sin_port = 0;
|
|
to.sin_addr = addr;
|
|
SET_SOCKA_LEN4(to);
|
|
|
|
sentlen = sendto(ping_isocket, &icmpd, ICMP4_ECHO_LEN, 0, (struct sockaddr *)&to, sizeof(to));
|
|
if (sentlen != ICMP4_ECHO_LEN) {
|
|
if (icmp_errs < ICMP_MAX_ERRS) {
|
|
if (sentlen == -1)
|
|
Syslog('+', "ping: sent error: %s", strerror(errno));
|
|
else
|
|
Syslog('+', "ping: sent %d octets, ret %d", ICMP4_ECHO_LEN, sentlen);
|
|
}
|
|
return -2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Process received data on ping socket
|
|
*/
|
|
void ping_receive(char *buf, int len)
|
|
{
|
|
struct icmphdr icmpp;
|
|
struct iphdr iph;
|
|
int reply;
|
|
|
|
memcpy(&iph, buf, sizeof(iph));
|
|
if (len - iph.ip_hl * 4 >= ICMP_BASEHDR_LEN) {
|
|
memcpy(&icmpp, ((uint32_t *)buf)+iph.ip_hl, sizeof(icmpp));
|
|
if (iph.ip_saddr == paddr.s_addr && icmpp.icmp_type == ICMP_ECHOREPLY &&
|
|
ntohs(icmpp.icmp_id) == id && ntohs(icmpp.icmp_seq) == p_sequence) {
|
|
/*
|
|
* Good reply
|
|
*/
|
|
ping_rcvd = time(NULL);
|
|
pingresult[pingnr - 1] = TRUE;
|
|
reply = ((int)ping_rcvd - (int)ping_sent);
|
|
if (reply > 10)
|
|
Syslog('p', "Ping: got slow reply pingnr=%d to %s in %d seconds", pingnr, pingaddress, reply);
|
|
return;
|
|
} else {
|
|
/* No regular echo reply. Maybe an error? */
|
|
if (icmp4_errcmp((char *)&icmpd, ICMP4_ECHO_LEN, &to.sin_addr, buf, len, ICMP_DEST_UNREACH)) {
|
|
Syslog('p', "Ping: got destination unreachable");
|
|
return;
|
|
}
|
|
if (icmp4_errcmp((char *)&icmpd, ICMP4_ECHO_LEN, &to.sin_addr, buf, len, ICMP_TIME_EXCEEDED)) {
|
|
Syslog('p', "Ping: got time exceeded");
|
|
return;
|
|
}
|
|
#ifdef __linux__
|
|
if (icmp4_errcmp((char *)&icmpd, ICMP4_ECHO_LEN, &to.sin_addr, buf, len, ICMP_PARAMETERPROB)) {
|
|
Syslog('p', "Ping: got parameter problem");
|
|
return;
|
|
}
|
|
#endif
|
|
/*
|
|
* Received packet was not for us.
|
|
*/
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Create the ping socket, called from main() during init as root.
|
|
*/
|
|
void init_pingsocket(void)
|
|
{
|
|
if ((ping_isocket = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP)) == -1) {
|
|
if (errno == EPERM) {
|
|
fprintf(stderr, "socket init failed, mbtask not installed setuid root\n");
|
|
} else {
|
|
fprintf(stderr, "socket init failed\n");
|
|
}
|
|
exit(MBERR_INIT_ERROR);
|
|
}
|
|
|
|
/*
|
|
* If someone's messing with us, bail.
|
|
* It would be nice to issue an error message, but to where?
|
|
*/
|
|
if (ping_isocket == STDIN_FILENO || ping_isocket == STDOUT_FILENO || ping_isocket == STDERR_FILENO) {
|
|
exit(MBERR_GENERAL);
|
|
}
|
|
|
|
pingresult[0] = pingresult[1] = FALSE;
|
|
ping_next = ping_sent = ping_rcvd = time(NULL);
|
|
snprintf(pingaddress, 41, "N/A");
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Called regular, but at least each second
|
|
*/
|
|
void check_ping(void)
|
|
{
|
|
int rc = 0;
|
|
time_t now;
|
|
|
|
now = time(NULL);
|
|
if ((int)now >= (int)ping_next) {
|
|
/*
|
|
* Was previous ping received?
|
|
*/
|
|
if (pingresult[pingnr - 1] == FALSE) {
|
|
Syslog('p', "Ping: timeout to %s", pingaddress);
|
|
}
|
|
|
|
/*
|
|
* Select new address to ping
|
|
*/
|
|
if (pingnr == 1) {
|
|
pingnr = 2;
|
|
if (strlen(TCFG.isp_ping2)) {
|
|
snprintf(pingaddress, 41, "%s", TCFG.isp_ping2);
|
|
} else {
|
|
pingresult[1] = TRUE;
|
|
}
|
|
} else {
|
|
pingnr = 1;
|
|
if (strlen(TCFG.isp_ping1)) {
|
|
snprintf(pingaddress, 41, "%s", TCFG.isp_ping1);
|
|
} else {
|
|
pingresult[0] = TRUE;
|
|
}
|
|
}
|
|
|
|
ping_next = (time_t)(now + 20);
|
|
|
|
if (inet_pton(AF_INET, pingaddress, &paddr)) {
|
|
pingresult[pingnr - 1] = FALSE;
|
|
rc = ping_send(paddr);
|
|
if (rc) {
|
|
if (icmp_errs++ < ICMP_MAX_ERRS)
|
|
Syslog('?', "ping: to %s rc=%d", pingaddress, rc);
|
|
} else {
|
|
ping_sent = now;
|
|
pingresult[pingnr - 1] = FALSE;
|
|
return; // Don't check right after send
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Evaluate the result of the ping test
|
|
*/
|
|
if ((pingresult[0] == FALSE) && (pingresult[1] == FALSE)) {
|
|
icmp_errs++;
|
|
if (internet) {
|
|
Syslog('!', "Internet connection is down");
|
|
internet = FALSE;
|
|
sem_set((char *)"scanout", TRUE);
|
|
RemoveSema((char *)"is_inet");
|
|
rescan = TRUE;
|
|
}
|
|
} else {
|
|
icmp_errs = 0;
|
|
if (!internet) {
|
|
Syslog('!', "Internet connection is up");
|
|
internet = TRUE;
|
|
sem_set((char *)"scanout", TRUE);
|
|
CreateSema((char *)"is_inet");
|
|
rescan = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void deinit_ping(void)
|
|
{
|
|
int rc;
|
|
|
|
if ((rc = close(ping_isocket))) {
|
|
WriteError("$ping loop error socket close");
|
|
}
|
|
ping_isocket = -1;
|
|
|
|
Syslog('+', "Ping loop stopped");
|
|
}
|
|
|
|
|