Changeset d4eed70 for lib/format_erf.c


Ignore:
Timestamp:
01/16/19 15:12:25 (3 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
66ffac4
Parents:
d51e5d0
Message:

Add config option TRACE_OPTION_DISCARD_META

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    ref5ba20 rd4eed70  
    8888        uint64_t drops;
    8989
     90        bool discard_meta;
     91
    9092        /* Config options for the input trace */
    9193        struct {
     
    258260        DATA(libtrace)->drops = 0;
    259261
     262        DATA(libtrace)->discard_meta = 0;
     263
    260264        return 0; /* success */
    261265}
     
    279283                                        "Unsupported option");
    280284                        return -1;
     285                case TRACE_OPTION_DISCARD_META:
     286                        if (*(int *)value > 0) {
     287                                DATA(libtrace)->discard_meta = true;
     288                        } else {
     289                                DATA(libtrace)->discard_meta = false;
     290                        }
     291                        return 0;
    281292                default:
    282293                        /* Unknown option */
     
    538549        uint32_t flags = 0;
    539550        libtrace_rt_types_t linktype;
    540        
     551        int gotpacket = 0;
     552
    541553        if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
    542554                packet->buffer = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    543555                if (!packet->buffer) {
    544                         trace_set_err(libtrace, errno,
    545                                         "Cannot allocate memory");
    546                         return -1;
    547                 }
    548         }
    549 
    550         flags |= TRACE_PREP_OWN_BUFFER;
    551        
    552         if ((numbytes=wandio_read(libtrace->io,
    553                                         packet->buffer,
    554                                         (size_t)dag_record_size)) == -1) {
    555                 trace_set_err(libtrace,errno,"reading ERF file");
    556                 return -1;
    557         }
    558         /* EOF */
    559         if (numbytes == 0) {
    560                 return 0;
    561         }
    562 
    563         if (numbytes < (int)dag_record_size) {
    564                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
    565                 return -1;
    566         }
    567 
    568         rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
    569         buffer2 = (char*)packet->buffer + dag_record_size;
    570         size = rlen - dag_record_size;
    571 
    572         if (size >= LIBTRACE_PACKET_BUFSIZE) {
    573                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     556                        trace_set_err(libtrace, errno, "Cannot allocate memory");
     557                        return -1;
     558                }
     559        }
     560
     561        flags |= TRACE_PREP_OWN_BUFFER;
     562
     563        while (!gotpacket) {
     564
     565                if ((numbytes=wandio_read(libtrace->io, packet->buffer,
     566                        (size_t)dag_record_size)) == -1) {
     567
     568                        trace_set_err(libtrace,errno,"reading ERF file");
     569                        return -1;
     570                }
     571
     572                /* EOF */
     573                if (numbytes == 0) {
     574                        return 0;
     575                }
     576
     577                if (numbytes < (int)dag_record_size) {
     578                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF header");
     579                        return -1;
     580                }
     581
     582                rlen = ntohs(((dag_record_t *)packet->buffer)->rlen);
     583                buffer2 = (char*)packet->buffer + dag_record_size;
     584                size = rlen - dag_record_size;
     585
     586                if (size >= LIBTRACE_PACKET_BUFSIZE) {
     587                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    574588                                "Packet size %u larger than supported by libtrace - packet is probably corrupt",
    575589                                size);
    576                 return -1;
    577         }
    578 
    579         /* Unknown/corrupt */
    580         if ((((dag_record_t *)packet->buffer)->type & 0x7f) > ERF_TYPE_MAX) {
    581                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
     590                        return -1;
     591                }
     592
     593                /* Unknown/corrupt */
     594                if ((((dag_record_t *)packet->buffer)->type & 0x7f) > ERF_TYPE_MAX) {
     595                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
    582596                                "Corrupt or Unknown ERF type");
    583                 return -1;
    584         }
    585        
    586         /* read in the rest of the packet */
    587         if ((numbytes=wandio_read(libtrace->io,
    588                                         buffer2,
    589                                         (size_t)size)) != (int)size) {
    590                 if (numbytes==-1) {
    591                         trace_set_err(libtrace,errno, "read(%s)",
     597                        return -1;
     598                }
     599
     600                /* read in the rest of the packet */
     601                if ((numbytes=wandio_read(libtrace->io, buffer2,
     602                        (size_t)size)) != (int)size) {
     603
     604                        if (numbytes==-1) {
     605                                trace_set_err(libtrace,errno, "read(%s)",
    592606                                        libtrace->uridata);
    593                         return -1;
    594                 }
    595                 trace_set_err(libtrace,EIO,
    596                                 "Truncated packet (wanted %d, got %d)",
    597                                 size, numbytes);
    598                 /* Failed to read the full packet?  must be EOF */
    599                 return -1;
    600         }
    601 
    602         if (numbytes < (int)size) {
    603                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
    604                 return -1;
    605         }
    606 
    607         /* If a provenance packet make sure correct rt linktype is set.
    608          * Only bits 0-6 are used for the type */
    609         if ((((dag_record_t *)packet->buffer)->type & 127) == ERF_META_TYPE) {
    610                 linktype = TRACE_RT_ERF_META;
    611         } else { linktype = TRACE_RT_DATA_ERF; }
    612 
    613         if (erf_prepare_packet(libtrace, packet, packet->buffer,
    614                                 linktype, flags))
    615                 return -1;
    616        
     607                                return -1;
     608                        }
     609
     610                        trace_set_err(libtrace,EIO,
     611                                "Truncated packet (wanted %d, got %d)", size, numbytes);
     612
     613                        /* Failed to read the full packet?  must be EOF */
     614                        return -1;
     615                }
     616
     617                if (numbytes < (int)size) {
     618                        trace_set_err(libtrace, TRACE_ERR_BAD_PACKET, "Incomplete ERF record");
     619                        return -1;
     620                }
     621
     622                /* If a provenance packet make sure correct rt linktype is set.
     623                 * Only bits 0-6 are used for the type */
     624                if ((((dag_record_t *)packet->buffer)->type & 127) == ERF_META_TYPE) {
     625                        linktype = TRACE_RT_ERF_META;
     626                } else { linktype = TRACE_RT_DATA_ERF; }
     627
     628                /* If this is a meta packet and TRACE_OPTION_DISCARD_META is set
     629                 * ignore this packet and get another */
     630                if ((linktype == TRACE_RT_ERF_META && !DATA(libtrace)->discard_meta) ||
     631                        linktype == TRACE_RT_DATA_ERF) {
     632                        gotpacket = 1;
     633
     634                        if (erf_prepare_packet(libtrace, packet, packet->buffer, linktype, flags)) {
     635                                return -1;
     636                        }
     637                }
     638        }
     639
    617640        return rlen;
    618641}
Note: See TracChangeset for help on using the changeset viewer.