/*
 * This file implement the WSMP(Wave Short Message Protocol)  priv API.
 *
 * Authors :	Tata P Vamsi Krishna <vamsi07450@gmail.com>
 * Copyright	2014 Tata P Vamsi Krishna <vamsi07450@gmail.com>
 *
 * (As all part of the Linux kernel, this file is GPL)
 */


#include <linux/module.h>
#include <asm/ioctls.h>
#include "wsmp.h"
#include <linux/proc_fs.h>
#include <linux/socket.h>
#include <linux/net.h>
#include <net/sock.h>
#include<linux/init.h>
#include <linux/netdevice.h>


static void wsmp_setup(struct net_device *dev)
{
	
}

 

static void wsmp_proto_sendmsg(struct kiocb *iocb, struct sock *sk,struct msghdr *msg, size_t len)
{
	struct net_device *dev;
     //   unsigned int mtu;
        struct sk_buff *skb;
	int i;
	//__be16 proto;
	//struct wsmp_sock *wsmpo = wsmp_sk(sk);
	//struct dgram_sock *ro = dgram_sk(sk);
	//unsigned char * data;
	struct wsmphdr wsmp_hdr;
	int err,hlen,tlen;
	
	
	//DECLARE_SOCKADDR(struct sockaddr_ll *, saddr, msg->msg_name);
	
	//printk("\nprotocol number%d \n",saddr->sll_protocol);
	//dev = alloc_netdev(0,"wlan0",wsmp_setup);
	dev=__dev_get_by_name(&init_net,"wlan0");
	
	if (!dev) {
		printk("alloc_netdev failed\n");
	}
	

	hlen = LL_RESERVED_SPACE(dev);
	tlen = dev->needed_tailroom;
	wsmp_hdr.wsm_version=2;
	wsmp_hdr.security_type=5;
	wsmp_hdr.cno=100;
	wsmp_hdr.data_rate=24;
	wsmp_hdr.tx_pow_level=48;
	wsmp_hdr.psid=14;
	wsmp_hdr.wsm_length=114;

	skb = sock_alloc_send_skb(sk, 237,
                        msg->msg_flags & MSG_DONTWAIT,
                        &err);

	printk("len ............%d..............\n",hlen+tlen+len+WSMP_HDR_SIZE);
        if (!skb)
                printk("error occuring allocation of sk_buff");
	
        skb_reserve(skb, hlen);

	
	skb_reset_network_header(skb);
	
	

	printk("wsmp_proto_sendmsg....%s......%d....\n",msg->msg_iov->iov_base,msg->msg_iov->iov_len);
	
	

        err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
        if (err < 0) {
		printk("memcpy_fromiovec");
		return;
	}

	printk("---------%s------\n",skb->data);
	printk("-----len:----%d---data:- %s--%x....%d...%d\n",dev->mtu,dev->name,dev->dev_addr[1],hlen,tlen);
	skb_push(skb, WSMP_HDR_SIZE);
	printk("---------%s------\n",skb->data);
        skb_reset_transport_header(skb);
        memcpy(skb_transport_header(skb), &wsmp_hdr, WSMP_HDR_SIZE);
               // goto out_skb;
	
        skb->dev = dev;
        skb->sk  = sk;
       skb->protocol = htons(0x88dc);
	
      	printk(".....%d.....%x",skb->protocol,skb->protocol);
	
	

	printk("wsmp_proto_sendmsg. return:%d.. data:%s..len:%d.. \n",err,skb->data,skb->len);
   	err = dev_queue_xmit(skb);
	
	printk("wsmp_proto_sendmsg. return:%d.. data:%s..len:%d.. \n",err,skb->data,skb->len);
    	if (err < 0) {
		printk("dev_queue_xmit");
		return;
	}
         

	  dev_put(dev);
	for (i=0; i < skb->len; i++)
		printk("%02x ",skb->data[i]);
	printk("\n....wsmp_proto_sendmsg\n");

}

static struct proto wsmp_proto = {
	.name		= "WSMP",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct wsmp_sock),
	.sendmsg	= wsmp_proto_sendmsg,	
};

static struct sock *wsmp_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
{		
		struct sock *sk;

	sk = sk_alloc(net, PF_WSMP, prio, &wsmp_proto);
	if (!sk)
		return NULL;
	sock_init_data(sock, sk);
	INIT_LIST_HEAD(&wsmp_sk(sk)->accept_q);
	
	printk("this inside wsmp_sock_alloc..\n");
	return sk;
	
}


static void wsmp_sock_init(struct sock *sk, struct sock *parent)
{
	
	printk("I am inside wsmp_sock_init\n");
	if (parent) {
		sk->sk_type = parent->sk_type;
		security_sk_clone(parent, sk);
	}
}

static int wsmp_sock_create(struct net *net, struct socket *sock, int protocol,
			   int kern)
{
	struct sock *sk;

	printk("I am inside wsmp_sock_create..\n");

	sock->state = SS_UNCONNECTED;
	
	if (sock->type != SOCK_SEQPACKET&& sock->type != SOCK_STREAM&&
			sock->type != SOCK_DGRAM)
		return -ESOCKTNOSUPPORT;
	
	sock->ops = &wsmp_sock_ops;

	sk = wsmp_sock_alloc(net, sock, protocol, GFP_ATOMIC);
	if (!sk)
		return -ENOMEM;
	
	wsmp_sock_init(sk, NULL);
	
	return 0;
}

static struct net_proto_family wsmp_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_WSMP,
	.create	= wsmp_sock_create,
};




static int __init wsmp_init(void) {

	int err;
	printk("Inserting wsmp module..\n");

	err = sock_register(&wsmp_sock_family_ops);
	if (err < 0) {
		printk("sock_register failed\n");
		return err;
	} else		
	err = proto_register(&wsmp_proto, 1);
	if (err < 0) {
		printk("proto_register failed\n");
		goto err;
	}

err:
	//sock_unregister(PF_WSMP);

	return err;
}
void __exit wsmp_exit(void)
{
	sock_unregister(PF_WSMP);
	proto_unregister(&wsmp_proto);
}

module_init(wsmp_init);
module_exit(wsmp_exit);
MODULE_LICENSE("GPL");