/***
 *
 *  ipv4/icmp.c
 *
 *  rtnet - real-time networking subsystem
 *  Copyright (C) 1999, 2000 Zentropic Computing, LLC
 *                2002       Ulrich Marx <marx@kammer.uni-hannover.de>
 *                2002       Vinay Sridhara <vinaysridhara@yahoo.com>
 *                2003-2005  Jan Kiszka <jan.kiszka@web.de>
 *
 *  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.
 *
 */

#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/icmp.h>
#include <net/checksum.h>

#include <rtskb.h>
#include <rtnet_socket.h>
#include <rtnet_checksum.h>
#include <ipv4_chrdev.h>
#include <ipv4/icmp.h>
#include <ipv4/ip_fragment.h>
#include <ipv4/ip_output.h>
#include <ipv4/protocol.h>
#include <ipv4/route.h>

/***
 * Structure for sending the icmp packets
 */
struct icmp_bxm {
	unsigned int csum;
	size_t head_len;
	size_t data_len;
	off_t offset;
	struct {
		struct icmphdr icmph;
		nanosecs_abs_t timestamp;
	} head;
	union {
		struct rtskb *skb;
		void *buf;
	} data;
};

struct rt_icmp_control {
	void (*handler)(struct rtskb *skb);
	short error; /* This ICMP is classed as an error message */
};

static DEFINE_RTDM_LOCK(echo_calls_lock);
LIST_HEAD(echo_calls);

static struct {
	/*
     * Scratch pad, provided so that rt_socket_dereference(&icmp_socket);
     * remains legal.
     */
	struct rtdm_dev_context dummy;

	/*
     *  Socket for icmp replies
     *  It is not part of the socket pool. It may furthermore be used
     *  concurrently by multiple tasks because all fields are static excect
     *  skb_pool, but that one is spinlock protected.
     */
	struct rtsocket socket;
} icmp_socket_container;

#define icmp_fd (&icmp_socket_container.dummy.fd)
#define icmp_socket ((struct rtsocket *)rtdm_fd_to_private(icmp_fd))

void rt_icmp_queue_echo_request(struct rt_proc_call *call)
{
	rtdm_lockctx_t context;

	rtdm_lock_get_irqsave(&echo_calls_lock, context);
	list_add_tail(&call->list_entry, &echo_calls);
	rtdm_lock_put_irqrestore(&echo_calls_lock, context);
}

void rt_icmp_dequeue_echo_request(struct rt_proc_call *call)
{
	rtdm_lockctx_t context;

	rtdm_lock_get_irqsave(&echo_calls_lock, context);
	list_del(&call->list_entry);
	rtdm_lock_put_irqrestore(&echo_calls_lock, context);
}

void rt_icmp_cleanup_echo_requests(void)
{
	rtdm_lockctx_t context;
	struct list_head *entry;
	struct list_head *next;

	rtdm_lock_get_irqsave(&echo_calls_lock, context);
	entry = echo_calls.next;
	INIT_LIST_HEAD(&echo_calls);
	rtdm_lock_put_irqrestore(&echo_calls_lock, context);

	while (entry != &echo_calls) {
		next = entry->next;
		rtpc_complete_call_nrt((struct rt_proc_call *)entry, -EINTR);
		entry = next;
	}

	/* purge any pending ICMP fragments */
	rt_ip_frag_invalidate_socket(icmp_socket);
}

/***
 *  rt_icmp_discard - dummy function
 */
static void rt_icmp_discard(struct rtskb *skb)
{
}

static int rt_icmp_glue_reply_bits(const void *p, unsigned char *to,
				   unsigned int offset, unsigned int fraglen)
{
	struct icmp_bxm *icmp_param = (struct icmp_bxm *)p;
	struct icmphdr *icmph;
	unsigned long csum;

	/* TODO: add support for fragmented ICMP packets */
	if (offset != 0)
		return -EMSGSIZE;

	csum = rtnet_csum_copy((void *)&icmp_param->head, to,
			       icmp_param->head_len,
			       icmp_param->csum);

	csum = rtskb_copy_and_csum_bits(icmp_param->data.skb,
					icmp_param->offset,
					to + icmp_param->head_len,
					fraglen - icmp_param->head_len, csum);

	icmph = (struct icmphdr *)to;

	icmph->checksum = csum_fold(csum);

	return 0;
}

