Changeset 9cdbedb


Ignore:
Timestamp:
07/03/17 16:45:23 (3 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
cachetimestamps, develop, dpdk-ndag, etsilive, master, ndag_format, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance
Children:
5732e9b, ea75ec2
Parents:
1105ce0 (diff), 568a341 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'pcapng-reader' into develop

Files:
4 added
29 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    rcaf7841 r568a341  
    7676test/test-plen
    7777test/test-ports
     78test/test-setcaplen
    7879test/test-time
    7980test/test-tracetime-parallel
  • lib/Makefile.am

    r4db5b98 red5b2ce  
    5555                format_rt.c format_helper.c format_helper.h format_pcapfile.c \
    5656                format_duck.c format_tsh.c $(NATIVEFORMATS) $(BPFFORMATS) \
    57                 format_atmhdr.c \
     57                format_atmhdr.c format_pcapng.c \
    5858                libtrace_int.h lt_inttypes.h lt_bswap.h \
    5959                linktypes.c link_wireless.c byteswap.c \
  • lib/format_helper.c

    ree6e802 r633339d  
    323323        va_end(va);
    324324}
     325
     326/** Attempts to determine the direction for a pcap (or pcapng) packet.
     327 *
     328 * @param packet        The packet in question.
     329 * @return A valid libtrace_direction_t describing the direction that the
     330 *         packet was travelling, if direction can be determined. Otherwise
     331 *         returns TRACE_DIR_UNKNOWN.
     332 * @internal
     333 *
     334 * Note that we can determine the direction for only certain types of packets
     335 * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
     336 */
     337libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
     338        libtrace_direction_t direction  = -1;
     339        switch(pcap_linktype_to_libtrace(rt_to_pcap_linktype(packet->type))) {
     340                /* We can only get the direction for PCAP packets that have
     341                 * been encapsulated in Linux SLL or PFLOG */
     342                case TRACE_TYPE_LINUX_SLL:
     343                {
     344                        libtrace_sll_header_t *sll;
     345                        libtrace_linktype_t linktype;
     346
     347                        sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
     348                                        packet,
     349                                        &linktype,
     350                                        NULL);
     351                        if (!sll) {
     352                                trace_set_err(packet->trace,
     353                                        TRACE_ERR_BAD_PACKET,
     354                                                "Bad or missing packet");
     355                                return -1;
     356                        }
     357                        /* 0 == LINUX_SLL_HOST */
     358                        /* the Waikato Capture point defines "packets
     359                         * originating locally" (ie, outbound), with a
     360                         * direction of 0, and "packets destined locally"
     361                         * (ie, inbound), with a direction of 1.
     362                         * This is kind-of-opposite to LINUX_SLL.
     363                         * We return consistent values here, however
     364                         *
     365                         * Note that in recent versions of pcap, you can
     366                         * use "inbound" and "outbound" on ppp in linux
     367                         */
     368                        if (ntohs(sll->pkttype == 0)) {
     369                                direction = TRACE_DIR_INCOMING;
     370                        } else {
     371                                direction = TRACE_DIR_OUTGOING;
     372                        }
     373                        break;
     374
     375                }
     376               case TRACE_TYPE_PFLOG:
     377                {
     378                        libtrace_pflog_header_t *pflog;
     379                        libtrace_linktype_t linktype;
     380
     381                        pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
     382                                        packet,&linktype,NULL);
     383                        if (!pflog) {
     384                                trace_set_err(packet->trace,
     385                                                TRACE_ERR_BAD_PACKET,
     386                                                "Bad or missing packet");
     387                                return -1;
     388                        }
     389                        /* enum    { PF_IN=0, PF_OUT=1 }; */
     390                        if (ntohs(pflog->dir==0)) {
     391
     392                                direction = TRACE_DIR_INCOMING;
     393                        }
     394                        else {
     395                                direction = TRACE_DIR_OUTGOING;
     396                        }
     397                        break;
     398                }
     399                default:
     400                        break;
     401        }       
     402        return direction;
     403}
     404
     405
  • lib/format_helper.h

    ree6e802 r633339d  
    8787                int level,
    8888                int filemode);
     89
     90
     91/** Attempts to determine the direction for a pcap (or pcapng) packet.
     92 *
     93 * @param packet        The packet in question.
     94 * @return A valid libtrace_direction_t describing the direction that the
     95 *         packet was travelling, if direction can be determined. Otherwise
     96 *         returns TRACE_DIR_UNKNOWN.
     97 *
     98 * Note that we can determine the direction for only certain types of packets
     99 * if they are captured using pcap/pcapng, specifically SLL and PFLOG captures.
     100 */
     101libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet);
     102
     103
     104
    89105#endif /* FORMAT_HELPER_H */
  • lib/format_pcap.c

    rd47ca18 r4578626  
    574574                pcap_dump((u_char*)OUTPUT.trace.dump, &pcap_pkt_hdr, packet->payload);
    575575        }
    576         return 0;
     576        return remaining;
    577577}
    578578
     
    640640}
    641641
    642 static libtrace_direction_t pcap_get_direction(const libtrace_packet_t *packet) {
    643         libtrace_direction_t direction  = -1;
    644         switch(pcap_get_link_type(packet)) {
    645                 /* Only packets encapsulated in Linux SLL or PFLOG have any
    646                  * direction information */
    647 
    648                 case TRACE_TYPE_LINUX_SLL:
    649                 {
    650                         libtrace_sll_header_t *sll;
    651                         sll = trace_get_packet_buffer(packet, NULL, NULL);
    652                         /* TODO: should check remaining>=sizeof(*sll) */
    653                         if (!sll) {
    654                                 trace_set_err(packet->trace,
    655                                         TRACE_ERR_BAD_PACKET,
    656                                                 "Bad or missing packet");
    657                                 return -1;
    658                         }
    659                         /* 0 == LINUX_SLL_HOST */
    660                         /* the Waikato Capture point defines "packets
    661                          * originating locally" (ie, outbound), with a
    662                          * direction of 0, and "packets destined locally"
    663                          * (ie, inbound), with a direction of 1.
    664                          * This is kind-of-opposite to LINUX_SLL.
    665                          * We return consistent values here, however
    666                          *
    667                          * Note that in recent versions of pcap, you can
    668                          * use "inbound" and "outbound" on ppp in linux
    669                          */
    670                         if (sll->pkttype == TRACE_SLL_OUTGOING) {
    671                                 direction = TRACE_DIR_OUTGOING;
    672                         } else {
    673                                 direction = TRACE_DIR_INCOMING;
    674                         }
    675                         break;
    676 
    677                 }
    678                 case TRACE_TYPE_PFLOG:
    679                 {
    680                         libtrace_pflog_header_t *pflog;
    681                         pflog = trace_get_packet_buffer(packet, NULL, NULL);
    682                         /* TODO: should check remaining >= sizeof(*pflog) */
    683                         if (!pflog) {
    684                                 trace_set_err(packet->trace,
    685                                                 TRACE_ERR_BAD_PACKET,
    686                                                 "Bad or missing packet");
    687                                 return -1;
    688                         }
    689                         /* enum    { PF_IN=0, PF_OUT=1 }; */
    690                         if (ntohs(pflog->dir==0)) {
    691 
    692                                 direction = TRACE_DIR_INCOMING;
    693                         }
    694                         else {
    695                                 direction = TRACE_DIR_OUTGOING;
    696                         }
    697                         break;
    698                 }
    699                 default:
    700                         break;
    701         }       
    702         return direction;
     642static libtrace_direction_t pcapint_get_direction(const libtrace_packet_t *packet) {
     643        /* This function is defined in format_helper.c */
     644        return pcap_get_direction(packet);
    703645}
    704646
     
    828770        pcap_write_packet,              /* write_packet */
    829771        pcap_get_link_type,             /* get_link_type */
    830         pcap_get_direction,             /* get_direction */
     772        pcapint_get_direction,          /* get_direction */
    831773        pcap_set_direction,             /* set_direction */
    832774        NULL,                           /* get_erf_timestamp */
     
    872814        pcapint_write_packet,           /* write_packet */
    873815        pcap_get_link_type,             /* get_link_type */
    874         pcap_get_direction,             /* get_direction */
     816        pcapint_get_direction,          /* get_direction */
    875817        pcap_set_direction,             /* set_direction */
    876818        NULL,                           /* get_erf_timestamp */
  • lib/format_pcapfile.c

    ree6e802 r633339d  
    541541static libtrace_direction_t pcapfile_get_direction(const libtrace_packet_t *packet)
    542542{
    543         libtrace_direction_t direction  = -1;
    544         switch(pcapfile_get_link_type(packet)) {
    545                 /* We can only get the direction for PCAP packets that have
    546                  * been encapsulated in Linux SLL or PFLOG */
    547                 case TRACE_TYPE_LINUX_SLL:
    548                 {
    549                         libtrace_sll_header_t *sll;
    550                         libtrace_linktype_t linktype;
    551 
    552                         sll = (libtrace_sll_header_t*)trace_get_packet_buffer(
    553                                         packet,
    554                                         &linktype,
    555                                         NULL);
    556                         if (!sll) {
    557                                 trace_set_err(packet->trace,
    558                                         TRACE_ERR_BAD_PACKET,
    559                                                 "Bad or missing packet");
    560                                 return -1;
    561                         }
    562                         /* 0 == LINUX_SLL_HOST */
    563                         /* the Waikato Capture point defines "packets
    564                          * originating locally" (ie, outbound), with a
    565                          * direction of 0, and "packets destined locally"
    566                          * (ie, inbound), with a direction of 1.
    567                          * This is kind-of-opposite to LINUX_SLL.
    568                          * We return consistent values here, however
    569                          *
    570                          * Note that in recent versions of pcap, you can
    571                          * use "inbound" and "outbound" on ppp in linux
    572                          */
    573                         if (ntohs(sll->pkttype == 0)) {
    574                                 direction = TRACE_DIR_INCOMING;
    575                         } else {
    576                                 direction = TRACE_DIR_OUTGOING;
    577                         }
    578                         break;
    579 
    580                 }
    581                 case TRACE_TYPE_PFLOG:
    582                 {
    583                         libtrace_pflog_header_t *pflog;
    584                         libtrace_linktype_t linktype;
    585 
    586                         pflog=(libtrace_pflog_header_t*)trace_get_packet_buffer(
    587                                         packet,&linktype,NULL);
    588                         if (!pflog) {
    589                                 trace_set_err(packet->trace,
    590                                                 TRACE_ERR_BAD_PACKET,
    591                                                 "Bad or missing packet");
    592                                 return -1;
    593                         }
    594                         /* enum    { PF_IN=0, PF_OUT=1 }; */
    595                         if (ntohs(pflog->dir==0)) {
    596 
    597                                 direction = TRACE_DIR_INCOMING;
    598                         }
    599                         else {
    600                                 direction = TRACE_DIR_OUTGOING;
    601                         }
    602                         break;
    603                 }
    604                 default:
    605                         break;
    606         }       
    607         return direction;
     543        /* This function can be found in format_helper.c */
     544        return pcap_get_direction(packet);
    608545}
    609546
  • lib/libtrace.h.in

    r317e903 red5b2ce  
    391391        TRACE_FORMAT_LINUX_RING   =15,  /**< Linux native interface capture PACKET_MMAP */
    392392        TRACE_FORMAT_RAWERF       =16,  /**< Special format for reading uncompressed ERF traces without checking for compression */
    393     TRACE_FORMAT_DPDK     =17, /**< The Intel Data Plane Development Kit format */
     393        TRACE_FORMAT_DPDK     =17, /**< The Intel Data Plane Development Kit format */
     394        TRACE_FORMAT_PCAPNG     =18,    /**< PCAP-NG trace file */
    394395};
    395396
     
    417418        TRACE_RT_METADATA       =18,/**< Packet contains server meta-data */
    418419        TRACE_RT_DUCK_5_0       =19,/**< Dag 5.0 Duck */
     420        TRACE_RT_PCAPNG_META    =20,/**< Metadata for a PCAP NG input source */
    419421
    420422        /** Not actually used - all DATA types begin from this value */
     
    480482
    481483        TRACE_RT_DATA_BPF_END           = 3999,
     484
     485        TRACE_RT_DATA_PCAPNG            = 4000,
     486        TRACE_RT_DATA_PCAPNG_END        = 4499,
    482487        /** Unused value marking the end of the valid range for all RT packet
    483488         * types */
    484         TRACE_RT_LAST                   = 4000
     489        TRACE_RT_LAST                   = 4500
    485490} libtrace_rt_types_t;
    486491
     
    551556        void *srcbucket;
    552557} libtrace_packet_t;
     558
     559#define IS_LIBTRACE_META_PACKET(packet) (packet->type < TRACE_RT_DATA_SIMPLE)
    553560
    554561
  • lib/libtrace_int.h

    r5e3f16c red5b2ce  
    10811081libtrace_rt_types_t pcap_linktype_to_rt(libtrace_dlt_t linktype);
    10821082
     1083/** Converts a PCAP-NG DLT into an RT protocol type.
     1084 *
     1085 * @param linktype      The PCAP DLT to be converted
     1086 * @return The RT type that is equivalent to the provided DLT
     1087 */
     1088libtrace_rt_types_t pcapng_linktype_to_rt(libtrace_dlt_t linktype);
     1089
    10831090/** Converts a libtrace link type into a PCAP linktype.
    10841091 *
     
    12611268/** Constructor for the PCAP File format module */
    12621269void pcapfile_constructor(void);
     1270/** Constructor for the PCAP-NG File format module */
     1271void pcapng_constructor(void);
    12631272/** Constructor for the RT format module */
    12641273void rt_constructor(void);
  • lib/linktypes.c

    r4b64a045 red5b2ce  
    139139}
    140140
     141libtrace_rt_types_t pcapng_linktype_to_rt(libtrace_dlt_t linktype) {
     142
     143        return TRACE_RT_DATA_PCAPNG + pcap_dlt_to_pcap_linktype(linktype);
     144}
     145
    141146libtrace_dlt_t rt_to_pcap_linktype(libtrace_rt_types_t rt_type)
    142147{
    143        
     148
    144149        if (rt_type >= TRACE_RT_DATA_DLT && rt_type < TRACE_RT_DATA_DLT_END) {
    145150                /* RT type is in the pcap range */
    146151                return rt_type - TRACE_RT_DATA_DLT;
    147         } 
     152        }
    148153        else if (rt_type >= TRACE_RT_DATA_BPF && rt_type < TRACE_RT_DATA_BPF_END) {
    149154                return rt_type - TRACE_RT_DATA_BPF;
    150         }
    151        
     155        } else if (rt_type >= TRACE_RT_DATA_PCAPNG && rt_type < TRACE_RT_DATA_PCAPNG_END) {
     156                return rt_type - TRACE_RT_DATA_PCAPNG;
     157        }
     158
    152159        fprintf(stderr, "Error: RT type %u cannot be converted to a pcap DLT\n", rt_type);
    153         assert(rt_type >= TRACE_RT_DATA_DLT && rt_type < TRACE_RT_DATA_BPF_END);
     160        assert(false);
    154161        return 0;       /* satisfy warnings */
    155162}
  • lib/trace.c

    rd47ca18 red5b2ce  
    145145                bpf_constructor();
    146146                pcapfile_constructor();
    147                 rt_constructor();
     147                pcapng_constructor();
     148                rt_constructor();
    148149#ifdef HAVE_DAG
    149150                dag_constructor();
     
    957958                                                libtrace->snaplen);
    958959                        }
     960                        if (!IS_LIBTRACE_META_PACKET(packet)) {
     961                                ++libtrace->accepted_packets;
     962                        }
    959963                        trace_packet_set_order(packet, libtrace->sequence_number);
    960                         ++libtrace->accepted_packets;
    961                         ++libtrace->sequence_number;
     964                        ++libtrace->sequence_number;
    962965                        if (!libtrace_parallel && packet->trace == libtrace)
    963966                                libtrace->last_packet = packet;
     
    10331036                return -1;
    10341037        }
     1038
     1039        /* Don't try to convert meta-packets across formats */
     1040        if (strcmp(libtrace->format->name, packet->trace->format->name) != 0 &&
     1041                        IS_LIBTRACE_META_PACKET(packet)) {
     1042                return 0;
     1043        }
    10351044
    10361045        if (libtrace->format->write_packet) {
  • lib/trace_parallel.c

    rb606855 red5b2ce  
    343343                        (int) t->tid, prev_state, t->state);
    344344
    345         if (trace->perpkt_thread_states[THREAD_FINISHED] == trace->perpkt_thread_count)
     345        if (trace->perpkt_thread_states[THREAD_FINISHED] == trace->perpkt_thread_count) {
     346                /* Make sure we save our final stats in case someone wants
     347                 * them at the end of their program.
     348                 */
     349
     350                trace_get_statistics(trace, NULL);
    346351                libtrace_change_state(trace, STATE_FINISHED, false);
     352        }
    347353
    348354        pthread_cond_broadcast(&trace->perpkt_cond);
     
    473479                                return READ_MESSAGE;
    474480                }
    475                 t->accepted_packets++;
     481                if (!IS_LIBTRACE_META_PACKET((*packet))) {
     482                        t->accepted_packets++;
     483                }
    476484                if (trace->perpkt_cbs->message_packet)
    477485                        *packet = (*trace->perpkt_cbs->message_packet)(trace, t, trace->global_blob, t->user_data, *packet);
     
    608616        /* The offset to the first NULL packet upto offset */
    609617        int empty = 0;
     618        int j;
    610619
    611620        /* Wait until trace_pstart has been completed */
     
    692701                /* Handle error/message cases */
    693702                if (nb_packets > 0) {
    694                         /* Store the first packet */
    695                         if (packets[0]->error > 0) {
    696                                 store_first_packet(trace, packets[0], t);
     703                        /* Store the first non-meta packet */
     704                        for (j = 0; j < nb_packets; j++) {
     705                                if (t->recorded_first)
     706                                        break;
     707                                if (packets[j]->error > 0) {
     708                                        store_first_packet(trace, packets[j], t);
     709                                }
    697710                        }
    698711                        dispatch_packets(trace, t, packets, nb_packets, &empty,
     
    918931                        tick_hit = true;
    919932                }*/
    920         }
    921         // Doing this inside the lock ensures the first packet is always
    922         // recorded first
    923         if (packets[0]->error > 0) {
    924                 store_first_packet(libtrace, packets[0], t);
     933
     934                // Doing this inside the lock ensures the first packet is
     935                // always recorded first
     936                if (!t->recorded_first && packets[0]->error > 0) {
     937                        store_first_packet(libtrace, packets[0], t);
     938                }
    925939        }
    926940        ASSERT_RET(pthread_mutex_unlock(&libtrace->read_packet_lock), == 0);
     
    9941008void store_first_packet(libtrace_t *libtrace, libtrace_packet_t *packet, libtrace_thread_t *t)
    9951009{
    996         if (!t->recorded_first) {
    997                 libtrace_message_t mesg = {0, {.uint64=0}, NULL};
    998                 struct timeval tv;
    999                 libtrace_packet_t * dup;
    1000 
    1001                 /* We mark system time against a copy of the packet */
    1002                 gettimeofday(&tv, NULL);
    1003                 dup = trace_copy_packet(packet);
    1004 
    1005                 ASSERT_RET(pthread_spin_lock(&libtrace->first_packets.lock), == 0);
    1006                 libtrace->first_packets.packets[t->perpkt_num].packet = dup;
    1007                 memcpy(&libtrace->first_packets.packets[t->perpkt_num].tv, &tv, sizeof(tv));
    1008                 libtrace->first_packets.count++;
    1009 
    1010                 /* Now update the first */
    1011                 if (libtrace->first_packets.count == 1) {
    1012                         /* We the first entry hence also the first known packet */
    1013                         libtrace->first_packets.first = t->perpkt_num;
    1014                 } else {
    1015                         /* Check if we are newer than the previous 'first' packet */
    1016                         size_t first = libtrace->first_packets.first;
    1017                         struct timeval cur_ts = trace_get_timeval(dup);
    1018                         struct timeval first_ts = trace_get_timeval(libtrace->first_packets.packets[first].packet);
    1019                         if (timercmp(&cur_ts, &first_ts, <))
    1020                                 libtrace->first_packets.first = t->perpkt_num;
    1021                 }
    1022                 ASSERT_RET(pthread_spin_unlock(&libtrace->first_packets.lock), == 0);
    1023 
    1024                 mesg.code = MESSAGE_FIRST_PACKET;
    1025                 trace_message_reporter(libtrace, &mesg);
    1026                 trace_message_perpkts(libtrace, &mesg);
    1027                 t->recorded_first = true;
    1028         }
     1010
     1011        libtrace_message_t mesg = {0, {.uint64=0}, NULL};
     1012        struct timeval tv;
     1013        libtrace_packet_t * dup;
     1014
     1015        if (t->recorded_first) {
     1016                return;
     1017        }
     1018
     1019        if (IS_LIBTRACE_META_PACKET(packet)) {
     1020                return;
     1021        }
     1022
     1023        /* We mark system time against a copy of the packet */
     1024        gettimeofday(&tv, NULL);
     1025        dup = trace_copy_packet(packet);
     1026
     1027        ASSERT_RET(pthread_spin_lock(&libtrace->first_packets.lock), == 0);
     1028        libtrace->first_packets.packets[t->perpkt_num].packet = dup;
     1029        memcpy(&libtrace->first_packets.packets[t->perpkt_num].tv, &tv, sizeof(tv));
     1030        libtrace->first_packets.count++;
     1031
     1032        /* Now update the first */
     1033        if (libtrace->first_packets.count == 1) {
     1034                /* We the first entry hence also the first known packet */
     1035                libtrace->first_packets.first = t->perpkt_num;
     1036        } else {
     1037                /* Check if we are newer than the previous 'first' packet */
     1038                size_t first = libtrace->first_packets.first;
     1039                struct timeval cur_ts = trace_get_timeval(dup);
     1040                struct timeval first_ts = trace_get_timeval(libtrace->first_packets.packets[first].packet);
     1041                if (timercmp(&cur_ts, &first_ts, <))
     1042                        libtrace->first_packets.first = t->perpkt_num;
     1043        }
     1044        ASSERT_RET(pthread_spin_unlock(&libtrace->first_packets.lock), == 0);
     1045
     1046        mesg.code = MESSAGE_FIRST_PACKET;
     1047        trace_message_reporter(libtrace, &mesg);
     1048        trace_message_perpkts(libtrace, &mesg);
     1049        t->recorded_first = true;
    10291050}
    10301051
     
    12211242                int64_t initial_offset;
    12221243                int stable = trace_get_first_packet(libtrace, NULL, &first_pkt, &sys_tv);
    1223                 assert(first_pkt);
     1244                if (!first_pkt)
     1245                        return 0;
    12241246                pkt_tv = trace_get_timeval(first_pkt);
    12251247                initial_offset = (int64_t)tv_to_usec(sys_tv) - (int64_t)tv_to_usec(&pkt_tv);
  • test/Makefile

    r6c84681 r568a341  
    1919BINS = test-pcap-bpf test-event test-time test-dir test-wireless test-errors \
    2020        test-plen test-autodetect test-ports test-fragment test-live \
    21         test-live-snaplen test-vxlan $(BINS_DATASTRUCT) $(BINS_PARALLEL)
     21        test-live-snaplen test-vxlan test-setcaplen $(BINS_DATASTRUCT) $(BINS_PARALLEL)
    2222
    2323.PHONY: all clean distclean install depend test
  • test/do-tests-parallel.sh

    r01619eb r568a341  
    4545do_test ./test-format-parallel rawerf
    4646
     47echo \* Read pcapng
     48do_test ./test-format-parallel pcapng
     49
    4750echo \* Read testing hasher function
    4851do_test ./test-format-parallel-hasher erf
  • test/do-tests.sh

    r3fc3267 r568a341  
    6565do_test ./test-format rawerf
    6666do_test ./test-decode rawerf
     67
     68echo \* Read pcapng
     69do_test ./test-format pcapng
     70do_test ./test-decode pcapng
    6771
    6872
     
    101105echo \* tsh
    102106do_test ./test-time tsh
     107echo \* pcapng
     108do_test ./test-time pcapng
    103109
    104110echo \* Testing directions
     
    181187rm -f traces/*.out.*
    182188do_test ./test-convert erf pcapfile
     189
     190echo " * pcapng -> pcapfile"
     191rm -f traces/*.out.*
     192do_test ./test-convert pcapng pcapfile
     193
     194echo " * pcapng -> erf"
     195rm -f traces/*.out.*
     196do_test ./test-convert pcapng erf
    183197
    184198echo " * pcap (sll) -> erf    raw IP"
     
    209223do_test ./test-convert legacypos pcapfile
    210224
    211 echo " * duck -> duck"
    212 rm -f traces/*.out.*
    213 do_test ./test-convert duck duck
     225# Don't bother with this anymore -- DUCK qualifies as 'meta' so
     226# doesn't get written at the moment.
     227#echo " * duck -> duck"
     228#rm -f traces/*.out.*
     229#do_test ./test-convert duck duck
    214230
    215231echo " * tsh -> pcapfile"
     
    220236rm -f traces/*.out.*
    221237do_test ./test-convert tsh pcap
     238
     239echo \* Testing packet truncation
     240echo " * pcap "
     241rm -f traces/*.out.*
     242do_test ./test-setcaplen pcap pcapfile
     243
     244echo " * pcapfile "
     245rm -f traces/*.out.*
     246do_test ./test-setcaplen pcapfile pcapfile
     247
     248echo " * erf "
     249rm -f traces/*.out.*
     250do_test ./test-setcaplen erf erf
     251
     252echo " * pcapng "
     253rm -f traces/*.out.*
     254do_test ./test-setcaplen pcapng pcapfile
     255
     256echo " * pcapfilens "
     257rm -f traces/*.out.*
     258do_test ./test-setcaplen pcapfilens pcapfile
     259
     260
    222261
    223262echo " * format autodetection - uncompressed"
  • test/test-convert.c

    r86bec15 r568a341  
    7474        if (!strcmp(type,"pcap"))
    7575                return "pcap:traces/100_packets.pcap";
     76        if (!strcmp(type,"pcapng"))
     77                return "pcapng:traces/100_packets.pcapng";
    7678        if (!strcmp(type,"wtf"))
    7779                return "wtf:traces/wed.wtf";
     
    204206                        break;
    205207                }
    206                 count ++;
    207                 trace_write_packet(outtrace,packet);
     208                if (trace_write_packet(outtrace,packet) > 0)
     209                        count ++;
    208210                iferrout(outtrace);
    209211                if (count>100)
     
    241243        while(trace_read_packet(trace,packet)>0) {
    242244                int err;
     245
     246                if (IS_LIBTRACE_META_PACKET(packet))
     247                        continue;
     248
    243249                ++count;
    244                 if ((err=trace_read_packet(trace2,packet2))<1) {
    245                         printf("premature EOF on destination, %i from %s, %i from %s\n",count,lookup_uri(argv[1]),count-1,lookup_out_uri(argv[2]));
    246                         iferr(trace2);
    247                         error=1;
    248                         break;
    249                 }
     250                do {
     251                        if ((err=trace_read_packet(trace2,packet2))<1) {
     252                                printf("premature EOF on destination, %i from %s, %i from %s\n",count,lookup_uri(argv[1]),count-1,lookup_out_uri(argv[2]));
     253                                iferr(trace2);
     254                                error=1;
     255                                break;
     256                        }
     257                } while (IS_LIBTRACE_META_PACKET(packet2));
     258
    250259                /* The capture length might be snapped down to the wire length */
    251260                if (length_changed(packet, packet2)) {
  • test/test-decode.c

    rbcb2402 r568a341  
    6868        if (!strcmp(type,"pcap"))
    6969                return "pcap:traces/100_packets.pcap";
     70        if (!strcmp(type,"pcapng"))
     71                return "pcap:traces/100_packets.pcapng";
    7072        if (!strcmp(type,"wtf"))
    7173                return "wtf:traces/wed.wtf";
  • test/test-format-parallel.c

    r135e3f6 r568a341  
    7070        if (!strcmp(type,"pcap"))
    7171                return "pcap:traces/100_packets.pcap";
     72        if (!strcmp(type,"pcapng"))
     73                return "pcap:traces/100_packets.pcapng";
    7274        if (!strcmp(type,"wtf"))
    7375                return "wtf:traces/wed.wtf";
  • test/test-format.c

    rbcb2402 r568a341  
    6767        if (!strcmp(type,"pcap"))
    6868                return "pcap:traces/100_packets.pcap";
     69        if (!strcmp(type,"pcapng"))
     70                return "pcap:traces/100_packets.pcapng";
    6971        if (!strcmp(type,"wtf"))
    7072                return "wtf:traces/wed.wtf";
  • test/test-time.c

    r6a38a7e r568a341  
    6060        if (!strcmp(type,"pcap"))
    6161                return "pcap:traces/100_packets.pcap";
     62        if (!strcmp(type,"pcapng"))
     63                return "pcap:traces/100_packets.pcapng";
    6264        if (!strcmp(type,"wtf"))
    6365                return "wtf:traces/wed.wtf";
  • tools/traceanon/traceanon.cc

    r684a21c r8e11beb  
    175175        Anonymiser *anon = (Anonymiser *)tls;
    176176        libtrace_generic_t result;
     177
     178        if (IS_LIBTRACE_META_PACKET(packet))
     179                return packet;
    177180
    178181        ipptr = trace_get_ip(packet);
  • tools/traceends/traceends.cc

    ree6e802 r8e11beb  
    309309        c->src_pbytes += plen;
    310310        c->src_bytes += ip->ip_len;
    311         c->last_active = ts;
     311        if (ts != 0)
     312                c->last_active = ts;
    312313       
    313314        key = ip->ip_dst.s_addr;
     
    324325        c->dst_pbytes += plen;
    325326        c->dst_bytes += ip_len;
    326         c->last_active = ts;
     327        if (ts != 0)
     328                c->last_active = ts;
    327329}
    328330
     
    455457
    456458                while (trace_read_packet(input,packet)>0) {
     459                        if (IS_LIBTRACE_META_PACKET(packet))
     460                                continue;
    457461                        if (per_packet(packet) < 1)
    458462                                done = 1;
  • tools/tracemerge/tracemerge.c

    ree6e802 r8e11beb  
    213213        while(1) {
    214214                uint64_t oldest_ts=0;
     215                uint64_t this_ts = 0;
    215216                int oldest=-1;
    216217                int curr_dir;
     
    234235                                        live[i]=true;
    235236                        }
    236                         if (live[i] &&
    237                                 (oldest==-1 ||
    238                                  oldest_ts>trace_get_erf_timestamp(packet[i]))) {
    239                                 oldest=i;
    240                                 oldest_ts=trace_get_erf_timestamp(packet[i]);
    241                         }
     237                        if (live[i]) {
     238                                this_ts = trace_get_erf_timestamp(packet[i]);
     239                                if (this_ts != 0 && (oldest==-1 ||
     240                                                oldest_ts>this_ts)) {
     241                                        oldest=i;
     242                                        oldest_ts=this_ts;
     243                                }
     244                        }
    242245                }
    243246                /* We have run out of packets! */
  • tools/tracereplay/tracereplay.c

    ree6e802 r8e11beb  
    9696        int i;
    9797
     98        if (IS_LIBTRACE_META_PACKET(packet))
     99                return NULL;
     100
    98101        pkt_buffer = trace_get_packet_buffer(packet,&linktype,&remaining);
    99102        remaining = 0;
     
    307310                new = per_packet(packet);
    308311
     312                if (!new)
     313                        continue;
     314
    309315                if (trace_write_packet(output, new) < 0) {
    310316                        trace_perror_output(output, "Writing packet");
  • tools/tracereport/misc_report.c

    ree6e802 r8e11beb  
    4646{
    4747        double ts = trace_get_seconds(packet);
    48         if (!has_starttime || starttime > ts)
     48        if (ts != 0 && (!has_starttime || starttime > ts))
    4949                starttime = ts;
    50         if (!has_endtime || endtime < ts)
     50        if (ts != 0 && (!has_endtime || endtime < ts))
    5151                endtime = ts;
    5252        has_starttime = has_endtime = true;
  • tools/tracereport/tracereport.c

    ree6e802 r8e11beb  
    9393                        break;
    9494                }
     95                if (IS_LIBTRACE_META_PACKET(packet))
     96                        continue;
     97
    9598                if (reports_required & REPORT_TYPE_MISC)
    9699                        misc_per_packet(packet);
  • tools/tracertstats/tracertstats.c

    r0b4b388 r8e11beb  
    188188        thread_data_t *td = (thread_data_t *)tls;
    189189        int i;
     190
     191        if (IS_LIBTRACE_META_PACKET(packet)) {
     192                return packet;
     193        }
    190194
    191195        key = trace_get_erf_timestamp(packet);
  • tools/tracesplit/tracesplit.c

    ree6e802 r8e11beb  
    190190 */
    191191static int per_packet(libtrace_packet_t **packet) {
     192        if (IS_LIBTRACE_META_PACKET((*packet))) {
     193                return 1;
     194        }
    192195
    193196        if (trace_get_link_type(*packet) == -1) {
     
    210213        if (firsttime==0) {
    211214                time_t now = trace_get_seconds(*packet);
    212                 if (starttime != 0) {
     215                if (now != 0 && starttime != 0) {
    213216                        firsttime=now-((now - starttime)%interval);
    214217                }
    215                 else {
     218                else if (now != 0) {
    216219                        firsttime=now;
    217220                }
  • tools/tracestats/tracestats.c

    ree6e802 r8e11beb  
    155155        int i, wlen;
    156156
     157        if (IS_LIBTRACE_META_PACKET(pkt))
     158                return pkt;
     159
    157160        /* Apply filters to every packet note the result */
    158161        wlen = trace_get_wire_length(pkt);
  • tools/tracetop/tracetop.cc

    ree6e802 r8e11beb  
    261261        flows_t::iterator it;
    262262
     263        if (IS_LIBTRACE_META_PACKET(packet))
     264                return;
     265
    263266        if (trace_get_source_address(packet,(struct sockaddr*)&flowkey.sip)==NULL)
    264267                flowkey.sip.ss_family = AF_UNSPEC;
     
    467470                                if (trace_get_seconds(packet) - last_report >= interval) {
    468471                                        do_report();
    469                                                
    470472                                        last_report=trace_get_seconds(packet);
    471473                                }
Note: See TracChangeset for help on using the changeset viewer.