/******************************************************************************/
/*                                                                            */
/*   Copyright (c) International Business Machines  Corp., 2006               */
/*                                                                            */
/*   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  */
/*                                                                            */
/******************************************************************************/

/*
 * File:
 *	ns-icmpv4_sender.c
 *
 * Description:
 *	This is ICMPv4 echo request sender.
 *	This utility is also able to set illegal information in the IP header
 *
 * Author:
 *	Mitsuru Chinen <mitch@jp.ibm.com>
 *
 * History:
 *	Mar 5 2006 - Created (Mitsuru Chinen)
 *---------------------------------------------------------------------------*/

/*
 * Header Files
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <net/ethernet.h>
#include <net/if_arp.h>

#include "ns-traffic.h"

/*
 * Structure Definitions
 */
struct icmpv4_fake {
	struct ip4_datagram pkt;
	char *src_ifname;
	struct sockaddr_ll saddr_ll;
	struct sockaddr_ll daddr_ll;
	struct in_addr saddr;
	struct in_addr daddr;
	unsigned short int pkt_size;
	unsigned short int data_size;
	double timeout;

	u_int16_t fake_flag;
};

/*
 * Gloval variables
 */
char *program_name;		/* program name */
struct sigaction handler;	/* Behavior for a signal */
int catch_sighup;		/* When catch the SIGHUP, set to non-zero */

/*
 * Function: usage()
 *
 * Descripton:
 *  Print the usage of this program. Then, terminate this program with
 *  the specified exit value.
 *
 * Argument:
 *  exit_value:	exit value
 *
 * Return value:
 *  This function does not return.
 */
void usage(char *program_name, int exit_value)
{
	FILE *stream = stdout;	/* stream where the usage is output */

	if (exit_value == EXIT_FAILURE)
		stream = stderr;

	fprintf(stream, "%s [OPTION]\n"
		"\t-I if_name\tInterface name of the source host\n"
		"\t-S ip_addr\tIPv4 address of the source host\n"
		"\t-M mac_addr\tMAC address of the destination host\n"
		"\t-D ip_addr\tIPv4 address of the destination host\n"
		"\t-s packetsize\tnumber of data bytes (exclude header)\n"
		"\t-t value\ttimeout [sec]\n"
		"\t-d\t\tdisplay debug informations\n"
		"\t-h\t\tdisplay this usage\n"
		"\n"
		"\t[options for fake]\n"
		"\t  -c\tbreak checksum\n"
		"\t  -f\tbreak fragment information\n"
		"\t  -i\tbreak IPv4 destination address\n"
		"\t  -l\tbreak header length\n"
		"\t  -L\tbreak total length\n"
		"\t  -p\tbreak protocol number\n"
		"\t  -v\tbreak IP version\n", program_name);
	exit(exit_value);
}

/*
 * Function: set_signal_flag()
 *
 * Description:
 *  This function sets global variables accordig to signal
 *
 * Argument:
 *  type: type of signal
 *
 * Return value:
 *  None
 */
void set_signal_flag(int type)
{
	if (debug)
		fprintf(stderr, "Catch signal. type is %d\n", type);

	switch (type) {
	case SIGHUP:
		catch_sighup = 1;
		handler.sa_handler = SIG_IGN;
		if (sigaction(type, &handler, NULL) < 0)
			fatal_error("sigaction()");
		break;

	default:
		fprintf(stderr, "Unexpected signal (%d) is caught\n", type);
		exit(EXIT_FAILURE);
	}
}

/*
 * Function: parse_options()
 *
 * Description:
 *  This function parse the options, then modify the fake icmp data
 *
 * Argument:
 *   argc:  the number of argument
 *   argv:  arguments
 *  fake_p: pointer to data of fake icmp data to modify
 *
 * Return value:
 *  None
 */
