/*

 * Rdisc (this program) was developed by Sun Microsystems, Inc. and is

 * provided for unrestricted use provided that this legend is included on

 * all tape media and as a part of the software program in whole or part.

 * Users may copy or modify Rdisc without charge, and they may freely

 * distribute it.

 *

 * RDISC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE

 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.

 *

 * Rdisc is provided with no support and without any obligation on the

 * part of Sun Microsystems, Inc. to assist in its use, correction,

 * modification or enhancement.

 *

 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE

 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY RDISC

 * OR ANY PART THEREOF.

 *

 * In no event will Sun Microsystems, Inc. be liable for any lost revenue

 * or profits or other special, indirect and consequential damages, even if

 * Sun has been advised of the possibility of such damages.

 *

 * Sun Microsystems, Inc.

 * 2550 Garcia Avenue

 * Mountain View, California  94043

 */

#include <stdio.h>

#include <errno.h>

#include <signal.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/time.h>

/* Do not use "improved" glibc version! */

#include <linux/limits.h>

#include <sys/param.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <sys/file.h>

#include <malloc.h>

#include <sys/ioctl.h>

#include <linux/if.h>

#include <linux/route.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet/ip_icmp.h>

/*

 * The next include contains all defs and structures for multicast

 * that are not in SunOS 4.1.x. On a SunOS 4.1.x system none of this code

 * is ever used because it does not support multicast

 * Fraser Gardiner - Sun Microsystems Australia

 */

#include <netdb.h>

#include <arpa/inet.h>

#include <string.h>

#include <syslog.h>

#include "SNAPSHOT.h"

struct interface

{

	struct in_addr 	address;	/* Used to identify the interface */

	struct in_addr	localaddr;	/* Actual address if the interface */

	int 		preference;

	int		flags;

	struct in_addr	bcastaddr;

	struct in_addr	remoteaddr;

	struct in_addr	netmask;

	int		ifindex;

	char		name[IFNAMSIZ];

};

/*

 * TBD

 *	Use 255.255.255.255 for broadcasts - not the interface broadcast

 *	address.

 */

#define ALLIGN(ptr)	(ptr)

static int join(int sock, struct sockaddr_in *sin);

static void solicitor(struct sockaddr_in *);

#ifdef RDISC_SERVER

static void advertise(struct sockaddr_in *, int lft);

#endif

static char *pr_name(struct in_addr addr);

static void pr_pack(char *buf, int cc, struct sockaddr_in *from);

static void age_table(int time);

static void record_router(struct in_addr router, int preference, int ttl);

static void add_route(struct in_addr addr);

static void del_route(struct in_addr addr);

static void rtioctl(struct in_addr addr, int op);

static int support_multicast(void);

static int sendbcast(int s, char *packet, int packetlen);

static int sendmcast(int s, char *packet, int packetlen, struct sockaddr_in *);

static int sendbcastif(int s, char *packet, int packetlen, struct interface *ifp);

static int sendmcastif(int s, char *packet, int packetlen, struct sockaddr_in *sin, struct interface *ifp);

static int is_directly_connected(struct in_addr in);

static void initlog(void);

static void discard_table(void);

static void init(void);

#define ICMP_ROUTER_ADVERTISEMENT	9

#define ICMP_ROUTER_SOLICITATION	10

#define ALL_HOSTS_ADDRESS		"224.0.0.1"

#define ALL_ROUTERS_ADDRESS		"224.0.0.2"

#define MAXIFS 32

#if defined(__GLIBC__) && __GLIBC__ < 2

/* For router advertisement */

struct icmp_ra

{

	unsigned char	icmp_type;		/* type of message, see below */

	unsigned char	icmp_code;		/* type sub code */

	unsigned short	icmp_cksum;		/* ones complement cksum of struct */

	unsigned char	icmp_num_addrs;

	unsigned char	icmp_wpa;		/* Words per address */

	short 	icmp_lifetime;

};

struct icmp_ra_addr

{

	__u32	ira_addr;

	__u32	ira_preference;

};

#else

#define icmp_ra icmp

#endif

/* Router constants */

#define	MAX_INITIAL_ADVERT_INTERVAL	16

#define	MAX_INITIAL_ADVERTISEMENTS  	3

#define	MAX_RESPONSE_DELAY		2	/* Not used */

/* Host constants */

