socket.c

无线网络路有协议aodv的 linux的实现

/***************************************************************************
                          socket.c  -  description
                             -------------------
    begin                : Wed Aug 13 2003
    copyright            : (C) 2003 by Luke Klein-Berndt
    email                : [e-mail]
 ***************************************************************************/
#include "socket.h"

static struct sockaddr_in sin;
extern u_int32_t g_broadcast_ip;

int init_sock(struct socket *sock, u_int32_t ip, char *dev_name)
{

    int error;
    struct ifreq interface;
    mm_segment_t oldfs;

    //set the address we are sending from
    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = ip;
    sin.sin_port = htons(AODVPORT);

    sock->sk->reuse = 1;
    sock->sk->allocation = GFP_ATOMIC;
    sock->sk->priority = GFP_ATOMIC;

    error = sock->ops->bind(sock, (struct sockaddr *) &sin, sizeof(struct sockaddr_in));
    strncpy(interface.ifr_ifrn.ifrn_name, dev_name, IFNAMSIZ);

    oldfs = get_fs();
    set_fs(KERNEL_DS);          //thank to Soyeon Anh and Dinesh Dharmaraju for spotting this bug!
    error = sock_setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, (char *) &interface, sizeof(interface)) < 0;
    set_fs(oldfs);



    if (error < 0)
    {
        printk(KERN_ERR "Kernel AODV: Error, %d  binding socket. This means that some other \n", error);
        printk(KERN_ERR "        daemon is (or was a short time axgo) using port %i.\n", AODVPORT);
        return 0;
    }

    return 0;
}

void close_sock(void)
{
    aodv_dev *tmp_dev, *dead_dev;

    tmp_dev = first_aodv_dev();
    while (tmp_dev != NULL)
    {
        sock_release(tmp_dev->sock);
        dead_dev = tmp_dev;
        tmp_dev = tmp_dev->next;
        kfree(dead_dev);
    }
}


int local_broadcast(u_int8_t ttl, void *data,const size_t datalen)
{
    aodv_dev *tmp_dev;
    struct msghdr msg;
    struct iovec iov;
    u_int64_t curr_time = getcurrtime();
    mm_segment_t oldfs;
    int len = 0;


    if (ttl < 1)
    {
        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_NOSIGNAL;
    msg.msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
    msg.msg_iov->iov_len = (__kernel_size_t) datalen;
    msg.msg_iov->iov_base = (char *) data;

    tmp_dev = first_aodv_dev();

    while ((tmp_dev) && (tmp_dev->sock) && (sock_wspace(tmp_dev->sock->sk) >= datalen))
    {
        tmp_dev->sock->sk->broadcast = 1;
        tmp_dev->sock->sk->protinfo.af_inet.ttl = ttl;
		   oldfs = get_fs();
        set_fs(KERNEL_DS);

        len = sock_sendmsg(tmp_dev->sock, &msg,(size_t) datalen);
				
        if (len < 0)
            printk(KERN_WARNING "AODV: Error sending! err no: %d,on interface: %s\n", len, tmp_dev->dev->name);
        set_fs(oldfs);
        tmp_dev = tmp_dev->next;
    }

    return len;
}


int send_message(u_int32_t dst_ip, u_int8_t ttl, void *data, const size_t datalen, struct net_device *dev)
{
    struct msghdr msg;
    struct iovec iov;
    aodv_dev *tmp_dev;
    aodv_route *tmp_route;
    mm_segment_t oldfs;
    u_int64_t curr_time;
    u_int32_t space;
    int len;


    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 = (__kernel_size_t) datalen;
    msg.msg_iov->iov_base = (char *) data;


    if (ttl == 0)
        return 0;

    curr_time = getcurrtime();
		
		if (dev)
		{
		tmp_dev = find_aodv_dev_by_dev(dev);
		}
		else
		{
    tmp_route = find_aodv_route(dst_ip);
    if (tmp_route == NULL)
    {
        printk(KERN_WARNING "AODV: Can't find route to: %s \n", inet_ntoa(dst_ip));
        return -EHOSTUNREACH;

    }
    tmp_dev = find_aodv_dev_by_dev(tmp_route->dev);
		}


    
    if (tmp_dev == NULL)
    {

        printk(KERN_WARNING "AODV: Error sending! Unable to find interface!\n");
        return -ENODEV;
    }

    space = sock_wspace(tmp_dev->sock->sk);

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

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

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