Olivier Abad's patches to add:
[obnox/wireshark/wip.git] / wiretap / wtap.c
1 /* wtap.c
2  *
3  * $Id: wtap.c,v 1.26 1999/10/18 01:51:32 guy Exp $
4  *
5  * Wiretap Library
6  * Copyright (c) 1998 by Gilbert Ramirez <gram@verdict.uthscsa.edu>
7  * 
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  * 
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  */
23 #include <string.h>
24 #include <errno.h>
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 #include "wtap.h"
30 #include "file.h"
31 #include "buffer.h"
32 #include "ascend.h"
33
34 FILE* wtap_file(wtap *wth)
35 {
36         return wth->fh;
37 }
38
39 int wtap_fd(wtap *wth)
40 {
41         return wth->fd;
42 }
43
44 int wtap_file_type(wtap *wth)
45 {
46         return wth->file_type;
47 }
48
49 int wtap_snapshot_length(wtap *wth)
50 {
51         return wth->snapshot_length;
52 }
53
54 int wtap_file_encap(wtap *wth)
55 {
56         return wth->file_encap;
57 }
58
59 const char *wtap_file_type_string(wtap *wth)
60 {
61         switch (wth->file_type) {
62                 case WTAP_FILE_WTAP:
63                         return "wiretap";
64
65                 case WTAP_FILE_PCAP:
66                         return "pcap";
67
68                 case WTAP_FILE_LANALYZER:
69                         return "Novell LANalyzer";
70
71                 case WTAP_FILE_NGSNIFFER:
72                         return "Network Associates Sniffer (DOS-based)";
73
74                 case WTAP_FILE_SNOOP:
75                         return "snoop";
76
77                 case WTAP_FILE_IPTRACE:
78                         return "iptrace";
79
80                 case WTAP_FILE_NETMON_1_x:
81                         return "Microsoft Network Monitor 1.x";
82
83                 case WTAP_FILE_NETMON_2_x:
84                         return "Microsoft Network Monitor 2.x";
85
86                 case WTAP_FILE_NETXRAY_1_0:
87                         return "Cinco Networks NetXRay";
88
89                 case WTAP_FILE_NETXRAY_1_1:
90                         return "Network Associates Sniffer (Windows-based) 1.1";
91
92                 case WTAP_FILE_NETXRAY_2_001:
93                         return "Network Associates Sniffer (Windows-based) 2.001";
94
95                 case WTAP_FILE_RADCOM:
96                         return "RADCOM WAN/LAN analyzer";
97
98                 case WTAP_FILE_ASCEND:
99                         return "Lucent/Ascend access server trace";
100
101                 case WTAP_FILE_NETTL:
102                         return "HP-UX nettl traces";
103
104                 default:
105                         g_error("Unknown capture file type %d", wth->file_type);
106                         return NULL;
107         }
108 }
109
110 static const char *wtap_errlist[] = {
111         "The file isn't a plain file",
112         "The file isn't a capture file in a known format",
113         "File contains record data we don't support",
114         NULL,
115         "Files can't be saved in that format",
116         "Files from that network type can't be saved in that format",
117         "That format doesn't support per-packet encapsulations",
118         NULL,
119         NULL,
120         "Less data was read than was expected",
121         "File contains a record that's not valid",
122         "Less data was written than was requested"
123 };
124 #define WTAP_ERRLIST_SIZE       (sizeof wtap_errlist / sizeof wtap_errlist[0])
125
126 const char *wtap_strerror(int err)
127 {
128         static char errbuf[6+11+1];     /* "Error %d" */
129         int wtap_errlist_index;
130
131         if (err < 0) {
132 #ifdef HAVE_LIBZ
133                 if (err >= WTAP_ERR_ZLIB_MIN && err <= WTAP_ERR_ZLIB_MAX) {
134                         /* Assume it's a zlib error. */
135                         sprintf(errbuf, "Uncompression error: %s",
136                             zError(err - WTAP_ERR_ZLIB));
137                         return errbuf;
138                 }
139 #endif
140                 wtap_errlist_index = -1 - err;
141                 if (wtap_errlist_index >= WTAP_ERRLIST_SIZE) {
142                         sprintf(errbuf, "Error %d", err);
143                         return errbuf;
144                 }
145                 if (wtap_errlist[wtap_errlist_index] == NULL)
146                         return "Unknown reason";
147                 return wtap_errlist[wtap_errlist_index];
148         } else
149                 return strerror(err);
150 }
151
152 void wtap_close(wtap *wth)
153 {
154         /* free up memory. If any capture structure ever allocates
155          * its own memory, it would be better to make a *close() function
156          * for each filetype, like pcap_close(0, lanalyzer_close(), etc.
157          * But for now this will work. */
158         switch(wth->file_type) {
159                 case WTAP_FILE_PCAP:
160                         g_free(wth->capture.pcap);
161                         break;
162
163                 case WTAP_FILE_LANALYZER:
164                         g_free(wth->capture.lanalyzer);
165                         break;
166
167                 case WTAP_FILE_NGSNIFFER:
168                         g_free(wth->capture.ngsniffer);
169                         break;
170
171                 case WTAP_FILE_RADCOM:
172                         g_free(wth->capture.radcom);
173                         break;
174
175                 case WTAP_FILE_NETMON_1_x:
176                 case WTAP_FILE_NETMON_2_x:
177                         g_free(wth->capture.netmon);
178                         break;
179
180                 case WTAP_FILE_NETXRAY_1_0:
181                 case WTAP_FILE_NETXRAY_1_1:
182                 case WTAP_FILE_NETXRAY_2_001:
183                         g_free(wth->capture.netxray);
184                         break;
185
186                 case WTAP_FILE_ASCEND:
187                         g_free(wth->capture.ascend);
188                         break;
189
190                 case WTAP_FILE_NETTL:
191                         g_free(wth->capture.nettl);
192                         break;
193
194                 /* default:
195                          nothing */
196         }
197
198         file_close(wth->fh);
199 }
200
201 int wtap_loop(wtap *wth, int count, wtap_handler callback, u_char* user,
202         int *err)
203 {
204         int data_offset, loop = 0;
205
206         while ((data_offset = wth->subtype_read(wth, err)) > 0) {
207                 callback(user, &wth->phdr, data_offset,
208                     buffer_start_ptr(wth->frame_buffer));
209                 if (count > 0 && ++loop >= count)
210                         break;
211         }
212         if (data_offset < 0)
213                 return FALSE;   /* failure */
214         else
215                 return TRUE;    /* success */
216 }
217
218 int wtap_seek_read(int encaps, FILE *fh, int seek_off, guint8 *pd, int len)
219 {
220         switch (encaps) {
221
222         case WTAP_ENCAP_ASCEND:
223                 return ascend_seek_read(fh, seek_off, pd, len);
224
225         default:
226                 return wtap_def_seek_read(fh, seek_off, pd, len);
227         }
228 }