#define MAX_SOLICITATIONS 		3

#define SOLICITATION_INTERVAL 		3

#define MAX_SOLICITATION_DELAY		1	/* Not used */

#define INELIGIBLE_PREF			0x80000000	/* Maximum negative */

#define MAX_ADV_INT 600

/* Statics */

static int num_interfaces;

static struct interface *interfaces;

static int interfaces_size;			/* Number of elements in interfaces */

#define	MAXPACKET	4096	/* max packet size */

/* fraser */

int debugfile;

const char usage[] =

"Usage:	rdisc [-b] [-d] [-s] [-v] [-f] [-a] [-V] [send_address] [receive_address]\n"

#ifdef RDISC_SERVER

"       rdisc -r [-b] [-d] [-s] [-v] [-f] [-a] [-V] [-p <preference>] [-T <secs>]\n"

"		 [send_address] [receive_address]\n"

#endif

;

int s;			/* Socket file descriptor */

struct sockaddr_in whereto;/* Address to send to */

/* Common variables */

int verbose = 0;

int debug = 0;

int trace = 0;

int solicit = 0;

int ntransmitted = 0;

int nreceived = 0;

int forever = 0;	/* Never give up on host. If 0 defer fork until

			 * first response.

			 */

#ifdef RDISC_SERVER

/* Router variables */

int responder;

int max_adv_int = MAX_ADV_INT;

int min_adv_int;

int lifetime;

int initial_advert_interval = MAX_INITIAL_ADVERT_INTERVAL;

int initial_advertisements = MAX_INITIAL_ADVERTISEMENTS;

int preference = 0;		/* Setable with -p option */

#endif

/* Host variables */

int max_solicitations = MAX_SOLICITATIONS;

unsigned int solicitation_interval = SOLICITATION_INTERVAL;

int best_preference = 1;  	/* Set to record only the router(s) with the

				   best preference in the kernel. Not set

				   puts all routes in the kernel. */

static void graceful_finish(void);

static void finish(void);

static void timer(void);

static void initifs(void);

static unsigned short in_cksum(unsigned short *addr, int len);

static int logging = 0;

#define logerr(fmt...) ({ if (logging) syslog(LOG_ERR, fmt); \

			  else fprintf(stderr, fmt); })

#define logtrace(fmt...) ({ if (logging) syslog(LOG_INFO, fmt); \

			  else fprintf(stderr, fmt); })

#define logdebug(fmt...) ({ if (logging) syslog(LOG_DEBUG, fmt); \

			  else fprintf(stderr, fmt); })

static void logperror(char *str);

static __inline__ int isbroadcast(struct sockaddr_in *sin)

{

	return (sin->sin_addr.s_addr == INADDR_BROADCAST);

}

static __inline__ int ismulticast(struct sockaddr_in *sin)

{

	return IN_CLASSD(ntohl(sin->sin_addr.s_addr));

}

static void prusage(void)

{

	fputs(usage, stderr);

	exit(1);

}

void do_fork(void)

{

	int t;

	pid_t pid;

	long open_max;

	if (trace)

		return;

	if ((open_max = sysconf(_SC_OPEN_MAX)) == -1) {

		if (errno == 0) {

			(void) fprintf(stderr, "OPEN_MAX is not supported\n");

		} 

		else {

			(void) fprintf(stderr, "sysconf() error\n");

		}

		exit(1);

	}

	if ((pid=fork()) != 0)

		exit(0);

	for (t = 0; t < open_max; t++)

		if (t != s)

			close(t);

	setsid();

	initlog();

}

void signal_setup(int signo, void (*handler)(void))

{

	struct sigaction sa;

	memset(&sa, 0, sizeof(sa));

	sa.sa_handler = (void (*)(int))handler;

#ifdef SA_INTERRUPT

	sa.sa_flags = SA_INTERRUPT;

#endif

	sigaction(signo, &sa, NULL);

}

/*

 * 			M A I N

 */

char    *sendaddress, *recvaddress;

int main(int argc, char **argv)