/***
 *  common reply function
 */
static void rt_icmp_send_reply(struct icmp_bxm *icmp_param, struct rtskb *skb)
{
	struct dest_route rt;
	int err;

	icmp_param->head.icmph.checksum = 0;
	icmp_param->csum = 0;

	/* route back to the source address via the incoming device */
	if (rt_ip_route_output(&rt, skb->nh.iph->saddr, skb->rtdev->local_ip) !=
	    0)
		return;

	rt_socket_reference(icmp_socket);
	err = rt_ip_build_xmit(icmp_socket, rt_icmp_glue_reply_bits, icmp_param,
			       sizeof(struct icmphdr) + icmp_param->data_len,
			       &rt, MSG_DONTWAIT);
	if (err)
		rt_socket_dereference(icmp_socket);

	rtdev_dereference(rt.rtdev);

	RTNET_ASSERT(err == 0,
		     rtdm_printk("RTnet: %s() error in xmit\n", __FUNCTION__););
	(void)err;
}

/***
 *  rt_icmp_echo - handles echo replies on our previously sent requests
 */
static void rt_icmp_echo_reply(struct rtskb *skb)
{
	rtdm_lockctx_t context;
	struct rt_proc_call *call;
	struct ipv4_cmd *cmd;

	rtdm_lock_get_irqsave(&echo_calls_lock, context);

	if (!list_empty(&echo_calls)) {
		call = (struct rt_proc_call *)echo_calls.next;
		list_del(&call->list_entry);

		rtdm_lock_put_irqrestore(&echo_calls_lock, context);
	} else {
		rtdm_lock_put_irqrestore(&echo_calls_lock, context);
		return;
	}

	cmd = rtpc_get_priv(call, struct ipv4_cmd);

	cmd->args.ping.ip_addr = skb->nh.iph->saddr;
	cmd->args.ping.rtt = 0;

	if ((skb->h.icmph->un.echo.id == cmd->args.ping.id) &&
	    (ntohs(skb->h.icmph->un.echo.sequence) ==
	     cmd->args.ping.sequence) &&
	    skb->len == cmd->args.ping.msg_size) {
		if (skb->len >= sizeof(nanosecs_abs_t))
			cmd->args.ping.rtt = rtdm_clock_read() -
					     *((nanosecs_abs_t *)skb->data);
		rtpc_complete_call(call, sizeof(struct icmphdr) + skb->len);
	} else
		rtpc_complete_call(call, 0);
}

/***
 *  rt_icmp_echo_request - handles echo requests sent by other stations
 */
static void rt_icmp_echo_request(struct rtskb *skb)
{
	struct icmp_bxm icmp_param;

	icmp_param.head.icmph = *skb->h.icmph;
	icmp_param.head.icmph.type = ICMP_ECHOREPLY;
	icmp_param.data.skb = skb;
	icmp_param.offset = 0;
	icmp_param.data_len = skb->len;
	icmp_param.head_len = sizeof(struct icmphdr);

	rt_icmp_send_reply(&icmp_param, skb);

	return;
}

static int rt_icmp_glue_request_bits(const void *p, unsigned char *to,
				     unsigned int offset, unsigned int fraglen)
{
	struct icmp_bxm *icmp_param = (struct icmp_bxm *)p;
	struct icmphdr *icmph;
	unsigned long csum;

	/* TODO: add support for fragmented ICMP packets */
	RTNET_ASSERT(
		offset == 0,
		rtdm_printk("RTnet: %s() does not support fragmentation.\n",
			    __FUNCTION__);
		return -1;);

	csum = rtnet_csum_copy((void *)&icmp_param->head, to,
			       icmp_param->head_len,
			       icmp_param->csum);

	csum = rtnet_csum_copy(icmp_param->data.buf,
			       to + icmp_param->head_len,
			       fraglen - icmp_param->head_len, csum);

	icmph = (struct icmphdr *)to;

	icmph->checksum = csum_fold(csum);

	return 0;
}

