Revert "Refactor Wiretap"
[metze/wireshark/wip.git] / frame_tvbuff.c
1 /* frame_tvbuff.c
2  * Implements a tvbuff for frame
3  *
4  * Wireshark - Network traffic analyzer
5  * By Gerald Combs <gerald@wireshark.org>
6  * Copyright 1998 Gerald Combs
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21  */
22
23 #include "config.h"
24
25 #include <glib.h>
26
27 #include <epan/packet.h>
28 #include <epan/tvbuff-int.h>
29 #include <epan/tvbuff.h>
30
31 #include "frame_tvbuff.h"
32 #include "globals.h"
33
34 #include "wtap-int.h" /* for ->random_fh */
35
36 struct tvb_frame {
37         struct tvbuff tvb;
38
39         Buffer *buf;         /* Packet data */
40
41         wtap *wth;           /**< Wiretap session */
42         gint64 file_off;     /**< File offset */
43
44         guint offset;
45 };
46
47 static gboolean
48 frame_read(struct tvb_frame *frame_tvb, struct wtap_pkthdr *phdr, Buffer *buf)
49 {
50         int    err;
51         gchar *err_info;
52
53         /* sanity check, capture file was closed? */
54         if (cfile.wth != frame_tvb->wth)
55                 return FALSE;
56
57         /* XXX, what if phdr->caplen isn't equal to
58          * frame_tvb->tvb.length + frame_tvb->offset?
59          */
60         if (!wtap_seek_read(frame_tvb->wth, frame_tvb->file_off, phdr, buf, &err, &err_info)) {
61                 switch (err) {
62                         case WTAP_ERR_UNSUPPORTED_ENCAP:
63                         case WTAP_ERR_BAD_FILE:
64                                 g_free(err_info);
65                                 break;
66                 }
67                 return FALSE;
68         }
69         return TRUE;
70 }
71
72 static void
73 frame_cache(struct tvb_frame *frame_tvb)
74 {
75         struct wtap_pkthdr phdr; /* Packet header */
76
77         memset(&phdr, 0, sizeof(struct wtap_pkthdr));
78
79         if (frame_tvb->buf == NULL) {
80                 frame_tvb->buf = (struct Buffer *) g_malloc(sizeof(struct Buffer));
81
82                 /* XXX, register frame_tvb to some list which frees from time to time not used buffers :] */
83                 buffer_init(frame_tvb->buf, frame_tvb->tvb.length + frame_tvb->offset);
84
85                 if (!frame_read(frame_tvb, &phdr, frame_tvb->buf))
86                         { /* TODO: THROW(???); */ }
87         }
88
89         frame_tvb->tvb.real_data = buffer_start_ptr(frame_tvb->buf) + frame_tvb->offset;
90 }
91
92 static void
93 frame_free(tvbuff_t *tvb)
94 {
95         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
96
97         if (frame_tvb->buf) {
98                 buffer_free(frame_tvb->buf);
99
100                 g_free(frame_tvb->buf);
101         }
102 }
103
104 static const guint8 *
105 frame_get_ptr(tvbuff_t *tvb, guint abs_offset, guint abs_length _U_)
106 {
107         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
108
109         frame_cache(frame_tvb);
110
111         return tvb->real_data + abs_offset;
112 }
113
114 static void *
115 frame_memcpy(tvbuff_t *tvb, void *target, guint abs_offset, guint abs_length)
116 {
117         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
118
119         frame_cache(frame_tvb);
120
121         return memcpy(target, tvb->real_data + abs_offset, abs_length);
122 }
123
124 static gint
125 frame_find_guint8(tvbuff_t *tvb, guint abs_offset, guint limit, guint8 needle)
126 {
127         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
128         const guint8 *result;
129
130         frame_cache(frame_tvb);
131
132         result = (const guint8 *)memchr(tvb->real_data + abs_offset, needle, limit);
133         if (result)
134                 return (gint) (result - tvb->real_data);
135         else
136                 return -1;
137 }
138
139 static gint
140 frame_pbrk_guint8(tvbuff_t *tvb, guint abs_offset, guint limit, const guint8 *needles, guchar *found_needle)
141 {
142         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
143
144         frame_cache(frame_tvb);
145
146         return tvb_pbrk_guint8(tvb, abs_offset, limit, needles, found_needle);
147 }
148
149 static guint
150 frame_offset(const tvbuff_t *tvb _U_, const guint counter)
151 {
152         /* XXX: frame_tvb->offset */
153         return counter;
154 }
155
156 static tvbuff_t *frame_clone(tvbuff_t *tvb, guint abs_offset, guint abs_length);
157
158 static const struct tvb_ops tvb_frame_ops = {
159         sizeof(struct tvb_frame), /* size */
160
161         frame_free,           /* free */
162         frame_offset,         /* offset */
163         frame_get_ptr,        /* get_ptr */
164         frame_memcpy,         /* memcpy */
165         frame_find_guint8,    /* find_guint8 */
166         frame_pbrk_guint8,    /* pbrk_guint8 */
167         frame_clone,          /* clone */
168 };
169
170 /* based on tvb_new_real_data() */
171 tvbuff_t *
172 frame_tvbuff_new(const frame_data *fd, const guint8 *buf)
173 {
174         struct tvb_frame *frame_tvb;
175         tvbuff_t *tvb;
176
177         tvb = tvb_new(&tvb_frame_ops);
178
179         /*
180          * XXX - currently, the length arguments in
181          * tvbuff structure are signed, but the captured
182          * and reported length values are unsigned; this means
183          * that length values > 2^31 - 1 will appear as
184          * negative lengths
185          *
186          * Captured length values that large will already
187          * have been filtered out by the Wiretap modules
188          * (the file will be reported as corrupted), to
189          * avoid trying to allocate large chunks of data.
190          *
191          * Reported length values will not have been
192          * filtered out, and should not be filtered out,
193          * as those lengths are not necessarily invalid.
194          *
195          * For now, we clip the reported length at G_MAXINT
196          *
197          * (XXX, is this still a problem?) There was an exception when we call
198          * tvb_new_real_data() now there's no one
199          */
200
201         tvb->real_data       = buf;
202         tvb->length          = fd->cap_len;
203         tvb->reported_length = fd->pkt_len > G_MAXINT ? G_MAXINT : fd->pkt_len;
204         tvb->initialized     = TRUE;
205
206         /*
207          * This is the top-level real tvbuff for this data source,
208          * so its data source tvbuff is itself.
209          */
210         tvb->ds_tvb = tvb;
211
212         frame_tvb = (struct tvb_frame *) tvb;
213
214         /* XXX, wtap_can_seek() */
215         if (cfile.wth && cfile.wth->random_fh
216 #ifdef WANT_PACKET_EDITOR
217                 && fd->file_off != -1 /* generic clone for modified packets */
218 #endif
219         ) {
220                 frame_tvb->wth = cfile.wth;
221                 frame_tvb->file_off = fd->file_off;
222                 frame_tvb->offset = 0;
223         } else
224                 frame_tvb->wth = NULL;
225
226         frame_tvb->buf = NULL;
227
228         return tvb;
229 }
230
231 tvbuff_t *
232 frame_tvbuff_new_buffer(const frame_data *fd, Buffer *buf)
233 {
234         return frame_tvbuff_new(fd, buffer_start_ptr(buf));
235 }
236
237 static tvbuff_t *
238 frame_clone(tvbuff_t *tvb, guint abs_offset, guint abs_length)
239 {
240         struct tvb_frame *frame_tvb = (struct tvb_frame *) tvb;
241
242         tvbuff_t *cloned_tvb;
243         struct tvb_frame *cloned_frame_tvb;
244
245         /* file not seekable */
246         if (!frame_tvb->wth)
247                 return NULL;
248
249         abs_offset += frame_tvb->offset;
250
251         cloned_tvb = tvb_new(&tvb_frame_ops);
252
253         /* data will be read when needed */
254         cloned_tvb->real_data       = NULL;
255         cloned_tvb->length          = abs_length;
256         cloned_tvb->reported_length = abs_length; /* XXX? */
257         cloned_tvb->initialized     = TRUE;
258
259         /*
260          * This is the top-level real tvbuff for this data source,
261          * so its data source tvbuff is itself.
262          */
263         cloned_tvb->ds_tvb = cloned_tvb;
264
265         cloned_frame_tvb = (struct tvb_frame *) cloned_tvb;
266         cloned_frame_tvb->wth = frame_tvb->wth;
267         cloned_frame_tvb->file_off = frame_tvb->file_off;
268         cloned_frame_tvb->offset = abs_offset;
269         cloned_frame_tvb->buf = NULL;
270
271         return cloned_tvb;
272 }
273
274
275 /* based on tvb_new_real_data() */
276 tvbuff_t *
277 file_tvbuff_new(const frame_data *fd, const guint8 *buf)
278 {
279         struct tvb_frame *frame_tvb;
280         tvbuff_t *tvb;
281
282         tvb = tvb_new(&tvb_frame_ops);
283
284         /*
285          * XXX - currently, the length arguments in
286          * tvbuff structure are signed, but the captured
287          * and reported length values are unsigned; this means
288          * that length values > 2^31 - 1 will appear as
289          * negative lengths
290          *
291          * Captured length values that large will already
292          * have been filtered out by the Wiretap modules
293          * (the file will be reported as corrupted), to
294          * avoid trying to allocate large chunks of data.
295          *
296          * Reported length values will not have been
297          * filtered out, and should not be filtered out,
298          * as those lengths are not necessarily invalid.
299          *
300          * For now, we clip the reported length at G_MAXINT
301          *
302          * (XXX, is this still a problem?) There was an exception when we call
303          * tvb_new_real_data() now there's no one
304          */
305
306         tvb->real_data       = buf;
307         tvb->length          = fd->cap_len;
308         tvb->reported_length = fd->pkt_len > G_MAXINT ? G_MAXINT : fd->pkt_len;
309         tvb->initialized     = TRUE;
310
311         /*
312          * This is the top-level real tvbuff for this data source,
313          * so its data source tvbuff is itself.
314          */
315         tvb->ds_tvb = tvb;
316
317         frame_tvb = (struct tvb_frame *) tvb;
318
319         /* XXX, wtap_can_seek() */
320         if (cfile.wth && cfile.wth->random_fh
321 #ifdef WANT_PACKET_EDITOR
322                 && fd->file_off != -1 /* generic clone for modified packets */
323 #endif
324         ) {
325                 frame_tvb->wth = cfile.wth;
326                 frame_tvb->file_off = fd->file_off;
327                 frame_tvb->offset = 0;
328         } else
329                 frame_tvb->wth = NULL;
330
331         frame_tvb->buf = NULL;
332
333         return tvb;
334 }
335
336 tvbuff_t *
337 file_tvbuff_new_buffer(const frame_data *fd, Buffer *buf)
338 {
339         return frame_tvbuff_new(fd, buffer_start_ptr(buf));
340 }