{

	struct sockaddr_in from;

	char **av = argv;

	struct sockaddr_in *to = &whereto;

	struct sockaddr_in joinaddr;

	sigset_t sset, sset_empty;

#ifdef RDISC_SERVER

	int val;

	min_adv_int =( max_adv_int * 3 / 4);

	lifetime = (3*max_adv_int);

#endif

	argc--, av++;

	while (argc > 0 && *av[0] == '-') {

		while (*++av[0]) {

			switch (*av[0]) {

			case 'd':

				debug = 1;

				break;

			case 't':

				trace = 1;

				break;

			case 'v':

				verbose++;

				break;

			case 's':

				solicit = 1;

				break;

#ifdef RDISC_SERVER

			case 'r':

				responder = 1;

				break;

#endif

			case 'a':

				best_preference = 0;

				break;

			case 'b':

				best_preference = 1;

				break;

			case 'f':

				forever = 1;

				break;

			case 'V':

				printf("rdisc utility, iputils-%s\n", SNAPSHOT);

				exit(0);

#ifdef RDISC_SERVER

			case 'T':

				argc--, av++;

				if (argc != 0) {

					val = strtol(av[0], (char **)NULL, 0);

					if (val < 4 || val > 1800) {

						(void) fprintf(stderr,

							       "Bad Max Advertizement Interval\n");

						exit(1);

					}

					max_adv_int = val;

					min_adv_int =( max_adv_int * 3 / 4);

					lifetime = (3*max_adv_int);

				} else {

					prusage();

					/* NOTREACHED*/

				}

				goto next;

			case 'p':

				argc--, av++;

				if (argc != 0) {

					val = strtol(av[0], (char **)NULL, 0);

					preference = val;

				} else {

					prusage();

					/* NOTREACHED*/

				}

				goto next;

#endif

			default:

				prusage();

				/* NOTREACHED*/

			}

		}

#ifdef RDISC_SERVER

next:

#endif

		argc--, av++;

	}

	if( argc < 1)  {

		if (support_multicast()) {

			sendaddress = ALL_ROUTERS_ADDRESS;

#ifdef RDISC_SERVER

			if (responder)

				sendaddress = ALL_HOSTS_ADDRESS;

#endif

		} else

			sendaddress = "255.255.255.255";

	} else {

		sendaddress = av[0];

		argc--;

	}

	if (argc < 1) {

		if (support_multicast()) {

			recvaddress = ALL_HOSTS_ADDRESS;

#ifdef RDISC_SERVER

			if (responder)

				recvaddress = ALL_ROUTERS_ADDRESS;

#endif

		} else

			recvaddress = "255.255.255.255";

	} else {

		recvaddress = av[0];

		argc--;

	}

	if (argc != 0) {

		(void) fprintf(stderr, "Extra parameters\n");

		prusage();

		/* NOTREACHED */

	}

#ifdef RDISC_SERVER

	if (solicit && responder) {

		prusage();

		/* NOTREACHED */

	}

#endif

	if (!(solicit && !forever)) {

		do_fork();

/*

 * Added the next line to stop forking a second time

 * Fraser Gardiner - Sun Microsystems Australia

 */

		forever = 1;

	}

	memset( (char *)&whereto, 0, sizeof(struct sockaddr_in) );

	to->sin_family = AF_INET;

	to->sin_addr.s_addr = inet_addr(sendaddress);

	memset( (char *)&joinaddr, 0, sizeof(struct sockaddr_in) );

	joinaddr.sin_family = AF_INET;

	joinaddr.sin_addr.s_addr = inet_addr(recvaddress);

#ifdef RDISC_SERVER

	if (responder)

		srandom((int)gethostid());

#endif

	if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) {

		logperror("socket");

		exit(5);

	}

	setlinebuf( stdout );

	signal_setup(SIGINT, finish );

	signal_setup(SIGTERM, graceful_finish );

	signal_setup(SIGHUP, initifs );

	signal_setup(SIGALRM, timer );

	sigemptyset(&sset);

	sigemptyset(&sset_empty);

	sigaddset(&sset, SIGALRM);

	sigaddset(&sset, SIGHUP);

	sigaddset(&sset, SIGTERM);

	sigaddset(&sset, SIGINT);

	init();

	if (join(s, &joinaddr) < 0) {

		logerr("Failed joining addresses\n");

		exit (2);

	}

	timer();	/* start things going */

	for (;;) {

		unsigned char	packet[MAXPACKET];

		int len = sizeof (packet);

		socklen_t fromlen = sizeof (from);

		int cc;

		cc=recvfrom(s, (char *)packet, len, 0,

			    (struct sockaddr *)&from, &fromlen);

		if (cc<0) {

			if (errno == EINTR)

				continue;

			logperror("recvfrom");

			continue;

		}

		sigprocmask(SIG_SETMASK, &sset, NULL);

		pr_pack( (char *)packet, cc, &from );

		sigprocmask(SIG_SETMASK, &sset_empty, NULL);

	}

	/*NOTREACHED*/

}

