Changeset 4e5a51f


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.

Files:
6 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;

  • libpacketdump/link_21.c

    r4c88365 r4e5a51f  
    55
    66#include <arpa/inet.h>
     7#include <inttypes.h>
    78
    89DLLEXPORT void decode(int link_type UNUSED, const char *packet UNUSED, unsigned len UNUSED) {
    … …  
    1819                                (char *)meta->items[i].data);
    1920                } else if (meta->items[i].datatype == TRACE_META_UINT8) {
    20                         printf("   %s: %u\n",
     21                        printf("   %s: %" PRIu8 "\n",
    2122                                meta->items[i].option_name,
    2223                                *(uint8_t *)meta->items[i].data);
    2324                } else if (meta->items[i].datatype == TRACE_META_UINT32) {
    24                         printf("   %s: %u\n",
     25                        printf("   %s: %" PRIu32 "\n",
    2526                                meta->items[i].option_name,
    2627                                *(uint32_t *)meta->items[i].data);
    2728                } else if (meta->items[i].datatype == TRACE_META_UINT64) {
    28                         printf("   %s: %lu\n",
     29                        printf("   %s: %" PRIu64 "\n",
    2930                                meta->items[i].option_name,
    3031                                *(uint64_t *)meta->items[i].data);
    … …  
    4546                                mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    4647                } else {
    47                         printf("   Unknown Option ID %u (output RAW): ", meta->items[i].option);
     48                        printf("   Unknown Option ID %" PRIu16 " (output RAW): ", meta->items[i].option);
    4849                        int k;
    4950                        unsigned char *curr = (unsigned char *)meta->items[i].data;

  • libpacketdump/link_23.c

    r0486a72 r4e5a51f  
    99#include <stdlib.h>
    1010#include <string.h>
    11 
    12 #define INET4_ADDRSTRLEN 16
    13 #define INET6_ADDRSTRLEN 46
     11#include <netinet/in.h>
     12#include <inttypes.h>
    1413
    1514DLLEXPORT void decode(int link_type UNUSED,const char *packet UNUSED,unsigned len UNUSED) {
    … …  
    8180                                break;
    8281                        case(PCAPNG_META_IF_SPEED):
    83                                 printf("  if_speed: %lu\n",
     82                                printf("  if_speed: %" PRIu64 "\n",
    8483                                        *(uint64_t *)r->items[i].data);
    8584                                break;
    8685                        case(PCAPNG_META_IF_TSRESOL):
    87                                 printf("  if_tsresol: %u\n",
     86                                printf("  if_tsresol: %" PRIu8 "\n",
    8887                                        *(uint8_t *)r->items[i].data);
    8988                                break;
    … …  
    9291                                break;
    9392                        case(PCAPNG_META_IF_FILTER):
    94                                 printf("  if_filter: %u",
     93                                printf("  if_filter: %" PRIu8 "",
    9594                                        *(uint8_t *)r->items[i].data);
    9695                                printf(" %s\n",
    … …  
    102101                                break;
    103102                        case(PCAPNG_META_IF_FCSLEN):
    104                                 printf("  if_fcslen: %u\n",
     103                                printf("  if_fcslen: %" PRIu8 "\n",
    105104                                        *(uint8_t *)r->items[i].data);
    106105                                break;
    107106                        case(PCAPNG_META_IF_TSOFFSET):
    108                                 printf("  if_tsoffset: %lu\n",
     107                                printf("  if_tsoffset: %" PRIu64 "\n",
    109108                                        *(uint64_t *)r->items[i].data);
    110109                                break;
    … …  
    166165                        case(PCAPNG_META_ISB_STARTTIME):
    167166                                /* Need to split into 4 octets */
    168                                 printf("  isb_starttime: %lu\n",
     167                                printf("  isb_starttime: %" PRIu64 "\n",
    169168                                        *(uint64_t *)r->items[i].data);
    170169                                break;
    171170                        case(PCAPNG_META_ISB_ENDTIME):
    172                                 printf("  isb_endtime: %lu\n",
     171                                printf("  isb_endtime: %" PRIu64 "\n",
    173172                                        *(uint64_t *)r->items[i].data);
    174173                                break;
    175174                        case(PCAPNG_META_ISB_IFRECV):
    176                                 printf("  isb_ifrecv: %lu\n",
     175                                printf("  isb_ifrecv: %" PRIu64 "\n",
    177176                                        *(uint64_t *)r->items[i].data);
    178177                                break;
    179178                        case(PCAPNG_META_ISB_IFDROP):
    180                                 printf("  isb_ifdrop: %lu\n",
     179                                printf("  isb_ifdrop: %" PRIu64 "\n",
    181180                                        *(uint64_t *)r->items[i].data);
    182181                                break;
    183182                        case(PCAPNG_META_ISB_FILTERACCEPT):
    184                                 printf("  isb_filteraccept: %lu\n",
     183                                printf("  isb_filteraccept: %" PRIu64 "\n",
    185184                                        *(uint64_t *)r->items[i].data);
    186185                                break;
    187186                        case(PCAPNG_META_ISB_OSDROP):
    188                                 printf("  isb_osdrop: %lu\n",
     187                                printf("  isb_osdrop: %" PRIu64 "\n",
    189188                                        *(uint64_t *)r->items[i].data);
    190189                                break;
    191190                        case(PCAPNG_META_ISB_USRDELIV):
    192                                 printf("  isb_usrdeliv: %lu\n",
     191                                printf("  isb_usrdeliv: %" PRIu64 "\n",
    193192                                        *(uint64_t *)r->items[i].data);
    194193                                break;
    … …  
    207206        /* print the custom data */
    208207        for (i=0; i<r->num; i++) {
    209                 printf("  Private Enterprise Number (PEN): %u\n",
     208                printf("  Private Enterprise Number (PEN): %" PRIu32 "\n",
    210209                        *(uint32_t *)r->items[i].data);
    211210                printf("   Data: ");
Note: See TracChangeset for help on using the changeset viewer.