Follow up to rev 34073: Since "-b files:0" is no longer necessary to
[obnox/wireshark/wip.git] / 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  * $Id$
8  *
9  * Copyright (C) 1999 by Gilbert Ramirez <gram@alumni.rice.edu>
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #ifdef HAVE_GETOPT_H
31 #include <getopt.h>
32 #else
33 #include "wsutil/wsgetopt.h"
34 #endif
35
36 #ifdef HAVE_UNISTD_H
37 #include <unistd.h>
38 #endif
39
40 #ifdef HAVE_FCNTL_H
41 #include <fcntl.h>
42 #endif
43
44 #include <time.h>
45 #include <errno.h>
46
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <glib.h>
51 #include "wiretap/wtap.h"
52
53 #define array_length(x) (sizeof x / sizeof x[0])
54
55 /* Types of produceable packets */
56 enum {
57         PKT_ARP,
58         PKT_BGP,
59         PKT_BVLC,
60         PKT_DNS,
61         PKT_ETHERNET,
62         PKT_FDDI,
63         PKT_GIOP,
64         PKT_ICMP,
65         PKT_IP,
66         PKT_LLC,
67         PKT_M2M,
68         PKT_MEGACO,
69         PKT_NBNS,
70         PKT_NCP2222,
71         PKT_SCTP,
72         PKT_SYSLOG,
73         PKT_TCP,
74         PKT_TDS,
75         PKT_TR,
76         PKT_UDP,
77         PKT_USB,
78         PKT_USB_LINUX
79 };
80
81 typedef struct {
82         const char      *abbrev;
83         const char      *longname;
84         int             produceable_type;
85         int             sample_wtap_encap;
86         guint8          *sample_buffer;
87         int             sample_length;
88         guint8          *pseudo_buffer;
89         int             pseudo_length;
90 } pkt_example;
91
92 /* Ethernet, indicating ARP */
93 guint8 pkt_arp[] = {
94         0xff, 0xff, 0xff, 0xff,
95         0xff, 0xff, 0x00, 0x00,
96         0x32, 0x25, 0x0f, 0xff,
97         0x08, 0x06
98 };
99
100 /* Ethernet+IP+UDP, indicating DNS */
101 guint8 pkt_dns[] = {
102         0xff, 0xff, 0xff, 0xff,
103         0xff, 0xff, 0x01, 0x01,
104         0x01, 0x01, 0x01, 0x01,
105         0x08, 0x00,
106
107         0x45, 0x00, 0x00, 0x3c,
108         0xc5, 0x9e, 0x40, 0x00,
109         0xff, 0x11, 0xd7, 0xe0,
110         0xd0, 0x15, 0x02, 0xb8,
111         0x0a, 0x01, 0x01, 0x63,
112
113         0x05, 0xe8, 0x00, 0x35,
114         0xff, 0xff, 0x2a, 0xb9,
115         0x30
116 };
117
118 /* Ethernet+IP, indicating ICMP */
119 guint8 pkt_icmp[] = {
120         0xff, 0xff, 0xff, 0xff,
121         0xff, 0xff, 0x01, 0x01,
122         0x01, 0x01, 0x01, 0x01,
123         0x08, 0x00,
124
125         0x45, 0x00, 0x00, 0x54,
126         0x8f, 0xb3, 0x40, 0x00,
127         0xfd, 0x01, 0x8a, 0x99,
128         0xcc, 0xfc, 0x66, 0x0b,
129         0xce, 0x41, 0x62, 0x12
130 };
131
132 /* Ethernet, indicating IP */
133 guint8 pkt_ip[] = {
134         0xff, 0xff, 0xff, 0xff,
135         0xff, 0xff, 0x01, 0x01,
136         0x01, 0x01, 0x01, 0x01,
137         0x08, 0x00
138 };
139
140 /* TR, indicating LLC */
141 guint8 pkt_llc[] = {
142         0x10, 0x40, 0x68, 0x00,
143         0x19, 0x69, 0x95, 0x8b,
144         0x00, 0x01, 0xfa, 0x68,
145         0xc4, 0x67
146 };
147
148 /* Ethernet, indicating WiMAX M2M */
149 guint8 pkt_m2m[] = {
150         0xff, 0xff, 0xff, 0xff,
151         0xff, 0xff, 0x00, 0x00,
152         0x32, 0x25, 0x0f, 0xff,
153         0x08, 0xf0
154 };
155
156 /* Ethernet+IP+UDP, indicating NBNS */
157 guint8 pkt_nbns[] = {
158         0xff, 0xff, 0xff, 0xff,
159         0xff, 0xff, 0x01, 0x01,
160         0x01, 0x01, 0x01, 0x01,
161         0x08, 0x00,
162
163         0x45, 0x00, 0x00, 0x3c,
164         0xc5, 0x9e, 0x40, 0x00,
165         0xff, 0x11, 0xd7, 0xe0,
166         0xd0, 0x15, 0x02, 0xb8,
167         0x0a, 0x01, 0x01, 0x63,
168
169         0x00, 0x89, 0x00, 0x89,
170         0x00, 0x00, 0x2a, 0xb9,
171         0x30
172 };
173
174 /* Ethernet+IP+UDP, indicating syslog */
175 guint8 pkt_syslog[] = {
176         0xff, 0xff, 0xff, 0xff,
177         0xff, 0xff, 0x01, 0x01,
178         0x01, 0x01, 0x01, 0x01,
179         0x08, 0x00,
180
181         0x45, 0x00, 0x00, 0x64,
182         0x20, 0x48, 0x00, 0x00,
183         0xfc, 0x11, 0xf8, 0x03,
184         0xd0, 0x15, 0x02, 0xb8,
185         0x0a, 0x01, 0x01, 0x63,
186
187         0x05, 0xe8, 0x02, 0x02,
188         0x00, 0x50, 0x51, 0xe1,
189         0x3c
190 };
191
192 /* TR+LLC+IP, indicating TCP */
193 guint8 pkt_tcp[] = {
194         0x10, 0x40, 0x68, 0x00,
195         0x19, 0x69, 0x95, 0x8b,
196         0x00, 0x01, 0xfa, 0x68,
197         0xc4, 0x67,
198
199         0xaa, 0xaa, 0x03, 0x00,
200         0x00, 0x00, 0x08, 0x00,
201
202         0x45, 0x00, 0x00, 0x28,
203         0x0b, 0x0b, 0x40, 0x00,
204         0x20, 0x06, 0x85, 0x37,
205         0xc0, 0xa8, 0x27, 0x01,
206         0xc0, 0xa8, 0x22, 0x3c
207 };
208
209 /* Ethernet+IP, indicating UDP */
210 guint8 pkt_udp[] = {
211         0xff, 0xff, 0xff, 0xff,
212         0xff, 0xff, 0x01, 0x01,
213         0x01, 0x01, 0x01, 0x01,
214         0x08, 0x00,
215
216         0x45, 0x00, 0x00, 0x3c,
217         0xc5, 0x9e, 0x40, 0x00,
218         0xff, 0x11, 0xd7, 0xe0,
219         0xd0, 0x15, 0x02, 0xb8,
220         0x0a, 0x01, 0x01, 0x63
221 };
222
223 /* Ethernet+IP+UDP, indicating BVLC */
224 guint8 pkt_bvlc[] = {
225         0xff, 0xff, 0xff, 0xff,
226         0xff, 0xff, 0x01, 0x01,
227         0x01, 0x01, 0x01, 0x01,
228         0x08, 0x00,
229
230         0x45, 0x00, 0x00, 0x3c,
231         0xc5, 0x9e, 0x40, 0x00,
232         0xff, 0x11, 0x01, 0xaa,
233         0xc1, 0xff, 0x19, 0x1e,
234         0xc1, 0xff, 0x19, 0xff,
235         0xba, 0xc0, 0xba, 0xc0,
236         0x00, 0xff, 0x2d, 0x5e,
237         0x81
238 };
239
240 /* TR+LLC+IPX, indicating NCP, with NCP Type == 0x2222 */
241 guint8 pkt_ncp2222[] = {
242         0x10, 0x40, 0x00, 0x00,
243         0xf6, 0x7c, 0x9b, 0x70,
244         0x68, 0x00, 0x19, 0x69,
245         0x95, 0x8b, 0xe0, 0xe0,
246         0x03, 0xff, 0xff, 0x00,
247         0x25, 0x02, 0x11, 0x00,
248         0x00, 0x74, 0x14, 0x00,
249         0x00, 0x00, 0x00, 0x00,
250         0x01, 0x04, 0x51, 0x00,
251         0x00, 0x00, 0x04, 0x00,
252         0x02, 0x16, 0x19, 0x7a,
253         0x84, 0x40, 0x01, 0x22,
254         0x22
255 };
256
257 /* Ethernet+IP+TCP, indicating GIOP */
258 guint8 pkt_giop[] = {
259         0xff, 0xff, 0xff, 0xff,
260         0xff, 0xff, 0x01, 0x01,
261         0x01, 0x01, 0x01, 0x01,
262         0x08, 0x00,
263
264         0x45, 0x00, 0x00, 0xa6,
265         0x00, 0x2f, 0x40, 0x00,
266         0x40, 0x06, 0x3c, 0x21,
267         0x7f, 0x00, 0x00, 0x01,
268         0x7f, 0x00, 0x00, 0x01,
269
270         0x30, 0x39, 0x04, 0x05,
271         0xac, 0x02, 0x1e, 0x69,
272         0xab, 0x74, 0xab, 0x64,
273         0x80, 0x18, 0x79, 0x60,
274         0xc4, 0xb8, 0x00, 0x00,
275         0x01, 0x01, 0x08, 0x0a,
276         0x00, 0x00, 0x48, 0xf5,
277         0x00, 0x00, 0x48, 0xf5,
278
279         0x47, 0x49, 0x4f, 0x50,
280         0x01, 0x00, 0x00, 0x00,
281         0x00, 0x00, 0x00, 0x30,
282         0x00, 0x00, 0x00, 0x00,
283         0x00, 0x00, 0x00, 0x01,
284         0x01
285 };
286
287 /* Ethernet+IP+TCP, indicating BGP */
288 guint8 pkt_bgp[] = {
289         0xff, 0xff, 0xff, 0xff,
290         0xff, 0xff, 0x01, 0x01,
291         0x01, 0x01, 0x01, 0x01,
292         0x08, 0x00,
293
294         0x45, 0x00, 0x00, 0xa6,
295         0x00, 0x2f, 0x40, 0x00,
296         0x40, 0x06, 0x3c, 0x21,
297         0x7f, 0x00, 0x00, 0x01,
298         0x7f, 0x00, 0x00, 0x01,
299
300         0x30, 0x39, 0x00, 0xb3,
301         0xac, 0x02, 0x1e, 0x69,
302         0xab, 0x74, 0xab, 0x64,
303         0x80, 0x18, 0x79, 0x60,
304         0xc4, 0xb8, 0x00, 0x00,
305         0x01, 0x01, 0x08, 0x0a,
306         0x00, 0x00, 0x48, 0xf5,
307         0x00, 0x00, 0x48, 0xf5,
308
309         0xff, 0xff, 0xff, 0xff,
310         0xff, 0xff, 0xff, 0xff,
311         0xff, 0xff, 0xff, 0xff,
312         0xff, 0xff, 0xff, 0xff,
313 };
314
315 /* Ethernet+IP+TCP, indicating TDS NetLib */
316 guint8 pkt_tds[] = {
317         0x00, 0x50, 0x8b, 0x0d,
318         0x7a, 0xed, 0x00, 0x08,
319         0xa3, 0x98, 0x39, 0x81,
320         0x08, 0x00,
321
322         0x45, 0x00, 0x03, 0x8d,
323         0x90, 0xd4, 0x40, 0x00,
324         0x7c, 0x06, 0xc3, 0x1b,
325         0xac, 0x14, 0x02, 0x22,
326         0x0a, 0xc2, 0xee, 0x82,
327
328         0x05, 0x99, 0x08, 0xf8,
329         0xff, 0x4e, 0x85, 0x46,
330         0xa2, 0xb4, 0x42, 0xaa,
331         0x50, 0x18, 0x3c, 0x28,
332         0x0f, 0xda, 0x00, 0x00,
333 };
334
335 /* Ethernet+IP, indicating SCTP */
336 guint8 pkt_sctp[] = {
337         0x00, 0xa0, 0x80, 0x00,
338         0x5e, 0x46, 0x08, 0x00,
339         0x03, 0x4a, 0x00, 0x35,
340         0x08, 0x00,
341
342         0x45, 0x00, 0x00, 0x7c,
343         0x14, 0x1c, 0x00, 0x00,
344         0x3b, 0x84, 0x4a, 0x54,
345         0x0a, 0x1c, 0x06, 0x2b,
346         0x0a, 0x1c, 0x06, 0x2c,
347 };
348
349
350 /* Ethernet+IP+SCTP, indicating MEGACO */
351 guint8 pkt_megaco[] = {
352         0x00, 0xa0, 0x80, 0x00,
353         0x5e, 0x46, 0x08, 0x00,
354         0x03, 0x4a, 0x00, 0x35,
355         0x08, 0x00,
356
357         0x45, 0x00, 0x00, 0x7c,
358         0x14, 0x1c, 0x00, 0x00,
359         0x3b, 0x84, 0x4a, 0x54,
360         0x0a, 0x1c, 0x06, 0x2b,
361         0x0a, 0x1c, 0x06, 0x2c,
362
363         0x40, 0x00, 0x0b, 0x80,
364         0x00, 0x01, 0x6f, 0x0a,
365         0x6d, 0xb0, 0x18, 0x82,
366         0x00, 0x03, 0x00, 0x5b,
367         0x28, 0x02, 0x43, 0x45,
368         0x00, 0x00, 0xa0, 0xbd,
369         0x00, 0x00, 0x00, 0x07,
370 };
371
372 /* This little data table drives the whole program */
373 pkt_example examples[] = {
374         { "arp", "Address Resolution Protocol",
375                 PKT_ARP,        WTAP_ENCAP_ETHERNET,
376                 pkt_arp,        array_length(pkt_arp),
377                 NULL,           0 },
378
379         { "bgp", "Border Gateway Protocol",
380                 PKT_BGP,        WTAP_ENCAP_ETHERNET,
381                 pkt_bgp,        array_length(pkt_bgp),
382                 NULL,           0 },
383
384         { "bvlc", "BACnet Virtual Link Control",
385                 PKT_BVLC,       WTAP_ENCAP_ETHERNET,
386                 pkt_bvlc,       array_length(pkt_bvlc),
387                 NULL,           0 },
388
389         { "dns", "Domain Name Service",
390                 PKT_DNS,        WTAP_ENCAP_ETHERNET,
391                 pkt_dns,        array_length(pkt_dns),
392                 NULL,           0 },
393
394         { "eth", "Ethernet",
395                 PKT_ETHERNET,   WTAP_ENCAP_ETHERNET,
396                 NULL,           0,
397                 NULL,           0 },
398
399         { "fddi", "Fiber Distributed Data Interface",
400                 PKT_FDDI,       WTAP_ENCAP_FDDI,
401                 NULL,           0,
402                 NULL,           0 },
403
404         { "giop", "General Inter-ORB Protocol",
405                 PKT_GIOP,       WTAP_ENCAP_ETHERNET,
406                 pkt_giop,       array_length(pkt_giop),
407                 NULL,           0 },
408
409         { "icmp", "Internet Control Message Protocol",
410                 PKT_ICMP,       WTAP_ENCAP_ETHERNET,
411                 pkt_icmp,       array_length(pkt_icmp),
412                 NULL,           0 },
413
414         { "ip", "Internet Protocol",
415                 PKT_IP,         WTAP_ENCAP_ETHERNET,
416                 pkt_ip,         array_length(pkt_ip),
417                 NULL,           0 },
418
419         { "llc", "Logical Link Control",
420                 PKT_LLC,        WTAP_ENCAP_TOKEN_RING,
421                 pkt_llc,        array_length(pkt_llc),
422                 NULL,           0 },
423
424         { "m2m", "WiMAX M2M Encapsulation Protocol",
425                 PKT_M2M,        WTAP_ENCAP_ETHERNET,
426                 pkt_m2m,        array_length(pkt_m2m),
427                 NULL,           0 },
428
429         { "megaco", "MEGACO",
430                 PKT_MEGACO,     WTAP_ENCAP_ETHERNET,
431                 pkt_megaco,     array_length(pkt_megaco),
432                 NULL,           0 },
433
434         { "nbns", "NetBIOS-over-TCP Name Service",
435                 PKT_NBNS,       WTAP_ENCAP_ETHERNET,
436                 pkt_nbns,       array_length(pkt_nbns),
437                 NULL,           0 },
438
439         { "ncp2222", "NetWare Core Protocol",
440                 PKT_NCP2222,    WTAP_ENCAP_TOKEN_RING,
441                 pkt_ncp2222,    array_length(pkt_ncp2222),
442                 NULL,           0 },
443
444         { "sctp", "Stream Control Transmission Protocol",
445                 PKT_SCTP,       WTAP_ENCAP_ETHERNET,
446                 pkt_sctp,       array_length(pkt_sctp),
447                 NULL,           0 },
448
449         { "syslog", "Syslog message",
450                 PKT_SYSLOG,     WTAP_ENCAP_ETHERNET,
451                 pkt_syslog,     array_length(pkt_syslog),
452                 NULL,           0 },
453
454         { "tds", "TDS NetLib",
455                 PKT_TDS,        WTAP_ENCAP_ETHERNET,
456                 pkt_tds,        array_length(pkt_tds),
457                 NULL,           0 },
458
459         { "tcp", "Transmission Control Protocol",
460                 PKT_TCP,        WTAP_ENCAP_TOKEN_RING,
461                 pkt_tcp,        array_length(pkt_tcp),
462                 NULL,           0 },
463
464         { "tr",  "Token-Ring",
465                 PKT_TR,         WTAP_ENCAP_TOKEN_RING,
466                 NULL,           0,
467                 NULL,           0 },
468
469         { "udp", "User Datagram Protocol",
470                 PKT_UDP,        WTAP_ENCAP_ETHERNET,
471                 pkt_udp,        array_length(pkt_udp),
472                 NULL,           0 },
473
474         { "usb", "Universal Serial Bus",
475                 PKT_USB,        WTAP_ENCAP_USB,
476                 NULL,           0,
477                 NULL,           0 },
478
479         { "usb-linux", "Universal Serial Bus with Linux specific header",
480                 PKT_USB_LINUX,  WTAP_ENCAP_USB_LINUX,
481                 NULL,           0,
482                 NULL,           0 },
483
484 };
485
486
487
488 static int parse_type(char *string);
489 static void usage(void);
490 static void seed(void);
491
492 static pkt_example* find_example(int type);
493
494 int
495 main(int argc, char **argv)
496 {
497
498         wtap_dumper             *dump;
499         struct wtap_pkthdr      pkthdr;
500         union wtap_pseudo_header        ps_header;
501         int                     i, j, len_this_pkt, len_random, err;
502         guint8                  buffer[65536];
503
504         int                     opt;
505         int                     produce_count = 1000; /* number of pkts to produce */
506         int                     produce_type = PKT_ETHERNET;
507         char                    *produce_filename = NULL;
508         int                     produce_max_bytes = 5000;
509         pkt_example             *example;
510
511         while ((opt = getopt(argc, argv, "b:c:ht:")) != -1) {
512                 switch (opt) {
513                         case 'b':       /* max bytes */
514                                 produce_max_bytes = atoi(optarg);
515                                 if (produce_max_bytes > 65536) {
516                                         fprintf(stderr,
517                                             "randpkt: Max bytes is 65536\n");
518                                         exit(1);
519                                 }
520                                 break;
521
522                         case 'c':       /* count */
523                                 produce_count = atoi(optarg);
524                                 break;
525
526                         case 't':       /* type of packet to produce */
527                                 produce_type = parse_type(optarg);
528                                 break;
529
530                         case 'h':
531                         default:
532                                 usage();
533                                 break;
534                 }
535         }
536
537         /* any more command line parameters? */
538         if (argc > optind) {
539                 produce_filename = argv[optind];
540         }
541         else {
542                 usage();
543         }
544
545         example = find_example(produce_type);
546
547
548         dump = wtap_dump_open(produce_filename, WTAP_FILE_PCAP,
549                 example->sample_wtap_encap, produce_max_bytes, FALSE /* compressed */, &err);
550         if (!dump) {
551                 fprintf(stderr,
552                     "randpkt: Error writing to %s\n", produce_filename);
553                 exit(2);
554         }
555
556         seed();
557
558         /* reduce max_bytes by # of bytes already in sample */
559         if (produce_max_bytes <= example->sample_length) {
560                 fprintf(stderr,
561                     "randpkt: Sample packet length is %d, which is greater than or equal to\n",
562                     example->sample_length);
563                 fprintf(stderr, "your requested max_bytes value of %d\n",
564                     produce_max_bytes);
565                 exit(1);
566         }
567         else {
568                 produce_max_bytes -= example->sample_length;
569         }
570
571         memset(&pkthdr, 0, sizeof(pkthdr));
572         memset(&ps_header, 0, sizeof(ps_header));
573         memset(buffer, 0, sizeof(buffer));
574
575         pkthdr.pkt_encap = example->sample_wtap_encap;
576
577         /* Load the sample pseudoheader into our pseudoheader buffer */
578         if (example->pseudo_buffer)
579                 memcpy(&ps_header, example->pseudo_buffer, example->pseudo_length);
580
581         /* Load the sample into our buffer */
582         if (example->sample_buffer)
583                 memcpy(&buffer[0], example->sample_buffer, example->sample_length);
584
585         /* Produce random packets */
586         for (i = 0; i < produce_count; i++) {
587                 if (produce_max_bytes > 0) {
588                         len_random = (rand() % produce_max_bytes + 1);
589                 }
590                 else {
591                         len_random = 0;
592                 }
593
594                 len_this_pkt = example->sample_length + len_random;
595
596                 pkthdr.caplen = len_this_pkt;
597                 pkthdr.len = len_this_pkt;
598                 pkthdr.ts.secs = i; /* just for variety */
599
600                 for (j = example->pseudo_length; j < (int) sizeof(ps_header); j++) {
601                         ((guint8*)&ps_header)[j] = (rand() % 0x100);
602                 }
603
604                 for (j = example->sample_length; j < len_this_pkt; j++) {
605                         /* Add format strings here and there */
606                         if ((int) (100.0*rand()/(RAND_MAX+1.0)) < 3 && j < (len_random - 3)) {
607                                 memcpy(&buffer[j], "%s", 3);
608                                 j += 2;
609                         } else {
610                                 buffer[j] = (rand() % 0x100);
611                         }
612                 }
613
614                 wtap_dump(dump, &pkthdr, &ps_header, &buffer[0], &err);
615         }
616
617         wtap_dump_close(dump, &err);
618
619         return 0;
620
621 }
622
623 /* Print usage statement and exit program */
624 static
625 void usage(void)
626 {
627         int     num_entries = array_length(examples);
628         int     i;
629
630         printf("Usage: randpkt [-b maxbytes] [-c count] [-t type] filename\n");
631         printf("Default max bytes (per packet) is 5000\n");
632         printf("Default count is 1000.\n");
633         printf("Types:\n");
634
635         for (i = 0; i < num_entries; i++) {
636                 printf("\t%s\t%s\n", examples[i].abbrev, examples[i].longname);
637         }
638
639         printf("\n");
640
641         exit(0);
642 }
643
644 /* Parse command-line option "type" and return enum type */
645 static
646 int parse_type(char *string)
647 {
648         int     num_entries = array_length(examples);
649         int     i;
650
651         for (i = 0; i < num_entries; i++) {
652                 if (strcmp(examples[i].abbrev, string) == 0) {
653                         return examples[i].produceable_type;
654                 }
655         }
656
657         /* Complain */
658         fprintf(stderr, "randpkt: Type %s not known.\n", string);
659         exit(1);
660 }
661
662 /* Find pkt_example record and return pointer to it */
663 static
664 pkt_example* find_example(int type)
665 {
666         int     num_entries = array_length(examples);
667         int     i;
668
669         for (i = 0; i < num_entries; i++) {
670                 if (examples[i].produceable_type == type) {
671                         return &examples[i];
672                 }
673         }
674
675         fprintf(stderr,
676             "randpkt: Internal error. Type %d has no entry in examples table.\n",
677             type);
678         exit(1);
679 }
680
681 /* Seed the random-number generator */
682 void
683 seed(void)
684 {
685         unsigned int    randomness;
686         time_t now;
687 #ifndef _WIN32
688         int             fd;
689         ssize_t         ret;
690
691 #define RANDOM_DEV "/dev/urandom"
692
693         /*
694          * Assume it's at least worth trying /dev/urandom on UN*X.
695          * If it doesn't exist, fall back on time().
696          *
697          * XXX - Use CryptGenRandom on Windows?
698          */
699         fd = open(RANDOM_DEV, O_RDONLY);
700         if (fd == -1) {
701                 if (errno != ENOENT) {
702                         fprintf(stderr,
703                             "randpkt: Could not open " RANDOM_DEV " for reading: %s\n",
704                             strerror(errno));
705                         exit(2);
706                 }
707                 goto fallback;
708         }
709
710         ret = read(fd, &randomness, sizeof randomness);
711         if (ret == -1) {
712                 fprintf(stderr,
713                     "randpkt: Could not read from " RANDOM_DEV ": %s\n",
714                     strerror(errno));
715                 exit(2);
716         }
717         if ((size_t)ret != sizeof randomness) {
718                 fprintf(stderr,
719                     "randpkt: Tried to read %lu bytes from " RANDOM_DEV ", got %ld\n",
720                     (unsigned long)sizeof randomness, (long)ret);
721                 exit(2);
722         }
723         srand(randomness);
724         return;
725
726 fallback:
727 #endif
728         now = time(NULL);
729         randomness = (unsigned int) now;
730
731         srand(randomness);
732 }