Changes in / [d994324:9e429e8]


Ignore:
Files:
2 added
1 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • INSTALL

    r17094b2 r0ae5feb  
    1313Installing libtrace:
    1414
     15./bootstrap.sh (only if you've cloned the source from GitHub)
    1516./configure
    1617make
     
    3637
    3738A. You need to install the development version of the pcap library.
    38 For example, Ubuntu/Debian users will need to install the libpcap0.8-dev package
    39 in addition to the libpcap0.8 package.
     39For example, Ubuntu/Debian users will need to install the libpcap0.8-dev
     40package in addition to the libpcap0.8 package.
     41
    4042
    4143----------------------------------
  • README

    r9ad7a35 ra7c8f4a  
    44Libtrace functions might not function correctly breaking the supplied tools.
    55
    6 libtrace 3.0.20
     6libtrace 3.0.21
    77
    88---------------------------------------------------------------------------
     
    1414---------------------------------------------------------------------------
    1515
     16See INSTALL for instructions on how to install libtrace.
    1617
    1718This directory contains source code for libtrace, a userspace library for
     
    2526Further information about libtrace see
    2627http://research.wand.net.nz/software/libtrace.php
    27 Bugs should be reported in trac at http://www.wand.net.nz/trac/libtrace
     28
     29Bugs should be reported by either emailing contact@wand.net.nz or filing
     30an issue at https://github.com/wanduow/libtrace
    2831
    2932It is licensed under the GNU General Public License (GPL) version 2. Please
     
    3134
    3235A detailed ChangeLog can be found on the libtrace wiki:
    33 https://secure.wand.net.nz/trac/libtrace/wiki/ChangeLog
     36https://github.com/wanduow/libtrace/wiki/ChangeLog
    3437
    3538Documentation, usage instructions and a detailed tutorial can also found
  • configure.in

    r457bf45 r092a09c  
    44# and in the README
    55
    6 AC_INIT([libtrace],[3.0.20],[contact@wand.net.nz],[libtrace])
     6AC_INIT([libtrace],[3.0.21],[contact@wand.net.nz],[libtrace])
    77
    88LIBTRACE_MAJOR=3
    99LIBTRACE_MID=0
    10 LIBTRACE_MINOR=20
     10LIBTRACE_MINOR=21
    1111
    1212# OpenSolaris hides libraries like libncurses in /usr/gnu/lib, which is not
     
    4141        examples/stats/Makefile examples/tutorial/Makefile
    4242        docs/libtrace.doxygen
    43         lib/libtrace.h libwandio/Makefile
     43        lib/libtrace.h libwandio/Makefile libwandio/tools/wandiocat/Makefile
    4444        ])
    4545
     
    386386        AC_SUBST([RTE_SDK])
    387387        # Force dpdk library to be statically linked to allow compiler optimisations
    388         LIBTRACE_LIBS="$LIBTRACE_LIBS -l:libintel_dpdk.a"
     388        LIBTRACE_LIBS="$LIBTRACE_LIBS -Wl,--whole-archive -Wl,-l:libintel_dpdk.a -Wl,--no-whole-archive -Wl,-lm"
    389389                AC_DEFINE(HAVE_DPDK,1,[conditional for building with DPDK live capture support])
    390390                libtrace_dpdk=true
  • lib/Makefile.am

    r2498008 r2498008  
    1818DAGSOURCE=
    1919endif
    20 EXTRA_DIST=format_dag24.c format_dag25.c
     20EXTRA_DIST=format_dag24.c format_dag25.c dpdk_libtrace.mk
    2121
    2222if HAVE_LLVM
  • lib/format_bpf.c

    r10e183f r08f5060  
    422422        packet->payload=(char *)buffer + BPFHDR(packet)->bh_hdrlen;
    423423
    424         /*
    425         if (libtrace->format_data == NULL) {
    426                 if (bpf_init_input(libtrace))
    427                         return -1;
    428         }
    429         */
    430 
    431424        return 0;
    432425}
     
    439432{
    440433        uint32_t flags = 0;
     434        fd_set readfds;
     435        struct timeval tout;
     436        int ret;
    441437
    442438        packet->type = bpf_linktype_to_rt(FORMATIN(libtrace)->linktype);
     439
     440        while (FORMATIN(libtrace)->remaining <= 0) {
     441                tout.tv_sec = 0;
     442                tout.tv_usec = 500000;
     443                FD_ZERO(&readfds);
     444                FD_SET(FORMATIN(libtrace)->fd, &readfds);
     445
     446                ret = select(FORMATIN(libtrace)->fd + 1, &readfds, NULL,
     447                                NULL, &tout);
     448                if (ret < 0 && errno != EINTR) {
     449                        trace_set_err(libtrace, errno, "select");
     450                        return -1;
     451                } else if (ret < 0) {
     452                        continue;
     453                }
     454
     455                if (FD_ISSET(FORMATIN(libtrace)->fd, &readfds)) {
     456                        /* Packets are available, read into buffer */
     457                        ret=read(FORMATIN(libtrace)->fd,
     458                                FORMATIN(libtrace)->buffer,
     459                                FORMATIN(libtrace)->buffersize);
     460
     461                        if (ret == -1) {
     462                                trace_set_err(libtrace,errno,"Failed to read");
     463                                return -1;
     464                        }
     465
     466                        if (ret == 0) {
     467                                /* EOF */
     468                                return 0;
     469                        }
     470
     471                        FORMATIN(libtrace)->remaining=ret;
     472                        FORMATIN(libtrace)->bufptr=
     473                                        FORMATIN(libtrace)->buffer;
     474                        break;
     475                }
     476
     477                /* Timed out -- check if we should halt */
     478                if (libtrace_halt)
     479                        return 0;
     480        }
    443481       
    444         /* Read from the BPF interface into our capture buffer */
    445         if (FORMATIN(libtrace)->remaining<=0) {
    446                 int ret;
    447 
    448                 ret=read(FORMATIN(libtrace)->fd,
    449                         FORMATIN(libtrace)->buffer,
    450                         FORMATIN(libtrace)->buffersize);
    451 
    452                 if (ret == -1) {
    453                         trace_set_err(libtrace,errno,"Failed to read");
    454                         return -1;
    455                 }
    456 
    457                 if (ret == 0) {
    458                         /* EOF */
    459                         return 0;
    460                 }
    461 
    462                 FORMATIN(libtrace)->remaining=ret;
    463                 FORMATIN(libtrace)->bufptr=
    464                                 FORMATIN(libtrace)->buffer;
    465         }
    466 
    467482        /* We do NOT want anything trying to free the memory the packet is
    468483         * stored in */
  • lib/format_dag24.c

    rb13b939 rc70f59f  
    473473                        } else {
    474474                                /* Do not sleep - try to read another packet */
     475                                trace->filtered_packets ++;
    475476                                continue;
    476477                        }
     
    483484                        trace_set_capture_length(packet, trace->snaplen);
    484485                }
    485 
     486                trace->accepted_packets ++;
    486487                return event;
    487488        } while (1);
  • lib/format_dag25.c

    rb13b939 r51d1f64  
    586586
    587587        zero.tv_sec = 0;
    588         zero.tv_usec = 0;
     588        zero.tv_usec = 10000;
    589589        nopoll = zero;
    590590
     
    992992                /* Flags. Can't do this */
    993993                memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
    994                 if (trace_get_direction(packet)!=~0U)
     994                if (trace_get_direction(packet)!=(int)~0U)
    995995                        erfhdr.flags.iface = trace_get_direction(packet);
    996996
     
    10351035        int numbytes = 0;
    10361036        uint32_t flags = 0;
     1037        struct timeval maxwait;
     1038        struct timeval pollwait;
     1039
     1040        pollwait.tv_sec = 0;
     1041        pollwait.tv_usec = 10000;
     1042        maxwait.tv_sec = 0;
     1043        maxwait.tv_usec = 250000;
    10371044
    10381045        /* Check if we're due for a DUCK report */
     
    10571064                packet->buffer = 0;
    10581065        }
     1066       
     1067        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     1068                        FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait,
     1069                        &pollwait) == -1)
     1070        {
     1071                trace_set_err(libtrace, errno, "dag_set_stream_poll");
     1072                return -1;
     1073        }
     1074
    10591075
    10601076        /* Grab a full ERF record */
     
    10631079                if (numbytes < 0)
    10641080                        return numbytes;
    1065                 if (numbytes < dag_record_size)
     1081                if (numbytes < dag_record_size) {
     1082                        if (libtrace_halt)
     1083                                return 0;
    10661084                        /* Block until we see a packet */
    10671085                        continue;
     1086                }
    10681087                erfptr = dag_get_record(libtrace);
    10691088        } while (erfptr == NULL);
     
    10861105 * return a SLEEP event (as we cannot select on the DAG file descriptor).
    10871106 */
    1088 static libtrace_eventobj_t trace_event_dag(libtrace_t *trace,
     1107static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
    10891108                                        libtrace_packet_t *packet) {
    10901109        libtrace_eventobj_t event = {0,0,0.0,0};
     
    10921111        int numbytes;
    10931112        uint32_t flags = 0;
     1113        struct timeval minwait;
     1114       
     1115        minwait.tv_sec = 0;
     1116        minwait.tv_usec = 10000;
     1117       
     1118        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     1119                        FORMAT_DATA->dagstream, 0, &minwait,
     1120                        &minwait) == -1)
     1121        {
     1122                trace_set_err(libtrace, errno, "dag_set_stream_poll");
     1123                event.type = TRACE_EVENT_TERMINATE;
     1124                return event;
     1125        }
    10941126
    10951127        do {
     
    10991131                /* Need to call dag_available so that the top pointer will get
    11001132                 * updated, otherwise we'll never see any data! */
    1101                 numbytes = dag_available(trace);
     1133                numbytes = dag_available(libtrace);
    11021134
    11031135                /* May as well not bother calling dag_get_record if
    11041136                 * dag_available suggests that there's no data */
    11051137                if (numbytes != 0)
    1106                         erfptr = dag_get_record(trace);
     1138                        erfptr = dag_get_record(libtrace);
    11071139                if (erfptr == NULL) {
    11081140                        /* No packet available - sleep for a very short time */
    1109                         event.type = TRACE_EVENT_SLEEP;
    1110                         event.seconds = 0.0001;
     1141                        if (libtrace_halt) {
     1142                                event.type = TRACE_EVENT_TERMINATE;
     1143                        } else {                       
     1144                                event.type = TRACE_EVENT_SLEEP;
     1145                                event.seconds = 0.0001;
     1146                        }
    11111147                        break;
    11121148                }
    1113                 if (dag_prepare_packet(trace, packet, erfptr,
     1149                if (dag_prepare_packet(libtrace, packet, erfptr,
    11141150                                        TRACE_RT_DATA_ERF, flags)) {
    11151151                        event.type = TRACE_EVENT_TERMINATE;
     
    11251161                 * trace_event() so we have to do it ourselves */
    11261162
    1127                 if (trace->filter) {
    1128                         if (trace_apply_filter(trace->filter, packet)) {
    1129                                 event.type = TRACE_EVENT_PACKET;
    1130                         } else {
     1163                if (libtrace->filter) {
     1164                        int filtret = trace_apply_filter(libtrace->filter,
     1165                                        packet);
     1166                        if (filtret == -1) {
     1167                                trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
     1168                                                "Bad BPF Filter");
     1169                                event.type = TRACE_EVENT_TERMINATE;
     1170                                break;
     1171                        }
     1172
     1173                        if (filtret == 0) {
    11311174                                /* This packet isn't useful so we want to
    11321175                                 * immediately see if there is another suitable
     
    11341177                                 * a sleep event in this case, like we used to
    11351178                                 * do! */
     1179                                libtrace->filtered_packets ++;
    11361180                                trace_clear_cache(packet);
    11371181                                continue;
    11381182                        }
     1183                               
     1184                        event.type = TRACE_EVENT_PACKET;
    11391185                } else {
    11401186                        event.type = TRACE_EVENT_PACKET;
    11411187                }
    11421188
    1143                 if (trace->snaplen > 0) {
    1144                         trace_set_capture_length(packet, trace->snaplen);
     1189                if (libtrace->snaplen > 0) {
     1190                        trace_set_capture_length(packet, libtrace->snaplen);
    11451191                }
     1192                libtrace->accepted_packets ++;
    11461193                break;
    11471194        } while (1);
  • lib/format_dpdk.c

    r50ce607 r9f43919  
    6060#include <unistd.h>
    6161#include <endian.h>
     62#include <string.h>
     63
     64/* We can deal with any minor differences by checking the RTE VERSION
     65 * Typically DPDK backports some fixes (typically for building against
     66 * newer kernels) to the older version of DPDK.
     67 *
     68 * These get released with the rX suffix. The following macros where added
     69 * in these new releases.
     70 *
     71 * Below this is a log of version that required changes to the libtrace
     72 * code (that we still attempt to support).
     73 *
     74 * Currently 1.5 to 1.7 is supported.
     75 */
    6276#include <rte_eal.h>
     77#include <rte_version.h>
     78#ifndef RTE_VERSION_NUM
     79#       define RTE_VERSION_NUM(a,b,c,d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
     80#endif
     81#ifndef RTE_VER_PATCH_RELEASE
     82#       define RTE_VER_PATCH_RELEASE 0
     83#endif
     84#ifndef RTE_VERSION
     85#       define RTE_VERSION RTE_VERSION_NUM(RTE_VER_MAJOR,RTE_VER_MINOR, \
     86        RTE_VER_PATCH_LEVEL, RTE_VER_PATCH_RELEASE)
     87#endif
     88
     89/* 1.6.0r2 :
     90 *      rte_eal_pci_set_blacklist() is removed
     91 *      device_list is renamed ot pci_device_list
     92 *
     93 * Replaced by:
     94 *      rte_devargs (we can simply whitelist)
     95 */
     96#if RTE_VERSION <= RTE_VERSION_NUM(1, 6, 0, 1)
     97#       define DPDK_USE_BLACKLIST 1
     98#else
     99#       define DPDK_USE_BLACKLIST 0
     100#endif
     101
     102/*
     103 * 1.7.0 :
     104 *      rte_pmd_init_all is removed
     105 *
     106 * Replaced by:
     107 *      Nothing, no longer needed
     108 */
     109#if RTE_VERSION < RTE_VERSION_NUM(1, 7, 0, 0)
     110#       define DPDK_USE_PMD_INIT 1
     111#else
     112#       define DPDK_USE_PMD_INIT 0
     113#endif
     114
    63115#include <rte_per_lcore.h>
    64116#include <rte_debug.h>
     
    207259    int nb_tx_buf; /* The number of packet buffers in the tx ring */
    208260    struct rte_mempool * pktmbuf_pool; /* Our packet memory pool */
     261#if DPDK_USE_BLACKLIST
    209262    struct rte_pci_addr blacklist[BLACK_LIST_SIZE]; /* Holds our device blacklist */
     263        unsigned int nb_blacklist; /* Number of blacklist items in are valid */
     264#endif
    210265    char mempool_name[MEMPOOL_NAME_LEN]; /* The name of the mempool that we are using */
    211     unsigned int nb_blacklist; /* Number of blacklist items in are valid */
    212266    uint8_t rss_key[40]; // This is the RSS KEY
    213267#if HAS_HW_TIMESTAMPS_82580
     
    262316 * So blacklist all devices except the one that we wish to use so that
    263317 * the others can still be used as standard ethernet ports.
    264  */
    265 static void blacklist_devices(struct dpdk_format_data_t *format_data, struct rte_pci_addr *whitelist)
     318 *
     319 * @return 0 if successful, otherwise -1 on error.
     320 */
     321#if DPDK_USE_BLACKLIST
     322static int blacklist_devices(struct dpdk_format_data_t *format_data, struct rte_pci_addr *whitelist)
    266323{
    267324        struct rte_pci_device *dev = NULL;
     
    287344
    288345        rte_eal_pci_set_blacklist(format_data->blacklist, format_data->nb_blacklist);
    289 }
     346        return 0;
     347}
     348#else /* DPDK_USE_BLACKLIST */
     349#include <rte_devargs.h>
     350static int blacklist_devices(struct dpdk_format_data_t *format_data UNUSED, struct rte_pci_addr *whitelist)
     351{
     352        char pci_str[20] = {0};
     353        snprintf(pci_str, sizeof(pci_str), PCI_PRI_FMT,
     354                 whitelist->domain,
     355                 whitelist->bus,
     356                 whitelist->devid,
     357                 whitelist->function);
     358        if (rte_eal_devargs_add(RTE_DEVTYPE_WHITELISTED_PCI, pci_str) < 0) {
     359                return -1;
     360        }
     361        return 0;
     362}
     363#endif
    290364
    291365/**
     
    441515
    442516
    443 static inline int dpdk_init_enviroment(char * uridata, struct dpdk_format_data_t * format_data,
     517/**
     518 * XXX This is very bad XXX
     519 * But we have to do something to allow getopts nesting
     520 * Luckly normally the format is last so it doesn't matter
     521 * DPDK only supports modern systems so hopefully this
     522 * will continue to work
     523 */
     524struct saved_getopts {
     525        char *optarg;
     526        int optind;
     527        int opterr;
     528        int optopt;
     529};
     530
     531static void save_getopts(struct saved_getopts *opts) {
     532        opts->optarg = optarg;
     533        opts->optind = optind;
     534        opts->opterr = opterr;
     535        opts->optopt = optopt;
     536}
     537
     538static void restore_getopts(struct saved_getopts *opts) {
     539        optarg = opts->optarg;
     540        optind = opts->optind;
     541        opterr = opts->opterr;
     542        optopt = opts->optopt;
     543}
     544
     545static inline int dpdk_init_environment(char * uridata, struct dpdk_format_data_t * format_data,
    444546                                        char * err, int errlen) {
    445547    int ret; /* Returned error codes */
     
    451553    int i;
    452554    struct rte_config *cfg = rte_eal_get_configuration();
     555        struct saved_getopts save_opts;
    453556   
    454557#if DEBUG
     
    457560    rte_set_log_level(RTE_LOG_WARNING);
    458561#endif
    459     /* Using proc-type auto allows this to be either primary or secondary
    460      * Secondary allows two instances of libtrace to be used on different
    461      * ports. However current version of DPDK doesn't support this on the
    462      * same card (My understanding is this should work with two separate
    463      * cards).
     562    /*
     563     * Using unique file prefixes mean separate memory is used, unlinking
     564     * the two processes. However be careful we still cannot access a
     565     * port that already in use.
    464566     *
    465567     * Using unique file prefixes mean separate memory is used, unlinking
     
    518620    //snprintf(cpu_number, sizeof(cpu_number), "%x", 0x1 << (my_cpu - 1));
    519621
    520         /* Give this a name */
     622
     623        /* Give the memory map a unique name */
    521624        snprintf(mem_map, sizeof(mem_map), "libtrace-%d", (int) getpid());
    522625    /* rte_eal_init it makes a call to getopt so we need to reset the
    523626     * global optind variable of getopt otherwise this fails */
     627        save_getopts(&save_opts);
    524628    optind = 1;
    525629    if ((ret = rte_eal_init(argc, argv)) < 0) {
     
    528632        return -1;
    529633    }
    530 
     634        restore_getopts(&save_opts);
    531635    // These are still running but will never do anything with DPDK v1.7 we
    532636    // should remove this XXX in the future
     
    545649    dump_configuration();
    546650#endif
     651
     652#if DPDK_USE_PMD_INIT
    547653    /* This registers all available NICs with Intel DPDK
    548654     * These are not loaded until rte_eal_pci_probe() is called.
     
    553659        return -1;
    554660    }
     661#endif
    555662
    556663    /* Black list all ports besides the one that we want to use */
    557     blacklist_devices(format_data, &use_addr);
     664        if ((ret = blacklist_devices(format_data, &use_addr)) < 0) {
     665                snprintf(err, errlen, "Intel DPDK - Whitelisting PCI device failed,"
     666                         " are you sure the address is correct?: %s", strerror(-ret));
     667                return -1;
     668        }
    558669
    559670    /* This loads DPDK drivers against all ports that are not blacklisted */
     
    595706    FORMAT(libtrace)->promisc = -1;
    596707    FORMAT(libtrace)->pktmbuf_pool = NULL;
     708#if DPDK_USE_BLACKLIST
    597709    FORMAT(libtrace)->nb_blacklist = 0;
     710#endif
    598711    FORMAT(libtrace)->paused = DPDK_NEVER_STARTED;
    599712    FORMAT(libtrace)->mempool_name[0] = 0;
     
    604717#endif
    605718       
    606     if (dpdk_init_enviroment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
     719    if (dpdk_init_environment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
    607720        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "%s", err);
    608721        free(libtrace->format_data);
     
    628741    FORMAT(libtrace)->promisc = -1;
    629742    FORMAT(libtrace)->pktmbuf_pool = NULL;
     743#if DPDK_USE_BLACKLIST
    630744    FORMAT(libtrace)->nb_blacklist = 0;
     745#endif
    631746    FORMAT(libtrace)->paused = DPDK_NEVER_STARTED;
    632747    FORMAT(libtrace)->mempool_name[0] = 0;
     
    637752#endif
    638753
    639     if (dpdk_init_enviroment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
     754    if (dpdk_init_environment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
    640755        trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "%s", err);
    641756        free(libtrace->format_data);
     
    815930
    816931    /* First time started we need to alloc our memory, doing this here
    817      * rather than in enviroment setup because we don't have snaplen then */
     932     * rather than in environment setup because we don't have snaplen then */
    818933    if (format_data->paused == DPDK_NEVER_STARTED) {
    819934        if (format_data->snaplen == 0) {
     
    18071922                if (!trace_apply_filter(trace->filter, packet)) {
    18081923                    /* Failed the filter so we loop for another packet */
     1924                    trace->filtered_packets ++;
    18091925                    continue;
    18101926                }
    18111927            }
     1928            trace->accepted_packets ++;
    18121929        } else {
    18131930            /* We only want to sleep for a very short time - we are non-blocking */
  • lib/format_erf.c

    rb13b939 rc70f59f  
    746746         * we just need to read and return the next packet in the trace */
    747747        if (IN_OPTIONS.real_time) {
    748                 event.size = erf_read_packet(libtrace, packet);
     748                event.size = trace_read_packet(libtrace, packet);
    749749                if (event.size < 1)
    750750                        event.type = TRACE_EVENT_TERMINATE;
  • lib/format_helper.c

    r74ecbc7 r4649fea  
    9898         * solution. */
    9999
    100         do {
     100        do {
    101101                tv.tv_sec = 0;
    102102                tv.tv_usec = 0;
     
    111111
    112112        if (FD_ISSET(event.fd, &rfds_param)) {
    113                 event.size = trace_read_packet(trace,packet);
    114                
     113                event.size = trace_read_packet(trace,packet);
    115114                if (event.size < 1) {
    116115                        /* Covers error and EOF events - terminate rather
  • lib/format_linux.c

    r2498008 r2498008  
    546546         */
    547547        if (filter != NULL) {
    548                 assert(filter->flag == 1);
     548                /* Check if the filter was successfully compiled. If not,
     549                 * it is probably a bad filter and we should return an error
     550                 * before the caller tries to read any packets */
     551                if (filter->flag == 0) {
     552                        return -1;
     553                }
     554               
    549555                if (setsockopt(FORMAT(libtrace->format_data)->fd,
    550556                                        SOL_SOCKET,
     
    902908
    903909                if (pcap_compile(pcap, &f->filter, f->filterstring, 0, 0) == -1) {
    904                         perror("PCAP failed to compile the filterstring");
    905                         return -1;
     910                        /* Filter didn't compile, set flag to 0 so we can
     911                         * detect this when trace_start() is called and
     912                         * produce a useful error
     913                         */
     914                        f->flag = 0;
     915                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     916                                        "Failed to compile BPF filter (%s): %s",
     917                                        f->filterstring, pcap_geterr(pcap));
     918                } else {
     919                        /* Set the "flag" to indicate that the filterstring
     920                         * has been compiled
     921                         */
     922                        f->flag = 1;
    906923                }
    907924
    908925                pcap_close(pcap);
    909926               
    910                 /* Set the "flag" to indicate that the filterstring has been
    911                  * compiled
    912                  */
    913                 f->flag = 1;
    914927        }
    915928       
     
    10721085
    10731086        uint32_t flags = 0;
     1087        fd_set readfds;
     1088        struct timeval tout;
     1089        int ret;
    10741090       
    10751091        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
     
    11181134                        FD_SET(get_thread_table(libtrace)->messages.pipefd[0], &rfds);
    11191135                        int largestfd = fd > get_thread_table(libtrace)->messages.pipefd[0] ? fd : get_thread_table(libtrace)->messages.pipefd[0];
    1120                        
    11211136                        do {
    11221137                                ret = select(largestfd+1, &rfds, NULL, NULL, NULL);
     
    11361151                }
    11371152        } else {
    1138                 hdr->wirelen = recvmsg(fd, &msghdr, MSG_TRUNC);
    1139         }
     1153        /* Use select to allow us to time out occasionally to check if someone
     1154         * has hit Ctrl-C or otherwise wants us to stop reading and return
     1155         * so they can exit their program.
     1156         */
     1157
     1158        while (1) {
     1159                tout.tv_sec = 0;
     1160                tout.tv_usec = 500000;
     1161                FD_ZERO(&readfds);
     1162                FD_SET(FORMAT(libtrace->format_data)->fd, &readfds);
     1163
     1164                ret = select(FORMAT(libtrace->format_data)->fd + 1, &readfds,
     1165                                NULL, NULL, &tout);
     1166                if (ret < 0 && errno != EINTR) {
     1167                        trace_set_err(libtrace, errno, "select");
     1168                        return -1;
     1169                } else if (ret < 0) {
     1170                        continue;
     1171                }
     1172               
     1173                if (FD_ISSET(FORMAT(libtrace->format_data)->fd, &readfds)) {
     1174                        /* There's something available for us to read */
     1175                        break;
     1176                }
     1177
     1178               
     1179                /* If we get here, we timed out -- check if we should halt */
     1180                if (libtrace_halt)
     1181                        return 0;
     1182        }
     1183        hdr->wirelen = recvmsg(FORMAT(libtrace->format_data)->fd, &msghdr, MSG_TRUNC);
     1184        }
     1185
     1186                       
     1187                       
    11401188       
    11411189        if (hdr->wirelen==~0U) {
     
    12881336        assert((((unsigned long) header) & (pagesize - 1)) == 0);
    12891337
    1290         /* TP_STATUS_USER means that we can use the frame.
    1291          * When a slot does not have this flag set, the frame is not
    1292          * ready for consumption.
    1293          */
    1294         while (!(header->tp_status & TP_STATUS_USER)) {
     1338        while (1) {
    12951339                if (message) {
    12961340                        struct pollfd pollset[2];
     
    13181362
    13191363                        /* Wait for more data or a message*/
    1320                         ret = poll(&pollset, 1, -1);
     1364                ret = poll(&pollset, 1, 500);
    13211365                        if (ret < 0) {
    13221366                                if (errno != EINTR)
    13231367                                        trace_set_err(libtrace,errno,"poll()");
    13241368                                return -1;
    1325                         }
     1369                } else if (ret == 0) {
     1370                        /* Poll timed out - check if we should exit */
     1371                        if (libtrace_halt)
     1372                                return 0;
     1373                        continue;
     1374                }
     1375
     1376                /* TP_STATUS_USER means that we can use the frame.
     1377                 * When a slot does not have this flag set, the frame is not
     1378                 * ready for consumption.
     1379                 */
     1380                if (header->tp_status & TP_STATUS_USER)
     1381                        break;
    13261382                }
    13271383        }
     
    13801436        if(header->tp_status & TP_STATUS_USER){
    13811437                /* We have a frame waiting */
    1382                 event.size = linuxring_read_packet(libtrace, packet);
     1438                event.size = trace_read_packet(libtrace, packet);
    13831439                event.type = TRACE_EVENT_PACKET;
    13841440        } else {
  • lib/format_pcap.c

    ra6c77b0 r4649fea  
    295295        }
    296296#endif
     297#ifdef HAVE_PCAP_SETNONBLOCK
     298        pcap_setnonblock(INPUT.pcap,0,errbuf);
     299#endif
    297300        /* Set a filter if one is defined */
    298301        if (DATA(libtrace)->filter) {
    299                 if (DATA(libtrace)->filter->flag == 0) {
     302                struct pcap_pkthdr *pcap_hdr = NULL;
     303                u_char *pcap_payload = NULL;
     304                int pcapret;
     305               
     306                if (DATA(libtrace)->filter->flag == 0) {
    300307                        pcap_compile(INPUT.pcap,
    301308                                        &DATA(libtrace)->filter->filter,
     
    304311                        DATA(libtrace)->filter->flag = 1;
    305312                }
    306                 if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
     313                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
    307314                        == -1) {
    308315                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
     
    310317                        return -1; /* failure */
    311318                }
    312         }
    313 #ifdef HAVE_PCAP_SETNONBLOCK
    314         pcap_setnonblock(INPUT.pcap,0,errbuf);
    315 #endif
     319
     320                /* Consume the first packet in the queue, as this may not
     321                 * have had the filter applied to it.
     322                 *
     323                 * Otherwise we can get problems with the event API, where
     324                 * select tells us that there is a packet available but
     325                 * calling trace_read_packet will block forever because the
     326                 * packet in the queue didn't match the filter so
     327                 * pcap_next_ex returns "timed out".
     328                 *
     329                 * This does mean we may consume a legitimate packet, but
     330                 * that's a pretty small downside compared with trace_event
     331                 * getting stuck in an infinite loop because of pcap
     332                 * wackiness.
     333                 *
     334                 * For some reason, we only need to consume one packet for
     335                 * this to work, so let's hope that holds in the future.
     336                 */
     337                do {
     338                        pcapret = pcap_next_ex(INPUT.pcap, &pcap_hdr,
     339                                (const u_char **)&pcap_payload);
     340                } while (0);
     341
     342                if (pcapret < 0)
     343                        return -1;
     344        }
    316345        return 0; /* success */
    317346}
     
    421450                                if (libtrace_halt)
    422451                                        return 0;
    423                                 continue; /* timeout expired */
     452                                continue; /* timeout expired */
    424453                        case -1:
    425454                                trace_set_err(libtrace,TRACE_ERR_BAD_PACKET,
  • lib/format_pcapfile.c

    rb13b939 rc70f59f  
    713713
    714714        if (IN_OPTIONS.real_time) {
    715                 event.size = pcapfile_read_packet(libtrace, packet);
     715                event.size = trace_read_packet(libtrace, packet);
    716716                if (event.size < 1)
    717717                        event.type = TRACE_EVENT_TERMINATE;
  • lib/format_rt.c

    rb13b939 rc70f59f  
    780780                        if (packet->type == TRACE_RT_END_DATA)
    781781                                event.type = TRACE_EVENT_TERMINATE;
    782                         else
     782                        else {
    783783                                /* Since several RT messages can have zero-byte
    784784                                 * length (once the framing is removed), an
     
    786786                                 * PACKET event */
    787787                                event.type = TRACE_EVENT_PACKET;
     788                                trace->accepted_packets ++;
     789                        }
    788790
    789791                }       
    790792                else {
    791793                        event.type = TRACE_EVENT_PACKET;
     794                        trace->accepted_packets ++;
    792795                }
    793796
     
    795798                        if (!trace_apply_filter(trace->filter, packet)) {
    796799                                trace_clear_cache(packet);
    797                                 continue;
     800                                trace->filtered_packets ++;
     801                                continue;
    798802                        }
    799803                }
  • lib/trace.c

    rd994324 rd994324  
    825825                do {
    826826                        size_t ret;
     827                        int filtret;
    827828                        /* Finalise the packet, freeing any resources the format module
    828829                         * may have allocated it and zeroing all data associated with it.
     
    840841                                 * packet
    841842                                 */
    842                                 if (!trace_apply_filter(libtrace->filter,packet)){
     843                                filtret = trace_apply_filter(libtrace->filter, packet);
     844                                if (filtret == -1) {
     845                                        /* Error compiling filter, probably */
     846                                        return ~0U;
     847                                }
     848                               
     849                                if (filtret == 0) {
    843850                                        ++libtrace->filtered_packets;
    844851                                        continue;
     
    12201227
    12211228        if (packet->trace->format->trace_event) {
     1229                /* Note: incrementing accepted, filtered etc. packet
     1230                 * counters is handled by the format-specific
     1231                 * function so don't increment them here.
     1232                 */
    12221233                event=packet->trace->format->trace_event(trace,packet);
    1223                 if (event.type == TRACE_EVENT_PACKET) {
    1224                         ++trace->accepted_packets;
    1225                 }
    1226         }
     1234                }
    12271235        return event;
    12281236
     
    19481956                return trace->format->get_filtered_packets(trace)+
    19491957                        trace->filtered_packets;
    1950         }
    1951         if (trace->format->get_received_packets
    1952                 && trace->format->get_dropped_packets) {
    1953                 return
    1954                         ((trace_get_received_packets(trace)
    1955                         -trace_get_accepted_packets(trace))
    1956                         -trace_get_dropped_packets(trace))
    1957                         +trace->filtered_packets;
    19581958        }
    19591959        return trace->filtered_packets;
  • libwandio/Makefile.am

    r3b6e0cf rcd8efa6  
     1SUBDIRS = . tools/wandiocat
     2
    13lib_LTLIBRARIES=libwandio.la
    24
     
    3941libwandio_la_LDFLAGS=-version-info 1:1:0 @ADD_LDFLAGS@
    4042
    41 bin_PROGRAMS = wandiocat
    42 wandiocat_SOURCES = wcat.c
    43 wandiocat_CFLAGS = -I"$(top_srcdir)/libwandio"
    44 wandiocat_CXXFLAGS = -I"$(top_srcdir)/libwandio"
    45 wandiocat_LDFLAGS = -L"$(top_srcdir)/libwandio" -lwandio
  • libwandio/ior-peek.c

    rf7bcbfb rce7153d  
    6262        io_t *child;
    6363        char *buffer;
    64         int length; /* Length of buffer */
    65         int offset; /* Offset into buffer */
     64        off_t length; /* Length of buffer */
     65        off_t offset; /* Offset into buffer */
    6666};
    6767
  • test/test-live.c

    r262a093 r25110ee  
    3939#include <signal.h>
    4040#include <unistd.h>
    41 
     41#include <stdint.h>
    4242#include <netinet/in.h>
    4343#include <netinet/in_systm.h>
Note: See TracChangeset for help on using the changeset viewer.