netsukuku/src/libping.c

/**
 * PING module
 *
 * Copyright (C) 2001 Jeffrey Fulmer <jdfulmer@armstrong.com>
 * This file is part of LIBPING
 *
 * 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 of the License, 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.
 *
 * --
 *
 * This code has been lightly modified to adapt it in the Netsukuku source
 * code.
 */
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <pthread.h>
#include <stdlib.h>

#include "libping.h"
#include "xmalloc.h"
#include "log.h"

#define  MAXPACKET   65535
#define  PKTSIZE     64 
#define  HDRLEN      ICMP_MINLEN
#define  DATALEN     (PKTSIZE-HDRLEN)
#define  MAXDATA     (MAXPKT-HDRLEN-TIMLEN)
#define  DEF_TIMEOUT 5

struct ping_priv
ping_priv_default (void)
{
  struct ping_priv datum;
  datum.ident = IDENT_DEFAULT;
  datum.timo = TIMO_DEFAULT;
  return datum;
}

/**
 * elapsed_time
 * returns an int value for the difference
 * between now and starttime in milliseconds.
 */
int
elapsed_time( struct timeval *starttime ){
  struct timeval *newtime;
  int elapsed;
  newtime = (struct timeval*)xmalloc( sizeof(struct timeval));
  gettimeofday(newtime,NULL);
  elapsed = 0;
  
  if(( newtime->tv_usec - starttime->tv_usec) > 0 ){
    elapsed += (newtime->tv_usec - starttime->tv_usec)/1000 ;
  } 
  else{
    elapsed += ( 1000000 + newtime->tv_usec - starttime->tv_usec ) /1000;
    newtime->tv_sec--;
  } 
  if(( newtime->tv_sec - starttime->tv_sec ) > 0 ){
    elapsed += 1000 * ( newtime->tv_sec - starttime->tv_sec );
  } 
  if( elapsed < 1 )
    elapsed = 1;
    
  xfree( newtime );
  return( elapsed );
}

void
JOEfreeprotoent( struct protoent *p )
{
  char **a;
  xfree( p->p_name );
  if( p->p_aliases != NULL ){
    for( a = p->p_aliases; *a != NULL; a++ ){
      xfree( *a );
    }
  }
  xfree( p );
}

void
JOEfreehostent( struct hostent *h )
{
  char **p;

  xfree( h->h_name );
  if( h->h_aliases != NULL ){
    for( p = h->h_aliases; *p != NULL; ++p )
      xfree( *p );
    xfree( h->h_aliases );
  }
  if( h->h_addr_list != NULL ){
    for( p = h->h_addr_list; *p != NULL; ++p )
      xfree( *p );
    xfree (h->h_addr_list);
  }
  xfree( h );
}

static int 
in_checksum( u_short *buf, int len )
{
  register long sum = 0;
  u_short  answer = 0;

  while( len > 1 ){
    sum += *buf++;
    len -= 2;
  }

  if( len == 1 ){
    *( u_char* )( &answer ) = *( u_char* )buf;
    sum += answer;
  }
  sum = ( sum >> 16 ) + ( sum & 0xffff );
  sum += ( sum >> 16 );     
  answer = ~sum;     

  return ( answer );

} 

static int
send_ping( const char *host, struct sockaddr_in *taddr, struct ping_priv * datum )
{
  int len;
  int ss;
  unsigned char buf[ HDRLEN + DATALEN ];

#define PROTO_BUF_LEN	1024
  char   proto_buf[PROTO_BUF_LEN];
  struct protoent *proto = NULL;
  struct protoent proto_datum;

  struct hostent  *hp = NULL;
  struct hostent  hent;
  int herrno;
  char hbf[9000];
#if defined(_AIX)
  char *aixbuf;
  char *probuf;
  int  rc;
#endif/*_AIX*/

  struct icmp     *icp;
  unsigned short  last;

  len = HDRLEN + DATALEN;

#if defined(__GLIBC__)
  /* for systems using GNU libc */
  getprotobyname_r("icmp", &proto_datum, proto_buf, PROTO_BUF_LEN, &proto);
  if(( gethostbyname_r( host, &hent, hbf, sizeof(hbf), &hp, &herrno ) < 0 )){
    hp = NULL;
  }
#elif defined(sun)
  /* Solaris 5++ */
  proto = getprotobyname_r("icmp", &proto_datum, proto_buf, PROTO_BUF_LEN);
  hp    = gethostbyname_r( host, &hent, hbf, sizeof(hbf), &herrno );
#elif defined(_AIX)
  aixbuf = (char*)xmalloc( 9000 );
  probuf = (char*)xmalloc( 9000 );
  rc  = getprotobyname_r( "icmp", &proto,
                        ( struct protoent_data *)(probuf + sizeof( struct protoent)));
  rc  = gethostbyname_r ( host, (struct hostent *)aixbuf,
                        (struct hostent_data *)(aixbuf + sizeof(struct hostent)));
  hp = (struct hostent*)aixbuf;
#elif ( defined(hpux) || defined(__osf__) )
  proto  = getprotobyname( "icmp" ); 
  hp     = gethostbyname( host );
  herrno = h_errno;
#else
  /* simply hoping that get*byname is thread-safe */
  proto  = getprotobyname( "icmp" ); 
  hp     = gethostbyname( host );
  herrno = h_errno;
#endif/*OS SPECIFICS*/
  
  if( proto == NULL ) {
    return -1;
  }

  if(hp != NULL ){
    memcpy( &taddr->sin_addr, hp->h_addr_list[0], sizeof( taddr->sin_addr ));
    taddr->sin_port = 0;
    taddr->sin_family = AF_INET;
  }
  else if( inet_aton( host, &taddr->sin_addr ) == 0 ){
    return -1;
  }

  last = ntohl( taddr->sin_addr.s_addr ) & 0xFF;
  if(( last == 0x00 ) || ( last == 0xFF )){
    return -1;
  }

  if(( datum->sock = socket( AF_INET, SOCK_RAW, proto->p_proto )) < 0 ){
#ifdef  DEBUG
	  debug(DBG_NORMAL, ERROR_MSG "sock: %s" ERROR_POS, strerror(errno));
#endif/*DEBUG*/
	  return -2;
  }

  icp = (struct icmp *)buf;
  icp->icmp_type  = ICMP_ECHO;
  icp->icmp_code  = 0;
  icp->icmp_cksum = 0;
  icp->icmp_id    = getpid() & 0xFFFF;
  icp->icmp_cksum = in_checksum((u_short *)icp, len );

  if(( ss = sendto( datum->sock, buf, sizeof( buf ), 0, 
				  (struct sockaddr*)taddr, sizeof( *taddr ))) < 0 ){
#ifdef  DEBUG
	  debug(DBG_NORMAL, ERROR_MSG "sock: %s" ERROR_POS, strerror(errno));
#endif/*DEBUG*/
	  return -2;
  }
  if( ss != len ){
#ifdef  DEBUG
	  debug(DBG_NORMAL, ERROR_MSG "sock: %s" ERROR_POS, strerror(errno));
#endif/*DEBUG*/
	  return -2;
  }

#if defined(_AIX)
  xfree( aixbuf );
  xfree( probuf );
#endif 
  /* JOEfreeprotoent( proto ); */
  /* JOEfreeprotoent( &proto_datum ); */
  /* JOEfreehostent( hp ); */
  /* JOEfreehostent( &hent ); */
  return 0;
}

