source: lib/format_pcap.c @ 73dd29f

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 73dd29f was 73dd29f, checked in by Perry Lorier <perry@…>, 14 years ago

Sooo, pcap has two types of DLT's "pure" DLT's that are platform dependant,
and "linktype" DLT's that are portable and are what are written to pcap files.

Instead of fudging the two concepts together so much, attempt to disintangle
this mess without exposing too much of the god awful mess to the end user.

  • Property mode set to 100644
File size: 17.1 KB
RevLine 
[4dedc28]1/*
2 * This file is part of libtrace
3 *
[d5a27e8]4 * Copyright (c) 2007 The University of Waikato, Hamilton, New Zealand.
[4dedc28]5 * Authors: Daniel Lawson
6 *          Perry Lorier
7 *         
8 * All rights reserved.
9 *
10 * This code has been developed by the University of Waikato WAND
11 * research group. For further information please see http://www.wand.net.nz/
12 *
13 * libtrace is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * libtrace is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with libtrace; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26 *
27 * $Id$
28 *
29 */
30
31#include "common.h"
32#include "config.h"
33#include "libtrace.h"
[9e2a109]34#include "libtrace_int.h"
[72bfe20]35#include "format_helper.h"
[ffc8c8d]36
[4dedc28]37#include <sys/stat.h>
38#include <assert.h>
[b69afb1]39#include <stdio.h>
[9c6aa95]40#include <stdlib.h>
41#include <string.h>
[880aa58]42#include <errno.h>
[4dedc28]43
[e5c2bc4]44#ifdef HAVE_PCAP_H
[4dedc28]45#  include <pcap.h>
46#  ifdef HAVE_PCAP_INT_H
47#    include <pcap-int.h>
48#  endif
49#endif
50
[e5c2bc4]51#ifdef HAVE_LIBPCAP
[f3ed52a]52static struct libtrace_format_t pcap;
53static struct libtrace_format_t pcapint;
[91ebc50]54
[ab4cb04]55#define DATA(x) ((struct pcap_format_data_t*)((x)->format_data))
56#define DATAOUT(x) ((struct pcap_format_data_out_t*)((x)->format_data))
[3073c04]57
[ab4cb04]58#define INPUT DATA(libtrace)->input
59#define OUTPUT DATAOUT(libtrace)->output
60struct pcap_format_data_t {
[9e2a109]61        /** Information about the current state of the input device */
62        union {
63                pcap_t *pcap;
64        } input;
[df338b3]65        int snaplen;
66        libtrace_filter_t *filter;
67        int promisc;
[9e2a109]68};
69
[ab4cb04]70struct pcap_format_data_out_t {
[3073c04]71        union {
[1974620]72                struct {
73                        pcap_t *pcap;
74                        pcap_dumper_t *dump;
75                } trace;
76
[3073c04]77        } output;
78};
79
[e6d963c]80static int pcap_init_input(libtrace_t *libtrace) {
[ab4cb04]81        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
[72bfe20]82
[df338b3]83        INPUT.pcap = NULL;
84        DATA(libtrace)->filter = NULL;
[bdde7b8]85        DATA(libtrace)->snaplen = LIBTRACE_PACKET_BUFSIZE;
[df338b3]86        DATA(libtrace)->promisc = 0;
87
[d5879cc]88        return 0;
[df338b3]89}
90
[e6d963c]91static int pcap_start_input(libtrace_t *libtrace) {
[df338b3]92        char errbuf[PCAP_ERRBUF_SIZE];
[6c248a9]93
94        /* if the file is already open */
95        if (INPUT.pcap)
96                return 0; /* success */
97
[df338b3]98        if ((INPUT.pcap = 
99                pcap_open_offline(libtrace->uridata,
100                        errbuf)) == NULL) {
[0ea3526]101                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
[df338b3]102                                errbuf);
103                return -1;
104        }
105        if (DATA(libtrace)->filter) {
[d5879cc]106                pcap_compile(INPUT.pcap, &DATA(libtrace)->filter->filter,
107                                DATA(libtrace)->filter->filterstring, 1, 0);
[df338b3]108                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter) 
109                                == -1) {
[0ea3526]110                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
[df338b3]111                                        pcap_geterr(INPUT.pcap));
112                        return -1;
[4dedc28]113                }
114        }
[df338b3]115        return 0;
116}
117
118static int pcap_config_input(libtrace_t *libtrace,
119                trace_option_t option,
120                void *data)
121{
122        switch(option) {
123                case TRACE_OPTION_FILTER:
124                        DATA(libtrace)->filter=data;
125                        return 0;
126                case TRACE_OPTION_SNAPLEN:
127                        /* Snapping isn't supported directly, so fall thru
128                         * and let libtrace deal with it
129                         */
130                case TRACE_OPTION_PROMISC:
131                        /* can't do promisc on a trace! fall thru */
[cd7eec7]132                case TRACE_META_FREQ:
133                        /* No meta data for this format */
[df338b3]134                default:
[0ea3526]135                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
[df338b3]136                                        "Unknown option %i", option);
137                        return -1;
138        }
139        assert(0);
140}
141
[e4e95499]142static int pcap_init_output(libtrace_out_t *libtrace) {
[ab4cb04]143        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
[1974620]144        OUTPUT.trace.pcap = NULL;
145        OUTPUT.trace.dump = NULL;
[fe76c55]146        return 0;
[3073c04]147}
148
[e4e95499]149static int pcapint_init_output(libtrace_out_t *libtrace) {
150#ifdef HAVE_PCAP_INJECT
151        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
152        OUTPUT.trace.pcap = NULL;
153        OUTPUT.trace.dump = NULL;
154        return 0;
155#else
156#ifdef HAVE_PCAP_SENDPACKET
157        libtrace->format_data = malloc(sizeof(struct pcap_format_data_out_t));
158        OUTPUT.trace.pcap = NULL;
159        OUTPUT.trace.dump = NULL;
160        return 0;
161#else
[91db67b]162        trace_set_err_out(libtrace,TRACE_ERR_UNSUPPORTED,
[e4e95499]163                        "writing not supported by this version of pcap");
164        return -1;
165#endif
166#endif
167}
168
[e6d963c]169static int pcapint_init_input(libtrace_t *libtrace) {
[ab4cb04]170        libtrace->format_data = malloc(sizeof(struct pcap_format_data_t));
[df338b3]171        DATA(libtrace)->filter = NULL;
[b7d2de5]172        DATA(libtrace)->snaplen = LIBTRACE_PACKET_BUFSIZE;
[df338b3]173        DATA(libtrace)->promisc = 0;
[6c248a9]174        return 0; /* success */
[df338b3]175}
176
177static int pcapint_config_input(libtrace_t *libtrace,
178                trace_option_t option,
179                void *data)
180{
181        switch(option) {
182                case TRACE_OPTION_FILTER:
[85a79b0]183                        DATA(libtrace)->filter=(libtrace_filter_t*)data;
[df338b3]184                        return 0;
185                case TRACE_OPTION_SNAPLEN:
186                        DATA(libtrace)->snaplen=*(int*)data;
187                        return 0;
188                case TRACE_OPTION_PROMISC:
189                        DATA(libtrace)->promisc=*(int*)data;
190                        return 0;
[cd7eec7]191                case TRACE_META_FREQ:
192                        /* No meta-data for this format */
[df338b3]193                default:
[0ea3526]194                        trace_set_err(libtrace,TRACE_ERR_UNKNOWN_OPTION,
[df338b3]195                                        "Unknown option %i", option);
196                        return -1;
197        }
198        assert(0);
199}
200
201static int pcapint_start_input(libtrace_t *libtrace) {
202        char errbuf[PCAP_ERRBUF_SIZE];
[72bfe20]203        if ((INPUT.pcap = 
[df338b3]204                        pcap_open_live(libtrace->uridata,
205                        DATA(libtrace)->snaplen,
206                        DATA(libtrace)->promisc,
[4dedc28]207                        1,
208                        errbuf)) == NULL) {
[0ea3526]209                trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",errbuf);
[6c248a9]210                return -1; /* failure */
[8ea5b38]211        }
212        /* Set a filter if one is defined */
213        if (DATA(libtrace)->filter) {
214                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
215                        == -1) {
[0ea3526]216                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
[8ea5b38]217                                        pcap_geterr(INPUT.pcap));
[6c248a9]218                        return -1; /* failure */
[8ea5b38]219                }
[4dedc28]220        }
[9d7d9e9]221#ifdef HAVE_PCAP_SETNONBLOCK
[998bee5]222        pcap_setnonblock(INPUT.pcap,0,errbuf);
[9d7d9e9]223#endif
[6c248a9]224        return 0; /* success */
[4dedc28]225}
226
[747c501]227static int pcap_pause_input(libtrace_t *libtrace)
[6c248a9]228{
229        pcap_close(INPUT.pcap);
230        INPUT.pcap=NULL;
231        return 0; /* success */
232}
233
[747c501]234
[6c248a9]235static int pcap_fin_input(libtrace_t *libtrace) 
236{
[3073c04]237        free(libtrace->format_data);
[6c248a9]238        return 0; /* success */
[3073c04]239}
240
[6c248a9]241static int pcap_fin_output(libtrace_out_t *libtrace) 
242{
[f875681]243        if (OUTPUT.trace.dump) {
244                pcap_dump_flush(OUTPUT.trace.dump);
245                pcap_dump_close(OUTPUT.trace.dump);
246        }
[f0d19d4]247        pcap_close(OUTPUT.trace.pcap);
248        free(libtrace->format_data);
[3073c04]249        return 0;
[4dedc28]250}
251
[e4e95499]252static int pcapint_fin_output(libtrace_out_t *libtrace)
253{
254        pcap_close(OUTPUT.trace.pcap);
255        free(libtrace->format_data);
256        return 0;
257}
258
[ffc8c8d]259
[e6d963c]260static int pcap_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
[62987bb]261        int ret = 0;
[7ac9705]262        int linktype;
263
264        assert(libtrace->format_data);
265        linktype = pcap_datalink(DATA(libtrace)->input.pcap);
[73dd29f]266        packet->type = pcap_linktype_to_rt(linktype);
[62987bb]267
268        packet->buf_control = TRACE_CTRL_PACKET;
269
[77285d9]270        /* If we're using the replacement pcap_next_ex() we need to
271         * make sure we have a buffer to *shudder* memcpy into
272         */
273        if (!packet->buffer) {
274                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
275                if (!packet->buffer) {
276                        trace_set_err(libtrace, errno, 
277                                        "Cannot allocate memory");
278                        return -1;
279                }
280                       
281                packet->header = packet->buffer;
282                packet->payload = (char *)packet->buffer + 
283                                        sizeof(struct pcap_pkthdr);
284        }
285       
[62987bb]286        for(;;) {
287
288                ret=pcap_next_ex(INPUT.pcap, 
289                                (struct pcap_pkthdr **)&packet->header,
290                                (const u_char **)&packet->payload);
291
292                switch(ret) {
293                        case 1: break; /* no error */
294                        case 0: continue; /* timeout expired */
295                        case -1:
296                                trace_set_err(libtrace,TRACE_ERR_BAD_PACKET,
297                                                "%s",pcap_geterr(INPUT.pcap));
298                                return -1; /* Error */
299                        case -2:
300                                return 0; /* EOF */
301                }
302
303                return ((struct pcap_pkthdr*)packet->header)->len
304                        +sizeof(struct pcap_pkthdr);
[4dedc28]305        }
306}
307
[85a79b0]308static int pcap_write_packet(libtrace_out_t *libtrace, 
309                libtrace_packet_t *packet) 
310{
[3073c04]311        struct pcap_pkthdr pcap_pkt_hdr;
312
[d5e1796]313        /* If this packet cannot be converted to a pcap linktype then
314         * pop off the top header until it can be converted
315         */
[73dd29f]316        while (libtrace_to_pcap_linktype(trace_get_link_type(packet))==~0U) {
[d5e1796]317                if (!demote_packet(packet)) {
318                        trace_set_err_out(libtrace, 
319                                TRACE_ERR_NO_CONVERSION,
320                                "pcap does not support this format");
321                        return -1;
322                }
323        }
324
[73dd29f]325
[1974620]326        if (!OUTPUT.trace.pcap) {
[73dd29f]327                int linktype=libtrace_to_pcap_dlt(trace_get_link_type(packet));
328                OUTPUT.trace.pcap = pcap_open_dead(linktype,65536);
[f875681]329                if (!OUTPUT.trace.pcap) {
[73dd29f]330                        trace_set_err_out(libtrace,TRACE_ERR_INIT_FAILED,
331                                        "Failed to open dead trace: %s\n",
[f875681]332                                        pcap_geterr(OUTPUT.trace.pcap));
333                }
[d5879cc]334                OUTPUT.trace.dump = pcap_dump_open(OUTPUT.trace.pcap,
335                                libtrace->uridata);
[f875681]336                if (!OUTPUT.trace.dump) {
337                        char *errmsg = pcap_geterr(OUTPUT.trace.pcap);
338                        trace_set_err_out(libtrace,TRACE_ERR_INIT_FAILED,"Failed to open output file: %s\n",
339                                        errmsg ? errmsg : "Unknown error");
340                        return -1;
341                }
[3073c04]342        }
[e373992]343
344        /* Corrupt packet, or other "non data" packet, so skip it */
345        if (trace_get_link(packet) == NULL) {
346                /* Return "success", but nothing written */
347                return 0;
348        }
349
[85a0d42]350        if (packet->trace->format == &pcap || 
351                        packet->trace->format == &pcapint) {
[ed636fb4]352                pcap_dump((u_char*)OUTPUT.trace.dump,
353                                (struct pcap_pkthdr *)packet->header,
354                                packet->payload);
[3073c04]355        } else {
[7068467]356                /* Leave the manual copy as it is, as it gets around
357                 * some OS's having different structures in pcap_pkt_hdr
358                 */
[41b53c2]359                struct timeval ts = trace_get_timeval(packet);
360                pcap_pkt_hdr.ts.tv_sec = ts.tv_sec;
361                pcap_pkt_hdr.ts.tv_usec = ts.tv_usec;
[3073c04]362                pcap_pkt_hdr.caplen = trace_get_capture_length(packet);
[ed636fb4]363                /* trace_get_wire_length includes FCS, while pcap doesn't */
364                if (trace_get_link_type(packet)==TRACE_TYPE_ETH)
[e373992]365                        if (trace_get_wire_length(packet) >= 4) { 
366                                pcap_pkt_hdr.len = 
367                                        trace_get_wire_length(packet)-4;
368                        }
369                        else {
370                                pcap_pkt_hdr.len = 0;
371                        }
[ed636fb4]372                else
373                        pcap_pkt_hdr.len = trace_get_wire_length(packet);
[3073c04]374
[85a0d42]375                assert(pcap_pkt_hdr.caplen<65536);
376                assert(pcap_pkt_hdr.len<65536);
377
[14d8a63]378                pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, packet->payload);
[3073c04]379        }
380        return 0;
381}
382
[85a79b0]383static int pcapint_write_packet(libtrace_out_t *libtrace,
384                libtrace_packet_t *packet) 
385{
[e4e95499]386        int err;
387
388        if (!OUTPUT.trace.pcap) {
389                OUTPUT.trace.pcap = (pcap_t *)pcap_open_live(
390                        libtrace->uridata,65536,0,0,NULL);
391        }
[e5c2bc4]392#ifdef HAVE_PCAP_INJECT
[e4e95499]393        err=pcap_inject(OUTPUT.trace.pcap,
394                        packet->payload,
395                        trace_get_capture_length(packet));
[7af689a]396        if (err!=(int)trace_get_capture_length(packet))
[e4e95499]397                err=-1;
398#else
[e5c2bc4]399#ifdef HAVE_PCAP_SENDPACKET
[e4e95499]400        err=pcap_sendpacket(OUTPUT.trace.pcap,
401                        packet->payload,
402                        trace_get_capture_length(packet));
[103cc3b]403#else
404    trace_set_err(packet->trace,TRACE_ERR_UNSUPPORTED,"writing is not supported on this platform");
405        return -1;
[e4e95499]406#endif
407#endif
408        return err;
409}
410
[eeab9832]411static libtrace_linktype_t pcap_get_link_type(const libtrace_packet_t *packet) {
[73dd29f]412        /* pcap doesn't store linktype in the framing header so we need
[7ac9705]413         * rt to do it for us
414         */
[73dd29f]415        int linktype = rt_to_pcap_linktype(packet->type);
416        return pcap_linktype_to_libtrace(linktype);
[4dedc28]417}
418
[431548c5]419static libtrace_direction_t pcap_set_direction(libtrace_packet_t *packet,
420                libtrace_direction_t dir) {
[81f9b6e]421        libtrace_sll_header_t *sll;
422        promote_packet(packet);
423        sll=packet->payload;
[cde66c3]424        /* sll->pkttype should be in the endianness of the host that the
425         * trace was taken on.  this is impossible to achieve
426         * so we assume host endianness
427         */
[431548c5]428        if(dir==TRACE_DIR_OUTGOING)
[cde66c3]429                sll->pkttype=TRACE_SLL_OUTGOING;
[81f9b6e]430        else
[cde66c3]431                sll->pkttype=TRACE_SLL_HOST;
432        return dir;
[81f9b6e]433}
434
[431548c5]435static libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
[e5f1431]436        libtrace_direction_t direction  = -1;
[4dedc28]437        switch(pcap_get_link_type(packet)) {
438                case TRACE_TYPE_LINUX_SLL:
439                {
[67a14d4]440                        libtrace_sll_header_t *sll;
[4dedc28]441                        sll = trace_get_link(packet);
442                        if (!sll) {
[0ea3526]443                                trace_set_err(packet->trace,
444                                        TRACE_ERR_BAD_PACKET,
[880aa58]445                                                "Bad or missing packet");
[4dedc28]446                                return -1;
447                        }
448                        /* 0 == LINUX_SLL_HOST */
449                        /* the Waikato Capture point defines "packets
450                         * originating locally" (ie, outbound), with a
451                         * direction of 0, and "packets destined locally"
452                         * (ie, inbound), with a direction of 1.
453                         * This is kind-of-opposite to LINUX_SLL.
454                         * We return consistent values here, however
455                         *
456                         * Note that in recent versions of pcap, you can
457                         * use "inbound" and "outbound" on ppp in linux
458                         */
[cde66c3]459                        if (sll->pkttype == TRACE_SLL_OUTGOING) {
[431548c5]460                                direction = TRACE_DIR_OUTGOING;
[cde66c3]461                        } else {
462                                direction = TRACE_DIR_INCOMING;
[4dedc28]463                        }
464                        break;
465
466                }
467                case TRACE_TYPE_PFLOG:
468                {
[67a14d4]469                        libtrace_pflog_header_t *pflog;
[4dedc28]470                        pflog = trace_get_link(packet);
471                        if (!pflog) {
[0ea3526]472                                trace_set_err(packet->trace,
473                                                TRACE_ERR_BAD_PACKET,
[880aa58]474                                                "Bad or missing packet");
[4dedc28]475                                return -1;
476                        }
477                        /* enum    { PF_IN=0, PF_OUT=1 }; */
478                        if (ntohs(pflog->dir==0)) {
479
[431548c5]480                                direction = TRACE_DIR_INCOMING;
[4dedc28]481                        }
482                        else {
[431548c5]483                                direction = TRACE_DIR_OUTGOING;
[4dedc28]484                        }
485                        break;
486                }
487                default:
488                        break;
489        }       
490        return direction;
491}
492
493
[e6d963c]494static struct timeval pcap_get_timeval(const libtrace_packet_t *packet) {
[14d8a63]495        struct pcap_pkthdr *pcapptr = (struct pcap_pkthdr *)packet->header;
[41b53c2]496        struct timeval ts;
497        ts.tv_sec = pcapptr->ts.tv_sec;
498        ts.tv_usec = pcapptr->ts.tv_usec;
499        return ts;
[4dedc28]500}
501
502
[d3b2234]503static int pcap_get_capture_length(const libtrace_packet_t *packet) {
[4dedc28]504        struct pcap_pkthdr *pcapptr = 0;
[14d8a63]505        pcapptr = (struct pcap_pkthdr *)packet->header;
[d8f02df]506        assert(pcapptr->caplen<=65536);
[ed636fb4]507
[4dedc28]508        return pcapptr->caplen;
509}
510
[d3b2234]511static int pcap_get_wire_length(const libtrace_packet_t *packet) {
[4dedc28]512        struct pcap_pkthdr *pcapptr = 0;
[14d8a63]513        pcapptr = (struct pcap_pkthdr *)packet->header;
[73dd29f]514        if (packet->type==pcap_linktype_to_rt(TRACE_DLT_EN10MB))
[ed636fb4]515                return pcapptr->len+4; /* Include the missing FCS */
[73dd29f]516        else if (packet->type==pcap_linktype_to_rt(TRACE_DLT_IEEE802_11_RADIO)) {
[f0c639b]517                /* If the packet is Radiotap and the flags field indicates
518                 * that the FCS is not included in the 802.11 frame, then
519                 * we need to add 4 to the wire-length to account for it.
520                 */
[73dd29f]521                uint8_t flags;
522                trace_get_wireless_flags(trace_get_link(packet), 
523                                trace_get_link_type(packet), &flags);
[f0c639b]524                if ((flags & TRACE_RADIOTAP_F_FCS) == 0)
525                        return pcapptr->len + 4;
526        }
527        return pcapptr->len;
[4dedc28]528}
529
[85a79b0]530static int pcap_get_framing_length(UNUSED const libtrace_packet_t *packet) {
[7c8eacf]531        return sizeof(struct pcap_pkthdr);
532}
533
[d3b2234]534static size_t pcap_set_capture_length(libtrace_packet_t *packet,size_t size) {
[4dedc28]535        struct pcap_pkthdr *pcapptr = 0;
536        assert(packet);
[d3b2234]537        if (size > trace_get_capture_length(packet)) {
[7068467]538                /* can't make a packet larger */
[d3b2234]539                return trace_get_capture_length(packet);
[4dedc28]540        }
[14d8a63]541        pcapptr = (struct pcap_pkthdr *)packet->header;
[194d49b]542        pcapptr->caplen = size;
[d3b2234]543        return trace_get_capture_length(packet);
[4dedc28]544}
545
[52f8fc2]546static int pcap_get_fd(const libtrace_t *trace) {
[7ac9705]547
548        assert(trace->format_data);
[ab4cb04]549        return pcap_fileno(DATA(trace)->input.pcap);
[72bfe20]550}
551
[33d83d4]552static void pcap_help(void) {
[7d69878]553        printf("pcap format module: $Revision$\n");
[40ba6ad]554        printf("Supported input URIs:\n");
555        printf("\tpcap:/path/to/file\n");
556        printf("\n");
557        printf("\te.g.: pcap:/tmp/trace.pcap\n");
[7d69878]558        printf("\n");
[40ba6ad]559        printf("Supported output URIs:\n");
560        printf("\tnone\n");
[7d69878]561        printf("\n");
[dd22d84]562}
[7d69878]563
[33d83d4]564static void pcapint_help(void) {
[7d69878]565        printf("pcapint format module: $Revision$\n");
[40ba6ad]566        printf("Supported input URIs:\n");
567        printf("\tpcapint:interface\n");
568        printf("\n");
569        printf("\te.g.: pcapint:eth0\n");
[7d69878]570        printf("\n");
[40ba6ad]571        printf("Supported output URIs:\n");
572        printf("\tnone\n");
[7d69878]573        printf("\n");
[dd22d84]574}
[9e2a109]575
576
577static struct libtrace_format_t pcap = {
[4dedc28]578        "pcap",
579        "$Id$",
[6dbc47a]580        TRACE_FORMAT_PCAP,
[7050c10]581        pcap_init_input,                /* init_input */
[ab4cb04]582        pcap_config_input,              /* config_input */
[df338b3]583        pcap_start_input,               /* start_input */
[6c248a9]584        NULL,                           /* pause_input */
[3073c04]585        pcap_init_output,               /* init_output */
[91ebc50]586        NULL,                           /* config_output */
[d5879cc]587        NULL,                           /* start_output */
[7050c10]588        pcap_fin_input,                 /* fin_input */
[3073c04]589        pcap_fin_output,                /* fin_output */
[7050c10]590        pcap_read_packet,               /* read_packet */
[eeab9832]591        NULL,                           /* fin_packet */
[3073c04]592        pcap_write_packet,              /* write_packet */
[7050c10]593        pcap_get_link_type,             /* get_link_type */
594        pcap_get_direction,             /* get_direction */
[81f9b6e]595        pcap_set_direction,             /* set_direction */
[7050c10]596        NULL,                           /* get_erf_timestamp */
597        pcap_get_timeval,               /* get_timeval */
598        NULL,                           /* get_seconds */
[1fbd938]599        NULL,                           /* seek_erf */
600        NULL,                           /* seek_timeval */
601        NULL,                           /* seek_seconds */
[7050c10]602        pcap_get_capture_length,        /* get_capture_length */
603        pcap_get_wire_length,           /* get_wire_length */
[7c8eacf]604        pcap_get_framing_length,        /* get_framing_length */
[dd22d84]605        pcap_set_capture_length,        /* set_capture_length */
[72bfe20]606        NULL,                           /* get_fd */
607        trace_event_trace,              /* trace_event */
[eeab9832]608        pcap_help,                      /* help */
609        NULL                            /* next pointer */
[4dedc28]610};
611
[9e2a109]612static struct libtrace_format_t pcapint = {
[4dedc28]613        "pcapint",
614        "$Id$",
[6dbc47a]615        TRACE_FORMAT_PCAP,
[7050c10]616        pcapint_init_input,             /* init_input */
[df338b3]617        pcapint_config_input,           /* config_input */
618        pcapint_start_input,            /* start_input */
[747c501]619        pcap_pause_input,               /* pause_input */
[e4e95499]620        pcapint_init_output,            /* init_output */
[91ebc50]621        NULL,                           /* config_output */
[37195b4]622        NULL,                           /* start_output */
[7050c10]623        pcap_fin_input,                 /* fin_input */
[e4e95499]624        pcapint_fin_output,             /* fin_output */
[7050c10]625        pcap_read_packet,               /* read_packet */
[eeab9832]626        NULL,                           /* fin_packet */
[e4e95499]627        pcapint_write_packet,           /* write_packet */
[7050c10]628        pcap_get_link_type,             /* get_link_type */
629        pcap_get_direction,             /* get_direction */
[81f9b6e]630        pcap_set_direction,             /* set_direction */
[7050c10]631        NULL,                           /* get_erf_timestamp */
632        pcap_get_timeval,               /* get_timeval */
633        NULL,                           /* get_seconds */
[1fbd938]634        NULL,                           /* seek_erf */
635        NULL,                           /* seek_timeval */
636        NULL,                           /* seek_seconds */
[7050c10]637        pcap_get_capture_length,        /* get_capture_length */
638        pcap_get_wire_length,           /* get_wire_length */
[7c8eacf]639        pcap_get_framing_length,        /* get_framing_length */
[dd22d84]640        pcap_set_capture_length,        /* set_capture_length */
[72bfe20]641        pcap_get_fd,                    /* get_fd */
[187a6d6]642        trace_event_device,             /* trace_event */
[eeab9832]643        pcapint_help,                   /* help */
644        NULL                            /* next pointer */
[4dedc28]645};
646
[33d83d4]647void pcap_constructor(void) {
[7c8eacf]648        register_format(&pcap);
649        register_format(&pcapint);
[4dedc28]650}
[91ebc50]651
652
653#endif
Note: See TracBrowser for help on using the repository browser.