lib/Libnet/test/TCP/tcp+data.c

   1 /*
   2  *  $Id: tcp+data.c,v 1.1.1.1 2000/05/25 00:28:49 route Exp $
   3  *
   4  *  libnet
   5  *  TCP Packet assembly tester (with payload)
   6  *
   7  *  Copyright (c) 1998, 1999, 2000 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 #if (HAVE_CONFIG_H)
  34 #include "../../include/config.h"
  35 #endif
  36 #include "../libnet_test.h"
  37
  38 int
  39 main(int argc, char **argv)
  40 {
  41     int sock, c;
  42     u_long src_ip, dst_ip;
  43     u_short src_prt, dst_prt;
  44     u_char *cp, *buf;
  45     u_char *payload = "hello world";
  46     int payload_s = strlen(payload);
  47
  48     printf("TCP + payload packet building/writing test\n");
  49
  50     src_ip  = 0;
  51     dst_ip  = 0;
  52     src_prt = 0;
  53     dst_prt = 0;
  54     while((c = getopt(argc, argv, "d:s:")) != EOF)
  55     {
  56         switch (c)
  57         {
  58             /*
  59              *  We expect the input to be of the form `ip.ip.ip.ip.port`.  We
  60              *  point cp to the last dot of the IP address/port string and
  61              *  then seperate them with a NULL byte.  The optarg now points to
  62              *  just the IP address, and cp points to the port.
  63              */
  64             case 'd':
  65                 if (!(cp = strrchr(optarg, '.')))
  66                 {
  67                     usage(argv[0]);
  68                 }
  69                 *cp++ = 0;
  70                 dst_prt = (u_short)atoi(cp);
  71                 if (!(dst_ip = libnet_name_resolve(optarg, 1)))
  72                 {
  73                     fprintf(stderr, "Bad destination IP address: %s\n", optarg);
  74                     exit(EXIT_FAILURE);
  75                 }
  76                 break;
  77             case 's':
  78                 if (!(cp = strrchr(optarg, '.')))
  79                 {
  80                     usage(argv[0]);
  81                 }
  82                 *cp++ = 0;
  83                 src_prt = (u_short)atoi(cp);
  84                 if (!(src_ip = libnet_name_resolve(optarg, 1)))
  85                 {
  86                     fprintf(stderr, "Bad source IP address: %s\n", optarg);
  87                     exit(EXIT_FAILURE);
  88                 }
  89                 break;
  90         }
  91     }
  92
  93     if (!src_ip || !src_prt || !dst_ip || !dst_prt)
  94     {
  95         usage(argv[0]);
  96         exit(EXIT_FAILURE);
  97     }
  98
  99     /*
 100      *  Get our block of memory for the packet.  This time, we need memory
 101      *  for the packet headers and payload.
 102      */
 103     buf = malloc(LIBNET_TCP_H + LIBNET_IP_H + payload_s);
 104     if (!buf)
 105     {
 106         perror("No memory for packet");
 107         exit(EXIT_FAILURE);
 108     }
 109
 110     /*
 111      *  Open our raw IP socket and set IP_HDRINCL.
 112      */
 113     sock = libnet_open_raw_sock(IPPROTO_RAW);
 114     if (sock == -1)
 115     {
 116         perror("No socket");
 117         exit(EXIT_FAILURE);
 118     }
 119
 120     /*
 121      *  Build the IP header (shown exploded for commenting).
 122      */
 123     libnet_build_ip(LIBNET_TCP_H + payload_s, /* Size of the payload */
 124             0,                              /* IP tos */
 125             242,                            /* IP ID */
 126             0,                              /* Frag stuff */
 127             48,                             /* TTL */
 128             IPPROTO_TCP,                    /* Transport protocol */
 129             src_ip,                         /* Source IP */
 130             dst_ip,                         /* Destination IP */
 131             NULL,                           /* Pointer to payload (none) */
 132             0,
 133             buf);                           /* Packet header memory */
 134
 135     /*
 136      *  Build the TCP header.
 137      */
 138     libnet_build_tcp(src_prt,               /* Source TCP port */
 139             dst_prt,                        /* Destination TCP port */
 140             11111,                          /* Sequence number */
 141             99999,                          /* Acknowledgement number */
 142             TH_SYN|TH_ACK,                  /* Control flags */
 143             1024,                           /* Window size */
 144             0,                              /* Urgent pointer */
 145             payload,                        /* Pointer to payload */
 146             payload_s,                      /* Payload size */
 147             buf + LIBNET_IP_H);             /* Packet header memory */
 148
 149     /*
 150      *  Calculate the TCP header checksum (IP header checksum is *always* done
 151      *  by the kernel.
 152      */
 153     libnet_do_checksum(buf, IPPROTO_TCP, LIBNET_TCP_H + payload_s);
 154
 155     /*
 156      *  Write the packet to the network.
 157      */
 158     c = libnet_write_ip(sock, buf, LIBNET_TCP_H + LIBNET_IP_H + payload_s);
 159     if (c < LIBNET_TCP_H + LIBNET_IP_H + payload_s)
 160     {
 161         fprintf(stderr, "libnet_write_ip\n");
 162     }
 163     printf("Completed, wrote %d bytes\n", c);
 164     free(buf);
 165
 166     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
 167 }
 168
 169
 170 void
 171 usage(u_char *name)
 172 {
 173     fprintf(stderr,
 174         "usage: %s -s source_ip.source_port -d destination_ip.destination_port\n",
 175         name);
 176 }
 177
 178 /* EOF */