Changeset 97d170d


Ignore:
Timestamp:
01/15/15 13:57:47 (6 years ago)
Author:
Dan Collins <dan@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
d97778c
Parents:
4cc6e74 (diff), 21f3226 (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 'develop' of github.com:wanduow/libtrace into develop

Conflicts:

lib/format_dag25.c

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • Makefile.am

    r60f3c4c ra2ce0a6  
    2222        $(RM) -rf autom4te.cache/
    2323
    24 dist-hook:
    25         if which svnversion > /dev/null; then \
    26                 r=`svnversion -nc . | sed -e 's/^[^:]*://;s/[A-Za-z]//'` ;\
    27                 sed -i "s/SVN_REVISION.*/SVN_REVISION $$r/" $(distdir)/lib/libtrace.h.in; \
    28         fi
    29 
    3024if HAS_DOXYGEN
    3125docs/doxygen/man/man3/*.3: docs
  • lib/format_dag25.c

    rc66a465 r97d170d  
    161161         * structures. Most of the stuff above doesn't get used in parallel mode. */
    162162        struct dag_per_thread_t *per_thread;
     163
     164        uint8_t seeninterface[4];
    163165};
    164166
     
    241243        FORMAT_DATA->bottom = NULL;
    242244        FORMAT_DATA->top = NULL;
     245        memset(FORMAT_DATA->seeninterface, 0, sizeof(FORMAT_DATA->seeninterface));
    243246}
    244247
     
    290293        dag_close(dev->fd);
    291294        if (dev->dev_name)
    292         free(dev->dev_name);
     295                free(dev->dev_name);
    293296        free(dev);
    294297}
     
    575578
    576579        if (dag_attach_stream(FORMAT_DATA_OUT->device->fd,
    577                         FORMAT_DATA_OUT->dagstream, 0, 1048576) < 0) {
     580                        FORMAT_DATA_OUT->dagstream, 0, 4 * 1024 * 1024) < 0) {
    578581                trace_set_err_out(libtrace, errno, "Cannot attach DAG stream");
    579582                return -1;
     
    599602static int dag_start_input(libtrace_t *libtrace) {
    600603        struct timeval zero, nopoll;
    601         uint8_t *top, *bottom;
    602         uint8_t diff = 0;
     604        uint8_t *top, *bottom, *starttop;
     605        uint64_t diff = 0;
    603606        top = bottom = NULL;
    604607
     
    626629                                &nopoll);
    627630
     631        starttop = dag_advance_stream(FORMAT_DATA->device->fd,
     632                                        FORMAT_DATA->dagstream,
     633                                        &bottom);
     634
    628635        /* Should probably flush the memory hole now */
    629         do {
     636        while (starttop - bottom > 0) {
     637                bottom += (starttop - bottom);
    630638                top = dag_advance_stream(FORMAT_DATA->device->fd,
    631639                                        FORMAT_DATA->dagstream,
    632640                                        &bottom);
    633                 assert(top && bottom);
    634                 diff = top - bottom;
    635                 bottom -= diff;
    636         } while (diff != 0);
    637         FORMAT_DATA->top = NULL;
    638         FORMAT_DATA->bottom = NULL;
     641        }
     642        FORMAT_DATA->top = top;
     643        FORMAT_DATA->bottom = bottom;
    639644        FORMAT_DATA->processed = 0;
    640645        FORMAT_DATA->drops = 0;
     
    867872                        PERPKT_DATA(t)->drops += ntohs(erfptr->lctr);
    868873                } else {
    869                         printf("DROP!\n");
    870                         DATA(libtrace)->drops += ntohs(erfptr->lctr);
     874                        if (FORMAT_DATA->seeninterface[erfptr->flags.iface] == 0) {
     875                                FORMAT_DATA->seeninterface[erfptr->flags.iface] = 1;
     876                        } else {
     877                                FORMAT_DATA->drops += ntohs(erfptr->lctr);
     878                        }
    871879                }
    872880        }
  • lib/format_erf.c

    r9e429e8 r97d170d  
    480480                                        packet->buffer,
    481481                                        (size_t)dag_record_size)) == -1) {
    482                 trace_set_err(libtrace,errno,"read(%s)",
    483                                 libtrace->uridata);
     482                trace_set_err(libtrace,errno,"reading ERF file");
    484483                return -1;
    485484        }
     
    488487                return 0;
    489488        }
     489
     490        if (numbytes < (int)dag_record_size) {
     491                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
     492                return -1;
     493        }
    490494
    491495        rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
     
    522526                return -1;
    523527        }
     528
     529        if (numbytes < (int)size) {
     530                trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
     531                return -1;
     532        }
    524533       
    525534        if (erf_prepare_packet(libtrace, packet, packet->buffer,
  • lib/format_pcapfile.c

    r9e429e8 r97d170d  
    210210               
    211211                if (err<1) {
    212                         if (err == 0) {
    213                                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
    214                                                 "Reading pcap file header\n");
    215                         }
     212                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     213                                "Error while reading pcap file header\n");
    216214                        return -1;
    217215                }
    218                
     216       
     217                if (err != (int)sizeof(DATA(libtrace)->header)) {
     218                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     219                                "Incomplete pcap file header");
     220                        return -1;
     221                }
     222               
    219223                if (!header_is_magic(&(DATA(libtrace)->header))) {
    220224                        trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,
     
    359363                        packet->buffer,
    360364                        sizeof(libtrace_pcapfile_pkt_hdr_t));
    361 
    362365        if (err<0) {
    363366                trace_set_err(libtrace,errno,"reading packet");
     
    368371                return 0;
    369372        }
     373
     374        if (err < (int)sizeof(libtrace_pcapfile_pkt_hdr_t)) {
     375                trace_set_err(libtrace, errno, "Incomplete pcap packet header");
     376                return -1;
     377        }
    370378
    371379        bytes_to_read = swapl(libtrace,((libtrace_pcapfile_pkt_hdr_t*)packet->buffer)->caplen);
     
    391399                        );
    392400
    393        
    394401        if (err<0) {
    395402                trace_set_err(libtrace,errno,"reading packet");
     
    399406                return 0;
    400407        }
     408
     409        if (err < (int)bytes_to_read) {
     410                trace_set_err(libtrace, errno, "Incomplete pcap packet body");
     411                return -1;
     412        }
    401413
    402414        if (pcapfile_prepare_packet(libtrace, packet, packet->buffer,
  • lib/format_tsh.c

    rb13b939 r97d170d  
    147147                return 0;
    148148        }
     149
     150        if (numbytes < (int)sizeof(tsh_pkt_header_t)) {
     151                trace_set_err(libtrace, errno, "Incomplete TSH header");
     152                return -1;
     153        }
    149154
    150155        buffer2 = (char*)buffer2 + numbytes;
  • lib/libtrace.h.in

    rd994324 r97d170d  
    109109            ((@LIBTRACE_MAJOR@<<16)|(@LIBTRACE_MID@<<8)|(@LIBTRACE_MINOR@))
    110110
    111 /** Replaced with the current SVN revision number when 'make dist' is invoked
    112  *  to create a distributable tarball */
    113 #define LIBTRACE_SVN_REVISION 0
     111/** This used to be replaced with the current SVN revision number when
     112 * 'make dist' was invoked to create a distributable tarball. We don't use
     113 * SVN anymore and there probably isn't any need to know the exact revision
     114 * number either these days. */
     115#define LIBTRACE_SVN_REVISION LIBTRACE_API_VERSION
    114116
    115117/** DAG driver version installed on the current system */
  • libwandio/ior-zlib.c

    r60f3c4c r525d09d  
    5656        int outoffset;
    5757        enum err_t err;
     58        size_t sincelastend;
    5859};
    5960
     
    8384        DATA(io)->strm.opaque = NULL;
    8485        DATA(io)->err = ERR_OK;
     86        DATA(io)->sincelastend = 1;
    8587
    8688        inflateInit2(&DATA(io)->strm, 15 | 32);
     
    108110                                sizeof(DATA(io)->inbuff));
    109111                        if (bytes_read == 0) {
    110                                 /* EOF */
     112                                /* If we get EOF immediately after a
     113                                 * Z_STREAM_END, then we assume we've reached
     114                                 * the end of the file. If there was data
     115                                 * between the Z_STREAM_END and the EOF, the
     116                                 * file has more likely been truncated.
     117                                 */
     118                                if (DATA(io)->sincelastend > 0) {
     119                                        fprintf(stderr, "Unexpected EOF while reading compressed file -- file is probably incomplete\n");
     120                                        errno = EIO;
     121                                        DATA(io)->err = ERR_ERROR;
     122                                        return -1;
     123                                }
     124
     125                                /* EOF */
    111126                                if (DATA(io)->strm.avail_out == (uint32_t)len) {
    112                                         DATA(io)->err = ERR_EOF;
     127                                        DATA(io)->err = ERR_EOF;
    113128                                        return 0;
    114129                                }
     
    128143                        DATA(io)->strm.next_in = DATA(io)->inbuff;
    129144                        DATA(io)->strm.avail_in = bytes_read;
     145                        DATA(io)->sincelastend += bytes_read;
    130146                }
    131147                /* Decompress some data into the output buffer */
     
    144160                                inflateInit2(&DATA(io)->strm, 15 | 32);
    145161                                DATA(io)->err = ERR_OK;
     162                                DATA(io)->sincelastend = 0;
    146163                                break;
    147164                        default:
  • tools/tracestats/tracestats.c

    rc0ccccd r3c54095  
    157157
    158158        if (trace_is_err(trace))
    159                 trace_perror(trace,"%s",uri);
     159                trace_perror(trace,"Processing trace");
    160160
    161161        trace_destroy(trace);
Note: See TracChangeset for help on using the changeset viewer.