--- /dev/null
+/*
+ * EMULAB-COPYRIGHT
+ * Copyright (c) 2000-2002 University of Utah and the Flux Group.
+ * All rights reserved.
+ */
+
+/*
+ * Send the magical ping of death ICMP type
+ */
+
+
+#include <time.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include <arpa/inet.h>
+
+#define IPOD_ICMPTYPE 6
+#define IPOD_ICMPCODE 6
+#define IPOD_IPLEN 666
+#define IPOD_IDLEN 32
+
+int icmpid = 0;
+static char myid[IPOD_IDLEN];
+static int myidlen = 0;
+
+u_short in_cksum(u_short *addr, int len);
+void icmpmap_init(); /* For getting information */
+void icmp_info(struct icmp *icmp, char *outbuf, int maxlen);
+
+/*
+ * We perform lookups on the hosts, and then store them in a chain
+ * here.
+ */
+
+struct hostdesc {
+ char *hostname;
+ struct in_addr hostaddr;
+ struct hostdesc *next;
+};
+
+struct hostdesc *hostnames;
+struct hostdesc *hosttail;
+
+/*
+ * Set up the list of hosts. Return the count.
+ */
+
+int makehosts(char **hostlist)
+{
+ int i;
+ struct hostent *hp;
+ struct in_addr tmpaddr;
+ int hostcount = 0;
+
+ for (i = 0; hostlist[i]; i++) {
+#ifdef DEBUG
+ printf("Resolving %s\n", hostlist[i]);
+#endif
+ if (!hostlist[i] ||
+ !hostlist[i][0] ||
+ strlen(hostlist[i]) > MAXHOSTNAMELEN) {
+ fprintf(stderr, "bad host entry, exiting\n");
+ exit(-1);
+ }
+ if (!inet_aton(hostlist[i], &tmpaddr)) {
+ if ((hp = gethostbyname(hostlist[i])) == NULL) {
+ /* Could not resolve it. Skip it. */
+ fprintf(stderr, "%s: unknown host\n",
+ hostlist[i]);
+ continue;
+ }
+ else {
+ memcpy(&tmpaddr.s_addr,
+ hp->h_addr_list[0],
+ hp->h_length);
+ }
+ }
+
+ /* The host has been resolved. Put it in the chain */
+ /* We want to stick it on the end. */
+ if (hostnames == NULL) {
+ hostnames = (struct hostdesc *)
+ malloc(sizeof(*hostnames));
+ if (hostnames == NULL) {
+ perror("hostnames malloc failed");
+ exit(-1);
+ }
+ hosttail = hostnames;
+ } else {
+ hosttail->next = (struct hostdesc *)
+ malloc(sizeof(*hostnames));
+ if (hosttail->next == NULL) {
+ perror("hosttail->next malloc failed");
+ exit(-1);
+ }
+ hosttail = hosttail->next;
+ }
+ hosttail->hostname = strdup(hostlist[i]);
+ if (hosttail->hostname == NULL) {
+ perror("strdup failed");
+ exit(-1);
+ }
+ hosttail->hostaddr = tmpaddr;
+ hosttail->next = NULL;
+ hostcount++;
+ }
+ return hostcount;
+}
+
+void usage(char *prog)
+{
+ fprintf(stderr, "%s [ -i identityfile ] target [ target ... ]\n", prog);
+}
+
+/*
+ * Set up a packet. Returns the length of the ICMP portion.
+ */
+
+void initpacket(char *buf, int querytype, struct in_addr fromaddr)
+{
+ struct ip *ip = (struct ip *)buf;
+ struct icmp *icmp = (struct icmp *)(ip + 1);
+
+ /* things we customize */
+ int icmplen = 0;
+
+ ip->ip_src = fromaddr; /* if 0, have kernel fill in */
+ ip->ip_v = 4; /* Always use ipv4 for now */
+ ip->ip_hl = sizeof *ip >> 2;
+ ip->ip_tos = 0;
+ ip->ip_id = htons(4321);
+ ip->ip_ttl = 255;
+ ip->ip_p = 1;
+ ip->ip_sum = 0; /* kernel fills in */
+
+ icmp->icmp_seq = 1;
+ icmp->icmp_cksum = 0; /* We'll compute it later. */
+ icmp->icmp_type = querytype;
+ icmp->icmp_code = IPOD_ICMPCODE;
+ if (myidlen)
+ memcpy(icmp->icmp_data, myid, myidlen);
+
+ ip->ip_len = IPOD_IPLEN;
+ icmplen = IPOD_IPLEN - sizeof(struct ip);
+ icmp->icmp_cksum = in_cksum((u_short *)icmp, icmplen);
+}
+
+/*
+ * Send all of the ICMP queries.
+ */
+
+void sendpings(int s, int querytype, struct hostdesc *head, int delay,
+ struct in_addr fromaddr)
+
+{
+ char buf[1500];
+ struct ip *ip = (struct ip *)buf;
+ struct sockaddr_in dst;
+
+ bzero(buf, 1500);
+ initpacket(buf, querytype, fromaddr);
+ dst.sin_family = AF_INET;
+#ifdef DA_HAS_SIN_LEN
+ dst.sin_len = sizeof(dst);
+#endif
+
+ while (head != NULL) {
+ int rc;
+#ifdef DEBUG
+ printf("pinging %s\n", head->hostname);
+#endif
+ ip->ip_dst.s_addr = head->hostaddr.s_addr;
+ dst.sin_addr = head->hostaddr;
+ rc = sendto(s, buf, ip->ip_len, 0,
+ (struct sockaddr *)&dst,
+ sizeof(dst));
+ if (rc != ip->ip_len) {
+ perror("sendto");
+ }
+ /* Don't flood small pipes. */
+ if (delay)
+ usleep(delay);
+ head = head->next;
+ }
+}
+
+/*
+ * Handles our timeout for us. Called by the signal handler
+ * when we get a SIGARLM.
+ */
+
+void myexit(int whatsig)
+{
+ exit(0);
+}
+
+/*
+ * Open a raw socket for receiving ICMP. Tell the kernel we want
+ * to supply the IP headers.
+ */
+
+int get_icmp_socket()
+{
+ int s;
+ int on = 1;
+ if ((s = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) {
+ perror("socket");
+ exit(1);
+ }
+ if (setsockopt(s, IPPROTO_IP, IP_HDRINCL,
+ (const char *)&on, sizeof(on)) < 0) {
+ perror("IP_HDRINCL");
+ exit(1);
+ }
+ return s;
+}
+
+int
+main(int argc, char **argv)
+{
+ int s;
+
+ char *progname;
+ extern char *optarg; /* getopt variable declarations */
+ extern int optind;
+ char ch; /* Holds the getopt result */
+ int hostcount;
+ int delay = 0;
+ int querytype = ICMP_TSTAMP;
+ struct in_addr fromaddr;
+ int timeout = 5; /* Default to 5 seconds */
+ int identityfile;
+
+ fromaddr.s_addr = 0;
+
+ progname = argv[0];
+
+ querytype = IPOD_ICMPTYPE; /* the magical death packet number */
+
+ while ((ch = getopt(argc, argv, "i:")) != -1)
+ switch(ch)
+ {
+ case 'i':
+ if (optarg[0] == '-')
+ identityfile = 0;
+ else if ((identityfile = open(optarg, 0)) < 0)
+ {
+ perror(optarg);
+ exit(1);
+ }
+ myidlen = read(identityfile, myid, IPOD_IDLEN);
+ if (optarg[0] != '-')
+ close(identityfile);
+ if (myidlen != IPOD_IDLEN)
+ {
+ fprintf(stderr, "%s: cannot read %d-byte identity\n",
+ optarg[0] != '-' ? optarg : "<stdin>", IPOD_IDLEN);
+ exit(2);
+ }
+ break;
+ default:
+ usage(progname);
+ exit(-1);
+ }
+
+ argc -= optind;
+ argv += optind;
+ if (!argv[0] || !strlen(argv[0]))
+ {
+ usage(progname);
+ exit(-1);
+ }
+
+ hostcount = makehosts(argv);
+
+ s = get_icmp_socket();
+
+ signal(SIGALRM, myexit);
+ alarm(timeout);
+ sendpings(s, querytype, hostnames, delay, fromaddr);
+ exit(0);
+}
+
+/*
+ * in_cksum --
+ * Checksum routine for Internet Protocol family headers (C Version)
+ * From FreeBSD's ping.c
+ */
+
+u_short
+in_cksum(addr, len)
+ u_short *addr;
+ int len;
+{
+ register int nleft = len;
+ register u_short *w = addr;
+ register int sum = 0;
+ u_short answer = 0;
+
+ /*
+ * Our algorithm is simple, using a 32 bit accumulator (sum), we add
+ * sequential 16 bit words to it, and at the end, fold back all the
+ * carry bits from the top 16 bits into the lower 16 bits.
+ */
+ while (nleft > 1) {
+ sum += *w++;
+ nleft -= 2;
+ }
+
+ /* mop up an odd byte, if necessary */
+ if (nleft == 1) {
+ *(u_char *)(&answer) = *(u_char *)w ;
+ sum += answer;
+ }
+
+ /* add back carry outs from top 16 bits to low 16 bits */
+ sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
+ sum += (sum >> 16); /* add carry */
+ answer = ~sum; /* truncate to 16 bits */
+ return(answer);
+}
+
git://git.onelab.eu / pingofdeath.git / blobdiff