utils.c

linux 下的aodv实现源代码

int read_stats_proc(char *buffer, char **buffer_location, off_t offset, int buffer_length,int *eof,void *data)
{

    static char *my_buffer;
    char temp_buffer[200];
    char temp[20];
    int len=0,i;
    u_int32_t curr_time;
    char dst[16];
    char hop[16];
    u_int64_t numerator;

    my_buffer=buffer;

    numerator = (getcurrtime()-monitor.last_read);
    curr_time=do_div( numerator, 1000 );

    if (curr_time!=0)
    {
        sprintf(my_buffer,"Bytes: %d\nPackets: %d\nRouting: %d\nRREP: %d\nRREQ: %d\nRERR: %d\n",monitor.bytes/curr_time,monitor.packets/curr_time,monitor.routing_packets/curr_time,monitor.rrep/curr_time,monitor.rreq/curr_time,monitor.rrer/curr_time);

        monitor.last_read=getcurrtime();
        monitor.bytes=0;
        monitor.packets=0;
        monitor.routing_packets=0;
        monitor.rreq=0;
        monitor.rrep=0;
        monitor.rrer=0;

        len = strlen(my_buffer);
        *buffer_location = my_buffer + offset;
        len -= offset;

        if (len > buffer_length)
            len = buffer_length;
        else if (len < 0)
            len = 0;
    }
    return len;
}




/****************************************************

   send_datagram
----------------------------------------------------
Used to send out a UDP packet through a
socket
****************************************************/

#ifdef AODV_MULTICAST