/***
 *  common request function
 */
static int rt_icmp_send_request(u32 daddr, struct icmp_bxm *icmp_param)
{
	struct dest_route rt;
	unsigned int size;
	int err;

	icmp_param->head.icmph.checksum = 0;
	icmp_param->csum = 0;

	if ((err = rt_ip_route_output(&rt, daddr, INADDR_ANY)) < 0)
		return err;

	/* TODO: add support for fragmented ICMP packets */
	size = icmp_param->head_len + icmp_param->data_len;
	if (size + 20 /* ip header */ >
	    rt.rtdev->get_mtu(rt.rtdev, RT_ICMP_PRIO))
		err = -EMSGSIZE;
	else {
		rt_socket_reference(icmp_socket);
		err = rt_ip_build_xmit(icmp_socket, rt_icmp_glue_request_bits,
				       icmp_param, size, &rt, MSG_DONTWAIT);
		if (err)
			rt_socket_dereference(icmp_socket);
	}

	rtdev_dereference(rt.rtdev);

	return err;
}

/***
 *  rt_icmp_send_echo - sends an echo request to the specified address
 */
int rt_icmp_send_echo(u32 daddr, u16 id, u16 sequence, size_t msg_size)
{
	struct icmp_bxm icmp_param;
	unsigned char *pattern_buf;
	off_t pos;
	int ret;

	/*
	 * This is just setup of a ping message, exec time is not critical, so
	 * rtdm_malloc() is ok here.
	 */
	pattern_buf = rtdm_malloc(msg_size);
	if (pattern_buf == NULL)
		return -ENOMEM;

	/* first purge any potentially pending ICMP fragments */
	rt_ip_frag_invalidate_socket(icmp_socket);

	icmp_param.head.icmph.type = ICMP_ECHO;
	icmp_param.head.icmph.code = 0;
	icmp_param.head.icmph.un.echo.id = id;
	icmp_param.head.icmph.un.echo.sequence = htons(sequence);
	icmp_param.offset = 0;

	if (msg_size >= sizeof(nanosecs_abs_t)) {
		icmp_param.head_len =
			sizeof(struct icmphdr) + sizeof(nanosecs_abs_t);
		icmp_param.data_len = msg_size - sizeof(nanosecs_abs_t);

		for (pos = 0; pos < icmp_param.data_len; pos++)
			pattern_buf[pos] = pos & 0xFF;

		icmp_param.head.timestamp = rtdm_clock_read();
	} else {
		icmp_param.head_len = sizeof(struct icmphdr) + msg_size;
		icmp_param.data_len = 0;

		for (pos = 0; pos < msg_size; pos++)
			pattern_buf[pos] = pos & 0xFF;
	}
	icmp_param.data.buf = pattern_buf;

	ret = rt_icmp_send_request(daddr, &icmp_param);
	rtdm_free(pattern_buf);

	return ret;
}

/***
 *  rt_icmp_socket
 */
int rt_icmp_socket(struct rtdm_fd *fd)
{
	/* we don't support user-created ICMP sockets */
	return -ENOPROTOOPT;
}

static struct rt_icmp_control rt_icmp_pointers[NR_ICMP_TYPES + 1] = {
	/* ECHO REPLY (0) */
	{ rt_icmp_echo_reply, 0 },
	{ rt_icmp_discard, 1 },
	{ rt_icmp_discard, 1 },

	/* DEST UNREACH (3) */
	{ rt_icmp_discard, 1 },