#define TIMER_INTERVAL 	3

#define GETIFCONF_TIMER	30

static int left_until_advertise;

/* Called every TIMER_INTERVAL */

void timer()

{

	static int time;

	static int left_until_getifconf;

	static int left_until_solicit;

	time += TIMER_INTERVAL;

	left_until_getifconf -= TIMER_INTERVAL;

	left_until_advertise -= TIMER_INTERVAL;

	left_until_solicit -= TIMER_INTERVAL;

	if (left_until_getifconf < 0) {

		initifs();

		left_until_getifconf = GETIFCONF_TIMER;

	}

#ifdef RDISC_SERVER

	if (responder && left_until_advertise <= 0) {

		ntransmitted++;

		advertise(&whereto, lifetime);

		if (ntransmitted < initial_advertisements)

			left_until_advertise = initial_advert_interval;

		else

			left_until_advertise = min_adv_int +

				((max_adv_int - min_adv_int) *

				 (random() % 1000)/1000);

	} else

#endif

	if (solicit && left_until_solicit <= 0) {

		ntransmitted++;

		solicitor(&whereto);

		if (ntransmitted < max_solicitations)

			left_until_solicit = solicitation_interval;

		else {

			solicit = 0;

			if (!forever && nreceived == 0)

				exit(5);

		}

	}

	age_table(TIMER_INTERVAL);

	alarm(TIMER_INTERVAL);

}

/*

 * 			S O L I C I T O R

 *

 * Compose and transmit an ICMP ROUTER SOLICITATION REQUEST packet.

 * The IP packet will be added on by the kernel.

 */

void

solicitor(struct sockaddr_in *sin)

{

	static unsigned char outpack[MAXPACKET];

	struct icmphdr *icp = (struct icmphdr *) ALLIGN(outpack);

	int packetlen, i;

	if (verbose) {

		logtrace("Sending solicitation to %s\n",

			 pr_name(sin->sin_addr));

	}

	icp->type = ICMP_ROUTER_SOLICITATION;

	icp->code = 0;

	icp->checksum = 0;

	icp->un.gateway = 0; /* Reserved */

	packetlen = 8;

	/* Compute ICMP checksum here */

	icp->checksum = in_cksum( (unsigned short *)icp, packetlen );

	if (isbroadcast(sin))

		i = sendbcast(s, (char *)outpack, packetlen);

	else if (ismulticast(sin))

		i = sendmcast(s, (char *)outpack, packetlen, sin);

	else

		i = sendto( s, (char *)outpack, packetlen, 0,

			   (struct sockaddr *)sin, sizeof(struct sockaddr));

	if( i < 0 || i != packetlen )  {

		if( i<0 ) {

		    logperror("solicitor:sendto");

		}

		logerr("wrote %s %d chars, ret=%d\n",

			sendaddress, packetlen, i );

	}

}

#ifdef RDISC_SERVER

/*

 * 			A V E R T I S E

 *

 * Compose and transmit an ICMP ROUTER ADVERTISEMENT packet.

 * The IP packet will be added on by the kernel.

 */

void

advertise(struct sockaddr_in *sin, int lft)

