Changeset 4e5a51f for lib


Ignore:
Timestamp:
02/07/19 14:07:07 (2 years ago)
Author:
Jacob Van Walraven <jcv9@…>
Branches:
develop
Children:
5cdb37d
Parents:
58c226e
git-author:
Jacob Van Walraven <jcv9@…> (02/07/19 14:00:51)
git-committer:
Jacob Van Walraven <jcv9@…> (02/07/19 14:07:07)
Message:

Structs mapped directly to a packet/file are now packed.
Replaced hardcoded value 27 with ERF_META_TYPE.
PCAPNG meta packets are still processed when DISCARD_META config is set in order to update the trace state, however the meta callback will not be called.
Removed INET_ADDRSTRLEN definitions and used ones provided by the standard headers.
Replaced %u, %lu in libpacketdump linktypes 21 and 23 with PRIu8, PRIu32 etc.

Location:
lib
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • lib/dagformat.h

    ref5ba20 r4e5a51f  
    107107        uint16_t type;
    108108        uint16_t len;
    109 } dag_sec_t;
     109} PACKED dag_sec_t;
    110110
    111111struct dag_opthdr {
    112112        uint16_t optcode;
    113113        uint16_t optlen;
    114 };
     114} PACKED;
    115115
    116116#ifdef WIN32
  • lib/format_erf.c

    r6f6fcbb r4e5a51f  
    10751075}
    10761076
    1077 /* An ERF provenance packet can contain multiple sections of the same type per packet,
    1078  * Need to think of a way to handle this currently the first found is returned*/
     1077/* An ERF provenance packet can contain multiple sections of the same type per packet */
    10791078void *erf_get_meta_section(libtrace_packet_t *packet, uint32_t section) {
    10801079
     
    10961095
    10971096        /* ensure this packet is a meta packet */
    1098         if ((hdr->type & 127) != 27) { return NULL; }
     1097        if ((hdr->type & 127) != ERF_META_TYPE) { return NULL; }
    10991098        /* set remaining to size of packet minus header length */
    11001099        remaining = ntohs(hdr->rlen) - 24;
  • lib/format_pcapng.c

    r0cc91ee r4e5a51f  
    471471}
    472472
     473static void pcapng_create_output_sectionheader_packet(libtrace_out_t *libtrace) {
     474        /* Create section block */
     475        pcapng_sec_t sechdr;
     476        sechdr.blocktype = pcapng_swap32(libtrace, PCAPNG_SECTION_TYPE);
     477        sechdr.blocklen = pcapng_swap32(libtrace, 28);
     478        sechdr.ordering = pcapng_swap32(libtrace, 0x1A2B3C4D);
     479        sechdr.majorversion = pcapng_swap16(libtrace, 1);
     480        sechdr.minorversion = 0;
     481        sechdr.sectionlen = 0xFFFFFFFFFFFFFFFF;
     482
     483        wandio_wwrite(DATAOUT(libtrace)->file, &sechdr, sizeof(sechdr));
     484        wandio_wwrite(DATAOUT(libtrace)->file, &sechdr.blocklen, sizeof(sechdr.blocklen));
     485
     486        DATAOUT(libtrace)->sechdr_count += 1;
     487}
     488
     489static void pcapng_create_output_interface_packet(libtrace_out_t *libtrace, libtrace_linktype_t linktype) {
     490        /* Create interface block*/
     491        pcapng_int_t inthdr;
     492        inthdr.blocktype = pcapng_swap32(libtrace, PCAPNG_INTERFACE_TYPE);
     493        inthdr.blocklen = pcapng_swap32(libtrace, 20);
     494        inthdr.linktype = pcapng_swap16(libtrace, libtrace_to_pcap_dlt(linktype));
     495        inthdr.reserved = 0;
     496        inthdr.snaplen = 0;
     497
     498        wandio_wwrite(DATAOUT(libtrace)->file, &inthdr, sizeof(inthdr));
     499        wandio_wwrite(DATAOUT(libtrace)->file, &inthdr.blocklen, sizeof(inthdr.blocklen));
     500
     501        /* increment the interface counter */
     502        DATAOUT(libtrace)->nextintid += 1;
     503        /* update the last linktype */
     504        DATAOUT(libtrace)->lastdlt = linktype;
     505}
     506
    473507static int pcapng_probe_magic(io_t *io) {
    474508
     
    829863                }
    830864                case PCAPNG_SIMPLE_PACKET_TYPE: {
     865                        /* If no section header or interface packets have been received create and
     866                         * output them. This can occur when discard meta is enabled and the input
     867                         * format is also pcapng */
     868                        if (DATAOUT(libtrace)->sechdr_count == 0) {
     869                                pcapng_create_output_sectionheader_packet(libtrace);
     870                        }
    831871                        if (DATAOUT(libtrace)->nextintid == 0) {
    832                                 trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    833                                         "Cannot output simple packet before a interface "
    834                                         "block has been output in pcapng_write_packet()\n");
    835                                 return -1;
     872                                pcapng_create_output_interface_packet(libtrace, linktype);
    836873                        }
    837874                        return pcapng_output_simple_packet(libtrace, packet);
     
    841878                }
    842879                case PCAPNG_INTERFACE_STATS_TYPE: {
    843                         if (DATAOUT(libtrace)->nextintid == 0) {
    844                                 trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    845                                         "Cannot output a interface statistics block before a "
    846                                         "interface block has been output in pcapng_write_packet()\n");
    847                                 return -1;
    848                         }
     880                        /* If no section header or interface packets have been received create and
     881                         * output them. This can occur when discard meta is enabled and the input
     882                         * format is also pcapng */
     883                        if (DATAOUT(libtrace)->sechdr_count == 0) {
     884                                pcapng_create_output_sectionheader_packet(libtrace);
     885                        }
     886                        if (DATAOUT(libtrace)->nextintid == 0) {
     887                                pcapng_create_output_interface_packet(libtrace, linktype);
     888                        }
    849889                        return pcapng_output_interfacestats_packet(libtrace, packet);
    850890                }
    851891                case PCAPNG_ENHANCED_PACKET_TYPE: {
    852                         if (DATAOUT(libtrace)->nextintid == 0) {
    853                                 trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
    854                                         "Cannot output enhanced packet before a interface "
    855                                         "block has been output in pcapng_write_packet()\n");
    856                                 return -1;
    857                         }
     892                        /* If no section header or interface packets have been received create and
     893                         * output them. This can occur when discard meta is enabled and the input
     894                         * format is also pcapng */
     895                        if (DATAOUT(libtrace)->sechdr_count == 0) {
     896                                pcapng_create_output_sectionheader_packet(libtrace);
     897                        }
     898                        if (DATAOUT(libtrace)->nextintid == 0) {
     899                                pcapng_create_output_interface_packet(libtrace, linktype);
     900                        }
    858901                        return pcapng_output_enhanced_packet(libtrace, packet);
    859902                }
     
    870913                default: {
    871914
    872                         /* create section header if not already */
     915                        /* create and output section header if none have occured yet */
    873916                        if (DATAOUT(libtrace)->sechdr_count == 0) {
    874                                 /* Create section block */
    875                                 pcapng_sec_t sechdr;
    876                                 sechdr.blocktype = pcapng_swap32(libtrace, PCAPNG_SECTION_TYPE);
    877                                 sechdr.blocklen = pcapng_swap32(libtrace, 28);
    878                                 sechdr.ordering = pcapng_swap32(libtrace, 0x1A2B3C4D);
    879                                 sechdr.majorversion = pcapng_swap16(libtrace, 1);
    880                                 sechdr.minorversion = 0;
    881                                 sechdr.sectionlen = 0xFFFFFFFFFFFFFFFF;
    882 
    883                                 wandio_wwrite(DATAOUT(libtrace)->file, &sechdr, sizeof(sechdr));
    884                                 wandio_wwrite(DATAOUT(libtrace)->file, &sechdr.blocklen, sizeof(sechdr.blocklen));
    885 
    886                                 DATAOUT(libtrace)->sechdr_count += 1;
     917                                pcapng_create_output_sectionheader_packet(libtrace);
    887918                        }
    888919
    889                         /* create interface header if not already or if the linktype has changed */
     920                        /* create and output interface header if not already or if the
     921                         * linktype has changed */
    890922                        if (DATAOUT(libtrace)->nextintid == 0
    891923                                || DATAOUT(libtrace)->lastdlt != linktype) {
    892                                 /* Create interface block*/
    893                                 pcapng_int_t inthdr;
    894                                 inthdr.blocktype = pcapng_swap32(libtrace, PCAPNG_INTERFACE_TYPE);
    895                                 inthdr.blocklen = pcapng_swap32(libtrace, 20);
    896                                 inthdr.linktype = pcapng_swap16(libtrace, libtrace_to_pcap_dlt(linktype));
    897                                 inthdr.reserved = 0;
    898                                 inthdr.snaplen = 0;
    899 
    900                                 wandio_wwrite(DATAOUT(libtrace)->file, &inthdr, sizeof(inthdr));
    901                                 wandio_wwrite(DATAOUT(libtrace)->file, &inthdr.blocklen, sizeof(inthdr.blocklen));
    902 
    903                                 /* increment the interface counter */
    904                                 DATAOUT(libtrace)->nextintid += 1;
    905                                 /* update the last linktype */
    906                                 DATAOUT(libtrace)->lastdlt = linktype;
     924
     925                                pcapng_create_output_interface_packet(libtrace, linktype);
    907926                        }
    908927
     
    15811600                        /* Section Header */
    15821601                        case PCAPNG_SECTION_TYPE:
    1583                                 /* Section header is required to make pcapng valid
    1584                                  * so we cannot exclude when option discard_meta is set */
     1602                                /* Section header packets are required for PCAPNG so even if discard_meta
     1603                                 * option is set it still needs to be processed. Not setting gotpacket will
     1604                                 * prevent triggering the meta callback */
    15851605                                err = pcapng_read_section(libtrace, packet, flags);
    1586                                 gotpacket = 1;
     1606                                if (!DATA(libtrace)->discard_meta) {
     1607                                        gotpacket = 1;
     1608                                }
    15871609
    15881610                                break;
     
    15901612                        /* Interface Header */
    15911613                        case PCAPNG_INTERFACE_TYPE:
    1592                                 /* Section interface is required to make pcapng valid
    1593                                  * so we cannot exclude when option discard_meta is set */
     1614                                /* Same applies here for Interface packets */
    15941615                                err = pcapng_read_interface(libtrace, packet, to_read, flags);
    1595                                 gotpacket = 1;
     1616                                if (!DATA(libtrace)->discard_meta) {
     1617                                        gotpacket = 1;
     1618                                }
    15961619                                break;
    15971620
  • lib/format_pcapng.h

    r0cc91ee r4e5a51f  
    109109        uint16_t minorversion;
    110110        uint64_t sectionlen;
    111 } pcapng_sec_t;
     111} PACKED pcapng_sec_t;
    112112
    113113typedef struct pcapng_interface_header_t {
     
    117117        uint16_t reserved;
    118118        uint32_t snaplen;
    119 } pcapng_int_t;
     119} PACKED pcapng_int_t;
    120120
    121121typedef struct pcapng_nrb_header_t {
    122122        uint32_t blocktype;
    123123        uint32_t blocklen;
    124 } pcapng_nrb_t;
     124} PACKED pcapng_nrb_t;
    125125
    126126typedef struct pcapng_enhanced_packet_t {
     
    132132        uint32_t caplen;
    133133        uint32_t wlen;
    134 } pcapng_epkt_t;
     134} PACKED pcapng_epkt_t;
    135135
    136136typedef struct pcapng_simple_packet_t {
     
    138138        uint32_t blocklen;
    139139        uint32_t wlen;
    140 } pcapng_spkt_t;
     140} PACKED pcapng_spkt_t;
    141141
    142142typedef struct pcapng_old_packet_t {
     
    149149        uint32_t caplen;
    150150        uint32_t wlen;
    151 } pcapng_opkt_t;
     151} PACKED pcapng_opkt_t;
    152152
    153153typedef struct pcapng_stats_header_t {
     
    157157        uint32_t timestamp_high;
    158158        uint32_t timestamp_low;
    159 } pcapng_stats_t;
     159} PACKED pcapng_stats_t;
    160160
    161161typedef struct pcapng_decryption_secrets_header_t {
     
    164164        uint32_t secrets_type;
    165165        uint32_t secrets_len;
    166 } pcapng_secrets_t;
     166} PACKED pcapng_secrets_t;
    167167
    168168typedef struct pcapng_custom_header_t {
     
    170170        uint32_t blocklen;
    171171        uint32_t pen;
    172 } pcapng_custom_t;
     172} PACKED pcapng_custom_t;
    173173
    174174typedef struct pcapng_interface_t pcapng_interface_t;
     
    228228        uint16_t optcode;
    229229        uint16_t optlen;
    230 };
     230} PACKED;
    231231
    232232struct pcapng_custom_optheader {
     
    234234        uint16_t optlen;
    235235        uint32_t pen;
    236 };
     236} PACKED;
    237237struct pcapng_nrb_record {
    238238        uint16_t recordtype;
    239239        uint16_t recordlen;
    240 };
     240} PACKED;
    241241struct pcapng_peeker {
    242242        uint32_t blocktype;
    243243        uint32_t blocklen;
    244 };
     244} PACKED;
    245245
    246246typedef struct pcapng_peeker pcapng_hdr_t;
Note: See TracChangeset for help on using the changeset viewer.