	/* SOURCE QUENCH (4) */
	{ rt_icmp_discard, 1 },

	/* REDIRECT (5) */
	{ rt_icmp_discard, 1 },
	{ rt_icmp_discard, 1 },
	{ rt_icmp_discard, 1 },

	/* ECHO (8) */
	{ rt_icmp_echo_request, 0 },
	{ rt_icmp_discard, 1 },
	{ rt_icmp_discard, 1 },

	/* TIME EXCEEDED (11) */
	{ rt_icmp_discard, 1 },

	/* PARAMETER PROBLEM (12) */
	{ rt_icmp_discard, 1 },

	/* TIMESTAMP (13) */
	{ rt_icmp_discard, 0 },

	/* TIMESTAMP REPLY (14) */
	{ rt_icmp_discard, 0 },

	/* INFO (15) */
	{ rt_icmp_discard, 0 },

	/* INFO REPLY (16) */
	{ rt_icmp_discard, 0 },

	/* ADDR MASK (17) */
	{ rt_icmp_discard, 0 },

	/* ADDR MASK REPLY (18) */
	{ rt_icmp_discard, 0 }
};

/***
 *  rt_icmp_dest_pool
 */
struct rtsocket *rt_icmp_dest_socket(struct rtskb *skb)
{
	rt_socket_reference(icmp_socket);
	return icmp_socket;
}

/***
 *  rt_icmp_rcv
 */
void rt_icmp_rcv(struct rtskb *skb)
{
	struct icmphdr *icmpHdr = skb->h.icmph;
	unsigned int length = skb->len;

	/* check header sanity and don't accept fragmented packets */
	if ((length < sizeof(struct icmphdr)) || (skb->next != NULL)) {
		rtdm_printk("RTnet: improper length in icmp packet\n");
		goto cleanup;
	}

	if (ip_compute_csum((unsigned char *)icmpHdr, length)) {
		rtdm_printk("RTnet: invalid checksum in icmp packet %d\n",
			    length);
		goto cleanup;
	}

	if (!rtskb_pull(skb, sizeof(struct icmphdr))) {
		rtdm_printk("RTnet: pull failed %p\n", (skb->sk));
		goto cleanup;
	}

	if (icmpHdr->type > NR_ICMP_TYPES) {
		rtdm_printk("RTnet: invalid icmp type\n");
		goto cleanup;
	}

	/* sane packet, process it */
	rt_icmp_pointers[icmpHdr->type].handler(skb);

cleanup:
	kfree_rtskb(skb);
}

/***
 *  rt_icmp_rcv_err
 */
void rt_icmp_rcv_err(struct rtskb *skb)
{
	rtdm_printk("RTnet: rt_icmp_rcv err\n");
}

/***
 *  ICMP-Initialisation
 */
static struct rtinet_protocol icmp_protocol = { .protocol = IPPROTO_ICMP,
						.dest_socket =
							&rt_icmp_dest_socket,
						.rcv_handler = &rt_icmp_rcv,
						.err_handler = &rt_icmp_rcv_err,
						.init_socket =
							&rt_icmp_socket };

/***
 *  rt_icmp_init
 */
void __init rt_icmp_init(void)
{
	int skbs;

	skbs = rt_bare_socket_init(icmp_fd, IPPROTO_ICMP, RT_ICMP_PRIO,
				   ICMP_REPLY_POOL_SIZE);
	BUG_ON(skbs < 0);
	if (skbs < ICMP_REPLY_POOL_SIZE)
		printk("RTnet: allocated only %d icmp rtskbs\n", skbs);

	icmp_socket->prot.inet.tos = 0;
	icmp_fd->refs = 1;

	rt_inet_add_protocol(&icmp_protocol);
}

/***
 *  rt_icmp_release
 */
void rt_icmp_release(void)
{
	rt_icmp_cleanup_echo_requests();
	rt_inet_del_protocol(&icmp_protocol);
	rt_bare_socket_cleanup(icmp_socket);
}