{

	static unsigned char outpack[MAXPACKET];

	struct icmp_ra *rap = (struct icmp_ra *) ALLIGN(outpack);

	struct icmp_ra_addr *ap;

	int packetlen, i, cc;

	if (verbose) {

		logtrace("Sending advertisement to %s\n",

			 pr_name(sin->sin_addr));

	}

	for (i = 0; i < num_interfaces; i++) {

		rap->icmp_type = ICMP_ROUTER_ADVERTISEMENT;

		rap->icmp_code = 0;

		rap->icmp_cksum = 0;

		rap->icmp_num_addrs = 0;

		rap->icmp_wpa = 2;

		rap->icmp_lifetime = htons(lft);

		packetlen = 8;

		/*

		 * TODO handle multiple logical interfaces per

		 * physical interface. (increment with rap->icmp_wpa * 4 for

		 * each address.)

		 */

		ap = (struct icmp_ra_addr *)ALLIGN(outpack + ICMP_MINLEN);

		ap->ira_addr = interfaces[i].localaddr.s_addr;

		ap->ira_preference = htonl(interfaces[i].preference);

		packetlen += rap->icmp_wpa * 4;

		rap->icmp_num_addrs++;

		/* Compute ICMP checksum here */

		rap->icmp_cksum = in_cksum( (unsigned short *)rap, packetlen );

		if (isbroadcast(sin))

			cc = sendbcastif(s, (char *)outpack, packetlen,

					&interfaces[i]);

		else if (ismulticast(sin))

			cc = sendmcastif( s, (char *)outpack, packetlen, sin,

					&interfaces[i]);

		else {

			struct interface *ifp = &interfaces[i];

			/*

			 * Verify that the interface matches the destination

			 * address.

			 */

			if ((sin->sin_addr.s_addr & ifp->netmask.s_addr) ==

			    (ifp->address.s_addr & ifp->netmask.s_addr)) {

				if (debug) {

					logdebug("Unicast to %s ",

						 pr_name(sin->sin_addr));

					logdebug("on interface %s, %s\n",

						 ifp->name,

						 pr_name(ifp->address));

				}

				cc = sendto( s, (char *)outpack, packetlen, 0,

					    (struct sockaddr *)sin,

					    sizeof(struct sockaddr));

			} else

				cc = packetlen;

		}

		if( cc < 0 || cc != packetlen )  {

			if (cc < 0) {

				logperror("sendto");

			} else {

				logerr("wrote %s %d chars, ret=%d\n",

				       sendaddress, packetlen, cc );

			}

		}

	}

}

#endif

/*

 * 			P R _ T Y P E

 *

 * Convert an ICMP "type" field to a printable string.

 */

char *

pr_type(int t)

{

	static char *ttab[] = {

		"Echo Reply",

		"ICMP 1",

		"ICMP 2",

		"Dest Unreachable",

		"Source Quench",

		"Redirect",

		"ICMP 6",

		"ICMP 7",

		"Echo",

		"Router Advertise",

		"Router Solicitation",

		"Time Exceeded",

		"Parameter Problem",

		"Timestamp",

		"Timestamp Reply",

		"Info Request",

		"Info Reply",

		"Netmask Request",

		"Netmask Reply"

	};

	if ( t < 0 || t > 16 )

		return("OUT-OF-RANGE");

	return(ttab[t]);

}

/*

 *			P R _ N A M E

 *

 * Return a string name for the given IP address.

 */

char *pr_name(struct in_addr addr)

{

	struct sockaddr_in sin = { .sin_family = AF_INET, .sin_addr = addr };

	char hnamebuf[NI_MAXHOST] = "";

	static char buf[80];

	getnameinfo((struct sockaddr *) &sin, sizeof sin, hnamebuf, sizeof hnamebuf, NULL, 0, 0);

	snprintf(buf, sizeof buf, "%s (%s)", hnamebuf, inet_ntoa(addr));

	return(buf);

}

/*

 *			P R _ P A C K

 *

 * Print out the packet, if it came from us.  This logic is necessary

 * because ALL readers of the ICMP socket get a copy of ALL ICMP packets

 * which arrive ('tis only fair).  This permits multiple copies of this

 * program to be run without having intermingled output (or statistics!).

 */

void

pr_pack(char *buf, int cc, struct sockaddr_in *from)