int rebroadcast(u_int32_t dst,u_int16_t datalen, void *data, u_int8_t ttl)
{
   struct msghdr msg;
   struct iovec iov;
    mm_segment_t oldfs;

    unsigned char *ucp;
    u_int32_t space;
    struct iphdr *iph=data;
    int retval;
    int len=0;




    /* First, test if the socket has any buffer-space left.
       If not, no need to actually try to send something.  */
		  
		
	
    ucp=(unsigned char *)&(g_my_ip);



    space = sock_wspace(multicast_sock->sk);
    
    if (space<datalen)
      {
	printk(KERN_WARNING "AODV: Space: %d, Data: %d \n",space,datalen);
	return -ENOMEM;
      }

    if (ttl < 1 )
        return 0;

    memset(&sin,0,sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr= dst;
    //    sin.sin_port         = htons(0);

    //define the message we are going to be sending out
    msg.msg_name     = (void *) &(sin);
    msg.msg_namelen  = sizeof(sin);
    msg.msg_iov  = &iov;
    msg.msg_iovlen   = 1;
    msg.msg_control  = NULL;
    msg.msg_controllen = 0;
    msg.msg_flags    = MSG_DONTWAIT|MSG_NOSIGNAL;
    msg.msg_iov->iov_len =  datalen;
    msg.msg_iov->iov_base = (char*) data;

    multicast_sock->sk->broadcast=1;
    multicast_sock->sk->protinfo.af_inet.ttl=ttl;

    oldfs = get_fs();
    set_fs(KERNEL_DS);

    len = sock_sendmsg(multicast_sock,&msg,datalen);
    if (len<0)
    {
        printk("REBROADCAST: Error sending! err no: %d, Dst: %s\n",len,inet_ntoa(dst));
    }
    set_fs(oldfs);

    return 0;
}
#endif


int local_broadcast(u_int8_t ttl, void *data, int datalen)
{
    struct interface_list_entry *tmp_interface;
    struct msghdr msg;
    struct iovec iov;
    u_int64_t curr_time;
    mm_segment_t oldfs;
    int len=0;

    curr_time=getcurrtime();

    if (ttl == 0 )
        return 0;



    memset(&sin,0,sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr= g_broadcast_ip;
    sin.sin_port         = htons((unsigned short)AODVPORT);

    //define the message we are going to be sending out
    msg.msg_name     = (void *) &(sin);
    msg.msg_namelen  = sizeof(sin);
    msg.msg_iov  = &iov;
    msg.msg_iovlen   = 1;
    msg.msg_control  = NULL;
    msg.msg_controllen = 0;
    msg.msg_flags    = MSG_DONTWAIT|MSG_NOSIGNAL;
    msg.msg_iov->iov_len = (__kernel_size_t) datalen;
    msg.msg_iov->iov_base = (char*) data;

    tmp_interface=find_first_interface_entry();
    
    while ( (tmp_interface) && (tmp_interface->sock) && ( sock_wspace(tmp_interface->sock->sk) >= datalen) )
    {
        tmp_interface->sock->sk->broadcast=1;
        tmp_interface->sock->sk->protinfo.af_inet.ttl=ttl;
        tmp_interface->last_broadcast=curr_time;

        oldfs = get_fs();
        set_fs(KERNEL_DS);

        len = sock_sendmsg(tmp_interface->sock,&msg,datalen);

        if (len<0)
            printk(KERN_WARNING "AODV: Error sending! err no: %d,on interface: %s\n",len,tmp_interface->dev->name);
        set_fs(oldfs);
	monitor.routing_packets++;
        tmp_interface=tmp_interface->next;
    }

    return len;
}


int send_message(u_int32_t dst_ip,u_int8_t ttl, void *data, int datalen)
{
    mm_segment_t oldfs;
    struct msghdr msg;
    struct interface_list_entry *tmp_interface;
    struct route_table_entry *tmp_route;
    struct iovec iov;
    u_int64_t curr_time;
    int   len;
    u_int32_t space;


    memset(&sin,0,sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr= dst_ip;
    sin.sin_port         = htons((unsigned short)AODVPORT);



    //define the message we are going to be sending out
    msg.msg_name     = (void *) &(sin);
    msg.msg_namelen  = sizeof(sin);
    msg.msg_iov  = &iov;
    msg.msg_iovlen   = 1;
    msg.msg_control  = NULL;
    msg.msg_controllen = 0;
    msg.msg_flags    = MSG_DONTWAIT|MSG_NOSIGNAL;
    msg.msg_iov->iov_len =  datalen;
    msg.msg_iov->iov_base = (char*) data;


    if (ttl == 0 )
        return 0;

    curr_time=getcurrtime();
    tmp_route=find_route_table_entry(dst_ip);
    if (tmp_route==NULL)
      {

	printk(KERN_WARNING "AODV: Can't find route to: %s \n",inet_ntoa(dst_ip));
	return -EHOSTUNREACH;

      }
    tmp_interface=find_interface_by_dev(tmp_route->dev);
    if (tmp_interface==NULL)
    {
	
        printk(KERN_WARNING "AODV: Error sending! Unable to find interface!\n");
	
        return -ENODEV;
    }

    space = sock_wspace(tmp_interface->sock->sk);
    
    if (space<datalen)
    {
	printk(KERN_WARNING "AODV: Space: %d, Data: %d \n",space,datalen);
	return -ENOMEM;
    }

    tmp_interface->sock->sk->broadcast=0;
    tmp_interface->sock->sk->protinfo.af_inet.ttl=ttl;
    tmp_interface->last_broadcast=curr_time;
    oldfs = get_fs();
    set_fs(KERNEL_DS);

    len = sock_sendmsg(tmp_interface->sock,&msg,datalen);
    if (len<0)
    {
        printk(KERN_WARNING "AODV: Error sending! err no: %d, Dst: %s\n",len,inet_ntoa(dst_ip));
    }
    set_fs(oldfs);

    monitor.routing_packets++;
    return 0;
}

/****************************************************

   getcurrtime
----------------------------------------------------
Returns the current time
****************************************************/
u_int64_t getcurrtime()
{
    struct timeval tv;
        u_int64_t      result;

    do_gettimeofday(&tv);

	//This is a fix for an error that occurs on ARM Linux Kernels because they do 64bits differently
	//Thanks to S. Peter Li for coming up with this fix!

    result = (u_int64_t)tv.tv_usec;
    do_div(result, 1000);
    return ((u_int64_t)tv.tv_sec) * 1000 + result;
}

/****************************************************

   inet_ntoa
----------------------------------------------------
Converts a IP address repersented in a 32 bit
unsigned int into a string
****************************************************/
char *inet_ntoa(__u32 ina)
{
    static char buf[4*sizeof "123"];
    unsigned char *ucp = (unsigned char *)&ina;
    sprintf(buf, "%d.%d.%d.%d",
            ucp[0] & 0xff,
            ucp[1] & 0xff,
            ucp[2] & 0xff,
            ucp[3] & 0xff);
    return buf;
}


#ifdef AODV_GATEWAY

/****************************************************

   adhoc_subnet_test
----------------------------------------------------
Tests to see if the address is the subnet defined 
as the Ad Hoc Subnet
****************************************************/
int adhoc_subnet_test( u_int32_t ina)
{

    unsigned char *ucp = (unsigned char *)&ina;
    unsigned char *uco = (unsigned char *)&g_aodv_subnet;


    if (g_aodv_subnet==0)
        return 1;

    if ((!(uco[0] & 0xff) || ((uco[0] & 0xff) == (ucp[0] & 0xff))) &&
            (!(uco[1] & 0xff) || ((uco[1] & 0xff) == (ucp[1] & 0xff))) &&
            (!(uco[2] & 0xff) || ((uco[2] & 0xff) == (ucp[2] & 0xff))) &&
            (!(uco[3] & 0xff) || ((uco[3] & 0xff) == (ucp[3] & 0xff))))
        return 1;

    printk(" AODV: %s is not in the AODV subnet\n",inet_ntoa(ina));

        return 0;
}
#endif


#ifdef AODV_MULTICAST
/****************************************************

   multicast_test
----------------------------------------------------
Tests to see if the address is a multicast address
****************************************************/
int multicast_test( u_int32_t ina)
{

    unsigned char *ucp = (unsigned char *)&ina;
    
    if (((ucp[0] & 0xff) >=224) && ((ucp[0] & 0xff)<239))
        return 1;
    else
        return 0;
}
#endif

int seq_less_or_equal(u_int32_t seq_one,u_int32_t seq_two)
{
    int *comp_seq_one = &seq_one;
    int *comp_seq_two = &seq_two;

    if (  ( *comp_seq_one - *comp_seq_two ) > 0 )
    {
        return 0;
    }
    else
        return 1;
}


int seq_greater(u_int32_t seq_one,u_int32_t seq_two)
{
    int *comp_seq_one = &seq_one;
    int *comp_seq_two = &seq_two;

    if (  ( *comp_seq_one - *comp_seq_two ) < 0 )
        return 0;
    else
        return 1;
}



/****************************************************

   inet_aton
----------------------------------------------------
Converts a string into a 32-bit unsigned int
****************************************************/
int inet_aton(const char *cp, __u32 *addr)
{
    unsigned int val;
    int                     base,
    n;
    char            c;
    u_int           parts[4];
    u_int      *pp = parts;

    for (;;)
    {

        //Collect number up to ``.''. Values are specified as for C:
        // 0x=hex, 0=octal, other=decimal.

        val = 0;
        base = 10;
        if (*cp == '0')
        {
            if (*++cp == 'x' || *cp == 'X')
                base = 16, cp++;
            else
                base = 8;
        }
        while ((c = *cp) != '\0')
        {
            if (isascii(c) && isdigit(c))
            {
                val = (val * base) + (c - '0');
                cp++;
                continue;

            }
            if (base == 16 && isascii(c) && isxdigit(c))
            {
                val = (val << 4) +
                      (c + 10 - (islower(c) ? 'a' : 'A'));
                cp++;
                continue;
            }
            break;
        }
        if (*cp == '.')
        {
            // Internet format: a.b.c.d a.b.c       (with c treated as
            // 16-bits) a.b         (with b treated as 24 bits)

            if (pp >= parts + 3 || val > 0xff)
                return (0);
            *pp++ = val, cp++;
        }
        else
            break;
    }

    // Check for trailing characters.

    if (*cp && (!isascii(*cp) || !isspace(*cp)))
        return (0);


    // Concoct the address according to the number of parts specified.

    n = pp - parts + 1;
    switch (n)
    {

    case 1:                 // a -- 32 bits
        break;

    case 2:                 //a.b -- 8.24 bits
        if (val > 0xffffff)
            return (0);
        val |= parts[0] << 24;
        break;

    case 3:                 //a.b.c -- 8.8.16 bits
        if (val > 0xffff)
            return (0);
        val |= (parts[0] << 24) | (parts[1] << 16);
        break;

    case 4:                 // a.b.c.d -- 8.8.8.8 bits
        if (val > 0xff)
            return (0);
        val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
        break;
    }
    if (addr)
        *addr= htonl(val);
    return (1);
}