lib/Libnet/example/libnet-example-3.c

   1 /*
   2  *  $Id: libnet-example-3.c,v 1.1.1.1 2000/05/25 00:28:49 route Exp $
   3  *
   4  *  libnet example code
   5  *  example 2:  raw socket api / ICMP_ECHO packet(s) using an arena
   6  *
   7  *  Copyright (c) 1998 - 2001 Mike D. Schiffman <mike@infonexus.com>
   8  *  All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  */
  32
  33 #include <libnet.h>
  34
  35 void usage(char *);
  36
  37
  38 int
  39 main(int argc, char **argv)
  40 {
  41     int network, n, c, number_of_packets, packet_size;
  42     struct libnet_arena arena, *arena_p;
  43     u_char *packets[10];
  44     u_long src_ip, dst_ip;
  45
  46     printf("libnet example code:\tmodule 3\n\n");
  47     printf("packet injection interface:\tlink layer\n");
  48     printf("packet type:\t\t\tICMP_ECHO [no payload] using an arena\n");
  49
  50     src_ip = 0;
  51     dst_ip = 0;
  52     while((c = getopt(argc, argv, "d:s:")) != EOF)
  53     {
  54         switch (c)
  55         {
  56             case 'd':
  57                 if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
  58                 {
  59                     libnet_error(LIBNET_ERR_FATAL, "Bad destination IP address: %s\n", optarg);
  60                 }
  61                 break;
  62             case 's':
  63                 if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))
  64                 {
  65                     libnet_error(LIBNET_ERR_FATAL, "Bad source IP address: %s\n", optarg);
  66                 }
  67                 break;
  68         }
  69     }
  70     if (!src_ip || !dst_ip)
  71     {
  72         usage(argv[0]);
  73         exit(EXIT_FAILURE);
  74     }
  75
  76     /*
  77      *  We're just going to build an ICMP packet with no payload using the
  78      *  raw sockets API, so we only need memory for a ICMP header and an IP
  79      *  header.
  80      */
  81     packet_size = LIBNET_IP_H + LIBNET_ICMP_ECHO_H;
  82
  83     /*
  84      *  Let's just build say, 10 packets.
  85      */
  86     number_of_packets = 10;
  87
  88     arena_p = &arena;
  89     if (libnet_init_packet_arena(&arena_p, number_of_packets, packet_size) == -1)
  90     {
  91         libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet_arena failed\n");
  92     }
  93     else
  94     {
  95         printf("Allocated an arena of %ld bytes..\n", LIBNET_GET_ARENA_SIZE(arena));
  96     }
  97
  98     network = libnet_open_raw_sock(IPPROTO_RAW);
  99     if (network == -1)
 100     {
 101         libnet_error(LIBNET_ERR_FATAL, "Can't open the network.\n");
 102     }
 103
 104     for (n = 0; n < number_of_packets; n++)
 105     {
 106         printf("%ld bytes remaining in arena\n", LIBNET_GET_ARENA_REMAINING_BYTES(arena));
 107         packets[n] = libnet_next_packet_from_arena(&arena_p, packet_size);
 108         if (!packets[n])
 109         {
 110             libnet_error(LIBNET_ERR_WARNING, "Arena is empty\n");
 111             continue;
 112         }
 113
 114         libnet_build_ip(ICMP_ECHO_H,                /* Size of the payload */
 115                 IPTOS_LOWDELAY | IPTOS_THROUGHPUT,  /* IP tos */
 116                 242,                                /* IP ID */
 117                 0,                                  /* frag stuff */
 118                 48,                                 /* TTL */
 119                 IPPROTO_ICMP,                       /* transport protocol */
 120                 src_ip,                             /* source IP */
 121                 dst_ip,                             /* destination IP */
 122                 NULL,                               /* pointer to payload */
 123                 0,                                  /* payload length */
 124                 packets[n]);                        /* packet header memory */
 125
 126         libnet_build_icmp_echo(ICMP_ECHO,           /* type */
 127                 0,                                  /* code */
 128                 242,                                /* id */
 129                 5,                                  /* seq */
 130                 NULL,                               /* pointer to payload */
 131                 0,                                  /* payload length */
 132                 packets[n] + LIBNET_IP_H);          /* packet header memory */
 133
 134         if (libnet_do_checksum(packets[n], IPPROTO_ICMP, LIBNET_ICMP_ECHO_H) == -1)
 135         {
 136             libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");
 137         }
 138
 139         c = libnet_write_ip(network, packets[n], packet_size);
 140         if (c < packet_size)
 141         {
 142             libnet_error(LN_ERR_WARNING, "libnet_write_ip only wrote %d bytes\n", c);
 143         }
 144         else
 145         {
 146             printf("construction and injection of packet %d of %d completed, wrote all %d bytes\n",  n + 1, number_of_packets, c);
 147         }
 148     }
 149
 150     libnet_destroy_packet_arena(&arena_p);
 151     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
 152 }
 153
 154
 155 void
 156 usage(char *name)
 157 {
 158     fprintf(stderr, "usage: %s -s source_ip -d destination_ip\n ", name);
 159 }
 160
 161 /* EOF */