Changeset 9a6bdbc


Ignore:
Timestamp:
01/07/19 10:35:07 (21 months ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
51276bd
Parents:
979ab1a0
git-author:
Jacob Van Walraven <jcv9@…> (12/14/18 09:31:48)
git-committer:
Jacob Van Walraven <jcv9@…> (01/07/19 10:35:07)
Message:

Added can_write functions to each output format, Fixed pcapng_get_header_type incorrectly flipping type bytes

Location:
lib
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dag25.c

    r8c5c550 r9a6bdbc  
    174174 * many times or close a device that we're still using */
    175175struct dag_dev_t *open_dags = NULL;
     176
     177static bool dag_can_write(libtrace_packet_t *packet) {
     178        /* Get the linktype */
     179        libtrace_linktype_t ltype = trace_get_link_type(packet);
     180
     181        if (ltype == TRACE_TYPE_ERF_META
     182                || ltype == TRACE_TYPE_NONDATA) {
     183
     184                return false;
     185        }
     186
     187        return true;
     188}
    176189
    177190/* Returns the amount of padding between the ERF header and the start of the
     
    11861199static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
    11871200{
     1201        /* Check dag can write this type of packet */
     1202        if (!dag_can_write(packet)) {
     1203                return 0;
     1204        }
     1205
    11881206        /* This is heavily borrowed from erf_write_packet(). Yes, CnP
    11891207         * coding sucks, sorry about that.
     
    12001218                return -1;
    12011219        }
    1202 
    1203         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    1204                 return 0;
    12051220
    12061221        pad = dag_get_padding(packet);
  • lib/format_dpdk.c

    r10fd24b r9a6bdbc  
    144144        uint32_t cap_len; /* The size to say the capture is */
    145145};
     146
     147static bool dpdk_can_write(libtrace_packet_t *packet) {
     148        return true;
     149}
    146150
    147151/**
     
    15571561static int dpdk_write_packet(libtrace_out_t *trace,
    15581562                             libtrace_packet_t *packet){
     1563
     1564        /* Check dpdk can write this type of packet */
     1565        if (!dpdk_can_write(packet)) {
     1566                return 0;
     1567        }
     1568
    15591569        struct rte_mbuf* m_buff[1];
    15601570
  • lib/format_erf.c

    rd439067 r9a6bdbc  
    119119} erf_index_t;
    120120
     121static bool erf_can_write(libtrace_packet_t *packet) {
     122        /* Get the linktype */
     123        libtrace_linktype_t ltype = trace_get_link_type(packet);
     124
     125        if (ltype == TRACE_TYPE_PCAPNG_META
     126                || ltype == TRACE_TYPE_NONDATA) {
     127
     128                return false;
     129        }
     130
     131        return true;
     132}
     133
    121134/* Ethernet packets have a 2 byte padding before the packet
    122135 * so that the IP header is aligned on a 32 bit boundary.
     
    670683                libtrace_packet_t *packet)
    671684{
     685
     686        /* Check erf can write this type of packet */
     687        if (!erf_can_write(packet)) {
     688                return 0;
     689        }
     690
    672691        int numbytes = 0;
    673692        dag_record_t *dag_hdr = (dag_record_t *)packet->header;
     
    679698                return -1;
    680699        }
    681 
    682         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    683                 return 0;
    684700
    685701        if (!packet->header) {
  • lib/format_linux_int.c

    rd439067 r9a6bdbc  
    5656#ifdef HAVE_NETPACKET_PACKET_H
    5757
     58static bool linuxnative_can_write(libtrace_packet_t *packet) {
     59        /* Get the linktype */
     60        libtrace_linktype_t ltype = trace_get_link_type(packet);
     61
     62        if (ltype == TRACE_TYPE_NONDATA) {
     63                return false;
     64        }
     65
     66        return true;
     67}
    5868
    5969static int linuxnative_start_input(libtrace_t *libtrace)
     
    336346                libtrace_packet_t *packet)
    337347{
     348        /* Check linuxnative can write this type of packet */
     349        if (!linuxnative_can_write(packet)) {
     350                return 0;
     351        }
     352
    338353        struct sockaddr_ll hdr;
    339354        int ret = 0;
    340 
    341         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    342                 return 0;
    343355
    344356        hdr.sll_family = AF_PACKET;
  • lib/format_linux_ring.c

    rd439067 r9a6bdbc  
    7171static int pagesize = 0;
    7272
     73static bool linuxring_can_write(libtrace_packet_t *packet) {
     74        /* Get the linktype */
     75        libtrace_linktype_t ltype = trace_get_link_type(packet);
     76
     77        if (ltype == TRACE_TYPE_NONDATA) {
     78                return false;
     79        }
     80
     81        return true;
     82}
    7383
    7484/*
     
    709719                                  libtrace_packet_t *packet)
    710720{
     721        /* Check linuxring can write this type of packet */
     722        if (!linuxring_can_write(packet)) {
     723                return 0;
     724        }
     725
    711726        struct tpacket2_hdr *header;
    712727        struct pollfd pollset;
     
    715730        unsigned max_size;
    716731        void * off;
    717 
    718         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    719                 return 0;
    720732
    721733        max_size = FORMAT_DATA_OUT->req.tp_frame_size -
  • lib/format_pcap.c

    rd439067 r9a6bdbc  
    9797        } output;
    9898};
     99
     100static bool pcap_can_write(libtrace_packet_t *packet) {
     101        /* Get the linktype */
     102        libtrace_linktype_t ltype = trace_get_link_type(packet);
     103
     104        if (ltype == TRACE_TYPE_PCAPNG_META
     105                || ltype == TRACE_TYPE_CONTENT_INVALID
     106                || ltype == TRACE_TYPE_UNKNOWN
     107                || ltype == TRACE_TYPE_ERF_META
     108                || ltype == TRACE_TYPE_NONDATA) {
     109
     110                return false;
     111        }
     112
     113        return true;
     114}
    99115
    100116static int pcap_init_input(libtrace_t *libtrace) {
     
    521537{
    522538
     539        /* Check pcap can write this type of packet */
     540        if (!pcap_can_write(packet)) {
     541                return 0;
     542        }
     543
    523544        if (!libtrace) {
    524545                fprintf(stderr, "NULL trace passed into pcap_write_packet()\n");
     
    536557
    537558        link = trace_get_packet_buffer(packet,&linktype,&remaining);
    538 
    539         /* Silently discard RT metadata packets and packets with an
    540          * unknown linktype. */
    541         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    542                 return 0;
    543         }
    544559
    545560        /* We may have to convert this packet into a suitable PCAP packet */
  • lib/format_pcapfile.c

    rd439067 r9a6bdbc  
    6868#define MAGIC2_REV  0x4d3cb2a1
    6969
     70static bool pcapfile_can_write(libtrace_packet_t *packet) {
     71        /* Get the linktype */
     72        libtrace_linktype_t ltype = trace_get_link_type(packet);
     73
     74        if (ltype == TRACE_TYPE_PCAPNG_META
     75                || ltype == TRACE_TYPE_CONTENT_INVALID
     76                || ltype == TRACE_TYPE_UNKNOWN
     77                || ltype == TRACE_TYPE_ERF_META
     78                || ltype == TRACE_TYPE_NONDATA) {
     79
     80                return false;
     81        }
     82
     83        return true;
     84}
     85
    7086static inline int header_is_backwards_magic(pcapfile_header_t *header) {
    7187        return (header->magic_number == MAGIC1_REV || header->magic_number == MAGIC2_REV);
     
    175191        if (!DATA(libtrace))
    176192                return num;
    177        
     193
    178194        /* We can use the PCAP magic number to determine the byte order */
    179195        if (header_is_backwards_magic(&(DATA(libtrace)->header)))
     
    371387                        packet->buffer,
    372388                        sizeof(libtrace_pcapfile_pkt_hdr_t));
     389
    373390        if (err<0) {
    374391                trace_set_err(libtrace,TRACE_ERR_WANDIO_FAILED,"reading packet");
     
    432449                libtrace_packet_t *packet)
    433450{
     451
     452        /* Check pcapfile can write this type of packet */
     453        if (!pcapfile_can_write(packet)) {
     454                return 0;
     455        }
     456
    434457        struct libtrace_pcapfile_pkt_hdr_t hdr;
    435458        struct timeval tv = trace_get_timeval(packet);
     
    441464
    442465        ptr = trace_get_packet_buffer(packet,&linktype,&remaining);
    443        
    444         /* Silently discard RT metadata packets and packets with an
    445          * unknown linktype. */
    446         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    447                 return 0;
    448         }
    449466
    450467        /* If this packet cannot be converted to a pcap linktype then
  • lib/format_pcapng.c

    r979ab1a0 r9a6bdbc  
    198198#define DATAOUT(x) ((struct pcapng_format_data_out_t*)((x)->format_data))
    199199
     200static bool pcapng_can_write(libtrace_packet_t *packet) {
     201        /* Get the linktype */
     202        libtrace_linktype_t ltype = trace_get_link_type(packet);
     203
     204        if (ltype == TRACE_TYPE_CONTENT_INVALID
     205                || ltype == TRACE_TYPE_UNKNOWN
     206                || ltype == TRACE_TYPE_ERF_META
     207                || ltype == TRACE_TYPE_NONDATA) {
     208
     209                return false;
     210        }
     211
     212        return true;
     213}
     214
    200215static pcapng_interface_t *lookup_interface(libtrace_t *libtrace,
    201216                uint32_t intid) {
     
    224239        /* Section blocks, interface blocks, name resolution blocks, stats blocks and
    225240         * Custom blocks are all of type trace_type_pcapng_meta */
    226         if (trace_get_link_type(packet) == TRACE_TYPE_PCAPNG_META) {
    227                 if (DATAOUT(packet->trace)->byteswapped) {
    228                         return byteswap32(*type);
    229                 } else {
    230                         return *type;
    231                 }
    232         /* Only check for enhanced or simple packet blocks */
    233         } else {
    234                 if (DATAOUT(packet->trace)->byteswapped) {
    235                         *type = byteswap32(*type);
    236                 }
    237                 if (*type == 0x00000006 || *type == 0x00000003) {
    238                         return *type;
    239                 }
     241        if (packet->type == TRACE_RT_PCAPNG_META) {
     242                return *type;
     243        }
     244
     245        if (packet->type == 0x00000006 || packet->type == 0x00000003) {
     246                return *type;
    240247        }
    241248        /* not a pcapng header type */
     
    269276
    270277static struct pcapng_timestamp pcapng_get_timestamp(libtrace_packet_t *packet) {
    271         struct timespec ts = trace_get_timespec(packet);
    272         uint64_t time = (((uint64_t) ts.tv_sec) * 1000000LL) + ts.tv_nsec / 1000;
     278        struct timeval tv = trace_get_timeval(packet);
     279        uint64_t time = ((uint64_t)tv.tv_sec * (uint64_t)1000000) + tv.tv_usec;
    273280
    274281        struct pcapng_timestamp timestamp;
     
    555562        }
    556563
    557         libtrace_linktype_t linktype;
    558 
    559         linktype = trace_get_link_type(packet);
    560         /* discard meta packets from other capture types and unknown packets
    561          * could try to convert erf meta packets? */
    562         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN
    563                 || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    564                 return 0;
    565         }
     564        /* Check pcapng can write this type of packet */
     565        if (!pcapng_can_write(packet)) {
     566                return 0;
     567        }
     568
     569        libtrace_linktype_t linktype = trace_get_link_type(packet);
    566570
    567571        /* If the file is not open, open it */
     
    572576                        DATAOUT(libtrace)->flag);
    573577        }
    574         fprintf(stderr, "switch\n");
     578
    575579        /* If the packet is already encapsulated in a pcapng frame just output it */
    576580        switch (pcapng_get_header_type(packet)) {
     
    693697                                DATAOUT(libtrace)->lastdlt = linktype;
    694698                        }
     699
    695700                        break;
    696701                }
     
    711716        epkthdr.caplen = trace_get_capture_length(packet);
    712717
     718        /* trace_get_wirelength includes FCS, while pcapng doesn't */
     719        if (trace_get_link_type(packet)==TRACE_TYPE_ETH) {
     720                if (epkthdr.wlen >= 4) {
     721                        epkthdr.wlen -= 4;
     722                } else {
     723                        epkthdr.wlen = 0;
     724                }
     725        }
    713726        /* capture length should always be less than the wirelength */
    714727        if (epkthdr.caplen > epkthdr.wlen) {
     
    819832        }
    820833
    821         packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
     834        packet->type = TRACE_RT_PCAPNG_META;
    822835        if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
    823836                        packet->type, flags)) {
     
    886899        bodyptr = (char *) packet->buffer + sizeof(pcapng_int_t);
    887900
    888         packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
     901        packet->type = TRACE_RT_PCAPNG_META;
    889902
    890903        if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
     
    951964        }
    952965
    953         packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
     966        packet->type = TRACE_RT_PCAPNG_META;
    954967        if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
    955968                        packet->type, flags)) {
     
    9951008        }
    9961009
    997         packet->type = pcapng_linktype_to_rt(TRACE_RT_PCAPNG_META);
     1010        packet->type = TRACE_RT_PCAPNG_META;
    9981011        if (pcapng_prepare_packet(libtrace, packet, packet->buffer,
    9991012                        packet->type, flags)) {
     
    14141427static libtrace_linktype_t pcapng_get_link_type(const libtrace_packet_t *packet) {
    14151428
    1416         struct pcapng_peeker *hdr = (struct pcapng_peeker *)packet->buffer;
    1417 
    1418         if (hdr->blocktype == PCAPNG_SECTION_TYPE
    1419                 || hdr->blocktype == PCAPNG_INTERFACE_TYPE
    1420                 || hdr->blocktype == PCAPNG_NAME_RESOLUTION_TYPE
    1421                 || hdr->blocktype == PCAPNG_INTERFACE_STATS_TYPE
    1422                 || hdr->blocktype == PCAPNG_CUSTOM_TYPE) {
     1429        if (packet->type == TRACE_RT_PCAPNG_META) {
    14231430                return TRACE_TYPE_PCAPNG_META;
    14241431        }
  • lib/trace.c

    rd439067 r9a6bdbc  
    17181718        linktype = trace_get_link_type(packet);
    17191719
    1720         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META)
     1720        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_ERF_META
     1721                || linktype == TRACE_TYPE_PCAPNG_META)
    17211722                return 1;
    17221723
Note: See TracChangeset for help on using the changeset viewer.