Changeset d4eed70 for lib


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

Add config option TRACE_OPTION_DISCARD_META

Location:
lib
Files:
6 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}
  • lib/format_linux_common.c

    r509ee47 rd4eed70  
    169169                case TRACE_OPTION_CONSTANT_ERF_FRAMING:
    170170                        break;
     171                case TRACE_OPTION_DISCARD_META:
     172                        break;
    171173                /* Avoid default: so that future options will cause a warning
    172174                 * here to remind us to implement it, or flag it as
  • lib/format_pcapfile.c

    ref5ba20 rd4eed70  
    286286                        /* All these are either unsupported or handled
    287287                         * by trace_config */
     288                        break;
     289                case TRACE_OPTION_DISCARD_META:
    288290                        break;
    289291        }
  • lib/format_pcapng.c

    ref5ba20 rd4eed70  
    136136        bool started;
    137137        bool realtime;
     138        bool discard_meta;
    138139
    139140        /* Section data */
     
    655656        DATA(libtrace)->started = false;
    656657        DATA(libtrace)->realtime = false;
     658        DATA(libtrace)->discard_meta = false;
    657659        DATA(libtrace)->byteswapped = true;
    658660        DATA(libtrace)->interfaces = (pcapng_interface_t **)calloc(10, \
     
    715717                case TRACE_OPTION_CONSTANT_ERF_FRAMING:
    716718                        break;
     719                case TRACE_OPTION_DISCARD_META:
     720                        if (*(int *)data > 0) {
     721                                DATA(libtrace)->discard_meta = true;
     722                        } else {
     723                                DATA(libtrace)->discard_meta = false;
     724                        }
     725                        return 0;
    717726        }
    718727
     
    17161725                        /* Section Header */
    17171726                        case PCAPNG_SECTION_TYPE:
    1718                                 err = pcapng_read_section(libtrace, packet, flags);
    1719                                 gotpacket = 1;
     1727                                /* Section header is required to make pcapng valid
     1728                                 * so we cannot exclude when option discard_meta is set */
     1729                                err = pcapng_read_section(libtrace, packet, flags);
     1730                                gotpacket = 1;
     1731
    17201732                                break;
    17211733
    17221734                        /* Interface Header */
    17231735                        case PCAPNG_INTERFACE_TYPE:
     1736                                /* Section interface is required to make pcapng valid
     1737                                 * so we cannot exclude when option discard_meta is set */
    17241738                                err = pcapng_read_interface(libtrace, packet, to_read, flags);
    17251739                                gotpacket = 1;
     
    17391753
    17401754                        case PCAPNG_INTERFACE_STATS_TYPE:
    1741                                 err = pcapng_read_stats(libtrace, packet, to_read, flags);
    1742                                 gotpacket = 1;
     1755                                /* If discard_meta is set ignore this packet type */
     1756                                if (!DATA(libtrace)->discard_meta) {
     1757                                        err = pcapng_read_stats(libtrace, packet, to_read, flags);
     1758                                        gotpacket = 1;
     1759                                }
    17431760                                break;
    17441761
    17451762                        case PCAPNG_NAME_RESOLUTION_TYPE:
    1746                                 err = pcapng_read_nrb(libtrace, packet, to_read, flags);
    1747                                 gotpacket = 1;
     1763                                /* If discard meta is set ignore this packet type */
     1764                                if (!DATA(libtrace)->discard_meta) {
     1765                                        err = pcapng_read_nrb(libtrace, packet, to_read, flags);
     1766                                        gotpacket = 1;
     1767                                }
    17481768                                break;
    17491769
    17501770                        case PCAPNG_CUSTOM_TYPE:
    17511771                        case PCAPNG_CUSTOM_NONCOPY_TYPE:
    1752                                 err = pcapng_read_custom(libtrace, packet, to_read, flags);
    1753                                 gotpacket = 1;
     1772                                /* If discard meta is set ignore this packet type */
     1773                                if (!DATA(libtrace)->discard_meta) {
     1774                                        err = pcapng_read_custom(libtrace, packet, to_read, flags);
     1775                                        gotpacket = 1;
     1776                                }
    17541777                                break;
    17551778
  • lib/libtrace.h.in

    rd51e5d0 rd4eed70  
    14121412         *  trying to calculate it from the packet type. */
    14131413        TRACE_OPTION_CONSTANT_ERF_FRAMING,
     1414
     1415        /** If enabled all meta packet will be discarded */
     1416        TRACE_OPTION_DISCARD_META,
    14141417} trace_option_t;
    14151418
  • lib/trace.c

    re7132d6 rd4eed70  
    685685                        return -1;
    686686
    687 
     687                case TRACE_OPTION_DISCARD_META:
     688                        if (!trace_is_err(libtrace)) {
     689                                trace_set_err(libtrace, TRACE_ERR_OPTION_UNAVAIL,
     690                                        "Libtrace does not support meta packets for this format");
     691                        }
     692                        return -1;
    688693        }
    689694        if (!trace_is_err(libtrace)) {
Note: See TracChangeset for help on using the changeset viewer.