testcases/network/stress/ns-tools/ns-icmpv6_sender.c - platform/external/ltp - Gitiles

 /******************************************************************************/
 /*                                                                            */
 /*   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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  */
 /*                                                                            */
 /******************************************************************************/

 /*
  * File:
  *	ns-icmpv6_sender.c
  *
  * Description:
  *	This is ICMPv6 message (Echo request / MLDv2 query) sender.
  *	This utility is also able to set illegal information in the IP header
  *
  * Author:
  *	Mitsuru Chinen <mitch@jp.ibm.com>
  *
  * History:
  *	Mar 15 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 <netinet/in.h>

 #include "ns-mcast.h"
 #include "ns-traffic.h"

 /*
  * Structure Definitions
  */
 struct icmp6_info {
     struct ip6_datagram pkt;
     struct sockaddr_ll saddr_ll;
     struct sockaddr_ll daddr_ll;
     struct in6_addr saddr;
     struct in6_addr daddr;
     unsigned short int pkt_size;
     unsigned short int data_size;
     double timeout;
     struct timespec interval;

     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 */
 struct in6_addr in6addr_allnodes = IN6ADDR_ALLNODES_MULTICAST_INIT;

 /*
  * 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\tIPv6 address of the source host\n"
 		     "\t-M mac_addr\tMAC address of the destination host\n"
 		     "\t-D ip_addr\tIPv6 address of the destination host\n"
 		     "\t-t value\ttimeout [sec]\n"
 		     "\t-w value\tinterval [nanosec]\n"
 		     "\t-o\t\tsend only one ICMPv6 message\n"
 		     "\t-b\t\twork in the background\n"
 		     "\t-d\t\tdisplay debug informations\n"
 		     "\t-h\t\tdisplay this usage\n"
 		     "\n"
 		     "\t[options for echo request]\n"
 		     "\t  -s packetsize\tsize of data (exclude header)\n"
 		     "\n"
 		     "\t[options for fake]\n"
 		     "\t  -i\t\tbreak IPv6 destination address\n"
 		     "\t  -L\t\tbreak payload length\n"
 		     "\t  -n\t\tbreak next header\n"
 		     "\t  -v\t\tbreak IP version\n"
 		     "\n"
 		     "\t[options for MLDv2 query]\n"
 		     "\t  -m\t\tsend MLDv2 query\n"
 		     "\t  -a addrs\tcomma separated array of Source Addresses\n"
 		     "\t  -r value\tMax Resp Code\n"
 			    , program_name);
     exit (exit_value);
 }

 /*
  * Function: set_signal_flag()
  *
  * Description:
  *  This function sets global variables according 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: specify_hw_addr()
  *
  * Description:
  *  This function specifies the hardware address from the interface name
  *
  * Argument:
  *   lladdr_p:	pointer to the sockaddr_ll structure
  *    ifname:	interface name where icmpv6 messages go out
  *
  * Return value:
  *  None
  *
  */
 void
 specify_hw_addr(struct sockaddr_ll *lladdr_p, const char *ifname)
 {
     int sock_fd;		/* Socket for ioctl() */
     struct ifreq ifinfo;	/* Interface information */

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

     lladdr_p->sll_family    = AF_PACKET;	/* Always AF_PACKET */
     lladdr_p->sll_protocol  = htons(ETH_P_IPV6);	/* IPv6 */
     lladdr_p->sll_hatype    = ARPHRD_ETHER;	/* Header type */
     lladdr_p->sll_pkttype   = PACKET_HOST;	/* Packet type */
     lladdr_p->sll_halen	    = ETH_ALEN;		/* Length of address */

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

     /* Get the interface index */
     lladdr_p->sll_ifindex = if_nametoindex(ifname);
     close(sock_fd);
 }

 /*
  * Function: calc_hd_mcastaddr
  *
  * Description:
  *  This function calculate multicast hardware address from IPv6
  *  multicast address
  *
  * Argument:
  *   lladdr_p:	pointer to the sockaddr_ll structure
  *    addr_p:	pointer to the in6_addr structure
  *
  * Return value:
  *  None
  */
 void
 calc_hd_mcastaddr(struct sockaddr_ll *lladdr_p, struct in6_addr *addr_p)
 {
     lladdr_p->sll_family    = AF_PACKET;	/* Always AF_PACKET */
     lladdr_p->sll_protocol  = htons(ETH_P_IPV6);	/* IPv6 */
     lladdr_p->sll_ifindex   = 0;		/* Unspecified here */
     lladdr_p->sll_hatype    = ARPHRD_ETHER;	/* Header type */
     lladdr_p->sll_pkttype   = PACKET_MULTICAST;	/* Packet type */
     lladdr_p->sll_halen	    = ETH_ALEN;		/* Length of address */

     lladdr_p->sll_addr[0]   = 0x33;
     lladdr_p->sll_addr[1]   = 0x33;
     memcpy(&lladdr_p->sll_addr[2], &addr_p->s6_addr[12], ETH_ALEN - 2);
 }

 /*
  * Function: create_mld_query()
  *
  * Description:
  *  This function create a mldv2 query information.
  *
  * Argument:
  *  info_p:	pointer to data of icmp structure
  *   mrc:	Max Resp Code
  *   saddrs:	comma separated array of the source addresses
  *
  * Return value:
  *  0: Success
  *  1: Fail
  */
 int
 create_mld_query(struct icmp6_info *info_p, uint16_t mrc, char *saddrs)
 {
     struct ip6_datagram pkt;		/* ICMPv6 packet */
     struct hbh_router_alert *alart_p;	/* pointer to router alart */
     struct my_mldv2_query *query_p;	/* pointer to my_mldv2_query */
     struct pseudo_ip6_datagram pseudo;	/* ICMPv6 pseudo packet for checksum */
     uint16_t numsrc;			/* number of source address */
     unsigned short int ip6_psize;	/* size of IPv6 payload */
     unsigned short int query_size;	/* size of my_mldv2_query */
     struct in6_addr ip6;
     uint32_t idx;
     char *sp, *ep;

     memset(&pkt, '\0', sizeof(struct ip6_datagram));
     alart_p = (struct hbh_router_alert *)&(pkt.payload);
     query_p = (struct my_mldv2_query *)((unsigned char*)alart_p + sizeof(struct hbh_router_alert));

     /* calculate the number of source address */
     if (saddrs == NULL) {
 	numsrc = 0;
     } else {
 	numsrc = 1;
 	for (sp = saddrs; *sp != '\0'; sp++)
 	    if (*sp == ',')
 		numsrc++;
     }
     if (debug)
 	fprintf(stderr, "number of source address is %u\n", numsrc);

     query_size = MY_MLDV2_QUERY_SIZE(numsrc);
     ip6_psize = sizeof(struct hbh_router_alert) + query_size;

     /* IPv6 Header */
     pkt.hdr.ip6_vfc     = 6 << 4;
     pkt.hdr.ip6_flow    |= 0;
     pkt.hdr.ip6_plen    = htons(ip6_psize);
     pkt.hdr.ip6_nxt     = IPPROTO_HOPOPTS;
     pkt.hdr.ip6_hlim    = 1;
     pkt.hdr.ip6_src     = info_p->saddr;
     pkt.hdr.ip6_dst     = info_p->daddr;

     /* Router Alert Option */
     alart_p->nxthdr	= IPPROTO_ICMPV6;
     alart_p->hbh_len	= 0;
     alart_p->alart_type	= 0x05;			/* router alert */
     alart_p->alart_len	= 0x02;			/* data len */
     alart_p->alart_data	= htons(0x0000);	/* MLD */
     alart_p->padn_type	= 0x01;			/* PadN option */
     alart_p->padn_len	= 0x00;			/* 2 Octets */

     /* MLDv2 query */
     query_p->type	= MLD_LISTENER_QUERY;
     query_p->code	= 0;
     query_p->cksum	= 0;			/* Calculate later */
     query_p->maxdelay	= htons(mrc);
     query_p->resv	= 0;
     query_p->suppress	= 0;
     query_p->qrv	= 0;
     query_p->qqic	= 0;
     query_p->nsrcs	= htons(numsrc);

     /* define the multicast address */
     if (memcmp(&info_p->daddr, &in6addr_allnodes, sizeof(struct in6_addr)) == 0)
 	query_p->addr	= in6addr_any;
     else
 	query_p->addr	= info_p->daddr;

     /* substitute source addresses */
     sp = saddrs;
     for (idx = 0; idx < numsrc; idx++) {
 	ep = strchr(sp, ',');
 	if (ep != NULL)
 	    *ep = '\0';
 	if (debug)
 	    fprintf(stderr, "source address[%u]: %s\n", idx, sp);

 	if (inet_pton(AF_INET6, sp, &ip6) <= 0) {
 	    fprintf(stderr, "source address list is something wrong\n");
 	    return 1;
 	}
 	query_p->srcs[idx] = ip6;
 	sp = ep + 1;
     }

     /* ICMPv6 Pseudo packet */
     pseudo.hdr.p_ip6_src	= pkt.hdr.ip6_src;
     pseudo.hdr.p_ip6_dst	= pkt.hdr.ip6_dst;
     pseudo.hdr.p_ip6_plen	= htons(query_size);
     pseudo.hdr.p_ip6_zero1	= 0;
     pseudo.hdr.p_ip6_zero2	= 0;
     pseudo.hdr.p_ip6_nxt	= IPPROTO_ICMPV6;
     memcpy(pseudo.payload, query_p, query_size);

     /* Calcualte checksums */
     query_p->cksum = calc_checksum((u_int16_t *)(&pseudo),
 	    sizeof(struct pseudo_ip6_hdr) + query_size);

     /* Store the clean packet data */
     info_p->pkt = pkt;
     info_p->pkt_size = sizeof(struct ip6_hdr) + ip6_psize;

         return 0;
 }

 /*
  * Function: create_echo_request()
  *
  * Description:
  *  This function creates icmpv6 echo request
  *
  * Argument:
  *  info_p: pointer to data of icmp structure
  *
  * Return value:
  *  None
  */
 void
 create_echo_request(struct icmp6_info *info_p)
 {
     struct ip6_datagram pkt;		/* ICMPv6 packet */
     struct icmp6_segment *echoreq_p;	/* Echo request header and payload */
     struct pseudo_ip6_datagram pseudo;	/* ICMPv6 pseudo packet for checksum */
     unsigned short int ip6_psize;	/* payload size */

     ip6_psize = sizeof(struct icmp6_hdr)	/* ICMP header */
 		    + info_p->data_size;	/* ICMP payload */
     memset(&pkt, '\0', sizeof(struct ip6_datagram));
     echoreq_p = (struct icmp6_segment *)&(pkt.payload);

     /* IPv6 Header */
     pkt.hdr.ip6_vfc	= 6 << 4;
     pkt.hdr.ip6_flow	|= 0;
     pkt.hdr.ip6_plen	= htons(ip6_psize);
     pkt.hdr.ip6_nxt	= IPPROTO_ICMPV6;
     pkt.hdr.ip6_hlim	= IPV6_DEFAULT_HOPLIMIT;
     pkt.hdr.ip6_src	= info_p->saddr;
     pkt.hdr.ip6_dst	= info_p->daddr;

     /* Echo Request Header */
     echoreq_p->hdr.icmp6_type	= ICMP6_ECHO_REQUEST;
     echoreq_p->hdr.icmp6_code	= 0;
     echoreq_p->hdr.icmp6_cksum	= 0;	/* Calculate later */
     echoreq_p->hdr.icmp6_id		= htons(ICMP_ECHO_ID);
     echoreq_p->hdr.icmp6_seq		= htons(1);

     /* Echo Request Payload */
     fill_payload(echoreq_p->data, info_p->data_size);

     /* ICMPv6 Pseudo packet */
     pseudo.hdr.p_ip6_src	= pkt.hdr.ip6_src;
     pseudo.hdr.p_ip6_dst	= pkt.hdr.ip6_dst;
     pseudo.hdr.p_ip6_plen	= htons(ip6_psize);
     pseudo.hdr.p_ip6_zero1	= 0;
     pseudo.hdr.p_ip6_zero2	= 0;
     pseudo.hdr.p_ip6_nxt	= IPPROTO_ICMPV6;
     memcpy(pseudo.payload, echoreq_p, ip6_psize);

     /* Calcualte checksums */
     echoreq_p->hdr.icmp6_cksum = calc_checksum((u_int16_t *)(&pseudo),
 				sizeof(struct pseudo_ip6_hdr) + ip6_psize);

     /* Store the clean packet data */
     info_p->pkt = pkt;
     info_p->pkt_size = sizeof(struct ip6_hdr) + ip6_psize;
 }

 /*
  * Function: parse_options()
  *
  * Description:
  *  This function parse the options
  *
  * Argument:
  *   argc:  the number of argument
  *   argv:  arguments
  *  info_p: pointer to data of icmp data to modify
  *   bg_p:  pointer to the flag of working in backgrond
  *
  * Return value:
  *  None
  */
 void
 parse_options(int argc, char *argv[], struct icmp6_info *info_p, int *bg_p)
 {
     int optc;			/* option */
     unsigned long opt_ul;	/* option value in unsigned long */
     double opt_d;		/* option value in double */
     struct in6_addr opt_addr;	/* option value in struct in_addr */
     struct sockaddr_ll opt_addr_ll;	/* option value in struct sockaddr_ll */
     char *ifname;		/* interface name where datagrams go out */
     int  is_mld_query;		/* set to non-zero if sending MLDv2 query */
     char *mld_saddrs;		/* comma separated array of source addresses */
     uint16_t max_resp;		/* Max Resp Code */
     int is_specified_daddr_ll = 0;
     int is_specified_saddr = 0;
     int is_specified_daddr = 0;

     ifname = NULL;
     is_mld_query = 0;
     mld_saddrs = NULL;
     max_resp = MY_MLD_MAX_HOST_REPORT_DELAY;

     while ((optc = getopt(argc, argv, "I:S:M:D:t:w:obdhs:iLnvma:r:")) != EOF) {
 	switch (optc) {
 	    case 'I':
 		if (if_nametoindex(optarg) == 0) {
 		    fprintf(stderr, "specified interface is incorrect\n");
 		    usage(program_name, EXIT_FAILURE);
 		}
 		ifname = strdup(optarg);
 		if (ifname == NULL)
 		    fatal_error("strdup() failed.");
 		break;

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

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

 	    case 'D':
 		if (inet_pton(AF_INET6, optarg, &opt_addr) <= 0) {
 		    fprintf(stderr, "Destination address is wrong\n");
 		    usage(program_name, EXIT_FAILURE);
 		}
 		info_p->daddr = opt_addr;
 		is_specified_daddr = 1;
 		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);
 		}
 		info_p->timeout = opt_d;
 		break;

 	    case 'w':
 		if (strtotimespec(optarg, &info_p->interval)) {
 		    fprintf(stderr, "Interval is something wrong\n");
 		    usage(program_name, EXIT_FAILURE);
 		}
 		break;

 	    case 'o':
 		info_p->timeout = -1.0;
 		break;

 	    case 'b':
 		*bg_p = 1;
 		break;

 	    case 'd':
 		debug = 1;
 		break;

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

 	    /* Options for echo request */
 	    case 's':
 		opt_ul = strtoul(optarg, NULL, 0);
 		if (opt_ul > ICMPV6_DATA_MAXSIZE) {
 		    fprintf(stderr, "Data size sholud be less than %d\n", ICMPV6_DATA_MAXSIZE + 1);
 		    usage(program_name, EXIT_FAILURE);
 		}
 		info_p->data_size = opt_ul;
 		break;

 	    /* Options for fake */
 	    case 'i':
 		info_p->fake_flag |= FAKE_DADDR;
 		break;

 	    case 'L':
 		info_p->fake_flag |= FAKE_PLEN;
 		break;

 	    case 'n':
 		info_p->fake_flag |= FAKE_NXT;
 		break;

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

 	    /* Options for MLDv2 query */
 	    case 'm':
 		is_mld_query = 1;
 		break;

 	    case 'a':
 		mld_saddrs = strdup(optarg);
 		if (mld_saddrs == NULL)
 		    fatal_error("strdup()");
 		break;

 	    case 'r':
 		opt_ul=strtoul(optarg, NULL, 0);
 		if (opt_ul > 0xFFFF) {
 		    fprintf(stderr, "Max Resp Code should be less than 65536\n");
 		    usage(program_name, EXIT_FAILURE);
 		}
 		max_resp = opt_ul;
 		break;

 	    default:
 		usage(program_name, EXIT_FAILURE);
 	}
     }

     if (ifname == NULL) {
 	fprintf(stderr, "Outgoing interface is not specified\n");
 	usage(program_name, EXIT_FAILURE);
     }
     specify_hw_addr(&info_p->saddr_ll, ifname);

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

     if (is_mld_query) {		/* MLDv2 query */
 	if (info_p->fake_flag) {
 	    fprintf(stderr, "It is not permitted to break MLDv2 query\n");
 	    usage(program_name, EXIT_FAILURE);
 	}

 	if (! is_specified_daddr)
 	    info_p->daddr = in6addr_allnodes;

 	calc_hd_mcastaddr(&info_p->daddr_ll, &info_p->daddr);
 	if (create_mld_query(info_p, max_resp, mld_saddrs))
 	    exit(EXIT_FAILURE);
     } else {			/* echo request */
 	if (info_p->fake_flag)
 	    srand(getpid());

 	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);
 	}

 	create_echo_request(info_p);
     }
     info_p->daddr_ll.sll_ifindex = if_nametoindex(ifname);
 }

 /*
  * 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 ip6_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.ip6_vfc ^= (seed << 4);
     }

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

     if (fake_flag & FAKE_NXT) {		/* next header */
 	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.ip6_nxt) * 8;
 		seed = bit_change_seed(bitsize, 0);
 		pkt->hdr.ip6_nxt ^= 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.ip6_nxt = number;
 			    break;
 			}
 		    }
 		}
 		break;

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

     if (fake_flag & FAKE_DADDR) {	/* destination address */
 	rand_val = rand() / ((RAND_MAX + 1U) / 4);
 	bitsize = sizeof(pkt->hdr.ip6_dst.s6_addr32[rand_val]) * 8;
 	seed = bit_change_seed(bitsize, bitsize / 8);
 	pkt->hdr.ip6_dst.s6_addr32[rand_val] ^= seed;
     }
 }

 /*
  * Function: send_packet()
  *
  * Description:
  *  This function sends icmpv6 packet
  *
  * Argument:
  *  info_p: pointer to data of icmp structure
  *
  * Return value:
  *  None
  */
 void
 send_packets(struct icmp6_info *info_p)
 {
     int sock_fd;
     int retval;
     struct ip6_datagram pkt;
     double start_time;

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

     /* Bind the socket to the physical address */
     retval = bind(sock_fd, (struct sockaddr *)&(info_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	= info_p->pkt;
     start_time = time(NULL);

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

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

 	/* Check timeout:
 	   If timeout value is negative only send one datagram */
 	if (info_p->timeout)
 	    if (info_p->timeout < difftime(time(NULL), start_time))
 		break;

 	/* Wait in specified interval */
 	nanosleep(&info_p->interval, NULL);

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

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

 /*
  *
  *  Function: main()
  *
  */
 int
 main(int argc, char *argv[])
 {
     struct icmp6_info icmp6_data;
     int background = 0;

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

     memset(&icmp6_data, '\0', sizeof(struct icmp6_info));
     parse_options(argc, argv, &icmp6_data, &background);

     if (background)     /* Work in the background */
 	if (daemon(0, 0) < 0)
 	    fatal_error("daemon()");

     send_packets(&icmp6_data);

     exit(EXIT_SUCCESS);
 }
	/******************************************************************************/
	/* */
	/* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
	/* */
	/******************************************************************************/

	/*
	* File:
	* ns-icmpv6_sender.c
	*
	* Description:
	* This is ICMPv6 message (Echo request / MLDv2 query) sender.
	* This utility is also able to set illegal information in the IP header
	*
	* Author:
	* Mitsuru Chinen <mitch@jp.ibm.com>
	*
	* History:
	* Mar 15 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 <netinet/in.h>

	#include "ns-mcast.h"
	#include "ns-traffic.h"

	/*
	* Structure Definitions
	*/
	struct icmp6_info {
	struct ip6_datagram pkt;
	struct sockaddr_ll saddr_ll;
	struct sockaddr_ll daddr_ll;
	struct in6_addr saddr;
	struct in6_addr daddr;
	unsigned short int pkt_size;
	unsigned short int data_size;
	double timeout;
	struct timespec interval;

	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 */
	struct in6_addr in6addr_allnodes = IN6ADDR_ALLNODES_MULTICAST_INIT;

	/*
	* 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\tIPv6 address of the source host\n"
	"\t-M mac_addr\tMAC address of the destination host\n"
	"\t-D ip_addr\tIPv6 address of the destination host\n"
	"\t-t value\ttimeout [sec]\n"
	"\t-w value\tinterval [nanosec]\n"
	"\t-o\t\tsend only one ICMPv6 message\n"
	"\t-b\t\twork in the background\n"
	"\t-d\t\tdisplay debug informations\n"
	"\t-h\t\tdisplay this usage\n"
	"\n"
	"\t[options for echo request]\n"
	"\t -s packetsize\tsize of data (exclude header)\n"
	"\n"
	"\t[options for fake]\n"
	"\t -i\t\tbreak IPv6 destination address\n"
	"\t -L\t\tbreak payload length\n"
	"\t -n\t\tbreak next header\n"
	"\t -v\t\tbreak IP version\n"
	"\n"
	"\t[options for MLDv2 query]\n"
	"\t -m\t\tsend MLDv2 query\n"
	"\t -a addrs\tcomma separated array of Source Addresses\n"
	"\t -r value\tMax Resp Code\n"
	, program_name);
	exit (exit_value);
	}

	/*
	* Function: set_signal_flag()
	*
	* Description:
	* This function sets global variables according 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: specify_hw_addr()
	*
	* Description:
	* This function specifies the hardware address from the interface name
	*
	* Argument:
	* lladdr_p: pointer to the sockaddr_ll structure
	* ifname: interface name where icmpv6 messages go out
	*
	* Return value:
	* None
	*
	*/
	void
	specify_hw_addr(struct sockaddr_ll lladdr_p, const char ifname)
	{
	int sock_fd; /* Socket for ioctl() */
	struct ifreq ifinfo; /* Interface information */

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

	lladdr_p->sll_family = AF_PACKET; /* Always AF_PACKET */
	lladdr_p->sll_protocol = htons(ETH_P_IPV6); /* IPv6 */
	lladdr_p->sll_hatype = ARPHRD_ETHER; /* Header type */
	lladdr_p->sll_pkttype = PACKET_HOST; /* Packet type */
	lladdr_p->sll_halen = ETH_ALEN; /* Length of address */

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

	/* Get the interface index */
	lladdr_p->sll_ifindex = if_nametoindex(ifname);
	close(sock_fd);
	}

	/*
	* Function: calc_hd_mcastaddr
	*
	* Description:
	* This function calculate multicast hardware address from IPv6
	* multicast address
	*
	* Argument:
	* lladdr_p: pointer to the sockaddr_ll structure
	* addr_p: pointer to the in6_addr structure
	*
	* Return value:
	* None
	*/
	void
	calc_hd_mcastaddr(struct sockaddr_ll lladdr_p, struct in6_addr addr_p)
	{
	lladdr_p->sll_family = AF_PACKET; /* Always AF_PACKET */
	lladdr_p->sll_protocol = htons(ETH_P_IPV6); /* IPv6 */
	lladdr_p->sll_ifindex = 0; /* Unspecified here */
	lladdr_p->sll_hatype = ARPHRD_ETHER; /* Header type */
	lladdr_p->sll_pkttype = PACKET_MULTICAST; /* Packet type */
	lladdr_p->sll_halen = ETH_ALEN; /* Length of address */

	lladdr_p->sll_addr[0] = 0x33;
	lladdr_p->sll_addr[1] = 0x33;
	memcpy(&lladdr_p->sll_addr[2], &addr_p->s6_addr[12], ETH_ALEN - 2);
	}

	/*
	* Function: create_mld_query()
	*
	* Description:
	* This function create a mldv2 query information.
	*
	* Argument:
	* info_p: pointer to data of icmp structure
	* mrc: Max Resp Code
	* saddrs: comma separated array of the source addresses
	*
	* Return value:
	* 0: Success
	* 1: Fail
	*/
	int
	create_mld_query(struct icmp6_info info_p, uint16_t mrc, char saddrs)
	{
	struct ip6_datagram pkt; /* ICMPv6 packet */
	struct hbh_router_alert alart_p; / pointer to router alart */
	struct my_mldv2_query query_p; / pointer to my_mldv2_query */
	struct pseudo_ip6_datagram pseudo; /* ICMPv6 pseudo packet for checksum */
	uint16_t numsrc; /* number of source address */
	unsigned short int ip6_psize; /* size of IPv6 payload */
	unsigned short int query_size; /* size of my_mldv2_query */
	struct in6_addr ip6;
	uint32_t idx;
	char sp, ep;

	memset(&pkt, '\0', sizeof(struct ip6_datagram));
	alart_p = (struct hbh_router_alert *)&(pkt.payload);
	query_p = (struct my_mldv2_query )((unsigned char)alart_p + sizeof(struct hbh_router_alert));

	/* calculate the number of source address */
	if (saddrs == NULL) {
	numsrc = 0;
	} else {
	numsrc = 1;
	for (sp = saddrs; *sp != '\0'; sp++)
	if (*sp == ',')
	numsrc++;
	}
	if (debug)
	fprintf(stderr, "number of source address is %u\n", numsrc);

	query_size = MY_MLDV2_QUERY_SIZE(numsrc);
	ip6_psize = sizeof(struct hbh_router_alert) + query_size;

	/* IPv6 Header */
	pkt.hdr.ip6_vfc = 6 << 4;
	pkt.hdr.ip6_flow \|= 0;
	pkt.hdr.ip6_plen = htons(ip6_psize);
	pkt.hdr.ip6_nxt = IPPROTO_HOPOPTS;
	pkt.hdr.ip6_hlim = 1;
	pkt.hdr.ip6_src = info_p->saddr;
	pkt.hdr.ip6_dst = info_p->daddr;

	/* Router Alert Option */
	alart_p->nxthdr = IPPROTO_ICMPV6;
	alart_p->hbh_len = 0;
	alart_p->alart_type = 0x05; /* router alert */
	alart_p->alart_len = 0x02; /* data len */
	alart_p->alart_data = htons(0x0000); /* MLD */
	alart_p->padn_type = 0x01; /* PadN option */
	alart_p->padn_len = 0x00; /* 2 Octets */

	/* MLDv2 query */
	query_p->type = MLD_LISTENER_QUERY;
	query_p->code = 0;
	query_p->cksum = 0; /* Calculate later */
	query_p->maxdelay = htons(mrc);
	query_p->resv = 0;
	query_p->suppress = 0;
	query_p->qrv = 0;
	query_p->qqic = 0;
	query_p->nsrcs = htons(numsrc);

	/* define the multicast address */
	if (memcmp(&info_p->daddr, &in6addr_allnodes, sizeof(struct in6_addr)) == 0)
	query_p->addr = in6addr_any;
	else
	query_p->addr = info_p->daddr;

	/* substitute source addresses */
	sp = saddrs;
	for (idx = 0; idx < numsrc; idx++) {
	ep = strchr(sp, ',');
	if (ep != NULL)
	*ep = '\0';
	if (debug)
	fprintf(stderr, "source address[%u]: %s\n", idx, sp);

	if (inet_pton(AF_INET6, sp, &ip6) <= 0) {
	fprintf(stderr, "source address list is something wrong\n");
	return 1;
	}
	query_p->srcs[idx] = ip6;
	sp = ep + 1;
	}

	/* ICMPv6 Pseudo packet */
	pseudo.hdr.p_ip6_src = pkt.hdr.ip6_src;
	pseudo.hdr.p_ip6_dst = pkt.hdr.ip6_dst;
	pseudo.hdr.p_ip6_plen = htons(query_size);
	pseudo.hdr.p_ip6_zero1 = 0;
	pseudo.hdr.p_ip6_zero2 = 0;
	pseudo.hdr.p_ip6_nxt = IPPROTO_ICMPV6;
	memcpy(pseudo.payload, query_p, query_size);

	/* Calcualte checksums */
	query_p->cksum = calc_checksum((u_int16_t *)(&pseudo),
	sizeof(struct pseudo_ip6_hdr) + query_size);

	/* Store the clean packet data */
	info_p->pkt = pkt;
	info_p->pkt_size = sizeof(struct ip6_hdr) + ip6_psize;

	return 0;
	}

	/*
	* Function: create_echo_request()
	*
	* Description:
	* This function creates icmpv6 echo request
	*
	* Argument:
	* info_p: pointer to data of icmp structure
	*
	* Return value:
	* None
	*/
	void
	create_echo_request(struct icmp6_info *info_p)
	{
	struct ip6_datagram pkt; /* ICMPv6 packet */
	struct icmp6_segment echoreq_p; / Echo request header and payload */
	struct pseudo_ip6_datagram pseudo; /* ICMPv6 pseudo packet for checksum */
	unsigned short int ip6_psize; /* payload size */

	ip6_psize = sizeof(struct icmp6_hdr) /* ICMP header */
	+ info_p->data_size; /* ICMP payload */
	memset(&pkt, '\0', sizeof(struct ip6_datagram));
	echoreq_p = (struct icmp6_segment *)&(pkt.payload);

	/* IPv6 Header */
	pkt.hdr.ip6_vfc = 6 << 4;
	pkt.hdr.ip6_flow \|= 0;
	pkt.hdr.ip6_plen = htons(ip6_psize);
	pkt.hdr.ip6_nxt = IPPROTO_ICMPV6;
	pkt.hdr.ip6_hlim = IPV6_DEFAULT_HOPLIMIT;
	pkt.hdr.ip6_src = info_p->saddr;
	pkt.hdr.ip6_dst = info_p->daddr;

	/* Echo Request Header */
	echoreq_p->hdr.icmp6_type = ICMP6_ECHO_REQUEST;
	echoreq_p->hdr.icmp6_code = 0;
	echoreq_p->hdr.icmp6_cksum = 0; /* Calculate later */
	echoreq_p->hdr.icmp6_id = htons(ICMP_ECHO_ID);
	echoreq_p->hdr.icmp6_seq = htons(1);

	/* Echo Request Payload */
	fill_payload(echoreq_p->data, info_p->data_size);

	/* ICMPv6 Pseudo packet */
	pseudo.hdr.p_ip6_src = pkt.hdr.ip6_src;
	pseudo.hdr.p_ip6_dst = pkt.hdr.ip6_dst;
	pseudo.hdr.p_ip6_plen = htons(ip6_psize);
	pseudo.hdr.p_ip6_zero1 = 0;
	pseudo.hdr.p_ip6_zero2 = 0;
	pseudo.hdr.p_ip6_nxt = IPPROTO_ICMPV6;
	memcpy(pseudo.payload, echoreq_p, ip6_psize);

	/* Calcualte checksums */
	echoreq_p->hdr.icmp6_cksum = calc_checksum((u_int16_t *)(&pseudo),
	sizeof(struct pseudo_ip6_hdr) + ip6_psize);

	/* Store the clean packet data */
	info_p->pkt = pkt;
	info_p->pkt_size = sizeof(struct ip6_hdr) + ip6_psize;
	}

	/*
	* Function: parse_options()
	*
	* Description:
	* This function parse the options
	*
	* Argument:
	* argc: the number of argument
	* argv: arguments
	* info_p: pointer to data of icmp data to modify
	* bg_p: pointer to the flag of working in backgrond
	*
	* Return value:
	* None
	*/
	void
	parse_options(int argc, char argv[], struct icmp6_info info_p, int *bg_p)
	{
	int optc; /* option */
	unsigned long opt_ul; /* option value in unsigned long */
	double opt_d; /* option value in double */
	struct in6_addr opt_addr; /* option value in struct in_addr */
	struct sockaddr_ll opt_addr_ll; /* option value in struct sockaddr_ll */
	char ifname; / interface name where datagrams go out */
	int is_mld_query; /* set to non-zero if sending MLDv2 query */
	char mld_saddrs; / comma separated array of source addresses */
	uint16_t max_resp; /* Max Resp Code */
	int is_specified_daddr_ll = 0;
	int is_specified_saddr = 0;
	int is_specified_daddr = 0;

	ifname = NULL;
	is_mld_query = 0;
	mld_saddrs = NULL;
	max_resp = MY_MLD_MAX_HOST_REPORT_DELAY;

	while ((optc = getopt(argc, argv, "I:S:M:D:t:w:obdhs:iLnvma:r:")) != EOF) {
	switch (optc) {
	case 'I':
	if (if_nametoindex(optarg) == 0) {
	fprintf(stderr, "specified interface is incorrect\n");
	usage(program_name, EXIT_FAILURE);
	}
	ifname = strdup(optarg);
	if (ifname == NULL)
	fatal_error("strdup() failed.");
	break;

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

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

	case 'D':
	if (inet_pton(AF_INET6, optarg, &opt_addr) <= 0) {
	fprintf(stderr, "Destination address is wrong\n");
	usage(program_name, EXIT_FAILURE);
	}
	info_p->daddr = opt_addr;
	is_specified_daddr = 1;
	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);
	}
	info_p->timeout = opt_d;
	break;

	case 'w':
	if (strtotimespec(optarg, &info_p->interval)) {
	fprintf(stderr, "Interval is something wrong\n");
	usage(program_name, EXIT_FAILURE);
	}
	break;

	case 'o':
	info_p->timeout = -1.0;
	break;

	case 'b':
	*bg_p = 1;
	break;

	case 'd':
	debug = 1;
	break;

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

	/* Options for echo request */
	case 's':
	opt_ul = strtoul(optarg, NULL, 0);
	if (opt_ul > ICMPV6_DATA_MAXSIZE) {
	fprintf(stderr, "Data size sholud be less than %d\n", ICMPV6_DATA_MAXSIZE + 1);
	usage(program_name, EXIT_FAILURE);
	}
	info_p->data_size = opt_ul;
	break;

	/* Options for fake */
	case 'i':
	info_p->fake_flag \|= FAKE_DADDR;
	break;

	case 'L':
	info_p->fake_flag \|= FAKE_PLEN;
	break;

	case 'n':
	info_p->fake_flag \|= FAKE_NXT;
	break;

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

	/* Options for MLDv2 query */
	case 'm':
	is_mld_query = 1;
	break;

	case 'a':
	mld_saddrs = strdup(optarg);
	if (mld_saddrs == NULL)
	fatal_error("strdup()");
	break;

	case 'r':
	opt_ul=strtoul(optarg, NULL, 0);
	if (opt_ul > 0xFFFF) {
	fprintf(stderr, "Max Resp Code should be less than 65536\n");
	usage(program_name, EXIT_FAILURE);
	}
	max_resp = opt_ul;
	break;

	default:
	usage(program_name, EXIT_FAILURE);
	}
	}

	if (ifname == NULL) {
	fprintf(stderr, "Outgoing interface is not specified\n");
	usage(program_name, EXIT_FAILURE);
	}
	specify_hw_addr(&info_p->saddr_ll, ifname);

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

	if (is_mld_query) { /* MLDv2 query */
	if (info_p->fake_flag) {
	fprintf(stderr, "It is not permitted to break MLDv2 query\n");
	usage(program_name, EXIT_FAILURE);
	}

	if (! is_specified_daddr)
	info_p->daddr = in6addr_allnodes;

	calc_hd_mcastaddr(&info_p->daddr_ll, &info_p->daddr);
	if (create_mld_query(info_p, max_resp, mld_saddrs))
	exit(EXIT_FAILURE);
	} else { /* echo request */
	if (info_p->fake_flag)
	srand(getpid());

	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);
	}

	create_echo_request(info_p);
	}
	info_p->daddr_ll.sll_ifindex = if_nametoindex(ifname);
	}

	/*
	* 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 ip6_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.ip6_vfc ^= (seed << 4);
	}

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

	if (fake_flag & FAKE_NXT) { /* next header */
	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.ip6_nxt) * 8;
	seed = bit_change_seed(bitsize, 0);
	pkt->hdr.ip6_nxt ^= 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.ip6_nxt = number;
	break;
	}
	}
	}
	break;

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

	if (fake_flag & FAKE_DADDR) { /* destination address */
	rand_val = rand() / ((RAND_MAX + 1U) / 4);
	bitsize = sizeof(pkt->hdr.ip6_dst.s6_addr32[rand_val]) * 8;
	seed = bit_change_seed(bitsize, bitsize / 8);
	pkt->hdr.ip6_dst.s6_addr32[rand_val] ^= seed;
	}
	}

	/*
	* Function: send_packet()
	*
	* Description:
	* This function sends icmpv6 packet
	*
	* Argument:
	* info_p: pointer to data of icmp structure
	*
	* Return value:
	* None
	*/
	void
	send_packets(struct icmp6_info *info_p)
	{
	int sock_fd;
	int retval;
	struct ip6_datagram pkt;
	double start_time;

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

	/* Bind the socket to the physical address */
	retval = bind(sock_fd, (struct sockaddr *)&(info_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 = info_p->pkt;
	start_time = time(NULL);

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

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

	/* Check timeout:
	If timeout value is negative only send one datagram */
	if (info_p->timeout)
	if (info_p->timeout < difftime(time(NULL), start_time))
	break;

	/* Wait in specified interval */
	nanosleep(&info_p->interval, NULL);

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

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

	/*
	*
	* Function: main()
	*
	*/
	int
	main(int argc, char *argv[])
	{
	struct icmp6_info icmp6_data;
	int background = 0;

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

	memset(&icmp6_data, '\0', sizeof(struct icmp6_info));
	parse_options(argc, argv, &icmp6_data, &background);

	if (background) /* Work in the background */
	if (daemon(0, 0) < 0)
	fatal_error("daemon()");

	send_packets(&icmp6_data);

	exit(EXIT_SUCCESS);
	}