opa: Add dissectors for Intel’s Omni-Path Architecture (OPA)
[metze/wireshark/wip.git] / wiretap / netmon.c
1 /* netmon.c
2  *
3  * Wiretap Library
4  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20
21 #include "config.h"
22 #include <errno.h>
23 #include <string.h>
24 #include "wtap-int.h"
25 #include "file_wrappers.h"
26 #include "atm.h"
27 #include "pcap-encap.h"
28 #include "netmon.h"
29
30 /* The file at
31  *
32  *      ftp://ftp.microsoft.com/developr/drg/cifs/cifs/Bhfile.zip
33  *
34  * contains "STRUCT.H", which declares the typedef CAPTUREFILE_HEADER
35  * for the header of a Microsoft Network Monitor 1.x capture file.
36  *
37  * The help files for Network Monitor 3.x document the 2.x file format.
38  */
39
40 /* Capture file header, *including* magic number, is padded to 128 bytes. */
41 #define CAPTUREFILE_HEADER_SIZE 128
42
43 /* Magic number size, for both 1.x and 2.x. */
44 #define MAGIC_SIZE      4
45
46 /* Magic number in Network Monitor 1.x files. */
47 static const char netmon_1_x_magic[MAGIC_SIZE] = {
48         'R', 'T', 'S', 'S'
49 };
50
51 /* Magic number in Network Monitor 2.x files. */
52 static const char netmon_2_x_magic[MAGIC_SIZE] = {
53         'G', 'M', 'B', 'U'
54 };
55
56 /* Network Monitor file header (minus magic number). */
57 struct netmon_hdr {
58         guint8  ver_minor;      /* minor version number */
59         guint8  ver_major;      /* major version number */
60         guint16 network;        /* network type */
61         guint16 ts_year;        /* year of capture start */
62         guint16 ts_month;       /* month of capture start (January = 1) */
63         guint16 ts_dow;         /* day of week of capture start (Sun = 0) */
64         guint16 ts_day;         /* day of month of capture start */
65         guint16 ts_hour;        /* hour of capture start */
66         guint16 ts_min;         /* minute of capture start */
67         guint16 ts_sec;         /* second of capture start */
68         guint16 ts_msec;        /* millisecond of capture start */
69         guint32 frametableoffset;       /* frame index table offset */
70         guint32 frametablelength;       /* frame index table size */
71         guint32 userdataoffset;         /* user data offset */
72         guint32 userdatalength;         /* user data size */
73         guint32 commentdataoffset;      /* comment data offset */
74         guint32 commentdatalength;      /* comment data size */
75         guint32 statisticsoffset;       /* offset to statistics structure */
76         guint32 statisticslength;       /* length of statistics structure */
77         guint32 networkinfooffset;      /* offset to network info structure */
78         guint32 networkinfolength;      /* length of network info structure */
79 };
80
81 /* Network Monitor 1.x record header; not defined in STRUCT.H, but deduced by
82  * looking at capture files. */
83 struct netmonrec_1_x_hdr {
84         guint32 ts_delta;       /* time stamp - msecs since start of capture */
85         guint16 orig_len;       /* actual length of packet */
86         guint16 incl_len;       /* number of octets captured in file */
87 };
88
89 /*
90  * Network Monitor 2.x record header, as documented in NetMon 3.x's
91  * help files.
92  */
93 struct netmonrec_2_x_hdr {
94         guint64 ts_delta;       /* time stamp - usecs since start of capture */
95         guint32 orig_len;       /* actual length of packet */
96         guint32 incl_len;       /* number of octets captured in file */
97 };
98
99 /*
100  * Network Monitor 2.1 and later record trailers; documented in the Network
101  * Monitor 3.x help files, for 3.3 and later, although they don't clearly
102  * state how the trailer format changes from version to version.
103  *
104  * Some fields are multi-byte integers, but they're not aligned on their
105  * natural boundaries.
106  */
107 struct netmonrec_2_1_trlr {
108         guint8 network[2];              /* network type for this packet */
109 };
110
111 struct netmonrec_2_2_trlr {
112         guint8 network[2];              /* network type for this packet */
113         guint8 process_info_index[4];   /* index into the process info table */
114 };
115
116 struct netmonrec_2_3_trlr {
117         guint8 network[2];              /* network type for this packet */
118         guint8 process_info_index[4];   /* index into the process info table */
119         guint8 utc_timestamp[8];        /* packet time stamp, as .1 us units since January 1, 1601, 00:00:00 UTC */
120         guint8 timezone_index;          /* index of time zone information */
121 };
122
123 /*
124  * The link-layer header on ATM packets.
125  */
126 struct netmon_atm_hdr {
127         guint8  dest[6];        /* "Destination address" - what is it? */
128         guint8  src[6];         /* "Source address" - what is it? */
129         guint16 vpi;            /* VPI */
130         guint16 vci;            /* VCI */
131 };
132
133 typedef struct {
134         time_t  start_secs;
135         guint32 start_nsecs;
136         guint8  version_major;
137         guint8  version_minor;
138         guint32 *frame_table;
139         guint32 frame_table_size;
140         guint   current_frame;
141 } netmon_t;
142
143 /*
144  * XXX - at least in some NetMon 3.4 VPN captures, the per-packet
145  * link-layer type is 0, but the packets have Ethernet headers.
146  * We handle this by mapping 0 to WTAP_ENCAP_ETHERNET; should we,
147  * instead, use the per-file link-layer type?
148  */
149 static const int netmon_encap[] = {
150         WTAP_ENCAP_ETHERNET,
151         WTAP_ENCAP_ETHERNET,
152         WTAP_ENCAP_TOKEN_RING,
153         WTAP_ENCAP_FDDI_BITSWAPPED,
154         WTAP_ENCAP_ATM_PDUS,    /* NDIS WAN - this is what's used for ATM */
155         WTAP_ENCAP_UNKNOWN,     /* NDIS LocalTalk, but format 2.x uses it for IP-over-IEEE 1394 */
156         WTAP_ENCAP_IEEE_802_11_NETMON,
157                                 /* NDIS "DIX", but format 2.x uses it for 802.11 */
158         WTAP_ENCAP_RAW_IP,      /* NDIS ARCNET raw, but format 2.x uses it for "Tunneling interfaces" */
159         WTAP_ENCAP_RAW_IP,      /* NDIS ARCNET 878.2, but format 2.x uses it for "Wireless WAN" */
160         WTAP_ENCAP_RAW_IP,      /* NDIS ATM (no, this is NOT used for ATM); format 2.x uses it for "Raw IP Frames" */
161         WTAP_ENCAP_UNKNOWN,     /* NDIS Wireless WAN */
162         WTAP_ENCAP_UNKNOWN      /* NDIS IrDA */
163 };
164 #define NUM_NETMON_ENCAPS (sizeof netmon_encap / sizeof netmon_encap[0])
165
166 /*
167  * Special link-layer types.
168  */
169 #define NETMON_NET_PCAP_BASE            0xE000
170 #define NETMON_NET_NETEVENT             0xFFE0
171 #define NETMON_NET_NETWORK_INFO_EX      0xFFFB
172 #define NETMON_NET_PAYLOAD_HEADER       0xFFFC
173 #define NETMON_NET_NETWORK_INFO         0xFFFD
174 #define NETMON_NET_DNS_CACHE            0xFFFE
175 #define NETMON_NET_NETMON_FILTER        0xFFFF
176
177 static gboolean netmon_read(wtap *wth, int *err, gchar **err_info,
178     gint64 *data_offset);
179 static gboolean netmon_seek_read(wtap *wth, gint64 seek_off,
180     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
181 static gboolean netmon_read_atm_pseudoheader(FILE_T fh,
182     union wtap_pseudo_header *pseudo_header, int *err, gchar **err_info);
183 static void netmon_sequential_close(wtap *wth);
184 static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
185     const guint8 *pd, int *err, gchar **err_info);
186 static gboolean netmon_dump_finish(wtap_dumper *wdh, int *err);
187
188 wtap_open_return_val netmon_open(wtap *wth, int *err, gchar **err_info)
189 {
190         char magic[MAGIC_SIZE];
191         struct netmon_hdr hdr;
192         int file_type;
193         struct tm tm;
194         guint32 frame_table_offset;
195         guint32 frame_table_length;
196         guint32 frame_table_size;
197         guint32 *frame_table;
198 #ifdef WORDS_BIGENDIAN
199         unsigned int i;
200 #endif
201         netmon_t *netmon;
202
203         /* Read in the string that should be at the start of a Network
204          * Monitor file */
205         if (!wtap_read_bytes(wth->fh, magic, MAGIC_SIZE, err, err_info)) {
206                 if (*err != WTAP_ERR_SHORT_READ)
207                         return WTAP_OPEN_ERROR;
208                 return WTAP_OPEN_NOT_MINE;
209         }
210
211         if (memcmp(magic, netmon_1_x_magic, MAGIC_SIZE) != 0 &&
212             memcmp(magic, netmon_2_x_magic, MAGIC_SIZE) != 0) {
213                 return WTAP_OPEN_NOT_MINE;
214         }
215
216         /* Read the rest of the header. */
217         if (!wtap_read_bytes(wth->fh, &hdr, sizeof hdr, err, err_info))
218                 return WTAP_OPEN_ERROR;
219
220         switch (hdr.ver_major) {
221
222         case 1:
223                 file_type = WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x;
224                 break;
225
226         case 2:
227                 file_type = WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x;
228                 break;
229
230         default:
231                 *err = WTAP_ERR_UNSUPPORTED;
232                 *err_info = g_strdup_printf("netmon: major version %u unsupported", hdr.ver_major);
233                 return WTAP_OPEN_ERROR;
234         }
235
236         hdr.network = pletoh16(&hdr.network);
237         if (hdr.network >= NUM_NETMON_ENCAPS
238             || netmon_encap[hdr.network] == WTAP_ENCAP_UNKNOWN) {
239                 *err = WTAP_ERR_UNSUPPORTED;
240                 *err_info = g_strdup_printf("netmon: network type %u unknown or unsupported",
241                     hdr.network);
242                 return WTAP_OPEN_ERROR;
243         }
244
245         /* This is a netmon file */
246         wth->file_type_subtype = file_type;
247         netmon = (netmon_t *)g_malloc(sizeof(netmon_t));
248         wth->priv = (void *)netmon;
249         wth->subtype_read = netmon_read;
250         wth->subtype_seek_read = netmon_seek_read;
251         wth->subtype_sequential_close = netmon_sequential_close;
252
253         /* NetMon capture file formats v2.1+ use per-packet encapsulation types.  NetMon 3 sets the value in
254          * the header to 1 (Ethernet) for backwards compability. */
255         if((hdr.ver_major == 2 && hdr.ver_minor >= 1) || hdr.ver_major > 2)
256                 wth->file_encap = WTAP_ENCAP_PER_PACKET;
257         else
258                 wth->file_encap = netmon_encap[hdr.network];
259
260         wth->snapshot_length = 0;       /* not available in header */
261         /*
262          * Convert the time stamp to a "time_t" and a number of
263          * milliseconds.
264          */
265         tm.tm_year = pletoh16(&hdr.ts_year) - 1900;
266         tm.tm_mon = pletoh16(&hdr.ts_month) - 1;
267         tm.tm_mday = pletoh16(&hdr.ts_day);
268         tm.tm_hour = pletoh16(&hdr.ts_hour);
269         tm.tm_min = pletoh16(&hdr.ts_min);
270         tm.tm_sec = pletoh16(&hdr.ts_sec);
271         tm.tm_isdst = -1;
272         netmon->start_secs = mktime(&tm);
273         /*
274          * XXX - what if "secs" is -1?  Unlikely, but if the capture was
275          * done in a time zone that switches between standard and summer
276          * time sometime other than when we do, and thus the time was one
277          * that doesn't exist here because a switch from standard to summer
278          * time zips over it, it could happen.
279          *
280          * On the other hand, if the capture was done in a different time
281          * zone, this won't work right anyway; unfortunately, the time
282          * zone isn't stored in the capture file (why the hell didn't
283          * they stuff a FILETIME, which is the number of 100-nanosecond
284          * intervals since 1601-01-01 00:00:00 "UTC", there, instead
285          * of stuffing a SYSTEMTIME, which is time-zone-dependent, there?).
286          */
287         netmon->start_nsecs = pletoh16(&hdr.ts_msec)*1000000;
288
289         netmon->version_major = hdr.ver_major;
290         netmon->version_minor = hdr.ver_minor;
291
292         /*
293          * No frame table allocated yet; initialize these in case we
294          * get an error before allocating it or when trying to allocate
295          * it, so that the attempt to release the private data on failure
296          * doesn't crash.
297          */
298         netmon->frame_table_size = 0;
299         netmon->frame_table = NULL;
300
301         /*
302          * Get the offset of the frame index table.
303          */
304         frame_table_offset = pletoh32(&hdr.frametableoffset);
305
306         /*
307          * It appears that some NetMon 2.x files don't have the
308          * first packet starting exactly 128 bytes into the file.
309          *
310          * Furthermore, it also appears that there are "holes" in
311          * the file, i.e. frame N+1 doesn't always follow immediately
312          * after frame N.
313          *
314          * Therefore, we must read the frame table, and use the offsets
315          * in it as the offsets of the frames.
316          */
317         frame_table_length = pletoh32(&hdr.frametablelength);
318         frame_table_size = frame_table_length / (guint32)sizeof (guint32);
319         if ((frame_table_size * sizeof (guint32)) != frame_table_length) {
320                 *err = WTAP_ERR_BAD_FILE;
321                 *err_info = g_strdup_printf("netmon: frame table length is %u, which is not a multiple of the size of an entry",
322                     frame_table_length);
323                 return WTAP_OPEN_ERROR;
324         }
325         if (frame_table_size == 0) {
326                 *err = WTAP_ERR_BAD_FILE;
327                 *err_info = g_strdup_printf("netmon: frame table length is %u, which means it's less than one entry in size",
328                     frame_table_length);
329                 return WTAP_OPEN_ERROR;
330         }
331         /*
332          * XXX - clamp the size of the frame table, so that we don't
333          * attempt to allocate a huge frame table and fail.
334          *
335          * Given that file offsets in the frame table are 32-bit,
336          * a NetMon file cannot be bigger than 2^32 bytes.
337          * Given that a NetMon 1.x-format packet header is 8 bytes,
338          * that means a NetMon file cannot have more than
339          * 512*2^20 packets.  We'll pick that as the limit for
340          * now; it's 1/8th of a 32-bit address space, which is
341          * probably not going to exhaust the address space all by
342          * itself, and probably won't exhaust the backing store.
343          */
344         if (frame_table_size > 512*1024*1024) {
345                 *err = WTAP_ERR_BAD_FILE;
346                 *err_info = g_strdup_printf("netmon: frame table length is %u, which is larger than we support",
347                     frame_table_length);
348                 return WTAP_OPEN_ERROR;
349         }
350         if (file_seek(wth->fh, frame_table_offset, SEEK_SET, err) == -1) {
351                 return WTAP_OPEN_ERROR;
352         }
353         frame_table = (guint32 *)g_try_malloc(frame_table_length);
354         if (frame_table_length != 0 && frame_table == NULL) {
355                 *err = ENOMEM;  /* we assume we're out of memory */
356                 return WTAP_OPEN_ERROR;
357         }
358         if (!wtap_read_bytes(wth->fh, frame_table, frame_table_length,
359             err, err_info)) {
360                 g_free(frame_table);
361                 return WTAP_OPEN_ERROR;
362         }
363         netmon->frame_table_size = frame_table_size;
364         netmon->frame_table = frame_table;
365
366 #ifdef WORDS_BIGENDIAN
367         /*
368          * OK, now byte-swap the frame table.
369          */
370         for (i = 0; i < frame_table_size; i++)
371                 frame_table[i] = pletoh32(&frame_table[i]);
372 #endif
373
374         /* Set up to start reading at the first frame. */
375         netmon->current_frame = 0;
376         switch (netmon->version_major) {
377
378         case 1:
379                 /*
380                  * Version 1.x of the file format supports
381                  * millisecond precision.
382                  */
383                 wth->file_tsprec = WTAP_TSPREC_MSEC;
384                 break;
385
386         case 2:
387                 /*
388                  * Version 1.x of the file format supports
389                  * 100-nanosecond precision; we don't
390                  * currently support that, so say
391                  * "nanosecond precision" for now.
392                  */
393                 wth->file_tsprec = WTAP_TSPREC_NSEC;
394                 break;
395         }
396         return WTAP_OPEN_MINE;
397 }
398
399 static void
400 netmon_set_pseudo_header_info(struct wtap_pkthdr *phdr, Buffer *buf)
401 {
402         switch (phdr->pkt_encap) {
403
404         case WTAP_ENCAP_ATM_PDUS:
405                 /*
406                  * Attempt to guess from the packet data, the VPI, and
407                  * the VCI information about the type of traffic.
408                  */
409                 atm_guess_traffic_type(phdr, ws_buffer_start_ptr(buf));
410                 break;
411
412         case WTAP_ENCAP_ETHERNET:
413                 /*
414                  * We assume there's no FCS in this frame.
415                  */
416                 phdr->pseudo_header.eth.fcs_len = 0;
417                 break;
418
419         case WTAP_ENCAP_IEEE_802_11_NETMON:
420                 /*
421                  * It appears to be the case that management
422                  * frames (and control and extension frames ?) may
423                  * or may not have an FCS and data frames don't.
424                  * (Netmon capture files have been seen for this
425                  *  encapsulation having management frames either
426                  *  completely with or without an FCS. Also: instances have been
427                  *  seen where both Management and Control frames
428                  *  do not have an FCS).
429                  * An "FCS length" of -2 means "NetMon weirdness".
430                  */
431                 memset(&phdr->pseudo_header.ieee_802_11, 0, sizeof(phdr->pseudo_header.ieee_802_11));
432                 phdr->pseudo_header.ieee_802_11.fcs_len = -2;
433                 phdr->pseudo_header.ieee_802_11.decrypted = FALSE;
434                 phdr->pseudo_header.ieee_802_11.datapad = FALSE;
435                 phdr->pseudo_header.ieee_802_11.phy = PHDR_802_11_PHY_UNKNOWN;
436                 break;
437         }
438 }
439
440 typedef enum {
441         SUCCESS,
442         FAILURE,
443         RETRY
444 } process_record_retval;
445
446 static process_record_retval
447 netmon_process_record(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
448     Buffer *buf, int *err, gchar **err_info)
449 {
450         netmon_t *netmon = (netmon_t *)wth->priv;
451         int     hdr_size = 0;
452         union {
453                 struct netmonrec_1_x_hdr hdr_1_x;
454                 struct netmonrec_2_x_hdr hdr_2_x;
455         }       hdr;
456         gint64  delta = 0;      /* signed - frame times can be before the nominal start */
457         gint64  t;
458         time_t  secs;
459         int     nsecs;
460         guint32 packet_size = 0;
461         guint32 orig_size = 0;
462         int     trlr_size;
463         union {
464                 struct netmonrec_2_1_trlr trlr_2_1;
465                 struct netmonrec_2_2_trlr trlr_2_2;
466                 struct netmonrec_2_3_trlr trlr_2_3;
467         }       trlr;
468         guint16 network;
469         int     pkt_encap;
470
471         /* Read record header. */
472         switch (netmon->version_major) {
473
474         case 1:
475                 hdr_size = sizeof (struct netmonrec_1_x_hdr);
476                 break;
477
478         case 2:
479                 hdr_size = sizeof (struct netmonrec_2_x_hdr);
480                 break;
481         }
482         if (!wtap_read_bytes_or_eof(fh, &hdr, hdr_size, err, err_info))
483                 return FAILURE;
484
485         switch (netmon->version_major) {
486
487         case 1:
488                 orig_size = pletoh16(&hdr.hdr_1_x.orig_len);
489                 packet_size = pletoh16(&hdr.hdr_1_x.incl_len);
490                 break;
491
492         case 2:
493                 orig_size = pletoh32(&hdr.hdr_2_x.orig_len);
494                 packet_size = pletoh32(&hdr.hdr_2_x.incl_len);
495                 break;
496         }
497         if (packet_size > WTAP_MAX_PACKET_SIZE) {
498                 /*
499                  * Probably a corrupt capture file; don't blow up trying
500                  * to allocate space for an immensely-large packet.
501                  */
502                 *err = WTAP_ERR_BAD_FILE;
503                 *err_info = g_strdup_printf("netmon: File has %u-byte packet, bigger than maximum of %u",
504                     packet_size, WTAP_MAX_PACKET_SIZE);
505                 return FAILURE;
506         }
507
508         phdr->rec_type = REC_TYPE_PACKET;
509
510         /*
511          * If this is an ATM packet, the first
512          * "sizeof (struct netmon_atm_hdr)" bytes have destination and
513          * source addresses (6 bytes - MAC addresses of some sort?)
514          * and the VPI and VCI; read them and generate the pseudo-header
515          * from them.
516          */
517         switch (wth->file_encap) {
518
519         case WTAP_ENCAP_ATM_PDUS:
520                 if (packet_size < sizeof (struct netmon_atm_hdr)) {
521                         /*
522                          * Uh-oh, the packet isn't big enough to even
523                          * have a pseudo-header.
524                          */
525                         *err = WTAP_ERR_BAD_FILE;
526                         *err_info = g_strdup_printf("netmon: ATM file has a %u-byte packet, too small to have even an ATM pseudo-header",
527                             packet_size);
528                         return FAILURE;
529                 }
530                 if (!netmon_read_atm_pseudoheader(fh, &phdr->pseudo_header,
531                     err, err_info))
532                         return FAILURE; /* Read error */
533
534                 /*
535                  * Don't count the pseudo-header as part of the packet.
536                  */
537                 orig_size -= (guint)sizeof (struct netmon_atm_hdr);
538                 packet_size -= (guint)sizeof (struct netmon_atm_hdr);
539                 break;
540
541         default:
542                 break;
543         }
544
545         switch (netmon->version_major) {
546
547         case 1:
548                 /*
549                  * According to Paul Long, this offset is unsigned.
550                  * It's 32 bits, so the maximum value will fit in
551                  * a gint64 such as delta, even after multiplying
552                  * it by 1000000.
553                  *
554                  * pletoh32() returns a guint32; we cast it to gint64
555                  * before multiplying, so that the product doesn't
556                  * overflow a guint32.
557                  */
558                 delta = ((gint64)pletoh32(&hdr.hdr_1_x.ts_delta))*1000000;
559                 break;
560
561         case 2:
562                 /*
563                  * OK, this is weird.  Microsoft's documentation
564                  * says this is in microseconds and is a 64-bit
565                  * unsigned number, but it can be negative; they
566                  * say what appears to amount to "treat it as an
567                  * unsigned number, multiply it by 10, and then
568                  * interpret the resulting 64-bit quantity as a
569                  * signed number".  That operation can turn a
570                  * value with the uppermost bit 0 to a value with
571                  * the uppermost bit 1, hence turning a large
572                  * positive number-of-microseconds into a small
573                  * negative number-of-100-nanosecond-increments.
574                  */
575                 delta = pletoh64(&hdr.hdr_2_x.ts_delta)*10;
576
577                 /*
578                  * OK, it's now a signed value in 100-nanosecond
579                  * units.  Now convert it to nanosecond units.
580                  */
581                 delta *= 100;
582                 break;
583         }
584         secs = 0;
585         t = netmon->start_nsecs + delta;
586         while (t < 0) {
587                 /*
588                  * Propagate a borrow into the seconds.
589                  * The seconds is a time_t, and can be < 0
590                  * (unlikely, as Windows didn't exist before
591                  * January 1, 1970, 00:00:00 UTC), while the
592                  * nanoseconds should be positive, as in
593                  * "nanoseconds since the instant of time
594                  * represented by the seconds".
595                  *
596                  * We do not want t to be negative, as, according
597                  * to the C90 standard, "if either operand [of /
598                  * or %] is negative, whether the result of the
599                  * / operator is the largest integer less than or
600                  * equal to the algebraic quotient or the smallest
601                  * greater than or equal to the algebraic quotient
602                  * is implementation-defined, as is the sign of
603                  * the result of the % operator", and we want
604                  * the result of the division and remainder
605                  * operations to be the same on all platforms.
606                  */
607                 t += 1000000000;
608                 secs--;
609         }
610         secs += (time_t)(t/1000000000);
611         nsecs = (int)(t%1000000000);
612         phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
613         phdr->ts.secs = netmon->start_secs + secs;
614         phdr->ts.nsecs = nsecs;
615         phdr->caplen = packet_size;
616         phdr->len = orig_size;
617
618         /*
619          * Read the packet data.
620          */
621         if (!wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info))
622                 return FAILURE;
623
624         /*
625          * For version 2.1 and later, there's additional information
626          * after the frame data.
627          */
628         if ((netmon->version_major == 2 && netmon->version_minor >= 1) ||
629             netmon->version_major > 2) {
630                 if (netmon->version_major > 2) {
631                         /*
632                          * Asssume 2.3 format, for now.
633                          */
634                         trlr_size = (int)sizeof (struct netmonrec_2_3_trlr);
635                 } else {
636                         switch (netmon->version_minor) {
637
638                         case 1:
639                                 trlr_size = (int)sizeof (struct netmonrec_2_1_trlr);
640                                 break;
641
642                         case 2:
643                                 trlr_size = (int)sizeof (struct netmonrec_2_2_trlr);
644                                 break;
645
646                         default:
647                                 trlr_size = (int)sizeof (struct netmonrec_2_3_trlr);
648                                 break;
649                         }
650                 }
651
652                 if (!wtap_read_bytes(fh, &trlr, trlr_size, err, err_info))
653                         return FAILURE;
654
655                 network = pletoh16(trlr.trlr_2_1.network);
656                 if ((network & 0xF000) == NETMON_NET_PCAP_BASE) {
657                         /*
658                          * Converted pcap file - the LINKTYPE_ value
659                          * is the network value with 0xF000 masked off.
660                          */
661                         network &= 0x0FFF;
662                         pkt_encap = wtap_pcap_encap_to_wtap_encap(network);
663                         if (pkt_encap == WTAP_ENCAP_UNKNOWN) {
664                                 *err = WTAP_ERR_UNSUPPORTED;
665                                 *err_info = g_strdup_printf("netmon: converted pcap network type %u unknown or unsupported",
666                                     network);
667                                 return FAILURE;
668                         }
669                 } else if (network < NUM_NETMON_ENCAPS) {
670                         /*
671                          * Regular NetMon encapsulation.
672                          */
673                         pkt_encap = netmon_encap[network];
674                         if (pkt_encap == WTAP_ENCAP_UNKNOWN) {
675                                 *err = WTAP_ERR_UNSUPPORTED;
676                                 *err_info = g_strdup_printf("netmon: network type %u unknown or unsupported",
677                                     network);
678                                 return FAILURE;
679                         }
680                 } else {
681                         /*
682                          * Special packet type for metadata.
683                          */
684                         switch (network) {
685
686                         case NETMON_NET_NETEVENT:
687                                 /*
688                                  * Event Tracing event.
689                                  *
690                                  * http://msdn.microsoft.com/en-us/library/aa363759(VS.85).aspx
691                                  */
692                                 return RETRY;
693
694                         case NETMON_NET_NETWORK_INFO_EX:
695                                 /*
696                                  * List of adapters on which the capture
697                                  * was done.
698                                  */
699                                 return RETRY;
700
701                         case NETMON_NET_PAYLOAD_HEADER:
702                                 /*
703                                  * Header for a fake frame constructed
704                                  * by reassembly.
705                                  */
706                                 return RETRY;
707
708                         case NETMON_NET_NETWORK_INFO:
709                                 /*
710                                  * List of adapters on which the capture
711                                  * was done.
712                                  */
713                                 return RETRY;
714
715                         case NETMON_NET_DNS_CACHE:
716                                 /*
717                                  * List of resolved IP addresses.
718                                  */
719                                 return RETRY;
720
721                         case NETMON_NET_NETMON_FILTER:
722                                 /*
723                                  * NetMon capture or display filter
724                                  * string.
725                                  */
726                                 return RETRY;
727
728                         default:
729                                 *err = WTAP_ERR_UNSUPPORTED;
730                                 *err_info = g_strdup_printf("netmon: network type %u unknown or unsupported",
731                                     network);
732                                 return FAILURE;
733                         }
734                 }
735
736                 phdr->pkt_encap = pkt_encap;
737                 if (netmon->version_major > 2 || netmon->version_minor > 2) {
738                         guint64 d;
739
740                         d = pletoh64(trlr.trlr_2_3.utc_timestamp);
741
742                         /*
743                          * Get the time as seconds and nanoseconds.
744                          * and overwrite the time stamp obtained
745                          * from the record header.
746                          */
747                         if (!filetime_to_nstime(&phdr->ts, d)) {
748                                 *err = WTAP_ERR_BAD_FILE;
749                                 *err_info = g_strdup_printf("netmon: time stamp outside supported range");
750                                 return FAILURE;
751                         }
752                 }
753         }
754
755         netmon_set_pseudo_header_info(phdr, buf);
756         return SUCCESS;
757 }
758
759 /* Read the next packet */
760 static gboolean netmon_read(wtap *wth, int *err, gchar **err_info,
761     gint64 *data_offset)
762 {
763         netmon_t *netmon = (netmon_t *)wth->priv;
764         gint64  rec_offset;
765
766         for (;;) {
767                 /* Have we reached the end of the packet data? */
768                 if (netmon->current_frame >= netmon->frame_table_size) {
769                         /* Yes.  We won't need the frame table any more;
770                            free it. */
771                         g_free(netmon->frame_table);
772                         netmon->frame_table = NULL;
773                         *err = 0;       /* it's just an EOF, not an error */
774                         return FALSE;
775                 }
776
777                 /* Seek to the beginning of the current record, if we're
778                    not there already (seeking to the current position
779                    may still cause a seek and a read of the underlying file,
780                    so we don't want to do it unconditionally).
781
782                    Yes, the current record could be before the previous
783                    record.  At least some captures put the trailer record
784                    with statistics as the first physical record in the
785                    file, but set the frame table up so it's the last
786                    record in sequence. */
787                 rec_offset = netmon->frame_table[netmon->current_frame];
788                 if (file_tell(wth->fh) != rec_offset) {
789                         if (file_seek(wth->fh, rec_offset, SEEK_SET, err) == -1)
790                                 return FALSE;
791                 }
792                 netmon->current_frame++;
793
794                 *data_offset = file_tell(wth->fh);
795
796                 switch (netmon_process_record(wth, wth->fh, &wth->phdr,
797                     wth->frame_buffer, err, err_info)) {
798
799                 case RETRY:
800                         continue;
801
802                 case SUCCESS:
803                         return TRUE;
804
805                 case FAILURE:
806                         return FALSE;
807                 }
808         }
809 }
810
811 static gboolean
812 netmon_seek_read(wtap *wth, gint64 seek_off,
813     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
814 {
815         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
816                 return FALSE;
817
818         switch (netmon_process_record(wth, wth->random_fh, phdr, buf, err,
819             err_info)) {
820
821         default:
822                 /*
823                  * This should not happen.
824                  */
825                 *err = WTAP_ERR_BAD_FILE;
826                 *err_info = g_strdup("netmon: saw metadata in netmon_seek_read");
827                 return FALSE;
828
829         case SUCCESS:
830                 return TRUE;
831
832         case FAILURE:
833                 return FALSE;
834         }
835 }
836
837 static gboolean
838 netmon_read_atm_pseudoheader(FILE_T fh, union wtap_pseudo_header *pseudo_header,
839     int *err, gchar **err_info)
840 {
841         struct netmon_atm_hdr atm_phdr;
842         guint16 vpi, vci;
843
844         if (!wtap_read_bytes(fh, &atm_phdr, sizeof (struct netmon_atm_hdr),
845             err, err_info))
846                 return FALSE;
847
848         vpi = g_ntohs(atm_phdr.vpi);
849         vci = g_ntohs(atm_phdr.vci);
850
851         pseudo_header->atm.vpi = vpi;
852         pseudo_header->atm.vci = vci;
853
854         /* We don't have this information */
855         pseudo_header->atm.flags = 0;
856         pseudo_header->atm.channel = 0;
857         pseudo_header->atm.cells = 0;
858         pseudo_header->atm.aal5t_u2u = 0;
859         pseudo_header->atm.aal5t_len = 0;
860         pseudo_header->atm.aal5t_chksum = 0;
861
862         return TRUE;
863 }
864
865 /* Throw away the frame table used by the sequential I/O stream. */
866 static void
867 netmon_sequential_close(wtap *wth)
868 {
869         netmon_t *netmon = (netmon_t *)wth->priv;
870
871         if (netmon->frame_table != NULL) {
872                 g_free(netmon->frame_table);
873                 netmon->frame_table = NULL;
874         }
875 }
876
877 typedef struct {
878         gboolean got_first_record_time;
879         nstime_t first_record_time;
880         guint32 frame_table_offset;
881         guint32 *frame_table;
882         guint   frame_table_index;
883         guint   frame_table_size;
884         gboolean no_more_room;          /* TRUE if no more records can be written */
885 } netmon_dump_t;
886
887 static const int wtap_encap[] = {
888         -1,             /* WTAP_ENCAP_UNKNOWN -> unsupported */
889         1,              /* WTAP_ENCAP_ETHERNET -> NDIS Ethernet */
890         2,              /* WTAP_ENCAP_TOKEN_RING -> NDIS Token Ring */
891         -1,             /* WTAP_ENCAP_SLIP -> unsupported */
892         -1,             /* WTAP_ENCAP_PPP -> unsupported */
893         3,              /* WTAP_ENCAP_FDDI -> NDIS FDDI */
894         3,              /* WTAP_ENCAP_FDDI_BITSWAPPED -> NDIS FDDI */
895         -1,             /* WTAP_ENCAP_RAW_IP -> unsupported */
896         -1,             /* WTAP_ENCAP_ARCNET -> unsupported */
897         -1,             /* WTAP_ENCAP_ARCNET_LINUX -> unsupported */
898         -1,             /* WTAP_ENCAP_ATM_RFC1483 -> unsupported */
899         -1,             /* WTAP_ENCAP_LINUX_ATM_CLIP -> unsupported */
900         -1,             /* WTAP_ENCAP_LAPB -> unsupported*/
901         4,              /* WTAP_ENCAP_ATM_PDUS -> NDIS WAN (*NOT* ATM!) */
902 };
903 #define NUM_WTAP_ENCAPS (sizeof wtap_encap / sizeof wtap_encap[0])
904
905 /* Returns 0 if we could write the specified encapsulation type,
906    an error indication otherwise. */
907 int netmon_dump_can_write_encap_1_x(int encap)
908 {
909         /*
910          * Per-packet encapsulations are *not* supported in NetMon 1.x
911          * format.
912          */
913         if (encap < 0 || (unsigned) encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
914                 return WTAP_ERR_UNWRITABLE_ENCAP;
915
916         return 0;
917 }
918
919 int netmon_dump_can_write_encap_2_x(int encap)
920 {
921         /*
922          * Per-packet encapsulations are supported in NetMon 2.1
923          * format.
924          */
925         if (encap == WTAP_ENCAP_PER_PACKET)
926                 return 0;
927
928         if (encap < 0 || (unsigned) encap >= NUM_WTAP_ENCAPS || wtap_encap[encap] == -1)
929                 return WTAP_ERR_UNWRITABLE_ENCAP;
930
931         return 0;
932 }
933
934 /* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
935    failure */
936 gboolean netmon_dump_open(wtap_dumper *wdh, int *err)
937 {
938         netmon_dump_t *netmon;
939
940         /* We can't fill in all the fields in the file header, as we
941            haven't yet written any packets.  As we'll have to rewrite
942            the header when we've written out all the packets, we just
943            skip over the header for now. */
944         if (wtap_dump_file_seek(wdh, CAPTUREFILE_HEADER_SIZE, SEEK_SET, err) == -1)
945                 return FALSE;
946
947         wdh->subtype_write = netmon_dump;
948         wdh->subtype_finish = netmon_dump_finish;
949
950         netmon = (netmon_dump_t *)g_malloc(sizeof(netmon_dump_t));
951         wdh->priv = (void *)netmon;
952         netmon->frame_table_offset = CAPTUREFILE_HEADER_SIZE;
953         netmon->got_first_record_time = FALSE;
954         netmon->frame_table = NULL;
955         netmon->frame_table_index = 0;
956         netmon->frame_table_size = 0;
957         netmon->no_more_room = FALSE;
958
959         return TRUE;
960 }
961
962 /* Write a record for a packet to a dump file.
963    Returns TRUE on success, FALSE on failure. */
964 static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
965     const guint8 *pd, int *err, gchar **err_info _U_)
966 {
967         const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
968         netmon_dump_t *netmon = (netmon_dump_t *)wdh->priv;
969         struct netmonrec_1_x_hdr rec_1_x_hdr;
970         struct netmonrec_2_x_hdr rec_2_x_hdr;
971         void *hdrp;
972         size_t rec_size;
973         struct netmonrec_2_1_trlr rec_2_x_trlr;
974         size_t hdr_size;
975         struct netmon_atm_hdr atm_hdr;
976         int atm_hdrsize;
977         gint64  secs;
978         gint32  nsecs;
979
980         /* We can only write packet records. */
981         if (phdr->rec_type != REC_TYPE_PACKET) {
982                 *err = WTAP_ERR_UNWRITABLE_REC_TYPE;
983                 return FALSE;
984         }
985
986         switch (wdh->file_type_subtype) {
987
988         case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
989                 /*
990                  * The length fields are 16-bit, so there's a hard limit
991                  * of 65535.
992                  */
993                 if (phdr->caplen > 65535) {
994                         *err = WTAP_ERR_PACKET_TOO_LARGE;
995                         return FALSE;
996                 }
997                 break;
998
999         case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
1000                 /* Don't write anything we're not willing to read. */
1001                 if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
1002                         *err = WTAP_ERR_PACKET_TOO_LARGE;
1003                         return FALSE;
1004                 }
1005                 break;
1006
1007         default:
1008                 /* We should never get here - our open routine
1009                    should only get called for the types above. */
1010                 *err = WTAP_ERR_UNWRITABLE_FILE_TYPE;
1011                 return FALSE;
1012         }
1013
1014         if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
1015                 /*
1016                  * Is this network type supported?
1017                  */
1018                 if (phdr->pkt_encap < 0 ||
1019                     (unsigned) phdr->pkt_encap >= NUM_WTAP_ENCAPS ||
1020                     wtap_encap[phdr->pkt_encap] == -1) {
1021                         /*
1022                          * No.  Fail.
1023                          */
1024                         *err = WTAP_ERR_UNWRITABLE_ENCAP;
1025                         return FALSE;
1026                 }
1027
1028                 /*
1029                  * Fill in the trailer with the network type.
1030                  */
1031                 phtoles(rec_2_x_trlr.network, wtap_encap[phdr->pkt_encap]);
1032         }
1033
1034         /*
1035          * Will the file offset of this frame fit in a 32-bit unsigned
1036          * integer?
1037          */
1038         if (netmon->no_more_room) {
1039                 /*
1040                  * No, so the file is too big for NetMon format to
1041                  * handle.
1042                  */
1043                 *err = EFBIG;
1044                 return FALSE;
1045         }
1046
1047         /*
1048          * NetMon files have a capture start time in the file header,
1049          * and have times relative to that in the packet headers;
1050          * pick the time of the first packet as the capture start
1051          * time.
1052          *
1053          * That time has millisecond resolution, so chop any
1054          * sub-millisecond part of the time stamp off.
1055          */
1056         if (!netmon->got_first_record_time) {
1057                 netmon->first_record_time.secs = phdr->ts.secs;
1058                 netmon->first_record_time.nsecs =
1059                     (phdr->ts.nsecs/1000000)*1000000;
1060                 netmon->got_first_record_time = TRUE;
1061         }
1062
1063         if (wdh->encap == WTAP_ENCAP_ATM_PDUS)
1064                 atm_hdrsize = sizeof (struct netmon_atm_hdr);
1065         else
1066                 atm_hdrsize = 0;
1067         secs = (gint64)(phdr->ts.secs - netmon->first_record_time.secs);
1068         nsecs = phdr->ts.nsecs - netmon->first_record_time.nsecs;
1069         while (nsecs < 0) {
1070                 /*
1071                  * Propagate a borrow into the seconds.
1072                  * The seconds is a time_t, and can be < 0
1073                  * (unlikely, as neither UN*X nor DOS
1074                  * nor the original Mac System existed
1075                  * before January 1, 1970, 00:00:00 UTC),
1076                  * while the nanoseconds should be positive,
1077                  * as in "nanoseconds since the instant of time
1078                  * represented by the seconds".
1079                  *
1080                  * We do not want t to be negative, as, according
1081                  * to the C90 standard, "if either operand [of /
1082                  * or %] is negative, whether the result of the
1083                  * / operator is the largest integer less than or
1084                  * equal to the algebraic quotient or the smallest
1085                  * greater than or equal to the algebraic quotient
1086                  * is implementation-defined, as is the sign of
1087                  * the result of the % operator", and we want
1088                  * the result of the division and remainder
1089                  * operations to be the same on all platforms.
1090                  */
1091                 nsecs += 1000000000;
1092                 secs--;
1093         }
1094         switch (wdh->file_type_subtype) {
1095
1096         case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
1097                 rec_1_x_hdr.ts_delta = GUINT32_TO_LE(secs*1000 + (nsecs + 500000)/1000000);
1098                 rec_1_x_hdr.orig_len = GUINT16_TO_LE(phdr->len + atm_hdrsize);
1099                 rec_1_x_hdr.incl_len = GUINT16_TO_LE(phdr->caplen + atm_hdrsize);
1100                 hdrp = &rec_1_x_hdr;
1101                 hdr_size = sizeof rec_1_x_hdr;
1102                 break;
1103
1104         case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
1105                 rec_2_x_hdr.ts_delta = GUINT64_TO_LE(secs*1000000 + (nsecs + 500)/1000);
1106                 rec_2_x_hdr.orig_len = GUINT32_TO_LE(phdr->len + atm_hdrsize);
1107                 rec_2_x_hdr.incl_len = GUINT32_TO_LE(phdr->caplen + atm_hdrsize);
1108                 hdrp = &rec_2_x_hdr;
1109                 hdr_size = sizeof rec_2_x_hdr;
1110                 break;
1111
1112         default:
1113                 /* We should never get here - our open routine
1114                    should only get called for the types above. */
1115                 *err = WTAP_ERR_UNWRITABLE_FILE_TYPE;
1116                 return FALSE;
1117         }
1118
1119         /*
1120          * Keep track of the record size, as we need to update
1121          * the current file offset.
1122          */
1123         rec_size = 0;
1124
1125         if (!wtap_dump_file_write(wdh, hdrp, hdr_size, err))
1126                 return FALSE;
1127         rec_size += hdr_size;
1128
1129         if (wdh->encap == WTAP_ENCAP_ATM_PDUS) {
1130                 /*
1131                  * Write the ATM header.
1132                  * We supply all-zero destination and source addresses.
1133                  */
1134                 memset(&atm_hdr.dest, 0, sizeof atm_hdr.dest);
1135                 memset(&atm_hdr.src, 0, sizeof atm_hdr.src);
1136                 atm_hdr.vpi = g_htons(pseudo_header->atm.vpi);
1137                 atm_hdr.vci = g_htons(pseudo_header->atm.vci);
1138                 if (!wtap_dump_file_write(wdh, &atm_hdr, sizeof atm_hdr, err))
1139                         return FALSE;
1140                 rec_size += sizeof atm_hdr;
1141         }
1142
1143         if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
1144                 return FALSE;
1145         rec_size += phdr->caplen;
1146
1147         if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
1148                 /*
1149                  * Write out the trailer.
1150                  */
1151                 if (!wtap_dump_file_write(wdh, &rec_2_x_trlr,
1152                     sizeof rec_2_x_trlr, err))
1153                         return FALSE;
1154                 rec_size += sizeof rec_2_x_trlr;
1155         }
1156
1157         /*
1158          * Stash the file offset of this frame.
1159          */
1160         if (netmon->frame_table_size == 0) {
1161                 /*
1162                  * Haven't yet allocated the buffer for the frame table.
1163                  */
1164                 netmon->frame_table = (guint32 *)g_malloc(1024 * sizeof *netmon->frame_table);
1165                 netmon->frame_table_size = 1024;
1166         } else {
1167                 /*
1168                  * We've allocated it; are we at the end?
1169                  */
1170                 if (netmon->frame_table_index >= netmon->frame_table_size) {
1171                         /*
1172                          * Yes - double the size of the frame table.
1173                          */
1174                         netmon->frame_table_size *= 2;
1175                         netmon->frame_table = (guint32 *)g_realloc(netmon->frame_table,
1176                             netmon->frame_table_size * sizeof *netmon->frame_table);
1177                 }
1178         }
1179
1180         netmon->frame_table[netmon->frame_table_index] =
1181             GUINT32_TO_LE(netmon->frame_table_offset);
1182
1183         /*
1184          * Is this the last record we can write?
1185          * I.e., will the frame table offset of the next record not fit
1186          * in a 32-bit frame table offset entry?
1187          *
1188          * (We don't bother checking whether the number of frames
1189          * will fit in a 32-bit value, as, even if each record were
1190          * 1 byte, if there were more than 2^32-1 packets, the frame
1191          * table offset of at least one of those packets will be >
1192          * 2^32 - 1.)
1193          *
1194          * Note: this also catches the unlikely possibility that
1195          * the record itself is > 2^32 - 1 bytes long.
1196          */
1197         if ((guint64)netmon->frame_table_offset + rec_size > G_MAXUINT32) {
1198                 /*
1199                  * Yup, too big.
1200                  */
1201                 netmon->no_more_room = TRUE;
1202         }
1203         netmon->frame_table_index++;
1204         netmon->frame_table_offset += (guint32) rec_size;
1205
1206         return TRUE;
1207 }
1208
1209 /* Finish writing to a dump file.
1210    Returns TRUE on success, FALSE on failure. */
1211 static gboolean netmon_dump_finish(wtap_dumper *wdh, int *err)
1212 {
1213         netmon_dump_t *netmon = (netmon_dump_t *)wdh->priv;
1214         size_t n_to_write;
1215         struct netmon_hdr file_hdr;
1216         const char *magicp;
1217         size_t magic_size;
1218         struct tm *tm;
1219
1220         /* Write out the frame table.  "netmon->frame_table_index" is
1221            the number of entries we've put into it. */
1222         n_to_write = netmon->frame_table_index * sizeof *netmon->frame_table;
1223         if (!wtap_dump_file_write(wdh, netmon->frame_table, n_to_write, err))
1224                 return FALSE;
1225
1226         /* Now go fix up the file header. */
1227         if (wtap_dump_file_seek(wdh, 0, SEEK_SET, err) == -1)
1228                 return FALSE;
1229         memset(&file_hdr, '\0', sizeof file_hdr);
1230         switch (wdh->file_type_subtype) {
1231
1232         case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
1233                 magicp = netmon_1_x_magic;
1234                 magic_size = sizeof netmon_1_x_magic;
1235                 /* NetMon file version, for 1.x, is 1.1 */
1236                 file_hdr.ver_major = 1;
1237                 file_hdr.ver_minor = 1;
1238                 break;
1239
1240         case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
1241                 magicp = netmon_2_x_magic;
1242                 magic_size = sizeof netmon_2_x_magic;
1243                 /*
1244                  * NetMon file version, for 2.x, is 2.0;
1245                  * for 3.0, it's 2.1.
1246                  *
1247                  * If the file encapsulation is WTAP_ENCAP_PER_PACKET,
1248                  * we need version 2.1.
1249                  *
1250                  * XXX - version 2.3 supports UTC time stamps; when
1251                  * should we use it?  According to the file format
1252                  * documentation, NetMon 3.3 "cannot properly
1253                  * interpret" the UTC timestamp information; does
1254                  * that mean it ignores it and uses the local-time
1255                  * start time and time deltas, or mishandles them?
1256                  * Also, NetMon 3.1 and earlier can't read version
1257                  * 2.2, much less version 2.3.
1258                  */
1259                 file_hdr.ver_major = 2;
1260                 file_hdr.ver_minor =
1261                     (wdh->encap == WTAP_ENCAP_PER_PACKET) ? 1 : 0;
1262                 break;
1263
1264         default:
1265                 /* We should never get here - our open routine
1266                    should only get called for the types above. */
1267                 if (err != NULL)
1268                         *err = WTAP_ERR_UNWRITABLE_FILE_TYPE;
1269                 return FALSE;
1270         }
1271         if (!wtap_dump_file_write(wdh, magicp, magic_size, err))
1272                 return FALSE;
1273
1274         if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
1275                 /*
1276                  * We're writing NetMon 2.1 format, so the media
1277                  * type in the file header is irrelevant.  Set it
1278                  * to 1, just as Network Monitor does.
1279                  */
1280                 file_hdr.network = GUINT16_TO_LE(1);
1281         } else
1282                 file_hdr.network = GUINT16_TO_LE(wtap_encap[wdh->encap]);
1283         tm = localtime(&netmon->first_record_time.secs);
1284         if (tm != NULL) {
1285                 file_hdr.ts_year  = GUINT16_TO_LE(1900 + tm->tm_year);
1286                 file_hdr.ts_month = GUINT16_TO_LE(tm->tm_mon + 1);
1287                 file_hdr.ts_dow   = GUINT16_TO_LE(tm->tm_wday);
1288                 file_hdr.ts_day   = GUINT16_TO_LE(tm->tm_mday);
1289                 file_hdr.ts_hour  = GUINT16_TO_LE(tm->tm_hour);
1290                 file_hdr.ts_min   = GUINT16_TO_LE(tm->tm_min);
1291                 file_hdr.ts_sec   = GUINT16_TO_LE(tm->tm_sec);
1292         } else {
1293                 file_hdr.ts_year  = GUINT16_TO_LE(1900 + 0);
1294                 file_hdr.ts_month = GUINT16_TO_LE(0 + 1);
1295                 file_hdr.ts_dow   = GUINT16_TO_LE(0);
1296                 file_hdr.ts_day   = GUINT16_TO_LE(0);
1297                 file_hdr.ts_hour  = GUINT16_TO_LE(0);
1298                 file_hdr.ts_min   = GUINT16_TO_LE(0);
1299                 file_hdr.ts_sec   = GUINT16_TO_LE(0);
1300         }
1301         file_hdr.ts_msec = GUINT16_TO_LE(netmon->first_record_time.nsecs/1000000);
1302         file_hdr.frametableoffset = GUINT32_TO_LE(netmon->frame_table_offset);
1303         file_hdr.frametablelength =
1304             GUINT32_TO_LE(netmon->frame_table_index * sizeof *netmon->frame_table);
1305         if (!wtap_dump_file_write(wdh, &file_hdr, sizeof file_hdr, err))
1306                 return FALSE;
1307
1308         return TRUE;
1309 }
1310
1311 /*
1312  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
1313  *
1314  * Local variables:
1315  * c-basic-offset: 8
1316  * tab-width: 8
1317  * indent-tabs-mode: t
1318  * End:
1319  *
1320  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
1321  * :indentSize=8:tabSize=8:noTabs=false:
1322  */