randpkt.c

   1 /*
   2  * randpkt.c
   3  * ---------
   4  * Creates random packet traces. Useful for debugging sniffers by testing
   5  * assumptions about the veracity of the data found in the packet.
   6  *
   7  * Copyright (C) 1999 by Gilbert Ramirez <gram@alumni.rice.edu>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23
  24 #include <config.h>
  25
  26 #include <glib.h>
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <wsutil/clopts_common.h>
  31 #include <wsutil/cmdarg_err.h>
  32 #include <wsutil/unicode-utils.h>
  33 #include <wsutil/file_util.h>
  34 #include <wsutil/filesystem.h>
  35 #include <wsutil/privileges.h>
  36
  37 #ifdef HAVE_PLUGINS
  38 #include <wsutil/plugins.h>
  39 #endif
  40
  41 #include <wsutil/report_err.h>
  42 #ifdef HAVE_GETOPT_H
  43 #include <getopt.h>
  44 #endif
  45
  46 #ifndef HAVE_GETOPT_LONG
  47 #include "wsutil/wsgetopt.h"
  48 #endif
  49
  50 #include "randpkt_core/randpkt_core.h"
  51
  52 /*
  53  * General errors are reported with an console message in randpkt.
  54  */
  55 static void
  56 failure_message(const char *msg_format, va_list ap)
  57 {
  58         fprintf(stderr, "randpkt: ");
  59         vfprintf(stderr, msg_format, ap);
  60         fprintf(stderr, "\n");
  61 }
  62
  63 /*
  64  * Report additional information for an error in command-line arguments.
  65  */
  66 static void
  67 failure_message_cont(const char *msg_format, va_list ap)
  68 {
  69         vfprintf(stderr, msg_format, ap);
  70         fprintf(stderr, "\n");
  71 }
  72
  73 /* Print usage statement and exit program */
  74 static void
  75 usage(gboolean is_error)
  76 {
  77         FILE *output;
  78         char** abbrev_list;
  79         char** longname_list;
  80         unsigned i = 0;
  81
  82         if (!is_error) {
  83                 output = stdout;
  84         }
  85         else {
  86                 output = stderr;
  87         }
  88
  89         fprintf(output, "Usage: randpkt [-b maxbytes] [-c count] [-t type] [-r] filename\n");
  90         fprintf(output, "Default max bytes (per packet) is 5000\n");
  91         fprintf(output, "Default count is 1000.\n");
  92         fprintf(output, "-r: random packet type selection\n");
  93         fprintf(output, "\n");
  94         fprintf(output, "Types:\n");
  95
  96         /* Get the examples list */
  97         randpkt_example_list(&abbrev_list, &longname_list);
  98         while (abbrev_list[i] && longname_list[i]) {
  99                 fprintf(output, "\t%-16s%s\n", abbrev_list[i], longname_list[i]);
 100                 i++;
 101         }
 102
 103         g_strfreev(abbrev_list);
 104         g_strfreev(longname_list);
 105
 106         fprintf(output, "\nIf type is not specified, a random packet will be chosen\n\n");
 107
 108         exit(is_error ? 1 : 0);
 109 }
 110 int
 111 main(int argc, char **argv)
 112 {
 113         char                   *init_progfile_dir_error;
 114         int                     opt;
 115         int                     produce_type = -1;
 116         char                    *produce_filename = NULL;
 117         int                     produce_max_bytes = 5000;
 118         int                     produce_count = 1000;
 119         randpkt_example         *example;
 120         guint8*                 type = NULL;
 121         int                     allrandom = FALSE;
 122         wtap_dumper             *savedump;
 123         static const struct option long_options[] = {
 124                 {"help", no_argument, NULL, 'h'},
 125                 {0, 0, 0, 0 }
 126         };
 127
 128         /*
 129          * Get credential information for later use.
 130          */
 131         init_process_policies();
 132
 133         /*
 134          * Attempt to get the pathname of the directory containing the
 135          * executable file.
 136          */
 137         init_progfile_dir_error = init_progfile_dir(argv[0], main);
 138         if (init_progfile_dir_error != NULL) {
 139                 fprintf(stderr,
 140                     "capinfos: Can't get pathname of directory containing the capinfos program: %s.\n",
 141                     init_progfile_dir_error);
 142                 g_free(init_progfile_dir_error);
 143         }
 144
 145         wtap_init();
 146
 147         cmdarg_err_init(failure_message, failure_message_cont);
 148
 149 #ifdef _WIN32
 150         arg_list_utf_16to8(argc, argv);
 151         create_app_running_mutex();
 152 #endif /* _WIN32 */
 153
 154 #ifdef HAVE_PLUGINS
 155         /* Register wiretap plugins */
 156         init_report_err(failure_message,NULL,NULL,NULL);
 157
 158         /* Scan for plugins.  This does *not* call their registration routines;
 159            that's done later.
 160
 161            Don't report failures to load plugins because most
 162            (non-wiretap) plugins *should* fail to load (because
 163            we're not linked against libwireshark and dissector
 164            plugins need libwireshark). */
 165         scan_plugins(DONT_REPORT_LOAD_FAILURE);
 166
 167         /* Register all libwiretap plugin modules. */
 168         register_all_wiretap_modules();
 169 #endif
 170
 171         while ((opt = getopt_long(argc, argv, "b:c:ht:r", long_options, NULL)) != -1) {
 172                 switch (opt) {
 173                         case 'b':       /* max bytes */
 174                                 produce_max_bytes = get_positive_int(optarg, "max bytes");
 175                                 if (produce_max_bytes > 65536) {
 176                                         cmdarg_err("max bytes is > 65536");
 177                                         return 1;
 178                                 }
 179                                 break;
 180
 181                         case 'c':       /* count */
 182                                 produce_count = get_positive_int(optarg, "count");
 183                                 break;
 184
 185                         case 't':       /* type of packet to produce */
 186                                 type = g_strdup(optarg);
 187                                 break;
 188
 189                         case 'h':
 190                                 usage(FALSE);
 191                                 break;
 192
 193                         case 'r':
 194                                 allrandom = TRUE;
 195                                 break;
 196
 197                         default:
 198                                 usage(TRUE);
 199                                 break;
 200                 }
 201         }
 202
 203         /* any more command line parameters? */
 204         if (argc > optind) {
 205                 produce_filename = argv[optind];
 206         }
 207         else {
 208                 usage(TRUE);
 209         }
 210
 211         if (!allrandom) {
 212                 produce_type = randpkt_parse_type(type);
 213                 g_free(type);
 214
 215                 example = randpkt_find_example(produce_type);
 216                 if (!example)
 217                         return 1;
 218
 219                 randpkt_example_init(example, produce_filename, produce_max_bytes);
 220                 randpkt_loop(example, produce_count);
 221         } else {
 222                 if (type) {
 223                         fprintf(stderr, "Can't set type in random mode\n");
 224                         return 2;
 225                 }
 226
 227                 produce_type = randpkt_parse_type(NULL);
 228                 example = randpkt_find_example(produce_type);
 229                 if (!example)
 230                         return 1;
 231                 randpkt_example_init(example, produce_filename, produce_max_bytes);
 232
 233                 while (produce_count-- > 0) {
 234                         randpkt_loop(example, 1);
 235                         produce_type = randpkt_parse_type(NULL);
 236
 237                         savedump = example->dump;
 238
 239                         example = randpkt_find_example(produce_type);
 240                         if (!example)
 241                                 return 1;
 242                         example->dump = savedump;
 243                 }
 244         }
 245         if (!randpkt_example_close(example))
 246                 return 2;
 247         return 0;
 248
 249 }
 250
 251 /*
 252  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 253  *
 254  * Local variables:
 255  * c-basic-offset: 8
 256  * tab-width: 8
 257  * indent-tabs-mode: t
 258  * End:
 259  *
 260  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 261  * :indentSize=8:tabSize=8:noTabs=false:
 262  */