void parse_options(int argc, char *argv[], struct icmpv4_fake *fake_p)
{
	int optc;		/* option */
	unsigned long opt_ul;	/* option value in unsigned long */
	double opt_d;		/* option value in double */
	struct in_addr opt_addr;	/* option value in struct in_addr */
	struct sockaddr_ll opt_addr_ll;	/* option value in struct sockaddr_ll */
	int is_specified_src_ifname = 0;
	int is_specified_saddr = 0;
	int is_specified_daddr_ll = 0;
	int is_specified_daddr = 0;

	while ((optc = getopt(argc, argv, "I:S:M:D:s:t:dhcfilLpv")) != EOF) {
		switch (optc) {
		case 'I':
			fake_p->src_ifname = strdup(optarg);
			if (fake_p->src_ifname == NULL)
				fatal_error("strdup() failed.");
			is_specified_src_ifname = 1;
			break;

		case 'S':
			if (inet_pton(AF_INET, optarg, &opt_addr) <= 0) {
				fprintf(stderr, "Source address is wrong\n");
				usage(program_name, EXIT_FAILURE);
			}
			fake_p->saddr = opt_addr;
			is_specified_saddr = 1;
			break;

		case 'M':
			if (eth_pton(AF_INET, optarg, &opt_addr_ll)) {
				fprintf(stderr,
					"Destination MAC address is wrong\n");
				usage(program_name, EXIT_FAILURE);
			}
			fake_p->daddr_ll = opt_addr_ll;
			is_specified_daddr_ll = 1;
			break;

		case 'D':
			if (inet_pton(AF_INET, optarg, &opt_addr) <= 0) {
				fprintf(stderr,
					"Destination address is wrong\n");
				usage(program_name, EXIT_FAILURE);
			}
			fake_p->daddr = opt_addr;
			is_specified_daddr = 1;
			break;

		case 's':
			opt_ul = strtoul(optarg, NULL, 0);
			if (opt_ul > ICMPV4_DATA_MAXSIZE) {
				fprintf(stderr,
					"Data size sholud be less than %d\n",
					ICMPV4_DATA_MAXSIZE + 1);
				usage(program_name, EXIT_FAILURE);
			}
			fake_p->data_size = opt_ul;
			break;

		case 't':
			opt_d = strtod(optarg, NULL);
			if (opt_d < 0.0) {
				fprintf(stderr,
					"Timeout should be positive value\n");
				usage(program_name, EXIT_FAILURE);
			}
			fake_p->timeout = opt_d;
			break;

		case 'd':
			debug = 1;
			break;

		case 'h':
			usage(program_name, EXIT_SUCCESS);
			break;

			/* Options for fake */
		case 'c':
			fake_p->fake_flag |= FAKE_CHECK;
			break;

		case 'f':
			fake_p->fake_flag |= FAKE_FRAGMENT;
			break;

		case 'i':
			fake_p->fake_flag |= FAKE_DADDR;
			break;

		case 'l':
			fake_p->fake_flag |= FAKE_IHL;
			break;

		case 'L':
			fake_p->fake_flag |= FAKE_TOT_LEN;
			break;

		case 'p':
			fake_p->fake_flag |= FAKE_PROTOCOL;
			break;

		case 'v':
			fake_p->fake_flag |= FAKE_VERSION;
			break;

		default:
			usage(program_name, EXIT_FAILURE);
		}
	}

	if (!is_specified_src_ifname) {
		fprintf(stderr,
			"Interface name of the source host is not specified\n");
		usage(program_name, EXIT_FAILURE);
	}

	if (!is_specified_saddr) {
		fprintf(stderr, "Source IP address is not specified\n");
		usage(program_name, EXIT_FAILURE);
	}

	if (!is_specified_daddr_ll) {
		fprintf(stderr, "Destination MAC address is not specified\n");
		usage(program_name, EXIT_FAILURE);
	}

	if (!is_specified_daddr) {
		fprintf(stderr, "Destination IP address is not specified\n");
		usage(program_name, EXIT_FAILURE);
	}
}

/*
 * Function: complete_eth_addrs()
 *
 * Description:
 *  This function sets the source and destination ethernet address completely
 *
 * Argument:
 *  fake_p: pointer to data of fake icmp structure
 *
 * Return value:
 *  None
 *
 */
void complete_eth_addrs(struct icmpv4_fake *fake_p)
{
	int sock_fd;		/* Socket for ioctl() */
	struct ifreq ifinfo;	/* Interface information */

	if ((sock_fd = socket(AF_PACKET, SOCK_DGRAM, 0)) < 0)
		fatal_error("socket()");

	/* Source */
	fake_p->saddr_ll.sll_family = AF_PACKET;	/* Always AF_PACKET */
	fake_p->saddr_ll.sll_protocol = htons(ETH_P_IP);	/* IPv4 */
	fake_p->saddr_ll.sll_hatype = ARPHRD_ETHER;	/* Header type */
	fake_p->saddr_ll.sll_pkttype = PACKET_HOST;	/* Packet type */
	fake_p->saddr_ll.sll_halen = ETH_ALEN;	/* Length of address */

	/* Get the MAC address of the interface at source host */
	get_ifinfo(&ifinfo, sock_fd, fake_p->src_ifname, SIOCGIFHWADDR);
	memcpy(fake_p->saddr_ll.sll_addr, ifinfo.ifr_hwaddr.sa_data, ETH_ALEN);

	/* Get the interface index */
	get_ifinfo(&ifinfo, sock_fd, fake_p->src_ifname, SIOCGIFINDEX);
	fake_p->saddr_ll.sll_ifindex = ifinfo.ifr_ifindex;
	fake_p->daddr_ll.sll_ifindex = ifinfo.ifr_ifindex;

	close(sock_fd);
}