static int 
recv_ping( struct sockaddr_in *taddr, struct ping_priv * datum )
{
	int len;
	int from;
	int nf, cc;
	unsigned char buf[ HDRLEN + DATALEN ];
	struct icmp        *icp;
	struct sockaddr_in faddr;
	struct timeval to;
	fd_set readset;

	to.tv_sec = datum->timo / 100000;
	to.tv_usec = ( datum->timo - ( to.tv_sec * 100000 ) ) * 10;

	FD_ZERO( &readset );
	FD_SET( datum->sock, &readset );
	/* we use select to see if there is any activity
	   on the socket.  If not, then we've requested an
	   unreachable network and we'll time out here. */
	if(( nf = select( datum->sock + 1, &readset, NULL, NULL, &to )) < 0 ){
		datum->rrt = -4;
#ifdef  DEBUG
		debug(DBG_NORMAL, ERROR_MSG "sock: %s" ERROR_POS, strerror(errno));
#endif/*DEBUG*/    
		return 0;
	}
	if( nf == 0 ){ 
		return -1; 
	}

	len = HDRLEN + DATALEN;
	from = sizeof( faddr ); 

	cc = recvfrom( datum->sock, buf, len, 0, (struct sockaddr*)&faddr,(socklen_t*)&from );
	if( cc < 0 ){
		datum->rrt = -4;
#ifdef  DEBUG
		debug(DBG_NORMAL, ERROR_MSG "sock: %s" ERROR_POS, strerror(errno));
#endif/*DEBUG*/    
    return 0;
  }

  icp = (struct icmp *)(buf + HDRLEN + DATALEN );
  if( faddr.sin_addr.s_addr != taddr->sin_addr.s_addr ){
    return 1;
  }
  /*****
  if( icp->icmp_id   != ( getpid() & 0xFFFF )){
    printf( "id: %d\n",  icp->icmp_id );
    return 1; 
  }
  *****/
  return 0;
}

int 
myping( const char *hostname, int t , struct ping_priv * datum)
{
  int err;
  int rrt;
  struct sockaddr_in sa;
  struct timeval mytime;
 
  datum->ident = getpid() & 0xFFFF;

  if( t == 0 ) datum->timo = 2; 
  else         datum->timo = t;

  datum->rrt = 0;
  
  (void) gettimeofday( &mytime, (struct timezone *)NULL); 
  if(( err = send_ping( hostname, &sa, datum)) < 0 ){
    close( datum->sock );
    return err;
  }
  do {
    rrt = elapsed_time( &mytime );
    if (datum->rrt < 0)
      return 0;
    datum->rrt = rrt;
    if (datum->rrt > datum->timo * 1000 ) {
      close( datum->sock );
      return 0;
    }
  } while( recv_ping( &sa, datum ));
  close( datum->sock ); 
 
  return 1;
}

int
pinghost( const char *hostname )
{
  struct ping_priv datum = ping_priv_default();
  return myping( hostname, 0, &datum );
}

int
pingthost( const char *hostname, int t )
{
  struct ping_priv datum = ping_priv_default();
  return myping( hostname, t, &datum );
}

int
tpinghost( const char *hostname )
{
  int ret;
  struct ping_priv datum = ping_priv_default();

  ret = myping( hostname, 0, &datum );
  if(ret > 0 )
    ret = datum.rrt;
  return ret;
} 

int
tpingthost( const char *hostname, int t )
{
  int ret;
  struct ping_priv datum = ping_priv_default();

  ret = myping( hostname, t, &datum );
  if(ret > 0 )
    ret = datum.rrt;
  return ret;
}