{

	struct iphdr *ip;

	struct icmphdr *icp;

	int i;

	int hlen;

	ip = (struct iphdr *) ALLIGN(buf);

	hlen = ip->ihl << 2;

	if (cc < hlen + 8) {

		if (verbose)

			logtrace("packet too short (%d bytes) from %s\n", cc,

				 pr_name(from->sin_addr));

		return;

	}

	cc -= hlen;

	icp = (struct icmphdr *)ALLIGN(buf + hlen);

	switch (icp->type) {

	case ICMP_ROUTER_ADVERTISEMENT:

	{

		struct icmp_ra *rap = (struct icmp_ra *)ALLIGN(icp);

		struct icmp_ra_addr *ap;

#ifdef RDISC_SERVER

		if (responder)

			break;

#endif

		/* TBD verify that the link is multicast or broadcast */

		/* XXX Find out the link it came in over? */

		if (in_cksum((unsigned short *)ALLIGN(buf+hlen), cc)) {

			if (verbose)

				logtrace("ICMP %s from %s: Bad checksum\n",

					 pr_type((int)rap->icmp_type),

					 pr_name(from->sin_addr));

			return;

		}

		if (rap->icmp_code != 0) {

			if (verbose)

				logtrace("ICMP %s from %s: Code = %d\n",

					 pr_type((int)rap->icmp_type),

					 pr_name(from->sin_addr),

					 rap->icmp_code);

			return;

		}

		if (rap->icmp_num_addrs < 1) {

			if (verbose)

				logtrace("ICMP %s from %s: No addresses\n",

					 pr_type((int)rap->icmp_type),

					 pr_name(from->sin_addr));

			return;

		}

		if (rap->icmp_wpa < 2) {

			if (verbose)

				logtrace("ICMP %s from %s: Words/addr = %d\n",

					 pr_type((int)rap->icmp_type),

					 pr_name(from->sin_addr),

					 rap->icmp_wpa);

			return;

		}

		if ((unsigned)cc <

		    8 + rap->icmp_num_addrs * rap->icmp_wpa * 4) {

			if (verbose)

				logtrace("ICMP %s from %s: Too short %d, %d\n",

					      pr_type((int)rap->icmp_type),

					      pr_name(from->sin_addr),

					      cc,

					      8 + rap->icmp_num_addrs * rap->icmp_wpa * 4);

			return;

		}

		if (verbose)

			logtrace("ICMP %s from %s, lifetime %d\n",

				      pr_type((int)rap->icmp_type),

				      pr_name(from->sin_addr),

				      ntohs(rap->icmp_lifetime));

		/* Check that at least one router address is a neighboor

		 * on the arriving link.

		 */

		for (i = 0; (unsigned)i < rap->icmp_num_addrs; i++) {

			struct in_addr ina;

			ap = (struct icmp_ra_addr *)

				ALLIGN(buf + hlen + 8 +

				       i * rap->icmp_wpa * 4);

			ina.s_addr = ap->ira_addr;

			if (verbose)

				logtrace("\taddress %s, preference 0x%x\n",

					      pr_name(ina),

					      (unsigned int)ntohl(ap->ira_preference));

			if (is_directly_connected(ina))

				record_router(ina,

					      ntohl(ap->ira_preference),

					      ntohs(rap->icmp_lifetime));

		}

		nreceived++;

		if (!forever) {

			do_fork();

			forever = 1;

/*

 * The next line was added so that the alarm is set for the new procces

 * Fraser Gardiner Sun Microsystems Australia

 */

			(void) alarm(TIMER_INTERVAL);

		}

		break;

	}

#ifdef RDISC_SERVER

	case ICMP_ROUTER_SOLICITATION:

	{

		struct sockaddr_in sin;

		if (!responder)

			break;

		/* TBD verify that the link is multicast or broadcast */

		/* XXX Find out the link it came in over? */

		if (in_cksum((unsigned short *)ALLIGN(buf+hlen), cc)) {

			if (verbose)

				logtrace("ICMP %s from %s: Bad checksum\n",

					      pr_type((int)icp->type),

					      pr_name(from->sin_addr));

			return;

		}

		if (icp->code != 0) {

			if (verbose)

				logtrace("ICMP %s from %s: Code = %d\n",

					      pr_type((int)icp->type),

					      pr_name(from->sin_addr),

					      icp->code);

			return;

		}

		if (cc < ICMP_MINLEN) {

			if (verbose)

				logtrace("ICMP %s from %s: Too short %d, %d\n",

					      pr_type((int)icp->type),

					      pr_name(from->sin_addr),

					      cc,

					      ICMP_MINLEN);

			return;

		}

		if (verbose)

			logtrace("ICMP %s from %s\n",

				      pr_type((int)icp->type),

				      pr_name(from->sin_addr));

		/* Check that ip_src is either a neighboor

		 * on the arriving link or 0.

		 */

		sin.sin_family = AF_INET;

		if (ip->saddr == 0) {

			/* If it was sent to the broadcast address we respond

			 * to the broadcast address.

			 */

			if (IN_CLASSD(ntohl(ip->daddr)))

				sin.sin_addr.s_addr = htonl(0xe0000001);