/*
 * Function: create_clean_packet()
 *
 * Description:
 *  This function creates icmpv4 packet without any fakes
 *
 * Argument:
 *  fake_p: pointer to data of fake icmp structure
 *
 * Return value:
 *  None
 */
void create_clean_packet(struct icmpv4_fake *fake_p)
{
	struct ip4_datagram pkt;	/* sending IPv4 packet */
	struct icmp4_segment *icmp_p;	/* ICMPv4 part of sending packet */
	unsigned short int pkt_size;

	memset(&pkt, '\0', sizeof(struct ip4_datagram));
	pkt_size = sizeof(struct iphdr)	/* IP header */
	    +sizeof(struct icmphdr)	/* ICMP header */
	    +fake_p->data_size;	/* ICMP payload */

	icmp_p = (struct icmp4_segment *)&(pkt.payload);

	/* IPv4 Header */
	pkt.hdr.version = 4;
	pkt.hdr.ihl = sizeof(struct iphdr) / 4;
	pkt.hdr.tos = 0;
	pkt.hdr.tot_len = htons(pkt_size);
	pkt.hdr.id = htons(IPV4_PACKET_ID);
	pkt.hdr.frag_off = htons(IPV4_DEFAULT_FLAG);
	pkt.hdr.ttl = IPV4_DEFAULT_TTL;
	pkt.hdr.protocol = IPPROTO_ICMP;
	pkt.hdr.check = 0;	/* Calculate later */
	pkt.hdr.saddr = fake_p->saddr.s_addr;
	pkt.hdr.daddr = fake_p->daddr.s_addr;

	/* ICMPv4 Header */
	icmp_p->hdr.type = ICMP_ECHO;
	icmp_p->hdr.code = 0;
	icmp_p->hdr.checksum = 0;	/* Calculate later */
	icmp_p->hdr.un.echo.id = htons(ICMP_ECHO_ID);
	icmp_p->hdr.un.echo.sequence = htons(1);

	/* ICMPv4 Payload */
	fill_payload(icmp_p->data, fake_p->data_size);

	/* Calcualte checksums */
	pkt.hdr.check = calc_checksum((u_int16_t *) (&pkt.hdr),
				      sizeof(struct iphdr));
	icmp_p->hdr.checksum = calc_checksum((u_int16_t *) icmp_p,
					     sizeof(struct icmphdr) +
					     fake_p->data_size);

	/* Store the clean packet data */
	fake_p->pkt = pkt;
	fake_p->pkt_size = pkt_size;
}

/*
 * Function: thrust_fakes()
 *
 * Description:
 *  This function thrust fake information to the icmp packet
 *
 * Argument:
 *     pkt   : Payload of the Ethernet frame (Namely, IPv6 packet
 *  fake_flag: Flag which represents what information would be faked
 *
 * Return value:
 *  None
 */
void thrust_fakes(struct ip4_datagram *pkt, u_int16_t fake_flag)
{
	int rand_val;
	size_t bitsize;
	u_int32_t seed;

	if (debug)
		fprintf(stderr, "fake_flag = %2x\n", fake_flag);

	if (fake_flag & FAKE_VERSION) {	/* version */
		bitsize = 4;
		seed = bit_change_seed(bitsize, 1);
		pkt->hdr.version ^= seed;
	}

	if (fake_flag & FAKE_IHL) {	/* header length */
		bitsize = 4;
		seed = bit_change_seed(bitsize, 1);
		pkt->hdr.ihl ^= seed;
	}

	if (fake_flag & FAKE_TOT_LEN) {	/* total length */
		bitsize = sizeof(pkt->hdr.tot_len) * 8;
		seed = bit_change_seed(bitsize, bitsize / 8);
		pkt->hdr.tot_len ^= seed;
	}

	if (fake_flag & FAKE_FRAGMENT) {	/* fragment information */
		/* Set reserved flag */
		rand_val = rand() / ((RAND_MAX + 1U) / 16);
		if (!rand_val) {
			if (debug)
				fprintf(stderr, "Up reserved bit\n");
			pkt->hdr.frag_off |= htonl(0x80000000);
		}

		/* Set more fragments flag */
		rand_val = rand() / ((RAND_MAX + 1U) / 3);
		if (!rand_val) {
			if (debug)
				fprintf(stderr, "Set more fragments flag\n");
			pkt->hdr.frag_off |= htons(0x2000);
		}

		/* Unset unfragmented flag */
		rand_val = rand() / ((RAND_MAX + 1U) / 3);
		if (!rand_val) {
			if (debug)
				fprintf(stderr, "Unset unfragmented flag\n");
			pkt->hdr.frag_off &= htons(0xbfff);
		}

		/* Set fragment offset */
		rand_val = rand() / ((RAND_MAX + 1U) / 3);
		if (!rand_val) {
			bitsize = 13;
			seed = bit_change_seed(bitsize, 0);
			if (debug)
				fprintf(stderr, "Set fragment offset %02x\n",
					seed);
			pkt->hdr.frag_off |= htons(seed);
		}
	}

	if (fake_flag & FAKE_PROTOCOL) {	/* protocol */
		rand_val = rand() / ((RAND_MAX + 1U) / 5);
		switch (rand_val) {
		case 1:
		case 2:
			if (debug)
				fprintf(stderr, "Bit reverse\n");
			bitsize = sizeof(pkt->hdr.protocol) * 8;
			seed = bit_change_seed(bitsize, 0);
			pkt->hdr.protocol ^= seed;
			break;

		case 3:
		case 4:
			if (debug)
				fprintf(stderr, "Unknown Protocol\n");
			if (rand_val) {
				int number;
				int counter;
				for (counter = 0; counter <= 0xff; counter++) {
					number =
					    rand() / ((RAND_MAX + 1U) / 0x100);
					if (getprotobynumber(number) == NULL) {
						pkt->hdr.protocol = number;
						break;
					}
				}
			}
			break;

		default:
			if (debug)
				fprintf(stderr, "Do nothing\n");
			break;
		}
	}

	if (fake_flag & FAKE_DADDR) {	/* destination address */
		bitsize = sizeof(pkt->hdr.daddr) * 8;
		seed = bit_change_seed(bitsize, bitsize / 8);
		pkt->hdr.daddr ^= seed;
	}

	/* Recalculate checksum once */
	pkt->hdr.check = 0;
	pkt->hdr.check =
	    calc_checksum((u_int16_t *) & (pkt->hdr), sizeof(struct iphdr));

	if (fake_flag & FAKE_CHECK) {	/* checksum */
		bitsize = sizeof(pkt->hdr.check) * 8;
		seed = bit_change_seed(bitsize, bitsize / 8);
		pkt->hdr.check ^= seed;
	}
}

/*
 * Function: send_packet()
 *
 * Description:
 *  This function sends icmpv4 packet
 *
 * Argument:
 *  fake_p: pointer to data of fake icmp structure
 *
 * Return value:
 *  None
 */
void send_packets(struct icmpv4_fake *fake_p)
{
	int sock_fd;
	int retval;
	struct ip4_datagram pkt;
	double start_time;

	/* Open a socket */
	sock_fd = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
	if (sock_fd < 0)
		fatal_error("socket()");

	/* Bind the socket to the physical address */
	retval = bind(sock_fd, (struct sockaddr *)&(fake_p->saddr_ll),
		      sizeof(struct sockaddr_ll));
	if (retval < 0)
		fatal_error("bind()");

	/* Set singal hander for SIGHUP */
	handler.sa_handler = set_signal_flag;
	handler.sa_flags = 0;
	if (sigfillset(&handler.sa_mask) < 0)
		fatal_error("sigfillset()");
	if (sigaction(SIGHUP, &handler, NULL) < 0)
		fatal_error("sigfillset()");

	/*
	 * loop for sending packets
	 */
	pkt = fake_p->pkt;
	start_time = time(NULL);

	for (;;) {
		if (fake_p->fake_flag) {
			pkt = fake_p->pkt;
			thrust_fakes(&pkt, fake_p->fake_flag);
		}

		retval = sendto(sock_fd, &pkt, fake_p->pkt_size, 0,
				(struct sockaddr *)&(fake_p->daddr_ll),
				sizeof(struct sockaddr_ll));
		if (retval < 0)
			fatal_error("sendto()");

		if (fake_p->timeout)	/* timeout */
			if (fake_p->timeout < difftime(time(NULL), start_time))
				break;

		if (catch_sighup)	/* catch SIGHUP */
			break;
	}

	/* Close the socket */
	close(sock_fd);
}

/*
 *
 *  Function: main()
 *
 */
int main(int argc, char *argv[])
{
	struct icmpv4_fake fake_data;

	debug = 0;
	program_name = strdup(argv[0]);
	srand(getpid());

	memset(&fake_data, '\0', sizeof(struct icmpv4_fake));
	parse_options(argc, argv, &fake_data);

	complete_eth_addrs(&fake_data);
	create_clean_packet(&fake_data);

	send_packets(&fake_data);

	exit(EXIT_SUCCESS);
}